| blob | ce348c5c706ce901f05cc72349804c63cc2b9935 |
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);
1250 /* Unknown IOCB command */
1252 "0321 Unknown IOCB command "
1258 }
1260 }
1262 /*
1263 * The response IOCB has been processed. Update the ring
1264 * pointer in SLIM. If the port response put pointer has not
1265 * been updated, sync the pgp->rspPutInx and fetch the new port
1266 * response put pointer.
1267 */
1272 }
1284 }
1291 /* Force update of the local copy of cmdGetInx */
1299 }
1302 }
1304 /*
1305 * This routine presumes LPFC_FCP_RING handling and doesn't bother
1306 * to check it explicitly.
1307 */
1308 static int
1311 {
1322 lpfc_iocb_type type;
1329 /*
1330 * The next available response entry should never exceed the maximum
1331 * entries. If it does, treat it as an adapter hardware error.
1332 */
1339 }
1343 /*
1344 * Fetch an entry off the ring and copy it into a local data
1345 * structure. The copy involves a byte-swap since the
1346 * network byte order and pci byte orders are different.
1347 */
1362 rsp_cmpl++;
1365 /*
1366 * If resource errors reported from HBA, reduce
1367 * queuedepths of the SCSI device.
1368 */
1374 }
1376 /* Rsp ring <ringno> error: IOCB */
1378 "0336 Rsp Ring %d error: IOCB Data: "
1389 }
1394 /*
1395 * Idle exchange closed via ABTS from port. No iocb
1396 * resources need to be recovered.
1397 */
1400 "0333 IOCB cmd 0x%x"
1401 " processed. Skipping"
1405 }
1415 iflag);
1419 iflag);
1420 }
1421 }
1433 MAX_MSG_DATA);
1438 /* Unknown IOCB command */
1440 "0334 Unknown IOCB command "
1446 }
1448 }
1450 /*
1451 * The response IOCB has been processed. Update the ring
1452 * pointer in SLIM. If the port response put pointer has not
1453 * been updated, sync the pgp->rspPutInx and fetch the new port
1454 * response put pointer.
1455 */
1460 }
1467 }
1472 /* Force update of the local copy of cmdGetInx */
1479 }
1483 }
1485 int
1488 {
1499 lpfc_iocb_type type;
1508 /*
1509 * The next available response entry should never exceed the maximum
1510 * entries. If it does, treat it as an adapter hardware error.
1511 */
1515 /*
1516 * Ring <ringno> handler: portRspPut <portRspPut> is bigger then
1517 * rsp ring <portRspMax>
1518 */
1520 "0303 Ring %d handler: portRspPut %d "
1531 }
1535 /*
1536 * Build a completion list and call the appropriate handler.
1537 * The process is to get the next available response iocb, get
1538 * a free iocb from the list, copy the response data into the
1539 * free iocb, insert to the continuation list, and update the
1540 * next response index to slim. This process makes response
1541 * iocb's in the ring available to DMA as fast as possible but
1542 * pays a penalty for a copy operation. Since the iocb is
1543 * only 32 bytes, this penalty is considered small relative to
1544 * the PCI reads for register values and a slim write. When
1545 * the ulpLe field is set, the entire Command has been
1546 * received.
1547 */
1556 }
1571 }
1580 }
1584 /*
1585 * By default, the driver expects to free all resources
1586 * associated with this iocb completion.
1587 */
1597 /*
1598 * If resource errors reported from HBA, reduce
1599 * queuedepths of the SCSI device.
1600 */
1606 }
1609 /* Rsp ring <ringno> error: IOCB */
1611 "0328 Rsp Ring %d error: "
1612 "IOCB Data: "
1613 "x%x x%x x%x x%x "
1614 "x%x x%x x%x x%x "
1615 "x%x x%x x%x x%x "
1634 }
1636 /*
1637 * Fetch the IOCB command type and call the correct
1638 * completion routine. Solicited and Unsolicited
1639 * IOCBs on the ELS ring get freed back to the
1640 * lpfc_iocb_list by the discovery kernel thread.
1641 */
1646 iflag);
1648 saveq);
1652 iflag);
1654 saveq);
1660 saveq)))) {
1661 /* Call the specified completion
1662 routine */
1666 iflag);
1671 iflag);
1674 cmdiocbp);
1675 }
1682 LPFC_MAX_ADPTMSG);
1684 MAX_MSG_DATA);
1689 /* Unknown IOCB command */
1691 "0335 Unknown IOCB "
1692 "command Data: x%x "
1698 }
1699 }
1706 rspiocbp);
1707 }
1709 }
1711 }
1713 /*
1714 * If the port response put pointer has not been updated, sync
1715 * the pgp->rspPutInx in the MAILBOX_tand fetch the new port
1716 * response put pointer.
1717 */
1720 }
1724 /* At least one response entry has been freed */
1726 /* SET RxRE_RSP in Chip Att register */
1730 }
1735 /* Force update of the local copy of cmdGetInx */
1742 }
1746 }
1748 void
1750 {
1757 }
1759 /* Error everything on txq and txcmplq
1760 * First do the txq.
1761 */
1766 /* Next issue ABTS for everything on the txcmplq */
1783 }
1784 }
1785 }
1787 int
1789 {
1794 /* Read the HBA Host Status Register */
1797 /*
1798 * Check status register every 100ms for 5 retries, then every
1799 * 500ms for 5, then every 2.5 sec for 5, then reset board and
1800 * every 2.5 sec for 4.
1801 * Break our of the loop if errors occurred during init.
1802 */
1811 else
1815 /* Do post */
1818 }
1819 /* Read the HBA Host Status Register */
1821 }
1823 /* Check to see if any errors occurred during init */
1827 }
1830 }
1832 #define BARRIER_TEST_PATTERN (0xdeadbeef)
1835 {
1849 /*
1850 * Tell the other part of the chip to suspend temporarily all
1851 * its DMA activity.
1852 */
1855 /* Disable the error attention */
1862 /* Clear Chip error bit */
1865 }
1883 else
1885 }
1891 clear_errat:
1899 }
1901 restore_hc:
1905 }
1907 int
1909 {
1919 /* Kill HBA */
1928 /* Disable the error attention */
1948 }
1954 /* There is no completion for a KILL_BOARD mbox cmd. Check for an error
1955 * attention every 100ms for 3 seconds. If we don't get ERATT after
1956 * 3 seconds we still set HBA_ERROR state because the status of the
1957 * board is now undefined.
1958 */
1964 }
1970 }
1981 }
1983 int
1985 {
1993 /* Reset HBA */
1998 /* perform board reset */
2003 /* Turn off parity checking and serr during the physical reset */
2010 /* Now toggle INITFF bit in the Host Control Register */
2017 /* Restore PCI cmd register */
2020 /* Initialize relevant SLI info */
2029 }
2033 }
2035 int
2037 {
2048 /* Restart HBA */
2064 /* Only skip post after fc_ffinit is completed */
2071 }
2087 else
2093 }
2095 static int
2097 {
2100 /* Read the HBA Host Status Register */
2103 /* Check status register to see what current state is */
2107 /* Check every 100ms for 5 retries, then every 500ms for 5, then
2108 * every 2.5 sec for 5, then reset board and every 2.5 sec for
2109 * 4.
2110 */
2112 /* Adapter failed to init, timeout, status reg
2113 <status> */
2115 "0436 Adapter failed to init, "
2119 }
2121 /* Check to see if any errors occurred during init */
2123 /* ERROR: During chipset initialization */
2124 /* Adapter failed to init, chipset, status reg
2125 <status> */
2127 "0437 Adapter failed to init, "
2131 }
2139 }
2142 /* Do post */
2145 }
2146 /* Read the HBA Host Status Register */
2148 }
2150 /* Check to see if any errors occurred during init */
2152 /* ERROR: During chipset initialization */
2153 /* Adapter failed to init, chipset, status reg <status> */
2155 "0438 Adapter failed to init, chipset, "
2159 }
2161 /* Clear all interrupt enable conditions */
2165 /* setup host attn register */
2169 }
2171 int
2173 {
2175 }
2177 static int
2179 {
2187 }
2189 int
2191 {
2193 }
2195 static int
2197 {
2204 /* Get a Mailbox buffer to setup mailbox
2205 * commands for HBA initialization
2206 */
2214 /* Initialize the struct lpfc_sli_hbq structure for each hbq */
2229 /* Adapter failed to init, mbxCmd <cmd> CFG_RING,
2230 mbxStatus <status>, ring <num> */
2234 "1805 Adapter failed to init. "
2242 }
2243 }
2248 /* Initially populate or replenish the HBQs */
2252 }
2254 }
2256 static int
2258 {
2266 }
2283 resetcount++;
2285 /* Call pre CONFIG_PORT mailbox command initialization. A
2286 * value of 0 means the call was successful. Any other
2287 * nonzero value is a failure, but if ERESTART is returned,
2288 * the driver may reset the HBA and try again.
2289 */
2296 }
2303 "0442 Adapter failed to init, mbxCmd x%x "
2316 }
2317 }
2322 }
2328 }
2331 do_prep_failed:
2334 }
2336 int
2338 {
2346 "1824 NPIV enabled: Override lpfc_sli_mode "
2348 lpfc_sli_mode);
2350 }
2358 "1819 Unrecognized lpfc_sli_mode "
2362 }
2367 "1820 Unable to select SLI-3. "
2384 }
2394 /* Init HBQs */
2400 }
2410 lpfc_sli_hba_setup_error:
2415 }
2417 /*! lpfc_mbox_timeout
2418 *
2419 * \pre
2420 * \post
2421 * \param hba Pointer to per struct lpfc_hba structure
2422 * \param l1 Pointer to the driver's mailbox queue.
2423 * \return
2424 * void
2425 *
2426 * \b Description:
2427 *
2428 * This routine handles mailbox timeout events at timer interrupt context.
2429 */
2430 void
2432 {
2448 }
2449 }
2451 void
2453 {
2461 }
2463 /* Mbox cmd <mbxCommand> timeout */
2471 /* Setting state unknown so lpfc_sli_abort_iocb_ring
2472 * would get IOCB_ERROR from lpfc_sli_issue_iocb, allowing
2473 * it to fail all oustanding SCSI IO.
2474 */
2489 /*
2490 * lpfc_offline calls lpfc_sli_hba_down which will clean up
2491 * on oustanding mailbox commands.
2492 */
2500 }
2502 int
2504 {
2523 }
2524 }
2527 /* If the PCI channel is in offline state, do not post mbox. */
2541 /* Mbox command <mbxCommand> cannot issue */
2544 }
2551 }
2554 /* Polling for a mbox command when another one is already active
2555 * is not allowed in SLI. Also, the driver must have established
2556 * SLI2 mode to queue and process multiple mbox commands.
2557 */
2562 /* Mbox command <mbxCommand> cannot issue */
2565 }
2569 /* Mbox command <mbxCommand> cannot issue */
2572 }
2574 /* Handle STOP IOCB processing flag. This is only meaningful
2575 * if we are not polling for mbox completion.
2576 */
2579 /* Now flag each ring */
2581 /* If the ring is active, flag it */
2584 LPFC_STOP_IOCB_MBX;
2585 }
2586 }
2587 }
2589 /* Another mailbox command is still being processed, queue this
2590 * command to be processed later.
2591 */
2594 /* Mbox cmd issue - BUSY */
2596 "(%d):0308 Mbox cmd issue - BUSY Data: "
2607 LPFC_DISC_TRC_MBOX_VPORT,
2611 }
2614 LPFC_DISC_TRC_MBOX,
2618 }
2621 }
2623 /* Handle STOP IOCB processing flag. This is only meaningful
2624 * if we are not polling for mbox completion.
2625 */
2629 /* Now flag each ring */
2631 /* If the ring is active, flag it */
2634 LPFC_STOP_IOCB_MBX;
2635 }
2636 }
2637 }
2638 }
2642 /* If we are not polling, we MUST be in SLI2 mode */
2648 /* Mbox command <mbxCommand> cannot issue */
2651 }
2652 /* timeout active mbox command */
2655 }
2657 /* Mailbox cmd <cmd> issue */
2659 "(%d):0309 Mailbox cmd x%x issue Data: x%x x%x "
2668 LPFC_DISC_TRC_MBOX_VPORT,
2672 }
2675 LPFC_DISC_TRC_MBOX,
2679 }
2680 }
2685 /* next set own bit for the adapter and copy over command word */
2689 /* First copy command data to host SLIM area */
2693 /* copy command data into host mbox for cmpl */
2695 MAILBOX_CMD_SIZE);
2696 }
2698 /* First copy mbox command data to HBA SLIM, skip past first
2699 word */
2704 /* Next copy over first word, with mbxOwner set */
2711 /* switch over to host mailbox */
2713 }
2714 }
2717 /* interrupt board to doit right away */
2723 /* Don't wait for it to finish, just return */
2730 /* First read mbox status word */
2734 /* First read mbox status word */
2736 }
2738 /* Read the HBA Host Attention Register */
2744 /* Wait for command to complete */
2751 drvr_flag);
2753 }
2755 /* Check if we took a mbox interrupt while we were
2756 polling */
2762 drvr_flag);
2769 /* First copy command data */
2776 /* Check real SLIM for any errors */
2784 }
2785 }
2787 /* First copy command data */
2789 }
2790 /* Read the HBA Host Attention Register */
2792 }
2795 /* copy results back to user */
2797 MAILBOX_CMD_SIZE);
2799 /* First copy command data */
2801 MAILBOX_CMD_SIZE);
2807 }
2808 }
2815 }
2819 }
2821 /*
2822 * Caller needs to hold lock.
2823 */
2824 static void
2827 {
2828 /* Insert the caller's iocb in the txq tail for later processing. */
2831 }
2836 {
2843 }
2846 }
2848 /*
2849 * Lockless version of lpfc_sli_issue_iocb.
2850 */
2851 int
2854 {
2867 }
2870 /* If the PCI channel is in offline state, do not post iocbs. */
2874 /*
2875 * We should never get an IOCB if we are in a < LINK_DOWN state
2876 */
2880 /*
2881 * Check to see if we are blocking IOCB processing because of a
2882 * outstanding mbox command.
2883 */
2888 /*
2889 * Only CREATE_XRI, CLOSE_XRI, and QUE_RING_BUF
2890 * can be issued if the link is not up.
2891 */
2895 /*
2896 * For IOCBs, like QUE_RING_BUF, that have no rsp ring
2897 * completion, iocb_cmpl MUST be 0.
2898 */
2901 /*FALLTHROUGH*/
2908 }
2910 /*
2911 * For FCP commands, we must be in a state where we can process link
2912 * attention events.
2913 */
2917 }
2925 else
2933 iocb_busy:
2936 out_busy:
2941 }
2944 }
2947 int
2950 {
2959 }
2961 static int
2963 {
2969 /* Adjust cmd/rsp ring iocb entries more evenly */
2971 /* Take some away from the FCP ring */
2978 /* and give them to the extra ring */
2986 /* Setup default profile for this ring */
2994 }
2996 int
2998 {
3017 /* numCiocb and numRiocb are used in config_port */
3025 SLI3_IOCB_CMD_SIZE :
3026 SLI2_IOCB_CMD_SIZE;
3028 SLI3_IOCB_RSP_SIZE :
3029 SLI2_IOCB_RSP_SIZE;
3037 /* numCiocb and numRiocb are used in config_port */
3041 SLI3_IOCB_CMD_SIZE :
3042 SLI2_IOCB_CMD_SIZE;
3044 SLI3_IOCB_RSP_SIZE :
3045 SLI2_IOCB_RSP_SIZE;
3050 /* numCiocb and numRiocb are used in config_port */
3054 SLI3_IOCB_CMD_SIZE :
3055 SLI2_IOCB_CMD_SIZE;
3057 SLI3_IOCB_RSP_SIZE :
3058 SLI2_IOCB_RSP_SIZE;
3067 lpfc_els_unsol_event;
3072 lpfc_els_unsol_event;
3074 /* NameServer Inquiry */
3076 /* NameServer */
3079 lpfc_ct_unsol_event;
3081 /* NameServer response */
3083 /* NameServer */
3086 lpfc_ct_unsol_event;
3088 }
3091 }
3093 /* Too many cmd / rsp ring entries in SLI2 SLIM */
3098 }
3103 }
3105 int
3107 {
3116 /* Initialize list headers for txq and txcmplq as double linked lists */
3127 }
3130 }
3132 int
3134 {
3152 /*
3153 * Error everything on the txq since these iocbs have not been
3154 * given to the FW yet.
3155 */
3161 }
3163 /* Next issue ABTS for everything on the txcmplq */
3165 list) {
3169 }
3172 }
3185 }
3186 }
3188 }
3190 int
3192 {
3212 /*
3213 * Error everything on the txq since these iocbs have not been
3214 * given to the FW yet.
3215 */
3219 }
3232 }
3233 }
3235 /* Return any active mbox cmds */
3247 }
3249 /* Return any pending or completed mbox cmds */
3262 }
3263 }
3265 }
3267 void
3269 {
3279 src++;
3280 dest++;
3281 }
3282 }
3284 int
3287 {
3288 /* Stick struct lpfc_dmabuf at end of postbufq so driver can look it up
3289 later */
3295 }
3300 dma_addr_t phys)
3301 {
3305 /* Search postbufq, from the begining, looking for a match on phys */
3313 }
3314 }
3318 "0410 Cannot find virtual addr for mapped buf on "
3323 }
3325 static void
3328 {
3345 "0327 Cannot abort els iocb %p "
3346 "with tag %x context %x, abort status %x, "
3351 /*
3352 * make sure we have the right iocbq before taking it
3353 * off the txcmplq and try to call completion routine.
3354 */
3368 }
3369 }
3373 }
3375 static void
3378 {
3381 /* ELS cmd tag <ulpIoTag> completes */
3383 "0133 Ignoring ELS cmd tag x%x completion Data: "
3389 else
3392 }
3394 int
3397 {
3404 /*
3405 * There are certain command types we don't want to abort. And we
3406 * don't want to abort commands that are already in the process of
3407 * being aborted.
3408 */
3415 /* If we're unloading, don't abort iocb on the ELS ring, but change the
3416 * callback so that nothing happens when it finishes.
3417 */
3422 else
3425 }
3427 /* issue ABTS for this IOCB based on iotag */
3432 /* This signals the response to set the correct status
3433 * before calling the completion handler.
3434 */
3446 else
3452 "0339 Abort xri x%x, original iotag x%x, "
3458 abort_iotag_exit:
3459 /*
3460 * Caller to this routine should check for IOCB_ERROR
3461 * and handle it properly. This routine no longer removes
3462 * iocb off txcmplq and call compl in case of IOCB_ERROR.
3463 */
3465 }
3467 static int
3470 lpfc_ctx_cmd ctx_cmd)
3471 {
3505 }
3508 }
3510 int
3512 lpfc_ctx_cmd ctx_cmd)
3513 {
3523 sum++;
3524 }
3527 }
3529 void
3532 {
3535 }
3537 int
3540 {
3555 /* issue ABTS for this IOCB based on iotag */
3558 errcnt++;
3560 }
3572 else
3575 /* Setup callback routine and issue the command. */
3580 errcnt++;
3582 }
3583 }
3586 }
3588 static void
3592 {
3607 }
3609 /*
3610 * Issue the caller's iocb and wait for its completion, but no longer than the
3611 * caller's timeout. Note that iocb_flags is cleared before the
3612 * lpfc_sli_issue_call since the wake routine sets a unique value and by
3613 * definition this is a wait function.
3614 */
3616 int
3622 {
3628 /*
3629 * If the caller has provided a response iocbq buffer, then context2
3630 * is NULL or its an error.
3631 */
3636 }
3647 }
3654 timeout_req);
3661 "0338 IOCB wait timeout error - no "
3666 "0330 IOCB wake NOT set, "
3670 }
3674 retval);
3676 }
3683 }
3691 }
3693 int
3696 {
3701 /* The caller must leave context1 empty. */
3705 /* setup wake call as IOCB callback */
3707 /* setup context field to pass wait_queue pointer to wake function */
3710 /* now issue the command */
3720 /*
3721 * if LPFC_MBX_WAKE flag is set the mailbox is completed
3722 * else do not free the resources.
3723 */
3729 }
3731 }
3734 }
3736 int
3738 {
3747 /*
3748 * Call lpfc_sli_handle_mb_event only if a mailbox cmd
3749 * did finish. This way we won't get the misleading
3750 * "Stray Mailbox Interrupt" message.
3751 */
3762 }
3765 }
3767 irqreturn_t
3769 {
3784 /*
3785 * Get the driver's phba structure from the dev_id and
3786 * assume the HBA is not interrupting.
3787 */
3793 /* If the pci channel is offline, ignore all the interrupts. */
3799 /*
3800 * Call the HBA to see if it is interrupting. If not, don't claim
3801 * the interrupt
3802 */
3804 /* Ignore all interrupts during initialization. */
3808 /*
3809 * Read host attention register to determine interrupt source
3810 * Clear Attention Sources, except Error Attention (to
3811 * preserve status) and Link Attention
3812 */
3815 /* If somebody is waiting to handle an eratt don't process it
3816 * here. The brdkill function will do this.
3817 */
3832 /*
3833 * Turn off Link Attention interrupts
3834 * until CLEAR_LA done
3835 */
3843 }
3844 else
3846 }
3849 /*
3850 * Turn off Slow Rings interrupts, LPFC_ELS_RING is
3851 * the only slow ring.
3852 */
3867 "ISR Disable ring:"
3873 control &=
3877 }
3880 "ISR slow ring: pwork:"
3885 }
3887 }
3888 }
3892 /*
3893 * There was a link/board error. Read the
3894 * status register to retrieve the error event
3895 * and process it.
3896 */
3898 /* Save status info */
3903 /* Clear Chip error bit */
3907 }
3916 /* First check out the status word */
3919 /*
3920 * Stray Mailbox Interrupt, mbxCommand <cmd>
3921 * mbxStatus <status>
3922 */
3924 LOG_SLI,
3925 "(%d):0304 Stray Mailbox "
3926 "Interrupt mbxCommand x%x "
3931 }
3938 MAILBOX_CMD_SIZE);
3939 }
3944 LPFC_DISC_TRC_MBOX_VPORT,
3955 /* Reg_LOGIN of dflt RPI was successful.
3956 * new lets get rid of the RPI using the
3957 * same mbox buffer.
3958 */
3970 }
3971 }
3976 }
3979 send_next_mbox:
3984 send_current_mbox:
3985 /* Process next mailbox command if there is one */
3992 }
3994 /* Turn on IOCB processing */
3997 }
3999 }
4006 }
4010 /*
4011 * Process all events on FCP ring. Take the optimized path for
4012 * FCP IO. Any other IO is slow path and is handled by
4013 * the worker thread.
4014 */
4020 status);
4023 /*
4024 * Process all events on extra ring. Take the optimized path
4025 * for extra ring IO. Any other IO is slow path and is handled
4026 * by the worker thread.
4027 */
4033 status);
4034 }
4035 }