| blob | 2da75d85de8463fe3b8daf1088a6a1d10882de62 |
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 }
549 }
551 void
553 {
557 /* Return all memory used by all HBQs */
564 }
565 }
567 static void
570 {
574 /* Get next HBQ entry slot to use */
585 /* Sync SLIM */
588 /* flush */
591 }
592 }
603 };
607 };
609 int
611 {
619 }
621 /* Populate HBQ entries */
624 GFP_KERNEL);
634 }
636 }
638 int
640 {
643 }
645 int
647 {
650 }
654 {
662 }
663 }
668 }
670 void
672 {
678 }
679 }
681 static int
683 {
740 }
742 }
743 static void
745 {
749 /*
750 * If pdone_q is empty, the driver thread gave up waiting and
751 * continued running.
752 */
760 }
762 void
764 {
774 }
776 /*
777 * If a REG_LOGIN succeeded after node is destroyed or node
778 * is in re-discovery driver need to cleanup the RPI.
779 */
790 }
794 }
796 int
798 {
806 /* Get all completed mailboxe buffers into the cmplq */
811 /* Get a Mailbox buffer to setup mailbox commands for callback */
822 LPFC_DISC_TRC_MBOX_VPORT,
827 }
830 LPFC_DISC_TRC_MBOX,
835 }
836 }
838 /*
839 * It is a fatal error if unknown mbox command completion.
840 */
842 MBX_SHUTDOWN) {
843 /* Unknow mailbox command compl */
845 "(%d):0323 Unknown Mailbox command "
853 }
858 /* Mbox cmd cmpl error - RETRYing */
861 "(%d):0305 Mbox cmd cmpl "
862 "error - RETRYing Data: x%x "
877 }
878 }
880 /* Mailbox cmd <cmd> Cmpl <cmpl> */
882 "(%d):0307 Mailbox cmd x%x Cmpl x%p "
901 }
905 {
921 }
924 }
926 static int
929 {
944 w5p =
950 /* Firmware Workaround */
958 }
959 }
968 }
970 /* unSolicited Responses */
974 saveq);
977 /* We must search, based on rctl / type
978 for the right routine */
980 i++) {
982 Rctl)
990 }
991 }
992 }
994 /* Unexpected Rctl / Type received */
995 /* Ring <ringno> handler: unexpected
996 Rctl <Rctl> Type <Type> received */
998 "0313 Ring %d handler: unexpected Rctl x%x "
1001 }
1003 }
1009 {
1020 }
1023 "0317 iotag x%x is out off "
1028 }
1030 static int
1033 {
1038 /* Based on the iotag field, get the cmd IOCB from the txcmplq */
1045 /*
1046 * Post all ELS completions to the worker thread.
1047 * All other are passed to the completion callback.
1048 */
1054 IOSTAT_LOCAL_REJECT;
1056 IOERR_SLI_ABORTED;
1057 }
1058 }
1063 /*
1064 * Unknown initiating command based on the response iotag.
1065 * This could be the case on the ELS ring because of
1066 * lpfc_els_abort().
1067 */
1069 /*
1070 * Ring <ringno> handler: unexpected completion IoTag
1071 * <IoTag>
1072 */
1074 "0322 Ring %d handler: "
1075 "unexpected completion IoTag x%x "
1083 }
1084 }
1087 }
1089 static void
1091 {
1095 /*
1096 * Ring <ringno> handler: portRspPut <portRspPut> is bigger then
1097 * rsp ring <portRspMax>
1098 */
1100 "0312 Ring %d handler: portRspPut %d "
1107 /*
1108 * All error attention handlers are posted to
1109 * worker thread
1110 */
1114 /* hbalock should already be held */
1119 }
1122 {
1144 /*
1145 * The next available response entry should never exceed the maximum
1146 * entries. If it does, treat it as an adapter hardware error.
1147 */
1153 }
1167 rsp_cmpl++;
1170 /* Rsp ring <ringno> error: IOCB */
1172 "0326 Rsp Ring %d error: IOCB Data: "
1183 }
1188 /*
1189 * Idle exchange closed via ABTS from port. No iocb
1190 * resources need to be recovered.
1191 */
1194 "0314 IOCB cmd 0x%x "
1195 "processed. Skipping "
1199 }
1208 }
1215 MAX_MSG_DATA);
1219 /* Unknown IOCB command */
1221 "0321 Unknown IOCB command "
1227 }
1229 }
1231 /*
1232 * The response IOCB has been processed. Update the ring
1233 * pointer in SLIM. If the port response put pointer has not
1234 * been updated, sync the pgp->rspPutInx and fetch the new port
1235 * response put pointer.
1236 */
1241 }
1253 }
1260 /* Force update of the local copy of cmdGetInx */
1268 }
1271 }
1273 /*
1274 * This routine presumes LPFC_FCP_RING handling and doesn't bother
1275 * to check it explicitly.
1276 */
1277 static int
1280 {
1291 lpfc_iocb_type type;
1298 /*
1299 * The next available response entry should never exceed the maximum
1300 * entries. If it does, treat it as an adapter hardware error.
1301 */
1308 }
1312 /*
1313 * Fetch an entry off the ring and copy it into a local data
1314 * structure. The copy involves a byte-swap since the
1315 * network byte order and pci byte orders are different.
1316 */
1331 rsp_cmpl++;
1334 /*
1335 * If resource errors reported from HBA, reduce
1336 * queuedepths of the SCSI device.
1337 */
1343 }
1345 /* Rsp ring <ringno> error: IOCB */
1347 "0336 Rsp Ring %d error: IOCB Data: "
1358 }
1363 /*
1364 * Idle exchange closed via ABTS from port. No iocb
1365 * resources need to be recovered.
1366 */
1369 "0333 IOCB cmd 0x%x"
1370 " processed. Skipping"
1374 }
1384 iflag);
1388 iflag);
1389 }
1390 }
1402 MAX_MSG_DATA);
1406 /* Unknown IOCB command */
1408 "0334 Unknown IOCB command "
1414 }
1416 }
1418 /*
1419 * The response IOCB has been processed. Update the ring
1420 * pointer in SLIM. If the port response put pointer has not
1421 * been updated, sync the pgp->rspPutInx and fetch the new port
1422 * response put pointer.
1423 */
1428 }
1435 }
1440 /* Force update of the local copy of cmdGetInx */
1447 }
1451 }
1453 int
1456 {
1467 lpfc_iocb_type type;
1476 /*
1477 * The next available response entry should never exceed the maximum
1478 * entries. If it does, treat it as an adapter hardware error.
1479 */
1483 /*
1484 * Ring <ringno> handler: portRspPut <portRspPut> is bigger then
1485 * rsp ring <portRspMax>
1486 */
1488 "0303 Ring %d handler: portRspPut %d "
1499 }
1503 /*
1504 * Build a completion list and call the appropriate handler.
1505 * The process is to get the next available response iocb, get
1506 * a free iocb from the list, copy the response data into the
1507 * free iocb, insert to the continuation list, and update the
1508 * next response index to slim. This process makes response
1509 * iocb's in the ring available to DMA as fast as possible but
1510 * pays a penalty for a copy operation. Since the iocb is
1511 * only 32 bytes, this penalty is considered small relative to
1512 * the PCI reads for register values and a slim write. When
1513 * the ulpLe field is set, the entire Command has been
1514 * received.
1515 */
1524 }
1539 }
1548 }
1552 /*
1553 * By default, the driver expects to free all resources
1554 * associated with this iocb completion.
1555 */
1565 /*
1566 * If resource errors reported from HBA, reduce
1567 * queuedepths of the SCSI device.
1568 */
1574 }
1577 /* Rsp ring <ringno> error: IOCB */
1579 "0328 Rsp Ring %d error: "
1580 "IOCB Data: "
1581 "x%x x%x x%x x%x "
1582 "x%x x%x x%x x%x "
1583 "x%x x%x x%x x%x "
1602 }
1604 /*
1605 * Fetch the IOCB command type and call the correct
1606 * completion routine. Solicited and Unsolicited
1607 * IOCBs on the ELS ring get freed back to the
1608 * lpfc_iocb_list by the discovery kernel thread.
1609 */
1614 iflag);
1616 saveq);
1620 iflag);
1622 saveq);
1628 saveq)))) {
1629 /* Call the specified completion
1630 routine */
1634 iflag);
1639 iflag);
1642 cmdiocbp);
1643 }
1650 LPFC_MAX_ADPTMSG);
1652 MAX_MSG_DATA);
1657 /* Unknown IOCB command */
1659 "0335 Unknown IOCB "
1660 "command Data: x%x "
1666 }
1667 }
1674 rspiocbp);
1675 }
1677 }
1679 }
1681 /*
1682 * If the port response put pointer has not been updated, sync
1683 * the pgp->rspPutInx in the MAILBOX_tand fetch the new port
1684 * response put pointer.
1685 */
1688 }
1692 /* At least one response entry has been freed */
1694 /* SET RxRE_RSP in Chip Att register */
1698 }
1703 /* Force update of the local copy of cmdGetInx */
1710 }
1714 }
1716 void
1718 {
1725 }
1727 /* Error everything on txq and txcmplq
1728 * First do the txq.
1729 */
1734 /* Next issue ABTS for everything on the txcmplq */
1751 }
1752 }
1753 }
1755 int
1757 {
1762 /* Read the HBA Host Status Register */
1765 /*
1766 * Check status register every 100ms for 5 retries, then every
1767 * 500ms for 5, then every 2.5 sec for 5, then reset board and
1768 * every 2.5 sec for 4.
1769 * Break our of the loop if errors occurred during init.
1770 */
1779 else
1783 /* Do post */
1786 }
1787 /* Read the HBA Host Status Register */
1789 }
1791 /* Check to see if any errors occurred during init */
1795 }
1798 }
1800 #define BARRIER_TEST_PATTERN (0xdeadbeef)
1803 {
1817 /*
1818 * Tell the other part of the chip to suspend temporarily all
1819 * its DMA activity.
1820 */
1823 /* Disable the error attention */
1830 /* Clear Chip error bit */
1833 }
1851 else
1853 }
1859 clear_errat:
1867 }
1869 restore_hc:
1873 }
1875 int
1877 {
1887 /* Kill HBA */
1896 /* Disable the error attention */
1916 }
1922 /* There is no completion for a KILL_BOARD mbox cmd. Check for an error
1923 * attention every 100ms for 3 seconds. If we don't get ERATT after
1924 * 3 seconds we still set HBA_ERROR state because the status of the
1925 * board is now undefined.
1926 */
1932 }
1938 }
1949 }
1951 int
1953 {
1961 /* Reset HBA */
1966 /* perform board reset */
1971 /* Turn off parity checking and serr during the physical reset */
1978 /* Now toggle INITFF bit in the Host Control Register */
1985 /* Restore PCI cmd register */
1988 /* Initialize relevant SLI info */
1997 }
2001 }
2003 int
2005 {
2016 /* Restart HBA */
2032 /* Only skip post after fc_ffinit is completed */
2039 }
2055 else
2061 }
2063 static int
2065 {
2068 /* Read the HBA Host Status Register */
2071 /* Check status register to see what current state is */
2075 /* Check every 100ms for 5 retries, then every 500ms for 5, then
2076 * every 2.5 sec for 5, then reset board and every 2.5 sec for
2077 * 4.
2078 */
2080 /* Adapter failed to init, timeout, status reg
2081 <status> */
2083 "0436 Adapter failed to init, "
2087 }
2089 /* Check to see if any errors occurred during init */
2091 /* ERROR: During chipset initialization */
2092 /* Adapter failed to init, chipset, status reg
2093 <status> */
2095 "0437 Adapter failed to init, "
2099 }
2107 }
2110 /* Do post */
2113 }
2114 /* Read the HBA Host Status Register */
2116 }
2118 /* Check to see if any errors occurred during init */
2120 /* ERROR: During chipset initialization */
2121 /* Adapter failed to init, chipset, status reg <status> */
2123 "0438 Adapter failed to init, chipset, "
2127 }
2129 /* Clear all interrupt enable conditions */
2133 /* setup host attn register */
2137 }
2139 static int
2141 {
2143 }
2145 static int
2147 {
2155 }
2157 int
2159 {
2161 }
2163 static int
2165 {
2172 /* Get a Mailbox buffer to setup mailbox
2173 * commands for HBA initialization
2174 */
2182 /* Initialize the struct lpfc_sli_hbq structure for each hbq */
2193 pmb);
2197 /* Adapter failed to init, mbxCmd <cmd> CFG_RING,
2198 mbxStatus <status>, ring <num> */
2202 "1805 Adapter failed to init. "
2210 }
2211 }
2216 /* Initially populate or replenish the HBQs */
2220 }
2222 }
2224 static int
2226 {
2234 }
2251 resetcount++;
2253 /* Call pre CONFIG_PORT mailbox command initialization. A
2254 * value of 0 means the call was successful. Any other
2255 * nonzero value is a failure, but if ERESTART is returned,
2256 * the driver may reset the HBA and try again.
2257 */
2264 }
2271 "0442 Adapter failed to init, mbxCmd x%x "
2284 }
2285 }
2290 }
2296 }
2299 do_prep_failed:
2302 }
2304 int
2306 {
2314 "1824 NPIV enabled: Override lpfc_sli_mode "
2316 lpfc_sli_mode);
2318 }
2326 "1819 Unrecognized lpfc_sli_mode "
2330 }
2335 "1820 Unable to select SLI-3. "
2352 }
2362 /* Init HBQs */
2368 }
2378 lpfc_sli_hba_setup_error:
2383 }
2385 /*! lpfc_mbox_timeout
2386 *
2387 * \pre
2388 * \post
2389 * \param hba Pointer to per struct lpfc_hba structure
2390 * \param l1 Pointer to the driver's mailbox queue.
2391 * \return
2392 * void
2393 *
2394 * \b Description:
2395 *
2396 * This routine handles mailbox timeout events at timer interrupt context.
2397 */
2398 void
2400 {
2416 }
2417 }
2419 void
2421 {
2429 }
2431 /* Mbox cmd <mbxCommand> timeout */
2439 /* Setting state unknown so lpfc_sli_abort_iocb_ring
2440 * would get IOCB_ERROR from lpfc_sli_issue_iocb, allowing
2441 * it to fail all oustanding SCSI IO.
2442 */
2457 /*
2458 * lpfc_offline calls lpfc_sli_hba_down which will clean up
2459 * on oustanding mailbox commands.
2460 */
2468 }
2470 int
2472 {
2491 }
2492 }
2495 /* If the PCI channel is in offline state, do not post mbox. */
2509 /* Mbox command <mbxCommand> cannot issue */
2512 }
2519 }
2522 /* Polling for a mbox command when another one is already active
2523 * is not allowed in SLI. Also, the driver must have established
2524 * SLI2 mode to queue and process multiple mbox commands.
2525 */
2530 /* Mbox command <mbxCommand> cannot issue */
2533 }
2537 /* Mbox command <mbxCommand> cannot issue */
2540 }
2542 /* Handle STOP IOCB processing flag. This is only meaningful
2543 * if we are not polling for mbox completion.
2544 */
2547 /* Now flag each ring */
2549 /* If the ring is active, flag it */
2552 LPFC_STOP_IOCB_MBX;
2553 }
2554 }
2555 }
2557 /* Another mailbox command is still being processed, queue this
2558 * command to be processed later.
2559 */
2562 /* Mbox cmd issue - BUSY */
2564 "(%d):0308 Mbox cmd issue - BUSY Data: "
2575 LPFC_DISC_TRC_MBOX_VPORT,
2579 }
2582 LPFC_DISC_TRC_MBOX,
2586 }
2589 }
2591 /* Handle STOP IOCB processing flag. This is only meaningful
2592 * if we are not polling for mbox completion.
2593 */
2597 /* Now flag each ring */
2599 /* If the ring is active, flag it */
2602 LPFC_STOP_IOCB_MBX;
2603 }
2604 }
2605 }
2606 }
2610 /* If we are not polling, we MUST be in SLI2 mode */
2616 /* Mbox command <mbxCommand> cannot issue */
2619 }
2620 /* timeout active mbox command */
2623 }
2625 /* Mailbox cmd <cmd> issue */
2627 "(%d):0309 Mailbox cmd x%x issue Data: x%x x%x "
2636 LPFC_DISC_TRC_MBOX_VPORT,
2640 }
2643 LPFC_DISC_TRC_MBOX,
2647 }
2648 }
2653 /* next set own bit for the adapter and copy over command word */
2657 /* First copy command data to host SLIM area */
2661 /* copy command data into host mbox for cmpl */
2663 MAILBOX_CMD_SIZE);
2664 }
2666 /* First copy mbox command data to HBA SLIM, skip past first
2667 word */
2672 /* Next copy over first word, with mbxOwner set */
2679 /* switch over to host mailbox */
2681 }
2682 }
2685 /* interrupt board to doit right away */
2691 /* Don't wait for it to finish, just return */
2698 /* First read mbox status word */
2702 /* First read mbox status word */
2704 }
2706 /* Read the HBA Host Attention Register */
2712 /* Wait for command to complete */
2719 drvr_flag);
2721 }
2723 /* Check if we took a mbox interrupt while we were
2724 polling */
2730 drvr_flag);
2737 /* First copy command data */
2744 /* Check real SLIM for any errors */
2752 }
2753 }
2755 /* First copy command data */
2757 }
2758 /* Read the HBA Host Attention Register */
2760 }
2763 /* copy results back to user */
2765 MAILBOX_CMD_SIZE);
2767 /* First copy command data */
2769 MAILBOX_CMD_SIZE);
2775 }
2776 }
2783 }
2787 }
2789 /*
2790 * Caller needs to hold lock.
2791 */
2792 static void
2795 {
2796 /* Insert the caller's iocb in the txq tail for later processing. */
2799 }
2804 {
2811 }
2814 }
2816 /*
2817 * Lockless version of lpfc_sli_issue_iocb.
2818 */
2819 int
2822 {
2835 }
2838 /* If the PCI channel is in offline state, do not post iocbs. */
2842 /*
2843 * We should never get an IOCB if we are in a < LINK_DOWN state
2844 */
2848 /*
2849 * Check to see if we are blocking IOCB processing because of a
2850 * outstanding mbox command.
2851 */
2856 /*
2857 * Only CREATE_XRI, CLOSE_XRI, and QUE_RING_BUF
2858 * can be issued if the link is not up.
2859 */
2863 /*
2864 * For IOCBs, like QUE_RING_BUF, that have no rsp ring
2865 * completion, iocb_cmpl MUST be 0.
2866 */
2869 /*FALLTHROUGH*/
2876 }
2878 /*
2879 * For FCP commands, we must be in a state where we can process link
2880 * attention events.
2881 */
2885 }
2893 else
2901 iocb_busy:
2904 out_busy:
2909 }
2912 }
2915 int
2918 {
2927 }
2929 static int
2931 {
2937 /* Adjust cmd/rsp ring iocb entries more evenly */
2939 /* Take some away from the FCP ring */
2946 /* and give them to the extra ring */
2954 /* Setup default profile for this ring */
2962 }
2964 int
2966 {
2985 /* numCiocb and numRiocb are used in config_port */
2993 SLI3_IOCB_CMD_SIZE :
2994 SLI2_IOCB_CMD_SIZE;
2996 SLI3_IOCB_RSP_SIZE :
2997 SLI2_IOCB_RSP_SIZE;
3005 /* numCiocb and numRiocb are used in config_port */
3009 SLI3_IOCB_CMD_SIZE :
3010 SLI2_IOCB_CMD_SIZE;
3012 SLI3_IOCB_RSP_SIZE :
3013 SLI2_IOCB_RSP_SIZE;
3018 /* numCiocb and numRiocb are used in config_port */
3022 SLI3_IOCB_CMD_SIZE :
3023 SLI2_IOCB_CMD_SIZE;
3025 SLI3_IOCB_RSP_SIZE :
3026 SLI2_IOCB_RSP_SIZE;
3035 lpfc_els_unsol_event;
3040 lpfc_els_unsol_event;
3042 /* NameServer Inquiry */
3044 /* NameServer */
3047 lpfc_ct_unsol_event;
3049 /* NameServer response */
3051 /* NameServer */
3054 lpfc_ct_unsol_event;
3056 }
3059 }
3061 /* Too many cmd / rsp ring entries in SLI2 SLIM */
3066 }
3071 }
3073 int
3075 {
3084 /* Initialize list headers for txq and txcmplq as double linked lists */
3095 }
3098 }
3100 int
3102 {
3120 /*
3121 * Error everything on the txq since these iocbs have not been
3122 * given to the FW yet.
3123 */
3129 }
3131 /* Next issue ABTS for everything on the txcmplq */
3133 list) {
3137 }
3140 }
3153 }
3154 }
3156 }
3158 int
3160 {
3180 /*
3181 * Error everything on the txq since these iocbs have not been
3182 * given to the FW yet.
3183 */
3187 }
3200 }
3201 }
3203 /* Return any active mbox cmds */
3215 }
3217 /* Return any pending or completed mbox cmds */
3230 }
3231 }
3233 }
3235 void
3237 {
3247 src++;
3248 dest++;
3249 }
3250 }
3252 int
3255 {
3256 /* Stick struct lpfc_dmabuf at end of postbufq so driver can look it up
3257 later */
3263 }
3268 dma_addr_t phys)
3269 {
3273 /* Search postbufq, from the begining, looking for a match on phys */
3281 }
3282 }
3286 "0410 Cannot find virtual addr for mapped buf on "
3291 }
3293 static void
3296 {
3313 "0327 Cannot abort els iocb %p "
3314 "with tag %x context %x, abort status %x, "
3319 /*
3320 * make sure we have the right iocbq before taking it
3321 * off the txcmplq and try to call completion routine.
3322 */
3336 }
3337 }
3341 }
3343 static void
3346 {
3349 /* ELS cmd tag <ulpIoTag> completes */
3351 "0133 Ignoring ELS cmd tag x%x completion Data: "
3357 else
3360 }
3362 int
3365 {
3372 /*
3373 * There are certain command types we don't want to abort. And we
3374 * don't want to abort commands that are already in the process of
3375 * being aborted.
3376 */
3383 /* If we're unloading, don't abort iocb on the ELS ring, but change the
3384 * callback so that nothing happens when it finishes.
3385 */
3390 else
3393 }
3395 /* issue ABTS for this IOCB based on iotag */
3400 /* This signals the response to set the correct status
3401 * before calling the completion handler.
3402 */
3414 else
3420 "0339 Abort xri x%x, original iotag x%x, "
3426 abort_iotag_exit:
3427 /*
3428 * Caller to this routine should check for IOCB_ERROR
3429 * and handle it properly. This routine no longer removes
3430 * iocb off txcmplq and call compl in case of IOCB_ERROR.
3431 */
3433 }
3435 static int
3438 lpfc_ctx_cmd ctx_cmd)
3439 {
3474 }
3477 }
3479 int
3482 {
3491 sum++;
3492 }
3495 }
3497 void
3500 {
3503 }
3505 int
3508 lpfc_ctx_cmd abort_cmd)
3509 {
3523 /* issue ABTS for this IOCB based on iotag */
3526 errcnt++;
3528 }
3540 else
3543 /* Setup callback routine and issue the command. */
3548 errcnt++;
3550 }
3551 }
3554 }
3556 static void
3560 {
3575 }
3577 /*
3578 * Issue the caller's iocb and wait for its completion, but no longer than the
3579 * caller's timeout. Note that iocb_flags is cleared before the
3580 * lpfc_sli_issue_call since the wake routine sets a unique value and by
3581 * definition this is a wait function.
3582 */
3584 int
3590 {
3596 /*
3597 * If the caller has provided a response iocbq buffer, then context2
3598 * is NULL or its an error.
3599 */
3604 }
3615 }
3622 timeout_req);
3629 "0338 IOCB wait timeout error - no "
3634 "0330 IOCB wake NOT set, "
3638 }
3642 retval);
3644 }
3651 }
3659 }
3661 int
3664 {
3669 /* The caller must leave context1 empty. */
3673 /* setup wake call as IOCB callback */
3675 /* setup context field to pass wait_queue pointer to wake function */
3678 /* now issue the command */
3688 /*
3689 * if LPFC_MBX_WAKE flag is set the mailbox is completed
3690 * else do not free the resources.
3691 */
3697 }
3699 }
3702 }
3704 int
3706 {
3715 /*
3716 * Call lpfc_sli_handle_mb_event only if a mailbox cmd
3717 * did finish. This way we won't get the misleading
3718 * "Stray Mailbox Interrupt" message.
3719 */
3730 }
3733 }
3735 irqreturn_t
3737 {
3752 /*
3753 * Get the driver's phba structure from the dev_id and
3754 * assume the HBA is not interrupting.
3755 */
3761 /* If the pci channel is offline, ignore all the interrupts. */
3767 /*
3768 * Call the HBA to see if it is interrupting. If not, don't claim
3769 * the interrupt
3770 */
3772 /* Ignore all interrupts during initialization. */
3776 /*
3777 * Read host attention register to determine interrupt source
3778 * Clear Attention Sources, except Error Attention (to
3779 * preserve status) and Link Attention
3780 */
3783 /* If somebody is waiting to handle an eratt don't process it
3784 * here. The brdkill function will do this.
3785 */
3800 /*
3801 * Turn off Link Attention interrupts
3802 * until CLEAR_LA done
3803 */
3811 }
3812 else
3814 }
3817 /*
3818 * Turn off Slow Rings interrupts, LPFC_ELS_RING is
3819 * the only slow ring.
3820 */
3835 "ISR Disable ring:"
3841 control &=
3845 }
3848 "ISR slow ring: pwork:"
3853 }
3855 }
3856 }
3860 /*
3861 * There was a link/board error. Read the
3862 * status register to retrieve the error event
3863 * and process it.
3864 */
3866 /* Save status info */
3871 /* Clear Chip error bit */
3875 }
3884 /* First check out the status word */
3887 /*
3888 * Stray Mailbox Interrupt, mbxCommand <cmd>
3889 * mbxStatus <status>
3890 */
3892 LOG_SLI,
3893 "(%d):0304 Stray Mailbox "
3894 "Interrupt mbxCommand x%x "
3899 }
3906 MAILBOX_CMD_SIZE);
3907 }
3912 LPFC_DISC_TRC_MBOX_VPORT,
3923 /* Reg_LOGIN of dflt RPI was successful.
3924 * new lets get rid of the RPI using the
3925 * same mbox buffer.
3926 */
3938 }
3939 }
3944 }
3947 send_next_mbox:
3952 send_current_mbox:
3953 /* Process next mailbox command if there is one */
3960 }
3962 /* Turn on IOCB processing */
3965 }
3967 }
3974 }
3978 /*
3979 * Process all events on FCP ring. Take the optimized path for
3980 * FCP IO. Any other IO is slow path and is handled by
3981 * the worker thread.
3982 */
3988 status);
3991 /*
3992 * Process all events on extra ring. Take the optimized path
3993 * for extra ring IO. Any other IO is slow path and is handled
3994 * by the worker thread.
3995 */
4001 status);
4002 }
4003 }