drivers/misc/pci_endpoint_test.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /**
   3  * Host side test driver to test endpoint functionality
   4  *
   5  * Copyright (C) 2017 Texas Instruments
   6  * Author: Kishon Vijay Abraham I <kishon@ti.com>
   7  */
   8
   9 #include <linux/crc32.h>
  10 #include <linux/delay.h>
  11 #include <linux/fs.h>
  12 #include <linux/io.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/irq.h>
  15 #include <linux/miscdevice.h>
  16 #include <linux/module.h>
  17 #include <linux/mutex.h>
  18 #include <linux/random.h>
  19 #include <linux/slab.h>
  20 #include <linux/uaccess.h>
  21 #include <linux/pci.h>
  22 #include <linux/pci_ids.h>
  23
  24 #include <linux/pci_regs.h>
  25
  26 #include <uapi/linux/pcitest.h>
  27
  28 #define DRV_MODULE_NAME                         "pci-endpoint-test"
  29
  30 #define IRQ_TYPE_UNDEFINED                      -1
  31 #define IRQ_TYPE_LEGACY                         0
  32 #define IRQ_TYPE_MSI                            1
  33 #define IRQ_TYPE_MSIX                           2
  34
  35 #define PCI_ENDPOINT_TEST_MAGIC                 0x0
  36
  37 #define PCI_ENDPOINT_TEST_COMMAND               0x4
  38 #define COMMAND_RAISE_LEGACY_IRQ                BIT(0)
  39 #define COMMAND_RAISE_MSI_IRQ                   BIT(1)
  40 #define COMMAND_RAISE_MSIX_IRQ                  BIT(2)
  41 #define COMMAND_READ                            BIT(3)
  42 #define COMMAND_WRITE                           BIT(4)
  43 #define COMMAND_COPY                            BIT(5)
  44
  45 #define PCI_ENDPOINT_TEST_STATUS                0x8
  46 #define STATUS_READ_SUCCESS                     BIT(0)
  47 #define STATUS_READ_FAIL                        BIT(1)
  48 #define STATUS_WRITE_SUCCESS                    BIT(2)
  49 #define STATUS_WRITE_FAIL                       BIT(3)
  50 #define STATUS_COPY_SUCCESS                     BIT(4)
  51 #define STATUS_COPY_FAIL                        BIT(5)
  52 #define STATUS_IRQ_RAISED                       BIT(6)
  53 #define STATUS_SRC_ADDR_INVALID                 BIT(7)
  54 #define STATUS_DST_ADDR_INVALID                 BIT(8)
  55
  56 #define PCI_ENDPOINT_TEST_STATUS                0x8
  57 #define PCI_ENDPOINT_TEST_LOWER_SRC_ADDR        0x0c
  58 #define PCI_ENDPOINT_TEST_UPPER_SRC_ADDR        0x10
  59
  60 #define PCI_ENDPOINT_TEST_LOWER_DST_ADDR        0x14
  61 #define PCI_ENDPOINT_TEST_UPPER_DST_ADDR        0x18
  62
  63 #define PCI_ENDPOINT_TEST_SIZE                  0x1c
  64 #define PCI_ENDPOINT_TEST_CHECKSUM              0x20
  65
  66 #define PCI_ENDPOINT_TEST_IRQ_TYPE              0x24
  67 #define PCI_ENDPOINT_TEST_IRQ_NUMBER            0x28
  68
  69 #define PCI_ENDPOINT_TEST_FLAGS                 0x2c
  70 #define FLAG_USE_DMA                            BIT(0)
  71
  72 #define PCI_DEVICE_ID_TI_AM654                  0xb00c
  73
  74 #define is_am654_pci_dev(pdev)          \
  75                 ((pdev)->device == PCI_DEVICE_ID_TI_AM654)
  76
  77 static DEFINE_IDA(pci_endpoint_test_ida);
  78
  79 #define to_endpoint_test(priv) container_of((priv), struct pci_endpoint_test, \
  80                                             miscdev)
  81
  82 static bool no_msi;
  83 module_param(no_msi, bool, 0444);
  84 MODULE_PARM_DESC(no_msi, "Disable MSI interrupt in pci_endpoint_test");
  85
  86 static int irq_type = IRQ_TYPE_MSI;
  87 module_param(irq_type, int, 0444);
  88 MODULE_PARM_DESC(irq_type, "IRQ mode selection in pci_endpoint_test (0 - Legacy, 1 - MSI, 2 - MSI-X)");
  89
  90 enum pci_barno {
  91         BAR_0,
  92         BAR_1,
  93         BAR_2,
  94         BAR_3,
  95         BAR_4,
  96         BAR_5,
  97 };
  98
  99 struct pci_endpoint_test {
 100         struct pci_dev  *pdev;
 101         void __iomem    *base;
 102         void __iomem    *bar[PCI_STD_NUM_BARS];
 103         struct completion irq_raised;
 104         int             last_irq;
 105         int             num_irqs;
 106         /* mutex to protect the ioctls */
 107         struct mutex    mutex;
 108         struct miscdevice miscdev;
 109         enum pci_barno test_reg_bar;
 110         size_t alignment;
 111 };
 112
 113 struct pci_endpoint_test_data {
 114         enum pci_barno test_reg_bar;
 115         size_t alignment;
 116         int irq_type;
 117 };
 118
 119 static inline u32 pci_endpoint_test_readl(struct pci_endpoint_test *test,
 120                                           u32 offset)
 121 {
 122         return readl(test->base + offset);
 123 }
 124
 125 static inline void pci_endpoint_test_writel(struct pci_endpoint_test *test,
 126                                             u32 offset, u32 value)
 127 {
 128         writel(value, test->base + offset);
 129 }
 130
 131 static inline u32 pci_endpoint_test_bar_readl(struct pci_endpoint_test *test,
 132                                               int bar, int offset)
 133 {
 134         return readl(test->bar[bar] + offset);
 135 }
 136
 137 static inline void pci_endpoint_test_bar_writel(struct pci_endpoint_test *test,
 138                                                 int bar, u32 offset, u32 value)
 139 {
 140         writel(value, test->bar[bar] + offset);
 141 }
 142
 143 static irqreturn_t pci_endpoint_test_irqhandler(int irq, void *dev_id)
 144 {
 145         struct pci_endpoint_test *test = dev_id;
 146         u32 reg;
 147
 148         reg = pci_endpoint_test_readl(test, PCI_ENDPOINT_TEST_STATUS);
 149         if (reg & STATUS_IRQ_RAISED) {
 150                 test->last_irq = irq;
 151                 complete(&test->irq_raised);
 152                 reg &= ~STATUS_IRQ_RAISED;
 153         }
 154         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_STATUS,
 155                                  reg);
 156
 157         return IRQ_HANDLED;
 158 }
 159
 160 static void pci_endpoint_test_free_irq_vectors(struct pci_endpoint_test *test)
 161 {
 162         struct pci_dev *pdev = test->pdev;
 163
 164         pci_free_irq_vectors(pdev);
 165 }
 166
 167 static bool pci_endpoint_test_alloc_irq_vectors(struct pci_endpoint_test *test,
 168                                                 int type)
 169 {
 170         int irq = -1;
 171         struct pci_dev *pdev = test->pdev;
 172         struct device *dev = &pdev->dev;
 173         bool res = true;
 174
 175         switch (type) {
 176         case IRQ_TYPE_LEGACY:
 177                 irq = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_LEGACY);
 178                 if (irq < 0)
 179                         dev_err(dev, "Failed to get Legacy interrupt\n");
 180                 break;
 181         case IRQ_TYPE_MSI:
 182                 irq = pci_alloc_irq_vectors(pdev, 1, 32, PCI_IRQ_MSI);
 183                 if (irq < 0)
 184                         dev_err(dev, "Failed to get MSI interrupts\n");
 185                 break;
 186         case IRQ_TYPE_MSIX:
 187                 irq = pci_alloc_irq_vectors(pdev, 1, 2048, PCI_IRQ_MSIX);
 188                 if (irq < 0)
 189                         dev_err(dev, "Failed to get MSI-X interrupts\n");
 190                 break;
 191         default:
 192                 dev_err(dev, "Invalid IRQ type selected\n");
 193         }
 194
 195         if (irq < 0) {
 196                 irq = 0;
 197                 res = false;
 198         }
 199         test->num_irqs = irq;
 200
 201         return res;
 202 }
 203
 204 static void pci_endpoint_test_release_irq(struct pci_endpoint_test *test)
 205 {
 206         int i;
 207         struct pci_dev *pdev = test->pdev;
 208         struct device *dev = &pdev->dev;
 209
 210         for (i = 0; i < test->num_irqs; i++)
 211                 devm_free_irq(dev, pci_irq_vector(pdev, i), test);
 212
 213         test->num_irqs = 0;
 214 }
 215
 216 static bool pci_endpoint_test_request_irq(struct pci_endpoint_test *test)
 217 {
 218         int i;
 219         int err;
 220         struct pci_dev *pdev = test->pdev;
 221         struct device *dev = &pdev->dev;
 222
 223         for (i = 0; i < test->num_irqs; i++) {
 224                 err = devm_request_irq(dev, pci_irq_vector(pdev, i),
 225                                        pci_endpoint_test_irqhandler,
 226                                        IRQF_SHARED, DRV_MODULE_NAME, test);
 227                 if (err)
 228                         goto fail;
 229         }
 230
 231         return true;
 232
 233 fail:
 234         switch (irq_type) {
 235         case IRQ_TYPE_LEGACY:
 236                 dev_err(dev, "Failed to request IRQ %d for Legacy\n",
 237                         pci_irq_vector(pdev, i));
 238                 break;
 239         case IRQ_TYPE_MSI:
 240                 dev_err(dev, "Failed to request IRQ %d for MSI %d\n",
 241                         pci_irq_vector(pdev, i),
 242                         i + 1);
 243                 break;
 244         case IRQ_TYPE_MSIX:
 245                 dev_err(dev, "Failed to request IRQ %d for MSI-X %d\n",
 246                         pci_irq_vector(pdev, i),
 247                         i + 1);
 248                 break;
 249         }
 250
 251         return false;
 252 }
 253
 254 static bool pci_endpoint_test_bar(struct pci_endpoint_test *test,
 255                                   enum pci_barno barno)
 256 {
 257         int j;
 258         u32 val;
 259         int size;
 260         struct pci_dev *pdev = test->pdev;
 261
 262         if (!test->bar[barno])
 263                 return false;
 264
 265         size = pci_resource_len(pdev, barno);
 266
 267         if (barno == test->test_reg_bar)
 268                 size = 0x4;
 269
 270         for (j = 0; j < size; j += 4)
 271                 pci_endpoint_test_bar_writel(test, barno, j, 0xA0A0A0A0);
 272
 273         for (j = 0; j < size; j += 4) {
 274                 val = pci_endpoint_test_bar_readl(test, barno, j);
 275                 if (val != 0xA0A0A0A0)
 276                         return false;
 277         }
 278
 279         return true;
 280 }
 281
 282 static bool pci_endpoint_test_legacy_irq(struct pci_endpoint_test *test)
 283 {
 284         u32 val;
 285
 286         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_TYPE,
 287                                  IRQ_TYPE_LEGACY);
 288         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_NUMBER, 0);
 289         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_COMMAND,
 290                                  COMMAND_RAISE_LEGACY_IRQ);
 291         val = wait_for_completion_timeout(&test->irq_raised,
 292                                           msecs_to_jiffies(1000));
 293         if (!val)
 294                 return false;
 295
 296         return true;
 297 }
 298
 299 static bool pci_endpoint_test_msi_irq(struct pci_endpoint_test *test,
 300                                        u16 msi_num, bool msix)
 301 {
 302         u32 val;
 303         struct pci_dev *pdev = test->pdev;
 304
 305         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_TYPE,
 306                                  msix == false ? IRQ_TYPE_MSI :
 307                                  IRQ_TYPE_MSIX);
 308         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_NUMBER, msi_num);
 309         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_COMMAND,
 310                                  msix == false ? COMMAND_RAISE_MSI_IRQ :
 311                                  COMMAND_RAISE_MSIX_IRQ);
 312         val = wait_for_completion_timeout(&test->irq_raised,
 313                                           msecs_to_jiffies(1000));
 314         if (!val)
 315                 return false;
 316
 317         if (pci_irq_vector(pdev, msi_num - 1) == test->last_irq)
 318                 return true;
 319
 320         return false;
 321 }
 322
 323 static bool pci_endpoint_test_copy(struct pci_endpoint_test *test,
 324                                    unsigned long arg)
 325 {
 326         struct pci_endpoint_test_xfer_param param;
 327         bool ret = false;
 328         void *src_addr;
 329         void *dst_addr;
 330         u32 flags = 0;
 331         bool use_dma;
 332         size_t size;
 333         dma_addr_t src_phys_addr;
 334         dma_addr_t dst_phys_addr;
 335         struct pci_dev *pdev = test->pdev;
 336         struct device *dev = &pdev->dev;
 337         void *orig_src_addr;
 338         dma_addr_t orig_src_phys_addr;
 339         void *orig_dst_addr;
 340         dma_addr_t orig_dst_phys_addr;
 341         size_t offset;
 342         size_t alignment = test->alignment;
 343         u32 src_crc32;
 344         u32 dst_crc32;
 345         int err;
 346
 347         err = copy_from_user(&param, (void __user *)arg, sizeof(param));
 348         if (err) {
 349                 dev_err(dev, "Failed to get transfer param\n");
 350                 return false;
 351         }
 352
 353         size = param.size;
 354         if (size > SIZE_MAX - alignment)
 355                 goto err;
 356
 357         use_dma = !!(param.flags & PCITEST_FLAGS_USE_DMA);
 358         if (use_dma)
 359                 flags |= FLAG_USE_DMA;
 360
 361         if (irq_type < IRQ_TYPE_LEGACY || irq_type > IRQ_TYPE_MSIX) {
 362                 dev_err(dev, "Invalid IRQ type option\n");
 363                 goto err;
 364         }
 365
 366         orig_src_addr = kzalloc(size + alignment, GFP_KERNEL);
 367         if (!orig_src_addr) {
 368                 dev_err(dev, "Failed to allocate source buffer\n");
 369                 ret = false;
 370                 goto err;
 371         }
 372
 373         get_random_bytes(orig_src_addr, size + alignment);
 374         orig_src_phys_addr = dma_map_single(dev, orig_src_addr,
 375                                             size + alignment, DMA_TO_DEVICE);
 376         if (dma_mapping_error(dev, orig_src_phys_addr)) {
 377                 dev_err(dev, "failed to map source buffer address\n");
 378                 ret = false;
 379                 goto err_src_phys_addr;
 380         }
 381
 382         if (alignment && !IS_ALIGNED(orig_src_phys_addr, alignment)) {
 383                 src_phys_addr = PTR_ALIGN(orig_src_phys_addr, alignment);
 384                 offset = src_phys_addr - orig_src_phys_addr;
 385                 src_addr = orig_src_addr + offset;
 386         } else {
 387                 src_phys_addr = orig_src_phys_addr;
 388                 src_addr = orig_src_addr;
 389         }
 390
 391         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_LOWER_SRC_ADDR,
 392                                  lower_32_bits(src_phys_addr));
 393
 394         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_UPPER_SRC_ADDR,
 395                                  upper_32_bits(src_phys_addr));
 396
 397         src_crc32 = crc32_le(~0, src_addr, size);
 398
 399         orig_dst_addr = kzalloc(size + alignment, GFP_KERNEL);
 400         if (!orig_dst_addr) {
 401                 dev_err(dev, "Failed to allocate destination address\n");
 402                 ret = false;
 403                 goto err_dst_addr;
 404         }
 405
 406         orig_dst_phys_addr = dma_map_single(dev, orig_dst_addr,
 407                                             size + alignment, DMA_FROM_DEVICE);
 408         if (dma_mapping_error(dev, orig_dst_phys_addr)) {
 409                 dev_err(dev, "failed to map destination buffer address\n");
 410                 ret = false;
 411                 goto err_dst_phys_addr;
 412         }
 413
 414         if (alignment && !IS_ALIGNED(orig_dst_phys_addr, alignment)) {
 415                 dst_phys_addr = PTR_ALIGN(orig_dst_phys_addr, alignment);
 416                 offset = dst_phys_addr - orig_dst_phys_addr;
 417                 dst_addr = orig_dst_addr + offset;
 418         } else {
 419                 dst_phys_addr = orig_dst_phys_addr;
 420                 dst_addr = orig_dst_addr;
 421         }
 422
 423         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_LOWER_DST_ADDR,
 424                                  lower_32_bits(dst_phys_addr));
 425         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_UPPER_DST_ADDR,
 426                                  upper_32_bits(dst_phys_addr));
 427
 428         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_SIZE,
 429                                  size);
 430
 431         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_FLAGS, flags);
 432         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_TYPE, irq_type);
 433         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_NUMBER, 1);
 434         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_COMMAND,
 435                                  COMMAND_COPY);
 436
 437         wait_for_completion(&test->irq_raised);
 438
 439         dma_unmap_single(dev, orig_dst_phys_addr, size + alignment,
 440                          DMA_FROM_DEVICE);
 441
 442         dst_crc32 = crc32_le(~0, dst_addr, size);
 443         if (dst_crc32 == src_crc32)
 444                 ret = true;
 445
 446 err_dst_phys_addr:
 447         kfree(orig_dst_addr);
 448
 449 err_dst_addr:
 450         dma_unmap_single(dev, orig_src_phys_addr, size + alignment,
 451                          DMA_TO_DEVICE);
 452
 453 err_src_phys_addr:
 454         kfree(orig_src_addr);
 455
 456 err:
 457         return ret;
 458 }
 459
 460 static bool pci_endpoint_test_write(struct pci_endpoint_test *test,
 461                                     unsigned long arg)
 462 {
 463         struct pci_endpoint_test_xfer_param param;
 464         bool ret = false;
 465         u32 flags = 0;
 466         bool use_dma;
 467         u32 reg;
 468         void *addr;
 469         dma_addr_t phys_addr;
 470         struct pci_dev *pdev = test->pdev;
 471         struct device *dev = &pdev->dev;
 472         void *orig_addr;
 473         dma_addr_t orig_phys_addr;
 474         size_t offset;
 475         size_t alignment = test->alignment;
 476         size_t size;
 477         u32 crc32;
 478         int err;
 479
 480         err = copy_from_user(&param, (void __user *)arg, sizeof(param));
 481         if (err != 0) {
 482                 dev_err(dev, "Failed to get transfer param\n");
 483                 return false;
 484         }
 485
 486         size = param.size;
 487         if (size > SIZE_MAX - alignment)
 488                 goto err;
 489
 490         use_dma = !!(param.flags & PCITEST_FLAGS_USE_DMA);
 491         if (use_dma)
 492                 flags |= FLAG_USE_DMA;
 493
 494         if (irq_type < IRQ_TYPE_LEGACY || irq_type > IRQ_TYPE_MSIX) {
 495                 dev_err(dev, "Invalid IRQ type option\n");
 496                 goto err;
 497         }
 498
 499         orig_addr = kzalloc(size + alignment, GFP_KERNEL);
 500         if (!orig_addr) {
 501                 dev_err(dev, "Failed to allocate address\n");
 502                 ret = false;
 503                 goto err;
 504         }
 505
 506         get_random_bytes(orig_addr, size + alignment);
 507
 508         orig_phys_addr = dma_map_single(dev, orig_addr, size + alignment,
 509                                         DMA_TO_DEVICE);
 510         if (dma_mapping_error(dev, orig_phys_addr)) {
 511                 dev_err(dev, "failed to map source buffer address\n");
 512                 ret = false;
 513                 goto err_phys_addr;
 514         }
 515
 516         if (alignment && !IS_ALIGNED(orig_phys_addr, alignment)) {
 517                 phys_addr =  PTR_ALIGN(orig_phys_addr, alignment);
 518                 offset = phys_addr - orig_phys_addr;
 519                 addr = orig_addr + offset;
 520         } else {
 521                 phys_addr = orig_phys_addr;
 522                 addr = orig_addr;
 523         }
 524
 525         crc32 = crc32_le(~0, addr, size);
 526         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_CHECKSUM,
 527                                  crc32);
 528
 529         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_LOWER_SRC_ADDR,
 530                                  lower_32_bits(phys_addr));
 531         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_UPPER_SRC_ADDR,
 532                                  upper_32_bits(phys_addr));
 533
 534         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_SIZE, size);
 535
 536         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_FLAGS, flags);
 537         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_TYPE, irq_type);
 538         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_NUMBER, 1);
 539         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_COMMAND,
 540                                  COMMAND_READ);
 541
 542         wait_for_completion(&test->irq_raised);
 543
 544         reg = pci_endpoint_test_readl(test, PCI_ENDPOINT_TEST_STATUS);
 545         if (reg & STATUS_READ_SUCCESS)
 546                 ret = true;
 547
 548         dma_unmap_single(dev, orig_phys_addr, size + alignment,
 549                          DMA_TO_DEVICE);
 550
 551 err_phys_addr:
 552         kfree(orig_addr);
 553
 554 err:
 555         return ret;
 556 }
 557
 558 static bool pci_endpoint_test_read(struct pci_endpoint_test *test,
 559                                    unsigned long arg)
 560 {
 561         struct pci_endpoint_test_xfer_param param;
 562         bool ret = false;
 563         u32 flags = 0;
 564         bool use_dma;
 565         size_t size;
 566         void *addr;
 567         dma_addr_t phys_addr;
 568         struct pci_dev *pdev = test->pdev;
 569         struct device *dev = &pdev->dev;
 570         void *orig_addr;
 571         dma_addr_t orig_phys_addr;
 572         size_t offset;
 573         size_t alignment = test->alignment;
 574         u32 crc32;
 575         int err;
 576
 577         err = copy_from_user(&param, (void __user *)arg, sizeof(param));
 578         if (err) {
 579                 dev_err(dev, "Failed to get transfer param\n");
 580                 return false;
 581         }
 582
 583         size = param.size;
 584         if (size > SIZE_MAX - alignment)
 585                 goto err;
 586
 587         use_dma = !!(param.flags & PCITEST_FLAGS_USE_DMA);
 588         if (use_dma)
 589                 flags |= FLAG_USE_DMA;
 590
 591         if (irq_type < IRQ_TYPE_LEGACY || irq_type > IRQ_TYPE_MSIX) {
 592                 dev_err(dev, "Invalid IRQ type option\n");
 593                 goto err;
 594         }
 595
 596         orig_addr = kzalloc(size + alignment, GFP_KERNEL);
 597         if (!orig_addr) {
 598                 dev_err(dev, "Failed to allocate destination address\n");
 599                 ret = false;
 600                 goto err;
 601         }
 602
 603         orig_phys_addr = dma_map_single(dev, orig_addr, size + alignment,
 604                                         DMA_FROM_DEVICE);
 605         if (dma_mapping_error(dev, orig_phys_addr)) {
 606                 dev_err(dev, "failed to map source buffer address\n");
 607                 ret = false;
 608                 goto err_phys_addr;
 609         }
 610
 611         if (alignment && !IS_ALIGNED(orig_phys_addr, alignment)) {
 612                 phys_addr = PTR_ALIGN(orig_phys_addr, alignment);
 613                 offset = phys_addr - orig_phys_addr;
 614                 addr = orig_addr + offset;
 615         } else {
 616                 phys_addr = orig_phys_addr;
 617                 addr = orig_addr;
 618         }
 619
 620         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_LOWER_DST_ADDR,
 621                                  lower_32_bits(phys_addr));
 622         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_UPPER_DST_ADDR,
 623                                  upper_32_bits(phys_addr));
 624
 625         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_SIZE, size);
 626
 627         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_FLAGS, flags);
 628         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_TYPE, irq_type);
 629         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_NUMBER, 1);
 630         pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_COMMAND,
 631                                  COMMAND_WRITE);
 632
 633         wait_for_completion(&test->irq_raised);
 634
 635         dma_unmap_single(dev, orig_phys_addr, size + alignment,
 636                          DMA_FROM_DEVICE);
 637
 638         crc32 = crc32_le(~0, addr, size);
 639         if (crc32 == pci_endpoint_test_readl(test, PCI_ENDPOINT_TEST_CHECKSUM))
 640                 ret = true;
 641
 642 err_phys_addr:
 643         kfree(orig_addr);
 644 err:
 645         return ret;
 646 }
 647
 648 static bool pci_endpoint_test_set_irq(struct pci_endpoint_test *test,
 649                                       int req_irq_type)
 650 {
 651         struct pci_dev *pdev = test->pdev;
 652         struct device *dev = &pdev->dev;
 653
 654         if (req_irq_type < IRQ_TYPE_LEGACY || req_irq_type > IRQ_TYPE_MSIX) {
 655                 dev_err(dev, "Invalid IRQ type option\n");
 656                 return false;
 657         }
 658
 659         if (irq_type == req_irq_type)
 660                 return true;
 661
 662         pci_endpoint_test_release_irq(test);
 663         pci_endpoint_test_free_irq_vectors(test);
 664
 665         if (!pci_endpoint_test_alloc_irq_vectors(test, req_irq_type))
 666                 goto err;
 667
 668         if (!pci_endpoint_test_request_irq(test))
 669                 goto err;
 670
 671         irq_type = req_irq_type;
 672         return true;
 673
 674 err:
 675         pci_endpoint_test_free_irq_vectors(test);
 676         irq_type = IRQ_TYPE_UNDEFINED;
 677         return false;
 678 }
 679
 680 static long pci_endpoint_test_ioctl(struct file *file, unsigned int cmd,
 681                                     unsigned long arg)
 682 {
 683         int ret = -EINVAL;
 684         enum pci_barno bar;
 685         struct pci_endpoint_test *test = to_endpoint_test(file->private_data);
 686         struct pci_dev *pdev = test->pdev;
 687
 688         mutex_lock(&test->mutex);
 689         switch (cmd) {
 690         case PCITEST_BAR:
 691                 bar = arg;
 692                 if (bar < 0 || bar > 5)
 693                         goto ret;
 694                 if (is_am654_pci_dev(pdev) && bar == BAR_0)
 695                         goto ret;
 696                 ret = pci_endpoint_test_bar(test, bar);
 697                 break;
 698         case PCITEST_LEGACY_IRQ:
 699                 ret = pci_endpoint_test_legacy_irq(test);
 700                 break;
 701         case PCITEST_MSI:
 702         case PCITEST_MSIX:
 703                 ret = pci_endpoint_test_msi_irq(test, arg, cmd == PCITEST_MSIX);
 704                 break;
 705         case PCITEST_WRITE:
 706                 ret = pci_endpoint_test_write(test, arg);
 707                 break;
 708         case PCITEST_READ:
 709                 ret = pci_endpoint_test_read(test, arg);
 710                 break;
 711         case PCITEST_COPY:
 712                 ret = pci_endpoint_test_copy(test, arg);
 713                 break;
 714         case PCITEST_SET_IRQTYPE:
 715                 ret = pci_endpoint_test_set_irq(test, arg);
 716                 break;
 717         case PCITEST_GET_IRQTYPE:
 718                 ret = irq_type;
 719                 break;
 720         }
 721
 722 ret:
 723         mutex_unlock(&test->mutex);
 724         return ret;
 725 }
 726
 727 static const struct file_operations pci_endpoint_test_fops = {
 728         .owner = THIS_MODULE,
 729         .unlocked_ioctl = pci_endpoint_test_ioctl,
 730 };
 731
 732 static int pci_endpoint_test_probe(struct pci_dev *pdev,
 733                                    const struct pci_device_id *ent)
 734 {
 735         int err;
 736         int id;
 737         char name[20];
 738         enum pci_barno bar;
 739         void __iomem *base;
 740         struct device *dev = &pdev->dev;
 741         struct pci_endpoint_test *test;
 742         struct pci_endpoint_test_data *data;
 743         enum pci_barno test_reg_bar = BAR_0;
 744         struct miscdevice *misc_device;
 745
 746         if (pci_is_bridge(pdev))
 747                 return -ENODEV;
 748
 749         test = devm_kzalloc(dev, sizeof(*test), GFP_KERNEL);
 750         if (!test)
 751                 return -ENOMEM;
 752
 753         test->test_reg_bar = 0;
 754         test->alignment = 0;
 755         test->pdev = pdev;
 756
 757         if (no_msi)
 758                 irq_type = IRQ_TYPE_LEGACY;
 759
 760         data = (struct pci_endpoint_test_data *)ent->driver_data;
 761         if (data) {
 762                 test_reg_bar = data->test_reg_bar;
 763                 test->test_reg_bar = test_reg_bar;
 764                 test->alignment = data->alignment;
 765                 irq_type = data->irq_type;
 766         }
 767
 768         init_completion(&test->irq_raised);
 769         mutex_init(&test->mutex);
 770
 771         if ((dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(48)) != 0) &&
 772             dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)) != 0) {
 773                 dev_err(dev, "Cannot set DMA mask\n");
 774                 return -EINVAL;
 775         }
 776
 777         err = pci_enable_device(pdev);
 778         if (err) {
 779                 dev_err(dev, "Cannot enable PCI device\n");
 780                 return err;
 781         }
 782
 783         err = pci_request_regions(pdev, DRV_MODULE_NAME);
 784         if (err) {
 785                 dev_err(dev, "Cannot obtain PCI resources\n");
 786                 goto err_disable_pdev;
 787         }
 788
 789         pci_set_master(pdev);
 790
 791         if (!pci_endpoint_test_alloc_irq_vectors(test, irq_type))
 792                 goto err_disable_irq;
 793
 794         if (!pci_endpoint_test_request_irq(test))
 795                 goto err_disable_irq;
 796
 797         for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
 798                 if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM) {
 799                         base = pci_ioremap_bar(pdev, bar);
 800                         if (!base) {
 801                                 dev_err(dev, "Failed to read BAR%d\n", bar);
 802                                 WARN_ON(bar == test_reg_bar);
 803                         }
 804                         test->bar[bar] = base;
 805                 }
 806         }
 807
 808         test->base = test->bar[test_reg_bar];
 809         if (!test->base) {
 810                 err = -ENOMEM;
 811                 dev_err(dev, "Cannot perform PCI test without BAR%d\n",
 812                         test_reg_bar);
 813                 goto err_iounmap;
 814         }
 815
 816         pci_set_drvdata(pdev, test);
 817
 818         id = ida_simple_get(&pci_endpoint_test_ida, 0, 0, GFP_KERNEL);
 819         if (id < 0) {
 820                 err = id;
 821                 dev_err(dev, "Unable to get id\n");
 822                 goto err_iounmap;
 823         }
 824
 825         snprintf(name, sizeof(name), DRV_MODULE_NAME ".%d", id);
 826         misc_device = &test->miscdev;
 827         misc_device->minor = MISC_DYNAMIC_MINOR;
 828         misc_device->name = kstrdup(name, GFP_KERNEL);
 829         if (!misc_device->name) {
 830                 err = -ENOMEM;
 831                 goto err_ida_remove;
 832         }
 833         misc_device->fops = &pci_endpoint_test_fops,
 834
 835         err = misc_register(misc_device);
 836         if (err) {
 837                 dev_err(dev, "Failed to register device\n");
 838                 goto err_kfree_name;
 839         }
 840
 841         return 0;
 842
 843 err_kfree_name:
 844         kfree(misc_device->name);
 845
 846 err_ida_remove:
 847         ida_simple_remove(&pci_endpoint_test_ida, id);
 848
 849 err_iounmap:
 850         for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
 851                 if (test->bar[bar])
 852                         pci_iounmap(pdev, test->bar[bar]);
 853         }
 854         pci_endpoint_test_release_irq(test);
 855
 856 err_disable_irq:
 857         pci_endpoint_test_free_irq_vectors(test);
 858         pci_release_regions(pdev);
 859
 860 err_disable_pdev:
 861         pci_disable_device(pdev);
 862
 863         return err;
 864 }
 865
 866 static void pci_endpoint_test_remove(struct pci_dev *pdev)
 867 {
 868         int id;
 869         enum pci_barno bar;
 870         struct pci_endpoint_test *test = pci_get_drvdata(pdev);
 871         struct miscdevice *misc_device = &test->miscdev;
 872
 873         if (sscanf(misc_device->name, DRV_MODULE_NAME ".%d", &id) != 1)
 874                 return;
 875         if (id < 0)
 876                 return;
 877
 878         misc_deregister(&test->miscdev);
 879         kfree(misc_device->name);
 880         ida_simple_remove(&pci_endpoint_test_ida, id);
 881         for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
 882                 if (test->bar[bar])
 883                         pci_iounmap(pdev, test->bar[bar]);
 884         }
 885
 886         pci_endpoint_test_release_irq(test);
 887         pci_endpoint_test_free_irq_vectors(test);
 888
 889         pci_release_regions(pdev);
 890         pci_disable_device(pdev);
 891 }
 892
 893 static const struct pci_endpoint_test_data default_data = {
 894         .test_reg_bar = BAR_0,
 895         .alignment = SZ_4K,
 896         .irq_type = IRQ_TYPE_MSI,
 897 };
 898
 899 static const struct pci_endpoint_test_data am654_data = {
 900         .test_reg_bar = BAR_2,
 901         .alignment = SZ_64K,
 902         .irq_type = IRQ_TYPE_MSI,
 903 };
 904
 905 static const struct pci_device_id pci_endpoint_test_tbl[] = {
 906         { PCI_DEVICE(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_DRA74x),
 907           .driver_data = (kernel_ulong_t)&default_data,
 908         },
 909         { PCI_DEVICE(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_DRA72x),
 910           .driver_data = (kernel_ulong_t)&default_data,
 911         },
 912         { PCI_DEVICE(PCI_VENDOR_ID_FREESCALE, 0x81c0) },
 913         { PCI_DEVICE_DATA(SYNOPSYS, EDDA, NULL) },
 914         { PCI_DEVICE(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_AM654),
 915           .driver_data = (kernel_ulong_t)&am654_data
 916         },
 917         { }
 918 };
 919 MODULE_DEVICE_TABLE(pci, pci_endpoint_test_tbl);
 920
 921 static struct pci_driver pci_endpoint_test_driver = {
 922         .name           = DRV_MODULE_NAME,
 923         .id_table       = pci_endpoint_test_tbl,
 924         .probe          = pci_endpoint_test_probe,
 925         .remove         = pci_endpoint_test_remove,
 926 };
 927 module_pci_driver(pci_endpoint_test_driver);
 928
 929 MODULE_DESCRIPTION("PCI ENDPOINT TEST HOST DRIVER");
 930 MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
 931 MODULE_LICENSE("GPL v2");