leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source 
Pull more SCSI updates from James Bottomley:
 "This series is all the stragglers that didn't quite make the first
  merge window pull. It's mostly minor updates and bug fixes of merge
  window code"

* tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi:
  scsi: nsp_cs: Check of ioremap return value
  scsi: ufs: ufs-mediatek: Fix error checking in ufs_mtk_init_va09_pwr_ctrl()
  scsi: ufs: Modify Tactive time setting conditions
  scsi: efct: Remove useless DMA-32 fallback configuration
  scsi: message: fusion: mptctl: Use dma_alloc_coherent()
  scsi: message: fusion: mptsas: Use dma_alloc_coherent()
  scsi: message: fusion: Use dma_alloc_coherent() in mptsas_exp_repmanufacture_info()
  scsi: message: fusion: mptbase: Use dma_alloc_coherent()
  scsi: message: fusion: Use dma_alloc_coherent() in mpt_alloc_fw_memory()
  scsi: message: fusion: Remove usage of the deprecated "pci-dma-compat.h" API
  scsi: megaraid: Avoid mismatched storage type sizes
  scsi: hisi_sas: Remove unused variable and check in hisi_sas_send_ata_reset_each_phy()
  scsi: aic79xx: Remove redundant error variable
  scsi: pm80xx: Port reset timeout error handling correction
  scsi: mpi3mr: Fix formatting problems in some kernel-doc comments
  scsi: mpi3mr: Fix some spelling mistakes
  scsi: mpt3sas: Update persistent trigger pages from sysfs interface
  scsi: core: Fix scsi_mode_select() interface
  scsi: aacraid: Fix spelling of "its"
  scsi: qedf: Fix potential dereference of NULL pointer
This commit is contained in:
Linus Torvalds
2022-01-22 10:24:02 +02:00
parent b087788c20 2576e153cd
commit 369af20a2c
22 changed files with 386 additions and 280 deletions
Download Patch File Download Diff File Expand all files Collapse all files

149
drivers/message/fusion/mptbase.c
View File

