drivers/pci/endpoint/functions/pci-epf-test.c

   1 /**
   2  * Test driver to test endpoint functionality
   3  *
   4  * Copyright (C) 2017 Texas Instruments
   5  * Author: Kishon Vijay Abraham I <kishon@ti.com>
   6  *
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 of
   9  * the License as published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <linux/crc32.h>
  21 #include <linux/delay.h>
  22 #include <linux/io.h>
  23 #include <linux/module.h>
  24 #include <linux/slab.h>
  25 #include <linux/pci_ids.h>
  26 #include <linux/random.h>
  27
  28 #include <linux/pci-epc.h>
  29 #include <linux/pci-epf.h>
  30 #include <linux/pci_regs.h>
  31
  32 #define COMMAND_RAISE_LEGACY_IRQ        BIT(0)
  33 #define COMMAND_RAISE_MSI_IRQ           BIT(1)
  34 #define MSI_NUMBER_SHIFT                2
  35 #define MSI_NUMBER_MASK                 (0x3f << MSI_NUMBER_SHIFT)
  36 #define COMMAND_READ                    BIT(8)
  37 #define COMMAND_WRITE                   BIT(9)
  38 #define COMMAND_COPY                    BIT(10)
  39
  40 #define STATUS_READ_SUCCESS             BIT(0)
  41 #define STATUS_READ_FAIL                BIT(1)
  42 #define STATUS_WRITE_SUCCESS            BIT(2)
  43 #define STATUS_WRITE_FAIL               BIT(3)
  44 #define STATUS_COPY_SUCCESS             BIT(4)
  45 #define STATUS_COPY_FAIL                BIT(5)
  46 #define STATUS_IRQ_RAISED               BIT(6)
  47 #define STATUS_SRC_ADDR_INVALID         BIT(7)
  48 #define STATUS_DST_ADDR_INVALID         BIT(8)
  49
  50 #define TIMER_RESOLUTION                1
  51
  52 static struct workqueue_struct *kpcitest_workqueue;
  53
  54 struct pci_epf_test {
  55         void                    *reg[6];
  56         struct pci_epf          *epf;
  57         enum pci_barno          test_reg_bar;
  58         bool                    linkup_notifier;
  59         struct delayed_work     cmd_handler;
  60 };
  61
  62 struct pci_epf_test_reg {
  63         u32     magic;
  64         u32     command;
  65         u32     status;
  66         u64     src_addr;
  67         u64     dst_addr;
  68         u32     size;
  69         u32     checksum;
  70 } __packed;
  71
  72 static struct pci_epf_header test_header = {
  73         .vendorid       = PCI_ANY_ID,
  74         .deviceid       = PCI_ANY_ID,
  75         .baseclass_code = PCI_CLASS_OTHERS,
  76         .interrupt_pin  = PCI_INTERRUPT_INTA,
  77 };
  78
  79 struct pci_epf_test_data {
  80         enum pci_barno  test_reg_bar;
  81         bool            linkup_notifier;
  82 };
  83
  84 static int bar_size[] = { 512, 512, 1024, 16384, 131072, 1048576 };
  85
  86 static int pci_epf_test_copy(struct pci_epf_test *epf_test)
  87 {
  88         int ret;
  89         void __iomem *src_addr;
  90         void __iomem *dst_addr;
  91         phys_addr_t src_phys_addr;
  92         phys_addr_t dst_phys_addr;
  93         struct pci_epf *epf = epf_test->epf;
  94         struct device *dev = &epf->dev;
  95         struct pci_epc *epc = epf->epc;
  96         enum pci_barno test_reg_bar = epf_test->test_reg_bar;
  97         struct pci_epf_test_reg *reg = epf_test->reg[test_reg_bar];
  98
  99         src_addr = pci_epc_mem_alloc_addr(epc, &src_phys_addr, reg->size);
 100         if (!src_addr) {
 101                 dev_err(dev, "failed to allocate source address\n");
 102                 reg->status = STATUS_SRC_ADDR_INVALID;
 103                 ret = -ENOMEM;
 104                 goto err;
 105         }
 106
 107         ret = pci_epc_map_addr(epc, src_phys_addr, reg->src_addr, reg->size);
 108         if (ret) {
 109                 dev_err(dev, "failed to map source address\n");
 110                 reg->status = STATUS_SRC_ADDR_INVALID;
 111                 goto err_src_addr;
 112         }
 113
 114         dst_addr = pci_epc_mem_alloc_addr(epc, &dst_phys_addr, reg->size);
 115         if (!dst_addr) {
 116                 dev_err(dev, "failed to allocate destination address\n");
 117                 reg->status = STATUS_DST_ADDR_INVALID;
 118                 ret = -ENOMEM;
 119                 goto err_src_map_addr;
 120         }
 121
 122         ret = pci_epc_map_addr(epc, dst_phys_addr, reg->dst_addr, reg->size);
 123         if (ret) {
 124                 dev_err(dev, "failed to map destination address\n");
 125                 reg->status = STATUS_DST_ADDR_INVALID;
 126                 goto err_dst_addr;
 127         }
 128
 129         memcpy(dst_addr, src_addr, reg->size);
 130
 131         pci_epc_unmap_addr(epc, dst_phys_addr);
 132
 133 err_dst_addr:
 134         pci_epc_mem_free_addr(epc, dst_phys_addr, dst_addr, reg->size);
 135
 136 err_src_map_addr:
 137         pci_epc_unmap_addr(epc, src_phys_addr);
 138
 139 err_src_addr:
 140         pci_epc_mem_free_addr(epc, src_phys_addr, src_addr, reg->size);
 141
 142 err:
 143         return ret;
 144 }
 145
 146 static int pci_epf_test_read(struct pci_epf_test *epf_test)
 147 {
 148         int ret;
 149         void __iomem *src_addr;
 150         void *buf;
 151         u32 crc32;
 152         phys_addr_t phys_addr;
 153         struct pci_epf *epf = epf_test->epf;
 154         struct device *dev = &epf->dev;
 155         struct pci_epc *epc = epf->epc;
 156         enum pci_barno test_reg_bar = epf_test->test_reg_bar;
 157         struct pci_epf_test_reg *reg = epf_test->reg[test_reg_bar];
 158
 159         src_addr = pci_epc_mem_alloc_addr(epc, &phys_addr, reg->size);
 160         if (!src_addr) {
 161                 dev_err(dev, "failed to allocate address\n");
 162                 reg->status = STATUS_SRC_ADDR_INVALID;
 163                 ret = -ENOMEM;
 164                 goto err;
 165         }
 166
 167         ret = pci_epc_map_addr(epc, phys_addr, reg->src_addr, reg->size);
 168         if (ret) {
 169                 dev_err(dev, "failed to map address\n");
 170                 reg->status = STATUS_SRC_ADDR_INVALID;
 171                 goto err_addr;
 172         }
 173
 174         buf = kzalloc(reg->size, GFP_KERNEL);
 175         if (!buf) {
 176                 ret = -ENOMEM;
 177                 goto err_map_addr;
 178         }
 179
 180         memcpy(buf, src_addr, reg->size);
 181
 182         crc32 = crc32_le(~0, buf, reg->size);
 183         if (crc32 != reg->checksum)
 184                 ret = -EIO;
 185
 186         kfree(buf);
 187
 188 err_map_addr:
 189         pci_epc_unmap_addr(epc, phys_addr);
 190
 191 err_addr:
 192         pci_epc_mem_free_addr(epc, phys_addr, src_addr, reg->size);
 193
 194 err:
 195         return ret;
 196 }
 197
 198 static int pci_epf_test_write(struct pci_epf_test *epf_test)
 199 {
 200         int ret;
 201         void __iomem *dst_addr;
 202         void *buf;
 203         phys_addr_t phys_addr;
 204         struct pci_epf *epf = epf_test->epf;
 205         struct device *dev = &epf->dev;
 206         struct pci_epc *epc = epf->epc;
 207         enum pci_barno test_reg_bar = epf_test->test_reg_bar;
 208         struct pci_epf_test_reg *reg = epf_test->reg[test_reg_bar];
 209
 210         dst_addr = pci_epc_mem_alloc_addr(epc, &phys_addr, reg->size);
 211         if (!dst_addr) {
 212                 dev_err(dev, "failed to allocate address\n");
 213                 reg->status = STATUS_DST_ADDR_INVALID;
 214                 ret = -ENOMEM;
 215                 goto err;
 216         }
 217
 218         ret = pci_epc_map_addr(epc, phys_addr, reg->dst_addr, reg->size);
 219         if (ret) {
 220                 dev_err(dev, "failed to map address\n");
 221                 reg->status = STATUS_DST_ADDR_INVALID;
 222                 goto err_addr;
 223         }
 224
 225         buf = kzalloc(reg->size, GFP_KERNEL);
 226         if (!buf) {
 227                 ret = -ENOMEM;
 228                 goto err_map_addr;
 229         }
 230
 231         get_random_bytes(buf, reg->size);
 232         reg->checksum = crc32_le(~0, buf, reg->size);
 233
 234         memcpy(dst_addr, buf, reg->size);
 235
 236         /*
 237          * wait 1ms inorder for the write to complete. Without this delay L3
 238          * error in observed in the host system.
 239          */
 240         mdelay(1);
 241
 242         kfree(buf);
 243
 244 err_map_addr:
 245         pci_epc_unmap_addr(epc, phys_addr);
 246
 247 err_addr:
 248         pci_epc_mem_free_addr(epc, phys_addr, dst_addr, reg->size);
 249
 250 err:
 251         return ret;
 252 }
 253
 254 static void pci_epf_test_raise_irq(struct pci_epf_test *epf_test, u8 irq)
 255 {
 256         u8 msi_count;
 257         struct pci_epf *epf = epf_test->epf;
 258         struct pci_epc *epc = epf->epc;
 259         enum pci_barno test_reg_bar = epf_test->test_reg_bar;
 260         struct pci_epf_test_reg *reg = epf_test->reg[test_reg_bar];
 261
 262         reg->status |= STATUS_IRQ_RAISED;
 263         msi_count = pci_epc_get_msi(epc);
 264         if (irq > msi_count || msi_count <= 0)
 265                 pci_epc_raise_irq(epc, PCI_EPC_IRQ_LEGACY, 0);
 266         else
 267                 pci_epc_raise_irq(epc, PCI_EPC_IRQ_MSI, irq);
 268 }
 269
 270 static void pci_epf_test_cmd_handler(struct work_struct *work)
 271 {
 272         int ret;
 273         u8 irq;
 274         u8 msi_count;
 275         u32 command;
 276         struct pci_epf_test *epf_test = container_of(work, struct pci_epf_test,
 277                                                      cmd_handler.work);
 278         struct pci_epf *epf = epf_test->epf;
 279         struct pci_epc *epc = epf->epc;
 280         enum pci_barno test_reg_bar = epf_test->test_reg_bar;
 281         struct pci_epf_test_reg *reg = epf_test->reg[test_reg_bar];
 282
 283         command = reg->command;
 284         if (!command)
 285                 goto reset_handler;
 286
 287         reg->command = 0;
 288         reg->status = 0;
 289
 290         irq = (command & MSI_NUMBER_MASK) >> MSI_NUMBER_SHIFT;
 291
 292         if (command & COMMAND_RAISE_LEGACY_IRQ) {
 293                 reg->status = STATUS_IRQ_RAISED;
 294                 pci_epc_raise_irq(epc, PCI_EPC_IRQ_LEGACY, 0);
 295                 goto reset_handler;
 296         }
 297
 298         if (command & COMMAND_WRITE) {
 299                 ret = pci_epf_test_write(epf_test);
 300                 if (ret)
 301                         reg->status |= STATUS_WRITE_FAIL;
 302                 else
 303                         reg->status |= STATUS_WRITE_SUCCESS;
 304                 pci_epf_test_raise_irq(epf_test, irq);
 305                 goto reset_handler;
 306         }
 307
 308         if (command & COMMAND_READ) {
 309                 ret = pci_epf_test_read(epf_test);
 310                 if (!ret)
 311                         reg->status |= STATUS_READ_SUCCESS;
 312                 else
 313                         reg->status |= STATUS_READ_FAIL;
 314                 pci_epf_test_raise_irq(epf_test, irq);
 315                 goto reset_handler;
 316         }
 317
 318         if (command & COMMAND_COPY) {
 319                 ret = pci_epf_test_copy(epf_test);
 320                 if (!ret)
 321                         reg->status |= STATUS_COPY_SUCCESS;
 322                 else
 323                         reg->status |= STATUS_COPY_FAIL;
 324                 pci_epf_test_raise_irq(epf_test, irq);
 325                 goto reset_handler;
 326         }
 327
 328         if (command & COMMAND_RAISE_MSI_IRQ) {
 329                 msi_count = pci_epc_get_msi(epc);
 330                 if (irq > msi_count || msi_count <= 0)
 331                         goto reset_handler;
 332                 reg->status = STATUS_IRQ_RAISED;
 333                 pci_epc_raise_irq(epc, PCI_EPC_IRQ_MSI, irq);
 334                 goto reset_handler;
 335         }
 336
 337 reset_handler:
 338         queue_delayed_work(kpcitest_workqueue, &epf_test->cmd_handler,
 339                            msecs_to_jiffies(1));
 340 }
 341
 342 static void pci_epf_test_linkup(struct pci_epf *epf)
 343 {
 344         struct pci_epf_test *epf_test = epf_get_drvdata(epf);
 345
 346         queue_delayed_work(kpcitest_workqueue, &epf_test->cmd_handler,
 347                            msecs_to_jiffies(1));
 348 }
 349
 350 static void pci_epf_test_unbind(struct pci_epf *epf)
 351 {
 352         struct pci_epf_test *epf_test = epf_get_drvdata(epf);
 353         struct pci_epc *epc = epf->epc;
 354         int bar;
 355
 356         cancel_delayed_work(&epf_test->cmd_handler);
 357         pci_epc_stop(epc);
 358         for (bar = BAR_0; bar <= BAR_5; bar++) {
 359                 if (epf_test->reg[bar]) {
 360                         pci_epf_free_space(epf, epf_test->reg[bar], bar);
 361                         pci_epc_clear_bar(epc, bar);
 362                 }
 363         }
 364 }
 365
 366 static int pci_epf_test_set_bar(struct pci_epf *epf)
 367 {
 368         int flags;
 369         int bar;
 370         int ret;
 371         struct pci_epf_bar *epf_bar;
 372         struct pci_epc *epc = epf->epc;
 373         struct device *dev = &epf->dev;
 374         struct pci_epf_test *epf_test = epf_get_drvdata(epf);
 375         enum pci_barno test_reg_bar = epf_test->test_reg_bar;
 376
 377         flags = PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_32;
 378         if (sizeof(dma_addr_t) == 0x8)
 379                 flags |= PCI_BASE_ADDRESS_MEM_TYPE_64;
 380
 381         for (bar = BAR_0; bar <= BAR_5; bar++) {
 382                 epf_bar = &epf->bar[bar];
 383                 ret = pci_epc_set_bar(epc, bar, epf_bar->phys_addr,
 384                                       epf_bar->size, flags);
 385                 if (ret) {
 386                         pci_epf_free_space(epf, epf_test->reg[bar], bar);
 387                         dev_err(dev, "failed to set BAR%d\n", bar);
 388                         if (bar == test_reg_bar)
 389                                 return ret;
 390                 }
 391         }
 392
 393         return 0;
 394 }
 395
 396 static int pci_epf_test_alloc_space(struct pci_epf *epf)
 397 {
 398         struct pci_epf_test *epf_test = epf_get_drvdata(epf);
 399         struct device *dev = &epf->dev;
 400         void *base;
 401         int bar;
 402         enum pci_barno test_reg_bar = epf_test->test_reg_bar;
 403
 404         base = pci_epf_alloc_space(epf, sizeof(struct pci_epf_test_reg),
 405                                    test_reg_bar);
 406         if (!base) {
 407                 dev_err(dev, "failed to allocated register space\n");
 408                 return -ENOMEM;
 409         }
 410         epf_test->reg[test_reg_bar] = base;
 411
 412         for (bar = BAR_0; bar <= BAR_5; bar++) {
 413                 if (bar == test_reg_bar)
 414                         continue;
 415                 base = pci_epf_alloc_space(epf, bar_size[bar], bar);
 416                 if (!base)
 417                         dev_err(dev, "failed to allocate space for BAR%d\n",
 418                                 bar);
 419                 epf_test->reg[bar] = base;
 420         }
 421
 422         return 0;
 423 }
 424
 425 static int pci_epf_test_bind(struct pci_epf *epf)
 426 {
 427         int ret;
 428         struct pci_epf_test *epf_test = epf_get_drvdata(epf);
 429         struct pci_epf_header *header = epf->header;
 430         struct pci_epc *epc = epf->epc;
 431         struct device *dev = &epf->dev;
 432
 433         if (WARN_ON_ONCE(!epc))
 434                 return -EINVAL;
 435
 436         ret = pci_epc_write_header(epc, header);
 437         if (ret) {
 438                 dev_err(dev, "configuration header write failed\n");
 439                 return ret;
 440         }
 441
 442         ret = pci_epf_test_alloc_space(epf);
 443         if (ret)
 444                 return ret;
 445
 446         ret = pci_epf_test_set_bar(epf);
 447         if (ret)
 448                 return ret;
 449
 450         ret = pci_epc_set_msi(epc, epf->msi_interrupts);
 451         if (ret)
 452                 return ret;
 453
 454         if (!epf_test->linkup_notifier)
 455                 queue_work(kpcitest_workqueue, &epf_test->cmd_handler.work);
 456
 457         return 0;
 458 }
 459
 460 static const struct pci_epf_device_id pci_epf_test_ids[] = {
 461         {
 462                 .name = "pci_epf_test",
 463         },
 464         {},
 465 };
 466
 467 static int pci_epf_test_probe(struct pci_epf *epf)
 468 {
 469         struct pci_epf_test *epf_test;
 470         struct device *dev = &epf->dev;
 471         const struct pci_epf_device_id *match;
 472         struct pci_epf_test_data *data;
 473         enum pci_barno test_reg_bar = BAR_0;
 474         bool linkup_notifier = true;
 475
 476         match = pci_epf_match_device(pci_epf_test_ids, epf);
 477         data = (struct pci_epf_test_data *)match->driver_data;
 478         if (data) {
 479                 test_reg_bar = data->test_reg_bar;
 480                 linkup_notifier = data->linkup_notifier;
 481         }
 482
 483         epf_test = devm_kzalloc(dev, sizeof(*epf_test), GFP_KERNEL);
 484         if (!epf_test)
 485                 return -ENOMEM;
 486
 487         epf->header = &test_header;
 488         epf_test->epf = epf;
 489         epf_test->test_reg_bar = test_reg_bar;
 490         epf_test->linkup_notifier = linkup_notifier;
 491
 492         INIT_DELAYED_WORK(&epf_test->cmd_handler, pci_epf_test_cmd_handler);
 493
 494         epf_set_drvdata(epf, epf_test);
 495         return 0;
 496 }
 497
 498 static struct pci_epf_ops ops = {
 499         .unbind = pci_epf_test_unbind,
 500         .bind   = pci_epf_test_bind,
 501         .linkup = pci_epf_test_linkup,
 502 };
 503
 504 static struct pci_epf_driver test_driver = {
 505         .driver.name    = "pci_epf_test",
 506         .probe          = pci_epf_test_probe,
 507         .id_table       = pci_epf_test_ids,
 508         .ops            = &ops,
 509         .owner          = THIS_MODULE,
 510 };
 511
 512 static int __init pci_epf_test_init(void)
 513 {
 514         int ret;
 515
 516         kpcitest_workqueue = alloc_workqueue("kpcitest",
 517                                              WQ_MEM_RECLAIM | WQ_HIGHPRI, 0);
 518         ret = pci_epf_register_driver(&test_driver);
 519         if (ret) {
 520                 pr_err("failed to register pci epf test driver --> %d\n", ret);
 521                 return ret;
 522         }
 523
 524         return 0;
 525 }
 526 module_init(pci_epf_test_init);
 527
 528 static void __exit pci_epf_test_exit(void)
 529 {
 530         pci_epf_unregister_driver(&test_driver);
 531 }
 532 module_exit(pci_epf_test_exit);
 533
 534 MODULE_DESCRIPTION("PCI EPF TEST DRIVER");
 535 MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
 536 MODULE_LICENSE("GPL v2");