| blob | fc0d9501aba628f41a79c0b4a8ae31f384d60ab2 |
1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2008 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 {
228 }
231 }
233 static int
235 {
251 "0446 Adapter failed to init (%d), "
252 "mbxCmd x%x CFG_RING, mbxStatus x%x, "
259 }
260 }
263 }
265 static int
268 {
276 else
279 }
283 }
287 {
294 }
298 {
314 "0315 Ring %d issue: portCmdGet %d "
320 /*
321 * All error attention handlers are posted to
322 * worker thread
323 */
327 /* hbalock should already be held */
332 }
336 }
339 }
341 uint16_t
343 {
363 GFP_KERNEL);
368 /* highly unprobable case */
377 }
380 }
393 }
402 }
404 static void
407 {
408 /*
409 * Set up an iotag
410 */
419 }
421 /*
422 * Issue iocb command to adapter
423 */
428 /*
429 * If there is no completion routine to call, we can release the
430 * IOCB buffer back right now. For IOCBs, like QUE_RING_BUF,
431 * that have no rsp ring completion, iocb_cmpl MUST be NULL.
432 */
435 else
438 /*
439 * Let the HBA know what IOCB slot will be the next one the
440 * driver will put a command into.
441 */
444 }
446 static void
448 {
455 /*
456 * Set ring 'ringno' to SET R0CE_REQ in Chip Att register.
457 * The HBA will tell us when an IOCB entry is available.
458 */
463 }
465 static void
467 {
470 /*
471 * Tell the HBA that there is work to do in this ring.
472 */
476 }
478 static void
480 {
484 /*
485 * Check to see if:
486 * (a) there is anything on the txq to send
487 * (b) link is up
488 * (c) link attention events can be processed (fcp ring only)
489 * (d) IOCB processing is not blocked by the outstanding mbox command.
490 */
502 else
504 }
507 }
511 {
527 "1802 HBQ %d: local_hbqGetIdx "
534 }
538 }
542 }
544 void
546 {
554 /* Return all memory used by all HBQs */
562 }
564 }
565 /* Return all HBQ buffer that are in-fly */
578 else
580 hbq_buf);
581 }
582 }
584 /* Mark the HBQs not in use */
587 }
592 {
596 /* Get next HBQ entry slot to use */
607 /* Sync SLIM */
610 /* flush */
613 }
615 }
626 };
637 };
642 };
644 static int
646 {
659 /* Check whether HBQ is still in use */
664 /* Populate HBQ entries */
672 else
674 }
676 out:
679 err:
682 }
684 int
686 {
689 }
691 static int
693 {
696 }
700 {
713 }
714 }
719 }
721 void
723 {
730 }
731 }
732 }
734 static int
736 {
795 }
797 }
798 static void
800 {
804 /*
805 * If pdone_q is empty, the driver thread gave up waiting and
806 * continued running.
807 */
815 }
817 void
819 {
829 }
831 /*
832 * If a REG_LOGIN succeeded after node is destroyed or node
833 * is in re-discovery driver need to cleanup the RPI.
834 */
845 }
849 }
851 int
853 {
861 /* Get all completed mailboxe buffers into the cmplq */
866 /* Get a Mailbox buffer to setup mailbox commands for callback */
877 LPFC_DISC_TRC_MBOX_VPORT,
882 }
885 LPFC_DISC_TRC_MBOX,
890 }
891 }
893 /*
894 * It is a fatal error if unknown mbox command completion.
895 */
897 MBX_SHUTDOWN) {
898 /* Unknow mailbox command compl */
900 "(%d):0323 Unknown Mailbox command "
908 }
913 /* Mbox cmd cmpl error - RETRYing */
916 "(%d):0305 Mbox cmd cmpl "
917 "error - RETRYing Data: x%x "
932 }
933 }
935 /* Mailbox cmd <cmd> Cmpl <cmpl> */
937 "(%d):0307 Mailbox cmd x%x Cmpl x%p "
956 }
960 {
967 /* Check whether HBQ is still in use */
972 }
978 }
987 }
1000 }
1006 {
1009 else
1011 }
1013 static int
1016 {
1032 else
1034 KERN_WARNING,
1035 LOG_SLI,
1036 "0316 Ring %d handler: unexpected "
1037 "ASYNC_STATUS iocb received evt_code "
1042 }
1050 }
1056 }
1062 }
1065 }
1073 KERN_ERR,
1074 LOG_SLI,
1075 "0341 Ring %d Cannot find buffer for "
1079 }
1085 KERN_ERR,
1086 LOG_SLI,
1087 "0342 Ring %d Cannot find buffer for an"
1091 }
1099 KERN_ERR,
1100 LOG_SLI,
1101 "0343 Ring %d Cannot find "
1102 "buffer for an unsolicited iocb"
1105 }
1111 KERN_ERR,
1112 LOG_SLI,
1113 "0344 Ring %d Cannot find "
1114 "buffer for an unsolicited "
1118 }
1119 }
1120 }
1126 /* search continue save q for same XRI */
1132 }
1133 }
1143 }
1154 /* Firmware Workaround */
1162 }
1163 }
1165 /* unSolicited Responses */
1169 saveq);
1172 /* We must search, based on rctl / type
1173 for the right routine */
1182 }
1183 }
1184 }
1186 /* Unexpected Rctl / Type received */
1187 /* Ring <ringno> handler: unexpected
1188 Rctl <Rctl> Type <Type> received */
1190 "0313 Ring %d handler: unexpected Rctl x%x "
1193 }
1195 }
1201 {
1212 }
1215 "0317 iotag x%x is out off "
1220 }
1222 static int
1225 {
1230 /* Based on the iotag field, get the cmd IOCB from the txcmplq */
1237 /*
1238 * Post all ELS completions to the worker thread.
1239 * All other are passed to the completion callback.
1240 */
1246 IOSTAT_LOCAL_REJECT;
1248 IOERR_SLI_ABORTED;
1250 /* Firmware could still be in progress
1251 * of DMAing payload, so don't free data
1252 * buffer till after a hbeat.
1253 */
1255 }
1256 }
1261 /*
1262 * Unknown initiating command based on the response iotag.
1263 * This could be the case on the ELS ring because of
1264 * lpfc_els_abort().
1265 */
1267 /*
1268 * Ring <ringno> handler: unexpected completion IoTag
1269 * <IoTag>
1270 */
1272 "0322 Ring %d handler: "
1273 "unexpected completion IoTag x%x "
1281 }
1282 }
1285 }
1287 static void
1289 {
1293 /*
1294 * Ring <ringno> handler: portRspPut <portRspPut> is bigger then
1295 * rsp ring <portRspMax>
1296 */
1298 "0312 Ring %d handler: portRspPut %d "
1305 /*
1306 * All error attention handlers are posted to
1307 * worker thread
1308 */
1312 /* hbalock should already be held */
1317 }
1320 {
1342 /*
1343 * The next available response entry should never exceed the maximum
1344 * entries. If it does, treat it as an adapter hardware error.
1345 */
1351 }
1365 rsp_cmpl++;
1368 /* Rsp ring <ringno> error: IOCB */
1370 "0326 Rsp Ring %d error: IOCB Data: "
1381 }
1386 /*
1387 * Idle exchange closed via ABTS from port. No iocb
1388 * resources need to be recovered.
1389 */
1392 "0314 IOCB cmd 0x%x "
1393 "processed. Skipping "
1397 }
1406 }
1413 MAX_MSG_DATA);
1418 /* Unknown IOCB command */
1420 "0321 Unknown IOCB command "
1426 }
1428 }
1430 /*
1431 * The response IOCB has been processed. Update the ring
1432 * pointer in SLIM. If the port response put pointer has not
1433 * been updated, sync the pgp->rspPutInx and fetch the new port
1434 * response put pointer.
1435 */
1440 }
1452 }
1459 /* Force update of the local copy of cmdGetInx */
1467 }
1470 }
1472 /*
1473 * This routine presumes LPFC_FCP_RING handling and doesn't bother
1474 * to check it explicitly.
1475 */
1476 static int
1479 {
1490 lpfc_iocb_type type;
1497 /*
1498 * The next available response entry should never exceed the maximum
1499 * entries. If it does, treat it as an adapter hardware error.
1500 */
1507 }
1511 /*
1512 * Fetch an entry off the ring and copy it into a local data
1513 * structure. The copy involves a byte-swap since the
1514 * network byte order and pci byte orders are different.
1515 */
1530 rsp_cmpl++;
1533 /*
1534 * If resource errors reported from HBA, reduce
1535 * queuedepths of the SCSI device.
1536 */
1542 }
1544 /* Rsp ring <ringno> error: IOCB */
1546 "0336 Rsp Ring %d error: IOCB Data: "
1557 }
1562 /*
1563 * Idle exchange closed via ABTS from port. No iocb
1564 * resources need to be recovered.
1565 */
1568 "0333 IOCB cmd 0x%x"
1569 " processed. Skipping"
1573 }
1583 iflag);
1587 iflag);
1588 }
1589 }
1601 MAX_MSG_DATA);
1606 /* Unknown IOCB command */
1608 "0334 Unknown IOCB command "
1614 }
1616 }
1618 /*
1619 * The response IOCB has been processed. Update the ring
1620 * pointer in SLIM. If the port response put pointer has not
1621 * been updated, sync the pgp->rspPutInx and fetch the new port
1622 * response put pointer.
1623 */
1628 }
1635 }
1640 /* Force update of the local copy of cmdGetInx */
1647 }
1651 }
1653 int
1656 {
1667 lpfc_iocb_type type;
1676 /*
1677 * The next available response entry should never exceed the maximum
1678 * entries. If it does, treat it as an adapter hardware error.
1679 */
1683 /*
1684 * Ring <ringno> handler: portRspPut <portRspPut> is bigger then
1685 * rsp ring <portRspMax>
1686 */
1688 "0303 Ring %d handler: portRspPut %d "
1699 }
1703 /*
1704 * Build a completion list and call the appropriate handler.
1705 * The process is to get the next available response iocb, get
1706 * a free iocb from the list, copy the response data into the
1707 * free iocb, insert to the continuation list, and update the
1708 * next response index to slim. This process makes response
1709 * iocb's in the ring available to DMA as fast as possible but
1710 * pays a penalty for a copy operation. Since the iocb is
1711 * only 32 bytes, this penalty is considered small relative to
1712 * the PCI reads for register values and a slim write. When
1713 * the ulpLe field is set, the entire Command has been
1714 * received.
1715 */
1724 }
1739 }
1747 /*
1748 * By default, the driver expects to free all resources
1749 * associated with this iocb completion.
1750 */
1760 /*
1761 * If resource errors reported from HBA, reduce
1762 * queuedepths of the SCSI device.
1763 */
1769 }
1772 /* Rsp ring <ringno> error: IOCB */
1774 "0328 Rsp Ring %d error: "
1775 "IOCB Data: "
1776 "x%x x%x x%x x%x "
1777 "x%x x%x x%x x%x "
1778 "x%x x%x x%x x%x "
1797 }
1799 /*
1800 * Fetch the IOCB command type and call the correct
1801 * completion routine. Solicited and Unsolicited
1802 * IOCBs on the ELS ring get freed back to the
1803 * lpfc_iocb_list by the discovery kernel thread.
1804 */
1810 saveq);
1815 saveq);
1823 saveq)))) {
1824 /* Call the specified completion
1825 routine */
1829 iflag);
1834 iflag);
1837 cmdiocbp);
1838 }
1845 LPFC_MAX_ADPTMSG);
1847 MAX_MSG_DATA);
1852 /* Unknown IOCB command */
1854 "0335 Unknown IOCB "
1855 "command Data: x%x "
1861 }
1862 }
1869 rspiocbp);
1870 }
1872 }
1874 }
1876 /*
1877 * If the port response put pointer has not been updated, sync
1878 * the pgp->rspPutInx in the MAILBOX_tand fetch the new port
1879 * response put pointer.
1880 */
1883 }
1887 /* At least one response entry has been freed */
1889 /* SET RxRE_RSP in Chip Att register */
1893 }
1898 /* Force update of the local copy of cmdGetInx */
1905 }
1909 }
1911 void
1913 {
1920 }
1922 /* Error everything on txq and txcmplq
1923 * First do the txq.
1924 */
1929 /* Next issue ABTS for everything on the txcmplq */
1946 }
1947 }
1948 }
1950 int
1952 {
1957 /* Read the HBA Host Status Register */
1960 /*
1961 * Check status register every 100ms for 5 retries, then every
1962 * 500ms for 5, then every 2.5 sec for 5, then reset board and
1963 * every 2.5 sec for 4.
1964 * Break our of the loop if errors occurred during init.
1965 */
1974 else
1978 /* Do post */
1981 }
1982 /* Read the HBA Host Status Register */
1984 }
1986 /* Check to see if any errors occurred during init */
1990 }
1993 }
1995 #define BARRIER_TEST_PATTERN (0xdeadbeef)
1998 {
2012 /*
2013 * Tell the other part of the chip to suspend temporarily all
2014 * its DMA activity.
2015 */
2018 /* Disable the error attention */
2025 /* Clear Chip error bit */
2028 }
2046 else
2048 }
2054 clear_errat:
2062 }
2064 restore_hc:
2068 }
2070 int
2072 {
2082 /* Kill HBA */
2091 /* Disable the error attention */
2111 }
2117 /* There is no completion for a KILL_BOARD mbox cmd. Check for an error
2118 * attention every 100ms for 3 seconds. If we don't get ERATT after
2119 * 3 seconds we still set HBA_ERROR state because the status of the
2120 * board is now undefined.
2121 */
2127 }
2133 }
2144 }
2146 int
2148 {
2156 /* Reset HBA */
2161 /* perform board reset */
2166 /* Turn off parity checking and serr during the physical reset */
2173 /* Now toggle INITFF bit in the Host Control Register */
2180 /* Restore PCI cmd register */
2183 /* Initialize relevant SLI info */
2192 }
2196 }
2198 int
2200 {
2211 /* Restart HBA */
2227 /* Only skip post after fc_ffinit is completed */
2234 }
2250 else
2256 }
2258 static int
2260 {
2263 /* Read the HBA Host Status Register */
2266 /* Check status register to see what current state is */
2270 /* Check every 100ms for 5 retries, then every 500ms for 5, then
2271 * every 2.5 sec for 5, then reset board and every 2.5 sec for
2272 * 4.
2273 */
2275 /* Adapter failed to init, timeout, status reg
2276 <status> */
2278 "0436 Adapter failed to init, "
2279 "timeout, status reg x%x, "
2285 }
2287 /* Check to see if any errors occurred during init */
2289 /* ERROR: During chipset initialization */
2290 /* Adapter failed to init, chipset, status reg
2291 <status> */
2293 "0437 Adapter failed to init, "
2294 "chipset, status reg x%x, "
2300 }
2308 }
2311 /* Do post */
2314 }
2315 /* Read the HBA Host Status Register */
2317 }
2319 /* Check to see if any errors occurred during init */
2321 /* ERROR: During chipset initialization */
2322 /* Adapter failed to init, chipset, status reg <status> */
2324 "0438 Adapter failed to init, chipset, "
2325 "status reg x%x, "
2331 }
2333 /* Clear all interrupt enable conditions */
2337 /* setup host attn register */
2341 }
2343 int
2345 {
2347 }
2349 static int
2351 {
2359 }
2361 int
2363 {
2365 }
2367 static int
2369 {
2376 /* Get a Mailbox buffer to setup mailbox
2377 * commands for HBA initialization
2378 */
2386 /* Initialize the struct lpfc_sli_hbq structure for each hbq */
2402 /* Adapter failed to init, mbxCmd <cmd> CFG_RING,
2403 mbxStatus <status>, ring <num> */
2407 "1805 Adapter failed to init. "
2415 }
2416 }
2421 /* Initially populate or replenish the HBQs */
2425 }
2427 }
2429 static int
2431 {
2439 }
2456 resetcount++;
2458 /* Call pre CONFIG_PORT mailbox command initialization. A
2459 * value of 0 means the call was successful. Any other
2460 * nonzero value is a failure, but if ERESTART is returned,
2461 * the driver may reset the HBA and try again.
2462 */
2469 }
2476 "0442 Adapter failed to init, mbxCmd x%x "
2489 }
2490 }
2495 }
2500 }
2502 do_prep_failed:
2505 }
2507 int
2509 {
2517 "1824 NPIV enabled: Override lpfc_sli_mode "
2519 lpfc_sli_mode);
2521 }
2529 "1819 Unrecognized lpfc_sli_mode "
2533 }
2538 "1820 Unable to select SLI-3. "
2555 }
2565 /* Init HBQs */
2571 }
2581 lpfc_sli_hba_setup_error:
2586 }
2588 /*! lpfc_mbox_timeout
2589 *
2590 * \pre
2591 * \post
2592 * \param hba Pointer to per struct lpfc_hba structure
2593 * \param l1 Pointer to the driver's mailbox queue.
2594 * \return
2595 * void
2596 *
2597 * \b Description:
2598 *
2599 * This routine handles mailbox timeout events at timer interrupt context.
2600 */
2601 void
2603 {
2619 }
2620 }
2622 void
2624 {
2632 }
2634 /* Mbox cmd <mbxCommand> timeout */
2642 /* Setting state unknown so lpfc_sli_abort_iocb_ring
2643 * would get IOCB_ERROR from lpfc_sli_issue_iocb, allowing
2644 * it to fail all oustanding SCSI IO.
2645 */
2660 /*
2661 * lpfc_offline calls lpfc_sli_hba_down which will clean up
2662 * on oustanding mailbox commands.
2663 */
2664 /* If resets are disabled then set error state and return. */
2668 }
2676 }
2678 int
2680 {
2700 }
2701 }
2704 /* If the PCI channel is in offline state, do not post mbox. */
2718 /* Mbox command <mbxCommand> cannot issue */
2721 }
2728 }
2731 /* Polling for a mbox command when another one is already active
2732 * is not allowed in SLI. Also, the driver must have established
2733 * SLI2 mode to queue and process multiple mbox commands.
2734 */
2739 /* Mbox command <mbxCommand> cannot issue */
2742 }
2746 /* Mbox command <mbxCommand> cannot issue */
2749 }
2751 /* Another mailbox command is still being processed, queue this
2752 * command to be processed later.
2753 */
2756 /* Mbox cmd issue - BUSY */
2758 "(%d):0308 Mbox cmd issue - BUSY Data: "
2769 LPFC_DISC_TRC_MBOX_VPORT,
2773 }
2776 LPFC_DISC_TRC_MBOX,
2780 }
2783 }
2787 /* If we are not polling, we MUST be in SLI2 mode */
2793 /* Mbox command <mbxCommand> cannot issue */
2796 }
2797 /* timeout active mbox command */
2800 }
2802 /* Mailbox cmd <cmd> issue */
2804 "(%d):0309 Mailbox cmd x%x issue Data: x%x x%x "
2813 LPFC_DISC_TRC_MBOX_VPORT,
2817 }
2820 LPFC_DISC_TRC_MBOX,
2824 }
2825 }
2830 /* next set own bit for the adapter and copy over command word */
2834 /* First copy command data to host SLIM area */
2838 /* copy command data into host mbox for cmpl */
2840 MAILBOX_CMD_SIZE);
2841 }
2843 /* First copy mbox command data to HBA SLIM, skip past first
2844 word */
2849 /* Next copy over first word, with mbxOwner set */
2856 /* switch over to host mailbox */
2858 }
2859 }
2865 /* Set up reference to mailbox command */
2867 /* Interrupt board to do it */
2870 /* Don't wait for it to finish, just return */
2874 /* Set up null reference to mailbox command */
2876 /* Interrupt board to do it */
2881 /* First read mbox status word */
2885 /* First read mbox status word */
2887 }
2889 /* Read the HBA Host Attention Register */
2895 /* Wait for command to complete */
2902 drvr_flag);
2904 }
2906 /* Check if we took a mbox interrupt while we were
2907 polling */
2914 drvr_flag);
2917 }
2920 /* First copy command data */
2927 /* Check real SLIM for any errors */
2935 }
2936 }
2938 /* First copy command data */
2940 }
2941 /* Read the HBA Host Attention Register */
2943 }
2946 /* copy results back to user */
2948 MAILBOX_CMD_SIZE);
2950 /* First copy command data */
2952 MAILBOX_CMD_SIZE);
2958 }
2959 }
2966 }
2970 }
2972 /*
2973 * Caller needs to hold lock.
2974 */
2975 static void
2978 {
2979 /* Insert the caller's iocb in the txq tail for later processing. */
2982 }
2987 {
2994 }
2997 }
2999 /*
3000 * Lockless version of lpfc_sli_issue_iocb.
3001 */
3002 static int
3005 {
3018 }
3021 /* If the PCI channel is in offline state, do not post iocbs. */
3025 /*
3026 * We should never get an IOCB if we are in a < LINK_DOWN state
3027 */
3031 /*
3032 * Check to see if we are blocking IOCB processing because of a
3033 * outstanding event.
3034 */
3039 /*
3040 * Only CREATE_XRI, CLOSE_XRI, and QUE_RING_BUF
3041 * can be issued if the link is not up.
3042 */
3046 /*
3047 * For IOCBs, like QUE_RING_BUF, that have no rsp ring
3048 * completion, iocb_cmpl MUST be 0.
3049 */
3052 /*FALLTHROUGH*/
3059 }
3061 /*
3062 * For FCP commands, we must be in a state where we can process link
3063 * attention events.
3064 */
3068 }
3076 else
3084 iocb_busy:
3087 out_busy:
3092 }
3095 }
3098 int
3101 {
3110 }
3112 static int
3114 {
3120 /* Adjust cmd/rsp ring iocb entries more evenly */
3122 /* Take some away from the FCP ring */
3129 /* and give them to the extra ring */
3137 /* Setup default profile for this ring */
3145 }
3147 static void
3150 {
3164 KERN_ERR,
3165 LOG_SLI,
3166 "0346 Ring %d handler: unexpected ASYNC_STATUS"
3171 }
3177 KERN_ERR,
3178 LOG_TEMP,
3179 "0347 Adapter is very hot, please take "
3181 temp);
3182 }
3186 KERN_ERR,
3187 LOG_TEMP,
3188 "0340 Adapter temperature is OK now. "
3190 temp);
3191 }
3193 /* Send temperature change event to applications */
3199 }
3202 int
3204 {
3223 /* numCiocb and numRiocb are used in config_port */
3231 SLI3_IOCB_CMD_SIZE :
3232 SLI2_IOCB_CMD_SIZE;
3234 SLI3_IOCB_RSP_SIZE :
3235 SLI2_IOCB_RSP_SIZE;
3243 /* numCiocb and numRiocb are used in config_port */
3247 SLI3_IOCB_CMD_SIZE :
3248 SLI2_IOCB_CMD_SIZE;
3250 SLI3_IOCB_RSP_SIZE :
3251 SLI2_IOCB_RSP_SIZE;
3256 /* numCiocb and numRiocb are used in config_port */
3260 SLI3_IOCB_CMD_SIZE :
3261 SLI2_IOCB_CMD_SIZE;
3263 SLI3_IOCB_RSP_SIZE :
3264 SLI2_IOCB_RSP_SIZE;
3269 lpfc_sli_async_event_handler;
3275 lpfc_els_unsol_event;
3280 lpfc_els_unsol_event;
3282 /* NameServer Inquiry */
3284 /* NameServer */
3287 lpfc_ct_unsol_event;
3289 /* NameServer response */
3291 /* NameServer */
3294 lpfc_ct_unsol_event;
3296 }
3299 }
3301 /* Too many cmd / rsp ring entries in SLI2 SLIM */
3306 }
3311 }
3313 int
3315 {
3324 /* Initialize list headers for txq and txcmplq as double linked lists */
3336 }
3339 }
3341 int
3343 {
3361 /*
3362 * Error everything on the txq since these iocbs have not been
3363 * given to the FW yet.
3364 */
3370 }
3372 /* Next issue ABTS for everything on the txcmplq */
3374 list) {
3378 }
3381 }
3394 }
3395 }
3397 }
3399 int
3401 {
3422 /*
3423 * Error everything on the txq since these iocbs have not been
3424 * given to the FW yet.
3425 */
3429 }
3442 }
3443 }
3456 }
3458 /* Return any active mbox cmds */
3470 }
3472 /* Return any pending or completed mbox cmds */
3485 }
3486 }
3488 }
3490 void
3492 {
3502 src++;
3503 dest++;
3504 }
3505 }
3507 int
3510 {
3511 /* Stick struct lpfc_dmabuf at end of postbufq so driver can look it up
3512 later */
3518 }
3520 uint32_t
3522 {
3525 /*
3526 * Always set the QUE_BUFTAG_BIT to distiguish between
3527 * a tag assigned by HBQ.
3528 */
3532 }
3537 {
3541 /* Search postbufq, from the begining, looking for a match on tag */
3549 }
3550 }
3554 "0410 Cannot find virtual addr for buffer tag on "
3560 }
3564 dma_addr_t phys)
3565 {
3569 /* Search postbufq, from the begining, looking for a match on phys */
3577 }
3578 }
3582 "0410 Cannot find virtual addr for mapped buf on "
3587 }
3589 static void
3592 {
3609 "0327 Cannot abort els iocb %p "
3610 "with tag %x context %x, abort status %x, "
3615 /*
3616 * make sure we have the right iocbq before taking it
3617 * off the txcmplq and try to call completion routine.
3618 */
3628 /* Firmware could still be in progress of DMAing
3629 * payload, so don't free data buffer till after
3630 * a hbeat.
3631 */
3638 }
3639 }
3643 }
3645 static void
3648 {
3651 /* ELS cmd tag <ulpIoTag> completes */
3653 "0133 Ignoring ELS cmd tag x%x completion Data: "
3659 else
3662 }
3664 int
3667 {
3674 /*
3675 * There are certain command types we don't want to abort. And we
3676 * don't want to abort commands that are already in the process of
3677 * being aborted.
3678 */
3685 /* If we're unloading, don't abort iocb on the ELS ring, but change the
3686 * callback so that nothing happens when it finishes.
3687 */
3692 else
3695 }
3697 /* issue ABTS for this IOCB based on iotag */
3702 /* This signals the response to set the correct status
3703 * before calling the completion handler.
3704 */
3716 else
3722 "0339 Abort xri x%x, original iotag x%x, "
3728 abort_iotag_exit:
3729 /*
3730 * Caller to this routine should check for IOCB_ERROR
3731 * and handle it properly. This routine no longer removes
3732 * iocb off txcmplq and call compl in case of IOCB_ERROR.
3733 */
3735 }
3737 static int
3740 lpfc_ctx_cmd ctx_cmd)
3741 {
3775 }
3778 }
3780 int
3782 lpfc_ctx_cmd ctx_cmd)
3783 {
3793 sum++;
3794 }
3797 }
3799 void
3802 {
3805 }
3807 int
3810 {
3825 /* issue ABTS for this IOCB based on iotag */
3828 errcnt++;
3830 }
3842 else
3845 /* Setup callback routine and issue the command. */
3850 errcnt++;
3852 }
3853 }
3856 }
3858 static void
3862 {
3877 }
3879 /*
3880 * Issue the caller's iocb and wait for its completion, but no longer than the
3881 * caller's timeout. Note that iocb_flags is cleared before the
3882 * lpfc_sli_issue_call since the wake routine sets a unique value and by
3883 * definition this is a wait function.
3884 */
3886 int
3892 {
3898 /*
3899 * If the caller has provided a response iocbq buffer, then context2
3900 * is NULL or its an error.
3901 */
3906 }
3917 }
3924 timeout_req);
3931 "0338 IOCB wait timeout error - no "
3936 "0330 IOCB wake NOT set, "
3940 }
3944 retval);
3946 }
3953 }
3961 }
3963 int
3966 {
3971 /* The caller must leave context1 empty. */
3975 /* setup wake call as IOCB callback */
3977 /* setup context field to pass wait_queue pointer to wake function */
3980 /* now issue the command */
3990 /*
3991 * if LPFC_MBX_WAKE flag is set the mailbox is completed
3992 * else do not free the resources.
3993 */
3999 }
4001 }
4004 }
4006 int
4008 {
4017 /*
4018 * Call lpfc_sli_handle_mb_event only if a mailbox cmd
4019 * did finish. This way we won't get the misleading
4020 * "Stray Mailbox Interrupt" message.
4021 */
4032 }
4035 }
4037 irqreturn_t
4039 {
4053 /*
4054 * Get the driver's phba structure from the dev_id and
4055 * assume the HBA is not interrupting.
4056 */
4062 /* If the pci channel is offline, ignore all the interrupts. */
4068 /*
4069 * Call the HBA to see if it is interrupting. If not, don't claim
4070 * the interrupt
4071 */
4073 /* Ignore all interrupts during initialization. */
4077 /*
4078 * Read host attention register to determine interrupt source
4079 * Clear Attention Sources, except Error Attention (to
4080 * preserve status) and Link Attention
4081 */
4084 /* If somebody is waiting to handle an eratt don't process it
4085 * here. The brdkill function will do this.
4086 */
4101 /*
4102 * Turn off Link Attention interrupts
4103 * until CLEAR_LA done
4104 */
4112 }
4113 else
4115 }
4118 /*
4119 * Turn off Slow Rings interrupts, LPFC_ELS_RING is
4120 * the only slow ring.
4121 */
4136 "ISR Disable ring:"
4142 control &=
4146 }
4149 "ISR slow ring: pwork:"
4154 }
4156 }
4157 }
4160 /*
4161 * There was a link/board error. Read the
4162 * status register to retrieve the error event
4163 * and process it.
4164 */
4166 /* Save status info */
4171 /* Clear Chip error bit */
4175 }
4184 /* First check out the status word */
4187 /*
4188 * Stray Mailbox Interrupt, mbxCommand <cmd>
4189 * mbxStatus <status>
4190 */
4192 LOG_SLI,
4193 "(%d):0304 Stray Mailbox "
4194 "Interrupt mbxCommand x%x "
4199 /* clear mailbox attention bit */
4208 MAILBOX_CMD_SIZE);
4209 }
4214 LPFC_DISC_TRC_MBOX_VPORT,
4215 "MBOX dflt rpi: : "
4226 /* Reg_LOGIN of dflt RPI was
4227 * successful. new lets get
4228 * rid of the RPI using the
4229 * same mbox buffer.
4230 */
4234 pmb);
4236 lpfc_mbx_cmpl_dflt_rpi;
4245 }
4246 }
4252 }
4253 }
4256 send_next_mbox:
4261 send_current_mbox:
4262 /* Process next mailbox command if there is one */
4269 }
4270 }
4272 }
4279 }
4283 /*
4284 * Process all events on FCP ring. Take the optimized path for
4285 * FCP IO. Any other IO is slow path and is handled by
4286 * the worker thread.
4287 */
4293 status);
4296 /*
4297 * Process all events on extra ring. Take the optimized path
4298 * for extra ring IO. Any other IO is slow path and is handled
4299 * by the worker thread.
4300 */
4306 status);
4307 }
4308 }