@@ -300,8 +300,8 @@ mpt_is_discovery_complete(MPT_ADAPTER *ioc)
if (!hdr.ExtPageLength) if (!hdr.ExtPageLength)
goto out; goto out;
buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
&dma_handle); &dma_handle, GFP_KERNEL);
if (!buffer) if (!buffer)
goto out; goto out;
@@ -316,8 +316,8 @@ mpt_is_discovery_complete(MPT_ADAPTER *ioc)
rc = 1; rc = 1;
out_free_consistent: out_free_consistent:
pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
buffer, dma_handle); dma_handle);
out: out:
return rc; return rc;
} }
@@ -1661,16 +1661,14 @@ mpt_mapresources(MPT_ADAPTER *ioc)
const uint64_t required_mask = dma_get_required_mask const uint64_t required_mask = dma_get_required_mask
(&pdev->dev); (&pdev->dev);
if (required_mask > DMA_BIT_MASK(32) if (required_mask > DMA_BIT_MASK(32)
&& !pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) && !dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))
&& !pci_set_consistent_dma_mask(pdev, && !dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64))) {
DMA_BIT_MASK(64))) {
ioc->dma_mask = DMA_BIT_MASK(64); ioc->dma_mask = DMA_BIT_MASK(64);
dinitprintk(ioc, printk(MYIOC_s_INFO_FMT dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n", ": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
ioc->name)); ioc->name));
} else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) } else if (!dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))
&& !pci_set_consistent_dma_mask(pdev, && !dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32))) {
DMA_BIT_MASK(32))) {
ioc->dma_mask = DMA_BIT_MASK(32); ioc->dma_mask = DMA_BIT_MASK(32);
dinitprintk(ioc, printk(MYIOC_s_INFO_FMT dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
": 32 BIT PCI BUS DMA ADDRESSING SUPPORTED\n", ": 32 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
@@ -1681,9 +1679,8 @@ mpt_mapresources(MPT_ADAPTER *ioc)
goto out_pci_release_region; goto out_pci_release_region;
} }
} else { } else {
if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) if (!dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))
&& !pci_set_consistent_dma_mask(pdev, && !dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32))) {
DMA_BIT_MASK(32))) {
ioc->dma_mask = DMA_BIT_MASK(32); ioc->dma_mask = DMA_BIT_MASK(32);
dinitprintk(ioc, printk(MYIOC_s_INFO_FMT dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
": 32 BIT PCI BUS DMA ADDRESSING SUPPORTED\n", ": 32 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
@@ -2769,9 +2766,9 @@ mpt_adapter_disable(MPT_ADAPTER *ioc)
if (ioc->spi_data.pIocPg4 != NULL) { if (ioc->spi_data.pIocPg4 != NULL) {
sz = ioc->spi_data.IocPg4Sz; sz = ioc->spi_data.IocPg4Sz;
pci_free_consistent(ioc->pcidev, sz, dma_free_coherent(&ioc->pcidev->dev, sz,
ioc->spi_data.pIocPg4, ioc->spi_data.pIocPg4,
ioc->spi_data.IocPg4_dma); ioc->spi_data.IocPg4_dma);
ioc->spi_data.pIocPg4 = NULL; ioc->spi_data.pIocPg4 = NULL;
ioc->alloc_total -= sz; ioc->alloc_total -= sz;
} }
@@ -3515,7 +3512,8 @@ mpt_alloc_fw_memory(MPT_ADAPTER *ioc, int size)
rc = 0; rc = 0;
goto out; goto out;
} }
ioc->cached_fw = pci_alloc_consistent(ioc->pcidev, size, &ioc->cached_fw_dma); ioc->cached_fw = dma_alloc_coherent(&ioc->pcidev->dev, size,
&ioc->cached_fw_dma, GFP_ATOMIC);
if (!ioc->cached_fw) { if (!ioc->cached_fw) {
printk(MYIOC_s_ERR_FMT "Unable to allocate memory for the cached firmware image!\n", printk(MYIOC_s_ERR_FMT "Unable to allocate memory for the cached firmware image!\n",
ioc->name); ioc->name);
@@ -3548,7 +3546,8 @@ mpt_free_fw_memory(MPT_ADAPTER *ioc)
sz = ioc->facts.FWImageSize; sz = ioc->facts.FWImageSize;
dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "free_fw_memory: FW Image @ %p[%p], sz=%d[%x] bytes\n", dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "free_fw_memory: FW Image @ %p[%p], sz=%d[%x] bytes\n",
ioc->name, ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz)); ioc->name, ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
pci_free_consistent(ioc->pcidev, sz, ioc->cached_fw, ioc->cached_fw_dma); dma_free_coherent(&ioc->pcidev->dev, sz, ioc->cached_fw,
ioc->cached_fw_dma);
ioc->alloc_total -= sz; ioc->alloc_total -= sz;
ioc->cached_fw = NULL; ioc->cached_fw = NULL;
} }
@@ -4447,9 +4446,8 @@ PrimeIocFifos(MPT_ADAPTER *ioc)
*/ */
if (ioc->pcidev->device == MPI_MANUFACTPAGE_DEVID_SAS1078 && if (ioc->pcidev->device == MPI_MANUFACTPAGE_DEVID_SAS1078 &&
ioc->dma_mask > DMA_BIT_MASK(35)) { ioc->dma_mask > DMA_BIT_MASK(35)) {
if (!pci_set_dma_mask(ioc->pcidev, DMA_BIT_MASK(32)) if (!dma_set_mask(&ioc->pcidev->dev, DMA_BIT_MASK(32))
&& !pci_set_consistent_dma_mask(ioc->pcidev, && !dma_set_coherent_mask(&ioc->pcidev->dev, DMA_BIT_MASK(32))) {
DMA_BIT_MASK(32))) {
dma_mask = DMA_BIT_MASK(35); dma_mask = DMA_BIT_MASK(35);
d36memprintk(ioc, printk(MYIOC_s_DEBUG_FMT d36memprintk(ioc, printk(MYIOC_s_DEBUG_FMT
"setting 35 bit addressing for " "setting 35 bit addressing for "
@@ -4457,10 +4455,10 @@ PrimeIocFifos(MPT_ADAPTER *ioc)
ioc->name)); ioc->name));
} else { } else {
/*Reseting DMA mask to 64 bit*/ /*Reseting DMA mask to 64 bit*/
pci_set_dma_mask(ioc->pcidev, dma_set_mask(&ioc->pcidev->dev,
DMA_BIT_MASK(64)); DMA_BIT_MASK(64));
pci_set_consistent_dma_mask(ioc->pcidev, dma_set_coherent_mask(&ioc->pcidev->dev,
DMA_BIT_MASK(64)); DMA_BIT_MASK(64));
printk(MYIOC_s_ERR_FMT printk(MYIOC_s_ERR_FMT
"failed setting 35 bit addressing for " "failed setting 35 bit addressing for "
@@ -4595,8 +4593,8 @@ PrimeIocFifos(MPT_ADAPTER *ioc)
alloc_dma += ioc->reply_sz; alloc_dma += ioc->reply_sz;
} }
if (dma_mask == DMA_BIT_MASK(35) && !pci_set_dma_mask(ioc->pcidev, if (dma_mask == DMA_BIT_MASK(35) && !dma_set_mask(&ioc->pcidev->dev,
ioc->dma_mask) && !pci_set_consistent_dma_mask(ioc->pcidev, ioc->dma_mask) && !dma_set_coherent_mask(&ioc->pcidev->dev,
ioc->dma_mask)) ioc->dma_mask))
d36memprintk(ioc, printk(MYIOC_s_DEBUG_FMT d36memprintk(ioc, printk(MYIOC_s_DEBUG_FMT
"restoring 64 bit addressing\n", ioc->name)); "restoring 64 bit addressing\n", ioc->name));
@@ -4620,8 +4618,8 @@ out_fail:
ioc->sense_buf_pool = NULL; ioc->sense_buf_pool = NULL;
} }
if (dma_mask == DMA_BIT_MASK(35) && !pci_set_dma_mask(ioc->pcidev, if (dma_mask == DMA_BIT_MASK(35) && !dma_set_mask(&ioc->pcidev->dev,
DMA_BIT_MASK(64)) && !pci_set_consistent_dma_mask(ioc->pcidev, DMA_BIT_MASK(64)) && !dma_set_coherent_mask(&ioc->pcidev->dev,
DMA_BIT_MASK(64))) DMA_BIT_MASK(64)))
d36memprintk(ioc, printk(MYIOC_s_DEBUG_FMT d36memprintk(ioc, printk(MYIOC_s_DEBUG_FMT
"restoring 64 bit addressing\n", ioc->name)); "restoring 64 bit addressing\n", ioc->name));
@@ -4968,7 +4966,8 @@ GetLanConfigPages(MPT_ADAPTER *ioc)
if (hdr.PageLength > 0) { if (hdr.PageLength > 0) {
data_sz = hdr.PageLength * 4; data_sz = hdr.PageLength * 4;
ppage0_alloc = pci_alloc_consistent(ioc->pcidev, data_sz, &page0_dma); ppage0_alloc = dma_alloc_coherent(&ioc->pcidev->dev, data_sz,
&page0_dma, GFP_KERNEL);
rc = -ENOMEM; rc = -ENOMEM;
if (ppage0_alloc) { if (ppage0_alloc) {
memset((u8 *)ppage0_alloc, 0, data_sz); memset((u8 *)ppage0_alloc, 0, data_sz);
@@ -4982,7 +4981,8 @@ GetLanConfigPages(MPT_ADAPTER *ioc)
} }
pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage0_alloc, page0_dma); dma_free_coherent(&ioc->pcidev->dev, data_sz,
(u8 *)ppage0_alloc, page0_dma);
/* FIXME! /* FIXME!
* Normalize endianness of structure data, * Normalize endianness of structure data,
@@ -5014,7 +5014,8 @@ GetLanConfigPages(MPT_ADAPTER *ioc)
data_sz = hdr.PageLength * 4; data_sz = hdr.PageLength * 4;
rc = -ENOMEM; rc = -ENOMEM;
ppage1_alloc = pci_alloc_consistent(ioc->pcidev, data_sz, &page1_dma); ppage1_alloc = dma_alloc_coherent(&ioc->pcidev->dev, data_sz,
&page1_dma, GFP_KERNEL);
if (ppage1_alloc) { if (ppage1_alloc) {
memset((u8 *)ppage1_alloc, 0, data_sz); memset((u8 *)ppage1_alloc, 0, data_sz);
cfg.physAddr = page1_dma; cfg.physAddr = page1_dma;
@@ -5026,7 +5027,8 @@ GetLanConfigPages(MPT_ADAPTER *ioc)
memcpy(&ioc->lan_cnfg_page1, ppage1_alloc, copy_sz); memcpy(&ioc->lan_cnfg_page1, ppage1_alloc, copy_sz);
} }
pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage1_alloc, page1_dma); dma_free_coherent(&ioc->pcidev->dev, data_sz,
(u8 *)ppage1_alloc, page1_dma);
/* FIXME! /* FIXME!
* Normalize endianness of structure data, * Normalize endianness of structure data,
@@ -5315,7 +5317,8 @@ GetIoUnitPage2(MPT_ADAPTER *ioc)
/* Read the config page */ /* Read the config page */
data_sz = hdr.PageLength * 4; data_sz = hdr.PageLength * 4;
rc = -ENOMEM; rc = -ENOMEM;
ppage_alloc = pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma); ppage_alloc = dma_alloc_coherent(&ioc->pcidev->dev, data_sz,
&page_dma, GFP_KERNEL);
if (ppage_alloc) { if (ppage_alloc) {
memset((u8 *)ppage_alloc, 0, data_sz); memset((u8 *)ppage_alloc, 0, data_sz);
cfg.physAddr = page_dma; cfg.physAddr = page_dma;
@@ -5325,7 +5328,8 @@ GetIoUnitPage2(MPT_ADAPTER *ioc)
if ((rc = mpt_config(ioc, &cfg)) == 0) if ((rc = mpt_config(ioc, &cfg)) == 0)
ioc->biosVersion = le32_to_cpu(ppage_alloc->BiosVersion); ioc->biosVersion = le32_to_cpu(ppage_alloc->BiosVersion);
pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage_alloc, page_dma); dma_free_coherent(&ioc->pcidev->dev, data_sz,
(u8 *)ppage_alloc, page_dma);
} }
return rc; return rc;
@@ -5400,7 +5404,9 @@ mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum)
return -EFAULT; return -EFAULT;
if (header.PageLength > 0) { if (header.PageLength > 0) {
pbuf = pci_alloc_consistent(ioc->pcidev, header.PageLength * 4, &buf_dma); pbuf = dma_alloc_coherent(&ioc->pcidev->dev,
header.PageLength * 4, &buf_dma,
GFP_KERNEL);
if (pbuf) { if (pbuf) {
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
cfg.physAddr = buf_dma; cfg.physAddr = buf_dma;
@@ -5456,7 +5462,9 @@ mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum)
} }
} }
if (pbuf) { if (pbuf) {
pci_free_consistent(ioc->pcidev, header.PageLength * 4, pbuf, buf_dma); dma_free_coherent(&ioc->pcidev->dev,
header.PageLength * 4, pbuf,
buf_dma);
} }
} }
} }
@@ -5478,7 +5486,9 @@ mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum)
if (header.PageLength > 0) { if (header.PageLength > 0) {
/* Allocate memory and read SCSI Port Page 2 /* Allocate memory and read SCSI Port Page 2
*/ */
pbuf = pci_alloc_consistent(ioc->pcidev, header.PageLength * 4, &buf_dma); pbuf = dma_alloc_coherent(&ioc->pcidev->dev,
header.PageLength * 4, &buf_dma,
GFP_KERNEL);
if (pbuf) { if (pbuf) {
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_NVRAM; cfg.action = MPI_CONFIG_ACTION_PAGE_READ_NVRAM;
cfg.physAddr = buf_dma; cfg.physAddr = buf_dma;
@@ -5543,7 +5553,9 @@ mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum)
} }
} }
pci_free_consistent(ioc->pcidev, header.PageLength * 4, pbuf, buf_dma); dma_free_coherent(&ioc->pcidev->dev,
header.PageLength * 4, pbuf,
buf_dma);
} }
} }
@@ -5659,8 +5671,8 @@ mpt_inactive_raid_volumes(MPT_ADAPTER *ioc, u8 channel, u8 id)
if (!hdr.PageLength) if (!hdr.PageLength)
goto out; goto out;
buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
&dma_handle); &dma_handle, GFP_KERNEL);
if (!buffer) if (!buffer)
goto out; goto out;
@@ -5707,8 +5719,8 @@ mpt_inactive_raid_volumes(MPT_ADAPTER *ioc, u8 channel, u8 id)
out: out:
if (buffer) if (buffer)
pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer, dma_free_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
dma_handle); buffer, dma_handle);
} }
/** /**
@@ -5752,8 +5764,8 @@ mpt_raid_phys_disk_pg0(MPT_ADAPTER *ioc, u8 phys_disk_num,
goto out; goto out;
} }
buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
&dma_handle); &dma_handle, GFP_KERNEL);
if (!buffer) { if (!buffer) {
rc = -ENOMEM; rc = -ENOMEM;
@@ -5776,8 +5788,8 @@ mpt_raid_phys_disk_pg0(MPT_ADAPTER *ioc, u8 phys_disk_num,
out: out:
if (buffer) if (buffer)
pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer, dma_free_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
dma_handle); buffer, dma_handle);
return rc; return rc;
} }
@@ -5819,8 +5831,8 @@ mpt_raid_phys_disk_get_num_paths(MPT_ADAPTER *ioc, u8 phys_disk_num)
goto out; goto out;
} }
buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
&dma_handle); &dma_handle, GFP_KERNEL);
if (!buffer) { if (!buffer) {
rc = 0; rc = 0;
@@ -5840,8 +5852,8 @@ mpt_raid_phys_disk_get_num_paths(MPT_ADAPTER *ioc, u8 phys_disk_num)
out: out:
if (buffer) if (buffer)
pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer, dma_free_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
dma_handle); buffer, dma_handle);
return rc; return rc;
} }
@@ -5891,8 +5903,8 @@ mpt_raid_phys_disk_pg1(MPT_ADAPTER *ioc, u8 phys_disk_num,
goto out; goto out;
} }
buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
&dma_handle); &dma_handle, GFP_KERNEL);
if (!buffer) { if (!buffer) {
rc = -ENOMEM; rc = -ENOMEM;
@@ -5929,8 +5941,8 @@ mpt_raid_phys_disk_pg1(MPT_ADAPTER *ioc, u8 phys_disk_num,
out: out:
if (buffer) if (buffer)
pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer, dma_free_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
dma_handle); buffer, dma_handle);
return rc; return rc;
} }
@@ -5986,7 +5998,8 @@ mpt_findImVolumes(MPT_ADAPTER *ioc)
return -EFAULT; return -EFAULT;
iocpage2sz = header.PageLength * 4; iocpage2sz = header.PageLength * 4;
pIoc2 = pci_alloc_consistent(ioc->pcidev, iocpage2sz, &ioc2_dma); pIoc2 = dma_alloc_coherent(&ioc->pcidev->dev, iocpage2sz, &ioc2_dma,
GFP_KERNEL);
if (!pIoc2) if (!pIoc2)
return -ENOMEM; return -ENOMEM;
@@ -6011,7 +6024,7 @@ mpt_findImVolumes(MPT_ADAPTER *ioc)
pIoc2->RaidVolume[i].VolumeID); pIoc2->RaidVolume[i].VolumeID);
out: out:
pci_free_consistent(ioc->pcidev, iocpage2sz, pIoc2, ioc2_dma); dma_free_coherent(&ioc->pcidev->dev, iocpage2sz, pIoc2, ioc2_dma);
return rc; return rc;
} }
@@ -6053,7 +6066,8 @@ mpt_read_ioc_pg_3(MPT_ADAPTER *ioc)
/* Read Header good, alloc memory /* Read Header good, alloc memory
*/ */
iocpage3sz = header.PageLength * 4; iocpage3sz = header.PageLength * 4;
pIoc3 = pci_alloc_consistent(ioc->pcidev, iocpage3sz, &ioc3_dma); pIoc3 = dma_alloc_coherent(&ioc->pcidev->dev, iocpage3sz, &ioc3_dma,
GFP_KERNEL);
if (!pIoc3) if (!pIoc3)
return 0; return 0;
@@ -6070,7 +6084,7 @@ mpt_read_ioc_pg_3(MPT_ADAPTER *ioc)
} }
} }
pci_free_consistent(ioc->pcidev, iocpage3sz, pIoc3, ioc3_dma); dma_free_coherent(&ioc->pcidev->dev, iocpage3sz, pIoc3, ioc3_dma);
return 0; return 0;
} }
@@ -6104,7 +6118,8 @@ mpt_read_ioc_pg_4(MPT_ADAPTER *ioc)
if ( (pIoc4 = ioc->spi_data.pIocPg4) == NULL ) { if ( (pIoc4 = ioc->spi_data.pIocPg4) == NULL ) {
iocpage4sz = (header.PageLength + 4) * 4; /* Allow 4 additional SEP's */ iocpage4sz = (header.PageLength + 4) * 4; /* Allow 4 additional SEP's */
pIoc4 = pci_alloc_consistent(ioc->pcidev, iocpage4sz, &ioc4_dma); pIoc4 = dma_alloc_coherent(&ioc->pcidev->dev, iocpage4sz,
&ioc4_dma, GFP_KERNEL);
if (!pIoc4) if (!pIoc4)
return; return;
ioc->alloc_total += iocpage4sz; ioc->alloc_total += iocpage4sz;
@@ -6122,7 +6137,8 @@ mpt_read_ioc_pg_4(MPT_ADAPTER *ioc)
ioc->spi_data.IocPg4_dma = ioc4_dma; ioc->spi_data.IocPg4_dma = ioc4_dma;
ioc->spi_data.IocPg4Sz = iocpage4sz; ioc->spi_data.IocPg4Sz = iocpage4sz;
} else { } else {
pci_free_consistent(ioc->pcidev, iocpage4sz, pIoc4, ioc4_dma); dma_free_coherent(&ioc->pcidev->dev, iocpage4sz, pIoc4,
ioc4_dma);
ioc->spi_data.pIocPg4 = NULL; ioc->spi_data.pIocPg4 = NULL;
ioc->alloc_total -= iocpage4sz; ioc->alloc_total -= iocpage4sz;
} }
@@ -6159,7 +6175,8 @@ mpt_read_ioc_pg_1(MPT_ADAPTER *ioc)
/* Read Header good, alloc memory /* Read Header good, alloc memory
*/ */
iocpage1sz = header.PageLength * 4; iocpage1sz = header.PageLength * 4;
pIoc1 = pci_alloc_consistent(ioc->pcidev, iocpage1sz, &ioc1_dma); pIoc1 = dma_alloc_coherent(&ioc->pcidev->dev, iocpage1sz, &ioc1_dma,
GFP_KERNEL);
if (!pIoc1) if (!pIoc1)
return; return;
@@ -6210,7 +6227,7 @@ mpt_read_ioc_pg_1(MPT_ADAPTER *ioc)
} }
} }
pci_free_consistent(ioc->pcidev, iocpage1sz, pIoc1, ioc1_dma); dma_free_coherent(&ioc->pcidev->dev, iocpage1sz, pIoc1, ioc1_dma);
return; return;
} }
@@ -6239,7 +6256,8 @@ mpt_get_manufacturing_pg_0(MPT_ADAPTER *ioc)
goto out; goto out;
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma); pbuf = dma_alloc_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
&buf_dma, GFP_KERNEL);
if (!pbuf) if (!pbuf)
goto out; goto out;
@@ -6255,7 +6273,8 @@ mpt_get_manufacturing_pg_0(MPT_ADAPTER *ioc)
out: out:
if (pbuf) if (pbuf)
pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma); dma_free_coherent(&ioc->pcidev->dev, hdr.PageLength * 4, pbuf,
buf_dma);
} }
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

