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