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

misc: pci_endpoint_test: Add support to provide aligned buffer addresses

Browse Source 
Some platforms like TI's K2G have a restriction that the host side buffer
address should be aligned to either 1MB/2MB/4MB or 8MB (Ref: 11.14.4.9.1
Outbound Address Translation in K2G TRM SPRUHY8F January 2016 – Revised May
2017) addresses depending on how it is configured in the endpoint.

Add support to provide such aligned address here so that pci_endpoint_test
driver can be used to test K2G EP.

Signed-off-by: Kishon Vijay Abraham I <kishon@ti.com>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
This commit is contained in:
Kishon Vijay Abraham I 2017-08-18 20:28:06 +05:30 committed by Bjorn Helgaas
parent 834b905199
commit 13107c6068
1 changed files with 76 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
drivers/misc/pci_endpoint_test.c
View File

@ -91,10 +91,12 @@ struct pci_endpoint_test {
struct mutex mutex; struct mutex mutex;
struct miscdevice miscdev; struct miscdevice miscdev;
enum pci_barno test_reg_bar; enum pci_barno test_reg_bar;
size_t alignment;
}; };
struct pci_endpoint_test_data { struct pci_endpoint_test_data {
enum pci_barno test_reg_bar; enum pci_barno test_reg_bar;
size_t alignment;
}; };
static int bar_size[] = { 512, 512, 1024, 16384, 131072, 1048576 }; static int bar_size[] = { 512, 512, 1024, 16384, 131072, 1048576 };
@ -210,16 +212,32 @@ static bool pci_endpoint_test_copy(struct pci_endpoint_test *test, size_t size)
dma_addr_t dst_phys_addr; dma_addr_t dst_phys_addr;
struct pci_dev *pdev = test->pdev; struct pci_dev *pdev = test->pdev;
struct device *dev = &pdev->dev; struct device *dev = &pdev->dev;
void *orig_src_addr;
dma_addr_t orig_src_phys_addr;
void *orig_dst_addr;
dma_addr_t orig_dst_phys_addr;
size_t offset;
size_t alignment = test->alignment;
u32 src_crc32; u32 src_crc32;
u32 dst_crc32; u32 dst_crc32;
src_addr = dma_alloc_coherent(dev, size, &src_phys_addr, GFP_KERNEL); orig_src_addr = dma_alloc_coherent(dev, size + alignment,
if (!src_addr) { &orig_src_phys_addr, GFP_KERNEL);
if (!orig_src_addr) {
dev_err(dev, "failed to allocate source buffer\n"); dev_err(dev, "failed to allocate source buffer\n");
ret = false; ret = false;
goto err; goto err;
} }
if (alignment && !IS_ALIGNED(orig_src_phys_addr, alignment)) {
src_phys_addr = PTR_ALIGN(orig_src_phys_addr, alignment);
offset = src_phys_addr - orig_src_phys_addr;
src_addr = orig_src_addr + offset;
} else {
src_phys_addr = orig_src_phys_addr;
src_addr = orig_src_addr;
}
pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_LOWER_SRC_ADDR, pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_LOWER_SRC_ADDR,
lower_32_bits(src_phys_addr)); lower_32_bits(src_phys_addr));
@ -229,11 +247,21 @@ static bool pci_endpoint_test_copy(struct pci_endpoint_test *test, size_t size)
get_random_bytes(src_addr, size); get_random_bytes(src_addr, size);
src_crc32 = crc32_le(~0, src_addr, size); src_crc32 = crc32_le(~0, src_addr, size);
dst_addr = dma_alloc_coherent(dev, size, &dst_phys_addr, GFP_KERNEL); orig_dst_addr = dma_alloc_coherent(dev, size + alignment,
if (!dst_addr) { &orig_dst_phys_addr, GFP_KERNEL);
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 = false;
goto err_src_addr; goto err_orig_src_addr;
}
if (alignment && !IS_ALIGNED(orig_dst_phys_addr, alignment)) {
dst_phys_addr = PTR_ALIGN(orig_dst_phys_addr, alignment);
offset = dst_phys_addr - orig_dst_phys_addr;
dst_addr = orig_dst_addr + offset;
} else {
dst_phys_addr = orig_dst_phys_addr;
dst_addr = orig_dst_addr;
} }
pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_LOWER_DST_ADDR, pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_LOWER_DST_ADDR,
@ -253,10 +281,12 @@ static bool pci_endpoint_test_copy(struct pci_endpoint_test *test, size_t size)
if (dst_crc32 == src_crc32) if (dst_crc32 == src_crc32)
ret = true; ret = true;
dma_free_coherent(dev, size, dst_addr, dst_phys_addr); dma_free_coherent(dev, size + alignment, orig_dst_addr,
orig_dst_phys_addr);
err_src_addr: err_orig_src_addr:
dma_free_coherent(dev, size, src_addr, src_phys_addr); dma_free_coherent(dev, size + alignment, orig_src_addr,
orig_src_phys_addr);
err: err:
return ret; return ret;
@ -270,15 +300,29 @@ static bool pci_endpoint_test_write(struct pci_endpoint_test *test, size_t size)
dma_addr_t phys_addr; dma_addr_t phys_addr;
struct pci_dev *pdev = test->pdev; struct pci_dev *pdev = test->pdev;
struct device *dev = &pdev->dev; struct device *dev = &pdev->dev;
void *orig_addr;
dma_addr_t orig_phys_addr;
size_t offset;
size_t alignment = test->alignment;
u32 crc32; u32 crc32;
addr = dma_alloc_coherent(dev, size, &phys_addr, GFP_KERNEL); orig_addr = dma_alloc_coherent(dev, size + alignment, &orig_phys_addr,
if (!addr) { GFP_KERNEL);
if (!orig_addr) {
dev_err(dev, "failed to allocate address\n"); dev_err(dev, "failed to allocate address\n");
ret = false; ret = false;
goto err; goto err;
} }
if (alignment && !IS_ALIGNED(orig_phys_addr, alignment)) {
phys_addr = PTR_ALIGN(orig_phys_addr, alignment);
offset = phys_addr - orig_phys_addr;
addr = orig_addr + offset;
} else {
phys_addr = orig_phys_addr;
addr = orig_addr;
}
get_random_bytes(addr, size); get_random_bytes(addr, size);
crc32 = crc32_le(~0, addr, size); crc32 = crc32_le(~0, addr, size);
@ -301,7 +345,7 @@ static bool pci_endpoint_test_write(struct pci_endpoint_test *test, size_t size)
if (reg & STATUS_READ_SUCCESS) if (reg & STATUS_READ_SUCCESS)
ret = true; ret = true;
dma_free_coherent(dev, size, addr, phys_addr); dma_free_coherent(dev, size + alignment, orig_addr, orig_phys_addr);
err: err:
return ret; return ret;
@ -314,15 +358,29 @@ static bool pci_endpoint_test_read(struct pci_endpoint_test *test, size_t size)
dma_addr_t phys_addr; dma_addr_t phys_addr;
struct pci_dev *pdev = test->pdev; struct pci_dev *pdev = test->pdev;
struct device *dev = &pdev->dev; struct device *dev = &pdev->dev;
void *orig_addr;
dma_addr_t orig_phys_addr;
size_t offset;
size_t alignment = test->alignment;
u32 crc32; u32 crc32;
addr = dma_alloc_coherent(dev, size, &phys_addr, GFP_KERNEL); orig_addr = dma_alloc_coherent(dev, size + alignment, &orig_phys_addr,
if (!addr) { GFP_KERNEL);
if (!orig_addr) {
dev_err(dev, "failed to allocate destination address\n"); dev_err(dev, "failed to allocate destination address\n");
ret = false; ret = false;
goto err; goto err;
} }
if (alignment && !IS_ALIGNED(orig_phys_addr, alignment)) {
phys_addr = PTR_ALIGN(orig_phys_addr, alignment);
offset = phys_addr - orig_phys_addr;
addr = orig_addr + offset;
} else {
phys_addr = orig_phys_addr;
addr = orig_addr;
}
pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_LOWER_DST_ADDR, pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_LOWER_DST_ADDR,
lower_32_bits(phys_addr)); lower_32_bits(phys_addr));
pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_UPPER_DST_ADDR, pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_UPPER_DST_ADDR,
@ -339,7 +397,7 @@ static bool pci_endpoint_test_read(struct pci_endpoint_test *test, size_t 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 = true;
dma_free_coherent(dev, size, addr, phys_addr); dma_free_coherent(dev, size + alignment, orig_addr, orig_phys_addr);
err: err:
return ret; return ret;
} }
@ -410,11 +468,14 @@ static int pci_endpoint_test_probe(struct pci_dev *pdev,
return -ENOMEM; return -ENOMEM;
test->test_reg_bar = 0; test->test_reg_bar = 0;
test->alignment = 0;
test->pdev = pdev; test->pdev = pdev;
data = (struct pci_endpoint_test_data *)ent->driver_data; data = (struct pci_endpoint_test_data *)ent->driver_data;
if (data) if (data) {
test_reg_bar = data->test_reg_bar; test_reg_bar = data->test_reg_bar;
test->alignment = data->alignment;
}
init_completion(&test->irq_raised); init_completion(&test->irq_raised);
mutex_init(&test->mutex); mutex_init(&test->mutex);