| blob | 4800c9e94ce4bb9cc7f44856381f704c54bb04b0 |
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
22 /*
23 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
27 /*
28 * SiliconImage 3124/3132/3531 sata controller driver
29 */
31 /*
32 *
33 *
34 * Few Design notes
35 *
36 *
37 * I. General notes
38 *
39 * Even though the driver is named as si3124, it is actually meant to
40 * work with SiI3124, SiI3132 and SiI3531 controllers.
41 *
42 * The current file si3124.c is the main driver code. The si3124reg.h
43 * holds the register definitions from SiI 3124/3132/3531 data sheets. The
44 * si3124var.h holds the driver specific definitions which are not
45 * directly derived from data sheets.
46 *
47 *
48 * II. Data structures
49 *
50 * si_ctl_state_t: This holds the driver private information for each
51 * controller instance. Each of the sata ports within a single
52 * controller are represented by si_port_state_t. The
53 * sictl_global_acc_handle and sictl_global_address map the
54 * controller-wide global register space and are derived from pci
55 * BAR 0. The sictl_port_acc_handle and sictl_port_addr map the
56 * per-port register space and are derived from pci BAR 1.
57 *
58 * si_port_state_t: This holds the per port information. The siport_mutex
59 * holds the per port mutex. The siport_pending_tags is the bit mask of
60 * commands posted to controller. The siport_slot_pkts[] holds the
61 * pending sata packets. The siport_port_type holds the device type
62 * connected directly to the port while the siport_portmult_state
63 * holds the similar information for the devices behind a port
64 * multiplier.
65 *
66 * si_prb_t: This contains the PRB being posted to the controller.
67 * The two SGE entries contained within si_prb_t itself are not
68 * really used to hold any scatter gather entries. The scatter gather
69 * list is maintained external to PRB and is linked from one
70 * of the contained SGEs inside the PRB. For atapi devices, the
71 * first contained SGE holds the PACKET and second contained
72 * SGE holds the link to an external SGT. For non-atapi devices,
73 * the first contained SGE works as link to external SGT while
74 * second SGE is blank.
75 *
76 * external SGT tables: The external SGT tables pointed to from
77 * within si_prb_t are actually abstracted as si_sgblock_t. Each
78 * si_sgblock_t contains si_dma_sg_number number of
79 * SGT tables linked in a chain. Currently this default value of
80 * SGT tables per block is at 85 as which translates
81 * to a maximum of 256 dma cookies per single dma transfer.
82 * This value can be changed through the global var: si_dma_sg_number
83 * in /etc/system, the maxium is at 21844 as which translates to 65535
84 * dma cookies per single dma transfer.
85 *
86 *
87 * III. Driver operation
88 *
89 * Command Issuing: We use the "indirect method of command issuance". The
90 * PRB contains the command [and atapi PACKET] and a link to the
91 * external SGT chain. We write the physical address of the PRB into
92 * command activation register. There are 31 command slots for
93 * each port. After posting a command, we remember the posted slot &
94 * the sata packet in siport_pending_tags & siport_slot_pkts[]
95 * respectively.
96 *
97 * Command completion: On a successful completion, intr_command_complete()
98 * receives the control. The slot_status register holds the outstanding
99 * commands. Any reading of slot_status register automatically clears
100 * the interrupt. By comparing the slot_status register contents with
101 * per port siport_pending_tags, we determine which of the previously
102 * posted commands have finished.
103 *
104 * Timeout handling: Every 5 seconds, the watchdog handler scans thru the
105 * pending packets. The satapkt->satapkt_hba_driver_private field is
106 * overloaded with the count of watchdog cycles a packet has survived.
107 * If a packet has not completed within satapkt->satapkt_time, it is
108 * failed with error code of SATA_PKT_TIMEOUT. There is one watchdog
109 * handler running for each instance of controller.
110 *
111 * Error handling: For 3124, whenever any single command has encountered
112 * an error, the whole port execution completely stalls; there is no
113 * way of canceling or aborting the particular failed command. If
114 * the port is connected to a port multiplier, we can however RESUME
115 * other non-error devices connected to the port multiplier.
116 * The only way to recover the failed commands is to either initialize
117 * the port or reset the port/device. Both port initialize and reset
118 * operations result in discarding any of pending commands on the port.
119 * All such discarded commands are sent up to framework with PKT_RESET
120 * satapkt_reason. The assumption is that framework [and sd] would
121 * retry these commands again. The failed command itself however is
122 * sent up with PKT_DEV_ERROR.
123 *
124 * Here is the implementation strategy based on SiliconImage email
125 * regarding how they handle the errors for their Windows driver:
126 *
127 * a) for DEVICEERROR:
128 * If the port is connected to port multiplier, then
129 * 1) Resume the port
130 * 2) Wait for all the non-failed commands to complete
131 * 3) Perform a Port Initialize
132 *
133 * If the port is not connected to port multiplier, issue
134 * a Port Initialize.
135 *
136 * b) for SDBERROR: [SDBERROR means failed command is an NCQ command]
137 * Handle exactly like DEVICEERROR handling.
138 * After the Port Initialize done, do a Read Log Extended.
139 *
140 * c) for SENDFISERROR:
141 * If the port is connected to port multiplier, then
142 * 1) Resume the port
143 * 2) Wait for all the non-failed commands to complete
144 * 3) Perform a Port Initialize
145 *
146 * If the port is not connected to port multiplier, issue
147 * a Device Reset.
148 *
149 * d) for DATAFISERROR:
150 * If the port was executing an NCQ command, issue a Device
151 * Reset.
152 *
153 * Otherwise, follow the same error recovery as DEVICEERROR.
154 *
155 * e) for any other error, simply issue a Device Reset.
156 *
157 * To synchronize the interactions between various control flows (e.g.
158 * error recovery, timeout handling, si_poll_timeout, incoming flow
159 * from framework etc.), the following precautions are taken care of:
160 * a) During mopping_in_progress, no more commands are
161 * accepted from the framework.
162 *
163 * b) While draining the port multiplier commands, we should
164 * handle the possibility of any of the other waited commands
165 * failing (possibly with a different error code)
166 *
167 * Atapi handling: For atapi devices, we use the first SGE within the PRB
168 * to fill the scsi cdb while the second SGE points to external SGT.
169 *
170 * Queuing: Queue management is achieved external to the driver inside sd.
171 * Based on sata_hba_tran->qdepth and IDENTIFY data, the framework
172 * enables or disables the queuing. The qdepth for si3124 is 31
173 * commands.
174 *
175 * Port Multiplier: Enumeration of port multiplier is handled during the
176 * controller initialization and also during the a hotplug operation.
177 * Current logic takes care of situation where a port multiplier
178 * is hotplugged into a port which had a cdisk connected previously
179 * and vice versa.
180 *
181 * Register poll timeouts: Currently most of poll timeouts on register
182 * reads is set to 0.5 seconds except for a value of 10 seconds
183 * while reading the device signature. [Such a big timeout values
184 * for device signature were found needed during cold reboots
185 * for devices behind port multiplier].
186 *
187 *
188 * IV. Known Issues
189 *
190 * 1) Currently the atapi packet length is hard coded to 12 bytes
191 * This is wrong. The framework should determine it just like they
192 * determine ad_cdb_len in legacy atapi.c. It should even reject
193 * init_pkt() for greater CDB lengths. See atapi.c. Revisit this
194 * in 2nd phase of framework project.
195 *
196 * 2) Do real REQUEST SENSE command instead of faking for ATAPI case.
197 *
198 */
201 #include <sys/note.h>
202 #include <sys/scsi/scsi.h>
203 #include <sys/pci.h>
204 #include <sys/sata/sata_hba.h>
205 #include <sys/sata/adapters/si3124/si3124reg.h>
206 #include <sys/sata/adapters/si3124/si3124var.h>
207 #include <sys/sdt.h>
209 /*
210 * FMA header files
211 */
212 #include <sys/ddifm.h>
213 #include <sys/fm/protocol.h>
214 #include <sys/fm/util.h>
215 #include <sys/fm/io/ddi.h>
217 /*
218 * Function prototypes for driver entry points
219 */
225 /*
226 * Function prototypes for SATA Framework interfaces
227 */
238 /*
239 * Local function prototypes
240 */
252 sata_pkt_t *);
255 sata_pkt_t *);
322 /*
323 * FMA Prototypes
324 */
338 /*
339 * DMA attributes for the data buffer
340 */
355 };
357 /*
358 * DMA attributes for incore RPB and SGT pool
359 */
373 };
375 /* Device access attributes */
377 DDI_DEVICE_ATTR_V1,
378 DDI_STRUCTURE_LE_ACC,
379 DDI_STRICTORDER_ACC,
380 DDI_DEFAULT_ACC
381 };
397 };
400 SATA_TRAN_HOTPLUG_OPS_REV_1,
401 si_tran_hotplug_port_activate,
402 si_tran_hotplug_port_deactivate
403 };
415 };
418 MODREV_1,
420 NULL
421 };
424 /* The following are needed for si_log() */
432 /*
433 * The below global variables are tunable via /etc/system
434 *
435 * si_dma_sg_number
436 */
440 /* Opaque state pointer to be initialized by ddi_soft_state_init() */
443 /*
444 * si3124 module initialization.
445 *
446 */
447 int
449 {
455 }
463 }
471 }
476 }
478 /*
479 * si3124 module uninitialize.
480 *
481 */
482 int
484 {
490 }
492 /* Remove the resources allocated in _init(). */
498 }
500 /*
501 * _info entry point
502 *
503 */
504 int
506 {
508 }
511 /*
512 * The attach entry point for dev_ops.
513 *
514 * We initialize the controller, initialize the soft state, register
515 * the interrupt handlers and then register ourselves with sata framework.
516 */
517 static int
519 {
525 sata_device_t sdevice;
535 /* Allocate si_softc. */
539 }
546 /* Initialize FMA */
556 /* Configure pci config space handle. */
560 }
564 PCI_CONF_DEVID);
579 /*
580 * Driver should not have attatched if device
581 * ID is not already known and is supported.
582 */
584 }
588 /* Now map the bar0; the bar0 contains the global registers. */
590 PCI_BAR0,
598 }
602 /* Now map bar1; the bar1 contains the port registers. */
604 PCI_BAR1,
612 }
616 /*
617 * Disable all the interrupts before adding interrupt
618 * handler(s). The interrupts shall be re-enabled selectively
619 * out of si_init_port().
620 */
623 /* Get supported interrupt types. */
629 }
633 intr_types);
639 /*
640 * Try MSI first, but fall back to legacy if MSI
641 * attach fails.
642 */
650 "MSI registration failed "
652 }
653 }
657 /*
658 * Either the MSI interrupt setup has failed or only
659 * fixed interrupts are available on the system.
660 */
673 }
674 }
680 }
683 /* Initialize the mutex. */
689 /*
690 * Initialize the controller and driver core.
691 */
697 }
705 }
721 }
729 /* Notify SATA framework about RESUME. */
734 }
736 /*
737 * Notify the "framework" that it should reprobe ports to see
738 * if any device got changed while suspended.
739 */
742 SATA_EVNT_PWR_LEVEL_CHANGED);
755 }
757 err_out:
760 /* We want to set SI_DETACH to deallocate all memory */
763 }
767 }
771 }
775 }
779 }
783 }
787 }
791 }
794 }
797 /*
798 * The detach entry point for dev_ops.
799 *
800 * We undo the things we did in si_attach().
801 */
802 static int
804 {
818 /* disable the interrupts for an uninterrupted detach */
822 /* unregister from the sata framework. */
826 }
829 /* now cancel the timeout handler. */
834 /* de-initialize the controller. */
839 /* destroy any mutexes */
843 /* remove the interrupts */
846 /* remove the reg maps. */
851 /* deinit FMA */
854 /* free the soft state. */
860 /* Inform SATA framework */
863 }
867 /*
868 * Device needs to be at full power in case it is needed to
869 * handle dump(9e) to save CPR state after DDI_SUSPEND
870 * completes. This is OK since presumably power will be
871 * removed anyways. No outstanding transactions should be
872 * on the controller since the children are already quiesced.
873 *
874 * If any ioctls/cfgadm support is added that touches
875 * hardware, those entry points will need to check for
876 * suspend and then block or return errors until resume.
877 *
878 */
880 DDI_SUCCESS) {
883 PM_LEVEL_D0);
885 }
894 instance);
903 }
905 }
907 static int
909 {
910 #ifndef __lock_lint
918 sata_device_t sdevice;
924 }
935 #ifndef __lock_lint
944 /*
945 * If called from attach, just raise device power,
946 * restore config registers (if they were saved
947 * from a previous detach that lowered power),
948 * and exit.
949 */
979 }
996 }
1001 }
1004 /*
1005 * The info entry point for dev_ops.
1006 *
1007 */
1008 static int
1012 {
1013 #ifndef __lock_lint
1018 dev_t dev;
1032 }
1038 }
1040 }
1044 /*
1045 * Registers the si3124 with sata framework.
1046 */
1047 static int
1049 {
1057 /* Allocate memory for the sata_hba_tran */
1067 }
1071 }
1088 /* Attach it to SATA framework */
1093 }
1100 }
1103 /*
1104 * Unregisters the si3124 with sata framework.
1105 */
1106 static int
1108 {
1110 /* Detach from the SATA framework. */
1112 DDI_SUCCESS) {
1114 }
1116 /* Deallocate sata_hba_tran. */
1123 }
1125 /*
1126 * Called by sata framework to probe a port. We return the
1127 * cached information from a previous hardware probe.
1128 *
1129 * The actual hardware probing itself was done either from within
1130 * si_initialize_controller() during the driver attach or
1131 * from a phy ready change interrupt handler.
1132 */
1133 static int
1135 {
1155 }
1164 }
1177 }
1180 }
1203 /* we don't support any other device types. */
1206 }
1221 /*
1222 * Since we are implementing the port deactivation
1223 * in software only, we need to fake a valid value
1224 * for sstatus when the device is in deactivated state.
1225 */
1227 SSTATUS_DET_PHYOFFLINE);
1229 SSTATUS_IPM_NODEV_NOPHY);
1231 }
1232 }
1236 }
1238 /*
1239 * Called by sata framework to transport a sata packet down stream.
1240 *
1241 * The actual work of building the FIS & transporting it to the hardware
1242 * is done out of the subroutine si_deliver_satapkt().
1243 */
1244 static int
1246 {
1265 /*
1266 * si_intr_phy_ready_change() may have rendered it to
1267 * PORT_TYPE_NODEV. cfgadm operation may have rendered
1268 * it inactive.
1269 */
1274 }
1279 "si_tran_start clearing the "
1281 }
1289 "si_tran_start returning BUSY while "
1293 }
1298 "si_tran_start returning BUSY while "
1302 }
1309 NULL);
1312 }
1315 /* we need to poll now */
1317 /*
1318 * The command has completed, and spkt will be freed by the
1319 * sata module, so don't keep a pointer to it lying around.
1320 */
1322 }
1326 }
1328 #define SENDUP_PACKET(si_portp, satapkt, reason) \
1329 if (satapkt) { \
1330 if ((satapkt->satapkt_cmd.satacmd_cmd_reg == \
1331 SATAC_WRITE_FPDMA_QUEUED) || \
1332 (satapkt->satapkt_cmd.satacmd_cmd_reg == \
1333 SATAC_READ_FPDMA_QUEUED)) { \
1334 si_portp->siport_pending_ncq_count--; \
1335 } \
1336 satapkt->satapkt_reason = reason; \
1337 /* \
1338 * We set the satapkt_reason in both synch and \
1339 * non-synch cases. \
1341 if (!(satapkt->satapkt_op_mode & SATA_OPMODE_SYNCH) && \
1342 satapkt->satapkt_comp) { \
1343 mutex_exit(&si_portp->siport_mutex); \
1344 (*satapkt->satapkt_comp)(satapkt); \
1345 mutex_enter(&si_portp->siport_mutex); \
1346 } \
1347 }
1349 /*
1350 * Mopping is necessitated because of the si3124 hardware limitation.
1351 * The only way to recover from errors or to abort a command is to
1352 * reset the port/device but such a reset also results in throwing
1353 * away all the unfinished pending commands.
1354 *
1355 * A port or device is reset in four scenarios:
1356 * a) some commands failed with errors
1357 * b) or we need to timeout some commands
1358 * c) or we need to abort some commands
1359 * d) or we need reset the port at the request of sata framework
1360 *
1361 * In all these scenarios, we need to send any pending unfinished
1362 * commands up to sata framework.
1363 *
1364 * WARNING!!! siport_mutex should be acquired before the function is called.
1365 */
1366 static void
1375 {
1383 slot_status);
1386 "si_mop_commands: failed_tags: 0x%x, timedout_tags: 0x%x"
1388 failed_tags,
1389 timedout_tags,
1390 aborting_tags,
1391 reset_tags);
1393 /*
1394 * We could be here for four reasons: abort, reset,
1395 * timeout or error handling. Only one such mopping
1396 * is allowed at a time.
1397 */
1408 /* Send up the finished_tags with SATA_PKT_COMPLETED. */
1413 }
1421 }
1425 satapkt);
1430 }
1434 /* Send up failed_tags with SATA_PKT_DEV_ERROR. */
1439 }
1448 SATA_DTYPE_ATAPICD) {
1450 }
1469 /*
1470 * In the case of NCQ command failures, the error is
1471 * overwritten by the one obtained from issuing of a
1472 * READ LOG EXTENDED command.
1473 */
1478 }
1479 }
1484 }
1488 /* Send up timedout_tags with SATA_PKT_TIMEOUT. */
1493 }
1497 "si_mop_commands sending "
1499 satapkt);
1504 }
1508 /* Send up aborting packets with SATA_PKT_ABORTED. */
1513 }
1518 satapkt);
1520 SATA_DTYPE_ATAPICD) {
1522 }
1528 }
1532 /* Reset tags are sent up to framework with SATA_PKT_RESET. */
1537 }
1540 "si_mop_commands sending PKT_RESET for "
1542 satapkt);
1547 }
1551 /* Send up the unfinished_tags with SATA_PKT_RESET. */
1556 }
1559 "si_mop_commands sending SATA_PKT_RESET for "
1561 satapkt);
1566 }
1572 }
1574 /*
1575 * Called by the sata framework to abort the previously sent packet(s).
1576 *
1577 * We reset the device and mop the commands on the port.
1578 */
1579 static int
1581 {
1600 /*
1601 * If already mopping, then no need to abort anything.
1602 */
1605 "si_tran_abort: port %d mopping "
1609 }
1613 /*
1614 * si_intr_phy_ready_change() may have rendered it to
1615 * PORT_TYPE_NODEV. cfgadm operation may have rendered
1616 * it inactive.
1617 */
1622 }
1627 /*
1628 * Need to abort a single packet.
1629 * Search our siport_slot_pkts[] list for matching spkt.
1630 */
1636 }
1637 }
1640 /* requested packet is not on pending list. */
1645 }
1646 }
1655 /*
1656 * Compute which have finished and which need to be retried.
1657 *
1658 * The finished tags are siport_pending_tags minus the slot_status.
1659 * The aborting_tags have to be reduced by finished_tags since we
1660 * can't possibly abort a tag which had finished already.
1661 */
1667 si_portp,
1668 port,
1669 slot_status,
1672 aborting_tags,
1678 }
1681 /*
1682 * Used to reject all the pending packets on a port during a reset
1683 * operation.
1684 *
1685 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
1686 * before calling us.
1687 */
1688 static void
1693 {
1701 port);
1706 /* Compute which tags need to be sent up. */
1712 si_portp,
1713 port,
1714 slot_status,
1718 reset_tags);
1719 }
1722 /*
1723 * Called by sata framework to reset a port(s) or device.
1724 *
1725 */
1726 static int
1728 {
1738 port);
1748 /*
1749 * If already mopping, then no need to reset or mop again.
1750 */
1753 "si_tran_reset_dport: CPORT port %d mopping "
1758 }
1761 SI_PORT_RESET);
1779 }
1781 /*
1782 * If already mopping, then no need to reset or mop again.
1783 */
1786 "si_tran_reset_dport: DCPORT port %d mopping "
1791 }
1794 SI_DEVICE_RESET);
1808 /*
1809 * If mopping, then all the pending commands are being
1810 * mopped, therefore there is nothing else to do.
1811 */
1814 "si_tran_reset_dport: CNTRL port %d mopping"
1819 }
1826 }
1829 }
1836 /* FALLTHROUGH */
1841 }
1844 }
1847 /*
1848 * Called by sata framework to activate a port as part of hotplug.
1849 *
1850 * Note: Not port-mult aware.
1851 */
1852 static int
1854 {
1866 NULL);
1871 /*
1872 * Reset the device so that a si_find_dev_signature() would trigger.
1873 * But this reset is an internal operation; the sata framework does
1874 * not need to know about it.
1875 */
1887 }
1889 /*
1890 * Called by sata framework to deactivate a port as part of hotplug.
1891 *
1892 * Note: Not port-mult aware.
1893 */
1894 static int
1896 {
1911 /*
1912 * There are pending commands on this port.
1913 * Fail the deactivate request.
1914 */
1918 }
1920 /* mark the device as not accessible any more. */
1923 /* disable the interrupts on the port. */
1929 /*
1930 * Since we are implementing the port deactivation in software only,
1931 * we need to fake a valid value for sstatus.
1932 */
1938 }
1941 /*
1942 * Allocates the si_port_state_t.
1943 */
1944 static int
1946 {
1957 /* allocate prb & sgt pkts for this port. */
1962 }
1968 }
1970 /* Allocate the argument for the timeout */
1979 }
1981 /*
1982 * Deallocates the si_port_state_t.
1983 */
1984 static void
1986 {
2000 }
2002 /*
2003 * Allocates the SGB (Scatter Gather Block) incore buffer.
2004 */
2005 static int
2007 {
2009 uint_t cookie_count;
2013 ddi_dma_cookie_t sgbpool_dma_cookie;
2017 /* allocate sgbpool dma handle. */
2020 DDI_DMA_SLEEP,
2021 NULL,
2023 DDI_SUCCESS) {
2026 }
2028 /* allocate the memory for sgbpool. */
2030 incore_sgbpool_size,
2033 DDI_DMA_SLEEP,
2034 NULL,
2039 /* error.. free the dma handle. */
2042 }
2044 /* now bind it */
2046 NULL,
2048 incore_sgbpool_size,
2049 DDI_DMA_CONSISTENT,
2050 DDI_DMA_SLEEP,
2051 NULL,
2054 /* error.. free the dma handle & free the memory. */
2058 }
2062 }
2064 /*
2065 * Deallocates the SGB (Scatter Gather Block) incore buffer.
2066 */
2067 static void
2069 {
2072 /* Unbind the dma handle first. */
2075 /* Then free the underlying memory. */
2078 /* Now free the handle itself. */
2081 }
2083 /*
2084 * Allocates the PRB (Port Request Block) incore packets.
2085 */
2086 static int
2088 {
2090 uint_t cookie_count;
2093 ddi_dma_cookie_t prbpool_dma_cookie;
2097 /* allocate prb pkts. */
2100 DDI_DMA_SLEEP,
2101 NULL,
2103 DDI_SUCCESS) {
2106 }
2109 incore_pkt_size,
2112 DDI_DMA_SLEEP,
2113 NULL,
2118 /* error.. free the dma handle. */
2121 }
2124 NULL,
2126 incore_pkt_size,
2127 DDI_DMA_CONSISTENT,
2128 DDI_DMA_SLEEP,
2129 NULL,
2132 /* error.. free the dma handle & free the memory. */
2136 }
2141 }
2143 /*
2144 * Deallocates the PRB (Port Request Block) incore packets.
2145 */
2146 static void
2148 {
2151 /* Unbind the prb dma handle first. */
2154 /* Then free the underlying memory. */
2157 /* Now free the handle itself. */
2160 }
2164 /*
2165 * Soft-reset the port to find the signature of the device connected to
2166 * the port.
2167 */
2168 static void
2174 {
2183 /* Build a Soft Reset PRB in host memory. */
2188 /* Empty slot could not be found. */
2190 /* We are behind port multiplier. */
2192 PORT_TYPE_NODEV;
2195 }
2199 }
2206 #if SI_DEBUG
2216 }
2218 }
2220 }
2223 /* deliver soft reset prb to empty slot. */
2227 /* Loop till the soft reset is finished. */
2233 /* We are effectively timing out after 10 sec. */
2235 }
2237 /* Wait for 10 millisec */
2238 #ifndef __lock_lint
2250 /* Read device signature from command slot. */
2267 /*
2268 * It is wrong to chain a port multiplier behind
2269 * another port multiplier.
2270 */
2272 PORT_TYPE_NODEV;
2279 }
2284 /* We are behind port multiplier. */
2286 PORT_TYPE_ATAPI;
2290 }
2298 /* We are behind port multiplier. */
2300 PORT_TYPE_DISK;
2304 }
2311 /* We are behind port multiplier. */
2313 PORT_TYPE_UNKNOWN;
2316 }
2320 }
2323 }
2326 /*
2327 * Polls for the completion of the command. This is safe with both
2328 * interrupts enabled or disabled.
2329 */
2330 static void
2337 {
2349 /* we start out with SATA_PKT_COMPLETED as the satapkt_reason */
2358 /*
2359 * If we are in panic, we can't rely on
2360 * timers; so, busy wait instead of delay().
2361 */
2367 #ifndef __lock_lint
2371 }
2374 }
2381 /* The si_mop_command() got to our packet before us */
2384 }
2386 /*
2387 * Interrupts and timers may not be working properly in a crash dump
2388 * situation; we may need to handle all the three conditions here:
2389 * successful completion, packet failure and packet timeout.
2390 */
2407 /*
2408 * Why do we need to call si_intr_command_error() ?
2409 *
2410 * Answer: Even if the current packet is not the
2411 * offending command, we need to restart the stalled
2412 * port; (may be, the interrupts are not working well
2413 * in panic condition). The call to routine
2414 * si_intr_command_error() will achieve that.
2415 *
2416 * What if the interrupts are working fine and the
2417 * si_intr_command_error() gets called once more from
2418 * interrupt context ?
2419 *
2420 * Answer: The second instance of routine
2421 * si_intr_command_error() will not mop anything
2422 * since the first error handler has already blown
2423 * away the hardware pending queues through reset.
2424 *
2425 * Will the si_intr_command_error() hurt current
2426 * packet ?
2427 *
2428 * Answer: No.
2429 */
2431 /* Ignore any non-error interrupts at this stage */
2434 port)),
2436 }
2445 }
2448 SATAC_WRITE_FPDMA_QUEUED) ||
2450 SATAC_READ_FPDMA_QUEUED)) {
2452 }
2456 /*
2457 * tidbit: What is the interaction of abort with polling ?
2458 * What happens if the current polled pkt is aborted in parallel ?
2459 *
2460 * Answer: Assuming that the si_mop_commands() completes ahead
2461 * of polling, all it does is to set the satapkt_reason to
2462 * SPKT_PKT_ABORTED. That would be fine with us.
2463 *
2464 * The same logic applies to reset interacting with polling.
2465 */
2466 }
2469 /*
2470 * Searches for and claims a free slot.
2471 *
2472 * Returns: SI_FAILURE if no slots found
2473 * claimed slot number if successful
2474 *
2475 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
2476 * before calling us.
2477 */
2478 /*ARGSUSED*/
2479 static int
2481 {
2497 }
2501 slot);
2503 }
2505 /*
2506 * Builds the PRB for the sata packet and delivers it to controller.
2507 *
2508 * Returns:
2509 * slot number if we can obtain a slot successfully
2510 * otherwise, return SI_FAILURE
2511 *
2512 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
2513 * before calling us.
2514 */
2515 static int
2521 {
2531 ddi_dma_cookie_t cookie;
2538 }
2542 }
2546 /*
2547 * si_intr_phy_ready_change() may have rendered it to
2548 * PORT_TYPE_NODEV. cfgadm operation may have rendered
2549 * it inactive.
2550 */
2556 }
2565 "si_deliver_satpkt entry: cmd_reg: 0x%x, slot: 0x%x, \
2569 /* Now fill the prb. */
2572 SATA_DIR_READ) {
2577 }
2578 }
2585 }
2594 /*
2595 * satacmd_addr_type will be 0 for the commands below:
2596 * SATAC_PACKET
2597 * SATAC_IDLE_IM
2598 * SATAC_STANDBY_IM
2599 * SATAC_DOWNLOAD_MICROCODE
2600 * SATAC_FLUSH_CACHE
2601 * SATAC_SET_FEATURES
2602 * SATAC_SMART
2603 * SATAC_ID_PACKET_DEVICE
2604 * SATAC_ID_DEVICE
2605 * SATAC_READ_PORTMULT
2606 * SATAC_WRITE_PORTMULT
2607 */
2608 /* FALLTHRU */
2611 /* FALLTHRU */
2614 /* LBA[7:0] */
2617 /* LBA[15:8] */
2620 /* LBA[23:16] */
2623 /* LBA [27:24] (also called dev_head) */
2629 /* LBA[7:0] */
2632 /* LBA[15:8] */
2635 /* LBA[23:16] */
2638 /* LBA [31:24] */
2641 /* LBA [39:32] */
2644 /* LBA [47:40] */
2647 /* Set dev_head */
2650 /* Set the extended sector count and features */
2658 }
2661 /*
2662 * For queued commands, the TAG for the sector count lsb is
2663 * generated from current slot number.
2664 */
2666 }
2671 }
2673 /* *** now fill the scatter gather list ******* */
2676 /* atapi command goes into sge0 */
2679 /* Now fill sge1 with pointer to external SGT. */
2687 }
2689 /* Fill the sge0 */
2698 }
2700 /* sge1 is left empty in non-ATAPI case */
2701 }
2715 /* No cookies. Terminate the chain. */
2717 NULL);
2725 }
2733 /* Now fill the first 3 entries of SGT in the loop below. */
2740 cookie_index,
2741 ncookies);
2748 }
2750 /*
2751 * If this happens to be the last cookie, we terminate it here.
2752 * Otherwise, we link to next SGT.
2753 */
2756 /* This is the last cookie. Terminate the chain. */
2758 "filling the last: cookie_index: %d, "
2760 cookie_index,
2761 ncookies);
2773 /* This is not the last one. So link it. */
2776 cookie_index,
2777 ncookies);
2783 }
2785 }
2787 /* *** finished filling the scatter gather list ******* */
2789 sgl_fill_done:
2790 /* Now remember the sata packet in siport_slot_pkts[]. */
2793 /*
2794 * We are overloading satapkt_hba_driver_private with
2795 * watched_cycle count.
2796 */
2800 /* program the packet_lenth if it is atapi device. */
2803 #ifdef ATAPI_2nd_PHASE
2804 /*
2805 * Framework needs to calculate the acdb_len based on
2806 * identify packet data. This needs to be accomplished
2807 * in second phase of the project.
2808 */
2817 PORT_CONTROL_SET_BITS_PACKET_LEN);
2821 PORT_CONTROL_CLEAR_BITS_PACKET_LEN);
2822 }
2825 /* hard coding for now to 12 bytes */
2828 PORT_CONTROL_CLEAR_BITS_PACKET_LEN);
2830 }
2833 #if SI_DEBUG
2836 /*
2837 * Do not dump the atapi Test-Unit-Ready commands.
2838 * The sd_media_watch spews too many of these.
2839 */
2848 }
2866 }
2868 }
2869 }
2871 }
2874 /* Deliver PRB */
2878 }
2880 /*
2881 * Initialize the controller and set up driver data structures.
2882 *
2883 * This routine can be called from three separate cases: DDI_ATTACH, PM_LEVEL_D0
2884 * and DDI_RESUME. The DDI_ATTACH case is different from other two cases; the
2885 * memory allocation & device signature probing are attempted only during
2886 * DDI_ATTACH case. In the case of PM_LEVEL_D0 & DDI_RESUME, we are starting
2887 * from a previously initialized state; so there is no need to allocate memory
2888 * or to attempt probing the device signatures.
2889 */
2890 static int
2892 {
2905 /* Remove the Global Reset. */
2908 GLOBAL_CONTROL_REG_BITS_CLEAR);
2913 /*
2914 * We allocate the port state only during attach
2915 * sequence. We don't want to do it during
2916 * suspend/resume sequence.
2917 */
2921 }
2922 }
2929 /* Clear Port Reset. */
2932 PORT_CONTROL_SET_BITS_PORT_RESET);
2935 PORT_CONTROL_CLEAR_BITS_PORT_RESET);
2937 /*
2938 * Arm the interrupts for: Cmd completion, Cmd error,
2939 * Port Ready, PM Change, PhyRdyChange, Commwake,
2940 * UnrecFIS, Devxchanged, SDBNotify.
2941 */
2945 INTR_COMMAND_ERROR |
2946 INTR_PORT_READY |
2947 INTR_POWER_CHANGE |
2948 INTR_PHYRDY_CHANGE |
2949 INTR_COMWAKE_RECEIVED |
2950 INTR_UNRECOG_FIS |
2951 INTR_DEV_XCHANGED |
2952 INTR_SETDEVBITS_NOTIFY));
2954 /* Now enable the interrupts. */
2957 /*
2958 * The following PHY initialization is redundant in
2959 * in x86 since the BIOS anyway does this as part of
2960 * device enumeration during the power up. But this
2961 * is a required step in sparc since there is no BIOS.
2962 *
2963 * The way to initialize the PHY is to write a 1 and then
2964 * a 0 to DET field of SControl register.
2965 */
2967 /*
2968 * Fetch the current SControl before writing the
2969 * DET part with 1
2970 */
2976 SControl);
2977 #ifndef __lock_lint
2981 /*
2982 * Now fetch the SControl again and rewrite the
2983 * DET part with 0
2984 */
2990 SControl);
2992 /*
2993 * PHY may be initialized by now. Check the DET field of
2994 * SStatus to determine if there is a device present.
2995 *
2996 * The DET field is valid only if IPM field indicates that
2997 * the interface is in active state.
2998 */
3006 SSTATUS_IPM_INTERFACE_ACTIVE) {
3007 /*
3008 * If the interface is not active, the DET field
3009 * is considered not accurate. So we want to
3010 * continue looping.
3011 */
3013 SSTATUS_DET_NODEV_NOPHY);
3014 }
3017 /*
3018 * We are effectively timing out after 0.1 sec.
3019 */
3021 }
3023 /* Wait for 10 millisec */
3024 #ifndef __lock_lint
3029 SSTATUS_DET_DEVPRESENT_PHYONLINE);
3032 "si_initialize_controller: 1st loop count: %d, "
3034 loop_count,
3035 SStatus);
3038 SSTATUS_IPM_INTERFACE_ACTIVE) ||
3040 SSTATUS_DET_DEVPRESENT_PHYONLINE)) {
3041 /*
3042 * Either the port is not active or there
3043 * is no device present.
3044 */
3046 PORT_TYPE_NODEV;
3049 }
3051 /* Wait until Port Ready */
3058 /*
3059 * We are effectively timing out after 0.5 sec.
3060 */
3062 }
3064 /* Wait for 10 millisec */
3065 #ifndef __lock_lint
3073 loop_count);
3076 /*
3077 * We want to probe for dev signature only during attach
3078 * case. Don't do it during suspend/resume sequence.
3079 */
3083 PORTMULT_CONTROL_PORT);
3087 PORT_TYPE_NODEV;
3088 }
3089 }
3094 DDI_SERVICE_LOST);
3098 }
3101 }
3105 }
3107 /*
3108 * Reverse of si_initialize_controller().
3109 *
3110 * WARNING, WARNING: The caller is expected to obtain the sictl_mutex
3111 * before calling us.
3112 */
3113 static void
3115 {
3123 /* disable all the interrupts. */
3127 /*
3128 * We want to dealloc all the memory in detach case.
3129 */
3132 }
3133 }
3135 }
3137 /*
3138 * Prepare the port ready for usage.
3139 *
3140 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
3141 * before calling us.
3142 */
3143 static void
3145 {
3149 port);
3151 /* Initialize the port. */
3154 PORT_CONTROL_SET_BITS_PORT_INITIALIZE);
3156 /*
3157 * Clear the InterruptNCOR (Interrupt No Clear on Read).
3158 * This step ensures that a mere reading of slot_status will clear
3159 * the interrupt; no explicit clearing of interrupt condition
3160 * will be needed for successful completion of commands.
3161 */
3164 PORT_CONTROL_CLEAR_BITS_INTR_NCoR);
3166 /* clear any pending interrupts at this point */
3169 INTR_MASK);
3171 }
3174 /*
3175 * Enumerate the devices connected to the port multiplier.
3176 * Once a device is detected, we call si_find_dev_signature()
3177 * to find the type of device connected. Even though we are
3178 * called from within si_find_dev_signature(), there is no
3179 * recursion possible.
3180 */
3181 static int
3186 {
3196 port);
3200 /* Enable Port Multiplier context switching. */
3203 PORT_CONTROL_SET_BITS_PM_ENABLE);
3205 /*
3206 * Read the num dev ports connected.
3207 * GSCR[2] contains the number of device ports.
3208 */
3213 }
3218 num_dev_ports);
3221 /*
3222 * Enable PHY by writing a 1, then a 0 to SControl
3223 * (i.e. PSCR[2]) DET field.
3224 */
3228 }
3230 /* First write a 1 to DET field of SControl. */
3235 }
3236 #ifndef __lock_lint
3240 /* Then write a 0 to the DET field of SControl. */
3245 }
3247 /* Wait for PHYRDY by polling SStatus (i.e. PSCR[0]). */
3253 }
3256 SStatus);
3259 SSTATUS_IPM_INTERFACE_ACTIVE) {
3260 /*
3261 * If the interface is not active, the DET field
3262 * is considered not accurate. So we want to
3263 * continue looping.
3264 */
3266 SSTATUS_DET_NODEV_NOPHY);
3267 }
3270 /*
3271 * We are effectively timing out after 0.1 sec.
3272 */
3274 }
3276 /* Wait for 10 millisec */
3277 #ifndef __lock_lint
3282 SSTATUS_DET_DEVPRESENT_PHYONLINE);
3285 "si_enumerate_port_multiplier: "
3287 loop_count,
3288 SStatus);
3291 SSTATUS_IPM_INTERFACE_ACTIVE) &&
3293 SSTATUS_DET_DEVPRESENT_PHYONLINE)) {
3294 /* The interface is active and the device is present */
3297 SStatus);
3298 /*
3299 * Clear error bits in SError register (i.e. PSCR[1]
3300 * by writing back error bits.
3301 */
3305 }
3311 }
3313 /* There exists a device. */
3317 }
3318 }
3323 }
3326 /*
3327 * Read a port multiplier register.
3328 *
3329 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
3330 * before calling us.
3331 */
3332 static int
3340 {
3357 }
3362 /* Now fill the prb. */
3371 /* no real data transfer is involved. */
3374 #if SI_DEBUG
3383 }
3385 }
3388 /* Deliver PRB */
3391 /* Loop till the command is finished. */
3398 slot_status);
3401 /* We are effectively timing out after 0.5 sec. */
3403 }
3405 /* Wait for 10 millisec */
3406 #ifndef __lock_lint
3414 loop_count);
3418 /* Now inspect the port LRAM for the modified FIS. */
3423 }
3428 DDI_SERVICE_UNAFFECTED);
3430 }
3434 /* command failed. */
3436 }
3438 /* command succeeded. */
3445 }
3447 /*
3448 * Write a port multiplier register.
3449 *
3450 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
3451 * before calling us.
3452 */
3453 static int
3461 {
3472 "si_write_portmult_reg: port: %x, pmport: %x,"
3479 }
3484 /* Now fill the prb. */
3498 /* no real data transfer is involved. */
3501 #if SI_DEBUG
3510 }
3512 }
3515 /* Deliver PRB */
3518 /* Loop till the command is finished. */
3525 slot_status);
3528 /* We are effectively timing out after 0.5 sec. */
3530 }
3532 /* Wait for 10 millisec */
3533 #ifndef __lock_lint
3541 loop_count);
3545 /* Now inspect the port LRAM for the modified FIS. */
3550 }
3555 DDI_SERVICE_UNAFFECTED);
3557 }
3561 /* command failed */
3563 }
3565 /* command succeeded */
3567 }
3570 /*
3571 * Set the auto sense data for ATAPI devices.
3572 *
3573 * Note: Currently the sense data is simulated; this code will be enhanced
3574 * in second phase to fetch the real sense data from the atapi device.
3575 */
3576 static void
3578 {
3601 }
3602 }
3605 /*
3606 * Interrupt service handler. We loop through each of the ports to find
3607 * if the interrupt belongs to any of them.
3608 *
3609 * Bulk of the interrupt handling is actually done out of subroutines
3610 * like si_intr_command_complete() etc.
3611 */
3612 /*ARGSUSED*/
3613 static uint_t
3615 {
3627 global_intr_status);
3630 DDI_SUCCESS) {
3632 DDI_SERVICE_UNAFFECTED);
3634 }
3637 /* Sorry, the interrupt is not ours. */
3639 }
3641 /* Loop for all the ports. */
3647 }
3658 port_intr_status,
3659 port);
3663 port);
3669 DDI_SERVICE_UNAFFECTED);
3671 port);
3672 }
3675 /* Clear the interrupts */
3679 }
3681 /*
3682 * Note that we did not clear the interrupt for command
3683 * completion interrupt. Reading of slot_status takes care
3684 * of clearing the interrupt for command completion case.
3685 */
3689 }
3693 }
3697 }
3701 port);
3702 }
3706 port);
3707 }
3711 port);
3712 }
3716 }
3720 port);
3721 }
3725 port);
3726 }
3731 }
3735 port);
3736 }
3737 }
3740 }
3742 /*
3743 * Interrupt which indicates that one or more commands have successfully
3744 * completed.
3745 *
3746 * Since we disabled W1C (write-one-to-clear) previously, mere reading
3747 * of slot_status register clears the interrupt. There is no need to
3748 * explicitly clear the interrupt.
3749 */
3750 static int
3755 {
3771 /*
3772 * Spurious interrupt. Nothing to be done.
3773 * The interrupt was cleared when slot_status was read.
3774 */
3777 }
3782 slot_status);
3791 }
3797 finished_slot);
3798 }
3803 }
3808 slot_status);
3810 /*
3811 * tidbit: no need to clear the interrupt since reading of
3812 * slot_status automatically clears the interrupt in the case
3813 * of a successful command completion.
3814 */
3819 }
3821 /*
3822 * Schedule a call to si_intr_command_error using a timeout to get it done
3823 * off the interrupt thread.
3824 */
3825 static void
3830 {
3841 }
3849 }
3851 /*
3852 * Called from timeout()
3853 * Unpack the arguments and call si_intr_command_error()
3854 */
3855 static void
3857 {
3873 }
3875 /*
3876 * Interrupt which indicates that a command did not complete successfully.
3877 *
3878 * The port halts whenever a command error interrupt is received.
3879 * The only way to restart it is to reset or reinitialize the port
3880 * but such an operation throws away all the pending commands on
3881 * the port.
3882 *
3883 * We reset the device and mop the commands on the port.
3884 */
3885 static int
3890 {
3899 command_error);
3903 /*
3904 * Remember the slot_status since any of the recovery handler
3905 * can blow it away with reset operation.
3906 */
3922 DDI_SERVICE_UNAFFECTED);
3930 DDI_SERVICE_UNAFFECTED);
3938 DDI_SERVICE_UNAFFECTED);
3946 DDI_SERVICE_UNAFFECTED);
3949 }
3951 /*
3952 * Compute the failed_tags by adding up the error tags.
3953 *
3954 * The siport_err_tags_SDBERROR and siport_err_tags_nonSDBERROR
3955 * were filled in by the si_error_recovery_* routines.
3956 */
3962 "err_tags_SDBERROR: 0x%x, "
3963 "err_tags_nonSDBERRROR: 0x%x, "
3967 failed_tags);
3970 "si3124: si_intr_command_error: "
3972 slot_status,
3978 si_portp,
3979 port,
3980 slot_status,
3981 failed_tags,
3994 }
3996 /*
3997 * There is a subtle difference between errors on a normal port and
3998 * a port-mult port. When an error happens on a normal port, the port
3999 * is halted effectively until the port is reset or initialized.
4000 * However, in port-mult port errors, port does not get halted since
4001 * other non-error devices behind the port multiplier can still
4002 * continue to operate. So we wait till all the commands are drained
4003 * instead of resetting it right away.
4004 *
4005 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4006 * before calling us.
4007 */
4008 static void
4013 {
4022 port);
4024 /* Resume the port */
4027 PORT_CONTROL_SET_BITS_RESUME);
4040 }
4042 /* Now we drain the pending commands. */
4047 /*
4048 * Since we have not yet returned DDI_INTR_CLAIMED,
4049 * our interrupt handler is guaranteed not to be called again.
4050 * So we need to check IS_ATTENTION_RAISED() for further
4051 * decisions.
4052 *
4053 * This is a too big a delay for an interrupt context.
4054 * But this is supposed to be a rare condition.
4055 */
4058 /* Resume again */
4061 PORT_CONTROL_SET_BITS_RESUME);
4069 port)));
4076 }
4077 }
4080 /* We are effectively timing out after 10 sec. */
4082 }
4084 /* Wait for 10 millisec */
4085 #ifndef __lock_lint
4091 /*
4092 * The above loop can be improved for 3132 since we could obtain the
4093 * Port Multiplier Context of the device in error. Then we could
4094 * do a better job in filtering out commands for the device in error.
4095 * The loop could finish much earlier with such a logic.
4096 */
4098 /* Clear the RESUME bit. */
4101 PORT_CONTROL_CLEAR_BITS_RESUME);
4103 }
4105 /*
4106 * If we are connected to port multiplier, drain the non-failed devices.
4107 * Otherwise, we initialize the port (which effectively fails all the
4108 * pending commands in the hope that sd would retry them later).
4109 *
4110 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4111 * before calling us.
4112 */
4113 static void
4118 {
4126 port);
4135 }
4137 /* In either case (port-mult or not), we reinitialize the port. */
4139 }
4141 /*
4142 * Handle exactly like DEVICEERROR. Remember the tags with SDBERROR
4143 * to perform read_log_ext on them later. SDBERROR means that the
4144 * error was for an NCQ command.
4145 *
4146 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4147 * before calling us.
4148 */
4149 static void
4154 {
4162 port);
4171 }
4173 /* In either case (port-mult or not), we reinitialize the port. */
4175 }
4177 /*
4178 * Handle exactly like DEVICEERROR except resetting the port if there was
4179 * an NCQ command on the port.
4180 *
4181 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4182 * before calling us.
4183 */
4184 static void
4189 {
4197 port);
4199 /* reset device if we were waiting for any ncq commands. */
4206 SI_DEVICE_RESET);
4208 }
4210 /*
4211 * If we don't have any ncq commands pending, the rest of
4212 * the process is similar to the one for DEVICEERROR.
4213 */
4215 }
4217 /*
4218 * We handle just like DEVICERROR except that we reset the device instead
4219 * of initializing the port.
4220 *
4221 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4222 * before calling us.
4223 */
4224 static void
4229 {
4237 port);
4247 SI_DEVICE_RESET);
4248 }
4249 }
4251 /*
4252 * The default behavior for all other errors is to reset the device.
4253 *
4254 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4255 * before calling us.
4256 */
4257 static void
4262 {
4270 port);
4278 SI_DEVICE_RESET);
4279 }
4281 /*
4282 * Read Log Ext with PAGE 10 to retrieve the error for an NCQ command.
4283 *
4284 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4285 * before calling us.
4286 */
4287 static uint8_t
4289 {
4306 }
4311 /* Now fill the prb */
4318 /* no real data transfer is involved */
4321 #if SI_DEBUG
4330 }
4332 }
4335 /* Deliver PRB */
4338 /* Loop till the command is finished. */
4345 slot_status);
4348 /* We are effectively timing out after 0.5 sec. */
4350 }
4352 /* Wait for 10 millisec */
4353 #ifndef __lock_lint
4360 /*
4361 * If we fail with the READ LOG EXT command, we need to
4362 * initialize the port to clear the slot_status register.
4363 * We don't need to worry about any other valid commands
4364 * being thrown away because we are already in recovery
4365 * mode and READ LOG EXT is the only pending command.
4366 */
4368 }
4372 loop_count);
4374 /*
4375 * The LRAM contains the the modified FIS.
4376 * Read the modified FIS to obtain the Error.
4377 */
4382 }
4387 DDI_SERVICE_UNAFFECTED);
4388 }
4396 }
4398 /*
4399 * Dump the error message to the log.
4400 */
4401 static void
4403 {
4404 #if SI_DEBUG
4405 #ifndef __lock_lint
4509 }
4513 errstr);
4514 #else
4515 #ifndef __lock_lint
4522 }
4525 /*
4526 * Interrupt which indicates that the Port Ready state has changed
4527 * from zero to one.
4528 *
4529 * We are not interested in this interrupt; we just log a debug message.
4530 */
4531 /*ARGSUSED*/
4532 static int
4537 {
4540 }
4542 /*
4543 * Interrupt which indicates that the port power management state
4544 * has been modified.
4545 *
4546 * We are not interested in this interrupt; we just log a debug message.
4547 */
4548 /*ARGSUSED*/
4549 static int
4554 {
4557 }
4559 /*
4560 * Interrupt which indicates that the PHY state has changed either from
4561 * Not-Ready to Ready or from Ready to Not-Ready.
4562 */
4563 static int
4568 {
4569 sata_device_t sdevice;
4579 /* the whole controller setup is not yet done. */
4582 }
4588 /* SStatus tells the presence of device. */
4591 dev_exists_now =
4596 }
4603 /* we don't have a way of determining the exact port-mult port. */
4608 }
4615 /* Things are fine now. The loss was temporary. */
4620 "sending event: LINK_LOST & "
4625 sata_tran_hba_dip,
4627 SATA_EVNT_LINK_LOST|
4628 SATA_EVNT_LINK_ESTABLISHED);
4629 }
4633 /* A new device has been detected. */
4636 PORTMULT_CONTROL_PORT);
4646 sata_tran_hba_dip,
4648 SATA_EVNT_LINK_ESTABLISHED);
4649 }
4651 }
4656 /* An existing device is lost. */
4663 sata_tran_hba_dip,
4665 SATA_EVNT_LINK_LOST);
4666 }
4671 /* spurious interrupt */
4674 }
4675 }
4679 }
4682 /*
4683 * Interrupt which indicates that a COMWAKE OOB signal has been decoded
4684 * on the receiver.
4685 *
4686 * We are not interested in this interrupt; we just log a debug message.
4687 */
4688 /*ARGSUSED*/
4689 static int
4694 {
4698 }
4700 /*
4701 * Interrupt which indicates that the F-bit has been set in SError
4702 * Diag field.
4703 *
4704 * We are not interested in this interrupt; we just log a debug message.
4705 */
4706 /*ARGSUSED*/
4707 static int
4712 {
4716 }
4718 /*
4719 * Interrupt which indicates that the X-bit has been set in SError
4720 * Diag field.
4721 *
4722 * We are not interested in this interrupt; we just log a debug message.
4723 */
4724 /*ARGSUSED*/
4725 static int
4730 {
4735 }
4737 /*
4738 * Interrupt which indicates that the 8b/10b Decode Error counter has
4739 * exceeded the programmed non-zero threshold value.
4740 *
4741 * We are not interested in this interrupt; we just log a debug message.
4742 */
4743 /*ARGSUSED*/
4744 static int
4749 {
4753 }
4755 /*
4756 * Interrupt which indicates that the CRC Error counter has exceeded the
4757 * programmed non-zero threshold value.
4758 *
4759 * We are not interested in this interrupt; we just log a debug message.
4760 */
4761 /*ARGSUSED*/
4762 static int
4767 {
4771 }
4773 /*
4774 * Interrupt which indicates that the Handshake Error counter has
4775 * exceeded the programmed non-zero threshold value.
4776 *
4777 * We are not interested in this interrupt; we just log a debug message.
4778 */
4779 /*ARGSUSED*/
4780 static int
4785 {
4789 }
4791 /*
4792 * Interrupt which indicates that a "Set Device Bits" FIS has been
4793 * received with N-bit set in the control field.
4794 *
4795 * We are not interested in this interrupt; we just log a debug message.
4796 */
4797 /*ARGSUSED*/
4798 static int
4803 {
4807 }
4810 /*
4811 * Enable the interrupts for a particular port.
4812 *
4813 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4814 * before calling us.
4815 */
4816 static void
4818 {
4822 /* get the current settings first. */
4828 mask);
4830 /* enable the bit for current port. */
4833 /* now use this mask to enable the interrupt. */
4836 mask);
4837 }
4839 /*
4840 * Enable interrupts for all the ports.
4841 */
4842 static void
4844 {
4849 }
4850 }
4852 /*
4853 * Disable interrupts for a particular port.
4854 *
4855 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4856 * before calling us.
4857 */
4858 static void
4860 {
4863 /* get the current settings first. */
4867 /* clear the bit for current port. */
4870 /* now use this mask to disable the interrupt. */
4873 mask);
4875 }
4877 /*
4878 * Disable interrupts for all the ports.
4879 */
4880 static void
4882 {
4887 }
4888 }
4890 /*
4891 * Fetches the latest sstatus, scontrol, serror, sactive registers
4892 * and stuffs them into sata_device_t structure.
4893 */
4894 static void
4896 {
4907 }
4909 /*
4910 * si_add_legacy_intrs() handles INTx and legacy interrupts.
4911 */
4912 static int
4914 {
4921 /* get number of interrupts. */
4925 "ddi_intr_get_nintrs() failed, "
4928 }
4930 /* Allocate an array of interrupt handles. */
4934 /* call ddi_intr_alloc(). */
4943 }
4951 }
4955 }
4959 /* Get intr priority. */
4967 }
4971 }
4973 /* Test for high level mutex. */
4980 }
4985 }
4987 /* Call ddi_intr_add_handler(). */
4996 }
5001 }
5002 }
5004 /* Call ddi_intr_enable() for legacy interrupts. */
5007 }
5010 }
5012 /*
5013 * si_add_msictl_intrs() handles MSI interrupts.
5014 */
5015 static int
5017 {
5024 /* get number of interrupts. */
5028 "ddi_intr_get_nintrs() failed, "
5031 }
5033 /* get number of available interrupts. */
5037 "ddi_intr_get_navail() failed, "
5040 }
5046 }
5048 /* Allocate an array of interrupt handles. */
5052 /* call ddi_intr_alloc(). */
5061 }
5063 /* use interrupt count returned */
5067 }
5071 /*
5072 * Get priority for first msi, assume remaining are all the same.
5073 */
5078 /* Free already allocated intr. */
5081 }
5085 }
5087 /* Test for high level mutex. */
5092 /* Free already allocated intr. */
5095 }
5100 }
5102 /* Call ddi_intr_add_handler(). */
5109 /* Free already allocated intr. */
5112 }
5117 }
5118 }
5124 /* Call ddi_intr_block_enable() for MSI. */
5128 /* Call ddi_intr_enable() for MSI non block enable. */
5131 }
5132 }
5135 }
5137 /*
5138 * Removes the registered interrupts irrespective of whether they
5139 * were legacy or MSI.
5140 */
5141 static void
5143 {
5148 /* Disable all interrupts. */
5151 /* Call ddi_intr_block_disable(). */
5157 }
5158 }
5160 /* Call ddi_intr_remove_handler(). */
5164 }
5167 }
5169 /*
5170 * Resets either the port or the device connected to the port based on
5171 * the flag variable.
5172 *
5173 * The reset effectively throws away all the pending commands. So, the caller
5174 * has to make provision to handle the pending commands.
5175 *
5176 * After the reset, we wait till the port is ready again.
5177 *
5178 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
5179 * before calling us.
5180 *
5181 * Note: Not port-mult aware.
5182 */
5183 static int
5189 {
5192 sata_device_t sdevice;
5202 PORT_CONTROL_SET_BITS_PORT_RESET);
5204 /* Port reset is not self clearing. So clear it now. */
5207 PORT_CONTROL_CLEAR_BITS_PORT_RESET);
5209 /* Reset the device. */
5212 PORT_CONTROL_SET_BITS_DEV_RESET);
5214 /*
5215 * tidbit: this bit is self clearing; so there is no need
5216 * for manual clear as we did for port reset.
5217 */
5218 }
5220 /* Set the reset in progress flag */
5223 }
5226 /*
5227 * Every reset needs a PHY initialization.
5228 *
5229 * The way to initialize the PHY is to write a 1 and then
5230 * a 0 to DET field of SControl register.
5231 */
5233 /* Fetch the current SControl before writing the DET part with 1. */
5239 SControl);
5240 #ifndef __lock_lint
5244 /* Now fetch the SControl again and rewrite the DET part with 0 */
5250 SControl);
5252 /*
5253 * PHY may be initialized by now. Check the DET field of SStatus
5254 * to determine if there is a device present.
5255 *
5256 * The DET field is valid only if IPM field indicates that
5257 * the interface is in active state.
5258 */
5266 SSTATUS_IPM_INTERFACE_ACTIVE) {
5267 /*
5268 * If the interface is not active, the DET field
5269 * is considered not accurate. So we want to
5270 * continue looping.
5271 */
5273 }
5276 /* We are effectively timing out after 0.1 sec. */
5278 }
5280 /* Wait for 10 millisec */
5281 #ifndef __lock_lint
5288 "si_reset_dport_wait_till_ready: loop count: %d, \
5290 loop_count,
5291 SStatus);
5293 /* Now check for port readiness. */
5300 /* We are effectively timing out after 0.5 sec. */
5302 }
5304 /* Wait for 10 millisec */
5305 #ifndef __lock_lint
5312 "si_reset_dport_wait_till_ready: loop count: %d, \
5314 loop_count,
5315 port_status,
5316 SStatus);
5318 /* Indicate to the framework that a reset has happened. */
5330 }
5332 SATA_DSTATE_PWR_ACTIVE;
5337 SATA_EVNT_DEVICE_RESET);
5338 }
5342 }
5346 SSTATUS_DET_DEVPRESENT_PHYONLINE)) {
5347 /* The interface is active and the device is present */
5349 /* But the port is is not ready for some reason */
5353 }
5354 }
5357 /*
5358 * For some reason, we are losing the interrupt enablement after
5359 * any reset condition. So restore them back now.
5360 */
5370 INTR_COMMAND_ERROR |
5371 INTR_PORT_READY |
5372 INTR_POWER_CHANGE |
5373 INTR_PHYRDY_CHANGE |
5374 INTR_COMWAKE_RECEIVED |
5375 INTR_UNRECOG_FIS |
5376 INTR_DEV_XCHANGED |
5377 INTR_SETDEVBITS_NOTIFY));
5381 /*
5382 * make sure interrupts are cleared
5383 */
5389 port)),
5397 }
5399 /*
5400 * Schedule an initialization of the port using a timeout to get it done
5401 * off an interrupt thread.
5402 *
5403 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
5404 * before calling us.
5405 */
5406 static void
5411 {
5421 }
5427 }
5429 /*
5430 * Called from timeout()
5431 * Unpack the arguments and call si_initialize_port_wait_till_ready()
5432 */
5433 static void
5435 {
5451 }
5454 /*
5455 * Initializes the port.
5456 *
5457 * Initialization effectively throws away all the pending commands on
5458 * the port. So, the caller has to make provision to handle the pending
5459 * commands.
5460 *
5461 * After the port initialization, we wait till the port is ready again.
5462 *
5463 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
5464 * before calling us.
5465 */
5466 static int
5468 {
5474 /* Initialize the port. */
5477 PORT_CONTROL_SET_BITS_PORT_INITIALIZE);
5479 /* Wait until Port Ready */
5487 "si_initialize_port_wait is timing out: "
5489 port_status);
5490 /* We are effectively timing out after 0.5 sec. */
5492 }
5494 /* Wait for 10 millisec */
5495 #ifndef __lock_lint
5503 loop_count);
5510 SSTATUS_DET_DEVPRESENT_PHYONLINE)) {
5511 /* The interface is active and the device is present */
5513 /* But the port is is not ready for some reason */
5515 }
5516 }
5519 }
5522 /*
5523 * si_watchdog_handler() calls us if it detects that there are some
5524 * commands which timed out. We recalculate the timed out commands once
5525 * again since some of them may have finished recently.
5526 */
5527 static void
5533 {
5546 /*
5547 * Initialize the controller. The only way to timeout the commands
5548 * is to reset or initialize the controller. We mop commands after
5549 * the initialization.
5550 */
5553 /*
5554 * Recompute the timedout tags since some of them may have finished
5555 * meanwhile.
5556 */
5563 finished_tags,
5564 timedout_tags);
5567 si_portp,
5568 port,
5569 slot_status,
5571 timedout_tags,
5576 }
5580 /*
5581 * Watchdog handler kicks in every 5 seconds to timeout any commands pending
5582 * for long time.
5583 */
5584 static void
5586 {
5594 /* max number of cycles this packet should survive */
5597 /* how many cycles this packet survived so far */
5609 }
5616 }
5618 /* Skip the check for those ports in error recovery */
5621 "si_watchdog_handler: port %d mopping "
5625 }
5633 }
5638 /*
5639 * We are overloading satapkt_hba_driver_private
5640 * with watched_cycle count.
5641 *
5642 * If a packet has survived for more than it's
5643 * max life cycles, it is a candidate for time
5644 * out.
5645 */
5648 watched_cycles++;
5651 si_watchdog_timeout;
5655 si_portp,
5657 timedout_tags);
5658 }
5661 }
5664 }
5672 }
5675 }
5677 /* Reinstall the watchdog timeout handler. */
5682 }
5684 }
5686 /*
5687 * FMA Functions
5688 */
5690 /*
5691 * The IO fault service error handling callback function
5692 */
5693 /*ARGSUSED*/
5694 static int
5696 {
5697 /*
5698 * as the driver can always deal with an error in any dma or
5699 * access handle, we can just return the fme_status value.
5700 */
5703 }
5705 /*
5706 * si_fm_init - initialize fma capabilities and register with IO
5707 * fault services.
5708 */
5709 static void
5711 {
5712 /*
5713 * Need to change iblock to priority for new MSI intr
5714 */
5715 ddi_iblock_cookie_t fm_ibc;
5717 /* Only register with IO Fault Services if we have some capability */
5719 /* Adjust access and dma attributes for FMA */
5724 /*
5725 * Register capabilities with IO Fault Services.
5726 * fm_capabilities will be updated to indicate
5727 * capabilities actually supported (not requested.)
5728 */
5735 /*
5736 * Initialize pci ereport capabilities if ereport
5737 * capable (should always be.)
5738 */
5742 }
5744 /*
5745 * Register error callback if error callback capable.
5746 */
5750 }
5751 }
5752 }
5754 /*
5755 * si_fm_fini - Releases fma capabilities and un-registers with IO
5756 * fault services.
5757 */
5758 static void
5760 {
5761 /* Only unregister FMA capabilities if registered */
5763 /*
5764 * Un-register error callback if error callback capable.
5765 */
5768 }
5770 /*
5771 * Release any resources allocated by pci_ereport_setup()
5772 */
5776 }
5778 /* Unregister from IO Fault Services */
5781 /* Adjust access and dma attributes for FMA */
5785 }
5786 }
5788 static int
5790 {
5791 ddi_fm_error_t de;
5796 }
5798 static int
5800 {
5801 ddi_fm_error_t de;
5806 }
5808 static int
5810 {
5818 }
5821 }
5823 /*
5824 * WARNING: The caller is expected to obtain the siport_mutex
5825 * before calling us.
5826 */
5827 static int
5829 {
5839 }
5842 }
5844 static void
5846 {
5855 DDI_NOSLEEP,
5858 NULL);
5859 }
5860 }
5862 /*
5863 * Logs the message.
5864 */
5865 static void
5867 {
5879 }
5886 }
5888 /*
5889 * si_portp is not NULL, but si_ctlp might be.
5890 * Reference si_portp for both port and dip.
5891 */
5900 }
5909 }
5911 static void
5914 {
5920 /*
5921 * The LRAM contains the the modified FIS after command completion, so
5922 * first copy it back to the in-core PRB pool. To save read cycles,
5923 * just copy over the FIS portion of the PRB pool.
5924 */
5934 }
5936 /*
5937 * always get the status register
5938 */
5949 }
5956 }
5963 }
5970 }
5978 }
5985 }
5992 }
5999 }
6006 }
6013 }
6014 }
6016 /*
6017 * This function clear the special port by send the PORT RESET
6018 * After reset was sent, all commands running on the port
6019 * is aborted
6020 */
6021 static int
6023 {
6027 /*
6028 * reset this port so that all existing command
6029 * is clear
6030 */
6033 PORT_CONTROL_SET_BITS_PORT_RESET);
6035 /* Port reset is not self clearing. So clear it now. */
6038 PORT_CONTROL_CLEAR_BITS_PORT_RESET);
6040 }
6042 /*
6043 * quiesce(9E) entry point.
6044 * This function is called when the system is single-threaded at high
6045 * PIL with preemption disabled. Therefore, this function must not be
6046 * blocked.
6047 *
6048 * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure.
6049 * DDI_FAILURE indicates an error condition and should almost never happen.
6050 */
6051 static int
6053 {
6064 /*
6065 * Disable all the interrupts before quiesce
6066 */
6071 }
6074 }