| blob | 32df68974996a48c3215d91343c0b1ff40127bbe |
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
1376 {
1384 slot_status);
1387 "si_mop_commands: failed_tags: 0x%x, timedout_tags: 0x%x"
1389 failed_tags,
1390 timedout_tags,
1391 aborting_tags,
1392 reset_tags);
1394 /*
1395 * We could be here for four reasons: abort, reset,
1396 * timeout or error handling. Only one such mopping
1397 * is allowed at a time.
1398 */
1409 /* Send up the finished_tags with SATA_PKT_COMPLETED. */
1414 }
1422 }
1426 satapkt);
1431 }
1435 /* Send up failed_tags with SATA_PKT_DEV_ERROR. */
1440 }
1449 SATA_DTYPE_ATAPICD) {
1451 }
1470 /*
1471 * In the case of NCQ command failures, the error is
1472 * overwritten by the one obtained from issuing of a
1473 * READ LOG EXTENDED command.
1474 */
1479 }
1480 }
1485 }
1489 /* Send up timedout_tags with SATA_PKT_TIMEOUT. */
1494 }
1498 "si_mop_commands sending "
1500 satapkt);
1505 }
1509 /* Send up aborting packets with SATA_PKT_ABORTED. */
1514 }
1519 satapkt);
1521 SATA_DTYPE_ATAPICD) {
1523 }
1529 }
1533 /* Reset tags are sent up to framework with SATA_PKT_RESET. */
1538 }
1541 "si_mop_commands sending PKT_RESET for "
1543 satapkt);
1548 }
1552 /* Send up the unfinished_tags with SATA_PKT_RESET. */
1557 }
1560 "si_mop_commands sending SATA_PKT_RESET for "
1562 satapkt);
1567 }
1573 }
1575 /*
1576 * Called by the sata framework to abort the previously sent packet(s).
1577 *
1578 * We reset the device and mop the commands on the port.
1579 */
1580 static int
1582 {
1601 /*
1602 * If already mopping, then no need to abort anything.
1603 */
1606 "si_tran_abort: port %d mopping "
1610 }
1614 /*
1615 * si_intr_phy_ready_change() may have rendered it to
1616 * PORT_TYPE_NODEV. cfgadm operation may have rendered
1617 * it inactive.
1618 */
1623 }
1628 /*
1629 * Need to abort a single packet.
1630 * Search our siport_slot_pkts[] list for matching spkt.
1631 */
1637 }
1638 }
1641 /* requested packet is not on pending list. */
1646 }
1647 }
1656 /*
1657 * Compute which have finished and which need to be retried.
1658 *
1659 * The finished tags are siport_pending_tags minus the slot_status.
1660 * The aborting_tags have to be reduced by finished_tags since we
1661 * can't possibly abort a tag which had finished already.
1662 */
1668 si_portp,
1669 port,
1670 slot_status,
1673 aborting_tags,
1679 }
1682 /*
1683 * Used to reject all the pending packets on a port during a reset
1684 * operation.
1685 *
1686 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
1687 * before calling us.
1688 */
1689 static void
1694 {
1702 port);
1707 /* Compute which tags need to be sent up. */
1713 si_portp,
1714 port,
1715 slot_status,
1719 reset_tags);
1720 }
1723 /*
1724 * Called by sata framework to reset a port(s) or device.
1725 *
1726 */
1727 static int
1729 {
1739 port);
1749 /*
1750 * If already mopping, then no need to reset or mop again.
1751 */
1754 "si_tran_reset_dport: CPORT port %d mopping "
1759 }
1762 SI_PORT_RESET);
1780 }
1782 /*
1783 * If already mopping, then no need to reset or mop again.
1784 */
1787 "si_tran_reset_dport: DCPORT port %d mopping "
1792 }
1795 SI_DEVICE_RESET);
1809 /*
1810 * If mopping, then all the pending commands are being
1811 * mopped, therefore there is nothing else to do.
1812 */
1815 "si_tran_reset_dport: CNTRL port %d mopping"
1820 }
1827 }
1830 }
1837 /* FALLTHROUGH */
1842 }
1845 }
1848 /*
1849 * Called by sata framework to activate a port as part of hotplug.
1850 *
1851 * Note: Not port-mult aware.
1852 */
1853 static int
1855 {
1867 NULL);
1872 /*
1873 * Reset the device so that a si_find_dev_signature() would trigger.
1874 * But this reset is an internal operation; the sata framework does
1875 * not need to know about it.
1876 */
1888 }
1890 /*
1891 * Called by sata framework to deactivate a port as part of hotplug.
1892 *
1893 * Note: Not port-mult aware.
1894 */
1895 static int
1897 {
1912 /*
1913 * There are pending commands on this port.
1914 * Fail the deactivate request.
1915 */
1919 }
1921 /* mark the device as not accessible any more. */
1924 /* disable the interrupts on the port. */
1930 /*
1931 * Since we are implementing the port deactivation in software only,
1932 * we need to fake a valid value for sstatus.
1933 */
1939 }
1942 /*
1943 * Allocates the si_port_state_t.
1944 */
1945 static int
1947 {
1958 /* allocate prb & sgt pkts for this port. */
1963 }
1969 }
1971 /* Allocate the argument for the timeout */
1980 }
1982 /*
1983 * Deallocates the si_port_state_t.
1984 */
1985 static void
1987 {
2001 }
2003 /*
2004 * Allocates the SGB (Scatter Gather Block) incore buffer.
2005 */
2006 static int
2008 {
2010 uint_t cookie_count;
2014 ddi_dma_cookie_t sgbpool_dma_cookie;
2018 /* allocate sgbpool dma handle. */
2021 DDI_DMA_SLEEP,
2022 NULL,
2024 DDI_SUCCESS) {
2027 }
2029 /* allocate the memory for sgbpool. */
2031 incore_sgbpool_size,
2034 DDI_DMA_SLEEP,
2035 NULL,
2040 /* error.. free the dma handle. */
2043 }
2045 /* now bind it */
2047 NULL,
2049 incore_sgbpool_size,
2050 DDI_DMA_CONSISTENT,
2051 DDI_DMA_SLEEP,
2052 NULL,
2055 /* error.. free the dma handle & free the memory. */
2059 }
2063 }
2065 /*
2066 * Deallocates the SGB (Scatter Gather Block) incore buffer.
2067 */
2068 static void
2070 {
2073 /* Unbind the dma handle first. */
2076 /* Then free the underlying memory. */
2079 /* Now free the handle itself. */
2082 }
2084 /*
2085 * Allocates the PRB (Port Request Block) incore packets.
2086 */
2087 static int
2089 {
2091 uint_t cookie_count;
2094 ddi_dma_cookie_t prbpool_dma_cookie;
2098 /* allocate prb pkts. */
2101 DDI_DMA_SLEEP,
2102 NULL,
2104 DDI_SUCCESS) {
2107 }
2110 incore_pkt_size,
2113 DDI_DMA_SLEEP,
2114 NULL,
2119 /* error.. free the dma handle. */
2122 }
2125 NULL,
2127 incore_pkt_size,
2128 DDI_DMA_CONSISTENT,
2129 DDI_DMA_SLEEP,
2130 NULL,
2133 /* error.. free the dma handle & free the memory. */
2137 }
2142 }
2144 /*
2145 * Deallocates the PRB (Port Request Block) incore packets.
2146 */
2147 static void
2149 {
2152 /* Unbind the prb dma handle first. */
2155 /* Then free the underlying memory. */
2158 /* Now free the handle itself. */
2161 }
2165 /*
2166 * Soft-reset the port to find the signature of the device connected to
2167 * the port.
2168 */
2169 static void
2175 {
2184 /* Build a Soft Reset PRB in host memory. */
2189 /* Empty slot could not be found. */
2191 /* We are behind port multiplier. */
2193 PORT_TYPE_NODEV;
2196 }
2200 }
2207 #if SI_DEBUG
2217 }
2219 }
2221 }
2224 /* deliver soft reset prb to empty slot. */
2228 /* Loop till the soft reset is finished. */
2234 /* We are effectively timing out after 10 sec. */
2236 }
2238 /* Wait for 10 millisec */
2239 #ifndef __lock_lint
2251 /* Read device signature from command slot. */
2268 /*
2269 * It is wrong to chain a port multiplier behind
2270 * another port multiplier.
2271 */
2273 PORT_TYPE_NODEV;
2280 }
2285 /* We are behind port multiplier. */
2287 PORT_TYPE_ATAPI;
2291 }
2299 /* We are behind port multiplier. */
2301 PORT_TYPE_DISK;
2305 }
2312 /* We are behind port multiplier. */
2314 PORT_TYPE_UNKNOWN;
2317 }
2321 }
2324 }
2327 /*
2328 * Polls for the completion of the command. This is safe with both
2329 * interrupts enabled or disabled.
2330 */
2331 static void
2338 {
2350 /* we start out with SATA_PKT_COMPLETED as the satapkt_reason */
2359 /*
2360 * If we are in panic, we can't rely on
2361 * timers; so, busy wait instead of delay().
2362 */
2368 #ifndef __lock_lint
2372 }
2375 }
2382 /* The si_mop_command() got to our packet before us */
2385 }
2387 /*
2388 * Interrupts and timers may not be working properly in a crash dump
2389 * situation; we may need to handle all the three conditions here:
2390 * successful completion, packet failure and packet timeout.
2391 */
2408 /*
2409 * Why do we need to call si_intr_command_error() ?
2410 *
2411 * Answer: Even if the current packet is not the
2412 * offending command, we need to restart the stalled
2413 * port; (may be, the interrupts are not working well
2414 * in panic condition). The call to routine
2415 * si_intr_command_error() will achieve that.
2416 *
2417 * What if the interrupts are working fine and the
2418 * si_intr_command_error() gets called once more from
2419 * interrupt context ?
2420 *
2421 * Answer: The second instance of routine
2422 * si_intr_command_error() will not mop anything
2423 * since the first error handler has already blown
2424 * away the hardware pending queues through reset.
2425 *
2426 * Will the si_intr_command_error() hurt current
2427 * packet ?
2428 *
2429 * Answer: No.
2430 */
2432 /* Ignore any non-error interrupts at this stage */
2435 port)),
2437 }
2446 }
2449 SATAC_WRITE_FPDMA_QUEUED) ||
2451 SATAC_READ_FPDMA_QUEUED)) {
2453 }
2457 /*
2458 * tidbit: What is the interaction of abort with polling ?
2459 * What happens if the current polled pkt is aborted in parallel ?
2460 *
2461 * Answer: Assuming that the si_mop_commands() completes ahead
2462 * of polling, all it does is to set the satapkt_reason to
2463 * SPKT_PKT_ABORTED. That would be fine with us.
2464 *
2465 * The same logic applies to reset interacting with polling.
2466 */
2467 }
2470 /*
2471 * Searches for and claims a free slot.
2472 *
2473 * Returns: SI_FAILURE if no slots found
2474 * claimed slot number if successful
2475 *
2476 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
2477 * before calling us.
2478 */
2479 /*ARGSUSED*/
2480 static int
2482 {
2498 }
2502 slot);
2504 }
2506 /*
2507 * Builds the PRB for the sata packet and delivers it to controller.
2508 *
2509 * Returns:
2510 * slot number if we can obtain a slot successfully
2511 * otherwise, return SI_FAILURE
2512 *
2513 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
2514 * before calling us.
2515 */
2516 static int
2522 {
2532 ddi_dma_cookie_t cookie;
2539 }
2543 }
2547 /*
2548 * si_intr_phy_ready_change() may have rendered it to
2549 * PORT_TYPE_NODEV. cfgadm operation may have rendered
2550 * it inactive.
2551 */
2557 }
2566 "si_deliver_satpkt entry: cmd_reg: 0x%x, slot: 0x%x, \
2570 /* Now fill the prb. */
2573 SATA_DIR_READ) {
2578 }
2579 }
2586 }
2595 /*
2596 * satacmd_addr_type will be 0 for the commands below:
2597 * SATAC_PACKET
2598 * SATAC_IDLE_IM
2599 * SATAC_STANDBY_IM
2600 * SATAC_DOWNLOAD_MICROCODE
2601 * SATAC_FLUSH_CACHE
2602 * SATAC_SET_FEATURES
2603 * SATAC_SMART
2604 * SATAC_ID_PACKET_DEVICE
2605 * SATAC_ID_DEVICE
2606 * SATAC_READ_PORTMULT
2607 * SATAC_WRITE_PORTMULT
2608 */
2609 /* FALLTHRU */
2612 /* FALLTHRU */
2615 /* LBA[7:0] */
2618 /* LBA[15:8] */
2621 /* LBA[23:16] */
2624 /* LBA [27:24] (also called dev_head) */
2630 /* LBA[7:0] */
2633 /* LBA[15:8] */
2636 /* LBA[23:16] */
2639 /* LBA [31:24] */
2642 /* LBA [39:32] */
2645 /* LBA [47:40] */
2648 /* Set dev_head */
2651 /* Set the extended sector count and features */
2659 }
2662 /*
2663 * For queued commands, the TAG for the sector count lsb is
2664 * generated from current slot number.
2665 */
2667 }
2672 }
2674 /* *** now fill the scatter gather list ******* */
2677 /* atapi command goes into sge0 */
2680 /* Now fill sge1 with pointer to external SGT. */
2688 }
2690 /* Fill the sge0 */
2699 }
2701 /* sge1 is left empty in non-ATAPI case */
2702 }
2716 /* No cookies. Terminate the chain. */
2718 NULL);
2726 }
2734 /* Now fill the first 3 entries of SGT in the loop below. */
2741 cookie_index,
2742 ncookies);
2749 }
2751 /*
2752 * If this happens to be the last cookie, we terminate it here.
2753 * Otherwise, we link to next SGT.
2754 */
2757 /* This is the last cookie. Terminate the chain. */
2759 "filling the last: cookie_index: %d, "
2761 cookie_index,
2762 ncookies);
2774 /* This is not the last one. So link it. */
2777 cookie_index,
2778 ncookies);
2784 }
2786 }
2788 /* *** finished filling the scatter gather list ******* */
2790 sgl_fill_done:
2791 /* Now remember the sata packet in siport_slot_pkts[]. */
2794 /*
2795 * We are overloading satapkt_hba_driver_private with
2796 * watched_cycle count.
2797 */
2801 /* program the packet_lenth if it is atapi device. */
2804 #ifdef ATAPI_2nd_PHASE
2805 /*
2806 * Framework needs to calculate the acdb_len based on
2807 * identify packet data. This needs to be accomplished
2808 * in second phase of the project.
2809 */
2818 PORT_CONTROL_SET_BITS_PACKET_LEN);
2822 PORT_CONTROL_CLEAR_BITS_PACKET_LEN);
2823 }
2826 /* hard coding for now to 12 bytes */
2829 PORT_CONTROL_CLEAR_BITS_PACKET_LEN);
2831 }
2834 #if SI_DEBUG
2837 /*
2838 * Do not dump the atapi Test-Unit-Ready commands.
2839 * The sd_media_watch spews too many of these.
2840 */
2849 }
2867 }
2869 }
2870 }
2872 }
2875 /* Deliver PRB */
2879 }
2881 /*
2882 * Initialize the controller and set up driver data structures.
2883 *
2884 * This routine can be called from three separate cases: DDI_ATTACH, PM_LEVEL_D0
2885 * and DDI_RESUME. The DDI_ATTACH case is different from other two cases; the
2886 * memory allocation & device signature probing are attempted only during
2887 * DDI_ATTACH case. In the case of PM_LEVEL_D0 & DDI_RESUME, we are starting
2888 * from a previously initialized state; so there is no need to allocate memory
2889 * or to attempt probing the device signatures.
2890 */
2891 static int
2893 {
2906 /* Remove the Global Reset. */
2909 GLOBAL_CONTROL_REG_BITS_CLEAR);
2914 /*
2915 * We allocate the port state only during attach
2916 * sequence. We don't want to do it during
2917 * suspend/resume sequence.
2918 */
2922 }
2923 }
2930 /* Clear Port Reset. */
2933 PORT_CONTROL_SET_BITS_PORT_RESET);
2936 PORT_CONTROL_CLEAR_BITS_PORT_RESET);
2938 /*
2939 * Arm the interrupts for: Cmd completion, Cmd error,
2940 * Port Ready, PM Change, PhyRdyChange, Commwake,
2941 * UnrecFIS, Devxchanged, SDBNotify.
2942 */
2946 INTR_COMMAND_ERROR |
2947 INTR_PORT_READY |
2948 INTR_POWER_CHANGE |
2949 INTR_PHYRDY_CHANGE |
2950 INTR_COMWAKE_RECEIVED |
2951 INTR_UNRECOG_FIS |
2952 INTR_DEV_XCHANGED |
2953 INTR_SETDEVBITS_NOTIFY));
2955 /* Now enable the interrupts. */
2958 /*
2959 * The following PHY initialization is redundant in
2960 * in x86 since the BIOS anyway does this as part of
2961 * device enumeration during the power up. But this
2962 * is a required step in sparc since there is no BIOS.
2963 *
2964 * The way to initialize the PHY is to write a 1 and then
2965 * a 0 to DET field of SControl register.
2966 */
2968 /*
2969 * Fetch the current SControl before writing the
2970 * DET part with 1
2971 */
2977 SControl);
2978 #ifndef __lock_lint
2982 /*
2983 * Now fetch the SControl again and rewrite the
2984 * DET part with 0
2985 */
2991 SControl);
2993 /*
2994 * PHY may be initialized by now. Check the DET field of
2995 * SStatus to determine if there is a device present.
2996 *
2997 * The DET field is valid only if IPM field indicates that
2998 * the interface is in active state.
2999 */
3007 SSTATUS_IPM_INTERFACE_ACTIVE) {
3008 /*
3009 * If the interface is not active, the DET field
3010 * is considered not accurate. So we want to
3011 * continue looping.
3012 */
3014 SSTATUS_DET_NODEV_NOPHY);
3015 }
3018 /*
3019 * We are effectively timing out after 0.1 sec.
3020 */
3022 }
3024 /* Wait for 10 millisec */
3025 #ifndef __lock_lint
3030 SSTATUS_DET_DEVPRESENT_PHYONLINE);
3033 "si_initialize_controller: 1st loop count: %d, "
3035 loop_count,
3036 SStatus);
3039 SSTATUS_IPM_INTERFACE_ACTIVE) ||
3041 SSTATUS_DET_DEVPRESENT_PHYONLINE)) {
3042 /*
3043 * Either the port is not active or there
3044 * is no device present.
3045 */
3047 PORT_TYPE_NODEV;
3050 }
3052 /* Wait until Port Ready */
3059 /*
3060 * We are effectively timing out after 0.5 sec.
3061 */
3063 }
3065 /* Wait for 10 millisec */
3066 #ifndef __lock_lint
3074 loop_count);
3077 /*
3078 * We want to probe for dev signature only during attach
3079 * case. Don't do it during suspend/resume sequence.
3080 */
3084 PORTMULT_CONTROL_PORT);
3088 PORT_TYPE_NODEV;
3089 }
3090 }
3095 DDI_SERVICE_LOST);
3099 }
3102 }
3106 }
3108 /*
3109 * Reverse of si_initialize_controller().
3110 *
3111 * WARNING, WARNING: The caller is expected to obtain the sictl_mutex
3112 * before calling us.
3113 */
3114 static void
3116 {
3124 /* disable all the interrupts. */
3128 /*
3129 * We want to dealloc all the memory in detach case.
3130 */
3133 }
3134 }
3136 }
3138 /*
3139 * Prepare the port ready for usage.
3140 *
3141 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
3142 * before calling us.
3143 */
3144 static void
3146 {
3150 port);
3152 /* Initialize the port. */
3155 PORT_CONTROL_SET_BITS_PORT_INITIALIZE);
3157 /*
3158 * Clear the InterruptNCOR (Interrupt No Clear on Read).
3159 * This step ensures that a mere reading of slot_status will clear
3160 * the interrupt; no explicit clearing of interrupt condition
3161 * will be needed for successful completion of commands.
3162 */
3165 PORT_CONTROL_CLEAR_BITS_INTR_NCoR);
3167 /* clear any pending interrupts at this point */
3170 INTR_MASK);
3172 }
3175 /*
3176 * Enumerate the devices connected to the port multiplier.
3177 * Once a device is detected, we call si_find_dev_signature()
3178 * to find the type of device connected. Even though we are
3179 * called from within si_find_dev_signature(), there is no
3180 * recursion possible.
3181 */
3182 static int
3187 {
3197 port);
3201 /* Enable Port Multiplier context switching. */
3204 PORT_CONTROL_SET_BITS_PM_ENABLE);
3206 /*
3207 * Read the num dev ports connected.
3208 * GSCR[2] contains the number of device ports.
3209 */
3214 }
3219 num_dev_ports);
3222 /*
3223 * Enable PHY by writing a 1, then a 0 to SControl
3224 * (i.e. PSCR[2]) DET field.
3225 */
3229 }
3231 /* First write a 1 to DET field of SControl. */
3236 }
3237 #ifndef __lock_lint
3241 /* Then write a 0 to the DET field of SControl. */
3246 }
3248 /* Wait for PHYRDY by polling SStatus (i.e. PSCR[0]). */
3254 }
3257 SStatus);
3260 SSTATUS_IPM_INTERFACE_ACTIVE) {
3261 /*
3262 * If the interface is not active, the DET field
3263 * is considered not accurate. So we want to
3264 * continue looping.
3265 */
3267 SSTATUS_DET_NODEV_NOPHY);
3268 }
3271 /*
3272 * We are effectively timing out after 0.1 sec.
3273 */
3275 }
3277 /* Wait for 10 millisec */
3278 #ifndef __lock_lint
3283 SSTATUS_DET_DEVPRESENT_PHYONLINE);
3286 "si_enumerate_port_multiplier: "
3288 loop_count,
3289 SStatus);
3292 SSTATUS_IPM_INTERFACE_ACTIVE) &&
3294 SSTATUS_DET_DEVPRESENT_PHYONLINE)) {
3295 /* The interface is active and the device is present */
3298 SStatus);
3299 /*
3300 * Clear error bits in SError register (i.e. PSCR[1]
3301 * by writing back error bits.
3302 */
3306 }
3312 }
3314 /* There exists a device. */
3318 }
3319 }
3324 }
3327 /*
3328 * Read a port multiplier register.
3329 *
3330 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
3331 * before calling us.
3332 */
3333 static int
3341 {
3358 }
3363 /* Now fill the prb. */
3372 /* no real data transfer is involved. */
3375 #if SI_DEBUG
3384 }
3386 }
3389 /* Deliver PRB */
3392 /* Loop till the command is finished. */
3399 slot_status);
3402 /* We are effectively timing out after 0.5 sec. */
3404 }
3406 /* Wait for 10 millisec */
3407 #ifndef __lock_lint
3415 loop_count);
3419 /* Now inspect the port LRAM for the modified FIS. */
3424 }
3429 DDI_SERVICE_UNAFFECTED);
3431 }
3435 /* command failed. */
3437 }
3439 /* command succeeded. */
3446 }
3448 /*
3449 * Write a port multiplier register.
3450 *
3451 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
3452 * before calling us.
3453 */
3454 static int
3462 {
3473 "si_write_portmult_reg: port: %x, pmport: %x,"
3480 }
3485 /* Now fill the prb. */
3499 /* no real data transfer is involved. */
3502 #if SI_DEBUG
3511 }
3513 }
3516 /* Deliver PRB */
3519 /* Loop till the command is finished. */
3526 slot_status);
3529 /* We are effectively timing out after 0.5 sec. */
3531 }
3533 /* Wait for 10 millisec */
3534 #ifndef __lock_lint
3542 loop_count);
3546 /* Now inspect the port LRAM for the modified FIS. */
3551 }
3556 DDI_SERVICE_UNAFFECTED);
3558 }
3562 /* command failed */
3564 }
3566 /* command succeeded */
3568 }
3571 /*
3572 * Set the auto sense data for ATAPI devices.
3573 *
3574 * Note: Currently the sense data is simulated; this code will be enhanced
3575 * in second phase to fetch the real sense data from the atapi device.
3576 */
3577 static void
3579 {
3602 }
3603 }
3606 /*
3607 * Interrupt service handler. We loop through each of the ports to find
3608 * if the interrupt belongs to any of them.
3609 *
3610 * Bulk of the interrupt handling is actually done out of subroutines
3611 * like si_intr_command_complete() etc.
3612 */
3613 /*ARGSUSED*/
3614 static uint_t
3616 {
3628 global_intr_status);
3631 DDI_SUCCESS) {
3633 DDI_SERVICE_UNAFFECTED);
3635 }
3638 /* Sorry, the interrupt is not ours. */
3640 }
3642 /* Loop for all the ports. */
3648 }
3659 port_intr_status,
3660 port);
3664 port);
3670 DDI_SERVICE_UNAFFECTED);
3672 port);
3673 }
3676 /* Clear the interrupts */
3680 }
3682 /*
3683 * Note that we did not clear the interrupt for command
3684 * completion interrupt. Reading of slot_status takes care
3685 * of clearing the interrupt for command completion case.
3686 */
3690 }
3694 }
3698 }
3702 port);
3703 }
3707 port);
3708 }
3712 port);
3713 }
3717 }
3721 port);
3722 }
3726 port);
3727 }
3732 }
3736 port);
3737 }
3738 }
3741 }
3743 /*
3744 * Interrupt which indicates that one or more commands have successfully
3745 * completed.
3746 *
3747 * Since we disabled W1C (write-one-to-clear) previously, mere reading
3748 * of slot_status register clears the interrupt. There is no need to
3749 * explicitly clear the interrupt.
3750 */
3751 static int
3756 {
3772 /*
3773 * Spurious interrupt. Nothing to be done.
3774 * The interrupt was cleared when slot_status was read.
3775 */
3778 }
3783 slot_status);
3792 }
3798 finished_slot);
3799 }
3804 }
3809 slot_status);
3811 /*
3812 * tidbit: no need to clear the interrupt since reading of
3813 * slot_status automatically clears the interrupt in the case
3814 * of a successful command completion.
3815 */
3820 }
3822 /*
3823 * Schedule a call to si_intr_command_error using a timeout to get it done
3824 * off the interrupt thread.
3825 */
3826 static void
3831 {
3842 }
3850 }
3852 /*
3853 * Called from timeout()
3854 * Unpack the arguments and call si_intr_command_error()
3855 */
3856 static void
3858 {
3874 }
3876 /*
3877 * Interrupt which indicates that a command did not complete successfully.
3878 *
3879 * The port halts whenever a command error interrupt is received.
3880 * The only way to restart it is to reset or reinitialize the port
3881 * but such an operation throws away all the pending commands on
3882 * the port.
3883 *
3884 * We reset the device and mop the commands on the port.
3885 */
3886 static int
3891 {
3900 command_error);
3904 /*
3905 * Remember the slot_status since any of the recovery handler
3906 * can blow it away with reset operation.
3907 */
3923 DDI_SERVICE_UNAFFECTED);
3931 DDI_SERVICE_UNAFFECTED);
3939 DDI_SERVICE_UNAFFECTED);
3947 DDI_SERVICE_UNAFFECTED);
3950 }
3952 /*
3953 * Compute the failed_tags by adding up the error tags.
3954 *
3955 * The siport_err_tags_SDBERROR and siport_err_tags_nonSDBERROR
3956 * were filled in by the si_error_recovery_* routines.
3957 */
3963 "err_tags_SDBERROR: 0x%x, "
3964 "err_tags_nonSDBERRROR: 0x%x, "
3968 failed_tags);
3971 "si3124: si_intr_command_error: "
3973 slot_status,
3979 si_portp,
3980 port,
3981 slot_status,
3982 failed_tags,
3995 }
3997 /*
3998 * There is a subtle difference between errors on a normal port and
3999 * a port-mult port. When an error happens on a normal port, the port
4000 * is halted effectively until the port is reset or initialized.
4001 * However, in port-mult port errors, port does not get halted since
4002 * other non-error devices behind the port multiplier can still
4003 * continue to operate. So we wait till all the commands are drained
4004 * instead of resetting it right away.
4005 *
4006 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4007 * before calling us.
4008 */
4009 static void
4014 {
4023 port);
4025 /* Resume the port */
4028 PORT_CONTROL_SET_BITS_RESUME);
4041 }
4043 /* Now we drain the pending commands. */
4048 /*
4049 * Since we have not yet returned DDI_INTR_CLAIMED,
4050 * our interrupt handler is guaranteed not to be called again.
4051 * So we need to check IS_ATTENTION_RAISED() for further
4052 * decisions.
4053 *
4054 * This is a too big a delay for an interrupt context.
4055 * But this is supposed to be a rare condition.
4056 */
4059 /* Resume again */
4062 PORT_CONTROL_SET_BITS_RESUME);
4070 port)));
4077 }
4078 }
4081 /* We are effectively timing out after 10 sec. */
4083 }
4085 /* Wait for 10 millisec */
4086 #ifndef __lock_lint
4092 /*
4093 * The above loop can be improved for 3132 since we could obtain the
4094 * Port Multiplier Context of the device in error. Then we could
4095 * do a better job in filtering out commands for the device in error.
4096 * The loop could finish much earlier with such a logic.
4097 */
4099 /* Clear the RESUME bit. */
4102 PORT_CONTROL_CLEAR_BITS_RESUME);
4104 }
4106 /*
4107 * If we are connected to port multiplier, drain the non-failed devices.
4108 * Otherwise, we initialize the port (which effectively fails all the
4109 * pending commands in the hope that sd would retry them later).
4110 *
4111 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4112 * before calling us.
4113 */
4114 static void
4119 {
4127 port);
4136 }
4138 /* In either case (port-mult or not), we reinitialize the port. */
4140 }
4142 /*
4143 * Handle exactly like DEVICEERROR. Remember the tags with SDBERROR
4144 * to perform read_log_ext on them later. SDBERROR means that the
4145 * error was for an NCQ command.
4146 *
4147 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4148 * before calling us.
4149 */
4150 static void
4155 {
4163 port);
4172 }
4174 /* In either case (port-mult or not), we reinitialize the port. */
4176 }
4178 /*
4179 * Handle exactly like DEVICEERROR except resetting the port if there was
4180 * an NCQ command on the port.
4181 *
4182 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4183 * before calling us.
4184 */
4185 static void
4190 {
4198 port);
4200 /* reset device if we were waiting for any ncq commands. */
4207 SI_DEVICE_RESET);
4209 }
4211 /*
4212 * If we don't have any ncq commands pending, the rest of
4213 * the process is similar to the one for DEVICEERROR.
4214 */
4216 }
4218 /*
4219 * We handle just like DEVICERROR except that we reset the device instead
4220 * of initializing the port.
4221 *
4222 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4223 * before calling us.
4224 */
4225 static void
4230 {
4238 port);
4248 SI_DEVICE_RESET);
4249 }
4250 }
4252 /*
4253 * The default behavior for all other errors is to reset the device.
4254 *
4255 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4256 * before calling us.
4257 */
4258 static void
4263 {
4271 port);
4279 SI_DEVICE_RESET);
4280 }
4282 /*
4283 * Read Log Ext with PAGE 10 to retrieve the error for an NCQ command.
4284 *
4285 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4286 * before calling us.
4287 */
4288 static uint8_t
4290 {
4307 }
4312 /* Now fill the prb */
4319 /* no real data transfer is involved */
4322 #if SI_DEBUG
4331 }
4333 }
4336 /* Deliver PRB */
4339 /* Loop till the command is finished. */
4346 slot_status);
4349 /* We are effectively timing out after 0.5 sec. */
4351 }
4353 /* Wait for 10 millisec */
4354 #ifndef __lock_lint
4361 /*
4362 * If we fail with the READ LOG EXT command, we need to
4363 * initialize the port to clear the slot_status register.
4364 * We don't need to worry about any other valid commands
4365 * being thrown away because we are already in recovery
4366 * mode and READ LOG EXT is the only pending command.
4367 */
4369 }
4373 loop_count);
4375 /*
4376 * The LRAM contains the the modified FIS.
4377 * Read the modified FIS to obtain the Error.
4378 */
4383 }
4388 DDI_SERVICE_UNAFFECTED);
4389 }
4397 }
4399 /*
4400 * Dump the error message to the log.
4401 */
4402 static void
4404 {
4405 #if SI_DEBUG
4406 #ifndef __lock_lint
4510 }
4514 errstr);
4515 #else
4516 #ifndef __lock_lint
4523 }
4526 /*
4527 * Interrupt which indicates that the Port Ready state has changed
4528 * from zero to one.
4529 *
4530 * We are not interested in this interrupt; we just log a debug message.
4531 */
4532 /*ARGSUSED*/
4533 static int
4538 {
4541 }
4543 /*
4544 * Interrupt which indicates that the port power management state
4545 * has been modified.
4546 *
4547 * We are not interested in this interrupt; we just log a debug message.
4548 */
4549 /*ARGSUSED*/
4550 static int
4555 {
4558 }
4560 /*
4561 * Interrupt which indicates that the PHY state has changed either from
4562 * Not-Ready to Ready or from Ready to Not-Ready.
4563 */
4564 static int
4569 {
4570 sata_device_t sdevice;
4580 /* the whole controller setup is not yet done. */
4583 }
4589 /* SStatus tells the presence of device. */
4592 dev_exists_now =
4597 }
4604 /* we don't have a way of determining the exact port-mult port. */
4609 }
4616 /* Things are fine now. The loss was temporary. */
4621 "sending event: LINK_LOST & "
4626 sata_tran_hba_dip,
4628 SATA_EVNT_LINK_LOST|
4629 SATA_EVNT_LINK_ESTABLISHED);
4630 }
4634 /* A new device has been detected. */
4637 PORTMULT_CONTROL_PORT);
4647 sata_tran_hba_dip,
4649 SATA_EVNT_LINK_ESTABLISHED);
4650 }
4652 }
4657 /* An existing device is lost. */
4664 sata_tran_hba_dip,
4666 SATA_EVNT_LINK_LOST);
4667 }
4672 /* spurious interrupt */
4675 }
4676 }
4680 }
4683 /*
4684 * Interrupt which indicates that a COMWAKE OOB signal has been decoded
4685 * on the receiver.
4686 *
4687 * We are not interested in this interrupt; we just log a debug message.
4688 */
4689 /*ARGSUSED*/
4690 static int
4695 {
4699 }
4701 /*
4702 * Interrupt which indicates that the F-bit has been set in SError
4703 * Diag field.
4704 *
4705 * We are not interested in this interrupt; we just log a debug message.
4706 */
4707 /*ARGSUSED*/
4708 static int
4713 {
4717 }
4719 /*
4720 * Interrupt which indicates that the X-bit has been set in SError
4721 * Diag field.
4722 *
4723 * We are not interested in this interrupt; we just log a debug message.
4724 */
4725 /*ARGSUSED*/
4726 static int
4731 {
4736 }
4738 /*
4739 * Interrupt which indicates that the 8b/10b Decode Error counter has
4740 * exceeded the programmed non-zero threshold value.
4741 *
4742 * We are not interested in this interrupt; we just log a debug message.
4743 */
4744 /*ARGSUSED*/
4745 static int
4750 {
4754 }
4756 /*
4757 * Interrupt which indicates that the CRC Error counter has exceeded the
4758 * programmed non-zero threshold value.
4759 *
4760 * We are not interested in this interrupt; we just log a debug message.
4761 */
4762 /*ARGSUSED*/
4763 static int
4768 {
4772 }
4774 /*
4775 * Interrupt which indicates that the Handshake Error counter has
4776 * exceeded the programmed non-zero threshold value.
4777 *
4778 * We are not interested in this interrupt; we just log a debug message.
4779 */
4780 /*ARGSUSED*/
4781 static int
4786 {
4790 }
4792 /*
4793 * Interrupt which indicates that a "Set Device Bits" FIS has been
4794 * received with N-bit set in the control field.
4795 *
4796 * We are not interested in this interrupt; we just log a debug message.
4797 */
4798 /*ARGSUSED*/
4799 static int
4804 {
4808 }
4811 /*
4812 * Enable the interrupts for a particular port.
4813 *
4814 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4815 * before calling us.
4816 */
4817 static void
4819 {
4823 /* get the current settings first. */
4829 mask);
4831 /* enable the bit for current port. */
4834 /* now use this mask to enable the interrupt. */
4837 mask);
4838 }
4840 /*
4841 * Enable interrupts for all the ports.
4842 */
4843 static void
4845 {
4850 }
4851 }
4853 /*
4854 * Disable interrupts for a particular port.
4855 *
4856 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
4857 * before calling us.
4858 */
4859 static void
4861 {
4864 /* get the current settings first. */
4868 /* clear the bit for current port. */
4871 /* now use this mask to disable the interrupt. */
4874 mask);
4876 }
4878 /*
4879 * Disable interrupts for all the ports.
4880 */
4881 static void
4883 {
4888 }
4889 }
4891 /*
4892 * Fetches the latest sstatus, scontrol, serror, sactive registers
4893 * and stuffs them into sata_device_t structure.
4894 */
4895 static void
4897 {
4908 }
4910 /*
4911 * si_add_legacy_intrs() handles INTx and legacy interrupts.
4912 */
4913 static int
4915 {
4922 /* get number of interrupts. */
4926 "ddi_intr_get_nintrs() failed, "
4929 }
4931 /* Allocate an array of interrupt handles. */
4935 /* call ddi_intr_alloc(). */
4944 }
4952 }
4956 }
4960 /* Get intr priority. */
4968 }
4972 }
4974 /* Test for high level mutex. */
4981 }
4986 }
4988 /* Call ddi_intr_add_handler(). */
4997 }
5002 }
5003 }
5005 /* Call ddi_intr_enable() for legacy interrupts. */
5008 }
5011 }
5013 /*
5014 * si_add_msictl_intrs() handles MSI interrupts.
5015 */
5016 static int
5018 {
5025 /* get number of interrupts. */
5029 "ddi_intr_get_nintrs() failed, "
5032 }
5034 /* get number of available interrupts. */
5038 "ddi_intr_get_navail() failed, "
5041 }
5047 }
5049 /* Allocate an array of interrupt handles. */
5053 /* call ddi_intr_alloc(). */
5062 }
5064 /* use interrupt count returned */
5068 }
5072 /*
5073 * Get priority for first msi, assume remaining are all the same.
5074 */
5079 /* Free already allocated intr. */
5082 }
5086 }
5088 /* Test for high level mutex. */
5093 /* Free already allocated intr. */
5096 }
5101 }
5103 /* Call ddi_intr_add_handler(). */
5110 /* Free already allocated intr. */
5113 }
5118 }
5119 }
5125 /* Call ddi_intr_block_enable() for MSI. */
5129 /* Call ddi_intr_enable() for MSI non block enable. */
5132 }
5133 }
5136 }
5138 /*
5139 * Removes the registered interrupts irrespective of whether they
5140 * were legacy or MSI.
5141 */
5142 static void
5144 {
5149 /* Disable all interrupts. */
5152 /* Call ddi_intr_block_disable(). */
5158 }
5159 }
5161 /* Call ddi_intr_remove_handler(). */
5165 }
5168 }
5170 /*
5171 * Resets either the port or the device connected to the port based on
5172 * the flag variable.
5173 *
5174 * The reset effectively throws away all the pending commands. So, the caller
5175 * has to make provision to handle the pending commands.
5176 *
5177 * After the reset, we wait till the port is ready again.
5178 *
5179 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
5180 * before calling us.
5181 *
5182 * Note: Not port-mult aware.
5183 */
5184 static int
5190 {
5193 sata_device_t sdevice;
5203 PORT_CONTROL_SET_BITS_PORT_RESET);
5205 /* Port reset is not self clearing. So clear it now. */
5208 PORT_CONTROL_CLEAR_BITS_PORT_RESET);
5210 /* Reset the device. */
5213 PORT_CONTROL_SET_BITS_DEV_RESET);
5215 /*
5216 * tidbit: this bit is self clearing; so there is no need
5217 * for manual clear as we did for port reset.
5218 */
5219 }
5221 /* Set the reset in progress flag */
5224 }
5227 /*
5228 * Every reset needs a PHY initialization.
5229 *
5230 * The way to initialize the PHY is to write a 1 and then
5231 * a 0 to DET field of SControl register.
5232 */
5234 /* Fetch the current SControl before writing the DET part with 1. */
5240 SControl);
5241 #ifndef __lock_lint
5245 /* Now fetch the SControl again and rewrite the DET part with 0 */
5251 SControl);
5253 /*
5254 * PHY may be initialized by now. Check the DET field of SStatus
5255 * to determine if there is a device present.
5256 *
5257 * The DET field is valid only if IPM field indicates that
5258 * the interface is in active state.
5259 */
5267 SSTATUS_IPM_INTERFACE_ACTIVE) {
5268 /*
5269 * If the interface is not active, the DET field
5270 * is considered not accurate. So we want to
5271 * continue looping.
5272 */
5274 }
5277 /* We are effectively timing out after 0.1 sec. */
5279 }
5281 /* Wait for 10 millisec */
5282 #ifndef __lock_lint
5289 "si_reset_dport_wait_till_ready: loop count: %d, \
5291 loop_count,
5292 SStatus);
5294 /* Now check for port readiness. */
5301 /* We are effectively timing out after 0.5 sec. */
5303 }
5305 /* Wait for 10 millisec */
5306 #ifndef __lock_lint
5313 "si_reset_dport_wait_till_ready: loop count: %d, \
5315 loop_count,
5316 port_status,
5317 SStatus);
5319 /* Indicate to the framework that a reset has happened. */
5331 }
5333 SATA_DSTATE_PWR_ACTIVE;
5338 SATA_EVNT_DEVICE_RESET);
5339 }
5343 }
5347 SSTATUS_DET_DEVPRESENT_PHYONLINE)) {
5348 /* The interface is active and the device is present */
5350 /* But the port is is not ready for some reason */
5354 }
5355 }
5358 /*
5359 * For some reason, we are losing the interrupt enablement after
5360 * any reset condition. So restore them back now.
5361 */
5371 INTR_COMMAND_ERROR |
5372 INTR_PORT_READY |
5373 INTR_POWER_CHANGE |
5374 INTR_PHYRDY_CHANGE |
5375 INTR_COMWAKE_RECEIVED |
5376 INTR_UNRECOG_FIS |
5377 INTR_DEV_XCHANGED |
5378 INTR_SETDEVBITS_NOTIFY));
5382 /*
5383 * make sure interrupts are cleared
5384 */
5390 port)),
5398 }
5400 /*
5401 * Schedule an initialization of the port using a timeout to get it done
5402 * off an interrupt thread.
5403 *
5404 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
5405 * before calling us.
5406 */
5407 static void
5412 {
5422 }
5428 }
5430 /*
5431 * Called from timeout()
5432 * Unpack the arguments and call si_initialize_port_wait_till_ready()
5433 */
5434 static void
5436 {
5452 }
5455 /*
5456 * Initializes the port.
5457 *
5458 * Initialization effectively throws away all the pending commands on
5459 * the port. So, the caller has to make provision to handle the pending
5460 * commands.
5461 *
5462 * After the port initialization, we wait till the port is ready again.
5463 *
5464 * WARNING, WARNING: The caller is expected to obtain the siport_mutex
5465 * before calling us.
5466 */
5467 static int
5469 {
5475 /* Initialize the port. */
5478 PORT_CONTROL_SET_BITS_PORT_INITIALIZE);
5480 /* Wait until Port Ready */
5488 "si_initialize_port_wait is timing out: "
5490 port_status);
5491 /* We are effectively timing out after 0.5 sec. */
5493 }
5495 /* Wait for 10 millisec */
5496 #ifndef __lock_lint
5504 loop_count);
5511 SSTATUS_DET_DEVPRESENT_PHYONLINE)) {
5512 /* The interface is active and the device is present */
5514 /* But the port is is not ready for some reason */
5516 }
5517 }
5520 }
5523 /*
5524 * si_watchdog_handler() calls us if it detects that there are some
5525 * commands which timed out. We recalculate the timed out commands once
5526 * again since some of them may have finished recently.
5527 */
5528 static void
5534 {
5547 /*
5548 * Initialize the controller. The only way to timeout the commands
5549 * is to reset or initialize the controller. We mop commands after
5550 * the initialization.
5551 */
5554 /*
5555 * Recompute the timedout tags since some of them may have finished
5556 * meanwhile.
5557 */
5564 finished_tags,
5565 timedout_tags);
5568 si_portp,
5569 port,
5570 slot_status,
5572 timedout_tags,
5577 }
5581 /*
5582 * Watchdog handler kicks in every 5 seconds to timeout any commands pending
5583 * for long time.
5584 */
5585 static void
5587 {
5595 /* max number of cycles this packet should survive */
5598 /* how many cycles this packet survived so far */
5610 }
5617 }
5619 /* Skip the check for those ports in error recovery */
5622 "si_watchdog_handler: port %d mopping "
5626 }
5634 }
5639 /*
5640 * We are overloading satapkt_hba_driver_private
5641 * with watched_cycle count.
5642 *
5643 * If a packet has survived for more than it's
5644 * max life cycles, it is a candidate for time
5645 * out.
5646 */
5649 watched_cycles++;
5652 si_watchdog_timeout;
5656 si_portp,
5658 timedout_tags);
5659 }
5662 }
5665 }
5673 }
5676 }
5678 /* Reinstall the watchdog timeout handler. */
5683 }
5685 }
5687 /*
5688 * FMA Functions
5689 */
5691 /*
5692 * The IO fault service error handling callback function
5693 */
5694 /*ARGSUSED*/
5695 static int
5697 {
5698 /*
5699 * as the driver can always deal with an error in any dma or
5700 * access handle, we can just return the fme_status value.
5701 */
5704 }
5706 /*
5707 * si_fm_init - initialize fma capabilities and register with IO
5708 * fault services.
5709 */
5710 static void
5712 {
5713 /*
5714 * Need to change iblock to priority for new MSI intr
5715 */
5716 ddi_iblock_cookie_t fm_ibc;
5718 /* Only register with IO Fault Services if we have some capability */
5720 /* Adjust access and dma attributes for FMA */
5725 /*
5726 * Register capabilities with IO Fault Services.
5727 * fm_capabilities will be updated to indicate
5728 * capabilities actually supported (not requested.)
5729 */
5736 /*
5737 * Initialize pci ereport capabilities if ereport
5738 * capable (should always be.)
5739 */
5743 }
5745 /*
5746 * Register error callback if error callback capable.
5747 */
5751 }
5752 }
5753 }
5755 /*
5756 * si_fm_fini - Releases fma capabilities and un-registers with IO
5757 * fault services.
5758 */
5759 static void
5761 {
5762 /* Only unregister FMA capabilities if registered */
5764 /*
5765 * Un-register error callback if error callback capable.
5766 */
5769 }
5771 /*
5772 * Release any resources allocated by pci_ereport_setup()
5773 */
5777 }
5779 /* Unregister from IO Fault Services */
5782 /* Adjust access and dma attributes for FMA */
5786 }
5787 }
5789 static int
5791 {
5792 ddi_fm_error_t de;
5797 }
5799 static int
5801 {
5802 ddi_fm_error_t de;
5807 }
5809 static int
5811 {
5819 }
5822 }
5824 /*
5825 * WARNING: The caller is expected to obtain the siport_mutex
5826 * before calling us.
5827 */
5828 static int
5830 {
5840 }
5843 }
5845 static void
5847 {
5856 DDI_NOSLEEP,
5859 NULL);
5860 }
5861 }
5863 /*
5864 * Logs the message.
5865 */
5866 static void
5868 {
5880 }
5887 }
5889 /*
5890 * si_portp is not NULL, but si_ctlp might be.
5891 * Reference si_portp for both port and dip.
5892 */
5901 }
5910 }
5912 static void
5915 {
5921 /*
5922 * The LRAM contains the the modified FIS after command completion, so
5923 * first copy it back to the in-core PRB pool. To save read cycles,
5924 * just copy over the FIS portion of the PRB pool.
5925 */
5935 }
5937 /*
5938 * always get the status register
5939 */
5950 }
5957 }
5964 }
5971 }
5979 }
5986 }
5993 }
6000 }
6007 }
6014 }
6015 }
6017 /*
6018 * This function clear the special port by send the PORT RESET
6019 * After reset was sent, all commands running on the port
6020 * is aborted
6021 */
6022 static int
6024 {
6028 /*
6029 * reset this port so that all existing command
6030 * is clear
6031 */
6034 PORT_CONTROL_SET_BITS_PORT_RESET);
6036 /* Port reset is not self clearing. So clear it now. */
6039 PORT_CONTROL_CLEAR_BITS_PORT_RESET);
6041 }
6043 /*
6044 * quiesce(9E) entry point.
6045 * This function is called when the system is single-threaded at high
6046 * PIL with preemption disabled. Therefore, this function must not be
6047 * blocked.
6048 *
6049 * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure.
6050 * DDI_FAILURE indicates an error condition and should almost never happen.
6051 */
6052 static int
6054 {
6065 /*
6066 * Disable all the interrupts before quiesce
6067 */
6072 }
6075 }