dma.c 2.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Direct Memory Access U-Class tests
  4. *
  5. * Copyright (C) 2018 Texas Instruments Incorporated <www.ti.com>
  6. * Grygorii Strashko <grygorii.strashko@ti.com>
  7. */
  8. #include <common.h>
  9. #include <dm.h>
  10. #include <malloc.h>
  11. #include <dm/test.h>
  12. #include <dma.h>
  13. #include <test/test.h>
  14. #include <test/ut.h>
  15. static int dm_test_dma_m2m(struct unit_test_state *uts)
  16. {
  17. struct udevice *dev;
  18. struct dma dma_m2m;
  19. u8 src_buf[512];
  20. u8 dst_buf[512];
  21. size_t len = 512;
  22. int i;
  23. ut_assertok(uclass_get_device_by_name(UCLASS_DMA, "dma", &dev));
  24. ut_assertok(dma_get_by_name(dev, "m2m", &dma_m2m));
  25. memset(dst_buf, 0, len);
  26. for (i = 0; i < len; i++)
  27. src_buf[i] = i;
  28. ut_assertok(dma_memcpy(dst_buf, src_buf, len));
  29. ut_asserteq_mem(src_buf, dst_buf, len);
  30. return 0;
  31. }
  32. DM_TEST(dm_test_dma_m2m, UT_TESTF_SCAN_FDT);
  33. static int dm_test_dma(struct unit_test_state *uts)
  34. {
  35. struct udevice *dev;
  36. struct dma dma_tx, dma_rx;
  37. u8 src_buf[512];
  38. u8 dst_buf[512];
  39. void *dst_ptr;
  40. size_t len = 512;
  41. u32 meta1, meta2;
  42. int i;
  43. ut_assertok(uclass_get_device_by_name(UCLASS_DMA, "dma", &dev));
  44. ut_assertok(dma_get_by_name(dev, "tx0", &dma_tx));
  45. ut_assertok(dma_get_by_name(dev, "rx0", &dma_rx));
  46. ut_assertok(dma_enable(&dma_tx));
  47. ut_assertok(dma_enable(&dma_rx));
  48. memset(dst_buf, 0, len);
  49. for (i = 0; i < len; i++)
  50. src_buf[i] = i;
  51. meta1 = 0xADADDEAD;
  52. meta2 = 0;
  53. dst_ptr = &dst_buf;
  54. ut_assertok(dma_send(&dma_tx, src_buf, len, &meta1));
  55. ut_asserteq(len, dma_receive(&dma_rx, &dst_ptr, &meta2));
  56. ut_asserteq(0xADADDEAD, meta2);
  57. ut_assertok(dma_disable(&dma_tx));
  58. ut_assertok(dma_disable(&dma_rx));
  59. ut_assertok(dma_free(&dma_tx));
  60. ut_assertok(dma_free(&dma_rx));
  61. ut_asserteq_mem(src_buf, dst_buf, len);
  62. return 0;
  63. }
  64. DM_TEST(dm_test_dma, UT_TESTF_SCAN_FDT);
  65. static int dm_test_dma_rx(struct unit_test_state *uts)
  66. {
  67. struct udevice *dev;
  68. struct dma dma_tx, dma_rx;
  69. u8 src_buf[512];
  70. u8 dst_buf[512];
  71. void *dst_ptr;
  72. size_t len = 512;
  73. u32 meta1, meta2;
  74. int i;
  75. ut_assertok(uclass_get_device_by_name(UCLASS_DMA, "dma", &dev));
  76. ut_assertok(dma_get_by_name(dev, "tx0", &dma_tx));
  77. ut_assertok(dma_get_by_name(dev, "rx0", &dma_rx));
  78. ut_assertok(dma_enable(&dma_tx));
  79. ut_assertok(dma_enable(&dma_rx));
  80. memset(dst_buf, 0, len);
  81. for (i = 0; i < len; i++)
  82. src_buf[i] = i;
  83. meta1 = 0xADADDEAD;
  84. meta2 = 0;
  85. dst_ptr = NULL;
  86. ut_assertok(dma_prepare_rcv_buf(&dma_tx, dst_buf, len));
  87. ut_assertok(dma_send(&dma_tx, src_buf, len, &meta1));
  88. ut_asserteq(len, dma_receive(&dma_rx, &dst_ptr, &meta2));
  89. ut_asserteq(0xADADDEAD, meta2);
  90. ut_asserteq_ptr(dst_buf, dst_ptr);
  91. ut_assertok(dma_disable(&dma_tx));
  92. ut_assertok(dma_disable(&dma_rx));
  93. ut_assertok(dma_free(&dma_tx));
  94. ut_assertok(dma_free(&dma_rx));
  95. ut_asserteq_mem(src_buf, dst_buf, len);
  96. return 0;
  97. }
  98. DM_TEST(dm_test_dma_rx, UT_TESTF_SCAN_FDT);