public-mirrors/linux
1
0
Fork 0
mirror of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2025-08-05 16:54:27 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

misc: pci_endpoint_test: Fix IOCTL return value

Browse source 
IOCTLs are supposed to return 0 for success and negative error codes for
failure. Currently, this driver is returning 0 for failure and 1 for
success, that's not correct. Hence, fix it!

Link: https://lore.kernel.org/r/20250116171650.33585-3-manivannan.sadhasivam@linaro.org
Fixes: 2c156ac71c ("misc: Add host side PCI driver for PCI test function device")
Reported-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Closes: https://lore.kernel.org/r/YvzNg5ROnxEApDgS@kroah.com
Signed-off-by: Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
Tested-by: Niklas Cassel <cassel@kernel.org>
Reviewed-by: Damien Le Moal <dlemoal@kernel.org>
Reviewed-by: Niklas Cassel <cassel@kernel.org>
This commit is contained in:
Manivannan Sadhasivam 2025-01-16 22:46:48 +05:30 • committed by Bjorn Helgaas
parent 4644db8364
commit f26d37ee9b
2 changed files with 153 additions and 153 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

255
drivers/misc/pci_endpoint_test.c
View file

@ -169,43 +169,47 @@ static void pci_endpoint_test_free_irq_vectors(struct pci_endpoint_test *test)
test->irq_type = IRQ_TYPE_UNDEFINED; test->irq_type = IRQ_TYPE_UNDEFINED;
} }
static bool pci_endpoint_test_alloc_irq_vectors(struct pci_endpoint_test *test, static int pci_endpoint_test_alloc_irq_vectors(struct pci_endpoint_test *test,
int type) int type)
{ {
int irq = -1; int irq;
struct pci_dev *pdev = test->pdev; struct pci_dev *pdev = test->pdev;
struct device *dev = &pdev->dev; struct device *dev = &pdev->dev;
bool res = true;
switch (type) { switch (type) {
case IRQ_TYPE_INTX: case IRQ_TYPE_INTX:
irq = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_INTX); irq = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_INTX);
if (irq < 0) if (irq < 0) {
dev_err(dev, "Failed to get Legacy interrupt\n"); dev_err(dev, "Failed to get Legacy interrupt\n");
return irq;
}
break; break;
case IRQ_TYPE_MSI: case IRQ_TYPE_MSI:
irq = pci_alloc_irq_vectors(pdev, 1, 32, PCI_IRQ_MSI); irq = pci_alloc_irq_vectors(pdev, 1, 32, PCI_IRQ_MSI);
if (irq < 0) if (irq < 0) {
dev_err(dev, "Failed to get MSI interrupts\n"); dev_err(dev, "Failed to get MSI interrupts\n");
return irq;
}
break; break;
case IRQ_TYPE_MSIX: case IRQ_TYPE_MSIX:
irq = pci_alloc_irq_vectors(pdev, 1, 2048, PCI_IRQ_MSIX); irq = pci_alloc_irq_vectors(pdev, 1, 2048, PCI_IRQ_MSIX);
if (irq < 0) if (irq < 0) {
dev_err(dev, "Failed to get MSI-X interrupts\n"); dev_err(dev, "Failed to get MSI-X interrupts\n");
return irq;
}
break; break;
default: default:
dev_err(dev, "Invalid IRQ type selected\n"); dev_err(dev, "Invalid IRQ type selected\n");
} return -EINVAL;
if (irq < 0) {
irq = 0;
res = false;
} }
test->irq_type = type; test->irq_type = type;
test->num_irqs = irq; test->num_irqs = irq;
return res; return 0;
} }
static void pci_endpoint_test_release_irq(struct pci_endpoint_test *test) static void pci_endpoint_test_release_irq(struct pci_endpoint_test *test)
@ -220,22 +224,22 @@ static void pci_endpoint_test_release_irq(struct pci_endpoint_test *test)
test->num_irqs = 0; test->num_irqs = 0;
} }
static bool pci_endpoint_test_request_irq(struct pci_endpoint_test *test) static int pci_endpoint_test_request_irq(struct pci_endpoint_test *test)
{ {
int i; int i;
int err; int ret;
struct pci_dev *pdev = test->pdev; struct pci_dev *pdev = test->pdev;
struct device *dev = &pdev->dev; struct device *dev = &pdev->dev;
for (i = 0; i < test->num_irqs; i++) { for (i = 0; i < test->num_irqs; i++) {
err = devm_request_irq(dev, pci_irq_vector(pdev, i), ret = devm_request_irq(dev, pci_irq_vector(pdev, i),
pci_endpoint_test_irqhandler, pci_endpoint_test_irqhandler,
IRQF_SHARED, test->name, test); IRQF_SHARED, test->name, test);
if (err) if (ret)
goto fail; goto fail;
} }
return true; return 0;
fail: fail:
switch (irq_type) { switch (irq_type) {
@ -255,7 +259,7 @@ fail:
break; break;
} }
return false; return ret;
} }
static const u32 bar_test_pattern[] = { static const u32 bar_test_pattern[] = {
@ -280,7 +284,7 @@ static int pci_endpoint_test_bar_memcmp(struct pci_endpoint_test *test,
return memcmp(write_buf, read_buf, size); return memcmp(write_buf, read_buf, size);
} }
static bool pci_endpoint_test_bar(struct pci_endpoint_test *test, static int pci_endpoint_test_bar(struct pci_endpoint_test *test,
enum pci_barno barno) enum pci_barno barno)
{ {
int j, bar_size, buf_size, iters; int j, bar_size, buf_size, iters;
@ -289,7 +293,7 @@ static bool pci_endpoint_test_bar(struct pci_endpoint_test *test,
struct pci_dev *pdev = test->pdev; struct pci_dev *pdev = test->pdev;
if (!test->bar[barno]) if (!test->bar[barno])
return false; return -ENOMEM;
bar_size = pci_resource_len(pdev, barno); bar_size = pci_resource_len(pdev, barno);
@ -304,19 +308,19 @@ static bool pci_endpoint_test_bar(struct pci_endpoint_test *test,
write_buf = kmalloc(buf_size, GFP_KERNEL); write_buf = kmalloc(buf_size, GFP_KERNEL);
if (!write_buf) if (!write_buf)
return false; return -ENOMEM;
read_buf = kmalloc(buf_size, GFP_KERNEL); read_buf = kmalloc(buf_size, GFP_KERNEL);
if (!read_buf) if (!read_buf)
return false; return -ENOMEM;
iters = bar_size / buf_size; iters = bar_size / buf_size;
for (j = 0; j < iters; j++) for (j = 0; j < iters; j++)
if (pci_endpoint_test_bar_memcmp(test, barno, buf_size * j, if (pci_endpoint_test_bar_memcmp(test, barno, buf_size * j,
write_buf, read_buf, buf_size)) write_buf, read_buf, buf_size))
return false; return -EIO;
return true; return 0;
} }
static u32 bar_test_pattern_with_offset(enum pci_barno barno, int offset) static u32 bar_test_pattern_with_offset(enum pci_barno barno, int offset)
@ -331,7 +335,7 @@ static u32 bar_test_pattern_with_offset(enum pci_barno barno, int offset)
return val; return val;
} }
static bool pci_endpoint_test_bars_write_bar(struct pci_endpoint_test *test, static void pci_endpoint_test_bars_write_bar(struct pci_endpoint_test *test,
enum pci_barno barno) enum pci_barno barno)
{ {
struct pci_dev *pdev = test->pdev; struct pci_dev *pdev = test->pdev;
@ -345,11 +349,9 @@ static bool pci_endpoint_test_bars_write_bar(struct pci_endpoint_test *test,
for (j = 0; j < size; j += 4) for (j = 0; j < size; j += 4)
writel_relaxed(bar_test_pattern_with_offset(barno, j), writel_relaxed(bar_test_pattern_with_offset(barno, j),
test->bar[barno] + j); test->bar[barno] + j);
return true;
} }
static bool pci_endpoint_test_bars_read_bar(struct pci_endpoint_test *test, static int pci_endpoint_test_bars_read_bar(struct pci_endpoint_test *test,
enum pci_barno barno) enum pci_barno barno)
{ {
struct pci_dev *pdev = test->pdev; struct pci_dev *pdev = test->pdev;
@ -370,14 +372,14 @@ static bool pci_endpoint_test_bars_read_bar(struct pci_endpoint_test *test,
dev_err(dev, dev_err(dev,
"BAR%d incorrect data at offset: %#x, got: %#x expected: %#x\n", "BAR%d incorrect data at offset: %#x, got: %#x expected: %#x\n",
barno, j, val, expected); barno, j, val, expected);
return false; return -EIO;
} }
} }
return true; return 0;
} }
static bool pci_endpoint_test_bars(struct pci_endpoint_test *test) static int pci_endpoint_test_bars(struct pci_endpoint_test *test)
{ {
enum pci_barno bar; enum pci_barno bar;
bool ret; bool ret;
@ -401,10 +403,10 @@ static bool pci_endpoint_test_bars(struct pci_endpoint_test *test)
} }
} }
return true; return 0;
} }
static bool pci_endpoint_test_intx_irq(struct pci_endpoint_test *test) static int pci_endpoint_test_intx_irq(struct pci_endpoint_test *test)
{ {
u32 val; u32 val;
@ -416,16 +418,17 @@ static bool pci_endpoint_test_intx_irq(struct pci_endpoint_test *test)
val = wait_for_completion_timeout(&test->irq_raised, val = wait_for_completion_timeout(&test->irq_raised,
msecs_to_jiffies(1000)); msecs_to_jiffies(1000));
if (!val) if (!val)
return false; return -ETIMEDOUT;
return true; return 0;
} }
static bool pci_endpoint_test_msi_irq(struct pci_endpoint_test *test, static int pci_endpoint_test_msi_irq(struct pci_endpoint_test *test,
u16 msi_num, bool msix) u16 msi_num, bool msix)
{ {
u32 val;
struct pci_dev *pdev = test->pdev; struct pci_dev *pdev = test->pdev;
u32 val;
int ret;
pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_TYPE, pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_TYPE,
msix ? IRQ_TYPE_MSIX : IRQ_TYPE_MSI); msix ? IRQ_TYPE_MSIX : IRQ_TYPE_MSI);
@ -436,9 +439,16 @@ static bool pci_endpoint_test_msi_irq(struct pci_endpoint_test *test,
val = wait_for_completion_timeout(&test->irq_raised, val = wait_for_completion_timeout(&test->irq_raised,
msecs_to_jiffies(1000)); msecs_to_jiffies(1000));
if (!val) if (!val)
return false; return -ETIMEDOUT;
return pci_irq_vector(pdev, msi_num - 1) == test->last_irq; ret = pci_irq_vector(pdev, msi_num - 1);
if (ret < 0)
return ret;
if (ret != test->last_irq)
return -EIO;
return 0;
} }
static int pci_endpoint_test_validate_xfer_params(struct device *dev, static int pci_endpoint_test_validate_xfer_params(struct device *dev,
@ -457,11 +467,10 @@ static int pci_endpoint_test_validate_xfer_params(struct device *dev,
return 0; return 0;
} }
static bool pci_endpoint_test_copy(struct pci_endpoint_test *test, static int pci_endpoint_test_copy(struct pci_endpoint_test *test,
unsigned long arg) unsigned long arg)
{ {
struct pci_endpoint_test_xfer_param param; struct pci_endpoint_test_xfer_param param;
bool ret = false;
void *src_addr; void *src_addr;
void *dst_addr; void *dst_addr;
u32 flags = 0; u32 flags = 0;
@ -480,17 +489,17 @@ static bool pci_endpoint_test_copy(struct pci_endpoint_test *test,
int irq_type = test->irq_type; int irq_type = test->irq_type;
u32 src_crc32; u32 src_crc32;
u32 dst_crc32; u32 dst_crc32;
int err; int ret;
err = copy_from_user(&param, (void __user *)arg, sizeof(param)); ret = copy_from_user(&param, (void __user *)arg, sizeof(param));
if (err) { if (ret) {
dev_err(dev, "Failed to get transfer param\n"); dev_err(dev, "Failed to get transfer param\n");
return false; return -EFAULT;
} }
err = pci_endpoint_test_validate_xfer_params(dev, &param, alignment); ret = pci_endpoint_test_validate_xfer_params(dev, &param, alignment);
if (err) if (ret)
return false; return ret;
size = param.size; size = param.size;
@ -500,22 +509,21 @@ static bool pci_endpoint_test_copy(struct pci_endpoint_test *test,
if (irq_type < IRQ_TYPE_INTX || irq_type > IRQ_TYPE_MSIX) { if (irq_type < IRQ_TYPE_INTX || irq_type > IRQ_TYPE_MSIX) {
dev_err(dev, "Invalid IRQ type option\n"); dev_err(dev, "Invalid IRQ type option\n");
goto err; return -EINVAL;
} }
orig_src_addr = kzalloc(size + alignment, GFP_KERNEL); orig_src_addr = kzalloc(size + alignment, GFP_KERNEL);
if (!orig_src_addr) { if (!orig_src_addr) {
dev_err(dev, "Failed to allocate source buffer\n"); dev_err(dev, "Failed to allocate source buffer\n");
ret = false; return -ENOMEM;
goto err;
} }
get_random_bytes(orig_src_addr, size + alignment); get_random_bytes(orig_src_addr, size + alignment);
orig_src_phys_addr = dma_map_single(dev, orig_src_addr, orig_src_phys_addr = dma_map_single(dev, orig_src_addr,
size + alignment, DMA_TO_DEVICE); size + alignment, DMA_TO_DEVICE);
if (dma_mapping_error(dev, orig_src_phys_addr)) { ret = dma_mapping_error(dev, orig_src_phys_addr);
if (ret) {
dev_err(dev, "failed to map source buffer address\n"); dev_err(dev, "failed to map source buffer address\n");
ret = false;
goto err_src_phys_addr; goto err_src_phys_addr;
} }
@ -539,15 +547,15 @@ static bool pci_endpoint_test_copy(struct pci_endpoint_test *test,
orig_dst_addr = kzalloc(size + alignment, GFP_KERNEL); orig_dst_addr = kzalloc(size + alignment, GFP_KERNEL);
if (!orig_dst_addr) { if (!orig_dst_addr) {
dev_err(dev, "Failed to allocate destination address\n"); dev_err(dev, "Failed to allocate destination address\n");
ret = false; ret = -ENOMEM;
goto err_dst_addr; goto err_dst_addr;
} }
orig_dst_phys_addr = dma_map_single(dev, orig_dst_addr, orig_dst_phys_addr = dma_map_single(dev, orig_dst_addr,
size + alignment, DMA_FROM_DEVICE); size + alignment, DMA_FROM_DEVICE);
if (dma_mapping_error(dev, orig_dst_phys_addr)) { ret = dma_mapping_error(dev, orig_dst_phys_addr);
if (ret) {
dev_err(dev, "failed to map destination buffer address\n"); dev_err(dev, "failed to map destination buffer address\n");
ret = false;
goto err_dst_phys_addr; goto err_dst_phys_addr;
} }
@ -580,8 +588,8 @@ static bool pci_endpoint_test_copy(struct pci_endpoint_test *test,
DMA_FROM_DEVICE); DMA_FROM_DEVICE);
dst_crc32 = crc32_le(~0, dst_addr, size); dst_crc32 = crc32_le(~0, dst_addr, size);
if (dst_crc32 == src_crc32) if (dst_crc32 != src_crc32)
ret = true; ret = -EIO;
err_dst_phys_addr: err_dst_phys_addr:
kfree(orig_dst_addr); kfree(orig_dst_addr);
@ -592,16 +600,13 @@ err_dst_addr:
err_src_phys_addr: err_src_phys_addr:
kfree(orig_src_addr); kfree(orig_src_addr);
err:
return ret; return ret;
} }
static bool pci_endpoint_test_write(struct pci_endpoint_test *test, static int pci_endpoint_test_write(struct pci_endpoint_test *test,
unsigned long arg) unsigned long arg)
{ {
struct pci_endpoint_test_xfer_param param; struct pci_endpoint_test_xfer_param param;
bool ret = false;
u32 flags = 0; u32 flags = 0;
bool use_dma; bool use_dma;
u32 reg; u32 reg;
@ -616,17 +621,17 @@ static bool pci_endpoint_test_write(struct pci_endpoint_test *test,
int irq_type = test->irq_type; int irq_type = test->irq_type;
size_t size; size_t size;
u32 crc32; u32 crc32;
int err; int ret;
err = copy_from_user(&param, (void __user *)arg, sizeof(param)); ret = copy_from_user(&param, (void __user *)arg, sizeof(param));
if (err != 0) { if (ret) {
dev_err(dev, "Failed to get transfer param\n"); dev_err(dev, "Failed to get transfer param\n");
return false; return -EFAULT;
} }
err = pci_endpoint_test_validate_xfer_params(dev, &param, alignment); ret = pci_endpoint_test_validate_xfer_params(dev, &param, alignment);
if (err) if (ret)
return false; return ret;
size = param.size; size = param.size;
@ -636,23 +641,22 @@ static bool pci_endpoint_test_write(struct pci_endpoint_test *test,
if (irq_type < IRQ_TYPE_INTX || irq_type > IRQ_TYPE_MSIX) { if (irq_type < IRQ_TYPE_INTX || irq_type > IRQ_TYPE_MSIX) {
dev_err(dev, "Invalid IRQ type option\n"); dev_err(dev, "Invalid IRQ type option\n");
goto err; return -EINVAL;
} }
orig_addr = kzalloc(size + alignment, GFP_KERNEL); orig_addr = kzalloc(size + alignment, GFP_KERNEL);
if (!orig_addr) { if (!orig_addr) {
dev_err(dev, "Failed to allocate address\n"); dev_err(dev, "Failed to allocate address\n");
ret = false; return -ENOMEM;
goto err;
} }
get_random_bytes(orig_addr, size + alignment); get_random_bytes(orig_addr, size + alignment);
orig_phys_addr = dma_map_single(dev, orig_addr, size + alignment, orig_phys_addr = dma_map_single(dev, orig_addr, size + alignment,
DMA_TO_DEVICE); DMA_TO_DEVICE);
if (dma_mapping_error(dev, orig_phys_addr)) { ret = dma_mapping_error(dev, orig_phys_addr);
if (ret) {
dev_err(dev, "failed to map source buffer address\n"); dev_err(dev, "failed to map source buffer address\n");
ret = false;
goto err_phys_addr; goto err_phys_addr;
} }
@ -685,24 +689,21 @@ static bool pci_endpoint_test_write(struct pci_endpoint_test *test,
wait_for_completion(&test->irq_raised); wait_for_completion(&test->irq_raised);
reg = pci_endpoint_test_readl(test, PCI_ENDPOINT_TEST_STATUS); reg = pci_endpoint_test_readl(test, PCI_ENDPOINT_TEST_STATUS);
if (reg & STATUS_READ_SUCCESS) if (!(reg & STATUS_READ_SUCCESS))
ret = true; ret = -EIO;
dma_unmap_single(dev, orig_phys_addr, size + alignment, dma_unmap_single(dev, orig_phys_addr, size + alignment,
DMA_TO_DEVICE); DMA_TO_DEVICE);
err_phys_addr: err_phys_addr:
kfree(orig_addr); kfree(orig_addr);
err:
return ret; return ret;
} }
static bool pci_endpoint_test_read(struct pci_endpoint_test *test, static int pci_endpoint_test_read(struct pci_endpoint_test *test,
unsigned long arg) unsigned long arg)
{ {
struct pci_endpoint_test_xfer_param param; struct pci_endpoint_test_xfer_param param;
bool ret = false;
u32 flags = 0; u32 flags = 0;
bool use_dma; bool use_dma;
size_t size; size_t size;
@ -716,17 +717,17 @@ static bool pci_endpoint_test_read(struct pci_endpoint_test *test,
size_t alignment = test->alignment; size_t alignment = test->alignment;
int irq_type = test->irq_type; int irq_type = test->irq_type;
u32 crc32; u32 crc32;
int err; int ret;
err = copy_from_user(&param, (void __user *)arg, sizeof(param)); ret = copy_from_user(&param, (void __user *)arg, sizeof(param));
if (err) { if (ret) {
dev_err(dev, "Failed to get transfer param\n"); dev_err(dev, "Failed to get transfer param\n");
return false; return -EFAULT;
} }
err = pci_endpoint_test_validate_xfer_params(dev, &param, alignment); ret = pci_endpoint_test_validate_xfer_params(dev, &param, alignment);
if (err) if (ret)
return false; return ret;
size = param.size; size = param.size;
@ -736,21 +737,20 @@ static bool pci_endpoint_test_read(struct pci_endpoint_test *test,
if (irq_type < IRQ_TYPE_INTX || irq_type > IRQ_TYPE_MSIX) { if (irq_type < IRQ_TYPE_INTX || irq_type > IRQ_TYPE_MSIX) {
dev_err(dev, "Invalid IRQ type option\n"); dev_err(dev, "Invalid IRQ type option\n");
goto err; return -EINVAL;
} }
orig_addr = kzalloc(size + alignment, GFP_KERNEL); orig_addr = kzalloc(size + alignment, GFP_KERNEL);
if (!orig_addr) { if (!orig_addr) {
dev_err(dev, "Failed to allocate destination address\n"); dev_err(dev, "Failed to allocate destination address\n");
ret = false; return -ENOMEM;
goto err;
} }
orig_phys_addr = dma_map_single(dev, orig_addr, size + alignment, orig_phys_addr = dma_map_single(dev, orig_addr, size + alignment,
DMA_FROM_DEVICE); DMA_FROM_DEVICE);
if (dma_mapping_error(dev, orig_phys_addr)) { ret = dma_mapping_error(dev, orig_phys_addr);
if (ret) {
dev_err(dev, "failed to map source buffer address\n"); dev_err(dev, "failed to map source buffer address\n");
ret = false;
goto err_phys_addr; goto err_phys_addr;
} }
@ -782,50 +782,51 @@ static bool pci_endpoint_test_read(struct pci_endpoint_test *test,
DMA_FROM_DEVICE); DMA_FROM_DEVICE);
crc32 = crc32_le(~0, addr, size); crc32 = crc32_le(~0, addr, size);
if (crc32 == pci_endpoint_test_readl(test, PCI_ENDPOINT_TEST_CHECKSUM)) if (crc32 != pci_endpoint_test_readl(test, PCI_ENDPOINT_TEST_CHECKSUM))
ret = true; ret = -EIO;
err_phys_addr: err_phys_addr:
kfree(orig_addr); kfree(orig_addr);
err:
return ret; return ret;
} }
static bool pci_endpoint_test_clear_irq(struct pci_endpoint_test *test) static int pci_endpoint_test_clear_irq(struct pci_endpoint_test *test)
{ {
pci_endpoint_test_release_irq(test); pci_endpoint_test_release_irq(test);
pci_endpoint_test_free_irq_vectors(test); pci_endpoint_test_free_irq_vectors(test);
return true;
return 0;
} }
static bool pci_endpoint_test_set_irq(struct pci_endpoint_test *test, static int pci_endpoint_test_set_irq(struct pci_endpoint_test *test,
int req_irq_type) int req_irq_type)
{ {
struct pci_dev *pdev = test->pdev; struct pci_dev *pdev = test->pdev;
struct device *dev = &pdev->dev; struct device *dev = &pdev->dev;
int ret;
if (req_irq_type < IRQ_TYPE_INTX || req_irq_type > IRQ_TYPE_MSIX) { if (req_irq_type < IRQ_TYPE_INTX || req_irq_type > IRQ_TYPE_MSIX) {
dev_err(dev, "Invalid IRQ type option\n"); dev_err(dev, "Invalid IRQ type option\n");
return false; return -EINVAL;
} }
if (test->irq_type == req_irq_type) if (test->irq_type == req_irq_type)
return true; return 0;
pci_endpoint_test_release_irq(test); pci_endpoint_test_release_irq(test);
pci_endpoint_test_free_irq_vectors(test); pci_endpoint_test_free_irq_vectors(test);
if (!pci_endpoint_test_alloc_irq_vectors(test, req_irq_type)) ret = pci_endpoint_test_alloc_irq_vectors(test, req_irq_type);
goto err; if (ret)
return ret;
if (!pci_endpoint_test_request_irq(test)) ret = pci_endpoint_test_request_irq(test);
goto err; if (ret) {
pci_endpoint_test_free_irq_vectors(test);
return ret;
}
return true; return 0;
err:
pci_endpoint_test_free_irq_vectors(test);
return false;
} }
static long pci_endpoint_test_ioctl(struct file *file, unsigned int cmd, static long pci_endpoint_test_ioctl(struct file *file, unsigned int cmd,
@ -907,7 +908,7 @@ static void pci_endpoint_test_get_capabilities(struct pci_endpoint_test *test)
static int pci_endpoint_test_probe(struct pci_dev *pdev, static int pci_endpoint_test_probe(struct pci_dev *pdev,
const struct pci_device_id *ent) const struct pci_device_id *ent)
{ {
int err; int ret;
int id; int id;
char name[24]; char name[24];
enum pci_barno bar; enum pci_barno bar;
@ -946,24 +947,23 @@ static int pci_endpoint_test_probe(struct pci_dev *pdev,
dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(48)); dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(48));
err = pci_enable_device(pdev); ret = pci_enable_device(pdev);
if (err) { if (ret) {
dev_err(dev, "Cannot enable PCI device\n"); dev_err(dev, "Cannot enable PCI device\n");
return err; return ret;
} }
err = pci_request_regions(pdev, DRV_MODULE_NAME); ret = pci_request_regions(pdev, DRV_MODULE_NAME);
if (err) { if (ret) {
dev_err(dev, "Cannot obtain PCI resources\n"); dev_err(dev, "Cannot obtain PCI resources\n");
goto err_disable_pdev; goto err_disable_pdev;
} }
pci_set_master(pdev); pci_set_master(pdev);
if (!pci_endpoint_test_alloc_irq_vectors(test, irq_type)) { ret = pci_endpoint_test_alloc_irq_vectors(test, irq_type);
err = -EINVAL; if (ret)
goto err_disable_irq; goto err_disable_irq;
}
for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) { for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM) { if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM) {
@ -978,7 +978,7 @@ static int pci_endpoint_test_probe(struct pci_dev *pdev,
test->base = test->bar[test_reg_bar]; test->base = test->bar[test_reg_bar];
if (!test->base) { if (!test->base) {
err = -ENOMEM; ret = -ENOMEM;
dev_err(dev, "Cannot perform PCI test without BAR%d\n", dev_err(dev, "Cannot perform PCI test without BAR%d\n",
test_reg_bar); test_reg_bar);
goto err_iounmap; goto err_iounmap;
@ -988,7 +988,7 @@ static int pci_endpoint_test_probe(struct pci_dev *pdev,
id = ida_alloc(&pci_endpoint_test_ida, GFP_KERNEL); id = ida_alloc(&pci_endpoint_test_ida, GFP_KERNEL);
if (id < 0) { if (id < 0) {
err = id; ret = id;
dev_err(dev, "Unable to get id\n"); dev_err(dev, "Unable to get id\n");
goto err_iounmap; goto err_iounmap;
} }
@ -996,14 +996,13 @@ static int pci_endpoint_test_probe(struct pci_dev *pdev,
snprintf(name, sizeof(name), DRV_MODULE_NAME ".%d", id); snprintf(name, sizeof(name), DRV_MODULE_NAME ".%d", id);
test->name = kstrdup(name, GFP_KERNEL); test->name = kstrdup(name, GFP_KERNEL);
if (!test->name) { if (!test->name) {
err = -ENOMEM; ret = -ENOMEM;
goto err_ida_remove; goto err_ida_remove;
} }
if (!pci_endpoint_test_request_irq(test)) { ret = pci_endpoint_test_request_irq(test);
err = -EINVAL; if (ret)
goto err_kfree_test_name; goto err_kfree_test_name;
}
pci_endpoint_test_get_capabilities(test); pci_endpoint_test_get_capabilities(test);
@ -1011,14 +1010,14 @@ static int pci_endpoint_test_probe(struct pci_dev *pdev,
misc_device->minor = MISC_DYNAMIC_MINOR; misc_device->minor = MISC_DYNAMIC_MINOR;
misc_device->name = kstrdup(name, GFP_KERNEL); misc_device->name = kstrdup(name, GFP_KERNEL);
if (!misc_device->name) { if (!misc_device->name) {
err = -ENOMEM; ret = -ENOMEM;
goto err_release_irq; goto err_release_irq;
} }
misc_device->parent = &pdev->dev; misc_device->parent = &pdev->dev;
misc_device->fops = &pci_endpoint_test_fops; misc_device->fops = &pci_endpoint_test_fops;
err = misc_register(misc_device); ret = misc_register(misc_device);
if (err) { if (ret) {
dev_err(dev, "Failed to register device\n"); dev_err(dev, "Failed to register device\n");
goto err_kfree_name; goto err_kfree_name;
} }
@ -1050,7 +1049,7 @@ err_disable_irq:
err_disable_pdev: err_disable_pdev:
pci_disable_device(pdev); pci_disable_device(pdev);
return err; return ret;
} }
static void pci_endpoint_test_remove(struct pci_dev *pdev) static void pci_endpoint_test_remove(struct pci_dev *pdev)

51
tools/pci/pcitest.c
View file

@ -16,7 +16,6 @@
#include <linux/pcitest.h> #include <linux/pcitest.h>
static char *result[] = { "NOT OKAY", "OKAY" };
static char *irq[] = { "LEGACY", "MSI", "MSI-X" }; static char *irq[] = { "LEGACY", "MSI", "MSI-X" };
struct pci_test { struct pci_test {
@ -53,72 +52,74 @@ static int run_test(struct pci_test *test)
ret = ioctl(fd, PCITEST_BAR, test->barnum); ret = ioctl(fd, PCITEST_BAR, test->barnum);
fprintf(stdout, "BAR%d:\t\t", test->barnum); fprintf(stdout, "BAR%d:\t\t", test->barnum);
if (ret < 0) if (ret < 0)
fprintf(stdout, "TEST FAILED\n"); fprintf(stdout, "NOT OKAY\n");
else else
fprintf(stdout, "%s\n", result[ret]); fprintf(stdout, "OKAY\n");
} }
if (test->consecutive_bar_test) { if (test->consecutive_bar_test) {
ret = ioctl(fd, PCITEST_BARS); ret = ioctl(fd, PCITEST_BARS);
fprintf(stdout, "Consecutive BAR test:\t\t"); fprintf(stdout, "Consecutive BAR test:\t\t");
if (ret < 0) if (ret < 0)
fprintf(stdout, "TEST FAILED\n"); fprintf(stdout, "NOT OKAY\n");
else else
fprintf(stdout, "%s\n", result[ret]); fprintf(stdout, "OKAY\n");
} }
if (test->set_irqtype) { if (test->set_irqtype) {
ret = ioctl(fd, PCITEST_SET_IRQTYPE, test->irqtype); ret = ioctl(fd, PCITEST_SET_IRQTYPE, test->irqtype);
fprintf(stdout, "SET IRQ TYPE TO %s:\t\t", irq[test->irqtype]); fprintf(stdout, "SET IRQ TYPE TO %s:\t\t", irq[test->irqtype]);
if (ret < 0) if (ret < 0)
fprintf(stdout, "FAILED\n"); fprintf(stdout, "NOT OKAY\n");
else else
fprintf(stdout, "%s\n", result[ret]); fprintf(stdout, "OKAY\n");
} }
if (test->get_irqtype) { if (test->get_irqtype) {
ret = ioctl(fd, PCITEST_GET_IRQTYPE); ret = ioctl(fd, PCITEST_GET_IRQTYPE);
fprintf(stdout, "GET IRQ TYPE:\t\t"); fprintf(stdout, "GET IRQ TYPE:\t\t");
if (ret < 0) if (ret < 0) {
fprintf(stdout, "FAILED\n"); fprintf(stdout, "NOT OKAY\n");
else } else {
fprintf(stdout, "%s\n", irq[ret]); fprintf(stdout, "%s\n", irq[ret]);
ret = 0;
}
} }
if (test->clear_irq) { if (test->clear_irq) {
ret = ioctl(fd, PCITEST_CLEAR_IRQ); ret = ioctl(fd, PCITEST_CLEAR_IRQ);
fprintf(stdout, "CLEAR IRQ:\t\t"); fprintf(stdout, "CLEAR IRQ:\t\t");
if (ret < 0) if (ret < 0)
fprintf(stdout, "FAILED\n"); fprintf(stdout, "NOT OKAY\n");
else else
fprintf(stdout, "%s\n", result[ret]); fprintf(stdout, "OKAY\n");
} }
if (test->legacyirq) { if (test->legacyirq) {
ret = ioctl(fd, PCITEST_LEGACY_IRQ, 0); ret = ioctl(fd, PCITEST_LEGACY_IRQ, 0);
fprintf(stdout, "LEGACY IRQ:\t"); fprintf(stdout, "LEGACY IRQ:\t");
if (ret < 0) if (ret < 0)
fprintf(stdout, "TEST FAILED\n"); fprintf(stdout, "NOT OKAY\n");
else else
fprintf(stdout, "%s\n", result[ret]); fprintf(stdout, "OKAY\n");
} }
if (test->msinum > 0 && test->msinum <= 32) { if (test->msinum > 0 && test->msinum <= 32) {
ret = ioctl(fd, PCITEST_MSI, test->msinum); ret = ioctl(fd, PCITEST_MSI, test->msinum);
fprintf(stdout, "MSI%u:\t\t", test->msinum); fprintf(stdout, "MSI%u:\t\t", test->msinum);
if (ret < 0) if (ret < 0)
fprintf(stdout, "TEST FAILED\n"); fprintf(stdout, "NOT OKAY\n");
else else
fprintf(stdout, "%s\n", result[ret]); fprintf(stdout, "OKAY\n");
} }
if (test->msixnum > 0 && test->msixnum <= 2048) { if (test->msixnum > 0 && test->msixnum <= 2048) {
ret = ioctl(fd, PCITEST_MSIX, test->msixnum); ret = ioctl(fd, PCITEST_MSIX, test->msixnum);
fprintf(stdout, "MSI-X%u:\t\t", test->msixnum); fprintf(stdout, "MSI-X%u:\t\t", test->msixnum);
if (ret < 0) if (ret < 0)
fprintf(stdout, "TEST FAILED\n"); fprintf(stdout, "NOT OKAY\n");
else else
fprintf(stdout, "%s\n", result[ret]); fprintf(stdout, "OKAY\n");
} }
if (test->write) { if (test->write) {
@ -128,9 +129,9 @@ static int run_test(struct pci_test *test)
ret = ioctl(fd, PCITEST_WRITE, &param); ret = ioctl(fd, PCITEST_WRITE, &param);
fprintf(stdout, "WRITE (%7lu bytes):\t\t", test->size); fprintf(stdout, "WRITE (%7lu bytes):\t\t", test->size);
if (ret < 0) if (ret < 0)
fprintf(stdout, "TEST FAILED\n"); fprintf(stdout, "NOT OKAY\n");
else else
fprintf(stdout, "%s\n", result[ret]); fprintf(stdout, "OKAY\n");
} }
if (test->read) { if (test->read) {
@ -140,9 +141,9 @@ static int run_test(struct pci_test *test)
ret = ioctl(fd, PCITEST_READ, &param); ret = ioctl(fd, PCITEST_READ, &param);
fprintf(stdout, "READ (%7lu bytes):\t\t", test->size); fprintf(stdout, "READ (%7lu bytes):\t\t", test->size);
if (ret < 0) if (ret < 0)
fprintf(stdout, "TEST FAILED\n"); fprintf(stdout, "NOT OKAY\n");
else else
fprintf(stdout, "%s\n", result[ret]); fprintf(stdout, "OKAY\n");
} }
if (test->copy) { if (test->copy) {
@ -152,14 +153,14 @@ static int run_test(struct pci_test *test)
ret = ioctl(fd, PCITEST_COPY, &param); ret = ioctl(fd, PCITEST_COPY, &param);
fprintf(stdout, "COPY (%7lu bytes):\t\t", test->size); fprintf(stdout, "COPY (%7lu bytes):\t\t", test->size);
if (ret < 0) if (ret < 0)
fprintf(stdout, "TEST FAILED\n"); fprintf(stdout, "NOT OKAY\n");
else else
fprintf(stdout, "%s\n", result[ret]); fprintf(stdout, "OKAY\n");
} }
fflush(stdout); fflush(stdout);
close(fd); close(fd);
return (ret < 0) ? ret : 1 - ret; /* return 0 if test succeeded */ return ret;
} }
int main(int argc, char **argv) int main(int argc, char **argv)