82
drivers/message/fusion/mptctl.c
View File

@@ -1041,14 +1041,15 @@ kbuf_alloc_2_sgl(int bytes, u32 sgdir, int sge_offset, int *frags,
* copying the data in this array into the correct place in the * copying the data in this array into the correct place in the
* request and chain buffers. * request and chain buffers.
*/ */
sglbuf = pci_alloc_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf_dma); sglbuf = dma_alloc_coherent(&ioc->pcidev->dev, MAX_SGL_BYTES,
sglbuf_dma, GFP_KERNEL);
if (sglbuf == NULL) if (sglbuf == NULL)
goto free_and_fail; goto free_and_fail;
if (sgdir & 0x04000000) if (sgdir & 0x04000000)
dir = PCI_DMA_TODEVICE; dir = DMA_TO_DEVICE;
else else
dir = PCI_DMA_FROMDEVICE; dir = DMA_FROM_DEVICE;
/* At start: /* At start:
* sgl = sglbuf = point to beginning of sg buffer * sgl = sglbuf = point to beginning of sg buffer
@@ -1062,9 +1063,9 @@ kbuf_alloc_2_sgl(int bytes, u32 sgdir, int sge_offset, int *frags,
while (bytes_allocd < bytes) { while (bytes_allocd < bytes) {
this_alloc = min(alloc_sz, bytes-bytes_allocd); this_alloc = min(alloc_sz, bytes-bytes_allocd);
buflist[buflist_ent].len = this_alloc; buflist[buflist_ent].len = this_alloc;
buflist[buflist_ent].kptr = pci_alloc_consistent(ioc->pcidev, buflist[buflist_ent].kptr = dma_alloc_coherent(&ioc->pcidev->dev,
this_alloc, this_alloc,
&pa); &pa, GFP_KERNEL);
if (buflist[buflist_ent].kptr == NULL) { if (buflist[buflist_ent].kptr == NULL) {
alloc_sz = alloc_sz / 2; alloc_sz = alloc_sz / 2;
if (alloc_sz == 0) { if (alloc_sz == 0) {
@@ -1080,8 +1081,9 @@ kbuf_alloc_2_sgl(int bytes, u32 sgdir, int sge_offset, int *frags,
bytes_allocd += this_alloc; bytes_allocd += this_alloc;
sgl->FlagsLength = (0x10000000|sgdir|this_alloc); sgl->FlagsLength = (0x10000000|sgdir|this_alloc);
dma_addr = pci_map_single(ioc->pcidev, dma_addr = dma_map_single(&ioc->pcidev->dev,
buflist[buflist_ent].kptr, this_alloc, dir); buflist[buflist_ent].kptr,
this_alloc, dir);
sgl->Address = dma_addr; sgl->Address = dma_addr;
fragcnt++; fragcnt++;
@@ -1140,9 +1142,11 @@ free_and_fail:
kptr = buflist[i].kptr; kptr = buflist[i].kptr;
len = buflist[i].len; len = buflist[i].len;
pci_free_consistent(ioc->pcidev, len, kptr, dma_addr); dma_free_coherent(&ioc->pcidev->dev, len, kptr,
dma_addr);
} }
pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sglbuf, *sglbuf_dma); dma_free_coherent(&ioc->pcidev->dev, MAX_SGL_BYTES, sglbuf,
*sglbuf_dma);
} }
kfree(buflist); kfree(buflist);
return NULL; return NULL;
@@ -1162,9 +1166,9 @@ kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma, struct buflist *buflist, MPT_ADAPTE
int n = 0; int n = 0;
if (sg->FlagsLength & 0x04000000) if (sg->FlagsLength & 0x04000000)
dir = PCI_DMA_TODEVICE; dir = DMA_TO_DEVICE;
else else
dir = PCI_DMA_FROMDEVICE; dir = DMA_FROM_DEVICE;
nib = (sg->FlagsLength & 0xF0000000) >> 28; nib = (sg->FlagsLength & 0xF0000000) >> 28;
while (! (nib & 0x4)) { /* eob */ while (! (nib & 0x4)) { /* eob */
@@ -1179,8 +1183,10 @@ kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma, struct buflist *buflist, MPT_ADAPTE
dma_addr = sg->Address; dma_addr = sg->Address;
kptr = bl->kptr; kptr = bl->kptr;
len = bl->len; len = bl->len;
pci_unmap_single(ioc->pcidev, dma_addr, len, dir); dma_unmap_single(&ioc->pcidev->dev, dma_addr, len,
pci_free_consistent(ioc->pcidev, len, kptr, dma_addr); dir);
dma_free_coherent(&ioc->pcidev->dev, len, kptr,
dma_addr);
n++; n++;
} }
sg++; sg++;
@@ -1197,12 +1203,12 @@ kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma, struct buflist *buflist, MPT_ADAPTE
dma_addr = sg->Address; dma_addr = sg->Address;
kptr = bl->kptr; kptr = bl->kptr;
len = bl->len; len = bl->len;
pci_unmap_single(ioc->pcidev, dma_addr, len, dir); dma_unmap_single(&ioc->pcidev->dev, dma_addr, len, dir);
pci_free_consistent(ioc->pcidev, len, kptr, dma_addr); dma_free_coherent(&ioc->pcidev->dev, len, kptr, dma_addr);
n++; n++;
} }
pci_free_consistent(ioc->pcidev, MAX_SGL_BYTES, sgl, sgl_dma); dma_free_coherent(&ioc->pcidev->dev, MAX_SGL_BYTES, sgl, sgl_dma);
kfree(buflist); kfree(buflist);
dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: Free'd 1 SGL buf + %d kbufs!\n", dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "-SG: Free'd 1 SGL buf + %d kbufs!\n",
ioc->name, n)); ioc->name, n));
@@ -2100,8 +2106,9 @@ mptctl_do_mpt_command (MPT_ADAPTER *ioc, struct mpt_ioctl_command karg, void __u
} }
flagsLength |= karg.dataOutSize; flagsLength |= karg.dataOutSize;
bufOut.len = karg.dataOutSize; bufOut.len = karg.dataOutSize;
bufOut.kptr = pci_alloc_consistent( bufOut.kptr = dma_alloc_coherent(&ioc->pcidev->dev,
ioc->pcidev, bufOut.len, &dma_addr_out); bufOut.len,
&dma_addr_out, GFP_KERNEL);
if (bufOut.kptr == NULL) { if (bufOut.kptr == NULL) {
rc = -ENOMEM; rc = -ENOMEM;
@@ -2134,8 +2141,9 @@ mptctl_do_mpt_command (MPT_ADAPTER *ioc, struct mpt_ioctl_command karg, void __u
flagsLength |= karg.dataInSize; flagsLength |= karg.dataInSize;
bufIn.len = karg.dataInSize; bufIn.len = karg.dataInSize;
bufIn.kptr = pci_alloc_consistent(ioc->pcidev, bufIn.kptr = dma_alloc_coherent(&ioc->pcidev->dev,
bufIn.len, &dma_addr_in); bufIn.len,
&dma_addr_in, GFP_KERNEL);
if (bufIn.kptr == NULL) { if (bufIn.kptr == NULL) {
rc = -ENOMEM; rc = -ENOMEM;
@@ -2283,13 +2291,13 @@ done_free_mem:
/* Free the allocated memory. /* Free the allocated memory.
*/ */
if (bufOut.kptr != NULL) { if (bufOut.kptr != NULL) {
pci_free_consistent(ioc->pcidev, dma_free_coherent(&ioc->pcidev->dev, bufOut.len,
bufOut.len, (void *) bufOut.kptr, dma_addr_out); (void *)bufOut.kptr, dma_addr_out);
} }
if (bufIn.kptr != NULL) { if (bufIn.kptr != NULL) {
pci_free_consistent(ioc->pcidev, dma_free_coherent(&ioc->pcidev->dev, bufIn.len,
bufIn.len, (void *) bufIn.kptr, dma_addr_in); (void *)bufIn.kptr, dma_addr_in);
} }
/* mf is null if command issued successfully /* mf is null if command issued successfully
@@ -2395,7 +2403,9 @@ mptctl_hp_hostinfo(MPT_ADAPTER *ioc, unsigned long arg, unsigned int data_size)
/* Issue the second config page request */ /* Issue the second config page request */
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma); pbuf = dma_alloc_coherent(&ioc->pcidev->dev,
hdr.PageLength * 4,
&buf_dma, GFP_KERNEL);
if (pbuf) { if (pbuf) {
cfg.physAddr = buf_dma; cfg.physAddr = buf_dma;
if (mpt_config(ioc, &cfg) == 0) { if (mpt_config(ioc, &cfg) == 0) {
@@ -2405,7 +2415,9 @@ mptctl_hp_hostinfo(MPT_ADAPTER *ioc, unsigned long arg, unsigned int data_size)
pdata->BoardTracerNumber, 24); pdata->BoardTracerNumber, 24);
} }
} }
pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma); dma_free_coherent(&ioc->pcidev->dev,
hdr.PageLength * 4, pbuf,
buf_dma);
pbuf = NULL; pbuf = NULL;
} }
} }
@@ -2470,7 +2482,7 @@ mptctl_hp_hostinfo(MPT_ADAPTER *ioc, unsigned long arg, unsigned int data_size)
else else
IstwiRWRequest->DeviceAddr = 0xB0; IstwiRWRequest->DeviceAddr = 0xB0;
pbuf = pci_alloc_consistent(ioc->pcidev, 4, &buf_dma); pbuf = dma_alloc_coherent(&ioc->pcidev->dev, 4, &buf_dma, GFP_KERNEL);
if (!pbuf) if (!pbuf)
goto out; goto out;
ioc->add_sge((char *)&IstwiRWRequest->SGL, ioc->add_sge((char *)&IstwiRWRequest->SGL,
@@ -2519,7 +2531,7 @@ retry_wait:
SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0); SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
if (pbuf) if (pbuf)
pci_free_consistent(ioc->pcidev, 4, pbuf, buf_dma); dma_free_coherent(&ioc->pcidev->dev, 4, pbuf, buf_dma);
/* Copy the data from kernel memory to user memory /* Copy the data from kernel memory to user memory
*/ */
@@ -2585,7 +2597,8 @@ mptctl_hp_targetinfo(MPT_ADAPTER *ioc, unsigned long arg)
/* Get the data transfer speeds /* Get the data transfer speeds
*/ */
data_sz = ioc->spi_data.sdp0length * 4; data_sz = ioc->spi_data.sdp0length * 4;
pg0_alloc = pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma); pg0_alloc = dma_alloc_coherent(&ioc->pcidev->dev, data_sz, &page_dma,
GFP_KERNEL);
if (pg0_alloc) { if (pg0_alloc) {
hdr.PageVersion = ioc->spi_data.sdp0version; hdr.PageVersion = ioc->spi_data.sdp0version;
hdr.PageLength = data_sz; hdr.PageLength = data_sz;
@@ -2623,7 +2636,8 @@ mptctl_hp_targetinfo(MPT_ADAPTER *ioc, unsigned long arg)
karg.negotiated_speed = HP_DEV_SPEED_ASYNC; karg.negotiated_speed = HP_DEV_SPEED_ASYNC;
} }
pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg0_alloc, page_dma); dma_free_coherent(&ioc->pcidev->dev, data_sz, (u8 *)pg0_alloc,
page_dma);
} }
/* Set defaults /* Set defaults
@@ -2649,7 +2663,8 @@ mptctl_hp_targetinfo(MPT_ADAPTER *ioc, unsigned long arg)
/* Issue the second config page request */ /* Issue the second config page request */
cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
data_sz = (int) cfg.cfghdr.hdr->PageLength * 4; data_sz = (int) cfg.cfghdr.hdr->PageLength * 4;
pg3_alloc = pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma); pg3_alloc = dma_alloc_coherent(&ioc->pcidev->dev, data_sz,
&page_dma, GFP_KERNEL);
if (pg3_alloc) { if (pg3_alloc) {
cfg.physAddr = page_dma; cfg.physAddr = page_dma;
cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id; cfg.pageAddr = (karg.hdr.channel << 8) | karg.hdr.id;
@@ -2658,7 +2673,8 @@ mptctl_hp_targetinfo(MPT_ADAPTER *ioc, unsigned long arg)
karg.phase_errors = (u32) le16_to_cpu(pg3_alloc->PhaseErrorCount); karg.phase_errors = (u32) le16_to_cpu(pg3_alloc->PhaseErrorCount);
karg.parity_errors = (u32) le16_to_cpu(pg3_alloc->ParityErrorCount); karg.parity_errors = (u32) le16_to_cpu(pg3_alloc->ParityErrorCount);
} }
pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg3_alloc, page_dma); dma_free_coherent(&ioc->pcidev->dev, data_sz,
(u8 *)pg3_alloc, page_dma);
} }
} }
hd = shost_priv(ioc->sh); hd = shost_priv(ioc->sh);

