8682867ac14a2204f53568df7db5b2ab8b9738c9
[platform/kernel/linux-starfive.git] / 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");