forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-05-10 37f49e37ab4cb5d0bc4c60eb5c6d4dd57db767bb 
 kernel/drivers/misc/pci_endpoint_test.c
....@@ -1,20 +1,9 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
12 /**
23  * Host side test driver to test endpoint functionality
34  *
45  * Copyright (C) 2017 Texas Instruments
56  * 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/>.
187  */
198 
209 #include <linux/crc32.h>
....@@ -28,6 +17,7 @@
2817 #include <linux/mutex.h>
2918 #include <linux/random.h>
3019 #include <linux/slab.h>
20
+#include <linux/uaccess.h>
3121 #include <linux/pci.h>
3222 #include <linux/pci_ids.h>
3323 
....@@ -75,10 +65,20 @@
7565 #define PCI_ENDPOINT_TEST_IRQ_TYPE		0x24
7666 #define PCI_ENDPOINT_TEST_IRQ_NUMBER		0x28
7767 
68
+#define PCI_ENDPOINT_TEST_FLAGS			0x2c
69
+#define FLAG_USE_DMA				BIT(0)
70
+
71
+#define PCI_DEVICE_ID_TI_J721E			0xb00d
7872 #define PCI_DEVICE_ID_TI_AM654			0xb00c
73
+#define PCI_DEVICE_ID_LS1088A			0x80c0
7974 
8075 #define is_am654_pci_dev(pdev)		\
8176 		((pdev)->device == PCI_DEVICE_ID_TI_AM654)
77
+
78
+#define PCI_DEVICE_ID_RENESAS_R8A774A1		0x0028
79
+#define PCI_DEVICE_ID_RENESAS_R8A774B1		0x002b
80
+#define PCI_DEVICE_ID_RENESAS_R8A774C0		0x002d
81
+#define PCI_DEVICE_ID_RENESAS_R8A774E1		0x0025
8282 
8383 static DEFINE_IDA(pci_endpoint_test_ida);
8484 
....@@ -105,7 +105,7 @@
105105 struct pci_endpoint_test {
106106 	struct pci_dev	*pdev;
107107 	void __iomem	*base;
108
-	void __iomem	*bar[6];
108
+	void __iomem	*bar[PCI_STD_NUM_BARS];
109109 	struct completion irq_raised;
110110 	int		last_irq;
111111 	int		num_irqs;
....@@ -115,6 +115,7 @@
115115 	struct miscdevice miscdev;
116116 	enum pci_barno test_reg_bar;
117117 	size_t alignment;
118
+	const char *name;
118119 };
119120 
120121 struct pci_endpoint_test_data {
....@@ -233,7 +234,7 @@
233234 	for (i = 0; i < test->num_irqs; i++) {
234235 		err = devm_request_irq(dev, pci_irq_vector(pdev, i),
235236 				       pci_endpoint_test_irqhandler,
236
-				       IRQF_SHARED, DRV_MODULE_NAME, test);
237
+				       IRQF_SHARED, test->name, test);
237238 		if (err)
238239 			goto fail;
239240 	}
....@@ -330,11 +331,32 @@
330331 	return false;
331332 }
332333 
333
-static bool pci_endpoint_test_copy(struct pci_endpoint_test *test, size_t size)
334
+static int pci_endpoint_test_validate_xfer_params(struct device *dev,
335
+		struct pci_endpoint_test_xfer_param *param, size_t alignment)
334336 {
337
+	if (!param->size) {
338
+		dev_dbg(dev, "Data size is zero\n");
339
+		return -EINVAL;
340
+	}
341
+
342
+	if (param->size > SIZE_MAX - alignment) {
343
+		dev_dbg(dev, "Maximum transfer data size exceeded\n");
344
+		return -EINVAL;
345
+	}
346
+
347
+	return 0;
348
+}
349
+
350
+static bool pci_endpoint_test_copy(struct pci_endpoint_test *test,
351
+				   unsigned long arg)
352
+{
353
+	struct pci_endpoint_test_xfer_param param;
335354 	bool ret = false;
336355 	void *src_addr;
337356 	void *dst_addr;
357
+	u32 flags = 0;
358
+	bool use_dma;
359
+	size_t size;
338360 	dma_addr_t src_phys_addr;
339361 	dma_addr_t dst_phys_addr;
340362 	struct pci_dev *pdev = test->pdev;
....@@ -348,21 +370,43 @@
348370 	int irq_type = test->irq_type;
349371 	u32 src_crc32;
350372 	u32 dst_crc32;
373
+	int err;
351374 
352
-	if (size > SIZE_MAX - alignment)
353
-		goto err;
375
+	err = copy_from_user(&param, (void __user *)arg, sizeof(param));
376
+	if (err) {
377
+		dev_err(dev, "Failed to get transfer param\n");
378
+		return false;
379
+	}
380
+
381
+	err = pci_endpoint_test_validate_xfer_params(dev, &param, alignment);
382
+	if (err)
383
+		return false;
384
+
385
+	size = param.size;
386
+
387
+	use_dma = !!(param.flags & PCITEST_FLAGS_USE_DMA);
388
+	if (use_dma)
389
+		flags |= FLAG_USE_DMA;
354390 
355391 	if (irq_type < IRQ_TYPE_LEGACY || irq_type > IRQ_TYPE_MSIX) {
356392 		dev_err(dev, "Invalid IRQ type option\n");
357393 		goto err;
358394 	}
359395 
360
-	orig_src_addr = dma_alloc_coherent(dev, size + alignment,
361
-					   &orig_src_phys_addr, GFP_KERNEL);
396
+	orig_src_addr = kzalloc(size + alignment, GFP_KERNEL);
362397 	if (!orig_src_addr) {
363398 		dev_err(dev, "Failed to allocate source buffer\n");
364399 		ret = false;
365400 		goto err;
401
+	}
402
+
403
+	get_random_bytes(orig_src_addr, size + alignment);
404
+	orig_src_phys_addr = dma_map_single(dev, orig_src_addr,
405
+					    size + alignment, DMA_TO_DEVICE);
406
+	if (dma_mapping_error(dev, orig_src_phys_addr)) {
407
+		dev_err(dev, "failed to map source buffer address\n");
408
+		ret = false;
409
+		goto err_src_phys_addr;
366410 	}
367411 
368412 	if (alignment && !IS_ALIGNED(orig_src_phys_addr, alignment)) {
....@@ -380,15 +424,21 @@
380424 	pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_UPPER_SRC_ADDR,
381425 				 upper_32_bits(src_phys_addr));
382426 
383
-	get_random_bytes(src_addr, size);
384427 	src_crc32 = crc32_le(~0, src_addr, size);
385428 
386
-	orig_dst_addr = dma_alloc_coherent(dev, size + alignment,
387
-					   &orig_dst_phys_addr, GFP_KERNEL);
429
+	orig_dst_addr = kzalloc(size + alignment, GFP_KERNEL);
388430 	if (!orig_dst_addr) {
389431 		dev_err(dev, "Failed to allocate destination address\n");
390432 		ret = false;
391
-		goto err_orig_src_addr;
433
+		goto err_dst_addr;
434
+	}
435
+
436
+	orig_dst_phys_addr = dma_map_single(dev, orig_dst_addr,
437
+					    size + alignment, DMA_FROM_DEVICE);
438
+	if (dma_mapping_error(dev, orig_dst_phys_addr)) {
439
+		dev_err(dev, "failed to map destination buffer address\n");
440
+		ret = false;
441
+		goto err_dst_phys_addr;
392442 	}
393443 
394444 	if (alignment && !IS_ALIGNED(orig_dst_phys_addr, alignment)) {
....@@ -408,6 +458,7 @@
408458 	pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_SIZE,
409459 				 size);
410460 
461
+	pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_FLAGS, flags);
411462 	pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_TYPE, irq_type);
412463 	pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_NUMBER, 1);
413464 	pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_COMMAND,
....@@ -415,24 +466,34 @@
415466 
416467 	wait_for_completion(&test->irq_raised);
417468 
469
+	dma_unmap_single(dev, orig_dst_phys_addr, size + alignment,
470
+			 DMA_FROM_DEVICE);
471
+
418472 	dst_crc32 = crc32_le(~0, dst_addr, size);
419473 	if (dst_crc32 == src_crc32)
420474 		ret = true;
421475 
422
-	dma_free_coherent(dev, size + alignment, orig_dst_addr,
423
-			  orig_dst_phys_addr);
476
+err_dst_phys_addr:
477
+	kfree(orig_dst_addr);
424478 
425
-err_orig_src_addr:
426
-	dma_free_coherent(dev, size + alignment, orig_src_addr,
427
-			  orig_src_phys_addr);
479
+err_dst_addr:
480
+	dma_unmap_single(dev, orig_src_phys_addr, size + alignment,
481
+			 DMA_TO_DEVICE);
482
+
483
+err_src_phys_addr:
484
+	kfree(orig_src_addr);
428485 
429486 err:
430487 	return ret;
431488 }
432489 
433
-static bool pci_endpoint_test_write(struct pci_endpoint_test *test, size_t size)
490
+static bool pci_endpoint_test_write(struct pci_endpoint_test *test,
491
+				    unsigned long arg)
434492 {
493
+	struct pci_endpoint_test_xfer_param param;
435494 	bool ret = false;
495
+	u32 flags = 0;
496
+	bool use_dma;
436497 	u32 reg;
437498 	void *addr;
438499 	dma_addr_t phys_addr;
....@@ -443,22 +504,46 @@
443504 	size_t offset;
444505 	size_t alignment = test->alignment;
445506 	int irq_type = test->irq_type;
507
+	size_t size;
446508 	u32 crc32;
509
+	int err;
447510 
448
-	if (size > SIZE_MAX - alignment)
449
-		goto err;
511
+	err = copy_from_user(&param, (void __user *)arg, sizeof(param));
512
+	if (err != 0) {
513
+		dev_err(dev, "Failed to get transfer param\n");
514
+		return false;
515
+	}
516
+
517
+	err = pci_endpoint_test_validate_xfer_params(dev, &param, alignment);
518
+	if (err)
519
+		return false;
520
+
521
+	size = param.size;
522
+
523
+	use_dma = !!(param.flags & PCITEST_FLAGS_USE_DMA);
524
+	if (use_dma)
525
+		flags |= FLAG_USE_DMA;
450526 
451527 	if (irq_type < IRQ_TYPE_LEGACY || irq_type > IRQ_TYPE_MSIX) {
452528 		dev_err(dev, "Invalid IRQ type option\n");
453529 		goto err;
454530 	}
455531 
456
-	orig_addr = dma_alloc_coherent(dev, size + alignment, &orig_phys_addr,
457
-				       GFP_KERNEL);
532
+	orig_addr = kzalloc(size + alignment, GFP_KERNEL);
458533 	if (!orig_addr) {
459534 		dev_err(dev, "Failed to allocate address\n");
460535 		ret = false;
461536 		goto err;
537
+	}
538
+
539
+	get_random_bytes(orig_addr, size + alignment);
540
+
541
+	orig_phys_addr = dma_map_single(dev, orig_addr, size + alignment,
542
+					DMA_TO_DEVICE);
543
+	if (dma_mapping_error(dev, orig_phys_addr)) {
544
+		dev_err(dev, "failed to map source buffer address\n");
545
+		ret = false;
546
+		goto err_phys_addr;
462547 	}
463548 
464549 	if (alignment && !IS_ALIGNED(orig_phys_addr, alignment)) {
....@@ -469,8 +554,6 @@
469554 		phys_addr = orig_phys_addr;
470555 		addr = orig_addr;
471556 	}
472
-
473
-	get_random_bytes(addr, size);
474557 
475558 	crc32 = crc32_le(~0, addr, size);
476559 	pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_CHECKSUM,
....@@ -483,6 +566,7 @@
483566 
484567 	pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_SIZE, size);
485568 
569
+	pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_FLAGS, flags);
486570 	pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_TYPE, irq_type);
487571 	pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_NUMBER, 1);
488572 	pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_COMMAND,
....@@ -494,15 +578,24 @@
494578 	if (reg & STATUS_READ_SUCCESS)
495579 		ret = true;
496580 
497
-	dma_free_coherent(dev, size + alignment, orig_addr, orig_phys_addr);
581
+	dma_unmap_single(dev, orig_phys_addr, size + alignment,
582
+			 DMA_TO_DEVICE);
583
+
584
+err_phys_addr:
585
+	kfree(orig_addr);
498586 
499587 err:
500588 	return ret;
501589 }
502590 
503
-static bool pci_endpoint_test_read(struct pci_endpoint_test *test, size_t size)
591
+static bool pci_endpoint_test_read(struct pci_endpoint_test *test,
592
+				   unsigned long arg)
504593 {
594
+	struct pci_endpoint_test_xfer_param param;
505595 	bool ret = false;
596
+	u32 flags = 0;
597
+	bool use_dma;
598
+	size_t size;
506599 	void *addr;
507600 	dma_addr_t phys_addr;
508601 	struct pci_dev *pdev = test->pdev;
....@@ -513,21 +606,42 @@
513606 	size_t alignment = test->alignment;
514607 	int irq_type = test->irq_type;
515608 	u32 crc32;
609
+	int err;
516610 
517
-	if (size > SIZE_MAX - alignment)
518
-		goto err;
611
+	err = copy_from_user(&param, (void __user *)arg, sizeof(param));
612
+	if (err) {
613
+		dev_err(dev, "Failed to get transfer param\n");
614
+		return false;
615
+	}
616
+
617
+	err = pci_endpoint_test_validate_xfer_params(dev, &param, alignment);
618
+	if (err)
619
+		return false;
620
+
621
+	size = param.size;
622
+
623
+	use_dma = !!(param.flags & PCITEST_FLAGS_USE_DMA);
624
+	if (use_dma)
625
+		flags |= FLAG_USE_DMA;
519626 
520627 	if (irq_type < IRQ_TYPE_LEGACY || irq_type > IRQ_TYPE_MSIX) {
521628 		dev_err(dev, "Invalid IRQ type option\n");
522629 		goto err;
523630 	}
524631 
525
-	orig_addr = dma_alloc_coherent(dev, size + alignment, &orig_phys_addr,
526
-				       GFP_KERNEL);
632
+	orig_addr = kzalloc(size + alignment, GFP_KERNEL);
527633 	if (!orig_addr) {
528634 		dev_err(dev, "Failed to allocate destination address\n");
529635 		ret = false;
530636 		goto err;
637
+	}
638
+
639
+	orig_phys_addr = dma_map_single(dev, orig_addr, size + alignment,
640
+					DMA_FROM_DEVICE);
641
+	if (dma_mapping_error(dev, orig_phys_addr)) {
642
+		dev_err(dev, "failed to map source buffer address\n");
643
+		ret = false;
644
+		goto err_phys_addr;
531645 	}
532646 
533647 	if (alignment && !IS_ALIGNED(orig_phys_addr, alignment)) {
....@@ -546,6 +660,7 @@
546660 
547661 	pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_SIZE, size);
548662 
663
+	pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_FLAGS, flags);
549664 	pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_TYPE, irq_type);
550665 	pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_IRQ_NUMBER, 1);
551666 	pci_endpoint_test_writel(test, PCI_ENDPOINT_TEST_COMMAND,
....@@ -553,13 +668,24 @@
553668 
554669 	wait_for_completion(&test->irq_raised);
555670 
671
+	dma_unmap_single(dev, orig_phys_addr, size + alignment,
672
+			 DMA_FROM_DEVICE);
673
+
556674 	crc32 = crc32_le(~0, addr, size);
557675 	if (crc32 == pci_endpoint_test_readl(test, PCI_ENDPOINT_TEST_CHECKSUM))
558676 		ret = true;
559677 
560
-	dma_free_coherent(dev, size + alignment, orig_addr, orig_phys_addr);
678
+err_phys_addr:
679
+	kfree(orig_addr);
561680 err:
562681 	return ret;
682
+}
683
+
684
+static bool pci_endpoint_test_clear_irq(struct pci_endpoint_test *test)
685
+{
686
+	pci_endpoint_test_release_irq(test);
687
+	pci_endpoint_test_free_irq_vectors(test);
688
+	return true;
563689 }
564690 
565691 static bool pci_endpoint_test_set_irq(struct pci_endpoint_test *test,
....@@ -601,6 +727,10 @@
601727 	struct pci_dev *pdev = test->pdev;
602728 
603729 	mutex_lock(&test->mutex);
730
+
731
+	reinit_completion(&test->irq_raised);
732
+	test->last_irq = -ENODATA;
733
+
604734 	switch (cmd) {
605735 	case PCITEST_BAR:
606736 		bar = arg;
....@@ -631,6 +761,9 @@
631761 		break;
632762 	case PCITEST_GET_IRQTYPE:
633763 		ret = irq_type;
764
+		break;
765
+	case PCITEST_CLEAR_IRQ:
766
+		ret = pci_endpoint_test_clear_irq(test);
634767 		break;
635768 	}
636769 
....@@ -684,6 +817,12 @@
684817 	init_completion(&test->irq_raised);
685818 	mutex_init(&test->mutex);
686819 
820
+	if ((dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(48)) != 0) &&
821
+	    dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)) != 0) {
822
+		dev_err(dev, "Cannot set DMA mask\n");
823
+		return -EINVAL;
824
+	}
825
+
687826 	err = pci_enable_device(pdev);
688827 	if (err) {
689828 		dev_err(dev, "Cannot enable PCI device\n");
....@@ -698,13 +837,12 @@
698837 
699838 	pci_set_master(pdev);
700839 
701
-	if (!pci_endpoint_test_alloc_irq_vectors(test, irq_type))
840
+	if (!pci_endpoint_test_alloc_irq_vectors(test, irq_type)) {
841
+		err = -EINVAL;
702842 		goto err_disable_irq;
843
+	}
703844 
704
-	if (!pci_endpoint_test_request_irq(test))
705
-		goto err_disable_irq;
706
-
707
-	for (bar = BAR_0; bar <= BAR_5; bar++) {
845
+	for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
708846 		if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM) {
709847 			base = pci_ioremap_bar(pdev, bar);
710848 			if (!base) {
....@@ -733,12 +871,23 @@
733871 	}
734872 
735873 	snprintf(name, sizeof(name), DRV_MODULE_NAME ".%d", id);
874
+	test->name = kstrdup(name, GFP_KERNEL);
875
+	if (!test->name) {
876
+		err = -ENOMEM;
877
+		goto err_ida_remove;
878
+	}
879
+
880
+	if (!pci_endpoint_test_request_irq(test)) {
881
+		err = -EINVAL;
882
+		goto err_kfree_test_name;
883
+	}
884
+
736885 	misc_device = &test->miscdev;
737886 	misc_device->minor = MISC_DYNAMIC_MINOR;
738887 	misc_device->name = kstrdup(name, GFP_KERNEL);
739888 	if (!misc_device->name) {
740889 		err = -ENOMEM;
741
-		goto err_ida_remove;
890
+		goto err_release_irq;
742891 	}
743892 	misc_device->fops = &pci_endpoint_test_fops,
744893 
....@@ -753,15 +902,20 @@
753902 err_kfree_name:
754903 	kfree(misc_device->name);
755904 
905
+err_release_irq:
906
+	pci_endpoint_test_release_irq(test);
907
+
908
+err_kfree_test_name:
909
+	kfree(test->name);
910
+
756911 err_ida_remove:
757912 	ida_simple_remove(&pci_endpoint_test_ida, id);
758913 
759914 err_iounmap:
760
-	for (bar = BAR_0; bar <= BAR_5; bar++) {
915
+	for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
761916 		if (test->bar[bar])
762917 			pci_iounmap(pdev, test->bar[bar]);
763918 	}
764
-	pci_endpoint_test_release_irq(test);
765919 
766920 err_disable_irq:
767921 	pci_endpoint_test_free_irq_vectors(test);
....@@ -785,20 +939,27 @@
785939 	if (id < 0)
786940 		return;
787941 
942
+	pci_endpoint_test_release_irq(test);
943
+	pci_endpoint_test_free_irq_vectors(test);
944
+
788945 	misc_deregister(&test->miscdev);
789946 	kfree(misc_device->name);
947
+	kfree(test->name);
790948 	ida_simple_remove(&pci_endpoint_test_ida, id);
791
-	for (bar = BAR_0; bar <= BAR_5; bar++) {
949
+	for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
792950 		if (test->bar[bar])
793951 			pci_iounmap(pdev, test->bar[bar]);
794952 	}
795953 
796
-	pci_endpoint_test_release_irq(test);
797
-	pci_endpoint_test_free_irq_vectors(test);
798
-
799954 	pci_release_regions(pdev);
800955 	pci_disable_device(pdev);
801956 }
957
+
958
+static const struct pci_endpoint_test_data default_data = {
959
+	.test_reg_bar = BAR_0,
960
+	.alignment = SZ_4K,
961
+	.irq_type = IRQ_TYPE_MSI,
962
+};
802963 
803964 static const struct pci_endpoint_test_data am654_data = {
804965 	.test_reg_bar = BAR_2,
....@@ -806,14 +967,35 @@
806967 	.irq_type = IRQ_TYPE_MSI,
807968 };
808969 
970
+static const struct pci_endpoint_test_data j721e_data = {
971
+	.alignment = 256,
972
+	.irq_type = IRQ_TYPE_MSI,
973
+};
974
+
809975 static const struct pci_device_id pci_endpoint_test_tbl[] = {
810
-	{ PCI_DEVICE(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_DRA74x) },
811
-	{ PCI_DEVICE(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_DRA72x) },
812
-	{ PCI_DEVICE(PCI_VENDOR_ID_FREESCALE, 0x81c0) },
976
+	{ PCI_DEVICE(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_DRA74x),
977
+	  .driver_data = (kernel_ulong_t)&default_data,
978
+	},
979
+	{ PCI_DEVICE(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_DRA72x),
980
+	  .driver_data = (kernel_ulong_t)&default_data,
981
+	},
982
+	{ PCI_DEVICE(PCI_VENDOR_ID_FREESCALE, 0x81c0),
983
+	  .driver_data = (kernel_ulong_t)&default_data,
984
+	},
985
+	{ PCI_DEVICE(PCI_VENDOR_ID_FREESCALE, PCI_DEVICE_ID_LS1088A),
986
+	  .driver_data = (kernel_ulong_t)&default_data,
987
+	},
813988 	{ PCI_DEVICE_DATA(SYNOPSYS, EDDA, NULL) },
814989 	{ PCI_DEVICE(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_AM654),
815990 	  .driver_data = (kernel_ulong_t)&am654_data
816991 	},
992
+	{ PCI_DEVICE(PCI_VENDOR_ID_RENESAS, PCI_DEVICE_ID_RENESAS_R8A774A1),},
993
+	{ PCI_DEVICE(PCI_VENDOR_ID_RENESAS, PCI_DEVICE_ID_RENESAS_R8A774B1),},
994
+	{ PCI_DEVICE(PCI_VENDOR_ID_RENESAS, PCI_DEVICE_ID_RENESAS_R8A774C0),},
995
+	{ PCI_DEVICE(PCI_VENDOR_ID_RENESAS, PCI_DEVICE_ID_RENESAS_R8A774E1),},
996
+	{ PCI_DEVICE(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_J721E),
997
+	  .driver_data = (kernel_ulong_t)&j721e_data,
998
+	},
817999 	{ }
8181000 };
8191001 MODULE_DEVICE_TABLE(pci, pci_endpoint_test_tbl);