mirror of
git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
synced 2025-08-05 16:54:27 +00:00
misc: pci_endpoint_test: Fix IOCTL return value
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
Bjorn Helgaas
parent
4644db8364
commit
f26d37ee9b
2 changed files with 153 additions and 153 deletions
|
|
@ -169,43 +169,47 @@ static void pci_endpoint_test_free_irq_vectors(struct pci_endpoint_test *test)
|
|||
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 irq = -1;
|
||||
int irq;
|
||||
struct pci_dev *pdev = test->pdev;
|
||||
struct device *dev = &pdev->dev;
|
||||
bool res = true;
|
||||
|
||||
switch (type) {
|
||||
case IRQ_TYPE_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");
|
||||
return irq;
|
||||
}
|
||||
|
||||
break;
|
||||
case IRQ_TYPE_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");
|
||||
return irq;
|
||||
}
|
||||
|
||||
break;
|
||||
case IRQ_TYPE_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");
|
||||
return irq;
|
||||
}
|
||||
|
||||
break;
|
||||
default:
|
||||
dev_err(dev, "Invalid IRQ type selected\n");
|
||||
}
|
||||
|
||||
if (irq < 0) {
|
||||
irq = 0;
|
||||
res = false;
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
test->irq_type = type;
|
||||
test->num_irqs = irq;
|
||||
|
||||
return res;
|
||||
return 0;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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 err;
|
||||
int ret;
|
||||
struct pci_dev *pdev = test->pdev;
|
||||
struct device *dev = &pdev->dev;
|
||||
|
||||
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,
|
||||
IRQF_SHARED, test->name, test);
|
||||
if (err)
|
||||
if (ret)
|
||||
goto fail;
|
||||
}
|
||||
|
||||
return true;
|
||||
return 0;
|
||||
|
||||
fail:
|
||||
switch (irq_type) {
|
||||
|
|
@ -255,7 +259,7 @@ fail:
|
|||
break;
|
||||
}
|
||||
|
||||
return false;
|
||||
return ret;
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
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;
|
||||
|
||||
if (!test->bar[barno])
|
||||
return false;
|
||||
return -ENOMEM;
|
||||
|
||||
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);
|
||||
if (!write_buf)
|
||||
return false;
|
||||
return -ENOMEM;
|
||||
|
||||
read_buf = kmalloc(buf_size, GFP_KERNEL);
|
||||
if (!read_buf)
|
||||
return false;
|
||||
return -ENOMEM;
|
||||
|
||||
iters = bar_size / buf_size;
|
||||
for (j = 0; j < iters; j++)
|
||||
if (pci_endpoint_test_bar_memcmp(test, barno, buf_size * j,
|
||||
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)
|
||||
|
|
@ -331,7 +335,7 @@ static u32 bar_test_pattern_with_offset(enum pci_barno barno, int offset)
|
|||
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)
|
||||
{
|
||||
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)
|
||||
writel_relaxed(bar_test_pattern_with_offset(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)
|
||||
{
|
||||
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,
|
||||
"BAR%d incorrect data at offset: %#x, got: %#x expected: %#x\n",
|
||||
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;
|
||||
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;
|
||||
|
||||
|
|
@ -416,16 +418,17 @@ static bool pci_endpoint_test_intx_irq(struct pci_endpoint_test *test)
|
|||
val = wait_for_completion_timeout(&test->irq_raised,
|
||||
msecs_to_jiffies(1000));
|
||||
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)
|
||||
{
|
||||
u32 val;
|
||||
struct pci_dev *pdev = test->pdev;
|
||||
u32 val;
|
||||
int ret;
|
||||
|
||||
pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_TYPE,
|
||||
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,
|
||||
msecs_to_jiffies(1000));
|
||||
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,
|
||||
|
|
@ -457,11 +467,10 @@ static int pci_endpoint_test_validate_xfer_params(struct device *dev,
|
|||
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)
|
||||
{
|
||||
struct pci_endpoint_test_xfer_param param;
|
||||
bool ret = false;
|
||||
void *src_addr;
|
||||
void *dst_addr;
|
||||
u32 flags = 0;
|
||||
|
|
@ -480,17 +489,17 @@ static bool pci_endpoint_test_copy(struct pci_endpoint_test *test,
|
|||
int irq_type = test->irq_type;
|
||||
u32 src_crc32;
|
||||
u32 dst_crc32;
|
||||
int err;
|
||||
int ret;
|
||||
|
||||
err = copy_from_user(¶m, (void __user *)arg, sizeof(param));
|
||||
if (err) {
|
||||
ret = copy_from_user(¶m, (void __user *)arg, sizeof(param));
|
||||
if (ret) {
|
||||
dev_err(dev, "Failed to get transfer param\n");
|
||||
return false;
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
err = pci_endpoint_test_validate_xfer_params(dev, ¶m, alignment);
|
||||
if (err)
|
||||
return false;
|
||||
ret = pci_endpoint_test_validate_xfer_params(dev, ¶m, alignment);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
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) {
|
||||
dev_err(dev, "Invalid IRQ type option\n");
|
||||
goto err;
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
orig_src_addr = kzalloc(size + alignment, GFP_KERNEL);
|
||||
if (!orig_src_addr) {
|
||||
dev_err(dev, "Failed to allocate source buffer\n");
|
||||
ret = false;
|
||||
goto err;
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
get_random_bytes(orig_src_addr, size + alignment);
|
||||
orig_src_phys_addr = dma_map_single(dev, orig_src_addr,
|
||||
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");
|
||||
ret = false;
|
||||
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);
|
||||
if (!orig_dst_addr) {
|
||||
dev_err(dev, "Failed to allocate destination address\n");
|
||||
ret = false;
|
||||
ret = -ENOMEM;
|
||||
goto err_dst_addr;
|
||||
}
|
||||
|
||||
orig_dst_phys_addr = dma_map_single(dev, orig_dst_addr,
|
||||
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");
|
||||
ret = false;
|
||||
goto err_dst_phys_addr;
|
||||
}
|
||||
|
||||
|
|
@ -580,8 +588,8 @@ static bool pci_endpoint_test_copy(struct pci_endpoint_test *test,
|
|||
DMA_FROM_DEVICE);
|
||||
|
||||
dst_crc32 = crc32_le(~0, dst_addr, size);
|
||||
if (dst_crc32 == src_crc32)
|
||||
ret = true;
|
||||
if (dst_crc32 != src_crc32)
|
||||
ret = -EIO;
|
||||
|
||||
err_dst_phys_addr:
|
||||
kfree(orig_dst_addr);
|
||||
|
|
@ -592,16 +600,13 @@ err_dst_addr:
|
|||
|
||||
err_src_phys_addr:
|
||||
kfree(orig_src_addr);
|
||||
|
||||
err:
|
||||
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)
|
||||
{
|
||||
struct pci_endpoint_test_xfer_param param;
|
||||
bool ret = false;
|
||||
u32 flags = 0;
|
||||
bool use_dma;
|
||||
u32 reg;
|
||||
|
|
@ -616,17 +621,17 @@ static bool pci_endpoint_test_write(struct pci_endpoint_test *test,
|
|||
int irq_type = test->irq_type;
|
||||
size_t size;
|
||||
u32 crc32;
|
||||
int err;
|
||||
int ret;
|
||||
|
||||
err = copy_from_user(¶m, (void __user *)arg, sizeof(param));
|
||||
if (err != 0) {
|
||||
ret = copy_from_user(¶m, (void __user *)arg, sizeof(param));
|
||||
if (ret) {
|
||||
dev_err(dev, "Failed to get transfer param\n");
|
||||
return false;
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
err = pci_endpoint_test_validate_xfer_params(dev, ¶m, alignment);
|
||||
if (err)
|
||||
return false;
|
||||
ret = pci_endpoint_test_validate_xfer_params(dev, ¶m, alignment);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
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) {
|
||||
dev_err(dev, "Invalid IRQ type option\n");
|
||||
goto err;
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
orig_addr = kzalloc(size + alignment, GFP_KERNEL);
|
||||
if (!orig_addr) {
|
||||
dev_err(dev, "Failed to allocate address\n");
|
||||
ret = false;
|
||||
goto err;
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
get_random_bytes(orig_addr, size + alignment);
|
||||
|
||||
orig_phys_addr = dma_map_single(dev, orig_addr, size + alignment,
|
||||
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");
|
||||
ret = false;
|
||||
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);
|
||||
|
||||
reg = pci_endpoint_test_readl(test, PCI_ENDPOINT_TEST_STATUS);
|
||||
if (reg & STATUS_READ_SUCCESS)
|
||||
ret = true;
|
||||
if (!(reg & STATUS_READ_SUCCESS))
|
||||
ret = -EIO;
|
||||
|
||||
dma_unmap_single(dev, orig_phys_addr, size + alignment,
|
||||
DMA_TO_DEVICE);
|
||||
|
||||
err_phys_addr:
|
||||
kfree(orig_addr);
|
||||
|
||||
err:
|
||||
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)
|
||||
{
|
||||
struct pci_endpoint_test_xfer_param param;
|
||||
bool ret = false;
|
||||
u32 flags = 0;
|
||||
bool use_dma;
|
||||
size_t size;
|
||||
|
|
@ -716,17 +717,17 @@ static bool pci_endpoint_test_read(struct pci_endpoint_test *test,
|
|||
size_t alignment = test->alignment;
|
||||
int irq_type = test->irq_type;
|
||||
u32 crc32;
|
||||
int err;
|
||||
int ret;
|
||||
|
||||
err = copy_from_user(¶m, (void __user *)arg, sizeof(param));
|
||||
if (err) {
|
||||
ret = copy_from_user(¶m, (void __user *)arg, sizeof(param));
|
||||
if (ret) {
|
||||
dev_err(dev, "Failed to get transfer param\n");
|
||||
return false;
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
err = pci_endpoint_test_validate_xfer_params(dev, ¶m, alignment);
|
||||
if (err)
|
||||
return false;
|
||||
ret = pci_endpoint_test_validate_xfer_params(dev, ¶m, alignment);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
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) {
|
||||
dev_err(dev, "Invalid IRQ type option\n");
|
||||
goto err;
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
orig_addr = kzalloc(size + alignment, GFP_KERNEL);
|
||||
if (!orig_addr) {
|
||||
dev_err(dev, "Failed to allocate destination address\n");
|
||||
ret = false;
|
||||
goto err;
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
orig_phys_addr = dma_map_single(dev, orig_addr, size + alignment,
|
||||
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");
|
||||
ret = false;
|
||||
goto err_phys_addr;
|
||||
}
|
||||
|
||||
|
|
@ -782,50 +782,51 @@ static bool pci_endpoint_test_read(struct pci_endpoint_test *test,
|
|||
DMA_FROM_DEVICE);
|
||||
|
||||
crc32 = crc32_le(~0, addr, size);
|
||||
if (crc32 == pci_endpoint_test_readl(test, PCI_ENDPOINT_TEST_CHECKSUM))
|
||||
ret = true;
|
||||
if (crc32 != pci_endpoint_test_readl(test, PCI_ENDPOINT_TEST_CHECKSUM))
|
||||
ret = -EIO;
|
||||
|
||||
err_phys_addr:
|
||||
kfree(orig_addr);
|
||||
err:
|
||||
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_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)
|
||||
{
|
||||
struct pci_dev *pdev = test->pdev;
|
||||
struct device *dev = &pdev->dev;
|
||||
int ret;
|
||||
|
||||
if (req_irq_type < IRQ_TYPE_INTX || req_irq_type > IRQ_TYPE_MSIX) {
|
||||
dev_err(dev, "Invalid IRQ type option\n");
|
||||
return false;
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (test->irq_type == req_irq_type)
|
||||
return true;
|
||||
return 0;
|
||||
|
||||
pci_endpoint_test_release_irq(test);
|
||||
pci_endpoint_test_free_irq_vectors(test);
|
||||
|
||||
if (!pci_endpoint_test_alloc_irq_vectors(test, req_irq_type))
|
||||
goto err;
|
||||
ret = pci_endpoint_test_alloc_irq_vectors(test, req_irq_type);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
if (!pci_endpoint_test_request_irq(test))
|
||||
goto err;
|
||||
ret = pci_endpoint_test_request_irq(test);
|
||||
if (ret) {
|
||||
pci_endpoint_test_free_irq_vectors(test);
|
||||
return ret;
|
||||
}
|
||||
|
||||
return true;
|
||||
|
||||
err:
|
||||
pci_endpoint_test_free_irq_vectors(test);
|
||||
return false;
|
||||
return 0;
|
||||
}
|
||||
|
||||
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,
|
||||
const struct pci_device_id *ent)
|
||||
{
|
||||
int err;
|
||||
int ret;
|
||||
int id;
|
||||
char name[24];
|
||||
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));
|
||||
|
||||
err = pci_enable_device(pdev);
|
||||
if (err) {
|
||||
ret = pci_enable_device(pdev);
|
||||
if (ret) {
|
||||
dev_err(dev, "Cannot enable PCI device\n");
|
||||
return err;
|
||||
return ret;
|
||||
}
|
||||
|
||||
err = pci_request_regions(pdev, DRV_MODULE_NAME);
|
||||
if (err) {
|
||||
ret = pci_request_regions(pdev, DRV_MODULE_NAME);
|
||||
if (ret) {
|
||||
dev_err(dev, "Cannot obtain PCI resources\n");
|
||||
goto err_disable_pdev;
|
||||
}
|
||||
|
||||
pci_set_master(pdev);
|
||||
|
||||
if (!pci_endpoint_test_alloc_irq_vectors(test, irq_type)) {
|
||||
err = -EINVAL;
|
||||
ret = pci_endpoint_test_alloc_irq_vectors(test, irq_type);
|
||||
if (ret)
|
||||
goto err_disable_irq;
|
||||
}
|
||||
|
||||
for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
|
||||
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];
|
||||
if (!test->base) {
|
||||
err = -ENOMEM;
|
||||
ret = -ENOMEM;
|
||||
dev_err(dev, "Cannot perform PCI test without BAR%d\n",
|
||||
test_reg_bar);
|
||||
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);
|
||||
if (id < 0) {
|
||||
err = id;
|
||||
ret = id;
|
||||
dev_err(dev, "Unable to get id\n");
|
||||
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);
|
||||
test->name = kstrdup(name, GFP_KERNEL);
|
||||
if (!test->name) {
|
||||
err = -ENOMEM;
|
||||
ret = -ENOMEM;
|
||||
goto err_ida_remove;
|
||||
}
|
||||
|
||||
if (!pci_endpoint_test_request_irq(test)) {
|
||||
err = -EINVAL;
|
||||
ret = pci_endpoint_test_request_irq(test);
|
||||
if (ret)
|
||||
goto err_kfree_test_name;
|
||||
}
|
||||
|
||||
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->name = kstrdup(name, GFP_KERNEL);
|
||||
if (!misc_device->name) {
|
||||
err = -ENOMEM;
|
||||
ret = -ENOMEM;
|
||||
goto err_release_irq;
|
||||
}
|
||||
misc_device->parent = &pdev->dev;
|
||||
misc_device->fops = &pci_endpoint_test_fops;
|
||||
|
||||
err = misc_register(misc_device);
|
||||
if (err) {
|
||||
ret = misc_register(misc_device);
|
||||
if (ret) {
|
||||
dev_err(dev, "Failed to register device\n");
|
||||
goto err_kfree_name;
|
||||
}
|
||||
|
|
@ -1050,7 +1049,7 @@ err_disable_irq:
|
|||
err_disable_pdev:
|
||||
pci_disable_device(pdev);
|
||||
|
||||
return err;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void pci_endpoint_test_remove(struct pci_dev *pdev)
|
||||
|
|
|
|||
|
|
@ -16,7 +16,6 @@
|
|||
|
||||
#include <linux/pcitest.h>
|
||||
|
||||
static char *result[] = { "NOT OKAY", "OKAY" };
|
||||
static char *irq[] = { "LEGACY", "MSI", "MSI-X" };
|
||||
|
||||
struct pci_test {
|
||||
|
|
@ -53,72 +52,74 @@ static int run_test(struct pci_test *test)
|
|||
ret = ioctl(fd, PCITEST_BAR, test->barnum);
|
||||
fprintf(stdout, "BAR%d:\t\t", test->barnum);
|
||||
if (ret < 0)
|
||||
fprintf(stdout, "TEST FAILED\n");
|
||||
fprintf(stdout, "NOT OKAY\n");
|
||||
else
|
||||
fprintf(stdout, "%s\n", result[ret]);
|
||||
fprintf(stdout, "OKAY\n");
|
||||
}
|
||||
|
||||
if (test->consecutive_bar_test) {
|
||||
ret = ioctl(fd, PCITEST_BARS);
|
||||
fprintf(stdout, "Consecutive BAR test:\t\t");
|
||||
if (ret < 0)
|
||||
fprintf(stdout, "TEST FAILED\n");
|
||||
fprintf(stdout, "NOT OKAY\n");
|
||||
else
|
||||
fprintf(stdout, "%s\n", result[ret]);
|
||||
fprintf(stdout, "OKAY\n");
|
||||
}
|
||||
|
||||
if (test->set_irqtype) {
|
||||
ret = ioctl(fd, PCITEST_SET_IRQTYPE, test->irqtype);
|
||||
fprintf(stdout, "SET IRQ TYPE TO %s:\t\t", irq[test->irqtype]);
|
||||
if (ret < 0)
|
||||
fprintf(stdout, "FAILED\n");
|
||||
fprintf(stdout, "NOT OKAY\n");
|
||||
else
|
||||
fprintf(stdout, "%s\n", result[ret]);
|
||||
fprintf(stdout, "OKAY\n");
|
||||
}
|
||||
|
||||
if (test->get_irqtype) {
|
||||
ret = ioctl(fd, PCITEST_GET_IRQTYPE);
|
||||
fprintf(stdout, "GET IRQ TYPE:\t\t");
|
||||
if (ret < 0)
|
||||
fprintf(stdout, "FAILED\n");
|
||||
else
|
||||
if (ret < 0) {
|
||||
fprintf(stdout, "NOT OKAY\n");
|
||||
} else {
|
||||
fprintf(stdout, "%s\n", irq[ret]);
|
||||
ret = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (test->clear_irq) {
|
||||
ret = ioctl(fd, PCITEST_CLEAR_IRQ);
|
||||
fprintf(stdout, "CLEAR IRQ:\t\t");
|
||||
if (ret < 0)
|
||||
fprintf(stdout, "FAILED\n");
|
||||
fprintf(stdout, "NOT OKAY\n");
|
||||
else
|
||||
fprintf(stdout, "%s\n", result[ret]);
|
||||
fprintf(stdout, "OKAY\n");
|
||||
}
|
||||
|
||||
if (test->legacyirq) {
|
||||
ret = ioctl(fd, PCITEST_LEGACY_IRQ, 0);
|
||||
fprintf(stdout, "LEGACY IRQ:\t");
|
||||
if (ret < 0)
|
||||
fprintf(stdout, "TEST FAILED\n");
|
||||
fprintf(stdout, "NOT OKAY\n");
|
||||
else
|
||||
fprintf(stdout, "%s\n", result[ret]);
|
||||
fprintf(stdout, "OKAY\n");
|
||||
}
|
||||
|
||||
if (test->msinum > 0 && test->msinum <= 32) {
|
||||
ret = ioctl(fd, PCITEST_MSI, test->msinum);
|
||||
fprintf(stdout, "MSI%u:\t\t", test->msinum);
|
||||
if (ret < 0)
|
||||
fprintf(stdout, "TEST FAILED\n");
|
||||
fprintf(stdout, "NOT OKAY\n");
|
||||
else
|
||||
fprintf(stdout, "%s\n", result[ret]);
|
||||
fprintf(stdout, "OKAY\n");
|
||||
}
|
||||
|
||||
if (test->msixnum > 0 && test->msixnum <= 2048) {
|
||||
ret = ioctl(fd, PCITEST_MSIX, test->msixnum);
|
||||
fprintf(stdout, "MSI-X%u:\t\t", test->msixnum);
|
||||
if (ret < 0)
|
||||
fprintf(stdout, "TEST FAILED\n");
|
||||
fprintf(stdout, "NOT OKAY\n");
|
||||
else
|
||||
fprintf(stdout, "%s\n", result[ret]);
|
||||
fprintf(stdout, "OKAY\n");
|
||||
}
|
||||
|
||||
if (test->write) {
|
||||
|
|
@ -128,9 +129,9 @@ static int run_test(struct pci_test *test)
|
|||
ret = ioctl(fd, PCITEST_WRITE, ¶m);
|
||||
fprintf(stdout, "WRITE (%7lu bytes):\t\t", test->size);
|
||||
if (ret < 0)
|
||||
fprintf(stdout, "TEST FAILED\n");
|
||||
fprintf(stdout, "NOT OKAY\n");
|
||||
else
|
||||
fprintf(stdout, "%s\n", result[ret]);
|
||||
fprintf(stdout, "OKAY\n");
|
||||
}
|
||||
|
||||
if (test->read) {
|
||||
|
|
@ -140,9 +141,9 @@ static int run_test(struct pci_test *test)
|
|||
ret = ioctl(fd, PCITEST_READ, ¶m);
|
||||
fprintf(stdout, "READ (%7lu bytes):\t\t", test->size);
|
||||
if (ret < 0)
|
||||
fprintf(stdout, "TEST FAILED\n");
|
||||
fprintf(stdout, "NOT OKAY\n");
|
||||
else
|
||||
fprintf(stdout, "%s\n", result[ret]);
|
||||
fprintf(stdout, "OKAY\n");
|
||||
}
|
||||
|
||||
if (test->copy) {
|
||||
|
|
@ -152,14 +153,14 @@ static int run_test(struct pci_test *test)
|
|||
ret = ioctl(fd, PCITEST_COPY, ¶m);
|
||||
fprintf(stdout, "COPY (%7lu bytes):\t\t", test->size);
|
||||
if (ret < 0)
|
||||
fprintf(stdout, "TEST FAILED\n");
|
||||
fprintf(stdout, "NOT OKAY\n");
|
||||
else
|
||||
fprintf(stdout, "%s\n", result[ret]);
|
||||
fprintf(stdout, "OKAY\n");
|
||||
}
|
||||
|
||||
fflush(stdout);
|
||||
close(fd);
|
||||
return (ret < 0) ? ret : 1 - ret; /* return 0 if test succeeded */
|
||||
return ret;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue