c8be01f6f8110d2e3eb7999443e54ef3e959d3a6
[dragonfly.git] / sys / dev / disk / ahci / ahci.c
1 /*
2  * Copyright (c) 2006 David Gwynne <dlg@openbsd.org>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  *
16  *
17  * Copyright (c) 2009 The DragonFly Project.  All rights reserved.
18  *
19  * This code is derived from software contributed to The DragonFly Project
20  * by Matthew Dillon <dillon@backplane.com>
21  *
22  * Redistribution and use in source and binary forms, with or without
23  * modification, are permitted provided that the following conditions
24  * are met:
25  *
26  * 1. Redistributions of source code must retain the above copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in
30  *    the documentation and/or other materials provided with the
31  *    distribution.
32  * 3. Neither the name of The DragonFly Project nor the names of its
33  *    contributors may be used to endorse or promote products derived
34  *    from this software without specific, prior written permission.
35  *
36  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
37  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
38  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
39  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
40  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
41  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
42  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
43  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
44  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
45  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
46  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
47  * SUCH DAMAGE.
48  *
49  * $OpenBSD: ahci.c,v 1.147 2009/02/16 21:19:07 miod Exp $
50  */
51
52 #include "ahci.h"
53
54 int     ahci_port_start(struct ahci_port *ap);
55 int     ahci_port_stop(struct ahci_port *ap, int stop_fis_rx);
56 int     ahci_port_clo(struct ahci_port *ap);
57 void    ahci_port_interrupt_enable(struct ahci_port *ap);
58
59 int     ahci_load_prdt(struct ahci_ccb *);
60 void    ahci_unload_prdt(struct ahci_ccb *);
61 static void ahci_load_prdt_callback(void *info, bus_dma_segment_t *segs,
62                                     int nsegs, int error);
63 void    ahci_start(struct ahci_ccb *);
64 int     ahci_port_softreset(struct ahci_port *ap);
65 int     ahci_port_pmprobe(struct ahci_port *ap);
66 int     ahci_port_hardreset(struct ahci_port *ap, int hard);
67 void    ahci_port_hardstop(struct ahci_port *ap);
68 void    ahci_flush_tfd(struct ahci_port *ap);
69
70 static void ahci_ata_cmd_timeout_unserialized(void *);
71 void    ahci_quick_timeout(struct ahci_ccb *ccb);
72 void    ahci_check_active_timeouts(struct ahci_port *ap);
73
74 void    ahci_beg_exclusive_access(struct ahci_port *ap, struct ata_port *at);
75 void    ahci_end_exclusive_access(struct ahci_port *ap, struct ata_port *at);
76 void    ahci_issue_pending_ncq_commands(struct ahci_port *);
77 void    ahci_issue_pending_commands(struct ahci_port *, int);
78
79 struct ahci_ccb *ahci_get_err_ccb(struct ahci_port *);
80 void    ahci_put_err_ccb(struct ahci_ccb *);
81
82 int     ahci_port_read_ncq_error(struct ahci_port *, int *);
83
84 struct ahci_dmamem *ahci_dmamem_alloc(struct ahci_softc *, bus_dma_tag_t tag);
85 void    ahci_dmamem_free(struct ahci_softc *, struct ahci_dmamem *);
86 static void ahci_dmamem_saveseg(void *info, bus_dma_segment_t *segs, int nsegs, int error);
87
88 void    ahci_empty_done(struct ahci_ccb *ccb);
89 void    ahci_ata_cmd_done(struct ahci_ccb *ccb);
90
91 /* Wait for all bits in _b to be cleared */
92 #define ahci_pwait_clr(_ap, _r, _b) \
93         ahci_pwait_eq((_ap), AHCI_PWAIT_TIMEOUT, (_r), (_b), 0)
94 #define ahci_pwait_clr_to(_ap, _to,  _r, _b) \
95         ahci_pwait_eq((_ap), _to, (_r), (_b), 0)
96
97 /* Wait for all bits in _b to be set */
98 #define ahci_pwait_set(_ap, _r, _b) \
99         ahci_pwait_eq((_ap), AHCI_PWAIT_TIMEOUT, (_r), (_b), (_b))
100 #define ahci_pwait_set_to(_ap, _to, _r, _b) \
101         ahci_pwait_eq((_ap), _to, (_r), (_b), (_b))
102
103 #define AHCI_PWAIT_TIMEOUT      1000
104
105 /*
106  * Initialize the global AHCI hardware.  This code does not set up any of
107  * its ports.
108  */
109 int
110 ahci_init(struct ahci_softc *sc)
111 {
112         u_int32_t       cap, pi;
113         int             i;
114         struct ahci_port *ap;
115
116         DPRINTF(AHCI_D_VERBOSE, " GHC 0x%b",
117                 ahci_read(sc, AHCI_REG_GHC), AHCI_FMT_GHC);
118
119         /* save BIOS initialised parameters, enable staggered spin up */
120         cap = ahci_read(sc, AHCI_REG_CAP);
121         cap &= AHCI_REG_CAP_SMPS;
122         cap |= AHCI_REG_CAP_SSS;
123         pi = ahci_read(sc, AHCI_REG_PI);
124
125 #if 1
126         /*
127          * This is a hack that currently does not appear to have
128          * a significant effect, but I noticed the port registers
129          * do not appear to be completely cleared after the host
130          * controller is reset.
131          */
132         ap = kmalloc(sizeof(*ap), M_DEVBUF, M_WAITOK | M_ZERO);
133         ap->ap_sc = sc;
134         for (i = 0; i < AHCI_MAX_PMPORTS; ++i) {
135                 if ((pi & (1 << i)) == 0)
136                         continue;
137                 if (bus_space_subregion(sc->sc_iot, sc->sc_ioh,
138                     AHCI_PORT_REGION(i), AHCI_PORT_SIZE, &ap->ap_ioh) != 0) {
139                         device_printf(sc->sc_dev, "can't map port\n");
140                         return (1);
141                 }
142                 ahci_pwrite(ap, AHCI_PREG_SCTL, AHCI_PREG_SCTL_IPM_DISABLED |
143                                                 AHCI_PREG_SCTL_DET_DISABLE);
144                 ahci_pwrite(ap, AHCI_PREG_SERR, -1);
145                 ahci_pwrite(ap, AHCI_PREG_IE, 0);
146                 ahci_pwrite(ap, AHCI_PREG_CMD, 0);
147                 ahci_pwrite(ap, AHCI_PREG_IS, 0);
148         }
149         kfree(ap, M_DEVBUF);
150 #endif
151
152         /*
153          * Unconditionally reset the controller, do not conditionalize on
154          * trying to figure it if it was previously active or not.
155          *
156          * NOTE BRICKS (1)
157          *
158          *      If you have a port multiplier and it does not have a device
159          *      in target 0, and it probes normally, but a later operation
160          *      mis-probes a target behind that PM, it is possible for the
161          *      port to brick such that only (a) a power cycle of the host
162          *      or (b) placing a device in target 0 will fix the problem.
163          *      Power cycling the PM has no effect (it works fine on another
164          *      host port).  This issue is unrelated to CLO.
165          */
166         ahci_write(sc, AHCI_REG_GHC, AHCI_REG_GHC_HR);
167         if (ahci_wait_ne(sc, AHCI_REG_GHC,
168                          AHCI_REG_GHC_HR, AHCI_REG_GHC_HR) != 0) {
169                 device_printf(sc->sc_dev,
170                               "unable to reset controller\n");
171                 return (1);
172         }
173         ahci_os_sleep(100);
174
175         /* enable ahci (global interrupts disabled) */
176         ahci_write(sc, AHCI_REG_GHC, AHCI_REG_GHC_AE);
177
178         /* restore parameters */
179         ahci_write(sc, AHCI_REG_CAP, cap);
180         ahci_write(sc, AHCI_REG_PI, pi);
181
182         return (0);
183 }
184
185 /*
186  * Allocate and initialize an AHCI port.
187  */
188 int
189 ahci_port_alloc(struct ahci_softc *sc, u_int port)
190 {
191         struct ahci_port        *ap;
192         struct ata_port         *at;
193         struct ahci_ccb         *ccb;
194         u_int64_t               dva;
195         u_int32_t               cmd;
196         struct ahci_cmd_hdr     *hdr;
197         struct ahci_cmd_table   *table;
198         int     rc = ENOMEM;
199         int     error;
200         int     i;
201
202         ap = kmalloc(sizeof(*ap), M_DEVBUF, M_WAITOK | M_ZERO);
203
204         ksnprintf(ap->ap_name, sizeof(ap->ap_name), "%s%d.%d",
205                   device_get_name(sc->sc_dev),
206                   device_get_unit(sc->sc_dev),
207                   port);
208         sc->sc_ports[port] = ap;
209
210         /*
211          * Allocate enough so we never have to reallocate, it makes
212          * it easier.
213          *
214          * ap_pmcount will be reduced by the scan if we encounter the
215          * port multiplier port prior to target 15.
216          */
217         if (ap->ap_ata == NULL) {
218                 ap->ap_ata = kmalloc(sizeof(*ap->ap_ata) * AHCI_MAX_PMPORTS,
219                                      M_DEVBUF, M_INTWAIT | M_ZERO);
220                 for (i = 0; i < AHCI_MAX_PMPORTS; ++i) {
221                         at = &ap->ap_ata[i];
222                         at->at_ahci_port = ap;
223                         at->at_target = i;
224                         at->at_probe = ATA_PROBE_NEED_INIT;
225                         at->at_features |= ATA_PORT_F_RESCAN;
226                         ksnprintf(at->at_name, sizeof(at->at_name),
227                                   "%s.%d", ap->ap_name, i);
228                 }
229         }
230         if (bus_space_subregion(sc->sc_iot, sc->sc_ioh,
231             AHCI_PORT_REGION(port), AHCI_PORT_SIZE, &ap->ap_ioh) != 0) {
232                 device_printf(sc->sc_dev,
233                               "unable to create register window for port %d\n",
234                               port);
235                 goto freeport;
236         }
237
238         ap->ap_sc = sc;
239         ap->ap_num = port;
240         ap->ap_probe = ATA_PROBE_NEED_INIT;
241         TAILQ_INIT(&ap->ap_ccb_free);
242         TAILQ_INIT(&ap->ap_ccb_pending);
243         lockinit(&ap->ap_ccb_lock, "ahcipo", 0, 0);
244
245         /* Disable port interrupts */
246         ahci_pwrite(ap, AHCI_PREG_IE, 0);
247         ahci_pwrite(ap, AHCI_PREG_SERR, -1);
248
249         /*
250          * Sec 10.1.2 - deinitialise port if it is already running
251          */
252         cmd = ahci_pread(ap, AHCI_PREG_CMD);
253         if ((cmd & (AHCI_PREG_CMD_ST | AHCI_PREG_CMD_CR |
254                     AHCI_PREG_CMD_FRE | AHCI_PREG_CMD_FR)) ||
255             (ahci_pread(ap, AHCI_PREG_SCTL) & AHCI_PREG_SCTL_DET)) {
256                 int r;
257
258                 r = ahci_port_stop(ap, 1);
259                 if (r) {
260                         device_printf(sc->sc_dev,
261                                   "unable to disable %s, ignoring port %d\n",
262                                   ((r == 2) ? "CR" : "FR"), port);
263                         rc = ENXIO;
264                         goto freeport;
265                 }
266
267                 /* Write DET to zero */
268                 ahci_pwrite(ap, AHCI_PREG_SCTL, AHCI_PREG_SCTL_IPM_DISABLED);
269         }
270
271         /* Allocate RFIS */
272         ap->ap_dmamem_rfis = ahci_dmamem_alloc(sc, sc->sc_tag_rfis);
273         if (ap->ap_dmamem_rfis == NULL) {
274                 kprintf("%s: NORFIS\n", PORTNAME(ap));
275                 goto nomem;
276         }
277
278         /* Setup RFIS base address */
279         ap->ap_rfis = (struct ahci_rfis *) AHCI_DMA_KVA(ap->ap_dmamem_rfis);
280         dva = AHCI_DMA_DVA(ap->ap_dmamem_rfis);
281         ahci_pwrite(ap, AHCI_PREG_FBU, (u_int32_t)(dva >> 32));
282         ahci_pwrite(ap, AHCI_PREG_FB, (u_int32_t)dva);
283
284         /* Clear SERR before starting FIS reception or ST or anything */
285         ahci_flush_tfd(ap);
286         ahci_pwrite(ap, AHCI_PREG_SERR, -1);
287
288         /* Enable FIS reception and activate port. */
289         cmd = ahci_pread(ap, AHCI_PREG_CMD) & ~AHCI_PREG_CMD_ICC;
290         cmd &= ~(AHCI_PREG_CMD_CLO | AHCI_PREG_CMD_PMA);
291         cmd |= AHCI_PREG_CMD_FRE | AHCI_PREG_CMD_POD | AHCI_PREG_CMD_SUD;
292         ahci_pwrite(ap, AHCI_PREG_CMD, cmd | AHCI_PREG_CMD_ICC_ACTIVE);
293
294         /* Check whether port activated.  Skip it if not. */
295         cmd = ahci_pread(ap, AHCI_PREG_CMD) & ~AHCI_PREG_CMD_ICC;
296         if ((cmd & AHCI_PREG_CMD_FRE) == 0) {
297                 kprintf("%s: NOT-ACTIVATED\n", PORTNAME(ap));
298                 rc = ENXIO;
299                 goto freeport;
300         }
301
302         /* Allocate a CCB for each command slot */
303         ap->ap_ccbs = kmalloc(sizeof(struct ahci_ccb) * sc->sc_ncmds, M_DEVBUF,
304                               M_WAITOK | M_ZERO);
305         if (ap->ap_ccbs == NULL) {
306                 device_printf(sc->sc_dev,
307                               "unable to allocate command list for port %d\n",
308                               port);
309                 goto freeport;
310         }
311
312         /* Command List Structures and Command Tables */
313         ap->ap_dmamem_cmd_list = ahci_dmamem_alloc(sc, sc->sc_tag_cmdh);
314         ap->ap_dmamem_cmd_table = ahci_dmamem_alloc(sc, sc->sc_tag_cmdt);
315         if (ap->ap_dmamem_cmd_table == NULL ||
316             ap->ap_dmamem_cmd_list == NULL) {
317 nomem:
318                 device_printf(sc->sc_dev,
319                               "unable to allocate DMA memory for port %d\n",
320                               port);
321                 goto freeport;
322         }
323
324         /* Setup command list base address */
325         dva = AHCI_DMA_DVA(ap->ap_dmamem_cmd_list);
326         ahci_pwrite(ap, AHCI_PREG_CLBU, (u_int32_t)(dva >> 32));
327         ahci_pwrite(ap, AHCI_PREG_CLB, (u_int32_t)dva);
328
329         /* Split CCB allocation into CCBs and assign to command header/table */
330         hdr = AHCI_DMA_KVA(ap->ap_dmamem_cmd_list);
331         table = AHCI_DMA_KVA(ap->ap_dmamem_cmd_table);
332         for (i = 0; i < sc->sc_ncmds; i++) {
333                 ccb = &ap->ap_ccbs[i];
334
335                 error = bus_dmamap_create(sc->sc_tag_data, BUS_DMA_ALLOCNOW,
336                                           &ccb->ccb_dmamap);
337                 if (error) {
338                         device_printf(sc->sc_dev,
339                                       "unable to create dmamap for port %d "
340                                       "ccb %d\n", port, i);
341                         goto freeport;
342                 }
343
344                 callout_init(&ccb->ccb_timeout);
345                 ccb->ccb_slot = i;
346                 ccb->ccb_port = ap;
347                 ccb->ccb_cmd_hdr = &hdr[i];
348                 ccb->ccb_cmd_table = &table[i];
349                 dva = AHCI_DMA_DVA(ap->ap_dmamem_cmd_table) +
350                     ccb->ccb_slot * sizeof(struct ahci_cmd_table);
351                 ccb->ccb_cmd_hdr->ctba_hi = htole32((u_int32_t)(dva >> 32));
352                 ccb->ccb_cmd_hdr->ctba_lo = htole32((u_int32_t)dva);
353
354                 ccb->ccb_xa.fis =
355                     (struct ata_fis_h2d *)ccb->ccb_cmd_table->cfis;
356                 ccb->ccb_xa.packetcmd = ccb->ccb_cmd_table->acmd;
357                 ccb->ccb_xa.tag = i;
358
359                 ccb->ccb_xa.state = ATA_S_COMPLETE;
360
361                 /*
362                  * CCB[1] is the error CCB and is not get or put.  It is
363                  * also used for probing.  Numerous HBAs only load the
364                  * signature from CCB[1] so it MUST be used for the second
365                  * FIS.
366                  */
367                 if (i == 1)
368                         ap->ap_err_ccb = ccb;
369                 else
370                         ahci_put_ccb(ccb);
371         }
372
373         /* Wait for ICC change to complete */
374         ahci_pwait_clr(ap, AHCI_PREG_CMD, AHCI_PREG_CMD_ICC);
375
376         /*
377          * Start the port.  The helper thread will call ahci_port_init()
378          * so the ports can all be started in parallel.  A failure by
379          * ahci_port_init() does not deallocate the port since we still
380          * want hot-plug events.
381          */
382         ahci_os_start_port(ap);
383         return(0);
384 freeport:
385         ahci_port_free(sc, port);
386         return (rc);
387 }
388
389 /*
390  * [re]initialize an idle port.  No CCBs should be active.
391  *
392  * If at is NULL we are initializing a directly connected port, otherwise
393  * we are indirectly initializing a port multiplier port.
394  *
395  * This function is called during the initial port allocation sequence
396  * and is also called on hot-plug insertion.  We take no chances and
397  * use a portreset instead of a softreset.
398  *
399  * This function is the only way to move a failed port back to active
400  * status.
401  *
402  * Returns 0 if a device is successfully detected.
403  */
404 int
405 ahci_port_init(struct ahci_port *ap, struct ata_port *atx)
406 {
407         u_int32_t data;
408         int rc;
409
410         /*
411          * Clear all notification bits
412          */
413         if (atx == NULL && (ap->ap_sc->sc_cap & AHCI_REG_CAP_SSNTF))
414                 ahci_pwrite(ap, AHCI_PREG_SNTF, -1);
415
416         /*
417          * Hard-reset the port.  If a device is detected but it is busy
418          * we try a second time, this time cycling the phy as well.
419          *
420          * XXX note: hard reset mode 2 (cycling the PHY) is not reliable.
421          */
422         if (atx)
423                 atx->at_probe = ATA_PROBE_NEED_HARD_RESET;
424         else
425                 ap->ap_probe = ATA_PROBE_NEED_HARD_RESET;
426
427         rc = ahci_port_reset(ap, atx, 1);
428 #if 0
429         rc = ahci_port_reset(ap, atx, 1);
430         if (rc == EBUSY) {
431                 rc = ahci_port_reset(ap, atx, 2);
432         }
433 #endif
434
435         switch (rc) {
436         case ENODEV:
437                 /*
438                  * We had problems talking to the device on the port.
439                  */
440                 if (atx) {
441                         ahci_pm_read(ap, atx->at_target,
442                                      AHCI_PMREG_SSTS, &data);
443                 } else {
444                         data = ahci_pread(ap, AHCI_PREG_SSTS);
445                 }
446
447                 switch(data & AHCI_PREG_SSTS_DET) {
448                 case AHCI_PREG_SSTS_DET_DEV_NE:
449                         kprintf("%s: Device not communicating\n",
450                                 ATANAME(ap, atx));
451                         break;
452                 case AHCI_PREG_SSTS_DET_PHYOFFLINE:
453                         kprintf("%s: PHY offline\n",
454                                 ATANAME(ap, atx));
455                         break;
456                 default:
457                         kprintf("%s: No device detected\n",
458                                 ATANAME(ap, atx));
459                         break;
460                 }
461                 break;
462
463         case EBUSY:
464                 /*
465                  * The device on the port is still telling us its busy,
466                  * which means that it is not properly handling a SATA
467                  * port COMRESET.
468                  *
469                  * It may be possible to softreset the device using CLO
470                  * and a device reset command.
471                  */
472                 if (atx) {
473                         kprintf("%s: Device on port is bricked, giving up\n",
474                                 ATANAME(ap, atx));
475                 } else {
476                         kprintf("%s: Device on port is bricked, "
477                                 "trying softreset\n", PORTNAME(ap));
478
479                         rc = ahci_port_reset(ap, atx, 0);
480                         if (rc) {
481                                 kprintf("%s: Unable unbrick device\n",
482                                         PORTNAME(ap));
483                         } else {
484                                 kprintf("%s: Successfully unbricked\n",
485                                         PORTNAME(ap));
486                         }
487                 }
488                 break;
489
490         default:
491                 break;
492         }
493
494         /*
495          * Command transfers can only be enabled if a device was successfully
496          * detected.
497          *
498          * Allocate or deallocate the ap_ata array here too.
499          */
500         if (atx == NULL) {
501                 switch(ap->ap_type) {
502                 case ATA_PORT_T_NONE:
503                         ap->ap_pmcount = 0;
504                         break;
505                 case ATA_PORT_T_PM:
506                         /* already set */
507                         break;
508                 default:
509                         ap->ap_pmcount = 1;
510                         break;
511                 }
512         }
513
514         /*
515          * Start the port if we succeeded.
516          *
517          * There's nothing to start for devices behind a port multiplier.
518          */
519         if (rc == 0 && atx == NULL) {
520                 if (ahci_port_start(ap)) {
521                         kprintf("%s: failed to start command DMA on port, "
522                                 "disabling\n", PORTNAME(ap));
523                         rc = ENXIO;     /* couldn't start port */
524                 }
525         }
526
527         /*
528          * Flush interrupts on the port. XXX
529          *
530          * Enable interrupts on the port whether a device is sitting on
531          * it or not, to handle hot-plug events.
532          */
533         if (atx == NULL) {
534                 ahci_pwrite(ap, AHCI_PREG_IS, ahci_pread(ap, AHCI_PREG_IS));
535                 ahci_write(ap->ap_sc, AHCI_REG_IS, 1 << ap->ap_num);
536
537                 ahci_port_interrupt_enable(ap);
538         }
539         return(rc);
540 }
541
542 /*
543  * Enable or re-enable interrupts on a port.
544  *
545  * This routine is called from the port initialization code or from the
546  * helper thread as the real interrupt may be forced to turn off certain
547  * interrupt sources.
548  */
549 void
550 ahci_port_interrupt_enable(struct ahci_port *ap)
551 {
552         u_int32_t data;
553
554         data = AHCI_PREG_IE_TFEE | AHCI_PREG_IE_HBFE |
555                AHCI_PREG_IE_IFE | AHCI_PREG_IE_OFE |
556                AHCI_PREG_IE_DPE | AHCI_PREG_IE_UFE |
557                AHCI_PREG_IE_PCE | AHCI_PREG_IE_PRCE |
558                AHCI_PREG_IE_DHRE;
559         if (ap->ap_sc->sc_cap & AHCI_REG_CAP_SSNTF)
560                 data |= AHCI_PREG_IE_SDBE;
561 #ifdef AHCI_COALESCE
562         if (sc->sc_ccc_ports & (1 << port)
563                 data &= ~(AHCI_PREG_IE_SDBE | AHCI_PREG_IE_DHRE);
564 #endif
565         ahci_pwrite(ap, AHCI_PREG_IE, data);
566 }
567
568 /*
569  * Run the port / target state machine from a main context.
570  *
571  * The state machine for the port is always run.
572  *
573  * If atx is non-NULL run the state machine for a particular target.
574  * If atx is NULL run the state machine for all targets.
575  */
576 void
577 ahci_port_state_machine(struct ahci_port *ap, int initial)
578 {
579         struct ata_port *at;
580         u_int32_t data;
581         int target;
582         int didsleep;
583         int loop;
584
585         /*
586          * State machine for port.  Note that CAM is not yet associated
587          * during the initial parallel probe and the port's probe state
588          * will not get past ATA_PROBE_NEED_IDENT.
589          */
590         if (ap->ap_type == ATA_PORT_T_NONE) {
591                 if (initial == 0 && ap->ap_probe <= ATA_PROBE_NEED_HARD_RESET) {
592                         kprintf("%s: Waiting 10 seconds on insertion\n",
593                                 PORTNAME(ap));
594                         ahci_os_sleep(10000);
595                         initial = 1;
596                 }
597                 if (ap->ap_probe == ATA_PROBE_NEED_INIT)
598                         ahci_port_init(ap, NULL);
599                 if (ap->ap_probe == ATA_PROBE_NEED_HARD_RESET)
600                         ahci_port_reset(ap, NULL, 1);
601                 if (ap->ap_probe == ATA_PROBE_NEED_SOFT_RESET)
602                         ahci_port_reset(ap, NULL, 0);
603                 if (ap->ap_probe == ATA_PROBE_NEED_IDENT)
604                         ahci_cam_probe(ap, NULL);
605         }
606         if (ap->ap_type != ATA_PORT_T_PM) {
607                 if (ap->ap_probe == ATA_PROBE_FAILED) {
608                         ahci_cam_changed(ap, NULL, 0);
609                 } else if (ap->ap_probe >= ATA_PROBE_NEED_IDENT) {
610                         ahci_cam_changed(ap, NULL, 1);
611                 }
612                 return;
613         }
614
615         /*
616          * Port Multiplier state machine.
617          *
618          * Get a mask of changed targets and combine with any runnable
619          * states already present.
620          */
621         for (loop = 0; ;++loop) {
622                 if (ahci_pm_read(ap, 15, AHCI_PMREG_EINFO, &data)) {
623                         kprintf("%s: PM unable to read hot-plug bitmap\n",
624                                 PORTNAME(ap));
625                         break;
626                 }
627                 data &= (1 << ap->ap_pmcount) - 1;
628
629                 /*
630                  * Do at least one loop, then stop if no more state changes
631                  * have occured.  The PM might not generate a new
632                  * notification until we clear the entire bitmap.
633                  */
634                 if (loop && data == 0)
635                         break;
636
637                 /*
638                  * New devices showing up in the bitmap require some spin-up
639                  * time before we start probing them.  Reset didsleep.  The
640                  * first new device we detect will sleep before probing.
641                  *
642                  * This only applies to devices whos change bit is set in
643                  * the data, and does not apply to the initial boot-time
644                  * probe.
645                  */
646                 didsleep = 0;
647
648                 for (target = 0; target < ap->ap_pmcount; ++target) {
649                         at = &ap->ap_ata[target];
650
651                         /*
652                          * Check the target state for targets behind the PM
653                          * which have changed state.  This will adjust
654                          * at_probe and set ATA_PORT_F_RESCAN
655                          *
656                          * We want to wait at least 10 seconds before probing
657                          * a newly inserted device.  If the check status
658                          * indicates a device is present and in need of a
659                          * hard reset, we make sure we have slept before
660                          * continuing.
661                          *
662                          * We also need to wait at least 1 second for the
663                          * PHY state to change after insertion, if we
664                          * haven't already waited the 10 seconds.
665                          *
666                          * NOTE: When pm_check_good finds a good port it
667                          *       typically starts us in probe state
668                          *       NEED_HARD_RESET rather than INIT.
669                          */
670                         if (data & (1 << target)) {
671                                 if (initial == 0 && didsleep == 0)
672                                         ahci_os_sleep(1000);
673                                 ahci_pm_check_good(ap, target);
674                                 if (initial == 0 && didsleep == 0 &&
675                                     at->at_probe <= ATA_PROBE_NEED_HARD_RESET
676                                 ) {
677                                         didsleep = 1;
678                                         kprintf("%s: Waiting 10 seconds on insertion\n", PORTNAME(ap));
679                                         ahci_os_sleep(10000);
680                                 }
681                         }
682
683                         /*
684                          * Report hot-plug events before the probe state
685                          * really gets hot.  Only actual events are reported
686                          * here to reduce spew.
687                          */
688                         if (data & (1 << target)) {
689                                 kprintf("%s: HOTPLUG (PM) - ", ATANAME(ap, at));
690                                 switch(at->at_probe) {
691                                 case ATA_PROBE_NEED_INIT:
692                                 case ATA_PROBE_NEED_HARD_RESET:
693                                         kprintf("Device inserted\n");
694                                         break;
695                                 case ATA_PROBE_FAILED:
696                                         kprintf("Device removed\n");
697                                         break;
698                                 default:
699                                         kprintf("Device probe in progress\n");
700                                         break;
701                                 }
702                         }
703
704                         /*
705                          * Run through the state machine as necessary if
706                          * the port is not marked failed.
707                          *
708                          * The state machine may stop at NEED_IDENT if
709                          * CAM is not yet attached.
710                          *
711                          * Acquire exclusive access to the port while we
712                          * are doing this.  This prevents command-completion
713                          * from queueing commands for non-polled targets
714                          * inbetween our probe steps.  We need to do this
715                          * because the reset probes can generate severe PHY
716                          * and protocol errors and soft-brick the port.
717                          */
718                         if (at->at_probe != ATA_PROBE_FAILED &&
719                             at->at_probe != ATA_PROBE_GOOD) {
720                                 ahci_beg_exclusive_access(ap, at);
721                                 if (at->at_probe == ATA_PROBE_NEED_INIT)
722                                         ahci_port_init(ap, at);
723                                 if (at->at_probe == ATA_PROBE_NEED_HARD_RESET)
724                                         ahci_port_reset(ap, at, 1);
725                                 if (at->at_probe == ATA_PROBE_NEED_SOFT_RESET)
726                                         ahci_port_reset(ap, at, 0);
727                                 if (at->at_probe == ATA_PROBE_NEED_IDENT)
728                                         ahci_cam_probe(ap, at);
729                                 ahci_end_exclusive_access(ap, at);
730                         }
731
732                         /*
733                          * Add or remove from CAM
734                          */
735                         if (at->at_features & ATA_PORT_F_RESCAN) {
736                                 at->at_features &= ~ATA_PORT_F_RESCAN;
737                                 if (at->at_probe == ATA_PROBE_FAILED) {
738                                         ahci_cam_changed(ap, at, 0);
739                                 } else if (at->at_probe >= ATA_PROBE_NEED_IDENT) {
740                                         ahci_cam_changed(ap, at, 1);
741                                 }
742                         }
743                 }
744         }
745 }
746
747
748 /*
749  * De-initialize and detach a port.
750  */
751 void
752 ahci_port_free(struct ahci_softc *sc, u_int port)
753 {
754         struct ahci_port                *ap = sc->sc_ports[port];
755         struct ahci_ccb                 *ccb;
756
757         /*
758          * Ensure port is disabled and its interrupts are all flushed.
759          */
760         if (ap->ap_sc) {
761                 ahci_port_stop(ap, 1);
762                 ahci_os_stop_port(ap);
763                 ahci_pwrite(ap, AHCI_PREG_CMD, 0);
764                 ahci_pwrite(ap, AHCI_PREG_IE, 0);
765                 ahci_pwrite(ap, AHCI_PREG_IS, ahci_pread(ap, AHCI_PREG_IS));
766                 ahci_write(sc, AHCI_REG_IS, 1 << port);
767         }
768
769         if (ap->ap_ccbs) {
770                 while ((ccb = ahci_get_ccb(ap)) != NULL) {
771                         if (ccb->ccb_dmamap) {
772                                 bus_dmamap_destroy(sc->sc_tag_data,
773                                                    ccb->ccb_dmamap);
774                                 ccb->ccb_dmamap = NULL;
775                         }
776                 }
777                 if ((ccb = ap->ap_err_ccb) != NULL) {
778                         if (ccb->ccb_dmamap) {
779                                 bus_dmamap_destroy(sc->sc_tag_data,
780                                                    ccb->ccb_dmamap);
781                                 ccb->ccb_dmamap = NULL;
782                         }
783                         ap->ap_err_ccb = NULL;
784                 }
785                 kfree(ap->ap_ccbs, M_DEVBUF);
786                 ap->ap_ccbs = NULL;
787         }
788
789         if (ap->ap_dmamem_cmd_list) {
790                 ahci_dmamem_free(sc, ap->ap_dmamem_cmd_list);
791                 ap->ap_dmamem_cmd_list = NULL;
792         }
793         if (ap->ap_dmamem_rfis) {
794                 ahci_dmamem_free(sc, ap->ap_dmamem_rfis);
795                 ap->ap_dmamem_rfis = NULL;
796         }
797         if (ap->ap_dmamem_cmd_table) {
798                 ahci_dmamem_free(sc, ap->ap_dmamem_cmd_table);
799                 ap->ap_dmamem_cmd_table = NULL;
800         }
801         if (ap->ap_ata) {
802                 kfree(ap->ap_ata, M_DEVBUF);
803                 ap->ap_ata = NULL;
804         }
805
806         /* bus_space(9) says we dont free the subregions handle */
807
808         kfree(ap, M_DEVBUF);
809         sc->sc_ports[port] = NULL;
810 }
811
812 /*
813  * Start high-level command processing on the port
814  */
815 int
816 ahci_port_start(struct ahci_port *ap)
817 {
818         u_int32_t       r, oldr, s, olds, is, oldis, tfd, oldtfd;
819
820         /*
821          * FRE must be turned on before ST.  Wait for FR to go active
822          * before turning on ST.  The spec doesn't seem to think this
823          * is necessary but waiting here avoids an on-off race in the
824          * ahci_port_stop() code.
825          */
826          /* XXX REMOVE ME */
827         olds = ahci_pread(ap, AHCI_PREG_SERR);
828         oldis= ahci_pread(ap, AHCI_PREG_IS);
829         oldtfd = ahci_pread(ap, AHCI_PREG_TFD);
830         oldr = r = ahci_pread(ap, AHCI_PREG_CMD) & ~AHCI_PREG_CMD_ICC;
831         if ((r & AHCI_PREG_CMD_FRE) == 0) {
832                 r |= AHCI_PREG_CMD_FRE;
833                 ahci_pwrite(ap, AHCI_PREG_CMD, r);
834         }
835         if ((ap->ap_sc->sc_flags & AHCI_F_IGN_FR) == 0) {
836                 if (ahci_pwait_set(ap, AHCI_PREG_CMD, AHCI_PREG_CMD_FR)) {
837                         kprintf("%s: Cannot start FIS reception\n",
838                                 PORTNAME(ap));
839                         return (2);
840                 }
841         }
842
843         /*
844          * Turn on ST, wait for CR to come up.
845          */
846         r |= AHCI_PREG_CMD_ST;
847         ahci_pwrite(ap, AHCI_PREG_CMD, r);
848         if (ahci_pwait_set(ap, AHCI_PREG_CMD, AHCI_PREG_CMD_CR)) {
849                 s = ahci_pread(ap, AHCI_PREG_SERR);
850                 is = ahci_pread(ap, AHCI_PREG_IS);
851                 tfd = ahci_pread(ap, AHCI_PREG_TFD);
852                 kprintf("%s: Cannot start command DMA\n"
853                         "OCMD=%b OSERR=%b\n"
854                         "NCMP=%b NSERR=%b\n"
855                         "OLDIS=%b\nNEWIS=%b\n"
856                         "OLDTFD=%b\nNEWTFD=%b\n",
857                         PORTNAME(ap),
858                         oldr, AHCI_PFMT_CMD, olds, AHCI_PFMT_SERR,
859                         r, AHCI_PFMT_CMD, s, AHCI_PFMT_SERR,
860                         oldis, AHCI_PFMT_IS, is, AHCI_PFMT_IS,
861                         oldtfd, AHCI_PFMT_TFD_STS, tfd, AHCI_PFMT_TFD_STS);
862                 return (1);
863         }
864
865 #ifdef AHCI_COALESCE
866         /*
867          * (Re-)enable coalescing on the port.
868          */
869         if (ap->ap_sc->sc_ccc_ports & (1 << ap->ap_num)) {
870                 ap->ap_sc->sc_ccc_ports_cur |= (1 << ap->ap_num);
871                 ahci_write(ap->ap_sc, AHCI_REG_CCC_PORTS,
872                     ap->ap_sc->sc_ccc_ports_cur);
873         }
874 #endif
875
876         return (0);
877 }
878
879 /*
880  * Stop high-level command processing on a port
881  */
882 int
883 ahci_port_stop(struct ahci_port *ap, int stop_fis_rx)
884 {
885         u_int32_t                       r;
886
887 #ifdef AHCI_COALESCE
888         /*
889          * Disable coalescing on the port while it is stopped.
890          */
891         if (ap->ap_sc->sc_ccc_ports & (1 << ap->ap_num)) {
892                 ap->ap_sc->sc_ccc_ports_cur &= ~(1 << ap->ap_num);
893                 ahci_write(ap->ap_sc, AHCI_REG_CCC_PORTS,
894                     ap->ap_sc->sc_ccc_ports_cur);
895         }
896 #endif
897
898         /*
899          * Turn off ST, then wait for CR to go off.
900          */
901         r = ahci_pread(ap, AHCI_PREG_CMD) & ~AHCI_PREG_CMD_ICC;
902         r &= ~AHCI_PREG_CMD_ST;
903         ahci_pwrite(ap, AHCI_PREG_CMD, r);
904
905         if (ahci_pwait_clr(ap, AHCI_PREG_CMD, AHCI_PREG_CMD_CR)) {
906                 kprintf("%s: Port bricked, unable to stop (ST)\n",
907                         PORTNAME(ap));
908                 return (1);
909         }
910
911 #if 0
912         /*
913          * Turn off FRE, then wait for FR to go off.  FRE cannot
914          * be turned off until CR transitions to 0.
915          */
916         if ((r & AHCI_PREG_CMD_FR) == 0) {
917                 kprintf("%s: FR stopped, clear FRE for next start\n",
918                         PORTNAME(ap));
919                 stop_fis_rx = 2;
920         }
921 #endif
922         if (stop_fis_rx) {
923                 r &= ~AHCI_PREG_CMD_FRE;
924                 ahci_pwrite(ap, AHCI_PREG_CMD, r);
925                 if (ahci_pwait_clr(ap, AHCI_PREG_CMD, AHCI_PREG_CMD_FR)) {
926                         kprintf("%s: Port bricked, unable to stop (FRE)\n",
927                                 PORTNAME(ap));
928                         return (2);
929                 }
930         }
931
932         return (0);
933 }
934
935 /*
936  * AHCI command list override -> forcibly clear TFD.STS.{BSY,DRQ}
937  */
938 int
939 ahci_port_clo(struct ahci_port *ap)
940 {
941         struct ahci_softc               *sc = ap->ap_sc;
942         u_int32_t                       cmd;
943
944         /* Only attempt CLO if supported by controller */
945         if ((ahci_read(sc, AHCI_REG_CAP) & AHCI_REG_CAP_SCLO) == 0)
946                 return (1);
947
948         /* Issue CLO */
949         cmd = ahci_pread(ap, AHCI_PREG_CMD) & ~AHCI_PREG_CMD_ICC;
950 #ifdef DIAGNOSTIC
951         if (cmd & AHCI_PREG_CMD_ST) {
952                 kprintf("%s: CLO requested while port running\n",
953                         PORTNAME(ap));
954         }
955 #endif
956         ahci_pwrite(ap, AHCI_PREG_CMD, cmd | AHCI_PREG_CMD_CLO);
957
958         /* Wait for completion */
959         if (ahci_pwait_clr(ap, AHCI_PREG_CMD, AHCI_PREG_CMD_CLO)) {
960                 kprintf("%s: CLO did not complete\n", PORTNAME(ap));
961                 return (1);
962         }
963
964         return (0);
965 }
966
967 /*
968  * Reset a port.
969  *
970  * If hard is 0 perform a softreset of the port.
971  * If hard is 1 perform a hard reset of the port.
972  * If hard is 2 perform a hard reset of the port and cycle the phy.
973  *
974  * If at is non-NULL an indirect port via a port-multiplier is being
975  * reset, otherwise a direct port is being reset.
976  *
977  * NOTE: Indirect ports can only be soft-reset.
978  */
979 int
980 ahci_port_reset(struct ahci_port *ap, struct ata_port *at, int hard)
981 {
982         int rc;
983
984         if (hard) {
985                 if (at)
986                         rc = ahci_pm_hardreset(ap, at->at_target, hard);
987                 else
988                         rc = ahci_port_hardreset(ap, hard);
989         } else {
990                 if (at)
991                         rc = ahci_pm_softreset(ap, at->at_target);
992                 else
993                         rc = ahci_port_softreset(ap);
994         }
995         return(rc);
996 }
997
998 /*
999  * AHCI soft reset, Section 10.4.1
1000  *
1001  * (at) will be NULL when soft-resetting a directly-attached device, and
1002  * non-NULL when soft-resetting a device through a port multiplier.
1003  *
1004  * This function keeps port communications intact and attempts to generate
1005  * a reset to the connected device using device commands.
1006  */
1007 int
1008 ahci_port_softreset(struct ahci_port *ap)
1009 {
1010         struct ahci_ccb         *ccb = NULL;
1011         struct ahci_cmd_hdr     *cmd_slot;
1012         u_int8_t                *fis;
1013         int                     error;
1014         u_int32_t               cmd;
1015
1016         error = EIO;
1017
1018         kprintf("%s: START SOFTRESET %b\n", PORTNAME(ap),
1019                 ahci_pread(ap, AHCI_PREG_CMD), AHCI_PFMT_CMD);
1020
1021         DPRINTF(AHCI_D_VERBOSE, "%s: soft reset\n", PORTNAME(ap));
1022
1023         crit_enter();
1024         ap->ap_flags |= AP_F_IN_RESET;
1025         ap->ap_state = AP_S_NORMAL;
1026
1027         /*
1028          * Remember port state in cmd (main to restore start/stop)
1029          *
1030          * Idle port.
1031          */
1032         cmd = ahci_pread(ap, AHCI_PREG_CMD) & ~AHCI_PREG_CMD_ICC;
1033         if (ahci_port_stop(ap, 0)) {
1034                 kprintf("%s: failed to stop port, cannot softreset\n",
1035                         PORTNAME(ap));
1036                 goto err;
1037         }
1038
1039         /*
1040          * Request CLO if device appears hung.
1041          */
1042         if (ahci_pread(ap, AHCI_PREG_TFD) &
1043                    (AHCI_PREG_TFD_STS_BSY | AHCI_PREG_TFD_STS_DRQ)) {
1044                 ahci_port_clo(ap);
1045         }
1046
1047         /*
1048          * This is an attempt to clear errors so a new signature will
1049          * be latched.  It isn't working properly.  XXX
1050          */
1051         ahci_flush_tfd(ap);
1052         ahci_pwrite(ap, AHCI_PREG_SERR, -1);
1053
1054         /* Restart port */
1055         if (ahci_port_start(ap)) {
1056                 kprintf("%s: failed to start port, cannot softreset\n",
1057                         PORTNAME(ap));
1058                 goto err;
1059         }
1060
1061         /* Check whether CLO worked */
1062         if (ahci_pwait_clr(ap, AHCI_PREG_TFD,
1063                                AHCI_PREG_TFD_STS_BSY | AHCI_PREG_TFD_STS_DRQ)) {
1064                 kprintf("%s: CLO %s, need port reset\n",
1065                         PORTNAME(ap),
1066                         (ahci_read(ap->ap_sc, AHCI_REG_CAP) & AHCI_REG_CAP_SCLO)
1067                         ? "failed" : "unsupported");
1068                 error = EBUSY;
1069                 goto err;
1070         }
1071
1072         /*
1073          * Prep first D2H command with SRST feature & clear busy/reset flags
1074          *
1075          * It is unclear which other fields in the FIS are used.  Just zero
1076          * everything.
1077          *
1078          * NOTE!  This CCB is used for both the first and second commands.
1079          *        The second command must use CCB slot 1 to properly load
1080          *        the signature.
1081          */
1082         ccb = ahci_get_err_ccb(ap);
1083         KKASSERT(ccb->ccb_slot == 1);
1084         ccb->ccb_xa.at = NULL;
1085         cmd_slot = ccb->ccb_cmd_hdr;
1086
1087         fis = ccb->ccb_cmd_table->cfis;
1088         bzero(fis, sizeof(ccb->ccb_cmd_table->cfis));
1089         fis[0] = ATA_FIS_TYPE_H2D;
1090         fis[15] = ATA_FIS_CONTROL_SRST|ATA_FIS_CONTROL_4BIT;
1091
1092         cmd_slot->prdtl = 0;
1093         cmd_slot->flags = htole16(5);   /* FIS length: 5 DWORDS */
1094         cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_C); /* Clear busy on OK */
1095         cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_R); /* Reset */
1096
1097         ccb->ccb_xa.state = ATA_S_PENDING;
1098         ccb->ccb_xa.flags = 0;
1099         if (ahci_poll(ccb, 1000, ahci_quick_timeout) != ATA_S_COMPLETE) {
1100                 kprintf("%s: First FIS failed\n", PORTNAME(ap));
1101                 goto err;
1102         }
1103
1104         /*
1105          * WARNING!     TIME SENSITIVE SPACE!   WARNING!
1106          *
1107          * The two FISes are supposed to be back to back.  Don't issue other
1108          * commands or even delay if we can help it.
1109          */
1110
1111         /*
1112          * Prep second D2H command to read status and complete reset sequence
1113          * AHCI 10.4.1 and "Serial ATA Revision 2.6".  I can't find the ATA
1114          * Rev 2.6 and it is unclear how the second FIS should be set up
1115          * from the AHCI document.
1116          *
1117          * Give the device 3ms before sending the second FIS.
1118          *
1119          * It is unclear which other fields in the FIS are used.  Just zero
1120          * everything.
1121          */
1122         bzero(fis, sizeof(ccb->ccb_cmd_table->cfis));
1123         fis[0] = ATA_FIS_TYPE_H2D;
1124         fis[15] = ATA_FIS_CONTROL_4BIT;
1125
1126         cmd_slot->prdtl = 0;
1127         cmd_slot->flags = htole16(5);   /* FIS length: 5 DWORDS */
1128
1129         ccb->ccb_xa.state = ATA_S_PENDING;
1130         ccb->ccb_xa.flags = 0;
1131         if (ahci_poll(ccb, 1000, ahci_quick_timeout) != ATA_S_COMPLETE) {
1132                 kprintf("%s: Second FIS failed\n", PORTNAME(ap));
1133                 goto err;
1134         }
1135
1136         if (ahci_pwait_clr(ap, AHCI_PREG_TFD,
1137                             AHCI_PREG_TFD_STS_BSY | AHCI_PREG_TFD_STS_DRQ)) {
1138                 kprintf("%s: device didn't come ready after reset, TFD: 0x%b\n",
1139                         PORTNAME(ap),
1140                         ahci_pread(ap, AHCI_PREG_TFD), AHCI_PFMT_TFD_STS);
1141                 error = EBUSY;
1142                 goto err;
1143         }
1144         ahci_os_sleep(10);
1145
1146         /*
1147          * If the softreset is trying to clear a BSY condition after a
1148          * normal portreset we assign the port type.
1149          *
1150          * If the softreset is being run first as part of the ccb error
1151          * processing code then report if the device signature changed
1152          * unexpectedly.
1153          */
1154         if (ap->ap_type == ATA_PORT_T_NONE) {
1155                 ap->ap_type = ahci_port_signature_detect(ap, NULL);
1156         } else {
1157                 if (ahci_port_signature_detect(ap, NULL) != ap->ap_type) {
1158                         kprintf("%s: device signature unexpectedly "
1159                                 "changed\n", PORTNAME(ap));
1160                         error = EBUSY; /* XXX */
1161                 }
1162         }
1163         error = 0;
1164
1165         ahci_os_sleep(3);
1166 err:
1167         if (ccb != NULL) {
1168                 ahci_put_err_ccb(ccb);
1169
1170                 /*
1171                  * If the target is busy use CLO to clear the busy
1172                  * condition.  The BSY should be cleared on the next
1173                  * start.
1174                  */
1175                 if (ahci_pread(ap, AHCI_PREG_TFD) &
1176                     (AHCI_PREG_TFD_STS_BSY | AHCI_PREG_TFD_STS_DRQ)) {
1177                         ahci_port_clo(ap);
1178                 }
1179         }
1180
1181         /*
1182          * If we failed to softreset make the port quiescent, otherwise
1183          * make sure the port's start/stop state matches what it was on
1184          * entry.
1185          *
1186          * Don't kill the port if the softreset is on a port multiplier
1187          * target, that would kill all the targets!
1188          */
1189         if (error) {
1190                 ahci_port_hardstop(ap);
1191                 /* ap_probe set to failed */
1192         } else if (cmd & AHCI_PREG_CMD_ST) {
1193                 ap->ap_probe = ATA_PROBE_NEED_IDENT;
1194                 kprintf("%s: STARTING PORT\n", PORTNAME(ap));
1195                 ahci_port_start(ap);
1196         } else {
1197                 ap->ap_probe = ATA_PROBE_NEED_IDENT;
1198                 kprintf("%s: STOPPING PORT\n", PORTNAME(ap));
1199                 ahci_port_stop(ap, !(cmd & AHCI_PREG_CMD_FRE));
1200         }
1201         ap->ap_flags &= ~AP_F_IN_RESET;
1202         crit_exit();
1203
1204         kprintf("%s: END SOFTRESET\n", PORTNAME(ap));
1205
1206         return (error);
1207 }
1208
1209 /*
1210  * AHCI port reset, Section 10.4.2
1211  *
1212  * This function does a hard reset of the port.  Note that the device
1213  * connected to the port could still end-up hung.
1214  */
1215 int
1216 ahci_port_hardreset(struct ahci_port *ap, int hard)
1217 {
1218         u_int32_t cmd, r;
1219         int     error;
1220         int     loop;
1221         int     type;
1222
1223         DPRINTF(AHCI_D_VERBOSE, "%s: port reset\n", PORTNAME(ap));
1224
1225         ap->ap_flags |= AP_F_IN_RESET;
1226
1227         /*
1228          * Idle the port,
1229          */
1230         ahci_port_stop(ap, 0);
1231         ap->ap_state = AP_S_NORMAL;
1232         error = 0;
1233
1234         /*
1235          * The port may have been quiescent with its SUD bit cleared, so
1236          * set the SUD (spin up device).
1237          */
1238         cmd = ahci_pread(ap, AHCI_PREG_CMD) & ~AHCI_PREG_CMD_ICC;
1239         cmd |= AHCI_PREG_CMD_SUD;
1240         ahci_pwrite(ap, AHCI_PREG_CMD, cmd);
1241
1242         /*
1243          * Perform device detection.  Cycle the PHY off, wait 10ms.
1244          * This simulates the SATA cable being physically unplugged.
1245          *
1246          * NOTE: hard reset mode 2 (cycling the PHY) is not reliable
1247          *       and not currently used.
1248          */
1249         ap->ap_type = ATA_PORT_T_NONE;
1250
1251         r = AHCI_PREG_SCTL_IPM_DISABLED;
1252         if (hard == 2)
1253                 r |= AHCI_PREG_SCTL_DET_DISABLE;
1254         ahci_pwrite(ap, AHCI_PREG_SCTL, r);
1255         ahci_os_sleep(10);
1256
1257         /*
1258          * Start transmitting COMRESET.  COMRESET must be sent for at
1259          * least 1ms.
1260          */
1261         r = AHCI_PREG_SCTL_IPM_DISABLED | AHCI_PREG_SCTL_DET_INIT;
1262         if (AhciForceGen1 & (1 << ap->ap_num)) {
1263                 kprintf("%s: Force 1.5Gbits\n", PORTNAME(ap));
1264                 r |= AHCI_PREG_SCTL_SPD_GEN1;
1265         } else {
1266                 r |= AHCI_PREG_SCTL_SPD_ANY;
1267         }
1268         ahci_pwrite(ap, AHCI_PREG_SCTL, r);
1269
1270         /*
1271          * Through trial and error it seems to take around 100ms
1272          * for the detect logic to settle down.  If this is too
1273          * short the softreset code will fail.
1274          */
1275         ahci_os_sleep(100);
1276
1277         /*
1278          * Only SERR_DIAG_X needs to be cleared for TFD updates, but
1279          * since we are hard-resetting the port we might as well clear
1280          * the whole enchillada
1281          */
1282         ahci_flush_tfd(ap);
1283         ahci_pwrite(ap, AHCI_PREG_SERR, -1);
1284         r &= ~AHCI_PREG_SCTL_DET_INIT;
1285         r |= AHCI_PREG_SCTL_DET_NONE;
1286         ahci_pwrite(ap, AHCI_PREG_SCTL, r);
1287
1288         /*
1289          * Try to determine if there is a device on the port.
1290          *
1291          * Give the device 3/10 second to at least be detected.
1292          * If we fail clear PRCS (phy detect) since we may cycled
1293          * the phy and probably caused another PRCS interrupt.
1294          */
1295         for (loop = 30; loop; --loop) {
1296                 r = ahci_pread(ap, AHCI_PREG_SSTS);
1297                 if (r & AHCI_PREG_SSTS_DET)
1298                         break;
1299                 ahci_os_sleep(10);
1300         }
1301         if (loop == 0) {
1302                 ahci_pwrite(ap, AHCI_PREG_IS, AHCI_PREG_IS_PRCS);
1303                 kprintf("%s: Port appears to be unplugged\n",
1304                         PORTNAME(ap));
1305                 error = ENODEV;
1306         }
1307
1308         /*
1309          * There is something on the port.  Give the device 3 seconds
1310          * to fully negotiate.
1311          */
1312         if (error == 0 &&
1313             ahci_pwait_eq(ap, 3000, AHCI_PREG_SSTS,
1314                           AHCI_PREG_SSTS_DET, AHCI_PREG_SSTS_DET_DEV)) {
1315                 kprintf("%s: Device may be powered down\n",
1316                         PORTNAME(ap));
1317                 error = ENODEV;
1318         }
1319
1320         /*
1321          * Wait for the device to become ready.
1322          *
1323          * This can take more then a second, give it 3 seconds.  If we
1324          * succeed give the device another 3ms after that.
1325          *
1326          * NOTE: Port multipliers can do two things here.  First they can
1327          *       return device-ready if a device is on target 0 and also
1328          *       return the signature for that device.  If there is no
1329          *       device on target 0 then BSY/DRQ is never cleared and
1330          *       it never comes ready.
1331          */
1332         if (error == 0 &&
1333             ahci_pwait_clr_to(ap, 3000, AHCI_PREG_TFD,
1334                             AHCI_PREG_TFD_STS_BSY | AHCI_PREG_TFD_STS_DRQ)) {
1335                 /*
1336                  * The device is bricked or its a port multiplier and will
1337                  * not unbusy until we do the pmprobe CLO softreset sequence.
1338                  */
1339                 error = ahci_port_pmprobe(ap);
1340                 if (error) {
1341                         kprintf("%s: Device will not come ready 0x%b\n",
1342                                 PORTNAME(ap),
1343                                 ahci_pread(ap, AHCI_PREG_TFD),
1344                                 AHCI_PFMT_TFD_STS);
1345                 } else {
1346                         ap->ap_type = ATA_PORT_T_PM;
1347                 }
1348         } else if (error == 0) {
1349                 /*
1350                  * We generally will not get a port multiplier signature in
1351                  * this case even if this is a port multiplier, because of
1352                  * Intel's stupidity.  We almost certainly got target 0
1353                  * behind the PM, if there is a PM.
1354                  *
1355                  * Save the signature and probe for a PM.  If we do not
1356                  * find a PM then use the saved signature and return
1357                  * success.
1358                  */
1359                 type = ahci_port_signature_detect(ap, NULL);
1360                 error = ahci_port_pmprobe(ap);
1361                 if (error) {
1362                         ap->ap_type = type;
1363                         error = 0;
1364                 } else {
1365                         ap->ap_type = ATA_PORT_T_PM;
1366                         kprintf("%s: Port multiplier detected\n",
1367                                 PORTNAME(ap));
1368                 }
1369         }
1370
1371         /*
1372          * hard-stop the port if we failed.  This will set ap_probe
1373          * to FAILED.
1374          */
1375         ap->ap_flags &= ~AP_F_IN_RESET;
1376         if (error) {
1377                 ahci_port_hardstop(ap);
1378                 /* ap_probe set to failed */
1379         } else {
1380                 if (ap->ap_type == ATA_PORT_T_PM)
1381                         ap->ap_probe = ATA_PROBE_GOOD;
1382                 else
1383                         ap->ap_probe = ATA_PROBE_NEED_SOFT_RESET;
1384         }
1385         return (error);
1386 }
1387
1388 /*
1389  * AHCI port multiplier probe.  This routine is run by the hardreset code
1390  * if it gets past the device detect, whether or not BSY is found to be
1391  * stuck.
1392  *
1393  * We MUST use CLO to properly probe whether the port multiplier exists
1394  * or not.
1395  *
1396  * Return 0 on success, non-zero on failure.
1397  */
1398 int
1399 ahci_port_pmprobe(struct ahci_port *ap)
1400 {
1401         struct ahci_cmd_hdr *cmd_slot;
1402         struct ata_port *at;
1403         struct ahci_ccb *ccb = NULL;
1404         u_int8_t        *fis = NULL;
1405         int             error = EIO;
1406         u_int32_t       cmd;
1407         int             count;
1408         int             i;
1409
1410         /*
1411          * If we don't support port multipliers don't try to detect one.
1412          */
1413         if ((ap->ap_sc->sc_cap & AHCI_REG_CAP_SPM) == 0)
1414                 return (ENODEV);
1415
1416         count = 2;
1417 retry:
1418         /*
1419          * This code is only called from hardreset, which does not
1420          * high level command processing.  The port should be stopped.
1421          *
1422          * Set PMA mode while the port is stopped.
1423          *
1424          * NOTE: On retry the port might be running, stopped, or failed.
1425          */
1426         ahci_port_stop(ap, 0);
1427         ap->ap_state = AP_S_NORMAL;
1428         cmd = ahci_pread(ap, AHCI_PREG_CMD) & ~AHCI_PREG_CMD_ICC;
1429         if ((cmd & AHCI_PREG_CMD_PMA) == 0) {
1430                 cmd |= AHCI_PREG_CMD_PMA;
1431                 ahci_pwrite(ap, AHCI_PREG_CMD, cmd);
1432         }
1433
1434         /*
1435          * Flush any errors and request CLO unconditionally, then start
1436          * the port.
1437          */
1438         ahci_flush_tfd(ap);
1439         ahci_port_clo(ap);
1440         if (ahci_port_start(ap)) {
1441                 kprintf("%s: PMPROBE failed to start port, cannot softreset\n",
1442                         PORTNAME(ap));
1443                 goto err;
1444         }
1445
1446         /*
1447          * Check whether CLO worked
1448          */
1449         if (ahci_pwait_clr(ap, AHCI_PREG_TFD,
1450                                AHCI_PREG_TFD_STS_BSY | AHCI_PREG_TFD_STS_DRQ)) {
1451                 kprintf("%s: PMPROBE CLO %s, need port reset\n",
1452                         PORTNAME(ap),
1453                         (ahci_read(ap->ap_sc, AHCI_REG_CAP) & AHCI_REG_CAP_SCLO)
1454                         ? "failed" : "unsupported");
1455                 error = EBUSY;
1456                 goto err;
1457         }
1458
1459         /*
1460          * Use the error CCB for all commands
1461          *
1462          * NOTE!  This CCB is used for both the first and second commands.
1463          *        The second command must use CCB slot 1 to properly load
1464          *        the signature.
1465          */
1466         ccb = ahci_get_err_ccb(ap);
1467         cmd_slot = ccb->ccb_cmd_hdr;
1468         KKASSERT(ccb->ccb_slot == 1);
1469
1470         /*
1471          * Prep the first H2D command with SRST feature & clear busy/reset
1472          * flags.
1473          */
1474
1475         fis = ccb->ccb_cmd_table->cfis;
1476         bzero(fis, sizeof(ccb->ccb_cmd_table->cfis));
1477         fis[0] = ATA_FIS_TYPE_H2D;
1478         fis[1] = 0x0F;                  /* Target 15 */
1479         fis[15] = ATA_FIS_CONTROL_SRST | ATA_FIS_CONTROL_4BIT;
1480
1481         cmd_slot->prdtl = 0;
1482         cmd_slot->flags = htole16(5);   /* FIS length: 5 DWORDS */
1483         cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_C); /* Clear busy on OK */
1484         cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_R); /* Reset */
1485         cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_PMP); /* port 0xF */
1486
1487         ccb->ccb_xa.state = ATA_S_PENDING;
1488         ccb->ccb_xa.flags = 0;
1489
1490         if (ahci_poll(ccb, 1000, ahci_quick_timeout) != ATA_S_COMPLETE) {
1491                 kprintf("%s: PMPROBE First FIS failed\n", PORTNAME(ap));
1492                 if (--count) {
1493                         ahci_put_err_ccb(ccb);
1494                         goto retry;
1495                 }
1496                 goto err;
1497         }
1498         if (ahci_pwait_clr(ap, AHCI_PREG_TFD,
1499                                AHCI_PREG_TFD_STS_BSY | AHCI_PREG_TFD_STS_DRQ)) {
1500                 kprintf("%s: PMPROBE Busy after first FIS\n", PORTNAME(ap));
1501         }
1502
1503         /*
1504          * The device may have muffed up the PHY when it reset.
1505          */
1506         ahci_os_sleep(100);
1507         ahci_flush_tfd(ap);
1508         ahci_pwrite(ap, AHCI_PREG_SERR, -1);
1509         /* ahci_pm_phy_status(ap, 15, &cmd); */
1510
1511         /*
1512          * Prep second D2H command to read status and complete reset sequence
1513          * AHCI 10.4.1 and "Serial ATA Revision 2.6".  I can't find the ATA
1514          * Rev 2.6 and it is unclear how the second FIS should be set up
1515          * from the AHCI document.
1516          *
1517          * Give the device 3ms before sending the second FIS.
1518          *
1519          * It is unclear which other fields in the FIS are used.  Just zero
1520          * everything.
1521          */
1522         bzero(fis, sizeof(ccb->ccb_cmd_table->cfis));
1523         fis[0] = ATA_FIS_TYPE_H2D;
1524         fis[1] = 0x0F;
1525         fis[15] = ATA_FIS_CONTROL_4BIT;
1526
1527         cmd_slot->prdtl = 0;
1528         cmd_slot->flags = htole16(5);   /* FIS length: 5 DWORDS */
1529         cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_PMP); /* port 0xF */
1530
1531         ccb->ccb_xa.state = ATA_S_PENDING;
1532         ccb->ccb_xa.flags = 0;
1533
1534         if (ahci_poll(ccb, 5000, ahci_quick_timeout) != ATA_S_COMPLETE) {
1535                 kprintf("%s: PMPROBE Second FIS failed\n", PORTNAME(ap));
1536                 if (--count) {
1537                         ahci_put_err_ccb(ccb);
1538                         goto retry;
1539                 }
1540                 goto err;
1541         }
1542
1543         /*
1544          * What? We succeeded?  Yup, but for some reason the signature
1545          * is still latched from the original detect (that saw target 0
1546          * behind the PM), and I don't know how to clear the condition
1547          * other then by retrying the whole reset sequence.
1548          */
1549         if (--count) {
1550                 fis[15] = 0;
1551                 ahci_put_err_ccb(ccb);
1552                 goto retry;
1553         }
1554
1555         /*
1556          * Get the signature.  The caller sets the ap fields.
1557          */
1558         if (ahci_port_signature_detect(ap, NULL) == ATA_PORT_T_PM) {
1559                 ap->ap_ata[15].at_probe = ATA_PROBE_GOOD;
1560                 error = 0;
1561         } else {
1562                 error = EBUSY;
1563         }
1564
1565         /*
1566          * Fall through / clean up the CCB and perform error processing.
1567          */
1568 err:
1569         if (ccb != NULL)
1570                 ahci_put_err_ccb(ccb);
1571
1572         if (error == 0 && ahci_pm_identify(ap)) {
1573                 kprintf("%s: PM - cannot identify port multiplier\n",
1574                         PORTNAME(ap));
1575                 error = EBUSY;
1576         }
1577
1578         /*
1579          * If we probed the PM reset the state for the targets behind
1580          * it so they get probed by the state machine.
1581          */
1582         if (error == 0) {
1583                 for (i = 0; i < AHCI_MAX_PMPORTS; ++i) {
1584                         at = &ap->ap_ata[i];
1585                         at->at_probe = ATA_PROBE_NEED_INIT;
1586                         at->at_features |= ATA_PORT_F_RESCAN;
1587                 }
1588         }
1589
1590         /*
1591          * If we failed turn off PMA, otherwise identify the port multiplier.
1592          * CAM will iterate the devices.
1593          */
1594         if (error) {
1595                 ahci_port_stop(ap, 0);
1596                 cmd = ahci_pread(ap, AHCI_PREG_CMD) & ~AHCI_PREG_CMD_ICC;
1597                 cmd &= ~AHCI_PREG_CMD_PMA;
1598                 ahci_pwrite(ap, AHCI_PREG_CMD, cmd);
1599         }
1600         ahci_port_stop(ap, 0);
1601
1602         return(error);
1603 }
1604
1605
1606 /*
1607  * Hard-stop on hot-swap device removal.  See 10.10.1
1608  *
1609  * Place the port in a mode that will allow it to detect hot-swap insertions.
1610  * This is a bit imprecise because just setting-up SCTL to DET_INIT doesn't
1611  * seem to do the job.
1612  */
1613 void
1614 ahci_port_hardstop(struct ahci_port *ap)
1615 {
1616         struct ata_port *at;
1617         u_int32_t r;
1618         u_int32_t cmd;
1619         int i;
1620
1621         /*
1622          * Stop the port.  We can't modify things like SUD if the port
1623          * is running.
1624          */
1625         ap->ap_state = AP_S_FATAL_ERROR;
1626         ap->ap_probe = ATA_PROBE_FAILED;
1627         ap->ap_type = ATA_PORT_T_NONE;
1628         ahci_port_stop(ap, 0);
1629         cmd = ahci_pread(ap, AHCI_PREG_CMD);
1630
1631         /*
1632          * Clean up AT sub-ports on SATA port.
1633          */
1634         for (i = 0; ap->ap_ata && i < AHCI_MAX_PMPORTS; ++i) {
1635                 at = &ap->ap_ata[i];
1636                 at->at_type = ATA_PORT_T_NONE;
1637                 at->at_probe = ATA_PROBE_FAILED;
1638         }
1639
1640         /*
1641          * Turn off port-multiplier control bit
1642          */
1643         if (cmd & AHCI_PREG_CMD_PMA) {
1644                 cmd &= ~AHCI_PREG_CMD_PMA;
1645                 ahci_pwrite(ap, AHCI_PREG_CMD, cmd);
1646         }
1647
1648         /*
1649          * Make sure FRE is active.  There isn't anything we can do if it
1650          * fails so just ignore errors.
1651          */
1652         if ((cmd & AHCI_PREG_CMD_FRE) == 0) {
1653                 cmd |= AHCI_PREG_CMD_FRE;
1654                 ahci_pwrite(ap, AHCI_PREG_CMD, cmd);
1655                 if ((ap->ap_sc->sc_flags & AHCI_F_IGN_FR) == 0)
1656                         ahci_pwait_set(ap, AHCI_PREG_CMD, AHCI_PREG_CMD_FR);
1657         }
1658
1659         /*
1660          * 10.10.3 DET must be set to 0 before setting SUD to 0.
1661          * 10.10.1 place us in the Listen state.
1662          *
1663          * Deactivating SUD only applies if the controller supports SUD.
1664          */
1665         ahci_pwrite(ap, AHCI_PREG_SCTL, AHCI_PREG_SCTL_IPM_DISABLED);
1666         ahci_os_sleep(1);
1667         if (cmd & AHCI_PREG_CMD_SUD) {
1668                 cmd &= ~AHCI_PREG_CMD_SUD;
1669                 ahci_pwrite(ap, AHCI_PREG_CMD, cmd);
1670         }
1671         ahci_os_sleep(1);
1672
1673         /*
1674          * Transition su to the spin-up state.  HVA shall send COMRESET and
1675          * begin initialization sequence (whatever that means).
1676          *
1677          * This only applies if the controller supports SUD.
1678          */
1679         cmd |= AHCI_PREG_CMD_SUD;
1680         ahci_pwrite(ap, AHCI_PREG_CMD, cmd);
1681         ahci_os_sleep(1);
1682
1683         /*
1684          * Transition us to the Reset state.  Theoretically we send a
1685          * continuous stream of COMRESETs in this state.
1686          */
1687         r = AHCI_PREG_SCTL_IPM_DISABLED | AHCI_PREG_SCTL_DET_INIT;
1688         if (AhciForceGen1 & (1 << ap->ap_num)) {
1689                 kprintf("%s: Force 1.5Gbits\n", PORTNAME(ap));
1690                 r |= AHCI_PREG_SCTL_SPD_GEN1;
1691         } else {
1692                 r |= AHCI_PREG_SCTL_SPD_ANY;
1693         }
1694         ahci_pwrite(ap, AHCI_PREG_SCTL, r);
1695         ahci_os_sleep(1);
1696
1697         /*
1698          * Flush SERR_DIAG_X so the TFD can update.
1699          */
1700         ahci_flush_tfd(ap);
1701
1702         /*
1703          * Leave us in COMRESET (both SUD and INIT active), the HBA should
1704          * hopefully send us a DIAG_X-related interrupt if it receives
1705          * a COMINIT, and if not that then at least a Phy transition
1706          * interrupt.
1707          *
1708          * If we transition INIT from 1->0 to begin the initalization
1709          * sequence it is unclear if that sequence will remain active
1710          * until the next device insertion.
1711          *
1712          * If we go back to the listen state it is unclear if the
1713          * device will actually send us a COMINIT, since we aren't
1714          * sending any COMRESET's
1715          */
1716         /* NOP */
1717 }
1718
1719 /*
1720  * Multiple events may have built up in the TFD.  The spec is not very
1721  * clear on this but it does seem to serialize events so clearing DIAG_X
1722  * just once might not do the job during a reset sequence.
1723  *
1724  * XXX this probably isn't right.
1725  */
1726 void
1727 ahci_flush_tfd(struct ahci_port *ap)
1728 {
1729         u_int32_t r;
1730
1731         r = ahci_pread(ap, AHCI_PREG_SERR);
1732         while (r & AHCI_PREG_SERR_DIAG_X) {
1733                 ahci_pwrite(ap, AHCI_PREG_SERR, AHCI_PREG_SERR_DIAG_X);
1734                 ahci_os_sleep(1);
1735                 r = ahci_pread(ap, AHCI_PREG_SERR);
1736         }
1737 }
1738
1739 /*
1740  * Figure out what type of device is connected to the port, ATAPI or
1741  * DISK.
1742  */
1743 int
1744 ahci_port_signature_detect(struct ahci_port *ap, struct ata_port *at)
1745 {
1746         u_int32_t sig;
1747
1748         sig = ahci_pread(ap, AHCI_PREG_SIG);
1749         kprintf("%s: sig %08x\n", ATANAME(ap, at), sig);
1750         if ((sig & 0xffff0000) == (SATA_SIGNATURE_ATAPI & 0xffff0000)) {
1751                 return(ATA_PORT_T_ATAPI);
1752         } else if ((sig & 0xffff0000) ==
1753                  (SATA_SIGNATURE_PORT_MULTIPLIER & 0xffff0000)) {
1754                 return(ATA_PORT_T_PM);
1755         } else {
1756                 return(ATA_PORT_T_DISK);
1757         }
1758 }
1759
1760 /*
1761  * Load the DMA descriptor table for a CCB's buffer.
1762  */
1763 int
1764 ahci_load_prdt(struct ahci_ccb *ccb)
1765 {
1766         struct ahci_port                *ap = ccb->ccb_port;
1767         struct ahci_softc               *sc = ap->ap_sc;
1768         struct ata_xfer                 *xa = &ccb->ccb_xa;
1769         struct ahci_prdt                *prdt = ccb->ccb_cmd_table->prdt;
1770         bus_dmamap_t                    dmap = ccb->ccb_dmamap;
1771         struct ahci_cmd_hdr             *cmd_slot = ccb->ccb_cmd_hdr;
1772         int                             error;
1773
1774         if (xa->datalen == 0) {
1775                 ccb->ccb_cmd_hdr->prdtl = 0;
1776                 return (0);
1777         }
1778
1779         error = bus_dmamap_load(sc->sc_tag_data, dmap,
1780                                 xa->data, xa->datalen,
1781                                 ahci_load_prdt_callback,
1782                                 &prdt,
1783                                 ((xa->flags & ATA_F_NOWAIT) ?
1784                                     BUS_DMA_NOWAIT : BUS_DMA_WAITOK));
1785         if (error != 0) {
1786                 kprintf("%s: error %d loading dmamap\n", PORTNAME(ap), error);
1787                 return (1);
1788         }
1789         if (xa->flags & ATA_F_PIO)
1790                 prdt->flags |= htole32(AHCI_PRDT_FLAG_INTR);
1791
1792         cmd_slot->prdtl = htole16(prdt - ccb->ccb_cmd_table->prdt + 1);
1793
1794         bus_dmamap_sync(sc->sc_tag_data, dmap,
1795                         (xa->flags & ATA_F_READ) ?
1796                             BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
1797
1798         return (0);
1799
1800 #ifdef DIAGNOSTIC
1801 diagerr:
1802         bus_dmamap_unload(sc->sc_tag_data, dmap);
1803         return (1);
1804 #endif
1805 }
1806
1807 /*
1808  * Callback from BUSDMA system to load the segment list.  The passed segment
1809  * list is a temporary structure.
1810  */
1811 static
1812 void
1813 ahci_load_prdt_callback(void *info, bus_dma_segment_t *segs, int nsegs,
1814                         int error)
1815 {
1816         struct ahci_prdt *prd = *(void **)info;
1817         u_int64_t addr;
1818
1819         KKASSERT(nsegs <= AHCI_MAX_PRDT);
1820
1821         while (nsegs) {
1822                 addr = segs->ds_addr;
1823                 prd->dba_hi = htole32((u_int32_t)(addr >> 32));
1824                 prd->dba_lo = htole32((u_int32_t)addr);
1825 #ifdef DIAGNOSTIC
1826                 KKASSERT((addr & 1) == 0);
1827                 KKASSERT((segs->ds_len & 1) == 0);
1828 #endif
1829                 prd->flags = htole32(segs->ds_len - 1);
1830                 --nsegs;
1831                 if (nsegs)
1832                         ++prd;
1833                 ++segs;
1834         }
1835         *(void **)info = prd;   /* return last valid segment */
1836 }
1837
1838 void
1839 ahci_unload_prdt(struct ahci_ccb *ccb)
1840 {
1841         struct ahci_port                *ap = ccb->ccb_port;
1842         struct ahci_softc               *sc = ap->ap_sc;
1843         struct ata_xfer                 *xa = &ccb->ccb_xa;
1844         bus_dmamap_t                    dmap = ccb->ccb_dmamap;
1845
1846         if (xa->datalen != 0) {
1847                 bus_dmamap_sync(sc->sc_tag_data, dmap,
1848                                 (xa->flags & ATA_F_READ) ?
1849                                 BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
1850
1851                 bus_dmamap_unload(sc->sc_tag_data, dmap);
1852
1853                 if (ccb->ccb_xa.flags & ATA_F_NCQ)
1854                         xa->resid = 0;
1855                 else
1856                         xa->resid = xa->datalen -
1857                             le32toh(ccb->ccb_cmd_hdr->prdbc);
1858         }
1859 }
1860
1861 /*
1862  * Start a command and poll for completion.
1863  *
1864  * timeout is in ms and only counts once the command gets on-chip.
1865  *
1866  * Returns ATA_S_* state, compare against ATA_S_COMPLETE to determine
1867  * that no error occured.
1868  *
1869  * NOTE: If the caller specifies a NULL timeout function the caller is
1870  *       responsible for clearing hardware state on failure, but we will
1871  *       deal with removing the ccb from any pending queue.
1872  *
1873  * NOTE: NCQ should never be used with this function.
1874  *
1875  * NOTE: If the port is in a failed state and stopped we do not try
1876  *       to activate the ccb.
1877  */
1878 int
1879 ahci_poll(struct ahci_ccb *ccb, int timeout,
1880           void (*timeout_fn)(struct ahci_ccb *))
1881 {
1882         struct ahci_port *ap = ccb->ccb_port;
1883
1884         if (ccb->ccb_port->ap_state == AP_S_FATAL_ERROR) {
1885                 ccb->ccb_xa.state = ATA_S_ERROR;
1886                 return(ccb->ccb_xa.state);
1887         }
1888         crit_enter();
1889         ahci_start(ccb);
1890
1891         do {
1892                 ahci_port_intr(ap, 1);
1893                 switch(ccb->ccb_xa.state) {
1894                 case ATA_S_ONCHIP:
1895                         timeout -= ahci_os_softsleep();
1896                         break;
1897                 case ATA_S_PENDING:
1898                         ahci_os_softsleep();
1899                         ahci_check_active_timeouts(ap);
1900                         break;
1901                 default:
1902                         crit_exit();
1903                         return (ccb->ccb_xa.state);
1904                 }
1905         } while (timeout > 0);
1906
1907         kprintf("%s: Poll timeout slot %d CMD: %b TFD: 0x%b SERR: %b\n",
1908                 ATANAME(ap, ccb->ccb_xa.at), ccb->ccb_slot,
1909                 ahci_pread(ap, AHCI_PREG_CMD), AHCI_PFMT_CMD,
1910                 ahci_pread(ap, AHCI_PREG_TFD), AHCI_PFMT_TFD_STS,
1911                 ahci_pread(ap, AHCI_PREG_SERR), AHCI_PFMT_SERR);
1912
1913         timeout_fn(ccb);
1914
1915         crit_exit();
1916
1917         return(ccb->ccb_xa.state);
1918 }
1919
1920 /*
1921  * When polling we have to check if the currently active CCB(s)
1922  * have timed out as the callout will be deadlocked while we
1923  * hold the port lock.
1924  */
1925 void
1926 ahci_check_active_timeouts(struct ahci_port *ap)
1927 {
1928         struct ahci_ccb *ccb;
1929         u_int32_t mask;
1930         int tag;
1931
1932         mask = ap->ap_active | ap->ap_sactive;
1933         while (mask) {
1934                 tag = ffs(mask) - 1;
1935                 mask &= ~(1 << tag);
1936                 ccb = &ap->ap_ccbs[tag];
1937                 if (ccb->ccb_xa.flags & ATA_F_TIMEOUT_EXPIRED) {
1938                         ahci_ata_cmd_timeout(ccb);
1939                 }
1940         }
1941 }
1942
1943 static
1944 __inline
1945 void
1946 ahci_start_timeout(struct ahci_ccb *ccb)
1947 {
1948         if (ccb->ccb_xa.flags & ATA_F_TIMEOUT_DESIRED) {
1949                 ccb->ccb_xa.flags |= ATA_F_TIMEOUT_RUNNING;
1950                 callout_reset(&ccb->ccb_timeout,
1951                               (ccb->ccb_xa.timeout * hz + 999) / 1000,
1952                               ahci_ata_cmd_timeout_unserialized, ccb);
1953         }
1954 }
1955
1956 void
1957 ahci_start(struct ahci_ccb *ccb)
1958 {
1959         struct ahci_port                *ap = ccb->ccb_port;
1960         struct ahci_softc               *sc = ap->ap_sc;
1961
1962         KKASSERT(ccb->ccb_xa.state == ATA_S_PENDING);
1963
1964         /* Zero transferred byte count before transfer */
1965         ccb->ccb_cmd_hdr->prdbc = 0;
1966
1967         /* Sync command list entry and corresponding command table entry */
1968         bus_dmamap_sync(sc->sc_tag_cmdh,
1969                         AHCI_DMA_MAP(ap->ap_dmamem_cmd_list),
1970                         BUS_DMASYNC_PREWRITE);
1971         bus_dmamap_sync(sc->sc_tag_cmdt,
1972                         AHCI_DMA_MAP(ap->ap_dmamem_cmd_table),
1973                         BUS_DMASYNC_PREWRITE);
1974
1975         /* Prepare RFIS area for write by controller */
1976         bus_dmamap_sync(sc->sc_tag_rfis,
1977                         AHCI_DMA_MAP(ap->ap_dmamem_rfis),
1978                         BUS_DMASYNC_PREREAD);
1979
1980         if (ccb->ccb_xa.flags & ATA_F_NCQ) {
1981                 /*
1982                  * Issue NCQ commands only when there are no outstanding
1983                  * standard commands.
1984                  */
1985                 if (ap->ap_active || TAILQ_FIRST(&ap->ap_ccb_pending)) {
1986                         TAILQ_INSERT_TAIL(&ap->ap_ccb_pending, ccb, ccb_entry);
1987                 } else {
1988                         ahci_start_timeout(ccb);
1989                         KKASSERT(ap->ap_active_cnt == 0);
1990                         ap->ap_sactive |= (1 << ccb->ccb_slot);
1991                         ccb->ccb_xa.state = ATA_S_ONCHIP;
1992                         ahci_pwrite(ap, AHCI_PREG_SACT, 1 << ccb->ccb_slot);
1993                         ahci_pwrite(ap, AHCI_PREG_CI, 1 << ccb->ccb_slot);
1994                 }
1995         } else {
1996                 /*
1997                  * Wait for all NCQ commands to finish before issuing standard
1998                  * command.  Allow up to <limit> non-NCQ commands to be active.
1999                  *
2000                  * XXX If ap is a port multiplier only allow 1.  At least the
2001                  *     NVidia-MCP77 part seems to barf if more then one
2002                  *     command is activated, even though it isn't NCQ.
2003                  *
2004                  *     If I set up more then one I get phy errors and the
2005                  *     port fails.
2006                  */
2007                 int limit = (ap->ap_type == ATA_PORT_T_PM) ? 1 : 2;
2008                 if (ap->ap_sactive || ap->ap_active_cnt >= limit) {
2009                         TAILQ_INSERT_TAIL(&ap->ap_ccb_pending, ccb, ccb_entry);
2010                 } else {
2011                         ahci_start_timeout(ccb);
2012                         ap->ap_active |= 1 << ccb->ccb_slot;
2013                         ccb->ccb_xa.state = ATA_S_ONCHIP;
2014                         ahci_pwrite(ap, AHCI_PREG_CI, 1 << ccb->ccb_slot);
2015                         ap->ap_active_cnt++;
2016                 }
2017         }
2018 }
2019
2020 /*
2021  * While holding the port lock acquire exclusive access to the port.
2022  *
2023  * This is used when running the state machine to initialize and identify
2024  * targets over a port multiplier.  Setting exclusive access prevents
2025  * ahci_port_intr() from activating any requests sitting on the pending
2026  * queue.
2027  */
2028 void
2029 ahci_beg_exclusive_access(struct ahci_port *ap, struct ata_port *at)
2030 {
2031         KKASSERT((ap->ap_flags & AP_F_EXCLUSIVE_ACCESS) == 0);
2032         ap->ap_flags |= AP_F_EXCLUSIVE_ACCESS;
2033         while (ap->ap_active || ap->ap_sactive) {
2034                 ahci_port_intr(ap, 1);
2035                 ahci_os_softsleep();
2036         }
2037 }
2038
2039 void
2040 ahci_end_exclusive_access(struct ahci_port *ap, struct ata_port *at)
2041 {
2042         KKASSERT((ap->ap_flags & AP_F_EXCLUSIVE_ACCESS) != 0);
2043         ap->ap_flags &= ~AP_F_EXCLUSIVE_ACCESS;
2044         if (ap->ap_active == 0 && ap->ap_sactive == 0)
2045                 ahci_issue_pending_commands(ap, 0);
2046 }
2047
2048 void
2049 ahci_issue_pending_ncq_commands(struct ahci_port *ap)
2050 {
2051         struct ahci_ccb                 *nextccb;
2052         u_int32_t                       sact_change = 0;
2053
2054         KKASSERT(ap->ap_active_cnt == 0);
2055
2056         nextccb = TAILQ_FIRST(&ap->ap_ccb_pending);
2057         if (nextccb == NULL || !(nextccb->ccb_xa.flags & ATA_F_NCQ))
2058                 return;
2059         if (ap->ap_flags & AP_F_EXCLUSIVE_ACCESS)
2060                 return;
2061
2062         /* Start all the NCQ commands at the head of the pending list. */
2063         do {
2064                 TAILQ_REMOVE(&ap->ap_ccb_pending, nextccb, ccb_entry);
2065                 ahci_start_timeout(nextccb);
2066                 sact_change |= 1 << nextccb->ccb_slot;
2067                 nextccb->ccb_xa.state = ATA_S_ONCHIP;
2068                 nextccb = TAILQ_FIRST(&ap->ap_ccb_pending);
2069         } while (nextccb && (nextccb->ccb_xa.flags & ATA_F_NCQ));
2070
2071         ap->ap_sactive |= sact_change;
2072         ahci_pwrite(ap, AHCI_PREG_SACT, sact_change);
2073         ahci_pwrite(ap, AHCI_PREG_CI, sact_change);
2074
2075         return;
2076 }
2077
2078 void
2079 ahci_issue_pending_commands(struct ahci_port *ap, int last_was_ncq)
2080 {
2081         struct ahci_ccb                 *nextccb;
2082
2083         nextccb = TAILQ_FIRST(&ap->ap_ccb_pending);
2084         if (nextccb == NULL)
2085                 return;
2086         if (ap->ap_flags & AP_F_EXCLUSIVE_ACCESS)
2087                 return;
2088
2089         if (nextccb->ccb_xa.flags & ATA_F_NCQ) {
2090                 KKASSERT(last_was_ncq == 0);    /* otherwise it should have
2091                                                  * been started already. */
2092
2093                 /*
2094                  * Issue NCQ commands only when there are no outstanding
2095                  * standard commands.
2096                  */
2097                 if (ap->ap_active == 0)
2098                         ahci_issue_pending_ncq_commands(ap);
2099                 else
2100                         KKASSERT(ap->ap_active_cnt > 0);
2101         } else {
2102                 if (ap->ap_sactive || last_was_ncq)
2103                         KKASSERT(ap->ap_active_cnt == 0);
2104
2105                 /*
2106                  * Wait for all NCQ commands to finish before issuing standard
2107                  * command.  Then keep up to 2 standard commands on-chip at
2108                  * a time.
2109                  */
2110                 if (ap->ap_sactive)
2111                         return;
2112
2113                 while (ap->ap_active_cnt < 2 &&
2114                        nextccb && (nextccb->ccb_xa.flags & ATA_F_NCQ) == 0) {
2115                         TAILQ_REMOVE(&ap->ap_ccb_pending, nextccb, ccb_entry);
2116                         ahci_start_timeout(nextccb);
2117                         ap->ap_active |= 1 << nextccb->ccb_slot;
2118                         nextccb->ccb_xa.state = ATA_S_ONCHIP;
2119                         ahci_pwrite(ap, AHCI_PREG_CI, 1 << nextccb->ccb_slot);
2120                         ap->ap_active_cnt++;
2121                         nextccb = TAILQ_FIRST(&ap->ap_ccb_pending);
2122                 }
2123         }
2124 }
2125
2126 void
2127 ahci_intr(void *arg)
2128 {
2129         struct ahci_softc       *sc = arg;
2130         struct ahci_port        *ap;
2131         u_int32_t               is, ack = 0;
2132         int                     port;
2133
2134         /*
2135          * Check if the master enable is up, and whether any interrupts are
2136          * pending.
2137          */
2138         if ((sc->sc_flags & AHCI_F_INT_GOOD) == 0)
2139                 return;
2140         is = ahci_read(sc, AHCI_REG_IS);
2141         if (is == 0 || is == 0xffffffff)
2142                 return;
2143         ack = is;
2144
2145 #ifdef AHCI_COALESCE
2146         /* Check coalescing interrupt first */
2147         if (is & sc->sc_ccc_mask) {
2148                 DPRINTF(AHCI_D_INTR, "%s: command coalescing interrupt\n",
2149                     DEVNAME(sc));
2150                 is &= ~sc->sc_ccc_mask;
2151                 is |= sc->sc_ccc_ports_cur;
2152         }
2153 #endif
2154
2155         /*
2156          * Process interrupts for each port in a non-blocking fashion.
2157          */
2158         while (is) {
2159                 port = ffs(is) - 1;
2160                 ap = sc->sc_ports[port];
2161                 if (ap) {
2162                         if (ahci_os_lock_port_nb(ap) == 0) {
2163                                 ahci_port_intr(ap, 0);
2164                                 ahci_os_unlock_port(ap);
2165                         } else {
2166                                 ahci_pwrite(ap, AHCI_PREG_IE, 0);
2167                                 ahci_os_signal_port_thread(ap, AP_SIGF_PORTINT);
2168                         }
2169                 }
2170                 is &= ~(1 << port);
2171         }
2172
2173         /* Finally, acknowledge global interrupt */
2174         ahci_write(sc, AHCI_REG_IS, ack);
2175 }
2176
2177 /*
2178  * Core called from helper thread.
2179  */
2180 void
2181 ahci_port_thread_core(struct ahci_port *ap, int mask)
2182 {
2183         /*
2184          * Process any expired timedouts.
2185          */
2186         ahci_os_lock_port(ap);
2187         if (mask & AP_SIGF_TIMEOUT) {
2188                 ahci_check_active_timeouts(ap);
2189         }
2190
2191         /*
2192          * Process port interrupts which require a higher level of
2193          * intervention.
2194          */
2195         if (mask & AP_SIGF_PORTINT) {
2196                 ahci_port_intr(ap, 1);
2197                 ahci_port_interrupt_enable(ap);
2198                 ahci_os_unlock_port(ap);
2199         } else {
2200                 ahci_os_unlock_port(ap);
2201         }
2202 }
2203
2204 /*
2205  * Core per-port interrupt handler.
2206  *
2207  * If blockable is 0 we cannot call ahci_os_sleep() at all and we can only
2208  * deal with normal command completions which do not require blocking.
2209  */
2210 void
2211 ahci_port_intr(struct ahci_port *ap, int blockable)
2212 {
2213         struct ahci_softc       *sc = ap->ap_sc;
2214         u_int32_t               is, ci_saved, ci_masked;
2215         int                     slot;
2216         struct ahci_ccb         *ccb = NULL;
2217         struct ata_port         *ccb_at = NULL;
2218         volatile u_int32_t      *active;
2219 #ifdef DIAGNOSTIC
2220         u_int32_t               tmp;
2221 #endif
2222         const u_int32_t         blockable_mask = AHCI_PREG_IS_TFES |
2223                                                  AHCI_PREG_IS_IFS |
2224                                                  AHCI_PREG_IS_PCS |
2225                                                  AHCI_PREG_IS_PRCS |
2226                                                  AHCI_PREG_IS_HBFS |
2227                                                  AHCI_PREG_IS_OFS |
2228                                                  AHCI_PREG_IS_UFS;
2229
2230         enum { NEED_NOTHING, NEED_RESTART, NEED_HOTPLUG_INSERT,
2231                NEED_HOTPLUG_REMOVE } need = NEED_NOTHING;
2232
2233         is = ahci_pread(ap, AHCI_PREG_IS);
2234
2235         /*
2236          * All basic command completions are always processed.
2237          */
2238         if (is & AHCI_PREG_IS_DPS)
2239                 ahci_pwrite(ap, AHCI_PREG_IS, is & AHCI_PREG_IS_DPS);
2240
2241         /*
2242          * If we can't block then we can't handle these here.  Disable
2243          * the interrupts in question so we don't live-lock, the helper
2244          * thread will re-enable them.
2245          *
2246          * If the port is in a completely failed state we do not want
2247          * to drop through to failed-command-processing if blockable is 0,
2248          * just let the thread deal with it all.
2249          *
2250          * Otherwise we fall through and still handle DHRS and any commands
2251          * which completed normally.  Even if we are errored we haven't
2252          * stopped the port yet so CI/SACT are still good.
2253          */
2254         if (blockable == 0) {
2255                 if (ap->ap_state == AP_S_FATAL_ERROR) {
2256                         ahci_pwrite(ap, AHCI_PREG_IE,
2257                                     ahci_pread(ap, AHCI_PREG_IE) & ~is);
2258                         ahci_os_signal_port_thread(ap, AP_SIGF_PORTINT);
2259                         return;
2260                 }
2261                 if (is & blockable_mask) {
2262                         ahci_pwrite(ap, AHCI_PREG_IE,
2263                             ahci_pread(ap, AHCI_PREG_IE) & ~blockable_mask);
2264                         is &= ~blockable_mask;
2265                         ahci_os_signal_port_thread(ap, AP_SIGF_PORTINT);
2266                 }
2267         }
2268
2269 #if 0
2270         kprintf("%s: INTERRUPT %b\n", PORTNAME(ap),
2271                 is, AHCI_PFMT_IS);
2272 #endif
2273
2274         /*
2275          * Either NCQ or non-NCQ commands will be active, never both.
2276          */
2277         if (ap->ap_sactive) {
2278                 KKASSERT(ap->ap_active == 0);
2279                 KKASSERT(ap->ap_active_cnt == 0);
2280                 ci_saved = ahci_pread(ap, AHCI_PREG_SACT);
2281                 active = &ap->ap_sactive;
2282         } else {
2283                 ci_saved = ahci_pread(ap, AHCI_PREG_CI);
2284                 active = &ap->ap_active;
2285         }
2286
2287         if (is & AHCI_PREG_IS_TFES) {
2288                 /*
2289                  * Command failed (blockable).
2290                  *
2291                  * See AHCI 1.1 spec 6.2.2.1 and 6.2.2.2.
2292                  *
2293                  * This stops command processing.
2294                  */
2295                 u_int32_t tfd, serr;
2296                 int     err_slot;
2297
2298                 tfd = ahci_pread(ap, AHCI_PREG_TFD);
2299                 serr = ahci_pread(ap, AHCI_PREG_SERR);
2300
2301                 /*
2302                  * If no NCQ commands are active the error slot is easily
2303                  * determined, otherwise we have to extract the error
2304                  * from the log page.
2305                  */
2306                 if (ap->ap_sactive == 0) {
2307                         err_slot = AHCI_PREG_CMD_CCS(
2308                                         ahci_pread(ap, AHCI_PREG_CMD));
2309                         ccb = &ap->ap_ccbs[err_slot];
2310                         ccb_at = ccb->ccb_xa.at;        /* can be NULL */
2311
2312                         /* Preserve received taskfile data from the RFIS. */
2313                         memcpy(&ccb->ccb_xa.rfis, ap->ap_rfis->rfis,
2314                                sizeof(struct ata_fis_d2h));
2315                 } else {
2316                         err_slot = -1;
2317                 }
2318
2319                 DPRINTF(AHCI_D_VERBOSE, "%s: errd slot %d, TFD: %b, SERR: %b\n",
2320                         PORTNAME(ap), err_slot,
2321                         tfd, AHCI_PFMT_TFD_STS,
2322                         serr, AHCI_PFMT_SERR);
2323
2324                 /* Stopping the port clears CI and SACT */
2325                 ahci_port_stop(ap, 0);
2326                 need = NEED_RESTART;
2327
2328                 /*
2329                  * Clear SERR (primarily DIAG_X) to enable capturing of the
2330                  * next error.
2331                  */
2332                 ahci_pwrite(ap, AHCI_PREG_SERR, serr);
2333
2334                 /* Acknowledge the interrupts we can recover from. */
2335                 ahci_pwrite(ap, AHCI_PREG_IS,
2336                             is & (AHCI_PREG_IS_TFES | AHCI_PREG_IS_IFS));
2337                 is &= ~(AHCI_PREG_IS_TFES | AHCI_PREG_IS_IFS);
2338
2339                 /* If device hasn't cleared its busy status, try to idle it. */
2340                 if (tfd & (AHCI_PREG_TFD_STS_BSY | AHCI_PREG_TFD_STS_DRQ)) {
2341                         kprintf("%s: Attempting to idle device ccb=%p\n",
2342                                 PORTNAME(ap), ccb_at);
2343                         if (ap->ap_flags & AP_F_IN_RESET)
2344                                 goto fatal;
2345                         /*
2346                          * XXX how do we unbrick a PM target (ccb_at != NULL).
2347                          *
2348                          * For now fail the target and use CLO to clear the
2349                          * busy condition and make the ahci port usable for
2350                          * the remaining devices.
2351                          */
2352                         if (ccb_at) {
2353                                 ccb_at->at_probe = ATA_PROBE_FAILED;
2354                                 ahci_port_clo(ap);
2355                         } else if (ahci_port_reset(ap, ccb_at, 0)) {
2356                                 kprintf("%s: Unable to idle device, port "
2357                                         "bricked on us\n",
2358                                         PORTNAME(ap));
2359                                 goto fatal;
2360                         }
2361
2362                         /* Had to reset device, can't gather extended info. */
2363                 } else if (ap->ap_sactive) {
2364                         /*
2365                          * Recover the NCQ error from log page 10h.
2366                          *
2367                          * XXX NCQ currently not supported with port
2368                          *     multiplier.
2369                          */
2370                         ahci_port_read_ncq_error(ap, &err_slot);
2371                         kprintf("recover from NCQ error err_slot %d\n",
2372                                 err_slot);
2373                         if (err_slot < 0)
2374                                 goto failall;
2375
2376                         DPRINTF(AHCI_D_VERBOSE, "%s: NCQ errored slot %d\n",
2377                                 PORTNAME(ap), err_slot);
2378
2379                         ccb = &ap->ap_ccbs[err_slot];
2380                 } else {
2381                         /* Didn't reset, could gather extended info from log. */
2382                         kprintf("%s: didn't reset err_slot %d "
2383                                 "sact=%08x act=%08x\n",
2384                                 PORTNAME(ap),
2385                                 err_slot, ap->ap_sactive, ap->ap_active);
2386                 }
2387
2388                 /*
2389                  * If we couldn't determine the errored slot, reset the port
2390                  * and fail all the active slots.
2391                  */
2392                 if (err_slot == -1) {
2393                         if (ap->ap_flags & AP_F_IN_RESET)
2394                                 goto fatal;
2395                         /*
2396                          * XXX how do we unbrick a PM target (ccb_at != NULL).
2397                          *
2398                          * For now fail the target and use CLO to clear the
2399                          * busy condition and make the ahci port usable for
2400                          * the remaining devices.
2401                          */
2402                         if (ccb_at) {
2403                                 ccb_at->at_probe = ATA_PROBE_FAILED;
2404                                 ahci_port_clo(ap);
2405                         } else if (ahci_port_reset(ap, ccb_at, 0)) {
2406                                 kprintf("%s: Unable to idle device after "
2407                                         "NCQ error, port bricked on us\n",
2408                                         PORTNAME(ap));
2409                                 goto fatal;
2410                         }
2411                         kprintf("%s: couldn't recover NCQ error, failing "
2412                                 "all outstanding commands.\n",
2413                                 PORTNAME(ap));
2414                         goto failall;
2415                 }
2416
2417                 /* Clear the failed command in saved CI so completion runs. */
2418                 ci_saved &= ~(1 << err_slot);
2419
2420                 /* Note the error in the ata_xfer. */
2421                 KKASSERT(ccb->ccb_xa.state == ATA_S_ONCHIP);
2422                 ccb->ccb_xa.state = ATA_S_ERROR;
2423
2424 #ifdef DIAGNOSTIC
2425                 /* There may only be one outstanding standard command now. */
2426                 if (ap->ap_sactive == 0) {
2427                         tmp = ci_saved;
2428                         if (tmp) {
2429                                 slot = ffs(tmp) - 1;
2430                                 tmp &= ~(1 << slot);
2431                                 KKASSERT(tmp == 0);
2432                         }
2433                 }
2434 #endif
2435         } else if (is & AHCI_PREG_IS_DHRS) {
2436                 /*
2437                  * Command posted D2H register FIS to the rfis (non-blocking).
2438                  *
2439                  * Command posted D2H register FIS to the rfis.  This
2440                  * does NOT stop command processing and it is unclear
2441                  * how we are supposed to deal with it other then using
2442                  * only a queue of 1.
2443                  *
2444                  * We must copy the port rfis to the ccb and restart
2445                  * command processing.  ahci_pm_read() does not function
2446                  * without this support.
2447                  */
2448                 int     err_slot;
2449
2450                 if (ap->ap_sactive == 0) {
2451                         err_slot = AHCI_PREG_CMD_CCS(
2452                                         ahci_pread(ap, AHCI_PREG_CMD));
2453                         ccb = &ap->ap_ccbs[err_slot];
2454                         ccb_at = ccb->ccb_xa.at;        /* can be NULL */
2455
2456                         memcpy(&ccb->ccb_xa.rfis, ap->ap_rfis->rfis,
2457                                sizeof(struct ata_fis_d2h));
2458                 } else {
2459                         kprintf("%s: Unexpected DHRS posted while "
2460                                 "NCQ running\n", PORTNAME(ap));
2461                         err_slot = -1;
2462                 }
2463                 ahci_pwrite(ap, AHCI_PREG_IS, AHCI_PREG_IS_DHRS);
2464                 is &= ~AHCI_PREG_IS_DHRS;
2465         }
2466
2467         /*
2468          * Device notification to us (non-blocking)
2469          *
2470          * NOTE!  On some parts notification bits can get set without
2471          *        generating an interrupt.  It is unclear whether this is
2472          *        a bug in the PM (sending a DTOH device setbits with 'N' set
2473          *        and 'I' not set), or a bug in the host controller.
2474          *
2475          *        It only seems to occur under load.
2476          */
2477         if (/*(is & AHCI_PREG_IS_SDBS) &&*/ (sc->sc_cap & AHCI_REG_CAP_SSNTF)) {
2478                 u_int32_t data;
2479                 const char *xstr;
2480
2481                 data = ahci_pread(ap, AHCI_PREG_SNTF);
2482                 if (is & AHCI_PREG_IS_SDBS) {
2483                         ahci_pwrite(ap, AHCI_PREG_IS, AHCI_PREG_IS_SDBS);
2484                         is &= ~AHCI_PREG_IS_SDBS;
2485                         xstr = " (no SDBS!)";
2486                 } else {
2487                         xstr = "";
2488                 }
2489                 if (data) {
2490                         ahci_pwrite(ap, AHCI_PREG_IS, AHCI_PREG_IS_SDBS);
2491
2492                         kprintf("%s: NOTIFY %08x%s\n",
2493                                 PORTNAME(ap), data, xstr);
2494                         ahci_pwrite(ap, AHCI_PREG_SERR, AHCI_PREG_SERR_DIAG_N);
2495                         ahci_pwrite(ap, AHCI_PREG_SNTF, data);
2496                         ahci_cam_changed(ap, NULL, -1);
2497                 }
2498         }
2499
2500         /*
2501          * Spurious IFS errors (blockable).
2502          *
2503          * Spurious IFS errors can occur while we are doing a reset
2504          * sequence through a PM.  Try to recover if we are being asked
2505          * to ignore IFS errors during these periods.
2506          */
2507         if ((is & AHCI_PREG_IS_IFS) && (ap->ap_flags & AP_F_IGNORE_IFS)) {
2508                 u_int32_t serr = ahci_pread(ap, AHCI_PREG_SERR);
2509                 if ((ap->ap_flags & AP_F_IFS_IGNORED) == 0) {
2510                         kprintf("%s: Ignoring IFS (XXX) (IS: %b, SERR: %b)\n",
2511                                 PORTNAME(ap),
2512                                 is, AHCI_PFMT_IS,
2513                                 serr, AHCI_PFMT_SERR);
2514                         ap->ap_flags |= AP_F_IFS_IGNORED;
2515                 }
2516                 ap->ap_flags |= AP_F_IFS_OCCURED;
2517                 ahci_pwrite(ap, AHCI_PREG_SERR, -1);
2518                 ahci_pwrite(ap, AHCI_PREG_IS, AHCI_PREG_IS_IFS);
2519                 is &= ~AHCI_PREG_IS_IFS;
2520                 ahci_port_stop(ap, 0);
2521                 ahci_port_start(ap);
2522                 need = NEED_RESTART;
2523         }
2524
2525         /*
2526          * Port change (hot-plug) (blockable).
2527          *
2528          * A PCS interrupt will occur on hot-plug once communication is
2529          * established.
2530          *
2531          * A PRCS interrupt will occur on hot-unplug (and possibly also
2532          * on hot-plug).
2533          *
2534          * XXX We can then check the CPS (Cold Presence State) bit, if
2535          * supported, to determine if a device is plugged in or not and do
2536          * the right thing.
2537          *
2538          * WARNING:  A PCS interrupt is cleared by clearing DIAG_X, and
2539          *           can also occur if an unsolicited COMINIT is received.
2540          *           If this occurs command processing is automatically
2541          *           stopped (CR goes inactive) and the port must be stopped
2542          *           and restarted.
2543          */
2544         if (is & (AHCI_PREG_IS_PCS | AHCI_PREG_IS_PRCS)) {
2545                 ahci_pwrite(ap, AHCI_PREG_IS,
2546                             is & (AHCI_PREG_IS_PCS | AHCI_PREG_IS_PRCS));
2547                 is &= ~(AHCI_PREG_IS_PCS | AHCI_PREG_IS_PRCS);
2548                 ahci_pwrite(ap, AHCI_PREG_SERR,
2549                         (AHCI_PREG_SERR_DIAG_N | AHCI_PREG_SERR_DIAG_X));
2550                 ahci_port_stop(ap, 0);
2551                 switch (ahci_pread(ap, AHCI_PREG_SSTS) & AHCI_PREG_SSTS_DET) {
2552                 case AHCI_PREG_SSTS_DET_DEV:
2553                         if (ap->ap_type == ATA_PORT_T_NONE) {
2554                                 need = NEED_HOTPLUG_INSERT;
2555                                 goto fatal;
2556                         }
2557                         need = NEED_RESTART;
2558                         break;
2559                 default:
2560                         if (ap->ap_type != ATA_PORT_T_NONE) {
2561                                 need = NEED_HOTPLUG_REMOVE;
2562                                 goto fatal;
2563                         }
2564                         need = NEED_RESTART;
2565                         break;
2566                 }
2567         }
2568
2569         /*
2570          * Check for remaining errors - they are fatal. (blockable)
2571          */
2572         if (is & (AHCI_PREG_IS_TFES | AHCI_PREG_IS_HBFS | AHCI_PREG_IS_IFS |
2573                   AHCI_PREG_IS_OFS | AHCI_PREG_IS_UFS)) {
2574                 u_int32_t serr;
2575
2576                 ahci_pwrite(ap, AHCI_PREG_IS,
2577                             is & (AHCI_PREG_IS_TFES | AHCI_PREG_IS_HBFS |
2578                                   AHCI_PREG_IS_IFS | AHCI_PREG_IS_OFS |
2579                                   AHCI_PREG_IS_UFS));
2580                 serr = ahci_pread(ap, AHCI_PREG_SERR);
2581                 kprintf("%s: Unrecoverable errors (IS: %b, SERR: %b), "
2582                         "disabling port.\n",
2583                         PORTNAME(ap),
2584                         is, AHCI_PFMT_IS,
2585                         serr, AHCI_PFMT_SERR
2586                 );
2587                 is &= ~(AHCI_PREG_IS_TFES | AHCI_PREG_IS_HBFS |
2588                         AHCI_PREG_IS_IFS | AHCI_PREG_IS_OFS |
2589                         AHCI_PREG_IS_UFS);
2590                 /* XXX try recovery first */
2591                 goto fatal;
2592         }
2593
2594         /*
2595          * Fail all outstanding commands if we know the port won't recover.
2596          *
2597          * We may have a ccb_at if the failed command is known and was
2598          * being sent to a device over a port multiplier (PM).  In this
2599          * case if the port itself has not completely failed we fail just
2600          * the commands related to that target.
2601          */
2602         if (ap->ap_state == AP_S_FATAL_ERROR) {
2603 fatal:
2604                 ap->ap_state = AP_S_FATAL_ERROR;
2605 failall:
2606
2607                 /* Stopping the port clears CI/SACT */
2608                 ahci_port_stop(ap, 0);
2609
2610                 /*
2611                  * Error all the active slots.  If running across a PM
2612                  * try to error out just the slots related to the target.
2613                  */
2614                 ci_masked = ci_saved & *active;
2615                 while (ci_masked) {
2616                         slot = ffs(ci_masked) - 1;
2617                         ccb = &ap->ap_ccbs[slot];
2618                         if (ccb_at == ccb->ccb_xa.at ||
2619                             ap->ap_state == AP_S_FATAL_ERROR) {
2620                                 ci_masked &= ~(1 << slot);
2621                                 ccb->ccb_xa.state = ATA_S_ERROR;
2622                         }
2623                 }
2624
2625                 /* Run completion for all active slots. */
2626                 ci_saved &= ~*active;
2627
2628                 /*
2629                  * Don't restart the port if our problems were deemed fatal.
2630                  *
2631                  * Also acknowlege all fatal interrupt sources to prevent
2632                  * a livelock.
2633                  */
2634                 if (ap->ap_state == AP_S_FATAL_ERROR) {
2635                         if (need == NEED_RESTART)
2636                                 need = NEED_NOTHING;
2637                         ahci_pwrite(ap, AHCI_PREG_IS,
2638                                     AHCI_PREG_IS_TFES | AHCI_PREG_IS_HBFS |
2639                                     AHCI_PREG_IS_IFS | AHCI_PREG_IS_OFS |
2640                                     AHCI_PREG_IS_UFS);
2641                 }
2642         }
2643
2644         /*
2645          * CCB completion (non blocking).
2646          *
2647          * CCB completion is detected by noticing its slot's bit in CI has
2648          * changed to zero some time after we activated it.
2649          * If we are polling, we may only be interested in particular slot(s).
2650          *
2651          * Any active bits not saved are completed within the restrictions
2652          * imposed by the caller.
2653          */
2654         ci_masked = ~ci_saved & *active;
2655         while (ci_masked) {
2656                 slot = ffs(ci_masked) - 1;
2657                 ccb = &ap->ap_ccbs[slot];
2658                 ci_masked &= ~(1 << slot);
2659
2660                 DPRINTF(AHCI_D_INTR, "%s: slot %d is complete%s\n",
2661                     PORTNAME(ap), slot, ccb->ccb_xa.state == ATA_S_ERROR ?
2662                     " (error)" : "");
2663
2664                 bus_dmamap_sync(sc->sc_tag_cmdh,
2665                                 AHCI_DMA_MAP(ap->ap_dmamem_cmd_list),
2666                                 BUS_DMASYNC_POSTWRITE);
2667
2668                 bus_dmamap_sync(sc->sc_tag_cmdt,
2669                                 AHCI_DMA_MAP(ap->ap_dmamem_cmd_table),
2670                                 BUS_DMASYNC_POSTWRITE);
2671
2672                 bus_dmamap_sync(sc->sc_tag_rfis,
2673                                 AHCI_DMA_MAP(ap->ap_dmamem_rfis),
2674                                 BUS_DMASYNC_POSTREAD);
2675
2676                 *active &= ~(1 << ccb->ccb_slot);
2677                 if (active == &ap->ap_active) {
2678                         KKASSERT(ap->ap_active_cnt > 0);
2679                         --ap->ap_active_cnt;
2680                 }
2681                 ccb->ccb_done(ccb);
2682         }
2683
2684         /*
2685          * Cleanup.  Will not be set if non-blocking.
2686          */
2687         switch(need) {
2688         case NEED_RESTART:
2689                 /*
2690                  * A recoverable error occured and we can restart outstanding
2691                  * commands on the port.
2692                  */
2693                 ahci_port_start(ap);
2694
2695                 if (ci_saved) {
2696 #ifdef DIAGNOSTIC
2697                         tmp = ci_saved;
2698                         while (tmp) {
2699                                 slot = ffs(tmp) - 1;
2700                                 tmp &= ~(1 << slot);
2701                                 ccb = &ap->ap_ccbs[slot];
2702                                 KKASSERT(ccb->ccb_xa.state == ATA_S_ONCHIP);
2703                                 KKASSERT((!!(ccb->ccb_xa.flags & ATA_F_NCQ)) ==
2704                                     (!!ap->ap_sactive));
2705                         }
2706 #endif
2707                         DPRINTF(AHCI_D_VERBOSE, "%s: ahci_port_intr "
2708                             "re-enabling%s slots %08x\n", PORTNAME(ap),
2709                             ap->ap_sactive ? " NCQ" : "", ci_saved);
2710
2711                         if (ap->ap_sactive)
2712                                 ahci_pwrite(ap, AHCI_PREG_SACT, ci_saved);
2713                         ahci_pwrite(ap, AHCI_PREG_CI, ci_saved);
2714                 }
2715                 break;
2716         case NEED_HOTPLUG_INSERT:
2717                 /*
2718                  * A hot-plug insertion event has occured and all
2719                  * outstanding commands have already been revoked.
2720                  *
2721                  * Don't recurse if this occurs while we are
2722                  * resetting the port.
2723                  */
2724                 if ((ap->ap_flags & AP_F_IN_RESET) == 0) {
2725                         kprintf("%s: HOTPLUG - Device inserted\n",
2726                                 PORTNAME(ap));
2727                         ap->ap_probe = ATA_PROBE_NEED_INIT;
2728                         ahci_cam_changed(ap, NULL, -1);
2729                 }
2730                 break;
2731         case NEED_HOTPLUG_REMOVE:
2732                 /*
2733                  * A hot-plug removal event has occured and all
2734                  * outstanding commands have already been revoked.
2735                  *
2736                  * Don't recurse if this occurs while we are
2737                  * resetting the port.
2738                  */
2739                 if ((ap->ap_flags & AP_F_IN_RESET) == 0) {
2740                         kprintf("%s: HOTPLUG - Device removed\n",
2741                                 PORTNAME(ap));
2742                         ahci_port_hardstop(ap);
2743                         /* ap_probe set to failed */
2744                         ahci_cam_changed(ap, NULL, -1);
2745                 }
2746                 break;
2747         default:
2748                 break;
2749         }
2750 }
2751
2752 struct ahci_ccb *
2753 ahci_get_ccb(struct ahci_port *ap)
2754 {
2755         struct ahci_ccb                 *ccb;
2756
2757         lockmgr(&ap->ap_ccb_lock, LK_EXCLUSIVE);
2758         ccb = TAILQ_FIRST(&ap->ap_ccb_free);
2759         if (ccb != NULL) {
2760                 KKASSERT(ccb->ccb_xa.state == ATA_S_PUT);
2761                 TAILQ_REMOVE(&ap->ap_ccb_free, ccb, ccb_entry);
2762                 ccb->ccb_xa.state = ATA_S_SETUP;
2763                 ccb->ccb_xa.at = NULL;
2764         }
2765         lockmgr(&ap->ap_ccb_lock, LK_RELEASE);
2766
2767         return (ccb);
2768 }
2769
2770 void
2771 ahci_put_ccb(struct ahci_ccb *ccb)
2772 {
2773         struct ahci_port                *ap = ccb->ccb_port;
2774
2775 #ifdef DIAGNOSTIC
2776         if (ccb->ccb_xa.state != ATA_S_COMPLETE &&
2777             ccb->ccb_xa.state != ATA_S_TIMEOUT &&
2778             ccb->ccb_xa.state != ATA_S_ERROR) {
2779                 kprintf("%s: invalid ata_xfer state %02x in ahci_put_ccb, "
2780                         "slot %d\n",
2781                         PORTNAME(ccb->ccb_port), ccb->ccb_xa.state,
2782                         ccb->ccb_slot);
2783         }
2784 #endif
2785
2786         ccb->ccb_xa.state = ATA_S_PUT;
2787         lockmgr(&ap->ap_ccb_lock, LK_EXCLUSIVE);
2788         TAILQ_INSERT_TAIL(&ap->ap_ccb_free, ccb, ccb_entry);
2789         lockmgr(&ap->ap_ccb_lock, LK_RELEASE);
2790 }
2791
2792 struct ahci_ccb *
2793 ahci_get_err_ccb(struct ahci_port *ap)
2794 {
2795         struct ahci_ccb *err_ccb;
2796         u_int32_t sact;
2797
2798         /* No commands may be active on the chip. */
2799         sact = ahci_pread(ap, AHCI_PREG_SACT);
2800         if (sact != 0)
2801                 kprintf("ahci_get_err_ccb but SACT %08x != 0?\n", sact);
2802         KKASSERT(ahci_pread(ap, AHCI_PREG_CI) == 0);
2803
2804 #ifdef DIAGNOSTIC
2805         KKASSERT(ap->ap_err_busy == 0);
2806         ap->ap_err_busy = 1;
2807 #endif
2808         /* Save outstanding command state. */
2809         ap->ap_err_saved_active = ap->ap_active;
2810         ap->ap_err_saved_active_cnt = ap->ap_active_cnt;
2811         ap->ap_err_saved_sactive = ap->ap_sactive;
2812
2813         /*
2814          * Pretend we have no commands outstanding, so that completions won't
2815          * run prematurely.
2816          */
2817         ap->ap_active = ap->ap_active_cnt = ap->ap_sactive = 0;
2818
2819         /*
2820          * Grab a CCB to use for error recovery.  This should never fail, as
2821          * we ask atascsi to reserve one for us at init time.
2822          */
2823         err_ccb = ap->ap_err_ccb;
2824         KKASSERT(err_ccb != NULL);
2825         err_ccb->ccb_xa.flags = 0;
2826         err_ccb->ccb_done = ahci_empty_done;
2827
2828         return err_ccb;
2829 }
2830
2831 void
2832 ahci_put_err_ccb(struct ahci_ccb *ccb)
2833 {
2834         struct ahci_port *ap = ccb->ccb_port;
2835         u_int32_t sact;
2836         u_int32_t ci;
2837
2838 #ifdef DIAGNOSTIC
2839         KKASSERT(ap->ap_err_busy);
2840 #endif
2841         /*
2842          * No commands may be active on the chip
2843          */
2844         sact = ahci_pread(ap, AHCI_PREG_SACT);
2845         if (sact) {
2846                 panic("ahci_port_err_ccb(%d) but SACT %08x != 0\n",
2847                       ccb->ccb_slot, sact);
2848         }
2849         ci = ahci_pread(ap, AHCI_PREG_CI);
2850         if (ci) {
2851                 panic("ahci_put_err_ccb(%d) but CI %08x != 0 "
2852                       "(act=%08x sact=%08x)\n",
2853                       ccb->ccb_slot, ci,
2854                       ap->ap_active, ap->ap_sactive);
2855         }
2856
2857         KKASSERT(ccb == ap->ap_err_ccb);
2858
2859         /* Restore outstanding command state */
2860         ap->ap_sactive = ap->ap_err_saved_sactive;
2861         ap->ap_active_cnt = ap->ap_err_saved_active_cnt;
2862         ap->ap_active = ap->ap_err_saved_active;
2863
2864 #ifdef DIAGNOSTIC
2865         ap->ap_err_busy = 0;
2866 #endif
2867 }
2868
2869 /*
2870  * Read log page to get NCQ error.
2871  *
2872  * NOTE: NCQ not currently supported on port multipliers. XXX
2873  */
2874 int
2875 ahci_port_read_ncq_error(struct ahci_port *ap, int *err_slotp)
2876 {
2877         struct ahci_ccb                 *ccb;
2878         struct ahci_cmd_hdr             *cmd_slot;
2879         u_int32_t                       cmd;
2880         struct ata_fis_h2d              *fis;
2881         int                             rc = EIO;
2882
2883         DPRINTF(AHCI_D_VERBOSE, "%s: read log page\n", PORTNAME(ap));
2884
2885         /* Save command register state. */
2886         cmd = ahci_pread(ap, AHCI_PREG_CMD) & ~AHCI_PREG_CMD_ICC;
2887
2888         /* Port should have been idled already.  Start it. */
2889         KKASSERT((cmd & AHCI_PREG_CMD_CR) == 0);
2890         ahci_port_start(ap);
2891
2892         /* Prep error CCB for READ LOG EXT, page 10h, 1 sector. */
2893         ccb = ahci_get_err_ccb(ap);
2894         ccb->ccb_xa.flags = ATA_F_NOWAIT | ATA_F_READ | ATA_F_POLL;
2895         ccb->ccb_xa.data = ap->ap_err_scratch;
2896         ccb->ccb_xa.datalen = 512;
2897         cmd_slot = ccb->ccb_cmd_hdr;
2898         bzero(ccb->ccb_cmd_table, sizeof(struct ahci_cmd_table));
2899
2900         fis = (struct ata_fis_h2d *)ccb->ccb_cmd_table->cfis;
2901         fis->type = ATA_FIS_TYPE_H2D;
2902         fis->flags = ATA_H2D_FLAGS_CMD;
2903         fis->command = ATA_C_READ_LOG_EXT;
2904         fis->lba_low = 0x10;            /* queued error log page (10h) */
2905         fis->sector_count = 1;          /* number of sectors (1) */
2906         fis->sector_count_exp = 0;
2907         fis->lba_mid = 0;               /* starting offset */
2908         fis->lba_mid_exp = 0;
2909         fis->device = 0;
2910
2911         cmd_slot->flags = htole16(5);   /* FIS length: 5 DWORDS */
2912
2913         if (ahci_load_prdt(ccb) != 0) {
2914                 rc = ENOMEM;    /* XXX caller must abort all commands */
2915                 goto err;
2916         }
2917
2918         ccb->ccb_xa.state = ATA_S_PENDING;
2919         if (ahci_poll(ccb, 1000, ahci_quick_timeout) != 0)
2920                 goto err;
2921
2922         rc = 0;
2923 err:
2924         /* Abort our command, if it failed, by stopping command DMA. */
2925         if (rc) {
2926                 kprintf("%s: log page read failed, slot %d was still active.\n",
2927                         PORTNAME(ap), ccb->ccb_slot);
2928         }
2929
2930         /* Done with the error CCB now. */
2931         ahci_unload_prdt(ccb);
2932         ahci_put_err_ccb(ccb);
2933
2934         /* Extract failed register set and tags from the scratch space. */
2935         if (rc == 0) {
2936                 struct ata_log_page_10h         *log;
2937                 int                             err_slot;
2938
2939                 log = (struct ata_log_page_10h *)ap->ap_err_scratch;
2940                 if (log->err_regs.type & ATA_LOG_10H_TYPE_NOTQUEUED) {
2941                         /* Not queued bit was set - wasn't an NCQ error? */
2942                         kprintf("%s: read NCQ error page, but not an NCQ "
2943                                 "error?\n",
2944                                 PORTNAME(ap));
2945                         rc = ESRCH;
2946                 } else {
2947                         /* Copy back the log record as a D2H register FIS. */
2948                         *err_slotp = err_slot = log->err_regs.type &
2949                             ATA_LOG_10H_TYPE_TAG_MASK;
2950
2951                         ccb = &ap->ap_ccbs[err_slot];
2952                         memcpy(&ccb->ccb_xa.rfis, &log->err_regs,
2953                             sizeof(struct ata_fis_d2h));
2954                         ccb->ccb_xa.rfis.type = ATA_FIS_TYPE_D2H;
2955                         ccb->ccb_xa.rfis.flags = 0;
2956                 }
2957         }
2958
2959         /* Restore saved CMD register state */
2960         ahci_pwrite(ap, AHCI_PREG_CMD, cmd);
2961
2962         return (rc);
2963 }
2964
2965 /*
2966  * Allocate memory for various structures DMAd by hardware.  The maximum
2967  * number of segments for these tags is 1 so the DMA memory will have a
2968  * single physical base address.
2969  */
2970 struct ahci_dmamem *
2971 ahci_dmamem_alloc(struct ahci_softc *sc, bus_dma_tag_t tag)
2972 {
2973         struct ahci_dmamem *adm;
2974         int     error;
2975
2976         adm = kmalloc(sizeof(*adm), M_DEVBUF, M_INTWAIT | M_ZERO);
2977
2978         error = bus_dmamem_alloc(tag, (void **)&adm->adm_kva,
2979                                  BUS_DMA_ZERO, &adm->adm_map);
2980         if (error == 0) {
2981                 adm->adm_tag = tag;
2982                 error = bus_dmamap_load(tag, adm->adm_map,
2983                                         adm->adm_kva,
2984                                         bus_dma_tag_getmaxsize(tag),
2985                                         ahci_dmamem_saveseg, &adm->adm_busaddr,
2986                                         0);
2987         }
2988         if (error) {
2989                 if (adm->adm_map) {
2990                         bus_dmamap_destroy(tag, adm->adm_map);
2991                         adm->adm_map = NULL;
2992                         adm->adm_tag = NULL;
2993                         adm->adm_kva = NULL;
2994                 }
2995                 kfree(adm, M_DEVBUF);
2996                 adm = NULL;
2997         }
2998         return (adm);
2999 }
3000
3001 static
3002 void
3003 ahci_dmamem_saveseg(void *info, bus_dma_segment_t *segs, int nsegs, int error)
3004 {
3005         KKASSERT(error == 0);
3006         KKASSERT(nsegs == 1);
3007         *(bus_addr_t *)info = segs->ds_addr;
3008 }
3009
3010
3011 void
3012 ahci_dmamem_free(struct ahci_softc *sc, struct ahci_dmamem *adm)
3013 {
3014         if (adm->adm_map) {
3015                 bus_dmamap_unload(adm->adm_tag, adm->adm_map);
3016                 bus_dmamap_destroy(adm->adm_tag, adm->adm_map);
3017                 adm->adm_map = NULL;
3018                 adm->adm_tag = NULL;
3019                 adm->adm_kva = NULL;
3020         }
3021         kfree(adm, M_DEVBUF);
3022 }
3023
3024 u_int32_t
3025 ahci_read(struct ahci_softc *sc, bus_size_t r)
3026 {
3027         bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4,
3028                           BUS_SPACE_BARRIER_READ);
3029         return (bus_space_read_4(sc->sc_iot, sc->sc_ioh, r));
3030 }
3031
3032 void
3033 ahci_write(struct ahci_softc *sc, bus_size_t r, u_int32_t v)
3034 {
3035         bus_space_write_4(sc->sc_iot, sc->sc_ioh, r, v);
3036         bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4,
3037                           BUS_SPACE_BARRIER_WRITE);
3038 }
3039
3040 u_int32_t
3041 ahci_pread(struct ahci_port *ap, bus_size_t r)
3042 {
3043         bus_space_barrier(ap->ap_sc->sc_iot, ap->ap_ioh, r, 4,
3044                           BUS_SPACE_BARRIER_READ);
3045         return (bus_space_read_4(ap->ap_sc->sc_iot, ap->ap_ioh, r));
3046 }
3047
3048 void
3049 ahci_pwrite(struct ahci_port *ap, bus_size_t r, u_int32_t v)
3050 {
3051         bus_space_write_4(ap->ap_sc->sc_iot, ap->ap_ioh, r, v);
3052         bus_space_barrier(ap->ap_sc->sc_iot, ap->ap_ioh, r, 4,
3053                           BUS_SPACE_BARRIER_WRITE);
3054 }
3055
3056 /*
3057  * Wait up to (timeout) milliseconds for the masked port register to
3058  * match the target.
3059  *
3060  * Timeout is in milliseconds.
3061  */
3062 int
3063 ahci_pwait_eq(struct ahci_port *ap, int timeout,
3064               bus_size_t r, u_int32_t mask, u_int32_t target)
3065 {
3066         int     t;
3067
3068         /*
3069          * Loop hard up to 100uS
3070          */
3071         for (t = 0; t < 100; ++t) {
3072                 if ((ahci_pread(ap, r) & mask) == target)
3073                         return (0);
3074                 ahci_os_hardsleep(1);   /* us */
3075         }
3076
3077         do {
3078                 timeout -= ahci_os_softsleep();
3079                 if ((ahci_pread(ap, r) & mask) == target)
3080                         return (0);
3081         } while (timeout > 0);
3082         return (1);
3083 }
3084
3085 int
3086 ahci_wait_ne(struct ahci_softc *sc, bus_size_t r, u_int32_t mask,
3087              u_int32_t target)
3088 {
3089         int     t;
3090
3091         /*
3092          * Loop hard up to 100uS
3093          */
3094         for (t = 0; t < 100; ++t) {
3095                 if ((ahci_read(sc, r) & mask) != target)
3096                         return (0);
3097                 ahci_os_hardsleep(1);   /* us */
3098         }
3099
3100         /*
3101          * And one millisecond the slow way
3102          */
3103         t = 1000;
3104         do {
3105                 t -= ahci_os_softsleep();
3106                 if ((ahci_read(sc, r) & mask) != target)
3107                         return (0);
3108         } while (t > 0);
3109
3110         return (1);
3111 }
3112
3113
3114 /*
3115  * Acquire an ata transfer.
3116  *
3117  * Pass a NULL at for direct-attached transfers, and a non-NULL at for
3118  * targets that go through the port multiplier.
3119  */
3120 struct ata_xfer *
3121 ahci_ata_get_xfer(struct ahci_port *ap, struct ata_port *at)
3122 {
3123         struct ahci_ccb         *ccb;
3124
3125         ccb = ahci_get_ccb(ap);
3126         if (ccb == NULL) {
3127                 DPRINTF(AHCI_D_XFER, "%s: ahci_ata_get_xfer: NULL ccb\n",
3128                     PORTNAME(ap));
3129                 return (NULL);
3130         }
3131
3132         DPRINTF(AHCI_D_XFER, "%s: ahci_ata_get_xfer got slot %d\n",
3133             PORTNAME(ap), ccb->ccb_slot);
3134
3135         ccb->ccb_xa.at = at;
3136         ccb->ccb_xa.fis->type = ATA_FIS_TYPE_H2D;
3137
3138         return (&ccb->ccb_xa);
3139 }
3140
3141 void
3142 ahci_ata_put_xfer(struct ata_xfer *xa)
3143 {
3144         struct ahci_ccb                 *ccb = (struct ahci_ccb *)xa;
3145
3146         DPRINTF(AHCI_D_XFER, "ahci_ata_put_xfer slot %d\n", ccb->ccb_slot);
3147
3148         ahci_put_ccb(ccb);
3149 }
3150
3151 int
3152 ahci_ata_cmd(struct ata_xfer *xa)
3153 {
3154         struct ahci_ccb                 *ccb = (struct ahci_ccb *)xa;
3155         struct ahci_cmd_hdr             *cmd_slot;
3156
3157         KKASSERT(xa->state == ATA_S_SETUP);
3158
3159         if (ccb->ccb_port->ap_state == AP_S_FATAL_ERROR)
3160                 goto failcmd;
3161 #if 0
3162         kprintf("%s: started std command %b ccb %d ccb_at %p %d\n",
3163                 ATANAME(ccb->ccb_port, ccb->ccb_xa.at),
3164                 ahci_pread(ccb->ccb_port, AHCI_PREG_CMD), AHCI_PFMT_CMD,
3165                 ccb->ccb_slot,
3166                 ccb->ccb_xa.at,
3167                 ccb->ccb_xa.at ? ccb->ccb_xa.at->at_target : -1);
3168 #endif
3169
3170         ccb->ccb_done = ahci_ata_cmd_done;
3171
3172         cmd_slot = ccb->ccb_cmd_hdr;
3173         cmd_slot->flags = htole16(5); /* FIS length (in DWORDs) */
3174         if (ccb->ccb_xa.at) {
3175                 cmd_slot->flags |= htole16(ccb->ccb_xa.at->at_target <<
3176                                            AHCI_CMD_LIST_FLAG_PMP_SHIFT);
3177         }
3178
3179         if (xa->flags & ATA_F_WRITE)
3180                 cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_W);
3181
3182         if (xa->flags & ATA_F_PACKET)
3183                 cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_A);
3184
3185         if (ahci_load_prdt(ccb) != 0)
3186                 goto failcmd;
3187
3188         xa->state = ATA_S_PENDING;
3189
3190         if (xa->flags & ATA_F_POLL)
3191                 return (ahci_poll(ccb, xa->timeout, ahci_ata_cmd_timeout));
3192
3193         crit_enter();
3194         KKASSERT((xa->flags & ATA_F_TIMEOUT_EXPIRED) == 0);
3195         xa->flags |= ATA_F_TIMEOUT_DESIRED;
3196         ahci_start(ccb);
3197         crit_exit();
3198         return (xa->state);
3199
3200 failcmd:
3201         crit_enter();
3202         xa->state = ATA_S_ERROR;
3203         xa->complete(xa);
3204         crit_exit();
3205         return (ATA_S_ERROR);
3206 }
3207
3208 void
3209 ahci_ata_cmd_done(struct ahci_ccb *ccb)
3210 {
3211         struct ata_xfer                 *xa = &ccb->ccb_xa;
3212
3213         /*
3214          * NOTE: callout does not lock port and may race us modifying
3215          * the flags, so make sure its stopped.
3216          */
3217         if (xa->flags & ATA_F_TIMEOUT_RUNNING) {
3218                 callout_stop(&ccb->ccb_timeout);
3219                 xa->flags &= ~ATA_F_TIMEOUT_RUNNING;
3220         }
3221         xa->flags &= ~(ATA_F_TIMEOUT_DESIRED | ATA_F_TIMEOUT_EXPIRED);
3222
3223         if (xa->state == ATA_S_ONCHIP || xa->state == ATA_S_ERROR) {
3224                 ahci_issue_pending_commands(ccb->ccb_port,
3225                                             xa->flags & ATA_F_NCQ);
3226         }
3227
3228         ahci_unload_prdt(ccb);
3229
3230         if (xa->state == ATA_S_ONCHIP)
3231                 xa->state = ATA_S_COMPLETE;
3232 #ifdef DIAGNOSTIC
3233         else if (xa->state != ATA_S_ERROR && xa->state != ATA_S_TIMEOUT)
3234                 kprintf("%s: invalid ata_xfer state %02x in ahci_ata_cmd_done, "
3235                         "slot %d\n",
3236                         PORTNAME(ccb->ccb_port), xa->state, ccb->ccb_slot);
3237 #endif
3238         if (xa->state != ATA_S_TIMEOUT)
3239                 xa->complete(xa);
3240 }
3241
3242 /*
3243  * Timeout from callout, MPSAFE - nothing can mess with the CCB's flags
3244  * while the callout is runing.
3245  *
3246  * We can't safely get the port lock here or delay, we could block
3247  * the callout thread.
3248  */
3249 static void
3250 ahci_ata_cmd_timeout_unserialized(void *arg)
3251 {
3252         struct ahci_ccb         *ccb = arg;
3253         struct ahci_port        *ap = ccb->ccb_port;
3254
3255         ccb->ccb_xa.flags &= ~ATA_F_TIMEOUT_RUNNING;
3256         ccb->ccb_xa.flags |= ATA_F_TIMEOUT_EXPIRED;
3257         ahci_os_signal_port_thread(ap, AP_SIGF_TIMEOUT);
3258 }
3259
3260 void
3261 ahci_ata_cmd_timeout(struct ahci_ccb *ccb)
3262 {
3263         struct ata_xfer         *xa = &ccb->ccb_xa;
3264         struct ahci_port        *ap = ccb->ccb_port;
3265         volatile u_int32_t      *active;
3266         int                     ccb_was_started, ncq_cmd;
3267         int                     status;
3268
3269         crit_enter();
3270         kprintf("%s: CMD TIMEOUT state=%d cmd-reg 0x%b\n"
3271                 "\tsactive=%08x active=%08x\n"
3272                 "\t   sact=%08x     ci=%08x\n",
3273                 ATANAME(ap, ccb->ccb_xa.at),
3274                 ccb->ccb_xa.state,
3275                 ahci_pread(ap, AHCI_PREG_CMD), AHCI_PFMT_CMD,
3276                 ap->ap_sactive, ap->ap_active,
3277                 ahci_pread(ap, AHCI_PREG_SACT),
3278                 ahci_pread(ap, AHCI_PREG_CI));
3279
3280         /*
3281          * NOTE: Timeout will not be running if the command was polled.
3282          *       If we got here at least one of these flags should be set.
3283          */
3284         KKASSERT(xa->flags & (ATA_F_POLL | ATA_F_TIMEOUT_DESIRED |
3285                               ATA_F_TIMEOUT_RUNNING));
3286         xa->flags &= ~(ATA_F_TIMEOUT_RUNNING | ATA_F_TIMEOUT_EXPIRED);
3287         ncq_cmd = (xa->flags & ATA_F_NCQ);
3288         active = ncq_cmd ? &ap->ap_sactive : &ap->ap_active;
3289
3290         if (ccb->ccb_xa.state == ATA_S_PENDING) {
3291                 DPRINTF(AHCI_D_TIMEOUT, "%s: command for slot %d timed out "
3292                     "before it got on chip\n", PORTNAME(ap), ccb->ccb_slot);
3293                 TAILQ_REMOVE(&ap->ap_ccb_pending, ccb, ccb_entry);
3294                 ccb_was_started = 0;
3295         } else if (ccb->ccb_xa.state != ATA_S_ONCHIP) {
3296                 DPRINTF(AHCI_D_TIMEOUT, "%s: command slot %d already "
3297                     "handled%s\n", PORTNAME(ap), ccb->ccb_slot,
3298                     (*active & (1 << ccb->ccb_slot)) ?
3299                     " but slot is still active?" : ".");
3300                 goto ret;
3301         } else if ((ahci_pread(ap, ncq_cmd ? AHCI_PREG_SACT : AHCI_PREG_CI) &
3302                     (1 << ccb->ccb_slot)) == 0 &&
3303                    (*active & (1 << ccb->ccb_slot))) {
3304                 kprintf("%s: ahci_port_intr() failed to detect "
3305                         "completed slot\n", ATANAME(ap, ccb->ccb_xa.at));
3306                 *active &= ~(1 << ccb->ccb_slot);
3307                 if (ncq_cmd == 0) {
3308                         KKASSERT(ap->ap_active_cnt > 0);
3309                         --ap->ap_active_cnt;
3310                 }
3311                 ccb->ccb_done(ccb);
3312                 goto ret;
3313         } else {
3314                 ccb_was_started = 1;
3315         }
3316
3317         /* Complete the slot with a timeout error. */
3318         ccb->ccb_xa.state = ATA_S_TIMEOUT;
3319         *active &= ~(1 << ccb->ccb_slot);
3320         if (ncq_cmd == 0) {
3321                 KKASSERT(ap->ap_active_cnt > 0);
3322                 --ap->ap_active_cnt;
3323         }
3324         DPRINTF(AHCI_D_TIMEOUT, "%s: run completion (1)\n", PORTNAME(ap));
3325         ccb->ccb_done(ccb);     /* This won't issue pending commands or run the
3326                                    atascsi completion. */
3327
3328         /* Reset port to abort running command. */
3329         if (ccb_was_started) {
3330                 DPRINTF(AHCI_D_TIMEOUT, "%s: resetting port to abort%s command "
3331                     "in slot %d, active %08x\n", PORTNAME(ap), ncq_cmd ? " NCQ"
3332                     : "", ccb->ccb_slot, *active);
3333                 /* XXX */
3334                 if (ccb->ccb_xa.at && ap->ap_type == ATA_PORT_T_PM) {
3335                         /* XXX how do we unbrick a PM target? */
3336                         kprintf("%s: PM target bricked and timed-out, "
3337                                 "disabling PM target but trying to "
3338                                 "leave the port intact\n",
3339                                 ATANAME(ap, ccb->ccb_xa.at));
3340                         ccb->ccb_xa.at->at_probe = ATA_PROBE_FAILED;
3341                         ahci_port_intr(ap, 1);
3342                         ahci_port_stop(ap, 0);
3343                         ahci_port_clo(ap);
3344                         ahci_port_start(ap);
3345                         status = 0;
3346                 } else if (ahci_port_reset(ap, ccb->ccb_xa.at, 0)) {
3347                         /*
3348                          * If the softreset failed place the port in a
3349                          * failed state and use ahci_port_intr() to cancel
3350                          * any remaining commands.
3351                          */
3352                         kprintf("%s: Unable to reset during timeout, port "
3353                                 "bricked on us\n",
3354                                 PORTNAME(ap));
3355                         ap->ap_state = AP_S_FATAL_ERROR;
3356                         ahci_port_intr(ap, 1);
3357                         status = 1;
3358                 } else {
3359                         status = 0;
3360                 }
3361                 if (status == 0) {
3362                         /*
3363                          * Restart any other commands that were aborted
3364                          * by the reset.
3365                          */
3366                         if (*active) {
3367                                 DPRINTF(AHCI_D_TIMEOUT, "%s: re-enabling%s slots "
3368                                     "%08x\n", PORTNAME(ap), ncq_cmd ? " NCQ" : "",
3369                                     *active);
3370                                 if (ncq_cmd)
3371                                         ahci_pwrite(ap, AHCI_PREG_SACT, *active);
3372                                 ahci_pwrite(ap, AHCI_PREG_CI, *active);
3373                         }
3374                 }
3375         }
3376
3377         /* Issue any pending commands now. */
3378         DPRINTF(AHCI_D_TIMEOUT, "%s: issue pending\n", PORTNAME(ap));
3379         if (ccb_was_started)
3380                 ahci_issue_pending_commands(ap, ncq_cmd);
3381         else if (ap->ap_active == 0)
3382                 ahci_issue_pending_ncq_commands(ap);
3383
3384         /* Complete the timed out ata_xfer I/O (may generate new I/O). */
3385         DPRINTF(AHCI_D_TIMEOUT, "%s: run completion (2)\n", PORTNAME(ap));
3386         xa->complete(xa);
3387
3388         DPRINTF(AHCI_D_TIMEOUT, "%s: splx\n", PORTNAME(ap));
3389 ret:
3390         crit_exit();
3391 }
3392
3393 /*
3394  * Used by the softreset, pmprobe, and read_ncq_error only, in very
3395  * specialized, controlled circumstances.
3396  *
3397  * Only one command may be pending.
3398  */
3399 void
3400 ahci_quick_timeout(struct ahci_ccb *ccb)
3401 {
3402         struct ahci_port *ap = ccb->ccb_port;
3403
3404         switch (ccb->ccb_xa.state) {
3405         case ATA_S_PENDING:
3406                 TAILQ_REMOVE(&ap->ap_ccb_pending, ccb, ccb_entry);
3407                 ccb->ccb_xa.state = ATA_S_TIMEOUT;
3408                 break;
3409         case ATA_S_ONCHIP:
3410                 KKASSERT(ap->ap_active == (1 << ccb->ccb_slot) &&
3411                          ap->ap_sactive == 0);
3412                 ahci_port_stop(ap, 0);
3413                 ahci_port_start(ap);
3414
3415                 ccb->ccb_xa.state = ATA_S_TIMEOUT;
3416                 ap->ap_active &= ~(1 << ccb->ccb_slot);
3417                 KKASSERT(ap->ap_active_cnt > 0);
3418                 --ap->ap_active_cnt;
3419                 break;
3420         default:
3421                 panic("%s: ahci_quick_timeout: ccb in bad state %d",
3422                       ATANAME(ap, ccb->ccb_xa.at), ccb->ccb_xa.state);
3423         }
3424 }
3425
3426 void
3427 ahci_empty_done(struct ahci_ccb *ccb)
3428 {
3429         if (ccb->ccb_xa.state == ATA_S_ONCHIP)
3430                 ccb->ccb_xa.state = ATA_S_COMPLETE;
3431 }