90
drivers/message/fusion/mptlan.c
View File

@@ -516,9 +516,9 @@ mpt_lan_close(struct net_device *dev)
if (priv->RcvCtl[i].skb != NULL) { if (priv->RcvCtl[i].skb != NULL) {
/**/ dlprintk((KERN_INFO MYNAM "/lan_close: bucket %05x " /**/ dlprintk((KERN_INFO MYNAM "/lan_close: bucket %05x "
/**/ "is still out\n", i)); /**/ "is still out\n", i));
pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[i].dma, dma_unmap_single(&mpt_dev->pcidev->dev,
priv->RcvCtl[i].len, priv->RcvCtl[i].dma,
PCI_DMA_FROMDEVICE); priv->RcvCtl[i].len, DMA_FROM_DEVICE);
dev_kfree_skb(priv->RcvCtl[i].skb); dev_kfree_skb(priv->RcvCtl[i].skb);
} }
} }
@@ -528,9 +528,9 @@ mpt_lan_close(struct net_device *dev)
for (i = 0; i < priv->tx_max_out; i++) { for (i = 0; i < priv->tx_max_out; i++) {
if (priv->SendCtl[i].skb != NULL) { if (priv->SendCtl[i].skb != NULL) {
pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[i].dma, dma_unmap_single(&mpt_dev->pcidev->dev,
priv->SendCtl[i].len, priv->SendCtl[i].dma,
PCI_DMA_TODEVICE); priv->SendCtl[i].len, DMA_TO_DEVICE);
dev_kfree_skb(priv->SendCtl[i].skb); dev_kfree_skb(priv->SendCtl[i].skb);
} }
} }
@@ -582,8 +582,8 @@ mpt_lan_send_turbo(struct net_device *dev, u32 tmsg)
__func__, sent)); __func__, sent));
priv->SendCtl[ctx].skb = NULL; priv->SendCtl[ctx].skb = NULL;
pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[ctx].dma, dma_unmap_single(&mpt_dev->pcidev->dev, priv->SendCtl[ctx].dma,
priv->SendCtl[ctx].len, PCI_DMA_TODEVICE); priv->SendCtl[ctx].len, DMA_TO_DEVICE);
dev_kfree_skb_irq(sent); dev_kfree_skb_irq(sent);
spin_lock_irqsave(&priv->txfidx_lock, flags); spin_lock_irqsave(&priv->txfidx_lock, flags);
@@ -648,8 +648,9 @@ mpt_lan_send_reply(struct net_device *dev, LANSendReply_t *pSendRep)
__func__, sent)); __func__, sent));
priv->SendCtl[ctx].skb = NULL; priv->SendCtl[ctx].skb = NULL;
pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[ctx].dma, dma_unmap_single(&mpt_dev->pcidev->dev,
priv->SendCtl[ctx].len, PCI_DMA_TODEVICE); priv->SendCtl[ctx].dma,
priv->SendCtl[ctx].len, DMA_TO_DEVICE);
dev_kfree_skb_irq(sent); dev_kfree_skb_irq(sent);
priv->mpt_txfidx[++priv->mpt_txfidx_tail] = ctx; priv->mpt_txfidx[++priv->mpt_txfidx_tail] = ctx;
@@ -720,8 +721,8 @@ mpt_lan_sdu_send (struct sk_buff *skb, struct net_device *dev)
skb_reset_mac_header(skb); skb_reset_mac_header(skb);
skb_pull(skb, 12); skb_pull(skb, 12);
dma = pci_map_single(mpt_dev->pcidev, skb->data, skb->len, dma = dma_map_single(&mpt_dev->pcidev->dev, skb->data, skb->len,
PCI_DMA_TODEVICE); DMA_TO_DEVICE);
priv->SendCtl[ctx].skb = skb; priv->SendCtl[ctx].skb = skb;
priv->SendCtl[ctx].dma = dma; priv->SendCtl[ctx].dma = dma;
@@ -868,13 +869,17 @@ mpt_lan_receive_post_turbo(struct net_device *dev, u32 tmsg)
return -ENOMEM; return -ENOMEM;
} }
pci_dma_sync_single_for_cpu(mpt_dev->pcidev, priv->RcvCtl[ctx].dma, dma_sync_single_for_cpu(&mpt_dev->pcidev->dev,
priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE); priv->RcvCtl[ctx].dma,
priv->RcvCtl[ctx].len,
DMA_FROM_DEVICE);
skb_copy_from_linear_data(old_skb, skb_put(skb, len), len); skb_copy_from_linear_data(old_skb, skb_put(skb, len), len);
pci_dma_sync_single_for_device(mpt_dev->pcidev, priv->RcvCtl[ctx].dma, dma_sync_single_for_device(&mpt_dev->pcidev->dev,
priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE); priv->RcvCtl[ctx].dma,
priv->RcvCtl[ctx].len,
DMA_FROM_DEVICE);
goto out; goto out;
} }
@@ -882,8 +887,8 @@ mpt_lan_receive_post_turbo(struct net_device *dev, u32 tmsg)
priv->RcvCtl[ctx].skb = NULL; priv->RcvCtl[ctx].skb = NULL;
pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma, dma_unmap_single(&mpt_dev->pcidev->dev, priv->RcvCtl[ctx].dma,
priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE); priv->RcvCtl[ctx].len, DMA_FROM_DEVICE);
out: out:
spin_lock_irqsave(&priv->rxfidx_lock, flags); spin_lock_irqsave(&priv->rxfidx_lock, flags);
@@ -927,8 +932,8 @@ mpt_lan_receive_post_free(struct net_device *dev,
// dlprintk((KERN_INFO MYNAM "@rpr[2] TC + 3\n")); // dlprintk((KERN_INFO MYNAM "@rpr[2] TC + 3\n"));
priv->RcvCtl[ctx].skb = NULL; priv->RcvCtl[ctx].skb = NULL;
pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma, dma_unmap_single(&mpt_dev->pcidev->dev, priv->RcvCtl[ctx].dma,
priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE); priv->RcvCtl[ctx].len, DMA_FROM_DEVICE);
dev_kfree_skb_any(skb); dev_kfree_skb_any(skb);
priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx; priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
@@ -1028,16 +1033,16 @@ mpt_lan_receive_post_reply(struct net_device *dev,
// IOC_AND_NETDEV_NAMES_s_s(dev), // IOC_AND_NETDEV_NAMES_s_s(dev),
// i, l)); // i, l));
pci_dma_sync_single_for_cpu(mpt_dev->pcidev, dma_sync_single_for_cpu(&mpt_dev->pcidev->dev,
priv->RcvCtl[ctx].dma, priv->RcvCtl[ctx].dma,
priv->RcvCtl[ctx].len, priv->RcvCtl[ctx].len,
PCI_DMA_FROMDEVICE); DMA_FROM_DEVICE);
skb_copy_from_linear_data(old_skb, skb_put(skb, l), l); skb_copy_from_linear_data(old_skb, skb_put(skb, l), l);
pci_dma_sync_single_for_device(mpt_dev->pcidev, dma_sync_single_for_device(&mpt_dev->pcidev->dev,
priv->RcvCtl[ctx].dma, priv->RcvCtl[ctx].dma,
priv->RcvCtl[ctx].len, priv->RcvCtl[ctx].len,
PCI_DMA_FROMDEVICE); DMA_FROM_DEVICE);
priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx; priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
szrem -= l; szrem -= l;
@@ -1056,17 +1061,17 @@ mpt_lan_receive_post_reply(struct net_device *dev,
return -ENOMEM; return -ENOMEM;
} }
pci_dma_sync_single_for_cpu(mpt_dev->pcidev, dma_sync_single_for_cpu(&mpt_dev->pcidev->dev,
priv->RcvCtl[ctx].dma, priv->RcvCtl[ctx].dma,
priv->RcvCtl[ctx].len, priv->RcvCtl[ctx].len,
PCI_DMA_FROMDEVICE); DMA_FROM_DEVICE);
skb_copy_from_linear_data(old_skb, skb_put(skb, len), len); skb_copy_from_linear_data(old_skb, skb_put(skb, len), len);
pci_dma_sync_single_for_device(mpt_dev->pcidev, dma_sync_single_for_device(&mpt_dev->pcidev->dev,
priv->RcvCtl[ctx].dma, priv->RcvCtl[ctx].dma,
priv->RcvCtl[ctx].len, priv->RcvCtl[ctx].len,
PCI_DMA_FROMDEVICE); DMA_FROM_DEVICE);
spin_lock_irqsave(&priv->rxfidx_lock, flags); spin_lock_irqsave(&priv->rxfidx_lock, flags);
priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx; priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
@@ -1077,8 +1082,8 @@ mpt_lan_receive_post_reply(struct net_device *dev,
priv->RcvCtl[ctx].skb = NULL; priv->RcvCtl[ctx].skb = NULL;
pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma, dma_unmap_single(&mpt_dev->pcidev->dev, priv->RcvCtl[ctx].dma,
priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE); priv->RcvCtl[ctx].len, DMA_FROM_DEVICE);
priv->RcvCtl[ctx].dma = 0; priv->RcvCtl[ctx].dma = 0;
priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx; priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
@@ -1199,10 +1204,10 @@ mpt_lan_post_receive_buckets(struct mpt_lan_priv *priv)
skb = priv->RcvCtl[ctx].skb; skb = priv->RcvCtl[ctx].skb;
if (skb && (priv->RcvCtl[ctx].len != len)) { if (skb && (priv->RcvCtl[ctx].len != len)) {
pci_unmap_single(mpt_dev->pcidev, dma_unmap_single(&mpt_dev->pcidev->dev,
priv->RcvCtl[ctx].dma, priv->RcvCtl[ctx].dma,
priv->RcvCtl[ctx].len, priv->RcvCtl[ctx].len,
PCI_DMA_FROMDEVICE); DMA_FROM_DEVICE);
dev_kfree_skb(priv->RcvCtl[ctx].skb); dev_kfree_skb(priv->RcvCtl[ctx].skb);
skb = priv->RcvCtl[ctx].skb = NULL; skb = priv->RcvCtl[ctx].skb = NULL;
} }
@@ -1218,8 +1223,9 @@ mpt_lan_post_receive_buckets(struct mpt_lan_priv *priv)
break; break;
} }
dma = pci_map_single(mpt_dev->pcidev, skb->data, dma = dma_map_single(&mpt_dev->pcidev->dev,
len, PCI_DMA_FROMDEVICE); skb->data, len,
DMA_FROM_DEVICE);
priv->RcvCtl[ctx].skb = skb; priv->RcvCtl[ctx].skb = skb;
priv->RcvCtl[ctx].dma = dma; priv->RcvCtl[ctx].dma = dma;

