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