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