586068188bfe7dbff798a059cdca1e0b17f23600
[dragonfly.git] / sys / dev / disk / sili / sili.c
1 /*
2  * Copyright (c) 2009 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  *
34  *
35  * Copyright (c) 2006 David Gwynne <dlg@openbsd.org>
36  *
37  * Permission to use, copy, modify, and distribute this software for any
38  * purpose with or without fee is hereby granted, provided that the above
39  * copyright notice and this permission notice appear in all copies.
40  *
41  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
42  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
43  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
44  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
45  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
46  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
47  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
48  *
49  *
50  *
51  * $OpenBSD: sili.c,v 1.147 2009/02/16 21:19:07 miod Exp $
52  */
53
54 #include "sili.h"
55
56 void    sili_port_interrupt_enable(struct sili_port *ap);
57 void    sili_port_interrupt_redisable(struct sili_port *ap);
58 void    sili_port_interrupt_reenable(struct sili_port *ap);
59
60 int     sili_load_prb(struct sili_ccb *);
61 void    sili_unload_prb(struct sili_ccb *);
62 static void sili_load_prb_callback(void *info, bus_dma_segment_t *segs,
63                                     int nsegs, int error);
64 void    sili_start(struct sili_ccb *);
65 int     sili_port_softreset(struct sili_port *ap);
66 int     sili_port_pmprobe(struct sili_port *ap);
67 int     sili_port_hardreset(struct sili_port *ap, int hard);
68 void    sili_port_hardstop(struct sili_port *ap);
69 void    sili_port_listen(struct sili_port *ap);
70
71 static void sili_ata_cmd_timeout_unserialized(void *);
72 static int sili_core_timeout(struct sili_ccb *ccb);
73 void    sili_quick_timeout(struct sili_ccb *ccb);
74 void    sili_check_active_timeouts(struct sili_port *ap);
75
76 void    sili_beg_exclusive_access(struct sili_port *ap, struct ata_port *at);
77 void    sili_end_exclusive_access(struct sili_port *ap, struct ata_port *at);
78 void    sili_issue_pending_commands(struct sili_port *ap, struct sili_ccb *ccb);
79
80 int     sili_port_read_ncq_error(struct sili_port *, int);
81
82 struct sili_dmamem *sili_dmamem_alloc(struct sili_softc *, bus_dma_tag_t tag);
83 void    sili_dmamem_free(struct sili_softc *, struct sili_dmamem *);
84 static void sili_dmamem_saveseg(void *info, bus_dma_segment_t *segs, int nsegs, int error);
85
86 static void sili_dummy_done(struct ata_xfer *xa);
87 static void sili_empty_done(struct sili_ccb *ccb);
88 static void sili_ata_cmd_done(struct sili_ccb *ccb);
89
90 /* Wait for all bits in _b to be cleared */
91 #define sili_pwait_clr(_ap, _r, _b) \
92         sili_pwait_eq((_ap), SILI_PWAIT_TIMEOUT, (_r), (_b), 0)
93 #define sili_pwait_clr_to(_ap, _to,  _r, _b) \
94         sili_pwait_eq((_ap), _to, (_r), (_b), 0)
95
96 /* Wait for all bits in _b to be set */
97 #define sili_pwait_set(_ap, _r, _b) \
98         sili_pwait_eq((_ap), SILI_PWAIT_TIMEOUT, (_r), (_b), (_b))
99 #define sili_pwait_set_to(_ap, _to, _r, _b) \
100         sili_pwait_eq((_ap), _to, (_r), (_b), (_b))
101
102 #define SILI_PWAIT_TIMEOUT      1000
103
104 /*
105  * Initialize the global SILI hardware.  This code does not set up any of
106  * its ports.
107  */
108 int
109 sili_init(struct sili_softc *sc)
110 {
111         DPRINTF(SILI_D_VERBOSE, " GHC 0x%b",
112                 sili_read(sc, SILI_REG_GHC), SILI_FMT_GHC);
113
114         /*
115          * Reset the entire chip.  This also resets all ports.
116          *
117          * The spec doesn't say anything about how long we have to
118          * wait, so wait 10ms.
119          */
120         sili_write(sc, SILI_REG_GCTL, SILI_REG_GCTL_GRESET);
121         sili_os_sleep(10);
122         sili_write(sc, SILI_REG_GCTL, 0);
123         sili_os_sleep(10);
124
125         return (0);
126 }
127
128 /*
129  * Allocate and initialize an SILI port.
130  */
131 int
132 sili_port_alloc(struct sili_softc *sc, u_int port)
133 {
134         struct sili_port        *ap;
135         struct ata_port         *at;
136         struct sili_prb         *prb;
137         struct sili_ccb         *ccb;
138         int     rc = ENOMEM;
139         int     error;
140         int     i;
141
142         ap = kmalloc(sizeof(*ap), M_DEVBUF, M_WAITOK | M_ZERO);
143
144         ksnprintf(ap->ap_name, sizeof(ap->ap_name), "%s%d.%d",
145                   device_get_name(sc->sc_dev),
146                   device_get_unit(sc->sc_dev),
147                   port);
148         sc->sc_ports[port] = ap;
149         kprintf("%s: allocate port\n", PORTNAME(ap));
150
151         /*
152          * Allocate enough so we never have to reallocate, it makes
153          * it easier.
154          *
155          * ap_pmcount will be reduced by the scan if we encounter the
156          * port multiplier port prior to target 15.
157          */
158         if (ap->ap_ata == NULL) {
159                 ap->ap_ata = kmalloc(sizeof(*ap->ap_ata) * SILI_MAX_PMPORTS,
160                                      M_DEVBUF, M_INTWAIT | M_ZERO);
161                 for (i = 0; i < SILI_MAX_PMPORTS; ++i) {
162                         at = &ap->ap_ata[i];
163                         at->at_sili_port = ap;
164                         at->at_target = i;
165                         at->at_probe = ATA_PROBE_NEED_INIT;
166                         at->at_features |= ATA_PORT_F_RESCAN;
167                         ksnprintf(at->at_name, sizeof(at->at_name),
168                                   "%s.%d", ap->ap_name, i);
169                 }
170         }
171         if (bus_space_subregion(sc->sc_piot, sc->sc_pioh,
172                                 SILI_PORT_REGION(port), SILI_PORT_SIZE,
173                                 &ap->ap_ioh) != 0) {
174                 device_printf(sc->sc_dev,
175                               "unable to create register window for port %d\n",
176                               port);
177                 goto freeport;
178         }
179
180         ap->ap_sc = sc;
181         ap->ap_num = port;
182         ap->ap_probe = ATA_PROBE_NEED_INIT;
183         TAILQ_INIT(&ap->ap_ccb_free);
184         TAILQ_INIT(&ap->ap_ccb_pending);
185         lockinit(&ap->ap_ccb_lock, "silipo", 0, 0);
186
187         /* Disable port interrupts */
188         sili_pwrite(ap, SILI_PREG_INT_DISABLE, SILI_PREG_INT_MASK);
189
190         /*
191          * Reset the port.  This is similar to a Device Reset but far
192          * more invasive.  We use Device Reset in our hardreset function.
193          * This function also does the same OOB initialization sequence
194          * that Device Reset does.
195          *
196          * NOTE: SILI_PREG_STATUS_READY will not be asserted unless and until
197          *       a device is connected to the port, so we can't use it to
198          *       verify that the port exists.
199          */
200         sili_pwrite(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_RESET);
201         if (sili_pread(ap, SILI_PREG_STATUS) & SILI_PREG_STATUS_READY) {
202                 device_printf(sc->sc_dev,
203                               "Port %d will not go into reset\n", port);
204                 goto freeport;
205         }
206         sili_os_sleep(10);
207         sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_RESUME);
208         sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_RESET);
209
210         /*
211          * Adjust FIFO thresholds to improve PCI-e use.
212          */
213         sili_pwrite(ap, SILI_PREG_FIFO_CTL,
214                 SILI_PREG_FIFO_CTL_ENCODE(1024, 1024));
215
216         /*
217          * Allocate the SGE Table
218          */
219         ap->ap_dmamem_prbs = sili_dmamem_alloc(sc, sc->sc_tag_prbs);
220         if (ap->ap_dmamem_prbs == NULL) {
221                 kprintf("%s: NOSGET\n", PORTNAME(ap));
222                 goto freeport;
223         }
224
225         /*
226          * Set up the SGE table base address
227          */
228         ap->ap_prbs = (struct sili_prb *)SILI_DMA_KVA(ap->ap_dmamem_prbs);
229
230         /*
231          * Allocate a CCB for each command slot
232          */
233         ap->ap_ccbs = kmalloc(sizeof(struct sili_ccb) * sc->sc_ncmds, M_DEVBUF,
234                               M_WAITOK | M_ZERO);
235         if (ap->ap_ccbs == NULL) {
236                 device_printf(sc->sc_dev,
237                               "unable to allocate command list for port %d\n",
238                               port);
239                 goto freeport;
240         }
241
242         /*
243          * Port control register setup.
244          */
245         sili_pwrite(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_NOAUTOCC);
246         sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_32BITDMA |
247                                            SILI_PREG_CTL_PMA |
248                                            SILI_PREG_CTL_NOAUTOCC);
249
250         /*
251          * Most structures are in the port BAR.  Assign convenient
252          * pointers in the CCBs
253          */
254
255         for (i = 0; i < sc->sc_ncmds; i++) {
256                 ccb = &ap->ap_ccbs[i];
257
258                 error = bus_dmamap_create(sc->sc_tag_data, BUS_DMA_ALLOCNOW,
259                                           &ccb->ccb_dmamap);
260                 if (error) {
261                         device_printf(sc->sc_dev,
262                                       "unable to create dmamap for port %d "
263                                       "ccb %d\n", port, i);
264                         goto freeport;
265                 }
266
267                 /*
268                  * WARNING!!!  Access to the rfis is only allowed under very
269                  *             carefully controlled circumstances because it
270                  *             is located in the LRAM and reading from the
271                  *             LRAM has hardware issues which can blow the
272                  *             port up.  I kid you not (from Linux, and
273                  *             verified by testing here).
274                  */
275                 callout_init(&ccb->ccb_timeout);
276                 ccb->ccb_slot = i;
277                 ccb->ccb_port = ap;
278                 ccb->ccb_prb = &ap->ap_prbs[i];
279                 ccb->ccb_prb_paddr = SILI_DMA_DVA(ap->ap_dmamem_prbs) +
280                                      sizeof(*ccb->ccb_prb) * i;
281                 ccb->ccb_xa.fis = &ccb->ccb_prb->prb_h2d;
282                 prb = bus_space_kva(ap->ap_sc->sc_iot, ap->ap_ioh,
283                                     SILI_PREG_LRAM_SLOT(i));
284                 ccb->ccb_xa.rfis = &prb->prb_d2h;
285                 ccb->ccb_xa.packetcmd = prb_packet(ccb->ccb_prb);
286                 ccb->ccb_xa.tag = i;
287
288                 ccb->ccb_xa.state = ATA_S_COMPLETE;
289
290                 /*
291                  * Reserve CCB[1] as the error CCB.  It doesn't matter
292                  * which one we use for the Sili controllers.
293                  */
294                 if (i == 1)
295                         ap->ap_err_ccb = ccb;
296                 else
297                         sili_put_ccb(ccb);
298         }
299         kprintf("%s: start port\n", PORTNAME(ap));
300         sili_os_start_port(ap);
301         return(0);
302 freeport:
303         sili_port_free(sc, port);
304         return (rc);
305 }
306
307 /*
308  * [re]initialize an idle port.  No CCBs should be active.
309  *
310  * If at is NULL we are initializing a directly connected port, otherwise
311  * we are indirectly initializing a port multiplier port.
312  *
313  * This function is called during the initial port allocation sequence
314  * and is also called on hot-plug insertion.  We take no chances and
315  * use a hardreset instead of a softreset.
316  *
317  * This function is the only way to move a failed port back to active
318  * status.
319  *
320  * Returns 0 if a device is successfully detected.
321  */
322 int
323 sili_port_init(struct sili_port *ap, struct ata_port *atx)
324 {
325         u_int32_t data;
326         int rc;
327
328         /*
329          * Clear all notification bits
330          */
331         if (atx == NULL && (ap->ap_sc->sc_flags & SILI_F_SSNTF))
332                 sili_pwrite(ap, SILI_PREG_SNTF, -1);
333
334         /*
335          * Make sure the port is out of continuous COMRESET mode.
336          */
337         data = SILI_PREG_SCTL_SPM_NONE |
338                SILI_PREG_SCTL_IPM_NONE |
339                SILI_PREG_SCTL_SPD_NONE |
340                SILI_PREG_SCTL_DET_NONE;
341         if (SiliForceGen1 & (1 << ap->ap_num)) {
342                 data &= ~SILI_PREG_SCTL_SPD_NONE;
343                 data |= SILI_PREG_SCTL_SPD_GEN1;
344         }
345         sili_pwrite(ap, SILI_PREG_SCTL, data);
346
347         /*
348          * Hard-reset the port.  If a device is detected but it is busy
349          * we try a second time, this time cycling the phy as well.
350          *
351          * XXX note: hard reset mode 2 (cycling the PHY) is not reliable.
352          */
353         if (atx)
354                 atx->at_probe = ATA_PROBE_NEED_HARD_RESET;
355         else
356                 ap->ap_probe = ATA_PROBE_NEED_HARD_RESET;
357
358         rc = sili_port_reset(ap, atx, 1);
359 #if 0
360         rc = sili_port_reset(ap, atx, 1);
361         if (rc == EBUSY) {
362                 rc = sili_port_reset(ap, atx, 2);
363         }
364 #endif
365
366         switch (rc) {
367         case ENODEV:
368                 /*
369                  * We had problems talking to the device on the port.
370                  */
371                 if (atx) {
372                         sili_pm_read(ap, atx->at_target,
373                                      SATA_PMREG_SSTS, &data);
374
375                         switch(data & SATA_PM_SSTS_DET) {
376                         case SATA_PM_SSTS_DET_DEV_NE:
377                                 kprintf("%s: Device not communicating\n",
378                                         ATANAME(ap, atx));
379                                 break;
380                         case SATA_PM_SSTS_DET_PHYOFFLINE:
381                                 kprintf("%s: PHY offline\n",
382                                         ATANAME(ap, atx));
383                                 break;
384                         default:
385                                 kprintf("%s: No device detected\n",
386                                         ATANAME(ap, atx));
387                                 break;
388                         }
389                 } else {
390                         data = sili_pread(ap, SILI_PREG_SSTS);
391
392                         switch(data & SATA_PM_SSTS_DET) {
393                         case SILI_PREG_SSTS_DET_DEV_NE:
394                                 kprintf("%s: Device not communicating\n",
395                                         ATANAME(ap, atx));
396                                 break;
397                         case SILI_PREG_SSTS_DET_OFFLINE:
398                                 kprintf("%s: PHY offline\n",
399                                         ATANAME(ap, atx));
400                                 break;
401                         default:
402                                 kprintf("%s: No device detected\n",
403                                         ATANAME(ap, atx));
404                                 break;
405                         }
406                 }
407                 break;
408
409         case EBUSY:
410                 /*
411                  * The device on the port is still telling us its busy,
412                  * which means that it is not properly handling a SATA
413                  * port COMRESET.
414                  *
415                  * It may be possible to softreset the device using CLO
416                  * and a device reset command.
417                  */
418                 if (atx) {
419                         kprintf("%s: Device on port is bricked, giving up\n",
420                                 ATANAME(ap, atx));
421                 } else {
422                         kprintf("%s: Device on port is bricked, "
423                                 "trying softreset\n", PORTNAME(ap));
424
425                         rc = sili_port_reset(ap, atx, 0);
426                         if (rc) {
427                                 kprintf("%s: Unable unbrick device\n",
428                                         PORTNAME(ap));
429                         } else {
430                                 kprintf("%s: Successfully unbricked\n",
431                                         PORTNAME(ap));
432                         }
433                 }
434                 break;
435
436         default:
437                 break;
438         }
439
440         /*
441          * Command transfers can only be enabled if a device was successfully
442          * detected.
443          *
444          * Allocate or deallocate the ap_ata array here too.
445          */
446         if (atx == NULL) {
447                 switch(ap->ap_type) {
448                 case ATA_PORT_T_NONE:
449                         ap->ap_pmcount = 0;
450                         break;
451                 case ATA_PORT_T_PM:
452                         /* already set */
453                         break;
454                 default:
455                         ap->ap_pmcount = 1;
456                         break;
457                 }
458         }
459
460         /*
461          * Flush interrupts on the port. XXX
462          *
463          * Enable interrupts on the port whether a device is sitting on
464          * it or not, to handle hot-plug events.
465          */
466         if (atx == NULL) {
467 #if 0
468                 sili_pwrite(ap, SILI_PREG_IS, sili_pread(ap, SILI_PREG_IS));
469                 sili_write(ap->ap_sc, SILI_REG_IS, 1 << ap->ap_num);
470 #endif
471                 sili_port_interrupt_enable(ap);
472         }
473         return(rc);
474 }
475
476 /*
477  * Handle an errored port.  This routine is called when the only
478  * commands left on the queue are expired, meaning we can safely
479  * go through a port init to clear its state.
480  *
481  * We complete the expired CCBs and then restart the queue.
482  */
483 static
484 void
485 sili_port_reinit(struct sili_port *ap)
486 {
487         struct sili_ccb *ccb;
488         struct ata_port *at;
489         int slot;
490         int target;
491         u_int32_t data;
492         int reentrant;
493
494         reentrant = (ap->ap_flags & AP_F_ERR_CCB_RESERVED) ? 1 : 0;
495
496         kprintf("%s: PORT REINIT AFTER ERROR reentrant=%d\n",
497                 PORTNAME(ap), reentrant);
498
499         /*
500          * Clear port resume, clear bits 16:13 in the port device status
501          * register.  This is from the data sheet.
502          *
503          * Data sheet does not specify a delay but it seems prudent.
504          */
505         sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_RESUME);
506         sili_os_sleep(10);
507         for (target = 0; target < SILI_MAX_PMPORTS; ++target) {
508                 data = sili_pread(ap, SILI_PREG_PM_STATUS(target));
509                 data &= ~(SILI_PREG_PM_STATUS_SERVICE |
510                           SILI_PREG_PM_STATUS_LEGACY |
511                           SILI_PREG_PM_STATUS_NATIVE |
512                           SILI_PREG_PM_STATUS_VBSY);
513                 sili_pwrite(ap, SILI_PREG_PM_STATUS(target), data);
514                 sili_pwrite(ap, SILI_PREG_PM_QACTIVE(target), 0);
515         }
516
517         /*
518          * Issue a Port Initialize and wait for it to clear.  This flushes
519          * commands but does not reset the port.  Then wait for port ready.
520          */
521         sili_pwrite(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_INIT);
522         if (sili_pwait_clr(ap, SILI_PREG_STATUS, SILI_PREG_CTL_INIT)) {
523                 kprintf("%s: Unable to reinit, port failed\n",
524                         PORTNAME(ap));
525         }
526         if (sili_pwait_set(ap, SILI_PREG_STATUS, SILI_PREG_STATUS_READY)) {
527                 kprintf("%s: Unable to reinit, port will not come ready\n",
528                         PORTNAME(ap));
529         }
530
531         /*
532          * Read the LOG ERROR page for targets that returned a specific
533          * D2H FIS with ERR set.
534          */
535         if (reentrant == 0) {
536                 for (target = 0; target < SILI_MAX_PMPORTS; ++target) {
537                         at = &ap->ap_ata[target];
538                         if (at->at_features & ATA_PORT_F_READLOG) {
539                                 kprintf("%s: READ LOG ERROR PAGE\n",
540                                         ATANAME(ap, at));
541                                 at->at_features &= ~ATA_PORT_F_READLOG;
542                                 sili_port_read_ncq_error(ap, target);
543                         }
544                 }
545         }
546
547         /*
548          * Finally clean out the expired commands, we've probed the error
549          * status (or hopefully probed the error status).  Well, ok,
550          * we probably didn't XXX.
551          */
552         while (ap->ap_expired) {
553                 slot = ffs(ap->ap_expired) - 1;
554                 ap->ap_expired &= ~(1 << slot);
555                 KKASSERT(ap->ap_active & (1 << slot));
556                 ap->ap_active &= ~(1 << slot);
557                 --ap->ap_active_cnt;
558                 ccb = &ap->ap_ccbs[slot];
559                 ccb->ccb_xa.state = ATA_S_TIMEOUT;
560                 kprintf("%s: reinit: kill slot %d\n",
561                         ATANAME(ap, ccb->ccb_xa.at), ccb->ccb_slot);
562                 ccb->ccb_done(ccb);
563                 ccb->ccb_xa.complete(&ccb->ccb_xa);
564         }
565
566         /*
567          * Wow.  All done.  We can get the port moving again.
568          */
569         if (reentrant) {
570                 kprintf("%s: reinit called reentrantly, skip end\n",
571                         PORTNAME(ap));
572         } else if (ap->ap_probe == ATA_PROBE_FAILED) {
573                 kprintf("%s: reinit failed, port is dead\n", PORTNAME(ap));
574                 while ((ccb = TAILQ_FIRST(&ap->ap_ccb_pending)) != NULL) {
575                         TAILQ_REMOVE(&ap->ap_ccb_pending, ccb, ccb_entry);
576                         ccb->ccb_xa.flags &= ~ATA_F_TIMEOUT_DESIRED;
577                         ccb->ccb_xa.state = ATA_S_TIMEOUT;
578                         ccb->ccb_done(ccb);
579                         ccb->ccb_xa.complete(&ccb->ccb_xa);
580                 }
581         } else {
582                 kprintf("%s: reinit succeeded probe=%d type=%d\n", PORTNAME(ap), ap->ap_probe, ap->ap_type);
583                 sili_issue_pending_commands(ap, NULL);
584         }
585         return;
586 }
587
588 /*
589  * Enable or re-enable interrupts on a port.
590  *
591  * This routine is called from the port initialization code or from the
592  * helper thread as the real interrupt may be forced to turn off certain
593  * interrupt sources.
594  */
595 void
596 sili_port_interrupt_enable(struct sili_port *ap)
597 {
598         u_int32_t data;
599
600         data =  SILI_PREG_INT_CCOMPLETE | SILI_PREG_INT_CERROR |
601                 SILI_PREG_INT_PHYRDYCHG | SILI_PREG_INT_DEVEXCHG |
602                 SILI_PREG_INT_DECODE | SILI_PREG_INT_CRC |
603                 SILI_PREG_INT_HANDSHK | SILI_PREG_INT_PMCHANGE;
604         if (ap->ap_sc->sc_flags & SILI_F_SSNTF)
605                 data |= SILI_PREG_INT_SDB;
606         sili_pwrite(ap, SILI_PREG_INT_ENABLE, data);
607 }
608
609 void
610 sili_port_interrupt_redisable(struct sili_port *ap)
611 {
612         u_int32_t data;
613
614         data = sili_read(ap->ap_sc, SILI_REG_GCTL);
615         data &= SILI_REG_GINT_PORTMASK;
616         data &= ~(1 << ap->ap_num);
617         sili_write(ap->ap_sc, SILI_REG_GCTL, data);
618 }
619
620 void
621 sili_port_interrupt_reenable(struct sili_port *ap)
622 {
623         u_int32_t data;
624
625         data = sili_read(ap->ap_sc, SILI_REG_GCTL);
626         data &= SILI_REG_GINT_PORTMASK;
627         data |= (1 << ap->ap_num);
628         sili_write(ap->ap_sc, SILI_REG_GCTL, data);
629 }
630
631 /*
632  * Run the port / target state machine from a main context.
633  *
634  * The state machine for the port is always run.
635  *
636  * If atx is non-NULL run the state machine for a particular target.
637  * If atx is NULL run the state machine for all targets.
638  */
639 void
640 sili_port_state_machine(struct sili_port *ap, int initial)
641 {
642         struct ata_port *at;
643         u_int32_t data;
644         int target;
645         int didsleep;
646         int loop;
647
648         /*
649          * State machine for port.  Note that CAM is not yet associated
650          * during the initial parallel probe and the port's probe state
651          * will not get past ATA_PROBE_NEED_IDENT.
652          */
653         {
654                 if (initial == 0 && ap->ap_probe <= ATA_PROBE_NEED_HARD_RESET) {
655                         kprintf("%s: Waiting 10 seconds on insertion\n",
656                                 PORTNAME(ap));
657                         sili_os_sleep(10000);
658                         initial = 1;
659                 }
660                 if (ap->ap_probe == ATA_PROBE_NEED_INIT)
661                         sili_port_init(ap, NULL);
662                 if (ap->ap_probe == ATA_PROBE_NEED_HARD_RESET)
663                         sili_port_reset(ap, NULL, 1);
664                 if (ap->ap_probe == ATA_PROBE_NEED_SOFT_RESET)
665                         sili_port_reset(ap, NULL, 0);
666                 if (ap->ap_probe == ATA_PROBE_NEED_IDENT)
667                         sili_cam_probe(ap, NULL);
668         }
669         if (ap->ap_type != ATA_PORT_T_PM) {
670                 if (ap->ap_probe == ATA_PROBE_FAILED) {
671                         sili_cam_changed(ap, NULL, 0);
672                 } else if (ap->ap_probe >= ATA_PROBE_NEED_IDENT) {
673                         sili_cam_changed(ap, NULL, 1);
674                 }
675                 return;
676         }
677
678         /*
679          * Port Multiplier state machine.
680          *
681          * Get a mask of changed targets and combine with any runnable
682          * states already present.
683          */
684         for (loop = 0; ;++loop) {
685                 if (sili_pm_read(ap, 15, SATA_PMREG_EINFO, &data)) {
686                         kprintf("%s: PM unable to read hot-plug bitmap\n",
687                                 PORTNAME(ap));
688                         break;
689                 }
690
691                 /*
692                  * Do at least one loop, then stop if no more state changes
693                  * have occured.  The PM might not generate a new
694                  * notification until we clear the entire bitmap.
695                  */
696                 if (loop && data == 0)
697                         break;
698
699                 /*
700                  * New devices showing up in the bitmap require some spin-up
701                  * time before we start probing them.  Reset didsleep.  The
702                  * first new device we detect will sleep before probing.
703                  *
704                  * This only applies to devices whos change bit is set in
705                  * the data, and does not apply to the initial boot-time
706                  * probe.
707                  */
708                 didsleep = 0;
709
710                 for (target = 0; target < ap->ap_pmcount; ++target) {
711                         at = &ap->ap_ata[target];
712
713                         /*
714                          * Check the target state for targets behind the PM
715                          * which have changed state.  This will adjust
716                          * at_probe and set ATA_PORT_F_RESCAN
717                          *
718                          * We want to wait at least 10 seconds before probing
719                          * a newly inserted device.  If the check status
720                          * indicates a device is present and in need of a
721                          * hard reset, we make sure we have slept before
722                          * continuing.
723                          *
724                          * We also need to wait at least 1 second for the
725                          * PHY state to change after insertion, if we
726                          * haven't already waited the 10 seconds.
727                          *
728                          * NOTE: When pm_check_good finds a good port it
729                          *       typically starts us in probe state
730                          *       NEED_HARD_RESET rather than INIT.
731                          */
732                         if (data & (1 << target)) {
733                                 if (initial == 0 && didsleep == 0)
734                                         sili_os_sleep(1000);
735                                 sili_pm_check_good(ap, target);
736                                 if (initial == 0 && didsleep == 0 &&
737                                     at->at_probe <= ATA_PROBE_NEED_HARD_RESET
738                                 ) {
739                                         didsleep = 1;
740                                         kprintf("%s: Waiting 10 seconds on insertion\n", PORTNAME(ap));
741                                         sili_os_sleep(10000);
742                                 }
743                         }
744
745                         /*
746                          * Report hot-plug events before the probe state
747                          * really gets hot.  Only actual events are reported
748                          * here to reduce spew.
749                          */
750                         if (data & (1 << target)) {
751                                 kprintf("%s: HOTPLUG (PM) - ", ATANAME(ap, at));
752                                 switch(at->at_probe) {
753                                 case ATA_PROBE_NEED_INIT:
754                                 case ATA_PROBE_NEED_HARD_RESET:
755                                         kprintf("Device inserted\n");
756                                         break;
757                                 case ATA_PROBE_FAILED:
758                                         kprintf("Device removed\n");
759                                         break;
760                                 default:
761                                         kprintf("Device probe in progress\n");
762                                         break;
763                                 }
764                         }
765
766                         /*
767                          * Run through the state machine as necessary if
768                          * the port is not marked failed.
769                          *
770                          * The state machine may stop at NEED_IDENT if
771                          * CAM is not yet attached.
772                          *
773                          * Acquire exclusive access to the port while we
774                          * are doing this.  This prevents command-completion
775                          * from queueing commands for non-polled targets
776                          * inbetween our probe steps.  We need to do this
777                          * because the reset probes can generate severe PHY
778                          * and protocol errors and soft-brick the port.
779                          */
780                         if (at->at_probe != ATA_PROBE_FAILED &&
781                             at->at_probe != ATA_PROBE_GOOD) {
782                                 sili_beg_exclusive_access(ap, at);
783                                 if (at->at_probe == ATA_PROBE_NEED_INIT)
784                                         sili_port_init(ap, at);
785                                 if (at->at_probe == ATA_PROBE_NEED_HARD_RESET)
786                                         sili_port_reset(ap, at, 1);
787                                 if (at->at_probe == ATA_PROBE_NEED_SOFT_RESET)
788                                         sili_port_reset(ap, at, 0);
789                                 if (at->at_probe == ATA_PROBE_NEED_IDENT)
790                                         sili_cam_probe(ap, at);
791                                 sili_end_exclusive_access(ap, at);
792                         }
793
794                         /*
795                          * Add or remove from CAM
796                          */
797                         if (at->at_features & ATA_PORT_F_RESCAN) {
798                                 at->at_features &= ~ATA_PORT_F_RESCAN;
799                                 if (at->at_probe == ATA_PROBE_FAILED) {
800                                         sili_cam_changed(ap, at, 0);
801                                 } else if (at->at_probe >= ATA_PROBE_NEED_IDENT) {
802                                         sili_cam_changed(ap, at, 1);
803                                 }
804                         }
805                         data &= ~(1 << target);
806                 }
807                 if (data) {
808                         kprintf("%s: WARNING (PM): extra bits set in "
809                                 "EINFO: %08x\n", PORTNAME(ap), data);
810                         while (target < SILI_MAX_PMPORTS) {
811                                 sili_pm_check_good(ap, target);
812                                 ++target;
813                         }
814                 }
815         }
816 }
817
818 /*
819  * De-initialize and detach a port.
820  */
821 void
822 sili_port_free(struct sili_softc *sc, u_int port)
823 {
824         struct sili_port                *ap = sc->sc_ports[port];
825         struct sili_ccb                 *ccb;
826
827         /*
828          * Ensure port is disabled and its interrupts are all flushed.
829          */
830         if (ap->ap_sc) {
831                 sili_os_stop_port(ap);
832                 sili_pwrite(ap, SILI_PREG_INT_DISABLE, SILI_PREG_INT_MASK);
833                 sili_pwrite(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_RESET);
834                 sili_write(ap->ap_sc, SILI_REG_GCTL,
835                         sili_read(ap->ap_sc, SILI_REG_GCTL) &
836                         ~SILI_REG_GINT_PORTST(ap->ap_num));
837         }
838
839         if (ap->ap_ccbs) {
840                 while ((ccb = sili_get_ccb(ap)) != NULL) {
841                         if (ccb->ccb_dmamap) {
842                                 bus_dmamap_destroy(sc->sc_tag_data,
843                                                    ccb->ccb_dmamap);
844                                 ccb->ccb_dmamap = NULL;
845                         }
846                 }
847                 if ((ccb = ap->ap_err_ccb) != NULL) {
848                         if (ccb->ccb_dmamap) {
849                                 bus_dmamap_destroy(sc->sc_tag_data,
850                                                    ccb->ccb_dmamap);
851                                 ccb->ccb_dmamap = NULL;
852                         }
853                         ap->ap_err_ccb = NULL;
854                 }
855                 kfree(ap->ap_ccbs, M_DEVBUF);
856                 ap->ap_ccbs = NULL;
857         }
858
859         if (ap->ap_dmamem_prbs) {
860                 sili_dmamem_free(sc, ap->ap_dmamem_prbs);
861                 ap->ap_dmamem_prbs = NULL;
862         }
863         if (ap->ap_ata) {
864                 kfree(ap->ap_ata, M_DEVBUF);
865                 ap->ap_ata = NULL;
866         }
867
868         /* bus_space(9) says we dont free the subregions handle */
869
870         kfree(ap, M_DEVBUF);
871         sc->sc_ports[port] = NULL;
872 }
873
874 /*
875  * Reset a port.
876  *
877  * If hard is 0 perform a softreset of the port.
878  * If hard is 1 perform a hard reset of the port.
879  * If hard is 2 perform a hard reset of the port and cycle the phy.
880  *
881  * If at is non-NULL an indirect port via a port-multiplier is being
882  * reset, otherwise a direct port is being reset.
883  *
884  * NOTE: Indirect ports can only be soft-reset.
885  */
886 int
887 sili_port_reset(struct sili_port *ap, struct ata_port *at, int hard)
888 {
889         int rc;
890
891         if (hard) {
892                 if (at)
893                         rc = sili_pm_hardreset(ap, at->at_target, hard);
894                 else
895                         rc = sili_port_hardreset(ap, hard);
896         } else {
897                 if (at)
898                         rc = sili_pm_softreset(ap, at->at_target);
899                 else
900                         rc = sili_port_softreset(ap);
901         }
902         return(rc);
903 }
904
905 /*
906  * SILI soft reset, Section 10.4.1
907  *
908  * (at) will be NULL when soft-resetting a directly-attached device, and
909  * non-NULL when soft-resetting a device through a port multiplier.
910  *
911  * This function keeps port communications intact and attempts to generate
912  * a reset to the connected device using device commands.
913  */
914 int
915 sili_port_softreset(struct sili_port *ap)
916 {
917         struct sili_ccb         *ccb = NULL;
918         struct sili_prb         *prb;
919         int                     error;
920         u_int32_t               sig;
921
922         error = EIO;
923
924         kprintf("%s: START SOFTRESET\n", PORTNAME(ap));
925
926         DPRINTF(SILI_D_VERBOSE, "%s: soft reset\n", PORTNAME(ap));
927
928         crit_enter();
929         ap->ap_state = AP_S_NORMAL;
930
931         /*
932          * Prep the special soft-reset SII command.
933          */
934         ccb = sili_get_err_ccb(ap);
935         ccb->ccb_done = sili_empty_done;
936         ccb->ccb_xa.flags = ATA_F_POLL;
937         ccb->ccb_xa.complete = sili_dummy_done;
938         ccb->ccb_xa.at = NULL;
939
940         prb = ccb->ccb_prb;
941         bzero(&prb->prb_h2d, sizeof(prb->prb_h2d));
942         prb->prb_h2d.flags = 0;
943         prb->prb_control = SILI_PRB_CTRL_SOFTRESET;
944         prb->prb_override = 0;
945
946         ccb->ccb_xa.state = ATA_S_PENDING;
947         ccb->ccb_xa.flags = 0;
948
949                                 /* XXX */
950         if (sili_poll(ccb, 8000, sili_quick_timeout) != ATA_S_COMPLETE) {
951                 kprintf("%s: First FIS failed\n", PORTNAME(ap));
952                 goto err;
953         }
954
955         sig = (prb->prb_d2h.lba_high << 24) |
956               (prb->prb_d2h.lba_mid << 16) |
957               (prb->prb_d2h.lba_low << 8) |
958               (prb->prb_d2h.sector_count);
959         kprintf("%s: SOFTRESET SIGNATURE %08x\n", PORTNAME(ap), sig);
960
961         /*
962          * If the softreset is trying to clear a BSY condition after a
963          * normal portreset we assign the port type.
964          *
965          * If the softreset is being run first as part of the ccb error
966          * processing code then report if the device signature changed
967          * unexpectedly.
968          */
969         if (ap->ap_type == ATA_PORT_T_NONE) {
970                 ap->ap_type = sili_port_signature(ap, NULL, sig);
971         } else {
972                 if (sili_port_signature(ap, NULL, sig) != ap->ap_type) {
973                         kprintf("%s: device signature unexpectedly "
974                                 "changed\n", PORTNAME(ap));
975                         error = EBUSY; /* XXX */
976                 }
977         }
978         error = 0;
979 err:
980         if (ccb != NULL) {
981                 sili_put_err_ccb(ccb);
982         }
983
984         /*
985          * If we failed to softreset make the port quiescent, otherwise
986          * make sure the port's start/stop state matches what it was on
987          * entry.
988          *
989          * Don't kill the port if the softreset is on a port multiplier
990          * target, that would kill all the targets!
991          */
992         kprintf("%s: END SOFTRESET %d prob=%d state=%d\n", PORTNAME(ap), error, ap->ap_probe, ap->ap_state);
993         if (error) {
994                 sili_port_hardstop(ap);
995                 /* ap_probe set to failed */
996         } else {
997                 ap->ap_probe = ATA_PROBE_NEED_IDENT;
998         }
999         crit_exit();
1000
1001         if (bootverbose)
1002                 kprintf("%s: END SOFTRESET\n", PORTNAME(ap));
1003
1004         return (error);
1005 }
1006
1007 /*
1008  * SILI port reset, Section 10.4.2
1009  *
1010  * This function does a hard reset of the port.  Note that the device
1011  * connected to the port could still end-up hung.
1012  */
1013 int
1014 sili_port_hardreset(struct sili_port *ap, int hard)
1015 {
1016         u_int32_t r;
1017         int     error;
1018         int     loop;
1019
1020         DPRINTF(SILI_D_VERBOSE, "%s: port reset\n", PORTNAME(ap));
1021
1022         ap->ap_state = AP_S_NORMAL;
1023         error = 0;
1024
1025         /*
1026          * Issue Device Reset.
1027          *
1028          * NOTE:  Unlike Port Reset, the port ready signal will not
1029          *        go active unless a device is established to be on
1030          *        the port.
1031          */
1032         sili_pwrite(ap, SILI_PREG_SERR, -1);
1033         sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_PMA);
1034         sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_RESUME);
1035         sili_pwrite(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_DEVRESET);
1036         if (sili_pwait_clr(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_DEVRESET)) {
1037                 kprintf("%s: hardreset failed to clear\n", PORTNAME(ap));
1038         }
1039
1040         /*
1041          * Try to determine if there is a device on the port.
1042          *
1043          * Give the device 3/10 second to at least be detected.
1044          */
1045         loop = 300;
1046         while (loop > 0) {
1047                 r = sili_pread(ap, SILI_PREG_SSTS);
1048                 if (r & SILI_PREG_SSTS_DET)
1049                         break;
1050                 loop -= sili_os_softsleep();
1051         }
1052         if (loop <= 0) {
1053                 if (bootverbose) {
1054                         kprintf("%s: Port appears to be unplugged\n",
1055                                 PORTNAME(ap));
1056                 }
1057                 error = ENODEV;
1058         }
1059
1060         /*
1061          * There is something on the port.  Give the device 3 seconds
1062          * to fully negotiate.
1063          */
1064         if (error == 0 &&
1065             sili_pwait_eq(ap, 3000, SILI_PREG_SSTS,
1066                           SILI_PREG_SSTS_DET, SILI_PREG_SSTS_DET_DEV)) {
1067                 if (bootverbose) {
1068                         kprintf("%s: Device may be powered down\n",
1069                                 PORTNAME(ap));
1070                 }
1071                 error = ENODEV;
1072         }
1073
1074         /*
1075          * Wait for the port to become ready.
1076          *
1077          * This can take more then a second, give it 3 seconds.  If we
1078          * succeed give the device another 3ms after that.
1079          *
1080          * NOTE: Port multipliers can do two things here.  First they can
1081          *       return device-ready if a device is on target 0 and also
1082          *       return the signature for that device.  If there is no
1083          *       device on target 0 then BSY/DRQ is never cleared and
1084          *       it never comes ready.
1085          */
1086         if (error == 0 && sili_pwait_set_to(ap, 3000, SILI_PREG_STATUS,
1087                                             SILI_PREG_STATUS_READY)) {
1088                 /*
1089                  * The device is bricked or its a port multiplier and will
1090                  * not unbusy until we do the pmprobe CLO softreset sequence.
1091                  */
1092                 error = sili_port_pmprobe(ap);
1093                 if (error) {
1094                         kprintf("%s: Device will not come ready\n",
1095                                 PORTNAME(ap));
1096                 } else {
1097                         ap->ap_type = ATA_PORT_T_PM;
1098                 }
1099         } else if (error == 0) {
1100                 /*
1101                  * The sili's hardreset doesn't return a signature (does it)?
1102                  * In anycase, set the type so the signature gets set by
1103                  * the softreset stage.
1104                  */
1105                 error = sili_port_pmprobe(ap);
1106                 if (error) {
1107                         ap->ap_type = ATA_PORT_T_NONE;
1108                         error = 0;
1109                 } else {
1110                         ap->ap_type = ATA_PORT_T_PM;
1111                         kprintf("%s: Port multiplier detected\n",
1112                                 PORTNAME(ap));
1113                 }
1114         }
1115
1116         /*
1117          * hard-stop the port if we failed.  This will set ap_probe
1118          * to FAILED.
1119          */
1120         if (error) {
1121                 sili_port_hardstop(ap);
1122                 /* ap_probe set to failed */
1123         } else {
1124                 if (ap->ap_type == ATA_PORT_T_PM)
1125                         ap->ap_probe = ATA_PROBE_GOOD;
1126                 else
1127                         ap->ap_probe = ATA_PROBE_NEED_SOFT_RESET;
1128         }
1129         return (error);
1130 }
1131
1132 /*
1133  * SILI port multiplier probe.  This routine is run by the hardreset code
1134  * if it gets past the device detect.
1135  *
1136  * All we do here is call sili_pm_softreset().  The Sili chip does all the
1137  * hard work for us.
1138  *
1139  * Return 0 on success, non-zero on failure.
1140  */
1141 int
1142 sili_port_pmprobe(struct sili_port *ap)
1143 {
1144         struct ata_port *at;
1145         int error;
1146         int i;
1147
1148         /*
1149          * If we don't support port multipliers don't try to detect one.
1150          */
1151         if ((ap->ap_sc->sc_flags & SILI_F_SPM) == 0)
1152                 return (ENODEV);
1153
1154         /*
1155          * The port may be unhappy from its hardreset if there's a PM
1156          * but no device at target 0.  If we try to shove the softreset
1157          * for target 15 down its throat it will pop a gasket.
1158          *
1159          * Reiniting the port.. kind of a soft reset of its command
1160          * processor which otherwise does not effect the port registers,
1161          * seems to fix the problem.
1162          */
1163         sili_pwrite(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_PMA);
1164         sili_port_reinit(ap);
1165         ap->ap_state = AP_S_NORMAL;
1166         error = sili_pm_softreset(ap, 15);
1167         if (error == 0) {
1168                 ap->ap_ata[15].at_probe = ATA_PROBE_GOOD;
1169         } else {
1170                 error = EBUSY;
1171         }
1172
1173         kprintf("PMPROBE3 %d\n", error);
1174
1175         if (error == 0 && sili_pm_identify(ap)) {
1176                 kprintf("%s: PM - cannot identify port multiplier\n",
1177                         PORTNAME(ap));
1178                 error = EBUSY;
1179         }
1180         kprintf("PMPROBE3 %d %d %d\n", error, ap->ap_probe, ap->ap_state);
1181
1182         /*
1183          * If we probed the PM reset the state for the targets behind
1184          * it so they get probed by the state machine.
1185          */
1186         if (error == 0) {
1187                 for (i = 0; i < SILI_MAX_PMPORTS; ++i) {
1188                         at = &ap->ap_ata[i];
1189                         at->at_probe = ATA_PROBE_NEED_INIT;
1190                         at->at_features |= ATA_PORT_F_RESCAN;
1191                         at->at_features &= ~ATA_PORT_F_READLOG;
1192                 }
1193         }
1194
1195         /*
1196          * If we failed turn off PMA, otherwise identify the port multiplier.
1197          * CAM will iterate the devices.
1198          */
1199         if (error)
1200                 sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_PMA);
1201         return(error);
1202 }
1203
1204 /*
1205  * Hard-stop on hot-swap device removal.  See 10.10.1
1206  *
1207  * Place the port in a mode that will allow it to detect hot-swap insertions.
1208  * This is a bit imprecise because just setting-up SCTL to DET_INIT doesn't
1209  * seem to do the job.
1210  */
1211 void
1212 sili_port_hardstop(struct sili_port *ap)
1213 {
1214         struct sili_ccb *ccb;
1215         struct ata_port *at;
1216         int i;
1217         int slot;
1218
1219         ap->ap_state = AP_S_FATAL_ERROR;
1220         ap->ap_probe = ATA_PROBE_FAILED;
1221         ap->ap_type = ATA_PORT_T_NONE;
1222
1223         /*
1224          * Clean up AT sub-ports on SATA port.
1225          */
1226         for (i = 0; ap->ap_ata && i < SILI_MAX_PMPORTS; ++i) {
1227                 at = &ap->ap_ata[i];
1228                 at->at_type = ATA_PORT_T_NONE;
1229                 at->at_probe = ATA_PROBE_FAILED;
1230                 at->at_features &= ~ATA_PORT_F_READLOG;
1231         }
1232
1233         /*
1234          * Kill the port.  Don't bother waiting for it to transition
1235          * back up.
1236          */
1237         sili_pwrite(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_RESET);
1238         if (sili_pread(ap, SILI_PREG_STATUS) & SILI_PREG_STATUS_READY) {
1239                 kprintf("%s: Port will not go into reset\n",
1240                         PORTNAME(ap));
1241         }
1242         sili_os_sleep(10);
1243         sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_RESUME);
1244         sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_RESET);
1245
1246         /*
1247          * Turn off port-multiplier control bit
1248          */
1249         sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_PMA);
1250
1251         /*
1252          * Clean up the command list.
1253          */
1254         while (ap->ap_active) {
1255                 slot = ffs(ap->ap_active) - 1;
1256                 ap->ap_active &= ~(1 << slot);
1257                 ap->ap_expired &= ~(1 << slot);
1258                 --ap->ap_active_cnt;
1259                 ccb = &ap->ap_ccbs[slot];
1260                 if (ccb->ccb_xa.flags & ATA_F_TIMEOUT_RUNNING) {
1261                         callout_stop(&ccb->ccb_timeout);
1262                         ccb->ccb_xa.flags &= ~ATA_F_TIMEOUT_RUNNING;
1263                 }
1264                 ccb->ccb_xa.flags &= ~(ATA_F_TIMEOUT_DESIRED |
1265                                        ATA_F_TIMEOUT_EXPIRED);
1266                 ccb->ccb_xa.state = ATA_S_TIMEOUT;
1267                 ccb->ccb_done(ccb);
1268                 ccb->ccb_xa.complete(&ccb->ccb_xa);
1269         }
1270         while ((ccb = TAILQ_FIRST(&ap->ap_ccb_pending)) != NULL) {
1271                 TAILQ_REMOVE(&ap->ap_ccb_pending, ccb, ccb_entry);
1272                 ccb->ccb_xa.state = ATA_S_TIMEOUT;
1273                 ccb->ccb_xa.flags &= ~ATA_F_TIMEOUT_DESIRED;
1274                 ccb->ccb_done(ccb);
1275                 ccb->ccb_xa.complete(&ccb->ccb_xa);
1276         }
1277         KKASSERT(ap->ap_active_cnt == 0);
1278
1279         /*
1280          * Put the port into a listen mode, we want to get insertion/removal
1281          * events.
1282          */
1283         sili_port_listen(ap);
1284 }
1285
1286 /*
1287  * Place port into a listen mode for hotplug events only.  The port has
1288  * already been reset and the command processor may not be ready due
1289  * to the lack of a device.
1290  */
1291 void
1292 sili_port_listen(struct sili_port *ap)
1293 {
1294         u_int32_t data;
1295
1296 #if 1
1297         data = SILI_PREG_SCTL_SPM_NONE |
1298                SILI_PREG_SCTL_IPM_NONE |
1299                SILI_PREG_SCTL_SPD_NONE |
1300                SILI_PREG_SCTL_DET_INIT;
1301         if (SiliForceGen1 & (1 << ap->ap_num)) {
1302                 data &= ~SILI_PREG_SCTL_SPD_NONE;
1303                 data |= SILI_PREG_SCTL_SPD_GEN1;
1304         }
1305 #endif
1306         sili_pwrite(ap, SILI_PREG_SERR, -1);
1307         sili_pwrite(ap, SILI_PREG_INT_ENABLE, SILI_PREG_INT_PHYRDYCHG |
1308                                               SILI_PREG_INT_DEVEXCHG);
1309 }
1310
1311 /*
1312  * Figure out what type of device is connected to the port, ATAPI or
1313  * DISK.
1314  */
1315 int
1316 sili_port_signature(struct sili_port *ap, struct ata_port *at, u_int32_t sig)
1317 {
1318         if (bootverbose)
1319                 kprintf("%s: sig %08x\n", ATANAME(ap, at), sig);
1320         if ((sig & 0xffff0000) == (SATA_SIGNATURE_ATAPI & 0xffff0000)) {
1321                 return(ATA_PORT_T_ATAPI);
1322         } else if ((sig & 0xffff0000) ==
1323                  (SATA_SIGNATURE_PORT_MULTIPLIER & 0xffff0000)) {
1324                 return(ATA_PORT_T_PM);
1325         } else {
1326                 return(ATA_PORT_T_DISK);
1327         }
1328 }
1329
1330 /*
1331  * Load the DMA descriptor table for a CCB's buffer.
1332  *
1333  * NOTE: ATA_F_PIO is auto-selected by sili part.
1334  */
1335 int
1336 sili_load_prb(struct sili_ccb *ccb)
1337 {
1338         struct sili_port                *ap = ccb->ccb_port;
1339         struct sili_softc               *sc = ap->ap_sc;
1340         struct ata_xfer                 *xa = &ccb->ccb_xa;
1341         struct sili_prb                 *prb = ccb->ccb_prb;
1342         struct sili_sge                 *sge;
1343         bus_dmamap_t                    dmap = ccb->ccb_dmamap;
1344         int                             error;
1345
1346         /*
1347          * Set up the PRB.  The PRB contains 2 SGE's (1 if it is an ATAPI
1348          * command).  The SGE must be set up to link to the rest of our
1349          * SGE array, in blocks of four SGEs (a SGE table) starting at
1350          */
1351         prb->prb_xfer_count = 0;
1352         prb->prb_control = 0;
1353         prb->prb_override = 0;
1354         sge = (ccb->ccb_xa.flags & ATA_F_PACKET) ?
1355                 &prb->prb_sge_packet : &prb->prb_sge_normal;
1356         if (xa->datalen == 0) {
1357                 sge->sge_flags = SILI_SGE_FLAGS_TRM | SILI_SGE_FLAGS_DRD;
1358                 sge->sge_count = 0;
1359                 return (0);
1360         }
1361
1362         if (ccb->ccb_xa.flags & ATA_F_READ)
1363                 prb->prb_control |= SILI_PRB_CTRL_READ;
1364         if (ccb->ccb_xa.flags & ATA_F_WRITE)
1365                 prb->prb_control |= SILI_PRB_CTRL_WRITE;
1366         sge->sge_flags = SILI_SGE_FLAGS_LNK;
1367         sge->sge_count = 0;
1368         sge->sge_paddr = ccb->ccb_prb_paddr +
1369                          offsetof(struct sili_prb, prb_sge[0]);
1370
1371         /*
1372          * Load our sge array.
1373          */
1374         error = bus_dmamap_load(sc->sc_tag_data, dmap,
1375                                 xa->data, xa->datalen,
1376                                 sili_load_prb_callback,
1377                                 ccb,
1378                                 ((xa->flags & ATA_F_NOWAIT) ?
1379                                     BUS_DMA_NOWAIT : BUS_DMA_WAITOK));
1380         if (error != 0) {
1381                 kprintf("%s: error %d loading dmamap\n", PORTNAME(ap), error);
1382                 return (1);
1383         }
1384
1385         bus_dmamap_sync(sc->sc_tag_data, dmap,
1386                         (xa->flags & ATA_F_READ) ?
1387                             BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
1388
1389         return (0);
1390
1391 #ifdef DIAGNOSTIC
1392 diagerr:
1393         bus_dmamap_unload(sc->sc_tag_data, dmap);
1394         return (1);
1395 #endif
1396 }
1397
1398 /*
1399  * Callback from BUSDMA system to load the segment list.
1400  *
1401  * The scatter/gather table is loaded by the sili chip in blocks of
1402  * four SGE's.  If a continuance is required the last entry in each
1403  * block must point to the next block.
1404  */
1405 static
1406 void
1407 sili_load_prb_callback(void *info, bus_dma_segment_t *segs, int nsegs,
1408                         int error)
1409 {
1410         struct sili_ccb *ccb = info;
1411         struct sili_sge *sge;
1412         int sgi;
1413
1414         KKASSERT(nsegs <= SILI_MAX_SGET);
1415
1416         sgi = 0;
1417         sge = &ccb->ccb_prb->prb_sge[0];
1418         while (nsegs) {
1419                 if ((sgi & 3) == 3) {
1420                         sge->sge_paddr = htole64(ccb->ccb_prb_paddr +
1421                                                  offsetof(struct sili_prb,
1422                                                         prb_sge[sgi + 1]));
1423                         sge->sge_count = 0;
1424                         sge->sge_flags = SILI_SGE_FLAGS_LNK;
1425                 } else {
1426                         sge->sge_paddr = htole64(segs->ds_addr);
1427                         sge->sge_count = htole32(segs->ds_len);
1428                         sge->sge_flags = 0;
1429                         --nsegs;
1430                         ++segs;
1431                 }
1432                 ++sge;
1433                 ++sgi;
1434         }
1435         --sge;
1436         sge->sge_flags |= SILI_SGE_FLAGS_TRM;
1437 }
1438
1439 void
1440 sili_unload_prb(struct sili_ccb *ccb)
1441 {
1442         struct sili_port                *ap = ccb->ccb_port;
1443         struct sili_softc               *sc = ap->ap_sc;
1444         struct ata_xfer                 *xa = &ccb->ccb_xa;
1445         bus_dmamap_t                    dmap = ccb->ccb_dmamap;
1446
1447         if (xa->datalen != 0) {
1448                 bus_dmamap_sync(sc->sc_tag_data, dmap,
1449                                 (xa->flags & ATA_F_READ) ?
1450                                 BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
1451
1452                 bus_dmamap_unload(sc->sc_tag_data, dmap);
1453
1454                 if (ccb->ccb_xa.flags & ATA_F_NCQ)
1455                         xa->resid = 0;
1456                 else
1457                         xa->resid = xa->datalen -
1458                                     le32toh(ccb->ccb_prb->prb_xfer_count);
1459         }
1460 }
1461
1462 /*
1463  * Start a command and poll for completion.
1464  *
1465  * timeout is in ms and only counts once the command gets on-chip.
1466  *
1467  * Returns ATA_S_* state, compare against ATA_S_COMPLETE to determine
1468  * that no error occured.
1469  *
1470  * NOTE: If the caller specifies a NULL timeout function the caller is
1471  *       responsible for clearing hardware state on failure, but we will
1472  *       deal with removing the ccb from any pending queue.
1473  *
1474  * NOTE: NCQ should never be used with this function.
1475  *
1476  * NOTE: If the port is in a failed state and stopped we do not try
1477  *       to activate the ccb.
1478  */
1479 int
1480 sili_poll(struct sili_ccb *ccb, int timeout,
1481           void (*timeout_fn)(struct sili_ccb *))
1482 {
1483         struct sili_port *ap = ccb->ccb_port;
1484
1485         if (ccb->ccb_port->ap_state == AP_S_FATAL_ERROR) {
1486                 ccb->ccb_xa.state = ATA_S_ERROR;
1487                 return(ccb->ccb_xa.state);
1488         }
1489
1490         sili_start(ccb);
1491
1492         do {
1493                 sili_port_intr(ap, 1);
1494                 switch(ccb->ccb_xa.state) {
1495                 case ATA_S_ONCHIP:
1496                         timeout -= sili_os_softsleep();
1497                         break;
1498                 case ATA_S_PENDING:
1499                         /*
1500                          * The packet can get stuck on the pending queue
1501                          * if the port refuses to come ready.
1502                          */
1503                         if (AP_F_EXCLUSIVE_ACCESS)
1504                                 timeout -= sili_os_softsleep();
1505                         else
1506                                 sili_os_softsleep();
1507                         sili_check_active_timeouts(ap);
1508                         break;
1509                 default:
1510                         return (ccb->ccb_xa.state);
1511                 }
1512         } while (timeout > 0);
1513
1514         kprintf("%s: Poll timeout slot %d\n",
1515                 ATANAME(ap, ccb->ccb_xa.at),
1516                 ccb->ccb_slot);
1517
1518         timeout_fn(ccb);
1519
1520         return(ccb->ccb_xa.state);
1521 }
1522
1523 /*
1524  * When polling we have to check if the currently active CCB(s)
1525  * have timed out as the callout will be deadlocked while we
1526  * hold the port lock.
1527  */
1528 void
1529 sili_check_active_timeouts(struct sili_port *ap)
1530 {
1531         struct sili_ccb *ccb;
1532         u_int32_t mask;
1533         int tag;
1534
1535         mask = ap->ap_active;
1536         while (mask) {
1537                 tag = ffs(mask) - 1;
1538                 mask &= ~(1 << tag);
1539                 ccb = &ap->ap_ccbs[tag];
1540                 if (ccb->ccb_xa.flags & ATA_F_TIMEOUT_EXPIRED) {
1541                         sili_core_timeout(ccb);
1542                 }
1543         }
1544 }
1545
1546 static
1547 __inline
1548 void
1549 sili_start_timeout(struct sili_ccb *ccb)
1550 {
1551         if (ccb->ccb_xa.flags & ATA_F_TIMEOUT_DESIRED) {
1552                 ccb->ccb_xa.flags |= ATA_F_TIMEOUT_RUNNING;
1553                 callout_reset(&ccb->ccb_timeout,
1554                               (ccb->ccb_xa.timeout * hz + 999) / 1000,
1555                               sili_ata_cmd_timeout_unserialized, ccb);
1556         }
1557 }
1558
1559 void
1560 sili_start(struct sili_ccb *ccb)
1561 {
1562         struct sili_port                *ap = ccb->ccb_port;
1563 #if 0
1564         struct sili_softc               *sc = ap->ap_sc;
1565 #endif
1566
1567         KKASSERT(ccb->ccb_xa.state == ATA_S_PENDING);
1568
1569         /*
1570          * Sync our SGE table and PRB
1571          */
1572         bus_dmamap_sync(ap->ap_dmamem_prbs->adm_tag,
1573                         ap->ap_dmamem_prbs->adm_map,
1574                         BUS_DMASYNC_PREWRITE);
1575
1576         /*
1577          * XXX dmamap for PRB XXX  BUS_DMASYNC_PREWRITE
1578          */
1579
1580         /*
1581          * Controller will update shared memory!
1582          * XXX bus_dmamap_sync ... BUS_DMASYNC_PREREAD ...
1583          */
1584         /* Prepare RFIS area for write by controller */
1585
1586         /*
1587          * There's no point trying to optimize this, it only shaves a few
1588          * nanoseconds so just queue the command and call our generic issue.
1589          */
1590         sili_issue_pending_commands(ap, ccb);
1591 }
1592
1593 /*
1594  * While holding the port lock acquire exclusive access to the port.
1595  *
1596  * This is used when running the state machine to initialize and identify
1597  * targets over a port multiplier.  Setting exclusive access prevents
1598  * sili_port_intr() from activating any requests sitting on the pending
1599  * queue.
1600  */
1601 void
1602 sili_beg_exclusive_access(struct sili_port *ap, struct ata_port *at)
1603 {
1604         KKASSERT((ap->ap_flags & AP_F_EXCLUSIVE_ACCESS) == 0);
1605         ap->ap_flags |= AP_F_EXCLUSIVE_ACCESS;
1606         while (ap->ap_active) {
1607                 sili_port_intr(ap, 1);
1608                 sili_os_softsleep();
1609         }
1610 }
1611
1612 void
1613 sili_end_exclusive_access(struct sili_port *ap, struct ata_port *at)
1614 {
1615         KKASSERT((ap->ap_flags & AP_F_EXCLUSIVE_ACCESS) != 0);
1616         ap->ap_flags &= ~AP_F_EXCLUSIVE_ACCESS;
1617         sili_issue_pending_commands(ap, NULL);
1618 }
1619
1620 /*
1621  * If ccb is not NULL enqueue and/or issue it.
1622  *
1623  * If ccb is NULL issue whatever we can from the queue.  However, nothing
1624  * new is issued if the exclusive access flag is set or expired ccb's are
1625  * present.
1626  *
1627  * If existing commands are still active (ap_active) we can only
1628  * issue matching new commands.
1629  */
1630 void
1631 sili_issue_pending_commands(struct sili_port *ap, struct sili_ccb *ccb)
1632 {
1633         /*
1634          * Enqueue the ccb.
1635          *
1636          * If just running the queue and in exclusive access mode we
1637          * just return.  Also in this case if there are any expired ccb's
1638          * we want to clear the queue so the port can be safely stopped.
1639          *
1640          * XXX sili chip - expiration needs to be per-target if PM supports
1641          *      FBSS?
1642          */
1643         if (ccb) {
1644                 TAILQ_INSERT_TAIL(&ap->ap_ccb_pending, ccb, ccb_entry);
1645         } else if ((ap->ap_flags & AP_F_EXCLUSIVE_ACCESS) || ap->ap_expired) {
1646                 return;
1647         }
1648
1649         /*
1650          * Pull the next ccb off the queue and run it if possible.
1651          * If the port is not ready to accept commands enable the
1652          * ready interrupt instead of starting a new command.
1653          *
1654          * XXX limit ncqdepth for attached devices behind PM
1655          */
1656         while ((ccb = TAILQ_FIRST(&ap->ap_ccb_pending)) != NULL) {
1657                 if ((sili_pread(ap, SILI_PREG_STATUS) &
1658                     SILI_PREG_STATUS_READY) == 0) {
1659                         kprintf("%s: slot %d NOT READY\n",
1660                                 ATANAME(ap, ccb->ccb_xa.at), ccb->ccb_slot);
1661                         sili_pwrite(ap, SILI_PREG_INT_ENABLE,
1662                                     SILI_PREG_INT_READY);
1663                         break;
1664                 }
1665                 TAILQ_REMOVE(&ap->ap_ccb_pending, ccb, ccb_entry);
1666                 ccb->ccb_xa.state = ATA_S_ONCHIP;
1667                 ap->ap_active |= 1 << ccb->ccb_slot;
1668                 ap->ap_active_cnt++;
1669
1670                 /*
1671                  * We can't use the CMD_FIFO method because it requires us
1672                  * building the PRB in the LRAM, and the LRAM is buggy.  So
1673                  * we use host memory for the PRB.
1674                  */
1675                 sili_pwrite(ap, SILI_PREG_CMDACT(ccb->ccb_slot),
1676                             (u_int32_t)ccb->ccb_prb_paddr);
1677                 sili_pwrite(ap, SILI_PREG_CMDACT(ccb->ccb_slot) + 4,
1678                             (u_int32_t)(ccb->ccb_prb_paddr >> 32));
1679                 /* sili_pwrite(ap, SILI_PREG_CMD_FIFO, ccb->ccb_slot); */
1680                 sili_start_timeout(ccb);
1681         }
1682 }
1683
1684 void
1685 sili_intr(void *arg)
1686 {
1687         struct sili_softc       *sc = arg;
1688         struct sili_port        *ap;
1689         u_int32_t               gint;
1690         int                     port;
1691
1692         /*
1693          * Check if the master enable is up, and whether any interrupts are
1694          * pending.
1695          *
1696          * Clear the ints we got.
1697          */
1698         if ((sc->sc_flags & SILI_F_INT_GOOD) == 0)
1699                 return;
1700         gint = sili_read(sc, SILI_REG_GINT);
1701         if (gint == 0 || gint == 0xffffffff)
1702                 return;
1703         sili_write(sc, SILI_REG_GINT, gint);
1704
1705         /*
1706          * Process interrupts for each port in a non-blocking fashion.
1707          */
1708         while (gint & SILI_REG_GINT_PORTMASK) {
1709                 port = ffs(gint) - 1;
1710                 ap = sc->sc_ports[port];
1711                 if (ap) {
1712                         if (sili_os_lock_port_nb(ap) == 0) {
1713                                 sili_port_intr(ap, 0);
1714                                 sili_os_unlock_port(ap);
1715                         } else {
1716                                 sili_port_interrupt_redisable(ap);
1717                                 sili_os_signal_port_thread(ap, AP_SIGF_PORTINT);
1718                         }
1719                 }
1720                 gint &= ~(1 << port);
1721         }
1722 }
1723
1724 /*
1725  * Core called from helper thread.
1726  */
1727 void
1728 sili_port_thread_core(struct sili_port *ap, int mask)
1729 {
1730         /*
1731          * Process any expired timedouts.
1732          */
1733         sili_os_lock_port(ap);
1734         if (mask & AP_SIGF_TIMEOUT) {
1735                 sili_check_active_timeouts(ap);
1736         }
1737
1738         /*
1739          * Process port interrupts which require a higher level of
1740          * intervention.
1741          */
1742         if (mask & AP_SIGF_PORTINT) {
1743                 sili_port_intr(ap, 1);
1744                 sili_port_interrupt_reenable(ap);
1745                 sili_os_unlock_port(ap);
1746         } else {
1747                 sili_os_unlock_port(ap);
1748         }
1749 }
1750
1751 /*
1752  * Core per-port interrupt handler.
1753  *
1754  * If blockable is 0 we cannot call sili_os_sleep() at all and we can only
1755  * deal with normal command completions which do not require blocking.
1756  */
1757 void
1758 sili_port_intr(struct sili_port *ap, int blockable)
1759 {
1760         struct sili_softc       *sc = ap->ap_sc;
1761         u_int32_t               is;
1762         int                     slot;
1763         struct sili_ccb         *ccb = NULL;
1764         struct ata_port         *ccb_at = NULL;
1765 #ifdef DIAGNOSTIC
1766         u_int32_t               tmp;
1767 #endif
1768         u_int32_t               active;
1769         const u_int32_t         blockable_mask = SILI_PREG_IST_PHYRDYCHG |
1770                                                  SILI_PREG_IST_DEVEXCHG |
1771                                                  SILI_PREG_IST_CERROR |
1772                                                  SILI_PREG_IST_DECODE |
1773                                                  SILI_PREG_IST_CRC |
1774                                                  SILI_PREG_IST_HANDSHK;
1775         const u_int32_t         fatal_mask     = SILI_PREG_IST_PHYRDYCHG |
1776                                                  SILI_PREG_IST_DEVEXCHG |
1777                                                  SILI_PREG_IST_DECODE |
1778                                                  SILI_PREG_IST_CRC |
1779                                                  SILI_PREG_IST_HANDSHK;
1780
1781         enum { NEED_NOTHING, NEED_HOTPLUG_INSERT,
1782                NEED_HOTPLUG_REMOVE } need = NEED_NOTHING;
1783
1784         /*
1785          * NOTE: CCOMPLETE was automatically cleared when we read INT_STATUS.
1786          */
1787         is = sili_pread(ap, SILI_PREG_INT_STATUS);
1788         is &= SILI_PREG_IST_MASK;
1789         if (is & SILI_PREG_IST_CCOMPLETE)
1790                 sili_pwrite(ap, SILI_PREG_INT_STATUS, SILI_PREG_IST_CCOMPLETE);
1791
1792         /*
1793          * If we can't block then we can't handle these here.  Disable
1794          * the interrupts in question so we don't live-lock, the helper
1795          * thread will re-enable them.
1796          *
1797          * If the port is in a completely failed state we do not want
1798          * to drop through to failed-command-processing if blockable is 0,
1799          * just let the thread deal with it all.
1800          *
1801          * Otherwise we fall through and still handle DHRS and any commands
1802          * which completed normally.  Even if we are errored we haven't
1803          * stopped the port yet so CI/SACT are still good.
1804          */
1805         if (blockable == 0) {
1806                 if (ap->ap_state == AP_S_FATAL_ERROR) {
1807                         sili_port_interrupt_redisable(ap);
1808                         sili_os_signal_port_thread(ap, AP_SIGF_PORTINT);
1809                         /*is &= ~blockable_mask;*/
1810                         return;
1811                 }
1812                 if (is & blockable_mask) {
1813                         sili_port_interrupt_redisable(ap);
1814                         sili_os_signal_port_thread(ap, AP_SIGF_PORTINT);
1815                         /*is &= ~blockable_mask;*/
1816                         return;
1817                 }
1818         }
1819
1820         if (is & SILI_PREG_IST_CERROR) {
1821                 /*
1822                  * Command failed (blockable).
1823                  *
1824                  * This stops command processing.  We can extract the PM
1825                  * target from the PMP field in SILI_PREG_CONTEXT.  The
1826                  * tag is not necessarily valid so don't use that.
1827                  *
1828                  * We must then expire all CCB's for that target and resume
1829                  * processing if any other targets have active commands.
1830                  * Particular error codes can be recovered by reading the LOG
1831                  * page.
1832                  *
1833                  * The expire handling code will do the rest, which is
1834                  * basically to reset the port once the only active
1835                  * commands remaining are all expired.
1836                  */
1837                 u_int32_t error;
1838                 int       target;
1839                 int       resume = 1;
1840
1841                 target = (sili_pread(ap, SILI_PREG_CONTEXT) >>
1842                           SILI_PREG_CONTEXT_PMPORT_SHIFT) &
1843                           SILI_PREG_CONTEXT_PMPORT_MASK;
1844                 sili_pwrite(ap, SILI_PREG_INT_STATUS, SILI_PREG_IST_CERROR);
1845                 active = ap->ap_active & ~ap->ap_expired;
1846                 error = sili_pread(ap, SILI_PREG_CERROR);
1847                 kprintf("%s.%d target error %d active=%08x hactive=%08x "
1848                         "SERR=%b\n",
1849                         PORTNAME(ap), target, error,
1850                         active, sili_pread(ap, SILI_PREG_SLOTST),
1851                         sili_pread(ap, SILI_PREG_SERR), SILI_PFMT_SERR);
1852
1853                 while (active) {
1854                         slot = ffs(active) - 1;
1855                         ccb = &ap->ap_ccbs[slot];
1856                         if ((ccb_at = ccb->ccb_xa.at) == NULL)
1857                                 ccb_at = &ap->ap_ata[0];
1858                         if (target == ccb_at->at_target) {
1859                                 kprintf("%s kill ccb slot %d\n",
1860                                         ATANAME(ap, ccb->ccb_xa.at), slot);
1861                                 if (ccb->ccb_xa.flags & ATA_F_NCQ &&
1862                                     (error == SILI_PREG_CERROR_DEVICE ||
1863                                      error == SILI_PREG_CERROR_SDBERROR)) {
1864                                         ccb_at->at_features |= ATA_PORT_F_READLOG;
1865                                 }
1866                                 if (sili_core_timeout(ccb) == 0)
1867                                         resume = 0;
1868                         }
1869                         active &= ~(1 << slot);
1870                 }
1871
1872                 /*
1873                  * Resume will be 0 if the timeout reinited and restarted
1874                  * the port.  Otherwise we resume the port to allow other
1875                  * commands to complete.
1876                  */
1877                 kprintf("%s.%d remain=%08x resume=%d\n",
1878                         PORTNAME(ap), target,
1879                         ap->ap_active & ~ap->ap_expired, resume);
1880                 if (resume)
1881                         sili_pwrite(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_RESUME);
1882         }
1883
1884         /*
1885          * Device notification to us (non-blocking)
1886          *
1887          * This is interrupt status SILIPREG_IST_SDB
1888          *
1889          * NOTE!  On some parts notification bits can get set without
1890          *        generating an interrupt.  It is unclear whether this is
1891          *        a bug in the PM (sending a DTOH device setbits with 'N' set
1892          *        and 'I' not set), or a bug in the host controller.
1893          *
1894          *        It only seems to occur under load.
1895          */
1896         if (sc->sc_flags & SILI_F_SSNTF) {
1897                 u_int32_t data;
1898                 const char *xstr;
1899
1900                 data = sili_pread(ap, SILI_PREG_SNTF);
1901                 if (is & SILI_PREG_IST_SDB) {
1902                         sili_pwrite(ap, SILI_PREG_INT_STATUS,
1903                                     SILI_PREG_IST_SDB);
1904                         is &= ~SILI_PREG_IST_SDB;
1905                         xstr = " (no SDBS!)";
1906                 } else {
1907                         xstr = "";
1908                 }
1909                 if (data) {
1910                         kprintf("%s: NOTIFY %08x%s\n",
1911                                 PORTNAME(ap), data, xstr);
1912                         sili_pwrite(ap, SILI_PREG_SNTF, data);
1913                         sili_cam_changed(ap, NULL, -1);
1914                 }
1915         }
1916
1917         /*
1918          * Port change (hot-plug) (blockable).
1919          *
1920          * A PCS interrupt will occur on hot-plug once communication is
1921          * established.
1922          *
1923          * A PRCS interrupt will occur on hot-unplug (and possibly also
1924          * on hot-plug).
1925          *
1926          * XXX We can then check the CPS (Cold Presence State) bit, if
1927          * supported, to determine if a device is plugged in or not and do
1928          * the right thing.
1929          *
1930          * WARNING:  A PCS interrupt is cleared by clearing DIAG_X, and
1931          *           can also occur if an unsolicited COMINIT is received.
1932          *           If this occurs command processing is automatically
1933          *           stopped (CR goes inactive) and the port must be stopped
1934          *           and restarted.
1935          */
1936         if (is & (SILI_PREG_IST_PHYRDYCHG | SILI_PREG_IST_DEVEXCHG)) {
1937                 /* XXX */
1938                 sili_pwrite(ap, SILI_PREG_SERR,
1939                         (SILI_PREG_SERR_DIAG_N | SILI_PREG_SERR_DIAG_X));
1940                 sili_pwrite(ap, SILI_PREG_INT_STATUS,
1941                     is & (SILI_PREG_IST_PHYRDYCHG | SILI_PREG_IST_DEVEXCHG));
1942
1943                 is &= ~(SILI_PREG_IST_PHYRDYCHG | SILI_PREG_IST_DEVEXCHG);
1944                 kprintf("%s: Port change\n", PORTNAME(ap));
1945
1946                 switch (sili_pread(ap, SILI_PREG_SSTS) & SILI_PREG_SSTS_DET) {
1947                 case SILI_PREG_SSTS_DET_DEV:
1948                         if (ap->ap_type == ATA_PORT_T_NONE &&
1949                             ap->ap_probe == ATA_PROBE_FAILED) {
1950                                 need = NEED_HOTPLUG_INSERT;
1951                                 goto fatal;
1952                         }
1953                         break;
1954                 default:
1955                         kprintf("%s: Device lost\n", PORTNAME(ap));
1956                         if (ap->ap_type != ATA_PORT_T_NONE) {
1957                                 need = NEED_HOTPLUG_REMOVE;
1958                                 goto fatal;
1959                         }
1960                         break;
1961                 }
1962         }
1963
1964         /*
1965          * Check for remaining errors - they are fatal. (blockable)
1966          */
1967         if (is & fatal_mask) {
1968                 u_int32_t serr;
1969
1970                 sili_pwrite(ap, SILI_PREG_INT_STATUS, is & fatal_mask);
1971
1972                 serr = sili_pread(ap, SILI_PREG_SERR);
1973                 kprintf("%s: Unrecoverable errors (IS: %b, SERR: %b), "
1974                         "disabling port.\n",
1975                         PORTNAME(ap),
1976                         is, SILI_PFMT_INT_STATUS,
1977                         serr, SILI_PFMT_SERR
1978                 );
1979                 is &= ~fatal_mask;
1980                 /* XXX try recovery first */
1981                 goto fatal;
1982         }
1983
1984         /*
1985          * Fail all outstanding commands if we know the port won't recover.
1986          *
1987          * We may have a ccb_at if the failed command is known and was
1988          * being sent to a device over a port multiplier (PM).  In this
1989          * case if the port itself has not completely failed we fail just
1990          * the commands related to that target.
1991          */
1992         if (ap->ap_state == AP_S_FATAL_ERROR && ap->ap_active) {
1993 fatal:
1994                 kprintf("%s: Interrupt, fatal error\n", PORTNAME(ap));
1995                 ap->ap_state = AP_S_FATAL_ERROR;
1996 /*failall:*/
1997                 /*
1998                  * Error all the active slots.  If running across a PM
1999                  * try to error out just the slots related to the target.
2000                  */
2001                 active = ap->ap_active & ~ap->ap_expired;
2002
2003                 while (active) {
2004                         slot = ffs(active) - 1;
2005                         kprintf("%s: Killing slot %d\n", PORTNAME(ap), slot);
2006                         active &= ~(1 << slot);
2007                         ccb = &ap->ap_ccbs[slot];
2008                         sili_core_timeout(ccb);
2009                 }
2010         }
2011
2012         /*
2013          * CCB completion (non blocking).
2014          *
2015          * CCB completion is detected by noticing the slot bit in
2016          * the port slot status register has cleared while the bit
2017          * is still set in our ap_active variable.
2018          *
2019          * When completing expired events we must remember to reinit
2020          * the port once everything is clear.
2021          */
2022         active = ap->ap_active & ~sili_pread(ap, SILI_PREG_SLOTST);
2023
2024         while (active) {
2025                 slot = ffs(active) - 1;
2026                 ccb = &ap->ap_ccbs[slot];
2027
2028                 DPRINTF(SILI_D_INTR, "%s: slot %d is complete%s\n",
2029                     PORTNAME(ap), slot, ccb->ccb_xa.state == ATA_S_ERROR ?
2030                     " (error)" : "");
2031
2032                 active &= ~(1 << slot);
2033
2034                 /*
2035                  * XXX sync POSTREAD for return data?
2036                  */
2037                 ap->ap_active &= ~(1 << ccb->ccb_slot);
2038                 --ap->ap_active_cnt;
2039
2040                 /*
2041                  * Complete the ccb.  If the ccb was marked expired it
2042                  * may or may not have been cleared from the port,
2043                  * make sure we mark it as having timed out.
2044                  */
2045                 if (ap->ap_expired & (1 << ccb->ccb_slot)) {
2046                         ap->ap_expired &= ~(1 << ccb->ccb_slot);
2047                         ccb->ccb_xa.state = ATA_S_TIMEOUT;
2048                         ccb->ccb_done(ccb);
2049                         ccb->ccb_xa.complete(&ccb->ccb_xa);
2050                 } else {
2051                         if (ccb->ccb_xa.state == ATA_S_ONCHIP)
2052                                 ccb->ccb_xa.state = ATA_S_COMPLETE;
2053                         ccb->ccb_done(ccb);
2054                 }
2055         }
2056         if (is & SILI_PREG_IST_READY) {
2057                 is &= ~SILI_PREG_IST_READY;
2058                 sili_pwrite(ap, SILI_PREG_INT_DISABLE, SILI_PREG_INT_READY);
2059                 sili_pwrite(ap, SILI_PREG_INT_STATUS, SILI_PREG_IST_READY);
2060         }
2061
2062         /*
2063          * If we had expired commands and were waiting for
2064          * remaining commands to complete, and they have now
2065          * completed, we can reinit the port.
2066          *
2067          * This will also clean out the expired commands.
2068          * The timeout code also calls sili_port_reinit() if
2069          * the only commands remaining after a timeout are all
2070          * now expired commands.
2071          *
2072          * Otherwise just reissue.
2073          */
2074         if (ap->ap_expired && ap->ap_active == ap->ap_expired)
2075                 sili_port_reinit(ap);
2076         else
2077                 sili_issue_pending_commands(ap, NULL);
2078
2079         /*
2080          * Cleanup.  Will not be set if non-blocking.
2081          */
2082         switch(need) {
2083         case NEED_HOTPLUG_INSERT:
2084                 /*
2085                  * A hot-plug insertion event has occured and all
2086                  * outstanding commands have already been revoked.
2087                  *
2088                  * Don't recurse if this occurs while we are
2089                  * resetting the port.
2090                  *
2091                  * Place the port in a continuous COMRESET state
2092                  * until the INIT code gets to it.
2093                  */
2094                 kprintf("%s: HOTPLUG - Device inserted\n",
2095                         PORTNAME(ap));
2096                 ap->ap_probe = ATA_PROBE_NEED_INIT;
2097                 sili_cam_changed(ap, NULL, -1);
2098                 break;
2099         case NEED_HOTPLUG_REMOVE:
2100                 /*
2101                  * A hot-plug removal event has occured and all
2102                  * outstanding commands have already been revoked.
2103                  *
2104                  * Don't recurse if this occurs while we are
2105                  * resetting the port.
2106                  */
2107                 kprintf("%s: HOTPLUG - Device removed\n",
2108                         PORTNAME(ap));
2109                 sili_port_hardstop(ap);
2110                 /* ap_probe set to failed */
2111                 sili_cam_changed(ap, NULL, -1);
2112                 break;
2113         default:
2114                 break;
2115         }
2116 }
2117
2118 struct sili_ccb *
2119 sili_get_ccb(struct sili_port *ap)
2120 {
2121         struct sili_ccb                 *ccb;
2122
2123         lockmgr(&ap->ap_ccb_lock, LK_EXCLUSIVE);
2124         ccb = TAILQ_FIRST(&ap->ap_ccb_free);
2125         if (ccb != NULL) {
2126                 KKASSERT(ccb->ccb_xa.state == ATA_S_PUT);
2127                 TAILQ_REMOVE(&ap->ap_ccb_free, ccb, ccb_entry);
2128                 ccb->ccb_xa.state = ATA_S_SETUP;
2129                 ccb->ccb_xa.at = NULL;
2130         }
2131         lockmgr(&ap->ap_ccb_lock, LK_RELEASE);
2132
2133         return (ccb);
2134 }
2135
2136 void
2137 sili_put_ccb(struct sili_ccb *ccb)
2138 {
2139         struct sili_port                *ap = ccb->ccb_port;
2140
2141 #ifdef DIAGNOSTIC
2142         if (ccb->ccb_xa.state != ATA_S_COMPLETE &&
2143             ccb->ccb_xa.state != ATA_S_TIMEOUT &&
2144             ccb->ccb_xa.state != ATA_S_ERROR) {
2145                 kprintf("%s: invalid ata_xfer state %02x in sili_put_ccb, "
2146                         "slot %d\n",
2147                         PORTNAME(ccb->ccb_port), ccb->ccb_xa.state,
2148                         ccb->ccb_slot);
2149         }
2150 #endif
2151
2152         ccb->ccb_xa.state = ATA_S_PUT;
2153         lockmgr(&ap->ap_ccb_lock, LK_EXCLUSIVE);
2154         TAILQ_INSERT_TAIL(&ap->ap_ccb_free, ccb, ccb_entry);
2155         lockmgr(&ap->ap_ccb_lock, LK_RELEASE);
2156 }
2157
2158 struct sili_ccb *
2159 sili_get_err_ccb(struct sili_port *ap)
2160 {
2161         struct sili_ccb *err_ccb;
2162
2163         KKASSERT(sili_pread(ap, SILI_PREG_CI) == 0);
2164         KKASSERT((ap->ap_flags & AP_F_ERR_CCB_RESERVED) == 0);
2165         ap->ap_flags |= AP_F_ERR_CCB_RESERVED;
2166
2167 #ifdef DIAGNOSTIC
2168         KKASSERT(ap->ap_err_busy == 0);
2169         ap->ap_err_busy = 1;
2170 #endif
2171         /*
2172          * Grab a CCB to use for error recovery.  This should never fail, as
2173          * we ask atascsi to reserve one for us at init time.
2174          */
2175         err_ccb = ap->ap_err_ccb;
2176         KKASSERT(err_ccb != NULL);
2177         err_ccb->ccb_xa.flags = 0;
2178         err_ccb->ccb_done = sili_empty_done;
2179
2180         return err_ccb;
2181 }
2182
2183 void
2184 sili_put_err_ccb(struct sili_ccb *ccb)
2185 {
2186         struct sili_port *ap = ccb->ccb_port;
2187
2188 #ifdef DIAGNOSTIC
2189         KKASSERT(ap->ap_err_busy);
2190 #endif
2191         KKASSERT((ap->ap_flags & AP_F_ERR_CCB_RESERVED) != 0);
2192
2193         KKASSERT(ccb == ap->ap_err_ccb);
2194
2195 #ifdef DIAGNOSTIC
2196         ap->ap_err_busy = 0;
2197 #endif
2198         ap->ap_flags &= ~AP_F_ERR_CCB_RESERVED;
2199 }
2200
2201 /*
2202  * Read log page to get NCQ error.
2203  */
2204 int
2205 sili_port_read_ncq_error(struct sili_port *ap, int target)
2206 {
2207         struct sili_ccb         *ccb;
2208         struct ata_fis_h2d      *fis;
2209         int                     rc = EIO;
2210
2211         DPRINTF(SILI_D_VERBOSE, "%s: read log page\n", PORTNAME(ap));
2212
2213         /* Prep error CCB for READ LOG EXT, page 10h, 1 sector. */
2214         ccb = sili_get_err_ccb(ap);
2215         ccb->ccb_done = sili_empty_done;
2216         ccb->ccb_xa.flags = ATA_F_NOWAIT | ATA_F_READ | ATA_F_POLL;
2217         ccb->ccb_xa.data = ap->ap_err_scratch;
2218         ccb->ccb_xa.datalen = 512;
2219         ccb->ccb_xa.complete = sili_dummy_done;
2220         ccb->ccb_xa.at = &ap->ap_ata[target];
2221         fis = &ccb->ccb_prb->prb_h2d;
2222         bzero(fis, sizeof(*fis));
2223
2224         fis->type = ATA_FIS_TYPE_H2D;
2225         fis->flags = ATA_H2D_FLAGS_CMD | target;
2226         fis->command = ATA_C_READ_LOG_EXT;
2227         fis->lba_low = 0x10;            /* queued error log page (10h) */
2228         fis->sector_count = 1;          /* number of sectors (1) */
2229         fis->sector_count_exp = 0;
2230         fis->lba_mid = 0;               /* starting offset */
2231         fis->lba_mid_exp = 0;
2232         fis->device = 0;
2233
2234         if (sili_load_prb(ccb) != 0) {
2235                 rc = ENOMEM;    /* XXX caller must abort all commands */
2236         } else {
2237                 ccb->ccb_xa.state = ATA_S_PENDING;
2238                 rc = sili_poll(ccb, 1000, sili_quick_timeout);
2239         }
2240
2241         /* Abort our command, if it failed, by stopping command DMA. */
2242         if (rc) {
2243                 kprintf("%s: log page read failed, slot %d was still active.\n",
2244                         ATANAME(ap, ccb->ccb_xa.at), ccb->ccb_slot);
2245         }
2246
2247         /* Done with the error CCB now. */
2248         sili_unload_prb(ccb);
2249         sili_put_err_ccb(ccb);
2250
2251         /* Extract failed register set and tags from the scratch space. */
2252         if (rc == 0) {
2253                 struct ata_log_page_10h         *log;
2254                 int                             err_slot;
2255
2256                 log = (struct ata_log_page_10h *)ap->ap_err_scratch;
2257                 if (log->err_regs.type & ATA_LOG_10H_TYPE_NOTQUEUED) {
2258                         /* Not queued bit was set - wasn't an NCQ error? */
2259                         kprintf("%s: read NCQ error page, but not an NCQ "
2260                                 "error?\n",
2261                                 PORTNAME(ap));
2262                         rc = ESRCH;
2263                 } else {
2264                         /* Copy back the log record as a D2H register FIS. */
2265                         err_slot = log->err_regs.type &
2266                                    ATA_LOG_10H_TYPE_TAG_MASK;
2267                         ccb = &ap->ap_ccbs[err_slot];
2268                         if (ap->ap_expired & (1 << ccb->ccb_slot)) {
2269                                 kprintf("%s: read NCQ error page ok\n",
2270                                         ATANAME(ap, ccb->ccb_xa.at));
2271                                 memcpy(&ccb->ccb_prb->prb_d2h, &log->err_regs,
2272                                         sizeof(struct ata_fis_d2h));
2273                                 ccb->ccb_prb->prb_d2h.type = ATA_FIS_TYPE_D2H;
2274                                 ccb->ccb_prb->prb_d2h.flags = 0;
2275                         } else {
2276                                 kprintf("%s: error log slot %d did not match a failed ccb!\n", ATANAME(ccb->ccb_port, ccb->ccb_xa.at), err_slot);
2277                         }
2278                 }
2279         }
2280
2281         return (rc);
2282 }
2283
2284 /*
2285  * Allocate memory for various structures DMAd by hardware.  The maximum
2286  * number of segments for these tags is 1 so the DMA memory will have a
2287  * single physical base address.
2288  */
2289 struct sili_dmamem *
2290 sili_dmamem_alloc(struct sili_softc *sc, bus_dma_tag_t tag)
2291 {
2292         struct sili_dmamem *adm;
2293         int     error;
2294
2295         adm = kmalloc(sizeof(*adm), M_DEVBUF, M_INTWAIT | M_ZERO);
2296
2297         error = bus_dmamem_alloc(tag, (void **)&adm->adm_kva,
2298                                  BUS_DMA_ZERO, &adm->adm_map);
2299         if (error == 0) {
2300                 adm->adm_tag = tag;
2301                 error = bus_dmamap_load(tag, adm->adm_map,
2302                                         adm->adm_kva,
2303                                         bus_dma_tag_getmaxsize(tag),
2304                                         sili_dmamem_saveseg, &adm->adm_busaddr,
2305                                         0);
2306         }
2307         if (error) {
2308                 if (adm->adm_map) {
2309                         bus_dmamap_destroy(tag, adm->adm_map);
2310                         adm->adm_map = NULL;
2311                         adm->adm_tag = NULL;
2312                         adm->adm_kva = NULL;
2313                 }
2314                 kfree(adm, M_DEVBUF);
2315                 adm = NULL;
2316         }
2317         return (adm);
2318 }
2319
2320 static
2321 void
2322 sili_dmamem_saveseg(void *info, bus_dma_segment_t *segs, int nsegs, int error)
2323 {
2324         KKASSERT(error == 0);
2325         KKASSERT(nsegs == 1);
2326         *(bus_addr_t *)info = segs->ds_addr;
2327 }
2328
2329
2330 void
2331 sili_dmamem_free(struct sili_softc *sc, struct sili_dmamem *adm)
2332 {
2333         if (adm->adm_map) {
2334                 bus_dmamap_unload(adm->adm_tag, adm->adm_map);
2335                 bus_dmamap_destroy(adm->adm_tag, adm->adm_map);
2336                 adm->adm_map = NULL;
2337                 adm->adm_tag = NULL;
2338                 adm->adm_kva = NULL;
2339         }
2340         kfree(adm, M_DEVBUF);
2341 }
2342
2343 u_int32_t
2344 sili_read(struct sili_softc *sc, bus_size_t r)
2345 {
2346         bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4,
2347                           BUS_SPACE_BARRIER_READ);
2348         return (bus_space_read_4(sc->sc_iot, sc->sc_ioh, r));
2349 }
2350
2351 void
2352 sili_write(struct sili_softc *sc, bus_size_t r, u_int32_t v)
2353 {
2354         bus_space_write_4(sc->sc_iot, sc->sc_ioh, r, v);
2355         bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4,
2356                           BUS_SPACE_BARRIER_WRITE);
2357 }
2358
2359 u_int32_t
2360 sili_pread(struct sili_port *ap, bus_size_t r)
2361 {
2362         bus_space_barrier(ap->ap_sc->sc_iot, ap->ap_ioh, r, 4,
2363                           BUS_SPACE_BARRIER_READ);
2364         return (bus_space_read_4(ap->ap_sc->sc_iot, ap->ap_ioh, r));
2365 }
2366
2367 void
2368 sili_pwrite(struct sili_port *ap, bus_size_t r, u_int32_t v)
2369 {
2370         bus_space_write_4(ap->ap_sc->sc_iot, ap->ap_ioh, r, v);
2371         bus_space_barrier(ap->ap_sc->sc_iot, ap->ap_ioh, r, 4,
2372                           BUS_SPACE_BARRIER_WRITE);
2373 }
2374
2375 /*
2376  * Wait up to (timeout) milliseconds for the masked port register to
2377  * match the target.
2378  *
2379  * Timeout is in milliseconds.
2380  */
2381 int
2382 sili_pwait_eq(struct sili_port *ap, int timeout,
2383               bus_size_t r, u_int32_t mask, u_int32_t target)
2384 {
2385         int     t;
2386
2387         /*
2388          * Loop hard up to 100uS
2389          */
2390         for (t = 0; t < 100; ++t) {
2391                 if ((sili_pread(ap, r) & mask) == target)
2392                         return (0);
2393                 sili_os_hardsleep(1);   /* us */
2394         }
2395
2396         do {
2397                 timeout -= sili_os_softsleep();
2398                 if ((sili_pread(ap, r) & mask) == target)
2399                         return (0);
2400         } while (timeout > 0);
2401         return (1);
2402 }
2403
2404 int
2405 sili_wait_ne(struct sili_softc *sc, bus_size_t r, u_int32_t mask,
2406              u_int32_t target)
2407 {
2408         int     t;
2409
2410         /*
2411          * Loop hard up to 100uS
2412          */
2413         for (t = 0; t < 100; ++t) {
2414                 if ((sili_read(sc, r) & mask) != target)
2415                         return (0);
2416                 sili_os_hardsleep(1);   /* us */
2417         }
2418
2419         /*
2420          * And one millisecond the slow way
2421          */
2422         t = 1000;
2423         do {
2424                 t -= sili_os_softsleep();
2425                 if ((sili_read(sc, r) & mask) != target)
2426                         return (0);
2427         } while (t > 0);
2428
2429         return (1);
2430 }
2431
2432
2433 /*
2434  * Acquire an ata transfer.
2435  *
2436  * Pass a NULL at for direct-attached transfers, and a non-NULL at for
2437  * targets that go through the port multiplier.
2438  */
2439 struct ata_xfer *
2440 sili_ata_get_xfer(struct sili_port *ap, struct ata_port *at)
2441 {
2442         struct sili_ccb         *ccb;
2443
2444         ccb = sili_get_ccb(ap);
2445         if (ccb == NULL) {
2446                 DPRINTF(SILI_D_XFER, "%s: sili_ata_get_xfer: NULL ccb\n",
2447                     PORTNAME(ap));
2448                 return (NULL);
2449         }
2450
2451         DPRINTF(SILI_D_XFER, "%s: sili_ata_get_xfer got slot %d\n",
2452             PORTNAME(ap), ccb->ccb_slot);
2453
2454         bzero(ccb->ccb_xa.fis, sizeof(*ccb->ccb_xa.fis));
2455         ccb->ccb_xa.at = at;
2456         ccb->ccb_xa.fis->type = ATA_FIS_TYPE_H2D;
2457
2458         return (&ccb->ccb_xa);
2459 }
2460
2461 void
2462 sili_ata_put_xfer(struct ata_xfer *xa)
2463 {
2464         struct sili_ccb                 *ccb = (struct sili_ccb *)xa;
2465
2466         DPRINTF(SILI_D_XFER, "sili_ata_put_xfer slot %d\n", ccb->ccb_slot);
2467
2468         sili_put_ccb(ccb);
2469 }
2470
2471 int
2472 sili_ata_cmd(struct ata_xfer *xa)
2473 {
2474         struct sili_ccb                 *ccb = (struct sili_ccb *)xa;
2475
2476         KKASSERT(xa->state == ATA_S_SETUP);
2477
2478         if (ccb->ccb_port->ap_state == AP_S_FATAL_ERROR)
2479                 goto failcmd;
2480 #if 0
2481         kprintf("%s: started std command %b ccb %d ccb_at %p %d\n",
2482                 ATANAME(ccb->ccb_port, ccb->ccb_xa.at),
2483                 sili_pread(ccb->ccb_port, SILI_PREG_CMD), SILI_PFMT_CMD,
2484                 ccb->ccb_slot,
2485                 ccb->ccb_xa.at,
2486                 ccb->ccb_xa.at ? ccb->ccb_xa.at->at_target : -1);
2487 #endif
2488
2489         ccb->ccb_done = sili_ata_cmd_done;
2490
2491         if (sili_load_prb(ccb) != 0)
2492                 goto failcmd;
2493
2494         xa->state = ATA_S_PENDING;
2495
2496         if (xa->flags & ATA_F_POLL)
2497                 return (sili_poll(ccb, xa->timeout, sili_ata_cmd_timeout));
2498
2499         crit_enter();
2500         KKASSERT((xa->flags & ATA_F_TIMEOUT_EXPIRED) == 0);
2501         xa->flags |= ATA_F_TIMEOUT_DESIRED;
2502         sili_start(ccb);
2503         crit_exit();
2504         return (xa->state);
2505
2506 failcmd:
2507         crit_enter();
2508         xa->state = ATA_S_ERROR;
2509         xa->complete(xa);
2510         crit_exit();
2511         return (ATA_S_ERROR);
2512 }
2513
2514 static void
2515 sili_ata_cmd_done(struct sili_ccb *ccb)
2516 {
2517         struct ata_xfer                 *xa = &ccb->ccb_xa;
2518
2519         /*
2520          * NOTE: callout does not lock port and may race us modifying
2521          * the flags, so make sure its stopped.
2522          */
2523         if (xa->flags & ATA_F_TIMEOUT_RUNNING) {
2524                 callout_stop(&ccb->ccb_timeout);
2525                 xa->flags &= ~ATA_F_TIMEOUT_RUNNING;
2526         }
2527         xa->flags &= ~(ATA_F_TIMEOUT_DESIRED | ATA_F_TIMEOUT_EXPIRED);
2528
2529         KKASSERT(xa->state != ATA_S_ONCHIP);
2530         sili_unload_prb(ccb);
2531
2532 #ifdef DIAGNOSTIC
2533         else if (xa->state != ATA_S_ERROR && xa->state != ATA_S_TIMEOUT)
2534                 kprintf("%s: invalid ata_xfer state %02x in sili_ata_cmd_done, "
2535                         "slot %d\n",
2536                         PORTNAME(ccb->ccb_port), xa->state, ccb->ccb_slot);
2537 #endif
2538         if (xa->state != ATA_S_TIMEOUT)
2539                 xa->complete(xa);
2540 }
2541
2542 /*
2543  * Timeout from callout, MPSAFE - nothing can mess with the CCB's flags
2544  * while the callout is runing.
2545  *
2546  * We can't safely get the port lock here or delay, we could block
2547  * the callout thread.
2548  */
2549 static void
2550 sili_ata_cmd_timeout_unserialized(void *arg)
2551 {
2552         struct sili_ccb         *ccb = arg;
2553         struct sili_port        *ap = ccb->ccb_port;
2554
2555         ccb->ccb_xa.flags &= ~ATA_F_TIMEOUT_RUNNING;
2556         ccb->ccb_xa.flags |= ATA_F_TIMEOUT_EXPIRED;
2557         sili_os_signal_port_thread(ap, AP_SIGF_TIMEOUT);
2558 }
2559
2560 void
2561 sili_ata_cmd_timeout(struct sili_ccb *ccb)
2562 {
2563         sili_core_timeout(ccb);
2564 }
2565
2566 /*
2567  * Timeout code, typically called when the port command processor is running.
2568  *
2569  * Returns 0 if all timeout processing completed, non-zero if it is still
2570  * in progress.
2571  */
2572 static
2573 int
2574 sili_core_timeout(struct sili_ccb *ccb)
2575 {
2576         struct ata_xfer         *xa = &ccb->ccb_xa;
2577         struct sili_port        *ap = ccb->ccb_port;
2578         struct ata_port         *at;
2579
2580         at = ccb->ccb_xa.at;
2581
2582         kprintf("%s: CMD TIMEOUT state=%d slot=%d\n"
2583                 "\t active=%08x\n"
2584                 "\texpired=%08x\n"
2585                 "\thactive=%08x\n",
2586                 ATANAME(ap, at),
2587                 ccb->ccb_xa.state, ccb->ccb_slot,
2588                 ap->ap_active,
2589                 ap->ap_expired,
2590                 sili_pread(ap, SILI_PREG_SLOTST)
2591         );
2592
2593         /*
2594          * NOTE: Timeout will not be running if the command was polled.
2595          *       If we got here at least one of these flags should be set.
2596          *
2597          *       However, it might be running if we are called from the
2598          *       interrupt error handling code.
2599          */
2600         KKASSERT(xa->flags & (ATA_F_POLL | ATA_F_TIMEOUT_DESIRED |
2601                               ATA_F_TIMEOUT_RUNNING));
2602         if (xa->flags & ATA_F_TIMEOUT_RUNNING) {
2603                 callout_stop(&ccb->ccb_timeout);
2604                 xa->flags &= ~ATA_F_TIMEOUT_RUNNING;
2605         }
2606         xa->flags &= ~ATA_F_TIMEOUT_EXPIRED;
2607
2608         if (ccb->ccb_xa.state == ATA_S_PENDING) {
2609                 TAILQ_REMOVE(&ap->ap_ccb_pending, ccb, ccb_entry);
2610                 ccb->ccb_xa.state = ATA_S_TIMEOUT;
2611                 ccb->ccb_done(ccb);
2612                 xa->complete(xa);
2613                 sili_issue_pending_commands(ap, NULL);
2614                 return(1);
2615         }
2616         if (ccb->ccb_xa.state != ATA_S_ONCHIP) {
2617                 kprintf("%s: Unexpected state during timeout: %d\n",
2618                         ATANAME(ap, at), ccb->ccb_xa.state);
2619                 return(1);
2620         }
2621
2622         /*
2623          * We can't process timeouts while other commands are running.
2624          */
2625         ap->ap_expired |= 1 << ccb->ccb_slot;
2626
2627         if (ap->ap_active != ap->ap_expired) {
2628                 kprintf("%s: Deferred timeout until its safe, slot %d\n",
2629                         ATANAME(ap, at), ccb->ccb_slot);
2630                 return(1);
2631         }
2632
2633         /*
2634          * We have to issue a Port reinit.  We don't read an error log
2635          * page for timeouts.  Reiniting the port will clear all pending
2636          * commands.
2637          */
2638         sili_port_reinit(ap);
2639         return(0);
2640 }
2641
2642 /*
2643  * Used by the softreset, pmprobe, and read_ncq_error only, in very
2644  * specialized, controlled circumstances.
2645  */
2646 void
2647 sili_quick_timeout(struct sili_ccb *ccb)
2648 {
2649         struct sili_port *ap = ccb->ccb_port;
2650
2651         switch (ccb->ccb_xa.state) {
2652         case ATA_S_PENDING:
2653                 TAILQ_REMOVE(&ap->ap_ccb_pending, ccb, ccb_entry);
2654                 ccb->ccb_xa.state = ATA_S_TIMEOUT;
2655                 break;
2656         case ATA_S_ONCHIP:
2657                 KKASSERT((ap->ap_active & ~ap->ap_expired) ==
2658                          (1 << ccb->ccb_slot));
2659                 ccb->ccb_xa.state = ATA_S_TIMEOUT;
2660                 ap->ap_active &= ~(1 << ccb->ccb_slot);
2661                 KKASSERT(ap->ap_active_cnt > 0);
2662                 --ap->ap_active_cnt;
2663                 sili_port_reinit(ap);
2664                 break;
2665         default:
2666                 panic("%s: sili_quick_timeout: ccb in bad state %d",
2667                       ATANAME(ap, ccb->ccb_xa.at), ccb->ccb_xa.state);
2668         }
2669 }
2670
2671 static void
2672 sili_dummy_done(struct ata_xfer *xa)
2673 {
2674 }
2675
2676 static void
2677 sili_empty_done(struct sili_ccb *ccb)
2678 {
2679 }