94
drivers/message/fusion/mptsas.c
View File

@@ -702,8 +702,8 @@ mptsas_add_device_component_starget_ir(MPT_ADAPTER *ioc,
if (!hdr.PageLength) if (!hdr.PageLength)
goto out; goto out;
buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
&dma_handle); &dma_handle, GFP_KERNEL);
if (!buffer) if (!buffer)
goto out; goto out;
@@ -769,8 +769,8 @@ mptsas_add_device_component_starget_ir(MPT_ADAPTER *ioc,
out: out:
if (buffer) if (buffer)
pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer, dma_free_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
dma_handle); buffer, dma_handle);
} }
/** /**
@@ -1399,8 +1399,8 @@ mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,
goto out; goto out;
} }
buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
&dma_handle); &dma_handle, GFP_KERNEL);
if (!buffer) { if (!buffer) {
error = -ENOMEM; error = -ENOMEM;
goto out; goto out;
@@ -1426,8 +1426,8 @@ mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,
enclosure->sep_channel = buffer->SEPBus; enclosure->sep_channel = buffer->SEPBus;
out_free_consistent: out_free_consistent:
pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
buffer, dma_handle); dma_handle);
out: out:
return error; return error;
} }
@@ -2058,8 +2058,8 @@ static int mptsas_get_linkerrors(struct sas_phy *phy)
if (!hdr.ExtPageLength) if (!hdr.ExtPageLength)
return -ENXIO; return -ENXIO;
buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
&dma_handle); &dma_handle, GFP_KERNEL);
if (!buffer) if (!buffer)
return -ENOMEM; return -ENOMEM;
@@ -2081,8 +2081,8 @@ static int mptsas_get_linkerrors(struct sas_phy *phy)
le32_to_cpu(buffer->PhyResetProblemCount); le32_to_cpu(buffer->PhyResetProblemCount);
out_free_consistent: out_free_consistent:
pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
buffer, dma_handle); dma_handle);
return error; return error;
} }
@@ -2301,7 +2301,7 @@ static void mptsas_smp_handler(struct bsg_job *job, struct Scsi_Host *shost,
<< MPI_SGE_FLAGS_SHIFT; << MPI_SGE_FLAGS_SHIFT;
if (!dma_map_sg(&ioc->pcidev->dev, job->request_payload.sg_list, if (!dma_map_sg(&ioc->pcidev->dev, job->request_payload.sg_list,
1, PCI_DMA_BIDIRECTIONAL)) 1, DMA_BIDIRECTIONAL))
goto put_mf; goto put_mf;
flagsLength |= (sg_dma_len(job->request_payload.sg_list) - 4); flagsLength |= (sg_dma_len(job->request_payload.sg_list) - 4);
@@ -2318,7 +2318,7 @@ static void mptsas_smp_handler(struct bsg_job *job, struct Scsi_Host *shost,
flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT; flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
if (!dma_map_sg(&ioc->pcidev->dev, job->reply_payload.sg_list, if (!dma_map_sg(&ioc->pcidev->dev, job->reply_payload.sg_list,
1, PCI_DMA_BIDIRECTIONAL)) 1, DMA_BIDIRECTIONAL))
goto unmap_out; goto unmap_out;
flagsLength |= sg_dma_len(job->reply_payload.sg_list) + 4; flagsLength |= sg_dma_len(job->reply_payload.sg_list) + 4;
ioc->add_sge(psge, flagsLength, ioc->add_sge(psge, flagsLength,
@@ -2356,10 +2356,10 @@ static void mptsas_smp_handler(struct bsg_job *job, struct Scsi_Host *shost,
unmap_in: unmap_in:
dma_unmap_sg(&ioc->pcidev->dev, job->reply_payload.sg_list, 1, dma_unmap_sg(&ioc->pcidev->dev, job->reply_payload.sg_list, 1,
PCI_DMA_BIDIRECTIONAL); DMA_BIDIRECTIONAL);
unmap_out: unmap_out:
dma_unmap_sg(&ioc->pcidev->dev, job->request_payload.sg_list, 1, dma_unmap_sg(&ioc->pcidev->dev, job->request_payload.sg_list, 1,
PCI_DMA_BIDIRECTIONAL); DMA_BIDIRECTIONAL);
put_mf: put_mf:
if (mf) if (mf)
mpt_free_msg_frame(ioc, mf); mpt_free_msg_frame(ioc, mf);
@@ -2412,8 +2412,8 @@ mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
goto out; goto out;
} }
buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
&dma_handle); &dma_handle, GFP_KERNEL);
if (!buffer) { if (!buffer) {
error = -ENOMEM; error = -ENOMEM;
goto out; goto out;
@@ -2452,8 +2452,8 @@ mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
} }
out_free_consistent: out_free_consistent:
pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
buffer, dma_handle); dma_handle);
out: out:
return error; return error;
} }
@@ -2487,8 +2487,8 @@ mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc)
goto out; goto out;
} }
buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
&dma_handle); &dma_handle, GFP_KERNEL);
if (!buffer) { if (!buffer) {
error = -ENOMEM; error = -ENOMEM;
goto out; goto out;
@@ -2509,8 +2509,8 @@ mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc)
device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK; device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
out_free_consistent: out_free_consistent:
pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
buffer, dma_handle); dma_handle);
out: out:
return error; return error;
} }
@@ -2551,8 +2551,8 @@ mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
goto out; goto out;
} }
buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
&dma_handle); &dma_handle, GFP_KERNEL);
if (!buffer) { if (!buffer) {
error = -ENOMEM; error = -ENOMEM;
goto out; goto out;
@@ -2573,8 +2573,8 @@ mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle); phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
out_free_consistent: out_free_consistent:
pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
buffer, dma_handle); dma_handle);
out: out:
return error; return error;
} }
@@ -2614,8 +2614,8 @@ mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
goto out; goto out;
} }
buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
&dma_handle); &dma_handle, GFP_KERNEL);
if (!buffer) { if (!buffer) {
error = -ENOMEM; error = -ENOMEM;
goto out; goto out;
@@ -2654,8 +2654,8 @@ mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
device_info->flags = le16_to_cpu(buffer->Flags); device_info->flags = le16_to_cpu(buffer->Flags);
out_free_consistent: out_free_consistent:
pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
buffer, dma_handle); dma_handle);
out: out:
return error; return error;
} }
@@ -2697,8 +2697,8 @@ mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info,
goto out; goto out;
} }
buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
&dma_handle); &dma_handle, GFP_KERNEL);
if (!buffer) { if (!buffer) {
error = -ENOMEM; error = -ENOMEM;
goto out; goto out;
@@ -2737,8 +2737,8 @@ mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info,
} }
out_free_consistent: out_free_consistent:
pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
buffer, dma_handle); dma_handle);
out: out:
return error; return error;
} }
@@ -2777,8 +2777,8 @@ mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
goto out; goto out;
} }
buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
&dma_handle); &dma_handle, GFP_KERNEL);
if (!buffer) { if (!buffer) {
error = -ENOMEM; error = -ENOMEM;
goto out; goto out;
@@ -2810,8 +2810,8 @@ mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle); phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
out_free_consistent: out_free_consistent:
pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
buffer, dma_handle); dma_handle);
out: out:
return error; return error;
} }
@@ -2896,7 +2896,8 @@ mptsas_exp_repmanufacture_info(MPT_ADAPTER *ioc,
sz = sizeof(struct rep_manu_request) + sizeof(struct rep_manu_reply); sz = sizeof(struct rep_manu_request) + sizeof(struct rep_manu_reply);
data_out = pci_alloc_consistent(ioc->pcidev, sz, &data_out_dma); data_out = dma_alloc_coherent(&ioc->pcidev->dev, sz, &data_out_dma,
GFP_KERNEL);
if (!data_out) { if (!data_out) {
printk(KERN_ERR "Memory allocation failure at %s:%d/%s()!\n", printk(KERN_ERR "Memory allocation failure at %s:%d/%s()!\n",
__FILE__, __LINE__, __func__); __FILE__, __LINE__, __func__);
@@ -2987,7 +2988,8 @@ mptsas_exp_repmanufacture_info(MPT_ADAPTER *ioc,
} }
out_free: out_free:
if (data_out_dma) if (data_out_dma)
pci_free_consistent(ioc->pcidev, sz, data_out, data_out_dma); dma_free_coherent(&ioc->pcidev->dev, sz, data_out,
data_out_dma);
put_mf: put_mf:
if (mf) if (mf)
mpt_free_msg_frame(ioc, mf); mpt_free_msg_frame(ioc, mf);
@@ -4271,8 +4273,8 @@ mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id)
if (!hdr.PageLength) if (!hdr.PageLength)
goto out; goto out;
buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
&dma_handle); &dma_handle, GFP_KERNEL);
if (!buffer) if (!buffer)
goto out; goto out;
@@ -4318,8 +4320,8 @@ mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id)
out: out:
if (buffer) if (buffer)
pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer, dma_free_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
dma_handle); buffer, dma_handle);
} }
/* /*
* Work queue thread to handle SAS hotplug events * Work queue thread to handle SAS hotplug events

2
drivers/scsi/aacraid/aachba.c
View File

@@ -271,7 +271,7 @@ MODULE_PARM_DESC(msi, "IRQ handling."
" 0=PIC(default), 1=MSI, 2=MSI-X)"); " 0=PIC(default), 1=MSI, 2=MSI-X)");
module_param(startup_timeout, int, S_IRUGO|S_IWUSR); module_param(startup_timeout, int, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(startup_timeout, "The duration of time in seconds to wait for" MODULE_PARM_DESC(startup_timeout, "The duration of time in seconds to wait for"
" adapter to have it's kernel up and\n" " adapter to have its kernel up and\n"
"running. This is typically adjusted for large systems that do not" "running. This is typically adjusted for large systems that do not"
" have a BIOS."); " have a BIOS.");
module_param(aif_timeout, int, S_IRUGO|S_IWUSR); module_param(aif_timeout, int, S_IRUGO|S_IWUSR);

6
drivers/scsi/aic7xxx/aic79xx_osm.c
View File

@@ -755,11 +755,7 @@ ahd_linux_biosparam(struct scsi_device *sdev, struct block_device *bdev,
static int static int
ahd_linux_abort(struct scsi_cmnd *cmd) ahd_linux_abort(struct scsi_cmnd *cmd)
{ {
int error; return ahd_linux_queue_abort_cmd(cmd);
error = ahd_linux_queue_abort_cmd(cmd);
return error;
} }
/* /*

11
drivers/scsi/elx/efct/efct_driver.c
View File

@@ -541,13 +541,10 @@ efct_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
pci_set_drvdata(pdev, efct); pci_set_drvdata(pdev, efct);
if (dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)) != 0) { rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
dev_warn(&pdev->dev, "trying DMA_BIT_MASK(32)\n"); if (rc) {
if (dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)) != 0) { dev_err(&pdev->dev, "setting DMA_BIT_MASK failed\n");
dev_err(&pdev->dev, "setting DMA_BIT_MASK failed\n"); goto dma_mask_out;
rc = -1;
goto dma_mask_out;
}
} }
num_interrupts = efct_device_interrupts_required(efct); num_interrupts = efct_device_interrupts_required(efct);

5
drivers/scsi/hisi_sas/hisi_sas_main.c
View File

@@ -1525,16 +1525,11 @@ static void hisi_sas_send_ata_reset_each_phy(struct hisi_hba *hisi_hba,
struct device *dev = hisi_hba->dev; struct device *dev = hisi_hba->dev;
int s = sizeof(struct host_to_dev_fis); int s = sizeof(struct host_to_dev_fis);
int rc = TMF_RESP_FUNC_FAILED; int rc = TMF_RESP_FUNC_FAILED;
struct asd_sas_phy *sas_phy;
struct ata_link *link; struct ata_link *link;
u8 fis[20] = {0}; u8 fis[20] = {0};
u32 state;
int i; int i;
state = hisi_hba->hw->get_phys_state(hisi_hba);
for (i = 0; i < hisi_hba->n_phy; i++) { for (i = 0; i < hisi_hba->n_phy; i++) {
if (!(state & BIT(sas_phy->id)))
continue;
if (!(sas_port->phy_mask & BIT(i))) if (!(sas_port->phy_mask & BIT(i)))
continue; continue;

84
drivers/scsi/megaraid.c
View File

@@ -192,23 +192,21 @@ mega_query_adapter(adapter_t *adapter)
{ {
dma_addr_t prod_info_dma_handle; dma_addr_t prod_info_dma_handle;
mega_inquiry3 *inquiry3; mega_inquiry3 *inquiry3;
u8 raw_mbox[sizeof(struct mbox_out)]; struct mbox_out mbox;
mbox_t *mbox; u8 *raw_mbox = (u8 *)&mbox;
int retval; int retval;
/* Initialize adapter inquiry mailbox */ /* Initialize adapter inquiry mailbox */
mbox = (mbox_t *)raw_mbox;
memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE); memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE);
memset(&mbox->m_out, 0, sizeof(raw_mbox)); memset(&mbox, 0, sizeof(mbox));
/* /*
* Try to issue Inquiry3 command * Try to issue Inquiry3 command
* if not succeeded, then issue MEGA_MBOXCMD_ADAPTERINQ command and * if not succeeded, then issue MEGA_MBOXCMD_ADAPTERINQ command and
* update enquiry3 structure * update enquiry3 structure
*/ */
mbox->m_out.xferaddr = (u32)adapter->buf_dma_handle; mbox.xferaddr = (u32)adapter->buf_dma_handle;
inquiry3 = (mega_inquiry3 *)adapter->mega_buffer; inquiry3 = (mega_inquiry3 *)adapter->mega_buffer;
@@ -232,10 +230,10 @@ mega_query_adapter(adapter_t *adapter)
inq = &ext_inq->raid_inq; inq = &ext_inq->raid_inq;
mbox->m_out.xferaddr = (u32)dma_handle; mbox.xferaddr = (u32)dma_handle;
/*issue old 0x04 command to adapter */ /*issue old 0x04 command to adapter */
mbox->m_out.cmd = MEGA_MBOXCMD_ADPEXTINQ; mbox.cmd = MEGA_MBOXCMD_ADPEXTINQ;
issue_scb_block(adapter, raw_mbox); issue_scb_block(adapter, raw_mbox);
@@ -262,7 +260,7 @@ mega_query_adapter(adapter_t *adapter)
sizeof(mega_product_info), sizeof(mega_product_info),
DMA_FROM_DEVICE); DMA_FROM_DEVICE);
mbox->m_out.xferaddr = prod_info_dma_handle; mbox.xferaddr = prod_info_dma_handle;
raw_mbox[0] = FC_NEW_CONFIG; /* i.e. mbox->cmd=0xA1 */ raw_mbox[0] = FC_NEW_CONFIG; /* i.e. mbox->cmd=0xA1 */
raw_mbox[2] = NC_SUBOP_PRODUCT_INFO; /* i.e. 0x0E */ raw_mbox[2] = NC_SUBOP_PRODUCT_INFO; /* i.e. 0x0E */
@@ -3569,16 +3567,14 @@ mega_n_to_m(void __user *arg, megacmd_t *mc)
static int static int
mega_is_bios_enabled(adapter_t *adapter) mega_is_bios_enabled(adapter_t *adapter)
{ {
unsigned char raw_mbox[sizeof(struct mbox_out)]; struct mbox_out mbox;
mbox_t *mbox; unsigned char *raw_mbox = (u8 *)&mbox;
mbox = (mbox_t *)raw_mbox; memset(&mbox, 0, sizeof(mbox));
memset(&mbox->m_out, 0, sizeof(raw_mbox));
memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE); memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE);
mbox->m_out.xferaddr = (u32)adapter->buf_dma_handle; mbox.xferaddr = (u32)adapter->buf_dma_handle;
raw_mbox[0] = IS_BIOS_ENABLED; raw_mbox[0] = IS_BIOS_ENABLED;
raw_mbox[2] = GET_BIOS; raw_mbox[2] = GET_BIOS;
@@ -3600,13 +3596,11 @@ mega_is_bios_enabled(adapter_t *adapter)
static void static void
mega_enum_raid_scsi(adapter_t *adapter) mega_enum_raid_scsi(adapter_t *adapter)
{ {
unsigned char raw_mbox[sizeof(struct mbox_out)]; struct mbox_out mbox;
mbox_t *mbox; unsigned char *raw_mbox = (u8 *)&mbox;
int i; int i;
mbox = (mbox_t *)raw_mbox; memset(&mbox, 0, sizeof(mbox));
memset(&mbox->m_out, 0, sizeof(raw_mbox));
/* /*
* issue command to find out what channels are raid/scsi * issue command to find out what channels are raid/scsi
@@ -3616,7 +3610,7 @@ mega_enum_raid_scsi(adapter_t *adapter)
memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE); memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE);
mbox->m_out.xferaddr = (u32)adapter->buf_dma_handle; mbox.xferaddr = (u32)adapter->buf_dma_handle;
/* /*
* Non-ROMB firmware fail this command, so all channels * Non-ROMB firmware fail this command, so all channels
@@ -3655,23 +3649,21 @@ static void
mega_get_boot_drv(adapter_t *adapter) mega_get_boot_drv(adapter_t *adapter)
{ {
struct private_bios_data *prv_bios_data; struct private_bios_data *prv_bios_data;
unsigned char raw_mbox[sizeof(struct mbox_out)]; struct mbox_out mbox;
mbox_t *mbox; unsigned char *raw_mbox = (u8 *)&mbox;
u16 cksum = 0; u16 cksum = 0;
u8 *cksum_p; u8 *cksum_p;
u8 boot_pdrv; u8 boot_pdrv;
int i; int i;
mbox = (mbox_t *)raw_mbox; memset(&mbox, 0, sizeof(mbox));
memset(&mbox->m_out, 0, sizeof(raw_mbox));
raw_mbox[0] = BIOS_PVT_DATA; raw_mbox[0] = BIOS_PVT_DATA;
raw_mbox[2] = GET_BIOS_PVT_DATA; raw_mbox[2] = GET_BIOS_PVT_DATA;
memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE); memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE);
mbox->m_out.xferaddr = (u32)adapter->buf_dma_handle; mbox.xferaddr = (u32)adapter->buf_dma_handle;
adapter->boot_ldrv_enabled = 0; adapter->boot_ldrv_enabled = 0;
adapter->boot_ldrv = 0; adapter->boot_ldrv = 0;
@@ -3721,13 +3713,11 @@ mega_get_boot_drv(adapter_t *adapter)
static int static int
mega_support_random_del(adapter_t *adapter) mega_support_random_del(adapter_t *adapter)
{ {
unsigned char raw_mbox[sizeof(struct mbox_out)]; struct mbox_out mbox;
mbox_t *mbox; unsigned char *raw_mbox = (u8 *)&mbox;
int rval; int rval;
mbox = (mbox_t *)raw_mbox; memset(&mbox, 0, sizeof(mbox));
memset(&mbox->m_out, 0, sizeof(raw_mbox));
/* /*
* issue command * issue command
@@ -3750,13 +3740,11 @@ mega_support_random_del(adapter_t *adapter)
static int static int
mega_support_ext_cdb(adapter_t *adapter) mega_support_ext_cdb(adapter_t *adapter)
{ {
unsigned char raw_mbox[sizeof(struct mbox_out)]; struct mbox_out mbox;
mbox_t *mbox; unsigned char *raw_mbox = (u8 *)&mbox;
int rval; int rval;
mbox = (mbox_t *)raw_mbox; memset(&mbox, 0, sizeof(mbox));
memset(&mbox->m_out, 0, sizeof(raw_mbox));
/* /*
* issue command to find out if controller supports extended CDBs. * issue command to find out if controller supports extended CDBs.
*/ */
@@ -3865,16 +3853,14 @@ mega_do_del_logdrv(adapter_t *adapter, int logdrv)
static void static void
mega_get_max_sgl(adapter_t *adapter) mega_get_max_sgl(adapter_t *adapter)
{ {
unsigned char raw_mbox[sizeof(struct mbox_out)]; struct mbox_out mbox;
mbox_t *mbox; unsigned char *raw_mbox = (u8 *)&mbox;
mbox = (mbox_t *)raw_mbox; memset(&mbox, 0, sizeof(mbox));
memset(mbox, 0, sizeof(raw_mbox));
memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE); memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE);
mbox->m_out.xferaddr = (u32)adapter->buf_dma_handle; mbox.xferaddr = (u32)adapter->buf_dma_handle;
raw_mbox[0] = MAIN_MISC_OPCODE; raw_mbox[0] = MAIN_MISC_OPCODE;
raw_mbox[2] = GET_MAX_SG_SUPPORT; raw_mbox[2] = GET_MAX_SG_SUPPORT;
@@ -3888,7 +3874,7 @@ mega_get_max_sgl(adapter_t *adapter)
} }
else { else {
adapter->sglen = *((char *)adapter->mega_buffer); adapter->sglen = *((char *)adapter->mega_buffer);
/* /*
* Make sure this is not more than the resources we are * Make sure this is not more than the resources we are
* planning to allocate * planning to allocate
@@ -3910,16 +3896,14 @@ mega_get_max_sgl(adapter_t *adapter)
static int static int
mega_support_cluster(adapter_t *adapter) mega_support_cluster(adapter_t *adapter)
{ {
unsigned char raw_mbox[sizeof(struct mbox_out)]; struct mbox_out mbox;
mbox_t *mbox; unsigned char *raw_mbox = (u8 *)&mbox;
mbox = (mbox_t *)raw_mbox; memset(&mbox, 0, sizeof(mbox));
memset(mbox, 0, sizeof(raw_mbox));
memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE); memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE);
mbox->m_out.xferaddr = (u32)adapter->buf_dma_handle; mbox.xferaddr = (u32)adapter->buf_dma_handle;
/* /*
* Try to get the initiator id. This command will succeed iff the * Try to get the initiator id. This command will succeed iff the

11
drivers/scsi/mpi3mr/mpi3mr_fw.c
View File

@@ -901,7 +901,7 @@ static const struct {
}, },
{ MPI3MR_RESET_FROM_SYSFS, "sysfs invocation" }, { MPI3MR_RESET_FROM_SYSFS, "sysfs invocation" },
{ MPI3MR_RESET_FROM_SYSFS_TIMEOUT, "sysfs TM timeout" }, { MPI3MR_RESET_FROM_SYSFS_TIMEOUT, "sysfs TM timeout" },
{ MPI3MR_RESET_FROM_FIRMWARE, "firmware asynchronus reset" }, { MPI3MR_RESET_FROM_FIRMWARE, "firmware asynchronous reset" },
}; };
/** /**
@@ -1242,7 +1242,7 @@ static int mpi3mr_bring_ioc_ready(struct mpi3mr_ioc *mrioc)
ioc_state = mpi3mr_get_iocstate(mrioc); ioc_state = mpi3mr_get_iocstate(mrioc);
if (ioc_state == MRIOC_STATE_READY) { if (ioc_state == MRIOC_STATE_READY) {
ioc_info(mrioc, ioc_info(mrioc,
"successfully transistioned to %s state\n", "successfully transitioned to %s state\n",
mpi3mr_iocstate_name(ioc_state)); mpi3mr_iocstate_name(ioc_state));
return 0; return 0;
} }
@@ -2174,7 +2174,7 @@ out:
* mpi3mr_check_rh_fault_ioc - check reset history and fault * mpi3mr_check_rh_fault_ioc - check reset history and fault
* controller * controller
* @mrioc: Adapter instance reference * @mrioc: Adapter instance reference
* @reason_code, reason code for the fault. * @reason_code: reason code for the fault.
* *
* This routine will save snapdump and fault the controller with * This routine will save snapdump and fault the controller with
* the given reason code if it is not already in the fault or * the given reason code if it is not already in the fault or
@@ -3633,7 +3633,6 @@ static int mpi3mr_enable_events(struct mpi3mr_ioc *mrioc)
/** /**
* mpi3mr_init_ioc - Initialize the controller * mpi3mr_init_ioc - Initialize the controller
* @mrioc: Adapter instance reference * @mrioc: Adapter instance reference
* @init_type: Flag to indicate is the init_type
* *
* This the controller initialization routine, executed either * This the controller initialization routine, executed either
* after soft reset or from pci probe callback. * after soft reset or from pci probe callback.
@@ -3844,7 +3843,7 @@ retry_init:
if (mrioc->shost->nr_hw_queues > mrioc->num_op_reply_q) { if (mrioc->shost->nr_hw_queues > mrioc->num_op_reply_q) {
ioc_err(mrioc, ioc_err(mrioc,
"cannot create minimum number of operatioanl queues expected:%d created:%d\n", "cannot create minimum number of operational queues expected:%d created:%d\n",
mrioc->shost->nr_hw_queues, mrioc->num_op_reply_q); mrioc->shost->nr_hw_queues, mrioc->num_op_reply_q);
goto out_failed_noretry; goto out_failed_noretry;
} }
@@ -4174,7 +4173,7 @@ static void mpi3mr_issue_ioc_shutdown(struct mpi3mr_ioc *mrioc)
/** /**
* mpi3mr_cleanup_ioc - Cleanup controller * mpi3mr_cleanup_ioc - Cleanup controller
* @mrioc: Adapter instance reference * @mrioc: Adapter instance reference
*
* controller cleanup handler, Message unit reset or soft reset * controller cleanup handler, Message unit reset or soft reset
* and shutdown notification is issued to the controller. * and shutdown notification is issued to the controller.
* *

4
drivers/scsi/mpt3sas/mpt3sas_base.h
View File

@@ -77,8 +77,8 @@
#define MPT3SAS_DRIVER_NAME "mpt3sas" #define MPT3SAS_DRIVER_NAME "mpt3sas"
#define MPT3SAS_AUTHOR "Avago Technologies <MPT-FusionLinux.pdl@avagotech.com>" #define MPT3SAS_AUTHOR "Avago Technologies <MPT-FusionLinux.pdl@avagotech.com>"
#define MPT3SAS_DESCRIPTION "LSI MPT Fusion SAS 3.0 Device Driver" #define MPT3SAS_DESCRIPTION "LSI MPT Fusion SAS 3.0 Device Driver"
#define MPT3SAS_DRIVER_VERSION "39.100.00.00" #define MPT3SAS_DRIVER_VERSION "40.100.00.00"
#define MPT3SAS_MAJOR_VERSION 39 #define MPT3SAS_MAJOR_VERSION 40
#define MPT3SAS_MINOR_VERSION 100 #define MPT3SAS_MINOR_VERSION 100
#define MPT3SAS_BUILD_VERSION 0 #define MPT3SAS_BUILD_VERSION 0
#define MPT3SAS_RELEASE_VERSION 00 #define MPT3SAS_RELEASE_VERSION 00

87
drivers/scsi/mpt3sas/mpt3sas_ctl.c
View File

@@ -3533,11 +3533,31 @@ diag_trigger_master_store(struct device *cdev,
{ {
struct Scsi_Host *shost = class_to_shost(cdev); struct Scsi_Host *shost = class_to_shost(cdev);
struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
struct SL_WH_MASTER_TRIGGER_T *master_tg;
unsigned long flags; unsigned long flags;
ssize_t rc; ssize_t rc;
bool set = 1;
rc = min(sizeof(struct SL_WH_MASTER_TRIGGER_T), count);
if (ioc->supports_trigger_pages) {
master_tg = kzalloc(sizeof(struct SL_WH_MASTER_TRIGGER_T),
GFP_KERNEL);
if (!master_tg)
return -ENOMEM;
memcpy(master_tg, buf, rc);
if (!master_tg->MasterData)
set = 0;
if (mpt3sas_config_update_driver_trigger_pg1(ioc, master_tg,
set)) {
kfree(master_tg);
return -EFAULT;
}
kfree(master_tg);
}
spin_lock_irqsave(&ioc->diag_trigger_lock, flags); spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
rc = min(sizeof(struct SL_WH_MASTER_TRIGGER_T), count);
memset(&ioc->diag_trigger_master, 0, memset(&ioc->diag_trigger_master, 0,
sizeof(struct SL_WH_MASTER_TRIGGER_T)); sizeof(struct SL_WH_MASTER_TRIGGER_T));
memcpy(&ioc->diag_trigger_master, buf, rc); memcpy(&ioc->diag_trigger_master, buf, rc);
@@ -3589,11 +3609,31 @@ diag_trigger_event_store(struct device *cdev,
{ {
struct Scsi_Host *shost = class_to_shost(cdev); struct Scsi_Host *shost = class_to_shost(cdev);
struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
struct SL_WH_EVENT_TRIGGERS_T *event_tg;
unsigned long flags; unsigned long flags;
ssize_t sz; ssize_t sz;
bool set = 1;
sz = min(sizeof(struct SL_WH_EVENT_TRIGGERS_T), count);
if (ioc->supports_trigger_pages) {
event_tg = kzalloc(sizeof(struct SL_WH_EVENT_TRIGGERS_T),
GFP_KERNEL);
if (!event_tg)
return -ENOMEM;
memcpy(event_tg, buf, sz);
if (!event_tg->ValidEntries)
set = 0;
if (mpt3sas_config_update_driver_trigger_pg2(ioc, event_tg,
set)) {
kfree(event_tg);
return -EFAULT;
}
kfree(event_tg);
}
spin_lock_irqsave(&ioc->diag_trigger_lock, flags); spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
sz = min(sizeof(struct SL_WH_EVENT_TRIGGERS_T), count);
memset(&ioc->diag_trigger_event, 0, memset(&ioc->diag_trigger_event, 0,
sizeof(struct SL_WH_EVENT_TRIGGERS_T)); sizeof(struct SL_WH_EVENT_TRIGGERS_T));
memcpy(&ioc->diag_trigger_event, buf, sz); memcpy(&ioc->diag_trigger_event, buf, sz);
@@ -3644,11 +3684,31 @@ diag_trigger_scsi_store(struct device *cdev,
{ {
struct Scsi_Host *shost = class_to_shost(cdev); struct Scsi_Host *shost = class_to_shost(cdev);
struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
struct SL_WH_SCSI_TRIGGERS_T *scsi_tg;
unsigned long flags; unsigned long flags;
ssize_t sz; ssize_t sz;
bool set = 1;
sz = min(sizeof(struct SL_WH_SCSI_TRIGGERS_T), count);
if (ioc->supports_trigger_pages) {
scsi_tg = kzalloc(sizeof(struct SL_WH_SCSI_TRIGGERS_T),
GFP_KERNEL);
if (!scsi_tg)
return -ENOMEM;
memcpy(scsi_tg, buf, sz);
if (!scsi_tg->ValidEntries)
set = 0;
if (mpt3sas_config_update_driver_trigger_pg3(ioc, scsi_tg,
set)) {
kfree(scsi_tg);
return -EFAULT;
}
kfree(scsi_tg);
}
spin_lock_irqsave(&ioc->diag_trigger_lock, flags); spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
sz = min(sizeof(ioc->diag_trigger_scsi), count);
memset(&ioc->diag_trigger_scsi, 0, sizeof(ioc->diag_trigger_scsi)); memset(&ioc->diag_trigger_scsi, 0, sizeof(ioc->diag_trigger_scsi));
memcpy(&ioc->diag_trigger_scsi, buf, sz); memcpy(&ioc->diag_trigger_scsi, buf, sz);
if (ioc->diag_trigger_scsi.ValidEntries > NUM_VALID_ENTRIES) if (ioc->diag_trigger_scsi.ValidEntries > NUM_VALID_ENTRIES)
@@ -3698,11 +3758,30 @@ diag_trigger_mpi_store(struct device *cdev,
{ {
struct Scsi_Host *shost = class_to_shost(cdev); struct Scsi_Host *shost = class_to_shost(cdev);
struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
struct SL_WH_MPI_TRIGGERS_T *mpi_tg;
unsigned long flags; unsigned long flags;
ssize_t sz; ssize_t sz;
bool set = 1;
sz = min(sizeof(struct SL_WH_MPI_TRIGGERS_T), count);
if (ioc->supports_trigger_pages) {
mpi_tg = kzalloc(sizeof(struct SL_WH_MPI_TRIGGERS_T),
GFP_KERNEL);
if (!mpi_tg)
return -ENOMEM;
memcpy(mpi_tg, buf, sz);
if (!mpi_tg->ValidEntries)
set = 0;
if (mpt3sas_config_update_driver_trigger_pg4(ioc, mpi_tg,
set)) {
kfree(mpi_tg);
return -EFAULT;
}
kfree(mpi_tg);
}
spin_lock_irqsave(&ioc->diag_trigger_lock, flags); spin_lock_irqsave(&ioc->diag_trigger_lock, flags);
sz = min(sizeof(struct SL_WH_MPI_TRIGGERS_T), count);
memset(&ioc->diag_trigger_mpi, 0, memset(&ioc->diag_trigger_mpi, 0,
sizeof(ioc->diag_trigger_mpi)); sizeof(ioc->diag_trigger_mpi));
memcpy(&ioc->diag_trigger_mpi, buf, sz); memcpy(&ioc->diag_trigger_mpi, buf, sz);

3
drivers/scsi/pcmcia/nsp_cs.c
View File

@@ -1557,6 +1557,9 @@ static int nsp_cs_config_check(struct pcmcia_device *p_dev, void *priv_data)
data->MmioAddress = (unsigned long) data->MmioAddress = (unsigned long)
ioremap(p_dev->resource[2]->start, ioremap(p_dev->resource[2]->start,
resource_size(p_dev->resource[2])); resource_size(p_dev->resource[2]));
if (!data->MmioAddress)
goto next_entry;
data->MmioLength = resource_size(p_dev->resource[2]); data->MmioLength = resource_size(p_dev->resource[2]);
} }
/* If we got this far, we're cool! */ /* If we got this far, we're cool! */

7
drivers/scsi/pm8001/pm8001_sas.c
View File

@@ -1199,7 +1199,7 @@ int pm8001_abort_task(struct sas_task *task)
struct pm8001_device *pm8001_dev; struct pm8001_device *pm8001_dev;
struct pm8001_tmf_task tmf_task; struct pm8001_tmf_task tmf_task;
int rc = TMF_RESP_FUNC_FAILED, ret; int rc = TMF_RESP_FUNC_FAILED, ret;
u32 phy_id; u32 phy_id, port_id;
struct sas_task_slow slow_task; struct sas_task_slow slow_task;
if (unlikely(!task || !task->lldd_task || !task->dev)) if (unlikely(!task || !task->lldd_task || !task->dev))
@@ -1246,6 +1246,7 @@ int pm8001_abort_task(struct sas_task *task)
DECLARE_COMPLETION_ONSTACK(completion_reset); DECLARE_COMPLETION_ONSTACK(completion_reset);
DECLARE_COMPLETION_ONSTACK(completion); DECLARE_COMPLETION_ONSTACK(completion);
struct pm8001_phy *phy = pm8001_ha->phy + phy_id; struct pm8001_phy *phy = pm8001_ha->phy + phy_id;
port_id = phy->port->port_id;
/* 1. Set Device state as Recovery */ /* 1. Set Device state as Recovery */
pm8001_dev->setds_completion = &completion; pm8001_dev->setds_completion = &completion;
@@ -1297,6 +1298,10 @@ int pm8001_abort_task(struct sas_task *task)
PORT_RESET_TMO); PORT_RESET_TMO);
if (phy->port_reset_status == PORT_RESET_TMO) { if (phy->port_reset_status == PORT_RESET_TMO) {
pm8001_dev_gone_notify(dev); pm8001_dev_gone_notify(dev);
PM8001_CHIP_DISP->hw_event_ack_req(
pm8001_ha, 0,
0x07, /*HW_EVENT_PHY_DOWN ack*/
port_id, phy_id, 0, 0);
goto out; goto out;
} }
} }

