2 * Copyright (c) 2009 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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
35 * Copyright (c) 2006 David Gwynne <dlg@openbsd.org>
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.
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.
51 * $OpenBSD: sili.c,v 1.147 2009/02/16 21:19:07 miod Exp $
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);
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);
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);
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);
78 void sili_issue_pending_commands(struct sili_port *ap, struct sili_ccb *ccb);
80 void sili_port_read_ncq_error(struct sili_port *, int);
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);
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);
91 * Initialize the global SILI hardware. This code does not set up any of
95 sili_init(struct sili_softc *sc)
97 DPRINTF(SILI_D_VERBOSE, " GHC 0x%b",
98 sili_read(sc, SILI_REG_GHC), SILI_FMT_GHC);
101 * Reset the entire chip. This also resets all ports.
103 * The spec doesn't say anything about how long we have to
104 * wait, so wait 10ms.
106 sili_write(sc, SILI_REG_GCTL, SILI_REG_GCTL_GRESET);
108 sili_write(sc, SILI_REG_GCTL, 0);
115 * Allocate and initialize an SILI port.
118 sili_port_alloc(struct sili_softc *sc, u_int port)
120 struct sili_port *ap;
122 struct sili_prb *prb;
123 struct sili_ccb *ccb;
128 ap = kmalloc(sizeof(*ap), M_DEVBUF, M_WAITOK | M_ZERO);
130 ksnprintf(ap->ap_name, sizeof(ap->ap_name), "%s%d.%d",
131 device_get_name(sc->sc_dev),
132 device_get_unit(sc->sc_dev),
134 sc->sc_ports[port] = ap;
137 * Allocate enough so we never have to reallocate, it makes
140 * ap_pmcount will be reduced by the scan if we encounter the
141 * port multiplier port prior to target 15.
143 if (ap->ap_ata == NULL) {
144 ap->ap_ata = kmalloc(sizeof(*ap->ap_ata) * SILI_MAX_PMPORTS,
145 M_DEVBUF, M_INTWAIT | M_ZERO);
146 for (i = 0; i < SILI_MAX_PMPORTS; ++i) {
148 at->at_sili_port = ap;
150 at->at_probe = ATA_PROBE_NEED_INIT;
151 at->at_features |= ATA_PORT_F_RESCAN;
152 ksnprintf(at->at_name, sizeof(at->at_name),
153 "%s.%d", ap->ap_name, i);
156 if (bus_space_subregion(sc->sc_piot, sc->sc_pioh,
157 SILI_PORT_REGION(port), SILI_PORT_SIZE,
159 device_printf(sc->sc_dev,
160 "unable to create register window for port %d\n",
167 ap->ap_probe = ATA_PROBE_NEED_INIT;
168 TAILQ_INIT(&ap->ap_ccb_free);
169 TAILQ_INIT(&ap->ap_ccb_pending);
170 lockinit(&ap->ap_ccb_lock, "silipo", 0, 0);
172 /* Disable port interrupts */
173 sili_pwrite(ap, SILI_PREG_INT_DISABLE, SILI_PREG_INT_MASK);
176 * Reset the port. This is similar to a Device Reset but far
177 * more invasive. We use Device Reset in our hardreset function.
178 * This function also does the same OOB initialization sequence
179 * that Device Reset does.
181 * NOTE: SILI_PREG_STATUS_READY will not be asserted unless and until
182 * a device is connected to the port, so we can't use it to
183 * verify that the port exists.
185 sili_pwrite(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_RESET);
186 if (sili_pread(ap, SILI_PREG_STATUS) & SILI_PREG_STATUS_READY) {
187 device_printf(sc->sc_dev,
188 "Port %d will not go into reset\n", port);
192 sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_RESET);
195 * Allocate the SGE Table
197 ap->ap_dmamem_prbs = sili_dmamem_alloc(sc, sc->sc_tag_prbs);
198 if (ap->ap_dmamem_prbs == NULL) {
199 kprintf("%s: NOSGET\n", PORTNAME(ap));
204 * Set up the SGE table base address
206 ap->ap_prbs = (struct sili_prb *)SILI_DMA_KVA(ap->ap_dmamem_prbs);
209 * Allocate a CCB for each command slot
211 ap->ap_ccbs = kmalloc(sizeof(struct sili_ccb) * sc->sc_ncmds, M_DEVBUF,
213 if (ap->ap_ccbs == NULL) {
214 device_printf(sc->sc_dev,
215 "unable to allocate command list for port %d\n",
221 * Most structures are in the port BAR. Assign convenient
222 * pointers in the CCBs
224 for (i = 0; i < sc->sc_ncmds; i++) {
225 ccb = &ap->ap_ccbs[i];
227 error = bus_dmamap_create(sc->sc_tag_data, BUS_DMA_ALLOCNOW,
230 device_printf(sc->sc_dev,
231 "unable to create dmamap for port %d "
232 "ccb %d\n", port, i);
237 * WARNING!!! Access to the rfis is only allowed under very
238 * carefully controlled circumstances because it
239 * is located in the LRAM and reading from the
240 * LRAM has hardware issues which can blow the
241 * port up. I kid you not (from Linux, and
242 * verified by testing here).
244 callout_init(&ccb->ccb_timeout);
247 ccb->ccb_prb = &ap->ap_prbs[i];
248 ccb->ccb_prb_paddr = SILI_DMA_DVA(ap->ap_dmamem_prbs) +
249 sizeof(*ccb->ccb_prb) * i;
250 ccb->ccb_xa.fis = &ccb->ccb_prb->prb_h2d;
251 prb = bus_space_kva(ap->ap_sc->sc_iot, ap->ap_ioh,
252 SILI_PREG_LRAM_SLOT(i));
253 ccb->ccb_prb_lram = prb;
255 * Point our rfis to host-memory instead of the LRAM PRB.
256 * It will be copied back if ATA_F_AUTOSENSE is set. The
259 /*ccb->ccb_xa.rfis = &prb->prb_d2h;*/
260 ccb->ccb_xa.rfis = (void *)ccb->ccb_xa.fis;
262 ccb->ccb_xa.packetcmd = prb_packet(ccb->ccb_prb);
265 ccb->ccb_xa.state = ATA_S_COMPLETE;
268 * Reserve CCB[1] as the error CCB. It doesn't matter
269 * which one we use for the Sili controllers.
272 ap->ap_err_ccb = ccb;
277 * Do not call sili_port_init() here, the helper thread will
278 * call it for the parallel probe
280 sili_os_start_port(ap);
283 sili_port_free(sc, port);
288 * This is called once by the low level attach (from the helper thread)
289 * to get the port state machine rolling, and typically only called again
290 * on a hot-plug insertion event.
292 * This is called for PM attachments and hot-plug insertion events, and
293 * typically not called again until after an unplug/replug sequence.
295 * Returns 0 if a device is successfully detected.
298 sili_port_init(struct sili_port *ap)
301 * Do a very hard reset of the port
303 sili_pwrite(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_RESET);
305 sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_RESET);
308 * Register initialization
310 sili_pwrite(ap, SILI_PREG_FIFO_CTL,
311 SILI_PREG_FIFO_CTL_ENCODE(1024, 1024));
312 sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_32BITDMA |
314 sili_pwrite(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_NOAUTOCC);
315 if (ap->ap_sc->sc_flags & SILI_F_SSNTF)
316 sili_pwrite(ap, SILI_PREG_SNTF, -1);
317 ap->ap_probe = ATA_PROBE_NEED_HARD_RESET;
319 sili_port_interrupt_enable(ap);
324 * Handle an errored port. This routine is called when the only
325 * commands left on the queue are expired, meaning we can safely
326 * go through a port init to clear its state.
328 * We complete the expired CCBs and then restart the queue.
332 sili_port_reinit(struct sili_port *ap)
334 struct sili_ccb *ccb;
341 reentrant = (ap->ap_flags & AP_F_ERR_CCB_RESERVED) ? 1 : 0;
343 if (bootverbose || 1) {
344 kprintf("%s: reiniting port after error reent=%d "
346 PORTNAME(ap), reentrant, ap->ap_expired);
350 * Clear port resume, clear bits 16:13 in the port device status
351 * register. This is from the data sheet.
353 * Data sheet does not specify a delay but it seems prudent.
355 sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_RESUME);
357 for (target = 0; target < SILI_MAX_PMPORTS; ++target) {
358 data = sili_pread(ap, SILI_PREG_PM_STATUS(target));
359 data &= ~(SILI_PREG_PM_STATUS_SERVICE |
360 SILI_PREG_PM_STATUS_LEGACY |
361 SILI_PREG_PM_STATUS_NATIVE |
362 SILI_PREG_PM_STATUS_VBSY);
363 sili_pwrite(ap, SILI_PREG_PM_STATUS(target), data);
364 sili_pwrite(ap, SILI_PREG_PM_QACTIVE(target), 0);
368 * Issue a Port Initialize and wait for it to clear. This flushes
369 * commands but does not reset the port. Then wait for port ready.
371 sili_pwrite(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_INIT);
372 if (sili_pwait_clr_to(ap, 5000, SILI_PREG_STATUS, SILI_PREG_CTL_INIT)) {
373 kprintf("%s: Unable to reinit, port failed\n",
376 if (sili_pwait_set(ap, SILI_PREG_STATUS, SILI_PREG_STATUS_READY)) {
377 kprintf("%s: Unable to reinit, port will not come ready\n",
382 * If reentrant, stop here. Otherwise the state for the original
383 * ahci_port_reinit() will get ripped out from under it.
389 * Read the LOG ERROR page for targets that returned a specific
390 * D2H FIS with ERR set.
392 for (target = 0; target < SILI_MAX_PMPORTS; ++target) {
393 at = &ap->ap_ata[target];
394 if (at->at_features & ATA_PORT_F_READLOG) {
395 at->at_features &= ~ATA_PORT_F_READLOG;
396 sili_port_read_ncq_error(ap, target);
401 * Finally clean out the expired commands, we've probed the error
402 * status (or hopefully probed the error status). Well, ok,
403 * we probably didn't XXX.
405 while (ap->ap_expired) {
406 slot = ffs(ap->ap_expired) - 1;
407 ap->ap_expired &= ~(1 << slot);
408 KKASSERT(ap->ap_active & (1 << slot));
409 ap->ap_active &= ~(1 << slot);
411 ccb = &ap->ap_ccbs[slot];
412 ccb->ccb_xa.state = ATA_S_TIMEOUT;
414 ccb->ccb_xa.complete(&ccb->ccb_xa);
418 * Wow. All done. We can get the port moving again.
420 if (ap->ap_probe == ATA_PROBE_FAILED) {
421 kprintf("%s: reinit failed, port is dead\n", PORTNAME(ap));
422 while ((ccb = TAILQ_FIRST(&ap->ap_ccb_pending)) != NULL) {
423 TAILQ_REMOVE(&ap->ap_ccb_pending, ccb, ccb_entry);
424 ccb->ccb_xa.flags &= ~ATA_F_TIMEOUT_DESIRED;
425 ccb->ccb_xa.state = ATA_S_TIMEOUT;
427 ccb->ccb_xa.complete(&ccb->ccb_xa);
430 sili_issue_pending_commands(ap, NULL);
435 * Enable or re-enable interrupts on a port.
437 * This routine is called from the port initialization code or from the
438 * helper thread as the real interrupt may be forced to turn off certain
442 sili_port_interrupt_enable(struct sili_port *ap)
446 data = SILI_PREG_INT_CCOMPLETE | SILI_PREG_INT_CERROR |
447 SILI_PREG_INT_PHYRDYCHG | SILI_PREG_INT_DEVEXCHG |
448 SILI_PREG_INT_DECODE | SILI_PREG_INT_CRC |
449 SILI_PREG_INT_HANDSHK | SILI_PREG_INT_PMCHANGE;
450 if (ap->ap_sc->sc_flags & SILI_F_SSNTF)
451 data |= SILI_PREG_INT_SDB;
452 sili_pwrite(ap, SILI_PREG_INT_ENABLE, data);
456 sili_port_interrupt_redisable(struct sili_port *ap)
460 data = sili_read(ap->ap_sc, SILI_REG_GCTL);
461 data &= SILI_REG_GINT_PORTMASK;
462 data &= ~(1 << ap->ap_num);
463 sili_write(ap->ap_sc, SILI_REG_GCTL, data);
467 sili_port_interrupt_reenable(struct sili_port *ap)
471 data = sili_read(ap->ap_sc, SILI_REG_GCTL);
472 data &= SILI_REG_GINT_PORTMASK;
473 data |= (1 << ap->ap_num);
474 sili_write(ap->ap_sc, SILI_REG_GCTL, data);
478 * Run the port / target state machine from a main context.
480 * The state machine for the port is always run.
482 * If atx is non-NULL run the state machine for a particular target.
483 * If atx is NULL run the state machine for all targets.
486 sili_port_state_machine(struct sili_port *ap, int initial)
495 * State machine for port. Note that CAM is not yet associated
496 * during the initial parallel probe and the port's probe state
497 * will not get past ATA_PROBE_NEED_IDENT.
500 if (initial == 0 && ap->ap_probe <= ATA_PROBE_NEED_HARD_RESET) {
501 kprintf("%s: Waiting 7 seconds on insertion\n",
506 if (ap->ap_probe == ATA_PROBE_NEED_INIT)
508 if (ap->ap_probe == ATA_PROBE_NEED_HARD_RESET)
509 sili_port_reset(ap, NULL, 1);
510 if (ap->ap_probe == ATA_PROBE_NEED_SOFT_RESET)
511 sili_port_reset(ap, NULL, 0);
512 if (ap->ap_probe == ATA_PROBE_NEED_IDENT)
513 sili_cam_probe(ap, NULL);
515 if (ap->ap_type != ATA_PORT_T_PM) {
516 if (ap->ap_probe == ATA_PROBE_FAILED) {
517 sili_cam_changed(ap, NULL, 0);
518 } else if (ap->ap_probe >= ATA_PROBE_NEED_IDENT) {
519 sili_cam_changed(ap, NULL, 1);
525 * Port Multiplier state machine.
527 * Get a mask of changed targets and combine with any runnable
528 * states already present.
530 for (loop = 0; ;++loop) {
531 if (sili_pm_read(ap, 15, SATA_PMREG_EINFO, &data)) {
532 kprintf("%s: PM unable to read hot-plug bitmap\n",
538 * Do at least one loop, then stop if no more state changes
539 * have occured. The PM might not generate a new
540 * notification until we clear the entire bitmap.
542 if (loop && data == 0)
546 * New devices showing up in the bitmap require some spin-up
547 * time before we start probing them. Reset didsleep. The
548 * first new device we detect will sleep before probing.
550 * This only applies to devices whos change bit is set in
551 * the data, and does not apply to the initial boot-time
556 for (target = 0; target < ap->ap_pmcount; ++target) {
557 at = &ap->ap_ata[target];
560 * Check the target state for targets behind the PM
561 * which have changed state. This will adjust
562 * at_probe and set ATA_PORT_F_RESCAN
564 * We want to wait at least 10 seconds before probing
565 * a newly inserted device. If the check status
566 * indicates a device is present and in need of a
567 * hard reset, we make sure we have slept before
570 * We also need to wait at least 1 second for the
571 * PHY state to change after insertion, if we
572 * haven't already waited the 10 seconds.
574 * NOTE: When pm_check_good finds a good port it
575 * typically starts us in probe state
576 * NEED_HARD_RESET rather than INIT.
578 if (data & (1 << target)) {
579 if (initial == 0 && didsleep == 0)
581 sili_pm_check_good(ap, target);
582 if (initial == 0 && didsleep == 0 &&
583 at->at_probe <= ATA_PROBE_NEED_HARD_RESET
586 kprintf("%s: Waiting 10 seconds on insertion\n", PORTNAME(ap));
587 sili_os_sleep(10000);
592 * Report hot-plug events before the probe state
593 * really gets hot. Only actual events are reported
594 * here to reduce spew.
596 if (data & (1 << target)) {
597 kprintf("%s: HOTPLUG (PM) - ", ATANAME(ap, at));
598 switch(at->at_probe) {
599 case ATA_PROBE_NEED_INIT:
600 case ATA_PROBE_NEED_HARD_RESET:
601 kprintf("Device inserted\n");
603 case ATA_PROBE_FAILED:
604 kprintf("Device removed\n");
607 kprintf("Device probe in progress\n");
613 * Run through the state machine as necessary if
614 * the port is not marked failed.
616 * The state machine may stop at NEED_IDENT if
617 * CAM is not yet attached.
619 * Acquire exclusive access to the port while we
620 * are doing this. This prevents command-completion
621 * from queueing commands for non-polled targets
622 * inbetween our probe steps. We need to do this
623 * because the reset probes can generate severe PHY
624 * and protocol errors and soft-brick the port.
626 if (at->at_probe != ATA_PROBE_FAILED &&
627 at->at_probe != ATA_PROBE_GOOD) {
628 if (at->at_probe == ATA_PROBE_NEED_INIT)
629 sili_pm_port_init(ap, at);
630 if (at->at_probe == ATA_PROBE_NEED_HARD_RESET)
631 sili_port_reset(ap, at, 1);
632 if (at->at_probe == ATA_PROBE_NEED_SOFT_RESET)
633 sili_port_reset(ap, at, 0);
634 if (at->at_probe == ATA_PROBE_NEED_IDENT)
635 sili_cam_probe(ap, at);
639 * Add or remove from CAM
641 if (at->at_features & ATA_PORT_F_RESCAN) {
642 at->at_features &= ~ATA_PORT_F_RESCAN;
643 if (at->at_probe == ATA_PROBE_FAILED) {
644 sili_cam_changed(ap, at, 0);
645 } else if (at->at_probe >= ATA_PROBE_NEED_IDENT) {
646 sili_cam_changed(ap, at, 1);
649 data &= ~(1 << target);
652 kprintf("%s: WARNING (PM): extra bits set in "
653 "EINFO: %08x\n", PORTNAME(ap), data);
654 while (target < SILI_MAX_PMPORTS) {
655 sili_pm_check_good(ap, target);
663 * De-initialize and detach a port.
666 sili_port_free(struct sili_softc *sc, u_int port)
668 struct sili_port *ap = sc->sc_ports[port];
669 struct sili_ccb *ccb;
672 * Ensure port is disabled and its interrupts are all flushed.
675 sili_os_stop_port(ap);
676 sili_pwrite(ap, SILI_PREG_INT_DISABLE, SILI_PREG_INT_MASK);
677 sili_pwrite(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_RESET);
678 sili_write(ap->ap_sc, SILI_REG_GCTL,
679 sili_read(ap->ap_sc, SILI_REG_GCTL) &
680 ~SILI_REG_GINT_PORTST(ap->ap_num));
684 while ((ccb = sili_get_ccb(ap)) != NULL) {
685 if (ccb->ccb_dmamap) {
686 bus_dmamap_destroy(sc->sc_tag_data,
688 ccb->ccb_dmamap = NULL;
691 if ((ccb = ap->ap_err_ccb) != NULL) {
692 if (ccb->ccb_dmamap) {
693 bus_dmamap_destroy(sc->sc_tag_data,
695 ccb->ccb_dmamap = NULL;
697 ap->ap_err_ccb = NULL;
699 kfree(ap->ap_ccbs, M_DEVBUF);
703 if (ap->ap_dmamem_prbs) {
704 sili_dmamem_free(sc, ap->ap_dmamem_prbs);
705 ap->ap_dmamem_prbs = NULL;
708 kfree(ap->ap_ata, M_DEVBUF);
712 /* bus_space(9) says we dont free the subregions handle */
715 sc->sc_ports[port] = NULL;
721 * If hard is 0 perform a softreset of the port.
722 * If hard is 1 perform a hard reset of the port.
723 * If hard is 2 perform a hard reset of the port and cycle the phy.
725 * If at is non-NULL an indirect port via a port-multiplier is being
726 * reset, otherwise a direct port is being reset.
728 * NOTE: Indirect ports can only be soft-reset.
731 sili_port_reset(struct sili_port *ap, struct ata_port *at, int hard)
737 rc = sili_pm_hardreset(ap, at->at_target, hard);
739 rc = sili_port_hardreset(ap);
742 rc = sili_pm_softreset(ap, at->at_target);
744 rc = sili_port_softreset(ap);
750 * SILI soft reset, Section 10.4.1
752 * (at) will be NULL when soft-resetting a directly-attached device, and
753 * non-NULL when soft-resetting a device through a port multiplier.
755 * This function keeps port communications intact and attempts to generate
756 * a reset to the connected device using device commands.
759 sili_port_softreset(struct sili_port *ap)
761 struct sili_ccb *ccb = NULL;
762 struct sili_prb *prb;
769 kprintf("%s: START SOFTRESET\n", PORTNAME(ap));
772 ap->ap_state = AP_S_NORMAL;
775 * Prep the special soft-reset SII command.
777 ccb = sili_get_err_ccb(ap);
778 ccb->ccb_done = sili_empty_done;
779 ccb->ccb_xa.flags = ATA_F_POLL | ATA_F_AUTOSENSE | ATA_F_EXCLUSIVE;
780 ccb->ccb_xa.complete = sili_dummy_done;
781 ccb->ccb_xa.at = NULL;
784 bzero(&prb->prb_h2d, sizeof(prb->prb_h2d));
785 prb->prb_h2d.flags = 0;
786 prb->prb_control = SILI_PRB_CTRL_SOFTRESET;
787 prb->prb_override = 0;
788 prb->prb_xfer_count = 0;
790 ccb->ccb_xa.state = ATA_S_PENDING;
793 * NOTE: Must use sili_quick_timeout() because we hold the err_ccb
795 if (sili_poll(ccb, 8000, sili_quick_timeout) != ATA_S_COMPLETE) {
796 kprintf("%s: First FIS failed\n", PORTNAME(ap));
800 sig = (prb->prb_d2h.lba_high << 24) |
801 (prb->prb_d2h.lba_mid << 16) |
802 (prb->prb_d2h.lba_low << 8) |
803 (prb->prb_d2h.sector_count);
805 kprintf("%s: SOFTRESET SIGNATURE %08x\n", PORTNAME(ap), sig);
808 * If the softreset is trying to clear a BSY condition after a
809 * normal portreset we assign the port type.
811 * If the softreset is being run first as part of the ccb error
812 * processing code then report if the device signature changed
815 if (ap->ap_type == ATA_PORT_T_NONE) {
816 ap->ap_type = sili_port_signature(ap, NULL, sig);
818 if (sili_port_signature(ap, NULL, sig) != ap->ap_type) {
819 kprintf("%s: device signature unexpectedly "
820 "changed\n", PORTNAME(ap));
821 error = EBUSY; /* XXX */
827 sili_put_err_ccb(ccb);
831 * If we failed to softreset make the port quiescent, otherwise
832 * make sure the port's start/stop state matches what it was on
835 * Don't kill the port if the softreset is on a port multiplier
836 * target, that would kill all the targets!
839 kprintf("%s: END SOFTRESET %d prob=%d state=%d\n",
840 PORTNAME(ap), error, ap->ap_probe, ap->ap_state);
843 sili_port_hardstop(ap);
844 /* ap_probe set to failed */
846 ap->ap_probe = ATA_PROBE_NEED_IDENT;
851 sili_pwrite(ap, SILI_PREG_SERR, -1);
853 kprintf("%s: END SOFTRESET\n", PORTNAME(ap));
859 * This function does a hard reset of the port. Note that the device
860 * connected to the port could still end-up hung. Phy detection is
861 * used to short-cut longer operations.
864 sili_port_hardreset(struct sili_port *ap)
871 kprintf("%s: START HARDRESET\n", PORTNAME(ap));
873 ap->ap_state = AP_S_NORMAL;
876 * Set SCTL up for any speed restrictions before issuing the
877 * device reset. This may also take us out of an INIT state
878 * (if we were previously in a continuous reset state from
879 * sili_port_listen()).
881 data = SILI_PREG_SCTL_SPM_NONE |
882 SILI_PREG_SCTL_IPM_NONE |
883 SILI_PREG_SCTL_SPD_NONE |
884 SILI_PREG_SCTL_DET_NONE;
885 if (SiliForceGen1 & (1 << ap->ap_num)) {
886 data &= ~SILI_PREG_SCTL_SPD_NONE;
887 data |= SILI_PREG_SCTL_SPD_GEN1;
889 sili_pwrite(ap, SILI_PREG_SCTL, data);
892 * The transition from a continuous COMRESET state from
893 * sili_port_listen() back to device detect can take a
894 * few seconds. It's quite non-deterministic. Most of
895 * the time it takes far less. Use a polling loop to
900 data = sili_pread(ap, SILI_PREG_SSTS);
901 if (data & SILI_PREG_SSTS_DET)
903 loop -= sili_os_softsleep();
908 * Issue Device Reset, give the phy a little time to settle down.
910 * NOTE: Unlike Port Reset, the port ready signal will not
911 * go active unless a device is established to be on
914 sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_PMA);
915 sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_RESUME);
916 sili_pwrite(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_DEVRESET);
917 if (sili_pwait_clr(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_DEVRESET)) {
918 kprintf("%s: hardreset failed to clear\n", PORTNAME(ap));
923 * Try to determine if there is a device on the port.
925 * Give the device 3/10 second to at least be detected.
929 data = sili_pread(ap, SILI_PREG_SSTS);
930 if (data & SILI_PREG_SSTS_DET)
932 loop -= sili_os_softsleep();
936 kprintf("%s: Port appears to be unplugged\n",
944 * There is something on the port. Give the device 3 seconds
947 if (sili_pwait_eq(ap, 3000, SILI_PREG_SSTS,
948 SILI_PREG_SSTS_DET, SILI_PREG_SSTS_DET_DEV)) {
950 kprintf("%s: Device may be powered down\n",
958 * We got something that definitely looks like a device. Give
959 * the device time to send us its first D2H FIS.
961 * This effectively waits for BSY to clear.
963 if (sili_pwait_set_to(ap, 3000, SILI_PREG_STATUS,
964 SILI_PREG_STATUS_READY)) {
972 * Do the PM port probe regardless of how things turned out above.
974 * If the PM port probe fails it will return the original error
977 if (ap->ap_sc->sc_flags & SILI_F_SPM) {
978 error = sili_pm_port_probe(ap, error);
987 if (ap->ap_type == ATA_PORT_T_PM)
988 ap->ap_probe = ATA_PROBE_GOOD;
990 ap->ap_probe = ATA_PROBE_NEED_SOFT_RESET;
994 * No device detected.
996 data = sili_pread(ap, SILI_PREG_SSTS);
998 switch(data & SATA_PM_SSTS_DET) {
999 case SILI_PREG_SSTS_DET_DEV_NE:
1000 kprintf("%s: Device not communicating\n",
1003 case SILI_PREG_SSTS_DET_OFFLINE:
1004 kprintf("%s: PHY offline\n",
1008 kprintf("%s: No device detected\n",
1012 sili_port_hardstop(ap);
1018 kprintf("%s: Device on port is bricked\n",
1020 sili_port_hardstop(ap);
1023 sili_pwrite(ap, SILI_PREG_SERR, -1);
1026 kprintf("%s: END HARDRESET %d\n", PORTNAME(ap), error);
1031 * Hard-stop on hot-swap device removal. See 10.10.1
1033 * Place the port in a mode that will allow it to detect hot-swap insertions.
1034 * This is a bit imprecise because just setting-up SCTL to DET_INIT doesn't
1035 * seem to do the job.
1038 sili_port_hardstop(struct sili_port *ap)
1040 struct sili_ccb *ccb;
1041 struct ata_port *at;
1045 ap->ap_state = AP_S_FATAL_ERROR;
1046 ap->ap_probe = ATA_PROBE_FAILED;
1047 ap->ap_type = ATA_PORT_T_NONE;
1050 * Clean up AT sub-ports on SATA port.
1052 for (i = 0; ap->ap_ata && i < SILI_MAX_PMPORTS; ++i) {
1053 at = &ap->ap_ata[i];
1054 at->at_type = ATA_PORT_T_NONE;
1055 at->at_probe = ATA_PROBE_FAILED;
1056 at->at_features &= ~ATA_PORT_F_READLOG;
1060 * Kill the port. Don't bother waiting for it to transition
1063 sili_pwrite(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_RESET);
1064 if (sili_pread(ap, SILI_PREG_STATUS) & SILI_PREG_STATUS_READY) {
1065 kprintf("%s: Port will not go into reset\n",
1069 sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_RESET);
1072 * Turn off port-multiplier control bit
1074 sili_pwrite(ap, SILI_PREG_CTL_CLR, SILI_PREG_CTL_PMA);
1077 * Clean up the command list.
1079 while (ap->ap_active) {
1080 slot = ffs(ap->ap_active) - 1;
1081 ap->ap_active &= ~(1 << slot);
1082 ap->ap_expired &= ~(1 << slot);
1083 --ap->ap_active_cnt;
1084 ccb = &ap->ap_ccbs[slot];
1085 if (ccb->ccb_xa.flags & ATA_F_TIMEOUT_RUNNING) {
1086 callout_stop(&ccb->ccb_timeout);
1087 ccb->ccb_xa.flags &= ~ATA_F_TIMEOUT_RUNNING;
1089 ccb->ccb_xa.flags &= ~(ATA_F_TIMEOUT_DESIRED |
1090 ATA_F_TIMEOUT_EXPIRED);
1091 ccb->ccb_xa.state = ATA_S_TIMEOUT;
1093 ccb->ccb_xa.complete(&ccb->ccb_xa);
1095 while ((ccb = TAILQ_FIRST(&ap->ap_ccb_pending)) != NULL) {
1096 TAILQ_REMOVE(&ap->ap_ccb_pending, ccb, ccb_entry);
1097 ccb->ccb_xa.state = ATA_S_TIMEOUT;
1098 ccb->ccb_xa.flags &= ~ATA_F_TIMEOUT_DESIRED;
1100 ccb->ccb_xa.complete(&ccb->ccb_xa);
1102 KKASSERT(ap->ap_active_cnt == 0);
1105 * Put the port into a listen mode, we want to get insertion/removal
1108 sili_port_listen(ap);
1112 * Place port into a listen mode for hotplug events only. The port has
1113 * already been reset and the command processor may not be ready due
1114 * to the lack of a device.
1117 sili_port_listen(struct sili_port *ap)
1122 data = SILI_PREG_SCTL_SPM_NONE |
1123 SILI_PREG_SCTL_IPM_NONE |
1124 SILI_PREG_SCTL_SPD_NONE |
1125 SILI_PREG_SCTL_DET_INIT;
1126 if (SiliForceGen1 & (1 << ap->ap_num)) {
1127 data &= ~SILI_PREG_SCTL_SPD_NONE;
1128 data |= SILI_PREG_SCTL_SPD_GEN1;
1132 sili_pwrite(ap, SILI_PREG_SERR, -1);
1133 sili_pwrite(ap, SILI_PREG_INT_ENABLE, SILI_PREG_INT_PHYRDYCHG |
1134 SILI_PREG_INT_DEVEXCHG);
1138 * Figure out what type of device is connected to the port, ATAPI or
1142 sili_port_signature(struct sili_port *ap, struct ata_port *at, u_int32_t sig)
1145 kprintf("%s: sig %08x\n", ATANAME(ap, at), sig);
1146 if ((sig & 0xffff0000) == (SATA_SIGNATURE_ATAPI & 0xffff0000)) {
1147 return(ATA_PORT_T_ATAPI);
1148 } else if ((sig & 0xffff0000) ==
1149 (SATA_SIGNATURE_PORT_MULTIPLIER & 0xffff0000)) {
1150 return(ATA_PORT_T_PM);
1152 return(ATA_PORT_T_DISK);
1157 * Load the DMA descriptor table for a CCB's buffer.
1159 * NOTE: ATA_F_PIO is auto-selected by sili part.
1162 sili_load_prb(struct sili_ccb *ccb)
1164 struct sili_port *ap = ccb->ccb_port;
1165 struct sili_softc *sc = ap->ap_sc;
1166 struct ata_xfer *xa = &ccb->ccb_xa;
1167 struct sili_prb *prb = ccb->ccb_prb;
1168 struct sili_sge *sge;
1169 bus_dmamap_t dmap = ccb->ccb_dmamap;
1173 * Set up the PRB. The PRB contains 2 SGE's (1 if it is an ATAPI
1174 * command). The SGE must be set up to link to the rest of our
1175 * SGE array, in blocks of four SGEs (a SGE table) starting at
1177 prb->prb_xfer_count = 0;
1178 prb->prb_control = 0;
1179 prb->prb_override = 0;
1180 sge = (ccb->ccb_xa.flags & ATA_F_PACKET) ?
1181 &prb->prb_sge_packet : &prb->prb_sge_normal;
1182 if (xa->datalen == 0) {
1183 sge->sge_flags = SILI_SGE_FLAGS_TRM | SILI_SGE_FLAGS_DRD;
1188 if (ccb->ccb_xa.flags & ATA_F_READ)
1189 prb->prb_control |= SILI_PRB_CTRL_READ;
1190 if (ccb->ccb_xa.flags & ATA_F_WRITE)
1191 prb->prb_control |= SILI_PRB_CTRL_WRITE;
1192 sge->sge_flags = SILI_SGE_FLAGS_LNK;
1194 sge->sge_paddr = ccb->ccb_prb_paddr +
1195 offsetof(struct sili_prb, prb_sge[0]);
1198 * Load our sge array.
1200 error = bus_dmamap_load(sc->sc_tag_data, dmap,
1201 xa->data, xa->datalen,
1202 sili_load_prb_callback,
1204 ((xa->flags & ATA_F_NOWAIT) ?
1205 BUS_DMA_NOWAIT : BUS_DMA_WAITOK));
1207 kprintf("%s: error %d loading dmamap\n", PORTNAME(ap), error);
1211 bus_dmamap_sync(sc->sc_tag_data, dmap,
1212 (xa->flags & ATA_F_READ) ?
1213 BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
1219 bus_dmamap_unload(sc->sc_tag_data, dmap);
1225 * Callback from BUSDMA system to load the segment list.
1227 * The scatter/gather table is loaded by the sili chip in blocks of
1228 * four SGE's. If a continuance is required the last entry in each
1229 * block must point to the next block.
1233 sili_load_prb_callback(void *info, bus_dma_segment_t *segs, int nsegs,
1236 struct sili_ccb *ccb = info;
1237 struct sili_sge *sge;
1240 KKASSERT(nsegs <= SILI_MAX_SGET);
1243 sge = &ccb->ccb_prb->prb_sge[0];
1245 if ((sgi & 3) == 3) {
1246 sge->sge_paddr = htole64(ccb->ccb_prb_paddr +
1247 offsetof(struct sili_prb,
1250 sge->sge_flags = SILI_SGE_FLAGS_LNK;
1252 sge->sge_paddr = htole64(segs->ds_addr);
1253 sge->sge_count = htole32(segs->ds_len);
1262 sge->sge_flags |= SILI_SGE_FLAGS_TRM;
1266 sili_unload_prb(struct sili_ccb *ccb)
1268 struct sili_port *ap = ccb->ccb_port;
1269 struct sili_softc *sc = ap->ap_sc;
1270 struct ata_xfer *xa = &ccb->ccb_xa;
1271 bus_dmamap_t dmap = ccb->ccb_dmamap;
1273 if (xa->datalen != 0) {
1274 bus_dmamap_sync(sc->sc_tag_data, dmap,
1275 (xa->flags & ATA_F_READ) ?
1276 BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
1278 bus_dmamap_unload(sc->sc_tag_data, dmap);
1280 if (ccb->ccb_xa.flags & ATA_F_NCQ)
1283 xa->resid = xa->datalen -
1284 le32toh(ccb->ccb_prb->prb_xfer_count);
1289 * Start a command and poll for completion.
1291 * timeout is in ms and only counts once the command gets on-chip.
1293 * Returns ATA_S_* state, compare against ATA_S_COMPLETE to determine
1294 * that no error occured.
1296 * NOTE: If the caller specifies a NULL timeout function the caller is
1297 * responsible for clearing hardware state on failure, but we will
1298 * deal with removing the ccb from any pending queue.
1300 * NOTE: NCQ should never be used with this function.
1302 * NOTE: If the port is in a failed state and stopped we do not try
1303 * to activate the ccb.
1306 sili_poll(struct sili_ccb *ccb, int timeout,
1307 void (*timeout_fn)(struct sili_ccb *))
1309 struct sili_port *ap = ccb->ccb_port;
1311 if (ccb->ccb_port->ap_state == AP_S_FATAL_ERROR) {
1312 ccb->ccb_xa.state = ATA_S_ERROR;
1313 return(ccb->ccb_xa.state);
1319 sili_port_intr(ap, 1);
1320 switch(ccb->ccb_xa.state) {
1322 timeout -= sili_os_softsleep();
1326 * The packet can get stuck on the pending queue
1327 * if the port refuses to come ready. XXX
1330 if (xxx AP_F_EXCLUSIVE_ACCESS)
1331 timeout -= sili_os_softsleep();
1334 sili_os_softsleep();
1335 sili_check_active_timeouts(ap);
1338 return (ccb->ccb_xa.state);
1340 } while (timeout > 0);
1343 * Don't spew if this is a probe during hard reset
1345 if (ap->ap_probe != ATA_PROBE_NEED_HARD_RESET) {
1346 kprintf("%s: Poll timeout slot %d\n",
1347 ATANAME(ap, ccb->ccb_xa.at),
1353 return(ccb->ccb_xa.state);
1357 * When polling we have to check if the currently active CCB(s)
1358 * have timed out as the callout will be deadlocked while we
1359 * hold the port lock.
1362 sili_check_active_timeouts(struct sili_port *ap)
1364 struct sili_ccb *ccb;
1368 mask = ap->ap_active;
1370 tag = ffs(mask) - 1;
1371 mask &= ~(1 << tag);
1372 ccb = &ap->ap_ccbs[tag];
1373 if (ccb->ccb_xa.flags & ATA_F_TIMEOUT_EXPIRED) {
1374 sili_core_timeout(ccb, 0);
1382 sili_start_timeout(struct sili_ccb *ccb)
1384 if (ccb->ccb_xa.flags & ATA_F_TIMEOUT_DESIRED) {
1385 ccb->ccb_xa.flags |= ATA_F_TIMEOUT_RUNNING;
1386 callout_reset(&ccb->ccb_timeout,
1387 (ccb->ccb_xa.timeout * hz + 999) / 1000,
1388 sili_ata_cmd_timeout_unserialized, ccb);
1393 sili_start(struct sili_ccb *ccb)
1395 struct sili_port *ap = ccb->ccb_port;
1397 struct sili_softc *sc = ap->ap_sc;
1400 KKASSERT(ccb->ccb_xa.state == ATA_S_PENDING);
1403 * Sync our SGE table and PRB
1405 bus_dmamap_sync(ap->ap_dmamem_prbs->adm_tag,
1406 ap->ap_dmamem_prbs->adm_map,
1407 BUS_DMASYNC_PREWRITE);
1410 * XXX dmamap for PRB XXX BUS_DMASYNC_PREWRITE
1414 * Controller will update shared memory!
1415 * XXX bus_dmamap_sync ... BUS_DMASYNC_PREREAD ...
1417 /* Prepare RFIS area for write by controller */
1420 * There's no point trying to optimize this, it only shaves a few
1421 * nanoseconds so just queue the command and call our generic issue.
1423 sili_issue_pending_commands(ap, ccb);
1428 * While holding the port lock acquire exclusive access to the port.
1430 * This is used when running the state machine to initialize and identify
1431 * targets over a port multiplier. Setting exclusive access prevents
1432 * sili_port_intr() from activating any requests sitting on the pending
1436 sili_beg_exclusive_access(struct sili_port *ap, struct ata_port *at)
1438 KKASSERT((ap->ap_flags & AP_F_EXCLUSIVE_ACCESS) == 0);
1439 ap->ap_flags |= AP_F_EXCLUSIVE_ACCESS;
1440 while (ap->ap_active) {
1441 sili_port_intr(ap, 1);
1442 sili_os_softsleep();
1447 sili_end_exclusive_access(struct sili_port *ap, struct ata_port *at)
1449 KKASSERT((ap->ap_flags & AP_F_EXCLUSIVE_ACCESS) != 0);
1450 ap->ap_flags &= ~AP_F_EXCLUSIVE_ACCESS;
1451 sili_issue_pending_commands(ap, NULL);
1456 * If ccb is not NULL enqueue and/or issue it.
1458 * If ccb is NULL issue whatever we can from the queue. However, nothing
1459 * new is issued if the exclusive access flag is set or expired ccb's are
1462 * If existing commands are still active (ap_active) we can only
1463 * issue matching new commands.
1466 sili_issue_pending_commands(struct sili_port *ap, struct sili_ccb *ccb)
1471 * If just running the queue and in exclusive access mode we
1472 * just return. Also in this case if there are any expired ccb's
1473 * we want to clear the queue so the port can be safely stopped.
1475 * XXX sili chip - expiration needs to be per-target if PM supports
1479 TAILQ_INSERT_TAIL(&ap->ap_ccb_pending, ccb, ccb_entry);
1480 } else if (ap->ap_expired) {
1485 * Pull the next ccb off the queue and run it if possible.
1486 * If the port is not ready to accept commands enable the
1487 * ready interrupt instead of starting a new command.
1489 * XXX limit ncqdepth for attached devices behind PM
1491 while ((ccb = TAILQ_FIRST(&ap->ap_ccb_pending)) != NULL) {
1493 * Port may be wedged.
1495 if ((sili_pread(ap, SILI_PREG_STATUS) &
1496 SILI_PREG_STATUS_READY) == 0) {
1497 kprintf("%s: slot %d NOT READY\n",
1498 ATANAME(ap, ccb->ccb_xa.at), ccb->ccb_slot);
1499 sili_pwrite(ap, SILI_PREG_INT_ENABLE,
1500 SILI_PREG_INT_READY);
1505 * Handle exclusivity requirements. ATA_F_EXCLUSIVE is used
1506 * when we may have to access the rfis which is stored in
1507 * the LRAM PRB. Unfortunately reading the LRAM PRB is
1508 * highly problematic, so requests (like PM requests) which
1509 * need to access the rfis use exclusive mode and then
1510 * access the copy made by the port interrupt code back in
1513 if (ap->ap_active & ~ap->ap_expired) {
1515 * There may be multiple ccb's already running,
1516 * but there will only be one if it is exclusive.
1517 * We can't queue a new command in that case.
1519 * XXX Current AUTOSENSE code forces exclusivity
1520 * to simplify the code.
1522 KKASSERT(ap->ap_last_ccb);
1523 KKASSERT(ap->ap_active &
1524 (1 << ap->ap_last_ccb->ccb_slot));
1525 if (ap->ap_last_ccb->ccb_xa.flags &
1526 (ATA_F_EXCLUSIVE | ATA_F_AUTOSENSE)) {
1531 * If the ccb we want to run is exclusive and ccb's
1532 * are still active on the port, we can't queue it
1535 * XXX Current AUTOSENSE code forces exclusivity
1536 * to simplify the code.
1538 if (ccb->ccb_xa.flags &
1539 (ATA_F_EXCLUSIVE | ATA_F_AUTOSENSE)) {
1544 TAILQ_REMOVE(&ap->ap_ccb_pending, ccb, ccb_entry);
1545 ccb->ccb_xa.state = ATA_S_ONCHIP;
1546 ap->ap_active |= 1 << ccb->ccb_slot;
1547 ap->ap_active_cnt++;
1548 ap->ap_last_ccb = ccb;
1551 * We can't use the CMD_FIFO method because it requires us
1552 * building the PRB in the LRAM, and the LRAM is buggy. So
1553 * we use host memory for the PRB.
1555 sili_pwrite(ap, SILI_PREG_CMDACT(ccb->ccb_slot),
1556 (u_int32_t)ccb->ccb_prb_paddr);
1557 sili_pwrite(ap, SILI_PREG_CMDACT(ccb->ccb_slot) + 4,
1558 (u_int32_t)(ccb->ccb_prb_paddr >> 32));
1559 /* sili_pwrite(ap, SILI_PREG_CMD_FIFO, ccb->ccb_slot); */
1560 sili_start_timeout(ccb);
1565 sili_intr(void *arg)
1567 struct sili_softc *sc = arg;
1568 struct sili_port *ap;
1573 * Check if the master enable is up, and whether any interrupts are
1576 * Clear the ints we got.
1578 if ((sc->sc_flags & SILI_F_INT_GOOD) == 0)
1580 gint = sili_read(sc, SILI_REG_GINT);
1581 if (gint == 0 || gint == 0xffffffff)
1583 sili_write(sc, SILI_REG_GINT, gint);
1586 * Process interrupts for each port in a non-blocking fashion.
1588 while (gint & SILI_REG_GINT_PORTMASK) {
1589 port = ffs(gint) - 1;
1590 ap = sc->sc_ports[port];
1592 if (sili_os_lock_port_nb(ap) == 0) {
1593 sili_port_intr(ap, 0);
1594 sili_os_unlock_port(ap);
1596 sili_port_interrupt_redisable(ap);
1597 sili_os_signal_port_thread(ap, AP_SIGF_PORTINT);
1600 gint &= ~(1 << port);
1605 * Core called from helper thread.
1608 sili_port_thread_core(struct sili_port *ap, int mask)
1611 * Process any expired timedouts.
1613 sili_os_lock_port(ap);
1614 if (mask & AP_SIGF_TIMEOUT) {
1615 sili_check_active_timeouts(ap);
1619 * Process port interrupts which require a higher level of
1622 if (mask & AP_SIGF_PORTINT) {
1623 sili_port_intr(ap, 1);
1624 sili_port_interrupt_reenable(ap);
1625 sili_os_unlock_port(ap);
1627 sili_os_unlock_port(ap);
1632 * Core per-port interrupt handler.
1634 * If blockable is 0 we cannot call sili_os_sleep() at all and we can only
1635 * deal with normal command completions which do not require blocking.
1638 sili_port_intr(struct sili_port *ap, int blockable)
1640 struct sili_softc *sc = ap->ap_sc;
1643 struct sili_ccb *ccb = NULL;
1644 struct ata_port *ccb_at = NULL;
1650 const u_int32_t blockable_mask = SILI_PREG_IST_PHYRDYCHG |
1651 SILI_PREG_IST_DEVEXCHG |
1652 SILI_PREG_IST_CERROR |
1653 SILI_PREG_IST_DECODE |
1655 SILI_PREG_IST_HANDSHK;
1656 const u_int32_t fatal_mask = SILI_PREG_IST_PHYRDYCHG |
1657 SILI_PREG_IST_DEVEXCHG |
1658 SILI_PREG_IST_DECODE |
1660 SILI_PREG_IST_HANDSHK;
1662 enum { NEED_NOTHING, NEED_HOTPLUG_INSERT,
1663 NEED_HOTPLUG_REMOVE } need = NEED_NOTHING;
1666 * NOTE: CCOMPLETE was automatically cleared when we read INT_STATUS.
1668 is = sili_pread(ap, SILI_PREG_INT_STATUS);
1669 is &= SILI_PREG_IST_MASK;
1670 if (is & SILI_PREG_IST_CCOMPLETE)
1671 sili_pwrite(ap, SILI_PREG_INT_STATUS, SILI_PREG_IST_CCOMPLETE);
1674 * If we can't block then we can't handle these here. Disable
1675 * the interrupts in question so we don't live-lock, the helper
1676 * thread will re-enable them.
1678 * If the port is in a completely failed state we do not want
1679 * to drop through to failed-command-processing if blockable is 0,
1680 * just let the thread deal with it all.
1682 * Otherwise we fall through and still handle DHRS and any commands
1683 * which completed normally. Even if we are errored we haven't
1684 * stopped the port yet so CI/SACT are still good.
1686 if (blockable == 0) {
1687 if (ap->ap_state == AP_S_FATAL_ERROR) {
1688 sili_port_interrupt_redisable(ap);
1689 sili_os_signal_port_thread(ap, AP_SIGF_PORTINT);
1690 /*is &= ~blockable_mask;*/
1693 if (is & blockable_mask) {
1694 sili_port_interrupt_redisable(ap);
1695 sili_os_signal_port_thread(ap, AP_SIGF_PORTINT);
1696 /*is &= ~blockable_mask;*/
1701 if (is & SILI_PREG_IST_CERROR) {
1703 * Command failed (blockable).
1705 * This stops command processing. We can extract the PM
1706 * target from the PMP field in SILI_PREG_CONTEXT. The
1707 * tag is not necessarily valid so don't use that.
1709 * We must then expire all CCB's for that target and resume
1710 * processing if any other targets have active commands.
1711 * Particular error codes can be recovered by reading the LOG
1714 * The expire handling code will do the rest, which is
1715 * basically to reset the port once the only active
1716 * commands remaining are all expired.
1722 target = (sili_pread(ap, SILI_PREG_CONTEXT) >>
1723 SILI_PREG_CONTEXT_PMPORT_SHIFT) &
1724 SILI_PREG_CONTEXT_PMPORT_MASK;
1725 sili_pwrite(ap, SILI_PREG_INT_STATUS, SILI_PREG_IST_CERROR);
1726 active = ap->ap_active & ~ap->ap_expired;
1727 error = sili_pread(ap, SILI_PREG_CERROR);
1728 kprintf("%s.%d target error %d active=%08x hactive=%08x "
1730 PORTNAME(ap), target, error,
1731 active, sili_pread(ap, SILI_PREG_SLOTST),
1732 sili_pread(ap, SILI_PREG_SERR), SILI_PFMT_SERR);
1735 slot = ffs(active) - 1;
1736 ccb = &ap->ap_ccbs[slot];
1737 if ((ccb_at = ccb->ccb_xa.at) == NULL)
1738 ccb_at = &ap->ap_ata[0];
1739 if (target == ccb_at->at_target) {
1740 if (ccb->ccb_xa.flags & ATA_F_NCQ &&
1741 (error == SILI_PREG_CERROR_DEVICE ||
1742 error == SILI_PREG_CERROR_SDBERROR)) {
1743 ccb_at->at_features |= ATA_PORT_F_READLOG;
1745 if (sili_core_timeout(ccb, 1) == 0)
1748 active &= ~(1 << slot);
1752 * Resume will be 0 if the timeout reinited and restarted
1753 * the port. Otherwise we resume the port to allow other
1754 * commands to complete.
1757 sili_pwrite(ap, SILI_PREG_CTL_SET, SILI_PREG_CTL_RESUME);
1761 * Device notification to us (non-blocking)
1763 * This is interrupt status SILIPREG_IST_SDB
1765 * NOTE! On some parts notification bits can get set without
1766 * generating an interrupt. It is unclear whether this is
1767 * a bug in the PM (sending a DTOH device setbits with 'N' set
1768 * and 'I' not set), or a bug in the host controller.
1770 * It only seems to occur under load.
1772 if (sc->sc_flags & SILI_F_SSNTF) {
1776 data = sili_pread(ap, SILI_PREG_SNTF);
1777 if (is & SILI_PREG_IST_SDB) {
1778 sili_pwrite(ap, SILI_PREG_INT_STATUS,
1780 is &= ~SILI_PREG_IST_SDB;
1781 xstr = " (no SDBS!)";
1786 kprintf("%s: NOTIFY %08x%s\n",
1787 PORTNAME(ap), data, xstr);
1788 sili_pwrite(ap, SILI_PREG_SNTF, data);
1789 sili_cam_changed(ap, NULL, -1);
1794 * Port change (hot-plug) (blockable).
1796 * A PCS interrupt will occur on hot-plug once communication is
1799 * A PRCS interrupt will occur on hot-unplug (and possibly also
1802 * XXX We can then check the CPS (Cold Presence State) bit, if
1803 * supported, to determine if a device is plugged in or not and do
1806 * WARNING: A PCS interrupt is cleared by clearing DIAG_X, and
1807 * can also occur if an unsolicited COMINIT is received.
1808 * If this occurs command processing is automatically
1809 * stopped (CR goes inactive) and the port must be stopped
1812 if (is & (SILI_PREG_IST_PHYRDYCHG | SILI_PREG_IST_DEVEXCHG)) {
1814 sili_pwrite(ap, SILI_PREG_SERR,
1815 (SILI_PREG_SERR_DIAG_N | SILI_PREG_SERR_DIAG_X));
1816 sili_pwrite(ap, SILI_PREG_INT_STATUS,
1817 is & (SILI_PREG_IST_PHYRDYCHG | SILI_PREG_IST_DEVEXCHG));
1819 is &= ~(SILI_PREG_IST_PHYRDYCHG | SILI_PREG_IST_DEVEXCHG);
1820 kprintf("%s: Port change\n", PORTNAME(ap));
1822 switch (sili_pread(ap, SILI_PREG_SSTS) & SILI_PREG_SSTS_DET) {
1823 case SILI_PREG_SSTS_DET_DEV:
1824 if (ap->ap_type == ATA_PORT_T_NONE &&
1825 ap->ap_probe == ATA_PROBE_FAILED) {
1826 need = NEED_HOTPLUG_INSERT;
1831 kprintf("%s: Device lost\n", PORTNAME(ap));
1832 if (ap->ap_type != ATA_PORT_T_NONE) {
1833 need = NEED_HOTPLUG_REMOVE;
1841 * Check for remaining errors - they are fatal. (blockable)
1843 if (is & fatal_mask) {
1846 sili_pwrite(ap, SILI_PREG_INT_STATUS, is & fatal_mask);
1848 serr = sili_pread(ap, SILI_PREG_SERR);
1849 kprintf("%s: Unrecoverable errors (IS: %b, SERR: %b), "
1850 "disabling port.\n",
1852 is, SILI_PFMT_INT_STATUS,
1853 serr, SILI_PFMT_SERR
1856 /* XXX try recovery first */
1861 * Fail all outstanding commands if we know the port won't recover.
1863 * We may have a ccb_at if the failed command is known and was
1864 * being sent to a device over a port multiplier (PM). In this
1865 * case if the port itself has not completely failed we fail just
1866 * the commands related to that target.
1868 if (ap->ap_state == AP_S_FATAL_ERROR &&
1869 (ap->ap_active & ~ap->ap_expired)) {
1870 kprintf("%s: Fatal port error, expiring %08x\n",
1871 PORTNAME(ap), ap->ap_active & ~ap->ap_expired);
1873 ap->ap_state = AP_S_FATAL_ERROR;
1876 * Error all the active slots. If running across a PM
1877 * try to error out just the slots related to the target.
1879 active = ap->ap_active & ~ap->ap_expired;
1882 slot = ffs(active) - 1;
1883 active &= ~(1 << slot);
1884 ccb = &ap->ap_ccbs[slot];
1885 sili_core_timeout(ccb, 1);
1890 * CCB completion (non blocking).
1892 * CCB completion is detected by noticing the slot bit in
1893 * the port slot status register has cleared while the bit
1894 * is still set in our ap_active variable.
1896 * When completing expired events we must remember to reinit
1897 * the port once everything is clear.
1899 * Due to a single-level recursion when reading the log page,
1900 * it is possible for the slot to already have been cleared
1901 * for some expired tags, do not include expired tags in
1904 active = ap->ap_active & ~sili_pread(ap, SILI_PREG_SLOTST);
1905 active &= ~ap->ap_expired;
1909 slot = ffs(active) - 1;
1910 ccb = &ap->ap_ccbs[slot];
1912 DPRINTF(SILI_D_INTR, "%s: slot %d is complete%s\n",
1913 PORTNAME(ap), slot, ccb->ccb_xa.state == ATA_S_ERROR ?
1916 active &= ~(1 << slot);
1919 * XXX sync POSTREAD for return data?
1921 ap->ap_active &= ~(1 << ccb->ccb_slot);
1922 --ap->ap_active_cnt;
1925 * Complete the ccb. If the ccb was marked expired it
1926 * may or may not have been cleared from the port,
1927 * make sure we mark it as having timed out.
1929 * In a normal completion if AUTOSENSE is set we copy
1930 * the PRB LRAM rfis back to the rfis in host-memory.
1932 * XXX Currently AUTOSENSE also forces exclusivity so we
1933 * can safely work around a hardware bug when reading
1936 if (ap->ap_expired & (1 << ccb->ccb_slot)) {
1937 ap->ap_expired &= ~(1 << ccb->ccb_slot);
1938 ccb->ccb_xa.state = ATA_S_TIMEOUT;
1940 ccb->ccb_xa.complete(&ccb->ccb_xa);
1942 if (ccb->ccb_xa.flags & ATA_F_AUTOSENSE) {
1943 memcpy(ccb->ccb_xa.rfis,
1944 &ccb->ccb_prb_lram->prb_d2h,
1945 sizeof(ccb->ccb_prb_lram->prb_d2h));
1946 if (ccb->ccb_xa.state == ATA_S_TIMEOUT)
1947 ccb->ccb_xa.state = ATA_S_ERROR;
1949 if (ccb->ccb_xa.state == ATA_S_ONCHIP)
1950 ccb->ccb_xa.state = ATA_S_COMPLETE;
1954 if (is & SILI_PREG_IST_READY) {
1955 is &= ~SILI_PREG_IST_READY;
1956 sili_pwrite(ap, SILI_PREG_INT_DISABLE, SILI_PREG_INT_READY);
1957 sili_pwrite(ap, SILI_PREG_INT_STATUS, SILI_PREG_IST_READY);
1961 * If we had expired commands and were waiting for
1962 * remaining commands to complete, and they have now
1963 * completed, we can reinit the port.
1965 * This will also clean out the expired commands.
1966 * The timeout code also calls sili_port_reinit() if
1967 * the only commands remaining after a timeout are all
1968 * now expired commands.
1970 * Otherwise just reissue.
1972 if (ap->ap_expired && ap->ap_active == ap->ap_expired) {
1974 sili_port_reinit(ap);
1976 sili_issue_pending_commands(ap, NULL);
1980 * Cleanup. Will not be set if non-blocking.
1983 case NEED_HOTPLUG_INSERT:
1985 * A hot-plug insertion event has occured and all
1986 * outstanding commands have already been revoked.
1988 * Don't recurse if this occurs while we are
1989 * resetting the port.
1991 * Place the port in a continuous COMRESET state
1992 * until the INIT code gets to it.
1994 kprintf("%s: HOTPLUG - Device inserted\n",
1996 ap->ap_probe = ATA_PROBE_NEED_INIT;
1997 sili_cam_changed(ap, NULL, -1);
1999 case NEED_HOTPLUG_REMOVE:
2001 * A hot-plug removal event has occured and all
2002 * outstanding commands have already been revoked.
2004 * Don't recurse if this occurs while we are
2005 * resetting the port.
2007 kprintf("%s: HOTPLUG - Device removed\n",
2009 sili_port_hardstop(ap);
2010 /* ap_probe set to failed */
2011 sili_cam_changed(ap, NULL, -1);
2019 sili_get_ccb(struct sili_port *ap)
2021 struct sili_ccb *ccb;
2023 lockmgr(&ap->ap_ccb_lock, LK_EXCLUSIVE);
2024 ccb = TAILQ_FIRST(&ap->ap_ccb_free);
2026 KKASSERT(ccb->ccb_xa.state == ATA_S_PUT);
2027 TAILQ_REMOVE(&ap->ap_ccb_free, ccb, ccb_entry);
2028 ccb->ccb_xa.state = ATA_S_SETUP;
2029 ccb->ccb_xa.at = NULL;
2031 lockmgr(&ap->ap_ccb_lock, LK_RELEASE);
2037 sili_put_ccb(struct sili_ccb *ccb)
2039 struct sili_port *ap = ccb->ccb_port;
2042 if (ccb->ccb_xa.state != ATA_S_COMPLETE &&
2043 ccb->ccb_xa.state != ATA_S_TIMEOUT &&
2044 ccb->ccb_xa.state != ATA_S_ERROR) {
2045 kprintf("%s: invalid ata_xfer state %02x in sili_put_ccb, "
2047 PORTNAME(ccb->ccb_port), ccb->ccb_xa.state,
2052 ccb->ccb_xa.state = ATA_S_PUT;
2053 lockmgr(&ap->ap_ccb_lock, LK_EXCLUSIVE);
2054 TAILQ_INSERT_TAIL(&ap->ap_ccb_free, ccb, ccb_entry);
2055 lockmgr(&ap->ap_ccb_lock, LK_RELEASE);
2059 sili_get_err_ccb(struct sili_port *ap)
2061 struct sili_ccb *err_ccb;
2063 KKASSERT(sili_pread(ap, SILI_PREG_CI) == 0);
2064 KKASSERT((ap->ap_flags & AP_F_ERR_CCB_RESERVED) == 0);
2065 ap->ap_flags |= AP_F_ERR_CCB_RESERVED;
2068 KKASSERT(ap->ap_err_busy == 0);
2069 ap->ap_err_busy = 1;
2072 * Grab a CCB to use for error recovery. This should never fail, as
2073 * we ask atascsi to reserve one for us at init time.
2075 err_ccb = ap->ap_err_ccb;
2076 KKASSERT(err_ccb != NULL);
2077 err_ccb->ccb_xa.flags = 0;
2078 err_ccb->ccb_done = sili_empty_done;
2084 sili_put_err_ccb(struct sili_ccb *ccb)
2086 struct sili_port *ap = ccb->ccb_port;
2089 KKASSERT(ap->ap_err_busy);
2091 KKASSERT((ap->ap_flags & AP_F_ERR_CCB_RESERVED) != 0);
2093 KKASSERT(ccb == ap->ap_err_ccb);
2096 ap->ap_err_busy = 0;
2098 ap->ap_flags &= ~AP_F_ERR_CCB_RESERVED;
2102 * Read log page to get NCQ error.
2104 * Return 0 on success
2107 sili_port_read_ncq_error(struct sili_port *ap, int target)
2109 struct sili_ccb *ccb;
2110 struct ata_fis_h2d *fis;
2113 DPRINTF(SILI_D_VERBOSE, "%s: read log page\n", PORTNAME(ap));
2115 /* Prep error CCB for READ LOG EXT, page 10h, 1 sector. */
2116 ccb = sili_get_err_ccb(ap);
2117 ccb->ccb_done = sili_empty_done;
2118 ccb->ccb_xa.flags = ATA_F_NOWAIT | ATA_F_READ | ATA_F_POLL;
2119 ccb->ccb_xa.data = ap->ap_err_scratch;
2120 ccb->ccb_xa.datalen = 512;
2121 ccb->ccb_xa.complete = sili_dummy_done;
2122 ccb->ccb_xa.at = &ap->ap_ata[target];
2123 fis = &ccb->ccb_prb->prb_h2d;
2124 bzero(fis, sizeof(*fis));
2126 fis->type = ATA_FIS_TYPE_H2D;
2127 fis->flags = ATA_H2D_FLAGS_CMD | target;
2128 fis->command = ATA_C_READ_LOG_EXT;
2129 fis->lba_low = 0x10; /* queued error log page (10h) */
2130 fis->sector_count = 1; /* number of sectors (1) */
2131 fis->sector_count_exp = 0;
2132 fis->lba_mid = 0; /* starting offset */
2133 fis->lba_mid_exp = 0;
2137 * NOTE: Must use sili_quick_timeout() because we hold the err_ccb
2139 if (sili_load_prb(ccb) != 0) {
2140 status = ATA_S_ERROR;
2142 ccb->ccb_xa.state = ATA_S_PENDING;
2143 status = sili_poll(ccb, 1000, sili_quick_timeout);
2147 * Just spew if it fails, there isn't much we can do at this point.
2149 if (status != ATA_S_COMPLETE) {
2150 kprintf("%s: log page read failed, slot %d was still active.\n",
2151 ATANAME(ap, ccb->ccb_xa.at), ccb->ccb_slot);
2154 /* Done with the error CCB now. */
2155 sili_unload_prb(ccb);
2156 sili_put_err_ccb(ccb);
2158 /* Extract failed register set and tags from the scratch space. */
2159 if (status == ATA_S_COMPLETE) {
2160 struct ata_log_page_10h *log;
2163 log = (struct ata_log_page_10h *)ap->ap_err_scratch;
2164 if (log->err_regs.type & ATA_LOG_10H_TYPE_NOTQUEUED) {
2166 * Not queued bit was set - wasn't an NCQ error?
2168 * XXX This bit seems to be set a lot even for NCQ
2173 * Copy back the log record as a D2H register FIS.
2175 err_slot = log->err_regs.type &
2176 ATA_LOG_10H_TYPE_TAG_MASK;
2177 ccb = &ap->ap_ccbs[err_slot];
2178 if (ap->ap_expired & (1 << ccb->ccb_slot)) {
2179 kprintf("%s: read NCQ error page slot=%d\n",
2180 ATANAME(ap, ccb->ccb_xa.at), err_slot
2182 memcpy(&ccb->ccb_prb->prb_d2h, &log->err_regs,
2183 sizeof(struct ata_fis_d2h));
2184 ccb->ccb_prb->prb_d2h.type = ATA_FIS_TYPE_D2H;
2185 ccb->ccb_prb->prb_d2h.flags = 0;
2186 if (ccb->ccb_xa.state == ATA_S_TIMEOUT)
2187 ccb->ccb_xa.state = ATA_S_ERROR;
2189 kprintf("%s: read NCQ error page slot=%d, "
2190 "slot does not match any cmds\n",
2192 ATANAME(ccb->ccb_port, ccb->ccb_xa.at),
2201 * Allocate memory for various structures DMAd by hardware. The maximum
2202 * number of segments for these tags is 1 so the DMA memory will have a
2203 * single physical base address.
2205 struct sili_dmamem *
2206 sili_dmamem_alloc(struct sili_softc *sc, bus_dma_tag_t tag)
2208 struct sili_dmamem *adm;
2211 adm = kmalloc(sizeof(*adm), M_DEVBUF, M_INTWAIT | M_ZERO);
2213 error = bus_dmamem_alloc(tag, (void **)&adm->adm_kva,
2214 BUS_DMA_ZERO, &adm->adm_map);
2217 error = bus_dmamap_load(tag, adm->adm_map,
2219 bus_dma_tag_getmaxsize(tag),
2220 sili_dmamem_saveseg, &adm->adm_busaddr,
2225 bus_dmamap_destroy(tag, adm->adm_map);
2226 adm->adm_map = NULL;
2227 adm->adm_tag = NULL;
2228 adm->adm_kva = NULL;
2230 kfree(adm, M_DEVBUF);
2238 sili_dmamem_saveseg(void *info, bus_dma_segment_t *segs, int nsegs, int error)
2240 KKASSERT(error == 0);
2241 KKASSERT(nsegs == 1);
2242 *(bus_addr_t *)info = segs->ds_addr;
2247 sili_dmamem_free(struct sili_softc *sc, struct sili_dmamem *adm)
2250 bus_dmamap_unload(adm->adm_tag, adm->adm_map);
2251 bus_dmamap_destroy(adm->adm_tag, adm->adm_map);
2252 adm->adm_map = NULL;
2253 adm->adm_tag = NULL;
2254 adm->adm_kva = NULL;
2256 kfree(adm, M_DEVBUF);
2260 sili_read(struct sili_softc *sc, bus_size_t r)
2262 bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4,
2263 BUS_SPACE_BARRIER_READ);
2264 return (bus_space_read_4(sc->sc_iot, sc->sc_ioh, r));
2268 sili_write(struct sili_softc *sc, bus_size_t r, u_int32_t v)
2270 bus_space_write_4(sc->sc_iot, sc->sc_ioh, r, v);
2271 bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4,
2272 BUS_SPACE_BARRIER_WRITE);
2276 sili_pread(struct sili_port *ap, bus_size_t r)
2278 bus_space_barrier(ap->ap_sc->sc_iot, ap->ap_ioh, r, 4,
2279 BUS_SPACE_BARRIER_READ);
2280 return (bus_space_read_4(ap->ap_sc->sc_iot, ap->ap_ioh, r));
2284 sili_pwrite(struct sili_port *ap, bus_size_t r, u_int32_t v)
2286 bus_space_write_4(ap->ap_sc->sc_iot, ap->ap_ioh, r, v);
2287 bus_space_barrier(ap->ap_sc->sc_iot, ap->ap_ioh, r, 4,
2288 BUS_SPACE_BARRIER_WRITE);
2292 * Wait up to (timeout) milliseconds for the masked port register to
2295 * Timeout is in milliseconds.
2298 sili_pwait_eq(struct sili_port *ap, int timeout,
2299 bus_size_t r, u_int32_t mask, u_int32_t target)
2304 * Loop hard up to 100uS
2306 for (t = 0; t < 100; ++t) {
2307 if ((sili_pread(ap, r) & mask) == target)
2309 sili_os_hardsleep(1); /* us */
2313 timeout -= sili_os_softsleep();
2314 if ((sili_pread(ap, r) & mask) == target)
2316 } while (timeout > 0);
2321 sili_wait_ne(struct sili_softc *sc, bus_size_t r, u_int32_t mask,
2327 * Loop hard up to 100uS
2329 for (t = 0; t < 100; ++t) {
2330 if ((sili_read(sc, r) & mask) != target)
2332 sili_os_hardsleep(1); /* us */
2336 * And one millisecond the slow way
2340 t -= sili_os_softsleep();
2341 if ((sili_read(sc, r) & mask) != target)
2350 * Acquire an ata transfer.
2352 * Pass a NULL at for direct-attached transfers, and a non-NULL at for
2353 * targets that go through the port multiplier.
2356 sili_ata_get_xfer(struct sili_port *ap, struct ata_port *at)
2358 struct sili_ccb *ccb;
2360 ccb = sili_get_ccb(ap);
2362 DPRINTF(SILI_D_XFER, "%s: sili_ata_get_xfer: NULL ccb\n",
2367 DPRINTF(SILI_D_XFER, "%s: sili_ata_get_xfer got slot %d\n",
2368 PORTNAME(ap), ccb->ccb_slot);
2370 bzero(ccb->ccb_xa.fis, sizeof(*ccb->ccb_xa.fis));
2371 ccb->ccb_xa.at = at;
2372 ccb->ccb_xa.fis->type = ATA_FIS_TYPE_H2D;
2374 return (&ccb->ccb_xa);
2378 sili_ata_put_xfer(struct ata_xfer *xa)
2380 struct sili_ccb *ccb = (struct sili_ccb *)xa;
2382 DPRINTF(SILI_D_XFER, "sili_ata_put_xfer slot %d\n", ccb->ccb_slot);
2388 sili_ata_cmd(struct ata_xfer *xa)
2390 struct sili_ccb *ccb = (struct sili_ccb *)xa;
2392 KKASSERT(xa->state == ATA_S_SETUP);
2394 if (ccb->ccb_port->ap_state == AP_S_FATAL_ERROR)
2397 kprintf("%s: started std command %b ccb %d ccb_at %p %d\n",
2398 ATANAME(ccb->ccb_port, ccb->ccb_xa.at),
2399 sili_pread(ccb->ccb_port, SILI_PREG_CMD), SILI_PFMT_CMD,
2402 ccb->ccb_xa.at ? ccb->ccb_xa.at->at_target : -1);
2405 ccb->ccb_done = sili_ata_cmd_done;
2407 if (sili_load_prb(ccb) != 0)
2410 xa->state = ATA_S_PENDING;
2412 if (xa->flags & ATA_F_POLL)
2413 return (sili_poll(ccb, xa->timeout, sili_ata_cmd_timeout));
2416 KKASSERT((xa->flags & ATA_F_TIMEOUT_EXPIRED) == 0);
2417 xa->flags |= ATA_F_TIMEOUT_DESIRED;
2424 xa->state = ATA_S_ERROR;
2427 return (ATA_S_ERROR);
2431 sili_ata_cmd_done(struct sili_ccb *ccb)
2433 struct ata_xfer *xa = &ccb->ccb_xa;
2436 * NOTE: callout does not lock port and may race us modifying
2437 * the flags, so make sure its stopped.
2439 if (xa->flags & ATA_F_TIMEOUT_RUNNING) {
2440 callout_stop(&ccb->ccb_timeout);
2441 xa->flags &= ~ATA_F_TIMEOUT_RUNNING;
2443 xa->flags &= ~(ATA_F_TIMEOUT_DESIRED | ATA_F_TIMEOUT_EXPIRED);
2445 KKASSERT(xa->state != ATA_S_ONCHIP);
2446 sili_unload_prb(ccb);
2449 else if (xa->state != ATA_S_ERROR && xa->state != ATA_S_TIMEOUT)
2450 kprintf("%s: invalid ata_xfer state %02x in sili_ata_cmd_done, "
2452 PORTNAME(ccb->ccb_port), xa->state, ccb->ccb_slot);
2454 if (xa->state != ATA_S_TIMEOUT)
2459 * Timeout from callout, MPSAFE - nothing can mess with the CCB's flags
2460 * while the callout is runing.
2462 * We can't safely get the port lock here or delay, we could block
2463 * the callout thread.
2466 sili_ata_cmd_timeout_unserialized(void *arg)
2468 struct sili_ccb *ccb = arg;
2469 struct sili_port *ap = ccb->ccb_port;
2471 ccb->ccb_xa.flags &= ~ATA_F_TIMEOUT_RUNNING;
2472 ccb->ccb_xa.flags |= ATA_F_TIMEOUT_EXPIRED;
2473 sili_os_signal_port_thread(ap, AP_SIGF_TIMEOUT);
2477 sili_ata_cmd_timeout(struct sili_ccb *ccb)
2479 sili_core_timeout(ccb, 0);
2483 * Timeout code, typically called when the port command processor is running.
2485 * Returns 0 if all timeout processing completed, non-zero if it is still
2490 sili_core_timeout(struct sili_ccb *ccb, int really_error)
2492 struct ata_xfer *xa = &ccb->ccb_xa;
2493 struct sili_port *ap = ccb->ccb_port;
2494 struct ata_port *at;
2496 at = ccb->ccb_xa.at;
2498 kprintf("%s: CMD %s state=%d slot=%d\n"
2503 (really_error ? "ERROR" : "TIMEOUT"),
2504 ccb->ccb_xa.state, ccb->ccb_slot,
2507 sili_pread(ap, SILI_PREG_SLOTST)
2511 * NOTE: Timeout will not be running if the command was polled.
2512 * If we got here at least one of these flags should be set.
2514 * However, it might be running if we are called from the
2515 * interrupt error handling code.
2517 KKASSERT(xa->flags & (ATA_F_POLL | ATA_F_TIMEOUT_DESIRED |
2518 ATA_F_TIMEOUT_RUNNING));
2519 if (xa->flags & ATA_F_TIMEOUT_RUNNING) {
2520 callout_stop(&ccb->ccb_timeout);
2521 xa->flags &= ~ATA_F_TIMEOUT_RUNNING;
2523 xa->flags &= ~ATA_F_TIMEOUT_EXPIRED;
2525 if (ccb->ccb_xa.state == ATA_S_PENDING) {
2526 TAILQ_REMOVE(&ap->ap_ccb_pending, ccb, ccb_entry);
2527 ccb->ccb_xa.state = ATA_S_TIMEOUT;
2530 sili_issue_pending_commands(ap, NULL);
2533 if (ccb->ccb_xa.state != ATA_S_ONCHIP) {
2534 kprintf("%s: Unexpected state during timeout: %d\n",
2535 ATANAME(ap, at), ccb->ccb_xa.state);
2540 * We can't process timeouts while other commands are running.
2542 ap->ap_expired |= 1 << ccb->ccb_slot;
2544 if (ap->ap_active != ap->ap_expired) {
2545 kprintf("%s: Deferred timeout until its safe, slot %d\n",
2546 ATANAME(ap, at), ccb->ccb_slot);
2551 * We have to issue a Port reinit. We don't read an error log
2552 * page for timeouts. Reiniting the port will clear all pending
2555 sili_port_reinit(ap);
2560 * Used by the softreset, pm_port_probe, and read_ncq_error only, in very
2561 * specialized, controlled circumstances.
2564 sili_quick_timeout(struct sili_ccb *ccb)
2566 struct sili_port *ap = ccb->ccb_port;
2568 switch (ccb->ccb_xa.state) {
2570 TAILQ_REMOVE(&ap->ap_ccb_pending, ccb, ccb_entry);
2571 ccb->ccb_xa.state = ATA_S_TIMEOUT;
2574 KKASSERT((ap->ap_active & ~ap->ap_expired) ==
2575 (1 << ccb->ccb_slot));
2576 ccb->ccb_xa.state = ATA_S_TIMEOUT;
2577 ap->ap_active &= ~(1 << ccb->ccb_slot);
2578 KKASSERT(ap->ap_active_cnt > 0);
2579 --ap->ap_active_cnt;
2580 sili_port_reinit(ap);
2583 panic("%s: sili_quick_timeout: ccb in bad state %d",
2584 ATANAME(ap, ccb->ccb_xa.at), ccb->ccb_xa.state);
2589 sili_dummy_done(struct ata_xfer *xa)
2594 sili_empty_done(struct sili_ccb *ccb)