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

Pull more SCSI updates from James Bottomley: "The set of core changes here is Christoph's submission path cleanups. These introduced a couple of regressions when first proposed so they got held over from the initial merge window pull request to give more testing time, which they've now had and Syzbot has confirmed the regression it detected is fixed. The other main changes are two driver updates (arcmsr, pm80xx) and assorted minor clean ups" * tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi: (38 commits) scsi: qla2xxx: Fix return of uninitialized value in rval scsi: core: Set sc_data_direction to DMA_NONE for no-transfer commands scsi: sr: Initialize ->cmd_len scsi: arcmsr: Update driver version to v1.50.00.02-20200819 scsi: arcmsr: Add support for ARC-1886 series RAID controllers scsi: arcmsr: Fix device hot-plug monitoring timer stop scsi: arcmsr: Remove unnecessary syntax scsi: pm80xx: Driver version update scsi: pm80xx: Increase the number of outstanding I/O supported to 1024 scsi: pm80xx: Remove DMA memory allocation for ccb and device structures scsi: pm80xx: Increase number of supported queues scsi: sym53c8xx_2: Fix sizeof() mismatch scsi: isci: Fix a typo in a comment scsi: qla4xxx: Fix inconsistent format argument type scsi: myrb: Fix inconsistent format argument types scsi: myrb: Remove redundant assignment to variable timeout scsi: bfa: Fix error return in bfad_pci_init() scsi: fcoe: Simplify the return expression of fcoe_sysfs_setup() scsi: snic: Simplify the return expression of svnic_cq_alloc() scsi: fnic: Simplify the return expression of vnic_wq_copy_alloc() ...

Linus Torvalds committed 6 years ago

Commit af995382 parents bd7e8c9 1ef16a429 files · +818 −584Browse files

Unified · Split

29 files

drivers/scsi/53c700.c +0 −4
drivers/scsi/arcmsr/arcmsr.h +99 −3
drivers/scsi/arcmsr/arcmsr_hba.c +290 −87
drivers/scsi/bfa/bfad.c +1 −0
drivers/scsi/dc395x.c +1 −24
drivers/scsi/fcoe/fcoe_sysfs.c +1 −7
drivers/scsi/fnic/vnic_wq_copy.c +1 −7
drivers/scsi/gdth.c +76 −75
drivers/scsi/initio.c +1 −13
drivers/scsi/isci/remote_node_table.h +1 −1
drivers/scsi/myrb.c +2 −3
drivers/scsi/pm8001/pm8001_ctl.c +4 −2
drivers/scsi/pm8001/pm8001_defs.h +13 −14
drivers/scsi/pm8001/pm8001_hwi.c +20 −18
drivers/scsi/pm8001/pm8001_init.c +150 −71
drivers/scsi/pm8001/pm8001_sas.h +11 −4
drivers/scsi/pm8001/pm80xx_hwi.c +56 −53
drivers/scsi/qla2xxx/qla_dfs.c +8 −60
drivers/scsi/qla2xxx/qla_isr.c +15 −27
drivers/scsi/qla2xxx/qla_nvme.c +4 −4
drivers/scsi/qla2xxx/qla_nx2.c +1 −1
drivers/scsi/qla4xxx/ql4_nx.c +1 −1
drivers/scsi/scsi_lib.c +35 −73
drivers/scsi/sd.c +15 −12
drivers/scsi/snic/vnic_cq.c +1 −7
drivers/scsi/sr.c +7 −10
drivers/scsi/sym53c8xx_2/sym_hipd.c +1 −1
drivers/target/target_core_rd.c +1 −1
include/scsi/scsi_cmnd.h +2 −1

drivers/scsi/53c700.c+0−4

@@ -1506,10 +1506,8 @@ NCR_700_intr(int irq, void *dev_id) · 1505 unmodified lines
1506	1506	__u8 sstat0 = 0, dstat = 0;
1507	1507	__u32 dsp;
1508	1508	struct scsi_cmnd *SCp = hostdata->cmd;
1509		− enum NCR_700_Host_State state;
1510	1509
1511	1510	handled = 1;
1512		− state = hostdata->state;
1513	1511	SCp = hostdata->cmd;
1514	1512
1515	1513	if(istat & SCSI_INT_PENDING) {
@@ -1760,7 +1758,6 @@ NCR_700_queuecommand_lck(struct scsi_cmnd SCp, void (done)(struct scsi_cmnd *) · 244 unmodified lines
1760	1758	struct NCR_700_Host_Parameters *hostdata =
1761	1759	(struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0];
1762	1760	__u32 move_ins;
1763		− enum dma_data_direction direction;
1764	1761	struct NCR_700_command_slot *slot;
1765	1762
1766	1763	if(hostdata->command_slot_count >= NCR_700_COMMAND_SLOTS_PER_HOST) {
@@ -1877,7 +1874,6 @@ NCR_700_queuecommand_lck(struct scsi_cmnd SCp, void (done)(struct scsi_cmnd *) · 110 unmodified lines
1877	1874	}
1878	1875
1879	1876	/* now build the scatter gather list */
1880		− direction = SCp->sc_data_direction;
1881	1877	if(move_ins != 0) {
1882	1878	int i;
1883	1879	int sg_count;

drivers/scsi/arcmsr/arcmsr.h+99−3

@@ -49,7 +49,7 @@ struct device_attribute; · 48 unmodified lines
49	49	#define ARCMSR_MAX_OUTSTANDING_CMD 1024
50	50	#define ARCMSR_DEFAULT_OUTSTANDING_CMD 128
51	51	#define ARCMSR_MIN_OUTSTANDING_CMD 32
52		−#define ARCMSR_DRIVER_VERSION "v1.40.00.10-20190116"
	52	+#define ARCMSR_DRIVER_VERSION "v1.50.00.02-20200819"
53	53	#define ARCMSR_SCSI_INITIATOR_ID 255
54	54	#define ARCMSR_MAX_XFER_SECTORS 512
55	55	#define ARCMSR_MAX_XFER_SECTORS_B 4096
@@ -80,6 +80,7 @@ struct device_attribute; · 24 unmodified lines
80	80	#ifndef PCI_DEVICE_ID_ARECA_1884
81	81	#define PCI_DEVICE_ID_ARECA_1884 0x1884
82	82	#endif
	83	+#define PCI_DEVICE_ID_ARECA_1886 0x188A
83	84	#define ARCMSR_HOURS (1000 * 60 * 60 * 4)
84	85	#define ARCMSR_MINUTES (1000 * 60 * 60)
85	86	/*
@@ -436,6 +437,21 @@ struct FIRMWARE_INFO · 350 unmodified lines
436	437	#define ARCMSR_HBEMU_DOORBELL_SYNC 0x100
437	438	#define ARCMSR_ARC188X_RESET_ADAPTER 0x00000004
438	439	#define ARCMSR_ARC1884_DiagWrite_ENABLE 0x00000080
	440	+
	441	+/*
	442	+*******************************************************************************
	443	+** SPEC. for Areca Type F adapter
	444	+*******************************************************************************
	445	+*/
	446	+#define ARCMSR_SIGNATURE_1886 0x188617D3
	447	+// Doorbell and interrupt definition are same as Type E adapter
	448	+/* ARC-1886 doorbell sync */
	449	+#define ARCMSR_HBFMU_DOORBELL_SYNC 0x100
	450	+//set host rw buffer physical address at inbound message 0, 1 (low,high)
	451	+#define ARCMSR_HBFMU_DOORBELL_SYNC1 0x300
	452	+#define ARCMSR_HBFMU_MESSAGE_FIRMWARE_OK 0x80000000
	453	+#define ARCMSR_HBFMU_MESSAGE_NO_VOLUME_CHANGE 0x20000000
	454	+
439	455	/*
440	456	*******************************************************************************
441	457	** ARECA SCSI COMMAND DESCRIPTOR BLOCK size 0x1F8 (504)
@@ -720,6 +736,80 @@ struct MessageUnit_E{ · 278 unmodified lines
720	736	uint32_t msgcode_rwbuffer[256]; /2200 23FF/
721	737	};
722	738
	739	+/*
	740	+*********************************************************************
	741	+** Messaging Unit (MU) of Type F processor(LSI)
	742	+*********************************************************************
	743	+*/
	744	+struct MessageUnit_F {
	745	+ uint32_t iobound_doorbell; /0000 0003/
	746	+ uint32_t write_sequence_3xxx; /0004 0007/
	747	+ uint32_t host_diagnostic_3xxx; /0008 000B/
	748	+ uint32_t posted_outbound_doorbell; /000C 000F/
	749	+ uint32_t master_error_attribute; /0010 0013/
	750	+ uint32_t master_error_address_low; /0014 0017/
	751	+ uint32_t master_error_address_high; /0018 001B/
	752	+ uint32_t hcb_size; /001C 001F/
	753	+ uint32_t inbound_doorbell; /0020 0023/
	754	+ uint32_t diagnostic_rw_data; /0024 0027/
	755	+ uint32_t diagnostic_rw_address_low; /0028 002B/
	756	+ uint32_t diagnostic_rw_address_high; /002C 002F/
	757	+ uint32_t host_int_status; /0030 0033/
	758	+ uint32_t host_int_mask; /0034 0037/
	759	+ uint32_t dcr_data; /0038 003B/
	760	+ uint32_t dcr_address; /003C 003F/
	761	+ uint32_t inbound_queueport; /0040 0043/
	762	+ uint32_t outbound_queueport; /0044 0047/
	763	+ uint32_t hcb_pci_address_low; /0048 004B/
	764	+ uint32_t hcb_pci_address_high; /004C 004F/
	765	+ uint32_t iop_int_status; /0050 0053/
	766	+ uint32_t iop_int_mask; /0054 0057/
	767	+ uint32_t iop_inbound_queue_port; /0058 005B/
	768	+ uint32_t iop_outbound_queue_port; /005C 005F/
	769	+ uint32_t inbound_free_list_index; /0060 0063/
	770	+ uint32_t inbound_post_list_index; /0064 0067/
	771	+ uint32_t reply_post_producer_index; /0068 006B/
	772	+ uint32_t reply_post_consumer_index; /006C 006F/
	773	+ uint32_t inbound_doorbell_clear; /0070 0073/
	774	+ uint32_t i2o_message_unit_control; /0074 0077/
	775	+ uint32_t last_used_message_source_address_low; /0078 007B/
	776	+ uint32_t last_used_message_source_address_high; /007C 007F/
	777	+ uint32_t pull_mode_data_byte_count[4]; /0080 008F/
	778	+ uint32_t message_dest_address_index; /0090 0093/
	779	+ uint32_t done_queue_not_empty_int_counter_timer; /0094 0097/
	780	+ uint32_t utility_A_int_counter_timer; /0098 009B/
	781	+ uint32_t outbound_doorbell; /009C 009F/
	782	+ uint32_t outbound_doorbell_clear; /00A0 00A3/
	783	+ uint32_t message_source_address_index; /00A4 00A7/
	784	+ uint32_t message_done_queue_index; /00A8 00AB/
	785	+ uint32_t reserved0; /00AC 00AF/
	786	+ uint32_t inbound_msgaddr0; /00B0 00B3/
	787	+ uint32_t inbound_msgaddr1; /00B4 00B7/
	788	+ uint32_t outbound_msgaddr0; /00B8 00BB/
	789	+ uint32_t outbound_msgaddr1; /00BC 00BF/
	790	+ uint32_t inbound_queueport_low; /00C0 00C3/
	791	+ uint32_t inbound_queueport_high; /00C4 00C7/
	792	+ uint32_t outbound_queueport_low; /00C8 00CB/
	793	+ uint32_t outbound_queueport_high; /00CC 00CF/
	794	+ uint32_t iop_inbound_queue_port_low; /00D0 00D3/
	795	+ uint32_t iop_inbound_queue_port_high; /00D4 00D7/
	796	+ uint32_t iop_outbound_queue_port_low; /00D8 00DB/
	797	+ uint32_t iop_outbound_queue_port_high; /00DC 00DF/
	798	+ uint32_t message_dest_queue_port_low; /00E0 00E3/
	799	+ uint32_t message_dest_queue_port_high; /00E4 00E7/
	800	+ uint32_t last_used_message_dest_address_low; /00E8 00EB/
	801	+ uint32_t last_used_message_dest_address_high; /00EC 00EF/
	802	+ uint32_t message_done_queue_base_address_low; /00F0 00F3/
	803	+ uint32_t message_done_queue_base_address_high; /00F4 00F7/
	804	+ uint32_t host_diagnostic; /00F8 00FB/
	805	+ uint32_t write_sequence; /00FC 00FF/
	806	+ uint32_t reserved1[46]; /0100 01B7/
	807	+ uint32_t reply_post_producer_index1; /01B8 01BB/
	808	+ uint32_t reply_post_consumer_index1; /01BC 01BF/
	809	+};
	810	+
	811	+#define MESG_RW_BUFFER_SIZE (256 * 3)
	812	+
723	813	typedef struct deliver_completeQ {
724	814	uint16_t cmdFlag;
725	815	uint16_t cmdSMID;
@@ -739,6 +829,7 @@ struct AdapterControlBlock · 13 unmodified lines
739	829	#define ACB_ADAPTER_TYPE_C 0x00000002 /* hbc L IOP */
740	830	#define ACB_ADAPTER_TYPE_D 0x00000003 /* hbd M IOP */
741	831	#define ACB_ADAPTER_TYPE_E 0x00000004 /* hba L IOP */
	832	+#define ACB_ADAPTER_TYPE_F 0x00000005 /* hba L IOP */
742	833	u32 ioqueue_size;
743	834	struct pci_dev * pdev;
744	835	struct Scsi_Host * host;
@@ -760,10 +851,16 @@ struct AdapterControlBlock · 15 unmodified lines
760	851	struct MessageUnit_C __iomem *pmuC;
761	852	struct MessageUnit_D *pmuD;
762	853	struct MessageUnit_E __iomem *pmuE;
	854	+ struct MessageUnit_F __iomem *pmuF;
763	855	};
764	856	/* message unit ATU inbound base address0 */
765	857	void __iomem *mem_base0;
766	858	void __iomem *mem_base1;
	859	+ //0x000 - COMPORT_IN (Host sent to ROC)
	860	+ uint32_t *message_wbuffer;
	861	+ //0x100 - COMPORT_OUT (ROC sent to Host)
	862	+ uint32_t *message_rbuffer;
	863	+ uint32_t *msgcode_rwbuffer; //0x200 - BIOS_AREA
767	864	uint32_t acb_flags;
768	865	u16 dev_id;
769	866	uint8_t adapter_index;
@@ -836,8 +933,6 @@ struct AdapterControlBlock · 66 unmodified lines
836	933	#define FW_NORMAL 0x0000
837	934	#define FW_BOG 0x0001
838	935	#define FW_DEADLOCK 0x0010
839		− atomic_t rq_map_token;
840		− atomic_t ante_token_value;
841	936	uint32_t maxOutstanding;
842	937	int vector_count;
843	938	uint32_t maxFreeCCB;
@@ -848,6 +943,7 @@ struct AdapterControlBlock · 4 unmodified lines
848	943	uint32_t out_doorbell;
849	944	uint32_t completionQ_entry;
850	945	pCompletion_Q pCompletionQ;
	946	+ uint32_t completeQ_size;
851	947	};/* HW_DEVICE_EXTENSION */
852	948	/*
853	949	*******************************************************************************

drivers/scsi/arcmsr/arcmsr_hba.c+290−87

@@ -133,6 +133,7 @@ static void arcmsr_hbaC_message_isr(struct AdapterControlBlock *pACB); · 132 unmodified lines
133	133	static void arcmsr_hbaD_message_isr(struct AdapterControlBlock *acb);
134	134	static void arcmsr_hbaE_message_isr(struct AdapterControlBlock *acb);
135	135	static void arcmsr_hbaE_postqueue_isr(struct AdapterControlBlock *acb);
	136	+static void arcmsr_hbaF_postqueue_isr(struct AdapterControlBlock *acb);
136	137	static void arcmsr_hardware_reset(struct AdapterControlBlock *acb);
137	138	static const char arcmsr_info(struct Scsi_Host );
138	139	static irqreturn_t arcmsr_interrupt(struct AdapterControlBlock *acb);
@@ -209,6 +210,8 @@ static struct pci_device_id arcmsr_device_id_table[] = { · 70 unmodified lines
209	210	.driver_data = ACB_ADAPTER_TYPE_C},
210	211	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1884),
211	212	.driver_data = ACB_ADAPTER_TYPE_E},
	213	+ {PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1886),
	214	+ .driver_data = ACB_ADAPTER_TYPE_F},
212	215	{0, 0}, /* Terminating entry */
213	216	};
214	217	MODULE_DEVICE_TABLE(pci, arcmsr_device_id_table);
@@ -232,12 +235,12 @@ static void arcmsr_free_io_queue(struct AdapterControlBlock *acb) · 17 unmodified lines
232	235	switch (acb->adapter_type) {
233	236	case ACB_ADAPTER_TYPE_B:
234	237	case ACB_ADAPTER_TYPE_D:
235		− case ACB_ADAPTER_TYPE_E: {
	238	+ case ACB_ADAPTER_TYPE_E:
	239	+ case ACB_ADAPTER_TYPE_F:
236	240	dma_free_coherent(&acb->pdev->dev, acb->ioqueue_size,
237	241	acb->dma_coherent2, acb->dma_coherent_handle2);
238	242	break;
239	243	}
240		− }
241	244	}
242	245
243	246	static bool arcmsr_remap_pciregion(struct AdapterControlBlock *acb)
@@ -310,6 +313,19 @@ static bool arcmsr_remap_pciregion(struct AdapterControlBlock *acb) · 66 unmodified lines
310	313	acb->out_doorbell = 0;
311	314	break;
312	315	}
	316	+ case ACB_ADAPTER_TYPE_F: {
	317	+ acb->pmuF = ioremap(pci_resource_start(pdev, 0), pci_resource_len(pdev, 0));
	318	+ if (!acb->pmuF) {
	319	+ pr_notice("arcmsr%d: memory mapping region fail\n",
	320	+ acb->host->host_no);
	321	+ return false;
	322	+ }
	323	+ writel(0, &acb->pmuF->host_int_status); /* clear interrupt */
	324	+ writel(ARCMSR_HBFMU_DOORBELL_SYNC, &acb->pmuF->iobound_doorbell);
	325	+ acb->in_doorbell = 0;
	326	+ acb->out_doorbell = 0;
	327	+ break;
	328	+ }
313	329	}
314	330	return true;
315	331	}
@@ -317,26 +333,25 @@ static bool arcmsr_remap_pciregion(struct AdapterControlBlock *acb) · 1 unmodified line
317	333	static void arcmsr_unmap_pciregion(struct AdapterControlBlock *acb)
318	334	{
319	335	switch (acb->adapter_type) {
320		− case ACB_ADAPTER_TYPE_A:{
	336	+ case ACB_ADAPTER_TYPE_A:
321	337	iounmap(acb->pmuA);
322		− }
323		− break;
324		− case ACB_ADAPTER_TYPE_B:{
	338	+ break;
	339	+ case ACB_ADAPTER_TYPE_B:
325	340	iounmap(acb->mem_base0);
326	341	iounmap(acb->mem_base1);
327		− }
328		−
329		− break;
330		− case ACB_ADAPTER_TYPE_C:{
	342	+ break;
	343	+ case ACB_ADAPTER_TYPE_C:
331	344	iounmap(acb->pmuC);
332		− }
333		− break;
	345	+ break;
334	346	case ACB_ADAPTER_TYPE_D:
335	347	iounmap(acb->mem_base0);
336	348	break;
337	349	case ACB_ADAPTER_TYPE_E:
338	350	iounmap(acb->pmuE);
339	351	break;
	352	+ case ACB_ADAPTER_TYPE_F:
	353	+ iounmap(acb->pmuF);
	354	+ break;
340	355	}
341	356	}
342	357
@@ -552,23 +567,20 @@ static void arcmsr_flush_adapter_cache(struct AdapterControlBlock *acb) · 209 unmodified lines
552	567	{
553	568	switch (acb->adapter_type) {
554	569
555		− case ACB_ADAPTER_TYPE_A: {
	570	+ case ACB_ADAPTER_TYPE_A:
556	571	arcmsr_hbaA_flush_cache(acb);
557		− }
558	572	break;
559		−
560		− case ACB_ADAPTER_TYPE_B: {
	573	+ case ACB_ADAPTER_TYPE_B:
561	574	arcmsr_hbaB_flush_cache(acb);
562		− }
563	575	break;
564		− case ACB_ADAPTER_TYPE_C: {
	576	+ case ACB_ADAPTER_TYPE_C:
565	577	arcmsr_hbaC_flush_cache(acb);
566		− }
567	578	break;
568	579	case ACB_ADAPTER_TYPE_D:
569	580	arcmsr_hbaD_flush_cache(acb);
570	581	break;
571	582	case ACB_ADAPTER_TYPE_E:
	583	+ case ACB_ADAPTER_TYPE_F:
572	584	arcmsr_hbaE_flush_cache(acb);
573	585	break;
574	586	}
@@ -626,6 +638,27 @@ static void arcmsr_hbaD_assign_regAddr(struct AdapterControlBlock *acb) · 51 unmodified lines
626	638	reg->msgcode_rwbuffer = MEM_BASE0(ARCMSR_ARC1214_MESSAGE_RWBUFFER);
627	639	}
628	640
	641	+static void arcmsr_hbaF_assign_regAddr(struct AdapterControlBlock *acb)
	642	+{
	643	+ dma_addr_t host_buffer_dma;
	644	+ struct MessageUnit_F __iomem *pmuF;
	645	+
	646	+ memset(acb->dma_coherent2, 0xff, acb->completeQ_size);
	647	+ acb->message_wbuffer = (uint32_t *)round_up((unsigned long)acb->dma_coherent2 +
	648	+ acb->completeQ_size, 4);
	649	+ acb->message_rbuffer = ((void *)acb->message_wbuffer) + 0x100;
	650	+ acb->msgcode_rwbuffer = ((void *)acb->message_wbuffer) + 0x200;
	651	+ memset((void *)acb->message_wbuffer, 0, MESG_RW_BUFFER_SIZE);
	652	+ host_buffer_dma = round_up(acb->dma_coherent_handle2 + acb->completeQ_size, 4);
	653	+ pmuF = acb->pmuF;
	654	+ /* host buffer low address, bit0:1 all buffer active */
	655	+ writel(lower_32_bits(host_buffer_dma \| 1), &pmuF->inbound_msgaddr0);
	656	+ /* host buffer high address */
	657	+ writel(upper_32_bits(host_buffer_dma), &pmuF->inbound_msgaddr1);
	658	+ /* set host buffer physical address */
	659	+ writel(ARCMSR_HBFMU_DOORBELL_SYNC1, &pmuF->iobound_doorbell);
	660	+}
	661	+
