Guest User

Untitled

a guest
Jun 16th, 2026
137
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 9.36 KB | None | 0 0
  1. /*
  2. * QTests for NPCM7xx SD-3.0 / MMC-4.51 Host Controller
  3. *
  4. * Copyright (c) 2022 Google LLC
  5. *
  6. * This program is free software; you can redistribute it and/or modify it
  7. * under the terms of the GNU General Public License as published by the
  8. * Free Software Foundation; either version 2 of the License, or
  9. * (at your option) any later version.
  10. *
  11. * This program is distributed in the hope that it will be useful, but WITHOUT
  12. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13. * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  14. * for more details.
  15. */
  16.  
  17. #include "qemu/osdep.h"
  18. #include "hw/sd/npcm7xx_sdhci.h"
  19.  
  20. #include "libqtest.h"
  21. #include "libqtest-single.h"
  22. #include "libqos/sdhci-cmd.h"
  23.  
  24. #define NPCM7XX_REG_SIZE 0x100
  25. #define NPCM7XX_MMC_BA 0xF0842000
  26. #define NPCM7XX_BLK_SIZE 512
  27. #define NPCM7XX_TEST_IMAGE_SIZE (1 << 20)
  28. #define NPCM7XX_SDMA_BOUNDARY_ARG 7
  29. #define NPCM7XX_SDMA_BOUNDARY_SIZE (512 * 1024)
  30. #define NPCM7XX_SDMA_BLOCK_COUNT ((NPCM7XX_SDMA_BOUNDARY_SIZE / \
  31. NPCM7XX_BLK_SIZE) + 1)
  32. #define NPCM7XX_SDMA_TRANSFER_SIZE (NPCM7XX_SDMA_BLOCK_COUNT * \
  33. NPCM7XX_BLK_SIZE)
  34. #define NPCM7XX_DMA_ADDR 0x00100000
  35.  
  36. #define SDHC_SYSAD 0x00
  37. #define SDHC_NORINTSTS 0x30
  38.  
  39. #define SDHC_TRNS_DMA 0x0001
  40.  
  41. #define SDHC_MAKE_BLKSZ(boundary, size) (((boundary) << 12) | (size))
  42.  
  43. char *sd_path;
  44.  
  45. static QTestState *setup_sd_card(void)
  46. {
  47. uint16_t rca;
  48.  
  49. QTestState *qts = qtest_initf(
  50. "-machine kudo-bmc "
  51. "-device sd-card,drive=drive0 "
  52. "-drive id=drive0,if=none,file=%s,format=raw,auto-read-only=off",
  53. sd_path);
  54.  
  55. qtest_writew(qts, NPCM7XX_MMC_BA + SDHC_SWRST, SDHC_RESET_ALL);
  56. qtest_writew(qts, NPCM7XX_MMC_BA + SDHC_CLKCON,
  57. SDHC_CLOCK_SDCLK_EN | SDHC_CLOCK_INT_STABLE |
  58. SDHC_CLOCK_INT_EN);
  59. sdhci_cmd_regs(qts, NPCM7XX_MMC_BA, 0, 0, 0, 0, SDHC_APP_CMD);
  60. sdhci_cmd_regs(qts, NPCM7XX_MMC_BA, 0, 0, 0x41200000, 0, (41 << 8));
  61. sdhci_cmd_regs(qts, NPCM7XX_MMC_BA, 0, 0, 0, 0, SDHC_ALL_SEND_CID);
  62. sdhci_cmd_regs(qts, NPCM7XX_MMC_BA, 0, 0, 0, 0, SDHC_SEND_RELATIVE_ADDR
  63. | SDHC_CMD_RESPONSE);
  64. rca = qtest_readl(qts, NPCM7XX_MMC_BA + SDHC_RSPREG0) >> 16;
  65. sdhci_cmd_regs(qts, NPCM7XX_MMC_BA, 0, 0, rca << 16, 0,
  66. SDHC_SELECT_DESELECT_CARD);
  67.  
  68. return qts;
  69. }
  70.  
  71. static void write_sdread(QTestState *qts, const char *msg)
  72. {
  73. int fd, ret;
  74. size_t len = strlen(msg);
  75. char *rmsg = g_malloc(len);
  76.  
  77. /* write message to sd */
  78. fd = open(sd_path, O_WRONLY);
  79. g_assert(fd >= 0);
  80. ret = write(fd, msg, len);
  81. close(fd);
  82. g_assert(ret == len);
  83.  
  84. /* read message using sdhci */
  85. ret = sdhci_read_cmd(qts, NPCM7XX_MMC_BA, rmsg, len);
  86. g_assert(ret == len);
  87. g_assert(!memcmp(rmsg, msg, len));
  88.  
  89. g_free(rmsg);
  90. }
  91.  
  92. static void write_pattern_to_image(size_t offset, size_t len)
  93. {
  94. int fd, ret;
  95. uint8_t *buf = g_malloc(len);
  96.  
  97. for (size_t i = 0; i < len; i++) {
  98. buf[i] = (i * 13 + 7) & 0xff;
  99. }
  100.  
  101. fd = open(sd_path, O_WRONLY);
  102. g_assert(fd >= 0);
  103. ret = pwrite(fd, buf, len, offset);
  104. close(fd);
  105. g_assert_cmpint(ret, ==, len);
  106.  
  107. g_free(buf);
  108. }
  109.  
  110. static void wait_for_block_count(QTestState *qts, uint16_t expected)
  111. {
  112. int i;
  113.  
  114. for (i = 0; i < 1000; i++) {
  115. if (qtest_readw(qts, NPCM7XX_MMC_BA + SDHC_BLKCNT) == expected) {
  116. return;
  117. }
  118. usleep(100);
  119. }
  120.  
  121. g_assert_cmpuint(qtest_readw(qts, NPCM7XX_MMC_BA + SDHC_BLKCNT),
  122. ==, expected);
  123. }
  124.  
  125. /*
  126. * SDMA stops at each boundary and relies on software writing SYSAD to
  127. * continue the transfer. The bug this test covers leaves DOING_READ/WRITE
  128. * asserted, so the continuation SYSAD write is ignored and the read stalls.
  129. */
  130. static void test_read_sd_sdma_boundary_continue(void)
  131. {
  132. QTestState *qts = setup_sd_card();
  133. uint8_t *actual = g_malloc0(NPCM7XX_SDMA_TRANSFER_SIZE);
  134. uint8_t *expected = g_malloc(NPCM7XX_SDMA_TRANSFER_SIZE);
  135.  
  136. write_pattern_to_image(0, NPCM7XX_SDMA_TRANSFER_SIZE);
  137.  
  138. for (size_t i = 0; i < NPCM7XX_SDMA_TRANSFER_SIZE; i++) {
  139. expected[i] = (i * 13 + 7) & 0xff;
  140. }
  141.  
  142. qtest_writel(qts, NPCM7XX_DMA_ADDR, 0xdeadbeef);
  143. qtest_writel(qts, NPCM7XX_DMA_ADDR + NPCM7XX_SDMA_BOUNDARY_SIZE,
  144. 0xcafef00d);
  145.  
  146. qtest_writel(qts, NPCM7XX_MMC_BA + SDHC_SYSAD, NPCM7XX_DMA_ADDR);
  147. sdhci_cmd_regs(qts, NPCM7XX_MMC_BA,
  148. SDHC_MAKE_BLKSZ(NPCM7XX_SDMA_BOUNDARY_ARG,
  149. NPCM7XX_BLK_SIZE),
  150. NPCM7XX_SDMA_BLOCK_COUNT, 0,
  151. SDHC_TRNS_DMA | SDHC_TRNS_MULTI | SDHC_TRNS_READ |
  152. SDHC_TRNS_BLK_CNT_EN,
  153. SDHC_READ_MULTIPLE_BLOCK | SDHC_CMD_DATA_PRESENT);
  154.  
  155. wait_for_block_count(qts, 1);
  156.  
  157. qtest_writew(qts, NPCM7XX_MMC_BA + SDHC_NORINTSTS, 0xffff);
  158. qtest_writel(qts, NPCM7XX_MMC_BA + SDHC_SYSAD,
  159. NPCM7XX_DMA_ADDR + NPCM7XX_SDMA_BOUNDARY_SIZE);
  160.  
  161. wait_for_block_count(qts, 0);
  162.  
  163. qtest_memread(qts, NPCM7XX_DMA_ADDR, actual, NPCM7XX_SDMA_TRANSFER_SIZE);
  164. g_assert_cmpmem(actual, NPCM7XX_SDMA_TRANSFER_SIZE,
  165. expected, NPCM7XX_SDMA_TRANSFER_SIZE);
  166.  
  167. g_free(expected);
  168. g_free(actual);
  169. qtest_quit(qts);
  170. }
  171.  
  172. /* Check MMC can read values from sd */
  173. static void test_read_sd(void)
  174. {
  175. QTestState *qts = setup_sd_card();
  176.  
  177. write_sdread(qts, "hello world");
  178. write_sdread(qts, "goodbye");
  179.  
  180. qtest_quit(qts);
  181. }
  182.  
  183. static void sdwrite_read(QTestState *qts, const char *msg)
  184. {
  185. int fd, ret;
  186. size_t len = strlen(msg);
  187. char *rmsg = g_malloc(len);
  188.  
  189. /* write message using sdhci */
  190. sdhci_write_cmd(qts, NPCM7XX_MMC_BA, msg, len, NPCM7XX_BLK_SIZE);
  191.  
  192. /* read message from sd */
  193. fd = open(sd_path, O_RDONLY);
  194. g_assert(fd >= 0);
  195. ret = read(fd, rmsg, len);
  196. close(fd);
  197. g_assert(ret == len);
  198.  
  199. g_assert(!memcmp(rmsg, msg, len));
  200.  
  201. g_free(rmsg);
  202. }
  203.  
  204. /* Check MMC can write values to sd */
  205. static void test_write_sd(void)
  206. {
  207. QTestState *qts = setup_sd_card();
  208.  
  209. sdwrite_read(qts, "hello world");
  210. sdwrite_read(qts, "goodbye");
  211.  
  212. qtest_quit(qts);
  213. }
  214.  
  215. /* Check SDHCI has correct default values. */
  216. static void test_reset(void)
  217. {
  218. QTestState *qts = qtest_init("-machine kudo-bmc");
  219. uint64_t addr = NPCM7XX_MMC_BA;
  220. uint64_t end_addr = addr + NPCM7XX_REG_SIZE;
  221. uint16_t prstvals_resets[] = {NPCM7XX_PRSTVALS_0_RESET,
  222. NPCM7XX_PRSTVALS_1_RESET,
  223. 0,
  224. NPCM7XX_PRSTVALS_3_RESET,
  225. 0,
  226. 0};
  227. int i;
  228. uint32_t mask;
  229.  
  230. while (addr < end_addr) {
  231. switch (addr - NPCM7XX_MMC_BA) {
  232. case SDHC_PRNSTS:
  233. /*
  234. * ignores bits 20 to 24: they are changed when reading registers
  235. */
  236. mask = 0x1f00000;
  237. g_assert_cmphex(qtest_readl(qts, addr) | mask, ==,
  238. NPCM7XX_PRSNTS_RESET | mask);
  239. addr += 4;
  240. break;
  241. case SDHC_BLKGAP:
  242. g_assert_cmphex(qtest_readb(qts, addr), ==, NPCM7XX_BLKGAP_RESET);
  243. addr += 1;
  244. break;
  245. case SDHC_CAPAB:
  246. g_assert_cmphex(qtest_readq(qts, addr), ==, NPCM7XX_CAPAB_RESET);
  247. addr += 8;
  248. break;
  249. case SDHC_MAXCURR:
  250. g_assert_cmphex(qtest_readq(qts, addr), ==, NPCM7XX_MAXCURR_RESET);
  251. addr += 8;
  252. break;
  253. case SDHC_HCVER:
  254. g_assert_cmphex(qtest_readw(qts, addr), ==, NPCM7XX_HCVER_RESET);
  255. addr += 2;
  256. break;
  257. case NPCM7XX_PRSTVALS:
  258. for (i = 0; i < NPCM7XX_PRSTVALS_SIZE; ++i) {
  259. g_assert_cmphex(qtest_readw(qts, addr + 2 * i), ==,
  260. prstvals_resets[i]);
  261. }
  262. addr += NPCM7XX_PRSTVALS_SIZE * 2;
  263. break;
  264. default:
  265. g_assert_cmphex(qtest_readb(qts, addr), ==, 0);
  266. addr += 1;
  267. }
  268. }
  269.  
  270. qtest_quit(qts);
  271. }
  272.  
  273. static void drive_destroy(void)
  274. {
  275. unlink(sd_path);
  276. g_free(sd_path);
  277. }
  278.  
  279. static void drive_create(void)
  280. {
  281. int fd, ret;
  282. GError *error = NULL;
  283.  
  284. /* Create a temporary raw image */
  285. fd = g_file_open_tmp("sdhci_XXXXXX", &sd_path, &error);
  286. if (fd == -1) {
  287. fprintf(stderr, "unable to create sdhci file: %s\n", error->message);
  288. g_error_free(error);
  289. }
  290. g_assert(sd_path != NULL);
  291.  
  292. ret = ftruncate(fd, NPCM7XX_TEST_IMAGE_SIZE);
  293. g_assert_cmpint(ret, ==, 0);
  294. g_message("%s", sd_path);
  295. close(fd);
  296. }
  297.  
  298. int main(int argc, char **argv)
  299. {
  300. int ret;
  301.  
  302. drive_create();
  303.  
  304. g_test_init(&argc, &argv, NULL);
  305.  
  306. qtest_add_func("npcm7xx_sdhci/reset", test_reset);
  307. qtest_add_func("npcm7xx_sdhci/write_sd", test_write_sd);
  308. qtest_add_func("npcm7xx_sdhci/read_sd", test_read_sd);
  309. qtest_add_func("npcm7xx_sdhci/read_sd_sdma_boundary_continue",
  310. test_read_sd_sdma_boundary_continue);
  311.  
  312. ret = g_test_run();
  313. drive_destroy();
  314. return ret;
  315. }
  316.  
Advertisement
Add Comment
Please, Sign In to add comment