lael-labs/linux

Documentation/scsi/ufs.txt+20−0

@@ -128,6 +128,26 @@ The current UFSHCD implementation supports following functionality, · 127 unmodified lines
128	In this version of UFSHCD Query requests and power management	128	In this version of UFSHCD Query requests and power management
129	functionality are not implemented.	129	functionality are not implemented.
130		130
		131	4. BSG Support
		132	------------------
		133
		134	This transport driver supports exchanging UFS protocol information units
		135	(UPIUs) with a UFS device. Typically, user space will allocate
		136	struct ufs_bsg_request and struct ufs_bsg_reply (see ufs_bsg.h) as
		137	request_upiu and reply_upiu respectively. Filling those UPIUs should
		138	be done in accordance with JEDEC spec UFS2.1 paragraph 10.7.
		139	Caveat emptor: The driver makes no further input validations and sends the
		140	UPIU to the device as it is. Open the bsg device in /dev/ufs-bsg and
		141	send SG_IO with the applicable sg_io_v4:
		142
		143	io_hdr_v4.guard = 'Q';
		144	io_hdr_v4.protocol = BSG_PROTOCOL_SCSI;
		145	io_hdr_v4.subprotocol = BSG_SUB_PROTOCOL_SCSI_TRANSPORT;
		146	io_hdr_v4.response = (__u64)reply_upiu;
		147	io_hdr_v4.max_response_len = reply_len;
		148	io_hdr_v4.request_len = request_len;
		149	io_hdr_v4.request = (__u64)request_upiu;
		150
131	UFS Specifications can be found at,	151	UFS Specifications can be found at,
132	UFS - http://www.jedec.org/sites/default/files/docs/JESD220.pdf	152	UFS - http://www.jedec.org/sites/default/files/docs/JESD220.pdf
133	UFSHCI - http://www.jedec.org/sites/default/files/docs/JESD223.pdf	153	UFSHCI - http://www.jedec.org/sites/default/files/docs/JESD223.pdf

MAINTAINERS+8−1

@@ -4055,7 +4055,7 @@ M: Uma Krishnan <ukrishn@linux.vnet.ibm.com> · 4054 unmodified lines
4055	L: linux-scsi@vger.kernel.org	4055	L: linux-scsi@vger.kernel.org
4056	S: Supported	4056	S: Supported
4057	F: drivers/scsi/cxlflash/	4057	F: drivers/scsi/cxlflash/
4058	F: include/uapi/scsi/cxlflash_ioctls.h	4058	F: include/uapi/scsi/cxlflash_ioctl.h
4059	F: Documentation/powerpc/cxlflash.txt	4059	F: Documentation/powerpc/cxlflash.txt
4060		4060
4061	CYBERPRO FB DRIVER	4061	CYBERPRO FB DRIVER
@@ -10011,6 +10011,13 @@ S: Supported · 5949 unmodified lines
10011	F: drivers/gpu/drm/mxsfb/	10011	F: drivers/gpu/drm/mxsfb/
10012	F: Documentation/devicetree/bindings/display/mxsfb.txt	10012	F: Documentation/devicetree/bindings/display/mxsfb.txt
10013		10013
		10014	MYLEX DAC960 PCI RAID Controller
		10015	M: Hannes Reinecke <hare@kernel.org>
		10016	L: linux-scsi@vger.kernel.org
		10017	S: Supported
		10018	F: drivers/scsi/myrb.*
		10019	F: drivers/scsi/myrs.*
		10020
10014	MYRICOM MYRI-10G 10GbE DRIVER (MYRI10GE)	10021	MYRICOM MYRI-10G 10GbE DRIVER (MYRI10GE)
10015	M: Chris Lee <christopher.lee@cspi.com>	10022	M: Chris Lee <christopher.lee@cspi.com>
10016	L: netdev@vger.kernel.org	10023	L: netdev@vger.kernel.org

drivers/message/fusion/lsi/mpi_cnfg.h+1−1

@@ -2004,7 +2004,7 @@ typedef struct _CONFIG_PAGE_FC_PORT_6 · 2003 unmodified lines
2004	U64 LinkFailureCount; /* 50h */	2004	U64 LinkFailureCount; /* 50h */
2005	U64 LossOfSyncCount; /* 58h */	2005	U64 LossOfSyncCount; /* 58h */
2006	U64 LossOfSignalCount; /* 60h */	2006	U64 LossOfSignalCount; /* 60h */
2007	U64 PrimativeSeqErrCount; /* 68h */	2007	U64 PrimitiveSeqErrCount; /* 68h */
2008	U64 InvalidTxWordCount; /* 70h */	2008	U64 InvalidTxWordCount; /* 70h */
2009	U64 InvalidCrcCount; /* 78h */	2009	U64 InvalidCrcCount; /* 78h */
2010	U64 FcpInitiatorIoCount; /* 80h */	2010	U64 FcpInitiatorIoCount; /* 80h */

drivers/message/fusion/mptbase.c+6−6

@@ -335,11 +335,11 @@ static int mpt_remove_dead_ioc_func(void *arg) · 334 unmodified lines
335	MPT_ADAPTER ioc = (MPT_ADAPTER )arg;	335	MPT_ADAPTER ioc = (MPT_ADAPTER )arg;
336	struct pci_dev *pdev;	336	struct pci_dev *pdev;
337		337
338	if ((ioc == NULL))	338	if (!ioc)
339	return -1;	339	return -1;
340		340
341	pdev = ioc->pcidev;	341	pdev = ioc->pcidev;
342	if ((pdev == NULL))	342	if (!pdev)
343	return -1;	343	return -1;
344		344
345	pci_stop_and_remove_bus_device_locked(pdev);	345	pci_stop_and_remove_bus_device_locked(pdev);
@@ -7570,11 +7570,11 @@ mpt_display_event_info(MPT_ADAPTER ioc, EventNotificationReply_t pEventReply) · 7224 unmodified lines
7570	u8 phy_num = (u8)(evData0);	7570	u8 phy_num = (u8)(evData0);
7571	u8 port_num = (u8)(evData0 >> 8);	7571	u8 port_num = (u8)(evData0 >> 8);
7572	u8 port_width = (u8)(evData0 >> 16);	7572	u8 port_width = (u8)(evData0 >> 16);
7573	u8 primative = (u8)(evData0 >> 24);	7573	u8 primitive = (u8)(evData0 >> 24);
7574	snprintf(evStr, EVENT_DESCR_STR_SZ,	7574	snprintf(evStr, EVENT_DESCR_STR_SZ,
7575	"SAS Broadcase Primative: phy=%d port=%d "	7575	"SAS Broadcast Primitive: phy=%d port=%d "
7576	"width=%d primative=0x%02x",	7576	"width=%d primitive=0x%02x",
7577	phy_num, port_num, port_width, primative);	7577	phy_num, port_num, port_width, primitive);
7578	break;	7578	break;
7579	}	7579	}
7580		7580

drivers/message/fusion/mptsas.c+4−4

drivers/scsi/3w-9xxx.c+24−26

@@ -518,7 +518,8 @@ static int twa_allocate_memory(TW_Device_Extension *tw_dev, int size, int which) · 517 unmodified lines
518	unsigned long *cpu_addr;	518	unsigned long *cpu_addr;
519	int retval = 1;	519	int retval = 1;
520		520
521	cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);	521	cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev,
		522	size * TW_Q_LENGTH, &dma_handle, GFP_KERNEL);
522	if (!cpu_addr) {	523	if (!cpu_addr) {
523	TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");	524	TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
524	goto out;	525	goto out;
@@ -526,7 +527,8 @@ static int twa_allocate_memory(TW_Device_Extension *tw_dev, int size, int which) · 1 unmodified line
526		527
527	if ((unsigned long)cpu_addr % (TW_ALIGNMENT_9000)) {	528	if ((unsigned long)cpu_addr % (TW_ALIGNMENT_9000)) {
528	TW_PRINTK(tw_dev->host, TW_DRIVER, 0x6, "Failed to allocate correctly aligned memory");	529	TW_PRINTK(tw_dev->host, TW_DRIVER, 0x6, "Failed to allocate correctly aligned memory");
529	pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle);	530	dma_free_coherent(&tw_dev->tw_pci_dev->dev, size * TW_Q_LENGTH,
		531	cpu_addr, dma_handle);
530	goto out;	532	goto out;
531	}	533	}
532		534
@@ -1027,16 +1029,16 @@ out: · 494 unmodified lines
1027	static void twa_free_device_extension(TW_Device_Extension *tw_dev)	1029	static void twa_free_device_extension(TW_Device_Extension *tw_dev)
1028	{	1030	{
1029	if (tw_dev->command_packet_virt[0])	1031	if (tw_dev->command_packet_virt[0])
1030	pci_free_consistent(tw_dev->tw_pci_dev,	1032	dma_free_coherent(&tw_dev->tw_pci_dev->dev,
1031	sizeof(TW_Command_Full)*TW_Q_LENGTH,	1033	sizeof(TW_Command_Full) * TW_Q_LENGTH,
1032	tw_dev->command_packet_virt[0],	1034	tw_dev->command_packet_virt[0],
1033	tw_dev->command_packet_phys[0]);	1035	tw_dev->command_packet_phys[0]);
1034		1036
1035	if (tw_dev->generic_buffer_virt[0])	1037	if (tw_dev->generic_buffer_virt[0])
1036	pci_free_consistent(tw_dev->tw_pci_dev,	1038	dma_free_coherent(&tw_dev->tw_pci_dev->dev,
1037	TW_SECTOR_SIZE*TW_Q_LENGTH,	1039	TW_SECTOR_SIZE * TW_Q_LENGTH,
1038	tw_dev->generic_buffer_virt[0],	1040	tw_dev->generic_buffer_virt[0],
1039	tw_dev->generic_buffer_phys[0]);	1041	tw_dev->generic_buffer_phys[0]);
1040		1042
1041	kfree(tw_dev->event_queue[0]);	1043	kfree(tw_dev->event_queue[0]);
1042	} /* End twa_free_device_extension() */	1044	} /* End twa_free_device_extension() */
@@ -2015,14 +2017,12 @@ static int twa_probe(struct pci_dev pdev, const struct pci_device_id dev_id) · 972 unmodified lines
2015	pci_set_master(pdev);	2017	pci_set_master(pdev);
2016	pci_try_set_mwi(pdev);	2018	pci_try_set_mwi(pdev);
2017		2019
2018	if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))	2020	if (dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)) \|\|
2019	\|\| pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))	2021	dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32))) {
2020	if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))	2022	TW_PRINTK(host, TW_DRIVER, 0x23, "Failed to set dma mask");
2021	\|\| pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {	2023	retval = -ENODEV;
2022	TW_PRINTK(host, TW_DRIVER, 0x23, "Failed to set dma mask");	2024	goto out_disable_device;
2023	retval = -ENODEV;	2025	}
2024	goto out_disable_device;
2025	}
2026		2026
2027	host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));	2027	host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
2028	if (!host) {	2028	if (!host) {
@@ -2237,14 +2237,12 @@ static int twa_resume(struct pci_dev *pdev) · 208 unmodified lines
2237	pci_set_master(pdev);	2237	pci_set_master(pdev);
2238	pci_try_set_mwi(pdev);	2238	pci_try_set_mwi(pdev);
2239		2239
2240	if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))	2240	if (dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)) \|\|
2241	\|\| pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))	2241	dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32))) {
2242	if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))	2242	TW_PRINTK(host, TW_DRIVER, 0x40, "Failed to set dma mask during resume");
2243	\|\| pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {	2243	retval = -ENODEV;
2244	TW_PRINTK(host, TW_DRIVER, 0x40, "Failed to set dma mask during resume");	2244	goto out_disable_device;
2245	retval = -ENODEV;	2245	}
2246	goto out_disable_device;
2247	}
2248		2246
2249	/* Initialize the card */	2247	/* Initialize the card */
2250	if (twa_reset_sequence(tw_dev, 0)) {	2248	if (twa_reset_sequence(tw_dev, 0)) {

drivers/scsi/3w-sas.c+17−21

 	unsigned long *cpu_addr;
 	int retval = 1;
-	cpu_addr = pci_zalloc_consistent(tw_dev->tw_pci_dev, size * TW_Q_LENGTH,
+	cpu_addr = dma_zalloc_coherent(&tw_dev->tw_pci_dev->dev,
-					 &dma_handle);
+			size * TW_Q_LENGTH, &dma_handle, GFP_KERNEL);
 	if (!cpu_addr) {
 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
 		goto out;
 static void twl_free_device_extension(TW_Device_Extension *tw_dev)
 {
 	if (tw_dev->command_packet_virt[0])
-		pci_free_consistent(tw_dev->tw_pci_dev,
+		dma_free_coherent(&tw_dev->tw_pci_dev->dev,
 				    sizeof(TW_Command_Full)*TW_Q_LENGTH,
 				    tw_dev->command_packet_virt[0],
 				    tw_dev->command_packet_phys[0]);
 	if (tw_dev->generic_buffer_virt[0])
-		pci_free_consistent(tw_dev->tw_pci_dev,
+		dma_free_coherent(&tw_dev->tw_pci_dev->dev,
 				    TW_SECTOR_SIZE*TW_Q_LENGTH,
 				    tw_dev->generic_buffer_virt[0],
 				    tw_dev->generic_buffer_phys[0]);
 	if (tw_dev->sense_buffer_virt[0])
-		pci_free_consistent(tw_dev->tw_pci_dev,
+		dma_free_coherent(&tw_dev->tw_pci_dev->dev,
 				    sizeof(TW_Command_Apache_Header)*
 				    TW_Q_LENGTH,
 				    tw_dev->sense_buffer_virt[0],
 	pci_set_master(pdev);
 	pci_try_set_mwi(pdev);
-	if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
+	if (dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)) ||
-	    || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
+	    dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32))) {
-		if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
+		TW_PRINTK(host, TW_DRIVER, 0x18, "Failed to set dma mask");
-		    || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
+		retval = -ENODEV;
-			TW_PRINTK(host, TW_DRIVER, 0x18, "Failed to set dma mask");
+		goto out_disable_device;
-			retval = -ENODEV;
+	}
-			goto out_disable_device;
-		}
 	host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
 	if (!host) {
 	pci_set_master(pdev);
 	pci_try_set_mwi(pdev);
-	if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
+	if (dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)) ||
-	    || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
+	    dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32))) {
-		if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
+		TW_PRINTK(host, TW_DRIVER, 0x25, "Failed to set dma mask during resume");
-		    || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
+		retval = -ENODEV;
-			TW_PRINTK(host, TW_DRIVER, 0x25, "Failed to set dma mask during resume");
+		goto out_disable_device;
-			retval = -ENODEV;
+	}
-			goto out_disable_device;
-		}
 	/* Initialize the card */
 	if (twl_reset_sequence(tw_dev, 0)) {

drivers/scsi/3w-xxxx.c+14−6

 	dprintk(KERN_NOTICE "3w-xxxx: tw_allocate_memory()\n");
-	cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);
+	cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev,
+			size * TW_Q_LENGTH, &dma_handle, GFP_KERNEL);
 	if (cpu_addr == NULL) {
-		printk(KERN_WARNING "3w-xxxx: pci_alloc_consistent() failed.\n");
+		printk(KERN_WARNING "3w-xxxx: dma_alloc_coherent() failed.\n");
 		return 1;
 	}
 	if ((unsigned long)cpu_addr % (tw_dev->tw_pci_dev->device == TW_DEVICE_ID ? TW_ALIGNMENT_6000 : TW_ALIGNMENT_7000)) {
 		printk(KERN_WARNING "3w-xxxx: Couldn't allocate correctly aligned memory.\n");
-		pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle);
+		dma_free_coherent(&tw_dev->tw_pci_dev->dev, size * TW_Q_LENGTH,
+				cpu_addr, dma_handle);
 		return 1;
 	}
 	/* Free command packet and generic buffer memory */
 	if (tw_dev->command_packet_virtual_address[0])
-		pci_free_consistent(tw_dev->tw_pci_dev, sizeof(TW_Command)*TW_Q_LENGTH, tw_dev->command_packet_virtual_address[0], tw_dev->command_packet_physical_address[0]);
+		dma_free_coherent(&tw_dev->tw_pci_dev->dev,
+				sizeof(TW_Command) * TW_Q_LENGTH,
+				tw_dev->command_packet_virtual_address[0],
+				tw_dev->command_packet_physical_address[0]);
 	if (tw_dev->alignment_virtual_address[0])
-		pci_free_consistent(tw_dev->tw_pci_dev, sizeof(TW_Sector)*TW_Q_LENGTH, tw_dev->alignment_virtual_address[0], tw_dev->alignment_physical_address[0]);
+		dma_free_coherent(&tw_dev->tw_pci_dev->dev,
+				sizeof(TW_Sector) * TW_Q_LENGTH,
+				tw_dev->alignment_virtual_address[0],
+				tw_dev->alignment_physical_address[0]);
 } /* End tw_free_device_extension() */
 /* This function will send an initconnection command to controller */
 	pci_set_master(pdev);
-	retval = pci_set_dma_mask(pdev, TW_DMA_MASK);
+	retval = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
 	if (retval) {
 		printk(KERN_WARNING "3w-xxxx: Failed to set dma mask.");
 		goto out_disable_device;

drivers/scsi/3w-xxxx.h+0−1

@@ -230,7 +230,6 @@ static unsigned char tw_sense_table[][4] = · 229 unmodified lines
230	#define TW_IOCTL_TIMEOUT 25 /* 25 seconds */	230	#define TW_IOCTL_TIMEOUT 25 /* 25 seconds */
231	#define TW_IOCTL_CHRDEV_TIMEOUT 60 /* 60 seconds */	231	#define TW_IOCTL_CHRDEV_TIMEOUT 60 /* 60 seconds */
232	#define TW_IOCTL_CHRDEV_FREE -1	232	#define TW_IOCTL_CHRDEV_FREE -1
233	#define TW_DMA_MASK DMA_BIT_MASK(32)
234	#define TW_MAX_CDB_LEN 16	233	#define TW_MAX_CDB_LEN 16
235		234
236	/* Bitmask macros to eliminate bitfields */	235	/* Bitmask macros to eliminate bitfields */

drivers/scsi/53c700.h+1−1

@@ -90,7 +90,7 @@ struct NCR_700_Device_Parameters { · 89 unmodified lines
90	/* The SYNC negotiation sequence looks like:	90	/* The SYNC negotiation sequence looks like:
91	*	91	*
92	* If DEV_NEGOTIATED_SYNC not set, tack and SDTR message on to the	92	* If DEV_NEGOTIATED_SYNC not set, tack and SDTR message on to the
93	* initial identify for the device and set DEV_BEGIN_SYNC_NEGOTATION	93	* initial identify for the device and set DEV_BEGIN_SYNC_NEGOTIATION
94	* If we get an SDTR reply, work out the SXFER parameters, squirrel	94	* If we get an SDTR reply, work out the SXFER parameters, squirrel
95	* them away here, clear DEV_BEGIN_SYNC_NEGOTIATION and set	95	* them away here, clear DEV_BEGIN_SYNC_NEGOTIATION and set
96	* DEV_NEGOTIATED_SYNC. If we get a REJECT msg, squirrel	96	* DEV_NEGOTIATED_SYNC. If we get a REJECT msg, squirrel

drivers/scsi/BusLogic.c+19−17

 	dma_addr_t blkp;
 	while (adapter->alloc_ccbs < adapter->initccbs) {
-		blk_pointer = pci_alloc_consistent(adapter->pci_device,
+		blk_pointer = dma_alloc_coherent(&adapter->pci_device->dev,
-							blk_size, &blkp);
+				blk_size, &blkp, GFP_KERNEL);
 		if (blk_pointer == NULL) {
 			blogic_err("UNABLE TO ALLOCATE CCB GROUP - DETACHING\n",
 					adapter);
 		next_ccb = ccb->next_all;
 		if (ccb->allocgrp_head) {
 			if (lastccb)
-				pci_free_consistent(adapter->pci_device,
+				dma_free_coherent(&adapter->pci_device->dev,
 						lastccb->allocgrp_size, lastccb,
 						lastccb->allocgrp_head);
 			lastccb = ccb;
 		}
 	}
 	if (lastccb)
-		pci_free_consistent(adapter->pci_device, lastccb->allocgrp_size,
+		dma_free_coherent(&adapter->pci_device->dev,
-					lastccb, lastccb->allocgrp_head);
+				lastccb->allocgrp_size, lastccb,
+				lastccb->allocgrp_head);
 }
 	if (addl_ccbs <= 0)
 		return;
 	while (adapter->alloc_ccbs - prev_alloc < addl_ccbs) {
-		blk_pointer = pci_alloc_consistent(adapter->pci_device,
+		blk_pointer = dma_alloc_coherent(&adapter->pci_device->dev,
-							blk_size, &blkp);
+				blk_size, &blkp, GFP_KERNEL);
 		if (blk_pointer == NULL)
 			break;
 		blogic_init_ccbs(adapter, blk_pointer, blk_size, blkp);
 	if (ccb->command != NULL)
 		scsi_dma_unmap(ccb->command);
 	if (dma_unmap)
-		pci_unmap_single(adapter->pci_device, ccb->sensedata,
+		dma_unmap_single(&adapter->pci_device->dev, ccb->sensedata,
-			 ccb->sense_datalen, PCI_DMA_FROMDEVICE);
+			 ccb->sense_datalen, DMA_FROM_DEVICE);
 	ccb->command = NULL;
 	ccb->status = BLOGIC_CCB_FREE;
 		if (pci_enable_device(pci_device))
 			continue;
-		if (pci_set_dma_mask(pci_device, DMA_BIT_MASK(32)))
+		if (dma_set_mask(&pci_device->dev, DMA_BIT_MASK(32)))
 			continue;
 		bus = pci_device->bus->number;
 		if (pci_enable_device(pci_device))
 			continue;
-		if (pci_set_dma_mask(pci_device, DMA_BIT_MASK(32)))
+		if (dma_set_mask(&pci_device->dev, DMA_BIT_MASK(32)))
 			continue;
 		bus = pci_device->bus->number;
 		if (pci_enable_device(pci_device))
 			continue;
-		if (pci_set_dma_mask(pci_device, DMA_BIT_MASK(32)))
+		if (dma_set_mask(&pci_device->dev, DMA_BIT_MASK(32)))
 			continue;
 		bus = pci_device->bus->number;
 	   Release any allocated memory structs not released elsewhere
 	 */
 	if (adapter->mbox_space)
-		pci_free_consistent(adapter->pci_device, adapter->mbox_sz,
+		dma_free_coherent(&adapter->pci_device->dev, adapter->mbox_sz,
 			adapter->mbox_space, adapter->mbox_space_handle);
 	pci_dev_put(adapter->pci_device);
 	adapter->mbox_space = NULL;
 	   Initialize the Outgoing and Incoming Mailbox pointers.
 	 */
 	adapter->mbox_sz = adapter->mbox_count * (sizeof(struct blogic_outbox) + sizeof(struct blogic_inbox));
-	adapter->mbox_space = pci_alloc_consistent(adapter->pci_device,
+	adapter->mbox_space = dma_alloc_coherent(&adapter->pci_device->dev,
-				adapter->mbox_sz, &adapter->mbox_space_handle);
+				adapter->mbox_sz, &adapter->mbox_space_handle,
+				GFP_KERNEL);
 	if (adapter->mbox_space == NULL)
 		return blogic_failure(adapter, "MAILBOX ALLOCATION");
 	adapter->first_outbox = (struct blogic_outbox *) adapter->mbox_space;
 	memcpy(ccb->cdb, cdb, cdblen);
 	ccb->sense_datalen = SCSI_SENSE_BUFFERSIZE;
 	ccb->command = command;
-	sense_buf = pci_map_single(adapter->pci_device,
+	sense_buf = dma_map_single(&adapter->pci_device->dev,
 				command->sense_buffer, ccb->sense_datalen,
-				PCI_DMA_FROMDEVICE);
+				DMA_FROM_DEVICE);
 	if (dma_mapping_error(&adapter->pci_device->dev, sense_buf)) {
 		blogic_err("DMA mapping for sense data buffer failed\n",
 				adapter);

drivers/scsi/FlashPoint.c+3−3

@@ -2944,7 +2944,7 @@ static void FPT_sdecm(unsigned char message, u32 port, unsigned char p_card) · 2943 unmodified lines
2944	}	2944	}
2945		2945
2946	if (currSCCB->Lun == 0x00) {	2946	if (currSCCB->Lun == 0x00) {
2947	if ((currSCCB->Sccb_scsistat == SELECT_SN_ST)) {	2947	if (currSCCB->Sccb_scsistat == SELECT_SN_ST) {
2948		2948
2949	currTar_Info->TarStatus \|=	2949	currTar_Info->TarStatus \|=
2950	(unsigned char)SYNC_SUPPORTED;	2950	(unsigned char)SYNC_SUPPORTED;
@@ -2953,8 +2953,8 @@ static void FPT_sdecm(unsigned char message, u32 port, unsigned char p_card) · 2 unmodified lines
2953	~EE_SYNC_MASK;	2953	~EE_SYNC_MASK;
2954	}	2954	}
2955		2955
2956	else if ((currSCCB->Sccb_scsistat ==	2956	else if (currSCCB->Sccb_scsistat ==
2957	SELECT_WN_ST)) {	2957	SELECT_WN_ST) {
2958		2958
2959	currTar_Info->TarStatus =	2959	currTar_Info->TarStatus =
2960	(currTar_Info->	2960	(currTar_Info->

drivers/scsi/Kconfig+35−0

@@ -42,6 +42,9 @@ config SCSI_DMA · 41 unmodified lines
42	bool	42	bool
43	default n	43	default n
44		44
		45	config SCSI_ESP_PIO
		46	bool
		47
45	config SCSI_NETLINK	48	config SCSI_NETLINK
46	bool	49	bool
47	default n	50	default n
@@ -557,6 +560,36 @@ config SCSI_FLASHPOINT · 509 unmodified lines
557	substantial, so users of MultiMaster Host Adapters may not	560	substantial, so users of MultiMaster Host Adapters may not
558	wish to include it.	561	wish to include it.
559		562
		563	config SCSI_MYRB
		564	tristate "Mylex DAC960/DAC1100 PCI RAID Controller (Block Interface)"
		565	depends on PCI
		566	select RAID_ATTRS
		567	help
		568	This driver adds support for the Mylex DAC960, AcceleRAID, and
		569	eXtremeRAID PCI RAID controllers. This driver supports the
		570	older, block based interface.
		571	This driver is a reimplementation of the original DAC960
		572	driver. If you have used the DAC960 driver you should enable
		573	this module.
		574
		575	To compile this driver as a module, choose M here: the
		576	module will be called myrb.
		577
		578	config SCSI_MYRS
		579	tristate "Mylex DAC960/DAC1100 PCI RAID Controller (SCSI Interface)"
		580	depends on PCI
		581	select RAID_ATTRS
		582	help
		583	This driver adds support for the Mylex DAC960, AcceleRAID, and
		584	eXtremeRAID PCI RAID controllers. This driver supports the
		585	newer, SCSI-based interface only.
		586	This driver is a reimplementation of the original DAC960
		587	driver. If you have used the DAC960 driver you should enable
		588	this module.
		589
		590	To compile this driver as a module, choose M here: the
		591	module will be called myrs.
		592
560	config VMWARE_PVSCSI	593	config VMWARE_PVSCSI
561	tristate "VMware PVSCSI driver support"	594	tristate "VMware PVSCSI driver support"
562	depends on PCI && SCSI && X86	595	depends on PCI && SCSI && X86
@@ -1332,6 +1365,7 @@ config SCSI_ZORRO_ESP · 769 unmodified lines
1332	tristate "Zorro ESP SCSI support"	1365	tristate "Zorro ESP SCSI support"
1333	depends on ZORRO && SCSI	1366	depends on ZORRO && SCSI
1334	select SCSI_SPI_ATTRS	1367	select SCSI_SPI_ATTRS
		1368	select SCSI_ESP_PIO
1335	help	1369	help
1336	Support for various NCR53C9x (ESP) based SCSI controllers on Zorro	1370	Support for various NCR53C9x (ESP) based SCSI controllers on Zorro
1337	expansion boards for the Amiga.	1371	expansion boards for the Amiga.
@@ -1374,6 +1408,7 @@ config SCSI_MAC_ESP · 36 unmodified lines
1374	tristate "Macintosh NCR53c9[46] SCSI"	1408	tristate "Macintosh NCR53c9[46] SCSI"
1375	depends on MAC && SCSI	1409	depends on MAC && SCSI
1376	select SCSI_SPI_ATTRS	1410	select SCSI_SPI_ATTRS
		1411	select SCSI_ESP_PIO
1377	help	1412	help
1378	This is the NCR 53c9x SCSI controller found on most of the 68040	1413	This is the NCR 53c9x SCSI controller found on most of the 68040
1379	based Macintoshes.	1414	based Macintoshes.

drivers/scsi/Makefile+2−0

 obj-$(CONFIG_SCSI_QLOGICPTI)	+= qlogicpti.o
 obj-$(CONFIG_SCSI_MESH)		+= mesh.o
 obj-$(CONFIG_SCSI_MAC53C94)	+= mac53c94.o
+obj-$(CONFIG_SCSI_MYRB)		+= myrb.o
+obj-$(CONFIG_SCSI_MYRS)		+= myrs.o
 obj-$(CONFIG_BLK_DEV_3W_XXXX_RAID) += 3w-xxxx.o
 obj-$(CONFIG_SCSI_3W_9XXX)	+= 3w-9xxx.o
 obj-$(CONFIG_SCSI_3W_SAS)	+= 3w-sas.o

drivers/scsi/NCR5380.c+100−67

@@ -131,6 +131,7 @@ · 130 unmodified lines
131		131
132	static int do_abort(struct Scsi_Host *);	132	static int do_abort(struct Scsi_Host *);
133	static void do_reset(struct Scsi_Host *);	133	static void do_reset(struct Scsi_Host *);
		134	static void bus_reset_cleanup(struct Scsi_Host *);
134		135
135	/**	136	/**
136	* initialize_SCp - init the scsi pointer field	137	* initialize_SCp - init the scsi pointer field
@@ -513,16 +514,15 @@ static void complete_cmd(struct Scsi_Host *instance, · 376 unmodified lines
513		514
514	if (hostdata->sensing == cmd) {	515	if (hostdata->sensing == cmd) {
515	/* Autosense processing ends here */	516	/* Autosense processing ends here */
516	if ((cmd->result & 0xff) != SAM_STAT_GOOD) {	517	if (status_byte(cmd->result) != GOOD) {
517	scsi_eh_restore_cmnd(cmd, &hostdata->ses);	518	scsi_eh_restore_cmnd(cmd, &hostdata->ses);
518	set_host_byte(cmd, DID_ERROR);	519	} else {
519	} else
520	scsi_eh_restore_cmnd(cmd, &hostdata->ses);	520	scsi_eh_restore_cmnd(cmd, &hostdata->ses);
		521	set_driver_byte(cmd, DRIVER_SENSE);
		522	}
521	hostdata->sensing = NULL;	523	hostdata->sensing = NULL;
522	}	524	}
523		525
524	hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun);
525
526	cmd->scsi_done(cmd);	526	cmd->scsi_done(cmd);
527	}	527	}
528		528
@@ -884,7 +884,14 @@ static irqreturn_t __maybe_unused NCR5380_intr(int irq, void *dev_id) · 355 unmodified lines
884	/* Probably Bus Reset */	884	/* Probably Bus Reset */
885	NCR5380_read(RESET_PARITY_INTERRUPT_REG);	885	NCR5380_read(RESET_PARITY_INTERRUPT_REG);
886		886
887	dsprintk(NDEBUG_INTR, instance, "unknown interrupt\n");	887	if (sr & SR_RST) {
		888	/* Certainly Bus Reset */
		889	shost_printk(KERN_WARNING, instance,
		890	"bus reset interrupt\n");
		891	bus_reset_cleanup(instance);
		892	} else {
		893	dsprintk(NDEBUG_INTR, instance, "unknown interrupt\n");
		894	}
888	#ifdef SUN3_SCSI_VME	895	#ifdef SUN3_SCSI_VME
889	dregs->csr \|= CSR_DMA_ENABLE;	896	dregs->csr \|= CSR_DMA_ENABLE;
890	#endif	897	#endif
@@ -902,20 +909,16 @@ static irqreturn_t __maybe_unused NCR5380_intr(int irq, void *dev_id) · 11 unmodified lines
902	return IRQ_RETVAL(handled);	909	return IRQ_RETVAL(handled);
903	}	910	}
904		911
905	/*	912	/**
906	* Function : int NCR5380_select(struct Scsi_Host *instance,	913	* NCR5380_select - attempt arbitration and selection for a given command
907	* struct scsi_cmnd *cmd)	914	* @instance: the Scsi_Host instance
908	*	915	* @cmd: the scsi_cmnd to execute
909	* Purpose : establishes I_T_L or I_T_L_Q nexus for new or existing command,
910	* including ARBITRATION, SELECTION, and initial message out for
911	* IDENTIFY and queue messages.
912	*	916	*
913	* Inputs : instance - instantiation of the 5380 driver on which this	917	* This routine establishes an I_T_L nexus for a SCSI command. This involves
914	* target lives, cmd - SCSI command to execute.	918	* ARBITRATION, SELECTION and MESSAGE OUT phases and an IDENTIFY message.
915	*	919	*
916	* Returns cmd if selection failed but should be retried,	920	* Returns true if the operation should be retried.
917	* NULL if selection failed and should not be retried, or	921	* Returns false if it should not be retried.
918	* NULL if selection succeeded (hostdata->connected == cmd).
919	*	922	*
920	* Side effects :	923	* Side effects :
921	* If bus busy, arbitration failed, etc, NCR5380_select() will exit	924	* If bus busy, arbitration failed, etc, NCR5380_select() will exit
@@ -923,16 +926,15 @@ static irqreturn_t __maybe_unused NCR5380_intr(int irq, void *dev_id) · 1 unmodified line
923	* SELECT_ENABLE will be set appropriately, the NCR5380	926	* SELECT_ENABLE will be set appropriately, the NCR5380
924	* will cease to drive any SCSI bus signals.	927	* will cease to drive any SCSI bus signals.
925	*	928	*
926	* If successful : I_T_L or I_T_L_Q nexus will be established,	929	* If successful : the I_T_L nexus will be established, and
927	* instance->connected will be set to cmd.	930	* hostdata->connected will be set to cmd.
928	* SELECT interrupt will be disabled.	931	* SELECT interrupt will be disabled.
929	*	932	*
930	* If failed (no target) : cmd->scsi_done() will be called, and the	933	* If failed (no target) : cmd->scsi_done() will be called, and the
931	* cmd->result host byte set to DID_BAD_TARGET.	934	* cmd->result host byte set to DID_BAD_TARGET.
932	*/	935	*/
933		936
934	static struct scsi_cmnd NCR5380_select(struct Scsi_Host instance,	937	static bool NCR5380_select(struct Scsi_Host instance, struct scsi_cmnd cmd)
935	struct scsi_cmnd *cmd)
936	__releases(&hostdata->lock) __acquires(&hostdata->lock)	938	__releases(&hostdata->lock) __acquires(&hostdata->lock)
937	{	939	{
938	struct NCR5380_hostdata *hostdata = shost_priv(instance);	940	struct NCR5380_hostdata *hostdata = shost_priv(instance);
@@ -940,6 +942,9 @@ static struct scsi_cmnd NCR5380_select(struct Scsi_Host instance, · 1 unmodified line
940	unsigned char *data;	942	unsigned char *data;
941	int len;	943	int len;
942	int err;	944	int err;
		945	bool ret = true;
		946	bool can_disconnect = instance->irq != NO_IRQ &&
		947	cmd->cmnd[0] != REQUEST_SENSE;
943		948
944	NCR5380_dprint(NDEBUG_ARBITRATION, instance);	949	NCR5380_dprint(NDEBUG_ARBITRATION, instance);
945	dsprintk(NDEBUG_ARBITRATION, instance, "starting arbitration, id = %d\n",	950	dsprintk(NDEBUG_ARBITRATION, instance, "starting arbitration, id = %d\n",
@@ -948,7 +953,7 @@ static struct scsi_cmnd NCR5380_select(struct Scsi_Host instance, · 2 unmodified lines
948	/*	953	/*
949	* Arbitration and selection phases are slow and involve dropping the	954	* Arbitration and selection phases are slow and involve dropping the
950	* lock, so we have to watch out for EH. An exception handler may	955	* lock, so we have to watch out for EH. An exception handler may
951	* change 'selecting' to NULL. This function will then return NULL	956	* change 'selecting' to NULL. This function will then return false
952	* so that the caller will forget about 'cmd'. (During information	957	* so that the caller will forget about 'cmd'. (During information
953	* transfer phases, EH may change 'connected' to NULL.)	958	* transfer phases, EH may change 'connected' to NULL.)
954	*/	959	*/
@@ -984,7 +989,7 @@ static struct scsi_cmnd NCR5380_select(struct Scsi_Host instance, · 29 unmodified lines
984	if (!hostdata->selecting) {	989	if (!hostdata->selecting) {
985	/* Command was aborted */	990	/* Command was aborted */
986	NCR5380_write(MODE_REG, MR_BASE);	991	NCR5380_write(MODE_REG, MR_BASE);
987	goto out;	992	return false;
988	}	993	}
989	if (err < 0) {	994	if (err < 0) {
990	NCR5380_write(MODE_REG, MR_BASE);	995	NCR5380_write(MODE_REG, MR_BASE);
@@ -1033,7 +1038,7 @@ static struct scsi_cmnd NCR5380_select(struct Scsi_Host instance, · 42 unmodified lines
1033	if (!hostdata->selecting) {	1038	if (!hostdata->selecting) {
1034	NCR5380_write(MODE_REG, MR_BASE);	1039	NCR5380_write(MODE_REG, MR_BASE);
1035	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);	1040	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1036	goto out;	1041	return false;
1037	}	1042	}
1038		1043
1039	dsprintk(NDEBUG_ARBITRATION, instance, "won arbitration\n");	1044	dsprintk(NDEBUG_ARBITRATION, instance, "won arbitration\n");
@@ -1116,13 +1121,16 @@ static struct scsi_cmnd NCR5380_select(struct Scsi_Host instance, · 76 unmodified lines
1116	spin_lock_irq(&hostdata->lock);	1121	spin_lock_irq(&hostdata->lock);
1117	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);	1122	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1118	NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);	1123	NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
		1124
1119	/* Can't touch cmd if it has been reclaimed by the scsi ML */	1125	/* Can't touch cmd if it has been reclaimed by the scsi ML */
1120	if (hostdata->selecting) {	1126	if (!hostdata->selecting)
1121	cmd->result = DID_BAD_TARGET << 16;	1127	return false;
1122	complete_cmd(instance, cmd);	1128
1123	dsprintk(NDEBUG_SELECTION, instance, "target did not respond within 250ms\n");	1129	cmd->result = DID_BAD_TARGET << 16;
1124	cmd = NULL;	1130	complete_cmd(instance, cmd);
1125	}	1131	dsprintk(NDEBUG_SELECTION, instance,
		1132	"target did not respond within 250ms\n");
		1133	ret = false;
1126	goto out;	1134	goto out;
1127	}	1135	}
1128		1136
@@ -1155,12 +1163,12 @@ static struct scsi_cmnd NCR5380_select(struct Scsi_Host instance, · 26 unmodified lines
1155	}	1163	}
1156	if (!hostdata->selecting) {	1164	if (!hostdata->selecting) {
1157	do_abort(instance);	1165	do_abort(instance);
1158	goto out;	1166	return false;
1159	}	1167	}
1160		1168
1161	dsprintk(NDEBUG_SELECTION, instance, "target %d selected, going into MESSAGE OUT phase.\n",	1169	dsprintk(NDEBUG_SELECTION, instance, "target %d selected, going into MESSAGE OUT phase.\n",
1162	scmd_id(cmd));	1170	scmd_id(cmd));
1163	tmp[0] = IDENTIFY(((instance->irq == NO_IRQ) ? 0 : 1), cmd->device->lun);	1171	tmp[0] = IDENTIFY(can_disconnect, cmd->device->lun);
1164		1172
1165	len = 1;	1173	len = 1;
1166	data = tmp;	1174	data = tmp;
@@ -1171,7 +1179,7 @@ static struct scsi_cmnd NCR5380_select(struct Scsi_Host instance, · 4 unmodified lines
1171	cmd->result = DID_ERROR << 16;	1179	cmd->result = DID_ERROR << 16;
1172	complete_cmd(instance, cmd);	1180	complete_cmd(instance, cmd);
1173	dsprintk(NDEBUG_SELECTION, instance, "IDENTIFY message transfer failed\n");	1181	dsprintk(NDEBUG_SELECTION, instance, "IDENTIFY message transfer failed\n");
1174	cmd = NULL;	1182	ret = false;
1175	goto out;	1183	goto out;
1176	}	1184	}
1177		1185
@@ -1186,13 +1194,13 @@ static struct scsi_cmnd NCR5380_select(struct Scsi_Host instance, · 8 unmodified lines
1186		1194
1187	initialize_SCp(cmd);	1195	initialize_SCp(cmd);
1188		1196
1189	cmd = NULL;	1197	ret = false;
1190		1198
1191	out:	1199	out:
1192	if (!hostdata->selecting)	1200	if (!hostdata->selecting)
1193	return NULL;	1201	return NULL;
1194	hostdata->selecting = NULL;	1202	hostdata->selecting = NULL;
1195	return cmd;	1203	return ret;
1196	}	1204	}
1197		1205
1198	/*	1206	/*
@@ -1711,6 +1719,7 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance) · 512 unmodified lines
1711	cmd->result = DID_ERROR << 16;	1719	cmd->result = DID_ERROR << 16;
1712	complete_cmd(instance, cmd);	1720	complete_cmd(instance, cmd);
1713	hostdata->connected = NULL;	1721	hostdata->connected = NULL;
		1722	hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun);
1714	return;	1723	return;
1715	#endif	1724	#endif
1716	case PHASE_DATAIN:	1725	case PHASE_DATAIN:
@@ -1793,6 +1802,7 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance) · 76 unmodified lines
1793	cmd, scmd_id(cmd), cmd->device->lun);	1802	cmd, scmd_id(cmd), cmd->device->lun);
1794		1803
1795	hostdata->connected = NULL;	1804	hostdata->connected = NULL;
		1805	hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun);
1796		1806
1797	cmd->result &= ~0xffff;	1807	cmd->result &= ~0xffff;
1798	cmd->result \|= cmd->SCp.Status;	1808	cmd->result \|= cmd->SCp.Status;
@@ -1951,6 +1961,7 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance) · 152 unmodified lines
1951	NCR5380_transfer_pio(instance, &phase, &len, &data);	1961	NCR5380_transfer_pio(instance, &phase, &len, &data);
1952	if (msgout == ABORT) {	1962	if (msgout == ABORT) {
1953	hostdata->connected = NULL;	1963	hostdata->connected = NULL;
		1964	hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun);
1954	cmd->result = DID_ERROR << 16;	1965	cmd->result = DID_ERROR << 16;
1955	complete_cmd(instance, cmd);	1966	complete_cmd(instance, cmd);
1956	maybe_release_dma_irq(instance);	1967	maybe_release_dma_irq(instance);
@@ -2014,8 +2025,11 @@ static void NCR5380_reselect(struct Scsi_Host *instance) · 57 unmodified lines
2014	NCR5380_write(MODE_REG, MR_BASE);	2025	NCR5380_write(MODE_REG, MR_BASE);
2015		2026
2016	target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask);	2027	target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask);
2017		2028	if (!target_mask \|\| target_mask & (target_mask - 1)) {
2018	dsprintk(NDEBUG_RESELECTION, instance, "reselect\n");	2029	shost_printk(KERN_WARNING, instance,
		2030	"reselect: bad target_mask 0x%02x\n", target_mask);
		2031	return;
		2032	}
2019		2033
2020	/*	2034	/*
2021	* At this point, we have detected that our SCSI ID is on the bus,	2035	* At this point, we have detected that our SCSI ID is on the bus,
@@ -2029,6 +2043,7 @@ static void NCR5380_reselect(struct Scsi_Host *instance) · 7 unmodified lines
2029	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE \| ICR_ASSERT_BSY);	2043	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE \| ICR_ASSERT_BSY);
2030	if (NCR5380_poll_politely(hostdata,	2044	if (NCR5380_poll_politely(hostdata,
2031	STATUS_REG, SR_SEL, 0, 2 * HZ) < 0) {	2045	STATUS_REG, SR_SEL, 0, 2 * HZ) < 0) {
		2046	shost_printk(KERN_ERR, instance, "reselect: !SEL timeout\n");
2032	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);	2047	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2033	return;	2048	return;
2034	}	2049	}
@@ -2040,6 +2055,10 @@ static void NCR5380_reselect(struct Scsi_Host *instance) · 5 unmodified lines
2040		2055
2041	if (NCR5380_poll_politely(hostdata,	2056	if (NCR5380_poll_politely(hostdata,
2042	STATUS_REG, SR_REQ, SR_REQ, 2 * HZ) < 0) {	2057	STATUS_REG, SR_REQ, SR_REQ, 2 * HZ) < 0) {
		2058	if ((NCR5380_read(STATUS_REG) & (SR_BSY \| SR_SEL)) == 0)
		2059	/* BUS FREE phase */
		2060	return;
		2061	shost_printk(KERN_ERR, instance, "reselect: REQ timeout\n");
2043	do_abort(instance);	2062	do_abort(instance);
2044	return;	2063	return;
2045	}	2064	}
@@ -2101,13 +2120,16 @@ static void NCR5380_reselect(struct Scsi_Host *instance) · 55 unmodified lines
2101	dsprintk(NDEBUG_RESELECTION \| NDEBUG_QUEUES, instance,	2120	dsprintk(NDEBUG_RESELECTION \| NDEBUG_QUEUES, instance,
2102	"reselect: removed %p from disconnected queue\n", tmp);	2121	"reselect: removed %p from disconnected queue\n", tmp);
2103	} else {	2122	} else {
		2123	int target = ffs(target_mask) - 1;
		2124
2104	shost_printk(KERN_ERR, instance, "target bitmask 0x%02x lun %d not in disconnected queue.\n",	2125	shost_printk(KERN_ERR, instance, "target bitmask 0x%02x lun %d not in disconnected queue.\n",
2105	target_mask, lun);	2126	target_mask, lun);
2106	/*	2127	/*
2107	* Since we have an established nexus that we can't do anything	2128	* Since we have an established nexus that we can't do anything
2108	* with, we must abort it.	2129	* with, we must abort it.
2109	*/	2130	*/
2110	do_abort(instance);	2131	if (do_abort(instance) == 0)
		2132	hostdata->busy[target] &= ~(1 << lun);
2111	return;	2133	return;
2112	}	2134	}
2113		2135
@@ -2272,15 +2294,16 @@ static int NCR5380_abort(struct scsi_cmnd *cmd) · 158 unmodified lines
2272	if (list_del_cmd(&hostdata->autosense, cmd)) {	2294	if (list_del_cmd(&hostdata->autosense, cmd)) {
2273	dsprintk(NDEBUG_ABORT, instance,	2295	dsprintk(NDEBUG_ABORT, instance,
2274	"abort: removed %p from sense queue\n", cmd);	2296	"abort: removed %p from sense queue\n", cmd);
2275	set_host_byte(cmd, DID_ERROR);
2276	complete_cmd(instance, cmd);	2297	complete_cmd(instance, cmd);
2277	}	2298	}
2278		2299
2279	out:	2300	out:
2280	if (result == FAILED)	2301	if (result == FAILED)
2281	dsprintk(NDEBUG_ABORT, instance, "abort: failed to abort %p\n", cmd);	2302	dsprintk(NDEBUG_ABORT, instance, "abort: failed to abort %p\n", cmd);
2282	else	2303	else {
		2304	hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun);
2283	dsprintk(NDEBUG_ABORT, instance, "abort: successfully aborted %p\n", cmd);	2305	dsprintk(NDEBUG_ABORT, instance, "abort: successfully aborted %p\n", cmd);
		2306	}
2284		2307
2285	queue_work(hostdata->work_q, &hostdata->main_task);	2308	queue_work(hostdata->work_q, &hostdata->main_task);
2286	maybe_release_dma_irq(instance);	2309	maybe_release_dma_irq(instance);
@@ -2290,31 +2313,12 @@ out: · 3 unmodified lines
2290	}	2313	}
2291		2314
2292		2315
2293	/**	2316	static void bus_reset_cleanup(struct Scsi_Host *instance)
2294	* NCR5380_host_reset - reset the SCSI host
2295	* @cmd: SCSI command undergoing EH
2296	*
2297	* Returns SUCCESS
2298	*/
2299
2300	static int NCR5380_host_reset(struct scsi_cmnd *cmd)
2301	{	2317	{
2302	struct Scsi_Host *instance = cmd->device->host;
2303	struct NCR5380_hostdata *hostdata = shost_priv(instance);	2318	struct NCR5380_hostdata *hostdata = shost_priv(instance);
2304	int i;	2319	int i;
2305	unsigned long flags;
2306	struct NCR5380_cmd *ncmd;	2320	struct NCR5380_cmd *ncmd;
2307		2321
2308	spin_lock_irqsave(&hostdata->lock, flags);
2309
2310	#if (NDEBUG & NDEBUG_ANY)
2311	scmd_printk(KERN_INFO, cmd, __func__);
2312	#endif
2313	NCR5380_dprint(NDEBUG_ANY, instance);
2314	NCR5380_dprint_phase(NDEBUG_ANY, instance);
2315
2316	do_reset(instance);
2317
2318	/* reset NCR registers */	2322	/* reset NCR registers */
2319	NCR5380_write(MODE_REG, MR_BASE);	2323	NCR5380_write(MODE_REG, MR_BASE);
2320	NCR5380_write(TARGET_COMMAND_REG, 0);	2324	NCR5380_write(TARGET_COMMAND_REG, 0);
@@ -2326,11 +2330,6 @@ static int NCR5380_host_reset(struct scsi_cmnd *cmd) · 5 unmodified lines
2326	* commands!	2330	* commands!
2327	*/	2331	*/
2328		2332
2329	if (list_del_cmd(&hostdata->unissued, cmd)) {
2330	cmd->result = DID_RESET << 16;
2331	cmd->scsi_done(cmd);
2332	}
2333
2334	if (hostdata->selecting) {	2333	if (hostdata->selecting) {
2335	hostdata->selecting->result = DID_RESET << 16;	2334	hostdata->selecting->result = DID_RESET << 16;
2336	complete_cmd(instance, hostdata->selecting);	2335	complete_cmd(instance, hostdata->selecting);
@@ -2348,7 +2347,6 @@ static int NCR5380_host_reset(struct scsi_cmnd *cmd) · 11 unmodified lines
2348	list_for_each_entry(ncmd, &hostdata->autosense, list) {	2347	list_for_each_entry(ncmd, &hostdata->autosense, list) {
2349	struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd);	2348	struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd);
2350		2349
2351	set_host_byte(cmd, DID_RESET);
2352	cmd->scsi_done(cmd);	2350	cmd->scsi_done(cmd);
2353	}	2351	}
2354	INIT_LIST_HEAD(&hostdata->autosense);	2352	INIT_LIST_HEAD(&hostdata->autosense);
@@ -2365,6 +2363,41 @@ static int NCR5380_host_reset(struct scsi_cmnd *cmd) · 10 unmodified lines
2365		2363
2366	queue_work(hostdata->work_q, &hostdata->main_task);	2364	queue_work(hostdata->work_q, &hostdata->main_task);
2367	maybe_release_dma_irq(instance);	2365	maybe_release_dma_irq(instance);
		2366	}
		2367
		2368	/**
		2369	* NCR5380_host_reset - reset the SCSI host
		2370	* @cmd: SCSI command undergoing EH
		2371	*
		2372	* Returns SUCCESS
		2373	*/
		2374
		2375	static int NCR5380_host_reset(struct scsi_cmnd *cmd)
		2376	{
		2377	struct Scsi_Host *instance = cmd->device->host;
		2378	struct NCR5380_hostdata *hostdata = shost_priv(instance);
		2379	unsigned long flags;
		2380	struct NCR5380_cmd *ncmd;
		2381
		2382	spin_lock_irqsave(&hostdata->lock, flags);
		2383
		2384	#if (NDEBUG & NDEBUG_ANY)
		2385	shost_printk(KERN_INFO, instance, __func__);
		2386	#endif
		2387	NCR5380_dprint(NDEBUG_ANY, instance);
		2388	NCR5380_dprint_phase(NDEBUG_ANY, instance);
		2389
		2390	list_for_each_entry(ncmd, &hostdata->unissued, list) {
		2391	struct scsi_cmnd *scmd = NCR5380_to_scmd(ncmd);
		2392
		2393	scmd->result = DID_RESET << 16;
		2394	scmd->scsi_done(scmd);
		2395	}
		2396	INIT_LIST_HEAD(&hostdata->unissued);
		2397
		2398	do_reset(instance);
		2399	bus_reset_cleanup(instance);
		2400
2368	spin_unlock_irqrestore(&hostdata->lock, flags);	2401	spin_unlock_irqrestore(&hostdata->lock, flags);
2369		2402
2370	return SUCCESS;	2403	return SUCCESS;

drivers/scsi/NCR5380.h+1−1

@@ -275,7 +275,7 @@ static irqreturn_t NCR5380_intr(int irq, void *dev_id); · 274 unmodified lines
275	static void NCR5380_main(struct work_struct *work);	275	static void NCR5380_main(struct work_struct *work);
276	static const char NCR5380_info(struct Scsi_Host instance);	276	static const char NCR5380_info(struct Scsi_Host instance);
277	static void NCR5380_reselect(struct Scsi_Host *instance);	277	static void NCR5380_reselect(struct Scsi_Host *instance);
278	static struct scsi_cmnd NCR5380_select(struct Scsi_Host , struct scsi_cmnd *);	278	static bool NCR5380_select(struct Scsi_Host , struct scsi_cmnd );
279	static int NCR5380_transfer_dma(struct Scsi_Host instance, unsigned char phase, int count, unsigned char *data);	279	static int NCR5380_transfer_dma(struct Scsi_Host instance, unsigned char phase, int count, unsigned char *data);
280	static int NCR5380_transfer_pio(struct Scsi_Host instance, unsigned char phase, int count, unsigned char *data);	280	static int NCR5380_transfer_pio(struct Scsi_Host instance, unsigned char phase, int count, unsigned char *data);
281	static int NCR5380_poll_politely2(struct NCR5380_hostdata *,	281	static int NCR5380_poll_politely2(struct NCR5380_hostdata *,

drivers/scsi/a100u2w.c+13−7

 	if (pci_enable_device(pdev))
 		goto out;
-	if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
+	if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) {
 		printk(KERN_WARNING "Unable to set 32bit DMA "
 				    "on inia100 adapter, ignoring.\n");
 		goto out_disable_device;
 	/* Get total memory needed for SCB */
 	sz = ORC_MAXQUEUE * sizeof(struct orc_scb);
-	host->scb_virt = pci_zalloc_consistent(pdev, sz, &host->scb_phys);
+	host->scb_virt = dma_zalloc_coherent(&pdev->dev, sz, &host->scb_phys,
+					     GFP_KERNEL);
 	if (!host->scb_virt) {
 		printk("inia100: SCB memory allocation error\n");
 		goto out_host_put;
 	/* Get total memory needed for ESCB */
 	sz = ORC_MAXQUEUE * sizeof(struct orc_extended_scb);
-	host->escb_virt = pci_zalloc_consistent(pdev, sz, &host->escb_phys);
+	host->escb_virt = dma_zalloc_coherent(&pdev->dev, sz, &host->escb_phys,
+					      GFP_KERNEL);
 	if (!host->escb_virt) {
 		printk("inia100: ESCB memory allocation error\n");
 		goto out_free_scb_array;
 out_free_irq:
         free_irq(shost->irq, shost);
 out_free_escb_array:
-	pci_free_consistent(pdev, ORC_MAXQUEUE * sizeof(struct orc_extended_scb),
+	dma_free_coherent(&pdev->dev,
+			ORC_MAXQUEUE * sizeof(struct orc_extended_scb),
 			host->escb_virt, host->escb_phys);
 out_free_scb_array:
-	pci_free_consistent(pdev, ORC_MAXQUEUE * sizeof(struct orc_scb),
+	dma_free_coherent(&pdev->dev,
+			ORC_MAXQUEUE * sizeof(struct orc_scb),
 			host->scb_virt, host->scb_phys);
 out_host_put:
 	scsi_host_put(shost);
 	scsi_remove_host(shost);
         free_irq(shost->irq, shost);
-	pci_free_consistent(pdev, ORC_MAXQUEUE * sizeof(struct orc_extended_scb),
+	dma_free_coherent(&pdev->dev,
+			ORC_MAXQUEUE * sizeof(struct orc_extended_scb),
 			host->escb_virt, host->escb_phys);
-	pci_free_consistent(pdev, ORC_MAXQUEUE * sizeof(struct orc_scb),
+	dma_free_coherent(&pdev->dev,
+			ORC_MAXQUEUE * sizeof(struct orc_scb),
 			host->scb_virt, host->scb_phys);
         release_region(shost->io_port, 256);

drivers/scsi/aacraid/aachba.c+0−7

 static void aac_srb_callback(void *context, struct fib * fibptr)
 {
-	struct aac_dev *dev;
 	struct aac_srb_reply *srbreply;
 	struct scsi_cmnd *scsicmd;
 	BUG_ON(fibptr == NULL);
-	dev = fibptr->dev;
 	srbreply = (struct aac_srb_reply *) fib_data(fibptr);
 	scsicmd->sense_buffer[0] = '\0';  /* Initialize sense valid flag to false */
 static long aac_build_sg(struct scsi_cmnd *scsicmd, struct sgmap *psg)
 {
-	struct aac_dev *dev;
 	unsigned long byte_count = 0;
 	int nseg;
 	struct scatterlist *sg;
 	int i;
-	dev = (struct aac_dev *)scsicmd->device->host->hostdata;
 	// Get rid of old data
 	psg->count = 0;
 	psg->sg[0].addr = 0;
 static long aac_build_sg64(struct scsi_cmnd *scsicmd, struct sgmap64 *psg)
 {
-	struct aac_dev *dev;
 	unsigned long byte_count = 0;
 	u64 addr;
 	int nseg;
 	struct scatterlist *sg;
 	int i;
-	dev = (struct aac_dev *)scsicmd->device->host->hostdata;
 	// Get rid of old data
 	psg->count = 0;
 	psg->sg[0].addr[0] = 0;

drivers/scsi/aacraid/commsup.c+0−2

 void aac_free_irq(struct aac_dev *dev)
 {
 	int i;
-	int cpu;
-	cpu = cpumask_first(cpu_online_mask);
 	if (aac_is_src(dev)) {
 		if (dev->max_msix > 1) {
 			for (i = 0; i < dev->max_msix; i++)

drivers/scsi/advansys.c+1−3

 static void adv_isr_callback(ADV_DVC_VAR *adv_dvc_varp, ADV_SCSI_REQ_Q *scsiqp)
 {
 	struct asc_board *boardp = adv_dvc_varp->drv_ptr;
-	u32 srb_tag;
 	adv_req_t *reqp;
 	adv_sgblk_t *sgblkp;
 	struct scsi_cmnd *scp;
 	 * completed. The adv_req_t structure actually contains the
 	 * completed ADV_SCSI_REQ_Q structure.
 	 */
-	srb_tag = le32_to_cpu(scsiqp->srb_tag);
 	scp = scsi_host_find_tag(boardp->shost, scsiqp->srb_tag);
 	ASC_DBG(1, "scp 0x%p\n", scp);
 				sdtr_data =
 				    AscCalSDTRData(asc_dvc, ext_msg.xfer_period,
 						   ext_msg.req_ack_offset);
-				if ((sdtr_data == 0xFF)) {
+				if (sdtr_data == 0xFF) {
 					q_cntl |= QC_MSG_OUT;
 					asc_dvc->init_sdtr &= ~target_id;

drivers/scsi/aic7xxx/aic7770.c+0−6

  * $FreeBSD$
  */
-#ifdef __linux__
 #include "aic7xxx_osm.h"
 #include "aic7xxx_inline.h"
 #include "aic7xxx_93cx6.h"
-#else
-#include <dev/aic7xxx/aic7xxx_osm.h>
-#include <dev/aic7xxx/aic7xxx_inline.h>
-#include <dev/aic7xxx/aic7xxx_93cx6.h>
-#endif
 #define ID_AIC7770	0x04907770
 #define ID_AHA_274x	0x04907771

drivers/scsi/aic7xxx/aic79xx.h+0−6

 	ahd_io_ctx_t		  io_ctx;
 	struct ahd_softc	 *ahd_softc;
 	scb_flag		  flags;
-#ifndef __linux__
-	bus_dmamap_t		  dmamap;
-#endif
 	struct scb_platform_data *platform_data;
 	struct map_node	 	 *hscb_map;
 	struct map_node	 	 *sg_map;
 struct ahd_softc {
 	bus_space_tag_t           tags[2];
 	bus_space_handle_t        bshs[2];
-#ifndef __linux__
-	bus_dma_tag_t		  buffer_dmat;   /* dmat for buffer I/O */
-#endif
 	struct scb_data		  scb_data;
 	struct hardware_scb	 *next_queued_hscb;

drivers/scsi/aic7xxx/aic79xx_core.c+0−44

  * $Id: //depot/aic7xxx/aic7xxx/aic79xx.c#250 $
  */
-#ifdef __linux__
 #include "aic79xx_osm.h"
 #include "aic79xx_inline.h"
 #include "aicasm/aicasm_insformat.h"
-#else
-#include <dev/aic7xxx/aic79xx_osm.h>
-#include <dev/aic7xxx/aic79xx_inline.h>
-#include <dev/aic7xxx/aicasm/aicasm_insformat.h>
-#endif
 /***************************** Lookup Tables **********************************/
 static const char *const ahd_chip_names[] =
 	"aic7902",
 	"aic7901A"
 };
-static const u_int num_chip_names = ARRAY_SIZE(ahd_chip_names);
 /*
  * Hardware error codes.
 	case 2:
 		ahd_dma_tag_destroy(ahd, ahd->shared_data_dmat);
 	case 1:
-#ifndef __linux__
-		ahd_dma_tag_destroy(ahd, ahd->buffer_dmat);
-#endif
 		break;
 	case 0:
 		break;
 	}
-#ifndef __linux__
-	ahd_dma_tag_destroy(ahd, ahd->parent_dmat);
-#endif
 	ahd_platform_free(ahd);
 	ahd_fini_scbdata(ahd);
 	for (i = 0; i < AHD_NUM_TARGETS; i++) {
 	for (i = 0; i < newcount; i++) {
 		struct scb_platform_data *pdata;
 		u_int col_tag;
-#ifndef __linux__
-		int error;
-#endif
 		next_scb = kmalloc(sizeof(*next_scb), GFP_ATOMIC);
 		if (next_scb == NULL)
 			next_scb->sg_list_busaddr += sizeof(struct ahd_dma_seg);
 		next_scb->ahd_softc = ahd;
 		next_scb->flags = SCB_FLAG_NONE;
-#ifndef __linux__
-		error = ahd_dmamap_create(ahd, ahd->buffer_dmat, /*flags*/0,
-					  &next_scb->dmamap);
-		if (error != 0) {
-			kfree(next_scb);
-			kfree(pdata);
-			break;
-		}
-#endif
 		next_scb->hscb->tag = ahd_htole16(scb_data->numscbs);
 		col_tag = scb_data->numscbs ^ 0x100;
 		next_scb->col_scb = ahd_find_scb_by_tag(ahd, col_tag);
 	if ((AHD_TMODE_ENABLE & (0x1 << ahd->unit)) == 0)
 		ahd->features &= ~AHD_TARGETMODE;
-#ifndef __linux__
-	/* DMA tag for mapping buffers into device visible space. */
-	if (ahd_dma_tag_create(ahd, ahd->parent_dmat, /*alignment*/1,
-			       /*boundary*/BUS_SPACE_MAXADDR_32BIT + 1,
-			       /*lowaddr*/ahd->flags & AHD_39BIT_ADDRESSING
-					? (dma_addr_t)0x7FFFFFFFFFULL
-					: BUS_SPACE_MAXADDR_32BIT,
-			       /*highaddr*/BUS_SPACE_MAXADDR,
-			       /*filter*/NULL, /*filterarg*/NULL,
-			       /*maxsize*/(AHD_NSEG - 1) * PAGE_SIZE,
-			       /*nsegments*/AHD_NSEG,
-			       /*maxsegsz*/AHD_MAXTRANSFER_SIZE,
-			       /*flags*/BUS_DMA_ALLOCNOW,
-			       &ahd->buffer_dmat) != 0) {
-		return (ENOMEM);
-	}
-#endif
 	ahd->init_level++;
 	/*

drivers/scsi/aic7xxx/aic79xx_pci.c+0−8

  * $Id: //depot/aic7xxx/aic7xxx/aic79xx_pci.c#92 $
  */
-#ifdef __linux__
 #include "aic79xx_osm.h"
 #include "aic79xx_inline.h"
-#else
-#include <dev/aic7xxx/aic79xx_osm.h>
-#include <dev/aic7xxx/aic79xx_inline.h>
-#endif
 #include "aic79xx_pci.h"
 static inline uint64_t
 int
 ahd_pci_config(struct ahd_softc *ahd, const struct ahd_pci_identity *entry)
 {
-	struct scb_data *shared_scb_data;
 	u_int		 command;
 	uint32_t	 devconfig;
 	uint16_t	 subvendor;
 	int		 error;
-	shared_scb_data = NULL;
 	ahd->description = entry->name;
 	/*
 	 * Record if this is an HP board.

drivers/scsi/aic7xxx/aic7xxx.h+0−6

 	ahc_io_ctx_t		  io_ctx;
 	struct ahc_softc	 *ahc_softc;
 	scb_flag		  flags;
-#ifndef __linux__
-	bus_dmamap_t		  dmamap;
-#endif
 	struct scb_platform_data *platform_data;
 	struct sg_map_node	 *sg_map;
 	struct ahc_dma_seg 	 *sg_list;
 struct ahc_softc {
 	bus_space_tag_t           tag;
 	bus_space_handle_t        bsh;
-#ifndef __linux__
-	bus_dma_tag_t		  buffer_dmat;   /* dmat for buffer I/O */
-#endif
 	struct scb_data		 *scb_data;
 	struct scb		 *next_queued_scb;

drivers/scsi/aic7xxx/aic7xxx_93cx6.c+0−6

  *   bit to be sent from the chip.
  */
-#ifdef __linux__
 #include "aic7xxx_osm.h"
 #include "aic7xxx_inline.h"
 #include "aic7xxx_93cx6.h"
-#else
-#include <dev/aic7xxx/aic7xxx_osm.h>
-#include <dev/aic7xxx/aic7xxx_inline.h>
-#include <dev/aic7xxx/aic7xxx_93cx6.h>
-#endif
 /*
  * Right now, we only have to read the SEEPROM.  But we make it easier to

drivers/scsi/aic7xxx/aic7xxx_core.c+1−40

@@ -40,15 +40,9 @@ · 39 unmodified lines
40	* $Id: //depot/aic7xxx/aic7xxx/aic7xxx.c#155 $	40	* $Id: //depot/aic7xxx/aic7xxx/aic7xxx.c#155 $
41	*/	41	*/
42		42
43	#ifdef __linux__
44	#include "aic7xxx_osm.h"	43	#include "aic7xxx_osm.h"
45	#include "aic7xxx_inline.h"	44	#include "aic7xxx_inline.h"
46	#include "aicasm/aicasm_insformat.h"	45	#include "aicasm/aicasm_insformat.h"
47	#else
48	#include <dev/aic7xxx/aic7xxx_osm.h>
49	#include <dev/aic7xxx/aic7xxx_inline.h>
50	#include <dev/aic7xxx/aicasm/aicasm_insformat.h>
51	#endif
52		46
53	/*************************** Lookup Tables ********************************/	47	/*************************** Lookup Tables ********************************/
54	static const char *const ahc_chip_names[] = {	48	static const char *const ahc_chip_names[] = {
@@ -67,7 +61,6 @@ static const char *const ahc_chip_names[] = { · 12 unmodified lines
67	"aic7892",	61	"aic7892",
68	"aic7899"	62	"aic7899"
69	};	63	};
70	static const u_int num_chip_names = ARRAY_SIZE(ahc_chip_names);
71		64
72	/*	65	/*
73	* Hardware error codes.	66	* Hardware error codes.
@@ -4509,17 +4502,11 @@ ahc_free(struct ahc_softc *ahc) · 4435 unmodified lines
4509	case 2:	4502	case 2:
4510	ahc_dma_tag_destroy(ahc, ahc->shared_data_dmat);	4503	ahc_dma_tag_destroy(ahc, ahc->shared_data_dmat);
4511	case 1:	4504	case 1:
4512	#ifndef __linux__
4513	ahc_dma_tag_destroy(ahc, ahc->buffer_dmat);
4514	#endif
4515	break;	4505	break;
4516	case 0:	4506	case 0:
4517	break;	4507	break;
4518	}	4508	}
4519		4509
4520	#ifndef __linux__
4521	ahc_dma_tag_destroy(ahc, ahc->parent_dmat);
4522	#endif
4523	ahc_platform_free(ahc);	4510	ahc_platform_free(ahc);
4524	ahc_fini_scbdata(ahc);	4511	ahc_fini_scbdata(ahc);
4525	for (i = 0; i < AHC_NUM_TARGETS; i++) {	4512	for (i = 0; i < AHC_NUM_TARGETS; i++) {
@@ -5005,9 +4992,7 @@ ahc_alloc_scbs(struct ahc_softc *ahc) · 479 unmodified lines
5005	newcount = min(newcount, (AHC_SCB_MAX_ALLOC - scb_data->numscbs));	4992	newcount = min(newcount, (AHC_SCB_MAX_ALLOC - scb_data->numscbs));
5006	for (i = 0; i < newcount; i++) {	4993	for (i = 0; i < newcount; i++) {
5007	struct scb_platform_data *pdata;	4994	struct scb_platform_data *pdata;
5008	#ifndef __linux__	4995
5009	int error;
5010	#endif
5011	pdata = kmalloc(sizeof(*pdata), GFP_ATOMIC);	4996	pdata = kmalloc(sizeof(*pdata), GFP_ATOMIC);
5012	if (pdata == NULL)	4997	if (pdata == NULL)
5013	break;	4998	break;
@@ -5021,12 +5006,6 @@ ahc_alloc_scbs(struct ahc_softc *ahc) · 7 unmodified lines
5021	next_scb->sg_list_phys = physaddr + sizeof(struct ahc_dma_seg);	5006	next_scb->sg_list_phys = physaddr + sizeof(struct ahc_dma_seg);
5022	next_scb->ahc_softc = ahc;	5007	next_scb->ahc_softc = ahc;
5023	next_scb->flags = SCB_FREE;	5008	next_scb->flags = SCB_FREE;
5024	#ifndef __linux__
5025	error = ahc_dmamap_create(ahc, ahc->buffer_dmat, /flags/0,
5026	&next_scb->dmamap);
5027	if (error != 0)
5028	break;
5029	#endif
5030	next_scb->hscb = &scb_data->hscbs[scb_data->numscbs];	5009	next_scb->hscb = &scb_data->hscbs[scb_data->numscbs];
5031	next_scb->hscb->tag = ahc->scb_data->numscbs;	5010	next_scb->hscb->tag = ahc->scb_data->numscbs;
5032	SLIST_INSERT_HEAD(&ahc->scb_data->free_scbs,	5011	SLIST_INSERT_HEAD(&ahc->scb_data->free_scbs,
@@ -5325,24 +5304,6 @@ ahc_init(struct ahc_softc *ahc) · 292 unmodified lines
5325	if ((AHC_TMODE_ENABLE & (0x1 << ahc->unit)) == 0)	5304	if ((AHC_TMODE_ENABLE & (0x1 << ahc->unit)) == 0)
5326	ahc->features &= ~AHC_TARGETMODE;	5305	ahc->features &= ~AHC_TARGETMODE;
5327		5306
5328	#ifndef __linux__
5329	/* DMA tag for mapping buffers into device visible space. */
5330	if (ahc_dma_tag_create(ahc, ahc->parent_dmat, /alignment/1,
5331	/boundary/BUS_SPACE_MAXADDR_32BIT + 1,
5332	/lowaddr/ahc->flags & AHC_39BIT_ADDRESSING
5333	? (dma_addr_t)0x7FFFFFFFFFULL
5334	: BUS_SPACE_MAXADDR_32BIT,
5335	/highaddr/BUS_SPACE_MAXADDR,
5336	/filter/NULL, /filterarg/NULL,
5337	/maxsize/(AHC_NSEG - 1) * PAGE_SIZE,
5338	/nsegments/AHC_NSEG,
5339	/maxsegsz/AHC_MAXTRANSFER_SIZE,
5340	/flags/BUS_DMA_ALLOCNOW,
5341	&ahc->buffer_dmat) != 0) {
5342	return (ENOMEM);
5343	}
5344	#endif
5345
5346	ahc->init_level++;	5307	ahc->init_level++;
5347		5308
5348	/*	5309	/*

drivers/scsi/aic7xxx/aic7xxx_pci.c+0−7

  * $Id: //depot/aic7xxx/aic7xxx/aic7xxx_pci.c#79 $
  */
-#ifdef __linux__
 #include "aic7xxx_osm.h"
 #include "aic7xxx_inline.h"
 #include "aic7xxx_93cx6.h"
-#else
-#include <dev/aic7xxx/aic7xxx_osm.h>
-#include <dev/aic7xxx/aic7xxx_inline.h>
-#include <dev/aic7xxx/aic7xxx_93cx6.h>
-#endif
 #include "aic7xxx_pci.h"
 static inline uint64_t

drivers/scsi/aic7xxx/aicasm/aicasm.h+0−4

  * $FreeBSD$
  */
-#ifdef __linux__
 #include "../queue.h"
-#else
-#include <sys/queue.h>
-#endif
 #ifndef TRUE
 #define TRUE 1

drivers/scsi/aic7xxx/aicasm/aicasm_gram.y+0−4

 #include <string.h>
 #include <sysexits.h>
-#ifdef __linux__
 #include "../queue.h"
-#else
-#include <sys/queue.h>
-#endif
 #include "aicasm.h"
 #include "aicasm_symbol.h"

drivers/scsi/aic7xxx/aicasm/aicasm_macro_gram.y+0−4

 #include <string.h>
 #include <sysexits.h>
-#ifdef __linux__
 #include "../queue.h"
-#else
-#include <sys/queue.h>
-#endif
 #include "aicasm.h"
 #include "aicasm_symbol.h"

drivers/scsi/aic7xxx/aicasm/aicasm_macro_scan.l+0−4

 #include <stdio.h>
 #include <string.h>
 #include <sysexits.h>
-#ifdef __linux__
 #include "../queue.h"
-#else
-#include <sys/queue.h>
-#endif
 #include "aicasm.h"
 #include "aicasm_symbol.h"

drivers/scsi/aic7xxx/aicasm/aicasm_scan.l+0−4

 #include <stdio.h>
 #include <string.h>
 #include <sysexits.h>
-#ifdef __linux__
 #include "../queue.h"
-#else
-#include <sys/queue.h>
-#endif
 #include "aicasm.h"
 #include "aicasm_symbol.h"

drivers/scsi/aic7xxx/aicasm/aicasm_symbol.c+0−4

 #include <sys/types.h>
-#ifdef __linux__
 #include "aicdb.h"
-#else
-#include <db.h>
-#endif
 #include <fcntl.h>
 #include <inttypes.h>
 #include <regex.h>

drivers/scsi/aic7xxx/aicasm/aicasm_symbol.h+0−4

  * $FreeBSD$
  */
-#ifdef __linux__
 #include "../queue.h"
-#else
-#include <sys/queue.h>
-#endif
 typedef enum {
 	UNINITIALIZED,

drivers/scsi/aic94xx/aic94xx_init.c+2−7

 		goto Err_remove;
 	err = -ENODEV;
-	if (!pci_set_dma_mask(dev, DMA_BIT_MASK(64))
+	if (dma_set_mask_and_coherent(&dev->dev, DMA_BIT_MASK(64)) ||
-	    && !pci_set_consistent_dma_mask(dev, DMA_BIT_MASK(64)))
+	    dma_set_mask_and_coherent(&dev->dev, DMA_BIT_MASK(32))) {
-		;
-	else if (!pci_set_dma_mask(dev, DMA_BIT_MASK(32))
-		 && !pci_set_consistent_dma_mask(dev, DMA_BIT_MASK(32)))
-		;
-	else {
 		asd_printk("no suitable DMA mask for %s\n", pci_name(dev));
 		goto Err_remove;
 	}

drivers/scsi/aic94xx/aic94xx_scb.c+5−0

 	switch (pd->max_sas_lrate) {
 	case SAS_LINK_RATE_6_0_GBPS:
 		*speed_mask &= ~SAS_SPEED_60_DIS;
+		/* fall through*/
 	default:
 	case SAS_LINK_RATE_3_0_GBPS:
 		*speed_mask &= ~SAS_SPEED_30_DIS;
+		/* fall through*/
 	case SAS_LINK_RATE_1_5_GBPS:
 		*speed_mask &= ~SAS_SPEED_15_DIS;
 	}
 	switch (pd->min_sas_lrate) {
 	case SAS_LINK_RATE_6_0_GBPS:
 		*speed_mask |= SAS_SPEED_30_DIS;
+		/* fall through*/
 	case SAS_LINK_RATE_3_0_GBPS:
 		*speed_mask |= SAS_SPEED_15_DIS;
 	default:
 	switch (pd->max_sata_lrate) {
 	case SAS_LINK_RATE_3_0_GBPS:
 		*speed_mask &= ~SATA_SPEED_30_DIS;
+		/* fall through*/
 	default:
 	case SAS_LINK_RATE_1_5_GBPS:
 		*speed_mask &= ~SATA_SPEED_15_DIS;
 		/* link reset retries, this should be nominal */
 		control_phy->link_reset_retries = 10;
+		/* fall through */
 	case RELEASE_SPINUP_HOLD: /* 0x02 */
 		/* decide the func_mask */

drivers/scsi/aic94xx/aic94xx_task.c+23−23

@@ -42,13 +42,13 @@ static void asd_can_dequeue(struct asd_ha_struct *asd_ha, int num) · 41 unmodified lines
42	spin_unlock_irqrestore(&asd_ha->seq.pend_q_lock, flags);	42	spin_unlock_irqrestore(&asd_ha->seq.pend_q_lock, flags);
43	}	43	}
44		44
45	/* PCI_DMA_... to our direction translation.	45	/* DMA_... to our direction translation.
46	*/	46	*/
47	static const u8 data_dir_flags[] = {	47	static const u8 data_dir_flags[] = {
48	[PCI_DMA_BIDIRECTIONAL] = DATA_DIR_BYRECIPIENT, /* UNSPECIFIED */	48	[DMA_BIDIRECTIONAL] = DATA_DIR_BYRECIPIENT, /* UNSPECIFIED */
49	[PCI_DMA_TODEVICE] = DATA_DIR_OUT, /* OUTBOUND */	49	[DMA_TO_DEVICE] = DATA_DIR_OUT, /* OUTBOUND */
50	[PCI_DMA_FROMDEVICE] = DATA_DIR_IN, /* INBOUND */	50	[DMA_FROM_DEVICE] = DATA_DIR_IN, /* INBOUND */
51	[PCI_DMA_NONE] = DATA_DIR_NONE, /* NO TRANSFER */	51	[DMA_NONE] = DATA_DIR_NONE, /* NO TRANSFER */
52	};	52	};
53		53
54	static int asd_map_scatterlist(struct sas_task *task,	54	static int asd_map_scatterlist(struct sas_task *task,
@@ -60,12 +60,12 @@ static int asd_map_scatterlist(struct sas_task *task, · 5 unmodified lines
60	struct scatterlist *sc;	60	struct scatterlist *sc;
61	int num_sg, res;	61	int num_sg, res;
62		62
63	if (task->data_dir == PCI_DMA_NONE)	63	if (task->data_dir == DMA_NONE)
64	return 0;	64	return 0;
65		65
66	if (task->num_scatter == 0) {	66	if (task->num_scatter == 0) {
67	void *p = task->scatter;	67	void *p = task->scatter;
68	dma_addr_t dma = pci_map_single(asd_ha->pcidev, p,	68	dma_addr_t dma = dma_map_single(&asd_ha->pcidev->dev, p,
69	task->total_xfer_len,	69	task->total_xfer_len,
70	task->data_dir);	70	task->data_dir);
71	sg_arr[0].bus_addr = cpu_to_le64((u64)dma);	71	sg_arr[0].bus_addr = cpu_to_le64((u64)dma);
@@ -79,7 +79,7 @@ static int asd_map_scatterlist(struct sas_task *task, · 7 unmodified lines
79	if (sas_protocol_ata(task->task_proto))	79	if (sas_protocol_ata(task->task_proto))
80	num_sg = task->num_scatter;	80	num_sg = task->num_scatter;
81	else	81	else
82	num_sg = pci_map_sg(asd_ha->pcidev, task->scatter,	82	num_sg = dma_map_sg(&asd_ha->pcidev->dev, task->scatter,
83	task->num_scatter, task->data_dir);	83	task->num_scatter, task->data_dir);
84	if (num_sg == 0)	84	if (num_sg == 0)
85	return -ENOMEM;	85	return -ENOMEM;
@@ -126,8 +126,8 @@ static int asd_map_scatterlist(struct sas_task *task, · 40 unmodified lines
126	return 0;	126	return 0;
127	err_unmap:	127	err_unmap:
128	if (sas_protocol_ata(task->task_proto))	128	if (sas_protocol_ata(task->task_proto))
129	pci_unmap_sg(asd_ha->pcidev, task->scatter, task->num_scatter,	129	dma_unmap_sg(&asd_ha->pcidev->dev, task->scatter,
130	task->data_dir);	130	task->num_scatter, task->data_dir);
131	return res;	131	return res;
132	}	132	}
133		133
@@ -136,21 +136,21 @@ static void asd_unmap_scatterlist(struct asd_ascb *ascb) · 2 unmodified lines
136	struct asd_ha_struct *asd_ha = ascb->ha;	136	struct asd_ha_struct *asd_ha = ascb->ha;
137	struct sas_task *task = ascb->uldd_task;	137	struct sas_task *task = ascb->uldd_task;
138		138
139	if (task->data_dir == PCI_DMA_NONE)	139	if (task->data_dir == DMA_NONE)
140	return;	140	return;
141		141
142	if (task->num_scatter == 0) {	142	if (task->num_scatter == 0) {
143	dma_addr_t dma = (dma_addr_t)	143	dma_addr_t dma = (dma_addr_t)
144	le64_to_cpu(ascb->scb->ssp_task.sg_element[0].bus_addr);	144	le64_to_cpu(ascb->scb->ssp_task.sg_element[0].bus_addr);
145	pci_unmap_single(ascb->ha->pcidev, dma, task->total_xfer_len,	145	dma_unmap_single(&ascb->ha->pcidev->dev, dma,
146	task->data_dir);	146	task->total_xfer_len, task->data_dir);
147	return;	147	return;
148	}	148	}
149		149
150	asd_free_coherent(asd_ha, ascb->sg_arr);	150	asd_free_coherent(asd_ha, ascb->sg_arr);
151	if (task->task_proto != SAS_PROTOCOL_STP)	151	if (task->task_proto != SAS_PROTOCOL_STP)
152	pci_unmap_sg(asd_ha->pcidev, task->scatter, task->num_scatter,	152	dma_unmap_sg(&asd_ha->pcidev->dev, task->scatter,
153	task->data_dir);	153	task->num_scatter, task->data_dir);
154	}	154	}
155		155
156	/* ---------- Task complete tasklet ---------- */	156	/* ---------- Task complete tasklet ---------- */
@@ -436,10 +436,10 @@ static int asd_build_smp_ascb(struct asd_ascb ascb, struct sas_task task, · 279 unmodified lines
436	struct domain_device *dev = task->dev;	436	struct domain_device *dev = task->dev;
437	struct scb *scb;	437	struct scb *scb;
438		438
439	pci_map_sg(asd_ha->pcidev, &task->smp_task.smp_req, 1,	439	dma_map_sg(&asd_ha->pcidev->dev, &task->smp_task.smp_req, 1,
440	PCI_DMA_TODEVICE);	440	DMA_TO_DEVICE);
441	pci_map_sg(asd_ha->pcidev, &task->smp_task.smp_resp, 1,	441	dma_map_sg(&asd_ha->pcidev->dev, &task->smp_task.smp_resp, 1,
442	PCI_DMA_FROMDEVICE);	442	DMA_FROM_DEVICE);
443		443
444	scb = ascb->scb;	444	scb = ascb->scb;
445		445
@@ -471,10 +471,10 @@ static void asd_unbuild_smp_ascb(struct asd_ascb *a) · 25 unmodified lines
471	struct sas_task *task = a->uldd_task;	471	struct sas_task *task = a->uldd_task;
472		472
473	BUG_ON(!task);	473	BUG_ON(!task);
474	pci_unmap_sg(a->ha->pcidev, &task->smp_task.smp_req, 1,	474	dma_unmap_sg(&a->ha->pcidev->dev, &task->smp_task.smp_req, 1,
475	PCI_DMA_TODEVICE);	475	DMA_TO_DEVICE);
476	pci_unmap_sg(a->ha->pcidev, &task->smp_task.smp_resp, 1,	476	dma_unmap_sg(&a->ha->pcidev->dev, &task->smp_task.smp_resp, 1,
477	PCI_DMA_FROMDEVICE);	477	DMA_FROM_DEVICE);
478	}	478	}
479		479
480	/* ---------- SSP ---------- */	480	/* ---------- SSP ---------- */

drivers/scsi/am53c974.c+12−42

 static inline struct pci_esp_priv *pci_esp_get_priv(struct esp *esp)
 {
-	struct pci_dev *pdev = esp->dev;
+	return dev_get_drvdata(esp->dev);
-	return pci_get_drvdata(pdev);
 }
 static void pci_esp_write8(struct esp *esp, u8 val, unsigned long reg)
 	return iowrite32(val, esp->regs + (reg * 4UL));
 }
-static dma_addr_t pci_esp_map_single(struct esp *esp, void *buf,
-				     size_t sz, int dir)
-{
-	return pci_map_single(esp->dev, buf, sz, dir);
-}
-static int pci_esp_map_sg(struct esp *esp, struct scatterlist *sg,
-			  int num_sg, int dir)
-{
-	return pci_map_sg(esp->dev, sg, num_sg, dir);
-}
-static void pci_esp_unmap_single(struct esp *esp, dma_addr_t addr,
-				 size_t sz, int dir)
-{
-	pci_unmap_single(esp->dev, addr, sz, dir);
-}
-static void pci_esp_unmap_sg(struct esp *esp, struct scatterlist *sg,
-			     int num_sg, int dir)
-{
-	pci_unmap_sg(esp->dev, sg, num_sg, dir);
-}
 static int pci_esp_irq_pending(struct esp *esp)
 {
 	struct pci_esp_priv *pep = pci_esp_get_priv(esp);
 static const struct esp_driver_ops pci_esp_ops = {
 	.esp_write8	=	pci_esp_write8,
 	.esp_read8	=	pci_esp_read8,
-	.map_single	=	pci_esp_map_single,
-	.map_sg		=	pci_esp_map_sg,
-	.unmap_single	=	pci_esp_unmap_single,
-	.unmap_sg	=	pci_esp_unmap_sg,
 	.irq_pending	=	pci_esp_irq_pending,
 	.reset_dma	=	pci_esp_reset_dma,
 	.dma_drain	=	pci_esp_dma_drain,
 static void dc390_check_eeprom(struct esp *esp)
 {
+	struct pci_dev *pdev = to_pci_dev(esp->dev);
 	u8 EEbuf[128];
 	u16 *ptr = (u16 *)EEbuf, wval = 0;
 	int i;
-	dc390_read_eeprom((struct pci_dev *)esp->dev, ptr);
+	dc390_read_eeprom(pdev, ptr);
 	for (i = 0; i < DC390_EEPROM_LEN; i++, ptr++)
 		wval += *ptr;
 	/* no Tekram EEprom found */
 	if (wval != 0x1234) {
-		struct pci_dev *pdev = esp->dev;
 		dev_printk(KERN_INFO, &pdev->dev,
 			   "No valid Tekram EEprom found\n");
 		return;
 		return -ENODEV;
 	}
-	if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
+	if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) {
 		dev_printk(KERN_INFO, &pdev->dev,
 			   "failed to set 32bit DMA mask\n");
 		goto fail_disable_device;
 	esp = shost_priv(shost);
 	esp->host = shost;
-	esp->dev = pdev;
+	esp->dev = &pdev->dev;
 	esp->ops = &pci_esp_ops;
 	/*
 	 * The am53c974 HBA has a design flaw of generating
 	pci_set_master(pdev);
-	esp->command_block = pci_alloc_consistent(pdev, 16,
+	esp->command_block = dma_alloc_coherent(&pdev->dev, 16,
-						  &esp->command_block_dma);
+			&esp->command_block_dma, GFP_KERNEL);
 	if (!esp->command_block) {
 		dev_printk(KERN_ERR, &pdev->dev,
 			   "failed to allocate command block\n");
 	/* Assume 40MHz clock */
 	esp->cfreq = 40000000;
-	err = scsi_esp_register(esp, &pdev->dev);
+	err = scsi_esp_register(esp);
 	if (err)
 		goto fail_free_irq;
 	free_irq(pdev->irq, esp);
 fail_unmap_command_block:
 	pci_set_drvdata(pdev, NULL);
-	pci_free_consistent(pdev, 16, esp->command_block,
+	dma_free_coherent(&pdev->dev, 16, esp->command_block,
-			    esp->command_block_dma);
+			  esp->command_block_dma);
 fail_unmap_regs:
 	pci_iounmap(pdev, esp->regs);
 fail_release_regions:
 	scsi_esp_unregister(esp);
 	free_irq(pdev->irq, esp);
 	pci_set_drvdata(pdev, NULL);
-	pci_free_consistent(pdev, 16, esp->command_block,
+	dma_free_coherent(&pdev->dev, 16, esp->command_block,
-			    esp->command_block_dma);
+			  esp->command_block_dma);
 	pci_iounmap(pdev, esp->regs);
 	pci_release_regions(pdev);
 	pci_disable_device(pdev);

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

 static void arcmsr_drain_donequeue(struct AdapterControlBlock *acb, struct CommandControlBlock *pCCB, bool error)
 {
-	int id, lun;
 	if ((pCCB->acb != acb) || (pCCB->startdone != ARCMSR_CCB_START)) {
 		if (pCCB->startdone == ARCMSR_CCB_ABORTED) {
 			struct scsi_cmnd *abortcmd = pCCB->pcmd;
 			if (abortcmd) {
-				id = abortcmd->device->id;
-				lun = abortcmd->device->lun;
 				abortcmd->result |= DID_ABORT << 16;
 				arcmsr_ccb_complete(pCCB);
 				printk(KERN_NOTICE "arcmsr%d: pCCB ='0x%p' isr got aborted command \n",
 	writel(ARCMSR_INBOUND_MESG0_STOP_BGRB, &reg->inbound_msgaddr0);
 	if (!arcmsr_hbaA_wait_msgint_ready(acb)) {
 		printk(KERN_NOTICE
-			"arcmsr%d: wait 'stop adapter background rebulid' timeout\n"
+			"arcmsr%d: wait 'stop adapter background rebuild' timeout\n"
 			, acb->host->host_no);
 	}
 }
 	if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
 		printk(KERN_NOTICE
-			"arcmsr%d: wait 'stop adapter background rebulid' timeout\n"
+			"arcmsr%d: wait 'stop adapter background rebuild' timeout\n"
 			, acb->host->host_no);
 	}
 }
 	writel(ARCMSR_HBCMU_DRV2IOP_MESSAGE_CMD_DONE, &reg->inbound_doorbell);
 	if (!arcmsr_hbaC_wait_msgint_ready(pACB)) {
 		printk(KERN_NOTICE
-			"arcmsr%d: wait 'stop adapter background rebulid' timeout\n"
+			"arcmsr%d: wait 'stop adapter background rebuild' timeout\n"
 			, pACB->host->host_no);
 	}
 	return;
 	pACB->acb_flags &= ~ACB_F_MSG_START_BGRB;
 	writel(ARCMSR_INBOUND_MESG0_STOP_BGRB, reg->inbound_msgaddr0);
 	if (!arcmsr_hbaD_wait_msgint_ready(pACB))
-		pr_notice("arcmsr%d: wait 'stop adapter background rebulid' "
+		pr_notice("arcmsr%d: wait 'stop adapter background rebuild' "
 			"timeout\n", pACB->host->host_no);
 }
 	pACB->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
 	writel(pACB->out_doorbell, &reg->iobound_doorbell);
 	if (!arcmsr_hbaE_wait_msgint_ready(pACB)) {
-		pr_notice("arcmsr%d: wait 'stop adapter background rebulid' "
+		pr_notice("arcmsr%d: wait 'stop adapter background rebuild' "
 			"timeout\n", pACB->host->host_no);
 	}
 }
 	writel(ARCMSR_INBOUND_MESG0_START_BGRB, &reg->inbound_msgaddr0);
 	if (!arcmsr_hbaA_wait_msgint_ready(acb)) {
 		printk(KERN_NOTICE "arcmsr%d: wait 'start adapter background \
-				rebulid' timeout \n", acb->host->host_no);
+				rebuild' timeout \n", acb->host->host_no);
 	}
 }
 	writel(ARCMSR_MESSAGE_START_BGRB, reg->drv2iop_doorbell);
 	if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
 		printk(KERN_NOTICE "arcmsr%d: wait 'start adapter background \
-				rebulid' timeout \n",acb->host->host_no);
+				rebuild' timeout \n",acb->host->host_no);
 	}
 }
 	writel(ARCMSR_HBCMU_DRV2IOP_MESSAGE_CMD_DONE, &phbcmu->inbound_doorbell);
 	if (!arcmsr_hbaC_wait_msgint_ready(pACB)) {
 		printk(KERN_NOTICE "arcmsr%d: wait 'start adapter background \
-				rebulid' timeout \n", pACB->host->host_no);
+				rebuild' timeout \n", pACB->host->host_no);
 	}
 	return;
 }
 	writel(ARCMSR_INBOUND_MESG0_START_BGRB, pmu->inbound_msgaddr0);
 	if (!arcmsr_hbaD_wait_msgint_ready(pACB)) {
 		pr_notice("arcmsr%d: wait 'start adapter "
-			"background rebulid' timeout\n", pACB->host->host_no);
+			"background rebuild' timeout\n", pACB->host->host_no);
 	}
 }
 	writel(pACB->out_doorbell, &pmu->iobound_doorbell);
 	if (!arcmsr_hbaE_wait_msgint_ready(pACB)) {
 		pr_notice("arcmsr%d: wait 'start adapter "
-			"background rebulid' timeout \n", pACB->host->host_no);
+			"background rebuild' timeout \n", pACB->host->host_no);
 	}
 }
 		pci_read_config_byte(acb->pdev, i, &value[i]);
 	}
 	/* hardware reset signal */
-	if ((acb->dev_id == 0x1680)) {
+	if (acb->dev_id == 0x1680) {
 		writel(ARCMSR_ARC1680_BUS_RESET, &pmuA->reserved1[0]);
-	} else if ((acb->dev_id == 0x1880)) {
+	} else if (acb->dev_id == 0x1880) {
 		do {
 			count++;
 			writel(0xF, &pmuC->write_sequence);
 		} while (((readl(&pmuE->host_diagnostic_3xxx) &
 			ARCMSR_ARC1884_DiagWrite_ENABLE) == 0) && (count < 5));
 		writel(ARCMSR_ARC188X_RESET_ADAPTER, &pmuE->host_diagnostic_3xxx);
-	} else if ((acb->dev_id == 0x1214)) {
+	} else if (acb->dev_id == 0x1214) {
 		writel(0x20, pmuD->reset_request);
 	} else {
 		pci_write_config_byte(acb->pdev, 0x84, 0x20);

drivers/scsi/atp870u.c+3−3

@@ -1193,7 +1193,7 @@ static void atp870u_free_tables(struct Scsi_Host *host) · 1192 unmodified lines
1193	for (k = 0; k < 16; k++) {	1193	for (k = 0; k < 16; k++) {
1194	if (!atp_dev->id[j][k].prd_table)	1194	if (!atp_dev->id[j][k].prd_table)
1195	continue;	1195	continue;
1196	pci_free_consistent(atp_dev->pdev, 1024, atp_dev->id[j][k].prd_table, atp_dev->id[j][k].prd_bus);	1196	dma_free_coherent(&atp_dev->pdev->dev, 1024, atp_dev->id[j][k].prd_table, atp_dev->id[j][k].prd_bus);
1197	atp_dev->id[j][k].prd_table = NULL;	1197	atp_dev->id[j][k].prd_table = NULL;
1198	}	1198	}
1199	}	1199	}
@@ -1205,7 +1205,7 @@ static int atp870u_init_tables(struct Scsi_Host *host) · 5 unmodified lines
1205	int c,k;	1205	int c,k;
1206	for(c=0;c < 2;c++) {	1206	for(c=0;c < 2;c++) {
1207	for(k=0;k<16;k++) {	1207	for(k=0;k<16;k++) {
1208	atp_dev->id[c][k].prd_table = pci_alloc_consistent(atp_dev->pdev, 1024, &(atp_dev->id[c][k].prd_bus));	1208	atp_dev->id[c][k].prd_table = dma_alloc_coherent(&atp_dev->pdev->dev, 1024, &(atp_dev->id[c][k].prd_bus), GFP_KERNEL);
1209	if (!atp_dev->id[c][k].prd_table) {	1209	if (!atp_dev->id[c][k].prd_table) {
1210	printk("atp870u_init_tables fail\n");	1210	printk("atp870u_init_tables fail\n");
1211	atp870u_free_tables(host);	1211	atp870u_free_tables(host);
@@ -1509,7 +1509,7 @@ static int atp870u_probe(struct pci_dev pdev, const struct pci_device_id ent) · 297 unmodified lines
1509	if (err)	1509	if (err)
1510	goto fail;	1510	goto fail;
1511		1511
1512	if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {	1512	if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) {
1513	printk(KERN_ERR "atp870u: DMA mask required but not available.\n");	1513	printk(KERN_ERR "atp870u: DMA mask required but not available.\n");
1514	err = -EIO;	1514	err = -EIO;
1515	goto disable_device;	1515	goto disable_device;

drivers/scsi/be2iscsi/be_cmds.c+5−5

@@ -520,7 +520,7 @@ int beiscsi_process_mcc_compl(struct be_ctrl_info *ctrl, · 519 unmodified lines
520	**/	520	**/
521	tag_mem = &ctrl->ptag_state[tag].tag_mem_state;	521	tag_mem = &ctrl->ptag_state[tag].tag_mem_state;
522	if (tag_mem->size) {	522	if (tag_mem->size) {
523	pci_free_consistent(ctrl->pdev, tag_mem->size,	523	dma_free_coherent(&ctrl->pdev->dev, tag_mem->size,
524	tag_mem->va, tag_mem->dma);	524	tag_mem->va, tag_mem->dma);
525	tag_mem->size = 0;	525	tag_mem->size = 0;
526	}	526	}
@@ -1269,12 +1269,12 @@ int beiscsi_check_supported_fw(struct be_ctrl_info *ctrl, · 742 unmodified lines
1269	struct be_sge *sge = nonembedded_sgl(wrb);	1269	struct be_sge *sge = nonembedded_sgl(wrb);
1270	int status = 0;	1270	int status = 0;
1271		1271
1272	nonemb_cmd.va = pci_alloc_consistent(ctrl->pdev,	1272	nonemb_cmd.va = dma_alloc_coherent(&ctrl->pdev->dev,
1273	sizeof(struct be_mgmt_controller_attributes),	1273	sizeof(struct be_mgmt_controller_attributes),
1274	&nonemb_cmd.dma);	1274	&nonemb_cmd.dma, GFP_KERNEL);
1275	if (nonemb_cmd.va == NULL) {	1275	if (nonemb_cmd.va == NULL) {
1276	beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,	1276	beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
1277	"BG_%d : pci_alloc_consistent failed in %s\n",	1277	"BG_%d : dma_alloc_coherent failed in %s\n",
1278	__func__);	1278	__func__);
1279	return -ENOMEM;	1279	return -ENOMEM;
1280	}	1280	}
@@ -1314,7 +1314,7 @@ int beiscsi_check_supported_fw(struct be_ctrl_info *ctrl, · 33 unmodified lines
1314	"BG_%d : Failed in beiscsi_check_supported_fw\n");	1314	"BG_%d : Failed in beiscsi_check_supported_fw\n");
1315	mutex_unlock(&ctrl->mbox_lock);	1315	mutex_unlock(&ctrl->mbox_lock);
1316	if (nonemb_cmd.va)	1316	if (nonemb_cmd.va)
1317	pci_free_consistent(ctrl->pdev, nonemb_cmd.size,	1317	dma_free_coherent(&ctrl->pdev->dev, nonemb_cmd.size,
1318	nonemb_cmd.va, nonemb_cmd.dma);	1318	nonemb_cmd.va, nonemb_cmd.dma);
1319		1319
1320	return status;	1320	return status;

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

 			status = beiscsi_get_initiator_name(phba, buf, false);
 			if (status < 0) {
 				beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
-					    "BS_%d : Retreiving Initiator Name Failed\n");
+					    "BS_%d : Retrieving Initiator Name Failed\n");
 				status = 0;
 			}
 		}
 	else
 		req_memsize = sizeof(struct tcp_connect_and_offload_in_v1);
-	nonemb_cmd.va = pci_alloc_consistent(phba->ctrl.pdev,
+	nonemb_cmd.va = dma_alloc_coherent(&phba->ctrl.pdev->dev,
 				req_memsize,
-				&nonemb_cmd.dma);
+				&nonemb_cmd.dma, GFP_KERNEL);
 	if (nonemb_cmd.va == NULL) {
 		beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
 			    "BS_%d : mgmt_open_connection Failed for cid=%d\n",
 			    beiscsi_ep->ep_cid);
-		pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+		dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
 				    nonemb_cmd.va, nonemb_cmd.dma);
 		beiscsi_free_ep(beiscsi_ep);
 		return -EAGAIN;
 			    "BS_%d : mgmt_open_connection Failed");
 		if (ret != -EBUSY)
-			pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+			dma_free_coherent(&phba->ctrl.pdev->dev,
-					    nonemb_cmd.va, nonemb_cmd.dma);
+					nonemb_cmd.size, nonemb_cmd.va,
+					nonemb_cmd.dma);
 		beiscsi_free_ep(beiscsi_ep);
 		return ret;
 	beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
 		    "BS_%d : mgmt_open_connection Success\n");
-	pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+	dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
 			    nonemb_cmd.va, nonemb_cmd.dma);
 	return 0;
 }

drivers/scsi/be2iscsi/be_main.c+31−43

 	}
 	pci_set_master(pcidev);
-	ret = pci_set_dma_mask(pcidev, DMA_BIT_MASK(64));
+	ret = dma_set_mask_and_coherent(&pcidev->dev, DMA_BIT_MASK(64));
 	if (ret) {
-		ret = pci_set_dma_mask(pcidev, DMA_BIT_MASK(32));
+		ret = dma_set_mask_and_coherent(&pcidev->dev, DMA_BIT_MASK(32));
-		if (ret) {
-			dev_err(&pcidev->dev, "Could not set PCI DMA Mask\n");
-			goto pci_region_release;
-		} else {
-			ret = pci_set_consistent_dma_mask(pcidev,
-							  DMA_BIT_MASK(32));
-		}
-	} else {
-		ret = pci_set_consistent_dma_mask(pcidev, DMA_BIT_MASK(64));
 		if (ret) {
 			dev_err(&pcidev->dev, "Could not set PCI DMA Mask\n");
 			goto pci_region_release;
 	if (status)
 		return status;
 	mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
-	mbox_mem_alloc->va = pci_alloc_consistent(pdev,
+	mbox_mem_alloc->va = dma_alloc_coherent(&pdev->dev,
-						  mbox_mem_alloc->size,
+			mbox_mem_alloc->size, &mbox_mem_alloc->dma, GFP_KERNEL);
-						  &mbox_mem_alloc->dma);
 	if (!mbox_mem_alloc->va) {
 		beiscsi_unmap_pci_function(phba);
 		return -ENOMEM;
 {
 	struct be_queue_info *cq;
 	struct sol_cqe *sol;
-	struct dmsg_cqe *dmsg;
 	unsigned int total = 0;
 	unsigned int num_processed = 0;
 	unsigned short code = 0, cid = 0;
 				    "BM_%d : Received %s[%d] on CID : %d\n",
 				    cqe_desc[code], code, cid);
-			dmsg = (struct dmsg_cqe *)sol;
 			hwi_complete_drvr_msgs(beiscsi_conn, phba, sol);
 			break;
 		case UNSOL_HDR_NOTIFY:
 		/* Map addr only if there is data_count */
 		if (dsp_value) {
-			io_task->mtask_addr = pci_map_single(phba->pcidev,
+			io_task->mtask_addr = dma_map_single(&phba->pcidev->dev,
 							     task->data,
 							     task->data_count,
-							     PCI_DMA_TODEVICE);
+							     DMA_TO_DEVICE);
-			if (pci_dma_mapping_error(phba->pcidev,
+			if (dma_mapping_error(&phba->pcidev->dev,
 						  io_task->mtask_addr))
 				return -ENOMEM;
 			io_task->mtask_data_count = task->data_count;
 		       BEISCSI_MAX_FRAGS_INIT);
 		curr_alloc_size = min(be_max_phys_size * 1024, alloc_size);
 		do {
-			mem_arr->virtual_address = pci_alloc_consistent(
+			mem_arr->virtual_address =
-							phba->pcidev,
+				dma_alloc_coherent(&phba->pcidev->dev,
-							curr_alloc_size,
+					curr_alloc_size, &bus_add, GFP_KERNEL);
-							&bus_add);
 			if (!mem_arr->virtual_address) {
 				if (curr_alloc_size <= BE_MIN_MEM_SIZE)
 					goto free_mem;
 	mem_descr->num_elements = j;
 	while ((i) || (j)) {
 		for (j = mem_descr->num_elements; j > 0; j--) {
-			pci_free_consistent(phba->pcidev,
+			dma_free_coherent(&phba->pcidev->dev,
 					    mem_descr->mem_array[j - 1].size,
 					    mem_descr->mem_array[j - 1].
 					    virtual_address,
 		eq = &phwi_context->be_eq[i].q;
 		mem = &eq->dma_mem;
 		phwi_context->be_eq[i].phba = phba;
-		eq_vaddress = pci_alloc_consistent(phba->pcidev,
+		eq_vaddress = dma_alloc_coherent(&phba->pcidev->dev,
 						   num_eq_pages * PAGE_SIZE,
-						   &paddr);
+						   &paddr, GFP_KERNEL);
 		if (!eq_vaddress) {
 			ret = -ENOMEM;
 			goto create_eq_error;
 		eq = &phwi_context->be_eq[i].q;
 		mem = &eq->dma_mem;
 		if (mem->va)
-			pci_free_consistent(phba->pcidev, num_eq_pages
+			dma_free_coherent(&phba->pcidev->dev, num_eq_pages
 					    * PAGE_SIZE,
 					    mem->va, mem->dma);
 	}
 		pbe_eq->cq = cq;
 		pbe_eq->phba = phba;
 		mem = &cq->dma_mem;
-		cq_vaddress = pci_alloc_consistent(phba->pcidev,
+		cq_vaddress = dma_alloc_coherent(&phba->pcidev->dev,
 						   num_cq_pages * PAGE_SIZE,
-						   &paddr);
+						   &paddr, GFP_KERNEL);
 		if (!cq_vaddress) {
 			ret = -ENOMEM;
 			goto create_cq_error;
 		cq = &phwi_context->be_cq[i];
 		mem = &cq->dma_mem;
 		if (mem->va)
-			pci_free_consistent(phba->pcidev, num_cq_pages
+			dma_free_coherent(&phba->pcidev->dev, num_cq_pages
 					    * PAGE_SIZE,
 					    mem->va, mem->dma);
 	}
 {
 	struct be_dma_mem *mem = &q->dma_mem;
 	if (mem->va) {
-		pci_free_consistent(phba->pcidev, mem->size,
+		dma_free_coherent(&phba->pcidev->dev, mem->size,
 			mem->va, mem->dma);
 		mem->va = NULL;
 	}
 	q->len = len;
 	q->entry_size = entry_size;
 	mem->size = len * entry_size;
-	mem->va = pci_zalloc_consistent(phba->pcidev, mem->size, &mem->dma);
+	mem->va = dma_zalloc_coherent(&phba->pcidev->dev, mem->size, &mem->dma,
+			GFP_KERNEL);
 	if (!mem->va)
 		return -ENOMEM;
 	return 0;
 			     &ctrl->ptag_state[tag].tag_state)) {
 			ptag_mem = &ctrl->ptag_state[tag].tag_mem_state;
 			if (ptag_mem->size) {
-				pci_free_consistent(ctrl->pdev,
+				dma_free_coherent(&ctrl->pdev->dev,
 						    ptag_mem->size,
 						    ptag_mem->va,
 						    ptag_mem->dma);
 	j = 0;
 	for (i = 0; i < SE_MEM_MAX; i++) {
 		for (j = mem_descr->num_elements; j > 0; j--) {
-			pci_free_consistent(phba->pcidev,
+			dma_free_coherent(&phba->pcidev->dev,
 			  mem_descr->mem_array[j - 1].size,
 			  mem_descr->mem_array[j - 1].virtual_address,
 			  (unsigned long)mem_descr->mem_array[j - 1].
 	}
 	if (io_task->mtask_addr) {
-		pci_unmap_single(phba->pcidev,
+		dma_unmap_single(&phba->pcidev->dev,
 				 io_task->mtask_addr,
 				 io_task->mtask_data_count,
-				 PCI_DMA_TODEVICE);
+				 DMA_TO_DEVICE);
 		io_task->mtask_addr = 0;
 	}
 }
 	switch (bsg_req->msgcode) {
 	case ISCSI_BSG_HST_VENDOR:
-		nonemb_cmd.va = pci_alloc_consistent(phba->ctrl.pdev,
+		nonemb_cmd.va = dma_alloc_coherent(&phba->ctrl.pdev->dev,
 					job->request_payload.payload_len,
-					&nonemb_cmd.dma);
+					&nonemb_cmd.dma, GFP_KERNEL);
 		if (nonemb_cmd.va == NULL) {
 			beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
 				    "BM_%d : Failed to allocate memory for "
 			beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
 				    "BM_%d : MBX Tag Allocation Failed\n");
-			pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+			dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
 					    nonemb_cmd.va, nonemb_cmd.dma);
 			return -EAGAIN;
 		}
 		if (!test_bit(BEISCSI_HBA_ONLINE, &phba->state)) {
 			clear_bit(MCC_TAG_STATE_RUNNING,
 				  &phba->ctrl.ptag_state[tag].tag_state);
-			pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+			dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
 					    nonemb_cmd.va, nonemb_cmd.dma);
 			return -EIO;
 		}
 		bsg_reply->result = status;
 		bsg_job_done(job, bsg_reply->result,
 			     bsg_reply->reply_payload_rcv_len);
-		pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+		dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
 				    nonemb_cmd.va, nonemb_cmd.dma);
 		if (status || extd_status) {
 			beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
 	beiscsi_cleanup_port(phba);
 	beiscsi_free_mem(phba);
 free_port:
-	pci_free_consistent(phba->pcidev,
+	dma_free_coherent(&phba->pcidev->dev,
 			    phba->ctrl.mbox_mem_alloced.size,
 			    phba->ctrl.mbox_mem_alloced.va,
 			    phba->ctrl.mbox_mem_alloced.dma);
 	/* ctrl uninit */
 	beiscsi_unmap_pci_function(phba);
-	pci_free_consistent(phba->pcidev,
+	dma_free_coherent(&phba->pcidev->dev,
 			    phba->ctrl.mbox_mem_alloced.size,
 			    phba->ctrl.mbox_mem_alloced.va,
 			    phba->ctrl.mbox_mem_alloced.dma);

drivers/scsi/be2iscsi/be_mgmt.c+15−12

 		return rc;
 free_cmd:
-	pci_free_consistent(ctrl->pdev, nonemb_cmd->size,
+	dma_free_coherent(&ctrl->pdev->dev, nonemb_cmd->size,
 			    nonemb_cmd->va, nonemb_cmd->dma);
 	return rc;
 }
 				 struct be_dma_mem *cmd,
 				 u8 subsystem, u8 opcode, u32 size)
 {
-	cmd->va = pci_zalloc_consistent(phba->ctrl.pdev, size, &cmd->dma);
+	cmd->va = dma_zalloc_coherent(&phba->ctrl.pdev->dev, size, &cmd->dma,
+			GFP_KERNEL);
 	if (!cmd->va) {
 		beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
 			    "BG_%d : Failed to allocate memory for if info\n");
 	__beiscsi_mcc_compl_status(phba, tag, NULL, NULL);
 	tag_mem = &phba->ctrl.ptag_state[tag].tag_mem_state;
 	if (tag_mem->size) {
-		pci_free_consistent(phba->pcidev, tag_mem->size,
+		dma_free_coherent(&phba->pcidev->dev, tag_mem->size,
 				    tag_mem->va, tag_mem->dma);
 		tag_mem->size = 0;
 	}
 				    "BG_%d : Memory Allocation Failure\n");
 				/* Free the DMA memory for the IOCTL issuing */
-				pci_free_consistent(phba->ctrl.pdev,
+				dma_free_coherent(&phba->ctrl.pdev->dev,
 						    nonemb_cmd.size,
 						    nonemb_cmd.va,
 						    nonemb_cmd.dma);
 			ioctl_size += sizeof(struct be_cmd_req_hdr);
 			/* Free the previous allocated DMA memory */
-			pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+			dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
 					    nonemb_cmd.va,
 					    nonemb_cmd.dma);
 				      status);
 			boot_work = 0;
 		}
-		pci_free_consistent(phba->ctrl.pdev, bs->nonemb_cmd.size,
+		dma_free_coherent(&phba->ctrl.pdev->dev, bs->nonemb_cmd.size,
 				    bs->nonemb_cmd.va, bs->nonemb_cmd.dma);
 		bs->nonemb_cmd.va = NULL;
 		break;
 	nonemb_cmd = &phba->boot_struct.nonemb_cmd;
 	nonemb_cmd->size = sizeof(struct be_cmd_get_session_resp);
-	nonemb_cmd->va = pci_alloc_consistent(phba->ctrl.pdev,
+	nonemb_cmd->va = dma_alloc_coherent(&phba->ctrl.pdev->dev,
 					      nonemb_cmd->size,
-					      &nonemb_cmd->dma);
+					      &nonemb_cmd->dma,
+					      GFP_KERNEL);
 	if (!nonemb_cmd->va) {
 		mutex_unlock(&ctrl->mbox_lock);
 		return 0;
 		return -EINVAL;
 	nonemb_cmd.size = sizeof(union be_invldt_cmds_params);
-	nonemb_cmd.va = pci_zalloc_consistent(phba->ctrl.pdev,
+	nonemb_cmd.va = dma_zalloc_coherent(&phba->ctrl.pdev->dev,
 					      nonemb_cmd.size,
-					      &nonemb_cmd.dma);
+					      &nonemb_cmd.dma,
+					      GFP_KERNEL);
 	if (!nonemb_cmd.va) {
 		beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_EH,
 			    "BM_%d : invldt_cmds_params alloc failed\n");
 	wrb = alloc_mcc_wrb(phba, &tag);
 	if (!wrb) {
 		mutex_unlock(&ctrl->mbox_lock);
-		pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+		dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
 				    nonemb_cmd.va, nonemb_cmd.dma);
 		return -ENOMEM;
 	}
 	rc = beiscsi_mccq_compl_wait(phba, tag, NULL, &nonemb_cmd);
 	if (rc != -EBUSY)
-		pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+		dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
 				    nonemb_cmd.va, nonemb_cmd.dma);
 	return rc;
 }

drivers/scsi/bfa/bfa_defs_svc.h+1−1

@@ -1453,7 +1453,7 @@ union bfa_aen_data_u { · 1452 unmodified lines
1453	struct bfa_aen_entry_s {	1453	struct bfa_aen_entry_s {
1454	struct list_head qe;	1454	struct list_head qe;
1455	enum bfa_aen_category aen_category;	1455	enum bfa_aen_category aen_category;
1456	u32 aen_type;	1456	int aen_type;
1457	union bfa_aen_data_u aen_data;	1457	union bfa_aen_data_u aen_data;
1458	u64 aen_tv_sec;	1458	u64 aen_tv_sec;
1459	u64 aen_tv_usec;	1459	u64 aen_tv_usec;

drivers/scsi/bfa/bfa_fcbuild.c+0−108

@@ -190,27 +190,6 @@ fc_els_rsp_build(struct fchs_s *fchs, u32 d_id, u32 s_id, __be16 ox_id) · 189 unmodified lines
190	fchs->ox_id = ox_id;	190	fchs->ox_id = ox_id;
191	}	191	}
192		192
193	enum fc_parse_status
194	fc_els_rsp_parse(struct fchs_s *fchs, int len)
195	{
196	struct fc_els_cmd_s els_cmd = (struct fc_els_cmd_s ) (fchs + 1);
197	struct fc_ls_rjt_s ls_rjt = (struct fc_ls_rjt_s ) els_cmd;
198
199	len = len;
200
201	switch (els_cmd->els_code) {
202	case FC_ELS_LS_RJT:
203	if (ls_rjt->reason_code == FC_LS_RJT_RSN_LOGICAL_BUSY)
204	return FC_PARSE_BUSY;
205	else
206	return FC_PARSE_FAILURE;
207
208	case FC_ELS_ACC:
209	return FC_PARSE_OK;
210	}
211	return FC_PARSE_OK;
212	}
213
214	static void	193	static void
215	fc_bls_rsp_build(struct fchs_s *fchs, u32 d_id, u32 s_id, __be16 ox_id)	194	fc_bls_rsp_build(struct fchs_s *fchs, u32 d_id, u32 s_id, __be16 ox_id)
216	{	195	{
@@ -830,18 +809,6 @@ fc_rpsc_acc_build(struct fchs_s fchs, struct fc_rpsc_acc_s rpsc_acc, · 613 unmodified lines
830	return sizeof(struct fc_rpsc_acc_s);	809	return sizeof(struct fc_rpsc_acc_s);
831	}	810	}
832		811
833	u16
834	fc_logo_rsp_parse(struct fchs_s *fchs, int len)
835	{
836	struct fc_els_cmd_s els_cmd = (struct fc_els_cmd_s ) (fchs + 1);
837
838	len = len;
839	if (els_cmd->els_code != FC_ELS_ACC)
840	return FC_PARSE_FAILURE;
841
842	return FC_PARSE_OK;
843	}
844
845	u16	812	u16
846	fc_pdisc_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id,	813	fc_pdisc_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id,
847	wwn_t port_name, wwn_t node_name, u16 pdu_size)	814	wwn_t port_name, wwn_t node_name, u16 pdu_size)
@@ -907,40 +874,6 @@ fc_prlo_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id, · 59 unmodified lines
907	return be16_to_cpu(prlo->payload_len);	874	return be16_to_cpu(prlo->payload_len);
908	}	875	}
909		876
910	u16
911	fc_prlo_rsp_parse(struct fchs_s *fchs, int len)
912	{
913	struct fc_prlo_acc_s prlo = (struct fc_prlo_acc_s ) (fchs + 1);
914	int num_pages = 0;
915	int page = 0;
916
917	len = len;
918
919	if (prlo->command != FC_ELS_ACC)
920	return FC_PARSE_FAILURE;
921
922	num_pages = ((be16_to_cpu(prlo->payload_len)) - 4) / 16;
923
924	for (page = 0; page < num_pages; page++) {
925	if (prlo->prlo_acc_params[page].type != FC_TYPE_FCP)
926	return FC_PARSE_FAILURE;
927
928	if (prlo->prlo_acc_params[page].opa_valid != 0)
929	return FC_PARSE_FAILURE;
930
931	if (prlo->prlo_acc_params[page].rpa_valid != 0)
932	return FC_PARSE_FAILURE;
933
934	if (prlo->prlo_acc_params[page].orig_process_assc != 0)
935	return FC_PARSE_FAILURE;
936
937	if (prlo->prlo_acc_params[page].resp_process_assc != 0)
938	return FC_PARSE_FAILURE;
939	}
940	return FC_PARSE_OK;
941
942	}
943
944	u16	877	u16
945	fc_tprlo_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id,	878	fc_tprlo_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id,
946	int num_pages, enum fc_tprlo_type tprlo_type, u32 tpr_id)	879	int num_pages, enum fc_tprlo_type tprlo_type, u32 tpr_id)
@@ -971,47 +904,6 @@ fc_tprlo_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id, · 24 unmodified lines
971	return be16_to_cpu(tprlo->payload_len);	904	return be16_to_cpu(tprlo->payload_len);
972	}	905	}
973		906
974	u16
975	fc_tprlo_rsp_parse(struct fchs_s *fchs, int len)
976	{
977	struct fc_tprlo_acc_s tprlo = (struct fc_tprlo_acc_s ) (fchs + 1);
978	int num_pages = 0;
979	int page = 0;
980
981	len = len;
982
983	if (tprlo->command != FC_ELS_ACC)
984	return FC_PARSE_ACC_INVAL;
985
986	num_pages = (be16_to_cpu(tprlo->payload_len) - 4) / 16;
987
988	for (page = 0; page < num_pages; page++) {
989	if (tprlo->tprlo_acc_params[page].type != FC_TYPE_FCP)
990	return FC_PARSE_NOT_FCP;
991	if (tprlo->tprlo_acc_params[page].opa_valid != 0)
992	return FC_PARSE_OPAFLAG_INVAL;
993	if (tprlo->tprlo_acc_params[page].rpa_valid != 0)
994	return FC_PARSE_RPAFLAG_INVAL;
995	if (tprlo->tprlo_acc_params[page].orig_process_assc != 0)
996	return FC_PARSE_OPA_INVAL;
997	if (tprlo->tprlo_acc_params[page].resp_process_assc != 0)
998	return FC_PARSE_RPA_INVAL;
999	}
1000	return FC_PARSE_OK;
1001	}
1002
1003	enum fc_parse_status
1004	fc_rrq_rsp_parse(struct fchs_s *fchs, int len)
1005	{
1006	struct fc_els_cmd_s els_cmd = (struct fc_els_cmd_s ) (fchs + 1);
1007
1008	len = len;
1009	if (els_cmd->els_code != FC_ELS_ACC)
1010	return FC_PARSE_FAILURE;
1011
1012	return FC_PARSE_OK;
1013	}
1014
1015	u16	907	u16
1016	fc_ba_rjt_build(struct fchs_s *fchs, u32 d_id, u32 s_id, __be16 ox_id,	908	fc_ba_rjt_build(struct fchs_s *fchs, u32 d_id, u32 s_id, __be16 ox_id,
1017	u32 reason_code, u32 reason_expl)	909	u32 reason_code, u32 reason_expl)

drivers/scsi/bfa/bfa_fcbuild.h+0−9

 u16        fc_rrq_build(struct fchs_s *buf, struct fc_rrq_s *rrq, u32 d_id,
 			     u32 s_id, u16 ox_id, u16 rrq_oxid);
-enum fc_parse_status fc_rrq_rsp_parse(struct fchs_s *buf, int len);
 u16        fc_rspnid_build(struct fchs_s *fchs, void *pld, u32 s_id,
 				u16 ox_id, u8 *name);
 void		fc_els_req_build(struct fchs_s *fchs, u32 d_id, u32 s_id,
 					 __be16 ox_id);
-enum fc_parse_status	fc_els_rsp_parse(struct fchs_s *fchs, int len);
 enum fc_parse_status	fc_plogi_rsp_parse(struct fchs_s *fchs, int len,
 					wwn_t port_name);
 u16 fc_prlo_acc_build(struct fchs_s *fchs, struct fc_prlo_acc_s *prlo_acc,
 		u32 d_id, u32 s_id, __be16 ox_id, int num_pages);
-u16 fc_logo_rsp_parse(struct fchs_s *fchs, int len);
 u16 fc_pdisc_build(struct fchs_s *fchs, u32 d_id, u32 s_id,
 		u16 ox_id, wwn_t port_name, wwn_t node_name,
 		u16 pdu_size);
 u16 fc_prlo_build(struct fchs_s *fchs, u32 d_id, u32 s_id,
 		u16 ox_id, int num_pages);
-u16 fc_prlo_rsp_parse(struct fchs_s *fchs, int len);
 u16 fc_tprlo_build(struct fchs_s *fchs, u32 d_id, u32 s_id,
 		u16 ox_id, int num_pages, enum fc_tprlo_type tprlo_type,
 		u32 tpr_id);
-u16 fc_tprlo_rsp_parse(struct fchs_s *fchs, int len);
 u16 fc_ba_rjt_build(struct fchs_s *fchs, u32 d_id, u32 s_id,
 		__be16 ox_id, u32 reason_code, u32 reason_expl);

drivers/scsi/bfa/bfad_im.h+1−1

@@ -143,7 +143,7 @@ struct bfad_im_s { · 142 unmodified lines
143	static inline void bfad_im_post_vendor_event(struct bfa_aen_entry_s *entry,	143	static inline void bfad_im_post_vendor_event(struct bfa_aen_entry_s *entry,
144	struct bfad_s *drv, int cnt,	144	struct bfad_s *drv, int cnt,
145	enum bfa_aen_category cat,	145	enum bfa_aen_category cat,
146	enum bfa_ioc_aen_event evt)	146	int evt)
147	{	147	{
148	struct timespec64 ts;	148	struct timespec64 ts;
149		149

drivers/scsi/bnx2fc/bnx2fc_fcoe.c+0−3

 	struct fcoe_rcv_info *fr;
 	struct fcoe_percpu_s *bg;
 	struct sk_buff *tmp_skb;
-	unsigned short oxid;
 	interface = container_of(ptype, struct bnx2fc_interface,
 				 fcoe_packet_type);
 	skb_set_transport_header(skb, sizeof(struct fcoe_hdr));
 	fh = (struct fc_frame_header *) skb_transport_header(skb);
-	oxid = ntohs(fh->fh_ox_id);
 	fr = fcoe_dev_from_skb(skb);
 	fr->fr_dev = lport;

drivers/scsi/csiostor/csio_init.c+2−5

 	pci_set_master(pdev);
 	pci_try_set_mwi(pdev);
-	if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
+	if (dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)) ||
-		pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
+	    dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32))) {
-	} else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
-		pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
-	} else {
 		dev_err(&pdev->dev, "No suitable DMA available.\n");
 		goto err_release_regions;
 	}

drivers/scsi/csiostor/csio_lnode.c+3−3

@@ -1845,8 +1845,8 @@ csio_ln_fdmi_init(struct csio_lnode *ln) · 1844 unmodified lines
1845	/* Allocate Dma buffers for FDMI response Payload */	1845	/* Allocate Dma buffers for FDMI response Payload */
1846	dma_buf = &ln->mgmt_req->dma_buf;	1846	dma_buf = &ln->mgmt_req->dma_buf;
1847	dma_buf->len = 2048;	1847	dma_buf->len = 2048;
1848	dma_buf->vaddr = pci_alloc_consistent(hw->pdev, dma_buf->len,	1848	dma_buf->vaddr = dma_alloc_coherent(&hw->pdev->dev, dma_buf->len,
1849	&dma_buf->paddr);	1849	&dma_buf->paddr, GFP_KERNEL);
1850	if (!dma_buf->vaddr) {	1850	if (!dma_buf->vaddr) {
1851	csio_err(hw, "Failed to alloc DMA buffer for FDMI!\n");	1851	csio_err(hw, "Failed to alloc DMA buffer for FDMI!\n");
1852	kfree(ln->mgmt_req);	1852	kfree(ln->mgmt_req);
@@ -1873,7 +1873,7 @@ csio_ln_fdmi_exit(struct csio_lnode *ln) · 20 unmodified lines
1873		1873
1874	dma_buf = &ln->mgmt_req->dma_buf;	1874	dma_buf = &ln->mgmt_req->dma_buf;
1875	if (dma_buf->vaddr)	1875	if (dma_buf->vaddr)
1876	pci_free_consistent(hw->pdev, dma_buf->len, dma_buf->vaddr,	1876	dma_free_coherent(&hw->pdev->dev, dma_buf->len, dma_buf->vaddr,
1877	dma_buf->paddr);	1877	dma_buf->paddr);
1878		1878
1879	kfree(ln->mgmt_req);	1879	kfree(ln->mgmt_req);

drivers/scsi/csiostor/csio_scsi.c+6−6

@@ -2349,8 +2349,8 @@ csio_scsi_alloc_ddp_bufs(struct csio_scsim scm, struct csio_hw hw, · 2348 unmodified lines
2349	}	2349	}
2350		2350
2351	/* Allocate Dma buffers for DDP */	2351	/* Allocate Dma buffers for DDP */
2352	ddp_desc->vaddr = pci_alloc_consistent(hw->pdev, unit_size,	2352	ddp_desc->vaddr = dma_alloc_coherent(&hw->pdev->dev, unit_size,
2353	&ddp_desc->paddr);	2353	&ddp_desc->paddr, GFP_KERNEL);
2354	if (!ddp_desc->vaddr) {	2354	if (!ddp_desc->vaddr) {
2355	csio_err(hw,	2355	csio_err(hw,
2356	"SCSI response DMA buffer (ddp) allocation"	2356	"SCSI response DMA buffer (ddp) allocation"
@@ -2372,8 +2372,8 @@ no_mem: · 15 unmodified lines
2372	list_for_each(tmp, &scm->ddp_freelist) {	2372	list_for_each(tmp, &scm->ddp_freelist) {
2373	ddp_desc = (struct csio_dma_buf *) tmp;	2373	ddp_desc = (struct csio_dma_buf *) tmp;
2374	tmp = csio_list_prev(tmp);	2374	tmp = csio_list_prev(tmp);
2375	pci_free_consistent(hw->pdev, ddp_desc->len, ddp_desc->vaddr,	2375	dma_free_coherent(&hw->pdev->dev, ddp_desc->len,
2376	ddp_desc->paddr);	2376	ddp_desc->vaddr, ddp_desc->paddr);
2377	list_del_init(&ddp_desc->list);	2377	list_del_init(&ddp_desc->list);
2378	kfree(ddp_desc);	2378	kfree(ddp_desc);
2379	}	2379	}
@@ -2399,8 +2399,8 @@ csio_scsi_free_ddp_bufs(struct csio_scsim scm, struct csio_hw hw) · 19 unmodified lines
2399	list_for_each(tmp, &scm->ddp_freelist) {	2399	list_for_each(tmp, &scm->ddp_freelist) {
2400	ddp_desc = (struct csio_dma_buf *) tmp;	2400	ddp_desc = (struct csio_dma_buf *) tmp;
2401	tmp = csio_list_prev(tmp);	2401	tmp = csio_list_prev(tmp);
2402	pci_free_consistent(hw->pdev, ddp_desc->len, ddp_desc->vaddr,	2402	dma_free_coherent(&hw->pdev->dev, ddp_desc->len,
2403	ddp_desc->paddr);	2403	ddp_desc->vaddr, ddp_desc->paddr);
2404	list_del_init(&ddp_desc->list);	2404	list_del_init(&ddp_desc->list);
2405	kfree(ddp_desc);	2405	kfree(ddp_desc);
2406	}	2406	}

drivers/scsi/csiostor/csio_wr.c+9−8

 	while (n--) {
 		buf->len = sge->sge_fl_buf_size[sreg];
-		buf->vaddr = pci_alloc_consistent(hw->pdev, buf->len,
+		buf->vaddr = dma_alloc_coherent(&hw->pdev->dev, buf->len,
-						  &buf->paddr);
+						&buf->paddr, GFP_KERNEL);
 		if (!buf->vaddr) {
 			csio_err(hw, "Could only fill %d buffers!\n", n + 1);
 			return -ENOMEM;
 	q = wrm->q_arr[free_idx];
-	q->vstart = pci_zalloc_consistent(hw->pdev, qsz, &q->pstart);
+	q->vstart = dma_zalloc_coherent(&hw->pdev->dev, qsz, &q->pstart,
+			GFP_KERNEL);
 	if (!q->vstart) {
 		csio_err(hw,
 			 "Failed to allocate DMA memory for "
 					buf = &q->un.fl.bufs[j];
 					if (!buf->vaddr)
 						continue;
-					pci_free_consistent(hw->pdev, buf->len,
+					dma_free_coherent(&hw->pdev->dev,
-							    buf->vaddr,
+							buf->len, buf->vaddr,
-							    buf->paddr);
+							buf->paddr);
 				}
 				kfree(q->un.fl.bufs);
 			}
-			pci_free_consistent(hw->pdev, q->size,
+			dma_free_coherent(&hw->pdev->dev, q->size,
-					    q->vstart, q->pstart);
+					q->vstart, q->pstart);
 		}
 		kfree(q);
 	}

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c+153−1

@@ -35,6 +35,11 @@ static unsigned int dbg_level; · 34 unmodified lines
35		35
36	#include "../libcxgbi.h"	36	#include "../libcxgbi.h"
37		37
		38	#ifdef CONFIG_CHELSIO_T4_DCB
		39	#include <net/dcbevent.h>
		40	#include "cxgb4_dcb.h"
		41	#endif
		42
38	#define DRV_MODULE_NAME "cxgb4i"	43	#define DRV_MODULE_NAME "cxgb4i"
39	#define DRV_MODULE_DESC "Chelsio T4-T6 iSCSI Driver"	44	#define DRV_MODULE_DESC "Chelsio T4-T6 iSCSI Driver"
40	#define DRV_MODULE_VERSION "0.9.5-ko"	45	#define DRV_MODULE_VERSION "0.9.5-ko"
@@ -155,6 +160,15 @@ static struct iscsi_transport cxgb4i_iscsi_transport = { · 114 unmodified lines
155	.session_recovery_timedout = iscsi_session_recovery_timedout,	160	.session_recovery_timedout = iscsi_session_recovery_timedout,
156	};	161	};
157		162
		163	#ifdef CONFIG_CHELSIO_T4_DCB
		164	static int
		165	cxgb4_dcb_change_notify(struct notifier_block , unsigned long, void );
		166
		167	static struct notifier_block cxgb4_dcb_change = {
		168	.notifier_call = cxgb4_dcb_change_notify,
		169	};
		170	#endif
		171
158	static struct scsi_transport_template *cxgb4i_stt;	172	static struct scsi_transport_template *cxgb4i_stt;
159		173
160	/*	174	/*
@@ -574,6 +588,9 @@ static inline int tx_flowc_wr_credits(int nparamsp, int flowclenp) · 413 unmodified lines
574	int nparams, flowclen16, flowclen;	588	int nparams, flowclen16, flowclen;
575		589
576	nparams = FLOWC_WR_NPARAMS_MIN;	590	nparams = FLOWC_WR_NPARAMS_MIN;
		591	#ifdef CONFIG_CHELSIO_T4_DCB
		592	nparams++;
		593	#endif
577	flowclen = offsetof(struct fw_flowc_wr, mnemval[nparams]);	594	flowclen = offsetof(struct fw_flowc_wr, mnemval[nparams]);
578	flowclen16 = DIV_ROUND_UP(flowclen, 16);	595	flowclen16 = DIV_ROUND_UP(flowclen, 16);
579	flowclen = flowclen16 * 16;	596	flowclen = flowclen16 * 16;
@@ -595,6 +612,9 @@ static inline int send_tx_flowc_wr(struct cxgbi_sock *csk) · 15 unmodified lines
595	struct fw_flowc_wr *flowc;	612	struct fw_flowc_wr *flowc;
596	int nparams, flowclen16, flowclen;	613	int nparams, flowclen16, flowclen;
597		614
		615	#ifdef CONFIG_CHELSIO_T4_DCB
		616	u16 vlan = ((struct l2t_entry *)csk->l2t)->vlan;
		617	#endif
598	flowclen16 = tx_flowc_wr_credits(&nparams, &flowclen);	618	flowclen16 = tx_flowc_wr_credits(&nparams, &flowclen);
599	skb = alloc_wr(flowclen, 0, GFP_ATOMIC);	619	skb = alloc_wr(flowclen, 0, GFP_ATOMIC);
600	flowc = (struct fw_flowc_wr *)skb->head;	620	flowc = (struct fw_flowc_wr *)skb->head;
@@ -622,6 +642,17 @@ static inline int send_tx_flowc_wr(struct cxgbi_sock *csk) · 21 unmodified lines
622	flowc->mnemval[8].val = 0;	642	flowc->mnemval[8].val = 0;
623	flowc->mnemval[8].mnemonic = FW_FLOWC_MNEM_TXDATAPLEN_MAX;	643	flowc->mnemval[8].mnemonic = FW_FLOWC_MNEM_TXDATAPLEN_MAX;
624	flowc->mnemval[8].val = 16384;	644	flowc->mnemval[8].val = 16384;
		645	#ifdef CONFIG_CHELSIO_T4_DCB
		646	flowc->mnemval[9].mnemonic = FW_FLOWC_MNEM_DCBPRIO;
		647	if (vlan == CPL_L2T_VLAN_NONE) {
		648	pr_warn_ratelimited("csk %u without VLAN Tag on DCB Link\n",
		649	csk->tid);
		650	flowc->mnemval[9].val = cpu_to_be32(0);
		651	} else {
		652	flowc->mnemval[9].val = cpu_to_be32((vlan & VLAN_PRIO_MASK) >>
		653	VLAN_PRIO_SHIFT);
		654	}
		655	#endif
625		656
626	set_wr_txq(skb, CPL_PRIORITY_DATA, csk->port_id);	657	set_wr_txq(skb, CPL_PRIORITY_DATA, csk->port_id);
627		658
@@ -1600,6 +1631,46 @@ static void release_offload_resources(struct cxgbi_sock *csk) · 972 unmodified lines
1600	csk->dst = NULL;	1631	csk->dst = NULL;
1601	}	1632	}
1602		1633
		1634	#ifdef CONFIG_CHELSIO_T4_DCB
		1635	static inline u8 get_iscsi_dcb_state(struct net_device *ndev)
		1636	{
		1637	return ndev->dcbnl_ops->getstate(ndev);
		1638	}
		1639
		1640	static int select_priority(int pri_mask)
		1641	{
		1642	if (!pri_mask)
		1643	return 0;
		1644	return (ffs(pri_mask) - 1);
		1645	}
		1646
		1647	static u8 get_iscsi_dcb_priority(struct net_device *ndev)
		1648	{
		1649	int rv;
		1650	u8 caps;
		1651
		1652	struct dcb_app iscsi_dcb_app = {
		1653	.protocol = 3260
		1654	};
		1655
		1656	rv = (int)ndev->dcbnl_ops->getcap(ndev, DCB_CAP_ATTR_DCBX, &caps);
		1657	if (rv)
		1658	return 0;
		1659
		1660	if (caps & DCB_CAP_DCBX_VER_IEEE) {
		1661	iscsi_dcb_app.selector = IEEE_8021QAZ_APP_SEL_ANY;
		1662	rv = dcb_ieee_getapp_mask(ndev, &iscsi_dcb_app);
		1663	} else if (caps & DCB_CAP_DCBX_VER_CEE) {
		1664	iscsi_dcb_app.selector = DCB_APP_IDTYPE_PORTNUM;
		1665	rv = dcb_getapp(ndev, &iscsi_dcb_app);
		1666	}
		1667
		1668	log_debug(1 << CXGBI_DBG_ISCSI,
		1669	"iSCSI priority is set to %u\n", select_priority(rv));
		1670	return select_priority(rv);
		1671	}
		1672	#endif
		1673
1603	static int init_act_open(struct cxgbi_sock *csk)	1674	static int init_act_open(struct cxgbi_sock *csk)
1604	{	1675	{
1605	struct cxgbi_device *cdev = csk->cdev;	1676	struct cxgbi_device *cdev = csk->cdev;
@@ -1613,7 +1684,9 @@ static int init_act_open(struct cxgbi_sock *csk) · 7 unmodified lines
1613	unsigned int size, size6;	1684	unsigned int size, size6;
1614	unsigned int linkspeed;	1685	unsigned int linkspeed;
1615	unsigned int rcv_winf, snd_winf;	1686	unsigned int rcv_winf, snd_winf;
1616		1687	#ifdef CONFIG_CHELSIO_T4_DCB
		1688	u8 priority = 0;
		1689	#endif
1617	log_debug(1 << CXGBI_DBG_TOE \| 1 << CXGBI_DBG_SOCK,	1690	log_debug(1 << CXGBI_DBG_TOE \| 1 << CXGBI_DBG_SOCK,
1618	"csk 0x%p,%u,0x%lx,%u.\n",	1691	"csk 0x%p,%u,0x%lx,%u.\n",
1619	csk, csk->state, csk->flags, csk->tid);	1692	csk, csk->state, csk->flags, csk->tid);
@@ -1647,7 +1720,15 @@ static int init_act_open(struct cxgbi_sock *csk) · 27 unmodified lines
1647	cxgbi_sock_set_flag(csk, CTPF_HAS_ATID);	1720	cxgbi_sock_set_flag(csk, CTPF_HAS_ATID);
1648	cxgbi_sock_get(csk);	1721	cxgbi_sock_get(csk);
1649		1722
		1723	#ifdef CONFIG_CHELSIO_T4_DCB
		1724	if (get_iscsi_dcb_state(ndev))
		1725	priority = get_iscsi_dcb_priority(ndev);
		1726
		1727	csk->dcb_priority = priority;
		1728	csk->l2t = cxgb4_l2t_get(lldi->l2t, n, ndev, priority);
		1729	#else
1650	csk->l2t = cxgb4_l2t_get(lldi->l2t, n, ndev, 0);	1730	csk->l2t = cxgb4_l2t_get(lldi->l2t, n, ndev, 0);
		1731	#endif
1651	if (!csk->l2t) {	1732	if (!csk->l2t) {
1652	pr_err("%s, cannot alloc l2t.\n", ndev->name);	1733	pr_err("%s, cannot alloc l2t.\n", ndev->name);
1653	goto rel_resource_without_clip;	1734	goto rel_resource_without_clip;
@@ -2146,6 +2227,70 @@ static int t4_uld_state_change(void *handle, enum cxgb4_state state) · 492 unmodified lines
2146	return 0;	2227	return 0;
2147	}	2228	}
2148		2229
		2230	#ifdef CONFIG_CHELSIO_T4_DCB
		2231	static int
		2232	cxgb4_dcb_change_notify(struct notifier_block *self, unsigned long val,
		2233	void *data)
		2234	{
		2235	int i, port = 0xFF;
		2236	struct net_device *ndev;
		2237	struct cxgbi_device *cdev = NULL;
		2238	struct dcb_app_type *iscsi_app = data;
		2239	struct cxgbi_ports_map *pmap;
		2240	u8 priority;
		2241
		2242	if (iscsi_app->dcbx & DCB_CAP_DCBX_VER_IEEE) {
		2243	if (iscsi_app->app.selector != IEEE_8021QAZ_APP_SEL_ANY)
		2244	return NOTIFY_DONE;
		2245
		2246	priority = iscsi_app->app.priority;
		2247	} else if (iscsi_app->dcbx & DCB_CAP_DCBX_VER_CEE) {
		2248	if (iscsi_app->app.selector != DCB_APP_IDTYPE_PORTNUM)
		2249	return NOTIFY_DONE;
		2250
		2251	if (!iscsi_app->app.priority)
		2252	return NOTIFY_DONE;
		2253
		2254	priority = ffs(iscsi_app->app.priority) - 1;
		2255	} else {
		2256	return NOTIFY_DONE;
		2257	}
		2258
		2259	if (iscsi_app->app.protocol != 3260)
		2260	return NOTIFY_DONE;
		2261
		2262	log_debug(1 << CXGBI_DBG_ISCSI, "iSCSI priority for ifid %d is %u\n",
		2263	iscsi_app->ifindex, priority);
		2264
		2265	ndev = dev_get_by_index(&init_net, iscsi_app->ifindex);
		2266	if (!ndev)
		2267	return NOTIFY_DONE;
		2268
		2269	cdev = cxgbi_device_find_by_netdev_rcu(ndev, &port);
		2270
		2271	dev_put(ndev);
		2272	if (!cdev)
		2273	return NOTIFY_DONE;
		2274
		2275	pmap = &cdev->pmap;
		2276
		2277	for (i = 0; i < pmap->used; i++) {
		2278	if (pmap->port_csk[i]) {
		2279	struct cxgbi_sock *csk = pmap->port_csk[i];
		2280
		2281	if (csk->dcb_priority != priority) {
		2282	iscsi_conn_failure(csk->user_data,
		2283	ISCSI_ERR_CONN_FAILED);
		2284	pr_info("Restarting iSCSI connection %p with "
		2285	"priority %u->%u.\n", csk,
		2286	csk->dcb_priority, priority);
		2287	}
		2288	}
		2289	}
		2290	return NOTIFY_OK;
		2291	}
		2292	#endif
		2293
2149	static int __init cxgb4i_init_module(void)	2294	static int __init cxgb4i_init_module(void)
2150	{	2295	{
2151	int rc;	2296	int rc;
@@ -2157,11 +2302,18 @@ static int __init cxgb4i_init_module(void) · 5 unmodified lines
2157	return rc;	2302	return rc;
2158	cxgb4_register_uld(CXGB4_ULD_ISCSI, &cxgb4i_uld_info);	2303	cxgb4_register_uld(CXGB4_ULD_ISCSI, &cxgb4i_uld_info);
2159		2304
		2305	#ifdef CONFIG_CHELSIO_T4_DCB
		2306	pr_info("%s dcb enabled.\n", DRV_MODULE_NAME);
		2307	register_dcbevent_notifier(&cxgb4_dcb_change);
		2308	#endif
2160	return 0;	2309	return 0;
2161	}	2310	}
2162		2311
2163	static void __exit cxgb4i_exit_module(void)	2312	static void __exit cxgb4i_exit_module(void)
2164	{	2313	{
		2314	#ifdef CONFIG_CHELSIO_T4_DCB
		2315	unregister_dcbevent_notifier(&cxgb4_dcb_change);
		2316	#endif
2165	cxgb4_unregister_uld(CXGB4_ULD_ISCSI);	2317	cxgb4_unregister_uld(CXGB4_ULD_ISCSI);
2166	cxgbi_device_unregister_all(CXGBI_FLAG_DEV_T4);	2318	cxgbi_device_unregister_all(CXGBI_FLAG_DEV_T4);
2167	cxgbi_iscsi_cleanup(&cxgb4i_iscsi_transport, &cxgb4i_stt);	2319	cxgbi_iscsi_cleanup(&cxgb4i_iscsi_transport, &cxgb4i_stt);

drivers/scsi/cxgbi/libcxgbi.h+3−0

 	int wr_max_cred;
 	int wr_cred;
 	int wr_una_cred;
+#ifdef CONFIG_CHELSIO_T4_DCB
+	u8 dcb_priority;
+#endif
 	unsigned char hcrc_len;
 	unsigned char dcrc_len;

drivers/scsi/dc395x.c+43−148

 	return NULL;
 }
-static struct ScsiReqBlk *srb_get_free(struct AdapterCtlBlk *acb)
-{
-	struct list_head *head = &acb->srb_free_list;
-	struct ScsiReqBlk *srb = NULL;
-	if (!list_empty(head)) {
-		srb = list_entry(head->next, struct ScsiReqBlk, list);
-		list_del(head->next);
-		dprintkdbg(DBG_0, "srb_get_free: srb=%p\n", srb);
-	}
-	return srb;
-}
-static void srb_free_insert(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb)
-{
-	dprintkdbg(DBG_0, "srb_free_insert: srb=%p\n", srb);
-	list_add_tail(&srb->list, &acb->srb_free_list);
-}
-static void srb_waiting_insert(struct DeviceCtlBlk *dcb,
-		struct ScsiReqBlk *srb)
-{
-	dprintkdbg(DBG_0, "srb_waiting_insert: (0x%p) <%02i-%i> srb=%p\n",
-		srb->cmd, dcb->target_id, dcb->target_lun, srb);
-	list_add(&srb->list, &dcb->srb_waiting_list);
-}
-static void srb_waiting_append(struct DeviceCtlBlk *dcb,
-		struct ScsiReqBlk *srb)
-{
-	dprintkdbg(DBG_0, "srb_waiting_append: (0x%p) <%02i-%i> srb=%p\n",
-		 srb->cmd, dcb->target_id, dcb->target_lun, srb);
-	list_add_tail(&srb->list, &dcb->srb_waiting_list);
-}
-static void srb_going_append(struct DeviceCtlBlk *dcb, struct ScsiReqBlk *srb)
-{
-	dprintkdbg(DBG_0, "srb_going_append: (0x%p) <%02i-%i> srb=%p\n",
-		srb->cmd, dcb->target_id, dcb->target_lun, srb);
-	list_add_tail(&srb->list, &dcb->srb_going_list);
-}
-static void srb_going_remove(struct DeviceCtlBlk *dcb, struct ScsiReqBlk *srb)
-{
-	struct ScsiReqBlk *i;
-	struct ScsiReqBlk *tmp;
-	dprintkdbg(DBG_0, "srb_going_remove: (0x%p) <%02i-%i> srb=%p\n",
-		srb->cmd, dcb->target_id, dcb->target_lun, srb);
-	list_for_each_entry_safe(i, tmp, &dcb->srb_going_list, list)
-		if (i == srb) {
-			list_del(&srb->list);
-			break;
-		}
-}
-static void srb_waiting_remove(struct DeviceCtlBlk *dcb,
-		struct ScsiReqBlk *srb)
-{
-	struct ScsiReqBlk *i;
-	struct ScsiReqBlk *tmp;
-	dprintkdbg(DBG_0, "srb_waiting_remove: (0x%p) <%02i-%i> srb=%p\n",
-		srb->cmd, dcb->target_id, dcb->target_lun, srb);
-	list_for_each_entry_safe(i, tmp, &dcb->srb_waiting_list, list)
-		if (i == srb) {
-			list_del(&srb->list);
-			break;
-		}
-}
-static void srb_going_to_waiting_move(struct DeviceCtlBlk *dcb,
-		struct ScsiReqBlk *srb)
-{
-	dprintkdbg(DBG_0,
-		"srb_going_to_waiting_move: (0x%p) <%02i-%i> srb=%p\n",
-		srb->cmd, dcb->target_id, dcb->target_lun, srb);
-	list_move(&srb->list, &dcb->srb_waiting_list);
-}
-static void srb_waiting_to_going_move(struct DeviceCtlBlk *dcb,
-		struct ScsiReqBlk *srb)
-{
-	dprintkdbg(DBG_0,
-		"srb_waiting_to_going_move: (0x%p) <%02i-%i> srb=%p\n",
-		srb->cmd, dcb->target_id, dcb->target_lun, srb);
-	list_move(&srb->list, &dcb->srb_going_list);
-}
 /* Sets the timer to wake us up */
 static void waiting_set_timer(struct AdapterCtlBlk *acb, unsigned long to)
 {
 			/* Try to send to the bus */
 			if (!start_scsi(acb, pos, srb))
-				srb_waiting_to_going_move(pos, srb);
+				list_move(&srb->list, &pos->srb_going_list);
 			else
 				waiting_set_timer(acb, HZ/50);
 			break;
 	if (dcb->max_command <= list_size(&dcb->srb_going_list) ||
 	    acb->active_dcb ||
 	    (acb->acb_flag & (RESET_DETECT + RESET_DONE + RESET_DEV))) {
-		srb_waiting_append(dcb, srb);
+		list_add_tail(&srb->list, &dcb->srb_waiting_list);
 		waiting_process_next(acb);
 		return;
 	}
-	if (!start_scsi(acb, dcb, srb))
+	if (!start_scsi(acb, dcb, srb)) {
-		srb_going_append(dcb, srb);
+		list_add_tail(&srb->list, &dcb->srb_going_list);
-	else {
+	} else {
-		srb_waiting_insert(dcb, srb);
+		list_add(&srb->list, &dcb->srb_waiting_list);
 		waiting_set_timer(acb, HZ / 50);
 	}
 }
 			sgp->length++;
 		}
-		srb->sg_bus_addr = pci_map_single(dcb->acb->dev,
+		srb->sg_bus_addr = dma_map_single(&dcb->acb->dev->dev,
-						srb->segment_x,
+				srb->segment_x, SEGMENTX_LEN, DMA_TO_DEVICE);
-				            	SEGMENTX_LEN,
-				            	PCI_DMA_TODEVICE);
 		dprintkdbg(DBG_SG, "build_srb: [n] map sg %p->%08x(%05x)\n",
 			srb->segment_x, srb->sg_bus_addr, SEGMENTX_LEN);
 	cmd->scsi_done = done;
 	cmd->result = 0;
-	srb = srb_get_free(acb);
+	srb = list_first_entry_or_null(&acb->srb_free_list,
-	if (!srb)
+			struct ScsiReqBlk, list);
-	{
+	if (!srb) {
 		/*
 		 * Return 1 since we are unable to queue this command at this
 		 * point in time.
 		dprintkdbg(DBG_0, "queue_command: No free srb's\n");
 		return 1;
 	}
+	list_del(&srb->list);
 	build_srb(cmd, dcb, srb);
 	if (!list_empty(&dcb->srb_waiting_list)) {
 		/* append to waiting queue */
-		srb_waiting_append(dcb, srb);
+		list_add_tail(&srb->list, &dcb->srb_waiting_list);
 		waiting_process_next(acb);
 	} else {
 		/* process immediately */
 	srb = find_cmd(cmd, &dcb->srb_waiting_list);
 	if (srb) {
-		srb_waiting_remove(dcb, srb);
+		list_del(&srb->list);
 		pci_unmap_srb_sense(acb, srb);
 		pci_unmap_srb(acb, srb);
 		free_tag(dcb, srb);
-		srb_free_insert(acb, srb);
+		list_add_tail(&srb->list, &acb->srb_free_list);
 		dprintkl(KERN_DEBUG, "eh_abort: Command was waiting\n");
 		cmd->result = DID_ABORT << 16;
 		return SUCCESS;
 			xferred -= psge->length;
 		} else {
 			/* Partial SG entry done */
+			dma_sync_single_for_cpu(&srb->dcb->acb->dev->dev,
+					srb->sg_bus_addr, SEGMENTX_LEN,
+					DMA_TO_DEVICE);
 			psge->length -= xferred;
 			psge->address += xferred;
 			srb->sg_index = idx;
-			pci_dma_sync_single_for_device(srb->dcb->
+			dma_sync_single_for_device(&srb->dcb->acb->dev->dev,
-					    acb->dev,
+					srb->sg_bus_addr, SEGMENTX_LEN,
-					    srb->sg_bus_addr,
+					DMA_TO_DEVICE);
-					    SEGMENTX_LEN,
-					    PCI_DMA_TODEVICE);
 			break;
 		}
 		psge++;
 					goto disc1;
 				}
 				free_tag(dcb, srb);
-				srb_going_to_waiting_move(dcb, srb);
+				list_move(&srb->list, &dcb->srb_waiting_list);
 				dprintkdbg(DBG_KG,
 					"disconnect: (0x%p) Retry\n",
 					srb->cmd);
 			srb->state = SRB_READY;
 			free_tag(dcb, srb);
-			srb_going_to_waiting_move(dcb, srb);
+			list_move(&srb->list, &dcb->srb_waiting_list);
 			waiting_set_timer(acb, HZ / 20);
 			/* return; */
 		/* unmap DC395x SG list */
 		dprintkdbg(DBG_SG, "pci_unmap_srb: list=%08x(%05x)\n",
 			srb->sg_bus_addr, SEGMENTX_LEN);
-		pci_unmap_single(acb->dev, srb->sg_bus_addr,
+		dma_unmap_single(&acb->dev->dev, srb->sg_bus_addr, SEGMENTX_LEN,
-				 SEGMENTX_LEN,
+				DMA_TO_DEVICE);
-				 PCI_DMA_TODEVICE);
 		dprintkdbg(DBG_SG, "pci_unmap_srb: segs=%i buffer=%p\n",
 			   scsi_sg_count(cmd), scsi_bufflen(cmd));
 		/* unmap the sg segments */
 	/* Unmap sense buffer */
 	dprintkdbg(DBG_SG, "pci_unmap_srb_sense: buffer=%08x\n",
 	       srb->segment_x[0].address);
-	pci_unmap_single(acb->dev, srb->segment_x[0].address,
+	dma_unmap_single(&acb->dev->dev, srb->segment_x[0].address,
-			 srb->segment_x[0].length, PCI_DMA_FROMDEVICE);
+			 srb->segment_x[0].length, DMA_FROM_DEVICE);
 	/* Restore SG stuff */
 	srb->total_xfer_length = srb->xferred;
 	srb->segment_x[0].address =
 				tempcnt--;
 			dcb->max_command = tempcnt;
 			free_tag(dcb, srb);
-			srb_going_to_waiting_move(dcb, srb);
+			list_move(&srb->list, &dcb->srb_waiting_list);
 			waiting_set_timer(acb, HZ / 20);
 			srb->adapter_status = 0;
 			srb->target_status = 0;
 		}
 	}
-	if (dir != PCI_DMA_NONE && scsi_sg_count(cmd))
-		pci_dma_sync_sg_for_cpu(acb->dev, scsi_sglist(cmd),
-					scsi_sg_count(cmd), dir);
 	ckc_only = 0;
 /* Check Error Conditions */
       ckc_e:
+	pci_unmap_srb(acb, srb);
 	if (cmd->cmnd[0] == INQUIRY) {
 		unsigned char *base = NULL;
 		struct ScsiInqData *ptr;
 				cmd->cmnd[0], srb->total_xfer_length);
 	}
-	srb_going_remove(dcb, srb);
+	if (srb != acb->tmp_srb) {
-	/* Add to free list */
+		/* Add to free list */
-	if (srb == acb->tmp_srb)
-		dprintkl(KERN_ERR, "srb_done: ERROR! Completed cmd with tmp_srb\n");
-	else {
 		dprintkdbg(DBG_0, "srb_done: (0x%p) done result=0x%08x\n",
 			cmd, cmd->result);
-		srb_free_insert(acb, srb);
+		list_move_tail(&srb->list, &acb->srb_free_list);
+	} else {
+		dprintkl(KERN_ERR, "srb_done: ERROR! Completed cmd with tmp_srb\n");
 	}
-	pci_unmap_srb(acb, srb);
 	cmd->scsi_done(cmd);
 	waiting_process_next(acb);
 			result = MK_RES(0, did_flag, 0, 0);
 			printk("G:%p(%02i-%i) ", p,
 			       p->device->id, (u8)p->device->lun);
-			srb_going_remove(dcb, srb);
+			list_del(&srb->list);
 			free_tag(dcb, srb);
-			srb_free_insert(acb, srb);
+			list_add_tail(&srb->list, &acb->srb_free_list);
 			p->result = result;
 			pci_unmap_srb_sense(acb, srb);
 			pci_unmap_srb(acb, srb);
 			result = MK_RES(0, did_flag, 0, 0);
 			printk("W:%p<%02i-%i>", p, p->device->id,
 			       (u8)p->device->lun);
-			srb_waiting_remove(dcb, srb);
+			list_move_tail(&srb->list, &acb->srb_free_list);
-			srb_free_insert(acb, srb);
 			p->result = result;
 			pci_unmap_srb_sense(acb, srb);
 			pci_unmap_srb(acb, srb);
 	srb->total_xfer_length = SCSI_SENSE_BUFFERSIZE;
 	srb->segment_x[0].length = SCSI_SENSE_BUFFERSIZE;
 	/* Map sense buffer */
-	srb->segment_x[0].address =
+	srb->segment_x[0].address = dma_map_single(&acb->dev->dev,
-	    pci_map_single(acb->dev, cmd->sense_buffer,
+			cmd->sense_buffer, SCSI_SENSE_BUFFERSIZE,
-			   SCSI_SENSE_BUFFERSIZE, PCI_DMA_FROMDEVICE);
+			DMA_FROM_DEVICE);
 	dprintkdbg(DBG_SG, "request_sense: map buffer %p->%08x(%05x)\n",
 	       cmd->sense_buffer, srb->segment_x[0].address,
 	       SCSI_SENSE_BUFFERSIZE);
 		dprintkl(KERN_DEBUG,
 			"request_sense: (0x%p) failed <%02i-%i>\n",
 			srb->cmd, dcb->target_id, dcb->target_lun);
-		srb_going_to_waiting_move(dcb, srb);
+		list_move(&srb->list, &dcb->srb_waiting_list);
 		waiting_set_timer(acb, HZ / 100);
 	}
 }
 	/* link static array of srbs into the srb free list */
 	for (i = 0; i < acb->srb_count - 1; i++)
-		srb_free_insert(acb, &acb->srb_array[i]);
+		list_add_tail(&acb->srb_array[i].list, &acb->srb_free_list);
 }

drivers/scsi/esp_scsi.c+203−83

@@ -369,19 +369,28 @@ static void esp_map_dma(struct esp esp, struct scsi_cmnd cmd) · 368 unmodified lines
369	{	369	{
370	struct esp_cmd_priv *spriv = ESP_CMD_PRIV(cmd);	370	struct esp_cmd_priv *spriv = ESP_CMD_PRIV(cmd);
371	struct scatterlist *sg = scsi_sglist(cmd);	371	struct scatterlist *sg = scsi_sglist(cmd);
372	int dir = cmd->sc_data_direction;	372	int total = 0, i;
373	int total, i;
374		373
375	if (dir == DMA_NONE)	374	if (cmd->sc_data_direction == DMA_NONE)
376	return;	375	return;
377		376
378	spriv->u.num_sg = esp->ops->map_sg(esp, sg, scsi_sg_count(cmd), dir);	377	if (esp->flags & ESP_FLAG_NO_DMA_MAP) {
		378	/*
		379	* For pseudo DMA and PIO we need the virtual address instead of
		380	* a dma address, so perform an identity mapping.
		381	*/
		382	spriv->num_sg = scsi_sg_count(cmd);
		383	for (i = 0; i < spriv->num_sg; i++) {
		384	sg[i].dma_address = (uintptr_t)sg_virt(&sg[i]);
		385	total += sg_dma_len(&sg[i]);
		386	}
		387	} else {
		388	spriv->num_sg = scsi_dma_map(cmd);
		389	for (i = 0; i < spriv->num_sg; i++)
		390	total += sg_dma_len(&sg[i]);
		391	}
379	spriv->cur_residue = sg_dma_len(sg);	392	spriv->cur_residue = sg_dma_len(sg);
380	spriv->cur_sg = sg;	393	spriv->cur_sg = sg;
381
382	total = 0;
383	for (i = 0; i < spriv->u.num_sg; i++)
384	total += sg_dma_len(&sg[i]);
385	spriv->tot_residue = total;	394	spriv->tot_residue = total;
386	}	395	}
387		396
@@ -441,13 +450,8 @@ static void esp_advance_dma(struct esp esp, struct esp_cmd_entry ent, · 53 unmodified lines
441		450
442	static void esp_unmap_dma(struct esp esp, struct scsi_cmnd cmd)	451	static void esp_unmap_dma(struct esp esp, struct scsi_cmnd cmd)
443	{	452	{
444	struct esp_cmd_priv *spriv = ESP_CMD_PRIV(cmd);	453	if (!(esp->flags & ESP_FLAG_NO_DMA_MAP))
445	int dir = cmd->sc_data_direction;	454	scsi_dma_unmap(cmd);
446
447	if (dir == DMA_NONE)
448	return;
449
450	esp->ops->unmap_sg(esp, scsi_sglist(cmd), spriv->u.num_sg, dir);
451	}	455	}
452		456
453	static void esp_save_pointers(struct esp esp, struct esp_cmd_entry ent)	457	static void esp_save_pointers(struct esp esp, struct esp_cmd_entry ent)
@@ -478,17 +482,6 @@ static void esp_restore_pointers(struct esp esp, struct esp_cmd_entry ent) · 24 unmodified lines
478	spriv->tot_residue = ent->saved_tot_residue;	482	spriv->tot_residue = ent->saved_tot_residue;
479	}	483	}
480		484
481	static void esp_check_command_len(struct esp esp, struct scsi_cmnd cmd)
482	{
483	if (cmd->cmd_len == 6 \|\|
484	cmd->cmd_len == 10 \|\|
485	cmd->cmd_len == 12) {
486	esp->flags &= ~ESP_FLAG_DOING_SLOWCMD;
487	} else {
488	esp->flags \|= ESP_FLAG_DOING_SLOWCMD;
489	}
490	}
491
492	static void esp_write_tgt_config3(struct esp *esp, int tgt)	485	static void esp_write_tgt_config3(struct esp *esp, int tgt)
493	{	486	{
494	if (esp->rev > ESP100A) {	487	if (esp->rev > ESP100A) {
@@ -624,6 +617,26 @@ static void esp_free_lun_tag(struct esp_cmd_entry *ent, · 129 unmodified lines
624	}	617	}
625	}	618	}
626		619
		620	static void esp_map_sense(struct esp esp, struct esp_cmd_entry ent)
		621	{
		622	ent->sense_ptr = ent->cmd->sense_buffer;
		623	if (esp->flags & ESP_FLAG_NO_DMA_MAP) {
		624	ent->sense_dma = (uintptr_t)ent->sense_ptr;
		625	return;
		626	}
		627
		628	ent->sense_dma = dma_map_single(esp->dev, ent->sense_ptr,
		629	SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE);
		630	}
		631
		632	static void esp_unmap_sense(struct esp esp, struct esp_cmd_entry ent)
		633	{
		634	if (!(esp->flags & ESP_FLAG_NO_DMA_MAP))
		635	dma_unmap_single(esp->dev, ent->sense_dma,
		636	SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE);
		637	ent->sense_ptr = NULL;
		638	}
		639
627	/* When a contingent allegiance conditon is created, we force feed a	640	/* When a contingent allegiance conditon is created, we force feed a
628	* REQUEST_SENSE command to the device to fetch the sense data. I	641	* REQUEST_SENSE command to the device to fetch the sense data. I
629	* tried many other schemes, relying on the scsi error handling layer	642	* tried many other schemes, relying on the scsi error handling layer
@@ -645,12 +658,7 @@ static void esp_autosense(struct esp esp, struct esp_cmd_entry ent) · 15 unmodified lines
645	if (!ent->sense_ptr) {	658	if (!ent->sense_ptr) {
646	esp_log_autosense("Doing auto-sense for tgt[%d] lun[%d]\n",	659	esp_log_autosense("Doing auto-sense for tgt[%d] lun[%d]\n",
647	tgt, lun);	660	tgt, lun);
648		661	esp_map_sense(esp, ent);
649	ent->sense_ptr = cmd->sense_buffer;
650	ent->sense_dma = esp->ops->map_single(esp,
651	ent->sense_ptr,
652	SCSI_SENSE_BUFFERSIZE,
653	DMA_FROM_DEVICE);
654	}	662	}
655	ent->saved_sense_ptr = ent->sense_ptr;	663	ent->saved_sense_ptr = ent->sense_ptr;
656		664
@@ -717,10 +725,10 @@ static struct esp_cmd_entry find_and_prep_issuable_command(struct esp esp) · 60 unmodified lines
717	static void esp_maybe_execute_command(struct esp *esp)	725	static void esp_maybe_execute_command(struct esp *esp)
718	{	726	{
719	struct esp_target_data *tp;	727	struct esp_target_data *tp;
720	struct esp_lun_data *lp;
721	struct scsi_device *dev;	728	struct scsi_device *dev;
722	struct scsi_cmnd *cmd;	729	struct scsi_cmnd *cmd;
723	struct esp_cmd_entry *ent;	730	struct esp_cmd_entry *ent;
		731	bool select_and_stop = false;
724	int tgt, lun, i;	732	int tgt, lun, i;
725	u32 val, start_cmd;	733	u32 val, start_cmd;
726	u8 *p;	734	u8 *p;
@@ -743,7 +751,6 @@ static void esp_maybe_execute_command(struct esp *esp) · 16 unmodified lines
743	tgt = dev->id;	751	tgt = dev->id;
744	lun = dev->lun;	752	lun = dev->lun;
745	tp = &esp->target[tgt];	753	tp = &esp->target[tgt];
746	lp = dev->hostdata;
747		754
748	list_move(&ent->list, &esp->active_cmds);	755	list_move(&ent->list, &esp->active_cmds);
749		756
@@ -752,7 +759,8 @@ static void esp_maybe_execute_command(struct esp *esp) · 2 unmodified lines
752	esp_map_dma(esp, cmd);	759	esp_map_dma(esp, cmd);
753	esp_save_pointers(esp, ent);	760	esp_save_pointers(esp, ent);
754		761
755	esp_check_command_len(esp, cmd);	762	if (!(cmd->cmd_len == 6 \|\| cmd->cmd_len == 10 \|\| cmd->cmd_len == 12))
		763	select_and_stop = true;
756		764
757	p = esp->command_block;	765	p = esp->command_block;
758		766
@@ -793,42 +801,22 @@ static void esp_maybe_execute_command(struct esp *esp) · 34 unmodified lines
793	tp->flags &= ~ESP_TGT_CHECK_NEGO;	801	tp->flags &= ~ESP_TGT_CHECK_NEGO;
794	}	802	}
795		803
796	/* Process it like a slow command. */	804	/* If there are multiple message bytes, use Select and Stop */
797	if (tp->flags & (ESP_TGT_NEGO_WIDE \| ESP_TGT_NEGO_SYNC))	805	if (esp->msg_out_len)
798	esp->flags \|= ESP_FLAG_DOING_SLOWCMD;	806	select_and_stop = true;
799	}	807	}
800		808
801	build_identify:	809	build_identify:
802	/* If we don't have a lun-data struct yet, we're probing	810	*p++ = IDENTIFY(tp->flags & ESP_TGT_DISCONNECT, lun);
803	* so do not disconnect. Also, do not disconnect unless
804	* we have a tag on this command.
805	*/
806	if (lp && (tp->flags & ESP_TGT_DISCONNECT) && ent->tag[0])
807	*p++ = IDENTIFY(1, lun);
808	else
809	*p++ = IDENTIFY(0, lun);
810		811
811	if (ent->tag[0] && esp->rev == ESP100) {	812	if (ent->tag[0] && esp->rev == ESP100) {
812	/* ESP100 lacks select w/atn3 command, use select	813	/* ESP100 lacks select w/atn3 command, use select
813	* and stop instead.	814	* and stop instead.
814	*/	815	*/
815	esp->flags \|= ESP_FLAG_DOING_SLOWCMD;	816	select_and_stop = true;
816	}	817	}
817		818
818	if (!(esp->flags & ESP_FLAG_DOING_SLOWCMD)) {	819	if (select_and_stop) {
819	start_cmd = ESP_CMD_SELA;
820	if (ent->tag[0]) {
821	*p++ = ent->tag[0];
822	*p++ = ent->tag[1];
823
824	start_cmd = ESP_CMD_SA3;
825	}
826
827	for (i = 0; i < cmd->cmd_len; i++)
828	*p++ = cmd->cmnd[i];
829
830	esp->select_state = ESP_SELECT_BASIC;
831	} else {
832	esp->cmd_bytes_left = cmd->cmd_len;	820	esp->cmd_bytes_left = cmd->cmd_len;
833	esp->cmd_bytes_ptr = &cmd->cmnd[0];	821	esp->cmd_bytes_ptr = &cmd->cmnd[0];
834		822
@@ -843,6 +831,19 @@ build_identify: · 8 unmodified lines
843		831
844	start_cmd = ESP_CMD_SELAS;	832	start_cmd = ESP_CMD_SELAS;
845	esp->select_state = ESP_SELECT_MSGOUT;	833	esp->select_state = ESP_SELECT_MSGOUT;
		834	} else {
		835	start_cmd = ESP_CMD_SELA;
		836	if (ent->tag[0]) {
		837	*p++ = ent->tag[0];
		838	*p++ = ent->tag[1];
		839
		840	start_cmd = ESP_CMD_SA3;
		841	}
		842
		843	for (i = 0; i < cmd->cmd_len; i++)
		844	*p++ = cmd->cmnd[i];
		845
		846	esp->select_state = ESP_SELECT_BASIC;
846	}	847	}
847	val = tgt;	848	val = tgt;
848	if (esp->rev == FASHME)	849	if (esp->rev == FASHME)
@@ -902,9 +903,7 @@ static void esp_cmd_is_done(struct esp esp, struct esp_cmd_entry ent, · 53 unmodified lines
902	}	903	}
903		904
904	if (ent->flags & ESP_CMD_FLAG_AUTOSENSE) {	905	if (ent->flags & ESP_CMD_FLAG_AUTOSENSE) {
905	esp->ops->unmap_single(esp, ent->sense_dma,	906	esp_unmap_sense(esp, ent);
906	SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE);
907	ent->sense_ptr = NULL;
908		907
909	/* Restore the message/status bytes to what we actually	908	/* Restore the message/status bytes to what we actually
910	* saw originally. Also, report that we are providing	909	* saw originally. Also, report that we are providing
@@ -965,7 +964,7 @@ static int esp_queuecommand_lck(struct scsi_cmnd cmd, void (done)(struct scsi_ · 54 unmodified lines
965	cmd->scsi_done = done;	964	cmd->scsi_done = done;
966		965
967	spriv = ESP_CMD_PRIV(cmd);	966	spriv = ESP_CMD_PRIV(cmd);
968	spriv->u.dma_addr = ~(dma_addr_t)0x0;	967	spriv->num_sg = 0;
969		968
970	list_add_tail(&ent->list, &esp->queued_cmds);	969	list_add_tail(&ent->list, &esp->queued_cmds);
971		970
@@ -1252,14 +1251,10 @@ static int esp_finish_select(struct esp *esp) · 280 unmodified lines
1252	esp_unmap_dma(esp, cmd);	1251	esp_unmap_dma(esp, cmd);
1253	esp_free_lun_tag(ent, cmd->device->hostdata);	1252	esp_free_lun_tag(ent, cmd->device->hostdata);
1254	tp->flags &= ~(ESP_TGT_NEGO_SYNC \| ESP_TGT_NEGO_WIDE);	1253	tp->flags &= ~(ESP_TGT_NEGO_SYNC \| ESP_TGT_NEGO_WIDE);
1255	esp->flags &= ~ESP_FLAG_DOING_SLOWCMD;
1256	esp->cmd_bytes_ptr = NULL;	1254	esp->cmd_bytes_ptr = NULL;
1257	esp->cmd_bytes_left = 0;	1255	esp->cmd_bytes_left = 0;
1258	} else {	1256	} else {
1259	esp->ops->unmap_single(esp, ent->sense_dma,	1257	esp_unmap_sense(esp, ent);
1260	SCSI_SENSE_BUFFERSIZE,
1261	DMA_FROM_DEVICE);
1262	ent->sense_ptr = NULL;
1263	}	1258	}
1264		1259
1265	/* Now that the state is unwound properly, put back onto	1260	/* Now that the state is unwound properly, put back onto
@@ -1303,9 +1298,8 @@ static int esp_finish_select(struct esp *esp) · 37 unmodified lines
1303	esp_flush_fifo(esp);	1298	esp_flush_fifo(esp);
1304	}	1299	}
1305		1300
1306	/* If we are doing a slow command, negotiation, etc.	1301	/* If we are doing a Select And Stop command, negotiation, etc.
1307	* we'll do the right thing as we transition to the	1302	* we'll do the right thing as we transition to the next phase.
1308	* next phase.
1309	*/	1303	*/
1310	esp_event(esp, ESP_EVENT_CHECK_PHASE);	1304	esp_event(esp, ESP_EVENT_CHECK_PHASE);
1311	return 0;	1305	return 0;
@@ -1338,6 +1332,7 @@ static int esp_data_bytes_sent(struct esp esp, struct esp_cmd_entry ent, · 26 unmodified lines
1338		1332
1339	bytes_sent = esp->data_dma_len;	1333	bytes_sent = esp->data_dma_len;
1340	bytes_sent -= ecount;	1334	bytes_sent -= ecount;
		1335	bytes_sent -= esp->send_cmd_residual;
1341		1336
1342	/*	1337	/*
1343	* The am53c974 has a DMA 'pecularity'. The doc states:	1338	* The am53c974 has a DMA 'pecularity'. The doc states:
@@ -1358,7 +1353,7 @@ static int esp_data_bytes_sent(struct esp esp, struct esp_cmd_entry ent, · 14 unmodified lines
1358	struct esp_cmd_priv *p = ESP_CMD_PRIV(cmd);	1353	struct esp_cmd_priv *p = ESP_CMD_PRIV(cmd);
1359	u8 *ptr;	1354	u8 *ptr;
1360		1355
1361	ptr = scsi_kmap_atomic_sg(p->cur_sg, p->u.num_sg,	1356	ptr = scsi_kmap_atomic_sg(p->cur_sg, p->num_sg,
1362	&offset, &count);	1357	&offset, &count);
1363	if (likely(ptr)) {	1358	if (likely(ptr)) {
1364	*(ptr + offset) = bval;	1359	*(ptr + offset) = bval;
@@ -2039,11 +2034,8 @@ static void esp_reset_cleanup_one(struct esp esp, struct esp_cmd_entry ent) · 674 unmodified lines
2039	esp_free_lun_tag(ent, cmd->device->hostdata);	2034	esp_free_lun_tag(ent, cmd->device->hostdata);
2040	cmd->result = DID_RESET << 16;	2035	cmd->result = DID_RESET << 16;
2041		2036
2042	if (ent->flags & ESP_CMD_FLAG_AUTOSENSE) {	2037	if (ent->flags & ESP_CMD_FLAG_AUTOSENSE)
2043	esp->ops->unmap_single(esp, ent->sense_dma,	2038	esp_unmap_sense(esp, ent);
2044	SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE);
2045	ent->sense_ptr = NULL;
2046	}
2047		2039
2048	cmd->scsi_done(cmd);	2040	cmd->scsi_done(cmd);
2049	list_del(&ent->list);	2041	list_del(&ent->list);
@@ -2382,7 +2374,7 @@ static const char *esp_chip_names[] = { · 332 unmodified lines
2382		2374
2383	static struct scsi_transport_template *esp_transport_template;	2375	static struct scsi_transport_template *esp_transport_template;
2384		2376
2385	int scsi_esp_register(struct esp esp, struct device dev)	2377	int scsi_esp_register(struct esp *esp)
2386	{	2378	{
2387	static int instance;	2379	static int instance;
2388	int err;	2380	int err;
@@ -2402,10 +2394,10 @@ int scsi_esp_register(struct esp esp, struct device dev) · 13 unmodified lines
2402		2394
2403	esp_bootup_reset(esp);	2395	esp_bootup_reset(esp);
2404		2396
2405	dev_printk(KERN_INFO, dev, "esp%u: regs[%1p:%1p] irq[%u]\n",	2397	dev_printk(KERN_INFO, esp->dev, "esp%u: regs[%1p:%1p] irq[%u]\n",
2406	esp->host->unique_id, esp->regs, esp->dma_regs,	2398	esp->host->unique_id, esp->regs, esp->dma_regs,
2407	esp->host->irq);	2399	esp->host->irq);
2408	dev_printk(KERN_INFO, dev,	2400	dev_printk(KERN_INFO, esp->dev,
2409	"esp%u: is a %s, %u MHz (ccf=%u), SCSI ID %u\n",	2401	"esp%u: is a %s, %u MHz (ccf=%u), SCSI ID %u\n",
2410	esp->host->unique_id, esp_chip_names[esp->rev],	2402	esp->host->unique_id, esp_chip_names[esp->rev],
2411	esp->cfreq / 1000000, esp->cfact, esp->scsi_id);	2403	esp->cfreq / 1000000, esp->cfact, esp->scsi_id);
@@ -2413,7 +2405,7 @@ int scsi_esp_register(struct esp esp, struct device dev) · 1 unmodified line
2413	/* Let the SCSI bus reset settle. */	2405	/* Let the SCSI bus reset settle. */
2414	ssleep(esp_bus_reset_settle);	2406	ssleep(esp_bus_reset_settle);
2415		2407
2416	err = scsi_add_host(esp->host, dev);	2408	err = scsi_add_host(esp->host, esp->dev);
2417	if (err)	2409	if (err)
2418	return err;	2410	return err;
2419		2411
@@ -2790,3 +2782,131 @@ MODULE_PARM_DESC(esp_debug, · 370 unmodified lines
2790		2782
2791	module_init(esp_init);	2783	module_init(esp_init);
2792	module_exit(esp_exit);	2784	module_exit(esp_exit);
		2785
		2786	#ifdef CONFIG_SCSI_ESP_PIO
		2787	static inline unsigned int esp_wait_for_fifo(struct esp *esp)
		2788	{
		2789	int i = 500000;
		2790
		2791	do {
		2792	unsigned int fbytes = esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES;
		2793
		2794	if (fbytes)
		2795	return fbytes;
		2796
		2797	udelay(1);
		2798	} while (--i);
		2799
		2800	shost_printk(KERN_ERR, esp->host, "FIFO is empty. sreg [%02x]\n",
		2801	esp_read8(ESP_STATUS));
		2802	return 0;
		2803	}
		2804
		2805	static inline int esp_wait_for_intr(struct esp *esp)
		2806	{
		2807	int i = 500000;
		2808
		2809	do {
		2810	esp->sreg = esp_read8(ESP_STATUS);
		2811	if (esp->sreg & ESP_STAT_INTR)
		2812	return 0;
		2813
		2814	udelay(1);
		2815	} while (--i);
		2816
		2817	shost_printk(KERN_ERR, esp->host, "IRQ timeout. sreg [%02x]\n",
		2818	esp->sreg);
		2819	return 1;
		2820	}
		2821
		2822	#define ESP_FIFO_SIZE 16
		2823
		2824	void esp_send_pio_cmd(struct esp *esp, u32 addr, u32 esp_count,
		2825	u32 dma_count, int write, u8 cmd)
		2826	{
		2827	u8 phase = esp->sreg & ESP_STAT_PMASK;
		2828
		2829	cmd &= ~ESP_CMD_DMA;
		2830	esp->send_cmd_error = 0;
		2831
		2832	if (write) {
		2833	u8 dst = (u8 )addr;
		2834	u8 mask = ~(phase == ESP_MIP ? ESP_INTR_FDONE : ESP_INTR_BSERV);
		2835
		2836	scsi_esp_cmd(esp, cmd);
		2837
		2838	while (1) {
		2839	if (!esp_wait_for_fifo(esp))
		2840	break;
		2841
		2842	*dst++ = readb(esp->fifo_reg);
		2843	--esp_count;
		2844
		2845	if (!esp_count)
		2846	break;
		2847
		2848	if (esp_wait_for_intr(esp)) {
		2849	esp->send_cmd_error = 1;
		2850	break;
		2851	}
		2852
		2853	if ((esp->sreg & ESP_STAT_PMASK) != phase)
		2854	break;
		2855
		2856	esp->ireg = esp_read8(ESP_INTRPT);
		2857	if (esp->ireg & mask) {
		2858	esp->send_cmd_error = 1;
		2859	break;
		2860	}
		2861
		2862	if (phase == ESP_MIP)
		2863	esp_write8(ESP_CMD_MOK, ESP_CMD);
		2864
		2865	esp_write8(ESP_CMD_TI, ESP_CMD);
		2866	}
		2867	} else {
		2868	unsigned int n = ESP_FIFO_SIZE;
		2869	u8 src = (u8 )addr;
		2870
		2871	scsi_esp_cmd(esp, ESP_CMD_FLUSH);
		2872
		2873	if (n > esp_count)
		2874	n = esp_count;
		2875	writesb(esp->fifo_reg, src, n);
		2876	src += n;
		2877	esp_count -= n;
		2878
		2879	scsi_esp_cmd(esp, cmd);
		2880
		2881	while (esp_count) {
		2882	if (esp_wait_for_intr(esp)) {
		2883	esp->send_cmd_error = 1;
		2884	break;
		2885	}
		2886
		2887	if ((esp->sreg & ESP_STAT_PMASK) != phase)
		2888	break;
		2889
		2890	esp->ireg = esp_read8(ESP_INTRPT);
		2891	if (esp->ireg & ~ESP_INTR_BSERV) {
		2892	esp->send_cmd_error = 1;
		2893	break;
		2894	}
		2895
		2896	n = ESP_FIFO_SIZE -
		2897	(esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES);
		2898
		2899	if (n > esp_count)
		2900	n = esp_count;
		2901	writesb(esp->fifo_reg, src, n);
		2902	src += n;
		2903	esp_count -= n;
		2904
		2905	esp_write8(ESP_CMD_TI, ESP_CMD);
		2906	}
		2907	}
		2908
		2909	esp->send_cmd_residual = esp_count;
		2910	}
		2911	EXPORT_SYMBOL(esp_send_pio_cmd);
		2912	#endif

drivers/scsi/esp_scsi.h+14−24

 #define SYNC_DEFP_FAST            0x19   /* 10mb/s */
 struct esp_cmd_priv {
-	union {
+	int			num_sg;
-		dma_addr_t	dma_addr;
-		int		num_sg;
-	} u;
 	int			cur_residue;
 	struct scatterlist	*cur_sg;
 	int			tot_residue;
 	void (*esp_write8)(struct esp *esp, u8 val, unsigned long reg);
 	u8 (*esp_read8)(struct esp *esp, unsigned long reg);
-	/* Map and unmap DMA memory.  Eventually the driver will be
-	 * converted to the generic DMA API as soon as SBUS is able to
-	 * cope with that.  At such time we can remove this.
-	 */
-	dma_addr_t (*map_single)(struct esp *esp, void *buf,
-				 size_t sz, int dir);
-	int (*map_sg)(struct esp *esp, struct scatterlist *sg,
-		      int num_sg, int dir);
-	void (*unmap_single)(struct esp *esp, dma_addr_t addr,
-			     size_t sz, int dir);
-	void (*unmap_sg)(struct esp *esp, struct scatterlist *sg,
-			 int num_sg, int dir);
 	/* Return non-zero if there is an IRQ pending.  Usually this
 	 * status bit lives in the DMA controller sitting in front of
 	 * the ESP.  This has to be accurate or else the ESP interrupt
 	const struct esp_driver_ops *ops;
 	struct Scsi_Host	*host;
-	void			*dev;
+	struct device		*dev;
 	struct esp_cmd_entry	*active_cmd;
 	u32			flags;
 #define ESP_FLAG_DIFFERENTIAL	0x00000001
 #define ESP_FLAG_RESETTING	0x00000002
-#define ESP_FLAG_DOING_SLOWCMD	0x00000004
 #define ESP_FLAG_WIDE_CAPABLE	0x00000008
 #define ESP_FLAG_QUICKIRQ_CHECK	0x00000010
 #define ESP_FLAG_DISABLE_SYNC	0x00000020
 #define ESP_FLAG_USE_FIFO	0x00000040
+#define ESP_FLAG_NO_DMA_MAP	0x00000080
 	u8			select_state;
 #define ESP_SELECT_NONE		0x00 /* Not selecting */
 	u32			min_period;
 	u32			radelay;
-	/* Slow command state.  */
+	/* ESP_CMD_SELAS command state */
 	u8			*cmd_bytes_ptr;
 	int			cmd_bytes_left;
 	void			*dma;
 	int			dmarev;
+	/* These are used by esp_send_pio_cmd() */
+	u8 __iomem		*fifo_reg;
+	int			send_cmd_error;
+	u32			send_cmd_residual;
 };
 /* A front-end driver for the ESP chip should do the following in
  *     example, the DMA engine has to be reset before ESP can
  *     be programmed.
  * 11) If necessary, call dev_set_drvdata() as needed.
- * 12) Call scsi_esp_register() with prepared 'esp' structure
+ * 12) Call scsi_esp_register() with prepared 'esp' structure.
- *     and a device pointer if possible.
  * 13) Check scsi_esp_register() return value, release all resources
  *     if an error was returned.
  */
 extern struct scsi_host_template scsi_esp_template;
-extern int scsi_esp_register(struct esp *, struct device *);
+extern int scsi_esp_register(struct esp *);
 extern void scsi_esp_unregister(struct esp *);
 extern irqreturn_t scsi_esp_intr(int, void *);
 extern void scsi_esp_cmd(struct esp *, u8);
+extern void esp_send_pio_cmd(struct esp *esp, u32 dma_addr, u32 esp_count,
+			     u32 dma_count, int write, u8 cmd);
 #endif /* !(_ESP_SCSI_H) */

drivers/scsi/fnic/fnic_fcs.c+18−23

@@ -836,8 +836,8 @@ static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc · 835 unmodified lines
836	u32 fcp_bytes_written = 0;	836	u32 fcp_bytes_written = 0;
837	unsigned long flags;	837	unsigned long flags;
838		838
839	pci_unmap_single(fnic->pdev, buf->dma_addr, buf->len,	839	dma_unmap_single(&fnic->pdev->dev, buf->dma_addr, buf->len,
840	PCI_DMA_FROMDEVICE);	840	DMA_FROM_DEVICE);
841	skb = buf->os_buf;	841	skb = buf->os_buf;
842	fp = (struct fc_frame *)skb;	842	fp = (struct fc_frame *)skb;
843	buf->os_buf = NULL;	843	buf->os_buf = NULL;
@@ -977,9 +977,8 @@ int fnic_alloc_rq_frame(struct vnic_rq *rq) · 133 unmodified lines
977	skb_reset_transport_header(skb);	977	skb_reset_transport_header(skb);
978	skb_reset_network_header(skb);	978	skb_reset_network_header(skb);
979	skb_put(skb, len);	979	skb_put(skb, len);
980	pa = pci_map_single(fnic->pdev, skb->data, len, PCI_DMA_FROMDEVICE);	980	pa = dma_map_single(&fnic->pdev->dev, skb->data, len, DMA_FROM_DEVICE);
981		981	if (dma_mapping_error(&fnic->pdev->dev, pa)) {
982	if (pci_dma_mapping_error(fnic->pdev, pa)) {
983	r = -ENOMEM;	982	r = -ENOMEM;
984	printk(KERN_ERR "PCI mapping failed with error %d\n", r);	983	printk(KERN_ERR "PCI mapping failed with error %d\n", r);
985	goto free_skb;	984	goto free_skb;
@@ -998,8 +997,8 @@ void fnic_free_rq_buf(struct vnic_rq rq, struct vnic_rq_buf buf) · 12 unmodified lines
998	struct fc_frame *fp = buf->os_buf;	997	struct fc_frame *fp = buf->os_buf;
999	struct fnic *fnic = vnic_dev_priv(rq->vdev);	998	struct fnic *fnic = vnic_dev_priv(rq->vdev);
1000		999
1001	pci_unmap_single(fnic->pdev, buf->dma_addr, buf->len,	1000	dma_unmap_single(&fnic->pdev->dev, buf->dma_addr, buf->len,
1002	PCI_DMA_FROMDEVICE);	1001	DMA_FROM_DEVICE);
1003		1002
1004	dev_kfree_skb(fp_skb(fp));	1003	dev_kfree_skb(fp_skb(fp));
1005	buf->os_buf = NULL;	1004	buf->os_buf = NULL;
@@ -1018,7 +1017,6 @@ void fnic_eth_send(struct fcoe_ctlr fip, struct sk_buff skb) · 12 unmodified lines
1018	struct ethhdr *eth_hdr;	1017	struct ethhdr *eth_hdr;
1019	struct vlan_ethhdr *vlan_hdr;	1018	struct vlan_ethhdr *vlan_hdr;
1020	unsigned long flags;	1019	unsigned long flags;
1021	int r;
1022		1020
1023	if (!fnic->vlan_hw_insert) {	1021	if (!fnic->vlan_hw_insert) {
1024	eth_hdr = (struct ethhdr *)skb_mac_header(skb);	1022	eth_hdr = (struct ethhdr *)skb_mac_header(skb);
@@ -1038,11 +1036,10 @@ void fnic_eth_send(struct fcoe_ctlr fip, struct sk_buff skb) · 13 unmodified lines
1038	}	1036	}
1039	}	1037	}
1040		1038
1041	pa = pci_map_single(fnic->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);	1039	pa = dma_map_single(&fnic->pdev->dev, skb->data, skb->len,
1042		1040	DMA_TO_DEVICE);
1043	r = pci_dma_mapping_error(fnic->pdev, pa);	1041	if (dma_mapping_error(&fnic->pdev->dev, pa)) {
1044	if (r) {	1042	printk(KERN_ERR "DMA mapping failed\n");
1045	printk(KERN_ERR "PCI mapping failed with error %d\n", r);
1046	goto free_skb;	1043	goto free_skb;
1047	}	1044	}
1048		1045
@@ -1058,7 +1055,7 @@ void fnic_eth_send(struct fcoe_ctlr fip, struct sk_buff skb) · 9 unmodified lines
1058		1055
1059	irq_restore:	1056	irq_restore:
1060	spin_unlock_irqrestore(&fnic->wq_lock[0], flags);	1057	spin_unlock_irqrestore(&fnic->wq_lock[0], flags);
1061	pci_unmap_single(fnic->pdev, pa, skb->len, PCI_DMA_TODEVICE);	1058	dma_unmap_single(&fnic->pdev->dev, pa, skb->len, DMA_TO_DEVICE);
1062	free_skb:	1059	free_skb:
1063	kfree_skb(skb);	1060	kfree_skb(skb);
1064	}	1061	}
@@ -1115,9 +1112,8 @@ static int fnic_send_frame(struct fnic fnic, struct fc_frame fp) · 50 unmodified lines
1115	if (FC_FCOE_VER)	1112	if (FC_FCOE_VER)
1116	FC_FCOE_ENCAPS_VER(fcoe_hdr, FC_FCOE_VER);	1113	FC_FCOE_ENCAPS_VER(fcoe_hdr, FC_FCOE_VER);
1117		1114
1118	pa = pci_map_single(fnic->pdev, eth_hdr, tot_len, PCI_DMA_TODEVICE);	1115	pa = dma_map_single(&fnic->pdev->dev, eth_hdr, tot_len, DMA_TO_DEVICE);
1119		1116	if (dma_mapping_error(&fnic->pdev->dev, pa)) {
1120	if (pci_dma_mapping_error(fnic->pdev, pa)) {
1121	ret = -ENOMEM;	1117	ret = -ENOMEM;
1122	printk(KERN_ERR "DMA map failed with error %d\n", ret);	1118	printk(KERN_ERR "DMA map failed with error %d\n", ret);
1123	goto free_skb_on_err;	1119	goto free_skb_on_err;
@@ -1131,8 +1127,7 @@ static int fnic_send_frame(struct fnic fnic, struct fc_frame fp) · 7 unmodified lines
1131	spin_lock_irqsave(&fnic->wq_lock[0], flags);	1127	spin_lock_irqsave(&fnic->wq_lock[0], flags);
1132		1128
1133	if (!vnic_wq_desc_avail(wq)) {	1129	if (!vnic_wq_desc_avail(wq)) {
1134	pci_unmap_single(fnic->pdev, pa,	1130	dma_unmap_single(&fnic->pdev->dev, pa, tot_len, DMA_TO_DEVICE);
1135	tot_len, PCI_DMA_TODEVICE);
1136	ret = -1;	1131	ret = -1;
1137	goto irq_restore;	1132	goto irq_restore;
1138	}	1133	}
@@ -1247,8 +1242,8 @@ static void fnic_wq_complete_frame_send(struct vnic_wq *wq, · 108 unmodified lines
1247	struct fc_frame fp = (struct fc_frame )skb;	1242	struct fc_frame fp = (struct fc_frame )skb;
1248	struct fnic *fnic = vnic_dev_priv(wq->vdev);	1243	struct fnic *fnic = vnic_dev_priv(wq->vdev);
1249		1244
1250	pci_unmap_single(fnic->pdev, buf->dma_addr,	1245	dma_unmap_single(&fnic->pdev->dev, buf->dma_addr, buf->len,
1251	buf->len, PCI_DMA_TODEVICE);	1246	DMA_TO_DEVICE);
1252	dev_kfree_skb_irq(fp_skb(fp));	1247	dev_kfree_skb_irq(fp_skb(fp));
1253	buf->os_buf = NULL;	1248	buf->os_buf = NULL;
1254	}	1249	}
@@ -1290,8 +1285,8 @@ void fnic_free_wq_buf(struct vnic_wq wq, struct vnic_wq_buf buf) · 35 unmodified lines
1290	struct fc_frame *fp = buf->os_buf;	1285	struct fc_frame *fp = buf->os_buf;
1291	struct fnic *fnic = vnic_dev_priv(wq->vdev);	1286	struct fnic *fnic = vnic_dev_priv(wq->vdev);
1292		1287
1293	pci_unmap_single(fnic->pdev, buf->dma_addr,	1288	dma_unmap_single(&fnic->pdev->dev, buf->dma_addr, buf->len,
1294	buf->len, PCI_DMA_TODEVICE);	1289	DMA_TO_DEVICE);
1295		1290
1296	dev_kfree_skb(fp_skb(fp));	1291	dev_kfree_skb(fp_skb(fp));
1297	buf->os_buf = NULL;	1292	buf->os_buf = NULL;

drivers/scsi/fnic/fnic_main.c+2−17

 	 * limitation for the device.  Try 64-bit first, and
 	 * fail to 32-bit.
 	 */
-	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
+	err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
 	if (err) {
-		err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+		err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
 		if (err) {
 			shost_printk(KERN_ERR, fnic->lport->host,
 				     "No usable DMA configuration "
 				     "aborting\n");
 			goto err_out_release_regions;
 		}
-		err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
-		if (err) {
-			shost_printk(KERN_ERR, fnic->lport->host,
-				     "Unable to obtain 32-bit DMA "
-				     "for consistent allocations, aborting.\n");
-			goto err_out_release_regions;
-		}
-	} else {
-		err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
-		if (err) {
-			shost_printk(KERN_ERR, fnic->lport->host,
-				     "Unable to obtain 64-bit DMA "
-				     "for consistent allocations, aborting.\n");
-			goto err_out_release_regions;
-		}
 	}
 	/* Map vNIC resources from BAR0 */

drivers/scsi/fnic/fnic_scsi.c+28−71

@@ -126,17 +126,17 @@ static void fnic_release_ioreq_buf(struct fnic *fnic, · 125 unmodified lines
126	struct scsi_cmnd *sc)	126	struct scsi_cmnd *sc)
127	{	127	{
128	if (io_req->sgl_list_pa)	128	if (io_req->sgl_list_pa)
129	pci_unmap_single(fnic->pdev, io_req->sgl_list_pa,	129	dma_unmap_single(&fnic->pdev->dev, io_req->sgl_list_pa,
130	sizeof(io_req->sgl_list[0]) * io_req->sgl_cnt,	130	sizeof(io_req->sgl_list[0]) * io_req->sgl_cnt,
131	PCI_DMA_TODEVICE);	131	DMA_TO_DEVICE);
132	scsi_dma_unmap(sc);	132	scsi_dma_unmap(sc);
133		133
134	if (io_req->sgl_cnt)	134	if (io_req->sgl_cnt)
135	mempool_free(io_req->sgl_list_alloc,	135	mempool_free(io_req->sgl_list_alloc,
136	fnic->io_sgl_pool[io_req->sgl_type]);	136	fnic->io_sgl_pool[io_req->sgl_type]);
137	if (io_req->sense_buf_pa)	137	if (io_req->sense_buf_pa)
138	pci_unmap_single(fnic->pdev, io_req->sense_buf_pa,	138	dma_unmap_single(&fnic->pdev->dev, io_req->sense_buf_pa,
139	SCSI_SENSE_BUFFERSIZE, PCI_DMA_FROMDEVICE);	139	SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE);
140	}	140	}
141		141
142	/* Free up Copy Wq descriptors. Called with copy_wq lock held */	142	/* Free up Copy Wq descriptors. Called with copy_wq lock held */
@@ -330,7 +330,6 @@ static inline int fnic_queue_wq_copy_desc(struct fnic *fnic, · 187 unmodified lines
330	int flags;	330	int flags;
331	u8 exch_flags;	331	u8 exch_flags;
332	struct scsi_lun fc_lun;	332	struct scsi_lun fc_lun;
333	int r;
334		333
335	if (sg_count) {	334	if (sg_count) {
336	/* For each SGE, create a device desc entry */	335	/* For each SGE, create a device desc entry */
@@ -342,30 +341,25 @@ static inline int fnic_queue_wq_copy_desc(struct fnic *fnic, · 5 unmodified lines
342	desc++;	341	desc++;
343	}	342	}
344		343
345	io_req->sgl_list_pa = pci_map_single	344	io_req->sgl_list_pa = dma_map_single(&fnic->pdev->dev,
346	(fnic->pdev,	345	io_req->sgl_list,
347	io_req->sgl_list,	346	sizeof(io_req->sgl_list[0]) * sg_count,
348	sizeof(io_req->sgl_list[0]) * sg_count,	347	DMA_TO_DEVICE);
349	PCI_DMA_TODEVICE);	348	if (dma_mapping_error(&fnic->pdev->dev, io_req->sgl_list_pa)) {
350		349	printk(KERN_ERR "DMA mapping failed\n");
351	r = pci_dma_mapping_error(fnic->pdev, io_req->sgl_list_pa);
352	if (r) {
353	printk(KERN_ERR "PCI mapping failed with error %d\n", r);
354	return SCSI_MLQUEUE_HOST_BUSY;	350	return SCSI_MLQUEUE_HOST_BUSY;
355	}	351	}
356	}	352	}
357		353
358	io_req->sense_buf_pa = pci_map_single(fnic->pdev,	354	io_req->sense_buf_pa = dma_map_single(&fnic->pdev->dev,
359	sc->sense_buffer,	355	sc->sense_buffer,
360	SCSI_SENSE_BUFFERSIZE,	356	SCSI_SENSE_BUFFERSIZE,
361	PCI_DMA_FROMDEVICE);	357	DMA_FROM_DEVICE);
362		358	if (dma_mapping_error(&fnic->pdev->dev, io_req->sense_buf_pa)) {
363	r = pci_dma_mapping_error(fnic->pdev, io_req->sense_buf_pa);	359	dma_unmap_single(&fnic->pdev->dev, io_req->sgl_list_pa,
364	if (r) {
365	pci_unmap_single(fnic->pdev, io_req->sgl_list_pa,
366	sizeof(io_req->sgl_list[0]) * sg_count,	360	sizeof(io_req->sgl_list[0]) * sg_count,
367	PCI_DMA_TODEVICE);	361	DMA_TO_DEVICE);
368	printk(KERN_ERR "PCI mapping failed with error %d\n", r);	362	printk(KERN_ERR "DMA mapping failed\n");
369	return SCSI_MLQUEUE_HOST_BUSY;	363	return SCSI_MLQUEUE_HOST_BUSY;
370	}	364	}
371		365
@@ -2272,33 +2266,17 @@ clean_pending_aborts_end: · 1900 unmodified lines
2272	static inline int	2266	static inline int
2273	fnic_scsi_host_start_tag(struct fnic fnic, struct scsi_cmnd sc)	2267	fnic_scsi_host_start_tag(struct fnic fnic, struct scsi_cmnd sc)
2274	{	2268	{
2275	struct blk_queue_tag *bqt = fnic->lport->host->bqt;	2269	struct request_queue *q = sc->request->q;
2276	int tag, ret = SCSI_NO_TAG;	2270	struct request *dummy;
2277
2278	BUG_ON(!bqt);
2279	if (!bqt) {
2280	pr_err("Tags are not supported\n");
2281	goto end;
2282	}
2283
2284	do {
2285	tag = find_next_zero_bit(bqt->tag_map, bqt->max_depth, 1);
2286	if (tag >= bqt->max_depth) {
2287	pr_err("Tag allocation failure\n");
2288	goto end;
2289	}
2290	} while (test_and_set_bit(tag, bqt->tag_map));
2291		2271
2292	bqt->tag_index[tag] = sc->request;	2272	dummy = blk_mq_alloc_request(q, REQ_OP_WRITE, BLK_MQ_REQ_NOWAIT);
2293	sc->request->tag = tag;	2273	if (IS_ERR(dummy))
2294	sc->tag = tag;	2274	return SCSI_NO_TAG;
2295	if (!sc->request->special)
2296	sc->request->special = sc;
2297		2275
2298	ret = tag;	2276	sc->tag = sc->request->tag = dummy->tag;
		2277	sc->request->special = sc;
2299		2278
2300	end:	2279	return dummy->tag;
2301	return ret;
2302	}	2280	}
2303		2281
2304	/**	2282	/**
@@ -2308,20 +2286,9 @@ end: · 3 unmodified lines
2308	static inline void	2286	static inline void
2309	fnic_scsi_host_end_tag(struct fnic fnic, struct scsi_cmnd sc)	2287	fnic_scsi_host_end_tag(struct fnic fnic, struct scsi_cmnd sc)
2310	{	2288	{
2311	struct blk_queue_tag *bqt = fnic->lport->host->bqt;	2289	struct request *dummy = sc->request->special;
2312	int tag = sc->request->tag;
2313		2290
2314	if (tag == SCSI_NO_TAG)	2291	blk_mq_free_request(dummy);
2315	return;
2316
2317	BUG_ON(!bqt \|\| !bqt->tag_index[tag]);
2318	if (!bqt)
2319	return;
2320
2321	bqt->tag_index[tag] = NULL;
2322	clear_bit(tag, bqt->tag_map);
2323
2324	return;
2325	}	2292	}
2326		2293
2327	/*	2294	/*
@@ -2380,19 +2347,9 @@ int fnic_device_reset(struct scsi_cmnd *sc) · 52 unmodified lines
2380	tag = sc->request->tag;	2347	tag = sc->request->tag;
2381	if (unlikely(tag < 0)) {	2348	if (unlikely(tag < 0)) {
2382	/*	2349	/*
2383	* XXX(hch): current the midlayer fakes up a struct	2350	* Really should fix the midlayer to pass in a proper
2384	* request for the explicit reset ioctls, and those	2351	* request for ioctls...
2385	* don't have a tag allocated to them. The below
2386	* code pokes into midlayer structures to paper over
2387	* this design issue, but that won't work for blk-mq.
2388	*
2389	* Either someone who can actually test the hardware
2390	* will have to come up with a similar hack for the
2391	* blk-mq case, or we'll have to bite the bullet and
2392	* fix the way the EH ioctls work for real, but until
2393	* that happens we fail these explicit requests here.
2394	*/	2352	*/
2395
2396	tag = fnic_scsi_host_start_tag(fnic, sc);	2353	tag = fnic_scsi_host_start_tag(fnic, sc);
2397	if (unlikely(tag == SCSI_NO_TAG))	2354	if (unlikely(tag == SCSI_NO_TAG))
2398	goto fnic_device_reset_end;	2355	goto fnic_device_reset_end;

drivers/scsi/fnic/vnic_dev.c+13−13

@@ -195,9 +195,9 @@ int vnic_dev_alloc_desc_ring(struct vnic_dev vdev, struct vnic_dev_ring ring, · 194 unmodified lines
195	{	195	{
196	vnic_dev_desc_ring_size(ring, desc_count, desc_size);	196	vnic_dev_desc_ring_size(ring, desc_count, desc_size);
197		197
198	ring->descs_unaligned = pci_alloc_consistent(vdev->pdev,	198	ring->descs_unaligned = dma_alloc_coherent(&vdev->pdev->dev,
199	ring->size_unaligned,	199	ring->size_unaligned,
200	&ring->base_addr_unaligned);	200	&ring->base_addr_unaligned, GFP_KERNEL);
201		201
202	if (!ring->descs_unaligned) {	202	if (!ring->descs_unaligned) {
203	printk(KERN_ERR	203	printk(KERN_ERR
@@ -221,7 +221,7 @@ int vnic_dev_alloc_desc_ring(struct vnic_dev vdev, struct vnic_dev_ring ring, · 17 unmodified lines
221	void vnic_dev_free_desc_ring(struct vnic_dev vdev, struct vnic_dev_ring ring)	221	void vnic_dev_free_desc_ring(struct vnic_dev vdev, struct vnic_dev_ring ring)
222	{	222	{
223	if (ring->descs) {	223	if (ring->descs) {
224	pci_free_consistent(vdev->pdev,	224	dma_free_coherent(&vdev->pdev->dev,
225	ring->size_unaligned,	225	ring->size_unaligned,
226	ring->descs_unaligned,	226	ring->descs_unaligned,
227	ring->base_addr_unaligned);	227	ring->base_addr_unaligned);
@@ -298,9 +298,9 @@ int vnic_dev_fw_info(struct vnic_dev *vdev, · 70 unmodified lines
298	int err = 0;	298	int err = 0;
299		299
300	if (!vdev->fw_info) {	300	if (!vdev->fw_info) {
301	vdev->fw_info = pci_alloc_consistent(vdev->pdev,	301	vdev->fw_info = dma_alloc_coherent(&vdev->pdev->dev,
302	sizeof(struct vnic_devcmd_fw_info),	302	sizeof(struct vnic_devcmd_fw_info),
303	&vdev->fw_info_pa);	303	&vdev->fw_info_pa, GFP_KERNEL);
304	if (!vdev->fw_info)	304	if (!vdev->fw_info)
305	return -ENOMEM;	305	return -ENOMEM;
306		306
@@ -361,8 +361,8 @@ int vnic_dev_stats_dump(struct vnic_dev vdev, struct vnic_stats *stats) · 54 unmodified lines
361	int wait = 1000;	361	int wait = 1000;
362		362
363	if (!vdev->stats) {	363	if (!vdev->stats) {
364	vdev->stats = pci_alloc_consistent(vdev->pdev,	364	vdev->stats = dma_alloc_coherent(&vdev->pdev->dev,
365	sizeof(struct vnic_stats), &vdev->stats_pa);	365	sizeof(struct vnic_stats), &vdev->stats_pa, GFP_KERNEL);
366	if (!vdev->stats)	366	if (!vdev->stats)
367	return -ENOMEM;	367	return -ENOMEM;
368	}	368	}
@@ -523,9 +523,9 @@ int vnic_dev_notify_set(struct vnic_dev *vdev, u16 intr) · 154 unmodified lines
523	int wait = 1000;	523	int wait = 1000;
524		524
525	if (!vdev->notify) {	525	if (!vdev->notify) {
526	vdev->notify = pci_alloc_consistent(vdev->pdev,	526	vdev->notify = dma_alloc_coherent(&vdev->pdev->dev,
527	sizeof(struct vnic_devcmd_notify),	527	sizeof(struct vnic_devcmd_notify),
528	&vdev->notify_pa);	528	&vdev->notify_pa, GFP_KERNEL);
529	if (!vdev->notify)	529	if (!vdev->notify)
530	return -ENOMEM;	530	return -ENOMEM;
531	}	531	}
@@ -647,21 +647,21 @@ void vnic_dev_unregister(struct vnic_dev *vdev) · 115 unmodified lines
647	{	647	{
648	if (vdev) {	648	if (vdev) {
649	if (vdev->notify)	649	if (vdev->notify)
650	pci_free_consistent(vdev->pdev,	650	dma_free_coherent(&vdev->pdev->dev,
651	sizeof(struct vnic_devcmd_notify),	651	sizeof(struct vnic_devcmd_notify),
652	vdev->notify,	652	vdev->notify,
653	vdev->notify_pa);	653	vdev->notify_pa);
654	if (vdev->linkstatus)	654	if (vdev->linkstatus)
655	pci_free_consistent(vdev->pdev,	655	dma_free_coherent(&vdev->pdev->dev,
656	sizeof(u32),	656	sizeof(u32),
657	vdev->linkstatus,	657	vdev->linkstatus,
658	vdev->linkstatus_pa);	658	vdev->linkstatus_pa);
659	if (vdev->stats)	659	if (vdev->stats)
660	pci_free_consistent(vdev->pdev,	660	dma_free_coherent(&vdev->pdev->dev,
661	sizeof(struct vnic_stats),	661	sizeof(struct vnic_stats),
662	vdev->stats, vdev->stats_pa);	662	vdev->stats, vdev->stats_pa);
663	if (vdev->fw_info)	663	if (vdev->fw_info)
664	pci_free_consistent(vdev->pdev,	664	dma_free_coherent(&vdev->pdev->dev,
665	sizeof(struct vnic_devcmd_fw_info),	665	sizeof(struct vnic_devcmd_fw_info),
666	vdev->fw_info, vdev->fw_info_pa);	666	vdev->fw_info, vdev->fw_info_pa);
667	kfree(vdev);	667	kfree(vdev);

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

 #define HISI_SAS_MAX_DEVICES HISI_SAS_MAX_ITCT_ENTRIES
 #define HISI_SAS_RESET_BIT	0
 #define HISI_SAS_REJECT_CMD_BIT	1
+#define HISI_SAS_RESERVED_IPTT_CNT  96
 #define HISI_SAS_STATUS_BUF_SZ (sizeof(struct hisi_sas_status_buffer))
 #define HISI_SAS_COMMAND_TABLE_SZ (sizeof(union hisi_sas_command_table))
 	int (*hw_init)(struct hisi_hba *hisi_hba);
 	void (*setup_itct)(struct hisi_hba *hisi_hba,
 			   struct hisi_sas_device *device);
-	int (*slot_index_alloc)(struct hisi_hba *hisi_hba, int *slot_idx,
+	int (*slot_index_alloc)(struct hisi_hba *hisi_hba,
 				struct domain_device *device);
 	struct hisi_sas_device *(*alloc_dev)(struct domain_device *device);
 	void (*sl_notify)(struct hisi_hba *hisi_hba, int phy_no);

drivers/scsi/hisi_sas/hisi_sas_main.c+113−48

@@ -183,7 +183,14 @@ static void hisi_sas_slot_index_clear(struct hisi_hba *hisi_hba, int slot_idx) · 182 unmodified lines
183		183
184	static void hisi_sas_slot_index_free(struct hisi_hba *hisi_hba, int slot_idx)	184	static void hisi_sas_slot_index_free(struct hisi_hba *hisi_hba, int slot_idx)
185	{	185	{
186	hisi_sas_slot_index_clear(hisi_hba, slot_idx);	186	unsigned long flags;
		187
		188	if (hisi_hba->hw->slot_index_alloc \|\| (slot_idx >=
		189	hisi_hba->hw->max_command_entries - HISI_SAS_RESERVED_IPTT_CNT)) {
		190	spin_lock_irqsave(&hisi_hba->lock, flags);
		191	hisi_sas_slot_index_clear(hisi_hba, slot_idx);
		192	spin_unlock_irqrestore(&hisi_hba->lock, flags);
		193	}
187	}	194	}
188		195
189	static void hisi_sas_slot_index_set(struct hisi_hba *hisi_hba, int slot_idx)	196	static void hisi_sas_slot_index_set(struct hisi_hba *hisi_hba, int slot_idx)
@@ -193,24 +200,34 @@ static void hisi_sas_slot_index_set(struct hisi_hba *hisi_hba, int slot_idx) · 3 unmodified lines
193	set_bit(slot_idx, bitmap);	200	set_bit(slot_idx, bitmap);
194	}	201	}
195		202
196	static int hisi_sas_slot_index_alloc(struct hisi_hba hisi_hba, int slot_idx)	203	static int hisi_sas_slot_index_alloc(struct hisi_hba *hisi_hba,
		204	struct scsi_cmnd *scsi_cmnd)
197	{	205	{
198	unsigned int index;	206	int index;
199	void *bitmap = hisi_hba->slot_index_tags;	207	void *bitmap = hisi_hba->slot_index_tags;
		208	unsigned long flags;
		209
		210	if (scsi_cmnd)
		211	return scsi_cmnd->request->tag;
200		212
		213	spin_lock_irqsave(&hisi_hba->lock, flags);
201	index = find_next_zero_bit(bitmap, hisi_hba->slot_index_count,	214	index = find_next_zero_bit(bitmap, hisi_hba->slot_index_count,
202	hisi_hba->last_slot_index + 1);	215	hisi_hba->last_slot_index + 1);
203	if (index >= hisi_hba->slot_index_count) {	216	if (index >= hisi_hba->slot_index_count) {
204	index = find_next_zero_bit(bitmap, hisi_hba->slot_index_count,	217	index = find_next_zero_bit(bitmap,
205	0);	218	hisi_hba->slot_index_count,
206	if (index >= hisi_hba->slot_index_count)	219	hisi_hba->hw->max_command_entries -
		220	HISI_SAS_RESERVED_IPTT_CNT);
		221	if (index >= hisi_hba->slot_index_count) {
		222	spin_unlock_irqrestore(&hisi_hba->lock, flags);
207	return -SAS_QUEUE_FULL;	223	return -SAS_QUEUE_FULL;
		224	}
208	}	225	}
209	hisi_sas_slot_index_set(hisi_hba, index);	226	hisi_sas_slot_index_set(hisi_hba, index);
210	*slot_idx = index;
211	hisi_hba->last_slot_index = index;	227	hisi_hba->last_slot_index = index;
		228	spin_unlock_irqrestore(&hisi_hba->lock, flags);
212		229
213	return 0;	230	return index;
214	}	231	}
215		232
216	static void hisi_sas_slot_index_init(struct hisi_hba *hisi_hba)	233	static void hisi_sas_slot_index_init(struct hisi_hba *hisi_hba)
@@ -249,9 +266,7 @@ void hisi_sas_slot_task_free(struct hisi_hba hisi_hba, struct sas_task task, · 32 unmodified lines
249		266
250	memset(slot, 0, offsetof(struct hisi_sas_slot, buf));	267	memset(slot, 0, offsetof(struct hisi_sas_slot, buf));
251		268
252	spin_lock_irqsave(&hisi_hba->lock, flags);
253	hisi_sas_slot_index_free(hisi_hba, slot->idx);	269	hisi_sas_slot_index_free(hisi_hba, slot->idx);
254	spin_unlock_irqrestore(&hisi_hba->lock, flags);
255	}	270	}
256	EXPORT_SYMBOL_GPL(hisi_sas_slot_task_free);	271	EXPORT_SYMBOL_GPL(hisi_sas_slot_task_free);
257		272
@@ -287,13 +302,13 @@ static int hisi_sas_task_prep(struct sas_task *task, · 29 unmodified lines
287	int *pass)	302	int *pass)
288	{	303	{
289	struct domain_device *device = task->dev;	304	struct domain_device *device = task->dev;
290	struct hisi_hba *hisi_hba = dev_to_hisi_hba(device);	305	struct hisi_hba *hisi_hba;
291	struct hisi_sas_device *sas_dev = device->lldd_dev;	306	struct hisi_sas_device *sas_dev = device->lldd_dev;
292	struct hisi_sas_port *port;	307	struct hisi_sas_port *port;
293	struct hisi_sas_slot *slot;	308	struct hisi_sas_slot *slot;
294	struct hisi_sas_cmd_hdr *cmd_hdr_base;	309	struct hisi_sas_cmd_hdr *cmd_hdr_base;
295	struct asd_sas_port *sas_port = device->port;	310	struct asd_sas_port *sas_port = device->port;
296	struct device *dev = hisi_hba->dev;	311	struct device *dev;
297	int dlvry_queue_slot, dlvry_queue, rc, slot_idx;	312	int dlvry_queue_slot, dlvry_queue, rc, slot_idx;
298	int n_elem = 0, n_elem_req = 0, n_elem_resp = 0;	313	int n_elem = 0, n_elem_req = 0, n_elem_resp = 0;
299	struct hisi_sas_dq *dq;	314	struct hisi_sas_dq *dq;
@@ -314,6 +329,9 @@ static int hisi_sas_task_prep(struct sas_task *task, · 14 unmodified lines
314	return -ECOMM;	329	return -ECOMM;
315	}	330	}
316		331
		332	hisi_hba = dev_to_hisi_hba(device);
		333	dev = hisi_hba->dev;
		334
317	if (DEV_IS_GONE(sas_dev)) {	335	if (DEV_IS_GONE(sas_dev)) {
318	if (sas_dev)	336	if (sas_dev)
319	dev_info(dev, "task prep: device %d not ready\n",	337	dev_info(dev, "task prep: device %d not ready\n",
@@ -381,16 +399,27 @@ static int hisi_sas_task_prep(struct sas_task *task, · 61 unmodified lines
381	goto err_out_dma_unmap;	399	goto err_out_dma_unmap;
382	}	400	}
383		401
384	spin_lock_irqsave(&hisi_hba->lock, flags);
385	if (hisi_hba->hw->slot_index_alloc)	402	if (hisi_hba->hw->slot_index_alloc)
386	rc = hisi_hba->hw->slot_index_alloc(hisi_hba, &slot_idx,	403	rc = hisi_hba->hw->slot_index_alloc(hisi_hba, device);
387	device);	404	else {
388	else	405	struct scsi_cmnd *scsi_cmnd = NULL;
389	rc = hisi_sas_slot_index_alloc(hisi_hba, &slot_idx);	406
390	spin_unlock_irqrestore(&hisi_hba->lock, flags);	407	if (task->uldd_task) {
391	if (rc)	408	struct ata_queued_cmd *qc;
		409
		410	if (dev_is_sata(device)) {
		411	qc = task->uldd_task;
		412	scsi_cmnd = qc->scsicmd;
		413	} else {
		414	scsi_cmnd = task->uldd_task;
		415	}
		416	}
		417	rc = hisi_sas_slot_index_alloc(hisi_hba, scsi_cmnd);
		418	}
		419	if (rc < 0)
392	goto err_out_dma_unmap;	420	goto err_out_dma_unmap;
393		421
		422	slot_idx = rc;
394	slot = &hisi_hba->slot_info[slot_idx];	423	slot = &hisi_hba->slot_info[slot_idx];
395		424
396	spin_lock_irqsave(&dq->lock, flags);	425	spin_lock_irqsave(&dq->lock, flags);
@@ -451,9 +480,7 @@ static int hisi_sas_task_prep(struct sas_task *task, · 54 unmodified lines
451	return 0;	480	return 0;
452		481
453	err_out_tag:	482	err_out_tag:
454	spin_lock_irqsave(&hisi_hba->lock, flags);
455	hisi_sas_slot_index_free(hisi_hba, slot_idx);	483	hisi_sas_slot_index_free(hisi_hba, slot_idx);
456	spin_unlock_irqrestore(&hisi_hba->lock, flags);
457	err_out_dma_unmap:	484	err_out_dma_unmap:
458	if (!sas_protocol_ata(task->task_proto)) {	485	if (!sas_protocol_ata(task->task_proto)) {
459	if (task->num_scatter) {	486	if (task->num_scatter) {
@@ -904,6 +931,9 @@ static void hisi_sas_phy_set_linkrate(struct hisi_hba *hisi_hba, int phy_no, · 444 unmodified lines
904	_r.maximum_linkrate = max;	931	_r.maximum_linkrate = max;
905	_r.minimum_linkrate = min;	932	_r.minimum_linkrate = min;
906		933
		934	sas_phy->phy->maximum_linkrate = max;
		935	sas_phy->phy->minimum_linkrate = min;
		936
907	hisi_hba->hw->phy_disable(hisi_hba, phy_no);	937	hisi_hba->hw->phy_disable(hisi_hba, phy_no);
908	msleep(100);	938	msleep(100);
909	hisi_hba->hw->phy_set_linkrate(hisi_hba, phy_no, &_r);	939	hisi_hba->hw->phy_set_linkrate(hisi_hba, phy_no, &_r);
@@ -950,8 +980,7 @@ static int hisi_sas_control_phy(struct asd_sas_phy *sas_phy, enum phy_func func, · 40 unmodified lines
950		980
951	static void hisi_sas_task_done(struct sas_task *task)	981	static void hisi_sas_task_done(struct sas_task *task)
952	{	982	{
953	if (!del_timer(&task->slow_task->timer))	983	del_timer(&task->slow_task->timer);
954	return;
955	complete(&task->slow_task->completion);	984	complete(&task->slow_task->completion);
956	}	985	}
957		986
@@ -960,13 +989,17 @@ static void hisi_sas_tmf_timedout(struct timer_list *t) · 2 unmodified lines
960	struct sas_task_slow *slow = from_timer(slow, t, timer);	989	struct sas_task_slow *slow = from_timer(slow, t, timer);
961	struct sas_task *task = slow->task;	990	struct sas_task *task = slow->task;
962	unsigned long flags;	991	unsigned long flags;
		992	bool is_completed = true;
963		993
964	spin_lock_irqsave(&task->task_state_lock, flags);	994	spin_lock_irqsave(&task->task_state_lock, flags);
965	if (!(task->task_state_flags & SAS_TASK_STATE_DONE))	995	if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
966	task->task_state_flags \|= SAS_TASK_STATE_ABORTED;	996	task->task_state_flags \|= SAS_TASK_STATE_ABORTED;
		997	is_completed = false;
		998	}
967	spin_unlock_irqrestore(&task->task_state_lock, flags);	999	spin_unlock_irqrestore(&task->task_state_lock, flags);
968		1000
969	complete(&task->slow_task->completion);	1001	if (!is_completed)
		1002	complete(&task->slow_task->completion);
970	}	1003	}
971		1004
972	#define TASK_TIMEOUT 20	1005	#define TASK_TIMEOUT 20
@@ -1019,8 +1052,16 @@ static int hisi_sas_exec_internal_tmf_task(struct domain_device *device, · 46 unmodified lines
1019	struct hisi_sas_slot *slot = task->lldd_task;	1052	struct hisi_sas_slot *slot = task->lldd_task;
1020		1053
1021	dev_err(dev, "abort tmf: TMF task timeout and not done\n");	1054	dev_err(dev, "abort tmf: TMF task timeout and not done\n");
1022	if (slot)	1055	if (slot) {
		1056	struct hisi_sas_cq *cq =
		1057	&hisi_hba->cq[slot->dlvry_queue];
		1058	/*
		1059	* flush tasklet to avoid free'ing task
		1060	* before using task in IO completion
		1061	*/
		1062	tasklet_kill(&cq->tasklet);
1023	slot->task = NULL;	1063	slot->task = NULL;
		1064	}
1024		1065
1025	goto ex_err;	1066	goto ex_err;
1026	} else	1067	} else
@@ -1396,6 +1437,17 @@ static int hisi_sas_abort_task(struct sas_task *task) · 369 unmodified lines
1396		1437
1397	spin_lock_irqsave(&task->task_state_lock, flags);	1438	spin_lock_irqsave(&task->task_state_lock, flags);
1398	if (task->task_state_flags & SAS_TASK_STATE_DONE) {	1439	if (task->task_state_flags & SAS_TASK_STATE_DONE) {
		1440	struct hisi_sas_slot *slot = task->lldd_task;
		1441	struct hisi_sas_cq *cq;
		1442
		1443	if (slot) {
		1444	/*
		1445	* flush tasklet to avoid free'ing task
		1446	* before using task in IO completion
		1447	*/
		1448	cq = &hisi_hba->cq[slot->dlvry_queue];
		1449	tasklet_kill(&cq->tasklet);
		1450	}
1399	spin_unlock_irqrestore(&task->task_state_lock, flags);	1451	spin_unlock_irqrestore(&task->task_state_lock, flags);
1400	rc = TMF_RESP_FUNC_COMPLETE;	1452	rc = TMF_RESP_FUNC_COMPLETE;
1401	goto out;	1453	goto out;
@@ -1451,12 +1503,19 @@ static int hisi_sas_abort_task(struct sas_task *task) · 49 unmodified lines
1451	/* SMP */	1503	/* SMP */
1452	struct hisi_sas_slot *slot = task->lldd_task;	1504	struct hisi_sas_slot *slot = task->lldd_task;
1453	u32 tag = slot->idx;	1505	u32 tag = slot->idx;
		1506	struct hisi_sas_cq *cq = &hisi_hba->cq[slot->dlvry_queue];
1454		1507
1455	rc = hisi_sas_internal_task_abort(hisi_hba, device,	1508	rc = hisi_sas_internal_task_abort(hisi_hba, device,
1456	HISI_SAS_INT_ABT_CMD, tag);	1509	HISI_SAS_INT_ABT_CMD, tag);
1457	if (((rc < 0) \|\| (rc == TMF_RESP_FUNC_FAILED)) &&	1510	if (((rc < 0) \|\| (rc == TMF_RESP_FUNC_FAILED)) &&
1458	task->lldd_task)	1511	task->lldd_task) {
1459	hisi_sas_do_release_task(hisi_hba, task, slot);	1512	/*
		1513	* flush tasklet to avoid free'ing task
		1514	* before using task in IO completion
		1515	*/
		1516	tasklet_kill(&cq->tasklet);
		1517	slot->task = NULL;
		1518	}
1460	}	1519	}
1461		1520
1462	out:	1521	out:
@@ -1705,14 +1764,11 @@ hisi_sas_internal_abort_task_exec(struct hisi_hba *hisi_hba, int device_id, · 242 unmodified lines
1705	port = to_hisi_sas_port(sas_port);	1764	port = to_hisi_sas_port(sas_port);
1706		1765
1707	/* simply get a slot and send abort command */	1766	/* simply get a slot and send abort command */
1708	spin_lock_irqsave(&hisi_hba->lock, flags);	1767	rc = hisi_sas_slot_index_alloc(hisi_hba, NULL);
1709	rc = hisi_sas_slot_index_alloc(hisi_hba, &slot_idx);	1768	if (rc < 0)
1710	if (rc) {
1711	spin_unlock_irqrestore(&hisi_hba->lock, flags);
1712	goto err_out;	1769	goto err_out;
1713	}
1714	spin_unlock_irqrestore(&hisi_hba->lock, flags);
1715		1770
		1771	slot_idx = rc;
1716	slot = &hisi_hba->slot_info[slot_idx];	1772	slot = &hisi_hba->slot_info[slot_idx];
1717		1773
1718	spin_lock_irqsave(&dq->lock, flags_dq);	1774	spin_lock_irqsave(&dq->lock, flags_dq);
@@ -1748,7 +1804,6 @@ hisi_sas_internal_abort_task_exec(struct hisi_hba *hisi_hba, int device_id, · 29 unmodified lines
1748	spin_lock_irqsave(&task->task_state_lock, flags);	1804	spin_lock_irqsave(&task->task_state_lock, flags);
1749	task->task_state_flags \|= SAS_TASK_AT_INITIATOR;	1805	task->task_state_flags \|= SAS_TASK_AT_INITIATOR;
1750	spin_unlock_irqrestore(&task->task_state_lock, flags);	1806	spin_unlock_irqrestore(&task->task_state_lock, flags);
1751
1752	WRITE_ONCE(slot->ready, 1);	1807	WRITE_ONCE(slot->ready, 1);
1753	/* send abort command to the chip */	1808	/* send abort command to the chip */
1754	spin_lock_irqsave(&dq->lock, flags);	1809	spin_lock_irqsave(&dq->lock, flags);
@@ -1759,9 +1814,7 @@ hisi_sas_internal_abort_task_exec(struct hisi_hba *hisi_hba, int device_id, · 4 unmodified lines
1759	return 0;	1814	return 0;
1760		1815
1761	err_out_tag:	1816	err_out_tag:
1762	spin_lock_irqsave(&hisi_hba->lock, flags);
1763	hisi_sas_slot_index_free(hisi_hba, slot_idx);	1817	hisi_sas_slot_index_free(hisi_hba, slot_idx);
1764	spin_unlock_irqrestore(&hisi_hba->lock, flags);
1765	err_out:	1818	err_out:
1766	dev_err(dev, "internal abort task prep: failed[%d]!\n", rc);	1819	dev_err(dev, "internal abort task prep: failed[%d]!\n", rc);
1767		1820
@@ -1823,8 +1876,16 @@ hisi_sas_internal_task_abort(struct hisi_hba *hisi_hba, · 55 unmodified lines
1823	if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {	1876	if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
1824	struct hisi_sas_slot *slot = task->lldd_task;	1877	struct hisi_sas_slot *slot = task->lldd_task;
1825		1878
1826	if (slot)	1879	if (slot) {
		1880	struct hisi_sas_cq *cq =
		1881	&hisi_hba->cq[slot->dlvry_queue];
		1882	/*
		1883	* flush tasklet to avoid free'ing task
		1884	* before using task in IO completion
		1885	*/
		1886	tasklet_kill(&cq->tasklet);
1827	slot->task = NULL;	1887	slot->task = NULL;
		1888	}
1828	dev_err(dev, "internal task abort: timeout and not done.\n");	1889	dev_err(dev, "internal task abort: timeout and not done.\n");
1829	res = -EIO;	1890	res = -EIO;
1830	goto exit;	1891	goto exit;
@@ -1861,10 +1922,6 @@ static void hisi_sas_port_formed(struct asd_sas_phy *sas_phy) · 30 unmodified lines
1861	hisi_sas_port_notify_formed(sas_phy);	1922	hisi_sas_port_notify_formed(sas_phy);
1862	}	1923	}
1863		1924
1864	static void hisi_sas_port_deformed(struct asd_sas_phy *sas_phy)
1865	{
1866	}
1867
1868	static int hisi_sas_write_gpio(struct sas_ha_struct *sha, u8 reg_type,	1925	static int hisi_sas_write_gpio(struct sas_ha_struct *sha, u8 reg_type,
1869	u8 reg_index, u8 reg_count, u8 *write_data)	1926	u8 reg_index, u8 reg_count, u8 *write_data)
1870	{	1927	{
@@ -1954,10 +2011,9 @@ static struct sas_domain_function_template hisi_sas_transport_ops = { · 83 unmodified lines
1954	.lldd_I_T_nexus_reset = hisi_sas_I_T_nexus_reset,	2011	.lldd_I_T_nexus_reset = hisi_sas_I_T_nexus_reset,
1955	.lldd_lu_reset = hisi_sas_lu_reset,	2012	.lldd_lu_reset = hisi_sas_lu_reset,
1956	.lldd_query_task = hisi_sas_query_task,	2013	.lldd_query_task = hisi_sas_query_task,
1957	.lldd_clear_nexus_ha = hisi_sas_clear_nexus_ha,	2014	.lldd_clear_nexus_ha = hisi_sas_clear_nexus_ha,
1958	.lldd_port_formed = hisi_sas_port_formed,	2015	.lldd_port_formed = hisi_sas_port_formed,
1959	.lldd_port_deformed = hisi_sas_port_deformed,	2016	.lldd_write_gpio = hisi_sas_write_gpio,
1960	.lldd_write_gpio = hisi_sas_write_gpio,
1961	};	2017	};
1962		2018
1963	void hisi_sas_init_mem(struct hisi_hba *hisi_hba)	2019	void hisi_sas_init_mem(struct hisi_hba *hisi_hba)
@@ -2120,6 +2176,8 @@ int hisi_sas_alloc(struct hisi_hba hisi_hba, struct Scsi_Host shost) · 156 unmodified lines
2120	hisi_sas_init_mem(hisi_hba);	2176	hisi_sas_init_mem(hisi_hba);
2121		2177
2122	hisi_sas_slot_index_init(hisi_hba);	2178	hisi_sas_slot_index_init(hisi_hba);
		2179	hisi_hba->last_slot_index = hisi_hba->hw->max_command_entries -
		2180	HISI_SAS_RESERVED_IPTT_CNT;
2123		2181
2124	hisi_hba->wq = create_singlethread_workqueue(dev_name(dev));	2182	hisi_hba->wq = create_singlethread_workqueue(dev_name(dev));
2125	if (!hisi_hba->wq) {	2183	if (!hisi_hba->wq) {
@@ -2323,8 +2381,15 @@ int hisi_sas_probe(struct platform_device *pdev, · 197 unmodified lines
2323	shost->max_channel = 1;	2381	shost->max_channel = 1;
2324	shost->max_cmd_len = 16;	2382	shost->max_cmd_len = 16;
2325	shost->sg_tablesize = min_t(u16, SG_ALL, HISI_SAS_SGE_PAGE_CNT);	2383	shost->sg_tablesize = min_t(u16, SG_ALL, HISI_SAS_SGE_PAGE_CNT);
2326	shost->can_queue = hisi_hba->hw->max_command_entries;	2384	if (hisi_hba->hw->slot_index_alloc) {
2327	shost->cmd_per_lun = hisi_hba->hw->max_command_entries;	2385	shost->can_queue = hisi_hba->hw->max_command_entries;
		2386	shost->cmd_per_lun = hisi_hba->hw->max_command_entries;
		2387	} else {
		2388	shost->can_queue = hisi_hba->hw->max_command_entries -
		2389	HISI_SAS_RESERVED_IPTT_CNT;
		2390	shost->cmd_per_lun = hisi_hba->hw->max_command_entries -
		2391	HISI_SAS_RESERVED_IPTT_CNT;
		2392	}
2328		2393
2329	sha->sas_ha_name = DRV_NAME;	2394	sha->sas_ha_name = DRV_NAME;
2330	sha->dev = hisi_hba->dev;	2395	sha->dev = hisi_hba->dev;

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

@@ -1809,7 +1809,6 @@ static struct scsi_host_template sht_v1_hw = { · 1808 unmodified lines
1809	.scan_start = hisi_sas_scan_start,	1809	.scan_start = hisi_sas_scan_start,
1810	.change_queue_depth = sas_change_queue_depth,	1810	.change_queue_depth = sas_change_queue_depth,
1811	.bios_param = sas_bios_param,	1811	.bios_param = sas_bios_param,
1812	.can_queue = 1,
1813	.this_id = -1,	1812	.this_id = -1,
1814	.sg_tablesize = SG_ALL,	1813	.sg_tablesize = SG_ALL,
1815	.max_sectors = SCSI_DEFAULT_MAX_SECTORS,	1814	.max_sectors = SCSI_DEFAULT_MAX_SECTORS,

drivers/scsi/hisi_sas/hisi_sas_v2_hw.c+9−6

 /* This function needs to be protected from pre-emption. */
 static int
-slot_index_alloc_quirk_v2_hw(struct hisi_hba *hisi_hba, int *slot_idx,
+slot_index_alloc_quirk_v2_hw(struct hisi_hba *hisi_hba,
 			     struct domain_device *device)
 {
 	int sata_dev = dev_is_sata(device);
 	struct hisi_sas_device *sas_dev = device->lldd_dev;
 	int sata_idx = sas_dev->sata_idx;
 	int start, end;
+	unsigned long flags;
 	if (!sata_dev) {
 		/*
 		end = 64 * (sata_idx + 2);
 	}
+	spin_lock_irqsave(&hisi_hba->lock, flags);
 	while (1) {
 		start = find_next_zero_bit(bitmap,
 					hisi_hba->slot_index_count, start);
-		if (start >= end)
+		if (start >= end) {
+			spin_unlock_irqrestore(&hisi_hba->lock, flags);
 			return -SAS_QUEUE_FULL;
+		}
 		/*
 		  * SAS IPTT bit0 should be 1, and SATA IPTT bit0 should be 0.
 		  */
 	}
 	set_bit(start, bitmap);
-	*slot_idx = start;
+	spin_unlock_irqrestore(&hisi_hba->lock, flags);
-	return 0;
+	return start;
 }
 static bool sata_index_alloc_v2_hw(struct hisi_hba *hisi_hba, int *idx)
 	}
 out:
-	hisi_sas_slot_task_free(hisi_hba, task, slot);
 	sts = ts->stat;
 	spin_lock_irqsave(&task->task_state_lock, flags);
 	if (task->task_state_flags & SAS_TASK_STATE_ABORTED) {
 	}
 	task->task_state_flags |= SAS_TASK_STATE_DONE;
 	spin_unlock_irqrestore(&task->task_state_lock, flags);
+	hisi_sas_slot_task_free(hisi_hba, task, slot);
 	if (!is_internal && (task->task_proto != SAS_PROTOCOL_SMP)) {
 		spin_lock_irqsave(&device->done_lock, flags);
 	.scan_start		= hisi_sas_scan_start,
 	.change_queue_depth	= sas_change_queue_depth,
 	.bios_param		= sas_bios_param,
-	.can_queue		= 1,
 	.this_id		= -1,
 	.sg_tablesize		= SG_ALL,
 	.max_sectors		= SCSI_DEFAULT_MAX_SECTORS,

drivers/scsi/hisi_sas/hisi_sas_v3_hw.c+10−5

 #define PHY_CTRL_RESET_OFF		0
 #define PHY_CTRL_RESET_MSK		(0x1 << PHY_CTRL_RESET_OFF)
 #define SL_CFG				(PORT_BASE + 0x84)
+#define AIP_LIMIT			(PORT_BASE + 0x90)
 #define SL_CONTROL			(PORT_BASE + 0x94)
 #define SL_CONTROL_NOTIFY_EN_OFF	0
 #define SL_CONTROL_NOTIFY_EN_MSK	(0x1 << SL_CONTROL_NOTIFY_EN_OFF)
 			 (u32)((1ULL << hisi_hba->queue_count) - 1));
 	hisi_sas_write32(hisi_hba, CFG_MAX_TAG, 0xfff0400);
 	hisi_sas_write32(hisi_hba, HGC_SAS_TXFAIL_RETRY_CTRL, 0x108);
+	hisi_sas_write32(hisi_hba, CFG_AGING_TIME, 0x1);
 	hisi_sas_write32(hisi_hba, INT_COAL_EN, 0x1);
 	hisi_sas_write32(hisi_hba, OQ_INT_COAL_TIME, 0x1);
 	hisi_sas_write32(hisi_hba, OQ_INT_COAL_CNT, 0x1);
 	hisi_sas_write32(hisi_hba, ENT_INT_SRC_MSK1, 0xfefefefe);
 	hisi_sas_write32(hisi_hba, ENT_INT_SRC_MSK2, 0xfefefefe);
 	if (pdev->revision >= 0x21)
-		hisi_sas_write32(hisi_hba, ENT_INT_SRC_MSK3, 0xffff7fff);
+		hisi_sas_write32(hisi_hba, ENT_INT_SRC_MSK3, 0xffff7aff);
 	else
 		hisi_sas_write32(hisi_hba, ENT_INT_SRC_MSK3, 0xfffe20ff);
 	hisi_sas_write32(hisi_hba, CHNL_PHYUPDOWN_INT_MSK, 0x0);
 		/* used for 12G negotiate */
 		hisi_sas_phy_write32(hisi_hba, i, COARSETUNE_TIME, 0x1e);
+		hisi_sas_phy_write32(hisi_hba, i, AIP_LIMIT, 0x2ffff);
 	}
 	for (i = 0; i < hisi_hba->queue_count; i++) {
 	}
 out:
-	hisi_sas_slot_task_free(hisi_hba, task, slot);
 	sts = ts->stat;
 	spin_lock_irqsave(&task->task_state_lock, flags);
 	if (task->task_state_flags & SAS_TASK_STATE_ABORTED) {
 	}
 	task->task_state_flags |= SAS_TASK_STATE_DONE;
 	spin_unlock_irqrestore(&task->task_state_lock, flags);
+	hisi_sas_slot_task_free(hisi_hba, task, slot);
 	if (!is_internal && (task->task_proto != SAS_PROTOCOL_SMP)) {
 		spin_lock_irqsave(&device->done_lock, flags);
 	.scan_start		= hisi_sas_scan_start,
 	.change_queue_depth	= sas_change_queue_depth,
 	.bios_param		= sas_bios_param,
-	.can_queue		= 1,
 	.this_id		= -1,
 	.sg_tablesize		= SG_ALL,
 	.max_sectors		= SCSI_DEFAULT_MAX_SECTORS,
 	.target_destroy		= sas_target_destroy,
 	.ioctl			= sas_ioctl,
 	.shost_attrs		= host_attrs,
+	.tag_alloc_policy	= BLK_TAG_ALLOC_RR,
 };
 static const struct hisi_sas_hw hisi_sas_v3_hw = {
 	shost->max_channel = 1;
 	shost->max_cmd_len = 16;
 	shost->sg_tablesize = min_t(u16, SG_ALL, HISI_SAS_SGE_PAGE_CNT);
-	shost->can_queue = hisi_hba->hw->max_command_entries;
+	shost->can_queue = hisi_hba->hw->max_command_entries -
-	shost->cmd_per_lun = hisi_hba->hw->max_command_entries;
+		HISI_SAS_RESERVED_IPTT_CNT;
+	shost->cmd_per_lun = hisi_hba->hw->max_command_entries -
+		HISI_SAS_RESERVED_IPTT_CNT;
 	sha->sas_ha_name = DRV_NAME;
 	sha->dev = dev;

drivers/scsi/hpsa.c+73−75

 	chain_block = h->ioaccel2_cmd_sg_list[c->cmdindex];
 	chain_size = le32_to_cpu(cp->sg[0].length);
-	temp64 = pci_map_single(h->pdev, chain_block, chain_size,
+	temp64 = dma_map_single(&h->pdev->dev, chain_block, chain_size,
-				PCI_DMA_TODEVICE);
+				DMA_TO_DEVICE);
 	if (dma_mapping_error(&h->pdev->dev, temp64)) {
 		/* prevent subsequent unmapping */
 		cp->sg->address = 0;
 	chain_sg = cp->sg;
 	temp64 = le64_to_cpu(chain_sg->address);
 	chain_size = le32_to_cpu(cp->sg[0].length);
-	pci_unmap_single(h->pdev, temp64, chain_size, PCI_DMA_TODEVICE);
+	dma_unmap_single(&h->pdev->dev, temp64, chain_size, DMA_TO_DEVICE);
 }
 static int hpsa_map_sg_chain_block(struct ctlr_info *h,
 	chain_len = sizeof(*chain_sg) *
 		(le16_to_cpu(c->Header.SGTotal) - h->max_cmd_sg_entries);
 	chain_sg->Len = cpu_to_le32(chain_len);
-	temp64 = pci_map_single(h->pdev, chain_block, chain_len,
+	temp64 = dma_map_single(&h->pdev->dev, chain_block, chain_len,
-				PCI_DMA_TODEVICE);
+				DMA_TO_DEVICE);
 	if (dma_mapping_error(&h->pdev->dev, temp64)) {
 		/* prevent subsequent unmapping */
 		chain_sg->Addr = cpu_to_le64(0);
 		return;
 	chain_sg = &c->SG[h->max_cmd_sg_entries - 1];
-	pci_unmap_single(h->pdev, le64_to_cpu(chain_sg->Addr),
+	dma_unmap_single(&h->pdev->dev, le64_to_cpu(chain_sg->Addr),
-			le32_to_cpu(chain_sg->Len), PCI_DMA_TODEVICE);
+			le32_to_cpu(chain_sg->Len), DMA_TO_DEVICE);
 }
 	return hpsa_cmd_free_and_done(h, cp, cmd);
 }
-static void hpsa_pci_unmap(struct pci_dev *pdev,
+static void hpsa_pci_unmap(struct pci_dev *pdev, struct CommandList *c,
-	struct CommandList *c, int sg_used, int data_direction)
+		int sg_used, enum dma_data_direction data_direction)
 {
 	int i;
 	for (i = 0; i < sg_used; i++)
-		pci_unmap_single(pdev, (dma_addr_t) le64_to_cpu(c->SG[i].Addr),
+		dma_unmap_single(&pdev->dev, le64_to_cpu(c->SG[i].Addr),
 				le32_to_cpu(c->SG[i].Len),
 				data_direction);
 }
 		struct CommandList *cp,
 		unsigned char *buf,
 		size_t buflen,
-		int data_direction)
+		enum dma_data_direction data_direction)
 {
 	u64 addr64;
-	if (buflen == 0 || data_direction == PCI_DMA_NONE) {
+	if (buflen == 0 || data_direction == DMA_NONE) {
 		cp->Header.SGList = 0;
 		cp->Header.SGTotal = cpu_to_le16(0);
 		return 0;
 	}
-	addr64 = pci_map_single(pdev, buf, buflen, data_direction);
+	addr64 = dma_map_single(&pdev->dev, buf, buflen, data_direction);
 	if (dma_mapping_error(&pdev->dev, addr64)) {
 		/* Prevent subsequent unmap of something never mapped */
 		cp->Header.SGList = 0;
 #define MAX_DRIVER_CMD_RETRIES 25
 static int hpsa_scsi_do_simple_cmd_with_retry(struct ctlr_info *h,
-	struct CommandList *c, int data_direction, unsigned long timeout_msecs)
+		struct CommandList *c, enum dma_data_direction data_direction,
+		unsigned long timeout_msecs)
 {
 	int backoff_time = 10, retry_count = 0;
 	int rc;
 		rc = -1;
 		goto out;
 	}
-	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c,
+	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c, DMA_FROM_DEVICE,
-		PCI_DMA_FROMDEVICE, NO_TIMEOUT);
+			NO_TIMEOUT);
 	if (rc)
 		goto out;
 	ei = c->err_info;
 		rc = -1;
 		goto out;
 	}
-	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c,
+	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c, DMA_FROM_DEVICE,
-					PCI_DMA_FROMDEVICE, NO_TIMEOUT);
+			NO_TIMEOUT);
 	if (rc)
 		goto out;
 	ei = c->err_info;
 		cmd_free(h, c);
 		return -1;
 	}
-	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c,
+	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c, DMA_FROM_DEVICE,
-					PCI_DMA_FROMDEVICE, NO_TIMEOUT);
+			NO_TIMEOUT);
 	if (rc)
 		goto out;
 	ei = c->err_info;
 	c->Request.CDB[2] = bmic_device_index & 0xff;
 	c->Request.CDB[9] = (bmic_device_index >> 8) & 0xff;
-	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c,
+	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c, DMA_FROM_DEVICE,
-				PCI_DMA_FROMDEVICE, NO_TIMEOUT);
+			NO_TIMEOUT);
 	if (rc)
 		goto out;
 	ei = c->err_info;
 	if (rc)
 		goto out;
-	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c,
+	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c, DMA_FROM_DEVICE,
-		PCI_DMA_FROMDEVICE, NO_TIMEOUT);
+			NO_TIMEOUT);
 	if (rc)
 		goto out;
 	ei = c->err_info;
 	c->Request.CDB[2] = bmic_device_index & 0xff;
 	c->Request.CDB[9] = (bmic_device_index >> 8) & 0xff;
-	hpsa_scsi_do_simple_cmd_with_retry(h, c, PCI_DMA_FROMDEVICE,
+	hpsa_scsi_do_simple_cmd_with_retry(h, c, DMA_FROM_DEVICE,
 						NO_TIMEOUT);
 	ei = c->err_info;
 	if (ei->CommandStatus != 0 && ei->CommandStatus != CMD_DATA_UNDERRUN) {
 	else
 		c->Request.CDB[5] = 0;
-	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c, PCI_DMA_FROMDEVICE,
+	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c, DMA_FROM_DEVICE,
 						NO_TIMEOUT);
 	if (rc)
 		goto out;
 	}
 	if (extended_response)
 		c->Request.CDB[1] = extended_response;
-	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c,
+	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c, DMA_FROM_DEVICE,
-					PCI_DMA_FROMDEVICE, NO_TIMEOUT);
+			NO_TIMEOUT);
 	if (rc)
 		goto out;
 	ei = c->err_info;
 	/* Fill in the scatter gather information */
 	if (iocommand.buf_size > 0) {
-		temp64 = pci_map_single(h->pdev, buff,
+		temp64 = dma_map_single(&h->pdev->dev, buff,
-			iocommand.buf_size, PCI_DMA_BIDIRECTIONAL);
+			iocommand.buf_size, DMA_BIDIRECTIONAL);
 		if (dma_mapping_error(&h->pdev->dev, (dma_addr_t) temp64)) {
 			c->SG[0].Addr = cpu_to_le64(0);
 			c->SG[0].Len = cpu_to_le32(0);
 	rc = hpsa_scsi_do_simple_cmd(h, c, DEFAULT_REPLY_QUEUE,
 					NO_TIMEOUT);
 	if (iocommand.buf_size > 0)
-		hpsa_pci_unmap(h->pdev, c, 1, PCI_DMA_BIDIRECTIONAL);
+		hpsa_pci_unmap(h->pdev, c, 1, DMA_BIDIRECTIONAL);
 	check_ioctl_unit_attention(h, c);
 	if (rc) {
 		rc = -EIO;
 		return -EINVAL;
 	if (!capable(CAP_SYS_RAWIO))
 		return -EPERM;
-	ioc = kmalloc(sizeof(*ioc), GFP_KERNEL);
+	ioc = vmemdup_user(argp, sizeof(*ioc));
-	if (!ioc) {
+	if (IS_ERR(ioc)) {
-		status = -ENOMEM;
+		status = PTR_ERR(ioc);
-		goto cleanup1;
-	}
-	if (copy_from_user(ioc, argp, sizeof(*ioc))) {
-		status = -EFAULT;
 		goto cleanup1;
 	}
 	if ((ioc->buf_size < 1) &&
 	if (ioc->buf_size > 0) {
 		int i;
 		for (i = 0; i < sg_used; i++) {
-			temp64 = pci_map_single(h->pdev, buff[i],
+			temp64 = dma_map_single(&h->pdev->dev, buff[i],
-				    buff_size[i], PCI_DMA_BIDIRECTIONAL);
+				    buff_size[i], DMA_BIDIRECTIONAL);
 			if (dma_mapping_error(&h->pdev->dev,
 							(dma_addr_t) temp64)) {
 				c->SG[i].Addr = cpu_to_le64(0);
 				c->SG[i].Len = cpu_to_le32(0);
 				hpsa_pci_unmap(h->pdev, c, i,
-					PCI_DMA_BIDIRECTIONAL);
+					DMA_BIDIRECTIONAL);
 				status = -ENOMEM;
 				goto cleanup0;
 			}
 	status = hpsa_scsi_do_simple_cmd(h, c, DEFAULT_REPLY_QUEUE,
 						NO_TIMEOUT);
 	if (sg_used)
-		hpsa_pci_unmap(h->pdev, c, sg_used, PCI_DMA_BIDIRECTIONAL);
+		hpsa_pci_unmap(h->pdev, c, sg_used, DMA_BIDIRECTIONAL);
 	check_ioctl_unit_attention(h, c);
 	if (status) {
 		status = -EIO;
 		kfree(buff);
 	}
 	kfree(buff_size);
-	kfree(ioc);
+	kvfree(ioc);
 	return status;
 }
 	void *buff, size_t size, u16 page_code, unsigned char *scsi3addr,
 	int cmd_type)
 {
-	int pci_dir = XFER_NONE;
+	enum dma_data_direction dir = DMA_NONE;
 	c->cmd_type = CMD_IOCTL_PEND;
 	c->scsi_cmd = SCSI_CMD_BUSY;
 	switch (GET_DIR(c->Request.type_attr_dir)) {
 	case XFER_READ:
-		pci_dir = PCI_DMA_FROMDEVICE;
+		dir = DMA_FROM_DEVICE;
 		break;
 	case XFER_WRITE:
-		pci_dir = PCI_DMA_TODEVICE;
+		dir = DMA_TO_DEVICE;
 		break;
 	case XFER_NONE:
-		pci_dir = PCI_DMA_NONE;
+		dir = DMA_NONE;
 		break;
 	default:
-		pci_dir = PCI_DMA_BIDIRECTIONAL;
+		dir = DMA_BIDIRECTIONAL;
 	}
-	if (hpsa_map_one(h->pdev, c, buff, size, pci_dir))
+	if (hpsa_map_one(h->pdev, c, buff, size, dir))
 		return -1;
 	return 0;
 }
 	 * CCISS commands, so they must be allocated from the lower 4GiB of
 	 * memory.
 	 */
-	err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+	err = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
 	if (err) {
 		iounmap(vaddr);
 		return err;
 	}
-	cmd = pci_alloc_consistent(pdev, cmd_sz, &paddr64);
+	cmd = dma_alloc_coherent(&pdev->dev, cmd_sz, &paddr64, GFP_KERNEL);
 	if (cmd == NULL) {
 		iounmap(vaddr);
 		return -ENOMEM;
 		return -ETIMEDOUT;
 	}
-	pci_free_consistent(pdev, cmd_sz, cmd, paddr64);
+	dma_free_coherent(&pdev->dev, cmd_sz, cmd, paddr64);
 	if (tag & HPSA_ERROR_BIT) {
 		dev_err(&pdev->dev, "controller message %02x:%02x failed\n",
 	kfree(h->cmd_pool_bits);
 	h->cmd_pool_bits = NULL;
 	if (h->cmd_pool) {
-		pci_free_consistent(h->pdev,
+		dma_free_coherent(&h->pdev->dev,
 				h->nr_cmds * sizeof(struct CommandList),
 				h->cmd_pool,
 				h->cmd_pool_dhandle);
 		h->cmd_pool_dhandle = 0;
 	}
 	if (h->errinfo_pool) {
-		pci_free_consistent(h->pdev,
+		dma_free_coherent(&h->pdev->dev,
 				h->nr_cmds * sizeof(struct ErrorInfo),
 				h->errinfo_pool,
 				h->errinfo_pool_dhandle);
 	h->cmd_pool_bits = kcalloc(DIV_ROUND_UP(h->nr_cmds, BITS_PER_LONG),
 				   sizeof(unsigned long),
 				   GFP_KERNEL);
-	h->cmd_pool = pci_alloc_consistent(h->pdev,
+	h->cmd_pool = dma_alloc_coherent(&h->pdev->dev,
 		    h->nr_cmds * sizeof(*h->cmd_pool),
-		    &(h->cmd_pool_dhandle));
+		    &h->cmd_pool_dhandle, GFP_KERNEL);
-	h->errinfo_pool = pci_alloc_consistent(h->pdev,
+	h->errinfo_pool = dma_alloc_coherent(&h->pdev->dev,
 		    h->nr_cmds * sizeof(*h->errinfo_pool),
-		    &(h->errinfo_pool_dhandle));
+		    &h->errinfo_pool_dhandle, GFP_KERNEL);
 	if ((h->cmd_pool_bits == NULL)
 	    || (h->cmd_pool == NULL)
 	    || (h->errinfo_pool == NULL)) {
 	for (i = 0; i < h->nreply_queues; i++) {
 		if (!h->reply_queue[i].head)
 			continue;
-		pci_free_consistent(h->pdev,
+		dma_free_coherent(&h->pdev->dev,
 					h->reply_queue_size,
 					h->reply_queue[i].head,
 					h->reply_queue[i].busaddr);
 	number_of_controllers++;
 	/* configure PCI DMA stuff */
-	rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
+	rc = dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
 	if (rc == 0) {
 		dac = 1;
 	} else {
-		rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+		rc = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
 		if (rc == 0) {
 			dac = 0;
 		} else {
 		RAID_CTLR_LUNID, TYPE_CMD)) {
 		goto out;
 	}
-	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c,
+	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c, DMA_TO_DEVICE,
-					PCI_DMA_TODEVICE, DEFAULT_TIMEOUT);
+			DEFAULT_TIMEOUT);
 	if (rc)
 		goto out;
 	if (c->err_info->CommandStatus != 0)
 		RAID_CTLR_LUNID, TYPE_CMD))
 		goto errout;
-	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c,
+	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c, DMA_FROM_DEVICE,
-		PCI_DMA_FROMDEVICE, NO_TIMEOUT);
+			NO_TIMEOUT);
 	if ((rc != 0) || (c->err_info->CommandStatus != 0))
 		goto errout;
 		RAID_CTLR_LUNID, TYPE_CMD))
 		goto errout;
-	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c,
+	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c, DMA_TO_DEVICE,
-		PCI_DMA_TODEVICE, NO_TIMEOUT);
+			NO_TIMEOUT);
 	if ((rc != 0)  || (c->err_info->CommandStatus != 0))
 		goto errout;
 		RAID_CTLR_LUNID, TYPE_CMD))
 		goto errout;
-	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c,
+	rc = hpsa_scsi_do_simple_cmd_with_retry(h, c, DMA_FROM_DEVICE,
-		PCI_DMA_FROMDEVICE, NO_TIMEOUT);
+			NO_TIMEOUT);
 	if ((rc != 0)  || (c->err_info->CommandStatus != 0))
 		goto errout;
 	BUILD_BUG_ON(sizeof(struct io_accel1_cmd) %
 			IOACCEL1_COMMANDLIST_ALIGNMENT);
 	h->ioaccel_cmd_pool =
-		pci_alloc_consistent(h->pdev,
+		dma_alloc_coherent(&h->pdev->dev,
 			h->nr_cmds * sizeof(*h->ioaccel_cmd_pool),
-			&(h->ioaccel_cmd_pool_dhandle));
+			&h->ioaccel_cmd_pool_dhandle, GFP_KERNEL);
 	h->ioaccel1_blockFetchTable =
 		kmalloc(((h->ioaccel_maxsg + 1) *
 	BUILD_BUG_ON(sizeof(struct io_accel2_cmd) %
 			IOACCEL2_COMMANDLIST_ALIGNMENT);
 	h->ioaccel2_cmd_pool =
-		pci_alloc_consistent(h->pdev,
+		dma_alloc_coherent(&h->pdev->dev,
 			h->nr_cmds * sizeof(*h->ioaccel2_cmd_pool),
-			&(h->ioaccel2_cmd_pool_dhandle));
+			&h->ioaccel2_cmd_pool_dhandle, GFP_KERNEL);
 	h->ioaccel2_blockFetchTable =
 		kmalloc(((h->ioaccel_maxsg + 1) *
 	h->reply_queue_size = h->max_commands * sizeof(u64);
 	for (i = 0; i < h->nreply_queues; i++) {
-		h->reply_queue[i].head = pci_alloc_consistent(h->pdev,
+		h->reply_queue[i].head = dma_alloc_coherent(&h->pdev->dev,
 						h->reply_queue_size,
-						&(h->reply_queue[i].busaddr));
+						&h->reply_queue[i].busaddr,
+						GFP_KERNEL);
 		if (!h->reply_queue[i].head) {
 			rc = -ENOMEM;
 			goto clean1;	/* rq, ioaccel */

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c+0−1

@@ -2266,7 +2266,6 @@ static int ibmvscsis_drop_nexus(struct ibmvscsis_tport *tport) · 2265 unmodified lines
2266	/*	2266	/*
2267	* Release the SCSI I_T Nexus to the emulated ibmvscsis Target Port	2267	* Release the SCSI I_T Nexus to the emulated ibmvscsis Target Port
2268	*/	2268	*/
2269	target_wait_for_sess_cmds(se_sess);
2270	target_remove_session(se_sess);	2269	target_remove_session(se_sess);
2271	tport->ibmv_nexus = NULL;	2270	tport->ibmv_nexus = NULL;
2272	kfree(nexus);	2271	kfree(nexus);

drivers/scsi/ips.c+42−39

 #define IPS_DMA_DIR(scb) ((!scb->scsi_cmd || ips_is_passthru(scb->scsi_cmd) || \
                          DMA_NONE == scb->scsi_cmd->sc_data_direction) ? \
-                         PCI_DMA_BIDIRECTIONAL : \
+                         DMA_BIDIRECTIONAL : \
                          scb->scsi_cmd->sc_data_direction)
 #ifdef IPS_DEBUG
 	if (ha->ioctl_data && length <= ha->ioctl_len)
 		return 0;
 	/* there is no buffer or it's not big enough, allocate a new one */
-	bigger_buf = pci_alloc_consistent(ha->pcidev, length, &dma_busaddr);
+	bigger_buf = dma_alloc_coherent(&ha->pcidev->dev, length, &dma_busaddr,
+			GFP_KERNEL);
 	if (bigger_buf) {
 		/* free the old memory */
-		pci_free_consistent(ha->pcidev, ha->ioctl_len, ha->ioctl_data,
+		dma_free_coherent(&ha->pcidev->dev, ha->ioctl_len,
-				    ha->ioctl_busaddr);
+				  ha->ioctl_data, ha->ioctl_busaddr);
 		/* use the new memory */
 		ha->ioctl_data = (char *) bigger_buf;
 		ha->ioctl_len = length;
 		} else if (!ha->flash_data) {
 			datasize = pt->CoppCP.cmd.flashfw.total_packets *
 			    pt->CoppCP.cmd.flashfw.count;
-			ha->flash_data = pci_alloc_consistent(ha->pcidev,
+			ha->flash_data = dma_alloc_coherent(&ha->pcidev->dev,
-					                      datasize,
+					datasize, &ha->flash_busaddr, GFP_KERNEL);
-							      &ha->flash_busaddr);
 			if (!ha->flash_data){
 				printk(KERN_WARNING "Unable to allocate a flash buffer\n");
 				return IPS_FAILURE;
 	scb->data_len = ha->flash_datasize;
 	scb->data_busaddr =
-	    pci_map_single(ha->pcidev, ha->flash_data, scb->data_len,
+	    dma_map_single(&ha->pcidev->dev, ha->flash_data, scb->data_len,
 			   IPS_DMA_DIR(scb));
 	scb->flags |= IPS_SCB_MAP_SINGLE;
 	scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
 	if (ha->flash_data == ips_FlashData)
 		test_and_clear_bit(0, &ips_FlashDataInUse);
 	else if (ha->flash_data)
-		pci_free_consistent(ha->pcidev, ha->flash_len, ha->flash_data,
+		dma_free_coherent(&ha->pcidev->dev, ha->flash_len,
-				    ha->flash_busaddr);
+				  ha->flash_data, ha->flash_busaddr);
 	ha->flash_data = NULL;
 }
 		case START_STOP:
 			scb->scsi_cmd->result = DID_OK << 16;
+			break;
 		case TEST_UNIT_READY:
 		case INQUIRY:
 	if (ha) {
 		if (ha->enq) {
-			pci_free_consistent(ha->pcidev, sizeof(IPS_ENQ),
+			dma_free_coherent(&ha->pcidev->dev, sizeof(IPS_ENQ),
 					    ha->enq, ha->enq_busaddr);
 			ha->enq = NULL;
 		}
 		ha->conf = NULL;
 		if (ha->adapt) {
-			pci_free_consistent(ha->pcidev,
+			dma_free_coherent(&ha->pcidev->dev,
 					    sizeof (IPS_ADAPTER) +
 					    sizeof (IPS_IO_CMD), ha->adapt,
 					    ha->adapt->hw_status_start);
 		}
 		if (ha->logical_drive_info) {
-			pci_free_consistent(ha->pcidev,
+			dma_free_coherent(&ha->pcidev->dev,
 					    sizeof (IPS_LD_INFO),
 					    ha->logical_drive_info,
 					    ha->logical_drive_info_dma_addr);
 		ha->subsys = NULL;
 		if (ha->ioctl_data) {
-			pci_free_consistent(ha->pcidev, ha->ioctl_len,
+			dma_free_coherent(&ha->pcidev->dev, ha->ioctl_len,
 					    ha->ioctl_data, ha->ioctl_busaddr);
 			ha->ioctl_data = NULL;
 			ha->ioctl_datasize = 0;
 ips_deallocatescbs(ips_ha_t * ha, int cmds)
 {
 	if (ha->scbs) {
-		pci_free_consistent(ha->pcidev,
+		dma_free_coherent(&ha->pcidev->dev,
 				    IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * cmds,
 				    ha->scbs->sg_list.list,
 				    ha->scbs->sg_busaddr);
-		pci_free_consistent(ha->pcidev, sizeof (ips_scb_t) * cmds,
+		dma_free_coherent(&ha->pcidev->dev, sizeof (ips_scb_t) * cmds,
 				    ha->scbs, ha->scbs->scb_busaddr);
 		ha->scbs = NULL;
 	}			/* end if */
 	METHOD_TRACE("ips_allocatescbs", 1);
 	/* Allocate memory for the SCBs */
-	ha->scbs =
+	ha->scbs = dma_alloc_coherent(&ha->pcidev->dev,
-	    pci_alloc_consistent(ha->pcidev, ha->max_cmds * sizeof (ips_scb_t),
+			ha->max_cmds * sizeof (ips_scb_t),
-				 &command_dma);
+			&command_dma, GFP_KERNEL);
 	if (ha->scbs == NULL)
 		return 0;
-	ips_sg.list =
+	ips_sg.list = dma_alloc_coherent(&ha->pcidev->dev,
-	    pci_alloc_consistent(ha->pcidev,
+			IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * ha->max_cmds,
-				 IPS_SGLIST_SIZE(ha) * IPS_MAX_SG *
+			&sg_dma, GFP_KERNEL);
-				 ha->max_cmds, &sg_dma);
 	if (ips_sg.list == NULL) {
-		pci_free_consistent(ha->pcidev,
+		dma_free_coherent(&ha->pcidev->dev,
 				    ha->max_cmds * sizeof (ips_scb_t), ha->scbs,
 				    command_dma);
 		return 0;
 	if (scb->flags & IPS_SCB_MAP_SG)
                 scsi_dma_unmap(scb->scsi_cmd);
 	else if (scb->flags & IPS_SCB_MAP_SINGLE)
-		pci_unmap_single(ha->pcidev, scb->data_busaddr, scb->data_len,
+		dma_unmap_single(&ha->pcidev->dev, scb->data_busaddr,
-				 IPS_DMA_DIR(scb));
+				 scb->data_len, IPS_DMA_DIR(scb));
 	/* check to make sure this is not our "special" scb */
 	if (IPS_COMMAND_ID(ha, scb) < (ha->max_cmds - 1)) {
 	dma_addr_t command_dma;
 	/* Create a usuable SCB */
-	scb = pci_alloc_consistent(ha->pcidev, sizeof(ips_scb_t), &command_dma);
+	scb = dma_alloc_coherent(&ha->pcidev->dev, sizeof(ips_scb_t),
+			&command_dma, GFP_KERNEL);
 	if (scb) {
 	    memset(scb, 0, sizeof(ips_scb_t));
 	    ips_init_scb(ha, scb);
 	/* Now RESET and INIT the adapter */
 	(*ha->func.reset) (ha);
-	pci_free_consistent(ha->pcidev, sizeof(ips_scb_t), scb, command_dma);
+	dma_free_coherent(&ha->pcidev->dev, sizeof(ips_scb_t), scb, command_dma);
 	return;
 }
 	 * are guaranteed to be < 4G.
 	 */
 	if (IPS_ENABLE_DMA64 && IPS_HAS_ENH_SGLIST(ha) &&
-	    !pci_set_dma_mask(ha->pcidev, DMA_BIT_MASK(64))) {
+	    !dma_set_mask(&ha->pcidev->dev, DMA_BIT_MASK(64))) {
 		(ha)->flags |= IPS_HA_ENH_SG;
 	} else {
-		if (pci_set_dma_mask(ha->pcidev, DMA_BIT_MASK(32)) != 0) {
+		if (dma_set_mask(&ha->pcidev->dev, DMA_BIT_MASK(32)) != 0) {
 			printk(KERN_WARNING "Unable to set DMA Mask\n");
 			return ips_abort_init(ha, index);
 		}
 	}
 	if(ips_cd_boot && !ips_FlashData){
-		ips_FlashData = pci_alloc_consistent(pci_dev, PAGE_SIZE << 7,
+		ips_FlashData = dma_alloc_coherent(&pci_dev->dev,
-						     &ips_flashbusaddr);
+				PAGE_SIZE << 7, &ips_flashbusaddr, GFP_KERNEL);
 	}
-	ha->enq = pci_alloc_consistent(pci_dev, sizeof (IPS_ENQ),
+	ha->enq = dma_alloc_coherent(&pci_dev->dev, sizeof (IPS_ENQ),
-				       &ha->enq_busaddr);
+			&ha->enq_busaddr, GFP_KERNEL);
 	if (!ha->enq) {
 		IPS_PRINTK(KERN_WARNING, pci_dev,
 			   "Unable to allocate host inquiry structure\n");
 		return ips_abort_init(ha, index);
 	}
-	ha->adapt = pci_alloc_consistent(pci_dev, sizeof (IPS_ADAPTER) +
+	ha->adapt = dma_alloc_coherent(&pci_dev->dev,
-					 sizeof (IPS_IO_CMD), &dma_address);
+			sizeof (IPS_ADAPTER) + sizeof (IPS_IO_CMD),
+			&dma_address, GFP_KERNEL);
 	if (!ha->adapt) {
 		IPS_PRINTK(KERN_WARNING, pci_dev,
 			   "Unable to allocate host adapt & dummy structures\n");
-	ha->logical_drive_info = pci_alloc_consistent(pci_dev, sizeof (IPS_LD_INFO), &dma_address);
+	ha->logical_drive_info = dma_alloc_coherent(&pci_dev->dev,
+			sizeof (IPS_LD_INFO), &dma_address, GFP_KERNEL);
 	if (!ha->logical_drive_info) {
 		IPS_PRINTK(KERN_WARNING, pci_dev,
 			   "Unable to allocate logical drive info structure\n");
 	if (ips_ioctlsize < PAGE_SIZE)
 		ips_ioctlsize = PAGE_SIZE;
-	ha->ioctl_data = pci_alloc_consistent(pci_dev, ips_ioctlsize,
+	ha->ioctl_data = dma_alloc_coherent(&pci_dev->dev, ips_ioctlsize,
-					      &ha->ioctl_busaddr);
+			&ha->ioctl_busaddr, GFP_KERNEL);
 	ha->ioctl_len = ips_ioctlsize;
 	if (!ha->ioctl_data) {
 		IPS_PRINTK(KERN_WARNING, pci_dev,

drivers/scsi/isci/host.c+4−4

@@ -2717,9 +2717,9 @@ enum sci_status sci_controller_continue_io(struct isci_request *ireq) · 2716 unmodified lines
2717	* the task management request.	2717	* the task management request.
2718	* @task_request: the handle to the task request object to start.	2718	* @task_request: the handle to the task request object to start.
2719	*/	2719	*/
2720	enum sci_task_status sci_controller_start_task(struct isci_host *ihost,	2720	enum sci_status sci_controller_start_task(struct isci_host *ihost,
2721	struct isci_remote_device *idev,	2721	struct isci_remote_device *idev,
2722	struct isci_request *ireq)	2722	struct isci_request *ireq)
2723	{	2723	{
2724	enum sci_status status;	2724	enum sci_status status;
2725		2725
@@ -2728,7 +2728,7 @@ enum sci_task_status sci_controller_start_task(struct isci_host *ihost, · 2 unmodified lines
2728	"%s: SCIC Controller starting task from invalid "	2728	"%s: SCIC Controller starting task from invalid "
2729	"state\n",	2729	"state\n",
2730	__func__);	2730	__func__);
2731	return SCI_TASK_FAILURE_INVALID_STATE;	2731	return SCI_FAILURE_INVALID_STATE;
2732	}	2732	}
2733		2733
2734	status = sci_remote_device_start_task(ihost, idev, ireq);	2734	status = sci_remote_device_start_task(ihost, idev, ireq);

drivers/scsi/isci/host.h+1−1

@@ -489,7 +489,7 @@ enum sci_status sci_controller_start_io( · 488 unmodified lines
489	struct isci_remote_device *idev,	489	struct isci_remote_device *idev,
490	struct isci_request *ireq);	490	struct isci_request *ireq);
491		491
492	enum sci_task_status sci_controller_start_task(	492	enum sci_status sci_controller_start_task(
493	struct isci_host *ihost,	493	struct isci_host *ihost,
494	struct isci_remote_device *idev,	494	struct isci_remote_device *idev,
495	struct isci_request *ireq);	495	struct isci_request *ireq);

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

@@ -1626,9 +1626,9 @@ static enum sci_status atapi_d2h_reg_frame_handler(struct isci_request *ireq, · 1625 unmodified lines
1626		1626
1627	if (status == SCI_SUCCESS) {	1627	if (status == SCI_SUCCESS) {
1628	if (ireq->stp.rsp.status & ATA_ERR)	1628	if (ireq->stp.rsp.status & ATA_ERR)
1629	status = SCI_IO_FAILURE_RESPONSE_VALID;	1629	status = SCI_FAILURE_IO_RESPONSE_VALID;
1630	} else {	1630	} else {
1631	status = SCI_IO_FAILURE_RESPONSE_VALID;	1631	status = SCI_FAILURE_IO_RESPONSE_VALID;
1632	}	1632	}
1633		1633
1634	if (status != SCI_SUCCESS) {	1634	if (status != SCI_SUCCESS) {

drivers/scsi/isci/task.c+2−2

@@ -258,7 +258,7 @@ static int isci_task_execute_tmf(struct isci_host *ihost, · 257 unmodified lines
258	struct isci_tmf *tmf, unsigned long timeout_ms)	258	struct isci_tmf *tmf, unsigned long timeout_ms)
259	{	259	{
260	DECLARE_COMPLETION_ONSTACK(completion);	260	DECLARE_COMPLETION_ONSTACK(completion);
261	enum sci_task_status status = SCI_TASK_FAILURE;	261	enum sci_status status = SCI_FAILURE;
262	struct isci_request *ireq;	262	struct isci_request *ireq;
263	int ret = TMF_RESP_FUNC_FAILED;	263	int ret = TMF_RESP_FUNC_FAILED;
264	unsigned long flags;	264	unsigned long flags;
@@ -301,7 +301,7 @@ static int isci_task_execute_tmf(struct isci_host *ihost, · 36 unmodified lines
301	/* start the TMF io. */	301	/* start the TMF io. */
302	status = sci_controller_start_task(ihost, idev, ireq);	302	status = sci_controller_start_task(ihost, idev, ireq);
303		303
304	if (status != SCI_TASK_SUCCESS) {	304	if (status != SCI_SUCCESS) {
305	dev_dbg(&ihost->pdev->dev,	305	dev_dbg(&ihost->pdev->dev,
306	"%s: start_io failed - status = 0x%x, request = %p\n",	306	"%s: start_io failed - status = 0x%x, request = %p\n",
307	__func__,	307	__func__,

drivers/scsi/iscsi_tcp.c+2−1

@@ -800,7 +800,8 @@ static int iscsi_sw_tcp_host_get_param(struct Scsi_Host *shost, · 799 unmodified lines
800	return rc;	800	return rc;
801		801
802	return iscsi_conn_get_addr_param((struct sockaddr_storage *)	802	return iscsi_conn_get_addr_param((struct sockaddr_storage *)
803	&addr, param, buf);	803	&addr,
		804	(enum iscsi_param)param, buf);
804	default:	805	default:
805	return iscsi_host_get_param(shost, param, buf);	806	return iscsi_host_get_param(shost, param, buf);
806	}	807	}

drivers/scsi/jazz_esp.c+1−29

@@ -38,30 +38,6 @@ static u8 jazz_esp_read8(struct esp *esp, unsigned long reg) · 37 unmodified lines
38	return (volatile u8 )(esp->regs + reg);	38	return (volatile u8 )(esp->regs + reg);
39	}	39	}
40		40
41	static dma_addr_t jazz_esp_map_single(struct esp esp, void buf,
42	size_t sz, int dir)
43	{
44	return dma_map_single(esp->dev, buf, sz, dir);
45	}
46
47	static int jazz_esp_map_sg(struct esp esp, struct scatterlist sg,
48	int num_sg, int dir)
49	{
50	return dma_map_sg(esp->dev, sg, num_sg, dir);
51	}
52
53	static void jazz_esp_unmap_single(struct esp *esp, dma_addr_t addr,
54	size_t sz, int dir)
55	{
56	dma_unmap_single(esp->dev, addr, sz, dir);
57	}
58
59	static void jazz_esp_unmap_sg(struct esp esp, struct scatterlist sg,
60	int num_sg, int dir)
61	{
62	dma_unmap_sg(esp->dev, sg, num_sg, dir);
63	}
64
65	static int jazz_esp_irq_pending(struct esp *esp)	41	static int jazz_esp_irq_pending(struct esp *esp)
66	{	42	{
67	if (jazz_esp_read8(esp, ESP_STATUS) & ESP_STAT_INTR)	43	if (jazz_esp_read8(esp, ESP_STATUS) & ESP_STAT_INTR)
@@ -117,10 +93,6 @@ static int jazz_esp_dma_error(struct esp *esp) · 49 unmodified lines
117	static const struct esp_driver_ops jazz_esp_ops = {	93	static const struct esp_driver_ops jazz_esp_ops = {
118	.esp_write8 = jazz_esp_write8,	94	.esp_write8 = jazz_esp_write8,
119	.esp_read8 = jazz_esp_read8,	95	.esp_read8 = jazz_esp_read8,
120	.map_single = jazz_esp_map_single,
121	.map_sg = jazz_esp_map_sg,
122	.unmap_single = jazz_esp_unmap_single,
123	.unmap_sg = jazz_esp_unmap_sg,
124	.irq_pending = jazz_esp_irq_pending,	96	.irq_pending = jazz_esp_irq_pending,
125	.reset_dma = jazz_esp_reset_dma,	97	.reset_dma = jazz_esp_reset_dma,
126	.dma_drain = jazz_esp_dma_drain,	98	.dma_drain = jazz_esp_dma_drain,
@@ -182,7 +154,7 @@ static int esp_jazz_probe(struct platform_device *dev) · 55 unmodified lines
182		154
183	dev_set_drvdata(&dev->dev, esp);	155	dev_set_drvdata(&dev->dev, esp);
184		156
185	err = scsi_esp_register(esp, &dev->dev);	157	err = scsi_esp_register(esp);
186	if (err)	158	if (err)
187	goto fail_free_irq;	159	goto fail_free_irq;
188		160

drivers/scsi/libfc/fc_fcp.c+1−5

 	struct fc_lport *lport = shost_priv(shost);
 	struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
 	struct fc_fcp_pkt *fsp;
-	struct fc_rport_libfc_priv *rpriv;
 	int rval;
 	int rc = 0;
 	struct fc_stats *stats;
 		goto out;
 	}
-	rpriv = rport->dd_data;
 	if (!fc_fcp_lport_queue_ready(lport)) {
 		if (lport->qfull) {
 			if (fc_fcp_can_queue_ramp_down(lport))
 void fc_destroy_fcp(void)
 {
-	if (scsi_pkt_cachep)
+	kmem_cache_destroy(scsi_pkt_cachep);
-		kmem_cache_destroy(scsi_pkt_cachep);
 }
 /**

drivers/scsi/libfc/fc_rport.c+16−6

 		struct fc_els_ls_rjt *rjt;
 		rjt = fc_frame_payload_get(fp, sizeof(*rjt));
-		FC_RPORT_DBG(rdata, "PLOGI ELS rejected, reason %x expl %x\n",
+		if (!rjt)
-			     rjt->er_reason, rjt->er_explan);
+			FC_RPORT_DBG(rdata, "PLOGI bad response\n");
+		else
+			FC_RPORT_DBG(rdata, "PLOGI ELS rejected, reason %x expl %x\n",
+				     rjt->er_reason, rjt->er_explan);
 		fc_rport_error_retry(rdata, -FC_EX_ELS_RJT);
 	}
 out:
 	op = fc_frame_payload_op(fp);
 	if (op == ELS_LS_ACC) {
 		pp = fc_frame_payload_get(fp, sizeof(*pp));
-		if (!pp)
+		if (!pp) {
+			fc_rport_error_retry(rdata, -FC_EX_SEQ_ERR);
 			goto out;
+		}
 		resp_code = (pp->spp.spp_flags & FC_SPP_RESP_MASK);
 		FC_RPORT_DBG(rdata, "PRLI spp_flags = 0x%x spp_type 0x%x\n",
 				fc_rport_error_retry(rdata, -FC_EX_SEQ_ERR);
 			goto out;
 		}
-		if (pp->prli.prli_spp_len < sizeof(pp->spp))
+		if (pp->prli.prli_spp_len < sizeof(pp->spp)) {
+			fc_rport_error_retry(rdata, -FC_EX_SEQ_ERR);
 			goto out;
+		}
 		fcp_parm = ntohl(pp->spp.spp_params);
 		if (fcp_parm & FCP_SPPF_RETRY)
 	} else {
 		rjt = fc_frame_payload_get(fp, sizeof(*rjt));
-		FC_RPORT_DBG(rdata, "PRLI ELS rejected, reason %x expl %x\n",
+		if (!rjt)
-			     rjt->er_reason, rjt->er_explan);
+			FC_RPORT_DBG(rdata, "PRLI bad response\n");
+		else
+			FC_RPORT_DBG(rdata, "PRLI ELS rejected, reason %x expl %x\n",
+				     rjt->er_reason, rjt->er_explan);
 		fc_rport_error_retry(rdata, FC_EX_ELS_RJT);
 	}

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

@@ -654,7 +654,7 @@ void sas_probe_sata(struct asd_sas_port *port) · 653 unmodified lines
654	/* if libata could not bring the link up, don't surface	654	/* if libata could not bring the link up, don't surface
655	* the device	655	* the device
656	*/	656	*/
657	if (ata_dev_disabled(sas_to_ata_dev(dev)))	657	if (!ata_dev_enabled(sas_to_ata_dev(dev)))
658	sas_fail_probe(dev, __func__, -ENODEV);	658	sas_fail_probe(dev, __func__, -ENODEV);
659	}	659	}
660		660

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

@@ -260,7 +260,7 @@ static void sas_suspend_devices(struct work_struct *work) · 259 unmodified lines
260	* phy_list is not being mutated	260	* phy_list is not being mutated
261	*/	261	*/
262	list_for_each_entry(phy, &port->phy_list, port_phy_el) {	262	list_for_each_entry(phy, &port->phy_list, port_phy_el) {
263	if (si->dft->lldd_port_formed)	263	if (si->dft->lldd_port_deformed)
264	si->dft->lldd_port_deformed(phy);	264	si->dft->lldd_port_deformed(phy);
265	phy->suspended = 1;	265	phy->suspended = 1;
266	port->suspended = 1;	266	port->suspended = 1;

drivers/scsi/libsas/sas_expander.c+9−13

 	unsigned long flags;
 	spin_lock_irqsave(&task->task_state_lock, flags);
-	if (!(task->task_state_flags & SAS_TASK_STATE_DONE))
+	if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
 		task->task_state_flags |= SAS_TASK_STATE_ABORTED;
+		complete(&task->slow_task->completion);
+	}
 	spin_unlock_irqrestore(&task->task_state_lock, flags);
-	complete(&task->slow_task->completion);
 }
 static void smp_task_done(struct sas_task *task)
 {
-	if (!del_timer(&task->slow_task->timer))
+	del_timer(&task->slow_task->timer);
-		return;
 	complete(&task->slow_task->completion);
 }
 		return res;
 	}
-	/* delete the old link */
+	/* we always have to delete the old device when we went here */
-	if (SAS_ADDR(phy->attached_sas_addr) &&
+	SAS_DPRINTK("ex %016llx phy 0x%x replace %016llx\n",
-	    SAS_ADDR(sas_addr) != SAS_ADDR(phy->attached_sas_addr)) {
+		    SAS_ADDR(dev->sas_addr), phy_id,
-		SAS_DPRINTK("ex %016llx phy 0x%x replace %016llx\n",
+		    SAS_ADDR(phy->attached_sas_addr));
-			    SAS_ADDR(dev->sas_addr), phy_id,
+	sas_unregister_devs_sas_addr(dev, phy_id, last);
-			    SAS_ADDR(phy->attached_sas_addr));
-		sas_unregister_devs_sas_addr(dev, phy_id, last);
-	}
 	return sas_discover_new(dev, phy_id);
 }

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

 		downloads using bsg */
 #define LPFC_MIN_SG_SLI4_BUF_SZ	0x800	/* based on LPFC_DEFAULT_SG_SEG_CNT */
-#define LPFC_MAX_SG_SLI4_SEG_CNT_DIF 128 /* sg element count per scsi cmnd */
+#define LPFC_MAX_BG_SLI4_SEG_CNT_DIF 128 /* sg element count for BlockGuard */
 #define LPFC_MAX_SG_SEG_CNT_DIF 512	/* sg element count per scsi cmnd  */
 #define LPFC_MAX_SG_SEG_CNT	4096	/* sg element count per scsi cmnd */
 #define LPFC_MIN_SG_SEG_CNT	32	/* sg element count per scsi cmnd */
 	struct list_head ext_dmabuf_list;
 };
+struct lpfc_ras_fwlog {
+	uint8_t *fwlog_buff;
+	uint32_t fw_buffcount; /* Buffer size posted to FW */
+#define LPFC_RAS_BUFF_ENTERIES  16      /* Each entry can hold max of 64k */
+#define LPFC_RAS_MAX_ENTRY_SIZE (64 * 1024)
+#define LPFC_RAS_MIN_BUFF_POST_SIZE (256 * 1024)
+#define LPFC_RAS_MAX_BUFF_POST_SIZE (1024 * 1024)
+	uint32_t fw_loglevel; /* Log level set */
+	struct lpfc_dmabuf lwpd;
+	struct list_head fwlog_buff_list;
+	/* RAS support status on adapter */
+	bool ras_hwsupport; /* RAS Support available on HW or not */
+	bool ras_enabled;   /* Ras Enabled for the function */
+#define LPFC_RAS_DISABLE_LOGGING 0x00
+#define LPFC_RAS_ENABLE_LOGGING 0x01
+	bool ras_active;    /* RAS logging running state */
+};
 struct lpfc_hba {
 	/* SCSI interface function jump table entries */
 	int (*lpfc_new_scsi_buf)
 	uint32_t cfg_total_seg_cnt;
 	uint32_t cfg_sg_seg_cnt;
 	uint32_t cfg_nvme_seg_cnt;
+	uint32_t cfg_scsi_seg_cnt;
 	uint32_t cfg_sg_dma_buf_size;
 	uint64_t cfg_soft_wwnn;
 	uint64_t cfg_soft_wwpn;
 #define LPFC_FDMI_SUPPORT	1	/* FDMI supported? */
 	uint32_t cfg_enable_SmartSAN;
 	uint32_t cfg_enable_mds_diags;
+	uint32_t cfg_ras_fwlog_level;
+	uint32_t cfg_ras_fwlog_buffsize;
+	uint32_t cfg_ras_fwlog_func;
 	uint32_t cfg_enable_fc4_type;
 	uint32_t cfg_enable_bbcr;	/* Enable BB Credit Recovery */
 	uint32_t cfg_enable_dpp;	/* Enable Direct Packet Push */
 	uint32_t intr_mode;
 #define LPFC_INTR_ERROR	0xFFFFFFFF
 	struct list_head port_list;
+	spinlock_t port_list_lock;	/* lock for port_list mutations */
 	struct lpfc_vport *pport;	/* physical lpfc_vport pointer */
 	uint16_t max_vpi;		/* Maximum virtual nports */
 #define LPFC_MAX_VPI 0xFFFF		/* Max number of VPI supported */
 	struct unsol_rcv_ct_ctx ct_ctx[LPFC_CT_CTX_MAX];
 	uint32_t ctx_idx;
+	/* RAS Support */
+	struct lpfc_ras_fwlog ras_fwlog;
 	uint8_t menlo_flag;	/* menlo generic flags */
 #define HBA_MENLO_SUPPORT	0x1 /* HBA supports menlo commands */
 	uint32_t iocb_cnt;

drivers/scsi/lpfc/lpfc_attr.c+106−5

@@ -5358,15 +5358,74 @@ LPFC_ATTR(delay_discovery, 0, 0, 1, · 5357 unmodified lines
5358		5358
5359	/*	5359	/*
5360	* lpfc_sg_seg_cnt - Initial Maximum DMA Segment Count	5360	* lpfc_sg_seg_cnt - Initial Maximum DMA Segment Count
5361	* This value can be set to values between 64 and 4096. The default value is	5361	* This value can be set to values between 64 and 4096. The default value
5362	* 64, but may be increased to allow for larger Max I/O sizes. The scsi layer	5362	* is 64, but may be increased to allow for larger Max I/O sizes. The scsi
5363	* will be allowed to request I/Os of sizes up to (MAX_SEG_COUNT * SEG_SIZE).	5363	* and nvme layers will allow I/O sizes up to (MAX_SEG_COUNT * SEG_SIZE).
5364	* Because of the additional overhead involved in setting up T10-DIF,	5364	* Because of the additional overhead involved in setting up T10-DIF,
5365	* this parameter will be limited to 128 if BlockGuard is enabled under SLI4	5365	* this parameter will be limited to 128 if BlockGuard is enabled under SLI4
5366	* and will be limited to 512 if BlockGuard is enabled under SLI3.	5366	* and will be limited to 512 if BlockGuard is enabled under SLI3.
5367	*/	5367	*/
5368	LPFC_ATTR_R(sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT, LPFC_MIN_SG_SEG_CNT,	5368	static uint lpfc_sg_seg_cnt = LPFC_DEFAULT_SG_SEG_CNT;
5369	LPFC_MAX_SG_SEG_CNT, "Max Scatter Gather Segment Count");	5369	module_param(lpfc_sg_seg_cnt, uint, 0444);
		5370	MODULE_PARM_DESC(lpfc_sg_seg_cnt, "Max Scatter Gather Segment Count");
		5371
		5372	/**
		5373	* lpfc_sg_seg_cnt_show - Display the scatter/gather list sizes
		5374	* configured for the adapter
		5375	* @dev: class converted to a Scsi_host structure.
		5376	* @attr: device attribute, not used.
		5377	* @buf: on return contains a string with the list sizes
		5378	*
		5379	* Returns: size of formatted string.
		5380	**/
		5381	static ssize_t
		5382	lpfc_sg_seg_cnt_show(struct device dev, struct device_attribute attr,
		5383	char *buf)
		5384	{
		5385	struct Scsi_Host *shost = class_to_shost(dev);
		5386	struct lpfc_vport vport = (struct lpfc_vport )shost->hostdata;
		5387	struct lpfc_hba *phba = vport->phba;
		5388	int len;
		5389
		5390	len = snprintf(buf, PAGE_SIZE, "SGL sz: %d total SGEs: %d\n",
		5391	phba->cfg_sg_dma_buf_size, phba->cfg_total_seg_cnt);
		5392
		5393	len += snprintf(buf + len, PAGE_SIZE, "Cfg: %d SCSI: %d NVME: %d\n",
		5394	phba->cfg_sg_seg_cnt, phba->cfg_scsi_seg_cnt,
		5395	phba->cfg_nvme_seg_cnt);
		5396	return len;
		5397	}
		5398
		5399	static DEVICE_ATTR_RO(lpfc_sg_seg_cnt);
		5400
		5401	/**
		5402	* lpfc_sg_seg_cnt_init - Set the hba sg_seg_cnt initial value
		5403	* @phba: lpfc_hba pointer.
		5404	* @val: contains the initial value
		5405	*
		5406	* Description:
		5407	* Validates the initial value is within range and assigns it to the
		5408	* adapter. If not in range, an error message is posted and the
		5409	* default value is assigned.
		5410	*
		5411	* Returns:
		5412	* zero if value is in range and is set
		5413	* -EINVAL if value was out of range
		5414	**/
		5415	static int
		5416	lpfc_sg_seg_cnt_init(struct lpfc_hba *phba, int val)
		5417	{
		5418	if (val >= LPFC_MIN_SG_SEG_CNT && val <= LPFC_MAX_SG_SEG_CNT) {
		5419	phba->cfg_sg_seg_cnt = val;
		5420	return 0;
		5421	}
		5422	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
		5423	"0409 "LPFC_DRIVER_NAME"_sg_seg_cnt attribute cannot "
		5424	"be set to %d, allowed range is [%d, %d]\n",
		5425	val, LPFC_MIN_SG_SEG_CNT, LPFC_MAX_SG_SEG_CNT);
		5426	phba->cfg_sg_seg_cnt = LPFC_DEFAULT_SG_SEG_CNT;
		5427	return -EINVAL;
		5428	}
5370		5429
5371	/*	5430	/*
5372	* lpfc_enable_mds_diags: Enable MDS Diagnostics	5431	* lpfc_enable_mds_diags: Enable MDS Diagnostics
@@ -5376,6 +5435,31 @@ LPFC_ATTR_R(sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT, LPFC_MIN_SG_SEG_CNT, · 3 unmodified lines
5376	*/	5435	*/
5377	LPFC_ATTR_R(enable_mds_diags, 0, 0, 1, "Enable MDS Diagnostics");	5436	LPFC_ATTR_R(enable_mds_diags, 0, 0, 1, "Enable MDS Diagnostics");
5378		5437
		5438	/*
		5439	* lpfc_ras_fwlog_buffsize: Firmware logging host buffer size
		5440	* 0 = Disable firmware logging (default)
		5441	* [1-4] = Multiple of 1/4th Mb of host memory for FW logging
		5442	* Value range [0..4]. Default value is 0
		5443	*/
		5444	LPFC_ATTR_RW(ras_fwlog_buffsize, 0, 0, 4, "Host memory for FW logging");
		5445
		5446	/*
		5447	* lpfc_ras_fwlog_level: Firmware logging verbosity level
		5448	* Valid only if firmware logging is enabled
		5449	* 0(Least Verbosity) 4 (most verbosity)
		5450	* Value range is [0..4]. Default value is 0
		5451	*/
		5452	LPFC_ATTR_RW(ras_fwlog_level, 0, 0, 4, "Firmware Logging Level");
		5453
		5454	/*
		5455	* lpfc_ras_fwlog_func: Firmware logging enabled on function number
		5456	* Default function which has RAS support : 0
		5457	* Value Range is [0..7].
		5458	* FW logging is a global action and enablement is via a specific
		5459	* port.
		5460	*/
		5461	LPFC_ATTR_RW(ras_fwlog_func, 0, 0, 7, "Firmware Logging Enabled on Function");
		5462
5379	/*	5463	/*
5380	* lpfc_enable_bbcr: Enable BB Credit Recovery	5464	* lpfc_enable_bbcr: Enable BB Credit Recovery
5381	* 0 = BB Credit Recovery disabled	5465	* 0 = BB Credit Recovery disabled
@@ -5501,6 +5585,9 @@ struct device_attribute *lpfc_hba_attrs[] = { · 119 unmodified lines
5501	&dev_attr_protocol,	5585	&dev_attr_protocol,
5502	&dev_attr_lpfc_xlane_supported,	5586	&dev_attr_lpfc_xlane_supported,
5503	&dev_attr_lpfc_enable_mds_diags,	5587	&dev_attr_lpfc_enable_mds_diags,
		5588	&dev_attr_lpfc_ras_fwlog_buffsize,
		5589	&dev_attr_lpfc_ras_fwlog_level,
		5590	&dev_attr_lpfc_ras_fwlog_func,
5504	&dev_attr_lpfc_enable_bbcr,	5591	&dev_attr_lpfc_enable_bbcr,
5505	&dev_attr_lpfc_enable_dpp,	5592	&dev_attr_lpfc_enable_dpp,
5506	NULL,	5593	NULL,
@@ -6587,6 +6674,20 @@ lpfc_get_cfgparam(struct lpfc_hba *phba) · 1080 unmodified lines
6587	lpfc_sli_mode_init(phba, lpfc_sli_mode);	6674	lpfc_sli_mode_init(phba, lpfc_sli_mode);
6588	phba->cfg_enable_dss = 1;	6675	phba->cfg_enable_dss = 1;
6589	lpfc_enable_mds_diags_init(phba, lpfc_enable_mds_diags);	6676	lpfc_enable_mds_diags_init(phba, lpfc_enable_mds_diags);
		6677	lpfc_ras_fwlog_buffsize_init(phba, lpfc_ras_fwlog_buffsize);
		6678	lpfc_ras_fwlog_level_init(phba, lpfc_ras_fwlog_level);
		6679	lpfc_ras_fwlog_func_init(phba, lpfc_ras_fwlog_func);
		6680
		6681
		6682	/* If the NVME FC4 type is enabled, scale the sg_seg_cnt to
		6683	* accommodate 512K and 1M IOs in a single nvme buf and supply
		6684	* enough NVME LS iocb buffers for larger connectivity counts.
		6685	*/
		6686	if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
		6687	phba->cfg_sg_seg_cnt = LPFC_MAX_NVME_SEG_CNT;
		6688	phba->cfg_iocb_cnt = 5;
		6689	}
		6690
6590	return;	6691	return;
6591	}	6692	}
6592		6693

drivers/scsi/lpfc/lpfc_bsg.c+339−5

@@ -27,6 +27,7 @@ · 26 unmodified lines
27	#include <linux/delay.h>	27	#include <linux/delay.h>
28	#include <linux/list.h>	28	#include <linux/list.h>
29	#include <linux/bsg-lib.h>	29	#include <linux/bsg-lib.h>
		30	#include <linux/vmalloc.h>
30		31
31	#include <scsi/scsi.h>	32	#include <scsi/scsi.h>
32	#include <scsi/scsi_host.h>	33	#include <scsi/scsi_host.h>
@@ -2843,9 +2844,6 @@ diag_cmd_data_alloc(struct lpfc_hba *phba, · 2810 unmodified lines
2843		2844
2844	if (nocopydata) {	2845	if (nocopydata) {
2845	bpl->tus.f.bdeFlags = 0;	2846	bpl->tus.f.bdeFlags = 0;
2846	pci_dma_sync_single_for_device(phba->pcidev,
2847	dmp->dma.phys, LPFC_BPL_SIZE, PCI_DMA_TODEVICE);
2848
2849	} else {	2847	} else {
2850	memset((uint8_t *)dmp->dma.virt, 0, cnt);	2848	memset((uint8_t *)dmp->dma.virt, 0, cnt);
2851	bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;	2849	bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
@@ -5308,6 +5306,330 @@ job_error: · 2456 unmodified lines
5308	return rc;	5306	return rc;
5309	}	5307	}
5310		5308
		5309	/**
		5310	* lpfc_check_fwlog_support: Check FW log support on the adapter
		5311	* @phba: Pointer to HBA context object.
		5312	*
		5313	* Check if FW Logging support by the adapter
		5314	**/
		5315	int
		5316	lpfc_check_fwlog_support(struct lpfc_hba *phba)
		5317	{
		5318	struct lpfc_ras_fwlog *ras_fwlog = NULL;
		5319
		5320	ras_fwlog = &phba->ras_fwlog;
		5321
		5322	if (ras_fwlog->ras_hwsupport == false)
		5323	return -EACCES;
		5324	else if (ras_fwlog->ras_enabled == false)
		5325	return -EPERM;
		5326	else
		5327	return 0;
		5328	}
		5329
		5330	/**
		5331	* lpfc_bsg_get_ras_config: Get RAS configuration settings
		5332	* @job: fc_bsg_job to handle
		5333	*
		5334	* Get RAS configuration values set.
		5335	**/
		5336	static int
		5337	lpfc_bsg_get_ras_config(struct bsg_job *job)
		5338	{
		5339	struct Scsi_Host *shost = fc_bsg_to_shost(job);
		5340	struct lpfc_vport *vport = shost_priv(shost);
		5341	struct fc_bsg_reply *bsg_reply = job->reply;
		5342	struct lpfc_hba *phba = vport->phba;
		5343	struct lpfc_bsg_get_ras_config_reply *ras_reply;
		5344	struct lpfc_ras_fwlog *ras_fwlog = &phba->ras_fwlog;
		5345	int rc = 0;
		5346
		5347	if (job->request_len <
		5348	sizeof(struct fc_bsg_request) +
		5349	sizeof(struct lpfc_bsg_ras_req)) {
		5350	lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
		5351	"6181 Received RAS_LOG request "
		5352	"below minimum size\n");
		5353	rc = -EINVAL;
		5354	goto ras_job_error;
		5355	}
		5356
		5357	/* Check FW log status */
		5358	rc = lpfc_check_fwlog_support(phba);
		5359	if (rc == -EACCES \|\| rc == -EPERM)
		5360	goto ras_job_error;
		5361
		5362	ras_reply = (struct lpfc_bsg_get_ras_config_reply *)
		5363	bsg_reply->reply_data.vendor_reply.vendor_rsp;
		5364
		5365	/* Current logging state */
		5366	if (ras_fwlog->ras_active == true)
		5367	ras_reply->state = LPFC_RASLOG_STATE_RUNNING;
		5368	else
		5369	ras_reply->state = LPFC_RASLOG_STATE_STOPPED;
		5370
		5371	ras_reply->log_level = phba->ras_fwlog.fw_loglevel;
		5372	ras_reply->log_buff_sz = phba->cfg_ras_fwlog_buffsize;
		5373
		5374	ras_job_error:
		5375	/* make error code available to userspace */
		5376	bsg_reply->result = rc;
		5377
		5378	/* complete the job back to userspace */
		5379	bsg_job_done(job, bsg_reply->result, bsg_reply->reply_payload_rcv_len);
		5380	return rc;
		5381	}
		5382
		5383	/**
		5384	* lpfc_ras_stop_fwlog: Disable FW logging by the adapter
		5385	* @phba: Pointer to HBA context object.
		5386	*
		5387	* Disable FW logging into host memory on the adapter. To
		5388	* be done before reading logs from the host memory.
		5389	**/
		5390	static void
		5391	lpfc_ras_stop_fwlog(struct lpfc_hba *phba)
		5392	{
		5393	struct lpfc_ras_fwlog *ras_fwlog = &phba->ras_fwlog;
		5394
		5395	ras_fwlog->ras_active = false;
		5396
		5397	/* Disable FW logging to host memory */
		5398	writel(LPFC_CTL_PDEV_CTL_DDL_RAS,
		5399	phba->sli4_hba.conf_regs_memmap_p + LPFC_CTL_PDEV_CTL_OFFSET);
		5400	}
		5401
		5402	/**
		5403	* lpfc_bsg_set_ras_config: Set FW logging parameters
		5404	* @job: fc_bsg_job to handle
		5405	*
		5406	* Set log-level parameters for FW-logging in host memory
		5407	**/
		5408	static int
		5409	lpfc_bsg_set_ras_config(struct bsg_job *job)
		5410	{
		5411	struct Scsi_Host *shost = fc_bsg_to_shost(job);
		5412	struct lpfc_vport *vport = shost_priv(shost);
		5413	struct lpfc_hba *phba = vport->phba;
		5414	struct lpfc_bsg_set_ras_config_req *ras_req;
		5415	struct fc_bsg_request *bsg_request = job->request;
		5416	struct lpfc_ras_fwlog *ras_fwlog = &phba->ras_fwlog;
		5417	struct fc_bsg_reply *bsg_reply = job->reply;
		5418	uint8_t action = 0, log_level = 0;
		5419	int rc = 0;
		5420
		5421	if (job->request_len <
		5422	sizeof(struct fc_bsg_request) +
		5423	sizeof(struct lpfc_bsg_set_ras_config_req)) {
		5424	lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
		5425	"6182 Received RAS_LOG request "
		5426	"below minimum size\n");
		5427	rc = -EINVAL;
		5428	goto ras_job_error;
		5429	}
		5430
		5431	/* Check FW log status */
		5432	rc = lpfc_check_fwlog_support(phba);
		5433	if (rc == -EACCES \|\| rc == -EPERM)
		5434	goto ras_job_error;
		5435
		5436	ras_req = (struct lpfc_bsg_set_ras_config_req *)
		5437	bsg_request->rqst_data.h_vendor.vendor_cmd;
		5438	action = ras_req->action;
		5439	log_level = ras_req->log_level;
		5440
		5441	if (action == LPFC_RASACTION_STOP_LOGGING) {
		5442	/* Check if already disabled */
		5443	if (ras_fwlog->ras_active == false) {
		5444	rc = -ESRCH;
		5445	goto ras_job_error;
		5446	}
		5447
		5448	/* Disable logging */
		5449	lpfc_ras_stop_fwlog(phba);
		5450	} else {
		5451	/action = LPFC_RASACTION_START_LOGGING/
		5452	if (ras_fwlog->ras_active == true) {
		5453	rc = -EINPROGRESS;
		5454	goto ras_job_error;
		5455	}
		5456
		5457	/* Enable logging */
		5458	rc = lpfc_sli4_ras_fwlog_init(phba, log_level,
		5459	LPFC_RAS_ENABLE_LOGGING);
		5460	if (rc)
		5461	rc = -EINVAL;
		5462	}
		5463	ras_job_error:
		5464	/* make error code available to userspace */
		5465	bsg_reply->result = rc;
		5466
		5467	/* complete the job back to userspace */
		5468	bsg_job_done(job, bsg_reply->result,
		5469	bsg_reply->reply_payload_rcv_len);
		5470
		5471	return rc;
		5472	}
		5473
		5474	/**
		5475	* lpfc_bsg_get_ras_lwpd: Get log write position data
		5476	* @job: fc_bsg_job to handle
		5477	*
		5478	* Get Offset/Wrap count of the log message written
		5479	* in host memory
		5480	**/
		5481	static int
		5482	lpfc_bsg_get_ras_lwpd(struct bsg_job *job)
		5483	{
		5484	struct Scsi_Host *shost = fc_bsg_to_shost(job);
		5485	struct lpfc_vport *vport = shost_priv(shost);
		5486	struct lpfc_bsg_get_ras_lwpd *ras_reply;
		5487	struct lpfc_hba *phba = vport->phba;
		5488	struct lpfc_ras_fwlog *ras_fwlog = &phba->ras_fwlog;
		5489	struct fc_bsg_reply *bsg_reply = job->reply;
		5490	uint32_t lwpd_offset = 0;
		5491	uint64_t wrap_value = 0;
		5492	int rc = 0;
		5493
		5494	rc = lpfc_check_fwlog_support(phba);
		5495	if (rc == -EACCES \|\| rc == -EPERM)
		5496	goto ras_job_error;
		5497
		5498	if (job->request_len <
		5499	sizeof(struct fc_bsg_request) +
		5500	sizeof(struct lpfc_bsg_ras_req)) {
		5501	lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
		5502	"6183 Received RAS_LOG request "
		5503	"below minimum size\n");
		5504	rc = -EINVAL;
		5505	goto ras_job_error;
		5506	}
		5507
		5508	ras_reply = (struct lpfc_bsg_get_ras_lwpd *)
		5509	bsg_reply->reply_data.vendor_reply.vendor_rsp;
		5510
		5511	lwpd_offset = ((uint32_t )ras_fwlog->lwpd.virt) & 0xffffffff;
		5512	ras_reply->offset = be32_to_cpu(lwpd_offset);
		5513
		5514	wrap_value = ((uint64_t )ras_fwlog->lwpd.virt);
		5515	ras_reply->wrap_count = be32_to_cpu((wrap_value >> 32) & 0xffffffff);
		5516
		5517	ras_job_error:
		5518	/* make error code available to userspace */
		5519	bsg_reply->result = rc;
		5520
		5521	/* complete the job back to userspace */
		5522	bsg_job_done(job, bsg_reply->result, bsg_reply->reply_payload_rcv_len);
		5523
		5524	return rc;
		5525	}
		5526
		5527	/**
		5528	* lpfc_bsg_get_ras_fwlog: Read FW log
		5529	* @job: fc_bsg_job to handle
		5530	*
		5531	* Copy the FW log into the passed buffer.
		5532	**/
		5533	static int
		5534	lpfc_bsg_get_ras_fwlog(struct bsg_job *job)
		5535	{
		5536	struct Scsi_Host *shost = fc_bsg_to_shost(job);
		5537	struct lpfc_vport *vport = shost_priv(shost);
		5538	struct lpfc_hba *phba = vport->phba;
		5539	struct fc_bsg_request *bsg_request = job->request;
		5540	struct fc_bsg_reply *bsg_reply = job->reply;
		5541	struct lpfc_bsg_get_fwlog_req *ras_req;
		5542	uint32_t rd_offset, rd_index, offset, pending_wlen;
		5543	uint32_t boundary = 0, align_len = 0, write_len = 0;
		5544	void dest, src, *fwlog_buff;
		5545	struct lpfc_ras_fwlog *ras_fwlog = NULL;
		5546	struct lpfc_dmabuf dmabuf, next;
		5547	int rc = 0;
		5548
		5549	ras_fwlog = &phba->ras_fwlog;
		5550
		5551	rc = lpfc_check_fwlog_support(phba);
		5552	if (rc == -EACCES \|\| rc == -EPERM)
		5553	goto ras_job_error;
		5554
		5555	/* Logging to be stopped before reading */
		5556	if (ras_fwlog->ras_active == true) {
		5557	rc = -EINPROGRESS;
		5558	goto ras_job_error;
		5559	}
		5560
		5561	if (job->request_len <
		5562	sizeof(struct fc_bsg_request) +
		5563	sizeof(struct lpfc_bsg_get_fwlog_req)) {
		5564	lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
		5565	"6184 Received RAS_LOG request "
		5566	"below minimum size\n");
		5567	rc = -EINVAL;
		5568	goto ras_job_error;
		5569	}
		5570
		5571	ras_req = (struct lpfc_bsg_get_fwlog_req *)
		5572	bsg_request->rqst_data.h_vendor.vendor_cmd;
		5573	rd_offset = ras_req->read_offset;
		5574
		5575	/* Allocate memory to read fw log*/
		5576	fwlog_buff = vmalloc(ras_req->read_size);
		5577	if (!fwlog_buff) {
		5578	rc = -ENOMEM;
		5579	goto ras_job_error;
		5580	}
		5581
		5582	rd_index = (rd_offset / LPFC_RAS_MAX_ENTRY_SIZE);
		5583	offset = (rd_offset % LPFC_RAS_MAX_ENTRY_SIZE);
		5584	pending_wlen = ras_req->read_size;
		5585	dest = fwlog_buff;
		5586
		5587	list_for_each_entry_safe(dmabuf, next,
		5588	&ras_fwlog->fwlog_buff_list, list) {
		5589
		5590	if (dmabuf->buffer_tag < rd_index)
		5591	continue;
		5592
		5593	/* Align read to buffer size */
		5594	if (offset) {
		5595	boundary = ((dmabuf->buffer_tag + 1) *
		5596	LPFC_RAS_MAX_ENTRY_SIZE);
		5597
		5598	align_len = (boundary - offset);
		5599	write_len = min_t(u32, align_len,
		5600	LPFC_RAS_MAX_ENTRY_SIZE);
		5601	} else {
		5602	write_len = min_t(u32, pending_wlen,
		5603	LPFC_RAS_MAX_ENTRY_SIZE);
		5604	align_len = 0;
		5605	boundary = 0;
		5606	}
		5607	src = dmabuf->virt + offset;
		5608	memcpy(dest, src, write_len);
		5609
		5610	pending_wlen -= write_len;
		5611	if (!pending_wlen)
		5612	break;
		5613
		5614	dest += write_len;
		5615	offset = (offset + write_len) % LPFC_RAS_MAX_ENTRY_SIZE;
		5616	}
		5617
		5618	bsg_reply->reply_payload_rcv_len =
		5619	sg_copy_from_buffer(job->reply_payload.sg_list,
		5620	job->reply_payload.sg_cnt,
		5621	fwlog_buff, ras_req->read_size);
		5622
		5623	vfree(fwlog_buff);
		5624
		5625	ras_job_error:
		5626	bsg_reply->result = rc;
		5627	bsg_job_done(job, bsg_reply->result, bsg_reply->reply_payload_rcv_len);
		5628
		5629	return rc;
		5630	}
		5631
		5632
5311	/**	5633	/**
5312	* lpfc_bsg_hst_vendor - process a vendor-specific fc_bsg_job	5634	* lpfc_bsg_hst_vendor - process a vendor-specific fc_bsg_job
5313	* @job: fc_bsg_job to handle	5635	* @job: fc_bsg_job to handle
@@ -5355,6 +5677,18 @@ lpfc_bsg_hst_vendor(struct bsg_job *job) · 41 unmodified lines
5355	case LPFC_BSG_VENDOR_FORCED_LINK_SPEED:	5677	case LPFC_BSG_VENDOR_FORCED_LINK_SPEED:
5356	rc = lpfc_forced_link_speed(job);	5678	rc = lpfc_forced_link_speed(job);
5357	break;	5679	break;
		5680	case LPFC_BSG_VENDOR_RAS_GET_LWPD:
		5681	rc = lpfc_bsg_get_ras_lwpd(job);
		5682	break;
		5683	case LPFC_BSG_VENDOR_RAS_GET_FWLOG:
		5684	rc = lpfc_bsg_get_ras_fwlog(job);
		5685	break;
		5686	case LPFC_BSG_VENDOR_RAS_GET_CONFIG:
		5687	rc = lpfc_bsg_get_ras_config(job);
		5688	break;
		5689	case LPFC_BSG_VENDOR_RAS_SET_CONFIG:
		5690	rc = lpfc_bsg_set_ras_config(job);
		5691	break;
5358	default:	5692	default:
5359	rc = -EINVAL;	5693	rc = -EINVAL;
5360	bsg_reply->reply_payload_rcv_len = 0;	5694	bsg_reply->reply_payload_rcv_len = 0;
@@ -5368,7 +5702,7 @@ lpfc_bsg_hst_vendor(struct bsg_job *job) · 7 unmodified lines
5368		5702
5369	/**	5703	/**
5370	* lpfc_bsg_request - handle a bsg request from the FC transport	5704	* lpfc_bsg_request - handle a bsg request from the FC transport
5371	* @job: fc_bsg_job to handle	5705	* @job: bsg_job to handle
5372	**/	5706	**/
5373	int	5707	int
5374	lpfc_bsg_request(struct bsg_job *job)	5708	lpfc_bsg_request(struct bsg_job *job)
@@ -5402,7 +5736,7 @@ lpfc_bsg_request(struct bsg_job *job) · 27 unmodified lines
5402		5736
5403	/**	5737	/**
5404	* lpfc_bsg_timeout - handle timeout of a bsg request from the FC transport	5738	* lpfc_bsg_timeout - handle timeout of a bsg request from the FC transport
5405	* @job: fc_bsg_job that has timed out	5739	* @job: bsg_job that has timed out
5406	*	5740	*
5407	* This function just aborts the job's IOCB. The aborted IOCB will return to	5741	* This function just aborts the job's IOCB. The aborted IOCB will return to
5408	* the waiting function which will handle passing the error back to userspace	5742	* the waiting function which will handle passing the error back to userspace

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

@@ -38,6 +38,10 @@ · 37 unmodified lines
38	#define LPFC_BSG_VENDOR_DIAG_MODE_END 10	38	#define LPFC_BSG_VENDOR_DIAG_MODE_END 10
39	#define LPFC_BSG_VENDOR_LINK_DIAG_TEST 11	39	#define LPFC_BSG_VENDOR_LINK_DIAG_TEST 11
40	#define LPFC_BSG_VENDOR_FORCED_LINK_SPEED 14	40	#define LPFC_BSG_VENDOR_FORCED_LINK_SPEED 14
		41	#define LPFC_BSG_VENDOR_RAS_GET_LWPD 16
		42	#define LPFC_BSG_VENDOR_RAS_GET_FWLOG 17
		43	#define LPFC_BSG_VENDOR_RAS_GET_CONFIG 18
		44	#define LPFC_BSG_VENDOR_RAS_SET_CONFIG 19
41		45
42	struct set_ct_event {	46	struct set_ct_event {
43	uint32_t command;	47	uint32_t command;
@@ -296,6 +300,38 @@ struct forced_link_speed_support_reply { · 252 unmodified lines
296	uint8_t supported;	300	uint8_t supported;
297	};	301	};
298		302
		303	struct lpfc_bsg_ras_req {
		304	uint32_t command;
		305	};
		306
		307	struct lpfc_bsg_get_fwlog_req {
		308	uint32_t command;
		309	uint32_t read_size;
		310	uint32_t read_offset;
		311	};
		312
		313	struct lpfc_bsg_get_ras_lwpd {
		314	uint32_t offset;
		315	uint32_t wrap_count;
		316	};
		317
		318	struct lpfc_bsg_set_ras_config_req {
		319	uint32_t command;
		320	uint8_t action;
		321	#define LPFC_RASACTION_STOP_LOGGING 0x00
		322	#define LPFC_RASACTION_START_LOGGING 0x01
		323	uint8_t log_level;
		324	};
		325
		326	struct lpfc_bsg_get_ras_config_reply {
		327	uint8_t state;
		328	#define LPFC_RASLOG_STATE_STOPPED 0x00
		329	#define LPFC_RASLOG_STATE_RUNNING 0x01
		330	uint8_t log_level;
		331	uint32_t log_buff_sz;
		332	};
		333
		334
299	/* driver only */	335	/* driver only */
300	#define SLI_CONFIG_NOT_HANDLED 0	336	#define SLI_CONFIG_NOT_HANDLED 0
301	#define SLI_CONFIG_HANDLED 1	337	#define SLI_CONFIG_HANDLED 1

drivers/scsi/lpfc/lpfc_crtn.h+7−0

@@ -545,6 +545,13 @@ bool lpfc_find_next_oas_lun(struct lpfc_hba , struct lpfc_name , · 544 unmodified lines
545	int lpfc_sli4_dump_page_a0(struct lpfc_hba phba, struct lpfcMboxq mbox);	545	int lpfc_sli4_dump_page_a0(struct lpfc_hba phba, struct lpfcMboxq mbox);
546	void lpfc_mbx_cmpl_rdp_page_a0(struct lpfc_hba phba, LPFC_MBOXQ_t pmb);	546	void lpfc_mbx_cmpl_rdp_page_a0(struct lpfc_hba phba, LPFC_MBOXQ_t pmb);
547		547
		548	/* RAS Interface */
		549	void lpfc_sli4_ras_init(struct lpfc_hba *phba);
		550	void lpfc_sli4_ras_setup(struct lpfc_hba *phba);
		551	int lpfc_sli4_ras_fwlog_init(struct lpfc_hba *phba, uint32_t fwlog_level,
		552	uint32_t fwlog_enable);
		553	int lpfc_check_fwlog_support(struct lpfc_hba *phba);
		554
548	/* NVME interfaces. */	555	/* NVME interfaces. */
549	void lpfc_nvme_unregister_port(struct lpfc_vport *vport,	556	void lpfc_nvme_unregister_port(struct lpfc_vport *vport,
550	struct lpfc_nodelist *ndlp);	557	struct lpfc_nodelist *ndlp);

drivers/scsi/lpfc/lpfc_ct.c+3−8

 	struct lpfc_vport *vport_curr;
 	unsigned long flags;
-	spin_lock_irqsave(&phba->hbalock, flags);
+	spin_lock_irqsave(&phba->port_list_lock, flags);
 	list_for_each_entry(vport_curr, &phba->port_list, listentry) {
 		if ((vport_curr->fc_myDID) && (vport_curr->fc_myDID == did)) {
-			spin_unlock_irqrestore(&phba->hbalock, flags);
+			spin_unlock_irqrestore(&phba->port_list_lock, flags);
 			return vport_curr;
 		}
 	}
-	spin_unlock_irqrestore(&phba->hbalock, flags);
+	spin_unlock_irqrestore(&phba->port_list_lock, flags);
 	return NULL;
 }
 				"Parse GID_FTrsp: did:x%x flg:x%x x%x",
 				Did, ndlp->nlp_flag, vport->fc_flag);
-			/* Don't assume the rport is always the previous
-			 * FC4 type.
-			 */
-			ndlp->nlp_fc4_type &= ~(NLP_FC4_FCP | NLP_FC4_NVME);
 			/* By default, the driver expects to support FCP FC4 */
 			if (fc4_type == FC_TYPE_FCP)
 				ndlp->nlp_fc4_type |= NLP_FC4_FCP;

drivers/scsi/lpfc/lpfc_debugfs.c+0−2

 	struct lpfc_nodelist *ndlp;
 	unsigned char *statep;
 	struct nvme_fc_local_port *localport;
-	struct lpfc_nvmet_tgtport *tgtp;
 	struct nvme_fc_remote_port *nrport = NULL;
 	struct lpfc_nvme_rport *rport;
 			"\nOutstanding IO x%x\n",  outio);
 	if (phba->nvmet_support && phba->targetport && (vport == phba->pport)) {
-		tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private;
 		len += snprintf(buf + len, size - len,
 				"\nNVME Targetport Entry ...\n");

drivers/scsi/lpfc/lpfc_els.c+3−0

 lpfc_els_flush_all_cmd(struct lpfc_hba  *phba)
 {
 	struct lpfc_vport *vport;
+	spin_lock_irq(&phba->port_list_lock);
 	list_for_each_entry(vport, &phba->port_list, listentry)
 		lpfc_els_flush_cmd(vport);
+	spin_unlock_irq(&phba->port_list_lock);
 	return;
 }

drivers/scsi/lpfc/lpfc_hbadisc.c+4−6

 	if (new_state ==  NLP_STE_MAPPED_NODE ||
 	    new_state == NLP_STE_UNMAPPED_NODE) {
-		if (ndlp->nlp_fc4_type & NLP_FC4_FCP ||
+		if (ndlp->nlp_fc4_type ||
 		    ndlp->nlp_DID == Fabric_DID ||
 		    ndlp->nlp_DID == NameServer_DID ||
 		    ndlp->nlp_DID == FDMI_DID) {
 lpfc_free_tx(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
 {
 	LIST_HEAD(completions);
-	struct lpfc_sli *psli;
 	IOCB_t     *icmd;
 	struct lpfc_iocbq    *iocb, *next_iocb;
 	struct lpfc_sli_ring *pring;
-	psli = &phba->sli;
 	pring = lpfc_phba_elsring(phba);
 	if (unlikely(!pring))
 		return;
 		}
 	}
-	spin_lock_irqsave(&phba->hbalock, flags);
+	spin_lock_irqsave(&phba->port_list_lock, flags);
 	list_for_each_entry(vport, &phba->port_list, listentry) {
 		if (vport->vpi == i) {
-			spin_unlock_irqrestore(&phba->hbalock, flags);
+			spin_unlock_irqrestore(&phba->port_list_lock, flags);
 			return vport;
 		}
 	}
-	spin_unlock_irqrestore(&phba->hbalock, flags);
+	spin_unlock_irqrestore(&phba->port_list_lock, flags);
 	return NULL;
 }

drivers/scsi/lpfc/lpfc_hw4.h+45−0

@@ -186,6 +186,7 @@ struct lpfc_sli_intf { · 185 unmodified lines
186	#define LPFC_CTL_PDEV_CTL_FRL_ALL 0x00	186	#define LPFC_CTL_PDEV_CTL_FRL_ALL 0x00
187	#define LPFC_CTL_PDEV_CTL_FRL_FC_FCOE 0x10	187	#define LPFC_CTL_PDEV_CTL_FRL_FC_FCOE 0x10
188	#define LPFC_CTL_PDEV_CTL_FRL_NIC 0x20	188	#define LPFC_CTL_PDEV_CTL_FRL_NIC 0x20
		189	#define LPFC_CTL_PDEV_CTL_DDL_RAS 0x1000000
189		190
190	#define LPFC_FW_DUMP_REQUEST (LPFC_CTL_PDEV_CTL_DD \| LPFC_CTL_PDEV_CTL_FRST)	191	#define LPFC_FW_DUMP_REQUEST (LPFC_CTL_PDEV_CTL_DD \| LPFC_CTL_PDEV_CTL_FRST)
191		192
@@ -964,6 +965,7 @@ struct mbox_header { · 772 unmodified lines
964	/* Subsystem Definitions */	965	/* Subsystem Definitions */
965	#define LPFC_MBOX_SUBSYSTEM_NA 0x0	966	#define LPFC_MBOX_SUBSYSTEM_NA 0x0
966	#define LPFC_MBOX_SUBSYSTEM_COMMON 0x1	967	#define LPFC_MBOX_SUBSYSTEM_COMMON 0x1
		968	#define LPFC_MBOX_SUBSYSTEM_LOWLEVEL 0xB
967	#define LPFC_MBOX_SUBSYSTEM_FCOE 0xC	969	#define LPFC_MBOX_SUBSYSTEM_FCOE 0xC
968		970
969	/* Device Specific Definitions */	971	/* Device Specific Definitions */
@@ -1030,6 +1032,9 @@ struct mbox_header { · 60 unmodified lines
1030	#define LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_STATE 0x22	1032	#define LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_STATE 0x22
1031	#define LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_LOOPBACK 0x23	1033	#define LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_LOOPBACK 0x23
1032		1034
		1035	/* Low level Opcodes */
		1036	#define LPFC_MBOX_OPCODE_SET_DIAG_LOG_OPTION 0x37
		1037
1033	/* Mailbox command structures */	1038	/* Mailbox command structures */
1034	struct eq_context {	1039	struct eq_context {
1035	uint32_t word0;	1040	uint32_t word0;
@@ -1162,6 +1167,45 @@ struct lpfc_mbx_nop { · 126 unmodified lines
1162	uint32_t context[2];	1167	uint32_t context[2];
1163	};	1168	};
1164		1169
		1170
		1171
		1172	struct lpfc_mbx_set_ras_fwlog {
		1173	struct mbox_header header;
		1174	union {
		1175	struct {
		1176	uint32_t word4;
		1177	#define lpfc_fwlog_enable_SHIFT 0
		1178	#define lpfc_fwlog_enable_MASK 0x00000001
		1179	#define lpfc_fwlog_enable_WORD word4
		1180	#define lpfc_fwlog_loglvl_SHIFT 8
		1181	#define lpfc_fwlog_loglvl_MASK 0x0000000F
		1182	#define lpfc_fwlog_loglvl_WORD word4
		1183	#define lpfc_fwlog_ra_SHIFT 15
		1184	#define lpfc_fwlog_ra_WORD 0x00000008
		1185	#define lpfc_fwlog_buffcnt_SHIFT 16
		1186	#define lpfc_fwlog_buffcnt_MASK 0x000000FF
		1187	#define lpfc_fwlog_buffcnt_WORD word4
		1188	#define lpfc_fwlog_buffsz_SHIFT 24
		1189	#define lpfc_fwlog_buffsz_MASK 0x000000FF
		1190	#define lpfc_fwlog_buffsz_WORD word4
		1191	uint32_t word5;
		1192	#define lpfc_fwlog_acqe_SHIFT 0
		1193	#define lpfc_fwlog_acqe_MASK 0x0000FFFF
		1194	#define lpfc_fwlog_acqe_WORD word5
		1195	#define lpfc_fwlog_cqid_SHIFT 16
		1196	#define lpfc_fwlog_cqid_MASK 0x0000FFFF
		1197	#define lpfc_fwlog_cqid_WORD word5
		1198	#define LPFC_MAX_FWLOG_PAGE 16
		1199	struct dma_address lwpd;
		1200	struct dma_address buff_fwlog[LPFC_MAX_FWLOG_PAGE];
		1201	} request;
		1202	struct {
		1203	uint32_t word0;
		1204	} response;
		1205	} u;
		1206	};
		1207
		1208
1165	struct cq_context {	1209	struct cq_context {
1166	uint32_t word0;	1210	uint32_t word0;
1167	#define lpfc_cq_context_event_SHIFT 31	1211	#define lpfc_cq_context_event_SHIFT 31
@@ -3868,6 +3912,7 @@ struct lpfc_mqe { · 2700 unmodified lines
3868	struct lpfc_mbx_memory_dump_type3 mem_dump_type3;	3912	struct lpfc_mbx_memory_dump_type3 mem_dump_type3;
3869	struct lpfc_mbx_set_host_data set_host_data;	3913	struct lpfc_mbx_set_host_data set_host_data;
3870	struct lpfc_mbx_nop nop;	3914	struct lpfc_mbx_nop nop;
		3915	struct lpfc_mbx_set_ras_fwlog ras_fwlog;
3871	} un;	3916	} un;
3872	};	3917	};
3873		3918

drivers/scsi/lpfc/lpfc_init.c+83−20

 	if (phba->sli_rev == LPFC_SLI_REV4) {
 		shost->dma_boundary =
 			phba->sli4_hba.pc_sli4_params.sge_supp_len-1;
-		shost->sg_tablesize = phba->cfg_sg_seg_cnt;
+		shost->sg_tablesize = phba->cfg_scsi_seg_cnt;
 	}
 	/*
 	if (error)
 		goto out_put_shost;
-	spin_lock_irq(&phba->hbalock);
+	spin_lock_irq(&phba->port_list_lock);
 	list_add_tail(&vport->listentry, &phba->port_list);
-	spin_unlock_irq(&phba->hbalock);
+	spin_unlock_irq(&phba->port_list_lock);
 	return vport;
 out_put_shost:
 	fc_remove_host(shost);
 	scsi_remove_host(shost);
-	spin_lock_irq(&phba->hbalock);
+	spin_lock_irq(&phba->port_list_lock);
 	list_del_init(&vport->listentry);
-	spin_unlock_irq(&phba->hbalock);
+	spin_unlock_irq(&phba->port_list_lock);
 	lpfc_cleanup(vport);
 	return;
 	/* Initialize ndlp management spinlock */
 	spin_lock_init(&phba->ndlp_lock);
+	/* Initialize port_list spinlock */
+	spin_lock_init(&phba->port_list_lock);
 	INIT_LIST_HEAD(&phba->port_list);
 	INIT_LIST_HEAD(&phba->work_list);
 	init_waitqueue_head(&phba->wait_4_mlo_m_q);
 	 * There are going to be 2 reserved SGEs: 1 FCP cmnd + 1 FCP rsp
 	 */
 	max_buf_size = (2 * SLI4_PAGE_SIZE);
-	if (phba->cfg_sg_seg_cnt > LPFC_MAX_SGL_SEG_CNT - extra)
-		phba->cfg_sg_seg_cnt = LPFC_MAX_SGL_SEG_CNT - extra;
 	/*
 	 * Since lpfc_sg_seg_cnt is module param, the sg_dma_buf_size
 		/* Total SGEs for scsi_sg_list and scsi_sg_prot_list */
 		phba->cfg_total_seg_cnt = LPFC_MAX_SGL_SEG_CNT;
-		if (phba->cfg_sg_seg_cnt > LPFC_MAX_SG_SLI4_SEG_CNT_DIF)
+		/*
-			phba->cfg_sg_seg_cnt =
+		 * If supporting DIF, reduce the seg count for scsi to
-				LPFC_MAX_SG_SLI4_SEG_CNT_DIF;
+		 * allow room for the DIF sges.
+		 */
+		if (phba->cfg_enable_bg &&
+		    phba->cfg_sg_seg_cnt > LPFC_MAX_BG_SLI4_SEG_CNT_DIF)
+			phba->cfg_scsi_seg_cnt = LPFC_MAX_BG_SLI4_SEG_CNT_DIF;
+		else
+			phba->cfg_scsi_seg_cnt = phba->cfg_sg_seg_cnt;
 	} else {
 		/*
 		 * The scsi_buf for a regular I/O holds the FCP cmnd,
 		/* Total SGEs for scsi_sg_list */
 		phba->cfg_total_seg_cnt = phba->cfg_sg_seg_cnt + extra;
+		phba->cfg_scsi_seg_cnt = phba->cfg_sg_seg_cnt;
 		/*
 		 * NOTE: if (phba->cfg_sg_seg_cnt + extra) <= 256 we only
 		 */
 	}
+	/* Limit to LPFC_MAX_NVME_SEG_CNT for NVME. */
+	if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
+		if (phba->cfg_sg_seg_cnt > LPFC_MAX_NVME_SEG_CNT) {
+			lpfc_printf_log(phba, KERN_INFO, LOG_NVME | LOG_INIT,
+					"6300 Reducing NVME sg segment "
+					"cnt to %d\n",
+					LPFC_MAX_NVME_SEG_CNT);
+			phba->cfg_nvme_seg_cnt = LPFC_MAX_NVME_SEG_CNT;
+		} else
+			phba->cfg_nvme_seg_cnt = phba->cfg_sg_seg_cnt;
+	}
 	/* Initialize the host templates with the updated values. */
-	lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
+	lpfc_vport_template.sg_tablesize = phba->cfg_scsi_seg_cnt;
-	lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt;
+	lpfc_template.sg_tablesize = phba->cfg_scsi_seg_cnt;
-	lpfc_template_no_hr.sg_tablesize = phba->cfg_sg_seg_cnt;
+	lpfc_template_no_hr.sg_tablesize = phba->cfg_scsi_seg_cnt;
 	if (phba->cfg_sg_dma_buf_size  <= LPFC_MIN_SG_SLI4_BUF_SZ)
 		phba->cfg_sg_dma_buf_size = LPFC_MIN_SG_SLI4_BUF_SZ;
 			SLI4_PAGE_ALIGN(phba->cfg_sg_dma_buf_size);
 	lpfc_printf_log(phba, KERN_INFO, LOG_INIT | LOG_FCP,
-			"9087 sg_tablesize:%d dmabuf_size:%d total_sge:%d\n",
+			"9087 sg_seg_cnt:%d dmabuf_size:%d "
+			"total:%d scsi:%d nvme:%d\n",
 			phba->cfg_sg_seg_cnt, phba->cfg_sg_dma_buf_size,
-			phba->cfg_total_seg_cnt);
+			phba->cfg_total_seg_cnt,  phba->cfg_scsi_seg_cnt,
+			phba->cfg_nvme_seg_cnt);
 	/* Initialize buffer queue management fields */
 	INIT_LIST_HEAD(&phba->hbqs[LPFC_ELS_HBQ].hbq_buffer_list);
 	if (phba->cfg_fof)
 		fof_vectors = 1;
+	/* Verify RAS support on adapter */
+	lpfc_sli4_ras_init(phba);
 	/* Verify all the SLI4 queues */
 	rc = lpfc_sli4_queue_verify(phba);
 	if (rc)
 	else
 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
 				"3028 GET_FUNCTION_CONFIG: failed to find "
-				"Resrouce Descriptor:x%x\n",
+				"Resource Descriptor:x%x\n",
 				LPFC_RSRC_DESC_TYPE_FCFCOE);
 read_cfg_out:
 	/* Stop kthread signal shall trigger work_done one more time */
 	kthread_stop(phba->worker_thread);
+	/* Disable FW logging to host memory */
+	writel(LPFC_CTL_PDEV_CTL_DDL_RAS,
+	       phba->sli4_hba.conf_regs_memmap_p + LPFC_CTL_PDEV_CTL_OFFSET);
+	/* Free RAS DMA memory */
+	if (phba->ras_fwlog.ras_enabled == true)
+		lpfc_sli4_ras_dma_free(phba);
 	/* Unset the queues shared with the hardware then release all
 	 * allocated resources.
 	 */
 		phba->mds_diags_support = 1;
 	else
 		phba->mds_diags_support = 0;
 	return 0;
 }
 	kfree(phba->vpi_ids);
 	lpfc_stop_hba_timers(phba);
-	spin_lock_irq(&phba->hbalock);
+	spin_lock_irq(&phba->port_list_lock);
 	list_del_init(&vport->listentry);
-	spin_unlock_irq(&phba->hbalock);
+	spin_unlock_irq(&phba->port_list_lock);
 	lpfc_debugfs_terminate(vport);
 	/* Check if there are static vports to be created. */
 	lpfc_create_static_vport(phba);
+	/* Enable RAS FW log support */
+	lpfc_sli4_ras_setup(phba);
 	return 0;
 out_disable_intr:
 	lpfc_sli4_hba_unset(phba);
 	lpfc_stop_hba_timers(phba);
-	spin_lock_irq(&phba->hbalock);
+	spin_lock_irq(&phba->port_list_lock);
 	list_del_init(&vport->listentry);
-	spin_unlock_irq(&phba->hbalock);
+	spin_unlock_irq(&phba->port_list_lock);
 	/* Perform scsi free before driver resource_unset since scsi
 	 * buffers are released to their corresponding pools here.
 	return;
 }
+/**
+ * lpfc_sli4_ras_init - Verify RAS-FW log is supported by this adapter
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine checks to see if RAS is supported by the adapter. Check the
+ * function through which RAS support enablement is to be done.
+ **/
+void
+lpfc_sli4_ras_init(struct lpfc_hba *phba)
+{
+	switch (phba->pcidev->device) {
+	case PCI_DEVICE_ID_LANCER_G6_FC:
+	case PCI_DEVICE_ID_LANCER_G7_FC:
+		phba->ras_fwlog.ras_hwsupport = true;
+		if (phba->cfg_ras_fwlog_func == PCI_FUNC(phba->pcidev->devfn))
+			phba->ras_fwlog.ras_enabled = true;
+		else
+			phba->ras_fwlog.ras_enabled = false;
+		break;
+	default:
+		phba->ras_fwlog.ras_hwsupport = false;
+	}
+}
 /**
  * lpfc_fof_queue_setup - Set up all the fof queues
  * @phba: pointer to lpfc hba data structure.

drivers/scsi/lpfc/lpfc_nportdisc.c+3−0

 	lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
 	spin_lock_irq(shost->host_lock);
 	ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC);
+	ndlp->nlp_fc4_type &= ~(NLP_FC4_FCP | NLP_FC4_NVME);
 	spin_unlock_irq(shost->host_lock);
 	lpfc_disc_set_adisc(vport, ndlp);
 	lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
 	spin_lock_irq(shost->host_lock);
 	ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC);
+	ndlp->nlp_fc4_type &= ~(NLP_FC4_FCP | NLP_FC4_NVME);
 	spin_unlock_irq(shost->host_lock);
 	lpfc_disc_set_adisc(vport, ndlp);
 	return ndlp->nlp_state;
 	lpfc_cancel_retry_delay_tmo(vport, ndlp);
 	spin_lock_irq(shost->host_lock);
 	ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC);
+	ndlp->nlp_fc4_type &= ~(NLP_FC4_FCP | NLP_FC4_NVME);
 	spin_unlock_irq(shost->host_lock);
 	return ndlp->nlp_state;
 }

drivers/scsi/lpfc/lpfc_nvme.c+5−14

 	vport = lport->vport;
 	lpfc_printf_vlog(vport, KERN_INFO, LOG_NVME,
-			"6001 ENTER.  lpfc_pnvme %p, qidx x%xi qhandle %p\n",
+			"6001 ENTER.  lpfc_pnvme %p, qidx x%x qhandle %p\n",
 			lport, qidx, handle);
 	kfree(handle);
 }
 	struct sli4_sge *sgl;
 	dma_addr_t pdma_phys_sgl;
 	uint16_t iotag, lxri = 0;
-	int bcnt, num_posted, sgl_size;
+	int bcnt, num_posted;
 	LIST_HEAD(prep_nblist);
 	LIST_HEAD(post_nblist);
 	LIST_HEAD(nvme_nblist);
-	sgl_size = phba->cfg_sg_dma_buf_size;
 	for (bcnt = 0; bcnt < num_to_alloc; bcnt++) {
 		lpfc_ncmd = kzalloc(sizeof(struct lpfc_nvme_buf), GFP_KERNEL);
 		if (!lpfc_ncmd)
 	nfcp_info.node_name = wwn_to_u64(vport->fc_nodename.u.wwn);
 	nfcp_info.port_name = wwn_to_u64(vport->fc_portname.u.wwn);
-	/* Limit to LPFC_MAX_NVME_SEG_CNT.
+	/* We need to tell the transport layer + 1 because it takes page
-	 * For now need + 1 to get around NVME transport logic.
+	 * alignment into account. When space for the SGL is allocated we
+	 * allocate + 3, one for cmd, one for rsp and one for this alignment
 	 */
-	if (phba->cfg_sg_seg_cnt > LPFC_MAX_NVME_SEG_CNT) {
-		lpfc_printf_vlog(vport, KERN_INFO, LOG_NVME | LOG_INIT,
-				 "6300 Reducing sg segment cnt to %d\n",
-				 LPFC_MAX_NVME_SEG_CNT);
-		phba->cfg_nvme_seg_cnt = LPFC_MAX_NVME_SEG_CNT;
-	} else {
-		phba->cfg_nvme_seg_cnt = phba->cfg_sg_seg_cnt;
-	}
 	lpfc_nvme_template.max_sgl_segments = phba->cfg_nvme_seg_cnt + 1;
 	lpfc_nvme_template.max_hw_queues = phba->cfg_nvme_io_channel;

drivers/scsi/lpfc/lpfc_nvmet.c+6−14

 			idx = 0;
 	}
-	infop = phba->sli4_hba.nvmet_ctx_info;
+	for (i = 0; i < phba->sli4_hba.num_present_cpu; i++) {
-	for (j = 0; j < phba->cfg_nvmet_mrq; j++) {
+		for (j = 0; j < phba->cfg_nvmet_mrq; j++) {
-		for (i = 0; i < phba->sli4_hba.num_present_cpu; i++) {
+			infop = lpfc_get_ctx_list(phba, i, j);
 			lpfc_printf_log(phba, KERN_INFO, LOG_NVME | LOG_INIT,
 					"6408 TOTAL NVMET ctx for CPU %d "
 					"MRQ %d: cnt %d nextcpu %p\n",
 					i, j, infop->nvmet_ctx_list_cnt,
 					infop->nvmet_ctx_next_cpu);
-			infop++;
 		}
 	}
 	return 0;
 	pinfo.port_name = wwn_to_u64(vport->fc_portname.u.wwn);
 	pinfo.port_id = vport->fc_myDID;
-	/* Limit to LPFC_MAX_NVME_SEG_CNT.
+	/* We need to tell the transport layer + 1 because it takes page
-	 * For now need + 1 to get around NVME transport logic.
+	 * alignment into account. When space for the SGL is allocated we
+	 * allocate + 3, one for cmd, one for rsp and one for this alignment
 	 */
-	if (phba->cfg_sg_seg_cnt > LPFC_MAX_NVME_SEG_CNT) {
-		lpfc_printf_log(phba, KERN_INFO, LOG_NVME | LOG_INIT,
-				"6400 Reducing sg segment cnt to %d\n",
-				LPFC_MAX_NVME_SEG_CNT);
-		phba->cfg_nvme_seg_cnt = LPFC_MAX_NVME_SEG_CNT;
-	} else {
-		phba->cfg_nvme_seg_cnt = phba->cfg_sg_seg_cnt;
-	}
 	lpfc_tgttemplate.max_sgl_segments = phba->cfg_nvme_seg_cnt + 1;
 	lpfc_tgttemplate.max_hw_queues = phba->cfg_nvme_io_channel;
 	lpfc_tgttemplate.target_features = NVMET_FCTGTFEAT_READDATA_RSP;

drivers/scsi/lpfc/lpfc_scsi.c+22−12

 static void
 lpfc_update_stats(struct lpfc_hba *phba, struct  lpfc_scsi_buf *lpfc_cmd)
 {
-	struct lpfc_rport_data *rdata = lpfc_cmd->rdata;
+	struct lpfc_rport_data *rdata;
-	struct lpfc_nodelist *pnode = rdata->pnode;
+	struct lpfc_nodelist *pnode;
 	struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
 	unsigned long flags;
 	struct Scsi_Host  *shost = cmd->device->host;
 	unsigned long latency;
 	int i;
-	if (cmd->result)
+	if (!vport->stat_data_enabled ||
+	    vport->stat_data_blocked ||
+	    (cmd->result))
 		return;
 	latency = jiffies_to_msecs((long)jiffies - (long)lpfc_cmd->start_time);
+	rdata = lpfc_cmd->rdata;
+	pnode = rdata->pnode;
 	spin_lock_irqsave(shost->host_lock, flags);
-	if (!vport->stat_data_enabled ||
+	if (!pnode ||
-		vport->stat_data_blocked ||
+	    !pnode->lat_data ||
-		!pnode ||
+	    (phba->bucket_type == LPFC_NO_BUCKET)) {
-		!pnode->lat_data ||
-		(phba->bucket_type == LPFC_NO_BUCKET)) {
 		spin_unlock_irqrestore(shost->host_lock, flags);
 		return;
 	}
 	if (!found)
 		return NULL;
-	if (lpfc_ndlp_check_qdepth(phba, ndlp) && lpfc_cmd) {
+	if (lpfc_ndlp_check_qdepth(phba, ndlp)) {
 		atomic_inc(&ndlp->cmd_pending);
 		lpfc_cmd->flags |= LPFC_SBUF_BUMP_QDEPTH;
 	}
 	}
 	lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
-	spin_lock_irqsave(&phba->hbalock, flags);
+	/* If pCmd was set to NULL from abort path, do not call scsi_done */
-	lpfc_cmd->pCmd = NULL;
+	if (xchg(&lpfc_cmd->pCmd, NULL) == NULL) {
-	spin_unlock_irqrestore(&phba->hbalock, flags);
+		lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
+				 "0711 FCP cmd already NULL, sid: 0x%06x, "
+				 "did: 0x%06x, oxid: 0x%04x\n",
+				 vport->fc_myDID,
+				 (pnode) ? pnode->nlp_DID : 0,
+				 phba->sli_rev == LPFC_SLI_REV4 ?
+				 lpfc_cmd->cur_iocbq.sli4_xritag : 0xffff);
+		return;
+	}
 	/* The sdev is not guaranteed to be valid post scsi_done upcall. */
 	cmd->scsi_done(cmd);

drivers/scsi/lpfc/lpfc_sli.c+297−13

@@ -392,11 +392,7 @@ lpfc_sli4_if6_eq_clr_intr(struct lpfc_queue *q) · 391 unmodified lines
392	struct lpfc_register doorbell;	392	struct lpfc_register doorbell;
393		393
394	doorbell.word0 = 0;	394	doorbell.word0 = 0;
395	bf_set(lpfc_eqcq_doorbell_eqci, &doorbell, 1);	395	bf_set(lpfc_if6_eq_doorbell_eqid, &doorbell, q->queue_id);
396	bf_set(lpfc_eqcq_doorbell_qt, &doorbell, LPFC_QUEUE_TYPE_EVENT);
397	bf_set(lpfc_eqcq_doorbell_eqid_hi, &doorbell,
398	(q->queue_id >> LPFC_EQID_HI_FIELD_SHIFT));
399	bf_set(lpfc_eqcq_doorbell_eqid_lo, &doorbell, q->queue_id);
400	writel(doorbell.word0, q->phba->sli4_hba.EQDBregaddr);	396	writel(doorbell.word0, q->phba->sli4_hba.EQDBregaddr);
401	}	397	}
402		398
@@ -3797,6 +3793,7 @@ lpfc_sli_handle_slow_ring_event_s4(struct lpfc_hba *phba, · 3394 unmodified lines
3797	struct hbq_dmabuf *dmabuf;	3793	struct hbq_dmabuf *dmabuf;
3798	struct lpfc_cq_event *cq_event;	3794	struct lpfc_cq_event *cq_event;
3799	unsigned long iflag;	3795	unsigned long iflag;
		3796	int count = 0;
3800		3797
3801	spin_lock_irqsave(&phba->hbalock, iflag);	3798	spin_lock_irqsave(&phba->hbalock, iflag);
3802	phba->hba_flag &= ~HBA_SP_QUEUE_EVT;	3799	phba->hba_flag &= ~HBA_SP_QUEUE_EVT;
@@ -3818,16 +3815,22 @@ lpfc_sli_handle_slow_ring_event_s4(struct lpfc_hba *phba, · 15 unmodified lines
3818	if (irspiocbq)	3815	if (irspiocbq)
3819	lpfc_sli_sp_handle_rspiocb(phba, pring,	3816	lpfc_sli_sp_handle_rspiocb(phba, pring,
3820	irspiocbq);	3817	irspiocbq);
		3818	count++;
3821	break;	3819	break;
3822	case CQE_CODE_RECEIVE:	3820	case CQE_CODE_RECEIVE:
3823	case CQE_CODE_RECEIVE_V1:	3821	case CQE_CODE_RECEIVE_V1:
3824	dmabuf = container_of(cq_event, struct hbq_dmabuf,	3822	dmabuf = container_of(cq_event, struct hbq_dmabuf,
3825	cq_event);	3823	cq_event);
3826	lpfc_sli4_handle_received_buffer(phba, dmabuf);	3824	lpfc_sli4_handle_received_buffer(phba, dmabuf);
		3825	count++;
3827	break;	3826	break;
3828	default:	3827	default:
3829	break;	3828	break;
3830	}	3829	}
		3830
		3831	/* Limit the number of events to 64 to avoid soft lockups */
		3832	if (count == 64)
		3833	break;
3831	}	3834	}
3832	}	3835	}
3833		3836
@@ -6145,6 +6148,271 @@ lpfc_set_features(struct lpfc_hba phba, LPFC_MBOXQ_t mbox, · 2311 unmodified lines
6145	return;	6148	return;
6146	}	6149	}
6147		6150
		6151	/**
		6152	* lpfc_sli4_ras_dma_free - Free memory allocated for FW logging.
		6153	* @phba: Pointer to HBA context object.
		6154	*
		6155	* This function is called to free memory allocated for RAS FW logging
		6156	* support in the driver.
		6157	**/
		6158	void
		6159	lpfc_sli4_ras_dma_free(struct lpfc_hba *phba)
		6160	{
		6161	struct lpfc_ras_fwlog *ras_fwlog = &phba->ras_fwlog;
		6162	struct lpfc_dmabuf dmabuf, next;
		6163
		6164	if (!list_empty(&ras_fwlog->fwlog_buff_list)) {
		6165	list_for_each_entry_safe(dmabuf, next,
		6166	&ras_fwlog->fwlog_buff_list,
		6167	list) {
		6168	list_del(&dmabuf->list);
		6169	dma_free_coherent(&phba->pcidev->dev,
		6170	LPFC_RAS_MAX_ENTRY_SIZE,
		6171	dmabuf->virt, dmabuf->phys);
		6172	kfree(dmabuf);
		6173	}
		6174	}
		6175
		6176	if (ras_fwlog->lwpd.virt) {
		6177	dma_free_coherent(&phba->pcidev->dev,
		6178	sizeof(uint32_t) * 2,
		6179	ras_fwlog->lwpd.virt,
		6180	ras_fwlog->lwpd.phys);
		6181	ras_fwlog->lwpd.virt = NULL;
		6182	}
		6183
		6184	ras_fwlog->ras_active = false;
		6185	}
		6186
		6187	/**
		6188	* lpfc_sli4_ras_dma_alloc: Allocate memory for FW support
		6189	* @phba: Pointer to HBA context object.
		6190	* @fwlog_buff_count: Count of buffers to be created.
		6191	*
		6192	* This routine DMA memory for Log Write Position Data[LPWD] and buffer
		6193	* to update FW log is posted to the adapter.
		6194	* Buffer count is calculated based on module param ras_fwlog_buffsize
		6195	* Size of each buffer posted to FW is 64K.
		6196	**/
		6197
		6198	static int
		6199	lpfc_sli4_ras_dma_alloc(struct lpfc_hba *phba,
		6200	uint32_t fwlog_buff_count)
		6201	{
		6202	struct lpfc_ras_fwlog *ras_fwlog = &phba->ras_fwlog;
		6203	struct lpfc_dmabuf *dmabuf;
		6204	int rc = 0, i = 0;
		6205
		6206	/* Initialize List */
		6207	INIT_LIST_HEAD(&ras_fwlog->fwlog_buff_list);
		6208
		6209	/* Allocate memory for the LWPD */
		6210	ras_fwlog->lwpd.virt = dma_alloc_coherent(&phba->pcidev->dev,
		6211	sizeof(uint32_t) * 2,
		6212	&ras_fwlog->lwpd.phys,
		6213	GFP_KERNEL);
		6214	if (!ras_fwlog->lwpd.virt) {
		6215	lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
		6216	"6185 LWPD Memory Alloc Failed\n");
		6217
		6218	return -ENOMEM;
		6219	}
		6220
		6221	ras_fwlog->fw_buffcount = fwlog_buff_count;
		6222	for (i = 0; i < ras_fwlog->fw_buffcount; i++) {
		6223	dmabuf = kzalloc(sizeof(struct lpfc_dmabuf),
		6224	GFP_KERNEL);
		6225	if (!dmabuf) {
		6226	rc = -ENOMEM;
		6227	lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
		6228	"6186 Memory Alloc failed FW logging");
		6229	goto free_mem;
		6230	}
		6231
		6232	dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev,
		6233	LPFC_RAS_MAX_ENTRY_SIZE,
		6234	&dmabuf->phys,
		6235	GFP_KERNEL);
		6236	if (!dmabuf->virt) {
		6237	kfree(dmabuf);
		6238	rc = -ENOMEM;
		6239	lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
		6240	"6187 DMA Alloc Failed FW logging");
		6241	goto free_mem;
		6242	}
		6243	memset(dmabuf->virt, 0, LPFC_RAS_MAX_ENTRY_SIZE);
		6244	dmabuf->buffer_tag = i;
		6245	list_add_tail(&dmabuf->list, &ras_fwlog->fwlog_buff_list);
		6246	}
		6247
		6248	free_mem:
		6249	if (rc)
		6250	lpfc_sli4_ras_dma_free(phba);
		6251
		6252	return rc;
		6253	}
		6254
		6255	/**
		6256	* lpfc_sli4_ras_mbox_cmpl: Completion handler for RAS MBX command
		6257	* @phba: pointer to lpfc hba data structure.
		6258	* @pmboxq: pointer to the driver internal queue element for mailbox command.
		6259	*
		6260	* Completion handler for driver's RAS MBX command to the device.
		6261	**/
		6262	static void
		6263	lpfc_sli4_ras_mbox_cmpl(struct lpfc_hba phba, LPFC_MBOXQ_t pmb)
		6264	{
		6265	MAILBOX_t *mb;
		6266	union lpfc_sli4_cfg_shdr *shdr;
		6267	uint32_t shdr_status, shdr_add_status;
		6268	struct lpfc_ras_fwlog *ras_fwlog = &phba->ras_fwlog;
		6269
		6270	mb = &pmb->u.mb;
		6271
		6272	shdr = (union lpfc_sli4_cfg_shdr *)
		6273	&pmb->u.mqe.un.ras_fwlog.header.cfg_shdr;
		6274	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
		6275	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
		6276
		6277	if (mb->mbxStatus != MBX_SUCCESS \|\| shdr_status) {
		6278	lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX,
		6279	"6188 FW LOG mailbox "
		6280	"completed with status x%x add_status x%x,"
		6281	" mbx status x%x\n",
		6282	shdr_status, shdr_add_status, mb->mbxStatus);
		6283	goto disable_ras;
		6284	}
		6285
		6286	ras_fwlog->ras_active = true;
		6287	mempool_free(pmb, phba->mbox_mem_pool);
		6288
		6289	return;
		6290
		6291	disable_ras:
		6292	/* Free RAS DMA memory */
		6293	lpfc_sli4_ras_dma_free(phba);
		6294	mempool_free(pmb, phba->mbox_mem_pool);
		6295	}
		6296
		6297	/**
		6298	* lpfc_sli4_ras_fwlog_init: Initialize memory and post RAS MBX command
		6299	* @phba: pointer to lpfc hba data structure.
		6300	* @fwlog_level: Logging verbosity level.
		6301	* @fwlog_enable: Enable/Disable logging.
		6302	*
		6303	* Initialize memory and post mailbox command to enable FW logging in host
		6304	* memory.
		6305	**/
		6306	int
		6307	lpfc_sli4_ras_fwlog_init(struct lpfc_hba *phba,
		6308	uint32_t fwlog_level,
		6309	uint32_t fwlog_enable)
		6310	{
		6311	struct lpfc_ras_fwlog *ras_fwlog = &phba->ras_fwlog;
		6312	struct lpfc_mbx_set_ras_fwlog *mbx_fwlog = NULL;
		6313	struct lpfc_dmabuf *dmabuf;
		6314	LPFC_MBOXQ_t *mbox;
		6315	uint32_t len = 0, fwlog_buffsize, fwlog_entry_count;
		6316	int rc = 0;
		6317
		6318	fwlog_buffsize = (LPFC_RAS_MIN_BUFF_POST_SIZE *
		6319	phba->cfg_ras_fwlog_buffsize);
		6320	fwlog_entry_count = (fwlog_buffsize/LPFC_RAS_MAX_ENTRY_SIZE);
		6321
		6322	/*
		6323	* If re-enabling FW logging support use earlier allocated
		6324	* DMA buffers while posting MBX command.
		6325	**/
		6326	if (!ras_fwlog->lwpd.virt) {
		6327	rc = lpfc_sli4_ras_dma_alloc(phba, fwlog_entry_count);
		6328	if (rc) {
		6329	lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
		6330	"6189 RAS FW Log Support Not Enabled");
		6331	return rc;
		6332	}
		6333	}
		6334
		6335	/* Setup Mailbox command */
		6336	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
		6337	if (!mbox) {
		6338	lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
		6339	"6190 RAS MBX Alloc Failed");
		6340	rc = -ENOMEM;
		6341	goto mem_free;
		6342	}
		6343
		6344	ras_fwlog->fw_loglevel = fwlog_level;
		6345	len = (sizeof(struct lpfc_mbx_set_ras_fwlog) -
		6346	sizeof(struct lpfc_sli4_cfg_mhdr));
		6347
		6348	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_LOWLEVEL,
		6349	LPFC_MBOX_OPCODE_SET_DIAG_LOG_OPTION,
		6350	len, LPFC_SLI4_MBX_EMBED);
		6351
		6352	mbx_fwlog = (struct lpfc_mbx_set_ras_fwlog *)&mbox->u.mqe.un.ras_fwlog;
		6353	bf_set(lpfc_fwlog_enable, &mbx_fwlog->u.request,
		6354	fwlog_enable);
		6355	bf_set(lpfc_fwlog_loglvl, &mbx_fwlog->u.request,
		6356	ras_fwlog->fw_loglevel);
		6357	bf_set(lpfc_fwlog_buffcnt, &mbx_fwlog->u.request,
		6358	ras_fwlog->fw_buffcount);
		6359	bf_set(lpfc_fwlog_buffsz, &mbx_fwlog->u.request,
		6360	LPFC_RAS_MAX_ENTRY_SIZE/SLI4_PAGE_SIZE);
		6361
		6362	/* Update DMA buffer address */
		6363	list_for_each_entry(dmabuf, &ras_fwlog->fwlog_buff_list, list) {
		6364	memset(dmabuf->virt, 0, LPFC_RAS_MAX_ENTRY_SIZE);
		6365
		6366	mbx_fwlog->u.request.buff_fwlog[dmabuf->buffer_tag].addr_lo =
		6367	putPaddrLow(dmabuf->phys);
		6368
		6369	mbx_fwlog->u.request.buff_fwlog[dmabuf->buffer_tag].addr_hi =
		6370	putPaddrHigh(dmabuf->phys);
		6371	}
		6372
		6373	/* Update LPWD address */
		6374	mbx_fwlog->u.request.lwpd.addr_lo = putPaddrLow(ras_fwlog->lwpd.phys);
		6375	mbx_fwlog->u.request.lwpd.addr_hi = putPaddrHigh(ras_fwlog->lwpd.phys);
		6376
		6377	mbox->vport = phba->pport;
		6378	mbox->mbox_cmpl = lpfc_sli4_ras_mbox_cmpl;
		6379
		6380	rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
		6381
		6382	if (rc == MBX_NOT_FINISHED) {
		6383	lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
		6384	"6191 RAS Mailbox failed. "
		6385	"status %d mbxStatus : x%x", rc,
		6386	bf_get(lpfc_mqe_status, &mbox->u.mqe));
		6387	mempool_free(mbox, phba->mbox_mem_pool);
		6388	rc = -EIO;
		6389	goto mem_free;
		6390	} else
		6391	rc = 0;
		6392	mem_free:
		6393	if (rc)
		6394	lpfc_sli4_ras_dma_free(phba);
		6395
		6396	return rc;
		6397	}
		6398
		6399	/**
		6400	* lpfc_sli4_ras_setup - Check if RAS supported on the adapter
		6401	* @phba: Pointer to HBA context object.
		6402	*
		6403	* Check if RAS is supported on the adapter and initialize it.
		6404	**/
		6405	void
		6406	lpfc_sli4_ras_setup(struct lpfc_hba *phba)
		6407	{
		6408	/* Check RAS FW Log needs to be enabled or not */
		6409	if (lpfc_check_fwlog_support(phba))
		6410	return;
		6411
		6412	lpfc_sli4_ras_fwlog_init(phba, phba->cfg_ras_fwlog_level,
		6413	LPFC_RAS_ENABLE_LOGGING);
		6414	}
		6415
6148	/**	6416	/**
6149	* lpfc_sli4_alloc_resource_identifiers - Allocate all SLI4 resource extents.	6417	* lpfc_sli4_alloc_resource_identifiers - Allocate all SLI4 resource extents.
6150	* @phba: Pointer to HBA context object.	6418	* @phba: Pointer to HBA context object.
@@ -10266,8 +10534,12 @@ lpfc_sli_mbox_sys_flush(struct lpfc_hba *phba) · 4115 unmodified lines
10266	LPFC_MBOXQ_t *pmb;	10534	LPFC_MBOXQ_t *pmb;
10267	unsigned long iflag;	10535	unsigned long iflag;
10268		10536
		10537	/* Disable softirqs, including timers from obtaining phba->hbalock */
		10538	local_bh_disable();
		10539
10269	/* Flush all the mailbox commands in the mbox system */	10540	/* Flush all the mailbox commands in the mbox system */
10270	spin_lock_irqsave(&phba->hbalock, iflag);	10541	spin_lock_irqsave(&phba->hbalock, iflag);
		10542
10271	/* The pending mailbox command queue */	10543	/* The pending mailbox command queue */
10272	list_splice_init(&phba->sli.mboxq, &completions);	10544	list_splice_init(&phba->sli.mboxq, &completions);
10273	/* The outstanding active mailbox command */	10545	/* The outstanding active mailbox command */
@@ -10280,6 +10552,9 @@ lpfc_sli_mbox_sys_flush(struct lpfc_hba *phba) · 6 unmodified lines
10280	list_splice_init(&phba->sli.mboxq_cmpl, &completions);	10552	list_splice_init(&phba->sli.mboxq_cmpl, &completions);
10281	spin_unlock_irqrestore(&phba->hbalock, iflag);	10553	spin_unlock_irqrestore(&phba->hbalock, iflag);
10282		10554
		10555	/* Enable softirqs again, done with phba->hbalock */
		10556	local_bh_enable();
		10557
10283	/* Return all flushed mailbox commands with MBX_NOT_FINISHED status */	10558	/* Return all flushed mailbox commands with MBX_NOT_FINISHED status */
10284	while (!list_empty(&completions)) {	10559	while (!list_empty(&completions)) {
10285	list_remove_head(&completions, pmb, LPFC_MBOXQ_t, list);	10560	list_remove_head(&completions, pmb, LPFC_MBOXQ_t, list);
@@ -10419,6 +10694,9 @@ lpfc_sli_hba_down(struct lpfc_hba *phba) · 133 unmodified lines
10419		10694
10420	lpfc_hba_down_prep(phba);	10695	lpfc_hba_down_prep(phba);
10421		10696
		10697	/* Disable softirqs, including timers from obtaining phba->hbalock */
		10698	local_bh_disable();
		10699
10422	lpfc_fabric_abort_hba(phba);	10700	lpfc_fabric_abort_hba(phba);
10423		10701
10424	spin_lock_irqsave(&phba->hbalock, flags);	10702	spin_lock_irqsave(&phba->hbalock, flags);
@@ -10472,6 +10750,9 @@ lpfc_sli_hba_down(struct lpfc_hba *phba) · 47 unmodified lines
10472	kfree(buf_ptr);	10750	kfree(buf_ptr);
10473	}	10751	}
10474		10752
		10753	/* Enable softirqs again, done with phba->hbalock */
		10754	local_bh_enable();
		10755
10475	/* Return any active mbox cmds */	10756	/* Return any active mbox cmds */
10476	del_timer_sync(&psli->mbox_tmo);	10757	del_timer_sync(&psli->mbox_tmo);
10477		10758
@@ -11775,6 +12056,9 @@ lpfc_sli_mbox_sys_shutdown(struct lpfc_hba *phba, int mbx_action) · 1297 unmodified lines
11775	}	12056	}
11776	timeout = msecs_to_jiffies(LPFC_MBOX_TMO * 1000) + jiffies;	12057	timeout = msecs_to_jiffies(LPFC_MBOX_TMO * 1000) + jiffies;
11777		12058
		12059	/* Disable softirqs, including timers from obtaining phba->hbalock */
		12060	local_bh_disable();
		12061
11778	spin_lock_irq(&phba->hbalock);	12062	spin_lock_irq(&phba->hbalock);
11779	psli->sli_flag \|= LPFC_SLI_ASYNC_MBX_BLK;	12063	psli->sli_flag \|= LPFC_SLI_ASYNC_MBX_BLK;
11780		12064
@@ -11788,6 +12072,9 @@ lpfc_sli_mbox_sys_shutdown(struct lpfc_hba *phba, int mbx_action) · 7 unmodified lines
11788	1000) + jiffies;	12072	1000) + jiffies;
11789	spin_unlock_irq(&phba->hbalock);	12073	spin_unlock_irq(&phba->hbalock);
11790		12074
		12075	/* Enable softirqs again, done with phba->hbalock */
		12076	local_bh_enable();
		12077
11791	while (phba->sli.mbox_active) {	12078	while (phba->sli.mbox_active) {
11792	/* Check active mailbox complete status every 2ms */	12079	/* Check active mailbox complete status every 2ms */
11793	msleep(2);	12080	msleep(2);
@@ -11797,9 +12084,13 @@ lpfc_sli_mbox_sys_shutdown(struct lpfc_hba *phba, int mbx_action) · 3 unmodified lines
11797	*/	12084	*/
11798	break;	12085	break;
11799	}	12086	}
11800	} else	12087	} else {
11801	spin_unlock_irq(&phba->hbalock);	12088	spin_unlock_irq(&phba->hbalock);
11802		12089
		12090	/* Enable softirqs again, done with phba->hbalock */
		12091	local_bh_enable();
		12092	}
		12093
11803	lpfc_sli_mbox_sys_flush(phba);	12094	lpfc_sli_mbox_sys_flush(phba);
11804	}	12095	}
11805		12096
@@ -13136,7 +13427,6 @@ static bool · 1330 unmodified lines
13136	lpfc_sli4_sp_handle_rcqe(struct lpfc_hba phba, struct lpfc_rcqe rcqe)	13427	lpfc_sli4_sp_handle_rcqe(struct lpfc_hba phba, struct lpfc_rcqe rcqe)
13137	{	13428	{
13138	bool workposted = false;	13429	bool workposted = false;
13139	struct fc_frame_header *fc_hdr;
13140	struct lpfc_queue *hrq = phba->sli4_hba.hdr_rq;	13430	struct lpfc_queue *hrq = phba->sli4_hba.hdr_rq;
13141	struct lpfc_queue *drq = phba->sli4_hba.dat_rq;	13431	struct lpfc_queue *drq = phba->sli4_hba.dat_rq;
13142	struct lpfc_nvmet_tgtport *tgtp;	13432	struct lpfc_nvmet_tgtport *tgtp;
@@ -13173,9 +13463,6 @@ lpfc_sli4_sp_handle_rcqe(struct lpfc_hba phba, struct lpfc_rcqe rcqe) · 30 unmodified lines
13173	hrq->RQ_buf_posted--;	13463	hrq->RQ_buf_posted--;
13174	memcpy(&dma_buf->cq_event.cqe.rcqe_cmpl, rcqe, sizeof(*rcqe));	13464	memcpy(&dma_buf->cq_event.cqe.rcqe_cmpl, rcqe, sizeof(*rcqe));
13175		13465
13176	/* If a NVME LS event (type 0x28), treat it as Fast path */
13177	fc_hdr = (struct fc_frame_header *)dma_buf->hbuf.virt;
13178
13179	/* save off the frame for the word thread to process */	13466	/* save off the frame for the word thread to process */
13180	list_add_tail(&dma_buf->cq_event.list,	13467	list_add_tail(&dma_buf->cq_event.list,
13181	&phba->sli4_hba.sp_queue_event);	13468	&phba->sli4_hba.sp_queue_event);
@@ -14558,13 +14845,10 @@ lpfc_cq_create(struct lpfc_hba phba, struct lpfc_queue cq, · 1376 unmodified lines
14558	int rc, length, status = 0;	14845	int rc, length, status = 0;
14559	uint32_t shdr_status, shdr_add_status;	14846	uint32_t shdr_status, shdr_add_status;
14560	union lpfc_sli4_cfg_shdr *shdr;	14847	union lpfc_sli4_cfg_shdr *shdr;
14561	uint32_t hw_page_size = phba->sli4_hba.pc_sli4_params.if_page_sz;
14562		14848
14563	/* sanity check on queue memory */	14849	/* sanity check on queue memory */
14564	if (!cq \|\| !eq)	14850	if (!cq \|\| !eq)
14565	return -ENODEV;	14851	return -ENODEV;
14566	if (!phba->sli4_hba.pc_sli4_params.supported)
14567	hw_page_size = cq->page_size;
14568		14852
14569	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);	14853	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
14570	if (!mbox)	14854	if (!mbox)

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

@@ -886,3 +886,4 @@ int lpfc_sli4_unregister_fcf(struct lpfc_hba *); · 885 unmodified lines
886	int lpfc_sli4_post_status_check(struct lpfc_hba *);	886	int lpfc_sli4_post_status_check(struct lpfc_hba *);
887	uint8_t lpfc_sli_config_mbox_subsys_get(struct lpfc_hba , LPFC_MBOXQ_t );	887	uint8_t lpfc_sli_config_mbox_subsys_get(struct lpfc_hba , LPFC_MBOXQ_t );
888	uint8_t lpfc_sli_config_mbox_opcode_get(struct lpfc_hba , LPFC_MBOXQ_t );	888	uint8_t lpfc_sli_config_mbox_opcode_get(struct lpfc_hba , LPFC_MBOXQ_t );
		889	void lpfc_sli4_ras_dma_free(struct lpfc_hba *phba);

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.0.0.6"	23	#define LPFC_DRIVER_VERSION "12.0.0.7"
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+7−7

@@ -207,7 +207,7 @@ lpfc_unique_wwpn(struct lpfc_hba phba, struct lpfc_vport new_vport) · 206 unmodified lines
207	struct lpfc_vport *vport;	207	struct lpfc_vport *vport;
208	unsigned long flags;	208	unsigned long flags;
209		209
210	spin_lock_irqsave(&phba->hbalock, flags);	210	spin_lock_irqsave(&phba->port_list_lock, flags);
211	list_for_each_entry(vport, &phba->port_list, listentry) {	211	list_for_each_entry(vport, &phba->port_list, listentry) {
212	if (vport == new_vport)	212	if (vport == new_vport)
213	continue;	213	continue;
@@ -215,11 +215,11 @@ lpfc_unique_wwpn(struct lpfc_hba phba, struct lpfc_vport new_vport) · 1 unmodified line
215	if (memcmp(&vport->fc_sparam.portName,	215	if (memcmp(&vport->fc_sparam.portName,
216	&new_vport->fc_sparam.portName,	216	&new_vport->fc_sparam.portName,
217	sizeof(struct lpfc_name)) == 0) {	217	sizeof(struct lpfc_name)) == 0) {
218	spin_unlock_irqrestore(&phba->hbalock, flags);	218	spin_unlock_irqrestore(&phba->port_list_lock, flags);
219	return 0;	219	return 0;
220	}	220	}
221	}	221	}
222	spin_unlock_irqrestore(&phba->hbalock, flags);	222	spin_unlock_irqrestore(&phba->port_list_lock, flags);
223	return 1;	223	return 1;
224	}	224	}
225		225
@@ -825,9 +825,9 @@ skip_logo: · 599 unmodified lines
825		825
826	lpfc_free_vpi(phba, vport->vpi);	826	lpfc_free_vpi(phba, vport->vpi);
827	vport->work_port_events = 0;	827	vport->work_port_events = 0;
828	spin_lock_irq(&phba->hbalock);	828	spin_lock_irq(&phba->port_list_lock);
829	list_del_init(&vport->listentry);	829	list_del_init(&vport->listentry);
830	spin_unlock_irq(&phba->hbalock);	830	spin_unlock_irq(&phba->port_list_lock);
831	lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,	831	lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
832	"1828 Vport Deleted.\n");	832	"1828 Vport Deleted.\n");
833	scsi_host_put(shost);	833	scsi_host_put(shost);
@@ -844,7 +844,7 @@ lpfc_create_vport_work_array(struct lpfc_hba *phba) · 10 unmodified lines
844	GFP_KERNEL);	844	GFP_KERNEL);
845	if (vports == NULL)	845	if (vports == NULL)
846	return NULL;	846	return NULL;
847	spin_lock_irq(&phba->hbalock);	847	spin_lock_irq(&phba->port_list_lock);
848	list_for_each_entry(port_iterator, &phba->port_list, listentry) {	848	list_for_each_entry(port_iterator, &phba->port_list, listentry) {
849	if (port_iterator->load_flag & FC_UNLOADING)	849	if (port_iterator->load_flag & FC_UNLOADING)
850	continue;	850	continue;
@@ -856,7 +856,7 @@ lpfc_create_vport_work_array(struct lpfc_hba *phba) · 5 unmodified lines
856	}	856	}
857	vports[index++] = port_iterator;	857	vports[index++] = port_iterator;
858	}	858	}
859	spin_unlock_irq(&phba->hbalock);	859	spin_unlock_irq(&phba->port_list_lock);
860	return vports;	860	return vports;
861	}	861	}
862		862

drivers/scsi/mac_esp.c+11−206

@@ -52,14 +52,12 @@ struct mac_esp_priv { · 51 unmodified lines
52	struct esp *esp;	52	struct esp *esp;
53	void __iomem *pdma_regs;	53	void __iomem *pdma_regs;
54	void __iomem *pdma_io;	54	void __iomem *pdma_io;
55	int error;
56	};	55	};
57	static struct esp *esp_chips[2];	56	static struct esp *esp_chips[2];
58	static DEFINE_SPINLOCK(esp_chips_lock);	57	static DEFINE_SPINLOCK(esp_chips_lock);
59		58
60	#define MAC_ESP_GET_PRIV(esp) ((struct mac_esp_priv *) \	59	#define MAC_ESP_GET_PRIV(esp) ((struct mac_esp_priv *) \
61	platform_get_drvdata((struct platform_device *) \	60	dev_get_drvdata((esp)->dev))
62	(esp->dev)))
63		61
64	static inline void mac_esp_write8(struct esp *esp, u8 val, unsigned long reg)	62	static inline void mac_esp_write8(struct esp *esp, u8 val, unsigned long reg)
65	{	63	{
@@ -71,38 +69,6 @@ static inline u8 mac_esp_read8(struct esp *esp, unsigned long reg) · 5 unmodified lines
71	return nubus_readb(esp->regs + reg * 16);	69	return nubus_readb(esp->regs + reg * 16);
72	}	70	}
73		71
74	/* For pseudo DMA and PIO we need the virtual address
75	* so this address mapping is the identity mapping.
76	*/
77
78	static dma_addr_t mac_esp_map_single(struct esp esp, void buf,
79	size_t sz, int dir)
80	{
81	return (dma_addr_t)buf;
82	}
83
84	static int mac_esp_map_sg(struct esp esp, struct scatterlist sg,
85	int num_sg, int dir)
86	{
87	int i;
88
89	for (i = 0; i < num_sg; i++)
90	sg[i].dma_address = (u32)sg_virt(&sg[i]);
91	return num_sg;
92	}
93
94	static void mac_esp_unmap_single(struct esp *esp, dma_addr_t addr,
95	size_t sz, int dir)
96	{
97	/* Nothing to do. */
98	}
99
100	static void mac_esp_unmap_sg(struct esp esp, struct scatterlist sg,
101	int num_sg, int dir)
102	{
103	/* Nothing to do. */
104	}
105
106	static void mac_esp_reset_dma(struct esp *esp)	72	static void mac_esp_reset_dma(struct esp *esp)
107	{	73	{
108	/* Nothing to do. */	74	/* Nothing to do. */
@@ -120,12 +86,11 @@ static void mac_esp_dma_invalidate(struct esp *esp) · 11 unmodified lines
120		86
121	static int mac_esp_dma_error(struct esp *esp)	87	static int mac_esp_dma_error(struct esp *esp)
122	{	88	{
123	return MAC_ESP_GET_PRIV(esp)->error;	89	return esp->send_cmd_error;
124	}	90	}
125		91
126	static inline int mac_esp_wait_for_empty_fifo(struct esp *esp)	92	static inline int mac_esp_wait_for_empty_fifo(struct esp *esp)
127	{	93	{
128	struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
129	int i = 500000;	94	int i = 500000;
130		95
131	do {	96	do {
@@ -140,7 +105,7 @@ static inline int mac_esp_wait_for_empty_fifo(struct esp *esp) · 8 unmodified lines
140		105
141	printk(KERN_ERR PFX "FIFO is not empty (sreg %02x)\n",	106	printk(KERN_ERR PFX "FIFO is not empty (sreg %02x)\n",
142	esp_read8(ESP_STATUS));	107	esp_read8(ESP_STATUS));
143	mep->error = 1;	108	esp->send_cmd_error = 1;
144	return 1;	109	return 1;
145	}	110	}
146		111
@@ -166,7 +131,7 @@ static inline int mac_esp_wait_for_dreq(struct esp *esp) · 19 unmodified lines
166		131
167	printk(KERN_ERR PFX "PDMA timeout (sreg %02x)\n",	132	printk(KERN_ERR PFX "PDMA timeout (sreg %02x)\n",
168	esp_read8(ESP_STATUS));	133	esp_read8(ESP_STATUS));
169	mep->error = 1;	134	esp->send_cmd_error = 1;
170	return 1;	135	return 1;
171	}	136	}
172		137
@@ -233,7 +198,7 @@ static void mac_esp_send_pdma_cmd(struct esp *esp, u32 addr, u32 esp_count, · 60 unmodified lines
233	{	198	{
234	struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);	199	struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
235		200
236	mep->error = 0;	201	esp->send_cmd_error = 0;
237		202
238	if (!write)	203	if (!write)
239	scsi_esp_cmd(esp, ESP_CMD_FLUSH);	204	scsi_esp_cmd(esp, ESP_CMD_FLUSH);
@@ -271,164 +236,6 @@ static void mac_esp_send_pdma_cmd(struct esp *esp, u32 addr, u32 esp_count, · 31 unmodified lines
271	} while (esp_count);	236	} while (esp_count);
272	}	237	}
273		238
274	/*
275	* Programmed IO routines follow.
276	*/
277
278	static inline unsigned int mac_esp_wait_for_fifo(struct esp *esp)
279	{
280	int i = 500000;
281
282	do {
283	unsigned int fbytes = esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES;
284
285	if (fbytes)
286	return fbytes;
287
288	udelay(2);
289	} while (--i);
290
291	printk(KERN_ERR PFX "FIFO is empty (sreg %02x)\n",
292	esp_read8(ESP_STATUS));
293	return 0;
294	}
295
296	static inline int mac_esp_wait_for_intr(struct esp *esp)
297	{
298	struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
299	int i = 500000;
300
301	do {
302	esp->sreg = esp_read8(ESP_STATUS);
303	if (esp->sreg & ESP_STAT_INTR)
304	return 0;
305
306	udelay(2);
307	} while (--i);
308
309	printk(KERN_ERR PFX "IRQ timeout (sreg %02x)\n", esp->sreg);
310	mep->error = 1;
311	return 1;
312	}
313
314	#define MAC_ESP_PIO_LOOP(operands, reg1) \
315	asm volatile ( \
316	"1: moveb " operands " \n" \
317	" subqw #1,%1 \n" \
318	" jbne 1b \n" \
319	: "+a" (addr), "+r" (reg1) \
320	: "a" (fifo))
321
322	#define MAC_ESP_PIO_FILL(operands, reg1) \
323	asm volatile ( \
324	" moveb " operands " \n" \
325	" moveb " operands " \n" \
326	" moveb " operands " \n" \
327	" moveb " operands " \n" \
328	" moveb " operands " \n" \
329	" moveb " operands " \n" \
330	" moveb " operands " \n" \
331	" moveb " operands " \n" \
332	" moveb " operands " \n" \
333	" moveb " operands " \n" \
334	" moveb " operands " \n" \
335	" moveb " operands " \n" \
336	" moveb " operands " \n" \
337	" moveb " operands " \n" \
338	" moveb " operands " \n" \
339	" moveb " operands " \n" \
340	" subqw #8,%1 \n" \
341	" subqw #8,%1 \n" \
342	: "+a" (addr), "+r" (reg1) \
343	: "a" (fifo))
344
345	#define MAC_ESP_FIFO_SIZE 16
346
347	static void mac_esp_send_pio_cmd(struct esp *esp, u32 addr, u32 esp_count,
348	u32 dma_count, int write, u8 cmd)
349	{
350	struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
351	u8 __iomem fifo = esp->regs + ESP_FDATA 16;
352	u8 phase = esp->sreg & ESP_STAT_PMASK;
353
354	cmd &= ~ESP_CMD_DMA;
355	mep->error = 0;
356
357	if (write) {
358	u8 dst = (u8 )addr;
359	u8 mask = ~(phase == ESP_MIP ? ESP_INTR_FDONE : ESP_INTR_BSERV);
360
361	scsi_esp_cmd(esp, cmd);
362
363	while (1) {
364	if (!mac_esp_wait_for_fifo(esp))
365	break;
366
367	*dst++ = esp_read8(ESP_FDATA);
368	--esp_count;
369
370	if (!esp_count)
371	break;
372
373	if (mac_esp_wait_for_intr(esp))
374	break;
375
376	if ((esp->sreg & ESP_STAT_PMASK) != phase)
377	break;
378
379	esp->ireg = esp_read8(ESP_INTRPT);
380	if (esp->ireg & mask) {
381	mep->error = 1;
382	break;
383	}
384
385	if (phase == ESP_MIP)
386	scsi_esp_cmd(esp, ESP_CMD_MOK);
387
388	scsi_esp_cmd(esp, ESP_CMD_TI);
389	}
390	} else {
391	scsi_esp_cmd(esp, ESP_CMD_FLUSH);
392
393	if (esp_count >= MAC_ESP_FIFO_SIZE)
394	MAC_ESP_PIO_FILL("%0@+,%2@", esp_count);
395	else
396	MAC_ESP_PIO_LOOP("%0@+,%2@", esp_count);
397
398	scsi_esp_cmd(esp, cmd);
399
400	while (esp_count) {
401	unsigned int n;
402
403	if (mac_esp_wait_for_intr(esp))
404	break;
405
406	if ((esp->sreg & ESP_STAT_PMASK) != phase)
407	break;
408
409	esp->ireg = esp_read8(ESP_INTRPT);
410	if (esp->ireg & ~ESP_INTR_BSERV) {
411	mep->error = 1;
412	break;
413	}
414
415	n = MAC_ESP_FIFO_SIZE -
416	(esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES);
417	if (n > esp_count)
418	n = esp_count;
419
420	if (n == MAC_ESP_FIFO_SIZE) {
421	MAC_ESP_PIO_FILL("%0@+,%2@", esp_count);
422	} else {
423	esp_count -= n;
424	MAC_ESP_PIO_LOOP("%0@+,%2@", n);
425	}
426
427	scsi_esp_cmd(esp, ESP_CMD_TI);
428	}
429	}
430	}
431
432	static int mac_esp_irq_pending(struct esp *esp)	239	static int mac_esp_irq_pending(struct esp *esp)
433	{	240	{
434	if (esp_read8(ESP_STATUS) & ESP_STAT_INTR)	241	if (esp_read8(ESP_STATUS) & ESP_STAT_INTR)
@@ -470,10 +277,6 @@ static irqreturn_t mac_scsi_esp_intr(int irq, void *dev_id) · 35 unmodified lines
470	static struct esp_driver_ops mac_esp_ops = {	277	static struct esp_driver_ops mac_esp_ops = {
471	.esp_write8 = mac_esp_write8,	278	.esp_write8 = mac_esp_write8,
472	.esp_read8 = mac_esp_read8,	279	.esp_read8 = mac_esp_read8,
473	.map_single = mac_esp_map_single,
474	.map_sg = mac_esp_map_sg,
475	.unmap_single = mac_esp_unmap_single,
476	.unmap_sg = mac_esp_unmap_sg,
477	.irq_pending = mac_esp_irq_pending,	280	.irq_pending = mac_esp_irq_pending,
478	.dma_length_limit = mac_esp_dma_length_limit,	281	.dma_length_limit = mac_esp_dma_length_limit,
479	.reset_dma = mac_esp_reset_dma,	282	.reset_dma = mac_esp_reset_dma,
@@ -508,7 +311,7 @@ static int esp_mac_probe(struct platform_device *dev) · 28 unmodified lines
508	esp = shost_priv(host);	311	esp = shost_priv(host);
509		312
510	esp->host = host;	313	esp->host = host;
511	esp->dev = dev;	314	esp->dev = &dev->dev;
512		315
513	esp->command_block = kzalloc(16, GFP_KERNEL);	316	esp->command_block = kzalloc(16, GFP_KERNEL);
514	if (!esp->command_block)	317	if (!esp->command_block)
@@ -551,14 +354,16 @@ static int esp_mac_probe(struct platform_device *dev) · 36 unmodified lines
551	mep->pdma_regs = NULL;	354	mep->pdma_regs = NULL;
552	break;	355	break;
553	}	356	}
		357	esp->fifo_reg = esp->regs + ESP_FDATA * 16;
554		358
555	esp->ops = &mac_esp_ops;	359	esp->ops = &mac_esp_ops;
		360	esp->flags = ESP_FLAG_NO_DMA_MAP;
556	if (mep->pdma_io == NULL) {	361	if (mep->pdma_io == NULL) {
557	printk(KERN_INFO PFX "using PIO for controller %d\n", dev->id);	362	printk(KERN_INFO PFX "using PIO for controller %d\n", dev->id);
558	esp_write8(0, ESP_TCLOW);	363	esp_write8(0, ESP_TCLOW);
559	esp_write8(0, ESP_TCMED);	364	esp_write8(0, ESP_TCMED);
560	esp->flags = ESP_FLAG_DISABLE_SYNC;	365	esp->flags \|= ESP_FLAG_DISABLE_SYNC;
561	mac_esp_ops.send_dma_cmd = mac_esp_send_pio_cmd;	366	mac_esp_ops.send_dma_cmd = esp_send_pio_cmd;
562	} else {	367	} else {
563	printk(KERN_INFO PFX "using PDMA for controller %d\n", dev->id);	368	printk(KERN_INFO PFX "using PDMA for controller %d\n", dev->id);
564	}	369	}
@@ -577,7 +382,7 @@ static int esp_mac_probe(struct platform_device *dev) · 12 unmodified lines
577	esp_chips[dev->id] = esp;	382	esp_chips[dev->id] = esp;
578	spin_unlock(&esp_chips_lock);	383	spin_unlock(&esp_chips_lock);
579		384
580	err = scsi_esp_register(esp, &dev->dev);	385	err = scsi_esp_register(esp);
581	if (err)	386	if (err)
582	goto fail_free_irq;	387	goto fail_free_irq;
583		388

drivers/scsi/megaraid/megaraid_mbox.c+28−89

 module_param_named(debug_level, mraid_debug_level, int, 0);
 MODULE_PARM_DESC(debug_level, "Debug level for driver (default=0)");
-/*
- * ### global data ###
- */
-static uint8_t megaraid_mbox_version[8] =
-	{ 0x02, 0x20, 0x04, 0x06, 3, 7, 20, 5 };
 /*
  * PCI table for all supported controllers.
  */
 	// Setup the default DMA mask. This would be changed later on
 	// depending on hardware capabilities
-	if (pci_set_dma_mask(adapter->pdev, DMA_BIT_MASK(32)) != 0) {
+	if (dma_set_mask(&adapter->pdev->dev, DMA_BIT_MASK(32))) {
 		con_log(CL_ANN, (KERN_WARNING
-			"megaraid: pci_set_dma_mask failed:%d\n", __LINE__));
+			"megaraid: dma_set_mask failed:%d\n", __LINE__));
 		goto out_free_adapter;
 	}
 	// Start the mailbox based controller
 	if (megaraid_init_mbox(adapter) != 0) {
 		con_log(CL_ANN, (KERN_WARNING
-			"megaraid: maibox adapter did not initialize\n"));
+			"megaraid: mailbox adapter did not initialize\n"));
 		goto out_free_adapter;
 	}
 		adapter->pdev->device == PCI_DEVICE_ID_PERC4_DI_EVERGLADES) ||
 		(adapter->pdev->vendor == PCI_VENDOR_ID_DELL &&
 		adapter->pdev->device == PCI_DEVICE_ID_PERC4E_DI_KOBUK)) {
-		if (pci_set_dma_mask(adapter->pdev, DMA_BIT_MASK(64))) {
+		if (dma_set_mask(&adapter->pdev->dev, DMA_BIT_MASK(64))) {
 			con_log(CL_ANN, (KERN_WARNING
 				"megaraid: DMA mask for 64-bit failed\n"));
-			if (pci_set_dma_mask (adapter->pdev, DMA_BIT_MASK(32))) {
+			if (dma_set_mask(&adapter->pdev->dev,
+						DMA_BIT_MASK(32))) {
 				con_log(CL_ANN, (KERN_WARNING
 					"megaraid: 32-bit DMA mask failed\n"));
 				goto out_free_sysfs_res;
  * megaraid_alloc_cmd_packets - allocate shared mailbox
  * @adapter		: soft state of the raid controller
  *
- * Allocate and align the shared mailbox. This maibox is used to issue
+ * Allocate and align the shared mailbox. This mailbox is used to issue
  * all the commands. For IO based controllers, the mailbox is also registered
  * with the FW. Allocate memory for all commands as well.
  * This is our big allocator.
 	 * Allocate the common 16-byte aligned memory for the handshake
 	 * mailbox.
 	 */
-	raid_dev->una_mbox64 = pci_zalloc_consistent(adapter->pdev,
+	raid_dev->una_mbox64 = dma_zalloc_coherent(&adapter->pdev->dev,
-						     sizeof(mbox64_t),
+			sizeof(mbox64_t), &raid_dev->una_mbox64_dma,
-						     &raid_dev->una_mbox64_dma);
+			GFP_KERNEL);
 	if (!raid_dev->una_mbox64) {
 		con_log(CL_ANN, (KERN_WARNING
 			align;
 	// Allocate memory for commands issued internally
-	adapter->ibuf = pci_zalloc_consistent(pdev, MBOX_IBUF_SIZE,
+	adapter->ibuf = dma_zalloc_coherent(&pdev->dev, MBOX_IBUF_SIZE,
-					      &adapter->ibuf_dma_h);
+			&adapter->ibuf_dma_h, GFP_KERNEL);
 	if (!adapter->ibuf) {
 		con_log(CL_ANN, (KERN_WARNING
 		scb->scp		= NULL;
 		scb->state		= SCB_FREE;
-		scb->dma_direction	= PCI_DMA_NONE;
+		scb->dma_direction	= DMA_NONE;
 		scb->dma_type		= MRAID_DMA_NONE;
 		scb->dev_channel	= -1;
 		scb->dev_target		= -1;
 out_free_scb_list:
 	kfree(adapter->kscb_list);
 out_free_ibuf:
-	pci_free_consistent(pdev, MBOX_IBUF_SIZE, (void *)adapter->ibuf,
+	dma_free_coherent(&pdev->dev, MBOX_IBUF_SIZE, (void *)adapter->ibuf,
 		adapter->ibuf_dma_h);
 out_free_common_mbox:
-	pci_free_consistent(adapter->pdev, sizeof(mbox64_t),
+	dma_free_coherent(&adapter->pdev->dev, sizeof(mbox64_t),
 		(caddr_t)raid_dev->una_mbox64, raid_dev->una_mbox64_dma);
 	return -1;
 	kfree(adapter->kscb_list);
-	pci_free_consistent(adapter->pdev, MBOX_IBUF_SIZE,
+	dma_free_coherent(&adapter->pdev->dev, MBOX_IBUF_SIZE,
 		(void *)adapter->ibuf, adapter->ibuf_dma_h);
-	pci_free_consistent(adapter->pdev, sizeof(mbox64_t),
+	dma_free_coherent(&adapter->pdev->dev, sizeof(mbox64_t),
 		(caddr_t)raid_dev->una_mbox64, raid_dev->una_mbox64_dma);
 	return;
 }
 	adapter->outstanding_cmds++;
-	if (scb->dma_direction == PCI_DMA_TODEVICE)
-		pci_dma_sync_sg_for_device(adapter->pdev,
-					   scsi_sglist(scb->scp),
-					   scsi_sg_count(scb->scp),
-					   PCI_DMA_TODEVICE);
 	mbox->busy	= 1;	// Set busy
 	mbox->poll	= 0;
 	mbox->ack	= 0;
 }
-/**
- * megaraid_mbox_sync_scb - sync kernel buffers
- * @adapter	: controller's soft state
- * @scb		: pointer to the resource packet
- *
- * DMA sync if required.
- */
-static void
-megaraid_mbox_sync_scb(adapter_t *adapter, scb_t *scb)
-{
-	mbox_ccb_t	*ccb;
-	ccb	= (mbox_ccb_t *)scb->ccb;
-	if (scb->dma_direction == PCI_DMA_FROMDEVICE)
-		pci_dma_sync_sg_for_cpu(adapter->pdev,
-					scsi_sglist(scb->scp),
-					scsi_sg_count(scb->scp),
-					PCI_DMA_FROMDEVICE);
-	scsi_dma_unmap(scb->scp);
-	return;
-}
 /**
  * megaraid_mbox_dpc - the tasklet to complete the commands from completed list
  * @devp	: pointer to HBA soft state
 			megaraid_mbox_display_scb(adapter, scb);
 		}
-		// Free our internal resources and call the mid-layer callback
+		scsi_dma_unmap(scp);
-		// routine
-		megaraid_mbox_sync_scb(adapter, scb);
 		// remove from local clist
 		list_del_init(&scb->list);
 	uint8_t		raw_mbox[sizeof(mbox_t)];
 	int		rval;
 	int		recovery_window;
-	int		recovering;
 	int		i;
 	uioc_t		*kioc;
 		return FAILED;
 	}
 	// Under exceptional conditions, FW can take up to 3 minutes to
 	// complete command processing. Wait for additional 2 minutes for the
 	// pending commands counter to go down to 0. If it doesn't, let the
 	recovery_window = MBOX_RESET_WAIT + MBOX_RESET_EXT_WAIT;
-	recovering = adapter->outstanding_cmds;
 	for (i = 0; i < recovery_window; i++) {
 		megaraid_ack_sequence(adapter);
 mbox_post_sync_cmd(adapter_t *adapter, uint8_t raw_mbox[])
 {
 	mraid_device_t	*raid_dev = ADAP2RAIDDEV(adapter);
-	mbox64_t	*mbox64;
 	mbox_t		*mbox;
 	uint8_t		status;
 	int		i;
-	mbox64	= raid_dev->mbox64;
 	mbox	= raid_dev->mbox;
 	/*
 	 * Issue an ENQUIRY3 command to find out certain adapter parameters,
 	 * e.g., max channels, max commands etc.
 	 */
-	pinfo = pci_zalloc_consistent(adapter->pdev, sizeof(mraid_pinfo_t),
+	pinfo = dma_zalloc_coherent(&adapter->pdev->dev, sizeof(mraid_pinfo_t),
-				      &pinfo_dma_h);
+			&pinfo_dma_h, GFP_KERNEL);
 	if (pinfo == NULL) {
 		con_log(CL_ANN, (KERN_WARNING
 			"megaraid: out of memory, %s %d\n", __func__,
 		con_log(CL_ANN, (KERN_WARNING "megaraid: Inquiry3 failed\n"));
-		pci_free_consistent(adapter->pdev, sizeof(mraid_pinfo_t),
+		dma_free_coherent(&adapter->pdev->dev, sizeof(mraid_pinfo_t),
 			pinfo, pinfo_dma_h);
 		return -1;
 		con_log(CL_ANN, (KERN_WARNING
 			"megaraid: product info failed\n"));
-		pci_free_consistent(adapter->pdev, sizeof(mraid_pinfo_t),
+		dma_free_coherent(&adapter->pdev->dev, sizeof(mraid_pinfo_t),
 			pinfo, pinfo_dma_h);
 		return -1;
 		"megaraid: fw version:[%s] bios version:[%s]\n",
 		adapter->fw_version, adapter->bios_version));
-	pci_free_consistent(adapter->pdev, sizeof(mraid_pinfo_t), pinfo,
+	dma_free_coherent(&adapter->pdev->dev, sizeof(mraid_pinfo_t), pinfo,
 			pinfo_dma_h);
 	return 0;
 static int
 megaraid_mbox_support_random_del(adapter_t *adapter)
 {
-	mbox_t		*mbox;
 	uint8_t		raw_mbox[sizeof(mbox_t)];
 	int		rval;
 		return 0;
 	}
-	mbox = (mbox_t *)raw_mbox;
 	memset((caddr_t)raw_mbox, 0, sizeof(mbox_t));
 	raw_mbox[0] = FC_DEL_LOGDRV;
 static void
 megaraid_mbox_flush_cache(adapter_t *adapter)
 {
-	mbox_t	*mbox;
 	uint8_t	raw_mbox[sizeof(mbox_t)];
-	mbox = (mbox_t *)raw_mbox;
 	memset((caddr_t)raw_mbox, 0, sizeof(mbox_t));
 	raw_mbox[0] = FLUSH_ADAPTER;
 	mbox_t	*mbox;
 	uint8_t	raw_mbox[sizeof(mbox_t)];
 	mraid_device_t	*raid_dev = ADAP2RAIDDEV(adapter);
-	mbox64_t *mbox64;
 	int	status = 0;
 	int i;
 	uint32_t dword;
 	raw_mbox[0] = 0xFF;
-	mbox64	= raid_dev->mbox64;
 	mbox	= raid_dev->mbox;
 	/* Wait until mailbox is free */
 		scb->scp		= NULL;
 		scb->state		= SCB_FREE;
-		scb->dma_direction	= PCI_DMA_NONE;
+		scb->dma_direction	= DMA_NONE;
 		scb->dma_type		= MRAID_DMA_NONE;
 		scb->dev_channel	= -1;
 		scb->dev_target		= -1;
 	scb->state		= SCB_ACTIVE;
 	scb->dma_type		= MRAID_DMA_NONE;
-	scb->dma_direction	= PCI_DMA_NONE;
+	scb->dma_direction	= DMA_NONE;
 	ccb		= (mbox_ccb_t *)scb->ccb;
 	mbox64		= (mbox64_t *)(unsigned long)kioc->cmdbuf;
 static int
 gather_hbainfo(adapter_t *adapter, mraid_hba_info_t *hinfo)
 {
-	uint8_t	dmajor;
-	dmajor			= megaraid_mbox_version[0];
 	hinfo->pci_vendor_id	= adapter->pdev->vendor;
 	hinfo->pci_device_id	= adapter->pdev->device;
 	hinfo->subsys_vendor_id	= adapter->pdev->subsystem_vendor;
 	raid_dev->sysfs_mbox64 = kmalloc(sizeof(mbox64_t), GFP_KERNEL);
-	raid_dev->sysfs_buffer = pci_alloc_consistent(adapter->pdev,
+	raid_dev->sysfs_buffer = dma_alloc_coherent(&adapter->pdev->dev,
-			PAGE_SIZE, &raid_dev->sysfs_buffer_dma);
+			PAGE_SIZE, &raid_dev->sysfs_buffer_dma, GFP_KERNEL);
 	if (!raid_dev->sysfs_uioc || !raid_dev->sysfs_mbox64 ||
 		!raid_dev->sysfs_buffer) {
 	kfree(raid_dev->sysfs_mbox64);
 	if (raid_dev->sysfs_buffer) {
-		pci_free_consistent(adapter->pdev, PAGE_SIZE,
+		dma_free_coherent(&adapter->pdev->dev, PAGE_SIZE,
 			raid_dev->sysfs_buffer, raid_dev->sysfs_buffer_dma);
 	}
 }

drivers/scsi/megaraid/megaraid_mbox.h+1−1

@@ -117,7 +117,7 @@ · 116 unmodified lines
117	* @raw_mbox : raw mailbox pointer	117	* @raw_mbox : raw mailbox pointer
118	* @mbox : mailbox	118	* @mbox : mailbox
119	* @mbox64 : extended mailbox	119	* @mbox64 : extended mailbox
120	* @mbox_dma_h : maibox dma address	120	* @mbox_dma_h : mailbox dma address
121	* @sgl64 : 64-bit scatter-gather list	121	* @sgl64 : 64-bit scatter-gather list
122	* @sgl32 : 32-bit scatter-gather list	122	* @sgl32 : 32-bit scatter-gather list
123	* @sgl_dma_h : dma handle for the scatter-gather list	123	* @sgl_dma_h : dma handle for the scatter-gather list

drivers/scsi/megaraid/megaraid_sas_base.c+78−75

 	device_id = MEGASAS_DEV_INDEX(scp);
 	pthru = (struct megasas_pthru_frame *)cmd->frame;
-	if (scp->sc_data_direction == PCI_DMA_TODEVICE)
+	if (scp->sc_data_direction == DMA_TO_DEVICE)
 		flags = MFI_FRAME_DIR_WRITE;
-	else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
+	else if (scp->sc_data_direction == DMA_FROM_DEVICE)
 		flags = MFI_FRAME_DIR_READ;
-	else if (scp->sc_data_direction == PCI_DMA_NONE)
+	else if (scp->sc_data_direction == DMA_NONE)
 		flags = MFI_FRAME_DIR_NONE;
 	if (instance->flag_ieee == 1) {
 	device_id = MEGASAS_DEV_INDEX(scp);
 	ldio = (struct megasas_io_frame *)cmd->frame;
-	if (scp->sc_data_direction == PCI_DMA_TODEVICE)
+	if (scp->sc_data_direction == DMA_TO_DEVICE)
 		flags = MFI_FRAME_DIR_WRITE;
-	else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
+	else if (scp->sc_data_direction == DMA_FROM_DEVICE)
 		flags = MFI_FRAME_DIR_READ;
 	if (instance->flag_ieee == 1) {
 			       sizeof(struct MR_LD_VF_AFFILIATION_111));
 	else {
 		new_affiliation_111 =
-			pci_zalloc_consistent(instance->pdev,
+			dma_zalloc_coherent(&instance->pdev->dev,
 					      sizeof(struct MR_LD_VF_AFFILIATION_111),
-					      &new_affiliation_111_h);
+					      &new_affiliation_111_h, GFP_KERNEL);
 		if (!new_affiliation_111) {
 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate "
 			       "memory for new affiliation for scsi%d\n",
 	}
 out:
 	if (new_affiliation_111) {
-		pci_free_consistent(instance->pdev,
+		dma_free_coherent(&instance->pdev->dev,
 				    sizeof(struct MR_LD_VF_AFFILIATION_111),
 				    new_affiliation_111,
 				    new_affiliation_111_h);
 		       sizeof(struct MR_LD_VF_AFFILIATION));
 	else {
 		new_affiliation =
-			pci_zalloc_consistent(instance->pdev,
+			dma_zalloc_coherent(&instance->pdev->dev,
 					      (MAX_LOGICAL_DRIVES + 1) *
 					      sizeof(struct MR_LD_VF_AFFILIATION),
-					      &new_affiliation_h);
+					      &new_affiliation_h, GFP_KERNEL);
 		if (!new_affiliation) {
 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate "
 			       "memory for new affiliation for scsi%d\n",
 	}
 	if (new_affiliation)
-		pci_free_consistent(instance->pdev,
+		dma_free_coherent(&instance->pdev->dev,
 				    (MAX_LOGICAL_DRIVES + 1) *
 				    sizeof(struct MR_LD_VF_AFFILIATION),
 				    new_affiliation, new_affiliation_h);
 	if (initial) {
 		instance->hb_host_mem =
-			pci_zalloc_consistent(instance->pdev,
+			dma_zalloc_coherent(&instance->pdev->dev,
 					      sizeof(struct MR_CTRL_HB_HOST_MEM),
-					      &instance->hb_host_mem_h);
+					      &instance->hb_host_mem_h, GFP_KERNEL);
 		if (!instance->hb_host_mem) {
 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate"
 			       " memory for heartbeat host memory for scsi%d\n",
 	context_sz = sizeof(u32);
 	reply_q_sz = context_sz * (instance->max_fw_cmds + 1);
-	instance->reply_queue = pci_alloc_consistent(instance->pdev,
+	instance->reply_queue = dma_alloc_coherent(&instance->pdev->dev,
-						     reply_q_sz,
+			reply_q_sz, &instance->reply_queue_h, GFP_KERNEL);
-						     &instance->reply_queue_h);
 	if (!instance->reply_queue) {
 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Out of DMA mem for reply queue\n");
 fail_fw_init:
-	pci_free_consistent(instance->pdev, reply_q_sz,
+	dma_free_coherent(&instance->pdev->dev, reply_q_sz,
 			    instance->reply_queue, instance->reply_queue_h);
 fail_reply_queue:
 	megasas_free_cmds(instance);
 	else {
 		if (instance->crash_dump_buf)
-			pci_free_consistent(instance->pdev,
+			dma_free_coherent(&instance->pdev->dev,
 				CRASH_DMA_BUF_SIZE,
 				instance->crash_dump_buf,
 				instance->crash_dump_h);
 	u32 reply_q_sz = sizeof(u32) *(instance->max_mfi_cmds + 1);
 	if (instance->reply_queue)
-		pci_free_consistent(instance->pdev, reply_q_sz,
+		dma_free_coherent(&instance->pdev->dev, reply_q_sz,
 			    instance->reply_queue, instance->reply_queue_h);
 	megasas_free_cmds(instance);
 	}
 	dcmd = &cmd->frame->dcmd;
-	el_info = pci_zalloc_consistent(instance->pdev,
+	el_info = dma_zalloc_coherent(&instance->pdev->dev,
-					sizeof(struct megasas_evt_log_info),
+			sizeof(struct megasas_evt_log_info), &el_info_h,
-					&el_info_h);
+			GFP_KERNEL);
 	if (!el_info) {
 		megasas_return_cmd(instance, cmd);
 		return -ENOMEM;
 	eli->boot_seq_num = el_info->boot_seq_num;
 dcmd_failed:
-	pci_free_consistent(instance->pdev, sizeof(struct megasas_evt_log_info),
+	dma_free_coherent(&instance->pdev->dev,
-			    el_info, el_info_h);
+			sizeof(struct megasas_evt_log_info),
+			el_info, el_info_h);
 	megasas_return_cmd(instance, cmd);
 static inline int megasas_alloc_mfi_ctrl_mem(struct megasas_instance *instance)
 {
-	instance->producer = pci_alloc_consistent(instance->pdev, sizeof(u32),
+	instance->producer = dma_alloc_coherent(&instance->pdev->dev,
-						  &instance->producer_h);
+			sizeof(u32), &instance->producer_h, GFP_KERNEL);
-	instance->consumer = pci_alloc_consistent(instance->pdev, sizeof(u32),
+	instance->consumer = dma_alloc_coherent(&instance->pdev->dev,
-						  &instance->consumer_h);
+			sizeof(u32), &instance->consumer_h, GFP_KERNEL);
 	if (!instance->producer || !instance->consumer) {
 		dev_err(&instance->pdev->dev,
 	kfree(instance->reply_map);
 	if (instance->adapter_type == MFI_SERIES) {
 		if (instance->producer)
-			pci_free_consistent(instance->pdev, sizeof(u32),
+			dma_free_coherent(&instance->pdev->dev, sizeof(u32),
 					    instance->producer,
 					    instance->producer_h);
 		if (instance->consumer)
-			pci_free_consistent(instance->pdev, sizeof(u32),
+			dma_free_coherent(&instance->pdev->dev, sizeof(u32),
 					    instance->consumer,
 					    instance->consumer_h);
 	} else {
 	struct pci_dev *pdev = instance->pdev;
 	struct fusion_context *fusion = instance->ctrl_context;
-	instance->evt_detail =
+	instance->evt_detail = dma_alloc_coherent(&pdev->dev,
-		pci_alloc_consistent(pdev,
+			sizeof(struct megasas_evt_detail),
-				     sizeof(struct megasas_evt_detail),
+			&instance->evt_detail_h, GFP_KERNEL);
-				     &instance->evt_detail_h);
 	if (!instance->evt_detail) {
 		dev_err(&instance->pdev->dev,
 	}
 	instance->pd_list_buf =
-		pci_alloc_consistent(pdev,
+		dma_alloc_coherent(&pdev->dev,
 				     MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST),
-				     &instance->pd_list_buf_h);
+				     &instance->pd_list_buf_h, GFP_KERNEL);
 	if (!instance->pd_list_buf) {
 		dev_err(&pdev->dev, "Failed to allocate PD list buffer\n");
 	}
 	instance->ctrl_info_buf =
-		pci_alloc_consistent(pdev,
+		dma_alloc_coherent(&pdev->dev,
 				     sizeof(struct megasas_ctrl_info),
-				     &instance->ctrl_info_buf_h);
+				     &instance->ctrl_info_buf_h, GFP_KERNEL);
 	if (!instance->ctrl_info_buf) {
 		dev_err(&pdev->dev,
 	}
 	instance->ld_list_buf =
-		pci_alloc_consistent(pdev,
+		dma_alloc_coherent(&pdev->dev,
 				     sizeof(struct MR_LD_LIST),
-				     &instance->ld_list_buf_h);
+				     &instance->ld_list_buf_h, GFP_KERNEL);
 	if (!instance->ld_list_buf) {
 		dev_err(&pdev->dev, "Failed to allocate LD list buffer\n");
 	}
 	instance->ld_targetid_list_buf =
-		pci_alloc_consistent(pdev,
+		dma_alloc_coherent(&pdev->dev,
-				     sizeof(struct MR_LD_TARGETID_LIST),
+				sizeof(struct MR_LD_TARGETID_LIST),
-				     &instance->ld_targetid_list_buf_h);
+				&instance->ld_targetid_list_buf_h, GFP_KERNEL);
 	if (!instance->ld_targetid_list_buf) {
 		dev_err(&pdev->dev,
 	if (!reset_devices) {
 		instance->system_info_buf =
-			pci_alloc_consistent(pdev,
+			dma_alloc_coherent(&pdev->dev,
-					     sizeof(struct MR_DRV_SYSTEM_INFO),
+					sizeof(struct MR_DRV_SYSTEM_INFO),
-					     &instance->system_info_h);
+					&instance->system_info_h, GFP_KERNEL);
 		instance->pd_info =
-			pci_alloc_consistent(pdev,
+			dma_alloc_coherent(&pdev->dev,
-					     sizeof(struct MR_PD_INFO),
+					sizeof(struct MR_PD_INFO),
-					     &instance->pd_info_h);
+					&instance->pd_info_h, GFP_KERNEL);
 		instance->tgt_prop =
-			pci_alloc_consistent(pdev,
+			dma_alloc_coherent(&pdev->dev,
-					     sizeof(struct MR_TARGET_PROPERTIES),
+					sizeof(struct MR_TARGET_PROPERTIES),
-					     &instance->tgt_prop_h);
+					&instance->tgt_prop_h, GFP_KERNEL);
 		instance->crash_dump_buf =
-			pci_alloc_consistent(pdev,
+			dma_alloc_coherent(&pdev->dev, CRASH_DMA_BUF_SIZE,
-					     CRASH_DMA_BUF_SIZE,
+					&instance->crash_dump_h, GFP_KERNEL);
-					     &instance->crash_dump_h);
 		if (!instance->system_info_buf)
 			dev_err(&instance->pdev->dev,
 	struct fusion_context *fusion = instance->ctrl_context;
 	if (instance->evt_detail)
-		pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
+		dma_free_coherent(&pdev->dev, sizeof(struct megasas_evt_detail),
 				    instance->evt_detail,
 				    instance->evt_detail_h);
 				  fusion->ioc_init_request_phys);
 	if (instance->pd_list_buf)
-		pci_free_consistent(pdev,
+		dma_free_coherent(&pdev->dev,
 				    MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST),
 				    instance->pd_list_buf,
 				    instance->pd_list_buf_h);
 	if (instance->ld_list_buf)
-		pci_free_consistent(pdev, sizeof(struct MR_LD_LIST),
+		dma_free_coherent(&pdev->dev, sizeof(struct MR_LD_LIST),
 				    instance->ld_list_buf,
 				    instance->ld_list_buf_h);
 	if (instance->ld_targetid_list_buf)
-		pci_free_consistent(pdev, sizeof(struct MR_LD_TARGETID_LIST),
+		dma_free_coherent(&pdev->dev, sizeof(struct MR_LD_TARGETID_LIST),
 				    instance->ld_targetid_list_buf,
 				    instance->ld_targetid_list_buf_h);
 	if (instance->ctrl_info_buf)
-		pci_free_consistent(pdev, sizeof(struct megasas_ctrl_info),
+		dma_free_coherent(&pdev->dev, sizeof(struct megasas_ctrl_info),
 				    instance->ctrl_info_buf,
 				    instance->ctrl_info_buf_h);
 	if (instance->system_info_buf)
-		pci_free_consistent(pdev, sizeof(struct MR_DRV_SYSTEM_INFO),
+		dma_free_coherent(&pdev->dev, sizeof(struct MR_DRV_SYSTEM_INFO),
 				    instance->system_info_buf,
 				    instance->system_info_h);
 	if (instance->pd_info)
-		pci_free_consistent(pdev, sizeof(struct MR_PD_INFO),
+		dma_free_coherent(&pdev->dev, sizeof(struct MR_PD_INFO),
 				    instance->pd_info, instance->pd_info_h);
 	if (instance->tgt_prop)
-		pci_free_consistent(pdev, sizeof(struct MR_TARGET_PROPERTIES),
+		dma_free_coherent(&pdev->dev, sizeof(struct MR_TARGET_PROPERTIES),
 				    instance->tgt_prop, instance->tgt_prop_h);
 	if (instance->crash_dump_buf)
-		pci_free_consistent(pdev, CRASH_DMA_BUF_SIZE,
+		dma_free_coherent(&pdev->dev, CRASH_DMA_BUF_SIZE,
 				    instance->crash_dump_buf,
 				    instance->crash_dump_h);
 }
 	if (instance->requestorId) {
 		if (instance->PlasmaFW111) {
 			instance->vf_affiliation_111 =
-				pci_alloc_consistent(pdev, sizeof(struct MR_LD_VF_AFFILIATION_111),
+				dma_alloc_coherent(&pdev->dev,
-						     &instance->vf_affiliation_111_h);
+					sizeof(struct MR_LD_VF_AFFILIATION_111),
+					&instance->vf_affiliation_111_h,
+					GFP_KERNEL);
 			if (!instance->vf_affiliation_111)
 				dev_warn(&pdev->dev, "Can't allocate "
 				       "memory for VF affiliation buffer\n");
 		} else {
 			instance->vf_affiliation =
-				pci_alloc_consistent(pdev,
+				dma_alloc_coherent(&pdev->dev,
-						     (MAX_LOGICAL_DRIVES + 1) *
+					(MAX_LOGICAL_DRIVES + 1) *
-						     sizeof(struct MR_LD_VF_AFFILIATION),
+					sizeof(struct MR_LD_VF_AFFILIATION),
-						     &instance->vf_affiliation_h);
+					&instance->vf_affiliation_h,
+					GFP_KERNEL);
 			if (!instance->vf_affiliation)
 				dev_warn(&pdev->dev, "Can't allocate "
 				       "memory for VF affiliation buffer\n");
 	}
 	if (instance->vf_affiliation)
-		pci_free_consistent(pdev, (MAX_LOGICAL_DRIVES + 1) *
+		dma_free_coherent(&pdev->dev, (MAX_LOGICAL_DRIVES + 1) *
 				    sizeof(struct MR_LD_VF_AFFILIATION),
 				    instance->vf_affiliation,
 				    instance->vf_affiliation_h);
 	if (instance->vf_affiliation_111)
-		pci_free_consistent(pdev,
+		dma_free_coherent(&pdev->dev,
 				    sizeof(struct MR_LD_VF_AFFILIATION_111),
 				    instance->vf_affiliation_111,
 				    instance->vf_affiliation_111_h);
 	if (instance->hb_host_mem)
-		pci_free_consistent(pdev, sizeof(struct MR_CTRL_HB_HOST_MEM),
+		dma_free_coherent(&pdev->dev, sizeof(struct MR_CTRL_HB_HOST_MEM),
 				    instance->hb_host_mem,
 				    instance->hb_host_mem_h);
 		/*
 		 * We don't change the dma_coherent_mask, so
-		 * pci_alloc_consistent only returns 32bit addresses
+		 * dma_alloc_coherent only returns 32bit addresses
 		 */
 		if (instance->consistent_mask_64bit) {
 			kern_sge64[i].phys_addr = cpu_to_le64(buf_handle);
 		get_user(user_sense_off, &cioc->sense_off))
 		return -EFAULT;
+	if (local_sense_off != user_sense_off)
+		return -EINVAL;
 	if (local_sense_len) {
 		void __user **sense_ioc_ptr =
 			(void __user **)((u8 *)((unsigned long)&ioc->frame.raw) + local_sense_off);

drivers/scsi/megaraid/megaraid_sas_fusion.c+8−8

@@ -684,8 +684,8 @@ megasas_alloc_rdpq_fusion(struct megasas_instance *instance) · 683 unmodified lines
684	array_size = sizeof(struct MPI2_IOC_INIT_RDPQ_ARRAY_ENTRY) *	684	array_size = sizeof(struct MPI2_IOC_INIT_RDPQ_ARRAY_ENTRY) *
685	MAX_MSIX_QUEUES_FUSION;	685	MAX_MSIX_QUEUES_FUSION;
686		686
687	fusion->rdpq_virt = pci_zalloc_consistent(instance->pdev, array_size,	687	fusion->rdpq_virt = dma_zalloc_coherent(&instance->pdev->dev,
688	&fusion->rdpq_phys);	688	array_size, &fusion->rdpq_phys, GFP_KERNEL);
689	if (!fusion->rdpq_virt) {	689	if (!fusion->rdpq_virt) {
690	dev_err(&instance->pdev->dev,	690	dev_err(&instance->pdev->dev,
691	"Failed from %s %d\n", __func__, __LINE__);	691	"Failed from %s %d\n", __func__, __LINE__);
@@ -813,7 +813,7 @@ megasas_free_rdpq_fusion(struct megasas_instance *instance) { · 121 unmodified lines
813	dma_pool_destroy(fusion->reply_frames_desc_pool_align);	813	dma_pool_destroy(fusion->reply_frames_desc_pool_align);
814		814
815	if (fusion->rdpq_virt)	815	if (fusion->rdpq_virt)
816	pci_free_consistent(instance->pdev,	816	dma_free_coherent(&instance->pdev->dev,
817	sizeof(struct MPI2_IOC_INIT_RDPQ_ARRAY_ENTRY) * MAX_MSIX_QUEUES_FUSION,	817	sizeof(struct MPI2_IOC_INIT_RDPQ_ARRAY_ENTRY) * MAX_MSIX_QUEUES_FUSION,
818	fusion->rdpq_virt, fusion->rdpq_phys);	818	fusion->rdpq_virt, fusion->rdpq_phys);
819	}	819	}
@@ -2209,7 +2209,7 @@ megasas_set_pd_lba(struct MPI2_RAID_SCSI_IO_REQUEST *io_request, u8 cdb_len, · 1389 unmodified lines
2209	cdb[0] = MEGASAS_SCSI_VARIABLE_LENGTH_CMD;	2209	cdb[0] = MEGASAS_SCSI_VARIABLE_LENGTH_CMD;
2210	cdb[7] = MEGASAS_SCSI_ADDL_CDB_LEN;	2210	cdb[7] = MEGASAS_SCSI_ADDL_CDB_LEN;
2211		2211
2212	if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)	2212	if (scp->sc_data_direction == DMA_FROM_DEVICE)
2213	cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_READ32;	2213	cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_READ32;
2214	else	2214	else
2215	cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_WRITE32;	2215	cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_WRITE32;
@@ -2238,7 +2238,7 @@ megasas_set_pd_lba(struct MPI2_RAID_SCSI_IO_REQUEST *io_request, u8 cdb_len, · 22 unmodified lines
2238	cdb[31] = (u8)(num_blocks & 0xff);	2238	cdb[31] = (u8)(num_blocks & 0xff);
2239		2239
2240	/* set SCSI IO EEDPFlags */	2240	/* set SCSI IO EEDPFlags */
2241	if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) {	2241	if (scp->sc_data_direction == DMA_FROM_DEVICE) {
2242	io_request->EEDPFlags = cpu_to_le16(	2242	io_request->EEDPFlags = cpu_to_le16(
2243	MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG \|	2243	MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG \|
2244	MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG \|	2244	MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG \|
@@ -2621,7 +2621,7 @@ megasas_build_ldio_fusion(struct megasas_instance *instance, · 376 unmodified lines
2621	scsi_buff_len = scsi_bufflen(scp);	2621	scsi_buff_len = scsi_bufflen(scp);
2622	io_request->DataLength = cpu_to_le32(scsi_buff_len);	2622	io_request->DataLength = cpu_to_le32(scsi_buff_len);
2623		2623
2624	if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)	2624	if (scp->sc_data_direction == DMA_FROM_DEVICE)
2625	io_info.isRead = 1;	2625	io_info.isRead = 1;
2626		2626
2627	local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];	2627	local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
@@ -3088,9 +3088,9 @@ megasas_build_io_fusion(struct megasas_instance *instance, · 460 unmodified lines
3088		3088
3089	io_request->SGLFlags = cpu_to_le16(MPI2_SGE_FLAGS_64_BIT_ADDRESSING);	3089	io_request->SGLFlags = cpu_to_le16(MPI2_SGE_FLAGS_64_BIT_ADDRESSING);
3090		3090
3091	if (scp->sc_data_direction == PCI_DMA_TODEVICE)	3091	if (scp->sc_data_direction == DMA_TO_DEVICE)
3092	io_request->Control \|= cpu_to_le32(MPI2_SCSIIO_CONTROL_WRITE);	3092	io_request->Control \|= cpu_to_le32(MPI2_SCSIIO_CONTROL_WRITE);
3093	else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)	3093	else if (scp->sc_data_direction == DMA_FROM_DEVICE)
3094	io_request->Control \|= cpu_to_le32(MPI2_SCSIIO_CONTROL_READ);	3094	io_request->Control \|= cpu_to_le32(MPI2_SCSIIO_CONTROL_READ);
3095		3095
3096	io_request->SGLOffset0 =	3096	io_request->SGLOffset0 =

drivers/scsi/mesh.c+4−4

@@ -1915,8 +1915,8 @@ static int mesh_probe(struct macio_dev mdev, const struct of_device_id match) · 1914 unmodified lines
1915	/* We use the PCI APIs for now until the generic one gets fixed	1915	/* We use the PCI APIs for now until the generic one gets fixed
1916	* enough or until we get some macio-specific versions	1916	* enough or until we get some macio-specific versions
1917	*/	1917	*/
1918	dma_cmd_space = pci_zalloc_consistent(macio_get_pci_dev(mdev),	1918	dma_cmd_space = dma_zalloc_coherent(&macio_get_pci_dev(mdev)->dev,
1919	ms->dma_cmd_size, &dma_cmd_bus);	1919	ms->dma_cmd_size, &dma_cmd_bus, GFP_KERNEL);
1920	if (dma_cmd_space == NULL) {	1920	if (dma_cmd_space == NULL) {
1921	printk(KERN_ERR "mesh: can't allocate DMA table\n");	1921	printk(KERN_ERR "mesh: can't allocate DMA table\n");
1922	goto out_unmap;	1922	goto out_unmap;
@@ -1974,7 +1974,7 @@ static int mesh_probe(struct macio_dev mdev, const struct of_device_id match) · 51 unmodified lines
1974	*/	1974	*/
1975	mesh_shutdown(mdev);	1975	mesh_shutdown(mdev);
1976	set_mesh_power(ms, 0);	1976	set_mesh_power(ms, 0);
1977	pci_free_consistent(macio_get_pci_dev(mdev), ms->dma_cmd_size,	1977	dma_free_coherent(&macio_get_pci_dev(mdev)->dev, ms->dma_cmd_size,
1978	ms->dma_cmd_space, ms->dma_cmd_bus);	1978	ms->dma_cmd_space, ms->dma_cmd_bus);
1979	out_unmap:	1979	out_unmap:
1980	iounmap(ms->dma);	1980	iounmap(ms->dma);
@@ -2007,7 +2007,7 @@ static int mesh_remove(struct macio_dev *mdev) · 26 unmodified lines
2007	iounmap(ms->dma);	2007	iounmap(ms->dma);
2008		2008
2009	/* Free DMA commands memory */	2009	/* Free DMA commands memory */
2010	pci_free_consistent(macio_get_pci_dev(mdev), ms->dma_cmd_size,	2010	dma_free_coherent(&macio_get_pci_dev(mdev)->dev, ms->dma_cmd_size,
2011	ms->dma_cmd_space, ms->dma_cmd_bus);	2011	ms->dma_cmd_space, ms->dma_cmd_bus);
2012		2012
2013	/* Release memory resources */	2013	/* Release memory resources */

drivers/scsi/mpt3sas/mpt3sas_base.c+524−665

@@ -122,8 +122,8 @@ mpt3sas_base_check_cmd_timeout(struct MPT3SAS_ADAPTER *ioc, · 121 unmodified lines
122	if (!(status & MPT3_CMD_RESET))	122	if (!(status & MPT3_CMD_RESET))
123	issue_reset = 1;	123	issue_reset = 1;
124		124
125	pr_err(MPT3SAS_FMT "Command %s\n", ioc->name,	125	ioc_err(ioc, "Command %s\n",
126	((issue_reset == 0) ? "terminated due to Host Reset" : "Timeout"));	126	issue_reset == 0 ? "terminated due to Host Reset" : "Timeout");
127	_debug_dump_mf(mpi_request, sz);	127	_debug_dump_mf(mpi_request, sz);
128		128
129	return issue_reset;	129	return issue_reset;
@@ -336,9 +336,7 @@ _base_get_chain_buffer_dma_to_chain_buffer(struct MPT3SAS_ADAPTER *ioc, · 206 unmodified lines
336	return ct->chain_buffer;	336	return ct->chain_buffer;
337	}	337	}
338	}	338	}
339	pr_info(MPT3SAS_FMT	339	ioc_info(ioc, "Provided chain_buffer_dma address is not in the lookup list\n");
340	"Provided chain_buffer_dma address is not in the lookup list\n",
341	ioc->name);
342	return NULL;	340	return NULL;
343	}	341	}
344		342
@@ -394,7 +392,7 @@ static void _clone_sg_entries(struct MPT3SAS_ADAPTER *ioc, · 49 unmodified lines
394	/* Get scsi_cmd using smid */	392	/* Get scsi_cmd using smid */
395	scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid);	393	scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid);
396	if (scmd == NULL) {	394	if (scmd == NULL) {
397	pr_err(MPT3SAS_FMT "scmd is NULL\n", ioc->name);	395	ioc_err(ioc, "scmd is NULL\n");
398	return;	396	return;
399	}	397	}
400		398
@@ -532,11 +530,11 @@ static int mpt3sas_remove_dead_ioc_func(void *arg) · 131 unmodified lines
532	struct MPT3SAS_ADAPTER ioc = (struct MPT3SAS_ADAPTER )arg;	530	struct MPT3SAS_ADAPTER ioc = (struct MPT3SAS_ADAPTER )arg;
533	struct pci_dev *pdev;	531	struct pci_dev *pdev;
534		532
535	if ((ioc == NULL))	533	if (!ioc)
536	return -1;	534	return -1;
537		535
538	pdev = ioc->pdev;	536	pdev = ioc->pdev;
539	if ((pdev == NULL))	537	if (!pdev)
540	return -1;	538	return -1;
541	pci_stop_and_remove_bus_device_locked(pdev);	539	pci_stop_and_remove_bus_device_locked(pdev);
542	return 0;	540	return 0;
@@ -566,8 +564,7 @@ _base_fault_reset_work(struct work_struct *work) · 23 unmodified lines
566		564
567	doorbell = mpt3sas_base_get_iocstate(ioc, 0);	565	doorbell = mpt3sas_base_get_iocstate(ioc, 0);
568	if ((doorbell & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_MASK) {	566	if ((doorbell & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_MASK) {
569	pr_err(MPT3SAS_FMT "SAS host is non-operational !!!!\n",	567	ioc_err(ioc, "SAS host is non-operational !!!!\n");
570	ioc->name);
571		568
572	/* It may be possible that EEH recovery can resolve some of	569	/* It may be possible that EEH recovery can resolve some of
573	* pci bus failure issues rather removing the dead ioc function	570	* pci bus failure issues rather removing the dead ioc function
@@ -600,13 +597,11 @@ _base_fault_reset_work(struct work_struct *work) · 26 unmodified lines
600	p = kthread_run(mpt3sas_remove_dead_ioc_func, ioc,	597	p = kthread_run(mpt3sas_remove_dead_ioc_func, ioc,
601	"%s_dead_ioc_%d", ioc->driver_name, ioc->id);	598	"%s_dead_ioc_%d", ioc->driver_name, ioc->id);
602	if (IS_ERR(p))	599	if (IS_ERR(p))
603	pr_err(MPT3SAS_FMT	600	ioc_err(ioc, "%s: Running mpt3sas_dead_ioc thread failed !!!!\n",
604	"%s: Running mpt3sas_dead_ioc thread failed !!!!\n",	601	__func__);
605	ioc->name, __func__);
606	else	602	else
607	pr_err(MPT3SAS_FMT	603	ioc_err(ioc, "%s: Running mpt3sas_dead_ioc thread success !!!!\n",
608	"%s: Running mpt3sas_dead_ioc thread success !!!!\n",	604	__func__);
609	ioc->name, __func__);
610	return; /* don't rearm timer */	605	return; /* don't rearm timer */
611	}	606	}
612		607
@@ -614,8 +609,8 @@ _base_fault_reset_work(struct work_struct *work) · 1 unmodified line
614		609
615	if ((doorbell & MPI2_IOC_STATE_MASK) != MPI2_IOC_STATE_OPERATIONAL) {	610	if ((doorbell & MPI2_IOC_STATE_MASK) != MPI2_IOC_STATE_OPERATIONAL) {
616	rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);	611	rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
617	pr_warn(MPT3SAS_FMT "%s: hard reset: %s\n", ioc->name,	612	ioc_warn(ioc, "%s: hard reset: %s\n",
618	__func__, (rc == 0) ? "success" : "failed");	613	__func__, rc == 0 ? "success" : "failed");
619	doorbell = mpt3sas_base_get_iocstate(ioc, 0);	614	doorbell = mpt3sas_base_get_iocstate(ioc, 0);
620	if ((doorbell & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_FAULT)	615	if ((doorbell & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_FAULT)
621	mpt3sas_base_fault_info(ioc, doorbell &	616	mpt3sas_base_fault_info(ioc, doorbell &
@@ -657,8 +652,7 @@ mpt3sas_base_start_watchdog(struct MPT3SAS_ADAPTER *ioc) · 35 unmodified lines
657	ioc->fault_reset_work_q =	652	ioc->fault_reset_work_q =
658	create_singlethread_workqueue(ioc->fault_reset_work_q_name);	653	create_singlethread_workqueue(ioc->fault_reset_work_q_name);
659	if (!ioc->fault_reset_work_q) {	654	if (!ioc->fault_reset_work_q) {
660	pr_err(MPT3SAS_FMT "%s: failed (line=%d)\n",	655	ioc_err(ioc, "%s: failed (line=%d)\n", __func__, __LINE__);
661	ioc->name, __func__, __LINE__);
662	return;	656	return;
663	}	657	}
664	spin_lock_irqsave(&ioc->ioc_reset_in_progress_lock, flags);	658	spin_lock_irqsave(&ioc->ioc_reset_in_progress_lock, flags);
@@ -700,8 +694,7 @@ mpt3sas_base_stop_watchdog(struct MPT3SAS_ADAPTER *ioc) · 35 unmodified lines
700	void	694	void
701	mpt3sas_base_fault_info(struct MPT3SAS_ADAPTER *ioc , u16 fault_code)	695	mpt3sas_base_fault_info(struct MPT3SAS_ADAPTER *ioc , u16 fault_code)
702	{	696	{
703	pr_err(MPT3SAS_FMT "fault_state(0x%04x)!\n",	697	ioc_err(ioc, "fault_state(0x%04x)!\n", fault_code);
704	ioc->name, fault_code);
705	}	698	}
706		699
707	/**	700	/**
@@ -728,8 +721,7 @@ mpt3sas_halt_firmware(struct MPT3SAS_ADAPTER *ioc) · 20 unmodified lines
728	mpt3sas_base_fault_info(ioc , doorbell);	721	mpt3sas_base_fault_info(ioc , doorbell);
729	else {	722	else {
730	writel(0xC0FFEE00, &ioc->chip->Doorbell);	723	writel(0xC0FFEE00, &ioc->chip->Doorbell);
731	pr_err(MPT3SAS_FMT "Firmware is halted due to command timeout\n",	724	ioc_err(ioc, "Firmware is halted due to command timeout\n");
732	ioc->name);
733	}	725	}
734		726
735	if (ioc->fwfault_debug == 2)	727	if (ioc->fwfault_debug == 2)
@@ -956,8 +948,8 @@ _base_sas_ioc_info(struct MPT3SAS_ADAPTER ioc, MPI2DefaultReply_t mpi_reply, · 220 unmodified lines
956	break;	948	break;
957	}	949	}
958		950
959	pr_warn(MPT3SAS_FMT "ioc_status: %s(0x%04x), request(0x%p),(%s)\n",	951	ioc_warn(ioc, "ioc_status: %s(0x%04x), request(0x%p),(%s)\n",
960	ioc->name, desc, ioc_status, request_hdr, func_str);	952	desc, ioc_status, request_hdr, func_str);
961		953
962	_debug_dump_mf(request_hdr, frame_sz/4);	954	_debug_dump_mf(request_hdr, frame_sz/4);
963	}	955	}
@@ -1003,9 +995,9 @@ _base_display_event_data(struct MPT3SAS_ADAPTER *ioc, · 39 unmodified lines
1003	{	995	{
1004	Mpi2EventDataSasDiscovery_t *event_data =	996	Mpi2EventDataSasDiscovery_t *event_data =
1005	(Mpi2EventDataSasDiscovery_t *)mpi_reply->EventData;	997	(Mpi2EventDataSasDiscovery_t *)mpi_reply->EventData;
1006	pr_info(MPT3SAS_FMT "Discovery: (%s)", ioc->name,	998	ioc_info(ioc, "Discovery: (%s)",
1007	(event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED) ?	999	event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED ?
1008	"start" : "stop");	1000	"start" : "stop");
1009	if (event_data->DiscoveryStatus)	1001	if (event_data->DiscoveryStatus)
1010	pr_cont(" discovery_status(0x%08x)",	1002	pr_cont(" discovery_status(0x%08x)",
1011	le32_to_cpu(event_data->DiscoveryStatus));	1003	le32_to_cpu(event_data->DiscoveryStatus));
@@ -1059,14 +1051,13 @@ _base_display_event_data(struct MPT3SAS_ADAPTER *ioc, · 47 unmodified lines
1059	{	1051	{
1060	Mpi26EventDataPCIeEnumeration_t *event_data =	1052	Mpi26EventDataPCIeEnumeration_t *event_data =
1061	(Mpi26EventDataPCIeEnumeration_t *)mpi_reply->EventData;	1053	(Mpi26EventDataPCIeEnumeration_t *)mpi_reply->EventData;
1062	pr_info(MPT3SAS_FMT "PCIE Enumeration: (%s)", ioc->name,	1054	ioc_info(ioc, "PCIE Enumeration: (%s)",
1063	(event_data->ReasonCode ==	1055	event_data->ReasonCode == MPI26_EVENT_PCIE_ENUM_RC_STARTED ?
1064	MPI26_EVENT_PCIE_ENUM_RC_STARTED) ?	1056	"start" : "stop");
1065	"start" : "stop");
1066	if (event_data->EnumerationStatus)	1057	if (event_data->EnumerationStatus)
1067	pr_info("enumeration_status(0x%08x)",	1058	pr_cont("enumeration_status(0x%08x)",
1068	le32_to_cpu(event_data->EnumerationStatus));	1059	le32_to_cpu(event_data->EnumerationStatus));
1069	pr_info("\n");	1060	pr_cont("\n");
1070	return;	1061	return;
1071	}	1062	}
1072	case MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST:	1063	case MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST:
@@ -1077,7 +1068,7 @@ _base_display_event_data(struct MPT3SAS_ADAPTER *ioc, · 4 unmodified lines
1077	if (!desc)	1068	if (!desc)
1078	return;	1069	return;
1079		1070
1080	pr_info(MPT3SAS_FMT "%s\n", ioc->name, desc);	1071	ioc_info(ioc, "%s\n", desc);
1081	}	1072	}
1082		1073
1083	/**	1074	/**
@@ -1128,11 +1119,9 @@ _base_sas_log_info(struct MPT3SAS_ADAPTER *ioc , u32 log_info) · 44 unmodified lines
1128	break;	1119	break;
1129	}	1120	}
1130		1121
1131	pr_warn(MPT3SAS_FMT	1122	ioc_warn(ioc, "log_info(0x%08x): originator(%s), code(0x%02x), sub_code(0x%04x)\n",
1132	"log_info(0x%08x): originator(%s), code(0x%02x), sub_code(0x%04x)\n",	1123	log_info,
1133	ioc->name, log_info,	1124	originator_str, sas_loginfo.dw.code, sas_loginfo.dw.subcode);
1134	originator_str, sas_loginfo.dw.code,
1135	sas_loginfo.dw.subcode);
1136	}	1125	}
1137		1126
1138	/**	1127	/**
@@ -1152,8 +1141,8 @@ _base_display_reply_info(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, · 13 unmodified lines
1152		1141
1153	mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);	1142	mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
1154	if (unlikely(!mpi_reply)) {	1143	if (unlikely(!mpi_reply)) {
1155	pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",	1144	ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
1156	ioc->name, __FILE__, __LINE__, __func__);	1145	__FILE__, __LINE__, __func__);
1157	return;	1146	return;
1158	}	1147	}
1159	ioc_status = le16_to_cpu(mpi_reply->IOCStatus);	1148	ioc_status = le16_to_cpu(mpi_reply->IOCStatus);
@@ -1249,9 +1238,9 @@ _base_async_event(struct MPT3SAS_ADAPTER *ioc, u8 msix_index, u32 reply) · 89 unmodified lines
1249	delayed_event_ack->EventContext = mpi_reply->EventContext;	1238	delayed_event_ack->EventContext = mpi_reply->EventContext;
1250	list_add_tail(&delayed_event_ack->list,	1239	list_add_tail(&delayed_event_ack->list,
1251	&ioc->delayed_event_ack_list);	1240	&ioc->delayed_event_ack_list);
1252	dewtprintk(ioc, pr_info(MPT3SAS_FMT	1241	dewtprintk(ioc,
1253	"DELAYED: EVENT ACK: event (0x%04x)\n",	1242	ioc_info(ioc, "DELAYED: EVENT ACK: event (0x%04x)\n",
1254	ioc->name, le16_to_cpu(mpi_reply->Event)));	1243	le16_to_cpu(mpi_reply->Event)));
1255	goto out;	1244	goto out;
1256	}	1245	}
1257		1246
@@ -2270,7 +2259,7 @@ _base_build_sg_scmd(struct MPT3SAS_ADAPTER *ioc, · 1012 unmodified lines
2270	sges_left = scsi_dma_map(scmd);	2259	sges_left = scsi_dma_map(scmd);
2271	if (sges_left < 0) {	2260	if (sges_left < 0) {
2272	sdev_printk(KERN_ERR, scmd->device,	2261	sdev_printk(KERN_ERR, scmd->device,
2273	"pci_map_sg failed: request for %d bytes!\n",	2262	"scsi_dma_map failed: request for %d bytes!\n",
2274	scsi_bufflen(scmd));	2263	scsi_bufflen(scmd));
2275	return -ENOMEM;	2264	return -ENOMEM;
2276	}	2265	}
@@ -2418,7 +2407,7 @@ _base_build_sg_scmd_ieee(struct MPT3SAS_ADAPTER *ioc, · 141 unmodified lines
2418	sges_left = scsi_dma_map(scmd);	2407	sges_left = scsi_dma_map(scmd);
2419	if (sges_left < 0) {	2408	if (sges_left < 0) {
2420	sdev_printk(KERN_ERR, scmd->device,	2409	sdev_printk(KERN_ERR, scmd->device,
2421	"pci_map_sg failed: request for %d bytes!\n",	2410	"scsi_dma_map failed: request for %d bytes!\n",
2422	scsi_bufflen(scmd));	2411	scsi_bufflen(scmd));
2423	return -ENOMEM;	2412	return -ENOMEM;
2424	}	2413	}
@@ -2563,44 +2552,41 @@ _base_build_sg_ieee(struct MPT3SAS_ADAPTER ioc, void psge, · 138 unmodified lines
2563	static int	2552	static int
2564	_base_config_dma_addressing(struct MPT3SAS_ADAPTER ioc, struct pci_dev pdev)	2553	_base_config_dma_addressing(struct MPT3SAS_ADAPTER ioc, struct pci_dev pdev)
2565	{	2554	{
		2555	u64 required_mask, coherent_mask;
2566	struct sysinfo s;	2556	struct sysinfo s;
2567	u64 consistent_dma_mask;
2568		2557
2569	if (ioc->is_mcpu_endpoint)	2558	if (ioc->is_mcpu_endpoint)
2570	goto try_32bit;	2559	goto try_32bit;
2571		2560
		2561	required_mask = dma_get_required_mask(&pdev->dev);
		2562	if (sizeof(dma_addr_t) == 4 \|\| required_mask == 32)
		2563	goto try_32bit;
		2564
2572	if (ioc->dma_mask)	2565	if (ioc->dma_mask)
2573	consistent_dma_mask = DMA_BIT_MASK(64);	2566	coherent_mask = DMA_BIT_MASK(64);
2574	else	2567	else
2575	consistent_dma_mask = DMA_BIT_MASK(32);	2568	coherent_mask = DMA_BIT_MASK(32);
2576		2569
2577	if (sizeof(dma_addr_t) > 4) {	2570	if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(64)) \|\|
2578	const uint64_t required_mask =	2571	dma_set_coherent_mask(&pdev->dev, coherent_mask))
2579	dma_get_required_mask(&pdev->dev);	2572	goto try_32bit;
2580	if ((required_mask > DMA_BIT_MASK(32)) &&	2573
2581	!pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) &&	2574	ioc->base_add_sg_single = &_base_add_sg_single_64;
2582	!pci_set_consistent_dma_mask(pdev, consistent_dma_mask)) {	2575	ioc->sge_size = sizeof(Mpi2SGESimple64_t);
2583	ioc->base_add_sg_single = &_base_add_sg_single_64;	2576	ioc->dma_mask = 64;
2584	ioc->sge_size = sizeof(Mpi2SGESimple64_t);	2577	goto out;
2585	ioc->dma_mask = 64;
2586	goto out;
2587	}
2588	}
2589		2578
2590	try_32bit:	2579	try_32bit:
2591	if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))	2580	if (dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)))
2592	&& !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
2593	ioc->base_add_sg_single = &_base_add_sg_single_32;
2594	ioc->sge_size = sizeof(Mpi2SGESimple32_t);
2595	ioc->dma_mask = 32;
2596	} else
2597	return -ENODEV;	2581	return -ENODEV;
2598		2582
		2583	ioc->base_add_sg_single = &_base_add_sg_single_32;
		2584	ioc->sge_size = sizeof(Mpi2SGESimple32_t);
		2585	ioc->dma_mask = 32;
2599	out:	2586	out:
2600	si_meminfo(&s);	2587	si_meminfo(&s);
2601	pr_info(MPT3SAS_FMT	2588	ioc_info(ioc, "%d BIT PCI BUS DMA ADDRESSING SUPPORTED, total mem (%ld kB)\n",
2602	"%d BIT PCI BUS DMA ADDRESSING SUPPORTED, total mem (%ld kB)\n",	2589	ioc->dma_mask, convert_to_kb(s.totalram));
2603	ioc->name, ioc->dma_mask, convert_to_kb(s.totalram));
2604		2590
2605	return 0;	2591	return 0;
2606	}	2592	}
@@ -2639,8 +2625,7 @@ _base_check_enable_msix(struct MPT3SAS_ADAPTER *ioc) · 32 unmodified lines
2639		2625
2640	base = pci_find_capability(ioc->pdev, PCI_CAP_ID_MSIX);	2626	base = pci_find_capability(ioc->pdev, PCI_CAP_ID_MSIX);
2641	if (!base) {	2627	if (!base) {
2642	dfailprintk(ioc, pr_info(MPT3SAS_FMT "msix not supported\n",	2628	dfailprintk(ioc, ioc_info(ioc, "msix not supported\n"));
2643	ioc->name));
2644	return -EINVAL;	2629	return -EINVAL;
2645	}	2630	}
2646		2631
@@ -2658,9 +2643,8 @@ _base_check_enable_msix(struct MPT3SAS_ADAPTER *ioc) · 11 unmodified lines
2658	pci_read_config_word(ioc->pdev, base + 2, &message_control);	2643	pci_read_config_word(ioc->pdev, base + 2, &message_control);
2659	ioc->msix_vector_count = (message_control & 0x3FF) + 1;	2644	ioc->msix_vector_count = (message_control & 0x3FF) + 1;
2660	}	2645	}
2661	dinitprintk(ioc, pr_info(MPT3SAS_FMT	2646	dinitprintk(ioc, ioc_info(ioc, "msix is supported, vector_count(%d)\n",
2662	"msix is supported, vector_count(%d)\n",	2647	ioc->msix_vector_count));
2663	ioc->name, ioc->msix_vector_count));
2664	return 0;	2648	return 0;
2665	}	2649	}
2666		2650
@@ -2702,8 +2686,8 @@ _base_request_irq(struct MPT3SAS_ADAPTER *ioc, u8 index) · 35 unmodified lines
2702		2686
2703	reply_q = kzalloc(sizeof(struct adapter_reply_queue), GFP_KERNEL);	2687	reply_q = kzalloc(sizeof(struct adapter_reply_queue), GFP_KERNEL);
2704	if (!reply_q) {	2688	if (!reply_q) {
2705	pr_err(MPT3SAS_FMT "unable to allocate memory %d!\n",	2689	ioc_err(ioc, "unable to allocate memory %zu!\n",
2706	ioc->name, (int)sizeof(struct adapter_reply_queue));	2690	sizeof(struct adapter_reply_queue));
2707	return -ENOMEM;	2691	return -ENOMEM;
2708	}	2692	}
2709	reply_q->ioc = ioc;	2693	reply_q->ioc = ioc;
@@ -2719,7 +2703,7 @@ _base_request_irq(struct MPT3SAS_ADAPTER *ioc, u8 index) · 9 unmodified lines
2719	r = request_irq(pci_irq_vector(pdev, index), _base_interrupt,	2703	r = request_irq(pci_irq_vector(pdev, index), _base_interrupt,
2720	IRQF_SHARED, reply_q->name, reply_q);	2704	IRQF_SHARED, reply_q->name, reply_q);
2721	if (r) {	2705	if (r) {
2722	pr_err(MPT3SAS_FMT "unable to allocate interrupt %d!\n",	2706	pr_err("%s: unable to allocate interrupt %d!\n",
2723	reply_q->name, pci_irq_vector(pdev, index));	2707	reply_q->name, pci_irq_vector(pdev, index));
2724	kfree(reply_q);	2708	kfree(reply_q);
2725	return -EBUSY;	2709	return -EBUSY;
@@ -2761,8 +2745,8 @@ _base_assign_reply_queues(struct MPT3SAS_ADAPTER *ioc) · 35 unmodified lines
2761	const cpumask_t *mask = pci_irq_get_affinity(ioc->pdev,	2745	const cpumask_t *mask = pci_irq_get_affinity(ioc->pdev,
2762	reply_q->msix_index);	2746	reply_q->msix_index);
2763	if (!mask) {	2747	if (!mask) {
2764	pr_warn(MPT3SAS_FMT "no affinity for msi %x\n",	2748	ioc_warn(ioc, "no affinity for msi %x\n",
2765	ioc->name, reply_q->msix_index);	2749	reply_q->msix_index);
2766	continue;	2750	continue;
2767	}	2751	}
2768		2752
@@ -2833,9 +2817,8 @@ _base_enable_msix(struct MPT3SAS_ADAPTER *ioc) · 64 unmodified lines
2833	ioc->reply_queue_count = min_t(int, ioc->cpu_count,	2817	ioc->reply_queue_count = min_t(int, ioc->cpu_count,
2834	ioc->msix_vector_count);	2818	ioc->msix_vector_count);
2835		2819
2836	printk(MPT3SAS_FMT "MSI-X vectors supported: %d, no of cores"	2820	ioc_info(ioc, "MSI-X vectors supported: %d, no of cores: %d, max_msix_vectors: %d\n",
2837	": %d, max_msix_vectors: %d\n", ioc->name, ioc->msix_vector_count,	2821	ioc->msix_vector_count, ioc->cpu_count, max_msix_vectors);
2838	ioc->cpu_count, max_msix_vectors);
2839		2822
2840	if (!ioc->rdpq_array_enable && max_msix_vectors == -1)	2823	if (!ioc->rdpq_array_enable && max_msix_vectors == -1)
2841	local_max_msix_vectors = (reset_devices) ? 1 : 8;	2824	local_max_msix_vectors = (reset_devices) ? 1 : 8;
@@ -2857,9 +2840,9 @@ _base_enable_msix(struct MPT3SAS_ADAPTER *ioc) · 15 unmodified lines
2857	r = pci_alloc_irq_vectors(ioc->pdev, 1, ioc->reply_queue_count,	2840	r = pci_alloc_irq_vectors(ioc->pdev, 1, ioc->reply_queue_count,
2858	irq_flags);	2841	irq_flags);
2859	if (r < 0) {	2842	if (r < 0) {
2860	dfailprintk(ioc, pr_info(MPT3SAS_FMT	2843	dfailprintk(ioc,
2861	"pci_alloc_irq_vectors failed (r=%d) !!!\n",	2844	ioc_info(ioc, "pci_alloc_irq_vectors failed (r=%d) !!!\n",
2862	ioc->name, r));	2845	r));
2863	goto try_ioapic;	2846	goto try_ioapic;
2864	}	2847	}
2865		2848
@@ -2882,9 +2865,9 @@ _base_enable_msix(struct MPT3SAS_ADAPTER *ioc) · 16 unmodified lines
2882	ioc->reply_queue_count = 1;	2865	ioc->reply_queue_count = 1;
2883	r = pci_alloc_irq_vectors(ioc->pdev, 1, 1, PCI_IRQ_LEGACY);	2866	r = pci_alloc_irq_vectors(ioc->pdev, 1, 1, PCI_IRQ_LEGACY);
2884	if (r < 0) {	2867	if (r < 0) {
2885	dfailprintk(ioc, pr_info(MPT3SAS_FMT	2868	dfailprintk(ioc,
2886	"pci_alloc_irq_vector(legacy) failed (r=%d) !!!\n",	2869	ioc_info(ioc, "pci_alloc_irq_vector(legacy) failed (r=%d) !!!\n",
2887	ioc->name, r));	2870	r));
2888	} else	2871	} else
2889	r = _base_request_irq(ioc, 0);	2872	r = _base_request_irq(ioc, 0);
2890		2873
@@ -2900,8 +2883,7 @@ mpt3sas_base_unmap_resources(struct MPT3SAS_ADAPTER *ioc) · 9 unmodified lines
2900	{	2883	{
2901	struct pci_dev *pdev = ioc->pdev;	2884	struct pci_dev *pdev = ioc->pdev;
2902		2885
2903	dexitprintk(ioc, printk(MPT3SAS_FMT "%s\n",	2886	dexitprintk(ioc, ioc_info(ioc, "%s\n", __func__));
2904	ioc->name, __func__));
2905		2887
2906	_base_free_irq(ioc);	2888	_base_free_irq(ioc);
2907	_base_disable_msix(ioc);	2889	_base_disable_msix(ioc);
@@ -2939,13 +2921,11 @@ mpt3sas_base_map_resources(struct MPT3SAS_ADAPTER *ioc) · 31 unmodified lines
2939	phys_addr_t chip_phys = 0;	2921	phys_addr_t chip_phys = 0;
2940	struct adapter_reply_queue *reply_q;	2922	struct adapter_reply_queue *reply_q;
2941		2923
2942	dinitprintk(ioc, pr_info(MPT3SAS_FMT "%s\n",	2924	dinitprintk(ioc, ioc_info(ioc, "%s\n", __func__));
2943	ioc->name, __func__));
2944		2925
2945	ioc->bars = pci_select_bars(pdev, IORESOURCE_MEM);	2926	ioc->bars = pci_select_bars(pdev, IORESOURCE_MEM);
2946	if (pci_enable_device_mem(pdev)) {	2927	if (pci_enable_device_mem(pdev)) {
2947	pr_warn(MPT3SAS_FMT "pci_enable_device_mem: failed\n",	2928	ioc_warn(ioc, "pci_enable_device_mem: failed\n");
2948	ioc->name);
2949	ioc->bars = 0;	2929	ioc->bars = 0;
2950	return -ENODEV;	2930	return -ENODEV;
2951	}	2931	}
@@ -2953,8 +2933,7 @@ mpt3sas_base_map_resources(struct MPT3SAS_ADAPTER *ioc) · 1 unmodified line
2953		2933
2954	if (pci_request_selected_regions(pdev, ioc->bars,	2934	if (pci_request_selected_regions(pdev, ioc->bars,
2955	ioc->driver_name)) {	2935	ioc->driver_name)) {
2956	pr_warn(MPT3SAS_FMT "pci_request_selected_regions: failed\n",	2936	ioc_warn(ioc, "pci_request_selected_regions: failed\n");
2957	ioc->name);
2958	ioc->bars = 0;	2937	ioc->bars = 0;
2959	r = -ENODEV;	2938	r = -ENODEV;
2960	goto out_fail;	2939	goto out_fail;
@@ -2967,8 +2946,7 @@ mpt3sas_base_map_resources(struct MPT3SAS_ADAPTER *ioc) · 6 unmodified lines
2967		2946
2968		2947
2969	if (_base_config_dma_addressing(ioc, pdev) != 0) {	2948	if (_base_config_dma_addressing(ioc, pdev) != 0) {
2970	pr_warn(MPT3SAS_FMT "no suitable DMA mask for %s\n",	2949	ioc_warn(ioc, "no suitable DMA mask for %s\n", pci_name(pdev));
2971	ioc->name, pci_name(pdev));
2972	r = -ENODEV;	2950	r = -ENODEV;
2973	goto out_fail;	2951	goto out_fail;
2974	}	2952	}
@@ -2991,8 +2969,7 @@ mpt3sas_base_map_resources(struct MPT3SAS_ADAPTER *ioc) · 16 unmodified lines
2991	}	2969	}
2992		2970
2993	if (ioc->chip == NULL) {	2971	if (ioc->chip == NULL) {
2994	pr_err(MPT3SAS_FMT "unable to map adapter memory! "	2972	ioc_err(ioc, "unable to map adapter memory! or resource not found\n");
2995	" or resource not found\n", ioc->name);
2996	r = -EINVAL;	2973	r = -EINVAL;
2997	goto out_fail;	2974	goto out_fail;
2998	}	2975	}
@@ -3026,9 +3003,8 @@ mpt3sas_base_map_resources(struct MPT3SAS_ADAPTER *ioc) · 27 unmodified lines
3026	ioc->combined_reply_index_count,	3003	ioc->combined_reply_index_count,
3027	sizeof(resource_size_t *), GFP_KERNEL);	3004	sizeof(resource_size_t *), GFP_KERNEL);
3028	if (!ioc->replyPostRegisterIndex) {	3005	if (!ioc->replyPostRegisterIndex) {
3029	dfailprintk(ioc, printk(MPT3SAS_FMT	3006	dfailprintk(ioc,
3030	"allocation for reply Post Register Index failed!!!\n",	3007	ioc_warn(ioc, "allocation for reply Post Register Index failed!!!\n"));
3031	ioc->name));
3032	r = -ENOMEM;	3008	r = -ENOMEM;
3033	goto out_fail;	3009	goto out_fail;
3034	}	3010	}
@@ -3053,15 +3029,15 @@ mpt3sas_base_map_resources(struct MPT3SAS_ADAPTER *ioc) · 18 unmodified lines
3053	}	3029	}
3054		3030
3055	list_for_each_entry(reply_q, &ioc->reply_queue_list, list)	3031	list_for_each_entry(reply_q, &ioc->reply_queue_list, list)
3056	pr_info(MPT3SAS_FMT "%s: IRQ %d\n",	3032	pr_info("%s: %s enabled: IRQ %d\n",
3057	reply_q->name, ((ioc->msix_enable) ? "PCI-MSI-X enabled" :	3033	reply_q->name,
3058	"IO-APIC enabled"),	3034	ioc->msix_enable ? "PCI-MSI-X" : "IO-APIC",
3059	pci_irq_vector(ioc->pdev, reply_q->msix_index));	3035	pci_irq_vector(ioc->pdev, reply_q->msix_index));
3060		3036
3061	pr_info(MPT3SAS_FMT "iomem(%pap), mapped(0x%p), size(%d)\n",	3037	ioc_info(ioc, "iomem(%pap), mapped(0x%p), size(%d)\n",
3062	ioc->name, &chip_phys, ioc->chip, memap_sz);	3038	&chip_phys, ioc->chip, memap_sz);
3063	pr_info(MPT3SAS_FMT "ioport(0x%016llx), size(%d)\n",	3039	ioc_info(ioc, "ioport(0x%016llx), size(%d)\n",
3064	ioc->name, (unsigned long long)pio_chip, pio_sz);	3040	(unsigned long long)pio_chip, pio_sz);
3065		3041
3066	/* Save PCI configuration state for recovery from PCI AER/EEH errors */	3042	/* Save PCI configuration state for recovery from PCI AER/EEH errors */
3067	pci_save_state(pdev);	3043	pci_save_state(pdev);
@@ -3176,8 +3152,7 @@ mpt3sas_base_get_smid(struct MPT3SAS_ADAPTER *ioc, u8 cb_idx) · 108 unmodified lines
3176	spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);	3152	spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
3177	if (list_empty(&ioc->internal_free_list)) {	3153	if (list_empty(&ioc->internal_free_list)) {
3178	spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);	3154	spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
3179	pr_err(MPT3SAS_FMT "%s: smid not available\n",	3155	ioc_err(ioc, "%s: smid not available\n", __func__);
3180	ioc->name, __func__);
3181	return 0;	3156	return 0;
3182	}	3157	}
3183		3158
@@ -3545,89 +3520,85 @@ _base_display_OEMs_branding(struct MPT3SAS_ADAPTER *ioc) · 361 unmodified lines
3545	case MPI2_MFGPAGE_DEVID_SAS2008:	3520	case MPI2_MFGPAGE_DEVID_SAS2008:
3546	switch (ioc->pdev->subsystem_device) {	3521	switch (ioc->pdev->subsystem_device) {
3547	case MPT2SAS_INTEL_RMS2LL080_SSDID:	3522	case MPT2SAS_INTEL_RMS2LL080_SSDID:
3548	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3523	ioc_info(ioc, "%s\n",
3549	MPT2SAS_INTEL_RMS2LL080_BRANDING);	3524	MPT2SAS_INTEL_RMS2LL080_BRANDING);
3550	break;	3525	break;
3551	case MPT2SAS_INTEL_RMS2LL040_SSDID:	3526	case MPT2SAS_INTEL_RMS2LL040_SSDID:
3552	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3527	ioc_info(ioc, "%s\n",
3553	MPT2SAS_INTEL_RMS2LL040_BRANDING);	3528	MPT2SAS_INTEL_RMS2LL040_BRANDING);
3554	break;	3529	break;
3555	case MPT2SAS_INTEL_SSD910_SSDID:	3530	case MPT2SAS_INTEL_SSD910_SSDID:
3556	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3531	ioc_info(ioc, "%s\n",
3557	MPT2SAS_INTEL_SSD910_BRANDING);	3532	MPT2SAS_INTEL_SSD910_BRANDING);
3558	break;	3533	break;
3559	default:	3534	default:
3560	pr_info(MPT3SAS_FMT	3535	ioc_info(ioc, "Intel(R) Controller: Subsystem ID: 0x%X\n",
3561	"Intel(R) Controller: Subsystem ID: 0x%X\n",	3536	ioc->pdev->subsystem_device);
3562	ioc->name, ioc->pdev->subsystem_device);
3563	break;	3537	break;
3564	}	3538	}
3565	case MPI2_MFGPAGE_DEVID_SAS2308_2:	3539	case MPI2_MFGPAGE_DEVID_SAS2308_2:
3566	switch (ioc->pdev->subsystem_device) {	3540	switch (ioc->pdev->subsystem_device) {
3567	case MPT2SAS_INTEL_RS25GB008_SSDID:	3541	case MPT2SAS_INTEL_RS25GB008_SSDID:
3568	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3542	ioc_info(ioc, "%s\n",
3569	MPT2SAS_INTEL_RS25GB008_BRANDING);	3543	MPT2SAS_INTEL_RS25GB008_BRANDING);
3570	break;	3544	break;
3571	case MPT2SAS_INTEL_RMS25JB080_SSDID:	3545	case MPT2SAS_INTEL_RMS25JB080_SSDID:
3572	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3546	ioc_info(ioc, "%s\n",
3573	MPT2SAS_INTEL_RMS25JB080_BRANDING);	3547	MPT2SAS_INTEL_RMS25JB080_BRANDING);
3574	break;	3548	break;
3575	case MPT2SAS_INTEL_RMS25JB040_SSDID:	3549	case MPT2SAS_INTEL_RMS25JB040_SSDID:
3576	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3550	ioc_info(ioc, "%s\n",
3577	MPT2SAS_INTEL_RMS25JB040_BRANDING);	3551	MPT2SAS_INTEL_RMS25JB040_BRANDING);
3578	break;	3552	break;
3579	case MPT2SAS_INTEL_RMS25KB080_SSDID:	3553	case MPT2SAS_INTEL_RMS25KB080_SSDID:
3580	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3554	ioc_info(ioc, "%s\n",
3581	MPT2SAS_INTEL_RMS25KB080_BRANDING);	3555	MPT2SAS_INTEL_RMS25KB080_BRANDING);
3582	break;	3556	break;
3583	case MPT2SAS_INTEL_RMS25KB040_SSDID:	3557	case MPT2SAS_INTEL_RMS25KB040_SSDID:
3584	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3558	ioc_info(ioc, "%s\n",
3585	MPT2SAS_INTEL_RMS25KB040_BRANDING);	3559	MPT2SAS_INTEL_RMS25KB040_BRANDING);
3586	break;	3560	break;
3587	case MPT2SAS_INTEL_RMS25LB040_SSDID:	3561	case MPT2SAS_INTEL_RMS25LB040_SSDID:
3588	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3562	ioc_info(ioc, "%s\n",
3589	MPT2SAS_INTEL_RMS25LB040_BRANDING);	3563	MPT2SAS_INTEL_RMS25LB040_BRANDING);
3590	break;	3564	break;
3591	case MPT2SAS_INTEL_RMS25LB080_SSDID:	3565	case MPT2SAS_INTEL_RMS25LB080_SSDID:
3592	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3566	ioc_info(ioc, "%s\n",
3593	MPT2SAS_INTEL_RMS25LB080_BRANDING);	3567	MPT2SAS_INTEL_RMS25LB080_BRANDING);
3594	break;	3568	break;
3595	default:	3569	default:
3596	pr_info(MPT3SAS_FMT	3570	ioc_info(ioc, "Intel(R) Controller: Subsystem ID: 0x%X\n",
3597	"Intel(R) Controller: Subsystem ID: 0x%X\n",	3571	ioc->pdev->subsystem_device);
3598	ioc->name, ioc->pdev->subsystem_device);
3599	break;	3572	break;
3600	}	3573	}
3601	case MPI25_MFGPAGE_DEVID_SAS3008:	3574	case MPI25_MFGPAGE_DEVID_SAS3008:
3602	switch (ioc->pdev->subsystem_device) {	3575	switch (ioc->pdev->subsystem_device) {
3603	case MPT3SAS_INTEL_RMS3JC080_SSDID:	3576	case MPT3SAS_INTEL_RMS3JC080_SSDID:
3604	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3577	ioc_info(ioc, "%s\n",
3605	MPT3SAS_INTEL_RMS3JC080_BRANDING);	3578	MPT3SAS_INTEL_RMS3JC080_BRANDING);
3606	break;	3579	break;
3607		3580
3608	case MPT3SAS_INTEL_RS3GC008_SSDID:	3581	case MPT3SAS_INTEL_RS3GC008_SSDID:
3609	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3582	ioc_info(ioc, "%s\n",
3610	MPT3SAS_INTEL_RS3GC008_BRANDING);	3583	MPT3SAS_INTEL_RS3GC008_BRANDING);
3611	break;	3584	break;
3612	case MPT3SAS_INTEL_RS3FC044_SSDID:	3585	case MPT3SAS_INTEL_RS3FC044_SSDID:
3613	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3586	ioc_info(ioc, "%s\n",
3614	MPT3SAS_INTEL_RS3FC044_BRANDING);	3587	MPT3SAS_INTEL_RS3FC044_BRANDING);
3615	break;	3588	break;
3616	case MPT3SAS_INTEL_RS3UC080_SSDID:	3589	case MPT3SAS_INTEL_RS3UC080_SSDID:
3617	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3590	ioc_info(ioc, "%s\n",
3618	MPT3SAS_INTEL_RS3UC080_BRANDING);	3591	MPT3SAS_INTEL_RS3UC080_BRANDING);
3619	break;	3592	break;
3620	default:	3593	default:
3621	pr_info(MPT3SAS_FMT	3594	ioc_info(ioc, "Intel(R) Controller: Subsystem ID: 0x%X\n",
3622	"Intel(R) Controller: Subsystem ID: 0x%X\n",	3595	ioc->pdev->subsystem_device);
3623	ioc->name, ioc->pdev->subsystem_device);
3624	break;	3596	break;
3625	}	3597	}
3626	break;	3598	break;
3627	default:	3599	default:
3628	pr_info(MPT3SAS_FMT	3600	ioc_info(ioc, "Intel(R) Controller: Subsystem ID: 0x%X\n",
3629	"Intel(R) Controller: Subsystem ID: 0x%X\n",	3601	ioc->pdev->subsystem_device);
3630	ioc->name, ioc->pdev->subsystem_device);
3631	break;	3602	break;
3632	}	3603	}
3633	break;	3604	break;
@@ -3636,57 +3607,54 @@ _base_display_OEMs_branding(struct MPT3SAS_ADAPTER *ioc) · 2 unmodified lines
3636	case MPI2_MFGPAGE_DEVID_SAS2008:	3607	case MPI2_MFGPAGE_DEVID_SAS2008:
3637	switch (ioc->pdev->subsystem_device) {	3608	switch (ioc->pdev->subsystem_device) {
3638	case MPT2SAS_DELL_6GBPS_SAS_HBA_SSDID:	3609	case MPT2SAS_DELL_6GBPS_SAS_HBA_SSDID:
3639	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3610	ioc_info(ioc, "%s\n",
3640	MPT2SAS_DELL_6GBPS_SAS_HBA_BRANDING);	3611	MPT2SAS_DELL_6GBPS_SAS_HBA_BRANDING);
3641	break;	3612	break;
3642	case MPT2SAS_DELL_PERC_H200_ADAPTER_SSDID:	3613	case MPT2SAS_DELL_PERC_H200_ADAPTER_SSDID:
3643	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3614	ioc_info(ioc, "%s\n",
3644	MPT2SAS_DELL_PERC_H200_ADAPTER_BRANDING);	3615	MPT2SAS_DELL_PERC_H200_ADAPTER_BRANDING);
3645	break;	3616	break;
3646	case MPT2SAS_DELL_PERC_H200_INTEGRATED_SSDID:	3617	case MPT2SAS_DELL_PERC_H200_INTEGRATED_SSDID:
3647	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3618	ioc_info(ioc, "%s\n",
3648	MPT2SAS_DELL_PERC_H200_INTEGRATED_BRANDING);	3619	MPT2SAS_DELL_PERC_H200_INTEGRATED_BRANDING);
3649	break;	3620	break;
3650	case MPT2SAS_DELL_PERC_H200_MODULAR_SSDID:	3621	case MPT2SAS_DELL_PERC_H200_MODULAR_SSDID:
3651	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3622	ioc_info(ioc, "%s\n",
3652	MPT2SAS_DELL_PERC_H200_MODULAR_BRANDING);	3623	MPT2SAS_DELL_PERC_H200_MODULAR_BRANDING);
3653	break;	3624	break;
3654	case MPT2SAS_DELL_PERC_H200_EMBEDDED_SSDID:	3625	case MPT2SAS_DELL_PERC_H200_EMBEDDED_SSDID:
3655	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3626	ioc_info(ioc, "%s\n",
3656	MPT2SAS_DELL_PERC_H200_EMBEDDED_BRANDING);	3627	MPT2SAS_DELL_PERC_H200_EMBEDDED_BRANDING);
3657	break;	3628	break;
3658	case MPT2SAS_DELL_PERC_H200_SSDID:	3629	case MPT2SAS_DELL_PERC_H200_SSDID:
3659	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3630	ioc_info(ioc, "%s\n",
3660	MPT2SAS_DELL_PERC_H200_BRANDING);	3631	MPT2SAS_DELL_PERC_H200_BRANDING);
3661	break;	3632	break;
3662	case MPT2SAS_DELL_6GBPS_SAS_SSDID:	3633	case MPT2SAS_DELL_6GBPS_SAS_SSDID:
3663	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3634	ioc_info(ioc, "%s\n",
3664	MPT2SAS_DELL_6GBPS_SAS_BRANDING);	3635	MPT2SAS_DELL_6GBPS_SAS_BRANDING);
3665	break;	3636	break;
3666	default:	3637	default:
3667	pr_info(MPT3SAS_FMT	3638	ioc_info(ioc, "Dell 6Gbps HBA: Subsystem ID: 0x%X\n",
3668	"Dell 6Gbps HBA: Subsystem ID: 0x%X\n",	3639	ioc->pdev->subsystem_device);
3669	ioc->name, ioc->pdev->subsystem_device);
3670	break;	3640	break;
3671	}	3641	}
3672	break;	3642	break;
3673	case MPI25_MFGPAGE_DEVID_SAS3008:	3643	case MPI25_MFGPAGE_DEVID_SAS3008:
3674	switch (ioc->pdev->subsystem_device) {	3644	switch (ioc->pdev->subsystem_device) {
3675	case MPT3SAS_DELL_12G_HBA_SSDID:	3645	case MPT3SAS_DELL_12G_HBA_SSDID:
3676	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3646	ioc_info(ioc, "%s\n",
3677	MPT3SAS_DELL_12G_HBA_BRANDING);	3647	MPT3SAS_DELL_12G_HBA_BRANDING);
3678	break;	3648	break;
3679	default:	3649	default:
3680	pr_info(MPT3SAS_FMT	3650	ioc_info(ioc, "Dell 12Gbps HBA: Subsystem ID: 0x%X\n",
3681	"Dell 12Gbps HBA: Subsystem ID: 0x%X\n",	3651	ioc->pdev->subsystem_device);
3682	ioc->name, ioc->pdev->subsystem_device);
3683	break;	3652	break;
3684	}	3653	}
3685	break;	3654	break;
3686	default:	3655	default:
3687	pr_info(MPT3SAS_FMT	3656	ioc_info(ioc, "Dell HBA: Subsystem ID: 0x%X\n",
3688	"Dell HBA: Subsystem ID: 0x%X\n", ioc->name,	3657	ioc->pdev->subsystem_device);
3689	ioc->pdev->subsystem_device);
3690	break;	3658	break;
3691	}	3659	}
3692	break;	3660	break;
@@ -3695,46 +3663,42 @@ _base_display_OEMs_branding(struct MPT3SAS_ADAPTER *ioc) · 2 unmodified lines
3695	case MPI25_MFGPAGE_DEVID_SAS3008:	3663	case MPI25_MFGPAGE_DEVID_SAS3008:
3696	switch (ioc->pdev->subsystem_device) {	3664	switch (ioc->pdev->subsystem_device) {
3697	case MPT3SAS_CISCO_12G_8E_HBA_SSDID:	3665	case MPT3SAS_CISCO_12G_8E_HBA_SSDID:
3698	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3666	ioc_info(ioc, "%s\n",
3699	MPT3SAS_CISCO_12G_8E_HBA_BRANDING);	3667	MPT3SAS_CISCO_12G_8E_HBA_BRANDING);
3700	break;	3668	break;
3701	case MPT3SAS_CISCO_12G_8I_HBA_SSDID:	3669	case MPT3SAS_CISCO_12G_8I_HBA_SSDID:
3702	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3670	ioc_info(ioc, "%s\n",
3703	MPT3SAS_CISCO_12G_8I_HBA_BRANDING);	3671	MPT3SAS_CISCO_12G_8I_HBA_BRANDING);
3704	break;	3672	break;
3705	case MPT3SAS_CISCO_12G_AVILA_HBA_SSDID:	3673	case MPT3SAS_CISCO_12G_AVILA_HBA_SSDID:
3706	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3674	ioc_info(ioc, "%s\n",
3707	MPT3SAS_CISCO_12G_AVILA_HBA_BRANDING);	3675	MPT3SAS_CISCO_12G_AVILA_HBA_BRANDING);
3708	break;	3676	break;
3709	default:	3677	default:
3710	pr_info(MPT3SAS_FMT	3678	ioc_info(ioc, "Cisco 12Gbps SAS HBA: Subsystem ID: 0x%X\n",
3711	"Cisco 12Gbps SAS HBA: Subsystem ID: 0x%X\n",	3679	ioc->pdev->subsystem_device);
3712	ioc->name, ioc->pdev->subsystem_device);
3713	break;	3680	break;
3714	}	3681	}
3715	break;	3682	break;
3716	case MPI25_MFGPAGE_DEVID_SAS3108_1:	3683	case MPI25_MFGPAGE_DEVID_SAS3108_1:
3717	switch (ioc->pdev->subsystem_device) {	3684	switch (ioc->pdev->subsystem_device) {
3718	case MPT3SAS_CISCO_12G_AVILA_HBA_SSDID:	3685	case MPT3SAS_CISCO_12G_AVILA_HBA_SSDID:
3719	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3686	ioc_info(ioc, "%s\n",
3720	MPT3SAS_CISCO_12G_AVILA_HBA_BRANDING);	3687	MPT3SAS_CISCO_12G_AVILA_HBA_BRANDING);
3721	break;	3688	break;
3722	case MPT3SAS_CISCO_12G_COLUSA_MEZZANINE_HBA_SSDID:	3689	case MPT3SAS_CISCO_12G_COLUSA_MEZZANINE_HBA_SSDID:
3723	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3690	ioc_info(ioc, "%s\n",
3724	MPT3SAS_CISCO_12G_COLUSA_MEZZANINE_HBA_BRANDING	3691	MPT3SAS_CISCO_12G_COLUSA_MEZZANINE_HBA_BRANDING);
3725	);
3726	break;	3692	break;
3727	default:	3693	default:
3728	pr_info(MPT3SAS_FMT	3694	ioc_info(ioc, "Cisco 12Gbps SAS HBA: Subsystem ID: 0x%X\n",
3729	"Cisco 12Gbps SAS HBA: Subsystem ID: 0x%X\n",	3695	ioc->pdev->subsystem_device);
3730	ioc->name, ioc->pdev->subsystem_device);
3731	break;	3696	break;
3732	}	3697	}
3733	break;	3698	break;
3734	default:	3699	default:
3735	pr_info(MPT3SAS_FMT	3700	ioc_info(ioc, "Cisco SAS HBA: Subsystem ID: 0x%X\n",
3736	"Cisco SAS HBA: Subsystem ID: 0x%X\n",	3701	ioc->pdev->subsystem_device);
3737	ioc->name, ioc->pdev->subsystem_device);
3738	break;	3702	break;
3739	}	3703	}
3740	break;	3704	break;
@@ -3743,43 +3707,40 @@ _base_display_OEMs_branding(struct MPT3SAS_ADAPTER *ioc) · 2 unmodified lines
3743	case MPI2_MFGPAGE_DEVID_SAS2004:	3707	case MPI2_MFGPAGE_DEVID_SAS2004:
3744	switch (ioc->pdev->subsystem_device) {	3708	switch (ioc->pdev->subsystem_device) {
3745	case MPT2SAS_HP_DAUGHTER_2_4_INTERNAL_SSDID:	3709	case MPT2SAS_HP_DAUGHTER_2_4_INTERNAL_SSDID:
3746	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3710	ioc_info(ioc, "%s\n",
3747	MPT2SAS_HP_DAUGHTER_2_4_INTERNAL_BRANDING);	3711	MPT2SAS_HP_DAUGHTER_2_4_INTERNAL_BRANDING);
3748	break;	3712	break;
3749	default:	3713	default:
3750	pr_info(MPT3SAS_FMT	3714	ioc_info(ioc, "HP 6Gbps SAS HBA: Subsystem ID: 0x%X\n",
3751	"HP 6Gbps SAS HBA: Subsystem ID: 0x%X\n",	3715	ioc->pdev->subsystem_device);
3752	ioc->name, ioc->pdev->subsystem_device);
3753	break;	3716	break;
3754	}	3717	}
3755	case MPI2_MFGPAGE_DEVID_SAS2308_2:	3718	case MPI2_MFGPAGE_DEVID_SAS2308_2:
3756	switch (ioc->pdev->subsystem_device) {	3719	switch (ioc->pdev->subsystem_device) {
3757	case MPT2SAS_HP_2_4_INTERNAL_SSDID:	3720	case MPT2SAS_HP_2_4_INTERNAL_SSDID:
3758	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3721	ioc_info(ioc, "%s\n",
3759	MPT2SAS_HP_2_4_INTERNAL_BRANDING);	3722	MPT2SAS_HP_2_4_INTERNAL_BRANDING);
3760	break;	3723	break;
3761	case MPT2SAS_HP_2_4_EXTERNAL_SSDID:	3724	case MPT2SAS_HP_2_4_EXTERNAL_SSDID:
3762	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3725	ioc_info(ioc, "%s\n",
3763	MPT2SAS_HP_2_4_EXTERNAL_BRANDING);	3726	MPT2SAS_HP_2_4_EXTERNAL_BRANDING);
3764	break;	3727	break;
3765	case MPT2SAS_HP_1_4_INTERNAL_1_4_EXTERNAL_SSDID:	3728	case MPT2SAS_HP_1_4_INTERNAL_1_4_EXTERNAL_SSDID:
3766	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3729	ioc_info(ioc, "%s\n",
3767	MPT2SAS_HP_1_4_INTERNAL_1_4_EXTERNAL_BRANDING);	3730	MPT2SAS_HP_1_4_INTERNAL_1_4_EXTERNAL_BRANDING);
3768	break;	3731	break;
3769	case MPT2SAS_HP_EMBEDDED_2_4_INTERNAL_SSDID:	3732	case MPT2SAS_HP_EMBEDDED_2_4_INTERNAL_SSDID:
3770	pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3733	ioc_info(ioc, "%s\n",
3771	MPT2SAS_HP_EMBEDDED_2_4_INTERNAL_BRANDING);	3734	MPT2SAS_HP_EMBEDDED_2_4_INTERNAL_BRANDING);
3772	break;	3735	break;
3773	default:	3736	default:
3774	pr_info(MPT3SAS_FMT	3737	ioc_info(ioc, "HP 6Gbps SAS HBA: Subsystem ID: 0x%X\n",
3775	"HP 6Gbps SAS HBA: Subsystem ID: 0x%X\n",	3738	ioc->pdev->subsystem_device);
3776	ioc->name, ioc->pdev->subsystem_device);
3777	break;	3739	break;
3778	}	3740	}
3779	default:	3741	default:
3780	pr_info(MPT3SAS_FMT	3742	ioc_info(ioc, "HP SAS HBA: Subsystem ID: 0x%X\n",
3781	"HP SAS HBA: Subsystem ID: 0x%X\n",	3743	ioc->pdev->subsystem_device);
3782	ioc->name, ioc->pdev->subsystem_device);
3783	break;	3744	break;
3784	}	3745	}
3785	default:	3746	default:
@@ -3806,28 +3767,25 @@ _base_display_fwpkg_version(struct MPT3SAS_ADAPTER *ioc) · 20 unmodified lines
3806	u16 smid, ioc_status;	3767	u16 smid, ioc_status;
3807	size_t data_length;	3768	size_t data_length;
3808		3769
3809	dinitprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,	3770	dinitprintk(ioc, ioc_info(ioc, "%s\n", __func__));
3810	__func__));
3811		3771
3812	if (ioc->base_cmds.status & MPT3_CMD_PENDING) {	3772	if (ioc->base_cmds.status & MPT3_CMD_PENDING) {
3813	pr_err(MPT3SAS_FMT "%s: internal command already in use\n",	3773	ioc_err(ioc, "%s: internal command already in use\n", __func__);
3814	ioc->name, __func__);
3815	return -EAGAIN;	3774	return -EAGAIN;
3816	}	3775	}
3817		3776
3818	data_length = sizeof(Mpi2FWImageHeader_t);	3777	data_length = sizeof(Mpi2FWImageHeader_t);
3819	fwpkg_data = pci_alloc_consistent(ioc->pdev, data_length,	3778	fwpkg_data = dma_alloc_coherent(&ioc->pdev->dev, data_length,
3820	&fwpkg_data_dma);	3779	&fwpkg_data_dma, GFP_KERNEL);
3821	if (!fwpkg_data) {	3780	if (!fwpkg_data) {
3822	pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",	3781	ioc_err(ioc, "failure at %s:%d/%s()!\n",
3823	ioc->name, __FILE__, __LINE__, __func__);	3782	__FILE__, __LINE__, __func__);
3824	return -ENOMEM;	3783	return -ENOMEM;
3825	}	3784	}
3826		3785
3827	smid = mpt3sas_base_get_smid(ioc, ioc->base_cb_idx);	3786	smid = mpt3sas_base_get_smid(ioc, ioc->base_cb_idx);
3828	if (!smid) {	3787	if (!smid) {
3829	pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",	3788	ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
3830	ioc->name, __func__);
3831	r = -EAGAIN;	3789	r = -EAGAIN;
3832	goto out;	3790	goto out;
3833	}	3791	}
@@ -3846,11 +3804,9 @@ _base_display_fwpkg_version(struct MPT3SAS_ADAPTER *ioc) · 12 unmodified lines
3846	/* Wait for 15 seconds */	3804	/* Wait for 15 seconds */
3847	wait_for_completion_timeout(&ioc->base_cmds.done,	3805	wait_for_completion_timeout(&ioc->base_cmds.done,
3848	FW_IMG_HDR_READ_TIMEOUT*HZ);	3806	FW_IMG_HDR_READ_TIMEOUT*HZ);
3849	pr_info(MPT3SAS_FMT "%s: complete\n",	3807	ioc_info(ioc, "%s: complete\n", __func__);
3850	ioc->name, __func__);
3851	if (!(ioc->base_cmds.status & MPT3_CMD_COMPLETE)) {	3808	if (!(ioc->base_cmds.status & MPT3_CMD_COMPLETE)) {
3852	pr_err(MPT3SAS_FMT "%s: timeout\n",	3809	ioc_err(ioc, "%s: timeout\n", __func__);
3853	ioc->name, __func__);
3854	_debug_dump_mf(mpi_request,	3810	_debug_dump_mf(mpi_request,
3855	sizeof(Mpi25FWUploadRequest_t)/4);	3811	sizeof(Mpi25FWUploadRequest_t)/4);
3856	r = -ETIME;	3812	r = -ETIME;
@@ -3864,13 +3820,11 @@ _base_display_fwpkg_version(struct MPT3SAS_ADAPTER *ioc) · 7 unmodified lines
3864	if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {	3820	if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
3865	FWImgHdr = (Mpi2FWImageHeader_t *)fwpkg_data;	3821	FWImgHdr = (Mpi2FWImageHeader_t *)fwpkg_data;
3866	if (FWImgHdr->PackageVersion.Word) {	3822	if (FWImgHdr->PackageVersion.Word) {
3867	pr_info(MPT3SAS_FMT "FW Package Version"	3823	ioc_info(ioc, "FW Package Version (%02d.%02d.%02d.%02d)\n",
3868	"(%02d.%02d.%02d.%02d)\n",	3824	FWImgHdr->PackageVersion.Struct.Major,
3869	ioc->name,	3825	FWImgHdr->PackageVersion.Struct.Minor,
3870	FWImgHdr->PackageVersion.Struct.Major,	3826	FWImgHdr->PackageVersion.Struct.Unit,
3871	FWImgHdr->PackageVersion.Struct.Minor,	3827	FWImgHdr->PackageVersion.Struct.Dev);
3872	FWImgHdr->PackageVersion.Struct.Unit,
3873	FWImgHdr->PackageVersion.Struct.Dev);
3874	}	3828	}
3875	} else {	3829	} else {
3876	_debug_dump_mf(&mpi_reply,	3830	_debug_dump_mf(&mpi_reply,
@@ -3881,7 +3835,7 @@ _base_display_fwpkg_version(struct MPT3SAS_ADAPTER *ioc) · 4 unmodified lines
3881	ioc->base_cmds.status = MPT3_CMD_NOT_USED;	3835	ioc->base_cmds.status = MPT3_CMD_NOT_USED;
3882	out:	3836	out:
3883	if (fwpkg_data)	3837	if (fwpkg_data)
3884	pci_free_consistent(ioc->pdev, data_length, fwpkg_data,	3838	dma_free_coherent(&ioc->pdev->dev, data_length, fwpkg_data,
3885	fwpkg_data_dma);	3839	fwpkg_data_dma);
3886	return r;	3840	return r;
3887	}	3841	}
@@ -3900,18 +3854,17 @@ _base_display_ioc_capabilities(struct MPT3SAS_ADAPTER *ioc) · 12 unmodified lines
3900		3854
3901	bios_version = le32_to_cpu(ioc->bios_pg3.BiosVersion);	3855	bios_version = le32_to_cpu(ioc->bios_pg3.BiosVersion);
3902	strncpy(desc, ioc->manu_pg0.ChipName, 16);	3856	strncpy(desc, ioc->manu_pg0.ChipName, 16);
3903	pr_info(MPT3SAS_FMT "%s: FWVersion(%02d.%02d.%02d.%02d), "\	3857	ioc_info(ioc, "%s: FWVersion(%02d.%02d.%02d.%02d), ChipRevision(0x%02x), BiosVersion(%02d.%02d.%02d.%02d)\n",
3904	"ChipRevision(0x%02x), BiosVersion(%02d.%02d.%02d.%02d)\n",	3858	desc,
3905	ioc->name, desc,	3859	(ioc->facts.FWVersion.Word & 0xFF000000) >> 24,
3906	(ioc->facts.FWVersion.Word & 0xFF000000) >> 24,	3860	(ioc->facts.FWVersion.Word & 0x00FF0000) >> 16,
3907	(ioc->facts.FWVersion.Word & 0x00FF0000) >> 16,	3861	(ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,
3908	(ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,	3862	ioc->facts.FWVersion.Word & 0x000000FF,
3909	ioc->facts.FWVersion.Word & 0x000000FF,	3863	ioc->pdev->revision,
3910	ioc->pdev->revision,	3864	(bios_version & 0xFF000000) >> 24,
3911	(bios_version & 0xFF000000) >> 24,	3865	(bios_version & 0x00FF0000) >> 16,
3912	(bios_version & 0x00FF0000) >> 16,	3866	(bios_version & 0x0000FF00) >> 8,
3913	(bios_version & 0x0000FF00) >> 8,	3867	bios_version & 0x000000FF);
3914	bios_version & 0x000000FF);
3915		3868
3916	_base_display_OEMs_branding(ioc);	3869	_base_display_OEMs_branding(ioc);
3917		3870
@@ -3920,82 +3873,81 @@ _base_display_ioc_capabilities(struct MPT3SAS_ADAPTER *ioc) · 2 unmodified lines
3920	i++;	3873	i++;
3921	}	3874	}
3922		3875
3923	pr_info(MPT3SAS_FMT "Protocol=(", ioc->name);	3876	ioc_info(ioc, "Protocol=(");
3924		3877
3925	if (ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR) {	3878	if (ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR) {
3926	pr_info("Initiator");	3879	pr_cont("Initiator");
3927	i++;	3880	i++;
3928	}	3881	}
3929		3882
3930	if (ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_TARGET) {	3883	if (ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_TARGET) {
3931	pr_info("%sTarget", i ? "," : "");	3884	pr_cont("%sTarget", i ? "," : "");
3932	i++;	3885	i++;
3933	}	3886	}
3934		3887
3935	i = 0;	3888	i = 0;
3936	pr_info("), ");	3889	pr_cont("), Capabilities=(");
3937	pr_info("Capabilities=(");
3938		3890
3939	if (!ioc->hide_ir_msg) {	3891	if (!ioc->hide_ir_msg) {
3940	if (ioc->facts.IOCCapabilities &	3892	if (ioc->facts.IOCCapabilities &
3941	MPI2_IOCFACTS_CAPABILITY_INTEGRATED_RAID) {	3893	MPI2_IOCFACTS_CAPABILITY_INTEGRATED_RAID) {
3942	pr_info("Raid");	3894	pr_cont("Raid");
3943	i++;	3895	i++;
3944	}	3896	}
3945	}	3897	}
3946		3898
3947	if (ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR) {	3899	if (ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR) {
3948	pr_info("%sTLR", i ? "," : "");	3900	pr_cont("%sTLR", i ? "," : "");
3949	i++;	3901	i++;
3950	}	3902	}
3951		3903
3952	if (ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_MULTICAST) {	3904	if (ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_MULTICAST) {
3953	pr_info("%sMulticast", i ? "," : "");	3905	pr_cont("%sMulticast", i ? "," : "");
3954	i++;	3906	i++;
3955	}	3907	}
3956		3908
3957	if (ioc->facts.IOCCapabilities &	3909	if (ioc->facts.IOCCapabilities &
3958	MPI2_IOCFACTS_CAPABILITY_BIDIRECTIONAL_TARGET) {	3910	MPI2_IOCFACTS_CAPABILITY_BIDIRECTIONAL_TARGET) {
3959	pr_info("%sBIDI Target", i ? "," : "");	3911	pr_cont("%sBIDI Target", i ? "," : "");
3960	i++;	3912	i++;
3961	}	3913	}
3962		3914
3963	if (ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_EEDP) {	3915	if (ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_EEDP) {
3964	pr_info("%sEEDP", i ? "," : "");	3916	pr_cont("%sEEDP", i ? "," : "");
3965	i++;	3917	i++;
3966	}	3918	}
3967		3919
3968	if (ioc->facts.IOCCapabilities &	3920	if (ioc->facts.IOCCapabilities &
3969	MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER) {	3921	MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER) {
3970	pr_info("%sSnapshot Buffer", i ? "," : "");	3922	pr_cont("%sSnapshot Buffer", i ? "," : "");
3971	i++;	3923	i++;
3972	}	3924	}
3973		3925
3974	if (ioc->facts.IOCCapabilities &	3926	if (ioc->facts.IOCCapabilities &
3975	MPI2_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER) {	3927	MPI2_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER) {
3976	pr_info("%sDiag Trace Buffer", i ? "," : "");	3928	pr_cont("%sDiag Trace Buffer", i ? "," : "");
3977	i++;	3929	i++;
3978	}	3930	}
3979		3931
3980	if (ioc->facts.IOCCapabilities &	3932	if (ioc->facts.IOCCapabilities &
3981	MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER) {	3933	MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER) {
3982	pr_info("%sDiag Extended Buffer", i ? "," : "");	3934	pr_cont("%sDiag Extended Buffer", i ? "," : "");
3983	i++;	3935	i++;
3984	}	3936	}
3985		3937
3986	if (ioc->facts.IOCCapabilities &	3938	if (ioc->facts.IOCCapabilities &
3987	MPI2_IOCFACTS_CAPABILITY_TASK_SET_FULL_HANDLING) {	3939	MPI2_IOCFACTS_CAPABILITY_TASK_SET_FULL_HANDLING) {
3988	pr_info("%sTask Set Full", i ? "," : "");	3940	pr_cont("%sTask Set Full", i ? "," : "");
3989	i++;	3941	i++;
3990	}	3942	}
3991		3943
3992	iounit_pg1_flags = le32_to_cpu(ioc->iounit_pg1.Flags);	3944	iounit_pg1_flags = le32_to_cpu(ioc->iounit_pg1.Flags);
3993	if (!(iounit_pg1_flags & MPI2_IOUNITPAGE1_NATIVE_COMMAND_Q_DISABLE)) {	3945	if (!(iounit_pg1_flags & MPI2_IOUNITPAGE1_NATIVE_COMMAND_Q_DISABLE)) {
3994	pr_info("%sNCQ", i ? "," : "");	3946	pr_cont("%sNCQ", i ? "," : "");
3995	i++;	3947	i++;
3996	}	3948	}
3997		3949
3998	pr_info(")\n");	3950	pr_cont(")\n");
3999	}	3951	}
4000		3952
4001	/**	3953	/**
@@ -4028,21 +3980,21 @@ mpt3sas_base_update_missing_delay(struct MPT3SAS_ADAPTER *ioc, · 26 unmodified lines
4028	sizeof(Mpi2SasIOUnit1PhyData_t));	3980	sizeof(Mpi2SasIOUnit1PhyData_t));
4029	sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);	3981	sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
4030	if (!sas_iounit_pg1) {	3982	if (!sas_iounit_pg1) {
4031	pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",	3983	ioc_err(ioc, "failure at %s:%d/%s()!\n",
4032	ioc->name, __FILE__, __LINE__, __func__);	3984	__FILE__, __LINE__, __func__);
4033	goto out;	3985	goto out;
4034	}	3986	}
4035	if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,	3987	if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
4036	sas_iounit_pg1, sz))) {	3988	sas_iounit_pg1, sz))) {
4037	pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",	3989	ioc_err(ioc, "failure at %s:%d/%s()!\n",
4038	ioc->name, __FILE__, __LINE__, __func__);	3990	__FILE__, __LINE__, __func__);
4039	goto out;	3991	goto out;
4040	}	3992	}
4041	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &	3993	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
4042	MPI2_IOCSTATUS_MASK;	3994	MPI2_IOCSTATUS_MASK;
4043	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {	3995	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
4044	pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",	3996	ioc_err(ioc, "failure at %s:%d/%s()!\n",
4045	ioc->name, __FILE__, __LINE__, __func__);	3997	__FILE__, __LINE__, __func__);
4046	goto out;	3998	goto out;
4047	}	3999	}
4048		4000
@@ -4074,11 +4026,11 @@ mpt3sas_base_update_missing_delay(struct MPT3SAS_ADAPTER *ioc, · 25 unmodified lines
4074	else	4026	else
4075	dmd_new =	4027	dmd_new =
4076	dmd & MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK;	4028	dmd & MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
4077	pr_info(MPT3SAS_FMT "device_missing_delay: old(%d), new(%d)\n",	4029	ioc_info(ioc, "device_missing_delay: old(%d), new(%d)\n",
4078	ioc->name, dmd_orignal, dmd_new);	4030	dmd_orignal, dmd_new);
4079	pr_info(MPT3SAS_FMT "ioc_missing_delay: old(%d), new(%d)\n",	4031	ioc_info(ioc, "ioc_missing_delay: old(%d), new(%d)\n",
4080	ioc->name, io_missing_delay_original,	4032	io_missing_delay_original,
4081	io_missing_delay);	4033	io_missing_delay);
4082	ioc->device_missing_delay = dmd_new;	4034	ioc->device_missing_delay = dmd_new;
4083	ioc->io_missing_delay = io_missing_delay;	4035	ioc->io_missing_delay = io_missing_delay;
4084	}	4036	}
@@ -4189,33 +4141,32 @@ _base_release_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 104 unmodified lines
4189	struct chain_tracker *ct;	4141	struct chain_tracker *ct;
4190	struct reply_post_struct *rps;	4142	struct reply_post_struct *rps;
4191		4143
4192	dexitprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,	4144	dexitprintk(ioc, ioc_info(ioc, "%s\n", __func__));
4193	__func__));
4194		4145
4195	if (ioc->request) {	4146	if (ioc->request) {
4196	pci_free_consistent(ioc->pdev, ioc->request_dma_sz,	4147	dma_free_coherent(&ioc->pdev->dev, ioc->request_dma_sz,
4197	ioc->request, ioc->request_dma);	4148	ioc->request, ioc->request_dma);
4198	dexitprintk(ioc, pr_info(MPT3SAS_FMT	4149	dexitprintk(ioc,
4199	"request_pool(0x%p): free\n",	4150	ioc_info(ioc, "request_pool(0x%p): free\n",
4200	ioc->name, ioc->request));	4151	ioc->request));
4201	ioc->request = NULL;	4152	ioc->request = NULL;
4202	}	4153	}
4203		4154
4204	if (ioc->sense) {	4155	if (ioc->sense) {
4205	dma_pool_free(ioc->sense_dma_pool, ioc->sense, ioc->sense_dma);	4156	dma_pool_free(ioc->sense_dma_pool, ioc->sense, ioc->sense_dma);
4206	dma_pool_destroy(ioc->sense_dma_pool);	4157	dma_pool_destroy(ioc->sense_dma_pool);
4207	dexitprintk(ioc, pr_info(MPT3SAS_FMT	4158	dexitprintk(ioc,
4208	"sense_pool(0x%p): free\n",	4159	ioc_info(ioc, "sense_pool(0x%p): free\n",
4209	ioc->name, ioc->sense));	4160	ioc->sense));
4210	ioc->sense = NULL;	4161	ioc->sense = NULL;
4211	}	4162	}
4212		4163
4213	if (ioc->reply) {	4164	if (ioc->reply) {
4214	dma_pool_free(ioc->reply_dma_pool, ioc->reply, ioc->reply_dma);	4165	dma_pool_free(ioc->reply_dma_pool, ioc->reply, ioc->reply_dma);
4215	dma_pool_destroy(ioc->reply_dma_pool);	4166	dma_pool_destroy(ioc->reply_dma_pool);
4216	dexitprintk(ioc, pr_info(MPT3SAS_FMT	4167	dexitprintk(ioc,
4217	"reply_pool(0x%p): free\n",	4168	ioc_info(ioc, "reply_pool(0x%p): free\n",
4218	ioc->name, ioc->reply));	4169	ioc->reply));
4219	ioc->reply = NULL;	4170	ioc->reply = NULL;
4220	}	4171	}
4221		4172
@@ -4223,9 +4174,9 @@ _base_release_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 1 unmodified line
4223	dma_pool_free(ioc->reply_free_dma_pool, ioc->reply_free,	4174	dma_pool_free(ioc->reply_free_dma_pool, ioc->reply_free,
4224	ioc->reply_free_dma);	4175	ioc->reply_free_dma);
4225	dma_pool_destroy(ioc->reply_free_dma_pool);	4176	dma_pool_destroy(ioc->reply_free_dma_pool);
4226	dexitprintk(ioc, pr_info(MPT3SAS_FMT	4177	dexitprintk(ioc,
4227	"reply_free_pool(0x%p): free\n",	4178	ioc_info(ioc, "reply_free_pool(0x%p): free\n",
4228	ioc->name, ioc->reply_free));	4179	ioc->reply_free));
4229	ioc->reply_free = NULL;	4180	ioc->reply_free = NULL;
4230	}	4181	}
4231		4182
@@ -4237,9 +4188,9 @@ _base_release_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 5 unmodified lines
4237	ioc->reply_post_free_dma_pool,	4188	ioc->reply_post_free_dma_pool,
4238	rps->reply_post_free,	4189	rps->reply_post_free,
4239	rps->reply_post_free_dma);	4190	rps->reply_post_free_dma);
4240	dexitprintk(ioc, pr_info(MPT3SAS_FMT	4191	dexitprintk(ioc,
4241	"reply_post_free_pool(0x%p): free\n",	4192	ioc_info(ioc, "reply_post_free_pool(0x%p): free\n",
4242	ioc->name, rps->reply_post_free));	4193	rps->reply_post_free));
4243	rps->reply_post_free = NULL;	4194	rps->reply_post_free = NULL;
4244	}	4195	}
4245	} while (ioc->rdpq_array_enable &&	4196	} while (ioc->rdpq_array_enable &&
@@ -4267,10 +4218,10 @@ _base_release_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 21 unmodified lines
4267	}	4218	}
4268		4219
4269	if (ioc->config_page) {	4220	if (ioc->config_page) {
4270	dexitprintk(ioc, pr_info(MPT3SAS_FMT	4221	dexitprintk(ioc,
4271	"config_page(0x%p): free\n", ioc->name,	4222	ioc_info(ioc, "config_page(0x%p): free\n",
4272	ioc->config_page));	4223	ioc->config_page));
4273	pci_free_consistent(ioc->pdev, ioc->config_page_sz,	4224	dma_free_coherent(&ioc->pdev->dev, ioc->config_page_sz,
4274	ioc->config_page, ioc->config_page_dma);	4225	ioc->config_page, ioc->config_page_dma);
4275	}	4226	}
4276		4227
@@ -4338,8 +4289,7 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 61 unmodified lines
4338	int i, j;	4289	int i, j;
4339	struct chain_tracker *ct;	4290	struct chain_tracker *ct;
4340		4291
4341	dinitprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,	4292	dinitprintk(ioc, ioc_info(ioc, "%s\n", __func__));
4342	__func__));
4343		4293
4344		4294
4345	retry_sz = 0;	4295	retry_sz = 0;
@@ -4368,10 +4318,8 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 22 unmodified lines
4368	else if (sg_tablesize > MPT_MAX_PHYS_SEGMENTS) {	4318	else if (sg_tablesize > MPT_MAX_PHYS_SEGMENTS) {
4369	sg_tablesize = min_t(unsigned short, sg_tablesize,	4319	sg_tablesize = min_t(unsigned short, sg_tablesize,
4370	SG_MAX_SEGMENTS);	4320	SG_MAX_SEGMENTS);
4371	pr_warn(MPT3SAS_FMT	4321	ioc_warn(ioc, "sg_tablesize(%u) is bigger than kernel defined SG_CHUNK_SIZE(%u)\n",
4372	"sg_tablesize(%u) is bigger than kernel "	4322	sg_tablesize, MPT_MAX_PHYS_SEGMENTS);
4373	"defined SG_CHUNK_SIZE(%u)\n", ioc->name,
4374	sg_tablesize, MPT_MAX_PHYS_SEGMENTS);
4375	}	4323	}
4376	ioc->shost->sg_tablesize = sg_tablesize;	4324	ioc->shost->sg_tablesize = sg_tablesize;
4377	}	4325	}
@@ -4381,9 +4329,8 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 3 unmodified lines
4381	if (ioc->internal_depth < INTERNAL_CMDS_COUNT) {	4329	if (ioc->internal_depth < INTERNAL_CMDS_COUNT) {
4382	if (facts->RequestCredit <= (INTERNAL_CMDS_COUNT +	4330	if (facts->RequestCredit <= (INTERNAL_CMDS_COUNT +
4383	INTERNAL_SCSIIO_CMDS_COUNT)) {	4331	INTERNAL_SCSIIO_CMDS_COUNT)) {
4384	pr_err(MPT3SAS_FMT "IOC doesn't have enough Request \	4332	ioc_err(ioc, "IOC doesn't have enough Request Credits, it has just %d number of credits\n",
4385	Credits, it has just %d number of credits\n",	4333	facts->RequestCredit);
4386	ioc->name, facts->RequestCredit);
4387	return -ENOMEM;	4334	return -ENOMEM;
4388	}	4335	}
4389	ioc->internal_depth = 10;	4336	ioc->internal_depth = 10;
@@ -4482,11 +4429,12 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 92 unmodified lines
4482	ioc->reply_free_queue_depth = ioc->hba_queue_depth + 64;	4429	ioc->reply_free_queue_depth = ioc->hba_queue_depth + 64;
4483	}	4430	}
4484		4431
4485	dinitprintk(ioc, pr_info(MPT3SAS_FMT "scatter gather: " \	4432	dinitprintk(ioc,
4486	"sge_in_main_msg(%d), sge_per_chain(%d), sge_per_io(%d), "	4433	ioc_info(ioc, "scatter gather: sge_in_main_msg(%d), sge_per_chain(%d), sge_per_io(%d), chains_per_io(%d)\n",
4487	"chains_per_io(%d)\n", ioc->name, ioc->max_sges_in_main_message,	4434	ioc->max_sges_in_main_message,
4488	ioc->max_sges_in_chain_message, ioc->shost->sg_tablesize,	4435	ioc->max_sges_in_chain_message,
4489	ioc->chains_needed_per_io));	4436	ioc->shost->sg_tablesize,
		4437	ioc->chains_needed_per_io));
4490		4438
4491	/* reply post queue, 16 byte align */	4439	/* reply post queue, 16 byte align */
4492	reply_post_free_sz = ioc->reply_post_queue_depth *	4440	reply_post_free_sz = ioc->reply_post_queue_depth *
@@ -4501,48 +4449,40 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 8 unmodified lines
4501	sizeof(struct reply_post_struct), GFP_KERNEL);	4449	sizeof(struct reply_post_struct), GFP_KERNEL);
4502		4450
4503	if (!ioc->reply_post) {	4451	if (!ioc->reply_post) {
4504	pr_err(MPT3SAS_FMT "reply_post_free pool: kcalloc failed\n",	4452	ioc_err(ioc, "reply_post_free pool: kcalloc failed\n");
4505	ioc->name);
4506	goto out;	4453	goto out;
4507	}	4454	}
4508	ioc->reply_post_free_dma_pool = dma_pool_create("reply_post_free pool",	4455	ioc->reply_post_free_dma_pool = dma_pool_create("reply_post_free pool",
4509	&ioc->pdev->dev, sz, 16, 0);	4456	&ioc->pdev->dev, sz, 16, 0);
4510	if (!ioc->reply_post_free_dma_pool) {	4457	if (!ioc->reply_post_free_dma_pool) {
4511	pr_err(MPT3SAS_FMT	4458	ioc_err(ioc, "reply_post_free pool: dma_pool_create failed\n");
4512	"reply_post_free pool: dma_pool_create failed\n",
4513	ioc->name);
4514	goto out;	4459	goto out;
4515	}	4460	}
4516	i = 0;	4461	i = 0;
4517	do {	4462	do {
4518	ioc->reply_post[i].reply_post_free =	4463	ioc->reply_post[i].reply_post_free =
4519	dma_pool_alloc(ioc->reply_post_free_dma_pool,	4464	dma_pool_zalloc(ioc->reply_post_free_dma_pool,
4520	GFP_KERNEL,	4465	GFP_KERNEL,
4521	&ioc->reply_post[i].reply_post_free_dma);	4466	&ioc->reply_post[i].reply_post_free_dma);
4522	if (!ioc->reply_post[i].reply_post_free) {	4467	if (!ioc->reply_post[i].reply_post_free) {
4523	pr_err(MPT3SAS_FMT	4468	ioc_err(ioc, "reply_post_free pool: dma_pool_alloc failed\n");
4524	"reply_post_free pool: dma_pool_alloc failed\n",
4525	ioc->name);
4526	goto out;	4469	goto out;
4527	}	4470	}
4528	memset(ioc->reply_post[i].reply_post_free, 0, sz);	4471	dinitprintk(ioc,
4529	dinitprintk(ioc, pr_info(MPT3SAS_FMT	4472	ioc_info(ioc, "reply post free pool (0x%p): depth(%d), element_size(%d), pool_size(%d kB)\n",
4530	"reply post free pool (0x%p): depth(%d),"	4473	ioc->reply_post[i].reply_post_free,
4531	"element_size(%d), pool_size(%d kB)\n", ioc->name,	4474	ioc->reply_post_queue_depth,
4532	ioc->reply_post[i].reply_post_free,	4475	8, sz / 1024));
4533	ioc->reply_post_queue_depth, 8, sz/1024));	4476	dinitprintk(ioc,
4534	dinitprintk(ioc, pr_info(MPT3SAS_FMT	4477	ioc_info(ioc, "reply_post_free_dma = (0x%llx)\n",
4535	"reply_post_free_dma = (0x%llx)\n", ioc->name,	4478	(u64)ioc->reply_post[i].reply_post_free_dma));
4536	(unsigned long long)
4537	ioc->reply_post[i].reply_post_free_dma));
4538	total_sz += sz;	4479	total_sz += sz;
4539	} while (ioc->rdpq_array_enable && (++i < ioc->reply_queue_count));	4480	} while (ioc->rdpq_array_enable && (++i < ioc->reply_queue_count));
4540		4481
4541	if (ioc->dma_mask == 64) {	4482	if (ioc->dma_mask == 64) {
4542	if (_base_change_consistent_dma_mask(ioc, ioc->pdev) != 0) {	4483	if (_base_change_consistent_dma_mask(ioc, ioc->pdev) != 0) {
4543	pr_warn(MPT3SAS_FMT	4484	ioc_warn(ioc, "no suitable consistent DMA mask for %s\n",
4544	"no suitable consistent DMA mask for %s\n",	4485	pci_name(ioc->pdev));
4545	ioc->name, pci_name(ioc->pdev));
4546	goto out;	4486	goto out;
4547	}	4487	}
4548	}	4488	}
@@ -4554,9 +4494,9 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 5 unmodified lines
4554	* with some internal commands that could be outstanding	4494	* with some internal commands that could be outstanding
4555	*/	4495	*/
4556	ioc->shost->can_queue = ioc->scsiio_depth - INTERNAL_SCSIIO_CMDS_COUNT;	4496	ioc->shost->can_queue = ioc->scsiio_depth - INTERNAL_SCSIIO_CMDS_COUNT;
4557	dinitprintk(ioc, pr_info(MPT3SAS_FMT	4497	dinitprintk(ioc,
4558	"scsi host: can_queue depth (%d)\n",	4498	ioc_info(ioc, "scsi host: can_queue depth (%d)\n",
4559	ioc->name, ioc->shost->can_queue));	4499	ioc->shost->can_queue));
4560		4500
4561		4501
4562	/* contiguous pool for request and chains, 16 byte align, one extra "	4502	/* contiguous pool for request and chains, 16 byte align, one extra "
@@ -4572,12 +4512,12 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 9 unmodified lines
4572	sz += (ioc->internal_depth * ioc->request_sz);	4512	sz += (ioc->internal_depth * ioc->request_sz);
4573		4513
4574	ioc->request_dma_sz = sz;	4514	ioc->request_dma_sz = sz;
4575	ioc->request = pci_alloc_consistent(ioc->pdev, sz, &ioc->request_dma);	4515	ioc->request = dma_alloc_coherent(&ioc->pdev->dev, sz,
		4516	&ioc->request_dma, GFP_KERNEL);
4576	if (!ioc->request) {	4517	if (!ioc->request) {
4577	pr_err(MPT3SAS_FMT "request pool: pci_alloc_consistent " \	4518	ioc_err(ioc, "request pool: dma_alloc_coherent failed: hba_depth(%d), chains_per_io(%d), frame_sz(%d), total(%d kB)\n",
4578	"failed: hba_depth(%d), chains_per_io(%d), frame_sz(%d), "	4519	ioc->hba_queue_depth, ioc->chains_needed_per_io,
4579	"total(%d kB)\n", ioc->name, ioc->hba_queue_depth,	4520	ioc->request_sz, sz / 1024);
4580	ioc->chains_needed_per_io, ioc->request_sz, sz/1024);
4581	if (ioc->scsiio_depth < MPT3SAS_SAS_QUEUE_DEPTH)	4521	if (ioc->scsiio_depth < MPT3SAS_SAS_QUEUE_DEPTH)
4582	goto out;	4522	goto out;
4583	retry_sz = 64;	4523	retry_sz = 64;
@@ -4587,10 +4527,9 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 3 unmodified lines
4587	}	4527	}
4588		4528
4589	if (retry_sz)	4529	if (retry_sz)
4590	pr_err(MPT3SAS_FMT "request pool: pci_alloc_consistent " \	4530	ioc_err(ioc, "request pool: dma_alloc_coherent succeed: hba_depth(%d), chains_per_io(%d), frame_sz(%d), total(%d kb)\n",
4591	"succeed: hba_depth(%d), chains_per_io(%d), frame_sz(%d), "	4531	ioc->hba_queue_depth, ioc->chains_needed_per_io,
4592	"total(%d kb)\n", ioc->name, ioc->hba_queue_depth,	4532	ioc->request_sz, sz / 1024);
4593	ioc->chains_needed_per_io, ioc->request_sz, sz/1024);
4594		4533
4595	/* hi-priority queue */	4534	/* hi-priority queue */
4596	ioc->hi_priority = ioc->request + ((ioc->scsiio_depth + 1) *	4535	ioc->hi_priority = ioc->request + ((ioc->scsiio_depth + 1) *
@@ -4604,24 +4543,26 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 7 unmodified lines
4604	ioc->internal_dma = ioc->hi_priority_dma + (ioc->hi_priority_depth *	4543	ioc->internal_dma = ioc->hi_priority_dma + (ioc->hi_priority_depth *
4605	ioc->request_sz);	4544	ioc->request_sz);
4606		4545
4607	dinitprintk(ioc, pr_info(MPT3SAS_FMT	4546	dinitprintk(ioc,
4608	"request pool(0x%p): depth(%d), frame_size(%d), pool_size(%d kB)\n",	4547	ioc_info(ioc, "request pool(0x%p): depth(%d), frame_size(%d), pool_size(%d kB)\n",
4609	ioc->name, ioc->request, ioc->hba_queue_depth, ioc->request_sz,	4548	ioc->request, ioc->hba_queue_depth,
4610	(ioc->hba_queue_depth * ioc->request_sz)/1024));	4549	ioc->request_sz,
		4550	(ioc->hba_queue_depth * ioc->request_sz) / 1024));
4611		4551
4612	dinitprintk(ioc, pr_info(MPT3SAS_FMT "request pool: dma(0x%llx)\n",	4552	dinitprintk(ioc,
4613	ioc->name, (unsigned long long) ioc->request_dma));	4553	ioc_info(ioc, "request pool: dma(0x%llx)\n",
		4554	(unsigned long long)ioc->request_dma));
4614	total_sz += sz;	4555	total_sz += sz;
4615		4556
4616	dinitprintk(ioc, pr_info(MPT3SAS_FMT "scsiio(0x%p): depth(%d)\n",	4557	dinitprintk(ioc,
4617	ioc->name, ioc->request, ioc->scsiio_depth));	4558	ioc_info(ioc, "scsiio(0x%p): depth(%d)\n",
		4559	ioc->request, ioc->scsiio_depth));
4618		4560
4619	ioc->chain_depth = min_t(u32, ioc->chain_depth, MAX_CHAIN_DEPTH);	4561	ioc->chain_depth = min_t(u32, ioc->chain_depth, MAX_CHAIN_DEPTH);
4620	sz = ioc->scsiio_depth * sizeof(struct chain_lookup);	4562	sz = ioc->scsiio_depth * sizeof(struct chain_lookup);
4621	ioc->chain_lookup = kzalloc(sz, GFP_KERNEL);	4563	ioc->chain_lookup = kzalloc(sz, GFP_KERNEL);
4622	if (!ioc->chain_lookup) {	4564	if (!ioc->chain_lookup) {
4623	pr_err(MPT3SAS_FMT "chain_lookup: __get_free_pages "	4565	ioc_err(ioc, "chain_lookup: __get_free_pages failed\n");
4624	"failed\n", ioc->name);
4625	goto out;	4566	goto out;
4626	}	4567	}
4627		4568
@@ -4629,8 +4570,7 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 1 unmodified line
4629	for (i = 0; i < ioc->scsiio_depth; i++) {	4570	for (i = 0; i < ioc->scsiio_depth; i++) {
4630	ioc->chain_lookup[i].chains_per_smid = kzalloc(sz, GFP_KERNEL);	4571	ioc->chain_lookup[i].chains_per_smid = kzalloc(sz, GFP_KERNEL);
4631	if (!ioc->chain_lookup[i].chains_per_smid) {	4572	if (!ioc->chain_lookup[i].chains_per_smid) {
4632	pr_err(MPT3SAS_FMT "chain_lookup: "	4573	ioc_err(ioc, "chain_lookup: kzalloc failed\n");
4633	" kzalloc failed\n", ioc->name);
4634	goto out;	4574	goto out;
4635	}	4575	}
4636	}	4576	}
@@ -4639,29 +4579,27 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 2 unmodified lines
4639	ioc->hpr_lookup = kcalloc(ioc->hi_priority_depth,	4579	ioc->hpr_lookup = kcalloc(ioc->hi_priority_depth,
4640	sizeof(struct request_tracker), GFP_KERNEL);	4580	sizeof(struct request_tracker), GFP_KERNEL);
4641	if (!ioc->hpr_lookup) {	4581	if (!ioc->hpr_lookup) {
4642	pr_err(MPT3SAS_FMT "hpr_lookup: kcalloc failed\n",	4582	ioc_err(ioc, "hpr_lookup: kcalloc failed\n");
4643	ioc->name);
4644	goto out;	4583	goto out;
4645	}	4584	}
4646	ioc->hi_priority_smid = ioc->scsiio_depth + 1;	4585	ioc->hi_priority_smid = ioc->scsiio_depth + 1;
4647	dinitprintk(ioc, pr_info(MPT3SAS_FMT	4586	dinitprintk(ioc,
4648	"hi_priority(0x%p): depth(%d), start smid(%d)\n",	4587	ioc_info(ioc, "hi_priority(0x%p): depth(%d), start smid(%d)\n",
4649	ioc->name, ioc->hi_priority,	4588	ioc->hi_priority,
4650	ioc->hi_priority_depth, ioc->hi_priority_smid));	4589	ioc->hi_priority_depth, ioc->hi_priority_smid));
4651		4590
4652	/* initialize internal queue smid's */	4591	/* initialize internal queue smid's */
4653	ioc->internal_lookup = kcalloc(ioc->internal_depth,	4592	ioc->internal_lookup = kcalloc(ioc->internal_depth,
4654	sizeof(struct request_tracker), GFP_KERNEL);	4593	sizeof(struct request_tracker), GFP_KERNEL);
4655	if (!ioc->internal_lookup) {	4594	if (!ioc->internal_lookup) {
4656	pr_err(MPT3SAS_FMT "internal_lookup: kcalloc failed\n",	4595	ioc_err(ioc, "internal_lookup: kcalloc failed\n");
4657	ioc->name);
4658	goto out;	4596	goto out;
4659	}	4597	}
4660	ioc->internal_smid = ioc->hi_priority_smid + ioc->hi_priority_depth;	4598	ioc->internal_smid = ioc->hi_priority_smid + ioc->hi_priority_depth;
4661	dinitprintk(ioc, pr_info(MPT3SAS_FMT	4599	dinitprintk(ioc,
4662	"internal(0x%p): depth(%d), start smid(%d)\n",	4600	ioc_info(ioc, "internal(0x%p): depth(%d), start smid(%d)\n",
4663	ioc->name, ioc->internal,	4601	ioc->internal,
4664	ioc->internal_depth, ioc->internal_smid));	4602	ioc->internal_depth, ioc->internal_smid));
4665	/*	4603	/*
4666	* The number of NVMe page sized blocks needed is:	4604	* The number of NVMe page sized blocks needed is:
4667	* (((sg_tablesize * 8) - 1) / (page_size - 8)) + 1	4605	* (((sg_tablesize * 8) - 1) / (page_size - 8)) + 1
@@ -4685,17 +4623,14 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 17 unmodified lines
4685	sz = sizeof(struct pcie_sg_list) * ioc->scsiio_depth;	4623	sz = sizeof(struct pcie_sg_list) * ioc->scsiio_depth;
4686	ioc->pcie_sg_lookup = kzalloc(sz, GFP_KERNEL);	4624	ioc->pcie_sg_lookup = kzalloc(sz, GFP_KERNEL);
4687	if (!ioc->pcie_sg_lookup) {	4625	if (!ioc->pcie_sg_lookup) {
4688	pr_info(MPT3SAS_FMT	4626	ioc_info(ioc, "PCIe SGL lookup: kzalloc failed\n");
4689	"PCIe SGL lookup: kzalloc failed\n", ioc->name);
4690	goto out;	4627	goto out;
4691	}	4628	}
4692	sz = nvme_blocks_needed * ioc->page_size;	4629	sz = nvme_blocks_needed * ioc->page_size;
4693	ioc->pcie_sgl_dma_pool =	4630	ioc->pcie_sgl_dma_pool =
4694	dma_pool_create("PCIe SGL pool", &ioc->pdev->dev, sz, 16, 0);	4631	dma_pool_create("PCIe SGL pool", &ioc->pdev->dev, sz, 16, 0);
4695	if (!ioc->pcie_sgl_dma_pool) {	4632	if (!ioc->pcie_sgl_dma_pool) {
4696	pr_info(MPT3SAS_FMT	4633	ioc_info(ioc, "PCIe SGL pool: dma_pool_create failed\n");
4697	"PCIe SGL pool: dma_pool_create failed\n",
4698	ioc->name);
4699	goto out;	4634	goto out;
4700	}	4635	}
4701		4636
@@ -4708,9 +4643,7 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 6 unmodified lines
4708	ioc->pcie_sgl_dma_pool, GFP_KERNEL,	4643	ioc->pcie_sgl_dma_pool, GFP_KERNEL,
4709	&ioc->pcie_sg_lookup[i].pcie_sgl_dma);	4644	&ioc->pcie_sg_lookup[i].pcie_sgl_dma);
4710	if (!ioc->pcie_sg_lookup[i].pcie_sgl) {	4645	if (!ioc->pcie_sg_lookup[i].pcie_sgl) {
4711	pr_info(MPT3SAS_FMT	4646	ioc_info(ioc, "PCIe SGL pool: dma_pool_alloc failed\n");
4712	"PCIe SGL pool: dma_pool_alloc failed\n",
4713	ioc->name);
4714	goto out;	4647	goto out;
4715	}	4648	}
4716	for (j = 0; j < ioc->chains_per_prp_buffer; j++) {	4649	for (j = 0; j < ioc->chains_per_prp_buffer; j++) {
@@ -4724,20 +4657,20 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 7 unmodified lines
4724	}	4657	}
4725	}	4658	}
4726		4659
4727	dinitprintk(ioc, pr_info(MPT3SAS_FMT "PCIe sgl pool depth(%d), "	4660	dinitprintk(ioc,
4728	"element_size(%d), pool_size(%d kB)\n", ioc->name,	4661	ioc_info(ioc, "PCIe sgl pool depth(%d), element_size(%d), pool_size(%d kB)\n",
4729	ioc->scsiio_depth, sz, (sz * ioc->scsiio_depth)/1024));	4662	ioc->scsiio_depth, sz,
4730	dinitprintk(ioc, pr_info(MPT3SAS_FMT "Number of chains can "	4663	(sz * ioc->scsiio_depth) / 1024));
4731	"fit in a PRP page(%d)\n", ioc->name,	4664	dinitprintk(ioc,
4732	ioc->chains_per_prp_buffer));	4665	ioc_info(ioc, "Number of chains can fit in a PRP page(%d)\n",
		4666	ioc->chains_per_prp_buffer));
4733	total_sz += sz * ioc->scsiio_depth;	4667	total_sz += sz * ioc->scsiio_depth;
4734	}	4668	}
4735		4669
4736	ioc->chain_dma_pool = dma_pool_create("chain pool", &ioc->pdev->dev,	4670	ioc->chain_dma_pool = dma_pool_create("chain pool", &ioc->pdev->dev,
4737	ioc->chain_segment_sz, 16, 0);	4671	ioc->chain_segment_sz, 16, 0);
4738	if (!ioc->chain_dma_pool) {	4672	if (!ioc->chain_dma_pool) {
4739	pr_err(MPT3SAS_FMT "chain_dma_pool: dma_pool_create failed\n",	4673	ioc_err(ioc, "chain_dma_pool: dma_pool_create failed\n");
4740	ioc->name);
4741	goto out;	4674	goto out;
4742	}	4675	}
4743	for (i = 0; i < ioc->scsiio_depth; i++) {	4676	for (i = 0; i < ioc->scsiio_depth; i++) {
@@ -4748,8 +4681,7 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 4 unmodified lines
4748	ioc->chain_dma_pool, GFP_KERNEL,	4681	ioc->chain_dma_pool, GFP_KERNEL,
4749	&ct->chain_buffer_dma);	4682	&ct->chain_buffer_dma);
4750	if (!ct->chain_buffer) {	4683	if (!ct->chain_buffer) {
4751	pr_err(MPT3SAS_FMT "chain_lookup: "	4684	ioc_err(ioc, "chain_lookup: pci_pool_alloc failed\n");
4752	" pci_pool_alloc failed\n", ioc->name);
4753	_base_release_memory_pools(ioc);	4685	_base_release_memory_pools(ioc);
4754	goto out;	4686	goto out;
4755	}	4687	}
@@ -4757,25 +4689,23 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 1 unmodified line
4757	total_sz += ioc->chain_segment_sz;	4689	total_sz += ioc->chain_segment_sz;
4758	}	4690	}
4759		4691
4760	dinitprintk(ioc, pr_info(MPT3SAS_FMT	4692	dinitprintk(ioc,
4761	"chain pool depth(%d), frame_size(%d), pool_size(%d kB)\n",	4693	ioc_info(ioc, "chain pool depth(%d), frame_size(%d), pool_size(%d kB)\n",
4762	ioc->name, ioc->chain_depth, ioc->chain_segment_sz,	4694	ioc->chain_depth, ioc->chain_segment_sz,
4763	((ioc->chain_depth * ioc->chain_segment_sz))/1024));	4695	(ioc->chain_depth * ioc->chain_segment_sz) / 1024));
4764		4696
4765	/* sense buffers, 4 byte align */	4697	/* sense buffers, 4 byte align */
4766	sz = ioc->scsiio_depth * SCSI_SENSE_BUFFERSIZE;	4698	sz = ioc->scsiio_depth * SCSI_SENSE_BUFFERSIZE;
4767	ioc->sense_dma_pool = dma_pool_create("sense pool", &ioc->pdev->dev, sz,	4699	ioc->sense_dma_pool = dma_pool_create("sense pool", &ioc->pdev->dev, sz,
4768	4, 0);	4700	4, 0);
4769	if (!ioc->sense_dma_pool) {	4701	if (!ioc->sense_dma_pool) {
4770	pr_err(MPT3SAS_FMT "sense pool: dma_pool_create failed\n",	4702	ioc_err(ioc, "sense pool: dma_pool_create failed\n");
4771	ioc->name);
4772	goto out;	4703	goto out;
4773	}	4704	}
4774	ioc->sense = dma_pool_alloc(ioc->sense_dma_pool, GFP_KERNEL,	4705	ioc->sense = dma_pool_alloc(ioc->sense_dma_pool, GFP_KERNEL,
4775	&ioc->sense_dma);	4706	&ioc->sense_dma);
4776	if (!ioc->sense) {	4707	if (!ioc->sense) {
4777	pr_err(MPT3SAS_FMT "sense pool: dma_pool_alloc failed\n",	4708	ioc_err(ioc, "sense pool: dma_pool_alloc failed\n");
4778	ioc->name);
4779	goto out;	4709	goto out;
4780	}	4710	}
4781	/* sense buffer requires to be in same 4 gb region.	4711	/* sense buffer requires to be in same 4 gb region.
@@ -4797,24 +4727,23 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 15 unmodified lines
4797	dma_pool_create("sense pool", &ioc->pdev->dev, sz,	4727	dma_pool_create("sense pool", &ioc->pdev->dev, sz,
4798	roundup_pow_of_two(sz), 0);	4728	roundup_pow_of_two(sz), 0);
4799	if (!ioc->sense_dma_pool) {	4729	if (!ioc->sense_dma_pool) {
4800	pr_err(MPT3SAS_FMT "sense pool: pci_pool_create failed\n",	4730	ioc_err(ioc, "sense pool: pci_pool_create failed\n");
4801	ioc->name);
4802	goto out;	4731	goto out;
4803	}	4732	}
4804	ioc->sense = dma_pool_alloc(ioc->sense_dma_pool, GFP_KERNEL,	4733	ioc->sense = dma_pool_alloc(ioc->sense_dma_pool, GFP_KERNEL,
4805	&ioc->sense_dma);	4734	&ioc->sense_dma);
4806	if (!ioc->sense) {	4735	if (!ioc->sense) {
4807	pr_err(MPT3SAS_FMT "sense pool: pci_pool_alloc failed\n",	4736	ioc_err(ioc, "sense pool: pci_pool_alloc failed\n");
4808	ioc->name);
4809	goto out;	4737	goto out;
4810	}	4738	}
4811	}	4739	}
4812	dinitprintk(ioc, pr_info(MPT3SAS_FMT	4740	dinitprintk(ioc,
4813	"sense pool(0x%p): depth(%d), element_size(%d), pool_size"	4741	ioc_info(ioc, "sense pool(0x%p): depth(%d), element_size(%d), pool_size(%d kB)\n",
4814	"(%d kB)\n", ioc->name, ioc->sense, ioc->scsiio_depth,	4742	ioc->sense, ioc->scsiio_depth,
4815	SCSI_SENSE_BUFFERSIZE, sz/1024));	4743	SCSI_SENSE_BUFFERSIZE, sz / 1024));
4816	dinitprintk(ioc, pr_info(MPT3SAS_FMT "sense_dma(0x%llx)\n",	4744	dinitprintk(ioc,
4817	ioc->name, (unsigned long long)ioc->sense_dma));	4745	ioc_info(ioc, "sense_dma(0x%llx)\n",
		4746	(unsigned long long)ioc->sense_dma));
4818	total_sz += sz;	4747	total_sz += sz;
4819		4748
4820	/* reply pool, 4 byte align */	4749	/* reply pool, 4 byte align */
@@ -4822,25 +4751,24 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 1 unmodified line
4822	ioc->reply_dma_pool = dma_pool_create("reply pool", &ioc->pdev->dev, sz,	4751	ioc->reply_dma_pool = dma_pool_create("reply pool", &ioc->pdev->dev, sz,
4823	4, 0);	4752	4, 0);
4824	if (!ioc->reply_dma_pool) {	4753	if (!ioc->reply_dma_pool) {
4825	pr_err(MPT3SAS_FMT "reply pool: dma_pool_create failed\n",	4754	ioc_err(ioc, "reply pool: dma_pool_create failed\n");
4826	ioc->name);
4827	goto out;	4755	goto out;
4828	}	4756	}
4829	ioc->reply = dma_pool_alloc(ioc->reply_dma_pool, GFP_KERNEL,	4757	ioc->reply = dma_pool_alloc(ioc->reply_dma_pool, GFP_KERNEL,
4830	&ioc->reply_dma);	4758	&ioc->reply_dma);
4831	if (!ioc->reply) {	4759	if (!ioc->reply) {
4832	pr_err(MPT3SAS_FMT "reply pool: dma_pool_alloc failed\n",	4760	ioc_err(ioc, "reply pool: dma_pool_alloc failed\n");
4833	ioc->name);
4834	goto out;	4761	goto out;
4835	}	4762	}
4836	ioc->reply_dma_min_address = (u32)(ioc->reply_dma);	4763	ioc->reply_dma_min_address = (u32)(ioc->reply_dma);
4837	ioc->reply_dma_max_address = (u32)(ioc->reply_dma) + sz;	4764	ioc->reply_dma_max_address = (u32)(ioc->reply_dma) + sz;
4838	dinitprintk(ioc, pr_info(MPT3SAS_FMT	4765	dinitprintk(ioc,
4839	"reply pool(0x%p): depth(%d), frame_size(%d), pool_size(%d kB)\n",	4766	ioc_info(ioc, "reply pool(0x%p): depth(%d), frame_size(%d), pool_size(%d kB)\n",
4840	ioc->name, ioc->reply,	4767	ioc->reply, ioc->reply_free_queue_depth,
4841	ioc->reply_free_queue_depth, ioc->reply_sz, sz/1024));	4768	ioc->reply_sz, sz / 1024));
4842	dinitprintk(ioc, pr_info(MPT3SAS_FMT "reply_dma(0x%llx)\n",	4769	dinitprintk(ioc,
4843	ioc->name, (unsigned long long)ioc->reply_dma));	4770	ioc_info(ioc, "reply_dma(0x%llx)\n",
		4771	(unsigned long long)ioc->reply_dma));
4844	total_sz += sz;	4772	total_sz += sz;
4845		4773
4846	/* reply free queue, 16 byte align */	4774	/* reply free queue, 16 byte align */
@@ -4848,24 +4776,22 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 1 unmodified line
4848	ioc->reply_free_dma_pool = dma_pool_create("reply_free pool",	4776	ioc->reply_free_dma_pool = dma_pool_create("reply_free pool",
4849	&ioc->pdev->dev, sz, 16, 0);	4777	&ioc->pdev->dev, sz, 16, 0);
4850	if (!ioc->reply_free_dma_pool) {	4778	if (!ioc->reply_free_dma_pool) {
4851	pr_err(MPT3SAS_FMT "reply_free pool: dma_pool_create failed\n",	4779	ioc_err(ioc, "reply_free pool: dma_pool_create failed\n");
4852	ioc->name);
4853	goto out;	4780	goto out;
4854	}	4781	}
4855	ioc->reply_free = dma_pool_alloc(ioc->reply_free_dma_pool, GFP_KERNEL,	4782	ioc->reply_free = dma_pool_zalloc(ioc->reply_free_dma_pool, GFP_KERNEL,
4856	&ioc->reply_free_dma);	4783	&ioc->reply_free_dma);
4857	if (!ioc->reply_free) {	4784	if (!ioc->reply_free) {
4858	pr_err(MPT3SAS_FMT "reply_free pool: dma_pool_alloc failed\n",	4785	ioc_err(ioc, "reply_free pool: dma_pool_alloc failed\n");
4859	ioc->name);
4860	goto out;	4786	goto out;
4861	}	4787	}
4862	memset(ioc->reply_free, 0, sz);	4788	dinitprintk(ioc,
4863	dinitprintk(ioc, pr_info(MPT3SAS_FMT "reply_free pool(0x%p): " \	4789	ioc_info(ioc, "reply_free pool(0x%p): depth(%d), element_size(%d), pool_size(%d kB)\n",
4864	"depth(%d), element_size(%d), pool_size(%d kB)\n", ioc->name,	4790	ioc->reply_free, ioc->reply_free_queue_depth,
4865	ioc->reply_free, ioc->reply_free_queue_depth, 4, sz/1024));	4791	4, sz / 1024));
4866	dinitprintk(ioc, pr_info(MPT3SAS_FMT	4792	dinitprintk(ioc,
4867	"reply_free_dma (0x%llx)\n",	4793	ioc_info(ioc, "reply_free_dma (0x%llx)\n",
4868	ioc->name, (unsigned long long)ioc->reply_free_dma));	4794	(unsigned long long)ioc->reply_free_dma));
4869	total_sz += sz;	4795	total_sz += sz;
4870		4796
4871	if (ioc->rdpq_array_enable) {	4797	if (ioc->rdpq_array_enable) {
@@ -4876,8 +4802,7 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 4 unmodified lines
4876	&ioc->pdev->dev, reply_post_free_array_sz, 16, 0);	4802	&ioc->pdev->dev, reply_post_free_array_sz, 16, 0);
4877	if (!ioc->reply_post_free_array_dma_pool) {	4803	if (!ioc->reply_post_free_array_dma_pool) {
4878	dinitprintk(ioc,	4804	dinitprintk(ioc,
4879	pr_info(MPT3SAS_FMT "reply_post_free_array pool: "	4805	ioc_info(ioc, "reply_post_free_array pool: dma_pool_create failed\n"));
4880	"dma_pool_create failed\n", ioc->name));
4881	goto out;	4806	goto out;
4882	}	4807	}
4883	ioc->reply_post_free_array =	4808	ioc->reply_post_free_array =
@@ -4885,34 +4810,31 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 1 unmodified line
4885	GFP_KERNEL, &ioc->reply_post_free_array_dma);	4810	GFP_KERNEL, &ioc->reply_post_free_array_dma);
4886	if (!ioc->reply_post_free_array) {	4811	if (!ioc->reply_post_free_array) {
4887	dinitprintk(ioc,	4812	dinitprintk(ioc,
4888	pr_info(MPT3SAS_FMT "reply_post_free_array pool: "	4813	ioc_info(ioc, "reply_post_free_array pool: dma_pool_alloc failed\n"));
4889	"dma_pool_alloc failed\n", ioc->name));
4890	goto out;	4814	goto out;
4891	}	4815	}
4892	}	4816	}
4893	ioc->config_page_sz = 512;	4817	ioc->config_page_sz = 512;
4894	ioc->config_page = pci_alloc_consistent(ioc->pdev,	4818	ioc->config_page = dma_alloc_coherent(&ioc->pdev->dev,
4895	ioc->config_page_sz, &ioc->config_page_dma);	4819	ioc->config_page_sz, &ioc->config_page_dma, GFP_KERNEL);
4896	if (!ioc->config_page) {	4820	if (!ioc->config_page) {
4897	pr_err(MPT3SAS_FMT	4821	ioc_err(ioc, "config page: dma_pool_alloc failed\n");
4898	"config page: dma_pool_alloc failed\n",
4899	ioc->name);
4900	goto out;	4822	goto out;
4901	}	4823	}
4902	dinitprintk(ioc, pr_info(MPT3SAS_FMT	4824	dinitprintk(ioc,
4903	"config page(0x%p): size(%d)\n",	4825	ioc_info(ioc, "config page(0x%p): size(%d)\n",
4904	ioc->name, ioc->config_page, ioc->config_page_sz));	4826	ioc->config_page, ioc->config_page_sz));
4905	dinitprintk(ioc, pr_info(MPT3SAS_FMT "config_page_dma(0x%llx)\n",	4827	dinitprintk(ioc,
4906	ioc->name, (unsigned long long)ioc->config_page_dma));	4828	ioc_info(ioc, "config_page_dma(0x%llx)\n",
		4829	(unsigned long long)ioc->config_page_dma));
4907	total_sz += ioc->config_page_sz;	4830	total_sz += ioc->config_page_sz;
4908		4831
4909	pr_info(MPT3SAS_FMT "Allocated physical memory: size(%d kB)\n",	4832	ioc_info(ioc, "Allocated physical memory: size(%d kB)\n",
4910	ioc->name, total_sz/1024);	4833	total_sz / 1024);
4911	pr_info(MPT3SAS_FMT	4834	ioc_info(ioc, "Current Controller Queue Depth(%d),Max Controller Queue Depth(%d)\n",
4912	"Current Controller Queue Depth(%d),Max Controller Queue Depth(%d)\n",	4835	ioc->shost->can_queue, facts->RequestCredit);
4913	ioc->name, ioc->shost->can_queue, facts->RequestCredit);	4836	ioc_info(ioc, "Scatter Gather Elements per IO(%d)\n",
4914	pr_info(MPT3SAS_FMT "Scatter Gather Elements per IO(%d)\n",	4837	ioc->shost->sg_tablesize);
4915	ioc->name, ioc->shost->sg_tablesize);
4916	return 0;	4838	return 0;
4917		4839
4918	out:	4840	out:
@@ -4990,9 +4912,9 @@ _base_wait_for_doorbell_int(struct MPT3SAS_ADAPTER *ioc, int timeout) · 71 unmodified lines
4990	do {	4912	do {
4991	int_status = readl(&ioc->chip->HostInterruptStatus);	4913	int_status = readl(&ioc->chip->HostInterruptStatus);
4992	if (int_status & MPI2_HIS_IOC2SYS_DB_STATUS) {	4914	if (int_status & MPI2_HIS_IOC2SYS_DB_STATUS) {
4993	dhsprintk(ioc, pr_info(MPT3SAS_FMT	4915	dhsprintk(ioc,
4994	"%s: successful count(%d), timeout(%d)\n",	4916	ioc_info(ioc, "%s: successful count(%d), timeout(%d)\n",
4995	ioc->name, __func__, count, timeout));	4917	__func__, count, timeout));
4996	return 0;	4918	return 0;
4997	}	4919	}
4998		4920
@@ -5000,9 +4922,8 @@ _base_wait_for_doorbell_int(struct MPT3SAS_ADAPTER *ioc, int timeout) · 1 unmodified line
5000	count++;	4922	count++;
5001	} while (--cntdn);	4923	} while (--cntdn);
5002		4924
5003	pr_err(MPT3SAS_FMT	4925	ioc_err(ioc, "%s: failed due to timeout count(%d), int_status(%x)!\n",
5004	"%s: failed due to timeout count(%d), int_status(%x)!\n",	4926	__func__, count, int_status);
5005	ioc->name, __func__, count, int_status);
5006	return -EFAULT;	4927	return -EFAULT;
5007	}	4928	}
5008		4929
@@ -5017,9 +4938,9 @@ _base_spin_on_doorbell_int(struct MPT3SAS_ADAPTER *ioc, int timeout) · 8 unmodified lines
5017	do {	4938	do {
5018	int_status = readl(&ioc->chip->HostInterruptStatus);	4939	int_status = readl(&ioc->chip->HostInterruptStatus);
5019	if (int_status & MPI2_HIS_IOC2SYS_DB_STATUS) {	4940	if (int_status & MPI2_HIS_IOC2SYS_DB_STATUS) {
5020	dhsprintk(ioc, pr_info(MPT3SAS_FMT	4941	dhsprintk(ioc,
5021	"%s: successful count(%d), timeout(%d)\n",	4942	ioc_info(ioc, "%s: successful count(%d), timeout(%d)\n",
5022	ioc->name, __func__, count, timeout));	4943	__func__, count, timeout));
5023	return 0;	4944	return 0;
5024	}	4945	}
5025		4946
@@ -5027,9 +4948,8 @@ _base_spin_on_doorbell_int(struct MPT3SAS_ADAPTER *ioc, int timeout) · 1 unmodified line
5027	count++;	4948	count++;
5028	} while (--cntdn);	4949	} while (--cntdn);
5029		4950
5030	pr_err(MPT3SAS_FMT	4951	ioc_err(ioc, "%s: failed due to timeout count(%d), int_status(%x)!\n",
5031	"%s: failed due to timeout count(%d), int_status(%x)!\n",	4952	__func__, count, int_status);
5032	ioc->name, __func__, count, int_status);
5033	return -EFAULT;	4953	return -EFAULT;
5034		4954
5035	}	4955	}
@@ -5056,9 +4976,9 @@ _base_wait_for_doorbell_ack(struct MPT3SAS_ADAPTER *ioc, int timeout) · 20 unmodified lines
5056	do {	4976	do {
5057	int_status = readl(&ioc->chip->HostInterruptStatus);	4977	int_status = readl(&ioc->chip->HostInterruptStatus);
5058	if (!(int_status & MPI2_HIS_SYS2IOC_DB_STATUS)) {	4978	if (!(int_status & MPI2_HIS_SYS2IOC_DB_STATUS)) {
5059	dhsprintk(ioc, pr_info(MPT3SAS_FMT	4979	dhsprintk(ioc,
5060	"%s: successful count(%d), timeout(%d)\n",	4980	ioc_info(ioc, "%s: successful count(%d), timeout(%d)\n",
5061	ioc->name, __func__, count, timeout));	4981	__func__, count, timeout));
5062	return 0;	4982	return 0;
5063	} else if (int_status & MPI2_HIS_IOC2SYS_DB_STATUS) {	4983	} else if (int_status & MPI2_HIS_IOC2SYS_DB_STATUS) {
5064	doorbell = readl(&ioc->chip->Doorbell);	4984	doorbell = readl(&ioc->chip->Doorbell);
@@ -5075,9 +4995,8 @@ _base_wait_for_doorbell_ack(struct MPT3SAS_ADAPTER *ioc, int timeout) · 10 unmodified lines
5075	} while (--cntdn);	4995	} while (--cntdn);
5076		4996
5077	out:	4997	out:
5078	pr_err(MPT3SAS_FMT	4998	ioc_err(ioc, "%s: failed due to timeout count(%d), int_status(%x)!\n",
5079	"%s: failed due to timeout count(%d), int_status(%x)!\n",	4999	__func__, count, int_status);
5080	ioc->name, __func__, count, int_status);
5081	return -EFAULT;	5000	return -EFAULT;
5082	}	5001	}
5083		5002
@@ -5099,9 +5018,9 @@ _base_wait_for_doorbell_not_used(struct MPT3SAS_ADAPTER *ioc, int timeout) · 15 unmodified lines
5099	do {	5018	do {
5100	doorbell_reg = readl(&ioc->chip->Doorbell);	5019	doorbell_reg = readl(&ioc->chip->Doorbell);
5101	if (!(doorbell_reg & MPI2_DOORBELL_USED)) {	5020	if (!(doorbell_reg & MPI2_DOORBELL_USED)) {
5102	dhsprintk(ioc, pr_info(MPT3SAS_FMT	5021	dhsprintk(ioc,
5103	"%s: successful count(%d), timeout(%d)\n",	5022	ioc_info(ioc, "%s: successful count(%d), timeout(%d)\n",
5104	ioc->name, __func__, count, timeout));	5023	__func__, count, timeout));
5105	return 0;	5024	return 0;
5106	}	5025	}
5107		5026
@@ -5109,9 +5028,8 @@ _base_wait_for_doorbell_not_used(struct MPT3SAS_ADAPTER *ioc, int timeout) · 1 unmodified line
5109	count++;	5028	count++;
5110	} while (--cntdn);	5029	} while (--cntdn);
5111		5030
5112	pr_err(MPT3SAS_FMT	5031	ioc_err(ioc, "%s: failed due to timeout count(%d), doorbell_reg(%x)!\n",
5113	"%s: failed due to timeout count(%d), doorbell_reg(%x)!\n",	5032	__func__, count, doorbell_reg);
5114	ioc->name, __func__, count, doorbell_reg);
5115	return -EFAULT;	5033	return -EFAULT;
5116	}	5034	}
5117		5035
@@ -5130,8 +5048,7 @@ _base_send_ioc_reset(struct MPT3SAS_ADAPTER *ioc, u8 reset_type, int timeout) · 12 unmodified lines
5130	int r = 0;	5048	int r = 0;
5131		5049
5132	if (reset_type != MPI2_FUNCTION_IOC_MESSAGE_UNIT_RESET) {	5050	if (reset_type != MPI2_FUNCTION_IOC_MESSAGE_UNIT_RESET) {
5133	pr_err(MPT3SAS_FMT "%s: unknown reset_type\n",	5051	ioc_err(ioc, "%s: unknown reset_type\n", __func__);
5134	ioc->name, __func__);
5135	return -EFAULT;	5052	return -EFAULT;
5136	}	5053	}
5137		5054
@@ -5139,7 +5056,7 @@ _base_send_ioc_reset(struct MPT3SAS_ADAPTER *ioc, u8 reset_type, int timeout) · 1 unmodified line
5139	MPI2_IOCFACTS_CAPABILITY_EVENT_REPLAY))	5056	MPI2_IOCFACTS_CAPABILITY_EVENT_REPLAY))
5140	return -EFAULT;	5057	return -EFAULT;
5141		5058
5142	pr_info(MPT3SAS_FMT "sending message unit reset !!\n", ioc->name);	5059	ioc_info(ioc, "sending message unit reset !!\n");
5143		5060
5144	writel(reset_type << MPI2_DOORBELL_FUNCTION_SHIFT,	5061	writel(reset_type << MPI2_DOORBELL_FUNCTION_SHIFT,
5145	&ioc->chip->Doorbell);	5062	&ioc->chip->Doorbell);
@@ -5149,15 +5066,14 @@ _base_send_ioc_reset(struct MPT3SAS_ADAPTER *ioc, u8 reset_type, int timeout) · 3 unmodified lines
5149	}	5066	}
5150	ioc_state = _base_wait_on_iocstate(ioc, MPI2_IOC_STATE_READY, timeout);	5067	ioc_state = _base_wait_on_iocstate(ioc, MPI2_IOC_STATE_READY, timeout);
5151	if (ioc_state) {	5068	if (ioc_state) {
5152	pr_err(MPT3SAS_FMT	5069	ioc_err(ioc, "%s: failed going to ready state (ioc_state=0x%x)\n",
5153	"%s: failed going to ready state (ioc_state=0x%x)\n",	5070	__func__, ioc_state);
5154	ioc->name, __func__, ioc_state);
5155	r = -EFAULT;	5071	r = -EFAULT;
5156	goto out;	5072	goto out;
5157	}	5073	}
5158	out:	5074	out:
5159	pr_info(MPT3SAS_FMT "message unit reset: %s\n",	5075	ioc_info(ioc, "message unit reset: %s\n",
5160	ioc->name, ((r == 0) ? "SUCCESS" : "FAILED"));	5076	r == 0 ? "SUCCESS" : "FAILED");
5161	return r;	5077	return r;
5162	}	5078	}
5163		5079
@@ -5183,9 +5099,7 @@ _base_handshake_req_reply_wait(struct MPT3SAS_ADAPTER *ioc, int request_bytes, · 19 unmodified lines
5183		5099
5184	/* make sure doorbell is not in use */	5100	/* make sure doorbell is not in use */
5185	if ((readl(&ioc->chip->Doorbell) & MPI2_DOORBELL_USED)) {	5101	if ((readl(&ioc->chip->Doorbell) & MPI2_DOORBELL_USED)) {
5186	pr_err(MPT3SAS_FMT	5102	ioc_err(ioc, "doorbell is in use (line=%d)\n", __LINE__);
5187	"doorbell is in use (line=%d)\n",
5188	ioc->name, __LINE__);
5189	return -EFAULT;	5103	return -EFAULT;
5190	}	5104	}
5191		5105
@@ -5200,17 +5114,15 @@ _base_handshake_req_reply_wait(struct MPT3SAS_ADAPTER *ioc, int request_bytes, · 8 unmodified lines
5200	&ioc->chip->Doorbell);	5114	&ioc->chip->Doorbell);
5201		5115
5202	if ((_base_spin_on_doorbell_int(ioc, 5))) {	5116	if ((_base_spin_on_doorbell_int(ioc, 5))) {
5203	pr_err(MPT3SAS_FMT	5117	ioc_err(ioc, "doorbell handshake int failed (line=%d)\n",
5204	"doorbell handshake int failed (line=%d)\n",	5118	__LINE__);
5205	ioc->name, __LINE__);
5206	return -EFAULT;	5119	return -EFAULT;
5207	}	5120	}
5208	writel(0, &ioc->chip->HostInterruptStatus);	5121	writel(0, &ioc->chip->HostInterruptStatus);
5209		5122
5210	if ((_base_wait_for_doorbell_ack(ioc, 5))) {	5123	if ((_base_wait_for_doorbell_ack(ioc, 5))) {
5211	pr_err(MPT3SAS_FMT	5124	ioc_err(ioc, "doorbell handshake ack failed (line=%d)\n",
5212	"doorbell handshake ack failed (line=%d)\n",	5125	__LINE__);
5213	ioc->name, __LINE__);
5214	return -EFAULT;	5126	return -EFAULT;
5215	}	5127	}
5216		5128
@@ -5222,17 +5134,15 @@ _base_handshake_req_reply_wait(struct MPT3SAS_ADAPTER *ioc, int request_bytes, · 5 unmodified lines
5222	}	5134	}
5223		5135
5224	if (failed) {	5136	if (failed) {
5225	pr_err(MPT3SAS_FMT	5137	ioc_err(ioc, "doorbell handshake sending request failed (line=%d)\n",
5226	"doorbell handshake sending request failed (line=%d)\n",	5138	__LINE__);
5227	ioc->name, __LINE__);
5228	return -EFAULT;	5139	return -EFAULT;
5229	}	5140	}
5230		5141
5231	/* now wait for the reply */	5142	/* now wait for the reply */
5232	if ((_base_wait_for_doorbell_int(ioc, timeout))) {	5143	if ((_base_wait_for_doorbell_int(ioc, timeout))) {
5233	pr_err(MPT3SAS_FMT	5144	ioc_err(ioc, "doorbell handshake int failed (line=%d)\n",
5234	"doorbell handshake int failed (line=%d)\n",	5145	__LINE__);
5235	ioc->name, __LINE__);
5236	return -EFAULT;	5146	return -EFAULT;
5237	}	5147	}
5238		5148
@@ -5241,9 +5151,8 @@ _base_handshake_req_reply_wait(struct MPT3SAS_ADAPTER *ioc, int request_bytes, · 2 unmodified lines
5241	& MPI2_DOORBELL_DATA_MASK);	5151	& MPI2_DOORBELL_DATA_MASK);
5242	writel(0, &ioc->chip->HostInterruptStatus);	5152	writel(0, &ioc->chip->HostInterruptStatus);
5243	if ((_base_wait_for_doorbell_int(ioc, 5))) {	5153	if ((_base_wait_for_doorbell_int(ioc, 5))) {
5244	pr_err(MPT3SAS_FMT	5154	ioc_err(ioc, "doorbell handshake int failed (line=%d)\n",
5245	"doorbell handshake int failed (line=%d)\n",	5155	__LINE__);
5246	ioc->name, __LINE__);
5247	return -EFAULT;	5156	return -EFAULT;
5248	}	5157	}
5249	reply[1] = le16_to_cpu(readl(&ioc->chip->Doorbell)	5158	reply[1] = le16_to_cpu(readl(&ioc->chip->Doorbell)
@@ -5252,9 +5161,8 @@ _base_handshake_req_reply_wait(struct MPT3SAS_ADAPTER *ioc, int request_bytes, · 2 unmodified lines
5252		5161
5253	for (i = 2; i < default_reply->MsgLength * 2; i++) {	5162	for (i = 2; i < default_reply->MsgLength * 2; i++) {
5254	if ((_base_wait_for_doorbell_int(ioc, 5))) {	5163	if ((_base_wait_for_doorbell_int(ioc, 5))) {
5255	pr_err(MPT3SAS_FMT	5164	ioc_err(ioc, "doorbell handshake int failed (line=%d)\n",
5256	"doorbell handshake int failed (line=%d)\n",	5165	__LINE__);
5257	ioc->name, __LINE__);
5258	return -EFAULT;	5166	return -EFAULT;
5259	}	5167	}
5260	if (i >= reply_bytes/2) /* overflow case */	5168	if (i >= reply_bytes/2) /* overflow case */
@@ -5267,8 +5175,9 @@ _base_handshake_req_reply_wait(struct MPT3SAS_ADAPTER *ioc, int request_bytes, · 6 unmodified lines
5267		5175
5268	_base_wait_for_doorbell_int(ioc, 5);	5176	_base_wait_for_doorbell_int(ioc, 5);
5269	if (_base_wait_for_doorbell_not_used(ioc, 5) != 0) {	5177	if (_base_wait_for_doorbell_not_used(ioc, 5) != 0) {
5270	dhsprintk(ioc, pr_info(MPT3SAS_FMT	5178	dhsprintk(ioc,
5271	"doorbell is in use (line=%d)\n", ioc->name, __LINE__));	5179	ioc_info(ioc, "doorbell is in use (line=%d)\n",
		5180	__LINE__));
5272	}	5181	}
5273	writel(0, &ioc->chip->HostInterruptStatus);	5182	writel(0, &ioc->chip->HostInterruptStatus);
5274		5183
@@ -5308,14 +5217,12 @@ mpt3sas_base_sas_iounit_control(struct MPT3SAS_ADAPTER *ioc, · 33 unmodified lines
5308	void *request;	5217	void *request;
5309	u16 wait_state_count;	5218	u16 wait_state_count;
5310		5219
5311	dinitprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,	5220	dinitprintk(ioc, ioc_info(ioc, "%s\n", __func__));
5312	__func__));
5313		5221
5314	mutex_lock(&ioc->base_cmds.mutex);	5222	mutex_lock(&ioc->base_cmds.mutex);
5315		5223
5316	if (ioc->base_cmds.status != MPT3_CMD_NOT_USED) {	5224	if (ioc->base_cmds.status != MPT3_CMD_NOT_USED) {
5317	pr_err(MPT3SAS_FMT "%s: base_cmd in use\n",	5225	ioc_err(ioc, "%s: base_cmd in use\n", __func__);
5318	ioc->name, __func__);
5319	rc = -EAGAIN;	5226	rc = -EAGAIN;
5320	goto out;	5227	goto out;
5321	}	5228	}
@@ -5324,23 +5231,20 @@ mpt3sas_base_sas_iounit_control(struct MPT3SAS_ADAPTER *ioc, · 2 unmodified lines
5324	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);	5231	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
5325	while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {	5232	while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
5326	if (wait_state_count++ == 10) {	5233	if (wait_state_count++ == 10) {
5327	pr_err(MPT3SAS_FMT	5234	ioc_err(ioc, "%s: failed due to ioc not operational\n",
5328	"%s: failed due to ioc not operational\n",	5235	__func__);
5329	ioc->name, __func__);
5330	rc = -EFAULT;	5236	rc = -EFAULT;
5331	goto out;	5237	goto out;
5332	}	5238	}
5333	ssleep(1);	5239	ssleep(1);
5334	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);	5240	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
5335	pr_info(MPT3SAS_FMT	5241	ioc_info(ioc, "%s: waiting for operational state(count=%d)\n",
5336	"%s: waiting for operational state(count=%d)\n",	5242	__func__, wait_state_count);
5337	ioc->name, __func__, wait_state_count);
5338	}	5243	}
5339		5244
5340	smid = mpt3sas_base_get_smid(ioc, ioc->base_cb_idx);	5245	smid = mpt3sas_base_get_smid(ioc, ioc->base_cb_idx);
5341	if (!smid) {	5246	if (!smid) {
5342	pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",	5247	ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
5343	ioc->name, __func__);
5344	rc = -EAGAIN;	5248	rc = -EAGAIN;
5345	goto out;	5249	goto out;
5346	}	5250	}
@@ -5408,14 +5312,12 @@ mpt3sas_base_scsi_enclosure_processor(struct MPT3SAS_ADAPTER *ioc, · 61 unmodified lines
5408	void *request;	5312	void *request;
5409	u16 wait_state_count;	5313	u16 wait_state_count;
5410		5314
5411	dinitprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,	5315	dinitprintk(ioc, ioc_info(ioc, "%s\n", __func__));
5412	__func__));
5413		5316
5414	mutex_lock(&ioc->base_cmds.mutex);	5317	mutex_lock(&ioc->base_cmds.mutex);
5415		5318
5416	if (ioc->base_cmds.status != MPT3_CMD_NOT_USED) {	5319	if (ioc->base_cmds.status != MPT3_CMD_NOT_USED) {
5417	pr_err(MPT3SAS_FMT "%s: base_cmd in use\n",	5320	ioc_err(ioc, "%s: base_cmd in use\n", __func__);
5418	ioc->name, __func__);
5419	rc = -EAGAIN;	5321	rc = -EAGAIN;
5420	goto out;	5322	goto out;
5421	}	5323	}
@@ -5424,24 +5326,20 @@ mpt3sas_base_scsi_enclosure_processor(struct MPT3SAS_ADAPTER *ioc, · 2 unmodified lines
5424	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);	5326	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
5425	while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {	5327	while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
5426	if (wait_state_count++ == 10) {	5328	if (wait_state_count++ == 10) {
5427	pr_err(MPT3SAS_FMT	5329	ioc_err(ioc, "%s: failed due to ioc not operational\n",
5428	"%s: failed due to ioc not operational\n",	5330	__func__);
5429	ioc->name, __func__);
5430	rc = -EFAULT;	5331	rc = -EFAULT;
5431	goto out;	5332	goto out;
5432	}	5333	}
5433	ssleep(1);	5334	ssleep(1);
5434	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);	5335	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
5435	pr_info(MPT3SAS_FMT	5336	ioc_info(ioc, "%s: waiting for operational state(count=%d)\n",
5436	"%s: waiting for operational state(count=%d)\n",	5337	__func__, wait_state_count);
5437	ioc->name,
5438	__func__, wait_state_count);
5439	}	5338	}
5440		5339
5441	smid = mpt3sas_base_get_smid(ioc, ioc->base_cb_idx);	5340	smid = mpt3sas_base_get_smid(ioc, ioc->base_cb_idx);
5442	if (!smid) {	5341	if (!smid) {
5443	pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",	5342	ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
5444	ioc->name, __func__);
5445	rc = -EAGAIN;	5343	rc = -EAGAIN;
5446	goto out;	5344	goto out;
5447	}	5345	}
@@ -5495,8 +5393,7 @@ _base_get_port_facts(struct MPT3SAS_ADAPTER *ioc, int port) · 47 unmodified lines
5495	struct mpt3sas_port_facts *pfacts;	5393	struct mpt3sas_port_facts *pfacts;
5496	int mpi_reply_sz, mpi_request_sz, r;	5394	int mpi_reply_sz, mpi_request_sz, r;
5497		5395
5498	dinitprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,	5396	dinitprintk(ioc, ioc_info(ioc, "%s\n", __func__));
5499	__func__));
5500		5397
5501	mpi_reply_sz = sizeof(Mpi2PortFactsReply_t);	5398	mpi_reply_sz = sizeof(Mpi2PortFactsReply_t);
5502	mpi_request_sz = sizeof(Mpi2PortFactsRequest_t);	5399	mpi_request_sz = sizeof(Mpi2PortFactsRequest_t);
@@ -5507,8 +5404,7 @@ _base_get_port_facts(struct MPT3SAS_ADAPTER *ioc, int port) · 4 unmodified lines
5507	(u32 )&mpi_request, mpi_reply_sz, (u16 )&mpi_reply, 5);	5404	(u32 )&mpi_request, mpi_reply_sz, (u16 )&mpi_reply, 5);
5508		5405
5509	if (r != 0) {	5406	if (r != 0) {
5510	pr_err(MPT3SAS_FMT "%s: handshake failed (r=%d)\n",	5407	ioc_err(ioc, "%s: handshake failed (r=%d)\n", __func__, r);
5511	ioc->name, __func__, r);
5512	return r;	5408	return r;
5513	}	5409	}
5514		5410
@@ -5536,26 +5432,26 @@ _base_wait_for_iocstate(struct MPT3SAS_ADAPTER *ioc, int timeout) · 21 unmodified lines
5536	u32 ioc_state;	5432	u32 ioc_state;
5537	int rc;	5433	int rc;
5538		5434
5539	dinitprintk(ioc, printk(MPT3SAS_FMT "%s\n", ioc->name,	5435	dinitprintk(ioc, ioc_info(ioc, "%s\n", __func__));
5540	__func__));
5541		5436
5542	if (ioc->pci_error_recovery) {	5437	if (ioc->pci_error_recovery) {
5543	dfailprintk(ioc, printk(MPT3SAS_FMT	5438	dfailprintk(ioc,
5544	"%s: host in pci error recovery\n", ioc->name, __func__));	5439	ioc_info(ioc, "%s: host in pci error recovery\n",
		5440	__func__));
5545	return -EFAULT;	5441	return -EFAULT;
5546	}	5442	}
5547		5443
5548	ioc_state = mpt3sas_base_get_iocstate(ioc, 0);	5444	ioc_state = mpt3sas_base_get_iocstate(ioc, 0);
5549	dhsprintk(ioc, printk(MPT3SAS_FMT "%s: ioc_state(0x%08x)\n",	5445	dhsprintk(ioc,
5550	ioc->name, __func__, ioc_state));	5446	ioc_info(ioc, "%s: ioc_state(0x%08x)\n",
		5447	__func__, ioc_state));
5551		5448
5552	if (((ioc_state & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_READY) \|\|	5449	if (((ioc_state & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_READY) \|\|
5553	(ioc_state & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_OPERATIONAL)	5450	(ioc_state & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_OPERATIONAL)
5554	return 0;	5451	return 0;
5555		5452
5556	if (ioc_state & MPI2_DOORBELL_USED) {	5453	if (ioc_state & MPI2_DOORBELL_USED) {
5557	dhsprintk(ioc, printk(MPT3SAS_FMT	5454	dhsprintk(ioc, ioc_info(ioc, "unexpected doorbell active!\n"));
5558	"unexpected doorbell active!\n", ioc->name));
5559	goto issue_diag_reset;	5455	goto issue_diag_reset;
5560	}	5456	}
5561		5457
@@ -5567,9 +5463,9 @@ _base_wait_for_iocstate(struct MPT3SAS_ADAPTER *ioc, int timeout) · 5 unmodified lines
5567		5463
5568	ioc_state = _base_wait_on_iocstate(ioc, MPI2_IOC_STATE_READY, timeout);	5464	ioc_state = _base_wait_on_iocstate(ioc, MPI2_IOC_STATE_READY, timeout);
5569	if (ioc_state) {	5465	if (ioc_state) {
5570	dfailprintk(ioc, printk(MPT3SAS_FMT	5466	dfailprintk(ioc,
5571	"%s: failed going to ready state (ioc_state=0x%x)\n",	5467	ioc_info(ioc, "%s: failed going to ready state (ioc_state=0x%x)\n",
5572	ioc->name, __func__, ioc_state));	5468	__func__, ioc_state));
5573	return -EFAULT;	5469	return -EFAULT;
5574	}	5470	}
5575		5471
@@ -5592,14 +5488,13 @@ _base_get_ioc_facts(struct MPT3SAS_ADAPTER *ioc) · 16 unmodified lines
5592	struct mpt3sas_facts *facts;	5488	struct mpt3sas_facts *facts;
5593	int mpi_reply_sz, mpi_request_sz, r;	5489	int mpi_reply_sz, mpi_request_sz, r;
5594		5490
5595	dinitprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,	5491	dinitprintk(ioc, ioc_info(ioc, "%s\n", __func__));
5596	__func__));
5597		5492
5598	r = _base_wait_for_iocstate(ioc, 10);	5493	r = _base_wait_for_iocstate(ioc, 10);
5599	if (r) {	5494	if (r) {
5600	dfailprintk(ioc, printk(MPT3SAS_FMT	5495	dfailprintk(ioc,
5601	"%s: failed getting to correct state\n",	5496	ioc_info(ioc, "%s: failed getting to correct state\n",
5602	ioc->name, __func__));	5497	__func__));
5603	return r;	5498	return r;
5604	}	5499	}
5605	mpi_reply_sz = sizeof(Mpi2IOCFactsReply_t);	5500	mpi_reply_sz = sizeof(Mpi2IOCFactsReply_t);
@@ -5610,8 +5505,7 @@ _base_get_ioc_facts(struct MPT3SAS_ADAPTER *ioc) · 4 unmodified lines
5610	(u32 )&mpi_request, mpi_reply_sz, (u16 )&mpi_reply, 5);	5505	(u32 )&mpi_request, mpi_reply_sz, (u16 )&mpi_reply, 5);
5611		5506
5612	if (r != 0) {	5507	if (r != 0) {
5613	pr_err(MPT3SAS_FMT "%s: handshake failed (r=%d)\n",	5508	ioc_err(ioc, "%s: handshake failed (r=%d)\n", __func__, r);
5614	ioc->name, __func__, r);
5615	return r;	5509	return r;
5616	}	5510	}
5617		5511
@@ -5663,20 +5557,20 @@ _base_get_ioc_facts(struct MPT3SAS_ADAPTER *ioc) · 45 unmodified lines
5663	*/	5557	*/
5664	ioc->page_size = 1 << facts->CurrentHostPageSize;	5558	ioc->page_size = 1 << facts->CurrentHostPageSize;
5665	if (ioc->page_size == 1) {	5559	if (ioc->page_size == 1) {
5666	pr_info(MPT3SAS_FMT "CurrentHostPageSize is 0: Setting "	5560	ioc_info(ioc, "CurrentHostPageSize is 0: Setting default host page size to 4k\n");
5667	"default host page size to 4k\n", ioc->name);
5668	ioc->page_size = 1 << MPT3SAS_HOST_PAGE_SIZE_4K;	5561	ioc->page_size = 1 << MPT3SAS_HOST_PAGE_SIZE_4K;
5669	}	5562	}
5670	dinitprintk(ioc, pr_info(MPT3SAS_FMT "CurrentHostPageSize(%d)\n",	5563	dinitprintk(ioc,
5671	ioc->name, facts->CurrentHostPageSize));	5564	ioc_info(ioc, "CurrentHostPageSize(%d)\n",
5672		5565	facts->CurrentHostPageSize));
5673	dinitprintk(ioc, pr_info(MPT3SAS_FMT	5566
5674	"hba queue depth(%d), max chains per io(%d)\n",	5567	dinitprintk(ioc,
5675	ioc->name, facts->RequestCredit,	5568	ioc_info(ioc, "hba queue depth(%d), max chains per io(%d)\n",
5676	facts->MaxChainDepth));	5569	facts->RequestCredit, facts->MaxChainDepth));
5677	dinitprintk(ioc, pr_info(MPT3SAS_FMT	5570	dinitprintk(ioc,
5678	"request frame size(%d), reply frame size(%d)\n", ioc->name,	5571	ioc_info(ioc, "request frame size(%d), reply frame size(%d)\n",
5679	facts->IOCRequestFrameSize * 4, facts->ReplyFrameSize * 4));	5572	facts->IOCRequestFrameSize * 4,
		5573	facts->ReplyFrameSize * 4));
5680	return 0;	5574	return 0;
5681	}	5575	}
5682		5576
@@ -5696,8 +5590,7 @@ _base_send_ioc_init(struct MPT3SAS_ADAPTER *ioc) · 13 unmodified lines
5696	u16 ioc_status;	5590	u16 ioc_status;
5697	u32 reply_post_free_array_sz = 0;	5591	u32 reply_post_free_array_sz = 0;
5698		5592
5699	dinitprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,	5593	dinitprintk(ioc, ioc_info(ioc, "%s\n", __func__));
5700	__func__));
5701		5594
5702	memset(&mpi_request, 0, sizeof(Mpi2IOCInitRequest_t));	5595	memset(&mpi_request, 0, sizeof(Mpi2IOCInitRequest_t));
5703	mpi_request.Function = MPI2_FUNCTION_IOC_INIT;	5596	mpi_request.Function = MPI2_FUNCTION_IOC_INIT;
@@ -5763,15 +5656,14 @@ _base_send_ioc_init(struct MPT3SAS_ADAPTER *ioc) · 59 unmodified lines
5763	sizeof(Mpi2IOCInitReply_t), (u16 *)&mpi_reply, 10);	5656	sizeof(Mpi2IOCInitReply_t), (u16 *)&mpi_reply, 10);
5764		5657
5765	if (r != 0) {	5658	if (r != 0) {
5766	pr_err(MPT3SAS_FMT "%s: handshake failed (r=%d)\n",	5659	ioc_err(ioc, "%s: handshake failed (r=%d)\n", __func__, r);
5767	ioc->name, __func__, r);
5768	return r;	5660	return r;
5769	}	5661	}
5770		5662
5771	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;	5663	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
5772	if (ioc_status != MPI2_IOCSTATUS_SUCCESS \|\|	5664	if (ioc_status != MPI2_IOCSTATUS_SUCCESS \|\|
5773	mpi_reply.IOCLogInfo) {	5665	mpi_reply.IOCLogInfo) {
5774	pr_err(MPT3SAS_FMT "%s: failed\n", ioc->name, __func__);	5666	ioc_err(ioc, "%s: failed\n", __func__);
5775	r = -EIO;	5667	r = -EIO;
5776	}	5668	}
5777		5669
@@ -5842,18 +5734,16 @@ _base_send_port_enable(struct MPT3SAS_ADAPTER *ioc) · 64 unmodified lines
5842	u16 smid;	5734	u16 smid;
5843	u16 ioc_status;	5735	u16 ioc_status;
5844		5736
5845	pr_info(MPT3SAS_FMT "sending port enable !!\n", ioc->name);	5737	ioc_info(ioc, "sending port enable !!\n");
5846		5738
5847	if (ioc->port_enable_cmds.status & MPT3_CMD_PENDING) {	5739	if (ioc->port_enable_cmds.status & MPT3_CMD_PENDING) {
5848	pr_err(MPT3SAS_FMT "%s: internal command already in use\n",	5740	ioc_err(ioc, "%s: internal command already in use\n", __func__);
5849	ioc->name, __func__);
5850	return -EAGAIN;	5741	return -EAGAIN;
5851	}	5742	}
5852		5743
5853	smid = mpt3sas_base_get_smid(ioc, ioc->port_enable_cb_idx);	5744	smid = mpt3sas_base_get_smid(ioc, ioc->port_enable_cb_idx);
5854	if (!smid) {	5745	if (!smid) {
5855	pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",	5746	ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
5856	ioc->name, __func__);
5857	return -EAGAIN;	5747	return -EAGAIN;
5858	}	5748	}
5859		5749
@@ -5867,8 +5757,7 @@ _base_send_port_enable(struct MPT3SAS_ADAPTER *ioc) · 7 unmodified lines
5867	mpt3sas_base_put_smid_default(ioc, smid);	5757	mpt3sas_base_put_smid_default(ioc, smid);
5868	wait_for_completion_timeout(&ioc->port_enable_cmds.done, 300*HZ);	5758	wait_for_completion_timeout(&ioc->port_enable_cmds.done, 300*HZ);
5869	if (!(ioc->port_enable_cmds.status & MPT3_CMD_COMPLETE)) {	5759	if (!(ioc->port_enable_cmds.status & MPT3_CMD_COMPLETE)) {
5870	pr_err(MPT3SAS_FMT "%s: timeout\n",	5760	ioc_err(ioc, "%s: timeout\n", __func__);
5871	ioc->name, __func__);
5872	_debug_dump_mf(mpi_request,	5761	_debug_dump_mf(mpi_request,
5873	sizeof(Mpi2PortEnableRequest_t)/4);	5762	sizeof(Mpi2PortEnableRequest_t)/4);
5874	if (ioc->port_enable_cmds.status & MPT3_CMD_RESET)	5763	if (ioc->port_enable_cmds.status & MPT3_CMD_RESET)
@@ -5881,16 +5770,15 @@ _base_send_port_enable(struct MPT3SAS_ADAPTER *ioc) · 6 unmodified lines
5881	mpi_reply = ioc->port_enable_cmds.reply;	5770	mpi_reply = ioc->port_enable_cmds.reply;
5882	ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;	5771	ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
5883	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {	5772	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
5884	pr_err(MPT3SAS_FMT "%s: failed with (ioc_status=0x%08x)\n",	5773	ioc_err(ioc, "%s: failed with (ioc_status=0x%08x)\n",
5885	ioc->name, __func__, ioc_status);	5774	__func__, ioc_status);
5886	r = -EFAULT;	5775	r = -EFAULT;
5887	goto out;	5776	goto out;
5888	}	5777	}
5889		5778
5890	out:	5779	out:
5891	ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED;	5780	ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED;
5892	pr_info(MPT3SAS_FMT "port enable: %s\n", ioc->name, ((r == 0) ?	5781	ioc_info(ioc, "port enable: %s\n", r == 0 ? "SUCCESS" : "FAILED");
5893	"SUCCESS" : "FAILED"));
5894	return r;	5782	return r;
5895	}	5783	}
5896		5784
@@ -5906,18 +5794,16 @@ mpt3sas_port_enable(struct MPT3SAS_ADAPTER *ioc) · 9 unmodified lines
5906	Mpi2PortEnableRequest_t *mpi_request;	5794	Mpi2PortEnableRequest_t *mpi_request;
5907	u16 smid;	5795	u16 smid;
5908		5796
5909	pr_info(MPT3SAS_FMT "sending port enable !!\n", ioc->name);	5797	ioc_info(ioc, "sending port enable !!\n");
5910		5798
5911	if (ioc->port_enable_cmds.status & MPT3_CMD_PENDING) {	5799	if (ioc->port_enable_cmds.status & MPT3_CMD_PENDING) {
5912	pr_err(MPT3SAS_FMT "%s: internal command already in use\n",	5800	ioc_err(ioc, "%s: internal command already in use\n", __func__);
5913	ioc->name, __func__);
5914	return -EAGAIN;	5801	return -EAGAIN;
5915	}	5802	}
5916		5803
5917	smid = mpt3sas_base_get_smid(ioc, ioc->port_enable_cb_idx);	5804	smid = mpt3sas_base_get_smid(ioc, ioc->port_enable_cb_idx);
5918	if (!smid) {	5805	if (!smid) {
5919	pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",	5806	ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
5920	ioc->name, __func__);
5921	return -EAGAIN;	5807	return -EAGAIN;
5922	}	5808	}
5923		5809
@@ -6020,19 +5906,16 @@ _base_event_notification(struct MPT3SAS_ADAPTER *ioc) · 96 unmodified lines
6020	int r = 0;	5906	int r = 0;
6021	int i;	5907	int i;
6022		5908
6023	dinitprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,	5909	dinitprintk(ioc, ioc_info(ioc, "%s\n", __func__));
6024	__func__));
6025		5910
6026	if (ioc->base_cmds.status & MPT3_CMD_PENDING) {	5911	if (ioc->base_cmds.status & MPT3_CMD_PENDING) {
6027	pr_err(MPT3SAS_FMT "%s: internal command already in use\n",	5912	ioc_err(ioc, "%s: internal command already in use\n", __func__);
6028	ioc->name, __func__);
6029	return -EAGAIN;	5913	return -EAGAIN;
6030	}	5914	}
6031		5915
6032	smid = mpt3sas_base_get_smid(ioc, ioc->base_cb_idx);	5916	smid = mpt3sas_base_get_smid(ioc, ioc->base_cb_idx);
6033	if (!smid) {	5917	if (!smid) {
6034	pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",	5918	ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
6035	ioc->name, __func__);
6036	return -EAGAIN;	5919	return -EAGAIN;
6037	}	5920	}
6038	ioc->base_cmds.status = MPT3_CMD_PENDING;	5921	ioc->base_cmds.status = MPT3_CMD_PENDING;
@@ -6049,8 +5932,7 @@ _base_event_notification(struct MPT3SAS_ADAPTER *ioc) · 10 unmodified lines
6049	mpt3sas_base_put_smid_default(ioc, smid);	5932	mpt3sas_base_put_smid_default(ioc, smid);
6050	wait_for_completion_timeout(&ioc->base_cmds.done, 30*HZ);	5933	wait_for_completion_timeout(&ioc->base_cmds.done, 30*HZ);
6051	if (!(ioc->base_cmds.status & MPT3_CMD_COMPLETE)) {	5934	if (!(ioc->base_cmds.status & MPT3_CMD_COMPLETE)) {
6052	pr_err(MPT3SAS_FMT "%s: timeout\n",	5935	ioc_err(ioc, "%s: timeout\n", __func__);
6053	ioc->name, __func__);
6054	_debug_dump_mf(mpi_request,	5936	_debug_dump_mf(mpi_request,
6055	sizeof(Mpi2EventNotificationRequest_t)/4);	5937	sizeof(Mpi2EventNotificationRequest_t)/4);
6056	if (ioc->base_cmds.status & MPT3_CMD_RESET)	5938	if (ioc->base_cmds.status & MPT3_CMD_RESET)
@@ -6058,8 +5940,7 @@ _base_event_notification(struct MPT3SAS_ADAPTER *ioc) · 1 unmodified line
6058	else	5940	else
6059	r = -ETIME;	5941	r = -ETIME;
6060	} else	5942	} else
6061	dinitprintk(ioc, pr_info(MPT3SAS_FMT "%s: complete\n",	5943	dinitprintk(ioc, ioc_info(ioc, "%s: complete\n", __func__));
6062	ioc->name, __func__));
6063	ioc->base_cmds.status = MPT3_CMD_NOT_USED;	5944	ioc->base_cmds.status = MPT3_CMD_NOT_USED;
6064	return r;	5945	return r;
6065	}	5946	}
@@ -6115,18 +5996,16 @@ _base_diag_reset(struct MPT3SAS_ADAPTER *ioc) · 49 unmodified lines
6115	u32 count;	5996	u32 count;
6116	u32 hcb_size;	5997	u32 hcb_size;
6117		5998
6118	pr_info(MPT3SAS_FMT "sending diag reset !!\n", ioc->name);	5999	ioc_info(ioc, "sending diag reset !!\n");
6119		6000
6120	drsprintk(ioc, pr_info(MPT3SAS_FMT "clear interrupts\n",	6001	drsprintk(ioc, ioc_info(ioc, "clear interrupts\n"));
6121	ioc->name));
6122		6002
6123	count = 0;	6003	count = 0;
6124	do {	6004	do {
6125	/* Write magic sequence to WriteSequence register	6005	/* Write magic sequence to WriteSequence register
6126	* Loop until in diagnostic mode	6006	* Loop until in diagnostic mode
6127	*/	6007	*/
6128	drsprintk(ioc, pr_info(MPT3SAS_FMT	6008	drsprintk(ioc, ioc_info(ioc, "write magic sequence\n"));
6129	"write magic sequence\n", ioc->name));
6130	writel(MPI2_WRSEQ_FLUSH_KEY_VALUE, &ioc->chip->WriteSequence);	6009	writel(MPI2_WRSEQ_FLUSH_KEY_VALUE, &ioc->chip->WriteSequence);
6131	writel(MPI2_WRSEQ_1ST_KEY_VALUE, &ioc->chip->WriteSequence);	6010	writel(MPI2_WRSEQ_1ST_KEY_VALUE, &ioc->chip->WriteSequence);
6132	writel(MPI2_WRSEQ_2ND_KEY_VALUE, &ioc->chip->WriteSequence);	6011	writel(MPI2_WRSEQ_2ND_KEY_VALUE, &ioc->chip->WriteSequence);
@@ -6142,16 +6021,15 @@ _base_diag_reset(struct MPT3SAS_ADAPTER *ioc) · 9 unmodified lines
6142	goto out;	6021	goto out;
6143		6022
6144	host_diagnostic = readl(&ioc->chip->HostDiagnostic);	6023	host_diagnostic = readl(&ioc->chip->HostDiagnostic);
6145	drsprintk(ioc, pr_info(MPT3SAS_FMT	6024	drsprintk(ioc,
6146	"wrote magic sequence: count(%d), host_diagnostic(0x%08x)\n",	6025	ioc_info(ioc, "wrote magic sequence: count(%d), host_diagnostic(0x%08x)\n",
6147	ioc->name, count, host_diagnostic));	6026	count, host_diagnostic));
6148		6027
6149	} while ((host_diagnostic & MPI2_DIAG_DIAG_WRITE_ENABLE) == 0);	6028	} while ((host_diagnostic & MPI2_DIAG_DIAG_WRITE_ENABLE) == 0);
6150		6029
6151	hcb_size = readl(&ioc->chip->HCBSize);	6030	hcb_size = readl(&ioc->chip->HCBSize);
6152		6031
6153	drsprintk(ioc, pr_info(MPT3SAS_FMT "diag reset: issued\n",	6032	drsprintk(ioc, ioc_info(ioc, "diag reset: issued\n"));
6154	ioc->name));
6155	writel(host_diagnostic \| MPI2_DIAG_RESET_ADAPTER,	6033	writel(host_diagnostic \| MPI2_DIAG_RESET_ADAPTER,
6156	&ioc->chip->HostDiagnostic);	6034	&ioc->chip->HostDiagnostic);
6157		6035
@@ -6174,43 +6052,38 @@ _base_diag_reset(struct MPT3SAS_ADAPTER *ioc) · 16 unmodified lines
6174		6052
6175	if (host_diagnostic & MPI2_DIAG_HCB_MODE) {	6053	if (host_diagnostic & MPI2_DIAG_HCB_MODE) {
6176		6054
6177	drsprintk(ioc, pr_info(MPT3SAS_FMT	6055	drsprintk(ioc,
6178	"restart the adapter assuming the HCB Address points to good F/W\n",	6056	ioc_info(ioc, "restart the adapter assuming the HCB Address points to good F/W\n"));
6179	ioc->name));
6180	host_diagnostic &= ~MPI2_DIAG_BOOT_DEVICE_SELECT_MASK;	6057	host_diagnostic &= ~MPI2_DIAG_BOOT_DEVICE_SELECT_MASK;
6181	host_diagnostic \|= MPI2_DIAG_BOOT_DEVICE_SELECT_HCDW;	6058	host_diagnostic \|= MPI2_DIAG_BOOT_DEVICE_SELECT_HCDW;
6182	writel(host_diagnostic, &ioc->chip->HostDiagnostic);	6059	writel(host_diagnostic, &ioc->chip->HostDiagnostic);
6183		6060
6184	drsprintk(ioc, pr_info(MPT3SAS_FMT	6061	drsprintk(ioc, ioc_info(ioc, "re-enable the HCDW\n"));
6185	"re-enable the HCDW\n", ioc->name));
6186	writel(hcb_size \| MPI2_HCB_SIZE_HCB_ENABLE,	6062	writel(hcb_size \| MPI2_HCB_SIZE_HCB_ENABLE,
6187	&ioc->chip->HCBSize);	6063	&ioc->chip->HCBSize);
6188	}	6064	}
6189		6065
6190	drsprintk(ioc, pr_info(MPT3SAS_FMT "restart the adapter\n",	6066	drsprintk(ioc, ioc_info(ioc, "restart the adapter\n"));
6191	ioc->name));
6192	writel(host_diagnostic & ~MPI2_DIAG_HOLD_IOC_RESET,	6067	writel(host_diagnostic & ~MPI2_DIAG_HOLD_IOC_RESET,
6193	&ioc->chip->HostDiagnostic);	6068	&ioc->chip->HostDiagnostic);
6194		6069
6195	drsprintk(ioc, pr_info(MPT3SAS_FMT	6070	drsprintk(ioc,
6196	"disable writes to the diagnostic register\n", ioc->name));	6071	ioc_info(ioc, "disable writes to the diagnostic register\n"));
6197	writel(MPI2_WRSEQ_FLUSH_KEY_VALUE, &ioc->chip->WriteSequence);	6072	writel(MPI2_WRSEQ_FLUSH_KEY_VALUE, &ioc->chip->WriteSequence);
6198		6073
6199	drsprintk(ioc, pr_info(MPT3SAS_FMT	6074	drsprintk(ioc, ioc_info(ioc, "Wait for FW to go to the READY state\n"));
6200	"Wait for FW to go to the READY state\n", ioc->name));
6201	ioc_state = _base_wait_on_iocstate(ioc, MPI2_IOC_STATE_READY, 20);	6075	ioc_state = _base_wait_on_iocstate(ioc, MPI2_IOC_STATE_READY, 20);
6202	if (ioc_state) {	6076	if (ioc_state) {
6203	pr_err(MPT3SAS_FMT	6077	ioc_err(ioc, "%s: failed going to ready state (ioc_state=0x%x)\n",
6204	"%s: failed going to ready state (ioc_state=0x%x)\n",	6078	__func__, ioc_state);
6205	ioc->name, __func__, ioc_state);
6206	goto out;	6079	goto out;
6207	}	6080	}
6208		6081
6209	pr_info(MPT3SAS_FMT "diag reset: SUCCESS\n", ioc->name);	6082	ioc_info(ioc, "diag reset: SUCCESS\n");
6210	return 0;	6083	return 0;
6211		6084
6212	out:	6085	out:
6213	pr_err(MPT3SAS_FMT "diag reset: FAILED\n", ioc->name);	6086	ioc_err(ioc, "diag reset: FAILED\n");
6214	return -EFAULT;	6087	return -EFAULT;
6215	}	6088	}
6216		6089
@@ -6228,15 +6101,15 @@ _base_make_ioc_ready(struct MPT3SAS_ADAPTER *ioc, enum reset_type type) · 11 unmodified lines
6228	int rc;	6101	int rc;
6229	int count;	6102	int count;
6230		6103
6231	dinitprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,	6104	dinitprintk(ioc, ioc_info(ioc, "%s\n", __func__));
6232	__func__));
6233		6105
6234	if (ioc->pci_error_recovery)	6106	if (ioc->pci_error_recovery)
6235	return 0;	6107	return 0;
6236		6108
6237	ioc_state = mpt3sas_base_get_iocstate(ioc, 0);	6109	ioc_state = mpt3sas_base_get_iocstate(ioc, 0);
6238	dhsprintk(ioc, pr_info(MPT3SAS_FMT "%s: ioc_state(0x%08x)\n",	6110	dhsprintk(ioc,
6239	ioc->name, __func__, ioc_state));	6111	ioc_info(ioc, "%s: ioc_state(0x%08x)\n",
		6112	__func__, ioc_state));
6240		6113
6241	/* if in RESET state, it should move to READY state shortly */	6114	/* if in RESET state, it should move to READY state shortly */
6242	count = 0;	6115	count = 0;
@@ -6244,9 +6117,8 @@ _base_make_ioc_ready(struct MPT3SAS_ADAPTER *ioc, enum reset_type type) · 1 unmodified line
6244	while ((ioc_state & MPI2_IOC_STATE_MASK) !=	6117	while ((ioc_state & MPI2_IOC_STATE_MASK) !=
6245	MPI2_IOC_STATE_READY) {	6118	MPI2_IOC_STATE_READY) {
6246	if (count++ == 10) {	6119	if (count++ == 10) {
6247	pr_err(MPT3SAS_FMT	6120	ioc_err(ioc, "%s: failed going to ready state (ioc_state=0x%x)\n",
6248	"%s: failed going to ready state (ioc_state=0x%x)\n",	6121	__func__, ioc_state);
6249	ioc->name, __func__, ioc_state);
6250	return -EFAULT;	6122	return -EFAULT;
6251	}	6123	}
6252	ssleep(1);	6124	ssleep(1);
@@ -6258,9 +6130,7 @@ _base_make_ioc_ready(struct MPT3SAS_ADAPTER *ioc, enum reset_type type) · 5 unmodified lines
6258	return 0;	6130	return 0;
6259		6131
6260	if (ioc_state & MPI2_DOORBELL_USED) {	6132	if (ioc_state & MPI2_DOORBELL_USED) {
6261	dhsprintk(ioc, pr_info(MPT3SAS_FMT	6133	dhsprintk(ioc, ioc_info(ioc, "unexpected doorbell active!\n"));
6262	"unexpected doorbell active!\n",
6263	ioc->name));
6264	goto issue_diag_reset;	6134	goto issue_diag_reset;
6265	}	6135	}
6266		6136
@@ -6304,8 +6174,7 @@ _base_make_ioc_operational(struct MPT3SAS_ADAPTER *ioc) · 37 unmodified lines
6304	struct adapter_reply_queue *reply_q;	6174	struct adapter_reply_queue *reply_q;
6305	Mpi2ReplyDescriptorsUnion_t *reply_post_free_contig;	6175	Mpi2ReplyDescriptorsUnion_t *reply_post_free_contig;
6306		6176
6307	dinitprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,	6177	dinitprintk(ioc, ioc_info(ioc, "%s\n", __func__));
6308	__func__));
6309		6178
6310	/* clean the delayed target reset list */	6179	/* clean the delayed target reset list */
6311	list_for_each_entry_safe(delayed_tr, delayed_tr_next,	6180	list_for_each_entry_safe(delayed_tr, delayed_tr_next,
@@ -6465,8 +6334,7 @@ _base_make_ioc_operational(struct MPT3SAS_ADAPTER *ioc) · 153 unmodified lines
6465	void	6334	void
6466	mpt3sas_base_free_resources(struct MPT3SAS_ADAPTER *ioc)	6335	mpt3sas_base_free_resources(struct MPT3SAS_ADAPTER *ioc)
6467	{	6336	{
6468	dexitprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,	6337	dexitprintk(ioc, ioc_info(ioc, "%s\n", __func__));
6469	__func__));
6470		6338
6471	/* synchronizing freeing resource with pci_access_mutex lock */	6339	/* synchronizing freeing resource with pci_access_mutex lock */
6472	mutex_lock(&ioc->pci_access_mutex);	6340	mutex_lock(&ioc->pci_access_mutex);
@@ -6494,8 +6362,7 @@ mpt3sas_base_attach(struct MPT3SAS_ADAPTER *ioc) · 21 unmodified lines
6494	int r, i;	6362	int r, i;
6495	int cpu_id, last_cpu_id = 0;	6363	int cpu_id, last_cpu_id = 0;
6496		6364
6497	dinitprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,	6365	dinitprintk(ioc, ioc_info(ioc, "%s\n", __func__));
6498	__func__));
6499		6366
6500	/* setup cpu_msix_table */	6367	/* setup cpu_msix_table */
6501	ioc->cpu_count = num_online_cpus();	6368	ioc->cpu_count = num_online_cpus();
@@ -6505,9 +6372,8 @@ mpt3sas_base_attach(struct MPT3SAS_ADAPTER *ioc) · 3 unmodified lines
6505	ioc->cpu_msix_table = kzalloc(ioc->cpu_msix_table_sz, GFP_KERNEL);	6372	ioc->cpu_msix_table = kzalloc(ioc->cpu_msix_table_sz, GFP_KERNEL);
6506	ioc->reply_queue_count = 1;	6373	ioc->reply_queue_count = 1;
6507	if (!ioc->cpu_msix_table) {	6374	if (!ioc->cpu_msix_table) {
6508	dfailprintk(ioc, pr_info(MPT3SAS_FMT	6375	dfailprintk(ioc,
6509	"allocation for cpu_msix_table failed!!!\n",	6376	ioc_info(ioc, "allocation for cpu_msix_table failed!!!\n"));
6510	ioc->name));
6511	r = -ENOMEM;	6377	r = -ENOMEM;
6512	goto out_free_resources;	6378	goto out_free_resources;
6513	}	6379	}
@@ -6516,9 +6382,8 @@ mpt3sas_base_attach(struct MPT3SAS_ADAPTER *ioc) · 2 unmodified lines
6516	ioc->reply_post_host_index = kcalloc(ioc->cpu_msix_table_sz,	6382	ioc->reply_post_host_index = kcalloc(ioc->cpu_msix_table_sz,
6517	sizeof(resource_size_t *), GFP_KERNEL);	6383	sizeof(resource_size_t *), GFP_KERNEL);
6518	if (!ioc->reply_post_host_index) {	6384	if (!ioc->reply_post_host_index) {
6519	dfailprintk(ioc, pr_info(MPT3SAS_FMT "allocation "	6385	dfailprintk(ioc,
6520	"for reply_post_host_index failed!!!\n",	6386	ioc_info(ioc, "allocation for reply_post_host_index failed!!!\n"));
6521	ioc->name));
6522	r = -ENOMEM;	6387	r = -ENOMEM;
6523	goto out_free_resources;	6388	goto out_free_resources;
6524	}	6389	}
@@ -6747,8 +6612,7 @@ mpt3sas_base_attach(struct MPT3SAS_ADAPTER *ioc) · 222 unmodified lines
6747	void	6612	void
6748	mpt3sas_base_detach(struct MPT3SAS_ADAPTER *ioc)	6613	mpt3sas_base_detach(struct MPT3SAS_ADAPTER *ioc)
6749	{	6614	{
6750	dexitprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,	6615	dexitprintk(ioc, ioc_info(ioc, "%s\n", __func__));
6751	__func__));
6752		6616
6753	mpt3sas_base_stop_watchdog(ioc);	6617	mpt3sas_base_stop_watchdog(ioc);
6754	mpt3sas_base_free_resources(ioc);	6618	mpt3sas_base_free_resources(ioc);
@@ -6781,8 +6645,7 @@ static void _base_pre_reset_handler(struct MPT3SAS_ADAPTER *ioc) · 26 unmodified lines
6781	{	6645	{
6782	mpt3sas_scsih_pre_reset_handler(ioc);	6646	mpt3sas_scsih_pre_reset_handler(ioc);
6783	mpt3sas_ctl_pre_reset_handler(ioc);	6647	mpt3sas_ctl_pre_reset_handler(ioc);
6784	dtmprintk(ioc, pr_info(MPT3SAS_FMT	6648	dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_PRE_RESET\n", __func__));
6785	"%s: MPT3_IOC_PRE_RESET\n", ioc->name, __func__));
6786	}	6649	}
6787		6650
6788	/**	6651	/**
@@ -6793,8 +6656,7 @@ static void _base_after_reset_handler(struct MPT3SAS_ADAPTER *ioc) · 4 unmodified lines
6793	{	6656	{
6794	mpt3sas_scsih_after_reset_handler(ioc);	6657	mpt3sas_scsih_after_reset_handler(ioc);
6795	mpt3sas_ctl_after_reset_handler(ioc);	6658	mpt3sas_ctl_after_reset_handler(ioc);
6796	dtmprintk(ioc, pr_info(MPT3SAS_FMT	6659	dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_AFTER_RESET\n", __func__));
6797	"%s: MPT3_IOC_AFTER_RESET\n", ioc->name, __func__));
6798	if (ioc->transport_cmds.status & MPT3_CMD_PENDING) {	6660	if (ioc->transport_cmds.status & MPT3_CMD_PENDING) {
6799	ioc->transport_cmds.status \|= MPT3_CMD_RESET;	6661	ioc->transport_cmds.status \|= MPT3_CMD_RESET;
6800	mpt3sas_base_free_smid(ioc, ioc->transport_cmds.smid);	6662	mpt3sas_base_free_smid(ioc, ioc->transport_cmds.smid);
@@ -6835,8 +6697,7 @@ static void _base_reset_done_handler(struct MPT3SAS_ADAPTER *ioc) · 34 unmodified lines
6835	{	6697	{
6836	mpt3sas_scsih_reset_done_handler(ioc);	6698	mpt3sas_scsih_reset_done_handler(ioc);
6837	mpt3sas_ctl_reset_done_handler(ioc);	6699	mpt3sas_ctl_reset_done_handler(ioc);
6838	dtmprintk(ioc, pr_info(MPT3SAS_FMT	6700	dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_DONE_RESET\n", __func__));
6839	"%s: MPT3_IOC_DONE_RESET\n", ioc->name, __func__));
6840	}	6701	}
6841		6702
6842	/**	6703	/**
@@ -6883,12 +6744,10 @@ mpt3sas_base_hard_reset_handler(struct MPT3SAS_ADAPTER *ioc, · 40 unmodified lines
6883	u32 ioc_state;	6744	u32 ioc_state;
6884	u8 is_fault = 0, is_trigger = 0;	6745	u8 is_fault = 0, is_trigger = 0;
6885		6746
6886	dtmprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name,	6747	dtmprintk(ioc, ioc_info(ioc, "%s: enter\n", __func__));
6887	__func__));
6888		6748
6889	if (ioc->pci_error_recovery) {	6749	if (ioc->pci_error_recovery) {
6890	pr_err(MPT3SAS_FMT "%s: pci error recovery reset\n",	6750	ioc_err(ioc, "%s: pci error recovery reset\n", __func__);
6891	ioc->name, __func__);
6892	r = 0;	6751	r = 0;
6893	goto out_unlocked;	6752	goto out_unlocked;
6894	}	6753	}
@@ -6942,8 +6801,9 @@ mpt3sas_base_hard_reset_handler(struct MPT3SAS_ADAPTER *ioc, · 47 unmodified lines
6942	_base_reset_done_handler(ioc);	6801	_base_reset_done_handler(ioc);
6943		6802
6944	out:	6803	out:
6945	dtmprintk(ioc, pr_info(MPT3SAS_FMT "%s: %s\n",	6804	dtmprintk(ioc,
6946	ioc->name, __func__, ((r == 0) ? "SUCCESS" : "FAILED")));	6805	ioc_info(ioc, "%s: %s\n",
		6806	__func__, r == 0 ? "SUCCESS" : "FAILED"));
6947		6807
6948	spin_lock_irqsave(&ioc->ioc_reset_in_progress_lock, flags);	6808	spin_lock_irqsave(&ioc->ioc_reset_in_progress_lock, flags);
6949	ioc->shost_recovery = 0;	6809	ioc->shost_recovery = 0;
@@ -6959,7 +6819,6 @@ mpt3sas_base_hard_reset_handler(struct MPT3SAS_ADAPTER *ioc, · 9 unmodified lines
6959	mpt3sas_trigger_master(ioc,	6819	mpt3sas_trigger_master(ioc,
6960	MASTER_TRIGGER_ADAPTER_RESET);	6820	MASTER_TRIGGER_ADAPTER_RESET);
6961	}	6821	}
6962	dtmprintk(ioc, pr_info(MPT3SAS_FMT "%s: exit\n", ioc->name,	6822	dtmprintk(ioc, ioc_info(ioc, "%s: exit\n", __func__));
6963	__func__));
6964	return r;	6823	return r;
6965	}	6824	}

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

 /*
  * logging format
  */
-#define MPT3SAS_FMT			"%s: "
+#define ioc_err(ioc, fmt, ...)						\
+	pr_err("%s: " fmt, (ioc)->name, ##__VA_ARGS__)
+#define ioc_notice(ioc, fmt, ...)					\
+	pr_notice("%s: " fmt, (ioc)->name, ##__VA_ARGS__)
+#define ioc_warn(ioc, fmt, ...)						\
+	pr_warn("%s: " fmt, (ioc)->name, ##__VA_ARGS__)
+#define ioc_info(ioc, fmt, ...)						\
+	pr_info("%s: " fmt, (ioc)->name, ##__VA_ARGS__)
 /*
  *  WarpDrive Specific Log codes

drivers/scsi/mpt3sas/mpt3sas_config.c+35−54

 	if (!desc)
 		return;
-	pr_info(MPT3SAS_FMT
+	ioc_info(ioc, "%s: %s(%d), action(%d), form(0x%08x), smid(%d)\n",
-		"%s: %s(%d), action(%d), form(0x%08x), smid(%d)\n",
+		 calling_function_name, desc,
-		ioc->name, calling_function_name, desc,
+		 mpi_request->Header.PageNumber, mpi_request->Action,
-	    mpi_request->Header.PageNumber, mpi_request->Action,
+		 le32_to_cpu(mpi_request->PageAddress), smid);
-	    le32_to_cpu(mpi_request->PageAddress), smid);
 	if (!mpi_reply)
 		return;
 	if (mpi_reply->IOCStatus || mpi_reply->IOCLogInfo)
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "\tiocstatus(0x%04x), loginfo(0x%08x)\n",
-		    "\tiocstatus(0x%04x), loginfo(0x%08x)\n",
+			 le16_to_cpu(mpi_reply->IOCStatus),
-		    ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
+			 le32_to_cpu(mpi_reply->IOCLogInfo));
-		    le32_to_cpu(mpi_reply->IOCLogInfo));
 }
 /**
 		mem->page = dma_alloc_coherent(&ioc->pdev->dev, mem->sz,
 		    &mem->page_dma, GFP_KERNEL);
 		if (!mem->page) {
-			pr_err(MPT3SAS_FMT
+			ioc_err(ioc, "%s: dma_alloc_coherent failed asking for (%d) bytes!!\n",
-				"%s: dma_alloc_coherent failed asking for (%d) bytes!!\n",
+				__func__, mem->sz);
-			    ioc->name, __func__, mem->sz);
 			r = -ENOMEM;
 		}
 	} else { /* use tmp buffer if less than 512 bytes */
 	mutex_lock(&ioc->config_cmds.mutex);
 	if (ioc->config_cmds.status != MPT3_CMD_NOT_USED) {
-		pr_err(MPT3SAS_FMT "%s: config_cmd in use\n",
+		ioc_err(ioc, "%s: config_cmd in use\n", __func__);
-		    ioc->name, __func__);
 		mutex_unlock(&ioc->config_cmds.mutex);
 		return -EAGAIN;
 	}
 			r = -EFAULT;
 			goto free_mem;
 		}
-		pr_info(MPT3SAS_FMT "%s: attempting retry (%d)\n",
+		ioc_info(ioc, "%s: attempting retry (%d)\n",
-		    ioc->name, __func__, retry_count);
+			 __func__, retry_count);
 	}
 	wait_state_count = 0;
 	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
 	while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
 		if (wait_state_count++ == MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT) {
-			pr_err(MPT3SAS_FMT
+			ioc_err(ioc, "%s: failed due to ioc not operational\n",
-			    "%s: failed due to ioc not operational\n",
+				__func__);
-			    ioc->name, __func__);
 			ioc->config_cmds.status = MPT3_CMD_NOT_USED;
 			r = -EFAULT;
 			goto free_mem;
 		}
 		ssleep(1);
 		ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "%s: waiting for operational state(count=%d)\n",
-			"%s: waiting for operational state(count=%d)\n",
+			 __func__, wait_state_count);
-			ioc->name, __func__, wait_state_count);
 	}
 	if (wait_state_count)
-		pr_info(MPT3SAS_FMT "%s: ioc is operational\n",
+		ioc_info(ioc, "%s: ioc is operational\n", __func__);
-		    ioc->name, __func__);
 	smid = mpt3sas_base_get_smid(ioc, ioc->config_cb_idx);
 	if (!smid) {
-		pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
+		ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
-		    ioc->name, __func__);
 		ioc->config_cmds.status = MPT3_CMD_NOT_USED;
 		r = -EAGAIN;
 		goto free_mem;
 		    (mpi_reply->Header.PageType & 0xF)) {
 			_debug_dump_mf(mpi_request, ioc->request_sz/4);
 			_debug_dump_reply(mpi_reply, ioc->request_sz/4);
-			panic(KERN_WARNING MPT3SAS_FMT "%s: Firmware BUG:" \
+			panic("%s: %s: Firmware BUG: mpi_reply mismatch: Requested PageType(0x%02x) Reply PageType(0x%02x)\n",
-			    " mpi_reply mismatch: Requested PageType(0x%02x)" \
+			      ioc->name, __func__,
-			    " Reply PageType(0x%02x)\n", \
+			      mpi_request->Header.PageType & 0xF,
-			    ioc->name, __func__,
+			      mpi_reply->Header.PageType & 0xF);
-			    (mpi_request->Header.PageType & 0xF),
-			    (mpi_reply->Header.PageType & 0xF));
 		}
 		if (((mpi_request->Header.PageType & 0xF) ==
 		    mpi_request->ExtPageType != mpi_reply->ExtPageType) {
 			_debug_dump_mf(mpi_request, ioc->request_sz/4);
 			_debug_dump_reply(mpi_reply, ioc->request_sz/4);
-			panic(KERN_WARNING MPT3SAS_FMT "%s: Firmware BUG:" \
+			panic("%s: %s: Firmware BUG: mpi_reply mismatch: Requested ExtPageType(0x%02x) Reply ExtPageType(0x%02x)\n",
-			    " mpi_reply mismatch: Requested ExtPageType(0x%02x)"
+			      ioc->name, __func__,
-			    " Reply ExtPageType(0x%02x)\n",
+			      mpi_request->ExtPageType,
-			    ioc->name, __func__, mpi_request->ExtPageType,
+			      mpi_reply->ExtPageType);
-			    mpi_reply->ExtPageType);
 		}
 		ioc_status = le16_to_cpu(mpi_reply->IOCStatus)
 		    & MPI2_IOCSTATUS_MASK;
 	}
 	if (retry_count)
-		pr_info(MPT3SAS_FMT "%s: retry (%d) completed!!\n", \
+		ioc_info(ioc, "%s: retry (%d) completed!!\n",
-		    ioc->name, __func__, retry_count);
+			 __func__, retry_count);
 	if ((ioc_status == MPI2_IOCSTATUS_SUCCESS) &&
 	    config_page && mpi_request->Action ==
 				_debug_dump_reply(mpi_reply, ioc->request_sz/4);
 				_debug_dump_config(p, min_t(u16, mem.sz,
 				    config_page_sz)/4);
-				panic(KERN_WARNING MPT3SAS_FMT
+				panic("%s: %s: Firmware BUG: config page mismatch: Requested PageType(0x%02x) Reply PageType(0x%02x)\n",
-					"%s: Firmware BUG:" \
+				      ioc->name, __func__,
-				    " config page mismatch:"
+				      mpi_request->Header.PageType & 0xF,
-				    " Requested PageType(0x%02x)"
+				      p[3] & 0xF);
-				    " Reply PageType(0x%02x)\n",
-				    ioc->name, __func__,
-				    (mpi_request->Header.PageType & 0xF),
-				    (p[3] & 0xF));
 			}
 			if (((mpi_request->Header.PageType & 0xF) ==
 				_debug_dump_reply(mpi_reply, ioc->request_sz/4);
 				_debug_dump_config(p, min_t(u16, mem.sz,
 				    config_page_sz)/4);
-				panic(KERN_WARNING MPT3SAS_FMT
+				panic("%s: %s: Firmware BUG: config page mismatch: Requested ExtPageType(0x%02x) Reply ExtPageType(0x%02x)\n",
-					"%s: Firmware BUG:" \
+				      ioc->name, __func__,
-				    " config page mismatch:"
+				      mpi_request->ExtPageType, p[6]);
-				    " Requested ExtPageType(0x%02x)"
-				    " Reply ExtPageType(0x%02x)\n",
-				    ioc->name, __func__,
-				    mpi_request->ExtPageType, p[6]);
 			}
 		}
 		memcpy(config_page, mem.page, min_t(u16, mem.sz,

drivers/scsi/mpt3sas/mpt3sas_ctl.c+226−301

 	if (!desc)
 		return;
-	pr_info(MPT3SAS_FMT "%s: %s, smid(%d)\n",
+	ioc_info(ioc, "%s: %s, smid(%d)\n", calling_function_name, desc, smid);
-	    ioc->name, calling_function_name, desc, smid);
 	if (!mpi_reply)
 		return;
 	if (mpi_reply->IOCStatus || mpi_reply->IOCLogInfo)
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "\tiocstatus(0x%04x), loginfo(0x%08x)\n",
-		    "\tiocstatus(0x%04x), loginfo(0x%08x)\n",
+			 le16_to_cpu(mpi_reply->IOCStatus),
-		    ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
+			 le32_to_cpu(mpi_reply->IOCLogInfo));
-		    le32_to_cpu(mpi_reply->IOCLogInfo));
 	if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
 	    mpi_request->Function ==
 		sas_device = mpt3sas_get_sdev_by_handle(ioc,
 		    le16_to_cpu(scsi_reply->DevHandle));
 		if (sas_device) {
-			pr_warn(MPT3SAS_FMT "\tsas_address(0x%016llx), phy(%d)\n",
+			ioc_warn(ioc, "\tsas_address(0x%016llx), phy(%d)\n",
-				ioc->name, (unsigned long long)
+				 (u64)sas_device->sas_address,
-			    sas_device->sas_address, sas_device->phy);
+				 sas_device->phy);
-			pr_warn(MPT3SAS_FMT
+			ioc_warn(ioc, "\tenclosure_logical_id(0x%016llx), slot(%d)\n",
-			    "\tenclosure_logical_id(0x%016llx), slot(%d)\n",
+				 (u64)sas_device->enclosure_logical_id,
-			    ioc->name, (unsigned long long)
+				 sas_device->slot);
-			    sas_device->enclosure_logical_id, sas_device->slot);
 			sas_device_put(sas_device);
 		}
 		if (!sas_device) {
 			pcie_device = mpt3sas_get_pdev_by_handle(ioc,
 				le16_to_cpu(scsi_reply->DevHandle));
 			if (pcie_device) {
-				pr_warn(MPT3SAS_FMT
+				ioc_warn(ioc, "\tWWID(0x%016llx), port(%d)\n",
-				    "\tWWID(0x%016llx), port(%d)\n", ioc->name,
+					 (unsigned long long)pcie_device->wwid,
-				    (unsigned long long)pcie_device->wwid,
+					 pcie_device->port_num);
-				    pcie_device->port_num);
 				if (pcie_device->enclosure_handle != 0)
-					pr_warn(MPT3SAS_FMT
+					ioc_warn(ioc, "\tenclosure_logical_id(0x%016llx), slot(%d)\n",
-					    "\tenclosure_logical_id(0x%016llx), slot(%d)\n",
+						 (u64)pcie_device->enclosure_logical_id,
-					    ioc->name, (unsigned long long)
+						 pcie_device->slot);
-					    pcie_device->enclosure_logical_id,
-					    pcie_device->slot);
 				pcie_device_put(pcie_device);
 			}
 		}
 		if (scsi_reply->SCSIState || scsi_reply->SCSIStatus)
-			pr_info(MPT3SAS_FMT
+			ioc_info(ioc, "\tscsi_state(0x%02x), scsi_status(0x%02x)\n",
-			    "\tscsi_state(0x%02x), scsi_status"
+				 scsi_reply->SCSIState,
-			    "(0x%02x)\n", ioc->name,
+				 scsi_reply->SCSIStatus);
-			    scsi_reply->SCSIState,
-			    scsi_reply->SCSIStatus);
 	}
 }
 	int i;
 	u8 issue_reset;
-	dtmprintk(ioc, pr_info(MPT3SAS_FMT
+	dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_PRE_RESET\n", __func__));
-			"%s: MPT3_IOC_PRE_RESET\n", ioc->name, __func__));
 	for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
 		if (!(ioc->diag_buffer_status[i] &
 		      MPT3_DIAG_BUFFER_IS_REGISTERED))
  */
 void mpt3sas_ctl_after_reset_handler(struct MPT3SAS_ADAPTER *ioc)
 {
-	dtmprintk(ioc, pr_info(MPT3SAS_FMT
+	dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_AFTER_RESET\n", __func__));
-			"%s: MPT3_IOC_AFTER_RESET\n", ioc->name, __func__));
 	if (ioc->ctl_cmds.status & MPT3_CMD_PENDING) {
 		ioc->ctl_cmds.status |= MPT3_CMD_RESET;
 		mpt3sas_base_free_smid(ioc, ioc->ctl_cmds.smid);
 {
 	int i;
-	dtmprintk(ioc, pr_info(MPT3SAS_FMT
+	dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_DONE_RESET\n", __func__));
-			"%s: MPT3_IOC_DONE_RESET\n", ioc->name, __func__));
 	for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
 		if (!(ioc->diag_buffer_status[i] &
 	}
 	if (!found) {
-		dctlprintk(ioc, pr_info(MPT3SAS_FMT
+		dctlprintk(ioc,
-			"%s: handle(0x%04x), lun(%d), no active mid!!\n",
+			   ioc_info(ioc, "%s: handle(0x%04x), lun(%d), no active mid!!\n",
-			ioc->name,
+				    desc, le16_to_cpu(tm_request->DevHandle),
-		    desc, le16_to_cpu(tm_request->DevHandle), lun));
+				    lun));
 		tm_reply = ioc->ctl_cmds.reply;
 		tm_reply->DevHandle = tm_request->DevHandle;
 		tm_reply->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
 		return 1;
 	}
-	dctlprintk(ioc, pr_info(MPT3SAS_FMT
+	dctlprintk(ioc,
-		"%s: handle(0x%04x), lun(%d), task_mid(%d)\n", ioc->name,
+		   ioc_info(ioc, "%s: handle(0x%04x), lun(%d), task_mid(%d)\n",
-	    desc, le16_to_cpu(tm_request->DevHandle), lun,
+			    desc, le16_to_cpu(tm_request->DevHandle), lun,
-	     le16_to_cpu(tm_request->TaskMID)));
+			    le16_to_cpu(tm_request->TaskMID)));
 	return 0;
 }
 	issue_reset = 0;
 	if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) {
-		pr_err(MPT3SAS_FMT "%s: ctl_cmd in use\n",
+		ioc_err(ioc, "%s: ctl_cmd in use\n", __func__);
-		    ioc->name, __func__);
 		ret = -EAGAIN;
 		goto out;
 	}
 	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
 	while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
 		if (wait_state_count++ == 10) {
-			pr_err(MPT3SAS_FMT
+			ioc_err(ioc, "%s: failed due to ioc not operational\n",
-			    "%s: failed due to ioc not operational\n",
+				__func__);
-			    ioc->name, __func__);
 			ret = -EFAULT;
 			goto out;
 		}
 		ssleep(1);
 		ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "%s: waiting for operational state(count=%d)\n",
-			"%s: waiting for operational state(count=%d)\n",
+			 __func__, wait_state_count);
-			ioc->name,
-		    __func__, wait_state_count);
 	}
 	if (wait_state_count)
-		pr_info(MPT3SAS_FMT "%s: ioc is operational\n",
+		ioc_info(ioc, "%s: ioc is operational\n", __func__);
-		    ioc->name, __func__);
 	mpi_request = kzalloc(ioc->request_sz, GFP_KERNEL);
 	if (!mpi_request) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: failed obtaining a memory for mpi_request\n",
-			"%s: failed obtaining a memory for mpi_request\n",
+			__func__);
-			ioc->name, __func__);
 		ret = -ENOMEM;
 		goto out;
 	}
 	if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) {
 		smid = mpt3sas_base_get_smid_hpr(ioc, ioc->ctl_cb_idx);
 		if (!smid) {
-			pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
+			ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
-			    ioc->name, __func__);
 			ret = -EAGAIN;
 			goto out;
 		}
 	/* obtain dma-able memory for data transfer */
 	if (data_out_sz) /* WRITE */ {
-		data_out = pci_alloc_consistent(ioc->pdev, data_out_sz,
+		data_out = dma_alloc_coherent(&ioc->pdev->dev, data_out_sz,
-		    &data_out_dma);
+				&data_out_dma, GFP_KERNEL);
 		if (!data_out) {
 			pr_err("failure at %s:%d/%s()!\n", __FILE__,
 			    __LINE__, __func__);
 	}
 	if (data_in_sz) /* READ */ {
-		data_in = pci_alloc_consistent(ioc->pdev, data_in_sz,
+		data_in = dma_alloc_coherent(&ioc->pdev->dev, data_in_sz,
-		    &data_in_dma);
+				&data_in_dma, GFP_KERNEL);
 		if (!data_in) {
 			pr_err("failure at %s:%d/%s()!\n", __FILE__,
 			    __LINE__, __func__);
 		ioc->build_nvme_prp(ioc, smid, nvme_encap_request,
 		    data_out_dma, data_out_sz, data_in_dma, data_in_sz);
 		if (test_bit(device_handle, ioc->device_remove_in_progress)) {
-			dtmprintk(ioc, pr_info(MPT3SAS_FMT "handle(0x%04x) :"
+			dtmprintk(ioc,
-			    "ioctl failed due to device removal in progress\n",
+				  ioc_info(ioc, "handle(0x%04x): ioctl failed due to device removal in progress\n",
-			    ioc->name, device_handle));
+					   device_handle));
 			mpt3sas_base_free_smid(ioc, smid);
 			ret = -EINVAL;
 			goto out;
 		    mpt3sas_base_get_sense_buffer_dma(ioc, smid);
 		memset(ioc->ctl_cmds.sense, 0, SCSI_SENSE_BUFFERSIZE);
 		if (test_bit(device_handle, ioc->device_remove_in_progress)) {
-			dtmprintk(ioc, pr_info(MPT3SAS_FMT
+			dtmprintk(ioc,
-				"handle(0x%04x) :ioctl failed due to device removal in progress\n",
+				  ioc_info(ioc, "handle(0x%04x) :ioctl failed due to device removal in progress\n",
-				ioc->name, device_handle));
+					   device_handle));
 			mpt3sas_base_free_smid(ioc, smid);
 			ret = -EINVAL;
 			goto out;
 		Mpi2SCSITaskManagementRequest_t *tm_request =
 		    (Mpi2SCSITaskManagementRequest_t *)request;
-		dtmprintk(ioc, pr_info(MPT3SAS_FMT
+		dtmprintk(ioc,
-			"TASK_MGMT: handle(0x%04x), task_type(0x%02x)\n",
+			  ioc_info(ioc, "TASK_MGMT: handle(0x%04x), task_type(0x%02x)\n",
-			ioc->name,
+				   le16_to_cpu(tm_request->DevHandle),
-		    le16_to_cpu(tm_request->DevHandle), tm_request->TaskType));
+				   tm_request->TaskType));
 		ioc->got_task_abort_from_ioctl = 1;
 		if (tm_request->TaskType ==
 		    MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK ||
 		ioc->got_task_abort_from_ioctl = 0;
 		if (test_bit(device_handle, ioc->device_remove_in_progress)) {
-			dtmprintk(ioc, pr_info(MPT3SAS_FMT
+			dtmprintk(ioc,
-				"handle(0x%04x) :ioctl failed due to device removal in progress\n",
+				  ioc_info(ioc, "handle(0x%04x) :ioctl failed due to device removal in progress\n",
-				ioc->name, device_handle));
+					   device_handle));
 			mpt3sas_base_free_smid(ioc, smid);
 			ret = -EINVAL;
 			goto out;
 	case MPI2_FUNCTION_SATA_PASSTHROUGH:
 	{
 		if (test_bit(device_handle, ioc->device_remove_in_progress)) {
-			dtmprintk(ioc, pr_info(MPT3SAS_FMT
+			dtmprintk(ioc,
-				"handle(0x%04x) :ioctl failed due to device removal in progress\n",
+				  ioc_info(ioc, "handle(0x%04x) :ioctl failed due to device removal in progress\n",
-				ioc->name, device_handle));
+					   device_handle));
 			mpt3sas_base_free_smid(ioc, smid);
 			ret = -EINVAL;
 			goto out;
 		Mpi2SCSITaskManagementReply_t *tm_reply =
 		    (Mpi2SCSITaskManagementReply_t *)mpi_reply;
-		pr_info(MPT3SAS_FMT "TASK_MGMT: " \
+		ioc_info(ioc, "TASK_MGMT: IOCStatus(0x%04x), IOCLogInfo(0x%08x), TerminationCount(0x%08x)\n",
-		    "IOCStatus(0x%04x), IOCLogInfo(0x%08x), "
+			 le16_to_cpu(tm_reply->IOCStatus),
-		    "TerminationCount(0x%08x)\n", ioc->name,
+			 le32_to_cpu(tm_reply->IOCLogInfo),
-		    le16_to_cpu(tm_reply->IOCStatus),
+			 le32_to_cpu(tm_reply->TerminationCount));
-		    le32_to_cpu(tm_reply->IOCLogInfo),
-		    le32_to_cpu(tm_reply->TerminationCount));
 	}
 	/* copy out xdata to user */
 	    MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH || mpi_request->Function ==
 	    MPI2_FUNCTION_NVME_ENCAPSULATED)) {
 		if (karg.sense_data_ptr == NULL) {
-			pr_info(MPT3SAS_FMT "Response buffer provided"
+			ioc_info(ioc, "Response buffer provided by application is NULL; Response data will not be returned\n");
-			    " by application is NULL; Response data will"
-			    " not be returned.\n", ioc->name);
 			goto out;
 		}
 		sz_arg = (mpi_request->Function ==
 		    mpi_request->Function ==
 		    MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH ||
 		    mpi_request->Function == MPI2_FUNCTION_SATA_PASSTHROUGH)) {
-			pr_info(MPT3SAS_FMT "issue target reset: handle = (0x%04x)\n",
+			ioc_info(ioc, "issue target reset: handle = (0x%04x)\n",
-				ioc->name,
+				 le16_to_cpu(mpi_request->FunctionDependent1));
-				le16_to_cpu(mpi_request->FunctionDependent1));
 			mpt3sas_halt_firmware(ioc);
 			pcie_device = mpt3sas_get_pdev_by_handle(ioc,
 				le16_to_cpu(mpi_request->FunctionDependent1));
 	/* free memory associated with sg buffers */
 	if (data_in)
-		pci_free_consistent(ioc->pdev, data_in_sz, data_in,
+		dma_free_coherent(&ioc->pdev->dev, data_in_sz, data_in,
 		    data_in_dma);
 	if (data_out)
-		pci_free_consistent(ioc->pdev, data_out_sz, data_out,
+		dma_free_coherent(&ioc->pdev->dev, data_out_sz, data_out,
 		    data_out_dma);
 	kfree(mpi_request);
 {
 	struct mpt3_ioctl_iocinfo karg;
-	dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name,
+	dctlprintk(ioc, ioc_info(ioc, "%s: enter\n",
-	    __func__));
+				 __func__));
 	memset(&karg, 0 , sizeof(karg));
 	if (ioc->pfacts)
 		return -EFAULT;
 	}
-	dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name,
+	dctlprintk(ioc, ioc_info(ioc, "%s: enter\n",
-	    __func__));
+				 __func__));
 	karg.event_entries = MPT3SAS_CTL_EVENT_LOG_SIZE;
 	memcpy(karg.event_types, ioc->event_type,
 		return -EFAULT;
 	}
-	dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name,
+	dctlprintk(ioc, ioc_info(ioc, "%s: enter\n",
-	    __func__));
+				 __func__));
 	memcpy(ioc->event_type, karg.event_types,
 	    MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32));
 		return -EFAULT;
 	}
-	dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name,
+	dctlprintk(ioc, ioc_info(ioc, "%s: enter\n",
-	    __func__));
+				 __func__));
 	number_bytes = karg.hdr.max_data_size -
 	    sizeof(struct mpt3_ioctl_header);
 	    ioc->is_driver_loading)
 		return -EAGAIN;
-	dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name,
+	dctlprintk(ioc, ioc_info(ioc, "%s: enter\n",
-	    __func__));
+				 __func__));
 	retval = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
-	pr_info(MPT3SAS_FMT "host reset: %s\n",
+	ioc_info(ioc, "host reset: %s\n", ((!retval) ? "SUCCESS" : "FAILED"));
-	    ioc->name, ((!retval) ? "SUCCESS" : "FAILED"));
 	return 0;
 }
 		return -EFAULT;
 	}
-	dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,
+	dctlprintk(ioc, ioc_info(ioc, "%s\n",
-	    __func__));
+				 __func__));
 	rc = _ctl_btdh_search_sas_device(ioc, &karg);
 	if (!rc)
 	u32 ioc_state;
 	u8 issue_reset = 0;
-	dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,
+	dctlprintk(ioc, ioc_info(ioc, "%s\n",
-	    __func__));
+				 __func__));
 	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
 	if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: failed due to ioc not operational\n",
-		    "%s: failed due to ioc not operational\n",
+			__func__);
-		    ioc->name, __func__);
 		rc = -EAGAIN;
 		goto out;
 	}
 	if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) {
-		pr_err(MPT3SAS_FMT "%s: ctl_cmd in use\n",
+		ioc_err(ioc, "%s: ctl_cmd in use\n", __func__);
-		    ioc->name, __func__);
 		rc = -EAGAIN;
 		goto out;
 	}
 	buffer_type = diag_register->buffer_type;
 	if (!_ctl_diag_capability(ioc, buffer_type)) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n",
-			"%s: doesn't have capability for buffer_type(0x%02x)\n",
+			__func__, buffer_type);
-			ioc->name, __func__, buffer_type);
 		return -EPERM;
 	}
 	if (ioc->diag_buffer_status[buffer_type] &
 	    MPT3_DIAG_BUFFER_IS_REGISTERED) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: already has a registered buffer for buffer_type(0x%02x)\n",
-			"%s: already has a registered buffer for buffer_type(0x%02x)\n",
+			__func__, buffer_type);
-			ioc->name, __func__,
-		    buffer_type);
 		return -EINVAL;
 	}
 	if (diag_register->requested_buffer_size % 4)  {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: the requested_buffer_size is not 4 byte aligned\n",
-			"%s: the requested_buffer_size is not 4 byte aligned\n",
+			__func__);
-			ioc->name, __func__);
 		return -EINVAL;
 	}
 	smid = mpt3sas_base_get_smid(ioc, ioc->ctl_cb_idx);
 	if (!smid) {
-		pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
+		ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
-		    ioc->name, __func__);
 		rc = -EAGAIN;
 		goto out;
 	}
 	if (request_data) {
 		request_data_dma = ioc->diag_buffer_dma[buffer_type];
 		if (request_data_sz != ioc->diag_buffer_sz[buffer_type]) {
-			pci_free_consistent(ioc->pdev,
+			dma_free_coherent(&ioc->pdev->dev,
-			    ioc->diag_buffer_sz[buffer_type],
+					ioc->diag_buffer_sz[buffer_type],
-			    request_data, request_data_dma);
+					request_data, request_data_dma);
 			request_data = NULL;
 		}
 	}
 	if (request_data == NULL) {
 		ioc->diag_buffer_sz[buffer_type] = 0;
 		ioc->diag_buffer_dma[buffer_type] = 0;
-		request_data = pci_alloc_consistent(
+		request_data = dma_alloc_coherent(&ioc->pdev->dev,
-			ioc->pdev, request_data_sz, &request_data_dma);
+				request_data_sz, &request_data_dma, GFP_KERNEL);
 		if (request_data == NULL) {
-			pr_err(MPT3SAS_FMT "%s: failed allocating memory" \
+			ioc_err(ioc, "%s: failed allocating memory for diag buffers, requested size(%d)\n",
-			    " for diag buffers, requested size(%d)\n",
+				__func__, request_data_sz);
-			    ioc->name, __func__, request_data_sz);
 			mpt3sas_base_free_smid(ioc, smid);
 			return -ENOMEM;
 		}
 	mpi_request->VF_ID = 0; /* TODO */
 	mpi_request->VP_ID = 0;
-	dctlprintk(ioc, pr_info(MPT3SAS_FMT
+	dctlprintk(ioc,
-		"%s: diag_buffer(0x%p), dma(0x%llx), sz(%d)\n",
+		   ioc_info(ioc, "%s: diag_buffer(0x%p), dma(0x%llx), sz(%d)\n",
-		ioc->name, __func__, request_data,
+			    __func__, request_data,
-	    (unsigned long long)request_data_dma,
+			    (unsigned long long)request_data_dma,
-	    le32_to_cpu(mpi_request->BufferLength)));
+			    le32_to_cpu(mpi_request->BufferLength)));
 	for (i = 0; i < MPT3_PRODUCT_SPECIFIC_DWORDS; i++)
 		mpi_request->ProductSpecific[i] =
 	/* process the completed Reply Message Frame */
 	if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) {
-		pr_err(MPT3SAS_FMT "%s: no reply message\n",
+		ioc_err(ioc, "%s: no reply message\n", __func__);
-		    ioc->name, __func__);
 		rc = -EFAULT;
 		goto out;
 	}
 	if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
 		ioc->diag_buffer_status[buffer_type] |=
 			MPT3_DIAG_BUFFER_IS_REGISTERED;
-		dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: success\n",
+		dctlprintk(ioc, ioc_info(ioc, "%s: success\n", __func__));
-		    ioc->name, __func__));
 	} else {
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "%s: ioc_status(0x%04x) log_info(0x%08x)\n",
-			"%s: ioc_status(0x%04x) log_info(0x%08x)\n",
+			 __func__,
-			ioc->name, __func__,
+			 ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
-		    ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
 		rc = -EFAULT;
 	}
  out:
 	if (rc && request_data)
-		pci_free_consistent(ioc->pdev, request_data_sz,
+		dma_free_coherent(&ioc->pdev->dev, request_data_sz,
 		    request_data, request_data_dma);
 	ioc->ctl_cmds.status = MPT3_CMD_NOT_USED;
 	memset(&diag_register, 0, sizeof(struct mpt3_diag_register));
 	if (bits_to_register & 1) {
-		pr_info(MPT3SAS_FMT "registering trace buffer support\n",
+		ioc_info(ioc, "registering trace buffer support\n");
-		    ioc->name);
 		ioc->diag_trigger_master.MasterData =
 		    (MASTER_TRIGGER_FW_FAULT + MASTER_TRIGGER_ADAPTER_RESET);
 		diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE;
 	}
 	if (bits_to_register & 2) {
-		pr_info(MPT3SAS_FMT "registering snapshot buffer support\n",
+		ioc_info(ioc, "registering snapshot buffer support\n");
-		    ioc->name);
 		diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_SNAPSHOT;
 		/* register for 2MB buffers  */
 		diag_register.requested_buffer_size = 2 * (1024 * 1024);
 	}
 	if (bits_to_register & 4) {
-		pr_info(MPT3SAS_FMT "registering extended buffer support\n",
+		ioc_info(ioc, "registering extended buffer support\n");
-		    ioc->name);
 		diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_EXTENDED;
 		/* register for 2MB buffers  */
 		diag_register.requested_buffer_size = 2 * (1024 * 1024);
 		return -EFAULT;
 	}
-	dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,
+	dctlprintk(ioc, ioc_info(ioc, "%s\n",
-	    __func__));
+				 __func__));
 	buffer_type = karg.unique_id & 0x000000ff;
 	if (!_ctl_diag_capability(ioc, buffer_type)) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n",
-			"%s: doesn't have capability for buffer_type(0x%02x)\n",
+			__func__, buffer_type);
-			ioc->name, __func__, buffer_type);
 		return -EPERM;
 	}
 	if ((ioc->diag_buffer_status[buffer_type] &
 	    MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: buffer_type(0x%02x) is not registered\n",
-			"%s: buffer_type(0x%02x) is not registered\n",
+			__func__, buffer_type);
-			ioc->name, __func__, buffer_type);
 		return -EINVAL;
 	}
 	if ((ioc->diag_buffer_status[buffer_type] &
 	    MPT3_DIAG_BUFFER_IS_RELEASED) == 0) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: buffer_type(0x%02x) has not been released\n",
-			"%s: buffer_type(0x%02x) has not been released\n",
+			__func__, buffer_type);
-			ioc->name, __func__, buffer_type);
 		return -EINVAL;
 	}
 	if (karg.unique_id != ioc->unique_id[buffer_type]) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: unique_id(0x%08x) is not registered\n",
-			"%s: unique_id(0x%08x) is not registered\n",
+			__func__, karg.unique_id);
-			ioc->name, __func__, karg.unique_id);
 		return -EINVAL;
 	}
 	request_data = ioc->diag_buffer[buffer_type];
 	if (!request_data) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: doesn't have memory allocated for buffer_type(0x%02x)\n",
-			"%s: doesn't have memory allocated for buffer_type(0x%02x)\n",
+			__func__, buffer_type);
-			ioc->name, __func__, buffer_type);
 		return -ENOMEM;
 	}
 	request_data_sz = ioc->diag_buffer_sz[buffer_type];
 	request_data_dma = ioc->diag_buffer_dma[buffer_type];
-	pci_free_consistent(ioc->pdev, request_data_sz,
+	dma_free_coherent(&ioc->pdev->dev, request_data_sz,
-	    request_data, request_data_dma);
+			request_data, request_data_dma);
 	ioc->diag_buffer[buffer_type] = NULL;
 	ioc->diag_buffer_status[buffer_type] = 0;
 	return 0;
 		return -EFAULT;
 	}
-	dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,
+	dctlprintk(ioc, ioc_info(ioc, "%s\n",
-	    __func__));
+				 __func__));
 	karg.application_flags = 0;
 	buffer_type = karg.buffer_type;
 	if (!_ctl_diag_capability(ioc, buffer_type)) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n",
-			"%s: doesn't have capability for buffer_type(0x%02x)\n",
+			__func__, buffer_type);
-			ioc->name, __func__, buffer_type);
 		return -EPERM;
 	}
 	if ((ioc->diag_buffer_status[buffer_type] &
 	    MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: buffer_type(0x%02x) is not registered\n",
-			"%s: buffer_type(0x%02x) is not registered\n",
+			__func__, buffer_type);
-			ioc->name, __func__, buffer_type);
 		return -EINVAL;
 	}
 	if (karg.unique_id & 0xffffff00) {
 		if (karg.unique_id != ioc->unique_id[buffer_type]) {
-			pr_err(MPT3SAS_FMT
+			ioc_err(ioc, "%s: unique_id(0x%08x) is not registered\n",
-				"%s: unique_id(0x%08x) is not registered\n",
+				__func__, karg.unique_id);
-				ioc->name, __func__, karg.unique_id);
 			return -EINVAL;
 		}
 	}
 	request_data = ioc->diag_buffer[buffer_type];
 	if (!request_data) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: doesn't have buffer for buffer_type(0x%02x)\n",
-			"%s: doesn't have buffer for buffer_type(0x%02x)\n",
+			__func__, buffer_type);
-			ioc->name, __func__, buffer_type);
 		return -ENOMEM;
 	}
 	karg.diagnostic_flags = ioc->diagnostic_flags[buffer_type];
 	if (copy_to_user(arg, &karg, sizeof(struct mpt3_diag_query))) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: unable to write mpt3_diag_query data @ %p\n",
-			"%s: unable to write mpt3_diag_query data @ %p\n",
+			__func__, arg);
-			ioc->name, __func__, arg);
 		return -EFAULT;
 	}
 	return 0;
 	u32 ioc_state;
 	int rc;
-	dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,
+	dctlprintk(ioc, ioc_info(ioc, "%s\n",
-	    __func__));
+				 __func__));
 	rc = 0;
 	*issue_reset = 0;
 		    MPT3_DIAG_BUFFER_IS_REGISTERED)
 			ioc->diag_buffer_status[buffer_type] |=
 			    MPT3_DIAG_BUFFER_IS_RELEASED;
-		dctlprintk(ioc, pr_info(MPT3SAS_FMT
+		dctlprintk(ioc,
-			"%s: skipping due to FAULT state\n", ioc->name,
+			   ioc_info(ioc, "%s: skipping due to FAULT state\n",
-		    __func__));
+				    __func__));
 		rc = -EAGAIN;
 		goto out;
 	}
 	if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) {
-		pr_err(MPT3SAS_FMT "%s: ctl_cmd in use\n",
+		ioc_err(ioc, "%s: ctl_cmd in use\n", __func__);
-		    ioc->name, __func__);
 		rc = -EAGAIN;
 		goto out;
 	}
 	smid = mpt3sas_base_get_smid(ioc, ioc->ctl_cb_idx);
 	if (!smid) {
-		pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
+		ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
-		    ioc->name, __func__);
 		rc = -EAGAIN;
 		goto out;
 	}
 	/* process the completed Reply Message Frame */
 	if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) {
-		pr_err(MPT3SAS_FMT "%s: no reply message\n",
+		ioc_err(ioc, "%s: no reply message\n", __func__);
-		    ioc->name, __func__);
 		rc = -EFAULT;
 		goto out;
 	}
 	if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
 		ioc->diag_buffer_status[buffer_type] |=
 		    MPT3_DIAG_BUFFER_IS_RELEASED;
-		dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: success\n",
+		dctlprintk(ioc, ioc_info(ioc, "%s: success\n", __func__));
-		    ioc->name, __func__));
 	} else {
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "%s: ioc_status(0x%04x) log_info(0x%08x)\n",
-			"%s: ioc_status(0x%04x) log_info(0x%08x)\n",
+			 __func__,
-			ioc->name, __func__,
+			 ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
-		    ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
 		rc = -EFAULT;
 	}
 		return -EFAULT;
 	}
-	dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,
+	dctlprintk(ioc, ioc_info(ioc, "%s\n",
-	    __func__));
+				 __func__));
 	buffer_type = karg.unique_id & 0x000000ff;
 	if (!_ctl_diag_capability(ioc, buffer_type)) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n",
-			"%s: doesn't have capability for buffer_type(0x%02x)\n",
+			__func__, buffer_type);
-			ioc->name, __func__, buffer_type);
 		return -EPERM;
 	}
 	if ((ioc->diag_buffer_status[buffer_type] &
 	    MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: buffer_type(0x%02x) is not registered\n",
-			"%s: buffer_type(0x%02x) is not registered\n",
+			__func__, buffer_type);
-			ioc->name, __func__, buffer_type);
 		return -EINVAL;
 	}
 	if (karg.unique_id != ioc->unique_id[buffer_type]) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: unique_id(0x%08x) is not registered\n",
-			"%s: unique_id(0x%08x) is not registered\n",
+			__func__, karg.unique_id);
-			ioc->name, __func__, karg.unique_id);
 		return -EINVAL;
 	}
 	if (ioc->diag_buffer_status[buffer_type] &
 	    MPT3_DIAG_BUFFER_IS_RELEASED) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: buffer_type(0x%02x) is already released\n",
-			"%s: buffer_type(0x%02x) is already released\n",
+			__func__, buffer_type);
-			ioc->name, __func__,
-		    buffer_type);
 		return 0;
 	}
 	request_data = ioc->diag_buffer[buffer_type];
 	if (!request_data) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: doesn't have memory allocated for buffer_type(0x%02x)\n",
-			"%s: doesn't have memory allocated for buffer_type(0x%02x)\n",
+			__func__, buffer_type);
-			ioc->name, __func__, buffer_type);
 		return -ENOMEM;
 	}
 		    MPT3_DIAG_BUFFER_IS_RELEASED;
 		ioc->diag_buffer_status[buffer_type] &=
 		    ~MPT3_DIAG_BUFFER_IS_DIAG_RESET;
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: buffer_type(0x%02x) was released due to host reset\n",
-			"%s: buffer_type(0x%02x) was released due to host reset\n",
+			__func__, buffer_type);
-			ioc->name, __func__, buffer_type);
 		return 0;
 	}
 		return -EFAULT;
 	}
-	dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,
+	dctlprintk(ioc, ioc_info(ioc, "%s\n",
-	    __func__));
+				 __func__));
 	buffer_type = karg.unique_id & 0x000000ff;
 	if (!_ctl_diag_capability(ioc, buffer_type)) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n",
-			"%s: doesn't have capability for buffer_type(0x%02x)\n",
+			__func__, buffer_type);
-			ioc->name, __func__, buffer_type);
 		return -EPERM;
 	}
 	if (karg.unique_id != ioc->unique_id[buffer_type]) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: unique_id(0x%08x) is not registered\n",
-			"%s: unique_id(0x%08x) is not registered\n",
+			__func__, karg.unique_id);
-			ioc->name, __func__, karg.unique_id);
 		return -EINVAL;
 	}
 	request_data = ioc->diag_buffer[buffer_type];
 	if (!request_data) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: doesn't have buffer for buffer_type(0x%02x)\n",
-			"%s: doesn't have buffer for buffer_type(0x%02x)\n",
+			__func__, buffer_type);
-			ioc->name, __func__, buffer_type);
 		return -ENOMEM;
 	}
 	request_size = ioc->diag_buffer_sz[buffer_type];
 	if ((karg.starting_offset % 4) || (karg.bytes_to_read % 4)) {
-		pr_err(MPT3SAS_FMT "%s: either the starting_offset " \
+		ioc_err(ioc, "%s: either the starting_offset or bytes_to_read are not 4 byte aligned\n",
-		    "or bytes_to_read are not 4 byte aligned\n", ioc->name,
+			__func__);
-		    __func__);
 		return -EINVAL;
 	}
 		return -EINVAL;
 	diag_data = (void *)(request_data + karg.starting_offset);
-	dctlprintk(ioc, pr_info(MPT3SAS_FMT
+	dctlprintk(ioc,
-		"%s: diag_buffer(%p), offset(%d), sz(%d)\n",
+		   ioc_info(ioc, "%s: diag_buffer(%p), offset(%d), sz(%d)\n",
-		ioc->name, __func__,
+			    __func__, diag_data, karg.starting_offset,
-	    diag_data, karg.starting_offset, karg.bytes_to_read));
+			    karg.bytes_to_read));
 	/* Truncate data on requests that are too large */
 	if ((diag_data + karg.bytes_to_read < diag_data) ||
 	if (copy_to_user((void __user *)uarg->diagnostic_data,
 	    diag_data, copy_size)) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: Unable to write mpt_diag_read_buffer_t data @ %p\n",
-			"%s: Unable to write mpt_diag_read_buffer_t data @ %p\n",
+			__func__, diag_data);
-			ioc->name, __func__, diag_data);
 		return -EFAULT;
 	}
 	if ((karg.flags & MPT3_FLAGS_REREGISTER) == 0)
 		return 0;
-	dctlprintk(ioc, pr_info(MPT3SAS_FMT
+	dctlprintk(ioc,
-		"%s: Reregister buffer_type(0x%02x)\n",
+		   ioc_info(ioc, "%s: Reregister buffer_type(0x%02x)\n",
-		ioc->name, __func__, buffer_type));
+			    __func__, buffer_type));
 	if ((ioc->diag_buffer_status[buffer_type] &
 	    MPT3_DIAG_BUFFER_IS_RELEASED) == 0) {
-		dctlprintk(ioc, pr_info(MPT3SAS_FMT
+		dctlprintk(ioc,
-			"%s: buffer_type(0x%02x) is still registered\n",
+			   ioc_info(ioc, "%s: buffer_type(0x%02x) is still registered\n",
-			ioc->name, __func__, buffer_type));
+				    __func__, buffer_type));
 		return 0;
 	}
 	/* Get a free request frame and save the message context.
 	*/
 	if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) {
-		pr_err(MPT3SAS_FMT "%s: ctl_cmd in use\n",
+		ioc_err(ioc, "%s: ctl_cmd in use\n", __func__);
-		    ioc->name, __func__);
 		rc = -EAGAIN;
 		goto out;
 	}
 	smid = mpt3sas_base_get_smid(ioc, ioc->ctl_cb_idx);
 	if (!smid) {
-		pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
+		ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
-		    ioc->name, __func__);
 		rc = -EAGAIN;
 		goto out;
 	}
 	/* process the completed Reply Message Frame */
 	if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) {
-		pr_err(MPT3SAS_FMT "%s: no reply message\n",
+		ioc_err(ioc, "%s: no reply message\n", __func__);
-		    ioc->name, __func__);
 		rc = -EFAULT;
 		goto out;
 	}
 	if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
 		ioc->diag_buffer_status[buffer_type] |=
 		    MPT3_DIAG_BUFFER_IS_REGISTERED;
-		dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: success\n",
+		dctlprintk(ioc, ioc_info(ioc, "%s: success\n", __func__));
-		    ioc->name, __func__));
 	} else {
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "%s: ioc_status(0x%04x) log_info(0x%08x)\n",
-			"%s: ioc_status(0x%04x) log_info(0x%08x)\n",
+			 __func__, ioc_status,
-			ioc->name, __func__,
+			 le32_to_cpu(mpi_reply->IOCLogInfo));
-		    ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
 		rc = -EFAULT;
 	}
 			ret = _ctl_diag_read_buffer(ioc, arg);
 		break;
 	default:
-		dctlprintk(ioc, pr_info(MPT3SAS_FMT
+		dctlprintk(ioc,
-		    "unsupported ioctl opcode(0x%08x)\n", ioc->name, cmd));
+			   ioc_info(ioc, "unsupported ioctl opcode(0x%08x)\n",
+				    cmd));
 		break;
 	}
 		return -EINVAL;
 	ioc->logging_level = val;
-	pr_info(MPT3SAS_FMT "logging_level=%08xh\n", ioc->name,
+	ioc_info(ioc, "logging_level=%08xh\n",
-	    ioc->logging_level);
+		 ioc->logging_level);
 	return strlen(buf);
 }
 static DEVICE_ATTR(logging_level, S_IRUGO | S_IWUSR, _ctl_logging_level_show,
 		return -EINVAL;
 	ioc->fwfault_debug = val;
-	pr_info(MPT3SAS_FMT "fwfault_debug=%d\n", ioc->name,
+	ioc_info(ioc, "fwfault_debug=%d\n",
-	    ioc->fwfault_debug);
+		 ioc->fwfault_debug);
 	return strlen(buf);
 }
 static DEVICE_ATTR(fwfault_debug, S_IRUGO | S_IWUSR,
 	ssize_t rc = 0;
 	if (!ioc->is_warpdrive) {
-		pr_err(MPT3SAS_FMT "%s: BRM attribute is only for"
+		ioc_err(ioc, "%s: BRM attribute is only for warpdrive\n",
-		    " warpdrive\n", ioc->name, __func__);
+			__func__);
 		goto out;
 	}
 	/* pci_access_mutex lock acquired by sysfs show path */
 	sz = offsetof(Mpi2IOUnitPage3_t, GPIOVal) + (sizeof(u16) * 36);
 	io_unit_pg3 = kzalloc(sz, GFP_KERNEL);
 	if (!io_unit_pg3) {
-		pr_err(MPT3SAS_FMT "%s: failed allocating memory "
+		ioc_err(ioc, "%s: failed allocating memory for iounit_pg3: (%d) bytes\n",
-		    "for iounit_pg3: (%d) bytes\n", ioc->name, __func__, sz);
+			__func__, sz);
 		goto out;
 	}
 	if (mpt3sas_config_get_iounit_pg3(ioc, &mpi_reply, io_unit_pg3, sz) !=
 	    0) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: failed reading iounit_pg3\n",
-		    "%s: failed reading iounit_pg3\n", ioc->name,
+			__func__);
-		    __func__);
 		goto out;
 	}
 	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
 	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-		pr_err(MPT3SAS_FMT "%s: iounit_pg3 failed with "
+		ioc_err(ioc, "%s: iounit_pg3 failed with ioc_status(0x%04x)\n",
-		    "ioc_status(0x%04x)\n", ioc->name, __func__, ioc_status);
+			__func__, ioc_status);
 		goto out;
 	}
 	if (io_unit_pg3->GPIOCount < 25) {
-		pr_err(MPT3SAS_FMT "%s: iounit_pg3->GPIOCount less than "
+		ioc_err(ioc, "%s: iounit_pg3->GPIOCount less than 25 entries, detected (%d) entries\n",
-		     "25 entries, detected (%d) entries\n", ioc->name, __func__,
+			__func__, io_unit_pg3->GPIOCount);
-		    io_unit_pg3->GPIOCount);
 		goto out;
 	}
 	struct DIAG_BUFFER_START *request_data;
 	if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: host_trace_buffer is not registered\n",
-			"%s: host_trace_buffer is not registered\n",
+			__func__);
-			ioc->name, __func__);
 		return 0;
 	}
 	if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
 	    MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: host_trace_buffer is not registered\n",
-			"%s: host_trace_buffer is not registered\n",
+			__func__);
-			ioc->name, __func__);
 		return 0;
 	}
 	u32 size;
 	if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: host_trace_buffer is not registered\n",
-			"%s: host_trace_buffer is not registered\n",
+			__func__);
-			ioc->name, __func__);
 		return 0;
 	}
 	if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
 	    MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: host_trace_buffer is not registered\n",
-			"%s: host_trace_buffer is not registered\n",
+			__func__);
-			ioc->name, __func__);
 		return 0;
 	}
 		    MPT3_DIAG_BUFFER_IS_RELEASED) == 0))
 			goto out;
 		memset(&diag_register, 0, sizeof(struct mpt3_diag_register));
-		pr_info(MPT3SAS_FMT "posting host trace buffers\n",
+		ioc_info(ioc, "posting host trace buffers\n");
-		    ioc->name);
 		diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE;
 		diag_register.requested_buffer_size = (1024 * 1024);
 		diag_register.unique_id = 0x7075900;
 		if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
 		    MPT3_DIAG_BUFFER_IS_RELEASED))
 			goto out;
-		pr_info(MPT3SAS_FMT "releasing host trace buffer\n",
+		ioc_info(ioc, "releasing host trace buffer\n");
-		    ioc->name);
 		mpt3sas_send_diag_release(ioc, MPI2_DIAG_BUF_TYPE_TRACE,
 		    &issue_reset);
 	}
 			if ((ioc->diag_buffer_status[i] &
 			    MPT3_DIAG_BUFFER_IS_RELEASED))
 				continue;
-			pci_free_consistent(ioc->pdev, ioc->diag_buffer_sz[i],
+			dma_free_coherent(&ioc->pdev->dev,
-			ioc->diag_buffer[i], ioc->diag_buffer_dma[i]);
+					  ioc->diag_buffer_sz[i],
+					  ioc->diag_buffer[i],
+					  ioc->diag_buffer_dma[i]);
 			ioc->diag_buffer[i] = NULL;
 			ioc->diag_buffer_status[i] = 0;
 		}

drivers/scsi/mpt3sas/mpt3sas_scsih.c+652−835

 	if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
 	    MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", ioc->name,
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		__FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return -ENXIO;
 	}
 		return -ENXIO;
 	/* else error case */
-	pr_err(MPT3SAS_FMT
+	ioc_err(ioc, "handle(0x%04x), ioc_status(0x%04x), failure at %s:%d/%s()!\n",
-		"handle(0x%04x), ioc_status(0x%04x), failure at %s:%d/%s()!\n",
+		handle, ioc_status, __FILE__, __LINE__, __func__);
-		ioc->name, handle, ioc_status,
-	     __FILE__, __LINE__, __func__);
 	return -EIO;
 }
 		    (ioc->bios_pg2.ReqBootDeviceForm &
 		    MPI2_BIOSPAGE2_FORM_MASK),
 		    &ioc->bios_pg2.RequestedBootDevice)) {
-			dinitprintk(ioc, pr_info(MPT3SAS_FMT
+			dinitprintk(ioc,
-			   "%s: req_boot_device(0x%016llx)\n",
+				    ioc_info(ioc, "%s: req_boot_device(0x%016llx)\n",
-			    ioc->name, __func__,
+					     __func__, (u64)sas_address));
-			    (unsigned long long)sas_address));
 			ioc->req_boot_device.device = device;
 			ioc->req_boot_device.channel = channel;
 		}
 		    (ioc->bios_pg2.ReqAltBootDeviceForm &
 		    MPI2_BIOSPAGE2_FORM_MASK),
 		    &ioc->bios_pg2.RequestedAltBootDevice)) {
-			dinitprintk(ioc, pr_info(MPT3SAS_FMT
+			dinitprintk(ioc,
-			   "%s: req_alt_boot_device(0x%016llx)\n",
+				    ioc_info(ioc, "%s: req_alt_boot_device(0x%016llx)\n",
-			    ioc->name, __func__,
+					     __func__, (u64)sas_address));
-			    (unsigned long long)sas_address));
 			ioc->req_alt_boot_device.device = device;
 			ioc->req_alt_boot_device.channel = channel;
 		}
 		    (ioc->bios_pg2.CurrentBootDeviceForm &
 		    MPI2_BIOSPAGE2_FORM_MASK),
 		    &ioc->bios_pg2.CurrentBootDevice)) {
-			dinitprintk(ioc, pr_info(MPT3SAS_FMT
+			dinitprintk(ioc,
-			   "%s: current_boot_device(0x%016llx)\n",
+				    ioc_info(ioc, "%s: current_boot_device(0x%016llx)\n",
-			    ioc->name, __func__,
+					     __func__, (u64)sas_address));
-			    (unsigned long long)sas_address));
 			ioc->current_boot_device.device = device;
 			ioc->current_boot_device.channel = channel;
 		}
 			    sas_device->chassis_slot);
 	} else {
 		if (sas_device->enclosure_handle != 0)
-			pr_info(MPT3SAS_FMT
+			ioc_info(ioc, "enclosure logical id(0x%016llx), slot(%d)\n",
-			    "enclosure logical id(0x%016llx), slot(%d) \n",
+				 (u64)sas_device->enclosure_logical_id,
-			    ioc->name, (unsigned long long)
+				 sas_device->slot);
-			    sas_device->enclosure_logical_id,
-			    sas_device->slot);
 		if (sas_device->connector_name[0] != '\0')
-			pr_info(MPT3SAS_FMT
+			ioc_info(ioc, "enclosure level(0x%04x), connector name( %s)\n",
-			    "enclosure level(0x%04x), connector name( %s)\n",
+				 sas_device->enclosure_level,
-			    ioc->name, sas_device->enclosure_level,
+				 sas_device->connector_name);
-			    sas_device->connector_name);
 		if (sas_device->is_chassis_slot_valid)
-			pr_info(MPT3SAS_FMT "chassis slot(0x%04x)\n",
+			ioc_info(ioc, "chassis slot(0x%04x)\n",
-			    ioc->name, sas_device->chassis_slot);
+				 sas_device->chassis_slot);
 	}
 }
 	if (!sas_device)
 		return;
-	pr_info(MPT3SAS_FMT
+	ioc_info(ioc, "removing handle(0x%04x), sas_addr(0x%016llx)\n",
-	    "removing handle(0x%04x), sas_addr(0x%016llx)\n",
+		 sas_device->handle, (u64)sas_device->sas_address);
-	    ioc->name, sas_device->handle,
-	    (unsigned long long) sas_device->sas_address);
 	_scsih_display_enclosure_chassis_info(ioc, sas_device, NULL, NULL);
 {
 	unsigned long flags;
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT
+	dewtprintk(ioc,
-		"%s: handle(0x%04x), sas_addr(0x%016llx)\n",
+		   ioc_info(ioc, "%s: handle(0x%04x), sas_addr(0x%016llx)\n",
-		ioc->name, __func__, sas_device->handle,
+			    __func__, sas_device->handle,
-		(unsigned long long)sas_device->sas_address));
+			    (u64)sas_device->sas_address));
 	dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
 	    NULL, NULL));
 {
 	unsigned long flags;
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT
+	dewtprintk(ioc,
-		"%s: handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name,
+		   ioc_info(ioc, "%s: handle(0x%04x), sas_addr(0x%016llx)\n",
-		__func__, sas_device->handle,
+			    __func__, sas_device->handle,
-		(unsigned long long)sas_device->sas_address));
+			    (u64)sas_device->sas_address));
 	dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
 	    NULL, NULL));
 	if (!pcie_device)
 		return;
-	pr_info(MPT3SAS_FMT
+	ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
-		"removing handle(0x%04x), wwid(0x%016llx)\n",
+		 pcie_device->handle, (u64)pcie_device->wwid);
-		ioc->name, pcie_device->handle,
-		(unsigned long long) pcie_device->wwid);
 	if (pcie_device->enclosure_handle != 0)
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "removing enclosure logical id(0x%016llx), slot(%d)\n",
-			"removing enclosure logical id(0x%016llx), slot(%d)\n",
+			 (u64)pcie_device->enclosure_logical_id,
-			ioc->name,
+			 pcie_device->slot);
-			(unsigned long long)pcie_device->enclosure_logical_id,
-		pcie_device->slot);
 	if (pcie_device->connector_name[0] != '\0')
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "removing enclosure level(0x%04x), connector name( %s)\n",
-		    "removing enclosure level(0x%04x), connector name( %s)\n",
+			 pcie_device->enclosure_level,
-			ioc->name, pcie_device->enclosure_level,
+			 pcie_device->connector_name);
-			pcie_device->connector_name);
 	spin_lock_irqsave(&ioc->pcie_device_lock, flags);
 	if (!list_empty(&pcie_device->list)) {
 {
 	unsigned long flags;
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT
+	dewtprintk(ioc,
-		"%s: handle (0x%04x), wwid(0x%016llx)\n", ioc->name, __func__,
+		   ioc_info(ioc, "%s: handle (0x%04x), wwid(0x%016llx)\n",
-		pcie_device->handle, (unsigned long long)pcie_device->wwid));
+			    __func__,
+			    pcie_device->handle, (u64)pcie_device->wwid));
 	if (pcie_device->enclosure_handle != 0)
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-			"%s: enclosure logical id(0x%016llx), slot( %d)\n",
+			   ioc_info(ioc, "%s: enclosure logical id(0x%016llx), slot( %d)\n",
-			ioc->name, __func__,
+				    __func__,
-			(unsigned long long)pcie_device->enclosure_logical_id,
+				    (u64)pcie_device->enclosure_logical_id,
-			pcie_device->slot));
+				    pcie_device->slot));
 	if (pcie_device->connector_name[0] != '\0')
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-			"%s: enclosure level(0x%04x), connector name( %s)\n",
+			   ioc_info(ioc, "%s: enclosure level(0x%04x), connector name( %s)\n",
-			ioc->name, __func__, pcie_device->enclosure_level,
+				    __func__, pcie_device->enclosure_level,
-			pcie_device->connector_name));
+				    pcie_device->connector_name));
 	spin_lock_irqsave(&ioc->pcie_device_lock, flags);
 	pcie_device_get(pcie_device);
 {
 	unsigned long flags;
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT
+	dewtprintk(ioc,
-		"%s: handle (0x%04x), wwid(0x%016llx)\n", ioc->name, __func__,
+		   ioc_info(ioc, "%s: handle (0x%04x), wwid(0x%016llx)\n",
-		pcie_device->handle, (unsigned long long)pcie_device->wwid));
+			    __func__,
+			    pcie_device->handle, (u64)pcie_device->wwid));
 	if (pcie_device->enclosure_handle != 0)
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-			"%s: enclosure logical id(0x%016llx), slot( %d)\n",
+			   ioc_info(ioc, "%s: enclosure logical id(0x%016llx), slot( %d)\n",
-			ioc->name, __func__,
+				    __func__,
-			(unsigned long long)pcie_device->enclosure_logical_id,
+				    (u64)pcie_device->enclosure_logical_id,
-			pcie_device->slot));
+				    pcie_device->slot));
 	if (pcie_device->connector_name[0] != '\0')
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-			"%s: enclosure level(0x%04x), connector name( %s)\n",
+			   ioc_info(ioc, "%s: enclosure level(0x%04x), connector name( %s)\n",
-			ioc->name, __func__, pcie_device->enclosure_level,
+				    __func__, pcie_device->enclosure_level,
-			pcie_device->connector_name));
+				    pcie_device->connector_name));
 	spin_lock_irqsave(&ioc->pcie_device_lock, flags);
 	pcie_device_get(pcie_device);
 {
 	unsigned long flags;
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT
+	dewtprintk(ioc,
-		"%s: handle(0x%04x), wwid(0x%016llx)\n", ioc->name, __func__,
+		   ioc_info(ioc, "%s: handle(0x%04x), wwid(0x%016llx)\n",
-	    raid_device->handle, (unsigned long long)raid_device->wwid));
+			    __func__,
+			    raid_device->handle, (u64)raid_device->wwid));
 	spin_lock_irqsave(&ioc->raid_device_lock, flags);
 	list_add_tail(&raid_device->list, &ioc->raid_device_list);
 	if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
 	    MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return;
 	}
 	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 	    MPI2_IOCSTATUS_MASK;
 	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return;
 	}
 	if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
 	     MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
 	     sizeof(Mpi2RaidVolPage0_t))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		percent_complete = 0;
 		goto out;
 	}
 	if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
 	     MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
 	     sizeof(Mpi2RaidVolPage0_t))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		goto out;
 	}
 	if ((mpt3sas_config_get_number_pds(ioc, raid_device->handle,
 	    &num_pds)) || !num_pds) {
-		dfailprintk(ioc, pr_warn(MPT3SAS_FMT
+		dfailprintk(ioc,
-		    "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
+			    ioc_warn(ioc, "failure at %s:%d/%s()!\n",
-		    __func__));
+				     __FILE__, __LINE__, __func__));
 		return 1;
 	}
 	    sizeof(Mpi2RaidVol0PhysDisk_t));
 	vol_pg0 = kzalloc(sz, GFP_KERNEL);
 	if (!vol_pg0) {
-		dfailprintk(ioc, pr_warn(MPT3SAS_FMT
+		dfailprintk(ioc,
-		    "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
+			    ioc_warn(ioc, "failure at %s:%d/%s()!\n",
-		    __func__));
+				     __FILE__, __LINE__, __func__));
 		return 1;
 	}
 	if ((mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0,
 	     MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle, sz))) {
-		dfailprintk(ioc, pr_warn(MPT3SAS_FMT
+		dfailprintk(ioc,
-		    "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
+			    ioc_warn(ioc, "failure at %s:%d/%s()!\n",
-		    __func__));
+				     __FILE__, __LINE__, __func__));
 		kfree(vol_pg0);
 		return 1;
 	}
 		raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle);
 		spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
 		if (!raid_device) {
-			dfailprintk(ioc, pr_warn(MPT3SAS_FMT
+			dfailprintk(ioc,
-			    "failure at %s:%d/%s()!\n", ioc->name, __FILE__,
+				    ioc_warn(ioc, "failure at %s:%d/%s()!\n",
-			    __LINE__, __func__));
+					     __FILE__, __LINE__, __func__));
 			return 1;
 		}
 		if (_scsih_get_volume_capabilities(ioc, raid_device)) {
-			dfailprintk(ioc, pr_warn(MPT3SAS_FMT
+			dfailprintk(ioc,
-			    "failure at %s:%d/%s()!\n", ioc->name, __FILE__,
+				    ioc_warn(ioc, "failure at %s:%d/%s()!\n",
-			    __LINE__, __func__));
+					     __FILE__, __LINE__, __func__));
 			return 1;
 		}
 	if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
 		if (mpt3sas_config_get_volume_handle(ioc, handle,
 		    &volume_handle)) {
-			dfailprintk(ioc, pr_warn(MPT3SAS_FMT
+			dfailprintk(ioc,
-			    "failure at %s:%d/%s()!\n", ioc->name,
+				    ioc_warn(ioc, "failure at %s:%d/%s()!\n",
-			    __FILE__, __LINE__, __func__));
+					     __FILE__, __LINE__, __func__));
 			return 1;
 		}
 		if (volume_handle && mpt3sas_config_get_volume_wwid(ioc,
 		    volume_handle, &volume_wwid)) {
-			dfailprintk(ioc, pr_warn(MPT3SAS_FMT
+			dfailprintk(ioc,
-			    "failure at %s:%d/%s()!\n", ioc->name,
+				    ioc_warn(ioc, "failure at %s:%d/%s()!\n",
-			    __FILE__, __LINE__, __func__));
+					     __FILE__, __LINE__, __func__));
 			return 1;
 		}
 	}
 				sas_device_priv_data->sas_target->sas_address);
 		if (!pcie_device) {
 			spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
-			dfailprintk(ioc, pr_warn(MPT3SAS_FMT
+			dfailprintk(ioc,
-				"failure at %s:%d/%s()!\n", ioc->name, __FILE__,
+				    ioc_warn(ioc, "failure at %s:%d/%s()!\n",
-				__LINE__, __func__));
+					     __FILE__, __LINE__, __func__));
 			return 1;
 		}
 	   sas_device_priv_data->sas_target->sas_address);
 	if (!sas_device) {
 		spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
-		dfailprintk(ioc, pr_warn(MPT3SAS_FMT
+		dfailprintk(ioc,
-		    "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
+			    ioc_warn(ioc, "failure at %s:%d/%s()!\n",
-		    __func__));
+				     __FILE__, __LINE__, __func__));
 		return 1;
 	}
 		desc = "unknown";
 		break;
 	}
-	pr_warn(MPT3SAS_FMT "response_code(0x%01x): %s\n",
+	ioc_warn(ioc, "response_code(0x%01x): %s\n", response_code, desc);
-		ioc->name, response_code, desc);
 }
 /**
 	lockdep_assert_held(&ioc->tm_cmds.mutex);
 	if (ioc->tm_cmds.status != MPT3_CMD_NOT_USED) {
-		pr_info(MPT3SAS_FMT "%s: tm_cmd busy!!!\n",
+		ioc_info(ioc, "%s: tm_cmd busy!!!\n", __func__);
-		    __func__, ioc->name);
 		return FAILED;
 	}
 	if (ioc->shost_recovery || ioc->remove_host ||
 	    ioc->pci_error_recovery) {
-		pr_info(MPT3SAS_FMT "%s: host reset in progress!\n",
+		ioc_info(ioc, "%s: host reset in progress!\n", __func__);
-		    __func__, ioc->name);
 		return FAILED;
 	}
 	ioc_state = mpt3sas_base_get_iocstate(ioc, 0);
 	if (ioc_state & MPI2_DOORBELL_USED) {
-		dhsprintk(ioc, pr_info(MPT3SAS_FMT
+		dhsprintk(ioc, ioc_info(ioc, "unexpected doorbell active!\n"));
-			"unexpected doorbell active!\n", ioc->name));
 		rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
 		return (!rc) ? SUCCESS : FAILED;
 	}
 	smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_cb_idx);
 	if (!smid) {
-		pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
+		ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
-		    ioc->name, __func__);
 		return FAILED;
 	}
-	dtmprintk(ioc, pr_info(MPT3SAS_FMT
+	dtmprintk(ioc,
-		"sending tm: handle(0x%04x), task_type(0x%02x), smid(%d), timeout(%d), tr_method(0x%x)\n",
+		  ioc_info(ioc, "sending tm: handle(0x%04x), task_type(0x%02x), smid(%d), timeout(%d), tr_method(0x%x)\n",
-		ioc->name, handle, type, smid_task, timeout, tr_method));
+			   handle, type, smid_task, timeout, tr_method));
 	ioc->tm_cmds.status = MPT3_CMD_PENDING;
 	mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
 	ioc->tm_cmds.smid = smid;
 	if (ioc->tm_cmds.status & MPT3_CMD_REPLY_VALID) {
 		mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
 		mpi_reply = ioc->tm_cmds.reply;
-		dtmprintk(ioc, pr_info(MPT3SAS_FMT "complete tm: " \
+		dtmprintk(ioc,
-		    "ioc_status(0x%04x), loginfo(0x%08x), term_count(0x%08x)\n",
+			  ioc_info(ioc, "complete tm: ioc_status(0x%04x), loginfo(0x%08x), term_count(0x%08x)\n",
-		    ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
+				   le16_to_cpu(mpi_reply->IOCStatus),
-		    le32_to_cpu(mpi_reply->IOCLogInfo),
+				   le32_to_cpu(mpi_reply->IOCLogInfo),
-		    le32_to_cpu(mpi_reply->TerminationCount)));
+				   le32_to_cpu(mpi_reply->TerminationCount)));
 		if (ioc->logging_level & MPT_DEBUG_TM) {
 			_scsih_response_code(ioc, mpi_reply->ResponseCode);
 			if (mpi_reply->IOCStatus)
 	struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
 	int r, retval;
-	pr_info(MPT3SAS_FMT "attempting host reset! scmd(%p)\n",
+	ioc_info(ioc, "attempting host reset! scmd(%p)\n", scmd);
-	    ioc->name, scmd);
 	scsi_print_command(scmd);
 	if (ioc->is_driver_loading || ioc->remove_host) {
-		pr_info(MPT3SAS_FMT "Blocking the host reset\n",
+		ioc_info(ioc, "Blocking the host reset\n");
-		    ioc->name);
 		r = FAILED;
 		goto out;
 	}
 	retval = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
 	r = (retval < 0) ? FAILED : SUCCESS;
 out:
-	pr_info(MPT3SAS_FMT "host reset: %s scmd(%p)\n",
+	ioc_info(ioc, "host reset: %s scmd(%p)\n",
-	    ioc->name, ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
+		 r == SUCCESS ? "SUCCESS" : "FAILED", scmd);
 	return r;
 }
 	u8 tr_method = 0;
 	if (ioc->pci_error_recovery) {
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-			"%s: host in pci error recovery: handle(0x%04x)\n",
+			   ioc_info(ioc, "%s: host in pci error recovery: handle(0x%04x)\n",
-			__func__, ioc->name,
+				    __func__, handle));
-		    handle));
 		return;
 	}
 	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
 	if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-			"%s: host is not operational: handle(0x%04x)\n",
+			   ioc_info(ioc, "%s: host is not operational: handle(0x%04x)\n",
-			__func__, ioc->name,
+				    __func__, handle));
-		   handle));
 		return;
 	}
 			tr_method = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET;
 	}
 	if (sas_target_priv_data) {
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-			"setting delete flag: handle(0x%04x), sas_addr(0x%016llx)\n",
+			   ioc_info(ioc, "setting delete flag: handle(0x%04x), sas_addr(0x%016llx)\n",
-			ioc->name, handle,
+				    handle, (u64)sas_address));
-		    (unsigned long long)sas_address));
 		if (sas_device) {
 			if (sas_device->enclosure_handle != 0)
-				dewtprintk(ioc, pr_info(MPT3SAS_FMT
+				dewtprintk(ioc,
-				    "setting delete flag:enclosure logical "
+					   ioc_info(ioc, "setting delete flag:enclosure logical id(0x%016llx), slot(%d)\n",
-				    "id(0x%016llx), slot(%d)\n", ioc->name,
+						    (u64)sas_device->enclosure_logical_id,
-				    (unsigned long long)
+						    sas_device->slot));
-				    sas_device->enclosure_logical_id,
-				    sas_device->slot));
 			if (sas_device->connector_name[0] != '\0')
-				dewtprintk(ioc, pr_info(MPT3SAS_FMT
+				dewtprintk(ioc,
-				    "setting delete flag: enclosure "
+					   ioc_info(ioc, "setting delete flag: enclosure level(0x%04x), connector name( %s)\n",
-				    "level(0x%04x), connector name( %s)\n",
+						    sas_device->enclosure_level,
-				    ioc->name, sas_device->enclosure_level,
+						    sas_device->connector_name));
-				    sas_device->connector_name));
 		} else if (pcie_device) {
 			if (pcie_device->enclosure_handle != 0)
-				dewtprintk(ioc, pr_info(MPT3SAS_FMT
+				dewtprintk(ioc,
-				    "setting delete flag: logical "
+					   ioc_info(ioc, "setting delete flag: logical id(0x%016llx), slot(%d)\n",
-				    "id(0x%016llx), slot(%d)\n", ioc->name,
+						    (u64)pcie_device->enclosure_logical_id,
-				    (unsigned long long)
+						    pcie_device->slot));
-				    pcie_device->enclosure_logical_id,
-				    pcie_device->slot));
 			if (pcie_device->connector_name[0] != '\0')
-				dewtprintk(ioc, pr_info(MPT3SAS_FMT
+				dewtprintk(ioc,
-				    "setting delete flag:, enclosure "
+					   ioc_info(ioc, "setting delete flag:, enclosure level(0x%04x), connector name( %s)\n",
-				    "level(0x%04x), "
+						    pcie_device->enclosure_level,
-				    "connector name( %s)\n", ioc->name,
+						    pcie_device->connector_name));
-				    pcie_device->enclosure_level,
-				    pcie_device->connector_name));
 		}
 		_scsih_ublock_io_device(ioc, sas_address);
 		sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE;
 		INIT_LIST_HEAD(&delayed_tr->list);
 		delayed_tr->handle = handle;
 		list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-		    "DELAYED:tr:handle(0x%04x), (open)\n",
+			   ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n",
-		    ioc->name, handle));
+				    handle));
 		goto out;
 	}
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT
+	dewtprintk(ioc,
-		"tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
+		   ioc_info(ioc, "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
-		ioc->name, handle, smid,
+			    handle, smid, ioc->tm_tr_cb_idx));
-	    ioc->tm_tr_cb_idx));
 	mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
 	memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
 	mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
 	struct _sc_list *delayed_sc;
 	if (ioc->pci_error_recovery) {
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-			"%s: host in pci error recovery\n", __func__,
+			   ioc_info(ioc, "%s: host in pci error recovery\n",
-			ioc->name));
+				    __func__));
 		return 1;
 	}
 	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
 	if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-			"%s: host is not operational\n", __func__, ioc->name));
+			   ioc_info(ioc, "%s: host is not operational\n",
+				    __func__));
 		return 1;
 	}
 	if (unlikely(!mpi_reply)) {
-		pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",
+		ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return 1;
 	}
 	mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid);
 	handle = le16_to_cpu(mpi_request_tm->DevHandle);
 	if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
-		dewtprintk(ioc, pr_err(MPT3SAS_FMT
+		dewtprintk(ioc,
-			"spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
+			   ioc_err(ioc, "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
-			ioc->name, handle,
+				   handle,
-		    le16_to_cpu(mpi_reply->DevHandle), smid));
+				   le16_to_cpu(mpi_reply->DevHandle), smid));
 		return 0;
 	}
 	mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT);
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT
+	dewtprintk(ioc,
-	    "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), "
+		   ioc_info(ioc, "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x), completed(%d)\n",
-	    "loginfo(0x%08x), completed(%d)\n", ioc->name,
+			    handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
-	    handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
+			    le32_to_cpu(mpi_reply->IOCLogInfo),
-	    le32_to_cpu(mpi_reply->IOCLogInfo),
+			    le32_to_cpu(mpi_reply->TerminationCount)));
-	    le32_to_cpu(mpi_reply->TerminationCount)));
 	smid_sas_ctrl = mpt3sas_base_get_smid(ioc, ioc->tm_sas_control_cb_idx);
 	if (!smid_sas_ctrl) {
 		INIT_LIST_HEAD(&delayed_sc->list);
 		delayed_sc->handle = le16_to_cpu(mpi_request_tm->DevHandle);
 		list_add_tail(&delayed_sc->list, &ioc->delayed_sc_list);
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-		    "DELAYED:sc:handle(0x%04x), (open)\n",
+			   ioc_info(ioc, "DELAYED:sc:handle(0x%04x), (open)\n",
-		    ioc->name, handle));
+				    handle));
 		return _scsih_check_for_pending_tm(ioc, smid);
 	}
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT
+	dewtprintk(ioc,
-		"sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
+		   ioc_info(ioc, "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
-		ioc->name, handle, smid_sas_ctrl,
+			    handle, smid_sas_ctrl, ioc->tm_sas_control_cb_idx));
-	    ioc->tm_sas_control_cb_idx));
 	mpi_request = mpt3sas_base_get_msg_frame(ioc, smid_sas_ctrl);
 	memset(mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t));
 	mpi_request->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
 	    mpt3sas_base_get_reply_virt_addr(ioc, reply);
 	if (likely(mpi_reply)) {
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-		"sc_complete:handle(0x%04x), (open) "
+			   ioc_info(ioc, "sc_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
-		"smid(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
+				    le16_to_cpu(mpi_reply->DevHandle), smid,
-		ioc->name, le16_to_cpu(mpi_reply->DevHandle), smid,
+				    le16_to_cpu(mpi_reply->IOCStatus),
-		le16_to_cpu(mpi_reply->IOCStatus),
+				    le32_to_cpu(mpi_reply->IOCLogInfo)));
-		le32_to_cpu(mpi_reply->IOCLogInfo)));
 		if (le16_to_cpu(mpi_reply->IOCStatus) ==
 		     MPI2_IOCSTATUS_SUCCESS) {
 			clear_bit(le16_to_cpu(mpi_reply->DevHandle),
 			    ioc->device_remove_in_progress);
 		}
 	} else {
-		pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",
+		ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 	}
 	return mpt3sas_check_for_pending_internal_cmds(ioc, smid);
 }
 	struct _tr_list *delayed_tr;
 	if (ioc->pci_error_recovery) {
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-			"%s: host reset in progress!\n",
+			   ioc_info(ioc, "%s: host reset in progress!\n",
-			__func__, ioc->name));
+				    __func__));
 		return;
 	}
 		INIT_LIST_HEAD(&delayed_tr->list);
 		delayed_tr->handle = handle;
 		list_add_tail(&delayed_tr->list, &ioc->delayed_tr_volume_list);
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-		    "DELAYED:tr:handle(0x%04x), (open)\n",
+			   ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n",
-		    ioc->name, handle));
+				    handle));
 		return;
 	}
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT
+	dewtprintk(ioc,
-		"tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
+		   ioc_info(ioc, "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
-		ioc->name, handle, smid,
+			    handle, smid, ioc->tm_tr_volume_cb_idx));
-	    ioc->tm_tr_volume_cb_idx));
 	mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
 	memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t));
 	mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
 	    mpt3sas_base_get_reply_virt_addr(ioc, reply);
 	if (ioc->shost_recovery || ioc->pci_error_recovery) {
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-			"%s: host reset in progress!\n",
+			   ioc_info(ioc, "%s: host reset in progress!\n",
-			__func__, ioc->name));
+				    __func__));
 		return 1;
 	}
 	if (unlikely(!mpi_reply)) {
-		pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",
+		ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return 1;
 	}
 	mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid);
 	handle = le16_to_cpu(mpi_request_tm->DevHandle);
 	if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
-		dewtprintk(ioc, pr_err(MPT3SAS_FMT
+		dewtprintk(ioc,
-			"spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
+			   ioc_err(ioc, "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n",
-			ioc->name, handle,
+				   handle, le16_to_cpu(mpi_reply->DevHandle),
-		    le16_to_cpu(mpi_reply->DevHandle), smid));
+				   smid));
 		return 0;
 	}
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT
+	dewtprintk(ioc,
-	    "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), "
+		   ioc_info(ioc, "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x), completed(%d)\n",
-	    "loginfo(0x%08x), completed(%d)\n", ioc->name,
+			    handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
-	    handle, smid, le16_to_cpu(mpi_reply->IOCStatus),
+			    le32_to_cpu(mpi_reply->IOCLogInfo),
-	    le32_to_cpu(mpi_reply->IOCLogInfo),
+			    le32_to_cpu(mpi_reply->TerminationCount)));
-	    le32_to_cpu(mpi_reply->TerminationCount)));
 	return _scsih_check_for_pending_tm(ioc, smid);
 }
 	ioc->internal_lookup[i].cb_idx = ioc->base_cb_idx;
 	spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT
+	dewtprintk(ioc,
-		"EVENT ACK: event(0x%04x), smid(%d), cb(%d)\n",
+		   ioc_info(ioc, "EVENT ACK: event(0x%04x), smid(%d), cb(%d)\n",
-		ioc->name, le16_to_cpu(event), smid,
+			    le16_to_cpu(event), smid, ioc->base_cb_idx));
-		ioc->base_cb_idx));
 	ack_request = mpt3sas_base_get_msg_frame(ioc, smid);
 	memset(ack_request, 0, sizeof(Mpi2EventAckRequest_t));
 	ack_request->Function = MPI2_FUNCTION_EVENT_ACK;
 	unsigned long flags;
 	if (ioc->remove_host) {
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-			    "%s: host has been removed\n",
+			   ioc_info(ioc, "%s: host has been removed\n",
-			     __func__, ioc->name));
+				    __func__));
 		return;
 	} else if (ioc->pci_error_recovery) {
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-			    "%s: host in pci error recovery\n",
+			   ioc_info(ioc, "%s: host in pci error recovery\n",
-			    __func__, ioc->name));
+				    __func__));
 		return;
 	}
 	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
 	if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-		    "%s: host is not operational\n",
+			   ioc_info(ioc, "%s: host is not operational\n",
-		    __func__, ioc->name));
+				    __func__));
 		return;
 	}
 	ioc->internal_lookup[i].cb_idx = ioc->tm_sas_control_cb_idx;
 	spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT
+	dewtprintk(ioc,
-	    "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
+		   ioc_info(ioc, "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n",
-	    ioc->name, handle, smid,
+			    handle, smid, ioc->tm_sas_control_cb_idx));
-	    ioc->tm_sas_control_cb_idx));
 	mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
 	memset(mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t));
 	mpi_request->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
 		    MPI2_EVENT_SAS_TOPO_ES_RESPONDING) {
 			if (le16_to_cpu(local_event_data->ExpanderDevHandle) ==
 			    expander_handle) {
-				dewtprintk(ioc, pr_info(MPT3SAS_FMT
+				dewtprintk(ioc,
-				    "setting ignoring flag\n", ioc->name));
+					   ioc_info(ioc, "setting ignoring flag\n"));
 				fw_event->ignore = 1;
 			}
 		}
 		    MPI2_EVENT_SAS_TOPO_ES_RESPONDING) {
 			if (le16_to_cpu(local_event_data->SwitchDevHandle) ==
 				switch_handle) {
-				dewtprintk(ioc, pr_info(MPT3SAS_FMT
+				dewtprintk(ioc,
-					"setting ignoring flag for switch event\n",
+					   ioc_info(ioc, "setting ignoring flag for switch event\n"));
-					ioc->name));
 				fw_event->ignore = 1;
 			}
 		}
 		sas_target_priv_data =
 		    raid_device->starget->hostdata;
 		sas_target_priv_data->deleted = 1;
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-		    "setting delete flag: handle(0x%04x), "
+			   ioc_info(ioc, "setting delete flag: handle(0x%04x), wwid(0x%016llx)\n",
-		    "wwid(0x%016llx)\n", ioc->name, handle,
+				    handle, (u64)raid_device->wwid));
-		    (unsigned long long) raid_device->wwid));
 	}
 	spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
 }
 			INIT_LIST_HEAD(&delayed_tr->list);
 			delayed_tr->handle = handle;
 			list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list);
-			dewtprintk(ioc, pr_info(MPT3SAS_FMT
+			dewtprintk(ioc,
-			    "DELAYED:tr:handle(0x%04x), (open)\n", ioc->name,
+				   ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n",
-			    handle));
+					    handle));
 		} else
 			_scsih_tm_tr_send(ioc, handle);
 	}
 	Mpi2EventDataTemperature_t *event_data)
 {
 	if (ioc->temp_sensors_count >= event_data->SensorNum) {
-		pr_err(MPT3SAS_FMT "Temperature Threshold flags %s%s%s%s"
+		ioc_err(ioc, "Temperature Threshold flags %s%s%s%s exceeded for Sensor: %d !!!\n",
-		  " exceeded for Sensor: %d !!!\n", ioc->name,
+			le16_to_cpu(event_data->Status) & 0x1 ? "0 " : " ",
-		  ((le16_to_cpu(event_data->Status) & 0x1) == 1) ? "0 " : " ",
+			le16_to_cpu(event_data->Status) & 0x2 ? "1 " : " ",
-		  ((le16_to_cpu(event_data->Status) & 0x2) == 2) ? "1 " : " ",
+			le16_to_cpu(event_data->Status) & 0x4 ? "2 " : " ",
-		  ((le16_to_cpu(event_data->Status) & 0x4) == 4) ? "2 " : " ",
+			le16_to_cpu(event_data->Status) & 0x8 ? "3 " : " ",
-		  ((le16_to_cpu(event_data->Status) & 0x8) == 8) ? "3 " : " ",
+			event_data->SensorNum);
-		  event_data->SensorNum);
+		ioc_err(ioc, "Current Temp In Celsius: %d\n",
-		pr_err(MPT3SAS_FMT "Current Temp In Celsius: %d\n",
+			event_data->CurrentTemperature);
-			ioc->name, event_data->CurrentTemperature);
 	}
 }
 			scmd->result = DID_RESET << 16;
 		scmd->scsi_done(scmd);
 	}
-	dtmprintk(ioc, pr_info(MPT3SAS_FMT "completing %d cmds\n",
+	dtmprintk(ioc, ioc_info(ioc, "completing %d cmds\n", count));
-	    ioc->name, count));
 }
 /**
 	smid = mpt3sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd);
 	if (!smid) {
-		pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
+		ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
-		    ioc->name, __func__);
 		_scsih_set_satl_pending(scmd, false);
 		goto out;
 	}
 	scsi_print_command(scmd);
 	if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
-		pr_warn(MPT3SAS_FMT "\t%s wwid(0x%016llx)\n", ioc->name,
+		ioc_warn(ioc, "\t%s wwid(0x%016llx)\n",
-		    device_str, (unsigned long long)priv_target->sas_address);
+			 device_str, (u64)priv_target->sas_address);
 	} else if (priv_target->flags & MPT_TARGET_FLAGS_PCIE_DEVICE) {
 		pcie_device = mpt3sas_get_pdev_from_target(ioc, priv_target);
 		if (pcie_device) {
-			pr_info(MPT3SAS_FMT "\twwid(0x%016llx), port(%d)\n",
+			ioc_info(ioc, "\twwid(0x%016llx), port(%d)\n",
-			    ioc->name,
+				 (u64)pcie_device->wwid, pcie_device->port_num);
-			    (unsigned long long)pcie_device->wwid,
-			    pcie_device->port_num);
 			if (pcie_device->enclosure_handle != 0)
-				pr_info(MPT3SAS_FMT
+				ioc_info(ioc, "\tenclosure logical id(0x%016llx), slot(%d)\n",
-				    "\tenclosure logical id(0x%016llx), "
+					 (u64)pcie_device->enclosure_logical_id,
-				    "slot(%d)\n", ioc->name,
+					 pcie_device->slot);
-				    (unsigned long long)
-				    pcie_device->enclosure_logical_id,
-				    pcie_device->slot);
 			if (pcie_device->connector_name[0])
-				pr_info(MPT3SAS_FMT
+				ioc_info(ioc, "\tenclosure level(0x%04x), connector name( %s)\n",
-				    "\tenclosure level(0x%04x),"
+					 pcie_device->enclosure_level,
-				    "connector name( %s)\n",
+					 pcie_device->connector_name);
-				    ioc->name, pcie_device->enclosure_level,
-				    pcie_device->connector_name);
 			pcie_device_put(pcie_device);
 		}
 	} else {
 		sas_device = mpt3sas_get_sdev_from_target(ioc, priv_target);
 		if (sas_device) {
-			pr_warn(MPT3SAS_FMT
+			ioc_warn(ioc, "\tsas_address(0x%016llx), phy(%d)\n",
-				"\tsas_address(0x%016llx), phy(%d)\n",
+				 (u64)sas_device->sas_address, sas_device->phy);
-				ioc->name, (unsigned long long)
-			    sas_device->sas_address, sas_device->phy);
 			_scsih_display_enclosure_chassis_info(ioc, sas_device,
 			    NULL, NULL);
 		}
 	}
-	pr_warn(MPT3SAS_FMT
+	ioc_warn(ioc, "\thandle(0x%04x), ioc_status(%s)(0x%04x), smid(%d)\n",
-		"\thandle(0x%04x), ioc_status(%s)(0x%04x), smid(%d)\n",
+		 le16_to_cpu(mpi_reply->DevHandle),
-		ioc->name, le16_to_cpu(mpi_reply->DevHandle),
+		 desc_ioc_state, ioc_status, smid);
-	    desc_ioc_state, ioc_status, smid);
+	ioc_warn(ioc, "\trequest_len(%d), underflow(%d), resid(%d)\n",
-	pr_warn(MPT3SAS_FMT
+		 scsi_bufflen(scmd), scmd->underflow, scsi_get_resid(scmd));
-		"\trequest_len(%d), underflow(%d), resid(%d)\n",
+	ioc_warn(ioc, "\ttag(%d), transfer_count(%d), sc->result(0x%08x)\n",
-		ioc->name, scsi_bufflen(scmd), scmd->underflow,
+		 le16_to_cpu(mpi_reply->TaskTag),
-	    scsi_get_resid(scmd));
+		 le32_to_cpu(mpi_reply->TransferCount), scmd->result);
-	pr_warn(MPT3SAS_FMT
+	ioc_warn(ioc, "\tscsi_status(%s)(0x%02x), scsi_state(%s)(0x%02x)\n",
-		"\ttag(%d), transfer_count(%d), sc->result(0x%08x)\n",
+		 desc_scsi_status, scsi_status, desc_scsi_state, scsi_state);
-		ioc->name, le16_to_cpu(mpi_reply->TaskTag),
-	    le32_to_cpu(mpi_reply->TransferCount), scmd->result);
-	pr_warn(MPT3SAS_FMT
-		"\tscsi_status(%s)(0x%02x), scsi_state(%s)(0x%02x)\n",
-		ioc->name, desc_scsi_status,
-	    scsi_status, desc_scsi_state, scsi_state);
 	if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
 		struct sense_info data;
 		_scsih_normalize_sense(scmd->sense_buffer, &data);
-		pr_warn(MPT3SAS_FMT
+		ioc_warn(ioc, "\t[sense_key,asc,ascq]: [0x%02x,0x%02x,0x%02x], count(%d)\n",
-		  "\t[sense_key,asc,ascq]: [0x%02x,0x%02x,0x%02x], count(%d)\n",
+			 data.skey, data.asc, data.ascq,
-		  ioc->name, data.skey,
+			 le32_to_cpu(mpi_reply->SenseCount));
-		  data.asc, data.ascq, le32_to_cpu(mpi_reply->SenseCount));
 	}
 	if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) {
 		response_info = le32_to_cpu(mpi_reply->ResponseInfo);
 	mpi_request.Flags = MPI2_SEP_REQ_FLAGS_DEVHANDLE_ADDRESS;
 	if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
 	    &mpi_request)) != 0) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", ioc->name,
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		__FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		goto out;
 	}
 	sas_device->pfa_led_on = 1;
 	if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) {
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-			"enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
+			   ioc_info(ioc, "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
-			ioc->name, le16_to_cpu(mpi_reply.IOCStatus),
+				    le16_to_cpu(mpi_reply.IOCStatus),
-		    le32_to_cpu(mpi_reply.IOCLogInfo)));
+				    le32_to_cpu(mpi_reply.IOCLogInfo)));
 		goto out;
 	}
 out:
 	mpi_request.Flags = MPI2_SEP_REQ_FLAGS_ENCLOSURE_SLOT_ADDRESS;
 	if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
 		&mpi_request)) != 0) {
-		printk(MPT3SAS_FMT "failure at %s:%d/%s()!\n", ioc->name,
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		__FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return;
 	}
 	if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) {
-		dewtprintk(ioc, printk(MPT3SAS_FMT
+		dewtprintk(ioc,
-		 "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
+			   ioc_info(ioc, "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n",
-		 ioc->name, le16_to_cpu(mpi_reply.IOCStatus),
+				    le16_to_cpu(mpi_reply.IOCStatus),
-		 le32_to_cpu(mpi_reply.IOCLogInfo)));
+				    le32_to_cpu(mpi_reply.IOCLogInfo)));
 		return;
 	}
 }
 	     sizeof(Mpi2EventDataSasDeviceStatusChange_t);
 	event_reply = kzalloc(sz, GFP_KERNEL);
 	if (!event_reply) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		goto out;
 	}
 	u16 attached_handle;
 	u8 link_rate;
-	dtmprintk(ioc, pr_info(MPT3SAS_FMT
+	dtmprintk(ioc,
-	    "updating handles for sas_host(0x%016llx)\n",
+		  ioc_info(ioc, "updating handles for sas_host(0x%016llx)\n",
-	    ioc->name, (unsigned long long)ioc->sas_hba.sas_address));
+			   (u64)ioc->sas_hba.sas_address));
 	sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys
 	    * sizeof(Mpi2SasIOUnit0PhyData_t));
 	sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
 	if (!sas_iounit_pg0) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return;
 	}
 	mpt3sas_config_get_number_hba_phys(ioc, &num_phys);
 	if (!num_phys) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return;
 	}
 	ioc->sas_hba.phy = kcalloc(num_phys,
 	    sizeof(struct _sas_phy), GFP_KERNEL);
 	if (!ioc->sas_hba.phy) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		goto out;
 	}
 	ioc->sas_hba.num_phys = num_phys;
 	    sizeof(Mpi2SasIOUnit0PhyData_t));
 	sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
 	if (!sas_iounit_pg0) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return;
 	}
 	if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
 	    sas_iounit_pg0, sz))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		goto out;
 	}
 	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 	    MPI2_IOCSTATUS_MASK;
 	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		goto out;
 	}
 	    sizeof(Mpi2SasIOUnit1PhyData_t));
 	sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
 	if (!sas_iounit_pg1) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		goto out;
 	}
 	if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
 	    sas_iounit_pg1, sz))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		goto out;
 	}
 	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 	    MPI2_IOCSTATUS_MASK;
 	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		goto out;
 	}
 	for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
 		if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
 		    i))) {
-			pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+			ioc_err(ioc, "failure at %s:%d/%s()!\n",
-			    ioc->name, __FILE__, __LINE__, __func__);
+				__FILE__, __LINE__, __func__);
 			goto out;
 		}
 		ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 		    MPI2_IOCSTATUS_MASK;
 		if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-			pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+			ioc_err(ioc, "failure at %s:%d/%s()!\n",
-			    ioc->name, __FILE__, __LINE__, __func__);
+				__FILE__, __LINE__, __func__);
 			goto out;
 		}
 	}
 	if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
 	    MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		goto out;
 	}
 	ioc->sas_hba.enclosure_handle =
 	    le16_to_cpu(sas_device_pg0.EnclosureHandle);
 	ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
-	pr_info(MPT3SAS_FMT
+	ioc_info(ioc, "host_add: handle(0x%04x), sas_addr(0x%016llx), phys(%d)\n",
-		"host_add: handle(0x%04x), sas_addr(0x%016llx), phys(%d)\n",
+		 ioc->sas_hba.handle,
-		ioc->name, ioc->sas_hba.handle,
+		 (u64)ioc->sas_hba.sas_address,
-	    (unsigned long long) ioc->sas_hba.sas_address,
+		 ioc->sas_hba.num_phys);
-	    ioc->sas_hba.num_phys) ;
 	if (ioc->sas_hba.enclosure_handle) {
 		if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
 	if ((mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,
 	    MPI2_SAS_EXPAND_PGAD_FORM_HNDL, handle))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return -1;
 	}
 	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 	    MPI2_IOCSTATUS_MASK;
 	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return -1;
 	}
 	parent_handle = le16_to_cpu(expander_pg0.ParentDevHandle);
 	if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent)
 	    != 0) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return -1;
 	}
 	if (sas_address_parent != ioc->sas_hba.sas_address) {
 	sas_expander = kzalloc(sizeof(struct _sas_node),
 	    GFP_KERNEL);
 	if (!sas_expander) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return -1;
 	}
 	sas_expander->sas_address_parent = sas_address_parent;
 	sas_expander->sas_address = sas_address;
-	pr_info(MPT3SAS_FMT "expander_add: handle(0x%04x)," \
+	ioc_info(ioc, "expander_add: handle(0x%04x), parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n",
-	    " parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n", ioc->name,
+		 handle, parent_handle,
-	    handle, parent_handle, (unsigned long long)
+		 (u64)sas_expander->sas_address, sas_expander->num_phys);
-	    sas_expander->sas_address, sas_expander->num_phys);
 	if (!sas_expander->num_phys)
 		goto out_fail;
 	sas_expander->phy = kcalloc(sas_expander->num_phys,
 	    sizeof(struct _sas_phy), GFP_KERNEL);
 	if (!sas_expander->phy) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		rc = -1;
 		goto out_fail;
 	}
 	mpt3sas_port = mpt3sas_transport_port_add(ioc, handle,
 	    sas_address_parent);
 	if (!mpt3sas_port) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		rc = -1;
 		goto out_fail;
 	}
 	for (i = 0 ; i < sas_expander->num_phys ; i++) {
 		if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
 		    &expander_pg1, i, handle))) {
-			pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+			ioc_err(ioc, "failure at %s:%d/%s()!\n",
-			    ioc->name, __FILE__, __LINE__, __func__);
+				__FILE__, __LINE__, __func__);
 			rc = -1;
 			goto out_fail;
 		}
 		if ((mpt3sas_transport_add_expander_phy(ioc,
 		    &sas_expander->phy[i], expander_pg1,
 		    sas_expander->parent_dev))) {
-			pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+			ioc_err(ioc, "failure at %s:%d/%s()!\n",
-			    ioc->name, __FILE__, __LINE__, __func__);
+				__FILE__, __LINE__, __func__);
 			rc = -1;
 			goto out_fail;
 		}
 	if (!rc)
 		return 0;
-	pr_err(MPT3SAS_FMT
+	ioc_err(ioc, "discovery errors(%s): sas_address(0x%016llx), handle(0x%04x)\n",
-		"discovery errors(%s): sas_address(0x%016llx), handle(0x%04x)\n",
+		desc, (u64)sas_address, handle);
-		ioc->name, desc, (unsigned long long)sas_address, handle);
 	return rc;
 }
 	/* check if device is present */
 	if (!(le16_to_cpu(sas_device_pg0.Flags) &
 	    MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "device is not present handle(0x%04x), flags!!!\n",
-			"device is not present handle(0x%04x), flags!!!\n",
+			handle);
-			ioc->name, handle);
 		goto out_unlock;
 	}
 	if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
 	    MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return -1;
 	}
 	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 	    MPI2_IOCSTATUS_MASK;
 	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return -1;
 	}
 	/* check if device is present */
 	if (!(le16_to_cpu(sas_device_pg0.Flags) &
 	    MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
-		pr_err(MPT3SAS_FMT "device is not present handle(0x04%x)!!!\n",
+		ioc_err(ioc, "device is not present handle(0x04%x)!!!\n",
-			ioc->name, handle);
+			handle);
 		return -1;
 	}
 			mpt3sas_scsih_enclosure_find_by_handle(ioc,
 			    le16_to_cpu(sas_device_pg0.EnclosureHandle));
 		if (enclosure_dev == NULL)
-			pr_info(MPT3SAS_FMT "Enclosure handle(0x%04x)"
+			ioc_info(ioc, "Enclosure handle(0x%04x) doesn't match with enclosure device!\n",
-			    "doesn't match with enclosure device!\n",
+				 sas_device_pg0.EnclosureHandle);
-			    ioc->name, sas_device_pg0.EnclosureHandle);
 	}
 	sas_device = kzalloc(sizeof(struct _sas_device),
 	    GFP_KERNEL);
 	if (!sas_device) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return 0;
 	}
 	if (_scsih_get_sas_address(ioc,
 	    le16_to_cpu(sas_device_pg0.ParentDevHandle),
 	    &sas_device->sas_address_parent) != 0)
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 	sas_device->enclosure_handle =
 	    le16_to_cpu(sas_device_pg0.EnclosureHandle);
 	if (sas_device->enclosure_handle != 0)
 		sas_device->pfa_led_on = 0;
 	}
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT
+	dewtprintk(ioc,
-		"%s: enter: handle(0x%04x), sas_addr(0x%016llx)\n",
+		   ioc_info(ioc, "%s: enter: handle(0x%04x), sas_addr(0x%016llx)\n",
-		ioc->name, __func__,
+			    __func__,
-	    sas_device->handle, (unsigned long long)
+			    sas_device->handle, (u64)sas_device->sas_address));
-	    sas_device->sas_address));
 	dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
 	    NULL, NULL));
 		    sas_device->sas_address,
 		    sas_device->sas_address_parent);
-	pr_info(MPT3SAS_FMT
+	ioc_info(ioc, "removing handle(0x%04x), sas_addr(0x%016llx)\n",
-		"removing handle(0x%04x), sas_addr(0x%016llx)\n",
+		 sas_device->handle, (u64)sas_device->sas_address);
-		ioc->name, sas_device->handle,
-	    (unsigned long long) sas_device->sas_address);
 	_scsih_display_enclosure_chassis_info(ioc, sas_device, NULL, NULL);
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT
+	dewtprintk(ioc,
-		"%s: exit: handle(0x%04x), sas_addr(0x%016llx)\n",
+		   ioc_info(ioc, "%s: exit: handle(0x%04x), sas_addr(0x%016llx)\n",
-		ioc->name, __func__,
+			    __func__,
-		sas_device->handle, (unsigned long long)
+			    sas_device->handle, (u64)sas_device->sas_address));
-		sas_device->sas_address));
 	dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device,
 	    NULL, NULL));
 }
 		status_str = "unknown status";
 		break;
 	}
-	pr_info(MPT3SAS_FMT "sas topology change: (%s)\n",
+	ioc_info(ioc, "sas topology change: (%s)\n", status_str);
-	    ioc->name, status_str);
 	pr_info("\thandle(0x%04x), enclosure_handle(0x%04x) " \
 	    "start_phy(%02d), count(%d)\n",
 	    le16_to_cpu(event_data->ExpanderDevHandle),
 		_scsih_sas_host_refresh(ioc);
 	if (fw_event->ignore) {
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc, ioc_info(ioc, "ignoring expander event\n"));
-			"ignoring expander event\n", ioc->name));
 		return 0;
 	}
 	/* handle siblings events */
 	for (i = 0; i < event_data->NumEntries; i++) {
 		if (fw_event->ignore) {
-			dewtprintk(ioc, pr_info(MPT3SAS_FMT
+			dewtprintk(ioc,
-				"ignoring expander event\n", ioc->name));
+				   ioc_info(ioc, "ignoring expander event\n"));
 			return 0;
 		}
 		if (ioc->remove_host || ioc->pci_error_recovery)
 		reason_str = "unknown reason";
 		break;
 	}
-	pr_info(MPT3SAS_FMT "device status change: (%s)\n"
+	ioc_info(ioc, "device status change: (%s)\thandle(0x%04x), sas address(0x%016llx), tag(%d)",
-	    "\thandle(0x%04x), sas address(0x%016llx), tag(%d)",
+		 reason_str, le16_to_cpu(event_data->DevHandle),
-	    ioc->name, reason_str, le16_to_cpu(event_data->DevHandle),
+		 (u64)le64_to_cpu(event_data->SASAddress),
-	    (unsigned long long)le64_to_cpu(event_data->SASAddress),
+		 le16_to_cpu(event_data->TaskTag));
-	    le16_to_cpu(event_data->TaskTag));
 	if (event_data->ReasonCode == MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA)
-		pr_info(MPT3SAS_FMT ", ASC(0x%x), ASCQ(0x%x)\n", ioc->name,
+		pr_cont(", ASC(0x%x), ASCQ(0x%x)\n",
-		    event_data->ASC, event_data->ASCQ);
+			event_data->ASC, event_data->ASCQ);
-	pr_info("\n");
+	pr_cont("\n");
 }
 /**
 		desc = "nvme failure status";
 		break;
 	default:
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "NVMe discovery error(0x%02x): wwid(0x%016llx), handle(0x%04x)\n",
-		    " NVMe discovery error(0x%02x): wwid(0x%016llx),"
+			access_status, (u64)wwid, handle);
-			"handle(0x%04x)\n", ioc->name, access_status,
-			(unsigned long long)wwid, handle);
 		return rc;
 	}
 	if (!rc)
 		return rc;
-	pr_info(MPT3SAS_FMT
+	ioc_info(ioc, "NVMe discovery error(%s): wwid(0x%016llx), handle(0x%04x)\n",
-		"NVMe discovery error(%s): wwid(0x%016llx), handle(0x%04x)\n",
+		 desc, (u64)wwid, handle);
-			ioc->name, desc,
-			(unsigned long long)wwid, handle);
 	return rc;
 }
 {
 	struct MPT3SAS_TARGET *sas_target_priv_data;
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT
+	dewtprintk(ioc,
-	    "%s: enter: handle(0x%04x), wwid(0x%016llx)\n", ioc->name, __func__,
+		   ioc_info(ioc, "%s: enter: handle(0x%04x), wwid(0x%016llx)\n",
-	    pcie_device->handle, (unsigned long long)
+			    __func__,
-	    pcie_device->wwid));
+			    pcie_device->handle, (u64)pcie_device->wwid));
 	if (pcie_device->enclosure_handle != 0)
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-		    "%s: enter: enclosure logical id(0x%016llx), slot(%d)\n",
+			   ioc_info(ioc, "%s: enter: enclosure logical id(0x%016llx), slot(%d)\n",
-		    ioc->name, __func__,
+				    __func__,
-		    (unsigned long long)pcie_device->enclosure_logical_id,
+				    (u64)pcie_device->enclosure_logical_id,
-		    pcie_device->slot));
+				    pcie_device->slot));
 	if (pcie_device->connector_name[0] != '\0')
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-		    "%s: enter: enclosure level(0x%04x), connector name( %s)\n",
+			   ioc_info(ioc, "%s: enter: enclosure level(0x%04x), connector name(%s)\n",
-		    ioc->name, __func__,
+				    __func__,
-		    pcie_device->enclosure_level,
+				    pcie_device->enclosure_level,
-		    pcie_device->connector_name));
+				    pcie_device->connector_name));
 	if (pcie_device->starget && pcie_device->starget->hostdata) {
 		sas_target_priv_data = pcie_device->starget->hostdata;
 		sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE;
 	}
-	pr_info(MPT3SAS_FMT
+	ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
-		"removing handle(0x%04x), wwid (0x%016llx)\n",
+		 pcie_device->handle, (u64)pcie_device->wwid);
-		ioc->name, pcie_device->handle,
-		(unsigned long long) pcie_device->wwid);
 	if (pcie_device->enclosure_handle != 0)
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "removing : enclosure logical id(0x%016llx), slot(%d)\n",
-		    "removing : enclosure logical id(0x%016llx), slot(%d)\n",
+			 (u64)pcie_device->enclosure_logical_id,
-		    ioc->name,
+			 pcie_device->slot);
-		    (unsigned long long)pcie_device->enclosure_logical_id,
-		    pcie_device->slot);
 	if (pcie_device->connector_name[0] != '\0')
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "removing: enclosure level(0x%04x), connector name( %s)\n",
-		    "removing: enclosure level(0x%04x), connector name( %s)\n",
+			 pcie_device->enclosure_level,
-		    ioc->name, pcie_device->enclosure_level,
+			 pcie_device->connector_name);
-		    pcie_device->connector_name);
 	if (pcie_device->starget)
 		scsi_remove_target(&pcie_device->starget->dev);
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT
+	dewtprintk(ioc,
-	    "%s: exit: handle(0x%04x), wwid(0x%016llx)\n", ioc->name, __func__,
+		   ioc_info(ioc, "%s: exit: handle(0x%04x), wwid(0x%016llx)\n",
-	    pcie_device->handle, (unsigned long long)
+			    __func__,
-	    pcie_device->wwid));
+			    pcie_device->handle, (u64)pcie_device->wwid));
 	if (pcie_device->enclosure_handle != 0)
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-			"%s: exit: enclosure logical id(0x%016llx), slot(%d)\n",
+			   ioc_info(ioc, "%s: exit: enclosure logical id(0x%016llx), slot(%d)\n",
-			ioc->name, __func__,
+				    __func__,
-			(unsigned long long)pcie_device->enclosure_logical_id,
+				    (u64)pcie_device->enclosure_logical_id,
-			pcie_device->slot));
+				    pcie_device->slot));
 	if (pcie_device->connector_name[0] != '\0')
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-		    "%s: exit: enclosure level(0x%04x), connector name( %s)\n",
+			   ioc_info(ioc, "%s: exit: enclosure level(0x%04x), connector name( %s)\n",
-		    ioc->name, __func__, pcie_device->enclosure_level,
+				    __func__,
-		    pcie_device->connector_name));
+				    pcie_device->enclosure_level,
+				    pcie_device->connector_name));
 	kfree(pcie_device->serial_number);
 }
 	/* check if device is present */
 	if (!(le32_to_cpu(pcie_device_pg0.Flags) &
 	    MPI26_PCIEDEV0_FLAGS_DEVICE_PRESENT)) {
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "device is not present handle(0x%04x), flags!!!\n",
-		    "device is not present handle(0x%04x), flags!!!\n",
+			 handle);
-		    ioc->name, handle);
 		spin_unlock_irqrestore(&ioc->pcie_device_lock, flags);
 		pcie_device_put(pcie_device);
 		return;
 	if ((mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply,
 	    &pcie_device_pg0, MPI26_PCIE_DEVICE_PGAD_FORM_HANDLE, handle))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return 0;
 	}
 	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 	    MPI2_IOCSTATUS_MASK;
 	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    "failure at %s:%d/%s()!\n",
+			__FILE__, __LINE__, __func__);
-		    ioc->name, __FILE__, __LINE__, __func__);
 		return 0;
 	}
 	/* check if device is present */
 	if (!(le32_to_cpu(pcie_device_pg0.Flags) &
 		MPI26_PCIEDEV0_FLAGS_DEVICE_PRESENT)) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "device is not present handle(0x04%x)!!!\n",
-		    "device is not present handle(0x04%x)!!!\n",
+			handle);
-		    ioc->name, handle);
 		return 0;
 	}
 	pcie_device = kzalloc(sizeof(struct _pcie_device), GFP_KERNEL);
 	if (!pcie_device) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-			ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return 0;
 	}
 	/* TODO -- Add device name once FW supports it */
 	if (mpt3sas_config_get_pcie_device_pg2(ioc, &mpi_reply,
 		&pcie_device_pg2, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle)) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-				ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		kfree(pcie_device);
 		return 0;
 	}
 	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
 	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-			ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		kfree(pcie_device);
 		return 0;
 	}
 		status_str = "unknown status";
 		break;
 	}
-	pr_info(MPT3SAS_FMT "pcie topology change: (%s)\n",
+	ioc_info(ioc, "pcie topology change: (%s)\n", status_str);
-		ioc->name, status_str);
 	pr_info("\tswitch_handle(0x%04x), enclosure_handle(0x%04x)"
 		"start_port(%02d), count(%d)\n",
 		le16_to_cpu(event_data->SwitchDevHandle),
 		return;
 	if (fw_event->ignore) {
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT "ignoring switch event\n",
+		dewtprintk(ioc, ioc_info(ioc, "ignoring switch event\n"));
-			ioc->name));
 		return;
 	}
 	/* handle siblings events */
 	for (i = 0; i < event_data->NumEntries; i++) {
 		if (fw_event->ignore) {
-			dewtprintk(ioc, pr_info(MPT3SAS_FMT
+			dewtprintk(ioc,
-				"ignoring switch event\n", ioc->name));
+				   ioc_info(ioc, "ignoring switch event\n"));
 			return;
 		}
 		if (ioc->remove_host || ioc->pci_error_recovery)
 			if (!test_bit(handle, ioc->pend_os_device_add))
 				break;
-			dewtprintk(ioc, pr_info(MPT3SAS_FMT
+			dewtprintk(ioc,
-				"handle(0x%04x) device not found: convert "
+				   ioc_info(ioc, "handle(0x%04x) device not found: convert event to a device add\n",
-				"event to a device add\n", ioc->name, handle));
+					    handle));
 			event_data->PortEntry[i].PortStatus &= 0xF0;
 			event_data->PortEntry[i].PortStatus |=
 				MPI26_EVENT_PCIE_TOPO_PS_DEV_ADDED;
 		break;
 	}
-	pr_info(MPT3SAS_FMT "PCIE device status change: (%s)\n"
+	ioc_info(ioc, "PCIE device status change: (%s)\n"
-		"\thandle(0x%04x), WWID(0x%016llx), tag(%d)",
+		 "\thandle(0x%04x), WWID(0x%016llx), tag(%d)",
-		ioc->name, reason_str, le16_to_cpu(event_data->DevHandle),
+		 reason_str, le16_to_cpu(event_data->DevHandle),
-		(unsigned long long)le64_to_cpu(event_data->WWID),
+		 (u64)le64_to_cpu(event_data->WWID),
-		le16_to_cpu(event_data->TaskTag));
+		 le16_to_cpu(event_data->TaskTag));
 	if (event_data->ReasonCode == MPI26_EVENT_PCIDEV_STAT_RC_SMART_DATA)
-		pr_info(MPT3SAS_FMT ", ASC(0x%x), ASCQ(0x%x)\n", ioc->name,
+		pr_cont(", ASC(0x%x), ASCQ(0x%x)\n",
 			event_data->ASC, event_data->ASCQ);
-	pr_info("\n");
+	pr_cont("\n");
 }
 /**
 		break;
 	}
-	pr_info(MPT3SAS_FMT "enclosure status change: (%s)\n"
+	ioc_info(ioc, "enclosure status change: (%s)\n"
-	    "\thandle(0x%04x), enclosure logical id(0x%016llx)"
+		 "\thandle(0x%04x), enclosure logical id(0x%016llx) number slots(%d)\n",
-	    " number slots(%d)\n", ioc->name, reason_str,
+		 reason_str,
-	    le16_to_cpu(event_data->EnclosureHandle),
+		 le16_to_cpu(event_data->EnclosureHandle),
-	    (unsigned long long)le64_to_cpu(event_data->EnclosureLogicalID),
+		 (u64)le64_to_cpu(event_data->EnclosureLogicalID),
-	    le16_to_cpu(event_data->StartSlot));
+		 le16_to_cpu(event_data->StartSlot));
 }
 /**
 				kzalloc(sizeof(struct _enclosure_node),
 					GFP_KERNEL);
 			if (!enclosure_dev) {
-				pr_info(MPT3SAS_FMT
+				ioc_info(ioc, "failure at %s:%d/%s()!\n",
-					"failure at %s:%d/%s()!\n", ioc->name,
+					 __FILE__, __LINE__, __func__);
-					__FILE__, __LINE__, __func__);
 				return;
 			}
 			rc = mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply,
 	u8 task_abort_retries;
 	mutex_lock(&ioc->tm_cmds.mutex);
-	pr_info(MPT3SAS_FMT
+	ioc_info(ioc, "%s: enter: phy number(%d), width(%d)\n",
-		"%s: enter: phy number(%d), width(%d)\n",
+		 __func__, event_data->PhyNum, event_data->PortWidth);
-		ioc->name, __func__, event_data->PhyNum,
-	     event_data->PortWidth);
 	_scsih_block_io_all_device(ioc);
 	/* sanity checks for retrying this loop */
 	if (max_retries++ == 5) {
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT "%s: giving up\n",
+		dewtprintk(ioc, ioc_info(ioc, "%s: giving up\n", __func__));
-		    ioc->name, __func__));
 		goto out;
 	} else if (max_retries > 1)
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT "%s: %d retry\n",
+		dewtprintk(ioc,
-		    ioc->name, __func__, max_retries - 1));
+			   ioc_info(ioc, "%s: %d retry\n",
+				    __func__, max_retries - 1));
 	termination_count = 0;
 	query_count = 0;
 		task_abort_retries = 0;
  tm_retry:
 		if (task_abort_retries++ == 60) {
-			dewtprintk(ioc, pr_info(MPT3SAS_FMT
+			dewtprintk(ioc,
-			    "%s: ABORT_TASK: giving up\n", ioc->name,
+				   ioc_info(ioc, "%s: ABORT_TASK: giving up\n",
-			    __func__));
+					    __func__));
 			spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
 			goto broadcast_aen_retry;
 		}
 	}
 	if (ioc->broadcast_aen_pending) {
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-			"%s: loop back due to pending AEN\n",
+			   ioc_info(ioc,
-			ioc->name, __func__));
+				    "%s: loop back due to pending AEN\n",
+				    __func__));
 		 ioc->broadcast_aen_pending = 0;
 		 goto broadcast_aen_retry;
 	}
 	spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
  out_no_lock:
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT
+	dewtprintk(ioc,
-	    "%s - exit, query_count = %d termination_count = %d\n",
+		   ioc_info(ioc, "%s - exit, query_count = %d termination_count = %d\n",
-	    ioc->name, __func__, query_count, termination_count));
+			    __func__, query_count, termination_count));
 	ioc->broadcast_aen_busy = 0;
 	if (!ioc->shost_recovery)
 		(Mpi2EventDataSasDiscovery_t *) fw_event->event_data;
 	if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) {
-		pr_info(MPT3SAS_FMT "discovery event: (%s)", ioc->name,
+		ioc_info(ioc, "discovery event: (%s)",
-		    (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED) ?
+			 event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED ?
-		    "start" : "stop");
+			 "start" : "stop");
 		if (event_data->DiscoveryStatus)
-			pr_info("discovery_status(0x%08x)",
+			pr_cont("discovery_status(0x%08x)",
-			    le32_to_cpu(event_data->DiscoveryStatus));
+				le32_to_cpu(event_data->DiscoveryStatus));
-		pr_info("\n");
+		pr_cont("\n");
 	}
 	if (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED &&
 	switch (event_data->ReasonCode) {
 	case MPI25_EVENT_SAS_DISC_ERR_SMP_FAILED:
-		pr_warn(MPT3SAS_FMT "SMP command sent to the expander"
+		ioc_warn(ioc, "SMP command sent to the expander (handle:0x%04x, sas_address:0x%016llx, physical_port:0x%02x) has failed\n",
-			"(handle:0x%04x, sas_address:0x%016llx,"
+			 le16_to_cpu(event_data->DevHandle),
-			"physical_port:0x%02x) has failed",
+			 (u64)le64_to_cpu(event_data->SASAddress),
-			ioc->name, le16_to_cpu(event_data->DevHandle),
+			 event_data->PhysicalPort);
-			(unsigned long long)le64_to_cpu(event_data->SASAddress),
-			event_data->PhysicalPort);
 		break;
 	case MPI25_EVENT_SAS_DISC_ERR_SMP_TIMEOUT:
-		pr_warn(MPT3SAS_FMT "SMP command sent to the expander"
+		ioc_warn(ioc, "SMP command sent to the expander (handle:0x%04x, sas_address:0x%016llx, physical_port:0x%02x) has timed out\n",
-			"(handle:0x%04x, sas_address:0x%016llx,"
+			 le16_to_cpu(event_data->DevHandle),
-			"physical_port:0x%02x) has timed out",
+			 (u64)le64_to_cpu(event_data->SASAddress),
-			ioc->name, le16_to_cpu(event_data->DevHandle),
+			 event_data->PhysicalPort);
-			(unsigned long long)le64_to_cpu(event_data->SASAddress),
-			event_data->PhysicalPort);
 		break;
 	default:
 		break;
 	if (!(ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK))
 		return;
-	pr_info(MPT3SAS_FMT "pcie enumeration event: (%s) Flag 0x%02x",
+	ioc_info(ioc, "pcie enumeration event: (%s) Flag 0x%02x",
-		ioc->name,
+		 (event_data->ReasonCode == MPI26_EVENT_PCIE_ENUM_RC_STARTED) ?
-		(event_data->ReasonCode == MPI26_EVENT_PCIE_ENUM_RC_STARTED) ?
+		 "started" : "completed",
-			"started" : "completed",
+		 event_data->Flags);
-		event_data->Flags);
 	if (event_data->EnumerationStatus)
 		pr_cont("enumeration_status(0x%08x)",
 			le32_to_cpu(event_data->EnumerationStatus));
 	mutex_lock(&ioc->scsih_cmds.mutex);
 	if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
-		pr_err(MPT3SAS_FMT "%s: scsih_cmd in use\n",
+		ioc_err(ioc, "%s: scsih_cmd in use\n", __func__);
-		    ioc->name, __func__);
 		rc = -EAGAIN;
 		goto out;
 	}
 	smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
 	if (!smid) {
-		pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
+		ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
-		    ioc->name, __func__);
 		ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
 		rc = -EAGAIN;
 		goto out;
 	mpi_request->Action = MPI2_RAID_ACTION_PHYSDISK_HIDDEN;
 	mpi_request->PhysDiskNum = phys_disk_num;
-	dewtprintk(ioc, pr_info(MPT3SAS_FMT "IR RAID_ACTION: turning fast "\
+	dewtprintk(ioc,
-	    "path on for handle(0x%04x), phys_disk_num (0x%02x)\n", ioc->name,
+		   ioc_info(ioc, "IR RAID_ACTION: turning fast path on for handle(0x%04x), phys_disk_num (0x%02x)\n",
-	    handle, phys_disk_num));
+			    handle, phys_disk_num));
 	init_completion(&ioc->scsih_cmds.done);
 	mpt3sas_base_put_smid_default(ioc, smid);
 			log_info = 0;
 		ioc_status &= MPI2_IOCSTATUS_MASK;
 		if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-			dewtprintk(ioc, pr_info(MPT3SAS_FMT
+			dewtprintk(ioc,
-			    "IR RAID_ACTION: failed: ioc_status(0x%04x), "
+				   ioc_info(ioc, "IR RAID_ACTION: failed: ioc_status(0x%04x), loginfo(0x%08x)!!!\n",
-			    "loginfo(0x%08x)!!!\n", ioc->name, ioc_status,
+					    ioc_status, log_info));
-			    log_info));
 			rc = -EFAULT;
 		} else
-			dewtprintk(ioc, pr_info(MPT3SAS_FMT
+			dewtprintk(ioc,
-			    "IR RAID_ACTION: completed successfully\n",
+				   ioc_info(ioc, "IR RAID_ACTION: completed successfully\n"));
-			    ioc->name));
 	}
  out:
 	mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
 	if (!wwid) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    "failure at %s:%d/%s()!\n", ioc->name,
+			__FILE__, __LINE__, __func__);
-		    __FILE__, __LINE__, __func__);
 		return;
 	}
 	raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
 	if (!raid_device) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    "failure at %s:%d/%s()!\n", ioc->name,
+			__FILE__, __LINE__, __func__);
-		    __FILE__, __LINE__, __func__);
 		return;
 	}
 			sas_target_priv_data = starget->hostdata;
 			sas_target_priv_data->deleted = 1;
 		}
-		pr_info(MPT3SAS_FMT "removing handle(0x%04x), wwid(0x%016llx)\n",
+		ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
-			ioc->name,  raid_device->handle,
+			 raid_device->handle, (u64)raid_device->wwid);
-		    (unsigned long long) raid_device->wwid);
 		list_del(&raid_device->list);
 		kfree(raid_device);
 	}
 	if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
 	    MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return;
 	}
 	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 	    MPI2_IOCSTATUS_MASK;
 	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return;
 	}
 	element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
-	pr_info(MPT3SAS_FMT "raid config change: (%s), elements(%d)\n",
+	ioc_info(ioc, "raid config change: (%s), elements(%d)\n",
-	    ioc->name, (le32_to_cpu(event_data->Flags) &
+		 le32_to_cpu(event_data->Flags) & MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG ?
-	    MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ?
+		 "foreign" : "native",
-	    "foreign" : "native", event_data->NumElements);
+		 event_data->NumElements);
 	for (i = 0; i < event_data->NumElements; i++, element++) {
 		switch (element->ReasonCode) {
 		case MPI2_EVENT_IR_CHANGE_RC_ADDED:
 	handle = le16_to_cpu(event_data->VolDevHandle);
 	state = le32_to_cpu(event_data->NewValue);
 	if (!ioc->hide_ir_msg)
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-		    "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
+			   ioc_info(ioc, "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
-		    ioc->name, __func__,  handle,
+				    __func__, handle,
-		    le32_to_cpu(event_data->PreviousValue), state));
+				    le32_to_cpu(event_data->PreviousValue),
+				    state));
 	switch (state) {
 	case MPI2_RAID_VOL_STATE_MISSING:
 	case MPI2_RAID_VOL_STATE_FAILED:
 		mpt3sas_config_get_volume_wwid(ioc, handle, &wwid);
 		if (!wwid) {
-			pr_err(MPT3SAS_FMT
+			ioc_err(ioc, "failure at %s:%d/%s()!\n",
-			    "failure at %s:%d/%s()!\n", ioc->name,
+				__FILE__, __LINE__, __func__);
-			    __FILE__, __LINE__, __func__);
 			break;
 		}
 		raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL);
 		if (!raid_device) {
-			pr_err(MPT3SAS_FMT
+			ioc_err(ioc, "failure at %s:%d/%s()!\n",
-			    "failure at %s:%d/%s()!\n", ioc->name,
+				__FILE__, __LINE__, __func__);
-			    __FILE__, __LINE__, __func__);
 			break;
 		}
 	state = le32_to_cpu(event_data->NewValue);
 	if (!ioc->hide_ir_msg)
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-		    "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
+			   ioc_info(ioc, "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n",
-		    ioc->name, __func__,  handle,
+				    __func__, handle,
-		    le32_to_cpu(event_data->PreviousValue), state));
+				    le32_to_cpu(event_data->PreviousValue),
+				    state));
 	switch (state) {
 	case MPI2_RAID_PD_STATE_ONLINE:
 		if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,
 		    &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE,
 		    handle))) {
-			pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+			ioc_err(ioc, "failure at %s:%d/%s()!\n",
-			    ioc->name, __FILE__, __LINE__, __func__);
+				__FILE__, __LINE__, __func__);
 			return;
 		}
 		ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 		    MPI2_IOCSTATUS_MASK;
 		if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-			pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+			ioc_err(ioc, "failure at %s:%d/%s()!\n",
-			    ioc->name, __FILE__, __LINE__, __func__);
+				__FILE__, __LINE__, __func__);
 			return;
 		}
 	if (!reason_str)
 		return;
-	pr_info(MPT3SAS_FMT "raid operational status: (%s)" \
+	ioc_info(ioc, "raid operational status: (%s)\thandle(0x%04x), percent complete(%d)\n",
-	    "\thandle(0x%04x), percent complete(%d)\n",
+		 reason_str,
-	    ioc->name, reason_str,
+		 le16_to_cpu(event_data->VolDevHandle),
-	    le16_to_cpu(event_data->VolDevHandle),
+		 event_data->PercentComplete);
-	    event_data->PercentComplete);
 }
 /**
 			mpt3sas_scsih_enclosure_find_by_handle(ioc,
 				le16_to_cpu(sas_device_pg0->EnclosureHandle));
 		if (enclosure_dev == NULL)
-			pr_info(MPT3SAS_FMT "Enclosure handle(0x%04x)"
+			ioc_info(ioc, "Enclosure handle(0x%04x) doesn't match with enclosure device!\n",
-			    "doesn't match with enclosure device!\n",
+				 sas_device_pg0->EnclosureHandle);
-			    ioc->name, sas_device_pg0->EnclosureHandle);
 	}
 	spin_lock_irqsave(&ioc->sas_device_lock, flags);
 	list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
 		enclosure_dev =
 			kzalloc(sizeof(struct _enclosure_node), GFP_KERNEL);
 		if (!enclosure_dev) {
-			pr_err(MPT3SAS_FMT
+			ioc_err(ioc, "failure at %s:%d/%s()!\n",
-				"failure at %s:%d/%s()!\n", ioc->name,
 				__FILE__, __LINE__, __func__);
 			return;
 		}
 	u16 handle;
 	u32 device_info;
-	pr_info(MPT3SAS_FMT "search for end-devices: start\n", ioc->name);
+	ioc_info(ioc, "search for end-devices: start\n");
 	if (list_empty(&ioc->sas_device_list))
 		goto out;
 	}
  out:
-	pr_info(MPT3SAS_FMT "search for end-devices: complete\n",
+	ioc_info(ioc, "search for end-devices: complete\n");
-	    ioc->name);
 }
 /**
 	u16 handle;
 	u32 device_info;
-	pr_info(MPT3SAS_FMT "search for end-devices: start\n", ioc->name);
+	ioc_info(ioc, "search for end-devices: start\n");
 	if (list_empty(&ioc->pcie_device_list))
 		goto out;
 		ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 		    MPI2_IOCSTATUS_MASK;
 		if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-			pr_info(MPT3SAS_FMT "\tbreak from %s: "
+			ioc_info(ioc, "\tbreak from %s: ioc_status(0x%04x), loginfo(0x%08x)\n",
-			    "ioc_status(0x%04x), loginfo(0x%08x)\n", ioc->name,
+				 __func__, ioc_status,
-			    __func__, ioc_status,
+				 le32_to_cpu(mpi_reply.IOCLogInfo));
-			    le32_to_cpu(mpi_reply.IOCLogInfo));
 			break;
 		}
 		handle = le16_to_cpu(pcie_device_pg0.DevHandle);
 		_scsih_mark_responding_pcie_device(ioc, &pcie_device_pg0);
 	}
 out:
-	pr_info(MPT3SAS_FMT "search for PCIe end-devices: complete\n",
+	ioc_info(ioc, "search for PCIe end-devices: complete\n");
-	    ioc->name);
 }
 /**
 	if (!ioc->ir_firmware)
 		return;
-	pr_info(MPT3SAS_FMT "search for raid volumes: start\n",
+	ioc_info(ioc, "search for raid volumes: start\n");
-	    ioc->name);
 	if (list_empty(&ioc->raid_device_list))
 		goto out;
 		}
 	}
  out:
-	pr_info(MPT3SAS_FMT "search for responding raid volumes: complete\n",
+	ioc_info(ioc, "search for responding raid volumes: complete\n");
-		ioc->name);
 }
 /**
 	u64 sas_address;
 	u16 handle;
-	pr_info(MPT3SAS_FMT "search for expanders: start\n", ioc->name);
+	ioc_info(ioc, "search for expanders: start\n");
 	if (list_empty(&ioc->sas_expander_list))
 		goto out;
 	}
  out:
-	pr_info(MPT3SAS_FMT "search for expanders: complete\n", ioc->name);
+	ioc_info(ioc, "search for expanders: complete\n");
 }
 /**
 	unsigned long flags;
 	LIST_HEAD(head);
-	pr_info(MPT3SAS_FMT "removing unresponding devices: start\n",
+	ioc_info(ioc, "removing unresponding devices: start\n");
-	    ioc->name);
 	/* removing unresponding end devices */
-	pr_info(MPT3SAS_FMT "removing unresponding devices: end-devices\n",
+	ioc_info(ioc, "removing unresponding devices: end-devices\n");
-	    ioc->name);
 	/*
 	 * Iterate, pulling off devices marked as non-responding. We become the
 	 * owner for the reference the list had on any object we prune.
 		sas_device_put(sas_device);
 	}
-	pr_info(MPT3SAS_FMT
+	ioc_info(ioc, "Removing unresponding devices: pcie end-devices\n");
-		" Removing unresponding devices: pcie end-devices\n"
-		, ioc->name);
 	INIT_LIST_HEAD(&head);
 	spin_lock_irqsave(&ioc->pcie_device_lock, flags);
 	list_for_each_entry_safe(pcie_device, pcie_device_next,
 	/* removing unresponding volumes */
 	if (ioc->ir_firmware) {
-		pr_info(MPT3SAS_FMT "removing unresponding devices: volumes\n",
+		ioc_info(ioc, "removing unresponding devices: volumes\n");
-			ioc->name);
 		list_for_each_entry_safe(raid_device, raid_device_next,
 		    &ioc->raid_device_list, list) {
 			if (!raid_device->responding)
 	}
 	/* removing unresponding expanders */
-	pr_info(MPT3SAS_FMT "removing unresponding devices: expanders\n",
+	ioc_info(ioc, "removing unresponding devices: expanders\n");
-	    ioc->name);
 	spin_lock_irqsave(&ioc->sas_node_lock, flags);
 	INIT_LIST_HEAD(&tmp_list);
 	list_for_each_entry_safe(sas_expander, sas_expander_next,
 		_scsih_expander_node_remove(ioc, sas_expander);
 	}
-	pr_info(MPT3SAS_FMT "removing unresponding devices: complete\n",
+	ioc_info(ioc, "removing unresponding devices: complete\n");
-	    ioc->name);
 	/* unblock devices */
 	_scsih_ublock_io_all_device(ioc);
 	for (i = 0 ; i < sas_expander->num_phys ; i++) {
 		if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,
 		    &expander_pg1, i, handle))) {
-			pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+			ioc_err(ioc, "failure at %s:%d/%s()!\n",
-			    ioc->name, __FILE__, __LINE__, __func__);
+				__FILE__, __LINE__, __func__);
 			return;
 		}
 	u8 retry_count;
 	unsigned long flags;
-	pr_info(MPT3SAS_FMT "scan devices: start\n", ioc->name);
+	ioc_info(ioc, "scan devices: start\n");
 	_scsih_sas_host_refresh(ioc);
-	pr_info(MPT3SAS_FMT "\tscan devices: expanders start\n", ioc->name);
+	ioc_info(ioc, "\tscan devices: expanders start\n");
 	/* expanders */
 	handle = 0xFFFF;
 		ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 		    MPI2_IOCSTATUS_MASK;
 		if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-			pr_info(MPT3SAS_FMT "\tbreak from expander scan: " \
+			ioc_info(ioc, "\tbreak from expander scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
-			    "ioc_status(0x%04x), loginfo(0x%08x)\n",
+				 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
-			    ioc->name, ioc_status,
-			    le32_to_cpu(mpi_reply.IOCLogInfo));
 			break;
 		}
 		handle = le16_to_cpu(expander_pg0.DevHandle);
 			_scsih_refresh_expander_links(ioc, expander_device,
 			    handle);
 		else {
-			pr_info(MPT3SAS_FMT "\tBEFORE adding expander: " \
+			ioc_info(ioc, "\tBEFORE adding expander: handle (0x%04x), sas_addr(0x%016llx)\n",
-			    "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
+				 handle,
-			    handle, (unsigned long long)
+				 (u64)le64_to_cpu(expander_pg0.SASAddress));
-			    le64_to_cpu(expander_pg0.SASAddress));
 			_scsih_expander_add(ioc, handle);
-			pr_info(MPT3SAS_FMT "\tAFTER adding expander: " \
+			ioc_info(ioc, "\tAFTER adding expander: handle (0x%04x), sas_addr(0x%016llx)\n",
-			    "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
+				 handle,
-			    handle, (unsigned long long)
+				 (u64)le64_to_cpu(expander_pg0.SASAddress));
-			    le64_to_cpu(expander_pg0.SASAddress));
 		}
 	}
-	pr_info(MPT3SAS_FMT "\tscan devices: expanders complete\n",
+	ioc_info(ioc, "\tscan devices: expanders complete\n");
-	    ioc->name);
 	if (!ioc->ir_firmware)
 		goto skip_to_sas;
-	pr_info(MPT3SAS_FMT "\tscan devices: phys disk start\n", ioc->name);
+	ioc_info(ioc, "\tscan devices: phys disk start\n");
 	/* phys disk */
 	phys_disk_num = 0xFF;
 		ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 		    MPI2_IOCSTATUS_MASK;
 		if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-			pr_info(MPT3SAS_FMT "\tbreak from phys disk scan: "\
+			ioc_info(ioc, "\tbreak from phys disk scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
-			    "ioc_status(0x%04x), loginfo(0x%08x)\n",
+				 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
-			    ioc->name, ioc_status,
-			    le32_to_cpu(mpi_reply.IOCLogInfo));
 			break;
 		}
 		phys_disk_num = pd_pg0.PhysDiskNum;
 		ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 		    MPI2_IOCSTATUS_MASK;
 		if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-			pr_info(MPT3SAS_FMT "\tbreak from phys disk scan " \
+			ioc_info(ioc, "\tbreak from phys disk scan ioc_status(0x%04x), loginfo(0x%08x)\n",
-			    "ioc_status(0x%04x), loginfo(0x%08x)\n",
+				 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
-			    ioc->name, ioc_status,
-			    le32_to_cpu(mpi_reply.IOCLogInfo));
 			break;
 		}
 		parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
 		if (!_scsih_get_sas_address(ioc, parent_handle,
 		    &sas_address)) {
-			pr_info(MPT3SAS_FMT "\tBEFORE adding phys disk: " \
+			ioc_info(ioc, "\tBEFORE adding phys disk: handle (0x%04x), sas_addr(0x%016llx)\n",
-			    " handle (0x%04x), sas_addr(0x%016llx)\n",
+				 handle,
-			    ioc->name, handle, (unsigned long long)
+				 (u64)le64_to_cpu(sas_device_pg0.SASAddress));
-			    le64_to_cpu(sas_device_pg0.SASAddress));
 			mpt3sas_transport_update_links(ioc, sas_address,
 			    handle, sas_device_pg0.PhyNum,
 			    MPI2_SAS_NEG_LINK_RATE_1_5);
 			    1)) {
 				ssleep(1);
 			}
-			pr_info(MPT3SAS_FMT "\tAFTER adding phys disk: " \
+			ioc_info(ioc, "\tAFTER adding phys disk: handle (0x%04x), sas_addr(0x%016llx)\n",
-			    " handle (0x%04x), sas_addr(0x%016llx)\n",
+				 handle,
-			    ioc->name, handle, (unsigned long long)
+				 (u64)le64_to_cpu(sas_device_pg0.SASAddress));
-			    le64_to_cpu(sas_device_pg0.SASAddress));
 		}
 	}
-	pr_info(MPT3SAS_FMT "\tscan devices: phys disk complete\n",
+	ioc_info(ioc, "\tscan devices: phys disk complete\n");
-	    ioc->name);
-	pr_info(MPT3SAS_FMT "\tscan devices: volumes start\n", ioc->name);
+	ioc_info(ioc, "\tscan devices: volumes start\n");
 	/* volumes */
 	handle = 0xFFFF;
 		ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 		    MPI2_IOCSTATUS_MASK;
 		if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-			pr_info(MPT3SAS_FMT "\tbreak from volume scan: " \
+			ioc_info(ioc, "\tbreak from volume scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
-			    "ioc_status(0x%04x), loginfo(0x%08x)\n",
+				 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
-			    ioc->name, ioc_status,
-			    le32_to_cpu(mpi_reply.IOCLogInfo));
 			break;
 		}
 		handle = le16_to_cpu(volume_pg1.DevHandle);
 		ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 		    MPI2_IOCSTATUS_MASK;
 		if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-			pr_info(MPT3SAS_FMT "\tbreak from volume scan: " \
+			ioc_info(ioc, "\tbreak from volume scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
-			    "ioc_status(0x%04x), loginfo(0x%08x)\n",
+				 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
-			    ioc->name, ioc_status,
-			    le32_to_cpu(mpi_reply.IOCLogInfo));
 			break;
 		}
 		if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL ||
 			memset(&element, 0, sizeof(Mpi2EventIrConfigElement_t));
 			element.ReasonCode = MPI2_EVENT_IR_CHANGE_RC_ADDED;
 			element.VolDevHandle = volume_pg1.DevHandle;
-			pr_info(MPT3SAS_FMT
+			ioc_info(ioc, "\tBEFORE adding volume: handle (0x%04x)\n",
-				"\tBEFORE adding volume: handle (0x%04x)\n",
+				 volume_pg1.DevHandle);
-				ioc->name, volume_pg1.DevHandle);
 			_scsih_sas_volume_add(ioc, &element);
-			pr_info(MPT3SAS_FMT
+			ioc_info(ioc, "\tAFTER adding volume: handle (0x%04x)\n",
-				"\tAFTER adding volume: handle (0x%04x)\n",
+				 volume_pg1.DevHandle);
-				ioc->name, volume_pg1.DevHandle);
 		}
 	}
-	pr_info(MPT3SAS_FMT "\tscan devices: volumes complete\n",
+	ioc_info(ioc, "\tscan devices: volumes complete\n");
-	    ioc->name);
  skip_to_sas:
-	pr_info(MPT3SAS_FMT "\tscan devices: end devices start\n",
+	ioc_info(ioc, "\tscan devices: end devices start\n");
-	    ioc->name);
 	/* sas devices */
 	handle = 0xFFFF;
 		ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 		    MPI2_IOCSTATUS_MASK;
 		if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-			pr_info(MPT3SAS_FMT "\tbreak from end device scan:"\
+			ioc_info(ioc, "\tbreak from end device scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
-			    " ioc_status(0x%04x), loginfo(0x%08x)\n",
+				 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
-			    ioc->name, ioc_status,
-			    le32_to_cpu(mpi_reply.IOCLogInfo));
 			break;
 		}
 		handle = le16_to_cpu(sas_device_pg0.DevHandle);
 		}
 		parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
 		if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) {
-			pr_info(MPT3SAS_FMT "\tBEFORE adding end device: " \
+			ioc_info(ioc, "\tBEFORE adding end device: handle (0x%04x), sas_addr(0x%016llx)\n",
-			    "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
+				 handle,
-			    handle, (unsigned long long)
+				 (u64)le64_to_cpu(sas_device_pg0.SASAddress));
-			    le64_to_cpu(sas_device_pg0.SASAddress));
 			mpt3sas_transport_update_links(ioc, sas_address, handle,
 			    sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
 			retry_count = 0;
 			    0)) {
 				ssleep(1);
 			}
-			pr_info(MPT3SAS_FMT "\tAFTER adding end device: " \
+			ioc_info(ioc, "\tAFTER adding end device: handle (0x%04x), sas_addr(0x%016llx)\n",
-			    "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name,
+				 handle,
-			    handle, (unsigned long long)
+				 (u64)le64_to_cpu(sas_device_pg0.SASAddress));
-			    le64_to_cpu(sas_device_pg0.SASAddress));
 		}
 	}
-	pr_info(MPT3SAS_FMT "\tscan devices: end devices complete\n",
+	ioc_info(ioc, "\tscan devices: end devices complete\n");
-	    ioc->name);
+	ioc_info(ioc, "\tscan devices: pcie end devices start\n");
-	pr_info(MPT3SAS_FMT "\tscan devices: pcie end devices start\n",
-	    ioc->name);
 	/* pcie devices */
 	handle = 0xFFFF;
 		ioc_status = le16_to_cpu(mpi_reply.IOCStatus)
 				& MPI2_IOCSTATUS_MASK;
 		if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-			pr_info(MPT3SAS_FMT "\tbreak from pcie end device"
+			ioc_info(ioc, "\tbreak from pcie end device scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
-				" scan: ioc_status(0x%04x), loginfo(0x%08x)\n",
+				 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo));
-				ioc->name, ioc_status,
-				le32_to_cpu(mpi_reply.IOCLogInfo));
 			break;
 		}
 		handle = le16_to_cpu(pcie_device_pg0.DevHandle);
 		parent_handle = le16_to_cpu(pcie_device_pg0.ParentDevHandle);
 		_scsih_pcie_add_device(ioc, handle);
-		pr_info(MPT3SAS_FMT "\tAFTER adding pcie end device: "
+		ioc_info(ioc, "\tAFTER adding pcie end device: handle (0x%04x), wwid(0x%016llx)\n",
-			"handle (0x%04x), wwid(0x%016llx)\n", ioc->name,
+			 handle, (u64)le64_to_cpu(pcie_device_pg0.WWID));
-			handle,
-			(unsigned long long) le64_to_cpu(pcie_device_pg0.WWID));
 	}
-	pr_info(MPT3SAS_FMT "\tpcie devices: pcie end devices complete\n",
+	ioc_info(ioc, "\tpcie devices: pcie end devices complete\n");
-		ioc->name);
+	ioc_info(ioc, "scan devices: complete\n");
-	pr_info(MPT3SAS_FMT "scan devices: complete\n", ioc->name);
 }
 /**
  */
 void mpt3sas_scsih_pre_reset_handler(struct MPT3SAS_ADAPTER *ioc)
 {
-	dtmprintk(ioc, pr_info(MPT3SAS_FMT
+	dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_PRE_RESET\n", __func__));
-			"%s: MPT3_IOC_PRE_RESET\n", ioc->name, __func__));
 }
 /**
 void
 mpt3sas_scsih_after_reset_handler(struct MPT3SAS_ADAPTER *ioc)
 {
-	dtmprintk(ioc, pr_info(MPT3SAS_FMT
+	dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_AFTER_RESET\n", __func__));
-			"%s: MPT3_IOC_AFTER_RESET\n", ioc->name, __func__));
 	if (ioc->scsih_cmds.status & MPT3_CMD_PENDING) {
 		ioc->scsih_cmds.status |= MPT3_CMD_RESET;
 		mpt3sas_base_free_smid(ioc, ioc->scsih_cmds.smid);
 void
 mpt3sas_scsih_reset_done_handler(struct MPT3SAS_ADAPTER *ioc)
 {
-	dtmprintk(ioc, pr_info(MPT3SAS_FMT
+	dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_DONE_RESET\n", __func__));
-			"%s: MPT3_IOC_DONE_RESET\n", ioc->name, __func__));
 	if ((!ioc->is_driver_loading) && !(disable_discovery > 0 &&
 					   !ioc->sas_hba.num_phys)) {
 		_scsih_prep_device_scan(ioc);
 		if (missing_delay[0] != -1 && missing_delay[1] != -1)
 			mpt3sas_base_update_missing_delay(ioc, missing_delay[0],
 			    missing_delay[1]);
-		dewtprintk(ioc, pr_info(MPT3SAS_FMT
+		dewtprintk(ioc,
-			"port enable: complete from worker thread\n",
+			   ioc_info(ioc, "port enable: complete from worker thread\n"));
-			ioc->name));
 		break;
 	case MPT3SAS_TURN_ON_PFA_LED:
 		_scsih_turn_on_pfa_led(ioc, fw_event->device_handle);
 	mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply);
 	if (unlikely(!mpi_reply)) {
-		pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n",
+		ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return 1;
 	}
 		switch (le32_to_cpu(*log_code)) {
 		case MPT2_WARPDRIVE_LC_SSDT:
-			pr_warn(MPT3SAS_FMT "WarpDrive Warning: "
+			ioc_warn(ioc, "WarpDrive Warning: IO Throttling has occurred in the WarpDrive subsystem. Check WarpDrive documentation for additional details.\n");
-			    "IO Throttling has occurred in the WarpDrive "
-			    "subsystem. Check WarpDrive documentation for "
-			    "additional details.\n", ioc->name);
 			break;
 		case MPT2_WARPDRIVE_LC_SSDLW:
-			pr_warn(MPT3SAS_FMT "WarpDrive Warning: "
+			ioc_warn(ioc, "WarpDrive Warning: Program/Erase Cycles for the WarpDrive subsystem in degraded range. Check WarpDrive documentation for additional details.\n");
-			    "Program/Erase Cycles for the WarpDrive subsystem "
-			    "in degraded range. Check WarpDrive documentation "
-			    "for additional details.\n", ioc->name);
 			break;
 		case MPT2_WARPDRIVE_LC_SSDLF:
-			pr_err(MPT3SAS_FMT "WarpDrive Fatal Error: "
+			ioc_err(ioc, "WarpDrive Fatal Error: There are no Program/Erase Cycles for the WarpDrive subsystem. The storage device will be in read-only mode. Check WarpDrive documentation for additional details.\n");
-			    "There are no Program/Erase Cycles for the "
-			    "WarpDrive subsystem. The storage device will be "
-			    "in read-only mode. Check WarpDrive documentation "
-			    "for additional details.\n", ioc->name);
 			break;
 		case MPT2_WARPDRIVE_LC_BRMF:
-			pr_err(MPT3SAS_FMT "WarpDrive Fatal Error: "
+			ioc_err(ioc, "WarpDrive Fatal Error: The Backup Rail Monitor has failed on the WarpDrive subsystem. Check WarpDrive documentation for additional details.\n");
-			    "The Backup Rail Monitor has failed on the "
-			    "WarpDrive subsystem. Check WarpDrive "
-			    "documentation for additional details.\n",
-			    ioc->name);
 			break;
 		}
 		    (Mpi26EventDataActiveCableExcept_t *) mpi_reply->EventData;
 		switch (ActiveCableEventData->ReasonCode) {
 		case MPI26_EVENT_ACTIVE_CABLE_INSUFFICIENT_POWER:
-			pr_notice(MPT3SAS_FMT
+			ioc_notice(ioc, "Currently an active cable with ReceptacleID %d\n",
-			    "Currently an active cable with ReceptacleID %d\n",
+				   ActiveCableEventData->ReceptacleID);
-			    ioc->name, ActiveCableEventData->ReceptacleID);
 			pr_notice("cannot be powered and devices connected\n");
 			pr_notice("to this active cable will not be seen\n");
 			pr_notice("This active cable requires %d mW of power\n",
 			break;
 		case MPI26_EVENT_ACTIVE_CABLE_DEGRADED:
-			pr_notice(MPT3SAS_FMT
+			ioc_notice(ioc, "Currently a cable with ReceptacleID %d\n",
-			    "Currently a cable with ReceptacleID %d\n",
+				   ActiveCableEventData->ReceptacleID);
-			    ioc->name, ActiveCableEventData->ReceptacleID);
 			pr_notice(
 			    "is not running at optimal speed(12 Gb/s rate)\n");
 			break;
 	sz = le16_to_cpu(mpi_reply->EventDataLength) * 4;
 	fw_event = alloc_fw_event_work(sz);
 	if (!fw_event) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return 1;
 	}
 	mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
 	    sas_expander->sas_address_parent);
-	pr_info(MPT3SAS_FMT
+	ioc_info(ioc, "expander_remove: handle(0x%04x), sas_addr(0x%016llx)\n",
-		"expander_remove: handle(0x%04x), sas_addr(0x%016llx)\n",
+		 sas_expander->handle, (unsigned long long)
-		ioc->name,
+		 sas_expander->sas_address);
-	    sas_expander->handle, (unsigned long long)
-	    sas_expander->sas_address);
 	spin_lock_irqsave(&ioc->sas_node_lock, flags);
 	list_del(&sas_expander->list);
 	mutex_lock(&ioc->scsih_cmds.mutex);
 	if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) {
-		pr_err(MPT3SAS_FMT "%s: scsih_cmd in use\n",
+		ioc_err(ioc, "%s: scsih_cmd in use\n", __func__);
-		    ioc->name, __func__);
 		goto out;
 	}
 	ioc->scsih_cmds.status = MPT3_CMD_PENDING;
 	smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx);
 	if (!smid) {
-		pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
+		ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
-		    ioc->name, __func__);
 		ioc->scsih_cmds.status = MPT3_CMD_NOT_USED;
 		goto out;
 	}
 	mpi_request->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED;
 	if (!ioc->hide_ir_msg)
-		pr_info(MPT3SAS_FMT "IR shutdown (sending)\n", ioc->name);
+		ioc_info(ioc, "IR shutdown (sending)\n");
 	init_completion(&ioc->scsih_cmds.done);
 	mpt3sas_base_put_smid_default(ioc, smid);
 	wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
 	if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {
-		pr_err(MPT3SAS_FMT "%s: timeout\n",
+		ioc_err(ioc, "%s: timeout\n", __func__);
-		    ioc->name, __func__);
 		goto out;
 	}
 	if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {
 		mpi_reply = ioc->scsih_cmds.reply;
 		if (!ioc->hide_ir_msg)
-			pr_info(MPT3SAS_FMT "IR shutdown "
+			ioc_info(ioc, "IR shutdown (complete): ioc_status(0x%04x), loginfo(0x%08x)\n",
-			   "(complete): ioc_status(0x%04x), loginfo(0x%08x)\n",
+				 le16_to_cpu(mpi_reply->IOCStatus),
-			    ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
+				 le32_to_cpu(mpi_reply->IOCLogInfo));
-			    le32_to_cpu(mpi_reply->IOCLogInfo));
 	}
  out:
 			sas_target_priv_data->deleted = 1;
 			scsi_remove_target(&raid_device->starget->dev);
 		}
-		pr_info(MPT3SAS_FMT "removing handle(0x%04x), wwid(0x%016llx)\n",
+		ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n",
-			ioc->name,  raid_device->handle,
+			 raid_device->handle, (u64)raid_device->wwid);
-		    (unsigned long long) raid_device->wwid);
 		_scsih_raid_device_remove(ioc, raid_device);
 	}
 	list_for_each_entry_safe(pcie_device, pcienext, &ioc->pcie_device_list,
 	rc = mpt3sas_port_enable(ioc);
 	if (rc != 0)
-		pr_info(MPT3SAS_FMT "port enable: FAILED\n", ioc->name);
+		ioc_info(ioc, "port enable: FAILED\n");
 }
 /**
 	if (time >= (300 * HZ)) {
 		ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED;
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "port enable: FAILED with timeout (timeout=300s)\n");
-			"port enable: FAILED with timeout (timeout=300s)\n",
-			ioc->name);
 		ioc->is_driver_loading = 0;
 		return 1;
 	}
 		return 0;
 	if (ioc->start_scan_failed) {
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "port enable: FAILED with (ioc_status=0x%08x)\n",
-			"port enable: FAILED with (ioc_status=0x%08x)\n",
+			 ioc->start_scan_failed);
-			ioc->name, ioc->start_scan_failed);
 		ioc->is_driver_loading = 0;
 		ioc->wait_for_discovery_to_complete = 0;
 		ioc->remove_host = 1;
 		return 1;
 	}
-	pr_info(MPT3SAS_FMT "port enable: SUCCESS\n", ioc->name);
+	ioc_info(ioc, "port enable: SUCCESS\n");
 	ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED;
 	if (ioc->wait_for_discovery_to_complete) {
 	if (ioc->is_mcpu_endpoint) {
 		/* mCPU MPI support 64K max IO */
 		shost->max_sectors = 128;
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "The max_sectors value is set to %d\n",
-				"The max_sectors value is set to %d\n",
+			 shost->max_sectors);
-				ioc->name, shost->max_sectors);
 	} else {
 		if (max_sectors != 0xFFFF) {
 			if (max_sectors < 64) {
 				shost->max_sectors = 64;
-				pr_warn(MPT3SAS_FMT "Invalid value %d passed " \
+				ioc_warn(ioc, "Invalid value %d passed for max_sectors, range is 64 to 32767. Assigning value of 64.\n",
-				    "for max_sectors, range is 64 to 32767. " \
+					 max_sectors);
-				    "Assigning value of 64.\n", \
-				    ioc->name, max_sectors);
 			} else if (max_sectors > 32767) {
 				shost->max_sectors = 32767;
-				pr_warn(MPT3SAS_FMT "Invalid value %d passed " \
+				ioc_warn(ioc, "Invalid value %d passed for max_sectors, range is 64 to 32767.Assigning default value of 32767.\n",
-				    "for max_sectors, range is 64 to 32767." \
+					 max_sectors);
-				    "Assigning default value of 32767.\n", \
-				    ioc->name, max_sectors);
 			} else {
 				shost->max_sectors = max_sectors & 0xFFFE;
-				pr_info(MPT3SAS_FMT
+				ioc_info(ioc, "The max_sectors value is set to %d\n",
-					"The max_sectors value is set to %d\n",
+					 shost->max_sectors);
-					ioc->name, shost->max_sectors);
 			}
 		}
 	}
 	ioc->firmware_event_thread = alloc_ordered_workqueue(
 	    ioc->firmware_event_name, 0);
 	if (!ioc->firmware_event_thread) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		rv = -ENODEV;
 		goto out_thread_fail;
 	}
 	ioc->is_driver_loading = 1;
 	if ((mpt3sas_base_attach(ioc))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		rv = -ENODEV;
 		goto out_attach_fail;
 	}
 	rv = scsi_add_host(shost, &pdev->dev);
 	if (rv) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		goto out_add_shost_fail;
 	}
 	flush_scheduled_work();
 	scsi_block_requests(shost);
 	device_state = pci_choose_state(pdev, state);
-	pr_info(MPT3SAS_FMT
+	ioc_info(ioc, "pdev=0x%p, slot=%s, entering operating state [D%d]\n",
-		"pdev=0x%p, slot=%s, entering operating state [D%d]\n",
+		 pdev, pci_name(pdev), device_state);
-		ioc->name, pdev, pci_name(pdev), device_state);
 	pci_save_state(pdev);
 	mpt3sas_base_free_resources(ioc);
 	pci_power_t device_state = pdev->current_state;
 	int r;
-	pr_info(MPT3SAS_FMT
+	ioc_info(ioc, "pdev=0x%p, slot=%s, previous operating state [D%d]\n",
-		"pdev=0x%p, slot=%s, previous operating state [D%d]\n",
+		 pdev, pci_name(pdev), device_state);
-		ioc->name, pdev, pci_name(pdev), device_state);
 	pci_set_power_state(pdev, PCI_D0);
 	pci_enable_wake(pdev, PCI_D0, 0);
 	struct Scsi_Host *shost = pci_get_drvdata(pdev);
 	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
-	pr_info(MPT3SAS_FMT "PCI error: detected callback, state(%d)!!\n",
+	ioc_info(ioc, "PCI error: detected callback, state(%d)!!\n", state);
-	    ioc->name, state);
 	switch (state) {
 	case pci_channel_io_normal:
 	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
 	int rc;
-	pr_info(MPT3SAS_FMT "PCI error: slot reset callback!!\n",
+	ioc_info(ioc, "PCI error: slot reset callback!!\n");
-	     ioc->name);
 	ioc->pci_error_recovery = 0;
 	ioc->pdev = pdev;
 	rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
-	pr_warn(MPT3SAS_FMT "hard reset: %s\n", ioc->name,
+	ioc_warn(ioc, "hard reset: %s\n",
-	    (rc == 0) ? "success" : "failed");
+		 (rc == 0) ? "success" : "failed");
 	if (!rc)
 		return PCI_ERS_RESULT_RECOVERED;
 	struct Scsi_Host *shost = pci_get_drvdata(pdev);
 	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
-	pr_info(MPT3SAS_FMT "PCI error: resume callback!!\n", ioc->name);
+	ioc_info(ioc, "PCI error: resume callback!!\n");
 	mpt3sas_base_start_watchdog(ioc);
 	scsi_unblock_requests(ioc->shost);
 	struct Scsi_Host *shost = pci_get_drvdata(pdev);
 	struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
-	pr_info(MPT3SAS_FMT "PCI error: mmio enabled callback!!\n",
+	ioc_info(ioc, "PCI error: mmio enabled callback!!\n");
-	    ioc->name);
 	/* TODO - dump whatever for debugging purposes */

drivers/scsi/mpt3sas/mpt3sas_transport.c+159−196

 	u32 ioc_status;
 	if (ioc->shost_recovery || ioc->pci_error_recovery) {
-		pr_info(MPT3SAS_FMT "%s: host reset in progress!\n",
+		ioc_info(ioc, "%s: host reset in progress!\n", __func__);
-		    __func__, ioc->name);
 		return -EFAULT;
 	}
 	if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
 	    MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return -ENXIO;
 	}
 	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 	    MPI2_IOCSTATUS_MASK;
 	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "handle(0x%04x), ioc_status(0x%04x) failure at %s:%d/%s()!\n",
-			"handle(0x%04x), ioc_status(0x%04x)\nfailure at %s:%d/%s()!\n",
+			handle, ioc_status, __FILE__, __LINE__, __func__);
-			ioc->name, handle, ioc_status,
-		     __FILE__, __LINE__, __func__);
 		return -EIO;
 	}
 	u16 wait_state_count;
 	if (ioc->shost_recovery || ioc->pci_error_recovery) {
-		pr_info(MPT3SAS_FMT "%s: host reset in progress!\n",
+		ioc_info(ioc, "%s: host reset in progress!\n", __func__);
-		    __func__, ioc->name);
 		return -EFAULT;
 	}
 	mutex_lock(&ioc->transport_cmds.mutex);
 	if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
-		pr_err(MPT3SAS_FMT "%s: transport_cmds in use\n",
+		ioc_err(ioc, "%s: transport_cmds in use\n", __func__);
-		    ioc->name, __func__);
 		rc = -EAGAIN;
 		goto out;
 	}
 	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
 	while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
 		if (wait_state_count++ == 10) {
-			pr_err(MPT3SAS_FMT
+			ioc_err(ioc, "%s: failed due to ioc not operational\n",
-			    "%s: failed due to ioc not operational\n",
+				__func__);
-			    ioc->name, __func__);
 			rc = -EFAULT;
 			goto out;
 		}
 		ssleep(1);
 		ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "%s: waiting for operational state(count=%d)\n",
-			"%s: waiting for operational state(count=%d)\n",
+			 __func__, wait_state_count);
-			ioc->name, __func__, wait_state_count);
 	}
 	if (wait_state_count)
-		pr_info(MPT3SAS_FMT "%s: ioc is operational\n",
+		ioc_info(ioc, "%s: ioc is operational\n", __func__);
-		    ioc->name, __func__);
 	smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
 	if (!smid) {
-		pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
+		ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
-		    ioc->name, __func__);
 		rc = -EAGAIN;
 		goto out;
 	}
 	data_out_sz = sizeof(struct rep_manu_request);
 	data_in_sz = sizeof(struct rep_manu_reply);
-	data_out = pci_alloc_consistent(ioc->pdev, data_out_sz + data_in_sz,
+	data_out = dma_alloc_coherent(&ioc->pdev->dev, data_out_sz + data_in_sz,
-	    &data_out_dma);
+			&data_out_dma, GFP_KERNEL);
 	if (!data_out) {
 		pr_err("failure at %s:%d/%s()!\n", __FILE__,
 		    __LINE__, __func__);
 	ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma,
 	    data_in_sz);
-	dtransportprintk(ioc, pr_info(MPT3SAS_FMT
+	dtransportprintk(ioc,
-		"report_manufacture - send to sas_addr(0x%016llx)\n",
+			 ioc_info(ioc, "report_manufacture - send to sas_addr(0x%016llx)\n",
-		ioc->name, (unsigned long long)sas_address));
+				  (u64)sas_address));
 	init_completion(&ioc->transport_cmds.done);
 	mpt3sas_base_put_smid_default(ioc, smid);
 	wait_for_completion_timeout(&ioc->transport_cmds.done, 10*HZ);
 	if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
-		pr_err(MPT3SAS_FMT "%s: timeout\n",
+		ioc_err(ioc, "%s: timeout\n", __func__);
-		    ioc->name, __func__);
 		_debug_dump_mf(mpi_request,
 		    sizeof(Mpi2SmpPassthroughRequest_t)/4);
 		if (!(ioc->transport_cmds.status & MPT3_CMD_RESET))
 		goto issue_host_reset;
 	}
-	dtransportprintk(ioc, pr_info(MPT3SAS_FMT
+	dtransportprintk(ioc, ioc_info(ioc, "report_manufacture - complete\n"));
-		"report_manufacture - complete\n", ioc->name));
 	if (ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID) {
 		u8 *tmp;
 		mpi_reply = ioc->transport_cmds.reply;
-		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
+		dtransportprintk(ioc,
-		    "report_manufacture - reply data transfer size(%d)\n",
+				 ioc_info(ioc, "report_manufacture - reply data transfer size(%d)\n",
-		    ioc->name, le16_to_cpu(mpi_reply->ResponseDataLength)));
+					  le16_to_cpu(mpi_reply->ResponseDataLength)));
 		if (le16_to_cpu(mpi_reply->ResponseDataLength) !=
 		    sizeof(struct rep_manu_reply))
 			    manufacture_reply->component_revision_id;
 		}
 	} else
-		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
+		dtransportprintk(ioc,
-		    "report_manufacture - no reply\n", ioc->name));
+				 ioc_info(ioc, "report_manufacture - no reply\n"));
  issue_host_reset:
 	if (issue_reset)
  out:
 	ioc->transport_cmds.status = MPT3_CMD_NOT_USED;
 	if (data_out)
-		pci_free_consistent(ioc->pdev, data_out_sz + data_in_sz,
+		dma_free_coherent(&ioc->pdev->dev, data_out_sz + data_in_sz,
 		    data_out, data_out_dma);
 	mutex_unlock(&ioc->transport_cmds.mutex);
 	mpt3sas_port = kzalloc(sizeof(struct _sas_port),
 	    GFP_KERNEL);
 	if (!mpt3sas_port) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return NULL;
 	}
 	spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
 	if (!sas_node) {
-		pr_err(MPT3SAS_FMT
+		ioc_err(ioc, "%s: Could not find parent sas_address(0x%016llx)!\n",
-			"%s: Could not find parent sas_address(0x%016llx)!\n",
+			__func__, (u64)sas_address);
-			ioc->name, __func__, (unsigned long long)sas_address);
 		goto out_fail;
 	}
 	if ((_transport_set_identify(ioc, handle,
 	    &mpt3sas_port->remote_identify))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		goto out_fail;
 	}
 	if (mpt3sas_port->remote_identify.device_type == SAS_PHY_UNUSED) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		goto out_fail;
 	}
 	}
 	if (!mpt3sas_port->num_phys) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		goto out_fail;
 	}
 	if (!sas_node->parent_dev) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		goto out_fail;
 	}
 	port = sas_port_alloc_num(sas_node->parent_dev);
 	if ((sas_port_add(port))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		goto out_fail;
 	}
 		sas_device = mpt3sas_get_sdev_by_addr(ioc,
 				    mpt3sas_port->remote_identify.sas_address);
 		if (!sas_device) {
-			dfailprintk(ioc, printk(MPT3SAS_FMT
+			dfailprintk(ioc,
-				"failure at %s:%d/%s()!\n",
+				    ioc_info(ioc, "failure at %s:%d/%s()!\n",
-				ioc->name, __FILE__, __LINE__, __func__));
+					     __FILE__, __LINE__, __func__));
 			goto out_fail;
 		}
 		sas_device->pend_sas_rphy_add = 1;
 	}
 	if ((sas_rphy_add(rphy))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 	}
 	if (mpt3sas_port->remote_identify.device_type == SAS_END_DEVICE) {
 	INIT_LIST_HEAD(&mpt3sas_phy->port_siblings);
 	phy = sas_phy_alloc(parent_dev, phy_index);
 	if (!phy) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return -1;
 	}
 	if ((_transport_set_identify(ioc, mpt3sas_phy->handle,
 	    &mpt3sas_phy->identify))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		sas_phy_free(phy);
 		return -1;
 	}
 	    phy_pg0.ProgrammedLinkRate >> 4);
 	if ((sas_phy_add(phy))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		sas_phy_free(phy);
 		return -1;
 	}
 	INIT_LIST_HEAD(&mpt3sas_phy->port_siblings);
 	phy = sas_phy_alloc(parent_dev, phy_index);
 	if (!phy) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return -1;
 	}
 	if ((_transport_set_identify(ioc, mpt3sas_phy->handle,
 	    &mpt3sas_phy->identify))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		sas_phy_free(phy);
 		return -1;
 	}
 	    expander_pg1.ProgrammedLinkRate >> 4);
 	if ((sas_phy_add(phy))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		sas_phy_free(phy);
 		return -1;
 	}
 	u16 wait_state_count;
 	if (ioc->shost_recovery || ioc->pci_error_recovery) {
-		pr_info(MPT3SAS_FMT "%s: host reset in progress!\n",
+		ioc_info(ioc, "%s: host reset in progress!\n", __func__);
-		    __func__, ioc->name);
 		return -EFAULT;
 	}
 	mutex_lock(&ioc->transport_cmds.mutex);
 	if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
-		pr_err(MPT3SAS_FMT "%s: transport_cmds in use\n",
+		ioc_err(ioc, "%s: transport_cmds in use\n", __func__);
-		    ioc->name, __func__);
 		rc = -EAGAIN;
 		goto out;
 	}
 	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
 	while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
 		if (wait_state_count++ == 10) {
-			pr_err(MPT3SAS_FMT
+			ioc_err(ioc, "%s: failed due to ioc not operational\n",
-			    "%s: failed due to ioc not operational\n",
+				__func__);
-			    ioc->name, __func__);
 			rc = -EFAULT;
 			goto out;
 		}
 		ssleep(1);
 		ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "%s: waiting for operational state(count=%d)\n",
-			"%s: waiting for operational state(count=%d)\n",
+			 __func__, wait_state_count);
-			ioc->name, __func__, wait_state_count);
 	}
 	if (wait_state_count)
-		pr_info(MPT3SAS_FMT "%s: ioc is operational\n",
+		ioc_info(ioc, "%s: ioc is operational\n", __func__);
-		    ioc->name, __func__);
 	smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
 	if (!smid) {
-		pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
+		ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
-		    ioc->name, __func__);
 		rc = -EAGAIN;
 		goto out;
 	}
 	sz = sizeof(struct phy_error_log_request) +
 	    sizeof(struct phy_error_log_reply);
-	data_out = pci_alloc_consistent(ioc->pdev, sz, &data_out_dma);
+	data_out = dma_alloc_coherent(&ioc->pdev->dev, sz, &data_out_dma,
+			GFP_KERNEL);
 	if (!data_out) {
 		pr_err("failure at %s:%d/%s()!\n", __FILE__,
 		    __LINE__, __func__);
 	    data_out_dma + sizeof(struct phy_error_log_request),
 	    sizeof(struct phy_error_log_reply));
-	dtransportprintk(ioc, pr_info(MPT3SAS_FMT
+	dtransportprintk(ioc,
-		"phy_error_log - send to sas_addr(0x%016llx), phy(%d)\n",
+			 ioc_info(ioc, "phy_error_log - send to sas_addr(0x%016llx), phy(%d)\n",
-		ioc->name, (unsigned long long)phy->identify.sas_address,
+				  (u64)phy->identify.sas_address,
-		phy->number));
+				  phy->number));
 	init_completion(&ioc->transport_cmds.done);
 	mpt3sas_base_put_smid_default(ioc, smid);
 	wait_for_completion_timeout(&ioc->transport_cmds.done, 10*HZ);
 	if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
-		pr_err(MPT3SAS_FMT "%s: timeout\n",
+		ioc_err(ioc, "%s: timeout\n", __func__);
-		    ioc->name, __func__);
 		_debug_dump_mf(mpi_request,
 		    sizeof(Mpi2SmpPassthroughRequest_t)/4);
 		if (!(ioc->transport_cmds.status & MPT3_CMD_RESET))
 		goto issue_host_reset;
 	}
-	dtransportprintk(ioc, pr_info(MPT3SAS_FMT
+	dtransportprintk(ioc, ioc_info(ioc, "phy_error_log - complete\n"));
-		"phy_error_log - complete\n", ioc->name));
 	if (ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID) {
 		mpi_reply = ioc->transport_cmds.reply;
-		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
+		dtransportprintk(ioc,
-		    "phy_error_log - reply data transfer size(%d)\n",
+				 ioc_info(ioc, "phy_error_log - reply data transfer size(%d)\n",
-		    ioc->name, le16_to_cpu(mpi_reply->ResponseDataLength)));
+					  le16_to_cpu(mpi_reply->ResponseDataLength)));
 		if (le16_to_cpu(mpi_reply->ResponseDataLength) !=
 		    sizeof(struct phy_error_log_reply))
 		phy_error_log_reply = data_out +
 		    sizeof(struct phy_error_log_request);
-		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
+		dtransportprintk(ioc,
-		    "phy_error_log - function_result(%d)\n",
+				 ioc_info(ioc, "phy_error_log - function_result(%d)\n",
-		    ioc->name, phy_error_log_reply->function_result));
+					  phy_error_log_reply->function_result));
 		phy->invalid_dword_count =
 		    be32_to_cpu(phy_error_log_reply->invalid_dword);
 		    be32_to_cpu(phy_error_log_reply->phy_reset_problem);
 		rc = 0;
 	} else
-		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
+		dtransportprintk(ioc,
-		    "phy_error_log - no reply\n", ioc->name));
+				 ioc_info(ioc, "phy_error_log - no reply\n"));
  issue_host_reset:
 	if (issue_reset)
  out:
 	ioc->transport_cmds.status = MPT3_CMD_NOT_USED;
 	if (data_out)
-		pci_free_consistent(ioc->pdev, sz, data_out, data_out_dma);
+		dma_free_coherent(&ioc->pdev->dev, sz, data_out, data_out_dma);
 	mutex_unlock(&ioc->transport_cmds.mutex);
 	return rc;
 	/* get hba phy error logs */
 	if ((mpt3sas_config_get_phy_pg1(ioc, &mpi_reply, &phy_pg1,
 		    phy->number))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return -ENXIO;
 	}
 	if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo)
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "phy(%d), ioc_status (0x%04x), loginfo(0x%08x)\n",
-			"phy(%d), ioc_status (0x%04x), loginfo(0x%08x)\n",
+			 phy->number,
-			ioc->name, phy->number,
+			 le16_to_cpu(mpi_reply.IOCStatus),
-			le16_to_cpu(mpi_reply.IOCStatus),
+			 le32_to_cpu(mpi_reply.IOCLogInfo));
-		    le32_to_cpu(mpi_reply.IOCLogInfo));
 	phy->invalid_dword_count = le32_to_cpu(phy_pg1.InvalidDwordCount);
 	phy->running_disparity_error_count =
 	u16 wait_state_count;
 	if (ioc->shost_recovery || ioc->pci_error_recovery) {
-		pr_info(MPT3SAS_FMT "%s: host reset in progress!\n",
+		ioc_info(ioc, "%s: host reset in progress!\n", __func__);
-		    __func__, ioc->name);
 		return -EFAULT;
 	}
 	mutex_lock(&ioc->transport_cmds.mutex);
 	if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
-		pr_err(MPT3SAS_FMT "%s: transport_cmds in use\n",
+		ioc_err(ioc, "%s: transport_cmds in use\n", __func__);
-		    ioc->name, __func__);
 		rc = -EAGAIN;
 		goto out;
 	}
 	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
 	while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
 		if (wait_state_count++ == 10) {
-			pr_err(MPT3SAS_FMT
+			ioc_err(ioc, "%s: failed due to ioc not operational\n",
-			    "%s: failed due to ioc not operational\n",
+				__func__);
-			    ioc->name, __func__);
 			rc = -EFAULT;
 			goto out;
 		}
 		ssleep(1);
 		ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "%s: waiting for operational state(count=%d)\n",
-			"%s: waiting for operational state(count=%d)\n",
+			 __func__, wait_state_count);
-			ioc->name, __func__, wait_state_count);
 	}
 	if (wait_state_count)
-		pr_info(MPT3SAS_FMT "%s: ioc is operational\n",
+		ioc_info(ioc, "%s: ioc is operational\n", __func__);
-		    ioc->name, __func__);
 	smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
 	if (!smid) {
-		pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
+		ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
-		    ioc->name, __func__);
 		rc = -EAGAIN;
 		goto out;
 	}
 	sz = sizeof(struct phy_control_request) +
 	    sizeof(struct phy_control_reply);
-	data_out = pci_alloc_consistent(ioc->pdev, sz, &data_out_dma);
+	data_out = dma_alloc_coherent(&ioc->pdev->dev, sz, &data_out_dma,
+			GFP_KERNEL);
 	if (!data_out) {
 		pr_err("failure at %s:%d/%s()!\n", __FILE__,
 		    __LINE__, __func__);
 	    data_out_dma + sizeof(struct phy_control_request),
 	    sizeof(struct phy_control_reply));
-	dtransportprintk(ioc, pr_info(MPT3SAS_FMT
+	dtransportprintk(ioc,
-		"phy_control - send to sas_addr(0x%016llx), phy(%d), opcode(%d)\n",
+			 ioc_info(ioc, "phy_control - send to sas_addr(0x%016llx), phy(%d), opcode(%d)\n",
-		ioc->name, (unsigned long long)phy->identify.sas_address,
+				  (u64)phy->identify.sas_address,
-		phy->number, phy_operation));
+				  phy->number, phy_operation));
 	init_completion(&ioc->transport_cmds.done);
 	mpt3sas_base_put_smid_default(ioc, smid);
 	wait_for_completion_timeout(&ioc->transport_cmds.done, 10*HZ);
 	if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
-		pr_err(MPT3SAS_FMT "%s: timeout\n",
+		ioc_err(ioc, "%s: timeout\n", __func__);
-		    ioc->name, __func__);
 		_debug_dump_mf(mpi_request,
 		    sizeof(Mpi2SmpPassthroughRequest_t)/4);
 		if (!(ioc->transport_cmds.status & MPT3_CMD_RESET))
 		goto issue_host_reset;
 	}
-	dtransportprintk(ioc, pr_info(MPT3SAS_FMT
+	dtransportprintk(ioc, ioc_info(ioc, "phy_control - complete\n"));
-		"phy_control - complete\n", ioc->name));
 	if (ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID) {
 		mpi_reply = ioc->transport_cmds.reply;
-		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
+		dtransportprintk(ioc,
-		    "phy_control - reply data transfer size(%d)\n",
+				 ioc_info(ioc, "phy_control - reply data transfer size(%d)\n",
-		    ioc->name, le16_to_cpu(mpi_reply->ResponseDataLength)));
+					  le16_to_cpu(mpi_reply->ResponseDataLength)));
 		if (le16_to_cpu(mpi_reply->ResponseDataLength) !=
 		    sizeof(struct phy_control_reply))
 		phy_control_reply = data_out +
 		    sizeof(struct phy_control_request);
-		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
+		dtransportprintk(ioc,
-		    "phy_control - function_result(%d)\n",
+				 ioc_info(ioc, "phy_control - function_result(%d)\n",
-		    ioc->name, phy_control_reply->function_result));
+					  phy_control_reply->function_result));
 		rc = 0;
 	} else
-		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
+		dtransportprintk(ioc,
-		    "phy_control - no reply\n", ioc->name));
+				 ioc_info(ioc, "phy_control - no reply\n"));
  issue_host_reset:
 	if (issue_reset)
  out:
 	ioc->transport_cmds.status = MPT3_CMD_NOT_USED;
 	if (data_out)
-		pci_free_consistent(ioc->pdev, sz, data_out, data_out_dma);
+		dma_free_coherent(&ioc->pdev->dev, sz, data_out,
+				data_out_dma);
 	mutex_unlock(&ioc->transport_cmds.mutex);
 	return rc;
 	mpi_request.PhyNum = phy->number;
 	if ((mpt3sas_base_sas_iounit_control(ioc, &mpi_reply, &mpi_request))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		return -ENXIO;
 	}
 	if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo)
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "phy(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
-		"phy(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
+			 phy->number, le16_to_cpu(mpi_reply.IOCStatus),
-		ioc->name, phy->number, le16_to_cpu(mpi_reply.IOCStatus),
+			 le32_to_cpu(mpi_reply.IOCLogInfo));
-		    le32_to_cpu(mpi_reply.IOCLogInfo));
 	return 0;
 }
 	    sizeof(Mpi2SasIOUnit0PhyData_t));
 	sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
 	if (!sas_iounit_pg0) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		rc = -ENOMEM;
 		goto out;
 	}
 	if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
 	    sas_iounit_pg0, sz))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		rc = -ENXIO;
 		goto out;
 	}
 	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 	    MPI2_IOCSTATUS_MASK;
 	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		rc = -EIO;
 		goto out;
 	}
 	for (i = 0, discovery_active = 0; i < ioc->sas_hba.num_phys ; i++) {
 		if (sas_iounit_pg0->PhyData[i].PortFlags &
 		    MPI2_SASIOUNIT0_PORTFLAGS_DISCOVERY_IN_PROGRESS) {
-			pr_err(MPT3SAS_FMT "discovery is active on " \
+			ioc_err(ioc, "discovery is active on port = %d, phy = %d: unable to enable/disable phys, try again later!\n",
-			    "port = %d, phy = %d: unable to enable/disable "
+				sas_iounit_pg0->PhyData[i].Port, i);
-			    "phys, try again later!\n", ioc->name,
-			    sas_iounit_pg0->PhyData[i].Port, i);
 			discovery_active = 1;
 		}
 	}
 	    sizeof(Mpi2SasIOUnit1PhyData_t));
 	sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
 	if (!sas_iounit_pg1) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		rc = -ENOMEM;
 		goto out;
 	}
 	if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
 	    sas_iounit_pg1, sz))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		rc = -ENXIO;
 		goto out;
 	}
 	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 	    MPI2_IOCSTATUS_MASK;
 	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		rc = -EIO;
 		goto out;
 	}
 	    sizeof(Mpi2SasIOUnit1PhyData_t));
 	sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
 	if (!sas_iounit_pg1) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		rc = -ENOMEM;
 		goto out;
 	}
 	if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
 	    sas_iounit_pg1, sz))) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		rc = -ENXIO;
 		goto out;
 	}
 	ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
 	    MPI2_IOCSTATUS_MASK;
 	if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		rc = -EIO;
 		goto out;
 	}
 	if (mpt3sas_config_set_sas_iounit_pg1(ioc, &mpi_reply, sas_iounit_pg1,
 	    sz)) {
-		pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n",
+		ioc_err(ioc, "failure at %s:%d/%s()!\n",
-		    ioc->name, __FILE__, __LINE__, __func__);
+			__FILE__, __LINE__, __func__);
 		rc = -ENXIO;
 		goto out;
 	}
 	unsigned int reslen = 0;
 	if (ioc->shost_recovery || ioc->pci_error_recovery) {
-		pr_info(MPT3SAS_FMT "%s: host reset in progress!\n",
+		ioc_info(ioc, "%s: host reset in progress!\n", __func__);
-		    __func__, ioc->name);
 		rc = -EFAULT;
 		goto job_done;
 	}
 		goto job_done;
 	if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
-		pr_err(MPT3SAS_FMT "%s: transport_cmds in use\n", ioc->name,
+		ioc_err(ioc, "%s: transport_cmds in use\n",
-		    __func__);
+			__func__);
 		rc = -EAGAIN;
 		goto out;
 	}
 	ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
 	while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
 		if (wait_state_count++ == 10) {
-			pr_err(MPT3SAS_FMT
+			ioc_err(ioc, "%s: failed due to ioc not operational\n",
-			    "%s: failed due to ioc not operational\n",
+				__func__);
-			    ioc->name, __func__);
 			rc = -EFAULT;
 			goto unmap_in;
 		}
 		ssleep(1);
 		ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
-		pr_info(MPT3SAS_FMT
+		ioc_info(ioc, "%s: waiting for operational state(count=%d)\n",
-			"%s: waiting for operational state(count=%d)\n",
+			 __func__, wait_state_count);
-			ioc->name, __func__, wait_state_count);
 	}
 	if (wait_state_count)
-		pr_info(MPT3SAS_FMT "%s: ioc is operational\n",
+		ioc_info(ioc, "%s: ioc is operational\n", __func__);
-		    ioc->name, __func__);
 	smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
 	if (!smid) {
-		pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
+		ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
-		    ioc->name, __func__);
 		rc = -EAGAIN;
 		goto unmap_in;
 	}
 	ioc->build_sg(ioc, psge, dma_addr_out, dma_len_out - 4, dma_addr_in,
 			dma_len_in - 4);
-	dtransportprintk(ioc, pr_info(MPT3SAS_FMT
+	dtransportprintk(ioc,
-		"%s - sending smp request\n", ioc->name, __func__));
+			 ioc_info(ioc, "%s: sending smp request\n", __func__));
 	init_completion(&ioc->transport_cmds.done);
 	mpt3sas_base_put_smid_default(ioc, smid);
 	wait_for_completion_timeout(&ioc->transport_cmds.done, 10*HZ);
 	if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
-		pr_err(MPT3SAS_FMT "%s : timeout\n",
+		ioc_err(ioc, "%s: timeout\n", __func__);
-		    __func__, ioc->name);
 		_debug_dump_mf(mpi_request,
 		    sizeof(Mpi2SmpPassthroughRequest_t)/4);
 		if (!(ioc->transport_cmds.status & MPT3_CMD_RESET)) {
 		}
 	}
-	dtransportprintk(ioc, pr_info(MPT3SAS_FMT
+	dtransportprintk(ioc, ioc_info(ioc, "%s - complete\n", __func__));
-		"%s - complete\n", ioc->name, __func__));
 	if (!(ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID)) {
-		dtransportprintk(ioc, pr_info(MPT3SAS_FMT
+		dtransportprintk(ioc,
-		    "%s - no reply\n", ioc->name, __func__));
+				 ioc_info(ioc, "%s: no reply\n", __func__));
 		rc = -ENXIO;
 		goto unmap_in;
 	}
 	mpi_reply = ioc->transport_cmds.reply;
 	dtransportprintk(ioc,
-		pr_info(MPT3SAS_FMT "%s - reply data transfer size(%d)\n",
+			 ioc_info(ioc, "%s: reply data transfer size(%d)\n",
-			ioc->name, __func__,
+				  __func__,
-			le16_to_cpu(mpi_reply->ResponseDataLength)));
+				  le16_to_cpu(mpi_reply->ResponseDataLength)));
 	memcpy(job->reply, mpi_reply, sizeof(*mpi_reply));
 	job->reply_len = sizeof(*mpi_reply);

drivers/scsi/mpt3sas/mpt3sas_trigger_diag.c+50−51

 	u16 sz, event_data_sz;
 	unsigned long flags;
-	dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n",
+	dTriggerDiagPrintk(ioc, ioc_info(ioc, "%s: enter\n", __func__));
-	    ioc->name, __func__));
 	sz = offsetof(Mpi2EventNotificationReply_t, EventData) +
 	    sizeof(struct SL_WH_TRIGGERS_EVENT_DATA_T) + 4;
 	mpi_reply->EventDataLength = cpu_to_le16(event_data_sz);
 	memcpy(&mpi_reply->EventData, event_data,
 	    sizeof(struct SL_WH_TRIGGERS_EVENT_DATA_T));
-	dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT
+	dTriggerDiagPrintk(ioc,
-		"%s: add to driver event log\n",
+			   ioc_info(ioc, "%s: add to driver event log\n",
-		ioc->name, __func__));
+				    __func__));
 	mpt3sas_ctl_add_to_event_log(ioc, mpi_reply);
 	kfree(mpi_reply);
  out:
 	/* clearing the diag_trigger_active flag */
 	spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
-	dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT
+	dTriggerDiagPrintk(ioc,
-		"%s: clearing diag_trigger_active flag\n",
+			   ioc_info(ioc, "%s: clearing diag_trigger_active flag\n",
-		ioc->name, __func__));
+				    __func__));
 	ioc->diag_trigger_active = 0;
 	spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags);
-	dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT "%s: exit\n", ioc->name,
+	dTriggerDiagPrintk(ioc, ioc_info(ioc, "%s: exit\n",
-	    __func__));
+					 __func__));
 }
 /**
 {
 	u8 issue_reset = 0;
-	dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n",
+	dTriggerDiagPrintk(ioc, ioc_info(ioc, "%s: enter\n", __func__));
-	    ioc->name, __func__));
 	/* release the diag buffer trace */
 	if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
 	    MPT3_DIAG_BUFFER_IS_RELEASED) == 0) {
-		dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT
+		dTriggerDiagPrintk(ioc,
-		"%s: release trace diag buffer\n", ioc->name, __func__));
+				   ioc_info(ioc, "%s: release trace diag buffer\n",
+					    __func__));
 		mpt3sas_send_diag_release(ioc, MPI2_DIAG_BUF_TYPE_TRACE,
 		    &issue_reset);
 	}
 	_mpt3sas_raise_sigio(ioc, event_data);
-	dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT "%s: exit\n", ioc->name,
+	dTriggerDiagPrintk(ioc, ioc_info(ioc, "%s: exit\n",
-	    __func__));
+					 __func__));
 }
 /**
  by_pass_checks:
-	dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT
+	dTriggerDiagPrintk(ioc,
-		"%s: enter - trigger_bitmask = 0x%08x\n",
+			   ioc_info(ioc, "%s: enter - trigger_bitmask = 0x%08x\n",
-		ioc->name, __func__, trigger_bitmask));
+				    __func__, trigger_bitmask));
 	/* don't send trigger if an trigger is currently active */
 	if (ioc->diag_trigger_active) {
 	if (ioc->diag_trigger_master.MasterData & trigger_bitmask) {
 		found_match = 1;
 		ioc->diag_trigger_active = 1;
-		dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT
+		dTriggerDiagPrintk(ioc,
-		"%s: setting diag_trigger_active flag\n",
+				   ioc_info(ioc, "%s: setting diag_trigger_active flag\n",
-		ioc->name, __func__));
+					    __func__));
 	}
 	spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags);
 		mpt3sas_send_trigger_data_event(ioc, &event_data);
  out:
-	dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT "%s: exit\n", ioc->name,
+	dTriggerDiagPrintk(ioc, ioc_info(ioc, "%s: exit\n",
-	    __func__));
+					 __func__));
 }
 /**
 		return;
 	}
-	dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT
+	dTriggerDiagPrintk(ioc,
-		"%s: enter - event = 0x%04x, log_entry_qualifier = 0x%04x\n",
+			   ioc_info(ioc, "%s: enter - event = 0x%04x, log_entry_qualifier = 0x%04x\n",
-		ioc->name, __func__, event, log_entry_qualifier));
+				    __func__, event, log_entry_qualifier));
 	/* don't send trigger if an trigger is currently active */
 	if (ioc->diag_trigger_active) {
 		}
 		found_match = 1;
 		ioc->diag_trigger_active = 1;
-		dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT
+		dTriggerDiagPrintk(ioc,
-			"%s: setting diag_trigger_active flag\n",
+				   ioc_info(ioc, "%s: setting diag_trigger_active flag\n",
-			ioc->name, __func__));
+					    __func__));
 	}
 	spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags);
 	if (!found_match)
 		goto out;
-	dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT
+	dTriggerDiagPrintk(ioc,
-		"%s: setting diag_trigger_active flag\n",
+			   ioc_info(ioc, "%s: setting diag_trigger_active flag\n",
-		ioc->name, __func__));
+				    __func__));
 	memset(&event_data, 0, sizeof(struct SL_WH_TRIGGERS_EVENT_DATA_T));
 	event_data.trigger_type = MPT3SAS_TRIGGER_EVENT;
 	event_data.u.event.EventValue = event;
 	event_data.u.event.LogEntryQualifier = log_entry_qualifier;
 	mpt3sas_send_trigger_data_event(ioc, &event_data);
  out:
-	dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT "%s: exit\n", ioc->name,
+	dTriggerDiagPrintk(ioc, ioc_info(ioc, "%s: exit\n",
-	    __func__));
+					 __func__));
 }
 /**
 		return;
 	}
-	dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT
+	dTriggerDiagPrintk(ioc,
-		"%s: enter - sense_key = 0x%02x, asc = 0x%02x, ascq = 0x%02x\n",
+			   ioc_info(ioc, "%s: enter - sense_key = 0x%02x, asc = 0x%02x, ascq = 0x%02x\n",
-		ioc->name, __func__, sense_key, asc, ascq));
+				    __func__, sense_key, asc, ascq));
 	/* don't send trigger if an trigger is currently active */
 	if (ioc->diag_trigger_active) {
 	if (!found_match)
 		goto out;
-	dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT
+	dTriggerDiagPrintk(ioc,
-		"%s: setting diag_trigger_active flag\n",
+			   ioc_info(ioc, "%s: setting diag_trigger_active flag\n",
-		ioc->name, __func__));
+				    __func__));
 	memset(&event_data, 0, sizeof(struct SL_WH_TRIGGERS_EVENT_DATA_T));
 	event_data.trigger_type = MPT3SAS_TRIGGER_SCSI;
 	event_data.u.scsi.SenseKey = sense_key;
 	event_data.u.scsi.ASCQ = ascq;
 	mpt3sas_send_trigger_data_event(ioc, &event_data);
  out:
-	dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT "%s: exit\n", ioc->name,
+	dTriggerDiagPrintk(ioc, ioc_info(ioc, "%s: exit\n",
-	    __func__));
+					 __func__));
 }
 /**
 		return;
 	}
-	dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT
+	dTriggerDiagPrintk(ioc,
-		"%s: enter - ioc_status = 0x%04x, loginfo = 0x%08x\n",
+			   ioc_info(ioc, "%s: enter - ioc_status = 0x%04x, loginfo = 0x%08x\n",
-		ioc->name, __func__, ioc_status, loginfo));
+				    __func__, ioc_status, loginfo));
 	/* don't send trigger if an trigger is currently active */
 	if (ioc->diag_trigger_active) {
 	if (!found_match)
 		goto out;
-	dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT
+	dTriggerDiagPrintk(ioc,
-		"%s: setting diag_trigger_active flag\n",
+			   ioc_info(ioc, "%s: setting diag_trigger_active flag\n",
-		ioc->name, __func__));
+				    __func__));
 	memset(&event_data, 0, sizeof(struct SL_WH_TRIGGERS_EVENT_DATA_T));
 	event_data.trigger_type = MPT3SAS_TRIGGER_MPI;
 	event_data.u.mpi.IOCStatus = ioc_status;
 	event_data.u.mpi.IocLogInfo = loginfo;
 	mpt3sas_send_trigger_data_event(ioc, &event_data);
  out:
-	dTriggerDiagPrintk(ioc, pr_info(MPT3SAS_FMT "%s: exit\n", ioc->name,
+	dTriggerDiagPrintk(ioc, ioc_info(ioc, "%s: exit\n",
-	    __func__));
+					 __func__));
 }

drivers/scsi/mpt3sas/mpt3sas_warpdrive.c+27−43

 		return;
 	if (ioc->mfg_pg10_hide_flag ==  MFG_PAGE10_EXPOSE_ALL_DISKS) {
-		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
+		ioc_info(ioc, "WarpDrive : Direct IO is disabled globally as drives are exposed\n");
-		    "globally as drives are exposed\n", ioc->name);
 		return;
 	}
 	if (mpt3sas_get_num_volumes(ioc) > 1) {
 		_warpdrive_disable_ddio(ioc);
-		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
+		ioc_info(ioc, "WarpDrive : Direct IO is disabled globally as number of drives > 1\n");
-		    "globally as number of drives > 1\n", ioc->name);
 		return;
 	}
 	if ((mpt3sas_config_get_number_pds(ioc, raid_device->handle,
 	    &num_pds)) || !num_pds) {
-		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
+		ioc_info(ioc, "WarpDrive : Direct IO is disabled Failure in computing number of drives\n");
-		    "Failure in computing number of drives\n", ioc->name);
 		return;
 	}
 	    sizeof(Mpi2RaidVol0PhysDisk_t));
 	vol_pg0 = kzalloc(sz, GFP_KERNEL);
 	if (!vol_pg0) {
-		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
+		ioc_info(ioc, "WarpDrive : Direct IO is disabled Memory allocation failure for RVPG0\n");
-		    "Memory allocation failure for RVPG0\n", ioc->name);
 		return;
 	}
 	if ((mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0,
 	     MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle, sz))) {
-		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
+		ioc_info(ioc, "WarpDrive : Direct IO is disabled Failure in retrieving RVPG0\n");
-		    "Failure in retrieving RVPG0\n", ioc->name);
 		kfree(vol_pg0);
 		return;
 	}
 	 * assumed for WARPDRIVE, disable direct I/O
 	 */
 	if (num_pds > MPT_MAX_WARPDRIVE_PDS) {
-		pr_warn(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
+		ioc_warn(ioc, "WarpDrive : Direct IO is disabled for the drive with handle(0x%04x): num_mem=%d, max_mem_allowed=%d\n",
-		    "for the drive with handle(0x%04x): num_mem=%d, "
+			 raid_device->handle, num_pds, MPT_MAX_WARPDRIVE_PDS);
-		    "max_mem_allowed=%d\n", ioc->name, raid_device->handle,
-		    num_pds, MPT_MAX_WARPDRIVE_PDS);
 		kfree(vol_pg0);
 		return;
 	}
 		    vol_pg0->PhysDisk[count].PhysDiskNum) ||
 		    le16_to_cpu(pd_pg0.DevHandle) ==
 		    MPT3SAS_INVALID_DEVICE_HANDLE) {
-			pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is "
+			ioc_info(ioc, "WarpDrive : Direct IO is disabled for the drive with handle(0x%04x) member handle retrieval failed for member number=%d\n",
-			    "disabled for the drive with handle(0x%04x) member"
+				 raid_device->handle,
-			    "handle retrieval failed for member number=%d\n",
+				 vol_pg0->PhysDisk[count].PhysDiskNum);
-			    ioc->name, raid_device->handle,
-			    vol_pg0->PhysDisk[count].PhysDiskNum);
 			goto out_error;
 		}
 		/* Disable direct I/O if member drive lba exceeds 4 bytes */
 		dev_max_lba = le64_to_cpu(pd_pg0.DeviceMaxLBA);
 		if (dev_max_lba >> 32) {
-			pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is "
+			ioc_info(ioc, "WarpDrive : Direct IO is disabled for the drive with handle(0x%04x) member handle (0x%04x) unsupported max lba 0x%016llx\n",
-			    "disabled for the drive with handle(0x%04x) member"
+				 raid_device->handle,
-			    " handle (0x%04x) unsupported max lba 0x%016llx\n",
+				 le16_to_cpu(pd_pg0.DevHandle),
-			    ioc->name, raid_device->handle,
+				 (u64)dev_max_lba);
-			    le16_to_cpu(pd_pg0.DevHandle),
-			    (unsigned long long)dev_max_lba);
 			goto out_error;
 		}
 	 * not RAID0
 	 */
 	if (raid_device->volume_type != MPI2_RAID_VOL_TYPE_RAID0) {
-		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
+		ioc_info(ioc, "WarpDrive : Direct IO is disabled for the drive with handle(0x%04x): type=%d, s_sz=%uK, blk_size=%u\n",
-		    "for the drive with handle(0x%04x): type=%d, "
+			 raid_device->handle, raid_device->volume_type,
-		    "s_sz=%uK, blk_size=%u\n", ioc->name,
+			 (le32_to_cpu(vol_pg0->StripeSize) *
-		    raid_device->handle, raid_device->volume_type,
+			  le16_to_cpu(vol_pg0->BlockSize)) / 1024,
-		    (le32_to_cpu(vol_pg0->StripeSize) *
+			 le16_to_cpu(vol_pg0->BlockSize));
-		    le16_to_cpu(vol_pg0->BlockSize)) / 1024,
-		    le16_to_cpu(vol_pg0->BlockSize));
 		goto out_error;
 	}
 	stripe_sz = le32_to_cpu(vol_pg0->StripeSize);
 	stripe_exp = find_first_bit(&stripe_sz, 32);
 	if (stripe_exp == 32) {
-		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
+		ioc_info(ioc, "WarpDrive : Direct IO is disabled for the drive with handle(0x%04x) invalid stripe sz %uK\n",
-		"for the drive with handle(0x%04x) invalid stripe sz %uK\n",
+			 raid_device->handle,
-		    ioc->name, raid_device->handle,
+			 (le32_to_cpu(vol_pg0->StripeSize) *
-		    (le32_to_cpu(vol_pg0->StripeSize) *
+			  le16_to_cpu(vol_pg0->BlockSize)) / 1024);
-		    le16_to_cpu(vol_pg0->BlockSize)) / 1024);
 		goto out_error;
 	}
 	raid_device->stripe_exponent = stripe_exp;
 	block_sz = le16_to_cpu(vol_pg0->BlockSize);
 	block_exp = find_first_bit(&block_sz, 16);
 	if (block_exp == 16) {
-		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
+		ioc_info(ioc, "WarpDrive : Direct IO is disabled for the drive with handle(0x%04x) invalid block sz %u\n",
-		    "for the drive with handle(0x%04x) invalid block sz %u\n",
+			 raid_device->handle, le16_to_cpu(vol_pg0->BlockSize));
-		    ioc->name, raid_device->handle,
-		    le16_to_cpu(vol_pg0->BlockSize));
 		goto out_error;
 	}
 	raid_device->block_exponent = block_exp;
 	raid_device->direct_io_enabled = 1;
-	pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is Enabled for the drive"
+	ioc_info(ioc, "WarpDrive : Direct IO is Enabled for the drive with handle(0x%04x)\n",
-	    " with handle(0x%04x)\n", ioc->name, raid_device->handle);
+		 raid_device->handle);
 	/*
 	 * WARPDRIVE: Though the following fields are not used for direct IO,
 	 * stored for future purpose:

drivers/scsi/mvsas/mv_init.c+3−18

@@ -403,29 +403,14 @@ static int pci_go_64(struct pci_dev *pdev) · 402 unmodified lines
403	{	403	{
404	int rc;	404	int rc;
405		405
406	if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {	406	rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
407	rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));	407	if (rc) {
408	if (rc) {	408	rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
409	rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
410	if (rc) {
411	dev_printk(KERN_ERR, &pdev->dev,
412	"64-bit DMA enable failed\n");
413	return rc;
414	}
415	}
416	} else {
417	rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
418	if (rc) {	409	if (rc) {
419	dev_printk(KERN_ERR, &pdev->dev,	410	dev_printk(KERN_ERR, &pdev->dev,
420	"32-bit DMA enable failed\n");	411	"32-bit DMA enable failed\n");
421	return rc;	412	return rc;
422	}	413	}
423	rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
424	if (rc) {
425	dev_printk(KERN_ERR, &pdev->dev,
426	"32-bit consistent DMA enable failed\n");
427	return rc;
428	}
429	}	414	}
430		415
431	return rc;	416	return rc;

drivers/scsi/mvsas/mv_sas.c+6−6

@@ -336,13 +336,13 @@ static int mvs_task_prep_smp(struct mvs_info *mvi, · 335 unmodified lines
336	* DMA-map SMP request, response buffers	336	* DMA-map SMP request, response buffers
337	*/	337	*/
338	sg_req = &task->smp_task.smp_req;	338	sg_req = &task->smp_task.smp_req;
339	elem = dma_map_sg(mvi->dev, sg_req, 1, PCI_DMA_TODEVICE);	339	elem = dma_map_sg(mvi->dev, sg_req, 1, DMA_TO_DEVICE);
340	if (!elem)	340	if (!elem)
341	return -ENOMEM;	341	return -ENOMEM;
342	req_len = sg_dma_len(sg_req);	342	req_len = sg_dma_len(sg_req);
343		343
344	sg_resp = &task->smp_task.smp_resp;	344	sg_resp = &task->smp_task.smp_resp;
345	elem = dma_map_sg(mvi->dev, sg_resp, 1, PCI_DMA_FROMDEVICE);	345	elem = dma_map_sg(mvi->dev, sg_resp, 1, DMA_FROM_DEVICE);
346	if (!elem) {	346	if (!elem) {
347	rc = -ENOMEM;	347	rc = -ENOMEM;
348	goto err_out;	348	goto err_out;
@@ -416,10 +416,10 @@ static int mvs_task_prep_smp(struct mvs_info *mvi, · 67 unmodified lines
416		416
417	err_out_2:	417	err_out_2:
418	dma_unmap_sg(mvi->dev, &tei->task->smp_task.smp_resp, 1,	418	dma_unmap_sg(mvi->dev, &tei->task->smp_task.smp_resp, 1,
419	PCI_DMA_FROMDEVICE);	419	DMA_FROM_DEVICE);
420	err_out:	420	err_out:
421	dma_unmap_sg(mvi->dev, &tei->task->smp_task.smp_req, 1,	421	dma_unmap_sg(mvi->dev, &tei->task->smp_task.smp_req, 1,
422	PCI_DMA_TODEVICE);	422	DMA_TO_DEVICE);
423	return rc;	423	return rc;
424	}	424	}
425		425
@@ -904,9 +904,9 @@ static void mvs_slot_task_free(struct mvs_info mvi, struct sas_task task, · 478 unmodified lines
904	switch (task->task_proto) {	904	switch (task->task_proto) {
905	case SAS_PROTOCOL_SMP:	905	case SAS_PROTOCOL_SMP:
906	dma_unmap_sg(mvi->dev, &task->smp_task.smp_resp, 1,	906	dma_unmap_sg(mvi->dev, &task->smp_task.smp_resp, 1,
907	PCI_DMA_FROMDEVICE);	907	DMA_FROM_DEVICE);
908	dma_unmap_sg(mvi->dev, &task->smp_task.smp_req, 1,	908	dma_unmap_sg(mvi->dev, &task->smp_task.smp_req, 1,
909	PCI_DMA_TODEVICE);	909	DMA_TO_DEVICE);
910	break;	910	break;
911		911
912	case SAS_PROTOCOL_SATA:	912	case SAS_PROTOCOL_SATA:

drivers/scsi/mvumi.c+36−53

@@ -143,8 +143,8 @@ static struct mvumi_res mvumi_alloc_mem_resource(struct mvumi_hba mhba, · 142 unmodified lines
143		143
144	case RESOURCE_UNCACHED_MEMORY:	144	case RESOURCE_UNCACHED_MEMORY:
145	size = round_up(size, 8);	145	size = round_up(size, 8);
146	res->virt_addr = pci_zalloc_consistent(mhba->pdev, size,	146	res->virt_addr = dma_zalloc_coherent(&mhba->pdev->dev, size,
147	&res->bus_addr);	147	&res->bus_addr, GFP_KERNEL);
148	if (!res->virt_addr) {	148	if (!res->virt_addr) {
149	dev_err(&mhba->pdev->dev,	149	dev_err(&mhba->pdev->dev,
150	"unable to allocate consistent mem,"	150	"unable to allocate consistent mem,"
@@ -175,7 +175,7 @@ static void mvumi_release_mem_resource(struct mvumi_hba *mhba) · 24 unmodified lines
175	list_for_each_entry_safe(res, tmp, &mhba->res_list, entry) {	175	list_for_each_entry_safe(res, tmp, &mhba->res_list, entry) {
176	switch (res->type) {	176	switch (res->type) {
177	case RESOURCE_UNCACHED_MEMORY:	177	case RESOURCE_UNCACHED_MEMORY:
178	pci_free_consistent(mhba->pdev, res->size,	178	dma_free_coherent(&mhba->pdev->dev, res->size,
179	res->virt_addr, res->bus_addr);	179	res->virt_addr, res->bus_addr);
180	break;	180	break;
181	case RESOURCE_CACHED_MEMORY:	181	case RESOURCE_CACHED_MEMORY:
@@ -211,14 +211,14 @@ static int mvumi_make_sgl(struct mvumi_hba mhba, struct scsi_cmnd scmd, · 29 unmodified lines
211	dma_addr_t busaddr;	211	dma_addr_t busaddr;
212		212
213	sg = scsi_sglist(scmd);	213	sg = scsi_sglist(scmd);
214	*sg_count = pci_map_sg(mhba->pdev, sg, sgnum,	214	*sg_count = dma_map_sg(&mhba->pdev->dev, sg, sgnum,
215	(int) scmd->sc_data_direction);	215	scmd->sc_data_direction);
216	if (*sg_count > mhba->max_sge) {	216	if (*sg_count > mhba->max_sge) {
217	dev_err(&mhba->pdev->dev,	217	dev_err(&mhba->pdev->dev,
218	"sg count[0x%x] is bigger than max sg[0x%x].\n",	218	"sg count[0x%x] is bigger than max sg[0x%x].\n",
219	*sg_count, mhba->max_sge);	219	*sg_count, mhba->max_sge);
220	pci_unmap_sg(mhba->pdev, sg, sgnum,	220	dma_unmap_sg(&mhba->pdev->dev, sg, sgnum,
221	(int) scmd->sc_data_direction);	221	scmd->sc_data_direction);
222	return -1;	222	return -1;
223	}	223	}
224	for (i = 0; i < *sg_count; i++) {	224	for (i = 0; i < *sg_count; i++) {
@@ -246,7 +246,8 @@ static int mvumi_internal_cmd_sgl(struct mvumi_hba mhba, struct mvumi_cmd cmd, · 21 unmodified lines
246	if (size == 0)	246	if (size == 0)
247	return 0;	247	return 0;
248		248
249	virt_addr = pci_zalloc_consistent(mhba->pdev, size, &phy_addr);	249	virt_addr = dma_zalloc_coherent(&mhba->pdev->dev, size, &phy_addr,
		250	GFP_KERNEL);
250	if (!virt_addr)	251	if (!virt_addr)
251	return -1;	252	return -1;
252		253
@@ -274,8 +275,8 @@ static struct mvumi_cmd mvumi_create_internal_cmd(struct mvumi_hba mhba, · 21 unmodified lines
274	}	275	}
275	INIT_LIST_HEAD(&cmd->queue_pointer);	276	INIT_LIST_HEAD(&cmd->queue_pointer);
276		277
277	cmd->frame = pci_alloc_consistent(mhba->pdev,	278	cmd->frame = dma_alloc_coherent(&mhba->pdev->dev, mhba->ib_max_size,
278	mhba->ib_max_size, &cmd->frame_phys);	279	&cmd->frame_phys, GFP_KERNEL);
279	if (!cmd->frame) {	280	if (!cmd->frame) {
280	dev_err(&mhba->pdev->dev, "failed to allocate memory for FW"	281	dev_err(&mhba->pdev->dev, "failed to allocate memory for FW"
281	" frame,size = %d.\n", mhba->ib_max_size);	282	" frame,size = %d.\n", mhba->ib_max_size);
@@ -287,7 +288,7 @@ static struct mvumi_cmd mvumi_create_internal_cmd(struct mvumi_hba mhba, · 5 unmodified lines
287	if (mvumi_internal_cmd_sgl(mhba, cmd, buf_size)) {	288	if (mvumi_internal_cmd_sgl(mhba, cmd, buf_size)) {
288	dev_err(&mhba->pdev->dev, "failed to allocate memory"	289	dev_err(&mhba->pdev->dev, "failed to allocate memory"
289	" for internal frame\n");	290	" for internal frame\n");
290	pci_free_consistent(mhba->pdev, mhba->ib_max_size,	291	dma_free_coherent(&mhba->pdev->dev, mhba->ib_max_size,
291	cmd->frame, cmd->frame_phys);	292	cmd->frame, cmd->frame_phys);
292	kfree(cmd);	293	kfree(cmd);
293	return NULL;	294	return NULL;
@@ -313,10 +314,10 @@ static void mvumi_delete_internal_cmd(struct mvumi_hba *mhba, · 19 unmodified lines
313	phy_addr = (dma_addr_t) m_sg->baseaddr_l \|	314	phy_addr = (dma_addr_t) m_sg->baseaddr_l \|
314	(dma_addr_t) ((m_sg->baseaddr_h << 16) << 16);	315	(dma_addr_t) ((m_sg->baseaddr_h << 16) << 16);
315		316
316	pci_free_consistent(mhba->pdev, size, cmd->data_buf,	317	dma_free_coherent(&mhba->pdev->dev, size, cmd->data_buf,
317	phy_addr);	318	phy_addr);
318	}	319	}
319	pci_free_consistent(mhba->pdev, mhba->ib_max_size,	320	dma_free_coherent(&mhba->pdev->dev, mhba->ib_max_size,
320	cmd->frame, cmd->frame_phys);	321	cmd->frame, cmd->frame_phys);
321	kfree(cmd);	322	kfree(cmd);
322	}	323	}
@@ -663,16 +664,17 @@ static void mvumi_restore_bar_addr(struct mvumi_hba *mhba) · 340 unmodified lines
663	}	664	}
664	}	665	}
665		666
666	static unsigned int mvumi_pci_set_master(struct pci_dev *pdev)	667	static int mvumi_pci_set_master(struct pci_dev *pdev)
667	{	668	{
668	unsigned int ret = 0;	669	int ret = 0;
		670
669	pci_set_master(pdev);	671	pci_set_master(pdev);
670		672
671	if (IS_DMA64) {	673	if (IS_DMA64) {
672	if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))	674	if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(64)))
673	ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));	675	ret = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
674	} else	676	} else
675	ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));	677	ret = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
676		678
677	return ret;	679	return ret;
678	}	680	}
@@ -771,7 +773,7 @@ static void mvumi_release_fw(struct mvumi_hba *mhba) · 92 unmodified lines
771	mvumi_free_cmds(mhba);	773	mvumi_free_cmds(mhba);
772	mvumi_release_mem_resource(mhba);	774	mvumi_release_mem_resource(mhba);
773	mvumi_unmap_pci_addr(mhba->pdev, mhba->base_addr);	775	mvumi_unmap_pci_addr(mhba->pdev, mhba->base_addr);
774	pci_free_consistent(mhba->pdev, HSP_MAX_SIZE,	776	dma_free_coherent(&mhba->pdev->dev, HSP_MAX_SIZE,
775	mhba->handshake_page, mhba->handshake_page_phys);	777	mhba->handshake_page, mhba->handshake_page_phys);
776	kfree(mhba->regs);	778	kfree(mhba->regs);
777	pci_release_regions(mhba->pdev);	779	pci_release_regions(mhba->pdev);
@@ -1339,9 +1341,9 @@ static void mvumi_complete_cmd(struct mvumi_hba mhba, struct mvumi_cmd cmd, · 561 unmodified lines
1339	}	1341	}
1340		1342
1341	if (scsi_bufflen(scmd))	1343	if (scsi_bufflen(scmd))
1342	pci_unmap_sg(mhba->pdev, scsi_sglist(scmd),	1344	dma_unmap_sg(&mhba->pdev->dev, scsi_sglist(scmd),
1343	scsi_sg_count(scmd),	1345	scsi_sg_count(scmd),
1344	(int) scmd->sc_data_direction);	1346	scmd->sc_data_direction);
1345	cmd->scmd->scsi_done(scmd);	1347	cmd->scmd->scsi_done(scmd);
1346	mvumi_return_cmd(mhba, cmd);	1348	mvumi_return_cmd(mhba, cmd);
1347	}	1349	}
@@ -2148,9 +2150,9 @@ static enum blk_eh_timer_return mvumi_timed_out(struct scsi_cmnd *scmd) · 800 unmodified lines
2148	scmd->result = (DRIVER_INVALID << 24) \| (DID_ABORT << 16);	2150	scmd->result = (DRIVER_INVALID << 24) \| (DID_ABORT << 16);
2149	scmd->SCp.ptr = NULL;	2151	scmd->SCp.ptr = NULL;
2150	if (scsi_bufflen(scmd)) {	2152	if (scsi_bufflen(scmd)) {
2151	pci_unmap_sg(mhba->pdev, scsi_sglist(scmd),	2153	dma_unmap_sg(&mhba->pdev->dev, scsi_sglist(scmd),
2152	scsi_sg_count(scmd),	2154	scsi_sg_count(scmd),
2153	(int)scmd->sc_data_direction);	2155	scmd->sc_data_direction);
2154	}	2156	}
2155	mvumi_return_cmd(mhba, cmd);	2157	mvumi_return_cmd(mhba, cmd);
2156	spin_unlock_irqrestore(mhba->shost->host_lock, flags);	2158	spin_unlock_irqrestore(mhba->shost->host_lock, flags);
@@ -2362,8 +2364,8 @@ static int mvumi_init_fw(struct mvumi_hba *mhba) · 205 unmodified lines
2362	ret = -ENOMEM;	2364	ret = -ENOMEM;
2363	goto fail_alloc_mem;	2365	goto fail_alloc_mem;
2364	}	2366	}
2365	mhba->handshake_page = pci_alloc_consistent(mhba->pdev, HSP_MAX_SIZE,	2367	mhba->handshake_page = dma_alloc_coherent(&mhba->pdev->dev,
2366	&mhba->handshake_page_phys);	2368	HSP_MAX_SIZE, &mhba->handshake_page_phys, GFP_KERNEL);
2367	if (!mhba->handshake_page) {	2369	if (!mhba->handshake_page) {
2368	dev_err(&mhba->pdev->dev,	2370	dev_err(&mhba->pdev->dev,
2369	"failed to allocate memory for handshake\n");	2371	"failed to allocate memory for handshake\n");
@@ -2383,7 +2385,7 @@ static int mvumi_init_fw(struct mvumi_hba *mhba) · 13 unmodified lines
2383		2385
2384	fail_ready_state:	2386	fail_ready_state:
2385	mvumi_release_mem_resource(mhba);	2387	mvumi_release_mem_resource(mhba);
2386	pci_free_consistent(mhba->pdev, HSP_MAX_SIZE,	2388	dma_free_coherent(&mhba->pdev->dev, HSP_MAX_SIZE,
2387	mhba->handshake_page, mhba->handshake_page_phys);	2389	mhba->handshake_page, mhba->handshake_page_phys);
2388	fail_alloc_page:	2390	fail_alloc_page:
2389	kfree(mhba->regs);	2391	kfree(mhba->regs);
@@ -2480,20 +2482,9 @@ static int mvumi_probe_one(struct pci_dev pdev, const struct pci_device_id id) · 90 unmodified lines
2480	if (ret)	2482	if (ret)
2481	return ret;	2483	return ret;
2482		2484
2483	pci_set_master(pdev);	2485	ret = mvumi_pci_set_master(pdev);
2484		2486	if (ret)
2485	if (IS_DMA64) {	2487	goto fail_set_dma_mask;
2486	ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
2487	if (ret) {
2488	ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2489	if (ret)
2490	goto fail_set_dma_mask;
2491	}
2492	} else {
2493	ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2494	if (ret)
2495	goto fail_set_dma_mask;
2496	}
2497		2488
2498	host = scsi_host_alloc(&mvumi_template, sizeof(*mhba));	2489	host = scsi_host_alloc(&mvumi_template, sizeof(*mhba));
2499	if (!host) {	2490	if (!host) {
@@ -2627,19 +2618,11 @@ static int __maybe_unused mvumi_resume(struct pci_dev *pdev) · 127 unmodified lines
2627	dev_err(&pdev->dev, "enable device failed\n");	2618	dev_err(&pdev->dev, "enable device failed\n");
2628	return ret;	2619	return ret;
2629	}	2620	}
2630	pci_set_master(pdev);	2621
2631	if (IS_DMA64) {	2622	ret = mvumi_pci_set_master(pdev);
2632	ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));	2623	ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2633	if (ret) {	2624	if (ret)
2634	ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));	2625	goto fail;
2635	if (ret)
2636	goto fail;
2637	}
2638	} else {
2639	ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2640	if (ret)
2641	goto fail;
2642	}
2643	ret = pci_request_regions(mhba->pdev, MV_DRIVER_NAME);	2626	ret = pci_request_regions(mhba->pdev, MV_DRIVER_NAME);
2644	if (ret)	2627	if (ret)
2645	goto fail;	2628	goto fail;

drivers/scsi/myrb.c+3656−0

@@ -0,0 +1,3656 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Linux Driver for Mylex DAC960/AcceleRAID/eXtremeRAID PCI RAID Controllers
	4	*
	5	* Copyright 2017 Hannes Reinecke, SUSE Linux GmbH <hare@suse.com>
	6	*
	7	* Based on the original DAC960 driver,
	8	* Copyright 1998-2001 by Leonard N. Zubkoff <lnz@dandelion.com>
	9	* Portions Copyright 2002 by Mylex (An IBM Business Unit)
	10	*
	11	*/
	12
	13	#include <linux/module.h>
	14	#include <linux/types.h>
	15	#include <linux/delay.h>
	16	#include <linux/interrupt.h>
	17	#include <linux/pci.h>
	18	#include <linux/raid_class.h>
	19	#include <asm/unaligned.h>
	20	#include <scsi/scsi.h>
	21	#include <scsi/scsi_host.h>
	22	#include <scsi/scsi_device.h>
	23	#include <scsi/scsi_cmnd.h>
	24	#include <scsi/scsi_tcq.h>
	25	#include "myrb.h"
	26
	27	static struct raid_template *myrb_raid_template;
	28
	29	static void myrb_monitor(struct work_struct *work);
	30	static inline void myrb_translate_devstate(void *DeviceState);
	31
	32	static inline int myrb_logical_channel(struct Scsi_Host *shost)
	33	{
	34	return shost->max_channel - 1;
	35	}
	36
	37	static struct myrb_devstate_name_entry {
	38	enum myrb_devstate state;
	39	const char *name;
	40	} myrb_devstate_name_list[] = {
	41	{ MYRB_DEVICE_DEAD, "Dead" },
	42	{ MYRB_DEVICE_WO, "WriteOnly" },
	43	{ MYRB_DEVICE_ONLINE, "Online" },
	44	{ MYRB_DEVICE_CRITICAL, "Critical" },
	45	{ MYRB_DEVICE_STANDBY, "Standby" },
	46	{ MYRB_DEVICE_OFFLINE, "Offline" },
	47	};
	48
	49	static const char *myrb_devstate_name(enum myrb_devstate state)
	50	{
	51	struct myrb_devstate_name_entry *entry = myrb_devstate_name_list;
	52	int i;
	53
	54	for (i = 0; i < ARRAY_SIZE(myrb_devstate_name_list); i++) {
	55	if (entry[i].state == state)
	56	return entry[i].name;
	57	}
	58	return "Unknown";
	59	}
	60
	61	static struct myrb_raidlevel_name_entry {
	62	enum myrb_raidlevel level;
	63	const char *name;
	64	} myrb_raidlevel_name_list[] = {
	65	{ MYRB_RAID_LEVEL0, "RAID0" },
	66	{ MYRB_RAID_LEVEL1, "RAID1" },
	67	{ MYRB_RAID_LEVEL3, "RAID3" },
	68	{ MYRB_RAID_LEVEL5, "RAID5" },
	69	{ MYRB_RAID_LEVEL6, "RAID6" },
	70	{ MYRB_RAID_JBOD, "JBOD" },
	71	};
	72
	73	static const char *myrb_raidlevel_name(enum myrb_raidlevel level)
	74	{
	75	struct myrb_raidlevel_name_entry *entry = myrb_raidlevel_name_list;
	76	int i;
	77
	78	for (i = 0; i < ARRAY_SIZE(myrb_raidlevel_name_list); i++) {
	79	if (entry[i].level == level)
	80	return entry[i].name;
	81	}
	82	return NULL;
	83	}
	84
	85	/**
	86	* myrb_create_mempools - allocates auxiliary data structures
	87	*
	88	* Return: true on success, false otherwise.
	89	*/
	90	static bool myrb_create_mempools(struct pci_dev pdev, struct myrb_hba cb)
	91	{
	92	size_t elem_size, elem_align;
	93
	94	elem_align = sizeof(struct myrb_sge);
	95	elem_size = cb->host->sg_tablesize * elem_align;
	96	cb->sg_pool = dma_pool_create("myrb_sg", &pdev->dev,
	97	elem_size, elem_align, 0);
	98	if (cb->sg_pool == NULL) {
	99	shost_printk(KERN_ERR, cb->host,
	100	"Failed to allocate SG pool\n");
	101	return false;
	102	}
	103
	104	cb->dcdb_pool = dma_pool_create("myrb_dcdb", &pdev->dev,
	105	sizeof(struct myrb_dcdb),
	106	sizeof(unsigned int), 0);
	107	if (!cb->dcdb_pool) {
	108	dma_pool_destroy(cb->sg_pool);
	109	cb->sg_pool = NULL;
	110	shost_printk(KERN_ERR, cb->host,
	111	"Failed to allocate DCDB pool\n");
	112	return false;
	113	}
	114
	115	snprintf(cb->work_q_name, sizeof(cb->work_q_name),
	116	"myrb_wq_%d", cb->host->host_no);
	117	cb->work_q = create_singlethread_workqueue(cb->work_q_name);
	118	if (!cb->work_q) {
	119	dma_pool_destroy(cb->dcdb_pool);
	120	cb->dcdb_pool = NULL;
	121	dma_pool_destroy(cb->sg_pool);
	122	cb->sg_pool = NULL;
	123	shost_printk(KERN_ERR, cb->host,
	124	"Failed to create workqueue\n");
	125	return false;
	126	}
	127
	128	/*
	129	* Initialize the Monitoring Timer.
	130	*/
	131	INIT_DELAYED_WORK(&cb->monitor_work, myrb_monitor);
	132	queue_delayed_work(cb->work_q, &cb->monitor_work, 1);
	133
	134	return true;
	135	}
	136
	137	/**
	138	* myrb_destroy_mempools - tears down the memory pools for the controller
	139	*/
	140	static void myrb_destroy_mempools(struct myrb_hba *cb)
	141	{
	142	cancel_delayed_work_sync(&cb->monitor_work);
	143	destroy_workqueue(cb->work_q);
	144
	145	dma_pool_destroy(cb->sg_pool);
	146	dma_pool_destroy(cb->dcdb_pool);
	147	}
	148
	149	/**
	150	* myrb_reset_cmd - reset command block
	151	*/
	152	static inline void myrb_reset_cmd(struct myrb_cmdblk *cmd_blk)
	153	{
	154	union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
	155
	156	memset(mbox, 0, sizeof(union myrb_cmd_mbox));
	157	cmd_blk->status = 0;
	158	}
	159
	160	/**
	161	* myrb_qcmd - queues command block for execution
	162	*/
	163	static void myrb_qcmd(struct myrb_hba cb, struct myrb_cmdblk cmd_blk)
	164	{
	165	void __iomem *base = cb->io_base;
	166	union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
	167	union myrb_cmd_mbox *next_mbox = cb->next_cmd_mbox;
	168
	169	cb->write_cmd_mbox(next_mbox, mbox);
	170	if (cb->prev_cmd_mbox1->words[0] == 0 \|\|
	171	cb->prev_cmd_mbox2->words[0] == 0)
	172	cb->get_cmd_mbox(base);
	173	cb->prev_cmd_mbox2 = cb->prev_cmd_mbox1;
	174	cb->prev_cmd_mbox1 = next_mbox;
	175	if (++next_mbox > cb->last_cmd_mbox)
	176	next_mbox = cb->first_cmd_mbox;
	177	cb->next_cmd_mbox = next_mbox;
	178	}
	179
	180	/**
	181	* myrb_exec_cmd - executes command block and waits for completion.
	182	*
	183	* Return: command status
	184	*/
	185	static unsigned short myrb_exec_cmd(struct myrb_hba *cb,
	186	struct myrb_cmdblk *cmd_blk)
	187	{
	188	DECLARE_COMPLETION_ONSTACK(cmpl);
	189	unsigned long flags;
	190
	191	cmd_blk->completion = &cmpl;
	192
	193	spin_lock_irqsave(&cb->queue_lock, flags);
	194	cb->qcmd(cb, cmd_blk);
	195	spin_unlock_irqrestore(&cb->queue_lock, flags);
	196
	197	WARN_ON(in_interrupt());
	198	wait_for_completion(&cmpl);
	199	return cmd_blk->status;
	200	}
	201
	202	/**
	203	* myrb_exec_type3 - executes a type 3 command and waits for completion.
	204	*
	205	* Return: command status
	206	*/
	207	static unsigned short myrb_exec_type3(struct myrb_hba *cb,
	208	enum myrb_cmd_opcode op, dma_addr_t addr)
	209	{
	210	struct myrb_cmdblk *cmd_blk = &cb->dcmd_blk;
	211	union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
	212	unsigned short status;
	213
	214	mutex_lock(&cb->dcmd_mutex);
	215	myrb_reset_cmd(cmd_blk);
	216	mbox->type3.id = MYRB_DCMD_TAG;
	217	mbox->type3.opcode = op;
	218	mbox->type3.addr = addr;
	219	status = myrb_exec_cmd(cb, cmd_blk);
	220	mutex_unlock(&cb->dcmd_mutex);
	221	return status;
	222	}
	223
	224	/**
	225	* myrb_exec_type3D - executes a type 3D command and waits for completion.
	226	*
	227	* Return: command status
	228	*/
	229	static unsigned short myrb_exec_type3D(struct myrb_hba *cb,
	230	enum myrb_cmd_opcode op, struct scsi_device *sdev,
	231	struct myrb_pdev_state *pdev_info)
	232	{
	233	struct myrb_cmdblk *cmd_blk = &cb->dcmd_blk;
	234	union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
	235	unsigned short status;
	236	dma_addr_t pdev_info_addr;
	237
	238	pdev_info_addr = dma_map_single(&cb->pdev->dev, pdev_info,
	239	sizeof(struct myrb_pdev_state),
	240	DMA_FROM_DEVICE);
	241	if (dma_mapping_error(&cb->pdev->dev, pdev_info_addr))
	242	return MYRB_STATUS_SUBSYS_FAILED;
	243
	244	mutex_lock(&cb->dcmd_mutex);
	245	myrb_reset_cmd(cmd_blk);
	246	mbox->type3D.id = MYRB_DCMD_TAG;
	247	mbox->type3D.opcode = op;
	248	mbox->type3D.channel = sdev->channel;
	249	mbox->type3D.target = sdev->id;
	250	mbox->type3D.addr = pdev_info_addr;
	251	status = myrb_exec_cmd(cb, cmd_blk);
	252	mutex_unlock(&cb->dcmd_mutex);
	253	dma_unmap_single(&cb->pdev->dev, pdev_info_addr,
	254	sizeof(struct myrb_pdev_state), DMA_FROM_DEVICE);
	255	if (status == MYRB_STATUS_SUCCESS &&
	256	mbox->type3D.opcode == MYRB_CMD_GET_DEVICE_STATE_OLD)
	257	myrb_translate_devstate(pdev_info);
	258
	259	return status;
	260	}
	261
	262	static char *myrb_event_msg[] = {
	263	"killed because write recovery failed",
	264	"killed because of SCSI bus reset failure",
	265	"killed because of double check condition",
	266	"killed because it was removed",
	267	"killed because of gross error on SCSI chip",
	268	"killed because of bad tag returned from drive",
	269	"killed because of timeout on SCSI command",
	270	"killed because of reset SCSI command issued from system",
	271	"killed because busy or parity error count exceeded limit",
	272	"killed because of 'kill drive' command from system",
	273	"killed because of selection timeout",
	274	"killed due to SCSI phase sequence error",
	275	"killed due to unknown status",
	276	};
	277
	278	/**
	279	* myrb_get_event - get event log from HBA
	280	* @cb: pointer to the hba structure
	281	* @event: number of the event
	282	*
	283	* Execute a type 3E command and logs the event message
	284	*/
	285	static void myrb_get_event(struct myrb_hba *cb, unsigned int event)
	286	{
	287	struct myrb_cmdblk *cmd_blk = &cb->mcmd_blk;
	288	union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
	289	struct myrb_log_entry *ev_buf;
	290	dma_addr_t ev_addr;
	291	unsigned short status;
	292
	293	ev_buf = dma_alloc_coherent(&cb->pdev->dev,
	294	sizeof(struct myrb_log_entry),
	295	&ev_addr, GFP_KERNEL);
	296	if (!ev_buf)
	297	return;
	298
	299	myrb_reset_cmd(cmd_blk);
	300	mbox->type3E.id = MYRB_MCMD_TAG;
	301	mbox->type3E.opcode = MYRB_CMD_EVENT_LOG_OPERATION;
	302	mbox->type3E.optype = DAC960_V1_GetEventLogEntry;
	303	mbox->type3E.opqual = 1;
	304	mbox->type3E.ev_seq = event;
	305	mbox->type3E.addr = ev_addr;
	306	status = myrb_exec_cmd(cb, cmd_blk);
	307	if (status != MYRB_STATUS_SUCCESS)
	308	shost_printk(KERN_INFO, cb->host,
	309	"Failed to get event log %d, status %04x\n",
	310	event, status);
	311
	312	else if (ev_buf->seq_num == event) {
	313	struct scsi_sense_hdr sshdr;
	314
	315	memset(&sshdr, 0, sizeof(sshdr));
	316	scsi_normalize_sense(ev_buf->sense, 32, &sshdr);
	317
	318	if (sshdr.sense_key == VENDOR_SPECIFIC &&
	319	sshdr.asc == 0x80 &&
	320	sshdr.ascq < ARRAY_SIZE(myrb_event_msg))
	321	shost_printk(KERN_CRIT, cb->host,
	322	"Physical drive %d:%d: %s\n",
	323	ev_buf->channel, ev_buf->target,
	324	myrb_event_msg[sshdr.ascq]);
	325	else
	326	shost_printk(KERN_CRIT, cb->host,
	327	"Physical drive %d:%d: Sense: %X/%02X/%02X\n",
	328	ev_buf->channel, ev_buf->target,
	329	sshdr.sense_key, sshdr.asc, sshdr.ascq);
	330	}
	331
	332	dma_free_coherent(&cb->pdev->dev, sizeof(struct myrb_log_entry),
	333	ev_buf, ev_addr);
	334	}
	335
	336	/**
	337	* myrb_get_errtable - retrieves the error table from the controller
	338	*
	339	* Executes a type 3 command and logs the error table from the controller.
	340	*/
	341	static void myrb_get_errtable(struct myrb_hba *cb)
	342	{
	343	struct myrb_cmdblk *cmd_blk = &cb->mcmd_blk;
	344	union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
	345	unsigned short status;
	346	struct myrb_error_entry old_table[MYRB_MAX_CHANNELS * MYRB_MAX_TARGETS];
	347
	348	memcpy(&old_table, cb->err_table, sizeof(old_table));
	349
	350	myrb_reset_cmd(cmd_blk);
	351	mbox->type3.id = MYRB_MCMD_TAG;
	352	mbox->type3.opcode = MYRB_CMD_GET_ERROR_TABLE;
	353	mbox->type3.addr = cb->err_table_addr;
	354	status = myrb_exec_cmd(cb, cmd_blk);
	355	if (status == MYRB_STATUS_SUCCESS) {
	356	struct myrb_error_entry *table = cb->err_table;
	357	struct myrb_error_entry new, old;
	358	size_t err_table_offset;
	359	struct scsi_device *sdev;
	360
	361	shost_for_each_device(sdev, cb->host) {
	362	if (sdev->channel >= myrb_logical_channel(cb->host))
	363	continue;
	364	err_table_offset = sdev->channel * MYRB_MAX_TARGETS
	365	+ sdev->id;
	366	new = table + err_table_offset;
	367	old = &old_table[err_table_offset];
	368	if (new->parity_err == old->parity_err &&
	369	new->soft_err == old->soft_err &&
	370	new->hard_err == old->hard_err &&
	371	new->misc_err == old->misc_err)
	372	continue;
	373	sdev_printk(KERN_CRIT, sdev,
	374	"Errors: Parity = %d, Soft = %d, Hard = %d, Misc = %d\n",
	375	new->parity_err, new->soft_err,
	376	new->hard_err, new->misc_err);
	377	}
	378	}
	379	}
	380
	381	/**
	382	* myrb_get_ldev_info - retrieves the logical device table from the controller
	383	*
	384	* Executes a type 3 command and updates the logical device table.
	385	*
	386	* Return: command status
	387	*/
	388	static unsigned short myrb_get_ldev_info(struct myrb_hba *cb)
	389	{
	390	unsigned short status;
	391	int ldev_num, ldev_cnt = cb->enquiry->ldev_count;
	392	struct Scsi_Host *shost = cb->host;
	393
	394	status = myrb_exec_type3(cb, MYRB_CMD_GET_LDEV_INFO,
	395	cb->ldev_info_addr);
	396	if (status != MYRB_STATUS_SUCCESS)
	397	return status;
	398
	399	for (ldev_num = 0; ldev_num < ldev_cnt; ldev_num++) {
	400	struct myrb_ldev_info *old = NULL;
	401	struct myrb_ldev_info *new = cb->ldev_info_buf + ldev_num;
	402	struct scsi_device *sdev;
	403
	404	sdev = scsi_device_lookup(shost, myrb_logical_channel(shost),
	405	ldev_num, 0);
	406	if (!sdev) {
	407	if (new->state == MYRB_DEVICE_OFFLINE)
	408	continue;
	409	shost_printk(KERN_INFO, shost,
	410	"Adding Logical Drive %d in state %s\n",
	411	ldev_num, myrb_devstate_name(new->state));
	412	scsi_add_device(shost, myrb_logical_channel(shost),
	413	ldev_num, 0);
	414	continue;
	415	}
	416	old = sdev->hostdata;
	417	if (new->state != old->state)
	418	shost_printk(KERN_INFO, shost,
	419	"Logical Drive %d is now %s\n",
	420	ldev_num, myrb_devstate_name(new->state));
	421	if (new->wb_enabled != old->wb_enabled)
	422	sdev_printk(KERN_INFO, sdev,
	423	"Logical Drive is now WRITE %s\n",
	424	(new->wb_enabled ? "BACK" : "THRU"));
	425	memcpy(old, new, sizeof(*new));
	426	scsi_device_put(sdev);
	427	}
	428	return status;
	429	}
	430
	431	/**
	432	* myrb_get_rbld_progress - get rebuild progress information
	433	*
	434	* Executes a type 3 command and returns the rebuild progress
	435	* information.
	436	*
	437	* Return: command status
	438	*/
	439	static unsigned short myrb_get_rbld_progress(struct myrb_hba *cb,
	440	struct myrb_rbld_progress *rbld)
	441	{
	442	struct myrb_cmdblk *cmd_blk = &cb->mcmd_blk;
	443	union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
	444	struct myrb_rbld_progress *rbld_buf;
	445	dma_addr_t rbld_addr;
	446	unsigned short status;
	447
	448	rbld_buf = dma_alloc_coherent(&cb->pdev->dev,
	449	sizeof(struct myrb_rbld_progress),
	450	&rbld_addr, GFP_KERNEL);
	451	if (!rbld_buf)
	452	return MYRB_STATUS_RBLD_NOT_CHECKED;
	453
	454	myrb_reset_cmd(cmd_blk);
	455	mbox->type3.id = MYRB_MCMD_TAG;
	456	mbox->type3.opcode = MYRB_CMD_GET_REBUILD_PROGRESS;
	457	mbox->type3.addr = rbld_addr;
	458	status = myrb_exec_cmd(cb, cmd_blk);
	459	if (rbld)
	460	memcpy(rbld, rbld_buf, sizeof(struct myrb_rbld_progress));
	461	dma_free_coherent(&cb->pdev->dev, sizeof(struct myrb_rbld_progress),
	462	rbld_buf, rbld_addr);
	463	return status;
	464	}
	465
	466	/**
	467	* myrb_update_rbld_progress - updates the rebuild status
	468	*
	469	* Updates the rebuild status for the attached logical devices.
	470	*
	471	*/
	472	static void myrb_update_rbld_progress(struct myrb_hba *cb)
	473	{
	474	struct myrb_rbld_progress rbld_buf;
	475	unsigned short status;
	476
	477	status = myrb_get_rbld_progress(cb, &rbld_buf);
	478	if (status == MYRB_NO_STDBY_RBLD_OR_CHECK_IN_PROGRESS &&
	479	cb->last_rbld_status == MYRB_STATUS_SUCCESS)
	480	status = MYRB_STATUS_RBLD_SUCCESS;
	481	if (status != MYRB_NO_STDBY_RBLD_OR_CHECK_IN_PROGRESS) {
	482	unsigned int blocks_done =
	483	rbld_buf.ldev_size - rbld_buf.blocks_left;
	484	struct scsi_device *sdev;
	485
	486	sdev = scsi_device_lookup(cb->host,
	487	myrb_logical_channel(cb->host),
	488	rbld_buf.ldev_num, 0);
	489	if (!sdev)
	490	return;
	491
	492	switch (status) {
	493	case MYRB_STATUS_SUCCESS:
	494	sdev_printk(KERN_INFO, sdev,
	495	"Rebuild in Progress, %d%% completed\n",
	496	(100 * (blocks_done >> 7))
	497	/ (rbld_buf.ldev_size >> 7));
	498	break;
	499	case MYRB_STATUS_RBLD_FAILED_LDEV_FAILURE:
	500	sdev_printk(KERN_INFO, sdev,
	501	"Rebuild Failed due to Logical Drive Failure\n");
	502	break;
	503	case MYRB_STATUS_RBLD_FAILED_BADBLOCKS:
	504	sdev_printk(KERN_INFO, sdev,
	505	"Rebuild Failed due to Bad Blocks on Other Drives\n");
	506	break;
	507	case MYRB_STATUS_RBLD_FAILED_NEW_DRIVE_FAILED:
	508	sdev_printk(KERN_INFO, sdev,
	509	"Rebuild Failed due to Failure of Drive Being Rebuilt\n");
	510	break;
	511	case MYRB_STATUS_RBLD_SUCCESS:
	512	sdev_printk(KERN_INFO, sdev,
	513	"Rebuild Completed Successfully\n");
	514	break;
	515	case MYRB_STATUS_RBLD_SUCCESS_TERMINATED:
	516	sdev_printk(KERN_INFO, sdev,
	517	"Rebuild Successfully Terminated\n");
	518	break;
	519	default:
	520	break;
	521	}
	522	scsi_device_put(sdev);
	523	}
	524	cb->last_rbld_status = status;
	525	}
	526
	527	/**
	528	* myrb_get_cc_progress - retrieve the rebuild status
	529	*
	530	* Execute a type 3 Command and fetch the rebuild / consistency check
	531	* status.
	532	*/
	533	static void myrb_get_cc_progress(struct myrb_hba *cb)
	534	{
	535	struct myrb_cmdblk *cmd_blk = &cb->mcmd_blk;
	536	union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
	537	struct myrb_rbld_progress *rbld_buf;
	538	dma_addr_t rbld_addr;
	539	unsigned short status;
	540
	541	rbld_buf = dma_alloc_coherent(&cb->pdev->dev,
	542	sizeof(struct myrb_rbld_progress),
	543	&rbld_addr, GFP_KERNEL);
	544	if (!rbld_buf) {
	545	cb->need_cc_status = true;
	546	return;
	547	}
	548	myrb_reset_cmd(cmd_blk);
	549	mbox->type3.id = MYRB_MCMD_TAG;
	550	mbox->type3.opcode = MYRB_CMD_REBUILD_STAT;
	551	mbox->type3.addr = rbld_addr;
	552	status = myrb_exec_cmd(cb, cmd_blk);
	553	if (status == MYRB_STATUS_SUCCESS) {
	554	unsigned int ldev_num = rbld_buf->ldev_num;
	555	unsigned int ldev_size = rbld_buf->ldev_size;
	556	unsigned int blocks_done =
	557	ldev_size - rbld_buf->blocks_left;
	558	struct scsi_device *sdev;
	559
	560	sdev = scsi_device_lookup(cb->host,
	561	myrb_logical_channel(cb->host),
	562	ldev_num, 0);
	563	if (sdev) {
	564	sdev_printk(KERN_INFO, sdev,
	565	"Consistency Check in Progress: %d%% completed\n",
	566	(100 * (blocks_done >> 7))
	567	/ (ldev_size >> 7));
	568	scsi_device_put(sdev);
	569	}
	570	}
	571	dma_free_coherent(&cb->pdev->dev, sizeof(struct myrb_rbld_progress),
	572	rbld_buf, rbld_addr);
	573	}
	574
	575	/**
	576	* myrb_bgi_control - updates background initialisation status
	577	*
	578	* Executes a type 3B command and updates the background initialisation status
	579	*/
	580	static void myrb_bgi_control(struct myrb_hba *cb)
	581	{
	582	struct myrb_cmdblk *cmd_blk = &cb->mcmd_blk;
	583	union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
	584	struct myrb_bgi_status bgi, last_bgi;
	585	dma_addr_t bgi_addr;
	586	struct scsi_device *sdev = NULL;
	587	unsigned short status;
	588
	589	bgi = dma_alloc_coherent(&cb->pdev->dev, sizeof(struct myrb_bgi_status),
	590	&bgi_addr, GFP_KERNEL);
	591	if (!bgi) {
	592	shost_printk(KERN_ERR, cb->host,
	593	"Failed to allocate bgi memory\n");
	594	return;
	595	}
	596	myrb_reset_cmd(cmd_blk);
	597	mbox->type3B.id = MYRB_DCMD_TAG;
	598	mbox->type3B.opcode = MYRB_CMD_BGI_CONTROL;
	599	mbox->type3B.optype = 0x20;
	600	mbox->type3B.addr = bgi_addr;
	601	status = myrb_exec_cmd(cb, cmd_blk);
	602	last_bgi = &cb->bgi_status;
	603	sdev = scsi_device_lookup(cb->host,
	604	myrb_logical_channel(cb->host),
	605	bgi->ldev_num, 0);
	606	switch (status) {
	607	case MYRB_STATUS_SUCCESS:
	608	switch (bgi->status) {
	609	case MYRB_BGI_INVALID:
	610	break;
	611	case MYRB_BGI_STARTED:
	612	if (!sdev)
	613	break;
	614	sdev_printk(KERN_INFO, sdev,
	615	"Background Initialization Started\n");
	616	break;
	617	case MYRB_BGI_INPROGRESS:
	618	if (!sdev)
	619	break;
	620	if (bgi->blocks_done == last_bgi->blocks_done &&
	621	bgi->ldev_num == last_bgi->ldev_num)
	622	break;
	623	sdev_printk(KERN_INFO, sdev,
	624	"Background Initialization in Progress: %d%% completed\n",
	625	(100 * (bgi->blocks_done >> 7))
	626	/ (bgi->ldev_size >> 7));
	627	break;
	628	case MYRB_BGI_SUSPENDED:
	629	if (!sdev)
	630	break;
	631	sdev_printk(KERN_INFO, sdev,
	632	"Background Initialization Suspended\n");
	633	break;
	634	case MYRB_BGI_CANCELLED:
	635	if (!sdev)
	636	break;
	637	sdev_printk(KERN_INFO, sdev,
	638	"Background Initialization Cancelled\n");
	639	break;
	640	}
	641	memcpy(&cb->bgi_status, bgi, sizeof(struct myrb_bgi_status));
	642	break;
	643	case MYRB_STATUS_BGI_SUCCESS:
	644	if (sdev && cb->bgi_status.status == MYRB_BGI_INPROGRESS)
	645	sdev_printk(KERN_INFO, sdev,
	646	"Background Initialization Completed Successfully\n");
	647	cb->bgi_status.status = MYRB_BGI_INVALID;
	648	break;
	649	case MYRB_STATUS_BGI_ABORTED:
	650	if (sdev && cb->bgi_status.status == MYRB_BGI_INPROGRESS)
	651	sdev_printk(KERN_INFO, sdev,
	652	"Background Initialization Aborted\n");
	653	/* Fallthrough */
	654	case MYRB_STATUS_NO_BGI_INPROGRESS:
	655	cb->bgi_status.status = MYRB_BGI_INVALID;
	656	break;
	657	}
	658	if (sdev)
	659	scsi_device_put(sdev);
	660	dma_free_coherent(&cb->pdev->dev, sizeof(struct myrb_bgi_status),
	661	bgi, bgi_addr);
	662	}
	663
	664	/**
	665	* myrb_hba_enquiry - updates the controller status
	666	*
	667	* Executes a DAC_V1_Enquiry command and updates the controller status.
	668	*
	669	* Return: command status
	670	*/
	671	static unsigned short myrb_hba_enquiry(struct myrb_hba *cb)
	672	{
	673	struct myrb_enquiry old, *new;
	674	unsigned short status;
	675
	676	memcpy(&old, cb->enquiry, sizeof(struct myrb_enquiry));
	677
	678	status = myrb_exec_type3(cb, MYRB_CMD_ENQUIRY, cb->enquiry_addr);
	679	if (status != MYRB_STATUS_SUCCESS)
	680	return status;
	681
	682	new = cb->enquiry;
	683	if (new->ldev_count > old.ldev_count) {
	684	int ldev_num = old.ldev_count - 1;
	685
	686	while (++ldev_num < new->ldev_count)
	687	shost_printk(KERN_CRIT, cb->host,
	688	"Logical Drive %d Now Exists\n",
	689	ldev_num);
	690	}
	691	if (new->ldev_count < old.ldev_count) {
	692	int ldev_num = new->ldev_count - 1;
	693
	694	while (++ldev_num < old.ldev_count)
	695	shost_printk(KERN_CRIT, cb->host,
	696	"Logical Drive %d No Longer Exists\n",
	697	ldev_num);
	698	}
	699	if (new->status.deferred != old.status.deferred)
	700	shost_printk(KERN_CRIT, cb->host,
	701	"Deferred Write Error Flag is now %s\n",
	702	(new->status.deferred ? "TRUE" : "FALSE"));
	703	if (new->ev_seq != old.ev_seq) {
	704	cb->new_ev_seq = new->ev_seq;
	705	cb->need_err_info = true;
	706	shost_printk(KERN_INFO, cb->host,
	707	"Event log %d/%d (%d/%d) available\n",
	708	cb->old_ev_seq, cb->new_ev_seq,
	709	old.ev_seq, new->ev_seq);
	710	}
	711	if ((new->ldev_critical > 0 &&
	712	new->ldev_critical != old.ldev_critical) \|\|
	713	(new->ldev_offline > 0 &&
	714	new->ldev_offline != old.ldev_offline) \|\|
	715	(new->ldev_count != old.ldev_count)) {
	716	shost_printk(KERN_INFO, cb->host,
	717	"Logical drive count changed (%d/%d/%d)\n",
	718	new->ldev_critical,
	719	new->ldev_offline,
	720	new->ldev_count);
	721	cb->need_ldev_info = true;
	722	}
	723	if (new->pdev_dead > 0 \|\|
	724	new->pdev_dead != old.pdev_dead \|\|
	725	time_after_eq(jiffies, cb->secondary_monitor_time
	726	+ MYRB_SECONDARY_MONITOR_INTERVAL)) {
	727	cb->need_bgi_status = cb->bgi_status_supported;
	728	cb->secondary_monitor_time = jiffies;
	729	}
	730	if (new->rbld == MYRB_STDBY_RBLD_IN_PROGRESS \|\|
	731	new->rbld == MYRB_BG_RBLD_IN_PROGRESS \|\|
	732	old.rbld == MYRB_STDBY_RBLD_IN_PROGRESS \|\|
	733	old.rbld == MYRB_BG_RBLD_IN_PROGRESS) {
	734	cb->need_rbld = true;
	735	cb->rbld_first = (new->ldev_critical < old.ldev_critical);
	736	}
	737	if (old.rbld == MYRB_BG_CHECK_IN_PROGRESS)
	738	switch (new->rbld) {
	739	case MYRB_NO_STDBY_RBLD_OR_CHECK_IN_PROGRESS:
	740	shost_printk(KERN_INFO, cb->host,
	741	"Consistency Check Completed Successfully\n");
	742	break;
	743	case MYRB_STDBY_RBLD_IN_PROGRESS:
	744	case MYRB_BG_RBLD_IN_PROGRESS:
	745	break;
	746	case MYRB_BG_CHECK_IN_PROGRESS:
	747	cb->need_cc_status = true;
	748	break;
	749	case MYRB_STDBY_RBLD_COMPLETED_WITH_ERROR:
	750	shost_printk(KERN_INFO, cb->host,
	751	"Consistency Check Completed with Error\n");
	752	break;
	753	case MYRB_BG_RBLD_OR_CHECK_FAILED_DRIVE_FAILED:
	754	shost_printk(KERN_INFO, cb->host,
	755	"Consistency Check Failed - Physical Device Failed\n");
	756	break;
	757	case MYRB_BG_RBLD_OR_CHECK_FAILED_LDEV_FAILED:
	758	shost_printk(KERN_INFO, cb->host,
	759	"Consistency Check Failed - Logical Drive Failed\n");
	760	break;
	761	case MYRB_BG_RBLD_OR_CHECK_FAILED_OTHER:
	762	shost_printk(KERN_INFO, cb->host,
	763	"Consistency Check Failed - Other Causes\n");
	764	break;
	765	case MYRB_BG_RBLD_OR_CHECK_SUCCESS_TERMINATED:
	766	shost_printk(KERN_INFO, cb->host,
	767	"Consistency Check Successfully Terminated\n");
	768	break;
	769	}
	770	else if (new->rbld == MYRB_BG_CHECK_IN_PROGRESS)
	771	cb->need_cc_status = true;
	772
	773	return MYRB_STATUS_SUCCESS;
	774	}
	775
	776	/**
	777	* myrb_set_pdev_state - sets the device state for a physical device
	778	*
	779	* Return: command status
	780	*/
	781	static unsigned short myrb_set_pdev_state(struct myrb_hba *cb,
	782	struct scsi_device *sdev, enum myrb_devstate state)
	783	{
	784	struct myrb_cmdblk *cmd_blk = &cb->dcmd_blk;
	785	union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
	786	unsigned short status;
	787
	788	mutex_lock(&cb->dcmd_mutex);
	789	mbox->type3D.opcode = MYRB_CMD_START_DEVICE;
	790	mbox->type3D.id = MYRB_DCMD_TAG;
	791	mbox->type3D.channel = sdev->channel;
	792	mbox->type3D.target = sdev->id;
	793	mbox->type3D.state = state & 0x1F;
	794	status = myrb_exec_cmd(cb, cmd_blk);
	795	mutex_unlock(&cb->dcmd_mutex);
	796
	797	return status;
	798	}
	799
	800	/**
	801	* myrb_enable_mmio - enables the Memory Mailbox Interface
	802	*
	803	* PD and P controller types have no memory mailbox, but still need the
	804	* other dma mapped memory.
	805	*
	806	* Return: true on success, false otherwise.
	807	*/
	808	static bool myrb_enable_mmio(struct myrb_hba *cb, mbox_mmio_init_t mmio_init_fn)
	809	{
	810	void __iomem *base = cb->io_base;
	811	struct pci_dev *pdev = cb->pdev;
	812	size_t err_table_size;
	813	size_t ldev_info_size;
	814	union myrb_cmd_mbox *cmd_mbox_mem;
	815	struct myrb_stat_mbox *stat_mbox_mem;
	816	union myrb_cmd_mbox mbox;
	817	unsigned short status;
	818
	819	memset(&mbox, 0, sizeof(union myrb_cmd_mbox));
	820
	821	if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) {
	822	dev_err(&pdev->dev, "DMA mask out of range\n");
	823	return false;
	824	}
	825
	826	cb->enquiry = dma_alloc_coherent(&pdev->dev,
	827	sizeof(struct myrb_enquiry),
	828	&cb->enquiry_addr, GFP_KERNEL);
	829	if (!cb->enquiry)
	830	return false;
	831
	832	err_table_size = sizeof(struct myrb_error_entry) *
	833	MYRB_MAX_CHANNELS * MYRB_MAX_TARGETS;
	834	cb->err_table = dma_alloc_coherent(&pdev->dev, err_table_size,
	835	&cb->err_table_addr, GFP_KERNEL);
	836	if (!cb->err_table)
	837	return false;
	838
	839	ldev_info_size = sizeof(struct myrb_ldev_info) * MYRB_MAX_LDEVS;
	840	cb->ldev_info_buf = dma_alloc_coherent(&pdev->dev, ldev_info_size,
	841	&cb->ldev_info_addr, GFP_KERNEL);
	842	if (!cb->ldev_info_buf)
	843	return false;
	844
	845	/*
	846	* Skip mailbox initialisation for PD and P Controllers
	847	*/
	848	if (!mmio_init_fn)
	849	return true;
	850
	851	/* These are the base addresses for the command memory mailbox array */
	852	cb->cmd_mbox_size = MYRB_CMD_MBOX_COUNT * sizeof(union myrb_cmd_mbox);
	853	cb->first_cmd_mbox = dma_alloc_coherent(&pdev->dev,
	854	cb->cmd_mbox_size,
	855	&cb->cmd_mbox_addr,
	856	GFP_KERNEL);
	857	if (!cb->first_cmd_mbox)
	858	return false;
	859
	860	cmd_mbox_mem = cb->first_cmd_mbox;
	861	cmd_mbox_mem += MYRB_CMD_MBOX_COUNT - 1;
	862	cb->last_cmd_mbox = cmd_mbox_mem;
	863	cb->next_cmd_mbox = cb->first_cmd_mbox;
	864	cb->prev_cmd_mbox1 = cb->last_cmd_mbox;
	865	cb->prev_cmd_mbox2 = cb->last_cmd_mbox - 1;
	866
	867	/* These are the base addresses for the status memory mailbox array */
	868	cb->stat_mbox_size = MYRB_STAT_MBOX_COUNT *
	869	sizeof(struct myrb_stat_mbox);
	870	cb->first_stat_mbox = dma_alloc_coherent(&pdev->dev,
	871	cb->stat_mbox_size,
	872	&cb->stat_mbox_addr,
	873	GFP_KERNEL);
	874	if (!cb->first_stat_mbox)
	875	return false;
	876
	877	stat_mbox_mem = cb->first_stat_mbox;
	878	stat_mbox_mem += MYRB_STAT_MBOX_COUNT - 1;
	879	cb->last_stat_mbox = stat_mbox_mem;
	880	cb->next_stat_mbox = cb->first_stat_mbox;
	881
	882	/* Enable the Memory Mailbox Interface. */
	883	cb->dual_mode_interface = true;
	884	mbox.typeX.opcode = 0x2B;
	885	mbox.typeX.id = 0;
	886	mbox.typeX.opcode2 = 0x14;
	887	mbox.typeX.cmd_mbox_addr = cb->cmd_mbox_addr;
	888	mbox.typeX.stat_mbox_addr = cb->stat_mbox_addr;
	889
	890	status = mmio_init_fn(pdev, base, &mbox);
	891	if (status != MYRB_STATUS_SUCCESS) {
	892	cb->dual_mode_interface = false;
	893	mbox.typeX.opcode2 = 0x10;
	894	status = mmio_init_fn(pdev, base, &mbox);
	895	if (status != MYRB_STATUS_SUCCESS) {
	896	dev_err(&pdev->dev,
	897	"Failed to enable mailbox, statux %02X\n",
	898	status);
	899	return false;
	900	}
	901	}
	902	return true;
	903	}
	904
	905	/**
	906	* myrb_get_hba_config - reads the configuration information
	907	*
	908	* Reads the configuration information from the controller and
	909	* initializes the controller structure.
	910	*
	911	* Return: 0 on success, errno otherwise
	912	*/
	913	static int myrb_get_hba_config(struct myrb_hba *cb)
	914	{
	915	struct myrb_enquiry2 *enquiry2;
	916	dma_addr_t enquiry2_addr;
	917	struct myrb_config2 *config2;
	918	dma_addr_t config2_addr;
	919	struct Scsi_Host *shost = cb->host;
	920	struct pci_dev *pdev = cb->pdev;
	921	int pchan_max = 0, pchan_cur = 0;
	922	unsigned short status;
	923	int ret = -ENODEV, memsize = 0;
	924
	925	enquiry2 = dma_alloc_coherent(&pdev->dev, sizeof(struct myrb_enquiry2),
	926	&enquiry2_addr, GFP_KERNEL);
	927	if (!enquiry2) {
	928	shost_printk(KERN_ERR, cb->host,
	929	"Failed to allocate V1 enquiry2 memory\n");
	930	return -ENOMEM;
	931	}
	932	config2 = dma_alloc_coherent(&pdev->dev, sizeof(struct myrb_config2),
	933	&config2_addr, GFP_KERNEL);
	934	if (!config2) {
	935	shost_printk(KERN_ERR, cb->host,
	936	"Failed to allocate V1 config2 memory\n");
	937	dma_free_coherent(&pdev->dev, sizeof(struct myrb_enquiry2),
	938	enquiry2, enquiry2_addr);
	939	return -ENOMEM;
	940	}
	941	mutex_lock(&cb->dma_mutex);
	942	status = myrb_hba_enquiry(cb);
	943	mutex_unlock(&cb->dma_mutex);
	944	if (status != MYRB_STATUS_SUCCESS) {
	945	shost_printk(KERN_WARNING, cb->host,
	946	"Failed it issue V1 Enquiry\n");
	947	goto out_free;
	948	}
	949
	950	status = myrb_exec_type3(cb, MYRB_CMD_ENQUIRY2, enquiry2_addr);
	951	if (status != MYRB_STATUS_SUCCESS) {
	952	shost_printk(KERN_WARNING, cb->host,
	953	"Failed to issue V1 Enquiry2\n");
	954	goto out_free;
	955	}
	956
	957	status = myrb_exec_type3(cb, MYRB_CMD_READ_CONFIG2, config2_addr);
	958	if (status != MYRB_STATUS_SUCCESS) {
	959	shost_printk(KERN_WARNING, cb->host,
	960	"Failed to issue ReadConfig2\n");
	961	goto out_free;
	962	}
	963
	964	status = myrb_get_ldev_info(cb);
	965	if (status != MYRB_STATUS_SUCCESS) {
	966	shost_printk(KERN_WARNING, cb->host,
	967	"Failed to get logical drive information\n");
	968	goto out_free;
	969	}
	970
	971	/*
	972	* Initialize the Controller Model Name and Full Model Name fields.
	973	*/
	974	switch (enquiry2->hw.sub_model) {
	975	case DAC960_V1_P_PD_PU:
	976	if (enquiry2->scsi_cap.bus_speed == MYRB_SCSI_SPEED_ULTRA)
	977	strcpy(cb->model_name, "DAC960PU");
	978	else
	979	strcpy(cb->model_name, "DAC960PD");
	980	break;
	981	case DAC960_V1_PL:
	982	strcpy(cb->model_name, "DAC960PL");
	983	break;
	984	case DAC960_V1_PG:
	985	strcpy(cb->model_name, "DAC960PG");
	986	break;
	987	case DAC960_V1_PJ:
	988	strcpy(cb->model_name, "DAC960PJ");
	989	break;
	990	case DAC960_V1_PR:
	991	strcpy(cb->model_name, "DAC960PR");
	992	break;
	993	case DAC960_V1_PT:
	994	strcpy(cb->model_name, "DAC960PT");
	995	break;
	996	case DAC960_V1_PTL0:
	997	strcpy(cb->model_name, "DAC960PTL0");
	998	break;
	999	case DAC960_V1_PRL:
	1000	strcpy(cb->model_name, "DAC960PRL");
	1001	break;
	1002	case DAC960_V1_PTL1:
	1003	strcpy(cb->model_name, "DAC960PTL1");
	1004	break;
	1005	case DAC960_V1_1164P:
	1006	strcpy(cb->model_name, "eXtremeRAID 1100");
	1007	break;
	1008	default:
	1009	shost_printk(KERN_WARNING, cb->host,
	1010	"Unknown Model %X\n",
	1011	enquiry2->hw.sub_model);
	1012	goto out;
	1013	}
	1014	/*
	1015	* Initialize the Controller Firmware Version field and verify that it
	1016	* is a supported firmware version.
	1017	* The supported firmware versions are:
	1018	*
	1019	* DAC1164P 5.06 and above
	1020	* DAC960PTL/PRL/PJ/PG 4.06 and above
	1021	* DAC960PU/PD/PL 3.51 and above
	1022	* DAC960PU/PD/PL/P 2.73 and above
	1023	*/
	1024	#if defined(CONFIG_ALPHA)
	1025	/*
	1026	* DEC Alpha machines were often equipped with DAC960 cards that were
	1027	* OEMed from Mylex, and had their own custom firmware. Version 2.70,
	1028	* the last custom FW revision to be released by DEC for these older
	1029	* controllers, appears to work quite well with this driver.
	1030	*
	1031	* Cards tested successfully were several versions each of the PD and
	1032	* PU, called by DEC the KZPSC and KZPAC, respectively, and having
	1033	* the Manufacturer Numbers (from Mylex), usually on a sticker on the
	1034	* back of the board, of:
	1035	*
	1036	* KZPSC: D040347 (1-channel) or D040348 (2-channel)
	1037	* or D040349 (3-channel)
	1038	* KZPAC: D040395 (1-channel) or D040396 (2-channel)
	1039	* or D040397 (3-channel)
	1040	*/
	1041	# define FIRMWARE_27X "2.70"
	1042	#else
	1043	# define FIRMWARE_27X "2.73"
	1044	#endif
	1045
	1046	if (enquiry2->fw.major_version == 0) {
	1047	enquiry2->fw.major_version = cb->enquiry->fw_major_version;
	1048	enquiry2->fw.minor_version = cb->enquiry->fw_minor_version;
	1049	enquiry2->fw.firmware_type = '0';
	1050	enquiry2->fw.turn_id = 0;
	1051	}
	1052	sprintf(cb->fw_version, "%d.%02d-%c-%02d",
	1053	enquiry2->fw.major_version,
	1054	enquiry2->fw.minor_version,
	1055	enquiry2->fw.firmware_type,
	1056	enquiry2->fw.turn_id);
	1057	if (!((enquiry2->fw.major_version == 5 &&
	1058	enquiry2->fw.minor_version >= 6) \|\|
	1059	(enquiry2->fw.major_version == 4 &&
	1060	enquiry2->fw.minor_version >= 6) \|\|
	1061	(enquiry2->fw.major_version == 3 &&
	1062	enquiry2->fw.minor_version >= 51) \|\|
	1063	(enquiry2->fw.major_version == 2 &&
	1064	strcmp(cb->fw_version, FIRMWARE_27X) >= 0))) {
	1065	shost_printk(KERN_WARNING, cb->host,
	1066	"Firmware Version '%s' unsupported\n",
	1067	cb->fw_version);
	1068	goto out;
	1069	}
	1070	/*
	1071	* Initialize the Channels, Targets, Memory Size, and SAF-TE
	1072	* Enclosure Management Enabled fields.
	1073	*/
	1074	switch (enquiry2->hw.model) {
	1075	case MYRB_5_CHANNEL_BOARD:
	1076	pchan_max = 5;
	1077	break;
	1078	case MYRB_3_CHANNEL_BOARD:
	1079	case MYRB_3_CHANNEL_ASIC_DAC:
	1080	pchan_max = 3;
	1081	break;
	1082	case MYRB_2_CHANNEL_BOARD:
	1083	pchan_max = 2;
	1084	break;
	1085	default:
	1086	pchan_max = enquiry2->cfg_chan;
	1087	break;
	1088	}
	1089	pchan_cur = enquiry2->cur_chan;
	1090	if (enquiry2->scsi_cap.bus_width == MYRB_WIDTH_WIDE_32BIT)
	1091	cb->bus_width = 32;
	1092	else if (enquiry2->scsi_cap.bus_width == MYRB_WIDTH_WIDE_16BIT)
	1093	cb->bus_width = 16;
	1094	else
	1095	cb->bus_width = 8;
	1096	cb->ldev_block_size = enquiry2->ldev_block_size;
	1097	shost->max_channel = pchan_cur;
	1098	shost->max_id = enquiry2->max_targets;
	1099	memsize = enquiry2->mem_size >> 20;
	1100	cb->safte_enabled = (enquiry2->fault_mgmt == MYRB_FAULT_SAFTE);
	1101	/*
	1102	* Initialize the Controller Queue Depth, Driver Queue Depth,
	1103	* Logical Drive Count, Maximum Blocks per Command, Controller
	1104	* Scatter/Gather Limit, and Driver Scatter/Gather Limit.
	1105	* The Driver Queue Depth must be at most one less than the
	1106	* Controller Queue Depth to allow for an automatic drive
	1107	* rebuild operation.
	1108	*/
	1109	shost->can_queue = cb->enquiry->max_tcq;
	1110	if (shost->can_queue < 3)
	1111	shost->can_queue = enquiry2->max_cmds;
	1112	if (shost->can_queue < 3)
	1113	/* Play safe and disable TCQ */
	1114	shost->can_queue = 1;
	1115
	1116	if (shost->can_queue > MYRB_CMD_MBOX_COUNT - 2)
	1117	shost->can_queue = MYRB_CMD_MBOX_COUNT - 2;
	1118	shost->max_sectors = enquiry2->max_sectors;
	1119	shost->sg_tablesize = enquiry2->max_sge;
	1120	if (shost->sg_tablesize > MYRB_SCATTER_GATHER_LIMIT)
	1121	shost->sg_tablesize = MYRB_SCATTER_GATHER_LIMIT;
	1122	/*
	1123	* Initialize the Stripe Size, Segment Size, and Geometry Translation.
	1124	*/
	1125	cb->stripe_size = config2->blocks_per_stripe * config2->block_factor
	1126	>> (10 - MYRB_BLKSIZE_BITS);
	1127	cb->segment_size = config2->blocks_per_cacheline * config2->block_factor
	1128	>> (10 - MYRB_BLKSIZE_BITS);
	1129	/* Assume 255/63 translation */
	1130	cb->ldev_geom_heads = 255;
	1131	cb->ldev_geom_sectors = 63;
	1132	if (config2->drive_geometry) {
	1133	cb->ldev_geom_heads = 128;
	1134	cb->ldev_geom_sectors = 32;
	1135	}
	1136
	1137	/*
	1138	* Initialize the Background Initialization Status.
	1139	*/
	1140	if ((cb->fw_version[0] == '4' &&
	1141	strcmp(cb->fw_version, "4.08") >= 0) \|\|
	1142	(cb->fw_version[0] == '5' &&
	1143	strcmp(cb->fw_version, "5.08") >= 0)) {
	1144	cb->bgi_status_supported = true;
	1145	myrb_bgi_control(cb);
	1146	}
	1147	cb->last_rbld_status = MYRB_NO_STDBY_RBLD_OR_CHECK_IN_PROGRESS;
	1148	ret = 0;
	1149
	1150	out:
	1151	shost_printk(KERN_INFO, cb->host,
	1152	"Configuring %s PCI RAID Controller\n", cb->model_name);
	1153	shost_printk(KERN_INFO, cb->host,
	1154	" Firmware Version: %s, Memory Size: %dMB\n",
	1155	cb->fw_version, memsize);
	1156	if (cb->io_addr == 0)
	1157	shost_printk(KERN_INFO, cb->host,
	1158	" I/O Address: n/a, PCI Address: 0x%lX, IRQ Channel: %d\n",
	1159	(unsigned long)cb->pci_addr, cb->irq);
	1160	else
	1161	shost_printk(KERN_INFO, cb->host,
	1162	" I/O Address: 0x%lX, PCI Address: 0x%lX, IRQ Channel: %d\n",
	1163	(unsigned long)cb->io_addr, (unsigned long)cb->pci_addr,
	1164	cb->irq);
	1165	shost_printk(KERN_INFO, cb->host,
	1166	" Controller Queue Depth: %d, Maximum Blocks per Command: %d\n",
	1167	cb->host->can_queue, cb->host->max_sectors);
	1168	shost_printk(KERN_INFO, cb->host,
	1169	" Driver Queue Depth: %d, Scatter/Gather Limit: %d of %d Segments\n",
	1170	cb->host->can_queue, cb->host->sg_tablesize,
	1171	MYRB_SCATTER_GATHER_LIMIT);
	1172	shost_printk(KERN_INFO, cb->host,
	1173	" Stripe Size: %dKB, Segment Size: %dKB, BIOS Geometry: %d/%d%s\n",
	1174	cb->stripe_size, cb->segment_size,
	1175	cb->ldev_geom_heads, cb->ldev_geom_sectors,
	1176	cb->safte_enabled ?
	1177	" SAF-TE Enclosure Management Enabled" : "");
	1178	shost_printk(KERN_INFO, cb->host,
	1179	" Physical: %d/%d channels %d/%d/%d devices\n",
	1180	pchan_cur, pchan_max, 0, cb->enquiry->pdev_dead,
	1181	cb->host->max_id);
	1182
	1183	shost_printk(KERN_INFO, cb->host,
	1184	" Logical: 1/1 channels, %d/%d disks\n",
	1185	cb->enquiry->ldev_count, MYRB_MAX_LDEVS);
	1186
	1187	out_free:
	1188	dma_free_coherent(&pdev->dev, sizeof(struct myrb_enquiry2),
	1189	enquiry2, enquiry2_addr);
	1190	dma_free_coherent(&pdev->dev, sizeof(struct myrb_config2),
	1191	config2, config2_addr);
	1192
	1193	return ret;
	1194	}
	1195
	1196	/**
	1197	* myrb_unmap - unmaps controller structures
	1198	*/
	1199	static void myrb_unmap(struct myrb_hba *cb)
	1200	{
	1201	if (cb->ldev_info_buf) {
	1202	size_t ldev_info_size = sizeof(struct myrb_ldev_info) *
	1203	MYRB_MAX_LDEVS;
	1204	dma_free_coherent(&cb->pdev->dev, ldev_info_size,
	1205	cb->ldev_info_buf, cb->ldev_info_addr);
	1206	cb->ldev_info_buf = NULL;
	1207	}
	1208	if (cb->err_table) {
	1209	size_t err_table_size = sizeof(struct myrb_error_entry) *
	1210	MYRB_MAX_CHANNELS * MYRB_MAX_TARGETS;
	1211	dma_free_coherent(&cb->pdev->dev, err_table_size,
	1212	cb->err_table, cb->err_table_addr);
	1213	cb->err_table = NULL;
	1214	}
	1215	if (cb->enquiry) {
	1216	dma_free_coherent(&cb->pdev->dev, sizeof(struct myrb_enquiry),
	1217	cb->enquiry, cb->enquiry_addr);
	1218	cb->enquiry = NULL;
	1219	}
	1220	if (cb->first_stat_mbox) {
	1221	dma_free_coherent(&cb->pdev->dev, cb->stat_mbox_size,
	1222	cb->first_stat_mbox, cb->stat_mbox_addr);
	1223	cb->first_stat_mbox = NULL;
	1224	}
	1225	if (cb->first_cmd_mbox) {
	1226	dma_free_coherent(&cb->pdev->dev, cb->cmd_mbox_size,
	1227	cb->first_cmd_mbox, cb->cmd_mbox_addr);
	1228	cb->first_cmd_mbox = NULL;
	1229	}
	1230	}
	1231
	1232	/**
	1233	* myrb_cleanup - cleanup controller structures
	1234	*/
	1235	static void myrb_cleanup(struct myrb_hba *cb)
	1236	{
	1237	struct pci_dev *pdev = cb->pdev;
	1238
	1239	/* Free the memory mailbox, status, and related structures */
	1240	myrb_unmap(cb);
	1241
	1242	if (cb->mmio_base) {
	1243	cb->disable_intr(cb->io_base);
	1244	iounmap(cb->mmio_base);
	1245	}
	1246	if (cb->irq)
	1247	free_irq(cb->irq, cb);
	1248	if (cb->io_addr)
	1249	release_region(cb->io_addr, 0x80);
	1250	pci_set_drvdata(pdev, NULL);
	1251	pci_disable_device(pdev);
	1252	scsi_host_put(cb->host);
	1253	}
	1254
	1255	static int myrb_host_reset(struct scsi_cmnd *scmd)
	1256	{
	1257	struct Scsi_Host *shost = scmd->device->host;
	1258	struct myrb_hba *cb = shost_priv(shost);
	1259
	1260	cb->reset(cb->io_base);
	1261	return SUCCESS;
	1262	}
	1263
	1264	static int myrb_pthru_queuecommand(struct Scsi_Host *shost,
	1265	struct scsi_cmnd *scmd)
	1266	{
	1267	struct myrb_hba *cb = shost_priv(shost);
	1268	struct myrb_cmdblk *cmd_blk = scsi_cmd_priv(scmd);
	1269	union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
	1270	struct myrb_dcdb *dcdb;
	1271	dma_addr_t dcdb_addr;
	1272	struct scsi_device *sdev = scmd->device;
	1273	struct scatterlist *sgl;
	1274	unsigned long flags;
	1275	int nsge;
	1276
	1277	myrb_reset_cmd(cmd_blk);
	1278	dcdb = dma_pool_alloc(cb->dcdb_pool, GFP_ATOMIC, &dcdb_addr);
	1279	if (!dcdb)
	1280	return SCSI_MLQUEUE_HOST_BUSY;
	1281	nsge = scsi_dma_map(scmd);
	1282	if (nsge > 1) {
	1283	dma_pool_free(cb->dcdb_pool, dcdb, dcdb_addr);
	1284	scmd->result = (DID_ERROR << 16);
	1285	scmd->scsi_done(scmd);
	1286	return 0;
	1287	}
	1288
	1289	mbox->type3.opcode = MYRB_CMD_DCDB;
	1290	mbox->type3.id = scmd->request->tag + 3;
	1291	mbox->type3.addr = dcdb_addr;
	1292	dcdb->channel = sdev->channel;
	1293	dcdb->target = sdev->id;
	1294	switch (scmd->sc_data_direction) {
	1295	case DMA_NONE:
	1296	dcdb->data_xfer = MYRB_DCDB_XFER_NONE;
	1297	break;
	1298	case DMA_TO_DEVICE:
	1299	dcdb->data_xfer = MYRB_DCDB_XFER_SYSTEM_TO_DEVICE;
	1300	break;
	1301	case DMA_FROM_DEVICE:
	1302	dcdb->data_xfer = MYRB_DCDB_XFER_DEVICE_TO_SYSTEM;
	1303	break;
	1304	default:
	1305	dcdb->data_xfer = MYRB_DCDB_XFER_ILLEGAL;
	1306	break;
	1307	}
	1308	dcdb->early_status = false;
	1309	if (scmd->request->timeout <= 10)
	1310	dcdb->timeout = MYRB_DCDB_TMO_10_SECS;
	1311	else if (scmd->request->timeout <= 60)
	1312	dcdb->timeout = MYRB_DCDB_TMO_60_SECS;
	1313	else if (scmd->request->timeout <= 600)
	1314	dcdb->timeout = MYRB_DCDB_TMO_10_MINS;
	1315	else
	1316	dcdb->timeout = MYRB_DCDB_TMO_24_HRS;
	1317	dcdb->no_autosense = false;
	1318	dcdb->allow_disconnect = true;
	1319	sgl = scsi_sglist(scmd);
	1320	dcdb->dma_addr = sg_dma_address(sgl);
	1321	if (sg_dma_len(sgl) > USHRT_MAX) {
	1322	dcdb->xfer_len_lo = sg_dma_len(sgl) & 0xffff;
	1323	dcdb->xfer_len_hi4 = sg_dma_len(sgl) >> 16;
	1324	} else {
	1325	dcdb->xfer_len_lo = sg_dma_len(sgl);
	1326	dcdb->xfer_len_hi4 = 0;
	1327	}
	1328	dcdb->cdb_len = scmd->cmd_len;
	1329	dcdb->sense_len = sizeof(dcdb->sense);
	1330	memcpy(&dcdb->cdb, scmd->cmnd, scmd->cmd_len);
	1331
	1332	spin_lock_irqsave(&cb->queue_lock, flags);
	1333	cb->qcmd(cb, cmd_blk);
	1334	spin_unlock_irqrestore(&cb->queue_lock, flags);
	1335	return 0;
	1336	}
	1337
	1338	static void myrb_inquiry(struct myrb_hba *cb,
	1339	struct scsi_cmnd *scmd)
	1340	{
	1341	unsigned char inq[36] = {
	1342	0x00, 0x00, 0x03, 0x02, 0x20, 0x00, 0x01, 0x00,
	1343	0x4d, 0x59, 0x4c, 0x45, 0x58, 0x20, 0x20, 0x20,
	1344	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
	1345	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
	1346	0x20, 0x20, 0x20, 0x20,
	1347	};
	1348
	1349	if (cb->bus_width > 16)
	1350	inq[7] \|= 1 << 6;
	1351	if (cb->bus_width > 8)
	1352	inq[7] \|= 1 << 5;
	1353	memcpy(&inq[16], cb->model_name, 16);
	1354	memcpy(&inq[32], cb->fw_version, 1);
	1355	memcpy(&inq[33], &cb->fw_version[2], 2);
	1356	memcpy(&inq[35], &cb->fw_version[7], 1);
	1357
	1358	scsi_sg_copy_from_buffer(scmd, (void *)inq, 36);
	1359	}
	1360
	1361	static void
	1362	myrb_mode_sense(struct myrb_hba cb, struct scsi_cmnd scmd,
	1363	struct myrb_ldev_info *ldev_info)
	1364	{
	1365	unsigned char modes[32], *mode_pg;
	1366	bool dbd;
	1367	size_t mode_len;
	1368
	1369	dbd = (scmd->cmnd[1] & 0x08) == 0x08;
	1370	if (dbd) {
	1371	mode_len = 24;
	1372	mode_pg = &modes[4];
	1373	} else {
	1374	mode_len = 32;
	1375	mode_pg = &modes[12];
	1376	}
	1377	memset(modes, 0, sizeof(modes));
	1378	modes[0] = mode_len - 1;
	1379	if (!dbd) {
	1380	unsigned char *block_desc = &modes[4];
	1381
	1382	modes[3] = 8;
	1383	put_unaligned_be32(ldev_info->size, &block_desc[0]);
	1384	put_unaligned_be32(cb->ldev_block_size, &block_desc[5]);
	1385	}
	1386	mode_pg[0] = 0x08;
	1387	mode_pg[1] = 0x12;
	1388	if (ldev_info->wb_enabled)
	1389	mode_pg[2] \|= 0x04;
	1390	if (cb->segment_size) {
	1391	mode_pg[2] \|= 0x08;
	1392	put_unaligned_be16(cb->segment_size, &mode_pg[14]);
	1393	}
	1394
	1395	scsi_sg_copy_from_buffer(scmd, modes, mode_len);
	1396	}
	1397
	1398	static void myrb_request_sense(struct myrb_hba *cb,
	1399	struct scsi_cmnd *scmd)
	1400	{
	1401	scsi_build_sense_buffer(0, scmd->sense_buffer,
	1402	NO_SENSE, 0, 0);
	1403	scsi_sg_copy_from_buffer(scmd, scmd->sense_buffer,
	1404	SCSI_SENSE_BUFFERSIZE);
	1405	}
	1406
	1407	static void myrb_read_capacity(struct myrb_hba cb, struct scsi_cmnd scmd,
	1408	struct myrb_ldev_info *ldev_info)
	1409	{
	1410	unsigned char data[8];
	1411
	1412	dev_dbg(&scmd->device->sdev_gendev,
	1413	"Capacity %u, blocksize %u\n",
	1414	ldev_info->size, cb->ldev_block_size);
	1415	put_unaligned_be32(ldev_info->size - 1, &data[0]);
	1416	put_unaligned_be32(cb->ldev_block_size, &data[4]);
	1417	scsi_sg_copy_from_buffer(scmd, data, 8);
	1418	}
	1419
	1420	static int myrb_ldev_queuecommand(struct Scsi_Host *shost,
	1421	struct scsi_cmnd *scmd)
	1422	{
	1423	struct myrb_hba *cb = shost_priv(shost);
	1424	struct myrb_cmdblk *cmd_blk = scsi_cmd_priv(scmd);
	1425	union myrb_cmd_mbox *mbox = &cmd_blk->mbox;
	1426	struct myrb_ldev_info *ldev_info;
	1427	struct scsi_device *sdev = scmd->device;
	1428	struct scatterlist *sgl;
	1429	unsigned long flags;
	1430	u64 lba;
	1431	u32 block_cnt;
	1432	int nsge;
	1433
	1434	ldev_info = sdev->hostdata;
	1435	if (ldev_info->state != MYRB_DEVICE_ONLINE &&
	1436	ldev_info->state != MYRB_DEVICE_WO) {
	1437	dev_dbg(&shost->shost_gendev, "ldev %u in state %x, skip\n",
	1438	sdev->id, ldev_info ? ldev_info->state : 0xff);
	1439	scmd->result = (DID_BAD_TARGET << 16);
	1440	scmd->scsi_done(scmd);
	1441	return 0;
	1442	}
	1443	switch (scmd->cmnd[0]) {
	1444	case TEST_UNIT_READY:
	1445	scmd->result = (DID_OK << 16);
	1446	scmd->scsi_done(scmd);
	1447	return 0;
	1448	case INQUIRY:
	1449	if (scmd->cmnd[1] & 1) {
	1450	/* Illegal request, invalid field in CDB */
	1451	scsi_build_sense_buffer(0, scmd->sense_buffer,
	1452	ILLEGAL_REQUEST, 0x24, 0);
	1453	scmd->result = (DRIVER_SENSE << 24) \|
	1454	SAM_STAT_CHECK_CONDITION;
	1455	} else {
	1456	myrb_inquiry(cb, scmd);
	1457	scmd->result = (DID_OK << 16);
	1458	}
	1459	scmd->scsi_done(scmd);
	1460	return 0;
	1461	case SYNCHRONIZE_CACHE:
	1462	scmd->result = (DID_OK << 16);
	1463	scmd->scsi_done(scmd);
	1464	return 0;
	1465	case MODE_SENSE:
	1466	if ((scmd->cmnd[2] & 0x3F) != 0x3F &&
	1467	(scmd->cmnd[2] & 0x3F) != 0x08) {
	1468	/* Illegal request, invalid field in CDB */
	1469	scsi_build_sense_buffer(0, scmd->sense_buffer,
	1470	ILLEGAL_REQUEST, 0x24, 0);
	1471	scmd->result = (DRIVER_SENSE << 24) \|
	1472	SAM_STAT_CHECK_CONDITION;
	1473	} else {
	1474	myrb_mode_sense(cb, scmd, ldev_info);
	1475	scmd->result = (DID_OK << 16);
	1476	}
	1477	scmd->scsi_done(scmd);
	1478	return 0;
	1479	case READ_CAPACITY:
	1480	if ((scmd->cmnd[1] & 1) \|\|
	1481	(scmd->cmnd[8] & 1)) {
	1482	/* Illegal request, invalid field in CDB */
	1483	scsi_build_sense_buffer(0, scmd->sense_buffer,
	1484	ILLEGAL_REQUEST, 0x24, 0);
	1485	scmd->result = (DRIVER_SENSE << 24) \|
	1486	SAM_STAT_CHECK_CONDITION;
	1487	scmd->scsi_done(scmd);
	1488	return 0;
	1489	}
	1490	lba = get_unaligned_be32(&scmd->cmnd[2]);
	1491	if (lba) {
	1492	/* Illegal request, invalid field in CDB */
	1493	scsi_build_sense_buffer(0, scmd->sense_buffer,
	1494	ILLEGAL_REQUEST, 0x24, 0);
	1495	scmd->result = (DRIVER_SENSE << 24) \|
	1496	SAM_STAT_CHECK_CONDITION;
	1497	scmd->scsi_done(scmd);
	1498	return 0;
	1499	}
	1500	myrb_read_capacity(cb, scmd, ldev_info);
	1501	scmd->scsi_done(scmd);
	1502	return 0;
	1503	case REQUEST_SENSE:
	1504	myrb_request_sense(cb, scmd);
	1505	scmd->result = (DID_OK << 16);
	1506	return 0;
	1507	case SEND_DIAGNOSTIC:
	1508	if (scmd->cmnd[1] != 0x04) {
	1509	/* Illegal request, invalid field in CDB */
	1510	scsi_build_sense_buffer(0, scmd->sense_buffer,
	1511	ILLEGAL_REQUEST, 0x24, 0);
	1512	scmd->result = (DRIVER_SENSE << 24) \|
	1513	SAM_STAT_CHECK_CONDITION;
	1514	} else {
	1515	/* Assume good status */
	1516	scmd->result = (DID_OK << 16);
	1517	}
	1518	scmd->scsi_done(scmd);
	1519	return 0;
	1520	case READ_6:
	1521	if (ldev_info->state == MYRB_DEVICE_WO) {
	1522	/* Data protect, attempt to read invalid data */
	1523	scsi_build_sense_buffer(0, scmd->sense_buffer,
	1524	DATA_PROTECT, 0x21, 0x06);
	1525	scmd->result = (DRIVER_SENSE << 24) \|
	1526	SAM_STAT_CHECK_CONDITION;
	1527	scmd->scsi_done(scmd);
	1528	return 0;
	1529	}
	1530	case WRITE_6:
	1531	lba = (((scmd->cmnd[1] & 0x1F) << 16) \|
	1532	(scmd->cmnd[2] << 8) \|
	1533	scmd->cmnd[3]);
	1534	block_cnt = scmd->cmnd[4];
	1535	break;
	1536	case READ_10:
	1537	if (ldev_info->state == MYRB_DEVICE_WO) {
	1538	/* Data protect, attempt to read invalid data */
	1539	scsi_build_sense_buffer(0, scmd->sense_buffer,
	1540	DATA_PROTECT, 0x21, 0x06);
	1541	scmd->result = (DRIVER_SENSE << 24) \|
	1542	SAM_STAT_CHECK_CONDITION;
	1543	scmd->scsi_done(scmd);
	1544	return 0;
	1545	}
	1546	case WRITE_10:
	1547	case VERIFY: /* 0x2F */
	1548	case WRITE_VERIFY: /* 0x2E */
	1549	lba = get_unaligned_be32(&scmd->cmnd[2]);
	1550	block_cnt = get_unaligned_be16(&scmd->cmnd[7]);
	1551	break;
	1552	case READ_12:
	1553	if (ldev_info->state == MYRB_DEVICE_WO) {
	1554	/* Data protect, attempt to read invalid data */
	1555	scsi_build_sense_buffer(0, scmd->sense_buffer,
	1556	DATA_PROTECT, 0x21, 0x06);
	1557	scmd->result = (DRIVER_SENSE << 24) \|
	1558	SAM_STAT_CHECK_CONDITION;
	1559	scmd->scsi_done(scmd);
	1560	return 0;
	1561	}
	1562	case WRITE_12:
	1563	case VERIFY_12: /* 0xAF */
	1564	case WRITE_VERIFY_12: /* 0xAE */
	1565	lba = get_unaligned_be32(&scmd->cmnd[2]);
	1566	block_cnt = get_unaligned_be32(&scmd->cmnd[6]);
	1567	break;
	1568	default:
	1569	/* Illegal request, invalid opcode */
	1570	scsi_build_sense_buffer(0, scmd->sense_buffer,
	1571	ILLEGAL_REQUEST, 0x20, 0);
	1572	scmd->result = (DRIVER_SENSE << 24) \| SAM_STAT_CHECK_CONDITION;
	1573	scmd->scsi_done(scmd);
	1574	return 0;
	1575	}
	1576
	1577	myrb_reset_cmd(cmd_blk);
	1578	mbox->type5.id = scmd->request->tag + 3;
	1579	if (scmd->sc_data_direction == DMA_NONE)
	1580	goto submit;
	1581	nsge = scsi_dma_map(scmd);
	1582	if (nsge == 1) {
	1583	sgl = scsi_sglist(scmd);
	1584	if (scmd->sc_data_direction == DMA_FROM_DEVICE)
	1585	mbox->type5.opcode = MYRB_CMD_READ;
	1586	else
	1587	mbox->type5.opcode = MYRB_CMD_WRITE;
	1588
	1589	mbox->type5.ld.xfer_len = block_cnt;
	1590	mbox->type5.ld.ldev_num = sdev->id;
	1591	mbox->type5.lba = lba;
	1592	mbox->type5.addr = (u32)sg_dma_address(sgl);
	1593	} else {
	1594	struct myrb_sge *hw_sgl;
	1595	dma_addr_t hw_sgl_addr;
	1596	int i;
	1597
	1598	hw_sgl = dma_pool_alloc(cb->sg_pool, GFP_ATOMIC, &hw_sgl_addr);
	1599	if (!hw_sgl)
	1600	return SCSI_MLQUEUE_HOST_BUSY;
	1601
	1602	cmd_blk->sgl = hw_sgl;
	1603	cmd_blk->sgl_addr = hw_sgl_addr;
	1604
	1605	if (scmd->sc_data_direction == DMA_FROM_DEVICE)
	1606	mbox->type5.opcode = MYRB_CMD_READ_SG;
	1607	else
	1608	mbox->type5.opcode = MYRB_CMD_WRITE_SG;
	1609
	1610	mbox->type5.ld.xfer_len = block_cnt;
	1611	mbox->type5.ld.ldev_num = sdev->id;
	1612	mbox->type5.lba = lba;
	1613	mbox->type5.addr = hw_sgl_addr;
	1614	mbox->type5.sg_count = nsge;
	1615
	1616	scsi_for_each_sg(scmd, sgl, nsge, i) {
	1617	hw_sgl->sge_addr = (u32)sg_dma_address(sgl);
	1618	hw_sgl->sge_count = (u32)sg_dma_len(sgl);
	1619	hw_sgl++;
	1620	}
	1621	}
	1622	submit:
	1623	spin_lock_irqsave(&cb->queue_lock, flags);
	1624	cb->qcmd(cb, cmd_blk);
	1625	spin_unlock_irqrestore(&cb->queue_lock, flags);
	1626
	1627	return 0;
	1628	}
	1629
	1630	static int myrb_queuecommand(struct Scsi_Host *shost,
	1631	struct scsi_cmnd *scmd)
	1632	{
	1633	struct scsi_device *sdev = scmd->device;
	1634
	1635	if (sdev->channel > myrb_logical_channel(shost)) {
	1636	scmd->result = (DID_BAD_TARGET << 16);
	1637	scmd->scsi_done(scmd);
	1638	return 0;
	1639	}
	1640	if (sdev->channel == myrb_logical_channel(shost))
	1641	return myrb_ldev_queuecommand(shost, scmd);
	1642
	1643	return myrb_pthru_queuecommand(shost, scmd);
	1644	}
	1645
	1646	static int myrb_ldev_slave_alloc(struct scsi_device *sdev)
	1647	{
	1648	struct myrb_hba *cb = shost_priv(sdev->host);
	1649	struct myrb_ldev_info *ldev_info;
	1650	unsigned short ldev_num = sdev->id;
	1651	enum raid_level level;
	1652
	1653	ldev_info = cb->ldev_info_buf + ldev_num;
	1654	if (!ldev_info)
	1655	return -ENXIO;
	1656
	1657	sdev->hostdata = kzalloc(sizeof(*ldev_info), GFP_KERNEL);
	1658	if (!sdev->hostdata)
	1659	return -ENOMEM;
	1660	dev_dbg(&sdev->sdev_gendev,
	1661	"slave alloc ldev %d state %x\n",
	1662	ldev_num, ldev_info->state);
	1663	memcpy(sdev->hostdata, ldev_info,
	1664	sizeof(*ldev_info));
	1665	switch (ldev_info->raid_level) {
	1666	case MYRB_RAID_LEVEL0:
	1667	level = RAID_LEVEL_LINEAR;
	1668	break;
	1669	case MYRB_RAID_LEVEL1:
	1670	level = RAID_LEVEL_1;
	1671	break;
	1672	case MYRB_RAID_LEVEL3:
	1673	level = RAID_LEVEL_3;
	1674	break;
	1675	case MYRB_RAID_LEVEL5:
	1676	level = RAID_LEVEL_5;
	1677	break;
	1678	case MYRB_RAID_LEVEL6:
	1679	level = RAID_LEVEL_6;
	1680	break;
	1681	case MYRB_RAID_JBOD:
	1682	level = RAID_LEVEL_JBOD;
	1683	break;
	1684	default:
	1685	level = RAID_LEVEL_UNKNOWN;
	1686	break;
	1687	}
	1688	raid_set_level(myrb_raid_template, &sdev->sdev_gendev, level);
	1689	return 0;
	1690	}
	1691
	1692	static int myrb_pdev_slave_alloc(struct scsi_device *sdev)
	1693	{
	1694	struct myrb_hba *cb = shost_priv(sdev->host);
	1695	struct myrb_pdev_state *pdev_info;
	1696	unsigned short status;
	1697
	1698	if (sdev->id > MYRB_MAX_TARGETS)
	1699	return -ENXIO;
	1700
	1701	pdev_info = kzalloc(sizeof(*pdev_info), GFP_KERNEL\|GFP_DMA);
	1702	if (!pdev_info)
	1703	return -ENOMEM;
	1704
	1705	status = myrb_exec_type3D(cb, MYRB_CMD_GET_DEVICE_STATE,
	1706	sdev, pdev_info);
	1707	if (status != MYRB_STATUS_SUCCESS) {
	1708	dev_dbg(&sdev->sdev_gendev,
	1709	"Failed to get device state, status %x\n",
	1710	status);
	1711	kfree(pdev_info);
	1712	return -ENXIO;
	1713	}
	1714	if (!pdev_info->present) {
	1715	dev_dbg(&sdev->sdev_gendev,
	1716	"device not present, skip\n");
	1717	kfree(pdev_info);
	1718	return -ENXIO;
	1719	}
	1720	dev_dbg(&sdev->sdev_gendev,
	1721	"slave alloc pdev %d:%d state %x\n",
	1722	sdev->channel, sdev->id, pdev_info->state);
	1723	sdev->hostdata = pdev_info;
	1724
	1725	return 0;
	1726	}
	1727
	1728	static int myrb_slave_alloc(struct scsi_device *sdev)
	1729	{
	1730	if (sdev->channel > myrb_logical_channel(sdev->host))
	1731	return -ENXIO;
	1732
	1733	if (sdev->lun > 0)
	1734	return -ENXIO;
	1735
	1736	if (sdev->channel == myrb_logical_channel(sdev->host))
	1737	return myrb_ldev_slave_alloc(sdev);
	1738
	1739	return myrb_pdev_slave_alloc(sdev);
	1740	}
	1741
	1742	static int myrb_slave_configure(struct scsi_device *sdev)
	1743	{
	1744	struct myrb_ldev_info *ldev_info;
	1745
	1746	if (sdev->channel > myrb_logical_channel(sdev->host))
	1747	return -ENXIO;
	1748
	1749	if (sdev->channel < myrb_logical_channel(sdev->host)) {
	1750	sdev->no_uld_attach = 1;
	1751	return 0;
	1752	}
	1753	if (sdev->lun != 0)
	1754	return -ENXIO;
	1755
	1756	ldev_info = sdev->hostdata;
	1757	if (!ldev_info)
	1758	return -ENXIO;
	1759	if (ldev_info->state != MYRB_DEVICE_ONLINE)
	1760	sdev_printk(KERN_INFO, sdev,
	1761	"Logical drive is %s\n",
	1762	myrb_devstate_name(ldev_info->state));
	1763
	1764	sdev->tagged_supported = 1;
	1765	return 0;
	1766	}
	1767
	1768	static void myrb_slave_destroy(struct scsi_device *sdev)
	1769	{
	1770	kfree(sdev->hostdata);
	1771	}
	1772
	1773	static int myrb_biosparam(struct scsi_device sdev, struct block_device bdev,
	1774	sector_t capacity, int geom[])
	1775	{
	1776	struct myrb_hba *cb = shost_priv(sdev->host);
	1777
	1778	geom[0] = cb->ldev_geom_heads;
	1779	geom[1] = cb->ldev_geom_sectors;
	1780	geom[2] = sector_div(capacity, geom[0] * geom[1]);
	1781
	1782	return 0;
	1783	}
	1784
	1785	static ssize_t raid_state_show(struct device *dev,
	1786	struct device_attribute attr, char buf)
	1787	{
	1788	struct scsi_device *sdev = to_scsi_device(dev);
	1789	struct myrb_hba *cb = shost_priv(sdev->host);
	1790	int ret;
	1791
	1792	if (!sdev->hostdata)
	1793	return snprintf(buf, 16, "Unknown\n");
	1794
	1795	if (sdev->channel == myrb_logical_channel(sdev->host)) {
	1796	struct myrb_ldev_info *ldev_info = sdev->hostdata;
	1797	const char *name;
	1798
	1799	name = myrb_devstate_name(ldev_info->state);
	1800	if (name)
	1801	ret = snprintf(buf, 32, "%s\n", name);
	1802	else
	1803	ret = snprintf(buf, 32, "Invalid (%02X)\n",
	1804	ldev_info->state);
	1805	} else {
	1806	struct myrb_pdev_state *pdev_info = sdev->hostdata;
	1807	unsigned short status;
	1808	const char *name;
	1809
	1810	status = myrb_exec_type3D(cb, MYRB_CMD_GET_DEVICE_STATE,
	1811	sdev, pdev_info);
	1812	if (status != MYRB_STATUS_SUCCESS)
	1813	sdev_printk(KERN_INFO, sdev,
	1814	"Failed to get device state, status %x\n",
	1815	status);
	1816
	1817	if (!pdev_info->present)
	1818	name = "Removed";
	1819	else
	1820	name = myrb_devstate_name(pdev_info->state);
	1821	if (name)
	1822	ret = snprintf(buf, 32, "%s\n", name);
	1823	else
	1824	ret = snprintf(buf, 32, "Invalid (%02X)\n",
	1825	pdev_info->state);
	1826	}
	1827	return ret;
	1828	}
	1829
	1830	static ssize_t raid_state_store(struct device *dev,
	1831	struct device_attribute attr, const char buf, size_t count)
	1832	{
	1833	struct scsi_device *sdev = to_scsi_device(dev);
	1834	struct myrb_hba *cb = shost_priv(sdev->host);
	1835	struct myrb_pdev_state *pdev_info;
	1836	enum myrb_devstate new_state;
	1837	unsigned short status;
	1838
	1839	if (!strncmp(buf, "kill", 4) \|\|
	1840	!strncmp(buf, "offline", 7))
	1841	new_state = MYRB_DEVICE_DEAD;
	1842	else if (!strncmp(buf, "online", 6))
	1843	new_state = MYRB_DEVICE_ONLINE;
	1844	else if (!strncmp(buf, "standby", 7))
	1845	new_state = MYRB_DEVICE_STANDBY;
	1846	else
	1847	return -EINVAL;
	1848
	1849	pdev_info = sdev->hostdata;
	1850	if (!pdev_info) {
	1851	sdev_printk(KERN_INFO, sdev,
	1852	"Failed - no physical device information\n");
	1853	return -ENXIO;
	1854	}
	1855	if (!pdev_info->present) {
	1856	sdev_printk(KERN_INFO, sdev,
	1857	"Failed - device not present\n");
	1858	return -ENXIO;
	1859	}
	1860
	1861	if (pdev_info->state == new_state)
	1862	return count;
	1863
	1864	status = myrb_set_pdev_state(cb, sdev, new_state);
	1865	switch (status) {
	1866	case MYRB_STATUS_SUCCESS:
	1867	break;
	1868	case MYRB_STATUS_START_DEVICE_FAILED:
	1869	sdev_printk(KERN_INFO, sdev,
	1870	"Failed - Unable to Start Device\n");
	1871	count = -EAGAIN;
	1872	break;
	1873	case MYRB_STATUS_NO_DEVICE:
	1874	sdev_printk(KERN_INFO, sdev,
	1875	"Failed - No Device at Address\n");
	1876	count = -ENODEV;
	1877	break;
	1878	case MYRB_STATUS_INVALID_CHANNEL_OR_TARGET:
	1879	sdev_printk(KERN_INFO, sdev,
	1880	"Failed - Invalid Channel or Target or Modifier\n");
	1881	count = -EINVAL;
	1882	break;
	1883	case MYRB_STATUS_CHANNEL_BUSY:
	1884	sdev_printk(KERN_INFO, sdev,
	1885	"Failed - Channel Busy\n");
	1886	count = -EBUSY;
	1887	break;
	1888	default:
	1889	sdev_printk(KERN_INFO, sdev,
	1890	"Failed - Unexpected Status %04X\n", status);
	1891	count = -EIO;
	1892	break;
	1893	}
	1894	return count;
	1895	}
	1896	static DEVICE_ATTR_RW(raid_state);
	1897
	1898	static ssize_t raid_level_show(struct device *dev,
	1899	struct device_attribute attr, char buf)
	1900	{
	1901	struct scsi_device *sdev = to_scsi_device(dev);
	1902
	1903	if (sdev->channel == myrb_logical_channel(sdev->host)) {
	1904	struct myrb_ldev_info *ldev_info = sdev->hostdata;
	1905	const char *name;
	1906
	1907	if (!ldev_info)
	1908	return -ENXIO;
	1909
	1910	name = myrb_raidlevel_name(ldev_info->raid_level);
	1911	if (!name)
	1912	return snprintf(buf, 32, "Invalid (%02X)\n",
	1913	ldev_info->state);
	1914	return snprintf(buf, 32, "%s\n", name);
	1915	}
	1916	return snprintf(buf, 32, "Physical Drive\n");
	1917	}
	1918	static DEVICE_ATTR_RO(raid_level);
	1919
	1920	static ssize_t rebuild_show(struct device *dev,
	1921	struct device_attribute attr, char buf)
	1922	{
	1923	struct scsi_device *sdev = to_scsi_device(dev);
	1924	struct myrb_hba *cb = shost_priv(sdev->host);
	1925	struct myrb_rbld_progress rbld_buf;
	1926	unsigned char status;
	1927
	1928	if (sdev->channel < myrb_logical_channel(sdev->host))
	1929	return snprintf(buf, 32, "physical device - not rebuilding\n");
	1930
	1931	status = myrb_get_rbld_progress(cb, &rbld_buf);
	1932
	1933	if (rbld_buf.ldev_num != sdev->id \|\|
	1934	status != MYRB_STATUS_SUCCESS)
	1935	return snprintf(buf, 32, "not rebuilding\n");
	1936
	1937	return snprintf(buf, 32, "rebuilding block %u of %u\n",
	1938	rbld_buf.ldev_size - rbld_buf.blocks_left,
	1939	rbld_buf.ldev_size);
	1940	}
	1941
	1942	static ssize_t rebuild_store(struct device *dev,
	1943	struct device_attribute attr, const char buf, size_t count)
	1944	{
	1945	struct scsi_device *sdev = to_scsi_device(dev);
	1946	struct myrb_hba *cb = shost_priv(sdev->host);
	1947	struct myrb_cmdblk *cmd_blk;
	1948	union myrb_cmd_mbox *mbox;
	1949	unsigned short status;
	1950	int rc, start;
	1951	const char *msg;
	1952
	1953	rc = kstrtoint(buf, 0, &start);
	1954	if (rc)
	1955	return rc;
	1956
	1957	if (sdev->channel >= myrb_logical_channel(sdev->host))
	1958	return -ENXIO;
	1959
	1960	status = myrb_get_rbld_progress(cb, NULL);
	1961	if (start) {
	1962	if (status == MYRB_STATUS_SUCCESS) {
	1963	sdev_printk(KERN_INFO, sdev,
	1964	"Rebuild Not Initiated; already in progress\n");
	1965	return -EALREADY;
	1966	}
	1967	mutex_lock(&cb->dcmd_mutex);
	1968	cmd_blk = &cb->dcmd_blk;
	1969	myrb_reset_cmd(cmd_blk);
	1970	mbox = &cmd_blk->mbox;
	1971	mbox->type3D.opcode = MYRB_CMD_REBUILD_ASYNC;
	1972	mbox->type3D.id = MYRB_DCMD_TAG;
	1973	mbox->type3D.channel = sdev->channel;
	1974	mbox->type3D.target = sdev->id;
	1975	status = myrb_exec_cmd(cb, cmd_blk);
	1976	mutex_unlock(&cb->dcmd_mutex);
	1977	} else {
	1978	struct pci_dev *pdev = cb->pdev;
	1979	unsigned char *rate;
	1980	dma_addr_t rate_addr;
	1981
	1982	if (status != MYRB_STATUS_SUCCESS) {
	1983	sdev_printk(KERN_INFO, sdev,
	1984	"Rebuild Not Cancelled; not in progress\n");
	1985	return 0;
	1986	}
	1987
	1988	rate = dma_alloc_coherent(&pdev->dev, sizeof(char),
	1989	&rate_addr, GFP_KERNEL);
	1990	if (rate == NULL) {
	1991	sdev_printk(KERN_INFO, sdev,
	1992	"Cancellation of Rebuild Failed - Out of Memory\n");
	1993	return -ENOMEM;
	1994	}
	1995	mutex_lock(&cb->dcmd_mutex);
	1996	cmd_blk = &cb->dcmd_blk;
	1997	myrb_reset_cmd(cmd_blk);
	1998	mbox = &cmd_blk->mbox;
	1999	mbox->type3R.opcode = MYRB_CMD_REBUILD_CONTROL;
	2000	mbox->type3R.id = MYRB_DCMD_TAG;
	2001	mbox->type3R.rbld_rate = 0xFF;
	2002	mbox->type3R.addr = rate_addr;
	2003	status = myrb_exec_cmd(cb, cmd_blk);
	2004	dma_free_coherent(&pdev->dev, sizeof(char), rate, rate_addr);
	2005	mutex_unlock(&cb->dcmd_mutex);
	2006	}
	2007	if (status == MYRB_STATUS_SUCCESS) {
	2008	sdev_printk(KERN_INFO, sdev, "Rebuild %s\n",
	2009	start ? "Initiated" : "Cancelled");
	2010	return count;
	2011	}
	2012	if (!start) {
	2013	sdev_printk(KERN_INFO, sdev,
	2014	"Rebuild Not Cancelled, status 0x%x\n",
	2015	status);
	2016	return -EIO;
	2017	}
	2018
	2019	switch (status) {
	2020	case MYRB_STATUS_ATTEMPT_TO_RBLD_ONLINE_DRIVE:
	2021	msg = "Attempt to Rebuild Online or Unresponsive Drive";
	2022	break;
	2023	case MYRB_STATUS_RBLD_NEW_DISK_FAILED:
	2024	msg = "New Disk Failed During Rebuild";
	2025	break;
	2026	case MYRB_STATUS_INVALID_ADDRESS:
	2027	msg = "Invalid Device Address";
	2028	break;
	2029	case MYRB_STATUS_RBLD_OR_CHECK_INPROGRESS:
	2030	msg = "Already in Progress";
	2031	break;
	2032	default:
	2033	msg = NULL;
	2034	break;
	2035	}
	2036	if (msg)
	2037	sdev_printk(KERN_INFO, sdev,
	2038	"Rebuild Failed - %s\n", msg);
	2039	else
	2040	sdev_printk(KERN_INFO, sdev,
	2041	"Rebuild Failed, status 0x%x\n", status);
	2042
	2043	return -EIO;
	2044	}
	2045	static DEVICE_ATTR_RW(rebuild);
	2046
	2047	static ssize_t consistency_check_store(struct device *dev,
	2048	struct device_attribute attr, const char buf, size_t count)
	2049	{
	2050	struct scsi_device *sdev = to_scsi_device(dev);
	2051	struct myrb_hba *cb = shost_priv(sdev->host);
	2052	struct myrb_rbld_progress rbld_buf;
	2053	struct myrb_cmdblk *cmd_blk;
	2054	union myrb_cmd_mbox *mbox;
	2055	unsigned short ldev_num = 0xFFFF;
	2056	unsigned short status;
	2057	int rc, start;
	2058	const char *msg;
	2059
	2060	rc = kstrtoint(buf, 0, &start);
	2061	if (rc)
	2062	return rc;
	2063
	2064	if (sdev->channel < myrb_logical_channel(sdev->host))
	2065	return -ENXIO;
	2066
	2067	status = myrb_get_rbld_progress(cb, &rbld_buf);
	2068	if (start) {
	2069	if (status == MYRB_STATUS_SUCCESS) {
	2070	sdev_printk(KERN_INFO, sdev,
	2071	"Check Consistency Not Initiated; already in progress\n");
	2072	return -EALREADY;
	2073	}
	2074	mutex_lock(&cb->dcmd_mutex);
	2075	cmd_blk = &cb->dcmd_blk;
	2076	myrb_reset_cmd(cmd_blk);
	2077	mbox = &cmd_blk->mbox;
	2078	mbox->type3C.opcode = MYRB_CMD_CHECK_CONSISTENCY_ASYNC;
	2079	mbox->type3C.id = MYRB_DCMD_TAG;
	2080	mbox->type3C.ldev_num = sdev->id;
	2081	mbox->type3C.auto_restore = true;
	2082
	2083	status = myrb_exec_cmd(cb, cmd_blk);
	2084	mutex_unlock(&cb->dcmd_mutex);
	2085	} else {
	2086	struct pci_dev *pdev = cb->pdev;
	2087	unsigned char *rate;
	2088	dma_addr_t rate_addr;
	2089
	2090	if (ldev_num != sdev->id) {
	2091	sdev_printk(KERN_INFO, sdev,
	2092	"Check Consistency Not Cancelled; not in progress\n");
	2093	return 0;
	2094	}
	2095	rate = dma_alloc_coherent(&pdev->dev, sizeof(char),
	2096	&rate_addr, GFP_KERNEL);
	2097	if (rate == NULL) {
	2098	sdev_printk(KERN_INFO, sdev,
	2099	"Cancellation of Check Consistency Failed - Out of Memory\n");
	2100	return -ENOMEM;
	2101	}
	2102	mutex_lock(&cb->dcmd_mutex);
	2103	cmd_blk = &cb->dcmd_blk;
	2104	myrb_reset_cmd(cmd_blk);
	2105	mbox = &cmd_blk->mbox;
	2106	mbox->type3R.opcode = MYRB_CMD_REBUILD_CONTROL;
	2107	mbox->type3R.id = MYRB_DCMD_TAG;
	2108	mbox->type3R.rbld_rate = 0xFF;
	2109	mbox->type3R.addr = rate_addr;
	2110	status = myrb_exec_cmd(cb, cmd_blk);
	2111	dma_free_coherent(&pdev->dev, sizeof(char), rate, rate_addr);
	2112	mutex_unlock(&cb->dcmd_mutex);
	2113	}
	2114	if (status == MYRB_STATUS_SUCCESS) {
	2115	sdev_printk(KERN_INFO, sdev, "Check Consistency %s\n",
	2116	start ? "Initiated" : "Cancelled");
	2117	return count;
	2118	}
	2119	if (!start) {
	2120	sdev_printk(KERN_INFO, sdev,
	2121	"Check Consistency Not Cancelled, status 0x%x\n",
	2122	status);
	2123	return -EIO;
	2124	}
	2125
	2126	switch (status) {
	2127	case MYRB_STATUS_ATTEMPT_TO_RBLD_ONLINE_DRIVE:
	2128	msg = "Dependent Physical Device is DEAD";
	2129	break;
	2130	case MYRB_STATUS_RBLD_NEW_DISK_FAILED:
	2131	msg = "New Disk Failed During Rebuild";
	2132	break;
	2133	case MYRB_STATUS_INVALID_ADDRESS:
	2134	msg = "Invalid or Nonredundant Logical Drive";
	2135	break;
	2136	case MYRB_STATUS_RBLD_OR_CHECK_INPROGRESS:
	2137	msg = "Already in Progress";
	2138	break;
	2139	default:
	2140	msg = NULL;
	2141	break;
	2142	}
	2143	if (msg)
	2144	sdev_printk(KERN_INFO, sdev,
	2145	"Check Consistency Failed - %s\n", msg);
	2146	else
	2147	sdev_printk(KERN_INFO, sdev,
	2148	"Check Consistency Failed, status 0x%x\n", status);
	2149
	2150	return -EIO;
	2151	}
	2152
	2153	static ssize_t consistency_check_show(struct device *dev,
	2154	struct device_attribute attr, char buf)
	2155	{
	2156	return rebuild_show(dev, attr, buf);
	2157	}
	2158	static DEVICE_ATTR_RW(consistency_check);
	2159
	2160	static ssize_t ctlr_num_show(struct device *dev,
	2161	struct device_attribute attr, char buf)
	2162	{
	2163	struct Scsi_Host *shost = class_to_shost(dev);
	2164	struct myrb_hba *cb = shost_priv(shost);
	2165
	2166	return snprintf(buf, 20, "%d\n", cb->ctlr_num);
	2167	}
	2168	static DEVICE_ATTR_RO(ctlr_num);
	2169
	2170	static ssize_t firmware_show(struct device *dev,
	2171	struct device_attribute attr, char buf)
	2172	{
	2173	struct Scsi_Host *shost = class_to_shost(dev);
	2174	struct myrb_hba *cb = shost_priv(shost);
	2175
	2176	return snprintf(buf, 16, "%s\n", cb->fw_version);
	2177	}
	2178	static DEVICE_ATTR_RO(firmware);
	2179
	2180	static ssize_t model_show(struct device *dev,
	2181	struct device_attribute attr, char buf)
	2182	{
	2183	struct Scsi_Host *shost = class_to_shost(dev);
	2184	struct myrb_hba *cb = shost_priv(shost);
	2185
	2186	return snprintf(buf, 16, "%s\n", cb->model_name);
	2187	}
	2188	static DEVICE_ATTR_RO(model);
	2189
	2190	static ssize_t flush_cache_store(struct device *dev,
	2191	struct device_attribute attr, const char buf, size_t count)
	2192	{
	2193	struct Scsi_Host *shost = class_to_shost(dev);
	2194	struct myrb_hba *cb = shost_priv(shost);
	2195	unsigned short status;
	2196
	2197	status = myrb_exec_type3(cb, MYRB_CMD_FLUSH, 0);
	2198	if (status == MYRB_STATUS_SUCCESS) {
	2199	shost_printk(KERN_INFO, shost,
	2200	"Cache Flush Completed\n");
	2201	return count;
	2202	}
	2203	shost_printk(KERN_INFO, shost,
	2204	"Cache Flush Failed, status %x\n", status);
	2205	return -EIO;
	2206	}
	2207	static DEVICE_ATTR_WO(flush_cache);
	2208
	2209	static struct device_attribute *myrb_sdev_attrs[] = {
	2210	&dev_attr_rebuild,
	2211	&dev_attr_consistency_check,
	2212	&dev_attr_raid_state,
	2213	&dev_attr_raid_level,
	2214	NULL,
	2215	};
	2216
	2217	static struct device_attribute *myrb_shost_attrs[] = {
	2218	&dev_attr_ctlr_num,
	2219	&dev_attr_model,
	2220	&dev_attr_firmware,
	2221	&dev_attr_flush_cache,
	2222	NULL,
	2223	};
	2224
	2225	struct scsi_host_template myrb_template = {
	2226	.module = THIS_MODULE,
	2227	.name = "DAC960",
	2228	.proc_name = "myrb",
	2229	.queuecommand = myrb_queuecommand,
	2230	.eh_host_reset_handler = myrb_host_reset,
	2231	.slave_alloc = myrb_slave_alloc,
	2232	.slave_configure = myrb_slave_configure,
	2233	.slave_destroy = myrb_slave_destroy,
	2234	.bios_param = myrb_biosparam,
	2235	.cmd_size = sizeof(struct myrb_cmdblk),
	2236	.shost_attrs = myrb_shost_attrs,
	2237	.sdev_attrs = myrb_sdev_attrs,
	2238	.this_id = -1,
	2239	};
	2240
	2241	/**
	2242	* myrb_is_raid - return boolean indicating device is raid volume
	2243	* @dev the device struct object
	2244	*/
	2245	static int myrb_is_raid(struct device *dev)
	2246	{
	2247	struct scsi_device *sdev = to_scsi_device(dev);
	2248
	2249	return sdev->channel == myrb_logical_channel(sdev->host);
	2250	}
	2251
	2252	/**
	2253	* myrb_get_resync - get raid volume resync percent complete
	2254	* @dev the device struct object
	2255	*/
	2256	static void myrb_get_resync(struct device *dev)
	2257	{
	2258	struct scsi_device *sdev = to_scsi_device(dev);
	2259	struct myrb_hba *cb = shost_priv(sdev->host);
	2260	struct myrb_rbld_progress rbld_buf;
	2261	unsigned int percent_complete = 0;
	2262	unsigned short status;
	2263	unsigned int ldev_size = 0, remaining = 0;
	2264
	2265	if (sdev->channel < myrb_logical_channel(sdev->host))
	2266	return;
	2267	status = myrb_get_rbld_progress(cb, &rbld_buf);
	2268	if (status == MYRB_STATUS_SUCCESS) {
	2269	if (rbld_buf.ldev_num == sdev->id) {
	2270	ldev_size = rbld_buf.ldev_size;
	2271	remaining = rbld_buf.blocks_left;
	2272	}
	2273	}
	2274	if (remaining && ldev_size)
	2275	percent_complete = (ldev_size - remaining) * 100 / ldev_size;
	2276	raid_set_resync(myrb_raid_template, dev, percent_complete);
	2277	}
	2278
	2279	/**
	2280	* myrb_get_state - get raid volume status
	2281	* @dev the device struct object
	2282	*/
	2283	static void myrb_get_state(struct device *dev)
	2284	{
	2285	struct scsi_device *sdev = to_scsi_device(dev);
	2286	struct myrb_hba *cb = shost_priv(sdev->host);
	2287	struct myrb_ldev_info *ldev_info = sdev->hostdata;
	2288	enum raid_state state = RAID_STATE_UNKNOWN;
	2289	unsigned short status;
	2290
	2291	if (sdev->channel < myrb_logical_channel(sdev->host) \|\| !ldev_info)
	2292	state = RAID_STATE_UNKNOWN;
	2293	else {
	2294	status = myrb_get_rbld_progress(cb, NULL);
	2295	if (status == MYRB_STATUS_SUCCESS)
	2296	state = RAID_STATE_RESYNCING;
	2297	else {
	2298	switch (ldev_info->state) {
	2299	case MYRB_DEVICE_ONLINE:
	2300	state = RAID_STATE_ACTIVE;
	2301	break;
	2302	case MYRB_DEVICE_WO:
	2303	case MYRB_DEVICE_CRITICAL:
	2304	state = RAID_STATE_DEGRADED;
	2305	break;
	2306	default:
	2307	state = RAID_STATE_OFFLINE;
	2308	}
	2309	}
	2310	}
	2311	raid_set_state(myrb_raid_template, dev, state);
	2312	}
	2313
	2314	struct raid_function_template myrb_raid_functions = {
	2315	.cookie = &myrb_template,
	2316	.is_raid = myrb_is_raid,
	2317	.get_resync = myrb_get_resync,
	2318	.get_state = myrb_get_state,
	2319	};
	2320
	2321	static void myrb_handle_scsi(struct myrb_hba cb, struct myrb_cmdblk cmd_blk,
	2322	struct scsi_cmnd *scmd)
	2323	{
	2324	unsigned short status;
	2325
	2326	if (!cmd_blk)
	2327	return;
	2328
	2329	scsi_dma_unmap(scmd);
	2330
	2331	if (cmd_blk->dcdb) {
	2332	memcpy(scmd->sense_buffer, &cmd_blk->dcdb->sense, 64);
	2333	dma_pool_free(cb->dcdb_pool, cmd_blk->dcdb,
	2334	cmd_blk->dcdb_addr);
	2335	cmd_blk->dcdb = NULL;
	2336	}
	2337	if (cmd_blk->sgl) {
	2338	dma_pool_free(cb->sg_pool, cmd_blk->sgl, cmd_blk->sgl_addr);
	2339	cmd_blk->sgl = NULL;
	2340	cmd_blk->sgl_addr = 0;
	2341	}
	2342	status = cmd_blk->status;
	2343	switch (status) {
	2344	case MYRB_STATUS_SUCCESS:
	2345	case MYRB_STATUS_DEVICE_BUSY:
	2346	scmd->result = (DID_OK << 16) \| status;
	2347	break;
	2348	case MYRB_STATUS_BAD_DATA:
	2349	dev_dbg(&scmd->device->sdev_gendev,
	2350	"Bad Data Encountered\n");
	2351	if (scmd->sc_data_direction == DMA_FROM_DEVICE)
	2352	/* Unrecovered read error */
	2353	scsi_build_sense_buffer(0, scmd->sense_buffer,
	2354	MEDIUM_ERROR, 0x11, 0);
	2355	else
	2356	/* Write error */
	2357	scsi_build_sense_buffer(0, scmd->sense_buffer,
	2358	MEDIUM_ERROR, 0x0C, 0);
	2359	scmd->result = (DID_OK << 16) \| SAM_STAT_CHECK_CONDITION;
	2360	break;
	2361	case MYRB_STATUS_IRRECOVERABLE_DATA_ERROR:
	2362	scmd_printk(KERN_ERR, scmd, "Irrecoverable Data Error\n");
	2363	if (scmd->sc_data_direction == DMA_FROM_DEVICE)
	2364	/* Unrecovered read error, auto-reallocation failed */
	2365	scsi_build_sense_buffer(0, scmd->sense_buffer,
	2366	MEDIUM_ERROR, 0x11, 0x04);
	2367	else
	2368	/* Write error, auto-reallocation failed */
	2369	scsi_build_sense_buffer(0, scmd->sense_buffer,
	2370	MEDIUM_ERROR, 0x0C, 0x02);
	2371	scmd->result = (DID_OK << 16) \| SAM_STAT_CHECK_CONDITION;
	2372	break;
	2373	case MYRB_STATUS_LDRV_NONEXISTENT_OR_OFFLINE:
	2374	dev_dbg(&scmd->device->sdev_gendev,
	2375	"Logical Drive Nonexistent or Offline");
	2376	scmd->result = (DID_BAD_TARGET << 16);
	2377	break;
	2378	case MYRB_STATUS_ACCESS_BEYOND_END_OF_LDRV:
	2379	dev_dbg(&scmd->device->sdev_gendev,
	2380	"Attempt to Access Beyond End of Logical Drive");
	2381	/* Logical block address out of range */
	2382	scsi_build_sense_buffer(0, scmd->sense_buffer,
	2383	NOT_READY, 0x21, 0);
	2384	break;
	2385	case MYRB_STATUS_DEVICE_NONRESPONSIVE:
	2386	dev_dbg(&scmd->device->sdev_gendev, "Device nonresponsive\n");
	2387	scmd->result = (DID_BAD_TARGET << 16);
	2388	break;
	2389	default:
	2390	scmd_printk(KERN_ERR, scmd,
	2391	"Unexpected Error Status %04X", status);
	2392	scmd->result = (DID_ERROR << 16);
	2393	break;
	2394	}
	2395	scmd->scsi_done(scmd);
	2396	}
	2397
	2398	static void myrb_handle_cmdblk(struct myrb_hba cb, struct myrb_cmdblk cmd_blk)
	2399	{
	2400	if (!cmd_blk)
	2401	return;
	2402
	2403	if (cmd_blk->completion) {
	2404	complete(cmd_blk->completion);
	2405	cmd_blk->completion = NULL;
	2406	}
	2407	}
	2408
	2409	static void myrb_monitor(struct work_struct *work)
	2410	{
	2411	struct myrb_hba *cb = container_of(work,
	2412	struct myrb_hba, monitor_work.work);
	2413	struct Scsi_Host *shost = cb->host;
	2414	unsigned long interval = MYRB_PRIMARY_MONITOR_INTERVAL;
	2415
	2416	dev_dbg(&shost->shost_gendev, "monitor tick\n");
	2417
	2418	if (cb->new_ev_seq > cb->old_ev_seq) {
	2419	int event = cb->old_ev_seq;
	2420
	2421	dev_dbg(&shost->shost_gendev,
	2422	"get event log no %d/%d\n",
	2423	cb->new_ev_seq, event);
	2424	myrb_get_event(cb, event);
	2425	cb->old_ev_seq = event + 1;
	2426	interval = 10;
	2427	} else if (cb->need_err_info) {
	2428	cb->need_err_info = false;
	2429	dev_dbg(&shost->shost_gendev, "get error table\n");
	2430	myrb_get_errtable(cb);
	2431	interval = 10;
	2432	} else if (cb->need_rbld && cb->rbld_first) {
	2433	cb->need_rbld = false;
	2434	dev_dbg(&shost->shost_gendev,
	2435	"get rebuild progress\n");
	2436	myrb_update_rbld_progress(cb);
	2437	interval = 10;
	2438	} else if (cb->need_ldev_info) {
	2439	cb->need_ldev_info = false;
	2440	dev_dbg(&shost->shost_gendev,
	2441	"get logical drive info\n");
	2442	myrb_get_ldev_info(cb);
	2443	interval = 10;
	2444	} else if (cb->need_rbld) {
	2445	cb->need_rbld = false;
	2446	dev_dbg(&shost->shost_gendev,
	2447	"get rebuild progress\n");
	2448	myrb_update_rbld_progress(cb);
	2449	interval = 10;
	2450	} else if (cb->need_cc_status) {
	2451	cb->need_cc_status = false;
	2452	dev_dbg(&shost->shost_gendev,
	2453	"get consistency check progress\n");
	2454	myrb_get_cc_progress(cb);
	2455	interval = 10;
	2456	} else if (cb->need_bgi_status) {
	2457	cb->need_bgi_status = false;
	2458	dev_dbg(&shost->shost_gendev, "get background init status\n");
	2459	myrb_bgi_control(cb);
	2460	interval = 10;
	2461	} else {
	2462	dev_dbg(&shost->shost_gendev, "new enquiry\n");
	2463	mutex_lock(&cb->dma_mutex);
	2464	myrb_hba_enquiry(cb);
	2465	mutex_unlock(&cb->dma_mutex);
	2466	if ((cb->new_ev_seq - cb->old_ev_seq > 0) \|\|
	2467	cb->need_err_info \|\| cb->need_rbld \|\|
	2468	cb->need_ldev_info \|\| cb->need_cc_status \|\|
	2469	cb->need_bgi_status) {
	2470	dev_dbg(&shost->shost_gendev,
	2471	"reschedule monitor\n");
	2472	interval = 0;
	2473	}
	2474	}
	2475	if (interval > 1)
	2476	cb->primary_monitor_time = jiffies;
	2477	queue_delayed_work(cb->work_q, &cb->monitor_work, interval);
	2478	}
	2479
	2480	/**
	2481	* myrb_err_status - reports controller BIOS messages
	2482	*
	2483	* Controller BIOS messages are passed through the Error Status Register
	2484	* when the driver performs the BIOS handshaking.
	2485	*
	2486	* Return: true for fatal errors and false otherwise.
	2487	*/
	2488	bool myrb_err_status(struct myrb_hba *cb, unsigned char error,
	2489	unsigned char parm0, unsigned char parm1)
	2490	{
	2491	struct pci_dev *pdev = cb->pdev;
	2492
	2493	switch (error) {
	2494	case 0x00:
	2495	dev_info(&pdev->dev,
	2496	"Physical Device %d:%d Not Responding\n",
	2497	parm1, parm0);
	2498	break;
	2499	case 0x08:
	2500	dev_notice(&pdev->dev, "Spinning Up Drives\n");
	2501	break;
	2502	case 0x30:
	2503	dev_notice(&pdev->dev, "Configuration Checksum Error\n");
	2504	break;
	2505	case 0x60:
	2506	dev_notice(&pdev->dev, "Mirror Race Recovery Failed\n");
	2507	break;
	2508	case 0x70:
	2509	dev_notice(&pdev->dev, "Mirror Race Recovery In Progress\n");
	2510	break;
	2511	case 0x90:
	2512	dev_notice(&pdev->dev, "Physical Device %d:%d COD Mismatch\n",
	2513	parm1, parm0);
	2514	break;
	2515	case 0xA0:
	2516	dev_notice(&pdev->dev, "Logical Drive Installation Aborted\n");
	2517	break;
	2518	case 0xB0:
	2519	dev_notice(&pdev->dev, "Mirror Race On A Critical Logical Drive\n");
	2520	break;
	2521	case 0xD0:
	2522	dev_notice(&pdev->dev, "New Controller Configuration Found\n");
	2523	break;
	2524	case 0xF0:
	2525	dev_err(&pdev->dev, "Fatal Memory Parity Error\n");
	2526	return true;
	2527	default:
	2528	dev_err(&pdev->dev, "Unknown Initialization Error %02X\n",
	2529	error);
	2530	return true;
	2531	}
	2532	return false;
	2533	}
	2534
	2535	/*
	2536	* Hardware-specific functions
	2537	*/
	2538
	2539	/*
	2540	* DAC960 LA Series Controllers
	2541	*/
	2542
	2543	static inline void DAC960_LA_hw_mbox_new_cmd(void __iomem *base)
	2544	{
	2545	writeb(DAC960_LA_IDB_HWMBOX_NEW_CMD, base + DAC960_LA_IDB_OFFSET);
	2546	}
	2547
	2548	static inline void DAC960_LA_ack_hw_mbox_status(void __iomem *base)
	2549	{
	2550	writeb(DAC960_LA_IDB_HWMBOX_ACK_STS, base + DAC960_LA_IDB_OFFSET);
	2551	}
	2552
	2553	static inline void DAC960_LA_gen_intr(void __iomem *base)
	2554	{
	2555	writeb(DAC960_LA_IDB_GEN_IRQ, base + DAC960_LA_IDB_OFFSET);
	2556	}
	2557
	2558	static inline void DAC960_LA_reset_ctrl(void __iomem *base)
	2559	{
	2560	writeb(DAC960_LA_IDB_CTRL_RESET, base + DAC960_LA_IDB_OFFSET);
	2561	}
	2562
	2563	static inline void DAC960_LA_mem_mbox_new_cmd(void __iomem *base)
	2564	{
	2565	writeb(DAC960_LA_IDB_MMBOX_NEW_CMD, base + DAC960_LA_IDB_OFFSET);
	2566	}
	2567
	2568	static inline bool DAC960_LA_hw_mbox_is_full(void __iomem *base)
	2569	{
	2570	unsigned char idb = readb(base + DAC960_LA_IDB_OFFSET);
	2571
	2572	return !(idb & DAC960_LA_IDB_HWMBOX_EMPTY);
	2573	}
	2574
	2575	static inline bool DAC960_LA_init_in_progress(void __iomem *base)
	2576	{
	2577	unsigned char idb = readb(base + DAC960_LA_IDB_OFFSET);
	2578
	2579	return !(idb & DAC960_LA_IDB_INIT_DONE);
	2580	}
	2581
	2582	static inline void DAC960_LA_ack_hw_mbox_intr(void __iomem *base)
	2583	{
	2584	writeb(DAC960_LA_ODB_HWMBOX_ACK_IRQ, base + DAC960_LA_ODB_OFFSET);
	2585	}
	2586
	2587	static inline void DAC960_LA_ack_mem_mbox_intr(void __iomem *base)
	2588	{
	2589	writeb(DAC960_LA_ODB_MMBOX_ACK_IRQ, base + DAC960_LA_ODB_OFFSET);
	2590	}
	2591
	2592	static inline void DAC960_LA_ack_intr(void __iomem *base)
	2593	{
	2594	writeb(DAC960_LA_ODB_HWMBOX_ACK_IRQ \| DAC960_LA_ODB_MMBOX_ACK_IRQ,
	2595	base + DAC960_LA_ODB_OFFSET);
	2596	}
	2597
	2598	static inline bool DAC960_LA_hw_mbox_status_available(void __iomem *base)
	2599	{
	2600	unsigned char odb = readb(base + DAC960_LA_ODB_OFFSET);
	2601
	2602	return odb & DAC960_LA_ODB_HWMBOX_STS_AVAIL;
	2603	}
	2604
	2605	static inline bool DAC960_LA_mem_mbox_status_available(void __iomem *base)
	2606	{
	2607	unsigned char odb = readb(base + DAC960_LA_ODB_OFFSET);
	2608
	2609	return odb & DAC960_LA_ODB_MMBOX_STS_AVAIL;
	2610	}
	2611
	2612	static inline void DAC960_LA_enable_intr(void __iomem *base)
	2613	{
	2614	unsigned char odb = 0xFF;
	2615
	2616	odb &= ~DAC960_LA_IRQMASK_DISABLE_IRQ;
	2617	writeb(odb, base + DAC960_LA_IRQMASK_OFFSET);
	2618	}
	2619
	2620	static inline void DAC960_LA_disable_intr(void __iomem *base)
	2621	{
	2622	unsigned char odb = 0xFF;
	2623
	2624	odb \|= DAC960_LA_IRQMASK_DISABLE_IRQ;
	2625	writeb(odb, base + DAC960_LA_IRQMASK_OFFSET);
	2626	}
	2627
	2628	static inline bool DAC960_LA_intr_enabled(void __iomem *base)
	2629	{
	2630	unsigned char imask = readb(base + DAC960_LA_IRQMASK_OFFSET);
	2631
	2632	return !(imask & DAC960_LA_IRQMASK_DISABLE_IRQ);
	2633	}
	2634
	2635	static inline void DAC960_LA_write_cmd_mbox(union myrb_cmd_mbox *mem_mbox,
	2636	union myrb_cmd_mbox *mbox)
	2637	{
	2638	mem_mbox->words[1] = mbox->words[1];
	2639	mem_mbox->words[2] = mbox->words[2];
	2640	mem_mbox->words[3] = mbox->words[3];
	2641	/* Memory barrier to prevent reordering */
	2642	wmb();
	2643	mem_mbox->words[0] = mbox->words[0];
	2644	/* Memory barrier to force PCI access */
	2645	mb();
	2646	}
	2647
	2648	static inline void DAC960_LA_write_hw_mbox(void __iomem *base,
	2649	union myrb_cmd_mbox *mbox)
	2650	{
	2651	writel(mbox->words[0], base + DAC960_LA_CMDOP_OFFSET);
	2652	writel(mbox->words[1], base + DAC960_LA_MBOX4_OFFSET);
	2653	writel(mbox->words[2], base + DAC960_LA_MBOX8_OFFSET);
	2654	writeb(mbox->bytes[12], base + DAC960_LA_MBOX12_OFFSET);
	2655	}
	2656
	2657	static inline unsigned char DAC960_LA_read_status_cmd_ident(void __iomem *base)
	2658	{
	2659	return readb(base + DAC960_LA_STSID_OFFSET);
	2660	}
	2661
	2662	static inline unsigned short DAC960_LA_read_status(void __iomem *base)
	2663	{
	2664	return readw(base + DAC960_LA_STS_OFFSET);
	2665	}
	2666
	2667	static inline bool
	2668	DAC960_LA_read_error_status(void __iomem base, unsigned char error,
	2669	unsigned char param0, unsigned char param1)
	2670	{
	2671	unsigned char errsts = readb(base + DAC960_LA_ERRSTS_OFFSET);
	2672
	2673	if (!(errsts & DAC960_LA_ERRSTS_PENDING))
	2674	return false;
	2675	errsts &= ~DAC960_LA_ERRSTS_PENDING;
	2676
	2677	*error = errsts;
	2678	*param0 = readb(base + DAC960_LA_CMDOP_OFFSET);
	2679	*param1 = readb(base + DAC960_LA_CMDID_OFFSET);
	2680	writeb(0xFF, base + DAC960_LA_ERRSTS_OFFSET);
	2681	return true;
	2682	}
	2683
	2684	static inline unsigned short
	2685	DAC960_LA_mbox_init(struct pci_dev pdev, void __iomem base,
	2686	union myrb_cmd_mbox *mbox)
	2687	{
	2688	unsigned short status;
	2689	int timeout = 0;
	2690
	2691	while (timeout < MYRB_MAILBOX_TIMEOUT) {
	2692	if (!DAC960_LA_hw_mbox_is_full(base))
	2693	break;
	2694	udelay(10);
	2695	timeout++;
	2696	}
	2697	if (DAC960_LA_hw_mbox_is_full(base)) {
	2698	dev_err(&pdev->dev,
	2699	"Timeout waiting for empty mailbox\n");
	2700	return MYRB_STATUS_SUBSYS_TIMEOUT;
	2701	}
	2702	DAC960_LA_write_hw_mbox(base, mbox);
	2703	DAC960_LA_hw_mbox_new_cmd(base);
	2704	timeout = 0;
	2705	while (timeout < MYRB_MAILBOX_TIMEOUT) {
	2706	if (DAC960_LA_hw_mbox_status_available(base))
	2707	break;
	2708	udelay(10);
	2709	timeout++;
	2710	}
	2711	if (!DAC960_LA_hw_mbox_status_available(base)) {
	2712	dev_err(&pdev->dev, "Timeout waiting for mailbox status\n");
	2713	return MYRB_STATUS_SUBSYS_TIMEOUT;
	2714	}
	2715	status = DAC960_LA_read_status(base);
	2716	DAC960_LA_ack_hw_mbox_intr(base);
	2717	DAC960_LA_ack_hw_mbox_status(base);
	2718
	2719	return status;
	2720	}
	2721
	2722	static int DAC960_LA_hw_init(struct pci_dev *pdev,
	2723	struct myrb_hba cb, void __iomem base)
	2724	{
	2725	int timeout = 0;
	2726	unsigned char error, parm0, parm1;
	2727
	2728	DAC960_LA_disable_intr(base);
	2729	DAC960_LA_ack_hw_mbox_status(base);
	2730	udelay(1000);
	2731	timeout = 0;
	2732	while (DAC960_LA_init_in_progress(base) &&
	2733	timeout < MYRB_MAILBOX_TIMEOUT) {
	2734	if (DAC960_LA_read_error_status(base, &error,
	2735	&parm0, &parm1) &&
	2736	myrb_err_status(cb, error, parm0, parm1))
	2737	return -ENODEV;
	2738	udelay(10);
	2739	timeout++;
	2740	}
	2741	if (timeout == MYRB_MAILBOX_TIMEOUT) {
	2742	dev_err(&pdev->dev,
	2743	"Timeout waiting for Controller Initialisation\n");
	2744	return -ETIMEDOUT;
	2745	}
	2746	if (!myrb_enable_mmio(cb, DAC960_LA_mbox_init)) {
	2747	dev_err(&pdev->dev,
	2748	"Unable to Enable Memory Mailbox Interface\n");
	2749	DAC960_LA_reset_ctrl(base);
	2750	return -ENODEV;
	2751	}
	2752	DAC960_LA_enable_intr(base);
	2753	cb->qcmd = myrb_qcmd;
	2754	cb->write_cmd_mbox = DAC960_LA_write_cmd_mbox;
	2755	if (cb->dual_mode_interface)
	2756	cb->get_cmd_mbox = DAC960_LA_mem_mbox_new_cmd;
	2757	else
	2758	cb->get_cmd_mbox = DAC960_LA_hw_mbox_new_cmd;
	2759	cb->disable_intr = DAC960_LA_disable_intr;
	2760	cb->reset = DAC960_LA_reset_ctrl;
	2761
	2762	return 0;
	2763	}
	2764
	2765	static irqreturn_t DAC960_LA_intr_handler(int irq, void *arg)
	2766	{
	2767	struct myrb_hba *cb = arg;
	2768	void __iomem *base = cb->io_base;
	2769	struct myrb_stat_mbox *next_stat_mbox;
	2770	unsigned long flags;
	2771
	2772	spin_lock_irqsave(&cb->queue_lock, flags);
	2773	DAC960_LA_ack_intr(base);
	2774	next_stat_mbox = cb->next_stat_mbox;
	2775	while (next_stat_mbox->valid) {
	2776	unsigned char id = next_stat_mbox->id;
	2777	struct scsi_cmnd *scmd = NULL;
	2778	struct myrb_cmdblk *cmd_blk = NULL;
	2779
	2780	if (id == MYRB_DCMD_TAG)
	2781	cmd_blk = &cb->dcmd_blk;
	2782	else if (id == MYRB_MCMD_TAG)
	2783	cmd_blk = &cb->mcmd_blk;
	2784	else {
	2785	scmd = scsi_host_find_tag(cb->host, id - 3);
	2786	if (scmd)
	2787	cmd_blk = scsi_cmd_priv(scmd);
	2788	}
	2789	if (cmd_blk)
	2790	cmd_blk->status = next_stat_mbox->status;
	2791	else
	2792	dev_err(&cb->pdev->dev,
	2793	"Unhandled command completion %d\n", id);
	2794
	2795	memset(next_stat_mbox, 0, sizeof(struct myrb_stat_mbox));
	2796	if (++next_stat_mbox > cb->last_stat_mbox)
	2797	next_stat_mbox = cb->first_stat_mbox;
	2798
	2799	if (cmd_blk) {
	2800	if (id < 3)
	2801	myrb_handle_cmdblk(cb, cmd_blk);
	2802	else
	2803	myrb_handle_scsi(cb, cmd_blk, scmd);
	2804	}
	2805	}
	2806	cb->next_stat_mbox = next_stat_mbox;
	2807	spin_unlock_irqrestore(&cb->queue_lock, flags);
	2808	return IRQ_HANDLED;
	2809	}
	2810
	2811	struct myrb_privdata DAC960_LA_privdata = {
	2812	.hw_init = DAC960_LA_hw_init,
	2813	.irq_handler = DAC960_LA_intr_handler,
	2814	.mmio_size = DAC960_LA_mmio_size,
	2815	};
	2816
	2817	/*
	2818	* DAC960 PG Series Controllers
	2819	*/
	2820	static inline void DAC960_PG_hw_mbox_new_cmd(void __iomem *base)
	2821	{
	2822	writel(DAC960_PG_IDB_HWMBOX_NEW_CMD, base + DAC960_PG_IDB_OFFSET);
	2823	}
	2824
	2825	static inline void DAC960_PG_ack_hw_mbox_status(void __iomem *base)
	2826	{
	2827	writel(DAC960_PG_IDB_HWMBOX_ACK_STS, base + DAC960_PG_IDB_OFFSET);
	2828	}
	2829
	2830	static inline void DAC960_PG_gen_intr(void __iomem *base)
	2831	{
	2832	writel(DAC960_PG_IDB_GEN_IRQ, base + DAC960_PG_IDB_OFFSET);
	2833	}
	2834
	2835	static inline void DAC960_PG_reset_ctrl(void __iomem *base)
	2836	{
	2837	writel(DAC960_PG_IDB_CTRL_RESET, base + DAC960_PG_IDB_OFFSET);
	2838	}
	2839
	2840	static inline void DAC960_PG_mem_mbox_new_cmd(void __iomem *base)
	2841	{
	2842	writel(DAC960_PG_IDB_MMBOX_NEW_CMD, base + DAC960_PG_IDB_OFFSET);
	2843	}
	2844
	2845	static inline bool DAC960_PG_hw_mbox_is_full(void __iomem *base)
	2846	{
	2847	unsigned char idb = readl(base + DAC960_PG_IDB_OFFSET);
	2848
	2849	return idb & DAC960_PG_IDB_HWMBOX_FULL;
	2850	}
	2851
	2852	static inline bool DAC960_PG_init_in_progress(void __iomem *base)
	2853	{
	2854	unsigned char idb = readl(base + DAC960_PG_IDB_OFFSET);
	2855
	2856	return idb & DAC960_PG_IDB_INIT_IN_PROGRESS;
	2857	}
	2858
	2859	static inline void DAC960_PG_ack_hw_mbox_intr(void __iomem *base)
	2860	{
	2861	writel(DAC960_PG_ODB_HWMBOX_ACK_IRQ, base + DAC960_PG_ODB_OFFSET);
	2862	}
	2863
	2864	static inline void DAC960_PG_ack_mem_mbox_intr(void __iomem *base)
	2865	{
	2866	writel(DAC960_PG_ODB_MMBOX_ACK_IRQ, base + DAC960_PG_ODB_OFFSET);
	2867	}
	2868
	2869	static inline void DAC960_PG_ack_intr(void __iomem *base)
	2870	{
	2871	writel(DAC960_PG_ODB_HWMBOX_ACK_IRQ \| DAC960_PG_ODB_MMBOX_ACK_IRQ,
	2872	base + DAC960_PG_ODB_OFFSET);
	2873	}
	2874
	2875	static inline bool DAC960_PG_hw_mbox_status_available(void __iomem *base)
	2876	{
	2877	unsigned char odb = readl(base + DAC960_PG_ODB_OFFSET);
	2878
	2879	return odb & DAC960_PG_ODB_HWMBOX_STS_AVAIL;
	2880	}
	2881
	2882	static inline bool DAC960_PG_mem_mbox_status_available(void __iomem *base)
	2883	{
	2884	unsigned char odb = readl(base + DAC960_PG_ODB_OFFSET);
	2885
	2886	return odb & DAC960_PG_ODB_MMBOX_STS_AVAIL;
	2887	}
	2888
	2889	static inline void DAC960_PG_enable_intr(void __iomem *base)
	2890	{
	2891	unsigned int imask = (unsigned int)-1;
	2892
	2893	imask &= ~DAC960_PG_IRQMASK_DISABLE_IRQ;
	2894	writel(imask, base + DAC960_PG_IRQMASK_OFFSET);
	2895	}
	2896
	2897	static inline void DAC960_PG_disable_intr(void __iomem *base)
	2898	{
	2899	unsigned int imask = (unsigned int)-1;
	2900
	2901	writel(imask, base + DAC960_PG_IRQMASK_OFFSET);
	2902	}
	2903
	2904	static inline bool DAC960_PG_intr_enabled(void __iomem *base)
	2905	{
	2906	unsigned int imask = readl(base + DAC960_PG_IRQMASK_OFFSET);
	2907
	2908	return !(imask & DAC960_PG_IRQMASK_DISABLE_IRQ);
	2909	}
	2910
	2911	static inline void DAC960_PG_write_cmd_mbox(union myrb_cmd_mbox *mem_mbox,
	2912	union myrb_cmd_mbox *mbox)
	2913	{
	2914	mem_mbox->words[1] = mbox->words[1];
	2915	mem_mbox->words[2] = mbox->words[2];
	2916	mem_mbox->words[3] = mbox->words[3];
	2917	/* Memory barrier to prevent reordering */
	2918	wmb();
	2919	mem_mbox->words[0] = mbox->words[0];
	2920	/* Memory barrier to force PCI access */
	2921	mb();
	2922	}
	2923
	2924	static inline void DAC960_PG_write_hw_mbox(void __iomem *base,
	2925	union myrb_cmd_mbox *mbox)
	2926	{
	2927	writel(mbox->words[0], base + DAC960_PG_CMDOP_OFFSET);
	2928	writel(mbox->words[1], base + DAC960_PG_MBOX4_OFFSET);
	2929	writel(mbox->words[2], base + DAC960_PG_MBOX8_OFFSET);
	2930	writeb(mbox->bytes[12], base + DAC960_PG_MBOX12_OFFSET);
	2931	}
	2932
	2933	static inline unsigned char
	2934	DAC960_PG_read_status_cmd_ident(void __iomem *base)
	2935	{
	2936	return readb(base + DAC960_PG_STSID_OFFSET);
	2937	}
	2938
	2939	static inline unsigned short
	2940	DAC960_PG_read_status(void __iomem *base)
	2941	{
	2942	return readw(base + DAC960_PG_STS_OFFSET);
	2943	}
	2944
	2945	static inline bool
	2946	DAC960_PG_read_error_status(void __iomem base, unsigned char error,
	2947	unsigned char param0, unsigned char param1)
	2948	{
	2949	unsigned char errsts = readb(base + DAC960_PG_ERRSTS_OFFSET);
	2950
	2951	if (!(errsts & DAC960_PG_ERRSTS_PENDING))
	2952	return false;
	2953	errsts &= ~DAC960_PG_ERRSTS_PENDING;
	2954	*error = errsts;
	2955	*param0 = readb(base + DAC960_PG_CMDOP_OFFSET);
	2956	*param1 = readb(base + DAC960_PG_CMDID_OFFSET);
	2957	writeb(0, base + DAC960_PG_ERRSTS_OFFSET);
	2958	return true;
	2959	}
	2960
	2961	static inline unsigned short
	2962	DAC960_PG_mbox_init(struct pci_dev pdev, void __iomem base,
	2963	union myrb_cmd_mbox *mbox)
	2964	{
	2965	unsigned short status;
	2966	int timeout = 0;
	2967
	2968	while (timeout < MYRB_MAILBOX_TIMEOUT) {
	2969	if (!DAC960_PG_hw_mbox_is_full(base))
	2970	break;
	2971	udelay(10);
	2972	timeout++;
	2973	}
	2974	if (DAC960_PG_hw_mbox_is_full(base)) {
	2975	dev_err(&pdev->dev,
	2976	"Timeout waiting for empty mailbox\n");
	2977	return MYRB_STATUS_SUBSYS_TIMEOUT;
	2978	}
	2979	DAC960_PG_write_hw_mbox(base, mbox);
	2980	DAC960_PG_hw_mbox_new_cmd(base);
	2981
	2982	timeout = 0;
	2983	while (timeout < MYRB_MAILBOX_TIMEOUT) {
	2984	if (DAC960_PG_hw_mbox_status_available(base))
	2985	break;
	2986	udelay(10);
	2987	timeout++;
	2988	}
	2989	if (!DAC960_PG_hw_mbox_status_available(base)) {
	2990	dev_err(&pdev->dev,
	2991	"Timeout waiting for mailbox status\n");
	2992	return MYRB_STATUS_SUBSYS_TIMEOUT;
	2993	}
	2994	status = DAC960_PG_read_status(base);
	2995	DAC960_PG_ack_hw_mbox_intr(base);
	2996	DAC960_PG_ack_hw_mbox_status(base);
	2997
	2998	return status;
	2999	}
	3000
	3001	static int DAC960_PG_hw_init(struct pci_dev *pdev,
	3002	struct myrb_hba cb, void __iomem base)
	3003	{
	3004	int timeout = 0;
	3005	unsigned char error, parm0, parm1;
	3006
	3007	DAC960_PG_disable_intr(base);
	3008	DAC960_PG_ack_hw_mbox_status(base);
	3009	udelay(1000);
	3010	while (DAC960_PG_init_in_progress(base) &&
	3011	timeout < MYRB_MAILBOX_TIMEOUT) {
	3012	if (DAC960_PG_read_error_status(base, &error,
	3013	&parm0, &parm1) &&
	3014	myrb_err_status(cb, error, parm0, parm1))
	3015	return -EIO;
	3016	udelay(10);
	3017	timeout++;
	3018	}
	3019	if (timeout == MYRB_MAILBOX_TIMEOUT) {
	3020	dev_err(&pdev->dev,
	3021	"Timeout waiting for Controller Initialisation\n");
	3022	return -ETIMEDOUT;
	3023	}
	3024	if (!myrb_enable_mmio(cb, DAC960_PG_mbox_init)) {
	3025	dev_err(&pdev->dev,
	3026	"Unable to Enable Memory Mailbox Interface\n");
	3027	DAC960_PG_reset_ctrl(base);
	3028	return -ENODEV;
	3029	}
	3030	DAC960_PG_enable_intr(base);
	3031	cb->qcmd = myrb_qcmd;
	3032	cb->write_cmd_mbox = DAC960_PG_write_cmd_mbox;
	3033	if (cb->dual_mode_interface)
	3034	cb->get_cmd_mbox = DAC960_PG_mem_mbox_new_cmd;
	3035	else
	3036	cb->get_cmd_mbox = DAC960_PG_hw_mbox_new_cmd;
	3037	cb->disable_intr = DAC960_PG_disable_intr;
	3038	cb->reset = DAC960_PG_reset_ctrl;
	3039
	3040	return 0;
	3041	}
	3042
	3043	static irqreturn_t DAC960_PG_intr_handler(int irq, void *arg)
	3044	{
	3045	struct myrb_hba *cb = arg;
	3046	void __iomem *base = cb->io_base;
	3047	struct myrb_stat_mbox *next_stat_mbox;
	3048	unsigned long flags;
	3049
	3050	spin_lock_irqsave(&cb->queue_lock, flags);
	3051	DAC960_PG_ack_intr(base);
	3052	next_stat_mbox = cb->next_stat_mbox;
	3053	while (next_stat_mbox->valid) {
	3054	unsigned char id = next_stat_mbox->id;
	3055	struct scsi_cmnd *scmd = NULL;
	3056	struct myrb_cmdblk *cmd_blk = NULL;
	3057
	3058	if (id == MYRB_DCMD_TAG)
	3059	cmd_blk = &cb->dcmd_blk;
	3060	else if (id == MYRB_MCMD_TAG)
	3061	cmd_blk = &cb->mcmd_blk;
	3062	else {
	3063	scmd = scsi_host_find_tag(cb->host, id - 3);
	3064	if (scmd)
	3065	cmd_blk = scsi_cmd_priv(scmd);
	3066	}
	3067	if (cmd_blk)
	3068	cmd_blk->status = next_stat_mbox->status;
	3069	else
	3070	dev_err(&cb->pdev->dev,
	3071	"Unhandled command completion %d\n", id);
	3072
	3073	memset(next_stat_mbox, 0, sizeof(struct myrb_stat_mbox));
	3074	if (++next_stat_mbox > cb->last_stat_mbox)
	3075	next_stat_mbox = cb->first_stat_mbox;
	3076

580 more lines aren’t shown here.

drivers/scsi/myrb.h+958−0

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

drivers/scsi/myrs.c+3268−0

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

drivers/scsi/myrs.h+1134−0

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

drivers/scsi/nsp32.c+10−8

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

drivers/scsi/osd/osd_initiator.c+1−1

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

drivers/scsi/pm8001/pm8001_defs.h+8−0

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

drivers/scsi/pm8001/pm8001_hwi.c+19−12

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

drivers/scsi/pm8001/pm8001_hwi.h+0−4

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

drivers/scsi/pm8001/pm8001_init.c+7−24

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

drivers/scsi/pm8001/pm8001_sas.c+37−12

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

drivers/scsi/pm8001/pm8001_sas.h+2−1

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

drivers/scsi/pm8001/pm80xx_hwi.c+94−25

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

drivers/scsi/pm8001/pm80xx_hwi.h+7−2

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

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

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

drivers/scsi/qedi/qedi_main.c+4−4

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

drivers/scsi/qla1280.c+13−13

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

drivers/scsi/qla2xxx/qla_attr.c+569−18

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

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

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

drivers/scsi/qla2xxx/qla_def.h+23−9

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

drivers/scsi/qla2xxx/qla_gbl.h+9−8

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

drivers/scsi/qla2xxx/qla_gs.c+143−393

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

drivers/scsi/qla2xxx/qla_init.c+257−155

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

drivers/scsi/qla2xxx/qla_inline.h+12−11

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

drivers/scsi/qla2xxx/qla_iocb.c+13−30

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

drivers/scsi/qla2xxx/qla_isr.c+44−40

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

drivers/scsi/qla2xxx/qla_mbx.c+38−14

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

drivers/scsi/qla2xxx/qla_nvme.c+2−5

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

drivers/scsi/qla2xxx/qla_nx.c+2−2

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

drivers/scsi/qla2xxx/qla_os.c+210−107

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

drivers/scsi/qla2xxx/qla_target.c+374−168

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

drivers/scsi/qla2xxx/qla_target.h+7−1

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

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

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

drivers/scsi/qla2xxx/tcm_qla2xxx.c+43−8

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

drivers/scsi/qla4xxx/ql4_init.c+4−6

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

drivers/scsi/qla4xxx/ql4_os.c+8−17

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

drivers/scsi/raid_class.c+1−3

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

drivers/scsi/scsi_error.c+0−3

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

drivers/scsi/scsi_lib.c+3−2

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

drivers/scsi/scsi_transport_sas.c+0−2

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

drivers/scsi/sg.c+1−1

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

drivers/scsi/smartpqi/smartpqi_init.c+42−58

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

drivers/scsi/smartpqi/smartpqi_sis.c+5−6

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

drivers/scsi/snic/snic_disc.c+4−3

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

drivers/scsi/snic/snic_io.c+13−12

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

drivers/scsi/snic/snic_main.c+2−22

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

drivers/scsi/snic/snic_scsi.c+7−8

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

drivers/scsi/snic/vnic_dev.c+14−15

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

drivers/scsi/sun3x_esp.c+1−29

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

drivers/scsi/sun_esp.c+11−50

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

drivers/scsi/sym53c8xx_2/sym_hipd.c+11−4

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

drivers/scsi/ufs/Kconfig+19−0

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

drivers/scsi/ufs/Makefile+2−1

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

drivers/scsi/ufs/ufs-qcom.c+28−26

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

drivers/scsi/ufs/ufs.h+3−91

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

drivers/scsi/ufs/ufs_bsg.c+210−0

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

drivers/scsi/ufs/ufs_bsg.h+23−0

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

drivers/scsi/ufs/ufshcd.c+289−142

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

drivers/scsi/ufs/ufshcd.h+12−0

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

drivers/scsi/ufs/ufshci.h+14−11

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

drivers/scsi/vmw_pvscsi.c+38−39

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

drivers/scsi/zorro_esp.c+36−254

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

drivers/target/iscsi/cxgbit/cxgbit_cm.c+20−3

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

drivers/target/iscsi/iscsi_target.c+1−1

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

drivers/target/iscsi/iscsi_target_erl0.c+1−14

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

drivers/target/iscsi/iscsi_target_erl1.c+12−5

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

drivers/target/iscsi/iscsi_target_erl2.c+1−1

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

drivers/target/iscsi/iscsi_target_erl2.h+1−1

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

drivers/target/iscsi/iscsi_target_login.c+1−1

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

drivers/target/iscsi/iscsi_target_stat.c+2−2

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

drivers/target/iscsi/iscsi_target_util.c+25−19

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

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

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

drivers/target/target_core_iblock.c+39−19

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

drivers/target/target_core_iblock.h+0−1

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

drivers/target/target_core_sbc.c+10−13

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

drivers/target/target_core_transport.c+7−12

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

drivers/target/target_core_xcopy.c+0−3

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

include/linux/wait.h+15−5

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

include/target/iscsi/iscsi_target_core.h+3−3

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

include/target/iscsi/iscsi_target_stat.h+2−2

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

include/target/target_core_base.h+0−1

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

include/uapi/scsi/scsi_bsg_ufs.h+106−0

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

Merge tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -129,7 +129,7 @@ static void mptsas_expander_delete(MPT_ADAPTER *ioc, · 128 unmodified lines
129	static void mptsas_send_expander_event(struct fw_event_work *fw_event);	129	static void mptsas_send_expander_event(struct fw_event_work *fw_event);
130	static void mptsas_not_responding_devices(MPT_ADAPTER *ioc);	130	static void mptsas_not_responding_devices(MPT_ADAPTER *ioc);
131	static void mptsas_scan_sas_topology(MPT_ADAPTER *ioc);	131	static void mptsas_scan_sas_topology(MPT_ADAPTER *ioc);
132	static void mptsas_broadcast_primative_work(struct fw_event_work *fw_event);	132	static void mptsas_broadcast_primitive_work(struct fw_event_work *fw_event);
133	static void mptsas_handle_queue_full_event(struct fw_event_work *fw_event);	133	static void mptsas_handle_queue_full_event(struct fw_event_work *fw_event);
134	static void mptsas_volume_delete(MPT_ADAPTER *ioc, u8 id);	134	static void mptsas_volume_delete(MPT_ADAPTER *ioc, u8 id);
135	void mptsas_schedule_target_reset(void *ioc);	135	void mptsas_schedule_target_reset(void *ioc);
@@ -1665,7 +1665,7 @@ mptsas_firmware_event_work(struct work_struct *work) · 1529 unmodified lines
1665	mptsas_free_fw_event(ioc, fw_event);	1665	mptsas_free_fw_event(ioc, fw_event);
1666	break;	1666	break;
1667	case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:	1667	case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
1668	mptsas_broadcast_primative_work(fw_event);	1668	mptsas_broadcast_primitive_work(fw_event);
1669	break;	1669	break;
1670	case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:	1670	case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
1671	mptsas_send_expander_event(fw_event);	1671	mptsas_send_expander_event(fw_event);
@@ -4826,13 +4826,13 @@ mptsas_issue_tm(MPT_ADAPTER *ioc, u8 type, u8 channel, u8 id, u64 lun, · 3154 unmodified lines
4826	}	4826	}
4827		4827
4828	/**	4828	/**
4829	* mptsas_broadcast_primative_work - Handle broadcast primitives	4829	* mptsas_broadcast_primitive_work - Handle broadcast primitives
4830	* @work: work queue payload containing info describing the event	4830	* @work: work queue payload containing info describing the event
4831	*	4831	*
4832	* this will be handled in workqueue context.	4832	* this will be handled in workqueue context.
4833	*/	4833	*/
4834	static void	4834	static void
4835	mptsas_broadcast_primative_work(struct fw_event_work *fw_event)	4835	mptsas_broadcast_primitive_work(struct fw_event_work *fw_event)
4836	{	4836	{
4837	MPT_ADAPTER *ioc = fw_event->ioc;	4837	MPT_ADAPTER *ioc = fw_event->ioc;
4838	MPT_FRAME_HDR *mf;	4838	MPT_FRAME_HDR *mf;