629	662	static bool arcmsr_alloc_io_queue(struct AdapterControlBlock *acb)
630	663	{
631	664	bool rtn = true;
@@ -679,6 +712,28 @@ static bool arcmsr_alloc_io_queue(struct AdapterControlBlock *acb) · 47 unmodified lines
679	712	acb->doneq_index = 0;
680	713	}
681	714	break;
	715	+ case ACB_ADAPTER_TYPE_F: {
	716	+ uint32_t QueueDepth;
	717	+ uint32_t depthTbl[] = {256, 512, 1024, 128, 64, 32};
	718	+
	719	+ arcmsr_wait_firmware_ready(acb);
	720	+ QueueDepth = depthTbl[readl(&acb->pmuF->outbound_msgaddr1) & 7];
	721	+ acb->completeQ_size = sizeof(struct deliver_completeQ) * QueueDepth + 128;
	722	+ acb->ioqueue_size = roundup(acb->completeQ_size + MESG_RW_BUFFER_SIZE, 32);
	723	+ dma_coherent = dma_alloc_coherent(&pdev->dev, acb->ioqueue_size,
	724	+ &dma_coherent_handle, GFP_KERNEL);
	725	+ if (!dma_coherent) {
	726	+ pr_notice("arcmsr%d: DMA allocation failed\n", acb->host->host_no);
	727	+ return false;
	728	+ }
	729	+ acb->dma_coherent_handle2 = dma_coherent_handle;
	730	+ acb->dma_coherent2 = dma_coherent;
	731	+ acb->pCompletionQ = dma_coherent;
	732	+ acb->completionQ_entry = acb->completeQ_size / sizeof(struct deliver_completeQ);
	733	+ acb->doneq_index = 0;
	734	+ arcmsr_hbaF_assign_regAddr(acb);
	735	+ }
	736	+ break;
682	737	default:
683	738	break;
684	739	}
@@ -713,7 +768,8 @@ static int arcmsr_alloc_ccb_pool(struct AdapterControlBlock *acb) · 28 unmodified lines
713	768	acb->host->sg_tablesize = max_sg_entrys;
714	769	roundup_ccbsize = roundup(sizeof(struct CommandControlBlock) + (max_sg_entrys - 1) * sizeof(struct SG64ENTRY), 32);
715	770	acb->uncache_size = roundup_ccbsize * acb->maxFreeCCB;
716		− acb->uncache_size += acb->ioqueue_size;
	771	+ if (acb->adapter_type != ACB_ADAPTER_TYPE_F)
	772	+ acb->uncache_size += acb->ioqueue_size;
717	773	dma_coherent = dma_alloc_coherent(&pdev->dev, acb->uncache_size, &dma_coherent_handle, GFP_KERNEL);
718	774	if(!dma_coherent){
719	775	printk(KERN_NOTICE "arcmsr%d: dma_alloc_coherent got error\n", acb->host->host_no);
@@ -736,6 +792,7 @@ static int arcmsr_alloc_ccb_pool(struct AdapterControlBlock *acb) · 16 unmodified lines
736	792	case ACB_ADAPTER_TYPE_C:
737	793	case ACB_ADAPTER_TYPE_D:
738	794	case ACB_ADAPTER_TYPE_E:
	795	+ case ACB_ADAPTER_TYPE_F:
739	796	ccb_tmp->cdb_phyaddr = cdb_phyaddr;
740	797	break;
741	798	}
@@ -754,8 +811,10 @@ static int arcmsr_alloc_ccb_pool(struct AdapterControlBlock *acb) · 12 unmodified lines
754	811	ccb_tmp = (struct CommandControlBlock *)((unsigned long)ccb_tmp + roundup_ccbsize);
755	812	dma_coherent_handle = next_ccb_phy;
756	813	}
757		− acb->dma_coherent_handle2 = dma_coherent_handle;
758		− acb->dma_coherent2 = ccb_tmp;
	814	+ if (acb->adapter_type != ACB_ADAPTER_TYPE_F) {
	815	+ acb->dma_coherent_handle2 = dma_coherent_handle;
	816	+ acb->dma_coherent2 = ccb_tmp;
	817	+ }
759	818	switch (acb->adapter_type) {
760	819	case ACB_ADAPTER_TYPE_B:
761	820	acb->pmuB = (struct MessageUnit_B *)acb->dma_coherent2;
@@ -785,7 +844,6 @@ static void arcmsr_message_isr_bh_fn(struct work_struct *work) · 23 unmodified lines
785	844	struct scsi_device *psdev;
786	845	char diff, temp;
787	846
788		− acb->acb_flags &= ~ACB_F_MSG_GET_CONFIG;
789	847	switch (acb->adapter_type) {
790	848	case ACB_ADAPTER_TYPE_A: {
791	849	struct MessageUnit_A __iomem *reg = acb->pmuA;
@@ -822,8 +880,12 @@ static void arcmsr_message_isr_bh_fn(struct work_struct *work) · 30 unmodified lines
822	880	devicemap = (char __iomem *)(&reg->msgcode_rwbuffer[21]);
823	881	break;
824	882	}
	883	+ case ACB_ADAPTER_TYPE_F: {
	884	+ signature = (uint32_t __iomem *)(&acb->msgcode_rwbuffer[0]);
	885	+ devicemap = (char __iomem *)(&acb->msgcode_rwbuffer[21]);
	886	+ break;
	887	+ }
825	888	}
826		− atomic_inc(&acb->rq_map_token);
827	889	if (readl(signature) != ARCMSR_SIGNATURE_GET_CONFIG)
828	890	return;
829	891	for (target = 0; target < ARCMSR_MAX_TARGETID - 1;
@@ -854,6 +916,7 @@ static void arcmsr_message_isr_bh_fn(struct work_struct *work) · 24 unmodified lines
854	916	devicemap++;
855	917	acb_dev_map++;
856	918	}
	919	+ acb->acb_flags &= ~ACB_F_MSG_GET_CONFIG;
857	920	}
858	921
859	922	static int
@@ -906,8 +969,6 @@ out_free_irq: · 46 unmodified lines
906	969	static void arcmsr_init_get_devmap_timer(struct AdapterControlBlock *pacb)
907	970	{
908	971	INIT_WORK(&pacb->arcmsr_do_message_isr_bh, arcmsr_message_isr_bh_fn);
909		− atomic_set(&pacb->rq_map_token, 16);
910		− atomic_set(&pacb->ante_token_value, 16);
911	972	pacb->fw_flag = FW_NORMAL;
912	973	timer_setup(&pacb->eternal_timer, arcmsr_request_device_map, 0);
913	974	pacb->eternal_timer.expires = jiffies + msecs_to_jiffies(6 * HZ);
@@ -1009,7 +1070,8 @@ static int arcmsr_probe(struct pci_dev pdev, const struct pci_device_id id) · 95 unmodified lines
1009	1070	if(!error){
1010	1071	goto free_hbb_mu;
1011	1072	}
1012		− arcmsr_free_io_queue(acb);
	1073	+ if (acb->adapter_type != ACB_ADAPTER_TYPE_F)
	1074	+ arcmsr_free_io_queue(acb);
1013	1075	error = arcmsr_alloc_ccb_pool(acb);
1014	1076	if(error){
1015	1077	goto unmap_pci_region;
@@ -1122,6 +1184,14 @@ static int arcmsr_resume(struct pci_dev *pdev) · 106 unmodified lines
1122	1184	acb->out_doorbell = 0;
1123	1185	acb->doneq_index = 0;
1124	1186	break;
	1187	+ case ACB_ADAPTER_TYPE_F:
	1188	+ writel(0, &acb->pmuF->host_int_status);
	1189	+ writel(ARCMSR_HBFMU_DOORBELL_SYNC, &acb->pmuF->iobound_doorbell);
	1190	+ acb->in_doorbell = 0;
	1191	+ acb->out_doorbell = 0;
	1192	+ acb->doneq_index = 0;
	1193	+ arcmsr_hbaF_assign_regAddr(acb);
	1194	+ break;
1125	1195	}
1126	1196	arcmsr_iop_init(acb);
1127	1197	arcmsr_init_get_devmap_timer(acb);
@@ -1134,6 +1204,8 @@ controller_stop: · 6 unmodified lines
1134	1204	controller_unregister:
1135	1205	scsi_remove_host(host);
1136	1206	arcmsr_free_ccb_pool(acb);
	1207	+ if (acb->adapter_type == ACB_ADAPTER_TYPE_F)
	1208	+ arcmsr_free_io_queue(acb);
1137	1209	arcmsr_unmap_pciregion(acb);
1138	1210	pci_release_regions(pdev);
1139	1211	scsi_host_put(host);
@@ -1213,25 +1285,20 @@ static uint8_t arcmsr_abort_allcmd(struct AdapterControlBlock *acb) · 73 unmodified lines
1213	1285	{
1214	1286	uint8_t rtnval = 0;
1215	1287	switch (acb->adapter_type) {
1216		− case ACB_ADAPTER_TYPE_A: {
	1288	+ case ACB_ADAPTER_TYPE_A:
1217	1289	rtnval = arcmsr_hbaA_abort_allcmd(acb);
1218		− }
1219	1290	break;
1220		−
1221		− case ACB_ADAPTER_TYPE_B: {
	1291	+ case ACB_ADAPTER_TYPE_B:
1222	1292	rtnval = arcmsr_hbaB_abort_allcmd(acb);
1223		− }
1224	1293	break;
1225		−
1226		− case ACB_ADAPTER_TYPE_C: {
	1294	+ case ACB_ADAPTER_TYPE_C:
1227	1295	rtnval = arcmsr_hbaC_abort_allcmd(acb);
1228		− }
1229	1296	break;
1230		−
1231	1297	case ACB_ADAPTER_TYPE_D:
1232	1298	rtnval = arcmsr_hbaD_abort_allcmd(acb);
1233	1299	break;
1234	1300	case ACB_ADAPTER_TYPE_E:
	1301	+ case ACB_ADAPTER_TYPE_F:
1235	1302	rtnval = arcmsr_hbaE_abort_allcmd(acb);
1236	1303	break;
1237	1304	}
@@ -1307,7 +1374,8 @@ static u32 arcmsr_disable_outbound_ints(struct AdapterControlBlock *acb) · 69 unmodified lines
1307	1374	writel(ARCMSR_ARC1214_ALL_INT_DISABLE, reg->pcief0_int_enable);
1308	1375	}
1309	1376	break;
1310		− case ACB_ADAPTER_TYPE_E: {
	1377	+ case ACB_ADAPTER_TYPE_E:
	1378	+ case ACB_ADAPTER_TYPE_F: {
1311	1379	struct MessageUnit_E __iomem *reg = acb->pmuE;
1312	1380	orig_mask = readl(&reg->host_int_mask);
1313	1381	writel(orig_mask \| ARCMSR_HBEMU_OUTBOUND_DOORBELL_ISR \| ARCMSR_HBEMU_OUTBOUND_POSTQUEUE_ISR, &reg->host_int_mask);
@@ -1514,6 +1582,9 @@ static void arcmsr_done4abort_postqueue(struct AdapterControlBlock *acb) · 200 unmodified lines
1514	1582	case ACB_ADAPTER_TYPE_E:
1515	1583	arcmsr_hbaE_postqueue_isr(acb);
1516	1584	break;
	1585	+ case ACB_ADAPTER_TYPE_F:
	1586	+ arcmsr_hbaF_postqueue_isr(acb);
	1587	+ break;
1517	1588	}
1518	1589	}
1519	1590
@@ -1568,6 +1639,8 @@ static void arcmsr_free_pcidev(struct AdapterControlBlock *acb) · 48 unmodified lines
1568	1639	pdev = acb->pdev;
1569	1640	arcmsr_free_irq(pdev, acb);
1570	1641	arcmsr_free_ccb_pool(acb);
	1642	+ if (acb->adapter_type == ACB_ADAPTER_TYPE_F)
	1643	+ arcmsr_free_io_queue(acb);
1571	1644	arcmsr_unmap_pciregion(acb);
1572	1645	pci_release_regions(pdev);
1573	1646	scsi_host_put(host);
@@ -1625,6 +1698,8 @@ static void arcmsr_remove(struct pci_dev *pdev) · 51 unmodified lines
1625	1698	}
1626	1699	arcmsr_free_irq(pdev, acb);
1627	1700	arcmsr_free_ccb_pool(acb);
	1701	+ if (acb->adapter_type == ACB_ADAPTER_TYPE_F)
	1702	+ arcmsr_free_io_queue(acb);
1628	1703	arcmsr_unmap_pciregion(acb);
1629	1704	pci_release_regions(pdev);
1630	1705	scsi_host_put(host);
@@ -1702,7 +1777,8 @@ static void arcmsr_enable_outbound_ints(struct AdapterControlBlock *acb, · 71 unmodified lines
1702	1777	writel(intmask_org \| mask, reg->pcief0_int_enable);
1703	1778	break;
1704	1779	}
1705		− case ACB_ADAPTER_TYPE_E: {
	1780	+ case ACB_ADAPTER_TYPE_E:
	1781	+ case ACB_ADAPTER_TYPE_F: {
1706	1782	struct MessageUnit_E __iomem *reg = acb->pmuE;
1707	1783
1708	1784	mask = ~(ARCMSR_HBEMU_OUTBOUND_DOORBELL_ISR \| ARCMSR_HBEMU_OUTBOUND_POSTQUEUE_ISR);
@@ -1846,6 +1922,19 @@ static void arcmsr_post_ccb(struct AdapterControlBlock *acb, struct CommandContr · 137 unmodified lines
1846	1922	writel(ccb_post_stamp, &pmu->inbound_queueport_low);
1847	1923	break;
1848	1924	}
	1925	+ case ACB_ADAPTER_TYPE_F: {
	1926	+ struct MessageUnit_F __iomem *pmu = acb->pmuF;
	1927	+ u32 ccb_post_stamp, arc_cdb_size;
	1928	+
	1929	+ if (ccb->arc_cdb_size <= 0x300)
	1930	+ arc_cdb_size = (ccb->arc_cdb_size - 1) >> 6 \| 1;
	1931	+ else
	1932	+ arc_cdb_size = (((ccb->arc_cdb_size + 0xff) >> 8) + 2) << 1 \| 1;
	1933	+ ccb_post_stamp = (ccb->smid \| arc_cdb_size);
	1934	+ writel(0, &pmu->inbound_queueport_high);
	1935	+ writel(ccb_post_stamp, &pmu->inbound_queueport_low);
	1936	+ break;
	1937	+ }
1849	1938	}
1850	1939	}
1851	1940
@@ -1916,23 +2005,20 @@ static void arcmsr_hbaE_stop_bgrb(struct AdapterControlBlock *pACB) · 64 unmodified lines
1916	2005	static void arcmsr_stop_adapter_bgrb(struct AdapterControlBlock *acb)
1917	2006	{
1918	2007	switch (acb->adapter_type) {
1919		− case ACB_ADAPTER_TYPE_A: {
	2008	+ case ACB_ADAPTER_TYPE_A:
1920	2009	arcmsr_hbaA_stop_bgrb(acb);
1921		− }
1922	2010	break;
1923		−
1924		− case ACB_ADAPTER_TYPE_B: {
	2011	+ case ACB_ADAPTER_TYPE_B:
1925	2012	arcmsr_hbaB_stop_bgrb(acb);
1926		− }
1927	2013	break;
1928		− case ACB_ADAPTER_TYPE_C: {
	2014	+ case ACB_ADAPTER_TYPE_C:
1929	2015	arcmsr_hbaC_stop_bgrb(acb);
1930		− }
1931	2016	break;
1932	2017	case ACB_ADAPTER_TYPE_D:
1933	2018	arcmsr_hbaD_stop_bgrb(acb);
1934	2019	break;
1935	2020	case ACB_ADAPTER_TYPE_E:
	2021	+ case ACB_ADAPTER_TYPE_F:
1936	2022	arcmsr_hbaE_stop_bgrb(acb);
1937	2023	break;
1938	2024	}
@@ -1951,7 +2037,6 @@ static void arcmsr_iop_message_read(struct AdapterControlBlock *acb) · 12 unmodified lines
1951	2037	writel(ARCMSR_INBOUND_DRIVER_DATA_READ_OK, &reg->inbound_doorbell);
1952	2038	}
1953	2039	break;
1954		−
1955	2040	case ACB_ADAPTER_TYPE_B: {
1956	2041	struct MessageUnit_B *reg = acb->pmuB;
1957	2042	writel(ARCMSR_DRV2IOP_DATA_READ_OK, reg->drv2iop_doorbell);
@@ -1969,7 +2054,8 @@ static void arcmsr_iop_message_read(struct AdapterControlBlock *acb) · 11 unmodified lines
1969	2054	reg->inbound_doorbell);
1970	2055	}
1971	2056	break;
1972		− case ACB_ADAPTER_TYPE_E: {
	2057	+ case ACB_ADAPTER_TYPE_E:
	2058	+ case ACB_ADAPTER_TYPE_F: {
1973	2059	struct MessageUnit_E __iomem *reg = acb->pmuE;
1974	2060	acb->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_DATA_READ_OK;
1975	2061	writel(acb->out_doorbell, &reg->iobound_doorbell);
@@ -2015,7 +2101,8 @@ static void arcmsr_iop_message_wrote(struct AdapterControlBlock *acb) · 39 unmodified lines
2015	2101	reg->inbound_doorbell);
2016	2102	}
2017	2103	break;
2018		− case ACB_ADAPTER_TYPE_E: {
	2104	+ case ACB_ADAPTER_TYPE_E:
	2105	+ case ACB_ADAPTER_TYPE_F: {
2019	2106	struct MessageUnit_E __iomem *reg = acb->pmuE;
2020	2107	acb->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_DATA_WRITE_OK;
2021	2108	writel(acb->out_doorbell, &reg->iobound_doorbell);
@@ -2034,7 +2121,6 @@ struct QBUFFER __iomem arcmsr_get_iop_rqbuffer(struct AdapterControlBlock acb) · 12 unmodified lines
2034	2121	qbuffer = (struct QBUFFER __iomem *)&reg->message_rbuffer;
2035	2122	}
2036	2123	break;
2037		−
2038	2124	case ACB_ADAPTER_TYPE_B: {
2039	2125	struct MessageUnit_B *reg = acb->pmuB;
2040	2126	qbuffer = (struct QBUFFER __iomem *)reg->message_rbuffer;
@@ -2055,6 +2141,10 @@ struct QBUFFER __iomem arcmsr_get_iop_rqbuffer(struct AdapterControlBlock acb) · 14 unmodified lines
2055	2141	qbuffer = (struct QBUFFER __iomem *)&reg->message_rbuffer;
2056	2142	}
2057	2143	break;
	2144	+ case ACB_ADAPTER_TYPE_F: {
	2145	+ qbuffer = (struct QBUFFER __iomem *)acb->message_rbuffer;
	2146	+ }
	2147	+ break;
2058	2148	}
2059	2149	return qbuffer;
2060	2150	}
@@ -2069,7 +2159,6 @@ static struct QBUFFER __iomem *arcmsr_get_iop_wqbuffer(struct AdapterControlBloc · 8 unmodified lines
2069	2159	pqbuffer = (struct QBUFFER __iomem *) &reg->message_wbuffer;
2070	2160	}
2071	2161	break;
2072		−
2073	2162	case ACB_ADAPTER_TYPE_B: {
2074	2163	struct MessageUnit_B *reg = acb->pmuB;
2075	2164	pqbuffer = (struct QBUFFER __iomem *)reg->message_wbuffer;
@@ -2090,6 +2179,9 @@ static struct QBUFFER __iomem *arcmsr_get_iop_wqbuffer(struct AdapterControlBloc · 14 unmodified lines
2090	2179	pqbuffer = (struct QBUFFER __iomem *)&reg->message_wbuffer;
2091	2180	}
2092	2181	break;
	2182	+ case ACB_ADAPTER_TYPE_F:
	2183	+ pqbuffer = (struct QBUFFER __iomem *)acb->message_wbuffer;
	2184	+ break;
2093	2185	}
2094	2186	return pqbuffer;
2095	2187	}
@@ -2504,6 +2596,36 @@ static void arcmsr_hbaE_postqueue_isr(struct AdapterControlBlock *acb) · 408 unmodified lines
2504	2596	spin_unlock_irqrestore(&acb->doneq_lock, flags);
2505	2597	}
2506	2598
	2599	+static void arcmsr_hbaF_postqueue_isr(struct AdapterControlBlock *acb)
	2600	+{
	2601	+ uint32_t doneq_index;
	2602	+ uint16_t cmdSMID;
	2603	+ int error;
	2604	+ struct MessageUnit_F __iomem *phbcmu;
	2605	+ struct CommandControlBlock *ccb;
	2606	+ unsigned long flags;
	2607	+
	2608	+ spin_lock_irqsave(&acb->doneq_lock, flags);
	2609	+ doneq_index = acb->doneq_index;
	2610	+ phbcmu = acb->pmuF;
	2611	+ while (1) {
	2612	+ cmdSMID = acb->pCompletionQ[doneq_index].cmdSMID;
	2613	+ if (cmdSMID == 0xffff)
	2614	+ break;
	2615	+ ccb = acb->pccb_pool[cmdSMID];
	2616	+ error = (acb->pCompletionQ[doneq_index].cmdFlag &
	2617	+ ARCMSR_CCBREPLY_FLAG_ERROR_MODE1) ? true : false;
	2618	+ arcmsr_drain_donequeue(acb, ccb, error);
	2619	+ acb->pCompletionQ[doneq_index].cmdSMID = 0xffff;
	2620	+ doneq_index++;
	2621	+ if (doneq_index >= acb->completionQ_entry)
	2622	+ doneq_index = 0;
	2623	+ }
	2624	+ acb->doneq_index = doneq_index;
	2625	+ writel(doneq_index, &phbcmu->reply_post_consumer_index);
	2626	+ spin_unlock_irqrestore(&acb->doneq_lock, flags);
	2627	+}
	2628	+