3
drivers/scsi/pm8001/pm8001_sas.h
View File

@@ -216,6 +216,9 @@ struct pm8001_dispatch {
u32 state); u32 state);
int (*sas_re_init_req)(struct pm8001_hba_info *pm8001_ha); int (*sas_re_init_req)(struct pm8001_hba_info *pm8001_ha);
int (*fatal_errors)(struct pm8001_hba_info *pm8001_ha); int (*fatal_errors)(struct pm8001_hba_info *pm8001_ha);
void (*hw_event_ack_req)(struct pm8001_hba_info *pm8001_ha,
u32 Qnum, u32 SEA, u32 port_id, u32 phyId, u32 param0,
u32 param1);
}; };
struct pm8001_chip_info { struct pm8001_chip_info {

7
drivers/scsi/pm8001/pm80xx_hwi.c
View File

@@ -3712,8 +3712,10 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
break; break;
case HW_EVENT_PORT_RESET_TIMER_TMO: case HW_EVENT_PORT_RESET_TIMER_TMO:
pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PORT_RESET_TIMER_TMO\n"); pm8001_dbg(pm8001_ha, MSG, "HW_EVENT_PORT_RESET_TIMER_TMO\n");
pm80xx_hw_event_ack_req(pm8001_ha, 0, HW_EVENT_PHY_DOWN, if (!pm8001_ha->phy[phy_id].reset_completion) {
port_id, phy_id, 0, 0); pm80xx_hw_event_ack_req(pm8001_ha, 0, HW_EVENT_PHY_DOWN,
port_id, phy_id, 0, 0);
}
sas_phy_disconnected(sas_phy); sas_phy_disconnected(sas_phy);
phy->phy_attached = 0; phy->phy_attached = 0;
sas_notify_port_event(sas_phy, PORTE_LINK_RESET_ERR, sas_notify_port_event(sas_phy, PORTE_LINK_RESET_ERR,
@@ -5055,4 +5057,5 @@ const struct pm8001_dispatch pm8001_80xx_dispatch = {
.fw_flash_update_req = pm8001_chip_fw_flash_update_req, .fw_flash_update_req = pm8001_chip_fw_flash_update_req,
.set_dev_state_req = pm8001_chip_set_dev_state_req, .set_dev_state_req = pm8001_chip_set_dev_state_req,
.fatal_errors = pm80xx_fatal_errors, .fatal_errors = pm80xx_fatal_errors,
.hw_event_ack_req = pm80xx_hw_event_ack_req,
}; };

2
drivers/scsi/qedf/qedf_main.c
View File

@@ -1415,6 +1415,8 @@ static void qedf_upload_connection(struct qedf_ctx *qedf,
*/ */
term_params = dma_alloc_coherent(&qedf->pdev->dev, QEDF_TERM_BUFF_SIZE, term_params = dma_alloc_coherent(&qedf->pdev->dev, QEDF_TERM_BUFF_SIZE,
&term_params_dma, GFP_KERNEL); &term_params_dma, GFP_KERNEL);
if (!term_params)
return;
QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN, "Uploading connection " QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN, "Uploading connection "
"port_id=%06x.\n", fcport->rdata->ids.port_id); "port_id=%06x.\n", fcport->rdata->ids.port_id);

8
drivers/scsi/scsi_lib.c
View File

@@ -2067,7 +2067,6 @@ void scsi_exit_queue(void)
* @sdev: SCSI device to be queried * @sdev: SCSI device to be queried
* @pf: Page format bit (1 == standard, 0 == vendor specific) * @pf: Page format bit (1 == standard, 0 == vendor specific)
* @sp: Save page bit (0 == don't save, 1 == save) * @sp: Save page bit (0 == don't save, 1 == save)
* @modepage: mode page being requested
* @buffer: request buffer (may not be smaller than eight bytes) * @buffer: request buffer (may not be smaller than eight bytes)
* @len: length of request buffer. * @len: length of request buffer.
* @timeout: command timeout * @timeout: command timeout
@@ -2080,10 +2079,9 @@ void scsi_exit_queue(void)
* status on error * status on error
* *
*/ */
int int scsi_mode_select(struct scsi_device *sdev, int pf, int sp,
scsi_mode_select(struct scsi_device *sdev, int pf, int sp, int modepage, unsigned char *buffer, int len, int timeout, int retries,
unsigned char *buffer, int len, int timeout, int retries, struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr)
struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr)
{ {
unsigned char cmd[10]; unsigned char cmd[10];
unsigned char *real_buffer; unsigned char *real_buffer;

2
drivers/scsi/sd.c
View File

@@ -209,7 +209,7 @@ cache_type_store(struct device *dev, struct device_attribute *attr,
*/ */
data.device_specific = 0; data.device_specific = 0;
if (scsi_mode_select(sdp, 1, sp, 8, buffer_data, len, SD_TIMEOUT, if (scsi_mode_select(sdp, 1, sp, buffer_data, len, SD_TIMEOUT,
sdkp->max_retries, &data, &sshdr)) { sdkp->max_retries, &data, &sshdr)) {
if (scsi_sense_valid(&sshdr)) if (scsi_sense_valid(&sshdr))
sd_print_sense_hdr(sdkp, &sshdr); sd_print_sense_hdr(sdkp, &sshdr);

2
drivers/scsi/ufs/ufs-mediatek.c
View File

@@ -557,7 +557,7 @@ static void ufs_mtk_init_va09_pwr_ctrl(struct ufs_hba *hba)
struct ufs_mtk_host *host = ufshcd_get_variant(hba); struct ufs_mtk_host *host = ufshcd_get_variant(hba);
host->reg_va09 = regulator_get(hba->dev, "va09"); host->reg_va09 = regulator_get(hba->dev, "va09");
if (!host->reg_va09) if (IS_ERR(host->reg_va09))
dev_info(hba->dev, "failed to get va09"); dev_info(hba->dev, "failed to get va09");
else else
host->caps |= UFS_MTK_CAP_VA09_PWR_CTRL; host->caps |= UFS_MTK_CAP_VA09_PWR_CTRL;

2
drivers/scsi/ufs/ufshcd.c
View File

@@ -7815,7 +7815,7 @@ static int ufshcd_quirk_tune_host_pa_tactivate(struct ufs_hba *hba)
peer_pa_tactivate_us = peer_pa_tactivate * peer_pa_tactivate_us = peer_pa_tactivate *
gran_to_us_table[peer_granularity - 1]; gran_to_us_table[peer_granularity - 1];
if (pa_tactivate_us > peer_pa_tactivate_us) { if (pa_tactivate_us >= peer_pa_tactivate_us) {
u32 new_peer_pa_tactivate; u32 new_peer_pa_tactivate;
new_peer_pa_tactivate = pa_tactivate_us / new_peer_pa_tactivate = pa_tactivate_us /

5
include/scsi/scsi_device.h
View File

@@ -415,9 +415,8 @@ extern int scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,
int retries, struct scsi_mode_data *data, int retries, struct scsi_mode_data *data,
struct scsi_sense_hdr *); struct scsi_sense_hdr *);
extern int scsi_mode_select(struct scsi_device *sdev, int pf, int sp, extern int scsi_mode_select(struct scsi_device *sdev, int pf, int sp,
int modepage, unsigned char *buffer, int len, unsigned char *buffer, int len, int timeout,
int timeout, int retries, int retries, struct scsi_mode_data *data,
struct scsi_mode_data *data,
struct scsi_sense_hdr *); struct scsi_sense_hdr *);
extern int scsi_test_unit_ready(struct scsi_device *sdev, int timeout, extern int scsi_test_unit_ready(struct scsi_device *sdev, int timeout,
int retries, struct scsi_sense_hdr *sshdr); int retries, struct scsi_sense_hdr *sshdr);