lael-labs/linux

Documentation/ABI/testing/sysfs-driver-ufs+136−0

@@ -883,3 +883,139 @@ Contact: Subhash Jadavani <subhashj@codeaurora.org> · 882 unmodified lines
883	Description: This entry shows the target state of an UFS UIC link	883	Description: This entry shows the target state of an UFS UIC link
884	for the chosen system power management level.	884	for the chosen system power management level.
885	The file is read only.	885	The file is read only.
		886
		887	What: /sys/bus/platform/drivers/ufshcd/*/device_descriptor/wb_presv_us_en
		888	Date: June 2020
		889	Contact: Asutosh Das <asutoshd@codeaurora.org>
		890	Description: This entry shows if preserve user-space was configured
		891	The file is read only.
		892
		893	What: /sys/bus/platform/drivers/ufshcd/*/device_descriptor/wb_shared_alloc_units
		894	Date: June 2020
		895	Contact: Asutosh Das <asutoshd@codeaurora.org>
		896	Description: This entry shows the shared allocated units of WB buffer
		897	The file is read only.
		898
		899	What: /sys/bus/platform/drivers/ufshcd/*/device_descriptor/wb_type
		900	Date: June 2020
		901	Contact: Asutosh Das <asutoshd@codeaurora.org>
		902	Description: This entry shows the configured WB type.
		903	0x1 for shared buffer mode. 0x0 for dedicated buffer mode.
		904	The file is read only.
		905
		906	What: /sys/bus/platform/drivers/ufshcd/*/geometry_descriptor/wb_buff_cap_adj
		907	Date: June 2020
		908	Contact: Asutosh Das <asutoshd@codeaurora.org>
		909	Description: This entry shows the total user-space decrease in shared
		910	buffer mode.
		911	The value of this parameter is 3 for TLC NAND when SLC mode
		912	is used as WriteBooster Buffer. 2 for MLC NAND.
		913	The file is read only.
		914
		915	What: /sys/bus/platform/drivers/ufshcd/*/geometry_descriptor/wb_max_alloc_units
		916	Date: June 2020
		917	Contact: Asutosh Das <asutoshd@codeaurora.org>
		918	Description: This entry shows the Maximum total WriteBooster Buffer size
		919	which is supported by the entire device.
		920	The file is read only.
		921
		922	What: /sys/bus/platform/drivers/ufshcd/*/geometry_descriptor/wb_max_wb_luns
		923	Date: June 2020
		924	Contact: Asutosh Das <asutoshd@codeaurora.org>
		925	Description: This entry shows the maximum number of luns that can support
		926	WriteBooster.
		927	The file is read only.
		928
		929	What: /sys/bus/platform/drivers/ufshcd/*/geometry_descriptor/wb_sup_red_type
		930	Date: June 2020
		931	Contact: Asutosh Das <asutoshd@codeaurora.org>
		932	Description: The supportability of user space reduction mode
		933	and preserve user space mode.
		934	00h: WriteBooster Buffer can be configured only in
		935	user space reduction type.
		936	01h: WriteBooster Buffer can be configured only in
		937	preserve user space type.
		938	02h: Device can be configured in either user space
		939	reduction type or preserve user space type.
		940	The file is read only.
		941
		942	What: /sys/bus/platform/drivers/ufshcd/*/geometry_descriptor/wb_sup_wb_type
		943	Date: June 2020
		944	Contact: Asutosh Das <asutoshd@codeaurora.org>
		945	Description: The supportability of WriteBooster Buffer type.
		946	00h: LU based WriteBooster Buffer configuration
		947	01h: Single shared WriteBooster Buffer
		948	configuration
		949	02h: Supporting both LU based WriteBooster
		950	Buffer and Single shared WriteBooster Buffer
		951	configuration
		952	The file is read only.
		953
		954	What: /sys/bus/platform/drivers/ufshcd/*/flags/wb_enable
		955	Date: June 2020
		956	Contact: Asutosh Das <asutoshd@codeaurora.org>
		957	Description: This entry shows the status of WriteBooster.
		958	0: WriteBooster is not enabled.
		959	1: WriteBooster is enabled
		960	The file is read only.
		961
		962	What: /sys/bus/platform/drivers/ufshcd/*/flags/wb_flush_en
		963	Date: June 2020
		964	Contact: Asutosh Das <asutoshd@codeaurora.org>
		965	Description: This entry shows if flush is enabled.
		966	0: Flush operation is not performed.
		967	1: Flush operation is performed.
		968	The file is read only.
		969
		970	What: /sys/bus/platform/drivers/ufshcd/*/flags/wb_flush_during_h8
		971	Date: June 2020
		972	Contact: Asutosh Das <asutoshd@codeaurora.org>
		973	Description: Flush WriteBooster Buffer during hibernate state.
		974	0: Device is not allowed to flush the
		975	WriteBooster Buffer during link hibernate
		976	state.
		977	1: Device is allowed to flush the
		978	WriteBooster Buffer during link hibernate
		979	state
		980	The file is read only.
		981
		982	What: /sys/bus/platform/drivers/ufshcd/*/attributes/wb_avail_buf
		983	Date: June 2020
		984	Contact: Asutosh Das <asutoshd@codeaurora.org>
		985	Description: This entry shows the amount of unused WriteBooster buffer
		986	available.
		987	The file is read only.
		988
		989	What: /sys/bus/platform/drivers/ufshcd/*/attributes/wb_cur_buf
		990	Date: June 2020
		991	Contact: Asutosh Das <asutoshd@codeaurora.org>
		992	Description: This entry shows the amount of unused current buffer.
		993	The file is read only.
		994
		995	What: /sys/bus/platform/drivers/ufshcd/*/attributes/wb_flush_status
		996	Date: June 2020
		997	Contact: Asutosh Das <asutoshd@codeaurora.org>
		998	Description: This entry shows the flush operation status.
		999	00h: idle
		1000	01h: Flush operation in progress
		1001	02h: Flush operation stopped prematurely.
		1002	03h: Flush operation completed successfully
		1003	04h: Flush operation general failure
		1004	The file is read only.
		1005
		1006	What: /sys/bus/platform/drivers/ufshcd/*/attributes/wb_life_time_est
		1007	Date: June 2020
		1008	Contact: Asutosh Das <asutoshd@codeaurora.org>
		1009	Description: This entry shows an indication of the WriteBooster Buffer
		1010	lifetime based on the amount of performed program/erase cycles
		1011	01h: 0% - 10% WriteBooster Buffer life time used
		1012	...
		1013	0Ah: 90% - 100% WriteBooster Buffer life time used
		1014	The file is read only.
		1015
		1016	What: /sys/class/scsi_device/*/device/unit_descriptor/wb_buf_alloc_units
		1017	Date: June 2020
		1018	Contact: Asutosh Das <asutoshd@codeaurora.org>
		1019	Description: This entry shows the configured size of WriteBooster buffer.
		1020	0400h corresponds to 4GB.
		1021	The file is read only.

Documentation/scsi/advansys.rst+1−1

@@ -125,7 +125,7 @@ The following constants can be defined in the source file. · 124 unmodified lines
125	c. klogd is started with the appropriate -c parameter	125	c. klogd is started with the appropriate -c parameter
126	(e.g. klogd -c 8)	126	(e.g. klogd -c 8)
127		127
128	This will cause printk() messages to be be displayed on the	128	This will cause printk() messages to be displayed on the
129	current console. Refer to the klogd(8) and syslogd(8) man pages	129	current console. Refer to the klogd(8) and syslogd(8) man pages
130	for details.	130	for details.
131		131

Documentation/scsi/scsi-parameters.rst+1−1

@@ -94,7 +94,7 @@ parameters may be changed at runtime by the command · 93 unmodified lines
94	(/proc/sys/dev/scsi/logging_level).	94	(/proc/sys/dev/scsi/logging_level).
95	There is also a nice 'scsi_logging_level' script in the	95	There is also a nice 'scsi_logging_level' script in the
96	S390-tools package, available for download at	96	S390-tools package, available for download at
97	http://www-128.ibm.com/developerworks/linux/linux390/s390-tools-1.5.4.html	97	https://github.com/ibm-s390-tools/s390-tools/blob/master/scripts/scsi_logging_level
98		98
99	scsi_mod.scan= [SCSI] sync (default) scans SCSI busses as they are	99	scsi_mod.scan= [SCSI] sync (default) scans SCSI busses as they are
100	discovered. async scans them in kernel threads,	100	discovered. async scans them in kernel threads,

MAINTAINERS+1−1

@@ -2309,7 +2309,7 @@ F: drivers/pci/controller/dwc/pcie-qcom.c · 2308 unmodified lines
2309	F: drivers/phy/qualcomm/	2309	F: drivers/phy/qualcomm/
2310	F: drivers/power//msm	2310	F: drivers/power//msm
2311	F: drivers/reset/reset-qcom-*	2311	F: drivers/reset/reset-qcom-*
2312	F: drivers/scsi/ufs/ufs-qcom.*	2312	F: drivers/scsi/ufs/ufs-qcom*
2313	F: drivers/spi/spi-geni-qcom.c	2313	F: drivers/spi/spi-geni-qcom.c
2314	F: drivers/spi/spi-qcom-qspi.c	2314	F: drivers/spi/spi-qcom-qspi.c
2315	F: drivers/spi/spi-qup.c	2315	F: drivers/spi/spi-qup.c

block/blk-pm.c+22−19

@@ -164,9 +164,8 @@ EXPORT_SYMBOL(blk_pre_runtime_resume); · 163 unmodified lines
164	*	164	*
165	* Description:	165	* Description:
166	* Update the queue's runtime status according to the return value of the	166	* Update the queue's runtime status according to the return value of the
167	* device's runtime_resume function. If it is successfully resumed, process	167	* device's runtime_resume function. If the resume was successful, call
168	* the requests that are queued into the device's queue when it is resuming	168	* blk_set_runtime_active() to do the real work of restarting the queue.
169	* and then mark last busy and initiate autosuspend for it.
170	*	169	*
171	* This function should be called near the end of the device's	170	* This function should be called near the end of the device's
172	* runtime_resume callback.	171	* runtime_resume callback.
@@ -175,19 +174,13 @@ void blk_post_runtime_resume(struct request_queue *q, int err) · 2 unmodified lines
175	{	174	{
176	if (!q->dev)	175	if (!q->dev)
177	return;	176	return;
178
179	spin_lock_irq(&q->queue_lock);
180	if (!err) {	177	if (!err) {
181	q->rpm_status = RPM_ACTIVE;	178	blk_set_runtime_active(q);
182	pm_runtime_mark_last_busy(q->dev);
183	pm_request_autosuspend(q->dev);
184	} else {	179	} else {
		180	spin_lock_irq(&q->queue_lock);
185	q->rpm_status = RPM_SUSPENDED;	181	q->rpm_status = RPM_SUSPENDED;
		182	spin_unlock_irq(&q->queue_lock);
186	}	183	}
187	spin_unlock_irq(&q->queue_lock);
188
189	if (!err)
190	blk_clear_pm_only(q);
191	}	184	}
192	EXPORT_SYMBOL(blk_post_runtime_resume);	185	EXPORT_SYMBOL(blk_post_runtime_resume);
193		186
@@ -204,15 +197,25 @@ EXPORT_SYMBOL(blk_post_runtime_resume); · 10 unmodified lines
204	* This function can be used in driver's resume hook to correct queue	197	* This function can be used in driver's resume hook to correct queue
205	* runtime PM status and re-enable peeking requests from the queue. It	198	* runtime PM status and re-enable peeking requests from the queue. It
206	* should be called before first request is added to the queue.	199	* should be called before first request is added to the queue.
		200	*
		201	* This function is also called by blk_post_runtime_resume() for successful
		202	* runtime resumes. It does everything necessary to restart the queue.
207	*/	203	*/
208	void blk_set_runtime_active(struct request_queue *q)	204	void blk_set_runtime_active(struct request_queue *q)
209	{	205	{
210	if (q->dev) {	206	int old_status;
211	spin_lock_irq(&q->queue_lock);	207
212	q->rpm_status = RPM_ACTIVE;	208	if (!q->dev)
213	pm_runtime_mark_last_busy(q->dev);	209	return;
214	pm_request_autosuspend(q->dev);	210
215	spin_unlock_irq(&q->queue_lock);	211	spin_lock_irq(&q->queue_lock);
216	}	212	old_status = q->rpm_status;
		213	q->rpm_status = RPM_ACTIVE;
		214	pm_runtime_mark_last_busy(q->dev);
		215	pm_request_autosuspend(q->dev);
		216	spin_unlock_irq(&q->queue_lock);
		217
		218	if (old_status != RPM_ACTIVE)
		219	blk_clear_pm_only(q);
217	}	220	}
218	EXPORT_SYMBOL(blk_set_runtime_active);	221	EXPORT_SYMBOL(blk_set_runtime_active);

drivers/firmware/qcom_scm.c+101−0

@@ -922,6 +922,107 @@ int qcom_scm_ocmem_unlock(enum qcom_scm_ocmem_client id, u32 offset, u32 size) · 921 unmodified lines
922	}	922	}
923	EXPORT_SYMBOL(qcom_scm_ocmem_unlock);	923	EXPORT_SYMBOL(qcom_scm_ocmem_unlock);
924		924
		925	/**
		926	* qcom_scm_ice_available() - Is the ICE key programming interface available?
		927	*
		928	* Return: true iff the SCM calls wrapped by qcom_scm_ice_invalidate_key() and
		929	* qcom_scm_ice_set_key() are available.
		930	*/
		931	bool qcom_scm_ice_available(void)
		932	{
		933	return __qcom_scm_is_call_available(__scm->dev, QCOM_SCM_SVC_ES,
		934	QCOM_SCM_ES_INVALIDATE_ICE_KEY) &&
		935	__qcom_scm_is_call_available(__scm->dev, QCOM_SCM_SVC_ES,
		936	QCOM_SCM_ES_CONFIG_SET_ICE_KEY);
		937	}
		938	EXPORT_SYMBOL(qcom_scm_ice_available);
		939
		940	/**
		941	* qcom_scm_ice_invalidate_key() - Invalidate an inline encryption key
		942	* @index: the keyslot to invalidate
		943	*
		944	* The UFSHCI standard defines a standard way to do this, but it doesn't work on
		945	* these SoCs; only this SCM call does.
		946	*
		947	* Return: 0 on success; -errno on failure.
		948	*/
		949	int qcom_scm_ice_invalidate_key(u32 index)
		950	{
		951	struct qcom_scm_desc desc = {
		952	.svc = QCOM_SCM_SVC_ES,
		953	.cmd = QCOM_SCM_ES_INVALIDATE_ICE_KEY,
		954	.arginfo = QCOM_SCM_ARGS(1),
		955	.args[0] = index,
		956	.owner = ARM_SMCCC_OWNER_SIP,
		957	};
		958
		959	return qcom_scm_call(__scm->dev, &desc, NULL);
		960	}
		961	EXPORT_SYMBOL(qcom_scm_ice_invalidate_key);
		962
		963	/**
		964	* qcom_scm_ice_set_key() - Set an inline encryption key
		965	* @index: the keyslot into which to set the key
		966	* @key: the key to program
		967	* @key_size: the size of the key in bytes
		968	* @cipher: the encryption algorithm the key is for
		969	* @data_unit_size: the encryption data unit size, i.e. the size of each
		970	* individual plaintext and ciphertext. Given in 512-byte
		971	* units, e.g. 1 = 512 bytes, 8 = 4096 bytes, etc.
		972	*
		973	* Program a key into a keyslot of Qualcomm ICE (Inline Crypto Engine), where it
		974	* can then be used to encrypt/decrypt UFS I/O requests inline.
		975	*
		976	* The UFSHCI standard defines a standard way to do this, but it doesn't work on
		977	* these SoCs; only this SCM call does.
		978	*
		979	* Return: 0 on success; -errno on failure.
		980	*/
		981	int qcom_scm_ice_set_key(u32 index, const u8 *key, u32 key_size,
		982	enum qcom_scm_ice_cipher cipher, u32 data_unit_size)
		983	{
		984	struct qcom_scm_desc desc = {
		985	.svc = QCOM_SCM_SVC_ES,
		986	.cmd = QCOM_SCM_ES_CONFIG_SET_ICE_KEY,
		987	.arginfo = QCOM_SCM_ARGS(5, QCOM_SCM_VAL, QCOM_SCM_RW,
		988	QCOM_SCM_VAL, QCOM_SCM_VAL,
		989	QCOM_SCM_VAL),
		990	.args[0] = index,
		991	.args[2] = key_size,
		992	.args[3] = cipher,
		993	.args[4] = data_unit_size,
		994	.owner = ARM_SMCCC_OWNER_SIP,
		995	};
		996	void *keybuf;
		997	dma_addr_t key_phys;
		998	int ret;
		999
		1000	/*
		1001	* 'key' may point to vmalloc()'ed memory, but we need to pass a
		1002	* physical address that's been properly flushed. The sanctioned way to
		1003	* do this is by using the DMA API. But as is best practice for crypto
		1004	* keys, we also must wipe the key after use. This makes kmemdup() +
		1005	* dma_map_single() not clearly correct, since the DMA API can use
		1006	* bounce buffers. Instead, just use dma_alloc_coherent(). Programming
		1007	* keys is normally rare and thus not performance-critical.
		1008	*/
		1009
		1010	keybuf = dma_alloc_coherent(__scm->dev, key_size, &key_phys,
		1011	GFP_KERNEL);
		1012	if (!keybuf)
		1013	return -ENOMEM;
		1014	memcpy(keybuf, key, key_size);
		1015	desc.args[1] = key_phys;
		1016
		1017	ret = qcom_scm_call(__scm->dev, &desc, NULL);
		1018
		1019	memzero_explicit(keybuf, key_size);
		1020
		1021	dma_free_coherent(__scm->dev, key_size, keybuf, key_phys);
		1022	return ret;
		1023	}
		1024	EXPORT_SYMBOL(qcom_scm_ice_set_key);
		1025
925	/**	1026	/**
926	* qcom_scm_hdcp_available() - Check if secure environment supports HDCP.	1027	* qcom_scm_hdcp_available() - Check if secure environment supports HDCP.
927	*	1028	*

drivers/firmware/qcom_scm.h+4−0

@@ -103,6 +103,10 @@ extern int scm_legacy_call(struct device dev, const struct qcom_scm_desc desc, · 102 unmodified lines
103	#define QCOM_SCM_OCMEM_LOCK_CMD 0x01	103	#define QCOM_SCM_OCMEM_LOCK_CMD 0x01
104	#define QCOM_SCM_OCMEM_UNLOCK_CMD 0x02	104	#define QCOM_SCM_OCMEM_UNLOCK_CMD 0x02
105		105
		106	#define QCOM_SCM_SVC_ES 0x10 /* Enterprise Security */
		107	#define QCOM_SCM_ES_INVALIDATE_ICE_KEY 0x03
		108	#define QCOM_SCM_ES_CONFIG_SET_ICE_KEY 0x04
		109
106	#define QCOM_SCM_SVC_HDCP 0x11	110	#define QCOM_SCM_SVC_HDCP 0x11
107	#define QCOM_SCM_HDCP_INVOKE 0x01	111	#define QCOM_SCM_HDCP_INVOKE 0x01
108		112

drivers/s390/scsi/zfcp_ccw.c+3−4

 		return;
 	write_lock_irq(&adapter->port_list_lock);
-	list_for_each_entry_safe(port, p, &adapter->port_list, list) {
+	list_for_each_entry(port, &adapter->port_list, list) {
 		write_lock(&port->unit_list_lock);
-		list_for_each_entry_safe(unit, u, &port->unit_list, list)
+		list_splice_init(&port->unit_list, &unit_remove_lh);
-			list_move(&unit->list, &unit_remove_lh);
 		write_unlock(&port->unit_list_lock);
-		list_move(&port->list, &port_remove_lh);
 	}
+	list_splice_init(&adapter->port_list, &port_remove_lh);
 	write_unlock_irq(&adapter->port_list_lock);
 	zfcp_ccw_adapter_put(adapter); /* put from zfcp_ccw_adapter_by_cdev */

drivers/s390/scsi/zfcp_erp.c+1−1

@@ -68,7 +68,7 @@ static void zfcp_erp_action_ready(struct zfcp_erp_action *act) · 67 unmodified lines
68	{	68	{
69	struct zfcp_adapter *adapter = act->adapter;	69	struct zfcp_adapter *adapter = act->adapter;
70		70
71	list_move(&act->list, &act->adapter->erp_ready_head);	71	list_move(&act->list, &adapter->erp_ready_head);
72	zfcp_dbf_rec_run("erardy1", act);	72	zfcp_dbf_rec_run("erardy1", act);
73	wake_up(&adapter->erp_ready_wq);	73	wake_up(&adapter->erp_ready_wq);
74	zfcp_dbf_rec_run("erardy2", act);	74	zfcp_dbf_rec_run("erardy2", act);

drivers/s390/scsi/zfcp_fc.c+1−1

@@ -48,7 +48,7 @@ unsigned int zfcp_fc_port_scan_backoff(void) · 47 unmodified lines
48	{	48	{
49	if (!port_scan_backoff)	49	if (!port_scan_backoff)
50	return 0;	50	return 0;
51	return get_random_int() % port_scan_backoff;	51	return prandom_u32_max(port_scan_backoff);
52	}	52	}
53		53
54	static void zfcp_fc_port_scan_time(struct zfcp_adapter *adapter)	54	static void zfcp_fc_port_scan_time(struct zfcp_adapter *adapter)

drivers/s390/scsi/zfcp_qdio.c+5−2

 }
 /**
- * zfcp_qdio_send - set PCI flag in first SBALE and send req to QDIO
+ * zfcp_qdio_send - send req to QDIO
  * @qdio: pointer to struct zfcp_qdio
  * @q_req: pointer to struct zfcp_qdio_req
  * Returns: 0 on success, error otherwise
 	zfcp_qdio_account(qdio);
 	spin_unlock(&qdio->stat_lock);
+	atomic_sub(sbal_number, &qdio->req_q_free);
 	retval = do_QDIO(qdio->adapter->ccw_device, QDIO_FLAG_SYNC_OUTPUT, 0,
 			 q_req->sbal_first, sbal_number);
 	if (unlikely(retval)) {
+		/* Failed to submit the IO, roll back our modifications. */
+		atomic_add(sbal_number, &qdio->req_q_free);
 		zfcp_qdio_zero_sbals(qdio->req_q, q_req->sbal_first,
 				     sbal_number);
 		return retval;
 	}
 	/* account for transferred buffers */
-	atomic_sub(sbal_number, &qdio->req_q_free);
 	qdio->req_q_idx += sbal_number;
 	qdio->req_q_idx %= QDIO_MAX_BUFFERS_PER_Q;

drivers/scsi/Kconfig+11−5

@@ -1154,6 +1154,7 @@ source "drivers/scsi/qedf/Kconfig" · 1153 unmodified lines
1154	config SCSI_LPFC	1154	config SCSI_LPFC
1155	tristate "Emulex LightPulse Fibre Channel Support"	1155	tristate "Emulex LightPulse Fibre Channel Support"
1156	depends on PCI && SCSI	1156	depends on PCI && SCSI
		1157	depends on CPU_FREQ
1157	depends on SCSI_FC_ATTRS	1158	depends on SCSI_FC_ATTRS
1158	depends on NVME_TARGET_FC \|\| NVME_TARGET_FC=n	1159	depends on NVME_TARGET_FC \|\| NVME_TARGET_FC=n
1159	depends on NVME_FC \|\| NVME_FC=n	1160	depends on NVME_FC \|\| NVME_FC=n
@@ -1469,14 +1470,19 @@ config SCSI_SUNESP · 309 unmodified lines
1469	module will be called sun_esp.	1470	module will be called sun_esp.
1470		1471
1471	config ZFCP	1472	config ZFCP
1472	tristate "FCP host bus adapter driver for IBM eServer zSeries"	1473	tristate "FCP host bus adapter driver for IBM mainframes"
1473	depends on S390 && QDIO && SCSI	1474	depends on S390 && QDIO && SCSI
1474	depends on SCSI_FC_ATTRS	1475	depends on SCSI_FC_ATTRS
1475	help	1476	help
1476	If you want to access SCSI devices attached to your IBM eServer	1477	If you want to access SCSI devices attached to your IBM mainframe by
1477	zSeries by means of Fibre Channel interfaces say Y.	1478	means of Fibre Channel Protocol host bus adapters say Y.
1478	For details please refer to the documentation provided by IBM at	1479
1479	<http://oss.software.ibm.com/developerworks/opensource/linux390>	1480	Supported HBAs include different models of the FICON Express and FCP
		1481	Express I/O cards.
		1482
		1483	For a more complete list, and for more details about setup and
		1484	operation refer to the IBM publication "Device Drivers, Features, and
		1485	Commands", SC33-8411.
1480		1486
1481	This driver is also available as a module. This module will be	1487	This driver is also available as a module. This module will be
1482	called zfcp. If you want to compile it as a module, say M here	1488	called zfcp. If you want to compile it as a module, say M here

drivers/scsi/aacraid/aachba.c+6−16

 /**
  *	aac_get_config_status	-	check the adapter configuration
- *	@common: adapter to query
+ *	@dev: aac driver data
+ *	@commit_flag: force sending CT_COMMIT_CONFIG
  *
  *	Query config status, and commit the configuration if needed.
  */
 /**
  *	aac_get_containers	-	list containers
- *	@common: adapter to probe
+ *	@dev: aac driver data
  *
  *	Make a list of all containers on this controller
  */
 	scsicmd->scsi_done(scsicmd);
 }
-/**
+/*
  *	aac_get_container_name	-	get container name, none blocking.
  */
 static int aac_get_container_name(struct scsi_cmnd * scsicmd)
 /**
  *	aac_probe_container		-	query a logical volume
- *	@dev: device to query
+ * @scsicmd: the scsi command block
- *	@cid: container identifier
  *
  *	Queries the controller about the given volume. The volume information
  *	is updated in the struct fsa_dev_info structure rather than returned.
 	scsicmd->scsi_done(scsicmd);
 }
-/**
+/*
  *	aac_get_container_serial - get container serial, none blocking.
  */
 static int aac_get_container_serial(struct scsi_cmnd * scsicmd)
 /**
  *	aac_set_safw_attr_all_targets-	update current hba map with data from FW
  *	@dev:	aac_dev structure
- *	@phys_luns: FW information from report phys luns
- *	@rescan: Indicates scan type
  *
  *	Update our hba map with the information gathered from the FW
  */
 }
 /**
- *
  * aac_srb_callback
  * @context: the context set in the fib - here it is scsi cmd
  * @fibptr: pointer to the fib
  *
  * Handles the completion of a scsi command to a non dasd device
- *
  */
 static void aac_srb_callback(void *context, struct fib * fibptr)
 {
 	struct aac_srb_reply *srbreply;
 }
 /**
- *
  * aac_hba_callback
  * @context: the context set in the fib - here it is scsi cmd
  * @fibptr: pointer to the fib
  *
  * Handles the completion of a native HBA scsi command
- *
  */
 void aac_hba_callback(void *context, struct fib *fibptr)
 {
 }
 /**
- *
  * aac_send_srb_fib
  * @scsicmd: the scsi command block
  *
  * This routine will form a FIB and fill in the aac_srb from the
  * scsicmd passed in.
  */
 static int aac_send_srb_fib(struct scsi_cmnd* scsicmd)
 {
 	struct fib* cmd_fibcontext;
 }
 /**
- *
  * aac_send_hba_fib
  * @scsicmd: the scsi command block
  *

drivers/scsi/aacraid/commctrl.c+6−8

 #include "aacraid.h"
+# define AAC_DEBUG_PREAMBLE	KERN_INFO
+# define AAC_DEBUG_POSTAMBLE
 /**
  *	ioctl_send_fib	-	send a FIB from userspace
  *	@dev:	adapter is being processed
  *	This routine sends a fib to the adapter on behalf of a user level
  *	program.
  */
-# define AAC_DEBUG_PREAMBLE	KERN_INFO
-# define AAC_DEBUG_POSTAMBLE
 static int ioctl_send_fib(struct aac_dev * dev, void __user *arg)
 {
 	struct hw_fib * kfib;
 /**
  *	open_getadapter_fib	-	Get the next fib
+ *	@dev:	adapter is being processed
+ *	@arg:	arguments to the open call
  *
  *	This routine will get the next Fib, if available, from the AdapterFibContext
  *	passed in from the user.
  */
 static int open_getadapter_fib(struct aac_dev * dev, void __user *arg)
 {
 	struct aac_fib_context * fibctx;
  *	This routine will get the next Fib, if available, from the AdapterFibContext
  *	passed in from the user.
  */
 static int next_getadapter_fib(struct aac_dev * dev, void __user *arg)
 {
 	struct fib_ioctl f;
 /**
- *
  * aac_send_raw_scb
- *
+ *	@dev:	adapter is being processed
+ *	@arg:	arguments to the send call
  */
 static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
 {
 	struct fib* srbfib;

drivers/scsi/aacraid/commsup.c+6−6

 /**
  *	aac_fib_alloc_tag-allocate a fib using tags
  *	@dev: Adapter to allocate the fib for
+ *	@scmd: SCSI command
  *
  *	Allocate a fib from the adapter fib pool using tags
  *	from the blk layer.
  *	aac_queue_get		-	get the next free QE
  *	@dev: Adapter
  *	@index: Returned index
- *	@priority: Priority of fib
+ *	@qid: Queue number
- *	@fib: Fib to associate with the queue entry
+ *	@hw_fib: Fib to associate with the queue entry
  *	@wait: Wait if queue full
  *	@fibptr: Driver fib object to go with fib
  *	@nonotify: Don't notify the adapter
 /**
  *	aac_fib_complete	-	fib completion handler
- *	@fib: FIB to complete
+ *	@fibptr: FIB to complete
  *
  *	Will do all necessary work to complete a FIB.
  */
 	}
 }
+#define AIF_SNIFF_TIMEOUT	(500*HZ)
 /**
  *	aac_handle_aif		-	Handle a message from the firmware
  *	@dev: Which adapter this fib is from
  *	This routine handles a driver notify fib from the adapter and
  *	dispatches it to the appropriate routine for handling.
  */
-#define AIF_SNIFF_TIMEOUT	(500*HZ)
 static void aac_handle_aif(struct aac_dev * dev, struct fib * fibptr)
 {
 	struct hw_fib * hw_fib = fibptr->hw_fib_va;
 /**
  *	aac_command_thread	-	command processing thread
- *	@dev: Adapter to monitor
+ *	@data: Adapter to monitor
  *
  *	Waits on the commandready event in it's queue. When the event gets set
  *	it will pull FIBs off it's queue. It will continue to pull FIBs off

drivers/scsi/aacraid/dpcsup.c+8−7

 		}
 		if (hwfib->header.XferState & cpu_to_le32(NoResponseExpected | Async))
 		{
-	        	if (hwfib->header.XferState & cpu_to_le32(NoResponseExpected))
+			if (hwfib->header.XferState & cpu_to_le32(NoResponseExpected)) {
 				FIB_COUNTER_INCREMENT(aac_config.NoResponseRecved);
-			else
+			} else {
 				FIB_COUNTER_INCREMENT(aac_config.AsyncRecved);
+			}
 			/*
 			 *	NOTE:  we cannot touch the fib after this
 			 *	    call, because it may have been deallocated.
 	struct fib *fibctx;
 	struct aac_dev *dev;
 	struct aac_aifcmd *cmd;
-	int status;
 	fibctx = (struct fib *)context;
 	BUG_ON(fibptr == NULL);
 	cmd = (struct aac_aifcmd *) fib_data(fibctx);
 	cmd->command = cpu_to_le32(AifReqEvent);
-	status = aac_fib_send(AifRequest,
+	aac_fib_send(AifRequest,
 		fibctx,
 		sizeof(struct hw_fib)-sizeof(struct aac_fibhdr),
 		FsaNormal,
 }
-/**
+/*
  *	aac_intr_normal	-	Handle command replies
  *	@dev: Device
  *	@index: completion reference
 			if (hwfib->header.XferState &
 				cpu_to_le32(NoResponseExpected | Async)) {
 				if (hwfib->header.XferState & cpu_to_le32(
-					NoResponseExpected))
+					NoResponseExpected)) {
 					FIB_COUNTER_INCREMENT(
 						aac_config.NoResponseRecved);
-				else
+				} else {
 					FIB_COUNTER_INCREMENT(
 						aac_config.AsyncRecved);
+				}
 				start_callback = 1;
 			} else {
 				unsigned long flagv;

drivers/scsi/aacraid/linit.c+3−3

 /**
  *	aac_queuecommand	-	queue a SCSI command
+ *	@shost:		Scsi host to queue command on
  *	@cmd:		SCSI command to queue
- *	@done:		Function to call on command completion
  *
  *	Queues a command for execution by the associated Host Adapter.
  *
 		param->cylinders = cap_to_cyls(capacity, param->heads * param->sectors);
 		if (num < 4 && end_sec == param->sectors) {
-			if (param->cylinders != saved_cylinders)
+			if (param->cylinders != saved_cylinders) {
 				dprintk((KERN_DEBUG "Adopting geometry: heads=%d, sectors=%d from partition table %d.\n",
 					param->heads, param->sectors, num));
+			}
 		} else if (end_head > 0 || end_sec > 0) {
 			dprintk((KERN_DEBUG "Strange geometry: heads=%d, sectors=%d in partition table %d.\n",
 				end_head + 1, end_sec, num));
 /**
  *	aac_cfg_ioctl		-	AAC configuration request
- *	@inode: inode of device
  *	@file: file handle
  *	@cmd: ioctl command code
  *	@arg: argument

drivers/scsi/aacraid/nark.c+1−0

@@ -24,6 +24,7 @@ · 23 unmodified lines
24		24
25	/**	25	/**
26	* aac_nark_ioremap	26	* aac_nark_ioremap
		27	* @dev: device to ioremap
27	* @size: mapping resize request	28	* @size: mapping resize request
28	*	29	*
29	*/	30	*/

drivers/scsi/aacraid/rkt.c+3−2

 /**
  *	aac_rkt_ioremap
+ *	@dev: device to ioremap
  *	@size: mapping resize request
  *
  */
  *	aac_rkt_init	-	initialize an i960 based AAC card
  *	@dev: device to configure
  *
  *	Allocate and set up resources for the i960 based AAC variants. The
  *	device_interface in the commregion will be allocated and linked
  *	to the comm region.
  */

drivers/scsi/aacraid/rx.c+11−1

  *	@dev: Adapter
  *	@command: Command to execute
  *	@p1: first parameter
- *	@ret: adapter status
+ *	@p2: second parameter
+ *	@p3: third parameter
+ *	@p4: forth parameter
+ *	@p5: fifth parameter
+ *	@p6: sixth parameter
+ *	@status: adapter status
+ *	@r1: first return value
+ *	@r2: second return value
+ *	@r3: third return value
+ *	@r4: forth return value
  *
  *	This routine will send a synchronous command to the adapter and wait
  *	for its	completion.
 /**
  *	aac_rx_ioremap
+ *	@dev: adapter
  *	@size: mapping resize request
  *
  */

drivers/scsi/aacraid/sa.c+14−5

@@ -135,13 +135,21 @@ static void aac_sa_notify_adapter(struct aac_dev *dev, u32 event) · 134 unmodified lines
135	* @dev: Adapter	135	* @dev: Adapter
136	* @command: Command to execute	136	* @command: Command to execute
137	* @p1: first parameter	137	* @p1: first parameter
		138	* @p2: second parameter
		139	* @p3: third parameter
		140	* @p4: forth parameter
		141	* @p5: fifth parameter
		142	* @p6: sixth parameter
138	* @ret: adapter status	143	* @ret: adapter status
		144	* @r1: first return value
		145	* @r2: second return value
		146	* @r3: third return value
		147	* @r4: forth return value
139	*	148	*
140	* This routine will send a synchronous command to the adapter and wait	149	* This routine will send a synchronous command to the adapter and wait
141	* for its completion.	150	* for its completion.
142	*/	151	*/
143		152	static int sa_sync_cmd(struct aac_dev *dev, u32 command,
144	static int sa_sync_cmd(struct aac_dev *dev, u32 command,
145	u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6,	153	u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6,
146	u32 ret, u32 r1, u32 r2, u32 r3, u32 *r4)	154	u32 ret, u32 r1, u32 r2, u32 r3, u32 *r4)
147	{	155	{
@@ -283,6 +291,7 @@ static int aac_sa_check_health(struct aac_dev *dev) · 135 unmodified lines
283		291
284	/**	292	/**
285	* aac_sa_ioremap	293	* aac_sa_ioremap
		294	* @dev: device to ioremap
286	* @size: mapping resize request	295	* @size: mapping resize request
287	*	296	*
288	*/	297	*/
@@ -300,8 +309,8 @@ static int aac_sa_ioremap(struct aac_dev * dev, u32 size) · 11 unmodified lines
300	* aac_sa_init - initialize an ARM based AAC card	309	* aac_sa_init - initialize an ARM based AAC card
301	* @dev: device to configure	310	* @dev: device to configure
302	*	311	*
303	* Allocate and set up resources for the ARM based AAC variants. The	312	* Allocate and set up resources for the ARM based AAC variants. The
304	* device_interface in the commregion will be allocated and linked	313	* device_interface in the commregion will be allocated and linked
305	* to the comm region.	314	* to the comm region.
306	*/	315	*/
307		316

drivers/scsi/aacraid/src.c+12−1

  *	@dev: Adapter
  *	@command: Command to execute
  *	@p1: first parameter
- *	@ret: adapter status
+ *	@p2: second parameter
+ *	@p3: third parameter
+ *	@p4: forth parameter
+ *	@p5: fifth parameter
+ *	@p6: sixth parameter
+ *	@status: adapter status
+ *	@r1: first return value
+ *	@r2: second return valu
+ *	@r3: third return value
+ *	@r4: forth return value
  *
  *	This routine will send a synchronous command to the adapter and wait
  *	for its	completion.
 /**
  *	aac_src_ioremap
+ *	@dev: device ioremap
  *	@size: mapping resize request
  *
  */
 /**
  *  aac_srcv_ioremap
+ *	@dev: device ioremap
  *	@size: mapping resize request
  *
  */

drivers/scsi/aha152x.c+1−2

 				    fifodata, GETPORT(FIFOSTAT));
 			SETPORT(DMACNTRL0, ENDMA|_8BIT);
 			while(fifodata>0) {
-				int data;
+				GETPORT(DATAPORT);
-				data=GETPORT(DATAPORT);
 				fifodata--;
 				DATA_LEN++;
 			}

drivers/scsi/aic7xxx/aic79xx_core.c+3−17

 			sg_list = (struct ahd_dma64_seg*)scb->sg_list;
 			for (i = 0; i < scb->sg_count; i++) {
 				uint64_t addr;
-				uint32_t len;
 				addr = ahd_le64toh(sg_list[i].addr);
-				len = ahd_le32toh(sg_list[i].len);
 				printk("sg[%d] - Addr 0x%x%x : Length %d%s\n",
 				       i,
 				       (uint32_t)((addr >> 32) & 0xFFFFFFFF),
 		{
 			struct	ahd_devinfo devinfo;
 			struct	scb *scb;
-			struct	ahd_initiator_tinfo *targ_info;
-			struct	ahd_tmode_tstate *tstate;
-			struct	ahd_transinfo *tinfo;
 			u_int	scbid;
 			/*
 					    SCB_GET_LUN(scb),
 					    SCB_GET_CHANNEL(ahd, scb),
 					    ROLE_INITIATOR);
-			targ_info = ahd_fetch_transinfo(ahd,
-							devinfo.channel,
-							devinfo.our_scsiid,
-							devinfo.target,
-							&tstate);
-			tinfo = &targ_info->curr;
 			ahd_set_width(ahd, &devinfo, MSG_EXT_WDTR_BUS_8_BIT,
 				      AHD_TRANS_ACTIVE, /*paused*/TRUE);
 			ahd_set_syncrate(ahd, &devinfo, /*period*/0,
 	struct	scb *scb;
 	u_int	scbid;
 	u_int	lqistat1;
-	u_int	lqistat2;
 	u_int	msg_out;
 	u_int	curphase;
 	u_int	lastphase;
 	scb = NULL;
 	ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
 	lqistat1 = ahd_inb(ahd, LQISTAT1) & ~(LQIPHASE_LQ|LQIPHASE_NLQ);
-	lqistat2 = ahd_inb(ahd, LQISTAT2);
+	ahd_inb(ahd, LQISTAT2);
 	if ((lqistat1 & (LQICRCI_NLQ|LQICRCI_LQ)) == 0
 	 && (ahd->bugs & AHD_NLQICRC_DELAYED_BUG) != 0) {
 		u_int lqistate;
 	pending_scb_count = 0;
 	LIST_FOREACH(pending_scb, &ahd->pending_scbs, pending_links) {
 		struct ahd_devinfo devinfo;
-		struct ahd_initiator_tinfo *tinfo;
 		struct ahd_tmode_tstate *tstate;
 		ahd_scb_devinfo(ahd, &devinfo, pending_scb);
-		tinfo = ahd_fetch_transinfo(ahd, devinfo.channel,
+		ahd_fetch_transinfo(ahd, devinfo.channel, devinfo.our_scsiid,
-					    devinfo.our_scsiid,
+				    devinfo.target, &tstate);
-					    devinfo.target, &tstate);
 		if ((tstate->auto_negotiate & devinfo.target_mask) == 0
 		 && (pending_scb->flags & SCB_AUTO_NEGOTIATE) != 0) {
 			pending_scb->flags &= ~SCB_AUTO_NEGOTIATE;

drivers/scsi/aic7xxx/aic79xx_osm.c+10−23

@@ -700,9 +700,6 @@ ahd_linux_slave_alloc(struct scsi_device *sdev) · 699 unmodified lines
700	static int	700	static int
701	ahd_linux_slave_configure(struct scsi_device *sdev)	701	ahd_linux_slave_configure(struct scsi_device *sdev)
702	{	702	{
703	struct ahd_softc *ahd;
704
705	ahd = ((struct ahd_softc *)sdev->host->hostdata);
706	if (bootverbose)	703	if (bootverbose)
707	sdev_printk(KERN_INFO, sdev, "Slave Configure\n");	704	sdev_printk(KERN_INFO, sdev, "Slave Configure\n");
708		705
@@ -778,16 +775,13 @@ ahd_linux_dev_reset(struct scsi_cmnd *cmd) · 69 unmodified lines
778	struct scb *reset_scb;	775	struct scb *reset_scb;
779	u_int cdb_byte;	776	u_int cdb_byte;
780	int retval = SUCCESS;	777	int retval = SUCCESS;
781	int paused;
782	int wait;
783	struct ahd_initiator_tinfo *tinfo;	778	struct ahd_initiator_tinfo *tinfo;
784	struct ahd_tmode_tstate *tstate;	779	struct ahd_tmode_tstate *tstate;
785	unsigned long flags;	780	unsigned long flags;
786	DECLARE_COMPLETION_ONSTACK(done);	781	DECLARE_COMPLETION_ONSTACK(done);
787		782
788	reset_scb = NULL;	783	reset_scb = NULL;
789	paused = FALSE;	784
790	wait = FALSE;
791	ahd = (struct ahd_softc *)cmd->device->host->hostdata;	785	ahd = (struct ahd_softc *)cmd->device->host->hostdata;
792		786
793	scmd_printk(KERN_INFO, cmd,	787	scmd_printk(KERN_INFO, cmd,
@@ -1793,10 +1787,12 @@ ahd_done(struct ahd_softc ahd, struct scb scb) · 999 unmodified lines
1793	*/	1787	*/
1794	cmd->sense_buffer[0] = 0;	1788	cmd->sense_buffer[0] = 0;
1795	if (ahd_get_transaction_status(scb) == CAM_REQ_INPROG) {	1789	if (ahd_get_transaction_status(scb) == CAM_REQ_INPROG) {
		1790	#ifdef AHD_REPORT_UNDERFLOWS
1796	uint32_t amount_xferred;	1791	uint32_t amount_xferred;
1797		1792
1798	amount_xferred =	1793	amount_xferred =
1799	ahd_get_transfer_length(scb) - ahd_get_residual(scb);	1794	ahd_get_transfer_length(scb) - ahd_get_residual(scb);
		1795	#endif
1800	if ((scb->flags & SCB_TRANSMISSION_ERROR) != 0) {	1796	if ((scb->flags & SCB_TRANSMISSION_ERROR) != 0) {
1801	#ifdef AHD_DEBUG	1797	#ifdef AHD_DEBUG
1802	if ((ahd_debug & AHD_SHOW_MISC) != 0) {	1798	if ((ahd_debug & AHD_SHOW_MISC) != 0) {
@@ -2147,7 +2143,7 @@ ahd_linux_queue_abort_cmd(struct scsi_cmnd *cmd) · 344 unmodified lines
2147	u_int last_phase;	2143	u_int last_phase;
2148	u_int saved_scsiid;	2144	u_int saved_scsiid;
2149	u_int cdb_byte;	2145	u_int cdb_byte;
2150	int retval;	2146	int retval = SUCCESS;
2151	int was_paused;	2147	int was_paused;
2152	int paused;	2148	int paused;
2153	int wait;	2149	int wait;
@@ -2185,8 +2181,7 @@ ahd_linux_queue_abort_cmd(struct scsi_cmnd *cmd) · 31 unmodified lines
2185	* so we must not still own the command.	2181	* so we must not still own the command.
2186	*/	2182	*/
2187	scmd_printk(KERN_INFO, cmd, "Is not an active device\n");	2183	scmd_printk(KERN_INFO, cmd, "Is not an active device\n");
2188	retval = SUCCESS;	2184	goto done;
2189	goto no_cmd;
2190	}	2185	}
2191		2186
2192	/*	2187	/*
@@ -2199,7 +2194,7 @@ ahd_linux_queue_abort_cmd(struct scsi_cmnd *cmd) · 6 unmodified lines
2199		2194
2200	if (pending_scb == NULL) {	2195	if (pending_scb == NULL) {
2201	scmd_printk(KERN_INFO, cmd, "Command not found\n");	2196	scmd_printk(KERN_INFO, cmd, "Command not found\n");
2202	goto no_cmd;	2197	goto done;
2203	}	2198	}
2204		2199
2205	if ((pending_scb->flags & SCB_RECOVERY_SCB) != 0) {	2200	if ((pending_scb->flags & SCB_RECOVERY_SCB) != 0) {
@@ -2207,7 +2202,7 @@ ahd_linux_queue_abort_cmd(struct scsi_cmnd *cmd) · 1 unmodified line
2207	* We can't queue two recovery actions using the same SCB	2202	* We can't queue two recovery actions using the same SCB
2208	*/	2203	*/
2209	retval = FAILED;	2204	retval = FAILED;
2210	goto done;	2205	goto done;
2211	}	2206	}
2212		2207
2213	/*	2208	/*
@@ -2222,7 +2217,7 @@ ahd_linux_queue_abort_cmd(struct scsi_cmnd *cmd) · 8 unmodified lines
2222		2217
2223	if ((pending_scb->flags & SCB_ACTIVE) == 0) {	2218	if ((pending_scb->flags & SCB_ACTIVE) == 0) {
2224	scmd_printk(KERN_INFO, cmd, "Command already completed\n");	2219	scmd_printk(KERN_INFO, cmd, "Command already completed\n");
2225	goto no_cmd;	2220	goto done;
2226	}	2221	}
2227		2222
2228	printk("%s: At time of recovery, card was %spaused\n",	2223	printk("%s: At time of recovery, card was %spaused\n",
@@ -2239,7 +2234,6 @@ ahd_linux_queue_abort_cmd(struct scsi_cmnd *cmd) · 10 unmodified lines
2239	printk("%s:%d:%d:%d: Cmd aborted from QINFIFO\n",	2234	printk("%s:%d:%d:%d: Cmd aborted from QINFIFO\n",
2240	ahd_name(ahd), cmd->device->channel,	2235	ahd_name(ahd), cmd->device->channel,
2241	cmd->device->id, (u8)cmd->device->lun);	2236	cmd->device->id, (u8)cmd->device->lun);
2242	retval = SUCCESS;
2243	goto done;	2237	goto done;
2244	}	2238	}
2245		2239
@@ -2336,17 +2330,10 @@ ahd_linux_queue_abort_cmd(struct scsi_cmnd *cmd) · 90 unmodified lines
2336	} else {	2330	} else {
2337	scmd_printk(KERN_INFO, cmd, "Unable to deliver message\n");	2331	scmd_printk(KERN_INFO, cmd, "Unable to deliver message\n");
2338	retval = FAILED;	2332	retval = FAILED;
2339	goto done;
2340	}	2333	}
2341		2334
2342	no_cmd:	2335
2343	/*	2336	ahd_restore_modes(ahd, saved_modes);
2344	* Our assumption is that if we don't have the command, no
2345	* recovery action was required, so we return success. Again,
2346	* the semantics of the mid-layer recovery engine are not
2347	* well defined, so this may change in time.
2348	*/
2349	retval = SUCCESS;
2350	done:	2337	done:
2351	if (paused)	2338	if (paused)
2352	ahd_unpause(ahd);	2339	ahd_unpause(ahd);

drivers/scsi/aic7xxx/aic7xxx_osm.c+2−11

 	struct scsi_target **ahc_targp = ahc_linux_target_in_softc(starget);
 	unsigned short scsirate;
 	struct ahc_devinfo devinfo;
-	struct ahc_initiator_tinfo *tinfo;
-	struct ahc_tmode_tstate *tstate;
 	char channel = starget->channel + 'A';
 	unsigned int our_id = ahc->our_id;
 	unsigned int target_offset;
 			spi_max_offset(starget) = 0;
 		spi_min_period(starget) =
 			ahc_find_period(ahc, scsirate, maxsync);
-		tinfo = ahc_fetch_transinfo(ahc, channel, ahc->our_id,
-					    starget->id, &tstate);
 	}
 	ahc_compile_devinfo(&devinfo, our_id, starget->id,
 			    CAM_LUN_WILDCARD, channel,
 static int
 ahc_linux_slave_configure(struct scsi_device *sdev)
 {
-	struct	ahc_softc *ahc;
-	ahc = *((struct ahc_softc **)sdev->host->hostdata);
 	if (bootverbose)
 		sdev_printk(KERN_INFO, sdev, "Slave Configure\n");
 	case AC_TRANSFER_NEG:
 	{
 		struct	scsi_target *starget;
-		struct	ahc_linux_target *targ;
 		struct	ahc_initiator_tinfo *tinfo;
 		struct	ahc_tmode_tstate *tstate;
 		int	target_offset;
 		starget = ahc->platform_data->starget[target_offset];
 		if (starget == NULL)
 			break;
-		targ = scsi_transport_target_data(starget);
 		target_ppr_options =
 			(spi_dt(starget) ? MSG_EXT_PPR_DT_REQ : 0)
 	 */
 	cmd->sense_buffer[0] = 0;
 	if (ahc_get_transaction_status(scb) == CAM_REQ_INPROG) {
+#ifdef AHC_REPORT_UNDERFLOWS
 		uint32_t amount_xferred;
 		amount_xferred =
 		    ahc_get_transfer_length(scb) - ahc_get_residual(scb);
+#endif
 		if ((scb->flags & SCB_TRANSMISSION_ERROR) != 0) {
 #ifdef AHC_DEBUG
 			if ((ahc_debug & AHC_SHOW_MISC) != 0) {

drivers/scsi/aic94xx/aic94xx_dev.c+2−2

@@ -236,7 +236,7 @@ static int asd_init_sata_pm_table_ddb(struct domain_device *dev) · 235 unmodified lines
236		236
237	/**	237	/**
238	* asd_init_sata_pm_port_ddb -- SATA Port Multiplier Port	238	* asd_init_sata_pm_port_ddb -- SATA Port Multiplier Port
239	* dev: pointer to domain device	239	* @dev: pointer to domain device
240	*	240	*
241	* For SATA Port Multiplier Ports we need to allocate one SATA Port	241	* For SATA Port Multiplier Ports we need to allocate one SATA Port
242	* Multiplier Port DDB and depending on whether the target on it	242	* Multiplier Port DDB and depending on whether the target on it
@@ -281,7 +281,7 @@ static int asd_init_initiator_ddb(struct domain_device *dev) · 38 unmodified lines
281		281
282	/**	282	/**
283	* asd_init_sata_pm_ddb -- SATA Port Multiplier	283	* asd_init_sata_pm_ddb -- SATA Port Multiplier
284	* dev: pointer to domain device	284	* @dev: pointer to domain device
285	*	285	*
286	* For STP and direct-attached SATA Port Multipliers we need	286	* For STP and direct-attached SATA Port Multipliers we need
287	* one target port DDB entry and one SATA PM table DDB entry.	287	* one target port DDB entry and one SATA PM table DDB entry.

drivers/scsi/aic94xx/aic94xx_hwi.c+1−2

 /**
  * asd_init_ctxmem -- initialize context memory
- * asd_ha: pointer to host adapter structure
+ * @asd_ha: pointer to host adapter structure
  *
  * This function sets the maximum number of SCBs and
  * DDBs which can be used by the sequencer.  This is normally
 /**
  * asd_start_timers -- (add and) start timers of SCBs
  * @list: pointer to struct list_head of the scbs
- * @to: timeout in jiffies
  *
  * If an SCB in the @list has no timer function, assign the default
  * one,  then start the timer of the SCB.  This function is

drivers/scsi/aic94xx/aic94xx_init.c+1−1

@@ -530,7 +530,7 @@ static int asd_create_ha_caches(struct asd_ha_struct *asd_ha) · 529 unmodified lines
530	return 0;	530	return 0;
531	}	531	}
532		532
533	/**	533	/*
534	* asd_free_edbs -- free empty data buffers	534	* asd_free_edbs -- free empty data buffers
535	* asd_ha: pointer to host adapter structure	535	* asd_ha: pointer to host adapter structure
536	*/	536	*/

drivers/scsi/aic94xx/aic94xx_scb.c+3−3

@@ -123,8 +123,8 @@ static unsigned ord_phy(struct asd_ha_struct asd_ha, struct asd_phy phy) · 122 unmodified lines
123		123
124	/**	124	/**
125	* asd_get_attached_sas_addr -- extract/generate attached SAS address	125	* asd_get_attached_sas_addr -- extract/generate attached SAS address
126	* phy: pointer to asd_phy	126	* @phy: pointer to asd_phy
127	* sas_addr: pointer to buffer where the SAS address is to be written	127	* @sas_addr: pointer to buffer where the SAS address is to be written
128	*	128	*
129	* This function extracts the SAS address from an IDENTIFY frame	129	* This function extracts the SAS address from an IDENTIFY frame
130	* received. If OOB is SATA, then a SAS address is generated from the	130	* received. If OOB is SATA, then a SAS address is generated from the
@@ -847,7 +847,7 @@ void asd_build_initiate_link_adm_task(struct asd_ascb *ascb, int phy_id, · 716 unmodified lines
847		847
848	/**	848	/**
849	* asd_ascb_timedout -- called when a pending SCB's timer has expired	849	* asd_ascb_timedout -- called when a pending SCB's timer has expired
850	* @data: unsigned long, a pointer to the ascb in question	850	* @t: Timer context used to fetch the SCB
851	*	851	*
852	* This is the default timeout function which does the most necessary.	852	* This is the default timeout function which does the most necessary.
853	* Upper layers can implement their own timeout function, say to free	853	* Upper layers can implement their own timeout function, say to free

drivers/scsi/aic94xx/aic94xx_seq.c+5−1

 /**
  * asd_init_lseq_mip -- initialize LSEQ Mode independent pages 0-3
  * @asd_ha: pointer to host adapter structure
+ * @lseq:  link sequencer
  */
 static void asd_init_lseq_mip(struct asd_ha_struct *asd_ha, u8 lseq)
 {
 /**
  * asd_init_lseq_mdp -- initialize LSEQ mode dependent pages.
  * @asd_ha: pointer to host adapter structure
+ * @lseq:  link sequencer
  */
 static void asd_init_lseq_mdp(struct asd_ha_struct *asd_ha,  int lseq)
 {
 /**
  * asd_init_lseq_cio -- initialize LmSEQ CIO registers
  * @asd_ha: pointer to host adapter structure
+ * @lseq:  link sequencer
  */
 static void asd_init_lseq_cio(struct asd_ha_struct *asd_ha, int lseq)
 {
 /**
  * asd_update_port_links -- update port_map_by_links and phy_is_up
- * @sas_phy: pointer to the phy which has been added to a port
+ * @asd_ha: pointer to host adapter structure
+ * @phy: pointer to the phy which has been added to a port
  *
  * 1) When a link reset has completed and we got BYTES DMAED with a
  * valid frame we call this function for that phy, to indicate that

drivers/scsi/aic94xx/aic94xx_tmf.c+1−1

@@ -673,7 +673,7 @@ int asd_lu_reset(struct domain_device dev, u8 lun) · 672 unmodified lines
673		673
674	/**	674	/**
675	* asd_query_task -- send a QUERY TASK TMF to an I_T_L_Q nexus	675	* asd_query_task -- send a QUERY TASK TMF to an I_T_L_Q nexus
676	* task: pointer to sas_task struct of interest	676	* @task: pointer to sas_task struct of interest
677	*	677	*
678	* Returns: TMF_RESP_FUNC_COMPLETE if the task is not in the task set,	678	* Returns: TMF_RESP_FUNC_COMPLETE if the task is not in the task set,
679	* or TMF_RESP_FUNC_SUCC if the task is in the task set.	679	* or TMF_RESP_FUNC_SUCC if the task is in the task set.

drivers/scsi/arcmsr/arcmsr_hba.c+5−13

 	}
 	case ACB_ADAPTER_TYPE_D: {
 		void __iomem *mem_base0;
-		unsigned long addr, range, flags;
+		unsigned long addr, range;
 		addr = (unsigned long)pci_resource_start(pdev, 0);
 		range = pci_resource_len(pdev, 0);
-		flags = pci_resource_flags(pdev, 0);
 		mem_base0 = ioremap(addr, range);
 		if (!mem_base0) {
 			pr_notice("arcmsr%d: memory mapping region fail\n",
 static int arcmsr_suspend(struct pci_dev *pdev, pm_message_t state)
 {
-	uint32_t intmask_org;
 	struct Scsi_Host *host = pci_get_drvdata(pdev);
 	struct AdapterControlBlock *acb =
 		(struct AdapterControlBlock *)host->hostdata;
-	intmask_org = arcmsr_disable_outbound_ints(acb);
+	arcmsr_disable_outbound_ints(acb);
 	arcmsr_free_irq(pdev, acb);
 	del_timer_sync(&acb->eternal_timer);
 	if (set_date_time)
 	struct ARCMSR_CDB *pARCMSR_CDB;
 	bool error;
 	struct CommandControlBlock *pCCB;
-	unsigned long ccb_cdb_phy, cdb_phy_hipart;
+	unsigned long ccb_cdb_phy;
 	switch (acb->adapter_type) {
 					((toggle ^ 0x4000) + 1);
 				doneq_index = pmu->doneq_index;
 				spin_unlock_irqrestore(&acb->doneq_lock, flags);
-				cdb_phy_hipart = pmu->done_qbuffer[doneq_index &
-					0xFFF].addressHigh;
 				addressLow = pmu->done_qbuffer[doneq_index &
 					0xFFF].addressLow;
 				ccb_cdb_phy = (addressLow & 0xFFFFFFF0);
 	struct MessageUnit_D  *pmu;
 	struct ARCMSR_CDB *arcmsr_cdb;
 	struct CommandControlBlock *ccb;
-	unsigned long flags, ccb_cdb_phy, cdb_phy_hipart;
+	unsigned long flags, ccb_cdb_phy;
 	spin_lock_irqsave(&acb->doneq_lock, flags);
 	pmu = acb->pmuD;
 			pmu->doneq_index = index_stripped ? (index_stripped | toggle) :
 				((toggle ^ 0x4000) + 1);
 			doneq_index = pmu->doneq_index;
-			cdb_phy_hipart = pmu->done_qbuffer[doneq_index &
-				0xFFF].addressHigh;
 			addressLow = pmu->done_qbuffer[doneq_index &
 				0xFFF].addressLow;
 			ccb_cdb_phy = (addressLow & 0xFFFFFFF0);
 	bool error;
 	uint32_t poll_ccb_done = 0, poll_count = 0, flag_ccb;
 	int rtn, doneq_index, index_stripped, outbound_write_pointer, toggle;
-	unsigned long flags, ccb_cdb_phy, cdb_phy_hipart;
+	unsigned long flags, ccb_cdb_phy;
 	struct ARCMSR_CDB *arcmsr_cdb;
 	struct CommandControlBlock *pCCB;
 	struct MessageUnit_D *pmu = acb->pmuD;
 				((toggle ^ 0x4000) + 1);
 		doneq_index = pmu->doneq_index;
 		spin_unlock_irqrestore(&acb->doneq_lock, flags);
-		cdb_phy_hipart = pmu->done_qbuffer[doneq_index &
-				0xFFF].addressHigh;
 		flag_ccb = pmu->done_qbuffer[doneq_index & 0xFFF].addressLow;
 		ccb_cdb_phy = (flag_ccb & 0xFFFFFFF0);
 		if (acb->cdb_phyadd_hipart)

drivers/scsi/arm/cumana_2.c+1−1

@@ -450,7 +450,7 @@ static int cumanascsi2_probe(struct expansion_card *ec, · 449 unmodified lines
450		450
451	if (info->info.scsi.dma != NO_DMA)	451	if (info->info.scsi.dma != NO_DMA)
452	free_dma(info->info.scsi.dma);	452	free_dma(info->info.scsi.dma);
453	free_irq(ec->irq, host);	453	free_irq(ec->irq, info);
454		454
455	out_release:	455	out_release:
456	fas216_release(host);	456	fas216_release(host);

drivers/scsi/arm/eesox.c+1−1

@@ -571,7 +571,7 @@ static int eesoxscsi_probe(struct expansion_card ec, const struct ecard_id id) · 570 unmodified lines
571		571
572	if (info->info.scsi.dma != NO_DMA)	572	if (info->info.scsi.dma != NO_DMA)
573	free_dma(info->info.scsi.dma);	573	free_dma(info->info.scsi.dma);
574	free_irq(ec->irq, host);	574	free_irq(ec->irq, info);
575		575
576	out_remove:	576	out_remove:
577	fas216_remove(host);	577	fas216_remove(host);

drivers/scsi/arm/powertec.c+1−1

@@ -378,7 +378,7 @@ static int powertecscsi_probe(struct expansion_card *ec, · 377 unmodified lines
378		378
379	if (info->info.scsi.dma != NO_DMA)	379	if (info->info.scsi.dma != NO_DMA)
380	free_dma(info->info.scsi.dma);	380	free_dma(info->info.scsi.dma);
381	free_irq(ec->irq, host);	381	free_irq(ec->irq, info);
382		382
383	out_release:	383	out_release:
384	fas216_release(host);	384	fas216_release(host);

drivers/scsi/be2iscsi/be_iscsi.c+7−4

 /**
  * beiscsi_session_create - creates a new iscsi session
+ * @ep: pointer to iscsi ep
  * @cmds_max: max commands supported
  * @qdepth: max queue depth supported
  * @initial_cmdsn: initial iscsi CMDSN
  * @cls_session: pointer to iscsi cls session
  * @cls_conn: pointer to iscsi cls conn
  * @transport_fd: EP handle(64 bit)
+ * @is_leading: indicate if this is the session leading connection (MCS)
  *
  * This function binds the TCP Conn with iSCSI Connection and Session.
  */
 /**
  * beiscsi_free_ep - free endpoint
- * @ep:	pointer to iscsi endpoint structure
+ * @beiscsi_ep: pointer to device endpoint struct
  */
 static void beiscsi_free_ep(struct beiscsi_endpoint *beiscsi_ep)
 {
 /**
  * beiscsi_open_conn - Ask FW to open a TCP connection
- * @ep:	endpoint to be used
+ * @ep: pointer to device endpoint struct
  * @src_addr: The source IP address
  * @dst_addr: The Destination  IP address
+ * @non_blocking: blocking or non-blocking call
  *
  * Asks the FW to open a TCP connection
  */
 /**
  * beiscsi_ep_connect - Ask chip to create TCP Conn
- * @scsi_host: Pointer to scsi_host structure
+ * @shost: Pointer to scsi_host structure
  * @dst_addr: The IP address of Target
  * @non_blocking: blocking or non-blocking call
  *
 /**
  * beiscsi_conn_close - Invalidate and upload connection
- * @ep: The iscsi endpoint
+ * @beiscsi_ep: pointer to device endpoint struct
  *
  * Returns 0 on success,  -1 on failure.
  */

drivers/scsi/be2iscsi/be_main.c+2−2

@@ -977,7 +977,7 @@ beiscsi_get_wrb_handle(struct hwi_wrb_context *pwrb_context, · 976 unmodified lines
977	* alloc_wrb_handle - To allocate a wrb handle	977	* alloc_wrb_handle - To allocate a wrb handle
978	* @phba: The hba pointer	978	* @phba: The hba pointer
979	* @cid: The cid to use for allocation	979	* @cid: The cid to use for allocation
980	* @pwrb_context: ptr to ptr to wrb context	980	* @pcontext: ptr to ptr to wrb context
981	*	981	*
982	* This happens under session_lock until submission to chip	982	* This happens under session_lock until submission to chip
983	*/	983	*/
@@ -1394,7 +1394,7 @@ static void hwi_complete_cmd(struct beiscsi_conn *beiscsi_conn, · 410 unmodified lines
1394	spin_unlock_bh(&session->back_lock);	1394	spin_unlock_bh(&session->back_lock);
1395	}	1395	}
1396		1396
1397	/**	1397	/*
1398	* ASYNC PDUs include	1398	* ASYNC PDUs include
1399	* a. Unsolicited NOP-In (target initiated NOP-In)	1399	* a. Unsolicited NOP-In (target initiated NOP-In)
1400	* b. ASYNC Messages	1400	* b. ASYNC Messages

drivers/scsi/be2iscsi/be_mgmt.c+2−1

 /**
  * mgmt_open_connection()- Establish a TCP CXN
+ * @phba: driver priv structure
  * @dst_addr: Destination Address
  * @beiscsi_ep: ptr to device endpoint struct
  * @nonemb_cmd: ptr to memory allocated for command
 	return tag;
 }
-/*
+/**
  * beiscsi_exec_nemb_cmd()- execute non-embedded MBX cmd
  * @phba: driver priv structure
  * @nonemb_cmd: DMA address of the MBX command to be issued

drivers/scsi/bfa/bfa_core.c+1−1

@@ -1237,7 +1237,7 @@ bfa_iocfc_disable_cb(void *bfa_arg, bfa_boolean_t compl) · 1236 unmodified lines
1237	complete(&bfad->disable_comp);	1237	complete(&bfad->disable_comp);
1238	}	1238	}
1239		1239
1240	/**	1240	/*
1241	* configure queue registers from firmware response	1241	* configure queue registers from firmware response
1242	*/	1242	*/
1243	static void	1243	static void

drivers/scsi/bfa/bfa_fcpim.c+2−8

 			 wwn_t rpwwn, struct scsi_lun lun)
 {
 	struct bfa_lun_mask_s	*lunm_list;
-	struct bfa_rport_s	*rp = NULL;
 	struct bfa_fcs_lport_s *port = NULL;
-	struct bfa_fcs_rport_s *rp_fcs;
 	int	i;
 	/* in min cfg lunm_list could be NULL but  no commands should run. */
 		port = bfa_fcs_lookup_port(
 				&((struct bfad_s *)bfa->bfad)->bfa_fcs,
 				vf_id, *pwwn);
-		if (port) {
+		if (port)
 			*pwwn = port->port_cfg.pwwn;
-			rp_fcs = bfa_fcs_lport_get_rport_by_pwwn(port, rpwwn);
-			if (rp_fcs)
-				rp = rp_fcs->bfa_rport;
-		}
 	}
 	lunm_list = bfa_get_lun_mask_list(bfa);
 }
-/**
+/*
  * To send config req, first try to use throttle value from flash
  * If 0, then use driver parameter
  * We need to use min(flash_val, drv_val) because

drivers/scsi/bfa/bfa_fcs_rport.c+0−3

 	struct bfa_fcxp_s *fcxp;
 	struct fchs_s	fchs;
 	struct bfa_fcs_lport_s *port = rport->port;
-	struct fc_adisc_s	*adisc;
 	bfa_trc(port->fcs, rx_fchs->s_id);
 	bfa_trc(port->fcs, rx_fchs->d_id);
 	rport->stats.adisc_rcvd++;
-	adisc = (struct fc_adisc_s *) (rx_fchs + 1);
 	/*
 	 * Accept if the itnim for this rport is online.
 	 * Else reject the ADISC.

drivers/scsi/bfa/bfa_ioc.c+25−32

@@ -701,7 +701,7 @@ static void · 700 unmodified lines
701	bfa_iocpf_sm_fwcheck_entry(struct bfa_iocpf_s *iocpf)	701	bfa_iocpf_sm_fwcheck_entry(struct bfa_iocpf_s *iocpf)
702	{	702	{
703	struct bfi_ioc_image_hdr_s fwhdr;	703	struct bfi_ioc_image_hdr_s fwhdr;
704	u32 r32, fwstate, pgnum, pgoff, loff = 0;	704	u32 r32, fwstate, pgnum, loff = 0;
705	int i;	705	int i;
706		706
707	/*	707	/*
@@ -731,7 +731,6 @@ bfa_iocpf_sm_fwcheck_entry(struct bfa_iocpf_s *iocpf) · 23 unmodified lines
731	* Clear fwver hdr	731	* Clear fwver hdr
732	*/	732	*/
733	pgnum = PSS_SMEM_PGNUM(iocpf->ioc->ioc_regs.smem_pg0, loff);	733	pgnum = PSS_SMEM_PGNUM(iocpf->ioc->ioc_regs.smem_pg0, loff);
734	pgoff = PSS_SMEM_PGOFF(loff);
735	writel(pgnum, iocpf->ioc->ioc_regs.host_page_num_fn);	734	writel(pgnum, iocpf->ioc->ioc_regs.host_page_num_fn);
736		735
737	for (i = 0; i < sizeof(struct bfi_ioc_image_hdr_s) / sizeof(u32); i++) {	736	for (i = 0; i < sizeof(struct bfi_ioc_image_hdr_s) / sizeof(u32); i++) {
@@ -1440,13 +1439,12 @@ bfa_ioc_lpu_stop(struct bfa_ioc_s *ioc) · 702 unmodified lines
1440	void	1439	void
1441	bfa_ioc_fwver_get(struct bfa_ioc_s ioc, struct bfi_ioc_image_hdr_s fwhdr)	1440	bfa_ioc_fwver_get(struct bfa_ioc_s ioc, struct bfi_ioc_image_hdr_s fwhdr)
1442	{	1441	{
1443	u32 pgnum, pgoff;	1442	u32 pgnum;
1444	u32 loff = 0;	1443	u32 loff = 0;
1445	int i;	1444	int i;
1446	u32 fwsig = (u32 ) fwhdr;	1445	u32 fwsig = (u32 ) fwhdr;
1447		1446
1448	pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, loff);	1447	pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, loff);
1449	pgoff = PSS_SMEM_PGOFF(loff);
1450	writel(pgnum, ioc->ioc_regs.host_page_num_fn);	1448	writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1451		1449
1452	for (i = 0; i < (sizeof(struct bfi_ioc_image_hdr_s) / sizeof(u32));	1450	for (i = 0; i < (sizeof(struct bfi_ioc_image_hdr_s) / sizeof(u32));
@@ -1662,7 +1660,7 @@ bfa_status_t · 209 unmodified lines
1662	bfa_ioc_fwsig_invalidate(struct bfa_ioc_s *ioc)	1660	bfa_ioc_fwsig_invalidate(struct bfa_ioc_s *ioc)
1663	{	1661	{
1664		1662
1665	u32 pgnum, pgoff;	1663	u32 pgnum;
1666	u32 loff = 0;	1664	u32 loff = 0;
1667	enum bfi_ioc_state ioc_fwstate;	1665	enum bfi_ioc_state ioc_fwstate;
1668		1666
@@ -1671,7 +1669,6 @@ bfa_ioc_fwsig_invalidate(struct bfa_ioc_s *ioc) · 2 unmodified lines
1671	return BFA_STATUS_ADAPTER_ENABLED;	1669	return BFA_STATUS_ADAPTER_ENABLED;
1672		1670
1673	pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, loff);	1671	pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, loff);
1674	pgoff = PSS_SMEM_PGOFF(loff);
1675	writel(pgnum, ioc->ioc_regs.host_page_num_fn);	1672	writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1676	bfa_mem_write(ioc->ioc_regs.smem_page_start, loff, BFA_IOC_FW_INV_SIGN);	1673	bfa_mem_write(ioc->ioc_regs.smem_page_start, loff, BFA_IOC_FW_INV_SIGN);
1677		1674
@@ -1863,7 +1860,7 @@ bfa_ioc_download_fw(struct bfa_ioc_s *ioc, u32 boot_type, · 185 unmodified lines
1863	u32 boot_env)	1860	u32 boot_env)
1864	{	1861	{
1865	u32 *fwimg;	1862	u32 *fwimg;
1866	u32 pgnum, pgoff;	1863	u32 pgnum;
1867	u32 loff = 0;	1864	u32 loff = 0;
1868	u32 chunkno = 0;	1865	u32 chunkno = 0;
1869	u32 i;	1866	u32 i;
@@ -1892,8 +1889,6 @@ bfa_ioc_download_fw(struct bfa_ioc_s *ioc, u32 boot_type, · 22 unmodified lines
1892		1889
1893		1890
1894	pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, loff);	1891	pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, loff);
1895	pgoff = PSS_SMEM_PGOFF(loff);
1896
1897	writel(pgnum, ioc->ioc_regs.host_page_num_fn);	1892	writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1898		1893
1899	for (i = 0; i < fwimg_size; i++) {	1894	for (i = 0; i < fwimg_size; i++) {
@@ -4763,11 +4758,9 @@ bfa_diag_memtest_done(void *cbarg) · 2863 unmodified lines
4763	struct bfa_ioc_s *ioc = diag->ioc;	4758	struct bfa_ioc_s *ioc = diag->ioc;
4764	struct bfa_diag_memtest_result *res = diag->result;	4759	struct bfa_diag_memtest_result *res = diag->result;
4765	u32 loff = BFI_BOOT_MEMTEST_RES_ADDR;	4760	u32 loff = BFI_BOOT_MEMTEST_RES_ADDR;
4766	u32 pgnum, pgoff, i;	4761	u32 pgnum, i;
4767		4762
4768	pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, loff);	4763	pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, loff);
4769	pgoff = PSS_SMEM_PGOFF(loff);
4770
4771	writel(pgnum, ioc->ioc_regs.host_page_num_fn);	4764	writel(pgnum, ioc->ioc_regs.host_page_num_fn);
4772		4765
4773	for (i = 0; i < (sizeof(struct bfa_diag_memtest_result) /	4766	for (i = 0; i < (sizeof(struct bfa_diag_memtest_result) /
@@ -5026,7 +5019,7 @@ diag_portbeacon_comp(struct bfa_diag_s *diag) · 252 unmodified lines
5026	/*	5019	/*
5027	* Diag hmbox handler	5020	* Diag hmbox handler
5028	*/	5021	*/
5029	void	5022	static void
5030	bfa_diag_intr(void diagarg, struct bfi_mbmsg_s msg)	5023	bfa_diag_intr(void diagarg, struct bfi_mbmsg_s msg)
5031	{	5024	{
5032	struct bfa_diag_s *diag = diagarg;	5025	struct bfa_diag_s *diag = diagarg;
@@ -6649,8 +6642,8 @@ enum bfa_flash_cmd { · 1616 unmodified lines
6649	BFA_FLASH_READ_STATUS = 0x05, /* read status */	6642	BFA_FLASH_READ_STATUS = 0x05, /* read status */
6650	};	6643	};
6651		6644
6652	/**	6645	/*
6653	* @brief hardware error definition	6646	* Hardware error definition
6654	*/	6647	*/
6655	enum bfa_flash_err {	6648	enum bfa_flash_err {
6656	BFA_FLASH_NOT_PRESENT = -1, /!< flash not present /	6649	BFA_FLASH_NOT_PRESENT = -1, /!< flash not present /
@@ -6664,8 +6657,8 @@ enum bfa_flash_err { · 7 unmodified lines
6664	BFA_FLASH_ERR_LEN = -9, /!< invalid length /	6657	BFA_FLASH_ERR_LEN = -9, /!< invalid length /
6665	};	6658	};
6666		6659
6667	/**	6660	/*
6668	* @brief flash command register data structure	6661	* Flash command register data structure
6669	*/	6662	*/
6670	union bfa_flash_cmd_reg_u {	6663	union bfa_flash_cmd_reg_u {
6671	struct {	6664	struct {
@@ -6688,8 +6681,8 @@ union bfa_flash_cmd_reg_u { · 16 unmodified lines
6688	u32 i;	6681	u32 i;
6689	};	6682	};
6690		6683
6691	/**	6684	/*
6692	* @brief flash device status register data structure	6685	* Flash device status register data structure
6693	*/	6686	*/
6694	union bfa_flash_dev_status_reg_u {	6687	union bfa_flash_dev_status_reg_u {
6695	struct {	6688	struct {
@@ -6714,8 +6707,8 @@ union bfa_flash_dev_status_reg_u { · 18 unmodified lines
6714	u32 i;	6707	u32 i;
6715	};	6708	};
6716		6709
6717	/**	6710	/*
6718	* @brief flash address register data structure	6711	* Flash address register data structure
6719	*/	6712	*/
6720	union bfa_flash_addr_reg_u {	6713	union bfa_flash_addr_reg_u {
6721	struct {	6714	struct {
@@ -6730,7 +6723,7 @@ union bfa_flash_addr_reg_u { · 8 unmodified lines
6730	u32 i;	6723	u32 i;
6731	};	6724	};
6732		6725
6733	/**	6726	/*
6734	* dg flash_raw_private Flash raw private functions	6727	* dg flash_raw_private Flash raw private functions
6735	*/	6728	*/
6736	static void	6729	static void
@@ -6771,7 +6764,7 @@ bfa_flash_cmd_act_check(void __iomem *pci_bar) · 34 unmodified lines
6771	return 0;	6764	return 0;
6772	}	6765	}
6773		6766
6774	/**	6767	/*
6775	* @brief	6768	* @brief
6776	* Flush FLI data fifo.	6769	* Flush FLI data fifo.
6777	*	6770	*
@@ -6784,7 +6777,6 @@ static u32 · 6 unmodified lines
6784	bfa_flash_fifo_flush(void __iomem *pci_bar)	6777	bfa_flash_fifo_flush(void __iomem *pci_bar)
6785	{	6778	{
6786	u32 i;	6779	u32 i;
6787	u32 t;
6788	union bfa_flash_dev_status_reg_u dev_status;	6780	union bfa_flash_dev_status_reg_u dev_status;
6789		6781
6790	dev_status.i = readl(pci_bar + FLI_DEV_STATUS_REG);	6782	dev_status.i = readl(pci_bar + FLI_DEV_STATUS_REG);
@@ -6794,7 +6786,7 @@ bfa_flash_fifo_flush(void __iomem *pci_bar) · 3 unmodified lines
6794		6786
6795	/* fifo counter in terms of words */	6787	/* fifo counter in terms of words */
6796	for (i = 0; i < dev_status.r.fifo_cnt; i++)	6788	for (i = 0; i < dev_status.r.fifo_cnt; i++)
6797	t = readl(pci_bar + FLI_RDDATA_REG);	6789	readl(pci_bar + FLI_RDDATA_REG);
6798		6790
6799	/*	6791	/*
6800	* Check the device status. It may take some time.	6792	* Check the device status. It may take some time.
@@ -6811,7 +6803,7 @@ bfa_flash_fifo_flush(void __iomem *pci_bar) · 10 unmodified lines
6811	return 0;	6803	return 0;
6812	}	6804	}
6813		6805
6814	/**	6806	/*
6815	* @brief	6807	* @brief
6816	* Read flash status.	6808	* Read flash status.
6817	*	6809	*
@@ -6856,7 +6848,7 @@ bfa_flash_status_read(void __iomem *pci_bar) · 38 unmodified lines
6856	return ret_status;	6848	return ret_status;
6857	}	6849	}
6858		6850
6859	/**	6851	/*
6860	* @brief	6852	* @brief
6861	* Start flash read operation.	6853	* Start flash read operation.
6862	*	6854	*
@@ -6902,7 +6894,7 @@ bfa_flash_read_start(void __iomem *pci_bar, u32 offset, u32 len, · 39 unmodified lines
6902	return 0;	6894	return 0;
6903	}	6895	}
6904		6896
6905	/**	6897	/*
6906	* @brief	6898	* @brief
6907	* Check flash read operation.	6899	* Check flash read operation.
6908	*	6900	*
@@ -6918,7 +6910,8 @@ bfa_flash_read_check(void __iomem *pci_bar) · 9 unmodified lines
6918		6910
6919	return 0;	6911	return 0;
6920	}	6912	}
6921	/**	6913
		6914	/*
6922	* @brief	6915	* @brief
6923	* End flash read operation.	6916	* End flash read operation.
6924	*	6917	*
@@ -6944,7 +6937,7 @@ bfa_flash_read_end(void __iomem pci_bar, u32 len, char buf) · 19 unmodified lines
6944	bfa_flash_fifo_flush(pci_bar);	6937	bfa_flash_fifo_flush(pci_bar);
6945	}	6938	}
6946		6939
6947	/**	6940	/*
6948	* @brief	6941	* @brief
6949	* Perform flash raw read.	6942	* Perform flash raw read.
6950	*	6943	*
@@ -6970,7 +6963,7 @@ bfa_raw_sem_get(void __iomem *bar) · 19 unmodified lines
6970		6963
6971	}	6964	}
6972		6965
6973	bfa_status_t	6966	static bfa_status_t
6974	bfa_flash_sem_get(void __iomem *bar)	6967	bfa_flash_sem_get(void __iomem *bar)
6975	{	6968	{
6976	u32 n = FLASH_BLOCKING_OP_MAX;	6969	u32 n = FLASH_BLOCKING_OP_MAX;
@@ -6983,7 +6976,7 @@ bfa_flash_sem_get(void __iomem *bar) · 6 unmodified lines
6983	return BFA_STATUS_OK;	6976	return BFA_STATUS_OK;
6984	}	6977	}
6985		6978
6986	void	6979	static void
6987	bfa_flash_sem_put(void __iomem *bar)	6980	bfa_flash_sem_put(void __iomem *bar)
6988	{	6981	{
6989	writel(0, (bar + FLASH_SEM_LOCK_REG));	6982	writel(0, (bar + FLASH_SEM_LOCK_REG));

drivers/scsi/bfa/bfa_ioc_ct.c+3−3

@@ -496,7 +496,7 @@ bfa_ioc_ct_sync_complete(struct bfa_ioc_s *ioc) · 495 unmodified lines
496	return BFA_FALSE;	496	return BFA_FALSE;
497	}	497	}
498		498
499	/**	499	/*
500	* Called from bfa_ioc_attach() to map asic specific calls.	500	* Called from bfa_ioc_attach() to map asic specific calls.
501	*/	501	*/
502	static void	502	static void
@@ -517,7 +517,7 @@ bfa_ioc_set_ctx_hwif(struct bfa_ioc_s ioc, struct bfa_ioc_hwif_s hwif) · 14 unmodified lines
517	hwif->ioc_get_alt_fwstate = bfa_ioc_ct_get_alt_ioc_fwstate;	517	hwif->ioc_get_alt_fwstate = bfa_ioc_ct_get_alt_ioc_fwstate;
518	}	518	}
519		519
520	/**	520	/*
521	* Called from bfa_ioc_attach() to map asic specific calls.	521	* Called from bfa_ioc_attach() to map asic specific calls.
522	*/	522	*/
523	void	523	void
@@ -532,7 +532,7 @@ bfa_ioc_set_ct_hwif(struct bfa_ioc_s *ioc) · 8 unmodified lines
532	ioc->ioc_hwif = &hwif_ct;	532	ioc->ioc_hwif = &hwif_ct;
533	}	533	}
534		534
535	/**	535	/*
536	* Called from bfa_ioc_attach() to map asic specific calls.	536	* Called from bfa_ioc_attach() to map asic specific calls.
537	*/	537	*/
538	void	538	void

drivers/scsi/bfa/bfa_port.c+2−2

@@ -756,7 +756,7 @@ bfa_cee_reset_stats(struct bfa_cee_s *cee, · 755 unmodified lines
756	* @return void	756	* @return void
757	*/	757	*/
758		758
759	void	759	static void
760	bfa_cee_isr(void cbarg, struct bfi_mbmsg_s m)	760	bfa_cee_isr(void cbarg, struct bfi_mbmsg_s m)
761	{	761	{
762	union bfi_cee_i2h_msg_u *msg;	762	union bfi_cee_i2h_msg_u *msg;
@@ -792,7 +792,7 @@ bfa_cee_isr(void cbarg, struct bfi_mbmsg_s m) · 29 unmodified lines
792	* @return void	792	* @return void
793	*/	793	*/
794		794
795	void	795	static void
796	bfa_cee_notify(void *arg, enum bfa_ioc_event_e event)	796	bfa_cee_notify(void *arg, enum bfa_ioc_event_e event)
797	{	797	{
798	struct bfa_cee_s cee = (struct bfa_cee_s ) arg;	798	struct bfa_cee_s cee = (struct bfa_cee_s ) arg;

drivers/scsi/bfa/bfa_svc.c+2−2

@@ -2718,7 +2718,7 @@ bfa_fcport_sm_ddport(struct bfa_fcport_s *fcport, · 2717 unmodified lines
2718	case BFA_FCPORT_SM_DPORTDISABLE:	2718	case BFA_FCPORT_SM_DPORTDISABLE:
2719	case BFA_FCPORT_SM_ENABLE:	2719	case BFA_FCPORT_SM_ENABLE:
2720	case BFA_FCPORT_SM_START:	2720	case BFA_FCPORT_SM_START:
2721	/**	2721	/*
2722	* Ignore event for a port that is ddport	2722	* Ignore event for a port that is ddport
2723	*/	2723	*/
2724	break;	2724	break;
@@ -3839,7 +3839,7 @@ bfa_fcport_get_topology(struct bfa_s *bfa) · 1114 unmodified lines
3839	return fcport->topology;	3839	return fcport->topology;
3840	}	3840	}
3841		3841
3842	/**	3842	/*
3843	* Get config topology.	3843	* Get config topology.
3844	*/	3844	*/
3845	enum bfa_port_topology	3845	enum bfa_port_topology

drivers/scsi/bfa/bfad_bsg.c+111−111

@@ -15,7 +15,7 @@ · 14 unmodified lines
15		15
16	BFA_TRC_FILE(LDRV, BSG);	16	BFA_TRC_FILE(LDRV, BSG);
17		17
18	int	18	static int
19	bfad_iocmd_ioc_enable(struct bfad_s bfad, void cmd)	19	bfad_iocmd_ioc_enable(struct bfad_s bfad, void cmd)
20	{	20	{
21	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;	21	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;
@@ -38,7 +38,7 @@ bfad_iocmd_ioc_enable(struct bfad_s bfad, void cmd) · 16 unmodified lines
38	return 0;	38	return 0;
39	}	39	}
40		40
41	int	41	static int
42	bfad_iocmd_ioc_disable(struct bfad_s bfad, void cmd)	42	bfad_iocmd_ioc_disable(struct bfad_s bfad, void cmd)
43	{	43	{
44	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;	44	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;
@@ -146,7 +146,7 @@ bfad_iocmd_ioc_get_stats(struct bfad_s bfad, void cmd) · 101 unmodified lines
146	return 0;	146	return 0;
147	}	147	}
148		148
149	int	149	static int
150	bfad_iocmd_ioc_get_fwstats(struct bfad_s bfad, void cmd,	150	bfad_iocmd_ioc_get_fwstats(struct bfad_s bfad, void cmd,
151	unsigned int payload_len)	151	unsigned int payload_len)
152	{	152	{
@@ -176,7 +176,7 @@ out: · 23 unmodified lines
176	return 0;	176	return 0;
177	}	177	}
178		178
179	int	179	static int
180	bfad_iocmd_ioc_reset_stats(struct bfad_s bfad, void cmd, unsigned int v_cmd)	180	bfad_iocmd_ioc_reset_stats(struct bfad_s bfad, void cmd, unsigned int v_cmd)
181	{	181	{
182	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;	182	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;
@@ -194,7 +194,7 @@ bfad_iocmd_ioc_reset_stats(struct bfad_s bfad, void cmd, unsigned int v_cmd) · 11 unmodified lines
194	return 0;	194	return 0;
195	}	195	}
196		196
197	int	197	static int
198	bfad_iocmd_ioc_set_name(struct bfad_s bfad, void cmd, unsigned int v_cmd)	198	bfad_iocmd_ioc_set_name(struct bfad_s bfad, void cmd, unsigned int v_cmd)
199	{	199	{
200	struct bfa_bsg_ioc_name_s iocmd = (struct bfa_bsg_ioc_name_s ) cmd;	200	struct bfa_bsg_ioc_name_s iocmd = (struct bfa_bsg_ioc_name_s ) cmd;
@@ -208,7 +208,7 @@ bfad_iocmd_ioc_set_name(struct bfad_s bfad, void cmd, unsigned int v_cmd) · 7 unmodified lines
208	return 0;	208	return 0;
209	}	209	}
210		210
211	int	211	static int
212	bfad_iocmd_iocfc_get_attr(struct bfad_s bfad, void cmd)	212	bfad_iocmd_iocfc_get_attr(struct bfad_s bfad, void cmd)
213	{	213	{
214	struct bfa_bsg_iocfc_attr_s iocmd = (struct bfa_bsg_iocfc_attr_s )cmd;	214	struct bfa_bsg_iocfc_attr_s iocmd = (struct bfa_bsg_iocfc_attr_s )cmd;
@@ -219,7 +219,7 @@ bfad_iocmd_iocfc_get_attr(struct bfad_s bfad, void cmd) · 4 unmodified lines
219	return 0;	219	return 0;
220	}	220	}
221		221
222	int	222	static int
223	bfad_iocmd_ioc_fw_sig_inv(struct bfad_s bfad, void cmd)	223	bfad_iocmd_ioc_fw_sig_inv(struct bfad_s bfad, void cmd)
224	{	224	{
225	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;	225	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;
@@ -231,7 +231,7 @@ bfad_iocmd_ioc_fw_sig_inv(struct bfad_s bfad, void cmd) · 5 unmodified lines
231	return 0;	231	return 0;
232	}	232	}
233		233
234	int	234	static int
235	bfad_iocmd_iocfc_set_intr(struct bfad_s bfad, void cmd)	235	bfad_iocmd_iocfc_set_intr(struct bfad_s bfad, void cmd)
236	{	236	{
237	struct bfa_bsg_iocfc_intr_s iocmd = (struct bfa_bsg_iocfc_intr_s )cmd;	237	struct bfa_bsg_iocfc_intr_s iocmd = (struct bfa_bsg_iocfc_intr_s )cmd;
@@ -244,7 +244,7 @@ bfad_iocmd_iocfc_set_intr(struct bfad_s bfad, void cmd) · 6 unmodified lines
244	return 0;	244	return 0;
245	}	245	}
246		246
247	int	247	static int
248	bfad_iocmd_port_enable(struct bfad_s bfad, void cmd)	248	bfad_iocmd_port_enable(struct bfad_s bfad, void cmd)
249	{	249	{
250	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;	250	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;
@@ -265,7 +265,7 @@ bfad_iocmd_port_enable(struct bfad_s bfad, void cmd) · 14 unmodified lines
265	return 0;	265	return 0;
266	}	266	}
267		267
268	int	268	static int
269	bfad_iocmd_port_disable(struct bfad_s bfad, void cmd)	269	bfad_iocmd_port_disable(struct bfad_s bfad, void cmd)
270	{	270	{
271	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;	271	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;
@@ -315,7 +315,7 @@ bfad_iocmd_port_get_attr(struct bfad_s bfad, void cmd) · 43 unmodified lines
315	return 0;	315	return 0;
316	}	316	}
317		317
318	int	318	static int
319	bfad_iocmd_port_get_stats(struct bfad_s bfad, void cmd,	319	bfad_iocmd_port_get_stats(struct bfad_s bfad, void cmd,
320	unsigned int payload_len)	320	unsigned int payload_len)
321	{	321	{
@@ -349,7 +349,7 @@ out: · 27 unmodified lines
349	return 0;	349	return 0;
350	}	350	}
351		351
352	int	352	static int
353	bfad_iocmd_port_reset_stats(struct bfad_s bfad, void cmd)	353	bfad_iocmd_port_reset_stats(struct bfad_s bfad, void cmd)
354	{	354	{
355	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;	355	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;
@@ -370,7 +370,7 @@ bfad_iocmd_port_reset_stats(struct bfad_s bfad, void cmd) · 14 unmodified lines
370	return 0;	370	return 0;
371	}	371	}
372		372
373	int	373	static int
374	bfad_iocmd_set_port_cfg(struct bfad_s bfad, void iocmd, unsigned int v_cmd)	374	bfad_iocmd_set_port_cfg(struct bfad_s bfad, void iocmd, unsigned int v_cmd)
375	{	375	{
376	struct bfa_bsg_port_cfg_s cmd = (struct bfa_bsg_port_cfg_s )iocmd;	376	struct bfa_bsg_port_cfg_s cmd = (struct bfa_bsg_port_cfg_s )iocmd;
@@ -390,7 +390,7 @@ bfad_iocmd_set_port_cfg(struct bfad_s bfad, void iocmd, unsigned int v_cmd) · 13 unmodified lines
390	return 0;	390	return 0;
391	}	391	}
392		392
393	int	393	static int
394	bfad_iocmd_port_cfg_maxfrsize(struct bfad_s bfad, void cmd)	394	bfad_iocmd_port_cfg_maxfrsize(struct bfad_s bfad, void cmd)
395	{	395	{
396	struct bfa_bsg_port_cfg_maxfrsize_s *iocmd =	396	struct bfa_bsg_port_cfg_maxfrsize_s *iocmd =
@@ -404,7 +404,7 @@ bfad_iocmd_port_cfg_maxfrsize(struct bfad_s bfad, void cmd) · 7 unmodified lines
404	return 0;	404	return 0;
405	}	405	}
406		406
407	int	407	static int
408	bfad_iocmd_port_cfg_bbcr(struct bfad_s bfad, unsigned int cmd, void pcmd)	408	bfad_iocmd_port_cfg_bbcr(struct bfad_s bfad, unsigned int cmd, void pcmd)
409	{	409	{
410	struct bfa_bsg_bbcr_enable_s *iocmd =	410	struct bfa_bsg_bbcr_enable_s *iocmd =
@@ -427,7 +427,7 @@ bfad_iocmd_port_cfg_bbcr(struct bfad_s bfad, unsigned int cmd, void pcmd) · 16 unmodified lines
427	return 0;	427	return 0;
428	}	428	}
429		429
430	int	430	static int
431	bfad_iocmd_port_get_bbcr_attr(struct bfad_s bfad, void pcmd)	431	bfad_iocmd_port_get_bbcr_attr(struct bfad_s bfad, void pcmd)
432	{	432	{
433	struct bfa_bsg_bbcr_attr_s iocmd = (struct bfa_bsg_bbcr_attr_s ) pcmd;	433	struct bfa_bsg_bbcr_attr_s iocmd = (struct bfa_bsg_bbcr_attr_s ) pcmd;
@@ -465,7 +465,7 @@ out: · 31 unmodified lines
465	return 0;	465	return 0;
466	}	466	}
467		467
468	int	468	static int
469	bfad_iocmd_lport_get_stats(struct bfad_s bfad, void cmd)	469	bfad_iocmd_lport_get_stats(struct bfad_s bfad, void cmd)
470	{	470	{
471	struct bfa_fcs_lport_s *fcs_port;	471	struct bfa_fcs_lport_s *fcs_port;
@@ -489,7 +489,7 @@ out: · 17 unmodified lines
489	return 0;	489	return 0;
490	}	490	}
491		491
492	int	492	static int
493	bfad_iocmd_lport_reset_stats(struct bfad_s bfad, void cmd)	493	bfad_iocmd_lport_reset_stats(struct bfad_s bfad, void cmd)
494	{	494	{
495	struct bfa_fcs_lport_s *fcs_port;	495	struct bfa_fcs_lport_s *fcs_port;
@@ -523,7 +523,7 @@ out: · 27 unmodified lines
523	return 0;	523	return 0;
524	}	524	}
525		525
526	int	526	static int
527	bfad_iocmd_lport_get_iostats(struct bfad_s bfad, void cmd)	527	bfad_iocmd_lport_get_iostats(struct bfad_s bfad, void cmd)
528	{	528	{
529	struct bfa_fcs_lport_s *fcs_port;	529	struct bfa_fcs_lport_s *fcs_port;
@@ -548,7 +548,7 @@ out: · 18 unmodified lines
548	return 0;	548	return 0;
549	}	549	}
550		550
551	int	551	static int
552	bfad_iocmd_lport_get_rports(struct bfad_s bfad, void cmd,	552	bfad_iocmd_lport_get_rports(struct bfad_s bfad, void cmd,
553	unsigned int payload_len)	553	unsigned int payload_len)
554	{	554	{
@@ -590,7 +590,7 @@ out: · 35 unmodified lines
590	return 0;	590	return 0;
591	}	591	}
592		592
593	int	593	static int
594	bfad_iocmd_rport_get_attr(struct bfad_s bfad, void cmd)	594	bfad_iocmd_rport_get_attr(struct bfad_s bfad, void cmd)
595	{	595	{
596	struct bfa_bsg_rport_attr_s iocmd = (struct bfa_bsg_rport_attr_s )cmd;	596	struct bfa_bsg_rport_attr_s iocmd = (struct bfa_bsg_rport_attr_s )cmd;
@@ -676,7 +676,7 @@ out: · 79 unmodified lines
676	return 0;	676	return 0;
677	}	677	}
678		678
679	int	679	static int
680	bfad_iocmd_rport_get_stats(struct bfad_s bfad, void cmd)	680	bfad_iocmd_rport_get_stats(struct bfad_s bfad, void cmd)
681	{	681	{
682	struct bfa_bsg_rport_stats_s *iocmd =	682	struct bfa_bsg_rport_stats_s *iocmd =
@@ -717,7 +717,7 @@ out: · 34 unmodified lines
717	return 0;	717	return 0;
718	}	718	}
719		719
720	int	720	static int
721	bfad_iocmd_rport_clr_stats(struct bfad_s bfad, void cmd)	721	bfad_iocmd_rport_clr_stats(struct bfad_s bfad, void cmd)
722	{	722	{
723	struct bfa_bsg_rport_reset_stats_s *iocmd =	723	struct bfa_bsg_rport_reset_stats_s *iocmd =
@@ -753,7 +753,7 @@ out: · 29 unmodified lines
753	return 0;	753	return 0;
754	}	754	}
755		755
756	int	756	static int
757	bfad_iocmd_rport_set_speed(struct bfad_s bfad, void cmd)	757	bfad_iocmd_rport_set_speed(struct bfad_s bfad, void cmd)
758	{	758	{
759	struct bfa_bsg_rport_set_speed_s *iocmd =	759	struct bfa_bsg_rport_set_speed_s *iocmd =
@@ -789,7 +789,7 @@ out: · 29 unmodified lines
789	return 0;	789	return 0;
790	}	790	}
791		791
792	int	792	static int
793	bfad_iocmd_vport_get_attr(struct bfad_s bfad, void cmd)	793	bfad_iocmd_vport_get_attr(struct bfad_s bfad, void cmd)
794	{	794	{
795	struct bfa_fcs_vport_s *fcs_vport;	795	struct bfa_fcs_vport_s *fcs_vport;
@@ -812,7 +812,7 @@ out: · 16 unmodified lines
812	return 0;	812	return 0;
813	}	813	}
814		814
815	int	815	static int
816	bfad_iocmd_vport_get_stats(struct bfad_s bfad, void cmd)	816	bfad_iocmd_vport_get_stats(struct bfad_s bfad, void cmd)
817	{	817	{
818	struct bfa_fcs_vport_s *fcs_vport;	818	struct bfa_fcs_vport_s *fcs_vport;
@@ -840,7 +840,7 @@ out: · 21 unmodified lines
840	return 0;	840	return 0;
841	}	841	}
842		842
843	int	843	static int
844	bfad_iocmd_vport_clr_stats(struct bfad_s bfad, void cmd)	844	bfad_iocmd_vport_clr_stats(struct bfad_s bfad, void cmd)
845	{	845	{
846	struct bfa_fcs_vport_s *fcs_vport;	846	struct bfa_fcs_vport_s *fcs_vport;
@@ -907,7 +907,7 @@ out: · 60 unmodified lines
907	return 0;	907	return 0;
908	}	908	}
909		909
910	int	910	static int
911	bfad_iocmd_qos_set_bw(struct bfad_s bfad, void pcmd)	911	bfad_iocmd_qos_set_bw(struct bfad_s bfad, void pcmd)
912	{	912	{
913	struct bfa_bsg_qos_bw_s iocmd = (struct bfa_bsg_qos_bw_s )pcmd;	913	struct bfa_bsg_qos_bw_s iocmd = (struct bfa_bsg_qos_bw_s )pcmd;
@@ -920,7 +920,7 @@ bfad_iocmd_qos_set_bw(struct bfad_s bfad, void pcmd) · 6 unmodified lines
920	return 0;	920	return 0;
921	}	921	}
922		922
923	int	923	static int
924	bfad_iocmd_ratelim(struct bfad_s bfad, unsigned int cmd, void pcmd)	924	bfad_iocmd_ratelim(struct bfad_s bfad, unsigned int cmd, void pcmd)
925	{	925	{
926	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )pcmd;	926	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )pcmd;
@@ -949,7 +949,7 @@ bfad_iocmd_ratelim(struct bfad_s bfad, unsigned int cmd, void pcmd) · 22 unmodified lines
949	return 0;	949	return 0;
950	}	950	}
951		951
952	int	952	static int
953	bfad_iocmd_ratelim_speed(struct bfad_s bfad, unsigned int cmd, void pcmd)	953	bfad_iocmd_ratelim_speed(struct bfad_s bfad, unsigned int cmd, void pcmd)
954	{	954	{
955	struct bfa_bsg_trl_speed_s iocmd = (struct bfa_bsg_trl_speed_s )pcmd;	955	struct bfa_bsg_trl_speed_s iocmd = (struct bfa_bsg_trl_speed_s )pcmd;
@@ -978,7 +978,7 @@ bfad_iocmd_ratelim_speed(struct bfad_s bfad, unsigned int cmd, void pcmd) · 22 unmodified lines
978	return 0;	978	return 0;
979	}	979	}
980		980
981	int	981	static int
982	bfad_iocmd_cfg_fcpim(struct bfad_s bfad, void cmd)	982	bfad_iocmd_cfg_fcpim(struct bfad_s bfad, void cmd)
983	{	983	{
984	struct bfa_bsg_fcpim_s iocmd = (struct bfa_bsg_fcpim_s )cmd;	984	struct bfa_bsg_fcpim_s iocmd = (struct bfa_bsg_fcpim_s )cmd;
@@ -991,7 +991,7 @@ bfad_iocmd_cfg_fcpim(struct bfad_s bfad, void cmd) · 6 unmodified lines
991	return 0;	991	return 0;
992	}	992	}
993		993
994	int	994	static int
995	bfad_iocmd_fcpim_get_modstats(struct bfad_s bfad, void cmd)	995	bfad_iocmd_fcpim_get_modstats(struct bfad_s bfad, void cmd)
996	{	996	{
997	struct bfa_bsg_fcpim_modstats_s *iocmd =	997	struct bfa_bsg_fcpim_modstats_s *iocmd =
@@ -1013,7 +1013,7 @@ bfad_iocmd_fcpim_get_modstats(struct bfad_s bfad, void cmd) · 15 unmodified lines
1013	return 0;	1013	return 0;
1014	}	1014	}
1015		1015
1016	int	1016	static int
1017	bfad_iocmd_fcpim_clr_modstats(struct bfad_s bfad, void cmd)	1017	bfad_iocmd_fcpim_clr_modstats(struct bfad_s bfad, void cmd)
1018	{	1018	{
1019	struct bfa_bsg_fcpim_modstatsclr_s *iocmd =	1019	struct bfa_bsg_fcpim_modstatsclr_s *iocmd =
@@ -1035,7 +1035,7 @@ bfad_iocmd_fcpim_clr_modstats(struct bfad_s bfad, void cmd) · 15 unmodified lines
1035	return 0;	1035	return 0;
1036	}	1036	}
1037		1037
1038	int	1038	static int
1039	bfad_iocmd_fcpim_get_del_itn_stats(struct bfad_s bfad, void cmd)	1039	bfad_iocmd_fcpim_get_del_itn_stats(struct bfad_s bfad, void cmd)
1040	{	1040	{
1041	struct bfa_bsg_fcpim_del_itn_stats_s *iocmd =	1041	struct bfa_bsg_fcpim_del_itn_stats_s *iocmd =
@@ -1160,7 +1160,7 @@ bfad_iocmd_itnim_get_itnstats(struct bfad_s bfad, void cmd) · 118 unmodified lines
1160	return 0;	1160	return 0;
1161	}	1161	}
1162		1162
1163	int	1163	static int
1164	bfad_iocmd_fcport_enable(struct bfad_s bfad, void cmd)	1164	bfad_iocmd_fcport_enable(struct bfad_s bfad, void cmd)
1165	{	1165	{
1166	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;	1166	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;
@@ -1173,7 +1173,7 @@ bfad_iocmd_fcport_enable(struct bfad_s bfad, void cmd) · 6 unmodified lines
1173	return 0;	1173	return 0;
1174	}	1174	}
1175		1175
1176	int	1176	static int
1177	bfad_iocmd_fcport_disable(struct bfad_s bfad, void cmd)	1177	bfad_iocmd_fcport_disable(struct bfad_s bfad, void cmd)
1178	{	1178	{
1179	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;	1179	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;
@@ -1186,7 +1186,7 @@ bfad_iocmd_fcport_disable(struct bfad_s bfad, void cmd) · 6 unmodified lines
1186	return 0;	1186	return 0;
1187	}	1187	}
1188		1188
1189	int	1189	static int
1190	bfad_iocmd_ioc_get_pcifn_cfg(struct bfad_s bfad, void cmd)	1190	bfad_iocmd_ioc_get_pcifn_cfg(struct bfad_s bfad, void cmd)
1191	{	1191	{
1192	struct bfa_bsg_pcifn_cfg_s iocmd = (struct bfa_bsg_pcifn_cfg_s )cmd;	1192	struct bfa_bsg_pcifn_cfg_s iocmd = (struct bfa_bsg_pcifn_cfg_s )cmd;
@@ -1208,7 +1208,7 @@ out: · 15 unmodified lines
1208	return 0;	1208	return 0;
1209	}	1209	}
1210		1210
1211	int	1211	static int
1212	bfad_iocmd_pcifn_create(struct bfad_s bfad, void cmd)	1212	bfad_iocmd_pcifn_create(struct bfad_s bfad, void cmd)
1213	{	1213	{
1214	struct bfa_bsg_pcifn_s iocmd = (struct bfa_bsg_pcifn_s )cmd;	1214	struct bfa_bsg_pcifn_s iocmd = (struct bfa_bsg_pcifn_s )cmd;
@@ -1231,7 +1231,7 @@ out: · 16 unmodified lines
1231	return 0;	1231	return 0;
1232	}	1232	}
1233		1233
1234	int	1234	static int
1235	bfad_iocmd_pcifn_delete(struct bfad_s bfad, void cmd)	1235	bfad_iocmd_pcifn_delete(struct bfad_s bfad, void cmd)
1236	{	1236	{
1237	struct bfa_bsg_pcifn_s iocmd = (struct bfa_bsg_pcifn_s )cmd;	1237	struct bfa_bsg_pcifn_s iocmd = (struct bfa_bsg_pcifn_s )cmd;
@@ -1253,7 +1253,7 @@ out: · 15 unmodified lines
1253	return 0;	1253	return 0;
1254	}	1254	}
1255		1255
1256	int	1256	static int
1257	bfad_iocmd_pcifn_bw(struct bfad_s bfad, void cmd)	1257	bfad_iocmd_pcifn_bw(struct bfad_s bfad, void cmd)
1258	{	1258	{
1259	struct bfa_bsg_pcifn_s iocmd = (struct bfa_bsg_pcifn_s )cmd;	1259	struct bfa_bsg_pcifn_s iocmd = (struct bfa_bsg_pcifn_s )cmd;
@@ -1277,7 +1277,7 @@ out: · 17 unmodified lines
1277	return 0;	1277	return 0;
1278	}	1278	}
1279		1279
1280	int	1280	static int
1281	bfad_iocmd_adapter_cfg_mode(struct bfad_s bfad, void cmd)	1281	bfad_iocmd_adapter_cfg_mode(struct bfad_s bfad, void cmd)
1282	{	1282	{
1283	struct bfa_bsg_adapter_cfg_mode_s *iocmd =	1283	struct bfa_bsg_adapter_cfg_mode_s *iocmd =
@@ -1300,7 +1300,7 @@ out: · 16 unmodified lines
1300	return 0;	1300	return 0;
1301	}	1301	}
1302		1302
1303	int	1303	static int
1304	bfad_iocmd_port_cfg_mode(struct bfad_s bfad, void cmd)	1304	bfad_iocmd_port_cfg_mode(struct bfad_s bfad, void cmd)
1305	{	1305	{
1306	struct bfa_bsg_port_cfg_mode_s *iocmd =	1306	struct bfa_bsg_port_cfg_mode_s *iocmd =
@@ -1324,7 +1324,7 @@ out: · 17 unmodified lines
1324	return 0;	1324	return 0;
1325	}	1325	}
1326		1326
1327	int	1327	static int
1328	bfad_iocmd_ablk_optrom(struct bfad_s bfad, unsigned int cmd, void pcmd)	1328	bfad_iocmd_ablk_optrom(struct bfad_s bfad, unsigned int cmd, void pcmd)
1329	{	1329	{
1330	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )pcmd;	1330	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )pcmd;
@@ -1350,7 +1350,7 @@ out: · 19 unmodified lines
1350	return 0;	1350	return 0;
1351	}	1351	}
1352		1352
1353	int	1353	static int
1354	bfad_iocmd_faa_query(struct bfad_s bfad, void cmd)	1354	bfad_iocmd_faa_query(struct bfad_s bfad, void cmd)
1355	{	1355	{
1356	struct bfa_bsg_faa_attr_s iocmd = (struct bfa_bsg_faa_attr_s )cmd;	1356	struct bfa_bsg_faa_attr_s iocmd = (struct bfa_bsg_faa_attr_s )cmd;
@@ -1373,7 +1373,7 @@ out: · 16 unmodified lines
1373	return 0;	1373	return 0;
1374	}	1374	}
1375		1375
1376	int	1376	static int
1377	bfad_iocmd_cee_attr(struct bfad_s bfad, void cmd, unsigned int payload_len)	1377	bfad_iocmd_cee_attr(struct bfad_s bfad, void cmd, unsigned int payload_len)
1378	{	1378	{
1379	struct bfa_bsg_cee_attr_s *iocmd =	1379	struct bfa_bsg_cee_attr_s *iocmd =
@@ -1409,7 +1409,7 @@ out: · 29 unmodified lines
1409	return 0;	1409	return 0;
1410	}	1410	}
1411		1411
1412	int	1412	static int
1413	bfad_iocmd_cee_get_stats(struct bfad_s bfad, void cmd,	1413	bfad_iocmd_cee_get_stats(struct bfad_s bfad, void cmd,
1414	unsigned int payload_len)	1414	unsigned int payload_len)
1415	{	1415	{
@@ -1446,7 +1446,7 @@ out: · 30 unmodified lines
1446	return 0;	1446	return 0;
1447	}	1447	}
1448		1448
1449	int	1449	static int
1450	bfad_iocmd_cee_reset_stats(struct bfad_s bfad, void cmd)	1450	bfad_iocmd_cee_reset_stats(struct bfad_s bfad, void cmd)
1451	{	1451	{
1452	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;	1452	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;
@@ -1460,7 +1460,7 @@ bfad_iocmd_cee_reset_stats(struct bfad_s bfad, void cmd) · 7 unmodified lines
1460	return 0;	1460	return 0;
1461	}	1461	}
1462		1462
1463	int	1463	static int
1464	bfad_iocmd_sfp_media(struct bfad_s bfad, void cmd)	1464	bfad_iocmd_sfp_media(struct bfad_s bfad, void cmd)
1465	{	1465	{
1466	struct bfa_bsg_sfp_media_s iocmd = (struct bfa_bsg_sfp_media_s )cmd;	1466	struct bfa_bsg_sfp_media_s iocmd = (struct bfa_bsg_sfp_media_s )cmd;
@@ -1482,7 +1482,7 @@ out: · 15 unmodified lines
1482	return 0;	1482	return 0;
1483	}	1483	}
1484		1484
1485	int	1485	static int
1486	bfad_iocmd_sfp_speed(struct bfad_s bfad, void cmd)	1486	bfad_iocmd_sfp_speed(struct bfad_s bfad, void cmd)
1487	{	1487	{
1488	struct bfa_bsg_sfp_speed_s iocmd = (struct bfa_bsg_sfp_speed_s )cmd;	1488	struct bfa_bsg_sfp_speed_s iocmd = (struct bfa_bsg_sfp_speed_s )cmd;
@@ -1503,7 +1503,7 @@ out: · 14 unmodified lines
1503	return 0;	1503	return 0;
1504	}	1504	}
1505		1505
1506	int	1506	static int
1507	bfad_iocmd_flash_get_attr(struct bfad_s bfad, void cmd)	1507	bfad_iocmd_flash_get_attr(struct bfad_s bfad, void cmd)
1508	{	1508	{
1509	struct bfa_bsg_flash_attr_s *iocmd =	1509	struct bfa_bsg_flash_attr_s *iocmd =
@@ -1524,7 +1524,7 @@ out: · 14 unmodified lines
1524	return 0;	1524	return 0;
1525	}	1525	}
1526		1526
1527	int	1527	static int
1528	bfad_iocmd_flash_erase_part(struct bfad_s bfad, void cmd)	1528	bfad_iocmd_flash_erase_part(struct bfad_s bfad, void cmd)
1529	{	1529	{
1530	struct bfa_bsg_flash_s iocmd = (struct bfa_bsg_flash_s )cmd;	1530	struct bfa_bsg_flash_s iocmd = (struct bfa_bsg_flash_s )cmd;
@@ -1544,7 +1544,7 @@ out: · 13 unmodified lines
1544	return 0;	1544	return 0;
1545	}	1545	}
1546		1546
1547	int	1547	static int
1548	bfad_iocmd_flash_update_part(struct bfad_s bfad, void cmd,	1548	bfad_iocmd_flash_update_part(struct bfad_s bfad, void cmd,
1549	unsigned int payload_len)	1549	unsigned int payload_len)
1550	{	1550	{
@@ -1576,7 +1576,7 @@ out: · 25 unmodified lines
1576	return 0;	1576	return 0;
1577	}	1577	}
1578		1578
1579	int	1579	static int
1580	bfad_iocmd_flash_read_part(struct bfad_s bfad, void cmd,	1580	bfad_iocmd_flash_read_part(struct bfad_s bfad, void cmd,
1581	unsigned int payload_len)	1581	unsigned int payload_len)
1582	{	1582	{
@@ -1608,7 +1608,7 @@ out: · 25 unmodified lines
1608	return 0;	1608	return 0;
1609	}	1609	}
1610		1610
1611	int	1611	static int
1612	bfad_iocmd_diag_temp(struct bfad_s bfad, void cmd)	1612	bfad_iocmd_diag_temp(struct bfad_s bfad, void cmd)
1613	{	1613	{
1614	struct bfa_bsg_diag_get_temp_s *iocmd =	1614	struct bfa_bsg_diag_get_temp_s *iocmd =
@@ -1630,7 +1630,7 @@ out: · 15 unmodified lines
1630	return 0;	1630	return 0;
1631	}	1631	}
1632		1632
1633	int	1633	static int
1634	bfad_iocmd_diag_memtest(struct bfad_s bfad, void cmd)	1634	bfad_iocmd_diag_memtest(struct bfad_s bfad, void cmd)
1635	{	1635	{
1636	struct bfa_bsg_diag_memtest_s *iocmd =	1636	struct bfa_bsg_diag_memtest_s *iocmd =
@@ -1653,7 +1653,7 @@ out: · 16 unmodified lines
1653	return 0;	1653	return 0;
1654	}	1654	}
1655		1655
1656	int	1656	static int
1657	bfad_iocmd_diag_loopback(struct bfad_s bfad, void cmd)	1657	bfad_iocmd_diag_loopback(struct bfad_s bfad, void cmd)
1658	{	1658	{
1659	struct bfa_bsg_diag_loopback_s *iocmd =	1659	struct bfa_bsg_diag_loopback_s *iocmd =
@@ -1676,7 +1676,7 @@ out: · 16 unmodified lines
1676	return 0;	1676	return 0;
1677	}	1677	}
1678		1678
1679	int	1679	static int
1680	bfad_iocmd_diag_fwping(struct bfad_s bfad, void cmd)	1680	bfad_iocmd_diag_fwping(struct bfad_s bfad, void cmd)
1681	{	1681	{
1682	struct bfa_bsg_diag_fwping_s *iocmd =	1682	struct bfa_bsg_diag_fwping_s *iocmd =
@@ -1700,7 +1700,7 @@ out: · 17 unmodified lines
1700	return 0;	1700	return 0;
1701	}	1701	}
1702		1702
1703	int	1703	static int
1704	bfad_iocmd_diag_queuetest(struct bfad_s bfad, void cmd)	1704	bfad_iocmd_diag_queuetest(struct bfad_s bfad, void cmd)
1705	{	1705	{
1706	struct bfa_bsg_diag_qtest_s iocmd = (struct bfa_bsg_diag_qtest_s )cmd;	1706	struct bfa_bsg_diag_qtest_s iocmd = (struct bfa_bsg_diag_qtest_s )cmd;
@@ -1721,7 +1721,7 @@ out: · 14 unmodified lines
1721	return 0;	1721	return 0;
1722	}	1722	}
1723		1723
1724	int	1724	static int
1725	bfad_iocmd_diag_sfp(struct bfad_s bfad, void cmd)	1725	bfad_iocmd_diag_sfp(struct bfad_s bfad, void cmd)
1726	{	1726	{
1727	struct bfa_bsg_sfp_show_s *iocmd =	1727	struct bfa_bsg_sfp_show_s *iocmd =
@@ -1744,7 +1744,7 @@ out: · 16 unmodified lines
1744	return 0;	1744	return 0;
1745	}	1745	}
1746		1746
1747	int	1747	static int
1748	bfad_iocmd_diag_led(struct bfad_s bfad, void cmd)	1748	bfad_iocmd_diag_led(struct bfad_s bfad, void cmd)
1749	{	1749	{
1750	struct bfa_bsg_diag_led_s iocmd = (struct bfa_bsg_diag_led_s )cmd;	1750	struct bfa_bsg_diag_led_s iocmd = (struct bfa_bsg_diag_led_s )cmd;
@@ -1757,7 +1757,7 @@ bfad_iocmd_diag_led(struct bfad_s bfad, void cmd) · 6 unmodified lines
1757	return 0;	1757	return 0;
1758	}	1758	}
1759		1759
1760	int	1760	static int
1761	bfad_iocmd_diag_beacon_lport(struct bfad_s bfad, void cmd)	1761	bfad_iocmd_diag_beacon_lport(struct bfad_s bfad, void cmd)
1762	{	1762	{
1763	struct bfa_bsg_diag_beacon_s *iocmd =	1763	struct bfa_bsg_diag_beacon_s *iocmd =
@@ -1772,7 +1772,7 @@ bfad_iocmd_diag_beacon_lport(struct bfad_s bfad, void cmd) · 8 unmodified lines
1772	return 0;	1772	return 0;
1773	}	1773	}
1774		1774
1775	int	1775	static int
1776	bfad_iocmd_diag_lb_stat(struct bfad_s bfad, void cmd)	1776	bfad_iocmd_diag_lb_stat(struct bfad_s bfad, void cmd)
1777	{	1777	{
1778	struct bfa_bsg_diag_lb_stat_s *iocmd =	1778	struct bfa_bsg_diag_lb_stat_s *iocmd =
@@ -1787,7 +1787,7 @@ bfad_iocmd_diag_lb_stat(struct bfad_s bfad, void cmd) · 8 unmodified lines
1787	return 0;	1787	return 0;
1788	}	1788	}
1789		1789
1790	int	1790	static int
1791	bfad_iocmd_diag_dport_enable(struct bfad_s bfad, void pcmd)	1791	bfad_iocmd_diag_dport_enable(struct bfad_s bfad, void pcmd)
1792	{	1792	{
1793	struct bfa_bsg_dport_enable_s *iocmd =	1793	struct bfa_bsg_dport_enable_s *iocmd =
@@ -1809,7 +1809,7 @@ bfad_iocmd_diag_dport_enable(struct bfad_s bfad, void pcmd) · 15 unmodified lines
1809	return 0;	1809	return 0;
1810	}	1810	}
1811		1811
1812	int	1812	static int
1813	bfad_iocmd_diag_dport_disable(struct bfad_s bfad, void pcmd)	1813	bfad_iocmd_diag_dport_disable(struct bfad_s bfad, void pcmd)
1814	{	1814	{
1815	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )pcmd;	1815	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )pcmd;
@@ -1829,7 +1829,7 @@ bfad_iocmd_diag_dport_disable(struct bfad_s bfad, void pcmd) · 13 unmodified lines
1829	return 0;	1829	return 0;
1830	}	1830	}
1831		1831
1832	int	1832	static int
1833	bfad_iocmd_diag_dport_start(struct bfad_s bfad, void pcmd)	1833	bfad_iocmd_diag_dport_start(struct bfad_s bfad, void pcmd)
1834	{	1834	{
1835	struct bfa_bsg_dport_enable_s *iocmd =	1835	struct bfa_bsg_dport_enable_s *iocmd =
@@ -1854,7 +1854,7 @@ bfad_iocmd_diag_dport_start(struct bfad_s bfad, void pcmd) · 18 unmodified lines
1854	return 0;	1854	return 0;
1855	}	1855	}
1856		1856
1857	int	1857	static int
1858	bfad_iocmd_diag_dport_show(struct bfad_s bfad, void pcmd)	1858	bfad_iocmd_diag_dport_show(struct bfad_s bfad, void pcmd)
1859	{	1859	{
1860	struct bfa_bsg_diag_dport_show_s *iocmd =	1860	struct bfa_bsg_diag_dport_show_s *iocmd =
@@ -1869,7 +1869,7 @@ bfad_iocmd_diag_dport_show(struct bfad_s bfad, void pcmd) · 8 unmodified lines
1869	}	1869	}
1870		1870
1871		1871
1872	int	1872	static int
1873	bfad_iocmd_phy_get_attr(struct bfad_s bfad, void cmd)	1873	bfad_iocmd_phy_get_attr(struct bfad_s bfad, void cmd)
1874	{	1874	{
1875	struct bfa_bsg_phy_attr_s *iocmd =	1875	struct bfa_bsg_phy_attr_s *iocmd =
@@ -1890,7 +1890,7 @@ out: · 14 unmodified lines
1890	return 0;	1890	return 0;
1891	}	1891	}
1892		1892
1893	int	1893	static int
1894	bfad_iocmd_phy_get_stats(struct bfad_s bfad, void cmd)	1894	bfad_iocmd_phy_get_stats(struct bfad_s bfad, void cmd)
1895	{	1895	{
1896	struct bfa_bsg_phy_stats_s *iocmd =	1896	struct bfa_bsg_phy_stats_s *iocmd =
@@ -1911,7 +1911,7 @@ out: · 14 unmodified lines
1911	return 0;	1911	return 0;
1912	}	1912	}
1913		1913
1914	int	1914	static int
1915	bfad_iocmd_phy_read(struct bfad_s bfad, void cmd, unsigned int payload_len)	1915	bfad_iocmd_phy_read(struct bfad_s bfad, void cmd, unsigned int payload_len)
1916	{	1916	{
1917	struct bfa_bsg_phy_s iocmd = (struct bfa_bsg_phy_s )cmd;	1917	struct bfa_bsg_phy_s iocmd = (struct bfa_bsg_phy_s )cmd;
@@ -1943,7 +1943,7 @@ out: · 25 unmodified lines
1943	return 0;	1943	return 0;
1944	}	1944	}
1945		1945
1946	int	1946	static int
1947	bfad_iocmd_vhba_query(struct bfad_s bfad, void cmd)	1947	bfad_iocmd_vhba_query(struct bfad_s bfad, void cmd)
1948	{	1948	{
1949	struct bfa_bsg_vhba_attr_s *iocmd =	1949	struct bfa_bsg_vhba_attr_s *iocmd =
@@ -1962,7 +1962,7 @@ bfad_iocmd_vhba_query(struct bfad_s bfad, void cmd) · 12 unmodified lines
1962	return 0;	1962	return 0;
1963	}	1963	}
1964		1964
1965	int	1965	static int
1966	bfad_iocmd_phy_update(struct bfad_s bfad, void cmd, unsigned int payload_len)	1966	bfad_iocmd_phy_update(struct bfad_s bfad, void cmd, unsigned int payload_len)
1967	{	1967	{
1968	struct bfa_bsg_phy_s iocmd = (struct bfa_bsg_phy_s )cmd;	1968	struct bfa_bsg_phy_s iocmd = (struct bfa_bsg_phy_s )cmd;
@@ -1992,7 +1992,7 @@ out: · 23 unmodified lines
1992	return 0;	1992	return 0;
1993	}	1993	}
1994		1994
1995	int	1995	static int
1996	bfad_iocmd_porglog_get(struct bfad_s bfad, void cmd)	1996	bfad_iocmd_porglog_get(struct bfad_s bfad, void cmd)
1997	{	1997	{
1998	struct bfa_bsg_debug_s iocmd = (struct bfa_bsg_debug_s )cmd;	1998	struct bfa_bsg_debug_s iocmd = (struct bfa_bsg_debug_s )cmd;
@@ -2012,7 +2012,7 @@ out: · 13 unmodified lines
2012	}	2012	}
2013		2013
2014	#define BFA_DEBUG_FW_CORE_CHUNK_SZ 0x4000U /* 16K chunks for FW dump */	2014	#define BFA_DEBUG_FW_CORE_CHUNK_SZ 0x4000U /* 16K chunks for FW dump */
2015	int	2015	static int
2016	bfad_iocmd_debug_fw_core(struct bfad_s bfad, void cmd,	2016	bfad_iocmd_debug_fw_core(struct bfad_s bfad, void cmd,
2017	unsigned int payload_len)	2017	unsigned int payload_len)
2018	{	2018	{
@@ -2046,7 +2046,7 @@ out: · 27 unmodified lines
2046	return 0;	2046	return 0;
2047	}	2047	}
2048		2048
2049	int	2049	static int
2050	bfad_iocmd_debug_ctl(struct bfad_s bfad, void cmd, unsigned int v_cmd)	2050	bfad_iocmd_debug_ctl(struct bfad_s bfad, void cmd, unsigned int v_cmd)
2051	{	2051	{
2052	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;	2052	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;
@@ -2067,7 +2067,7 @@ bfad_iocmd_debug_ctl(struct bfad_s bfad, void cmd, unsigned int v_cmd) · 14 unmodified lines
2067	return 0;	2067	return 0;
2068	}	2068	}
2069		2069
2070	int	2070	static int
2071	bfad_iocmd_porglog_ctl(struct bfad_s bfad, void cmd)	2071	bfad_iocmd_porglog_ctl(struct bfad_s bfad, void cmd)
2072	{	2072	{
2073	struct bfa_bsg_portlogctl_s iocmd = (struct bfa_bsg_portlogctl_s )cmd;	2073	struct bfa_bsg_portlogctl_s iocmd = (struct bfa_bsg_portlogctl_s )cmd;
@@ -2081,7 +2081,7 @@ bfad_iocmd_porglog_ctl(struct bfad_s bfad, void cmd) · 7 unmodified lines
2081	return 0;	2081	return 0;
2082	}	2082	}
2083		2083
2084	int	2084	static int
2085	bfad_iocmd_fcpim_cfg_profile(struct bfad_s bfad, void cmd, unsigned int v_cmd)	2085	bfad_iocmd_fcpim_cfg_profile(struct bfad_s bfad, void cmd, unsigned int v_cmd)
2086	{	2086	{
2087	struct bfa_bsg_fcpim_profile_s *iocmd =	2087	struct bfa_bsg_fcpim_profile_s *iocmd =
@@ -2125,7 +2125,7 @@ bfad_iocmd_itnim_get_ioprofile(struct bfad_s bfad, void cmd) · 37 unmodified lines
2125	return 0;	2125	return 0;
2126	}	2126	}
2127		2127
2128	int	2128	static int
2129	bfad_iocmd_fcport_get_stats(struct bfad_s bfad, void cmd)	2129	bfad_iocmd_fcport_get_stats(struct bfad_s bfad, void cmd)
2130	{	2130	{
2131	struct bfa_bsg_fcport_stats_s *iocmd =	2131	struct bfa_bsg_fcport_stats_s *iocmd =
@@ -2150,7 +2150,7 @@ out: · 18 unmodified lines
2150	return 0;	2150	return 0;
2151	}	2151	}
2152		2152
2153	int	2153	static int
2154	bfad_iocmd_fcport_reset_stats(struct bfad_s bfad, void cmd)	2154	bfad_iocmd_fcport_reset_stats(struct bfad_s bfad, void cmd)
2155	{	2155	{
2156	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;	2156	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;
@@ -2174,7 +2174,7 @@ out: · 17 unmodified lines
2174	return 0;	2174	return 0;
2175	}	2175	}
2176		2176
2177	int	2177	static int
2178	bfad_iocmd_boot_cfg(struct bfad_s bfad, void cmd)	2178	bfad_iocmd_boot_cfg(struct bfad_s bfad, void cmd)
2179	{	2179	{
2180	struct bfa_bsg_boot_s iocmd = (struct bfa_bsg_boot_s )cmd;	2180	struct bfa_bsg_boot_s iocmd = (struct bfa_bsg_boot_s )cmd;
@@ -2196,7 +2196,7 @@ out: · 15 unmodified lines
2196	return 0;	2196	return 0;
2197	}	2197	}
2198		2198
2199	int	2199	static int
2200	bfad_iocmd_boot_query(struct bfad_s bfad, void cmd)	2200	bfad_iocmd_boot_query(struct bfad_s bfad, void cmd)
2201	{	2201	{
2202	struct bfa_bsg_boot_s iocmd = (struct bfa_bsg_boot_s )cmd;	2202	struct bfa_bsg_boot_s iocmd = (struct bfa_bsg_boot_s )cmd;
@@ -2218,7 +2218,7 @@ out: · 15 unmodified lines
2218	return 0;	2218	return 0;
2219	}	2219	}
2220		2220
2221	int	2221	static int
2222	bfad_iocmd_preboot_query(struct bfad_s bfad, void cmd)	2222	bfad_iocmd_preboot_query(struct bfad_s bfad, void cmd)
2223	{	2223	{
2224	struct bfa_bsg_preboot_s iocmd = (struct bfa_bsg_preboot_s )cmd;	2224	struct bfa_bsg_preboot_s iocmd = (struct bfa_bsg_preboot_s )cmd;
@@ -2237,7 +2237,7 @@ bfad_iocmd_preboot_query(struct bfad_s bfad, void cmd) · 12 unmodified lines
2237	return 0;	2237	return 0;
2238	}	2238	}
2239		2239
2240	int	2240	static int
2241	bfad_iocmd_ethboot_cfg(struct bfad_s bfad, void cmd)	2241	bfad_iocmd_ethboot_cfg(struct bfad_s bfad, void cmd)
2242	{	2242	{
2243	struct bfa_bsg_ethboot_s iocmd = (struct bfa_bsg_ethboot_s )cmd;	2243	struct bfa_bsg_ethboot_s iocmd = (struct bfa_bsg_ethboot_s )cmd;
@@ -2260,7 +2260,7 @@ out: · 16 unmodified lines
2260	return 0;	2260	return 0;
2261	}	2261	}
2262		2262
2263	int	2263	static int
2264	bfad_iocmd_ethboot_query(struct bfad_s bfad, void cmd)	2264	bfad_iocmd_ethboot_query(struct bfad_s bfad, void cmd)
2265	{	2265	{
2266	struct bfa_bsg_ethboot_s iocmd = (struct bfa_bsg_ethboot_s )cmd;	2266	struct bfa_bsg_ethboot_s iocmd = (struct bfa_bsg_ethboot_s )cmd;
@@ -2283,7 +2283,7 @@ out: · 16 unmodified lines
2283	return 0;	2283	return 0;
2284	}	2284	}
2285		2285
2286	int	2286	static int
2287	bfad_iocmd_cfg_trunk(struct bfad_s bfad, void cmd, unsigned int v_cmd)	2287	bfad_iocmd_cfg_trunk(struct bfad_s bfad, void cmd, unsigned int v_cmd)
2288	{	2288	{
2289	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;	2289	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;
@@ -2323,7 +2323,7 @@ bfad_iocmd_cfg_trunk(struct bfad_s bfad, void cmd, unsigned int v_cmd) · 33 unmodified lines
2323	return 0;	2323	return 0;
2324	}	2324	}
2325		2325
2326	int	2326	static int
2327	bfad_iocmd_trunk_get_attr(struct bfad_s bfad, void cmd)	2327	bfad_iocmd_trunk_get_attr(struct bfad_s bfad, void cmd)
2328	{	2328	{
2329	struct bfa_bsg_trunk_attr_s iocmd = (struct bfa_bsg_trunk_attr_s )cmd;	2329	struct bfa_bsg_trunk_attr_s iocmd = (struct bfa_bsg_trunk_attr_s )cmd;
@@ -2346,7 +2346,7 @@ bfad_iocmd_trunk_get_attr(struct bfad_s bfad, void cmd) · 16 unmodified lines
2346	return 0;	2346	return 0;
2347	}	2347	}
2348		2348
2349	int	2349	static int
2350	bfad_iocmd_qos(struct bfad_s bfad, void cmd, unsigned int v_cmd)	2350	bfad_iocmd_qos(struct bfad_s bfad, void cmd, unsigned int v_cmd)
2351	{	2351	{
2352	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;	2352	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;
@@ -2374,7 +2374,7 @@ bfad_iocmd_qos(struct bfad_s bfad, void cmd, unsigned int v_cmd) · 21 unmodified lines
2374	return 0;	2374	return 0;
2375	}	2375	}
2376		2376
2377	int	2377	static int
2378	bfad_iocmd_qos_get_attr(struct bfad_s bfad, void cmd)	2378	bfad_iocmd_qos_get_attr(struct bfad_s bfad, void cmd)
2379	{	2379	{
2380	struct bfa_bsg_qos_attr_s iocmd = (struct bfa_bsg_qos_attr_s )cmd;	2380	struct bfa_bsg_qos_attr_s iocmd = (struct bfa_bsg_qos_attr_s )cmd;
@@ -2400,7 +2400,7 @@ bfad_iocmd_qos_get_attr(struct bfad_s bfad, void cmd) · 19 unmodified lines
2400	return 0;	2400	return 0;
2401	}	2401	}
2402		2402
2403	int	2403	static int
2404	bfad_iocmd_qos_get_vc_attr(struct bfad_s bfad, void cmd)	2404	bfad_iocmd_qos_get_vc_attr(struct bfad_s bfad, void cmd)
2405	{	2405	{
2406	struct bfa_bsg_qos_vc_attr_s *iocmd =	2406	struct bfa_bsg_qos_vc_attr_s *iocmd =
@@ -2432,7 +2432,7 @@ bfad_iocmd_qos_get_vc_attr(struct bfad_s bfad, void cmd) · 25 unmodified lines
2432	return 0;	2432	return 0;
2433	}	2433	}
2434		2434
2435	int	2435	static int
2436	bfad_iocmd_qos_get_stats(struct bfad_s bfad, void cmd)	2436	bfad_iocmd_qos_get_stats(struct bfad_s bfad, void cmd)
2437	{	2437	{
2438	struct bfa_bsg_fcport_stats_s *iocmd =	2438	struct bfa_bsg_fcport_stats_s *iocmd =
@@ -2464,7 +2464,7 @@ out: · 25 unmodified lines
2464	return 0;	2464	return 0;
2465	}	2465	}
2466		2466
2467	int	2467	static int
2468	bfad_iocmd_qos_reset_stats(struct bfad_s bfad, void cmd)	2468	bfad_iocmd_qos_reset_stats(struct bfad_s bfad, void cmd)
2469	{	2469	{
2470	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;	2470	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )cmd;
@@ -2495,7 +2495,7 @@ out: · 24 unmodified lines
2495	return 0;	2495	return 0;
2496	}	2496	}
2497		2497
2498	int	2498	static int
2499	bfad_iocmd_vf_get_stats(struct bfad_s bfad, void cmd)	2499	bfad_iocmd_vf_get_stats(struct bfad_s bfad, void cmd)
2500	{	2500	{
2501	struct bfa_bsg_vf_stats_s *iocmd =	2501	struct bfa_bsg_vf_stats_s *iocmd =
@@ -2518,7 +2518,7 @@ out: · 16 unmodified lines
2518	return 0;	2518	return 0;
2519	}	2519	}
2520		2520
2521	int	2521	static int
2522	bfad_iocmd_vf_clr_stats(struct bfad_s bfad, void cmd)	2522	bfad_iocmd_vf_clr_stats(struct bfad_s bfad, void cmd)
2523	{	2523	{
2524	struct bfa_bsg_vf_reset_stats_s *iocmd =	2524	struct bfa_bsg_vf_reset_stats_s *iocmd =
@@ -2555,7 +2555,7 @@ bfad_iocmd_lunmask_reset_lunscan_mode(struct bfad_s *bfad, int lunmask_cfg) · 30 unmodified lines
2555	bfad_reset_sdev_bflags(vport->drv_port.im_port, lunmask_cfg);	2555	bfad_reset_sdev_bflags(vport->drv_port.im_port, lunmask_cfg);
2556	}	2556	}
2557		2557
2558	int	2558	static int
2559	bfad_iocmd_lunmask(struct bfad_s bfad, void pcmd, unsigned int v_cmd)	2559	bfad_iocmd_lunmask(struct bfad_s bfad, void pcmd, unsigned int v_cmd)
2560	{	2560	{
2561	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )pcmd;	2561	struct bfa_bsg_gen_s iocmd = (struct bfa_bsg_gen_s )pcmd;
@@ -2578,7 +2578,7 @@ bfad_iocmd_lunmask(struct bfad_s bfad, void pcmd, unsigned int v_cmd) · 16 unmodified lines
2578	return 0;	2578	return 0;
2579	}	2579	}
2580		2580
2581	int	2581	static int
2582	bfad_iocmd_fcpim_lunmask_query(struct bfad_s bfad, void cmd)	2582	bfad_iocmd_fcpim_lunmask_query(struct bfad_s bfad, void cmd)
2583	{	2583	{
2584	struct bfa_bsg_fcpim_lunmask_query_s *iocmd =	2584	struct bfa_bsg_fcpim_lunmask_query_s *iocmd =
@@ -2592,7 +2592,7 @@ bfad_iocmd_fcpim_lunmask_query(struct bfad_s bfad, void cmd) · 7 unmodified lines
2592	return 0;	2592	return 0;
2593	}	2593	}
2594		2594
2595	int	2595	static int
2596	bfad_iocmd_fcpim_cfg_lunmask(struct bfad_s bfad, void cmd, unsigned int v_cmd)	2596	bfad_iocmd_fcpim_cfg_lunmask(struct bfad_s bfad, void cmd, unsigned int v_cmd)
2597	{	2597	{
2598	struct bfa_bsg_fcpim_lunmask_s *iocmd =	2598	struct bfa_bsg_fcpim_lunmask_s *iocmd =
@@ -2611,7 +2611,7 @@ bfad_iocmd_fcpim_cfg_lunmask(struct bfad_s bfad, void cmd, unsigned int v_cmd) · 12 unmodified lines
2611	return 0;	2611	return 0;
2612	}	2612	}
2613		2613
2614	int	2614	static int
2615	bfad_iocmd_fcpim_throttle_query(struct bfad_s bfad, void cmd)	2615	bfad_iocmd_fcpim_throttle_query(struct bfad_s bfad, void cmd)
2616	{	2616	{
2617	struct bfa_bsg_fcpim_throttle_s *iocmd =	2617	struct bfa_bsg_fcpim_throttle_s *iocmd =
@@ -2626,7 +2626,7 @@ bfad_iocmd_fcpim_throttle_query(struct bfad_s bfad, void cmd) · 8 unmodified lines
2626	return 0;	2626	return 0;
2627	}	2627	}
2628		2628
2629	int	2629	static int
2630	bfad_iocmd_fcpim_throttle_set(struct bfad_s bfad, void cmd)	2630	bfad_iocmd_fcpim_throttle_set(struct bfad_s bfad, void cmd)
2631	{	2631	{
2632	struct bfa_bsg_fcpim_throttle_s *iocmd =	2632	struct bfa_bsg_fcpim_throttle_s *iocmd =
@@ -2641,7 +2641,7 @@ bfad_iocmd_fcpim_throttle_set(struct bfad_s bfad, void cmd) · 8 unmodified lines
2641	return 0;	2641	return 0;
2642	}	2642	}
2643		2643
2644	int	2644	static int
2645	bfad_iocmd_tfru_read(struct bfad_s bfad, void cmd)	2645	bfad_iocmd_tfru_read(struct bfad_s bfad, void cmd)
2646	{	2646	{
2647	struct bfa_bsg_tfru_s *iocmd =	2647	struct bfa_bsg_tfru_s *iocmd =
@@ -2663,7 +2663,7 @@ bfad_iocmd_tfru_read(struct bfad_s bfad, void cmd) · 15 unmodified lines
2663	return 0;	2663	return 0;
2664	}	2664	}
2665		2665
2666	int	2666	static int
2667	bfad_iocmd_tfru_write(struct bfad_s bfad, void cmd)	2667	bfad_iocmd_tfru_write(struct bfad_s bfad, void cmd)
2668	{	2668	{
2669	struct bfa_bsg_tfru_s *iocmd =	2669	struct bfa_bsg_tfru_s *iocmd =
@@ -2685,7 +2685,7 @@ bfad_iocmd_tfru_write(struct bfad_s bfad, void cmd) · 15 unmodified lines
2685	return 0;	2685	return 0;
2686	}	2686	}
2687		2687
2688	int	2688	static int
2689	bfad_iocmd_fruvpd_read(struct bfad_s bfad, void cmd)	2689	bfad_iocmd_fruvpd_read(struct bfad_s bfad, void cmd)
2690	{	2690	{
2691	struct bfa_bsg_fruvpd_s *iocmd =	2691	struct bfa_bsg_fruvpd_s *iocmd =
@@ -2707,7 +2707,7 @@ bfad_iocmd_fruvpd_read(struct bfad_s bfad, void cmd) · 15 unmodified lines
2707	return 0;	2707	return 0;
2708	}	2708	}
2709		2709
2710	int	2710	static int
2711	bfad_iocmd_fruvpd_update(struct bfad_s bfad, void cmd)	2711	bfad_iocmd_fruvpd_update(struct bfad_s bfad, void cmd)
2712	{	2712	{
2713	struct bfa_bsg_fruvpd_s *iocmd =	2713	struct bfa_bsg_fruvpd_s *iocmd =
@@ -2729,7 +2729,7 @@ bfad_iocmd_fruvpd_update(struct bfad_s bfad, void cmd) · 15 unmodified lines
2729	return 0;	2729	return 0;
2730	}	2730	}
2731		2731
2732	int	2732	static int
2733	bfad_iocmd_fruvpd_get_max_size(struct bfad_s bfad, void cmd)	2733	bfad_iocmd_fruvpd_get_max_size(struct bfad_s bfad, void cmd)
2734	{	2734	{
2735	struct bfa_bsg_fruvpd_max_size_s *iocmd =	2735	struct bfa_bsg_fruvpd_max_size_s *iocmd =
@@ -3177,7 +3177,7 @@ out: · 441 unmodified lines
3177	}	3177	}
3178		3178
3179	/* FC passthru call backs */	3179	/* FC passthru call backs */
3180	u64	3180	static u64
3181	bfad_fcxp_get_req_sgaddr_cb(void *bfad_fcxp, int sgeid)	3181	bfad_fcxp_get_req_sgaddr_cb(void *bfad_fcxp, int sgeid)
3182	{	3182	{
3183	struct bfad_fcxp *drv_fcxp = bfad_fcxp;	3183	struct bfad_fcxp *drv_fcxp = bfad_fcxp;
@@ -3189,7 +3189,7 @@ bfad_fcxp_get_req_sgaddr_cb(void *bfad_fcxp, int sgeid) · 5 unmodified lines
3189	return addr;	3189	return addr;
3190	}	3190	}
3191		3191
3192	u32	3192	static u32
3193	bfad_fcxp_get_req_sglen_cb(void *bfad_fcxp, int sgeid)	3193	bfad_fcxp_get_req_sglen_cb(void *bfad_fcxp, int sgeid)
3194	{	3194	{
3195	struct bfad_fcxp *drv_fcxp = bfad_fcxp;	3195	struct bfad_fcxp *drv_fcxp = bfad_fcxp;
@@ -3199,7 +3199,7 @@ bfad_fcxp_get_req_sglen_cb(void *bfad_fcxp, int sgeid) · 3 unmodified lines
3199	return sge->sg_len;	3199	return sge->sg_len;
3200	}	3200	}
3201		3201
3202	u64	3202	static u64
3203	bfad_fcxp_get_rsp_sgaddr_cb(void *bfad_fcxp, int sgeid)	3203	bfad_fcxp_get_rsp_sgaddr_cb(void *bfad_fcxp, int sgeid)
3204	{	3204	{
3205	struct bfad_fcxp *drv_fcxp = bfad_fcxp;	3205	struct bfad_fcxp *drv_fcxp = bfad_fcxp;
@@ -3211,7 +3211,7 @@ bfad_fcxp_get_rsp_sgaddr_cb(void *bfad_fcxp, int sgeid) · 5 unmodified lines
3211	return addr;	3211	return addr;
3212	}	3212	}
3213		3213
3214	u32	3214	static u32
3215	bfad_fcxp_get_rsp_sglen_cb(void *bfad_fcxp, int sgeid)	3215	bfad_fcxp_get_rsp_sglen_cb(void *bfad_fcxp, int sgeid)
3216	{	3216	{
3217	struct bfad_fcxp *drv_fcxp = bfad_fcxp;	3217	struct bfad_fcxp *drv_fcxp = bfad_fcxp;
@@ -3221,7 +3221,7 @@ bfad_fcxp_get_rsp_sglen_cb(void *bfad_fcxp, int sgeid) · 3 unmodified lines
3221	return sge->sg_len;	3221	return sge->sg_len;
3222	}	3222	}
3223		3223
3224	void	3224	static void
3225	bfad_send_fcpt_cb(void bfad_fcxp, struct bfa_fcxp_s fcxp, void *cbarg,	3225	bfad_send_fcpt_cb(void bfad_fcxp, struct bfa_fcxp_s fcxp, void *cbarg,
3226	bfa_status_t req_status, u32 rsp_len, u32 resid_len,	3226	bfa_status_t req_status, u32 rsp_len, u32 resid_len,
3227	struct fchs_s *rsp_fchs)	3227	struct fchs_s *rsp_fchs)
@@ -3236,7 +3236,7 @@ bfad_send_fcpt_cb(void bfad_fcxp, struct bfa_fcxp_s fcxp, void *cbarg, · 8 unmodified lines
3236	complete(&drv_fcxp->comp);	3236	complete(&drv_fcxp->comp);
3237	}	3237	}
3238		3238
3239	struct bfad_buf_info *	3239	static struct bfad_buf_info *
3240	bfad_fcxp_map_sg(struct bfad_s bfad, void payload_kbuf,	3240	bfad_fcxp_map_sg(struct bfad_s bfad, void payload_kbuf,
3241	uint32_t payload_len, uint32_t *num_sgles)	3241	uint32_t payload_len, uint32_t *num_sgles)
3242	{	3242	{
@@ -3280,7 +3280,7 @@ out_free_mem: · 37 unmodified lines
3280	return NULL;	3280	return NULL;
3281	}	3281	}
3282		3282
3283	void	3283	static void
3284	bfad_fcxp_free_mem(struct bfad_s bfad, struct bfad_buf_info buf_base,	3284	bfad_fcxp_free_mem(struct bfad_s bfad, struct bfad_buf_info buf_base,
3285	uint32_t num_sgles)	3285	uint32_t num_sgles)
3286	{	3286	{
@@ -3298,7 +3298,7 @@ bfad_fcxp_free_mem(struct bfad_s bfad, struct bfad_buf_info buf_base, · 11 unmodified lines
3298	}	3298	}
3299	}	3299	}
3300		3300
3301	int	3301	static int
3302	bfad_fcxp_bsg_send(struct bsg_job job, struct bfad_fcxp drv_fcxp,	3302	bfad_fcxp_bsg_send(struct bsg_job job, struct bfad_fcxp drv_fcxp,
3303	bfa_bsg_fcpt_t *bsg_fcpt)	3303	bfa_bsg_fcpt_t *bsg_fcpt)
3304	{	3304	{
@@ -3338,7 +3338,7 @@ bfad_fcxp_bsg_send(struct bsg_job job, struct bfad_fcxp drv_fcxp, · 33 unmodified lines
3338	return BFA_STATUS_OK;	3338	return BFA_STATUS_OK;
3339	}	3339	}
3340		3340
3341	int	3341	static int
3342	bfad_im_bsg_els_ct_request(struct bsg_job *job)	3342	bfad_im_bsg_els_ct_request(struct bsg_job *job)
3343	{	3343	{
3344	struct bfa_bsg_data *bsg_data;	3344	struct bfa_bsg_data *bsg_data;

drivers/scsi/bnx2fc/bnx2fc_fcoe.c+8−10

 /**
  * bnx2fc_update_src_mac - Update Ethernet MAC filters.
  *
- * @fip: FCoE controller.
+ * @lport: The local port
- * @old: Unicast MAC address to delete if the MAC is non-zero.
+ * @addr: Location of data to copy
- * @new: Unicast MAC address to add.
  *
  * Remove any previously-set unicast MAC filter.
  * Add secondary FCoE MAC address filter for our OUI.
 /**
  * bnx2fc_destroy - Destroy a bnx2fc FCoE interface
  *
- * @buffer: The name of the Ethernet interface to be destroyed
+ * @netdev: The net device that the FCoE interface is on
- * @kp:     The associated kernel parameter
  *
  * Called from sysfs.
  *
 	return 0;
 }
-/**
+/*
  * Deperecated: Use bnx2fc_enabled()
  */
 static int bnx2fc_disable(struct net_device *netdev)
 	return 0;
 }
-/**
+/*
  * Deprecated: Use bnx2fc_enabled()
  */
 static int bnx2fc_enable(struct net_device *netdev)
 /**
  * bnx2fc_ulp_exit - shuts down adapter instance and frees all resources
  *
- * @dev		cnic device handle
+ * @dev:	cnic device handle
  */
 static void bnx2fc_ulp_exit(struct cnic_dev *dev)
 {
 	NULL,
 };
-/**
+/*
  * scsi_host_template structure used while registering with SCSI-ml
  */
 static struct scsi_host_template bnx2fc_shost_template = {
 	.rport_event_callback	= bnx2fc_rport_event_handler,
 };
-/**
+/*
  * bnx2fc_cnic_cb - global template of bnx2fc - cnic driver interface
  *			structure carrying callback function pointers
  */

drivers/scsi/bnx2fc/bnx2fc_hwi.c+4−18

 /**
  * bnx2fc_send_session_destroy_req - initiates FCoE Session destroy
  *
- * @port:		port structure pointer
+ * @hba:		adapter structure pointer
  * @tgt:		bnx2fc_rport structure pointer
  */
 int bnx2fc_send_session_destroy_req(struct bnx2fc_hba *hba,
 	struct bnx2fc_cmd *io_req = NULL;
 	struct bnx2fc_interface *interface = tgt->port->priv;
 	struct bnx2fc_hba *hba = interface->hba;
-	int task_idx, index;
 	int rc = 0;
 	u64 err_warn_bit_map;
 	u8 err_warn = 0xff;
 		BNX2FC_TGT_DBG(tgt, "buf_offsets - tx = 0x%x, rx = 0x%x\n",
 			err_entry->data.tx_buf_off, err_entry->data.rx_buf_off);
 		if (xid > hba->max_xid) {
 			BNX2FC_TGT_DBG(tgt, "xid(0x%x) out of FW range\n",
 				   xid);
 			goto ret_err_rqe;
 		}
-		task_idx = xid / BNX2FC_TASKS_PER_PAGE;
-		index = xid % BNX2FC_TASKS_PER_PAGE;
 		io_req = (struct bnx2fc_cmd *)hba->cmd_mgr->cmds[xid];
 		if (!io_req)
 		}
 		BNX2FC_TGT_DBG(tgt, "warn = 0x%x\n", err_warn);
-		task_idx = xid / BNX2FC_TASKS_PER_PAGE;
-		index = xid % BNX2FC_TASKS_PER_PAGE;
 		io_req = (struct bnx2fc_cmd *)hba->cmd_mgr->cmds[xid];
 		if (!io_req)
 			goto ret_warn_rqe;
 	unsigned char *rq_data = NULL;
 	unsigned char rq_data_buff[BNX2FC_RQ_BUF_SZ];
 	int task_idx, index;
-	unsigned char *dummy;
 	u16 xid;
 	u8 num_rq;
 	int i;
 	if (num_rq > 1) {
 		/* We do not need extra sense data */
 		for (i = 1; i < num_rq; i++)
-			dummy = bnx2fc_get_next_rqe(tgt, 1);
+			bnx2fc_get_next_rqe(tgt, 1);
 	}
 	if (rq_data)
 /**
  * bnx2fc_indicae_kcqe - process KCQE
  *
- * @hba:	adapter structure pointer
+ * @context:	adapter structure pointer
- * @kcqe:	kcqe pointer
+ * @kcq:	kcqe pointer
  * @num_cqe:	Number of completion queue elements
  *
  * Generic KCQ event handler
 	u64 phys_addr = (u64)orig_io_req->bd_tbl->bd_tbl_dma;
 	u32 orig_offset = offset;
 	int bd_count;
-	int orig_task_idx, index;
 	int i;
 	memset(task, 0, sizeof(struct fcoe_task_ctx_entry));
 				offset; /* adjusted offset */
 		task->txwr_only.sgl_ctx.sgl.mul_sgl.cur_sge_idx = i;
 	} else {
-		orig_task_idx = orig_xid / BNX2FC_TASKS_PER_PAGE;
-		index = orig_xid % BNX2FC_TASKS_PER_PAGE;
 		/* Multiple SGEs were used for this IO */
 		sgl = &task->rxwr_only.union_ctx.read_info.sgl_ctx.sgl;
 	pbl = hba->hash_tbl_pbl;
 	i = 0;
 	while (*pbl && *(pbl + 1)) {
-		u32 lo;
-		u32 hi;
-		lo = *pbl;
 		++pbl;
-		hi = *pbl;
 		++pbl;
 		++i;
 	}

drivers/scsi/bnx2fc/bnx2fc_tgt.c+3−4

 	return 0;
 }
-/**
+/*
  * This event_callback is called after successful completion of libfc
  * initiated target login. bnx2fc can proceed with initiating the session
  * establishment.
 	spin_unlock_bh(&hba->hba_lock);
 }
-/**
+/*
- *bnx2fc_alloc_session_resc - Allocate qp resources for the session
+ * bnx2fc_alloc_session_resc - Allocate qp resources for the session
- *
  */
 static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
 					struct bnx2fc_rport *tgt)

drivers/scsi/bnx2i/bnx2i_hwi.c+27−26

 /**
  * bnx2i_get_rq_buf - copy RQ buffer contents to driver buffer
- * @conn:		iscsi connection on which RQ event occurred
+ * @bnx2i_conn:		iscsi connection on which RQ event occurred
  * @ptr:		driver buffer to which RQ buffer contents is to
  *			be copied
  * @len:		length of valid data inside RQ buf
 /**
  * bnx2i_put_rq_buf - Replenish RQ buffer, if required ring on chip doorbell
- * @conn:	iscsi connection on which event to post
+ * @bnx2i_conn:	iscsi connection on which event to post
  * @count:	number of RQ buffer being posted to chip
  *
  * No need to ring hardware doorbell for 57710 family of devices
 /**
  * bnx2i_ring_sq_dbell - Ring SQ doorbell to wake-up the processing engine
- * @conn: 		iscsi connection to which new SQ entries belong
+ * @bnx2i_conn:		iscsi connection to which new SQ entries belong
  * @count: 		number of SQ WQEs to post
  *
  * SQ DB is updated in host memory and TX Doorbell is rung for 57710 family
 /**
  * bnx2i_ring_dbell_update_sq_params - update SQ driver parameters
- * @conn:	iscsi connection to which new SQ entries belong
+ * @bnx2i_conn:	iscsi connection to which new SQ entries belong
  * @count:	number of SQ WQEs to post
  *
  * this routine will update SQ driver parameters and ring the doorbell
 /**
  * bnx2i_send_iscsi_login - post iSCSI login request MP WQE to hardware
- * @conn:	iscsi connection
+ * @bnx2i_conn:	iscsi connection
- * @cmd:	driver command structure which is requesting
+ * @task: transport layer's command structure pointer which is requesting
- *		a WQE to sent to chip for further processing
+ *	  a WQE to sent to chip for further processing
  *
  * prepare and post an iSCSI Login request WQE to CNIC firmware
  */
 /**
  * bnx2i_send_iscsi_tmf - post iSCSI task management request MP WQE to hardware
- * @conn:	iscsi connection
+ * @bnx2i_conn:	iscsi connection
  * @mtask:	driver command structure which is requesting
  *		a WQE to sent to chip for further processing
  *
 /**
  * bnx2i_send_iscsi_text - post iSCSI text WQE to hardware
- * @conn:	iscsi connection
+ * @bnx2i_conn:	iscsi connection
  * @mtask:	driver command structure which is requesting
  *		a WQE to sent to chip for further processing
  *
 /**
  * bnx2i_send_iscsi_scsicmd - post iSCSI scsicmd request WQE to hardware
- * @conn:	iscsi connection
+ * @bnx2i_conn:	iscsi connection
  * @cmd:	driver command structure which is requesting
  *		a WQE to sent to chip for further processing
  *
 /**
  * bnx2i_send_iscsi_nopout - post iSCSI NOPOUT request WQE to hardware
- * @conn:		iscsi connection
+ * @bnx2i_conn:		iscsi connection
- * @cmd:		driver command structure which is requesting
+ * @task:		transport layer's command structure pointer which is
- *			a WQE to sent to chip for further processing
+ *                      requesting a WQE to sent to chip for further processing
  * @datap:		payload buffer pointer
  * @data_len:		payload data length
  * @unsol:		indicated whether nopout pdu is unsolicited pdu or
 /**
  * bnx2i_send_iscsi_logout - post iSCSI logout request WQE to hardware
- * @conn:	iscsi connection
+ * @bnx2i_conn:	iscsi connection
- * @cmd:	driver command structure which is requesting
+ * @task:	transport layer's command structure pointer which is
- *		a WQE to sent to chip for further processing
+ *		requesting a WQE to sent to chip for further processing
  *
  * prepare and post logout request WQE to CNIC firmware
  */
 /**
  * bnx2i_ep_ofld_timer - post iSCSI logout request WQE to hardware
- * @data:	endpoint (transport handle) structure pointer
+ * @t:	timer context used to fetch the endpoint (transport
+ *	handle) structure pointer
  *
  * routine to handle connection offload/destroy request timeout
  */
 /**
  * bnx2i_unsol_pdu_adjust_rq - makes adjustments to RQ after unsol pdu is recvd
- * @conn:	iscsi connection
+ * @bnx2i_conn:	iscsi connection
  *
  * Firmware advances RQ producer index for every unsolicited PDU even if
  *	payload data length is '0'. This function makes corresponding
 /**
  * bnx2i_queue_scsi_cmd_resp - queue cmd completion to the percpu thread
+ * @session:		iscsi session
  * @bnx2i_conn:		bnx2i connection
+ * @cqe:		pointer to newly DMA'ed CQE entry for processing
  *
  * this function is called by generic KCQ handler to queue all pending cmd
  * completion CQEs
 /**
  * bnx2i_indicate_kcqe - process iscsi conn update completion KCQE
- * @hba:		adapter structure pointer
+ * @context:		adapter structure pointer
- * @update_kcqe:	kcqe pointer
+ * @kcqe:		kcqe pointer
+ * @num_cqe:		number of kcqes to process
  *
  * Generic KCQ event handler/dispatcher
  */
 /**
  * bnx2i_cm_remote_close - process received TCP FIN
- * @hba:		adapter structure pointer
+ * @cm_sk:	cnic sock structure pointer
- * @update_kcqe:	kcqe pointer
  *
  * function callback exported via bnx2i - cnic driver interface to indicate
  *	async TCP events such as FIN
 /**
  * bnx2i_cm_remote_abort - process TCP RST and start conn cleanup
- * @hba:		adapter structure pointer
+ * @cm_sk:	cnic sock structure pointer
- * @update_kcqe:	kcqe pointer
  *
  * function callback exported via bnx2i - cnic driver interface to
  *	indicate async TCP events (RST) sent by the peer.
 }
-/**
+/*
  * bnx2i_cnic_cb - global template of bnx2i - cnic driver interface structure
  *			carrying callback function pointers
- *
  */
 struct cnic_ulp_ops bnx2i_cnic_cb = {
 	.cnic_init = bnx2i_ulp_init,

drivers/scsi/bnx2i/bnx2i_init.c+1−1

@@ -73,7 +73,7 @@ DEFINE_PER_CPU(struct bnx2i_percpu_s, bnx2i_percpu); · 72 unmodified lines
73	/**	73	/**
74	* bnx2i_identify_device - identifies NetXtreme II device type	74	* bnx2i_identify_device - identifies NetXtreme II device type
75	* @hba: Adapter structure pointer	75	* @hba: Adapter structure pointer
76	* @cnic: Corresponding cnic device	76	* @dev: Corresponding cnic device
77	*	77	*
78	* This function identifies the NX2 device type and sets appropriate	78	* This function identifies the NX2 device type and sets appropriate
79	* queue mailbox register access method, 5709 requires driver to	79	* queue mailbox register access method, 5709 requires driver to

drivers/scsi/bnx2i/bnx2i_iscsi.c+9−10

 /**
  * bnx2i_bind_conn_to_iscsi_cid - bind conn structure to 'iscsi_cid'
  * @hba:	pointer to adapter instance
- * @conn:	pointer to iscsi connection
+ * @bnx2i_conn:	pointer to iscsi connection
  * @iscsi_cid:	iscsi context ID, range 0 - (MAX_CONN - 1)
  *
  * update iscsi cid table entry with connection pointer. This enables
  * bnx2i_destroy_cmd_pool - destroys iscsi command pool and release BD table
  * @hba:	adapter instance pointer
  * @session:	iscsi session pointer
- * @cmd:	iscsi command structure
  */
 static void bnx2i_destroy_cmd_pool(struct bnx2i_hba *hba,
 				   struct iscsi_session *session)
 /**
  * bnx2i_drop_session - notifies iscsid of connection error.
- * @hba:	adapter instance pointer
+ * @cls_session:	iscsi cls session pointer
- * @session:	iscsi session pointer
  *
  * This notifies iscsid that there is a error, so it can initiate
  * recovery.
 /**
  * bnx2i_session_create - create a new iscsi session
- * @cmds_max:		max commands supported
+ * @ep:		pointer to iscsi endpoint
+ * @cmds_max:		user specified maximum commands
  * @qdepth:		scsi queue depth to support
  * @initial_cmdsn:	initial iscsi CMDSN to be used for this session
  *
 /**
  * bnx2i_ep_tcp_conn_active - check EP state transition
- * @ep:		endpoint pointer
+ * @bnx2i_ep:		endpoint pointer
  *
  * check if underlying TCP connection is active
  */
 }
-/*
+/**
  * bnx2i_hw_ep_disconnect - executes TCP connection teardown process in the hw
- * @ep:		TCP connection (bnx2i endpoint) handle
+ * @bnx2i_ep:		TCP connection (bnx2i endpoint) handle
  *
  * executes  TCP connection teardown process
  */
 /**
  * bnx2i_nl_set_path - ISCSI_UEVENT_PATH_UPDATE user message handler
- * @buf:	pointer to buffer containing iscsi path message
+ * @shost:	scsi host pointer
- *
+ * @params:	pointer to buffer containing iscsi path message
  */
 static int bnx2i_nl_set_path(struct Scsi_Host *shost, struct iscsi_path *params)
 {

drivers/scsi/bnx2i/bnx2i_sysfs.c+4−0

 /**
  * bnx2i_show_sq_info - return(s currently configured send queue (SQ) size
  * @dev:	device pointer
+ * @attr:	device attribute (unused)
  * @buf:	buffer to return current SQ size parameter
  *
  * Returns current SQ size parameter, this paramater determines the number
 /**
  * bnx2i_set_sq_info - update send queue (SQ) size parameter
  * @dev:	device pointer
+ * @attr:	device attribute (unused)
  * @buf:	buffer to return current SQ size parameter
  * @count:	parameter buffer size
  *
 /**
  * bnx2i_show_ccell_info - returns command cell (HQ) size
  * @dev:	device pointer
+ * @attr:	device attribute (unused)
  * @buf:	buffer to return current SQ size parameter
  *
  * returns per-connection TCP history queue size parameter
 /**
  * bnx2i_get_link_state - set command cell (HQ) size
  * @dev:	device pointer
+ * @attr:	device attribute (unused)
  * @buf:	buffer to return current SQ size parameter
  * @count:	parameter buffer size
  *

drivers/scsi/csiostor/csio_hw.c+1−1

@@ -306,7 +306,7 @@ csio_hw_get_vpd_params(struct csio_hw hw, struct csio_vpd p) · 305 unmodified lines
306	uint8_t *vpd, csum;	306	uint8_t *vpd, csum;
307	const struct t4_vpd_hdr *v;	307	const struct t4_vpd_hdr *v;
308	/* To get around compilation warning from strstrip */	308	/* To get around compilation warning from strstrip */
309	char *s;	309	char __always_unused *s;
310		310
311	if (csio_is_valid_vpd(hw))	311	if (csio_is_valid_vpd(hw))
312	return 0;	312	return 0;

drivers/scsi/csiostor/csio_hw_t5.c+2−4

 {
 	int i;
 	uint32_t mc_bist_cmd_reg, mc_bist_cmd_addr_reg, mc_bist_cmd_len_reg;
-	uint32_t mc_bist_status_rdata_reg, mc_bist_data_pattern_reg;
+	uint32_t mc_bist_data_pattern_reg;
 	mc_bist_cmd_reg = MC_REG(MC_P_BIST_CMD_A, idx);
 	mc_bist_cmd_addr_reg = MC_REG(MC_P_BIST_CMD_ADDR_A, idx);
 	mc_bist_cmd_len_reg = MC_REG(MC_P_BIST_CMD_LEN_A, idx);
-	mc_bist_status_rdata_reg = MC_REG(MC_P_BIST_STATUS_RDATA_A, idx);
 	mc_bist_data_pattern_reg = MC_REG(MC_P_BIST_DATA_PATTERN_A, idx);
 	if (csio_rd_reg32(hw, mc_bist_cmd_reg) & START_BIST_F)
 {
 	int i;
 	uint32_t edc_bist_cmd_reg, edc_bist_cmd_addr_reg, edc_bist_cmd_len_reg;
-	uint32_t edc_bist_cmd_data_pattern, edc_bist_status_rdata_reg;
+	uint32_t edc_bist_cmd_data_pattern;
 /*
  * These macro are missing in t4_regs.h file.
 	edc_bist_cmd_addr_reg = EDC_REG_T5(EDC_H_BIST_CMD_ADDR_A, idx);
 	edc_bist_cmd_len_reg = EDC_REG_T5(EDC_H_BIST_CMD_LEN_A, idx);
 	edc_bist_cmd_data_pattern = EDC_REG_T5(EDC_H_BIST_DATA_PATTERN_A, idx);
-	edc_bist_status_rdata_reg = EDC_REG_T5(EDC_H_BIST_STATUS_RDATA_A, idx);
 #undef EDC_REG_T5
 #undef EDC_STRIDE_T5

drivers/scsi/csiostor/csio_init.c+1−1

@@ -582,7 +582,7 @@ csio_hw_free(struct csio_hw *hw) · 581 unmodified lines
582	* @hw: The HW module.	582	* @hw: The HW module.
583	* @dev: The device associated with this invocation.	583	* @dev: The device associated with this invocation.
584	* @probe: Called from probe context or not?	584	* @probe: Called from probe context or not?
585	* @os_pln: Parent lnode if any.	585	* @pln: Parent lnode if any.
586	*	586	*
587	* Allocates lnode structure via scsi_host_alloc, initializes	587	* Allocates lnode structure via scsi_host_alloc, initializes
588	* shost, initializes lnode module and registers with SCSI ML	588	* shost, initializes lnode module and registers with SCSI ML

drivers/scsi/csiostor/csio_lnode.c+1−2

 	ln->fcfinfo = NULL;
 }
-/**
+/*
  * csio_lnode_init - Initialize the members of an lnode.
  * @ln:		lnode
- *
  */
 int
 csio_lnode_init(struct csio_lnode *ln, struct csio_hw *hw,

drivers/scsi/csiostor/csio_rnode.c+1−1

@@ -862,7 +862,7 @@ csio_rnode_devloss_handler(struct csio_rnode *rn) · 861 unmodified lines
862	/**	862	/**
863	* csio_rnode_fwevt_handler - Event handler for firmware rnode events.	863	* csio_rnode_fwevt_handler - Event handler for firmware rnode events.
864	* @rn: rnode	864	* @rn: rnode
865	*	865	* @fwevt: firmware event to handle
866	*/	866	*/
867	void	867	void
868	csio_rnode_fwevt_handler(struct csio_rnode *rn, uint8_t fwevt)	868	csio_rnode_fwevt_handler(struct csio_rnode *rn, uint8_t fwevt)

drivers/scsi/cxgbi/cxgb3i/cxgb3i.c+7−10

 	/* len includes the length of any HW ULP additions */
 	req->len = htonl(len);
 	/* V_TX_ULP_SUBMODE sets both the mode and submode */
-	req->flags = htonl(V_TX_ULP_SUBMODE(cxgbi_skcb_ulp_mode(skb)) |
+	req->flags = htonl(V_TX_ULP_SUBMODE(cxgbi_skcb_tx_ulp_mode(skb)) |
 			   V_TX_SHOVE((skb_peek(&csk->write_queue) ? 0 : 1)));
 	req->sndseq = htonl(csk->snd_nxt);
 	req->param = htonl(V_TX_PORT(l2t->smt_idx));
 	}
 }
-/**
+/*
  * push_tx_frames -- start transmit
- * @c3cn: the offloaded connection
- * @req_completion: request wr_ack or not
  *
  * Prepends TX_DATA_WR or CPL_CLOSE_CON_REQ headers to buffers waiting in a
  * connection's send queue and sends them on to T3.  Must be called with the
 				req_completion = 1;
 				csk->wr_una_cred = 0;
 			}
-			len += cxgbi_ulp_extra_len(cxgbi_skcb_ulp_mode(skb));
+			len += cxgbi_ulp_extra_len(cxgbi_skcb_tx_ulp_mode(skb));
 			make_tx_data_wr(csk, skb, len, req_completion);
 			csk->snd_nxt += len;
 			cxgbi_skcb_clear_flag(skb, SKCBF_TX_NEED_HDR);
 	return -ENOMEM;
 }
-/**
- * release_offload_resources - release offload resource
- * @c3cn: the offloaded iscsi tcp connection.
- * Release resources held by an offload connection (TID, L2T entry, etc.)
- */
 static void l2t_put(struct cxgbi_sock *csk)
 {
 	struct t3cdev *t3dev = (struct t3cdev *)csk->cdev->lldev;
 	}
 }
+/*
+ * release_offload_resources - release offload resource
+ * Release resources held by an offload connection (TID, L2T entry, etc.)
+ */
 static void release_offload_resources(struct cxgbi_sock *csk)
 {
 	struct t3cdev *t3dev = (struct t3cdev *)csk->cdev->lldev;

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c+184−58

@@ -197,7 +197,10 @@ static inline bool is_ofld_imm(const struct sk_buff *skb) · 196 unmodified lines
197	if (likely(cxgbi_skcb_test_flag(skb, SKCBF_TX_NEED_HDR)))	197	if (likely(cxgbi_skcb_test_flag(skb, SKCBF_TX_NEED_HDR)))
198	len += sizeof(struct fw_ofld_tx_data_wr);	198	len += sizeof(struct fw_ofld_tx_data_wr);
199		199
200	return len <= MAX_IMM_TX_PKT_LEN;	200	if (likely(cxgbi_skcb_test_flag((struct sk_buff *)skb, SKCBF_TX_ISO)))
		201	len += sizeof(struct cpl_tx_data_iso);
		202
		203	return (len <= MAX_IMM_OFLD_TX_DATA_WR_LEN);
201	}	204	}
202		205
203	static void send_act_open_req(struct cxgbi_sock csk, struct sk_buff skb,	206	static void send_act_open_req(struct cxgbi_sock csk, struct sk_buff skb,
@@ -641,7 +644,10 @@ static inline int send_tx_flowc_wr(struct cxgbi_sock *csk) · 437 unmodified lines
641	flowc->mnemval[8].mnemonic = 0;	644	flowc->mnemval[8].mnemonic = 0;
642	flowc->mnemval[8].val = 0;	645	flowc->mnemval[8].val = 0;
643	flowc->mnemval[8].mnemonic = FW_FLOWC_MNEM_TXDATAPLEN_MAX;	646	flowc->mnemval[8].mnemonic = FW_FLOWC_MNEM_TXDATAPLEN_MAX;
644	flowc->mnemval[8].val = 16384;	647	if (csk->cdev->skb_iso_txhdr)
		648	flowc->mnemval[8].val = cpu_to_be32(CXGBI_MAX_ISO_DATA_IN_SKB);
		649	else
		650	flowc->mnemval[8].val = cpu_to_be32(16128);
645	#ifdef CONFIG_CHELSIO_T4_DCB	651	#ifdef CONFIG_CHELSIO_T4_DCB
646	flowc->mnemval[9].mnemonic = FW_FLOWC_MNEM_DCBPRIO;	652	flowc->mnemval[9].mnemonic = FW_FLOWC_MNEM_DCBPRIO;
647	if (vlan == CPL_L2T_VLAN_NONE) {	653	if (vlan == CPL_L2T_VLAN_NONE) {
@@ -667,38 +673,86 @@ static inline int send_tx_flowc_wr(struct cxgbi_sock *csk) · 19 unmodified lines
667	return flowclen16;	673	return flowclen16;
668	}	674	}
669		675
670	static inline void make_tx_data_wr(struct cxgbi_sock csk, struct sk_buff skb,	676	static void
671	int dlen, int len, u32 credits, int compl)	677	cxgb4i_make_tx_iso_cpl(struct sk_buff skb, struct cpl_tx_data_iso cpl)
		678	{
		679	struct cxgbi_iso_info info = (struct cxgbi_iso_info )skb->head;
		680	u32 imm_en = !!(info->flags & CXGBI_ISO_INFO_IMM_ENABLE);
		681	u32 fslice = !!(info->flags & CXGBI_ISO_INFO_FSLICE);
		682	u32 lslice = !!(info->flags & CXGBI_ISO_INFO_LSLICE);
		683	u32 pdu_type = (info->op == ISCSI_OP_SCSI_CMD) ? 0 : 1;
		684	u32 submode = cxgbi_skcb_tx_ulp_mode(skb) & 0x3;
		685
		686	cpl->op_to_scsi = cpu_to_be32(CPL_TX_DATA_ISO_OP_V(CPL_TX_DATA_ISO) \|
		687	CPL_TX_DATA_ISO_FIRST_V(fslice) \|
		688	CPL_TX_DATA_ISO_LAST_V(lslice) \|
		689	CPL_TX_DATA_ISO_CPLHDRLEN_V(0) \|
		690	CPL_TX_DATA_ISO_HDRCRC_V(submode & 1) \|
		691	CPL_TX_DATA_ISO_PLDCRC_V(((submode >> 1) & 1)) \|
		692	CPL_TX_DATA_ISO_IMMEDIATE_V(imm_en) \|
		693	CPL_TX_DATA_ISO_SCSI_V(pdu_type));
		694
		695	cpl->ahs_len = info->ahs;
		696	cpl->mpdu = cpu_to_be16(DIV_ROUND_UP(info->mpdu, 4));
		697	cpl->burst_size = cpu_to_be32(info->burst_size);
		698	cpl->len = cpu_to_be32(info->len);
		699	cpl->reserved2_seglen_offset =
		700	cpu_to_be32(CPL_TX_DATA_ISO_SEGLEN_OFFSET_V(info->segment_offset));
		701	cpl->datasn_offset = cpu_to_be32(info->datasn_offset);
		702	cpl->buffer_offset = cpu_to_be32(info->buffer_offset);
		703	cpl->reserved3 = cpu_to_be32(0);
		704	log_debug(1 << CXGBI_DBG_ISCSI \| 1 << CXGBI_DBG_PDU_TX,
		705	"iso: flags 0x%x, op %u, ahs %u, num_pdu %u, mpdu %u, "
		706	"burst_size %u, iso_len %u\n",
		707	info->flags, info->op, info->ahs, info->num_pdu,
		708	info->mpdu, info->burst_size << 2, info->len);
		709	}
		710
		711	static void
		712	cxgb4i_make_tx_data_wr(struct cxgbi_sock csk, struct sk_buff skb, int dlen,
		713	int len, u32 credits, int compl)
672	{	714	{
		715	struct cxgbi_device *cdev = csk->cdev;
		716	struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
673	struct fw_ofld_tx_data_wr *req;	717	struct fw_ofld_tx_data_wr *req;
674	unsigned int submode = cxgbi_skcb_ulp_mode(skb) & 3;	718	struct cpl_tx_data_iso *cpl;
675	unsigned int wr_ulp_mode = 0, val;	719	u32 submode = cxgbi_skcb_tx_ulp_mode(skb) & 0x3;
676	bool imm = is_ofld_imm(skb);	720	u32 wr_ulp_mode = 0;
677		721	u32 hdr_size = sizeof(*req);
678	req = __skb_push(skb, sizeof(*req));	722	u32 opcode = FW_OFLD_TX_DATA_WR;
679		723	u32 immlen = 0;
680	if (imm) {	724	u32 force = is_t5(lldi->adapter_type) ? TX_FORCE_V(!submode) :
681	req->op_to_immdlen = htonl(FW_WR_OP_V(FW_OFLD_TX_DATA_WR) \|	725	T6_TX_FORCE_F;
682	FW_WR_COMPL_F \|	726
683	FW_WR_IMMDLEN_V(dlen));	727	if (cxgbi_skcb_test_flag(skb, SKCBF_TX_ISO)) {
684	req->flowid_len16 = htonl(FW_WR_FLOWID_V(csk->tid) \|	728	hdr_size += sizeof(struct cpl_tx_data_iso);
685	FW_WR_LEN16_V(credits));	729	opcode = FW_ISCSI_TX_DATA_WR;
686	} else {	730	immlen += sizeof(struct cpl_tx_data_iso);
687	req->op_to_immdlen =	731	submode \|= 8;
688	cpu_to_be32(FW_WR_OP_V(FW_OFLD_TX_DATA_WR) \|
689	FW_WR_COMPL_F \|
690	FW_WR_IMMDLEN_V(0));
691	req->flowid_len16 =
692	cpu_to_be32(FW_WR_FLOWID_V(csk->tid) \|
693	FW_WR_LEN16_V(credits));
694	}	732	}
		733
		734	if (is_ofld_imm(skb))
		735	immlen += dlen;
		736
		737	req = (struct fw_ofld_tx_data_wr *)__skb_push(skb, hdr_size);
		738	req->op_to_immdlen = cpu_to_be32(FW_WR_OP_V(opcode) \|
		739	FW_WR_COMPL_V(compl) \|
		740	FW_WR_IMMDLEN_V(immlen));
		741	req->flowid_len16 = cpu_to_be32(FW_WR_FLOWID_V(csk->tid) \|
		742	FW_WR_LEN16_V(credits));
		743	req->plen = cpu_to_be32(len);
		744	cpl = (struct cpl_tx_data_iso *)(req + 1);
		745
		746	if (likely(cxgbi_skcb_test_flag(skb, SKCBF_TX_ISO)))
		747	cxgb4i_make_tx_iso_cpl(skb, cpl);
		748
695	if (submode)	749	if (submode)
696	wr_ulp_mode = FW_OFLD_TX_DATA_WR_ULPMODE_V(ULP2_MODE_ISCSI) \|	750	wr_ulp_mode = FW_OFLD_TX_DATA_WR_ULPMODE_V(ULP2_MODE_ISCSI) \|
697	FW_OFLD_TX_DATA_WR_ULPSUBMODE_V(submode);	751	FW_OFLD_TX_DATA_WR_ULPSUBMODE_V(submode);
698	val = skb_peek(&csk->write_queue) ? 0 : 1;	752
699	req->tunnel_to_proxy = htonl(wr_ulp_mode \|	753	req->tunnel_to_proxy = cpu_to_be32(wr_ulp_mode \| force \|
700	FW_OFLD_TX_DATA_WR_SHOVE_V(val));	754	FW_OFLD_TX_DATA_WR_SHOVE_V(1U));
701	req->plen = htonl(len);	755
702	if (!cxgbi_sock_flag(csk, CTPF_TX_DATA_SENT))	756	if (!cxgbi_sock_flag(csk, CTPF_TX_DATA_SENT))
703	cxgbi_sock_set_flag(csk, CTPF_TX_DATA_SENT);	757	cxgbi_sock_set_flag(csk, CTPF_TX_DATA_SENT);
704	}	758	}
@@ -716,30 +770,34 @@ static int push_tx_frames(struct cxgbi_sock *csk, int req_completion) · 11 unmodified lines
716	if (unlikely(csk->state < CTP_ESTABLISHED \|\|	770	if (unlikely(csk->state < CTP_ESTABLISHED \|\|
717	csk->state == CTP_CLOSE_WAIT_1 \|\| csk->state >= CTP_ABORTING)) {	771	csk->state == CTP_CLOSE_WAIT_1 \|\| csk->state >= CTP_ABORTING)) {
718	log_debug(1 << CXGBI_DBG_TOE \| 1 << CXGBI_DBG_SOCK \|	772	log_debug(1 << CXGBI_DBG_TOE \| 1 << CXGBI_DBG_SOCK \|
719	1 << CXGBI_DBG_PDU_TX,	773	1 << CXGBI_DBG_PDU_TX,
720	"csk 0x%p,%u,0x%lx,%u, in closing state.\n",	774	"csk 0x%p,%u,0x%lx,%u, in closing state.\n",
721	csk, csk->state, csk->flags, csk->tid);	775	csk, csk->state, csk->flags, csk->tid);
722	return 0;	776	return 0;
723	}	777	}
724		778
725	while (csk->wr_cred && (skb = skb_peek(&csk->write_queue)) != NULL) {	779	while (csk->wr_cred && ((skb = skb_peek(&csk->write_queue)) != NULL)) {
726	int dlen = skb->len;	780	struct cxgbi_iso_info *iso_cpl;
727	int len = skb->len;	781	u32 dlen = skb->len;
728	unsigned int credits_needed;	782	u32 len = skb->len;
729	int flowclen16 = 0;	783	u32 iso_cpl_len = 0;
		784	u32 flowclen16 = 0;
		785	u32 credits_needed;
		786	u32 num_pdu = 1, hdr_len;
		787
		788	if (cxgbi_skcb_test_flag(skb, SKCBF_TX_ISO))
		789	iso_cpl_len = sizeof(struct cpl_tx_data_iso);
730		790
731	skb_reset_transport_header(skb);
732	if (is_ofld_imm(skb))	791	if (is_ofld_imm(skb))
733	credits_needed = DIV_ROUND_UP(dlen, 16);	792	credits_needed = DIV_ROUND_UP(dlen + iso_cpl_len, 16);
734	else	793	else
735	credits_needed = DIV_ROUND_UP(	794	credits_needed =
736	8 * calc_tx_flits_ofld(skb),	795	DIV_ROUND_UP((8 * calc_tx_flits_ofld(skb)) +
737	16);	796	iso_cpl_len, 16);
738		797
739	if (likely(cxgbi_skcb_test_flag(skb, SKCBF_TX_NEED_HDR)))	798	if (likely(cxgbi_skcb_test_flag(skb, SKCBF_TX_NEED_HDR)))
740	credits_needed += DIV_ROUND_UP(	799	credits_needed +=
741	sizeof(struct fw_ofld_tx_data_wr),	800	DIV_ROUND_UP(sizeof(struct fw_ofld_tx_data_wr), 16);
742	16);
743		801
744	/*	802	/*
745	* Assumes the initial credits is large enough to support	803	* Assumes the initial credits is large enough to support
@@ -754,14 +812,19 @@ static int push_tx_frames(struct cxgbi_sock *csk, int req_completion) · 8 unmodified lines
754		812
755	if (csk->wr_cred < credits_needed) {	813	if (csk->wr_cred < credits_needed) {
756	log_debug(1 << CXGBI_DBG_PDU_TX,	814	log_debug(1 << CXGBI_DBG_PDU_TX,
757	"csk 0x%p, skb %u/%u, wr %d < %u.\n",	815	"csk 0x%p, skb %u/%u, wr %d < %u.\n",
758	csk, skb->len, skb->data_len,	816	csk, skb->len, skb->data_len,
759	credits_needed, csk->wr_cred);	817	credits_needed, csk->wr_cred);
		818
		819	csk->no_tx_credits++;
760	break;	820	break;
761	}	821	}
		822
		823	csk->no_tx_credits = 0;
		824
762	__skb_unlink(skb, &csk->write_queue);	825	__skb_unlink(skb, &csk->write_queue);
763	set_wr_txq(skb, CPL_PRIORITY_DATA, csk->port_id);	826	set_wr_txq(skb, CPL_PRIORITY_DATA, csk->port_id);
764	skb->csum = credits_needed + flowclen16;	827	skb->csum = (__force __wsum)(credits_needed + flowclen16);
765	csk->wr_cred -= credits_needed;	828	csk->wr_cred -= credits_needed;
766	csk->wr_una_cred += credits_needed;	829	csk->wr_una_cred += credits_needed;
767	cxgbi_sock_enqueue_wr(csk, skb);	830	cxgbi_sock_enqueue_wr(csk, skb);
@@ -771,25 +834,42 @@ static int push_tx_frames(struct cxgbi_sock *csk, int req_completion) · 3 unmodified lines
771	csk, skb->len, skb->data_len, credits_needed,	834	csk, skb->len, skb->data_len, credits_needed,
772	csk->wr_cred, csk->wr_una_cred);	835	csk->wr_cred, csk->wr_una_cred);
773		836
		837	if (!req_completion &&
		838	((csk->wr_una_cred >= (csk->wr_max_cred / 2)) \|\|
		839	after(csk->write_seq, (csk->snd_una + csk->snd_win / 2))))
		840	req_completion = 1;
		841
774	if (likely(cxgbi_skcb_test_flag(skb, SKCBF_TX_NEED_HDR))) {	842	if (likely(cxgbi_skcb_test_flag(skb, SKCBF_TX_NEED_HDR))) {
775	len += cxgbi_ulp_extra_len(cxgbi_skcb_ulp_mode(skb));	843	u32 ulp_mode = cxgbi_skcb_tx_ulp_mode(skb);
776	make_tx_data_wr(csk, skb, dlen, len, credits_needed,	844
777	req_completion);	845	if (cxgbi_skcb_test_flag(skb, SKCBF_TX_ISO)) {
		846	iso_cpl = (struct cxgbi_iso_info *)skb->head;
		847	num_pdu = iso_cpl->num_pdu;
		848	hdr_len = cxgbi_skcb_tx_iscsi_hdrlen(skb);
		849	len += (cxgbi_ulp_extra_len(ulp_mode) * num_pdu) +
		850	(hdr_len * (num_pdu - 1));
		851	} else {
		852	len += cxgbi_ulp_extra_len(ulp_mode);
		853	}
		854
		855	cxgb4i_make_tx_data_wr(csk, skb, dlen, len,
		856	credits_needed, req_completion);
778	csk->snd_nxt += len;	857	csk->snd_nxt += len;
779	cxgbi_skcb_clear_flag(skb, SKCBF_TX_NEED_HDR);	858	cxgbi_skcb_clear_flag(skb, SKCBF_TX_NEED_HDR);
780	} else if (cxgbi_skcb_test_flag(skb, SKCBF_TX_FLAG_COMPL) &&	859	} else if (cxgbi_skcb_test_flag(skb, SKCBF_TX_FLAG_COMPL) &&
781	(csk->wr_una_cred >= (csk->wr_max_cred / 2))) {	860	(csk->wr_una_cred >= (csk->wr_max_cred / 2))) {
782	struct cpl_close_con_req *req =	861	struct cpl_close_con_req *req =
783	(struct cpl_close_con_req *)skb->data;	862	(struct cpl_close_con_req *)skb->data;
784	req->wr.wr_hi \|= htonl(FW_WR_COMPL_F);	863
		864	req->wr.wr_hi \|= cpu_to_be32(FW_WR_COMPL_F);
785	}	865	}
		866
786	total_size += skb->truesize;	867	total_size += skb->truesize;
787	t4_set_arp_err_handler(skb, csk, arp_failure_skb_discard);	868	t4_set_arp_err_handler(skb, csk, arp_failure_skb_discard);
788		869
789	log_debug(1 << CXGBI_DBG_TOE \| 1 << CXGBI_DBG_PDU_TX,	870	log_debug(1 << CXGBI_DBG_TOE \| 1 << CXGBI_DBG_PDU_TX,
790	"csk 0x%p,%u,0x%lx,%u, skb 0x%p, %u.\n",	871	"csk 0x%p,%u,0x%lx,%u, skb 0x%p, %u.\n",
791	csk, csk->state, csk->flags, csk->tid, skb, len);	872	csk, csk->state, csk->flags, csk->tid, skb, len);
792
793	cxgb4_l2t_send(csk->cdev->ports[csk->port_id], skb, csk->l2t);	873	cxgb4_l2t_send(csk->cdev->ports[csk->port_id], skb, csk->l2t);
794	}	874	}
795	return total_size;	875	return total_size;
@@ -2111,10 +2191,30 @@ static int cxgb4i_ddp_init(struct cxgbi_device *cdev) · 1315 unmodified lines
2111	return 0;	2191	return 0;
2112	}	2192	}
2113		2193
		2194	static bool is_memfree(struct adapter *adap)
		2195	{
		2196	u32 io;
		2197
		2198	io = t4_read_reg(adap, MA_TARGET_MEM_ENABLE_A);
		2199	if (is_t5(adap->params.chip)) {
		2200	if ((io & EXT_MEM0_ENABLE_F) \|\| (io & EXT_MEM1_ENABLE_F))
		2201	return false;
		2202	} else if (io & EXT_MEM_ENABLE_F) {
		2203	return false;
		2204	}
		2205
		2206	return true;
		2207	}
		2208
2114	static void t4_uld_add(const struct cxgb4_lld_info lldi)	2209	static void t4_uld_add(const struct cxgb4_lld_info lldi)
2115	{	2210	{
2116	struct cxgbi_device *cdev;	2211	struct cxgbi_device *cdev;
2117	struct port_info *pi;	2212	struct port_info *pi;
		2213	struct net_device *ndev;
		2214	struct adapter *adap;
		2215	struct tid_info *t;
		2216	u32 max_cmds = CXGB4I_SCSI_HOST_QDEPTH;
		2217	u32 max_conn = CXGBI_MAX_CONN;
2118	int i, rc;	2218	int i, rc;
2119		2219
2120	cdev = cxgbi_device_register(sizeof(*lldi), lldi->nports);	2220	cdev = cxgbi_device_register(sizeof(*lldi), lldi->nports);
@@ -2154,14 +2254,40 @@ static void t4_uld_add(const struct cxgb4_lld_info lldi) · 33 unmodified lines
2154	pr_info("t4 0x%p ddp init failed %d.\n", cdev, rc);	2254	pr_info("t4 0x%p ddp init failed %d.\n", cdev, rc);
2155	goto err_out;	2255	goto err_out;
2156	}	2256	}
		2257
		2258	ndev = cdev->ports[0];
		2259	adap = netdev2adap(ndev);
		2260	if (adap) {
		2261	t = &adap->tids;
		2262	if (t->ntids <= CXGBI_MAX_CONN)
		2263	max_conn = t->ntids;
		2264
		2265	if (is_memfree(adap)) {
		2266	cdev->flags \|= CXGBI_FLAG_DEV_ISO_OFF;
		2267	max_cmds = CXGB4I_SCSI_HOST_QDEPTH >> 2;
		2268
		2269	pr_info("%s: 0x%p, tid %u, SO adapter.\n",
		2270	ndev->name, cdev, t->ntids);
		2271	}
		2272	} else {
		2273	pr_info("%s, 0x%p, NO adapter struct.\n", ndev->name, cdev);
		2274	}
		2275
		2276	/* ISO is enabled in T5/T6 firmware version >= 1.13.43.0 */
		2277	if (!is_t4(lldi->adapter_type) &&
		2278	(lldi->fw_vers >= 0x10d2b00) &&
		2279	!(cdev->flags & CXGBI_FLAG_DEV_ISO_OFF))
		2280	cdev->skb_iso_txhdr = sizeof(struct cpl_tx_data_iso);
		2281
2157	rc = cxgb4i_ofld_init(cdev);	2282	rc = cxgb4i_ofld_init(cdev);
2158	if (rc) {	2283	if (rc) {
2159	pr_info("t4 0x%p ofld init failed.\n", cdev);	2284	pr_info("t4 0x%p ofld init failed.\n", cdev);
2160	goto err_out;	2285	goto err_out;
2161	}	2286	}
2162		2287
2163	rc = cxgbi_hbas_add(cdev, CXGB4I_MAX_LUN, CXGBI_MAX_CONN,	2288	cxgb4i_host_template.can_queue = max_cmds;
2164	&cxgb4i_host_template, cxgb4i_stt);	2289	rc = cxgbi_hbas_add(cdev, CXGB4I_MAX_LUN, max_conn,
		2290	&cxgb4i_host_template, cxgb4i_stt);
2165	if (rc)	2291	if (rc)
2166	goto err_out;	2292	goto err_out;
2167		2293

drivers/scsi/cxgbi/libcxgbi.c+502−170

@@ -359,13 +359,15 @@ int cxgbi_hbas_add(struct cxgbi_device *cdev, u64 max_lun, · 358 unmodified lines
359	shost->max_lun = max_lun;	359	shost->max_lun = max_lun;
360	shost->max_id = max_id;	360	shost->max_id = max_id;
361	shost->max_channel = 0;	361	shost->max_channel = 0;
362	shost->max_cmd_len = 16;	362	shost->max_cmd_len = SCSI_MAX_VARLEN_CDB_SIZE;
363		363
364	chba = iscsi_host_priv(shost);	364	chba = iscsi_host_priv(shost);
365	chba->cdev = cdev;	365	chba->cdev = cdev;
366	chba->ndev = cdev->ports[i];	366	chba->ndev = cdev->ports[i];
367	chba->shost = shost;	367	chba->shost = shost;
368		368
		369	shost->can_queue = sht->can_queue - ISCSI_MGMT_CMDS_MAX;
		370
369	log_debug(1 << CXGBI_DBG_DEV,	371	log_debug(1 << CXGBI_DBG_DEV,
370	"cdev 0x%p, p#%d %s: chba 0x%p.\n",	372	"cdev 0x%p, p#%d %s: chba 0x%p.\n",
371	cdev, i, cdev->ports[i]->name, chba);	373	cdev, i, cdev->ports[i]->name, chba);
@@ -1136,82 +1138,6 @@ void cxgbi_sock_check_wr_invariants(const struct cxgbi_sock *csk) · 764 unmodified lines
1136	}	1138	}
1137	EXPORT_SYMBOL_GPL(cxgbi_sock_check_wr_invariants);	1139	EXPORT_SYMBOL_GPL(cxgbi_sock_check_wr_invariants);
1138		1140
1139	static int cxgbi_sock_send_pdus(struct cxgbi_sock csk, struct sk_buff skb)
1140	{
1141	struct cxgbi_device *cdev = csk->cdev;
1142	struct sk_buff *next;
1143	int err, copied = 0;
1144
1145	spin_lock_bh(&csk->lock);
1146
1147	if (csk->state != CTP_ESTABLISHED) {
1148	log_debug(1 << CXGBI_DBG_PDU_TX,
1149	"csk 0x%p,%u,0x%lx,%u, EAGAIN.\n",
1150	csk, csk->state, csk->flags, csk->tid);
1151	err = -EAGAIN;
1152	goto out_err;
1153	}
1154
1155	if (csk->err) {
1156	log_debug(1 << CXGBI_DBG_PDU_TX,
1157	"csk 0x%p,%u,0x%lx,%u, EPIPE %d.\n",
1158	csk, csk->state, csk->flags, csk->tid, csk->err);
1159	err = -EPIPE;
1160	goto out_err;
1161	}
1162
1163	if (csk->write_seq - csk->snd_una >= csk->snd_win) {
1164	log_debug(1 << CXGBI_DBG_PDU_TX,
1165	"csk 0x%p,%u,0x%lx,%u, FULL %u-%u >= %u.\n",
1166	csk, csk->state, csk->flags, csk->tid, csk->write_seq,
1167	csk->snd_una, csk->snd_win);
1168	err = -ENOBUFS;
1169	goto out_err;
1170	}
1171
1172	while (skb) {
1173	int frags = skb_shinfo(skb)->nr_frags +
1174	(skb->len != skb->data_len);
1175
1176	if (unlikely(skb_headroom(skb) < cdev->skb_tx_rsvd)) {
1177	pr_err("csk 0x%p, skb head %u < %u.\n",
1178	csk, skb_headroom(skb), cdev->skb_tx_rsvd);
1179	err = -EINVAL;
1180	goto out_err;
1181	}
1182
1183	if (frags >= SKB_WR_LIST_SIZE) {
1184	pr_err("csk 0x%p, frags %d, %u,%u >%u.\n",
1185	csk, skb_shinfo(skb)->nr_frags, skb->len,
1186	skb->data_len, (uint)(SKB_WR_LIST_SIZE));
1187	err = -EINVAL;
1188	goto out_err;
1189	}
1190
1191	next = skb->next;
1192	skb->next = NULL;
1193	cxgbi_skcb_set_flag(skb, SKCBF_TX_NEED_HDR);
1194	cxgbi_sock_skb_entail(csk, skb);
1195	copied += skb->len;
1196	csk->write_seq += skb->len +
1197	cxgbi_ulp_extra_len(cxgbi_skcb_ulp_mode(skb));
1198	skb = next;
1199	}
1200
1201	if (likely(skb_queue_len(&csk->write_queue)))
1202	cdev->csk_push_tx_frames(csk, 1);
1203	done:
1204	spin_unlock_bh(&csk->lock);
1205	return copied;
1206
1207	out_err:
1208	if (copied == 0 && err == -EPIPE)
1209	copied = csk->err ? csk->err : -EPIPE;
1210	else
1211	copied = err;
1212	goto done;
1213	}
1214
1215	static inline void	1141	static inline void
1216	scmd_get_params(struct scsi_cmnd sc, struct scatterlist *sgl,	1142	scmd_get_params(struct scsi_cmnd sc, struct scatterlist *sgl,
1217	unsigned int sgcnt, unsigned int dlen,	1143	unsigned int sgcnt, unsigned int dlen,
@@ -1284,8 +1210,6 @@ EXPORT_SYMBOL_GPL(cxgbi_ddp_set_one_ppod); · 66 unmodified lines
1284	* APIs interacting with open-iscsi libraries	1210	* APIs interacting with open-iscsi libraries
1285	*/	1211	*/
1286		1212
1287	static unsigned char padding[4];
1288
1289	int cxgbi_ddp_ppm_setup(void *ppm_pp, struct cxgbi_device cdev,	1213	int cxgbi_ddp_ppm_setup(void *ppm_pp, struct cxgbi_device cdev,
1290	struct cxgbi_tag_format *tformat,	1214	struct cxgbi_tag_format *tformat,
1291	unsigned int iscsi_size, unsigned int llimit,	1215	unsigned int iscsi_size, unsigned int llimit,
@@ -1833,9 +1757,10 @@ static int sgl_seek_offset(struct scatterlist *sgl, unsigned int sgcnt, · 541 unmodified lines
1833	return -EFAULT;	1757	return -EFAULT;
1834	}	1758	}
1835		1759
1836	static int sgl_read_to_frags(struct scatterlist *sg, unsigned int sgoffset,	1760	static int
1837	unsigned int dlen, struct page_frag *frags,	1761	sgl_read_to_frags(struct scatterlist *sg, unsigned int sgoffset,
1838	int frag_max)	1762	unsigned int dlen, struct page_frag *frags,
		1763	int frag_max, u32 *dlimit)
1839	{	1764	{
1840	unsigned int datalen = dlen;	1765	unsigned int datalen = dlen;
1841	unsigned int sglen = sg->length - sgoffset;	1766	unsigned int sglen = sg->length - sgoffset;
@@ -1867,6 +1792,7 @@ static int sgl_read_to_frags(struct scatterlist *sg, unsigned int sgoffset, · 25 unmodified lines
1867	if (i >= frag_max) {	1792	if (i >= frag_max) {
1868	pr_warn("too many pages %u, dlen %u.\n",	1793	pr_warn("too many pages %u, dlen %u.\n",
1869	frag_max, dlen);	1794	frag_max, dlen);
		1795	*dlimit = dlen - datalen;
1870	return -EINVAL;	1796	return -EINVAL;
1871	}	1797	}
1872		1798
@@ -1883,38 +1809,220 @@ static int sgl_read_to_frags(struct scatterlist *sg, unsigned int sgoffset, · 10 unmodified lines
1883	return i;	1809	return i;
1884	}	1810	}
1885		1811
1886	int cxgbi_conn_alloc_pdu(struct iscsi_task *task, u8 opcode)	1812	static void cxgbi_task_data_sgl_check(struct iscsi_task *task)
1887	{	1813	{
1888	struct iscsi_tcp_conn *tcp_conn = task->conn->dd_data;	1814	struct scsi_cmnd *sc = task->sc;
		1815	struct cxgbi_task_data *tdata = iscsi_task_cxgbi_data(task);
		1816	struct scatterlist sg, sgl = NULL;
		1817	u32 sgcnt = 0;
		1818	int i;
		1819
		1820	tdata->flags = CXGBI_TASK_SGL_CHECKED;
		1821	if (!sc)
		1822	return;
		1823
		1824	scmd_get_params(sc, &sgl, &sgcnt, &tdata->dlen, 0);
		1825	if (!sgl \|\| !sgcnt) {
		1826	tdata->flags \|= CXGBI_TASK_SGL_COPY;
		1827	return;
		1828	}
		1829
		1830	for_each_sg(sgl, sg, sgcnt, i) {
		1831	if (page_count(sg_page(sg)) < 1) {
		1832	tdata->flags \|= CXGBI_TASK_SGL_COPY;
		1833	return;
		1834	}
		1835	}
		1836	}
		1837
		1838	static int
		1839	cxgbi_task_data_sgl_read(struct iscsi_task *task, u32 offset, u32 count,
		1840	u32 *dlimit)
		1841	{
		1842	struct scsi_cmnd *sc = task->sc;
		1843	struct cxgbi_task_data *tdata = iscsi_task_cxgbi_data(task);
		1844	struct scatterlist *sgl = NULL;
		1845	struct scatterlist *sg;
		1846	u32 dlen = 0;
		1847	u32 sgcnt;
		1848	int err;
		1849
		1850	if (!sc)
		1851	return 0;
		1852
		1853	scmd_get_params(sc, &sgl, &sgcnt, &dlen, 0);
		1854	if (!sgl \|\| !sgcnt)
		1855	return 0;
		1856
		1857	err = sgl_seek_offset(sgl, sgcnt, offset, &tdata->sgoffset, &sg);
		1858	if (err < 0) {
		1859	pr_warn("tpdu max, sgl %u, bad offset %u/%u.\n",
		1860	sgcnt, offset, tdata->dlen);
		1861	return err;
		1862	}
		1863	err = sgl_read_to_frags(sg, tdata->sgoffset, count,
		1864	tdata->frags, MAX_SKB_FRAGS, dlimit);
		1865	if (err < 0) {
		1866	log_debug(1 << CXGBI_DBG_ISCSI,
		1867	"sgl max limit, sgl %u, offset %u, %u/%u, dlimit %u.\n",
		1868	sgcnt, offset, count, tdata->dlen, *dlimit);
		1869	return err;
		1870	}
		1871	tdata->offset = offset;
		1872	tdata->count = count;
		1873	tdata->nr_frags = err;
		1874	tdata->total_count = count;
		1875	tdata->total_offset = offset;
		1876
		1877	log_debug(1 << CXGBI_DBG_ISCSI \| 1 << CXGBI_DBG_PDU_TX,
		1878	"%s: offset %u, count %u,\n"
		1879	"err %u, total_count %u, total_offset %u\n",
		1880	__func__, offset, count, err, tdata->total_count, tdata->total_offset);
		1881
		1882	return 0;
		1883	}
		1884
		1885	int cxgbi_conn_alloc_pdu(struct iscsi_task *task, u8 op)
		1886	{
		1887	struct iscsi_conn *conn = task->conn;
		1888	struct iscsi_session *session = task->conn->session;
		1889	struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
1889	struct cxgbi_conn *cconn = tcp_conn->dd_data;	1890	struct cxgbi_conn *cconn = tcp_conn->dd_data;
1890	struct cxgbi_device *cdev = cconn->chba->cdev;	1891	struct cxgbi_device *cdev = cconn->chba->cdev;
1891	struct iscsi_conn *conn = task->conn;	1892	struct cxgbi_sock *csk = cconn->cep ? cconn->cep->csk : NULL;
1892	struct iscsi_tcp_task *tcp_task = task->dd_data;	1893	struct iscsi_tcp_task *tcp_task = task->dd_data;
1893	struct cxgbi_task_data *tdata = iscsi_task_cxgbi_data(task);	1894	struct cxgbi_task_data *tdata = iscsi_task_cxgbi_data(task);
1894	struct scsi_cmnd *sc = task->sc;	1895	struct scsi_cmnd *sc = task->sc;
1895	struct cxgbi_sock *csk = cconn->cep->csk;	1896	u32 headroom = SKB_TX_ISCSI_PDU_HEADER_MAX;
1896	struct net_device *ndev = cdev->ports[csk->port_id];	1897	u32 max_txdata_len = conn->max_xmit_dlength;
1897	int headroom = SKB_TX_ISCSI_PDU_HEADER_MAX;	1898	u32 iso_tx_rsvd = 0, local_iso_info = 0;
		1899	u32 last_tdata_offset, last_tdata_count;
		1900	int err = 0;
		1901
		1902	if (!tcp_task) {
		1903	pr_err("task 0x%p, tcp_task 0x%p, tdata 0x%p.\n",
		1904	task, tcp_task, tdata);
		1905	return -ENOMEM;
		1906	}
		1907	if (!csk) {
		1908	pr_err("task 0x%p, csk gone.\n", task);
		1909	return -EPIPE;
		1910	}
		1911
		1912	op &= ISCSI_OPCODE_MASK;
1898		1913
1899	tcp_task->dd_data = tdata;	1914	tcp_task->dd_data = tdata;
1900	task->hdr = NULL;	1915	task->hdr = NULL;
1901		1916
1902	if (SKB_MAX_HEAD(cdev->skb_tx_rsvd) > (512 * MAX_SKB_FRAGS) &&	1917	last_tdata_count = tdata->count;
1903	(opcode == ISCSI_OP_SCSI_DATA_OUT \|\|	1918	last_tdata_offset = tdata->offset;
1904	(opcode == ISCSI_OP_SCSI_CMD &&	1919
1905	sc->sc_data_direction == DMA_TO_DEVICE)))	1920	if ((op == ISCSI_OP_SCSI_DATA_OUT) \|\|
1906	/* data could goes into skb head */	1921	((op == ISCSI_OP_SCSI_CMD) &&
1907	headroom += min_t(unsigned int,	1922	(sc->sc_data_direction == DMA_TO_DEVICE))) {
1908	SKB_MAX_HEAD(cdev->skb_tx_rsvd),	1923	u32 remaining_data_tosend, dlimit = 0;
1909	conn->max_xmit_dlength);	1924	u32 max_pdu_size, max_num_pdu, num_pdu;
		1925	u32 count;
1910		1926
1911	tdata->skb = alloc_skb(cdev->skb_tx_rsvd + headroom, GFP_ATOMIC);	1927	/* Preserve conn->max_xmit_dlength because it can get updated to
		1928	* ISO data size.
		1929	*/
		1930	if (task->state == ISCSI_TASK_PENDING)
		1931	tdata->max_xmit_dlength = conn->max_xmit_dlength;
		1932
		1933	if (!tdata->offset)
		1934	cxgbi_task_data_sgl_check(task);
		1935
		1936	remaining_data_tosend =
		1937	tdata->dlen - tdata->offset - tdata->count;
		1938
		1939	recalculate_sgl:
		1940	max_txdata_len = tdata->max_xmit_dlength;
		1941	log_debug(1 << CXGBI_DBG_ISCSI \| 1 << CXGBI_DBG_PDU_TX,
		1942	"tdata->dlen %u, remaining to send %u "
		1943	"conn->max_xmit_dlength %u, "
		1944	"tdata->max_xmit_dlength %u\n",
		1945	tdata->dlen, remaining_data_tosend,
		1946	conn->max_xmit_dlength, tdata->max_xmit_dlength);
		1947
		1948	if (cdev->skb_iso_txhdr && !csk->disable_iso &&
		1949	(remaining_data_tosend > tdata->max_xmit_dlength) &&
		1950	!(remaining_data_tosend % 4)) {
		1951	u32 max_iso_data;
		1952
		1953	if ((op == ISCSI_OP_SCSI_CMD) &&
		1954	session->initial_r2t_en)
		1955	goto no_iso;
		1956
		1957	max_pdu_size = tdata->max_xmit_dlength +
		1958	ISCSI_PDU_NONPAYLOAD_LEN;
		1959	max_iso_data = rounddown(CXGBI_MAX_ISO_DATA_IN_SKB,
		1960	csk->advmss);
		1961	max_num_pdu = max_iso_data / max_pdu_size;
		1962
		1963	num_pdu = (remaining_data_tosend +
		1964	tdata->max_xmit_dlength - 1) /
		1965	tdata->max_xmit_dlength;
		1966
		1967	if (num_pdu > max_num_pdu)
		1968	num_pdu = max_num_pdu;
		1969
		1970	conn->max_xmit_dlength = tdata->max_xmit_dlength * num_pdu;
		1971	max_txdata_len = conn->max_xmit_dlength;
		1972	iso_tx_rsvd = cdev->skb_iso_txhdr;
		1973	local_iso_info = sizeof(struct cxgbi_iso_info);
		1974
		1975	log_debug(1 << CXGBI_DBG_ISCSI \| 1 << CXGBI_DBG_PDU_TX,
		1976	"max_pdu_size %u, max_num_pdu %u, "
		1977	"max_txdata %u, num_pdu %u\n",
		1978	max_pdu_size, max_num_pdu,
		1979	max_txdata_len, num_pdu);
		1980	}
		1981	no_iso:
		1982	count = min_t(u32, max_txdata_len, remaining_data_tosend);
		1983	err = cxgbi_task_data_sgl_read(task,
		1984	tdata->offset + tdata->count,
		1985	count, &dlimit);
		1986	if (unlikely(err < 0)) {
		1987	log_debug(1 << CXGBI_DBG_ISCSI,
		1988	"task 0x%p, tcp_task 0x%p, tdata 0x%p, "
		1989	"sgl err %d, count %u, dlimit %u\n",
		1990	task, tcp_task, tdata, err, count, dlimit);
		1991	if (dlimit) {
		1992	remaining_data_tosend =
		1993	rounddown(dlimit,
		1994	tdata->max_xmit_dlength);
		1995	if (!remaining_data_tosend)
		1996	remaining_data_tosend = dlimit;
		1997
		1998	dlimit = 0;
		1999
		2000	conn->max_xmit_dlength = remaining_data_tosend;
		2001	goto recalculate_sgl;
		2002	}
		2003
		2004	pr_err("task 0x%p, tcp_task 0x%p, tdata 0x%p, "
		2005	"sgl err %d\n",
		2006	task, tcp_task, tdata, err);
		2007	goto ret_err;
		2008	}
		2009
		2010	if ((tdata->flags & CXGBI_TASK_SGL_COPY) \|\|
		2011	(tdata->nr_frags > MAX_SKB_FRAGS))
		2012	headroom += conn->max_xmit_dlength;
		2013	}
		2014
		2015	tdata->skb = alloc_skb(local_iso_info + cdev->skb_tx_rsvd +
		2016	iso_tx_rsvd + headroom, GFP_ATOMIC);
1912	if (!tdata->skb) {	2017	if (!tdata->skb) {
1913	ndev->stats.tx_dropped++;	2018	tdata->count = last_tdata_count;
1914	return -ENOMEM;	2019	tdata->offset = last_tdata_offset;
		2020	err = -ENOMEM;
		2021	goto ret_err;
1915	}	2022	}
1916		2023
1917	skb_reserve(tdata->skb, cdev->skb_tx_rsvd);	2024	skb_reserve(tdata->skb, local_iso_info + cdev->skb_tx_rsvd +
		2025	iso_tx_rsvd);
1918		2026
1919	if (task->sc) {	2027	if (task->sc) {
1920	task->hdr = (struct iscsi_hdr *)tdata->skb->data;	2028	task->hdr = (struct iscsi_hdr *)tdata->skb->data;
@@ -1923,25 +2031,100 @@ int cxgbi_conn_alloc_pdu(struct iscsi_task *task, u8 opcode) · 2 unmodified lines
1923	if (!task->hdr) {	2031	if (!task->hdr) {
1924	__kfree_skb(tdata->skb);	2032	__kfree_skb(tdata->skb);
1925	tdata->skb = NULL;	2033	tdata->skb = NULL;
1926	ndev->stats.tx_dropped++;
1927	return -ENOMEM;	2034	return -ENOMEM;
1928	}	2035	}
1929	}	2036	}
1930	task->hdr_max = SKB_TX_ISCSI_PDU_HEADER_MAX; /* BHS + AHS */	2037
		2038	task->hdr_max = SKB_TX_ISCSI_PDU_HEADER_MAX;
		2039
		2040	if (iso_tx_rsvd)
		2041	cxgbi_skcb_set_flag(tdata->skb, SKCBF_TX_ISO);
1931		2042
1932	/* data_out uses scsi_cmd's itt */	2043	/* data_out uses scsi_cmd's itt */
1933	if (opcode != ISCSI_OP_SCSI_DATA_OUT)	2044	if (op != ISCSI_OP_SCSI_DATA_OUT)
1934	task_reserve_itt(task, &task->hdr->itt);	2045	task_reserve_itt(task, &task->hdr->itt);
1935		2046
1936	log_debug(1 << CXGBI_DBG_ISCSI \| 1 << CXGBI_DBG_PDU_TX,	2047	log_debug(1 << CXGBI_DBG_ISCSI \| 1 << CXGBI_DBG_PDU_TX,
1937	"task 0x%p, op 0x%x, skb 0x%p,%u+%u/%u, itt 0x%x.\n",	2048	"task 0x%p, op 0x%x, skb 0x%p,%u+%u/%u, itt 0x%x.\n",
1938	task, opcode, tdata->skb, cdev->skb_tx_rsvd, headroom,	2049	task, op, tdata->skb, cdev->skb_tx_rsvd, headroom,
1939	conn->max_xmit_dlength, ntohl(task->hdr->itt));	2050	conn->max_xmit_dlength, be32_to_cpu(task->hdr->itt));
1940		2051
1941	return 0;	2052	return 0;
		2053
		2054	ret_err:
		2055	conn->max_xmit_dlength = tdata->max_xmit_dlength;
		2056	return err;
1942	}	2057	}
1943	EXPORT_SYMBOL_GPL(cxgbi_conn_alloc_pdu);	2058	EXPORT_SYMBOL_GPL(cxgbi_conn_alloc_pdu);
1944		2059
		2060	static int
		2061	cxgbi_prep_iso_info(struct iscsi_task task, struct sk_buff skb,
		2062	u32 count)
		2063	{
		2064	struct cxgbi_iso_info iso_info = (struct cxgbi_iso_info )skb->head;
		2065	struct iscsi_r2t_info *r2t;
		2066	struct cxgbi_task_data *tdata = iscsi_task_cxgbi_data(task);
		2067	struct iscsi_conn *conn = task->conn;
		2068	struct iscsi_session *session = conn->session;
		2069	struct iscsi_tcp_task *tcp_task = task->dd_data;
		2070	u32 burst_size = 0, r2t_dlength = 0, dlength;
		2071	u32 max_pdu_len = tdata->max_xmit_dlength;
		2072	u32 segment_offset = 0;
		2073	u32 num_pdu;
		2074
		2075	if (unlikely(!cxgbi_skcb_test_flag(skb, SKCBF_TX_ISO)))
		2076	return 0;
		2077
		2078	memset(iso_info, 0, sizeof(struct cxgbi_iso_info));
		2079
		2080	if (task->hdr->opcode == ISCSI_OP_SCSI_CMD && session->imm_data_en) {
		2081	iso_info->flags \|= CXGBI_ISO_INFO_IMM_ENABLE;
		2082	burst_size = count;
		2083	}
		2084
		2085	dlength = ntoh24(task->hdr->dlength);
		2086	dlength = min(dlength, max_pdu_len);
		2087	hton24(task->hdr->dlength, dlength);
		2088
		2089	num_pdu = (count + max_pdu_len - 1) / max_pdu_len;
		2090
		2091	if (iscsi_task_has_unsol_data(task))
		2092	r2t = &task->unsol_r2t;
		2093	else
		2094	r2t = tcp_task->r2t;
		2095
		2096	if (r2t) {
		2097	log_debug(1 << CXGBI_DBG_ISCSI \| 1 << CXGBI_DBG_PDU_TX,
		2098	"count %u, tdata->count %u, num_pdu %u,"
		2099	"task->hdr_len %u, r2t->data_length %u, r2t->sent %u\n",
		2100	count, tdata->count, num_pdu, task->hdr_len,
		2101	r2t->data_length, r2t->sent);
		2102
		2103	r2t_dlength = r2t->data_length - r2t->sent;
		2104	segment_offset = r2t->sent;
		2105	r2t->datasn += num_pdu - 1;
		2106	}
		2107
		2108	if (!r2t \|\| !r2t->sent)
		2109	iso_info->flags \|= CXGBI_ISO_INFO_FSLICE;
		2110
		2111	if (task->hdr->flags & ISCSI_FLAG_CMD_FINAL)
		2112	iso_info->flags \|= CXGBI_ISO_INFO_LSLICE;
		2113
		2114	task->hdr->flags &= ~ISCSI_FLAG_CMD_FINAL;
		2115
		2116	iso_info->op = task->hdr->opcode;
		2117	iso_info->ahs = task->hdr->hlength;
		2118	iso_info->num_pdu = num_pdu;
		2119	iso_info->mpdu = max_pdu_len;
		2120	iso_info->burst_size = (burst_size + r2t_dlength) >> 2;
		2121	iso_info->len = count + task->hdr_len;
		2122	iso_info->segment_offset = segment_offset;
		2123
		2124	cxgbi_skcb_tx_iscsi_hdrlen(skb) = task->hdr_len;
		2125	return 0;
		2126	}
		2127
1945	static inline void tx_skb_setmode(struct sk_buff *skb, int hcrc, int dcrc)	2128	static inline void tx_skb_setmode(struct sk_buff *skb, int hcrc, int dcrc)
1946	{	2129	{
1947	if (hcrc \|\| dcrc) {	2130	if (hcrc \|\| dcrc) {
@@ -1951,133 +2134,260 @@ static inline void tx_skb_setmode(struct sk_buff *skb, int hcrc, int dcrc) · 3 unmodified lines
1951	submode \|= 1;	2134	submode \|= 1;
1952	if (dcrc)	2135	if (dcrc)
1953	submode \|= 2;	2136	submode \|= 2;
1954	cxgbi_skcb_ulp_mode(skb) = (ULP2_MODE_ISCSI << 4) \| submode;	2137	cxgbi_skcb_tx_ulp_mode(skb) = (ULP2_MODE_ISCSI << 4) \| submode;
1955	} else	2138	} else
1956	cxgbi_skcb_ulp_mode(skb) = 0;	2139	cxgbi_skcb_tx_ulp_mode(skb) = 0;
1957	}	2140	}
1958		2141
		2142	static struct page *rsvd_page;
		2143
1959	int cxgbi_conn_init_pdu(struct iscsi_task *task, unsigned int offset,	2144	int cxgbi_conn_init_pdu(struct iscsi_task *task, unsigned int offset,
1960	unsigned int count)	2145	unsigned int count)
1961	{	2146	{
1962	struct iscsi_conn *conn = task->conn;	2147	struct iscsi_conn *conn = task->conn;
		2148	struct iscsi_tcp_task *tcp_task = task->dd_data;
1963	struct cxgbi_task_data *tdata = iscsi_task_cxgbi_data(task);	2149	struct cxgbi_task_data *tdata = iscsi_task_cxgbi_data(task);
1964	struct sk_buff *skb = tdata->skb;	2150	struct sk_buff *skb;
1965	unsigned int datalen = count;	2151	struct scsi_cmnd *sc = task->sc;
1966	int i, padlen = iscsi_padding(count);	2152	u32 expected_count, expected_offset;
		2153	u32 datalen = count, dlimit = 0;
		2154	u32 i, padlen = iscsi_padding(count);
1967	struct page *pg;	2155	struct page *pg;
		2156	int err;
		2157
		2158	if (!tcp_task \|\| (tcp_task->dd_data != tdata)) {
		2159	pr_err("task 0x%p,0x%p, tcp_task 0x%p, tdata 0x%p/0x%p.\n",
		2160	task, task->sc, tcp_task,
		2161	tcp_task ? tcp_task->dd_data : NULL, tdata);
		2162	return -EINVAL;
		2163	}
		2164	skb = tdata->skb;
1968		2165
1969	log_debug(1 << CXGBI_DBG_ISCSI \| 1 << CXGBI_DBG_PDU_TX,	2166	log_debug(1 << CXGBI_DBG_ISCSI \| 1 << CXGBI_DBG_PDU_TX,
1970	"task 0x%p,0x%p, skb 0x%p, 0x%x,0x%x,0x%x, %u+%u.\n",	2167	"task 0x%p,0x%p, skb 0x%p, 0x%x,0x%x,0x%x, %u+%u.\n",
1971	task, task->sc, skb, (*skb->data) & ISCSI_OPCODE_MASK,	2168	task, task->sc, skb, (*skb->data) & ISCSI_OPCODE_MASK,
1972	ntohl(task->cmdsn), ntohl(task->hdr->itt), offset, count);	2169	be32_to_cpu(task->cmdsn), be32_to_cpu(task->hdr->itt), offset, count);
1973		2170
1974	skb_put(skb, task->hdr_len);	2171	skb_put(skb, task->hdr_len);
1975	tx_skb_setmode(skb, conn->hdrdgst_en, datalen ? conn->datadgst_en : 0);	2172	tx_skb_setmode(skb, conn->hdrdgst_en, datalen ? conn->datadgst_en : 0);
1976	if (!count)	2173	if (!count) {
		2174	tdata->count = count;
		2175	tdata->offset = offset;
		2176	tdata->nr_frags = 0;
		2177	tdata->total_offset = 0;
		2178	tdata->total_count = 0;
		2179	if (tdata->max_xmit_dlength)
		2180	conn->max_xmit_dlength = tdata->max_xmit_dlength;
		2181	cxgbi_skcb_clear_flag(skb, SKCBF_TX_ISO);
1977	return 0;	2182	return 0;
		2183	}
1978		2184
1979	if (task->sc) {	2185	log_debug(1 << CXGBI_DBG_ISCSI \| 1 << CXGBI_DBG_PDU_TX,
1980	struct scsi_data_buffer *sdb = &task->sc->sdb;	2186	"data->total_count %u, tdata->total_offset %u\n",
1981	struct scatterlist *sg = NULL;	2187	tdata->total_count, tdata->total_offset);
1982	int err;
1983		2188
1984	tdata->offset = offset;	2189	expected_count = tdata->total_count;
1985	tdata->count = count;	2190	expected_offset = tdata->total_offset;
1986	err = sgl_seek_offset(	2191
1987	sdb->table.sgl, sdb->table.nents,	2192	if ((count != expected_count) \|\|
1988	tdata->offset, &tdata->sgoffset, &sg);	2193	(offset != expected_offset)) {
1989	if (err < 0) {	2194	err = cxgbi_task_data_sgl_read(task, offset, count, &dlimit);
1990	pr_warn("tpdu, sgl %u, bad offset %u/%u.\n",
1991	sdb->table.nents, tdata->offset, sdb->length);
1992	return err;
1993	}
1994	err = sgl_read_to_frags(sg, tdata->sgoffset, tdata->count,
1995	tdata->frags, MAX_PDU_FRAGS);
1996	if (err < 0) {	2195	if (err < 0) {
1997	pr_warn("tpdu, sgl %u, bad offset %u + %u.\n",	2196	pr_err("task 0x%p,0x%p, tcp_task 0x%p, tdata 0x%p/0x%p "
1998	sdb->table.nents, tdata->offset, tdata->count);	2197	"dlimit %u, sgl err %d.\n", task, task->sc,
		2198	tcp_task, tcp_task ? tcp_task->dd_data : NULL,
		2199	tdata, dlimit, err);
1999	return err;	2200	return err;
2000	}	2201	}
2001	tdata->nr_frags = err;	2202	}
		2203
		2204	/* Restore original value of conn->max_xmit_dlength because
		2205	* it can get updated to ISO data size.
		2206	*/
		2207	conn->max_xmit_dlength = tdata->max_xmit_dlength;
		2208
		2209	if (sc) {
		2210	struct page_frag *frag = tdata->frags;
2002		2211
2003	if (tdata->nr_frags > MAX_SKB_FRAGS \|\|	2212	if ((tdata->flags & CXGBI_TASK_SGL_COPY) \|\|
2004	(padlen && tdata->nr_frags == MAX_SKB_FRAGS)) {	2213	(tdata->nr_frags > MAX_SKB_FRAGS) \|\|
		2214	(padlen && (tdata->nr_frags ==
		2215	MAX_SKB_FRAGS))) {
2005	char *dst = skb->data + task->hdr_len;	2216	char *dst = skb->data + task->hdr_len;
2006	struct page_frag *frag = tdata->frags;
2007		2217
2008	/* data fits in the skb's headroom */	2218	/* data fits in the skb's headroom */
2009	for (i = 0; i < tdata->nr_frags; i++, frag++) {	2219	for (i = 0; i < tdata->nr_frags; i++, frag++) {
2010	char *src = kmap_atomic(frag->page);	2220	char *src = kmap_atomic(frag->page);
2011		2221
2012	memcpy(dst, src+frag->offset, frag->size);	2222	memcpy(dst, src + frag->offset, frag->size);
2013	dst += frag->size;	2223	dst += frag->size;
2014	kunmap_atomic(src);	2224	kunmap_atomic(src);
2015	}	2225	}
		2226
2016	if (padlen) {	2227	if (padlen) {
2017	memset(dst, 0, padlen);	2228	memset(dst, 0, padlen);
2018	padlen = 0;	2229	padlen = 0;
2019	}	2230	}
2020	skb_put(skb, count + padlen);	2231	skb_put(skb, count + padlen);
2021	} else {	2232	} else {
2022	/* data fit into frag_list */	2233	for (i = 0; i < tdata->nr_frags; i++, frag++) {
2023	for (i = 0; i < tdata->nr_frags; i++) {	2234	get_page(frag->page);
2024	__skb_fill_page_desc(skb, i,	2235	skb_fill_page_desc(skb, i, frag->page,
2025	tdata->frags[i].page,	2236	frag->offset, frag->size);
2026	tdata->frags[i].offset,
2027	tdata->frags[i].size);
2028	skb_frag_ref(skb, i);
2029	}	2237	}
2030	skb_shinfo(skb)->nr_frags = tdata->nr_frags;	2238
2031	skb->len += count;	2239	skb->len += count;
2032	skb->data_len += count;	2240	skb->data_len += count;
2033	skb->truesize += count;	2241	skb->truesize += count;
2034	}	2242	}
2035
2036	} else {	2243	} else {
2037	pg = virt_to_page(task->data);	2244	pg = virt_to_head_page(task->data);
2038
2039	get_page(pg);	2245	get_page(pg);
2040	skb_fill_page_desc(skb, 0, pg, offset_in_page(task->data),	2246	skb_fill_page_desc(skb, 0, pg,
2041	count);	2247	task->data - (char *)page_address(pg),
		2248	count);
2042	skb->len += count;	2249	skb->len += count;
2043	skb->data_len += count;	2250	skb->data_len += count;
2044	skb->truesize += count;	2251	skb->truesize += count;
2045	}	2252	}
2046		2253
2047	if (padlen) {	2254	if (padlen) {
2048	i = skb_shinfo(skb)->nr_frags;	2255	get_page(rsvd_page);
2049	skb_fill_page_desc(skb, skb_shinfo(skb)->nr_frags,	2256	skb_fill_page_desc(skb, skb_shinfo(skb)->nr_frags,
2050	virt_to_page(padding), offset_in_page(padding),	2257	rsvd_page, 0, padlen);
2051	padlen);
2052		2258
2053	skb->data_len += padlen;	2259	skb->data_len += padlen;
2054	skb->truesize += padlen;	2260	skb->truesize += padlen;
2055	skb->len += padlen;	2261	skb->len += padlen;
2056	}	2262	}
2057		2263
		2264	if (likely(count > tdata->max_xmit_dlength))
		2265	cxgbi_prep_iso_info(task, skb, count);
		2266	else
		2267	cxgbi_skcb_clear_flag(skb, SKCBF_TX_ISO);
		2268
2058	return 0;	2269	return 0;
2059	}	2270	}
2060	EXPORT_SYMBOL_GPL(cxgbi_conn_init_pdu);	2271	EXPORT_SYMBOL_GPL(cxgbi_conn_init_pdu);
2061		2272
		2273	static int cxgbi_sock_tx_queue_up(struct cxgbi_sock csk, struct sk_buff skb)
		2274	{
		2275	struct cxgbi_device *cdev = csk->cdev;
		2276	struct cxgbi_iso_info *iso_cpl;
		2277	u32 frags = skb_shinfo(skb)->nr_frags;
		2278	u32 extra_len, num_pdu, hdr_len;
		2279	u32 iso_tx_rsvd = 0;
		2280
		2281	if (csk->state != CTP_ESTABLISHED) {
		2282	log_debug(1 << CXGBI_DBG_PDU_TX,
		2283	"csk 0x%p,%u,0x%lx,%u, EAGAIN.\n",
		2284	csk, csk->state, csk->flags, csk->tid);
		2285	return -EPIPE;
		2286	}
		2287
		2288	if (csk->err) {
		2289	log_debug(1 << CXGBI_DBG_PDU_TX,
		2290	"csk 0x%p,%u,0x%lx,%u, EPIPE %d.\n",
		2291	csk, csk->state, csk->flags, csk->tid, csk->err);
		2292	return -EPIPE;
		2293	}
		2294
		2295	if ((cdev->flags & CXGBI_FLAG_DEV_T3) &&
		2296	before((csk->snd_win + csk->snd_una), csk->write_seq)) {
		2297	log_debug(1 << CXGBI_DBG_PDU_TX,
		2298	"csk 0x%p,%u,0x%lx,%u, FULL %u-%u >= %u.\n",
		2299	csk, csk->state, csk->flags, csk->tid, csk->write_seq,
		2300	csk->snd_una, csk->snd_win);
		2301	return -ENOBUFS;
		2302	}
		2303
		2304	if (cxgbi_skcb_test_flag(skb, SKCBF_TX_ISO))
		2305	iso_tx_rsvd = cdev->skb_iso_txhdr;
		2306
		2307	if (unlikely(skb_headroom(skb) < (cdev->skb_tx_rsvd + iso_tx_rsvd))) {
		2308	pr_err("csk 0x%p, skb head %u < %u.\n",
		2309	csk, skb_headroom(skb), cdev->skb_tx_rsvd);
		2310	return -EINVAL;
		2311	}
		2312
		2313	if (skb->len != skb->data_len)
		2314	frags++;
		2315
		2316	if (frags >= SKB_WR_LIST_SIZE) {
		2317	pr_err("csk 0x%p, frags %u, %u,%u >%lu.\n",
		2318	csk, skb_shinfo(skb)->nr_frags, skb->len,
		2319	skb->data_len, SKB_WR_LIST_SIZE);
		2320	return -EINVAL;
		2321	}
		2322
		2323	cxgbi_skcb_set_flag(skb, SKCBF_TX_NEED_HDR);
		2324	skb_reset_transport_header(skb);
		2325	cxgbi_sock_skb_entail(csk, skb);
		2326
		2327	extra_len = cxgbi_ulp_extra_len(cxgbi_skcb_tx_ulp_mode(skb));
		2328
		2329	if (likely(cxgbi_skcb_test_flag(skb, SKCBF_TX_ISO))) {
		2330	iso_cpl = (struct cxgbi_iso_info *)skb->head;
		2331	num_pdu = iso_cpl->num_pdu;
		2332	hdr_len = cxgbi_skcb_tx_iscsi_hdrlen(skb);
		2333	extra_len = (cxgbi_ulp_extra_len(cxgbi_skcb_tx_ulp_mode(skb)) *
		2334	num_pdu) + (hdr_len * (num_pdu - 1));
		2335	}
		2336
		2337	csk->write_seq += (skb->len + extra_len);
		2338
		2339	return 0;
		2340	}
		2341
		2342	static int cxgbi_sock_send_skb(struct cxgbi_sock csk, struct sk_buff skb)
		2343	{
		2344	struct cxgbi_device *cdev = csk->cdev;
		2345	int len = skb->len;
		2346	int err;
		2347
		2348	spin_lock_bh(&csk->lock);
		2349	err = cxgbi_sock_tx_queue_up(csk, skb);
		2350	if (err < 0) {
		2351	spin_unlock_bh(&csk->lock);
		2352	return err;
		2353	}
		2354
		2355	if (likely(skb_queue_len(&csk->write_queue)))
		2356	cdev->csk_push_tx_frames(csk, 0);
		2357	spin_unlock_bh(&csk->lock);
		2358	return len;
		2359	}
		2360
2062	int cxgbi_conn_xmit_pdu(struct iscsi_task *task)	2361	int cxgbi_conn_xmit_pdu(struct iscsi_task *task)
2063	{	2362	{
2064	struct iscsi_tcp_conn *tcp_conn = task->conn->dd_data;	2363	struct iscsi_tcp_conn *tcp_conn = task->conn->dd_data;
2065	struct cxgbi_conn *cconn = tcp_conn->dd_data;	2364	struct cxgbi_conn *cconn = tcp_conn->dd_data;
		2365	struct iscsi_tcp_task *tcp_task = task->dd_data;
2066	struct cxgbi_task_data *tdata = iscsi_task_cxgbi_data(task);	2366	struct cxgbi_task_data *tdata = iscsi_task_cxgbi_data(task);
2067	struct cxgbi_task_tag_info *ttinfo = &tdata->ttinfo;	2367	struct cxgbi_task_tag_info *ttinfo = &tdata->ttinfo;
2068	struct sk_buff *skb = tdata->skb;	2368	struct sk_buff *skb;
2069	struct cxgbi_sock *csk = NULL;	2369	struct cxgbi_sock *csk = NULL;
2070	unsigned int datalen;	2370	u32 pdulen = 0;
		2371	u32 datalen;
2071	int err;	2372	int err;
2072		2373
		2374	if (!tcp_task \|\| (tcp_task->dd_data != tdata)) {
		2375	pr_err("task 0x%p,0x%p, tcp_task 0x%p, tdata 0x%p/0x%p.\n",
		2376	task, task->sc, tcp_task,
		2377	tcp_task ? tcp_task->dd_data : NULL, tdata);
		2378	return -EINVAL;
		2379	}
		2380
		2381	skb = tdata->skb;
2073	if (!skb) {	2382	if (!skb) {
2074	log_debug(1 << CXGBI_DBG_ISCSI \| 1 << CXGBI_DBG_PDU_TX,	2383	log_debug(1 << CXGBI_DBG_ISCSI \| 1 << CXGBI_DBG_PDU_TX,
2075	"task 0x%p\n", task);	2384	"task 0x%p, skb NULL.\n", task);
2076	return 0;	2385	return 0;
2077	}	2386	}
2078		2387
2079	if (cconn && cconn->cep)	2388	if (cconn && cconn->cep)
2080	csk = cconn->cep->csk;	2389	csk = cconn->cep->csk;
		2390
2081	if (!csk) {	2391	if (!csk) {
2082	log_debug(1 << CXGBI_DBG_ISCSI \| 1 << CXGBI_DBG_PDU_TX,	2392	log_debug(1 << CXGBI_DBG_ISCSI \| 1 << CXGBI_DBG_PDU_TX,
2083	"task 0x%p, csk gone.\n", task);	2393	"task 0x%p, csk gone.\n", task);
@@ -2101,13 +2411,12 @@ int cxgbi_conn_xmit_pdu(struct iscsi_task *task) · 17 unmodified lines
2101	if (!task->sc)	2411	if (!task->sc)
2102	memcpy(skb->data, task->hdr, SKB_TX_ISCSI_PDU_HEADER_MAX);	2412	memcpy(skb->data, task->hdr, SKB_TX_ISCSI_PDU_HEADER_MAX);
2103		2413
2104	err = cxgbi_sock_send_pdus(cconn->cep->csk, skb);	2414	err = cxgbi_sock_send_skb(csk, skb);
2105	if (err > 0) {	2415	if (err > 0) {
2106	int pdulen = err;	2416	pdulen += err;
2107		2417
2108	log_debug(1 << CXGBI_DBG_PDU_TX,	2418	log_debug(1 << CXGBI_DBG_PDU_TX, "task 0x%p,0x%p, rv %d.\n",
2109	"task 0x%p,0x%p, skb 0x%p, len %u/%u, rv %d.\n",	2419	task, task->sc, err);
2110	task, task->sc, skb, skb->len, skb->data_len, err);
2111		2420
2112	if (task->conn->hdrdgst_en)	2421	if (task->conn->hdrdgst_en)
2113	pdulen += ISCSI_DIGEST_SIZE;	2422	pdulen += ISCSI_DIGEST_SIZE;
@@ -2116,24 +2425,42 @@ int cxgbi_conn_xmit_pdu(struct iscsi_task *task) · 2 unmodified lines
2116	pdulen += ISCSI_DIGEST_SIZE;	2425	pdulen += ISCSI_DIGEST_SIZE;
2117		2426
2118	task->conn->txdata_octets += pdulen;	2427	task->conn->txdata_octets += pdulen;
		2428
		2429	if (unlikely(cxgbi_is_iso_config(csk) && cxgbi_is_iso_disabled(csk))) {
		2430	if (time_after(jiffies, csk->prev_iso_ts + HZ)) {
		2431	csk->disable_iso = false;
		2432	csk->prev_iso_ts = 0;
		2433	log_debug(1 << CXGBI_DBG_PDU_TX,
		2434	"enable iso: csk 0x%p\n", csk);
		2435	}
		2436	}
		2437
2119	return 0;	2438	return 0;
2120	}	2439	}
2121		2440
2122	if (err == -EAGAIN \|\| err == -ENOBUFS) {	2441	if (err == -EAGAIN \|\| err == -ENOBUFS) {
2123	log_debug(1 << CXGBI_DBG_PDU_TX,	2442	log_debug(1 << CXGBI_DBG_PDU_TX,
2124	"task 0x%p, skb 0x%p, len %u/%u, %d EAGAIN.\n",	2443	"task 0x%p, skb 0x%p, len %u/%u, %d EAGAIN.\n",
2125	task, skb, skb->len, skb->data_len, err);	2444	task, skb, skb->len, skb->data_len, err);
2126	/* reset skb to send when we are called again */	2445	/* reset skb to send when we are called again */
2127	tdata->skb = skb;	2446	tdata->skb = skb;
		2447
		2448	if (cxgbi_is_iso_config(csk) && !cxgbi_is_iso_disabled(csk) &&
		2449	(csk->no_tx_credits++ >= 2)) {
		2450	csk->disable_iso = true;
		2451	csk->prev_iso_ts = jiffies;
		2452	log_debug(1 << CXGBI_DBG_PDU_TX,
		2453	"disable iso:csk 0x%p, ts:%lu\n",
		2454	csk, csk->prev_iso_ts);
		2455	}
		2456
2128	return err;	2457	return err;
2129	}	2458	}
2130		2459
2131	log_debug(1 << CXGBI_DBG_ISCSI \| 1 << CXGBI_DBG_PDU_TX,
2132	"itt 0x%x, skb 0x%p, len %u/%u, xmit err %d.\n",
2133	task->itt, skb, skb->len, skb->data_len, err);
2134
2135	__kfree_skb(skb);	2460	__kfree_skb(skb);
2136		2461	log_debug(1 << CXGBI_DBG_ISCSI \| 1 << CXGBI_DBG_PDU_TX,
		2462	"itt 0x%x, skb 0x%p, len %u/%u, xmit err %d.\n",
		2463	task->itt, skb, skb->len, skb->data_len, err);
2137	iscsi_conn_printk(KERN_ERR, task->conn, "xmit err %d.\n", err);	2464	iscsi_conn_printk(KERN_ERR, task->conn, "xmit err %d.\n", err);
2138	iscsi_conn_failure(task->conn, ISCSI_ERR_XMIT_FAILED);	2465	iscsi_conn_failure(task->conn, ISCSI_ERR_XMIT_FAILED);
2139	return err;	2466	return err;
@@ -2145,7 +2472,7 @@ void cxgbi_cleanup_task(struct iscsi_task *task) · 5 unmodified lines
2145	struct iscsi_tcp_task *tcp_task = task->dd_data;	2472	struct iscsi_tcp_task *tcp_task = task->dd_data;
2146	struct cxgbi_task_data *tdata = iscsi_task_cxgbi_data(task);	2473	struct cxgbi_task_data *tdata = iscsi_task_cxgbi_data(task);
2147		2474
2148	if (!tcp_task \|\| !tdata \|\| (tcp_task->dd_data != tdata)) {	2475	if (!tcp_task \|\| (tcp_task->dd_data != tdata)) {
2149	pr_info("task 0x%p,0x%p, tcp_task 0x%p, tdata 0x%p/0x%p.\n",	2476	pr_info("task 0x%p,0x%p, tcp_task 0x%p, tdata 0x%p/0x%p.\n",
2150	task, task->sc, tcp_task,	2477	task, task->sc, tcp_task,
2151	tcp_task ? tcp_task->dd_data : NULL, tdata);	2478	tcp_task ? tcp_task->dd_data : NULL, tdata);
@@ -2749,12 +3076,17 @@ static int __init libcxgbi_init_module(void) · 597 unmodified lines
2749		3076
2750	BUILD_BUG_ON(sizeof_field(struct sk_buff, cb) <	3077	BUILD_BUG_ON(sizeof_field(struct sk_buff, cb) <
2751	sizeof(struct cxgbi_skb_cb));	3078	sizeof(struct cxgbi_skb_cb));
		3079	rsvd_page = alloc_page(GFP_KERNEL \| __GFP_ZERO);
		3080	if (!rsvd_page)
		3081	return -ENOMEM;
		3082
2752	return 0;	3083	return 0;
2753	}	3084	}
2754		3085
2755	static void __exit libcxgbi_exit_module(void)	3086	static void __exit libcxgbi_exit_module(void)
2756	{	3087	{
2757	cxgbi_device_unregister_all(0xFF);	3088	cxgbi_device_unregister_all(0xFF);
		3089	put_page(rsvd_page);
2758	return;	3090	return;
2759	}	3091	}
2760		3092

drivers/scsi/cxgbi/libcxgbi.h+42−4

 #define ULP2_MAX_PDU_PAYLOAD	\
 	(ULP2_MAX_PKT_SIZE - ISCSI_PDU_NONPAYLOAD_LEN)
+#define CXGBI_ULP2_MAX_ISO_PAYLOAD	65535
+#define CXGBI_MAX_ISO_DATA_IN_SKB	\
+	min_t(u32, MAX_SKB_FRAGS << PAGE_SHIFT, CXGBI_ULP2_MAX_ISO_PAYLOAD)
+#define cxgbi_is_iso_config(csk)	((csk)->cdev->skb_iso_txhdr)
+#define cxgbi_is_iso_disabled(csk)	((csk)->disable_iso)
 /*
  * For iscsi connections HW may inserts digest bytes into the pdu. Those digest
  * bytes are not sent by the host but are part of the TCP payload and therefore
 	u32 write_seq;
 	u32 snd_win;
 	u32 rcv_win;
+	bool disable_iso;
+	u32 no_tx_credits;
+	unsigned long prev_iso_ts;
 };
 /*
 	void *handle;
 	void *arp_err_handler;
 	struct sk_buff *wr_next;
+	u16 iscsi_hdr_len;
+	u8 ulp_mode;
 };
 enum cxgbi_skcb_flags {
 	SKCBF_RX_HCRC_ERR,	/* header digest error */
 	SKCBF_RX_DCRC_ERR,	/* data digest error */
 	SKCBF_RX_PAD_ERR,	/* padding byte error */
+	SKCBF_TX_ISO,		/* iso cpl in tx skb */
 };
 struct cxgbi_skb_cb {
 		struct cxgbi_skb_rx_cb rx;
 		struct cxgbi_skb_tx_cb tx;
 	};
-	unsigned char ulp_mode;
 	unsigned long flags;
 	unsigned int seq;
 };
 #define CXGBI_SKB_CB(skb)	((struct cxgbi_skb_cb *)&((skb)->cb[0]))
 #define cxgbi_skcb_flags(skb)		(CXGBI_SKB_CB(skb)->flags)
-#define cxgbi_skcb_ulp_mode(skb)	(CXGBI_SKB_CB(skb)->ulp_mode)
 #define cxgbi_skcb_tcp_seq(skb)		(CXGBI_SKB_CB(skb)->seq)
 #define cxgbi_skcb_rx_ddigest(skb)	(CXGBI_SKB_CB(skb)->rx.ddigest)
 #define cxgbi_skcb_rx_pdulen(skb)	(CXGBI_SKB_CB(skb)->rx.pdulen)
 #define cxgbi_skcb_tx_wr_next(skb)	(CXGBI_SKB_CB(skb)->tx.wr_next)
+#define cxgbi_skcb_tx_iscsi_hdrlen(skb)	(CXGBI_SKB_CB(skb)->tx.iscsi_hdr_len)
+#define cxgbi_skcb_tx_ulp_mode(skb)	(CXGBI_SKB_CB(skb)->tx.ulp_mode)
 static inline void cxgbi_skcb_set_flag(struct sk_buff *skb,
 					enum cxgbi_skcb_flags flag)
 #define CXGBI_FLAG_IPV4_SET		0x10
 #define CXGBI_FLAG_USE_PPOD_OFLDQ       0x40
 #define CXGBI_FLAG_DDP_OFF		0x100
+#define CXGBI_FLAG_DEV_ISO_OFF		0x400
 struct cxgbi_device {
 	struct list_head list_head;
 	unsigned int pfvf;
 	unsigned int rx_credit_thres;
 	unsigned int skb_tx_rsvd;
+	u32 skb_iso_txhdr;
 	unsigned int skb_rx_extra;	/* for msg coalesced mode */
 	unsigned int tx_max_size;
 	unsigned int rx_max_size;
 	struct cxgbi_sock *csk;
 };
-#define MAX_PDU_FRAGS	((ULP2_MAX_PDU_PAYLOAD + 512 - 1) / 512)
 struct cxgbi_task_data {
+#define CXGBI_TASK_SGL_CHECKED	0x1
+#define CXGBI_TASK_SGL_COPY	0x2
+	u8 flags;
 	unsigned short nr_frags;
-	struct page_frag frags[MAX_PDU_FRAGS];
+	struct page_frag frags[MAX_SKB_FRAGS];
 	struct sk_buff *skb;
 	unsigned int dlen;
 	unsigned int offset;
 	unsigned int count;
 	unsigned int sgoffset;
+	u32 total_count;
+	u32 total_offset;
+	u32 max_xmit_dlength;
 	struct cxgbi_task_tag_info ttinfo;
 };
 #define iscsi_task_cxgbi_data(task) \
 	((task)->dd_data + sizeof(struct iscsi_tcp_task))
+struct cxgbi_iso_info {
+#define CXGBI_ISO_INFO_FSLICE		0x1
+#define CXGBI_ISO_INFO_LSLICE		0x2
+#define CXGBI_ISO_INFO_IMM_ENABLE	0x4
+	u8 flags;
+	u8 op;
+	u8 ahs;
+	u8 num_pdu;
+	u32 mpdu;
+	u32 burst_size;
+	u32 len;
+	u32 segment_offset;
+	u32 datasn_offset;
+	u32 buffer_offset;
+};
 static inline void *cxgbi_alloc_big_mem(unsigned int size,
 					gfp_t gfp)
 {

drivers/scsi/dpt_i2o.c+0−4

 		printk(KERN_ERR"IOP reset failed - no free memory.\n");
 		return -ENOMEM;
 	}
-	memset(status,0,4);
 	msg[0]=EIGHT_WORD_MSG_SIZE|SGL_OFFSET_0;
 	msg[1]=I2O_CMD_ADAPTER_RESET<<24|HOST_TID<<12|ADAPTER_TID;
 			pHba->name);
 		return -ENOMEM;
 	}
-	memset(status, 0, 4);
 	writel(EIGHT_WORD_MSG_SIZE| SGL_OFFSET_6, &msg[0]);
 	writel(I2O_CMD_OUTBOUND_INIT<<24 | HOST_TID<<12 | ADAPTER_TID, &msg[1]);
 		printk(KERN_ERR "%s: Could not allocate reply pool\n", pHba->name);
 		return -ENOMEM;
 	}
-	memset(pHba->reply_pool, 0 , pHba->reply_fifo_size * REPLY_FRAME_SIZE * 4);
 	for(i = 0; i < pHba->reply_fifo_size; i++) {
 		writel(pHba->reply_pool_pa + (i * REPLY_FRAME_SIZE * 4),
 		printk(KERN_WARNING "SysTab Set failed. Out of memory.\n");
 		return -ENOMEM;
 	}
-	memset(sys_tbl, 0, sys_tbl_len);
 	sys_tbl->num_entries = hba_count;
 	sys_tbl->version = I2OVERSION;

drivers/scsi/esas2r/esas2r.h+2−1

@@ -1225,8 +1225,9 @@ static inline void esas2r_rq_init_request(struct esas2r_request *rq, · 1224 unmodified lines
1225		1225
1226	/* req_table entry should be NULL at this point - if not, halt */	1226	/* req_table entry should be NULL at this point - if not, halt */
1227		1227
1228	if (a->req_table[LOWORD(vrq->scsi.handle)])	1228	if (a->req_table[LOWORD(vrq->scsi.handle)]) {
1229	esas2r_bugon();	1229	esas2r_bugon();
		1230	}
1230		1231
1231	/* fill in the table for this handle so we can get back to the	1232	/* fill in the table for this handle so we can get back to the
1232	* request.	1233	* request.

drivers/scsi/esas2r/esas2r_log.c+5−5

@@ -75,7 +75,7 @@ static char event_buffer[EVENT_LOG_BUFF_SIZE]; · 74 unmodified lines
75	/* A lock to protect the shared buffer used for formatting messages. */	75	/* A lock to protect the shared buffer used for formatting messages. */
76	static DEFINE_SPINLOCK(event_buffer_lock);	76	static DEFINE_SPINLOCK(event_buffer_lock);
77		77
78	/**	78	/*
79	* translates an esas2r-defined logging event level to a kernel logging level.	79	* translates an esas2r-defined logging event level to a kernel logging level.
80	*	80	*
81	* @param [in] level the esas2r-defined logging event level to translate	81	* @param [in] level the esas2r-defined logging event level to translate
@@ -101,7 +101,7 @@ static const char *translate_esas2r_event_level_to_kernel(const long level) · 19 unmodified lines
101	}	101	}
102	}	102	}
103		103
104	/**	104	/*
105	* the master logging function. this function will format the message as	105	* the master logging function. this function will format the message as
106	* outlined by the formatting string, the input device information and the	106	* outlined by the formatting string, the input device information and the
107	* substitution arguments and output the resulting string to the system log.	107	* substitution arguments and output the resulting string to the system log.
@@ -170,7 +170,7 @@ static int esas2r_log_master(const long level, · 62 unmodified lines
170	return 0;	170	return 0;
171	}	171	}
172		172
173	/**	173	/*
174	* formats and logs a message to the system log.	174	* formats and logs a message to the system log.
175	*	175	*
176	* @param [in] level the event level of the message	176	* @param [in] level the event level of the message
@@ -193,7 +193,7 @@ int esas2r_log(const long level, const char *format, ...) · 16 unmodified lines
193	return retval;	193	return retval;
194	}	194	}
195		195
196	/**	196	/*
197	* formats and logs a message to the system log. this message will include	197	* formats and logs a message to the system log. this message will include
198	* device information.	198	* device information.
199	*	199	*
@@ -221,7 +221,7 @@ int esas2r_log_dev(const long level, · 21 unmodified lines
221	return retval;	221	return retval;
222	}	222	}
223		223
224	/**	224	/*
225	* formats and logs a message to the system log. this message will include	225	* formats and logs a message to the system log. this message will include
226	* device information.	226	* device information.
227	*	227	*

drivers/scsi/fcoe/fcoe.c+4−6

 	return 0;
 }
-/**
+/*
  * fcoe_netdev_features_change - Updates the lport's offload flags based
  * on the LLD netdev's FCoE feature flags
  */
 /**
  * fcoe_ctlr_mode() - Switch FIP mode
- * @cdev: The FCoE Controller that is being modified
+ * @ctlr_dev: The FCoE Controller that is being modified
  *
  * When the FIP mode has been changed we need to update
  * the multicast addresses to ensure we get the correct
 /**
  * fcoe_dcb_create() - Initialize DCB attributes and hooks
- * @netdev: The net_device object of the L2 link that should be queried
+ * @fcoe:   The new FCoE interface
- * @port: The fcoe_port to bind FCoE APP priority with
- * @
  */
 static void fcoe_dcb_create(struct fcoe_interface *fcoe)
 {
 	fc_lport_logo_resp(seq, fp, lport);
 }
-/**
+/*
  * fcoe_elsct_send - FCoE specific ELS handler
  *
  * This does special case handling of FIP encapsualted ELS exchanges for FCoE,

drivers/scsi/fcoe/fcoe_ctlr.c+15−15

 /**
  * fcoe_ctlr_init() - Initialize the FCoE Controller instance
  * @fip: The FCoE controller to initialize
+ * @mode: FIP mode to set
  */
 void fcoe_ctlr_init(struct fcoe_ctlr *fip, enum fip_mode mode)
 {
 		printk(KERN_NOTICE "libfcoe: host%d: "
 		       "FIP Fibre-Channel Forwarder MAC %pM deselected\n",
 		       fip->lp->host->host_no, fip->dest_addr);
-		memset(fip->dest_addr, 0, ETH_ALEN);
+		eth_zero_addr(fip->dest_addr);
 	}
 	if (sel) {
 		printk(KERN_INFO "libfcoe: host%d: FIP selected "
 /**
  * fcoe_ctlr_encaps() - Encapsulate an ELS frame for FIP, without sending it
  * @fip:   The FCoE controller for the ELS frame
+ * @lport: The local port
  * @dtype: The FIP descriptor type for the frame
  * @skb:   The FCoE ELS frame including FC header but no FCoE headers
  * @d_id:  The destination port ID.
 /**
  * fcoe_ctlr_recv_els() - Handle an incoming link reset frame
  * @fip: The FCoE controller that received the frame
- * @fh:	 The received FIP header
+ * @skb: The received FIP packet
  *
  * There may be multiple VN_Port descriptors.
  * The overall length has already been checked.
 /**
  * fcoe_ctlr_timeout() - FIP timeout handler
- * @arg: The FCoE controller that timed out
+ * @t: Timer context use to obtain the controller reference
  */
 static void fcoe_ctlr_timeout(struct timer_list *t)
 {
 /**
  * fcoe_ctlr_recv_flogi() - Snoop pre-FIP receipt of FLOGI response
  * @fip: The FCoE controller
+ * @lport: The local port
  * @fp:	 The FC frame to snoop
  *
  * Snoop potential response to FLOGI or even incoming FLOGI.
 /**
  * fcoe_ctlr_disc_stop_locked() - stop discovery in VN2VN mode
- * @fip: The FCoE controller
+ * @lport: The local port
  *
  * Called with ctlr_mutex held.
  */
 /**
  * fcoe_ctlr_disc_stop() - stop discovery in VN2VN mode
- * @fip: The FCoE controller
+ * @lport: The local port
  *
  * Called through the local port template for discovery.
  * Called without the ctlr_mutex held.
 /**
  * fcoe_ctlr_disc_stop_final() - stop discovery for shutdown in VN2VN mode
- * @fip: The FCoE controller
+ * @lport: The local port
  *
  * Called through the local port template for discovery.
  * Called without the ctlr_mutex held.
  * fcoe_ctlr_vn_parse - parse probe request or response
  * @fip: The FCoE controller
  * @skb: incoming packet
- * @rdata: buffer for resulting parsed VN entry plus fcoe_rport
+ * @frport: parsed FCoE rport from the probe request
  *
  * Returns non-zero error number on error.
  * Does not consume the packet.
  * fcoe_ctlr_vlan_parse - parse vlan discovery request or response
  * @fip: The FCoE controller
  * @skb: incoming packet
- * @rdata: buffer for resulting parsed VLAN entry plus fcoe_rport
+ * @frport: parsed FCoE rport from the probe request
  *
  * Returns non-zero error number on error.
  * Does not consume the packet.
  * @fip: The FCoE controller
  * @sub: sub-opcode for vlan notification or vn2vn vlan notification
  * @dest: The destination Ethernet MAC address
- * @min_len: minimum size of the Ethernet payload to be sent
  */
 static void fcoe_ctlr_vlan_send(struct fcoe_ctlr *fip,
 			      enum fip_vlan_subcode sub,
 /**
  * fcoe_ctlr_vlan_recv - vlan request receive handler for VN2VN mode.
- * @lport: The local port
+ * @fip: The FCoE controller
- * @fp: The received frame
+ * @skb: The received FIP packet
- *
  */
 static int fcoe_ctlr_vlan_recv(struct fcoe_ctlr *fip, struct sk_buff *skb)
 {
 	fc_frame_free(fp);
 }
-/**
+/*
- * fcoe_ctlr_disc_recv - start discovery for VN2VN mode.
+ * fcoe_ctlr_disc_start - start discovery for VN2VN mode.
- * @fip: The FCoE controller
  *
  * This sets a flag indicating that remote ports should be created
  * and started for the peers we discover.  We use the disc_callback

drivers/scsi/fcoe/fcoe_transport.c+3−1

 /**
  * fcoe_check_wait_queue() - Attempt to clear the transmit backlog
  * @lport: The local port whose backlog is to be cleared
+ * @skb: The received FIP packet
  *
  * This empties the wait_queue, dequeues the head of the wait_queue queue
  * and calls fcoe_start_io() for each packet. If all skb have been
 /**
  * fcoe_queue_timer() - The fcoe queue timer
- * @lport: The local port
+ * @t: Timer context use to obtain the FCoE port
  *
  * Calls fcoe_check_wait_queue on timeout
  */
 /**
  * fcoe_netdev_map_lookup - find the fcoe transport that matches the netdev on which
  * it was created
+ * @netdev: The net device that the FCoE interface is on
  *
  * Returns : ptr to the fcoe transport that supports this netdev or NULL
  * if not found.

drivers/scsi/fdomain.h+1−1

@@ -103,7 +103,7 @@ enum { · 102 unmodified lines
103	#define REG_FIFO_COUNT 14 /* R: FIFO Data Count */	103	#define REG_FIFO_COUNT 14 /* R: FIFO Data Count */
104		104
105	#ifdef CONFIG_PM_SLEEP	105	#ifdef CONFIG_PM_SLEEP
106	static const struct dev_pm_ops fdomain_pm_ops;	106	static const struct dev_pm_ops __maybe_unused fdomain_pm_ops;
107	#define FDOMAIN_PM_OPS (&fdomain_pm_ops)	107	#define FDOMAIN_PM_OPS (&fdomain_pm_ops)
108	#else	108	#else
109	#define FDOMAIN_PM_OPS NULL	109	#define FDOMAIN_PM_OPS NULL

drivers/scsi/fnic/fnic_scsi.c+2−1

 #include <linux/scatterlist.h>
 #include <linux/skbuff.h>
 #include <linux/spinlock.h>
+#include <linux/etherdevice.h>
 #include <linux/if_ether.h>
 #include <linux/if_vlan.h>
 #include <linux/delay.h>
 	}
 	if (fnic->ctlr.map_dest) {
-		memset(gw_mac, 0xff, ETH_ALEN);
+		eth_broadcast_addr(gw_mac);
 		format = FCPIO_FLOGI_REG_DEF_DEST;
 	} else {
 		memcpy(gw_mac, fnic->ctlr.dest_addr, ETH_ALEN);

drivers/scsi/hisi_sas/hisi_sas_v1_hw.c+3−1

 		!(cmplt_hdr_data & CMPLT_HDR_RSPNS_XFRD_MSK)) {
 		slot_err_v1_hw(hisi_hba, task, slot);
-		if (unlikely(slot->abort))
+		if (unlikely(slot->abort)) {
+			sas_task_abort(task);
 			return;
+		}
 		goto out;
 	}

drivers/scsi/hisi_sas/hisi_sas_v2_hw.c+4−2

 				 error_info[0], error_info[1],
 				 error_info[2], error_info[3]);
-		if (unlikely(slot->abort))
+		if (unlikely(slot->abort)) {
+			sas_task_abort(task);
 			return;
+		}
 		goto out;
 	}
 	fatal_axi_int_v2_hw
 };
-/**
+/*
  * There is a limitation in the hip06 chipset that we need
  * to map in all mbigen interrupts, even if they are not used.
  */

drivers/scsi/hisi_sas/hisi_sas_v3_hw.c+3−1

 				 dw0, dw1, complete_hdr->act, dw3,
 				 error_info[0], error_info[1],
 				 error_info[2], error_info[3]);
-		if (unlikely(slot->abort))
+		if (unlikely(slot->abort)) {
+			sas_task_abort(task);
 			return;
+		}
 		goto out;
 	}

drivers/scsi/hosts.c+5−3

 	if (shost->transportt->create_work_queue) {
 		snprintf(shost->work_q_name, sizeof(shost->work_q_name),
 			 "scsi_wq_%d", shost->host_no);
-		shost->work_q = create_singlethread_workqueue(
+		shost->work_q = alloc_workqueue("%s",
-					shost->work_q_name);
+			WQ_SYSFS | __WQ_LEGACY | WQ_MEM_RECLAIM | WQ_UNBOUND,
+			1, shost->work_q_name);
 		if (!shost->work_q) {
 			error = -EINVAL;
 			goto out_free_shost_data;
 	}
 	shost->tmf_work_q = alloc_workqueue("scsi_tmf_%d",
-					    WQ_UNBOUND | WQ_MEM_RECLAIM,
+					WQ_UNBOUND | WQ_MEM_RECLAIM | WQ_SYSFS,
 					   1, shost->host_no);
 	if (!shost->tmf_work_q) {
 		shost_printk(KERN_WARNING, shost,

drivers/scsi/hpsa.c+27−8

  * HPSA_DRIVER_VERSION must be 3 byte values (0-255) separated by '.'
  * with an optional trailing '-' followed by a byte value (0-255).
  */
-#define HPSA_DRIVER_VERSION "3.4.20-170"
+#define HPSA_DRIVER_VERSION "3.4.20-200"
 #define DRIVER_NAME "HP HPSA Driver (v " HPSA_DRIVER_VERSION ")"
 #define HPSA "hpsa"
 }
 /* configure scsi device based on internal per-device structure */
+#define CTLR_TIMEOUT (120 * HZ)
 static int hpsa_slave_configure(struct scsi_device *sdev)
 {
 	struct hpsa_scsi_dev_t *sd;
 	if (sd) {
 		sd->was_removed = 0;
+		queue_depth = sd->queue_depth != 0 ?
+				sd->queue_depth : sdev->host->can_queue;
 		if (sd->external) {
 			queue_depth = EXTERNAL_QD;
 			sdev->eh_timeout = HPSA_EH_PTRAID_TIMEOUT;
 			blk_queue_rq_timeout(sdev->request_queue,
 						HPSA_EH_PTRAID_TIMEOUT);
-		} else {
-			queue_depth = sd->queue_depth != 0 ?
-					sd->queue_depth : sdev->host->can_queue;
 		}
-	} else
+		if (is_hba_lunid(sd->scsi3addr)) {
+			sdev->eh_timeout = CTLR_TIMEOUT;
+			blk_queue_rq_timeout(sdev->request_queue, CTLR_TIMEOUT);
+		}
+	} else {
 		queue_depth = sdev->host->can_queue;
+	}
 	scsi_change_queue_depth(sdev, queue_depth);
 	struct ErrorInfo *ei = NULL;
 	struct bmic_sense_storage_box_params *bssbp = NULL;
 	struct bmic_identify_physical_device *id_phys = NULL;
-	struct ext_report_lun_entry *rle = &rlep->LUN[rle_index];
+	struct ext_report_lun_entry *rle;
 	u16 bmic_device_index = 0;
+	if (rle_index < 0 || rle_index >= HPSA_MAX_PHYS_LUN)
+		return;
+	rle = &rlep->LUN[rle_index];
 	encl_dev->eli =
 		hpsa_get_enclosure_logical_identifier(h, scsi3addr);
 	int rc;
 	struct ext_report_lun_entry *rle;
+	if (rle_index < 0 || rle_index >= HPSA_MAX_PHYS_LUN)
+		return;
 	rle = &rlep->LUN[rle_index];
 	dev->ioaccel_handle = rle->ioaccel_handle;
 	struct ReportExtendedLUNdata *rlep, int rle_index,
 	struct bmic_identify_physical_device *id_phys)
 {
-	struct ext_report_lun_entry *rle = &rlep->LUN[rle_index];
+	struct ext_report_lun_entry *rle;
+	if (rle_index < 0 || rle_index >= HPSA_MAX_PHYS_LUN)
+		return;
+	rle = &rlep->LUN[rle_index];
 	if ((rle->device_flags & 0x08) && this_device->ioaccel_handle)
 		this_device->hba_ioaccel_enabled = 1;
 		/*
 		 * Skip over some devices such as a spare.
 		 */
-		if (!tmpdevice->external && physical_device) {
+		if (phys_dev_index >= 0 && !tmpdevice->external &&
+			physical_device) {
 			skip_device = hpsa_skip_device(h, lunaddrbytes,
 					&physdev_list->LUN[phys_dev_index]);
 			if (skip_device)

drivers/scsi/hpsa.h+1−1

@@ -57,7 +57,7 @@ struct hpsa_sas_phy { · 56 unmodified lines
57	bool added_to_port;	57	bool added_to_port;
58	};	58	};
59		59
60	#define EXTERNAL_QD 7	60	#define EXTERNAL_QD 128
61	struct hpsa_scsi_dev_t {	61	struct hpsa_scsi_dev_t {
62	unsigned int devtype;	62	unsigned int devtype;
63	int bus, target, lun; /* as presented to the OS */	63	int bus, target, lun; /* as presented to the OS */

drivers/scsi/ibmvscsi/ibmvfc.c+1−1

@@ -1344,7 +1344,7 @@ static void ibmvfc_map_sg_list(struct scsi_cmnd *scmd, int nseg, · 1343 unmodified lines
1344	}	1344	}
1345		1345
1346	/**	1346	/**
1347	* ibmvfc_map_sg_data - Maps dma for a scatterlist and initializes decriptor fields	1347	* ibmvfc_map_sg_data - Maps dma for a scatterlist and initializes descriptor fields
1348	* @scmd: struct scsi_cmnd with the scatterlist	1348	* @scmd: struct scsi_cmnd with the scatterlist
1349	* @evt: ibmvfc event struct	1349	* @evt: ibmvfc event struct
1350	* @vfc_cmd: vfc_cmd that contains the memory descriptor	1350	* @vfc_cmd: vfc_cmd that contains the memory descriptor

drivers/scsi/ibmvscsi/ibmvscsi.c+1−1

@@ -669,7 +669,7 @@ static int map_sg_list(struct scsi_cmnd *cmd, int nseg, · 668 unmodified lines
669	}	669	}
670		670
671	/**	671	/**
672	* map_sg_data: - Maps dma for a scatterlist and initializes decriptor fields	672	* map_sg_data: - Maps dma for a scatterlist and initializes descriptor fields
673	* @cmd: struct scsi_cmnd with the scatterlist	673	* @cmd: struct scsi_cmnd with the scatterlist
674	* @srp_cmd: srp_cmd that contains the memory descriptor	674	* @srp_cmd: srp_cmd that contains the memory descriptor
675	* @dev: device for which to map dma memory	675	* @dev: device for which to map dma memory

drivers/scsi/imm.c+0−3

 			w_ctr(ppb, 0x4);
 		}
 		return 0;	/* Finished */
-		break;
 	default:
 		printk("imm: Invalid scsi phase\n");
 	case 1:		/* Have not connected to interface */
 		dev->cur_cmd = NULL;	/* Forget the problem */
 		return SUCCESS;
-		break;
 	default:		/* SCSI command sent, can not abort */
 		return FAILED;
-		break;
 	}
 }

drivers/scsi/ipr.c+57−33

 /**
  * ipr_init_ipr_cmnd - Initialize an IPR Cmnd block
  * @ipr_cmd:	ipr command struct
+ * @fast_done:	fast done function call-back
  *
  * Return value:
  * 	none
 /**
  * __ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block
- * @ioa_cfg:	ioa config struct
+ * @hrrq:	hrr queue
  *
  * Return value:
  * 	pointer to ipr command struct
 static void ipr_mask_and_clear_interrupts(struct ipr_ioa_cfg *ioa_cfg,
 					  u32 clr_ints)
 {
-	volatile u32 int_reg;
 	int i;
 	/* Stop new interrupts */
 	if (ioa_cfg->sis64)
 		writel(~0, ioa_cfg->regs.clr_interrupt_reg);
 	writel(clr_ints, ioa_cfg->regs.clr_interrupt_reg32);
-	int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
+	readl(ioa_cfg->regs.sense_interrupt_reg);
 }
 /**
 /**
  * __ipr_format_res_path - Format the resource path for printing.
  * @res_path:	resource path
- * @buf:	buffer
+ * @buffer:	buffer
  * @len:	length of buffer provided
  *
  * Return value:
  * ipr_format_res_path - Format the resource path for printing.
  * @ioa_cfg:	ioa config struct
  * @res_path:	resource path
- * @buf:	buffer
+ * @buffer:	buffer
  * @len:	length of buffer provided
  *
  * Return value:
  * ipr_clear_res_target - Clear the bit in the bit map representing the target
  * 			  for the resource.
  * @res:	resource entry struct
- * @cfgtew:	config table entry wrapper struct
  *
  * Return value:
  *      none
 /**
  * ipr_timeout -  An internally generated op has timed out.
- * @ipr_cmd:	ipr command struct
+ * @t: Timer context used to fetch ipr command struct
  *
  * This function blocks host requests and initiates an
  * adapter reset.
 /**
  * ipr_oper_timeout -  Adapter timed out transitioning to operational
- * @ipr_cmd:	ipr command struct
+ * @t: Timer context used to fetch ipr command struct
  *
  * This function blocks host requests and initiates an
  * adapter reset.
 /**
  * ipr_show_fw_version - Show the firmware version
  * @dev:	class device struct
+ * @attr:	device attribute (unused)
  * @buf:	buffer
  *
  * Return value:
 /**
  * ipr_show_log_level - Show the adapter's error logging level
  * @dev:	class device struct
+ * @attr:	device attribute (unused)
  * @buf:	buffer
  *
  * Return value:
 /**
  * ipr_store_log_level - Change the adapter's error logging level
  * @dev:	class device struct
+ * @attr:	device attribute (unused)
  * @buf:	buffer
+ * @count:	buffer size
  *
  * Return value:
  * 	number of bytes printed to buffer
 /**
  * ipr_store_diagnostics - IOA Diagnostics interface
  * @dev:	device struct
+ * @attr:	device attribute (unused)
  * @buf:	buffer
  * @count:	buffer size
  *
 /**
  * ipr_show_adapter_state - Show the adapter's state
- * @class_dev:	device struct
+ * @dev:	device struct
+ * @attr:	device attribute (unused)
  * @buf:	buffer
  *
  * Return value:
 /**
  * ipr_store_adapter_state - Change adapter state
  * @dev:	device struct
+ * @attr:	device attribute (unused)
  * @buf:	buffer
  * @count:	buffer size
  *
 /**
  * ipr_store_reset_adapter - Reset the adapter
  * @dev:	device struct
+ * @attr:	device attribute (unused)
  * @buf:	buffer
  * @count:	buffer size
  *
  /**
  * ipr_show_iopoll_weight - Show ipr polling mode
  * @dev:	class device struct
+ * @attr:	device attribute (unused)
  * @buf:	buffer
  *
  * Return value:
 /**
  * ipr_store_iopoll_weight - Change the adapter's polling mode
  * @dev:	class device struct
+ * @attr:	device attribute (unused)
  * @buf:	buffer
+ * @count:	buffer size
  *
  * Return value:
  *	number of bytes printed to buffer
 /**
  * ipr_free_ucode_buffer - Frees a microcode download buffer
- * @p_dnld:		scatter/gather list pointer
+ * @sglist:		scatter/gather list pointer
  *
  * Free a DMA'able ucode download buffer previously allocated with
  * ipr_alloc_ucode_buffer
 /**
  * ipr_store_update_fw - Update the firmware on the adapter
- * @class_dev:	device struct
+ * @dev:	device struct
+ * @attr:	device attribute (unused)
  * @buf:	buffer
  * @count:	buffer size
  *
 /**
  * ipr_show_fw_type - Show the adapter's firmware type.
  * @dev:	class device struct
+ * @attr:	device attribute (unused)
  * @buf:	buffer
  *
  * Return value:
  * ipr_change_queue_depth - Change the device's queue depth
  * @sdev:	scsi device struct
  * @qdepth:	depth to set
- * @reason:	calling context
  *
  * Return value:
  * 	actual depth set
 /**
  * ipr_show_raw_mode - Show the adapter's raw mode
  * @dev:	class device struct
+ * @attr:	device attribute (unused)
  * @buf:	buffer
  *
  * Return value:
 /**
  * ipr_store_raw_mode - Change the adapter's raw mode
  * @dev:	class device struct
+ * @attr:	device attribute (unused)
  * @buf:	buffer
+ * @count:		buffer size
  *
  * Return value:
  * 	number of bytes printed to buffer
 /**
  * ipr_cmnd_is_free - Check if a command is free or not
- * @ipr_cmd	ipr command struct
+ * @ipr_cmd:	ipr command struct
  *
  * Returns:
  *	true / false
 /**
  * ipr_wait_for_ops - Wait for matching commands to complete
- * @ipr_cmd:	ipr command struct
+ * @ioa_cfg:	ioa config struct
  * @device:		device to match (sdev)
  * @match:		match function to use
  *
  * ipr_sata_reset - Reset the SATA port
  * @link:	SATA link to reset
  * @classes:	class of the attached device
+ * @deadline:	unused
  *
  * This function issues a SATA phy reset to the affected ATA link.
  *
 /**
  * ipr_abort_timeout - An abort task has timed out
- * @ipr_cmd:	ipr command struct
+ * @t: Timer context used to fetch ipr command struct
  *
  * This function handles when an abort task times out. If this
  * happens we issue a bus reset since we have resources tied
 	struct ipr_ioa_cfg *ioa_cfg;
 	struct ipr_resource_entry *res;
 	struct ipr_cmd_pkt *cmd_pkt;
-	u32 ioasc, int_reg;
+	u32 ioasc;
 	int i, op_found = 0;
 	struct ipr_hrr_queue *hrrq;
 	 * by a still not detected EEH error. In such cases, reading a register will
 	 * trigger the EEH recovery infrastructure.
 	 */
-	int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
+	readl(ioa_cfg->regs.sense_interrupt_reg);
 	if (!ipr_is_gscsi(res))
 		return FAILED;
 /**
  * ipr_eh_abort - Abort a single op
- * @scsi_cmd:	scsi command struct
+ * @shost:           scsi host struct
+ * @elapsed_time:    elapsed time
  *
  * Return value:
  *	0 if scan in progress / 1 if scan is complete
  * ipr_isr_eh - Interrupt service routine error handler
  * @ioa_cfg:	ioa config struct
  * @msg:	message to log
+ * @number:	various meanings depending on the caller/message
  *
  * Return value:
  * 	none
 static int ipr_iopoll(struct irq_poll *iop, int budget)
 {
-	struct ipr_ioa_cfg *ioa_cfg;
 	struct ipr_hrr_queue *hrrq;
 	struct ipr_cmnd *ipr_cmd, *temp;
 	unsigned long hrrq_flags;
 	LIST_HEAD(doneq);
 	hrrq = container_of(iop, struct ipr_hrr_queue, iopoll);
-	ioa_cfg = hrrq->ioa_cfg;
 	spin_lock_irqsave(hrrq->lock, hrrq_flags);
 	completed_ops = ipr_process_hrrq(hrrq, budget, &doneq);
 /**
  * ipr_gen_sense - Generate SCSI sense data from an IOASA
- * @ioasa:		IOASA
+ * @ipr_cmd:	ipr command struct
- * @sense_buf:	sense data buffer
  *
  * Return value:
  * 	none
 /**
  * ipr_info - Get information about the card/driver
- * @scsi_host:	scsi host struct
+ * @host:	scsi host struct
  *
  * Return value:
  * 	pointer to buffer with description string
 /**
  * ipr_build_mode_sense - Builds a mode sense command
  * @ipr_cmd:	ipr command struct
- * @res:		resource entry struct
+ * @res_handle:		resource entry struct
  * @parm:		Byte 2 of mode sense command
  * @dma_addr:	DMA address of mode sense buffer
  * @xfer_len:	Size of DMA buffer
 /**
  * ipr_ioafp_set_caching_parameters - Issue Set Cache parameters service
  * action
+ * @ipr_cmd:	ipr command struct
  *
  * Return value:
  *	none
 /**
  * ipr_ioafp_inquiry - Send an Inquiry to the adapter.
  * @ipr_cmd:	ipr command struct
+ * @flags:	flags to send
+ * @page:	page to inquire
+ * @dma_addr:	DMA address
+ * @xfer_len:	transfer data length
  *
  * This utility function sends an inquiry to the adapter.
  *
 /**
  * ipr_reset_timer_done - Adapter reset timer function
- * @ipr_cmd:	ipr command struct
+ * @t: Timer context used to fetch ipr command struct
  *
  * Description: This function is used in adapter reset processing
  * for timing events. If the reset_cmd pointer in the IOA
 static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd)
 {
 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
-	u32 int_reg;
 	ENTER;
 	ioa_cfg->pdev->state_saved = true;
 	if (ioa_cfg->sis64) {
 		/* Set the adapter to the correct endian mode. */
 		writel(IPR_ENDIAN_SWAP_KEY, ioa_cfg->regs.endian_swap_reg);
-		int_reg = readl(ioa_cfg->regs.endian_swap_reg);
+		readl(ioa_cfg->regs.endian_swap_reg);
 	}
 	if (ioa_cfg->ioa_unit_checked) {
  * Description: This is the second phase of adapter initialization
  * This function takes care of initilizing the adapter to the point
  * where it can accept new commands.
  * Return value:
  * 	0 on success / -EIO on failure
  **/
 /**
  * ipr_free_all_resources - Free all allocated resources for an adapter.
- * @ipr_cmd:	ipr command struct
+ * @ioa_cfg:	ioa config struct
  *
  * This function frees all allocated resources for the
  * specified adapter.
 /**
  * ipr_test_intr - Handle the interrupt generated in ipr_test_msi().
- * @pdev:		PCI device struct
+ * @devp:		PCI device struct
+ * @irq:		IRQ number
  *
  * Description: Simply set the msi_received flag to 1 indicating that
  * Message Signaled Interrupts are supported.
 /**
  * ipr_test_msi - Test for Message Signaled Interrupt (MSI) support.
+ * @ioa_cfg:		ioa config struct
  * @pdev:		PCI device struct
  *
  * Description: This routine sets up and initiates a test interrupt to determine
 static int ipr_test_msi(struct ipr_ioa_cfg *ioa_cfg, struct pci_dev *pdev)
 {
 	int rc;
-	volatile u32 int_reg;
 	unsigned long lock_flags = 0;
 	int irq = pci_irq_vector(pdev, 0);
 	ioa_cfg->msi_received = 0;
 	ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
 	writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.clr_interrupt_mask_reg32);
-	int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
+	readl(ioa_cfg->regs.sense_interrupt_mask_reg);
 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
 	rc = request_irq(irq, ipr_test_intr, 0, IPR_NAME, ioa_cfg);
 		dev_info(&pdev->dev, "IRQ assigned: %d\n", irq);
 	writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.sense_interrupt_reg32);
-	int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
+	readl(ioa_cfg->regs.sense_interrupt_reg);
 	wait_event_timeout(ioa_cfg->msi_wait_q, ioa_cfg->msi_received, HZ);
 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
 	ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
 /**
  * ipr_probe - Adapter hot plug add entry point
+ * @pdev:	pci device struct
+ * @dev_id:	pci device ID
  *
  * Return value:
  * 	0 on success / non-zero on failure
 /**
  * ipr_halt_done - Shutdown prepare completion
+ * @ipr_cmd:   ipr command struct
  *
  * Return value:
  * 	none
 /**
  * ipr_halt - Issue shutdown prepare to all adapters
+ * @nb: Notifier block
+ * @event: Notifier event
+ * @buf: Notifier data (unused)
  *
  * Return value:
  * 	NOTIFY_OK on success / NOTIFY_DONE on failure

drivers/scsi/ipr.h+2−2

@@ -1684,7 +1684,7 @@ struct ipr_dump_entry_header { · 1683 unmodified lines
1684	struct ipr_dump_location_entry {	1684	struct ipr_dump_location_entry {
1685	struct ipr_dump_entry_header hdr;	1685	struct ipr_dump_entry_header hdr;
1686	u8 location[20];	1686	u8 location[20];
1687	}__attribute__((packed));	1687	}__attribute__((packed, aligned (4)));
1688		1688
1689	struct ipr_dump_trace_entry {	1689	struct ipr_dump_trace_entry {
1690	struct ipr_dump_entry_header hdr;	1690	struct ipr_dump_entry_header hdr;
@@ -1708,7 +1708,7 @@ struct ipr_driver_dump { · 17 unmodified lines
1708	struct ipr_dump_location_entry location_entry;	1708	struct ipr_dump_location_entry location_entry;
1709	struct ipr_dump_ioa_type_entry ioa_type_entry;	1709	struct ipr_dump_ioa_type_entry ioa_type_entry;
1710	struct ipr_dump_trace_entry trace_entry;	1710	struct ipr_dump_trace_entry trace_entry;
1711	}__attribute__((packed));	1711	}__attribute__((packed, aligned (4)));
1712		1712
1713	struct ipr_ioa_dump {	1713	struct ipr_ioa_dump {
1714	struct ipr_dump_entry_header hdr;	1714	struct ipr_dump_entry_header hdr;

drivers/scsi/ips.c+13−21

 	major = 0;
 	minor = 0;
-	strncpy(ha->bios_version, "       ?", 8);
+	memcpy(ha->bios_version, "       ?", 8);
 	if (ha->pcidev->device == IPS_DEVICEID_COPPERHEAD) {
 		if (IPS_USE_MEMIO(ha)) {
 					inquiry.Flags[1] =
 					    IPS_SCSI_INQ_WBus16 |
 					    IPS_SCSI_INQ_Sync;
-					strncpy(inquiry.VendorId, "IBM     ",
+					memcpy(inquiry.VendorId, "IBM     ",
 						8);
-					strncpy(inquiry.ProductId,
+					memcpy(inquiry.ProductId,
 						"SERVERAID       ", 16);
-					strncpy(inquiry.ProductRevisionLevel,
+					memcpy(inquiry.ProductRevisionLevel,
 						"1.00", 4);
 					ips_scmd_buf_write(scb->scsi_cmd,
 	inquiry.Flags[0] = IPS_SCSI_INQ_Address16;
 	inquiry.Flags[1] =
 	    IPS_SCSI_INQ_WBus16 | IPS_SCSI_INQ_Sync | IPS_SCSI_INQ_CmdQue;
-	strncpy(inquiry.VendorId, "IBM     ", 8);
+	memcpy(inquiry.VendorId, "IBM     ", 8);
-	strncpy(inquiry.ProductId, "SERVERAID       ", 16);
+	memcpy(inquiry.ProductId, "SERVERAID       ", 16);
-	strncpy(inquiry.ProductRevisionLevel, "1.00", 4);
+	memcpy(inquiry.ProductRevisionLevel, "1.00", 4);
 	ips_scmd_buf_write(scb->scsi_cmd, &inquiry, sizeof (inquiry));
 	uint8_t Isr;
 	uint8_t Cbsp;
 	uint8_t PostByte[IPS_MAX_POST_BYTES];
-	uint8_t ConfigByte[IPS_MAX_CONFIG_BYTES];
 	int i, j;
 	METHOD_TRACE("ips_init_copperhead", 1);
 			/* error occurred */
 			return (0);
-		ConfigByte[i] = inb(ha->io_addr + IPS_REG_ISPR);
+		inb(ha->io_addr + IPS_REG_ISPR);
 		outb(Isr, ha->io_addr + IPS_REG_HISR);
 	}
 	uint8_t Isr = 0;
 	uint8_t Cbsp;
 	uint8_t PostByte[IPS_MAX_POST_BYTES];
-	uint8_t ConfigByte[IPS_MAX_CONFIG_BYTES];
 	int i, j;
 	METHOD_TRACE("ips_init_copperhead_memio", 1);
 			/* error occurred */
 			return (0);
-		ConfigByte[i] = readb(ha->mem_ptr + IPS_REG_ISPR);
+		readb(ha->mem_ptr + IPS_REG_ISPR);
 		writeb(Isr, ha->mem_ptr + IPS_REG_HISR);
 	}
 	/* change values (as needed) */
 	ha->nvram->operating_system = IPS_OS_LINUX;
 	ha->nvram->adapter_type = ha->ad_type;
-	strncpy((char *) ha->nvram->driver_high, IPS_VERSION_HIGH, 4);
+	memcpy((char *) ha->nvram->driver_high, IPS_VERSION_HIGH, 4);
-	strncpy((char *) ha->nvram->driver_low, IPS_VERSION_LOW, 4);
+	memcpy((char *) ha->nvram->driver_low, IPS_VERSION_LOW, 4);
-	strncpy((char *) ha->nvram->bios_high, ha->bios_version, 4);
+	memcpy((char *) ha->nvram->bios_high, ha->bios_version, 4);
-	strncpy((char *) ha->nvram->bios_low, ha->bios_version + 4, 4);
+	memcpy((char *) ha->nvram->bios_low, ha->bios_version + 4, 4);
 	ha->nvram->versioning = 0;	/* Indicate the Driver Does Not Support Versioning */
 	uint32_t mem_addr;
 	uint32_t io_len;
 	uint32_t mem_len;
-	uint8_t bus;
-	uint8_t func;
 	int j;
 	int index;
 	dma_addr_t dma_address;
 	if (index >= IPS_MAX_ADAPTERS)
 		return -1;
-	/* stuff that we get in dev */
-	bus = pci_dev->bus->number;
-	func = pci_dev->devfn;
 	/* Init MEM/IO addresses to 0 */
 	mem_addr = 0;
 	io_addr = 0;

drivers/scsi/isci/request.c+1−1

@@ -3444,7 +3444,7 @@ struct isci_request isci_tmf_request_from_tag(struct isci_host ihost, · 3443 unmodified lines
3444	int isci_request_execute(struct isci_host ihost, struct isci_remote_device idev,	3444	int isci_request_execute(struct isci_host ihost, struct isci_remote_device idev,
3445	struct sas_task *task, u16 tag)	3445	struct sas_task *task, u16 tag)
3446	{	3446	{
3447	enum sci_status status = SCI_FAILURE_UNSUPPORTED_PROTOCOL;	3447	enum sci_status status;
3448	struct isci_request *ireq;	3448	struct isci_request *ireq;
3449	unsigned long flags;	3449	unsigned long flags;
3450	int ret = 0;	3450	int ret = 0;

drivers/scsi/libfc/fc_disc.c+3−3

drivers/scsi/libfc/fc_exch.c+6−1

  * @total_exches: Total allocated exchanges
  * @lock:	  Exch pool lock
  * @ex_list:	  List of exchanges
+ * @left:	  Cache of free slot in exch array
+ * @right:	  Cache of free slot in exch array
  *
  * This structure manages per cpu exchanges in array of exchange pointers.
  * This array is allocated followed by struct fc_exch_pool memory for
 	u16		 next_index;
 	u16		 total_exches;
-	/* two cache of free slot in exch array */
 	u16		 left;
 	u16		 right;
 } ____cacheline_aligned_in_smp;
  * @ep_pool:	    Reserved exchange pointers
  * @pool_max_index: Max exch array index in exch pool
  * @pool:	    Per cpu exch pool
+ * @lport:	    Local exchange port
  * @stats:	    Statistics structure
  *
  * This structure is the center for creating exchanges and sequences.
 /**
  * fc_invoke_resp() - invoke ep->resp()
+ * @ep:	   The exchange to be operated on
+ * @fp:	   The frame pointer to pass through to ->resp()
+ * @sp:	   The sequence pointer to pass through to ->resp()
  *
  * Notes:
  * It is assumed that after initialization finished (this means the

drivers/scsi/libfc/fc_fcp.c+7−4

 /**
  * fc_fcp_retry_cmd() - Retry a fcp_pkt
  * @fsp: The FCP packet to be retried
+ * @status_code: The FCP status code to set
  *
  * Sets the status code to be FC_ERROR and then calls
  * fc_fcp_complete_locked() which in turn calls fc_io_compl().
 /**
  * fc_fcp_send_data() - Send SCSI data to a target
  * @fsp:      The FCP packet the data is on
- * @sp:	      The sequence the data is to be sent on
+ * @seq:      The sequence the data is to be sent on
  * @offset:   The starting offset for this data request
  * @seq_blen: The burst length for this data request
  *
 /**
  * fc_lun_reset_send() - Send LUN reset command
- * @data: The FCP packet that identifies the LUN to be reset
+ * @t: Timer context used to fetch the FSP packet
  */
 static void fc_lun_reset_send(struct timer_list *t)
 {
 /**
  * fc_fcp_timeout() - Handler for fcp_pkt timeouts
- * @data: The FCP packet that has timed out
+ * @t: Timer context used to fetch the FSP packet
  *
  * If REC is supported then just issue it and return. The REC exchange will
  * complete or time out and recovery can continue at that point. Otherwise,
 /**
  * fc_fcp_recovery() - Handler for fcp_pkt recovery
  * @fsp: The FCP pkt that needs to be aborted
+ * @code: The FCP status code to set
  */
 static void fc_fcp_recovery(struct fc_fcp_pkt *fsp, u8 code)
 {
  * fc_fcp_srr() - Send a SRR request (Sequence Retransmission Request)
  * @fsp:   The FCP packet the SRR is to be sent on
  * @r_ctl: The R_CTL field for the SRR request
+ * @offset: The SRR relative offset
  * This is called after receiving status but insufficient data, or
  * when expecting status but the request has timed out.
  */
 /**
  * fc_queuecommand() - The queuecommand function of the SCSI template
  * @shost: The Scsi_Host that the command was issued to
- * @cmd:   The scsi_cmnd to be executed
+ * @sc_cmd:   The scsi_cmnd to be executed
  *
  * This is the i/o strategy routine, called by the SCSI layer.
  */

drivers/scsi/libfc/fc_lport.c+5−2

 /**
  * fc_lport_recv_echo_req() - Handle received ECHO request
  * @lport: The local port receiving the ECHO
- * @fp:	   ECHO request frame
+ * @in_fp: ECHO request frame
  */
 static void fc_lport_recv_echo_req(struct fc_lport *lport,
 				   struct fc_frame *in_fp)
 /**
  * fc_lport_recv_rnid_req() - Handle received Request Node ID data request
  * @lport: The local port receiving the RNID
- * @fp:	   The RNID request frame
+ * @in_fp: The RNID request frame
  */
 static void fc_lport_recv_rnid_req(struct fc_lport *lport,
 				   struct fc_frame *in_fp)
 /**
  * fc_lport_enter_ns() - register some object with the name server
  * @lport: Fibre Channel local port to register
+ * @state: Local port state
  */
 static void fc_lport_enter_ns(struct fc_lport *lport, enum fc_lport_state state)
 {
 /**
  * fc_lport_enter_ms() - management server commands
  * @lport: Fibre Channel local port to register
+ * @state: Local port state
  */
 static void fc_lport_enter_ms(struct fc_lport *lport, enum fc_lport_state state)
 {
  * @job:   The BSG Passthrough job
  * @lport: The local port sending the request
  * @did:   The destination port id
+ * @tov:   The timeout period (in ms)
  */
 static int fc_lport_els_request(struct bsg_job *job,
 				struct fc_lport *lport,

drivers/scsi/libfc/fc_rport.c+2−2

@@ -121,7 +121,7 @@ EXPORT_SYMBOL(fc_rport_lookup); · 120 unmodified lines
121	/**	121	/**
122	* fc_rport_create() - Create a new remote port	122	* fc_rport_create() - Create a new remote port
123	* @lport: The local port this remote port will be associated with	123	* @lport: The local port this remote port will be associated with
124	* @ids: The identifiers for the new remote port	124	* @port_id: The identifiers for the new remote port
125	*	125	*
126	* The remote port will start in the INIT state.	126	* The remote port will start in the INIT state.
127	*/	127	*/
@@ -1445,7 +1445,7 @@ drop: · 1317 unmodified lines
1445	* fc_rport_logo_resp() - Handler for logout (LOGO) responses	1445	* fc_rport_logo_resp() - Handler for logout (LOGO) responses
1446	* @sp: The sequence the LOGO was on	1446	* @sp: The sequence the LOGO was on
1447	* @fp: The LOGO response frame	1447	* @fp: The LOGO response frame
1448	* @lport_arg: The local port	1448	* @rdata_arg: The remote port
1449	*/	1449	*/
1450	static void fc_rport_logo_resp(struct fc_seq sp, struct fc_frame fp,	1450	static void fc_rport_logo_resp(struct fc_seq sp, struct fc_frame fp,
1451	void *rdata_arg)	1451	void *rdata_arg)

drivers/scsi/libsas/sas_ata.c+15−2

@@ -507,10 +507,23 @@ void sas_ata_end_eh(struct ata_port *ap) · 506 unmodified lines
507	spin_unlock_irqrestore(&ha->lock, flags);	507	spin_unlock_irqrestore(&ha->lock, flags);
508	}	508	}
509		509
		510	static int sas_ata_prereset(struct ata_link *link, unsigned long deadline)
		511	{
		512	struct ata_port *ap = link->ap;
		513	struct domain_device *dev = ap->private_data;
		514	struct sas_phy *local_phy = sas_get_local_phy(dev);
		515	int res = 0;
		516
		517	if (!local_phy->enabled \|\| test_bit(SAS_DEV_GONE, &dev->state))
		518	res = -ENOENT;
		519	sas_put_local_phy(local_phy);
		520
		521	return res;
		522	}
		523
510	static struct ata_port_operations sas_sata_ops = {	524	static struct ata_port_operations sas_sata_ops = {
511	.prereset = ata_std_prereset,	525	.prereset = sas_ata_prereset,
512	.hardreset = sas_ata_hard_reset,	526	.hardreset = sas_ata_hard_reset,
513	.postreset = ata_std_postreset,
514	.error_handler = ata_std_error_handler,	527	.error_handler = ata_std_error_handler,
515	.post_internal_cmd = sas_ata_post_internal,	528	.post_internal_cmd = sas_ata_post_internal,
516	.qc_defer = ata_std_qc_defer,	529	.qc_defer = ata_std_qc_defer,

drivers/scsi/libsas/sas_expander.c+1−1

@@ -427,7 +427,7 @@ out_err: · 426 unmodified lines
427	static int sas_expander_discover(struct domain_device *dev)	427	static int sas_expander_discover(struct domain_device *dev)
428	{	428	{
429	struct expander_device *ex = &dev->ex_dev;	429	struct expander_device *ex = &dev->ex_dev;
430	int res = -ENOMEM;	430	int res;
431		431
432	ex->ex_phy = kcalloc(ex->num_phys, sizeof(*ex->ex_phy), GFP_KERNEL);	432	ex->ex_phy = kcalloc(ex->num_phys, sizeof(*ex->ex_phy), GFP_KERNEL);
433	if (!ex->ex_phy)	433	if (!ex->ex_phy)

drivers/scsi/lpfc/lpfc.h+15−0

 	enum ras_state state;    /* RAS logging running state */
 };
+#define DBG_LOG_STR_SZ 256
+#define DBG_LOG_SZ 256
+struct dbg_log_ent {
+	char log[DBG_LOG_STR_SZ];
+	u64     t_ns;
+};
 enum lpfc_irq_chann_mode {
 	/* Assign IRQs to all possible cpus that have hardware queues */
 	NORMAL_MODE,
 	struct workqueue_struct *wq;
 	struct delayed_work     eq_delay_work;
+#define LPFC_IDLE_STAT_DELAY 1000
+	struct delayed_work	idle_stat_delay_work;
 	struct lpfc_sli sli;
 	uint8_t pci_dev_grp;	/* lpfc PCI dev group: 0x0, 0x1, 0x2,... */
 	uint32_t sli_rev;		/* SLI2, SLI3, or SLI4 */
 	struct scsi_host_template port_template;
 	/* SCSI host template information - for all vports */
 	struct scsi_host_template vport_template;
+	atomic_t dbg_log_idx;
+	atomic_t dbg_log_cnt;
+	atomic_t dbg_log_dmping;
+	struct dbg_log_ent dbg_log[DBG_LOG_SZ];
 };
 static inline struct Scsi_Host *

drivers/scsi/lpfc/lpfc_bsg.c+17−18

@@ -2404,33 +2404,27 @@ lpfc_sli4_bsg_link_diag_test(struct bsg_job *job) · 2403 unmodified lines
2404	union lpfc_sli4_cfg_shdr *shdr;	2404	union lpfc_sli4_cfg_shdr *shdr;
2405	uint32_t shdr_status, shdr_add_status;	2405	uint32_t shdr_status, shdr_add_status;
2406	struct diag_status *diag_status_reply;	2406	struct diag_status *diag_status_reply;
2407	int mbxstatus, rc = 0;	2407	int mbxstatus, rc = -ENODEV, rc1 = 0;
2408		2408
2409	shost = fc_bsg_to_shost(job);	2409	shost = fc_bsg_to_shost(job);
2410	if (!shost) {	2410	if (!shost)
2411	rc = -ENODEV;
2412	goto job_error;	2411	goto job_error;
2413	}	2412
2414	vport = shost_priv(shost);	2413	vport = shost_priv(shost);
2415	if (!vport) {	2414	if (!vport)
2416	rc = -ENODEV;
2417	goto job_error;	2415	goto job_error;
2418	}	2416
2419	phba = vport->phba;	2417	phba = vport->phba;
2420	if (!phba) {	2418	if (!phba)
2421	rc = -ENODEV;
2422	goto job_error;	2419	goto job_error;
2423	}
2424		2420
2425	if (phba->sli_rev < LPFC_SLI_REV4) {	2421
2426	rc = -ENODEV;	2422	if (phba->sli_rev < LPFC_SLI_REV4)
2427	goto job_error;	2423	goto job_error;
2428	}	2424
2429	if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) <	2425	if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) <
2430	LPFC_SLI_INTF_IF_TYPE_2) {	2426	LPFC_SLI_INTF_IF_TYPE_2)
2431	rc = -ENODEV;
2432	goto job_error;	2427	goto job_error;
2433	}
2434		2428
2435	if (job->request_len < sizeof(struct fc_bsg_request) +	2429	if (job->request_len < sizeof(struct fc_bsg_request) +
2436	sizeof(struct sli4_link_diag)) {	2430	sizeof(struct sli4_link_diag)) {
@@ -2465,8 +2459,10 @@ lpfc_sli4_bsg_link_diag_test(struct bsg_job *job) · 28 unmodified lines
2465	alloc_len = lpfc_sli4_config(phba, pmboxq, LPFC_MBOX_SUBSYSTEM_FCOE,	2459	alloc_len = lpfc_sli4_config(phba, pmboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
2466	LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_STATE,	2460	LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_STATE,
2467	req_len, LPFC_SLI4_MBX_EMBED);	2461	req_len, LPFC_SLI4_MBX_EMBED);
2468	if (alloc_len != req_len)	2462	if (alloc_len != req_len) {
		2463	rc = -ENOMEM;
2469	goto link_diag_test_exit;	2464	goto link_diag_test_exit;
		2465	}
2470		2466
2471	run_link_diag_test = &pmboxq->u.mqe.un.link_diag_test;	2467	run_link_diag_test = &pmboxq->u.mqe.un.link_diag_test;
2472	bf_set(lpfc_mbx_run_diag_test_link_num, &run_link_diag_test->u.req,	2468	bf_set(lpfc_mbx_run_diag_test_link_num, &run_link_diag_test->u.req,
@@ -2515,7 +2511,7 @@ lpfc_sli4_bsg_link_diag_test(struct bsg_job *job) · 42 unmodified lines
2515	diag_status_reply->shdr_add_status = shdr_add_status;	2511	diag_status_reply->shdr_add_status = shdr_add_status;
2516		2512
2517	link_diag_test_exit:	2513	link_diag_test_exit:
2518	rc = lpfc_sli4_bsg_set_link_diag_state(phba, 0);	2514	rc1 = lpfc_sli4_bsg_set_link_diag_state(phba, 0);
2519		2515
2520	if (pmboxq)	2516	if (pmboxq)
2521	mempool_free(pmboxq, phba->mbox_mem_pool);	2517	mempool_free(pmboxq, phba->mbox_mem_pool);
@@ -2524,6 +2520,8 @@ link_diag_test_exit: · 2 unmodified lines
2524		2520
2525	job_error:	2521	job_error:
2526	/* make error code available to userspace */	2522	/* make error code available to userspace */
		2523	if (rc1 && !rc)
		2524	rc = rc1;
2527	bsg_reply->result = rc;	2525	bsg_reply->result = rc;
2528	/* complete the job back to userspace if no error */	2526	/* complete the job back to userspace if no error */
2529	if (rc == 0)	2527	if (rc == 0)
@@ -4306,6 +4304,7 @@ lpfc_bsg_handle_sli_cfg_mbox(struct lpfc_hba phba, struct bsg_job job, · 1776 unmodified lines
4306	case COMN_OPCODE_GET_CNTL_ADDL_ATTRIBUTES:	4304	case COMN_OPCODE_GET_CNTL_ADDL_ATTRIBUTES:
4307	case COMN_OPCODE_GET_CNTL_ATTRIBUTES:	4305	case COMN_OPCODE_GET_CNTL_ATTRIBUTES:
4308	case COMN_OPCODE_GET_PROFILE_CONFIG:	4306	case COMN_OPCODE_GET_PROFILE_CONFIG:
		4307	case COMN_OPCODE_SET_FEATURES:
4309	lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,	4308	lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
4310	"3106 Handled SLI_CONFIG "	4309	"3106 Handled SLI_CONFIG "
4311	"subsys_comn, opcode:x%x\n",	4310	"subsys_comn, opcode:x%x\n",

drivers/scsi/lpfc/lpfc_bsg.h+14−0

 	uint32_t reserved5;
 };
+#define LPFC_CSF_BOOT_DEV		0x1D
+#define LPFC_CSF_QUERY			0
+#define LPFC_CSF_SAVE			1
 struct lpfc_sli_config_emb0_subsys {
 	struct lpfc_sli_config_hdr	sli_config_hdr;
 #define LPFC_MBX_SLI_CONFIG_MAX_MSE     19
 #define FCOE_OPCODE_ADD_FCF		0x09
 #define FCOE_OPCODE_SET_DPORT_MODE	0x27
 #define FCOE_OPCODE_GET_DPORT_RESULTS	0x28
+	uint32_t timeout;		/* comn_set_feature timeout */
+	uint32_t request_length;	/* comn_set_feature request len */
+	uint32_t version;		/* comn_set_feature version */
+	uint32_t csf_feature;		/* comn_set_feature feature */
+	uint32_t word69;		/* comn_set_feature parameter len */
+	uint32_t word70;		/* comn_set_feature parameter val0 */
+#define lpfc_emb0_subcmnd_csf_p0_SHIFT	0
+#define lpfc_emb0_subcmnd_csf_p0_MASK	0x3
+#define lpfc_emb0_subcmnd_csf_p0_WORD	word70
 };
 struct lpfc_sli_config_emb1_subsys {
 #define COMN_OPCODE_WRITE_OBJECT	0xAC
 #define COMN_OPCODE_READ_OBJECT_LIST	0xAD
 #define COMN_OPCODE_DELETE_OBJECT	0xAE
+#define COMN_OPCODE_SET_FEATURES	0xBF
 #define COMN_OPCODE_GET_CNTL_ADDL_ATTRIBUTES	0x79
 #define COMN_OPCODE_GET_CNTL_ATTRIBUTES	0x20
 	uint32_t timeout;

drivers/scsi/lpfc/lpfc_crtn.h+1−1

@@ -386,7 +386,7 @@ void lpfc_rq_buf_free(struct lpfc_hba phba, struct lpfc_dmabuf mp); · 385 unmodified lines
386	int lpfc_link_reset(struct lpfc_vport *vport);	386	int lpfc_link_reset(struct lpfc_vport *vport);
387		387
388	/* Function prototypes. */	388	/* Function prototypes. */
389	int lpfc_check_pci_resettable(const struct lpfc_hba *phba);	389	int lpfc_check_pci_resettable(struct lpfc_hba *phba);
390	const char* lpfc_info(struct Scsi_Host *);	390	const char* lpfc_info(struct Scsi_Host *);
391	int lpfc_scan_finished(struct Scsi_Host *, unsigned long);	391	int lpfc_scan_finished(struct Scsi_Host *, unsigned long);
392		392

drivers/scsi/lpfc/lpfc_ct.c+13−13

@@ -300,7 +300,7 @@ lpfc_ct_free_iocb(struct lpfc_hba phba, struct lpfc_iocbq ctiocb) · 299 unmodified lines
300	return 0;	300	return 0;
301	}	301	}
302		302
303	/**	303	/*
304	* lpfc_gen_req - Build and issue a GEN_REQUEST command to the SLI Layer	304	* lpfc_gen_req - Build and issue a GEN_REQUEST command to the SLI Layer
305	* @vport: pointer to a host virtual N_Port data structure.	305	* @vport: pointer to a host virtual N_Port data structure.
306	* @bmp: Pointer to BPL for SLI command	306	* @bmp: Pointer to BPL for SLI command
@@ -394,7 +394,7 @@ lpfc_gen_req(struct lpfc_vport vport, struct lpfc_dmabuf bmp, · 87 unmodified lines
394	return 0;	394	return 0;
395	}	395	}
396		396
397	/**	397	/*
398	* lpfc_ct_cmd - Build and issue a CT command	398	* lpfc_ct_cmd - Build and issue a CT command
399	* @vport: pointer to a host virtual N_Port data structure.	399	* @vport: pointer to a host virtual N_Port data structure.
400	* @inmp: Pointer to data buffer for response data.	400	* @inmp: Pointer to data buffer for response data.
@@ -750,7 +750,7 @@ lpfc_cmpl_ct_cmd_gid_ft(struct lpfc_hba phba, struct lpfc_iocbq cmdiocb, · 349 unmodified lines
750	if (vport->fc_flag & FC_RSCN_MODE)	750	if (vport->fc_flag & FC_RSCN_MODE)
751	lpfc_els_flush_rscn(vport);	751	lpfc_els_flush_rscn(vport);
752	lpfc_vport_set_state(vport, FC_VPORT_FAILED);	752	lpfc_vport_set_state(vport, FC_VPORT_FAILED);
753	lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,	753	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
754	"0257 GID_FT Query error: 0x%x 0x%x\n",	754	"0257 GID_FT Query error: 0x%x 0x%x\n",
755	irsp->ulpStatus, vport->fc_ns_retry);	755	irsp->ulpStatus, vport->fc_ns_retry);
756	} else {	756	} else {
@@ -811,7 +811,7 @@ lpfc_cmpl_ct_cmd_gid_ft(struct lpfc_hba phba, struct lpfc_iocbq cmdiocb, · 54 unmodified lines
811		811
812	} else {	812	} else {
813	/* NameServer Rsp Error */	813	/* NameServer Rsp Error */
814	lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,	814	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
815	"0241 NameServer Rsp Error "	815	"0241 NameServer Rsp Error "
816	"Data: x%x x%x x%x x%x\n",	816	"Data: x%x x%x x%x x%x\n",
817	CTrsp->CommandResponse.bits.CmdRsp,	817	CTrsp->CommandResponse.bits.CmdRsp,
@@ -951,7 +951,7 @@ lpfc_cmpl_ct_cmd_gid_pt(struct lpfc_hba phba, struct lpfc_iocbq cmdiocb, · 133 unmodified lines
951	if (vport->fc_flag & FC_RSCN_MODE)	951	if (vport->fc_flag & FC_RSCN_MODE)
952	lpfc_els_flush_rscn(vport);	952	lpfc_els_flush_rscn(vport);
953	lpfc_vport_set_state(vport, FC_VPORT_FAILED);	953	lpfc_vport_set_state(vport, FC_VPORT_FAILED);
954	lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,	954	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
955	"4103 GID_FT Query error: 0x%x 0x%x\n",	955	"4103 GID_FT Query error: 0x%x 0x%x\n",
956	irsp->ulpStatus, vport->fc_ns_retry);	956	irsp->ulpStatus, vport->fc_ns_retry);
957	} else {	957	} else {
@@ -1012,7 +1012,7 @@ lpfc_cmpl_ct_cmd_gid_pt(struct lpfc_hba phba, struct lpfc_iocbq cmdiocb, · 54 unmodified lines
1012	}	1012	}
1013	} else {	1013	} else {
1014	/* NameServer Rsp Error */	1014	/* NameServer Rsp Error */
1015	lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,	1015	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1016	"4109 NameServer Rsp Error "	1016	"4109 NameServer Rsp Error "
1017	"Data: x%x x%x x%x x%x\n",	1017	"Data: x%x x%x x%x x%x\n",
1018	CTrsp->CommandResponse.bits.CmdRsp,	1018	CTrsp->CommandResponse.bits.CmdRsp,
@@ -1143,7 +1143,7 @@ lpfc_cmpl_ct_cmd_gff_id(struct lpfc_hba phba, struct lpfc_iocbq cmdiocb, · 124 unmodified lines
1143	}	1143	}
1144	}	1144	}
1145	}	1145	}
1146	lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,	1146	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1147	"0267 NameServer GFF Rsp "	1147	"0267 NameServer GFF Rsp "
1148	"x%x Error (%d %d) Data: x%x x%x\n",	1148	"x%x Error (%d %d) Data: x%x x%x\n",
1149	did, irsp->ulpStatus, irsp->un.ulpWord[4],	1149	did, irsp->ulpStatus, irsp->un.ulpWord[4],
@@ -1271,7 +1271,7 @@ lpfc_cmpl_ct_cmd_gft_id(struct lpfc_hba phba, struct lpfc_iocbq cmdiocb, · 121 unmodified lines
1271	}	1271	}
1272	}	1272	}
1273	} else	1273	} else
1274	lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,	1274	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1275	"3065 GFT_ID failed x%08x\n", irsp->ulpStatus);	1275	"3065 GFT_ID failed x%08x\n", irsp->ulpStatus);
1276		1276
1277	lpfc_ct_free_iocb(phba, cmdiocb);	1277	lpfc_ct_free_iocb(phba, cmdiocb);
@@ -1320,7 +1320,7 @@ lpfc_cmpl_ct(struct lpfc_hba phba, struct lpfc_iocbq cmdiocb, · 42 unmodified lines
1320	irsp->ulpStatus, irsp->un.ulpWord[4], cmdcode);	1320	irsp->ulpStatus, irsp->un.ulpWord[4], cmdcode);
1321		1321
1322	if (irsp->ulpStatus) {	1322	if (irsp->ulpStatus) {
1323	lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,	1323	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1324	"0268 NS cmd x%x Error (x%x x%x)\n",	1324	"0268 NS cmd x%x Error (x%x x%x)\n",
1325	cmdcode, irsp->ulpStatus, irsp->un.ulpWord[4]);	1325	cmdcode, irsp->ulpStatus, irsp->un.ulpWord[4]);
1326		1326
@@ -1843,7 +1843,7 @@ ns_cmd_free_mpvirt: · 516 unmodified lines
1843	ns_cmd_free_mp:	1843	ns_cmd_free_mp:
1844	kfree(mp);	1844	kfree(mp);
1845	ns_cmd_exit:	1845	ns_cmd_exit:
1846	lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,	1846	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1847	"0266 Issue NameServer Req x%x err %d Data: x%x x%x\n",	1847	"0266 Issue NameServer Req x%x err %d Data: x%x x%x\n",
1848	cmdcode, rc, vport->fc_flag, vport->fc_rscn_id_cnt);	1848	cmdcode, rc, vport->fc_flag, vport->fc_rscn_id_cnt);
1849	return 1;	1849	return 1;
@@ -3019,8 +3019,8 @@ int (*lpfc_fdmi_port_action[]) · 1169 unmodified lines
3019	* lpfc_fdmi_cmd - Build and send a FDMI cmd to the specified NPort	3019	* lpfc_fdmi_cmd - Build and send a FDMI cmd to the specified NPort
3020	* @vport: pointer to a host virtual N_Port data structure.	3020	* @vport: pointer to a host virtual N_Port data structure.
3021	* @ndlp: ndlp to send FDMI cmd to (if NULL use FDMI_DID)	3021	* @ndlp: ndlp to send FDMI cmd to (if NULL use FDMI_DID)
3022	* cmdcode: FDMI command to send	3022	* @cmdcode: FDMI command to send
3023	* mask: Mask of HBA or PORT Attributes to send	3023	* @new_mask: Mask of HBA or PORT Attributes to send
3024	*	3024	*
3025	* Builds and sends a FDMI command using the CT subsystem.	3025	* Builds and sends a FDMI command using the CT subsystem.
3026	*/	3026	*/
@@ -3262,7 +3262,7 @@ fdmi_cmd_exit: · 235 unmodified lines
3262		3262
3263	/**	3263	/**
3264	* lpfc_delayed_disc_tmo - Timeout handler for delayed discovery timer.	3264	* lpfc_delayed_disc_tmo - Timeout handler for delayed discovery timer.
3265	* @ptr - Context object of the timer.	3265	* @t: Context object of the timer.
3266	*	3266	*
3267	* This function set the WORKER_DELAYED_DISC_TMO flag and wake up	3267	* This function set the WORKER_DELAYED_DISC_TMO flag and wake up
3268	* the worker thread.	3268	* the worker thread.

drivers/scsi/lpfc/lpfc_els.c+75−68

 		return 0;
 	/* Pending Link Event during Discovery */
-	lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
+	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			 "0237 Pending Link Event during "
 			 "Discovery: State x%x\n",
 			 phba->pport->port_state);
 fail:
 	lpfc_vport_set_state(vport, FC_VPORT_FAILED);
-	lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-		"0249 Cannot issue Register Fabric login: Err %d\n", err);
+			 "0249 Cannot issue Register Fabric login: Err %d\n",
+			 err);
 	return -ENXIO;
 }
 	}
 	lpfc_vport_set_state(vport, FC_VPORT_FAILED);
-	lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-		"0289 Issue Register VFI failed: Err %d\n", rc);
+			 "0289 Issue Register VFI failed: Err %d\n", rc);
 	return rc;
 }
 	mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 	if (!mboxq) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2556 UNREG_VFI mbox allocation failed"
 				"HBA state x%x\n", phba->pport->port_state);
 		return -ENOMEM;
 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
 	if (rc == MBX_NOT_FINISHED) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2557 UNREG_VFI issue mbox failed rc x%x "
 				"HBA state x%x\n",
 				rc, phba->pport->port_state);
 		if (!(irsp->ulpStatus == IOSTAT_LOCAL_REJECT &&
 		      ((irsp->un.ulpWord[4] & IOERR_PARAM_MASK) ==
 					IOERR_LOOP_OPEN_FAILURE)))
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-					"2858 FLOGI failure Status:x%x/x%x "
+					 "2858 FLOGI failure Status:x%x/x%x TMO"
-					"TMO:x%x Data x%x x%x\n",
+					 ":x%x Data x%x x%x\n",
-					irsp->ulpStatus, irsp->un.ulpWord[4],
+					 irsp->ulpStatus, irsp->un.ulpWord[4],
-					irsp->ulpTimeout, phba->hba_flag,
+					 irsp->ulpTimeout, phba->hba_flag,
-					phba->fcf.fcf_flag);
+					 phba->fcf.fcf_flag);
 		/* Check for retry */
 		if (lpfc_els_retry(phba, cmdiocb, rspiocb))
 			goto out;
-		lpfc_printf_vlog(vport, KERN_WARNING, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_WARNING, LOG_TRACE_EVENT,
 				 "0150 FLOGI failure Status:x%x/x%x "
 				 "xri x%x TMO:x%x\n",
 				 irsp->ulpStatus, irsp->un.ulpWord[4],
 		else if (!(phba->hba_flag & HBA_FCOE_MODE))
 			rc = lpfc_cmpl_els_flogi_nport(vport, ndlp, sp);
 		else {
-			lpfc_printf_vlog(vport, KERN_ERR,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-				LOG_FIP | LOG_ELS,
 				"2831 FLOGI response with cleared Fabric "
 				"bit fcf_index 0x%x "
 				"Switch Name %02x%02x%02x%02x%02x%02x%02x%02x "
 	ndlp = lpfc_findnode_did(vport, irsp->un.elsreq64.remoteID);
 	if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) || ndlp != rrq->ndlp) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "2882 RRQ completes to NPort x%x "
 				 "with no ndlp. Data: x%x x%x x%x\n",
 				 irsp->un.elsreq64.remoteID,
 			(((irsp->un.ulpWord[4]) >> 16 != LSRJT_INVALID_CMD) &&
 			((irsp->un.ulpWord[4]) >> 16 != LSRJT_UNABLE_TPC)) ||
 			(phba)->pport->cfg_log_verbose & LOG_ELS)
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-				 "2881 RRQ failure DID:%06X Status:x%x/x%x\n",
+					 "2881 RRQ failure DID:%06X Status:"
-				 ndlp->nlp_DID, irsp->ulpStatus,
+					 "x%x/x%x\n",
-				 irsp->un.ulpWord[4]);
+					 ndlp->nlp_DID, irsp->ulpStatus,
+					 irsp->un.ulpWord[4]);
 	}
 out:
 	if (rrq)
 	ndlp = lpfc_findnode_did(vport, irsp->un.elsreq64.remoteID);
 	if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0136 PLOGI completes to NPort x%x "
 				 "with no ndlp. Data: x%x x%x x%x\n",
 				 irsp->un.elsreq64.remoteID,
 			(((irsp->un.ulpWord[4]) >> 16 != LSRJT_INVALID_CMD) &&
 			((irsp->un.ulpWord[4]) >> 16 != LSRJT_UNABLE_TPC)) ||
 			(phba)->pport->cfg_log_verbose & LOG_ELS)
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "2753 PLOGI failure DID:%06X Status:x%x/x%x\n",
 				 ndlp->nlp_DID, irsp->ulpStatus,
 				 irsp->un.ulpWord[4]);
 	IOCB_t *irsp;
 	struct lpfc_nodelist *ndlp;
 	char *mode;
+	u32 loglevel;
 	/* we pass cmdiocb to state machine which needs rspiocb as well */
 	cmdiocb->context_un.rsp_iocb = rspiocb;
 		 * could be expected.
 		 */
 		if ((vport->fc_flag & FC_FABRIC) ||
-		    (vport->cfg_enable_fc4_type != LPFC_ENABLE_BOTH))
+		    (vport->cfg_enable_fc4_type != LPFC_ENABLE_BOTH)) {
 			mode = KERN_ERR;
-		else
+			loglevel =  LOG_TRACE_EVENT;
+		} else {
 			mode = KERN_INFO;
+			loglevel =  LOG_ELS;
+		}
 		/* PRLI failed */
-		lpfc_printf_vlog(vport, mode, LOG_ELS,
+		lpfc_printf_vlog(vport, mode, loglevel,
 				 "2754 PRLI failure DID:%06X Status:x%x/x%x, "
 				 "data: x%x\n",
 				 ndlp->nlp_DID, irsp->ulpStatus,
 			goto out;
 		}
 		/* ADISC failed */
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "2755 ADISC failure DID:%06X Status:x%x/x%x\n",
 				 ndlp->nlp_DID, irsp->ulpStatus,
 				 irsp->un.ulpWord[4]);
 	 */
 	if (irsp->ulpStatus) {
 		/* LOGO failed */
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "2756 LOGO failure, No Retry DID:%06X Status:x%x/x%x\n",
 				 ndlp->nlp_DID, irsp->ulpStatus,
 				 irsp->un.ulpWord[4]);
 /**
  * lpfc_els_retry_delay - Timer function with a ndlp delayed function timer
- * @ptr: holder for the pointer to the timer function associated data (ndlp).
+ * @t: pointer to the timer function associated data (ndlp).
  *
  * This routine is invoked by the ndlp delayed-function timer to check
  * whether there is any pending ELS retry event(s) with the node. If not, it
 			 "2851 Attempt link reset\n");
 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 	if (!mbox) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2852 Failed to allocate mbox memory");
 		return 1;
 	}
 	mbox->vport = vport;
 	rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
 	if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2853 Failed to issue INIT_LINK "
 				"mbox command, rc:x%x\n", rc);
 		mempool_free(mbox, phba->mbox_mem_pool);
 			break;
 		case IOERR_ILLEGAL_COMMAND:
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 					 "0124 Retry illegal cmd x%x "
 					 "retry:x%x delay:x%x\n",
 					 cmd, cmdiocb->retry, delay);
 			if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
 			  (cmd == ELS_CMD_FDISC) &&
 			  (stat.un.b.lsRjtRsnCodeExp == LSEXP_OUT_OF_RESOURCE)){
-				lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+				lpfc_printf_vlog(vport, KERN_ERR,
+						 LOG_TRACE_EVENT,
 						 "0125 FDISC Failed (x%x). "
 						 "Fabric out of resources\n",
 						 stat.un.lsRjtError);
 						LSEXP_NOTHING_MORE) {
 				vport->fc_sparam.cmn.bbRcvSizeMsb &= 0xf;
 				retry = 1;
-				lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+				lpfc_printf_vlog(vport, KERN_ERR,
+						 LOG_TRACE_EVENT,
 						 "0820 FLOGI Failed (x%x). "
 						 "BBCredit Not Supported\n",
 						 stat.un.lsRjtError);
 			  ((stat.un.b.lsRjtRsnCodeExp == LSEXP_INVALID_PNAME) ||
 			  (stat.un.b.lsRjtRsnCodeExp == LSEXP_INVALID_NPORT_ID))
 			  ) {
-				lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+				lpfc_printf_vlog(vport, KERN_ERR,
+						 LOG_TRACE_EVENT,
 						 "0122 FDISC Failed (x%x). "
 						 "Fabric Detected Bad WWN\n",
 						 stat.un.lsRjtError);
 	}
 	/* No retry ELS command <elsCmd> to remote NPORT <did> */
 	if (logerr) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			 "0137 No retry ELS command x%x to remote "
 			 "NPORT x%x: Out of Resources: Error:x%x/%x\n",
 			 cmd, did, irsp->ulpStatus,
 	irsp = &rspiocb->iocb;
 	if (!vport) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"3177 ELS response failed\n");
 		goto out;
 	}
 			ndlp->nlp_flag &= ~NLP_REG_LOGIN_SEND;
 			/* ELS rsp: Cannot issue reg_login for <NPortid> */
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				"0138 ELS rsp: Cannot issue reg_login for x%x "
 				"Data: x%x x%x x%x\n",
 				ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
 /**
  * lpfc_els_rsp_reject - Propare and issue a rjt response iocb command
  * @vport: pointer to a virtual N_Port data structure.
- * @rejectError:
+ * @rejectError: reject response to issue
  * @oldiocb: pointer to the original lpfc command iocb data structure.
  * @ndlp: pointer to a node-list data structure.
  * @mbox: pointer to the driver internal queue element for mailbox command.
 	lcb_context->rx_id = cmdiocb->iocb.ulpContext;
 	lcb_context->ndlp = lpfc_nlp_get(ndlp);
 	if (lpfc_sli4_set_beacon(vport, lcb_context, state)) {
-		lpfc_printf_vlog(ndlp->vport, KERN_ERR,
+		lpfc_printf_vlog(ndlp->vport, KERN_ERR, LOG_TRACE_EVENT,
-				 LOG_ELS, "0193 failed to send mail box");
+				 "0193 failed to send mail box");
 		kfree(lcb_context);
 		lpfc_nlp_put(ndlp);
 		rjt_err = LSRJT_UNABLE_TPC;
 	rscn_event_data = kmalloc(sizeof(struct lpfc_rscn_event_header) +
 		payload_len, GFP_KERNEL);
 	if (!rscn_event_data) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			"0147 Failed to allocate memory for RSCN event\n");
 		return;
 	}
 		/* An FLOGI ELS command <elsCmd> was received from DID <did> in
 		   Loop Mode */
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0113 An FLOGI ELS command x%x was "
 				 "received from DID x%x in Loop Mode\n",
 				 cmd, did);
 /**
  * lpfc_els_timeout - Handler funciton to the els timer
- * @ptr: holder for the timer function associated data.
+ * @t: timer context used to obtain the vport.
  *
  * This routine is invoked by the ELS timer after timeout. It posts the ELS
  * timer timeout event by setting the WORKER_ELS_TMO bit to the work port
 	list_for_each_entry_safe(piocb, tmp_iocb, &abort_list, dlist) {
 		cmd = &piocb->iocb;
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			 "0127 ELS timeout Data: x%x x%x x%x "
 			 "x%x\n", els_command,
 			 remote_ID, cmd->ulpCommand, cmd->ulpIoTag);
 		spin_unlock_irqrestore(&phba->hbalock, iflags);
 	}
 	if (!list_empty(&abort_list))
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "3387 abort list for txq not empty\n");
 	INIT_LIST_HEAD(&abort_list);
  * lpfc_send_els_event - Posts unsolicited els event
  * @vport: Pointer to vport object.
  * @ndlp: Pointer FC node object.
- * @cmd: ELS command code.
+ * @payload: ELS command code type.
  *
  * This function posts an event when there is an incoming
  * unsolicited ELS command.
 	if (*payload == ELS_CMD_LOGO) {
 		logo_data = kmalloc(sizeof(struct lpfc_logo_event), GFP_KERNEL);
 		if (!logo_data) {
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				"0148 Failed to allocate memory "
 				"for LOGO event\n");
 			return;
 		els_data = kmalloc(sizeof(struct lpfc_els_event_header),
 			GFP_KERNEL);
 		if (!els_data) {
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				"0149 Failed to allocate memory "
 				"for ELS event\n");
 			return;
 /**
  * lpfc_els_rcv_fpin_li - Process an FPIN Link Integrity Event.
  * @vport: Pointer to vport object.
- * @lnk_not:  Pointer to the Link Integrity Notification Descriptor.
+ * @tlv:  Pointer to the Link Integrity Notification Descriptor.
  *
  * This function processes a link integrity FPIN event by
  * logging a message
 			break;
 		default:
 			dtag_nm = lpfc_get_tlv_dtag_nm(dtag);
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 					 "4678  skipped FPIN descriptor[%d]: "
 					 "tag x%x (%s)\n",
 					 desc_cnt, dtag, dtag_nm);
 		rjt_exp = LSEXP_NOTHING_MORE;
 		/* Unknown ELS command <elsCmd> received from NPORT <did> */
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0115 Unknown ELS command x%x "
 				 "received from NPORT x%x\n", cmd, did);
 		if (newnode)
 dropit:
 	if (vport && !(vport->load_flag & FC_UNLOADING))
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			"0111 Dropping received ELS cmd "
 			"Data: x%x x%x x%x\n",
 			icmd->ulpStatus, icmd->un.ulpWord[4], icmd->ulpTimeout);
 	spin_lock_irq(shost->host_lock);
 	if (vport->fc_flag & FC_DISC_DELAYED) {
 		spin_unlock_irq(shost->host_lock);
-		lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"3334 Delay fc port discovery for %d seconds\n",
 				phba->fc_ratov);
 		mod_timer(&vport->delayed_disc_tmo,
 				return;
 			}
 			lpfc_vport_set_state(vport, FC_VPORT_FAILED);
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 					 "0251 NameServer login: no memory\n");
 			return;
 		}
 				return;
 			}
 			lpfc_vport_set_state(vport, FC_VPORT_FAILED);
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 					"0348 NameServer login: node freed\n");
 			return;
 		}
 	if (lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0)) {
 		lpfc_vport_set_state(vport, FC_VPORT_FAILED);
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0252 Cannot issue NameServer login\n");
 		return;
 	}
 	spin_unlock_irq(shost->host_lock);
 	if (mb->mbxStatus) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				"0915 Register VPI failed : Status: x%x"
 				" upd bit: x%x \n", mb->mbxStatus,
 				 mb->un.varRegVpi.upd);
 			rc = lpfc_sli_issue_mbox(phba, pmb,
 				MBX_NOWAIT);
 			if (rc == MBX_NOT_FINISHED) {
-				lpfc_printf_vlog(vport,
+				lpfc_printf_vlog(vport, KERN_ERR,
-					KERN_ERR, LOG_MBOX,
+						 LOG_TRACE_EVENT,
 					"2732 Failed to issue INIT_VPI"
 					" mailbox command\n");
 			} else {
 			lpfc_nlp_put(ndlp);
 			mempool_free(mbox, phba->mbox_mem_pool);
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				"0253 Register VPI: Can't send mbox\n");
 			goto mbox_err_exit;
 		}
 	} else {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0254 Register VPI: no memory\n");
 		goto mbox_err_exit;
 	}
 		if (lpfc_els_retry(phba, cmdiocb, rspiocb))
 			goto out;
 		/* FDISC failed */
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0126 FDISC failed. (x%x/x%x)\n",
 				 irsp->ulpStatus, irsp->un.ulpWord[4]);
 		goto fdisc_failed;
 				     ELS_CMD_FDISC);
 	if (!elsiocb) {
 		lpfc_vport_set_state(vport, FC_VPORT_FAILED);
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0255 Issue FDISC: no IOCB\n");
 		return 1;
 	}
 	if (rc == IOCB_ERROR) {
 		lpfc_els_free_iocb(phba, elsiocb);
 		lpfc_vport_set_state(vport, FC_VPORT_FAILED);
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0256 Issue FDISC: Cannot send IOCB\n");
 		return 1;
 	}
 /**
  * lpfc_fabric_block_timeout - Handler function to the fabric block timer
- * @ptr: holder for the timer function associated data.
+ * @t: timer context used to obtain the lpfc hba.
  *
  * This routine is invoked by the fabric iocb block timer after
  * timeout. It posts the fabric iocb block timeout event by setting the
 				"rport in state 0x%x\n", ndlp->nlp_state);
 		return;
 	}
-	lpfc_printf_log(phba, KERN_ERR,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
-			LOG_ELS | LOG_FCP_ERROR | LOG_NVME_IOERR,
 			"3094 Start rport recovery on shost id 0x%x "
 			"fc_id 0x%06x vpi 0x%x rpi 0x%x state 0x%x "
 			"flags 0x%x\n",

drivers/scsi/lpfc/lpfc_hbadisc.c+122−109

 		return;
 	if (rport->port_name != wwn_to_u64(ndlp->nlp_portname.u.wwn))
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_NODE,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-				"6789 rport name %llx != node port name %llx",
+				 "6789 rport name %llx != node port name %llx",
-				rport->port_name,
+				 rport->port_name,
-				wwn_to_u64(ndlp->nlp_portname.u.wwn));
+				 wwn_to_u64(ndlp->nlp_portname.u.wwn));
 	evtp = &ndlp->dev_loss_evt;
 	if (!list_empty(&evtp->evt_listp)) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_NODE,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-				"6790 rport name %llx dev_loss_evt pending",
+				 "6790 rport name %llx dev_loss_evt pending",
-				rport->port_name);
+				 rport->port_name);
 		return;
 	}
 	}
 	if (warn_on) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0203 Devloss timeout on "
 				 "WWPN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x "
 				 "NPort x%06x Data: x%x x%x x%x\n",
 				 ndlp->nlp_DID, ndlp->nlp_flag,
 				 ndlp->nlp_state, ndlp->nlp_rpi);
 	} else {
-		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
+		lpfc_printf_vlog(vport, KERN_INFO, LOG_TRACE_EVENT,
 				 "0204 Devloss timeout on "
 				 "WWPN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x "
 				 "NPort x%06x Data: x%x x%x x%x\n",
 					 || kthread_should_stop()));
 		/* Signal wakeup shall terminate the worker thread */
 		if (rc) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"0433 Wakeup on signal: rc=x%x\n", rc);
 			break;
 		}
 	/* Check for error */
 	if ((mb->mbxStatus) && (mb->mbxStatus != 0x1601)) {
 		/* CLEAR_LA mbox error <mbxStatus> state <hba_state> */
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0320 CLEAR_LA mbxStatus error x%x hba "
 				 "state x%x\n",
 				 mb->mbxStatus, vport->port_state);
 	return;
 out:
-	lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
+	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			 "0306 CONFIG_LINK mbxStatus error x%x "
 			 "HBA state x%x\n",
 			 pmb->u.mb.mbxStatus, vport->port_state);
 	lpfc_linkdown(phba);
-	lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
+	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			 "0200 CONFIG_LINK bad hba state x%x\n",
 			 vport->port_state);
 /**
  * lpfc_sli4_clear_fcf_rr_bmask
- * @phba pointer to the struct lpfc_hba for this port.
+ * @phba: pointer to the struct lpfc_hba for this port.
  * This fucnction resets the round robin bit mask and clears the
  * fcf priority list. The list deletions are done while holding the
  * hbalock. The ON_LIST flag and the FLOGI_FAILED flags are cleared
 	struct lpfc_vport *vport = mboxq->vport;
 	if (mboxq->u.mb.mbxStatus) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-			 "2017 REG_FCFI mbxStatus error x%x "
+				 "2017 REG_FCFI mbxStatus error x%x "
-			 "HBA state x%x\n",
+				 "HBA state x%x\n", mboxq->u.mb.mbxStatus,
-			 mboxq->u.mb.mbxStatus, vport->port_state);
+				 vport->port_state);
 		goto fail_out;
 	}
 /**
  * lpfc_sw_name_match - Check if the fcf switch name match.
- * @fab_name: pointer to fabric name.
+ * @sw_name: pointer to switch name.
  * @new_fcf_record: pointer to fcf record.
  *
  * This routine compare the fcf record's switch name with provided
 /**
  * lpfc_copy_fcf_record - Copy fcf information to lpfc_hba.
- * @fcf: pointer to driver fcf record.
+ * @fcf_rec: pointer to driver fcf record.
  * @new_fcf_record: pointer to fcf record.
  *
  * This routine copies the FCF information from the FCF
 	 */
 	lpfc_sli4_mbx_sge_get(mboxq, 0, &sge);
 	if (unlikely(!mboxq->sge_array)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2524 Failed to get the non-embedded SGE "
 				"virtual address\n");
 		return NULL;
 	if (shdr_status || shdr_add_status) {
 		if (shdr_status == STATUS_FCF_TABLE_EMPTY ||
 					if_type == LPFC_SLI_INTF_IF_TYPE_2)
-			lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
+			lpfc_printf_log(phba, KERN_ERR,
+					LOG_TRACE_EVENT,
 					"2726 READ_FCF_RECORD Indicates empty "
 					"FCF table.\n");
 		else
-			lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"2521 READ_FCF_RECORD mailbox failed "
 					"with status x%x add_status x%x, "
 					"mbx\n", shdr_status, shdr_add_status);
 }
 /**
- lpfc_sli4_fcf_record_match - testing new FCF record for matching existing FCF
+ * lpfc_sli4_fcf_record_match - testing new FCF record for matching existing FCF
  * @phba: pointer to lpfc hba data structure.
  * @fcf_rec: pointer to an existing FCF record.
  * @new_fcf_record: pointer to a new FCF record.
 /**
  * lpfc_sli4_fcf_pri_list_del
  * @phba: pointer to lpfc hba data structure.
- * @fcf_index the index of the fcf record to delete
+ * @fcf_index: the index of the fcf record to delete
  * This routine checks the on list flag of the fcf_index to be deleted.
  * If it is one the list then it is removed from the list, and the flag
  * is cleared. This routine grab the hbalock before removing the fcf
 /**
  * lpfc_sli4_set_fcf_flogi_fail
  * @phba: pointer to lpfc hba data structure.
- * @fcf_index the index of the fcf record to update
+ * @fcf_index: the index of the fcf record to update
  * This routine acquires the hbalock and then set the LPFC_FCF_FLOGI_FAILED
  * flag so the the round robin slection for the particular priority level
  * will try a different fcf record that does not have this bit set.
 /**
  * lpfc_sli4_fcf_pri_list_add
  * @phba: pointer to lpfc hba data structure.
- * @fcf_index the index of the fcf record to add
+ * @fcf_index: the index of the fcf record to add
+ * @new_fcf_record: pointer to a new FCF record.
  * This routine checks the priority of the fcf_index to be added.
  * If it is a lower priority than the current head of the fcf_pri list
  * then it is added to the list in the right order.
 	new_fcf_record = lpfc_sli4_fcf_rec_mbox_parse(phba, mboxq,
 						      &next_fcf_index);
 	if (!new_fcf_record) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2765 Mailbox command READ_FCF_RECORD "
 				"failed to retrieve a FCF record.\n");
 		/* Let next new FCF event trigger fast failover */
 		    new_fcf_record, LPFC_FCOE_IGNORE_VID)) {
 			if (bf_get(lpfc_fcf_record_fcf_index, new_fcf_record) !=
 			    phba->fcf.current_rec.fcf_indx) {
-				lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
+				lpfc_printf_log(phba, KERN_ERR,
+						LOG_TRACE_EVENT,
 					"2862 FCF (x%x) matches property "
 					"of in-use FCF (x%x)\n",
 					bf_get(lpfc_fcf_record_fcf_index,
 						phba->pport->fc_flag);
 				goto out;
 			} else
-				lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"2863 New FCF (x%x) matches "
 					"property of in-use FCF (x%x)\n",
 					bf_get(lpfc_fcf_record_fcf_index,
 	    (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
 			LPFC_SLI_INTF_IF_TYPE_0) &&
 	    mboxq->u.mb.mbxStatus != MBX_VFI_IN_USE) {
-		lpfc_printf_vlog(vport, KERN_ERR,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-				LOG_MBOX,
+				 "2891 Init VFI mailbox failed 0x%x\n",
-				"2891 Init VFI mailbox failed 0x%x\n",
+				 mboxq->u.mb.mbxStatus);
-				mboxq->u.mb.mbxStatus);
 		mempool_free(mboxq, phba->mbox_mem_pool);
 		lpfc_vport_set_state(vport, FC_VPORT_FAILED);
 		return;
 	mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 	if (!mboxq) {
 		lpfc_printf_vlog(vport, KERN_ERR,
-			LOG_MBOX, "2892 Failed to allocate "
+			LOG_TRACE_EVENT, "2892 Failed to allocate "
 			"init_vfi mailbox\n");
 		return;
 	}
 	mboxq->mbox_cmpl = lpfc_init_vfi_cmpl;
 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
 	if (rc == MBX_NOT_FINISHED) {
-		lpfc_printf_vlog(vport, KERN_ERR,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-			LOG_MBOX, "2893 Failed to issue init_vfi mailbox\n");
+				 "2893 Failed to issue init_vfi mailbox\n");
 		mempool_free(mboxq, vport->phba->mbox_mem_pool);
 	}
 }
 	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 	if (mboxq->u.mb.mbxStatus) {
-		lpfc_printf_vlog(vport, KERN_ERR,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-				LOG_MBOX,
+				 "2609 Init VPI mailbox failed 0x%x\n",
-				"2609 Init VPI mailbox failed 0x%x\n",
+				 mboxq->u.mb.mbxStatus);
-				mboxq->u.mb.mbxStatus);
 		mempool_free(mboxq, phba->mbox_mem_pool);
 		lpfc_vport_set_state(vport, FC_VPORT_FAILED);
 		return;
 			ndlp = lpfc_findnode_did(vport, Fabric_DID);
 			if (!ndlp)
 				lpfc_printf_vlog(vport, KERN_ERR,
-					LOG_DISCOVERY,
+					LOG_TRACE_EVENT,
 					"2731 Cannot find fabric "
 					"controller node\n");
 			else
 		lpfc_initial_fdisc(vport);
 	else {
 		lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "2606 No NPIV Fabric support\n");
 	}
 	mempool_free(mboxq, phba->mbox_mem_pool);
 	if ((vport->port_type != LPFC_PHYSICAL_PORT) && (!vport->vpi)) {
 		vpi = lpfc_alloc_vpi(vport->phba);
 		if (!vpi) {
-			lpfc_printf_vlog(vport, KERN_ERR,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-					 LOG_MBOX,
 					 "3303 Failed to obtain vport vpi\n");
 			lpfc_vport_set_state(vport, FC_VPORT_FAILED);
 			return;
 	mboxq = mempool_alloc(vport->phba->mbox_mem_pool, GFP_KERNEL);
 	if (!mboxq) {
 		lpfc_printf_vlog(vport, KERN_ERR,
-			LOG_MBOX, "2607 Failed to allocate "
+			LOG_TRACE_EVENT, "2607 Failed to allocate "
 			"init_vpi mailbox\n");
 		return;
 	}
 	mboxq->mbox_cmpl = lpfc_init_vpi_cmpl;
 	rc = lpfc_sli_issue_mbox(vport->phba, mboxq, MBX_NOWAIT);
 	if (rc == MBX_NOT_FINISHED) {
-		lpfc_printf_vlog(vport, KERN_ERR,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-			LOG_MBOX, "2608 Failed to issue init_vpi mailbox\n");
+				 "2608 Failed to issue init_vpi mailbox\n");
 		mempool_free(mboxq, vport->phba->mbox_mem_pool);
 	}
 }
 				lpfc_vport_set_state(vports[i],
 						     FC_VPORT_NO_FABRIC_SUPP);
 				lpfc_printf_vlog(vports[i], KERN_ERR,
-						 LOG_ELS,
+						 LOG_TRACE_EVENT,
 						 "0259 No NPIV "
 						 "Fabric support\n");
 			}
 	    (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
 			LPFC_SLI_INTF_IF_TYPE_0) &&
 	    mboxq->u.mb.mbxStatus != MBX_VFI_IN_USE) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-			 "2018 REG_VFI mbxStatus error x%x "
+				 "2018 REG_VFI mbxStatus error x%x "
-			 "HBA state x%x\n",
+				 "HBA state x%x\n",
-			 mboxq->u.mb.mbxStatus, vport->port_state);
+				 mboxq->u.mb.mbxStatus, vport->port_state);
 		if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
 			/* FLOGI failed, use loop map to make discovery list */
 			lpfc_disc_list_loopmap(vport);
 	/* Check for error */
 	if (mb->mbxStatus) {
 		/* READ_SPARAM mbox error <mbxStatus> state <hba_state> */
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0319 READ_SPARAM mbxStatus error x%x "
 				 "hba state x%x>\n",
 				 mb->mbxStatus, vport->port_state);
 					GFP_KERNEL);
 			if (unlikely(!fcf_record)) {
 				lpfc_printf_log(phba, KERN_ERR,
-					LOG_MBOX | LOG_SLI,
+					LOG_TRACE_EVENT,
 					"2554 Could not allocate memory for "
 					"fcf record\n");
 				rc = -ENODEV;
 			rc = lpfc_sli4_add_fcf_record(phba, fcf_record);
 			if (unlikely(rc)) {
 				lpfc_printf_log(phba, KERN_ERR,
-					LOG_MBOX | LOG_SLI,
+					LOG_TRACE_EVENT,
 					"2013 Could not manually add FCF "
 					"record 0, status %d\n", rc);
 				rc = -ENODEV;
 	return;
 out:
 	lpfc_vport_set_state(vport, FC_VPORT_FAILED);
-	lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
+	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			 "0263 Discovery Mailbox error: state: 0x%x : x%px x%px\n",
 			 vport->port_state, sparam_mbox, cfglink_mbox);
 	lpfc_issue_clear_la(phba, vport);
 		break;
 	/* If VPI is busy, reset the HBA */
 	case 0x9700:
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_NODE,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			"2798 Unreg_vpi failed vpi 0x%x, mb status = 0x%x\n",
 			vport->vpi, mb->mbxStatus);
 		if (!(phba->pport->load_flag & FC_UNLOADING))
 	mbox->mbox_cmpl = lpfc_mbx_cmpl_unreg_vpi;
 	rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
 	if (rc == MBX_NOT_FINISHED) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX | LOG_VPORT,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "1800 Could not issue unreg_vpi\n");
 		mempool_free(mbox, phba->mbox_mem_pool);
 		vport->unreg_vpi_cmpl = VPORT_ERROR;
 	pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 	if (!pmb) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0542 lpfc_create_static_vport failed to"
 				" allocate mailbox memory\n");
 		return;
 	vport_info = kzalloc(sizeof(struct static_vport_info), GFP_KERNEL);
 	if (!vport_info) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0543 lpfc_create_static_vport failed to"
 				" allocate vport_info\n");
 		mempool_free(pmb, phba->mbox_mem_pool);
 	if ((le32_to_cpu(vport_info->signature) != VPORT_INFO_SIG) ||
 		((le32_to_cpu(vport_info->rev) & VPORT_INFO_REV_MASK)
 			!= VPORT_INFO_REV)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
-			"0545 lpfc_create_static_vport bad"
+				"0545 lpfc_create_static_vport bad"
-			" information header 0x%x 0x%x\n",
+				" information header 0x%x 0x%x\n",
-			le32_to_cpu(vport_info->signature),
+				le32_to_cpu(vport_info->signature),
-			le32_to_cpu(vport_info->rev) & VPORT_INFO_REV_MASK);
+				le32_to_cpu(vport_info->rev) &
+				VPORT_INFO_REV_MASK);
 		goto out;
 	}
 	pmb->ctx_buf = NULL;
 	if (mb->mbxStatus) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0258 Register Fabric login error: 0x%x\n",
 				 mb->mbxStatus);
 		lpfc_mbuf_free(phba, mp->virt, mp->phys);
 			/* Cannot issue NameServer FCP Query, so finish up
 			 * discovery
 			 */
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_SLI,
+			lpfc_printf_vlog(vport, KERN_ERR,
+					 LOG_TRACE_EVENT,
 					 "0604 %s FC TYPE %x %s\n",
 					 "Failed to issue GID_FT to ",
 					 FC_TYPE_FCP,
 			/* Cannot issue NameServer NVME Query, so finish up
 			 * discovery
 			 */
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_SLI,
+			lpfc_printf_vlog(vport, KERN_ERR,
+					 LOG_TRACE_EVENT,
 					 "0605 %s FC_TYPE %x %s %d\n",
 					 "Failed to issue GID_FT to ",
 					 FC_TYPE_NVME,
 		/* Cannot issue NameServer FCP Query, so finish up
 		 * discovery
 		 */
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_SLI,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0606 %s Port TYPE %x %s\n",
 				 "Failed to issue GID_PT to ",
 				 GID_PT_N_PORT,
 	vport->gidft_inp = 0;
 	if (mb->mbxStatus) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0260 Register NameServer error: 0x%x\n",
 				 mb->mbxStatus);
 					 GFP_KERNEL);
 		if (!ndlp->lat_data)
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_NODE,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				"0286 lpfc_nlp_state_cleanup failed to "
 				"allocate statistical data buffer DID "
 				"0x%x\n", ndlp->nlp_DID);
 	vports = lpfc_create_vport_work_array(phba);
 	if (!vports) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
-			"2884 Vport array allocation failed \n");
+				"2884 Vport array allocation failed \n");
 		return;
 	}
 	for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
 			mempool_free(mbox, phba->mbox_mem_pool);
 		if ((rc == MBX_TIMEOUT) || (rc == MBX_NOT_FINISHED))
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX | LOG_VPORT,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-				"1836 Could not issue "
+					 "1836 Could not issue "
-				"unreg_login(all_rpis) status %d\n", rc);
+					 "unreg_login(all_rpis) status %d\n",
+					 rc);
 	}
 }
 			mempool_free(mbox, phba->mbox_mem_pool);
 		if ((rc == MBX_TIMEOUT) || (rc == MBX_NOT_FINISHED))
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX | LOG_VPORT,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 					 "1815 Could not issue "
 					 "unreg_did (default rpis) status %d\n",
 					 rc);
 	case LPFC_FLOGI:
 	/* port_state is identically LPFC_FLOGI while waiting for FLOGI cmpl */
 		/* Initial FLOGI timeout */
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
+		lpfc_printf_vlog(vport, KERN_ERR,
+				 LOG_TRACE_EVENT,
 				 "0222 Initial %s timeout\n",
 				 vport->vpi ? "FDISC" : "FLOGI");
 	case LPFC_FABRIC_CFG_LINK:
 	/* hba_state is identically LPFC_FABRIC_CFG_LINK while waiting for
 	   NameServer login */
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
+		lpfc_printf_vlog(vport, KERN_ERR,
+				 LOG_TRACE_EVENT,
 				 "0223 Timeout while waiting for "
 				 "NameServer login\n");
 		/* Next look for NameServer ndlp */
 	case LPFC_NS_QRY:
 	/* Check for wait for NameServer Rsp timeout */
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
+		lpfc_printf_vlog(vport, KERN_ERR,
+				 LOG_TRACE_EVENT,
 				 "0224 NameServer Query timeout "
 				 "Data: x%x x%x\n",
 				 vport->fc_ns_retry, LPFC_MAX_NS_RETRY);
 		/* Setup and issue mailbox INITIALIZE LINK command */
 		initlinkmbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 		if (!initlinkmbox) {
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
+			lpfc_printf_vlog(vport, KERN_ERR,
+					 LOG_TRACE_EVENT,
 					 "0206 Device Discovery "
 					 "completion error\n");
 			phba->link_state = LPFC_HBA_ERROR;
 	case LPFC_DISC_AUTH:
 	/* Node Authentication timeout */
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
+		lpfc_printf_vlog(vport, KERN_ERR,
+				 LOG_TRACE_EVENT,
 				 "0227 Node Authentication timeout\n");
 		lpfc_disc_flush_list(vport);
 	case LPFC_VPORT_READY:
 		if (vport->fc_flag & FC_RSCN_MODE) {
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
+			lpfc_printf_vlog(vport, KERN_ERR,
+					 LOG_TRACE_EVENT,
 					 "0231 RSCN timeout Data: x%x "
 					 "x%x\n",
 					 vport->fc_ns_retry, LPFC_MAX_NS_RETRY);
 		break;
 	default:
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
+		lpfc_printf_vlog(vport, KERN_ERR,
+				 LOG_TRACE_EVENT,
 				 "0273 Unexpected discovery timeout, "
 				 "vport State x%x\n", vport->port_state);
 		break;
 	switch (phba->link_state) {
 	case LPFC_CLEAR_LA:
 				/* CLEAR LA timeout */
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
+		lpfc_printf_vlog(vport, KERN_ERR,
+				 LOG_TRACE_EVENT,
 				 "0228 CLEAR LA timeout\n");
 		clrlaerr = 1;
 		break;
 	case LPFC_INIT_MBX_CMDS:
 	case LPFC_LINK_DOWN:
 	case LPFC_HBA_ERROR:
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
+		lpfc_printf_vlog(vport, KERN_ERR,
+				 LOG_TRACE_EVENT,
 				 "0230 Unexpected timeout, hba link "
 				 "state x%x\n", phba->link_state);
 		clrlaerr = 1;
 		}
 		if (i >= phba->max_vpi) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
-					 "2936 Could not find Vport mapped "
+					"2936 Could not find Vport mapped "
-					 "to vpi %d\n", vpi);
+					"to vpi %d\n", vpi);
 			return NULL;
 		}
 	}
 	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 	if (mboxq->u.mb.mbxStatus) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
-			"2555 UNREG_VFI mbxStatus error x%x "
+				"2555 UNREG_VFI mbxStatus error x%x "
-			"HBA state x%x\n",
+				"HBA state x%x\n",
-			mboxq->u.mb.mbxStatus, vport->port_state);
+				mboxq->u.mb.mbxStatus, vport->port_state);
 	}
 	spin_lock_irq(shost->host_lock);
 	phba->pport->fc_flag &= ~FC_VFI_REGISTERED;
 	struct lpfc_vport *vport = mboxq->vport;
 	if (mboxq->u.mb.mbxStatus) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
-			"2550 UNREG_FCFI mbxStatus error x%x "
+				"2550 UNREG_FCFI mbxStatus error x%x "
-			"HBA state x%x\n",
+				"HBA state x%x\n",
-			mboxq->u.mb.mbxStatus, vport->port_state);
+				mboxq->u.mb.mbxStatus, vport->port_state);
 	}
 	mempool_free(mboxq, phba->mbox_mem_pool);
 	return;
 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 	if (!mbox) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2551 UNREG_FCFI mbox allocation failed"
 				"HBA state x%x\n", phba->pport->port_state);
 		return -ENOMEM;
 	rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
 	if (rc == MBX_NOT_FINISHED) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2552 Unregister FCFI command failed rc x%x "
 				"HBA state x%x\n",
 				rc, phba->pport->port_state);
 	/* Preparation for unregistering fcf */
 	rc = lpfc_unregister_fcf_prep(phba);
 	if (rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2748 Failed to prepare for unregistering "
 				"HBA's FCF record: rc=%d\n", rc);
 		return;
 		spin_lock_irq(&phba->hbalock);
 		phba->fcf.fcf_flag &= ~FCF_INIT_DISC;
 		spin_unlock_irq(&phba->hbalock);
-		lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2553 lpfc_unregister_unused_fcf failed "
 				"to read FCF record HBA state x%x\n",
 				phba->pport->port_state);
 	/* Preparation for unregistering fcf */
 	rc = lpfc_unregister_fcf_prep(phba);
 	if (rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2749 Failed to prepare for unregistering "
 				"HBA's FCF record: rc=%d\n", rc);
 		return;
 		conn_entry = kzalloc(sizeof(struct lpfc_fcf_conn_entry),
 			GFP_KERNEL);
 		if (!conn_entry) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
-				"2566 Failed to allocate connection"
+					"2566 Failed to allocate connection"
-				" table entry\n");
+					" table entry\n");
 			return;
 		}
 	/* Check the region signature first */
 	if (memcmp(buff, LPFC_REGION23_SIGNATURE, 4)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"2567 Config region 23 has bad signature\n");
 		return;
 	}
 	/* Check the data structure version */
 	if (buff[offset] != LPFC_REGION23_VERSION) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
-			"2568 Config region 23 has bad version\n");
+				"2568 Config region 23 has bad version\n");
 		return;
 	}
 	offset += 4;

drivers/scsi/lpfc/lpfc_hw4.h+4−1

 #define lpfc_sliport_status_oti_SHIFT	29
 #define lpfc_sliport_status_oti_MASK	0x1
 #define lpfc_sliport_status_oti_WORD	word0
+#define lpfc_sliport_status_dip_SHIFT	25
+#define lpfc_sliport_status_dip_MASK	0x1
+#define lpfc_sliport_status_dip_WORD	word0
 #define lpfc_sliport_status_rn_SHIFT	24
 #define lpfc_sliport_status_rn_MASK	0x1
 #define lpfc_sliport_status_rn_WORD	word0
 };
 #define LPFC_SET_UE_RECOVERY		0x10
-#define LPFC_SET_MDS_DIAGS		0x11
+#define LPFC_SET_MDS_DIAGS		0x12
 #define LPFC_SET_DUAL_DUMP		0x1e
 struct lpfc_mbx_set_feature {
 	struct mbox_header header;

drivers/scsi/lpfc/lpfc_init.c+468−271

@@ -153,7 +153,7 @@ lpfc_config_port_prep(struct lpfc_hba *phba) · 152 unmodified lines
153	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);	153	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
154		154
155	if (rc != MBX_SUCCESS) {	155	if (rc != MBX_SUCCESS) {
156	lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,	156	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
157	"0324 Config Port initialization "	157	"0324 Config Port initialization "
158	"error, mbxCmd x%x READ_NVPARM, "	158	"error, mbxCmd x%x READ_NVPARM, "
159	"mbxStatus x%x\n",	159	"mbxStatus x%x\n",
@@ -177,7 +177,7 @@ lpfc_config_port_prep(struct lpfc_hba *phba) · 17 unmodified lines
177	lpfc_read_rev(phba, pmb);	177	lpfc_read_rev(phba, pmb);
178	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);	178	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
179	if (rc != MBX_SUCCESS) {	179	if (rc != MBX_SUCCESS) {
180	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	180	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
181	"0439 Adapter failed to init, mbxCmd x%x "	181	"0439 Adapter failed to init, mbxCmd x%x "
182	"READ_REV, mbxStatus x%x\n",	182	"READ_REV, mbxStatus x%x\n",
183	mb->mbxCommand, mb->mbxStatus);	183	mb->mbxCommand, mb->mbxStatus);
@@ -192,7 +192,7 @@ lpfc_config_port_prep(struct lpfc_hba *phba) · 8 unmodified lines
192	*/	192	*/
193	if (mb->un.varRdRev.rr == 0) {	193	if (mb->un.varRdRev.rr == 0) {
194	vp->rev.rBit = 0;	194	vp->rev.rBit = 0;
195	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	195	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
196	"0440 Adapter failed to init, READ_REV has "	196	"0440 Adapter failed to init, READ_REV has "
197	"missing revision information.\n");	197	"missing revision information.\n");
198	mempool_free(pmb, phba->mbox_mem_pool);	198	mempool_free(pmb, phba->mbox_mem_pool);
@@ -253,13 +253,15 @@ lpfc_config_port_prep(struct lpfc_hba *phba) · 54 unmodified lines
253	*/	253	*/
254	if (mb->un.varDmp.word_cnt == 0)	254	if (mb->un.varDmp.word_cnt == 0)
255	break;	255	break;
256	if (mb->un.varDmp.word_cnt > DMP_VPD_SIZE - offset)	256
257	mb->un.varDmp.word_cnt = DMP_VPD_SIZE - offset;	257	i = mb->un.varDmp.word_cnt * sizeof(uint32_t);
		258	if (offset + i > DMP_VPD_SIZE)
		259	i = DMP_VPD_SIZE - offset;
258	lpfc_sli_pcimem_bcopy(((uint8_t *)mb) + DMP_RSP_OFFSET,	260	lpfc_sli_pcimem_bcopy(((uint8_t *)mb) + DMP_RSP_OFFSET,
259	lpfc_vpd_data + offset,	261	lpfc_vpd_data + offset, i);
260	mb->un.varDmp.word_cnt);	262	offset += i;
261	offset += mb->un.varDmp.word_cnt;	263	} while (offset < DMP_VPD_SIZE);
262	} while (mb->un.varDmp.word_cnt && offset < DMP_VPD_SIZE);	264
263	lpfc_parse_vpd(phba, lpfc_vpd_data, offset);	265	lpfc_parse_vpd(phba, lpfc_vpd_data, offset);
264		266
265	kfree(lpfc_vpd_data);	267	kfree(lpfc_vpd_data);
@@ -442,7 +444,7 @@ lpfc_config_port_post(struct lpfc_hba *phba) · 176 unmodified lines
442		444
443	pmb->vport = vport;	445	pmb->vport = vport;
444	if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {	446	if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
445	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	447	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
446	"0448 Adapter failed init, mbxCmd x%x "	448	"0448 Adapter failed init, mbxCmd x%x "
447	"READ_SPARM mbxStatus x%x\n",	449	"READ_SPARM mbxStatus x%x\n",
448	mb->mbxCommand, mb->mbxStatus);	450	mb->mbxCommand, mb->mbxStatus);
@@ -496,7 +498,7 @@ lpfc_config_port_post(struct lpfc_hba *phba) · 47 unmodified lines
496	lpfc_read_config(phba, pmb);	498	lpfc_read_config(phba, pmb);
497	pmb->vport = vport;	499	pmb->vport = vport;
498	if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {	500	if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
499	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	501	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
500	"0453 Adapter failed to init, mbxCmd x%x "	502	"0453 Adapter failed to init, mbxCmd x%x "
501	"READ_CONFIG, mbxStatus x%x\n",	503	"READ_CONFIG, mbxStatus x%x\n",
502	mb->mbxCommand, mb->mbxStatus);	504	mb->mbxCommand, mb->mbxStatus);
@@ -545,7 +547,7 @@ lpfc_config_port_post(struct lpfc_hba *phba) · 42 unmodified lines
545	}	547	}
546	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);	548	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
547	if (rc != MBX_SUCCESS) {	549	if (rc != MBX_SUCCESS) {
548	lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,	550	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
549	"0352 Config MSI mailbox command "	551	"0352 Config MSI mailbox command "
550	"failed, mbxCmd x%x, mbxStatus x%x\n",	552	"failed, mbxCmd x%x, mbxStatus x%x\n",
551	pmb->u.mb.mbxCommand,	553	pmb->u.mb.mbxCommand,
@@ -596,17 +598,15 @@ lpfc_config_port_post(struct lpfc_hba *phba) · 44 unmodified lines
596	jiffies + msecs_to_jiffies(1000 * phba->eratt_poll_interval));	598	jiffies + msecs_to_jiffies(1000 * phba->eratt_poll_interval));
597		599
598	if (phba->hba_flag & LINK_DISABLED) {	600	if (phba->hba_flag & LINK_DISABLED) {
599	lpfc_printf_log(phba,	601	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
600	KERN_ERR, LOG_INIT,	602	"2598 Adapter Link is disabled.\n");
601	"2598 Adapter Link is disabled.\n");
602	lpfc_down_link(phba, pmb);	603	lpfc_down_link(phba, pmb);
603	pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;	604	pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
604	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);	605	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
605	if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {	606	if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {
606	lpfc_printf_log(phba,	607	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
607	KERN_ERR, LOG_INIT,	608	"2599 Adapter failed to issue DOWN_LINK"
608	"2599 Adapter failed to issue DOWN_LINK"	609	" mbox command rc 0x%x\n", rc);
609	" mbox command rc 0x%x\n", rc);
610		610
611	mempool_free(pmb, phba->mbox_mem_pool);	611	mempool_free(pmb, phba->mbox_mem_pool);
612	return -EIO;	612	return -EIO;
@@ -630,9 +630,7 @@ lpfc_config_port_post(struct lpfc_hba *phba) · 17 unmodified lines
630	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);	630	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
631		631
632	if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {	632	if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
633	lpfc_printf_log(phba,	633	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
634	KERN_ERR,
635	LOG_INIT,
636	"0456 Adapter failed to issue "	634	"0456 Adapter failed to issue "
637	"ASYNCEVT_ENABLE mbox status x%x\n",	635	"ASYNCEVT_ENABLE mbox status x%x\n",
638	rc);	636	rc);
@@ -652,7 +650,8 @@ lpfc_config_port_post(struct lpfc_hba *phba) · 13 unmodified lines
652	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);	650	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
653		651
654	if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {	652	if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
655	lpfc_printf_log(phba, KERN_ERR, LOG_INIT, "0435 Adapter failed "	653	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
		654	"0435 Adapter failed "
656	"to get Option ROM version status x%x\n", rc);	655	"to get Option ROM version status x%x\n", rc);
657	mempool_free(pmb, phba->mbox_mem_pool);	656	mempool_free(pmb, phba->mbox_mem_pool);
658	}	657	}
@@ -730,10 +729,10 @@ lpfc_hba_init_link_fc_topology(struct lpfc_hba *phba, uint32_t fc_topology, · 71 unmodified lines
730	((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_64G) &&	729	((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_64G) &&
731	!(phba->lmt & LMT_64Gb))) {	730	!(phba->lmt & LMT_64Gb))) {
732	/* Reset link speed to auto */	731	/* Reset link speed to auto */
733	lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,	732	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
734	"1302 Invalid speed for this board:%d "	733	"1302 Invalid speed for this board:%d "
735	"Reset link speed to auto.\n",	734	"Reset link speed to auto.\n",
736	phba->cfg_link_speed);	735	phba->cfg_link_speed);
737	phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;	736	phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
738	}	737	}
739	lpfc_init_link(phba, pmb, fc_topology, phba->cfg_link_speed);	738	lpfc_init_link(phba, pmb, fc_topology, phba->cfg_link_speed);
@@ -742,10 +741,10 @@ lpfc_hba_init_link_fc_topology(struct lpfc_hba *phba, uint32_t fc_topology, · 2 unmodified lines
742	lpfc_set_loopback_flag(phba);	741	lpfc_set_loopback_flag(phba);
743	rc = lpfc_sli_issue_mbox(phba, pmb, flag);	742	rc = lpfc_sli_issue_mbox(phba, pmb, flag);
744	if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {	743	if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
745	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	744	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
746	"0498 Adapter failed to init, mbxCmd x%x "	745	"0498 Adapter failed to init, mbxCmd x%x "
747	"INIT_LINK, mbxStatus x%x\n",	746	"INIT_LINK, mbxStatus x%x\n",
748	mb->mbxCommand, mb->mbxStatus);	747	mb->mbxCommand, mb->mbxStatus);
749	if (phba->sli_rev <= LPFC_SLI_REV3) {	748	if (phba->sli_rev <= LPFC_SLI_REV3) {
750	/* Clear all interrupt enable conditions */	749	/* Clear all interrupt enable conditions */
751	writel(0, phba->HCregaddr);	750	writel(0, phba->HCregaddr);
@@ -791,17 +790,15 @@ lpfc_hba_down_link(struct lpfc_hba *phba, uint32_t flag) · 39 unmodified lines
791	return -ENOMEM;	790	return -ENOMEM;
792	}	791	}
793		792
794	lpfc_printf_log(phba,	793	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
795	KERN_ERR, LOG_INIT,	794	"0491 Adapter Link is disabled.\n");
796	"0491 Adapter Link is disabled.\n");
797	lpfc_down_link(phba, pmb);	795	lpfc_down_link(phba, pmb);
798	pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;	796	pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
799	rc = lpfc_sli_issue_mbox(phba, pmb, flag);	797	rc = lpfc_sli_issue_mbox(phba, pmb, flag);
800	if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {	798	if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {
801	lpfc_printf_log(phba,	799	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
802	KERN_ERR, LOG_INIT,	800	"2522 Adapter failed to issue DOWN_LINK"
803	"2522 Adapter failed to issue DOWN_LINK"	801	" mbox command rc 0x%x\n", rc);
804	" mbox command rc 0x%x\n", rc);
805		802
806	mempool_free(pmb, phba->mbox_mem_pool);	803	mempool_free(pmb, phba->mbox_mem_pool);
807	return -EIO;	804	return -EIO;
@@ -996,7 +993,6 @@ lpfc_hba_clean_txcmplq(struct lpfc_hba *phba) · 188 unmodified lines
996		993
997	/**	994	/**
998	* lpfc_hba_down_post_s3 - Perform lpfc uninitialization after HBA reset	995	* lpfc_hba_down_post_s3 - Perform lpfc uninitialization after HBA reset
999	int i;
1000	* @phba: pointer to lpfc HBA data structure.	996	* @phba: pointer to lpfc HBA data structure.
1001	*	997	*
1002	* This routine will do uninitialization after the HBA is reset when bring	998	* This routine will do uninitialization after the HBA is reset when bring
@@ -1124,7 +1120,7 @@ lpfc_hba_down_post(struct lpfc_hba *phba) · 121 unmodified lines
1124		1120
1125	/**	1121	/**
1126	* lpfc_hb_timeout - The HBA-timer timeout handler	1122	* lpfc_hb_timeout - The HBA-timer timeout handler
1127	* @ptr: unsigned long holds the pointer to lpfc hba data structure.	1123	* @t: timer context used to obtain the pointer to lpfc hba data structure.
1128	*	1124	*
1129	* This is the HBA-timer timeout handler registered to the lpfc driver. When	1125	* This is the HBA-timer timeout handler registered to the lpfc driver. When
1130	* this timer fires, a HBA timeout event shall be posted to the lpfc driver	1126	* this timer fires, a HBA timeout event shall be posted to the lpfc driver
@@ -1158,7 +1154,7 @@ lpfc_hb_timeout(struct timer_list *t) · 27 unmodified lines
1158		1154
1159	/**	1155	/**
1160	* lpfc_rrq_timeout - The RRQ-timer timeout handler	1156	* lpfc_rrq_timeout - The RRQ-timer timeout handler
1161	* @ptr: unsigned long holds the pointer to lpfc hba data structure.	1157	* @t: timer context used to obtain the pointer to lpfc hba data structure.
1162	*	1158	*
1163	* This is the RRQ-timer timeout handler registered to the lpfc driver. When	1159	* This is the RRQ-timer timeout handler registered to the lpfc driver. When
1164	* this timer fires, a RRQ timeout event shall be posted to the lpfc driver	1160	* this timer fires, a RRQ timeout event shall be posted to the lpfc driver
@@ -1222,6 +1218,75 @@ lpfc_hb_mbox_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq) · 57 unmodified lines
1222	return;	1218	return;
1223	}	1219	}
1224		1220
		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
		1230	lpfc_idle_stat_delay_work(struct work_struct *work)
		1231	{
		1232	struct lpfc_hba *phba = container_of(to_delayed_work(work),
		1233	struct lpfc_hba,
		1234	idle_stat_delay_work);
		1235	struct lpfc_queue *cq;
		1236	struct lpfc_sli4_hdw_queue *hdwq;
		1237	struct lpfc_idle_stat *idle_stat;
		1238	u32 i, idle_percent;
		1239	u64 wall, wall_idle, diff_wall, diff_idle, busy_time;
		1240
		1241	if (phba->pport->load_flag & FC_UNLOADING)
		1242	return;
		1243
		1244	if (phba->link_state == LPFC_HBA_ERROR \|\|
		1245	phba->pport->fc_flag & FC_OFFLINE_MODE)
		1246	goto requeue;
		1247
		1248	for_each_present_cpu(i) {
		1249	hdwq = &phba->sli4_hba.hdwq[phba->sli4_hba.cpu_map[i].hdwq];
		1250	cq = hdwq->io_cq;
		1251
		1252	/* Skip if we've already handled this cq's primary CPU */
		1253	if (cq->chann != i)
		1254	continue;
		1255
		1256	idle_stat = &phba->sli4_hba.idle_stat[i];
		1257
		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	*/
		1264	wall_idle = get_cpu_idle_time(i, &wall, 1);
		1265	diff_idle = wall_idle - idle_stat->prev_idle;
		1266	diff_wall = wall - idle_stat->prev_wall;
		1267
		1268	if (diff_wall <= diff_idle)
		1269	busy_time = 0;
		1270	else
		1271	busy_time = diff_wall - diff_idle;
		1272
		1273	idle_percent = div64_u64(100 * busy_time, diff_wall);
		1274	idle_percent = 100 - idle_percent;
		1275
		1276	if (idle_percent < 15)
		1277	cq->poll_mode = LPFC_QUEUE_WORK;
		1278	else
		1279	cq->poll_mode = LPFC_IRQ_POLL;
		1280
		1281	idle_stat->prev_idle = wall_idle;
		1282	idle_stat->prev_wall = wall;
		1283	}
		1284
		1285	requeue:
		1286	schedule_delayed_work(&phba->idle_stat_delay_work,
		1287	msecs_to_jiffies(LPFC_IDLE_STAT_DELAY));
		1288	}
		1289
1225	static void	1290	static void
1226	lpfc_hb_eq_delay_work(struct work_struct *work)	1291	lpfc_hb_eq_delay_work(struct work_struct *work)
1227	{	1292	{
@@ -1538,11 +1603,11 @@ lpfc_handle_deferred_eratt(struct lpfc_hba *phba) · 310 unmodified lines
1538	return;	1603	return;
1539	}	1604	}
1540		1605
1541	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	1606	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1542	"0479 Deferred Adapter Hardware Error "	1607	"0479 Deferred Adapter Hardware Error "
1543	"Data: x%x x%x x%x\n",	1608	"Data: x%x x%x x%x\n",
1544	phba->work_hs,	1609	phba->work_hs, phba->work_status[0],
1545	phba->work_status[0], phba->work_status[1]);	1610	phba->work_status[1]);
1546		1611
1547	spin_lock_irq(&phba->hbalock);	1612	spin_lock_irq(&phba->hbalock);
1548	psli->sli_flag &= ~LPFC_SLI_ACTIVE;	1613	psli->sli_flag &= ~LPFC_SLI_ACTIVE;
@@ -1693,7 +1758,7 @@ lpfc_handle_eratt_s3(struct lpfc_hba *phba) · 144 unmodified lines
1693	temp_event_data.event_code = LPFC_CRIT_TEMP;	1758	temp_event_data.event_code = LPFC_CRIT_TEMP;
1694	temp_event_data.data = (uint32_t)temperature;	1759	temp_event_data.data = (uint32_t)temperature;
1695		1760
1696	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	1761	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1697	"0406 Adapter maximum temperature exceeded "	1762	"0406 Adapter maximum temperature exceeded "
1698	"(%ld), taking this port offline "	1763	"(%ld), taking this port offline "
1699	"Data: x%x x%x x%x\n",	1764	"Data: x%x x%x x%x\n",
@@ -1717,7 +1782,7 @@ lpfc_handle_eratt_s3(struct lpfc_hba *phba) · 17 unmodified lines
1717	* failure is a value other than FFER6. Do not call the offline	1782	* failure is a value other than FFER6. Do not call the offline
1718	* twice. This is the adapter hardware error path.	1783	* twice. This is the adapter hardware error path.
1719	*/	1784	*/
1720	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	1785	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1721	"0457 Adapter Hardware Error "	1786	"0457 Adapter Hardware Error "
1722	"Data: x%x x%x x%x\n",	1787	"Data: x%x x%x x%x\n",
1723	phba->work_hs,	1788	phba->work_hs,
@@ -1738,7 +1803,7 @@ lpfc_handle_eratt_s3(struct lpfc_hba *phba) · 14 unmodified lines
1738	* lpfc_sli4_port_sta_fn_reset - The SLI4 function reset due to port status reg	1803	* lpfc_sli4_port_sta_fn_reset - The SLI4 function reset due to port status reg
1739	* @phba: pointer to lpfc hba data structure.	1804	* @phba: pointer to lpfc hba data structure.
1740	* @mbx_action: flag for mailbox shutdown action.	1805	* @mbx_action: flag for mailbox shutdown action.
1741	*	1806	* @en_rn_msg: send reset/port recovery message.
1742	* This routine is invoked to perform an SLI4 port PCI function reset in	1807	* This routine is invoked to perform an SLI4 port PCI function reset in
1743	* response to port status register polling attention. It waits for port	1808	* response to port status register polling attention. It waits for port
1744	* status register (ERR, RDY, RN) bits before proceeding with function reset.	1809	* status register (ERR, RDY, RN) bits before proceeding with function reset.
@@ -1765,7 +1830,7 @@ lpfc_sli4_port_sta_fn_reset(struct lpfc_hba *phba, int mbx_action, · 20 unmodified lines
1765		1830
1766	/* need reset: attempt for port recovery */	1831	/* need reset: attempt for port recovery */
1767	if (en_rn_msg)	1832	if (en_rn_msg)
1768	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	1833	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1769	"2887 Reset Needed: Attempting Port "	1834	"2887 Reset Needed: Attempting Port "
1770	"Recovery...\n");	1835	"Recovery...\n");
1771	lpfc_offline_prep(phba, mbx_action);	1836	lpfc_offline_prep(phba, mbx_action);
@@ -1775,14 +1840,14 @@ lpfc_sli4_port_sta_fn_reset(struct lpfc_hba *phba, int mbx_action, · 3 unmodified lines
1775	lpfc_sli4_disable_intr(phba);	1840	lpfc_sli4_disable_intr(phba);
1776	rc = lpfc_sli_brdrestart(phba);	1841	rc = lpfc_sli_brdrestart(phba);
1777	if (rc) {	1842	if (rc) {
1778	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	1843	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1779	"6309 Failed to restart board\n");	1844	"6309 Failed to restart board\n");
1780	return rc;	1845	return rc;
1781	}	1846	}
1782	/* request and enable interrupt */	1847	/* request and enable interrupt */
1783	intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);	1848	intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);
1784	if (intr_mode == LPFC_INTR_ERROR) {	1849	if (intr_mode == LPFC_INTR_ERROR) {
1785	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	1850	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1786	"3175 Failed to enable interrupt\n");	1851	"3175 Failed to enable interrupt\n");
1787	return -EIO;	1852	return -EIO;
1788	}	1853	}
@@ -1821,7 +1886,7 @@ lpfc_handle_eratt_s4(struct lpfc_hba *phba) · 32 unmodified lines
1821	* we cannot communicate with the pci card anyway.	1886	* we cannot communicate with the pci card anyway.
1822	*/	1887	*/
1823	if (pci_channel_offline(phba->pcidev)) {	1888	if (pci_channel_offline(phba->pcidev)) {
1824	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	1889	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1825	"3166 pci channel is offline\n");	1890	"3166 pci channel is offline\n");
1826	lpfc_sli4_offline_eratt(phba);	1891	lpfc_sli4_offline_eratt(phba);
1827	return;	1892	return;
@@ -1844,7 +1909,7 @@ lpfc_handle_eratt_s4(struct lpfc_hba *phba) · 16 unmodified lines
1844	lpfc_sli4_offline_eratt(phba);	1909	lpfc_sli4_offline_eratt(phba);
1845	return;	1910	return;
1846	}	1911	}
1847	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	1912	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1848	"7623 Checking UE recoverable");	1913	"7623 Checking UE recoverable");
1849		1914
1850	for (i = 0; i < phba->sli4_hba.ue_to_sr / 1000; i++) {	1915	for (i = 0; i < phba->sli4_hba.ue_to_sr / 1000; i++) {
@@ -1861,7 +1926,7 @@ lpfc_handle_eratt_s4(struct lpfc_hba *phba) · 10 unmodified lines
1861	msleep(1000);	1926	msleep(1000);
1862	}	1927	}
1863		1928
1864	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	1929	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1865	"4827 smphr_port_status x%x : Waited %dSec",	1930	"4827 smphr_port_status x%x : Waited %dSec",
1866	smphr_port_status, i);	1931	smphr_port_status, i);
1867		1932
@@ -1879,14 +1944,14 @@ lpfc_handle_eratt_s4(struct lpfc_hba *phba) · 11 unmodified lines
1879	LPFC_MBX_NO_WAIT, en_rn_msg);	1944	LPFC_MBX_NO_WAIT, en_rn_msg);
1880	if (rc == 0)	1945	if (rc == 0)
1881	return;	1946	return;
1882	lpfc_printf_log(phba,	1947	lpfc_printf_log(phba, KERN_ERR,
1883	KERN_ERR, LOG_INIT,	1948	LOG_TRACE_EVENT,
1884	"4215 Failed to recover UE");	1949	"4215 Failed to recover UE");
1885	break;	1950	break;
1886	}	1951	}
1887	}	1952	}
1888	}	1953	}
1889	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	1954	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1890	"7624 Firmware not ready: Failing UE recovery,"	1955	"7624 Firmware not ready: Failing UE recovery,"
1891	" waited %dSec", i);	1956	" waited %dSec", i);
1892	phba->link_state = LPFC_HBA_ERROR;	1957	phba->link_state = LPFC_HBA_ERROR;
@@ -1899,7 +1964,7 @@ lpfc_handle_eratt_s4(struct lpfc_hba *phba) · 6 unmodified lines
1899	&portstat_reg.word0);	1964	&portstat_reg.word0);
1900	/* consider PCI bus read error as pci_channel_offline */	1965	/* consider PCI bus read error as pci_channel_offline */
1901	if (pci_rd_rc1 == -EIO) {	1966	if (pci_rd_rc1 == -EIO) {
1902	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	1967	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1903	"3151 PCI bus read access failure: x%x\n",	1968	"3151 PCI bus read access failure: x%x\n",
1904	readl(phba->sli4_hba.u.if_type2.STATUSregaddr));	1969	readl(phba->sli4_hba.u.if_type2.STATUSregaddr));
1905	lpfc_sli4_offline_eratt(phba);	1970	lpfc_sli4_offline_eratt(phba);
@@ -1908,10 +1973,10 @@ lpfc_handle_eratt_s4(struct lpfc_hba *phba) · 2 unmodified lines
1908	reg_err1 = readl(phba->sli4_hba.u.if_type2.ERR1regaddr);	1973	reg_err1 = readl(phba->sli4_hba.u.if_type2.ERR1regaddr);
1909	reg_err2 = readl(phba->sli4_hba.u.if_type2.ERR2regaddr);	1974	reg_err2 = readl(phba->sli4_hba.u.if_type2.ERR2regaddr);
1910	if (bf_get(lpfc_sliport_status_oti, &portstat_reg)) {	1975	if (bf_get(lpfc_sliport_status_oti, &portstat_reg)) {
1911	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	1976	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1912	"2889 Port Overtemperature event, "	1977	"2889 Port Overtemperature event, "
1913	"taking port offline Data: x%x x%x\n",	1978	"taking port offline Data: x%x x%x\n",
1914	reg_err1, reg_err2);	1979	reg_err1, reg_err2);
1915		1980
1916	phba->sfp_alarm \|= LPFC_TRANSGRESSION_HIGH_TEMPERATURE;	1981	phba->sfp_alarm \|= LPFC_TRANSGRESSION_HIGH_TEMPERATURE;
1917	temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;	1982	temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
@@ -1933,17 +1998,17 @@ lpfc_handle_eratt_s4(struct lpfc_hba *phba) · 15 unmodified lines
1933	}	1998	}
1934	if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&	1999	if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&
1935	reg_err2 == SLIPORT_ERR2_REG_FW_RESTART) {	2000	reg_err2 == SLIPORT_ERR2_REG_FW_RESTART) {
1936	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	2001	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1937	"3143 Port Down: Firmware Update "	2002	"3143 Port Down: Firmware Update "
1938	"Detected\n");	2003	"Detected\n");
1939	en_rn_msg = false;	2004	en_rn_msg = false;
1940	} else if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&	2005	} else if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&
1941	reg_err2 == SLIPORT_ERR2_REG_FORCED_DUMP)	2006	reg_err2 == SLIPORT_ERR2_REG_FORCED_DUMP)
1942	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	2007	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1943	"3144 Port Down: Debug Dump\n");	2008	"3144 Port Down: Debug Dump\n");
1944	else if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&	2009	else if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&
1945	reg_err2 == SLIPORT_ERR2_REG_FUNC_PROVISON)	2010	reg_err2 == SLIPORT_ERR2_REG_FUNC_PROVISON)
1946	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	2011	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1947	"3145 Port Down: Provisioning\n");	2012	"3145 Port Down: Provisioning\n");
1948		2013
1949	/* If resets are disabled then leave the HBA alone and return */	2014	/* If resets are disabled then leave the HBA alone and return */
@@ -1962,7 +2027,7 @@ lpfc_handle_eratt_s4(struct lpfc_hba *phba) · 12 unmodified lines
1962	break;	2027	break;
1963	}	2028	}
1964	/* fall through for not able to recover */	2029	/* fall through for not able to recover */
1965	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	2030	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1966	"3152 Unrecoverable error\n");	2031	"3152 Unrecoverable error\n");
1967	phba->link_state = LPFC_HBA_ERROR;	2032	phba->link_state = LPFC_HBA_ERROR;
1968	break;	2033	break;
@@ -2080,8 +2145,8 @@ lpfc_handle_latt_err_exit: · 111 unmodified lines
2080	lpfc_linkdown(phba);	2145	lpfc_linkdown(phba);
2081	phba->link_state = LPFC_HBA_ERROR;	2146	phba->link_state = LPFC_HBA_ERROR;
2082		2147
2083	lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,	2148	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
2084	"0300 LATT: Cannot issue READ_LA: Data:%d\n", rc);	2149	"0300 LATT: Cannot issue READ_LA: Data:%d\n", rc);
2085		2150
2086	return;	2151	return;
2087	}	2152	}
@@ -2830,12 +2895,13 @@ lpfc_cleanup(struct lpfc_vport *vport) · 742 unmodified lines
2830	*/	2895	*/
2831	while (!list_empty(&vport->fc_nodes)) {	2896	while (!list_empty(&vport->fc_nodes)) {
2832	if (i++ > 3000) {	2897	if (i++ > 3000) {
2833	lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,	2898	lpfc_printf_vlog(vport, KERN_ERR,
		2899	LOG_TRACE_EVENT,
2834	"0233 Nodelist not empty\n");	2900	"0233 Nodelist not empty\n");
2835	list_for_each_entry_safe(ndlp, next_ndlp,	2901	list_for_each_entry_safe(ndlp, next_ndlp,
2836	&vport->fc_nodes, nlp_listp) {	2902	&vport->fc_nodes, nlp_listp) {
2837	lpfc_printf_vlog(ndlp->vport, KERN_ERR,	2903	lpfc_printf_vlog(ndlp->vport, KERN_ERR,
2838	LOG_NODE,	2904	LOG_TRACE_EVENT,
2839	"0282 did:x%x ndlp:x%px "	2905	"0282 did:x%x ndlp:x%px "
2840	"usgmap:x%x refcnt:%d\n",	2906	"usgmap:x%x refcnt:%d\n",
2841	ndlp->nlp_DID, (void *)ndlp,	2907	ndlp->nlp_DID, (void *)ndlp,
@@ -2922,6 +2988,7 @@ lpfc_stop_hba_timers(struct lpfc_hba *phba) · 80 unmodified lines
2922	if (phba->pport)	2988	if (phba->pport)
2923	lpfc_stop_vport_timers(phba->pport);	2989	lpfc_stop_vport_timers(phba->pport);
2924	cancel_delayed_work_sync(&phba->eq_delay_work);	2990	cancel_delayed_work_sync(&phba->eq_delay_work);
		2991	cancel_delayed_work_sync(&phba->idle_stat_delay_work);
2925	del_timer_sync(&phba->sli.mbox_tmo);	2992	del_timer_sync(&phba->sli.mbox_tmo);
2926	del_timer_sync(&phba->fabric_block_timer);	2993	del_timer_sync(&phba->fabric_block_timer);
2927	del_timer_sync(&phba->eratt_poll);	2994	del_timer_sync(&phba->eratt_poll);
@@ -2942,7 +3009,7 @@ lpfc_stop_hba_timers(struct lpfc_hba *phba) · 14 unmodified lines
2942	lpfc_sli4_stop_fcf_redisc_wait_timer(phba);	3009	lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
2943	break;	3010	break;
2944	default:	3011	default:
2945	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	3012	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
2946	"0297 Invalid device group (x%x)\n",	3013	"0297 Invalid device group (x%x)\n",
2947	phba->pci_dev_grp);	3014	phba->pci_dev_grp);
2948	break;	3015	break;
@@ -2953,6 +3020,7 @@ lpfc_stop_hba_timers(struct lpfc_hba *phba) · 4 unmodified lines
2953	/**	3020	/**
2954	* lpfc_block_mgmt_io - Mark a HBA's management interface as blocked	3021	* lpfc_block_mgmt_io - Mark a HBA's management interface as blocked
2955	* @phba: pointer to lpfc hba data structure.	3022	* @phba: pointer to lpfc hba data structure.
		3023	* @mbx_action: flag for mailbox no wait action.
2956	*	3024	*
2957	* This routine marks a HBA's management interface as blocked. Once the HBA's	3025	* This routine marks a HBA's management interface as blocked. Once the HBA's
2958	* management interface is marked as blocked, all the user space access to	3026	* management interface is marked as blocked, all the user space access to
@@ -2989,10 +3057,10 @@ lpfc_block_mgmt_io(struct lpfc_hba *phba, int mbx_action) · 30 unmodified lines
2989	/* Check active mailbox complete status every 2ms */	3057	/* Check active mailbox complete status every 2ms */
2990	msleep(2);	3058	msleep(2);
2991	if (time_after(jiffies, timeout)) {	3059	if (time_after(jiffies, timeout)) {
2992	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	3060	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
2993	"2813 Mgmt IO is Blocked %x "	3061	"2813 Mgmt IO is Blocked %x "
2994	"- mbox cmd %x still active\n",	3062	"- mbox cmd %x still active\n",
2995	phba->sli.sli_flag, actcmd);	3063	phba->sli.sli_flag, actcmd);
2996	break;	3064	break;
2997	}	3065	}
2998	}	3066	}
@@ -3337,7 +3405,7 @@ lpfc_online(struct lpfc_hba *phba) · 338 unmodified lines
3337	!phba->nvmet_support) {	3405	!phba->nvmet_support) {
3338	error = lpfc_nvme_create_localport(phba->pport);	3406	error = lpfc_nvme_create_localport(phba->pport);
3339	if (error)	3407	if (error)
3340	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	3408	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
3341	"6132 NVME restore reg failed "	3409	"6132 NVME restore reg failed "
3342	"on nvmei error x%x\n", error);	3410	"on nvmei error x%x\n", error);
3343	}	3411	}
@@ -3403,6 +3471,7 @@ lpfc_unblock_mgmt_io(struct lpfc_hba * phba) · 59 unmodified lines
3403	/**	3471	/**
3404	* lpfc_offline_prep - Prepare a HBA to be brought offline	3472	* lpfc_offline_prep - Prepare a HBA to be brought offline
3405	* @phba: pointer to lpfc hba data structure.	3473	* @phba: pointer to lpfc hba data structure.
		3474	* @mbx_action: flag for mailbox shutdown action.
3406	*	3475	*
3407	* This routine is invoked to prepare a HBA to be brought offline. It performs	3476	* This routine is invoked to prepare a HBA to be brought offline. It performs
3408	* unregistration login to all the nodes on all vports and flushes the mailbox	3477	* unregistration login to all the nodes on all vports and flushes the mailbox
@@ -3677,7 +3746,8 @@ lpfc_sli4_els_sgl_update(struct lpfc_hba *phba) · 268 unmodified lines
3677	sglq_entry = kzalloc(sizeof(struct lpfc_sglq),	3746	sglq_entry = kzalloc(sizeof(struct lpfc_sglq),
3678	GFP_KERNEL);	3747	GFP_KERNEL);
3679	if (sglq_entry == NULL) {	3748	if (sglq_entry == NULL) {
3680	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	3749	lpfc_printf_log(phba, KERN_ERR,
		3750	LOG_TRACE_EVENT,
3681	"2562 Failure to allocate an "	3751	"2562 Failure to allocate an "
3682	"ELS sgl entry:%d\n", i);	3752	"ELS sgl entry:%d\n", i);
3683	rc = -ENOMEM;	3753	rc = -ENOMEM;
@@ -3688,7 +3758,8 @@ lpfc_sli4_els_sgl_update(struct lpfc_hba *phba) · 4 unmodified lines
3688	&sglq_entry->phys);	3758	&sglq_entry->phys);
3689	if (sglq_entry->virt == NULL) {	3759	if (sglq_entry->virt == NULL) {
3690	kfree(sglq_entry);	3760	kfree(sglq_entry);
3691	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	3761	lpfc_printf_log(phba, KERN_ERR,
		3762	LOG_TRACE_EVENT,
3692	"2563 Failure to allocate an "	3763	"2563 Failure to allocate an "
3693	"ELS mbuf:%d\n", i);	3764	"ELS mbuf:%d\n", i);
3694	rc = -ENOMEM;	3765	rc = -ENOMEM;
@@ -3743,7 +3814,8 @@ lpfc_sli4_els_sgl_update(struct lpfc_hba *phba) · 48 unmodified lines
3743	&phba->sli4_hba.lpfc_els_sgl_list, list) {	3814	&phba->sli4_hba.lpfc_els_sgl_list, list) {
3744	lxri = lpfc_sli4_next_xritag(phba);	3815	lxri = lpfc_sli4_next_xritag(phba);
3745	if (lxri == NO_XRI) {	3816	if (lxri == NO_XRI) {
3746	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	3817	lpfc_printf_log(phba, KERN_ERR,
		3818	LOG_TRACE_EVENT,
3747	"2400 Failed to allocate xri for "	3819	"2400 Failed to allocate xri for "
3748	"ELS sgl\n");	3820	"ELS sgl\n");
3749	rc = -ENOMEM;	3821	rc = -ENOMEM;
@@ -3798,7 +3870,8 @@ lpfc_sli4_nvmet_sgl_update(struct lpfc_hba *phba) · 48 unmodified lines
3798	sglq_entry = kzalloc(sizeof(struct lpfc_sglq),	3870	sglq_entry = kzalloc(sizeof(struct lpfc_sglq),
3799	GFP_KERNEL);	3871	GFP_KERNEL);
3800	if (sglq_entry == NULL) {	3872	if (sglq_entry == NULL) {
3801	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	3873	lpfc_printf_log(phba, KERN_ERR,
		3874	LOG_TRACE_EVENT,
3802	"6303 Failure to allocate an "	3875	"6303 Failure to allocate an "
3803	"NVMET sgl entry:%d\n", i);	3876	"NVMET sgl entry:%d\n", i);
3804	rc = -ENOMEM;	3877	rc = -ENOMEM;
@@ -3809,7 +3882,8 @@ lpfc_sli4_nvmet_sgl_update(struct lpfc_hba *phba) · 4 unmodified lines
3809	&sglq_entry->phys);	3882	&sglq_entry->phys);
3810	if (sglq_entry->virt == NULL) {	3883	if (sglq_entry->virt == NULL) {
3811	kfree(sglq_entry);	3884	kfree(sglq_entry);
3812	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	3885	lpfc_printf_log(phba, KERN_ERR,
		3886	LOG_TRACE_EVENT,
3813	"6304 Failure to allocate an "	3887	"6304 Failure to allocate an "
3814	"NVMET buf:%d\n", i);	3888	"NVMET buf:%d\n", i);
3815	rc = -ENOMEM;	3889	rc = -ENOMEM;
@@ -3865,7 +3939,8 @@ lpfc_sli4_nvmet_sgl_update(struct lpfc_hba *phba) · 49 unmodified lines
3865	&phba->sli4_hba.lpfc_nvmet_sgl_list, list) {	3939	&phba->sli4_hba.lpfc_nvmet_sgl_list, list) {
3866	lxri = lpfc_sli4_next_xritag(phba);	3940	lxri = lpfc_sli4_next_xritag(phba);
3867	if (lxri == NO_XRI) {	3941	if (lxri == NO_XRI) {
3868	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	3942	lpfc_printf_log(phba, KERN_ERR,
		3943	LOG_TRACE_EVENT,
3869	"6307 Failed to allocate xri for "	3944	"6307 Failed to allocate xri for "
3870	"NVMET sgl\n");	3945	"NVMET sgl\n");
3871	rc = -ENOMEM;	3946	rc = -ENOMEM;
@@ -4039,7 +4114,8 @@ lpfc_sli4_io_sgl_update(struct lpfc_hba *phba) · 167 unmodified lines
4039	&io_sgl_list, list) {	4114	&io_sgl_list, list) {
4040	lxri = lpfc_sli4_next_xritag(phba);	4115	lxri = lpfc_sli4_next_xritag(phba);
4041	if (lxri == NO_XRI) {	4116	if (lxri == NO_XRI) {
4042	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	4117	lpfc_printf_log(phba, KERN_ERR,
		4118	LOG_TRACE_EVENT,
4043	"6075 Failed to allocate xri for "	4119	"6075 Failed to allocate xri for "
4044	"nvme buffer\n");	4120	"nvme buffer\n");
4045	rc = -ENOMEM;	4121	rc = -ENOMEM;
@@ -4058,8 +4134,8 @@ out_free_mem: · 12 unmodified lines
4058		4134
4059	/**	4135	/**
4060	* lpfc_new_io_buf - IO buffer allocator for HBA with SLI4 IF spec	4136	* lpfc_new_io_buf - IO buffer allocator for HBA with SLI4 IF spec
4061	* @vport: The virtual port for which this call being executed.	4137	* @phba: Pointer to lpfc hba data structure.
4062	* @num_to_allocate: The requested number of buffers to allocate.	4138	* @num_to_alloc: The requested number of buffers to allocate.
4063	*	4139	*
4064	* This routine allocates nvme buffers for device with SLI-4 interface spec,	4140	* This routine allocates nvme buffers for device with SLI-4 interface spec,
4065	* the nvme buffer contains all the necessary information needed to initiate	4141	* the nvme buffer contains all the necessary information needed to initiate
@@ -4109,7 +4185,8 @@ lpfc_new_io_buf(struct lpfc_hba *phba, int num_to_alloc) · 43 unmodified lines
4109	if ((phba->sli3_options & LPFC_SLI3_BG_ENABLED) &&	4185	if ((phba->sli3_options & LPFC_SLI3_BG_ENABLED) &&
4110	(((unsigned long)(lpfc_ncmd->data) &	4186	(((unsigned long)(lpfc_ncmd->data) &
4111	(unsigned long)(SLI4_PAGE_SIZE - 1)) != 0)) {	4187	(unsigned long)(SLI4_PAGE_SIZE - 1)) != 0)) {
4112	lpfc_printf_log(phba, KERN_ERR, LOG_FCP,	4188	lpfc_printf_log(phba, KERN_ERR,
		4189	LOG_TRACE_EVENT,
4113	"3369 Memory alignment err: "	4190	"3369 Memory alignment err: "
4114	"addr=%lx\n",	4191	"addr=%lx\n",
4115	(unsigned long)lpfc_ncmd->data);	4192	(unsigned long)lpfc_ncmd->data);
@@ -4138,7 +4215,7 @@ lpfc_new_io_buf(struct lpfc_hba *phba, int num_to_alloc) · 22 unmodified lines
4138	dma_pool_free(phba->lpfc_sg_dma_buf_pool,	4215	dma_pool_free(phba->lpfc_sg_dma_buf_pool,
4139	lpfc_ncmd->data, lpfc_ncmd->dma_handle);	4216	lpfc_ncmd->data, lpfc_ncmd->dma_handle);
4140	kfree(lpfc_ncmd);	4217	kfree(lpfc_ncmd);
4141	lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,	4218	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
4142	"6121 Failed to allocate IOTAG for"	4219	"6121 Failed to allocate IOTAG for"
4143	" XRI:0x%x\n", lxri);	4220	" XRI:0x%x\n", lxri);
4144	lpfc_sli4_free_xri(phba, lxri);	4221	lpfc_sli4_free_xri(phba, lxri);
@@ -4189,7 +4266,7 @@ lpfc_get_wwpn(struct lpfc_hba *phba) · 44 unmodified lines
4189	lpfc_read_nv(phba, mboxq);	4266	lpfc_read_nv(phba, mboxq);
4190	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);	4267	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
4191	if (rc != MBX_SUCCESS) {	4268	if (rc != MBX_SUCCESS) {
4192	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	4269	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
4193	"6019 Mailbox failed , mbxCmd x%x "	4270	"6019 Mailbox failed , mbxCmd x%x "
4194	"READ_NV, mbxStatus x%x\n",	4271	"READ_NV, mbxStatus x%x\n",
4195	bf_get(lpfc_mqe_command, &mboxq->u.mqe),	4272	bf_get(lpfc_mqe_command, &mboxq->u.mqe),
@@ -4249,7 +4326,8 @@ lpfc_create_port(struct lpfc_hba phba, int instance, struct device dev) · 53 unmodified lines
4249		4326
4250	for (i = 0; i < lpfc_no_hba_reset_cnt; i++) {	4327	for (i = 0; i < lpfc_no_hba_reset_cnt; i++) {
4251	if (wwn == lpfc_no_hba_reset[i]) {	4328	if (wwn == lpfc_no_hba_reset[i]) {
4252	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	4329	lpfc_printf_log(phba, KERN_ERR,
		4330	LOG_TRACE_EVENT,
4253	"6020 Setting use_no_reset port=%llx\n",	4331	"6020 Setting use_no_reset port=%llx\n",
4254	wwn);	4332	wwn);
4255	use_no_reset_hba = true;	4333	use_no_reset_hba = true;
@@ -4646,7 +4724,7 @@ lpfc_fcf_redisc_wait_start_timer(struct lpfc_hba *phba) · 390 unmodified lines
4646		4724
4647	/**	4725	/**
4648	* lpfc_sli4_fcf_redisc_wait_tmo - FCF table rediscover wait timeout	4726	* lpfc_sli4_fcf_redisc_wait_tmo - FCF table rediscover wait timeout
4649	* @ptr: Map to lpfc_hba data structure pointer.	4727	* @t: Timer context used to obtain the pointer to lpfc hba data structure.
4650	*	4728	*
4651	* This routine is invoked when waiting for FCF table rediscover has been	4729	* This routine is invoked when waiting for FCF table rediscover has been
4652	* timed out. If new FCF record(s) has (have) been discovered during the	4730	* timed out. If new FCF record(s) has (have) been discovered during the
@@ -4694,7 +4772,7 @@ lpfc_sli4_parse_latt_fault(struct lpfc_hba *phba, · 41 unmodified lines
4694	case LPFC_ASYNC_LINK_FAULT_LR_LRR:	4772	case LPFC_ASYNC_LINK_FAULT_LR_LRR:
4695	break;	4773	break;
4696	default:	4774	default:
4697	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	4775	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
4698	"0398 Unknown link fault code: x%x\n",	4776	"0398 Unknown link fault code: x%x\n",
4699	bf_get(lpfc_acqe_link_fault, acqe_link));	4777	bf_get(lpfc_acqe_link_fault, acqe_link));
4700	break;	4778	break;
@@ -4730,7 +4808,7 @@ lpfc_sli4_parse_latt_type(struct lpfc_hba *phba, · 29 unmodified lines
4730	att_type = LPFC_ATT_LINK_UP;	4808	att_type = LPFC_ATT_LINK_UP;
4731	break;	4809	break;
4732	default:	4810	default:
4733	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	4811	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
4734	"0399 Invalid link attention type: x%x\n",	4812	"0399 Invalid link attention type: x%x\n",
4735	bf_get(lpfc_acqe_link_status, acqe_link));	4813	bf_get(lpfc_acqe_link_status, acqe_link));
4736	att_type = LPFC_ATT_RESERVED;	4814	att_type = LPFC_ATT_RESERVED;
@@ -4902,19 +4980,19 @@ lpfc_sli4_async_link_evt(struct lpfc_hba *phba, · 165 unmodified lines
4902	phba->fcoe_eventtag = acqe_link->event_tag;	4980	phba->fcoe_eventtag = acqe_link->event_tag;
4903	pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);	4981	pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4904	if (!pmb) {	4982	if (!pmb) {
4905	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	4983	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
4906	"0395 The mboxq allocation failed\n");	4984	"0395 The mboxq allocation failed\n");
4907	return;	4985	return;
4908	}	4986	}
4909	mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);	4987	mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
4910	if (!mp) {	4988	if (!mp) {
4911	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	4989	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
4912	"0396 The lpfc_dmabuf allocation failed\n");	4990	"0396 The lpfc_dmabuf allocation failed\n");
4913	goto out_free_pmb;	4991	goto out_free_pmb;
4914	}	4992	}
4915	mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);	4993	mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
4916	if (!mp->virt) {	4994	if (!mp->virt) {
4917	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	4995	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
4918	"0397 The mbuf allocation failed\n");	4996	"0397 The mbuf allocation failed\n");
4919	goto out_free_dmabuf;	4997	goto out_free_dmabuf;
4920	}	4998	}
@@ -5013,7 +5091,6 @@ out_free_pmb: · 92 unmodified lines
5013	* lpfc_async_link_speed_to_read_top - Parse async evt link speed code to read	5091	* lpfc_async_link_speed_to_read_top - Parse async evt link speed code to read
5014	* topology.	5092	* topology.
5015	* @phba: pointer to lpfc hba data structure.	5093	* @phba: pointer to lpfc hba data structure.
5016	* @evt_code: asynchronous event code.
5017	* @speed_code: asynchronous event link speed code.	5094	* @speed_code: asynchronous event link speed code.
5018	*	5095	*
5019	* This routine is to parse the giving SLI4 async event link speed code into	5096	* This routine is to parse the giving SLI4 async event link speed code into
@@ -5115,7 +5192,7 @@ lpfc_update_trunk_link_status(struct lpfc_hba *phba, · 95 unmodified lines
5115	phba->trunk_link.link3.fault = port_fault & 0x8 ? err : 0;	5192	phba->trunk_link.link3.fault = port_fault & 0x8 ? err : 0;
5116	}	5193	}
5117		5194
5118	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	5195	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
5119	"2910 Async FC Trunking Event - Speed:%d\n"	5196	"2910 Async FC Trunking Event - Speed:%d\n"
5120	"\tLogical speed:%d "	5197	"\tLogical speed:%d "
5121	"port0: %s port1: %s port2: %s port3: %s\n",	5198	"port0: %s port1: %s port2: %s port3: %s\n",
@@ -5125,7 +5202,7 @@ lpfc_update_trunk_link_status(struct lpfc_hba *phba, · 3 unmodified lines
5125	trunk_link_status(2), trunk_link_status(3));	5202	trunk_link_status(2), trunk_link_status(3));
5126		5203
5127	if (port_fault)	5204	if (port_fault)
5128	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	5205	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
5129	"3202 trunk error:0x%x (%s) seen on port0:%s "	5206	"3202 trunk error:0x%x (%s) seen on port0:%s "
5130	/*	5207	/*
5131	* SLI-4: We have only 0xA error codes	5208	* SLI-4: We have only 0xA error codes
@@ -5159,7 +5236,7 @@ lpfc_sli4_async_fc_evt(struct lpfc_hba phba, struct lpfc_acqe_fc_la acqe_fc) · 27 unmodified lines
5159		5236
5160	if (bf_get(lpfc_trailer_type, acqe_fc) !=	5237	if (bf_get(lpfc_trailer_type, acqe_fc) !=
5161	LPFC_FC_LA_EVENT_TYPE_FC_LINK) {	5238	LPFC_FC_LA_EVENT_TYPE_FC_LINK) {
5162	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	5239	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
5163	"2895 Non FC link Event detected.(%d)\n",	5240	"2895 Non FC link Event detected.(%d)\n",
5164	bf_get(lpfc_trailer_type, acqe_fc));	5241	bf_get(lpfc_trailer_type, acqe_fc));
5165	return;	5242	return;
@@ -5207,19 +5284,19 @@ lpfc_sli4_async_fc_evt(struct lpfc_hba phba, struct lpfc_acqe_fc_la acqe_fc) · 41 unmodified lines
5207	phba->sli4_hba.link_state.fault);	5284	phba->sli4_hba.link_state.fault);
5208	pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);	5285	pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
5209	if (!pmb) {	5286	if (!pmb) {
5210	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	5287	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
5211	"2897 The mboxq allocation failed\n");	5288	"2897 The mboxq allocation failed\n");
5212	return;	5289	return;
5213	}	5290	}
5214	mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);	5291	mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
5215	if (!mp) {	5292	if (!mp) {
5216	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	5293	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
5217	"2898 The lpfc_dmabuf allocation failed\n");	5294	"2898 The lpfc_dmabuf allocation failed\n");
5218	goto out_free_pmb;	5295	goto out_free_pmb;
5219	}	5296	}
5220	mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);	5297	mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
5221	if (!mp->virt) {	5298	if (!mp->virt) {
5222	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	5299	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
5223	"2899 The mbuf allocation failed\n");	5300	"2899 The mbuf allocation failed\n");
5224	goto out_free_dmabuf;	5301	goto out_free_dmabuf;
5225	}	5302	}
@@ -5291,7 +5368,7 @@ out_free_pmb: · 65 unmodified lines
5291	/**	5368	/**
5292	* lpfc_sli4_async_sli_evt - Process the asynchronous SLI link event	5369	* lpfc_sli4_async_sli_evt - Process the asynchronous SLI link event
5293	* @phba: pointer to lpfc hba data structure.	5370	* @phba: pointer to lpfc hba data structure.
5294	* @acqe_fc: pointer to the async SLI completion queue entry.	5371	* @acqe_sli: pointer to the async SLI completion queue entry.
5295	*	5372	*
5296	* This routine is to handle the SLI4 asynchronous SLI events.	5373	* This routine is to handle the SLI4 asynchronous SLI events.
5297	**/	5374	**/
@@ -5386,7 +5463,7 @@ lpfc_sli4_async_sli_evt(struct lpfc_hba phba, struct lpfc_acqe_sli acqe_sli) · 88 unmodified lines
5386	&misconfigured->theEvent);	5463	&misconfigured->theEvent);
5387	break;	5464	break;
5388	default:	5465	default:
5389	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	5466	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
5390	"3296 "	5467	"3296 "
5391	"LPFC_SLI_EVENT_TYPE_MISCONFIGURED "	5468	"LPFC_SLI_EVENT_TYPE_MISCONFIGURED "
5392	"event: Invalid link %d",	5469	"event: Invalid link %d",
@@ -5438,7 +5515,8 @@ lpfc_sli4_async_sli_evt(struct lpfc_hba phba, struct lpfc_acqe_sli acqe_sli) · 45 unmodified lines
5438	rc = lpfc_sli4_read_config(phba);	5515	rc = lpfc_sli4_read_config(phba);
5439	if (rc) {	5516	if (rc) {
5440	phba->lmt = 0;	5517	phba->lmt = 0;
5441	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	5518	lpfc_printf_log(phba, KERN_ERR,
		5519	LOG_TRACE_EVENT,
5442	"3194 Unable to retrieve supported "	5520	"3194 Unable to retrieve supported "
5443	"speeds, rc = 0x%x\n", rc);	5521	"speeds, rc = 0x%x\n", rc);
5444	}	5522	}
@@ -5546,7 +5624,7 @@ lpfc_sli4_perform_vport_cvl(struct lpfc_vport *vport) · 101 unmodified lines
5546		5624
5547	/**	5625	/**
5548	* lpfc_sli4_perform_all_vport_cvl - Perform clear virtual link on all vports	5626	* lpfc_sli4_perform_all_vport_cvl - Perform clear virtual link on all vports
5549	* @vport: pointer to lpfc hba data structure.	5627	* @phba: pointer to lpfc hba data structure.
5550	*	5628	*
5551	* This routine is to perform Clear Virtual Link (CVL) on all vports in	5629	* This routine is to perform Clear Virtual Link (CVL) on all vports in
5552	* response to a FCF dead event.	5630	* response to a FCF dead event.
@@ -5567,7 +5645,7 @@ lpfc_sli4_perform_all_vport_cvl(struct lpfc_hba *phba) · 14 unmodified lines
5567	/**	5645	/**
5568	* lpfc_sli4_async_fip_evt - Process the asynchronous FCoE FIP event	5646	* lpfc_sli4_async_fip_evt - Process the asynchronous FCoE FIP event
5569	* @phba: pointer to lpfc hba data structure.	5647	* @phba: pointer to lpfc hba data structure.
5570	* @acqe_link: pointer to the async fcoe completion queue entry.	5648	* @acqe_fip: pointer to the async fcoe completion queue entry.
5571	*	5649	*
5572	* This routine is to handle the SLI4 asynchronous fcoe event.	5650	* This routine is to handle the SLI4 asynchronous fcoe event.
5573	**/	5651	**/
@@ -5590,8 +5668,7 @@ lpfc_sli4_async_fip_evt(struct lpfc_hba *phba, · 16 unmodified lines
5590	case LPFC_FIP_EVENT_TYPE_NEW_FCF:	5668	case LPFC_FIP_EVENT_TYPE_NEW_FCF:
5591	case LPFC_FIP_EVENT_TYPE_FCF_PARAM_MOD:	5669	case LPFC_FIP_EVENT_TYPE_FCF_PARAM_MOD:
5592	if (event_type == LPFC_FIP_EVENT_TYPE_NEW_FCF)	5670	if (event_type == LPFC_FIP_EVENT_TYPE_NEW_FCF)
5593	lpfc_printf_log(phba, KERN_ERR, LOG_FIP \|	5671	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
5594	LOG_DISCOVERY,
5595	"2546 New FCF event, evt_tag:x%x, "	5672	"2546 New FCF event, evt_tag:x%x, "
5596	"index:x%x\n",	5673	"index:x%x\n",
5597	acqe_fip->event_tag,	5674	acqe_fip->event_tag,
@@ -5644,23 +5721,24 @@ lpfc_sli4_async_fip_evt(struct lpfc_hba *phba, · 46 unmodified lines
5644	rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba,	5721	rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba,
5645	LPFC_FCOE_FCF_GET_FIRST);	5722	LPFC_FCOE_FCF_GET_FIRST);
5646	if (rc)	5723	if (rc)
5647	lpfc_printf_log(phba, KERN_ERR, LOG_FIP \| LOG_DISCOVERY,	5724	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
5648	"2547 Issue FCF scan read FCF mailbox "	5725	"2547 Issue FCF scan read FCF mailbox "
5649	"command failed (x%x)\n", rc);	5726	"command failed (x%x)\n", rc);
5650	break;	5727	break;
5651		5728
5652	case LPFC_FIP_EVENT_TYPE_FCF_TABLE_FULL:	5729	case LPFC_FIP_EVENT_TYPE_FCF_TABLE_FULL:
5653	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	5730	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
5654	"2548 FCF Table full count 0x%x tag 0x%x\n",	5731	"2548 FCF Table full count 0x%x tag 0x%x\n",
5655	bf_get(lpfc_acqe_fip_fcf_count, acqe_fip),	5732	bf_get(lpfc_acqe_fip_fcf_count, acqe_fip),
5656	acqe_fip->event_tag);	5733	acqe_fip->event_tag);
5657	break;	5734	break;
5658		5735
5659	case LPFC_FIP_EVENT_TYPE_FCF_DEAD:	5736	case LPFC_FIP_EVENT_TYPE_FCF_DEAD:
5660	phba->fcoe_cvl_eventtag = acqe_fip->event_tag;	5737	phba->fcoe_cvl_eventtag = acqe_fip->event_tag;
5661	lpfc_printf_log(phba, KERN_ERR, LOG_FIP \| LOG_DISCOVERY,	5738	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
5662	"2549 FCF (x%x) disconnected from network, "	5739	"2549 FCF (x%x) disconnected from network, "
5663	"tag:x%x\n", acqe_fip->index, acqe_fip->event_tag);	5740	"tag:x%x\n", acqe_fip->index,
		5741	acqe_fip->event_tag);
5664	/*	5742	/*
5665	* If we are in the middle of FCF failover process, clear	5743	* If we are in the middle of FCF failover process, clear
5666	* the corresponding FCF bit in the roundrobin bitmap.	5744	* the corresponding FCF bit in the roundrobin bitmap.
@@ -5697,7 +5775,7 @@ lpfc_sli4_async_fip_evt(struct lpfc_hba *phba, · 30 unmodified lines
5697	rc = lpfc_sli4_redisc_fcf_table(phba);	5775	rc = lpfc_sli4_redisc_fcf_table(phba);
5698	if (rc) {	5776	if (rc) {
5699	lpfc_printf_log(phba, KERN_ERR, LOG_FIP \|	5777	lpfc_printf_log(phba, KERN_ERR, LOG_FIP \|
5700	LOG_DISCOVERY,	5778	LOG_TRACE_EVENT,
5701	"2772 Issue FCF rediscover mailbox "	5779	"2772 Issue FCF rediscover mailbox "
5702	"command failed, fail through to FCF "	5780	"command failed, fail through to FCF "
5703	"dead event\n");	5781	"dead event\n");
@@ -5721,7 +5799,8 @@ lpfc_sli4_async_fip_evt(struct lpfc_hba *phba, · 17 unmodified lines
5721	break;	5799	break;
5722	case LPFC_FIP_EVENT_TYPE_CVL:	5800	case LPFC_FIP_EVENT_TYPE_CVL:
5723	phba->fcoe_cvl_eventtag = acqe_fip->event_tag;	5801	phba->fcoe_cvl_eventtag = acqe_fip->event_tag;
5724	lpfc_printf_log(phba, KERN_ERR, LOG_FIP \| LOG_DISCOVERY,	5802	lpfc_printf_log(phba, KERN_ERR,
		5803	LOG_TRACE_EVENT,
5725	"2718 Clear Virtual Link Received for VPI 0x%x"	5804	"2718 Clear Virtual Link Received for VPI 0x%x"
5726	" tag 0x%x\n", acqe_fip->index, acqe_fip->event_tag);	5805	" tag 0x%x\n", acqe_fip->index, acqe_fip->event_tag);
5727		5806
@@ -5788,7 +5867,7 @@ lpfc_sli4_async_fip_evt(struct lpfc_hba *phba, · 60 unmodified lines
5788	rc = lpfc_sli4_redisc_fcf_table(phba);	5867	rc = lpfc_sli4_redisc_fcf_table(phba);
5789	if (rc) {	5868	if (rc) {
5790	lpfc_printf_log(phba, KERN_ERR, LOG_FIP \|	5869	lpfc_printf_log(phba, KERN_ERR, LOG_FIP \|
5791	LOG_DISCOVERY,	5870	LOG_TRACE_EVENT,
5792	"2774 Issue FCF rediscover "	5871	"2774 Issue FCF rediscover "
5793	"mailbox command failed, "	5872	"mailbox command failed, "
5794	"through to CVL event\n");	5873	"through to CVL event\n");
@@ -5809,9 +5888,9 @@ lpfc_sli4_async_fip_evt(struct lpfc_hba *phba, · 14 unmodified lines
5809	}	5888	}
5810	break;	5889	break;
5811	default:	5890	default:
5812	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	5891	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
5813	"0288 Unknown FCoE event type 0x%x event tag "	5892	"0288 Unknown FCoE event type 0x%x event tag "
5814	"0x%x\n", event_type, acqe_fip->event_tag);	5893	"0x%x\n", event_type, acqe_fip->event_tag);
5815	break;	5894	break;
5816	}	5895	}
5817	}	5896	}
@@ -5819,7 +5898,7 @@ lpfc_sli4_async_fip_evt(struct lpfc_hba *phba, · 1 unmodified line
5819	/**	5898	/**
5820	* lpfc_sli4_async_dcbx_evt - Process the asynchronous dcbx event	5899	* lpfc_sli4_async_dcbx_evt - Process the asynchronous dcbx event
5821	* @phba: pointer to lpfc hba data structure.	5900	* @phba: pointer to lpfc hba data structure.
5822	* @acqe_link: pointer to the async dcbx completion queue entry.	5901	* @acqe_dcbx: pointer to the async dcbx completion queue entry.
5823	*	5902	*
5824	* This routine is to handle the SLI4 asynchronous dcbx event.	5903	* This routine is to handle the SLI4 asynchronous dcbx event.
5825	**/	5904	**/
@@ -5828,7 +5907,7 @@ lpfc_sli4_async_dcbx_evt(struct lpfc_hba *phba, · 2 unmodified lines
5828	struct lpfc_acqe_dcbx *acqe_dcbx)	5907	struct lpfc_acqe_dcbx *acqe_dcbx)
5829	{	5908	{
5830	phba->fc_eventTag = acqe_dcbx->event_tag;	5909	phba->fc_eventTag = acqe_dcbx->event_tag;
5831	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	5910	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
5832	"0290 The SLI4 DCBX asynchronous event is not "	5911	"0290 The SLI4 DCBX asynchronous event is not "
5833	"handled yet\n");	5912	"handled yet\n");
5834	}	5913	}
@@ -5836,7 +5915,7 @@ lpfc_sli4_async_dcbx_evt(struct lpfc_hba *phba, · 1 unmodified line
5836	/**	5915	/**
5837	* lpfc_sli4_async_grp5_evt - Process the asynchronous group5 event	5916	* lpfc_sli4_async_grp5_evt - Process the asynchronous group5 event
5838	* @phba: pointer to lpfc hba data structure.	5917	* @phba: pointer to lpfc hba data structure.
5839	* @acqe_link: pointer to the async grp5 completion queue entry.	5918	* @acqe_grp5: pointer to the async grp5 completion queue entry.
5840	*	5919	*
5841	* This routine is to handle the SLI4 asynchronous grp5 event. A grp5 event	5920	* This routine is to handle the SLI4 asynchronous grp5 event. A grp5 event
5842	* is an asynchronous notified of a logical link speed change. The Port	5921	* is an asynchronous notified of a logical link speed change. The Port
@@ -5905,7 +5984,8 @@ void lpfc_sli4_async_event_proc(struct lpfc_hba *phba) · 62 unmodified lines
5905	lpfc_sli4_async_sli_evt(phba, &cq_event->cqe.acqe_sli);	5984	lpfc_sli4_async_sli_evt(phba, &cq_event->cqe.acqe_sli);
5906	break;	5985	break;
5907	default:	5986	default:
5908	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	5987	lpfc_printf_log(phba, KERN_ERR,
		5988	LOG_TRACE_EVENT,
5909	"1804 Invalid asynchronous event code: "	5989	"1804 Invalid asynchronous event code: "
5910	"x%x\n", bf_get(lpfc_trailer_code,	5990	"x%x\n", bf_get(lpfc_trailer_code,
5911	&cq_event->cqe.mcqe_cmpl));	5991	&cq_event->cqe.mcqe_cmpl));
@@ -5941,7 +6021,7 @@ void lpfc_sli4_fcf_redisc_event_proc(struct lpfc_hba *phba) · 29 unmodified lines
5941	"2777 Start post-quiescent FCF table scan\n");	6021	"2777 Start post-quiescent FCF table scan\n");
5942	rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba, LPFC_FCOE_FCF_GET_FIRST);	6022	rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba, LPFC_FCOE_FCF_GET_FIRST);
5943	if (rc)	6023	if (rc)
5944	lpfc_printf_log(phba, KERN_ERR, LOG_FIP \| LOG_DISCOVERY,	6024	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
5945	"2747 Issue FCF scan read FCF mailbox "	6025	"2747 Issue FCF scan read FCF mailbox "
5946	"command failed 0x%x\n", rc);	6026	"command failed 0x%x\n", rc);
5947	}	6027	}
@@ -6012,7 +6092,7 @@ static void lpfc_log_intr_mode(struct lpfc_hba *phba, uint32_t intr_mode) · 64 unmodified lines
6012	"0480 Enabled MSI-X interrupt mode.\n");	6092	"0480 Enabled MSI-X interrupt mode.\n");
6013	break;	6093	break;
6014	default:	6094	default:
6015	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	6095	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
6016	"0482 Illegal interrupt mode.\n");	6096	"0482 Illegal interrupt mode.\n");
6017	break;	6097	break;
6018	}	6098	}
@@ -6060,7 +6140,7 @@ lpfc_enable_pci_dev(struct lpfc_hba *phba) · 41 unmodified lines
6060	out_disable_device:	6140	out_disable_device:
6061	pci_disable_device(pdev);	6141	pci_disable_device(pdev);
6062	out_error:	6142	out_error:
6063	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	6143	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
6064	"1401 Failed to enable pci device\n");	6144	"1401 Failed to enable pci device\n");
6065	return -ENODEV;	6145	return -ENODEV;
6066	}	6146	}
@@ -6161,7 +6241,7 @@ lpfc_sli_probe_sriov_nr_virtfn(struct lpfc_hba *phba, int nr_vfn) · 94 unmodified lines
6161		6241
6162	max_nr_vfn = lpfc_sli_sriov_nr_virtfn_get(phba);	6242	max_nr_vfn = lpfc_sli_sriov_nr_virtfn_get(phba);
6163	if (nr_vfn > max_nr_vfn) {	6243	if (nr_vfn > max_nr_vfn) {
6164	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	6244	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
6165	"3057 Requested vfs (%d) greater than "	6245	"3057 Requested vfs (%d) greater than "
6166	"supported vfs (%d)", nr_vfn, max_nr_vfn);	6246	"supported vfs (%d)", nr_vfn, max_nr_vfn);
6167	return -EINVAL;	6247	return -EINVAL;
@@ -6200,6 +6280,9 @@ lpfc_setup_driver_resource_phase1(struct lpfc_hba *phba) · 32 unmodified lines
6200	* Driver resources common to all SLI revisions	6280	* Driver resources common to all SLI revisions
6201	*/	6281	*/
6202	atomic_set(&phba->fast_event_count, 0);	6282	atomic_set(&phba->fast_event_count, 0);
		6283	atomic_set(&phba->dbg_log_idx, 0);
		6284	atomic_set(&phba->dbg_log_cnt, 0);
		6285	atomic_set(&phba->dbg_log_dmping, 0);
6203	spin_lock_init(&phba->hbalock);	6286	spin_lock_init(&phba->hbalock);
6204		6287
6205	/* Initialize ndlp management spinlock */	6288	/* Initialize ndlp management spinlock */
@@ -6253,6 +6336,9 @@ lpfc_setup_driver_resource_phase1(struct lpfc_hba *phba) · 47 unmodified lines
6253		6336
6254	INIT_DELAYED_WORK(&phba->eq_delay_work, lpfc_hb_eq_delay_work);	6337	INIT_DELAYED_WORK(&phba->eq_delay_work, lpfc_hb_eq_delay_work);
6255		6338
		6339	INIT_DELAYED_WORK(&phba->idle_stat_delay_work,
		6340	lpfc_idle_stat_delay_work);
		6341
6256	return 0;	6342	return 0;
6257	}	6343	}
6258		6344
@@ -6624,7 +6710,8 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba) · 365 unmodified lines
6624	lpfc_read_nv(phba, mboxq);	6710	lpfc_read_nv(phba, mboxq);
6625	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);	6711	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
6626	if (rc != MBX_SUCCESS) {	6712	if (rc != MBX_SUCCESS) {
6627	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	6713	lpfc_printf_log(phba, KERN_ERR,
		6714	LOG_TRACE_EVENT,
6628	"6016 Mailbox failed , mbxCmd x%x "	6715	"6016 Mailbox failed , mbxCmd x%x "
6629	"READ_NV, mbxStatus x%x\n",	6716	"READ_NV, mbxStatus x%x\n",
6630	bf_get(lpfc_mqe_command, &mboxq->u.mqe),	6717	bf_get(lpfc_mqe_command, &mboxq->u.mqe),
@@ -6653,11 +6740,13 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba) · 22 unmodified lines
6653		6740
6654	phba->nvmet_support = 1; /* a match */	6741	phba->nvmet_support = 1; /* a match */
6655		6742
6656	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	6743	lpfc_printf_log(phba, KERN_ERR,
		6744	LOG_TRACE_EVENT,
6657	"6017 NVME Target %016llx\n",	6745	"6017 NVME Target %016llx\n",
6658	wwn);	6746	wwn);
6659	#else	6747	#else
6660	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	6748	lpfc_printf_log(phba, KERN_ERR,
		6749	LOG_TRACE_EVENT,
6661	"6021 Can't enable NVME Target."	6750	"6021 Can't enable NVME Target."
6662	" NVME_TARGET_FC infrastructure"	6751	" NVME_TARGET_FC infrastructure"
6663	" is not in kernel\n");	6752	" is not in kernel\n");
@@ -6717,9 +6806,9 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba) · 53 unmodified lines
6717	&phba->sli4_hba.sli_intf);	6806	&phba->sli4_hba.sli_intf);
6718	if (phba->sli4_hba.extents_in_use &&	6807	if (phba->sli4_hba.extents_in_use &&
6719	phba->sli4_hba.rpi_hdrs_in_use) {	6808	phba->sli4_hba.rpi_hdrs_in_use) {
6720	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	6809	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
6721	"2999 Unsupported SLI4 Parameters "	6810	"2999 Unsupported SLI4 Parameters "
6722	"Extents and RPI headers enabled.\n");	6811	"Extents and RPI headers enabled.\n");
6723	if (if_type == LPFC_SLI_INTF_IF_TYPE_0 &&	6812	if (if_type == LPFC_SLI_INTF_IF_TYPE_0 &&
6724	if_fam == LPFC_SLI_INTF_FAMILY_BE2) {	6813	if_fam == LPFC_SLI_INTF_FAMILY_BE2) {
6725	mempool_free(mboxq, phba->mbox_mem_pool);	6814	mempool_free(mboxq, phba->mbox_mem_pool);
@@ -6879,13 +6968,13 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba) · 153 unmodified lines
6879	/* Allocate and initialize active sgl array */	6968	/* Allocate and initialize active sgl array */
6880	rc = lpfc_init_active_sgl_array(phba);	6969	rc = lpfc_init_active_sgl_array(phba);
6881	if (rc) {	6970	if (rc) {
6882	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	6971	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
6883	"1430 Failed to initialize sgl list.\n");	6972	"1430 Failed to initialize sgl list.\n");
6884	goto out_destroy_cq_event_pool;	6973	goto out_destroy_cq_event_pool;
6885	}	6974	}
6886	rc = lpfc_sli4_init_rpi_hdrs(phba);	6975	rc = lpfc_sli4_init_rpi_hdrs(phba);
6887	if (rc) {	6976	if (rc) {
6888	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	6977	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
6889	"1432 Failed to initialize rpi headers.\n");	6978	"1432 Failed to initialize rpi headers.\n");
6890	goto out_free_active_sgl;	6979	goto out_free_active_sgl;
6891	}	6980	}
@@ -6895,7 +6984,7 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba) · 3 unmodified lines
6895	phba->fcf.fcf_rr_bmask = kcalloc(longs, sizeof(unsigned long),	6984	phba->fcf.fcf_rr_bmask = kcalloc(longs, sizeof(unsigned long),
6896	GFP_KERNEL);	6985	GFP_KERNEL);
6897	if (!phba->fcf.fcf_rr_bmask) {	6986	if (!phba->fcf.fcf_rr_bmask) {
6898	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	6987	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
6899	"2759 Failed allocate memory for FCF round "	6988	"2759 Failed allocate memory for FCF round "
6900	"robin failover bmask\n");	6989	"robin failover bmask\n");
6901	rc = -ENOMEM;	6990	rc = -ENOMEM;
@@ -6906,7 +6995,7 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba) · 4 unmodified lines
6906	sizeof(struct lpfc_hba_eq_hdl),	6995	sizeof(struct lpfc_hba_eq_hdl),
6907	GFP_KERNEL);	6996	GFP_KERNEL);
6908	if (!phba->sli4_hba.hba_eq_hdl) {	6997	if (!phba->sli4_hba.hba_eq_hdl) {
6909	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	6998	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
6910	"2572 Failed allocate memory for "	6999	"2572 Failed allocate memory for "
6911	"fast-path per-EQ handle array\n");	7000	"fast-path per-EQ handle array\n");
6912	rc = -ENOMEM;	7001	rc = -ENOMEM;
@@ -6917,7 +7006,7 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba) · 4 unmodified lines
6917	sizeof(struct lpfc_vector_map_info),	7006	sizeof(struct lpfc_vector_map_info),
6918	GFP_KERNEL);	7007	GFP_KERNEL);
6919	if (!phba->sli4_hba.cpu_map) {	7008	if (!phba->sli4_hba.cpu_map) {
6920	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	7009	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
6921	"3327 Failed allocate memory for msi-x "	7010	"3327 Failed allocate memory for msi-x "
6922	"interrupt vector mapping\n");	7011	"interrupt vector mapping\n");
6923	rc = -ENOMEM;	7012	rc = -ENOMEM;
@@ -6926,19 +7015,29 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba) · 2 unmodified lines
6926		7015
6927	phba->sli4_hba.eq_info = alloc_percpu(struct lpfc_eq_intr_info);	7016	phba->sli4_hba.eq_info = alloc_percpu(struct lpfc_eq_intr_info);
6928	if (!phba->sli4_hba.eq_info) {	7017	if (!phba->sli4_hba.eq_info) {
6929	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	7018	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
6930	"3321 Failed allocation for per_cpu stats\n");	7019	"3321 Failed allocation for per_cpu stats\n");
6931	rc = -ENOMEM;	7020	rc = -ENOMEM;
6932	goto out_free_hba_cpu_map;	7021	goto out_free_hba_cpu_map;
6933	}	7022	}
6934		7023
		7024	phba->sli4_hba.idle_stat = kcalloc(phba->sli4_hba.num_possible_cpu,
		7025	sizeof(*phba->sli4_hba.idle_stat),
		7026	GFP_KERNEL);
		7027	if (!phba->sli4_hba.idle_stat) {
		7028	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
		7029	"3390 Failed allocation for idle_stat\n");
		7030	rc = -ENOMEM;
		7031	goto out_free_hba_eq_info;
		7032	}
		7033
6935	#ifdef CONFIG_SCSI_LPFC_DEBUG_FS	7034	#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
6936	phba->sli4_hba.c_stat = alloc_percpu(struct lpfc_hdwq_stat);	7035	phba->sli4_hba.c_stat = alloc_percpu(struct lpfc_hdwq_stat);
6937	if (!phba->sli4_hba.c_stat) {	7036	if (!phba->sli4_hba.c_stat) {
6938	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	7037	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
6939	"3332 Failed allocating per cpu hdwq stats\n");	7038	"3332 Failed allocating per cpu hdwq stats\n");
6940	rc = -ENOMEM;	7039	rc = -ENOMEM;
6941	goto out_free_hba_eq_info;	7040	goto out_free_hba_idle_stat;
6942	}	7041	}
6943	#endif	7042	#endif
6944		7043
@@ -6962,9 +7061,11 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba) · 17 unmodified lines
6962	return 0;	7061	return 0;
6963		7062
6964	#ifdef CONFIG_SCSI_LPFC_DEBUG_FS	7063	#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
		7064	out_free_hba_idle_stat:
		7065	kfree(phba->sli4_hba.idle_stat);
		7066	#endif
6965	out_free_hba_eq_info:	7067	out_free_hba_eq_info:
6966	free_percpu(phba->sli4_hba.eq_info);	7068	free_percpu(phba->sli4_hba.eq_info);
6967	#endif
6968	out_free_hba_cpu_map:	7069	out_free_hba_cpu_map:
6969	kfree(phba->sli4_hba.cpu_map);	7070	kfree(phba->sli4_hba.cpu_map);
6970	out_free_hba_eq_hdl:	7071	out_free_hba_eq_hdl:
@@ -7006,6 +7107,7 @@ lpfc_sli4_driver_resource_unset(struct lpfc_hba *phba) · 35 unmodified lines
7006	#ifdef CONFIG_SCSI_LPFC_DEBUG_FS	7107	#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
7007	free_percpu(phba->sli4_hba.c_stat);	7108	free_percpu(phba->sli4_hba.c_stat);
7008	#endif	7109	#endif
		7110	kfree(phba->sli4_hba.idle_stat);
7009		7111
7010	/* Free memory allocated for msi-x interrupt vector to CPU mapping */	7112	/* Free memory allocated for msi-x interrupt vector to CPU mapping */
7011	kfree(phba->sli4_hba.cpu_map);	7113	kfree(phba->sli4_hba.cpu_map);
@@ -7080,7 +7182,7 @@ lpfc_init_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp) · 68 unmodified lines
7080	phba->lpfc_stop_port = lpfc_stop_port_s4;	7182	phba->lpfc_stop_port = lpfc_stop_port_s4;
7081	break;	7183	break;
7082	default:	7184	default:
7083	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	7185	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
7084	"1431 Invalid HBA PCI-device group: 0x%x\n",	7186	"1431 Invalid HBA PCI-device group: 0x%x\n",
7085	dev_grp);	7187	dev_grp);
7086	return -ENODEV;	7188	return -ENODEV;
@@ -7164,6 +7266,7 @@ lpfc_free_iocb_list(struct lpfc_hba *phba) · 77 unmodified lines
7164	/**	7266	/**
7165	* lpfc_init_iocb_list - Allocate and initialize iocb list.	7267	* lpfc_init_iocb_list - Allocate and initialize iocb list.
7166	* @phba: pointer to lpfc hba data structure.	7268	* @phba: pointer to lpfc hba data structure.
		7269	* @iocb_count: number of requested iocbs
7167	*	7270	*
7168	* This routine is invoked to allocate and initizlize the driver's IOCB	7271	* This routine is invoked to allocate and initizlize the driver's IOCB
7169	* list and set up the IOCB tag array accordingly.	7272	* list and set up the IOCB tag array accordingly.
@@ -7375,7 +7478,7 @@ lpfc_sli4_init_rpi_hdrs(struct lpfc_hba *phba) · 205 unmodified lines
7375		7478
7376	rpi_hdr = lpfc_sli4_create_rpi_hdr(phba);	7479	rpi_hdr = lpfc_sli4_create_rpi_hdr(phba);
7377	if (!rpi_hdr) {	7480	if (!rpi_hdr) {
7378	lpfc_printf_log(phba, KERN_ERR, LOG_MBOX \| LOG_SLI,	7481	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
7379	"0391 Error during rpi post operation\n");	7482	"0391 Error during rpi post operation\n");
7380	lpfc_sli4_remove_rpis(phba);	7483	lpfc_sli4_remove_rpis(phba);
7381	rc = -ENODEV;	7484	rc = -ENODEV;
@@ -7687,7 +7790,7 @@ lpfc_setup_bg(struct lpfc_hba phba, struct Scsi_Host shost) · 305 unmodified lines
7687	if (phba->cfg_prot_mask && phba->cfg_prot_guard) {	7790	if (phba->cfg_prot_mask && phba->cfg_prot_guard) {
7688	if ((old_mask != phba->cfg_prot_mask) \|\|	7791	if ((old_mask != phba->cfg_prot_mask) \|\|
7689	(old_guard != phba->cfg_prot_guard))	7792	(old_guard != phba->cfg_prot_guard))
7690	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	7793	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
7691	"1475 Registering BlockGuard with the "	7794	"1475 Registering BlockGuard with the "
7692	"SCSI layer: mask %d guard %d\n",	7795	"SCSI layer: mask %d guard %d\n",
7693	phba->cfg_prot_mask,	7796	phba->cfg_prot_mask,
@@ -7696,7 +7799,7 @@ lpfc_setup_bg(struct lpfc_hba phba, struct Scsi_Host shost) · 2 unmodified lines
7696	scsi_host_set_prot(shost, phba->cfg_prot_mask);	7799	scsi_host_set_prot(shost, phba->cfg_prot_mask);
7697	scsi_host_set_guard(shost, phba->cfg_prot_guard);	7800	scsi_host_set_guard(shost, phba->cfg_prot_guard);
7698	} else	7801	} else
7699	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	7802	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
7700	"1479 Not Registering BlockGuard with the SCSI "	7803	"1479 Not Registering BlockGuard with the SCSI "
7701	"layer, Bad protection parameters: %d %d\n",	7804	"layer, Bad protection parameters: %d %d\n",
7702	old_mask, old_guard);	7805	old_mask, old_guard);
@@ -7927,7 +8030,7 @@ lpfc_sli4_post_status_check(struct lpfc_hba *phba) · 224 unmodified lines
7927	* other register reads as the data may not be valid. Just exit.	8030	* other register reads as the data may not be valid. Just exit.
7928	*/	8031	*/
7929	if (port_error) {	8032	if (port_error) {
7930	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	8033	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
7931	"1408 Port Failed POST - portsmphr=0x%x, "	8034	"1408 Port Failed POST - portsmphr=0x%x, "
7932	"perr=x%x, sfi=x%x, nip=x%x, ipc=x%x, scr1=x%x, "	8035	"perr=x%x, sfi=x%x, nip=x%x, ipc=x%x, scr1=x%x, "
7933	"scr2=x%x, hscratch=x%x, pstatus=x%x\n",	8036	"scr2=x%x, hscratch=x%x, pstatus=x%x\n",
@@ -7976,7 +8079,8 @@ lpfc_sli4_post_status_check(struct lpfc_hba *phba) · 42 unmodified lines
7976	readl(phba->sli4_hba.u.if_type0.UERRHIregaddr);	8079	readl(phba->sli4_hba.u.if_type0.UERRHIregaddr);
7977	if ((~phba->sli4_hba.ue_mask_lo & uerrlo_reg.word0) \|\|	8080	if ((~phba->sli4_hba.ue_mask_lo & uerrlo_reg.word0) \|\|
7978	(~phba->sli4_hba.ue_mask_hi & uerrhi_reg.word0)) {	8081	(~phba->sli4_hba.ue_mask_hi & uerrhi_reg.word0)) {
7979	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	8082	lpfc_printf_log(phba, KERN_ERR,
		8083	LOG_TRACE_EVENT,
7980	"1422 Unrecoverable Error "	8084	"1422 Unrecoverable Error "
7981	"Detected during POST "	8085	"Detected during POST "
7982	"uerr_lo_reg=0x%x, "	8086	"uerr_lo_reg=0x%x, "
@@ -8003,7 +8107,7 @@ lpfc_sli4_post_status_check(struct lpfc_hba *phba) · 20 unmodified lines
8003	phba->work_status[1] =	8107	phba->work_status[1] =
8004	readl(phba->sli4_hba.u.if_type2.	8108	readl(phba->sli4_hba.u.if_type2.
8005	ERR2regaddr);	8109	ERR2regaddr);
8006	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	8110	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
8007	"2888 Unrecoverable port error "	8111	"2888 Unrecoverable port error "
8008	"following POST: port status reg "	8112	"following POST: port status reg "
8009	"0x%x, port_smphr reg 0x%x, "	8113	"0x%x, port_smphr reg 0x%x, "
@@ -8116,6 +8220,7 @@ lpfc_sli4_bar0_register_memmap(struct lpfc_hba *phba, uint32_t if_type) · 106 unmodified lines
8116	/**	8220	/**
8117	* lpfc_sli4_bar1_register_memmap - Set up SLI4 BAR1 register memory map.	8221	* lpfc_sli4_bar1_register_memmap - Set up SLI4 BAR1 register memory map.
8118	* @phba: pointer to lpfc hba data structure.	8222	* @phba: pointer to lpfc hba data structure.
		8223	* @if_type: sli if type to operate on.
8119	*	8224	*
8120	* This routine is invoked to set up SLI4 BAR1 register memory map.	8225	* This routine is invoked to set up SLI4 BAR1 register memory map.
8121	**/	8226	**/
@@ -8297,20 +8402,19 @@ static const char * const lpfc_topo_to_str[] = { · 175 unmodified lines
8297	"P2P then Loop",	8402	"P2P then Loop",
8298	};	8403	};
8299		8404
		8405	#define LINK_FLAGS_DEF 0x0
		8406	#define LINK_FLAGS_P2P 0x1
		8407	#define LINK_FLAGS_LOOP 0x2
8300	/**	8408	/**
8301	* lpfc_map_topology - Map the topology read from READ_CONFIG	8409	* lpfc_map_topology - Map the topology read from READ_CONFIG
8302	* @phba: pointer to lpfc hba data structure.	8410	* @phba: pointer to lpfc hba data structure.
8303	* @rdconf: pointer to read config data	8411	* @rd_config: pointer to read config data
8304	*	8412	*
8305	* This routine is invoked to map the topology values as read	8413	* This routine is invoked to map the topology values as read
8306	* from the read config mailbox command. If the persistent	8414	* from the read config mailbox command. If the persistent
8307	* topology feature is supported, the firmware will provide the	8415	* topology feature is supported, the firmware will provide the
8308	* saved topology information to be used in INIT_LINK	8416	* saved topology information to be used in INIT_LINK
8309	*
8310	**/	8417	**/
8311	#define LINK_FLAGS_DEF 0x0
8312	#define LINK_FLAGS_P2P 0x1
8313	#define LINK_FLAGS_LOOP 0x2
8314	static void	8418	static void
8315	lpfc_map_topology(struct lpfc_hba phba, struct lpfc_mbx_read_config rd_config)	8419	lpfc_map_topology(struct lpfc_hba phba, struct lpfc_mbx_read_config rd_config)
8316	{	8420	{
@@ -8397,7 +8501,7 @@ lpfc_sli4_read_config(struct lpfc_hba *phba) · 80 unmodified lines
8397		8501
8398	pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);	8502	pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
8399	if (!pmb) {	8503	if (!pmb) {
8400	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	8504	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
8401	"2011 Unable to allocate memory for issuing "	8505	"2011 Unable to allocate memory for issuing "
8402	"SLI_CONFIG_SPECIAL mailbox command\n");	8506	"SLI_CONFIG_SPECIAL mailbox command\n");
8403	return -ENOMEM;	8507	return -ENOMEM;
@@ -8407,11 +8511,11 @@ lpfc_sli4_read_config(struct lpfc_hba *phba) · 3 unmodified lines
8407		8511
8408	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);	8512	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
8409	if (rc != MBX_SUCCESS) {	8513	if (rc != MBX_SUCCESS) {
8410	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	8514	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
8411	"2012 Mailbox failed , mbxCmd x%x "	8515	"2012 Mailbox failed , mbxCmd x%x "
8412	"READ_CONFIG, mbxStatus x%x\n",	8516	"READ_CONFIG, mbxStatus x%x\n",
8413	bf_get(lpfc_mqe_command, &pmb->u.mqe),	8517	bf_get(lpfc_mqe_command, &pmb->u.mqe),
8414	bf_get(lpfc_mqe_status, &pmb->u.mqe));	8518	bf_get(lpfc_mqe_status, &pmb->u.mqe));
8415	rc = -EIO;	8519	rc = -EIO;
8416	} else {	8520	} else {
8417	rd_config = &pmb->u.mqe.un.rd_config;	8521	rd_config = &pmb->u.mqe.un.rd_config;
@@ -8521,7 +8625,7 @@ lpfc_sli4_read_config(struct lpfc_hba *phba) · 103 unmodified lines
8521	/* Check to see if there is enough for NVME */	8625	/* Check to see if there is enough for NVME */
8522	if ((phba->cfg_irq_chann > qmin) \|\|	8626	if ((phba->cfg_irq_chann > qmin) \|\|
8523	(phba->cfg_hdw_queue > qmin)) {	8627	(phba->cfg_hdw_queue > qmin)) {
8524	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	8628	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
8525	"2005 Reducing Queues: "	8629	"2005 Reducing Queues: "
8526	"WQ %d CQ %d EQ %d: min %d: "	8630	"WQ %d CQ %d EQ %d: min %d: "
8527	"IRQ %d HDWQ %d\n",	8631	"IRQ %d HDWQ %d\n",
@@ -8587,7 +8691,8 @@ lpfc_sli4_read_config(struct lpfc_hba *phba) · 59 unmodified lines
8587	LPFC_USER_LINK_SPEED_AUTO;	8691	LPFC_USER_LINK_SPEED_AUTO;
8588	break;	8692	break;
8589	default:	8693	default:
8590	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	8694	lpfc_printf_log(phba, KERN_ERR,
		8695	LOG_TRACE_EVENT,
8591	"0047 Unrecognized link "	8696	"0047 Unrecognized link "
8592	"speed : %d\n",	8697	"speed : %d\n",
8593	forced_link_speed);	8698	forced_link_speed);
@@ -8624,7 +8729,7 @@ lpfc_sli4_read_config(struct lpfc_hba *phba) · 30 unmodified lines
8624	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);	8729	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
8625	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);	8730	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
8626	if (rc2 \|\| shdr_status \|\| shdr_add_status) {	8731	if (rc2 \|\| shdr_status \|\| shdr_add_status) {
8627	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	8732	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
8628	"3026 Mailbox failed , mbxCmd x%x "	8733	"3026 Mailbox failed , mbxCmd x%x "
8629	"GET_FUNCTION_CONFIG, mbxStatus x%x\n",	8734	"GET_FUNCTION_CONFIG, mbxStatus x%x\n",
8630	bf_get(lpfc_mqe_command, &pmb->u.mqe),	8735	bf_get(lpfc_mqe_command, &pmb->u.mqe),
@@ -8661,7 +8766,7 @@ lpfc_sli4_read_config(struct lpfc_hba *phba) · 30 unmodified lines
8661	"vf_number:%d\n", phba->sli4_hba.iov.pf_number,	8766	"vf_number:%d\n", phba->sli4_hba.iov.pf_number,
8662	phba->sli4_hba.iov.vf_number);	8767	phba->sli4_hba.iov.vf_number);
8663	else	8768	else
8664	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,	8769	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
8665	"3028 GET_FUNCTION_CONFIG: failed to find "	8770	"3028 GET_FUNCTION_CONFIG: failed to find "
8666	"Resource Descriptor:x%x\n",	8771	"Resource Descriptor:x%x\n",
8667	LPFC_RSRC_DESC_TYPE_FCFCOE);	8772	LPFC_RSRC_DESC_TYPE_FCFCOE);
@@ -8698,7 +8803,7 @@ lpfc_setup_endian_order(struct lpfc_hba *phba) · 30 unmodified lines
8698	mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,	8803	mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
8699	GFP_KERNEL);	8804	GFP_KERNEL);
8700	if (!mboxq) {	8805	if (!mboxq) {
8701	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	8806	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
8702	"0492 Unable to allocate memory for "	8807	"0492 Unable to allocate memory for "
8703	"issuing SLI_CONFIG_SPECIAL mailbox "	8808	"issuing SLI_CONFIG_SPECIAL mailbox "
8704	"command\n");	8809	"command\n");
@@ -8713,7 +8818,7 @@ lpfc_setup_endian_order(struct lpfc_hba *phba) · 8 unmodified lines
8713	memcpy(&mboxq->u.mqe, &endian_mb_data, sizeof(endian_mb_data));	8818	memcpy(&mboxq->u.mqe, &endian_mb_data, sizeof(endian_mb_data));
8714	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);	8819	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
8715	if (rc != MBX_SUCCESS) {	8820	if (rc != MBX_SUCCESS) {
8716	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	8821	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
8717	"0493 SLI_CONFIG_SPECIAL mailbox "	8822	"0493 SLI_CONFIG_SPECIAL mailbox "
8718	"failed with status x%x\n",	8823	"failed with status x%x\n",
8719	rc);	8824	rc);
@@ -8793,8 +8898,9 @@ lpfc_alloc_io_wq_cq(struct lpfc_hba *phba, int idx) · 73 unmodified lines
8793	phba->sli4_hba.cq_esize,	8898	phba->sli4_hba.cq_esize,
8794	phba->sli4_hba.cq_ecount, cpu);	8899	phba->sli4_hba.cq_ecount, cpu);
8795	if (!qdesc) {	8900	if (!qdesc) {
8796	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	8901	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
8797	"0499 Failed allocate fast-path IO CQ (%d)\n", idx);	8902	"0499 Failed allocate fast-path IO CQ (%d)\n",
		8903	idx);
8798	return 1;	8904	return 1;
8799	}	8905	}
8800	qdesc->qe_valid = 1;	8906	qdesc->qe_valid = 1;
@@ -8816,7 +8922,7 @@ lpfc_alloc_io_wq_cq(struct lpfc_hba *phba, int idx) · 15 unmodified lines
8816	phba->sli4_hba.wq_ecount, cpu);	8922	phba->sli4_hba.wq_ecount, cpu);
8817		8923
8818	if (!qdesc) {	8924	if (!qdesc) {
8819	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	8925	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
8820	"0503 Failed allocate fast-path IO WQ (%d)\n",	8926	"0503 Failed allocate fast-path IO WQ (%d)\n",
8821	idx);	8927	idx);
8822	return 1;	8928	return 1;
@@ -8872,7 +8978,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba) · 49 unmodified lines
8872	phba->cfg_hdw_queue, sizeof(struct lpfc_sli4_hdw_queue),	8978	phba->cfg_hdw_queue, sizeof(struct lpfc_sli4_hdw_queue),
8873	GFP_KERNEL);	8979	GFP_KERNEL);
8874	if (!phba->sli4_hba.hdwq) {	8980	if (!phba->sli4_hba.hdwq) {
8875	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	8981	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
8876	"6427 Failed allocate memory for "	8982	"6427 Failed allocate memory for "
8877	"fast-path Hardware Queue array\n");	8983	"fast-path Hardware Queue array\n");
8878	goto out_error;	8984	goto out_error;
@@ -8904,7 +9010,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba) · 25 unmodified lines
8904	sizeof(struct lpfc_queue *),	9010	sizeof(struct lpfc_queue *),
8905	GFP_KERNEL);	9011	GFP_KERNEL);
8906	if (!phba->sli4_hba.nvmet_cqset) {	9012	if (!phba->sli4_hba.nvmet_cqset) {
8907	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9013	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
8908	"3121 Fail allocate memory for "	9014	"3121 Fail allocate memory for "
8909	"fast-path CQ set array\n");	9015	"fast-path CQ set array\n");
8910	goto out_error;	9016	goto out_error;
@@ -8914,7 +9020,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba) · 3 unmodified lines
8914	sizeof(struct lpfc_queue *),	9020	sizeof(struct lpfc_queue *),
8915	GFP_KERNEL);	9021	GFP_KERNEL);
8916	if (!phba->sli4_hba.nvmet_mrq_hdr) {	9022	if (!phba->sli4_hba.nvmet_mrq_hdr) {
8917	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9023	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
8918	"3122 Fail allocate memory for "	9024	"3122 Fail allocate memory for "
8919	"fast-path RQ set hdr array\n");	9025	"fast-path RQ set hdr array\n");
8920	goto out_error;	9026	goto out_error;
@@ -8924,7 +9030,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba) · 3 unmodified lines
8924	sizeof(struct lpfc_queue *),	9030	sizeof(struct lpfc_queue *),
8925	GFP_KERNEL);	9031	GFP_KERNEL);
8926	if (!phba->sli4_hba.nvmet_mrq_data) {	9032	if (!phba->sli4_hba.nvmet_mrq_data) {
8927	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9033	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
8928	"3124 Fail allocate memory for "	9034	"3124 Fail allocate memory for "
8929	"fast-path RQ set data array\n");	9035	"fast-path RQ set data array\n");
8930	goto out_error;	9036	goto out_error;
@@ -8952,7 +9058,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba) · 21 unmodified lines
8952	phba->sli4_hba.eq_esize,	9058	phba->sli4_hba.eq_esize,
8953	phba->sli4_hba.eq_ecount, cpu);	9059	phba->sli4_hba.eq_ecount, cpu);
8954	if (!qdesc) {	9060	if (!qdesc) {
8955	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9061	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
8956	"0497 Failed allocate EQ (%d)\n",	9062	"0497 Failed allocate EQ (%d)\n",
8957	cpup->hdwq);	9063	cpup->hdwq);
8958	goto out_error;	9064	goto out_error;
@@ -9006,7 +9112,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba) · 47 unmodified lines
9006	phba->sli4_hba.cq_ecount,	9112	phba->sli4_hba.cq_ecount,
9007	cpu);	9113	cpu);
9008	if (!qdesc) {	9114	if (!qdesc) {
9009	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9115	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9010	"3142 Failed allocate NVME "	9116	"3142 Failed allocate NVME "
9011	"CQ Set (%d)\n", idx);	9117	"CQ Set (%d)\n", idx);
9012	goto out_error;	9118	goto out_error;
@@ -9028,7 +9134,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba) · 15 unmodified lines
9028	phba->sli4_hba.cq_esize,	9134	phba->sli4_hba.cq_esize,
9029	phba->sli4_hba.cq_ecount, cpu);	9135	phba->sli4_hba.cq_ecount, cpu);
9030	if (!qdesc) {	9136	if (!qdesc) {
9031	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9137	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9032	"0500 Failed allocate slow-path mailbox CQ\n");	9138	"0500 Failed allocate slow-path mailbox CQ\n");
9033	goto out_error;	9139	goto out_error;
9034	}	9140	}
@@ -9040,7 +9146,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba) · 5 unmodified lines
9040	phba->sli4_hba.cq_esize,	9146	phba->sli4_hba.cq_esize,
9041	phba->sli4_hba.cq_ecount, cpu);	9147	phba->sli4_hba.cq_ecount, cpu);
9042	if (!qdesc) {	9148	if (!qdesc) {
9043	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9149	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9044	"0501 Failed allocate slow-path ELS CQ\n");	9150	"0501 Failed allocate slow-path ELS CQ\n");
9045	goto out_error;	9151	goto out_error;
9046	}	9152	}
@@ -9059,7 +9165,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba) · 12 unmodified lines
9059	phba->sli4_hba.mq_esize,	9165	phba->sli4_hba.mq_esize,
9060	phba->sli4_hba.mq_ecount, cpu);	9166	phba->sli4_hba.mq_ecount, cpu);
9061	if (!qdesc) {	9167	if (!qdesc) {
9062	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9168	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9063	"0505 Failed allocate slow-path MQ\n");	9169	"0505 Failed allocate slow-path MQ\n");
9064	goto out_error;	9170	goto out_error;
9065	}	9171	}
@@ -9075,7 +9181,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba) · 9 unmodified lines
9075	phba->sli4_hba.wq_esize,	9181	phba->sli4_hba.wq_esize,
9076	phba->sli4_hba.wq_ecount, cpu);	9182	phba->sli4_hba.wq_ecount, cpu);
9077	if (!qdesc) {	9183	if (!qdesc) {
9078	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9184	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9079	"0504 Failed allocate slow-path ELS WQ\n");	9185	"0504 Failed allocate slow-path ELS WQ\n");
9080	goto out_error;	9186	goto out_error;
9081	}	9187	}
@@ -9089,7 +9195,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba) · 7 unmodified lines
9089	phba->sli4_hba.cq_esize,	9195	phba->sli4_hba.cq_esize,
9090	phba->sli4_hba.cq_ecount, cpu);	9196	phba->sli4_hba.cq_ecount, cpu);
9091	if (!qdesc) {	9197	if (!qdesc) {
9092	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9198	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9093	"6079 Failed allocate NVME LS CQ\n");	9199	"6079 Failed allocate NVME LS CQ\n");
9094	goto out_error;	9200	goto out_error;
9095	}	9201	}
@@ -9102,7 +9208,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba) · 6 unmodified lines
9102	phba->sli4_hba.wq_esize,	9208	phba->sli4_hba.wq_esize,
9103	phba->sli4_hba.wq_ecount, cpu);	9209	phba->sli4_hba.wq_ecount, cpu);
9104	if (!qdesc) {	9210	if (!qdesc) {
9105	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9211	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9106	"6080 Failed allocate NVME LS WQ\n");	9212	"6080 Failed allocate NVME LS WQ\n");
9107	goto out_error;	9213	goto out_error;
9108	}	9214	}
@@ -9120,7 +9226,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba) · 11 unmodified lines
9120	phba->sli4_hba.rq_esize,	9226	phba->sli4_hba.rq_esize,
9121	phba->sli4_hba.rq_ecount, cpu);	9227	phba->sli4_hba.rq_ecount, cpu);
9122	if (!qdesc) {	9228	if (!qdesc) {
9123	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9229	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9124	"0506 Failed allocate receive HRQ\n");	9230	"0506 Failed allocate receive HRQ\n");
9125	goto out_error;	9231	goto out_error;
9126	}	9232	}
@@ -9131,7 +9237,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba) · 4 unmodified lines
9131	phba->sli4_hba.rq_esize,	9237	phba->sli4_hba.rq_esize,
9132	phba->sli4_hba.rq_ecount, cpu);	9238	phba->sli4_hba.rq_ecount, cpu);
9133	if (!qdesc) {	9239	if (!qdesc) {
9134	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9240	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9135	"0507 Failed allocate receive DRQ\n");	9241	"0507 Failed allocate receive DRQ\n");
9136	goto out_error;	9242	goto out_error;
9137	}	9243	}
@@ -9149,7 +9255,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba) · 11 unmodified lines
9149	LPFC_NVMET_RQE_DEF_COUNT,	9255	LPFC_NVMET_RQE_DEF_COUNT,
9150	cpu);	9256	cpu);
9151	if (!qdesc) {	9257	if (!qdesc) {
9152	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9258	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9153	"3146 Failed allocate "	9259	"3146 Failed allocate "
9154	"receive HRQ\n");	9260	"receive HRQ\n");
9155	goto out_error;	9261	goto out_error;
@@ -9162,7 +9268,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba) · 6 unmodified lines
9162	GFP_KERNEL,	9268	GFP_KERNEL,
9163	cpu_to_node(cpu));	9269	cpu_to_node(cpu));
9164	if (qdesc->rqbp == NULL) {	9270	if (qdesc->rqbp == NULL) {
9165	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9271	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9166	"6131 Failed allocate "	9272	"6131 Failed allocate "
9167	"Header RQBP\n");	9273	"Header RQBP\n");
9168	goto out_error;	9274	goto out_error;
@@ -9178,7 +9284,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba) · 9 unmodified lines
9178	LPFC_NVMET_RQE_DEF_COUNT,	9284	LPFC_NVMET_RQE_DEF_COUNT,
9179	cpu);	9285	cpu);
9180	if (!qdesc) {	9286	if (!qdesc) {
9181	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9287	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9182	"3156 Failed allocate "	9288	"3156 Failed allocate "
9183	"receive DRQ\n");	9289	"receive DRQ\n");
9184	goto out_error;	9290	goto out_error;
@@ -9369,7 +9475,7 @@ lpfc_create_wq_cq(struct lpfc_hba phba, struct lpfc_queue eq, · 184 unmodified lines
9369	int rc;	9475	int rc;
9370		9476
9371	if (!eq \|\| !cq \|\| !wq) {	9477	if (!eq \|\| !cq \|\| !wq) {
9372	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9478	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9373	"6085 Fast-path %s (%d) not allocated\n",	9479	"6085 Fast-path %s (%d) not allocated\n",
9374	((eq) ? ((cq) ? "WQ" : "CQ") : "EQ"), qidx);	9480	((eq) ? ((cq) ? "WQ" : "CQ") : "EQ"), qidx);
9375	return -ENOMEM;	9481	return -ENOMEM;
@@ -9379,9 +9485,9 @@ lpfc_create_wq_cq(struct lpfc_hba phba, struct lpfc_queue eq, · 3 unmodified lines
9379	rc = lpfc_cq_create(phba, cq, eq,	9485	rc = lpfc_cq_create(phba, cq, eq,
9380	(qtype == LPFC_MBOX) ? LPFC_MCQ : LPFC_WCQ, qtype);	9486	(qtype == LPFC_MBOX) ? LPFC_MCQ : LPFC_WCQ, qtype);
9381	if (rc) {	9487	if (rc) {
9382	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9488	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9383	"6086 Failed setup of CQ (%d), rc = 0x%x\n",	9489	"6086 Failed setup of CQ (%d), rc = 0x%x\n",
9384	qidx, (uint32_t)rc);	9490	qidx, (uint32_t)rc);
9385	return rc;	9491	return rc;
9386	}	9492	}
9387		9493
@@ -9397,7 +9503,7 @@ lpfc_create_wq_cq(struct lpfc_hba phba, struct lpfc_queue eq, · 9 unmodified lines
9397	/* create the wq */	9503	/* create the wq */
9398	rc = lpfc_wq_create(phba, wq, cq, qtype);	9504	rc = lpfc_wq_create(phba, wq, cq, qtype);
9399	if (rc) {	9505	if (rc) {
9400	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9506	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9401	"4618 Fail setup fastpath WQ (%d), rc = 0x%x\n",	9507	"4618 Fail setup fastpath WQ (%d), rc = 0x%x\n",
9402	qidx, (uint32_t)rc);	9508	qidx, (uint32_t)rc);
9403	/* no need to tear down cq - caller will do so */	9509	/* no need to tear down cq - caller will do so */
@@ -9415,9 +9521,9 @@ lpfc_create_wq_cq(struct lpfc_hba phba, struct lpfc_queue eq, · 11 unmodified lines
9415	} else {	9521	} else {
9416	rc = lpfc_mq_create(phba, wq, cq, LPFC_MBOX);	9522	rc = lpfc_mq_create(phba, wq, cq, LPFC_MBOX);
9417	if (rc) {	9523	if (rc) {
9418	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9524	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9419	"0539 Failed setup of slow-path MQ: "	9525	"0539 Failed setup of slow-path MQ: "
9420	"rc = 0x%x\n", rc);	9526	"rc = 0x%x\n", rc);
9421	/* no need to tear down cq - caller will do so */	9527	/* no need to tear down cq - caller will do so */
9422	return rc;	9528	return rc;
9423	}	9529	}
@@ -9490,7 +9596,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 66 unmodified lines
9490	/* Check for dual-ULP support */	9596	/* Check for dual-ULP support */
9491	mboxq = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);	9597	mboxq = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
9492	if (!mboxq) {	9598	if (!mboxq) {
9493	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9599	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9494	"3249 Unable to allocate memory for "	9600	"3249 Unable to allocate memory for "
9495	"QUERY_FW_CFG mailbox command\n");	9601	"QUERY_FW_CFG mailbox command\n");
9496	return -ENOMEM;	9602	return -ENOMEM;
@@ -9508,7 +9614,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 11 unmodified lines
9508	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);	9614	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
9509	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);	9615	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
9510	if (shdr_status \|\| shdr_add_status \|\| rc) {	9616	if (shdr_status \|\| shdr_add_status \|\| rc) {
9511	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9617	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9512	"3250 QUERY_FW_CFG mailbox failed with status "	9618	"3250 QUERY_FW_CFG mailbox failed with status "
9513	"x%x add_status x%x, mbx status x%x\n",	9619	"x%x add_status x%x, mbx status x%x\n",
9514	shdr_status, shdr_add_status, rc);	9620	shdr_status, shdr_add_status, rc);
@@ -9539,7 +9645,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 24 unmodified lines
9539		9645
9540	/* Set up HBA event queue */	9646	/* Set up HBA event queue */
9541	if (!qp) {	9647	if (!qp) {
9542	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9648	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9543	"3147 Fast-path EQs not allocated\n");	9649	"3147 Fast-path EQs not allocated\n");
9544	rc = -ENOMEM;	9650	rc = -ENOMEM;
9545	goto out_error;	9651	goto out_error;
@@ -9563,7 +9669,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 17 unmodified lines
9563	rc = lpfc_eq_create(phba, qp[cpup->hdwq].hba_eq,	9669	rc = lpfc_eq_create(phba, qp[cpup->hdwq].hba_eq,
9564	phba->cfg_fcp_imax);	9670	phba->cfg_fcp_imax);
9565	if (rc) {	9671	if (rc) {
9566	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9672	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9567	"0523 Failed setup of fast-path"	9673	"0523 Failed setup of fast-path"
9568	" EQ (%d), rc = 0x%x\n",	9674	" EQ (%d), rc = 0x%x\n",
9569	cpup->eq, (uint32_t)rc);	9675	cpup->eq, (uint32_t)rc);
@@ -9595,7 +9701,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 25 unmodified lines
9595	qidx,	9701	qidx,
9596	LPFC_IO);	9702	LPFC_IO);
9597	if (rc) {	9703	if (rc) {
9598	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9704	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9599	"0535 Failed to setup fastpath "	9705	"0535 Failed to setup fastpath "
9600	"IO WQ/CQ (%d), rc = 0x%x\n",	9706	"IO WQ/CQ (%d), rc = 0x%x\n",
9601	qidx, (uint32_t)rc);	9707	qidx, (uint32_t)rc);
@@ -9610,7 +9716,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 8 unmodified lines
9610	/* Set up slow-path MBOX CQ/MQ */	9716	/* Set up slow-path MBOX CQ/MQ */
9611		9717
9612	if (!phba->sli4_hba.mbx_cq \|\| !phba->sli4_hba.mbx_wq) {	9718	if (!phba->sli4_hba.mbx_cq \|\| !phba->sli4_hba.mbx_wq) {
9613	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9719	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9614	"0528 %s not allocated\n",	9720	"0528 %s not allocated\n",
9615	phba->sli4_hba.mbx_cq ?	9721	phba->sli4_hba.mbx_cq ?
9616	"Mailbox WQ" : "Mailbox CQ");	9722	"Mailbox WQ" : "Mailbox CQ");
@@ -9623,14 +9729,14 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 6 unmodified lines
9623	phba->sli4_hba.mbx_wq,	9729	phba->sli4_hba.mbx_wq,
9624	NULL, 0, LPFC_MBOX);	9730	NULL, 0, LPFC_MBOX);
9625	if (rc) {	9731	if (rc) {
9626	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9732	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9627	"0529 Failed setup of mailbox WQ/CQ: rc = 0x%x\n",	9733	"0529 Failed setup of mailbox WQ/CQ: rc = 0x%x\n",
9628	(uint32_t)rc);	9734	(uint32_t)rc);
9629	goto out_destroy;	9735	goto out_destroy;
9630	}	9736	}
9631	if (phba->nvmet_support) {	9737	if (phba->nvmet_support) {
9632	if (!phba->sli4_hba.nvmet_cqset) {	9738	if (!phba->sli4_hba.nvmet_cqset) {
9633	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9739	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9634	"3165 Fast-path NVME CQ Set "	9740	"3165 Fast-path NVME CQ Set "
9635	"array not allocated\n");	9741	"array not allocated\n");
9636	rc = -ENOMEM;	9742	rc = -ENOMEM;
@@ -9642,7 +9748,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 5 unmodified lines
9642	qp,	9748	qp,
9643	LPFC_WCQ, LPFC_NVMET);	9749	LPFC_WCQ, LPFC_NVMET);
9644	if (rc) {	9750	if (rc) {
9645	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9751	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9646	"3164 Failed setup of NVME CQ "	9752	"3164 Failed setup of NVME CQ "
9647	"Set, rc = 0x%x\n",	9753	"Set, rc = 0x%x\n",
9648	(uint32_t)rc);	9754	(uint32_t)rc);
@@ -9654,7 +9760,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 5 unmodified lines
9654	qp[0].hba_eq,	9760	qp[0].hba_eq,
9655	LPFC_WCQ, LPFC_NVMET);	9761	LPFC_WCQ, LPFC_NVMET);
9656	if (rc) {	9762	if (rc) {
9657	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9763	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9658	"6089 Failed setup NVMET CQ: "	9764	"6089 Failed setup NVMET CQ: "
9659	"rc = 0x%x\n", (uint32_t)rc);	9765	"rc = 0x%x\n", (uint32_t)rc);
9660	goto out_destroy;	9766	goto out_destroy;
@@ -9671,7 +9777,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 10 unmodified lines
9671		9777
9672	/* Set up slow-path ELS WQ/CQ */	9778	/* Set up slow-path ELS WQ/CQ */
9673	if (!phba->sli4_hba.els_cq \|\| !phba->sli4_hba.els_wq) {	9779	if (!phba->sli4_hba.els_cq \|\| !phba->sli4_hba.els_wq) {
9674	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9780	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9675	"0530 ELS %s not allocated\n",	9781	"0530 ELS %s not allocated\n",
9676	phba->sli4_hba.els_cq ? "WQ" : "CQ");	9782	phba->sli4_hba.els_cq ? "WQ" : "CQ");
9677	rc = -ENOMEM;	9783	rc = -ENOMEM;
@@ -9682,7 +9788,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 4 unmodified lines
9682	phba->sli4_hba.els_wq,	9788	phba->sli4_hba.els_wq,
9683	NULL, 0, LPFC_ELS);	9789	NULL, 0, LPFC_ELS);
9684	if (rc) {	9790	if (rc) {
9685	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9791	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9686	"0525 Failed setup of ELS WQ/CQ: rc = 0x%x\n",	9792	"0525 Failed setup of ELS WQ/CQ: rc = 0x%x\n",
9687	(uint32_t)rc);	9793	(uint32_t)rc);
9688	goto out_destroy;	9794	goto out_destroy;
@@ -9695,7 +9801,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 6 unmodified lines
9695	if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {	9801	if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
9696	/* Set up NVME LS Complete Queue */	9802	/* Set up NVME LS Complete Queue */
9697	if (!phba->sli4_hba.nvmels_cq \|\| !phba->sli4_hba.nvmels_wq) {	9803	if (!phba->sli4_hba.nvmels_cq \|\| !phba->sli4_hba.nvmels_wq) {
9698	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9804	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9699	"6091 LS %s not allocated\n",	9805	"6091 LS %s not allocated\n",
9700	phba->sli4_hba.nvmels_cq ? "WQ" : "CQ");	9806	phba->sli4_hba.nvmels_cq ? "WQ" : "CQ");
9701	rc = -ENOMEM;	9807	rc = -ENOMEM;
@@ -9706,7 +9812,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 4 unmodified lines
9706	phba->sli4_hba.nvmels_wq,	9812	phba->sli4_hba.nvmels_wq,
9707	NULL, 0, LPFC_NVME_LS);	9813	NULL, 0, LPFC_NVME_LS);
9708	if (rc) {	9814	if (rc) {
9709	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9815	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9710	"0526 Failed setup of NVVME LS WQ/CQ: "	9816	"0526 Failed setup of NVVME LS WQ/CQ: "
9711	"rc = 0x%x\n", (uint32_t)rc);	9817	"rc = 0x%x\n", (uint32_t)rc);
9712	goto out_destroy;	9818	goto out_destroy;
@@ -9726,7 +9832,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 13 unmodified lines
9726	if ((!phba->sli4_hba.nvmet_cqset) \|\|	9832	if ((!phba->sli4_hba.nvmet_cqset) \|\|
9727	(!phba->sli4_hba.nvmet_mrq_hdr) \|\|	9833	(!phba->sli4_hba.nvmet_mrq_hdr) \|\|
9728	(!phba->sli4_hba.nvmet_mrq_data)) {	9834	(!phba->sli4_hba.nvmet_mrq_data)) {
9729	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9835	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9730	"6130 MRQ CQ Queues not "	9836	"6130 MRQ CQ Queues not "
9731	"allocated\n");	9837	"allocated\n");
9732	rc = -ENOMEM;	9838	rc = -ENOMEM;
@@ -9739,7 +9845,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 6 unmodified lines
9739	phba->sli4_hba.nvmet_cqset,	9845	phba->sli4_hba.nvmet_cqset,
9740	LPFC_NVMET);	9846	LPFC_NVMET);
9741	if (rc) {	9847	if (rc) {
9742	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9848	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9743	"6098 Failed setup of NVMET "	9849	"6098 Failed setup of NVMET "
9744	"MRQ: rc = 0x%x\n",	9850	"MRQ: rc = 0x%x\n",
9745	(uint32_t)rc);	9851	(uint32_t)rc);
@@ -9753,7 +9859,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 7 unmodified lines
9753	phba->sli4_hba.nvmet_cqset[0],	9859	phba->sli4_hba.nvmet_cqset[0],
9754	LPFC_NVMET);	9860	LPFC_NVMET);
9755	if (rc) {	9861	if (rc) {
9756	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9862	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9757	"6057 Failed setup of NVMET "	9863	"6057 Failed setup of NVMET "
9758	"Receive Queue: rc = 0x%x\n",	9864	"Receive Queue: rc = 0x%x\n",
9759	(uint32_t)rc);	9865	(uint32_t)rc);
@@ -9772,7 +9878,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 12 unmodified lines
9772	}	9878	}
9773		9879
9774	if (!phba->sli4_hba.hdr_rq \|\| !phba->sli4_hba.dat_rq) {	9880	if (!phba->sli4_hba.hdr_rq \|\| !phba->sli4_hba.dat_rq) {
9775	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9881	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9776	"0540 Receive Queue not allocated\n");	9882	"0540 Receive Queue not allocated\n");
9777	rc = -ENOMEM;	9883	rc = -ENOMEM;
9778	goto out_destroy;	9884	goto out_destroy;
@@ -9781,7 +9887,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 2 unmodified lines
9781	rc = lpfc_rq_create(phba, phba->sli4_hba.hdr_rq, phba->sli4_hba.dat_rq,	9887	rc = lpfc_rq_create(phba, phba->sli4_hba.hdr_rq, phba->sli4_hba.dat_rq,
9782	phba->sli4_hba.els_cq, LPFC_USOL);	9888	phba->sli4_hba.els_cq, LPFC_USOL);
9783	if (rc) {	9889	if (rc) {
9784	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9890	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9785	"0541 Failed setup of Receive Queue: "	9891	"0541 Failed setup of Receive Queue: "
9786	"rc = 0x%x\n", (uint32_t)rc);	9892	"rc = 0x%x\n", (uint32_t)rc);
9787	goto out_destroy;	9893	goto out_destroy;
@@ -9809,7 +9915,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba) · 21 unmodified lines
9809	phba->sli4_hba.cq_lookup = kcalloc((phba->sli4_hba.cq_max + 1),	9915	phba->sli4_hba.cq_lookup = kcalloc((phba->sli4_hba.cq_max + 1),
9810	sizeof(struct lpfc_queue *), GFP_KERNEL);	9916	sizeof(struct lpfc_queue *), GFP_KERNEL);
9811	if (!phba->sli4_hba.cq_lookup) {	9917	if (!phba->sli4_hba.cq_lookup) {
9812	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	9918	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
9813	"0549 Failed setup of CQ Lookup table: "	9919	"0549 Failed setup of CQ Lookup table: "
9814	"size 0x%x\n", phba->sli4_hba.cq_max);	9920	"size 0x%x\n", phba->sli4_hba.cq_max);
9815	rc = -ENOMEM;	9921	rc = -ENOMEM;
@@ -10109,7 +10215,7 @@ lpfc_pci_function_reset(struct lpfc_hba *phba) · 293 unmodified lines
10109	mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,	10215	mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
10110	GFP_KERNEL);	10216	GFP_KERNEL);
10111	if (!mboxq) {	10217	if (!mboxq) {
10112	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	10218	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
10113	"0494 Unable to allocate memory for "	10219	"0494 Unable to allocate memory for "
10114	"issuing SLI_FUNCTION_RESET mailbox "	10220	"issuing SLI_FUNCTION_RESET mailbox "
10115	"command\n");	10221	"command\n");
@@ -10129,7 +10235,7 @@ lpfc_pci_function_reset(struct lpfc_hba *phba) · 13 unmodified lines
10129	if (rc != MBX_TIMEOUT)	10235	if (rc != MBX_TIMEOUT)
10130	mempool_free(mboxq, phba->mbox_mem_pool);	10236	mempool_free(mboxq, phba->mbox_mem_pool);
10131	if (shdr_status \|\| shdr_add_status \|\| rc) {	10237	if (shdr_status \|\| shdr_add_status \|\| rc) {
10132	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	10238	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
10133	"0495 SLI_FUNCTION_RESET mailbox "	10239	"0495 SLI_FUNCTION_RESET mailbox "
10134	"failed with status x%x add_status x%x,"	10240	"failed with status x%x add_status x%x,"
10135	" mbx status x%x\n",	10241	" mbx status x%x\n",
@@ -10161,7 +10267,7 @@ wait: · 25 unmodified lines
10161	phba->sli4_hba.u.if_type2.ERR1regaddr);	10267	phba->sli4_hba.u.if_type2.ERR1regaddr);
10162	phba->work_status[1] = readl(	10268	phba->work_status[1] = readl(
10163	phba->sli4_hba.u.if_type2.ERR2regaddr);	10269	phba->sli4_hba.u.if_type2.ERR2regaddr);
10164	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	10270	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
10165	"2890 Port not ready, port status reg "	10271	"2890 Port not ready, port status reg "
10166	"0x%x error 1=0x%x, error 2=0x%x\n",	10272	"0x%x error 1=0x%x, error 2=0x%x\n",
10167	reg_data.word0,	10273	reg_data.word0,
@@ -10203,7 +10309,7 @@ wait: · 35 unmodified lines
10203	out:	10309	out:
10204	/* Catch the not-ready port failure after a port reset. */	10310	/* Catch the not-ready port failure after a port reset. */
10205	if (rc) {	10311	if (rc) {
10206	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	10312	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
10207	"3317 HBA not functional: IP Reset Failed "	10313	"3317 HBA not functional: IP Reset Failed "
10208	"try: echo fw_reset > board_mode\n");	10314	"try: echo fw_reset > board_mode\n");
10209	rc = -ENODEV;	10315	rc = -ENODEV;
@@ -10253,7 +10359,7 @@ lpfc_sli4_pci_mem_setup(struct lpfc_hba *phba) · 43 unmodified lines
10253	/* There is no SLI3 failback for SLI4 devices. */	10359	/* There is no SLI3 failback for SLI4 devices. */
10254	if (bf_get(lpfc_sli_intf_valid, &phba->sli4_hba.sli_intf) !=	10360	if (bf_get(lpfc_sli_intf_valid, &phba->sli4_hba.sli_intf) !=
10255	LPFC_SLI_INTF_VALID) {	10361	LPFC_SLI_INTF_VALID) {
10256	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	10362	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
10257	"2894 SLI_INTF reg contents invalid "	10363	"2894 SLI_INTF reg contents invalid "
10258	"sli_intf reg 0x%x\n",	10364	"sli_intf reg 0x%x\n",
10259	phba->sli4_hba.sli_intf.word0);	10365	phba->sli4_hba.sli_intf.word0);
@@ -10528,7 +10634,7 @@ lpfc_sli_enable_msix(struct lpfc_hba *phba) · 268 unmodified lines
10528		10634
10529	if (!pmb) {	10635	if (!pmb) {
10530	rc = -ENOMEM;	10636	rc = -ENOMEM;
10531	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	10637	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
10532	"0474 Unable to allocate memory for issuing "	10638	"0474 Unable to allocate memory for issuing "
10533	"MBOX_CONFIG_MSI command\n");	10639	"MBOX_CONFIG_MSI command\n");
10534	goto mem_fail_out;	10640	goto mem_fail_out;
@@ -10611,6 +10717,7 @@ lpfc_sli_enable_msi(struct lpfc_hba *phba) · 76 unmodified lines
10611	/**	10717	/**
10612	* lpfc_sli_enable_intr - Enable device interrupt to SLI-3 device.	10718	* lpfc_sli_enable_intr - Enable device interrupt to SLI-3 device.
10613	* @phba: pointer to lpfc hba data structure.	10719	* @phba: pointer to lpfc hba data structure.
		10720	* @cfg_mode: Interrupt configuration mode (INTx, MSI or MSI-X).
10614	*	10721	*
10615	* This routine is invoked to enable device interrupt and associate driver's	10722	* This routine is invoked to enable device interrupt and associate driver's
10616	* interrupt handler(s) to interrupt vector(s) to device with SLI-3 interface	10723	* interrupt handler(s) to interrupt vector(s) to device with SLI-3 interface
@@ -11008,7 +11115,7 @@ found_any: · 391 unmodified lines
11008	/* 1 to 1, the first LPFC_CPU_FIRST_IRQ cpus to a unique hdwq */	11115	/* 1 to 1, the first LPFC_CPU_FIRST_IRQ cpus to a unique hdwq */
11009	cpup->hdwq = idx;	11116	cpup->hdwq = idx;
11010	idx++;	11117	idx++;
11011	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	11118	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
11012	"3333 Set Affinity: CPU %d (phys %d core %d): "	11119	"3333 Set Affinity: CPU %d (phys %d core %d): "
11013	"hdwq %d eq %d flg x%x\n",	11120	"hdwq %d eq %d flg x%x\n",
11014	cpu, cpup->phys_id, cpup->core_id,	11121	cpu, cpup->phys_id, cpup->core_id,
@@ -11086,7 +11193,7 @@ found_any: · 71 unmodified lines
11086	start_cpu = first_cpu;	11193	start_cpu = first_cpu;
11087	cpup->hdwq = new_cpup->hdwq;	11194	cpup->hdwq = new_cpup->hdwq;
11088	logit:	11195	logit:
11089	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	11196	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
11090	"3335 Set Affinity: CPU %d (phys %d core %d): "	11197	"3335 Set Affinity: CPU %d (phys %d core %d): "
11091	"hdwq %d eq %d flg x%x\n",	11198	"hdwq %d eq %d flg x%x\n",
11092	cpu, cpup->phys_id, cpup->core_id,	11199	cpu, cpup->phys_id, cpup->core_id,
@@ -11128,7 +11235,7 @@ found_any: · 35 unmodified lines
11128	*	11235	*
11129	* @phba: pointer to lpfc hba data structure.	11236	* @phba: pointer to lpfc hba data structure.
11130	* @cpu: cpu going offline	11237	* @cpu: cpu going offline
11131	* @eqlist:	11238	* @eqlist: eq list to append to
11132	*/	11239	*/
11133	static int	11240	static int
11134	lpfc_cpuhp_get_eq(struct lpfc_hba *phba, unsigned int cpu,	11241	lpfc_cpuhp_get_eq(struct lpfc_hba *phba, unsigned int cpu,
@@ -11417,9 +11524,9 @@ lpfc_sli4_enable_msix(struct lpfc_hba *phba) · 282 unmodified lines
11417	char *name;	11524	char *name;
11418	const struct cpumask *aff_mask = NULL;	11525	const struct cpumask *aff_mask = NULL;
11419	unsigned int cpu = 0, cpu_cnt = 0, cpu_select = nr_cpu_ids;	11526	unsigned int cpu = 0, cpu_cnt = 0, cpu_select = nr_cpu_ids;
		11527	struct lpfc_vector_map_info *cpup;
11420	struct lpfc_hba_eq_hdl *eqhdl;	11528	struct lpfc_hba_eq_hdl *eqhdl;
11421	const struct cpumask *maskp;	11529	const struct cpumask *maskp;
11422	bool first;
11423	unsigned int flags = PCI_IRQ_MSIX;	11530	unsigned int flags = PCI_IRQ_MSIX;
11424		11531
11425	/* Set up MSI-X multi-message vectors */	11532	/* Set up MSI-X multi-message vectors */
@@ -11492,24 +11599,34 @@ lpfc_sli4_enable_msix(struct lpfc_hba *phba) · 66 unmodified lines
11492	} else {	11599	} else {
11493	maskp = pci_irq_get_affinity(phba->pcidev, index);	11600	maskp = pci_irq_get_affinity(phba->pcidev, index);
11494		11601
11495	first = true;
11496	/* Loop through all CPUs associated with vector index */	11602	/* Loop through all CPUs associated with vector index */
11497	for_each_cpu_and(cpu, maskp, cpu_present_mask) {	11603	for_each_cpu_and(cpu, maskp, cpu_present_mask) {
		11604	cpup = &phba->sli4_hba.cpu_map[cpu];
		11605
11498	/* If this is the first CPU thats assigned to	11606	/* If this is the first CPU thats assigned to
11499	* this vector, set LPFC_CPU_FIRST_IRQ.	11607	* this vector, set LPFC_CPU_FIRST_IRQ.
		11608	*
		11609	* With certain platforms its possible that irq
		11610	* vectors are affinitized to all the cpu's.
		11611	* This can result in each cpu_map.eq to be set
		11612	* to the last vector, resulting in overwrite
		11613	* of all the previous cpu_map.eq. Ensure that
		11614	* each vector receives a place in cpu_map.
		11615	* Later call to lpfc_cpu_affinity_check will
		11616	* ensure we are nicely balanced out.
11500	*/	11617	*/
		11618	if (cpup->eq != LPFC_VECTOR_MAP_EMPTY)
		11619	continue;
11501	lpfc_assign_eq_map_info(phba, index,	11620	lpfc_assign_eq_map_info(phba, index,
11502	first ?	11621	LPFC_CPU_FIRST_IRQ,
11503	LPFC_CPU_FIRST_IRQ : 0,
11504	cpu);	11622	cpu);
11505	if (first)	11623	break;
11506	first = false;
11507	}	11624	}
11508	}	11625	}
11509	}	11626	}
11510		11627
11511	if (vectors != phba->cfg_irq_chann) {	11628	if (vectors != phba->cfg_irq_chann) {
11512	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	11629	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
11513	"3238 Reducing IO channels to match number of "	11630	"3238 Reducing IO channels to match number of "
11514	"MSI-X vectors, requested %d got %d\n",	11631	"MSI-X vectors, requested %d got %d\n",
11515	phba->cfg_irq_chann, vectors);	11632	phba->cfg_irq_chann, vectors);
@@ -11593,6 +11710,7 @@ lpfc_sli4_enable_msi(struct lpfc_hba *phba) · 77 unmodified lines
11593	/**	11710	/**
11594	* lpfc_sli4_enable_intr - Enable device interrupt to SLI-4 device	11711	* lpfc_sli4_enable_intr - Enable device interrupt to SLI-4 device
11595	* @phba: pointer to lpfc hba data structure.	11712	* @phba: pointer to lpfc hba data structure.
		11713	* @cfg_mode: Interrupt configuration mode (INTx, MSI or MSI-X).
11596	*	11714	*
11597	* This routine is invoked to enable device interrupt and associate driver's	11715	* This routine is invoked to enable device interrupt and associate driver's
11598	* interrupt handler(s) to interrupt vector(s) to device with SLI-4	11716	* interrupt handler(s) to interrupt vector(s) to device with SLI-4
@@ -11782,17 +11900,17 @@ lpfc_sli4_xri_exchange_busy_wait(struct lpfc_hba *phba) · 183 unmodified lines
11782	while (!els_xri_cmpl \|\| !io_xri_cmpl \|\| !nvmet_xri_cmpl) {	11900	while (!els_xri_cmpl \|\| !io_xri_cmpl \|\| !nvmet_xri_cmpl) {
11783	if (wait_time > LPFC_XRI_EXCH_BUSY_WAIT_TMO) {	11901	if (wait_time > LPFC_XRI_EXCH_BUSY_WAIT_TMO) {
11784	if (!nvmet_xri_cmpl)	11902	if (!nvmet_xri_cmpl)
11785	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	11903	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
11786	"6424 NVMET XRI exchange busy "	11904	"6424 NVMET XRI exchange busy "
11787	"wait time: %d seconds.\n",	11905	"wait time: %d seconds.\n",
11788	wait_time/1000);	11906	wait_time/1000);
11789	if (!io_xri_cmpl)	11907	if (!io_xri_cmpl)
11790	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	11908	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
11791	"6100 IO XRI exchange busy "	11909	"6100 IO XRI exchange busy "
11792	"wait time: %d seconds.\n",	11910	"wait time: %d seconds.\n",
11793	wait_time/1000);	11911	wait_time/1000);
11794	if (!els_xri_cmpl)	11912	if (!els_xri_cmpl)
11795	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	11913	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
11796	"2878 ELS XRI exchange busy "	11914	"2878 ELS XRI exchange busy "
11797	"wait time: %d seconds.\n",	11915	"wait time: %d seconds.\n",
11798	wait_time/1000);	11916	wait_time/1000);
@@ -12287,14 +12405,14 @@ lpfc_pci_probe_one_s3(struct pci_dev pdev, const struct pci_device_id pid) · 488 unmodified lines
12287	/* Configure and enable interrupt */	12405	/* Configure and enable interrupt */
12288	intr_mode = lpfc_sli_enable_intr(phba, cfg_mode);	12406	intr_mode = lpfc_sli_enable_intr(phba, cfg_mode);
12289	if (intr_mode == LPFC_INTR_ERROR) {	12407	if (intr_mode == LPFC_INTR_ERROR) {
12290	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	12408	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
12291	"0431 Failed to enable interrupt.\n");	12409	"0431 Failed to enable interrupt.\n");
12292	error = -ENODEV;	12410	error = -ENODEV;
12293	goto out_free_sysfs_attr;	12411	goto out_free_sysfs_attr;
12294	}	12412	}
12295	/* SLI-3 HBA setup */	12413	/* SLI-3 HBA setup */
12296	if (lpfc_sli_hba_setup(phba)) {	12414	if (lpfc_sli_hba_setup(phba)) {
12297	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	12415	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
12298	"1477 Failed to set up hba\n");	12416	"1477 Failed to set up hba\n");
12299	error = -ENODEV;	12417	error = -ENODEV;
12300	goto out_remove_device;	12418	goto out_remove_device;
@@ -12552,7 +12670,7 @@ lpfc_pci_resume_one_s3(struct pci_dev *pdev) · 251 unmodified lines
12552	/* Configure and enable interrupt */	12670	/* Configure and enable interrupt */
12553	intr_mode = lpfc_sli_enable_intr(phba, phba->intr_mode);	12671	intr_mode = lpfc_sli_enable_intr(phba, phba->intr_mode);
12554	if (intr_mode == LPFC_INTR_ERROR) {	12672	if (intr_mode == LPFC_INTR_ERROR) {
12555	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	12673	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
12556	"0430 PM resume Failed to enable interrupt\n");	12674	"0430 PM resume Failed to enable interrupt\n");
12557	return -EIO;	12675	return -EIO;
12558	} else	12676	} else
@@ -12578,7 +12696,7 @@ lpfc_pci_resume_one_s3(struct pci_dev *pdev) · 19 unmodified lines
12578	static void	12696	static void
12579	lpfc_sli_prep_dev_for_recover(struct lpfc_hba *phba)	12697	lpfc_sli_prep_dev_for_recover(struct lpfc_hba *phba)
12580	{	12698	{
12581	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	12699	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
12582	"2723 PCI channel I/O abort preparing for recovery\n");	12700	"2723 PCI channel I/O abort preparing for recovery\n");
12583		12701
12584	/*	12702	/*
@@ -12599,7 +12717,7 @@ lpfc_sli_prep_dev_for_recover(struct lpfc_hba *phba) · 14 unmodified lines
12599	static void	12717	static void
12600	lpfc_sli_prep_dev_for_reset(struct lpfc_hba *phba)	12718	lpfc_sli_prep_dev_for_reset(struct lpfc_hba *phba)
12601	{	12719	{
12602	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	12720	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
12603	"2710 PCI channel disable preparing for reset\n");	12721	"2710 PCI channel disable preparing for reset\n");
12604		12722
12605	/* Block any management I/Os to the device */	12723	/* Block any management I/Os to the device */
@@ -12630,7 +12748,7 @@ lpfc_sli_prep_dev_for_reset(struct lpfc_hba *phba) · 24 unmodified lines
12630	static void	12748	static void
12631	lpfc_sli_prep_dev_for_perm_failure(struct lpfc_hba *phba)	12749	lpfc_sli_prep_dev_for_perm_failure(struct lpfc_hba *phba)
12632	{	12750	{
12633	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	12751	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
12634	"2711 PCI channel permanent disable for failure\n");	12752	"2711 PCI channel permanent disable for failure\n");
12635	/* Block all SCSI devices' I/Os on the host */	12753	/* Block all SCSI devices' I/Os on the host */
12636	lpfc_scsi_dev_block(phba);	12754	lpfc_scsi_dev_block(phba);
@@ -12681,7 +12799,7 @@ lpfc_io_error_detected_s3(struct pci_dev *pdev, pci_channel_state_t state) · 44 unmodified lines
12681	return PCI_ERS_RESULT_DISCONNECT;	12799	return PCI_ERS_RESULT_DISCONNECT;
12682	default:	12800	default:
12683	/* Unknown state, prepare and request slot reset */	12801	/* Unknown state, prepare and request slot reset */
12684	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	12802	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
12685	"0472 Unknown PCI error state: x%x\n", state);	12803	"0472 Unknown PCI error state: x%x\n", state);
12686	lpfc_sli_prep_dev_for_reset(phba);	12804	lpfc_sli_prep_dev_for_reset(phba);
12687	return PCI_ERS_RESULT_NEED_RESET;	12805	return PCI_ERS_RESULT_NEED_RESET;
@@ -12739,7 +12857,7 @@ lpfc_io_slot_reset_s3(struct pci_dev *pdev) · 51 unmodified lines
12739	/* Configure and enable interrupt */	12857	/* Configure and enable interrupt */
12740	intr_mode = lpfc_sli_enable_intr(phba, phba->intr_mode);	12858	intr_mode = lpfc_sli_enable_intr(phba, phba->intr_mode);
12741	if (intr_mode == LPFC_INTR_ERROR) {	12859	if (intr_mode == LPFC_INTR_ERROR) {
12742	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	12860	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
12743	"0427 Cannot re-enable interrupt after "	12861	"0427 Cannot re-enable interrupt after "
12744	"slot reset.\n");	12862	"slot reset.\n");
12745	return PCI_ERS_RESULT_DISCONNECT;	12863	return PCI_ERS_RESULT_DISCONNECT;
@@ -12842,7 +12960,7 @@ lpfc_log_write_firmware_error(struct lpfc_hba *phba, uint32_t offset, · 96 unmodified lines
12842	magic_number != MAGIC_NUMBER_G6) \|\|	12960	magic_number != MAGIC_NUMBER_G6) \|\|
12843	(phba->pcidev->device == PCI_DEVICE_ID_LANCER_G7_FC &&	12961	(phba->pcidev->device == PCI_DEVICE_ID_LANCER_G7_FC &&
12844	magic_number != MAGIC_NUMBER_G7)) {	12962	magic_number != MAGIC_NUMBER_G7)) {
12845	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	12963	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
12846	"3030 This firmware version is not supported on"	12964	"3030 This firmware version is not supported on"
12847	" this HBA model. Device:%x Magic:%x Type:%x "	12965	" this HBA model. Device:%x Magic:%x Type:%x "
12848	"ID:%x Size %d %zd\n",	12966	"ID:%x Size %d %zd\n",
@@ -12850,7 +12968,7 @@ lpfc_log_write_firmware_error(struct lpfc_hba *phba, uint32_t offset, · 1 unmodified line
12850	fsize, fw->size);	12968	fsize, fw->size);
12851	rc = -EINVAL;	12969	rc = -EINVAL;
12852	} else if (offset == ADD_STATUS_FW_DOWNLOAD_HW_DISABLED) {	12970	} else if (offset == ADD_STATUS_FW_DOWNLOAD_HW_DISABLED) {
12853	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	12971	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
12854	"3021 Firmware downloads have been prohibited "	12972	"3021 Firmware downloads have been prohibited "
12855	"by a system configuration setting on "	12973	"by a system configuration setting on "
12856	"Device:%x Magic:%x Type:%x ID:%x Size %d "	12974	"Device:%x Magic:%x Type:%x ID:%x Size %d "
@@ -12859,7 +12977,7 @@ lpfc_log_write_firmware_error(struct lpfc_hba *phba, uint32_t offset, · 2 unmodified lines
12859	fsize, fw->size);	12977	fsize, fw->size);
12860	rc = -EACCES;	12978	rc = -EACCES;
12861	} else {	12979	} else {
12862	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	12980	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
12863	"3022 FW Download failed. Add Status x%x "	12981	"3022 FW Download failed. Add Status x%x "
12864	"Device:%x Magic:%x Type:%x ID:%x Size %d "	12982	"Device:%x Magic:%x Type:%x ID:%x Size %d "
12865	"%zd\n",	12983	"%zd\n",
@@ -12874,7 +12992,6 @@ lpfc_log_write_firmware_error(struct lpfc_hba *phba, uint32_t offset, · 8 unmodified lines
12874	* lpfc_write_firmware - attempt to write a firmware image to the port	12992	* lpfc_write_firmware - attempt to write a firmware image to the port
12875	* @fw: pointer to firmware image returned from request_firmware.	12993	* @fw: pointer to firmware image returned from request_firmware.
12876	* @context: pointer to firmware image returned from request_firmware.	12994	* @context: pointer to firmware image returned from request_firmware.
12877	* @ret: return value this routine provides to the caller.
12878	*	12995	*
12879	**/	12996	**/
12880	static void	12997	static void
@@ -12904,7 +13021,7 @@ lpfc_write_firmware(const struct firmware fw, void context) · 23 unmodified lines
12904	INIT_LIST_HEAD(&dma_buffer_list);	13021	INIT_LIST_HEAD(&dma_buffer_list);
12905	lpfc_decode_firmware_rev(phba, fwrev, 1);	13022	lpfc_decode_firmware_rev(phba, fwrev, 1);
12906	if (strncmp(fwrev, image->revision, strnlen(image->revision, 16))) {	13023	if (strncmp(fwrev, image->revision, strnlen(image->revision, 16))) {
12907	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13024	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
12908	"3023 Updating Firmware, Current Version:%s "	13025	"3023 Updating Firmware, Current Version:%s "
12909	"New Version:%s\n",	13026	"New Version:%s\n",
12910	fwrev, image->revision);	13027	fwrev, image->revision);
@@ -12954,7 +13071,7 @@ lpfc_write_firmware(const struct firmware fw, void context) · 43 unmodified lines
12954	}	13071	}
12955	rc = offset;	13072	rc = offset;
12956	} else	13073	} else
12957	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13074	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
12958	"3029 Skipped Firmware update, Current "	13075	"3029 Skipped Firmware update, Current "
12959	"Version:%s New Version:%s\n",	13076	"Version:%s New Version:%s\n",
12960	fwrev, image->revision);	13077	fwrev, image->revision);
@@ -12969,16 +13086,17 @@ release_out: · 8 unmodified lines
12969	release_firmware(fw);	13086	release_firmware(fw);
12970	out:	13087	out:
12971	if (rc < 0)	13088	if (rc < 0)
12972	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13089	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
12973	"3062 Firmware update error, status %d.\n", rc);	13090	"3062 Firmware update error, status %d.\n", rc);
12974	else	13091	else
12975	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13092	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
12976	"3024 Firmware update success: size %d.\n", rc);	13093	"3024 Firmware update success: size %d.\n", rc);
12977	}	13094	}
12978		13095
12979	/**	13096	/**
12980	* lpfc_sli4_request_firmware_update - Request linux generic firmware upgrade	13097	* lpfc_sli4_request_firmware_update - Request linux generic firmware upgrade
12981	* @phba: pointer to lpfc hba data structure.	13098	* @phba: pointer to lpfc hba data structure.
		13099	* @fw_upgrade: which firmware to update.
12982	*	13100	*
12983	* This routine is called to perform Linux generic firmware upgrade on device	13101	* This routine is called to perform Linux generic firmware upgrade on device
12984	* that supports such feature.	13102	* that supports such feature.
@@ -13101,7 +13219,7 @@ lpfc_pci_probe_one_s4(struct pci_dev pdev, const struct pci_device_id pid) · 116 unmodified lines
13101	/* Configure and enable interrupt */	13219	/* Configure and enable interrupt */
13102	intr_mode = lpfc_sli4_enable_intr(phba, cfg_mode);	13220	intr_mode = lpfc_sli4_enable_intr(phba, cfg_mode);
13103	if (intr_mode == LPFC_INTR_ERROR) {	13221	if (intr_mode == LPFC_INTR_ERROR) {
13104	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13222	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
13105	"0426 Failed to enable interrupt.\n");	13223	"0426 Failed to enable interrupt.\n");
13106	error = -ENODEV;	13224	error = -ENODEV;
13107	goto out_unset_driver_resource;	13225	goto out_unset_driver_resource;
@@ -13136,7 +13254,7 @@ lpfc_pci_probe_one_s4(struct pci_dev pdev, const struct pci_device_id pid) · 28 unmodified lines
13136		13254
13137	/* Set up SLI-4 HBA */	13255	/* Set up SLI-4 HBA */
13138	if (lpfc_sli4_hba_setup(phba)) {	13256	if (lpfc_sli4_hba_setup(phba)) {
13139	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13257	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
13140	"1421 Failed to set up hba\n");	13258	"1421 Failed to set up hba\n");
13141	error = -ENODEV;	13259	error = -ENODEV;
13142	goto out_free_sysfs_attr;	13260	goto out_free_sysfs_attr;
@@ -13161,7 +13279,7 @@ lpfc_pci_probe_one_s4(struct pci_dev pdev, const struct pci_device_id pid) · 18 unmodified lines
13161	*/	13279	*/
13162	error = lpfc_nvme_create_localport(vport);	13280	error = lpfc_nvme_create_localport(vport);
13163	if (error) {	13281	if (error) {
13164	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13282	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
13165	"6004 NVME registration "	13283	"6004 NVME registration "
13166	"failed, error x%x\n",	13284	"failed, error x%x\n",
13167	error);	13285	error);
@@ -13395,7 +13513,7 @@ lpfc_pci_resume_one_s4(struct pci_dev *pdev) · 227 unmodified lines
13395	/* Configure and enable interrupt */	13513	/* Configure and enable interrupt */
13396	intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);	13514	intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);
13397	if (intr_mode == LPFC_INTR_ERROR) {	13515	if (intr_mode == LPFC_INTR_ERROR) {
13398	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13516	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
13399	"0294 PM resume Failed to enable interrupt\n");	13517	"0294 PM resume Failed to enable interrupt\n");
13400	return -EIO;	13518	return -EIO;
13401	} else	13519	} else
@@ -13421,7 +13539,7 @@ lpfc_pci_resume_one_s4(struct pci_dev *pdev) · 19 unmodified lines
13421	static void	13539	static void
13422	lpfc_sli4_prep_dev_for_recover(struct lpfc_hba *phba)	13540	lpfc_sli4_prep_dev_for_recover(struct lpfc_hba *phba)
13423	{	13541	{
13424	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13542	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
13425	"2828 PCI channel I/O abort preparing for recovery\n");	13543	"2828 PCI channel I/O abort preparing for recovery\n");
13426	/*	13544	/*
13427	* There may be errored I/Os through HBA, abort all I/Os on txcmplq	13545	* There may be errored I/Os through HBA, abort all I/Os on txcmplq
@@ -13441,7 +13559,7 @@ lpfc_sli4_prep_dev_for_recover(struct lpfc_hba *phba) · 13 unmodified lines
13441	static void	13559	static void
13442	lpfc_sli4_prep_dev_for_reset(struct lpfc_hba *phba)	13560	lpfc_sli4_prep_dev_for_reset(struct lpfc_hba *phba)
13443	{	13561	{
13444	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13562	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
13445	"2826 PCI channel disable preparing for reset\n");	13563	"2826 PCI channel disable preparing for reset\n");
13446		13564
13447	/* Block any management I/Os to the device */	13565	/* Block any management I/Os to the device */
@@ -13473,7 +13591,7 @@ lpfc_sli4_prep_dev_for_reset(struct lpfc_hba *phba) · 25 unmodified lines
13473	static void	13591	static void
13474	lpfc_sli4_prep_dev_for_perm_failure(struct lpfc_hba *phba)	13592	lpfc_sli4_prep_dev_for_perm_failure(struct lpfc_hba *phba)
13475	{	13593	{
13476	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13594	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
13477	"2827 PCI channel permanent disable for failure\n");	13595	"2827 PCI channel permanent disable for failure\n");
13478		13596
13479	/* Block all SCSI devices' I/Os on the host */	13597	/* Block all SCSI devices' I/Os on the host */
@@ -13523,7 +13641,7 @@ lpfc_io_error_detected_s4(struct pci_dev *pdev, pci_channel_state_t state) · 43 unmodified lines
13523	return PCI_ERS_RESULT_DISCONNECT;	13641	return PCI_ERS_RESULT_DISCONNECT;
13524	default:	13642	default:
13525	/* Unknown state, prepare and request slot reset */	13643	/* Unknown state, prepare and request slot reset */
13526	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13644	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
13527	"2825 Unknown PCI error state: x%x\n", state);	13645	"2825 Unknown PCI error state: x%x\n", state);
13528	lpfc_sli4_prep_dev_for_reset(phba);	13646	lpfc_sli4_prep_dev_for_reset(phba);
13529	return PCI_ERS_RESULT_NEED_RESET;	13647	return PCI_ERS_RESULT_NEED_RESET;
@@ -13581,7 +13699,7 @@ lpfc_io_slot_reset_s4(struct pci_dev *pdev) · 51 unmodified lines
13581	/* Configure and enable interrupt */	13699	/* Configure and enable interrupt */
13582	intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);	13700	intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);
13583	if (intr_mode == LPFC_INTR_ERROR) {	13701	if (intr_mode == LPFC_INTR_ERROR) {
13584	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13702	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
13585	"2824 Cannot re-enable interrupt after "	13703	"2824 Cannot re-enable interrupt after "
13586	"slot reset.\n");	13704	"slot reset.\n");
13587	return PCI_ERS_RESULT_DISCONNECT;	13705	return PCI_ERS_RESULT_DISCONNECT;
@@ -13686,7 +13804,7 @@ lpfc_pci_remove_one(struct pci_dev *pdev) · 98 unmodified lines
13686	lpfc_pci_remove_one_s4(pdev);	13804	lpfc_pci_remove_one_s4(pdev);
13687	break;	13805	break;
13688	default:	13806	default:
13689	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13807	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
13690	"1424 Invalid PCI device group: 0x%x\n",	13808	"1424 Invalid PCI device group: 0x%x\n",
13691	phba->pci_dev_grp);	13809	phba->pci_dev_grp);
13692	break;	13810	break;
@@ -13723,7 +13841,7 @@ lpfc_pci_suspend_one(struct pci_dev *pdev, pm_message_t msg) · 30 unmodified lines
13723	rc = lpfc_pci_suspend_one_s4(pdev, msg);	13841	rc = lpfc_pci_suspend_one_s4(pdev, msg);
13724	break;	13842	break;
13725	default:	13843	default:
13726	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13844	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
13727	"1425 Invalid PCI device group: 0x%x\n",	13845	"1425 Invalid PCI device group: 0x%x\n",
13728	phba->pci_dev_grp);	13846	phba->pci_dev_grp);
13729	break;	13847	break;
@@ -13759,7 +13877,7 @@ lpfc_pci_resume_one(struct pci_dev *pdev) · 29 unmodified lines
13759	rc = lpfc_pci_resume_one_s4(pdev);	13877	rc = lpfc_pci_resume_one_s4(pdev);
13760	break;	13878	break;
13761	default:	13879	default:
13762	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13880	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
13763	"1426 Invalid PCI device group: 0x%x\n",	13881	"1426 Invalid PCI device group: 0x%x\n",
13764	phba->pci_dev_grp);	13882	phba->pci_dev_grp);
13765	break;	13883	break;
@@ -13797,7 +13915,7 @@ lpfc_io_error_detected(struct pci_dev *pdev, pci_channel_state_t state) · 31 unmodified lines
13797	rc = lpfc_io_error_detected_s4(pdev, state);	13915	rc = lpfc_io_error_detected_s4(pdev, state);
13798	break;	13916	break;
13799	default:	13917	default:
13800	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13918	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
13801	"1427 Invalid PCI device group: 0x%x\n",	13919	"1427 Invalid PCI device group: 0x%x\n",
13802	phba->pci_dev_grp);	13920	phba->pci_dev_grp);
13803	break;	13921	break;
@@ -13834,7 +13952,7 @@ lpfc_io_slot_reset(struct pci_dev *pdev) · 30 unmodified lines
13834	rc = lpfc_io_slot_reset_s4(pdev);	13952	rc = lpfc_io_slot_reset_s4(pdev);
13835	break;	13953	break;
13836	default:	13954	default:
13837	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13955	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
13838	"1428 Invalid PCI device group: 0x%x\n",	13956	"1428 Invalid PCI device group: 0x%x\n",
13839	phba->pci_dev_grp);	13957	phba->pci_dev_grp);
13840	break;	13958	break;
@@ -13866,7 +13984,7 @@ lpfc_io_resume(struct pci_dev *pdev) · 25 unmodified lines
13866	lpfc_io_resume_s4(pdev);	13984	lpfc_io_resume_s4(pdev);
13867	break;	13985	break;
13868	default:	13986	default:
13869	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,	13987	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
13870	"1429 Invalid PCI device group: 0x%x\n",	13988	"1429 Invalid PCI device group: 0x%x\n",
13871	phba->pci_dev_grp);	13989	phba->pci_dev_grp);
13872	break;	13990	break;
@@ -13974,8 +14092,8 @@ lpfc_init(void) · 101 unmodified lines
13974	{	14092	{
13975	int error = 0;	14093	int error = 0;
13976		14094
13977	printk(LPFC_MODULE_DESC "\n");	14095	pr_info(LPFC_MODULE_DESC "\n");
13978	printk(LPFC_COPYRIGHT "\n");	14096	pr_info(LPFC_COPYRIGHT "\n");
13979		14097
13980	error = misc_register(&lpfc_mgmt_dev);	14098	error = misc_register(&lpfc_mgmt_dev);
13981	if (error)	14099	if (error)
@@ -14022,6 +14140,85 @@ cpuhp_failure: · 40 unmodified lines
14022	return error;	14140	return error;
14023	}	14141	}
14024		14142
		14143	void lpfc_dmp_dbg(struct lpfc_hba *phba)
		14144	{
		14145	unsigned int start_idx;
		14146	unsigned int dbg_cnt;
		14147	unsigned int temp_idx;
		14148	int i;
		14149	int j = 0;
		14150	unsigned long rem_nsec;
		14151
		14152	if (phba->cfg_log_verbose)
		14153	return;
		14154
		14155	if (atomic_cmpxchg(&phba->dbg_log_dmping, 0, 1) != 0)
		14156	return;
		14157
		14158	start_idx = (unsigned int)atomic_read(&phba->dbg_log_idx) % DBG_LOG_SZ;
		14159	dbg_cnt = (unsigned int)atomic_read(&phba->dbg_log_cnt);
		14160	temp_idx = start_idx;
		14161	if (dbg_cnt >= DBG_LOG_SZ) {
		14162	dbg_cnt = DBG_LOG_SZ;
		14163	temp_idx -= 1;
		14164	} else {
		14165	if ((start_idx + dbg_cnt) > (DBG_LOG_SZ - 1)) {
		14166	temp_idx = (start_idx + dbg_cnt) % DBG_LOG_SZ;
		14167	} else {
		14168	if (start_idx < dbg_cnt)
		14169	start_idx = DBG_LOG_SZ - (dbg_cnt - start_idx);
		14170	else
		14171	start_idx -= dbg_cnt;
		14172	}
		14173	}
		14174	dev_info(&phba->pcidev->dev, "start %d end %d cnt %d\n",
		14175	start_idx, temp_idx, dbg_cnt);
		14176
		14177	for (i = 0; i < dbg_cnt; i++) {
		14178	if ((start_idx + i) < DBG_LOG_SZ)
		14179	temp_idx = (start_idx + i) % DBG_LOG_SZ;
		14180	else
		14181	temp_idx = j++;
		14182	rem_nsec = do_div(phba->dbg_log[temp_idx].t_ns, NSEC_PER_SEC);
		14183	dev_info(&phba->pcidev->dev, "%d: [%5lu.%06lu] %s",
		14184	temp_idx,
		14185	(unsigned long)phba->dbg_log[temp_idx].t_ns,
		14186	rem_nsec / 1000,
		14187	phba->dbg_log[temp_idx].log);
		14188	}
		14189	atomic_set(&phba->dbg_log_cnt, 0);
		14190	atomic_set(&phba->dbg_log_dmping, 0);
		14191	}
		14192
		14193	__printf(2, 3)
		14194	void lpfc_dbg_print(struct lpfc_hba phba, const char fmt, ...)
		14195	{
		14196	unsigned int idx;
		14197	va_list args;
		14198	int dbg_dmping = atomic_read(&phba->dbg_log_dmping);
		14199	struct va_format vaf;
		14200
		14201
		14202	va_start(args, fmt);
		14203	if (unlikely(dbg_dmping)) {
		14204	vaf.fmt = fmt;
		14205	vaf.va = &args;
		14206	dev_info(&phba->pcidev->dev, "%pV", &vaf);
		14207	va_end(args);
		14208	return;
		14209	}
		14210	idx = (unsigned int)atomic_fetch_add(1, &phba->dbg_log_idx) %
		14211	DBG_LOG_SZ;
		14212
		14213	atomic_inc(&phba->dbg_log_cnt);
		14214
		14215	vscnprintf(phba->dbg_log[idx].log,
		14216	sizeof(phba->dbg_log[idx].log), fmt, args);
		14217	va_end(args);
		14218
		14219	phba->dbg_log[idx].t_ns = local_clock();
		14220	}
		14221
14025	/**	14222	/**
14026	* lpfc_exit - lpfc module removal routine	14223	* lpfc_exit - lpfc module removal routine
14027	*	14224	*

drivers/scsi/lpfc/lpfc_logmsg.h+19−5

 #define LOG_NVME_DISC   0x00200000      /* NVME Discovery/Connect events. */
 #define LOG_NVME_ABTS   0x00400000      /* NVME ABTS events. */
 #define LOG_NVME_IOERR  0x00800000      /* NVME IO Error events. */
-#define LOG_ALL_MSG	0xffffffff	/* LOG all messages */
+#define LOG_TRACE_EVENT 0x80000000	/* Dmp the DBG log on this err */
+#define LOG_ALL_MSG	0x7fffffff	/* LOG all messages */
+void lpfc_dmp_dbg(struct lpfc_hba *phba);
+void lpfc_dbg_print(struct lpfc_hba *phba, const char *fmt, ...);
 /* generate message by verbose log setting or severity */
 #define lpfc_vlog_msg(vport, level, mask, fmt, arg...) \
 #define lpfc_printf_vlog(vport, level, mask, fmt, arg...) \
 do { \
-	{ if (((mask) & (vport)->cfg_log_verbose) || (level[1] <= '3')) \
+	{ if (((mask) & (vport)->cfg_log_verbose) || (level[1] <= '3')) { \
+		if ((mask) & LOG_TRACE_EVENT) \
+			lpfc_dmp_dbg((vport)->phba); \
 		dev_printk(level, &((vport)->phba->pcidev)->dev, "%d:(%d):" \
-			   fmt, (vport)->phba->brd_no, vport->vpi, ##arg); } \
+			   fmt, (vport)->phba->brd_no, vport->vpi, ##arg);  \
+		} else if (!(vport)->cfg_log_verbose) \
+			lpfc_dbg_print((vport)->phba, "%d:(%d):" fmt, \
+				(vport)->phba->brd_no, (vport)->vpi, ##arg); \
+	} \
 } while (0)
 #define lpfc_printf_log(phba, level, mask, fmt, arg...) \
 	{ uint32_t log_verbose = (phba)->pport ? \
 				 (phba)->pport->cfg_log_verbose : \
 				 (phba)->cfg_log_verbose; \
-	  if (((mask) & log_verbose) || (level[1] <= '3')) \
+	if (((mask) & log_verbose) || (level[1] <= '3')) { \
+		if ((mask) & LOG_TRACE_EVENT) \
+			lpfc_dmp_dbg(phba); \
 		dev_printk(level, &((phba)->pcidev)->dev, "%d:" \
-			   fmt, phba->brd_no, ##arg); \
+			fmt, phba->brd_no, ##arg); \
+	} else  if (!(phba)->cfg_log_verbose)\
+		lpfc_dbg_print(phba, "%d:" fmt, phba->brd_no, ##arg); \
 	} \
 } while (0)

drivers/scsi/lpfc/lpfc_mbox.c+7−5

 /**
  * lpfc_reg_vpi - Prepare a mailbox command for registering vport identifier
- * @phba: pointer to lpfc hba data structure.
+ * @vport: pointer to a vport object.
- * @vpi: virtual N_Port identifier.
- * @sid: Fibre Channel S_ID (N_Port_ID assigned to a virtual N_Port).
  * @pmb: pointer to the driver internal queue element for mailbox command.
  *
  * The registration vport identifier mailbox command is used to activate a
 /**
  * lpfc_config_ring - Prepare a mailbox command for configuring an IOCB ring
  * @phba: pointer to lpfc hba data structure.
- * @ring:
+ * @ring: ring number/index
  * @pmb: pointer to the driver internal queue element for mailbox command.
  *
  * The configure ring mailbox command is used to configure an IOCB ring. This
 /**
  * lpfc_mbox_tmo_val - Retrieve mailbox command timeout value
  * @phba: pointer to lpfc hba data structure.
- * @cmd: mailbox command code.
+ * @mboxq: pointer to the driver internal queue element for mailbox command.
  *
  * This routine retrieves the proper timeout value according to the mailbox
  * command code.
  * lpfc_sli4_mbx_sge_get - Get a sge entry from non-embedded mailbox command
  * @mbox: pointer to lpfc mbox command.
  * @sgentry: sge entry index.
+ * @sge: pointer to lpfc mailbox sge to load into.
  *
  * This routine gets an entry from the non-embedded mailbox command at the sge
  * index location.
  * @subsystem: The sli4 config sub mailbox subsystem.
  * @opcode: The sli4 config sub mailbox command opcode.
  * @length: Length of the sli4 config mailbox command (including sub-header).
+ * @emb: True if embedded mbox command should be setup.
  *
  * This routine sets up the header fields of SLI4 specific mailbox command
  * for sending IOCTL command.
 /**
  * lpfc_sli4_mbx_read_fcf_rec - Allocate and construct read fcf mbox cmd
  * @phba: pointer to lpfc hba data structure.
+ * @mboxq: pointer to lpfc mbox command.
  * @fcf_index: index to fcf table.
  *
  * This routine routine allocates and constructs non-embedded mailbox command
 /**
  * lpfc_request_features: Configure SLI4 REQUEST_FEATURES mailbox
+ * @phba: pointer to lpfc hba data structure.
  * @mboxq: pointer to lpfc mbox command.
  *
  * This routine sets up the mailbox for an SLI4 REQUEST_FEATURES

drivers/scsi/lpfc/lpfc_mem.c+3−1

 #define LPFC_MBUF_POOL_SIZE     64      /* max elements in MBUF safety pool */
 #define LPFC_MEM_POOL_SIZE      64      /* max elem in non-DMA safety pool */
 #define LPFC_DEVICE_DATA_POOL_SIZE 64   /* max elements in device data pool */
+#define LPFC_RRQ_POOL_SIZE	256	/* max elements in non-DMA  pool */
 int
 lpfc_mem_alloc_active_rrq_pool_s4(struct lpfc_hba *phba) {
 /**
  * lpfc_mem_alloc - create and allocate all PCI and memory pools
  * @phba: HBA to allocate pools for
+ * @align: alignment requirement for blocks; must be a power of two
  *
  * Description: Creates and allocates PCI pools lpfc_mbuf_pool,
  * lpfc_hrb_pool.  Creates and allocates kmalloc-backed mempools
 	if (phba->sli_rev == LPFC_SLI_REV4) {
 		phba->rrq_pool =
-			mempool_create_kmalloc_pool(LPFC_MEM_POOL_SIZE,
+			mempool_create_kmalloc_pool(LPFC_RRQ_POOL_SIZE,
 						sizeof(struct lpfc_node_rrq));
 		if (!phba->rrq_pool)
 			goto fail_free_nlp_mem_pool;

drivers/scsi/lpfc/lpfc_nportdisc.c+38−30

 	memcpy(&ndlp->nlp_portname, &sp->portName, sizeof (struct lpfc_name));
 	return 1;
 bad_service_param:
-	lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
+	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			 "0207 Device %x "
 			 "(%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x) sent "
 			 "invalid service parameters.  Ignoring device.\n",
 	/* Check for CONFIG_LINK error */
 	if (mb->mbxStatus) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"4575 CONFIG_LINK fails pt2pt discovery: %x\n",
 				mb->mbxStatus);
 		mempool_free(login_mbox, phba->mbox_mem_pool);
 	rc = lpfc_els_rsp_acc(link_mbox->vport, ELS_CMD_PLOGI,
 			      save_iocb, ndlp, login_mbox);
 	if (rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"4576 PLOGI ACC fails pt2pt discovery: %x\n",
 				rc);
 		mempool_free(login_mbox, phba->mbox_mem_pool);
 	lpfc_sli4_unreg_rpi_cmpl_clr(phba, pmb);
 	if (!piocb) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY | LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "4578 PLOGI ACC fail\n");
 		if (mbox)
 			mempool_free(mbox, phba->mbox_mem_pool);
 	rc = lpfc_els_rsp_acc(vport, ELS_CMD_PLOGI, piocb, ndlp, mbox);
 	if (rc) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY | LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "4579 PLOGI ACC fail %x\n", rc);
 		if (mbox)
 			mempool_free(mbox, phba->mbox_mem_pool);
 	lp = (uint32_t *) pcmd->virt;
 	sp = (struct serv_parm *) ((uint8_t *) lp + sizeof (uint32_t));
 	if (wwn_to_u64(sp->portName.u.wwn) == 0) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0140 PLOGI Reject: invalid nname\n");
 		stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
 		stat.un.b.lsRjtRsnCodeExp = LSEXP_INVALID_PNAME;
 		return 0;
 	}
 	if (wwn_to_u64(sp->nodeName.u.wwn) == 0) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0141 PLOGI Reject: invalid pname\n");
 		stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
 		stat.un.b.lsRjtRsnCodeExp = LSEXP_INVALID_NNAME;
 		}
 		if (nlp_portwwn != 0 &&
 		    nlp_portwwn != wwn_to_u64(sp->portName.u.wwn))
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 					 "0143 PLOGI recv'd from DID: x%x "
 					 "WWPN changed: old %llx new %llx\n",
 					 ndlp->nlp_DID,
 	return 1;
 out:
 	if (defer_acc)
-		lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"4577 discovery failure: %p %p %p\n",
 				save_iocb, link_mbox, login_mbox);
 	kfree(save_iocb);
 				ndlp, NULL);
 		}
 out:
-		/* If we are authenticated, move to the proper state */
+		/* If we are authenticated, move to the proper state.
-		if (ndlp->nlp_type & (NLP_FCP_TARGET | NLP_NVME_TARGET))
+		 * It is possible an ADISC arrived and the remote nport
-			lpfc_nlp_set_state(vport, ndlp, NLP_STE_MAPPED_NODE);
+		 * is already in MAPPED or UNMAPPED state.  Catch this
-		else
+		 * condition and don't set the nlp_state again because
-			lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
+		 * it causes an unnecessary transport unregister/register.
+		 */
+		if (ndlp->nlp_type & (NLP_FCP_TARGET | NLP_NVME_TARGET)) {
+			if (ndlp->nlp_state != NLP_STE_MAPPED_NODE)
+				lpfc_nlp_set_state(vport, ndlp,
+						   NLP_STE_MAPPED_NODE);
+		}
 		return 1;
 	}
  * lpfc_release_rpi - Release a RPI by issuing unreg_login mailbox cmd.
  * @phba : Pointer to lpfc_hba structure.
  * @vport: Pointer to lpfc_vport structure.
+ * @ndlp: Pointer to lpfc_nodelist structure.
  * @rpi  : rpi to be release.
  *
  * This function will send a unreg_login mailbox command to the firmware
 	pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
 			GFP_KERNEL);
 	if (!pmb)
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-			"2796 mailbox memory allocation failed \n");
+				 "2796 mailbox memory allocation failed \n");
 	else {
 		lpfc_unreg_login(phba, vport->vpi, rpi, pmb);
 		pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 		rpi = pmb->u.mb.un.varWords[0];
 		lpfc_release_rpi(phba, vport, ndlp, rpi);
 	}
-	lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
+	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			 "0271 Illegal State Transition: node x%x "
 			 "event x%x, state x%x Data: x%x x%x\n",
 			 ndlp->nlp_DID, evt, ndlp->nlp_state, ndlp->nlp_rpi,
 	 * to stop it.
 	 */
 	if (!(ndlp->nlp_flag & NLP_RCV_PLOGI)) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-			 "0272 Illegal State Transition: node x%x "
+				 "0272 Illegal State Transition: node x%x "
-			 "event x%x, state x%x Data: x%x x%x\n",
+				 "event x%x, state x%x Data: x%x x%x\n",
-			 ndlp->nlp_DID, evt, ndlp->nlp_state, ndlp->nlp_rpi,
+				  ndlp->nlp_DID, evt, ndlp->nlp_state,
-			 ndlp->nlp_flag);
+				  ndlp->nlp_rpi, ndlp->nlp_flag);
 	}
 	return ndlp->nlp_state;
 }
 	if ((ndlp->nlp_DID != FDMI_DID) &&
 		(wwn_to_u64(sp->portName.u.wwn) == 0 ||
 		wwn_to_u64(sp->nodeName.u.wwn) == 0)) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0142 PLOGI RSP: Invalid WWN.\n");
 		goto out;
 	}
 		} else {
 			mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 			if (!mbox) {
-				lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+				lpfc_printf_vlog(vport, KERN_ERR,
+						 LOG_TRACE_EVENT,
 						 "0133 PLOGI: no memory "
 						 "for config_link "
 						 "Data: x%x x%x x%x x%x\n",
 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 	if (!mbox) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0018 PLOGI: no memory for reg_login "
 				 "Data: x%x x%x x%x x%x\n",
 				 ndlp->nlp_DID, ndlp->nlp_state,
 		kfree(mp);
 		mempool_free(mbox, phba->mbox_mem_pool);
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0134 PLOGI: cannot issue reg_login "
 				 "Data: x%x x%x x%x x%x\n",
 				 ndlp->nlp_DID, ndlp->nlp_state,
 	} else {
 		mempool_free(mbox, phba->mbox_mem_pool);
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0135 PLOGI: cannot format reg_login "
 				 "Data: x%x x%x x%x x%x\n",
 				 ndlp->nlp_DID, ndlp->nlp_state,
 out:
 	if (ndlp->nlp_DID == NameServer_DID) {
 		lpfc_vport_set_state(vport, FC_VPORT_FAILED);
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0261 Cannot Register NameServer login\n");
 	}
 	if (mb->mbxStatus) {
 		/* RegLogin failed */
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-				"0246 RegLogin failed Data: x%x x%x x%x x%x "
+				 "0246 RegLogin failed Data: x%x x%x x%x x%x "
 				 "x%x\n",
 				 did, mb->mbxStatus, vport->port_state,
 				 mb->un.varRegLogin.vpi,

drivers/scsi/lpfc/lpfc_nvme.c+51−59

@@ -234,8 +234,10 @@ lpfc_nvme_prep_abort_wqe(struct lpfc_iocbq *pwqeq, u16 xritag, u8 opt) · 233 unmodified lines
234		234
235	/**	235	/**
236	* lpfc_nvme_create_queue -	236	* lpfc_nvme_create_queue -
		237	* @pnvme_lport: Transport localport that LS is to be issued from
237	* @lpfc_pnvme: Pointer to the driver's nvme instance data	238	* @lpfc_pnvme: Pointer to the driver's nvme instance data
238	* @qidx: An cpu index used to affinitize IO queues and MSIX vectors.	239	* @qidx: An cpu index used to affinitize IO queues and MSIX vectors.
		240	* @qsize: Size of the queue in bytes
239	* @handle: An opaque driver handle used in follow-up calls.	241	* @handle: An opaque driver handle used in follow-up calls.
240	*	242	*
241	* Driver registers this routine to preallocate and initialize any	243	* Driver registers this routine to preallocate and initialize any
@@ -292,7 +294,7 @@ lpfc_nvme_create_queue(struct nvme_fc_local_port *pnvme_lport, · 50 unmodified lines
292		294
293	/**	295	/**
294	* lpfc_nvme_delete_queue -	296	* lpfc_nvme_delete_queue -
295	* @lpfc_pnvme: Pointer to the driver's nvme instance data	297	* @pnvme_lport: Transport localport that LS is to be issued from
296	* @qidx: An cpu index used to affinitize IO queues and MSIX vectors.	298	* @qidx: An cpu index used to affinitize IO queues and MSIX vectors.
297	* @handle: An opaque driver handle from lpfc_nvme_create_queue	299	* @handle: An opaque driver handle from lpfc_nvme_create_queue
298	*	300	*
@@ -498,7 +500,7 @@ __lpfc_nvme_ls_req_cmp(struct lpfc_hba phba, struct lpfc_vport vport, · 199 unmodified lines
498	if (pnvme_lsreq->done)	500	if (pnvme_lsreq->done)
499	pnvme_lsreq->done(pnvme_lsreq, status);	501	pnvme_lsreq->done(pnvme_lsreq, status);
500	else	502	else
501	lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_DISC,	503	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
502	"6046 NVMEx cmpl without done call back? "	504	"6046 NVMEx cmpl without done call back? "
503	"Data %px DID %x Xri: %x status %x\n",	505	"Data %px DID %x Xri: %x status %x\n",
504	pnvme_lsreq, ndlp ? ndlp->nlp_DID : 0,	506	pnvme_lsreq, ndlp ? ndlp->nlp_DID : 0,
@@ -647,7 +649,7 @@ lpfc_nvme_gen_req(struct lpfc_vport vport, struct lpfc_dmabuf bmp, · 142 unmodified lines
647		649
648	rc = lpfc_sli4_issue_wqe(phba, &phba->sli4_hba.hdwq[0], genwqe);	650	rc = lpfc_sli4_issue_wqe(phba, &phba->sli4_hba.hdwq[0], genwqe);
649	if (rc) {	651	if (rc) {
650	lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_DISC \| LOG_ELS,	652	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
651	"6045 Issue GEN REQ WQE to NPORT x%x "	653	"6045 Issue GEN REQ WQE to NPORT x%x "
652	"Data: x%x x%x rc x%x\n",	654	"Data: x%x x%x rc x%x\n",
653	ndlp->nlp_DID, genwqe->iotag,	655	ndlp->nlp_DID, genwqe->iotag,
@@ -672,6 +674,7 @@ lpfc_nvme_gen_req(struct lpfc_vport vport, struct lpfc_dmabuf bmp, · 18 unmodified lines
672	* @vport: The local port issuing the LS	674	* @vport: The local port issuing the LS
673	* @ndlp: The remote port to send the LS to	675	* @ndlp: The remote port to send the LS to
674	* @pnvme_lsreq: Pointer to LS request structure from the transport	676	* @pnvme_lsreq: Pointer to LS request structure from the transport
		677	* @gen_req_cmp: Completion call-back
675	*	678	*
676	* Routine validates the ndlp, builds buffers and sends a GEN_REQUEST	679	* Routine validates the ndlp, builds buffers and sends a GEN_REQUEST
677	* WQE to perform the LS operation.	680	* WQE to perform the LS operation.
@@ -693,8 +696,7 @@ __lpfc_nvme_ls_req(struct lpfc_vport vport, struct lpfc_nodelist ndlp, · 15 unmodified lines
693	uint16_t ntype, nstate;	696	uint16_t ntype, nstate;
694		697
695	if (!ndlp \|\| !NLP_CHK_NODE_ACT(ndlp)) {	698	if (!ndlp \|\| !NLP_CHK_NODE_ACT(ndlp)) {
696	lpfc_printf_vlog(vport, KERN_ERR,	699	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
697	LOG_NVME_DISC \| LOG_NODE \| LOG_NVME_IOERR,
698	"6051 NVMEx LS REQ: Bad NDLP x%px, Failing "	700	"6051 NVMEx LS REQ: Bad NDLP x%px, Failing "
699	"LS Req\n",	701	"LS Req\n",
700	ndlp);	702	ndlp);
@@ -705,8 +707,7 @@ __lpfc_nvme_ls_req(struct lpfc_vport vport, struct lpfc_nodelist ndlp, · 4 unmodified lines
705	nstate = ndlp->nlp_state;	707	nstate = ndlp->nlp_state;
706	if ((ntype & NLP_NVME_TARGET && nstate != NLP_STE_MAPPED_NODE) \|\|	708	if ((ntype & NLP_NVME_TARGET && nstate != NLP_STE_MAPPED_NODE) \|\|
707	(ntype & NLP_NVME_INITIATOR && nstate != NLP_STE_UNMAPPED_NODE)) {	709	(ntype & NLP_NVME_INITIATOR && nstate != NLP_STE_UNMAPPED_NODE)) {
708	lpfc_printf_vlog(vport, KERN_ERR,	710	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
709	LOG_NVME_DISC \| LOG_NODE \| LOG_NVME_IOERR,
710	"6088 NVMEx LS REQ: Fail DID x%06x not "	711	"6088 NVMEx LS REQ: Fail DID x%06x not "
711	"ready for IO. Type x%x, State x%x\n",	712	"ready for IO. Type x%x, State x%x\n",
712	ndlp->nlp_DID, ntype, nstate);	713	ndlp->nlp_DID, ntype, nstate);
@@ -727,9 +728,7 @@ __lpfc_nvme_ls_req(struct lpfc_vport vport, struct lpfc_nodelist ndlp, · 14 unmodified lines
727		728
728	bmp = kmalloc(sizeof(*bmp), GFP_KERNEL);	729	bmp = kmalloc(sizeof(*bmp), GFP_KERNEL);
729	if (!bmp) {	730	if (!bmp) {
730		731	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
731	lpfc_printf_vlog(vport, KERN_ERR,
732	LOG_NVME_DISC \| LOG_NVME_IOERR,
733	"6044 NVMEx LS REQ: Could not alloc LS buf "	732	"6044 NVMEx LS REQ: Could not alloc LS buf "
734	"for DID %x\n",	733	"for DID %x\n",
735	ndlp->nlp_DID);	734	ndlp->nlp_DID);
@@ -738,8 +737,7 @@ __lpfc_nvme_ls_req(struct lpfc_vport vport, struct lpfc_nodelist ndlp, · 2 unmodified lines
738		737
739	bmp->virt = lpfc_mbuf_alloc(vport->phba, MEM_PRI, &(bmp->phys));	738	bmp->virt = lpfc_mbuf_alloc(vport->phba, MEM_PRI, &(bmp->phys));
740	if (!bmp->virt) {	739	if (!bmp->virt) {
741	lpfc_printf_vlog(vport, KERN_ERR,	740	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
742	LOG_NVME_DISC \| LOG_NVME_IOERR,
743	"6042 NVMEx LS REQ: Could not alloc mbuf "	741	"6042 NVMEx LS REQ: Could not alloc mbuf "
744	"for DID %x\n",	742	"for DID %x\n",
745	ndlp->nlp_DID);	743	ndlp->nlp_DID);
@@ -774,8 +772,7 @@ __lpfc_nvme_ls_req(struct lpfc_vport vport, struct lpfc_nodelist ndlp, · 28 unmodified lines
774	pnvme_lsreq, gen_req_cmp, ndlp, 2,	772	pnvme_lsreq, gen_req_cmp, ndlp, 2,
775	LPFC_NVME_LS_TIMEOUT, 0);	773	LPFC_NVME_LS_TIMEOUT, 0);
776	if (ret != WQE_SUCCESS) {	774	if (ret != WQE_SUCCESS) {
777	lpfc_printf_vlog(vport, KERN_ERR,	775	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
778	LOG_NVME_DISC \| LOG_NVME_IOERR,
779	"6052 NVMEx REQ: EXIT. issue ls wqe failed "	776	"6052 NVMEx REQ: EXIT. issue ls wqe failed "
780	"lsreq x%px Status %x DID %x\n",	777	"lsreq x%px Status %x DID %x\n",
781	pnvme_lsreq, ret, ndlp->nlp_DID);	778	pnvme_lsreq, ret, ndlp->nlp_DID);
@@ -789,9 +786,9 @@ __lpfc_nvme_ls_req(struct lpfc_vport vport, struct lpfc_nodelist ndlp, · 7 unmodified lines
789		786
790	/**	787	/**
791	* lpfc_nvme_ls_req - Issue an NVME Link Service request	788	* lpfc_nvme_ls_req - Issue an NVME Link Service request
792	* @lpfc_nvme_lport: Transport localport that LS is to be issued from.	789	* @pnvme_lport: Transport localport that LS is to be issued from.
793	* @lpfc_nvme_rport: Transport remoteport that LS is to be sent to.	790	* @nvme_rport: Transport remoteport that LS is to be sent to.
794	* @pnvme_lsreq - the transport nvme_ls_req structure for the LS	791	* @pnvme_lsreq: the transport nvme_ls_req structure for the LS
795	*	792	*
796	* Driver registers this routine to handle any link service request	793	* Driver registers this routine to handle any link service request
797	* from the nvme_fc transport to a remote nvme-aware port.	794	* from the nvme_fc transport to a remote nvme-aware port.
@@ -853,9 +850,7 @@ __lpfc_nvme_ls_abort(struct lpfc_vport vport, struct lpfc_nodelist ndlp, · 55 unmodified lines
853	bool foundit = false;	850	bool foundit = false;
854		851
855	if (!ndlp) {	852	if (!ndlp) {
856	lpfc_printf_log(phba, KERN_ERR,	853	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
857	LOG_NVME_DISC \| LOG_NODE \|
858	LOG_NVME_IOERR \| LOG_NVME_ABTS,
859	"6049 NVMEx LS REQ Abort: Bad NDLP x%px DID "	854	"6049 NVMEx LS REQ Abort: Bad NDLP x%px DID "
860	"x%06x, Failing LS Req\n",	855	"x%06x, Failing LS Req\n",
861	ndlp, ndlp ? ndlp->nlp_DID : 0);	856	ndlp, ndlp ? ndlp->nlp_DID : 0);
@@ -931,9 +926,9 @@ lpfc_nvme_xmt_ls_rsp(struct nvme_fc_local_port *localport, · 69 unmodified lines
931		926
932	/**	927	/**
933	* lpfc_nvme_ls_abort - Abort a prior NVME LS request	928	* lpfc_nvme_ls_abort - Abort a prior NVME LS request
934	* @lpfc_nvme_lport: Transport localport that LS is to be issued from.	929	* @pnvme_lport: Transport localport that LS is to be issued from.
935	* @lpfc_nvme_rport: Transport remoteport that LS is to be sent to.	930	* @pnvme_rport: Transport remoteport that LS is to be sent to.
936	* @pnvme_lsreq - the transport nvme_ls_req structure for the LS	931	* @pnvme_lsreq: the transport nvme_ls_req structure for the LS
937	*	932	*
938	* Driver registers this routine to abort a NVME LS request that is	933	* Driver registers this routine to abort a NVME LS request that is
939	* in progress (from the transports perspective).	934	* in progress (from the transports perspective).
@@ -1063,11 +1058,8 @@ lpfc_nvme_adj_fcp_sgls(struct lpfc_vport *vport, · 123 unmodified lines
1063	}	1058	}
1064		1059
1065		1060
1066	/**	1061	/*
1067	* lpfc_nvme_io_cmd_wqe_cmpl - Complete an NVME-over-FCP IO	1062	* lpfc_nvme_io_cmd_wqe_cmpl - Complete an NVME-over-FCP IO
1068	* @lpfc_pnvme: Pointer to the driver's nvme instance data
1069	* @lpfc_nvme_lport: Pointer to the driver's local port data
1070	* @lpfc_nvme_rport: Pointer to the rport getting the @lpfc_nvme_ereq
1071	*	1063	*
1072	* Driver registers this routine as it io request handler. This	1064	* Driver registers this routine as it io request handler. This
1073	* routine issues an fcp WQE with data from the @lpfc_nvme_fcpreq	1065	* routine issues an fcp WQE with data from the @lpfc_nvme_fcpreq
@@ -1099,8 +1091,7 @@ lpfc_nvme_io_cmd_wqe_cmpl(struct lpfc_hba phba, struct lpfc_iocbq pwqeIn, · 25 unmodified lines
1099		1091
1100	/* Sanity check on return of outstanding command */	1092	/* Sanity check on return of outstanding command */
1101	if (!lpfc_ncmd) {	1093	if (!lpfc_ncmd) {
1102	lpfc_printf_vlog(vport, KERN_ERR,	1094	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1103	LOG_NODE \| LOG_NVME_IOERR,
1104	"6071 Null lpfc_ncmd pointer. No "	1095	"6071 Null lpfc_ncmd pointer. No "
1105	"release, skip completion\n");	1096	"release, skip completion\n");
1106	return;	1097	return;
@@ -1111,7 +1102,7 @@ lpfc_nvme_io_cmd_wqe_cmpl(struct lpfc_hba phba, struct lpfc_iocbq pwqeIn, · 4 unmodified lines
1111		1102
1112	if (!lpfc_ncmd->nvmeCmd) {	1103	if (!lpfc_ncmd->nvmeCmd) {
1113	spin_unlock(&lpfc_ncmd->buf_lock);	1104	spin_unlock(&lpfc_ncmd->buf_lock);
1114	lpfc_printf_vlog(vport, KERN_ERR, LOG_NODE \| LOG_NVME_IOERR,	1105	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1115	"6066 Missing cmpl ptrs: lpfc_ncmd x%px, "	1106	"6066 Missing cmpl ptrs: lpfc_ncmd x%px, "
1116	"nvmeCmd x%px\n",	1107	"nvmeCmd x%px\n",
1117	lpfc_ncmd, lpfc_ncmd->nvmeCmd);	1108	lpfc_ncmd, lpfc_ncmd->nvmeCmd);
@@ -1144,7 +1135,7 @@ lpfc_nvme_io_cmd_wqe_cmpl(struct lpfc_hba phba, struct lpfc_iocbq pwqeIn, · 26 unmodified lines
1144	*/	1135	*/
1145	ndlp = lpfc_ncmd->ndlp;	1136	ndlp = lpfc_ncmd->ndlp;
1146	if (!ndlp \|\| !NLP_CHK_NODE_ACT(ndlp)) {	1137	if (!ndlp \|\| !NLP_CHK_NODE_ACT(ndlp)) {
1147	lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_IOERR,	1138	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1148	"6062 Ignoring NVME cmpl. No ndlp\n");	1139	"6062 Ignoring NVME cmpl. No ndlp\n");
1149	goto out_err;	1140	goto out_err;
1150	}	1141	}
@@ -1215,7 +1206,7 @@ lpfc_nvme_io_cmd_wqe_cmpl(struct lpfc_hba phba, struct lpfc_iocbq pwqeIn, · 64 unmodified lines
1215	/* Sanity check */	1206	/* Sanity check */
1216	if (nCmd->rcv_rsplen == LPFC_NVME_ERSP_LEN)	1207	if (nCmd->rcv_rsplen == LPFC_NVME_ERSP_LEN)
1217	break;	1208	break;
1218	lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_IOERR,	1209	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1219	"6081 NVME Completion Protocol Error: "	1210	"6081 NVME Completion Protocol Error: "
1220	"xri %x status x%x result x%x "	1211	"xri %x status x%x result x%x "
1221	"placed x%x\n",	1212	"placed x%x\n",
@@ -1300,11 +1291,10 @@ out_err: · 78 unmodified lines
1300		1291
1301	/**	1292	/**
1302	* lpfc_nvme_prep_io_cmd - Issue an NVME-over-FCP IO	1293	* lpfc_nvme_prep_io_cmd - Issue an NVME-over-FCP IO
1303	* @lpfc_pnvme: Pointer to the driver's nvme instance data	1294	* @vport: pointer to a host virtual N_Port data structure
1304	* @lpfc_nvme_lport: Pointer to the driver's local port data	1295	* @lpfcn_cmd: Pointer to lpfc scsi command
1305	* @lpfc_nvme_rport: Pointer to the rport getting the @lpfc_nvme_ereq	1296	* @pnode: pointer to a node-list data structure
1306	* @lpfc_nvme_fcreq: IO request from nvme fc to driver.	1297	* @cstat: pointer to the control status structure
1307	* @hw_queue_handle: Driver-returned handle in lpfc_nvme_create_queue
1308	*	1298	*
1309	* Driver registers this routine as it io request handler. This	1299	* Driver registers this routine as it io request handler. This
1310	* routine issues an fcp WQE with data from the @lpfc_nvme_fcpreq	1300	* routine issues an fcp WQE with data from the @lpfc_nvme_fcpreq
@@ -1409,11 +1399,8 @@ lpfc_nvme_prep_io_cmd(struct lpfc_vport *vport, · 98 unmodified lines
1409		1399
1410	/**	1400	/**
1411	* lpfc_nvme_prep_io_dma - Issue an NVME-over-FCP IO	1401	* lpfc_nvme_prep_io_dma - Issue an NVME-over-FCP IO
1412	* @lpfc_pnvme: Pointer to the driver's nvme instance data	1402	* @vport: pointer to a host virtual N_Port data structure
1413	* @lpfc_nvme_lport: Pointer to the driver's local port data	1403	* @lpfcn_cmd: Pointer to lpfc scsi command
1414	* @lpfc_nvme_rport: Pointer to the rport getting the @lpfc_nvme_ereq
1415	* @lpfc_nvme_fcreq: IO request from nvme fc to driver.
1416	* @hw_queue_handle: Driver-returned handle in lpfc_nvme_create_queue
1417	*	1404	*
1418	* Driver registers this routine as it io request handler. This	1405	* Driver registers this routine as it io request handler. This
1419	* routine issues an fcp WQE with data from the @lpfc_nvme_fcpreq	1406	* routine issues an fcp WQE with data from the @lpfc_nvme_fcpreq
@@ -1459,7 +1446,7 @@ lpfc_nvme_prep_io_dma(struct lpfc_vport *vport, · 39 unmodified lines
1459	first_data_sgl = sgl;	1446	first_data_sgl = sgl;
1460	lpfc_ncmd->seg_cnt = nCmd->sg_cnt;	1447	lpfc_ncmd->seg_cnt = nCmd->sg_cnt;
1461	if (lpfc_ncmd->seg_cnt > lpfc_nvme_template.max_sgl_segments) {	1448	if (lpfc_ncmd->seg_cnt > lpfc_nvme_template.max_sgl_segments) {
1462	lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,	1449	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1463	"6058 Too many sg segments from "	1450	"6058 Too many sg segments from "
1464	"NVME Transport. Max %d, "	1451	"NVME Transport. Max %d, "
1465	"nvmeIO sg_cnt %d\n",	1452	"nvmeIO sg_cnt %d\n",
@@ -1482,7 +1469,7 @@ lpfc_nvme_prep_io_dma(struct lpfc_vport *vport, · 16 unmodified lines
1482	j = 2;	1469	j = 2;
1483	for (i = 0; i < nseg; i++) {	1470	for (i = 0; i < nseg; i++) {
1484	if (data_sg == NULL) {	1471	if (data_sg == NULL) {
1485	lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,	1472	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1486	"6059 dptr err %d, nseg %d\n",	1473	"6059 dptr err %d, nseg %d\n",
1487	i, nseg);	1474	i, nseg);
1488	lpfc_ncmd->seg_cnt = 0;	1475	lpfc_ncmd->seg_cnt = 0;
@@ -1583,7 +1570,7 @@ lpfc_nvme_prep_io_dma(struct lpfc_vport *vport, · 94 unmodified lines
1583	* and sg_cnt must zero.	1570	* and sg_cnt must zero.
1584	*/	1571	*/
1585	if (nCmd->payload_length != 0) {	1572	if (nCmd->payload_length != 0) {
1586	lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,	1573	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1587	"6063 NVME DMA Prep Err: sg_cnt %d "	1574	"6063 NVME DMA Prep Err: sg_cnt %d "
1588	"payload_length x%x\n",	1575	"payload_length x%x\n",
1589	nCmd->sg_cnt, nCmd->payload_length);	1576	nCmd->sg_cnt, nCmd->payload_length);
@@ -1946,7 +1933,7 @@ lpfc_nvme_fcp_abort(struct nvme_fc_local_port *pnvme_lport, · 356 unmodified lines
1946	/* driver queued commands are in process of being flushed */	1933	/* driver queued commands are in process of being flushed */
1947	if (phba->hba_flag & HBA_IOQ_FLUSH) {	1934	if (phba->hba_flag & HBA_IOQ_FLUSH) {
1948	spin_unlock_irqrestore(&phba->hbalock, flags);	1935	spin_unlock_irqrestore(&phba->hbalock, flags);
1949	lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_ABTS,	1936	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1950	"6139 Driver in reset cleanup - flushing "	1937	"6139 Driver in reset cleanup - flushing "
1951	"NVME Req now. hba_flag x%x\n",	1938	"NVME Req now. hba_flag x%x\n",
1952	phba->hba_flag);	1939	phba->hba_flag);
@@ -1956,13 +1943,13 @@ lpfc_nvme_fcp_abort(struct nvme_fc_local_port *pnvme_lport, · 3 unmodified lines
1956	lpfc_nbuf = freqpriv->nvme_buf;	1943	lpfc_nbuf = freqpriv->nvme_buf;
1957	if (!lpfc_nbuf) {	1944	if (!lpfc_nbuf) {
1958	spin_unlock_irqrestore(&phba->hbalock, flags);	1945	spin_unlock_irqrestore(&phba->hbalock, flags);
1959	lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_ABTS,	1946	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1960	"6140 NVME IO req has no matching lpfc nvme "	1947	"6140 NVME IO req has no matching lpfc nvme "
1961	"io buffer. Skipping abort req.\n");	1948	"io buffer. Skipping abort req.\n");
1962	return;	1949	return;
1963	} else if (!lpfc_nbuf->nvmeCmd) {	1950	} else if (!lpfc_nbuf->nvmeCmd) {
1964	spin_unlock_irqrestore(&phba->hbalock, flags);	1951	spin_unlock_irqrestore(&phba->hbalock, flags);
1965	lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_ABTS,	1952	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1966	"6141 lpfc NVME IO req has no nvme_fcreq "	1953	"6141 lpfc NVME IO req has no nvme_fcreq "
1967	"io buffer. Skipping abort req.\n");	1954	"io buffer. Skipping abort req.\n");
1968	return;	1955	return;
@@ -1980,7 +1967,7 @@ lpfc_nvme_fcp_abort(struct nvme_fc_local_port *pnvme_lport, · 11 unmodified lines
1980	* has not seen it yet.	1967	* has not seen it yet.
1981	*/	1968	*/
1982	if (lpfc_nbuf->nvmeCmd != pnvme_fcreq) {	1969	if (lpfc_nbuf->nvmeCmd != pnvme_fcreq) {
1983	lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_ABTS,	1970	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1984	"6143 NVME req mismatch: "	1971	"6143 NVME req mismatch: "
1985	"lpfc_nbuf x%px nvmeCmd x%px, "	1972	"lpfc_nbuf x%px nvmeCmd x%px, "
1986	"pnvme_fcreq x%px. Skipping Abort xri x%x\n",	1973	"pnvme_fcreq x%px. Skipping Abort xri x%x\n",
@@ -1991,7 +1978,7 @@ lpfc_nvme_fcp_abort(struct nvme_fc_local_port *pnvme_lport, · 4 unmodified lines
1991		1978
1992	/* Don't abort IOs no longer on the pending queue. */	1979	/* Don't abort IOs no longer on the pending queue. */
1993	if (!(nvmereq_wqe->iocb_flag & LPFC_IO_ON_TXCMPLQ)) {	1980	if (!(nvmereq_wqe->iocb_flag & LPFC_IO_ON_TXCMPLQ)) {
1994	lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_ABTS,	1981	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1995	"6142 NVME IO req x%px not queued - skipping "	1982	"6142 NVME IO req x%px not queued - skipping "
1996	"abort req xri x%x\n",	1983	"abort req xri x%x\n",
1997	pnvme_fcreq, nvmereq_wqe->sli4_xritag);	1984	pnvme_fcreq, nvmereq_wqe->sli4_xritag);
@@ -2005,7 +1992,7 @@ lpfc_nvme_fcp_abort(struct nvme_fc_local_port *pnvme_lport, · 7 unmodified lines
2005		1992
2006	/* Outstanding abort is in progress */	1993	/* Outstanding abort is in progress */
2007	if (nvmereq_wqe->iocb_flag & LPFC_DRIVER_ABORTED) {	1994	if (nvmereq_wqe->iocb_flag & LPFC_DRIVER_ABORTED) {
2008	lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_ABTS,	1995	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
2009	"6144 Outstanding NVME I/O Abort Request "	1996	"6144 Outstanding NVME I/O Abort Request "
2010	"still pending on nvme_fcreq x%px, "	1997	"still pending on nvme_fcreq x%px, "
2011	"lpfc_ncmd %px xri x%x\n",	1998	"lpfc_ncmd %px xri x%x\n",
@@ -2016,7 +2003,7 @@ lpfc_nvme_fcp_abort(struct nvme_fc_local_port *pnvme_lport, · 4 unmodified lines
2016		2003
2017	abts_buf = __lpfc_sli_get_iocbq(phba);	2004	abts_buf = __lpfc_sli_get_iocbq(phba);
2018	if (!abts_buf) {	2005	if (!abts_buf) {
2019	lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_ABTS,	2006	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
2020	"6136 No available abort wqes. Skipping "	2007	"6136 No available abort wqes. Skipping "
2021	"Abts req for nvme_fcreq x%px xri x%x\n",	2008	"Abts req for nvme_fcreq x%px xri x%x\n",
2022	pnvme_fcreq, nvmereq_wqe->sli4_xritag);	2009	pnvme_fcreq, nvmereq_wqe->sli4_xritag);
@@ -2037,7 +2024,7 @@ lpfc_nvme_fcp_abort(struct nvme_fc_local_port *pnvme_lport, · 14 unmodified lines
2037	spin_unlock(&lpfc_nbuf->buf_lock);	2024	spin_unlock(&lpfc_nbuf->buf_lock);
2038	spin_unlock_irqrestore(&phba->hbalock, flags);	2025	spin_unlock_irqrestore(&phba->hbalock, flags);
2039	if (ret_val) {	2026	if (ret_val) {
2040	lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_ABTS,	2027	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
2041	"6137 Failed abts issue_wqe with status x%x "	2028	"6137 Failed abts issue_wqe with status x%x "
2042	"for nvme_fcreq x%px.\n",	2029	"for nvme_fcreq x%px.\n",
2043	ret_val, pnvme_fcreq);	2030	ret_val, pnvme_fcreq);
@@ -2310,7 +2297,7 @@ lpfc_nvme_lport_unreg_wait(struct lpfc_vport *vport, · 266 unmodified lines
2310	if (pring->txcmplq_cnt)	2297	if (pring->txcmplq_cnt)
2311	pending += pring->txcmplq_cnt;	2298	pending += pring->txcmplq_cnt;
2312	}	2299	}
2313	lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_IOERR,	2300	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
2314	"6176 Lport x%px Localport x%px wait "	2301	"6176 Lport x%px Localport x%px wait "
2315	"timed out. Pending %d. Renewing.\n",	2302	"timed out. Pending %d. Renewing.\n",
2316	lport, vport->localport, pending);	2303	lport, vport->localport, pending);
@@ -2432,6 +2419,7 @@ lpfc_nvme_register_port(struct lpfc_vport vport, struct lpfc_nodelist ndlp) · 115 unmodified lines
2432	struct nvme_fc_remote_port *remote_port;	2419	struct nvme_fc_remote_port *remote_port;
2433	struct nvme_fc_port_info rpinfo;	2420	struct nvme_fc_port_info rpinfo;
2434	struct lpfc_nodelist *prev_ndlp = NULL;	2421	struct lpfc_nodelist *prev_ndlp = NULL;
		2422	struct fc_rport *srport = ndlp->rport;
2435		2423
2436	lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_NVME_DISC,	2424	lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_NVME_DISC,
2437	"6006 Register NVME PORT. DID x%06x nlptype x%x\n",	2425	"6006 Register NVME PORT. DID x%06x nlptype x%x\n",
@@ -2461,6 +2449,10 @@ lpfc_nvme_register_port(struct lpfc_vport vport, struct lpfc_nodelist ndlp) · 23 unmodified lines
2461		2449
2462	rpinfo.port_name = wwn_to_u64(ndlp->nlp_portname.u.wwn);	2450	rpinfo.port_name = wwn_to_u64(ndlp->nlp_portname.u.wwn);
2463	rpinfo.node_name = wwn_to_u64(ndlp->nlp_nodename.u.wwn);	2451	rpinfo.node_name = wwn_to_u64(ndlp->nlp_nodename.u.wwn);
		2452	if (srport)
		2453	rpinfo.dev_loss_tmo = srport->dev_loss_tmo;
		2454	else
		2455	rpinfo.dev_loss_tmo = vport->cfg_devloss_tmo;
2464		2456
2465	spin_lock_irq(&vport->phba->hbalock);	2457	spin_lock_irq(&vport->phba->hbalock);
2466	oldrport = lpfc_ndlp_get_nrport(ndlp);	2458	oldrport = lpfc_ndlp_get_nrport(ndlp);
@@ -2528,7 +2520,7 @@ lpfc_nvme_register_port(struct lpfc_vport vport, struct lpfc_nodelist ndlp) · 61 unmodified lines
2528	ndlp, prev_ndlp);	2520	ndlp, prev_ndlp);
2529	} else {	2521	} else {
2530	lpfc_printf_vlog(vport, KERN_ERR,	2522	lpfc_printf_vlog(vport, KERN_ERR,
2531	LOG_NVME_DISC \| LOG_NODE,	2523	LOG_TRACE_EVENT,
2532	"6031 RemotePort Registration failed "	2524	"6031 RemotePort Registration failed "
2533	"err: %d, DID x%06x\n",	2525	"err: %d, DID x%06x\n",
2534	ret, ndlp->nlp_DID);	2526	ret, ndlp->nlp_DID);
@@ -2574,7 +2566,7 @@ lpfc_nvme_rescan_port(struct lpfc_vport vport, struct lpfc_nodelist ndlp) · 39 unmodified lines
2574	ndlp->nlp_state == NLP_STE_MAPPED_NODE) {	2566	ndlp->nlp_state == NLP_STE_MAPPED_NODE) {
2575	nvme_fc_rescan_remoteport(remoteport);	2567	nvme_fc_rescan_remoteport(remoteport);
2576		2568
2577	lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_DISC,	2569	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
2578	"6172 NVME rescanned DID x%06x "	2570	"6172 NVME rescanned DID x%06x "
2579	"port_state x%x\n",	2571	"port_state x%x\n",
2580	ndlp->nlp_DID, remoteport->port_state);	2572	ndlp->nlp_DID, remoteport->port_state);
@@ -2657,7 +2649,7 @@ lpfc_nvme_unregister_port(struct lpfc_vport vport, struct lpfc_nodelist ndlp) · 76 unmodified lines
2657	ret = nvme_fc_unregister_remoteport(remoteport);	2649	ret = nvme_fc_unregister_remoteport(remoteport);
2658	if (ret != 0) {	2650	if (ret != 0) {
2659	lpfc_nlp_put(ndlp);	2651	lpfc_nlp_put(ndlp);
2660	lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_DISC,	2652	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
2661	"6167 NVME unregister failed %d "	2653	"6167 NVME unregister failed %d "
2662	"port_state x%x\n",	2654	"port_state x%x\n",
2663	ret, remoteport->port_state);	2655	ret, remoteport->port_state);
@@ -2667,7 +2659,7 @@ lpfc_nvme_unregister_port(struct lpfc_vport vport, struct lpfc_nodelist ndlp) · 3 unmodified lines
2667		2659
2668	input_err:	2660	input_err:
2669	#endif	2661	#endif
2670	lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_DISC,	2662	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
2671	"6168 State error: lport x%px, rport x%px FCID x%06x\n",	2663	"6168 State error: lport x%px, rport x%px FCID x%06x\n",
2672	vport->localport, ndlp->rport, ndlp->nlp_DID);	2664	vport->localport, ndlp->rport, ndlp->nlp_DID);
2673	}	2665	}
@@ -2752,7 +2744,7 @@ lpfc_nvme_wait_for_io_drain(struct lpfc_hba *phba) · 78 unmodified lines
2752	* dump a message. Something is wrong.	2744	* dump a message. Something is wrong.
2753	*/	2745	*/
2754	if ((wait_cnt % 1000) == 0) {	2746	if ((wait_cnt % 1000) == 0) {
2755	lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,	2747	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
2756	"6178 NVME IO not empty, "	2748	"6178 NVME IO not empty, "
2757	"cnt %d\n", wait_cnt);	2749	"cnt %d\n", wait_cnt);
2758	}	2750	}

drivers/scsi/lpfc/lpfc_nvmet.c+47−49

 	result = wcqe->parameter;
 	if (axchg->state != LPFC_NVME_STE_LS_RSP || axchg->entry_cnt != 2) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC | LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6410 NVMEx LS cmpl state mismatch IO x%x: "
 				"%d %d\n",
 				axchg->oxid, axchg->state, axchg->entry_cnt);
 	unsigned long iflag;
 	if (ctxp->state == LPFC_NVME_STE_FREE) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6411 NVMET free, already free IO x%x: %d %d\n",
 				ctxp->oxid, ctxp->state, ctxp->entry_cnt);
 	}
 		if (!queue_work(phba->wq, &ctx_buf->defer_work)) {
 			atomic_inc(&tgtp->rcv_fcp_cmd_drop);
-			lpfc_printf_log(phba, KERN_ERR, LOG_NVME,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"6181 Unable to queue deferred work "
 					"for oxid x%x. "
 					"FCP Drop IO [x%x x%x x%x]\n",
 			"6023 NVMEx LS rsp oxid x%x\n", axchg->oxid);
 	if (axchg->state != LPFC_NVME_STE_LS_RCV || axchg->entry_cnt != 1) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC | LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6412 NVMEx LS rsp state mismatch "
 				"oxid x%x: %d %d\n",
 				axchg->oxid, axchg->state, axchg->entry_cnt);
 	nvmewqeq = lpfc_nvmet_prep_ls_wqe(phba, axchg, ls_rsp->rspdma,
 					 ls_rsp->rsplen);
 	if (nvmewqeq == NULL) {
-		lpfc_printf_log(phba, KERN_ERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
-				LOG_NVME_DISC | LOG_NVME_IOERR | LOG_NVME_ABTS,
 				"6150 NVMEx LS Drop Rsp x%x: Prep\n",
 				axchg->oxid);
 		rc = -ENOMEM;
 		return 0;
 	}
-	lpfc_printf_log(phba, KERN_ERR,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
-			LOG_NVME_DISC | LOG_NVME_IOERR | LOG_NVME_ABTS,
 			"6151 NVMEx LS RSP x%x: failed to transmit %d\n",
 			axchg->oxid, rc);
 	if ((ctxp->flag & LPFC_NVME_ABTS_RCV) ||
 	    (ctxp->state == LPFC_NVME_STE_ABORT)) {
 		atomic_inc(&lpfc_nvmep->xmt_fcp_drop);
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6102 IO oxid x%x aborted\n",
 				ctxp->oxid);
 		rc = -ENXIO;
 	nvmewqeq = lpfc_nvmet_prep_fcp_wqe(phba, ctxp);
 	if (nvmewqeq == NULL) {
 		atomic_inc(&lpfc_nvmep->xmt_fcp_drop);
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6152 FCP Drop IO x%x: Prep\n",
 				ctxp->oxid);
 		rc = -ENXIO;
 	/* Give back resources */
 	atomic_inc(&lpfc_nvmep->xmt_fcp_drop);
-	lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"6153 FCP Drop IO x%x: Issue: %d\n",
 			ctxp->oxid, rc);
 				ctxp->flag, ctxp->oxid);
 	else if (ctxp->state != LPFC_NVME_STE_DONE &&
 		 ctxp->state != LPFC_NVME_STE_ABORT)
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6413 NVMET release bad state %d %d oxid x%x\n",
 				ctxp->state, ctxp->entry_cnt, ctxp->oxid);
 	phba = tgtp->phba;
 	rc = lpfc_issue_els_rscn(phba->pport, 0);
-	lpfc_printf_log(phba, KERN_ERR, LOG_NVME,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"6420 NVMET subsystem change: Notification %s\n",
 			(rc) ? "Failed" : "Sent");
 }
 		phba->sli4_hba.num_possible_cpu * phba->cfg_nvmet_mrq,
 		sizeof(struct lpfc_nvmet_ctx_info), GFP_KERNEL);
 	if (!phba->sli4_hba.nvmet_ctx_info) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6419 Failed allocate memory for "
 				"nvmet context lists\n");
 		return -ENOMEM;
 	for (i = 0; i < phba->sli4_hba.nvmet_xri_cnt; i++) {
 		ctx_buf = kzalloc(sizeof(*ctx_buf), GFP_KERNEL);
 		if (!ctx_buf) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_NVME,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"6404 Ran out of memory for NVMET\n");
 			return -ENOMEM;
 		}
 					   GFP_KERNEL);
 		if (!ctx_buf->context) {
 			kfree(ctx_buf);
-			lpfc_printf_log(phba, KERN_ERR, LOG_NVME,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"6405 Ran out of NVMET "
 					"context memory\n");
 			return -ENOMEM;
 		if (!ctx_buf->iocbq) {
 			kfree(ctx_buf->context);
 			kfree(ctx_buf);
-			lpfc_printf_log(phba, KERN_ERR, LOG_NVME,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"6406 Ran out of NVMET iocb/WQEs\n");
 			return -ENOMEM;
 		}
 			lpfc_sli_release_iocbq(phba, ctx_buf->iocbq);
 			kfree(ctx_buf->context);
 			kfree(ctx_buf);
-			lpfc_printf_log(phba, KERN_ERR, LOG_NVME,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"6407 Ran out of NVMET XRIs\n");
 			return -ENOMEM;
 		}
 	error = -ENOENT;
 #endif
 	if (error) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6025 Cannot register NVME targetport x%x: "
 				"portnm %llx nodenm %llx segs %d qs %d\n",
 				error,
 		nvmet_fc_unregister_targetport(phba->targetport);
 		if (!wait_for_completion_timeout(tgtp->tport_unreg_cmp,
 					msecs_to_jiffies(LPFC_NVMET_WAIT_TMO)))
-			lpfc_printf_log(phba, KERN_ERR, LOG_NVME,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"6179 Unreg targetport x%px timeout "
 					"reached.\n", phba->targetport);
 		lpfc_nvmet_cleanup_io_context(phba);
 	unsigned long iflags;
 	if (!nvmebuf) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"6159 process_rcv_fcp_req, nvmebuf is NULL, "
 			"oxid: x%x flg: x%x state: x%x\n",
 			ctxp->oxid, ctxp->flag, ctxp->state);
 	}
 	if (ctxp->flag & LPFC_NVME_ABTS_RCV) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6324 IO oxid x%x aborted\n",
 				ctxp->oxid);
 		return;
 	}
 	ctxp->flag &= ~LPFC_NVME_TNOTIFY;
 	atomic_inc(&tgtp->rcv_fcp_cmd_drop);
-	lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"2582 FCP Drop IO x%x: err x%x: x%x x%x x%x\n",
 			ctxp->oxid, rc,
 			atomic_read(&tgtp->rcv_fcp_cmd_in),
 	ctx_buf = NULL;
 	if (!nvmebuf || !phba->targetport) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6157 NVMET FCP Drop IO\n");
 		if (nvmebuf)
 			lpfc_rq_buf_free(phba, &nvmebuf->hbuf);
 	list_add_tail(&ctxp->list, &phba->sli4_hba.t_active_ctx_list);
 	spin_unlock_irqrestore(&phba->sli4_hba.t_active_list_lock, iflag);
 	if (ctxp->state != LPFC_NVME_STE_FREE) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6414 NVMET Context corrupt %d %d oxid x%x\n",
 				ctxp->state, ctxp->entry_cnt, ctxp->oxid);
 	}
 	if (!queue_work(phba->wq, &ctx_buf->defer_work)) {
 		atomic_inc(&tgtp->rcv_fcp_cmd_drop);
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6325 Unable to queue work for oxid x%x. "
 				"FCP Drop IO [x%x x%x x%x]\n",
 				ctxp->oxid,
 			   uint8_t cqflag)
 {
 	if (!nvmebuf) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"3167 NVMET FCP Drop IO\n");
 		return;
 	}
 	union lpfc_wqe128 *wqe;
 	if (!lpfc_is_link_up(phba)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6104 NVMET prep LS wqe: link err: "
 				"NPORT x%x oxid:x%x ste %d\n",
 				ctxp->sid, ctxp->oxid, ctxp->state);
 	/* Allocate buffer for  command wqe */
 	nvmewqe = lpfc_sli_get_iocbq(phba);
 	if (nvmewqe == NULL) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6105 NVMET prep LS wqe: No WQE: "
 				"NPORT x%x oxid x%x ste %d\n",
 				ctxp->sid, ctxp->oxid, ctxp->state);
 	if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) ||
 	    ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
 	    (ndlp->nlp_state != NLP_STE_MAPPED_NODE))) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6106 NVMET prep LS wqe: No ndlp: "
 				"NPORT x%x oxid x%x ste %d\n",
 				ctxp->sid, ctxp->oxid, ctxp->state);
 	int xc = 1;
 	if (!lpfc_is_link_up(phba)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6107 NVMET prep FCP wqe: link err:"
 				"NPORT x%x oxid x%x ste %d\n",
 				ctxp->sid, ctxp->oxid, ctxp->state);
 	if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) ||
 	    ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
 	     (ndlp->nlp_state != NLP_STE_MAPPED_NODE))) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6108 NVMET prep FCP wqe: no ndlp: "
 				"NPORT x%x oxid x%x ste %d\n",
 				ctxp->sid, ctxp->oxid, ctxp->state);
 	}
 	if (rsp->sg_cnt > lpfc_tgttemplate.max_sgl_segments) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6109 NVMET prep FCP wqe: seg cnt err: "
 				"NPORT x%x oxid x%x ste %d cnt %d\n",
 				ctxp->sid, ctxp->oxid, ctxp->state,
 		/* Allocate buffer for  command wqe */
 		nvmewqe = ctxp->ctxbuf->iocbq;
 		if (nvmewqe == NULL) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"6110 NVMET prep FCP wqe: No "
 					"WQE: NPORT x%x oxid x%x ste %d\n",
 					ctxp->sid, ctxp->oxid, ctxp->state);
 	    (ctxp->state == LPFC_NVME_STE_DATA)) {
 		wqe = &nvmewqe->wqe;
 	} else {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6111 Wrong state NVMET FCP: %d  cnt %d\n",
 				ctxp->state, ctxp->entry_cnt);
 		return NULL;
 	/* Sanity check */
 	if (ctxp->state != LPFC_NVME_STE_ABORT) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6112 ABTS Wrong state:%d oxid x%x\n",
 				ctxp->state, ctxp->oxid);
 	}
 			result, wcqe->word3);
 	if (!ctxp) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6415 NVMET LS Abort No ctx: WCQE: "
 				 "%08x %08x %08x %08x\n",
 				wcqe->word0, wcqe->total_data_placed,
 	}
 	if (ctxp->state != LPFC_NVME_STE_LS_ABORT) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6416 NVMET LS abort cmpl state mismatch: "
 				"oxid x%x: %d %d\n",
 				ctxp->oxid, ctxp->state, ctxp->entry_cnt);
 	    (ndlp->nlp_state != NLP_STE_MAPPED_NODE))) {
 		if (tgtp)
 			atomic_inc(&tgtp->xmt_abort_rsp_error);
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6134 Drop ABTS - wrong NDLP state x%x.\n",
 				(ndlp) ? ndlp->nlp_state : NLP_STE_MAX_STATE);
 	    ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
 	    (ndlp->nlp_state != NLP_STE_MAPPED_NODE))) {
 		atomic_inc(&tgtp->xmt_abort_rsp_error);
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6160 Drop ABORT - wrong NDLP state x%x.\n",
 				(ndlp) ? ndlp->nlp_state : NLP_STE_MAX_STATE);
 	spin_lock_irqsave(&ctxp->ctxlock, flags);
 	if (!ctxp->abort_wqeq) {
 		atomic_inc(&tgtp->xmt_abort_rsp_error);
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6161 ABORT failed: No wqeqs: "
 				"xri: x%x\n", ctxp->oxid);
 		/* No failure to an ABTS request. */
 	if (phba->hba_flag & HBA_IOQ_FLUSH) {
 		spin_unlock_irqrestore(&phba->hbalock, flags);
 		atomic_inc(&tgtp->xmt_abort_rsp_error);
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6163 Driver in reset cleanup - flushing "
 				"NVME Req now. hba_flag x%x oxid x%x\n",
 				phba->hba_flag, ctxp->oxid);
 	if (abts_wqeq->iocb_flag & LPFC_DRIVER_ABORTED) {
 		spin_unlock_irqrestore(&phba->hbalock, flags);
 		atomic_inc(&tgtp->xmt_abort_rsp_error);
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6164 Outstanding NVME I/O Abort Request "
 				"still pending on oxid x%x\n",
 				ctxp->oxid);
 	ctxp->flag &= ~LPFC_NVME_ABORT_OP;
 	spin_unlock_irqrestore(&ctxp->ctxlock, flags);
 	lpfc_sli_release_iocbq(phba, abts_wqeq);
-	lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"6166 Failed ABORT issue_wqe with status x%x "
 			"for oxid x%x.\n",
 			rc, ctxp->oxid);
 	}
 	if (ctxp->state == LPFC_NVME_STE_FREE) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6417 NVMET ABORT ctx freed %d %d oxid x%x\n",
 				ctxp->state, ctxp->entry_cnt, ctxp->oxid);
 		rc = WQE_BUSY;
 	spin_unlock_irqrestore(&ctxp->ctxlock, flags);
 	atomic_inc(&tgtp->xmt_abort_rsp_error);
-	lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"6135 Failed to Issue ABTS for oxid x%x. Status x%x "
 			"(%x)\n",
 			ctxp->oxid, rc, released);
 		ctxp->state = LPFC_NVME_STE_LS_ABORT;
 		ctxp->entry_cnt++;
 	} else {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6418 NVMET LS abort state mismatch "
 				"IO x%x: %d %d\n",
 				ctxp->oxid, ctxp->state, ctxp->entry_cnt);
 		/* Issue ABTS for this WQE based on iotag */
 		ctxp->wqeq = lpfc_sli_get_iocbq(phba);
 		if (!ctxp->wqeq) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"6068 Abort failed: No wqeqs: "
 					"xri: x%x\n", xri);
 			/* No failure to an ABTS request. */
 	abts_wqeq->context2 = NULL;
 	abts_wqeq->context3 = NULL;
 	lpfc_sli_release_iocbq(phba, abts_wqeq);
-	lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"6056 Failed to Issue ABTS. Status x%x\n", rc);
 	return 1;
 }

drivers/scsi/lpfc/lpfc_scsi.c+64−61

 		lpfc_cmd->seg_cnt = nseg;
 		if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
-				"9064 BLKGRD: %s: Too many sg segments from "
+					"9064 BLKGRD: %s: Too many sg segments"
-			       "dma_map_sg.  Config %d, seg_cnt %d\n",
+					" from dma_map_sg.  Config %d, seg_cnt"
-			       __func__, phba->cfg_sg_seg_cnt,
+					" %d\n", __func__, phba->cfg_sg_seg_cnt,
-			       lpfc_cmd->seg_cnt);
+					lpfc_cmd->seg_cnt);
 			WARN_ON_ONCE(lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt);
 			lpfc_cmd->seg_cnt = 0;
 			scsi_dma_unmap(scsi_cmnd);
 					 * inserted in middle of the IO.
 					 */
-					lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+					lpfc_printf_log(phba, KERN_ERR,
+							LOG_TRACE_EVENT,
 					"9076 BLKGRD: Injecting reftag error: "
 					"write lba x%lx + x%x oldrefTag x%x\n",
 					(unsigned long)lba, blockoff,
 				}
 				rc = BG_ERR_TGT | BG_ERR_CHECK;
-				lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"9078 BLKGRD: Injecting reftag error: "
 					"write lba x%lx\n", (unsigned long)lba);
 				break;
 				}
 				rc = BG_ERR_INIT;
-				lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"9077 BLKGRD: Injecting reftag error: "
 					"write lba x%lx\n", (unsigned long)lba);
 				break;
 				}
 				rc = BG_ERR_INIT;
-				lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"9079 BLKGRD: Injecting reftag error: "
 					"read lba x%lx\n", (unsigned long)lba);
 				break;
 					 * inserted in middle of the IO.
 					 */
-					lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+					lpfc_printf_log(phba, KERN_ERR,
+							LOG_TRACE_EVENT,
 					"9080 BLKGRD: Injecting apptag error: "
 					"write lba x%lx + x%x oldappTag x%x\n",
 					(unsigned long)lba, blockoff,
 				}
 				rc = BG_ERR_TGT | BG_ERR_CHECK;
-				lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"0813 BLKGRD: Injecting apptag error: "
 					"write lba x%lx\n", (unsigned long)lba);
 				break;
 				}
 				rc = BG_ERR_INIT;
-				lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"0812 BLKGRD: Injecting apptag error: "
 					"write lba x%lx\n", (unsigned long)lba);
 				break;
 				}
 				rc = BG_ERR_INIT;
-				lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"0814 BLKGRD: Injecting apptag error: "
 					"read lba x%lx\n", (unsigned long)lba);
 				break;
 				rc |= BG_ERR_TGT | BG_ERR_SWAP;
 				/* Signals the caller to swap CRC->CSUM */
-				lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"0817 BLKGRD: Injecting guard error: "
 					"write lba x%lx\n", (unsigned long)lba);
 				break;
 				rc = BG_ERR_INIT | BG_ERR_SWAP;
 				/* Signals the caller to swap CRC->CSUM */
-				lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"0816 BLKGRD: Injecting guard error: "
 					"write lba x%lx\n", (unsigned long)lba);
 				break;
 				rc = BG_ERR_INIT | BG_ERR_SWAP;
 				/* Signals the caller to swap CRC->CSUM */
-				lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"0818 BLKGRD: Injecting guard error: "
 					"read lba x%lx\n", (unsigned long)lba);
 			}
 		case SCSI_PROT_NORMAL:
 		default:
-			lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"9063 BLKGRD: Bad op/guard:%d/IP combination\n",
 					scsi_get_prot_op(sc));
 			ret = 1;
 		case SCSI_PROT_NORMAL:
 		default:
-			lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"9075 BLKGRD: Bad op/guard:%d/CRC combination\n",
 					scsi_get_prot_op(sc));
 			ret = 1;
 	sgde = scsi_sglist(sc);
 	if (!sgpe || !sgde) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"9020 Invalid s/g entry: data=x%px prot=x%px\n",
 				sgpe, sgde);
 		return 0;
 				return num_bde + 1;
 			if (!sgde) {
-				lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"9065 BLKGRD:%s Invalid data segment\n",
 						__func__);
 				return 0;
 			reftag += protgrp_blks;
 		} else {
 			/* if we're here, we have a bug */
-			lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
-				"9054 BLKGRD: bug in %s\n", __func__);
+					"9054 BLKGRD: bug in %s\n", __func__);
 		}
 	} while (!alldone);
 	sgde = scsi_sglist(sc);
 	if (!sgpe || !sgde) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"9082 Invalid s/g entry: data=x%px prot=x%px\n",
 				sgpe, sgde);
 		return 0;
 				return num_sge + 1;
 			if (!sgde) {
-				lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"9086 BLKGRD:%s Invalid data segment\n",
 						__func__);
 				return 0;
 			reftag += protgrp_blks;
 		} else {
 			/* if we're here, we have a bug */
-			lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
-				"9085 BLKGRD: bug in %s\n", __func__);
+					"9085 BLKGRD: bug in %s\n", __func__);
 		}
 	} while (!alldone);
 		break;
 	default:
 		if (phba)
-			lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"9021 Unsupported protection op:%d\n",
 					op);
 		break;
 			scsi_dma_unmap(scsi_cmnd);
 			lpfc_cmd->seg_cnt = 0;
-			lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"9022 Unexpected protection group %i\n",
 					prot_group_type);
 			return 2;
 			     scsi_prot_sg_count(scsi_cmnd),
 			     scsi_cmnd->sc_data_direction);
-	lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"9023 Cannot setup S/G List for HBA"
 			"IO segs %d/%d BPL %d SCSI %d: %d %d\n",
 			lpfc_cmd->seg_cnt, lpfc_cmd->prot_seg_cnt,
 		lpfc_cmd->seg_cnt = nseg;
 		if (!phba->cfg_xpsgl &&
 		    lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9074 BLKGRD:"
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
-				" %s: Too many sg segments from "
+					"9074 BLKGRD:"
-				"dma_map_sg.  Config %d, seg_cnt %d\n",
+					" %s: Too many sg segments from "
-				__func__, phba->cfg_sg_seg_cnt,
+					"dma_map_sg.  Config %d, seg_cnt %d\n",
-			       lpfc_cmd->seg_cnt);
+					__func__, phba->cfg_sg_seg_cnt,
+					lpfc_cmd->seg_cnt);
 			WARN_ON_ONCE(lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt);
 			lpfc_cmd->seg_cnt = 0;
 			scsi_dma_unmap(scsi_cmnd);
 			scsi_dma_unmap(scsi_cmnd);
 			lpfc_cmd->seg_cnt = 0;
-			lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"9083 Unexpected protection group %i\n",
 					prot_group_type);
 			return 2;
 			     scsi_prot_sg_count(scsi_cmnd),
 			     scsi_cmnd->sc_data_direction);
-	lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"9084 Cannot setup S/G List for HBA"
 			"IO segs %d/%d SGL %d SCSI %d: %d %d\n",
 			lpfc_cmd->seg_cnt, lpfc_cmd->prot_seg_cnt,
 	if (resp_info & RSP_LEN_VALID) {
 		rsplen = be32_to_cpu(fcprsp->rspRspLen);
 		if (rsplen != 0 && rsplen != 4 && rsplen != 8) {
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
-				 "2719 Invalid response length: "
+					 "2719 Invalid response length: "
-				 "tgt x%x lun x%llx cmnd x%x rsplen x%x\n",
+					 "tgt x%x lun x%llx cmnd x%x rsplen "
-				 cmnd->device->id,
+					 "x%x\n", cmnd->device->id,
-				 cmnd->device->lun, cmnd->cmnd[0],
+					 cmnd->device->lun, cmnd->cmnd[0],
-				 rsplen);
+					 rsplen);
 			host_status = DID_ERROR;
 			goto out;
 		}
 		if (fcprsp->rspInfo3 != RSP_NO_FAILURE) {
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "2757 Protocol failure detected during "
 				 "processing of FCP I/O op: "
 				 "tgt x%x lun x%llx cmnd x%x rspInfo3 x%x\n",
 	/* Sanity check on return of outstanding command */
 	cmd = lpfc_cmd->pCmd;
 	if (!cmd || !phba) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "2621 IO completion: Not an active IO\n");
 		spin_unlock(&lpfc_cmd->buf_lock);
 		return;
 		phba->lpfc_get_scsi_buf = lpfc_get_scsi_buf_s4;
 		break;
 	default:
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"1418 Invalid HBA PCI-device group: 0x%x\n",
 				dev_grp);
 		return -ENODEV;
  *      0,    successful
  */
 int
-lpfc_check_pci_resettable(const struct lpfc_hba *phba)
+lpfc_check_pci_resettable(struct lpfc_hba *phba)
 {
 	const struct pci_dev *pdev = phba->pcidev;
 	struct pci_dev *ptr = NULL;
 	if ((scsi_get_prot_op(cmnd) != SCSI_PROT_NORMAL) &&
 		(!(phba->sli3_options & LPFC_SLI3_BG_ENABLED))) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"9058 BLKGRD: ERROR: rcvd protected cmd:%02x"
 				" op:%02x str=%s without registering for"
 				" BlockGuard - Rejecting command\n",
 	if (lpfc_cmd->pCmd == cmnd) {
 		ret = FAILED;
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0748 abort handler timed out waiting "
 				 "for aborting I/O (xri:x%x) to complete: "
 				 "ret %#x, ID %d, LUN %llu\n",
 	    (iocbqrsp->iocb.ulpStatus != IOSTAT_SUCCESS)) {
 		if (status != IOCB_SUCCESS ||
 		    iocbqrsp->iocb.ulpStatus != IOSTAT_FCP_RSP_ERROR)
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 					 "0727 TMF %s to TGT %d LUN %llu "
 					 "failed (%d, %d) iocb_flag x%x\n",
 					 lpfc_taskmgmt_name(task_mgmt_cmd),
 		cnt = lpfc_sli_sum_iocb(vport, tgt_id, lun_id, context);
 	}
 	if (cnt) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			"0724 I/O flush failure for context %s : cnt x%x\n",
 			((context == LPFC_CTX_LUN) ? "LUN" :
 			 ((context == LPFC_CTX_TGT) ? "TGT" :
 	rdata = lpfc_rport_data_from_scsi_device(cmnd->device);
 	if (!rdata || !rdata->pnode) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0798 Device Reset rdata failure: rdata x%px\n",
 				 rdata);
 		return FAILED;
 	status = lpfc_chk_tgt_mapped(vport, cmnd);
 	if (status == FAILED) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			"0721 Device Reset rport failure: rdata x%px\n", rdata);
 		return FAILED;
 	}
 	status = lpfc_send_taskmgmt(vport, cmnd, tgt_id, lun_id,
 						FCP_LUN_RESET);
-	lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			 "0713 SCSI layer issued Device Reset (%d, %llu) "
 			 "return x%x\n", tgt_id, lun_id, status);
 	rdata = lpfc_rport_data_from_scsi_device(cmnd->device);
 	if (!rdata || !rdata->pnode) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0799 Target Reset rdata failure: rdata x%px\n",
 				 rdata);
 		return FAILED;
 	status = lpfc_chk_tgt_mapped(vport, cmnd);
 	if (status == FAILED) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			"0722 Target Reset rport failure: rdata x%px\n", rdata);
 		if (pnode) {
 			spin_lock_irq(shost->host_lock);
 	status = lpfc_send_taskmgmt(vport, cmnd, tgt_id, lun_id,
 					FCP_TARGET_RESET);
-	lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			 "0723 SCSI layer issued Target Reset (%d, %llu) "
 			 "return x%x\n", tgt_id, lun_id, status);
 					i, 0, FCP_TARGET_RESET);
 		if (status != SUCCESS) {
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 					 "0700 Bus Reset on target %d failed\n",
 					 i);
 			ret = FAILED;
 	if (status != SUCCESS)
 		ret = FAILED;
-	lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			 "0714 SCSI layer issued Bus Reset Data: x%x\n", ret);
 	return ret;
 }
 	struct lpfc_hba *phba = vport->phba;
 	int rc, ret = SUCCESS;
-	lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			 "3172 SCSI layer issued Host Reset Data:\n");
 	lpfc_offline_prep(phba, LPFC_MBX_WAIT);
 	return ret;
 error:
-	lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 			 "3323 Failed host reset\n");
 	lpfc_unblock_mgmt_io(phba);
 	return FAILED;
 	}
 	num_allocated = lpfc_new_scsi_buf_s3(vport, num_to_alloc);
 	if (num_to_alloc != num_allocated) {
-			lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 					 "0708 Allocation request of %d "
 					 "command buffers did not succeed.  "
 					 "Allocated %d buffers.\n",

drivers/scsi/lpfc/lpfc_sli.c+425−258

 #include <scsi/scsi_transport_fc.h>
 #include <scsi/fc/fc_fs.h>
 #include <linux/aer.h>
+#include <linux/crash_dump.h>
 #ifdef CONFIG_X86
 #include <asm/set_memory.h>
 #endif
 /**
  * lpfc_sli4_mq_put - Put a Mailbox Queue Entry on an Mailbox Queue
  * @q: The Mailbox Queue to operate on.
- * @wqe: The Mailbox Queue Entry to put on the Work queue.
+ * @mqe: The Mailbox Queue Entry to put on the Work queue.
  *
  * This routine will copy the contents of @mqe to the next available entry on
  * the @q. This function will then ring the Work Queue Doorbell to signal the
 	writel(doorbell.word0, q->phba->sli4_hba.CQDBregaddr);
 }
-/**
+/*
  * lpfc_sli4_rq_put - Put a Receive Buffer Queue Entry on a Receive Queue
- * @q: The Header Receive Queue to operate on.
- * @wqe: The Receive Queue Entry to put on the Receive queue.
  *
  * This routine will copy the contents of @wqe to the next available entry on
  * the @q. This function will then ring the Receive Queue Doorbell to signal the
 	return hq_put_index;
 }
-/**
+/*
  * lpfc_sli4_rq_release - Updates internal hba index for RQ
- * @q: The Header Receive Queue to operate on.
  *
  * This routine will update the HBA index of a queue to reflect consumption of
  * one Receive Queue Entry by the HBA. When the HBA indicates that it has
  * lpfc_test_rrq_active - Test RRQ bit in xri_bitmap.
  * @phba: Pointer to HBA context object.
  * @ndlp: Targets nodelist pointer for this exchange.
- * @xritag the xri in the bitmap to test.
+ * @xritag: the xri in the bitmap to test.
  *
  * This function returns:
  * 0 = rrq not active for this xri
 		goto out;
 	spin_unlock_irqrestore(&phba->hbalock, iflags);
-	rrq = mempool_alloc(phba->rrq_pool, GFP_KERNEL);
+	rrq = mempool_alloc(phba->rrq_pool, GFP_ATOMIC);
 	if (!rrq) {
 		lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
 				"3155 Unable to allocate RRQ xri:0x%x rxid:0x%x"
 /**
  * __lpfc_sli_get_els_sglq - Allocates an iocb object from sgl pool
  * @phba: Pointer to HBA context object.
- * @piocb: Pointer to the iocbq.
+ * @piocbq: Pointer to the iocbq.
  *
  * The driver calls this function with either the nvme ls ring lock
  * or the fc els ring lock held depending on the iocb usage.  This function
 /**
  * __lpfc_sli_get_nvmet_sglq - Allocates an iocb object from sgl pool
  * @phba: Pointer to HBA context object.
- * @piocb: Pointer to the iocbq.
+ * @piocbq: Pointer to the iocbq.
  *
  * This function is called with the sgl_list lock held. This function
  * gets a new driver sglq object from the sglq list. If the
 	case DSSCMD_IWRITE64_CX:
 	case DSSCMD_IREAD64_CR:
 	case DSSCMD_IREAD64_CX:
+	case CMD_SEND_FRAME:
 		type = LPFC_SOL_IOCB;
 		break;
 	case CMD_ABORT_XRI_CN:
 		lpfc_config_ring(phba, i, pmb);
 		rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
 		if (rc != MBX_SUCCESS) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"0446 Adapter failed to init (%d), "
 					"mbxCmd x%x CFG_RING, mbxStatus x%x, "
 					"ring %d\n",
 		pring->sli.sli3.local_getidx = le32_to_cpu(pgp->cmdGetInx);
 		if (unlikely(pring->sli.sli3.local_getidx >= max_cmd_idx)) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"0315 Ring %d issue: portCmdGet %d "
 					"is bigger than cmd ring %d\n",
 					pring->ringno,
 		hbqp->local_hbqGetIdx = getidx;
 		if (unlikely(hbqp->local_hbqGetIdx >= hbqp->entry_count)) {
-			lpfc_printf_log(phba, KERN_ERR,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
-					LOG_SLI | LOG_VPORT,
 					"1802 HBQ %d: local_hbqGetIdx "
 					"%u is > than hbqp->entry_count %u\n",
 					hbqno, hbqp->local_hbqGetIdx,
 					 lpfc_hbq_defs[qno]->init_count);
 }
-/**
+/*
  * lpfc_sli_hbqbuf_get - Remove the first hbq off of an hbq list
- * @phba: Pointer to HBA context object.
- * @hbqno: HBQ number.
  *
  * This function removes the first hbq buffer on an hbq list and returns a
  * pointer to that buffer. If it finds no buffers on the list it returns NULL.
 /**
  * lpfc_sli_rqbuf_get - Remove the first dma buffer off of an RQ list
  * @phba: Pointer to HBA context object.
- * @hbqno: HBQ number.
+ * @hrq: HBQ number.
  *
  * This function removes the first RQ buffer on an RQ buffer list and returns a
  * pointer to that buffer. If it finds no buffers on the list it returns NULL.
 		}
 	}
 	spin_unlock_irq(&phba->hbalock);
-	lpfc_printf_log(phba, KERN_ERR, LOG_SLI | LOG_VPORT,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"1803 Bad hbq tag. Data: x%x x%x\n",
 			tag, phba->hbqs[tag >> 16].buffer_count);
 	return NULL;
 	/* Check security permission status on INIT_LINK mailbox command */
 	if ((pmb->u.mb.mbxCommand == MBX_INIT_LINK) &&
 	    (pmb->u.mb.mbxStatus == MBXERR_SEC_NO_PERMISSION))
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2860 SLI authentication is required "
 				"for INIT_LINK but has not done yet\n");
 		if (lpfc_sli_chk_mbx_command(pmbox->mbxCommand) ==
 		    MBX_SHUTDOWN) {
 			/* Unknown mailbox command compl */
-			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"(%d):0323 Unknown Mailbox command "
 					"x%x (x%x/x%x) Cmpl\n",
 					pmb->vport ? pmb->vport->vpi :
 	}
 	if (unlikely(failwhy)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC | LOG_NVME_IOERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6154 Drop NVME LS: SID %06X OXID x%X: %s\n",
 				sid, oxid, failwhy);
 		goto out_fail;
 	if (!ret)
 		return;
-	lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC | LOG_NVME_IOERR,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"6155 Drop NVME LS from DID %06X: SID %06X OXID x%X "
 			"NVMe%s handler failed %d\n",
 			did, sid, oxid,
 	}
 	spin_unlock_irqrestore(temp_lock, iflag);
-	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"0317 iotag x%x is out of "
 			"range: max iotag x%x wd0 x%x\n",
 			iotag, phba->sli.last_iotag,
 	}
 	spin_unlock_irqrestore(temp_lock, iflag);
-	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"0372 iotag x%x lookup error: max iotag (x%x) "
 			"iocb_flag x%x\n",
 			iotag, phba->sli.last_iotag,
 	 * Ring <ringno> handler: portRspPut <portRspPut> is bigger than
 	 * rsp ring <portRspMax>
 	 */
-	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"0312 Ring %d handler: portRspPut %d "
 			"is bigger than rsp ring %d\n",
 			pring->ringno, le32_to_cpu(pgp->rspPutInx),
 /**
  * lpfc_poll_eratt - Error attention polling timer timeout handler
- * @ptr: Pointer to address of HBA context object.
+ * @t: Context to fetch pointer to address of HBA context object from.
  *
  * This function is invoked by the Error Attention polling timer when the
  * timer times out. It will check the SLI Error Attention register for
 					 phba->brd_no, adaptermsg);
 			} else {
 				/* Unknown IOCB command */
-				lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 						"0334 Unknown IOCB command "
 						"Data: x%x, x%x x%x x%x x%x\n",
 						type, irsp->ulpCommand,
 					 phba->brd_no, adaptermsg);
 			} else {
 				/* Unknown IOCB command */
-				lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 						"0335 Unknown IOCB "
 						"command Data: x%x "
 						"x%x x%x x%x\n",
 		 * Ring <ringno> handler: portRspPut <portRspPut> is bigger than
 		 * rsp ring <portRspMax>
 		 */
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0303 Ring %d handler: portRspPut %d "
 				"is bigger than rsp ring %d\n",
 				pring->ringno, portRspPut, portRspMax);
 /**
  * lpfc_sli_abort_fcp_rings - Abort all iocbs in all FCP rings
  * @phba: Pointer to HBA context object.
- * @pring: Pointer to driver SLI ring object.
  *
  * This function aborts all iocbs in FCP rings and frees all the iocb
  * objects in txq. This function issues an abort iocb for all the iocb commands
 	/* Check to see if any errors occurred during init */
 	if ((status & HS_FFERM) || (i >= 20)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2751 Adapter failed to restart, "
 				"status reg x%x, FW Data: A8 x%x AC x%x\n",
 				status,
 	if (retval != MBX_SUCCESS) {
 		if (retval != MBX_BUSY)
 			mempool_free(pmb, phba->mbox_mem_pool);
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2752 KILL_BOARD command failed retval %d\n",
 				retval);
 		spin_lock_irq(&phba->hbalock);
 		if (i++ >= 200) {
 			/* Adapter failed to init, timeout, status reg
 			   <status> */
-			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"0436 Adapter failed to init, "
 					"timeout, status reg x%x, "
 					"FW Data: A8 x%x AC x%x\n", status,
 			/* ERROR: During chipset initialization */
 			/* Adapter failed to init, chipset, status reg
 			   <status> */
-			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"0437 Adapter failed to init, "
 					"chipset, status reg x%x, "
 					"FW Data: A8 x%x AC x%x\n", status,
 	if (status & HS_FFERM) {
 		/* ERROR: During chipset initialization */
 		/* Adapter failed to init, chipset, status reg <status> */
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0438 Adapter failed to init, chipset, "
 				"status reg x%x, "
 				"FW Data: A8 x%x AC x%x\n", status,
 					LPFC_SLI3_CRP_ENABLED |
 					LPFC_SLI3_DSS_ENABLED);
 		if (rc != MBX_SUCCESS) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0442 Adapter failed to init, mbxCmd x%x "
 				"CONFIG_PORT, mbxStatus x%x Data: x%x\n",
 				pmb->u.mb.mbxCommand, pmb->u.mb.mbxStatus, 0);
 			if (pmb->u.mb.un.varCfgPort.gbg == 0) {
 				phba->cfg_enable_bg = 0;
 				phba->sli3_options &= ~LPFC_SLI3_BG_ENABLED;
-				lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 						"0443 Adapter did not grant "
 						"BlockGuard\n");
 			}
 	switch (phba->cfg_sli_mode) {
 	case 2:
 		if (phba->cfg_enable_npiv) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"1824 NPIV enabled: Override sli_mode "
 				"parameter (%d) to auto (0).\n",
 				phba->cfg_sli_mode);
 	case 3:
 		break;
 	default:
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"1819 Unrecognized sli_mode parameter: %d.\n",
 				phba->cfg_sli_mode);
 	rc = lpfc_sli_config_port(phba, mode);
 	if (rc && phba->cfg_sli_mode == 3)
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"1820 Unable to select SLI-3.  "
 				"Not supported by adapter.\n");
 	if (rc && mode != 2)
 lpfc_sli_hba_setup_error:
 	phba->link_state = LPFC_HBA_ERROR;
-	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"0445 Firmware initialization failed\n");
 	return rc;
 }
 /**
  * lpfc_sli4_read_fcoe_params - Read fcoe params from conf region
  * @phba: Pointer to HBA context object.
- * @mboxq: mailbox pointer.
+ *
  * This function issue a dump mailbox command to read config region
  * 23 and parse the records in the region and populate driver
  * data structure.
 			LPFC_SLI4_MBX_NEMBED);
 	if (alloclen < reqlen) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"3084 Allocated DMA memory size (%d) is "
 				"less than the requested DMA memory size "
 				"(%d)\n", alloclen, reqlen);
 	rsrc_info = &mbox->u.mqe.un.rsrc_extent_info;
 	if (bf_get(lpfc_mbox_hdr_status,
 		   &rsrc_info->header.cfg_shdr.response)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2930 Failed to get resource extents "
 				"Status 0x%x Add'l Status 0x%x\n",
 				bf_get(lpfc_mbox_hdr_status,
 /**
  * lpfc_sli4_cfg_post_extnts -
  * @phba: Pointer to HBA context object.
- * @extnt_cnt - number of available extents.
+ * @extnt_cnt: number of available extents.
- * @type - the extent type (rpi, xri, vfi, vpi).
+ * @type: the extent type (rpi, xri, vfi, vpi).
- * @emb - buffer to hold either MBX_EMBED or MBX_NEMBED operation.
+ * @emb: buffer to hold either MBX_EMBED or MBX_NEMBED operation.
- * @mbox - pointer to the caller's allocated mailbox structure.
+ * @mbox: pointer to the caller's allocated mailbox structure.
  *
  * This function executes the extents allocation request.  It also
  * takes care of the amount of memory needed to allocate or get the
 				     LPFC_MBOX_OPCODE_ALLOC_RSRC_EXTENT,
 				     req_len, *emb);
 	if (alloc_len < req_len) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"2982 Allocated DMA memory size (x%x) is "
 			"less than the requested DMA memory "
 			"size (x%x)\n", alloc_len, req_len);
 		return -EIO;
 	if ((rsrc_cnt == 0) || (rsrc_size == 0)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"3009 No available Resource Extents "
 			"for resource type 0x%x: Count: 0x%x, "
 			"Size 0x%x\n", type, rsrc_cnt,
 	dealloc_rsrc = &mbox->u.mqe.un.dealloc_rsrc_extents;
 	if (bf_get(lpfc_mbox_hdr_status,
 		   &dealloc_rsrc->header.cfg_shdr.response)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2919 Failed to release resource extents "
 				"for type %d - Status 0x%x Add'l Status 0x%x. "
 				"Resource memory not released.\n",
 					    &ras_fwlog->lwpd.phys,
 					    GFP_KERNEL);
 	if (!ras_fwlog->lwpd.virt) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6185 LWPD Memory Alloc Failed\n");
 		return -ENOMEM;
 /**
  * lpfc_sli4_ras_mbox_cmpl: Completion handler for RAS MBX command
  * @phba: pointer to lpfc hba data structure.
- * @pmboxq: pointer to the driver internal queue element for mailbox command.
+ * @pmb: pointer to the driver internal queue element for mailbox command.
  *
  * Completion handler for driver's RAS MBX command to the device.
  **/
 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
 	if (mb->mbxStatus != MBX_SUCCESS || shdr_status) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6188 FW LOG mailbox "
 				"completed with status x%x add_status x%x,"
 				" mbx status x%x\n",
 	/* Setup Mailbox command */
 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 	if (!mbox) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6190 RAS MBX Alloc Failed");
 		rc = -ENOMEM;
 		goto mem_free;
 	rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
 	if (rc == MBX_NOT_FINISHED) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6191 FW-Log Mailbox failed. "
 				"status %d mbxStatus : x%x", rc,
 				bf_get(lpfc_mqe_status, &mbox->u.mqe));
 		/* RPIs. */
 		count = phba->sli4_hba.max_cfg_param.max_rpi;
 		if (count <= 0) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"3279 Invalid provisioning of "
 					"rpi:%d\n", count);
 			rc = -EINVAL;
 		/* VPIs. */
 		count = phba->sli4_hba.max_cfg_param.max_vpi;
 		if (count <= 0) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"3280 Invalid provisioning of "
 					"vpi:%d\n", count);
 			rc = -EINVAL;
 		/* XRIs. */
 		count = phba->sli4_hba.max_cfg_param.max_xri;
 		if (count <= 0) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"3281 Invalid provisioning of "
 					"xri:%d\n", count);
 			rc = -EINVAL;
 		/* VFIs. */
 		count = phba->sli4_hba.max_cfg_param.max_vfi;
 		if (count <= 0) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"3282 Invalid provisioning of "
 					"vfi:%d\n", count);
 			rc = -EINVAL;
  * lpfc_sli4_get_allocated_extnts - Get the port's allocated extents.
  * @phba: Pointer to HBA context object.
  * @type: The resource extent type.
- * @extnt_count: buffer to hold port extent count response
+ * @extnt_cnt: buffer to hold port extent count response
  * @extnt_size: buffer to hold port extent size response.
  *
  * This function calls the port to read the host allocated extents
 				     LPFC_MBOX_OPCODE_GET_ALLOC_RSRC_EXTENT,
 				     req_len, emb);
 	if (alloc_len < req_len) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"2983 Allocated DMA memory size (x%x) is "
 			"less than the requested DMA memory "
 			"size (x%x)\n", alloc_len, req_len);
 	}
 	if (bf_get(lpfc_mbox_hdr_status, &shdr->response)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"2984 Failed to read allocated resources "
 			"for type %d - Status 0x%x Add'l Status 0x%x.\n",
 			type,
 /**
  * lpfc_sli4_repost_sgl_list - Repost the buffers sgl pages as block
  * @phba: pointer to lpfc hba data structure.
- * @pring: Pointer to driver SLI ring object.
  * @sgl_list: linked link of sgl buffers to post
  * @cnt: number of linked list buffers
  *
 		spin_unlock(&phba->sli4_hba.sgl_list_lock);
 		spin_unlock_irq(&phba->hbalock);
 	} else {
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"3161 Failure to post sgl to port.\n");
 		return -EIO;
 	}
 		drqe.address_hi = putPaddrHigh(rqb_buffer->dbuf.phys);
 		rc = lpfc_sli4_rq_put(hrq, drq, &hrqe, &drqe);
 		if (rc < 0) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"6421 Cannot post to HRQ %d: %x %x %x "
 					"DRQ %x %x\n",
 					hrq->queue_id,
 	return 1;
 }
+/**
+ * lpfc_init_idle_stat_hb - Initialize idle_stat tracking
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine initializes the per-cq idle_stat to dynamically dictate
+ * polling decisions.
+ *
+ * Return codes:
+ *   None
+ **/
+static void lpfc_init_idle_stat_hb(struct lpfc_hba *phba)
+{
+	int i;
+	struct lpfc_sli4_hdw_queue *hdwq;
+	struct lpfc_queue *cq;
+	struct lpfc_idle_stat *idle_stat;
+	u64 wall;
+	for_each_present_cpu(i) {
+		hdwq = &phba->sli4_hba.hdwq[phba->sli4_hba.cpu_map[i].hdwq];
+		cq = hdwq->io_cq;
+		/* Skip if we've already handled this cq's primary CPU */
+		if (cq->chann != i)
+			continue;
+		idle_stat = &phba->sli4_hba.idle_stat[i];
+		idle_stat->prev_idle = get_cpu_idle_time(i, &wall, 1);
+		idle_stat->prev_wall = wall;
+		if (phba->nvmet_support)
+			cq->poll_mode = LPFC_QUEUE_WORK;
+		else
+			cq->poll_mode = LPFC_IRQ_POLL;
+	}
+	if (!phba->nvmet_support)
+		schedule_delayed_work(&phba->idle_stat_delay_work,
+				      msecs_to_jiffies(LPFC_IDLE_STAT_DELAY));
+}
+static void lpfc_sli4_dip(struct lpfc_hba *phba)
+{
+	uint32_t if_type;
+	if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
+	if (if_type == LPFC_SLI_INTF_IF_TYPE_2 ||
+	    if_type == LPFC_SLI_INTF_IF_TYPE_6) {
+		struct lpfc_register reg_data;
+		if (lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
+			       &reg_data.word0))
+			return;
+		if (bf_get(lpfc_sliport_status_dip, &reg_data))
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
+					"2904 Firmware Dump Image Present"
+					" on Adapter");
+	}
+}
 /**
  * lpfc_sli4_hba_setup - SLI4 device initialization PCI function
  * @phba: Pointer to HBA context object.
 		spin_unlock_irq(&phba->hbalock);
 	}
+	lpfc_sli4_dip(phba);
 	/*
 	 * Allocate a single mailbox container for initializing the
 	 * port.
 	phba->hba_flag &= ~HBA_IOQ_FLUSH;
 	if (phba->sli_rev != LPFC_SLI_REV4) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"0376 READ_REV Error. SLI Level %d "
 			"FCoE enabled %d\n",
 			phba->sli_rev, phba->hba_flag & HBA_FCOE_MODE);
 	 */
 	rc = lpfc_parse_vpd(phba, vpd, vpd_size);
 	if (unlikely(!rc)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0377 Error %d parsing vpd. "
 				"Using defaults.\n", rc);
 		rc = 0;
 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
 	dd = bf_get(lpfc_mbx_set_feature_dd, &mboxq->u.mqe.un.set_feature);
 	if ((rc == MBX_SUCCESS) && (dd == LPFC_ENABLE_DUAL_DUMP))
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI | LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
 				"6448 Dual Dump is enabled\n");
 	else
 		lpfc_printf_log(phba, KERN_INFO, LOG_SLI | LOG_INIT,
 	 */
 	rc = lpfc_sli4_alloc_resource_identifiers(phba);
 	if (rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2920 Failed to alloc Resource IDs "
 				"rc = x%x\n", rc);
 		goto out_free_mbox;
 	kfree(mp);
 	mboxq->ctx_buf = NULL;
 	if (unlikely(rc)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0382 READ_SPARAM command failed "
 				"status %d, mbxStatus x%x\n",
 				rc, bf_get(lpfc_mqe_status, mqe));
 	/* Create all the SLI4 queues */
 	rc = lpfc_sli4_queue_create(phba);
 	if (rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"3089 Failed to allocate queues\n");
 		rc = -ENODEV;
 		goto out_free_mbox;
 	/* Set up all the queues to the device */
 	rc = lpfc_sli4_queue_setup(phba);
 	if (unlikely(rc)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0381 Error %d during queue setup.\n ", rc);
 		goto out_stop_timers;
 	}
 	/* update host els xri-sgl sizes and mappings */
 	rc = lpfc_sli4_els_sgl_update(phba);
 	if (unlikely(rc)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"1400 Failed to update xri-sgl size and "
 				"mapping: %d\n", rc);
 		goto out_destroy_queue;
 	rc = lpfc_sli4_repost_sgl_list(phba, &phba->sli4_hba.lpfc_els_sgl_list,
 				       phba->sli4_hba.els_xri_cnt);
 	if (unlikely(rc < 0)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0582 Error %d during els sgl post "
 				"operation\n", rc);
 		rc = -ENODEV;
 		/* update host nvmet xri-sgl sizes and mappings */
 		rc = lpfc_sli4_nvmet_sgl_update(phba);
 		if (unlikely(rc)) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"6308 Failed to update nvmet-sgl size "
 					"and mapping: %d\n", rc);
 			goto out_destroy_queue;
 			&phba->sli4_hba.lpfc_nvmet_sgl_list,
 			phba->sli4_hba.nvmet_xri_cnt);
 		if (unlikely(rc < 0)) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"3117 Error %d during nvmet "
 					"sgl post\n", rc);
 			rc = -ENODEV;
 		/* update host common xri-sgl sizes and mappings */
 		rc = lpfc_sli4_io_sgl_update(phba);
 		if (unlikely(rc)) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"6082 Failed to update nvme-sgl size "
 					"and mapping: %d\n", rc);
 			goto out_destroy_queue;
 		/* register the allocated common sgl pool to the port */
 		rc = lpfc_sli4_repost_io_sgl_list(phba);
 		if (unlikely(rc)) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"6116 Error %d during nvme sgl post "
 					"operation\n", rc);
 			/* Some NVME buffers were moved to abort nvme list */
 				cnt);
 		rc = lpfc_init_iocb_list(phba, cnt);
 		if (rc) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"1413 Failed to init iocb list.\n");
 			goto out_destroy_queue;
 		}
 	/* Post the rpi header region to the device. */
 	rc = lpfc_sli4_post_all_rpi_hdrs(phba);
 	if (unlikely(rc)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0393 Error %d during rpi post operation\n",
 				rc);
 		rc = -ENODEV;
 		queue_delayed_work(phba->wq, &phba->eq_delay_work,
 				   msecs_to_jiffies(LPFC_EQ_DELAY_MSECS));
+	/* start per phba idle_stat_delay heartbeat */
+	lpfc_init_idle_stat_hb(phba);
 	/* Start error attention (ERATT) polling timer */
 	mod_timer(&phba->eratt_poll,
 		  jiffies + msecs_to_jiffies(1000 * phba->eratt_poll_interval));
 	if (!(phba->hba_flag & HBA_FCOE_MODE) &&
 	    (phba->hba_flag & LINK_DISABLED)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"3103 Adapter Link is disabled.\n");
 		lpfc_down_link(phba, mboxq);
 		rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
 		if (rc != MBX_SUCCESS) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"3104 Adapter failed to issue "
 					"DOWN_LINK mbox cmd, rc:x%x\n", rc);
 			goto out_io_buff_free;
 /**
  * lpfc_mbox_timeout - Timeout call back function for mbox timer
- * @ptr: context object - pointer to hba structure.
+ * @t: Context to fetch pointer to hba structure from.
  *
  * This is the callback function for mailbox timer. The mailbox
  * timer is armed when a new mailbox command is issued and the timer
 	}
 	/* Mbox cmd <mbxCommand> timeout */
-	lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"0310 Mailbox command x%x timeout Data: x%x x%x x%px\n",
 			mb->mbxCommand,
 			phba->pport->port_state,
 	lpfc_sli_abort_fcp_rings(phba);
-	lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"0345 Resetting board due to mailbox timeout\n");
 	/* Reset the HBA device */
 		spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
 		/* Mbox command <mbxCommand> cannot issue */
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"(%d):0311 Mailbox command x%x cannot "
 				"issue Data: x%x x%x\n",
 				pmbox->vport ? pmbox->vport->vpi : 0,
 		if (lpfc_readl(phba->HCregaddr, &hc_copy) ||
 			!(hc_copy & HC_MBINT_ENA)) {
 			spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
-			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"(%d):2528 Mailbox command x%x cannot "
 				"issue Data: x%x x%x\n",
 				pmbox->vport ? pmbox->vport->vpi : 0,
 			spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
 			/* Mbox command <mbxCommand> cannot issue */
-			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"(%d):2529 Mailbox command x%x "
 					"cannot issue Data: x%x x%x\n",
 					pmbox->vport ? pmbox->vport->vpi : 0,
 		if (!(psli->sli_flag & LPFC_SLI_ACTIVE)) {
 			spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
 			/* Mbox command <mbxCommand> cannot issue */
-			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"(%d):2530 Mailbox command x%x "
 					"cannot issue Data: x%x x%x\n",
 					pmbox->vport ? pmbox->vport->vpi : 0,
 			psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
 			spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
 			/* Mbox command <mbxCommand> cannot issue */
-			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"(%d):2531 Mailbox command x%x "
 					"cannot issue Data: x%x x%x\n",
 					pmbox->vport ? pmbox->vport->vpi : 0,
 	spin_lock_irqsave(&phba->hbalock, iflag);
 	if (psli->sli_flag & LPFC_SLI_MBOX_ACTIVE) {
 		spin_unlock_irqrestore(&phba->hbalock, iflag);
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"(%d):2532 Mailbox command x%x (x%x/x%x) "
 				"cannot issue Data: x%x x%x\n",
 				mboxq->vport ? mboxq->vport->vpi : 0,
 /**
  * lpfc_sli_issue_mbox_s4 - Issue an SLI4 mailbox command to firmware
  * @phba: Pointer to HBA context object.
- * @pmbox: Pointer to mailbox object.
+ * @mboxq: Pointer to mailbox object.
  * @flag: Flag indicating how the mailbox need to be processed.
  *
  * This function is called by discovery code and HBA management code to submit
 	rc = lpfc_mbox_dev_check(phba);
 	if (unlikely(rc)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"(%d):2544 Mailbox command x%x (x%x/x%x) "
 				"cannot issue Data: x%x x%x\n",
 				mboxq->vport ? mboxq->vport->vpi : 0,
 	/* Now, interrupt mode asynchronous mailbox command */
 	rc = lpfc_mbox_cmd_check(phba, mboxq);
 	if (rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"(%d):2543 Mailbox command x%x (x%x/x%x) "
 				"cannot issue Data: x%x x%x\n",
 				mboxq->vport ? mboxq->vport->vpi : 0,
 	}
 	if (unlikely(phba->sli.mbox_active)) {
 		spin_unlock_irqrestore(&phba->hbalock, iflags);
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0384 There is pending active mailbox cmd\n");
 		return MBX_NOT_FINISHED;
 	}
 	/* Post the mailbox command to the port */
 	rc = lpfc_sli4_mq_put(phba->sli4_hba.mbx_wq, mqe);
 	if (rc != MBX_SUCCESS) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"(%d):2533 Mailbox command x%x (x%x/x%x) "
 				"cannot issue Data: x%x x%x\n",
 				mboxq->vport ? mboxq->vport->vpi : 0,
 		phba->lpfc_sli_brdready = lpfc_sli_brdready_s4;
 		break;
 	default:
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"1420 Invalid HBA PCI-device group: 0x%x\n",
 				dev_grp);
 		return -ENODEV;
 	if (piocb->iocb_cmpl && (!piocb->vport) &&
 	   (piocb->iocb.ulpCommand != CMD_ABORT_XRI_CN) &&
 	   (piocb->iocb.ulpCommand != CMD_CLOSE_XRI_CN)) {
-		lpfc_printf_log(phba, KERN_ERR,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
-				LOG_SLI | LOG_VPORT,
 				"1807 IOCB x%x failed. No vport\n",
 				piocb->iocb.ulpCommand);
 		dump_stack();
 /**
  * lpfc_sli4_bpl2sgl - Convert the bpl/bde to a sgl.
  * @phba: Pointer to HBA context object.
- * @piocb: Pointer to command iocb.
+ * @piocbq: Pointer to command iocb.
  * @sglq: Pointer to the scatter gather queue object.
  *
  * This routine converts the bpl or bde that is in the IOCB
 /**
  * lpfc_sli_iocb2wqe - Convert the IOCB to a work queue entry.
  * @phba: Pointer to HBA context object.
- * @piocb: Pointer to command iocb.
+ * @iocbq: Pointer to command iocb.
  * @wqe: Pointer to the work queue entry.
  *
  * This routine converts the iocb command to its Work Queue Entry
 		else
 			ndlp = (struct lpfc_nodelist *)iocbq->context1;
 		if (!iocbq->iocb.ulpLe) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2007 Only Limited Edition cmd Format"
 				" supported 0x%x\n",
 				iocbq->iocb.ulpCommand);
 		/* word6 context tag copied in memcpy */
 		if (iocbq->iocb.ulpCt_h  || iocbq->iocb.ulpCt_l) {
 			ct = ((iocbq->iocb.ulpCt_h << 1) | iocbq->iocb.ulpCt_l);
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2015 Invalid CT %x command 0x%x\n",
 				ct, iocbq->iocb.ulpCommand);
 			return IOCB_ERROR;
 	case CMD_FCP_TRSP64_CX: /* Target mode rcv */
 	case CMD_FCP_AUTO_TRSP_CX: /* Auto target rsp */
 	default:
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2014 Invalid command 0x%x\n",
 				iocbq->iocb.ulpCommand);
 		return IOCB_ERROR;
 	return 0;
 }
-/**
+/*
  * __lpfc_sli_issue_iocb - Wrapper func of lockless version for issuing iocb
  *
  * This routine wraps the actual lockless version for issusing IOCB function
 		phba->__lpfc_sli_release_iocbq = __lpfc_sli_release_iocbq_s4;
 		break;
 	default:
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"1419 Invalid HBA PCI-device group: 0x%x\n",
 				dev_grp);
 		return -ENODEV;
 /**
  * lpfc_sli_issue_iocb - Wrapper function for __lpfc_sli_issue_iocb
  * @phba: Pointer to HBA context object.
- * @pring: Pointer to driver SLI ring object.
+ * @ring_number: Ring number
  * @piocb: Pointer to command iocb.
  * @flag: Flag indicating if this command can be put into txq.
  *
 		temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
 		if (evt_code == ASYNC_TEMP_WARN) {
 			temp_event_data.event_code = LPFC_THRESHOLD_TEMP;
-			lpfc_printf_log(phba, KERN_ERR, LOG_TEMP,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0347 Adapter is very hot, please take "
 				"corrective action. temperature : %d Celsius\n",
 				(uint32_t) icmd->ulpContext);
 		} else {
 			temp_event_data.event_code = LPFC_NORMAL_TEMP;
-			lpfc_printf_log(phba, KERN_ERR, LOG_TEMP,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0340 Adapter temperature is OK now. "
 				"temperature : %d Celsius\n",
 				(uint32_t) icmd->ulpContext);
 		break;
 	default:
 		iocb_w = (uint32_t *) icmd;
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"0346 Ring %d handler: unexpected ASYNC_STATUS"
 			" evt_code 0x%x\n"
 			"W0  0x%08x W1  0x%08x W2  0x%08x W3  0x%08x\n"
 	}
 	spin_unlock_irq(&phba->hbalock);
-	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"0402 Cannot find virtual addr for buffer tag on "
 			"ring %d Data x%lx x%px x%px x%x\n",
 			pring->ringno, (unsigned long) tag,
 	}
 	spin_unlock_irq(&phba->hbalock);
-	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"0410 Cannot find virtual addr for mapped buf on "
 			"ring %d Data x%llx x%px x%px x%x\n",
 			pring->ringno, (unsigned long long)phys,
  * @pring: Pointer to driver SLI ring object.
  * @tgt_id: SCSI ID of the target.
  * @lun_id: LUN ID of the scsi device.
- * @taskmgmt_cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST.
+ * @cmd: LPFC_CTX_LUN/LPFC_CTX_TGT/LPFC_CTX_HOST.
  *
  * This function sends an abort command for every SCSI command
  * associated with the given virtual port pending on the ring
 /**
  * lpfc_sli_issue_iocb_wait - Synchronous function to issue iocb commands
  * @phba: Pointer to HBA context object..
- * @pring: Pointer to sli ring.
+ * @ring_number: Ring number
  * @piocb: Pointer to command iocb.
  * @prspiocbq: Pointer to response iocb.
  * @timeout: Timeout in number of seconds.
 			 * completed. Not that it completed successfully.
 			 * */
 		} else if (timeleft == 0) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"0338 IOCB wait timeout error - no "
 					"wake response Data x%x\n", timeout);
 			retval = IOCB_TIMEDOUT;
 		} else {
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"0330 IOCB wake NOT set, "
 					"Data x%x x%lx\n",
 					timeout, (timeleft / jiffies));
 /**
  * lpfc_sli_mbox_sys_shutdown - shutdown mailbox command sub-system
  * @phba: Pointer to HBA context.
+ * @mbx_action: Mailbox shutdown options.
  *
  * This function is called to shutdown the driver's mailbox sub-system.
  * It first marks the mailbox sub-system is in a block state to prevent
 		}
 		if ((~phba->sli4_hba.ue_mask_lo & uerr_sta_lo) ||
 		    (~phba->sli4_hba.ue_mask_hi & uerr_sta_hi)) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"1423 HBA Unrecoverable error: "
 					"uerr_lo_reg=0x%x, uerr_hi_reg=0x%x, "
 					"ue_mask_lo_reg=0x%x, "
 				readl(phba->sli4_hba.u.if_type2.ERR1regaddr);
 			phba->work_status[1] =
 				readl(phba->sli4_hba.u.if_type2.ERR2regaddr);
-			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"2885 Port Status Event: "
 					"port status reg 0x%x, "
 					"port smphr reg 0x%x, "
 		break;
 	case LPFC_SLI_INTF_IF_TYPE_1:
 	default:
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2886 HBA Error Attention on unsupported "
 				"if type %d.", if_type);
 		return 1;
 		ha_copy = lpfc_sli4_eratt_read(phba);
 		break;
 	default:
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0299 Invalid SLI revision (%d)\n",
 				phba->sli_rev);
 		ha_copy = 0;
 				 * Stray Mailbox Interrupt, mbxCommand <cmd>
 				 * mbxStatus <status>
 				 */
-				lpfc_printf_log(phba, KERN_ERR, LOG_MBOX |
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
-						LOG_SLI,
 						"(%d):0304 Stray Mailbox "
 						"Interrupt mbxCommand x%x "
 						"mbxStatus x%x\n",
 						if (rc != MBX_BUSY)
 							lpfc_printf_log(phba,
 							KERN_ERR,
-							LOG_MBOX | LOG_SLI,
+							LOG_TRACE_EVENT,
 							"0350 rc should have"
 							"been MBX_BUSY\n");
 						if (rc != MBX_NOT_FINISHED)
 							 MBX_NOWAIT);
 			} while (rc == MBX_NOT_FINISHED);
 			if (rc != MBX_SUCCESS)
-				lpfc_printf_log(phba, KERN_ERR, LOG_MBOX |
+				lpfc_printf_log(phba, KERN_ERR,
-						LOG_SLI, "0349 rc should be "
+						LOG_TRACE_EVENT,
+						"0349 rc should be "
 						"MBX_SUCCESS\n");
 		}
 /**
  * lpfc_sli4_els_wcqe_to_rspiocbq - Get response iocbq from els wcqe
  * @phba: Pointer to HBA context object.
- * @wcqe: Pointer to work-queue completion queue entry.
+ * @irspiocbq: Pointer to work-queue completion queue entry.
  *
  * This routine handles an ELS work-queue completion event and construct
  * a pseudo response ELS IODBQ from the SLI4 ELS WCQE for the common
 	/* Allocate a new internal CQ_EVENT entry */
 	cq_event = lpfc_sli4_cq_event_alloc(phba);
 	if (!cq_event) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0602 Failed to alloc CQ_EVENT entry\n");
 		return NULL;
 	}
 /**
  * lpfc_sli4_sp_handle_async_event - Handle an asynchronous event
  * @phba: Pointer to HBA context object.
- * @cqe: Pointer to mailbox completion queue entry.
+ * @mcqe: Pointer to mailbox completion queue entry.
  *
  * This routine process a mailbox completion queue entry with asynchronous
  * event.
 /**
  * lpfc_sli4_sp_handle_mbox_event - Handle a mailbox completion event
  * @phba: Pointer to HBA context object.
- * @cqe: Pointer to mailbox completion queue entry.
+ * @mcqe: Pointer to mailbox completion queue entry.
  *
  * This routine process a mailbox completion queue entry with mailbox
  * completion event.
 	spin_lock_irqsave(&phba->hbalock, iflags);
 	pmb = phba->sli.mbox_active;
 	if (unlikely(!pmb)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"1832 No pending MBOX command to handle\n");
 		spin_unlock_irqrestore(&phba->hbalock, iflags);
 		goto out_no_mqe_complete;
 			pmb->vport = vport;
 			rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
 			if (rc != MBX_BUSY)
-				lpfc_printf_log(phba, KERN_ERR, LOG_MBOX |
+				lpfc_printf_log(phba, KERN_ERR,
-						LOG_SLI, "0385 rc should "
+						LOG_TRACE_EVENT,
+						"0385 rc should "
 						"have been MBX_BUSY\n");
 			if (rc != MBX_NOT_FINISHED)
 				goto send_current_mbox;
 /**
  * lpfc_sli4_sp_handle_mcqe - Process a mailbox completion queue entry
  * @phba: Pointer to HBA context object.
+ * @cq: Pointer to associated CQ
  * @cqe: Pointer to mailbox completion queue entry.
  *
  * This routine process a mailbox completion queue entry, it invokes the
 			txq_cnt++;
 		if (!list_empty(&pring->txcmplq))
 			txcmplq_cnt++;
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"0387 NO IOCBQ data: txq_cnt=%d iocb_cnt=%d "
 			"els_txcmplq_cnt=%d\n",
 			txq_cnt, phba->iocb_cnt,
 		workposted = true;
 		break;
 	default:
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0603 Invalid CQ subtype %d: "
 				"%08x %08x %08x %08x\n",
 				cq->subtype, wcqe->word0, wcqe->parameter,
 	status = bf_get(lpfc_rcqe_status, rcqe);
 	switch (status) {
 	case FC_STATUS_RQ_BUF_LEN_EXCEEDED:
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2537 Receive Frame Truncated!!\n");
 		/* fall through */
 	case FC_STATUS_RQ_SUCCESS:
 	case FC_STATUS_INSUFF_BUF_FRM_DISC:
 		if (phba->nvmet_support) {
 			tgtp = phba->targetport->private;
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI | LOG_NVME,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"6402 RQE Error x%x, posted %d err_cnt "
 					"%d: %x %x %x\n",
 					status, hrq->RQ_buf_posted,
 				(struct lpfc_rcqe *)&cqevt);
 		break;
 	default:
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0388 Not a valid WCQE code: x%x\n",
 				bf_get(lpfc_cqe_code, &cqevt));
 		break;
  * lpfc_sli4_sp_handle_eqe - Process a slow-path event queue entry
  * @phba: Pointer to HBA context object.
  * @eqe: Pointer to fast-path event queue entry.
+ * @speq: Pointer to slow-path event queue.
  *
  * This routine process a event queue entry from the slow-path event queue.
  * It will check the MajorCode and MinorCode to determine this is for a
 {
 	struct lpfc_queue *cq = NULL, *childq;
 	uint16_t cqid;
+	int ret = 0;
 	/* Get the reference to the corresponding CQ */
 	cqid = bf_get_le32(lpfc_eqe_resource_id, eqe);
 	}
 	if (unlikely(!cq)) {
 		if (phba->sli.sli_flag & LPFC_SLI_ACTIVE)
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"0365 Slow-path CQ identifier "
 					"(%d) does not exist\n", cqid);
 		return;
 	/* Save EQ associated with this CQ */
 	cq->assoc_qp = speq;
-	if (!queue_work_on(cq->chann, phba->wq, &cq->spwork))
+	if (is_kdump_kernel())
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		ret = queue_work(phba->wq, &cq->spwork);
-				"0390 Cannot schedule soft IRQ "
+	else
+		ret = queue_work_on(cq->chann, phba->wq, &cq->spwork);
+	if (!ret)
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
+				"0390 Cannot schedule queue work "
 				"for CQ eqcqid=%d, cqid=%d on CPU %d\n",
 				cqid, cq->queue_id, raw_smp_processor_id());
 }
  * @cq: Pointer to CQ to be processed
  * @handler: Routine to process each cqe
  * @delay: Pointer to usdelay to set in case of rescheduling of the handler
+ * @poll_mode: Polling mode we were called from
  *
  * This routine processes completion queue entries in a CQ. While a valid
  * queue element is found, the handler is called. During processing checks
 static bool
 __lpfc_sli4_process_cq(struct lpfc_hba *phba, struct lpfc_queue *cq,
 	bool (*handler)(struct lpfc_hba *, struct lpfc_queue *,
-			struct lpfc_cqe *), unsigned long *delay)
+			struct lpfc_cqe *), unsigned long *delay,
+			enum lpfc_poll_mode poll_mode)
 {
 	struct lpfc_cqe *cqe;
 	bool workposted = false;
 		arm = false;
 	}
+	/* Note: complete the irq_poll softirq before rearming CQ */
+	if (poll_mode == LPFC_IRQ_POLL)
+		irq_poll_complete(&cq->iop);
 	/* Track the max number of CQEs processed in 1 EQ */
 	if (count > cq->CQ_max_cqe)
 		cq->CQ_max_cqe = count;
 	struct lpfc_hba *phba = cq->phba;
 	unsigned long delay;
 	bool workposted = false;
+	int ret = 0;
 	/* Process and rearm the CQ */
 	switch (cq->type) {
 	case LPFC_MCQ:
 		workposted |= __lpfc_sli4_process_cq(phba, cq,
 						lpfc_sli4_sp_handle_mcqe,
-						&delay);
+						&delay, LPFC_QUEUE_WORK);
 		break;
 	case LPFC_WCQ:
 		if (cq->subtype == LPFC_IO)
 			workposted |= __lpfc_sli4_process_cq(phba, cq,
 						lpfc_sli4_fp_handle_cqe,
-						&delay);
+						&delay, LPFC_QUEUE_WORK);
 		else
 			workposted |= __lpfc_sli4_process_cq(phba, cq,
 						lpfc_sli4_sp_handle_cqe,
-						&delay);
+						&delay, LPFC_QUEUE_WORK);
 		break;
 	default:
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0370 Invalid completion queue type (%d)\n",
 				cq->type);
 		return;
 	}
 	if (delay) {
-		if (!queue_delayed_work_on(cq->chann, phba->wq,
+		if (is_kdump_kernel())
-					   &cq->sched_spwork, delay))
+			ret = queue_delayed_work(phba->wq, &cq->sched_spwork,
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+						delay);
-				"0394 Cannot schedule soft IRQ "
+		else
+			ret = queue_delayed_work_on(cq->chann, phba->wq,
+						&cq->sched_spwork, delay);
+		if (!ret)
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
+				"0394 Cannot schedule queue work "
 				"for cqid=%d on CPU %d\n",
 				cq->queue_id, cq->chann);
 	}
 		     IOERR_NO_RESOURCES))
 			phba->lpfc_rampdown_queue_depth(phba);
-		/* Log the error status */
+		/* Log the cmpl status */
 		lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
-				"0373 FCP CQE error: status=x%x: "
+				"0373 FCP CQE cmpl: status=x%x: "
 				"CQE: %08x %08x %08x %08x\n",
 				bf_get(lpfc_wcqe_c_status, wcqe),
 				wcqe->word0, wcqe->total_data_placed,
 /**
  * lpfc_sli4_nvmet_handle_rcqe - Process a receive-queue completion queue entry
  * @phba: Pointer to HBA context object.
+ * @cq: Pointer to completion queue.
  * @rcqe: Pointer to receive-queue completion queue entry.
  *
  * This routine process a receive-queue completion queue entry.
 	status = bf_get(lpfc_rcqe_status, rcqe);
 	switch (status) {
 	case FC_STATUS_RQ_BUF_LEN_EXCEEDED:
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6126 Receive Frame Truncated!!\n");
 		/* fall through */
 	case FC_STATUS_RQ_SUCCESS:
 	case FC_STATUS_INSUFF_BUF_FRM_DISC:
 		if (phba->nvmet_support) {
 			tgtp = phba->targetport->private;
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI | LOG_NVME,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"6401 RQE Error x%x, posted %d err_cnt "
 					"%d: %x %x %x\n",
 					status, hrq->RQ_buf_posted,
  * lpfc_sli4_fp_handle_cqe - Process fast-path work queue completion entry
  * @phba: adapter with cq
  * @cq: Pointer to the completion queue.
- * @eqe: Pointer to fast-path completion queue entry.
+ * @cqe: Pointer to fast-path completion queue entry.
  *
  * This routine process a fast-path work queue completion entry from fast-path
  * event queue for FCP command response completion.
 		}
 		break;
 	default:
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0144 Not a valid CQE code: x%x\n",
 				bf_get(lpfc_wcqe_c_code, &wcqe));
 		break;
 	return workposted;
 }
+/**
+ * lpfc_sli4_sched_cq_work - Schedules cq work
+ * @phba: Pointer to HBA context object.
+ * @cq: Pointer to CQ
+ * @cqid: CQ ID
+ *
+ * This routine checks the poll mode of the CQ corresponding to
+ * cq->chann, then either schedules a softirq or queue_work to complete
+ * cq work.
+ *
+ * queue_work path is taken if in NVMET mode, or if poll_mode is in
+ * LPFC_QUEUE_WORK mode.  Otherwise, softirq path is taken.
+ *
+ **/
+static void lpfc_sli4_sched_cq_work(struct lpfc_hba *phba,
+				    struct lpfc_queue *cq, uint16_t cqid)
+{
+	int ret = 0;
+	switch (cq->poll_mode) {
+	case LPFC_IRQ_POLL:
+		irq_poll_sched(&cq->iop);
+		break;
+	case LPFC_QUEUE_WORK:
+	default:
+		if (is_kdump_kernel())
+			ret = queue_work(phba->wq, &cq->irqwork);
+		else
+			ret = queue_work_on(cq->chann, phba->wq, &cq->irqwork);
+		if (!ret)
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
+					"0383 Cannot schedule queue work "
+					"for CQ eqcqid=%d, cqid=%d on CPU %d\n",
+					cqid, cq->queue_id,
+					raw_smp_processor_id());
+	}
+}
 /**
  * lpfc_sli4_hba_handle_eqe - Process a fast-path event queue entry
  * @phba: Pointer to HBA context object.
+ * @eq: Pointer to the queue structure.
  * @eqe: Pointer to fast-path event queue entry.
  *
  * This routine process a event queue entry from the fast-path event queue.
 	uint16_t cqid, id;
 	if (unlikely(bf_get_le32(lpfc_eqe_major_code, eqe) != 0)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0366 Not a valid completion "
 				"event: majorcode=x%x, minorcode=x%x\n",
 				bf_get_le32(lpfc_eqe_major_code, eqe),
 process_cq:
 	if (unlikely(cqid != cq->queue_id)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0368 Miss-matched fast-path completion "
 				"queue identifier: eqcqid=%d, fcpcqid=%d\n",
 				cqid, cq->queue_id);
 	else
 		cq->isr_timestamp = 0;
 #endif
-	if (!queue_work_on(cq->chann, phba->wq, &cq->irqwork))
+	lpfc_sli4_sched_cq_work(phba, cq, cqid);
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
-				"0363 Cannot schedule soft IRQ "
-				"for CQ eqcqid=%d, cqid=%d on CPU %d\n",
-				cqid, cq->queue_id, raw_smp_processor_id());
 }
 /**
  * __lpfc_sli4_hba_process_cq - Process a fast-path event queue entry
  * @cq: Pointer to CQ to be processed
+ * @poll_mode: Enum lpfc_poll_state to determine poll mode
  *
  * This routine calls the cq processing routine with the handler for
  * fast path CQEs.
  * the delay indicates when to reschedule it.
  **/
 static void
-__lpfc_sli4_hba_process_cq(struct lpfc_queue *cq)
+__lpfc_sli4_hba_process_cq(struct lpfc_queue *cq,
+			   enum lpfc_poll_mode poll_mode)
 {
 	struct lpfc_hba *phba = cq->phba;
 	unsigned long delay;
 	bool workposted = false;
+	int ret = 0;
 	/* process and rearm the CQ */
 	workposted |= __lpfc_sli4_process_cq(phba, cq, lpfc_sli4_fp_handle_cqe,
-					     &delay);
+					     &delay, poll_mode);
 	if (delay) {
-		if (!queue_delayed_work_on(cq->chann, phba->wq,
+		if (is_kdump_kernel())
-					   &cq->sched_irqwork, delay))
+			ret = queue_delayed_work(phba->wq, &cq->sched_irqwork,
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+						delay);
-				"0367 Cannot schedule soft IRQ "
+		else
-				"for cqid=%d on CPU %d\n",
+			ret = queue_delayed_work_on(cq->chann, phba->wq,
-				cq->queue_id, cq->chann);
+						&cq->sched_irqwork, delay);
+		if (!ret)
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
+					"0367 Cannot schedule queue work "
+					"for cqid=%d on CPU %d\n",
+					cq->queue_id, cq->chann);
 	}
 	/* wake up worker thread if there are works to be done */
 {
 	struct lpfc_queue *cq = container_of(work, struct lpfc_queue, irqwork);
-	__lpfc_sli4_hba_process_cq(cq);
+	__lpfc_sli4_hba_process_cq(cq, LPFC_QUEUE_WORK);
 }
 /**
 	struct lpfc_queue *cq = container_of(to_delayed_work(work),
 					struct lpfc_queue, sched_irqwork);
-	__lpfc_sli4_hba_process_cq(cq);
+	__lpfc_sli4_hba_process_cq(cq, LPFC_QUEUE_WORK);
 }
 /**
  * @phba: The HBA that this queue is being created on.
  * @page_size: The size of a queue page
  * @entry_size: The size of each queue entry for this queue.
- * @entry count: The number of entries that this queue will handle.
+ * @entry_count: The number of entries that this queue will handle.
  * @cpu: The cpu that will primarily utilize this queue.
  *
  * This function allocates a queue structure and the DMAable memory used for
 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 	if (!mbox) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_FCP | LOG_NVME,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6428 Failed allocating mailbox cmd buffer."
 				" EQ delay was not set.\n");
 		return;
 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2512 MODIFY_EQ_DELAY mailbox failed with "
 				"status x%x add_status x%x, mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 	       dmult);
 	switch (eq->entry_count) {
 	default:
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0360 Unsupported EQ count. (%d)\n",
 				eq->entry_count);
 		if (eq->entry_count < 256) {
 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2500 EQ_CREATE mailbox failed with "
 				"status x%x add_status x%x, mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 	return status;
 }
+static int lpfc_cq_poll_hdler(struct irq_poll *iop, int budget)
+{
+	struct lpfc_queue *cq = container_of(iop, struct lpfc_queue, iop);
+	__lpfc_sli4_hba_process_cq(cq, LPFC_IRQ_POLL);
+	return 1;
+}
 /**
  * lpfc_cq_create - Create a Completion Queue on the HBA
  * @phba: HBA structure that indicates port to create a queue on.
  * @cq: The queue structure to use to create the completion queue.
  * @eq: The event queue to bind this completion queue to.
+ * @type: Type of queue (EQ, GCQ, MCQ, WCQ, etc).
+ * @subtype: Functional purpose of the queue (MBOX, IO, ELS, NVMET, etc).
  *
  * This function creates a completion queue, as detailed in @wq, on a port,
  * described by @phba by sending a CQ_CREATE mailbox command to the HBA.
 		}
 		/* fall through */
 	default:
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0361 Unsupported CQ count: "
 				"entry cnt %d sz %d pg cnt %d\n",
 				cq->entry_count, cq->entry_size,
 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2501 CQ_CREATE mailbox failed with "
 				"status x%x add_status x%x, mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 	if (cq->queue_id > phba->sli4_hba.cq_max)
 		phba->sli4_hba.cq_max = cq->queue_id;
+	irq_poll_init(&cq->iop, LPFC_IRQ_POLL_WEIGHT, lpfc_cq_poll_hdler);
 out:
 	mempool_free(mbox, phba->mbox_mem_pool);
 	return status;
  * @phba: HBA structure that indicates port to create a queue on.
  * @cqp: The queue structure array to use to create the completion queues.
  * @hdwq: The hardware queue array  with the EQ to bind completion queues to.
+ * @type: Type of queue (EQ, GCQ, MCQ, WCQ, etc).
+ * @subtype: Functional purpose of the queue (MBOX, IO, ELS, NVMET, etc).
  *
  * This function creates a set of  completion queue, s to support MRQ
  * as detailed in @cqp, on a port,
 			LPFC_MBOX_OPCODE_FCOE_CQ_CREATE_SET, length,
 			LPFC_SLI4_MBX_NEMBED);
 	if (alloclen < length) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"3098 Allocated DMA memory size (%d) is "
 				"less than the requested DMA memory size "
 				"(%d)\n", alloclen, length);
 				}
 				/* fall through */
 			default:
-				lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 						"3118 Bad CQ count. (%d)\n",
 						cq->entry_count);
 				if (cq->entry_count < 256) {
 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"3119 CQ_CREATE_SET mailbox failed with "
 				"status x%x add_status x%x, mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 		       cq->queue_id);
 	switch (mq->entry_count) {
 	default:
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0362 Unsupported MQ count. (%d)\n",
 				mq->entry_count);
 		if (mq->entry_count < 16) {
 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2502 MQ_CREATE mailbox failed with "
 				"status x%x add_status x%x, mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 	uint16_t pci_barset;
 	uint8_t dpp_barset;
 	uint32_t dpp_offset;
-	unsigned long pg_addr;
 	uint8_t wq_create_version;
+#ifdef CONFIG_X86
+	unsigned long pg_addr;
+#endif
 	/* sanity check on queue memory */
 	if (!wq || !cq)
 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2503 WQ_CREATE mailbox failed with "
 				"status x%x add_status x%x, mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 					       &wq_create->u.response);
 			if ((wq->db_format != LPFC_DB_LIST_FORMAT) &&
 			    (wq->db_format != LPFC_DB_RING_FORMAT)) {
-				lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 						"3265 WQ[%d] doorbell format "
 						"not supported: x%x\n",
 						wq->queue_id, wq->db_format);
 			bar_memmap_p = lpfc_dual_chute_pci_bar_map(phba,
 								   pci_barset);
 			if (!bar_memmap_p) {
-				lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 						"3263 WQ[%d] failed to memmap "
 						"pci barset:x%x\n",
 						wq->queue_id, pci_barset);
 			db_offset = wq_create->u.response.doorbell_offset;
 			if ((db_offset != LPFC_ULP0_WQ_DOORBELL) &&
 			    (db_offset != LPFC_ULP1_WQ_DOORBELL)) {
-				lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 						"3252 WQ[%d] doorbell offset "
 						"not supported: x%x\n",
 						wq->queue_id, db_offset);
 			bar_memmap_p = lpfc_dual_chute_pci_bar_map(phba,
 								   pci_barset);
 			if (!bar_memmap_p) {
-				lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 						"3267 WQ[%d] failed to memmap "
 						"pci barset:x%x\n",
 						wq->queue_id, pci_barset);
 			bar_memmap_p = lpfc_dual_chute_pci_bar_map(phba,
 								   dpp_barset);
 			if (!bar_memmap_p) {
-				lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+				lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 						"3268 WQ[%d] failed to memmap "
 						"pci barset:x%x\n",
 						wq->queue_id, dpp_barset);
 					wq->queue_id, pci_barset, db_offset,
 					wq->dpp_id, dpp_barset, dpp_offset);
+#ifdef CONFIG_X86
 			/* Enable combined writes for DPP aperture */
 			pg_addr = (unsigned long)(wq->dpp_regaddr) & PAGE_MASK;
-#ifdef CONFIG_X86
 			rc = set_memory_wc(pg_addr, 1);
 			if (rc) {
 				lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
  * @hrq: The queue structure to use to create the header receive queue.
  * @drq: The queue structure to use to create the data receive queue.
  * @cq: The completion queue to bind this work queue to.
+ * @subtype: The subtype of the work queue indicating its functionality.
  *
  * This function creates a receive buffer queue pair , as detailed in @hrq and
  * @drq, on a port, described by @phba by sending a RQ_CREATE mailbox command
 	} else {
 		switch (hrq->entry_count) {
 		default:
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"2535 Unsupported RQ count. (%d)\n",
 					hrq->entry_count);
 			if (hrq->entry_count < 512) {
 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2504 RQ_CREATE mailbox failed with "
 				"status x%x add_status x%x, mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 					&rq_create->u.response);
 		if ((hrq->db_format != LPFC_DB_LIST_FORMAT) &&
 		    (hrq->db_format != LPFC_DB_RING_FORMAT)) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"3262 RQ [%d] doorbell format not "
 					"supported: x%x\n", hrq->queue_id,
 					hrq->db_format);
 				    &rq_create->u.response);
 		bar_memmap_p = lpfc_dual_chute_pci_bar_map(phba, pci_barset);
 		if (!bar_memmap_p) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"3269 RQ[%d] failed to memmap pci "
 					"barset:x%x\n", hrq->queue_id,
 					pci_barset);
 		db_offset = rq_create->u.response.doorbell_offset;
 		if ((db_offset != LPFC_ULP0_RQ_DOORBELL) &&
 		    (db_offset != LPFC_ULP1_RQ_DOORBELL)) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"3270 RQ[%d] doorbell offset not "
 					"supported: x%x\n", hrq->queue_id,
 					db_offset);
 	} else {
 		switch (drq->entry_count) {
 		default:
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"2536 Unsupported RQ count. (%d)\n",
 					drq->entry_count);
 			if (drq->entry_count < 512) {
  * @hrqp: The queue structure array to use to create the header receive queues.
  * @drqp: The queue structure array to use to create the data receive queues.
  * @cqp: The completion queue array to bind these receive queues to.
+ * @subtype: Functional purpose of the queue (MBOX, IO, ELS, NVMET, etc).
  *
  * This function creates a receive buffer queue pair , as detailed in @hrq and
  * @drq, on a port, described by @phba by sending a RQ_CREATE mailbox command
 				    LPFC_MBOX_OPCODE_FCOE_RQ_CREATE, length,
 				    LPFC_SLI4_MBX_NEMBED);
 	if (alloclen < length) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"3099 Allocated DMA memory size (%d) is "
 				"less than the requested DMA memory size "
 				"(%d)\n", alloclen, length);
 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"3120 RQ_CREATE mailbox failed with "
 				"status x%x add_status x%x, mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 /**
  * lpfc_eq_destroy - Destroy an event Queue on the HBA
+ * @phba: HBA structure that indicates port to destroy a queue on.
  * @eq: The queue structure associated with the queue to destroy.
  *
  * This function destroys a queue, as detailed in @eq by sending an mailbox
 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2505 EQ_DESTROY mailbox failed with "
 				"status x%x add_status x%x, mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 /**
  * lpfc_cq_destroy - Destroy a Completion Queue on the HBA
+ * @phba: HBA structure that indicates port to destroy a queue on.
  * @cq: The queue structure associated with the queue to destroy.
  *
  * This function destroys a queue, as detailed in @cq by sending an mailbox
 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2506 CQ_DESTROY mailbox failed with "
 				"status x%x add_status x%x, mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 /**
  * lpfc_mq_destroy - Destroy a Mailbox Queue on the HBA
- * @qm: The queue structure associated with the queue to destroy.
+ * @phba: HBA structure that indicates port to destroy a queue on.
+ * @mq: The queue structure associated with the queue to destroy.
  *
  * This function destroys a queue, as detailed in @mq by sending an mailbox
  * command, specific to the type of queue, to the HBA.
 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2507 MQ_DESTROY mailbox failed with "
 				"status x%x add_status x%x, mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 /**
  * lpfc_wq_destroy - Destroy a Work Queue on the HBA
+ * @phba: HBA structure that indicates port to destroy a queue on.
  * @wq: The queue structure associated with the queue to destroy.
  *
  * This function destroys a queue, as detailed in @wq by sending an mailbox
 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2508 WQ_DESTROY mailbox failed with "
 				"status x%x add_status x%x, mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 /**
  * lpfc_rq_destroy - Destroy a Receive Queue on the HBA
- * @rq: The queue structure associated with the queue to destroy.
+ * @phba: HBA structure that indicates port to destroy a queue on.
+ * @hrq: The queue structure associated with the queue to destroy.
+ * @drq: The queue structure associated with the queue to destroy.
  *
  * This function destroys a queue, as detailed in @rq by sending an mailbox
  * command, specific to the type of queue, to the HBA.
 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2509 RQ_DESTROY mailbox failed with "
 				"status x%x add_status x%x, mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
 	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2510 RQ_DESTROY mailbox failed with "
 				"status x%x add_status x%x, mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 	union lpfc_sli4_cfg_shdr *shdr;
 	if (xritag == NO_XRI) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0364 Invalid param:\n");
 		return -EINVAL;
 	}
 	if (rc != MBX_TIMEOUT)
 		mempool_free(mbox, phba->mbox_mem_pool);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2511 POST_SGL mailbox failed with "
 				"status x%x add_status x%x, mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 /**
  * lpfc_sli4_free_xri - Release an xri for reuse.
  * @phba: pointer to lpfc hba data structure.
+ * @xri: xri to release.
  *
  * This routine is invoked to release an xri to the pool of
  * available rpis maintained by the driver.
 /**
  * lpfc_sli4_free_xri - Release an xri for reuse.
  * @phba: pointer to lpfc hba data structure.
+ * @xri: xri to release.
  *
  * This routine is invoked to release an xri to the pool of
  * available rpis maintained by the driver.
  * lpfc_sli4_post_sgl_list - post a block of ELS sgls to the port.
  * @phba: pointer to lpfc hba data structure.
  * @post_sgl_list: pointer to els sgl entry list.
- * @count: number of els sgl entries on the list.
+ * @post_cnt: number of els sgl entries on the list.
  *
  * This routine is invoked to post a block of driver's sgl pages to the
  * HBA using non-embedded mailbox command. No Lock is held. This routine
 	reqlen = post_cnt * sizeof(struct sgl_page_pairs) +
 		 sizeof(union lpfc_sli4_cfg_shdr) + sizeof(uint32_t);
 	if (reqlen > SLI4_PAGE_SIZE) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2559 Block sgl registration required DMA "
 				"size (%d) great than a page\n", reqlen);
 		return -ENOMEM;
 			 LPFC_SLI4_MBX_NEMBED);
 	if (alloclen < reqlen) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"0285 Allocated DMA memory size (%d) is "
 				"less than the requested DMA memory "
 				"size (%d)\n", alloclen, reqlen);
 	if (rc != MBX_TIMEOUT)
 		lpfc_sli4_mbox_cmd_free(phba, mbox);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2513 POST_SGL_BLOCK mailbox command failed "
 				"status x%x add_status x%x mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 	}
 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 	if (!mbox) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6119 Failed to allocate mbox cmd memory\n");
 		return -ENOMEM;
 	}
 				    reqlen, LPFC_SLI4_MBX_NEMBED);
 	if (alloclen < reqlen) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6120 Allocated DMA memory size (%d) is "
 				"less than the requested DMA memory "
 				"size (%d)\n", alloclen, reqlen);
 	if (rc != MBX_TIMEOUT)
 		lpfc_sli4_mbox_cmd_free(phba, mbox);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"6125 POST_SGL_BLOCK mailbox command failed "
 				"status x%x add_status x%x mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
  * lpfc_sli4_post_io_sgl_list - Post blocks of nvme buffer sgls from a list
  * @phba: pointer to lpfc hba data structure.
  * @post_nblist: pointer to the nvme buffer list.
+ * @sb_count: number of nvme buffers.
  *
  * This routine walks a list of nvme buffers that was passed in. It attempts
  * to construct blocks of nvme buffer sgls which contains contiguous xris and
  * @phba: Pointer to the HBA structure to search for the vport on
  * @fc_hdr: A pointer to the FC Header data (In Big Endian Format)
  * @fcfi: The FC Fabric ID that the frame came from
+ * @did: Destination ID to match against
  *
  * This function searches the @phba for a vport that matches the content of the
  * @fc_hdr passed in and the @fcfi. This function uses the @fc_hdr to fetch the
 /**
  * lpfc_fc_frame_add - Adds a frame to the vport's list of received sequences
+ * @vport: pointer to a vitural port
  * @dmabuf: pointer to a dmabuf that describes the hdr and data of the FC frame
  *
  * This function searches through the existing incomplete sequences that have
 	/* Failure means BLS ABORT RSP did not get delivered to remote node*/
 	if (rsp_iocbq && rsp_iocbq->iocb.ulpStatus)
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"3154 BLS ABORT RSP failed, data:  x%x/x%x\n",
 			rsp_iocbq->iocb.ulpStatus,
 			rsp_iocbq->iocb.un.ulpWord[4]);
 /**
  * lpfc_sli4_seq_abort_rsp - bls rsp to sequence abort
- * @phba: Pointer to HBA context object.
+ * @vport: pointer to a vitural port.
  * @fc_hdr: pointer to a FC frame header.
+ * @aborted: was the partially assembled receive sequence successfully aborted
  *
  * This function sends a basic response to a previous unsol sequence abort
  * event after aborting the sequence handling.
 	rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, ctiocb, 0);
 	if (rc == IOCB_ERROR) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "2925 Failed to issue CT ABTS RSP x%x on "
 				 "xri x%x, Data x%x\n",
 				 icmd->un.xseq64.w5.hcsw.Rctl, oxid,
  * receive sequence is only partially assembed by the driver, it shall abort
  * the partially assembled frames for the sequence. Otherwise, if the
  * unsolicited receive sequence has been completely assembled and passed to
- * the Upper Layer Protocol (UPL), it then mark the per oxid status for the
+ * the Upper Layer Protocol (ULP), it then mark the per oxid status for the
  * unsolicited sequence has been aborted. After that, it will issue a basic
  * accept to accept the abort.
  **/
 /**
  * lpfc_prep_seq - Prep sequence for ULP processing
  * @vport: Pointer to the vport on which this sequence was received
- * @dmabuf: pointer to a dmabuf that describes the FC sequence
+ * @seq_dmabuf: pointer to a dmabuf that describes the FC sequence
  *
  * This function takes a sequence, described by a list of frames, and creates
  * a list of iocbq structures to describe the sequence. This iocbq list will be
 	fc_hdr = (struct fc_frame_header *)seq_dmabuf->hbuf.virt;
 	iocbq = lpfc_prep_seq(vport, seq_dmabuf);
 	if (!iocbq) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2707 Ring %d handler: Failed to allocate "
 				"iocb Rctl x%x Type x%x received\n",
 				LPFC_ELS_RING,
 				      phba->sli4_hba.els_wq->pring,
 				      iocbq, fc_hdr->fh_r_ctl,
 				      fc_hdr->fh_type))
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2540 Ring %d handler: unexpected Rctl "
 				"x%x Type x%x received\n",
 				LPFC_ELS_RING,
 /**
  * lpfc_sli4_handle_received_buffer - Handle received buffers from firmware
  * @phba: Pointer to HBA context object.
+ * @dmabuf: Pointer to a dmabuf that describes the FC sequence.
  *
  * This function is called with no lock held. This function processes all
  * the received buffers and gives it to upper layers when a received buffer
 		rc = lpfc_sli4_post_rpi_hdr(phba, rpi_page);
 		if (rc != MBX_SUCCESS) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"2008 Error %d posting all rpi "
 					"headers\n", rc);
 			rc = -EIO;
 	/* The port is notified of the header region via a mailbox command. */
 	mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 	if (!mboxq) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2001 Unable to allocate memory for issuing "
 				"SLI_CONFIG_SPECIAL mailbox command\n");
 		return -ENOMEM;
 	if (rc != MBX_TIMEOUT)
 		mempool_free(mboxq, phba->mbox_mem_pool);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2514 POST_RPI_HDR mailbox failed with "
 				"status x%x add_status x%x, mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 	if (rpi_remaining < LPFC_RPI_LOW_WATER_MARK) {
 		rpi_hdr = lpfc_sli4_create_rpi_hdr(phba);
 		if (!rpi_hdr) {
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"2002 Error Could not grow rpi "
 					"count\n");
 		} else {
 /**
  * lpfc_sli4_free_rpi - Release an rpi for reuse.
  * @phba: pointer to lpfc hba data structure.
+ * @rpi: rpi to free
  *
  * This routine is invoked to release an rpi to the pool of
  * available rpis maintained by the driver.
 /**
  * lpfc_sli4_free_rpi - Release an rpi for reuse.
  * @phba: pointer to lpfc hba data structure.
+ * @rpi: rpi to free
  *
  * This routine is invoked to release an rpi to the pool of
  * available rpis maintained by the driver.
 /**
  * lpfc_sli4_resume_rpi - Remove the rpi bitmask region
- * @phba: pointer to lpfc hba data structure.
+ * @ndlp: pointer to lpfc nodelist data structure.
+ * @cmpl: completion call-back.
+ * @arg: data to load as MBox 'caller buffer information'
  *
  * This routine is invoked to remove the memory region that
  * provided rpi via a bitmask.
 	mboxq->vport = ndlp->vport;
 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
 	if (rc == MBX_NOT_FINISHED) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2010 Resume RPI Mailbox failed "
 				"status %d, mbxStatus x%x\n", rc,
 				bf_get(lpfc_mqe_status, &mboxq->u.mqe));
 	mbox_tmo = lpfc_mbox_tmo_val(phba, mboxq);
 	rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
 	if (rc != MBX_SUCCESS) {
-		lpfc_printf_vlog(vport, KERN_ERR, LOG_SLI,
+		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				"2022 INIT VPI Mailbox failed "
 				"status %d, mbxStatus x%x\n", rc,
 				bf_get(lpfc_mqe_status, &mboxq->u.mqe));
 	if ((shdr_status || shdr_add_status) &&
 		(shdr_status != STATUS_FCF_IN_USE))
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"2558 ADD_FCF_RECORD mailbox failed with "
 			"status x%x add_status x%x\n",
 			shdr_status, shdr_add_status);
 	mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 	if (!mboxq) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"2009 Failed to allocate mbox for ADD_FCF cmd\n");
 		return -ENOMEM;
 	}
 				     LPFC_MBOX_OPCODE_FCOE_ADD_FCF,
 				     req_len, LPFC_SLI4_MBX_NEMBED);
 	if (alloc_len < req_len) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"2523 Allocated DMA memory size (x%x) is "
 			"less than the requested DMA memory "
 			"size (x%x)\n", alloc_len, req_len);
 	mboxq->mbox_cmpl = lpfc_mbx_cmpl_add_fcf_record;
 	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
 	if (rc == MBX_NOT_FINISHED) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"2515 ADD_FCF_RECORD mailbox failed with "
 			"status 0x%x\n", rc);
 		lpfc_sli4_mbox_cmd_free(phba, mboxq);
 	phba->fcoe_cvl_eventtag_attn = phba->fcoe_cvl_eventtag;
 	mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 	if (!mboxq) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2000 Failed to allocate mbox for "
 				"READ_FCF cmd\n");
 		error = -ENOMEM;
 /**
  * lpfc_check_next_fcf_pri_level
- * phba pointer to the lpfc_hba struct for this port.
+ * @phba: pointer to the lpfc_hba struct for this port.
  * This routine is called from the lpfc_sli4_fcf_rr_next_index_get
  * routine when the rr_bmask is empty. The FCF indecies are put into the
  * rr_bmask based on their priority level. Starting from the highest priority
 /**
  * lpfc_sli4_fcf_rr_index_set - Set bmask with eligible fcf record index
  * @phba: pointer to lpfc hba data structure.
+ * @fcf_index: index into the FCF table to 'set'
  *
  * This routine sets the FCF record index in to the eligible bmask for
  * roundrobin failover search. It checks to make sure that the index
 /**
  * lpfc_sli4_fcf_rr_index_clear - Clear bmask from eligible fcf record index
  * @phba: pointer to lpfc hba data structure.
+ * @fcf_index: index into the FCF table to 'clear'
  *
  * This routine clears the FCF record index from the eligible bmask for
  * roundrobin failover search. It checks to make sure that the index
 /**
  * lpfc_mbx_cmpl_redisc_fcf_table - completion routine for rediscover FCF table
  * @phba: pointer to lpfc hba data structure.
+ * @mbox: An allocated pointer to type LPFC_MBOXQ_t
  *
  * This routine is the completion routine for the rediscover FCF table mailbox
  * command. If the mailbox command returned failure, it will try to stop the
 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 	if (!mbox) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2745 Failed to allocate mbox for "
 				"requesting FCF rediscover.\n");
 		return -ENOMEM;
 	LPFC_MBOXQ_t *pmb = NULL;
 	MAILBOX_t *mb;
 	uint32_t offset = 0;
-	int rc;
+	int i, rc;
 	if (!rgn23_data)
 		return 0;
 	pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 	if (!pmb) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2600 failed to allocate mailbox memory\n");
 		return 0;
 	}
 		 */
 		if (mb->un.varDmp.word_cnt == 0)
 			break;
-		if (mb->un.varDmp.word_cnt > DMP_RGN23_SIZE - offset)
-			mb->un.varDmp.word_cnt = DMP_RGN23_SIZE - offset;
+		i =  mb->un.varDmp.word_cnt * sizeof(uint32_t);
+		if (offset + i >  DMP_RGN23_SIZE)
+			i =  DMP_RGN23_SIZE - offset;
 		lpfc_sli_pcimem_bcopy(((uint8_t *)mb) + DMP_RSP_OFFSET,
-				       rgn23_data + offset,
+				      rgn23_data  + offset, i);
-				       mb->un.varDmp.word_cnt);
+		offset += i;
-		offset += mb->un.varDmp.word_cnt;
+	} while (offset < DMP_RGN23_SIZE);
-	} while (mb->un.varDmp.word_cnt && offset < DMP_RGN23_SIZE);
 	mempool_free(pmb, phba->mbox_mem_pool);
 	return offset;
 	mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 	if (!mboxq) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"3105 failed to allocate mailbox memory\n");
 		return 0;
 	}
 	/* Check the region signature first */
 	if (memcmp(&rgn23_data[offset], LPFC_REGION23_SIGNATURE, 4)) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"2619 Config region 23 has bad signature\n");
 			goto out;
 	}
 	/* Check the data structure version */
 	if (rgn23_data[offset] != LPFC_REGION23_VERSION) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 			"2620 Config region 23 has bad version\n");
 		goto out;
 	}
 	if (rc != MBX_TIMEOUT)
 		mempool_free(mbox, phba->mbox_mem_pool);
 	if (shdr_status || shdr_add_status || rc) {
-		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+		lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"3025 Write Object mailbox failed with "
 				"status x%x add_status x%x, mbx status x%x\n",
 				shdr_status, shdr_add_status, rc);
 		piocbq = lpfc_sli_ringtx_get(phba, pring);
 		if (!piocbq) {
 			spin_unlock_irqrestore(&pring->ring_lock, iflags);
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 				"2823 txq empty and txq_cnt is %d\n ",
 				txq_cnt);
 			break;
 		if (fail_msg) {
 			/* Failed means we can't issue and need to cancel */
-			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+			lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
 					"2822 IOCB failed %s iotag 0x%x "
 					"xri 0x%x\n",
 					fail_msg,
 /**
  * lpfc_wqe_bpl2sgl - Convert the bpl/bde to a sgl.
  * @phba: Pointer to HBA context object.
- * @pwqe: Pointer to command WQE.
+ * @pwqeq: Pointer to command WQE.
  * @sglq: Pointer to the scatter gather queue object.
  *
  * This routine converts the bpl or bde that is in the WQE
 /**
  * lpfc_sli4_issue_wqe - Issue an SLI4 Work Queue Entry (WQE)
  * @phba: Pointer to HBA context object.
- * @ring_number: Base sli ring number
+ * @qp: Pointer to HDW queue.
  * @pwqe: Pointer to command WQE.
  **/
 int
 /**
  * _lpfc_move_xri_pbl_to_pvt - Move some XRIs from public to private pool
  * @phba: pointer to lpfc hba data structure
+ * @qp: pointer to HDW queue
  * @pbl_pool: specified public free XRI pool
  * @pvt_pool: specified private free XRI pool
  * @count: number of XRIs to move
 /**
  * lpfc_keep_pvt_pool_above_lowwm - Keep pvt_pool above low watermark
  * @phba: pointer to lpfc hba data structure.
- * @qp: belong to which HWQ.
+ * @hwqid: belong to which HWQ.
  *
  * This routine get a batch of XRIs from pbl_pool if pvt_pool is less than
  * low watermark.
 /**
  * lpfc_get_io_buf_from_private_pool - Get one free IO buf from private pool
  * @phba: pointer to lpfc hba data structure.
+ * @qp: pointer to HDW queue
  * @pvt_pool: pointer to private pool data structure.
  * @ndlp: pointer to lpfc nodelist data structure.
  *

drivers/scsi/lpfc/lpfc_sli4.h+18−0

  * included with this package.                                     *
  *******************************************************************/
+#include <linux/irq_poll.h>
+#include <linux/cpufreq.h>
 #if defined(CONFIG_DEBUG_FS) && !defined(CONFIG_SCSI_LPFC_DEBUG_FS)
 #define CONFIG_SCSI_LPFC_DEBUG_FS
 #endif
 					       struct rqb_dmabuf *);
 };
+enum lpfc_poll_mode {
+	LPFC_QUEUE_WORK,
+	LPFC_IRQ_POLL
+};
+struct lpfc_idle_stat {
+	u64 prev_idle;
+	u64 prev_wall;
+};
 struct lpfc_queue {
 	struct list_head list;
 	struct list_head wq_list;
 	struct lpfc_queue *assoc_qp;
 	struct list_head _poll_list;
 	void **q_pgs;	/* array to index entries per page */
+#define LPFC_IRQ_POLL_WEIGHT 256
+	struct irq_poll iop;
+	enum lpfc_poll_mode poll_mode;
 };
 struct lpfc_sli4_link {
 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
 	struct lpfc_hdwq_stat __percpu *c_stat;
 #endif
+	struct lpfc_idle_stat *idle_stat;
 	uint32_t conf_trunk;
 #define lpfc_conf_trunk_port0_WORD	conf_trunk
 #define lpfc_conf_trunk_port0_SHIFT	0

drivers/scsi/lpfc/lpfc_version.h+1−1

@@ -20,7 +20,7 @@ · 19 unmodified lines
20	* included with this package. *	20	* included with this package. *
21	*******************************************************************/	21	*******************************************************************/
22		22
23	#define LPFC_DRIVER_VERSION "12.8.0.1"	23	#define LPFC_DRIVER_VERSION "12.8.0.2"
24	#define LPFC_DRIVER_NAME "lpfc"	24	#define LPFC_DRIVER_NAME "lpfc"
25		25
26	/* Used for SLI 2/3 */	26	/* Used for SLI 2/3 */

drivers/scsi/lpfc/lpfc_vport.c+39−47

@@ -145,7 +145,7 @@ lpfc_vport_sparm(struct lpfc_hba phba, struct lpfc_vport vport) · 144 unmodified lines
145	rc = lpfc_sli_issue_mbox_wait(phba, pmb, phba->fc_ratov * 2);	145	rc = lpfc_sli_issue_mbox_wait(phba, pmb, phba->fc_ratov * 2);
146	if (rc != MBX_SUCCESS) {	146	if (rc != MBX_SUCCESS) {
147	if (signal_pending(current)) {	147	if (signal_pending(current)) {
148	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT \| LOG_VPORT,	148	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
149	"1830 Signal aborted mbxCmd x%x\n",	149	"1830 Signal aborted mbxCmd x%x\n",
150	mb->mbxCommand);	150	mb->mbxCommand);
151	lpfc_mbuf_free(phba, mp->virt, mp->phys);	151	lpfc_mbuf_free(phba, mp->virt, mp->phys);
@@ -154,7 +154,7 @@ lpfc_vport_sparm(struct lpfc_hba phba, struct lpfc_vport vport) · 2 unmodified lines
154	mempool_free(pmb, phba->mbox_mem_pool);	154	mempool_free(pmb, phba->mbox_mem_pool);
155	return -EINTR;	155	return -EINTR;
156	} else {	156	} else {
157	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT \| LOG_VPORT,	157	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
158	"1818 VPort failed init, mbxCmd x%x "	158	"1818 VPort failed init, mbxCmd x%x "
159	"READ_SPARM mbxStatus x%x, rc = x%x\n",	159	"READ_SPARM mbxStatus x%x, rc = x%x\n",
160	mb->mbxCommand, mb->mbxStatus, rc);	160	mb->mbxCommand, mb->mbxStatus, rc);
@@ -190,7 +190,7 @@ lpfc_valid_wwn_format(struct lpfc_hba phba, struct lpfc_name wwn, · 29 unmodified lines
190	((wwn->u.wwn[0] & 0xf) != 0 \|\| (wwn->u.wwn[1] & 0xf) != 0)))	190	((wwn->u.wwn[0] & 0xf) != 0 \|\| (wwn->u.wwn[1] & 0xf) != 0)))
191	return 1;	191	return 1;
192		192
193	lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,	193	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
194	"1822 Invalid %s: %02x:%02x:%02x:%02x:"	194	"1822 Invalid %s: %02x:%02x:%02x:%02x:"
195	"%02x:%02x:%02x:%02x\n",	195	"%02x:%02x:%02x:%02x\n",
196	name_type,	196	name_type,
@@ -284,11 +284,11 @@ static void lpfc_discovery_wait(struct lpfc_vport *vport) · 87 unmodified lines
284	}	284	}
285		285
286	if (time_after(jiffies, wait_time_max))	286	if (time_after(jiffies, wait_time_max))
287	lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,	287	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
288	"1835 Vport discovery quiesce failed:"	288	"1835 Vport discovery quiesce failed:"
289	" state x%x fc_flags x%x wait msecs x%x\n",	289	" state x%x fc_flags x%x wait msecs x%x\n",
290	vport->port_state, vport->fc_flag,	290	vport->port_state, vport->fc_flag,
291	jiffies_to_msecs(jiffies - start_time));	291	jiffies_to_msecs(jiffies - start_time));
292	}	292	}
293		293
294	int	294	int
@@ -305,7 +305,7 @@ lpfc_vport_create(struct fc_vport *fc_vport, bool disable) · 10 unmodified lines
305	int status;	305	int status;
306		306
307	if ((phba->sli_rev < 3) \|\| !(phba->cfg_enable_npiv)) {	307	if ((phba->sli_rev < 3) \|\| !(phba->cfg_enable_npiv)) {
308	lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,	308	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
309	"1808 Create VPORT failed: "	309	"1808 Create VPORT failed: "
310	"NPIV is not enabled: SLImode:%d\n",	310	"NPIV is not enabled: SLImode:%d\n",
311	phba->sli_rev);	311	phba->sli_rev);
@@ -315,7 +315,7 @@ lpfc_vport_create(struct fc_vport *fc_vport, bool disable) · 3 unmodified lines
315		315
316	/* NPIV is not supported if HBA has NVME Target enabled */	316	/* NPIV is not supported if HBA has NVME Target enabled */
317	if (phba->nvmet_support) {	317	if (phba->nvmet_support) {
318	lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,	318	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
319	"3189 Create VPORT failed: "	319	"3189 Create VPORT failed: "
320	"NPIV is not supported on NVME Target\n");	320	"NPIV is not supported on NVME Target\n");
321	rc = VPORT_INVAL;	321	rc = VPORT_INVAL;
@@ -324,7 +324,7 @@ lpfc_vport_create(struct fc_vport *fc_vport, bool disable) · 2 unmodified lines
324		324
325	vpi = lpfc_alloc_vpi(phba);	325	vpi = lpfc_alloc_vpi(phba);
326	if (vpi == 0) {	326	if (vpi == 0) {
327	lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,	327	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
328	"1809 Create VPORT failed: "	328	"1809 Create VPORT failed: "
329	"Max VPORTs (%d) exceeded\n",	329	"Max VPORTs (%d) exceeded\n",
330	phba->max_vpi);	330	phba->max_vpi);
@@ -334,7 +334,7 @@ lpfc_vport_create(struct fc_vport *fc_vport, bool disable) · 3 unmodified lines
334		334
335	/* Assign an unused board number */	335	/* Assign an unused board number */
336	if ((instance = lpfc_get_instance()) < 0) {	336	if ((instance = lpfc_get_instance()) < 0) {
337	lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,	337	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
338	"1810 Create VPORT failed: Cannot get "	338	"1810 Create VPORT failed: Cannot get "
339	"instance number\n");	339	"instance number\n");
340	lpfc_free_vpi(phba, vpi);	340	lpfc_free_vpi(phba, vpi);
@@ -344,7 +344,7 @@ lpfc_vport_create(struct fc_vport *fc_vport, bool disable) · 3 unmodified lines
344		344
345	vport = lpfc_create_port(phba, instance, &fc_vport->dev);	345	vport = lpfc_create_port(phba, instance, &fc_vport->dev);
346	if (!vport) {	346	if (!vport) {
347	lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,	347	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
348	"1811 Create VPORT failed: vpi x%x\n", vpi);	348	"1811 Create VPORT failed: vpi x%x\n", vpi);
349	lpfc_free_vpi(phba, vpi);	349	lpfc_free_vpi(phba, vpi);
350	rc = VPORT_NORESOURCES;	350	rc = VPORT_NORESOURCES;
@@ -356,11 +356,11 @@ lpfc_vport_create(struct fc_vport *fc_vport, bool disable) · 5 unmodified lines
356		356
357	if ((status = lpfc_vport_sparm(phba, vport))) {	357	if ((status = lpfc_vport_sparm(phba, vport))) {
358	if (status == -EINTR) {	358	if (status == -EINTR) {
359	lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,	359	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
360	"1831 Create VPORT Interrupted.\n");	360	"1831 Create VPORT Interrupted.\n");
361	rc = VPORT_ERROR;	361	rc = VPORT_ERROR;
362	} else {	362	} else {
363	lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,	363	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
364	"1813 Create VPORT failed. "	364	"1813 Create VPORT failed. "
365	"Cannot get sparam\n");	365	"Cannot get sparam\n");
366	rc = VPORT_NORESOURCES;	366	rc = VPORT_NORESOURCES;
@@ -378,7 +378,7 @@ lpfc_vport_create(struct fc_vport *fc_vport, bool disable) · 11 unmodified lines
378		378
379	if (!lpfc_valid_wwn_format(phba, &vport->fc_sparam.nodeName, "WWNN") \|\|	379	if (!lpfc_valid_wwn_format(phba, &vport->fc_sparam.nodeName, "WWNN") \|\|
380	!lpfc_valid_wwn_format(phba, &vport->fc_sparam.portName, "WWPN")) {	380	!lpfc_valid_wwn_format(phba, &vport->fc_sparam.portName, "WWPN")) {
381	lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,	381	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
382	"1821 Create VPORT failed. "	382	"1821 Create VPORT failed. "
383	"Invalid WWN format\n");	383	"Invalid WWN format\n");
384	lpfc_free_vpi(phba, vpi);	384	lpfc_free_vpi(phba, vpi);
@@ -388,7 +388,7 @@ lpfc_vport_create(struct fc_vport *fc_vport, bool disable) · 3 unmodified lines
388	}	388	}
389		389
390	if (!lpfc_unique_wwpn(phba, vport)) {	390	if (!lpfc_unique_wwpn(phba, vport)) {
391	lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,	391	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
392	"1823 Create VPORT failed. "	392	"1823 Create VPORT failed. "
393	"Duplicate WWN on HBA\n");	393	"Duplicate WWN on HBA\n");
394	lpfc_free_vpi(phba, vpi);	394	lpfc_free_vpi(phba, vpi);
@@ -426,7 +426,7 @@ lpfc_vport_create(struct fc_vport *fc_vport, bool disable) · 31 unmodified lines
426	(pport->fc_flag & FC_VFI_REGISTERED)) {	426	(pport->fc_flag & FC_VFI_REGISTERED)) {
427	rc = lpfc_sli4_init_vpi(vport);	427	rc = lpfc_sli4_init_vpi(vport);
428	if (rc) {	428	if (rc) {
429	lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,	429	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
430	"1838 Failed to INIT_VPI on vpi %d "	430	"1838 Failed to INIT_VPI on vpi %d "
431	"status %d\n", vpi, rc);	431	"status %d\n", vpi, rc);
432	rc = VPORT_NORESOURCES;	432	rc = VPORT_NORESOURCES;
@@ -469,7 +469,7 @@ lpfc_vport_create(struct fc_vport *fc_vport, bool disable) · 36 unmodified lines
469	lpfc_initial_fdisc(vport);	469	lpfc_initial_fdisc(vport);
470	} else {	470	} else {
471	lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);	471	lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
472	lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,	472	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
473	"0262 No NPIV Fabric support\n");	473	"0262 No NPIV Fabric support\n");
474	}	474	}
475	} else {	475	} else {
@@ -478,8 +478,8 @@ lpfc_vport_create(struct fc_vport *fc_vport, bool disable) · 2 unmodified lines
478	rc = VPORT_OK;	478	rc = VPORT_OK;
479		479
480	out:	480	out:
481	lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,	481	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
482	"1825 Vport Created.\n");	482	"1825 Vport Created.\n");
483	lpfc_host_attrib_init(lpfc_shost_from_vport(vport));	483	lpfc_host_attrib_init(lpfc_shost_from_vport(vport));
484	error_out:	484	error_out:
485	return rc;	485	return rc;
@@ -534,7 +534,7 @@ disable_vport(struct fc_vport *fc_vport) · 48 unmodified lines
534	}	534	}
535		535
536	lpfc_vport_set_state(vport, FC_VPORT_DISABLED);	536	lpfc_vport_set_state(vport, FC_VPORT_DISABLED);
537	lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,	537	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
538	"1826 Vport Disabled.\n");	538	"1826 Vport Disabled.\n");
539	return VPORT_OK;	539	return VPORT_OK;
540	}	540	}
@@ -575,7 +575,7 @@ enable_vport(struct fc_vport *fc_vport) · 34 unmodified lines
575	lpfc_initial_fdisc(vport);	575	lpfc_initial_fdisc(vport);
576	} else {	576	} else {
577	lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);	577	lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
578	lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,	578	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
579	"0264 No NPIV Fabric support\n");	579	"0264 No NPIV Fabric support\n");
580	}	580	}
581	} else {	581	} else {
@@ -583,7 +583,7 @@ enable_vport(struct fc_vport *fc_vport) · 1 unmodified line
583	}	583	}
584		584
585	out:	585	out:
586	lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,	586	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
587	"1827 Vport Enabled.\n");	587	"1827 Vport Enabled.\n");
588	return VPORT_OK;	588	return VPORT_OK;
589	}	589	}
@@ -609,7 +609,7 @@ lpfc_vport_delete(struct fc_vport *fc_vport) · 19 unmodified lines
609	bool ns_ndlp_referenced = false;	609	bool ns_ndlp_referenced = false;
610		610
611	if (vport->port_type == LPFC_PHYSICAL_PORT) {	611	if (vport->port_type == LPFC_PHYSICAL_PORT) {
612	lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,	612	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
613	"1812 vport_delete failed: Cannot delete "	613	"1812 vport_delete failed: Cannot delete "
614	"physical host\n");	614	"physical host\n");
615	return VPORT_ERROR;	615	return VPORT_ERROR;
@@ -618,7 +618,7 @@ lpfc_vport_delete(struct fc_vport *fc_vport) · 2 unmodified lines
618	/* If the vport is a static vport fail the deletion. */	618	/* If the vport is a static vport fail the deletion. */
619	if ((vport->vport_flag & STATIC_VPORT) &&	619	if ((vport->vport_flag & STATIC_VPORT) &&
620	!(phba->pport->load_flag & FC_UNLOADING)) {	620	!(phba->pport->load_flag & FC_UNLOADING)) {
621	lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,	621	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
622	"1837 vport_delete failed: Cannot delete "	622	"1837 vport_delete failed: Cannot delete "
623	"static vport.\n");	623	"static vport.\n");
624	return VPORT_ERROR;	624	return VPORT_ERROR;
@@ -642,27 +642,16 @@ lpfc_vport_delete(struct fc_vport *fc_vport) · 17 unmodified lines
642	vport->port_state < LPFC_VPORT_READY)	642	vport->port_state < LPFC_VPORT_READY)
643	return -EAGAIN;	643	return -EAGAIN;
644	}	644	}
		645
645	/*	646	/*
646	* This is a bit of a mess. We want to ensure the shost doesn't get	647	* Take early refcount for outstanding I/O requests we schedule during
647	* torn down until we're done with the embedded lpfc_vport structure.	648	* delete processing for unreg_vpi. Always keep this before
648	*	649	* scsi_remove_host() as we can no longer obtain a reference through
649	* Beyond holding a reference for this function, we also need a	650	* scsi_host_get() after scsi_host_remove as shost is set to SHOST_DEL.
650	* reference for outstanding I/O requests we schedule during delete
651	* processing. But once we scsi_remove_host() we can no longer obtain
652	* a reference through scsi_host_get().
653	*
654	* So we take two references here. We release one reference at the
655	* bottom of the function -- after delinking the vport. And we
656	* release the other at the completion of the unreg_vpi that get's
657	* initiated after we've disposed of all other resources associated
658	* with the port.
659	*/	651	*/
660	if (!scsi_host_get(shost))	652	if (!scsi_host_get(shost))
661	return VPORT_INVAL;	653	return VPORT_INVAL;
662	if (!scsi_host_get(shost)) {	654
663	scsi_host_put(shost);
664	return VPORT_INVAL;
665	}
666	lpfc_free_sysfs_attr(vport);	655	lpfc_free_sysfs_attr(vport);
667		656
668	lpfc_debugfs_terminate(vport);	657	lpfc_debugfs_terminate(vport);
@@ -809,15 +798,16 @@ skip_logo: · 140 unmodified lines
809	if (!(vport->vpi_state & LPFC_VPI_REGISTERED) \|\|	798	if (!(vport->vpi_state & LPFC_VPI_REGISTERED) \|\|
810	lpfc_mbx_unreg_vpi(vport))	799	lpfc_mbx_unreg_vpi(vport))
811	scsi_host_put(shost);	800	scsi_host_put(shost);
812	} else	801	} else {
813	scsi_host_put(shost);	802	scsi_host_put(shost);
		803	}
814		804
815	lpfc_free_vpi(phba, vport->vpi);	805	lpfc_free_vpi(phba, vport->vpi);
816	vport->work_port_events = 0;	806	vport->work_port_events = 0;
817	spin_lock_irq(&phba->port_list_lock);	807	spin_lock_irq(&phba->port_list_lock);
818	list_del_init(&vport->listentry);	808	list_del_init(&vport->listentry);
819	spin_unlock_irq(&phba->port_list_lock);	809	spin_unlock_irq(&phba->port_list_lock);
820	lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,	810	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
821	"1828 Vport Deleted.\n");	811	"1828 Vport Deleted.\n");
822	scsi_host_put(shost);	812	scsi_host_put(shost);
823	return VPORT_OK;	813	return VPORT_OK;
@@ -838,7 +828,8 @@ lpfc_create_vport_work_array(struct lpfc_hba *phba) · 14 unmodified lines
838	if (port_iterator->load_flag & FC_UNLOADING)	828	if (port_iterator->load_flag & FC_UNLOADING)
839	continue;	829	continue;
840	if (!scsi_host_get(lpfc_shost_from_vport(port_iterator))) {	830	if (!scsi_host_get(lpfc_shost_from_vport(port_iterator))) {
841	lpfc_printf_vlog(port_iterator, KERN_ERR, LOG_VPORT,	831	lpfc_printf_vlog(port_iterator, KERN_ERR,
		832	LOG_TRACE_EVENT,
842	"1801 Create vport work array FAILED: "	833	"1801 Create vport work array FAILED: "
843	"cannot do scsi_host_get\n");	834	"cannot do scsi_host_get\n");
844	continue;	835	continue;
@@ -908,7 +899,8 @@ lpfc_alloc_bucket(struct lpfc_vport *vport) · 63 unmodified lines
908	GFP_ATOMIC);	899	GFP_ATOMIC);
909		900
910	if (!ndlp->lat_data)	901	if (!ndlp->lat_data)
911	lpfc_printf_vlog(vport, KERN_ERR, LOG_NODE,	902	lpfc_printf_vlog(vport, KERN_ERR,
		903	LOG_TRACE_EVENT,
912	"0287 lpfc_alloc_bucket failed to "	904	"0287 lpfc_alloc_bucket failed to "
913	"allocate statistical data buffer DID "	905	"allocate statistical data buffer DID "
914	"0x%x\n", ndlp->nlp_DID);	906	"0x%x\n", ndlp->nlp_DID);

drivers/scsi/megaraid.c+109−113

@@ -124,7 +124,7 @@ static int trace_level; · 123 unmodified lines
124		124
125	/**	125	/**
126	* mega_setup_mailbox()	126	* mega_setup_mailbox()
127	* @adapter - pointer to our soft state	127	* @adapter: pointer to our soft state
128	*	128	*
129	* Allocates a 8 byte aligned memory for the handshake mailbox.	129	* Allocates a 8 byte aligned memory for the handshake mailbox.
130	*/	130	*/
@@ -347,7 +347,7 @@ mega_query_adapter(adapter_t *adapter) · 216 unmodified lines
347		347
348	/**	348	/**
349	* mega_runpendq()	349	* mega_runpendq()
350	* @adapter - pointer to our soft state	350	* @adapter: pointer to our soft state
351	*	351	*
352	* Runs through the list of pending requests.	352	* Runs through the list of pending requests.
353	*/	353	*/
@@ -413,8 +413,8 @@ static DEF_SCSI_QCMD(megaraid_queue) · 59 unmodified lines
413		413
414	/**	414	/**
415	* mega_allocate_scb()	415	* mega_allocate_scb()
416	* @adapter - pointer to our soft state	416	* @adapter: pointer to our soft state
417	* @cmd - scsi command from the mid-layer	417	* @cmd: scsi command from the mid-layer
418	*	418	*
419	* Allocate a SCB structure. This is the central structure for controller	419	* Allocate a SCB structure. This is the central structure for controller
420	* commands.	420	* commands.
@@ -444,9 +444,9 @@ mega_allocate_scb(adapter_t adapter, struct scsi_cmnd cmd) · 23 unmodified lines
444		444
445	/**	445	/**
446	* mega_get_ldrv_num()	446	* mega_get_ldrv_num()
447	* @adapter - pointer to our soft state	447	* @adapter: pointer to our soft state
448	* @cmd - scsi mid layer command	448	* @cmd: scsi mid layer command
449	* @channel - channel on the controller	449	* @channel: channel on the controller
450	*	450	*
451	* Calculate the logical drive number based on the information in scsi command	451	* Calculate the logical drive number based on the information in scsi command
452	* and the channel number.	452	* and the channel number.
@@ -503,9 +503,9 @@ mega_get_ldrv_num(adapter_t adapter, struct scsi_cmnd cmd, int channel) · 50 unmodified lines
503		503
504	/**	504	/**
505	* mega_build_cmd()	505	* mega_build_cmd()
506	* @adapter - pointer to our soft state	506	* @adapter: pointer to our soft state
507	* @cmd - Prepare using this scsi command	507	* @cmd: Prepare using this scsi command
508	* @busy - busy flag if no resources	508	* @busy: busy flag if no resources
509	*	509	*
510	* Prepares a command and scatter gather list for the controller. This routine	510	* Prepares a command and scatter gather list for the controller. This routine
511	* also finds out if the commands is intended for a logical drive or a	511	* also finds out if the commands is intended for a logical drive or a
@@ -517,7 +517,6 @@ mega_get_ldrv_num(adapter_t adapter, struct scsi_cmnd cmd, int channel) · 5 unmodified lines
517	static scb_t *	517	static scb_t *
518	mega_build_cmd(adapter_t adapter, struct scsi_cmnd cmd, int *busy)	518	mega_build_cmd(adapter_t adapter, struct scsi_cmnd cmd, int *busy)
519	{	519	{
520	mega_ext_passthru *epthru;
521	mega_passthru *pthru;	520	mega_passthru *pthru;
522	scb_t *scb;	521	scb_t *scb;
523	mbox_t *mbox;	522	mbox_t *mbox;
@@ -905,7 +904,7 @@ mega_build_cmd(adapter_t adapter, struct scsi_cmnd cmd, int *busy) · 381 unmodified lines
905		904
906	if( adapter->support_ext_cdb ) {	905	if( adapter->support_ext_cdb ) {
907		906
908	epthru = mega_prepare_extpassthru(adapter, scb, cmd,	907	mega_prepare_extpassthru(adapter, scb, cmd,
909	channel, target);	908	channel, target);
910		909
911	mbox->m_out.cmd = MEGA_MBOXCMD_EXTPTHRU;	910	mbox->m_out.cmd = MEGA_MBOXCMD_EXTPTHRU;
@@ -937,11 +936,11 @@ mega_build_cmd(adapter_t adapter, struct scsi_cmnd cmd, int *busy) · 25 unmodified lines
937		936
938	/**	937	/**
939	* mega_prepare_passthru()	938	* mega_prepare_passthru()
940	* @adapter - pointer to our soft state	939	* @adapter: pointer to our soft state
941	* @scb - our scsi control block	940	* @scb: our scsi control block
942	* @cmd - scsi command from the mid-layer	941	* @cmd: scsi command from the mid-layer
943	* @channel - actual channel on the controller	942	* @channel: actual channel on the controller
944	* @target - actual id on the controller.	943	* @target: actual id on the controller.
945	*	944	*
946	* prepare a command for the scsi physical devices.	945	* prepare a command for the scsi physical devices.
947	*/	946	*/
@@ -1000,11 +999,11 @@ mega_prepare_passthru(adapter_t adapter, scb_t scb, struct scsi_cmnd *cmd, · 52 unmodified lines
1000		999
1001	/**	1000	/**
1002	* mega_prepare_extpassthru()	1001	* mega_prepare_extpassthru()
1003	* @adapter - pointer to our soft state	1002	* @adapter: pointer to our soft state
1004	* @scb - our scsi control block	1003	* @scb: our scsi control block
1005	* @cmd - scsi command from the mid-layer	1004	* @cmd: scsi command from the mid-layer
1006	* @channel - actual channel on the controller	1005	* @channel: actual channel on the controller
1007	* @target - actual id on the controller.	1006	* @target: actual id on the controller.
1008	*	1007	*
1009	* prepare a command for the scsi physical devices. This rountine prepares	1008	* prepare a command for the scsi physical devices. This rountine prepares
1010	* commands for devices which can take extended CDBs (>10 bytes)	1009	* commands for devices which can take extended CDBs (>10 bytes)
@@ -1085,8 +1084,8 @@ __mega_runpendq(adapter_t *adapter) · 74 unmodified lines
1085		1084
1086	/**	1085	/**
1087	* issue_scb()	1086	* issue_scb()
1088	* @adapter - pointer to our soft state	1087	* @adapter: pointer to our soft state
1089	* @scb - scsi control block	1088	* @scb: scsi control block
1090	*	1089	*
1091	* Post a command to the card if the mailbox is available, otherwise return	1090	* Post a command to the card if the mailbox is available, otherwise return
1092	* busy. We also take the scb from the pending list if the mailbox is	1091	* busy. We also take the scb from the pending list if the mailbox is
@@ -1166,8 +1165,8 @@ mega_busywait_mbox (adapter_t *adapter) · 73 unmodified lines
1166		1165
1167	/**	1166	/**
1168	* issue_scb_block()	1167	* issue_scb_block()
1169	* @adapter - pointer to our soft state	1168	* @adapter: pointer to our soft state
1170	* @raw_mbox - the mailbox	1169	* @raw_mbox: the mailbox
1171	*	1170	*
1172	* Issue a scb in synchronous and non-interrupt mode	1171	* Issue a scb in synchronous and non-interrupt mode
1173	*/	1172	*/
@@ -1247,8 +1246,8 @@ bug_blocked_mailbox: · 73 unmodified lines
1247		1246
1248	/**	1247	/**
1249	* megaraid_isr_iomapped()	1248	* megaraid_isr_iomapped()
1250	* @irq - irq	1249	* @irq: irq
1251	* @devp - pointer to our soft state	1250	* @devp: pointer to our soft state
1252	*	1251	*
1253	* Interrupt service routine for io-mapped controllers.	1252	* Interrupt service routine for io-mapped controllers.
1254	* Find out if our device is interrupting. If yes, acknowledge the interrupt	1253	* Find out if our device is interrupting. If yes, acknowledge the interrupt
@@ -1323,8 +1322,8 @@ megaraid_isr_iomapped(int irq, void *devp) · 68 unmodified lines
1323		1322
1324	/**	1323	/**
1325	* megaraid_isr_memmapped()	1324	* megaraid_isr_memmapped()
1326	* @irq - irq	1325	* @irq: irq
1327	* @devp - pointer to our soft state	1326	* @devp: pointer to our soft state
1328	*	1327	*
1329	* Interrupt service routine for memory-mapped controllers.	1328	* Interrupt service routine for memory-mapped controllers.
1330	* Find out if our device is interrupting. If yes, acknowledge the interrupt	1329	* Find out if our device is interrupting. If yes, acknowledge the interrupt
@@ -1401,10 +1400,10 @@ megaraid_isr_memmapped(int irq, void *devp) · 70 unmodified lines
1401	}	1400	}
1402	/**	1401	/**
1403	* mega_cmd_done()	1402	* mega_cmd_done()
1404	* @adapter - pointer to our soft state	1403	* @adapter: pointer to our soft state
1405	* @completed - array of ids of completed commands	1404	* @completed: array of ids of completed commands
1406	* @nstatus - number of completed commands	1405	* @nstatus: number of completed commands
1407	* @status - status of the last command completed	1406	* @status: status of the last command completed
1408	*	1407	*
1409	* Complete the commands and call the scsi mid-layer callback hooks.	1408	* Complete the commands and call the scsi mid-layer callback hooks.
1410	*/	1409	*/
@@ -1921,9 +1920,9 @@ megaraid_reset(struct scsi_cmnd *cmd) · 510 unmodified lines
1921		1920
1922	/**	1921	/**
1923	* megaraid_abort_and_reset()	1922	* megaraid_abort_and_reset()
1924	* @adapter - megaraid soft state	1923	* @adapter: megaraid soft state
1925	* @cmd - scsi command to be aborted or reset	1924	* @cmd: scsi command to be aborted or reset
1926	* @aor - abort or reset flag	1925	* @aor: abort or reset flag
1927	*	1926	*
1928	* Try to locate the scsi command in the pending queue. If found and is not	1927	* Try to locate the scsi command in the pending queue. If found and is not
1929	* issued to the controller, abort/reset it. Otherwise return failure	1928	* issued to the controller, abort/reset it. Otherwise return failure
@@ -2021,8 +2020,8 @@ free_local_pdev(struct pci_dev *pdev) · 91 unmodified lines
2021		2020
2022	/**	2021	/**
2023	* mega_allocate_inquiry()	2022	* mega_allocate_inquiry()
2024	* @dma_handle - handle returned for dma address	2023	* @dma_handle: handle returned for dma address
2025	* @pdev - handle to pci device	2024	* @pdev: handle to pci device
2026	*	2025	*
2027	* allocates memory for inquiry structure	2026	* allocates memory for inquiry structure
2028	*/	2027	*/
@@ -2045,8 +2044,8 @@ mega_free_inquiry(void inquiry, dma_addr_t dma_handle, struct pci_dev pdev) · 16 unmodified lines
2045		2044
2046	/**	2045	/**
2047	* proc_show_config()	2046	* proc_show_config()
2048	* @m - Synthetic file construction data	2047	* @m: Synthetic file construction data
2049	* @v - File iterator	2048	* @v: File iterator
2050	*	2049	*
2051	* Display configuration information about the controller.	2050	* Display configuration information about the controller.
2052	*/	2051	*/
@@ -2109,8 +2108,8 @@ proc_show_config(struct seq_file m, void v) · 56 unmodified lines
2109		2108
2110	/**	2109	/**
2111	* proc_show_stat()	2110	* proc_show_stat()
2112	* @m - Synthetic file construction data	2111	* @m: Synthetic file construction data
2113	* @v - File iterator	2112	* @v: File iterator
2114	*	2113	*
2115	* Display statistical information about the I/O activity.	2114	* Display statistical information about the I/O activity.
2116	*/	2115	*/
@@ -2143,8 +2142,8 @@ proc_show_stat(struct seq_file m, void v) · 26 unmodified lines
2143		2142
2144	/**	2143	/**
2145	* proc_show_mbox()	2144	* proc_show_mbox()
2146	* @m - Synthetic file construction data	2145	* @m: Synthetic file construction data
2147	* @v - File iterator	2146	* @v: File iterator
2148	*	2147	*
2149	* Display mailbox information for the last command issued. This information	2148	* Display mailbox information for the last command issued. This information
2150	* is good for debugging.	2149	* is good for debugging.
@@ -2171,8 +2170,8 @@ proc_show_mbox(struct seq_file m, void v) · 20 unmodified lines
2171		2170
2172	/**	2171	/**
2173	* proc_show_rebuild_rate()	2172	* proc_show_rebuild_rate()
2174	* @m - Synthetic file construction data	2173	* @m: Synthetic file construction data
2175	* @v - File iterator	2174	* @v: File iterator
2176	*	2175	*
2177	* Display current rebuild rate	2176	* Display current rebuild rate
2178	*/	2177	*/
@@ -2214,8 +2213,8 @@ free_pdev: · 35 unmodified lines
2214		2213
2215	/**	2214	/**
2216	* proc_show_battery()	2215	* proc_show_battery()
2217	* @m - Synthetic file construction data	2216	* @m: Synthetic file construction data
2218	* @v - File iterator	2217	* @v: File iterator
2219	*	2218	*
2220	* Display information about the battery module on the controller.	2219	* Display information about the battery module on the controller.
2221	*/	2220	*/
@@ -2317,9 +2316,9 @@ mega_print_inquiry(struct seq_file m, char scsi_inq) · 95 unmodified lines
2317		2316
2318	/**	2317	/**
2319	* proc_show_pdrv()	2318	* proc_show_pdrv()
2320	* @m - Synthetic file construction data	2319	* @m: Synthetic file construction data
2321	* @page - buffer to write the data in	2320	* @adapter: pointer to our soft state
2322	* @adapter - pointer to our soft state	2321	* @channel: channel
2323	*	2322	*
2324	* Display information about the physical drives.	2323	* Display information about the physical drives.
2325	*/	2324	*/
@@ -2433,8 +2432,8 @@ free_pdev: · 107 unmodified lines
2433		2432
2434	/**	2433	/**
2435	* proc_show_pdrv_ch0()	2434	* proc_show_pdrv_ch0()
2436	* @m - Synthetic file construction data	2435	* @m: Synthetic file construction data
2437	* @v - File iterator	2436	* @v: File iterator
2438	*	2437	*
2439	* Display information about the physical drives on physical channel 0.	2438	* Display information about the physical drives on physical channel 0.
2440	*/	2439	*/
@@ -2447,8 +2446,8 @@ proc_show_pdrv_ch0(struct seq_file m, void v) · 6 unmodified lines
2447		2446
2448	/**	2447	/**
2449	* proc_show_pdrv_ch1()	2448	* proc_show_pdrv_ch1()
2450	* @m - Synthetic file construction data	2449	* @m: Synthetic file construction data
2451	* @v - File iterator	2450	* @v: File iterator
2452	*	2451	*
2453	* Display information about the physical drives on physical channel 1.	2452	* Display information about the physical drives on physical channel 1.
2454	*/	2453	*/
@@ -2461,8 +2460,8 @@ proc_show_pdrv_ch1(struct seq_file m, void v) · 6 unmodified lines
2461		2460
2462	/**	2461	/**
2463	* proc_show_pdrv_ch2()	2462	* proc_show_pdrv_ch2()
2464	* @m - Synthetic file construction data	2463	* @m: Synthetic file construction data
2465	* @v - File iterator	2464	* @v: File iterator
2466	*	2465	*
2467	* Display information about the physical drives on physical channel 2.	2466	* Display information about the physical drives on physical channel 2.
2468	*/	2467	*/
@@ -2475,8 +2474,8 @@ proc_show_pdrv_ch2(struct seq_file m, void v) · 6 unmodified lines
2475		2474
2476	/**	2475	/**
2477	* proc_show_pdrv_ch3()	2476	* proc_show_pdrv_ch3()
2478	* @m - Synthetic file construction data	2477	* @m: Synthetic file construction data
2479	* @v - File iterator	2478	* @v: File iterator
2480	*	2479	*
2481	* Display information about the physical drives on physical channel 3.	2480	* Display information about the physical drives on physical channel 3.
2482	*/	2481	*/
@@ -2489,10 +2488,10 @@ proc_show_pdrv_ch3(struct seq_file m, void v) · 6 unmodified lines
2489		2488
2490	/**	2489	/**
2491	* proc_show_rdrv()	2490	* proc_show_rdrv()
2492	* @m - Synthetic file construction data	2491	* @m: Synthetic file construction data
2493	* @adapter - pointer to our soft state	2492	* @adapter: pointer to our soft state
2494	* @start - starting logical drive to display	2493	* @start: starting logical drive to display
2495	* @end - ending logical drive to display	2494	* @end: ending logical drive to display
2496	*	2495	*
2497	* We do not print the inquiry information since its already available through	2496	* We do not print the inquiry information since its already available through
2498	* /proc/scsi/scsi interface	2497	* /proc/scsi/scsi interface
@@ -2674,8 +2673,8 @@ free_pdev: · 175 unmodified lines
2674		2673
2675	/**	2674	/**
2676	* proc_show_rdrv_10()	2675	* proc_show_rdrv_10()
2677	* @m - Synthetic file construction data	2676	* @m: Synthetic file construction data
2678	* @v - File iterator	2677	* @v: File iterator
2679	*	2678	*
2680	* Display real time information about the logical drives 0 through 9.	2679	* Display real time information about the logical drives 0 through 9.
2681	*/	2680	*/
@@ -2688,8 +2687,8 @@ proc_show_rdrv_10(struct seq_file m, void v) · 6 unmodified lines
2688		2687
2689	/**	2688	/**
2690	* proc_show_rdrv_20()	2689	* proc_show_rdrv_20()
2691	* @m - Synthetic file construction data	2690	* @m: Synthetic file construction data
2692	* @v - File iterator	2691	* @v: File iterator
2693	*	2692	*
2694	* Display real time information about the logical drives 0 through 9.	2693	* Display real time information about the logical drives 0 through 9.
2695	*/	2694	*/
@@ -2702,8 +2701,8 @@ proc_show_rdrv_20(struct seq_file m, void v) · 6 unmodified lines
2702		2701
2703	/**	2702	/**
2704	* proc_show_rdrv_30()	2703	* proc_show_rdrv_30()
2705	* @m - Synthetic file construction data	2704	* @m: Synthetic file construction data
2706	* @v - File iterator	2705	* @v: File iterator
2707	*	2706	*
2708	* Display real time information about the logical drives 0 through 9.	2707	* Display real time information about the logical drives 0 through 9.
2709	*/	2708	*/
@@ -2716,8 +2715,8 @@ proc_show_rdrv_30(struct seq_file m, void v) · 6 unmodified lines
2716		2715
2717	/**	2716	/**
2718	* proc_show_rdrv_40()	2717	* proc_show_rdrv_40()
2719	* @m - Synthetic file construction data	2718	* @m: Synthetic file construction data
2720	* @v - File iterator	2719	* @v: File iterator
2721	*	2720	*
2722	* Display real time information about the logical drives 0 through 9.	2721	* Display real time information about the logical drives 0 through 9.
2723	*/	2722	*/
@@ -2729,8 +2728,8 @@ proc_show_rdrv_40(struct seq_file m, void v) · 5 unmodified lines
2729		2728
2730	/**	2729	/**
2731	* mega_create_proc_entry()	2730	* mega_create_proc_entry()
2732	* @index - index in soft state array	2731	* @index: index in soft state array
2733	* @parent - parent node for this /proc entry	2732	* @parent: parent node for this /proc entry
2734	*	2733	*
2735	* Creates /proc entries for our controllers.	2734	* Creates /proc entries for our controllers.
2736	*/	2735	*/
@@ -2785,7 +2784,7 @@ static inline void mega_create_proc_entry(int index, struct proc_dir_entry *pare · 48 unmodified lines
2785	#endif	2784	#endif
2786		2785
2787		2786
2788	/**	2787	/*
2789	* megaraid_biosparam()	2788	* megaraid_biosparam()
2790	*	2789	*
2791	* Return the disk geometry for a particular disk	2790	* Return the disk geometry for a particular disk
@@ -2854,7 +2853,7 @@ megaraid_biosparam(struct scsi_device sdev, struct block_device bdev, · 62 unmodified lines
2854		2853
2855	/**	2854	/**
2856	* mega_init_scb()	2855	* mega_init_scb()
2857	* @adapter - pointer to our soft state	2856	* @adapter: pointer to our soft state
2858	*	2857	*
2859	* Allocate memory for the various pointers in the scb structures:	2858	* Allocate memory for the various pointers in the scb structures:
2860	* scatter-gather list pointer, passthru and extended passthru structure	2859	* scatter-gather list pointer, passthru and extended passthru structure
@@ -2934,8 +2933,8 @@ mega_init_scb(adapter_t *adapter) · 73 unmodified lines
2934		2933
2935	/**	2934	/**
2936	* megadev_open()	2935	* megadev_open()
2937	* @inode - unused	2936	* @inode: unused
2938	* @filep - unused	2937	* @filep: unused
2939	*	2938	*
2940	* Routines for the character/ioctl interface to the driver. Find out if this	2939	* Routines for the character/ioctl interface to the driver. Find out if this
2941	* is a valid open.	2940	* is a valid open.
@@ -2954,10 +2953,9 @@ megadev_open (struct inode inode, struct file filep) · 12 unmodified lines
2954		2953
2955	/**	2954	/**
2956	* megadev_ioctl()	2955	* megadev_ioctl()
2957	* @inode - Our device inode	2956	* @filep: Our device file
2958	* @filep - unused	2957	* @cmd: ioctl command
2959	* @cmd - ioctl command	2958	* @arg: user buffer
2960	* @arg - user buffer
2961	*	2959	*
2962	* ioctl entry point for our private ioctl interface. We move the data in from	2960	* ioctl entry point for our private ioctl interface. We move the data in from
2963	* the user space, prepare the command (if necessary, convert the old MIMD	2961	* the user space, prepare the command (if necessary, convert the old MIMD
@@ -2977,14 +2975,13 @@ megadev_ioctl(struct file *filep, unsigned int cmd, unsigned long arg) · 13 unmodified lines
2977	void data = NULL; / data to be transferred */	2975	void data = NULL; / data to be transferred */
2978	dma_addr_t data_dma_hndl; /* dma handle for data xfer area */	2976	dma_addr_t data_dma_hndl; /* dma handle for data xfer area */
2979	megacmd_t mc;	2977	megacmd_t mc;
2980	megastat_t __user *ustats;	2978	#if MEGA_HAVE_STATS
2981	int num_ldrv;	2979	megastat_t __user *ustats = NULL;
		2980	int num_ldrv = 0;
		2981	#endif
2982	u32 uxferaddr = 0;	2982	u32 uxferaddr = 0;
2983	struct pci_dev *pdev;	2983	struct pci_dev *pdev;
2984		2984
2985	ustats = NULL; /* avoid compilation warnings */
2986	num_ldrv = 0;
2987
2988	/*	2985	/*
2989	* Make sure only USCSICMD are issued through this interface.	2986	* Make sure only USCSICMD are issued through this interface.
2990	* MIMD application would still fire different command.	2987	* MIMD application would still fire different command.
@@ -3370,8 +3367,8 @@ megadev_unlocked_ioctl(struct file *filep, unsigned int cmd, unsigned long arg) · 379 unmodified lines
3370		3367
3371	/**	3368	/**
3372	* mega_m_to_n()	3369	* mega_m_to_n()
3373	* @arg - user address	3370	* @arg: user address
3374	* @uioc - new ioctl structure	3371	* @uioc: new ioctl structure
3375	*	3372	*
3376	* A thin layer to convert older mimd interface ioctl structure to NIT ioctl	3373	* A thin layer to convert older mimd interface ioctl structure to NIT ioctl
3377	* structure	3374	* structure
@@ -3498,8 +3495,8 @@ mega_m_to_n(void __user arg, nitioctl_t uioc) · 120 unmodified lines
3498		3495
3499	/*	3496	/*
3500	* mega_n_to_m()	3497	* mega_n_to_m()
3501	* @arg - user address	3498	* @arg: user address
3502	* @mc - mailbox command	3499	* @mc: mailbox command
3503	*	3500	*
3504	* Updates the status information to the application, depending on application	3501	* Updates the status information to the application, depending on application
3505	* conforms to older mimd ioctl interface or newer NIT ioctl interface	3502	* conforms to older mimd ioctl interface or newer NIT ioctl interface
@@ -3565,7 +3562,7 @@ mega_n_to_m(void __user arg, megacmd_t mc) · 59 unmodified lines
3565		3562
3566	/**	3563	/**
3567	* mega_is_bios_enabled()	3564	* mega_is_bios_enabled()
3568	* @adapter - pointer to our soft state	3565	* @adapter: pointer to our soft state
3569	*	3566	*
3570	* issue command to find out if the BIOS is enabled for this controller	3567	* issue command to find out if the BIOS is enabled for this controller
3571	*/	3568	*/
@@ -3574,7 +3571,6 @@ mega_is_bios_enabled(adapter_t *adapter) · 2 unmodified lines
3574	{	3571	{
3575	unsigned char raw_mbox[sizeof(struct mbox_out)];	3572	unsigned char raw_mbox[sizeof(struct mbox_out)];
3576	mbox_t *mbox;	3573	mbox_t *mbox;
3577	int ret;
3578		3574
3579	mbox = (mbox_t *)raw_mbox;	3575	mbox = (mbox_t *)raw_mbox;
3580		3576
@@ -3587,8 +3583,7 @@ mega_is_bios_enabled(adapter_t *adapter) · 6 unmodified lines
3587	raw_mbox[0] = IS_BIOS_ENABLED;	3583	raw_mbox[0] = IS_BIOS_ENABLED;
3588	raw_mbox[2] = GET_BIOS;	3584	raw_mbox[2] = GET_BIOS;
3589		3585
3590		3586	issue_scb_block(adapter, raw_mbox);
3591	ret = issue_scb_block(adapter, raw_mbox);
3592		3587
3593	return (char )adapter->mega_buffer;	3588	return (char )adapter->mega_buffer;
3594	}	3589	}
@@ -3596,7 +3591,7 @@ mega_is_bios_enabled(adapter_t *adapter) · 1 unmodified line
3596		3591
3597	/**	3592	/**
3598	* mega_enum_raid_scsi()	3593	* mega_enum_raid_scsi()
3599	* @adapter - pointer to our soft state	3594	* @adapter: pointer to our soft state
3600	*	3595	*
3601	* Find out what channels are RAID/SCSI. This information is used to	3596	* Find out what channels are RAID/SCSI. This information is used to
3602	* differentiate the virtual channels and physical channels and to support	3597	* differentiate the virtual channels and physical channels and to support
@@ -3651,7 +3646,7 @@ mega_enum_raid_scsi(adapter_t *adapter) · 48 unmodified lines
3651		3646
3652	/**	3647	/**
3653	* mega_get_boot_drv()	3648	* mega_get_boot_drv()
3654	* @adapter - pointer to our soft state	3649	* @adapter: pointer to our soft state
3655	*	3650	*
3656	* Find out which device is the boot device. Note, any logical drive or any	3651	* Find out which device is the boot device. Note, any logical drive or any
3657	* phyical device (e.g., a CDROM) can be designated as a boot device.	3652	* phyical device (e.g., a CDROM) can be designated as a boot device.
@@ -3718,7 +3713,7 @@ mega_get_boot_drv(adapter_t *adapter) · 60 unmodified lines
3718		3713
3719	/**	3714	/**
3720	* mega_support_random_del()	3715	* mega_support_random_del()
3721	* @adapter - pointer to our soft state	3716	* @adapter: pointer to our soft state
3722	*	3717	*
3723	* Find out if this controller supports random deletion and addition of	3718	* Find out if this controller supports random deletion and addition of
3724	* logical drives	3719	* logical drives
@@ -3748,7 +3743,7 @@ mega_support_random_del(adapter_t *adapter) · 23 unmodified lines
3748		3743
3749	/**	3744	/**
3750	* mega_support_ext_cdb()	3745	* mega_support_ext_cdb()
3751	* @adapter - pointer to our soft state	3746	* @adapter: pointer to our soft state
3752	*	3747	*
3753	* Find out if this firmware support cdblen > 10	3748	* Find out if this firmware support cdblen > 10
3754	*/	3749	*/
@@ -3776,8 +3771,8 @@ mega_support_ext_cdb(adapter_t *adapter) · 21 unmodified lines
3776		3771
3777	/**	3772	/**
3778	* mega_del_logdrv()	3773	* mega_del_logdrv()
3779	* @adapter - pointer to our soft state	3774	* @adapter: pointer to our soft state
3780	* @logdrv - logical drive to be deleted	3775	* @logdrv: logical drive to be deleted
3781	*	3776	*
3782	* Delete the specified logical drive. It is the responsibility of the user	3777	* Delete the specified logical drive. It is the responsibility of the user
3783	* app to let the OS know about this operation.	3778	* app to let the OS know about this operation.
@@ -3862,7 +3857,7 @@ mega_do_del_logdrv(adapter_t *adapter, int logdrv) · 78 unmodified lines
3862		3857
3863	/**	3858	/**
3864	* mega_get_max_sgl()	3859	* mega_get_max_sgl()
3865	* @adapter - pointer to our soft state	3860	* @adapter: pointer to our soft state
3866	*	3861	*
3867	* Find out the maximum number of scatter-gather elements supported by this	3862	* Find out the maximum number of scatter-gather elements supported by this
3868	* version of the firmware	3863	* version of the firmware
@@ -3908,7 +3903,7 @@ mega_get_max_sgl(adapter_t *adapter) · 39 unmodified lines
3908		3903
3909	/**	3904	/**
3910	* mega_support_cluster()	3905	* mega_support_cluster()
3911	* @adapter - pointer to our soft state	3906	* @adapter: pointer to our soft state
3912	*	3907	*
3913	* Find out if this firmware support cluster calls.	3908	* Find out if this firmware support cluster calls.
3914	*/	3909	*/
@@ -3950,8 +3945,8 @@ mega_support_cluster(adapter_t *adapter) · 35 unmodified lines
3950	#ifdef CONFIG_PROC_FS	3945	#ifdef CONFIG_PROC_FS
3951	/**	3946	/**
3952	* mega_adapinq()	3947	* mega_adapinq()
3953	* @adapter - pointer to our soft state	3948	* @adapter: pointer to our soft state
3954	* @dma_handle - DMA address of the buffer	3949	* @dma_handle: DMA address of the buffer
3955	*	3950	*
3956	* Issue internal commands while interrupts are available.	3951	* Issue internal commands while interrupts are available.
3957	* We only issue direct mailbox commands from within the driver. ioctl()	3952	* We only issue direct mailbox commands from within the driver. ioctl()
@@ -3983,11 +3978,12 @@ mega_adapinq(adapter_t *adapter, dma_addr_t dma_handle) · 25 unmodified lines
3983	}	3978	}
3984		3979
3985		3980
3986	/** mega_internal_dev_inquiry()	3981	/**
3987	* @adapter - pointer to our soft state	3982	* mega_internal_dev_inquiry()
3988	* @ch - channel for this device	3983	* @adapter: pointer to our soft state
3989	* @tgt - ID of this device	3984	* @ch: channel for this device
3990	* @buf_dma_handle - DMA address of the buffer	3985	* @tgt: ID of this device
		3986	* @buf_dma_handle: DMA address of the buffer
3991	*	3987	*
3992	* Issue the scsi inquiry for the specified device.	3988	* Issue the scsi inquiry for the specified device.
3993	*/	3989	*/
@@ -4056,9 +4052,9 @@ mega_internal_dev_inquiry(adapter_t *adapter, u8 ch, u8 tgt, · 62 unmodified lines
4056		4052
4057	/**	4053	/**
4058	* mega_internal_command()	4054	* mega_internal_command()
4059	* @adapter - pointer to our soft state	4055	* @adapter: pointer to our soft state
4060	* @mc - the mailbox command	4056	* @mc: the mailbox command
4061	* @pthru - Passthru structure for DCDB commands	4057	* @pthru: Passthru structure for DCDB commands
4062	*	4058	*
4063	* Issue the internal commands in interrupt mode.	4059	* Issue the internal commands in interrupt mode.
4064	* The last argument is the address of the passthru structure if the command	4060	* The last argument is the address of the passthru structure if the command

drivers/scsi/megaraid/megaraid_mbox.c+2−2

  * megaraid_mbox_display_scb - display SCB information, mostly debug purposes
  * @adapter		: controller's soft state
  * @scb			: SCB to be displayed
- * @level		: debug level for console print
  *
  * Diplay information about the given SCB iff the current debug level is
  * verbose.
 /**
  * megaraid_sysfs_show_app_hndl - display application handle for this adapter
- * @cdev	: class device object representation for the host
+ * @dev		: class device object representation for the host
+ * @attr	: device attribute (unused)
  * @buf		: buffer to send data to
  *
  * Display the handle used by the applications while executing management

drivers/scsi/megaraid/megaraid_mm.c+0−1

@@ -95,7 +95,6 @@ mraid_mm_open(struct inode inode, struct file filep) · 94 unmodified lines
95		95
96	/**	96	/**
97	* mraid_mm_ioctl - module entry-point for ioctls	97	* mraid_mm_ioctl - module entry-point for ioctls
98	* @inode : inode (ignored)
99	* @filep : file operations pointer (ignored)	98	* @filep : file operations pointer (ignored)
100	* @cmd : ioctl command	99	* @cmd : ioctl command
101	* @arg : user ioctl packet	100	* @arg : user ioctl packet

drivers/scsi/megaraid/megaraid_sas.h+20−0

@@ -2709,4 +2709,24 @@ int megasas_adp_reset_wait_for_ready(struct megasas_instance *instance, · 2708 unmodified lines
2709	int ocr_context);	2709	int ocr_context);
2710	int megasas_irqpoll(struct irq_poll *irqpoll, int budget);	2710	int megasas_irqpoll(struct irq_poll *irqpoll, int budget);
2711	void megasas_dump_fusion_io(struct scsi_cmnd *scmd);	2711	void megasas_dump_fusion_io(struct scsi_cmnd *scmd);
		2712	u32 megasas_readl(struct megasas_instance *instance,
		2713	const volatile void __iomem *addr);
		2714	struct megasas_cmd megasas_get_cmd(struct megasas_instance instance);
		2715	void megasas_return_cmd(struct megasas_instance *instance,
		2716	struct megasas_cmd *cmd);
		2717	int megasas_issue_polled(struct megasas_instance *instance,
		2718	struct megasas_cmd *cmd);
		2719	void megaraid_sas_kill_hba(struct megasas_instance *instance);
		2720	void megasas_check_and_restore_queue_depth(struct megasas_instance *instance);
		2721	void megasas_start_timer(struct megasas_instance *instance);
		2722	int megasas_sriov_start_heartbeat(struct megasas_instance *instance,
		2723	int initial);
		2724	int megasas_alloc_cmds(struct megasas_instance *instance);
		2725	void megasas_free_cmds(struct megasas_instance *instance);
		2726
		2727	void megasas_init_debugfs(void);
		2728	void megasas_exit_debugfs(void);
		2729	void megasas_setup_debugfs(struct megasas_instance *instance);
		2730	void megasas_destroy_debugfs(struct megasas_instance *instance);
		2731
2712	#endif /LSI_MEGARAID_SAS_H /	2732	#endif /LSI_MEGARAID_SAS_H /

drivers/scsi/megaraid/megaraid_sas_base.c+105−79

 static spinlock_t poll_aen_lock;
 extern struct dentry *megasas_debugfs_root;
-extern void megasas_init_debugfs(void);
-extern void megasas_exit_debugfs(void);
-extern void megasas_setup_debugfs(struct megasas_instance *instance);
-extern void megasas_destroy_debugfs(struct megasas_instance *instance);
 void
 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
 			evt_detail->description);
 }
-/**
+/*
-*	The following functions are defined for xscale
+ * The following functions are defined for xscale
-*	(deviceid : 1064R, PERC5) controllers
+ * (deviceid : 1064R, PERC5) controllers
-*/
+ */
 /**
  * megasas_enable_intr_xscale -	Enables interrupts
- * @regs:			MFI register set
+ * @instance:	Adapter soft state
  */
 static inline void
 megasas_enable_intr_xscale(struct megasas_instance *instance)
 /**
  * megasas_disable_intr_xscale -Disables interrupt
- * @regs:			MFI register set
+ * @instance:	Adapter soft state
  */
 static inline void
 megasas_disable_intr_xscale(struct megasas_instance *instance)
 /**
  * megasas_read_fw_status_reg_xscale - returns the current FW status value
- * @regs:			MFI register set
+ * @instance:	Adapter soft state
  */
 static u32
 megasas_read_fw_status_reg_xscale(struct megasas_instance *instance)
 }
 /**
  * megasas_clear_interrupt_xscale -	Check & clear interrupt
- * @regs:				MFI register set
+ * @instance:	Adapter soft state
  */
 static int
 megasas_clear_intr_xscale(struct megasas_instance *instance)
 /**
  * megasas_fire_cmd_xscale -	Sends command to the FW
- * @frame_phys_addr :		Physical address of cmd
+ * @instance:		Adapter soft state
- * @frame_count :		Number of frames for the command
+ * @frame_phys_addr :	Physical address of cmd
- * @regs :			MFI register set
+ * @frame_count :	Number of frames for the command
+ * @regs :		MFI register set
  */
 static inline void
 megasas_fire_cmd_xscale(struct megasas_instance *instance,
 /**
  * megasas_adp_reset_xscale -  For controller reset
- * @regs:                              MFI register set
+ * @instance:	Adapter soft state
+ * @regs:	MFI register set
  */
 static int
 megasas_adp_reset_xscale(struct megasas_instance *instance,
 /**
  * megasas_check_reset_xscale -	For controller reset check
- * @regs:				MFI register set
+ * @instance:	Adapter soft state
+ * @regs:	MFI register set
  */
 static int
 megasas_check_reset_xscale(struct megasas_instance *instance,
 	.issue_dcmd = megasas_issue_dcmd,
 };
-/**
+/*
-*	This is the end of set of functions & definitions specific
+ * This is the end of set of functions & definitions specific
-*	to xscale (deviceid : 1064R, PERC5) controllers
+ * to xscale (deviceid : 1064R, PERC5) controllers
-*/
+ */
-/**
+/*
-*	The following functions are defined for ppc (deviceid : 0x60)
+ * The following functions are defined for ppc (deviceid : 0x60)
-*	controllers
+ * controllers
-*/
+ */
 /**
  * megasas_enable_intr_ppc -	Enables interrupts
- * @regs:			MFI register set
+ * @instance:	Adapter soft state
  */
 static inline void
 megasas_enable_intr_ppc(struct megasas_instance *instance)
 /**
  * megasas_disable_intr_ppc -	Disable interrupt
- * @regs:			MFI register set
+ * @instance:	Adapter soft state
  */
 static inline void
 megasas_disable_intr_ppc(struct megasas_instance *instance)
 /**
  * megasas_read_fw_status_reg_ppc - returns the current FW status value
- * @regs:			MFI register set
+ * @instance:	Adapter soft state
  */
 static u32
 megasas_read_fw_status_reg_ppc(struct megasas_instance *instance)
 /**
  * megasas_clear_interrupt_ppc -	Check & clear interrupt
- * @regs:				MFI register set
+ * @instance:	Adapter soft state
  */
 static int
 megasas_clear_intr_ppc(struct megasas_instance *instance)
 /**
  * megasas_fire_cmd_ppc -	Sends command to the FW
- * @frame_phys_addr :		Physical address of cmd
+ * @instance:		Adapter soft state
- * @frame_count :		Number of frames for the command
+ * @frame_phys_addr:	Physical address of cmd
- * @regs :			MFI register set
+ * @frame_count:	Number of frames for the command
+ * @regs:		MFI register set
  */
 static inline void
 megasas_fire_cmd_ppc(struct megasas_instance *instance,
 /**
  * megasas_check_reset_ppc -	For controller reset check
- * @regs:				MFI register set
+ * @instance:	Adapter soft state
+ * @regs:	MFI register set
  */
 static int
 megasas_check_reset_ppc(struct megasas_instance *instance,
 /**
  * megasas_enable_intr_skinny -	Enables interrupts
- * @regs:			MFI register set
+ * @instance:	Adapter soft state
  */
 static inline void
 megasas_enable_intr_skinny(struct megasas_instance *instance)
 /**
  * megasas_disable_intr_skinny -	Disables interrupt
- * @regs:			MFI register set
+ * @instance:	Adapter soft state
  */
 static inline void
 megasas_disable_intr_skinny(struct megasas_instance *instance)
 /**
  * megasas_read_fw_status_reg_skinny - returns the current FW status value
- * @regs:			MFI register set
+ * @instance:	Adapter soft state
  */
 static u32
 megasas_read_fw_status_reg_skinny(struct megasas_instance *instance)
 /**
  * megasas_clear_interrupt_skinny -	Check & clear interrupt
- * @regs:				MFI register set
+ * @instance:	Adapter soft state
  */
 static int
 megasas_clear_intr_skinny(struct megasas_instance *instance)
 /**
  * megasas_fire_cmd_skinny -	Sends command to the FW
- * @frame_phys_addr :		Physical address of cmd
+ * @instance:		Adapter soft state
- * @frame_count :		Number of frames for the command
+ * @frame_phys_addr:	Physical address of cmd
- * @regs :			MFI register set
+ * @frame_count:	Number of frames for the command
+ * @regs:		MFI register set
  */
 static inline void
 megasas_fire_cmd_skinny(struct megasas_instance *instance,
 /**
  * megasas_check_reset_skinny -	For controller reset check
- * @regs:				MFI register set
+ * @instance:	Adapter soft state
+ * @regs:	MFI register set
  */
 static int
 megasas_check_reset_skinny(struct megasas_instance *instance,
 };
-/**
+/*
-*	The following functions are defined for gen2 (deviceid : 0x78 0x79)
+ * The following functions are defined for gen2 (deviceid : 0x78 0x79)
-*	controllers
+ * controllers
-*/
+ */
 /**
  * megasas_enable_intr_gen2 -  Enables interrupts
- * @regs:                      MFI register set
+ * @instance:	Adapter soft state
  */
 static inline void
 megasas_enable_intr_gen2(struct megasas_instance *instance)
 /**
  * megasas_disable_intr_gen2 - Disables interrupt
- * @regs:                      MFI register set
+ * @instance:	Adapter soft state
  */
 static inline void
 megasas_disable_intr_gen2(struct megasas_instance *instance)
 /**
  * megasas_read_fw_status_reg_gen2 - returns the current FW status value
- * @regs:                      MFI register set
+ * @instance:	Adapter soft state
  */
 static u32
 megasas_read_fw_status_reg_gen2(struct megasas_instance *instance)
 /**
  * megasas_clear_interrupt_gen2 -      Check & clear interrupt
- * @regs:                              MFI register set
+ * @instance:	Adapter soft state
  */
 static int
 megasas_clear_intr_gen2(struct megasas_instance *instance)
 	return mfiStatus;
 }
 /**
  * megasas_fire_cmd_gen2 -     Sends command to the FW
- * @frame_phys_addr :          Physical address of cmd
+ * @instance:		Adapter soft state
- * @frame_count :              Number of frames for the command
+ * @frame_phys_addr:	Physical address of cmd
- * @regs :                     MFI register set
+ * @frame_count:	Number of frames for the command
+ * @regs:		MFI register set
  */
 static inline void
 megasas_fire_cmd_gen2(struct megasas_instance *instance,
 /**
  * megasas_adp_reset_gen2 -	For controller reset
- * @regs:				MFI register set
+ * @instance:	Adapter soft state
+ * @reg_set:	MFI register set
  */
 static int
 megasas_adp_reset_gen2(struct megasas_instance *instance,
 /**
  * megasas_check_reset_gen2 -	For controller reset check
- * @regs:				MFI register set
+ * @instance:	Adapter soft state
+ * @regs:	MFI register set
  */
 static int
 megasas_check_reset_gen2(struct megasas_instance *instance,
 	.issue_dcmd = megasas_issue_dcmd,
 };
-/**
+/*
-*	This is the end of set of functions & definitions
+ * This is the end of set of functions & definitions
-*       specific to gen2 (deviceid : 0x78, 0x79) controllers
+ * specific to gen2 (deviceid : 0x78, 0x79) controllers
-*/
+ */
 /*
  * Template added for TB (Fusion)
 /**
  * megasas_cmd_type -		Checks if the cmd is for logical drive/sysPD
  *				and whether it's RW or non RW
- * @scmd:			SCSI command
+ * @cmd:			SCSI command
  *
  */
 inline int megasas_cmd_type(struct scsi_cmnd *cmd)
 /**
  * megasas_queue_command -	Queue entry point
+ * @shost:			adapter SCSI host
  * @scmd:			SCSI command to be queued
- * @done:			Callback entry point
  */
 static int
 megasas_queue_command(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
 /**
  * megasas_dump_reg_set -	This function will print hexdump of register set
- * @buf:			Buffer to be dumped
+ * @reg_set:	Register set to be dumped
- * @sz:				Size in bytes
- * @format:			Different formats of dumping e.g. format=n will
- *				cause only 'n' 32 bit words to be dumped in a
- *				single line.
  */
 inline void
 megasas_dump_reg_set(void __iomem *reg_set)
 /**
  * megasas_reset_bus_host -	Bus & host reset handler entry point
+ * @scmd:			Mid-layer SCSI command
  */
 static int megasas_reset_bus_host(struct scsi_cmnd *scmd)
 {
 	megasas_register_aen(instance, seq_num, class_locale.word);
 }
-/**
+/*
  * Move the internal reset pending commands to a deferred queue.
  *
  * We move the commands pending at internal reset time to a
  * completion of the internal reset sequence. if the internal reset
  * did not complete in time, the kernel reset handler would flush
  * these commands.
- **/
+ */
 static void
 megasas_internal_reset_defer_cmds(struct megasas_instance *instance)
 {
 	tasklet_schedule(&instance->isr_tasklet);
 	return IRQ_HANDLED;
 }
 /**
  * megasas_isr - isr entry point
+ * @irq:	IRQ number
+ * @devp:	IRQ context address
  */
 static irqreturn_t megasas_isr(int irq, void *devp)
 {
 /**
  * megasas_transition_to_ready -	Move the FW to READY state
  * @instance:				Adapter soft state
+ * @ocr:				Adapter reset state
  *
  * During the initialization, FW passes can potentially be in any one of
  * several possible states. If the FW in operational, waiting-for-handshake
 /**
  * megasas_ld_list_query -	Returns FW's ld_list structure
  * @instance:				Adapter soft state
- * @ld_list:				ld_list structure
+ * @query_type:				ld_list structure type
  *
  * Issues an internal command (DCMD) to get the FW's controller PD
  * list structure.  This information is mainly used to find out SYSTEM
 			&instance->irq_context[i])) {
 			dev_err(&instance->pdev->dev,
 				"Failed to register IRQ for vector %d.\n", i);
-			for (j = 0; j < i; j++)
+			for (j = 0; j < i; j++) {
+				if (j < instance->low_latency_index_start)
+					irq_set_affinity_hint(
+						pci_irq_vector(pdev, j), NULL);
 				free_irq(pci_irq_vector(pdev, j),
 					 &instance->irq_context[j]);
+			}
 			/* Retry irq register for IO_APIC*/
 			instance->msix_vectors = 0;
 			instance->msix_load_balance = false;
 	if (instance->msix_vectors)
 		for (i = 0; i < instance->msix_vectors; i++) {
+			if (i < instance->low_latency_index_start)
+				irq_set_affinity_hint(
+				    pci_irq_vector(instance->pdev, i), NULL);
 			free_irq(pci_irq_vector(instance->pdev, i),
 				 &instance->irq_context[i]);
 		}
 /**
  * megasas_setup_jbod_map -	setup jbod map for FP seq_number.
  * @instance:				Adapter soft state
- * @is_probe:				Driver probe check
  *
  * Return 0 on success.
  */
  * megasas_register_aen -	Registers for asynchronous event notification
  * @instance:			Adapter soft state
  * @seq_num:			The starting sequence number
- * @class_locale:		Class of the event
+ * @class_locale_word:		Class of the event
  *
  * This function subscribes for AEN for events beyond the @seq_num. It requests
  * to be notified if and only if the event is of type @class_locale
  * megasas_alloc_ctrl_dma_buffers -	Allocate consistent DMA buffers during
  *					driver load time
  *
- * @instance-				Adapter soft instance
+ * @instance:				Adapter soft instance
- * @return-				O for SUCCESS
+ *
+ * @return:				O for SUCCESS
  */
 static inline
 int megasas_alloc_ctrl_dma_buffers(struct megasas_instance *instance)
 /**
  * megasas_shutdown -	Shutdown entry point
- * @device:		Generic device structure
+ * @pdev:		Generic device structure
  */
 static void megasas_shutdown(struct pci_dev *pdev)
 {
 		pci_free_irq_vectors(instance->pdev);
 }
-/**
+/*
  * megasas_mgmt_open -	char node "open" entry point
+ * @inode:	char node inode
+ * @filep:	char node file
  */
 static int megasas_mgmt_open(struct inode *inode, struct file *filep)
 {
 	return 0;
 }
-/**
+/*
  * megasas_mgmt_fasync -	Async notifier registration from applications
+ * @fd:		char node file descriptor number
+ * @filep:	char node file
+ * @mode:	notifier on/off
  *
  * This function adds the calling process to a driver global queue. When an
  * event occurs, SIGIO will be sent to all processes in this queue.
 	return rc;
 }
-/**
+/*
  * megasas_mgmt_poll -  char node "poll" entry point
- * */
+ * @filep:	char node file
+ * @wait:	Events to poll for
+ */
 static __poll_t megasas_mgmt_poll(struct file *file, poll_table *wait)
 {
 	__poll_t mask;
 /**
  * megasas_mgmt_fw_ioctl -	Issues management ioctls to FW
  * @instance:			Adapter soft state
- * @argp:			User's ioctl packet
+ * @user_ioc:			User's ioctl packet
+ * @ioc:			ioctl packet
  */
 static int
 megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
 /**
  * megasas_mgmt_ioctl -	char node ioctl entry point
+ * @file:	char device file pointer
+ * @cmd:	ioctl command
+ * @arg:	ioctl command arguments address
  */
 static long
 megasas_mgmt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)

drivers/scsi/megaraid/megaraid_sas_fp.c+5−6

 }
 /**
- * @param dividend    : Dividend
+ * mega_div64_32 - Do a 64-bit division
- * @param divisor    : Divisor
+ * @dividend:	Dividend
+ * @divisor:	Divisor
  *
  * @return quotient
  **/
 static u64 mega_div64_32(uint64_t dividend, uint32_t divisor)
 {
-	u32 remainder;
+	u64 d = dividend;
-	u64 d;
 	if (!divisor)
 		printk(KERN_ERR "megasas : DIVISOR is zero in mod fn\n");
-	d = dividend;
+	do_div(d, divisor);
-	remainder = do_div(d, divisor);
 	return d;
 }

drivers/scsi/megaraid/megaraid_sas_fusion.c+48−45

 #include "megaraid_sas.h"
-extern void megasas_free_cmds(struct megasas_instance *instance);
-extern struct megasas_cmd *megasas_get_cmd(struct megasas_instance
-					   *instance);
 extern void
 megasas_complete_cmd(struct megasas_instance *instance,
 		     struct megasas_cmd *cmd, u8 alt_status);
 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
 	      int seconds);
-void
-megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd);
-int megasas_alloc_cmds(struct megasas_instance *instance);
 int
 megasas_clear_intr_fusion(struct megasas_instance *instance);
-int
-megasas_issue_polled(struct megasas_instance *instance,
-		     struct megasas_cmd *cmd);
-void
-megasas_check_and_restore_queue_depth(struct megasas_instance *instance);
 int megasas_transition_to_ready(struct megasas_instance *instance, int ocr);
-void megaraid_sas_kill_hba(struct megasas_instance *instance);
 extern u32 megasas_dbg_lvl;
 int megasas_sriov_start_heartbeat(struct megasas_instance *instance,
 				  int initial);
-void megasas_start_timer(struct megasas_instance *instance);
 extern struct megasas_mgmt_info megasas_mgmt_info;
 extern unsigned int resetwaittime;
 extern unsigned int dual_qdepth_disable;
 static inline
 void megasas_configure_queue_sizes(struct megasas_instance *instance);
 static void megasas_fusion_crash_dump(struct megasas_instance *instance);
-extern u32 megasas_readl(struct megasas_instance *instance,
-			 const volatile void __iomem *addr);
 /**
  * megasas_adp_reset_wait_for_ready -	initiate chip reset and wait for
  *					controller to come to ready state
- * @instance -				adapter's soft state
+ * @instance:				adapter's soft state
- * @do_adp_reset -			If true, do a chip reset
+ * @do_adp_reset:			If true, do a chip reset
- * @ocr_context -			If called from OCR context this will
+ * @ocr_context:			If called from OCR context this will
  *					be set to 1, else 0
  *
  * This function initates a chip reset followed by a wait for controller to
 /**
  * megasas_check_same_4gb_region -	check if allocation
  *					crosses same 4GB boundary or not
- * @instance -				adapter's soft instance
+ * @instance:				adapter's soft instance
- * start_addr -			start address of DMA allocation
+ * @start_addr:				start address of DMA allocation
- * size -				size of allocation in bytes
+ * @size:				size of allocation in bytes
- * return -				true : allocation does not cross same
+ * @return:				true : allocation does not cross same
  *					4GB boundary
  *					false: allocation crosses same
  *					4GB boundary
 /**
  * megasas_enable_intr_fusion -	Enables interrupts
- * @regs:			MFI register set
+ * @instance:	adapter's soft instance
  */
 static void
 megasas_enable_intr_fusion(struct megasas_instance *instance)
 /**
  * megasas_disable_intr_fusion - Disables interrupt
- * @regs:			 MFI register set
+ * @instance:	adapter's soft instance
  */
 static void
 megasas_disable_intr_fusion(struct megasas_instance *instance)
 /**
  * megasas_get_cmd_fusion -	Get a command from the free pool
  * @instance:		Adapter soft state
+ * @blk_tag:		Command tag
  *
  * Returns a blk_tag indexed mpt frame
  */
 /**
  * megasas_fusion_update_can_queue -	Do all Adapter Queue depth related calculations here
- * @instance:							Adapter soft state
+ * @instance:		Adapter soft state
- * fw_boot_context:						Whether this function called during probe or after OCR
+ * @fw_boot_context:	Whether this function called during probe or after OCR
  *
  * This function is only for fusion controllers.
  * Update host can queue, if firmware downgrade max supported firmware commands.
  * wait_and_poll -	Issues a polling command
  * @instance:			Adapter soft state
  * @cmd:			Command packet to be issued
+ * @seconds:			Maximum poll time
  *
  * For polling, MFI requires the cmd_status to be set to 0xFF before posting.
  */
 /**
  * megasas_fault_detect_work	-	Worker function of
  *					FW fault handling workqueue.
+ * @work:	FW fault work struct
  */
 static void
 megasas_fault_detect_work(struct work_struct *work)
 /**
  * map_cmd_status -	Maps FW cmd status to OS cmd status
- * @cmd :		Pointer to cmd
+ * @fusion:		fusion context
- * @status :		status of cmd returned by FW
+ * @scmd:		Pointer to cmd
- * @ext_status :	ext status of cmd returned by FW
+ * @status:		status of cmd returned by FW
+ * @ext_status:		ext status of cmd returned by FW
+ * @data_length:	command data length
+ * @sense:		command sense data
  */
 static void
 map_cmd_status(struct fusion_context *fusion,
 		struct scsi_cmnd *scmd, u8 status, u8 ext_status,
  * @scp:		SCSI command from the mid-layer
  * @sgl_ptr:		SGL to be filled in
  * @cmd:		cmd we are working on
- * @sge_count		sge count
+ * @sge_count:		sge count
  *
  */
 static void
 /**
  * megasas_set_pd_lba -	Sets PD LBA
- * @cdb:		CDB
+ * @io_request:		IO request
  * @cdb_len:		cdb length
- * @start_blk:		Start block of IO
+ * @io_info:		IO information
+ * @scp:		SCSI command
+ * @local_map_ptr:	Raid map
+ * @ref_tag:		Primary reference tag
  *
  * Used to set the PD LBA in CDB for FP IOs
  */
  * affinity (cpu of the controller) and raid_flags in the raid context
  * based on IO type.
  *
+ * @fusion:		Fusion context
  * @praid_context:	IO RAID context
  * @raid:		LD raid map
  * @fp_possible:	Is fast path possible?
  * @is_read:		Is read IO?
+ * @scsi_buff_len:	SCSI command buffer length
  *
  */
 static void
 /**
  * megasas_build_ld_nonrw_fusion - prepares non rw ios for virtual disk
  * @instance:		Adapter soft state
- * @scp:		SCSI command
+ * @scmd:		SCSI command
  * @cmd:		Command to be prepared
  *
  * Prepares the io_request frame for non-rw io cmds for vd.
 /**
  * megasas_build_syspd_fusion - prepares rw/non-rw ios for syspd
  * @instance:		Adapter soft state
- * @scp:		SCSI command
+ * @scmd:		SCSI command
  * @cmd:		Command to be prepared
  * @fp_possible:	parameter to detect fast path or firmware path io.
  *
  * megasas_complete_r1_command -
  * completes R1 FP write commands which has valid peer smid
  * @instance:			Adapter soft state
- * @cmd_fusion:			MPT command frame
+ * @cmd:			MPT command frame
  *
  */
 static inline void
 /**
  * complete_cmd_fusion -	Completes command
  * @instance:			Adapter soft state
+ * @MSIxIndex:			MSI number
+ * @irq_context:		IRQ context
+ *
  * Completes all commands that is in reply descriptor queue
  */
 static int
 /**
  * megasas_enable_irq_poll() - enable irqpoll
+ * @instance:			Adapter soft state
  */
 static void megasas_enable_irq_poll(struct megasas_instance *instance)
 {
 /**
  * megasas_sync_irqs -	Synchronizes all IRQs owned by adapter
- * @instance:			Adapter soft state
+ * @instance_addr:			Adapter soft state address
  */
 static void megasas_sync_irqs(unsigned long instance_addr)
 {
 /**
  * megasas_complete_cmd_dpc_fusion -	Completes command
- * @instance:			Adapter soft state
+ * @instance_addr:			Adapter soft state address
  *
  * Tasklet to complete cmds
  */
 /**
  * megasas_isr_fusion - isr entry point
+ * @irq:	IRQ number
+ * @devp:	IRQ context
  */
 static irqreturn_t megasas_isr_fusion(int irq, void *devp)
 {
 /**
  * build_mpt_mfi_pass_thru - builds a cmd fo MFI Pass thru
  * @instance:			Adapter soft state
- * mfi_cmd:			megasas_cmd pointer
+ * @mfi_cmd:			megasas_cmd pointer
  *
  */
 static void
 /**
  * megasas_read_fw_status_reg_fusion - returns the current FW status value
- * @regs:			MFI register set
+ * @instance:			Adapter soft state
  */
 static u32
 megasas_read_fw_status_reg_fusion(struct megasas_instance *instance)
 /**
  * megasas_alloc_host_crash_buffer -	Host buffers for Crash dump collection from Firmware
  * @instance:				Controller's soft instance
- * return:			        Number of allocated host crash buffers
+ * @return:			        Number of allocated host crash buffers
  */
 static void
 megasas_alloc_host_crash_buffer(struct megasas_instance *instance)
 /**
  * megasas_adp_reset_fusion -	For controller reset
+ * @instance:				Controller's soft instance
  * @regs:				MFI register set
  */
 static int
 /**
  * megasas_check_reset_fusion -	For controller reset check
+ * @instance:				Controller's soft instance
  * @regs:				MFI register set
  */
 static int
 /**
  * megasas_tm_response_code - translation of device response code
- * @ioc: per adapter object
+ * @instance:	Controller's soft instance
- * @mpi_reply: MPI reply returned by firmware
+ * @mpi_reply:	MPI reply returned by firmware
  *
  * Return nothing.
  */
  * @device_handle: device handle
  * @channel: the channel assigned by the OS
  * @id: the id assigned by the OS
- * @type: MPI2_SCSITASKMGMT_TASKTYPE__XXX (defined in megaraid_sas_fusion.c)
  * @smid_task: smid assigned to the task
- * @m_type: TM_MUTEX_ON or TM_MUTEX_OFF
+ * @type: MPI2_SCSITASKMGMT_TASKTYPE__XXX (defined in megaraid_sas_fusion.c)
+ * @mr_device_priv_data: private data
  * Context: user
  *
  * MegaRaid use MPT interface for Task Magement request.

drivers/scsi/mesh.c+7−1

 		while ((in_8(&mr->bus_status1) & BS1_RST) != 0)
 			udelay(1);
 		printk("done\n");
+		if (ms->dma_started)
+			halt_dma(ms);
 		handle_reset(ms);
 		/* request_q is empty, no point in mesh_start() */
 		return;
 		       ms->conn_tgt, ms->data_ptr, scsi_bufflen(cmd),
 		       ms->tgts[ms->conn_tgt].data_goes_out);
 	}
-	scsi_dma_unmap(cmd);
+	if (cmd)
+		scsi_dma_unmap(cmd);
 	ms->dma_started = 0;
 }
 	spin_lock_irqsave(ms->host->host_lock, flags);
+	if (ms->dma_started)
+		halt_dma(ms);
 	/* Reset the controller & dbdma channel */
 	out_le32(&md->control, (RUN|PAUSE|FLUSH|WAKE) << 16);	/* stop dma */
 	out_8(&mr->exception, 0xff);	/* clear all exception bits */

drivers/scsi/mpt3sas/mpt3sas_base.c+8−6

 /**
  * _base_readl_aero - retry readl for max three times.
- * @addr - MPT Fusion system interface register address
+ * @addr: MPT Fusion system interface register address
  *
  * Retry the readl() for max three times if it gets zero value
  * while reading the system interface register.
  * mpt3sas_base_wait_for_coredump_completion - Wait until coredump
  * completes or times out
  * @ioc: per adapter object
+ * @caller: caller function name
  *
  * Returns 0 for success, non-zero for failure.
  */
 /**
  * _base_irqpoll - IRQ poll callback handler
- * @irqpoll - irq_poll object
+ * @irqpoll: irq_poll object
- * @budget - irq poll weight
+ * @budget: irq poll weight
  *
  * returns number of reply descriptors processed
  */
 /**
  * _base_check_and_enable_high_iops_queues - enable high iops mode
- * @ ioc - per adapter object
+ * @ioc: per adapter object
- * @ hba_msix_vector_count - msix vectors supported by HBA
+ * @hba_msix_vector_count: msix vectors supported by HBA
  *
  * Enable high iops queues only if
  *  - HBA is a SEA/AERO controller and
  * _base_wait_for_doorbell_int - waiting for controller interrupt(generated by
  * a write to the doorbell)
  * @ioc: per adapter object
+ * @timeout: timeout in seconds
  *
  * Return: 0 for success, non-zero for failure.
  *
 /**
  * mpt3sas_wait_for_ioc - IOC's operational state is checked here.
  * @ioc: per adapter object
- * @wait_count: timeout in seconds
+ * @timeout: timeout in seconds
  *
  * Return: Waits up to timeout seconds for the IOC to
  * become operational. Returns 0 if IOC is present

drivers/scsi/mpt3sas/mpt3sas_base.h+1−1

@@ -1770,7 +1770,7 @@ void mpt3sas_send_trigger_data_event(struct MPT3SAS_ADAPTER *ioc, · 1769 unmodified lines
1770	void mpt3sas_process_trigger_data(struct MPT3SAS_ADAPTER *ioc,	1770	void mpt3sas_process_trigger_data(struct MPT3SAS_ADAPTER *ioc,
1771	struct SL_WH_TRIGGERS_EVENT_DATA_T *event_data);	1771	struct SL_WH_TRIGGERS_EVENT_DATA_T *event_data);
1772	void mpt3sas_trigger_master(struct MPT3SAS_ADAPTER *ioc,	1772	void mpt3sas_trigger_master(struct MPT3SAS_ADAPTER *ioc,
1773	u32 tigger_bitmask);	1773	u32 trigger_bitmask);
1774	void mpt3sas_trigger_event(struct MPT3SAS_ADAPTER *ioc, u16 event,	1774	void mpt3sas_trigger_event(struct MPT3SAS_ADAPTER *ioc, u16 event,
1775	u16 log_entry_qualifier);	1775	u16 log_entry_qualifier);
1776	void mpt3sas_trigger_scsi(struct MPT3SAS_ADAPTER *ioc, u8 sense_key,	1776	void mpt3sas_trigger_scsi(struct MPT3SAS_ADAPTER *ioc, u8 sense_key,

drivers/scsi/mpt3sas/mpt3sas_config.c+3−4

 	u8 retry_count, issue_host_reset = 0;
 	struct config_request mem;
 	u32 ioc_status = UINT_MAX;
-	u8 issue_reset = 0;
 	mutex_lock(&ioc->config_cmds.mutex);
 	if (ioc->config_cmds.status != MPT3_CMD_NOT_USED) {
 		if (!(ioc->logging_level & MPT_DEBUG_CONFIG))
 			_config_display_some_debug(ioc,
 			    smid, "config_request", NULL);
-		mpt3sas_check_cmd_timeout(ioc,
+		ioc_err(ioc, "%s: command timeout\n", __func__);
-		    ioc->config_cmds.status, mpi_request,
+		mpt3sas_base_check_cmd_timeout(ioc, ioc->config_cmds.status,
-		    sizeof(Mpi2ConfigRequest_t)/4, issue_reset);
+				mpi_request, sizeof(Mpi2ConfigRequest_t) / 4);
 		retry_count++;
 		if (ioc->config_cmds.smid == smid)
 			mpt3sas_base_free_smid(ioc, smid);

drivers/scsi/mpt3sas/mpt3sas_ctl.c+10−6

 /**
  * drv_support_bitmap_show - driver supported feature bitmap
- * @cdev - pointer to embedded class device
+ * @cdev: pointer to embedded class device
- * @buf - the buffer returned
+ * @attr: unused
+ * @buf: the buffer returned
  *
  * A sysfs 'read-only' shost attribute.
  */
 /**
  * enable_sdev_max_qd_show - display whether sdev max qd is enabled/disabled
- * @cdev - pointer to embedded class device
+ * @cdev: pointer to embedded class device
- * @buf - the buffer returned
+ * @attr: unused
+ * @buf: the buffer returned
  *
  * A sysfs read/write shost attribute. This attribute is used to set the
  * targets queue depth to HBA IO queue depth if this attribute is enabled.
 /**
  * enable_sdev_max_qd_store - Enable/disable sdev max qd
- * @cdev - pointer to embedded class device
+ * @cdev: pointer to embedded class device
- * @buf - the buffer returned
+ * @attr: unused
+ * @buf: the buffer returned
+ * @count: unused
  *
  * A sysfs read/write shost attribute. This attribute is used to set the
  * targets queue depth to HBA IO queue depth if this attribute is enabled.

drivers/scsi/mpt3sas/mpt3sas_trigger_diag.h+1−1

@@ -69,7 +69,7 @@ · 68 unmodified lines
69	#define MASTER_TRIGGER_TASK_MANAGMENT (0x00000004)	69	#define MASTER_TRIGGER_TASK_MANAGMENT (0x00000004)
70	#define MASTER_TRIGGER_DEVICE_REMOVAL (0x00000008)	70	#define MASTER_TRIGGER_DEVICE_REMOVAL (0x00000008)
71		71
72	/* fake firmware event for tigger */	72	/* fake firmware event for trigger */
73	#define MPI3_EVENT_DIAGNOSTIC_TRIGGER_FIRED (0x6E)	73	#define MPI3_EVENT_DIAGNOSTIC_TRIGGER_FIRED (0x6E)
74		74
75	/**	75	/**

drivers/scsi/mvsas/mv_init.c+4−4

 static irqreturn_t mvs_interrupt(int irq, void *opaque)
 {
-	u32 core_nr;
 	u32 stat;
 	struct mvs_info *mvi;
 	struct sas_ha_struct *sha = opaque;
 #ifndef CONFIG_SCSI_MVSAS_TASKLET
 	u32 i;
-#endif
+	u32 core_nr;
 	core_nr = ((struct mvs_prv_info *)sha->lldd_ha)->n_host;
+#endif
 	mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[0];
 	if (unlikely(!mvi))
 int mvs_ioremap(struct mvs_info *mvi, int bar, int bar_ex)
 {
-	unsigned long res_start, res_len, res_flag, res_flag_ex = 0;
+	unsigned long res_start, res_len, res_flag_ex = 0;
 	struct pci_dev *pdev = mvi->pdev;
 	if (bar_ex != -1) {
 		/*
 		goto err_out;
 	}
-	res_flag = pci_resource_flags(pdev, bar);
 	mvi->regs = ioremap(res_start, res_len);
 	if (!mvi->regs) {

drivers/scsi/myrs.c+17−17

@@ -87,7 +87,7 @@ static char *myrs_raid_level_name(enum myrs_raid_level level) · 86 unmodified lines
87	return NULL;	87	return NULL;
88	}	88	}
89		89
90	/**	90	/*
91	* myrs_reset_cmd - clears critical fields in struct myrs_cmdblk	91	* myrs_reset_cmd - clears critical fields in struct myrs_cmdblk
92	*/	92	*/
93	static inline void myrs_reset_cmd(struct myrs_cmdblk *cmd_blk)	93	static inline void myrs_reset_cmd(struct myrs_cmdblk *cmd_blk)
@@ -98,7 +98,7 @@ static inline void myrs_reset_cmd(struct myrs_cmdblk *cmd_blk) · 4 unmodified lines
98	cmd_blk->status = 0;	98	cmd_blk->status = 0;
99	}	99	}
100		100
101	/**	101	/*
102	* myrs_qcmd - queues Command for DAC960 V2 Series Controllers.	102	* myrs_qcmd - queues Command for DAC960 V2 Series Controllers.
103	*/	103	*/
104	static void myrs_qcmd(struct myrs_hba cs, struct myrs_cmdblk cmd_blk)	104	static void myrs_qcmd(struct myrs_hba cs, struct myrs_cmdblk cmd_blk)
@@ -122,7 +122,7 @@ static void myrs_qcmd(struct myrs_hba cs, struct myrs_cmdblk cmd_blk) · 17 unmodified lines
122	cs->next_cmd_mbox = next_mbox;	122	cs->next_cmd_mbox = next_mbox;
123	}	123	}
124		124
125	/**	125	/*
126	* myrs_exec_cmd - executes V2 Command and waits for completion.	126	* myrs_exec_cmd - executes V2 Command and waits for completion.
127	*/	127	*/
128	static void myrs_exec_cmd(struct myrs_hba *cs,	128	static void myrs_exec_cmd(struct myrs_hba *cs,
@@ -140,7 +140,7 @@ static void myrs_exec_cmd(struct myrs_hba *cs, · 11 unmodified lines
140	wait_for_completion(&complete);	140	wait_for_completion(&complete);
141	}	141	}
142		142
143	/**	143	/*
144	* myrs_report_progress - prints progress message	144	* myrs_report_progress - prints progress message
145	*/	145	*/
146	static void myrs_report_progress(struct myrs_hba *cs, unsigned short ldev_num,	146	static void myrs_report_progress(struct myrs_hba *cs, unsigned short ldev_num,
@@ -153,7 +153,7 @@ static void myrs_report_progress(struct myrs_hba *cs, unsigned short ldev_num, · 6 unmodified lines
153	(100 * (int)(blocks >> 7)) / (int)(size >> 7));	153	(100 * (int)(blocks >> 7)) / (int)(size >> 7));
154	}	154	}
155		155
156	/**	156	/*
157	* myrs_get_ctlr_info - executes a Controller Information IOCTL Command	157	* myrs_get_ctlr_info - executes a Controller Information IOCTL Command
158	*/	158	*/
159	static unsigned char myrs_get_ctlr_info(struct myrs_hba *cs)	159	static unsigned char myrs_get_ctlr_info(struct myrs_hba *cs)
@@ -214,7 +214,7 @@ static unsigned char myrs_get_ctlr_info(struct myrs_hba *cs) · 54 unmodified lines
214	return status;	214	return status;
215	}	215	}
216		216
217	/**	217	/*
218	* myrs_get_ldev_info - executes a Logical Device Information IOCTL Command	218	* myrs_get_ldev_info - executes a Logical Device Information IOCTL Command
219	*/	219	*/
220	static unsigned char myrs_get_ldev_info(struct myrs_hba *cs,	220	static unsigned char myrs_get_ldev_info(struct myrs_hba *cs,
@@ -301,7 +301,7 @@ static unsigned char myrs_get_ldev_info(struct myrs_hba *cs, · 80 unmodified lines
301	return status;	301	return status;
302	}	302	}
303		303
304	/**	304	/*
305	* myrs_get_pdev_info - executes a "Read Physical Device Information" Command	305	* myrs_get_pdev_info - executes a "Read Physical Device Information" Command
306	*/	306	*/
307	static unsigned char myrs_get_pdev_info(struct myrs_hba *cs,	307	static unsigned char myrs_get_pdev_info(struct myrs_hba *cs,
@@ -345,7 +345,7 @@ static unsigned char myrs_get_pdev_info(struct myrs_hba *cs, · 37 unmodified lines
345	return status;	345	return status;
346	}	346	}
347		347
348	/**	348	/*
349	* myrs_dev_op - executes a "Device Operation" Command	349	* myrs_dev_op - executes a "Device Operation" Command
350	*/	350	*/
351	static unsigned char myrs_dev_op(struct myrs_hba *cs,	351	static unsigned char myrs_dev_op(struct myrs_hba *cs,
@@ -369,7 +369,7 @@ static unsigned char myrs_dev_op(struct myrs_hba *cs, · 17 unmodified lines
369	return status;	369	return status;
370	}	370	}
371		371
372	/**	372	/*
373	* myrs_translate_pdev - translates a Physical Device Channel and	373	* myrs_translate_pdev - translates a Physical Device Channel and
374	* TargetID into a Logical Device.	374	* TargetID into a Logical Device.
375	*/	375	*/
@@ -414,7 +414,7 @@ static unsigned char myrs_translate_pdev(struct myrs_hba *cs, · 38 unmodified lines
414	return status;	414	return status;
415	}	415	}
416		416
417	/**	417	/*
418	* myrs_get_event - executes a Get Event Command	418	* myrs_get_event - executes a Get Event Command
419	*/	419	*/
420	static unsigned char myrs_get_event(struct myrs_hba *cs,	420	static unsigned char myrs_get_event(struct myrs_hba *cs,
@@ -476,7 +476,7 @@ static unsigned char myrs_get_fwstatus(struct myrs_hba *cs) · 55 unmodified lines
476	return status;	476	return status;
477	}	477	}
478		478
479	/**	479	/*
480	* myrs_enable_mmio_mbox - enables the Memory Mailbox Interface	480	* myrs_enable_mmio_mbox - enables the Memory Mailbox Interface
481	*/	481	*/
482	static bool myrs_enable_mmio_mbox(struct myrs_hba *cs,	482	static bool myrs_enable_mmio_mbox(struct myrs_hba *cs,
@@ -577,7 +577,7 @@ out_free: · 94 unmodified lines
577	return (status == MYRS_STATUS_SUCCESS);	577	return (status == MYRS_STATUS_SUCCESS);
578	}	578	}
579		579
580	/**	580	/*
581	* myrs_get_config - reads the Configuration Information	581	* myrs_get_config - reads the Configuration Information
582	*/	582	*/
583	static int myrs_get_config(struct myrs_hba *cs)	583	static int myrs_get_config(struct myrs_hba *cs)
@@ -682,7 +682,7 @@ static int myrs_get_config(struct myrs_hba *cs) · 98 unmodified lines
682	return 0;	682	return 0;
683	}	683	}
684		684
685	/**	685	/*
686	* myrs_log_event - prints a Controller Event message	686	* myrs_log_event - prints a Controller Event message
687	*/	687	*/
688	static struct {	688	static struct {
@@ -2338,11 +2338,11 @@ Failure: · 1649 unmodified lines
2338	return NULL;	2338	return NULL;
2339	}	2339	}
2340		2340
2341	/**	2341	/*
2342	* myrs_err_status reports Controller BIOS Messages passed through	2342	* myrs_err_status reports Controller BIOS Messages passed through
2343	the Error Status Register when the driver performs the BIOS handshaking.	2343	* the Error Status Register when the driver performs the BIOS handshaking.
2344	It returns true for fatal errors and false otherwise.	2344	* It returns true for fatal errors and false otherwise.
2345	*/	2345	*/
2346		2346
2347	static bool myrs_err_status(struct myrs_hba *cs, unsigned char status,	2347	static bool myrs_err_status(struct myrs_hba *cs, unsigned char status,
2348	unsigned char parm0, unsigned char parm1)	2348	unsigned char parm0, unsigned char parm1)

drivers/scsi/pcmcia/nsp_cs.c+3−2

 	scsi_set_resid(SCpnt, scsi_get_resid(SCpnt) + residInc);
 }
+__printf(4, 5)
 static void nsp_cs_message(const char *func, int line, char *type, char *fmt, ...)
 {
 	va_list args;
 {
 	unsigned int base = SCpnt->device->host->io_port;
 	unsigned int count;
-	unsigned int l, m, h, dummy;
+	unsigned int l, m, h;
 	nsp_index_write(base, POINTERCLR, POINTER_CLEAR | ACK_COUNTER);
 	l     = nsp_index_read(base, TRANSFERCOUNT);
 	m     = nsp_index_read(base, TRANSFERCOUNT);
 	h     = nsp_index_read(base, TRANSFERCOUNT);
-	dummy = nsp_index_read(base, TRANSFERCOUNT); /* required this! */
+	nsp_index_read(base, TRANSFERCOUNT); /* required this! */
 	count = (h << 16) | (m << 8) | (l << 0);

drivers/scsi/pm8001/pm8001_ctl.c+22−1

 /**
  * pm8001_ctl_mpi_interface_rev_show - MPI interface revision number
  * @cdev: pointer to embedded class device
+ * @attr: device attribute (unused)
  * @buf: the buffer returned
  *
  * A sysfs 'read-only' shost attribute.
 /**
  * controller_fatal_error_show - check controller is under fatal err
  * @cdev: pointer to embedded class device
+ * @attr: device attribute (unused)
  * @buf: the buffer returned
  *
  * A sysfs 'read only' shost attribute.
 /**
  * pm8001_ctl_fw_version_show - firmware version
  * @cdev: pointer to embedded class device
+ * @attr: device attribute (unused)
  * @buf: the buffer returned
  *
  * A sysfs 'read-only' shost attribute.
 /**
  * pm8001_ctl_ila_version_show - ila version
  * @cdev: pointer to embedded class device
+ * @attr: device attribute (unused)
  * @buf: the buffer returned
  *
  * A sysfs 'read-only' shost attribute.
 /**
  * pm8001_ctl_inactive_fw_version_show - Inacative firmware version number
  * @cdev: pointer to embedded class device
+ * @attr: device attribute (unused)
  * @buf: the buffer returned
  *
  * A sysfs 'read-only' shost attribute.
 /**
  * pm8001_ctl_max_out_io_show - max outstanding io supported
  * @cdev: pointer to embedded class device
+ * @attr: device attribute (unused)
  * @buf: the buffer returned
  *
  * A sysfs 'read-only' shost attribute.
 /**
  * pm8001_ctl_max_devices_show - max devices support
  * @cdev: pointer to embedded class device
+ * @attr: device attribute (unused)
  * @buf: the buffer returned
  *
  * A sysfs 'read-only' shost attribute.
  * pm8001_ctl_max_sg_list_show - max sg list supported iff not 0.0 for no
  * hardware limitation
  * @cdev: pointer to embedded class device
+ * @attr: device attribute (unused)
  * @buf: the buffer returned
  *
  * A sysfs 'read-only' shost attribute.
 /**
  * pm8001_ctl_sas_spec_support_show - sas spec supported
  * @cdev: pointer to embedded class device
+ * @attr: device attribute (unused)
  * @buf: the buffer returned
  *
  * A sysfs 'read-only' shost attribute.
 /**
  * pm8001_ctl_sas_address_show - sas address
  * @cdev: pointer to embedded class device
+ * @attr: device attribute (unused)
  * @buf: the buffer returned
  *
  * This is the controller sas address
 /**
  * pm8001_ctl_logging_level_show - logging level
  * @cdev: pointer to embedded class device
+ * @attr: device attribute (unused)
  * @buf: the buffer returned
  *
  * A sysfs 'read/write' shost attribute.
 	return snprintf(buf, PAGE_SIZE, "%08xh\n", pm8001_ha->logging_level);
 }
 static ssize_t pm8001_ctl_logging_level_store(struct device *cdev,
 	struct device_attribute *attr, const char *buf, size_t count)
 {
 /**
  * pm8001_ctl_aap_log_show - aap1 event log
  * @cdev: pointer to embedded class device
+ * @attr: device attribute (unused)
  * @buf: the buffer returned
  *
  * A sysfs 'read-only' shost attribute.
 /**
  * pm8001_ctl_ib_queue_log_show - Out bound Queue log
  * @cdev:pointer to embedded class device
+ * @attr: device attribute (unused)
  * @buf: the buffer returned
  * A sysfs 'read-only' shost attribute.
  */
 /**
  * pm8001_ctl_ob_queue_log_show - Out bound Queue log
  * @cdev:pointer to embedded class device
+ * @attr: device attribute (unused)
  * @buf: the buffer returned
  * A sysfs 'read-only' shost attribute.
  */
 /**
  * pm8001_ctl_bios_version_show - Bios version Display
  * @cdev:pointer to embedded class device
+ * @attr: device attribute (unused)
  * @buf:the buffer returned
  * A sysfs 'read-only' shost attribute.
  */
 /**
  * event_log_size_show - event log size
  * @cdev: pointer to embedded class device
+ * @attr: device attribute (unused)
  * @buf: the buffer returned
  *
  * A sysfs read  shost attribute.
 /**
  * pm8001_ctl_aap_log_show - IOP event log
  * @cdev: pointer to embedded class device
+ * @attr: device attribute (unused)
  * @buf: the buffer returned
  *
  * A sysfs 'read-only' shost attribute.
 /**
  ** pm8001_ctl_fatal_log_show - fatal error logging
  ** @cdev:pointer to embedded class device
+ ** @attr: device attribute
  ** @buf: the buffer returned
  **
  ** A sysfs 'read-only' shost attribute.
 /**
  ** non_fatal_log_show - non fatal error logging
  ** @cdev:pointer to embedded class device
+ ** @attr: device attribute
  ** @buf: the buffer returned
  **
  ** A sysfs 'read-only' shost attribute.
 /**
  ** pm8001_ctl_gsm_log_show - gsm dump collection
  ** @cdev:pointer to embedded class device
+ ** @attr: device attribute (unused)
  ** @buf: the buffer returned
- **A sysfs 'read-only' shost attribute.
+ ** A sysfs 'read-only' shost attribute.
  **/
 static ssize_t pm8001_ctl_gsm_log_show(struct device *cdev,
 	struct device_attribute *attr, char *buf)

drivers/scsi/pm8001/pm8001_hwi.c+14−13

 /**
  * update_inbnd_queue_table - update the inbound queue table to the HBA.
  * @pm8001_ha: our hba card information
+ * @number: entry in the queue
  */
 static void update_inbnd_queue_table(struct pm8001_hba_info *pm8001_ha,
 				     int number)
 /**
  * update_outbnd_queue_table - update the outbound queue table to the HBA.
  * @pm8001_ha: our hba card information
+ * @number: entry in the queue
  */
 static void update_outbnd_queue_table(struct pm8001_hba_info *pm8001_ha,
 				      int number)
 /**
  * mpi_set_open_retry_interval_reg
  * @pm8001_ha: our hba card information
- * @interval - interval time for each OPEN_REJECT (RETRY). The units are in 1us.
+ * @interval: interval time for each OPEN_REJECT (RETRY). The units are in 1us.
  */
 static void mpi_set_open_retry_interval_reg(struct pm8001_hba_info *pm8001_ha,
 					    u32 interval)
 /**
  * pm8001_chip_msix_interrupt_enable - enable PM8001 chip interrupt
  * @pm8001_ha: our hba card information
+ * @int_vec_idx: interrupt number to enable
  */
 static void
 pm8001_chip_msix_interrupt_enable(struct pm8001_hba_info *pm8001_ha,
 /**
  * pm8001_chip_msix_interrupt_disable - disable PM8001 chip interrupt
  * @pm8001_ha: our hba card information
+ * @int_vec_idx: interrupt number to disable
  */
 static void
 pm8001_chip_msix_interrupt_disable(struct pm8001_hba_info *pm8001_ha,
 /**
  * pm8001_chip_interrupt_enable - enable PM8001 chip interrupt
  * @pm8001_ha: our hba card information
+ * @vec: unused
  */
 static void
 pm8001_chip_interrupt_enable(struct pm8001_hba_info *pm8001_ha, u8 vec)
 /**
  * pm8001_chip_intx_interrupt_disable- disable PM8001 chip interrupt
  * @pm8001_ha: our hba card information
+ * @vec: unused
  */
 static void
 pm8001_chip_interrupt_disable(struct pm8001_hba_info *pm8001_ha, u8 vec)
 /**
  * pm8001_chip_phy_start_req - start phy via PHY_START COMMAND
  * @pm8001_ha: our hba card information.
- * @num: the inbound queue number
  * @phy_id: the phy id which we wanted to start up.
  */
 static int
 /**
  * pm8001_chip_phy_stop_req - start phy via PHY_STOP COMMAND
  * @pm8001_ha: our hba card information.
- * @num: the inbound queue number
  * @phy_id: the phy id which we wanted to start up.
  */
 static int pm8001_chip_phy_stop_req(struct pm8001_hba_info *pm8001_ha,
 	return ret;
 }
-/**
+/*
  * see comments on pm8001_mpi_reg_resp.
  */
 static int pm8001_chip_reg_dev_req(struct pm8001_hba_info *pm8001_ha,
 	return rc;
 }
-/**
+/*
  * see comments on pm8001_mpi_reg_resp.
  */
 int pm8001_chip_dereg_dev_req(struct pm8001_hba_info *pm8001_ha,
 /**
  * pm8001_chip_phy_ctl_req - support the local phy operation
  * @pm8001_ha: our hba card information.
- * @num: the inbound queue number
+ * @phyId: the phy id which we wanted to operate
- * @phy_id: the phy id which we wanted to operate
+ * @phy_op: the phy operation to request
- * @phy_op:
  */
 static int pm8001_chip_phy_ctl_req(struct pm8001_hba_info *pm8001_ha,
 	u32 phyId, u32 phy_op)
 /**
  * pm8001_chip_isr - PM8001 isr handler.
  * @pm8001_ha: our hba card information.
- * @irq: irq number.
+ * @vec: IRQ number
- * @stat: stat.
  */
 static irqreturn_t
 pm8001_chip_isr(struct pm8001_hba_info *pm8001_ha, u8 vec)
 	return ret;
 }
-/**
+/*
  * pm8001_chip_abort_task - SAS abort task when error or exception happened.
- * @task: the task we wanted to aborted.
- * @flag: the abort flag.
  */
 int pm8001_chip_abort_task(struct pm8001_hba_info *pm8001_ha,
 	struct pm8001_device *pm8001_dev, u8 flag, u32 task_tag, u32 cmd_tag)
  * pm8001_chip_fw_flash_update_build - support the firmware update operation
  * @pm8001_ha: our hba card information.
  * @fw_flash_updata_info: firmware flash update param
+ * @tag: Tag to apply to the payload
  */
 int
 pm8001_chip_fw_flash_update_build(struct pm8001_hba_info *pm8001_ha,

drivers/scsi/pm8001/pm8001_init.c+15−15

 static struct scsi_transport_template *pm8001_stt;
-/**
+/*
  * chip info structure to identify chip key functionality as
  * encryption available/not, no of ports, hw specific function ref
  */
 struct workqueue_struct *pm8001_wq;
-/**
+/*
  * The main structure which LLDD must register for scsi core.
  */
 static struct scsi_host_template pm8001_sht = {
 	.track_queue_depth	= 1,
 };
-/**
+/*
  * Sas layer call this function to execute specific task.
  */
 static struct sas_domain_function_template pm8001_transport_ops = {
 };
 /**
- *pm8001_phy_init - initiate our adapter phys
+ * pm8001_phy_init - initiate our adapter phys
- *@pm8001_ha: our hba structure.
+ * @pm8001_ha: our hba structure.
- *@phy_id: phy id.
+ * @phy_id: phy id.
  */
 static void pm8001_phy_init(struct pm8001_hba_info *pm8001_ha, int phy_id)
 {
 }
 /**
- *pm8001_free - free hba
+ * pm8001_free - free hba
- *@pm8001_ha:	our hba structure.
+ * @pm8001_ha:	our hba structure.
- *
  */
 static void pm8001_free(struct pm8001_hba_info *pm8001_ha)
 {
  * pm8001_interrupt_handler_msix - main MSIX interrupt handler.
  * It obtains the vector number and calls the equivalent bottom
  * half or services directly.
+ * @irq: interrupt number
  * @opaque: the passed outbound queue/vector. Host structure is
  * retrieved from the same.
  */
 /**
  * pm8001_interrupt_handler_intx - main INTx interrupt handler.
+ * @irq: interrupt number
  * @dev_id: sas_ha structure. The HBA is retrieved from sas_has structure.
  */
 /**
  * pm8001_alloc - initiate our hba structure and 6 DMAs area.
- * @pm8001_ha:our hba structure.
+ * @pm8001_ha: our hba structure.
- *
+ * @ent: PCI device ID structure to match on
  */
 static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha,
 			const struct pci_device_id *ent)
 /**
  * pm8001_init_sas_add - initialize sas address
- * @chip_info: our ha struct.
+ * @pm8001_ha: our ha struct.
  *
  * Currently we just set the fixed SAS address to our HBA,for manufacture,
  * it should read from the EEPROM
 #ifdef PM8001_USE_MSIX
 /**
  * pm8001_setup_msix - enable MSI-X interrupt
- * @chip_info: our ha struct.
+ * @pm8001_ha: our ha struct.
- * @irq_handler: irq_handler
  */
 static u32 pm8001_setup_msix(struct pm8001_hba_info *pm8001_ha)
 {
 /**
  * pm8001_request_irq - register interrupt
- * @chip_info: our ha struct.
+ * @pm8001_ha: our ha struct.
  */
 static u32 pm8001_request_irq(struct pm8001_hba_info *pm8001_ha)
 {

drivers/scsi/pm8001/pm8001_sas.c+5−4

 	*pphys_addr_lo = lower_32_bits(phys_align);
 	return 0;
 }
 /**
   * pm8001_find_ha_by_dev - from domain device which come from sas layer to
   * find out our hba struct.
 	return 0;
 }
+#define DEV_IS_GONE(pm8001_dev)	\
+	((!pm8001_dev || (pm8001_dev->dev_type == SAS_PHY_UNUSED)))
 /**
   * pm8001_task_exec - queue the task(ssp, smp && ata) to the hardware.
   * @task: the task to be execute.
-  * @num: if can_queue great than 1, the task can be queued up. for SMP task,
-  * we always execute one one time.
   * @gfp_flags: gfp_flags.
   * @is_tmf: if it is task management task.
   * @tmf: the task management IU
   */
-#define DEV_IS_GONE(pm8001_dev)	\
-	((!pm8001_dev || (pm8001_dev->dev_type == SAS_PHY_UNUSED)))
 static int pm8001_task_exec(struct sas_task *task,
 	gfp_t gfp_flags, int is_tmf, struct pm8001_tmf_task *tmf)
 {
 /**
   * pm8001_find_dev - find a matching pm8001_device
   * @pm8001_ha: our hba card information
+  * @device_id: device ID to match against
   */
 struct pm8001_device *pm8001_find_dev(struct pm8001_hba_info *pm8001_ha,
 					u32 device_id)
 /**
   * Standard mandates link reset for ATA  (type 0) and hard reset for
   * SSP (type 1) , only for RECOVERY
+  * @dev: the device structure for the device to reset.
   */
 int pm8001_I_T_nexus_reset(struct domain_device *dev)
 {

drivers/scsi/pm8001/pm80xx_hwi.c+12−11

 	return 0;
 }
-void pm80xx_pci_mem_copy(struct pm8001_hba_info  *pm8001_ha, u32 soffset,
+static void pm80xx_pci_mem_copy(struct pm8001_hba_info  *pm8001_ha, u32 soffset,
 				const void *destination,
 				u32 dw_count, u32 bus_base_number)
 {
 /**
  * update_inbnd_queue_table - update the inbound queue table to the HBA.
  * @pm8001_ha: our hba card information
+ * @number: entry in the queue
  */
 static void update_inbnd_queue_table(struct pm8001_hba_info *pm8001_ha,
 					 int number)
 /**
  * update_outbnd_queue_table - update the outbound queue table to the HBA.
  * @pm8001_ha: our hba card information
+ * @number: entry in the queue
  */
 static void update_outbnd_queue_table(struct pm8001_hba_info *pm8001_ha,
 						 int number)
 /**
  * pm8001_chip_interrupt_enable - enable PM8001 chip interrupt
  * @pm8001_ha: our hba card information
+ * @vec: interrupt number to enable
  */
 static void
 pm80xx_chip_interrupt_enable(struct pm8001_hba_info *pm8001_ha, u8 vec)
 /**
  * pm8001_chip_interrupt_disable- disable PM8001 chip interrupt
  * @pm8001_ha: our hba card information
+ * @vec: interrupt number to disable
  */
 static void
 pm80xx_chip_interrupt_disable(struct pm8001_hba_info *pm8001_ha, u8 vec)
 /**
  * pm80xx_chip_phy_start_req - start phy via PHY_START COMMAND
  * @pm8001_ha: our hba card information.
- * @num: the inbound queue number
  * @phy_id: the phy id which we wanted to start up.
  */
 static int
 /**
  * pm8001_chip_phy_stop_req - start phy via PHY_STOP COMMAND
  * @pm8001_ha: our hba card information.
- * @num: the inbound queue number
  * @phy_id: the phy id which we wanted to start up.
  */
 static int pm80xx_chip_phy_stop_req(struct pm8001_hba_info *pm8001_ha,
 	return ret;
 }
-/**
+/*
  * see comments on pm8001_mpi_reg_resp.
  */
 static int pm80xx_chip_reg_dev_req(struct pm8001_hba_info *pm8001_ha,
 /**
  * pm80xx_chip_phy_ctl_req - support the local phy operation
  * @pm8001_ha: our hba card information.
- * @num: the inbound queue number
+ * @phyId: the phy id which we wanted to operate
- * @phy_id: the phy id which we wanted to operate
+ * @phy_op: phy operation to request
- * @phy_op:
  */
 static int pm80xx_chip_phy_ctl_req(struct pm8001_hba_info *pm8001_ha,
 	u32 phyId, u32 phy_op)
 /**
  * pm8001_chip_isr - PM8001 isr handler.
  * @pm8001_ha: our hba card information.
- * @irq: irq number.
+ * @vec: irq number.
- * @stat: stat.
  */
 static irqreturn_t
 pm80xx_chip_isr(struct pm8001_hba_info *pm8001_ha, u8 vec)
 	return IRQ_HANDLED;
 }
-void mpi_set_phy_profile_req(struct pm8001_hba_info *pm8001_ha,
+static void mpi_set_phy_profile_req(struct pm8001_hba_info *pm8001_ha,
-	u32 operation, u32 phyid, u32 length, u32 *buf)
+				    u32 operation, u32 phyid,
+				    u32 length, u32 *buf)
 {
 	u32 tag , i, j = 0;
 	int rc;

drivers/scsi/ppa.c+0−3

 			    (DID_OK << 16) + (h << 8) + (l & STATUS_MASK);
 		}
 		return 0;	/* Finished */
-		break;
 	default:
 		printk(KERN_ERR "ppa: Invalid scsi phase\n");
 	case 1:		/* Have not connected to interface */
 		dev->cur_cmd = NULL;	/* Forget the problem */
 		return SUCCESS;
-		break;
 	default:		/* SCSI command sent, can not abort */
 		return FAILED;
-		break;
 	}
 }

drivers/scsi/qedf/qedf_debugfs.c+8−10

 static struct dentry *qedf_dbg_root;
-/**
+/*
  * qedf_dbg_host_init - setup the debugfs file for the pf
- * @pf: the pf that is starting up
+ */
- **/
 void
 qedf_dbg_host_init(struct qedf_dbg_ctx *qedf,
 		    const struct qedf_debugfs_ops *dops,
 	}
 }
-/**
+/*
  * qedf_dbg_host_exit - clear out the pf's debugfs entries
- * @pf: the pf that is stopping
+ */
- **/
 void
 qedf_dbg_host_exit(struct qedf_dbg_ctx *qedf_dbg)
 {
 	qedf_dbg->bdf_dentry = NULL;
 }
-/**
+/*
  * qedf_dbg_init - start up debugfs for the driver
- **/
+ */
 void
 qedf_dbg_init(char *drv_name)
 {
 	qedf_dbg_root = debugfs_create_dir(drv_name, NULL);
 }
-/**
+/*
  * qedf_dbg_exit - clean out the driver's debugfs entries
- **/
+ */
 void
 qedf_dbg_exit(void)
 {

drivers/scsi/qedf/qedf_io.c+4−26

 	    container_of(work, struct qedf_ioreq, timeout_work.work);
 	struct qedf_ctx *qedf;
 	struct qedf_rport *fcport;
-	u8 op = 0;
 	if (io_req == NULL) {
 		QEDF_INFO(NULL, QEDF_LOG_IO, "io_req is NULL.\n");
 		io_req->event = QEDF_IOREQ_EV_ELS_TMO;
 		/* Call callback function to complete command */
 		if (io_req->cb_func && io_req->cb_arg) {
-			op = io_req->cb_arg->op;
 			io_req->cb_func(io_req->cb_arg);
 			io_req->cb_arg = NULL;
 		}
 	int sg_count = 0;
 	int bd_count = 0;
 	u32 sg_len;
-	u64 addr, end_addr;
+	u64 addr;
 	int i = 0;
 	sg_count = dma_map_sg(&qedf->pdev->dev, scsi_sglist(sc),
 	scsi_for_each_sg(sc, sg, sg_count, i) {
 		sg_len = (u32)sg_dma_len(sg);
 		addr = (u64)sg_dma_address(sg);
-		end_addr = (u64)(addr + sg_len);
 		/*
-		 * Intermediate s/g element so check if start and end address
+		 * Intermediate s/g element so check if start address
 		 * is page aligned.  Only required for writes and only if the
 		 * number of scatter/gather elements is 8 or more.
 		 */
 	struct qedf_ctx *qedf = lport_priv(lport);
 	struct e4_fcoe_task_context *task_ctx;
 	u16 xid;
-	enum fcoe_task_type req_type = 0;
 	struct fcoe_wqe *sqe;
 	u16 sqe_idx;
 	io_req->cpu = smp_processor_id();
 	if (sc_cmd->sc_data_direction == DMA_FROM_DEVICE) {
-		req_type = FCOE_TASK_TYPE_READ_INITIATOR;
 		io_req->io_req_flags = QEDF_READ;
 		qedf->input_requests++;
 	} else if (sc_cmd->sc_data_direction == DMA_TO_DEVICE) {
-		req_type = FCOE_TASK_TYPE_WRITE_INITIATOR;
 		io_req->io_req_flags = QEDF_WRITE;
 		qedf->output_requests++;
 	} else {
 void qedf_scsi_completion(struct qedf_ctx *qedf, struct fcoe_cqe *cqe,
 	struct qedf_ioreq *io_req)
 {
-	u16 xid;
-	struct e4_fcoe_task_context *task_ctx;
 	struct scsi_cmnd *sc_cmd;
 	struct fcoe_cqe_rsp_info *fcp_rsp;
 	struct qedf_rport *fcport;
 		return;
 	}
-	xid = io_req->xid;
-	task_ctx = qedf_get_task_mem(&qedf->tasks, xid);
 	sc_cmd = io_req->sc_cmd;
 	fcp_rsp = &cqe->cqe_info.rsp_info;
 void qedf_scsi_done(struct qedf_ctx *qedf, struct qedf_ioreq *io_req,
 	int result)
 {
-	u16 xid;
 	struct scsi_cmnd *sc_cmd;
 	int refcount;
 	 */
 	clear_bit(QEDF_CMD_OUTSTANDING, &io_req->flags);
-	xid = io_req->xid;
 	sc_cmd = io_req->sc_cmd;
 	if (!sc_cmd) {
 	struct fc_rport_priv *rdata;
 	struct qedf_ctx *qedf;
 	u16 xid;
-	u32 r_a_tov = 0;
 	int rc = 0;
 	unsigned long flags;
 	struct fcoe_wqe *sqe;
 		goto out;
 	}
-	r_a_tov = rdata->r_a_tov;
 	lport = qedf->lport;
 	if (lport->state != LPORT_ST_READY || !(lport->link_up)) {
 	struct qedf_ioreq *io_req)
 {
 	uint32_t r_ctl;
-	uint16_t xid;
 	int rc;
 	struct qedf_rport *fcport = io_req->fcport;
 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_SCSI_TM, "Entered with xid = "
 		   "0x%x cmd_type = %d\n", io_req->xid, io_req->cmd_type);
-	xid = io_req->xid;
 	r_ctl = cqe->cqe_info.abts_info.r_ctl;
 	/* This was added at a point when we were scheduling abts_compl &
 {
 	struct qedf_rport *fcport;
 	struct qedf_ctx *qedf;
-	uint16_t xid;
-	struct e4_fcoe_task_context *task;
 	int tmo = 0;
 	int rc = SUCCESS;
 	unsigned long flags;
 		  refcount, fcport, fcport->rdata->ids.port_id);
 	/* Cleanup cmds re-use the same TID as the original I/O */
-	xid = io_req->xid;
 	io_req->cmd_type = QEDF_CLEANUP;
 	io_req->return_scsi_cmd_on_abts = return_scsi_cmd_on_abts;
-	task = qedf_get_task_mem(&qedf->tasks, xid);
 	init_completion(&io_req->cleanup_done);
 	spin_lock_irqsave(&fcport->rport_lock, flags);
 	struct fcoe_cqe *cqe)
 {
 	unsigned long flags;
-	uint16_t tmp;
 	uint16_t pktlen = cqe->cqe_info.unsolic_info.pkt_len;
 	u32 payload_len, crc;
 	struct fc_frame_header *fh;
 		qedf->bdq_prod_idx = 0;
 	writew(qedf->bdq_prod_idx, qedf->bdq_primary_prod);
-	tmp = readw(qedf->bdq_primary_prod);
+	readw(qedf->bdq_primary_prod);
 	writew(qedf->bdq_prod_idx, qedf->bdq_secondary_prod);
-	tmp = readw(qedf->bdq_secondary_prod);
+	readw(qedf->bdq_secondary_prod);
 	spin_unlock_irqrestore(&qedf->hba_lock, flags);
 }

drivers/scsi/qedf/qedf_main.c+4−6

 	return rc;
 }
-/**
+/*
  * qedf_xmit - qedf FCoE frame transmit function
- *
  */
 static int qedf_xmit(struct fc_lport *lport, struct fc_frame *fp)
 {
 	kref_put(&rdata->kref, fc_rport_destroy);
 }
-/**
+/*
  * This event_callback is called after successful completion of libfc
  * initiated target login. qedf can proceed with initiating the session
  * establishment.
 	void *task_start, *task_end;
 	struct qed_slowpath_params slowpath_params;
 	struct qed_probe_params qed_params;
-	u16 tmp;
 	/*
 	 * When doing error recovery we didn't reap the lport so don't try
 	    "Writing %d to primary and secondary BDQ doorbell registers.\n",
 	    qedf->bdq_prod_idx);
 	writew(qedf->bdq_prod_idx, qedf->bdq_primary_prod);
-	tmp = readw(qedf->bdq_primary_prod);
+	readw(qedf->bdq_primary_prod);
 	writew(qedf->bdq_prod_idx, qedf->bdq_secondary_prod);
-	tmp = readw(qedf->bdq_secondary_prod);
+	readw(qedf->bdq_secondary_prod);
 	qed_ops->common->set_power_state(qedf->cdev, PCI_D0);

drivers/scsi/qedi/qedi_fw.c+2−3

 				struct iscsi_cqe_unsolicited *cqe,
 				int count)
 {
-	u16 tmp;
 	u16 idx = 0;
 	struct scsi_bd *pbl;
 	qedi->bdq_prod_idx += count;
 	writew(qedi->bdq_prod_idx, qedi->bdq_primary_prod);
-	tmp = readw(qedi->bdq_primary_prod);
+	readw(qedi->bdq_primary_prod);
 	writew(qedi->bdq_prod_idx, qedi->bdq_secondary_prod);
-	tmp = readw(qedi->bdq_secondary_prod);
+	readw(qedi->bdq_secondary_prod);
 }
 static void qedi_unsol_pdu_adjust_bdq(struct qedi_ctx *qedi,

drivers/scsi/qedi/qedi_iscsi.c+1−1

@@ -1546,7 +1546,7 @@ static const struct { · 1545 unmodified lines
1546	},	1546	},
1547	};	1547	};
1548		1548
1549	char *qedi_get_iscsi_error(enum iscsi_error_types err_code)	1549	static char *qedi_get_iscsi_error(enum iscsi_error_types err_code)
1550	{	1550	{
1551	int i;	1551	int i;
1552	char *msg = NULL;	1552	char *msg = NULL;

drivers/scsi/qedi/qedi_main.c+3−6

 {
 	struct qedi_work *qedi_work;
 	struct qedi_conn *q_conn;
-	struct iscsi_conn *conn;
 	struct qedi_cmd *qedi_cmd;
 	u32 iscsi_cid;
 	int rc = 0;
 			  iscsi_cid);
 		return -1;
 	}
-	conn = q_conn->cls_conn->dd_data;
 	switch (cqe->cqe_common.cqe_type) {
 	case ISCSI_CQE_TYPE_SOLICITED:
 	qedi_ops->ll2->start(qedi->cdev, &params);
 }
-/**
+/*
  * qedi_get_nvram_block: - Scan through the iSCSI NVRAM block (while accounting
  * for gaps) for the matching absolute-pf-id of the QEDI device.
  */
 	struct qed_probe_params qed_params;
 	void *task_start, *task_end;
 	int rc;
-	u16 tmp;
 	if (mode != QEDI_MODE_RECOVERY) {
 		qedi = qedi_host_alloc(pdev);
 		  "Writing %d to primary and secondary BDQ doorbell registers.\n",
 		  qedi->bdq_prod_idx);
 	writew(qedi->bdq_prod_idx, qedi->bdq_primary_prod);
-	tmp = readw(qedi->bdq_primary_prod);
+	readw(qedi->bdq_primary_prod);
 	writew(qedi->bdq_prod_idx, qedi->bdq_secondary_prod);
-	tmp = readw(qedi->bdq_secondary_prod);
+	readw(qedi->bdq_secondary_prod);
 	ether_addr_copy(qedi->mac, qedi->dev_info.common.hw_mac);
 	QEDI_INFO(&qedi->dbg_ctx, QEDI_LOG_DISC, "MAC address is %pM.\n",

drivers/scsi/qla2xxx/qla_bsg.c+1−2

@@ -223,8 +223,7 @@ qla24xx_proc_fcp_prio_cfg_cmd(struct bsg_job *bsg_job) · 222 unmodified lines
223		223
224	/* validate fcp priority data */	224	/* validate fcp priority data */
225		225
226	if (!qla24xx_fcp_prio_cfg_valid(vha,	226	if (!qla24xx_fcp_prio_cfg_valid(vha, ha->fcp_prio_cfg, 1)) {
227	(struct qla_fcp_prio_cfg *) ha->fcp_prio_cfg, 1)) {
228	bsg_reply->result = (DID_ERROR << 16);	227	bsg_reply->result = (DID_ERROR << 16);
229	ret = -EINVAL;	228	ret = -EINVAL;
230	/* If buffer was invalidatic int	229	/* If buffer was invalidatic int

drivers/scsi/qla2xxx/qla_dbg.c+36−75

  * ----------------------------------------------------------------------
  * |             Level            |   Last Value Used  |     Holes	|
  * ----------------------------------------------------------------------
- * | Module Init and Probe        |       0x0193       | 0x0146         |
+ * | Module Init and Probe        |       0x0199       |                |
- * |                              |                    | 0x015b-0x0160	|
+ * | Mailbox commands             |       0x1206       | 0x11a5-0x11ff	|
- * |                              |                    | 0x016e		|
- * | Mailbox commands             |       0x1206       | 0x11a2-0x11ff	|
  * | Device Discovery             |       0x2134       | 0x210e-0x2116  |
  * |				  | 		       | 0x211a         |
  * |                              |                    | 0x211c-0x2128  |
  * |                              |                    | 0x3036,0x3038  |
  * |                              |                    | 0x303a		|
  * | DPC Thread                   |       0x4023       | 0x4002,0x4013  |
- * | Async Events                 |       0x5090       | 0x502b-0x502f  |
+ * | Async Events                 |       0x509c       |                |
- * |				  | 		       | 0x5047         |
- * |                              |                    | 0x5084,0x5075	|
- * |                              |                    | 0x503d,0x5044  |
- * |                              |                    | 0x505f		|
  * | Timer Routines               |       0x6012       |                |
  * | User Space Interactions      |       0x70e3       | 0x7018,0x702e  |
  * |				  |		       | 0x7020,0x7024  |
 	}
 	if (rval == QLA_SUCCESS)
-		qla2xxx_copy_queues(ha, &fw->risc_ram[cnt]);
+		qla2xxx_copy_queues(ha, &fw->queue_dump[0]);
 	qla2xxx_dump_post_process(base_vha, rval);
 }
 /*                         Driver Debug Functions.                          */
 /****************************************************************************/
+/* Write the debug message prefix into @pbuf. */
+static void ql_dbg_prefix(char *pbuf, int pbuf_size,
+			  const scsi_qla_host_t *vha, uint msg_id)
+{
+	if (vha) {
+		const struct pci_dev *pdev = vha->hw->pdev;
+		/* <module-name> [<dev-name>]-<msg-id>:<host>: */
+		snprintf(pbuf, pbuf_size, "%s [%s]-%04x:%ld: ", QL_MSGHDR,
+			 dev_name(&(pdev->dev)), msg_id, vha->host_no);
+	} else {
+		/* <module-name> [<dev-name>]-<msg-id>: : */
+		snprintf(pbuf, pbuf_size, "%s [%s]-%04x: : ", QL_MSGHDR,
+			 "0000:00:00.0", msg_id);
+	}
+}
 /*
  * This function is for formatting and logging debug information.
  * It is to be used when vha is available. It formats the message
 {
 	va_list va;
 	struct va_format vaf;
+	char pbuf[64];
 	va_start(va, fmt);
 	vaf.fmt = fmt;
 	vaf.va = &va;
-	if (!ql_mask_match(level)) {
+	ql_dbg_prefix(pbuf, ARRAY_SIZE(pbuf), vha, id);
-		char pbuf[64];
-		if (vha != NULL) {
+	if (!ql_mask_match(level))
-			const struct pci_dev *pdev = vha->hw->pdev;
-			/* <module-name> <msg-id>:<host> Message */
-			snprintf(pbuf, sizeof(pbuf), "%s [%s]-%04x:%ld: ",
-			    QL_MSGHDR, dev_name(&(pdev->dev)), id,
-			    vha->host_no);
-		} else {
-			snprintf(pbuf, sizeof(pbuf), "%s [%s]-%04x: : ",
-			    QL_MSGHDR, "0000:00:00.0", id);
-		}
-		pbuf[sizeof(pbuf) - 1] = 0;
 		trace_ql_dbg_log(pbuf, &vaf);
-		va_end(va);
+	else
-		return;
+		pr_warn("%s%pV", pbuf, &vaf);
-	}
-	if (vha != NULL) {
-		const struct pci_dev *pdev = vha->hw->pdev;
-		/* <module-name> <pci-name> <msg-id>:<host> Message */
-		pr_warn("%s [%s]-%04x:%ld: %pV",
-			QL_MSGHDR, dev_name(&(pdev->dev)), id + ql_dbg_offset,
-			vha->host_no, &vaf);
-	} else {
-		pr_warn("%s [%s]-%04x: : %pV",
-			QL_MSGHDR, "0000:00:00.0", id + ql_dbg_offset, &vaf);
-	}
 	va_end(va);
 {
 	va_list va;
 	struct va_format vaf;
+	char pbuf[128];
 	if (pdev == NULL)
 		return;
 	vaf.fmt = fmt;
 	vaf.va = &va;
-	/* <module-name> <dev-name>:<msg-id> Message */
+	ql_dbg_prefix(pbuf, ARRAY_SIZE(pbuf), NULL, id + ql_dbg_offset);
-	pr_warn("%s [%s]-%04x: : %pV",
+	pr_warn("%s%pV", pbuf, &vaf);
-		QL_MSGHDR, dev_name(&(pdev->dev)), id + ql_dbg_offset, &vaf);
 	va_end(va);
 }
 	if (level > ql_errlev)
 		return;
-	if (vha != NULL) {
+	ql_dbg_prefix(pbuf, ARRAY_SIZE(pbuf), vha, id);
-		const struct pci_dev *pdev = vha->hw->pdev;
-		/* <module-name> <msg-id>:<host> Message */
-		snprintf(pbuf, sizeof(pbuf), "%s [%s]-%04x:%ld: ",
-			QL_MSGHDR, dev_name(&(pdev->dev)), id, vha->host_no);
-	} else {
-		snprintf(pbuf, sizeof(pbuf), "%s [%s]-%04x: : ",
-			QL_MSGHDR, "0000:00:00.0", id);
-	}
-	pbuf[sizeof(pbuf) - 1] = 0;
 	va_start(va, fmt);
 	if (level > ql_errlev)
 		return;
-	/* <module-name> <dev-name>:<msg-id> Message */
+	ql_dbg_prefix(pbuf, ARRAY_SIZE(pbuf), NULL, id);
-	snprintf(pbuf, sizeof(pbuf), "%s [%s]-%04x: : ",
-		 QL_MSGHDR, dev_name(&(pdev->dev)), id);
-	pbuf[sizeof(pbuf) - 1] = 0;
 	va_start(va, fmt);
 		    "mbox[%d] %#04x\n", i, rd_reg_word(mbx_reg));
 }
 void
 ql_dump_buffer(uint level, scsi_qla_host_t *vha, uint id, const void *buf,
 	       uint size)
 	if (level > ql_errlev)
 		return;
-	if (qpair != NULL) {
+	ql_dbg_prefix(pbuf, ARRAY_SIZE(pbuf), qpair ? qpair->vha : NULL, id);
-		const struct pci_dev *pdev = qpair->pdev;
-		/* <module-name> <msg-id>:<host> Message */
-		snprintf(pbuf, sizeof(pbuf), "%s [%s]-%04x: ",
-			QL_MSGHDR, dev_name(&(pdev->dev)), id);
-	} else {
-		snprintf(pbuf, sizeof(pbuf), "%s [%s]-%04x: : ",
-			QL_MSGHDR, "0000:00:00.0", id);
-	}
-	pbuf[sizeof(pbuf) - 1] = 0;
 	va_start(va, fmt);
 {
 	va_list va;
 	struct va_format vaf;
+	char pbuf[128];
 	if (!ql_mask_match(level))
 		return;
 	vaf.fmt = fmt;
 	vaf.va = &va;
-	if (qpair != NULL) {
+	ql_dbg_prefix(pbuf, ARRAY_SIZE(pbuf), qpair ? qpair->vha : NULL,
-		const struct pci_dev *pdev = qpair->pdev;
+		      id + ql_dbg_offset);
-		/* <module-name> <pci-name> <msg-id>:<host> Message */
+	pr_warn("%s%pV", pbuf, &vaf);
-		pr_warn("%s [%s]-%04x: %pV",
-		    QL_MSGHDR, dev_name(&(pdev->dev)), id + ql_dbg_offset,
-		    &vaf);
-	} else {
-		pr_warn("%s [%s]-%04x: : %pV",
-			QL_MSGHDR, "0000:00:00.0", id + ql_dbg_offset, &vaf);
-	}
 	va_end(va);

drivers/scsi/qla2xxx/qla_dbg.h+1−0

@@ -53,6 +53,7 @@ struct qla2100_fw_dump { · 52 unmodified lines
53	__be16 fpm_b0_reg[64];	53	__be16 fpm_b0_reg[64];
54	__be16 fpm_b1_reg[64];	54	__be16 fpm_b1_reg[64];
55	__be16 risc_ram[0xf000];	55	__be16 risc_ram[0xf000];
		56	u8 queue_dump[];
56	};	57	};
57		58
58	struct qla24xx_fw_dump {	59	struct qla24xx_fw_dump {

drivers/scsi/qla2xxx/qla_def.h+62−2

 #include <scsi/scsi_transport_fc.h>
 #include <scsi/scsi_bsg_fc.h>
+#include <uapi/scsi/fc/fc_els.h>
 /* Big endian Fibre Channel S_ID (source ID) or D_ID (destination ID). */
 typedef struct {
 	uint8_t domain;
 #define MBA_LIP_F8		0x8016	/* Received a LIP F8. */
 #define MBA_LOOP_INIT_ERR	0x8017	/* Loop Initialization Error. */
 #define MBA_FABRIC_AUTH_REQ	0x801b	/* Fabric Authentication Required. */
+#define MBA_CONGN_NOTI_RECV	0x801e	/* Congestion Notification Received */
 #define MBA_SCSI_COMPLETION	0x8020	/* SCSI Command Complete. */
 #define MBA_CTIO_COMPLETION	0x8021	/* CTIO Complete. */
 #define MBA_IP_COMPLETION	0x8022	/* IP Transmit Command Complete. */
 #define RNID_TYPE_ASIC_TEMP	0xC
 #define ELS_CMD_MAP_SIZE	32
-#define ELS_COMMAND_RDP		0x18
 /*
  * Firmware state codes from get firmware state mailbox command
 	uint8_t  reserved_3[26];
 } init_cb_t;
+/* Special Features Control Block */
+struct init_sf_cb {
+	uint8_t	format;
+	uint8_t	reserved0;
+	/*
+	 * BIT 15-14 = Reserved
+	 * BIT_13 = SAN Congestion Management (1 - Enabled, 0 - Disabled)
+	 * BIT_12 = Remote Write Optimization (1 - Enabled, 0 - Disabled)
+	 * BIT 11-0 = Reserved
+	 */
+	uint16_t flags;
+	uint8_t	reserved1[32];
+	uint16_t discard_OHRB_timeout_value;
+	uint16_t remote_write_opt_queue_num;
+	uint8_t	reserved2[40];
+	uint8_t scm_related_parameter[16];
+	uint8_t reserved3[32];
+};
 /*
  * Get Link Status mailbox command return buffer.
  */
 	struct dsd64 rsp_dsd;
 } ms_iocb_entry_t;
+#define SCM_EDC_ACC_RECEIVED		BIT_6
+#define SCM_RDF_ACC_RECEIVED		BIT_7
 /*
  * ISP queue - Mailbox Command entry structure definition.
 		uint32_t        n2n_bigger:1;
 		uint32_t	secure_adapter:1;
 		uint32_t	secure_fw:1;
+				/* Supported by Adapter */
+		uint32_t	scm_supported_a:1;
+				/* Supported by Firmware */
+		uint32_t	scm_supported_f:1;
+				/* Enabled in Driver */
+		uint32_t	scm_enabled:1;
 	} flags;
 	uint16_t max_exchg;
 	int		init_cb_size;
 	dma_addr_t	ex_init_cb_dma;
 	struct ex_init_cb_81xx *ex_init_cb;
+	dma_addr_t	sf_init_cb_dma;
+	struct init_sf_cb *sf_init_cb;
+	void		*scm_fpin_els_buff;
+	uint64_t	scm_fpin_els_buff_size;
+	bool		scm_fpin_valid;
+	bool		scm_fpin_payload_size;
 	void		*async_pd;
 	dma_addr_t	async_pd_dma;
 #define FW_ATTR_H_NVME		BIT_10
 #define FW_ATTR_H_NVME_UPDATED  BIT_14
+	/* About firmware SCM support */
+#define FW_ATTR_EXT0_SCM_SUPPORTED	BIT_12
+	/* Brocade fabric attached */
+#define FW_ATTR_EXT0_SCM_BROCADE	0x00001000
+	/* Cisco fabric attached */
+#define FW_ATTR_EXT0_SCM_CISCO		0x00002000
 	uint16_t	fw_attributes_ext[2];
 	uint32_t	fw_memory_size;
 	uint32_t	fw_transfer_size;
 #define QLA_SET_DATA_RATE_NOLR	1
 #define QLA_SET_DATA_RATE_LR	2 /* Set speed and initiate LR */
+#define QLA_DEFAULT_PAYLOAD_SIZE	64
+/*
+ * This item might be allocated with a size > sizeof(struct purex_item).
+ * The "size" variable gives the size of the payload (which
+ * is variable) starting at "iocb".
+ */
 struct purex_item {
 	struct list_head list;
 	struct scsi_qla_host *vha;
-	void (*process_item)(struct scsi_qla_host *vha, void *pkt);
+	void (*process_item)(struct scsi_qla_host *vha,
+			     struct purex_item *pkt);
+	atomic_t in_use;
+	uint16_t size;
 	struct {
 		uint8_t iocb[64];
 	} iocb;
 };
+#define SCM_FLAG_RDF_REJECT		0x00
+#define SCM_FLAG_RDF_COMPLETED		0x01
+#define QLA_CON_PRIMITIVE_RECEIVED	0x1
+#define QLA_CONGESTION_ARB_WARNING	0x1
+#define QLA_CONGESTION_ARB_ALARM	0X2
 /*
  * Qlogic scsi host structure
  */
 		struct list_head head;
 		spinlock_t lock;
 	} purex_list;
+	struct purex_item default_item;
 	struct name_list_extended gnl;
 	/* Count of active session/fcport */
 	__le16 dport_data[4];
 	struct list_head gpnid_list;
 	struct fab_scan scan;
+	uint8_t	scm_fabric_connection_flags;
 	unsigned int irq_offset;
 } scsi_qla_host_t;

drivers/scsi/qla2xxx/qla_fw.h+6−2

 	__le32	residual_len;		/* FW calc residual transfer length. */
 	union {
-		uint16_t reserved_1;
+		__le16 reserved_1;
 		__le16	nvme_rsp_pyld_len;
 	};
 	struct dsd64 dsd[2];
 };
+#define PURX_ELS_HEADER_SIZE	0x18
 /*
  * ISP queue - PUREX IOCB entry structure definition
  */
 	 * BIT 0    = Extended BB credits for LR
 	 * BIT 1    = Virtual Fabric Enable
 	 * BIT 2-5  = Distance Support if BIT 0 is on
-	 * BIT 6-15 = Unused
+	 * BIT 6    = Prefer FCP
+	 * BIT 7    = SCM Disabled if BIT is set (1)
+	 * BIT 8-15 = Unused
 	 */
 	uint16_t enhanced_features;

drivers/scsi/qla2xxx/qla_gbl.h+3−1

 void qla_do_iidma_work(struct scsi_qla_host *vha, fc_port_t *fcport);
 int qla2x00_reserve_mgmt_server_loop_id(scsi_qla_host_t *);
 void qla_rscn_replay(fc_port_t *fcport);
+void qla24xx_free_purex_item(struct purex_item *item);
 extern bool qla24xx_risc_firmware_invalid(uint32_t *);
 /*
 int qla24xx_post_gnl_work(struct scsi_qla_host *, fc_port_t *);
 int qla24xx_post_relogin_work(struct scsi_qla_host *vha);
 void qla2x00_wait_for_sess_deletion(scsi_qla_host_t *);
-void qla24xx_process_purex_rdp(struct scsi_qla_host *vha, void *pkt);
+void qla24xx_process_purex_rdp(struct scsi_qla_host *vha,
+			       struct purex_item *pkt);
 /*
  * Global Functions in qla_mid.c source file.

drivers/scsi/qla2xxx/qla_init.c+29−19

@@ -3749,7 +3749,7 @@ enable_82xx_npiv: · 3748 unmodified lines
3749	}	3749	}
3750		3750
3751	/* Enable PUREX PASSTHRU */	3751	/* Enable PUREX PASSTHRU */
3752	if (ql2xrdpenable)	3752	if (ql2xrdpenable \|\| ha->flags.scm_supported_f)
3753	qla25xx_set_els_cmds_supported(vha);	3753	qla25xx_set_els_cmds_supported(vha);
3754	} else	3754	} else
3755	goto failed;	3755	goto failed;
@@ -3962,7 +3962,7 @@ qla24xx_update_fw_options(scsi_qla_host_t *vha) · 206 unmodified lines
3962	ha->fw_options[2] &= ~BIT_8;	3962	ha->fw_options[2] &= ~BIT_8;
3963	}	3963	}
3964		3964
3965	if (ql2xrdpenable)	3965	if (ql2xrdpenable \|\| ha->flags.scm_supported_f)
3966	ha->fw_options[1] \|= ADD_FO1_ENABLE_PUREX_IOCB;	3966	ha->fw_options[1] \|= ADD_FO1_ENABLE_PUREX_IOCB;
3967		3967
3968	/* Enable Async 8130/8131 events -- transceiver insertion/removal */	3968	/* Enable Async 8130/8131 events -- transceiver insertion/removal */
@@ -6996,36 +6996,41 @@ qla2x00_abort_isp(scsi_qla_host_t *vha) · 3027 unmodified lines
6996	static int	6996	static int
6997	qla2x00_restart_isp(scsi_qla_host_t *vha)	6997	qla2x00_restart_isp(scsi_qla_host_t *vha)
6998	{	6998	{
6999	int status = 0;	6999	int status;
7000	struct qla_hw_data *ha = vha->hw;	7000	struct qla_hw_data *ha = vha->hw;
7001		7001
7002	/* If firmware needs to be loaded */	7002	/* If firmware needs to be loaded */
7003	if (qla2x00_isp_firmware(vha)) {	7003	if (qla2x00_isp_firmware(vha)) {
7004	vha->flags.online = 0;	7004	vha->flags.online = 0;
7005	status = ha->isp_ops->chip_diag(vha);	7005	status = ha->isp_ops->chip_diag(vha);
7006	if (!status)	7006	if (status)
7007	status = qla2x00_setup_chip(vha);	7007	return status;
		7008	status = qla2x00_setup_chip(vha);
		7009	if (status)
		7010	return status;
7008	}	7011	}
7009		7012
7010	if (!status && !(status = qla2x00_init_rings(vha))) {	7013	status = qla2x00_init_rings(vha);
7011	clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);	7014	if (status)
7012	ha->flags.chip_reset_done = 1;	7015	return status;
7013		7016
7014	/* Initialize the queues in use */	7017	clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
7015	qla25xx_init_queues(ha);	7018	ha->flags.chip_reset_done = 1;
7016		7019
7017	status = qla2x00_fw_ready(vha);	7020	/* Initialize the queues in use */
7018	if (!status) {	7021	qla25xx_init_queues(ha);
7019	/* Issue a marker after FW becomes ready. */
7020	qla2x00_marker(vha, ha->base_qpair, 0, 0, MK_SYNC_ALL);
7021	set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
7022	}
7023		7022
		7023	status = qla2x00_fw_ready(vha);
		7024	if (status) {
7024	/* if no cable then assume it's good */	7025	/* if no cable then assume it's good */
7025	if ((vha->device_flags & DFLG_NO_CABLE))	7026	return vha->device_flags & DFLG_NO_CABLE ? 0 : status;
7026	status = 0;
7027	}	7027	}
7028	return (status);	7028
		7029	/* Issue a marker after FW becomes ready. */
		7030	qla2x00_marker(vha, ha->base_qpair, 0, 0, MK_SYNC_ALL);
		7031	set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
		7032
		7033	return 0;
7029	}	7034	}
7030		7035
7031	static int	7036	static int
@@ -8514,6 +8519,11 @@ qla81xx_nvram_config(scsi_qla_host_t *vha) · 1482 unmodified lines
8514	icb->node_name[0] &= 0xF0;	8519	icb->node_name[0] &= 0xF0;
8515	}	8520	}
8516		8521
		8522	if (IS_QLA28XX(ha) \|\| IS_QLA27XX(ha)) {
		8523	if ((nv->enhanced_features & BIT_7) == 0)
		8524	ha->flags.scm_supported_a = 1;
		8525	}
		8526
8517	/* Set host adapter parameters. */	8527	/* Set host adapter parameters. */
8518	ha->flags.disable_risc_code_load = 0;	8528	ha->flags.disable_risc_code_load = 0;
8519	ha->flags.enable_lip_reset = 0;	8529	ha->flags.enable_lip_reset = 0;

drivers/scsi/qla2xxx/qla_inline.h+1−1

@@ -11,7 +11,7 @@ · 10 unmodified lines
11	* Continuation Type 1 IOCBs to allocate.	11	* Continuation Type 1 IOCBs to allocate.
12	*	12	*
13	* @vha: HA context	13	* @vha: HA context
14	* @dsds: number of data segment decriptors needed	14	* @dsds: number of data segment descriptors needed
15	*	15	*
16	* Returns the number of IOCB entries needed to store @dsds.	16	* Returns the number of IOCB entries needed to store @dsds.
17	*/	17	*/

drivers/scsi/qla2xxx/qla_iocb.c+5−5

@@ -44,7 +44,7 @@ qla2x00_get_cmd_direction(srb_t *sp) · 43 unmodified lines
44	* qla2x00_calc_iocbs_32() - Determine number of Command Type 2 and	44	* qla2x00_calc_iocbs_32() - Determine number of Command Type 2 and
45	* Continuation Type 0 IOCBs to allocate.	45	* Continuation Type 0 IOCBs to allocate.
46	*	46	*
47	* @dsds: number of data segment decriptors needed	47	* @dsds: number of data segment descriptors needed
48	*	48	*
49	* Returns the number of IOCB entries needed to store @dsds.	49	* Returns the number of IOCB entries needed to store @dsds.
50	*/	50	*/
@@ -66,7 +66,7 @@ qla2x00_calc_iocbs_32(uint16_t dsds) · 15 unmodified lines
66	* qla2x00_calc_iocbs_64() - Determine number of Command Type 3 and	66	* qla2x00_calc_iocbs_64() - Determine number of Command Type 3 and
67	* Continuation Type 1 IOCBs to allocate.	67	* Continuation Type 1 IOCBs to allocate.
68	*	68	*
69	* @dsds: number of data segment decriptors needed	69	* @dsds: number of data segment descriptors needed
70	*	70	*
71	* Returns the number of IOCB entries needed to store @dsds.	71	* Returns the number of IOCB entries needed to store @dsds.
72	*/	72	*/
@@ -669,7 +669,7 @@ qla24xx_build_scsi_type_6_iocbs(srb_t sp, struct cmd_type_6 cmd_pkt, · 596 unmodified lines
669	* qla24xx_calc_dsd_lists() - Determine number of DSD list required	669	* qla24xx_calc_dsd_lists() - Determine number of DSD list required
670	* for Command Type 6.	670	* for Command Type 6.
671	*	671	*
672	* @dsds: number of data segment decriptors needed	672	* @dsds: number of data segment descriptors needed
673	*	673	*
674	* Returns the number of dsd list needed to store @dsds.	674	* Returns the number of dsd list needed to store @dsds.
675	*/	675	*/
@@ -2305,8 +2305,8 @@ __qla2x00_alloc_iocbs(struct qla_qpair qpair, srb_t sp) · 1629 unmodified lines
2305	pkt = req->ring_ptr;	2305	pkt = req->ring_ptr;
2306	memset(pkt, 0, REQUEST_ENTRY_SIZE);	2306	memset(pkt, 0, REQUEST_ENTRY_SIZE);
2307	if (IS_QLAFX00(ha)) {	2307	if (IS_QLAFX00(ha)) {
2308	wrt_reg_byte((void __iomem *)&pkt->entry_count, req_cnt);	2308	wrt_reg_byte((u8 __force __iomem *)&pkt->entry_count, req_cnt);
2309	wrt_reg_word((void __iomem *)&pkt->handle, handle);	2309	wrt_reg_dword((__le32 __force __iomem *)&pkt->handle, handle);
2310	} else {	2310	} else {
2311	pkt->entry_count = req_cnt;	2311	pkt->entry_count = req_cnt;
2312	pkt->handle = handle;	2312	pkt->handle = handle;

drivers/scsi/qla2xxx/qla_isr.c+249−41

@@ -22,6 +22,31 @@ static void qla2x00_status_entry(scsi_qla_host_t , struct rsp_que , void *); · 21 unmodified lines
22	static void qla2x00_status_cont_entry(struct rsp_que , sts_cont_entry_t );	22	static void qla2x00_status_cont_entry(struct rsp_que , sts_cont_entry_t );
23	static int qla2x00_error_entry(scsi_qla_host_t , struct rsp_que ,	23	static int qla2x00_error_entry(scsi_qla_host_t , struct rsp_que ,
24	sts_entry_t *);	24	sts_entry_t *);
		25	static void qla27xx_process_purex_fpin(struct scsi_qla_host *vha,
		26	struct purex_item *item);
		27	static struct purex_item qla24xx_alloc_purex_item(scsi_qla_host_t vha,
		28	uint16_t size);
		29	static struct purex_item qla24xx_copy_std_pkt(struct scsi_qla_host vha,
		30	void *pkt);
		31	static struct purex_item qla27xx_copy_fpin_pkt(struct scsi_qla_host vha,
		32	void pkt, struct rsp_que rsp);
		33
		34	static void
		35	qla27xx_process_purex_fpin(struct scsi_qla_host vha, struct purex_item item)
		36	{
		37	void *pkt = &item->iocb;
		38	uint16_t pkt_size = item->size;
		39
		40	ql_dbg(ql_dbg_init + ql_dbg_verbose, vha, 0x508d,
		41	"%s: Enter\n", __func__);
		42
		43	ql_dbg(ql_dbg_init + ql_dbg_verbose, vha, 0x508e,
		44	"-------- ELS REQ -------\n");
		45	ql_dump_buffer(ql_dbg_init + ql_dbg_verbose, vha, 0x508f,
		46	pkt, pkt_size);
		47
		48	fc_host_fpin_rcv(vha->host, pkt_size, (char *)pkt);
		49	}
25		50
26	const char *const port_state_str[] = {	51	const char *const port_state_str[] = {
27	"Unknown",	52	"Unknown",
@@ -31,35 +56,11 @@ const char *const port_state_str[] = { · 3 unmodified lines
31	"ONLINE"	56	"ONLINE"
32	};	57	};
33		58
34	static void qla24xx_purex_iocb(scsi_qla_host_t vha, void pkt,
35	void (process_item)(struct scsi_qla_host vha, void *pkt))
36	{
37	struct purex_list *list = &vha->purex_list;
38	struct purex_item *item;
39	ulong flags;
40
41	item = kzalloc(sizeof(*item), GFP_KERNEL);
42	if (!item) {
43	ql_log(ql_log_warn, vha, 0x5092,
44	">> Failed allocate purex list item.\n");
45	return;
46	}
47
48	item->vha = vha;
49	item->process_item = process_item;
50	memcpy(&item->iocb, pkt, sizeof(item->iocb));
51
52	spin_lock_irqsave(&list->lock, flags);
53	list_add_tail(&item->list, &list->head);
54	spin_unlock_irqrestore(&list->lock, flags);
55
56	set_bit(PROCESS_PUREX_IOCB, &vha->dpc_flags);
57	}
58
59	static void	59	static void
60	qla24xx_process_abts(struct scsi_qla_host vha, void pkt)	60	qla24xx_process_abts(struct scsi_qla_host vha, struct purex_item pkt)
61	{	61	{
62	struct abts_entry_24xx *abts = pkt;	62	struct abts_entry_24xx *abts =
		63	(struct abts_entry_24xx *)&pkt->iocb;
63	struct qla_hw_data *ha = vha->hw;	64	struct qla_hw_data *ha = vha->hw;
64	struct els_entry_24xx *rsp_els;	65	struct els_entry_24xx *rsp_els;
65	struct abts_entry_24xx *abts_rsp;	66	struct abts_entry_24xx *abts_rsp;
@@ -789,6 +790,179 @@ qla27xx_handle_8200_aen(scsi_qla_host_t vha, uint16_t mb) · 723 unmodified lines
789	}	790	}
790	}	791	}
791		792
		793	static struct purex_item *
		794	qla24xx_alloc_purex_item(scsi_qla_host_t *vha, uint16_t size)
		795	{
		796	struct purex_item *item = NULL;
		797	uint8_t item_hdr_size = sizeof(*item);
		798
		799	if (size > QLA_DEFAULT_PAYLOAD_SIZE) {
		800	item = kzalloc(item_hdr_size +
		801	(size - QLA_DEFAULT_PAYLOAD_SIZE), GFP_ATOMIC);
		802	} else {
		803	if (atomic_inc_return(&vha->default_item.in_use) == 1) {
		804	item = &vha->default_item;
		805	goto initialize_purex_header;
		806	} else {
		807	item = kzalloc(item_hdr_size, GFP_ATOMIC);
		808	}
		809	}
		810	if (!item) {
		811	ql_log(ql_log_warn, vha, 0x5092,
		812	">> Failed allocate purex list item.\n");
		813
		814	return NULL;
		815	}
		816
		817	initialize_purex_header:
		818	item->vha = vha;
		819	item->size = size;
		820	return item;
		821	}
		822
		823	static void
		824	qla24xx_queue_purex_item(scsi_qla_host_t vha, struct purex_item pkt,
		825	void (process_item)(struct scsi_qla_host vha,
		826	struct purex_item *pkt))
		827	{
		828	struct purex_list *list = &vha->purex_list;
		829	ulong flags;
		830
		831	pkt->process_item = process_item;
		832
		833	spin_lock_irqsave(&list->lock, flags);
		834	list_add_tail(&pkt->list, &list->head);
		835	spin_unlock_irqrestore(&list->lock, flags);
		836
		837	set_bit(PROCESS_PUREX_IOCB, &vha->dpc_flags);
		838	}
		839
		840	/**
		841	* qla24xx_copy_std_pkt() - Copy over purex ELS which is
		842	* contained in a single IOCB.
		843	* purex packet.
		844	* @vha: SCSI driver HA context
		845	* @pkt: ELS packet
		846	*/
		847	static struct purex_item
		848	qla24xx_copy_std_pkt(struct scsi_qla_host vha, void *pkt)
		849	{
		850	struct purex_item *item;
		851
		852	item = qla24xx_alloc_purex_item(vha,
		853	QLA_DEFAULT_PAYLOAD_SIZE);
		854	if (!item)
		855	return item;
		856
		857	memcpy(&item->iocb, pkt, sizeof(item->iocb));
		858	return item;
		859	}
		860
		861	/**
		862	* qla27xx_copy_fpin_pkt() - Copy over fpin packets that can
		863	* span over multiple IOCBs.
		864	* @vha: SCSI driver HA context
		865	* @pkt: ELS packet
		866	* @rsp: Response queue
		867	*/
		868	static struct purex_item *
		869	qla27xx_copy_fpin_pkt(struct scsi_qla_host vha, void *pkt,
		870	struct rsp_que **rsp)
		871	{
		872	struct purex_entry_24xx purex = pkt;
		873	struct rsp_que rsp_q = rsp;
		874	sts_cont_entry_t *new_pkt;
		875	uint16_t no_bytes = 0, total_bytes = 0, pending_bytes = 0;
		876	uint16_t buffer_copy_offset = 0;
		877	uint16_t entry_count, entry_count_remaining;
		878	struct purex_item *item;
		879	void *fpin_pkt = NULL;
		880
		881	total_bytes = (le16_to_cpu(purex->frame_size) & 0x0FFF)
		882	- PURX_ELS_HEADER_SIZE;
		883	pending_bytes = total_bytes;
		884	entry_count = entry_count_remaining = purex->entry_count;
		885	no_bytes = (pending_bytes > sizeof(purex->els_frame_payload)) ?
		886	sizeof(purex->els_frame_payload) : pending_bytes;
		887	ql_log(ql_log_info, vha, 0x509a,
		888	"FPIN ELS, frame_size 0x%x, entry count %d\n",
		889	total_bytes, entry_count);
		890
		891	item = qla24xx_alloc_purex_item(vha, total_bytes);
		892	if (!item)
		893	return item;
		894
		895	fpin_pkt = &item->iocb;
		896
		897	memcpy(fpin_pkt, &purex->els_frame_payload[0], no_bytes);
		898	buffer_copy_offset += no_bytes;
		899	pending_bytes -= no_bytes;
		900	--entry_count_remaining;
		901
		902	((response_t *)purex)->signature = RESPONSE_PROCESSED;
		903	wmb();
		904
		905	do {
		906	while ((total_bytes > 0) && (entry_count_remaining > 0)) {
		907	if (rsp_q->ring_ptr->signature == RESPONSE_PROCESSED) {
		908	ql_dbg(ql_dbg_async, vha, 0x5084,
		909	"Ran out of IOCBs, partial data 0x%x\n",
		910	buffer_copy_offset);
		911	cpu_relax();
		912	continue;
		913	}
		914
		915	new_pkt = (sts_cont_entry_t *)rsp_q->ring_ptr;
		916	*pkt = new_pkt;
		917
		918	if (new_pkt->entry_type != STATUS_CONT_TYPE) {
		919	ql_log(ql_log_warn, vha, 0x507a,
		920	"Unexpected IOCB type, partial data 0x%x\n",
		921	buffer_copy_offset);
		922	break;
		923	}
		924
		925	rsp_q->ring_index++;
		926	if (rsp_q->ring_index == rsp_q->length) {
		927	rsp_q->ring_index = 0;
		928	rsp_q->ring_ptr = rsp_q->ring;
		929	} else {
		930	rsp_q->ring_ptr++;
		931	}
		932	no_bytes = (pending_bytes > sizeof(new_pkt->data)) ?
		933	sizeof(new_pkt->data) : pending_bytes;
		934	if ((buffer_copy_offset + no_bytes) <= total_bytes) {
		935	memcpy(((uint8_t *)fpin_pkt +
		936	buffer_copy_offset), new_pkt->data,
		937	no_bytes);
		938	buffer_copy_offset += no_bytes;
		939	pending_bytes -= no_bytes;
		940	--entry_count_remaining;
		941	} else {
		942	ql_log(ql_log_warn, vha, 0x5044,
		943	"Attempt to copy more that we got, optimizing..%x\n",
		944	buffer_copy_offset);
		945	memcpy(((uint8_t *)fpin_pkt +
		946	buffer_copy_offset), new_pkt->data,
		947	total_bytes - buffer_copy_offset);
		948	}
		949
		950	((response_t *)new_pkt)->signature = RESPONSE_PROCESSED;
		951	wmb();
		952	}
		953
		954	if (pending_bytes != 0 \|\| entry_count_remaining != 0) {
		955	ql_log(ql_log_fatal, vha, 0x508b,
		956	"Dropping partial FPIN, underrun bytes = 0x%x, entry cnts 0x%x\n",
		957	total_bytes, entry_count_remaining);
		958	qla24xx_free_purex_item(item);
		959	return NULL;
		960	}
		961	} while (entry_count_remaining > 0);
		962	host_to_fcp_swap((uint8_t *)&item->iocb, total_bytes);
		963	return item;
		964	}
		965
792	/**	966	/**
793	* qla2x00_async_event() - Process aynchronous events.	967	* qla2x00_async_event() - Process aynchronous events.
794	* @vha: SCSI driver HA context	968	* @vha: SCSI driver HA context
@@ -1302,6 +1476,19 @@ global_port_update: · 507 unmodified lines
1302	qla2x00_post_aen_work(vha, FCH_EVT_RSCN, rscn_entry);	1476	qla2x00_post_aen_work(vha, FCH_EVT_RSCN, rscn_entry);
1303	}	1477	}
1304	break;	1478	break;
		1479	case MBA_CONGN_NOTI_RECV:
		1480	if (!ha->flags.scm_enabled \|\|
		1481	mb[1] != QLA_CON_PRIMITIVE_RECEIVED)
		1482	break;
		1483
		1484	if (mb[2] == QLA_CONGESTION_ARB_WARNING) {
		1485	ql_dbg(ql_dbg_async, vha, 0x509b,
		1486	"Congestion Warning %04x %04x.\n", mb[1], mb[2]);
		1487	} else if (mb[2] == QLA_CONGESTION_ARB_ALARM) {
		1488	ql_log(ql_log_warn, vha, 0x509b,
		1489	"Congestion Alarm %04x %04x.\n", mb[1], mb[2]);
		1490	}
		1491	break;
1305	/* case MBA_RIO_RESPONSE: */	1492	/* case MBA_RIO_RESPONSE: */
1306	case MBA_ZIO_RESPONSE:	1493	case MBA_ZIO_RESPONSE:
1307	ql_dbg(ql_dbg_async, vha, 0x5015,	1494	ql_dbg(ql_dbg_async, vha, 0x5015,
@@ -3229,6 +3416,8 @@ void qla24xx_process_response_queue(struct scsi_qla_host *vha, · 1921 unmodified lines
3229	{	3416	{
3230	struct sts_entry_24xx *pkt;	3417	struct sts_entry_24xx *pkt;
3231	struct qla_hw_data *ha = vha->hw;	3418	struct qla_hw_data *ha = vha->hw;
		3419	struct purex_entry_24xx *purex_entry;
		3420	struct purex_item *pure_item;
3232		3421
3233	if (!ha->flags.fw_started)	3422	if (!ha->flags.fw_started)
3234	return;	3423	return;
@@ -3280,8 +3469,11 @@ process_err: · 45 unmodified lines
3280	break;	3469	break;
3281	case ABTS_RECV_24XX:	3470	case ABTS_RECV_24XX:
3282	if (qla_ini_mode_enabled(vha)) {	3471	if (qla_ini_mode_enabled(vha)) {
3283	qla24xx_purex_iocb(vha, pkt,	3472	pure_item = qla24xx_copy_std_pkt(vha, pkt);
3284	qla24xx_process_abts);	3473	if (!pure_item)
		3474	break;
		3475	qla24xx_queue_purex_item(vha, pure_item,
		3476	qla24xx_process_abts);
3285	break;	3477	break;
3286	}	3478	}
3287	if (IS_QLA83XX(ha) \|\| IS_QLA27XX(ha) \|\|	3479	if (IS_QLA83XX(ha) \|\| IS_QLA27XX(ha) \|\|
@@ -3329,24 +3521,40 @@ process_err: · 41 unmodified lines
3329	(struct vp_ctrl_entry_24xx *)pkt);	3521	(struct vp_ctrl_entry_24xx *)pkt);
3330	break;	3522	break;
3331	case PUREX_IOCB_TYPE:	3523	case PUREX_IOCB_TYPE:
3332	{	3524	purex_entry = (void *)pkt;
3333	struct purex_entry_24xx purex = (void )pkt;	3525	switch (purex_entry->els_frame_payload[3]) {
3334		3526	case ELS_RDP:
3335	if (purex->els_frame_payload[3] != ELS_COMMAND_RDP) {	3527	pure_item = qla24xx_copy_std_pkt(vha, pkt);
3336	ql_dbg(ql_dbg_init, vha, 0x5091,	3528	if (!pure_item)
3337	"Discarding ELS Request opcode %#x...\n",	3529	break;
3338	purex->els_frame_payload[3]);	3530	qla24xx_queue_purex_item(vha, pure_item,
		3531	qla24xx_process_purex_rdp);
		3532	break;
		3533	case ELS_FPIN:
		3534	if (!vha->hw->flags.scm_enabled) {
		3535	ql_log(ql_log_warn, vha, 0x5094,
		3536	"SCM not active for this port\n");
		3537	break;
		3538	}
		3539	pure_item = qla27xx_copy_fpin_pkt(vha,
		3540	(void **)&pkt, &rsp);
		3541	if (!pure_item)
		3542	break;
		3543	qla24xx_queue_purex_item(vha, pure_item,
		3544	qla27xx_process_purex_fpin);
3339	break;	3545	break;
		3546
		3547	default:
		3548	ql_log(ql_log_warn, vha, 0x509c,
		3549	"Discarding ELS Request opcode 0x%x\n",
		3550	purex_entry->els_frame_payload[3]);
3340	}	3551	}
3341	qla24xx_purex_iocb(vha, pkt, qla24xx_process_purex_rdp);
3342	break;	3552	break;
3343	}
3344	default:	3553	default:
3345	/* Type Not Supported. */	3554	/* Type Not Supported. */
3346	ql_dbg(ql_dbg_async, vha, 0x5042,	3555	ql_dbg(ql_dbg_async, vha, 0x5042,
3347	"Received unknown response pkt type %x "	3556	"Received unknown response pkt type 0x%x entry status=%x.\n",
3348	"entry status=%x.\n",	3557	pkt->entry_type, pkt->entry_status);
3349	pkt->entry_type, pkt->entry_status);
3350	break;	3558	break;
3351	}	3559	}
3352	((response_t *)pkt)->signature = RESPONSE_PROCESSED;	3560	((response_t *)pkt)->signature = RESPONSE_PROCESSED;

drivers/scsi/qla2xxx/qla_mbx.c+57−7

 	{ MBC_IOCB_COMMAND_A64 },
 	{ MBC_GET_ADAPTER_LOOP_ID },
 	{ MBC_READ_SFP },
+	{ MBC_SET_RNID_PARAMS },
 	{ MBC_GET_RNID_PARAMS },
 	{ MBC_GET_SET_ZIO_THRESHOLD },
 };
 			    (ha->flags.secure_fw) ? "Supported" :
 			    "Not Supported");
 		}
+		if (ha->flags.scm_supported_a &&
+		    (ha->fw_attributes_ext[0] & FW_ATTR_EXT0_SCM_SUPPORTED)) {
+			ha->flags.scm_supported_f = 1;
+			memset(ha->sf_init_cb, 0, sizeof(struct init_sf_cb));
+			ha->sf_init_cb->flags |= BIT_13;
+		}
+		ql_log(ql_log_info, vha, 0x11a3, "SCM in FW: %s\n",
+		       (ha->flags.scm_supported_f) ? "Supported" :
+		       "Not Supported");
 	}
 failed:
 		mcp->in_mb |= MBX_13|MBX_12|MBX_11|MBX_10;
 	if (IS_FWI2_CAPABLE(vha->hw))
 		mcp->in_mb |= MBX_19|MBX_18|MBX_17|MBX_16;
-	if (IS_QLA27XX(vha->hw) || IS_QLA28XX(vha->hw))
+	if (IS_QLA27XX(vha->hw) || IS_QLA28XX(vha->hw)) {
 		mcp->in_mb |= MBX_15;
+		mcp->out_mb |= MBX_7|MBX_21|MBX_22|MBX_23;
+	}
 	mcp->tov = MBX_TOV_SECONDS;
 	mcp->flags = 0;
 	rval = qla2x00_mailbox_command(vha, mcp);
 			}
 		}
-		if (IS_QLA27XX(vha->hw) || IS_QLA28XX(vha->hw))
+		if (IS_QLA27XX(vha->hw) || IS_QLA28XX(vha->hw)) {
 			vha->bbcr = mcp->mb[15];
+			if (mcp->mb[7] & SCM_EDC_ACC_RECEIVED) {
+				ql_log(ql_log_info, vha, 0x11a4,
+				       "SCM: EDC ELS completed, flags 0x%x\n",
+				       mcp->mb[21]);
+			}
+			if (mcp->mb[7] & SCM_RDF_ACC_RECEIVED) {
+				vha->hw->flags.scm_enabled = 1;
+				vha->scm_fabric_connection_flags |=
+				    SCM_FLAG_RDF_COMPLETED;
+				ql_log(ql_log_info, vha, 0x11a5,
+				       "SCM: RDF ELS completed, flags 0x%x\n",
+				       mcp->mb[23]);
+			}
+		}
 	}
 	return rval;
 		mcp->mb[14] = sizeof(*ha->ex_init_cb);
 		mcp->out_mb |= MBX_14|MBX_13|MBX_12|MBX_11|MBX_10;
 	}
+	if (ha->flags.scm_supported_f) {
+		mcp->mb[1] |= BIT_1;
+		mcp->mb[16] = MSW(ha->sf_init_cb_dma);
+		mcp->mb[17] = LSW(ha->sf_init_cb_dma);
+		mcp->mb[18] = MSW(MSD(ha->sf_init_cb_dma));
+		mcp->mb[19] = LSW(MSD(ha->sf_init_cb_dma));
+		mcp->mb[15] = sizeof(*ha->sf_init_cb);
+		mcp->out_mb |= MBX_19|MBX_18|MBX_17|MBX_16|MBX_15;
+	}
 	/* 1 and 2 should normally be captured. */
 	mcp->in_mb = MBX_2|MBX_1|MBX_0;
 	if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha))
 	return rval;
 }
+#define PUREX_CMD_COUNT	2
 int
 qla25xx_set_els_cmds_supported(scsi_qla_host_t *vha)
 {
 	mbx_cmd_t *mcp = &mc;
 	uint8_t *els_cmd_map;
 	dma_addr_t els_cmd_map_dma;
-	uint cmd_opcode = ELS_COMMAND_RDP;
+	uint8_t cmd_opcode[PUREX_CMD_COUNT];
-	uint index = cmd_opcode / 8;
+	uint8_t i, index, purex_bit;
-	uint bit = cmd_opcode % 8;
 	struct qla_hw_data *ha = vha->hw;
-	if (!IS_QLA25XX(ha) && !IS_QLA2031(ha) && !IS_QLA27XX(ha))
+	if (!IS_QLA25XX(ha) && !IS_QLA2031(ha) &&
+	    !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
 		return QLA_SUCCESS;
 	ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1197,
 		return QLA_MEMORY_ALLOC_FAILED;
 	}
-	els_cmd_map[index] |= 1 << bit;
+	memset(els_cmd_map, 0, ELS_CMD_MAP_SIZE);
+	/* List of Purex ELS */
+	cmd_opcode[0] = ELS_FPIN;
+	cmd_opcode[1] = ELS_RDP;
+	for (i = 0; i < PUREX_CMD_COUNT; i++) {
+		index = cmd_opcode[i] / 8;
+		purex_bit = cmd_opcode[i] % 8;
+		els_cmd_map[index] |= 1 << purex_bit;
+	}
 	mcp->mb[0] = MBC_SET_RNID_PARAMS;
 	mcp->mb[1] = RNID_TYPE_ELS_CMD << 8;

drivers/scsi/qla2xxx/qla_nx.c+8−12

 static int
 qla82xx_flash_wait_write_finish(struct qla_hw_data *ha)
 {
-	long timeout = 0;
-	uint32_t done = 1 ;
 	uint32_t val;
-	int ret = 0;
+	int i, ret;
 	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 	qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_ABYTE_CNT, 0);
-	while ((done != 0) && (ret == 0)) {
+	for (i = 0; i < 50000; i++) {
 		ret = qla82xx_read_status_reg(ha, &val);
-		done = val & 1;
+		if (ret < 0 || (val & 1) == 0)
-		timeout++;
+			return ret;
 		udelay(10);
 		cond_resched();
-		if (timeout >= 50000) {
-			ql_log(ql_log_warn, vha, 0xb00d,
-			    "Timeout reached waiting for write finish.\n");
-			return -1;
-		}
 	}
-	return ret;
+	ql_log(ql_log_warn, vha, 0xb00d,
+	       "Timeout reached waiting for write finish.\n");
+	return -1;
 }
 static int
 	 * Offset 4: Offset and number of addr/value pairs
 	 * that present in CRB initialize sequence
 	 */
+	n = 0;
 	if (qla82xx_rom_fast_read(ha, 0, &n) != 0 || n != 0xcafecafeUL ||
 	    qla82xx_rom_fast_read(ha, 4, &n) != 0) {
 		ql_log(ql_log_fatal, vha, 0x006e,

drivers/scsi/qla2xxx/qla_os.c+33−4

 		    "ex_init_cb=%p.\n", ha->ex_init_cb);
 	}
+	/* Get consistent memory allocated for Special Features-CB. */
+	if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
+		ha->sf_init_cb = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
+						&ha->sf_init_cb_dma);
+		if (!ha->sf_init_cb)
+			goto fail_sf_init_cb;
+		ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0199,
+			   "sf_init_cb=%p.\n", ha->sf_init_cb);
+	}
 	INIT_LIST_HEAD(&ha->gbl_dsd_list);
 	/* Get consistent memory allocated for Async Port-Database. */
 fail_loop_id_map:
 	dma_pool_free(ha->s_dma_pool, ha->async_pd, ha->async_pd_dma);
 fail_async_pd:
+	dma_pool_free(ha->s_dma_pool, ha->sf_init_cb, ha->sf_init_cb_dma);
+fail_sf_init_cb:
 	dma_pool_free(ha->s_dma_pool, ha->ex_init_cb, ha->ex_init_cb_dma);
 fail_ex_init_cb:
 	kfree(ha->npiv_info);
 	ha->ms_iocb = NULL;
 	ha->ms_iocb_dma = 0;
+	if (ha->sf_init_cb)
+		dma_pool_free(ha->s_dma_pool,
+			      ha->sf_init_cb, ha->sf_init_cb_dma);
 	if (ha->ex_init_cb)
 		dma_pool_free(ha->s_dma_pool,
 			ha->ex_init_cb, ha->ex_init_cb_dma);
 	kfree(ha->swl);
 	ha->swl = NULL;
 	kfree(ha->loop_id_map);
+	ha->sf_init_cb = NULL;
+	ha->sf_init_cb_dma = 0;
 	ha->loop_id_map = NULL;
 }
  * vha:	SCSI qla host
  * purex: RDP request received by HBA
  */
-void qla24xx_process_purex_rdp(struct scsi_qla_host *vha, void *pkt)
+void qla24xx_process_purex_rdp(struct scsi_qla_host *vha,
+			       struct purex_item *item)
 {
 	struct qla_hw_data *ha = vha->hw;
-	struct purex_entry_24xx *purex = pkt;
+	struct purex_entry_24xx *purex =
+	    (struct purex_entry_24xx *)&item->iocb;
 	dma_addr_t rsp_els_dma;
 	dma_addr_t rsp_payload_dma;
 	dma_addr_t stat_dma;
 		    rsp_els, rsp_els_dma);
 }
+void
+qla24xx_free_purex_item(struct purex_item *item)
+{
+	if (item == &item->vha->default_item)
+		memset(&item->vha->default_item, 0, sizeof(struct purex_item));
+	else
+		kfree(item);
+}
 void qla24xx_process_purex_list(struct purex_list *list)
 {
 	struct list_head head = LIST_HEAD_INIT(head);
 	list_for_each_entry_safe(item, next, &head, list) {
 		list_del(&item->list);
-		item->process_item(item->vha, &item->iocb);
+		item->process_item(item->vha, item);
-		kfree(item);
+		qla24xx_free_purex_item(item);
 	}
 }

drivers/scsi/qla2xxx/qla_target.h+2−2

@@ -258,7 +258,7 @@ struct fcp_hdr { · 257 unmodified lines
258	__be16 ox_id;	258	__be16 ox_id;
259	uint16_t rx_id;	259	uint16_t rx_id;
260	__le32 parameter;	260	__le32 parameter;
261	} __packed;	261	};
262		262
263	struct fcp_hdr_le {	263	struct fcp_hdr_le {
264	le_id_t d_id;	264	le_id_t d_id;
@@ -273,7 +273,7 @@ struct fcp_hdr_le { · 8 unmodified lines
273	__le16 rx_id;	273	__le16 rx_id;
274	__le16 ox_id;	274	__le16 ox_id;
275	__le32 parameter;	275	__le32 parameter;
276	} __packed;	276	};
277		277
278	#define F_CTL_EXCH_CONTEXT_RESP BIT_23	278	#define F_CTL_EXCH_CONTEXT_RESP BIT_23
279	#define F_CTL_SEQ_CONTEXT_RESIP BIT_22	279	#define F_CTL_SEQ_CONTEXT_RESIP BIT_22

drivers/scsi/qla2xxx/tcm_qla2xxx.c+1−0

@@ -1971,6 +1971,7 @@ static int __init tcm_qla2xxx_init(void) · 1970 unmodified lines
1971	BUILD_BUG_ON(sizeof(struct ctio_crc2_to_fw) != 64);	1971	BUILD_BUG_ON(sizeof(struct ctio_crc2_to_fw) != 64);
1972	BUILD_BUG_ON(sizeof(struct ctio_crc_from_fw) != 64);	1972	BUILD_BUG_ON(sizeof(struct ctio_crc_from_fw) != 64);
1973	BUILD_BUG_ON(sizeof(struct ctio_to_2xxx) != 64);	1973	BUILD_BUG_ON(sizeof(struct ctio_to_2xxx) != 64);
		1974	BUILD_BUG_ON(sizeof(struct fcp_hdr) != 24);
1974	BUILD_BUG_ON(sizeof(struct fcp_hdr_le) != 24);	1975	BUILD_BUG_ON(sizeof(struct fcp_hdr_le) != 24);
1975	BUILD_BUG_ON(sizeof(struct nack_to_isp) != 64);	1976	BUILD_BUG_ON(sizeof(struct nack_to_isp) != 64);
1976		1977

drivers/scsi/qla4xxx/ql4_83xx.c+12−22

 static void qla4_83xx_dump_pause_control_regs(struct scsi_qla_host *ha)
 {
 	u32 val = 0, val1 = 0;
-	int i, status = QLA_SUCCESS;
+	int i;
-	status = qla4_83xx_rd_reg_indirect(ha, QLA83XX_SRE_SHIM_CONTROL, &val);
+	qla4_83xx_rd_reg_indirect(ha, QLA83XX_SRE_SHIM_CONTROL, &val);
 	DEBUG2(ql4_printk(KERN_INFO, ha, "SRE-Shim Ctrl:0x%x\n", val));
 	/* Port 0 Rx Buffer Pause Threshold Registers. */
 	DEBUG2(ql4_printk(KERN_INFO, ha,
 		"Port 0 Rx Buffer Pause Threshold Registers[TC7..TC0]:"));
 	for (i = 0; i < 8; i++) {
-		status = qla4_83xx_rd_reg_indirect(ha,
+		qla4_83xx_rd_reg_indirect(ha,
 				QLA83XX_PORT0_RXB_PAUSE_THRS + (i * 0x4), &val);
 		DEBUG2(pr_info("0x%x ", val));
 	}
 	DEBUG2(ql4_printk(KERN_INFO, ha,
 		"Port 1 Rx Buffer Pause Threshold Registers[TC7..TC0]:"));
 	for (i = 0; i < 8; i++) {
-		status = qla4_83xx_rd_reg_indirect(ha,
+		qla4_83xx_rd_reg_indirect(ha,
 				QLA83XX_PORT1_RXB_PAUSE_THRS + (i * 0x4), &val);
 		DEBUG2(pr_info("0x%x  ", val));
 	}
 	DEBUG2(ql4_printk(KERN_INFO, ha,
 		"Port 0 RxB Traffic Class Max Cell Registers[3..0]:"));
 	for (i = 0; i < 4; i++) {
-		status = qla4_83xx_rd_reg_indirect(ha,
+		qla4_83xx_rd_reg_indirect(ha,
 			       QLA83XX_PORT0_RXB_TC_MAX_CELL + (i * 0x4), &val);
 		DEBUG2(pr_info("0x%x  ", val));
 	}
 	DEBUG2(ql4_printk(KERN_INFO, ha,
 		"Port 1 RxB Traffic Class Max Cell Registers[3..0]:"));
 	for (i = 0; i < 4; i++) {
-		status = qla4_83xx_rd_reg_indirect(ha,
+		qla4_83xx_rd_reg_indirect(ha,
 			       QLA83XX_PORT1_RXB_TC_MAX_CELL + (i * 0x4), &val);
 		DEBUG2(pr_info("0x%x  ", val));
 	}
 	DEBUG2(ql4_printk(KERN_INFO, ha,
 			  "Port 0 RxB Rx Traffic Class Stats [TC7..TC0]"));
 	for (i = 7; i >= 0; i--) {
-		status = qla4_83xx_rd_reg_indirect(ha,
+		qla4_83xx_rd_reg_indirect(ha, QLA83XX_PORT0_RXB_TC_STATS, &val);
-						   QLA83XX_PORT0_RXB_TC_STATS,
-						   &val);
 		val &= ~(0x7 << 29);    /* Reset bits 29 to 31 */
 		qla4_83xx_wr_reg_indirect(ha, QLA83XX_PORT0_RXB_TC_STATS,
 					  (val | (i << 29)));
-		status = qla4_83xx_rd_reg_indirect(ha,
+		qla4_83xx_rd_reg_indirect(ha, QLA83XX_PORT0_RXB_TC_STATS, &val);
-						   QLA83XX_PORT0_RXB_TC_STATS,
-						   &val);
 		DEBUG2(pr_info("0x%x  ", val));
 	}
 	DEBUG2(ql4_printk(KERN_INFO, ha,
 			  "Port 1 RxB Rx Traffic Class Stats [TC7..TC0]"));
 	for (i = 7; i >= 0; i--) {
-		status = qla4_83xx_rd_reg_indirect(ha,
+		qla4_83xx_rd_reg_indirect(ha, QLA83XX_PORT1_RXB_TC_STATS, &val);
-						   QLA83XX_PORT1_RXB_TC_STATS,
-						   &val);
 		val &= ~(0x7 << 29);    /* Reset bits 29 to 31 */
 		qla4_83xx_wr_reg_indirect(ha, QLA83XX_PORT1_RXB_TC_STATS,
 					  (val | (i << 29)));
-		status = qla4_83xx_rd_reg_indirect(ha,
+		qla4_83xx_rd_reg_indirect(ha, QLA83XX_PORT1_RXB_TC_STATS, &val);
-						   QLA83XX_PORT1_RXB_TC_STATS,
-						   &val);
 		DEBUG2(pr_info("0x%x  ", val));
 	}
 	DEBUG2(pr_info("\n"));
-	status = qla4_83xx_rd_reg_indirect(ha, QLA83XX_PORT2_IFB_PAUSE_THRS,
+	qla4_83xx_rd_reg_indirect(ha, QLA83XX_PORT2_IFB_PAUSE_THRS, &val);
-					   &val);
+	qla4_83xx_rd_reg_indirect(ha, QLA83XX_PORT3_IFB_PAUSE_THRS, &val1);
-	status = qla4_83xx_rd_reg_indirect(ha, QLA83XX_PORT3_IFB_PAUSE_THRS,
-					   &val1);
 	DEBUG2(ql4_printk(KERN_INFO, ha,
 			  "IFB-Pause Thresholds: Port 2:0x%x, Port 3:0x%x\n",

drivers/scsi/qla4xxx/ql4_83xx.h+0−17

@@ -87,23 +87,6 @@ · 86 unmodified lines
87	#define QLA83XX_FW_API 0x356C	87	#define QLA83XX_FW_API 0x356C
88	#define QLA83XX_DRV_OP_MODE 0x3570	88	#define QLA83XX_DRV_OP_MODE 0x3570
89		89
90	static const uint32_t qla4_83xx_reg_tbl[] = {
91	QLA83XX_PEG_HALT_STATUS1,
92	QLA83XX_PEG_HALT_STATUS2,
93	QLA83XX_PEG_ALIVE_COUNTER,
94	QLA83XX_CRB_DRV_ACTIVE,
95	QLA83XX_CRB_DEV_STATE,
96	QLA83XX_CRB_DRV_STATE,
97	QLA83XX_CRB_DRV_SCRATCH,
98	QLA83XX_CRB_DEV_PART_INFO1,
99	QLA83XX_CRB_IDC_VER_MAJOR,
100	QLA83XX_FW_VER_MAJOR,
101	QLA83XX_FW_VER_MINOR,
102	QLA83XX_FW_VER_SUB,
103	QLA83XX_CMDPEG_STATE,
104	QLA83XX_ASIC_TEMP,
105	};
106
107	#define QLA83XX_CRB_WIN_BASE 0x3800	90	#define QLA83XX_CRB_WIN_BASE 0x3800
108	#define QLA83XX_CRB_WIN_FUNC(f) (QLA83XX_CRB_WIN_BASE+((f)*4))	91	#define QLA83XX_CRB_WIN_FUNC(f) (QLA83XX_CRB_WIN_BASE+((f)*4))
109	#define QLA83XX_SEM_LOCK_BASE 0x3840	92	#define QLA83XX_SEM_LOCK_BASE 0x3840

drivers/scsi/qla4xxx/ql4_bsg.c+2−2

@@ -805,7 +805,7 @@ static int qla4xxx_execute_diag_test(struct bsg_job *bsg_job) · 804 unmodified lines
805		805
806	/**	806	/**
807	* qla4xxx_process_vendor_specific - handle vendor specific bsg request	807	* qla4xxx_process_vendor_specific - handle vendor specific bsg request
808	* @job: iscsi_bsg_job to handle	808	* @bsg_job: iscsi_bsg_job to handle
809	**/	809	**/
810	int qla4xxx_process_vendor_specific(struct bsg_job *bsg_job)	810	int qla4xxx_process_vendor_specific(struct bsg_job *bsg_job)
811	{	811	{
@@ -852,7 +852,7 @@ int qla4xxx_process_vendor_specific(struct bsg_job *bsg_job) · 40 unmodified lines
852		852
853	/**	853	/**
854	* qla4xxx_bsg_request - handle bsg request from ISCSI transport	854	* qla4xxx_bsg_request - handle bsg request from ISCSI transport
855	* @job: iscsi_bsg_job to handle	855	* @bsg_job: iscsi_bsg_job to handle
856	*/	856	*/
857	int qla4xxx_bsg_request(struct bsg_job *bsg_job)	857	int qla4xxx_bsg_request(struct bsg_job *bsg_job)
858	{	858	{

drivers/scsi/qla4xxx/ql4_init.c+8−5

 static void ql4xxx_set_mac_number(struct scsi_qla_host *ha)
 {
 	uint32_t value;
-	uint8_t func_number;
 	unsigned long flags;
 	/* Get the function number */
 	value = readw(&ha->reg->ctrl_status);
 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
-	func_number = (uint8_t) ((value >> 4) & 0x30);
 	switch (value & ISP_CONTROL_FN_MASK) {
 	case ISP_CONTROL_FN0_SCSI:
 		ha->mac_index = 1;
 	pci_set_master(ha->pdev);
 	status = pci_set_mwi(ha->pdev);
+	if (status)
+		ql4_printk(KERN_WARNING, ha, "Failed to set MWI\n");
 	/*
 	 * We want to respect framework's setting of PCI configuration space
 	 * command register and also want to make sure that all bits of
 /**
  * qla4xxx_initialize_adapter - initiailizes hba
  * @ha: Pointer to host adapter structure.
+ * @is_reset: Is this init path or reset path
  *
  * This routine parforms all of the steps necessary to initialize the adapter.
  *
 /**
  * qla4xxx_process_ddb_changed - process ddb state change
- * @ha - Pointer to host adapter structure.
+ * @ha: Pointer to host adapter structure.
- * @fw_ddb_index - Firmware's device database index
+ * @fw_ddb_index: Firmware's device database index
- * @state - Device state
+ * @state: Device state
+ * @conn_err: Unused
  *
  * This routine processes a Decive Database Changed AEN Event.
  **/

drivers/scsi/qla4xxx/ql4_iocb.c+1−1

@@ -78,7 +78,7 @@ static int qla4xxx_get_req_pkt(struct scsi_qla_host *ha, · 77 unmodified lines
78	* @ha: Pointer to host adapter structure.	78	* @ha: Pointer to host adapter structure.
79	* @ddb_entry: Pointer to device database entry	79	* @ddb_entry: Pointer to device database entry
80	* @lun: SCSI LUN	80	* @lun: SCSI LUN
81	* @marker_type: marker identifier	81	* @mrkr_mod: marker identifier
82	*	82	*
83	* This routine issues a marker IOCB.	83	* This routine issues a marker IOCB.
84	**/	84	**/

drivers/scsi/qla4xxx/ql4_isr.c+4−2

 /**
  * qla4_83xx_loopback_in_progress: Is loopback in progress?
  * @ha: Pointer to host adapter structure.
- * @ret: 1 = loopback in progress, 0 = loopback not in progress
+ * returns: 1 = loopback in progress, 0 = loopback not in progress
  **/
 static int qla4_83xx_loopback_in_progress(struct scsi_qla_host *ha)
 {
 /**
  * qla4xxx_isr_decode_mailbox - decodes mailbox status
  * @ha: Pointer to host adapter structure.
- * @mailbox_status: Mailbox status.
+ * @mbox_status: Mailbox status.
  *
  * This routine decodes the mailbox status during the ISR.
  * Hardware_lock locked upon entry. runs in interrupt context.
 /**
  * qla4_82xx_interrupt_service_routine - isr
  * @ha: pointer to host adapter structure.
+ * @intr_status: Local interrupt status/type.
  *
  * This is the main interrupt service routine.
  * hardware_lock locked upon entry. runs in interrupt context.
 /**
  * qla4xxx_interrupt_service_routine - isr
  * @ha: pointer to host adapter structure.
+ * @intr_status: Local interrupt status/type.
  *
  * This is the main interrupt service routine.
  * hardware_lock locked upon entry. runs in interrupt context.

drivers/scsi/qla4xxx/ql4_mbx.c+3−4

 /**
  * qla4xxx_is_intr_poll_mode – Are we allowed to poll for interrupts?
  * @ha: Pointer to host adapter structure.
- * @ret: 1=polling mode, 0=non-polling mode
+ * returns: 1=polling mode, 0=non-polling mode
  **/
 static int qla4xxx_is_intr_poll_mode(struct scsi_qla_host *ha)
 {
 	return QLA_SUCCESS;
 }
-/**
+/*
  * qla4xxx_get_fwddb_entry - retrieves firmware ddb entry
  * @ha: Pointer to host adapter structure.
  * @fw_ddb_index: Firmware's device database index
 /**
  * qla4xxx_reset_target - issues target Reset
  * @ha: Pointer to host adapter structure.
- * @db_entry: Pointer to device database entry
+ * @ddb_entry: Pointer to device database entry
- * @un_entry: Pointer to lun entry structure
  *
  * This routine performs a TARGET RESET on the specified target.
  * The caller must ensure that the ddb_entry pointers

drivers/scsi/qla4xxx/ql4_nx.c+8−10

 	return ret;
 }
-/**
+/*
  * This routine does CRB initialize sequence
  * to put the ISP into operational state
- **/
+ */
 static int
 qla4_82xx_pinit_from_rom(struct scsi_qla_host *ha, int verbose)
 {
 	uint32_t addr1, addr2, value, data, temp, wrval;
 	uint8_t stride, stride2;
 	uint16_t count;
-	uint32_t poll, mask, data_size, modify_mask;
+	uint32_t poll, mask, modify_mask;
 	uint32_t wait_count = 0;
 	uint32_t *data_ptr = *d_ptr;
 	struct qla8044_minidump_entry_rddfe *rddfe;
 	poll = le32_to_cpu(rddfe->poll);
 	mask = le32_to_cpu(rddfe->mask);
 	modify_mask = le32_to_cpu(rddfe->modify_mask);
-	data_size = le32_to_cpu(rddfe->data_size);
 	addr2 = addr1 + stride;
 	uint8_t stride1, stride2;
 	uint32_t addr3, addr4, addr5, addr6, addr7;
 	uint16_t count, loop_cnt;
-	uint32_t poll, mask;
+	uint32_t mask;
 	uint32_t *data_ptr = *d_ptr;
 	struct qla8044_minidump_entry_rdmdio *rdmdio;
 	stride2 = le32_to_cpu(rdmdio->stride_2);
 	count = le32_to_cpu(rdmdio->count);
-	poll = le32_to_cpu(rdmdio->poll);
 	mask = le32_to_cpu(rdmdio->mask);
 	value2 = le32_to_cpu(rdmdio->value_2);
 				struct qla8xxx_minidump_entry_hdr *entry_hdr,
 				uint32_t **d_ptr)
 {
-	uint32_t addr1, addr2, value1, value2, poll, mask, r_value;
+	uint32_t addr1, addr2, value1, value2, poll, r_value;
 	struct qla8044_minidump_entry_pollwr *pollwr_hdr;
 	uint32_t wait_count = 0;
 	uint32_t rval = QLA_SUCCESS;
 	value2 = le32_to_cpu(pollwr_hdr->value_2);
 	poll = le32_to_cpu(pollwr_hdr->poll);
-	mask = le32_to_cpu(pollwr_hdr->mask);
 	while (wait_count < poll) {
 		ha->isp_ops->rd_reg_indirect(ha, addr1, &r_value);
 /**
  * qla4_8xxx_uevent_emit - Send uevent when the firmware dump is ready.
  * @ha: pointer to adapter structure
+ * @code: uevent code to act upon
  **/
 static void qla4_8xxx_uevent_emit(struct scsi_qla_host *ha, u32 code)
 {
 	return dwptr;
 }
-/**
+/*
  * Address and length are byte address
- **/
+ */
 static uint8_t *
 qla4_82xx_read_optrom_data(struct scsi_qla_host *ha, uint8_t *buf,
 		uint32_t offset, uint32_t length)

drivers/scsi/qla4xxx/ql4_nx.h+0−17

@@ -599,23 +599,6 @@ enum qla_regs { · 598 unmodified lines
599	QLA8XXX_CRB_TEMP_STATE,	599	QLA8XXX_CRB_TEMP_STATE,
600	};	600	};
601		601
602	static const uint32_t qla4_82xx_reg_tbl[] = {
603	QLA82XX_PEG_HALT_STATUS1,
604	QLA82XX_PEG_HALT_STATUS2,
605	QLA82XX_PEG_ALIVE_COUNTER,
606	QLA82XX_CRB_DRV_ACTIVE,
607	QLA82XX_CRB_DEV_STATE,
608	QLA82XX_CRB_DRV_STATE,
609	QLA82XX_CRB_DRV_SCRATCH,
610	QLA82XX_CRB_DEV_PART_INFO,
611	QLA82XX_CRB_DRV_IDC_VERSION,
612	QLA82XX_FW_VERSION_MAJOR,
613	QLA82XX_FW_VERSION_MINOR,
614	QLA82XX_FW_VERSION_SUB,
615	CRB_CMDPEG_STATE,
616	CRB_TEMP_STATE,
617	};
618
619	/* Every driver should use these Device State */	602	/* Every driver should use these Device State */
620	#define QLA8XXX_DEV_COLD 1	603	#define QLA8XXX_DEV_COLD 1
621	#define QLA8XXX_DEV_INITIALIZING 2	604	#define QLA8XXX_DEV_INITIALIZING 2

drivers/scsi/qla4xxx/ql4_os.c+42−16

 static struct qla4_8xxx_legacy_intr_set legacy_intr[] =
     QLA82XX_LEGACY_INTR_CONFIG;
+static const uint32_t qla4_82xx_reg_tbl[] = {
+	QLA82XX_PEG_HALT_STATUS1,
+	QLA82XX_PEG_HALT_STATUS2,
+	QLA82XX_PEG_ALIVE_COUNTER,
+	QLA82XX_CRB_DRV_ACTIVE,
+	QLA82XX_CRB_DEV_STATE,
+	QLA82XX_CRB_DRV_STATE,
+	QLA82XX_CRB_DRV_SCRATCH,
+	QLA82XX_CRB_DEV_PART_INFO,
+	QLA82XX_CRB_DRV_IDC_VERSION,
+	QLA82XX_FW_VERSION_MAJOR,
+	QLA82XX_FW_VERSION_MINOR,
+	QLA82XX_FW_VERSION_SUB,
+	CRB_CMDPEG_STATE,
+	CRB_TEMP_STATE,
+};
+static const uint32_t qla4_83xx_reg_tbl[] = {
+	QLA83XX_PEG_HALT_STATUS1,
+	QLA83XX_PEG_HALT_STATUS2,
+	QLA83XX_PEG_ALIVE_COUNTER,
+	QLA83XX_CRB_DRV_ACTIVE,
+	QLA83XX_CRB_DEV_STATE,
+	QLA83XX_CRB_DRV_STATE,
+	QLA83XX_CRB_DRV_SCRATCH,
+	QLA83XX_CRB_DEV_PART_INFO1,
+	QLA83XX_CRB_IDC_VER_MAJOR,
+	QLA83XX_FW_VER_MAJOR,
+	QLA83XX_FW_VER_MINOR,
+	QLA83XX_FW_VER_SUB,
+	QLA83XX_CMDPEG_STATE,
+	QLA83XX_ASIC_TEMP,
+};
 static struct scsi_host_template qla4xxx_driver_template = {
 	.module			= THIS_MODULE,
 	.name			= DRIVER_NAME,
 static enum blk_eh_timer_return qla4xxx_eh_cmd_timed_out(struct scsi_cmnd *sc)
 {
 	struct iscsi_cls_session *session;
-	struct iscsi_session *sess;
 	unsigned long flags;
 	enum blk_eh_timer_return ret = BLK_EH_DONE;
 	session = starget_to_session(scsi_target(sc->device));
-	sess = session->dd_data;
 	spin_lock_irqsave(&session->lock, flags);
 	if (session->state == ISCSI_SESSION_FAILED)
 	struct ddb_entry *ddb_entry;
 	uint16_t ddb_index;
 	struct iscsi_session *sess;
-	struct sockaddr *dst_addr;
 	int ret;
 	if (!ep) {
 	}
 	qla_ep = ep->dd_data;
-	dst_addr = (struct sockaddr *)&qla_ep->dst_addr;
 	ha = to_qla_host(qla_ep->host);
 	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: host: %ld\n", __func__,
 			  ha->host_no));
 /**
  * qla4xxx_timer - checks every second for work to do.
- * @ha: Pointer to host adapter structure.
+ * @t: Context to obtain pointer to host adapter structure.
  **/
 static void qla4xxx_timer(struct timer_list *t)
 {
 /**
  * qla4xxx_do_dpc - dpc routine
- * @data: in our case pointer to adapter structure
+ * @work: Context to obtain pointer to host adapter structure.
  *
  * This routine is a task that is schedule by the interrupt handler
  * to perform the background processing for interrupts.  We put it
 int qla4_8xxx_iospace_config(struct scsi_qla_host *ha)
 {
 	int status = 0;
-	unsigned long mem_base, mem_len, db_base, db_len;
+	unsigned long mem_base, mem_len;
 	struct pci_dev *pdev = ha->pdev;
 	status = pci_request_regions(pdev, DRIVER_NAME);
 				    ((uint8_t *)ha->nx_pcibase);
 	}
-	db_base = pci_resource_start(pdev, 4);  /* doorbell is on bar 4 */
-	db_len = pci_resource_len(pdev, 4);
 	return 0;
 iospace_error_exit:
 	return -ENOMEM;
 static void qla4xxx_get_param_ddb(struct ddb_entry *ddb_entry,
 				  struct ql4_tuple_ddb *tddb)
 {
-	struct scsi_qla_host *ha;
 	struct iscsi_cls_session *cls_sess;
 	struct iscsi_cls_conn *cls_conn;
 	struct iscsi_session *sess;
 	struct iscsi_conn *conn;
 	DEBUG2(printk(KERN_INFO "Func: %s\n", __func__));
-	ha = ddb_entry->ha;
 	cls_sess = ddb_entry->sess;
 	sess = cls_sess->dd_data;
 	cls_conn = ddb_entry->conn;
 /**
  * qla4xxx_probe_adapter - callback function to probe HBA
  * @pdev: pointer to pci_dev structure
- * @pci_device_id: pointer to pci_device entry
+ * @ent: pointer to pci_device entry
  *
  * This routine will probe for Qlogic 4xxx iSCSI host adapters.
  * It returns zero if successful. It also initializes all data necessary for
 }
 /**
  * qla4xxx_remove_adapter - callback function to remove adapter.
- * @pci_dev: PCI device pointer
+ * @pdev: PCI device pointer
  **/
 static void qla4xxx_remove_adapter(struct pci_dev *pdev)
 {
 /**
  * qla4xxx_eh_wait_for_commands - wait for active cmds to finish.
  * @ha: pointer to HBA
- * @t: target id
+ * @stgt: pointer to SCSI target
- * @l: lun id
+ * @sdev: pointer to SCSI device
  *
  * This function waits for all outstanding commands to a lun to complete. It
  * returns 0 if all pending commands are returned and 1 otherwise.
  * qla4xxx_pci_mmio_enabled() gets called if
  * qla4xxx_pci_error_detected() returns PCI_ERS_RESULT_CAN_RECOVER
  * and read/write to the device still works.
+ * @pdev: PCI device pointer
  **/
 static pci_ers_result_t
 qla4xxx_pci_mmio_enabled(struct pci_dev *pdev)

drivers/scsi/scsi.c+0−3

 {
 	int error;
-	error = scsi_init_queue();
-	if (error)
-		return error;
 	error = scsi_init_procfs();
 	if (error)
 		goto cleanup_queue;

drivers/scsi/scsi_debug.c+303−197

@@ -9,7 +9,7 @@ · 8 unmodified lines
9	*	9	*
10	* Copyright (C) 2001 - 2020 Douglas Gilbert	10	* Copyright (C) 2001 - 2020 Douglas Gilbert
11	*	11	*
12	* For documentation see http://sg.danny.cz/sg/sdebug26.html	12	* For documentation see http://sg.danny.cz/sg/scsi_debug.html
13	*/	13	*/
14		14
15		15
@@ -60,8 +60,8 @@ · 44 unmodified lines
60	#include "scsi_logging.h"	60	#include "scsi_logging.h"
61		61
62	/* make sure inq_product_rev string corresponds to this version */	62	/* make sure inq_product_rev string corresponds to this version */
63	#define SDEBUG_VERSION "0189" /* format to fit INQUIRY revision field */	63	#define SDEBUG_VERSION "0190" /* format to fit INQUIRY revision field */
64	static const char *sdebug_version_date = "20200421";	64	static const char *sdebug_version_date = "20200710";
65		65
66	#define MY_NAME "scsi_debug"	66	#define MY_NAME "scsi_debug"
67		67
@@ -151,6 +151,7 @@ static const char *sdebug_version_date = "20200421"; · 83 unmodified lines
151	#define DEF_STRICT 0	151	#define DEF_STRICT 0
152	#define DEF_STATISTICS false	152	#define DEF_STATISTICS false
153	#define DEF_SUBMIT_QUEUES 1	153	#define DEF_SUBMIT_QUEUES 1
		154	#define DEF_TUR_MS_TO_READY 0
154	#define DEF_UUID_CTL 0	155	#define DEF_UUID_CTL 0
155	#define JDELAY_OVERRIDDEN -9999	156	#define JDELAY_OVERRIDDEN -9999
156		157
@@ -187,21 +188,8 @@ static const char *sdebug_version_date = "20200421"; · 30 unmodified lines
187	SDEBUG_OPT_SHORT_TRANSFER \| \	188	SDEBUG_OPT_SHORT_TRANSFER \| \
188	SDEBUG_OPT_HOST_BUSY \| \	189	SDEBUG_OPT_HOST_BUSY \| \
189	SDEBUG_OPT_CMD_ABORT)	190	SDEBUG_OPT_CMD_ABORT)
190	/* When "every_nth" > 0 then modulo "every_nth" commands:	191	#define SDEBUG_OPT_RECOV_DIF_DIX (SDEBUG_OPT_RECOVERED_ERR \| \
191	* - a missing response is simulated if SDEBUG_OPT_TIMEOUT is set	192	SDEBUG_OPT_DIF_ERR \| SDEBUG_OPT_DIX_ERR)
192	* - a RECOVERED_ERROR is simulated on successful read and write
193	* commands if SDEBUG_OPT_RECOVERED_ERR is set.
194	* - a TRANSPORT_ERROR is simulated on successful read and write
195	* commands if SDEBUG_OPT_TRANSPORT_ERR is set.
196	* - similarly for DIF_ERR, DIX_ERR, SHORT_TRANSFER, HOST_BUSY and
197	* CMD_ABORT
198	*
199	* When "every_nth" < 0 then after "- every_nth" commands the selected
200	* error will be injected. The error will be injected on every subsequent
201	* command until some other action occurs; for example, the user writing
202	* a new value (other than -1 or 1) to every_nth:
203	* echo 0 > /sys/bus/pseudo/drivers/scsi_debug/every_nth
204	*/
205		193
206	/* As indicated in SAM-5 and SPC-4 Unit Attentions (UAs) are returned in	194	/* As indicated in SAM-5 and SPC-4 Unit Attentions (UAs) are returned in
207	* priority order. In the subset implemented here lower numbers have higher	195	* priority order. In the subset implemented here lower numbers have higher
@@ -301,7 +289,7 @@ struct sdebug_dev_info { · 93 unmodified lines
301	struct sdebug_host_info *sdbg_host;	289	struct sdebug_host_info *sdbg_host;
302	unsigned long uas_bm[1];	290	unsigned long uas_bm[1];
303	atomic_t num_in_q;	291	atomic_t num_in_q;
304	atomic_t stopped;	292	atomic_t stopped; /* 1: by SSU, 2: device start */
305	bool used;	293	bool used;
306		294
307	/* For ZBC devices */	295	/* For ZBC devices */
@@ -314,6 +302,7 @@ struct sdebug_dev_info { · 6 unmodified lines
314	unsigned int nr_exp_open;	302	unsigned int nr_exp_open;
315	unsigned int nr_closed;	303	unsigned int nr_closed;
316	unsigned int max_open;	304	unsigned int max_open;
		305	ktime_t create_ts; /* time since bootup that this device was created */
317	struct sdeb_zone_state *zstate;	306	struct sdeb_zone_state *zstate;
318	};	307	};
319		308
@@ -344,6 +333,7 @@ struct sdebug_defer { · 24 unmodified lines
344	struct execute_work ew;	333	struct execute_work ew;
345	int sqa_idx; /* index of sdebug_queue array */	334	int sqa_idx; /* index of sdebug_queue array */
346	int qc_idx; /* index of sdebug_queued_cmd array within sqa_idx */	335	int qc_idx; /* index of sdebug_queued_cmd array within sqa_idx */
		336	int hc_idx; /* hostwide tag index */
347	int issuing_cpu;	337	int issuing_cpu;
348	bool init_hrt;	338	bool init_hrt;
349	bool init_wq;	339	bool init_wq;
@@ -357,13 +347,6 @@ struct sdebug_queued_cmd { · 7 unmodified lines
357	*/	347	*/
358	struct sdebug_defer *sd_dp;	348	struct sdebug_defer *sd_dp;
359	struct scsi_cmnd *a_cmnd;	349	struct scsi_cmnd *a_cmnd;
360	unsigned int inj_recovered:1;
361	unsigned int inj_transport:1;
362	unsigned int inj_dif:1;
363	unsigned int inj_dix:1;
364	unsigned int inj_short:1;
365	unsigned int inj_host_busy:1;
366	unsigned int inj_cmd_abort:1;
367	};	350	};
368		351
369	struct sdebug_queue {	352	struct sdebug_queue {
@@ -377,6 +360,7 @@ static atomic_t sdebug_cmnd_count; /* number of incoming commands */ · 7 unmodified lines
377	static atomic_t sdebug_completions; /* count of deferred completions */	360	static atomic_t sdebug_completions; /* count of deferred completions */
378	static atomic_t sdebug_miss_cpus; /* submission + completion cpus differ */	361	static atomic_t sdebug_miss_cpus; /* submission + completion cpus differ */
379	static atomic_t sdebug_a_tsf; /* 'almost task set full' counter */	362	static atomic_t sdebug_a_tsf; /* 'almost task set full' counter */
		363	static atomic_t sdeb_inject_pending;
380		364
381	struct opcode_info_t {	365	struct opcode_info_t {
382	u8 num_attached; /* 0 if this is it (i.e. a leaf); use 0xff */	366	u8 num_attached; /* 0 if this is it (i.e. a leaf); use 0xff */
@@ -759,6 +743,7 @@ static int sdebug_dsense = DEF_D_SENSE; · 376 unmodified lines
759	static int sdebug_every_nth = DEF_EVERY_NTH;	743	static int sdebug_every_nth = DEF_EVERY_NTH;
760	static int sdebug_fake_rw = DEF_FAKE_RW;	744	static int sdebug_fake_rw = DEF_FAKE_RW;
761	static unsigned int sdebug_guard = DEF_GUARD;	745	static unsigned int sdebug_guard = DEF_GUARD;
		746	static int sdebug_host_max_queue; /* per host */
762	static int sdebug_lowest_aligned = DEF_LOWEST_ALIGNED;	747	static int sdebug_lowest_aligned = DEF_LOWEST_ALIGNED;
763	static int sdebug_max_luns = DEF_MAX_LUNS;	748	static int sdebug_max_luns = DEF_MAX_LUNS;
764	static int sdebug_max_queue = SDEBUG_CANQUEUE; /* per submit queue */	749	static int sdebug_max_queue = SDEBUG_CANQUEUE; /* per submit queue */
@@ -777,6 +762,7 @@ static int sdebug_opt_xferlen_exp = DEF_OPT_XFERLEN_EXP; · 12 unmodified lines
777	static int sdebug_ptype = DEF_PTYPE; /* SCSI peripheral device type */	762	static int sdebug_ptype = DEF_PTYPE; /* SCSI peripheral device type */
778	static int sdebug_scsi_level = DEF_SCSI_LEVEL;	763	static int sdebug_scsi_level = DEF_SCSI_LEVEL;
779	static int sdebug_sector_size = DEF_SECTOR_SIZE;	764	static int sdebug_sector_size = DEF_SECTOR_SIZE;
		765	static int sdeb_tur_ms_to_ready = DEF_TUR_MS_TO_READY;
780	static int sdebug_virtual_gb = DEF_VIRTUAL_GB;	766	static int sdebug_virtual_gb = DEF_VIRTUAL_GB;
781	static int sdebug_vpd_use_hostno = DEF_VPD_USE_HOSTNO;	767	static int sdebug_vpd_use_hostno = DEF_VPD_USE_HOSTNO;
782	static unsigned int sdebug_lbpu = DEF_LBPU;	768	static unsigned int sdebug_lbpu = DEF_LBPU;
@@ -1729,75 +1715,68 @@ static int resp_inquiry(struct scsi_cmnd scp, struct sdebug_dev_info devip) · 946 unmodified lines
1729	return ret;	1715	return ret;
1730	}	1716	}
1731		1717
		1718	/* See resp_iec_m_pg() for how this data is manipulated */
1732	static unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,	1719	static unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
1733	0, 0, 0x0, 0x0};	1720	0, 0, 0x0, 0x0};
1734		1721
1735	static int resp_requests(struct scsi_cmnd *scp,	1722	static int resp_requests(struct scsi_cmnd *scp,
1736	struct sdebug_dev_info *devip)	1723	struct sdebug_dev_info *devip)
1737	{	1724	{
1738	unsigned char *sbuff;
1739	unsigned char *cmd = scp->cmnd;	1725	unsigned char *cmd = scp->cmnd;
1740	unsigned char arr[SCSI_SENSE_BUFFERSIZE];	1726	unsigned char arr[SCSI_SENSE_BUFFERSIZE]; /* assume >= 18 bytes */
1741	bool dsense;	1727	bool dsense = !!(cmd[1] & 1);
		1728	int alloc_len = cmd[4];
1742	int len = 18;	1729	int len = 18;
		1730	int stopped_state = atomic_read(&devip->stopped);
1743		1731
1744	memset(arr, 0, sizeof(arr));	1732	memset(arr, 0, sizeof(arr));
1745	dsense = !!(cmd[1] & 1);	1733	if (stopped_state > 0) { /* some "pollable" data [spc6r02: 5.12.2] */
1746	sbuff = scp->sense_buffer;	1734	if (dsense) {
1747	if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {	1735	arr[0] = 0x72;
		1736	arr[1] = NOT_READY;
		1737	arr[2] = LOGICAL_UNIT_NOT_READY;
		1738	arr[3] = (stopped_state == 2) ? 0x1 : 0x2;
		1739	len = 8;
		1740	} else {
		1741	arr[0] = 0x70;
		1742	arr[2] = NOT_READY; /* NO_SENSE in sense_key */
		1743	arr[7] = 0xa; /* 18 byte sense buffer */
		1744	arr[12] = LOGICAL_UNIT_NOT_READY;
		1745	arr[13] = (stopped_state == 2) ? 0x1 : 0x2;
		1746	}
		1747	} else if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
		1748	/* Information exceptions control mode page: TEST=1, MRIE=6 */
1748	if (dsense) {	1749	if (dsense) {
1749	arr[0] = 0x72;	1750	arr[0] = 0x72;
1750	arr[1] = 0x0; /* NO_SENSE in sense_key */	1751	arr[1] = 0x0; /* NO_SENSE in sense_key */
1751	arr[2] = THRESHOLD_EXCEEDED;	1752	arr[2] = THRESHOLD_EXCEEDED;
1752	arr[3] = 0xff; /* TEST set and MRIE==6 */	1753	arr[3] = 0xff; /* Failure prediction(false) */
1753	len = 8;	1754	len = 8;
1754	} else {	1755	} else {
1755	arr[0] = 0x70;	1756	arr[0] = 0x70;
1756	arr[2] = 0x0; /* NO_SENSE in sense_key */	1757	arr[2] = 0x0; /* NO_SENSE in sense_key */
1757	arr[7] = 0xa; /* 18 byte sense buffer */	1758	arr[7] = 0xa; /* 18 byte sense buffer */
1758	arr[12] = THRESHOLD_EXCEEDED;	1759	arr[12] = THRESHOLD_EXCEEDED;
1759	arr[13] = 0xff; /* TEST set and MRIE==6 */	1760	arr[13] = 0xff; /* Failure prediction(false) */
1760	}	1761	}
1761	} else {	1762	} else { /* nothing to report */
1762	memcpy(arr, sbuff, SCSI_SENSE_BUFFERSIZE);	1763	if (dsense) {
1763	if (arr[0] >= 0x70 && dsense == sdebug_dsense)
1764	; /* have sense and formats match */
1765	else if (arr[0] <= 0x70) {
1766	if (dsense) {
1767	memset(arr, 0, 8);
1768	arr[0] = 0x72;
1769	len = 8;
1770	} else {
1771	memset(arr, 0, 18);
1772	arr[0] = 0x70;
1773	arr[7] = 0xa;
1774	}
1775	} else if (dsense) {
1776	memset(arr, 0, 8);
1777	arr[0] = 0x72;
1778	arr[1] = sbuff[2]; /* sense key */
1779	arr[2] = sbuff[12]; /* asc */
1780	arr[3] = sbuff[13]; /* ascq */
1781	len = 8;	1764	len = 8;
		1765	memset(arr, 0, len);
		1766	arr[0] = 0x72;
1782	} else {	1767	} else {
1783	memset(arr, 0, 18);	1768	memset(arr, 0, len);
1784	arr[0] = 0x70;	1769	arr[0] = 0x70;
1785	arr[2] = sbuff[1];
1786	arr[7] = 0xa;	1770	arr[7] = 0xa;
1787	arr[12] = sbuff[1];
1788	arr[13] = sbuff[3];
1789	}	1771	}
1790
1791	}	1772	}
1792	mk_sense_buffer(scp, 0, NO_ADDITIONAL_SENSE, 0);	1773	return fill_from_dev_buffer(scp, arr, min_t(int, len, alloc_len));
1793	return fill_from_dev_buffer(scp, arr, len);
1794	}	1774	}
1795		1775
1796	static int resp_start_stop(struct scsi_cmnd *scp,	1776	static int resp_start_stop(struct scsi_cmnd scp, struct sdebug_dev_info devip)
1797	struct sdebug_dev_info *devip)
1798	{	1777	{
1799	unsigned char *cmd = scp->cmnd;	1778	unsigned char *cmd = scp->cmnd;
1800	int power_cond, stop;	1779	int power_cond, want_stop, stopped_state;
1801	bool changing;	1780	bool changing;
1802		1781
1803	power_cond = (cmd[4] & 0xf0) >> 4;	1782	power_cond = (cmd[4] & 0xf0) >> 4;
@@ -1805,10 +1784,33 @@ static int resp_start_stop(struct scsi_cmnd *scp, · 1 unmodified line
1805	mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, 7);	1784	mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, 7);
1806	return check_condition_result;	1785	return check_condition_result;
1807	}	1786	}
1808	stop = !(cmd[4] & 1);	1787	want_stop = !(cmd[4] & 1);
1809	changing = atomic_read(&devip->stopped) == !stop;	1788	stopped_state = atomic_read(&devip->stopped);
1810	atomic_xchg(&devip->stopped, stop);	1789	if (stopped_state == 2) {
1811	if (!changing \|\| cmd[1] & 0x1) /* state unchanged or IMMED set */	1790	ktime_t now_ts = ktime_get_boottime();
		1791
		1792	if (ktime_to_ns(now_ts) > ktime_to_ns(devip->create_ts)) {
		1793	u64 diff_ns = ktime_to_ns(ktime_sub(now_ts, devip->create_ts));
		1794
		1795	if (diff_ns >= ((u64)sdeb_tur_ms_to_ready * 1000000)) {
		1796	/* tur_ms_to_ready timer extinguished */
		1797	atomic_set(&devip->stopped, 0);
		1798	stopped_state = 0;
		1799	}
		1800	}
		1801	if (stopped_state == 2) {
		1802	if (want_stop) {
		1803	stopped_state = 1; /* dummy up success */
		1804	} else { /* Disallow tur_ms_to_ready delay to be overridden */
		1805	mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, 0 /* START bit */);
		1806	return check_condition_result;
		1807	}
		1808	}
		1809	}
		1810	changing = (stopped_state != want_stop);
		1811	if (changing)
		1812	atomic_xchg(&devip->stopped, want_stop);
		1813	if (!changing \|\| (cmd[1] & 0x1)) /* state unchanged or IMMED bit set in cdb */
1812	return SDEG_RES_IMMED_MASK;	1814	return SDEG_RES_IMMED_MASK;
1813	else	1815	else
1814	return 0;	1816	return 0;
@@ -3109,7 +3111,6 @@ static int resp_read_dt0(struct scsi_cmnd scp, struct sdebug_dev_info devip) · 1294 unmodified lines
3109	struct sdeb_store_info *sip = devip2sip(devip, true);	3111	struct sdeb_store_info *sip = devip2sip(devip, true);
3110	rwlock_t *macc_lckp = sip ? &sip->macc_lck : &sdeb_fake_rw_lck;	3112	rwlock_t *macc_lckp = sip ? &sip->macc_lck : &sdeb_fake_rw_lck;
3111	u8 *cmd = scp->cmnd;	3113	u8 *cmd = scp->cmnd;
3112	struct sdebug_queued_cmd *sqcp;
3113		3114
3114	switch (cmd[0]) {	3115	switch (cmd[0]) {
3115	case READ_16:	3116	case READ_16:
@@ -3162,15 +3163,11 @@ static int resp_read_dt0(struct scsi_cmnd scp, struct sdebug_dev_info devip) · 46 unmodified lines
3162	sdev_printk(KERN_ERR, scp->device, "Unprotected RD "	3163	sdev_printk(KERN_ERR, scp->device, "Unprotected RD "
3163	"to DIF device\n");	3164	"to DIF device\n");
3164	}	3165	}
3165	if (unlikely(sdebug_any_injecting_opt)) {	3166	if (unlikely((sdebug_opts & SDEBUG_OPT_SHORT_TRANSFER) &&
3166	sqcp = (struct sdebug_queued_cmd *)scp->host_scribble;	3167	atomic_read(&sdeb_inject_pending))) {
3167		3168	num /= 2;
3168	if (sqcp) {	3169	atomic_set(&sdeb_inject_pending, 0);
3169	if (sqcp->inj_short)	3170	}
3170	num /= 2;
3171	}
3172	} else
3173	sqcp = NULL;
3174		3171
3175	ret = check_device_access_params(scp, lba, num, false);	3172	ret = check_device_access_params(scp, lba, num, false);
3176	if (ret)	3173	if (ret)
@@ -3211,21 +3208,20 @@ static int resp_read_dt0(struct scsi_cmnd scp, struct sdebug_dev_info devip) · 34 unmodified lines
3211		3208
3212	scsi_set_resid(scp, scsi_bufflen(scp) - ret);	3209	scsi_set_resid(scp, scsi_bufflen(scp) - ret);
3213		3210
3214	if (unlikely(sqcp)) {	3211	if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
3215	if (sqcp->inj_recovered) {	3212	atomic_read(&sdeb_inject_pending))) {
3216	mk_sense_buffer(scp, RECOVERED_ERROR,	3213	if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
3217	THRESHOLD_EXCEEDED, 0);	3214	mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
		3215	atomic_set(&sdeb_inject_pending, 0);
3218	return check_condition_result;	3216	return check_condition_result;
3219	} else if (sqcp->inj_transport) {	3217	} else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
3220	mk_sense_buffer(scp, ABORTED_COMMAND,
3221	TRANSPORT_PROBLEM, ACK_NAK_TO);
3222	return check_condition_result;
3223	} else if (sqcp->inj_dif) {
3224	/* Logical block guard check failed */	3218	/* Logical block guard check failed */
3225	mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);	3219	mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
		3220	atomic_set(&sdeb_inject_pending, 0);
3226	return illegal_condition_result;	3221	return illegal_condition_result;
3227	} else if (sqcp->inj_dix) {	3222	} else if (SDEBUG_OPT_DIX_ERR & sdebug_opts) {
3228	mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);	3223	mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
		3224	atomic_set(&sdeb_inject_pending, 0);
3229	return illegal_condition_result;	3225	return illegal_condition_result;
3230	}	3226	}
3231	}	3227	}
@@ -3504,23 +3500,21 @@ static int resp_write_dt0(struct scsi_cmnd scp, struct sdebug_dev_info devip) · 272 unmodified lines
3504	"%s: write: cdb indicated=%u, IO sent=%d bytes\n",	3500	"%s: write: cdb indicated=%u, IO sent=%d bytes\n",
3505	my_name, num * sdebug_sector_size, ret);	3501	my_name, num * sdebug_sector_size, ret);
3506		3502
3507	if (unlikely(sdebug_any_injecting_opt)) {	3503	if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
3508	struct sdebug_queued_cmd *sqcp =	3504	atomic_read(&sdeb_inject_pending))) {
3509	(struct sdebug_queued_cmd *)scp->host_scribble;	3505	if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
3510		3506	mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
3511	if (sqcp) {	3507	atomic_set(&sdeb_inject_pending, 0);
3512	if (sqcp->inj_recovered) {	3508	return check_condition_result;
3513	mk_sense_buffer(scp, RECOVERED_ERROR,	3509	} else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
3514	THRESHOLD_EXCEEDED, 0);	3510	/* Logical block guard check failed */
3515	return check_condition_result;	3511	mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
3516	} else if (sqcp->inj_dif) {	3512	atomic_set(&sdeb_inject_pending, 0);
3517	/* Logical block guard check failed */	3513	return illegal_condition_result;
3518	mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);	3514	} else if (sdebug_opts & SDEBUG_OPT_DIX_ERR) {
3519	return illegal_condition_result;	3515	mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
3520	} else if (sqcp->inj_dix) {	3516	atomic_set(&sdeb_inject_pending, 0);
3521	mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);	3517	return illegal_condition_result;
3522	return illegal_condition_result;
3523	}
3524	}	3518	}
3525	}	3519	}
3526	return 0;	3520	return 0;
@@ -3662,28 +3656,24 @@ static int resp_write_scat(struct scsi_cmnd *scp, · 135 unmodified lines
3662	"%s: write: cdb indicated=%u, IO sent=%d bytes\n",	3656	"%s: write: cdb indicated=%u, IO sent=%d bytes\n",
3663	my_name, num_by, ret);	3657	my_name, num_by, ret);
3664		3658
3665	if (unlikely(sdebug_any_injecting_opt)) {	3659	if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
3666	struct sdebug_queued_cmd *sqcp =	3660	atomic_read(&sdeb_inject_pending))) {
3667	(struct sdebug_queued_cmd *)scp->host_scribble;	3661	if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
3668		3662	mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
3669	if (sqcp) {	3663	atomic_set(&sdeb_inject_pending, 0);
3670	if (sqcp->inj_recovered) {	3664	ret = check_condition_result;
3671	mk_sense_buffer(scp, RECOVERED_ERROR,	3665	goto err_out_unlock;
3672	THRESHOLD_EXCEEDED, 0);	3666	} else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
3673	ret = illegal_condition_result;	3667	/* Logical block guard check failed */
3674	goto err_out_unlock;	3668	mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
3675	} else if (sqcp->inj_dif) {	3669	atomic_set(&sdeb_inject_pending, 0);
3676	/* Logical block guard check failed */	3670	ret = illegal_condition_result;
3677	mk_sense_buffer(scp, ABORTED_COMMAND,	3671	goto err_out_unlock;
3678	0x10, 1);	3672	} else if (sdebug_opts & SDEBUG_OPT_DIX_ERR) {
3679	ret = illegal_condition_result;	3673	mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
3680	goto err_out_unlock;	3674	atomic_set(&sdeb_inject_pending, 0);
3681	} else if (sqcp->inj_dix) {	3675	ret = illegal_condition_result;
3682	mk_sense_buffer(scp, ILLEGAL_REQUEST,	3676	goto err_out_unlock;
3683	0x10, 1);
3684	ret = illegal_condition_result;
3685	goto err_out_unlock;
3686	}
3687	}	3677	}
3688	}	3678	}
3689	sg_off += num_by;	3679	sg_off += num_by;
@@ -4049,7 +4039,7 @@ static int resp_sync_cache(struct scsi_cmnd *scp, · 359 unmodified lines
4049	mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);	4039	mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4050	return check_condition_result;	4040	return check_condition_result;
4051	}	4041	}
4052	if (!write_since_sync \|\| cmd[1] & 0x2)	4042	if (!write_since_sync \|\| (cmd[1] & 0x2))
4053	res = SDEG_RES_IMMED_MASK;	4043	res = SDEG_RES_IMMED_MASK;
4054	else /* delay if write_since_sync and IMMED clear */	4044	else /* delay if write_since_sync and IMMED clear */
4055	write_since_sync = false;	4045	write_since_sync = false;
@@ -4707,15 +4697,28 @@ fini: · 651 unmodified lines
4707		4697
4708	static struct sdebug_queue get_queue(struct scsi_cmnd cmnd)	4698	static struct sdebug_queue get_queue(struct scsi_cmnd cmnd)
4709	{	4699	{
4710	u32 tag = blk_mq_unique_tag(cmnd->request);	4700	u16 hwq;
4711	u16 hwq = blk_mq_unique_tag_to_hwq(tag);
4712		4701
4713	pr_debug("tag=%#x, hwq=%d\n", tag, hwq);	4702	if (sdebug_host_max_queue) {
4714	if (WARN_ON_ONCE(hwq >= submit_queues))	4703	/* Provide a simple method to choose the hwq */
4715	hwq = 0;	4704	hwq = smp_processor_id() % submit_queues;
		4705	} else {
		4706	u32 tag = blk_mq_unique_tag(cmnd->request);
		4707
		4708	hwq = blk_mq_unique_tag_to_hwq(tag);
		4709
		4710	pr_debug("tag=%#x, hwq=%d\n", tag, hwq);
		4711	if (WARN_ON_ONCE(hwq >= submit_queues))
		4712	hwq = 0;
		4713	}
4716	return sdebug_q_arr + hwq;	4714	return sdebug_q_arr + hwq;
4717	}	4715	}
4718		4716
		4717	static u32 get_tag(struct scsi_cmnd *cmnd)
		4718	{
		4719	return blk_mq_unique_tag(cmnd->request);
		4720	}
		4721
4719	/* Queued (deferred) command completions converge here. */	4722	/* Queued (deferred) command completions converge here. */
4720	static void sdebug_q_cmd_complete(struct sdebug_defer *sd_dp)	4723	static void sdebug_q_cmd_complete(struct sdebug_defer *sd_dp)
4721	{	4724	{
@@ -4747,8 +4750,8 @@ static void sdebug_q_cmd_complete(struct sdebug_defer *sd_dp) · 25 unmodified lines
4747	scp = sqcp->a_cmnd;	4750	scp = sqcp->a_cmnd;
4748	if (unlikely(scp == NULL)) {	4751	if (unlikely(scp == NULL)) {
4749	spin_unlock_irqrestore(&sqp->qc_lock, iflags);	4752	spin_unlock_irqrestore(&sqp->qc_lock, iflags);
4750	pr_err("scp is NULL, sqa_idx=%d, qc_idx=%d\n",	4753	pr_err("scp is NULL, sqa_idx=%d, qc_idx=%d, hc_idx=%d\n",
4751	sd_dp->sqa_idx, qc_idx);	4754	sd_dp->sqa_idx, qc_idx, sd_dp->hc_idx);
4752	return;	4755	return;
4753	}	4756	}
4754	devip = (struct sdebug_dev_info *)scp->device->hostdata;	4757	devip = (struct sdebug_dev_info *)scp->device->hostdata;
@@ -4925,6 +4928,8 @@ static struct sdebug_dev_info *sdebug_device_create( · 170 unmodified lines
4925	devip->zmodel = BLK_ZONED_NONE;	4928	devip->zmodel = BLK_ZONED_NONE;
4926	}	4929	}
4927	devip->sdbg_host = sdbg_host;	4930	devip->sdbg_host = sdbg_host;
		4931	devip->create_ts = ktime_get_boottime();
		4932	atomic_set(&devip->stopped, (sdeb_tur_ms_to_ready > 0 ? 2 : 0));
4928	list_add_tail(&devip->dev_list, &sdbg_host->dev_info_list);	4933	list_add_tail(&devip->dev_list, &sdbg_host->dev_info_list);
4929	}	4934	}
4930	return devip;	4935	return devip;
@@ -5333,24 +5338,11 @@ static void clear_queue_stats(void) · 402 unmodified lines
5333	atomic_set(&sdebug_a_tsf, 0);	5338	atomic_set(&sdebug_a_tsf, 0);
5334	}	5339	}
5335		5340
5336	static void setup_inject(struct sdebug_queue *sqp,	5341	static bool inject_on_this_cmd(void)
5337	struct sdebug_queued_cmd *sqcp)
5338	{	5342	{
5339	if ((atomic_read(&sdebug_cmnd_count) % abs(sdebug_every_nth)) > 0) {	5343	if (sdebug_every_nth == 0)
5340	if (sdebug_every_nth > 0)	5344	return false;
5341	sqcp->inj_recovered = sqcp->inj_transport	5345	return (atomic_read(&sdebug_cmnd_count) % abs(sdebug_every_nth)) == 0;
5342	= sqcp->inj_dif
5343	= sqcp->inj_dix = sqcp->inj_short
5344	= sqcp->inj_host_busy = sqcp->inj_cmd_abort = 0;
5345	return;
5346	}
5347	sqcp->inj_recovered = !!(SDEBUG_OPT_RECOVERED_ERR & sdebug_opts);
5348	sqcp->inj_transport = !!(SDEBUG_OPT_TRANSPORT_ERR & sdebug_opts);
5349	sqcp->inj_dif = !!(SDEBUG_OPT_DIF_ERR & sdebug_opts);
5350	sqcp->inj_dix = !!(SDEBUG_OPT_DIX_ERR & sdebug_opts);
5351	sqcp->inj_short = !!(SDEBUG_OPT_SHORT_TRANSFER & sdebug_opts);
5352	sqcp->inj_host_busy = !!(SDEBUG_OPT_HOST_BUSY & sdebug_opts);
5353	sqcp->inj_cmd_abort = !!(SDEBUG_OPT_CMD_ABORT & sdebug_opts);
5354	}	5346	}
5355		5347
5356	#define INCLUSIVE_TIMING_MAX_NS 1000000 /* 1 millisecond */	5348	#define INCLUSIVE_TIMING_MAX_NS 1000000 /* 1 millisecond */
@@ -5367,7 +5359,8 @@ static int schedule_resp(struct scsi_cmnd cmnd, struct sdebug_dev_info devip, · 10 unmodified lines
5367	int delta_jiff, int ndelay)	5359	int delta_jiff, int ndelay)
5368	{	5360	{
5369	bool new_sd_dp;	5361	bool new_sd_dp;
5370	int k, num_in_q, qdepth, inject;	5362	bool inject = false;
		5363	int k, num_in_q, qdepth;
5371	unsigned long iflags;	5364	unsigned long iflags;
5372	u64 ns_from_boot = 0;	5365	u64 ns_from_boot = 0;
5373	struct sdebug_queue *sqp;	5366	struct sdebug_queue *sqp;
@@ -5393,7 +5386,6 @@ static int schedule_resp(struct scsi_cmnd cmnd, struct sdebug_dev_info devip, · 19 unmodified lines
5393	}	5386	}
5394	num_in_q = atomic_read(&devip->num_in_q);	5387	num_in_q = atomic_read(&devip->num_in_q);
5395	qdepth = cmnd->device->queue_depth;	5388	qdepth = cmnd->device->queue_depth;
5396	inject = 0;
5397	if (unlikely((qdepth > 0) && (num_in_q >= qdepth))) {	5389	if (unlikely((qdepth > 0) && (num_in_q >= qdepth))) {
5398	if (scsi_result) {	5390	if (scsi_result) {
5399	spin_unlock_irqrestore(&sqp->qc_lock, iflags);	5391	spin_unlock_irqrestore(&sqp->qc_lock, iflags);
@@ -5407,7 +5399,7 @@ static int schedule_resp(struct scsi_cmnd cmnd, struct sdebug_dev_info devip, · 7 unmodified lines
5407	(atomic_inc_return(&sdebug_a_tsf) >=	5399	(atomic_inc_return(&sdebug_a_tsf) >=
5408	abs(sdebug_every_nth))) {	5400	abs(sdebug_every_nth))) {
5409	atomic_set(&sdebug_a_tsf, 0);	5401	atomic_set(&sdebug_a_tsf, 0);
5410	inject = 1;	5402	inject = true;
5411	scsi_result = device_qfull_result;	5403	scsi_result = device_qfull_result;
5412	}	5404	}
5413	}	5405	}
@@ -5430,35 +5422,47 @@ static int schedule_resp(struct scsi_cmnd cmnd, struct sdebug_dev_info devip, · 16 unmodified lines
5430	else	5422	else
5431	return SCSI_MLQUEUE_HOST_BUSY;	5423	return SCSI_MLQUEUE_HOST_BUSY;
5432	}	5424	}
5433	__set_bit(k, sqp->in_use_bm);	5425	set_bit(k, sqp->in_use_bm);
5434	atomic_inc(&devip->num_in_q);	5426	atomic_inc(&devip->num_in_q);
5435	sqcp = &sqp->qc_arr[k];	5427	sqcp = &sqp->qc_arr[k];
5436	sqcp->a_cmnd = cmnd;	5428	sqcp->a_cmnd = cmnd;
5437	cmnd->host_scribble = (unsigned char *)sqcp;	5429	cmnd->host_scribble = (unsigned char *)sqcp;
5438	sd_dp = sqcp->sd_dp;	5430	sd_dp = sqcp->sd_dp;
5439	spin_unlock_irqrestore(&sqp->qc_lock, iflags);	5431	spin_unlock_irqrestore(&sqp->qc_lock, iflags);
5440	if (unlikely(sdebug_every_nth && sdebug_any_injecting_opt))	5432	if (!sd_dp) {
5441	setup_inject(sqp, sqcp);
5442	if (sd_dp == NULL) {
5443	sd_dp = kzalloc(sizeof(*sd_dp), GFP_ATOMIC);	5433	sd_dp = kzalloc(sizeof(*sd_dp), GFP_ATOMIC);
5444	if (sd_dp == NULL)	5434	if (!sd_dp) {
		5435	atomic_dec(&devip->num_in_q);
		5436	clear_bit(k, sqp->in_use_bm);
5445	return SCSI_MLQUEUE_HOST_BUSY;	5437	return SCSI_MLQUEUE_HOST_BUSY;
		5438	}
5446	new_sd_dp = true;	5439	new_sd_dp = true;
5447	} else {	5440	} else {
5448	new_sd_dp = false;	5441	new_sd_dp = false;
5449	}	5442	}
5450		5443
		5444	/* Set the hostwide tag */
		5445	if (sdebug_host_max_queue)
		5446	sd_dp->hc_idx = get_tag(cmnd);
		5447
5451	if (ndelay > 0 && ndelay < INCLUSIVE_TIMING_MAX_NS)	5448	if (ndelay > 0 && ndelay < INCLUSIVE_TIMING_MAX_NS)
5452	ns_from_boot = ktime_get_boottime_ns();	5449	ns_from_boot = ktime_get_boottime_ns();
5453		5450
5454	/* one of the resp_() response functions is called here /	5451	/* one of the resp_() response functions is called here /
5455	cmnd->result = pfp != NULL ? pfp(cmnd, devip) : 0;	5452	cmnd->result = pfp ? pfp(cmnd, devip) : 0;
5456	if (cmnd->result & SDEG_RES_IMMED_MASK) {	5453	if (cmnd->result & SDEG_RES_IMMED_MASK) {
5457	cmnd->result &= ~SDEG_RES_IMMED_MASK;	5454	cmnd->result &= ~SDEG_RES_IMMED_MASK;
5458	delta_jiff = ndelay = 0;	5455	delta_jiff = ndelay = 0;
5459	}	5456	}
5460	if (cmnd->result == 0 && scsi_result != 0)	5457	if (cmnd->result == 0 && scsi_result != 0)
5461	cmnd->result = scsi_result;	5458	cmnd->result = scsi_result;
		5459	if (cmnd->result == 0 && unlikely(sdebug_opts & SDEBUG_OPT_TRANSPORT_ERR)) {
		5460	if (atomic_read(&sdeb_inject_pending)) {
		5461	mk_sense_buffer(cmnd, ABORTED_COMMAND, TRANSPORT_PROBLEM, ACK_NAK_TO);
		5462	atomic_set(&sdeb_inject_pending, 0);
		5463	cmnd->result = check_condition_result;
		5464	}
		5465	}
5462		5466
5463	if (unlikely(sdebug_verbose && cmnd->result))	5467	if (unlikely(sdebug_verbose && cmnd->result))
5464	sdev_printk(KERN_INFO, sdp, "%s: non-zero result=0x%x\n",	5468	sdev_printk(KERN_INFO, sdp, "%s: non-zero result=0x%x\n",
@@ -5524,21 +5528,20 @@ static int schedule_resp(struct scsi_cmnd cmnd, struct sdebug_dev_info devip, · 59 unmodified lines
5524	if (sdebug_statistics)	5528	if (sdebug_statistics)
5525	sd_dp->issuing_cpu = raw_smp_processor_id();	5529	sd_dp->issuing_cpu = raw_smp_processor_id();
5526	sd_dp->defer_t = SDEB_DEFER_WQ;	5530	sd_dp->defer_t = SDEB_DEFER_WQ;
5527	if (unlikely(sqcp->inj_cmd_abort))	5531	if (unlikely((sdebug_opts & SDEBUG_OPT_CMD_ABORT) &&
		5532	atomic_read(&sdeb_inject_pending)))
5528	sd_dp->aborted = true;	5533	sd_dp->aborted = true;
5529	schedule_work(&sd_dp->ew.work);	5534	schedule_work(&sd_dp->ew.work);
5530	if (unlikely(sqcp->inj_cmd_abort)) {	5535	if (unlikely((sdebug_opts & SDEBUG_OPT_CMD_ABORT) &&
5531	sdev_printk(KERN_INFO, sdp, "abort request tag %d\n",	5536	atomic_read(&sdeb_inject_pending))) {
5532	cmnd->request->tag);	5537	sdev_printk(KERN_INFO, sdp, "abort request tag %d\n", cmnd->request->tag);
5533	blk_abort_request(cmnd->request);	5538	blk_abort_request(cmnd->request);
		5539	atomic_set(&sdeb_inject_pending, 0);
5534	}	5540	}
5535	}	5541	}
5536	if (unlikely((SDEBUG_OPT_Q_NOISE & sdebug_opts) &&	5542	if (unlikely((SDEBUG_OPT_Q_NOISE & sdebug_opts) && scsi_result == device_qfull_result))
5537	(scsi_result == device_qfull_result)))	5543	sdev_printk(KERN_INFO, sdp, "%s: num_in_q=%d +1, %s%s\n", __func__,
5538	sdev_printk(KERN_INFO, sdp,	5544	num_in_q, (inject ? "<inject> " : ""), "status: TASK SET FULL");
5539	"%s: num_in_q=%d +1, %s%s\n", __func__,
5540	num_in_q, (inject ? "<inject> " : ""),
5541	"status: TASK SET FULL");
5542	return 0;	5545	return 0;
5543		5546
5544	respond_in_thread: /* call back to mid-layer using invocation thread */	5547	respond_in_thread: /* call back to mid-layer using invocation thread */
@@ -5569,6 +5572,7 @@ module_param_named(every_nth, sdebug_every_nth, int, S_IRUGO \| S_IWUSR); · 24 unmodified lines
5569	module_param_named(fake_rw, sdebug_fake_rw, int, S_IRUGO \| S_IWUSR);	5572	module_param_named(fake_rw, sdebug_fake_rw, int, S_IRUGO \| S_IWUSR);
5570	module_param_named(guard, sdebug_guard, uint, S_IRUGO);	5573	module_param_named(guard, sdebug_guard, uint, S_IRUGO);
5571	module_param_named(host_lock, sdebug_host_lock, bool, S_IRUGO \| S_IWUSR);	5574	module_param_named(host_lock, sdebug_host_lock, bool, S_IRUGO \| S_IWUSR);
		5575	module_param_named(host_max_queue, sdebug_host_max_queue, int, S_IRUGO);
5572	module_param_string(inq_product, sdebug_inq_product_id,	5576	module_param_string(inq_product, sdebug_inq_product_id,
5573	sizeof(sdebug_inq_product_id), S_IRUGO \| S_IWUSR);	5577	sizeof(sdebug_inq_product_id), S_IRUGO \| S_IWUSR);
5574	module_param_string(inq_rev, sdebug_inq_product_rev,	5578	module_param_string(inq_rev, sdebug_inq_product_rev,
@@ -5605,6 +5609,7 @@ module_param_named(sector_size, sdebug_sector_size, int, S_IRUGO); · 30 unmodified lines
5605	module_param_named(statistics, sdebug_statistics, bool, S_IRUGO \| S_IWUSR);	5609	module_param_named(statistics, sdebug_statistics, bool, S_IRUGO \| S_IWUSR);
5606	module_param_named(strict, sdebug_strict, bool, S_IRUGO \| S_IWUSR);	5610	module_param_named(strict, sdebug_strict, bool, S_IRUGO \| S_IWUSR);
5607	module_param_named(submit_queues, submit_queues, int, S_IRUGO);	5611	module_param_named(submit_queues, submit_queues, int, S_IRUGO);
		5612	module_param_named(tur_ms_to_ready, sdeb_tur_ms_to_ready, int, S_IRUGO);
5608	module_param_named(unmap_alignment, sdebug_unmap_alignment, int, S_IRUGO);	5613	module_param_named(unmap_alignment, sdebug_unmap_alignment, int, S_IRUGO);
5609	module_param_named(unmap_granularity, sdebug_unmap_granularity, int, S_IRUGO);	5614	module_param_named(unmap_granularity, sdebug_unmap_granularity, int, S_IRUGO);
5610	module_param_named(unmap_max_blocks, sdebug_unmap_max_blocks, int, S_IRUGO);	5615	module_param_named(unmap_max_blocks, sdebug_unmap_max_blocks, int, S_IRUGO);
@@ -5639,6 +5644,8 @@ MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)"); · 28 unmodified lines
5639	MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");	5644	MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
5640	MODULE_PARM_DESC(guard, "protection checksum: 0=crc, 1=ip (def=0)");	5645	MODULE_PARM_DESC(guard, "protection checksum: 0=crc, 1=ip (def=0)");
5641	MODULE_PARM_DESC(host_lock, "host_lock is ignored (def=0)");	5646	MODULE_PARM_DESC(host_lock, "host_lock is ignored (def=0)");
		5647	MODULE_PARM_DESC(host_max_queue,
		5648	"host max # of queued cmds (0 to max(def) [max_queue fixed equal for !0])");
5642	MODULE_PARM_DESC(inq_product, "SCSI INQUIRY product string (def=\"scsi_debug\")");	5649	MODULE_PARM_DESC(inq_product, "SCSI INQUIRY product string (def=\"scsi_debug\")");
5643	MODULE_PARM_DESC(inq_rev, "SCSI INQUIRY revision string (def=\""	5650	MODULE_PARM_DESC(inq_rev, "SCSI INQUIRY revision string (def=\""
5644	SDEBUG_VERSION "\")");	5651	SDEBUG_VERSION "\")");
@@ -5671,6 +5678,7 @@ MODULE_PARM_DESC(sector_size, "logical block size in bytes (def=512)"); · 26 unmodified lines
5671	MODULE_PARM_DESC(statistics, "collect statistics on commands, queues (def=0)");	5678	MODULE_PARM_DESC(statistics, "collect statistics on commands, queues (def=0)");
5672	MODULE_PARM_DESC(strict, "stricter checks: reserved field in cdb (def=0)");	5679	MODULE_PARM_DESC(strict, "stricter checks: reserved field in cdb (def=0)");
5673	MODULE_PARM_DESC(submit_queues, "support for block multi-queue (def=1)");	5680	MODULE_PARM_DESC(submit_queues, "support for block multi-queue (def=1)");
		5681	MODULE_PARM_DESC(tur_ms_to_ready, "TEST UNIT READY millisecs before initial good status (def=0)");
5674	MODULE_PARM_DESC(unmap_alignment, "lowest aligned thin provisioning lba (def=0)");	5682	MODULE_PARM_DESC(unmap_alignment, "lowest aligned thin provisioning lba (def=0)");
5675	MODULE_PARM_DESC(unmap_granularity, "thin provisioning granularity in blocks (def=1)");	5683	MODULE_PARM_DESC(unmap_granularity, "thin provisioning granularity in blocks (def=1)");
5676	MODULE_PARM_DESC(unmap_max_blocks, "max # of blocks can be unmapped in one cmd (def=0xffffffff)");	5684	MODULE_PARM_DESC(unmap_max_blocks, "max # of blocks can be unmapped in one cmd (def=0xffffffff)");
@@ -6072,17 +6080,27 @@ static ssize_t every_nth_store(struct device_driver ddp, const char buf, · 395 unmodified lines
6072	size_t count)	6080	size_t count)
6073	{	6081	{
6074	int nth;	6082	int nth;
		6083	char work[20];
6075		6084
6076	if ((count > 0) && (1 == sscanf(buf, "%d", &nth))) {	6085	if (sscanf(buf, "%10s", work) == 1) {
6077	sdebug_every_nth = nth;	6086	if (strncasecmp(work, "0x", 2) == 0) {
6078	if (nth && !sdebug_statistics) {	6087	if (kstrtoint(work + 2, 16, &nth) == 0)
6079	pr_info("every_nth needs statistics=1, set it\n");	6088	goto every_nth_done;
6080	sdebug_statistics = true;	6089	} else {
		6090	if (kstrtoint(work, 10, &nth) == 0)
		6091	goto every_nth_done;
6081	}	6092	}
6082	tweak_cmnd_count();
6083	return count;
6084	}	6093	}
6085	return -EINVAL;	6094	return -EINVAL;
		6095
		6096	every_nth_done:
		6097	sdebug_every_nth = nth;
		6098	if (nth && !sdebug_statistics) {
		6099	pr_info("every_nth needs statistics=1, set it\n");
		6100	sdebug_statistics = true;
		6101	}
		6102	tweak_cmnd_count();
		6103	return count;
6086	}	6104	}
6087	static DRIVER_ATTR_RW(every_nth);	6105	static DRIVER_ATTR_RW(every_nth);
6088		6106
@@ -6138,7 +6156,8 @@ static ssize_t max_queue_store(struct device_driver ddp, const char buf, · 49 unmodified lines
6138	struct sdebug_queue *sqp;	6156	struct sdebug_queue *sqp;
6139		6157
6140	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n > 0) &&	6158	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n > 0) &&
6141	(n <= SDEBUG_CANQUEUE)) {	6159	(n <= SDEBUG_CANQUEUE) &&
		6160	(sdebug_host_max_queue == 0)) {
6142	block_unblock_all_queues(true);	6161	block_unblock_all_queues(true);
6143	k = 0;	6162	k = 0;
6144	for (j = 0, sqp = sdebug_q_arr; j < submit_queues;	6163	for (j = 0, sqp = sdebug_q_arr; j < submit_queues;
@@ -6161,6 +6180,17 @@ static ssize_t max_queue_store(struct device_driver ddp, const char buf, · 16 unmodified lines
6161	}	6180	}
6162	static DRIVER_ATTR_RW(max_queue);	6181	static DRIVER_ATTR_RW(max_queue);
6163		6182
		6183	static ssize_t host_max_queue_show(struct device_driver ddp, char buf)
		6184	{
		6185	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_host_max_queue);
		6186	}
		6187
		6188	/*
		6189	* Since this is used for .can_queue, and we get the hc_idx tag from the bitmap
		6190	* in range [0, sdebug_host_max_queue), we can't change it.
		6191	*/
		6192	static DRIVER_ATTR_RO(host_max_queue);
		6193
6164	static ssize_t no_uld_show(struct device_driver ddp, char buf)	6194	static ssize_t no_uld_show(struct device_driver ddp, char buf)
6165	{	6195	{
6166	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_no_uld);	6196	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_no_uld);
@@ -6487,6 +6517,12 @@ static ssize_t zbc_show(struct device_driver ddp, char buf) · 320 unmodified lines
6487	}	6517	}
6488	static DRIVER_ATTR_RO(zbc);	6518	static DRIVER_ATTR_RO(zbc);
6489		6519
		6520	static ssize_t tur_ms_to_ready_show(struct device_driver ddp, char buf)
		6521	{
		6522	return scnprintf(buf, PAGE_SIZE, "%d\n", sdeb_tur_ms_to_ready);
		6523	}
		6524	static DRIVER_ATTR_RO(tur_ms_to_ready);
		6525
6490	/* Note: The following array creates attribute files in the	6526	/* Note: The following array creates attribute files in the
6491	/sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these	6527	/sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
6492	files (over those found in the /sys/module/scsi_debug/parameters	6528	files (over those found in the /sys/module/scsi_debug/parameters
@@ -6500,6 +6536,7 @@ static struct attribute *sdebug_drv_attrs[] = { · 7 unmodified lines
6500	&driver_attr_ptype.attr,	6536	&driver_attr_ptype.attr,
6501	&driver_attr_dsense.attr,	6537	&driver_attr_dsense.attr,
6502	&driver_attr_fake_rw.attr,	6538	&driver_attr_fake_rw.attr,
		6539	&driver_attr_host_max_queue.attr,
6503	&driver_attr_no_lun_0.attr,	6540	&driver_attr_no_lun_0.attr,
6504	&driver_attr_num_tgts.attr,	6541	&driver_attr_num_tgts.attr,
6505	&driver_attr_dev_size_mb.attr,	6542	&driver_attr_dev_size_mb.attr,
@@ -6528,6 +6565,7 @@ static struct attribute *sdebug_drv_attrs[] = { · 22 unmodified lines
6528	&driver_attr_strict.attr,	6565	&driver_attr_strict.attr,
6529	&driver_attr_uuid_ctl.attr,	6566	&driver_attr_uuid_ctl.attr,
6530	&driver_attr_cdb_len.attr,	6567	&driver_attr_cdb_len.attr,
		6568	&driver_attr_tur_ms_to_ready.attr,
6531	&driver_attr_zbc.attr,	6569	&driver_attr_zbc.attr,
6532	NULL,	6570	NULL,
6533	};	6571	};
@@ -6610,6 +6648,26 @@ static int __init scsi_debug_init(void) · 76 unmodified lines
6610	pr_err("submit_queues must be 1 or more\n");	6648	pr_err("submit_queues must be 1 or more\n");
6611	return -EINVAL;	6649	return -EINVAL;
6612	}	6650	}
		6651
		6652	if ((sdebug_max_queue > SDEBUG_CANQUEUE) \|\| (sdebug_max_queue < 1)) {
		6653	pr_err("max_queue must be in range [1, %d]\n", SDEBUG_CANQUEUE);
		6654	return -EINVAL;
		6655	}
		6656
		6657	if ((sdebug_host_max_queue > SDEBUG_CANQUEUE) \|\|
		6658	(sdebug_host_max_queue < 0)) {
		6659	pr_err("host_max_queue must be in range [0 %d]\n",
		6660	SDEBUG_CANQUEUE);
		6661	return -EINVAL;
		6662	}
		6663
		6664	if (sdebug_host_max_queue &&
		6665	(sdebug_max_queue != sdebug_host_max_queue)) {
		6666	sdebug_max_queue = sdebug_host_max_queue;
		6667	pr_warn("fixing max submit queue depth to host max queue depth, %d\n",
		6668	sdebug_max_queue);
		6669	}
		6670
6613	sdebug_q_arr = kcalloc(submit_queues, sizeof(struct sdebug_queue),	6671	sdebug_q_arr = kcalloc(submit_queues, sizeof(struct sdebug_queue),
6614	GFP_KERNEL);	6672	GFP_KERNEL);
6615	if (sdebug_q_arr == NULL)	6673	if (sdebug_q_arr == NULL)
@@ -7044,10 +7102,47 @@ static bool fake_timeout(struct scsi_cmnd *scp) · 428 unmodified lines
7044	return false;	7102	return false;
7045	}	7103	}
7046		7104
7047	static bool fake_host_busy(struct scsi_cmnd *scp)	7105	/* Response to TUR or media access command when device stopped */
		7106	static int resp_not_ready(struct scsi_cmnd scp, struct sdebug_dev_info devip)
7048	{	7107	{
7049	return (sdebug_opts & SDEBUG_OPT_HOST_BUSY) &&	7108	int stopped_state;
7050	(atomic_read(&sdebug_cmnd_count) % abs(sdebug_every_nth)) == 0;	7109	u64 diff_ns = 0;
		7110	ktime_t now_ts = ktime_get_boottime();
		7111	struct scsi_device *sdp = scp->device;
		7112
		7113	stopped_state = atomic_read(&devip->stopped);
		7114	if (stopped_state == 2) {
		7115	if (ktime_to_ns(now_ts) > ktime_to_ns(devip->create_ts)) {
		7116	diff_ns = ktime_to_ns(ktime_sub(now_ts, devip->create_ts));
		7117	if (diff_ns >= ((u64)sdeb_tur_ms_to_ready * 1000000)) {
		7118	/* tur_ms_to_ready timer extinguished */
		7119	atomic_set(&devip->stopped, 0);
		7120	return 0;
		7121	}
		7122	}
		7123	mk_sense_buffer(scp, NOT_READY, LOGICAL_UNIT_NOT_READY, 0x1);
		7124	if (sdebug_verbose)
		7125	sdev_printk(KERN_INFO, sdp,
		7126	"%s: Not ready: in process of becoming ready\n", my_name);
		7127	if (scp->cmnd[0] == TEST_UNIT_READY) {
		7128	u64 tur_nanosecs_to_ready = (u64)sdeb_tur_ms_to_ready * 1000000;
		7129
		7130	if (diff_ns <= tur_nanosecs_to_ready)
		7131	diff_ns = tur_nanosecs_to_ready - diff_ns;
		7132	else
		7133	diff_ns = tur_nanosecs_to_ready;
		7134	/* As per 20-061r2 approved for spc6 by T10 on 20200716 */
		7135	do_div(diff_ns, 1000000); /* diff_ns becomes milliseconds */
		7136	scsi_set_sense_information(scp->sense_buffer, SCSI_SENSE_BUFFERSIZE,
		7137	diff_ns);
		7138	return check_condition_result;
		7139	}
		7140	}
		7141	mk_sense_buffer(scp, NOT_READY, LOGICAL_UNIT_NOT_READY, 0x2);
		7142	if (sdebug_verbose)
		7143	sdev_printk(KERN_INFO, sdp, "%s: Not ready: initializing command required\n",
		7144	my_name);
		7145	return check_condition_result;
7051	}	7146	}
7052		7147
7053	static int scsi_debug_queuecommand(struct Scsi_Host *shost,	7148	static int scsi_debug_queuecommand(struct Scsi_Host *shost,
@@ -7058,7 +7153,6 @@ static int scsi_debug_queuecommand(struct Scsi_Host *shost, · 4 unmodified lines
7058	const struct opcode_info_t *oip;	7153	const struct opcode_info_t *oip;
7059	const struct opcode_info_t *r_oip;	7154	const struct opcode_info_t *r_oip;
7060	struct sdebug_dev_info *devip;	7155	struct sdebug_dev_info *devip;
7061
7062	u8 *cmd = scp->cmnd;	7156	u8 *cmd = scp->cmnd;
7063	int (r_pfp)(struct scsi_cmnd , struct sdebug_dev_info *);	7157	int (r_pfp)(struct scsi_cmnd , struct sdebug_dev_info *);
7064	int (pfp)(struct scsi_cmnd , struct sdebug_dev_info *) = NULL;	7158	int (pfp)(struct scsi_cmnd , struct sdebug_dev_info *) = NULL;
@@ -7068,10 +7162,15 @@ static int scsi_debug_queuecommand(struct Scsi_Host *shost, · 3 unmodified lines
7068	u16 sa;	7162	u16 sa;
7069	u8 opcode = cmd[0];	7163	u8 opcode = cmd[0];
7070	bool has_wlun_rl;	7164	bool has_wlun_rl;
		7165	bool inject_now;
7071		7166
7072	scsi_set_resid(scp, 0);	7167	scsi_set_resid(scp, 0);
7073	if (sdebug_statistics)	7168	if (sdebug_statistics) {
7074	atomic_inc(&sdebug_cmnd_count);	7169	atomic_inc(&sdebug_cmnd_count);
		7170	inject_now = inject_on_this_cmd();
		7171	} else {
		7172	inject_now = false;
		7173	}
7075	if (unlikely(sdebug_verbose &&	7174	if (unlikely(sdebug_verbose &&
7076	!(SDEBUG_OPT_NO_CDB_NOISE & sdebug_opts))) {	7175	!(SDEBUG_OPT_NO_CDB_NOISE & sdebug_opts))) {
7077	char b[120];	7176	char b[120];
@@ -7089,7 +7188,7 @@ static int scsi_debug_queuecommand(struct Scsi_Host *shost, · 11 unmodified lines
7089	sdev_printk(KERN_INFO, sdp, "%s: tag=%#x, cmd %s\n", my_name,	7188	sdev_printk(KERN_INFO, sdp, "%s: tag=%#x, cmd %s\n", my_name,
7090	blk_mq_unique_tag(scp->request), b);	7189	blk_mq_unique_tag(scp->request), b);
7091	}	7190	}
7092	if (fake_host_busy(scp))	7191	if (unlikely(inject_now && (sdebug_opts & SDEBUG_OPT_HOST_BUSY)))
7093	return SCSI_MLQUEUE_HOST_BUSY;	7192	return SCSI_MLQUEUE_HOST_BUSY;
7094	has_wlun_rl = (sdp->lun == SCSI_W_LUN_REPORT_LUNS);	7193	has_wlun_rl = (sdp->lun == SCSI_W_LUN_REPORT_LUNS);
7095	if (unlikely((sdp->lun >= sdebug_max_luns) && !has_wlun_rl))	7194	if (unlikely((sdp->lun >= sdebug_max_luns) && !has_wlun_rl))
@@ -7103,6 +7202,9 @@ static int scsi_debug_queuecommand(struct Scsi_Host *shost, · 7 unmodified lines
7103	if (NULL == devip)	7202	if (NULL == devip)
7104	goto err_out;	7203	goto err_out;
7105	}	7204	}
		7205	if (unlikely(inject_now && !atomic_read(&sdeb_inject_pending)))
		7206	atomic_set(&sdeb_inject_pending, 1);
		7207
7106	na = oip->num_attached;	7208	na = oip->num_attached;
7107	r_pfp = oip->pfp;	7209	r_pfp = oip->pfp;
7108	if (na) { /* multiple commands with this opcode */	7210	if (na) { /* multiple commands with this opcode */
@@ -7167,14 +7269,11 @@ static int scsi_debug_queuecommand(struct Scsi_Host *shost, · 58 unmodified lines
7167	if (errsts)	7269	if (errsts)
7168	goto check_cond;	7270	goto check_cond;
7169	}	7271	}
7170	if (unlikely((F_M_ACCESS & flags) && atomic_read(&devip->stopped))) {	7272	if (unlikely(((F_M_ACCESS & flags) \|\| scp->cmnd[0] == TEST_UNIT_READY) &&
7171	mk_sense_buffer(scp, NOT_READY, LOGICAL_UNIT_NOT_READY, 0x2);	7273	atomic_read(&devip->stopped))) {
7172	if (sdebug_verbose)	7274	errsts = resp_not_ready(scp, devip);
7173	sdev_printk(KERN_INFO, sdp, "%s reports: Not ready: "	7275	if (errsts)
7174	"%s\n", my_name, "initializing command "	7276	goto fini;
7175	"required");
7176	errsts = check_condition_result;
7177	goto fini;
7178	}	7277	}
7179	if (sdebug_fake_rw && (F_FAKE_RW & flags))	7278	if (sdebug_fake_rw && (F_FAKE_RW & flags))
7180	goto fini;	7279	goto fini;
@@ -7248,7 +7347,10 @@ static int sdebug_driver_probe(struct device *dev) · 67 unmodified lines
7248		7347
7249	sdbg_host = to_sdebug_host(dev);	7348	sdbg_host = to_sdebug_host(dev);
7250		7349
7251	sdebug_driver_template.can_queue = sdebug_max_queue;	7350	if (sdebug_host_max_queue)
		7351	sdebug_driver_template.can_queue = sdebug_host_max_queue;
		7352	else
		7353	sdebug_driver_template.can_queue = sdebug_max_queue;
7252	if (!sdebug_clustering)	7354	if (!sdebug_clustering)
7253	sdebug_driver_template.dma_boundary = PAGE_SIZE - 1;	7355	sdebug_driver_template.dma_boundary = PAGE_SIZE - 1;
7254		7356
@@ -7263,9 +7365,13 @@ static int sdebug_driver_probe(struct device *dev) · 8 unmodified lines
7263	my_name, submit_queues, nr_cpu_ids);	7365	my_name, submit_queues, nr_cpu_ids);
7264	submit_queues = nr_cpu_ids;	7366	submit_queues = nr_cpu_ids;
7265	}	7367	}
7266	/* Decide whether to tell scsi subsystem that we want mq */	7368	/*
7267	/* Following should give the same answer for each host */	7369	* Decide whether to tell scsi subsystem that we want mq. The
7268	hpnt->nr_hw_queues = submit_queues;	7370	* following should give the same answer for each host. If the host
		7371	* has a limit of hostwide max commands, then do not set.
		7372	*/
		7373	if (!sdebug_host_max_queue)
		7374	hpnt->nr_hw_queues = submit_queues;
7269		7375
7270	sdbg_host->shost = hpnt;	7376	sdbg_host->shost = hpnt;
7271	((struct sdebug_host_info *)hpnt->hostdata) = sdbg_host;	7377	((struct sdebug_host_info *)hpnt->hostdata) = sdbg_host;

drivers/scsi/scsi_lib.c+24−38

 #define  SCSI_INLINE_SG_CNT  2
 #endif
-static struct kmem_cache *scsi_sdb_cache;
 static struct kmem_cache *scsi_sense_cache;
 static struct kmem_cache *scsi_sense_isadma_cache;
 static DEFINE_MUTEX(scsi_sense_cache_mutex);
 		spin_unlock_irqrestore(shost->host_lock, flags);
 		scsi_kick_queue(sdev->request_queue);
 		spin_lock_irqsave(shost->host_lock, flags);
 		scsi_device_put(sdev);
 	}
  out:
 	scsi_log_completion(cmd, disposition);
 	switch (disposition) {
-		case SUCCESS:
+	case SUCCESS:
-			scsi_finish_command(cmd);
+		scsi_finish_command(cmd);
-			break;
+		break;
-		case NEEDS_RETRY:
+	case NEEDS_RETRY:
-			scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY);
+		scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY);
-			break;
+		break;
-		case ADD_TO_MLQUEUE:
+	case ADD_TO_MLQUEUE:
-			scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
+		scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
-			break;
+		break;
-		default:
+	default:
-			scsi_eh_scmd_add(cmd);
+		scsi_eh_scmd_add(cmd);
-			break;
+		break;
 	}
 }
 }
 EXPORT_SYMBOL(scsi_unblock_requests);
-int __init scsi_init_queue(void)
-{
-	scsi_sdb_cache = kmem_cache_create("scsi_data_buffer",
-					   sizeof(struct scsi_data_buffer),
-					   0, 0, NULL);
-	if (!scsi_sdb_cache) {
-		printk(KERN_ERR "SCSI: can't init scsi sdb cache\n");
-		return -ENOMEM;
-	}
-	return 0;
-}
 void scsi_exit_queue(void)
 {
 	kmem_cache_destroy(scsi_sense_cache);
 	kmem_cache_destroy(scsi_sense_isadma_cache);
-	kmem_cache_destroy(scsi_sdb_cache);
 }
 /**
 		real_buffer[1] = data->medium_type;
 		real_buffer[2] = data->device_specific;
 		real_buffer[3] = data->block_descriptor_length;
 		cmd[0] = MODE_SELECT;
 		cmd[4] = len;
 		if (scsi_sense_valid(sshdr)) {
 			if ((sshdr->sense_key == ILLEGAL_REQUEST) &&
 			    (sshdr->asc == 0x20) && (sshdr->ascq == 0)) {
 				/*
 				 * Invalid command operation code
 				 */
 				sdev->use_10_for_ms = 0;
 		}
 	}
-	if(scsi_status_is_good(result)) {
+	if (scsi_status_is_good(result)) {
 		if (unlikely(buffer[0] == 0x86 && buffer[1] == 0x0b &&
 			     (modepage == 6 || modepage == 8))) {
 			/* Initio breakage? */
 			data->device_specific = 0;
 			data->longlba = 0;
 			data->block_descriptor_length = 0;
-		} else if(use_10_for_ms) {
+		} else if (use_10_for_ms) {
 			data->length = buffer[0]*256 + buffer[1] + 2;
 			data->medium_type = buffer[2];
 			data->device_specific = buffer[3];
 			goto illegal;
 		}
 		break;
 	case SDEV_RUNNING:
 		switch (oldstate) {
 		case SDEV_CREATED:
  *	(which must be a legal transition).  When the device is in this
  *	state, only special requests will be accepted, all others will
  *	be deferred.  Since special requests may also be requeued requests,
  *	a successful return doesn't guarantee the device will be
  *	totally quiescent.
  *
  *	Must be called with user context, may sleep.
 			return err;
 	}
 	/*
 	 * The device has transitioned to SDEV_BLOCK.  Stop the
 	 * block layer from calling the midlayer with this device's
 	 * request queue.
 	 */
 	blk_mq_quiesce_queue_nowait(q);
 	return 0;
 	return err;
 }
 void scsi_start_queue(struct scsi_device *sdev)
 {
 	struct request_queue *q = sdev->request_queue;
 		mutex_lock(&sdev->state_mutex);
 		ret = scsi_internal_device_block_nowait(sdev);
 		mutex_unlock(&sdev->state_mutex);
-		if (ret)
+		if (ret) {
+			scsi_device_put(sdev);
 			break;
+		}
 	}
 	/*

drivers/scsi/scsi_logging.c+2−6

 		/* Print opcode in one line and use separate lines for CDB */
 		off += scnprintf(logbuf + off, logbuf_len - off, "\n");
 		dev_printk(KERN_INFO, &cmd->device->sdev_gendev, "%s", logbuf);
-		scsi_log_release_buffer(logbuf);
 		for (k = 0; k < cmd->cmd_len; k += 16) {
 			size_t linelen = min(cmd->cmd_len - k, 16);
-			logbuf = scsi_log_reserve_buffer(&logbuf_len);
-			if (!logbuf)
-				break;
 			off = sdev_format_header(logbuf, logbuf_len,
 						 scmd_name(cmd),
 						 cmd->request->tag);
 			}
 			dev_printk(KERN_INFO, &cmd->device->sdev_gendev, "%s",
 				   logbuf);
-			scsi_log_release_buffer(logbuf);
 		}
-		return;
+		goto out;
 	}
 	if (!WARN_ON(off > logbuf_len - 49)) {
 		off += scnprintf(logbuf + off, logbuf_len - off, " ");
 	}
 out_printk:
 	dev_printk(KERN_INFO, &cmd->device->sdev_gendev, "%s", logbuf);
+out:
 	scsi_log_release_buffer(logbuf);
 }
 EXPORT_SYMBOL(scsi_print_command);

drivers/scsi/scsi_pm.c+2−8

@@ -80,10 +80,6 @@ static int scsi_dev_type_resume(struct device *dev, · 79 unmodified lines
80	dev_dbg(dev, "scsi resume: %d\n", err);	80	dev_dbg(dev, "scsi resume: %d\n", err);
81		81
82	if (err == 0) {	82	if (err == 0) {
83	bool was_runtime_suspended;
84
85	was_runtime_suspended = pm_runtime_suspended(dev);
86
87	pm_runtime_disable(dev);	83	pm_runtime_disable(dev);
88	err = pm_runtime_set_active(dev);	84	err = pm_runtime_set_active(dev);
89	pm_runtime_enable(dev);	85	pm_runtime_enable(dev);
@@ -97,10 +93,8 @@ static int scsi_dev_type_resume(struct device *dev, · 7 unmodified lines
97	*/	93	*/
98	if (!err && scsi_is_sdev_device(dev)) {	94	if (!err && scsi_is_sdev_device(dev)) {
99	struct scsi_device *sdev = to_scsi_device(dev);	95	struct scsi_device *sdev = to_scsi_device(dev);
100	if (was_runtime_suspended)	96
101	blk_post_runtime_resume(sdev->request_queue, 0);	97	blk_set_runtime_active(sdev->request_queue);
102	else
103	blk_set_runtime_active(sdev->request_queue);
104	}	98	}
105	}	99	}
106		100

drivers/scsi/scsi_priv.h+0−1

@@ -93,7 +93,6 @@ extern struct request_queue scsi_mq_alloc_queue(struct scsi_device sdev); · 92 unmodified lines
93	extern void scsi_start_queue(struct scsi_device *sdev);	93	extern void scsi_start_queue(struct scsi_device *sdev);
94	extern int scsi_mq_setup_tags(struct Scsi_Host *shost);	94	extern int scsi_mq_setup_tags(struct Scsi_Host *shost);
95	extern void scsi_mq_destroy_tags(struct Scsi_Host *shost);	95	extern void scsi_mq_destroy_tags(struct Scsi_Host *shost);
96	extern int scsi_init_queue(void);
97	extern void scsi_exit_queue(void);	96	extern void scsi_exit_queue(void);
98	extern void scsi_evt_thread(struct work_struct *work);	97	extern void scsi_evt_thread(struct work_struct *work);
99	struct request_queue;	98	struct request_queue;

drivers/scsi/scsi_transport_iscsi.c+16−15

 static DEFINE_MUTEX(conn_mutex);
 static LIST_HEAD(sesslist);
-static LIST_HEAD(sessdestroylist);
 static DEFINE_SPINLOCK(sesslock);
 static LIST_HEAD(connlist);
 static LIST_HEAD(connlist_err);
 {
 	queue_work(iscsi_eh_timer_workq, &session->unblock_work);
 	/*
-	 * make sure all the events have completed before tell the driver
+	 * Blocking the session can be done from any context so we only
-	 * it is safe
+	 * queue the block work. Make sure the unblock work has completed
+	 * because it flushes/cancels the other works and updates the state.
 	 */
-	flush_workqueue(iscsi_eh_timer_workq);
+	flush_work(&session->unblock_work);
 }
 EXPORT_SYMBOL_GPL(iscsi_unblock_session);
 	spin_unlock_irqrestore(&session->lock, flags);
 	mutex_unlock(&ihost->mutex);
+	scsi_remove_target(&session->dev);
 	if (session->ida_used)
 		ida_simple_remove(&iscsi_sess_ida, target_id);
-	scsi_remove_target(&session->dev);
 unbind_session_exit:
 	iscsi_session_event(session, ISCSI_KEVENT_UNBIND_SESSION);
 	ISCSI_DBG_TRANS_SESSION(session, "Completed target removal\n");
 	ISCSI_DBG_TRANS_SESSION(session, "Removing session\n");
 	spin_lock_irqsave(&sesslock, flags);
-	list_del(&session->sess_list);
+	if (!list_empty(&session->sess_list))
+		list_del(&session->sess_list);
 	spin_unlock_irqrestore(&sesslock, flags);
-	/* make sure there are no blocks/unblocks queued */
+	flush_work(&session->block_work);
-	flush_workqueue(iscsi_eh_timer_workq);
+	flush_work(&session->unblock_work);
-	/* make sure the timedout callout is not running */
+	cancel_delayed_work_sync(&session->recovery_work);
-	if (!cancel_delayed_work(&session->recovery_work))
-		flush_workqueue(iscsi_eh_timer_workq);
 	/*
 	 * If we are blocked let commands flow again. The lld or iscsi
 	 * layer should set up the queuecommand to fail commands.
 		pr_err("%s could not find host no %u\n",
 		       __func__, ev->u.set_flashnode.host_no);
 		err = -ENODEV;
-		goto put_host;
+		goto exit_set_fnode;
 	}
 	idx = ev->u.set_flashnode.flashnode_idx;
 			/* Prevent this session from being found again */
 			spin_lock_irqsave(&sesslock, flags);
-			list_move(&session->sess_list, &sessdestroylist);
+			list_del_init(&session->sess_list);
 			spin_unlock_irqrestore(&sesslock, flags);
 			queue_work(iscsi_destroy_workq, &session->destroy_work);
 		goto release_nls;
 	}
-	iscsi_destroy_workq = create_singlethread_workqueue("iscsi_destroy");
+	iscsi_destroy_workq = alloc_workqueue("%s",
+			WQ_SYSFS | __WQ_LEGACY | WQ_MEM_RECLAIM | WQ_UNBOUND,
+			1, "iscsi_destroy");
 	if (!iscsi_destroy_workq) {
 		err = -ENOMEM;
 		goto destroy_wq;

drivers/scsi/scsi_transport_sas.c+1−1

@@ -563,7 +563,7 @@ show_sas_phy_enable(struct device dev, struct device_attribute attr, · 562 unmodified lines
563	{	563	{
564	struct sas_phy *phy = transport_class_to_phy(dev);	564	struct sas_phy *phy = transport_class_to_phy(dev);
565		565
566	return snprintf(buf, 20, "%d", phy->enabled);	566	return snprintf(buf, 20, "%d\n", phy->enabled);
567	}	567	}
568		568
569	static DEVICE_ATTR(enable, S_IRUGO \| S_IWUSR, show_sas_phy_enable,	569	static DEVICE_ATTR(enable, S_IRUGO \| S_IWUSR, show_sas_phy_enable,

drivers/scsi/scsi_transport_srp.c+5−7

@@ -395,6 +395,10 @@ static void srp_reconnect_work(struct work_struct *work) · 394 unmodified lines
395	}	395	}
396	}	396	}
397		397
		398	/*
		399	* scsi_target_block() must have been called before this function is
		400	* called to guarantee that no .queuecommand() calls are in progress.
		401	*/
398	static void __rport_fail_io_fast(struct srp_rport *rport)	402	static void __rport_fail_io_fast(struct srp_rport *rport)
399	{	403	{
400	struct Scsi_Host *shost = rport_to_shost(rport);	404	struct Scsi_Host *shost = rport_to_shost(rport);
@@ -404,11 +408,7 @@ static void __rport_fail_io_fast(struct srp_rport *rport) · 3 unmodified lines
404		408
405	if (srp_rport_set_state(rport, SRP_RPORT_FAIL_FAST))	409	if (srp_rport_set_state(rport, SRP_RPORT_FAIL_FAST))
406	return;	410	return;
407	/*	411
408	* Call scsi_target_block() to wait for ongoing shost->queuecommand()
409	* calls before invoking i->f->terminate_rport_io().
410	*/
411	scsi_target_block(rport->dev.parent);
412	scsi_target_unblock(rport->dev.parent, SDEV_TRANSPORT_OFFLINE);	412	scsi_target_unblock(rport->dev.parent, SDEV_TRANSPORT_OFFLINE);
413		413
414	/* Involve the LLD if possible to terminate all I/O on the rport. */	414	/* Involve the LLD if possible to terminate all I/O on the rport. */
@@ -570,8 +570,6 @@ int srp_reconnect_rport(struct srp_rport *rport) · 155 unmodified lines
570	* failure timers if these had not yet been started.	570	* failure timers if these had not yet been started.
571	*/	571	*/
572	__rport_fail_io_fast(rport);	572	__rport_fail_io_fast(rport);
573	scsi_target_unblock(&shost->shost_gendev,
574	SDEV_TRANSPORT_OFFLINE);
575	__srp_start_tl_fail_timers(rport);	573	__srp_start_tl_fail_timers(rport);

2 more lines aren’t shown here.

drivers/scsi/sd.c+1−1

This diff is large: its 9 lines aren’t shown here.

drivers/scsi/sd.h+0−6

This diff is large: its 18 lines aren’t shown here.

drivers/scsi/sd_zbc.c+1−2

This diff is large: its 17 lines aren’t shown here.

drivers/scsi/storvsc_drv.c+12−1

This diff is large: its 48 lines aren’t shown here.

drivers/scsi/sym53c8xx_2/sym_glue.c+1−0

This diff is large: its 8 lines aren’t shown here.

drivers/scsi/sym53c8xx_2/sym_hipd.c+8−0

This diff is large: its 50 lines aren’t shown here.

drivers/scsi/ufs/Kconfig+22−0

This diff is large: its 33 lines aren’t shown here.

drivers/scsi/ufs/Makefile+5−1

This diff is large: its 16 lines aren’t shown here.

drivers/scsi/ufs/ufs-exynos.c+1297−0

This diff is large: its 1298 lines aren’t shown here.

drivers/scsi/ufs/ufs-exynos.h+287−0

This diff is large: its 288 lines aren’t shown here.

drivers/scsi/ufs/ufs-mediatek.c+112−28

This diff is large: its 270 lines aren’t shown here.

drivers/scsi/ufs/ufs-mediatek.h+3−1

This diff is large: its 25 lines aren’t shown here.

drivers/scsi/ufs/ufs-qcom-ice.c+245−0

This diff is large: its 246 lines aren’t shown here.

drivers/scsi/ufs/ufs-qcom.c+16−5

This diff is large: its 84 lines aren’t shown here.

drivers/scsi/ufs/ufs-qcom.h+27−0

This diff is large: its 39 lines aren’t shown here.

drivers/scsi/ufs/ufs.h+2−36

This diff is large: its 63 lines aren’t shown here.

drivers/scsi/ufs/ufs_bsg.c+2−3

This diff is large: its 16 lines aren’t shown here.

drivers/scsi/ufs/ufs_quirks.h+9−1

This diff is large: its 24 lines aren’t shown here.

drivers/scsi/ufs/ufshcd-crypto.c+245−0

This diff is large: its 246 lines aren’t shown here.

drivers/scsi/ufs/ufshcd-crypto.h+77−0

This diff is large: its 78 lines aren’t shown here.

drivers/scsi/ufs/ufshcd-pci.c+1−24

This diff is large: its 36 lines aren’t shown here.

drivers/scsi/ufs/ufshcd-pltfrm.c+1−26

This diff is large: its 38 lines aren’t shown here.

drivers/scsi/ufs/ufshcd.c+290−251

This diff is large: its 1063 lines aren’t shown here.

drivers/scsi/ufs/ufshcd.h+61−44

This diff is large: its 222 lines aren’t shown here.

drivers/scsi/ufs/ufshci.h+66−28

This diff is large: its 150 lines aren’t shown here.

drivers/scsi/ufs/unipro.h+33−0

This diff is large: its 54 lines aren’t shown here.

drivers/scsi/virtio_scsi.c+13−9

This diff is large: its 43 lines aren’t shown here.

drivers/target/iscsi/cxgbit/cxgbit.h+0−1

This diff is large: its 8 lines aren’t shown here.

drivers/target/iscsi/cxgbit/cxgbit_cm.c+24−10

This diff is large: its 69 lines aren’t shown here.

drivers/target/iscsi/cxgbit/cxgbit_target.c+4−20

This diff is large: its 44 lines aren’t shown here.

drivers/target/iscsi/iscsi_target_nego.c+31−5

This diff is large: its 70 lines aren’t shown here.

drivers/target/target_core_fabric_lib.c+50−55

This diff is large: its 166 lines aren’t shown here.

drivers/target/target_core_internal.h+1−0

This diff is large: its 8 lines aren’t shown here.

drivers/target/target_core_pr.c+34−27

This diff is large: its 128 lines aren’t shown here.

drivers/target/target_core_tmr.c+28−8

This diff is large: its 77 lines aren’t shown here.

drivers/target/target_core_transport.c+7−1

This diff is large: its 29 lines aren’t shown here.

drivers/target/target_core_user.c+325−72

This diff is large: its 665 lines aren’t shown here.

drivers/target/target_core_xcopy.c+9−2

This diff is large: its 30 lines aren’t shown here.

include/linux/qcom_scm.h+19−0

This diff is large: its 40 lines aren’t shown here.

include/scsi/fc/fc_ms.h+2−2

This diff is large: its 11 lines aren’t shown here.

include/scsi/scsi_tcq.h+1−1

This diff is large: its 9 lines aren’t shown here.

include/scsi/scsi_transport_iscsi.h+1−1

This diff is large: its 9 lines aren’t shown here.

include/target/iscsi/iscsi_target_core.h+5−4

This diff is large: its 16 lines aren’t shown here.

include/target/target_core_backend.h+2−0

This diff is large: its 9 lines aren’t shown here.

include/target/target_core_base.h+1−0

This diff is large: its 8 lines aren’t shown here.

include/trace/events/ufs.h+31−0

This diff is large: its 38 lines aren’t shown here.

include/uapi/linux/target_core_user.h+25−0

This diff is large: its 46 lines aren’t shown here.

include/uapi/scsi/fc/fc_els.h+2−0

This diff is large: its 16 lines aren’t shown here.

@@ -337,7 +337,7 @@ static void fc_disc_error(struct fc_disc disc, struct fc_frame fp) · 336 unmodified lines
337		337
338	/**	338	/**
339	* fc_disc_gpn_ft_req() - Send Get Port Names by FC-4 type (GPN_FT) request	339	* fc_disc_gpn_ft_req() - Send Get Port Names by FC-4 type (GPN_FT) request
340	* @lport: The discovery context	340	* @disc: The discovery context
341	*/	341	*/
342	static void fc_disc_gpn_ft_req(struct fc_disc *disc)	342	static void fc_disc_gpn_ft_req(struct fc_disc *disc)
343	{	343	{
@@ -370,7 +370,7 @@ err: · 26 unmodified lines
370		370
371	/**	371	/**
372	* fc_disc_gpn_ft_parse() - Parse the body of the dNS GPN_FT response.	372	* fc_disc_gpn_ft_parse() - Parse the body of the dNS GPN_FT response.
373	* @lport: The local port the GPN_FT was received on	373	* @disc: The discovery context
374	* @buf: The GPN_FT response buffer	374	* @buf: The GPN_FT response buffer
375	* @len: The size of response buffer	375	* @len: The size of response buffer
376	*	376	*
@@ -488,7 +488,7 @@ static void fc_disc_timeout(struct work_struct *work) · 111 unmodified lines
488	* fc_disc_gpn_ft_resp() - Handle a response frame from Get Port Names (GPN_FT)	488	* fc_disc_gpn_ft_resp() - Handle a response frame from Get Port Names (GPN_FT)
489	* @sp: The sequence that the GPN_FT response was received on	489	* @sp: The sequence that the GPN_FT response was received on
490	* @fp: The GPN_FT response frame	490	* @fp: The GPN_FT response frame
491	* @lp_arg: The discovery context	491	* @disc_arg: The discovery context
492	*	492	*
493	* Locking Note: This function is called without disc mutex held, and	493	* Locking Note: This function is called without disc mutex held, and
494	* should do all its processing with the mutex held	494	* should do all its processing with the mutex held