| blob | 10e71db3b9da9de09c96eda9b280358d55314bea |
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 * Copyright 2018 Nexenta Systems, Inc. All rights reserved.
25 */
27 /*
28 * AHCI (Advanced Host Controller Interface) SATA HBA Driver
29 *
30 * Power Management Support
31 * ------------------------
32 *
33 * At the moment, the ahci driver only implements suspend/resume to
34 * support Suspend to RAM on X86 feature. Device power management isn't
35 * implemented, link power management is disabled, and hot plug isn't
36 * allowed during the period from suspend to resume.
37 *
38 * For s/r support, the ahci driver only need to implement DDI_SUSPEND
39 * and DDI_RESUME entries, and don't need to take care of new requests
40 * sent down after suspend because the target driver (sd) has already
41 * handled these conditions, and blocked these requests. For the detailed
42 * information, please check with sdopen, sdclose and sdioctl routines.
43 *
44 */
46 #include <sys/note.h>
47 #include <sys/scsi/scsi.h>
48 #include <sys/pci.h>
49 #include <sys/disp.h>
50 #include <sys/sata/sata_hba.h>
51 #include <sys/sata/adapters/ahci/ahcireg.h>
52 #include <sys/sata/adapters/ahci/ahcivar.h>
54 /*
55 * FMA header files
56 */
57 #include <sys/ddifm.h>
58 #include <sys/fm/protocol.h>
59 #include <sys/fm/util.h>
60 #include <sys/fm/io/ddi.h>
62 /*
63 * This is the string displayed by modinfo, etc.
64 */
67 /*
68 * Function prototypes for driver entry points
69 */
75 /*
76 * Function prototypes for SATA Framework interfaces
77 */
87 #if defined(__lock_lint)
89 #endif
91 /*
92 * FMA Prototypes
93 */
105 /*
106 * Local function prototypes
107 */
134 sata_device_t *);
136 sata_pmult_gscr_t *);
138 sata_device_t *);
142 sata_device_t *);
147 ahci_addr_t *);
168 ahci_addr_t *);
170 ahci_addr_t *);
172 ahci_addr_t *);
220 #if AHCI_DEBUG
222 #endif
225 /*
226 * DMA attributes for the data buffer
227 *
228 * dma_attr_addr_hi will be changed to 0xffffffffull if the HBA
229 * does not support 64-bit addressing
230 */
244 };
246 /*
247 * DMA attributes for the rcvd FIS
248 *
249 * dma_attr_addr_hi will be changed to 0xffffffffull if the HBA
250 * does not support 64-bit addressing
251 */
265 };
267 /*
268 * DMA attributes for the command list
269 *
270 * dma_attr_addr_hi will be changed to 0xffffffffull if the HBA
271 * does not support 64-bit addressing
272 */
286 };
288 /*
289 * DMA attributes for cmd tables
290 *
291 * dma_attr_addr_hi will be changed to 0xffffffffull if the HBA
292 * does not support 64-bit addressing
293 */
307 };
310 /* Device access attributes */
312 DDI_DEVICE_ATTR_V1,
313 DDI_STRUCTURE_LE_ACC,
314 DDI_STRICTORDER_ACC,
315 DDI_DEFAULT_ACC
316 };
332 };
335 SATA_TRAN_HOTPLUG_OPS_REV_1,
336 ahci_tran_hotplug_port_activate,
337 ahci_tran_hotplug_port_deactivate
338 };
346 };
349 MODREV_1,
351 NULL
352 };
354 /* The following variables are watchdog handler related */
358 /*
359 * This static variable indicates the size of command table,
360 * and it's changeable with prdt number, which ahci_dma_prdt_number
361 * indicates.
362 */
365 /*
366 * The below global variables are tunable via /etc/system
367 *
368 * ahci_dma_prdt_number
369 * ahci_msi_enabled
370 * ahci_buf_64bit_dma
371 * ahci_commu_64bit_dma
372 */
374 /* The number of Physical Region Descriptor Table(PRDT) in Command Table */
377 /* AHCI MSI is tunable */
380 /*
381 * 64-bit dma addressing for data buffer is tunable
382 *
383 * The variable controls only the below value:
384 * DBAU (upper 32-bits physical address of data block)
385 */
388 /*
389 * 64-bit dma addressing for communication system descriptors is tunable
390 *
391 * The variable controls the below three values:
392 *
393 * PxCLBU (upper 32-bits for the command list base physical address)
394 * PxFBU (upper 32-bits for the received FIS base physical address)
395 * CTBAU (upper 32-bits of command table base)
396 */
399 /*
400 * By default, 64-bit dma for data buffer will be disabled for AMD/ATI SB600
401 * chipset. If the users want to have a try with 64-bit dma, please change
402 * the below variable value to enable it.
403 */
406 /*
407 * By default, 64-bit dma for command buffer will be disabled for AMD/ATI
408 * SB600/700/710/750/800. If the users want to have a try with 64-bit dma,
409 * please change the below value to enable it.
410 */
414 /*
415 * End of global tunable variable definition
416 */
418 #if AHCI_DEBUG
420 #else
422 #endif
425 #if AHCI_DEBUG
426 /* The following is needed for ahci_log() */
429 #endif
431 /* Opaque state pointer initialized by ddi_soft_state_init() */
434 /*
435 * ahci module initialization.
436 */
437 int
439 {
445 }
447 #if AHCI_DEBUG
449 #endif
452 #if AHCI_DEBUG
454 #endif
457 }
459 /* watchdog tick */
466 #if AHCI_DEBUG
468 #endif
471 }
475 err_out:
478 }
480 /*
481 * ahci module uninitialize.
482 */
483 int
485 {
491 }
493 /* Remove the resources allocated in _init(). */
495 #if AHCI_DEBUG
497 #endif
501 }
503 /*
504 * _info entry point
505 */
506 int
508 {
510 }
512 /*
513 * The attach entry point for dev_ops.
514 */
515 static int
517 {
529 #if AHCI_DEBUG
531 #endif
534 NULL);
542 /*
543 * During DDI_RESUME, the hardware state of the device
544 * (power may have been removed from the device) must be
545 * restored, allow pending requests to continue, and
546 * service new requests.
547 */
551 /*
552 * GHC.AE must be set to 1 before any other AHCI register
553 * is accessed
554 */
561 /* Restart watch thread */
569 /*
570 * Re-initialize the controller and enable the interrupts and
571 * restart all the ports.
572 *
573 * Note that so far we don't support hot-plug during
574 * suspend/resume.
575 */
578 "Failed to initialize the controller "
581 }
591 }
595 /* Allocate soft state */
599 instance);
601 }
607 /* Initialize the cport/port mapping */
611 }
615 /* Initialize FMA properties */
620 /*
621 * Now map the AHCI base address; which includes global
622 * registers and port control registers
623 *
624 * According to the spec, the AHCI Base Address is BAR5,
625 * but BAR0-BAR4 are optional, so we need to check which
626 * rnumber is used for BAR5.
627 */
629 /*
630 * search through DDI "reg" property for the AHCI register set
631 */
636 instance);
638 }
640 /* AHCI Base Address is located at 0x24 offset */
645 }
651 instance);
653 }
658 rnumber,
666 instance);
668 }
672 /*
673 * GHC.AE must be set to 1 before any other AHCI register
674 * is accessed
675 */
682 /* Get the AHCI version information */
691 /* We don't support controllers whose versions are lower than 1.0 */
696 }
698 /* Get the HBA capabilities information */
703 cap_status);
705 /* CAP2 (HBA Capabilities Extended) is available since AHCI spec 1.2 */
709 /* Get the HBA capabilities extended information */
715 }
717 #if AHCI_DEBUG
718 /* Get the interface speed supported by the HBA */
729 }
730 #endif
732 /* Get the number of command slots supported by the HBA */
740 /* Get the bit map which indicates ports implemented by the HBA */
748 /* Max port number implemented */
755 /* Get the number of implemented ports by the HBA */
764 /* Check whether HBA supports 64bit DMA addressing */
770 }
772 /* Checking for the support of Port Multiplier */
778 /* Support FIS-based switching ? */
783 }
784 }
786 /* Checking for Support Command List Override */
791 }
793 /* Checking for Asynchronous Notification */
798 }
803 instance);
805 }
809 /*
810 * Check the pci configuration space, and set caps. We also
811 * handle the hardware defect in this function.
812 *
813 * For example, force ATI SB600 to use 32-bit dma addressing
814 * since it doesn't support 64-bit dma though its CAP register
815 * declares it support.
816 */
819 instance);
821 }
823 /*
824 * Disable the whole controller interrupts before adding
825 * interrupt handlers(s).
826 */
829 /* Get supported interrupt types */
832 instance);
834 }
838 intr_types);
841 /*
842 * Try MSI first, but fall back to FIXED if failed
843 */
845 DDI_SUCCESS) {
850 }
853 "MSI registration failed, "
855 }
859 DDI_SUCCESS) {
864 }
868 }
874 intr_done:
878 /* Initialize the controller mutex */
888 }
895 "ahci_attach: ahci_dma_prdt_number set by user is 0x%x,"
901 ahci_dma_prdt_number;
908 /*
909 * enable 64bit dma for data buffer for SB600 if
910 * sb600_buf_64bit_dma_disable is B_FALSE
911 */
919 }
921 /*
922 * enable 64bit dma for command buffer for SB600/700/710/800
923 * if sbxxx_commu_64bit_dma_disable is B_FALSE
924 */
937 }
939 /* Allocate the ports structure */
943 instance);
945 }
949 /*
950 * Initialize the controller and ports.
951 */
955 instance);
957 }
961 /* Start one thread to check packet timeouts */
970 instance);
972 }
974 /* Check all handles at the end of the attach operation. */
977 instance);
979 }
987 err_out:
988 /* FMA message */
997 }
1001 }
1005 }
1009 }
1013 }
1017 }
1021 }
1025 }
1029 }
1032 }
1034 /*
1035 * The detach entry point for dev_ops.
1036 */
1037 static int
1039 {
1052 /* disable the interrupts for an uninterrupted detach */
1057 /* unregister from the sata framework. */
1064 }
1068 /* stop the watchdog handler */
1074 /* uninitialize the controller */
1077 /* remove the interrupts */
1080 /* deallocate the ports structures */
1083 /* destroy mutex */
1086 /* teardown the pci config */
1089 /* remove the reg maps. */
1092 /* release fma resource */
1095 /* free the soft state. */
1102 /*
1103 * The steps associated with suspension must include putting
1104 * the underlying device into a quiescent state so that it
1105 * will not generate interrupts or modify or access memory.
1106 */
1111 }
1115 /* stop the watchdog handler */
1119 }
1123 /*
1124 * drain the taskq
1125 */
1128 /*
1129 * Disable the interrupts and stop all the ports.
1130 */
1137 }
1138 }
1140 /*
1141 * The info entry point for dev_ops.
1142 *
1143 */
1144 static int
1147 {
1148 #ifndef __lock_lint
1154 dev_t dev;
1168 }
1174 }
1177 }
1179 /*
1180 * Registers the ahci with sata framework.
1181 */
1182 static int
1184 {
1192 /* Allocate memory for the sata_hba_tran */
1200 /* Report the number of implemented ports */
1204 /* Support ATAPI device */
1207 /* Get the data transfer capability for PIO command by the HBA */
1212 }
1214 /*
1215 * According to the AHCI spec, the ATA/ATAPI-7 queued feature set
1216 * is not supported by AHCI (including the READ QUEUED (EXT), WRITE
1217 * QUEUED (EXT), and SERVICE commands). Queued operations are
1218 * supported in AHCI using the READ FPDMA QUEUED and WRITE FPDMA
1219 * QUEUED commands when the HBA and device support native command
1220 * queuing(NCQ).
1221 *
1222 * SATA_CTLF_NCQ will be set to sata_tran_hba_features_support if the
1223 * CAP register of the HBA indicates NCQ is supported.
1224 *
1225 * SATA_CTLF_NCQ cannot be set if AHCI_CAP_NO_MCMDLIST_NONQUEUE is
1226 * set because the previous register content of PxCI can be re-written
1227 * in the register write.
1228 */
1235 }
1237 /* Support port multiplier? */
1240 SATA_CTLF_PORT_MULTIPLIER;
1242 /* Support FIS-based switching for port multiplier? */
1245 SATA_CTLF_PMULT_FBS;
1246 }
1247 }
1249 /* Report the number of command slots */
1257 #ifdef __lock_lint
1259 #endif
1260 /*
1261 * When SATA framework adds support for pwrmgt the
1262 * pwrmgt_ops needs to be updated
1263 */
1271 /* Attach it to SATA framework */
1279 }
1282 }
1284 /*
1285 * Unregisters the ahci with sata framework.
1286 */
1287 static int
1289 {
1293 /* Detach from the SATA framework. */
1295 DDI_SUCCESS) {
1297 }
1299 /* Deallocate sata_hba_tran. */
1308 }
1310 #define SET_PORTSTR(str, addrp) \
1311 if (AHCI_ADDR_IS_PORT(addrp)) \
1313 else if (AHCI_ADDR_IS_PMULT(addrp)) \
1315 else \
1317 (addrp)->aa_pmport);
1319 /*
1320 * ahci_tran_probe_port is called by SATA framework. It returns port state,
1321 * port status registers and an attached device type via sata_device
1322 * structure.
1323 *
1324 * We return the cached information from a previous hardware probe. The
1325 * actual hardware probing itself was done either from within
1326 * ahci_initialize_controller() during the driver attach or from a phy
1327 * ready change interrupt handler.
1328 */
1329 static int
1331 {
1359 /* port mutliplier is removed. */
1361 "ahci_tran_probe_port: "
1365 }
1367 /*
1368 * The sata_device may refer to
1369 * 1. A controller port.
1370 * A controller port should be ready here.
1371 * 2. A port multiplier.
1372 * SATA_ADDR_PMULT_SPEC - if it is not initialized yet, initialize
1373 * it and register the port multiplier to the framework.
1374 * SATA_ADDR_PMULT - check the status of all its device ports.
1375 * 3. A port multiplier port.
1376 * If it has not been initialized, initialized it.
1377 *
1378 * A port multiplier or a port multiplier port may require some
1379 * initialization because we cannot do these time-consuming jobs in an
1380 * interrupt context.
1381 */
1384 /* Initialize registers on a port multiplier */
1389 "ahci_tran_probe_port: "
1393 }
1395 /* Check pmports hotplug events */
1398 SATA_ADDR_DPMPORT)) {
1403 }
1404 }
1406 /* Update port state and device type */
1441 }
1454 /*
1455 * HBA driver only knows it's an ATAPI device, and don't know
1456 * it's CD/DVD, tape or ATAPI disk because the ATAPI device
1457 * type need to be determined by checking IDENTIFY PACKET
1458 * DEVICE data
1459 */
1469 /* Update the number of pmports. */
1476 portstr);
1483 portstr);
1487 /* we don't support any other device types */
1492 }
1494 out:
1495 /* Register update only fails while probing a pmult/pmport */
1503 }
1505 /* Check handles for the sata registers access */
1509 DDI_SERVICE_UNAFFECTED);
1511 }
1515 }
1517 /*
1518 * There are four operation modes in sata framework:
1519 * SATA_OPMODE_INTERRUPTS
1520 * SATA_OPMODE_POLLING
1521 * SATA_OPMODE_ASYNCH
1522 * SATA_OPMODE_SYNCH
1523 *
1524 * Their combined meanings as following:
1525 *
1526 * SATA_OPMODE_SYNCH
1527 * The command has to be completed before sata_tran_start functions returns.
1528 * Either interrupts or polling could be used - it's up to the driver.
1529 * Mode used currently for internal, sata-module initiated operations.
1530 *
1531 * SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS
1532 * It is the same as the one above.
1533 *
1534 * SATA_OPMODE_SYNCH | SATA_OPMODE_POLLING
1535 * The command has to be completed before sata_tran_start function returns.
1536 * No interrupt used, polling only. This should be the mode used for scsi
1537 * packets with FLAG_NOINTR.
1538 *
1539 * SATA_OPMODE_ASYNCH | SATA_OPMODE_INTERRUPTS
1540 * The command may be queued (callback function specified). Interrupts could
1541 * be used. It's normal operation mode.
1542 */
1543 /*
1544 * Called by sata framework to transport a sata packet down stream.
1545 */
1546 static int
1548 {
1551 ahci_addr_t addr;
1569 /* Sanity check */
1580 "ahci_tran_start returning PORT_ERROR while "
1584 }
1587 SATA_STATE_READY)) {
1599 "ahci_tran_start returning PORT_ERROR "
1600 "while sub-link is not initialized "
1604 }
1605 }
1606 }
1611 /*
1612 * In case the target driver would send the packet before
1613 * sata framework can have the opportunity to process those
1614 * event reports.
1615 */
1622 "ahci_tran_start returning PORT_ERROR while "
1623 "port in FAILED/SHUTDOWN/PWROFF state: "
1627 }
1630 /*
1631 * ahci_intr_phyrdy_change() may have rendered it to
1632 * SATA_DTYPE_NONE.
1633 */
1641 "ahci_tran_start returning PORT_ERROR while "
1645 }
1647 /* R/W PMULT command will occupy the whole HBA port */
1650 "ahci_tran_start returning BUSY while "
1651 "executing READ/WRITE PORT-MULT command: "
1656 }
1660 "ahci_tran_start returning BUSY while "
1665 }
1667 /*
1668 * SATA HBA driver should remember that a device was reset and it
1669 * is supposed to reject any packets which do not specify either
1670 * SATA_IGNORE_DEV_RESET_STATE or SATA_CLEAR_DEV_RESET_STATE.
1671 *
1672 * This is to prevent a race condition when a device was arbitrarily
1673 * reset by the HBA driver (and lost it's setting) and a target
1674 * driver sending some commands to a device before the sata framework
1675 * has a chance to restore the device setting (such as cache enable/
1676 * disable or other resettable stuff).
1677 */
1678 /*
1679 * It is unnecessary to use specific flags to indicate
1680 * reset_in_progress for a pmport. While mopping, all command will be
1681 * mopped so that the entire HBA port is being dealt as a single
1682 * object.
1683 */
1687 "ahci_tran_start [CLEAR] the "
1689 }
1696 "ahci_tran_start returning BUSY while "
1700 }
1702 #ifdef AHCI_DEBUG
1707 }
1708 #endif
1713 "ahci_tran_start returning BUSY while "
1717 }
1721 DDI_SERVICE_UNAFFECTED);
1724 }
1728 /*
1729 * If a SYNC command to be executed in interrupt context,
1730 * bounce it back to sata module.
1731 */
1736 "ahci_tran_start returning BUSY while "
1737 "sending SYNC mode under interrupt context: "
1741 }
1743 /* We need to do the sync start now */
1747 }
1749 /* Async start, using interrupt */
1754 }
1755 }
1763 fail_out:
1764 /*
1765 * Failed to deliver packet to the controller.
1766 * Check if it's caused by invalid handles.
1767 */
1777 }
1783 }
1785 /*
1786 * SATA_OPMODE_SYNCH flag is set
1787 *
1788 * If SATA_OPMODE_POLLING flag is set, then we must poll the command
1789 * without interrupt, otherwise we can still use the interrupt.
1790 */
1791 static int
1794 {
1812 }
1814 pkt_timeout_ticks =
1818 /* Simulate the interrupt */
1840 }
1841 }
1851 #if AHCI_DEBUG
1852 /*
1853 * Note that the driver always uses the slot 0 to deliver
1854 * REQUEST SENSE or READ LOG EXT command
1855 */
1858 #endif
1865 }
1866 }
1868 /*
1869 * Searches for and claims a free command slot.
1870 *
1871 * Returns value:
1872 *
1873 * AHCI_FAILURE returned only if
1874 * 1. No empty slot left
1875 * 2. Non-queued command requested while queued command(s) is outstanding
1876 * 3. Queued command requested while non-queued command(s) is outstanding
1877 * 4. HBA doesn't support multiple-use of command list while already a
1878 * non-queued command is oustanding
1879 * 5. Queued command requested while some queued command(s) has been
1880 * outstanding on a different port multiplier port. (AHCI spec 1.2,
1881 * 9.1.2)
1882 *
1883 * claimed slot number returned if succeeded
1884 *
1885 * NOTE: it will always return slot 0 for following commands to simplify the
1886 * algorithm.
1887 * 1. REQUEST SENSE or READ LOG EXT command during error recovery process
1888 * 2. READ/WRITE PORTMULT command
1889 */
1890 static int
1893 {
1901 "ahciport_pending_tags = 0x%x "
1906 /*
1907 * According to the AHCI spec, system software is responsible to
1908 * ensure that queued and non-queued commands are not mixed in
1909 * the command list.
1910 */
1912 /* Non-NCQ command request */
1915 "ahci_claim_free_slot: there is still pending "
1916 "queued command(s) in the command list, "
1917 "so no available slot for the non-queued "
1920 }
1923 "ahci_claim_free_slot: there is still pending "
1924 "read/write port-mult command(s) in command list, "
1926 NULL);
1928 }
1932 "ahci_claim_free_slot: HBA cannot support multiple-"
1934 NULL);
1936 }
1940 /* NCQ command request */
1943 "ahci_claim_free_slot: there is still pending "
1944 "non-queued command(s) in the command list, "
1946 NULL);
1948 }
1950 /*
1951 * NCQ commands cannot be sent to different port multiplier
1952 * ports in Command-Based Switching mode
1953 */
1954 /*
1955 * NOTE: In Command-Based Switching mode, AHCI controller
1956 * usually reports a 'Handshake Error' when multiple NCQ
1957 * commands are outstanding simultaneously.
1958 */
1966 "ahci_claim_free_slot: there is still "
1967 "pending queued command(s) in the "
1968 "command list for another Port Multiplier "
1971 }
1972 }
1977 /* Error retrieval command request */
1979 "ahci_claim_free_slot: slot 0 is allocated for REQUEST "
1984 /*
1985 * An extra check on PxCI. Sometimes PxCI bits may not be
1986 * cleared during hot-plug or error recovery process.
1987 */
1993 "ahci_claim_free_slot: there is still pending "
1994 "command(s) in command list (0x%x/0x%x, PxCI %x),"
1998 port_cmd_issue);
2000 }
2003 "ahci_claim_free_slot: slot 0 is allocated for "
2007 }
2014 }
2016 /*
2017 * According to the AHCI spec, to allow a simple mechanism for the
2018 * HBA to map command list slots to queue entries, software must
2019 * match the tag number it uses to the slot it is placing the command
2020 * in. For example, if a queued command is placed in slot 5, the tag
2021 * for that command must be 5.
2022 */
2028 }
2029 }
2033 out:
2038 }
2040 /*
2041 * Builds the Command Table for the sata packet and delivers it to controller.
2042 *
2043 * Returns:
2044 * slot number if we can obtain a slot successfully
2045 * otherwise, return AHCI_FAILURE
2046 */
2047 static int
2050 {
2062 #if AHCI_DEBUG
2065 #endif
2076 /* Check if the command is a NCQ command */
2081 /*
2082 * When NCQ is support, system software must determine the
2083 * maximum tag allowed by the device and the HBA, and it
2084 * must use a value not beyond of the lower bound of the two.
2085 *
2086 * Sata module is going to calculate the qdepth and send
2087 * down to HBA driver via sata_cmd.
2088 */
2091 /*
2092 * At the moment, the driver doesn't support the dynamic
2093 * setting of the maximum ncq depth, and the value can be
2094 * set either during the attach or after hot-plug insertion.
2095 */
2099 "ahci_deliver_satapkt: port %d the max tags for "
2104 " port %d the max tag for NCQ command is "
2105 "requested to change from %d to %d, at the"
2106 " moment the driver doesn't support the "
2107 "dynamic change so it's going to "
2111 ncq_qdepth);
2112 }
2113 }
2114 }
2116 /* Check if the command is an error retrieval command */
2120 /* Check if the command is an read/write pmult command */
2124 /* Check if there is an empty command slot */
2130 }
2133 "ahci_deliver_satapkt enter: cmd_reg: 0x%x, cmd_slot: 0x%x, "
2140 /* For data transfer operations, it is the H2D Register FIS */
2141 h2d_register_fisp =
2146 /*
2147 * PMP field only make sense when target is a port multiplier or a
2148 * device behind a port multiplier. Otherwise should set it to 0.
2149 */
2161 /*
2162 * satacmd_addr_type will be 0 for the commands below:
2163 * ATAPI command
2164 * SATAC_IDLE_IM
2165 * SATAC_STANDBY_IM
2166 * SATAC_DOWNLOAD_MICROCODE
2167 * SATAC_FLUSH_CACHE
2168 * SATAC_SET_FEATURES
2169 * SATAC_SMART
2170 * SATAC_ID_PACKET_DEVICE
2171 * SATAC_ID_DEVICE
2172 * SATAC_READ_PORTMULT
2173 * SATAC_WRITE_PORTMULT
2174 */
2175 /* FALLTHRU */
2178 /* FALLTHRU */
2181 /* LBA[7:0] */
2184 /* LBA[15:8] */
2187 /* LBA[23:16] */
2190 /* LBA [27:24] (also called dev_head) */
2196 /* LBA[7:0] */
2199 /* LBA[15:8] */
2202 /* LBA[23:16] */
2205 /* LBA [31:24] */
2209 /* LBA [39:32] */
2213 /* LBA [47:40] */
2217 /* Set dev_head */
2221 /* Set the extended sector count and features */
2227 }
2229 /*
2230 * For NCQ command (READ/WRITE FPDMA QUEUED), sector count 7:0 is
2231 * filled into features field, and sector count 8:15 is filled into
2232 * features (exp) field. The hba driver doesn't need to anything
2233 * special with regard to this, since sata framework has already
2234 * done so.
2235 *
2236 * However the driver needs to make sure TAG is filled into sector
2237 * field.
2238 */
2242 }
2252 /* *** now fill the scatter gather list ******* */
2262 }
2268 /* The ACMD field is filled in for ATAPI command */
2271 SATA_ATAPI_MAX_CDB_LEN);
2272 }
2274 /* Set Command Header in Command List */
2279 /* Set the number of entries in the PRD table */
2282 /* Set the length of the command in the CFIS area */
2285 /*
2286 * PMP field only make sense when target is a port multiplier or a
2287 * device behind a port multiplier. Otherwise should set it to 0.
2288 */
2296 /* Set A bit if it is an ATAPI command */
2300 /* Set W bit if data is going to the device */
2304 /*
2305 * Set the prefetchable bit - this bit is only valid if the PRDTL
2306 * field is non-zero or the ATAPI 'A' bit is set in the command
2307 * header. This bit cannot be set when using native command
2308 * queuing commands or when using FIS-based switching with a Port
2309 * multiplier.
2310 */
2314 /*
2315 * Now remember the sata packet in ahciport_slot_pkts[].
2316 * Error retrieval command and r/w port multiplier command will
2317 * be stored specifically for each port.
2318 */
2323 /*
2324 * Keep the timeout value
2325 */
2328 /*
2329 * If the intial timout is less than 1 tick, then make it longer by
2330 * 1 tick to avoid immediate timeout
2331 */
2333 ahci_watchdog_timeout)
2335 ahci_watchdog_timeout;
2337 #if AHCI_DEBUG
2343 /* Dump the command header and table */
2353 /* Dump the H2D register FIS */
2359 /* Dump the ACMD register FIS */
2364 " ATAPI command: %2x %2x %2x %2x "
2371 /* Dump the PRDT */
2377 }
2378 }
2379 #endif
2384 ahci_cmd_table_size,
2385 DDI_DMA_SYNC_FORDEV);
2390 DDI_DMA_SYNC_FORDEV);
2397 DDI_SERVICE_UNAFFECTED);
2399 }
2401 /* Set the corresponding bit in the PxSACT.DS for queued command */
2406 }
2408 /* Indicate to the HBA that a command is active. */
2416 /* Make sure the command is started by the PxSACT/PxCI */
2420 DDI_SERVICE_UNAFFECTED);
2422 }
2425 }
2427 /*
2428 * Called by the sata framework to abort the previously sent packet(s).
2429 *
2430 * Reset device to abort commands.
2431 */
2432 static int
2434 {
2454 /*
2455 * If AHCI_PORT_FLAG_MOPPING flag is set, it means all the pending
2456 * commands are being mopped, therefore there is nothing else to do
2457 */
2460 "ahci_tran_abort: port %d is in "
2464 }
2466 /*
2467 * If AHCI_PORT_FLAG_RDWR_PMULT flag is set, it means a R/W PMULT
2468 * command is being executed so no other commands is outstanding,
2469 * nothing to do.
2470 */
2473 "ahci_tran_abort: port %d is reading/writing "
2477 }
2482 /*
2483 * In case the targer driver would send the request before
2484 * sata framework can have the opportunity to process those
2485 * event reports.
2486 */
2493 "ahci_tran_abort returning SATA_FAILURE while "
2494 "port in FAILED/SHUTDOWN/PWROFF state: "
2498 }
2501 /*
2502 * ahci_intr_phyrdy_change() may have rendered it to
2503 * AHCI_PORT_TYPE_NODEV.
2504 */
2512 "ahci_tran_abort returning SATA_FAILURE while "
2516 }
2528 /*
2529 * Aborting one specific packet, first search the
2530 * ahciport_slot_pkts[] list for matching spkt.
2531 */
2537 }
2538 }
2541 /* request packet is not on the pending list */
2543 "Cannot find the aborting pkt 0x%p on the "
2549 }
2552 }
2564 /*
2565 * To abort the packet(s), first we are trying to clear PxCMD.ST
2566 * to stop the port, and if the port can be stopped
2567 * successfully with PxTFD.STS.BSY and PxTFD.STS.DRQ cleared to '0',
2568 * then we just send back the aborted packet(s) with ABORTED flag
2569 * and then restart the port by setting PxCMD.ST and PxCMD.FRE.
2570 * If PxTFD.STS.BSY or PxTFD.STS.DRQ is set to '1', then we
2571 * perform a COMRESET.
2572 */
2576 /*
2577 * Compute which have finished and which need to be retried.
2578 *
2579 * The finished tags are ahciport_pending_tags/ahciport_pending_ncq_tags
2580 * minus the slot_status. The aborted_tags has to be deducted by
2581 * finished_tags since we can't possibly abort a tag which had finished
2582 * already.
2583 */
2594 ahci_portp,
2595 slot_status,
2598 aborted_tags,
2605 }
2607 /*
2608 * Used to do device reset and reject all the pending packets on a device
2609 * during the reset operation.
2610 *
2611 * NOTE: ONLY called by ahci_tran_reset_dport
2612 */
2613 static int
2616 {
2621 sata_device_t sdevice;
2629 /*
2630 * If AHCI_PORT_FLAG_MOPPING flag is set, it means all the pending
2631 * commands are being mopped, therefore there is nothing else to do
2632 */
2635 "ahci_reset_device_reject_pkts: port %d is in "
2638 }
2648 }
2653 "Try to do a port reset after software "
2658 "ahci_reset_device_reject_pkts: port %d "
2661 }
2662 }
2663 /* Set the reset in progress flag */
2669 /* Indicate to the framework that a reset has happened */
2675 SATA_DSTATE_PWR_ACTIVE;
2680 SATA_EVNT_DEVICE_RESET);
2686 /* Next try to mop the pending commands */
2697 ahci_portp,
2698 slot_status,
2705 }
2707 /*
2708 * Used to do device reset and reject all the pending packets on a device
2709 * during the reset operation.
2710 *
2711 * NOTE: ONLY called by ahci_tran_reset_dport
2712 */
2713 static int
2716 {
2720 sata_device_t sdevice;
2729 "ahci_reset_pmdevice_reject_pkts: port %d is in "
2732 }
2734 /* Checking for outstanding commands */
2743 }
2745 /* Issue SOFTWARE reset command. */
2749 "Try to do a port reset after software "
2752 }
2754 /* Set the reset in progress flag */
2760 /* Indicate to the framework that a reset has happened */
2766 else
2769 SATA_DSTATE_PWR_ACTIVE;
2774 SATA_EVNT_DEVICE_RESET);
2781 /* Next try to mop the pending commands */
2794 /*
2795 * NOTE: Because PxCI be only erased by unset PxCMD.ST bit, so even we
2796 * try to reset a single device behind a port multiplier will
2797 * terminate all the commands on that HBA port. We need mop these
2798 * commands as well.
2799 */
2801 ahci_portp,
2802 slot_status,
2809 }
2811 /*
2812 * Used to do port reset and reject all the pending packets on a port during
2813 * the reset operation.
2814 */
2815 static int
2818 {
2829 /*
2830 * If AHCI_PORT_FLAG_MOPPING flag is set, it means all the pending
2831 * commands are being mopped, therefore there is nothing else to do
2832 */
2835 "ahci_reset_port_reject_pkts: port %d is in "
2838 }
2851 }
2857 /* Clear mop flag */
2863 }
2875 ahci_portp,
2876 slot_status,
2883 }
2885 /*
2886 * Used to do hba reset and reject all the pending packets on all ports
2887 * during the reset operation.
2888 */
2889 static int
2891 {
2909 }
2935 }
2937 }
2941 }
2946 }
2951 /*
2952 * To prevent recursive enter to ahci_mop_commands, we need
2953 * check AHCI_PORT_FLAG_MOPPING flag.
2954 */
2957 "ahci_reset_hba_reject_pkts: port %d is in "
2961 }
2978 ahci_portp,
2985 }
2986 out:
2988 }
2990 /*
2991 * Called by sata framework to reset a port(s) or device.
2992 */
2993 static int
2995 {
2998 ahci_addr_t addr;
3016 /*
3017 * If we want to issue a COMRESET on a pmport, we need to
3018 * reject the outstanding commands on that pmport. According
3019 * to AHCI spec, PxCI register could only be cleared by
3020 * clearing PxCMD.ST, which will halt the controller port - as
3021 * well as other pmports.
3022 *
3023 * Therefore we directly reset the controller port for
3024 * simplicity. ahci_tran_probe_port() will handle reset stuff
3025 * like initializing the given pmport.
3026 */
3027 /* FALLTHRU */
3029 /* Port reset */
3043 /* FALLTHRU */
3045 /* Device reset */
3051 /*
3052 * software reset request must be sent to SATA_PMULT_HOSTPORT
3053 * if target is a port multiplier:
3054 */
3062 /*
3063 * In case the targer driver would send the request
3064 * before sata framework can have the opportunity to
3065 * process those event reports.
3066 */
3070 "ahci_tran_reset_dport returning SATA_FAILURE "
3071 "while port in FAILED/SHUTDOWN/PWROFF state: "
3076 }
3079 SATA_DTYPE_NONE) {
3080 /*
3081 * ahci_intr_phyrdy_change() may have rendered it to
3082 * AHCI_PORT_TYPE_NODEV.
3083 */
3089 "ahci_tran_reset_dport returning SATA_FAILURE "
3094 }
3102 }
3108 /* Reset the whole controller */
3116 }
3119 }
3121 /*
3122 * Called by sata framework to activate a port as part of hotplug.
3123 * (cfgadm -c connect satax/y)
3124 * Support port multiplier.
3125 */
3126 static int
3128 {
3131 ahci_addr_t addr;
3153 /* Enable the interrupts on the port */
3156 /*
3157 * Reset the port so that the PHY communication would be
3158 * re-established. But this reset is an internal operation
3159 * and the sata module doesn't need to know about it.
3160 * Moreover, the port with a device attached will be started
3161 * too.
3162 */
3166 NULL);
3168 /*
3169 * Need to check the link status and device status of the port
3170 * and consider raising power if the port was in D3 state
3171 */
3178 /* AHCI_ADDR_PMPORT */
3182 }
3190 }
3192 /*
3193 * Called by sata framework to deactivate a port as part of hotplug.
3194 * (cfgadm -c disconnect satax/y)
3195 * Support port multiplier.
3196 */
3197 static int
3199 {
3202 ahci_addr_t addr;
3224 /* Disable the interrupts on the port */
3229 /* First to abort all the pending commands */
3232 /* Then stop the port */
3235 }
3237 /* Next put the PHY offline */
3252 /* Re-enable the interrupts for the other pmports */
3254 }
3256 /* Update port state */
3264 }
3266 /*
3267 * To be used to mark all the outstanding pkts with SATA_PKT_ABORTED
3268 * when a device is unplugged or a port is deactivated.
3269 */
3270 static void
3273 {
3282 /* Read/write port multiplier command takes highest priority */
3287 }
3289 /*
3290 * When AHCI_PORT_FLAG_MOPPING is set, we need to check whether a
3291 * REQUEST SENSE command or READ LOG EXT command is delivered to HBA
3292 * to get the error data, if yes when the device is removed, the
3293 * command needs to be aborted too.
3294 */
3302 "ahci_reject_all_abort_pkts return directly "
3303 "port %d no needs to reject any outstanding "
3306 }
3307 }
3317 }
3319 out:
3320 /* No need to do mop when there is no outstanding commands */
3326 ahci_portp,
3327 slot_status,
3332 }
3333 }
3335 #if defined(__lock_lint)
3336 static int
3338 {
3340 }
3341 #endif
3343 /*
3344 * Initialize fma capabilities and register with IO fault services.
3345 */
3346 static void
3348 {
3349 /*
3350 * Need to change iblock to priority for new MSI intr
3351 */
3352 ddi_iblock_cookie_t fm_ibc;
3360 /* Only register with IO Fault Services if we have some capability */
3362 /* Adjust access and dma attributes for FMA */
3369 /*
3370 * Register capabilities with IO Fault Services.
3371 * ahcictl_fm_cap will be updated to indicate
3372 * capabilities actually supported (not requested.)
3373 */
3381 }
3382 /*
3383 * Initialize pci ereport capabilities if ereport
3384 * capable (should always be.)
3385 */
3389 }
3391 /*
3392 * Register error callback if error callback capable.
3393 */
3397 }
3401 }
3402 }
3404 /*
3405 * Releases fma capabilities and un-registers with IO fault services.
3406 */
3407 static void
3409 {
3410 /* Only unregister FMA capabilities if registered */
3412 /*
3413 * Un-register error callback if error callback capable.
3414 */
3417 }
3419 /*
3420 * Release any resources allocated by pci_ereport_setup()
3421 */
3425 }
3427 /* Unregister from IO Fault Services */
3430 /* Adjust access and dma attributes for FMA */
3439 }
3440 }
3442 /*ARGSUSED*/
3443 static int
3445 {
3446 /*
3447 * as the driver can always deal with an error in any dma or
3448 * access handle, we can just return the fme_status value.
3449 */
3452 }
3454 int
3456 {
3457 ddi_fm_error_t de;
3461 }
3463 int
3465 {
3466 ddi_fm_error_t de;
3470 }
3472 /*
3473 * Generate an ereport
3474 */
3475 void
3477 {
3487 }
3488 }
3490 /*
3491 * Check if all handles are correctly allocated.
3492 */
3493 static int
3495 {
3500 }
3514 }
3516 }
3519 }
3521 /*
3522 * Check the access handles for the controller. Note that
3523 * ahcictl_pci_conf_handle is only used in attach process.
3524 */
3525 static int
3527 {
3533 }
3535 }
3537 /*
3538 * Check the DMA handles and the access handles of a controller port.
3539 */
3540 static int
3542 {
3557 }
3562 }
3563 }
3565 }
3567 /*
3568 * Check the DMA handles and the access handles of a cmd table slot.
3569 */
3570 static int
3572 {
3580 }
3582 }
3584 /*
3585 * Allocate the ports structure, only called by ahci_attach
3586 */
3587 static int
3589 {
3597 /* Allocate structures only for the implemented ports */
3603 }
3611 }
3612 }
3617 err_out:
3621 }
3622 }
3626 }
3628 /*
3629 * Reverse of ahci_alloc_ports_state(), only called by ahci_detach
3630 */
3631 static void
3633 {
3638 /* if this port is implemented by the HBA */
3641 }
3643 }
3645 /*
3646 * Drain the taskq.
3647 */
3648 static void
3650 {
3657 }
3664 }
3665 }
3667 /*
3668 * Initialize the controller and all ports. And then try to start the ports
3669 * if there are devices attached.
3670 *
3671 * This routine can be called from three seperate cases: DDI_ATTACH,
3672 * PM_LEVEL_D0 and DDI_RESUME. The DDI_ATTACH case is different from
3673 * other two cases; device signature probing are attempted only during
3674 * DDI_ATTACH case.
3675 */
3676 static int
3678 {
3680 ahci_addr_t addr;
3686 /* Disable the whole controller interrupts */
3691 /* Initialize the implemented ports and structures */
3695 }
3700 /*
3701 * Ensure that the controller is not in the running state
3702 * by checking every implemented port's PxCMD register
3703 */
3709 "ahci_initialize_controller: failed to "
3711 /*
3712 * Set the port state to SATA_PSTATE_FAILED if
3713 * failed to initialize it.
3714 */
3716 }
3719 }
3721 /* Enable the whole controller interrupts */
3727 }
3729 /*
3730 * Reverse of ahci_initialize_controller()
3731 *
3732 * We only need to stop the ports and disable the interrupt.
3733 */
3734 static void
3736 {
3743 /* disable all the interrupts. */
3751 }
3755 /* Stop the port by clearing PxCMD.ST */
3758 /*
3759 * Here we must disable the port interrupt because
3760 * ahci_disable_all_intrs only clear GHC.IE, and IS
3761 * register will be still set if PxIE is enabled.
3762 * When ahci shares one IRQ with other drivers, the
3763 * intr handler may claim the intr mistakenly.
3764 */
3769 }
3770 }
3772 /*
3773 * ahci_alloc_pmult()
3774 * 1. Setting HBA port registers which are necessary for a port multiplier.
3775 * (Set PxCMD.PMA while PxCMD.ST is '0')
3776 * 2. Allocate ahci_pmult_info structure.
3777 *
3778 * NOTE: Must stop port before the function is called.
3779 */
3780 static void
3782 {
3791 /* The port must have been stopped before. */
3795 /* set PMA bit */
3801 "ahci_alloc_pmult: "
3803 }
3805 /* Allocate port multiplier information structure */
3809 }
3812 }
3814 /*
3815 * ahci_dealloc_pmult()
3816 * 1. Clearing related registers when a port multiplier is detached.
3817 * (Clear PxCMD.PMA while PxCMD.ST is '0')
3818 * 2. Deallocate ahci_pmult_info structure.
3819 *
3820 * NOTE: Must stop port before the function is called.
3821 */
3822 static void
3824 {
3834 /* Clear PMA bit */
3840 "ahci_dealloc_pmult: "
3842 }
3844 /* Release port multiplier information structure */
3849 }
3850 }
3852 /*
3853 * Staggered Spin-up.
3854 */
3855 static void
3857 {
3866 /* Check for staggered spin-up support */
3873 /* If PxCMD.SUD == 1, no staggered spin-up is needed */
3879 /* Set PxCMD.SUD */
3883 port_cmd_status);
3884 }
3886 /*
3887 * The routine is to initialize a port. First put the port in NotRunning
3888 * state, then enable port interrupt and clear Serror register. And under
3889 * AHCI_ATTACH case, find device signature and then try to start the port.
3890 *
3891 * Called by
3892 * 1. ahci_initialize_controller
3893 * 2. ahci_intr_phyrdy_change (hotplug)
3894 */
3895 static int
3898 {
3906 /* AHCI_ADDR_PORT: We've no idea of the attached device here. */
3909 /*
3910 * At the time being, only probe ports/devices and get the types of
3911 * attached devices during DDI_ATTACH. In fact, the device can be
3912 * changed during power state changes, but at the time being, we
3913 * don't support the situation.
3914 */
3918 /* check for DDI_RESUME case */
3925 }
3928 /*
3929 * During the resume, we need to set the PxCLB, PxCLBU, PxFB
3930 * and PxFBU registers in case these registers were cleared
3931 * during the suspend.
3932 */
3934 "ahci_initialize_port: port %d "
3935 "set PxCLB, PxCLBU, PxFB and PxFBU "
3939 AHCI_SUCCESS)
3941 }
3949 /*
3950 * Check whether the port is in NotRunning state, if not,
3951 * put the port in NotRunning state
3952 */
3955 AHCI_CMD_STATUS_CR |
3956 AHCI_CMD_STATUS_FRE |
3957 AHCI_CMD_STATUS_FR)) {
3960 }
3962 /* Make sure the drive is spun-up */
3965 /* Disable interrupt */
3968 /* Device is unknown at first */
3971 /* Disable the interface power management */
3979 /* Check physcial link status */
3983 /* Check interface status */
3987 /* Check whether port reset must be executed */
3990 /* Always reset port on RESUME */
3993 /* Something went wrong, we need do some reset things */
3996 /* Does port reset succeed on HBA port? */
3999 "ahci_initialize_port:"
4002 }
4004 /* Is port failed? */
4006 SATA_PSTATE_FAILED) {
4011 }
4012 }
4017 /*
4018 * Try to get the device signature if the port is not empty.
4019 */
4021 SATA_DTYPE_NONE)
4024 /* Return directly if no device connected */
4029 }
4031 /* If this is a port multiplier, we need do some initialization */
4036 }
4038 /* Try to start the port */
4044 }
4045 out:
4046 /* Enable port interrupts */
4050 }
4052 /*
4053 * Handle hardware defect, and check the capabilities. For example,
4054 * power management capabilty and MSI capability.
4055 */
4056 static int
4058 {
4060 #if AHCI_DEBUG
4062 ushort_t msimc;
4063 #endif
4068 PCI_CONF_VENID);
4072 PCI_CONF_DEVID);
4074 /*
4075 * Modify dma_attr_align of ahcictl_buffer_dma_attr. For VT8251, those
4076 * controllers with 0x00 revision id work on 4-byte aligned buffer,
4077 * which is a bug and was fixed after 0x00 revision id controllers.
4078 *
4079 * Moreover, VT8251 cannot use multiple command slots in the command
4080 * list for non-queued commands because the previous register content
4081 * of PxCI can be re-written in the register write, so a flag will be
4082 * set to record this defect - AHCI_CAP_NO_MCMDLIST_NONQUEUE.
4083 *
4084 * For VT8251, software reset also has the same defect as the below
4085 * AMD/ATI chipset. That is, software reset will get failed if 0xf
4086 * is filled in pmport field. Therefore, another software reset need
4087 * to be done with 0 filled in pmport field.
4088 */
4091 PCI_CONF_REVID);
4098 }
4102 "VT8251 cannot use multiple command lists for "
4106 }
4108 /*
4109 * AMD/ATI SB600 (0x1002,0x4380) AHCI chipset doesn't support 64-bit
4110 * DMA addressing for communication memory descriptors though S64A bit
4111 * of CAP register declares it supports. Even though 64-bit DMA for
4112 * data buffer works on ASUS M2A-VM with newer BIOS, three other
4113 * motherboards are known not, so both AHCI_CAP_BUF_32BIT_DMA and
4114 * AHCI_CAP_COMMU_32BIT_DMA are set for this controller.
4115 *
4116 * Due to certain hardware issue, the chipset must do port reset during
4117 * initialization, otherwise, when retrieving device signature,
4118 * software reset will get time out. So AHCI_CAP_INIT_PORT_RESET flag
4119 * need to set.
4120 *
4121 * For this chipset software reset will get failure if the pmport of
4122 * Register FIS was set with SATA_PMULT_HOSTPORT (0xf) and no port
4123 * multiplier is connected to the port. In order to fix the issue,
4124 * AHCI_CAP_SRST_NO_HOSTPORT flag need to be set, and once software
4125 * reset got failure, the driver will try to do another software reset
4126 * with pmport 0.
4127 */
4136 "ATI SB600 cannot do 64-bit DMA for both data buffer and "
4137 "communication memory descriptors though CAP indicates "
4141 NULL);
4143 "ATI SB600 will get software reset failure if pmport "
4145 }
4147 /*
4148 * AMD/ATI SB700/710/750/800 and SP5100 AHCI chipset share the same
4149 * vendor ID and device ID (0x1002,0x4391).
4150 *
4151 * SB700/750 AHCI chipset on some boards doesn't support 64-bit
4152 * DMA addressing for communication memory descriptors though S64A bit
4153 * of CAP register declares the support. However, it does support
4154 * 64-bit DMA for data buffer. So only AHCI_CAP_COMMU_32BIT_DMA is
4155 * set for this controller.
4156 *
4157 * SB710 has the same initialization issue as SB600, so it also need
4158 * a port reset. That is AHCI_CAP_INIT_PORT_RESET need to set for it.
4159 *
4160 * SB700 also has the same issue about software reset, and thus
4161 * AHCI_CAP_SRST_NO_HOSTPORT flag also is needed.
4162 */
4170 "ATI SB700/750 cannot do 64-bit DMA for communication "
4171 "memory descriptors though CAP indicates support, "
4175 NULL);
4177 "ATI SB700 will get software reset failure if pmport "
4179 }
4181 /*
4182 * Check if capabilities list is supported and if so,
4183 * get initial capabilities pointer and clear bits 0,1.
4184 */
4192 }
4194 /*
4195 * Walk capabilities if supported.
4196 */
4199 /*
4200 * Check that we haven't exceeded the maximum number of
4201 * capabilities and that the pointer is in a valid range.
4202 */
4207 }
4211 caps_ptr);
4213 }
4215 /*
4216 * Get next capability and check that it is valid.
4217 * For now, we only support power management.
4218 */
4220 caps_ptr);
4224 /* power management supported */
4227 /* Save PMCSR offset */
4230 #if AHCI_DEBUG
4238 "Power Management capability found PCI_PMCAP "
4242 "PCI Power Management Interface "
4244 #endif
4248 #if AHCI_DEBUG
4253 "Message Signaled Interrupt capability found "
4255 #endif
4289 }
4291 /*
4292 * Get next capabilities pointer and clear bits 0,1.
4293 */
4297 }
4300 }
4302 /*
4303 * Read/Write a register at port multiplier by SATA READ PORTMULT / SATA WRITE
4304 * PORTMULT command. SYNC & POLLING mode is used.
4305 */
4306 static int
4309 {
4311 ahci_addr_t pmult_addr;
4314 sata_device_t sata_device;
4329 /* Check the existence of the port multiplier */
4333 /* Request a READ/WRITE PORTMULT sata packet. */
4340 /*
4341 * Make sure no command is outstanding here. All R/W PMULT requests
4342 * come from
4343 *
4344 * 1. ahci_attach()
4345 * The port should be empty.
4346 *
4347 * 2. ahci_tran_probe_port()
4348 * Any request from SATA framework (via ahci_tran_start) should be
4349 * rejected if R/W PMULT command is outstanding.
4350 *
4351 * If we are doing mopping, do not check those flags because no
4352 * command will be actually outstanding.
4353 *
4354 * If the port has been occupied by any other commands, the probe
4355 * function will return a SATA_RETRY. SATA framework will retry
4356 * later.
4357 */
4363 }
4373 }
4375 /*
4376 * The port multiplier is gone. This may happen when
4377 * 1. Cutting off the power of an enclosure. The device lose the power
4378 * before port multiplier.
4379 * 2. Disconnecting the port multiplier during hot-plugging a sub-drive.
4380 *
4381 * The issued command should be aborted and the following command
4382 * should not be continued.
4383 */
4386 "READ/WRITE PMULT failed: "
4389 }
4396 /*
4397 * READ/WRITE PORTMULT command is intended to sent to the control port
4398 * of the port multiplier.
4399 */
4404 /* No interrupt here. Store the interrupt enable mask. */
4420 }
4422 /* Failed or not completed. */
4428 }
4429 out:
4430 /* Restore the interrupt mask */
4438 }
4440 static int
4443 {
4445 SATA_RDWR_PMULT_PKT_TYPE_READ);
4446 }
4448 static int
4451 {
4453 SATA_RDWR_PMULT_PKT_TYPE_WRITE);
4454 }
4456 #define READ_PMULT(addrp, r, pv, out) \
4457 if (ahci_read_pmult(ahci_ctlp, addrp, r, pv) != AHCI_SUCCESS) \
4458 goto out;
4460 #define WRITE_PMULT(addrp, r, v, out) \
4461 if (ahci_write_pmult(ahci_ctlp, addrp, r, v) != AHCI_SUCCESS) \
4462 goto out;
4464 /*
4465 * Update sata registers on port multiplier, including GSCR/PSCR registers.
4466 * ahci_update_pmult_gscr()
4467 * ahci_update_pmult_pscr()
4468 */
4469 static int
4472 {
4485 }
4487 static int
4490 {
4504 }
4506 /*
4507 * ahci_initialize_pmult()
4508 *
4509 * Initialize a port multiplier, including
4510 * 1. Enable FEATURES register at port multiplier. (SATA Chp.16)
4511 * 2. Redefine MASK register. (SATA Chap 16.?)
4512 */
4513 static int
4516 {
4517 sata_pmult_gscr_t sg;
4526 /*
4527 * Enable features of port multiplier. Currently only
4528 * Asynchronous Notification is enabled.
4529 */
4530 /* Check gscr64 for supported features. */
4535 "port %d: Port Multiplier supports "
4538 /* Write to gscr96 to enabled features */
4544 AHCI_SNOTIF_CLEAR_ALL);
4548 }
4550 /*
4551 * Now we need to update gscr33 register to enable hot-plug interrupt
4552 * for sub devices behind port multiplier.
4553 */
4558 /*
4559 * Fetch the number of device ports of the port multiplier
4560 */
4564 /* Register the port multiplier to SATA Framework. */
4576 /* Till now port-mult is successfully initialized */
4582 }
4584 /*
4585 * Initialize a port multiplier port. According to spec, firstly we need
4586 * issue a COMRESET, then a software reset to get its signature.
4587 *
4588 * NOTE: This function should only be called in ahci_probe_pmport()
4589 */
4590 static int
4593 {
4605 /* Check HBA port state */
4608 "ahci_initialize_pmport:"
4612 }
4616 }
4619 /* Checking for outstanding commands */
4628 }
4633 /* Clear status */
4636 /* Firstly assume an unknown device */
4641 /* port reset is necessary for port multiplier port */
4644 "ahci_initialize_pmport:"
4648 }
4650 /* Is port failed? */
4652 SATA_PSTATE_FAILED) {
4654 "ahci_initialize_pmport: port %d:%d failed. "
4658 }
4660 /* Is there any device attached? */
4663 /* Do not waste time on an empty port */
4665 "ahci_initialize_pmport: No device is found "
4669 }
4675 /*
4676 * Till now we can assure a device attached to that HBA port and work
4677 * correctly. Now try to get the device signature. This is an optional
4678 * step. If failed, unknown device is assumed, then SATA module will
4679 * continue to use IDENTIFY DEVICE to get the information of the
4680 * device.
4681 */
4686 out:
4687 /* Next try to mop the pending commands */
4697 ahci_portp,
4698 slot_status,
4704 /* Clear PxSNTF register if supported. */
4708 AHCI_SNOTIF_CLEAR_ALL);
4709 }
4714 }
4716 /*
4717 * ahci_probe_pmult()
4718 *
4719 * This function will be called to probe a port multiplier, which will
4720 * handle hotplug events on port multiplier ports.
4721 *
4722 * NOTE: Only called from ahci_tran_probe_port()
4723 */
4724 static int
4727 {
4728 sata_device_t sdevice;
4729 ahci_addr_t pmport_addr;
4738 /* The bits in GSCR32 refers to the pmport that has a hot-plug event. */
4745 /* no pending hot plug events. */
4753 /* Check previous device at that port */
4758 /* PxSStatus tells the presence of device. */
4763 SSTATUS_DET_DEVPRE_PHYCOM)
4766 /*
4767 * Clear PxSERR is critical. The transition from 0 to 1 will
4768 * emit a FIS which generates an asynchronous notification
4769 * event at controller. If we fail to clear the PxSERR, the
4770 * Async Notif events will no longer be activated on this
4771 * pmport.
4772 */
4785 dev_exists_now);
4789 /* Link (may) not change: Exist -> Exist * */
4791 "ahci_probe_pmult: port %d:%d "
4798 sata_tran_hba_dip,
4800 SATA_EVNT_LINK_LOST|
4801 SATA_EVNT_LINK_ESTABLISHED);
4804 /* Link change: None -> Exist */
4806 "ahci_probe_pmult: port %d:%d "
4809 /* Clear port state */
4811 SATA_STATE_UNKNOWN);
4813 "ahci_probe_pmult: port %d "
4819 sata_tran_hba_dip,
4821 SATA_EVNT_LINK_ESTABLISHED);
4823 }
4827 /* Link change: Exist -> None */
4829 "ahci_probe_pmult: port %d:%d "
4832 /* An existing device is lost. */
4834 SATA_STATE_UNKNOWN);
4836 SATA_DTYPE_NONE);
4841 sata_tran_hba_dip,
4843 SATA_EVNT_LINK_LOST);
4845 }
4846 }
4855 }
4857 /*
4858 * Probe and initialize a port multiplier port.
4859 * A port multiplier port could only be initilaizer here.
4860 */
4861 static int
4864 {
4867 ahci_addr_t addr_pmult;
4871 /*
4872 * Check the parent - port multiplier first.
4873 */
4875 /*
4876 * Parent port multiplier might have been removed. This event will be
4877 * ignored and failure.
4878 */
4882 "ahci_tran_probe_port: "
4886 }
4888 /* The port is ready? */
4892 "ahci_tran_probe_port: "
4897 AHCI_SUCCESS) {
4899 "ahci_tran_probe_port: "
4902 }
4903 }
4905 /*
4906 * If port-mult is restarted due to some reason, we need
4907 * re-initialized the PMult.
4908 */
4910 /* Initialize registers on a port multiplier */
4915 }
4917 /*
4918 * Then we check the port-mult port
4919 */
4920 /* Is this pmport initialized? */
4924 /* ahci_initialize_pmport() will set READY state */
4928 }
4931 }
4933 /*
4934 * AHCI device reset ...; a single device on one of the ports is reset,
4935 * but the HBA and physical communication remain intact. This is the
4936 * least intrusive.
4937 *
4938 * When issuing a software reset sequence, there should not be other
4939 * commands in the command list, so we will first clear and then re-set
4940 * PxCMD.ST to clear PxCI. And before issuing the software reset,
4941 * the port must be idle and PxTFD.STS.BSY and PxTFD.STS.DRQ must be
4942 * cleared unless command list override (PxCMD.CLO) is supported.
4943 */
4944 static int
4947 {
4962 /* First clear PxCMD.ST (AHCI v1.2 10.4.1) */
4968 }
4970 /* Check PxTFD.STS.BSY and PxTFD.STS.DRQ */
4978 "PxTFD.STS.BSY/DRQ is set (PxTFD=0x%x), "
4981 }
4983 /*
4984 * If HBA Support CLO, as Command List Override (CAP.SCLO is
4985 * set), PxCMD.CLO bit should be set before set PxCMD.ST, in
4986 * order to clear PxTFD.STS.BSY and PxTFD.STS.DRQ.
4987 */
4997 /* Waiting till PxCMD.SCLO bit is cleared */
5000 /* Wait for 10 millisec */
5003 /* We are effectively timing out after 1 sec. */
5008 }
5010 port_cmd_status =
5015 /* Re-check */
5022 port_task_file);
5024 }
5025 }
5027 /* Then start port */
5033 }
5035 /*
5036 * When ahci_port.ahciport_mop_in_progress is set, A non-zero
5037 * ahci_port.ahciport_pending_ncq_tags may fail
5038 * ahci_claim_free_slot(). Actually according to spec, by clearing
5039 * PxCMD.ST there is no command outstanding while executing software
5040 * reseting. Hence we directly use slot 0 instead of
5041 * ahci_claim_free_slot().
5042 */
5045 /* Now send the first H2D Register FIS with SRST set to 1 */
5049 h2d_register_fisp =
5056 /* Set Command Header in Command List */
5069 ahci_cmd_table_size,
5070 DDI_DMA_SYNC_FORDEV);
5075 DDI_DMA_SYNC_FORDEV);
5077 /* Indicate to the HBA that a command is active. */
5084 /* Loop till the first command is finished */
5089 /* We are effectively timing out after 1 sec. */
5092 "the first SRST FIS is timed out, "
5095 }
5096 /* Wait for 10 millisec */
5101 "ahci_software_reset: 1st loop count: %d, "
5105 /* According to ATA spec, we need wait at least 5 microsecs here. */
5108 /* Now send the second H2D Register FIS with SRST cleard to zero */
5112 h2d_register_fisp =
5118 /* Set Command Header in Command List */
5129 ahci_cmd_table_size,
5130 DDI_DMA_SYNC_FORDEV);
5135 DDI_DMA_SYNC_FORDEV);
5137 /* Indicate to the HBA that a command is active. */
5144 /* Loop till the second command is finished */
5149 /* We are effectively timing out after 1 sec. */
5152 "the second SRST FIS is timed out, "
5155 }
5157 /* Wait for 10 millisec */
5162 "ahci_software_reset: 2nd loop count: %d, "
5169 DDI_SERVICE_UNAFFECTED);
5171 }
5174 out:
5181 }
5183 /*
5184 * AHCI port reset ...; the physical communication between the HBA and device
5185 * on a port are disabled. This is more intrusive.
5186 *
5187 * When an HBA or port reset occurs, Phy communication is going to
5188 * be re-established with the device through a COMRESET followed by the
5189 * normal out-of-band communication sequence defined in Serial ATA. At
5190 * the end of reset, the device, if working properly, will send a D2H
5191 * Register FIS, which contains the device signature. When the HBA receives
5192 * this FIS, it updates PxTFD.STS and PxTFD.ERR register fields, and updates
5193 * the PxSIG register with the signature.
5194 *
5195 * NOTE: It is expected both PxCMD.ST and PxCMD.CR are cleared before the
5196 * function is called. If not, it is assumed the interface is in hung
5197 * condition.
5198 */
5199 static int
5202 {
5203 ahci_addr_t pmult_addr;
5215 /* Target is a port multiplier port? */
5219 /* Otherwise it must be an HBA port. */
5229 /*
5230 * According to the spec, SUD bit should be set here,
5231 * but JMicron JMB363 doesn't follow it, so print
5232 * a debug message.
5233 */
5244 port_scontrol);
5246 /* Enable PxCMD.FRE to read device */
5251 /*
5252 * The port enters P:StartComm state, and the HBA tells the link layer
5253 * to start communication, which involves sending COMRESET to the
5254 * device. And the HBA resets PxTFD.STS to 7Fh.
5255 *
5256 * Give time for COMRESET to percolate, according to the AHCI
5257 * spec, software shall wait at least 1 millisecond before
5258 * clearing PxSCTL.DET
5259 */
5262 /* Fetch the SCONTROL again and rewrite the DET part with 0 */
5268 port_scontrol);
5270 /*
5271 * When a COMINIT is received from the device, then the port enters
5272 * P:ComInit state. And HBA sets PxTFD.STS to FFh or 80h. HBA sets
5273 * PxSSTS.DET to 1h to indicate a device is detected but communication
5274 * is not yet established. HBA sets PxSERR.DIAG.X to '1' to indicate
5275 * a COMINIT has been received.
5276 */
5277 /*
5278 * The DET field is valid only if IPM field indicates
5279 * that the interface is in active state.
5280 */
5287 /*
5288 * If the interface is not active, the DET field
5289 * is considered not accurate. So we want to
5290 * continue looping.
5291 */
5293 }
5299 /*
5300 * We are effectively timing out after 0.1 sec.
5301 */
5303 }
5305 /* Wait for 10 millisec */
5307 }
5310 "ahci_port_reset: 1st loop count: %d, "
5315 /*
5316 * Either the port is not active or there
5317 * is no device present.
5318 */
5321 }
5323 /* Clear port serror register for the port */
5326 AHCI_SERROR_CLEAR_ALL);
5328 /*
5329 * Devices should return a FIS contains its signature to HBA after
5330 * COMINIT signal. Check whether a D2H Register FIS is received by
5331 * polling PxTFD.STS.
5332 */
5335 port_task_file =
5344 /*
5345 * We are effectively timing out after 11 sec.
5346 */
5348 "the device hardware has been initialized and "
5353 "port %d: some or all of BSY, DRQ and ERR in "
5354 "PxTFD.STS are not clear. We need another "
5357 /* Clear port serror register for the port */
5360 AHCI_SERROR_CLEAR_ALL);
5364 /* Try another software reset. */
5368 SATA_PSTATE_FAILED);
5370 }
5372 }
5374 /* Wait for 10 millisec */
5376 }
5379 "ahci_port_reset: 2nd loop count: %d, "
5383 /* Clear port serror register for the port */
5386 AHCI_SERROR_CLEAR_ALL);
5388 /* Set port as ready */
5395 }
5397 /*
5398 * COMRESET on a port multiplier port.
5399 *
5400 * NOTE: Only called in ahci_port_reset()
5401 */
5402 static int
5405 {
5417 /* Initialize pmport state */
5424 /* PxCMD.FRE should be set before. */
5431 /*
5432 * Give time for COMRESET to percolate, according to the AHCI
5433 * spec, software shall wait at least 1 millisecond before
5434 * clearing PxSCTL.DET
5435 */
5438 /*
5439 * Fetch the SCONTROL again and rewrite the DET part with 0
5440 * This will generate an Asychronous Notification events.
5441 */
5446 /*
5447 * The port enters P:StartComm state, and HBA tells link layer to
5448 * start communication, which involves sending COMRESET to device.
5449 * And the HBA resets PxTFD.STS to 7Fh.
5450 *
5451 * When a COMINIT is received from the device, then the port enters
5452 * P:ComInit state. And HBA sets PxTFD.STS to FFh or 80h. HBA sets
5453 * PxSSTS.DET to 1h to indicate a device is detected but communication
5454 * is not yet established. HBA sets PxSERR.DIAG.X to '1' to indicate
5455 * a COMINIT has been received.
5456 */
5457 /*
5458 * The DET field is valid only if IPM field indicates
5459 * that the interface is in active state.
5460 */
5466 /*
5467 * If the interface is not active, the DET field
5468 * is considered not accurate. So we want to
5469 * continue looping.
5470 */
5472 }
5475 /*
5476 * We are effectively timing out after 0.1 sec.
5477 */
5479 }
5481 /* Wait for 10 millisec */
5487 "ahci_pmport_reset: 1st loop count: %d, "
5493 /*
5494 * Either the port is not active or there
5495 * is no device present.
5496 */
5498 "ahci_pmport_reset: "
5503 }
5505 /* Now we can make sure there is a device connected to the port */
5506 /* COMINIT signal is supposed to be received (PxSERR.DIAG.X = '1') */
5516 }
5518 /*
5519 * After clear PxSERR register, we will receive a D2H FIS.
5520 * Normally this FIS will cause a IPMS error according to AHCI spec
5521 * v1.2 because there is no command outstanding for it. So we need
5522 * to ignore this error.
5523 */
5527 /* Now we need to check the D2H FIS by checking IPMS error. */
5534 /*
5535 * No D2H FIS received. This is possible according
5536 * to SATA 2.6 spec.
5537 */
5539 "PxIS.IPMS is not set, we need another "
5543 }
5545 /* Wait for 10 millisec */
5553 "ahci_pmport_reset: 2st loop count: %d, "
5557 /* Clear IPMS */
5560 AHCI_INTR_STATUS_IPMS);
5563 /* This pmport is now ready for ahci_tran_start() */
5572 /* IPMS flags might be set before. */
5578 }
5580 /*
5581 * AHCI HBA reset ...; the entire HBA is reset, and all ports are disabled.
5582 * This is the most intrusive.
5583 *
5584 * When an HBA reset occurs, Phy communication will be re-established with
5585 * the device through a COMRESET followed by the normal out-of-band
5586 * communication sequence defined in Serial ATA. At the end of reset, the
5587 * device, if working properly, will send a D2H Register FIS, which contains
5588 * the device signature. When the HBA receives this FIS, it updates PxTFD.STS
5589 * and PxTFD.ERR register fields, and updates the PxSIG register with the
5590 * signature.
5591 *
5592 * Remember to set GHC.AE to 1 before calling ahci_hba_reset.
5593 */
5594 static int
5596 {
5604 NULL);
5611 /* Setting GHC.HR to 1, remember GHC.AE is already set to 1 before */
5616 /*
5617 * Wait until HBA Reset complete or timeout
5618 */
5626 "ahci hba reset is timing out, "
5628 /* We are effectively timing out after 1 sec. */
5630 }
5632 /* Wait for 10 millisec */
5637 "ahci_hba_reset: 1st loop count: %d, "
5641 /* The hba is not reset for some reasons */
5646 }
5648 /*
5649 * HBA reset will clear (AHCI Spec v1.2 10.4.3) GHC.IE / GHC.AE
5650 */
5660 /* Only check implemented ports */
5663 }
5668 /* Make sure the drive is spun-up */
5673 AHCI_SUCCESS) {
5677 /*
5678 * Set the port state to SATA_PSTATE_FAILED if
5679 * failed to initialize it.
5680 */
5682 }
5685 }
5688 }
5690 /*
5691 * This routine is only called from AHCI_ATTACH or phyrdy change
5692 * case. It first calls software reset, then stop the port and try to
5693 * read PxSIG register to find the type of device attached to the port.
5694 *
5695 * The caller should make sure a valid device exists on specified port and
5696 * physical communication has been established so that the signature could
5697 * be retrieved by software reset.
5698 *
5699 * NOTE: The port interrupts should be disabled before the function is called.
5700 */
5701 static void
5704 {
5705 ahci_addr_t dev_addr;
5714 /*
5715 * If the HBA doesn't support port multiplier, then the driver
5716 * doesn't need to bother to check port multiplier device.
5717 *
5718 * The second port of ICH7 on ASUS P5W DH deluxe motherboard is
5719 * connected to Silicon Image 4723, to which the two sata drives
5720 * attached can be set with RAID1, RAID0 or Spanning mode.
5721 *
5722 * We found software reset will get failure if port multiplier address
5723 * 0xf is used by software reset, so just ignore the check since
5724 * ICH7 doesn't support port multiplier device at all.
5725 */
5731 /*
5732 * NOTE: when the ahci address is a HBA port, we do not know
5733 * it is a device or a port multiplier that attached. we need
5734 * try a software reset at port multiplier address (0xf
5735 * pmport)
5736 */
5743 }
5745 /* Assume it is unknown. */
5748 /* Issue a software reset to get the signature */
5752 /*
5753 * Try to do software reset again with pmport set with 0 if
5754 * the controller is set with AHCI_CAP_SRST_NO_HOSTPORT and
5755 * the original pmport is set with SATA_PMULT_HOSTPORT (0xf)
5756 */
5762 }
5766 "ahci_find_dev_signature: software reset failed "
5771 SATA_PSTATE_FAILED);
5773 }
5774 }
5776 /*
5777 * ahci_software_reset has started the port, so we need manually stop
5778 * the port again.
5779 */
5785 port);
5788 }
5789 }
5791 /* Now we can make sure that a valid signature is received. */
5803 }
5805 /* NOTE: Only support ATAPI device at controller port. */
5824 /* Port Multiplier cannot recursively attached. */
5835 }
5836 }
5838 /*
5839 * According to the spec, to reliably detect hot plug removals, software
5840 * must disable interface power management. Software should perform the
5841 * following initialization on a port after a device is attached:
5842 * Set PxSCTL.IPM to 3h to disable interface state transitions
5843 * Set PxCMD.ALPE to '0' to disable aggressive power management
5844 * Disable device initiated interface power management by SET FEATURE
5845 *
5846 * We can ignore the last item because by default the feature is disabled
5847 */
5848 static void
5850 {
5864 }
5866 /*
5867 * Start the port - set PxCMD.ST to 1, if PxCMD.FRE is not set
5868 * to 1, then set it firstly.
5869 *
5870 * Each port contains two major DMA engines. One DMA engine walks through
5871 * the command list, and is controlled by PxCMD.ST. The second DMA engine
5872 * copies received FISes into system memory, and is controlled by PxCMD.FRE.
5873 *
5874 * Software shall not set PxCMD.ST to '1' until it verifies that PxCMD.CR
5875 * is '0' and has set PxCMD.FRE is '1'. And software shall not clear
5876 * PxCMD.FRE while PxCMD.ST or PxCMD.CR is set '1'.
5877 *
5878 * Software shall not set PxCMD.ST to '1' unless a functional device is
5879 * present on the port(as determined by PxTFD.STS.BSY = '0',
5880 * PxTFD.STS.DRQ = '0', and PxSSTS.DET = 3h).
5881 */
5882 static int
5884 {
5896 }
5902 }
5904 /* First to set PxCMD.FRE before setting PxCMD.ST. */
5912 port_cmd_status);
5913 }
5922 port_cmd_status);
5930 }
5932 /*
5933 * Setup PxCLB, PxCLBU, PxFB, and PxFBU for particular port. First, we need
5934 * to make sure PxCMD.ST, PxCMD.CR, PxCMD.FRE, and PxCMD.FR are all cleared.
5935 * Then set PxCLB, PxCLBU, PxFB, and PxFBU.
5936 */
5937 static int
5939 {
5946 /* Step 1: Make sure both PxCMD.ST and PxCMD.CR are cleared. */
5954 }
5956 /* Step 2: Make sure both PxCMD.FRE and PxCMD.FR are cleared. */
5960 /* Clear PxCMD.FRE */
5964 port_cmd_status);
5966 /* Wait until PxCMD.FR is cleared */
5968 port_cmd_status =
5977 "ahci_setup_port_base_addresses: cannot "
5980 /*
5981 * We are effectively timing out after 0.5 sec.
5982 * This value is specified in AHCI spec.
5983 */
5985 }
5987 /* Wait for 1 millisec */
5989 }
5990 }
5992 /* Step 3: Config Port Command List Base Address */
6001 /* Step 4: Config Port Received FIS Base Address */
6011 }
6013 /*
6014 * Allocate the ahci_port_t including Received FIS and Command List.
6015 * The argument - port is the physical port number, and not logical
6016 * port number seen by the SATA framework.
6017 */
6018 static int
6020 {
6027 ahci_portp =
6033 /* Initialize the port condition variable */
6036 /* Initialize the port mutex */
6042 /*
6043 * Allocate memory for received FIS structure and
6044 * command list for this port
6045 */
6048 }
6052 }
6054 /* Setup PxCMD.CLB, PxCMD.CLBU, PxCMD.FB, and PxCMD.FBU */
6056 AHCI_SUCCESS) {
6058 }
6064 /* Create the taskq for the port */
6070 }
6072 /* Allocate the argument for the taskq */
6082 /* Initialize the done queue */
6091 err_case4:
6094 err_case3:
6097 err_case2:
6100 err_case1:
6108 }
6110 /*
6111 * Reverse of ahci_alloc_port_state().
6112 */
6113 static void
6115 {
6139 }
6141 /*
6142 * Allocates memory for the Received FIS Structure
6143 */
6144 static int
6146 {
6149 uint_t cookie_count;
6155 /* allocate rcvd FIS dma handle. */
6158 DDI_DMA_SLEEP,
6159 NULL,
6161 DDI_SUCCESS) {
6166 }
6169 rcvd_fis_size,
6171 DDI_DMA_CONSISTENT,
6172 DDI_DMA_SLEEP,
6173 NULL,
6180 /* error.. free the dma handle. */
6183 }
6186 NULL,
6188 rcvd_fis_size,
6190 DDI_DMA_SLEEP,
6191 NULL,
6197 /* error.. free the dma handle & free the memory. */
6201 }
6211 }
6213 /*
6214 * Deallocates the Received FIS Structure
6215 */
6216 static void
6218 {
6221 /* Unbind the cmd list dma handle first. */
6224 /* Then free the underlying memory. */
6227 /* Now free the handle itself. */
6229 }
6231 /*
6232 * Allocates memory for the Command List, which contains up to 32 entries.
6233 * Each entry contains a command header, which is a 32-byte structure that
6234 * includes the pointer to the command table.
6235 */
6236 static int
6238 {
6241 uint_t cookie_count;
6245 cmd_list_size =
6248 /* allocate cmd list dma handle. */
6251 DDI_DMA_SLEEP,
6252 NULL,
6258 }
6261 cmd_list_size,
6263 DDI_DMA_CONSISTENT,
6264 DDI_DMA_SLEEP,
6265 NULL,
6272 /* error.. free the dma handle. */
6275 }
6278 NULL,
6280 cmd_list_size,
6282 DDI_DMA_SLEEP,
6283 NULL,
6289 /* error.. free the dma handle & free the memory. */
6293 }
6305 }
6309 err_out:
6310 /* Unbind the cmd list dma handle first. */
6313 /* Then free the underlying memory. */
6316 /* Now free the handle itself. */
6320 }
6322 /*
6323 * Deallocates the Command List
6324 */
6325 static void
6327 {
6330 /* First dealloc command table */
6333 /* Unbind the cmd list dma handle first. */
6336 /* Then free the underlying memory. */
6339 /* Now free the handle itself. */
6341 }
6343 /*
6344 * Allocates memory for all Command Tables, which contains Command FIS,
6345 * ATAPI Command and Physical Region Descriptor Table.
6346 */
6347 static int
6349 {
6351 ddi_dma_cookie_t cmd_table_dma_cookie;
6352 uint_t cookie_count;
6362 /* Allocate cmd table dma handle. */
6365 DDI_DMA_SLEEP,
6366 NULL,
6368 DDI_SUCCESS) {
6374 }
6378 ahci_cmd_table_size,
6380 DDI_DMA_CONSISTENT,
6381 DDI_DMA_SLEEP,
6382 NULL,
6386 NULL) {
6391 /* error.. free the dma handle. */
6395 }
6399 NULL,
6401 ahci_cmd_table_size,
6403 DDI_DMA_SLEEP,
6404 NULL,
6410 /* error.. free the dma handle & free the memory. */
6416 }
6419 ahci_cmd_table_size);
6421 /* Config Port Command Table Base Address */
6426 #ifndef __lock_lint
6430 #endif
6431 }
6434 err_out:
6437 /* Unbind the cmd table dma handle first */
6441 /* Then free the underlying memory */
6445 /* Now free the handle itself */
6448 }
6451 }
6453 /*
6454 * Deallocates memory for all Command Tables.
6455 */
6456 static void
6458 {
6468 /* Unbind the cmd table dma handle first. */
6472 /* Then free the underlying memory. */
6476 /* Now free the handle itself. */
6479 }
6480 }
6482 /*
6483 * Update SATA registers at controller ports
6484 */
6485 static void
6488 {
6503 }
6505 /*
6506 * For poll mode, ahci_port_intr will be called to emulate the interrupt
6507 */
6508 static void
6510 {
6519 /* For SATA_OPMODE_POLLING commands */
6520 port_intr_enable =
6522 AHCI_INTR_STATUS_PSS |
6523 AHCI_INTR_STATUS_SDBS |
6524 AHCI_INTR_STATUS_UFS |
6525 AHCI_INTR_STATUS_PCS |
6526 AHCI_INTR_STATUS_PRCS |
6527 AHCI_INTR_STATUS_OFS |
6528 AHCI_INTR_STATUS_INFS |
6529 AHCI_INTR_STATUS_IFS |
6530 AHCI_INTR_STATUS_HBDS |
6531 AHCI_INTR_STATUS_HBFS |
6532 AHCI_INTR_STATUS_TFES);
6534 /*
6535 * port_intr_enable indicates that the corresponding interrrupt
6536 * reporting is enabled.
6537 */
6540 }
6542 /* IPMS error in port reset should be ignored according AHCI spec. */
6547 /*
6548 * port_intr_stats indicates that the corresponding interrupt
6549 * condition is active.
6550 */
6555 "ahci_port_intr: port %d, port_intr_status = 0x%x, "
6561 /*
6562 * Pending interrupt events are indicated by the PxIS register.
6563 * Make sure we don't miss any event.
6564 */
6567 DDI_SERVICE_UNAFFECTED);
6569 DDI_FME_VERSION);
6571 }
6573 /* First clear the port interrupts status */
6576 port_intr_status);
6578 /* Check the completed non-queued commands */
6580 AHCI_INTR_STATUS_PSS)) {
6583 }
6585 /* Check the completed queued commands */
6589 }
6591 /* Check the port connect change status interrupt bit */
6595 }
6597 /* Check the device mechanical presence status interrupt bit */
6601 }
6603 /* Check the PhyRdy change status interrupt bit */
6606 port);
6607 }
6609 /*
6610 * Check the non-fatal error interrupt bits, there are four
6611 * kinds of non-fatal errors at the time being:
6612 *
6613 * PxIS.UFS - Unknown FIS Error
6614 * PxIS.OFS - Overflow Error
6615 * PxIS.INFS - Interface Non-Fatal Error
6616 * PxIS.IPMS - Incorrect Port Multiplier Status Error
6617 *
6618 * For these non-fatal errors, the HBA can continue to operate,
6619 * so the driver just log the error messages.
6620 */
6622 AHCI_INTR_STATUS_OFS |
6623 AHCI_INTR_STATUS_IPMS |
6624 AHCI_INTR_STATUS_INFS)) {
6627 }
6629 /*
6630 * Check the fatal error interrupt bits, there are four kinds
6631 * of fatal errors for AHCI controllers:
6632 *
6633 * PxIS.HBFS - Host Bus Fatal Error
6634 * PxIS.HBDS - Host Bus Data Error
6635 * PxIS.IFS - Interface Fatal Error
6636 * PxIS.TFES - Task File Error
6637 *
6638 * The fatal error means the HBA can not recover from it by
6639 * itself, and it will try to abort the transfer, and the software
6640 * must intervene to restart the port.
6641 */
6643 AHCI_INTR_STATUS_HBDS |
6644 AHCI_INTR_STATUS_HBFS |
6645 AHCI_INTR_STATUS_TFES))
6649 /* Check the cold port detect interrupt bit */
6652 }
6654 /* Second clear the corresponding bit in IS.IPS */
6658 /* Try to recover at the end of the interrupt handler. */
6660 DDI_FM_OK) {
6662 DDI_SERVICE_UNAFFECTED);
6664 DDI_FME_VERSION);
6665 }
6666 }
6668 /*
6669 * Interrupt service handler
6670 */
6671 static uint_t
6673 {
6674 #ifndef __lock_lint
6676 #endif
6677 /* LINTED */
6683 /*
6684 * global_intr_status indicates that the corresponding port has
6685 * an interrupt pending.
6686 */
6691 /* The interrupt is not ours */
6693 }
6695 /*
6696 * Check the handle after reading global_intr_status - we don't want
6697 * to miss any port with pending interrupts.
6698 */
6700 DDI_FM_OK) {
6702 DDI_SERVICE_UNAFFECTED);
6704 DDI_FME_VERSION);
6706 }
6708 /* Loop for all the ports */
6712 }
6715 }
6719 /* Call ahci_port_intr */
6721 }
6724 }
6726 /*
6727 * For non-queued commands, when the corresponding bit in the PxCI register
6728 * is cleared, it means the command is completed successfully. And according
6729 * to the HBA state machine, there are three conditions which possibly will
6730 * try to clear the PxCI register bit.
6731 * 1. Receive one D2H Register FIS which is with 'I' bit set
6732 * 2. Update PIO Setup FIS
6733 * 3. Transmit a command and receive R_OK if CTBA.C is set (software reset)
6734 *
6735 * Process completed non-queued commands when the interrupt status bit -
6736 * AHCI_INTR_STATUS_DHRS or AHCI_INTR_STATUS_PSS is set.
6737 *
6738 * AHCI_INTR_STATUS_DHRS means a D2H Register FIS has been received
6739 * with the 'I' bit set. And the following commands will send thus
6740 * FIS with 'I' bit set upon the successful completion:
6741 * 1. Non-data commands
6742 * 2. DMA data-in command
6743 * 3. DMA data-out command
6744 * 4. PIO data-out command
6745 * 5. PACKET non-data commands
6746 * 6. PACKET PIO data-in command
6747 * 7. PACKET PIO data-out command
6748 * 8. PACKET DMA data-in command
6749 * 9. PACKET DMA data-out command
6750 *
6751 * AHCI_INTR_STATUS_PSS means a PIO Setup FIS has been received
6752 * with the 'I' bit set. And the following commands will send this
6753 * FIS upon the successful completion:
6754 * 1. PIO data-in command
6755 */
6756 static int
6759 {
6765 #if AHCI_DEBUG
6768 #endif
6775 /*
6776 * Spurious interrupt. Nothing to be done.
6777 */
6780 }
6785 /* If the PxCI corrupts, don't complete the commmands. */
6790 }
6793 /* Slot 0 is always used during error recovery */
6796 "ahci_intr_cmd_cmplt: port %d the sata pkt for error "
6802 "ahci_intr_cmd_cmplt: port %d the sata pkt for r/w "
6810 }
6813 "ahci_intr_cmd_cmplt: pending_tags = 0x%x, "
6816 finished_tags);
6824 "ahci_intr_cmd_cmplt: sending up pkt 0x%p "
6829 }
6837 "ahci_intr_cmd_cmplt: sending up pkt 0x%p "
6840 /* READ PORTMULT need copy out FIS content. */
6843 ahcirf_d2h_register_fis);
6847 }
6851 }
6857 }
6861 #if AHCI_DEBUG
6862 /*
6863 * For non-native queued commands, the PRD byte count field
6864 * shall contain an accurate count of the number of bytes
6865 * transferred for the command before the PxCI bit is cleared
6866 * to '0' for the command.
6867 *
6868 * The purpose of this field is to let software know how many
6869 * bytes transferred for a given operation in order to
6870 * determine if underflow occurred. When issuing native command
6871 * queuing commands, this field should not be used and is not
6872 * required to be valid since in this case underflow is always
6873 * illegal.
6874 *
6875 * For data reads, the HBA will update its PRD byte count with
6876 * the total number of bytes received from the last FIS, and
6877 * may be able to continue normally. For data writes, the
6878 * device will detect an error, and HBA most likely will get
6879 * a fatal error.
6880 *
6881 * Therefore, here just put code to debug part. And please
6882 * refer to the comment above ahci_intr_fatal_error for the
6883 * definition of underflow error.
6884 */
6885 cmd_dmacount =
6888 cmd_header =
6891 "ahci_intr_cmd_cmplt: port %d, "
6892 "PRD Byte Count = 0x%x, "
6895 cmd_dmacount);
6899 "ahci_intr_cmd_cmplt: port %d, "
6901 }
6902 }
6903 #endif
6905 /*
6906 * For SATAC_SMART command with SATA_SMART_RETURN_STATUS
6907 * feature, sata_special_regs flag will be set, and the
6908 * driver should copy the status and the other corresponding
6909 * register values in the D2H Register FIS received (It's
6910 * working on Non-data protocol) from the device back to
6911 * the sata_cmd.
6912 *
6913 * For every AHCI port, there is only one Received FIS
6914 * structure, which contains the FISes received from the
6915 * device, So we're trying to copy the content of D2H
6916 * Register FIS in the Received FIS structure back to
6917 * the sata_cmd.
6918 */
6921 ahcirf_d2h_register_fis);
6925 }
6928 "ahci_intr_cmd_cmplt: sending up pkt 0x%p "
6936 }
6937 out:
6947 }
6949 /*
6950 * AHCI_INTR_STATUS_SDBS means a Set Device Bits FIS has been received
6951 * with the 'I' bit set and has been copied into system memory. It will
6952 * be sent under the following situations:
6953 *
6954 * 1. NCQ command is completed
6955 *
6956 * The completion of NCQ commands (READ/WRITE FPDMA QUEUED) is performed
6957 * via the Set Device Bits FIS. When such event is generated, the software
6958 * needs to read PxSACT register and compares the current value to the
6959 * list of commands previously issue by software. ahciport_pending_ncq_tags
6960 * keeps the tags of previously issued commands.
6961 *
6962 * 2. Asynchronous Notification
6963 *
6964 * Asynchronous Notification is a feature in SATA spec 2.6.
6965 *
6966 * 1) ATAPI device will send a signal to the host when media is inserted or
6967 * removed and avoids polling the device for media changes. The signal
6968 * sent to the host is a Set Device Bits FIS with the 'I' and 'N' bits
6969 * set to '1'. At the moment, it's not supported yet.
6970 *
6971 * 2) Port multiplier will send a signal to the host when a hot plug event
6972 * has occured on a port multiplier port. It is used when command based
6973 * switching is employed. This is handled by ahci_intr_pmult_sntf_events()
6974 */
6975 static int
6978 {
6979 ahci_addr_t addr;
6984 /* Initialize HBA port address */
6987 /* NCQ plug handler */
6990 /* Check port multiplier's asynchronous notification events */
6994 }
6996 /* ATAPI events is not supported yet */
6999 }
7000 /*
7001 * NCQ interrupt handler. Called upon a NCQ command is completed.
7002 * Only be called from ahci_intr_set_device_bits().
7003 */
7004 static int
7007 {
7024 }
7026 /*
7027 * First the handler got which commands are finished by checking
7028 * PxSACT register
7029 */
7037 "ahci_intr_set_device_bits: port %d pending_ncq_tags = 0x%x "
7044 /*
7045 * For NCQ commands, the software can determine which command has
7046 * already been transmitted to the device by checking PxCI register.
7047 */
7054 /* If the PxSACT/PxCI corrupts, don't complete the NCQ commmands. */
7059 }
7062 "ahci_intr_set_device_bits: port %d pending_tags = 0x%x "
7069 /*
7070 * Clear ahciport_pending_tags bit when the corresponding command
7071 * is already sent down to the device.
7072 */
7077 }
7080 }
7082 next:
7087 }
7089 /* The command is certainly transmitted to the device */
7097 "ahci_intr_set_device_bits: sending up pkt 0x%p "
7105 }
7106 out:
7108 "ahci_intr_set_device_bits: port %d "
7118 }
7120 /*
7121 * Port multiplier asynchronous notification event handler. Called upon a
7122 * device is hot plugged/pulled.
7123 *
7124 * The async-notification event will only be recorded by ahcipmi_snotif_tags
7125 * here and will be handled by ahci_probe_pmult().
7126 *
7127 * NOTE: called only from ahci_port_intr().
7128 */
7129 static int
7132 {
7133 sata_device_t sdevice;
7138 /* no hot-plug while attaching process */
7143 }
7150 }
7159 AHCI_SNOTIF_CLEAR_ALL);
7164 }
7166 /* Port Multiplier sub-device hot-plug handler */
7170 }
7173 /* Not allowed to re-enter. */
7176 }
7180 /*
7181 * NOTE:
7182 * Even if Asynchronous Notification is supported (and enabled) by
7183 * both controller and the port multiplier, the content of PxSNTF
7184 * register is always set to 0x8000 by async notification event. We
7185 * need to check GSCR[32] on the port multiplier to find out the
7186 * owner of this event.
7187 * This is not accord with SATA spec 2.6 and needs further
7188 * clarification.
7189 */
7190 /* hot-plug will not reported while reseting. */
7197 }
7203 /*
7204 * Now we need do some necessary operation and inform SATA framework
7205 * that link/device events has happened.
7206 */
7214 /* Just reject packets, do not stop that port. */
7221 SATA_EVNT_PMULT_LINK_CHANGED);
7228 }
7230 /*
7231 * 1=Change in Current Connect Status. 0=No change in Current Connect Status.
7232 * This bit reflects the state of PxSERR.DIAG.X. This bit is only cleared
7233 * when PxSERR.DIAG.X is cleared. When PxSERR.DIAG.X is set to one, it
7234 * indicates a COMINIT signal was received.
7235 *
7236 * Hot plug insertion is detected by reception of a COMINIT signal from the
7237 * device. On reception of unsolicited COMINIT, the HBA shall generate a
7238 * COMRESET. If the COMINIT is in responce to a COMRESET, then the HBA shall
7239 * begin the normal communication negotiation sequence as outlined in the
7240 * Serial ATA 1.0a specification. When a COMRESET is sent to the device the
7241 * PxSSTS.DET field shall be cleared to 0h. When a COMINIT is received, the
7242 * PxSSTS.DET field shall be set to 1h. When the communication negotiation
7243 * sequence is complete and PhyRdy is true the PxSSTS.DET field shall be set
7244 * to 3h. Therefore, at the moment the ahci driver is going to check PhyRdy
7245 * to handle hot plug insertion. In this interrupt handler, just do nothing
7246 * but print some log message and clear the bit.
7247 */
7248 static int
7251 {
7252 #if AHCI_DEBUG
7254 #endif
7258 #if AHCI_DEBUG
7263 "ahci_intr_port_connect_change: port %d, "
7265 #endif
7267 /* Clear PxSERR.DIAG.X to clear the interrupt bit */
7270 SERROR_EXCHANGED_ERR);
7275 }
7277 /*
7278 * Hot Plug Operation for platforms that support Mechanical Presence
7279 * Switches.
7280 *
7281 * When set, it indicates that a mechanical presence switch attached to this
7282 * port has been opened or closed, which may lead to a change in the connection
7283 * state of the device. This bit is only valid if both CAP.SMPS and PxCMD.MPSP
7284 * are set to '1'.
7285 *
7286 * At the moment, this interrupt is not needed and disabled and we just log
7287 * the debug message.
7288 */
7289 static int
7292 {
7296 "ahci_intr_device_mechanical_presence_status enter, "
7309 "CAP.SMPS or PxCMD.MPSP is not set, so just ignore "
7310 "the interrupt: cap_status = 0x%x, "
7315 }
7317 #if AHCI_DEBUG
7320 "The mechanical presence switch is open: "
7325 "The mechanical presence switch is close: "
7328 }
7329 #endif
7334 }
7336 /*
7337 * Native Hot Plug Support.
7338 *
7339 * When set, it indicates that the internal PHYRDY signal changed state.
7340 * This bit reflects the state of PxSERR.DIAG.N.
7341 *
7342 * There are three kinds of conditions to generate this interrupt event:
7343 * 1. a device is inserted
7344 * 2. a device is disconnected
7345 * 3. when the link enters/exits a Partial or Slumber interface power
7346 * management state
7347 *
7348 * If inteface power management is enabled for a port, the PxSERR.DIAG.N
7349 * bit may be set due to the link entering the Partial or Slumber power
7350 * management state, rather than due to a hot plug insertion or removal
7351 * event. So far, the interface power management is disabled, so the
7352 * driver can reliably get removal detection notification via the
7353 * PxSERR.DIAG.N bit.
7354 */
7355 static int
7358 {
7360 sata_device_t sdevice;
7363 ahci_addr_t port_addr;
7368 /* Clear PxSERR.DIAG.N to clear the interrupt bit */
7372 SERROR_PHY_RDY_CHG);
7378 /* The whole controller setup is not yet done. */
7381 }
7386 /* SStatus tells the presence of device. */
7392 }
7396 }
7401 "ahci_intr_phyrdy_change: port %d "
7405 }
7419 /* Things are fine now. The loss was temporary. */
7421 "ahci_intr_phyrdy_change port %d "
7433 "ahci_intr_phyrdy_change: port %d "
7436 /*
7437 * A new device has been detected. The new device
7438 * might be a port multiplier instead of a drive, so
7439 * we cannot update the signature directly.
7440 */
7444 /* Try to start the port */
7449 "ahci_intr_phyrdy_change: port %d failed "
7451 }
7453 /* Clear the max queue depth for inserted device */
7460 SATA_EVNT_LINK_ESTABLISHED);
7463 }
7468 "ahci_intr_phyrdy_change: port %d "
7476 SATA_DTYPE_PMULT) {
7478 }
7480 /* An existing device is lost. */
7488 SATA_EVNT_LINK_LOST);
7490 }
7491 }
7497 }
7499 /*
7500 * PxIS.UFS - Unknown FIS Error
7501 *
7502 * This interrupt event means an unknown FIS was received and has been
7503 * copied into system memory. An unknown FIS is not considered an illegal
7504 * FIS, unless the length received is more than 64 bytes. If an unknown
7505 * FIS arrives with length <= 64 bytes, it is posted and the HBA continues
7506 * normal operation. If the unknown FIS is more than 64 bytes, then it
7507 * won't be posted to memory and PxSERR.ERR.P will be set, which is then
7508 * a fatal error.
7509 *
7510 * PxIS.IPMS - Incorrect Port Multiplier Status
7511 *
7512 * IPMS Indicates that the HBA received a FIS from a device that did not
7513 * have a command outstanding. The IPMS bit may be set during enumeration
7514 * of devices on a Port Multiplier due to the normal Port Multiplier
7515 * enumeration process. It is recommended that IPMS only be used after
7516 * enumeration is complete on the Port Multiplier (copied from spec).
7517 *
7518 * PxIS.OFS - Overflow Error
7519 *
7520 * Command list overflow is defined as software building a command table
7521 * that has fewer total bytes than the transaction given to the device.
7522 * On device writes, the HBA will run out of data, and on reads, there
7523 * will be no room to put the data.
7524 *
7525 * For an overflow on data read, either PIO or DMA, the HBA will set
7526 * PxIS.OFS, and the HBA will do a best effort to continue, and it's a
7527 * non-fatal error when the HBA can continues. Sometimes, it will cause
7528 * a fatal error and need the software to do something.
7529 *
7530 * For an overflow on data write, setting PxIS.OFS is optional for both
7531 * DMA and PIO, and it's a fatal error, and a COMRESET is required by
7532 * software to clean up from this serious error.
7533 *
7534 * PxIS.INFS - Interface Non-Fatal Error
7535 *
7536 * This interrupt event indicates that the HBA encountered an error on
7537 * the Serial ATA interface but was able to continue operation. The kind
7538 * of error usually occurred during a non-Data FIS, and under this condition
7539 * the FIS will be re-transmitted by HBA automatically.
7540 *
7541 * When the FMA is implemented, there should be a stat structure to
7542 * record how many every kind of error happens.
7543 */
7544 static int
7547 {
7549 #if AHCI_DEBUG
7558 #endif
7566 "ahci_intr_non_fatal_error: port %d, "
7575 /* Clear the interrupt bit by clearing PxSERR.DIAG.F */
7578 SERROR_FIS_TYPE);
7579 }
7581 #if AHCI_DEBUG
7585 }
7590 }
7595 }
7597 /*
7598 * Record the error occurred command's slot.
7599 */
7606 AHCI_CMD_STATUS_CCS_SHIFT;
7614 }
7618 "ahci_intr_non_fatal_error: pending_tags = 0x%x "
7623 "ahci_intr_non_fatal_error: port %d, "
7627 /*
7628 * PRD Byte Count field of command header is not
7629 * required to reflect the total number of bytes
7630 * transferred when an overflow occurs, so here
7631 * just log the value.
7632 */
7633 cmd_dmacount =
7639 "ahci_intr_non_fatal_error: port %d, "
7640 "PRD Byte Count = 0x%x, "
7643 cmd_dmacount);
7644 }
7645 }
7647 /*
7648 * For queued command, list those command which have already
7649 * been transmitted to the device and still not completed.
7650 */
7658 "ahci_intr_non_fatal_error: pending_ncq_tags = 0x%x "
7671 }
7676 "port %d, satapkt 0x%p is outstanding when "
7680 }
7681 }
7682 out:
7683 #endif
7687 }
7689 /*
7690 * According to the AHCI spec, the error types include system memory
7691 * errors, interface errors, port multiplier errors, device errors,
7692 * command list overflow, command list underflow, native command
7693 * queuing tag errors and pio data transfer errors.
7694 *
7695 * System memory errors such as target abort, master abort, and parity
7696 * may cause the host to stop, and they are serious errors and needed
7697 * to be recovered with software intervention. When system software
7698 * has given a pointer to the HBA that doesn't exist in physical memory,
7699 * a master/target abort error occurs, and PxIS.HBFS will be set. A
7700 * data error such as CRC or parity occurs, the HBA aborts the transfer
7701 * (if necessary) and PxIS.HBDS will be set.
7702 *
7703 * Interface errors are errors that occur due to electrical issues on
7704 * the interface, or protocol miscommunication between the device and
7705 * HBA, and the respective PxSERR register bit will be set. And PxIS.IFS
7706 * (fatal) or PxIS.INFS (non-fatal) will be set. The conditions that
7707 * causes PxIS.IFS/PxIS.INFS to be set are
7708 * 1. in PxSERR.ERR, P bit is set to '1'
7709 * 2. in PxSERR.DIAG, C or H bit is set to '1'
7710 * 3. PhyRdy drop unexpectly, N bit is set to '1'
7711 * If the error occurred during a non-data FIS, the FIS must be
7712 * retransmitted, and the error is non-fatal and PxIS.INFS is set. If
7713 * the error occurred during a data FIS, the transfer will stop, so
7714 * the error is fatal and PxIS.IFS is set.
7715 *
7716 * When a FIS arrives that updates the taskfile, the HBA checks to see
7717 * if PxTFD.STS.ERR is set. If yes, PxIS.TFES will be set and the HBA
7718 * stops processing any more commands.
7719 *
7720 * Command list overflow is defined as software building a command table
7721 * that has fewer total bytes than the transaction given to the device.
7722 * On device writes, the HBA will run out of data, and on reads, there
7723 * will be no room to put the data. For an overflow on data read, either
7724 * PIO or DMA, the HBA will set PxIS.OFS, and it's a non-fatal error.
7725 * For an overflow on data write, setting PxIS.OFS is optional for both
7726 * DMA and PIO, and a COMRESET is required by software to clean up from
7727 * this serious error.
7728 *
7729 * Command list underflow is defined as software building a command
7730 * table that has more total bytes than the transaction given to the
7731 * device. For data writes, both PIO and DMA, the device will detect
7732 * an error and end the transfer. And these errors are most likely going
7733 * to be fatal errors that will cause the port to be restarted. For
7734 * data reads, the HBA updates its PRD byte count, and may be
7735 * able to continue normally, but is not required to. And The HBA is
7736 * not required to detect underflow conditions for native command
7737 * queuing command.
7738 *
7739 * The HBA does not actively check incoming DMA Setup FISes to ensure
7740 * that the PxSACT register bit for that slot is set. Existing error
7741 * mechanisms, such as host bus failure, or bad protocol, are used to
7742 * recover from this case.
7743 *
7744 * In accordance with Serial ATA 1.0a, DATA FISes prior to the final
7745 * DATA FIS must be an integral number of Dwords. If the HBA receives
7746 * a request which is not an integral number of Dwords, the HBA
7747 * set PxSERR.ERR.P to '1', set PxIS.IFS to '1' and stop running until
7748 * software restarts the port. And the HBA ensures that the size
7749 * of the DATA FIS received during a PIO command matches the size in
7750 * the Transfer Cound field of the preceding PIO Setup FIS, if not, the
7751 * HBA sets PxSERR.ERR.P to '1', set PxIS.IFS to '1', and then
7752 * stop running until software restarts the port.
7753 */
7754 /*
7755 * the fatal errors include PxIS.IFS, PxIS.HBDS, PxIS.HBFS and PxIS.TFES.
7756 *
7757 * PxIS.IFS indicates that the hba encountered an error on the serial ata
7758 * interface which caused the transfer to stop.
7759 *
7760 * PxIS.HBDS indicates that the hba encountered a data error
7761 * (uncorrectable ecc/parity) when reading from or writing to system memory.
7762 *
7763 * PxIS.HBFS indicates that the hba encountered a host bus error that it
7764 * cannot recover from, such as a bad software pointer.
7765 *
7766 * PxIS.TFES is set whenever the status register is updated by the device
7767 * and the error bit (bit 0) is set.
7768 */
7769 static int
7772 {
7787 /*
7788 * ahci_intr_phyrdy_change() may have rendered it to
7789 * SATA_DTYPE_NONE.
7790 */
7793 "ahci_intr_fatal_error: port %d no device attached, "
7796 }
7802 "ahci_intr_fatal_error: port %d "
7810 }
7812 /*
7813 * Here we just log the fatal error info in interrupt context.
7814 * Misc recovery processing will be handled in task queue.
7815 */
7818 /*
7819 * Read PxCMD.CCS to determine the slot that the HBA
7820 * was processing when the error occurred.
7821 */
7826 AHCI_CMD_STATUS_CCS_SHIFT;
7831 "ahci_intr_fatal_error: spkt 0x%p is being "
7835 /*
7836 * Won't emit the error message if it is an IDENTIFY
7837 * DEVICE command sent to an ATAPI device.
7838 */
7841 SATAC_ID_DEVICE) &&
7845 /*
7846 * Won't emit the error message if it is an ATAPI PACKET
7847 * command
7848 */
7859 }
7860 }
7862 /* print the fatal error type */
7869 /* print PxSERR related error message */
7872 /* print task file register value */
7880 }
7881 }
7883 out1:
7884 /* Prepare the argument for the taskq */
7891 /* Start the taskq to handle error recovery */
7893 ahci_events_handler,
7898 }
7899 out0:
7903 }
7905 /*
7906 * Hot Plug Operation for platforms that support Cold Presence Detect.
7907 *
7908 * When set, a device status has changed as detected by the cold presence
7909 * detect logic. This bit can either be set due to a non-connected port
7910 * receiving a device, or a connected port having its device removed.
7911 * This bit is only valid if the port supports cold presence detect as
7912 * indicated by PxCMD.CPD set to '1'.
7913 *
7914 * At the moment, this interrupt is not needed and disabled and we just
7915 * log the debug message.
7916 */
7917 static int
7920 {
7922 sata_device_t sdevice;
7933 "port %d does not support cold presence detect, so "
7937 }
7955 SATA_EVNT_DEVICE_ATTACHED);
7965 SATA_EVNT_DEVICE_DETACHED);
7967 }
7972 }
7974 /*
7975 * Enable the interrupts for a particular port.
7976 */
7977 static void
7979 {
7985 /*
7986 * Clear port interrupt status before enabling interrupt
7987 */
7990 AHCI_PORT_INTR_MASK);
7992 /*
7993 * Clear the pending bit from IS.IPS
7994 */
7998 /*
7999 * Enable the following interrupts:
8000 * Device to Host Register FIS Interrupt (DHRS)
8001 * PIO Setup FIS Interrupt (PSS)
8002 * Set Device Bits Interrupt (SDBS)
8003 * Unknown FIS Interrupt (UFS)
8004 * Port Connect Change Status (PCS)
8005 * PhyRdy Change Status (PRCS)
8006 * Overflow Status (OFS)
8007 * Interface Non-fatal Error Status (INFS)
8008 * Interface Fatal Error Status (IFS)
8009 * Host Bus Data Error Status (HBDS)
8010 * Host Bus Fatal Error Status (HBFS)
8011 * Task File Error Status (TFES)
8012 */
8016 AHCI_INTR_STATUS_PSS |
8017 AHCI_INTR_STATUS_SDBS |
8018 AHCI_INTR_STATUS_UFS |
8019 AHCI_INTR_STATUS_DPS |
8020 AHCI_INTR_STATUS_PCS |
8021 AHCI_INTR_STATUS_PRCS |
8022 AHCI_INTR_STATUS_OFS |
8023 AHCI_INTR_STATUS_INFS |
8024 AHCI_INTR_STATUS_IFS |
8025 AHCI_INTR_STATUS_HBDS |
8026 AHCI_INTR_STATUS_HBFS |
8027 AHCI_INTR_STATUS_TFES));
8028 }
8030 /*
8031 * Enable interrupts for all the ports.
8032 */
8033 static void
8035 {
8049 }
8051 /*
8052 * Disable interrupts for a particular port.
8053 */
8054 static void
8056 {
8065 }
8067 /*
8068 * Disable interrupts for the whole HBA.
8069 *
8070 * The global bit is cleared, then all interrupt sources from all
8071 * ports are disabled.
8072 */
8073 static void
8075 {
8082 NULL);
8091 }
8093 /*
8094 * Handle FIXED or MSI interrupts.
8095 */
8096 /*
8097 * According to AHCI spec, the HBA may support several interrupt modes:
8098 * * pin based interrupts (FIXED)
8099 * * single MSI message interrupts
8100 * * multiple MSI based message interrupts
8101 *
8102 * For pin based interrupts, the software interrupt handler need to check IS
8103 * register to find out which port has pending interrupts. And then check
8104 * PxIS register to find out which interrupt events happened on that port.
8105 *
8106 * For single MSI message interrupts, MSICAP.MC.MSIE is set with '1', and
8107 * MSICAP.MC.MME is set with '0'. This mode is similar to pin based interrupts
8108 * in that software interrupt handler need to check IS register to determine
8109 * which port triggered the interrupts since it uses a single message for all
8110 * port interrupts.
8111 *
8112 * HBA may optionally support multiple MSI message for better performance. In
8113 * this mode, each port may have its own interrupt message, and thus generation
8114 * of interrupts is no longer controlled through the IS register. MSICAP.MC.MMC
8115 * represents a power-of-2 wrapper on the number of implemented ports, and
8116 * the mapping of ports to interrupts is done in a 1-1 relationship, up to the
8117 * maximum number of assigned interrupts. When the number of MSI messages
8118 * allocated is less than the number requested, then hardware may have two
8119 * implementation behaviors:
8120 * * assign each ports its own interrupt and then force all additional
8121 * ports to share the last interrupt message, and this condition is
8122 * indicated by clearing GHC.MRSM to '0'
8123 * * revert to single MSI mode, indicated by setting GHC.MRSM to '1'
8124 * When multiple-message MSI is enabled, hardware will still set IS register
8125 * as single message case. And this IS register may be used by software when
8126 * fewer than the requested number of messages is granted in order to determine
8127 * which port had the interrupt.
8128 *
8129 * Note: The current ahci driver only supports the first two interrupt modes:
8130 * pin based interrupts and single MSI message interrupts, and the reason
8131 * is indicated in below code.
8132 */
8133 static int
8135 {
8143 /* get number of interrupts. */
8147 "ddi_intr_get_nintrs() failed, "
8150 }
8152 /* get number of available interrupts. */
8156 "ddi_intr_get_navail() failed, "
8159 }
8161 #if AHCI_DEBUG
8166 }
8167 #endif
8169 /*
8170 * Note: So far Solaris restricts the maximum number of messages for
8171 * x86 to 2, that is avail is 2, so here we set the count with 1 to
8172 * force the driver to use single MSI message interrupt. In future if
8173 * Solaris remove the restriction, then we need to delete the below
8174 * code and try to use multiple interrupt routine to gain better
8175 * performance.
8176 */
8179 "force to use one interrupt routine though the "
8182 }
8184 /* Allocate an array of interrupt handles. */
8189 /* call ddi_intr_alloc(). */
8195 "ddi_intr_alloc() failed, rc %d count %d actual %d "
8200 }
8202 /* use interrupt count returned */
8203 #if AHCI_DEBUG
8207 }
8208 #endif
8212 /*
8213 * Get priority for first, assume remaining are all the same.
8214 */
8220 /* Free already allocated intr. */
8223 }
8228 }
8230 /* Test for high level interrupt. */
8235 /* Free already allocated intr. */
8238 }
8244 }
8246 /* Call ddi_intr_add_handler(). */
8253 /* Free already allocated intr. */
8257 }
8262 }
8263 }
8270 /* Free already allocated intr. */
8274 }
8279 }
8282 /* Call ddi_intr_block_enable() for MSI. */
8286 /* Call ddi_intr_enable() for FIXED or MSI non block enable. */
8290 }
8291 }
8294 }
8296 /*
8297 * Removes the registered interrupts irrespective of whether they
8298 * were legacy or MSI.
8299 *
8300 * NOTE: The controller interrupts must be disabled before calling
8301 * this routine.
8302 */
8303 static void
8305 {
8310 /* Disable all interrupts. */
8313 /* Call ddi_intr_block_disable(). */
8320 }
8321 }
8323 /* Call ddi_intr_remove_handler(). */
8328 }
8331 }
8333 /*
8334 * This routine tries to put port into P:NotRunning state by clearing
8335 * PxCMD.ST. HBA will clear PxCI to 0h, PxSACT to 0h, PxCMD.CCS to 0h
8336 * and PxCMD.CR to '0'.
8337 */
8338 static int
8341 {
8358 /* Wait until PxCMD.CR is cleared */
8361 port_cmd_status =
8367 "clearing port %d CMD.CR timeout, "
8369 port_cmd_status);
8370 /*
8371 * We are effectively timing out after 0.5 sec.
8372 * This value is specified in AHCI spec.
8373 */
8375 }
8377 /* Wait for 10 millisec */
8385 "ahci_put_port_into_notrunning_state: failed to clear "
8386 "PxCMD.CR to '0' after loop count: %d, and "
8391 "ahci_put_port_into_notrunning_state: succeeded to clear "
8392 "PxCMD.CR to '0' after loop count: %d, and "
8395 }
8396 }
8398 /*
8399 * First clear PxCMD.ST, and then check PxTFD. If both PxTFD.STS.BSY
8400 * and PxTFD.STS.DRQ cleared to '0', it means the device is in a
8401 * stable state, then set PxCMD.ST to '1' to start the port directly.
8402 * If PxTFD.STS.BSY or PxTFD.STS.DRQ is set to '1', then issue a
8403 * COMRESET to the device to put it in an idle state.
8404 *
8405 * The fifth argument returns whether the port reset is involved during
8406 * the process.
8407 *
8408 * The routine will be called under following scenarios:
8409 * + To reset the HBA
8410 * + To abort the packet(s)
8411 * + To reset the port
8412 * + To activate the port
8413 * + Fatal error recovery
8414 * + To abort the timeout packet(s)
8415 *
8416 * NOTES!!! During this procedure, PxSERR register will be cleared, and
8417 * according to the spec, the clearance of three bits will also clear
8418 * three interrupt status bits.
8419 * 1. PxSERR.DIAG.F will clear PxIS.UFS
8420 * 2. PxSERR.DIAG.X will clear PxIS.PCS
8421 * 3. PxSERR.DIAG.N will clear PxIS.PRCS
8422 *
8423 * Among these three interrupt events, the driver needs to take care of
8424 * PxIS.PRCS, which is the hot plug event. When the driver found out
8425 * a device was unplugged, it will call the interrupt handler.
8426 */
8427 static int
8430 {
8433 sata_device_t sdevice;
8435 ahci_addr_t addr_port;
8453 /* First clear PxCMD.ST */
8455 port);
8457 /*
8458 * If PxCMD.CR does not clear within a reasonable time, it
8459 * may assume the interface is in a hung condition and may
8460 * continue with issuing the port reset.
8461 */
8464 /* Then clear PxSERR */
8467 AHCI_SERROR_CLEAR_ALL);
8469 /* Then get PxTFD */
8473 /*
8474 * Check whether the device is in a stable status, if yes,
8475 * then start the port directly. However for ahci_tran_reset_dport,
8476 * we may have to perform a port reset.
8477 */
8482 reset:
8483 /*
8484 * If PxTFD.STS.BSY or PxTFD.STS.DRQ is set to '1', then issue
8485 * a COMRESET to the device
8486 */
8491 #ifdef AHCI_DEBUG
8495 port);
8496 #endif
8501 /* Indicate to the framework that a reset has happened. */
8505 /* Set the reset in progress flag */
8515 SATA_DSTATE_PWR_ACTIVE;
8521 SATA_EVNT_DEVICE_RESET);
8523 }
8529 }
8531 out:
8534 /* SStatus tells the presence of device. */
8540 }
8545 /* Check whether a hot plug event happened */
8548 "ahci_restart_port_wait_till_ready: port %d "
8552 "ahci_restart_port_wait_till_ready: port %d "
8559 }
8562 /* 0/1 -> 1 : device may change */
8563 /*
8564 * May be called by ahci_fatal_error_recovery_handler, so
8565 * don't issue software if the previous device is ATAPI.
8566 */
8570 /*
8571 * The COMRESET will make port multiplier enter legacy mode.
8572 * Issue a software reset to make it work again.
8573 */
8578 /*
8579 * Following codes are specific for the port multiplier
8580 */
8583 /* in case previous_dev_type is corrupt */
8587 }
8589 /* Device change: PMult -> Non-PMult */
8592 /*
8593 * This might happen because
8594 * 1. Software reset failed. Port multiplier is not correctly
8595 * enumerated.
8596 * 2. Another non-port-multiplier device is attached. Perhaps
8597 * the port multiplier was replaced by another device by
8598 * whatever reason, but AHCI driver missed hot-plug event.
8599 *
8600 * Now that the port has been initialized, we just need to
8601 * update the port structure according new device, then report
8602 * and wait SATA framework to probe new device.
8603 */
8605 /* Force to release pmult resource */
8616 SATA_DSTATE_PWR_ACTIVE;
8622 SATA_EVNT_DEVICE_RESET);
8631 }
8633 /* Device change: Non-PMult -> PMult */
8636 /* NOTE: The PxCMD.PMA may be cleared by HBA reset. */
8640 }
8644 /* Device (may) change: PMult -> PMult */
8645 /*
8646 * First initialize port multiplier. Set state to READY and wait for
8647 * probe entry point to initialize it
8648 */
8651 /*
8652 * It's a little complicated while target is a port multiplier. we
8653 * need to COMRESET all pmports behind that PMult otherwise those
8654 * sub-links between the PMult and the sub-devices will be in an
8655 * inactive state (indicated by PSCR0/PxSSTS) and the following access
8656 * to those sub-devices will be rejected by Link-Fatal-Error.
8657 */
8658 /*
8659 * The PxSNTF will be set soon after the pmult is plugged. While the
8660 * pmult itself is attaching, sata_hba_event_notfiy will fail. so we
8661 * simply mark every sub-port as 'unknown', then ahci_probe_pmport
8662 * will initialized it.
8663 */
8667 /* Report reset event. */
8676 SATA_EVNT_DEVICE_RESET);
8679 }
8681 /*
8682 * This routine may be called under four scenarios:
8683 * a) do the recovery from fatal error
8684 * b) or we need to timeout some commands
8685 * c) or we need to abort some commands
8686 * d) or we need reset device/port/controller
8687 *
8688 * In all these scenarios, we need to send any pending unfinished
8689 * commands up to sata framework.
8690 */
8691 static void
8699 {
8715 "ahci_mop_commands: failed_tags: 0x%x, "
8716 "timeout_tags: 0x%x aborted_tags: 0x%x, "
8720 #ifdef AHCI_DEBUG
8727 else
8729 }
8736 }
8737 #endif
8762 /*
8763 * When AHCI_PORT_FLAG_RQSENSE or AHCI_PORT_FLAG_RDLOGEXT is
8764 * set, it means REQUEST SENSE or READ LOG EXT command doesn't
8765 * complete successfully due to one of the following three
8766 * conditions:
8767 *
8768 * 1. Fatal error - failed_tags includes its slot
8769 * 2. Timed out - timeout_tags includes its slot
8770 * 3. Aborted when hot unplug - aborted_tags includes its
8771 * slot
8772 *
8773 * Please note that the command is always sent down in Slot 0
8774 */
8777 "ahci_mop_commands is called for port %d while "
8778 "REQUEST SENSE or READ LOG EXT for error retrieval "
8786 "ahci_mop_commands is called for port %d while "
8791 }
8793 #ifdef AHCI_DEBUG
8795 "ahci_mop_commands: finished_tags: 0x%x, "
8797 #endif
8799 /* Send up finished packets with SATA_PKT_COMPLETED */
8804 }
8813 /*
8814 * Cannot fetch the return register content since the port
8815 * was restarted, so the corresponding tag will be set to
8816 * aborted tags.
8817 */
8822 }
8826 tmp_slot);
8832 }
8834 /* Send up failed packets with SATA_PKT_DEV_ERROR. */
8846 }
8851 "ahci_mop_commands: sending up "
8856 }
8861 }
8872 tmp_slot);
8878 }
8880 /* Send up timeout packets with SATA_PKT_TIMEOUT. */
8892 }
8897 "ahci_mop_commands: sending up "
8902 }
8907 }
8918 tmp_slot);
8924 }
8926 /* Send up aborted packets with SATA_PKT_ABORTED */
8938 }
8944 "ahci_mop_commands: sending up "
8949 }
8954 }
8965 tmp_slot);
8971 }
8973 /* Send up reset packets with SATA_PKT_RESET. */
8980 "ahci_mop_commands: sending up "
8985 }
8990 }
9001 tmp_slot);
9007 }
9009 /* Send up unfinished packets with SATA_PKT_RESET */
9014 }
9025 tmp_slot);
9031 }
9040 }
9042 /*
9043 * This routine is going to first request a READ LOG EXT sata pkt from sata
9044 * module, and then deliver it to the HBA to get the ncq failure context.
9045 * The return value is the exactly failed tags.
9046 */
9047 static uint32_t
9050 {
9051 sata_device_t sdevice;
9053 ddi_dma_handle_t buf_dma_handle;
9054 ahci_addr_t addr;
9064 /* Prepare the sdevice data */
9071 /* Translate sata_device.satadev_addr -> ahci_addr */
9074 /*
9075 * Call the sata hba interface to get a rdlog spkt
9076 */
9078 loop:
9083 /* Sleep for a while */
9086 }
9087 /* Timed out after 1s */
9091 }
9095 /*
9096 * This flag is used to handle the specific error recovery when the
9097 * READ LOG EXT command gets a failure (fatal error or time-out).
9098 */
9101 /*
9102 * This start is not supposed to fail because after port is restarted,
9103 * the whole command list is empty.
9104 */
9109 /* Remove the flag after READ LOG EXT command is completed */
9113 /* Update the request log data */
9117 DDI_DMA_SYNC_FORKERNEL);
9119 ncq_err_page =
9123 /* Get the failed tag */
9126 "ahci_get_rdlogext_data: port %d "
9132 }
9143 }
9147 /* Fill out the error context */
9149 ncq_err_page);
9152 }
9153 }
9154 out:
9158 }
9160 /*
9161 * This routine is going to first request a REQUEST SENSE sata pkt from sata
9162 * module, and then deliver it to the HBA to get the sense data and copy
9163 * the sense data back to the orignal failed sata pkt, and free the REQUEST
9164 * SENSE sata pkt later.
9165 */
9166 static void
9169 {
9170 sata_device_t sdevice;
9173 ddi_dma_handle_t buf_dma_handle;
9174 ahci_addr_t addr;
9176 #if AHCI_DEBUG
9178 #endif
9183 /* Prepare the sdevice data */
9190 /* Translate sata_device.satadev_addr -> ahci_addr */
9195 /*
9196 * Call the sata hba interface to get a rs spkt
9197 */
9199 loop:
9204 /* Sleep for a while */
9208 }
9209 /* Timed out after 1s */
9213 }
9217 /*
9218 * This flag is used to handle the specific error recovery when the
9219 * REQUEST SENSE command gets a faiure (fatal error or time-out).
9220 */
9223 /*
9224 * This start is not supposed to fail because after port is restarted,
9225 * the whole command list is empty.
9226 */
9231 /* Remove the flag after REQUEST SENSE command is completed */
9235 /* Update the request sense data */
9239 DDI_DMA_SYNC_FORKERNEL);
9240 /* Copy the request sense data */
9244 SATA_ATAPI_MIN_RQSENSE_LEN);
9245 #if AHCI_DEBUG
9249 /* Dump the sense data */
9255 " es_code 0x%x es_class 0x%x "
9256 "es_key 0x%x es_add_code 0x%x "
9261 #endif
9262 }
9265 }
9267 /*
9268 * Fatal errors will cause the HBA to enter the ERR: Fatal state. To recover,
9269 * the port must be restarted. When the HBA detects thus error, it may try
9270 * to abort a transfer. And if the transfer was aborted, the device is
9271 * expected to send a D2H Register FIS with PxTFD.STS.ERR set to '1' and both
9272 * PxTFD.STS.BSY and PxTFD.STS.DRQ cleared to '0'. Then system software knows
9273 * that the device is in a stable status and transfers may be restarted without
9274 * issuing a COMRESET to the device. If PxTFD.STS.BSY or PxTFD.STS.DRQ is set,
9275 * then the software will send the COMRESET to do the port reset.
9276 *
9277 * Software should perform the appropriate error recovery actions based on
9278 * whether non-queued commands were being issued or natived command queuing
9279 * commands were being issued.
9280 *
9281 * And software will complete the command that had the error with error mark
9282 * to higher level software.
9283 *
9284 * Fatal errors include the following:
9285 * PxIS.IFS - Interface Fatal Error Status
9286 * PxIS.HBDS - Host Bus Data Error Status
9287 * PxIS.HBFS - Host Bus Fatal Error Status
9288 * PxIS.TFES - Task File Error Status
9289 */
9290 static void
9293 {
9302 #if AHCI_DEBUG
9304 #endif
9314 /* Port multiplier error */
9316 /* FBS code is neither completed nor tested. */
9320 /* Force a port reset */
9322 }
9327 /* Read PxCI to see which commands are still outstanding */
9331 /*
9332 * Read PxCMD.CCS to determine the slot that the HBA
9333 * was processing when the error occurred.
9334 */
9338 AHCI_CMD_STATUS_CCS_SHIFT;
9346 /* May happen when interface errors occur? */
9348 }
9349 }
9351 #if AHCI_DEBUG
9352 /*
9353 * Debugging purpose...
9354 */
9356 cmd_header =
9359 "ahci_fatal_error_recovery_handler: port %d, "
9360 "PRD Byte Count = 0x%x, "
9364 }
9365 #endif
9369 /* Fill out the status and error registers for PxIS.TFES */
9372 ahcirf_d2h_register_fis);
9374 /* Copy the error context back to the sata_cmd */
9376 }
9378 /* The failed command must be one of the outstanding commands */
9382 /* Update the sata registers, especially PxSERR register */
9387 /* Read PxSACT to see which commands are still outstanding */
9390 }
9391 next:
9393 #if AHCI_DEBUG
9394 /*
9395 * When AHCI_PORT_FLAG_RQSENSE or AHCI_PORT_FLAG_RDLOGEXT flag is
9396 * set, it means a fatal error happened after REQUEST SENSE command
9397 * or READ LOG EXT command is delivered to the HBA during the error
9398 * recovery process. At this time, the only outstanding command is
9399 * supposed to be REQUEST SENSE command or READ LOG EXT command.
9400 */
9403 "ahci_fatal_error_recovery_handler: port %d REQUEST SENSE "
9404 "command or READ LOG EXT command for error data retrieval "
9409 SCMD_REQUEST_SENSE ||
9411 SATAC_READ_LOG_EXT);
9412 }
9413 #endif
9426 else
9429 }
9431 /*
9432 * Won't retrieve error information:
9433 * 1. Port reset was involved to recover
9434 * 2. Device is gone
9435 * 3. IDENTIFY DEVICE command sent to ATAPI device
9436 * 4. REQUEST SENSE or READ LOG EXT command during error recovery
9437 */
9444 /*
9445 * Deliver READ LOG EXT to gather information about the error when
9446 * a COMRESET has not been performed as part of the error recovery
9447 * during NCQ command processing.
9448 */
9453 }
9455 /*
9456 * Deliver REQUEST SENSE for ATAPI command to gather information about
9457 * the error when a COMRESET has not been performed as part of the
9458 * error recovery.
9459 */
9462 out:
9464 "ahci_fatal_error_recovery_handler: port %d fatal error "
9465 "occurred slot_status = 0x%x, pending_tags = 0x%x, "
9471 ahci_portp,
9472 slot_status,
9477 }
9479 /*
9480 * Used to recovery a PMULT pmport fatal error under FIS-based switching.
9481 * 1. device specific.PxFBS.SDE=1
9482 * 2. Non-Deivce specific.
9483 * Nothing will be done when Command-based switching is employed.
9484 *
9485 * Currently code is neither completed nor tested.
9486 */
9487 static void
9490 {
9491 #ifndef __lock_lint
9493 #endif
9496 ahci_addr_t addr;
9500 /* Nothing will be done under Command-based switching. */
9508 /* FBS is not enabled. */
9511 /* Problem's getting complicated now. */
9512 /*
9513 * If FIS-based switching is used, we need to check
9514 * the PxFBS to see the error type.
9515 */
9519 /* Refer to spec(v1.2) 9.3.6.1 */
9523 /*
9524 * Controller has paused commands for all other
9525 * sub-devices until PxFBS.DEC is set.
9526 */
9534 /*
9535 * Wait controller clear PxFBS.DEC,
9536 * then we can continue.
9537 */
9545 /*
9546 * Esclate the error. Follow
9547 * non-device specific error
9548 * procedure.
9549 */
9555 /*
9556 * Issue a software reset to ensure drive is in
9557 * a known state.
9558 */
9564 /* Process Non-Device Specific Error. */
9565 /* This will be handled later on. */
9567 }
9568 }
9569 /*
9570 * Handle events - fatal error recovery
9571 */
9572 static void
9574 {
9596 /*
9597 * ahci_intr_phyrdy_change() may have rendered it to
9598 * SATA_DTYPE_NONE.
9599 */
9602 "ahci_events_handler: port %d no device attached, "
9610 }
9613 }
9616 AHCI_INTR_STATUS_HBDS |
9617 AHCI_INTR_STATUS_HBFS |
9618 AHCI_INTR_STATUS_TFES))
9622 out:
9624 }
9626 /*
9627 * ahci_watchdog_handler() and ahci_do_sync_start will call us if they
9628 * detect there are some commands which are timed out.
9629 */
9630 static void
9633 {
9646 /* Read PxCI to see which commands are still outstanding */
9650 /* Read PxSACT to see which commands are still outstanding */
9653 }
9655 #if AHCI_DEBUG
9656 /*
9657 * When AHCI_PORT_FLAG_RQSENSE or AHCI_PORT_FLAG_RDLOGEXT flag is
9658 * set, it means a fatal error happened after REQUEST SENSE command
9659 * or READ LOG EXT command is delivered to the HBA during the error
9660 * recovery process. At this time, the only outstanding command is
9661 * supposed to be REQUEST SENSE command or READ LOG EXT command.
9662 */
9665 "ahci_timeout_pkts called while REQUEST SENSE "
9666 "command or READ LOG EXT command for error recovery "
9667 "timed out timeout_tags = 0x%x, slot_status = 0x%x, "
9675 "ahci_timeout_pkts called while executing R/W PMULT "
9679 }
9680 #endif
9688 /*
9689 * Re-identify timeout tags because some previously checked commands
9690 * could already complete.
9691 */
9698 "ahci_timeout_pkts: port %d, finished_tags = 0x%x, "
9699 "timeout_tags = 0x%x, port_cmd_issue = 0x%x, "
9709 "ahci_timeout_pkts: port %d, finished_tags = 0x%x, "
9710 "timeout_tags = 0x%x, port_sactive = 0x%x, "
9717 }
9720 ahci_portp,
9721 slot_status,
9728 }
9730 /*
9731 * Watchdog handler kicks in every 5 seconds to timeout any commands pending
9732 * for long time.
9733 */
9734 static void
9736 {
9757 }
9765 }
9767 /* Skip the check for those ports in error recovery */
9772 }
9783 current_slot =
9785 AHCI_CMD_STATUS_CCS_SHIFT;
9795 }
9802 }
9808 else
9813 /*
9814 * If a packet has survived for more than it's
9815 * max life cycles, it is a candidate for time
9816 * out.
9817 */
9819 ahci_watchdog_timeout;
9825 #if AHCI_DEBUG
9834 }
9835 #endif
9837 /*
9838 * We need to check whether the HBA has
9839 * begun to execute the command, if not,
9840 * then re-set the timer of the command.
9841 */
9846 ahci_portp->ahciport_slot_timeout \
9853 }
9854 }
9855 next:
9857 }
9866 }
9869 }
9871 /* Re-install the watchdog timeout handler */
9876 }
9879 }
9881 /*
9882 * Fill the error context into sata_cmd for non-queued command error.
9883 */
9884 static void
9886 {
9900 }
9901 }
9903 /*
9904 * Fill the ncq error page into sata_cmd for queued command error.
9905 */
9906 static void
9909 {
9921 }
9923 /*
9924 * Put the respective register value to sata_cmd_t for satacmd_flags.
9925 */
9926 static void
9928 {
9949 }
9951 static void
9954 {
9975 }
9977 static void
9980 {
9984 sata_cmd_t cmd;
9993 }
10000 "features_reg = 0x%x sec_count_msb = 0x%x "
10001 "lba_low_msb = 0x%x lba_mid_msb = 0x%x "
10002 "lba_high_msb = 0x%x sec_count_lsb = 0x%x "
10003 "lba_low_lsb = 0x%x lba_mid_lsb = 0x%x "
10004 "lba_high_lsb = 0x%x device_reg = 0x%x "
10015 }
10016 }
10018 /*
10019 * Dump the serror message to the log.
10020 */
10021 static void
10024 {
10035 }
10040 }
10045 }
10050 }
10054 }
10058 }
10062 }
10066 }
10070 }
10074 }
10078 }
10082 }
10086 }
10090 }
10095 }
10099 }
10103 }
10117 /* sata trace debug */
10124 /* sata trace debug */
10126 }
10127 }
10129 /*
10130 * Translate the sata_address_t type into the ahci_addr_t type.
10131 * sata_device.satadev_addr structure is used as source.
10132 */
10133 static void
10136 {
10157 /* something went wrong */
10160 }
10161 }
10163 /*
10164 * This routine is to calculate the total number of ports implemented
10165 * by the HBA.
10166 */
10167 static int
10169 {
10175 num++;
10176 }
10179 }
10181 #if AHCI_DEBUG
10182 static void
10184 {
10196 }
10204 }
10205 #endif
10207 /*
10208 * quiesce(9E) entry point.
10209 *
10210 * This function is called when the system is single-threaded at high
10211 * PIL with preemption disabled. Therefore, this function must not be
10212 * blocked.
10213 *
10214 * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure.
10215 * DDI_FAILURE indicates an error condition and should almost never happen.
10216 */
10217 static int
10219 {
10230 #if AHCI_DEBUG
10232 #endif
10236 /* disable all the interrupts. */
10242 }
10246 /*
10247 * Stop the port by clearing PxCMD.ST
10248 *
10249 * Here we must disable the port interrupt because
10250 * ahci_disable_all_intrs only clear GHC.IE, and IS
10251 * register will be still set if PxIE is enabled.
10252 * When ahci shares one IRQ with other drivers, the
10253 * intr handler may claim the intr mistakenly.
10254 */
10258 }
10263 }
10265 /*
10266 * The function will add a sata packet to the done queue.
10267 */
10268 static void
10270 {
10274 /* set the reason for all packets */
10280 /*
10281 * only add to queue when mode is not synch and there is
10282 * completion callback
10283 */
10291 /*
10292 * for sync/non-poll mode, just call cv_broadcast
10293 */
10295 }
10297 /*
10298 * The function will call completion callback of sata packet on the
10299 * completed queue
10300 */
10301 static void
10303 {
10321 /* Call the callback */
10325 }
10328 }
10329 }