| blob | fdd01e384e363d39b0ebf0114a1df68cbdf2dc56 |
1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2007 Emulex. All rights reserved. *
5 * EMULEX and SLI are trademarks of Emulex. *
6 * www.emulex.com *
7 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
8 * *
9 * This program is free software; you can redistribute it and/or *
10 * modify it under the terms of version 2 of the GNU General *
11 * Public License as published by the Free Software Foundation. *
12 * This program is distributed in the hope that it will be useful. *
13 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
14 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
15 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
16 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
17 * TO BE LEGALLY INVALID. See the GNU General Public License for *
18 * more details, a copy of which can be found in the file COPYING *
19 * included with this package. *
20 *******************************************************************/
22 #include <linux/blkdev.h>
23 #include <linux/pci.h>
24 #include <linux/interrupt.h>
25 #include <linux/delay.h>
27 #include <scsi/scsi.h>
28 #include <scsi/scsi_cmnd.h>
29 #include <scsi/scsi_device.h>
30 #include <scsi/scsi_host.h>
31 #include <scsi/scsi_transport_fc.h>
43 /*
44 * Define macro to log: Mailbox command x%x cannot issue Data
45 * This allows multiple uses of lpfc_msgBlk0311
46 * w/o perturbing log msg utility.
47 */
48 #define LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag) \
49 lpfc_printf_log(phba, \
50 KERN_INFO, \
51 LOG_MBOX | LOG_SLI, \
54 pmbox->vport ? pmbox->vport->vpi : 0, \
55 pmbox->mb.mbxCommand, \
56 phba->pport->port_state, \
57 psli->sli_flag, \
58 flag)
61 /* There are only four IOCB completion types. */
63 LPFC_UNKNOWN_IOCB,
64 LPFC_UNSOL_IOCB,
65 LPFC_SOL_IOCB,
66 LPFC_ABORT_IOCB
69 /* SLI-2/SLI-3 provide different sized iocbs. Given a pointer
70 * to the start of the ring, and the slot number of the
71 * desired iocb entry, calc a pointer to that entry.
72 */
75 {
78 }
82 {
85 }
89 {
95 }
99 {
107 }
109 static void
111 {
114 /*
115 * Clean all volatile data fields, preserve iotag and node struct.
116 */
119 }
121 void
123 {
126 /*
127 * Clean all volatile data fields, preserve iotag and node struct.
128 */
132 }
134 /*
135 * Translate the iocb command to an iocb command type used to decide the final
136 * disposition of each completed IOCB.
137 */
138 static lpfc_iocb_type
140 {
211 }
214 }
216 static int
218 {
234 "0446 Adapter failed to init (%d), "
235 "mbxCmd x%x CFG_RING, mbxStatus x%x, "
242 }
243 }
246 }
248 static int
251 {
259 else
262 }
266 }
270 {
277 }
281 {
297 "0315 Ring %d issue: portCmdGet %d "
303 /*
304 * All error attention handlers are posted to
305 * worker thread
306 */
310 /* hbalock should already be held */
315 }
319 }
322 }
324 uint16_t
326 {
346 GFP_KERNEL);
351 /* highly unprobable case */
360 }
363 }
376 }
385 }
387 static void
390 {
391 /*
392 * Set up an iotag
393 */
402 }
404 /*
405 * Issue iocb command to adapter
406 */
411 /*
412 * If there is no completion routine to call, we can release the
413 * IOCB buffer back right now. For IOCBs, like QUE_RING_BUF,
414 * that have no rsp ring completion, iocb_cmpl MUST be NULL.
415 */
418 else
421 /*
422 * Let the HBA know what IOCB slot will be the next one the
423 * driver will put a command into.
424 */
427 }
429 static void
431 {
438 /*
439 * Set ring 'ringno' to SET R0CE_REQ in Chip Att register.
440 * The HBA will tell us when an IOCB entry is available.
441 */
446 }
448 static void
450 {
453 /*
454 * Tell the HBA that there is work to do in this ring.
455 */
459 }
461 static void
463 {
467 /*
468 * Check to see if:
469 * (a) there is anything on the txq to send
470 * (b) link is up
471 * (c) link attention events can be processed (fcp ring only)
472 * (d) IOCB processing is not blocked by the outstanding mbox command.
473 */
485 else
487 }
490 }
494 {
510 "1802 HBQ %d: local_hbqGetIdx "
517 }
521 }
525 }
527 void
529 {
535 /* Return all memory used by all HBQs */
542 }
544 }
545 }
550 {
554 /* Get next HBQ entry slot to use */
565 /* Sync SLIM */
568 /* flush */
571 }
573 }
584 };
595 };
600 };
602 static int
604 {
610 }
616 }
618 /* Populate HBQ entries */
626 else
628 }
630 }
632 int
634 {
637 }
639 static int
641 {
644 }
648 {
661 }
662 }
667 }
669 void
671 {
678 }
679 }
680 }
682 static int
684 {
743 }
745 }
746 static void
748 {
752 /*
753 * If pdone_q is empty, the driver thread gave up waiting and
754 * continued running.
755 */
763 }
765 void
767 {
777 }
779 /*
780 * If a REG_LOGIN succeeded after node is destroyed or node
781 * is in re-discovery driver need to cleanup the RPI.
782 */
793 }
797 }
799 int
801 {
809 /* Get all completed mailboxe buffers into the cmplq */
814 /* Get a Mailbox buffer to setup mailbox commands for callback */
825 LPFC_DISC_TRC_MBOX_VPORT,
830 }
833 LPFC_DISC_TRC_MBOX,
838 }
839 }
841 /*
842 * It is a fatal error if unknown mbox command completion.
843 */
845 MBX_SHUTDOWN) {
846 /* Unknow mailbox command compl */
848 "(%d):0323 Unknown Mailbox command "
856 }
861 /* Mbox cmd cmpl error - RETRYing */
864 "(%d):0305 Mbox cmd cmpl "
865 "error - RETRYing Data: x%x "
880 }
881 }
883 /* Mailbox cmd <cmd> Cmpl <cmpl> */
885 "(%d):0307 Mailbox cmd x%x Cmpl x%p "
904 }
908 {
932 }
938 {
941 else
943 }
945 static int
948 {
963 else
965 KERN_WARNING,
966 LOG_SLI,
967 "0316 Ring %d handler: unexpected "
968 "ASYNC_STATUS iocb received evt_code "
973 }
981 KERN_ERR,
982 LOG_SLI,
983 "0341 Ring %d Cannot find buffer for "
987 }
993 KERN_ERR,
994 LOG_SLI,
995 "0342 Ring %d Cannot find buffer for an"
999 }
1007 KERN_ERR,
1008 LOG_SLI,
1009 "0343 Ring %d Cannot find "
1010 "buffer for an unsolicited iocb"
1013 }
1019 KERN_ERR,
1020 LOG_SLI,
1021 "0344 Ring %d Cannot find "
1022 "buffer for an unsolicited "
1026 }
1027 }
1028 }
1034 /* search continue save q for same XRI */
1040 }
1041 }
1051 }
1062 /* Firmware Workaround */
1070 }
1071 }
1073 /* unSolicited Responses */
1077 saveq);
1080 /* We must search, based on rctl / type
1081 for the right routine */
1090 }
1091 }
1092 }
1094 /* Unexpected Rctl / Type received */
1095 /* Ring <ringno> handler: unexpected
1096 Rctl <Rctl> Type <Type> received */
1098 "0313 Ring %d handler: unexpected Rctl x%x "
1101 }
1103 }
1109 {
1120 }
1123 "0317 iotag x%x is out off "
1128 }
1130 static int
1133 {
1138 /* Based on the iotag field, get the cmd IOCB from the txcmplq */
1145 /*
1146 * Post all ELS completions to the worker thread.
1147 * All other are passed to the completion callback.
1148 */
1154 IOSTAT_LOCAL_REJECT;
1156 IOERR_SLI_ABORTED;
1158 /* Firmware could still be in progress
1159 * of DMAing payload, so don't free data
1160 * buffer till after a hbeat.
1161 */
1163 }
1164 }
1169 /*
1170 * Unknown initiating command based on the response iotag.
1171 * This could be the case on the ELS ring because of
1172 * lpfc_els_abort().
1173 */
1175 /*
1176 * Ring <ringno> handler: unexpected completion IoTag
1177 * <IoTag>
1178 */
1180 "0322 Ring %d handler: "
1181 "unexpected completion IoTag x%x "
1189 }
1190 }
1193 }
1195 static void
1197 {
1201 /*
1202 * Ring <ringno> handler: portRspPut <portRspPut> is bigger then
1203 * rsp ring <portRspMax>
1204 */
1206 "0312 Ring %d handler: portRspPut %d "
1213 /*
1214 * All error attention handlers are posted to
1215 * worker thread
1216 */
1220 /* hbalock should already be held */
1225 }
1228 {
1250 /*
1251 * The next available response entry should never exceed the maximum
1252 * entries. If it does, treat it as an adapter hardware error.
1253 */
1259 }
1273 rsp_cmpl++;
1276 /* Rsp ring <ringno> error: IOCB */
1278 "0326 Rsp Ring %d error: IOCB Data: "
1289 }
1294 /*
1295 * Idle exchange closed via ABTS from port. No iocb
1296 * resources need to be recovered.
1297 */
1300 "0314 IOCB cmd 0x%x "
1301 "processed. Skipping "
1305 }
1314 }
1321 MAX_MSG_DATA);
1326 /* Unknown IOCB command */
1328 "0321 Unknown IOCB command "
1334 }
1336 }
1338 /*
1339 * The response IOCB has been processed. Update the ring
1340 * pointer in SLIM. If the port response put pointer has not
1341 * been updated, sync the pgp->rspPutInx and fetch the new port
1342 * response put pointer.
1343 */
1348 }
1360 }
1367 /* Force update of the local copy of cmdGetInx */
1375 }
1378 }
1380 /*
1381 * This routine presumes LPFC_FCP_RING handling and doesn't bother
1382 * to check it explicitly.
1383 */
1384 static int
1387 {
1398 lpfc_iocb_type type;
1405 /*
1406 * The next available response entry should never exceed the maximum
1407 * entries. If it does, treat it as an adapter hardware error.
1408 */
1415 }
1419 /*
1420 * Fetch an entry off the ring and copy it into a local data
1421 * structure. The copy involves a byte-swap since the
1422 * network byte order and pci byte orders are different.
1423 */
1438 rsp_cmpl++;
1441 /*
1442 * If resource errors reported from HBA, reduce
1443 * queuedepths of the SCSI device.
1444 */
1450 }
1452 /* Rsp ring <ringno> error: IOCB */
1454 "0336 Rsp Ring %d error: IOCB Data: "
1465 }
1470 /*
1471 * Idle exchange closed via ABTS from port. No iocb
1472 * resources need to be recovered.
1473 */
1476 "0333 IOCB cmd 0x%x"
1477 " processed. Skipping"
1481 }
1491 iflag);
1495 iflag);
1496 }
1497 }
1509 MAX_MSG_DATA);
1514 /* Unknown IOCB command */
1516 "0334 Unknown IOCB command "
1522 }
1524 }
1526 /*
1527 * The response IOCB has been processed. Update the ring
1528 * pointer in SLIM. If the port response put pointer has not
1529 * been updated, sync the pgp->rspPutInx and fetch the new port
1530 * response put pointer.
1531 */
1536 }
1543 }
1548 /* Force update of the local copy of cmdGetInx */
1555 }
1559 }
1561 int
1564 {
1575 lpfc_iocb_type type;
1584 /*
1585 * The next available response entry should never exceed the maximum
1586 * entries. If it does, treat it as an adapter hardware error.
1587 */
1591 /*
1592 * Ring <ringno> handler: portRspPut <portRspPut> is bigger then
1593 * rsp ring <portRspMax>
1594 */
1596 "0303 Ring %d handler: portRspPut %d "
1607 }
1611 /*
1612 * Build a completion list and call the appropriate handler.
1613 * The process is to get the next available response iocb, get
1614 * a free iocb from the list, copy the response data into the
1615 * free iocb, insert to the continuation list, and update the
1616 * next response index to slim. This process makes response
1617 * iocb's in the ring available to DMA as fast as possible but
1618 * pays a penalty for a copy operation. Since the iocb is
1619 * only 32 bytes, this penalty is considered small relative to
1620 * the PCI reads for register values and a slim write. When
1621 * the ulpLe field is set, the entire Command has been
1622 * received.
1623 */
1632 }
1647 }
1655 /*
1656 * By default, the driver expects to free all resources
1657 * associated with this iocb completion.
1658 */
1668 /*
1669 * If resource errors reported from HBA, reduce
1670 * queuedepths of the SCSI device.
1671 */
1677 }
1680 /* Rsp ring <ringno> error: IOCB */
1682 "0328 Rsp Ring %d error: "
1683 "IOCB Data: "
1684 "x%x x%x x%x x%x "
1685 "x%x x%x x%x x%x "
1686 "x%x x%x x%x x%x "
1705 }
1707 /*
1708 * Fetch the IOCB command type and call the correct
1709 * completion routine. Solicited and Unsolicited
1710 * IOCBs on the ELS ring get freed back to the
1711 * lpfc_iocb_list by the discovery kernel thread.
1712 */
1718 saveq);
1723 saveq);
1731 saveq)))) {
1732 /* Call the specified completion
1733 routine */
1737 iflag);
1742 iflag);
1745 cmdiocbp);
1746 }
1753 LPFC_MAX_ADPTMSG);
1755 MAX_MSG_DATA);
1760 /* Unknown IOCB command */
1762 "0335 Unknown IOCB "
1763 "command Data: x%x "
1769 }
1770 }
1777 rspiocbp);
1778 }
1780 }
1782 }
1784 /*
1785 * If the port response put pointer has not been updated, sync
1786 * the pgp->rspPutInx in the MAILBOX_tand fetch the new port
1787 * response put pointer.
1788 */
1791 }
1795 /* At least one response entry has been freed */
1797 /* SET RxRE_RSP in Chip Att register */
1801 }
1806 /* Force update of the local copy of cmdGetInx */
1813 }
1817 }
1819 void
1821 {
1828 }
1830 /* Error everything on txq and txcmplq
1831 * First do the txq.
1832 */
1837 /* Next issue ABTS for everything on the txcmplq */
1854 }
1855 }
1856 }
1858 int
1860 {
1865 /* Read the HBA Host Status Register */
1868 /*
1869 * Check status register every 100ms for 5 retries, then every
1870 * 500ms for 5, then every 2.5 sec for 5, then reset board and
1871 * every 2.5 sec for 4.
1872 * Break our of the loop if errors occurred during init.
1873 */
1882 else
1886 /* Do post */
1889 }
1890 /* Read the HBA Host Status Register */
1892 }
1894 /* Check to see if any errors occurred during init */
1898 }
1901 }
1903 #define BARRIER_TEST_PATTERN (0xdeadbeef)
1906 {
1920 /*
1921 * Tell the other part of the chip to suspend temporarily all
1922 * its DMA activity.
1923 */
1926 /* Disable the error attention */
1933 /* Clear Chip error bit */
1936 }
1954 else
1956 }
1962 clear_errat:
1970 }
1972 restore_hc:
1976 }
1978 int
1980 {
1990 /* Kill HBA */
1999 /* Disable the error attention */
2019 }
2025 /* There is no completion for a KILL_BOARD mbox cmd. Check for an error
2026 * attention every 100ms for 3 seconds. If we don't get ERATT after
2027 * 3 seconds we still set HBA_ERROR state because the status of the
2028 * board is now undefined.
2029 */
2035 }
2041 }
2052 }
2054 int
2056 {
2064 /* Reset HBA */
2069 /* perform board reset */
2074 /* Turn off parity checking and serr during the physical reset */
2081 /* Now toggle INITFF bit in the Host Control Register */
2088 /* Restore PCI cmd register */
2091 /* Initialize relevant SLI info */
2100 }
2104 }
2106 int
2108 {
2119 /* Restart HBA */
2135 /* Only skip post after fc_ffinit is completed */
2142 }
2158 else
2164 }
2166 static int
2168 {
2171 /* Read the HBA Host Status Register */
2174 /* Check status register to see what current state is */
2178 /* Check every 100ms for 5 retries, then every 500ms for 5, then
2179 * every 2.5 sec for 5, then reset board and every 2.5 sec for
2180 * 4.
2181 */
2183 /* Adapter failed to init, timeout, status reg
2184 <status> */
2186 "0436 Adapter failed to init, "
2187 "timeout, status reg x%x, "
2193 }
2195 /* Check to see if any errors occurred during init */
2197 /* ERROR: During chipset initialization */
2198 /* Adapter failed to init, chipset, status reg
2199 <status> */
2201 "0437 Adapter failed to init, "
2202 "chipset, status reg x%x, "
2208 }
2216 }
2219 /* Do post */
2222 }
2223 /* Read the HBA Host Status Register */
2225 }
2227 /* Check to see if any errors occurred during init */
2229 /* ERROR: During chipset initialization */
2230 /* Adapter failed to init, chipset, status reg <status> */
2232 "0438 Adapter failed to init, chipset, "
2233 "status reg x%x, "
2239 }
2241 /* Clear all interrupt enable conditions */
2245 /* setup host attn register */
2249 }
2251 int
2253 {
2255 }
2257 static int
2259 {
2267 }
2269 int
2271 {
2273 }
2275 static int
2277 {
2284 /* Get a Mailbox buffer to setup mailbox
2285 * commands for HBA initialization
2286 */
2294 /* Initialize the struct lpfc_sli_hbq structure for each hbq */
2309 /* Adapter failed to init, mbxCmd <cmd> CFG_RING,
2310 mbxStatus <status>, ring <num> */
2314 "1805 Adapter failed to init. "
2322 }
2323 }
2328 /* Initially populate or replenish the HBQs */
2332 }
2334 }
2336 static int
2338 {
2346 }
2363 resetcount++;
2365 /* Call pre CONFIG_PORT mailbox command initialization. A
2366 * value of 0 means the call was successful. Any other
2367 * nonzero value is a failure, but if ERESTART is returned,
2368 * the driver may reset the HBA and try again.
2369 */
2376 }
2383 "0442 Adapter failed to init, mbxCmd x%x "
2396 }
2397 }
2402 }
2408 }
2411 do_prep_failed:
2414 }
2416 int
2418 {
2426 "1824 NPIV enabled: Override lpfc_sli_mode "
2428 lpfc_sli_mode);
2430 }
2438 "1819 Unrecognized lpfc_sli_mode "
2442 }
2447 "1820 Unable to select SLI-3. "
2464 }
2474 /* Init HBQs */
2480 }
2490 lpfc_sli_hba_setup_error:
2495 }
2497 /*! lpfc_mbox_timeout
2498 *
2499 * \pre
2500 * \post
2501 * \param hba Pointer to per struct lpfc_hba structure
2502 * \param l1 Pointer to the driver's mailbox queue.
2503 * \return
2504 * void
2505 *
2506 * \b Description:
2507 *
2508 * This routine handles mailbox timeout events at timer interrupt context.
2509 */
2510 void
2512 {
2528 }
2529 }
2531 void
2533 {
2541 }
2543 /* Mbox cmd <mbxCommand> timeout */
2551 /* Setting state unknown so lpfc_sli_abort_iocb_ring
2552 * would get IOCB_ERROR from lpfc_sli_issue_iocb, allowing
2553 * it to fail all oustanding SCSI IO.
2554 */
2569 /*
2570 * lpfc_offline calls lpfc_sli_hba_down which will clean up
2571 * on oustanding mailbox commands.
2572 */
2573 /* If resets are disabled then set error state and return. */
2577 }
2585 }
2587 int
2589 {
2609 }
2610 }
2613 /* If the PCI channel is in offline state, do not post mbox. */
2627 /* Mbox command <mbxCommand> cannot issue */
2630 }
2637 }
2640 /* Polling for a mbox command when another one is already active
2641 * is not allowed in SLI. Also, the driver must have established
2642 * SLI2 mode to queue and process multiple mbox commands.
2643 */
2648 /* Mbox command <mbxCommand> cannot issue */
2651 }
2655 /* Mbox command <mbxCommand> cannot issue */
2658 }
2660 /* Another mailbox command is still being processed, queue this
2661 * command to be processed later.
2662 */
2665 /* Mbox cmd issue - BUSY */
2667 "(%d):0308 Mbox cmd issue - BUSY Data: "
2678 LPFC_DISC_TRC_MBOX_VPORT,
2682 }
2685 LPFC_DISC_TRC_MBOX,
2689 }
2692 }
2696 /* If we are not polling, we MUST be in SLI2 mode */
2702 /* Mbox command <mbxCommand> cannot issue */
2705 }
2706 /* timeout active mbox command */
2709 }
2711 /* Mailbox cmd <cmd> issue */
2713 "(%d):0309 Mailbox cmd x%x issue Data: x%x x%x "
2722 LPFC_DISC_TRC_MBOX_VPORT,
2726 }
2729 LPFC_DISC_TRC_MBOX,
2733 }
2734 }
2739 /* next set own bit for the adapter and copy over command word */
2743 /* First copy command data to host SLIM area */
2747 /* copy command data into host mbox for cmpl */
2749 MAILBOX_CMD_SIZE);
2750 }
2752 /* First copy mbox command data to HBA SLIM, skip past first
2753 word */
2758 /* Next copy over first word, with mbxOwner set */
2765 /* switch over to host mailbox */
2767 }
2768 }
2774 /* Set up reference to mailbox command */
2776 /* Interrupt board to do it */
2779 /* Don't wait for it to finish, just return */
2783 /* Set up null reference to mailbox command */
2785 /* Interrupt board to do it */
2790 /* First read mbox status word */
2794 /* First read mbox status word */
2796 }
2798 /* Read the HBA Host Attention Register */
2804 /* Wait for command to complete */
2811 drvr_flag);
2813 }
2815 /* Check if we took a mbox interrupt while we were
2816 polling */
2823 drvr_flag);
2826 }
2829 /* First copy command data */
2836 /* Check real SLIM for any errors */
2844 }
2845 }
2847 /* First copy command data */
2849 }
2850 /* Read the HBA Host Attention Register */
2852 }
2855 /* copy results back to user */
2857 MAILBOX_CMD_SIZE);
2859 /* First copy command data */
2861 MAILBOX_CMD_SIZE);
2867 }
2868 }
2875 }
2879 }
2881 /*
2882 * Caller needs to hold lock.
2883 */
2884 static void
2887 {
2888 /* Insert the caller's iocb in the txq tail for later processing. */
2891 }
2896 {
2903 }
2906 }
2908 /*
2909 * Lockless version of lpfc_sli_issue_iocb.
2910 */
2911 static int
2914 {
2927 }
2930 /* If the PCI channel is in offline state, do not post iocbs. */
2934 /*
2935 * We should never get an IOCB if we are in a < LINK_DOWN state
2936 */
2940 /*
2941 * Check to see if we are blocking IOCB processing because of a
2942 * outstanding event.
2943 */
2948 /*
2949 * Only CREATE_XRI, CLOSE_XRI, and QUE_RING_BUF
2950 * can be issued if the link is not up.
2951 */
2955 /*
2956 * For IOCBs, like QUE_RING_BUF, that have no rsp ring
2957 * completion, iocb_cmpl MUST be 0.
2958 */
2961 /*FALLTHROUGH*/
2968 }
2970 /*
2971 * For FCP commands, we must be in a state where we can process link
2972 * attention events.
2973 */
2977 }
2985 else
2993 iocb_busy:
2996 out_busy:
3001 }
3004 }
3007 int
3010 {
3019 }
3021 static int
3023 {
3029 /* Adjust cmd/rsp ring iocb entries more evenly */
3031 /* Take some away from the FCP ring */
3038 /* and give them to the extra ring */
3046 /* Setup default profile for this ring */
3054 }
3056 static void
3059 {
3073 KERN_ERR,
3074 LOG_SLI,
3075 "0346 Ring %d handler: unexpected ASYNC_STATUS"
3080 }
3086 KERN_ERR,
3087 LOG_TEMP,
3088 "0347 Adapter is very hot, please take "
3090 temp);
3091 }
3095 KERN_ERR,
3096 LOG_TEMP,
3097 "0340 Adapter temperature is OK now. "
3099 temp);
3100 }
3102 /* Send temperature change event to applications */
3108 }
3111 int
3113 {
3132 /* numCiocb and numRiocb are used in config_port */
3140 SLI3_IOCB_CMD_SIZE :
3141 SLI2_IOCB_CMD_SIZE;
3143 SLI3_IOCB_RSP_SIZE :
3144 SLI2_IOCB_RSP_SIZE;
3152 /* numCiocb and numRiocb are used in config_port */
3156 SLI3_IOCB_CMD_SIZE :
3157 SLI2_IOCB_CMD_SIZE;
3159 SLI3_IOCB_RSP_SIZE :
3160 SLI2_IOCB_RSP_SIZE;
3165 /* numCiocb and numRiocb are used in config_port */
3169 SLI3_IOCB_CMD_SIZE :
3170 SLI2_IOCB_CMD_SIZE;
3172 SLI3_IOCB_RSP_SIZE :
3173 SLI2_IOCB_RSP_SIZE;
3178 lpfc_sli_async_event_handler;
3184 lpfc_els_unsol_event;
3189 lpfc_els_unsol_event;
3191 /* NameServer Inquiry */
3193 /* NameServer */
3196 lpfc_ct_unsol_event;
3198 /* NameServer response */
3200 /* NameServer */
3203 lpfc_ct_unsol_event;
3205 }
3208 }
3210 /* Too many cmd / rsp ring entries in SLI2 SLIM */
3215 }
3220 }
3222 int
3224 {
3233 /* Initialize list headers for txq and txcmplq as double linked lists */
3245 }
3248 }
3250 int
3252 {
3270 /*
3271 * Error everything on the txq since these iocbs have not been
3272 * given to the FW yet.
3273 */
3279 }
3281 /* Next issue ABTS for everything on the txcmplq */
3283 list) {
3287 }
3290 }
3303 }
3304 }
3306 }
3308 int
3310 {
3331 /*
3332 * Error everything on the txq since these iocbs have not been
3333 * given to the FW yet.
3334 */
3338 }
3351 }
3352 }
3365 }
3367 /* Return any active mbox cmds */
3379 }
3381 /* Return any pending or completed mbox cmds */
3394 }
3395 }
3397 }
3399 void
3401 {
3411 src++;
3412 dest++;
3413 }
3414 }
3416 int
3419 {
3420 /* Stick struct lpfc_dmabuf at end of postbufq so driver can look it up
3421 later */
3427 }
3429 uint32_t
3431 {
3434 /*
3435 * Always set the QUE_BUFTAG_BIT to distiguish between
3436 * a tag assigned by HBQ.
3437 */
3441 }
3446 {
3450 /* Search postbufq, from the begining, looking for a match on tag */
3458 }
3459 }
3463 "0410 Cannot find virtual addr for buffer tag on "
3469 }
3473 dma_addr_t phys)
3474 {
3478 /* Search postbufq, from the begining, looking for a match on phys */
3486 }
3487 }
3491 "0410 Cannot find virtual addr for mapped buf on "
3496 }
3498 static void
3501 {
3518 "0327 Cannot abort els iocb %p "
3519 "with tag %x context %x, abort status %x, "
3524 /*
3525 * make sure we have the right iocbq before taking it
3526 * off the txcmplq and try to call completion routine.
3527 */
3537 /* Firmware could still be in progress of DMAing
3538 * payload, so don't free data buffer till after
3539 * a hbeat.
3540 */
3547 }
3548 }
3552 }
3554 static void
3557 {
3560 /* ELS cmd tag <ulpIoTag> completes */
3562 "0133 Ignoring ELS cmd tag x%x completion Data: "
3568 else
3571 }
3573 int
3576 {
3583 /*
3584 * There are certain command types we don't want to abort. And we
3585 * don't want to abort commands that are already in the process of
3586 * being aborted.
3587 */
3594 /* If we're unloading, don't abort iocb on the ELS ring, but change the
3595 * callback so that nothing happens when it finishes.
3596 */
3601 else
3604 }
3606 /* issue ABTS for this IOCB based on iotag */
3611 /* This signals the response to set the correct status
3612 * before calling the completion handler.
3613 */
3625 else
3631 "0339 Abort xri x%x, original iotag x%x, "
3637 abort_iotag_exit:
3638 /*
3639 * Caller to this routine should check for IOCB_ERROR
3640 * and handle it properly. This routine no longer removes
3641 * iocb off txcmplq and call compl in case of IOCB_ERROR.
3642 */
3644 }
3646 static int
3649 lpfc_ctx_cmd ctx_cmd)
3650 {
3684 }
3687 }
3689 int
3691 lpfc_ctx_cmd ctx_cmd)
3692 {
3702 sum++;
3703 }
3706 }
3708 void
3711 {
3714 }
3716 int
3719 {
3734 /* issue ABTS for this IOCB based on iotag */
3737 errcnt++;
3739 }
3751 else
3754 /* Setup callback routine and issue the command. */
3759 errcnt++;
3761 }
3762 }
3765 }
3767 static void
3771 {
3786 }
3788 /*
3789 * Issue the caller's iocb and wait for its completion, but no longer than the
3790 * caller's timeout. Note that iocb_flags is cleared before the
3791 * lpfc_sli_issue_call since the wake routine sets a unique value and by
3792 * definition this is a wait function.
3793 */
3795 int
3801 {
3807 /*
3808 * If the caller has provided a response iocbq buffer, then context2
3809 * is NULL or its an error.
3810 */
3815 }
3826 }
3833 timeout_req);
3840 "0338 IOCB wait timeout error - no "
3845 "0330 IOCB wake NOT set, "
3849 }
3853 retval);
3855 }
3862 }
3870 }
3872 int
3875 {
3880 /* The caller must leave context1 empty. */
3884 /* setup wake call as IOCB callback */
3886 /* setup context field to pass wait_queue pointer to wake function */
3889 /* now issue the command */
3899 /*
3900 * if LPFC_MBX_WAKE flag is set the mailbox is completed
3901 * else do not free the resources.
3902 */
3908 }
3910 }
3913 }
3915 int
3917 {
3926 /*
3927 * Call lpfc_sli_handle_mb_event only if a mailbox cmd
3928 * did finish. This way we won't get the misleading
3929 * "Stray Mailbox Interrupt" message.
3930 */
3941 }
3944 }
3946 irqreturn_t
3948 {
3962 /*
3963 * Get the driver's phba structure from the dev_id and
3964 * assume the HBA is not interrupting.
3965 */
3971 /* If the pci channel is offline, ignore all the interrupts. */
3977 /*
3978 * Call the HBA to see if it is interrupting. If not, don't claim
3979 * the interrupt
3980 */
3982 /* Ignore all interrupts during initialization. */
3986 /*
3987 * Read host attention register to determine interrupt source
3988 * Clear Attention Sources, except Error Attention (to
3989 * preserve status) and Link Attention
3990 */
3993 /* If somebody is waiting to handle an eratt don't process it
3994 * here. The brdkill function will do this.
3995 */
4010 /*
4011 * Turn off Link Attention interrupts
4012 * until CLEAR_LA done
4013 */
4021 }
4022 else
4024 }
4027 /*
4028 * Turn off Slow Rings interrupts, LPFC_ELS_RING is
4029 * the only slow ring.
4030 */
4045 "ISR Disable ring:"
4051 control &=
4055 }
4058 "ISR slow ring: pwork:"
4063 }
4065 }
4066 }
4069 /*
4070 * There was a link/board error. Read the
4071 * status register to retrieve the error event
4072 * and process it.
4073 */
4075 /* Save status info */
4080 /* Clear Chip error bit */
4084 }
4093 /* First check out the status word */
4096 /*
4097 * Stray Mailbox Interrupt, mbxCommand <cmd>
4098 * mbxStatus <status>
4099 */
4101 LOG_SLI,
4102 "(%d):0304 Stray Mailbox "
4103 "Interrupt mbxCommand x%x "
4108 /* clear mailbox attention bit */
4117 MAILBOX_CMD_SIZE);
4118 }
4123 LPFC_DISC_TRC_MBOX_VPORT,
4124 "MBOX dflt rpi: : "
4135 /* Reg_LOGIN of dflt RPI was
4136 * successful. new lets get
4137 * rid of the RPI using the
4138 * same mbox buffer.
4139 */
4143 pmb);
4145 lpfc_mbx_cmpl_dflt_rpi;
4154 }
4155 }
4161 }
4162 }
4165 send_next_mbox:
4170 send_current_mbox:
4171 /* Process next mailbox command if there is one */
4178 }
4179 }
4181 }
4188 }
4192 /*
4193 * Process all events on FCP ring. Take the optimized path for
4194 * FCP IO. Any other IO is slow path and is handled by
4195 * the worker thread.
4196 */
4202 status);
4205 /*
4206 * Process all events on extra ring. Take the optimized path
4207 * for extra ring IO. Any other IO is slow path and is handled
4208 * by the worker thread.
4209 */
4215 status);
4216 }
4217 }