| blob | c71b9a577770fb9a132c391f4678a3db9f36c2cd |
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 */
2659 /*
2660 * lpfc_offline calls lpfc_sli_hba_down which will clean up
2661 * on oustanding mailbox commands.
2662 */
2663 /* If resets are disabled then set error state and return. */
2667 }
2674 }
2676 int
2678 {
2692 /* processing mbox queue from intr_handler */
2699 }
2700 }
2712 }
2713 }
2715 /* If the PCI channel is in offline state, do not post mbox. */
2719 }
2729 /* Mbox command <mbxCommand> cannot issue */
2732 }
2739 }
2742 /* Polling for a mbox command when another one is already active
2743 * is not allowed in SLI. Also, the driver must have established
2744 * SLI2 mode to queue and process multiple mbox commands.
2745 */
2750 /* Mbox command <mbxCommand> cannot issue */
2753 }
2757 /* Mbox command <mbxCommand> cannot issue */
2760 }
2762 /* Another mailbox command is still being processed, queue this
2763 * command to be processed later.
2764 */
2767 /* Mbox cmd issue - BUSY */
2769 "(%d):0308 Mbox cmd issue - BUSY Data: "
2780 LPFC_DISC_TRC_MBOX_VPORT,
2784 }
2787 LPFC_DISC_TRC_MBOX,
2791 }
2794 }
2798 /* If we are not polling, we MUST be in SLI2 mode */
2804 /* Mbox command <mbxCommand> cannot issue */
2807 }
2808 /* timeout active mbox command */
2811 }
2813 /* Mailbox cmd <cmd> issue */
2815 "(%d):0309 Mailbox cmd x%x issue Data: x%x x%x "
2824 LPFC_DISC_TRC_MBOX_VPORT,
2828 }
2831 LPFC_DISC_TRC_MBOX,
2835 }
2836 }
2841 /* next set own bit for the adapter and copy over command word */
2845 /* First copy command data to host SLIM area */
2849 /* copy command data into host mbox for cmpl */
2851 MAILBOX_CMD_SIZE);
2852 }
2854 /* First copy mbox command data to HBA SLIM, skip past first
2855 word */
2860 /* Next copy over first word, with mbxOwner set */
2867 /* switch over to host mailbox */
2869 }
2870 }
2876 /* Set up reference to mailbox command */
2878 /* Interrupt board to do it */
2881 /* Don't wait for it to finish, just return */
2885 /* Set up null reference to mailbox command */
2887 /* Interrupt board to do it */
2892 /* First read mbox status word */
2896 /* First read mbox status word */
2898 }
2900 /* Read the HBA Host Attention Register */
2906 /* Wait for command to complete */
2913 drvr_flag);
2915 }
2917 /* Check if we took a mbox interrupt while we were
2918 polling */
2925 drvr_flag);
2928 }
2931 /* First copy command data */
2938 /* Check real SLIM for any errors */
2946 }
2947 }
2949 /* First copy command data */
2951 }
2952 /* Read the HBA Host Attention Register */
2954 }
2957 /* copy results back to user */
2959 MAILBOX_CMD_SIZE);
2961 /* First copy command data */
2963 MAILBOX_CMD_SIZE);
2969 }
2970 }
2977 }
2982 out_not_finished:
2986 }
2988 }
2990 /*
2991 * Caller needs to hold lock.
2992 */
2993 static void
2996 {
2997 /* Insert the caller's iocb in the txq tail for later processing. */
3000 }
3005 {
3012 }
3015 }
3017 /*
3018 * Lockless version of lpfc_sli_issue_iocb.
3019 */
3020 static int
3023 {
3036 }
3039 /* If the PCI channel is in offline state, do not post iocbs. */
3043 /*
3044 * We should never get an IOCB if we are in a < LINK_DOWN state
3045 */
3049 /*
3050 * Check to see if we are blocking IOCB processing because of a
3051 * outstanding event.
3052 */
3057 /*
3058 * Only CREATE_XRI, CLOSE_XRI, and QUE_RING_BUF
3059 * can be issued if the link is not up.
3060 */
3064 /*
3065 * For IOCBs, like QUE_RING_BUF, that have no rsp ring
3066 * completion, iocb_cmpl MUST be 0.
3067 */
3070 /*FALLTHROUGH*/
3077 }
3079 /*
3080 * For FCP commands, we must be in a state where we can process link
3081 * attention events.
3082 */
3086 }
3094 else
3102 iocb_busy:
3105 out_busy:
3110 }
3113 }
3116 int
3119 {
3128 }
3130 static int
3132 {
3138 /* Adjust cmd/rsp ring iocb entries more evenly */
3140 /* Take some away from the FCP ring */
3147 /* and give them to the extra ring */
3155 /* Setup default profile for this ring */
3163 }
3165 static void
3168 {
3182 KERN_ERR,
3183 LOG_SLI,
3184 "0346 Ring %d handler: unexpected ASYNC_STATUS"
3189 }
3195 KERN_ERR,
3196 LOG_TEMP,
3197 "0347 Adapter is very hot, please take "
3199 temp);
3200 }
3204 KERN_ERR,
3205 LOG_TEMP,
3206 "0340 Adapter temperature is OK now. "
3208 temp);
3209 }
3211 /* Send temperature change event to applications */
3217 }
3220 int
3222 {
3241 /* numCiocb and numRiocb are used in config_port */
3249 SLI3_IOCB_CMD_SIZE :
3250 SLI2_IOCB_CMD_SIZE;
3252 SLI3_IOCB_RSP_SIZE :
3253 SLI2_IOCB_RSP_SIZE;
3261 /* numCiocb and numRiocb are used in config_port */
3265 SLI3_IOCB_CMD_SIZE :
3266 SLI2_IOCB_CMD_SIZE;
3268 SLI3_IOCB_RSP_SIZE :
3269 SLI2_IOCB_RSP_SIZE;
3274 /* numCiocb and numRiocb are used in config_port */
3278 SLI3_IOCB_CMD_SIZE :
3279 SLI2_IOCB_CMD_SIZE;
3281 SLI3_IOCB_RSP_SIZE :
3282 SLI2_IOCB_RSP_SIZE;
3287 lpfc_sli_async_event_handler;
3293 lpfc_els_unsol_event;
3298 lpfc_els_unsol_event;
3300 /* NameServer Inquiry */
3302 /* NameServer */
3305 lpfc_ct_unsol_event;
3307 /* NameServer response */
3309 /* NameServer */
3312 lpfc_ct_unsol_event;
3314 }
3317 }
3319 /* Too many cmd / rsp ring entries in SLI2 SLIM */
3324 }
3329 }
3331 int
3333 {
3342 /* Initialize list headers for txq and txcmplq as double linked lists */
3354 }
3357 }
3359 int
3361 {
3379 /*
3380 * Error everything on the txq since these iocbs have not been
3381 * given to the FW yet.
3382 */
3388 }
3390 /* Next issue ABTS for everything on the txcmplq */
3392 list) {
3396 }
3399 }
3412 }
3413 }
3415 }
3417 int
3419 {
3440 /*
3441 * Error everything on the txq since these iocbs have not been
3442 * given to the FW yet.
3443 */
3447 }
3460 }
3461 }
3474 }
3476 /* Return any active mbox cmds */
3488 }
3490 /* Return any pending or completed mbox cmds */
3503 }
3504 }
3506 }
3508 void
3510 {
3520 src++;
3521 dest++;
3522 }
3523 }
3525 int
3528 {
3529 /* Stick struct lpfc_dmabuf at end of postbufq so driver can look it up
3530 later */
3536 }
3538 uint32_t
3540 {
3543 /*
3544 * Always set the QUE_BUFTAG_BIT to distiguish between
3545 * a tag assigned by HBQ.
3546 */
3550 }
3555 {
3559 /* Search postbufq, from the begining, looking for a match on tag */
3567 }
3568 }
3572 "0410 Cannot find virtual addr for buffer tag on "
3578 }
3582 dma_addr_t phys)
3583 {
3587 /* Search postbufq, from the begining, looking for a match on phys */
3595 }
3596 }
3600 "0410 Cannot find virtual addr for mapped buf on "
3605 }
3607 static void
3610 {
3627 "0327 Cannot abort els iocb %p "
3628 "with tag %x context %x, abort status %x, "
3633 /*
3634 * If the iocb is not found in Firmware queue the iocb
3635 * might have completed already. Do not free it again.
3636 */
3642 }
3643 /*
3644 * make sure we have the right iocbq before taking it
3645 * off the txcmplq and try to call completion routine.
3646 */
3656 /* Firmware could still be in progress of DMAing
3657 * payload, so don't free data buffer till after
3658 * a hbeat.
3659 */
3666 }
3667 }
3671 }
3673 static void
3676 {
3679 /* ELS cmd tag <ulpIoTag> completes */
3681 "0133 Ignoring ELS cmd tag x%x completion Data: "
3687 else
3690 }
3692 int
3695 {
3702 /*
3703 * There are certain command types we don't want to abort. And we
3704 * don't want to abort commands that are already in the process of
3705 * being aborted.
3706 */
3713 /* If we're unloading, don't abort iocb on the ELS ring, but change the
3714 * callback so that nothing happens when it finishes.
3715 */
3720 else
3723 }
3725 /* issue ABTS for this IOCB based on iotag */
3730 /* This signals the response to set the correct status
3731 * before calling the completion handler.
3732 */
3744 else
3750 "0339 Abort xri x%x, original iotag x%x, "
3756 abort_iotag_exit:
3757 /*
3758 * Caller to this routine should check for IOCB_ERROR
3759 * and handle it properly. This routine no longer removes
3760 * iocb off txcmplq and call compl in case of IOCB_ERROR.
3761 */
3763 }
3765 static int
3768 lpfc_ctx_cmd ctx_cmd)
3769 {
3803 }
3806 }
3808 int
3810 lpfc_ctx_cmd ctx_cmd)
3811 {
3821 sum++;
3822 }
3825 }
3827 void
3830 {
3833 }
3835 int
3838 {
3853 /* issue ABTS for this IOCB based on iotag */
3856 errcnt++;
3858 }
3870 else
3873 /* Setup callback routine and issue the command. */
3878 errcnt++;
3880 }
3881 }
3884 }
3886 static void
3890 {
3905 }
3907 /*
3908 * Issue the caller's iocb and wait for its completion, but no longer than the
3909 * caller's timeout. Note that iocb_flags is cleared before the
3910 * lpfc_sli_issue_call since the wake routine sets a unique value and by
3911 * definition this is a wait function.
3912 */
3914 int
3920 {
3926 /*
3927 * If the caller has provided a response iocbq buffer, then context2
3928 * is NULL or its an error.
3929 */
3934 }
3945 }
3952 timeout_req);
3959 "0338 IOCB wait timeout error - no "
3964 "0330 IOCB wake NOT set, "
3968 }
3972 retval);
3974 }
3981 }
3989 }
3991 int
3994 {
3999 /* The caller must leave context1 empty. */
4003 /* setup wake call as IOCB callback */
4005 /* setup context field to pass wait_queue pointer to wake function */
4008 /* now issue the command */
4018 /*
4019 * if LPFC_MBX_WAKE flag is set the mailbox is completed
4020 * else do not free the resources.
4021 */
4027 }
4029 }
4032 }
4034 int
4036 {
4045 /*
4046 * Call lpfc_sli_handle_mb_event only if a mailbox cmd
4047 * did finish. This way we won't get the misleading
4048 * "Stray Mailbox Interrupt" message.
4049 */
4060 }
4063 }
4065 irqreturn_t
4067 {
4081 /*
4082 * Get the driver's phba structure from the dev_id and
4083 * assume the HBA is not interrupting.
4084 */
4090 /* If the pci channel is offline, ignore all the interrupts. */
4096 /*
4097 * Call the HBA to see if it is interrupting. If not, don't claim
4098 * the interrupt
4099 */
4101 /* Ignore all interrupts during initialization. */
4105 /*
4106 * Read host attention register to determine interrupt source
4107 * Clear Attention Sources, except Error Attention (to
4108 * preserve status) and Link Attention
4109 */
4112 /* If somebody is waiting to handle an eratt don't process it
4113 * here. The brdkill function will do this.
4114 */
4129 /*
4130 * Turn off Link Attention interrupts
4131 * until CLEAR_LA done
4132 */
4140 }
4141 else
4143 }
4146 /*
4147 * Turn off Slow Rings interrupts, LPFC_ELS_RING is
4148 * the only slow ring.
4149 */
4164 "ISR Disable ring:"
4170 control &=
4174 }
4177 "ISR slow ring: pwork:"
4182 }
4184 }
4185 }
4188 /*
4189 * There was a link/board error. Read the
4190 * status register to retrieve the error event
4191 * and process it.
4192 */
4194 /* Save status info */
4199 /* Clear Chip error bit */
4203 }
4212 /* First check out the status word */
4215 /*
4216 * Stray Mailbox Interrupt, mbxCommand <cmd>
4217 * mbxStatus <status>
4218 */
4220 LOG_SLI,
4221 "(%d):0304 Stray Mailbox "
4222 "Interrupt mbxCommand x%x "
4227 /* clear mailbox attention bit */
4236 MAILBOX_CMD_SIZE);
4237 }
4242 LPFC_DISC_TRC_MBOX_VPORT,
4243 "MBOX dflt rpi: : "
4254 /* Reg_LOGIN of dflt RPI was
4255 * successful. new lets get
4256 * rid of the RPI using the
4257 * same mbox buffer.
4258 */
4262 pmb);
4264 lpfc_mbx_cmpl_dflt_rpi;
4269 pmb,
4270 MBX_NOWAIT);
4273 KERN_ERR,
4275 "0306 rc should have"
4278 }
4279 }
4285 }
4286 }
4289 send_current_mbox:
4290 /* Process next mailbox command if there is one */
4293 MBX_NOWAIT);
4299 }
4306 }
4310 /*
4311 * Process all events on FCP ring. Take the optimized path for
4312 * FCP IO. Any other IO is slow path and is handled by
4313 * the worker thread.
4314 */
4320 status);
4323 /*
4324 * Process all events on extra ring. Take the optimized path
4325 * for extra ring IO. Any other IO is slow path and is handled
4326 * by the worker thread.
4327 */
4333 status);
4334 }
4335 }