| blob | ac67f420ec2642e81f1de78cfbc029fea53bfb99 |
1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2017-2020 Broadcom. All Rights Reserved. The term *
5 * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. *
6 * Copyright (C) 2004-2016 Emulex. All rights reserved. *
7 * EMULEX and SLI are trademarks of Emulex. *
8 * www.broadcom.com *
9 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
10 * *
11 * This program is free software; you can redistribute it and/or *
12 * modify it under the terms of version 2 of the GNU General *
13 * Public License as published by the Free Software Foundation. *
14 * This program is distributed in the hope that it will be useful. *
15 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
16 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
17 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
18 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
19 * TO BE LEGALLY INVALID. See the GNU General Public License for *
20 * more details, a copy of which can be found in the file COPYING *
21 * included with this package. *
22 *******************************************************************/
24 #include <linux/blkdev.h>
25 #include <linux/delay.h>
26 #include <linux/dma-mapping.h>
27 #include <linux/idr.h>
28 #include <linux/interrupt.h>
29 #include <linux/module.h>
30 #include <linux/kthread.h>
31 #include <linux/pci.h>
32 #include <linux/spinlock.h>
33 #include <linux/ctype.h>
34 #include <linux/aer.h>
35 #include <linux/slab.h>
36 #include <linux/firmware.h>
37 #include <linux/miscdevice.h>
38 #include <linux/percpu.h>
39 #include <linux/msi.h>
40 #include <linux/irq.h>
41 #include <linux/bitops.h>
42 #include <linux/crash_dump.h>
43 #include <linux/cpu.h>
44 #include <linux/cpuhotplug.h>
46 #include <scsi/scsi.h>
47 #include <scsi/scsi_device.h>
48 #include <scsi/scsi_host.h>
49 #include <scsi/scsi_transport_fc.h>
50 #include <scsi/scsi_tcq.h>
51 #include <scsi/fc/fc_fs.h>
69 /* Used when mapping IRQ vectors in a driver centric manner */
100 #define LPFC_NVMET_BUF_POST 254
102 /**
103 * lpfc_config_port_prep - Perform lpfc initialization prior to config port
104 * @phba: pointer to lpfc hba data structure.
105 *
106 * This routine will do LPFC initialization prior to issuing the CONFIG_PORT
107 * mailbox command. It retrieves the revision information from the HBA and
108 * collects the Vital Product Data (VPD) about the HBA for preparing the
109 * configuration of the HBA.
110 *
111 * Return codes:
112 * 0 - success.
113 * -ERESTART - requests the SLI layer to reset the HBA and try again.
114 * Any other value - indicates an error.
115 **/
116 int
118 {
133 }
145 }
157 "0324 Config Port initialization "
158 "error, mbxCmd x%x READ_NVPARM, "
163 }
168 }
170 /*
171 * Clear all option bits except LPFC_SLI3_BG_ENABLED,
172 * which was already set in lpfc_get_cfgparam()
173 */
176 /* Setup and issue mailbox READ REV command */
181 "0439 Adapter failed to init, mbxCmd x%x "
186 }
189 /*
190 * The value of rr must be 1 since the driver set the cv field to 1.
191 * This setting requires the FW to set all revision fields.
192 */
196 "0440 Adapter failed to init, READ_REV has "
200 }
205 }
207 /* Save information as VPD data */
225 /* If the sli feature level is less then 9, we must
226 * tear down all RPIs and VPIs on link down if NPIV
227 * is enabled.
228 */
236 /* Get adapter VPD information */
246 "0441 VPD not present on adapter, "
250 }
251 /* dump mem may return a zero when finished or we got a
252 * mailbox error, either way we are done.
253 */
268 out_free_mbox:
271 }
273 /**
274 * lpfc_config_async_cmpl - Completion handler for config async event mbox cmd
275 * @phba: pointer to lpfc hba data structure.
276 * @pmboxq: pointer to the driver internal queue element for mailbox command.
277 *
278 * This is the completion handler for driver's configuring asynchronous event
279 * mailbox command to the device. If the mailbox command returns successfully,
280 * it will set internal async event support flag to 1; otherwise, it will
281 * set internal async event support flag to 0.
282 **/
283 static void
285 {
288 else
292 }
294 /**
295 * lpfc_dump_wakeup_param_cmpl - dump memory mailbox command completion handler
296 * @phba: pointer to lpfc hba data structure.
297 * @pmboxq: pointer to the driver internal queue element for mailbox command.
298 *
299 * This is the completion handler for dump mailbox command for getting
300 * wake up parameters. When this command complete, the response contain
301 * Option rom version of the HBA. This function translate the version number
302 * into a human readable string and store it in OptionROMVersion.
303 **/
304 static void
306 {
310 /* character array used for decoding dist type. */
316 }
320 /* word 7 contain option rom version */
323 /* Decode the Option rom version word to a readable string */
330 else
336 }
338 /**
339 * lpfc_update_vport_wwn - Updates the fc_nodename, fc_portname,
340 * cfg_soft_wwnn, cfg_soft_wwpn
341 * @vport: pointer to lpfc vport data structure.
342 *
343 *
344 * Return codes
345 * None.
346 **/
347 void
349 {
353 /* If the soft name exists then update it using the service params */
361 /*
362 * If the name is empty or there exists a soft name
363 * then copy the service params name, otherwise use the fc name
364 */
368 else
372 /*
373 * If the port name has changed, then set the Param changes flag
374 * to unreg the login
375 */
390 }
391 else
394 }
396 /**
397 * lpfc_config_port_post - Perform lpfc initialization after config port
398 * @phba: pointer to lpfc hba data structure.
399 *
400 * This routine will do LPFC initialization after the CONFIG_PORT mailbox
401 * command call. It performs all internal resource and state setups on the
402 * port: post IOCB buffers, enable appropriate host interrupt attentions,
403 * ELS ring timers, etc.
404 *
405 * Return codes
406 * 0 - success.
407 * Any other value - error.
408 **/
409 int
411 {
423 /*
424 * If the Config port completed correctly the HBA is not
425 * over heated any more.
426 */
435 }
438 /* Get login parameters for NID. */
443 }
448 "0448 Adapter failed init, mbxCmd x%x "
457 }
467 /* Update the fc_host data structures with new wwn. */
472 /* If no serial number in VPD data, use low 6 bytes of WWNN */
473 /* This should be consolidated into parse_vpd ? - mr */
484 else
487 i++;
492 else
495 }
496 }
502 "0453 Adapter failed to init, mbxCmd x%x "
508 }
510 /* Check if the port is disabled */
513 /* Reset the DFT_HBA_Q_DEPTH to the max xri */
520 }
524 /* Get the default values for Model Name and Description */
529 /* Only process IOCBs on ELS ring till hba_state is READY */
535 /* Post receive buffers for desired rings */
539 /*
540 * Configure HBA MSI-X attention conditions to messages if MSI-X mode
541 */
547 }
551 "0352 Config MSI mailbox command "
557 }
558 }
561 /* Initialize ERATT handling flag */
564 /* Enable appropriate host interrupts */
568 }
587 /* Set up ring-0 (ELS) timer */
591 /* Set up heart beat (HB) timer */
596 /* Set up error attention (ERATT) polling timer */
608 "2599 Adapter failed to issue DOWN_LINK"
613 }
619 }
620 /* MBOX buffer will be freed in mbox compl */
625 }
634 "0456 Adapter failed to issue "
636 rc);
638 }
640 /* Get Option rom version */
645 }
654 "0435 Adapter failed "
657 }
660 }
662 /**
663 * lpfc_hba_init_link - Initialize the FC link
664 * @phba: pointer to lpfc hba data structure.
665 * @flag: mailbox command issue mode - either MBX_POLL or MBX_NOWAIT
666 *
667 * This routine will issue the INIT_LINK mailbox command call.
668 * It is available to other drivers through the lpfc_hba data
669 * structure for use as a delayed link up mechanism with the
670 * module parameter lpfc_suppress_link_up.
671 *
672 * Return code
673 * 0 - success
674 * Any other value - error
675 **/
676 static int
678 {
680 }
682 /**
683 * lpfc_hba_init_link_fc_topology - Initialize FC link with desired topology
684 * @phba: pointer to lpfc hba data structure.
685 * @fc_topology: desired fc topology.
686 * @flag: mailbox command issue mode - either MBX_POLL or MBX_NOWAIT
687 *
688 * This routine will issue the INIT_LINK mailbox command call.
689 * It is available to other drivers through the lpfc_hba data
690 * structure for use as a delayed link up mechanism with the
691 * module parameter lpfc_suppress_link_up.
692 *
693 * Return code
694 * 0 - success
695 * Any other value - error
696 **/
697 int
700 {
710 }
731 /* Reset link speed to auto */
733 "1302 Invalid speed for this board:%d "
737 }
745 "0498 Adapter failed to init, mbxCmd x%x "
749 /* Clear all interrupt enable conditions */
752 /* Clear all pending interrupts */
755 }
760 }
766 }
768 /**
769 * lpfc_hba_down_link - this routine downs the FC link
770 * @phba: pointer to lpfc hba data structure.
771 * @flag: mailbox command issue mode - either MBX_POLL or MBX_NOWAIT
772 *
773 * This routine will issue the DOWN_LINK mailbox command call.
774 * It is available to other drivers through the lpfc_hba data
775 * structure for use to stop the link.
776 *
777 * Return code
778 * 0 - success
779 * Any other value - error
780 **/
781 static int
783 {
791 }
800 "2522 Adapter failed to issue DOWN_LINK"
805 }
810 }
812 /**
813 * lpfc_hba_down_prep - Perform lpfc uninitialization prior to HBA reset
814 * @phba: pointer to lpfc HBA data structure.
815 *
816 * This routine will do LPFC uninitialization before the HBA is reset when
817 * bringing down the SLI Layer.
818 *
819 * Return codes
820 * 0 - success.
821 * Any other value - error.
822 **/
823 int
825 {
830 /* Disable interrupts */
833 }
844 }
846 }
848 /**
849 * lpfc_sli4_free_sp_events - Cleanup sp_queue_events to free
850 * rspiocb which got deferred
851 *
852 * @phba: pointer to lpfc HBA data structure.
853 *
854 * This routine will cleanup completed slow path events after HBA is reset
855 * when bringing down the SLI Layer.
856 *
857 *
858 * Return codes
859 * void.
860 **/
861 static void
863 {
873 /* Get the response iocb from the head of work queue */
882 cq_event);
888 cq_event);
890 }
891 }
892 }
894 /**
895 * lpfc_hba_free_post_buf - Perform lpfc uninitialization after HBA reset
896 * @phba: pointer to lpfc HBA data structure.
897 *
898 * This routine will cleanup posted ELS buffers after the HBA is reset
899 * when bringing down the SLI Layer.
900 *
901 *
902 * Return codes
903 * void.
904 **/
905 static void
907 {
917 /* Cleanup preposted buffers on the ELS ring */
926 count++;
929 }
934 }
935 }
937 /**
938 * lpfc_hba_clean_txcmplq - Perform lpfc uninitialization after HBA reset
939 * @phba: pointer to lpfc HBA data structure.
940 *
941 * This routine will cleanup the txcmplq after the HBA is reset when bringing
942 * down the SLI Layer.
943 *
944 * Return codes
945 * void
946 **/
947 static void
949 {
961 /* At this point in time the HBA is either reset or DOA
962 * Nothing should be on txcmplq as it will
963 * NEVER complete.
964 */
970 }
971 /* Cancel all the IOCBs from the completions list */
975 }
988 }
989 /* Cancel all the IOCBs from the completions list */
992 }
994 /**
995 * lpfc_hba_down_post_s3 - Perform lpfc uninitialization after HBA reset
996 * @phba: pointer to lpfc HBA data structure.
997 *
998 * This routine will do uninitialization after the HBA is reset when bring
999 * down the SLI Layer.
1000 *
1001 * Return codes
1002 * 0 - success.
1003 * Any other value - error.
1004 **/
1005 static int
1007 {
1011 }
1013 /**
1014 * lpfc_hba_down_post_s4 - Perform lpfc uninitialization after HBA reset
1015 * @phba: pointer to lpfc HBA data structure.
1016 *
1017 * This routine will do uninitialization after the HBA is reset when bring
1018 * down the SLI Layer.
1019 *
1020 * Return codes
1021 * 0 - success.
1022 * Any other value - error.
1023 **/
1024 static int
1026 {
1040 /* At this point in time the HBA is either reset or DOA. Either
1041 * way, nothing should be on lpfc_abts_els_sgl_list, it needs to be
1042 * on the lpfc_els_sgl_list so that it can either be freed if the
1043 * driver is unloading or reposted if the driver is restarting
1044 * the port.
1045 */
1047 /* scsl_buf_list */
1048 /* sgl_list_lock required because worker thread uses this
1049 * list.
1050 */
1062 /* abts_xxxx_buf_list_lock required because worker thread uses this
1063 * list.
1064 */
1076 cnt++;
1077 }
1086 }
1097 }
1098 }
1102 }
1104 /**
1105 * lpfc_hba_down_post - Wrapper func for hba down post routine
1106 * @phba: pointer to lpfc HBA data structure.
1107 *
1108 * This routine wraps the actual SLI3 or SLI4 routine for performing
1109 * uninitialization after the HBA is reset when bring down the SLI Layer.
1110 *
1111 * Return codes
1112 * 0 - success.
1113 * Any other value - error.
1114 **/
1115 int
1117 {
1119 }
1121 /**
1122 * lpfc_hb_timeout - The HBA-timer timeout handler
1123 * @t: timer context used to obtain the pointer to lpfc hba data structure.
1124 *
1125 * This is the HBA-timer timeout handler registered to the lpfc driver. When
1126 * this timer fires, a HBA timeout event shall be posted to the lpfc driver
1127 * work-port-events bitmap and the worker thread is notified. This timeout
1128 * event will be used by the worker thread to invoke the actual timeout
1129 * handler routine, lpfc_hb_timeout_handler. Any periodical operations will
1130 * be performed in the timeout handler and the HBA timeout event bit shall
1131 * be cleared by the worker thread after it has taken the event bitmap out.
1132 **/
1133 static void
1135 {
1142 /* Check for heart beat timeout conditions */
1149 /* Tell the worker thread there is work to do */
1153 }
1155 /**
1156 * lpfc_rrq_timeout - The RRQ-timer timeout handler
1157 * @t: timer context used to obtain the pointer to lpfc hba data structure.
1158 *
1159 * This is the RRQ-timer timeout handler registered to the lpfc driver. When
1160 * this timer fires, a RRQ timeout event shall be posted to the lpfc driver
1161 * work-port-events bitmap and the worker thread is notified. This timeout
1162 * event will be used by the worker thread to invoke the actual timeout
1163 * handler routine, lpfc_rrq_handler. Any periodical operations will
1164 * be performed in the timeout handler and the RRQ timeout event bit shall
1165 * be cleared by the worker thread after it has taken the event bitmap out.
1166 **/
1167 static void
1169 {
1177 else
1183 }
1185 /**
1186 * lpfc_hb_mbox_cmpl - The lpfc heart-beat mailbox command callback function
1187 * @phba: pointer to lpfc hba data structure.
1188 * @pmboxq: pointer to the driver internal queue element for mailbox command.
1189 *
1190 * This is the callback function to the lpfc heart-beat mailbox command.
1191 * If configured, the lpfc driver issues the heart-beat mailbox command to
1192 * the HBA every LPFC_HB_MBOX_INTERVAL (current 5) seconds. At the time the
1193 * heart-beat mailbox command is issued, the driver shall set up heart-beat
1194 * timeout timer to LPFC_HB_MBOX_TIMEOUT (current 30) seconds and marks
1195 * heart-beat outstanding state. Once the mailbox command comes back and
1196 * no error conditions detected, the heart-beat mailbox command timer is
1197 * reset to LPFC_HB_MBOX_INTERVAL seconds and the heart-beat outstanding
1198 * state is cleared for the next heart-beat. If the timer expired with the
1199 * heart-beat outstanding state set, the driver will put the HBA offline.
1200 **/
1201 static void
1203 {
1210 /* Check and reset heart-beat timer is necessary */
1216 jiffies +
1219 }
1221 /*
1222 * lpfc_idle_stat_delay_work - idle_stat tracking
1223 *
1224 * This routine tracks per-cq idle_stat and determines polling decisions.
1225 *
1226 * Return codes:
1227 * None
1228 **/
1229 static void
1231 {
1234 idle_stat_delay_work);
1252 /* Skip if we've already handled this cq's primary CPU */
1258 /* get_cpu_idle_time returns values as running counters. Thus,
1259 * to know the amount for this period, the prior counter values
1260 * need to be subtracted from the current counter values.
1261 * From there, the idle time stat can be calculated as a
1262 * percentage of 100 - the sum of the other consumption times.
1263 */
1270 else
1278 else
1283 }
1285 requeue:
1288 }
1290 static void
1292 {
1309 GFP_KERNEL);
1314 /* Get the EQ corresponding to the IRQ vector */
1321 }
1322 }
1332 }
1342 }
1345 usdelay);
1346 }
1347 }
1351 requeue:
1354 }
1356 /**
1357 * lpfc_hb_mxp_handler - Multi-XRI pools handler to adjust XRI distribution
1358 * @phba: pointer to lpfc hba data structure.
1359 *
1360 * For each heartbeat, this routine does some heuristic methods to adjust
1361 * XRI distribution. The goal is to fully utilize free XRIs.
1362 **/
1364 {
1365 u32 i;
1366 u32 hwq_count;
1370 /* Adjust XRIs in private pool */
1373 /* Adjust high watermark */
1376 #ifdef LPFC_MXP_STAT
1377 /* Snapshot pbl, pvt and busy count */
1379 #endif
1380 }
1381 }
1383 /**
1384 * lpfc_hb_timeout_handler - The HBA-timer timeout handler
1385 * @phba: pointer to lpfc hba data structure.
1386 *
1387 * This is the actual HBA-timer timeout handler to be invoked by the worker
1388 * thread whenever the HBA timer fired and HBA-timeout event posted. This
1389 * handler performs any periodic operations needed for the device. If such
1390 * periodic event has already been attended to either in the interrupt handler
1391 * or by processing slow-ring or fast-ring events within the HBA-timer
1392 * timeout window (LPFC_HB_MBOX_INTERVAL), this handler just simply resets
1393 * the timer for the next timeout period. If lpfc heart-beat mailbox command
1394 * is configured and there is no heart-beat mailbox command outstanding, a
1395 * heart-beat mailbox is issued and timer set properly. Otherwise, if there
1396 * has been a heart-beat mailbox command outstanding, the HBA shall be put
1397 * to offline.
1398 **/
1399 void
1401 {
1410 /* Multi-XRI pools handler */
1412 }
1419 }
1431 jiffies)) {
1435 jiffies +
1437 else
1439 jiffies +
1442 }
1458 }
1459 }
1462 /* If there is no heart beat outstanding, issue a heartbeat command */
1468 GFP_KERNEL);
1471 jiffies +
1473 LPFC_HB_MBOX_INTERVAL));
1475 }
1481 MBX_NOWAIT);
1488 jiffies +
1490 LPFC_HB_MBOX_INTERVAL));
1492 }
1498 "2857 Last completion time not "
1506 jiffies +
1510 /*
1511 * If heart beat timeout called with hb_outstanding set
1512 * we need to give the hb mailbox cmd a chance to
1513 * complete or TMO.
1514 */
1516 "0459 Adapter heartbeat still out"
1521 jiffies +
1523 }
1526 jiffies +
1528 }
1529 }
1531 /**
1532 * lpfc_offline_eratt - Bring lpfc offline on hardware error attention
1533 * @phba: pointer to lpfc hba data structure.
1534 *
1535 * This routine is called to bring the HBA offline when HBA hardware error
1536 * other than Port Error 6 has been detected.
1537 **/
1538 static void
1540 {
1558 }
1560 /**
1561 * lpfc_sli4_offline_eratt - Bring lpfc offline on SLI4 hardware error attention
1562 * @phba: pointer to lpfc hba data structure.
1563 *
1564 * This routine is called to bring a SLI4 HBA offline when HBA hardware error
1565 * other than Port Error 6 has been detected.
1566 **/
1567 void
1569 {
1579 }
1581 /**
1582 * lpfc_handle_deferred_eratt - The HBA hardware deferred error handler
1583 * @phba: pointer to lpfc hba data structure.
1584 *
1585 * This routine is invoked to handle the deferred HBA hardware error
1586 * conditions. This type of error is indicated by HBA by setting ER1
1587 * and another ER bit in the host status register. The driver will
1588 * wait until the ER1 bit clears before handling the error condition.
1589 **/
1590 static void
1592 {
1596 /* If the pci channel is offline, ignore possible errors,
1597 * since we cannot communicate with the pci card anyway.
1598 */
1604 }
1607 "0479 Deferred Adapter Hardware Error "
1617 /*
1618 * Firmware stops when it triggred erratt. That could cause the I/Os
1619 * dropped by the firmware. Error iocb (I/O) on txcmplq and let the
1620 * SCSI layer retry it after re-establishing link.
1621 */
1624 /*
1625 * There was a firmware error. Take the hba offline and then
1626 * attempt to restart it.
1627 */
1631 /* Wait for the ER1 bit to clear.*/
1637 }
1638 /* If driver is unloading let the worker thread continue */
1642 }
1643 }
1645 /*
1646 * This is to ptrotect against a race condition in which
1647 * first write to the host attention register clear the
1648 * host status register.
1649 */
1658 }
1660 static void
1662 {
1672 LPFC_NL_VENDOR_ID);
1673 }
1675 /**
1676 * lpfc_handle_eratt_s3 - The SLI3 HBA hardware error handler
1677 * @phba: pointer to lpfc hba data structure.
1678 *
1679 * This routine is invoked to handle the following HBA hardware error
1680 * conditions:
1681 * 1 - HBA error attention interrupt
1682 * 2 - DMA ring index out of range
1683 * 3 - Mailbox command came back as unknown
1684 **/
1685 static void
1687 {
1695 /* If the pci channel is offline, ignore possible errors,
1696 * since we cannot communicate with the pci card anyway.
1697 */
1703 }
1705 /* If resets are disabled then leave the HBA alone and return */
1709 /* Send an internal error event to mgmt application */
1717 /* Re-establishing Link */
1719 "1301 Re-establishing Link "
1724 /* Device Zeroization */
1726 "2861 Host Authentication device "
1735 /*
1736 * Firmware stops when it triggled erratt with HS_FFER6.
1737 * That could cause the I/Os dropped by the firmware.
1738 * Error iocb (I/O) on txcmplq and let the SCSI layer
1739 * retry it after re-establishing link.
1740 */
1743 /*
1744 * There was a firmware error. Take the hba offline and then
1745 * attempt to restart it.
1746 */
1753 }
1762 "0406 Adapter maximum temperature exceeded "
1763 "(%ld), taking this port offline "
1772 SCSI_NL_VID_TYPE_PCI
1781 /* The if clause above forces this code path when the status
1782 * failure is a value other than FFER6. Do not call the offline
1783 * twice. This is the adapter hardware error path.
1784 */
1786 "0457 Adapter Hardware Error "
1798 }
1800 }
1802 /**
1803 * lpfc_sli4_port_sta_fn_reset - The SLI4 function reset due to port status reg
1804 * @phba: pointer to lpfc hba data structure.
1805 * @mbx_action: flag for mailbox shutdown action.
1806 * @en_rn_msg: send reset/port recovery message.
1807 * This routine is invoked to perform an SLI4 port PCI function reset in
1808 * response to port status register polling attention. It waits for port
1809 * status register (ERR, RDY, RN) bits before proceeding with function reset.
1810 * During this process, interrupt vectors are freed and later requested
1811 * for handling possible port resource change.
1812 **/
1813 static int
1816 {
1821 LPFC_SLI_INTF_IF_TYPE_2) {
1822 /*
1823 * On error status condition, driver need to wait for port
1824 * ready before performing reset.
1825 */
1829 }
1831 /* need reset: attempt for port recovery */
1834 "2887 Reset Needed: Attempting Port "
1839 /* release interrupt for possible resource change */
1846 }
1847 /* request and enable interrupt */
1853 }
1860 }
1862 /**
1863 * lpfc_handle_eratt_s4 - The SLI4 HBA hardware error handler
1864 * @phba: pointer to lpfc hba data structure.
1865 *
1866 * This routine is invoked to handle the SLI4 HBA hardware error attention
1867 * conditions.
1868 **/
1869 static void
1871 {
1885 /* If the pci channel is offline, ignore possible errors, since
1886 * we cannot communicate with the pci card anyway.
1887 */
1893 }
1905 /* consider PCI bus read error as pci_channel_offline */
1911 }
1923 LPFC_PORT_SEM_UE_RECOVERABLE)
1925 /*Sleep for 1Sec, before checking SEMAPHORE */
1927 }
1933 /* Recoverable UE, reset the HBA device */
1935 LPFC_PORT_SEM_UE_RECOVERABLE) {
1948 LOG_TRACE_EVENT,
1951 }
1952 }
1953 }
1955 "7624 Firmware not ready: Failing UE recovery,"
1965 /* consider PCI bus read error as pci_channel_offline */
1972 }
1977 "2889 Port Overtemperature event, "
1990 SCSI_NL_VID_TYPE_PCI
1998 }
2002 "3143 Port Down: Firmware Update "
2014 /* If resets are disabled then leave the HBA alone and return */
2018 /* Check port status register for function reset */
2020 en_rn_msg);
2022 /* don't report event on forced debug dump */
2026 else
2028 }
2029 /* fall through for not able to recover */
2037 }
2040 /* Send an internal error event to mgmt application */
2048 }
2050 /**
2051 * lpfc_handle_eratt - Wrapper func for handling hba error attention
2052 * @phba: pointer to lpfc HBA data structure.
2053 *
2054 * This routine wraps the actual SLI3 or SLI4 hba error attention handling
2055 * routine from the API jump table function pointer from the lpfc_hba struct.
2056 *
2057 * Return codes
2058 * 0 - success.
2059 * Any other value - error.
2060 **/
2061 void
2063 {
2065 }
2067 /**
2068 * lpfc_handle_latt - The HBA link event handler
2069 * @phba: pointer to lpfc hba data structure.
2070 *
2071 * This routine is invoked from the worker thread to handle a HBA host
2072 * attention link event. SLI3 only.
2073 **/
2074 void
2076 {
2088 }
2094 }
2100 }
2102 /* Cleanup any outstanding ELS commands */
2109 /* Block ELS IOCBs until we have processed this mbox command */
2115 }
2117 /* Clear Link Attention in HA REG */
2125 lpfc_handle_latt_free_mbuf:
2128 lpfc_handle_latt_free_mp:
2130 lpfc_handle_latt_free_pmb:
2132 lpfc_handle_latt_err_exit:
2133 /* Enable Link attention interrupts */
2141 /* Clear Link Attention in HA REG */
2152 }
2154 /**
2155 * lpfc_parse_vpd - Parse VPD (Vital Product Data)
2156 * @phba: pointer to lpfc hba data structure.
2157 * @vpd: pointer to the vital product data.
2158 * @len: length of the vital product data in bytes.
2159 *
2160 * This routine parses the Vital Product Data (VPD). The VPD is treated as
2161 * an array of characters. In this routine, the ModelName, ProgramType, and
2162 * ModelDesc, etc. fields of the phba data structure will be populated.
2163 *
2164 * Return codes
2165 * 0 - pointer to the VPD passed in is NULL
2166 * 1 - success
2167 **/
2168 int
2170 {
2180 /* Vital Product */
2207 /* Look for Serial Number */
2218 }
2221 }
2233 }
2236 }
2248 }
2251 }
2263 }
2266 }
2277 LPFC_SLI4_PPNAME_GET)) {
2278 j++;
2279 index++;
2284 }
2287 LPFC_SLI4_PPNAME_NON))
2290 }
2297 }
2298 }
2305 index ++;
2307 }
2308 }
2311 }
2313 /**
2314 * lpfc_get_hba_model_desc - Retrieve HBA device model name and description
2315 * @phba: pointer to lpfc hba data structure.
2316 * @mdp: pointer to the data structure to hold the derived model name.
2317 * @descp: pointer to the data structure to hold the derived description.
2318 *
2319 * This routine retrieves HBA's description based on its registered PCI device
2320 * ID. The @descp passed into this function points to an array of 256 chars. It
2321 * shall be returned with the model name, maximum speed, and the host bus type.
2322 * The @mdp passed into this function points to an array of 80 chars. When the
2323 * function returns, the @mdp will be filled with the model name.
2324 **/
2325 static void
2327 {
2359 else
2372 else
2383 else
2555 }
2559 /*
2560 * oneConnect hba requires special processing, they are all initiators
2561 * and we put the port number on the end
2562 */
2573 else
2578 }
2579 }
2581 /**
2582 * lpfc_post_buffer - Post IOCB(s) with DMA buffer descriptor(s) to a IOCB ring
2583 * @phba: pointer to lpfc hba data structure.
2584 * @pring: pointer to a IOCB ring.
2585 * @cnt: the number of IOCBs to be posted to the IOCB ring.
2586 *
2587 * This routine posts a given number of IOCBs with the associated DMA buffer
2588 * descriptors specified by the cnt argument to the given IOCB ring.
2589 *
2590 * Return codes
2591 * The number of IOCBs NOT able to be posted to the IOCB ring.
2592 **/
2593 int
2595 {
2602 /* While there are buffers to post */
2604 /* Allocate buffer for command iocb */
2609 }
2612 /* 2 buffers can be posted per command */
2613 /* Allocate buffer to post */
2622 }
2625 /* Allocate buffer to post */
2638 }
2643 }
2649 cnt--;
2654 cnt--;
2656 }
2662 IOCB_ERROR) {
2665 cnt++;
2669 cnt++;
2670 }
2674 }
2678 }
2681 }
2683 /**
2684 * lpfc_post_rcv_buf - Post the initial receive IOCB buffers to ELS ring
2685 * @phba: pointer to lpfc hba data structure.
2686 *
2687 * This routine posts initial receive IOCB buffers to the ELS ring. The
2688 * current number of initial IOCB buffers specified by LPFC_BUF_RING0 is
2689 * set to 64 IOCBs. SLI3 only.
2690 *
2691 * Return codes
2692 * 0 - success (currently always success)
2693 **/
2694 static int
2696 {
2699 /* Ring 0, ELS / CT buffers */
2701 /* Ring 2 - FCP no buffers needed */
2704 }
2706 #define S(N,V) (((V)<<(N))|((V)>>(32-(N))))
2708 /**
2709 * lpfc_sha_init - Set up initial array of hash table entries
2710 * @HashResultPointer: pointer to an array as hash table.
2711 *
2712 * This routine sets up the initial values to the array of hash table entries
2713 * for the LC HBAs.
2714 **/
2715 static void
2717 {
2723 }
2725 /**
2726 * lpfc_sha_iterate - Iterate initial hash table with the working hash table
2727 * @HashResultPointer: pointer to an initial/result hash table.
2728 * @HashWorkingPointer: pointer to an working hash table.
2729 *
2730 * This routine iterates an initial hash table pointed by @HashResultPointer
2731 * with the values from the working hash table pointeed by @HashWorkingPointer.
2732 * The results are putting back to the initial hash table, returned through
2733 * the @HashResultPointer as the result hash table.
2734 **/
2735 static void
2737 {
2765 }
2780 }
2782 /**
2783 * lpfc_challenge_key - Create challenge key based on WWPN of the HBA
2784 * @RandomChallenge: pointer to the entry of host challenge random number array.
2785 * @HashWorking: pointer to the entry of the working hash array.
2786 *
2787 * This routine calculates the working hash array referred by @HashWorking
2788 * from the challenge random numbers associated with the host, referred by
2789 * @RandomChallenge. The result is put into the entry of the working hash
2790 * array and returned by reference through @HashWorking.
2791 **/
2792 static void
2794 {
2796 }
2798 /**
2799 * lpfc_hba_init - Perform special handling for LC HBA initialization
2800 * @phba: pointer to lpfc hba data structure.
2801 * @hbainit: pointer to an array of unsigned 32-bit integers.
2802 *
2803 * This routine performs the special handling for LC HBA initialization.
2804 **/
2805 void
2807 {
2825 }
2827 /**
2828 * lpfc_cleanup - Performs vport cleanups before deleting a vport
2829 * @vport: pointer to a virtual N_Port data structure.
2830 *
2831 * This routine performs the necessary cleanups before deleting the @vport.
2832 * It invokes the discovery state machine to perform necessary state
2833 * transitions and to release the ndlps associated with the @vport. Note,
2834 * the physical port is treated as @vport 0.
2835 **/
2836 void
2838 {
2849 /* Just free up ndlp with Fabric_DID for vports */
2852 }
2858 }
2860 /* Fabric Ports not in UNMAPPED state are cleaned up in the
2861 * DEVICE_RM event.
2862 */
2866 NLP_EVT_DEVICE_RECOVERY);
2870 NLP_EVT_DEVICE_RM);
2871 }
2873 /* At this point, ALL ndlp's should be gone
2874 * because of the previous NLP_EVT_DEVICE_RM.
2875 * Lets wait for this to happen, if needed.
2876 */
2880 LOG_TRACE_EVENT,
2885 LOG_TRACE_EVENT,
2886 "0282 did:x%x ndlp:x%px "
2892 }
2894 }
2896 /* Wait for any activity on ndlps to settle */
2898 }
2900 }
2902 /**
2903 * lpfc_stop_vport_timers - Stop all the timers associated with a vport
2904 * @vport: pointer to a virtual N_Port data structure.
2905 *
2906 * This routine stops all the timers associated with a @vport. This function
2907 * is invoked before disabling or deleting a @vport. Note that the physical
2908 * port is treated as @vport 0.
2909 **/
2910 void
2912 {
2917 }
2919 /**
2920 * __lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer
2921 * @phba: pointer to lpfc hba data structure.
2922 *
2923 * This routine stops the SLI4 FCF rediscover wait timer if it's on. The
2924 * caller of this routine should already hold the host lock.
2925 **/
2926 void
2928 {
2929 /* Clear pending FCF rediscovery wait flag */
2932 /* Now, try to stop the timer */
2934 }
2936 /**
2937 * lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer
2938 * @phba: pointer to lpfc hba data structure.
2939 *
2940 * This routine stops the SLI4 FCF rediscover wait timer if it's on. It
2941 * checks whether the FCF rediscovery wait timer is pending with the host
2942 * lock held before proceeding with disabling the timer and clearing the
2943 * wait timer pendig flag.
2944 **/
2945 void
2947 {
2950 /* FCF rediscovery timer already fired or stopped */
2953 }
2955 /* Clear failover in progress flags */
2958 }
2960 /**
2961 * lpfc_stop_hba_timers - Stop all the timers associated with an HBA
2962 * @phba: pointer to lpfc hba data structure.
2963 *
2964 * This routine stops all the timers associated with a HBA. This function is
2965 * invoked before either putting a HBA offline or unloading the driver.
2966 **/
2967 void
2969 {
2981 }
2986 /* Stop any LightPulse device specific driver timers */
2990 /* Stop any OneConnect device specific driver timers */
2998 }
3000 }
3002 /**
3003 * lpfc_block_mgmt_io - Mark a HBA's management interface as blocked
3004 * @phba: pointer to lpfc hba data structure.
3005 * @mbx_action: flag for mailbox no wait action.
3006 *
3007 * This routine marks a HBA's management interface as blocked. Once the HBA's
3008 * management interface is marked as blocked, all the user space access to
3009 * the HBA, whether they are from sysfs interface or libdfc interface will
3010 * all be blocked. The HBA is set to block the management interface when the
3011 * driver prepares the HBA interface for online or offline.
3012 **/
3013 static void
3015 {
3029 /* Determine how long we might wait for the active mailbox
3030 * command to be gracefully completed by firmware.
3031 */
3034 }
3037 /* Wait for the outstnading mailbox command to complete */
3039 /* Check active mailbox complete status every 2ms */
3043 "2813 Mgmt IO is Blocked %x "
3047 }
3048 }
3049 }
3051 /**
3052 * lpfc_sli4_node_prep - Assign RPIs for active nodes.
3053 * @phba: pointer to lpfc hba data structure.
3054 *
3055 * Allocate RPIs for all active remote nodes. This is needed whenever
3056 * an SLI4 adapter is reset and the driver is not unloading. Its purpose
3057 * is to fixup the temporary rpi assignments.
3058 **/
3059 void
3061 {
3079 nlp_listp) {
3082 /* TODO print log? */
3084 }
3088 "0009 Assign RPI x%x to ndlp x%px "
3092 }
3093 }
3095 }
3097 /**
3098 * lpfc_create_expedite_pool - create expedite pool
3099 * @phba: pointer to lpfc hba data structure.
3100 *
3101 * This routine moves a batch of XRIs from lpfc_io_buf_list_put of HWQ 0
3102 * to expedite pool. Mark them as expedite.
3103 **/
3105 {
3127 }
3130 }
3132 /**
3133 * lpfc_destroy_expedite_pool - destroy expedite pool
3134 * @phba: pointer to lpfc hba data structure.
3135 *
3136 * This routine returns XRIs from expedite pool to lpfc_io_buf_list_put
3137 * of HWQ 0. Clear the mark.
3138 **/
3140 {
3159 }
3162 }
3164 /**
3165 * lpfc_create_multixri_pools - create multi-XRI pools
3166 * @phba: pointer to lpfc hba data structure.
3167 *
3168 * This routine initialize public, private per HWQ. Then, move XRIs from
3169 * lpfc_io_buf_list_put to public pool. High and low watermark are also
3170 * Initialized.
3171 **/
3173 {
3175 u32 hwq_count;
3176 u32 count_per_hwq;
3201 "1238 Failed to allocate memory for "
3211 j++;
3212 }
3215 }
3223 /* Deal with public free xri pool */
3234 }
3241 /* Deal with private free xri pool */
3250 }
3251 }
3253 /**
3254 * lpfc_destroy_multixri_pools - destroy multi-XRI pools
3255 * @phba: pointer to lpfc hba data structure.
3256 *
3257 * This routine returns XRIs from public/private to lpfc_io_buf_list_put.
3258 **/
3260 {
3261 u32 i;
3262 u32 hwq_count;
3289 /* Deal with public free xri pool */
3303 }
3310 /* Deal with private free xri pool */
3324 }
3333 }
3334 }
3336 /**
3337 * lpfc_online - Initialize and bring a HBA online
3338 * @phba: pointer to lpfc hba data structure.
3339 *
3340 * This routine initializes the HBA and brings a HBA online. During this
3341 * process, the management interface is blocked to prevent user space access
3342 * to the HBA interfering with the driver initialization.
3343 *
3344 * Return codes
3345 * 0 - successful
3346 * 1 - failed
3347 **/
3348 int
3350 {
3372 }
3378 /* Reestablish the local initiator port.
3379 * The offline process destroyed the previous lport.
3380 */
3386 "6132 NVME restore reg failed "
3388 }
3394 }
3395 }
3410 LPFC_PHYSICAL_PORT))
3412 }
3414 }
3415 }
3425 }
3427 /**
3428 * lpfc_unblock_mgmt_io - Mark a HBA's management interface to be not blocked
3429 * @phba: pointer to lpfc hba data structure.
3430 *
3431 * This routine marks a HBA's management interface as not blocked. Once the
3432 * HBA's management interface is marked as not blocked, all the user space
3433 * access to the HBA, whether they are from sysfs interface or libdfc
3434 * interface will be allowed. The HBA is set to block the management interface
3435 * when the driver prepares the HBA interface for online or offline and then
3436 * set to unblock the management interface afterwards.
3437 **/
3438 void
3440 {
3446 }
3448 /**
3449 * lpfc_offline_prep - Prepare a HBA to be brought offline
3450 * @phba: pointer to lpfc hba data structure.
3451 * @mbx_action: flag for mailbox shutdown action.
3452 *
3453 * This routine is invoked to prepare a HBA to be brought offline. It performs
3454 * unregistration login to all the nodes on all vports and flushes the mailbox
3455 * queue to make it ready to be brought offline.
3456 **/
3457 void
3459 {
3473 /* Issue an unreg_login to all nodes on all vports */
3489 nlp_listp) {
3491 /* Driver must assume RPI is invalid for
3492 * any unused or inactive node.
3493 */
3496 }
3501 /*
3502 * Whenever an SLI4 port goes offline, free the
3503 * RPI. Get a new RPI when the adapter port
3504 * comes back online.
3505 */
3509 "0011 Free RPI x%x on "
3515 }
3522 /* Don't remove the node unless the
3523 * has been unregistered with the
3524 * transport. If so, let dev_loss
3525 * take care of the node.
3526 */
3529 lpfc_disc_state_machine
3531 NULL,
3532 NLP_EVT_DEVICE_RM);
3533 }
3534 }
3535 }
3536 }
3543 }
3545 /**
3546 * lpfc_offline - Bring a HBA offline
3547 * @phba: pointer to lpfc hba data structure.
3548 *
3549 * This routine actually brings a HBA offline. It stops all the timers
3550 * associated with the HBA, brings down the SLI layer, and eventually
3551 * marks the HBA as in offline state for the upper layer protocol.
3552 **/
3553 void
3555 {
3563 /* stop port and all timers associated with this hba */
3566 /* Tear down the local and target port registrations. The
3567 * nvme transports need to cleanup.
3568 */
3579 /* Bring down the SLI Layer and cleanup. The HBA is offline
3580 now. */
3593 }
3599 }
3601 /**
3602 * lpfc_scsi_free - Free all the SCSI buffers and IOCBs from driver lists
3603 * @phba: pointer to lpfc hba data structure.
3604 *
3605 * This routine is to free all the SCSI buffers and IOCBs from the driver
3606 * list back to kernel. It is called from lpfc_pci_remove_one to free
3607 * the internal resources before the device is removed from the system.
3608 **/
3609 static void
3611 {
3619 /* Release all the lpfc_scsi_bufs maintained by this host. */
3623 list) {
3629 }
3634 list) {
3640 }
3643 }
3645 /**
3646 * lpfc_io_free - Free all the IO buffers and IOCBs from driver lists
3647 * @phba: pointer to lpfc hba data structure.
3648 *
3649 * This routine is to free all the IO buffers and IOCBs from the driver
3650 * list back to kernel. It is called from lpfc_pci_remove_one to free
3651 * the internal resources before the device is removed from the system.
3652 **/
3653 void
3655 {
3662 /* Release all the lpfc_nvme_bufs maintained by this host. */
3666 list) {
3676 }
3682 list) {
3692 }
3694 }
3695 }
3697 /**
3698 * lpfc_sli4_els_sgl_update - update ELS xri-sgl sizing and mapping
3699 * @phba: pointer to lpfc hba data structure.
3700 *
3701 * This routine first calculates the sizes of the current els and allocated
3702 * scsi sgl lists, and then goes through all sgls to updates the physical
3703 * XRIs assigned due to port function reset. During port initialization, the
3704 * current els and allocated scsi sgl lists are 0s.
3705 *
3706 * Return codes
3707 * 0 - successful (for now, it always returns 0)
3708 **/
3709 int
3711 {
3717 /*
3718 * update on pci function's els xri-sgl list
3719 */
3723 /* els xri-sgl expanded */
3726 "3157 ELS xri-sgl count increased from "
3728 els_xri_cnt);
3729 /* allocate the additional els sgls */
3732 GFP_KERNEL);
3735 LOG_TRACE_EVENT,
3736 "2562 Failure to allocate an "
3740 }
3747 LOG_TRACE_EVENT,
3748 "2563 Failure to allocate an "
3752 }
3757 }
3765 /* els xri-sgl shrinked */
3768 "3158 ELS xri-sgl count decreased from "
3770 els_xri_cnt);
3775 /* release extra els sgls from list */
3783 }
3784 }
3792 els_xri_cnt);
3795 /* update xris to els sgls on the list */
3803 LOG_TRACE_EVENT,
3804 "2400 Failed to allocate xri for "
3808 }
3811 }
3814 out_free_mem:
3817 }
3819 /**
3820 * lpfc_sli4_nvmet_sgl_update - update xri-sgl sizing and mapping
3821 * @phba: pointer to lpfc hba data structure.
3822 *
3823 * This routine first calculates the sizes of the current els and allocated
3824 * scsi sgl lists, and then goes through all sgls to updates the physical
3825 * XRIs assigned due to port function reset. During port initialization, the
3826 * current els and allocated scsi sgl lists are 0s.
3827 *
3828 * Return codes
3829 * 0 - successful (for now, it always returns 0)
3830 **/
3831 int
3833 {
3840 /*
3841 * update on pci function's nvmet xri-sgl list
3842 */
3845 /* For NVMET, ALL remaining XRIs are dedicated for IO processing */
3848 /* els xri-sgl expanded */
3853 /* allocate the additional nvmet sgls */
3856 GFP_KERNEL);
3859 LOG_TRACE_EVENT,
3860 "6303 Failure to allocate an "
3864 }
3871 LOG_TRACE_EVENT,
3872 "6304 Failure to allocate an "
3876 }
3882 }
3890 /* nvmet xri-sgl shrunk */
3893 "6305 NVMET xri-sgl count decreased from "
3895 nvmet_xri_cnt);
3900 /* release extra nvmet sgls from list */
3908 }
3909 }
3917 nvmet_xri_cnt);
3920 /* update xris to nvmet sgls on the list */
3928 LOG_TRACE_EVENT,
3929 "6307 Failed to allocate xri for "
3933 }
3936 }
3939 out_free_mem:
3942 }
3944 int
3946 {
3959 /* Take everything off the get and put lists */
3970 }
3972 /*
3973 * Take IO buffers off blist and put on cbuf sorted by XRI.
3974 * This is because POST_SGL takes a sequential range of XRIs
3975 * to post to the firmware.
3976 */
3984 }
3993 else
3997 }
3999 }
4002 }
4004 }
4006 int
4008 {
4021 cnt++;
4033 }
4034 }
4036 }
4038 /**
4039 * lpfc_sli4_io_sgl_update - update xri-sgl sizing and mapping
4040 * @phba: pointer to lpfc hba data structure.
4041 *
4042 * This routine first calculates the sizes of the current els and allocated
4043 * scsi sgl lists, and then goes through all sgls to updates the physical
4044 * XRIs assigned due to port function reset. During port initialization, the
4045 * current els and allocated scsi sgl lists are 0s.
4046 *
4047 * Return codes
4048 * 0 - successful (for now, it always returns 0)
4049 **/
4050 int
4052 {
4059 /*
4060 * update on pci function's allocated nvme xri-sgl list
4061 */
4063 /* maximum number of xris available for nvme buffers */
4069 "6074 Current allocated XRI sgl count:%d, "
4077 /* max nvme xri shrunk below the allocated nvme buffers */
4080 /* release the extra allocated nvme buffers */
4089 }
4090 }
4092 }
4094 /* update xris associated to remaining allocated nvme buffers */
4103 LOG_TRACE_EVENT,
4104 "6075 Failed to allocate xri for "
4108 }
4111 }
4115 out_free_mem:
4118 }
4120 /**
4121 * lpfc_new_io_buf - IO buffer allocator for HBA with SLI4 IF spec
4122 * @phba: Pointer to lpfc hba data structure.
4123 * @num_to_alloc: The requested number of buffers to allocate.
4124 *
4125 * This routine allocates nvme buffers for device with SLI-4 interface spec,
4126 * the nvme buffer contains all the necessary information needed to initiate
4127 * an I/O. After allocating up to @num_to_allocate IO buffers and put
4128 * them on a list, it post them to the port by using SGL block post.
4129 *
4130 * Return codes:
4131 * int - number of IO buffers that were allocated and posted.
4132 * 0 = failure, less than num_to_alloc is a partial failure.
4133 **/
4134 int
4136 {
4150 /*
4151 * Get memory from the pci pool to map the virt space to
4152 * pci bus space for an I/O. The DMA buffer includes the
4153 * number of SGE's necessary to support the sg_tablesize.
4154 */
4156 GFP_KERNEL,
4161 }
4166 /*
4167 * 4K Page alignment is CRITICAL to BlockGuard, double
4168 * check to be sure.
4169 */
4174 LOG_TRACE_EVENT,
4175 "3369 Memory alignment err: "
4183 }
4184 }
4194 }
4197 /* Allocate iotag for lpfc_ncmd->cur_iocbq. */
4204 "6121 Failed to allocate IOTAG for"
4208 }
4213 /* Initialize local short-hand pointers. */
4219 /* add the nvme buffer to a post list */
4222 }
4224 "6114 Allocate %d out of %d requested new NVME "
4227 /* post the list of nvme buffer sgls to port if available */
4231 else
4235 }
4237 static uint64_t
4239 {
4246 GFP_KERNEL);
4250 /* First get WWN of HBA instance */
4255 "6019 Mailbox failed , mbxCmd x%x "
4261 }
4264 /* wwn is WWPN of HBA instance */
4268 else
4270 }
4272 /**
4273 * lpfc_create_port - Create an FC port
4274 * @phba: pointer to lpfc hba data structure.
4275 * @instance: a unique integer ID to this FC port.
4276 * @dev: pointer to the device data structure.
4277 *
4278 * This routine creates a FC port for the upper layer protocol. The FC port
4279 * can be created on top of either a physical port or a virtual port provided
4280 * by the HBA. This routine also allocates a SCSI host data structure (shost)
4281 * and associates the FC port created before adding the shost into the SCSI
4282 * layer.
4283 *
4284 * Return codes
4285 * @vport - pointer to the virtual N_Port data structure.
4286 * NULL - port create failed.
4287 **/
4290 {
4303 /* Reset the port first */
4308 }
4310 }
4315 LOG_TRACE_EVENT,
4317 wwn);
4320 }
4321 }
4323 /* Seed template for SCSI host registration */
4328 /* Seed physical port template */
4332 /* template is for a no reset SCSI Host */
4335 /* Template for all vports this physical port creates */
4343 /* Initialize the host templates with updated value */
4352 }
4355 /* NVMET is for physical port only */
4358 }
4361 }
4374 /* Adjust value in vport */
4396 else
4399 /* SLI-3 has a limited number of hardware queues (3),
4400 * thus there is only one for FCP processing.
4401 */
4404 /*
4405 * Set initial can_queue value since 0 is no longer supported and
4406 * scsi_add_host will fail. This will be adjusted later based on the
4407 * max xri value determined in hba setup.
4408 */
4416 }
4419 "9081 CreatePort TMPLATE type %x TBLsize %d "
4424 /* Initialize all internally managed lists. */
4447 out_put_shost:
4449 out:
4451 }
4453 /**
4454 * destroy_port - destroy an FC port
4455 * @vport: pointer to an lpfc virtual N_Port data structure.
4456 *
4457 * This routine destroys a FC port from the upper layer protocol. All the
4458 * resources associated with the port are released.
4459 **/
4460 void
4462 {
4476 }
4478 /**
4479 * lpfc_get_instance - Get a unique integer ID
4480 *
4481 * This routine allocates a unique integer ID from lpfc_hba_index pool. It
4482 * uses the kernel idr facility to perform the task.
4483 *
4484 * Return codes:
4485 * instance - a unique integer ID allocated as the new instance.
4486 * -1 - lpfc get instance failed.
4487 **/
4488 int
4490 {
4495 }
4497 /**
4498 * lpfc_scan_finished - method for SCSI layer to detect whether scan is done
4499 * @shost: pointer to SCSI host data structure.
4500 * @time: elapsed time of the scan in jiffies.
4501 *
4502 * This routine is called by the SCSI layer with a SCSI host to determine
4503 * whether the scan host is finished.
4504 *
4505 * Note: there is no scan_start function as adapter initialization will have
4506 * asynchronously kicked off the link initialization.
4507 *
4508 * Return codes
4509 * 0 - SCSI host scan is not over yet.
4510 * 1 - SCSI host scan is over.
4511 **/
4513 {
4523 }
4526 "0461 Scanning longer than 30 "
4530 }
4534 "0465 Link down longer than 15 "
4538 }
4551 finished:
4554 }
4557 {
4562 /*
4563 * Avoid reporting supported link speed for FCoE as it can't be
4564 * controlled via FCoE.
4565 */
4587 }
4589 /**
4590 * lpfc_host_attrib_init - Initialize SCSI host attributes on a FC port
4591 * @shost: pointer to SCSI host data structure.
4592 *
4593 * This routine initializes a given SCSI host attributes on a FC port. The
4594 * SCSI host can be either on top of a physical port or a virtual port.
4595 **/
4597 {
4600 /*
4601 * Set fixed host attributes. Must done after lpfc_sli_hba_setup().
4602 */
4624 /* This value is also unchanging */
4634 }
4636 /**
4637 * lpfc_stop_port_s3 - Stop SLI3 device port
4638 * @phba: pointer to lpfc hba data structure.
4639 *
4640 * This routine is invoked to stop an SLI3 device port, it stops the device
4641 * from generating interrupts and stops the device driver's timers for the
4642 * device.
4643 **/
4644 static void
4646 {
4647 /* Clear all interrupt enable conditions */
4650 /* Clear all pending interrupts */
4654 /* Reset some HBA SLI setup states */
4657 }
4659 /**
4660 * lpfc_stop_port_s4 - Stop SLI4 device port
4661 * @phba: pointer to lpfc hba data structure.
4662 *
4663 * This routine is invoked to stop an SLI4 device port, it stops the device
4664 * from generating interrupts and stops the device driver's timers for the
4665 * device.
4666 **/
4667 static void
4669 {
4670 /* Reset some HBA SLI4 setup states */
4675 }
4677 /**
4678 * lpfc_stop_port - Wrapper function for stopping hba port
4679 * @phba: Pointer to HBA context object.
4680 *
4681 * This routine wraps the actual SLI3 or SLI4 hba stop port routine from
4682 * the API jump table function pointer from the lpfc_hba struct.
4683 **/
4684 void
4686 {
4691 }
4693 /**
4694 * lpfc_fcf_redisc_wait_start_timer - Start fcf rediscover wait timer
4695 * @phba: Pointer to hba for which this call is being executed.
4696 *
4697 * This routine starts the timer waiting for the FCF rediscovery to complete.
4698 **/
4699 void
4701 {
4704 /* Start fcf rediscovery wait period timer */
4707 /* Allow action to new fcf asynchronous event */
4709 /* Mark the FCF rediscovery pending state */
4712 }
4714 /**
4715 * lpfc_sli4_fcf_redisc_wait_tmo - FCF table rediscover wait timeout
4716 * @t: Timer context used to obtain the pointer to lpfc hba data structure.
4717 *
4718 * This routine is invoked when waiting for FCF table rediscover has been
4719 * timed out. If new FCF record(s) has (have) been discovered during the
4720 * wait period, a new FCF event shall be added to the FCOE async event
4721 * list, and then worker thread shall be waked up for processing from the
4722 * worker thread context.
4723 **/
4724 static void
4726 {
4729 /* Don't send FCF rediscovery event if timer cancelled */
4734 }
4735 /* Clear FCF rediscovery timer pending flag */
4737 /* FCF rediscovery event to worker thread */
4742 /* wake up worker thread */
4744 }
4746 /**
4747 * lpfc_sli4_parse_latt_fault - Parse sli4 link-attention link fault code
4748 * @phba: pointer to lpfc hba data structure.
4749 * @acqe_link: pointer to the async link completion queue entry.
4750 *
4751 * This routine is to parse the SLI4 link-attention link fault code.
4752 **/
4753 static void
4756 {
4768 }
4769 }
4771 /**
4772 * lpfc_sli4_parse_latt_type - Parse sli4 link attention type
4773 * @phba: pointer to lpfc hba data structure.
4774 * @acqe_link: pointer to the async link completion queue entry.
4775 *
4776 * This routine is to parse the SLI4 link attention type and translate it
4777 * into the base driver's link attention type coding.
4778 *
4779 * Return: Link attention type in terms of base driver's coding.
4780 **/
4781 static uint8_t
4784 {
4793 /* Ignore physical link up events - wait for logical link up */
4805 }
4807 }
4809 /**
4810 * lpfc_sli_port_speed_get - Get sli3 link speed code to link speed
4811 * @phba: pointer to lpfc hba data structure.
4812 *
4813 * This routine is to get an SLI3 FC port's link speed in Mbps.
4814 *
4815 * Return: link speed in terms of Mbps.
4816 **/
4817 uint32_t
4819 {
4847 }
4850 link_speed =
4852 else
4854 }
4856 }
4858 /**
4859 * lpfc_sli4_port_speed_parse - Parse async evt link speed code to link speed
4860 * @phba: pointer to lpfc hba data structure.
4861 * @evt_code: asynchronous event code.
4862 * @speed_code: asynchronous event link speed code.
4863 *
4864 * This routine is to parse the giving SLI4 async event link speed code into
4865 * value of Mbps for the link speed.
4866 *
4867 * Return: link speed in terms of Mbps.
4868 **/
4869 static uint32_t
4872 {
4907 }
4943 }
4947 }
4949 }
4951 /**
4952 * lpfc_sli4_async_link_evt - Process the asynchronous FCoE link event
4953 * @phba: pointer to lpfc hba data structure.
4954 * @acqe_link: pointer to the async link completion queue entry.
4955 *
4956 * This routine is to handle the SLI4 asynchronous FCoE link event.
4957 **/
4958 static void
4961 {
4978 }
4984 }
4990 }
4992 /* Cleanup any outstanding ELS commands */
4995 /* Block ELS IOCBs until we have done process link event */
4998 /* Update link event statistics */
5001 /* Create lpfc_handle_latt mailbox command from link ACQE */
5006 /* Keep the link status for extra SLI4 state machine reference */
5024 "2900 Async FC/FCoE Link event - Speed:%dGBit "
5025 "duplex:x%x LA Type:x%x Port Type:%d Port Number:%d "
5034 /*
5035 * For FC Mode: issue the READ_TOPOLOGY mailbox command to fetch
5036 * topology info. Note: Optional for non FC-AL ports.
5037 */
5043 }
5044 /*
5045 * For FCoE Mode: fill in all the topology information we need and call
5046 * the READ_TOPOLOGY completion routine to continue without actually
5047 * sending the READ_TOPOLOGY mailbox command to the port.
5048 */
5049 /* Initialize completion status */
5053 /* Parse port fault information field */
5056 /* Parse and translate link attention fields */
5063 /* Fake the the following irrelvant fields */
5071 /* Invoke the lpfc_handle_latt mailbox command callback function */
5076 out_free_dmabuf:
5078 out_free_pmb:
5080 }
5082 /**
5083 * lpfc_async_link_speed_to_read_top - Parse async evt link speed code to read
5084 * topology.
5085 * @phba: pointer to lpfc hba data structure.
5086 * @speed_code: asynchronous event link speed code.
5087 *
5088 * This routine is to parse the giving SLI4 async event link speed code into
5089 * value of Read topology link speed.
5090 *
5091 * Return: link speed in terms of Read topology.
5092 **/
5093 static uint8_t
5095 {
5129 }
5132 }
5134 #define trunk_link_status(__idx)\
5135 bf_get(lpfc_acqe_fc_la_trunk_config_port##__idx, acqe_fc) ?\
5136 ((phba->trunk_link.link##__idx.state == LPFC_LINK_UP) ?\
5138 /* Did port __idx reported an error */
5139 #define trunk_port_fault(__idx)\
5140 bf_get(lpfc_acqe_fc_la_trunk_config_port##__idx, acqe_fc) ?\
5143 static void
5146 {
5156 /* We got FC link speed, convert to fc_linkspeed (READ_TOPOLOGY) */
5159 phba,
5167 }
5173 }
5179 }
5185 }
5198 "3202 trunk error:0x%x (%s) seen on port0:%s "
5199 /*
5200 * SLI-4: We have only 0xA error codes
5201 * defined as of now. print an appropriate
5202 * message in case driver needs to be updated.
5203 */
5208 }
5211 /**
5212 * lpfc_sli4_async_fc_evt - Process the asynchronous FC link event
5213 * @phba: pointer to lpfc hba data structure.
5214 * @acqe_fc: pointer to the async fc completion queue entry.
5215 *
5216 * This routine is to handle the SLI4 asynchronous FC event. It will simply log
5217 * that the event was received and then issue a read_topology mailbox command so
5218 * that the rest of the driver will treat it the same as SLI3.
5219 **/
5220 static void
5222 {
5230 LPFC_FC_LA_EVENT_TYPE_FC_LINK) {
5235 }
5238 LPFC_FC_LA_TYPE_TRUNKING_EVENT) {
5241 }
5243 /* Keep the link status for extra SLI4 state machine reference */
5260 LPFC_FC_LA_TYPE_LINK_DOWN)
5267 "2896 Async FC event - Speed:%dGBaud Topology:x%x "
5268 "LA Type:x%x Port Type:%d Port Number:%d Logical speed:"
5282 }
5288 }
5294 }
5296 /* Cleanup any outstanding ELS commands */
5299 /* Block ELS IOCBs until we have done process link event */
5302 /* Update link event statistics */
5305 /* Create lpfc_handle_latt mailbox command from link ACQE */
5322 }
5324 /* Initialize completion status */
5328 /* Parse port fault information field */
5331 /* Parse and translate link attention fields */
5336 LPFC_FC_LA_TYPE_UNEXP_WWPN) {
5338 LPFC_FC_LA_TYPE_UNEXP_WWPN);
5341 LPFC_FC_LA_TYPE_LINK_DOWN);
5342 }
5343 /* Invoke the mailbox command callback function */
5347 }
5354 out_free_dmabuf:
5356 out_free_pmb:
5358 }
5360 /**
5361 * lpfc_sli4_async_sli_evt - Process the asynchronous SLI link event
5362 * @phba: pointer to lpfc hba data structure.
5363 * @acqe_sli: pointer to the async SLI completion queue entry.
5364 *
5365 * This routine is to handle the SLI4 asynchronous SLI events.
5366 **/
5367 static void
5369 {
5384 "2901 Async SLI event - Type:%d, Event Data: x%08x "
5408 SCSI_NL_VID_TYPE_PCI
5424 SCSI_NL_VID_TYPE_PCI
5431 /* fetch the status for this port */
5459 "3296 "
5460 "LPFC_SLI_EVENT_TYPE_MISCONFIGURED "
5464 }
5466 /* Skip if optic state unchanged */
5476 "installed/not installed - Reseat optics, "
5481 "Optics of two types installed - Remove one "
5490 "Avago optics for Warranty and Technical "
5496 "Avago-certified optics to enable link "
5501 /* firmware is reporting a status we don't know about */
5504 }
5506 /* Issue READ_CONFIG mbox command to refresh supported speeds */
5511 LOG_TRACE_EVENT,
5512 "3194 Unable to retrieve supported "
5514 }
5518 i++) {
5521 }
5522 }
5531 "3192 Remote DPort Test Initiated - "
5536 /* Misconfigured WWN. Reports that the SLI Port is configured
5537 * to use FA-WWN, but the attached device doesn’t support it.
5538 * No driver action is required.
5539 * Event Data1 - N.A, Event Data2 - N.A
5540 */
5542 "2699 Misconfigured FA-WWN - Attached device does "
5546 /* EEPROM failure. No driver action is required */
5548 "2518 EEPROM failure - "
5555 evt_type);
5557 }
5558 }
5560 /**
5561 * lpfc_sli4_perform_vport_cvl - Perform clear virtual link on a vport
5562 * @vport: pointer to vport data structure.
5563 *
5564 * This routine is to perform Clear Virtual Link (CVL) on a vport in
5565 * response to a CVL event.
5566 *
5567 * Return the pointer to the ndlp with the vport if successful, otherwise
5568 * return NULL.
5569 **/
5572 {
5584 /* Cannot find existing Fabric ndlp, so allocate a new one */
5588 /* Set the node type */
5590 /* Put ndlp onto node list */
5592 }
5596 /* If virtual link is not yet instantiated ignore CVL */
5610 }
5612 /**
5613 * lpfc_sli4_perform_all_vport_cvl - Perform clear virtual link on all vports
5614 * @phba: pointer to lpfc hba data structure.
5615 *
5616 * This routine is to perform Clear Virtual Link (CVL) on all vports in
5617 * response to a FCF dead event.
5618 **/
5619 static void
5621 {
5630 }
5632 /**
5633 * lpfc_sli4_async_fip_evt - Process the asynchronous FCoE FIP event
5634 * @phba: pointer to lpfc hba data structure.
5635 * @acqe_fip: pointer to the async fcoe completion queue entry.
5636 *
5637 * This routine is to handle the SLI4 asynchronous fcoe event.
5638 **/
5639 static void
5642 {
5658 "2546 New FCF event, evt_tag:x%x, "
5662 else
5664 LOG_DISCOVERY,
5665 "2788 FCF param modified event, "
5670 /*
5671 * During period of FCF discovery, read the FCF
5672 * table record indexed by the event to update
5673 * FCF roundrobin failover eligible FCF bmask.
5674 */
5676 LOG_DISCOVERY,
5677 "2779 Read FCF (x%x) for updating "
5681 }
5683 /* If the FCF discovery is in progress, do nothing. */
5688 }
5689 /* If fast FCF failover rescan event is pending, do nothing */
5693 }
5695 /* If the FCF has been in discovered state, do nothing. */
5699 }
5702 /* Otherwise, scan the entire FCF table and re-discover SAN */
5704 "2770 Start FCF table scan per async FCF "
5708 LPFC_FCOE_FCF_GET_FIRST);
5711 "2547 Issue FCF scan read FCF mailbox "
5725 "2549 FCF (x%x) disconnected from network, "
5728 /*
5729 * If we are in the middle of FCF failover process, clear
5730 * the corresponding FCF bit in the roundrobin bitmap.
5731 */
5736 /* Update FLOGI FCF failover eligible FCF bmask */
5739 }
5742 /* If the event is not for currently used fcf do nothing */
5746 /*
5747 * Otherwise, request the port to rediscover the entire FCF
5748 * table for a fast recovery from case that the current FCF
5749 * is no longer valid as we are not in the middle of FCF
5750 * failover process already.
5751 */
5753 /* Mark the fast failover process in progress */
5758 "2771 Start FCF fast failover process due to "
5759 "FCF DEAD event: evt_tag:x%x, fcf_index:x%x "
5764 LOG_TRACE_EVENT,
5765 "2772 Issue FCF rediscover mailbox "
5766 "command failed, fail through to FCF "
5771 /*
5772 * Last resort will fail over by treating this
5773 * as a link down to FCF registration.
5774 */
5777 /* Reset FCF roundrobin bmask for new discovery */
5779 /*
5780 * Handling fast FCF failover to a DEAD FCF event is
5781 * considered equalivant to receiving CVL to all vports.
5782 */
5784 }
5789 LOG_TRACE_EVENT,
5790 "2718 Clear Virtual Link Received for VPI 0x%x"
5803 i++) {
5805 FC_VPORT_CVL_RCVD)) &&
5809 }
5810 }
5812 }
5814 /*
5815 * Don't re-instantiate if vport is marked for deletion.
5816 * If we are here first then vport_delete is going to wait
5817 * for discovery to complete.
5818 */
5820 active_vlink_present) {
5821 /*
5822 * If there are other active VLinks present,
5823 * re-instantiate the Vlink using FDISC.
5824 */
5833 /*
5834 * Otherwise, we request port to rediscover
5835 * the entire FCF table for a fast recovery
5836 * from possible case that the current FCF
5837 * is no longer valid if we are not already
5838 * in the FCF failover process.
5839 */
5844 }
5845 /* Mark the fast failover process in progress */
5849 LOG_DISCOVERY,
5850 "2773 Start FCF failover per CVL, "
5855 LOG_TRACE_EVENT,
5856 "2774 Issue FCF rediscover "
5857 "mailbox command failed, "
5862 /*
5863 * Last resort will be re-try on the
5864 * the current registered FCF entry.
5865 */
5868 /*
5869 * Reset FCF roundrobin bmask for new
5870 * discovery.
5871 */
5873 }
5877 "0288 Unknown FCoE event type 0x%x event tag "
5880 }
5881 }
5883 /**
5884 * lpfc_sli4_async_dcbx_evt - Process the asynchronous dcbx event
5885 * @phba: pointer to lpfc hba data structure.
5886 * @acqe_dcbx: pointer to the async dcbx completion queue entry.
5887 *
5888 * This routine is to handle the SLI4 asynchronous dcbx event.
5889 **/
5890 static void
5893 {
5896 "0290 The SLI4 DCBX asynchronous event is not "
5898 }
5900 /**
5901 * lpfc_sli4_async_grp5_evt - Process the asynchronous group5 event
5902 * @phba: pointer to lpfc hba data structure.
5903 * @acqe_grp5: pointer to the async grp5 completion queue entry.
5904 *
5905 * This routine is to handle the SLI4 asynchronous grp5 event. A grp5 event
5906 * is an asynchronous notified of a logical link speed change. The Port
5907 * reports the logical link speed in units of 10Mbps.
5908 **/
5909 static void
5912 {
5921 "2789 GRP5 Async Event: Updating logical link speed "
5924 }
5926 /**
5927 * lpfc_sli4_async_event_proc - Process all the pending asynchronous event
5928 * @phba: pointer to lpfc hba data structure.
5929 *
5930 * This routine is invoked by the worker thread to process all the pending
5931 * SLI4 asynchronous events.
5932 **/
5934 {
5938 /* First, declare the async event has been handled */
5943 /* Now, handle all the async events */
5949 iflags);
5951 /* Process the asynchronous event */
5976 LOG_TRACE_EVENT,
5977 "1804 Invalid asynchronous event code: "
5981 }
5983 /* Free the completion event processed to the free pool */
5986 }
5988 }
5990 /**
5991 * lpfc_sli4_fcf_redisc_event_proc - Process fcf table rediscovery event
5992 * @phba: pointer to lpfc hba data structure.
5993 *
5994 * This routine is invoked by the worker thread to process FCF table
5995 * rediscovery pending completion event.
5996 **/
5998 {
6002 /* Clear FCF rediscovery timeout event */
6004 /* Clear driver fast failover FCF record flag */
6006 /* Set state for FCF fast failover */
6010 /* Scan FCF table from the first entry to re-discover SAN */
6016 "2747 Issue FCF scan read FCF mailbox "
6018 }
6020 /**
6021 * lpfc_api_table_setup - Set up per hba pci-device group func api jump table
6022 * @phba: pointer to lpfc hba data structure.
6023 * @dev_grp: The HBA PCI-Device group number.
6024 *
6025 * This routine is invoked to set up the per HBA PCI-Device group function
6026 * API jump table entries.
6027 *
6028 * Return: 0 if success, otherwise -ENODEV
6029 **/
6030 int
6032 {
6035 /* Set up lpfc PCI-device group */
6038 /* The LPFC_PCI_DEV_OC uses SLI4 */
6042 /* Set up device INIT API function jump table */
6046 /* Set up SCSI API function jump table */
6050 /* Set up SLI API function jump table */
6054 /* Set up MBOX API function jump table */
6060 }
6062 /**
6063 * lpfc_log_intr_mode - Log the active interrupt mode
6064 * @phba: pointer to lpfc hba data structure.
6065 * @intr_mode: active interrupt mode adopted.
6066 *
6067 * This routine it invoked to log the currently used active interrupt mode
6068 * to the device.
6069 **/
6071 {
6089 }
6091 }
6093 /**
6094 * lpfc_enable_pci_dev - Enable a generic PCI device.
6095 * @phba: pointer to lpfc hba data structure.
6096 *
6097 * This routine is invoked to enable the PCI device that is common to all
6098 * PCI devices.
6099 *
6100 * Return codes
6101 * 0 - successful
6102 * other values - error
6103 **/
6104 static int
6106 {
6109 /* Obtain PCI device reference */
6112 else
6114 /* Enable PCI device */
6117 /* Request PCI resource for the device */
6120 /* Set up device as PCI master and save state for EEH */
6125 /* PCIe EEH recovery on powerpc platforms needs fundamental reset */
6131 out_disable_device:
6133 out_error:
6137 }
6139 /**
6140 * lpfc_disable_pci_dev - Disable a generic PCI device.
6141 * @phba: pointer to lpfc hba data structure.
6142 *
6143 * This routine is invoked to disable the PCI device that is common to all
6144 * PCI devices.
6145 **/
6146 static void
6148 {
6151 /* Obtain PCI device reference */
6154 else
6156 /* Release PCI resource and disable PCI device */
6161 }
6163 /**
6164 * lpfc_reset_hba - Reset a hba
6165 * @phba: pointer to lpfc hba data structure.
6166 *
6167 * This routine is invoked to reset a hba device. It brings the HBA
6168 * offline, performs a board restart, and then brings the board back
6169 * online. The lpfc_offline calls lpfc_sli_hba_down which will clean up
6170 * on outstanding mailbox commands.
6171 **/
6172 void
6174 {
6175 /* If resets are disabled then set error state and return. */
6179 }
6182 else
6188 }
6190 /**
6191 * lpfc_sli_sriov_nr_virtfn_get - Get the number of sr-iov virtual functions
6192 * @phba: pointer to lpfc hba data structure.
6193 *
6194 * This function enables the PCI SR-IOV virtual functions to a physical
6195 * function. It invokes the PCI SR-IOV api with the @nr_vfn provided to
6196 * enable the number of virtual functions to the physical function. As
6197 * not all devices support SR-IOV, the return code from the pci_enable_sriov()
6198 * API call does not considered as an error condition for most of the device.
6199 **/
6200 uint16_t
6202 {
6213 }
6215 /**
6216 * lpfc_sli_probe_sriov_nr_virtfn - Enable a number of sr-iov virtual functions
6217 * @phba: pointer to lpfc hba data structure.
6218 * @nr_vfn: number of virtual functions to be enabled.
6219 *
6220 * This function enables the PCI SR-IOV virtual functions to a physical
6221 * function. It invokes the PCI SR-IOV api with the @nr_vfn provided to
6222 * enable the number of virtual functions to the physical function. As
6223 * not all devices support SR-IOV, the return code from the pci_enable_sriov()
6224 * API call does not considered as an error condition for most of the device.
6225 **/
6226 int
6228 {
6236 "3057 Requested vfs (%d) greater than "
6239 }
6244 "2806 Failed to enable sriov on this device "
6249 "2807 Successful enable sriov on this device "
6252 }
6254 /**
6255 * lpfc_setup_driver_resource_phase1 - Phase1 etup driver internal resources.
6256 * @phba: pointer to lpfc hba data structure.
6257 *
6258 * This routine is invoked to set up the driver internal resources before the
6259 * device specific resource setup to support the HBA device it attached to.
6260 *
6261 * Return codes
6262 * 0 - successful
6263 * other values - error
6264 **/
6265 static int
6267 {
6270 /*
6271 * Driver resources common to all SLI revisions
6272 */
6279 /* Initialize port_list spinlock */
6286 /* Initialize the wait queue head for the kernel thread */
6297 /* Initialize the IO buffer list used by driver for SLI3 SCSI */
6303 /* Initialize the fabric iocb list */
6306 /* Initialize list to save ELS buffers */
6309 /* Initialize FCF connection rec list */
6312 /* Initialize OAS configuration list */
6316 /* MBOX heartbeat timer */
6318 /* Fabric block timer */
6320 /* EA polling mode timer */
6322 /* Heartbeat timer */
6328 lpfc_idle_stat_delay_work);
6331 }
6333 /**
6334 * lpfc_sli_driver_resource_setup - Setup driver internal resources for SLI3 dev
6335 * @phba: pointer to lpfc hba data structure.
6336 *
6337 * This routine is invoked to set up the driver internal resources specific to
6338 * support the SLI-3 HBA device it attached to.
6339 *
6340 * Return codes
6341 * 0 - successful
6342 * other values - error
6343 **/
6344 static int
6346 {
6349 /*
6350 * Initialize timers used by driver
6351 */
6353 /* FCP polling mode timer */
6356 /* Host attention work mask setup */
6360 /* Get all the module params for configuring this host */
6362 /* Set up phase-1 common device driver resources */
6370 /* check for menlo minimum sg count */
6373 }
6378 GFP_KERNEL);
6382 /*
6383 * Since lpfc_sg_seg_cnt is module parameter, the sg_dma_buf_size
6384 * used to create the sg_dma_buf_pool must be dynamically calculated.
6385 */
6389 else
6392 /* There are going to be 2 reserved BDEs: 1 FCP cmnd + 1 FCP rsp */
6394 /*
6395 * The scsi_buf for a T10-DIF I/O will hold the FCP cmnd,
6396 * the FCP rsp, and a BDE for each. Sice we have no control
6397 * over how many protection data segments the SCSI Layer
6398 * will hand us (ie: there could be one for every block
6399 * in the IO), we just allocate enough BDEs to accomidate
6400 * our max amount and we need to limit lpfc_sg_seg_cnt to
6401 * minimize the risk of running out.
6402 */
6410 /* Total BDEs in BPL for scsi_sg_list and scsi_sg_prot_list */
6413 /*
6414 * The scsi_buf for a regular I/O will hold the FCP cmnd,
6415 * the FCP rsp, a BDE for each, and a BDE for up to
6416 * cfg_sg_seg_cnt data segments.
6417 */
6422 /* Total BDEs in BPL for scsi_sg_list */
6424 }
6432 /* This will be set to correct value after config_port mbox */
6435 /*
6436 * Initialize the SLI Layer to run with lpfc HBAs.
6437 */
6441 /* Allocate device driver memory */
6463 /*
6464 * Enable sr-iov virtual functions if supported and configured
6465 * through the module parameter.
6466 */
6472 "2808 Requested number of SR-IOV "
6473 "virtual functions (%d) is not "
6477 }
6478 }
6482 fail_free_dma_buf_pool:
6485 fail_free_mem:
6488 }
6490 /**
6491 * lpfc_sli_driver_resource_unset - Unset drvr internal resources for SLI3 dev
6492 * @phba: pointer to lpfc hba data structure.
6493 *
6494 * This routine is invoked to unset the driver internal resources set up
6495 * specific for supporting the SLI-3 HBA device it attached to.
6496 **/
6497 static void
6499 {
6500 /* Free device driver memory allocated */
6504 }
6506 /**
6507 * lpfc_sli4_driver_resource_setup - Setup drvr internal resources for SLI4 dev
6508 * @phba: pointer to lpfc hba data structure.
6509 *
6510 * This routine is invoked to set up the driver internal resources specific to
6511 * support the SLI-4 HBA device it attached to.
6512 *
6513 * Return codes
6514 * 0 - successful
6515 * other values - error
6516 **/
6517 static int
6519 {
6528 u32 if_type;
6529 u32 if_fam;
6535 /* Get all the module params for configuring this host */
6538 /* Set up phase-1 common device driver resources */
6543 /* Before proceed, wait for POST done and device ready */
6548 /* Allocate all driver workqueues here */
6550 /* The lpfc_wq workqueue for deferred irq use */
6553 /*
6554 * Initialize timers used by driver
6555 */
6559 /* FCF rediscover timer */
6562 /*
6563 * Control structure for handling external multi-buffer mailbox
6564 * command pass-through.
6565 */
6572 /* This will be set to correct value after the read_config mbox */
6575 /* Program the default value of vlan_id and fc_map */
6581 /*
6582 * For SLI4, instead of using ring 0 (LPFC_FCP_RING) for FCP commands
6583 * we will associate a new ring, for each EQ/CQ/WQ tuple.
6584 * The WQ create will allocate the ring.
6585 */
6587 /* Initialize buffer queue management fields */
6592 /*
6593 * Initialize the SLI Layer to run with lpfc SLI4 HBAs.
6594 */
6595 /* Initialize the Abort buffer list used by driver */
6600 /* Initialize the Abort nvme buffer list used by driver */
6606 }
6608 /* This abort list used by worker thread */
6614 /*
6615 * Initialize driver internal slow-path work queues
6616 */
6618 /* Driver internel slow-path CQ Event pool */
6620 /* Response IOCB work queue list */
6622 /* Asynchronous event CQ Event work queue list */
6624 /* Slow-path XRI aborted CQ Event work queue list */
6626 /* Receive queue CQ Event work queue list */
6629 /* Initialize extent block lists. */
6635 /* Initialize mboxq lists. If the early init routines fail
6636 * these lists need to be correctly initialized.
6637 */
6641 /* initialize optic_state to 0xFF */
6644 /* Allocate device driver memory */
6649 /* IF Type 2 ports get initialized now. */
6651 LPFC_SLI_INTF_IF_TYPE_2) {
6656 }
6658 }
6660 /* Create the bootstrap mailbox command */
6665 /* Set up the host's endian order with the device. */
6670 /* Set up the hba's configuration parameters. */
6678 /* IF Type 0 ports get initialized now. */
6680 LPFC_SLI_INTF_IF_TYPE_0) {
6684 }
6687 GFP_KERNEL);
6691 }
6693 /* Check for NVMET being configured */
6697 /* First get WWN of HBA instance */
6702 LOG_TRACE_EVENT,
6703 "6016 Mailbox failed , mbxCmd x%x "
6710 }
6718 /* wwn is WWPN of HBA instance */
6722 /* Check to see if it matches any module parameter */
6725 #if (IS_ENABLED(CONFIG_NVME_TARGET_FC))
6732 LOG_TRACE_EVENT,
6734 wwn);
6735 #else
6737 LOG_TRACE_EVENT,
6738 "6021 Can't enable NVME Target."
6739 " NVME_TARGET_FC infrastructure"
6741 #endif
6742 /* Not supported for NVMET */
6750 }
6752 }
6753 }
6754 }
6758 /* Get the Supported Pages if PORT_CAPABILITIES is supported by port. */
6764 LPFC_MAX_SUPPORTED_PAGES);
6772 }
6773 }
6774 /* Read the port's SLI4 Parameters capabilities if supported. */
6781 }
6782 }
6784 /*
6785 * Get sli4 parameters that override parameters from Port capabilities.
6786 * If this call fails, it isn't critical unless the SLI4 parameters come
6787 * back in conflict.
6788 */
6798 "2999 Unsupported SLI4 Parameters "
6805 }
6806 }
6812 }
6813 }
6815 /*
6816 * 1 for cmd, 1 for rsp, NVME adds an extra one
6817 * for boundary conditions in its max_sgl_segment template.
6818 */
6821 extra++;
6823 /*
6824 * It doesn't matter what family our adapter is in, we are
6825 * limited to 2 Pages, 512 SGEs, for our SGL.
6826 * There are going to be 2 reserved SGEs: 1 FCP cmnd + 1 FCP rsp
6827 */
6830 /*
6831 * Since lpfc_sg_seg_cnt is module param, the sg_dma_buf_size
6832 * used to create the sg_dma_buf_pool must be calculated.
6833 */
6835 /* Both cfg_enable_bg and cfg_external_dif code paths */
6837 /*
6838 * The scsi_buf for a T10-DIF I/O holds the FCP cmnd,
6839 * the FCP rsp, and a SGE. Sice we have no control
6840 * over how many protection segments the SCSI Layer
6841 * will hand us (ie: there could be one for every block
6842 * in the IO), just allocate enough SGEs to accomidate
6843 * our max amount and we need to limit lpfc_sg_seg_cnt
6844 * to minimize the risk of running out.
6845 */
6849 /* Total SGEs for scsi_sg_list and scsi_sg_prot_list */
6852 /*
6853 * If supporting DIF, reduce the seg count for scsi to
6854 * allow room for the DIF sges.
6855 */
6859 else
6863 /*
6864 * The scsi_buf for a regular I/O holds the FCP cmnd,
6865 * the FCP rsp, a SGE for each, and a SGE for up to
6866 * cfg_sg_seg_cnt data segments.
6867 */
6873 /* Total SGEs for scsi_sg_list */
6877 /*
6878 * NOTE: if (phba->cfg_sg_seg_cnt + extra) <= 256 we only
6879 * need to post 1 page for the SGL.
6880 */
6881 }
6887 else
6894 /* Limit to LPFC_MAX_NVME_SEG_CNT for NVME. */
6898 "6300 Reducing NVME sg segment "
6900 LPFC_MAX_NVME_SEG_CNT);
6904 }
6907 "9087 sg_seg_cnt:%d dmabuf_size:%d "
6915 else
6937 /* Verify OAS is supported */
6940 /* Verify RAS support on adapter */
6943 /* Verify all the SLI4 queues */
6948 /* Create driver internal CQE event pool */
6953 /* Initialize sgl lists per host */
6956 /* Allocate and initialize active sgl array */
6962 }
6968 }
6970 /* Allocate eligible FCF bmask memory for FCF roundrobin failover */
6973 GFP_KERNEL);
6976 "2759 Failed allocate memory for FCF round "
6980 }
6984 GFP_KERNEL);
6987 "2572 Failed allocate memory for "
6991 }
6995 GFP_KERNEL);
6998 "3327 Failed allocate memory for msi-x "
7002 }
7010 }
7014 GFP_KERNEL);
7020 }
7022 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
7029 }
7030 #endif
7032 /*
7033 * Enable sr-iov virtual functions if supported and configured
7034 * through the module parameter.
7035 */
7041 "3020 Requested number of SR-IOV "
7042 "virtual functions (%d) is not "
7046 }
7047 }
7051 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
7052 out_free_hba_idle_stat:
7054 #endif
7055 out_free_hba_eq_info:
7057 out_free_hba_cpu_map:
7059 out_free_hba_eq_hdl:
7061 out_free_fcf_rr_bmask:
7063 out_remove_rpi_hdrs:
7065 out_free_active_sgl:
7067 out_destroy_cq_event_pool:
7069 out_free_cmd_rsp_buf:
7072 out_free_sg_dma_buf:
7075 out_free_bsmbx:
7077 out_free_mem:
7080 }
7082 /**
7083 * lpfc_sli4_driver_resource_unset - Unset drvr internal resources for SLI4 dev
7084 * @phba: pointer to lpfc hba data structure.
7085 *
7086 * This routine is invoked to unset the driver internal resources set up
7087 * specific for supporting the SLI-4 HBA device it attached to.
7088 **/
7089 static void
7091 {
7095 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
7097 #endif
7100 /* Free memory allocated for msi-x interrupt vector to CPU mapping */
7107 /* Free memory allocated for fast-path work queue handles */
7110 /* Free the allocated rpi headers. */
7114 /* Free eligible FCF index bmask */
7117 /* Free the ELS sgl list */
7122 /* Free the completion queue EQ event pool */
7126 /* Release resource identifiers. */
7129 /* Free the bsmbx region. */
7132 /* Free the SLI Layer memory with SLI4 HBAs */
7135 /* Free the current connect table */
7140 }
7143 }
7145 /**
7146 * lpfc_init_api_table_setup - Set up init api function jump table
7147 * @phba: The hba struct for which this call is being executed.
7148 * @dev_grp: The HBA PCI-Device group number.
7149 *
7150 * This routine sets up the device INIT interface API function jump table
7151 * in @phba struct.
7152 *
7153 * Returns: 0 - success, -ENODEV - failure.
7154 **/
7155 int
7157 {
7175 dev_grp);
7177 }
7179 }
7181 /**
7182 * lpfc_setup_driver_resource_phase2 - Phase2 setup driver internal resources.
7183 * @phba: pointer to lpfc hba data structure.
7184 *
7185 * This routine is invoked to set up the driver internal resources after the
7186 * device specific resource setup to support the HBA device it attached to.
7187 *
7188 * Return codes
7189 * 0 - successful
7190 * other values - error
7191 **/
7192 static int
7194 {
7197 /* Startup the kernel thread for this host adapter. */
7203 }
7206 }
7208 /**
7209 * lpfc_unset_driver_resource_phase2 - Phase2 unset driver internal resources.
7210 * @phba: pointer to lpfc hba data structure.
7211 *
7212 * This routine is invoked to unset the driver internal resources set up after
7213 * the device specific resource setup for supporting the HBA device it
7214 * attached to.
7215 **/
7216 static void
7218 {
7223 }
7225 /* Stop kernel worker thread */
7228 }
7230 /**
7231 * lpfc_free_iocb_list - Free iocb list.
7232 * @phba: pointer to lpfc hba data structure.
7233 *
7234 * This routine is invoked to free the driver's IOCB list and memory.
7235 **/
7236 void
7238 {
7247 }
7251 }
7253 /**
7254 * lpfc_init_iocb_list - Allocate and initialize iocb list.
7255 * @phba: pointer to lpfc hba data structure.
7256 * @iocb_count: number of requested iocbs
7257 *
7258 * This routine is invoked to allocate and initizlize the driver's IOCB
7259 * list and set up the IOCB tag array accordingly.
7260 *
7261 * Return codes
7262 * 0 - successful
7263 * other values - error
7264 **/
7265 int
7267 {
7272 /* Initialize and populate the iocb list per host. */
7281 }
7289 }
7297 }
7301 out_free_iocbq:
7305 }
7307 /**
7308 * lpfc_free_sgl_list - Free a given sgl list.
7309 * @phba: pointer to lpfc hba data structure.
7310 * @sglq_list: pointer to the head of sgl list.
7311 *
7312 * This routine is invoked to free a give sgl list and memory.
7313 **/
7314 void
7316 {
7323 }
7324 }
7326 /**
7327 * lpfc_free_els_sgl_list - Free els sgl list.
7328 * @phba: pointer to lpfc hba data structure.
7329 *
7330 * This routine is invoked to free the driver's els sgl list and memory.
7331 **/
7332 static void
7334 {
7337 /* Retrieve all els sgls from driver list */
7344 /* Now free the sgl list */
7346 }
7348 /**
7349 * lpfc_free_nvmet_sgl_list - Free nvmet sgl list.
7350 * @phba: pointer to lpfc hba data structure.
7351 *
7352 * This routine is invoked to free the driver's nvmet sgl list and memory.
7353 **/
7354 static void
7356 {
7360 /* Retrieve all nvmet sgls from driver list */
7367 /* Now free the sgl list */
7372 }
7374 /* Update the nvmet_xri_cnt to reflect no current sgls.
7375 * The next initialization cycle sets the count and allocates
7376 * the sgls over again.
7377 */
7379 }
7381 /**
7382 * lpfc_init_active_sgl_array - Allocate the buf to track active ELS XRIs.
7383 * @phba: pointer to lpfc hba data structure.
7384 *
7385 * This routine is invoked to allocate the driver's active sgl memory.
7386 * This array will hold the sglq_entry's for active IOs.
7387 **/
7388 static int
7390 {
7400 }
7402 /**
7403 * lpfc_free_active_sgl - Free the buf that tracks active ELS XRIs.
7404 * @phba: pointer to lpfc hba data structure.
7405 *
7406 * This routine is invoked to walk through the array of active sglq entries
7407 * and free all of the resources.
7408 * This is just a place holder for now.
7409 **/
7410 static void
7412 {
7414 }
7416 /**
7417 * lpfc_init_sgl_list - Allocate and initialize sgl list.
7418 * @phba: pointer to lpfc hba data structure.
7419 *
7420 * This routine is invoked to allocate and initizlize the driver's sgl
7421 * list and set up the sgl xritag tag array accordingly.
7422 *
7423 **/
7424 static void
7426 {
7427 /* Initialize and populate the sglq list per host/VF. */
7433 /* els xri-sgl book keeping */
7436 /* nvme xri-buffer book keeping */
7438 }
7440 /**
7441 * lpfc_sli4_init_rpi_hdrs - Post the rpi header memory region to the port
7442 * @phba: pointer to lpfc hba data structure.
7443 *
7444 * This routine is invoked to post rpi header templates to the
7445 * port for those SLI4 ports that do not support extents. This routine
7446 * posts a PAGE_SIZE memory region to the port to hold up to
7447 * PAGE_SIZE modulo 64 rpi context headers. This is an initialization routine
7448 * and should be called only when interrupts are disabled.
7449 *
7450 * Return codes
7451 * 0 - successful
7452 * -ERROR - otherwise.
7453 **/
7454 int
7456 {
7472 }
7475 }
7477 /**
7478 * lpfc_sli4_create_rpi_hdr - Allocate an rpi header memory region
7479 * @phba: pointer to lpfc hba data structure.
7480 *
7481 * This routine is invoked to allocate a single 4KB memory region to
7482 * support rpis and stores them in the phba. This single region
7483 * provides support for up to 64 rpis. The region is used globally
7484 * by the device.
7485 *
7486 * Returns:
7487 * A valid rpi hdr on success.
7488 * A NULL pointer on any failure.
7489 **/
7492 {
7497 /*
7498 * If the SLI4 port supports extents, posting the rpi header isn't
7499 * required. Set the expected maximum count and let the actual value
7500 * get set when extents are fully allocated.
7501 */
7507 /* The limit on the logical index is just the max_rpi count. */
7511 /*
7512 * Establish the starting RPI in this header block. The starting
7513 * rpi is normalized to a zero base because the physical rpi is
7514 * port based.
7515 */
7519 /* Reached full RPI range */
7523 /*
7524 * First allocate the protocol header region for the port. The
7525 * port expects a 4KB DMA-mapped memory region that is 4K aligned.
7526 */
7532 LPFC_HDR_TEMPLATE_SIZE,
7537 }
7542 }
7544 /* Save the rpi header data for cleanup later. */
7554 /* The rpi_hdr stores the logical index only. */
7562 err_free_coherent:
7565 err_free_dmabuf:
7568 }
7570 /**
7571 * lpfc_sli4_remove_rpi_hdrs - Remove all rpi header memory regions
7572 * @phba: pointer to lpfc hba data structure.
7573 *
7574 * This routine is invoked to remove all memory resources allocated
7575 * to support rpis for SLI4 ports not supporting extents. This routine
7576 * presumes the caller has released all rpis consumed by fabric or port
7577 * logins and is prepared to have the header pages removed.
7578 **/
7579 void
7581 {
7594 }
7595 exit:
7596 /* There are no rpis available to the port now. */
7598 }
7600 /**
7601 * lpfc_hba_alloc - Allocate driver hba data structure for a device.
7602 * @pdev: pointer to pci device data structure.
7603 *
7604 * This routine is invoked to allocate the driver hba data structure for an
7605 * HBA device. If the allocation is successful, the phba reference to the
7606 * PCI device data structure is set.
7607 *
7608 * Return codes
7609 * pointer to @phba - successful
7610 * NULL - error
7611 **/
7614 {
7617 /* Allocate memory for HBA structure */
7622 }
7624 /* Set reference to PCI device in HBA structure */
7627 /* Assign an unused board number */
7632 }
7639 }
7641 /**
7642 * lpfc_hba_free - Free driver hba data structure with a device.
7643 * @phba: pointer to lpfc hba data structure.
7644 *
7645 * This routine is invoked to free the driver hba data structure with an
7646 * HBA device.
7647 **/
7648 static void
7650 {
7654 /* Release the driver assigned board number */
7657 /* Free memory allocated with sli3 rings */
7663 }
7665 /**
7666 * lpfc_create_shost - Create hba physical port with associated scsi host.
7667 * @phba: pointer to lpfc hba data structure.
7668 *
7669 * This routine is invoked to create HBA physical port and associate a SCSI
7670 * host with it.
7671 *
7672 * Return codes
7673 * 0 - successful
7674 * other values - error
7675 **/
7676 static int
7678 {
7682 /* Initialize HBA FC structure */
7697 /* Only 1 vport (pport) will support NVME target */
7702 }
7705 /* Put reference to SCSI host to driver's device private data */
7708 /*
7709 * At this point we are fully registered with PSA. In addition,
7710 * any initial discovery should be completed.
7711 */
7716 /* Setup appropriate attribute masks */
7720 else
7722 }
7724 }
7726 /**
7727 * lpfc_destroy_shost - Destroy hba physical port with associated scsi host.
7728 * @phba: pointer to lpfc hba data structure.
7729 *
7730 * This routine is invoked to destroy HBA physical port and the associated
7731 * SCSI host.
7732 **/
7733 static void
7735 {
7738 /* Destroy physical port that associated with the SCSI host */
7742 }
7744 /**
7745 * lpfc_setup_bg - Setup Block guard structures and debug areas.
7746 * @phba: pointer to lpfc hba data structure.
7747 * @shost: the shost to be used to detect Block guard settings.
7748 *
7749 * This routine sets up the local Block guard protocol settings for @shost.
7750 * This routine also allocates memory for debugging bg buffers.
7751 **/
7752 static void
7754 {
7760 "1478 Registering BlockGuard with the "
7766 /* Only allow supported values */
7768 SHOST_DIX_TYPE0_PROTECTION |
7769 SHOST_DIX_TYPE1_PROTECTION);
7771 SHOST_DIX_GUARD_CRC);
7773 /* DIF Type 1 protection for profiles AST1/C1 is end to end */
7781 "1475 Registering BlockGuard with the "
7790 "1479 Not Registering BlockGuard with the SCSI "
7793 }
7794 }
7796 /**
7797 * lpfc_post_init_setup - Perform necessary device post initialization setup.
7798 * @phba: pointer to lpfc hba data structure.
7799 *
7800 * This routine is invoked to perform all the necessary post initialization
7801 * setup for the device.
7802 **/
7803 static void
7805 {
7809 /* Get the default values for Model Name and Description */
7812 /*
7813 * hba setup may have changed the hba_queue_depth so we need to
7814 * adjust the value of can_queue.
7815 */
7825 }
7829 /* Send board arrival event to upper layer */
7835 LPFC_NL_VENDOR_ID);
7837 }
7839 /**
7840 * lpfc_sli_pci_mem_setup - Setup SLI3 HBA PCI memory space.
7841 * @phba: pointer to lpfc hba data structure.
7842 *
7843 * This routine is invoked to set up the PCI device memory space for device
7844 * with SLI-3 interface spec.
7845 *
7846 * Return codes
7847 * 0 - successful
7848 * other values - error
7849 **/
7850 static int
7852 {
7862 /* Set the device DMA mask size */
7870 /* Get the bus address of Bar0 and Bar2 and the number of bytes
7871 * required by each mapping.
7872 */
7879 /* Map HBA SLIM to a kernel virtual address. */
7885 }
7887 /* Map HBA Control Registers to a kernel virtual address. */
7893 }
7895 /* Allocate memory for SLI-2 structures */
7911 GFP_KERNEL);
7922 }
7936 out_free_slim:
7939 out_iounmap:
7941 out_iounmap_slim:
7943 out:
7945 }
7947 /**
7948 * lpfc_sli_pci_mem_unset - Unset SLI3 HBA PCI memory space.
7949 * @phba: pointer to lpfc hba data structure.
7950 *
7951 * This routine is invoked to unset the PCI device memory space for device
7952 * with SLI-3 interface spec.
7953 **/
7954 static void
7956 {
7959 /* Obtain PCI device reference */
7962 else
7965 /* Free coherent DMA memory allocated */
7971 /* I/O memory unmap */
7976 }
7978 /**
7979 * lpfc_sli4_post_status_check - Wait for SLI4 POST done and check status
7980 * @phba: pointer to lpfc hba data structure.
7981 *
7982 * This routine is invoked to wait for SLI4 device Power On Self Test (POST)
7983 * done and check status.
7984 *
7985 * Return 0 if successful, otherwise -ENODEV.
7986 **/
7987 int
7989 {
8000 /* Wait up to 30 seconds for the SLI Port POST done and ready */
8005 /* Port has a fatal POST error, break out */
8008 }
8013 }
8015 /*
8016 * If there was a port error during POST, then don't proceed with
8017 * other register reads as the data may not be valid. Just exit.
8018 */
8021 "1408 Port Failed POST - portsmphr=0x%x, "
8022 "perr=x%x, sfi=x%x, nip=x%x, ipc=x%x, scr1=x%x, "
8035 "2534 Device Info: SLIFamily=0x%x, "
8036 "SLIRev=0x%x, IFType=0x%x, SLIHint_1=0x%x, "
8050 /*
8051 * Check for other Port errors during the initialization
8052 * process. Fail the load if the port did not come up
8053 * correctly.
8054 */
8070 LOG_TRACE_EVENT,
8071 "1422 Unrecoverable Error "
8072 "Detected during POST "
8073 "uerr_lo_reg=0x%x, "
8074 "uerr_hi_reg=0x%x, "
8075 "ue_mask_lo_reg=0x%x, "
8082 }
8086 /* Final checks. The port status should be clean. */
8093 ERR1regaddr);
8096 ERR2regaddr);
8098 "2888 Unrecoverable port error "
8099 "following POST: port status reg "
8100 "0x%x, port_smphr reg 0x%x, "
8107 }
8112 }
8113 }
8115 }
8117 /**
8118 * lpfc_sli4_bar0_register_memmap - Set up SLI4 BAR0 register memory map.
8119 * @phba: pointer to lpfc hba data structure.
8120 * @if_type: The SLI4 interface type getting configured.
8121 *
8122 * This routine is invoked to set up SLI4 BAR0 PCI config space register
8123 * memory map.
8124 **/
8125 static void
8127 {
8144 LPFC_CTL_PORT_EQ_DELAY_OFFSET;
8147 LPFC_CTL_PORT_ER1_OFFSET;
8150 LPFC_CTL_PORT_ER2_OFFSET;
8153 LPFC_CTL_PORT_CTL_OFFSET;
8156 LPFC_CTL_PORT_STA_OFFSET;
8161 LPFC_CTL_PORT_SEM_OFFSET;
8164 LPFC_ULP0_RQ_DOORBELL;
8167 LPFC_ULP0_WQ_DOORBELL;
8179 LPFC_CTL_PORT_EQ_DELAY_OFFSET;
8182 LPFC_CTL_PORT_ER1_OFFSET;
8185 LPFC_CTL_PORT_ER2_OFFSET;
8188 LPFC_CTL_PORT_CTL_OFFSET;
8191 LPFC_CTL_PORT_STA_OFFSET;
8194 LPFC_CTL_PORT_SEM_OFFSET;
8202 if_type);
8204 }
8205 }
8207 /**
8208 * lpfc_sli4_bar1_register_memmap - Set up SLI4 BAR1 register memory map.
8209 * @phba: pointer to lpfc hba data structure.
8210 * @if_type: sli if type to operate on.
8211 *
8212 * This routine is invoked to set up SLI4 BAR1 register memory map.
8213 **/
8214 static void
8216 {
8221 LPFC_SLIPORT_IF0_SMPHR;
8223 LPFC_HST_ISR0;
8225 LPFC_HST_IMR0;
8227 LPFC_HST_ISCR0;
8231 LPFC_IF6_RQ_DOORBELL;
8233 LPFC_IF6_WQ_DOORBELL;
8235 LPFC_IF6_CQ_DOORBELL;
8237 LPFC_IF6_EQ_DOORBELL;
8239 LPFC_IF6_MQ_DOORBELL;
8246 if_type);
8248 }
8249 }
8251 /**
8252 * lpfc_sli4_bar2_register_memmap - Set up SLI4 BAR2 register memory map.
8253 * @phba: pointer to lpfc hba data structure.
8254 * @vf: virtual function number
8255 *
8256 * This routine is invoked to set up SLI4 BAR2 doorbell register memory map
8257 * based on the given viftual function number, @vf.
8258 *
8259 * Return 0 if successful, otherwise -ENODEV.
8260 **/
8261 static int
8263 {
8269 LPFC_ULP0_RQ_DOORBELL);
8272 LPFC_ULP0_WQ_DOORBELL);
8275 LPFC_EQCQ_DOORBELL);
8282 }
8284 /**
8285 * lpfc_create_bootstrap_mbox - Create the bootstrap mailbox
8286 * @phba: pointer to lpfc hba data structure.
8287 *
8288 * This routine is invoked to create the bootstrap mailbox
8289 * region consistent with the SLI-4 interface spec. This
8290 * routine allocates all memory necessary to communicate
8291 * mailbox commands to the port and sets up all alignment
8292 * needs. No locks are expected to be held when calling
8293 * this routine.
8294 *
8295 * Return codes
8296 * 0 - successful
8297 * -ENOMEM - could not allocated memory.
8298 **/
8299 static int
8301 {
8312 /*
8313 * The bootstrap mailbox region is comprised of 2 parts
8314 * plus an alignment restriction of 16 bytes.
8315 */
8322 }
8324 /*
8325 * Initialize the bootstrap mailbox pointers now so that the register
8326 * operations are simple later. The mailbox dma address is required
8327 * to be 16-byte aligned. Also align the virtual memory as each
8328 * maibox is copied into the bmbx mailbox region before issuing the
8329 * command to the port.
8330 */
8335 LPFC_ALIGN_16_BYTE);
8337 LPFC_ALIGN_16_BYTE);
8339 /*
8340 * Set the high and low physical addresses now. The SLI4 alignment
8341 * requirement is 16 bytes and the mailbox is posted to the port
8342 * as two 30-bit addresses. The other data is a bit marking whether
8343 * the 30-bit address is the high or low address.
8344 * Upcast bmbx aphys to 64bits so shift instruction compiles
8345 * clean on 32 bit machines.
8346 */
8351 LPFC_BMBX_BIT1_ADDR_HI);
8355 LPFC_BMBX_BIT1_ADDR_LO);
8357 }
8359 /**
8360 * lpfc_destroy_bootstrap_mbox - Destroy all bootstrap mailbox resources
8361 * @phba: pointer to lpfc hba data structure.
8362 *
8363 * This routine is invoked to teardown the bootstrap mailbox
8364 * region and release all host resources. This routine requires
8365 * the caller to ensure all mailbox commands recovered, no
8366 * additional mailbox comands are sent, and interrupts are disabled
8367 * before calling this routine.
8368 *
8369 **/
8370 static void
8372 {
8380 }
8390 };
8392 #define LINK_FLAGS_DEF 0x0
8393 #define LINK_FLAGS_P2P 0x1
8394 #define LINK_FLAGS_LOOP 0x2
8395 /**
8396 * lpfc_map_topology - Map the topology read from READ_CONFIG
8397 * @phba: pointer to lpfc hba data structure.
8398 * @rd_config: pointer to read config data
8399 *
8400 * This routine is invoked to map the topology values as read
8401 * from the read config mailbox command. If the persistent
8402 * topology feature is supported, the firmware will provide the
8403 * saved topology information to be used in INIT_LINK
8404 **/
8405 static void
8407 {
8419 "2019 FW does not support persistent topology "
8423 }
8424 /* FW supports persistent topology - override module parameter value */
8431 ? FLAGS_TOPOLOGY_MODE_LOOP
8435 }
8439 /* If topology failover set - pt is '0' or '1' */
8441 FLAGS_TOPOLOGY_MODE_LOOP_PT);
8444 ? FLAGS_TOPOLOGY_MODE_PT_PT
8446 }
8448 }
8455 "2021 Invalid topology values from FW "
8458 }
8459 }
8461 /**
8462 * lpfc_sli4_read_config - Get the config parameters.
8463 * @phba: pointer to lpfc hba data structure.
8464 *
8465 * This routine is invoked to read the configuration parameters from the HBA.
8466 * The configuration parameters are used to set the base and maximum values
8467 * for RPI's XRI's VPI's VFI's and FCFIs. These values also affect the resource
8468 * allocation for the port.
8469 *
8470 * Return codes
8471 * 0 - successful
8472 * -ENOMEM - No available memory
8473 * -EIO - The mailbox failed to complete successfully.
8474 **/
8475 int
8477 {
8492 "2011 Unable to allocate memory for issuing "
8495 }
8502 "2012 Mailbox failed , mbxCmd x%x "
8526 }
8534 /* Reduce resource usage in kdump environment */
8542 /* Limit the max we support */
8574 "2003 cfg params Extents? %d "
8575 "XRI(B:%d M:%d), "
8576 "VPI(B:%d M:%d) "
8577 "VFI(B:%d M:%d) "
8578 "RPI(B:%d M:%d) "
8596 /*
8597 * Calculate queue resources based on how
8598 * many WQ/CQ/EQs are available.
8599 */
8605 /*
8606 * Whats left after this can go toward NVME / FCP.
8607 * The minus 4 accounts for ELS, NVME LS, MBOX
8608 * plus one extra. When configured for
8609 * NVMET, FCP io channel WQs are not created.
8610 */
8613 /* Check to see if there is enough for NVME */
8617 "2005 Reducing Queues - "
8618 "FW resource limitation: "
8619 "WQ %d CQ %d EQ %d: min %d: "
8631 }
8632 }
8637 /* Update link speed if forced link speed is supported */
8640 forced_link_speed =
8648 LPFC_USER_LINK_SPEED_1G;
8652 LPFC_USER_LINK_SPEED_2G;
8656 LPFC_USER_LINK_SPEED_4G;
8660 LPFC_USER_LINK_SPEED_8G;
8664 LPFC_USER_LINK_SPEED_10G;
8668 LPFC_USER_LINK_SPEED_16G;
8672 LPFC_USER_LINK_SPEED_32G;
8676 LPFC_USER_LINK_SPEED_64G;
8680 LPFC_USER_LINK_SPEED_AUTO;
8684 LOG_TRACE_EVENT,
8685 "0047 Unrecognized link "
8687 forced_link_speed);
8689 LPFC_USER_LINK_SPEED_AUTO;
8690 }
8691 }
8692 }
8694 /* Reset the DFT_HBA_Q_DEPTH to the max xri */
8702 }
8705 LPFC_SLI_INTF_IF_TYPE_2)
8708 /* get the pf# and vf# for SLI4 if_type 2 port */
8712 LPFC_MBOX_OPCODE_GET_FUNCTION_CONFIG,
8722 "3026 Mailbox failed , mbxCmd x%x "
8727 }
8729 /* search for fc_fcoe resrouce descriptor */
8749 }
8750 }
8754 "3027 GET_FUNCTION_CONFIG: pf_number:%d, "
8757 else
8759 "3028 GET_FUNCTION_CONFIG: failed to find "
8761 LPFC_RSRC_DESC_TYPE_FCFCOE);
8763 read_cfg_out:
8766 }
8768 /**
8769 * lpfc_setup_endian_order - Write endian order to an SLI4 if_type 0 port.
8770 * @phba: pointer to lpfc hba data structure.
8771 *
8772 * This routine is invoked to setup the port-side endian order when
8773 * the port if_type is 0. This routine has no function for other
8774 * if_types.
8775 *
8776 * Return codes
8777 * 0 - successful
8778 * -ENOMEM - No available memory
8779 * -EIO - The mailbox failed to complete successfully.
8780 **/
8781 static int
8783 {
8787 HOST_ENDIAN_HIGH_WORD1};
8793 GFP_KERNEL);
8796 "0492 Unable to allocate memory for "
8797 "issuing SLI_CONFIG_SPECIAL mailbox "
8800 }
8802 /*
8803 * The SLI4_CONFIG_SPECIAL mailbox command requires the first
8804 * two words to contain special data values and no other data.
8805 */
8811 "0493 SLI_CONFIG_SPECIAL mailbox "
8813 rc);
8815 }
8823 }
8825 }
8827 /**
8828 * lpfc_sli4_queue_verify - Verify and update EQ counts
8829 * @phba: pointer to lpfc hba data structure.
8830 *
8831 * This routine is invoked to check the user settable queue counts for EQs.
8832 * After this routine is called the counts will be set to valid values that
8833 * adhere to the constraints of the system's interrupt vectors and the port's
8834 * queue resources.
8835 *
8836 * Return codes
8837 * 0 - successful
8838 * -ENOMEM - No available memory
8839 **/
8840 static int
8842 {
8843 /*
8844 * Sanity check for configured queue parameters against the run-time
8845 * device parameters
8846 */
8853 }
8860 /* Get EQ depth from module parameter, fake the default for now */
8864 /* Get CQ depth from module parameter, fake the default for now */
8868 }
8870 static int
8872 {
8874 u32 wqesize;
8878 /* Create Fast Path IO CQs */
8880 /* Increase the CQ size when WQEs contain an embedded cdb */
8885 else
8892 idx);
8894 }
8900 /* Create Fast Path IO WQs */
8902 /* Increase the WQ size when WQEs contain an embedded cdb */
8906 wqesize,
8916 idx);
8918 }
8924 }
8926 /**
8927 * lpfc_sli4_queue_create - Create all the SLI4 queues
8928 * @phba: pointer to lpfc hba data structure.
8929 *
8930 * This routine is invoked to allocate all the SLI4 queues for the FCoE HBA
8931 * operation. For each SLI4 queue type, the parameters such as queue entry
8932 * count (queue depth) shall be taken from the module parameter. For now,
8933 * we just use some constant number as place holder.
8934 *
8935 * Return codes
8936 * 0 - successful
8937 * -ENOMEM - No availble memory
8938 * -EIO - The mailbox failed to complete successfully.
8939 **/
8940 int
8942 {
8950 /*
8951 * Create HBA Record arrays.
8952 * Both NVME and FCP will share that same vectors / EQs
8953 */
8968 GFP_KERNEL);
8971 "6427 Failed allocate memory for "
8974 }
8975 /* Prepare hardware queues to take IO buffers */
8992 }
8993 }
9000 GFP_KERNEL);
9003 "3121 Fail allocate memory for "
9006 }
9010 GFP_KERNEL);
9013 "3122 Fail allocate memory for "
9016 }
9020 GFP_KERNEL);
9023 "3124 Fail allocate memory for "
9026 }
9027 }
9028 }
9032 /* Create HBA Event Queues (EQs) */
9034 /* We only want to create 1 EQ per vector, even though
9035 * multiple CPUs might be using that vector. so only
9036 * selects the CPUs that are LPFC_CPU_FIRST_IRQ.
9037 */
9042 /* Get a ptr to the Hardware Queue associated with this CPU */
9045 /* Allocate an EQ */
9054 }
9060 /* Save the allocated EQ in the Hardware Queue */
9065 }
9067 /* Now we need to populate the other Hardware Queues, that share
9068 * an IRQ vector, with the associated EQ ptr.
9069 */
9073 /* Check for EQ already allocated in previous loop */
9077 /* Check for multiple CPUs per hdwq */
9082 /* We need to share an EQ for this hdwq */
9086 }
9088 /* Allocate IO Path SLI4 CQ/WQs */
9092 }
9097 LPFC_FIND_BY_HDWQ);
9099 LPFC_DEFAULT_PAGE_SIZE,
9102 cpu);
9105 "3142 Failed allocate NVME "
9108 }
9113 }
9114 }
9116 /*
9117 * Create Slow Path Completion Queues (CQs)
9118 */
9121 /* Create slow-path Mailbox Command Complete Queue */
9129 }
9133 /* Create slow-path ELS Complete Queue */
9141 }
9147 /*
9148 * Create Slow Path Work Queues (WQs)
9149 */
9151 /* Create Mailbox Command Queue */
9160 }
9164 /*
9165 * Create ELS Work Queues
9166 */
9168 /* Create slow-path ELS Work Queue */
9176 }
9182 /* Create NVME LS Complete Queue */
9190 }
9195 /* Create NVME LS Work Queue */
9203 }
9207 }
9209 /*
9210 * Create Receive Queue (RQ)
9211 */
9213 /* Create Receive Queue for header */
9221 }
9224 /* Create Receive Queue for data */
9232 }
9239 LPFC_FIND_BY_HDWQ);
9240 /* Create NVMET Receive Queue for header */
9242 LPFC_DEFAULT_PAGE_SIZE,
9244 LPFC_NVMET_RQE_DEF_COUNT,
9245 cpu);
9248 "3146 Failed allocate "
9251 }
9255 /* Only needed for header of RQ pair */
9257 GFP_KERNEL,
9261 "6131 Failed allocate "
9264 }
9266 /* Put list in known state in case driver load fails. */
9269 /* Create NVMET Receive Queue for data */
9271 LPFC_DEFAULT_PAGE_SIZE,
9273 LPFC_NVMET_RQE_DEF_COUNT,
9274 cpu);
9277 "3156 Failed allocate "
9280 }
9283 }
9284 }
9286 /* Clear NVME stats */
9291 }
9292 }
9294 /* Clear SCSI stats */
9299 }
9300 }
9304 out_error:
9307 }
9311 {
9315 }
9316 }
9320 {
9331 }
9335 {
9342 /* Loop thru all Hardware Queues */
9344 /* Free the CQ/WQ corresponding to the Hardware Queue */
9353 }
9354 /* Loop thru all IRQ vectors */
9356 /* Free the EQ corresponding to the IRQ vector */
9360 }
9361 }
9363 /**
9364 * lpfc_sli4_queue_destroy - Destroy all the SLI4 queues
9365 * @phba: pointer to lpfc hba data structure.
9366 *
9367 * This routine is invoked to release all the SLI4 queues with the FCoE HBA
9368 * operation.
9369 *
9370 * Return codes
9371 * 0 - successful
9372 * -ENOMEM - No available memory
9373 * -EIO - The mailbox failed to complete successfully.
9374 **/
9375 void
9377 {
9378 /*
9379 * Set FREE_INIT before beginning to free the queues.
9380 * Wait until the users of queues to acknowledge to
9381 * release queues by clearing FREE_WAIT.
9382 */
9389 }
9394 /* Release HBA eqs */
9406 }
9408 /* Release mailbox command work queue */
9411 /* Release ELS work queue */
9414 /* Release ELS work queue */
9417 /* Release unsolicited receive queue */
9421 /* Release ELS complete queue */
9424 /* Release NVME LS complete queue */
9427 /* Release mailbox command complete queue */
9430 /* Everything on this list has been freed */
9433 /* Done with freeing the queues */
9437 }
9439 int
9441 {
9454 }
9456 }
9458 static int
9462 {
9471 }
9473 /* create the Cq first */
9481 }
9484 /* Setup cq_map for fast lookup */
9492 /* create the wq */
9498 /* no need to tear down cq - caller will do so */
9500 }
9502 /* Bind this CQ/WQ to the NVME ring */
9514 "0539 Failed setup of slow-path MQ: "
9516 /* no need to tear down cq - caller will do so */
9518 }
9524 }
9527 }
9529 /**
9530 * lpfc_setup_cq_lookup - Setup the CQ lookup table
9531 * @phba: pointer to lpfc hba data structure.
9532 *
9533 * This routine will populate the cq_lookup table by all
9534 * available CQ queue_id's.
9535 **/
9536 static void
9538 {
9544 /* Loop thru all IRQ vectors */
9546 /* Get the EQ corresponding to the IRQ vector */
9550 /* Loop through all CQs associated with that EQ */
9556 childq;
9557 }
9558 }
9559 }
9561 /**
9562 * lpfc_sli4_queue_setup - Set up all the SLI4 queues
9563 * @phba: pointer to lpfc hba data structure.
9564 *
9565 * This routine is invoked to set up all the SLI4 queues for the FCoE HBA
9566 * operation.
9567 *
9568 * Return codes
9569 * 0 - successful
9570 * -ENOMEM - No available memory
9571 * -EIO - The mailbox failed to complete successfully.
9572 **/
9573 int
9575 {
9585 /* Check for dual-ULP support */
9589 "3249 Unable to allocate memory for "
9592 }
9596 LPFC_MBOX_OPCODE_QUERY_FW_CFG,
9607 "3250 QUERY_FW_CFG mailbox failed with status "
9614 }
9623 "3251 QUERY_FW_CFG: func_mode:x%x, ulp0_mode:x%x, "
9630 /*
9631 * Set up HBA Event Queues (EQs)
9632 */
9635 /* Set up HBA event queue */
9641 }
9643 /* Loop thru all IRQ vectors */
9645 /* Create HBA Event Queues (EQs) in order */
9649 /* Look for the CPU thats using that vector with
9650 * LPFC_CPU_FIRST_IRQ set.
9651 */
9657 /* Create an EQ for that vector */
9662 "0523 Failed setup of fast-path"
9666 }
9668 /* Save the EQ for that vector in the hba_eq_hdl */
9676 }
9677 }
9679 /* Loop thru all Hardware Queues */
9684 /* Create the CQ/WQ corresponding to the Hardware Queue */
9690 qidx,
9691 LPFC_IO);
9694 "0535 Failed to setup fastpath "
9698 }
9699 }
9701 /*
9702 * Set up Slow Path Complete Queues (CQs)
9703 */
9705 /* Set up slow-path MBOX CQ/MQ */
9714 }
9725 }
9729 "3165 Fast-path NVME CQ Set "
9733 }
9737 qp,
9741 "3164 Failed setup of NVME CQ "
9745 }
9747 /* Set up NVMET Receive Complete Queue */
9753 "6089 Failed setup NVMET CQ: "
9756 }
9760 "6090 NVMET CQ setup: cq-id=%d, "
9764 }
9765 }
9767 /* Set up slow-path ELS WQ/CQ */
9774 }
9784 }
9791 /* Set up NVME LS Complete Queue */
9798 }
9805 "0526 Failed setup of NVVME LS WQ/CQ: "
9808 }
9811 "6096 ELS WQ setup: wq-id=%d, "
9815 }
9817 /*
9818 * Create NVMET Receive Queue (RQ)
9819 */
9825 "6130 MRQ CQ Queues not "
9829 }
9835 LPFC_NVMET);
9838 "6098 Failed setup of NVMET "
9842 }
9849 LPFC_NVMET);
9852 "6057 Failed setup of NVMET "
9856 }
9860 "6099 NVMET RQ setup: hdr-rq-id=%d, "
9866 }
9867 }
9874 }
9880 "0541 Failed setup of Receive Queue: "
9883 }
9886 "2592 USL RQ setup: hdr-rq-id=%d, dat-rq-id=%d "
9894 else
9900 usdelay);
9908 "0549 Failed setup of CQ Lookup table: "
9912 }
9914 }
9917 out_destroy:
9919 out_error:
9921 }
9923 /**
9924 * lpfc_sli4_queue_unset - Unset all the SLI4 queues
9925 * @phba: pointer to lpfc hba data structure.
9926 *
9927 * This routine is invoked to unset all the SLI4 queues with the FCoE HBA
9928 * operation.
9929 *
9930 * Return codes
9931 * 0 - successful
9932 * -ENOMEM - No available memory
9933 * -EIO - The mailbox failed to complete successfully.
9934 **/
9935 void
9937 {
9942 /* Unset mailbox command work queue */
9946 /* Unset NVME LS work queue */
9950 /* Unset ELS work queue */
9954 /* Unset unsolicited receive queue */
9959 /* Unset mailbox command complete queue */
9963 /* Unset ELS complete queue */
9967 /* Unset NVME LS complete queue */
9972 /* Unset NVMET MRQ queue */
9976 phba,
9979 }
9981 /* Unset NVMET CQ Set complete queue */
9986 }
9987 }
9989 /* Unset fast-path SLI4 queues */
9991 /* Loop thru all Hardware Queues */
9993 /* Destroy the CQ/WQ corresponding to Hardware Queue */
9997 }
9998 /* Loop thru all IRQ vectors */
10000 /* Destroy the EQ corresponding to the IRQ vector */
10003 }
10004 }
10009 }
10011 /**
10012 * lpfc_sli4_cq_event_pool_create - Create completion-queue event free pool
10013 * @phba: pointer to lpfc hba data structure.
10014 *
10015 * This routine is invoked to allocate and set up a pool of completion queue
10016 * events. The body of the completion queue event is a completion queue entry
10017 * CQE. For now, this pool is used for the interrupt service routine to queue
10018 * the following HBA completion queue events for the worker thread to process:
10019 * - Mailbox asynchronous events
10020 * - Receive queue completion unsolicited events
10021 * Later, this can be used for all the slow-path events.
10022 *
10023 * Return codes
10024 * 0 - successful
10025 * -ENOMEM - No available memory
10026 **/
10027 static int
10029 {
10039 }
10042 out_pool_create_fail:
10045 }
10047 /**
10048 * lpfc_sli4_cq_event_pool_destroy - Free completion-queue event free pool
10049 * @phba: pointer to lpfc hba data structure.
10050 *
10051 * This routine is invoked to free the pool of completion queue events at
10052 * driver unload time. Note that, it is the responsibility of the driver
10053 * cleanup routine to free all the outstanding completion-queue events
10054 * allocated from this pool back into the pool before invoking this routine
10055 * to destroy the pool.
10056 **/
10057 static void
10059 {
10066 }
10067 }
10069 /**
10070 * __lpfc_sli4_cq_event_alloc - Allocate a completion-queue event from free pool
10071 * @phba: pointer to lpfc hba data structure.
10072 *
10073 * This routine is the lock free version of the API invoked to allocate a
10074 * completion-queue event from the free pool.
10075 *
10076 * Return: Pointer to the newly allocated completion-queue event if successful
10077 * NULL otherwise.
10078 **/
10081 {
10087 }
10089 /**
10090 * lpfc_sli4_cq_event_alloc - Allocate a completion-queue event from free pool
10091 * @phba: pointer to lpfc hba data structure.
10092 *
10093 * This routine is the lock version of the API invoked to allocate a
10094 * completion-queue event from the free pool.
10095 *
10096 * Return: Pointer to the newly allocated completion-queue event if successful
10097 * NULL otherwise.
10098 **/
10101 {
10109 }
10111 /**
10112 * __lpfc_sli4_cq_event_release - Release a completion-queue event to free pool
10113 * @phba: pointer to lpfc hba data structure.
10114 * @cq_event: pointer to the completion queue event to be freed.
10115 *
10116 * This routine is the lock free version of the API invoked to release a
10117 * completion-queue event back into the free pool.
10118 **/
10119 void
10122 {
10124 }
10126 /**
10127 * lpfc_sli4_cq_event_release - Release a completion-queue event to free pool
10128 * @phba: pointer to lpfc hba data structure.
10129 * @cq_event: pointer to the completion queue event to be freed.
10130 *
10131 * This routine is the lock version of the API invoked to release a
10132 * completion-queue event back into the free pool.
10133 **/
10134 void
10137 {
10142 }
10144 /**
10145 * lpfc_sli4_cq_event_release_all - Release all cq events to the free pool
10146 * @phba: pointer to lpfc hba data structure.
10147 *
10148 * This routine is to free all the pending completion-queue events to the
10149 * back into the free pool for device reset.
10150 **/
10151 static void
10153 {
10158 /* Retrieve all the pending WCQEs from pending WCQE lists */
10160 /* Pending ELS XRI abort events */
10166 /* Pending asynnc events */
10176 }
10177 }
10179 /**
10180 * lpfc_pci_function_reset - Reset pci function.
10181 * @phba: pointer to lpfc hba data structure.
10182 *
10183 * This routine is invoked to request a PCI function reset. It will destroys
10184 * all resources assigned to the PCI function which originates this request.
10185 *
10186 * Return codes
10187 * 0 - successful
10188 * -ENOMEM - No available memory
10189 * -EIO - The mailbox failed to complete successfully.
10190 **/
10191 int
10193 {
10207 GFP_KERNEL);
10210 "0494 Unable to allocate memory for "
10211 "issuing SLI_FUNCTION_RESET mailbox "
10214 }
10216 /* Setup PCI function reset mailbox-ioctl command */
10219 LPFC_SLI4_MBX_EMBED);
10230 "0495 SLI_FUNCTION_RESET mailbox "
10231 "failed with status x%x add_status x%x,"
10235 }
10239 wait:
10240 /*
10241 * Poll the Port Status Register and wait for RDY for
10242 * up to 30 seconds. If the port doesn't respond, treat
10243 * it as an error.
10244 */
10250 }
10254 }
10262 "2890 Port not ready, port status reg "
10269 }
10272 /*
10273 * Reset the port now
10274 */
10277 LPFC_SLIPORT_LITTLE_ENDIAN);
10279 LPFC_SLIPORT_INIT_PORT);
10281 CTRLregaddr);
10282 /* flush */
10292 }
10298 }
10300 out:
10301 /* Catch the not-ready port failure after a port reset. */
10304 "3317 HBA not functional: IP Reset Failed "
10307 }
10310 }
10312 /**
10313 * lpfc_sli4_pci_mem_setup - Setup SLI4 HBA PCI memory space.
10314 * @phba: pointer to lpfc hba data structure.
10315 *
10316 * This routine is invoked to set up the PCI device memory space for device
10317 * with SLI-4 interface spec.
10318 *
10319 * Return codes
10320 * 0 - successful
10321 * other values - error
10322 **/
10323 static int
10325 {
10334 /* Set the device DMA mask size */
10341 /*
10342 * The BARs and register set definitions and offset locations are
10343 * dependent on the if_type.
10344 */
10348 }
10350 /* There is no SLI3 failback for SLI4 devices. */
10352 LPFC_SLI_INTF_VALID) {
10354 "2894 SLI_INTF reg contents invalid "
10358 }
10361 /*
10362 * Get the bus address of SLI4 device Bar regions and the
10363 * number of bytes required by each mapping. The mapping of the
10364 * particular PCI BARs regions is dependent on the type of
10365 * SLI4 device.
10366 */
10371 /*
10372 * Map SLI4 PCI Config Space Register base to a kernel virtual
10373 * addr
10374 */
10379 "ioremap failed for SLI4 PCI config "
10382 }
10384 /* Set up BAR0 PCI config space register memory map */
10393 }
10398 "ioremap failed for SLI4 PCI config "
10401 }
10403 }
10407 /*
10408 * Map SLI4 if type 0 HBA Control Register base to a
10409 * kernel virtual address and setup the registers.
10410 */
10412 PCI_64BIT_BAR2);
10416 bar1map_len);
10419 "ioremap failed for SLI4 HBA "
10423 }
10430 }
10431 }
10435 /*
10436 * Map SLI4 if type 6 HBA Doorbell Register base to a kernel
10437 * virtual address and setup the registers.
10438 */
10448 }
10451 }
10455 /*
10456 * Map SLI4 if type 0 HBA Doorbell Register base to
10457 * a kernel virtual address and setup the registers.
10458 */
10460 PCI_64BIT_BAR4);
10464 bar2map_len);
10467 "ioremap failed for SLI4 HBA"
10471 }
10480 }
10481 }
10485 /*
10486 * Map SLI4 if type 6 HBA DPP Register base to a kernel
10487 * virtual address and setup the registers.
10488 */
10498 }
10500 }
10502 /* Set up the EQ/CQ register handeling functions now */
10517 }
10521 out_iounmap_all:
10523 out_iounmap_ctrl:
10525 out_iounmap_conf:
10529 }
10531 /**
10532 * lpfc_sli4_pci_mem_unset - Unset SLI4 HBA PCI memory space.
10533 * @phba: pointer to lpfc hba data structure.
10534 *
10535 * This routine is invoked to unset the PCI device memory space for device
10536 * with SLI-4 interface spec.
10537 **/
10538 static void
10540 {
10563 if_type);
10565 }
10566 }
10568 /**
10569 * lpfc_sli_enable_msix - Enable MSI-X interrupt mode on SLI-3 device
10570 * @phba: pointer to lpfc hba data structure.
10571 *
10572 * This routine is invoked to enable the MSI-X interrupt vectors to device
10573 * with SLI-3 interface specs.
10574 *
10575 * Return codes
10576 * 0 - successful
10577 * other values - error
10578 **/
10579 static int
10581 {
10585 /* Set up MSI-X multi-message vectors */
10592 }
10594 /*
10595 * Assign MSI-X vectors to interrupt handlers
10596 */
10598 /* vector-0 is associated to slow-path handler */
10604 "0421 MSI-X slow-path request_irq failed "
10607 }
10609 /* vector-1 is associated to fast-path handler */
10616 "0429 MSI-X fast-path request_irq failed "
10619 }
10621 /*
10622 * Configure HBA MSI-X attention conditions to messages
10623 */
10629 "0474 Unable to allocate memory for issuing "
10632 }
10639 "0351 Config MSI mailbox command failed, "
10643 }
10645 /* Free memory allocated for mailbox command */
10649 mbx_fail_out:
10650 /* Free memory allocated for mailbox command */
10653 mem_fail_out:
10654 /* free the irq already requested */
10657 irq_fail_out:
10658 /* free the irq already requested */
10661 msi_fail_out:
10662 /* Unconfigure MSI-X capability structure */
10665 vec_fail_out:
10667 }
10669 /**
10670 * lpfc_sli_enable_msi - Enable MSI interrupt mode on SLI-3 device.
10671 * @phba: pointer to lpfc hba data structure.
10672 *
10673 * This routine is invoked to enable the MSI interrupt mode to device with
10674 * SLI-3 interface spec. The kernel function pci_enable_msi() is called to
10675 * enable the MSI vector. The device driver is responsible for calling the
10676 * request_irq() to register MSI vector with a interrupt the handler, which
10677 * is done in this function.
10678 *
10679 * Return codes
10680 * 0 - successful
10681 * other values - error
10682 */
10683 static int
10685 {
10696 }
10704 }
10706 }
10708 /**
10709 * lpfc_sli_enable_intr - Enable device interrupt to SLI-3 device.
10710 * @phba: pointer to lpfc hba data structure.
10711 * @cfg_mode: Interrupt configuration mode (INTx, MSI or MSI-X).
10712 *
10713 * This routine is invoked to enable device interrupt and associate driver's
10714 * interrupt handler(s) to interrupt vector(s) to device with SLI-3 interface
10715 * spec. Depends on the interrupt mode configured to the driver, the driver
10716 * will try to fallback from the configured interrupt mode to an interrupt
10717 * mode which is supported by the platform, kernel, and device in the order
10718 * of:
10719 * MSI-X -> MSI -> IRQ.
10720 *
10721 * Return codes
10722 * 0 - successful
10723 * other values - error
10724 **/
10725 static uint32_t
10727 {
10732 /* Need to issue conf_port mbox cmd before conf_msi mbox cmd */
10735 /* Now, try to enable MSI-X interrupt mode */
10738 /* Indicate initialization to MSI-X mode */
10741 }
10742 }
10743 }
10745 /* Fallback to MSI if MSI-X initialization failed */
10749 /* Indicate initialization to MSI mode */
10752 }
10753 }
10755 /* Fallback to INTx if both MSI-X/MSI initalization failed */
10760 /* Indicate initialization to INTx mode */
10763 }
10764 }
10766 }
10768 /**
10769 * lpfc_sli_disable_intr - Disable device interrupt to SLI-3 device.
10770 * @phba: pointer to lpfc hba data structure.
10771 *
10772 * This routine is invoked to disable device interrupt and disassociate the
10773 * driver's interrupt handler(s) from interrupt vector(s) to device with
10774 * SLI-3 interface spec. Depending on the interrupt mode, the driver will
10775 * release the interrupt vector(s) for the message signaled interrupt.
10776 **/
10777 static void
10779 {
10784 else
10791 /* Reset interrupt management states */
10794 }
10796 /**
10797 * lpfc_find_cpu_handle - Find the CPU that corresponds to the specified Queue
10798 * @phba: pointer to lpfc hba data structure.
10799 * @id: EQ vector index or Hardware Queue index
10800 * @match: LPFC_FIND_BY_EQ = match by EQ
10801 * LPFC_FIND_BY_HDWQ = match by Hardware Queue
10802 * Return the CPU that matches the selection criteria
10803 */
10804 static uint16_t
10806 {
10810 /* Loop through all CPUs */
10814 /* If we are matching by EQ, there may be multiple CPUs using
10815 * using the same vector, so select the one with
10816 * LPFC_CPU_FIRST_IRQ set.
10817 */
10823 /* If matching by HDWQ, select the first CPU that matches */
10826 }
10828 }
10830 #ifdef CONFIG_X86
10831 /**
10832 * lpfc_find_hyper - Determine if the CPU map entry is hyper-threaded
10833 * @phba: pointer to lpfc hba data structure.
10834 * @cpu: CPU map index
10835 * @phys_id: CPU package physical id
10836 * @core_id: CPU core id
10837 */
10838 static int
10841 {
10847 /* Does the cpup match the one we are looking for */
10852 }
10854 }
10855 #endif
10857 /*
10858 * lpfc_assign_eq_map_info - Assigns eq for vector_map structure
10859 * @phba: pointer to lpfc hba data structure.
10860 * @eqidx: index for eq and irq vector
10861 * @flag: flags to set for vector_map structure
10862 * @cpu: cpu used to index vector_map structure
10863 *
10864 * The routine assigns eq info into vector_map structure
10865 */
10869 {
10879 }
10881 /**
10882 * lpfc_cpu_map_array_init - Initialize cpu_map structure
10883 * @phba: pointer to lpfc hba data structure.
10884 *
10885 * The routine initializes the cpu_map array structure
10886 */
10887 static void
10889 {
10904 }
10905 }
10907 /**
10908 * lpfc_hba_eq_hdl_array_init - Initialize hba_eq_hdl structure
10909 * @phba: pointer to lpfc hba data structure.
10910 *
10911 * The routine initializes the hba_eq_hdl array structure
10912 */
10913 static void
10915 {
10923 }
10924 }
10926 /**
10927 * lpfc_cpu_affinity_check - Check vector CPU affinity mappings
10928 * @phba: pointer to lpfc hba data structure.
10929 * @vectors: number of msix vectors allocated.
10930 *
10931 * The routine will figure out the CPU affinity assignment for every
10932 * MSI-X vector allocated for the HBA.
10933 * In addition, the CPU to IO channel mapping will be calculated
10934 * and the phba->sli4_hba.cpu_map array will reflect this.
10935 */
10936 static void
10938 {
10944 #ifdef CONFIG_X86
10946 #endif
10947 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
10949 #endif
10956 /* Update CPU map with physical id and core id of each CPU */
10959 #ifdef CONFIG_X86
10965 #else
10966 /* No distinction between CPUs for other platforms */
10969 #endif
10984 }
10986 /* After looking at each irq vector assigned to this pcidev, its
10987 * possible to see that not ALL CPUs have been accounted for.
10988 * Next we will set any unassigned (unaffinitized) cpu map
10989 * entries to a IRQ on the same phys_id.
10990 */
10997 /* Is this CPU entry unassigned */
10999 /* Mark CPU as IRQ not assigned by the kernel */
11002 /* If so, find a new_cpup thats on the the SAME
11003 * phys_id as cpup. start_cpu will start where we
11004 * left off so all unassigned entries don't get assgined
11005 * the IRQ of the first entry.
11006 */
11018 }
11019 /* At this point, we leave the CPU as unassigned */
11021 found_same:
11022 /* We found a matching phys_id, so copy the IRQ info */
11025 /* Bump start_cpu to the next slot to minmize the
11026 * chance of having multiple unassigned CPU entries
11027 * selecting the same IRQ.
11028 */
11034 "3337 Set Affinity: CPU %d "
11035 "eq %d from peer cpu %d same "
11039 }
11040 }
11042 /* Set any unassigned cpu map entries to a IRQ on any phys_id */
11048 /* Is this entry unassigned */
11050 /* Mark it as IRQ not assigned by the kernel */
11053 /* If so, find a new_cpup thats on ANY phys_id
11054 * as the cpup. start_cpu will start where we
11055 * left off so all unassigned entries don't get
11056 * assigned the IRQ of the first entry.
11057 */
11068 }
11069 /* We should never leave an entry unassigned */
11071 "3339 Set Affinity: CPU %d "
11075 found_any:
11076 /* We found an available entry, copy the IRQ info */
11079 /* Bump start_cpu to the next slot to minmize the
11080 * chance of having multiple unassigned CPU entries
11081 * selecting the same IRQ.
11082 */
11088 "3338 Set Affinity: CPU %d "
11092 }
11093 }
11095 /* Assign hdwq indices that are unique across all cpus in the map
11096 * that are also FIRST_CPUs.
11097 */
11102 /* Only FIRST IRQs get a hdwq index assignment. */
11106 /* 1 to 1, the first LPFC_CPU_FIRST_IRQ cpus to a unique hdwq */
11108 idx++;
11110 "3333 Set Affinity: CPU %d (phys %d core %d): "
11114 }
11115 /* Associate a hdwq with each cpu_map entry
11116 * This will be 1 to 1 - hdwq to cpu, unless there are less
11117 * hardware queues then CPUs. For that case we will just round-robin
11118 * the available hardware queues as they get assigned to CPUs.
11119 * The next_idx is the idx from the FIRST_CPU loop above to account
11120 * for irq_chann < hdwq. The idx is used for round-robin assignments
11121 * and needs to start at 0.
11122 */
11129 /* FIRST cpus are already mapped. */
11133 /* If the cfg_irq_chann < cfg_hdw_queue, set the hdwq
11134 * of the unassigned cpus to the next idx so that all
11135 * hdw queues are fully utilized.
11136 */
11139 next_idx++;
11141 }
11143 /* Not a First CPU and all hdw_queues are used. Reuse a
11144 * Hardware Queue for another CPU, so be smart about it
11145 * and pick one that has its IRQ/EQ mapped to the same phys_id
11146 * (CPU package) and core_id.
11147 */
11155 }
11159 }
11161 /* If we can't match both phys_id and core_id,
11162 * settle for just a phys_id match.
11163 */
11174 }
11176 /* Otherwise just round robin on cfg_hdw_queue */
11178 idx++;
11180 found_hdwq:
11181 /* We found an available entry, copy the IRQ info */
11186 logit:
11188 "3335 Set Affinity: CPU %d (phys %d core %d): "
11192 }
11194 /*
11195 * Initialize the cpu_map slots for not-present cpus in case
11196 * a cpu is hot-added. Perform a simple hdwq round robin assignment.
11197 */
11201 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
11204 #endif
11209 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
11211 #endif
11213 "3340 Set Affinity: not present "
11216 }
11218 /* The cpu_map array will be used later during initialization
11219 * when EQ / CQ / WQs are allocated and configured.
11220 */
11222 }
11224 /**
11225 * lpfc_cpuhp_get_eq
11226 *
11227 * @phba: pointer to lpfc hba data structure.
11228 * @cpu: cpu going offline
11229 * @eqlist: eq list to append to
11230 */
11231 static int
11234 {
11238 u16 idx;
11248 /*
11249 * if irq is not affinitized to the cpu going
11250 * then we don't need to poll the eq attached
11251 * to it.
11252 */
11255 /* get the cpus that are online and are affini-
11256 * tized to this irq vector. If the count is
11257 * more than 1 then cpuhp is not going to shut-
11258 * down this vector. Since this cpu has not
11259 * gone offline yet, we need >1.
11260 */
11265 /* Now that we have an irq to shutdown, get the eq
11266 * mapped to this irq. Note: multiple hdwq's in
11267 * the software can share an eq, but eventually
11268 * only eq will be mapped to this vector
11269 */
11272 }
11275 }
11278 {
11284 /*
11285 * unregistering the instance doesn't stop the polling
11286 * timer. Wait for the poll timer to retire.
11287 */
11290 }
11293 {
11298 }
11301 {
11315 }
11318 {
11322 }
11327 }
11329 /* proceed with the hotplug */
11331 }
11333 /**
11334 * lpfc_irq_set_aff - set IRQ affinity
11335 * @eqhdl: EQ handle
11336 * @cpu: cpu to set affinity
11337 *
11338 **/
11341 {
11346 }
11348 /**
11349 * lpfc_irq_clear_aff - clear IRQ affinity
11350 * @eqhdl: EQ handle
11351 *
11352 **/
11355 {
11358 }
11360 /**
11361 * lpfc_irq_rebalance - rebalances IRQ affinity according to cpuhp event
11362 * @phba: pointer to HBA context object.
11363 * @cpu: cpu going offline/online
11364 * @offline: true, cpu is going offline. false, cpu is coming online.
11365 *
11366 * If cpu is going offline, we'll try our best effort to find the next
11367 * online cpu on the phba's original_mask and migrate all offlining IRQ
11368 * affinities.
11369 *
11370 * If cpu is coming online, reaffinitize the IRQ back to the onlining cpu.
11371 *
11372 * Note: Call only if NUMA or NHT mode is enabled, otherwise rely on
11373 * PCI_IRQ_AFFINITY to auto-manage IRQ affinity.
11374 *
11375 **/
11376 static void
11378 {
11398 /* Find next online CPU on original mask */
11402 /* Found a valid CPU */
11404 /* Go through each eqhdl and ensure offlining
11405 * cpu aff_mask is migrated
11406 */
11410 /* Migrate affinity */
11413 cpu_select);
11414 }
11416 /* Rely on irqbalance if no online CPUs left on NUMA */
11419 }
11421 /* Migrate affinity back to this CPU */
11423 }
11424 }
11427 {
11436 }
11447 /* start polling on these eq's */
11451 }
11454 }
11457 {
11466 }
11477 }
11480 }
11482 /**
11483 * lpfc_sli4_enable_msix - Enable MSI-X interrupt mode to SLI-4 device
11484 * @phba: pointer to lpfc hba data structure.
11485 *
11486 * This routine is invoked to enable the MSI-X interrupt vectors to device
11487 * with SLI-4 interface spec. It also allocates MSI-X vectors and maps them
11488 * to cpus on the system.
11489 *
11490 * When cfg_irq_numa is enabled, the adapter will only allocate vectors for
11491 * the number of cpus on the same numa node as this adapter. The vectors are
11492 * allocated without requesting OS affinity mapping. A vector will be
11493 * allocated and assigned to each online and offline cpu. If the cpu is
11494 * online, then affinity will be set to that cpu. If the cpu is offline, then
11495 * affinity will be set to the nearest peer cpu within the numa node that is
11496 * online. If there are no online cpus within the numa node, affinity is not
11497 * assigned and the OS may do as it pleases. Note: cpu vector affinity mapping
11498 * is consistent with the way cpu online/offline is handled when cfg_irq_numa is
11499 * configured.
11500 *
11501 * If numa mode is not enabled and there is more than 1 vector allocated, then
11502 * the driver relies on the managed irq interface where the OS assigns vector to
11503 * cpu affinity. The driver will then use that affinity mapping to setup its
11504 * cpu mapping table.
11505 *
11506 * Return codes
11507 * 0 - successful
11508 * other values - error
11509 **/
11510 static int
11512 {
11522 /* Set up MSI-X multi-message vectors */
11532 /* cpu: iterates over aff_mask including offline or online
11533 * cpu_select: iterates over online aff_mask to set affinity
11534 */
11539 }
11546 }
11549 /* Assign MSI-X vectors to interrupt handlers */
11563 "0486 MSI-X fast-path (%d) "
11566 }
11571 /* If found a neighboring online cpu, set affinity */
11575 /* Assign EQ to cpu_map */
11577 LPFC_CPU_FIRST_IRQ,
11578 cpu);
11580 /* Iterate to next offline or online cpu in aff_mask */
11583 /* Find next online cpu in aff_mask to set affinity */
11588 cpu);
11592 /* Loop through all CPUs associated with vector index */
11596 /* If this is the first CPU thats assigned to
11597 * this vector, set LPFC_CPU_FIRST_IRQ.
11598 *
11599 * With certain platforms its possible that irq
11600 * vectors are affinitized to all the cpu's.
11601 * This can result in each cpu_map.eq to be set
11602 * to the last vector, resulting in overwrite
11603 * of all the previous cpu_map.eq. Ensure that
11604 * each vector receives a place in cpu_map.
11605 * Later call to lpfc_cpu_affinity_check will
11606 * ensure we are nicely balanced out.
11607 */
11611 LPFC_CPU_FIRST_IRQ,
11612 cpu);
11614 }
11615 }
11616 }
11620 "3238 Reducing IO channels to match number of "
11625 }
11629 cfg_fail_out:
11630 /* free the irq already requested */
11636 }
11638 /* Unconfigure MSI-X capability structure */
11641 vec_fail_out:
11643 }
11645 /**
11646 * lpfc_sli4_enable_msi - Enable MSI interrupt mode to SLI-4 device
11647 * @phba: pointer to lpfc hba data structure.
11648 *
11649 * This routine is invoked to enable the MSI interrupt mode to device with
11650 * SLI-4 interface spec. The kernel function pci_alloc_irq_vectors() is
11651 * called to enable the MSI vector. The device driver is responsible for
11652 * calling the request_irq() to register MSI vector with a interrupt the
11653 * handler, which is done in this function.
11654 *
11655 * Return codes
11656 * 0 - successful
11657 * other values - error
11658 **/
11659 static int
11661 {
11675 }
11684 }
11695 }
11698 }
11700 /**
11701 * lpfc_sli4_enable_intr - Enable device interrupt to SLI-4 device
11702 * @phba: pointer to lpfc hba data structure.
11703 * @cfg_mode: Interrupt configuration mode (INTx, MSI or MSI-X).
11704 *
11705 * This routine is invoked to enable device interrupt and associate driver's
11706 * interrupt handler(s) to interrupt vector(s) to device with SLI-4
11707 * interface spec. Depends on the interrupt mode configured to the driver,
11708 * the driver will try to fallback from the configured interrupt mode to an
11709 * interrupt mode which is supported by the platform, kernel, and device in
11710 * the order of:
11711 * MSI-X -> MSI -> IRQ.
11712 *
11713 * Return codes
11714 * 0 - successful
11715 * other values - error
11716 **/
11717 static uint32_t
11719 {
11724 /* Preparation before conf_msi mbox cmd */
11727 /* Now, try to enable MSI-X interrupt mode */
11730 /* Indicate initialization to MSI-X mode */
11733 }
11734 }
11735 }
11737 /* Fallback to MSI if MSI-X initialization failed */
11741 /* Indicate initialization to MSI mode */
11744 }
11745 }
11747 /* Fallback to INTx if both MSI-X/MSI initalization failed */
11755 /* Indicate initialization to INTx mode */
11764 cpu);
11768 }
11769 }
11770 }
11772 }
11774 /**
11775 * lpfc_sli4_disable_intr - Disable device interrupt to SLI-4 device
11776 * @phba: pointer to lpfc hba data structure.
11777 *
11778 * This routine is invoked to disable device interrupt and disassociate
11779 * the driver's interrupt handler(s) from interrupt vector(s) to device
11780 * with SLI-4 interface spec. Depending on the interrupt mode, the driver
11781 * will release the interrupt vector(s) for the message signaled interrupt.
11782 **/
11783 static void
11785 {
11786 /* Disable the currently initialized interrupt mode */
11791 /* Free up MSI-X multi-message vectors */
11797 }
11800 }
11804 /* Reset interrupt management states */
11807 }
11809 /**
11810 * lpfc_unset_hba - Unset SLI3 hba device initialization
11811 * @phba: pointer to lpfc hba data structure.
11812 *
11813 * This routine is invoked to unset the HBA device initialization steps to
11814 * a device with SLI-3 interface spec.
11815 **/
11816 static void
11818 {
11840 }
11842 /**
11843 * lpfc_sli4_xri_exchange_busy_wait - Wait for device XRI exchange busy
11844 * @phba: Pointer to HBA context object.
11845 *
11846 * This function is called in the SLI4 code path to wait for completion
11847 * of device's XRIs exchange busy. It will check the XRI exchange busy
11848 * on outstanding FCP and ELS I/Os every 10ms for up to 10 seconds; after
11849 * that, it will check the XRI exchange busy on outstanding FCP and ELS
11850 * I/Os every 30 seconds, log error message, and wait forever. Only when
11851 * all XRI exchange busy complete, the driver unload shall proceed with
11852 * invoking the function reset ioctl mailbox command to the CNA and the
11853 * the rest of the driver unload resource release.
11854 **/
11855 static void
11857 {
11865 /* Driver just aborted IOs during the hba_unset process. Pause
11866 * here to give the HBA time to complete the IO and get entries
11867 * into the abts lists.
11868 */
11871 /* Wait for NVME pending IO to flush back to transport. */
11880 ccnt++;
11881 }
11886 nvmet_xri_cmpl =
11888 }
11894 "6424 NVMET XRI exchange busy "
11899 "6100 IO XRI exchange busy "
11904 "2878 ELS XRI exchange busy "
11912 }
11920 ccnt++;
11921 }
11928 }
11929 els_xri_cmpl =
11932 }
11933 }
11935 /**
11936 * lpfc_sli4_hba_unset - Unset the fcoe hba
11937 * @phba: Pointer to HBA context object.
11938 *
11939 * This function is called in the SLI4 code path to reset the HBA's FCoE
11940 * function. The caller is not required to hold any lock. This routine
11941 * issues PCI function reset mailbox command to reset the FCoE function.
11942 * At the end of the function, it calls lpfc_hba_down_post function to
11943 * free any pending commands.
11944 **/
11945 static void
11947 {
11956 /*
11957 * Gracefully wait out the potential current outstanding asynchronous
11958 * mailbox command.
11959 */
11961 /* First, block any pending async mailbox command from posted */
11965 /* Now, trying to wait it out if we can */
11970 }
11971 /* Forcefully release the outstanding mailbox command if timed out */
11980 }
11982 /* Abort all iocbs associated with the hba */
11985 /* Wait for completion of device XRI exchange busy */
11988 /* per-phba callback de-registration for hotplug event */
11992 /* Disable PCI subsystem interrupt */
11995 /* Disable SR-IOV if enabled */
11999 /* Stop kthread signal shall trigger work_done one more time */
12002 /* Disable FW logging to host memory */
12005 /* Unset the queues shared with the hardware then release all
12006 * allocated resources.
12007 */
12011 /* Reset SLI4 HBA FCoE function */
12014 /* Free RAS DMA memory */
12018 /* Stop the SLI4 device port */
12021 }
12023 /**
12024 * lpfc_pc_sli4_params_get - Get the SLI4_PARAMS port capabilities.
12025 * @phba: Pointer to HBA context object.
12026 * @mboxq: Pointer to the mailboxq memory for the mailbox command response.
12027 *
12028 * This function is called in the SLI4 code path to read the port's
12029 * sli4 capabilities.
12030 *
12031 * This function may be be called from any context that can block-wait
12032 * for the completion. The expectation is that this routine is called
12033 * typically from probe_one or from the online routine.
12034 **/
12035 int
12037 {
12046 /* Read the port's SLI4 Parameters port capabilities */
12053 }
12088 /* Make sure that sge_supp_len can be handled by the driver */
12093 }
12095 /**
12096 * lpfc_get_sli4_parameters - Get the SLI4 Config PARAMETERS.
12097 * @phba: Pointer to HBA context object.
12098 * @mboxq: Pointer to the mailboxq memory for the mailbox command response.
12099 *
12100 * This function is called in the SLI4 code path to read the port's
12101 * sli4 capabilities.
12102 *
12103 * This function may be be called from any context that can block-wait
12104 * for the completion. The expectation is that this routine is called
12105 * typically from probe_one or from the online routine.
12106 **/
12107 int
12109 {
12118 /*
12119 * By default, the driver assumes the SLI4 port requires RPI
12120 * header postings. The SLI4_PARAM response will correct this
12121 * assumption.
12122 */
12125 /* Read the port's SLI4 Config Parameters */
12129 LPFC_MBOX_OPCODE_GET_SLI4_PARAMETERS,
12136 }
12145 mbx_sli4_parameters);
12147 mbx_sli4_parameters);
12150 else
12165 mbx_sli4_parameters);
12168 mbx_sli4_parameters);
12172 /* Check for Extended Pre-Registered SGL support */
12175 /* Check for firmware nvme support */
12180 /* Save this to indicate the Firmware supports NVME */
12183 /* Firmware NVME support, check driver FC4 NVME support */
12186 "6133 Disabling NVME support: "
12190 }
12192 /* No firmware NVME support, check driver FC4 NVME support */
12196 "6101 Disabling NVME support: Not "
12201 fcponly:
12207 /* If no FC4 type support, move to just SCSI support */
12211 }
12212 }
12214 /* If the NVME FC4 type is enabled, scale the sg_seg_cnt to
12215 * accommodate 512K and 1M IOs in a single nvme buf.
12216 */
12220 /* Only embed PBDE for if_type 6, PBDE support requires xib be set */
12225 /*
12226 * To support Suppress Response feature we must satisfy 3 conditions.
12227 * lpfc_suppress_rsp module parameter must be set (default).
12228 * In SLI4-Parameters Descriptor:
12229 * Extended Inline Buffers (XIB) must be supported.
12230 * Suppress Response IU Not Supported (SRIUNS) must NOT be supported
12231 * (double negative).
12232 */
12236 else
12242 /* Make sure that sge_supp_len can be handled by the driver */
12246 /*
12247 * Check whether the adapter supports an embedded copy of the
12248 * FCP CMD IU within the WQE for FCP_Ixxx commands. In order
12249 * to use this option, 128-byte WQEs must be used.
12250 */
12253 else
12264 LPFC_SLI_INTF_IF_TYPE_2) &&
12266 LPFC_SLI_INTF_FAMILY_LNCR_A0))
12271 exp_wqcq_pages &&
12274 else
12276 /*
12277 * Check if the SLI port supports MDS Diagnostics
12278 */
12281 else
12284 /*
12285 * Check if the SLI port supports NSLER
12286 */
12289 else
12292 /* Save PB info for use during HBA setup */
12298 /* Next we check for Vendor MIB support */
12308 }
12310 /**
12311 * lpfc_pci_probe_one_s3 - PCI probe func to reg SLI-3 device to PCI subsystem.
12312 * @pdev: pointer to PCI device
12313 * @pid: pointer to PCI device identifier
12314 *
12315 * This routine is to be called to attach a device with SLI-3 interface spec
12316 * to the PCI subsystem. When an Emulex HBA with SLI-3 interface spec is
12317 * presented on PCI bus, the kernel PCI subsystem looks at PCI device-specific
12318 * information of the device and driver to see if the driver state that it can
12319 * support this kind of device. If the match is successful, the driver core
12320 * invokes this routine. If this routine determines it can claim the HBA, it
12321 * does all the initialization that it needs to do to handle the HBA properly.
12322 *
12323 * Return code
12324 * 0 - driver can claim the device
12325 * negative value - driver can not claim the device
12326 **/
12327 static int
12329 {
12336 /* Allocate memory for HBA structure */
12341 /* Perform generic PCI device enabling operation */
12346 /* Set up SLI API function jump table for PCI-device group-0 HBAs */
12351 /* Set up SLI-3 specific device PCI memory space */
12357 }
12359 /* Set up SLI-3 specific device driver resources */
12365 }
12367 /* Initialize and populate the iocb list per host */
12374 }
12376 /* Set up common device driver resources */
12382 }
12384 /* Get the default values for Model Name and Description */
12387 /* Create SCSI host to the physical port */
12393 }
12395 /* Configure sysfs attributes */
12402 }
12405 /* Now, trying to enable interrupt and bring up the device */
12408 /* Put device to a known state before enabling interrupt */
12410 /* Configure and enable interrupt */
12417 }
12418 /* SLI-3 HBA setup */
12424 }
12426 /* Wait 50ms for the interrupts of previous mailbox commands */
12428 /* Check active interrupts on message signaled interrupts */
12431 /* Log the current active interrupt mode */
12437 "0447 Configure interrupt mode (%d) "
12439 intr_mode);
12440 /* Disable the current interrupt mode */
12442 /* Try next level of interrupt mode */
12444 }
12445 }
12447 /* Perform post initialization setup */
12450 /* Check if there are static vports to be created. */
12455 out_remove_device:
12457 out_free_sysfs_attr:
12459 out_destroy_shost:
12461 out_unset_driver_resource:
12463 out_free_iocb_list:
12465 out_unset_driver_resource_s3:
12467 out_unset_pci_mem_s3:
12469 out_disable_pci_dev:
12473 out_free_phba:
12476 }
12478 /**
12479 * lpfc_pci_remove_one_s3 - PCI func to unreg SLI-3 device from PCI subsystem.
12480 * @pdev: pointer to PCI device
12481 *
12482 * This routine is to be called to disattach a device with SLI-3 interface
12483 * spec from PCI subsystem. When an Emulex HBA with SLI-3 interface spec is
12484 * removed from PCI bus, it performs all the necessary cleanup for the HBA
12485 * device to be removed from the PCI subsystem properly.
12486 **/
12487 static void
12489 {
12502 /* Release all the vports against this physical port */
12509 }
12512 /* Remove FC host with the physical port */
12516 /* Clean up all nodes, mailboxes and IOs. */
12519 /*
12520 * Bring down the SLI Layer. This step disable all interrupts,
12521 * clears the rings, discards all mailbox commands, and resets
12522 * the HBA.
12523 */
12525 /* HBA interrupt will be disabled after this call */
12527 /* Stop kthread signal shall trigger work_done one more time */
12529 /* Final cleanup of txcmplq and reset the HBA */
12542 /* Disable SR-IOV if enabled */
12546 /* Disable interrupt */
12551 /*
12552 * Call scsi_free before mem_free since scsi bufs are released to their
12553 * corresponding pools here.
12554 */
12563 /* Free resources associated with SLI2 interface */
12567 /* unmap adapter SLIM and Control Registers */
12575 }
12577 /**
12578 * lpfc_pci_suspend_one_s3 - PCI func to suspend SLI-3 device for power mgmnt
12579 * @dev_d: pointer to device
12580 *
12581 * This routine is to be called from the kernel's PCI subsystem to support
12582 * system Power Management (PM) to device with SLI-3 interface spec. When
12583 * PM invokes this method, it quiesces the device by stopping the driver's
12584 * worker thread for the device, turning off device's interrupt and DMA,
12585 * and bring the device offline. Note that as the driver implements the
12586 * minimum PM requirements to a power-aware driver's PM support for the
12587 * suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE, FREEZE)
12588 * to the suspend() method call will be treated as SUSPEND and the driver will
12589 * fully reinitialize its device during resume() method call, the driver will
12590 * set device to PCI_D3hot state in PCI config space instead of setting it
12591 * according to the @msg provided by the PM.
12592 *
12593 * Return code
12594 * 0 - driver suspended the device
12595 * Error otherwise
12596 **/
12597 static int __maybe_unused
12599 {
12606 /* Bring down the device */
12611 /* Disable interrupt from device */
12615 }
12617 /**
12618 * lpfc_pci_resume_one_s3 - PCI func to resume SLI-3 device for power mgmnt
12619 * @dev_d: pointer to device
12620 *
12621 * This routine is to be called from the kernel's PCI subsystem to support
12622 * system Power Management (PM) to device with SLI-3 interface spec. When PM
12623 * invokes this method, it restores the device's PCI config space state and
12624 * fully reinitializes the device and brings it online. Note that as the
12625 * driver implements the minimum PM requirements to a power-aware driver's
12626 * PM for suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE,
12627 * FREEZE) to the suspend() method call will be treated as SUSPEND and the
12628 * driver will fully reinitialize its device during resume() method call,
12629 * the device will be set to PCI_D0 directly in PCI config space before
12630 * restoring the state.
12631 *
12632 * Return code
12633 * 0 - driver suspended the device
12634 * Error otherwise
12635 **/
12636 static int __maybe_unused
12638 {
12647 /* Startup the kernel thread for this host adapter. */
12653 "0434 PM resume failed to start worker "
12656 }
12658 /* Configure and enable interrupt */
12667 /* Restart HBA and bring it online */
12671 /* Log the current active interrupt mode */
12675 }
12677 /**
12678 * lpfc_sli_prep_dev_for_recover - Prepare SLI3 device for pci slot recover
12679 * @phba: pointer to lpfc hba data structure.
12680 *
12681 * This routine is called to prepare the SLI3 device for PCI slot recover. It
12682 * aborts all the outstanding SCSI I/Os to the pci device.
12683 **/
12684 static void
12686 {
12690 /*
12691 * There may be errored I/Os through HBA, abort all I/Os on txcmplq
12692 * and let the SCSI mid-layer to retry them to recover.
12693 */
12695 }
12697 /**
12698 * lpfc_sli_prep_dev_for_reset - Prepare SLI3 device for pci slot reset
12699 * @phba: pointer to lpfc hba data structure.
12700 *
12701 * This routine is called to prepare the SLI3 device for PCI slot reset. It
12702 * disables the device interrupt and pci device, and aborts the internal FCP
12703 * pending I/Os.
12704 **/
12705 static void
12707 {
12711 /* Block any management I/Os to the device */
12714 /* Block all SCSI devices' I/Os on the host */
12717 /* Flush all driver's outstanding SCSI I/Os as we are to reset */
12720 /* stop all timers */
12723 /* Disable interrupt and pci device */
12726 }
12728 /**
12729 * lpfc_sli_prep_dev_for_perm_failure - Prepare SLI3 dev for pci slot disable
12730 * @phba: pointer to lpfc hba data structure.
12731 *
12732 * This routine is called to prepare the SLI3 device for PCI slot permanently
12733 * disabling. It blocks the SCSI transport layer traffic and flushes the FCP
12734 * pending I/Os.
12735 **/
12736 static void
12738 {
12741 /* Block all SCSI devices' I/Os on the host */
12744 /* stop all timers */
12747 /* Clean up all driver's outstanding SCSI I/Os */
12749 }
12751 /**
12752 * lpfc_io_error_detected_s3 - Method for handling SLI-3 device PCI I/O error
12753 * @pdev: pointer to PCI device.
12754 * @state: the current PCI connection state.
12755 *
12756 * This routine is called from the PCI subsystem for I/O error handling to
12757 * device with SLI-3 interface spec. This function is called by the PCI
12758 * subsystem after a PCI bus error affecting this device has been detected.
12759 * When this function is invoked, it will need to stop all the I/Os and
12760 * interrupt(s) to the device. Once that is done, it will return
12761 * PCI_ERS_RESULT_NEED_RESET for the PCI subsystem to perform proper recovery
12762 * as desired.
12763 *
12764 * Return codes
12765 * PCI_ERS_RESULT_CAN_RECOVER - can be recovered with reset_link
12766 * PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
12767 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
12768 **/
12769 static pci_ers_result_t
12771 {
12777 /* Non-fatal error, prepare for recovery */
12781 /* Fatal error, prepare for slot reset */
12785 /* Permanent failure, prepare for device down */
12789 /* Unknown state, prepare and request slot reset */
12794 }
12795 }
12797 /**
12798 * lpfc_io_slot_reset_s3 - Method for restarting PCI SLI-3 device from scratch.
12799 * @pdev: pointer to PCI device.
12800 *
12801 * This routine is called from the PCI subsystem for error handling to
12802 * device with SLI-3 interface spec. This is called after PCI bus has been
12803 * reset to restart the PCI card from scratch, as if from a cold-boot.
12804 * During the PCI subsystem error recovery, after driver returns
12805 * PCI_ERS_RESULT_NEED_RESET, the PCI subsystem will perform proper error
12806 * recovery and then call this routine before calling the .resume method
12807 * to recover the device. This function will initialize the HBA device,
12808 * enable the interrupt, but it will just put the HBA to offline state
12809 * without passing any I/O traffic.
12810 *
12811 * Return codes
12812 * PCI_ERS_RESULT_RECOVERED - the device has been recovered
12813 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
12814 */
12815 static pci_ers_result_t
12817 {
12828 }
12832 /*
12833 * As the new kernel behavior of pci_restore_state() API call clears
12834 * device saved_state flag, need to save the restored state again.
12835 */
12845 /* Configure and enable interrupt */
12849 "0427 Cannot re-enable interrupt after "
12855 /* Take device offline, it will perform cleanup */
12860 /* Log the current active interrupt mode */
12864 }
12866 /**
12867 * lpfc_io_resume_s3 - Method for resuming PCI I/O operation on SLI-3 device.
12868 * @pdev: pointer to PCI device
12869 *
12870 * This routine is called from the PCI subsystem for error handling to device
12871 * with SLI-3 interface spec. It is called when kernel error recovery tells
12872 * the lpfc driver that it is ok to resume normal PCI operation after PCI bus
12873 * error recovery. After this call, traffic can start to flow from this device
12874 * again.
12875 */
12876 static void
12878 {
12882 /* Bring device online, it will be no-op for non-fatal error resume */
12884 }
12886 /**
12887 * lpfc_sli4_get_els_iocb_cnt - Calculate the # of ELS IOCBs to reserve
12888 * @phba: pointer to lpfc hba data structure.
12889 *
12890 * returns the number of ELS/CT IOCBs to reserve
12891 **/
12892 int
12894 {
12910 else
12914 }
12916 /**
12917 * lpfc_sli4_get_iocb_cnt - Calculate the # of total IOCBs to reserve
12918 * @phba: pointer to lpfc hba data structure.
12919 *
12920 * returns the number of ELS/CT + NVMET IOCBs to reserve
12921 **/
12922 int
12924 {
12930 }
12933 static int
12937 {
12940 /* Three cases: (1) FW was not supported on the detected adapter.
12941 * (2) FW update has been locked out administratively.
12942 * (3) Some other error during FW update.
12943 * In each case, an unmaskable message is written to the console
12944 * for admin diagnosis.
12945 */
12952 "3030 This firmware version is not supported on"
12953 " this HBA model. Device:%x Magic:%x Type:%x "
12960 "3021 Firmware downloads have been prohibited "
12961 "by a system configuration setting on "
12962 "Device:%x Magic:%x Type:%x ID:%x Size %d "
12969 "3022 FW Download failed. Add Status x%x "
12970 "Device:%x Magic:%x Type:%x ID:%x Size %d "
12975 }
12977 }
12979 /**
12980 * lpfc_write_firmware - attempt to write a firmware image to the port
12981 * @fw: pointer to firmware image returned from request_firmware.
12982 * @context: pointer to firmware image returned from request_firmware.
12983 *
12984 **/
12985 static void
12987 {
12997 /* It can be null in no-wait mode, sanity check */
13001 }
13013 "3023 Updating Firmware, Current Version:%s "
13018 GFP_KERNEL);
13022 }
13024 SLI4_PAGE_SIZE,
13026 GFP_KERNEL);
13031 }
13033 }
13043 }
13045 SLI4_PAGE_SIZE);
13047 }
13052 magic_number,
13053 ftype,
13054 fid,
13055 fsize,
13056 fw);
13058 }
13059 }
13063 "3029 Skipped Firmware update, Current "
13067 release_out:
13073 }
13075 out:
13079 else
13082 }
13084 /**
13085 * lpfc_sli4_request_firmware_update - Request linux generic firmware upgrade
13086 * @phba: pointer to lpfc hba data structure.
13087 * @fw_upgrade: which firmware to update.
13088 *
13089 * This routine is called to perform Linux generic firmware upgrade on device
13090 * that supports such feature.
13091 **/
13092 int
13094 {
13099 /* Only supported on SLI4 interface type 2 for now */
13101 LPFC_SLI_INTF_IF_TYPE_2)
13110 lpfc_write_firmware);
13117 }
13120 }
13122 /**
13123 * lpfc_pci_probe_one_s4 - PCI probe func to reg SLI-4 device to PCI subsys
13124 * @pdev: pointer to PCI device
13125 * @pid: pointer to PCI device identifier
13126 *
13127 * This routine is called from the kernel's PCI subsystem to device with
13128 * SLI-4 interface spec. When an Emulex HBA with SLI-4 interface spec is
13129 * presented on PCI bus, the kernel PCI subsystem looks at PCI device-specific
13130 * information of the device and driver to see if the driver state that it
13131 * can support this kind of device. If the match is successful, the driver
13132 * core invokes this routine. If this routine determines it can claim the HBA,
13133 * it does all the initialization that it needs to do to handle the HBA
13134 * properly.
13135 *
13136 * Return code
13137 * 0 - driver can claim the device
13138 * negative value - driver can not claim the device
13139 **/
13140 static int
13142 {
13149 /* Allocate memory for HBA structure */
13154 /* Perform generic PCI device enabling operation */
13159 /* Set up SLI API function jump table for PCI-device group-1 HBAs */
13164 /* Set up SLI-4 specific device PCI memory space */
13170 }
13172 /* Set up SLI-4 Specific device driver resources */
13178 }
13183 /* Set up common device driver resources */
13189 }
13191 /* Get the default values for Model Name and Description */
13194 /* Now, trying to enable interrupt and bring up the device */
13197 /* Put device to a known state before enabling interrupt */
13201 /* Init cpu_map array */
13204 /* Init hba_eq_hdl array */
13207 /* Configure and enable interrupt */
13214 }
13215 /* Default to single EQ for non-MSI-X */
13221 }
13222 }
13225 /* Create SCSI host to the physical port */
13231 }
13235 /* Configure sysfs attributes */
13241 }
13243 /* Set up SLI-4 HBA */
13249 }
13251 /* Log the current active interrupt mode */
13255 /* Perform post initialization setup */
13258 /* NVME support in FW earlier in the driver load corrects the
13259 * FC4 type making a check for nvme_support unnecessary.
13260 */
13263 /* Create NVME binding with nvme_fc_transport. This
13264 * ensures the vport is initialized. If the localport
13265 * create fails, it should not unload the driver to
13266 * support field issues.
13267 */
13271 "6004 NVME registration "
13273 error);
13274 }
13275 }
13276 }
13278 /* check for firmware upgrade or downgrade */
13282 /* Check if there are static vports to be created. */
13285 /* Enable RAS FW log support */
13294 out_free_sysfs_attr:
13296 out_destroy_shost:
13298 out_disable_intr:
13300 out_unset_driver_resource:
13302 out_unset_driver_resource_s4:
13304 out_unset_pci_mem_s4:
13306 out_disable_pci_dev:
13310 out_free_phba:
13313 }
13315 /**
13316 * lpfc_pci_remove_one_s4 - PCI func to unreg SLI-4 device from PCI subsystem
13317 * @pdev: pointer to PCI device
13318 *
13319 * This routine is called from the kernel's PCI subsystem to device with
13320 * SLI-4 interface spec. When an Emulex HBA with SLI-4 interface spec is
13321 * removed from PCI bus, it performs all the necessary cleanup for the HBA
13322 * device to be removed from the PCI subsystem properly.
13323 **/
13324 static void
13326 {
13333 /* Mark the device unloading flag */
13340 /* Release all the vports against this physical port */
13347 }
13350 /* Remove FC host with the physical port */
13354 /* Perform ndlp cleanup on the physical port. The nvme and nvmet
13355 * localports are destroyed after to cleanup all transport memory.
13356 */
13361 /* De-allocate multi-XRI pools */
13365 /*
13366 * Bring down the SLI Layer. This step disables all interrupts,
13367 * clears the rings, discards all mailbox commands, and resets
13368 * the HBA FCoE function.
13369 */
13377 /* Perform scsi free before driver resource_unset since scsi
13378 * buffers are released to their corresponding pools here.
13379 */
13387 /* Unmap adapter Control and Doorbell registers */
13390 /* Release PCI resources and disable device's PCI function */
13394 /* Finally, free the driver's device data structure */
13398 }
13400 /**
13401 * lpfc_pci_suspend_one_s4 - PCI func to suspend SLI-4 device for power mgmnt
13402 * @dev_d: pointer to device
13403 *
13404 * This routine is called from the kernel's PCI subsystem to support system
13405 * Power Management (PM) to device with SLI-4 interface spec. When PM invokes
13406 * this method, it quiesces the device by stopping the driver's worker
13407 * thread for the device, turning off device's interrupt and DMA, and bring
13408 * the device offline. Note that as the driver implements the minimum PM
13409 * requirements to a power-aware driver's PM support for suspend/resume -- all
13410 * the possible PM messages (SUSPEND, HIBERNATE, FREEZE) to the suspend()
13411 * method call will be treated as SUSPEND and the driver will fully
13412 * reinitialize its device during resume() method call, the driver will set
13413 * device to PCI_D3hot state in PCI config space instead of setting it
13414 * according to the @msg provided by the PM.
13415 *
13416 * Return code
13417 * 0 - driver suspended the device
13418 * Error otherwise
13419 **/
13420 static int __maybe_unused
13422 {
13429 /* Bring down the device */
13434 /* Disable interrupt from device */
13439 }
13441 /**
13442 * lpfc_pci_resume_one_s4 - PCI func to resume SLI-4 device for power mgmnt
13443 * @dev_d: pointer to device
13444 *
13445 * This routine is called from the kernel's PCI subsystem to support system
13446 * Power Management (PM) to device with SLI-4 interface spac. When PM invokes
13447 * this method, it restores the device's PCI config space state and fully
13448 * reinitializes the device and brings it online. Note that as the driver
13449 * implements the minimum PM requirements to a power-aware driver's PM for
13450 * suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE, FREEZE)
13451 * to the suspend() method call will be treated as SUSPEND and the driver
13452 * will fully reinitialize its device during resume() method call, the device
13453 * will be set to PCI_D0 directly in PCI config space before restoring the
13454 * state.
13455 *
13456 * Return code
13457 * 0 - driver suspended the device
13458 * Error otherwise
13459 **/
13460 static int __maybe_unused
13462 {
13471 /* Startup the kernel thread for this host adapter. */
13477 "0293 PM resume failed to start worker "
13480 }
13482 /* Configure and enable interrupt */
13491 /* Restart HBA and bring it online */
13495 /* Log the current active interrupt mode */
13499 }
13501 /**
13502 * lpfc_sli4_prep_dev_for_recover - Prepare SLI4 device for pci slot recover
13503 * @phba: pointer to lpfc hba data structure.
13504 *
13505 * This routine is called to prepare the SLI4 device for PCI slot recover. It
13506 * aborts all the outstanding SCSI I/Os to the pci device.
13507 **/
13508 static void
13510 {
13513 /*
13514 * There may be errored I/Os through HBA, abort all I/Os on txcmplq
13515 * and let the SCSI mid-layer to retry them to recover.
13516 */
13518 }
13520 /**
13521 * lpfc_sli4_prep_dev_for_reset - Prepare SLI4 device for pci slot reset
13522 * @phba: pointer to lpfc hba data structure.
13523 *
13524 * This routine is called to prepare the SLI4 device for PCI slot reset. It
13525 * disables the device interrupt and pci device, and aborts the internal FCP
13526 * pending I/Os.
13527 **/
13528 static void
13530 {
13534 /* Block any management I/Os to the device */
13537 /* Block all SCSI devices' I/Os on the host */
13540 /* Flush all driver's outstanding I/Os as we are to reset */
13543 /* stop all timers */
13546 /* Disable interrupt and pci device */
13550 }
13552 /**
13553 * lpfc_sli4_prep_dev_for_perm_failure - Prepare SLI4 dev for pci slot disable
13554 * @phba: pointer to lpfc hba data structure.
13555 *
13556 * This routine is called to prepare the SLI4 device for PCI slot permanently
13557 * disabling. It blocks the SCSI transport layer traffic and flushes the FCP
13558 * pending I/Os.
13559 **/
13560 static void
13562 {
13566 /* Block all SCSI devices' I/Os on the host */
13569 /* stop all timers */
13572 /* Clean up all driver's outstanding I/Os */
13574 }
13576 /**
13577 * lpfc_io_error_detected_s4 - Method for handling PCI I/O error to SLI-4 device
13578 * @pdev: pointer to PCI device.
13579 * @state: the current PCI connection state.
13580 *
13581 * This routine is called from the PCI subsystem for error handling to device
13582 * with SLI-4 interface spec. This function is called by the PCI subsystem
13583 * after a PCI bus error affecting this device has been detected. When this
13584 * function is invoked, it will need to stop all the I/Os and interrupt(s)
13585 * to the device. Once that is done, it will return PCI_ERS_RESULT_NEED_RESET
13586 * for the PCI subsystem to perform proper recovery as desired.
13587 *
13588 * Return codes
13589 * PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
13590 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
13591 **/
13592 static pci_ers_result_t
13594 {
13600 /* Non-fatal error, prepare for recovery */
13604 /* Fatal error, prepare for slot reset */
13608 /* Permanent failure, prepare for device down */
13612 /* Unknown state, prepare and request slot reset */
13617 }
13618 }
13620 /**
13621 * lpfc_io_slot_reset_s4 - Method for restart PCI SLI-4 device from scratch
13622 * @pdev: pointer to PCI device.
13623 *
13624 * This routine is called from the PCI subsystem for error handling to device
13625 * with SLI-4 interface spec. It is called after PCI bus has been reset to
13626 * restart the PCI card from scratch, as if from a cold-boot. During the
13627 * PCI subsystem error recovery, after the driver returns
13628 * PCI_ERS_RESULT_NEED_RESET, the PCI subsystem will perform proper error
13629 * recovery and then call this routine before calling the .resume method to
13630 * recover the device. This function will initialize the HBA device, enable
13631 * the interrupt, but it will just put the HBA to offline state without
13632 * passing any I/O traffic.
13633 *
13634 * Return codes
13635 * PCI_ERS_RESULT_RECOVERED - the device has been recovered
13636 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
13637 */
13638 static pci_ers_result_t
13640 {
13651 }
13655 /*
13656 * As the new kernel behavior of pci_restore_state() API call clears
13657 * device saved_state flag, need to save the restored state again.
13658 */
13668 /* Configure and enable interrupt */
13672 "2824 Cannot re-enable interrupt after "
13678 /* Log the current active interrupt mode */
13682 }
13684 /**
13685 * lpfc_io_resume_s4 - Method for resuming PCI I/O operation to SLI-4 device
13686 * @pdev: pointer to PCI device
13687 *
13688 * This routine is called from the PCI subsystem for error handling to device
13689 * with SLI-4 interface spec. It is called when kernel error recovery tells
13690 * the lpfc driver that it is ok to resume normal PCI operation after PCI bus
13691 * error recovery. After this call, traffic can start to flow from this device
13692 * again.
13693 **/
13694 static void
13696 {
13700 /*
13701 * In case of slot reset, as function reset is performed through
13702 * mailbox command which needs DMA to be enabled, this operation
13703 * has to be moved to the io resume phase. Taking device offline
13704 * will perform the necessary cleanup.
13705 */
13707 /* Perform device reset */
13711 /* Bring the device back online */
13713 }
13714 }
13716 /**
13717 * lpfc_pci_probe_one - lpfc PCI probe func to reg dev to PCI subsystem
13718 * @pdev: pointer to PCI device
13719 * @pid: pointer to PCI device identifier
13720 *
13721 * This routine is to be registered to the kernel's PCI subsystem. When an
13722 * Emulex HBA device is presented on PCI bus, the kernel PCI subsystem looks
13723 * at PCI device-specific information of the device and driver to see if the
13724 * driver state that it can support this kind of device. If the match is
13725 * successful, the driver core invokes this routine. This routine dispatches
13726 * the action to the proper SLI-3 or SLI-4 device probing routine, which will
13727 * do all the initialization that it needs to do to handle the HBA device
13728 * properly.
13729 *
13730 * Return code
13731 * 0 - driver can claim the device
13732 * negative value - driver can not claim the device
13733 **/
13734 static int
13736 {
13746 else
13750 }
13752 /**
13753 * lpfc_pci_remove_one - lpfc PCI func to unreg dev from PCI subsystem
13754 * @pdev: pointer to PCI device
13755 *
13756 * This routine is to be registered to the kernel's PCI subsystem. When an
13757 * Emulex HBA is removed from PCI bus, the driver core invokes this routine.
13758 * This routine dispatches the action to the proper SLI-3 or SLI-4 device
13759 * remove routine, which will perform all the necessary cleanup for the
13760 * device to be removed from the PCI subsystem properly.
13761 **/
13762 static void
13764 {
13780 }
13782 }
13784 /**
13785 * lpfc_pci_suspend_one - lpfc PCI func to suspend dev for power management
13786 * @dev: pointer to device
13787 *
13788 * This routine is to be registered to the kernel's PCI subsystem to support
13789 * system Power Management (PM). When PM invokes this method, it dispatches
13790 * the action to the proper SLI-3 or SLI-4 device suspend routine, which will
13791 * suspend the device.
13792 *
13793 * Return code
13794 * 0 - driver suspended the device
13795 * Error otherwise
13796 **/
13797 static int __maybe_unused
13799 {
13816 }
13818 }
13820 /**
13821 * lpfc_pci_resume_one - lpfc PCI func to resume dev for power management
13822 * @dev: pointer to device
13823 *
13824 * This routine is to be registered to the kernel's PCI subsystem to support
13825 * system Power Management (PM). When PM invokes this method, it dispatches
13826 * the action to the proper SLI-3 or SLI-4 device resume routine, which will
13827 * resume the device.
13828 *
13829 * Return code
13830 * 0 - driver suspended the device
13831 * Error otherwise
13832 **/
13833 static int __maybe_unused
13835 {
13852 }
13854 }
13856 /**
13857 * lpfc_io_error_detected - lpfc method for handling PCI I/O error
13858 * @pdev: pointer to PCI device.
13859 * @state: the current PCI connection state.
13860 *
13861 * This routine is registered to the PCI subsystem for error handling. This
13862 * function is called by the PCI subsystem after a PCI bus error affecting
13863 * this device has been detected. When this routine is invoked, it dispatches
13864 * the action to the proper SLI-3 or SLI-4 device error detected handling
13865 * routine, which will perform the proper error detected operation.
13866 *
13867 * Return codes
13868 * PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
13869 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
13870 **/
13871 static pci_ers_result_t
13873 {
13890 }
13892 }
13894 /**
13895 * lpfc_io_slot_reset - lpfc method for restart PCI dev from scratch
13896 * @pdev: pointer to PCI device.
13897 *
13898 * This routine is registered to the PCI subsystem for error handling. This
13899 * function is called after PCI bus has been reset to restart the PCI card
13900 * from scratch, as if from a cold-boot. When this routine is invoked, it
13901 * dispatches the action to the proper SLI-3 or SLI-4 device reset handling
13902 * routine, which will perform the proper device reset.
13903 *
13904 * Return codes
13905 * PCI_ERS_RESULT_RECOVERED - the device has been recovered
13906 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
13907 **/
13908 static pci_ers_result_t
13910 {
13927 }
13929 }
13931 /**
13932 * lpfc_io_resume - lpfc method for resuming PCI I/O operation
13933 * @pdev: pointer to PCI device
13934 *
13935 * This routine is registered to the PCI subsystem for error handling. It
13936 * is called when kernel error recovery tells the lpfc driver that it is
13937 * OK to resume normal PCI operation after PCI bus error recovery. When
13938 * this routine is invoked, it dispatches the action to the proper SLI-3
13939 * or SLI-4 device io_resume routine, which will resume the device operation.
13940 **/
13941 static void
13943 {
13959 }
13961 }
13963 /**
13964 * lpfc_sli4_oas_verify - Verify OAS is supported by this adapter
13965 * @phba: pointer to lpfc hba data structure.
13966 *
13967 * This routine checks to see if OAS is supported for this adapter. If
13968 * supported, the configure Flash Optimized Fabric flag is set. Otherwise,
13969 * the enable oas flag is cleared and the pool created for OAS device data
13970 * is destroyed.
13971 *
13972 **/
13973 static void
13975 {
13986 }
13989 }
13991 /**
13992 * lpfc_sli4_ras_init - Verify RAS-FW log is supported by this adapter
13993 * @phba: pointer to lpfc hba data structure.
13994 *
13995 * This routine checks to see if RAS is supported by the adapter. Check the
13996 * function through which RAS support enablement is to be done.
13997 **/
13998 void
14000 {
14008 else
14013 }
14014 }
14023 };
14026 lpfc_pci_suspend_one,
14027 lpfc_pci_resume_one);
14037 };
14041 };
14047 };
14049 /**
14050 * lpfc_init - lpfc module initialization routine
14051 *
14052 * This routine is to be invoked when the lpfc module is loaded into the
14053 * kernel. The special kernel macro module_init() is used to indicate the
14054 * role of this routine to the kernel as lpfc module entry point.
14055 *
14056 * Return codes
14057 * 0 - successful
14058 * -ENOMEM - FC attach transport failed
14059 * all others - failed
14060 */
14061 static int __init
14063 {
14077 lpfc_transport_template =
14081 lpfc_vport_transport_template =
14086 }
14090 /* Initialize in case vector mapping is needed */
14106 unwind:
14108 cpuhp_failure:
14111 unregister:
14115 }
14118 {
14144 else
14146 }
14147 }
14154 else
14158 temp_idx,
14162 }
14165 }
14169 {
14183 }
14185 DBG_LOG_SZ;
14194 }
14196 /**
14197 * lpfc_exit - lpfc module removal routine
14198 *
14199 * This routine is invoked when the lpfc module is removed from the kernel.
14200 * The special kernel macro module_exit() is used to indicate the role of
14201 * this routine to the kernel as lpfc module exit point.
14202 */
14203 static void __exit
14205 {
14212 }