| blob | e5337ad4121efd36f9d6493dc6ea011cd9404b6c |
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 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 {
210 }
213 }
215 static int
217 {
233 "0446 Adapter failed to init (%d), "
234 "mbxCmd x%x CFG_RING, mbxStatus x%x, "
241 }
242 }
245 }
247 static int
250 {
258 else
261 }
265 }
269 {
276 }
280 {
296 "0315 Ring %d issue: portCmdGet %d "
302 /*
303 * All error attention handlers are posted to
304 * worker thread
305 */
309 /* hbalock should already be held */
314 }
318 }
321 }
323 uint16_t
325 {
345 GFP_KERNEL);
350 /* highly unprobable case */
359 }
362 }
375 }
384 }
386 static void
389 {
390 /*
391 * Set up an iotag
392 */
401 }
403 /*
404 * Issue iocb command to adapter
405 */
410 /*
411 * If there is no completion routine to call, we can release the
412 * IOCB buffer back right now. For IOCBs, like QUE_RING_BUF,
413 * that have no rsp ring completion, iocb_cmpl MUST be NULL.
414 */
417 else
420 /*
421 * Let the HBA know what IOCB slot will be the next one the
422 * driver will put a command into.
423 */
426 }
428 static void
430 {
437 /*
438 * Set ring 'ringno' to SET R0CE_REQ in Chip Att register.
439 * The HBA will tell us when an IOCB entry is available.
440 */
445 }
447 static void
449 {
452 /*
453 * Tell the HBA that there is work to do in this ring.
454 */
458 }
460 static void
462 {
466 /*
467 * Check to see if:
468 * (a) there is anything on the txq to send
469 * (b) link is up
470 * (c) link attention events can be processed (fcp ring only)
471 * (d) IOCB processing is not blocked by the outstanding mbox command.
472 */
485 else
487 }
490 }
492 /* lpfc_sli_turn_on_ring is only called by lpfc_sli_handle_mb_event below */
493 static void
495 {
501 /* If the ring is active, flag it */
506 /*
507 * Force update of the local copy of cmdGetInx
508 */
512 }
513 }
515 }
519 {
535 "1802 HBQ %d: local_hbqGetIdx "
542 }
546 }
550 }
552 void
554 {
560 /* Return all memory used by all HBQs */
567 }
568 }
569 }
574 {
578 /* Get next HBQ entry slot to use */
589 /* Sync SLIM */
592 /* flush */
595 }
597 }
608 };
619 };
624 };
626 static int
628 {
634 }
640 }
642 /* Populate HBQ entries */
650 else
652 }
654 }
656 int
658 {
661 }
663 int
665 {
668 }
672 {
685 }
686 }
691 }
693 void
695 {
702 }
703 }
704 }
706 static int
708 {
765 }
767 }
768 static void
770 {
774 /*
775 * If pdone_q is empty, the driver thread gave up waiting and
776 * continued running.
777 */
785 }
787 void
789 {
799 }
801 /*
802 * If a REG_LOGIN succeeded after node is destroyed or node
803 * is in re-discovery driver need to cleanup the RPI.
804 */
815 }
819 }
821 int
823 {
831 /* Get all completed mailboxe buffers into the cmplq */
836 /* Get a Mailbox buffer to setup mailbox commands for callback */
847 LPFC_DISC_TRC_MBOX_VPORT,
852 }
855 LPFC_DISC_TRC_MBOX,
860 }
861 }
863 /*
864 * It is a fatal error if unknown mbox command completion.
865 */
867 MBX_SHUTDOWN) {
868 /* Unknow mailbox command compl */
870 "(%d):0323 Unknown Mailbox command "
878 }
883 /* Mbox cmd cmpl error - RETRYing */
886 "(%d):0305 Mbox cmd cmpl "
887 "error - RETRYing Data: x%x "
902 }
903 }
905 /* Mailbox cmd <cmd> Cmpl <cmpl> */
907 "(%d):0307 Mailbox cmd x%x Cmpl x%p "
926 }
930 {
954 }
956 static int
959 {
974 w5p =
980 /* Firmware Workaround */
988 }
989 }
998 }
1000 /* unSolicited Responses */
1004 saveq);
1007 /* We must search, based on rctl / type
1008 for the right routine */
1010 i++) {
1012 Rctl)
1020 }
1021 }
1022 }
1024 /* Unexpected Rctl / Type received */
1025 /* Ring <ringno> handler: unexpected
1026 Rctl <Rctl> Type <Type> received */
1028 "0313 Ring %d handler: unexpected Rctl x%x "
1031 }
1033 }
1039 {
1050 }
1053 "0317 iotag x%x is out off "
1058 }
1060 static int
1063 {
1068 /* Based on the iotag field, get the cmd IOCB from the txcmplq */
1075 /*
1076 * Post all ELS completions to the worker thread.
1077 * All other are passed to the completion callback.
1078 */
1084 IOSTAT_LOCAL_REJECT;
1086 IOERR_SLI_ABORTED;
1087 }
1088 }
1093 /*
1094 * Unknown initiating command based on the response iotag.
1095 * This could be the case on the ELS ring because of
1096 * lpfc_els_abort().
1097 */
1099 /*
1100 * Ring <ringno> handler: unexpected completion IoTag
1101 * <IoTag>
1102 */
1104 "0322 Ring %d handler: "
1105 "unexpected completion IoTag x%x "
1113 }
1114 }
1117 }
1119 static void
1121 {
1125 /*
1126 * Ring <ringno> handler: portRspPut <portRspPut> is bigger then
1127 * rsp ring <portRspMax>
1128 */
1130 "0312 Ring %d handler: portRspPut %d "
1137 /*
1138 * All error attention handlers are posted to
1139 * worker thread
1140 */
1144 /* hbalock should already be held */
1149 }
1152 {
1174 /*
1175 * The next available response entry should never exceed the maximum
1176 * entries. If it does, treat it as an adapter hardware error.
1177 */
1183 }
1197 rsp_cmpl++;
1200 /* Rsp ring <ringno> error: IOCB */
1202 "0326 Rsp Ring %d error: IOCB Data: "
1213 }
1218 /*
1219 * Idle exchange closed via ABTS from port. No iocb
1220 * resources need to be recovered.
1221 */
1224 "0314 IOCB cmd 0x%x "
1225 "processed. Skipping "
1229 }
1238 }
1245 MAX_MSG_DATA);
1249 /* Unknown IOCB command */
1251 "0321 Unknown IOCB command "
1257 }
1259 }
1261 /*
1262 * The response IOCB has been processed. Update the ring
1263 * pointer in SLIM. If the port response put pointer has not
1264 * been updated, sync the pgp->rspPutInx and fetch the new port
1265 * response put pointer.
1266 */
1271 }
1283 }
1290 /* Force update of the local copy of cmdGetInx */
1298 }
1301 }
1303 /*
1304 * This routine presumes LPFC_FCP_RING handling and doesn't bother
1305 * to check it explicitly.
1306 */
1307 static int
1310 {
1321 lpfc_iocb_type type;
1328 /*
1329 * The next available response entry should never exceed the maximum
1330 * entries. If it does, treat it as an adapter hardware error.
1331 */
1338 }
1342 /*
1343 * Fetch an entry off the ring and copy it into a local data
1344 * structure. The copy involves a byte-swap since the
1345 * network byte order and pci byte orders are different.
1346 */
1361 rsp_cmpl++;
1364 /*
1365 * If resource errors reported from HBA, reduce
1366 * queuedepths of the SCSI device.
1367 */
1373 }
1375 /* Rsp ring <ringno> error: IOCB */
1377 "0336 Rsp Ring %d error: IOCB Data: "
1388 }
1393 /*
1394 * Idle exchange closed via ABTS from port. No iocb
1395 * resources need to be recovered.
1396 */
1399 "0333 IOCB cmd 0x%x"
1400 " processed. Skipping"
1404 }
1414 iflag);
1418 iflag);
1419 }
1420 }
1432 MAX_MSG_DATA);
1436 /* Unknown IOCB command */
1438 "0334 Unknown IOCB command "
1444 }
1446 }
1448 /*
1449 * The response IOCB has been processed. Update the ring
1450 * pointer in SLIM. If the port response put pointer has not
1451 * been updated, sync the pgp->rspPutInx and fetch the new port
1452 * response put pointer.
1453 */
1458 }
1465 }
1470 /* Force update of the local copy of cmdGetInx */
1477 }
1481 }
1483 int
1486 {
1497 lpfc_iocb_type type;
1506 /*
1507 * The next available response entry should never exceed the maximum
1508 * entries. If it does, treat it as an adapter hardware error.
1509 */
1513 /*
1514 * Ring <ringno> handler: portRspPut <portRspPut> is bigger then
1515 * rsp ring <portRspMax>
1516 */
1518 "0303 Ring %d handler: portRspPut %d "
1529 }
1533 /*
1534 * Build a completion list and call the appropriate handler.
1535 * The process is to get the next available response iocb, get
1536 * a free iocb from the list, copy the response data into the
1537 * free iocb, insert to the continuation list, and update the
1538 * next response index to slim. This process makes response
1539 * iocb's in the ring available to DMA as fast as possible but
1540 * pays a penalty for a copy operation. Since the iocb is
1541 * only 32 bytes, this penalty is considered small relative to
1542 * the PCI reads for register values and a slim write. When
1543 * the ulpLe field is set, the entire Command has been
1544 * received.
1545 */
1554 }
1569 }
1578 }
1582 /*
1583 * By default, the driver expects to free all resources
1584 * associated with this iocb completion.
1585 */
1595 /*
1596 * If resource errors reported from HBA, reduce
1597 * queuedepths of the SCSI device.
1598 */
1604 }
1607 /* Rsp ring <ringno> error: IOCB */
1609 "0328 Rsp Ring %d error: "
1610 "IOCB Data: "
1611 "x%x x%x x%x x%x "
1612 "x%x x%x x%x x%x "
1613 "x%x x%x x%x x%x "
1632 }
1634 /*
1635 * Fetch the IOCB command type and call the correct
1636 * completion routine. Solicited and Unsolicited
1637 * IOCBs on the ELS ring get freed back to the
1638 * lpfc_iocb_list by the discovery kernel thread.
1639 */
1644 iflag);
1646 saveq);
1650 iflag);
1652 saveq);
1658 saveq)))) {
1659 /* Call the specified completion
1660 routine */
1664 iflag);
1669 iflag);
1672 cmdiocbp);
1673 }
1680 LPFC_MAX_ADPTMSG);
1682 MAX_MSG_DATA);
1687 /* Unknown IOCB command */
1689 "0335 Unknown IOCB "
1690 "command Data: x%x "
1696 }
1697 }
1704 rspiocbp);
1705 }
1707 }
1709 }
1711 /*
1712 * If the port response put pointer has not been updated, sync
1713 * the pgp->rspPutInx in the MAILBOX_tand fetch the new port
1714 * response put pointer.
1715 */
1718 }
1722 /* At least one response entry has been freed */
1724 /* SET RxRE_RSP in Chip Att register */
1728 }
1733 /* Force update of the local copy of cmdGetInx */
1740 }
1744 }
1746 void
1748 {
1755 }
1757 /* Error everything on txq and txcmplq
1758 * First do the txq.
1759 */
1764 /* Next issue ABTS for everything on the txcmplq */
1781 }
1782 }
1783 }
1785 int
1787 {
1792 /* Read the HBA Host Status Register */
1795 /*
1796 * Check status register every 100ms for 5 retries, then every
1797 * 500ms for 5, then every 2.5 sec for 5, then reset board and
1798 * every 2.5 sec for 4.
1799 * Break our of the loop if errors occurred during init.
1800 */
1809 else
1813 /* Do post */
1816 }
1817 /* Read the HBA Host Status Register */
1819 }
1821 /* Check to see if any errors occurred during init */
1825 }
1828 }
1830 #define BARRIER_TEST_PATTERN (0xdeadbeef)
1833 {
1847 /*
1848 * Tell the other part of the chip to suspend temporarily all
1849 * its DMA activity.
1850 */
1853 /* Disable the error attention */
1860 /* Clear Chip error bit */
1863 }
1881 else
1883 }
1889 clear_errat:
1897 }
1899 restore_hc:
1903 }
1905 int
1907 {
1917 /* Kill HBA */
1926 /* Disable the error attention */
1946 }
1952 /* There is no completion for a KILL_BOARD mbox cmd. Check for an error
1953 * attention every 100ms for 3 seconds. If we don't get ERATT after
1954 * 3 seconds we still set HBA_ERROR state because the status of the
1955 * board is now undefined.
1956 */
1962 }
1968 }
1979 }
1981 int
1983 {
1991 /* Reset HBA */
1996 /* perform board reset */
2001 /* Turn off parity checking and serr during the physical reset */
2008 /* Now toggle INITFF bit in the Host Control Register */
2015 /* Restore PCI cmd register */
2018 /* Initialize relevant SLI info */
2027 }
2031 }
2033 int
2035 {
2046 /* Restart HBA */
2062 /* Only skip post after fc_ffinit is completed */
2069 }
2085 else
2091 }
2093 static int
2095 {
2098 /* Read the HBA Host Status Register */
2101 /* Check status register to see what current state is */
2105 /* Check every 100ms for 5 retries, then every 500ms for 5, then
2106 * every 2.5 sec for 5, then reset board and every 2.5 sec for
2107 * 4.
2108 */
2110 /* Adapter failed to init, timeout, status reg
2111 <status> */
2113 "0436 Adapter failed to init, "
2117 }
2119 /* Check to see if any errors occurred during init */
2121 /* ERROR: During chipset initialization */
2122 /* Adapter failed to init, chipset, status reg
2123 <status> */
2125 "0437 Adapter failed to init, "
2129 }
2137 }
2140 /* Do post */
2143 }
2144 /* Read the HBA Host Status Register */
2146 }
2148 /* Check to see if any errors occurred during init */
2150 /* ERROR: During chipset initialization */
2151 /* Adapter failed to init, chipset, status reg <status> */
2153 "0438 Adapter failed to init, chipset, "
2157 }
2159 /* Clear all interrupt enable conditions */
2163 /* setup host attn register */
2167 }
2169 int
2171 {
2173 }
2175 static int
2177 {
2185 }
2187 int
2189 {
2191 }
2193 static int
2195 {
2202 /* Get a Mailbox buffer to setup mailbox
2203 * commands for HBA initialization
2204 */
2212 /* Initialize the struct lpfc_sli_hbq structure for each hbq */
2227 /* Adapter failed to init, mbxCmd <cmd> CFG_RING,
2228 mbxStatus <status>, ring <num> */
2232 "1805 Adapter failed to init. "
2240 }
2241 }
2246 /* Initially populate or replenish the HBQs */
2250 }
2252 }
2254 static int
2256 {
2264 }
2281 resetcount++;
2283 /* Call pre CONFIG_PORT mailbox command initialization. A
2284 * value of 0 means the call was successful. Any other
2285 * nonzero value is a failure, but if ERESTART is returned,
2286 * the driver may reset the HBA and try again.
2287 */
2294 }
2301 "0442 Adapter failed to init, mbxCmd x%x "
2314 }
2315 }
2320 }
2326 }
2329 do_prep_failed:
2332 }
2334 int
2336 {
2344 "1824 NPIV enabled: Override lpfc_sli_mode "
2346 lpfc_sli_mode);
2348 }
2356 "1819 Unrecognized lpfc_sli_mode "
2360 }
2365 "1820 Unable to select SLI-3. "
2382 }
2392 /* Init HBQs */
2398 }
2408 lpfc_sli_hba_setup_error:
2413 }
2415 /*! lpfc_mbox_timeout
2416 *
2417 * \pre
2418 * \post
2419 * \param hba Pointer to per struct lpfc_hba structure
2420 * \param l1 Pointer to the driver's mailbox queue.
2421 * \return
2422 * void
2423 *
2424 * \b Description:
2425 *
2426 * This routine handles mailbox timeout events at timer interrupt context.
2427 */
2428 void
2430 {
2446 }
2447 }
2449 void
2451 {
2459 }
2461 /* Mbox cmd <mbxCommand> timeout */
2469 /* Setting state unknown so lpfc_sli_abort_iocb_ring
2470 * would get IOCB_ERROR from lpfc_sli_issue_iocb, allowing
2471 * it to fail all oustanding SCSI IO.
2472 */
2487 /*
2488 * lpfc_offline calls lpfc_sli_hba_down which will clean up
2489 * on oustanding mailbox commands.
2490 */
2498 }
2500 int
2502 {
2521 }
2522 }
2525 /* If the PCI channel is in offline state, do not post mbox. */
2539 /* Mbox command <mbxCommand> cannot issue */
2542 }
2549 }
2552 /* Polling for a mbox command when another one is already active
2553 * is not allowed in SLI. Also, the driver must have established
2554 * SLI2 mode to queue and process multiple mbox commands.
2555 */
2560 /* Mbox command <mbxCommand> cannot issue */
2563 }
2567 /* Mbox command <mbxCommand> cannot issue */
2570 }
2572 /* Handle STOP IOCB processing flag. This is only meaningful
2573 * if we are not polling for mbox completion.
2574 */
2577 /* Now flag each ring */
2579 /* If the ring is active, flag it */
2582 LPFC_STOP_IOCB_MBX;
2583 }
2584 }
2585 }
2587 /* Another mailbox command is still being processed, queue this
2588 * command to be processed later.
2589 */
2592 /* Mbox cmd issue - BUSY */
2594 "(%d):0308 Mbox cmd issue - BUSY Data: "
2605 LPFC_DISC_TRC_MBOX_VPORT,
2609 }
2612 LPFC_DISC_TRC_MBOX,
2616 }
2619 }
2621 /* Handle STOP IOCB processing flag. This is only meaningful
2622 * if we are not polling for mbox completion.
2623 */
2627 /* Now flag each ring */
2629 /* If the ring is active, flag it */
2632 LPFC_STOP_IOCB_MBX;
2633 }
2634 }
2635 }
2636 }
2640 /* If we are not polling, we MUST be in SLI2 mode */
2646 /* Mbox command <mbxCommand> cannot issue */
2649 }
2650 /* timeout active mbox command */
2653 }
2655 /* Mailbox cmd <cmd> issue */
2657 "(%d):0309 Mailbox cmd x%x issue Data: x%x x%x "
2666 LPFC_DISC_TRC_MBOX_VPORT,
2670 }
2673 LPFC_DISC_TRC_MBOX,
2677 }
2678 }
2683 /* next set own bit for the adapter and copy over command word */
2687 /* First copy command data to host SLIM area */
2691 /* copy command data into host mbox for cmpl */
2693 MAILBOX_CMD_SIZE);
2694 }
2696 /* First copy mbox command data to HBA SLIM, skip past first
2697 word */
2702 /* Next copy over first word, with mbxOwner set */
2709 /* switch over to host mailbox */
2711 }
2712 }
2715 /* interrupt board to doit right away */
2721 /* Don't wait for it to finish, just return */
2728 /* First read mbox status word */
2732 /* First read mbox status word */
2734 }
2736 /* Read the HBA Host Attention Register */
2742 /* Wait for command to complete */
2749 drvr_flag);
2751 }
2753 /* Check if we took a mbox interrupt while we were
2754 polling */
2760 drvr_flag);
2767 /* First copy command data */
2774 /* Check real SLIM for any errors */
2782 }
2783 }
2785 /* First copy command data */
2787 }
2788 /* Read the HBA Host Attention Register */
2790 }
2793 /* copy results back to user */
2795 MAILBOX_CMD_SIZE);
2797 /* First copy command data */
2799 MAILBOX_CMD_SIZE);
2805 }
2806 }
2813 }
2817 }
2819 /*
2820 * Caller needs to hold lock.
2821 */
2822 static void
2825 {
2826 /* Insert the caller's iocb in the txq tail for later processing. */
2829 }
2834 {
2841 }
2844 }
2846 /*
2847 * Lockless version of lpfc_sli_issue_iocb.
2848 */
2849 int
2852 {
2865 }
2868 /* If the PCI channel is in offline state, do not post iocbs. */
2872 /*
2873 * We should never get an IOCB if we are in a < LINK_DOWN state
2874 */
2878 /*
2879 * Check to see if we are blocking IOCB processing because of a
2880 * outstanding mbox command.
2881 */
2886 /*
2887 * Only CREATE_XRI, CLOSE_XRI, and QUE_RING_BUF
2888 * can be issued if the link is not up.
2889 */
2893 /*
2894 * For IOCBs, like QUE_RING_BUF, that have no rsp ring
2895 * completion, iocb_cmpl MUST be 0.
2896 */
2899 /*FALLTHROUGH*/
2906 }
2908 /*
2909 * For FCP commands, we must be in a state where we can process link
2910 * attention events.
2911 */
2915 }
2923 else
2931 iocb_busy:
2934 out_busy:
2939 }
2942 }
2945 int
2948 {
2957 }
2959 static int
2961 {
2967 /* Adjust cmd/rsp ring iocb entries more evenly */
2969 /* Take some away from the FCP ring */
2976 /* and give them to the extra ring */
2984 /* Setup default profile for this ring */
2992 }
2994 int
2996 {
3015 /* numCiocb and numRiocb are used in config_port */
3023 SLI3_IOCB_CMD_SIZE :
3024 SLI2_IOCB_CMD_SIZE;
3026 SLI3_IOCB_RSP_SIZE :
3027 SLI2_IOCB_RSP_SIZE;
3035 /* numCiocb and numRiocb are used in config_port */
3039 SLI3_IOCB_CMD_SIZE :
3040 SLI2_IOCB_CMD_SIZE;
3042 SLI3_IOCB_RSP_SIZE :
3043 SLI2_IOCB_RSP_SIZE;
3048 /* numCiocb and numRiocb are used in config_port */
3052 SLI3_IOCB_CMD_SIZE :
3053 SLI2_IOCB_CMD_SIZE;
3055 SLI3_IOCB_RSP_SIZE :
3056 SLI2_IOCB_RSP_SIZE;
3065 lpfc_els_unsol_event;
3070 lpfc_els_unsol_event;
3072 /* NameServer Inquiry */
3074 /* NameServer */
3077 lpfc_ct_unsol_event;
3079 /* NameServer response */
3081 /* NameServer */
3084 lpfc_ct_unsol_event;
3086 }
3089 }
3091 /* Too many cmd / rsp ring entries in SLI2 SLIM */
3096 }
3101 }
3103 int
3105 {
3114 /* Initialize list headers for txq and txcmplq as double linked lists */
3125 }
3128 }
3130 int
3132 {
3150 /*
3151 * Error everything on the txq since these iocbs have not been
3152 * given to the FW yet.
3153 */
3159 }
3161 /* Next issue ABTS for everything on the txcmplq */
3163 list) {
3167 }
3170 }
3183 }
3184 }
3186 }
3188 int
3190 {
3210 /*
3211 * Error everything on the txq since these iocbs have not been
3212 * given to the FW yet.
3213 */
3217 }
3230 }
3231 }
3233 /* Return any active mbox cmds */
3245 }
3247 /* Return any pending or completed mbox cmds */
3260 }
3261 }
3263 }
3265 void
3267 {
3277 src++;
3278 dest++;
3279 }
3280 }
3282 int
3285 {
3286 /* Stick struct lpfc_dmabuf at end of postbufq so driver can look it up
3287 later */
3293 }
3298 dma_addr_t phys)
3299 {
3303 /* Search postbufq, from the begining, looking for a match on phys */
3311 }
3312 }
3316 "0410 Cannot find virtual addr for mapped buf on "
3321 }
3323 static void
3326 {
3343 "0327 Cannot abort els iocb %p "
3344 "with tag %x context %x, abort status %x, "
3349 /*
3350 * make sure we have the right iocbq before taking it
3351 * off the txcmplq and try to call completion routine.
3352 */
3366 }
3367 }
3371 }
3373 static void
3376 {
3379 /* ELS cmd tag <ulpIoTag> completes */
3381 "0133 Ignoring ELS cmd tag x%x completion Data: "
3387 else
3390 }
3392 int
3395 {
3402 /*
3403 * There are certain command types we don't want to abort. And we
3404 * don't want to abort commands that are already in the process of
3405 * being aborted.
3406 */
3413 /* If we're unloading, don't abort iocb on the ELS ring, but change the
3414 * callback so that nothing happens when it finishes.
3415 */
3420 else
3423 }
3425 /* issue ABTS for this IOCB based on iotag */
3430 /* This signals the response to set the correct status
3431 * before calling the completion handler.
3432 */
3444 else
3450 "0339 Abort xri x%x, original iotag x%x, "
3456 abort_iotag_exit:
3457 /*
3458 * Caller to this routine should check for IOCB_ERROR
3459 * and handle it properly. This routine no longer removes
3460 * iocb off txcmplq and call compl in case of IOCB_ERROR.
3461 */
3463 }
3465 static int
3468 lpfc_ctx_cmd ctx_cmd)
3469 {
3503 }
3506 }
3508 int
3510 lpfc_ctx_cmd ctx_cmd)
3511 {
3521 sum++;
3522 }
3525 }
3527 void
3530 {
3533 }
3535 int
3538 {
3553 /* issue ABTS for this IOCB based on iotag */
3556 errcnt++;
3558 }
3570 else
3573 /* Setup callback routine and issue the command. */
3578 errcnt++;
3580 }
3581 }
3584 }
3586 static void
3590 {
3605 }
3607 /*
3608 * Issue the caller's iocb and wait for its completion, but no longer than the
3609 * caller's timeout. Note that iocb_flags is cleared before the
3610 * lpfc_sli_issue_call since the wake routine sets a unique value and by
3611 * definition this is a wait function.
3612 */
3614 int
3620 {
3626 /*
3627 * If the caller has provided a response iocbq buffer, then context2
3628 * is NULL or its an error.
3629 */
3634 }
3645 }
3652 timeout_req);
3659 "0338 IOCB wait timeout error - no "
3664 "0330 IOCB wake NOT set, "
3668 }
3672 retval);
3674 }
3681 }
3689 }
3691 int
3694 {
3699 /* The caller must leave context1 empty. */
3703 /* setup wake call as IOCB callback */
3705 /* setup context field to pass wait_queue pointer to wake function */
3708 /* now issue the command */
3718 /*
3719 * if LPFC_MBX_WAKE flag is set the mailbox is completed
3720 * else do not free the resources.
3721 */
3727 }
3729 }
3732 }
3734 int
3736 {
3745 /*
3746 * Call lpfc_sli_handle_mb_event only if a mailbox cmd
3747 * did finish. This way we won't get the misleading
3748 * "Stray Mailbox Interrupt" message.
3749 */
3760 }
3763 }
3765 irqreturn_t
3767 {
3782 /*
3783 * Get the driver's phba structure from the dev_id and
3784 * assume the HBA is not interrupting.
3785 */
3791 /* If the pci channel is offline, ignore all the interrupts. */
3797 /*
3798 * Call the HBA to see if it is interrupting. If not, don't claim
3799 * the interrupt
3800 */
3802 /* Ignore all interrupts during initialization. */
3806 /*
3807 * Read host attention register to determine interrupt source
3808 * Clear Attention Sources, except Error Attention (to
3809 * preserve status) and Link Attention
3810 */
3813 /* If somebody is waiting to handle an eratt don't process it
3814 * here. The brdkill function will do this.
3815 */
3830 /*
3831 * Turn off Link Attention interrupts
3832 * until CLEAR_LA done
3833 */
3841 }
3842 else
3844 }
3847 /*
3848 * Turn off Slow Rings interrupts, LPFC_ELS_RING is
3849 * the only slow ring.
3850 */
3865 "ISR Disable ring:"
3871 control &=
3875 }
3878 "ISR slow ring: pwork:"
3883 }
3885 }
3886 }
3890 /*
3891 * There was a link/board error. Read the
3892 * status register to retrieve the error event
3893 * and process it.
3894 */
3896 /* Save status info */
3901 /* Clear Chip error bit */
3905 }
3914 /* First check out the status word */
3917 /*
3918 * Stray Mailbox Interrupt, mbxCommand <cmd>
3919 * mbxStatus <status>
3920 */
3922 LOG_SLI,
3923 "(%d):0304 Stray Mailbox "
3924 "Interrupt mbxCommand x%x "
3929 }
3936 MAILBOX_CMD_SIZE);
3937 }
3942 LPFC_DISC_TRC_MBOX_VPORT,
3953 /* Reg_LOGIN of dflt RPI was successful.
3954 * new lets get rid of the RPI using the
3955 * same mbox buffer.
3956 */
3968 }
3969 }
3974 }
3977 send_next_mbox:
3982 send_current_mbox:
3983 /* Process next mailbox command if there is one */
3990 }
3992 /* Turn on IOCB processing */
3995 }
3997 }
4004 }
4008 /*
4009 * Process all events on FCP ring. Take the optimized path for
4010 * FCP IO. Any other IO is slow path and is handled by
4011 * the worker thread.
4012 */
4018 status);
4021 /*
4022 * Process all events on extra ring. Take the optimized path
4023 * for extra ring IO. Any other IO is slow path and is handled
4024 * by the worker thread.
4025 */
4031 status);
4032 }
4033 }