2507	2629	/*
2508	2630	**********************************************************************************
2509	2631	** Handle a message interrupt
@@ -2694,21 +2816,46 @@ static irqreturn_t arcmsr_hbaE_handle_isr(struct AdapterControlBlock *pACB) · 184 unmodified lines
2694	2816	return IRQ_HANDLED;
2695	2817	}
2696	2818
	2819	+static irqreturn_t arcmsr_hbaF_handle_isr(struct AdapterControlBlock *pACB)
	2820	+{
	2821	+ uint32_t host_interrupt_status;
	2822	+ struct MessageUnit_F __iomem *phbcmu = pACB->pmuF;
	2823	+
	2824	+ host_interrupt_status = readl(&phbcmu->host_int_status) &
	2825	+ (ARCMSR_HBEMU_OUTBOUND_POSTQUEUE_ISR \|
	2826	+ ARCMSR_HBEMU_OUTBOUND_DOORBELL_ISR);
	2827	+ if (!host_interrupt_status)
	2828	+ return IRQ_NONE;
	2829	+ do {
	2830	+ /* MU post queue interrupts*/
	2831	+ if (host_interrupt_status & ARCMSR_HBEMU_OUTBOUND_POSTQUEUE_ISR)
	2832	+ arcmsr_hbaF_postqueue_isr(pACB);
	2833	+
	2834	+ /* MU ioctl transfer doorbell interrupts*/
	2835	+ if (host_interrupt_status & ARCMSR_HBEMU_OUTBOUND_DOORBELL_ISR)
	2836	+ arcmsr_hbaE_doorbell_isr(pACB);
	2837	+
	2838	+ host_interrupt_status = readl(&phbcmu->host_int_status);
	2839	+ } while (host_interrupt_status & (ARCMSR_HBEMU_OUTBOUND_POSTQUEUE_ISR \|
	2840	+ ARCMSR_HBEMU_OUTBOUND_DOORBELL_ISR));
	2841	+ return IRQ_HANDLED;
	2842	+}
	2843	+
2697	2844	static irqreturn_t arcmsr_interrupt(struct AdapterControlBlock *acb)
2698	2845	{
2699	2846	switch (acb->adapter_type) {
2700	2847	case ACB_ADAPTER_TYPE_A:
2701	2848	return arcmsr_hbaA_handle_isr(acb);
2702		− break;
2703	2849	case ACB_ADAPTER_TYPE_B:
2704	2850	return arcmsr_hbaB_handle_isr(acb);
2705		− break;
2706	2851	case ACB_ADAPTER_TYPE_C:
2707	2852	return arcmsr_hbaC_handle_isr(acb);
2708	2853	case ACB_ADAPTER_TYPE_D:
2709	2854	return arcmsr_hbaD_handle_isr(acb);
2710	2855	case ACB_ADAPTER_TYPE_E:
2711	2856	return arcmsr_hbaE_handle_isr(acb);
	2857	+ case ACB_ADAPTER_TYPE_F:
	2858	+ return arcmsr_hbaF_handle_isr(acb);
2712	2859	default:
2713	2860	return IRQ_NONE;
2714	2861	}
@@ -3257,6 +3404,31 @@ static bool arcmsr_hbaE_get_config(struct AdapterControlBlock *pACB) · 542 unmodified lines
3257	3404	return true;
3258	3405	}
3259	3406
	3407	+static bool arcmsr_hbaF_get_config(struct AdapterControlBlock *pACB)
	3408	+{
	3409	+ struct MessageUnit_F __iomem *reg = pACB->pmuF;
	3410	+ uint32_t intmask_org;
	3411	+
	3412	+ /* disable all outbound interrupt */
	3413	+ intmask_org = readl(&reg->host_int_mask); /* disable outbound message0 int */
	3414	+ writel(intmask_org \| ARCMSR_HBEMU_ALL_INTMASKENABLE, &reg->host_int_mask);
	3415	+ /* wait firmware ready */
	3416	+ arcmsr_wait_firmware_ready(pACB);
	3417	+ /* post "get config" instruction */
	3418	+ writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, &reg->inbound_msgaddr0);
	3419	+
	3420	+ pACB->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
	3421	+ writel(pACB->out_doorbell, &reg->iobound_doorbell);
	3422	+ /* wait message ready */
	3423	+ if (!arcmsr_hbaE_wait_msgint_ready(pACB)) {
	3424	+ pr_notice("arcmsr%d: wait get adapter firmware miscellaneous data timeout\n",
	3425	+ pACB->host->host_no);
	3426	+ return false;
	3427	+ }
	3428	+ arcmsr_get_adapter_config(pACB, pACB->msgcode_rwbuffer);
	3429	+ return true;
	3430	+}
	3431	+
3260	3432	static bool arcmsr_get_firmware_spec(struct AdapterControlBlock *acb)
3261	3433	{
3262	3434	bool rtn = false;
@@ -3277,6 +3449,9 @@ static bool arcmsr_get_firmware_spec(struct AdapterControlBlock *acb) · 14 unmodified lines
3277	3449	case ACB_ADAPTER_TYPE_E:
3278	3450	rtn = arcmsr_hbaE_get_config(acb);
3279	3451	break;
	3452	+ case ACB_ADAPTER_TYPE_F:
	3453	+ rtn = arcmsr_hbaF_get_config(acb);
	3454	+ break;
3280	3455	default:
3281	3456	break;
3282	3457	}
@@ -3634,23 +3809,20 @@ static int arcmsr_polling_ccbdone(struct AdapterControlBlock *acb, · 351 unmodified lines
3634	3809	int rtn = 0;
3635	3810	switch (acb->adapter_type) {
3636	3811
3637		− case ACB_ADAPTER_TYPE_A: {
	3812	+ case ACB_ADAPTER_TYPE_A:
3638	3813	rtn = arcmsr_hbaA_polling_ccbdone(acb, poll_ccb);
3639		− }
3640	3814	break;
3641		−
3642		− case ACB_ADAPTER_TYPE_B: {
	3815	+ case ACB_ADAPTER_TYPE_B:
3643	3816	rtn = arcmsr_hbaB_polling_ccbdone(acb, poll_ccb);
3644		− }
3645	3817	break;
3646		− case ACB_ADAPTER_TYPE_C: {
	3818	+ case ACB_ADAPTER_TYPE_C:
3647	3819	rtn = arcmsr_hbaC_polling_ccbdone(acb, poll_ccb);
3648		− }
3649	3820	break;
3650	3821	case ACB_ADAPTER_TYPE_D:
3651	3822	rtn = arcmsr_hbaD_polling_ccbdone(acb, poll_ccb);
3652	3823	break;
3653	3824	case ACB_ADAPTER_TYPE_E:
	3825	+ case ACB_ADAPTER_TYPE_F:
3654	3826	rtn = arcmsr_hbaE_polling_ccbdone(acb, poll_ccb);
3655	3827	break;
3656	3828	}
@@ -3731,6 +3903,16 @@ static void arcmsr_set_iop_datetime(struct timer_list *t) · 74 unmodified lines
3731	3903	writel(pacb->out_doorbell, &reg->iobound_doorbell);
3732	3904	break;
3733	3905	}
	3906	+ case ACB_ADAPTER_TYPE_F: {
	3907	+ struct MessageUnit_F __iomem *reg = pacb->pmuF;
	3908	+
	3909	+ pacb->msgcode_rwbuffer[0] = datetime.b.msg_time[0];
	3910	+ pacb->msgcode_rwbuffer[1] = datetime.b.msg_time[1];
	3911	+ writel(ARCMSR_INBOUND_MESG0_SYNC_TIMER, &reg->inbound_msgaddr0);
	3912	+ pacb->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
	3913	+ writel(pacb->out_doorbell, &reg->iobound_doorbell);
	3914	+ break;
	3915	+ }
3734	3916	}
3735	3917	if (sys_tz.tz_minuteswest)
3736	3918	next_time = ARCMSR_HOURS;
@@ -3756,6 +3938,7 @@ static int arcmsr_iop_confirm(struct AdapterControlBlock *acb) · 19 unmodified lines
3756	3938	dma_coherent_handle = acb->dma_coherent_handle2;
3757	3939	break;
3758	3940	case ACB_ADAPTER_TYPE_E:
	3941	+ case ACB_ADAPTER_TYPE_F:
3759	3942	dma_coherent_handle = acb->dma_coherent_handle +
3760	3943	offsetof(struct CommandControlBlock, arcmsr_cdb);
3761	3944	break;
@@ -3873,11 +4056,8 @@ static int arcmsr_iop_confirm(struct AdapterControlBlock *acb) · 111 unmodified lines
3873	4056	writel(cdb_phyaddr, &reg->msgcode_rwbuffer[2]);
3874	4057	writel(cdb_phyaddr_hi32, &reg->msgcode_rwbuffer[3]);
3875	4058	writel(acb->ccbsize, &reg->msgcode_rwbuffer[4]);
3876		− dma_coherent_handle = acb->dma_coherent_handle2;
3877		− cdb_phyaddr = (uint32_t)(dma_coherent_handle & 0xffffffff);
3878		− cdb_phyaddr_hi32 = (uint32_t)((dma_coherent_handle >> 16) >> 16);
3879		− writel(cdb_phyaddr, &reg->msgcode_rwbuffer[5]);
3880		− writel(cdb_phyaddr_hi32, &reg->msgcode_rwbuffer[6]);
	4059	+ writel(lower_32_bits(acb->dma_coherent_handle2), &reg->msgcode_rwbuffer[5]);
	4060	+ writel(upper_32_bits(acb->dma_coherent_handle2), &reg->msgcode_rwbuffer[6]);
3881	4061	writel(acb->ioqueue_size, &reg->msgcode_rwbuffer[7]);
3882	4062	writel(ARCMSR_INBOUND_MESG0_SET_CONFIG, &reg->inbound_msgaddr0);
3883	4063	acb->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
@@ -3889,6 +4069,27 @@ static int arcmsr_iop_confirm(struct AdapterControlBlock *acb) · 5 unmodified lines
3889	4069	}
3890	4070	}
3891	4071	break;
	4072	+ case ACB_ADAPTER_TYPE_F: {
	4073	+ struct MessageUnit_F __iomem *reg = acb->pmuF;
	4074	+
	4075	+ acb->msgcode_rwbuffer[0] = ARCMSR_SIGNATURE_SET_CONFIG;
	4076	+ acb->msgcode_rwbuffer[1] = ARCMSR_SIGNATURE_1886;
	4077	+ acb->msgcode_rwbuffer[2] = cdb_phyaddr;
	4078	+ acb->msgcode_rwbuffer[3] = cdb_phyaddr_hi32;
	4079	+ acb->msgcode_rwbuffer[4] = acb->ccbsize;
	4080	+ acb->msgcode_rwbuffer[5] = lower_32_bits(acb->dma_coherent_handle2);
	4081	+ acb->msgcode_rwbuffer[6] = upper_32_bits(acb->dma_coherent_handle2);
	4082	+ acb->msgcode_rwbuffer[7] = acb->completeQ_size;
	4083	+ writel(ARCMSR_INBOUND_MESG0_SET_CONFIG, &reg->inbound_msgaddr0);
	4084	+ acb->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
	4085	+ writel(acb->out_doorbell, &reg->iobound_doorbell);
	4086	+ if (!arcmsr_hbaE_wait_msgint_ready(acb)) {
	4087	+ pr_notice("arcmsr%d: 'set command Q window' timeout\n",
	4088	+ acb->host->host_no);
	4089	+ return 1;
	4090	+ }
	4091	+ }
	4092	+ break;
3892	4093	}
3893	4094	return 0;
3894	4095	}
@@ -3937,7 +4138,8 @@ static void arcmsr_wait_firmware_ready(struct AdapterControlBlock *acb) · 42 unmodified lines
3937	4138	ARCMSR_ARC1214_MESSAGE_FIRMWARE_OK) == 0);
3938	4139	}
3939	4140	break;
3940		− case ACB_ADAPTER_TYPE_E: {
	4141	+ case ACB_ADAPTER_TYPE_E:
	4142	+ case ACB_ADAPTER_TYPE_F: {
3941	4143	struct MessageUnit_E __iomem *reg = acb->pmuE;
3942	4144	do {
3943	4145	if (!(acb->acb_flags & ACB_F_IOP_INITED))
@@ -3952,24 +4154,10 @@ static void arcmsr_wait_firmware_ready(struct AdapterControlBlock *acb) · 8 unmodified lines
3952	4154	static void arcmsr_request_device_map(struct timer_list *t)
3953	4155	{
3954	4156	struct AdapterControlBlock *acb = from_timer(acb, t, eternal_timer);
3955		− if (unlikely(atomic_read(&acb->rq_map_token) == 0) \|\|
3956		− (acb->acb_flags & ACB_F_BUS_RESET) \|\|
3957		− (acb->acb_flags & ACB_F_ABORT)) {
3958		− mod_timer(&acb->eternal_timer,
3959		− jiffies + msecs_to_jiffies(6 * HZ));
	4157	+ if (acb->acb_flags & (ACB_F_MSG_GET_CONFIG \| ACB_F_BUS_RESET \| ACB_F_ABORT)) {
	4158	+ mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6 * HZ));
3960	4159	} else {
3961	4160	acb->fw_flag = FW_NORMAL;
3962		− if (atomic_read(&acb->ante_token_value) ==
3963		− atomic_read(&acb->rq_map_token)) {
3964		− atomic_set(&acb->rq_map_token, 16);
3965		− }
3966		− atomic_set(&acb->ante_token_value,
3967		− atomic_read(&acb->rq_map_token));
3968		− if (atomic_dec_and_test(&acb->rq_map_token)) {
3969		− mod_timer(&acb->eternal_timer, jiffies +
3970		− msecs_to_jiffies(6 * HZ));
3971		− return;
3972		− }
3973	4161	switch (acb->adapter_type) {
3974	4162	case ACB_ADAPTER_TYPE_A: {
3975	4163	struct MessageUnit_A __iomem *reg = acb->pmuA;
@@ -3999,10 +4187,23 @@ static void arcmsr_request_device_map(struct timer_list *t) · 23 unmodified lines
3999	4187	writel(acb->out_doorbell, &reg->iobound_doorbell);
4000	4188	break;
4001	4189	}
	4190	+ case ACB_ADAPTER_TYPE_F: {
	4191	+ struct MessageUnit_F __iomem *reg = acb->pmuF;
	4192	+ uint32_t outMsg1 = readl(&reg->outbound_msgaddr1);
	4193	+
	4194	+ if (!(outMsg1 & ARCMSR_HBFMU_MESSAGE_FIRMWARE_OK) \|\|
	4195	+ (outMsg1 & ARCMSR_HBFMU_MESSAGE_NO_VOLUME_CHANGE))
	4196	+ goto nxt6s;
	4197	+ writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, &reg->inbound_msgaddr0);
	4198	+ acb->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
	4199	+ writel(acb->out_doorbell, &reg->iobound_doorbell);
	4200	+ break;
	4201	+ }
4002	4202	default:
4003	4203	return;
4004	4204	}
4005	4205	acb->acb_flags \|= ACB_F_MSG_GET_CONFIG;
	4206	+nxt6s:
4006	4207	mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6 * HZ));
4007	4208	}
4008	4209	}
@@ -4084,6 +4285,7 @@ static void arcmsr_start_adapter_bgrb(struct AdapterControlBlock *acb) · 75 unmodified lines
4084	4285	arcmsr_hbaD_start_bgrb(acb);
4085	4286	break;
4086	4287	case ACB_ADAPTER_TYPE_E:
	4288	+ case ACB_ADAPTER_TYPE_F:
4087	4289	arcmsr_hbaE_start_bgrb(acb);
4088	4290	break;
4089	4291	}
@@ -4163,7 +4365,8 @@ static void arcmsr_clear_doorbell_queue_buffer(struct AdapterControlBlock *acb) · 73 unmodified lines
4163	4365	}
4164	4366	}
4165	4367	break;
4166		− case ACB_ADAPTER_TYPE_E: {
	4368	+ case ACB_ADAPTER_TYPE_E:
	4369	+ case ACB_ADAPTER_TYPE_F: {
4167	4370	struct MessageUnit_E __iomem *reg = acb->pmuE;
4168	4371	uint32_t i, tmp;
4169	4372
@@ -4290,7 +4493,8 @@ static bool arcmsr_reset_in_progress(struct AdapterControlBlock *acb) · 120 unmodified lines
4290	4493	true : false;
4291	4494	}
4292	4495	break;
4293		− case ACB_ADAPTER_TYPE_E:{
	4496	+ case ACB_ADAPTER_TYPE_E:
	4497	+ case ACB_ADAPTER_TYPE_F:{
4294	4498	struct MessageUnit_E __iomem *reg = acb->pmuE;
4295	4499	rtn = (readl(&reg->host_diagnostic_3xxx) &
4296	4500	ARCMSR_ARC188X_RESET_ADAPTER) ? true : false;
@@ -4389,8 +4593,6 @@ wait_reset_done: · 92 unmodified lines
4389	4593	goto wait_reset_done;
4390	4594	}
4391	4595	arcmsr_iop_init(acb);
4392		− atomic_set(&acb->rq_map_token, 16);
4393		− atomic_set(&acb->ante_token_value, 16);
4394	4596	acb->fw_flag = FW_NORMAL;
4395	4597	mod_timer(&acb->eternal_timer, jiffies +
4396	4598	msecs_to_jiffies(6 * HZ));
@@ -4399,8 +4601,6 @@ wait_reset_done: · 2 unmodified lines
4399	4601	pr_notice("arcmsr: scsi bus reset eh returns with success\n");
4400	4602	} else {
4401	4603	acb->acb_flags &= ~ACB_F_BUS_RESET;
4402		− atomic_set(&acb->rq_map_token, 16);
4403		− atomic_set(&acb->ante_token_value, 16);
4404	4604	acb->fw_flag = FW_NORMAL;
4405	4605	mod_timer(&acb->eternal_timer, jiffies +
4406	4606	msecs_to_jiffies(6 * HZ));
@@ -4493,6 +4693,9 @@ static const char arcmsr_info(struct Scsi_Host host) · 86 unmodified lines
4493	4693	case PCI_DEVICE_ID_ARECA_1884:
4494	4694	type = "SAS/SATA";
4495	4695	break;
	4696	+ case PCI_DEVICE_ID_ARECA_1886:
	4697	+ type = "NVMe/SAS/SATA";
	4698	+ break;
4496	4699	default:
4497	4700	type = "unknown";
4498	4701	raid6 = 0;

drivers/scsi/bfa/bfad.c+1−0

@@ -749,6 +749,7 @@ bfad_pci_init(struct pci_dev pdev, struct bfad_s bfad) · 748 unmodified lines
749	749
750	750	if (bfad->pci_bar0_kva == NULL) {
751	751	printk(KERN_ERR "Fail to map bar0\n");
	752	+ rc = -ENODEV;
752	753	goto out_release_region;
753	754	}
754	755

drivers/scsi/dc395x.c+1−24

@@ -4721,30 +4721,7 @@ static struct pci_driver dc395x_driver = { · 4720 unmodified lines
4721	4721	.probe = dc395x_init_one,
4722	4722	.remove = dc395x_remove_one,
4723	4723	};
4724		−
4725		−
4726		−/**
4727		− * dc395x_module_init - Module initialization function
4728		− *
4729		− * Used by both module and built-in driver to initialise this driver.
4730		− **/
4731		−static int __init dc395x_module_init(void)
4732		−{
4733		− return pci_register_driver(&dc395x_driver);
4734		−}
4735		−
4736		−
4737		−/**
4738		− * dc395x_module_exit - Module cleanup function.
4739		− **/
4740		−static void __exit dc395x_module_exit(void)
4741		−{
4742		− pci_unregister_driver(&dc395x_driver);
4743		−}
4744		−
4745		−
4746		−module_init(dc395x_module_init);
4747		−module_exit(dc395x_module_exit);
	4724	+module_pci_driver(dc395x_driver);
4748	4725
4749	4726	MODULE_AUTHOR("C.L. Huang / Erich Chen / Kurt Garloff");
4750	4727	MODULE_DESCRIPTION("SCSI host adapter driver for Tekram TRM-S1040 based adapters: Tekram DC395 and DC315 series");

drivers/scsi/fcoe/fcoe_sysfs.c+1−7

@@ -1053,16 +1053,10 @@ EXPORT_SYMBOL_GPL(fcoe_fcf_device_add); · 1052 unmodified lines
1053	1053
1054	1054	int __init fcoe_sysfs_setup(void)
1055	1055	{
1056		− int error;
1057		−
1058	1056	atomic_set(&ctlr_num, 0);
1059	1057	atomic_set(&fcf_num, 0);
1060	1058
1061		− error = bus_register(&fcoe_bus_type);
1062		− if (error)
1063		− return error;
1064		−
1065		− return 0;
	1059	+ return bus_register(&fcoe_bus_type);
1066	1060	}
1067	1061
1068	1062	void __exit fcoe_sysfs_teardown(void)

drivers/scsi/fnic/vnic_wq_copy.c+1−7

@@ -79,8 +79,6 @@ int vnic_wq_copy_alloc(struct vnic_dev vdev, struct vnic_wq_copy wq, · 78 unmodified lines
79	79	unsigned int index, unsigned int desc_count,
80	80	unsigned int desc_size)
81	81	{
82		− int err;
83		−
84	82	wq->index = index;
85	83	wq->vdev = vdev;
86	84	wq->to_use_index = wq->to_clean_index = 0;
@@ -92,11 +90,7 @@ int vnic_wq_copy_alloc(struct vnic_dev vdev, struct vnic_wq_copy wq, · 5 unmodified lines
92	90
93	91	vnic_wq_copy_disable(wq);
94	92
95		− err = vnic_dev_alloc_desc_ring(vdev, &wq->ring, desc_count, desc_size);
96		− if (err)
97		− return err;
98		−
99		− return 0;
	93	+ return vnic_dev_alloc_desc_ring(vdev, &wq->ring, desc_count, desc_size);
100	94	}
101	95
102	96	void vnic_wq_copy_init(struct vnic_wq_copy *wq, unsigned int cq_index,

drivers/scsi/gdth.c+76−75

@@ -3168,81 +3168,6 @@ static inline void gdth_timer_init(void) · 3167 unmodified lines
3168	3168	}
3169	3169	#endif
3170	3170
3171		−static void __init internal_setup(char str,int ints)
3172		−{
3173		− int i;
3174		− char cur_str, argv;
3175		−
3176		− TRACE2(("internal_setup() str %s ints[0] %d\n",
3177		− str ? str:"NULL", ints ? ints[0]:0));
3178		−
3179		− /* analyse string */
3180		− argv = str;
3181		− while (argv && (cur_str = strchr(argv, ':'))) {
3182		− int val = 0, c = *++cur_str;
3183		−
3184		− if (c == 'n' \|\| c == 'N')
3185		− val = 0;
3186		− else if (c == 'y' \|\| c == 'Y')
3187		− val = 1;
3188		− else
3189		− val = (int)simple_strtoul(cur_str, NULL, 0);
3190		−
3191		− if (!strncmp(argv, "disable:", 8))
3192		− disable = val;
3193		− else if (!strncmp(argv, "reserve_mode:", 13))
3194		− reserve_mode = val;
3195		− else if (!strncmp(argv, "reverse_scan:", 13))
3196		− reverse_scan = val;
3197		− else if (!strncmp(argv, "hdr_channel:", 12))
3198		− hdr_channel = val;
3199		− else if (!strncmp(argv, "max_ids:", 8))
3200		− max_ids = val;
3201		− else if (!strncmp(argv, "rescan:", 7))
3202		− rescan = val;
3203		− else if (!strncmp(argv, "shared_access:", 14))
3204		− shared_access = val;
3205		− else if (!strncmp(argv, "reserve_list:", 13)) {
3206		− reserve_list[0] = val;
3207		− for (i = 1; i < MAX_RES_ARGS; i++) {
3208		− cur_str = strchr(cur_str, ',');
3209		− if (!cur_str)
3210		− break;
3211		− if (!isdigit((int)*++cur_str)) {
3212		− --cur_str;
3213		− break;
3214		− }
3215		− reserve_list[i] =
3216		− (int)simple_strtoul(cur_str, NULL, 0);
3217		− }
3218		− if (!cur_str)
3219		− break;
3220		− argv = ++cur_str;
3221		− continue;
3222		− }
3223		−
3224		− if ((argv = strchr(argv, ',')))
3225		− ++argv;
3226		− }
3227		−}
3228		−
3229		−int __init option_setup(char *str)
3230		−{
3231		− int ints[MAXHA];
3232		− char *cur = str;
3233		− int i = 1;
3234		−
3235		− TRACE2(("option_setup() str %s\n", str ? str:"NULL"));
3236		−
3237		− while (cur && isdigit(*cur) && i < MAXHA) {
3238		− ints[i++] = simple_strtoul(cur, NULL, 0);
3239		− if ((cur = strchr(cur, ',')) != NULL) cur++;
3240		− }
3241		−
3242		− ints[0] = i - 1;
3243		− internal_setup(cur, ints);
3244		− return 1;
3245		−}
3246	3171
3247	3172	static const char gdth_ctr_name(gdth_ha_str ha)
3248	3173	{
@@ -4317,5 +4242,81 @@ module_init(gdth_init); · 1068 unmodified lines
4317	4242	module_exit(gdth_exit);
4318	4243
4319	4244	#ifndef MODULE
	4245	+static void __init internal_setup(char str,int ints)
	4246	+{
	4247	+ int i;
	4248	+ char cur_str, argv;
	4249	+
	4250	+ TRACE2(("internal_setup() str %s ints[0] %d\n",
	4251	+ str ? str:"NULL", ints ? ints[0]:0));
	4252	+
	4253	+ /* analyse string */
	4254	+ argv = str;
	4255	+ while (argv && (cur_str = strchr(argv, ':'))) {
	4256	+ int val = 0, c = *++cur_str;
	4257	+
	4258	+ if (c == 'n' \|\| c == 'N')
	4259	+ val = 0;
	4260	+ else if (c == 'y' \|\| c == 'Y')
	4261	+ val = 1;
	4262	+ else
	4263	+ val = (int)simple_strtoul(cur_str, NULL, 0);
	4264	+
	4265	+ if (!strncmp(argv, "disable:", 8))
	4266	+ disable = val;
	4267	+ else if (!strncmp(argv, "reserve_mode:", 13))
	4268	+ reserve_mode = val;
	4269	+ else if (!strncmp(argv, "reverse_scan:", 13))
	4270	+ reverse_scan = val;
	4271	+ else if (!strncmp(argv, "hdr_channel:", 12))
	4272	+ hdr_channel = val;
	4273	+ else if (!strncmp(argv, "max_ids:", 8))
	4274	+ max_ids = val;
	4275	+ else if (!strncmp(argv, "rescan:", 7))
	4276	+ rescan = val;
	4277	+ else if (!strncmp(argv, "shared_access:", 14))
	4278	+ shared_access = val;
	4279	+ else if (!strncmp(argv, "reserve_list:", 13)) {
	4280	+ reserve_list[0] = val;
	4281	+ for (i = 1; i < MAX_RES_ARGS; i++) {
	4282	+ cur_str = strchr(cur_str, ',');
	4283	+ if (!cur_str)
	4284	+ break;
	4285	+ if (!isdigit((int)*++cur_str)) {
	4286	+ --cur_str;
	4287	+ break;
	4288	+ }
	4289	+ reserve_list[i] =
	4290	+ (int)simple_strtoul(cur_str, NULL, 0);
	4291	+ }
	4292	+ if (!cur_str)
	4293	+ break;
	4294	+ argv = ++cur_str;
	4295	+ continue;
	4296	+ }
	4297	+
	4298	+ if ((argv = strchr(argv, ',')))
	4299	+ ++argv;
	4300	+ }
	4301	+}
	4302	+
	4303	+static int __init option_setup(char *str)
	4304	+{
	4305	+ int ints[MAXHA];
	4306	+ char *cur = str;
	4307	+ int i = 1;
	4308	+
	4309	+ TRACE2(("option_setup() str %s\n", str ? str:"NULL"));
	4310	+
	4311	+ while (cur && isdigit(*cur) && i < MAXHA) {
	4312	+ ints[i++] = simple_strtoul(cur, NULL, 0);
	4313	+ if ((cur = strchr(cur, ',')) != NULL) cur++;
	4314	+ }
	4315	+
	4316	+ ints[0] = i - 1;
	4317	+ internal_setup(cur, ints);
	4318	+ return 1;
	4319	+}
	4320	+
4320	4321	__setup("gdth=", option_setup);
4321	4322	#endif

drivers/scsi/initio.c+1−13

@@ -2962,20 +2962,8 @@ static struct pci_driver initio_pci_driver = { · 2961 unmodified lines
2962	2962	.probe = initio_probe_one,
2963	2963	.remove = initio_remove_one,
2964	2964	};
2965		−
2966		−static int __init initio_init_driver(void)
2967		−{
2968		− return pci_register_driver(&initio_pci_driver);
2969		−}
2970		−
2971		−static void __exit initio_exit_driver(void)
2972		−{
2973		− pci_unregister_driver(&initio_pci_driver);
2974		−}
	2965	+module_pci_driver(initio_pci_driver);
2975	2966
2976	2967	MODULE_DESCRIPTION("Initio INI-9X00U/UW SCSI device driver");
2977	2968	MODULE_AUTHOR("Initio Corporation");
2978	2969	MODULE_LICENSE("GPL");
2979		−
2980		−module_init(initio_init_driver);
2981		−module_exit(initio_exit_driver);

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

@@ -61,7 +61,7 @@ · 60 unmodified lines
61	61	/**
62	62	*
63	63	*
64		− * Remote node sets are sets of remote node index in the remtoe node table The
	64	+ * Remote node sets are sets of remote node index in the remote node table. The
65	65	* SCU hardware requires that STP remote node entries take three consecutive
66	66	* remote node index so the table is arranged in sets of three. The bits are
67	67	* used as 0111 0111 to make a byte and the bits define the set of three remote

drivers/scsi/myrb.c+2−3

@@ -1050,7 +1050,7 @@ static int myrb_get_hba_config(struct myrb_hba *cb) · 1049 unmodified lines
1050	1050	enquiry2->fw.turn_id = 0;
1051	1051	}
1052	1052	snprintf(cb->fw_version, sizeof(cb->fw_version),
1053		− "%d.%02d-%c-%02d",
	1053	+ "%u.%02u-%c-%02u",
1054	1054	enquiry2->fw.major_version,
1055	1055	enquiry2->fw.minor_version,
1056	1056	enquiry2->fw.firmware_type,
@@ -2167,7 +2167,7 @@ static ssize_t ctlr_num_show(struct device *dev, · 1110 unmodified lines
2167	2167	struct Scsi_Host *shost = class_to_shost(dev);
2168	2168	struct myrb_hba *cb = shost_priv(shost);
2169	2169
2170		− return snprintf(buf, 20, "%d\n", cb->ctlr_num);
	2170	+ return snprintf(buf, 20, "%u\n", cb->ctlr_num);
2171	2171	}
2172	2172	static DEVICE_ATTR_RO(ctlr_num);
2173	2173
@@ -2732,7 +2732,6 @@ static int DAC960_LA_hw_init(struct pci_dev *pdev, · 558 unmodified lines
2732	2732	DAC960_LA_disable_intr(base);
2733	2733	DAC960_LA_ack_hw_mbox_status(base);
2734	2734	udelay(1000);
2735		− timeout = 0;
2736	2735	while (DAC960_LA_init_in_progress(base) &&
2737	2736	timeout < MYRB_MAILBOX_TIMEOUT) {
2738	2737	if (DAC960_LA_read_error_status(base, &error,

drivers/scsi/pm8001/pm8001_ctl.c+4−2

@@ -408,9 +408,10 @@ static ssize_t pm8001_ctl_ib_queue_log_show(struct device *cdev, · 407 unmodified lines
408	408	int offset;
409	409	char *str = buf;
410	410	int start = 0;
	411	+ u32 ib_offset = pm8001_ha->ib_offset;
411	412	#define IB_MEMMAP(c) \
412	413	((u32 )((u8 *)pm8001_ha-> \
413		− memoryMap.region[IB].virt_ptr + \
	414	+ memoryMap.region[ib_offset].virt_ptr + \
414	415	pm8001_ha->evtlog_ib_offset + (c)))
415	416
416	417	for (offset = 0; offset < IB_OB_READ_TIMES; offset++) {
@@ -442,9 +443,10 @@ static ssize_t pm8001_ctl_ob_queue_log_show(struct device *cdev, · 25 unmodified lines
442	443	int offset;
443	444	char *str = buf;
444	445	int start = 0;
	446	+ u32 ob_offset = pm8001_ha->ob_offset;
445	447	#define OB_MEMMAP(c) \
446	448	((u32 )((u8 *)pm8001_ha-> \
447		− memoryMap.region[OB].virt_ptr + \
	449	+ memoryMap.region[ob_offset].virt_ptr + \
448	450	pm8001_ha->evtlog_ob_offset + (c)))
449	451
450	452	for (offset = 0; offset < IB_OB_READ_TIMES; offset++) {

drivers/scsi/pm8001/pm8001_defs.h+13−14

@@ -75,12 +75,10 @@ enum port_type { · 74 unmodified lines
75	75	};
76	76
77	77	/* driver compile-time configuration */
78		−#define PM8001_MAX_CCB 256 /* max ccbs supported */
	78	+#define PM8001_MAX_CCB 1024 /* max ccbs supported */
79	79	#define PM8001_MPI_QUEUE 1024 /* maximum mpi queue entries */
80		−#define PM8001_MAX_INB_NUM 1
81		−#define PM8001_MAX_OUTB_NUM 1
82		−#define PM8001_MAX_SPCV_INB_NUM 1
83		−#define PM8001_MAX_SPCV_OUTB_NUM 4
	80	+#define PM8001_MAX_INB_NUM 64
	81	+#define PM8001_MAX_OUTB_NUM 64
84	82	#define PM8001_CAN_QUEUE 508 /* SCSI Queue depth */
85	83
86	84	/* Inbound/Outbound queue size */
@@ -92,26 +90,27 @@ enum port_type { · 5 unmodified lines
92	90	#define PM8001_MAX_PORTS 16 /* max. possible ports */
93	91	#define PM8001_MAX_DEVICES 2048 /* max supported device */
94	92	#define PM8001_MAX_MSIX_VEC 64 /* max msi-x int for spcv/ve */
	93	+#define PM8001_RESERVE_SLOT 8
95	94
96		−#define USI_MAX_MEMCNT_BASE 5
97		−#define IB (USI_MAX_MEMCNT_BASE + 1)
98		−#define CI (IB + PM8001_MAX_SPCV_INB_NUM)
99		−#define OB (CI + PM8001_MAX_SPCV_INB_NUM)
100		−#define PI (OB + PM8001_MAX_SPCV_OUTB_NUM)
101		−#define USI_MAX_MEMCNT (PI + PM8001_MAX_SPCV_OUTB_NUM)
102	95	#define CONFIG_SCSI_PM8001_MAX_DMA_SG 528
103	96	#define PM8001_MAX_DMA_SG CONFIG_SCSI_PM8001_MAX_DMA_SG
	97	+
104	98	enum memory_region_num {
105	99	AAP1 = 0x0, /* application acceleration processor */
106	100	IOP, /* IO processor */
107	101	NVMD, /* NVM device */
108		− DEV_MEM, /* memory for devices */
109		− CCB_MEM, /* memory for command control block */
110	102	FW_FLASH, /* memory for fw flash update */
111		− FORENSIC_MEM /* memory for fw forensic data */
	103	+ FORENSIC_MEM, /* memory for fw forensic data */
	104	+ USI_MAX_MEMCNT_BASE
112	105	};
113	106	#define PM8001_EVENT_LOG_SIZE (128 * 1024)
114	107
	108	+/**
	109	+ * maximum DMA memory regions(number of IBQ + number of IBQ CI
	110	+ * + number of OBQ + number of OBQ PI)
	111	+ */
	112	+#define USI_MAX_MEMCNT (USI_MAX_MEMCNT_BASE + ((2 * PM8001_MAX_INB_NUM) \
	113	+ + (2 * PM8001_MAX_OUTB_NUM)))
115	114	/error code/
116	115	enum mpi_err {
117	116	MPI_IO_STATUS_SUCCESS = 0x0,

drivers/scsi/pm8001/pm8001_hwi.c+20−18

@@ -189,6 +189,10 @@ static void init_default_table_values(struct pm8001_hba_info *pm8001_ha) · 188 unmodified lines
189	189	u32 offsetib, offsetob;
190	190	void __iomem *addressib = pm8001_ha->inbnd_q_tbl_addr;
191	191	void __iomem *addressob = pm8001_ha->outbnd_q_tbl_addr;
	192	+ u32 ib_offset = pm8001_ha->ib_offset;
	193	+ u32 ob_offset = pm8001_ha->ob_offset;
	194	+ u32 ci_offset = pm8001_ha->ci_offset;
	195	+ u32 pi_offset = pm8001_ha->pi_offset;
192	196
193	197	pm8001_ha->main_cfg_tbl.pm8001_tbl.inbound_q_nppd_hppd = 0;
194	198	pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_hw_event_pid0_3 = 0;
@@ -223,19 +227,19 @@ static void init_default_table_values(struct pm8001_hba_info *pm8001_ha) · 28 unmodified lines
223	227	pm8001_ha->inbnd_q_tbl[i].element_pri_size_cnt =
224	228	PM8001_MPI_QUEUE \| (pm8001_ha->iomb_size << 16) \| (0x00<<30);
225	229	pm8001_ha->inbnd_q_tbl[i].upper_base_addr =
226		− pm8001_ha->memoryMap.region[IB + i].phys_addr_hi;
	230	+ pm8001_ha->memoryMap.region[ib_offset + i].phys_addr_hi;
227	231	pm8001_ha->inbnd_q_tbl[i].lower_base_addr =
228		− pm8001_ha->memoryMap.region[IB + i].phys_addr_lo;
	232	+ pm8001_ha->memoryMap.region[ib_offset + i].phys_addr_lo;
229	233	pm8001_ha->inbnd_q_tbl[i].base_virt =
230		− (u8 *)pm8001_ha->memoryMap.region[IB + i].virt_ptr;
	234	+ (u8 *)pm8001_ha->memoryMap.region[ib_offset + i].virt_ptr;
231	235	pm8001_ha->inbnd_q_tbl[i].total_length =
232		− pm8001_ha->memoryMap.region[IB + i].total_len;
	236	+ pm8001_ha->memoryMap.region[ib_offset + i].total_len;
233	237	pm8001_ha->inbnd_q_tbl[i].ci_upper_base_addr =
234		− pm8001_ha->memoryMap.region[CI + i].phys_addr_hi;
	238	+ pm8001_ha->memoryMap.region[ci_offset + i].phys_addr_hi;
235	239	pm8001_ha->inbnd_q_tbl[i].ci_lower_base_addr =
236		− pm8001_ha->memoryMap.region[CI + i].phys_addr_lo;
	240	+ pm8001_ha->memoryMap.region[ci_offset + i].phys_addr_lo;
237	241	pm8001_ha->inbnd_q_tbl[i].ci_virt =
238		− pm8001_ha->memoryMap.region[CI + i].virt_ptr;
	242	+ pm8001_ha->memoryMap.region[ci_offset + i].virt_ptr;
239	243	offsetib = i * 0x20;
240	244	pm8001_ha->inbnd_q_tbl[i].pi_pci_bar =
241	245	get_pci_bar_index(pm8001_mr32(addressib,
@@ -249,21 +253,21 @@ static void init_default_table_values(struct pm8001_hba_info *pm8001_ha) · 7 unmodified lines
249	253	pm8001_ha->outbnd_q_tbl[i].element_size_cnt =
250	254	PM8001_MPI_QUEUE \| (pm8001_ha->iomb_size << 16) \| (0x01<<30);
251	255	pm8001_ha->outbnd_q_tbl[i].upper_base_addr =
252		− pm8001_ha->memoryMap.region[OB + i].phys_addr_hi;
	256	+ pm8001_ha->memoryMap.region[ob_offset + i].phys_addr_hi;
253	257	pm8001_ha->outbnd_q_tbl[i].lower_base_addr =
254		− pm8001_ha->memoryMap.region[OB + i].phys_addr_lo;
	258	+ pm8001_ha->memoryMap.region[ob_offset + i].phys_addr_lo;
255	259	pm8001_ha->outbnd_q_tbl[i].base_virt =
256		− (u8 *)pm8001_ha->memoryMap.region[OB + i].virt_ptr;
	260	+ (u8 *)pm8001_ha->memoryMap.region[ob_offset + i].virt_ptr;
257	261	pm8001_ha->outbnd_q_tbl[i].total_length =
258		− pm8001_ha->memoryMap.region[OB + i].total_len;
	262	+ pm8001_ha->memoryMap.region[ob_offset + i].total_len;
259	263	pm8001_ha->outbnd_q_tbl[i].pi_upper_base_addr =
260		− pm8001_ha->memoryMap.region[PI + i].phys_addr_hi;
	264	+ pm8001_ha->memoryMap.region[pi_offset + i].phys_addr_hi;
261	265	pm8001_ha->outbnd_q_tbl[i].pi_lower_base_addr =
262		− pm8001_ha->memoryMap.region[PI + i].phys_addr_lo;
	266	+ pm8001_ha->memoryMap.region[pi_offset + i].phys_addr_lo;
263	267	pm8001_ha->outbnd_q_tbl[i].interrup_vec_cnt_delay =
264	268	0 \| (10 << 16) \| (i << 24);
265	269	pm8001_ha->outbnd_q_tbl[i].pi_virt =
266		− pm8001_ha->memoryMap.region[PI + i].virt_ptr;
	270	+ pm8001_ha->memoryMap.region[pi_offset + i].virt_ptr;
267	271	offsetob = i * 0x24;
268	272	pm8001_ha->outbnd_q_tbl[i].ci_pci_bar =
269	273	get_pci_bar_index(pm8001_mr32(addressob,
@@ -4371,8 +4375,7 @@ static int pm8001_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha, · 4101 unmodified lines
4371	4375	/* fill in PRD (scatter/gather) table, if any */
4372	4376	if (task->num_scatter > 1) {
4373	4377	pm8001_chip_make_sg(task->scatter, ccb->n_elem, ccb->buf_prd);
4374		− phys_addr = ccb->ccb_dma_handle +
4375		− offsetof(struct pm8001_ccb_info, buf_prd[0]);
	4378	+ phys_addr = ccb->ccb_dma_handle;
4376	4379	ssp_cmd.addr_low = cpu_to_le32(lower_32_bits(phys_addr));
4377	4380	ssp_cmd.addr_high = cpu_to_le32(upper_32_bits(phys_addr));
4378	4381	ssp_cmd.esgl = cpu_to_le32(1<<31);
@@ -4445,8 +4448,7 @@ static int pm8001_chip_sata_req(struct pm8001_hba_info *pm8001_ha, · 66 unmodified lines
4445	4448	/* fill in PRD (scatter/gather) table, if any */
4446	4449	if (task->num_scatter > 1) {
4447	4450	pm8001_chip_make_sg(task->scatter, ccb->n_elem, ccb->buf_prd);
4448		− phys_addr = ccb->ccb_dma_handle +
4449		− offsetof(struct pm8001_ccb_info, buf_prd[0]);
	4451	+ phys_addr = ccb->ccb_dma_handle;
4450	4452	sata_cmd.addr_low = lower_32_bits(phys_addr);
4451	4453	sata_cmd.addr_high = upper_32_bits(phys_addr);
4452	4454	sata_cmd.esgl = cpu_to_le32(1 << 31);

drivers/scsi/pm8001/pm8001_init.c+150−71

@@ -56,6 +56,7 @@ MODULE_PARM_DESC(link_rate, "Enable link rate.\n" · 55 unmodified lines
56	56	" 8: Link rate 12.0G\n");
57	57
58	58	static struct scsi_transport_template *pm8001_stt;
	59	+static int pm8001_init_ccb_tag(struct pm8001_hba_info , struct Scsi_Host , struct pci_dev *);
59	60
60	61	/*
61	62	* chip info structure to identify chip key functionality as
@@ -264,12 +265,36 @@ static u32 pm8001_request_irq(struct pm8001_hba_info *pm8001_ha); · 202 unmodified lines
264	265	static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha,
265	266	const struct pci_device_id *ent)
266	267	{
267		− int i;
	268	+ int i, count = 0, rc = 0;
	269	+ u32 ci_offset, ib_offset, ob_offset, pi_offset;
	270	+ struct inbound_queue_table *circularQ;
	271	+
268	272	spin_lock_init(&pm8001_ha->lock);
269	273	spin_lock_init(&pm8001_ha->bitmap_lock);
270	274	PM8001_INIT_DBG(pm8001_ha,
271	275	pm8001_printk("pm8001_alloc: PHY:%x\n",
272	276	pm8001_ha->chip->n_phy));
	277	+
	278	+ /* Setup Interrupt */
	279	+ rc = pm8001_setup_irq(pm8001_ha);
	280	+ if (rc) {
	281	+ PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
	282	+ "pm8001_setup_irq failed [ret: %d]\n", rc));
	283	+ goto err_out_shost;
	284	+ }
	285	+ /* Request Interrupt */
	286	+ rc = pm8001_request_irq(pm8001_ha);
	287	+ if (rc)
	288	+ goto err_out_shost;
	289	+
	290	+ count = pm8001_ha->max_q_num;
	291	+ /* Queues are chosen based on the number of cores/msix availability */
	292	+ ib_offset = pm8001_ha->ib_offset = USI_MAX_MEMCNT_BASE;
	293	+ ci_offset = pm8001_ha->ci_offset = ib_offset + count;
	294	+ ob_offset = pm8001_ha->ob_offset = ci_offset + count;
	295	+ pi_offset = pm8001_ha->pi_offset = ob_offset + count;
	296	+ pm8001_ha->max_memcnt = pi_offset + count;
	297	+
273	298	for (i = 0; i < pm8001_ha->chip->n_phy; i++) {
274	299	pm8001_phy_init(pm8001_ha, i);
275	300	pm8001_ha->port[i].wide_port_phymap = 0;
@@ -278,9 +303,6 @@ static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha, · 2 unmodified lines
278	303	INIT_LIST_HEAD(&pm8001_ha->port[i].list);
279	304	}
280	305
281		− pm8001_ha->tags = kzalloc(PM8001_MAX_CCB, GFP_KERNEL);
282		− if (!pm8001_ha->tags)
283		− goto err_out;
284	306	/* MPI Memory region 1 for AAP Event Log for fw */
285	307	pm8001_ha->memoryMap.region[AAP1].num_elements = 1;
286	308	pm8001_ha->memoryMap.region[AAP1].element_size = PM8001_EVENT_LOG_SIZE;
@@ -293,54 +315,62 @@ static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha, · 6 unmodified lines
293	315	pm8001_ha->memoryMap.region[IOP].total_len = PM8001_EVENT_LOG_SIZE;
294	316	pm8001_ha->memoryMap.region[IOP].alignment = 32;
295	317
296		− for (i = 0; i < PM8001_MAX_SPCV_INB_NUM; i++) {
	318	+ for (i = 0; i < count; i++) {
	319	+ circularQ = &pm8001_ha->inbnd_q_tbl[i];
	320	+ spin_lock_init(&circularQ->iq_lock);
297	321	/* MPI Memory region 3 for consumer Index of inbound queues */
298		− pm8001_ha->memoryMap.region[CI+i].num_elements = 1;
299		− pm8001_ha->memoryMap.region[CI+i].element_size = 4;
300		− pm8001_ha->memoryMap.region[CI+i].total_len = 4;
301		− pm8001_ha->memoryMap.region[CI+i].alignment = 4;
	322	+ pm8001_ha->memoryMap.region[ci_offset+i].num_elements = 1;
	323	+ pm8001_ha->memoryMap.region[ci_offset+i].element_size = 4;
	324	+ pm8001_ha->memoryMap.region[ci_offset+i].total_len = 4;
	325	+ pm8001_ha->memoryMap.region[ci_offset+i].alignment = 4;
302	326
303	327	if ((ent->driver_data) != chip_8001) {
304	328	/* MPI Memory region 5 inbound queues */
305		− pm8001_ha->memoryMap.region[IB+i].num_elements =
	329	+ pm8001_ha->memoryMap.region[ib_offset+i].num_elements =
306	330	PM8001_MPI_QUEUE;
307		− pm8001_ha->memoryMap.region[IB+i].element_size = 128;
308		− pm8001_ha->memoryMap.region[IB+i].total_len =
	331	+ pm8001_ha->memoryMap.region[ib_offset+i].element_size
	332	+ = 128;
	333	+ pm8001_ha->memoryMap.region[ib_offset+i].total_len =
309	334	PM8001_MPI_QUEUE * 128;
310		− pm8001_ha->memoryMap.region[IB+i].alignment = 128;
	335	+ pm8001_ha->memoryMap.region[ib_offset+i].alignment
	336	+ = 128;
311	337	} else {
312		− pm8001_ha->memoryMap.region[IB+i].num_elements =
	338	+ pm8001_ha->memoryMap.region[ib_offset+i].num_elements =
313	339	PM8001_MPI_QUEUE;
314		− pm8001_ha->memoryMap.region[IB+i].element_size = 64;
315		− pm8001_ha->memoryMap.region[IB+i].total_len =
	340	+ pm8001_ha->memoryMap.region[ib_offset+i].element_size
	341	+ = 64;
	342	+ pm8001_ha->memoryMap.region[ib_offset+i].total_len =
316	343	PM8001_MPI_QUEUE * 64;
317		− pm8001_ha->memoryMap.region[IB+i].alignment = 64;
	344	+ pm8001_ha->memoryMap.region[ib_offset+i].alignment = 64;
318	345	}
319	346	}
320	347
321		− for (i = 0; i < PM8001_MAX_SPCV_OUTB_NUM; i++) {
	348	+ for (i = 0; i < count; i++) {
322	349	/* MPI Memory region 4 for producer Index of outbound queues */
323		− pm8001_ha->memoryMap.region[PI+i].num_elements = 1;
324		− pm8001_ha->memoryMap.region[PI+i].element_size = 4;
325		− pm8001_ha->memoryMap.region[PI+i].total_len = 4;
326		− pm8001_ha->memoryMap.region[PI+i].alignment = 4;
	350	+ pm8001_ha->memoryMap.region[pi_offset+i].num_elements = 1;
	351	+ pm8001_ha->memoryMap.region[pi_offset+i].element_size = 4;
	352	+ pm8001_ha->memoryMap.region[pi_offset+i].total_len = 4;
	353	+ pm8001_ha->memoryMap.region[pi_offset+i].alignment = 4;
327	354
328	355	if (ent->driver_data != chip_8001) {
329	356	/* MPI Memory region 6 Outbound queues */
330		− pm8001_ha->memoryMap.region[OB+i].num_elements =
	357	+ pm8001_ha->memoryMap.region[ob_offset+i].num_elements =
331	358	PM8001_MPI_QUEUE;
332		− pm8001_ha->memoryMap.region[OB+i].element_size = 128;
333		− pm8001_ha->memoryMap.region[OB+i].total_len =
	359	+ pm8001_ha->memoryMap.region[ob_offset+i].element_size
	360	+ = 128;
	361	+ pm8001_ha->memoryMap.region[ob_offset+i].total_len =
334	362	PM8001_MPI_QUEUE * 128;
335		− pm8001_ha->memoryMap.region[OB+i].alignment = 128;
	363	+ pm8001_ha->memoryMap.region[ob_offset+i].alignment
	364	+ = 128;
336	365	} else {
337	366	/* MPI Memory region 6 Outbound queues */
338		− pm8001_ha->memoryMap.region[OB+i].num_elements =
	367	+ pm8001_ha->memoryMap.region[ob_offset+i].num_elements =
339	368	PM8001_MPI_QUEUE;
340		− pm8001_ha->memoryMap.region[OB+i].element_size = 64;
341		− pm8001_ha->memoryMap.region[OB+i].total_len =
	369	+ pm8001_ha->memoryMap.region[ob_offset+i].element_size
	370	+ = 64;
	371	+ pm8001_ha->memoryMap.region[ob_offset+i].total_len =
342	372	PM8001_MPI_QUEUE * 64;
343		− pm8001_ha->memoryMap.region[OB+i].alignment = 64;
	373	+ pm8001_ha->memoryMap.region[ob_offset+i].alignment = 64;
344	374	}
345	375
346	376	}
@@ -348,19 +378,6 @@ static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha, · 1 unmodified line
348	378	pm8001_ha->memoryMap.region[NVMD].num_elements = 1;
349	379	pm8001_ha->memoryMap.region[NVMD].element_size = 4096;
350	380	pm8001_ha->memoryMap.region[NVMD].total_len = 4096;
351		− /* Memory region for devices*/
352		− pm8001_ha->memoryMap.region[DEV_MEM].num_elements = 1;
353		− pm8001_ha->memoryMap.region[DEV_MEM].element_size = PM8001_MAX_DEVICES *
354		− sizeof(struct pm8001_device);
355		− pm8001_ha->memoryMap.region[DEV_MEM].total_len = PM8001_MAX_DEVICES *
356		− sizeof(struct pm8001_device);
357		−
358		− /* Memory region for ccb_info*/
359		− pm8001_ha->memoryMap.region[CCB_MEM].num_elements = 1;
360		− pm8001_ha->memoryMap.region[CCB_MEM].element_size = PM8001_MAX_CCB *
361		− sizeof(struct pm8001_ccb_info);
362		− pm8001_ha->memoryMap.region[CCB_MEM].total_len = PM8001_MAX_CCB *
363		− sizeof(struct pm8001_ccb_info);
364	381
365	382	/* Memory region for fw flash */
366	383	pm8001_ha->memoryMap.region[FW_FLASH].total_len = 4096;
@@ -369,7 +386,7 @@ static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha, · 2 unmodified lines
369	386	pm8001_ha->memoryMap.region[FORENSIC_MEM].total_len = 0x10000;
370	387	pm8001_ha->memoryMap.region[FORENSIC_MEM].element_size = 0x10000;
371	388	pm8001_ha->memoryMap.region[FORENSIC_MEM].alignment = 0x10000;
372		− for (i = 0; i < USI_MAX_MEMCNT; i++) {
	389	+ for (i = 0; i < pm8001_ha->max_memcnt; i++) {
373	390	if (pm8001_mem_alloc(pm8001_ha->pdev,
374	391	&pm8001_ha->memoryMap.region[i].virt_ptr,
375	392	&pm8001_ha->memoryMap.region[i].phys_addr,
@@ -384,27 +401,36 @@ static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha, · 8 unmodified lines
384	401	}
385	402	}
386	403
387		− pm8001_ha->devices = pm8001_ha->memoryMap.region[DEV_MEM].virt_ptr;
	404	+ /* Memory region for devices*/
	405	+ pm8001_ha->devices = kzalloc(PM8001_MAX_DEVICES
	406	+ * sizeof(struct pm8001_device), GFP_KERNEL);
	407	+ if (!pm8001_ha->devices) {
	408	+ rc = -ENOMEM;
	409	+ goto err_out_nodev;
	410	+ }
388	411	for (i = 0; i < PM8001_MAX_DEVICES; i++) {
389	412	pm8001_ha->devices[i].dev_type = SAS_PHY_UNUSED;
390	413	pm8001_ha->devices[i].id = i;
391	414	pm8001_ha->devices[i].device_id = PM8001_MAX_DEVICES;
392	415	pm8001_ha->devices[i].running_req = 0;
393	416	}
394		− pm8001_ha->ccb_info = pm8001_ha->memoryMap.region[CCB_MEM].virt_ptr;
395		− for (i = 0; i < PM8001_MAX_CCB; i++) {
396		− pm8001_ha->ccb_info[i].ccb_dma_handle =
397		− pm8001_ha->memoryMap.region[CCB_MEM].phys_addr +
398		− i * sizeof(struct pm8001_ccb_info);
399		− pm8001_ha->ccb_info[i].task = NULL;
400		− pm8001_ha->ccb_info[i].ccb_tag = 0xffffffff;
401		− pm8001_ha->ccb_info[i].device = NULL;
402		− ++pm8001_ha->tags_num;
403		− }
404	417	pm8001_ha->flags = PM8001F_INIT_TIME;
405	418	/* Initialize tags */
406	419	pm8001_tag_init(pm8001_ha);
407	420	return 0;
	421	+
	422	+err_out_shost:
	423	+ scsi_remove_host(pm8001_ha->shost);
	424	+err_out_nodev:
	425	+ for (i = 0; i < pm8001_ha->max_memcnt; i++) {
	426	+ if (pm8001_ha->memoryMap.region[i].virt_ptr != NULL) {
	427	+ pci_free_consistent(pm8001_ha->pdev,
	428	+ (pm8001_ha->memoryMap.region[i].total_len +
	429	+ pm8001_ha->memoryMap.region[i].alignment),
	430	+ pm8001_ha->memoryMap.region[i].virt_ptr,
	431	+ pm8001_ha->memoryMap.region[i].phys_addr);
	432	+ }
	433	+ }
408	434	err_out:
409	435	return 1;
410	436	}
@@ -899,7 +925,8 @@ static int pm8001_configure_phy_settings(struct pm8001_hba_info *pm8001_ha) · 488 unmodified lines
899	925	static u32 pm8001_setup_msix(struct pm8001_hba_info *pm8001_ha)
900	926	{
901	927	u32 number_of_intr;
902		− int rc;
	928	+ int rc, cpu_online_count;
	929	+ unsigned int allocated_irq_vectors;
903	930
904	931	/* SPCv controllers supports 64 msi-x */
905	932	if (pm8001_ha->chip_id == chip_8001) {
@@ -908,13 +935,21 @@ static u32 pm8001_setup_msix(struct pm8001_hba_info *pm8001_ha) · 2 unmodified lines
908	935	number_of_intr = PM8001_MAX_MSIX_VEC;
909	936	}
910	937
	938	+ cpu_online_count = num_online_cpus();
	939	+ number_of_intr = min_t(int, cpu_online_count, number_of_intr);
911	940	rc = pci_alloc_irq_vectors(pm8001_ha->pdev, number_of_intr,
912	941	number_of_intr, PCI_IRQ_MSIX);
913		− number_of_intr = rc;
	942	+ allocated_irq_vectors = rc;
914	943	if (rc < 0)
915	944	return rc;
	945	+
	946	+ /* Assigns the number of interrupts */
	947	+ number_of_intr = min_t(int, allocated_irq_vectors, number_of_intr);
916	948	pm8001_ha->number_of_intr = number_of_intr;
917	949
	950	+ /* Maximum queue number updating in HBA structure */
	951	+ pm8001_ha->max_q_num = number_of_intr;
	952	+
918	953	PM8001_INIT_DBG(pm8001_ha, pm8001_printk(
919	954	"pci_alloc_irq_vectors request ret:%d no of intr %d\n",
920	955	rc, pm8001_ha->number_of_intr));
@@ -1069,13 +1104,6 @@ static int pm8001_pci_probe(struct pci_dev *pdev, · 148 unmodified lines
1069	1104	rc = -ENOMEM;
1070	1105	goto err_out_free;
1071	1106	}
1072		− /* Setup Interrupt */
1073		− rc = pm8001_setup_irq(pm8001_ha);
1074		− if (rc) {
1075		− PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
1076		− "pm8001_setup_irq failed [ret: %d]\n", rc));
1077		− goto err_out_shost;
1078		− }
1079	1107
1080	1108	PM8001_CHIP_DISP->chip_soft_rst(pm8001_ha);
1081	1109	rc = PM8001_CHIP_DISP->chip_init(pm8001_ha);
@@ -1085,16 +1113,13 @@ static int pm8001_pci_probe(struct pci_dev *pdev, · 3 unmodified lines
1085	1113	goto err_out_ha_free;
1086	1114	}
1087	1115
	1116	+ rc = pm8001_init_ccb_tag(pm8001_ha, shost, pdev);
	1117	+ if (rc)
	1118	+ goto err_out_enable;
	1119	+
1088	1120	rc = scsi_add_host(shost, &pdev->dev);
1089	1121	if (rc)
1090	1122	goto err_out_ha_free;
1091		− /* Request Interrupt */
1092		− rc = pm8001_request_irq(pm8001_ha);
1093		− if (rc) {
1094		− PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
1095		− "pm8001_request_irq failed [ret: %d]\n", rc));
1096		− goto err_out_shost;
1097		− }
1098	1123
1099	1124	PM8001_CHIP_DISP->interrupt_enable(pm8001_ha, 0);
1100	1125	if (pm8001_ha->chip_id != chip_8001) {
@@ -1137,6 +1162,60 @@ err_out_enable: · 36 unmodified lines
1137	1162	return rc;
1138	1163	}
1139	1164
	1165	+/*
	1166	+ * pm8001_init_ccb_tag - allocate memory to CCB and tag.
	1167	+ * @pm8001_ha: our hba card information.
	1168	+ * @shost: scsi host which has been allocated outside.
	1169	+ */
	1170	+static int
	1171	+pm8001_init_ccb_tag(struct pm8001_hba_info pm8001_ha, struct Scsi_Host shost,
	1172	+ struct pci_dev *pdev)
	1173	+{
	1174	+ int i = 0;
	1175	+ u32 max_out_io, ccb_count;
	1176	+ u32 can_queue;
	1177	+
	1178	+ max_out_io = pm8001_ha->main_cfg_tbl.pm80xx_tbl.max_out_io;
	1179	+ ccb_count = min_t(int, PM8001_MAX_CCB, max_out_io);
	1180	+
	1181	+ /* Update to the scsi host*/
	1182	+ can_queue = ccb_count - PM8001_RESERVE_SLOT;
	1183	+ shost->can_queue = can_queue;
	1184	+
	1185	+ pm8001_ha->tags = kzalloc(ccb_count, GFP_KERNEL);
	1186	+ if (!pm8001_ha->tags)
	1187	+ goto err_out;
	1188	+
	1189	+ /* Memory region for ccb_info*/
	1190	+ pm8001_ha->ccb_info = (struct pm8001_ccb_info *)
	1191	+ kcalloc(ccb_count, sizeof(struct pm8001_ccb_info), GFP_KERNEL);
	1192	+ if (!pm8001_ha->ccb_info) {
	1193	+ PM8001_FAIL_DBG(pm8001_ha, pm8001_printk
	1194	+ ("Unable to allocate memory for ccb\n"));
	1195	+ goto err_out_noccb;
	1196	+ }
	1197	+ for (i = 0; i < ccb_count; i++) {
	1198	+ pm8001_ha->ccb_info[i].buf_prd = pci_alloc_consistent(pdev,
	1199	+ sizeof(struct pm8001_prd) * PM8001_MAX_DMA_SG,
	1200	+ &pm8001_ha->ccb_info[i].ccb_dma_handle);
	1201	+ if (!pm8001_ha->ccb_info[i].buf_prd) {
	1202	+ PM8001_FAIL_DBG(pm8001_ha, pm8001_printk
	1203	+ ("pm80xx: ccb prd memory allocation error\n"));
	1204	+ goto err_out;
	1205	+ }
	1206	+ pm8001_ha->ccb_info[i].task = NULL;
	1207	+ pm8001_ha->ccb_info[i].ccb_tag = 0xffffffff;
	1208	+ pm8001_ha->ccb_info[i].device = NULL;
	1209	+ ++pm8001_ha->tags_num;
	1210	+ }
	1211	+ return 0;
	1212	+
	1213	+err_out_noccb:
	1214	+ kfree(pm8001_ha->devices);
	1215	+err_out:
	1216	+ return -ENOMEM;
	1217	+}
	1218	+
1140	1219	static void pm8001_pci_remove(struct pci_dev *pdev)
1141	1220	{
1142	1221	struct sas_ha_struct *sha = pci_get_drvdata(pdev);

drivers/scsi/pm8001/pm8001_sas.h+11−4

@@ -58,7 +58,7 @@ · 57 unmodified lines
58	58	#include "pm8001_defs.h"
59	59
60	60	#define DRV_NAME "pm80xx"
61		−#define DRV_VERSION "0.1.39"
	61	+#define DRV_VERSION "0.1.40"
62	62	#define PM8001_FAIL_LOGGING 0x01 /* Error message logging */
63	63	#define PM8001_INIT_LOGGING 0x02 /* driver init logging */
64	64	#define PM8001_DISC_LOGGING 0x04 /* discovery layer logging */
@@ -315,7 +315,7 @@ struct pm8001_ccb_info { · 250 unmodified lines
315	315	u32 ccb_tag;
316	316	dma_addr_t ccb_dma_handle;
317	317	struct pm8001_device *device;
318		− struct pm8001_prd buf_prd[PM8001_MAX_DMA_SG];
	318	+ struct pm8001_prd *buf_prd;
319	319	struct fw_control_ex *fw_control_context;
320	320	u8 open_retry;
321	321	};
@@ -468,6 +468,7 @@ struct inbound_queue_table { · 146 unmodified lines
468	468	u32 reserved;
469	469	__le32 consumer_index;
470	470	u32 producer_idx;
	471	+ spinlock_t iq_lock;
471	472	};
472	473	struct outbound_queue_table {
473	474	u32 element_size_cnt;
@@ -524,8 +525,8 @@ struct pm8001_hba_info { · 50 unmodified lines
524	525	void __iomem fatal_tbl_addr; /MPI IVT Table Addr */
525	526	union main_cfg_table main_cfg_tbl;
526	527	union general_status_table gs_tbl;
527		− struct inbound_queue_table inbnd_q_tbl[PM8001_MAX_SPCV_INB_NUM];
528		− struct outbound_queue_table outbnd_q_tbl[PM8001_MAX_SPCV_OUTB_NUM];
	528	+ struct inbound_queue_table inbnd_q_tbl[PM8001_MAX_INB_NUM];
	529	+ struct outbound_queue_table outbnd_q_tbl[PM8001_MAX_OUTB_NUM];
529	530	struct sas_phy_attribute_table phy_attr_table;
530	531	/* MPI SAS PHY attributes */
531	532	u8 sas_addr[SAS_ADDR_SIZE];
@@ -561,6 +562,12 @@ struct pm8001_hba_info { · 29 unmodified lines
561	562	u32 reset_in_progress;
562	563	u32 non_fatal_count;
563	564	u32 non_fatal_read_length;
	565	+ u32 max_q_num;
	566	+ u32 ib_offset;
	567	+ u32 ob_offset;
	568	+ u32 ci_offset;
	569	+ u32 pi_offset;
	570	+ u32 max_memcnt;
564	571	};
565	572
566	573	struct pm8001_work {

drivers/scsi/pm8001/pm80xx_hwi.c+56−53

@@ -720,7 +720,7 @@ static void read_inbnd_queue_table(struct pm8001_hba_info *pm8001_ha) · 719 unmodified lines
720	720	{
721	721	int i;
722	722	void __iomem *address = pm8001_ha->inbnd_q_tbl_addr;
723		− for (i = 0; i < PM8001_MAX_SPCV_INB_NUM; i++) {
	723	+ for (i = 0; i < PM8001_MAX_INB_NUM; i++) {
724	724	u32 offset = i * 0x20;
725	725	pm8001_ha->inbnd_q_tbl[i].pi_pci_bar =
726	726	get_pci_bar_index(pm8001_mr32(address,
@@ -738,7 +738,7 @@ static void read_outbnd_queue_table(struct pm8001_hba_info *pm8001_ha) · 11 unmodified lines
738	738	{
739	739	int i;
740	740	void __iomem *address = pm8001_ha->outbnd_q_tbl_addr;
741		− for (i = 0; i < PM8001_MAX_SPCV_OUTB_NUM; i++) {
	741	+ for (i = 0; i < PM8001_MAX_OUTB_NUM; i++) {
742	742	u32 offset = i * 0x24;
743	743	pm8001_ha->outbnd_q_tbl[i].ci_pci_bar =
744	744	get_pci_bar_index(pm8001_mr32(address,
@@ -758,6 +758,10 @@ static void init_default_table_values(struct pm8001_hba_info *pm8001_ha) · 13 unmodified lines
758	758	u32 offsetib, offsetob;
759	759	void __iomem *addressib = pm8001_ha->inbnd_q_tbl_addr;
760	760	void __iomem *addressob = pm8001_ha->outbnd_q_tbl_addr;
	761	+ u32 ib_offset = pm8001_ha->ib_offset;
	762	+ u32 ob_offset = pm8001_ha->ob_offset;
	763	+ u32 ci_offset = pm8001_ha->ci_offset;
	764	+ u32 pi_offset = pm8001_ha->pi_offset;
761	765
762	766	pm8001_ha->main_cfg_tbl.pm80xx_tbl.upper_event_log_addr =
763	767	pm8001_ha->memoryMap.region[AAP1].phys_addr_hi;
@@ -778,23 +782,23 @@ static void init_default_table_values(struct pm8001_hba_info *pm8001_ha) · 14 unmodified lines
778	782	/* Disable end to end CRC checking */
779	783	pm8001_ha->main_cfg_tbl.pm80xx_tbl.crc_core_dump = (0x1 << 16);
780	784
781		− for (i = 0; i < PM8001_MAX_SPCV_INB_NUM; i++) {
	785	+ for (i = 0; i < pm8001_ha->max_q_num; i++) {
782	786	pm8001_ha->inbnd_q_tbl[i].element_pri_size_cnt =
783	787	PM8001_MPI_QUEUE \| (pm8001_ha->iomb_size << 16) \| (0x00<<30);
784	788	pm8001_ha->inbnd_q_tbl[i].upper_base_addr =
785		− pm8001_ha->memoryMap.region[IB + i].phys_addr_hi;
	789	+ pm8001_ha->memoryMap.region[ib_offset + i].phys_addr_hi;
786	790	pm8001_ha->inbnd_q_tbl[i].lower_base_addr =
787		− pm8001_ha->memoryMap.region[IB + i].phys_addr_lo;
	791	+ pm8001_ha->memoryMap.region[ib_offset + i].phys_addr_lo;
788	792	pm8001_ha->inbnd_q_tbl[i].base_virt =
789		− (u8 *)pm8001_ha->memoryMap.region[IB + i].virt_ptr;
	793	+ (u8 *)pm8001_ha->memoryMap.region[ib_offset + i].virt_ptr;
790	794	pm8001_ha->inbnd_q_tbl[i].total_length =
791		− pm8001_ha->memoryMap.region[IB + i].total_len;
	795	+ pm8001_ha->memoryMap.region[ib_offset + i].total_len;
792	796	pm8001_ha->inbnd_q_tbl[i].ci_upper_base_addr =
793		− pm8001_ha->memoryMap.region[CI + i].phys_addr_hi;
	797	+ pm8001_ha->memoryMap.region[ci_offset + i].phys_addr_hi;
794	798	pm8001_ha->inbnd_q_tbl[i].ci_lower_base_addr =
795		− pm8001_ha->memoryMap.region[CI + i].phys_addr_lo;
	799	+ pm8001_ha->memoryMap.region[ci_offset + i].phys_addr_lo;
796	800	pm8001_ha->inbnd_q_tbl[i].ci_virt =
797		− pm8001_ha->memoryMap.region[CI + i].virt_ptr;
	801	+ pm8001_ha->memoryMap.region[ci_offset + i].virt_ptr;
798	802	offsetib = i * 0x20;
799	803	pm8001_ha->inbnd_q_tbl[i].pi_pci_bar =
800	804	get_pci_bar_index(pm8001_mr32(addressib,
@@ -809,25 +813,25 @@ static void init_default_table_values(struct pm8001_hba_info *pm8001_ha) · 8 unmodified lines
809	813	pm8001_ha->inbnd_q_tbl[i].pi_pci_bar,
810	814	pm8001_ha->inbnd_q_tbl[i].pi_offset));
811	815	}
812		− for (i = 0; i < PM8001_MAX_SPCV_OUTB_NUM; i++) {
	816	+ for (i = 0; i < pm8001_ha->max_q_num; i++) {
813	817	pm8001_ha->outbnd_q_tbl[i].element_size_cnt =
814	818	PM8001_MPI_QUEUE \| (pm8001_ha->iomb_size << 16) \| (0x01<<30);
815	819	pm8001_ha->outbnd_q_tbl[i].upper_base_addr =
816		− pm8001_ha->memoryMap.region[OB + i].phys_addr_hi;
	820	+ pm8001_ha->memoryMap.region[ob_offset + i].phys_addr_hi;
817	821	pm8001_ha->outbnd_q_tbl[i].lower_base_addr =
818		− pm8001_ha->memoryMap.region[OB + i].phys_addr_lo;
	822	+ pm8001_ha->memoryMap.region[ob_offset + i].phys_addr_lo;
819	823	pm8001_ha->outbnd_q_tbl[i].base_virt =
820		− (u8 *)pm8001_ha->memoryMap.region[OB + i].virt_ptr;
	824	+ (u8 *)pm8001_ha->memoryMap.region[ob_offset + i].virt_ptr;
821	825	pm8001_ha->outbnd_q_tbl[i].total_length =
822		− pm8001_ha->memoryMap.region[OB + i].total_len;
	826	+ pm8001_ha->memoryMap.region[ob_offset + i].total_len;
823	827	pm8001_ha->outbnd_q_tbl[i].pi_upper_base_addr =
824		− pm8001_ha->memoryMap.region[PI + i].phys_addr_hi;
	828	+ pm8001_ha->memoryMap.region[pi_offset + i].phys_addr_hi;
825	829	pm8001_ha->outbnd_q_tbl[i].pi_lower_base_addr =
826		− pm8001_ha->memoryMap.region[PI + i].phys_addr_lo;
	830	+ pm8001_ha->memoryMap.region[pi_offset + i].phys_addr_lo;
827	831	/* interrupt vector based on oq */
828	832	pm8001_ha->outbnd_q_tbl[i].interrup_vec_cnt_delay = (i << 24);
829	833	pm8001_ha->outbnd_q_tbl[i].pi_virt =
830		− pm8001_ha->memoryMap.region[PI + i].virt_ptr;
	834	+ pm8001_ha->memoryMap.region[pi_offset + i].virt_ptr;
831	835	offsetob = i * 0x24;
832	836	pm8001_ha->outbnd_q_tbl[i].ci_pci_bar =
833	837	get_pci_bar_index(pm8001_mr32(addressob,
@@ -871,7 +875,7 @@ static void update_main_config_table(struct pm8001_hba_info *pm8001_ha) · 37 unmodified lines
871	875	pm8001_ha->main_cfg_tbl.pm80xx_tbl.pcs_event_log_severity);
872	876	/* Update Fatal error interrupt vector */
873	877	pm8001_ha->main_cfg_tbl.pm80xx_tbl.fatal_err_interrupt \|=
874		− ((pm8001_ha->number_of_intr - 1) << 8);
	878	+ ((pm8001_ha->max_q_num - 1) << 8);
875	879	pm8001_mw32(address, MAIN_FATAL_ERROR_INTERRUPT,
876	880	pm8001_ha->main_cfg_tbl.pm80xx_tbl.fatal_err_interrupt);
877	881	PM8001_DEV_DBG(pm8001_ha, pm8001_printk(
@@ -1010,8 +1014,12 @@ static int mpi_init_check(struct pm8001_hba_info *pm8001_ha) · 132 unmodified lines
1010	1014	value &= SPCv_MSGU_CFG_TABLE_UPDATE;
1011	1015	} while ((value != 0) && (--max_wait_count));
1012	1016
1013		− if (!max_wait_count)
1014		− return -1;
	1017	+ if (!max_wait_count) {
	1018	+ /* additional check */
	1019	+ PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
	1020	+ "Inb doorbell clear not toggled[value:%x]\n", value));
	1021	+ return -EBUSY;
	1022	+ }
1015	1023	/* check the MPI-State for initialization upto 100ms*/
1016	1024	max_wait_count = 100 * 1000;/* 100 msec */
1017	1025	do {
@@ -1022,12 +1030,12 @@ static int mpi_init_check(struct pm8001_hba_info *pm8001_ha) · 4 unmodified lines
1022	1030	} while ((GST_MPI_STATE_INIT !=
1023	1031	(gst_len_mpistate & GST_MPI_STATE_MASK)) && (--max_wait_count));
1024	1032	if (!max_wait_count)
1025		− return -1;
	1033	+ return -EBUSY;
1026	1034
1027	1035	/* check MPI Initialization error */
1028	1036	gst_len_mpistate = gst_len_mpistate >> 16;
1029	1037	if (0x0000 != gst_len_mpistate)
1030		− return -1;
	1038	+ return -EBUSY;
1031	1039
1032	1040	return 0;
1033	1041	}
@@ -1469,11 +1477,10 @@ static int pm80xx_chip_init(struct pm8001_hba_info *pm8001_ha) · 435 unmodified lines
1469	1477
1470	1478	/* update main config table ,inbound table and outbound table */
1471	1479	update_main_config_table(pm8001_ha);
1472		− for (i = 0; i < PM8001_MAX_SPCV_INB_NUM; i++)
	1480	+ for (i = 0; i < pm8001_ha->max_q_num; i++) {
1473	1481	update_inbnd_queue_table(pm8001_ha, i);
1474		− for (i = 0; i < PM8001_MAX_SPCV_OUTB_NUM; i++)
1475	1482	update_outbnd_queue_table(pm8001_ha, i);
1476		−
	1483	+ }
1477	1484	/* notify firmware update finished and check initialization status */
1478	1485	if (0 == mpi_init_check(pm8001_ha)) {
1479	1486	PM8001_INIT_DBG(pm8001_ha,
@@ -4191,7 +4198,7 @@ static int process_oq(struct pm8001_hba_info *pm8001_ha, u8 vec) · 2711 unmodified lines
4191	4198	unsigned long flags;
4192	4199	u32 regval;
4193	4200
4194		− if (vec == (pm8001_ha->number_of_intr - 1)) {
	4201	+ if (vec == (pm8001_ha->max_q_num - 1)) {
4195	4202	regval = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1);
4196	4203	if ((regval & SCRATCH_PAD_MIPSALL_READY) !=
4197	4204	SCRATCH_PAD_MIPSALL_READY) {
@@ -4274,6 +4281,7 @@ static int pm80xx_chip_smp_req(struct pm8001_hba_info *pm8001_ha, · 76 unmodified lines
4274	4281	char *preq_dma_addr = NULL;
4275	4282	__le64 tmp_addr;
4276	4283	u32 i, length;
	4284	+ unsigned long flags;
4277	4285
4278	4286	memset(&smp_cmd, 0, sizeof(smp_cmd));
4279	4287	/*
@@ -4369,8 +4377,10 @@ static int pm80xx_chip_smp_req(struct pm8001_hba_info *pm8001_ha, · 89 unmodified lines
4369	4377
4370	4378	build_smp_cmd(pm8001_dev->device_id, smp_cmd.tag,
4371	4379	&smp_cmd, pm8001_ha->smp_exp_mode, length);
	4380	+ spin_lock_irqsave(&circularQ->iq_lock, flags);
4372	4381	rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &smp_cmd,
4373	4382	sizeof(smp_cmd), 0);
	4383	+ spin_unlock_irqrestore(&circularQ->iq_lock, flags);
4374	4384	if (rc)
4375	4385	goto err_out_2;
4376	4386	return 0;
@@ -4434,7 +4444,8 @@ static int pm80xx_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha, · 57 unmodified lines
4434	4444	u64 phys_addr, start_addr, end_addr;
4435	4445	u32 end_addr_high, end_addr_low;
4436	4446	struct inbound_queue_table *circularQ;
4437		− u32 q_index;
	4447	+ unsigned long flags;
	4448	+ u32 q_index, cpu_id;
4438	4449	u32 opc = OPC_INB_SSPINIIOSTART;
4439	4450	memset(&ssp_cmd, 0, sizeof(ssp_cmd));
4440	4451	memcpy(ssp_cmd.ssp_iu.lun, task->ssp_task.LUN, 8);
@@ -4453,7 +4464,8 @@ static int pm80xx_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha, · 12 unmodified lines
4453	4464	ssp_cmd.ssp_iu.efb_prio_attr \|= (task->ssp_task.task_attr & 7);
4454	4465	memcpy(ssp_cmd.ssp_iu.cdb, task->ssp_task.cmd->cmnd,
4455	4466	task->ssp_task.cmd->cmd_len);
4456		− q_index = (u32) (pm8001_dev->id & 0x00ffffff) % PM8001_MAX_INB_NUM;
	4467	+ cpu_id = smp_processor_id();
	4468	+ q_index = (u32) (cpu_id) % (pm8001_ha->max_q_num);
4457	4469	circularQ = &pm8001_ha->inbnd_q_tbl[q_index];
4458	4470
4459	4471	/* Check if encryption is set */
@@ -4471,8 +4483,7 @@ static int pm80xx_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha, · 11 unmodified lines
4471	4483	if (task->num_scatter > 1) {
4472	4484	pm8001_chip_make_sg(task->scatter,
4473	4485	ccb->n_elem, ccb->buf_prd);
4474		− phys_addr = ccb->ccb_dma_handle +
4475		− offsetof(struct pm8001_ccb_info, buf_prd[0]);
	4486	+ phys_addr = ccb->ccb_dma_handle;
4476	4487	ssp_cmd.enc_addr_low =
4477	4488	cpu_to_le32(lower_32_bits(phys_addr));
4478	4489	ssp_cmd.enc_addr_high =
@@ -4501,9 +4512,7 @@ static int pm80xx_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha, · 22 unmodified lines
4501	4512	end_addr_high, end_addr_low));
4502	4513	pm8001_chip_make_sg(task->scatter, 1,
4503	4514	ccb->buf_prd);
4504		− phys_addr = ccb->ccb_dma_handle +
4505		− offsetof(struct pm8001_ccb_info,
4506		− buf_prd[0]);
	4515	+ phys_addr = ccb->ccb_dma_handle;
4507	4516	ssp_cmd.enc_addr_low =
4508	4517	cpu_to_le32(lower_32_bits(phys_addr));
4509	4518	ssp_cmd.enc_addr_high =
@@ -4531,8 +4540,7 @@ static int pm80xx_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha, · 21 unmodified lines
4531	4540	if (task->num_scatter > 1) {
4532	4541	pm8001_chip_make_sg(task->scatter, ccb->n_elem,
4533	4542	ccb->buf_prd);
4534		− phys_addr = ccb->ccb_dma_handle +
4535		− offsetof(struct pm8001_ccb_info, buf_prd[0]);
	4543	+ phys_addr = ccb->ccb_dma_handle;
4536	4544	ssp_cmd.addr_low =
4537	4545	cpu_to_le32(lower_32_bits(phys_addr));
4538	4546	ssp_cmd.addr_high =
@@ -4560,9 +4568,7 @@ static int pm80xx_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha, · 21 unmodified lines
4560	4568	end_addr_high, end_addr_low));
4561	4569	pm8001_chip_make_sg(task->scatter, 1,
4562	4570	ccb->buf_prd);
4563		− phys_addr = ccb->ccb_dma_handle +
4564		− offsetof(struct pm8001_ccb_info,
4565		− buf_prd[0]);
	4571	+ phys_addr = ccb->ccb_dma_handle;
4566	4572	ssp_cmd.addr_low =
4567	4573	cpu_to_le32(lower_32_bits(phys_addr));
4568	4574	ssp_cmd.addr_high =
@@ -4576,9 +4582,10 @@ static int pm80xx_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha, · 7 unmodified lines
4576	4582	ssp_cmd.esgl = 0;
4577	4583	}
4578	4584	}
4579		− q_index = (u32) (pm8001_dev->id & 0x00ffffff) % PM8001_MAX_OUTB_NUM;
	4585	+ spin_lock_irqsave(&circularQ->iq_lock, flags);
4580	4586	ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc,
4581	4587	&ssp_cmd, sizeof(ssp_cmd), q_index);
	4588	+ spin_unlock_irqrestore(&circularQ->iq_lock, flags);
4582	4589	return ret;
4583	4590	}
4584	4591
@@ -4590,7 +4597,7 @@ static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha, · 5 unmodified lines
4590	4597	struct pm8001_device *pm8001_ha_dev = dev->lldd_dev;
4591	4598	u32 tag = ccb->ccb_tag;
4592	4599	int ret;
4593		− u32 q_index;
	4600	+ u32 q_index, cpu_id;
4594	4601	struct sata_start_req sata_cmd;
4595	4602	u32 hdr_tag, ncg_tag = 0;
4596	4603	u64 phys_addr, start_addr, end_addr;
@@ -4601,7 +4608,8 @@ static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha, · 4 unmodified lines
4601	4608	unsigned long flags;
4602	4609	u32 opc = OPC_INB_SATA_HOST_OPSTART;
4603	4610	memset(&sata_cmd, 0, sizeof(sata_cmd));
4604		− q_index = (u32) (pm8001_ha_dev->id & 0x00ffffff) % PM8001_MAX_INB_NUM;
	4611	+ cpu_id = smp_processor_id();
	4612	+ q_index = (u32) (cpu_id) % (pm8001_ha->max_q_num);
4605	4613	circularQ = &pm8001_ha->inbnd_q_tbl[q_index];
4606	4614
4607	4615	if (task->data_dir == DMA_NONE) {
@@ -4652,8 +4660,7 @@ static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha, · 44 unmodified lines
4652	4660	if (task->num_scatter > 1) {
4653	4661	pm8001_chip_make_sg(task->scatter,
4654	4662	ccb->n_elem, ccb->buf_prd);
4655		− phys_addr = ccb->ccb_dma_handle +
4656		− offsetof(struct pm8001_ccb_info, buf_prd[0]);
	4663	+ phys_addr = ccb->ccb_dma_handle;
4657	4664	sata_cmd.enc_addr_low = lower_32_bits(phys_addr);
4658	4665	sata_cmd.enc_addr_high = upper_32_bits(phys_addr);
4659	4666	sata_cmd.enc_esgl = cpu_to_le32(1 << 31);
@@ -4678,9 +4685,7 @@ static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha, · 18 unmodified lines
4678	4685	end_addr_high, end_addr_low));
4679	4686	pm8001_chip_make_sg(task->scatter, 1,
4680	4687	ccb->buf_prd);
4681		− phys_addr = ccb->ccb_dma_handle +
4682		− offsetof(struct pm8001_ccb_info,
4683		− buf_prd[0]);
	4688	+ phys_addr = ccb->ccb_dma_handle;
4684	4689	sata_cmd.enc_addr_low =
4685	4690	lower_32_bits(phys_addr);
4686	4691	sata_cmd.enc_addr_high =
@@ -4718,8 +4723,7 @@ static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha, · 31 unmodified lines
4718	4723	if (task->num_scatter > 1) {
4719	4724	pm8001_chip_make_sg(task->scatter,
4720	4725	ccb->n_elem, ccb->buf_prd);
4721		− phys_addr = ccb->ccb_dma_handle +
4722		− offsetof(struct pm8001_ccb_info, buf_prd[0]);
	4726	+ phys_addr = ccb->ccb_dma_handle;
4723	4727	sata_cmd.addr_low = lower_32_bits(phys_addr);
4724	4728	sata_cmd.addr_high = upper_32_bits(phys_addr);
4725	4729	sata_cmd.esgl = cpu_to_le32(1 << 31);
@@ -4744,9 +4748,7 @@ static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha, · 18 unmodified lines
4744	4748	end_addr_high, end_addr_low));
4745	4749	pm8001_chip_make_sg(task->scatter, 1,
4746	4750	ccb->buf_prd);
4747		− phys_addr = ccb->ccb_dma_handle +
4748		− offsetof(struct pm8001_ccb_info,
4749		− buf_prd[0]);
	4751	+ phys_addr = ccb->ccb_dma_handle;
4750	4752	sata_cmd.addr_low =
4751	4753	lower_32_bits(phys_addr);
4752	4754	sata_cmd.addr_high =
@@ -4817,9 +4819,10 @@ static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha, · 64 unmodified lines
4817	4819	}
4818	4820	}
4819	4821	}
4820		− q_index = (u32) (pm8001_ha_dev->id & 0x00ffffff) % PM8001_MAX_OUTB_NUM;
	4822	+ spin_lock_irqsave(&circularQ->iq_lock, flags);
4821	4823	ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc,
4822	4824	&sata_cmd, sizeof(sata_cmd), q_index);
	4825	+ spin_unlock_irqrestore(&circularQ->iq_lock, flags);
4823	4826	return ret;
4824	4827	}
4825	4828

drivers/scsi/qla2xxx/qla_dfs.c+8−60

@@ -170,20 +170,7 @@ qla2x00_dfs_tgt_sess_show(struct seq_file s, void unused) · 169 unmodified lines
170	170	return 0;
171	171	}
172	172
173		−static int
174		−qla2x00_dfs_tgt_sess_open(struct inode inode, struct file file)
175		−{
176		− scsi_qla_host_t *vha = inode->i_private;
177		−
178		− return single_open(file, qla2x00_dfs_tgt_sess_show, vha);
179		−}
180		−
181		−static const struct file_operations dfs_tgt_sess_ops = {
182		− .open = qla2x00_dfs_tgt_sess_open,
183		− .read = seq_read,
184		− .llseek = seq_lseek,
185		− .release = single_release,
186		−};
	173	+DEFINE_SHOW_ATTRIBUTE(qla2x00_dfs_tgt_sess);
187	174
188	175	static int
189	176	qla2x00_dfs_tgt_port_database_show(struct seq_file s, void unused)
@@ -239,20 +226,7 @@ out_free_id_list: · 49 unmodified lines
239	226	return 0;
240	227	}
241	228
242		−static int
243		−qla2x00_dfs_tgt_port_database_open(struct inode inode, struct file file)
244		−{
245		− scsi_qla_host_t *vha = inode->i_private;
246		−
247		− return single_open(file, qla2x00_dfs_tgt_port_database_show, vha);
248		−}
249		−
250		−static const struct file_operations dfs_tgt_port_database_ops = {
251		− .open = qla2x00_dfs_tgt_port_database_open,
252		− .read = seq_read,
253		− .llseek = seq_lseek,
254		− .release = single_release,
255		−};
	229	+DEFINE_SHOW_ATTRIBUTE(qla2x00_dfs_tgt_port_database);
256	230
257	231	static int
258	232	qla_dfs_fw_resource_cnt_show(struct seq_file s, void unused)
@@ -301,20 +275,7 @@ qla_dfs_fw_resource_cnt_show(struct seq_file s, void unused) · 42 unmodified lines
301	275	return 0;
302	276	}
303	277
304		−static int
305		−qla_dfs_fw_resource_cnt_open(struct inode inode, struct file file)
306		−{
307		− struct scsi_qla_host *vha = inode->i_private;
308		−
309		− return single_open(file, qla_dfs_fw_resource_cnt_show, vha);
310		−}
311		−
312		−static const struct file_operations dfs_fw_resource_cnt_ops = {
313		− .open = qla_dfs_fw_resource_cnt_open,
314		− .read = seq_read,
315		− .llseek = seq_lseek,
316		− .release = single_release,
317		−};
	278	+DEFINE_SHOW_ATTRIBUTE(qla_dfs_fw_resource_cnt);
318	279
319	280	static int
320	281	qla_dfs_tgt_counters_show(struct seq_file s, void unused)
@@ -391,20 +352,7 @@ qla_dfs_tgt_counters_show(struct seq_file s, void unused) · 70 unmodified lines
391	352	return 0;
392	353	}
393	354
394		−static int
395		−qla_dfs_tgt_counters_open(struct inode inode, struct file file)
396		−{
397		− struct scsi_qla_host *vha = inode->i_private;
398		−
399		− return single_open(file, qla_dfs_tgt_counters_show, vha);
400		−}
401		−
402		−static const struct file_operations dfs_tgt_counters_ops = {
403		− .open = qla_dfs_tgt_counters_open,
404		− .read = seq_read,
405		− .llseek = seq_lseek,
406		− .release = single_release,
407		−};
	355	+DEFINE_SHOW_ATTRIBUTE(qla_dfs_tgt_counters);
408	356
409	357	static int
410	358	qla2x00_dfs_fce_show(struct seq_file s, void unused)
@@ -606,19 +554,19 @@ create_dir: · 195 unmodified lines
606	554
607	555	create_nodes:
608	556	ha->dfs_fw_resource_cnt = debugfs_create_file("fw_resource_count",
609		− S_IRUSR, ha->dfs_dir, vha, &dfs_fw_resource_cnt_ops);
	557	+ S_IRUSR, ha->dfs_dir, vha, &qla_dfs_fw_resource_cnt_fops);
610	558
611	559	ha->dfs_tgt_counters = debugfs_create_file("tgt_counters", S_IRUSR,
612		− ha->dfs_dir, vha, &dfs_tgt_counters_ops);
	560	+ ha->dfs_dir, vha, &qla_dfs_tgt_counters_fops);
613	561
614	562	ha->tgt.dfs_tgt_port_database = debugfs_create_file("tgt_port_database",
615		− S_IRUSR, ha->dfs_dir, vha, &dfs_tgt_port_database_ops);
	563	+ S_IRUSR, ha->dfs_dir, vha, &qla2x00_dfs_tgt_port_database_fops);
616	564
617	565	ha->dfs_fce = debugfs_create_file("fce", S_IRUSR, ha->dfs_dir, vha,
618	566	&dfs_fce_ops);
619	567
620	568	ha->tgt.dfs_tgt_sess = debugfs_create_file("tgt_sess",
621		− S_IRUSR, ha->dfs_dir, vha, &dfs_tgt_sess_ops);
	569	+ S_IRUSR, ha->dfs_dir, vha, &qla2x00_dfs_tgt_sess_fops);
622	570
623	571	if (IS_QLA27XX(ha) \|\| IS_QLA83XX(ha) \|\| IS_QLA28XX(ha)) {
624	572	ha->tgt.dfs_naqp = debugfs_create_file("naqp",

drivers/scsi/qla2xxx/qla_isr.c+15−27

@@ -1838,6 +1838,7 @@ qla24xx_mbx_iocb_entry(scsi_qla_host_t vha, struct req_que req, · 1837 unmodified lines
1838	1838	struct mbx_24xx_entry *pkt)
1839	1839	{
1840	1840	const char func[] = "MBX-IOCB2";
	1841	+ struct qla_hw_data *ha = vha->hw;
1841	1842	srb_t *sp;
1842	1843	struct srb_iocb *si;
1843	1844	u16 sz, i;
@@ -1847,6 +1848,18 @@ qla24xx_mbx_iocb_entry(scsi_qla_host_t vha, struct req_que req, · 3 unmodified lines
1847	1848	if (!sp)
1848	1849	return;
1849	1850
	1851	+ if (sp->type == SRB_SCSI_CMD \|\|
	1852	+ sp->type == SRB_NVME_CMD \|\|
	1853	+ sp->type == SRB_TM_CMD) {
	1854	+ ql_log(ql_log_warn, vha, 0x509d,
	1855	+ "Inconsistent event entry type %d\n", sp->type);
	1856	+ if (IS_P3P_TYPE(ha))
	1857	+ set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
	1858	+ else
	1859	+ set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
	1860	+ return;
	1861	+ }
	1862	+
1850	1863	si = &sp->u.iocb_cmd;
1851	1864	sz = min(ARRAY_SIZE(pkt->mb), ARRAY_SIZE(sp->u.iocb_cmd.u.mbx.in_mb));
1852	1865
@@ -3399,32 +3412,6 @@ void qla24xx_nvme_ls4_iocb(struct scsi_qla_host *vha, · 1546 unmodified lines
3399	3412	sp->done(sp, comp_status);
3400	3413	}
3401	3414
3402		−static void qla24xx_process_mbx_iocb_response(struct scsi_qla_host *vha,
3403		− struct rsp_que rsp, struct sts_entry_24xx pkt)
3404		−{
3405		− struct qla_hw_data *ha = vha->hw;
3406		− srb_t *sp;
3407		− static const char func[] = "MBX-IOCB2";
3408		−
3409		− sp = qla2x00_get_sp_from_handle(vha, func, rsp->req, pkt);
3410		− if (!sp)
3411		− return;
3412		−
3413		− if (sp->type == SRB_SCSI_CMD \|\|
3414		− sp->type == SRB_NVME_CMD \|\|
3415		− sp->type == SRB_TM_CMD) {
3416		− ql_log(ql_log_warn, vha, 0x509d,
3417		− "Inconsistent event entry type %d\n", sp->type);
3418		− if (IS_P3P_TYPE(ha))
3419		− set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
3420		− else
3421		− set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
3422		− return;
3423		− }
3424		−
3425		− qla24xx_mbx_iocb_entry(vha, rsp->req, (struct mbx_24xx_entry *)pkt);
3426		−}
3427		−
3428	3415	/**
3429	3416	* qla24xx_process_response_queue() - Process response queue entries.
3430	3417	* @vha: SCSI driver HA context
@@ -3534,7 +3521,8 @@ process_err: · 103 unmodified lines
3534	3521	(struct abort_entry_24xx *)pkt);
3535	3522	break;
3536	3523	case MBX_IOCB_TYPE:
3537		− qla24xx_process_mbx_iocb_response(vha, rsp, pkt);
	3524	+ qla24xx_mbx_iocb_entry(vha, rsp->req,
	3525	+ (struct mbx_24xx_entry *)pkt);
3538	3526	break;
3539	3527	case VP_CTRL_IOCB_TYPE:
3540	3528	qla_ctrlvp_completed(vha, rsp->req,

drivers/scsi/qla2xxx/qla_nvme.c+4−4

@@ -541,7 +541,7 @@ static int qla_nvme_post_cmd(struct nvme_fc_local_port *lport, · 540 unmodified lines
541	541	fc_port_t *fcport;
542	542	struct srb_iocb *nvme;
543	543	struct scsi_qla_host *vha;
544		− int rval = -ENODEV;
	544	+ int rval;
545	545	srb_t *sp;
546	546	struct qla_qpair *qpair = hw_queue_handle;
547	547	struct nvme_private *priv = fd->private;
@@ -549,19 +549,19 @@ static int qla_nvme_post_cmd(struct nvme_fc_local_port *lport, · 1 unmodified line
549	549
550	550	if (!priv) {
551	551	/* nvme association has been torn down */
552		− return rval;
	552	+ return -ENODEV;
553	553	}
554	554
555	555	fcport = qla_rport->fcport;
556	556
557	557	if (!qpair \|\| !fcport \|\| (qpair && !qpair->fw_started) \|\|
558	558	(fcport && fcport->deleted))
559		− return rval;
	559	+ return -ENODEV;
560	560
561	561	vha = fcport->vha;
562	562
563	563	if (!(fcport->nvme_flag & NVME_FLAG_REGISTERED))
564		− return rval;
	564	+ return -ENODEV;
565	565
566	566	if (test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) \|\|
567	567	(qpair && !qpair->fw_started) \|\| fcport->deleted)

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

@@ -659,7 +659,7 @@ static int · 658 unmodified lines
659	659	qla8044_poll_reg(struct scsi_qla_host *vha, uint32_t addr,
660	660	int duration, uint32_t test_mask, uint32_t test_result)
661	661	{
662		− uint32_t value;
	662	+ uint32_t value = 0;
663	663	int timeout_error;
664	664	uint8_t retries;
665	665	int ret_val = QLA_SUCCESS;

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

@@ -3225,7 +3225,7 @@ static void qla4_8xxx_uevent_emit(struct scsi_qla_host *ha, u32 code) · 3224 unmodified lines
3225	3225
3226	3226	switch (code) {
3227	3227	case QL4_UEVENT_CODE_FW_DUMP:
3228		− snprintf(event_string, sizeof(event_string), "FW_DUMP=%ld",
	3228	+ snprintf(event_string, sizeof(event_string), "FW_DUMP=%lu",
3229	3229	ha->host_no);
3230	3230	break;
3231	3231	default:

drivers/scsi/scsi_lib.c+35−73

@@ -293,21 +293,6 @@ int __scsi_execute(struct scsi_device sdev, const unsigned char cmd, · 292 unmodified lines
293	293	}
294	294	EXPORT_SYMBOL(__scsi_execute);
295	295
296		−/**
297		− * scsi_init_cmd_errh - Initialize cmd fields related to error handling.
298		− * @cmd: command that is ready to be queued.
299		− *
300		− * This function has the job of initializing a number of fields related to error
301		− * handling. Typically this will be called once for each command, as required.
302		− */
303		−static void scsi_init_cmd_errh(struct scsi_cmnd *cmd)
304		−{
305		− scsi_set_resid(cmd, 0);
306		− memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
307		− if (cmd->cmd_len == 0)
308		− cmd->cmd_len = scsi_command_size(cmd->cmnd);
309		−}
310		−
311	296	/*
312	297	* Wake up the error handler if necessary. Avoid as follows that the error
313	298	* handler is not woken up if host in-flight requests number ==
@@ -530,7 +515,7 @@ static void scsi_uninit_cmd(struct scsi_cmnd *cmd) · 216 unmodified lines
530	515	}
531	516	}
532	517
533		−static void scsi_free_sgtables(struct scsi_cmnd *cmd)
	518	+void scsi_free_sgtables(struct scsi_cmnd *cmd)
534	519	{
535	520	if (cmd->sdb.table.nents)
536	521	sg_free_table_chained(&cmd->sdb.table,
@@ -539,6 +524,7 @@ static void scsi_free_sgtables(struct scsi_cmnd *cmd) · 2 unmodified lines
539	524	sg_free_table_chained(&cmd->prot_sdb->table,
540	525	SCSI_INLINE_PROT_SG_CNT);
541	526	}
	527	+EXPORT_SYMBOL_GPL(scsi_free_sgtables);
542	528
543	529	static void scsi_mq_uninit_cmd(struct scsi_cmnd *cmd)
544	530	{
@@ -998,7 +984,7 @@ static inline bool scsi_cmd_needs_dma_drain(struct scsi_device *sdev, · 453 unmodified lines
998	984	}
999	985
1000	986	/**
1001		− * scsi_init_io - SCSI I/O initialization function.
	987	+ * scsi_alloc_sgtables - allocate S/G tables for a command
1002	988	* @cmd: command descriptor we wish to initialize
1003	989	*
1004	990	* Returns:
@@ -1006,7 +992,7 @@ static inline bool scsi_cmd_needs_dma_drain(struct scsi_device *sdev, · 1 unmodified line
1006	992	* * BLK_STS_RESOURCE - if the failure is retryable
1007	993	* * BLK_STS_IOERR - if the failure is fatal
1008	994	*/
1009		−blk_status_t scsi_init_io(struct scsi_cmnd *cmd)
	995	+blk_status_t scsi_alloc_sgtables(struct scsi_cmnd *cmd)
1010	996	{
1011	997	struct scsi_device *sdev = cmd->device;
1012	998	struct request *rq = cmd->request;
@@ -1098,7 +1084,7 @@ out_free_sgtables: · 85 unmodified lines
1098	1084	scsi_free_sgtables(cmd);
1099	1085	return ret;
1100	1086	}
1101		−EXPORT_SYMBOL(scsi_init_io);
	1087	+EXPORT_SYMBOL(scsi_alloc_sgtables);
1102	1088
1103	1089	/**
1104	1090	* scsi_initialize_rq - initialize struct scsi_cmnd partially
@@ -1186,7 +1172,7 @@ static blk_status_t scsi_setup_scsi_cmnd(struct scsi_device *sdev, · 81 unmodified lines
1186	1172	* submit a request without an attached bio.
1187	1173	*/
1188	1174	if (req->bio) {
1189		− blk_status_t ret = scsi_init_io(cmd);
	1175	+ blk_status_t ret = scsi_alloc_sgtables(cmd);
1190	1176	if (unlikely(ret != BLK_STS_OK))
1191	1177	return ret;
1192	1178	} else {
@@ -1196,58 +1182,16 @@ static blk_status_t scsi_setup_scsi_cmnd(struct scsi_device *sdev, · 3 unmodified lines
1196	1182	}
1197	1183
1198	1184	cmd->cmd_len = scsi_req(req)->cmd_len;
	1185	+ if (cmd->cmd_len == 0)
	1186	+ cmd->cmd_len = scsi_command_size(cmd->cmnd);
1199	1187	cmd->cmnd = scsi_req(req)->cmd;
1200	1188	cmd->transfersize = blk_rq_bytes(req);
1201	1189	cmd->allowed = scsi_req(req)->retries;
1202	1190	return BLK_STS_OK;
1203	1191	}
1204	1192
1205		−/*
1206		− * Setup a normal block command. These are simple request from filesystems
1207		− * that still need to be translated to SCSI CDBs from the ULD.
1208		− */
1209		−static blk_status_t scsi_setup_fs_cmnd(struct scsi_device *sdev,
1210		− struct request *req)
1211		−{
1212		− struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
1213		−
1214		− if (unlikely(sdev->handler && sdev->handler->prep_fn)) {
1215		− blk_status_t ret = sdev->handler->prep_fn(sdev, req);
1216		− if (ret != BLK_STS_OK)
1217		− return ret;
1218		− }
1219		−
1220		− cmd->cmnd = scsi_req(req)->cmd = scsi_req(req)->__cmd;
1221		− memset(cmd->cmnd, 0, BLK_MAX_CDB);
1222		− return scsi_cmd_to_driver(cmd)->init_command(cmd);
1223		−}
1224		−
1225		−static blk_status_t scsi_setup_cmnd(struct scsi_device *sdev,
1226		− struct request *req)
1227		−{
1228		− struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
1229		− blk_status_t ret;
1230		−
1231		− if (!blk_rq_bytes(req))
1232		− cmd->sc_data_direction = DMA_NONE;
1233		− else if (rq_data_dir(req) == WRITE)
1234		− cmd->sc_data_direction = DMA_TO_DEVICE;
1235		− else
1236		− cmd->sc_data_direction = DMA_FROM_DEVICE;
1237		−
1238		− if (blk_rq_is_scsi(req))
1239		− ret = scsi_setup_scsi_cmnd(sdev, req);
1240		− else
1241		− ret = scsi_setup_fs_cmnd(sdev, req);
1242		−
1243		− if (ret != BLK_STS_OK)
1244		− scsi_free_sgtables(cmd);
1245		−
1246		− return ret;
1247		−}
1248		−
1249	1193	static blk_status_t
1250		−scsi_prep_state_check(struct scsi_device sdev, struct request req)
	1194	+scsi_device_state_check(struct scsi_device sdev, struct request req)
1251	1195	{
1252	1196	switch (sdev->sdev_state) {
1253	1197	case SDEV_OFFLINE:
@@ -1589,7 +1533,7 @@ static unsigned int scsi_mq_inline_sgl_size(struct Scsi_Host *shost) · 335 unmodified lines
1589	1533	sizeof(struct scatterlist);
1590	1534	}
1591	1535
1592		−static blk_status_t scsi_mq_prep_fn(struct request *req)
	1536	+static blk_status_t scsi_prepare_cmd(struct request *req)
1593	1537	{
1594	1538	struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
1595	1539	struct scsi_device *sdev = req->q->queuedata;
@@ -1601,6 +1545,10 @@ static blk_status_t scsi_mq_prep_fn(struct request *req) · 5 unmodified lines
1601	1545	cmd->request = req;
1602	1546	cmd->tag = req->tag;
1603	1547	cmd->prot_op = SCSI_PROT_NORMAL;
	1548	+ if (blk_rq_bytes(req))
	1549	+ cmd->sc_data_direction = rq_dma_dir(req);
	1550	+ else
	1551	+ cmd->sc_data_direction = DMA_NONE;
1604	1552
1605	1553	sg = (void *)cmd + sizeof(struct scsi_cmnd) + shost->hostt->cmd_size;
1606	1554	cmd->sdb.table.sgl = sg;
@@ -1612,9 +1560,23 @@ static blk_status_t scsi_mq_prep_fn(struct request *req) · 5 unmodified lines
1612	1560	(struct scatterlist *)(cmd->prot_sdb + 1);
1613	1561	}
1614	1562
1615		− blk_mq_start_request(req);
	1563	+ /*
	1564	+ * Special handling for passthrough commands, which don't go to the ULP
	1565	+ * at all:
	1566	+ */
	1567	+ if (blk_rq_is_scsi(req))
	1568	+ return scsi_setup_scsi_cmnd(sdev, req);
	1569	+
	1570	+ if (sdev->handler && sdev->handler->prep_fn) {
	1571	+ blk_status_t ret = sdev->handler->prep_fn(sdev, req);
1616	1572
1617		− return scsi_setup_cmnd(sdev, req);
	1573	+ if (ret != BLK_STS_OK)
	1574	+ return ret;
	1575	+ }
	1576	+
	1577	+ cmd->cmnd = scsi_req(req)->cmd = scsi_req(req)->__cmd;
	1578	+ memset(cmd->cmnd, 0, BLK_MAX_CDB);
	1579	+ return scsi_cmd_to_driver(cmd)->init_command(cmd);
1618	1580	}
1619	1581
1620	1582	static void scsi_mq_done(struct scsi_cmnd *cmd)
@@ -1680,7 +1642,7 @@ static blk_status_t scsi_queue_rq(struct blk_mq_hw_ctx *hctx, · 59 unmodified lines
1680	1642	* commands.
1681	1643	*/
1682	1644	if (unlikely(sdev->sdev_state != SDEV_RUNNING)) {
1683		− ret = scsi_prep_state_check(sdev, req);
	1645	+ ret = scsi_device_state_check(sdev, req);
1684	1646	if (ret != BLK_STS_OK)
1685	1647	goto out_put_budget;
1686	1648	}
@@ -1692,13 +1654,12 @@ static blk_status_t scsi_queue_rq(struct blk_mq_hw_ctx *hctx, · 5 unmodified lines
1692	1654	goto out_dec_target_busy;
1693	1655
1694	1656	if (!(req->rq_flags & RQF_DONTPREP)) {
1695		− ret = scsi_mq_prep_fn(req);
	1657	+ ret = scsi_prepare_cmd(req);
1696	1658	if (ret != BLK_STS_OK)
1697	1659	goto out_dec_host_busy;
1698	1660	req->rq_flags \|= RQF_DONTPREP;
1699	1661	} else {
1700	1662	clear_bit(SCMD_STATE_COMPLETE, &cmd->state);
1701		− blk_mq_start_request(req);
1702	1663	}
1703	1664
1704	1665	cmd->flags &= SCMD_PRESERVED_FLAGS;
@@ -1707,9 +1668,11 @@ static blk_status_t scsi_queue_rq(struct blk_mq_hw_ctx *hctx, · 2 unmodified lines
1707	1668	if (bd->last)
1708	1669	cmd->flags \|= SCMD_LAST;
1709	1670
1710		− scsi_init_cmd_errh(cmd);
	1671	+ scsi_set_resid(cmd, 0);
	1672	+ memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1711	1673	cmd->scsi_done = scsi_mq_done;
1712	1674
	1675	+ blk_mq_start_request(req);
1713	1676	reason = scsi_dispatch_cmd(cmd);
1714	1677	if (reason) {
1715	1678	scsi_set_blocked(cmd, reason);
@@ -1970,7 +1933,6 @@ struct scsi_device scsi_device_from_queue(struct request_queue q) · 254 unmodified lines
1970	1933
1971	1934	return sdev;
1972	1935	}
1973		−EXPORT_SYMBOL_GPL(scsi_device_from_queue);
1974	1936
1975	1937	/**
1976	1938	* scsi_block_requests - Utility function used by low-level drivers to prevent

drivers/scsi/sd.c+15−12

@@ -902,7 +902,7 @@ static blk_status_t sd_setup_unmap_cmnd(struct scsi_cmnd *cmd) · 901 unmodified lines
902	902	cmd->transfersize = data_len;
903	903	rq->timeout = SD_TIMEOUT;
904	904
905		− return scsi_init_io(cmd);
	905	+ return scsi_alloc_sgtables(cmd);
906	906	}
907	907
908	908	static blk_status_t sd_setup_write_same16_cmnd(struct scsi_cmnd *cmd,
@@ -934,7 +934,7 @@ static blk_status_t sd_setup_write_same16_cmnd(struct scsi_cmnd *cmd, · 25 unmodified lines
934	934	cmd->transfersize = data_len;
935	935	rq->timeout = unmap ? SD_TIMEOUT : SD_WRITE_SAME_TIMEOUT;
936	936
937		− return scsi_init_io(cmd);
	937	+ return scsi_alloc_sgtables(cmd);
938	938	}
939	939
940	940	static blk_status_t sd_setup_write_same10_cmnd(struct scsi_cmnd *cmd,
@@ -966,7 +966,7 @@ static blk_status_t sd_setup_write_same10_cmnd(struct scsi_cmnd *cmd, · 25 unmodified lines
966	966	cmd->transfersize = data_len;
967	967	rq->timeout = unmap ? SD_TIMEOUT : SD_WRITE_SAME_TIMEOUT;
968	968
969		− return scsi_init_io(cmd);
	969	+ return scsi_alloc_sgtables(cmd);
970	970	}
971	971
972	972	static blk_status_t sd_setup_write_zeroes_cmnd(struct scsi_cmnd *cmd)
@@ -1107,7 +1107,7 @@ static blk_status_t sd_setup_write_same_cmnd(struct scsi_cmnd *cmd) · 134 unmodified lines
1107	1107	* knows how much to actually write.
1108	1108	*/
1109	1109	rq->__data_len = sdp->sector_size;
1110		− ret = scsi_init_io(cmd);
	1110	+ ret = scsi_alloc_sgtables(cmd);
1111	1111	rq->__data_len = blk_rq_bytes(rq);
1112	1112
1113	1113	return ret;
@@ -1226,23 +1226,24 @@ static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd) · 112 unmodified lines
1226	1226	unsigned int dif;
1227	1227	bool dix;
1228	1228
1229		− ret = scsi_init_io(cmd);
	1229	+ ret = scsi_alloc_sgtables(cmd);
1230	1230	if (ret != BLK_STS_OK)
1231	1231	return ret;
1232	1232
	1233	+ ret = BLK_STS_IOERR;
1233	1234	if (!scsi_device_online(sdp) \|\| sdp->changed) {
1234	1235	scmd_printk(KERN_ERR, cmd, "device offline or changed\n");
1235		− return BLK_STS_IOERR;
	1236	+ goto fail;
1236	1237	}
1237	1238
1238	1239	if (blk_rq_pos(rq) + blk_rq_sectors(rq) > get_capacity(rq->rq_disk)) {
1239	1240	scmd_printk(KERN_ERR, cmd, "access beyond end of device\n");
1240		− return BLK_STS_IOERR;
	1241	+ goto fail;
1241	1242	}
1242	1243
1243	1244	if ((blk_rq_pos(rq) & mask) \|\| (blk_rq_sectors(rq) & mask)) {
1244	1245	scmd_printk(KERN_ERR, cmd, "request not aligned to the logical block size\n");
1245		− return BLK_STS_IOERR;
	1246	+ goto fail;
1246	1247	}
1247	1248
1248	1249	/*
@@ -1264,7 +1265,7 @@ static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd) · 15 unmodified lines
1264	1265	if (req_op(rq) == REQ_OP_ZONE_APPEND) {
1265	1266	ret = sd_zbc_prepare_zone_append(cmd, &lba, nr_blocks);
1266	1267	if (ret)
1267		− return ret;
	1268	+ goto fail;
1268	1269	}
1269	1270
1270	1271	fua = rq->cmd_flags & REQ_FUA ? 0x8 : 0;
@@ -1292,7 +1293,7 @@ static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd) · 21 unmodified lines
1292	1293	}
1293	1294
1294	1295	if (unlikely(ret != BLK_STS_OK))
1295		− return ret;
	1296	+ goto fail;
1296	1297
1297	1298	/*
1298	1299	* We shouldn't disconnect in the middle of a sector, so with a dumb
@@ -1316,10 +1317,12 @@ static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd) · 17 unmodified lines
1316	1317	blk_rq_sectors(rq)));
1317	1318
1318	1319	/*
1319		− * This indicates that the command is ready from our end to be
1320		− * queued.
	1320	+ * This indicates that the command is ready from our end to be queued.
1321	1321	*/
1322	1322	return BLK_STS_OK;
	1323	+fail:
	1324	+ scsi_free_sgtables(cmd);
	1325	+ return ret;
1323	1326	}
1324	1327
1325	1328	static blk_status_t sd_init_command(struct scsi_cmnd *cmd)

drivers/scsi/snic/vnic_cq.c+1−7

@@ -31,8 +31,6 @@ void svnic_cq_free(struct vnic_cq *cq) · 30 unmodified lines
31	31	int svnic_cq_alloc(struct vnic_dev vdev, struct vnic_cq cq,
32	32	unsigned int index, unsigned int desc_count, unsigned int desc_size)
33	33	{
34		− int err;
35		−
36	34	cq->index = index;
37	35	cq->vdev = vdev;
38	36
@@ -43,11 +41,7 @@ int svnic_cq_alloc(struct vnic_dev vdev, struct vnic_cq cq, · 4 unmodified lines
43	41	return -EINVAL;
44	42	}
45	43
46		− err = svnic_dev_alloc_desc_ring(vdev, &cq->ring, desc_count, desc_size);
47		− if (err)
48		− return err;
49		−
50		− return 0;
	44	+ return svnic_dev_alloc_desc_ring(vdev, &cq->ring, desc_count, desc_size);
51	45	}
52	46
53	47	void svnic_cq_init(struct vnic_cq *cq, unsigned int flow_control_enable,

drivers/scsi/sr.c+7−10

@@ -392,15 +392,11 @@ static blk_status_t sr_init_command(struct scsi_cmnd *SCpnt) · 391 unmodified lines
392	392	struct request *rq = SCpnt->request;
393	393	blk_status_t ret;
394	394
395		− ret = scsi_init_io(SCpnt);
	395	+ ret = scsi_alloc_sgtables(SCpnt);
396	396	if (ret != BLK_STS_OK)
397		− goto out;
	397	+ return ret;
398	398	cd = scsi_cd(rq->rq_disk);
399	399
400		− /* from here on until we're complete, any goto out
401		− * is used for a killable error condition */
402		− ret = BLK_STS_IOERR;
403		−
404	400	SCSI_LOG_HLQUEUE(1, scmd_printk(KERN_INFO, SCpnt,
405	401	"Doing sr request, block = %d\n", block));
406	402
@@ -507,14 +503,15 @@ static blk_status_t sr_init_command(struct scsi_cmnd *SCpnt) · 100 unmodified lines
507	503	SCpnt->transfersize = cd->device->sector_size;
508	504	SCpnt->underflow = this_count << 9;
509	505	SCpnt->allowed = MAX_RETRIES;
	506	+ SCpnt->cmd_len = 10;
510	507
511	508	/*
512		− * This indicates that the command is ready from our end to be
513		− * queued.
	509	+ * This indicates that the command is ready from our end to be queued.
514	510	*/
515		− ret = BLK_STS_OK;
	511	+ return BLK_STS_OK;
516	512	out:
517		− return ret;
	513	+ scsi_free_sgtables(SCpnt);
	514	+ return BLK_STS_IOERR;
518	515	}
519	516
520	517	static void sr_revalidate_disk(struct scsi_cd *cd)

drivers/scsi/sym53c8xx_2/sym_hipd.c+1−1

@@ -5656,7 +5656,7 @@ int sym_hcb_attach(struct Scsi_Host shost, struct sym_fw fw, struct sym_nvram · 5655 unmodified lines
5656	5656	/*
5657	5657	* Allocate the array of lists of CCBs hashed by DSA.
5658	5658	*/
5659		− np->ccbh = kcalloc(CCB_HASH_SIZE, sizeof(struct sym_ccb **), GFP_KERNEL);
	5659	+ np->ccbh = kcalloc(CCB_HASH_SIZE, sizeof(*np->ccbh), GFP_KERNEL);
5660	5660	if (!np->ccbh)
5661	5661	goto attach_failed;
5662	5662

drivers/target/target_core_rd.c+1−1

@@ -131,7 +131,7 @@ static int rd_allocate_sgl_table(struct rd_dev rd_dev, struct rd_dev_sg_table · 130 unmodified lines
131	131	if (sg_per_table < total_sg_needed)
132	132	chain_entry = 1;
133	133
134		− sg = kcalloc(sg_per_table + chain_entry, sizeof(*sg),
	134	+ sg = kmalloc_array(sg_per_table + chain_entry, sizeof(*sg),
135	135	GFP_KERNEL);
136	136	if (!sg)
137	137	return -ENOMEM;

include/scsi/scsi_cmnd.h+2−1

@@ -165,7 +165,8 @@ extern void scsi_kmap_atomic_sg(struct scatterlist sg, int sg_count, · 164 unmodified lines
165	165	size_t offset, size_t len);
166	166	extern void scsi_kunmap_atomic_sg(void *virt);
167	167
168		−extern blk_status_t scsi_init_io(struct scsi_cmnd *cmd);
	168	+blk_status_t scsi_alloc_sgtables(struct scsi_cmnd *cmd);
	169	+void scsi_free_sgtables(struct scsi_cmnd *cmd);
169	170
170	171	#ifdef CONFIG_SCSI_DMA
171	172	extern int scsi_dma_map(struct scsi_cmnd *cmd);

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