1 /* 2 * QTests for Nuvoton NPCM7xx EMC Modules. 3 * 4 * Copyright 2020 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 "libqos/libqos.h" 19 #include "qapi/qmp/qdict.h" 20 #include "qapi/qmp/qnum.h" 21 #include "qemu/bitops.h" 22 #include "qemu/iov.h" 23 24 /* Name of the emc device. */ 25 #define TYPE_NPCM7XX_EMC "npcm7xx-emc" 26 27 /* Timeout for various operations, in seconds. */ 28 #define TIMEOUT_SECONDS 10 29 30 /* Address in memory of the descriptor. */ 31 #define DESC_ADDR (1 << 20) /* 1 MiB */ 32 33 /* Address in memory of the data packet. */ 34 #define DATA_ADDR (DESC_ADDR + 4096) 35 36 #define CRC_LENGTH 4 37 38 #define NUM_TX_DESCRIPTORS 3 39 #define NUM_RX_DESCRIPTORS 2 40 41 /* Size of tx,rx test buffers. */ 42 #define TX_DATA_LEN 64 43 #define RX_DATA_LEN 64 44 45 #define TX_STEP_COUNT 10000 46 #define RX_STEP_COUNT 10000 47 48 /* 32-bit register indices. */ 49 typedef enum NPCM7xxPWMRegister { 50 /* Control registers. */ 51 REG_CAMCMR, 52 REG_CAMEN, 53 54 /* There are 16 CAMn[ML] registers. */ 55 REG_CAMM_BASE, 56 REG_CAML_BASE, 57 58 REG_TXDLSA = 0x22, 59 REG_RXDLSA, 60 REG_MCMDR, 61 REG_MIID, 62 REG_MIIDA, 63 REG_FFTCR, 64 REG_TSDR, 65 REG_RSDR, 66 REG_DMARFC, 67 REG_MIEN, 68 69 /* Status registers. */ 70 REG_MISTA, 71 REG_MGSTA, 72 REG_MPCNT, 73 REG_MRPC, 74 REG_MRPCC, 75 REG_MREPC, 76 REG_DMARFS, 77 REG_CTXDSA, 78 REG_CTXBSA, 79 REG_CRXDSA, 80 REG_CRXBSA, 81 82 NPCM7XX_NUM_EMC_REGS, 83 } NPCM7xxPWMRegister; 84 85 enum { NUM_CAMML_REGS = 16 }; 86 87 /* REG_CAMCMR fields */ 88 /* Enable CAM Compare */ 89 #define REG_CAMCMR_ECMP (1 << 4) 90 /* Accept Unicast Packet */ 91 #define REG_CAMCMR_AUP (1 << 0) 92 93 /* REG_MCMDR fields */ 94 /* Software Reset */ 95 #define REG_MCMDR_SWR (1 << 24) 96 /* Frame Transmission On */ 97 #define REG_MCMDR_TXON (1 << 8) 98 /* Accept Long Packet */ 99 #define REG_MCMDR_ALP (1 << 1) 100 /* Frame Reception On */ 101 #define REG_MCMDR_RXON (1 << 0) 102 103 /* REG_MIEN fields */ 104 /* Enable Transmit Completion Interrupt */ 105 #define REG_MIEN_ENTXCP (1 << 18) 106 /* Enable Transmit Interrupt */ 107 #define REG_MIEN_ENTXINTR (1 << 16) 108 /* Enable Receive Good Interrupt */ 109 #define REG_MIEN_ENRXGD (1 << 4) 110 /* ENable Receive Interrupt */ 111 #define REG_MIEN_ENRXINTR (1 << 0) 112 113 /* REG_MISTA fields */ 114 /* Transmit Bus Error Interrupt */ 115 #define REG_MISTA_TXBERR (1 << 24) 116 /* Transmit Descriptor Unavailable Interrupt */ 117 #define REG_MISTA_TDU (1 << 23) 118 /* Transmit Completion Interrupt */ 119 #define REG_MISTA_TXCP (1 << 18) 120 /* Transmit Interrupt */ 121 #define REG_MISTA_TXINTR (1 << 16) 122 /* Receive Bus Error Interrupt */ 123 #define REG_MISTA_RXBERR (1 << 11) 124 /* Receive Descriptor Unavailable Interrupt */ 125 #define REG_MISTA_RDU (1 << 10) 126 /* DMA Early Notification Interrupt */ 127 #define REG_MISTA_DENI (1 << 9) 128 /* Maximum Frame Length Interrupt */ 129 #define REG_MISTA_DFOI (1 << 8) 130 /* Receive Good Interrupt */ 131 #define REG_MISTA_RXGD (1 << 4) 132 /* Packet Too Long Interrupt */ 133 #define REG_MISTA_PTLE (1 << 3) 134 /* Receive Interrupt */ 135 #define REG_MISTA_RXINTR (1 << 0) 136 137 typedef struct NPCM7xxEMCTxDesc NPCM7xxEMCTxDesc; 138 typedef struct NPCM7xxEMCRxDesc NPCM7xxEMCRxDesc; 139 140 struct NPCM7xxEMCTxDesc { 141 uint32_t flags; 142 uint32_t txbsa; 143 uint32_t status_and_length; 144 uint32_t ntxdsa; 145 }; 146 147 struct NPCM7xxEMCRxDesc { 148 uint32_t status_and_length; 149 uint32_t rxbsa; 150 uint32_t reserved; 151 uint32_t nrxdsa; 152 }; 153 154 /* NPCM7xxEMCTxDesc.flags values */ 155 /* Owner: 0 = cpu, 1 = emc */ 156 #define TX_DESC_FLAG_OWNER_MASK (1 << 31) 157 /* Transmit interrupt enable */ 158 #define TX_DESC_FLAG_INTEN (1 << 2) 159 160 /* NPCM7xxEMCTxDesc.status_and_length values */ 161 /* Transmission complete */ 162 #define TX_DESC_STATUS_TXCP (1 << 19) 163 /* Transmit interrupt */ 164 #define TX_DESC_STATUS_TXINTR (1 << 16) 165 166 /* NPCM7xxEMCRxDesc.status_and_length values */ 167 /* Owner: 0b00 = cpu, 0b10 = emc */ 168 #define RX_DESC_STATUS_OWNER_SHIFT 30 169 #define RX_DESC_STATUS_OWNER_MASK 0xc0000000 170 /* Frame Reception Complete */ 171 #define RX_DESC_STATUS_RXGD (1 << 20) 172 /* Packet too long */ 173 #define RX_DESC_STATUS_PTLE (1 << 19) 174 /* Receive Interrupt */ 175 #define RX_DESC_STATUS_RXINTR (1 << 16) 176 177 #define RX_DESC_PKT_LEN(word) ((uint32_t) (word) & 0xffff) 178 179 typedef struct EMCModule { 180 int rx_irq; 181 int tx_irq; 182 uint64_t base_addr; 183 } EMCModule; 184 185 typedef struct TestData { 186 const EMCModule *module; 187 } TestData; 188 189 static const EMCModule emc_module_list[] = { 190 { 191 .rx_irq = 15, 192 .tx_irq = 16, 193 .base_addr = 0xf0825000 194 }, 195 { 196 .rx_irq = 114, 197 .tx_irq = 115, 198 .base_addr = 0xf0826000 199 } 200 }; 201 202 /* Returns the index of the EMC module. */ 203 static int emc_module_index(const EMCModule *mod) 204 { 205 ptrdiff_t diff = mod - emc_module_list; 206 207 g_assert_true(diff >= 0 && diff < ARRAY_SIZE(emc_module_list)); 208 209 return diff; 210 } 211 212 #ifndef _WIN32 213 static void packet_test_clear(void *sockets) 214 { 215 int *test_sockets = sockets; 216 217 close(test_sockets[0]); 218 g_free(test_sockets); 219 } 220 221 static int *packet_test_init(int module_num, GString *cmd_line) 222 { 223 int *test_sockets = g_new(int, 2); 224 int ret = socketpair(PF_UNIX, SOCK_STREAM, 0, test_sockets); 225 g_assert_cmpint(ret, != , -1); 226 227 /* 228 * KISS and use -nic. We specify two nics (both emc{0,1}) because there's 229 * currently no way to specify only emc1: The driver implicitly relies on 230 * emc[i] == nd_table[i]. 231 */ 232 if (module_num == 0) { 233 g_string_append_printf(cmd_line, 234 " -nic socket,fd=%d,model=" TYPE_NPCM7XX_EMC " " 235 " -nic user,model=" TYPE_NPCM7XX_EMC " ", 236 test_sockets[1]); 237 } else { 238 g_string_append_printf(cmd_line, 239 " -nic user,model=" TYPE_NPCM7XX_EMC " " 240 " -nic socket,fd=%d,model=" TYPE_NPCM7XX_EMC " ", 241 test_sockets[1]); 242 } 243 244 g_test_queue_destroy(packet_test_clear, test_sockets); 245 return test_sockets; 246 } 247 #endif /* _WIN32 */ 248 249 static uint32_t emc_read(QTestState *qts, const EMCModule *mod, 250 NPCM7xxPWMRegister regno) 251 { 252 return qtest_readl(qts, mod->base_addr + regno * sizeof(uint32_t)); 253 } 254 255 #ifndef _WIN32 256 static void emc_write(QTestState *qts, const EMCModule *mod, 257 NPCM7xxPWMRegister regno, uint32_t value) 258 { 259 qtest_writel(qts, mod->base_addr + regno * sizeof(uint32_t), value); 260 } 261 262 static void emc_read_tx_desc(QTestState *qts, uint32_t addr, 263 NPCM7xxEMCTxDesc *desc) 264 { 265 qtest_memread(qts, addr, desc, sizeof(*desc)); 266 desc->flags = le32_to_cpu(desc->flags); 267 desc->txbsa = le32_to_cpu(desc->txbsa); 268 desc->status_and_length = le32_to_cpu(desc->status_and_length); 269 desc->ntxdsa = le32_to_cpu(desc->ntxdsa); 270 } 271 272 static void emc_write_tx_desc(QTestState *qts, const NPCM7xxEMCTxDesc *desc, 273 uint32_t addr) 274 { 275 NPCM7xxEMCTxDesc le_desc; 276 277 le_desc.flags = cpu_to_le32(desc->flags); 278 le_desc.txbsa = cpu_to_le32(desc->txbsa); 279 le_desc.status_and_length = cpu_to_le32(desc->status_and_length); 280 le_desc.ntxdsa = cpu_to_le32(desc->ntxdsa); 281 qtest_memwrite(qts, addr, &le_desc, sizeof(le_desc)); 282 } 283 284 static void emc_read_rx_desc(QTestState *qts, uint32_t addr, 285 NPCM7xxEMCRxDesc *desc) 286 { 287 qtest_memread(qts, addr, desc, sizeof(*desc)); 288 desc->status_and_length = le32_to_cpu(desc->status_and_length); 289 desc->rxbsa = le32_to_cpu(desc->rxbsa); 290 desc->reserved = le32_to_cpu(desc->reserved); 291 desc->nrxdsa = le32_to_cpu(desc->nrxdsa); 292 } 293 294 static void emc_write_rx_desc(QTestState *qts, const NPCM7xxEMCRxDesc *desc, 295 uint32_t addr) 296 { 297 NPCM7xxEMCRxDesc le_desc; 298 299 le_desc.status_and_length = cpu_to_le32(desc->status_and_length); 300 le_desc.rxbsa = cpu_to_le32(desc->rxbsa); 301 le_desc.reserved = cpu_to_le32(desc->reserved); 302 le_desc.nrxdsa = cpu_to_le32(desc->nrxdsa); 303 qtest_memwrite(qts, addr, &le_desc, sizeof(le_desc)); 304 } 305 306 /* 307 * Reset the EMC module. 308 * The module must be reset before, e.g., TXDLSA,RXDLSA are changed. 309 */ 310 static bool emc_soft_reset(QTestState *qts, const EMCModule *mod) 311 { 312 uint32_t val; 313 uint64_t end_time; 314 315 emc_write(qts, mod, REG_MCMDR, REG_MCMDR_SWR); 316 317 /* 318 * Wait for device to reset as the linux driver does. 319 * During reset the AHB reads 0 for all registers. So first wait for 320 * something that resets to non-zero, and then wait for SWR becoming 0. 321 */ 322 end_time = g_get_monotonic_time() + TIMEOUT_SECONDS * G_TIME_SPAN_SECOND; 323 324 do { 325 qtest_clock_step(qts, 100); 326 val = emc_read(qts, mod, REG_FFTCR); 327 } while (val == 0 && g_get_monotonic_time() < end_time); 328 if (val != 0) { 329 do { 330 qtest_clock_step(qts, 100); 331 val = emc_read(qts, mod, REG_MCMDR); 332 if ((val & REG_MCMDR_SWR) == 0) { 333 /* 334 * N.B. The CAMs have been reset here, so macaddr matching of 335 * incoming packets will not work. 336 */ 337 return true; 338 } 339 } while (g_get_monotonic_time() < end_time); 340 } 341 342 g_message("%s: Timeout expired", __func__); 343 return false; 344 } 345 #endif /* _WIN32 */ 346 347 /* Check emc registers are reset to default value. */ 348 static void test_init(gconstpointer test_data) 349 { 350 const TestData *td = test_data; 351 const EMCModule *mod = td->module; 352 QTestState *qts = qtest_init("-machine quanta-gsj"); 353 int i; 354 355 #define CHECK_REG(regno, value) \ 356 do { \ 357 g_assert_cmphex(emc_read(qts, mod, (regno)), ==, (value)); \ 358 } while (0) 359 360 CHECK_REG(REG_CAMCMR, 0); 361 CHECK_REG(REG_CAMEN, 0); 362 CHECK_REG(REG_TXDLSA, 0xfffffffc); 363 CHECK_REG(REG_RXDLSA, 0xfffffffc); 364 CHECK_REG(REG_MCMDR, 0); 365 CHECK_REG(REG_MIID, 0); 366 CHECK_REG(REG_MIIDA, 0x00900000); 367 CHECK_REG(REG_FFTCR, 0x0101); 368 CHECK_REG(REG_DMARFC, 0x0800); 369 CHECK_REG(REG_MIEN, 0); 370 CHECK_REG(REG_MISTA, 0); 371 CHECK_REG(REG_MGSTA, 0); 372 CHECK_REG(REG_MPCNT, 0x7fff); 373 CHECK_REG(REG_MRPC, 0); 374 CHECK_REG(REG_MRPCC, 0); 375 CHECK_REG(REG_MREPC, 0); 376 CHECK_REG(REG_DMARFS, 0); 377 CHECK_REG(REG_CTXDSA, 0); 378 CHECK_REG(REG_CTXBSA, 0); 379 CHECK_REG(REG_CRXDSA, 0); 380 CHECK_REG(REG_CRXBSA, 0); 381 382 #undef CHECK_REG 383 384 for (i = 0; i < NUM_CAMML_REGS; ++i) { 385 g_assert_cmpuint(emc_read(qts, mod, REG_CAMM_BASE + i * 2), ==, 386 0); 387 g_assert_cmpuint(emc_read(qts, mod, REG_CAML_BASE + i * 2), ==, 388 0); 389 } 390 391 qtest_quit(qts); 392 } 393 394 #ifndef _WIN32 395 static bool emc_wait_irq(QTestState *qts, const EMCModule *mod, int step, 396 bool is_tx) 397 { 398 uint64_t end_time = 399 g_get_monotonic_time() + TIMEOUT_SECONDS * G_TIME_SPAN_SECOND; 400 401 do { 402 if (qtest_get_irq(qts, is_tx ? mod->tx_irq : mod->rx_irq)) { 403 return true; 404 } 405 qtest_clock_step(qts, step); 406 } while (g_get_monotonic_time() < end_time); 407 408 g_message("%s: Timeout expired", __func__); 409 return false; 410 } 411 412 static bool emc_wait_mista(QTestState *qts, const EMCModule *mod, int step, 413 uint32_t flag) 414 { 415 uint64_t end_time = 416 g_get_monotonic_time() + TIMEOUT_SECONDS * G_TIME_SPAN_SECOND; 417 418 do { 419 uint32_t mista = emc_read(qts, mod, REG_MISTA); 420 if (mista & flag) { 421 return true; 422 } 423 qtest_clock_step(qts, step); 424 } while (g_get_monotonic_time() < end_time); 425 426 g_message("%s: Timeout expired", __func__); 427 return false; 428 } 429 430 static bool wait_socket_readable(int fd) 431 { 432 fd_set read_fds; 433 struct timeval tv; 434 int rv; 435 436 FD_ZERO(&read_fds); 437 FD_SET(fd, &read_fds); 438 tv.tv_sec = TIMEOUT_SECONDS; 439 tv.tv_usec = 0; 440 rv = select(fd + 1, &read_fds, NULL, NULL, &tv); 441 if (rv == -1) { 442 perror("select"); 443 } else if (rv == 0) { 444 g_message("%s: Timeout expired", __func__); 445 } 446 return rv == 1; 447 } 448 449 /* Initialize *desc (in host endian format). */ 450 static void init_tx_desc(NPCM7xxEMCTxDesc *desc, size_t count, 451 uint32_t desc_addr) 452 { 453 g_assert(count >= 2); 454 memset(&desc[0], 0, sizeof(*desc) * count); 455 /* Leave the last one alone, owned by the cpu -> stops transmission. */ 456 for (size_t i = 0; i < count - 1; ++i) { 457 desc[i].flags = 458 (TX_DESC_FLAG_OWNER_MASK | /* owner = 1: emc */ 459 TX_DESC_FLAG_INTEN | 460 0 | /* crc append = 0 */ 461 0 /* padding enable = 0 */); 462 desc[i].status_and_length = 463 (0 | /* collision count = 0 */ 464 0 | /* SQE = 0 */ 465 0 | /* PAU = 0 */ 466 0 | /* TXHA = 0 */ 467 0 | /* LC = 0 */ 468 0 | /* TXABT = 0 */ 469 0 | /* NCS = 0 */ 470 0 | /* EXDEF = 0 */ 471 0 | /* TXCP = 0 */ 472 0 | /* DEF = 0 */ 473 0 | /* TXINTR = 0 */ 474 0 /* length filled in later */); 475 desc[i].ntxdsa = desc_addr + (i + 1) * sizeof(*desc); 476 } 477 } 478 479 static void enable_tx(QTestState *qts, const EMCModule *mod, 480 const NPCM7xxEMCTxDesc *desc, size_t count, 481 uint32_t desc_addr, uint32_t mien_flags) 482 { 483 /* Write the descriptors to guest memory. */ 484 for (size_t i = 0; i < count; ++i) { 485 emc_write_tx_desc(qts, desc + i, desc_addr + i * sizeof(*desc)); 486 } 487 488 /* Trigger sending the packet. */ 489 /* The module must be reset before changing TXDLSA. */ 490 g_assert(emc_soft_reset(qts, mod)); 491 emc_write(qts, mod, REG_TXDLSA, desc_addr); 492 emc_write(qts, mod, REG_CTXDSA, ~0); 493 emc_write(qts, mod, REG_MIEN, REG_MIEN_ENTXCP | mien_flags); 494 { 495 uint32_t mcmdr = emc_read(qts, mod, REG_MCMDR); 496 mcmdr |= REG_MCMDR_TXON; 497 emc_write(qts, mod, REG_MCMDR, mcmdr); 498 } 499 } 500 501 static void emc_send_verify1(QTestState *qts, const EMCModule *mod, int fd, 502 bool with_irq, uint32_t desc_addr, 503 uint32_t next_desc_addr, 504 const char *test_data, int test_size) 505 { 506 NPCM7xxEMCTxDesc result_desc; 507 uint32_t expected_mask, expected_value, recv_len; 508 int ret; 509 char buffer[TX_DATA_LEN]; 510 511 g_assert(wait_socket_readable(fd)); 512 513 /* Read the descriptor back. */ 514 emc_read_tx_desc(qts, desc_addr, &result_desc); 515 /* Descriptor should be owned by cpu now. */ 516 g_assert((result_desc.flags & TX_DESC_FLAG_OWNER_MASK) == 0); 517 /* Test the status bits, ignoring the length field. */ 518 expected_mask = 0xffff << 16; 519 expected_value = TX_DESC_STATUS_TXCP; 520 if (with_irq) { 521 expected_value |= TX_DESC_STATUS_TXINTR; 522 } 523 g_assert_cmphex((result_desc.status_and_length & expected_mask), ==, 524 expected_value); 525 526 /* Check data sent to the backend. */ 527 recv_len = ~0; 528 ret = recv(fd, &recv_len, sizeof(recv_len), MSG_DONTWAIT); 529 g_assert_cmpint(ret, == , sizeof(recv_len)); 530 531 g_assert(wait_socket_readable(fd)); 532 memset(buffer, 0xff, sizeof(buffer)); 533 ret = recv(fd, buffer, test_size, MSG_DONTWAIT); 534 g_assert_cmpmem(buffer, ret, test_data, test_size); 535 } 536 537 static void emc_send_verify(QTestState *qts, const EMCModule *mod, int fd, 538 bool with_irq) 539 { 540 NPCM7xxEMCTxDesc desc[NUM_TX_DESCRIPTORS]; 541 uint32_t desc_addr = DESC_ADDR; 542 static const char test1_data[] = "TEST1"; 543 static const char test2_data[] = "Testing 1 2 3 ..."; 544 uint32_t data1_addr = DATA_ADDR; 545 uint32_t data2_addr = data1_addr + sizeof(test1_data); 546 bool got_tdu; 547 uint32_t end_desc_addr; 548 549 /* Prepare test data buffer. */ 550 qtest_memwrite(qts, data1_addr, test1_data, sizeof(test1_data)); 551 qtest_memwrite(qts, data2_addr, test2_data, sizeof(test2_data)); 552 553 init_tx_desc(&desc[0], NUM_TX_DESCRIPTORS, desc_addr); 554 desc[0].txbsa = data1_addr; 555 desc[0].status_and_length |= sizeof(test1_data); 556 desc[1].txbsa = data2_addr; 557 desc[1].status_and_length |= sizeof(test2_data); 558 559 enable_tx(qts, mod, &desc[0], NUM_TX_DESCRIPTORS, desc_addr, 560 with_irq ? REG_MIEN_ENTXINTR : 0); 561 562 /* Prod the device to send the packet. */ 563 emc_write(qts, mod, REG_TSDR, 1); 564 565 /* 566 * It's problematic to observe the interrupt for each packet. 567 * Instead just wait until all the packets go out. 568 */ 569 got_tdu = false; 570 while (!got_tdu) { 571 if (with_irq) { 572 g_assert_true(emc_wait_irq(qts, mod, TX_STEP_COUNT, 573 /*is_tx=*/true)); 574 } else { 575 g_assert_true(emc_wait_mista(qts, mod, TX_STEP_COUNT, 576 REG_MISTA_TXINTR)); 577 } 578 got_tdu = !!(emc_read(qts, mod, REG_MISTA) & REG_MISTA_TDU); 579 /* If we don't have TDU yet, reset the interrupt. */ 580 if (!got_tdu) { 581 emc_write(qts, mod, REG_MISTA, 582 emc_read(qts, mod, REG_MISTA) & 0xffff0000); 583 } 584 } 585 586 end_desc_addr = desc_addr + 2 * sizeof(desc[0]); 587 g_assert_cmphex(emc_read(qts, mod, REG_CTXDSA), ==, end_desc_addr); 588 g_assert_cmphex(emc_read(qts, mod, REG_MISTA), ==, 589 REG_MISTA_TXCP | REG_MISTA_TXINTR | REG_MISTA_TDU); 590 591 emc_send_verify1(qts, mod, fd, with_irq, 592 desc_addr, end_desc_addr, 593 test1_data, sizeof(test1_data)); 594 emc_send_verify1(qts, mod, fd, with_irq, 595 desc_addr + sizeof(desc[0]), end_desc_addr, 596 test2_data, sizeof(test2_data)); 597 } 598 599 /* Initialize *desc (in host endian format). */ 600 static void init_rx_desc(NPCM7xxEMCRxDesc *desc, size_t count, 601 uint32_t desc_addr, uint32_t data_addr) 602 { 603 g_assert_true(count >= 2); 604 memset(desc, 0, sizeof(*desc) * count); 605 desc[0].rxbsa = data_addr; 606 desc[0].status_and_length = 607 (0b10 << RX_DESC_STATUS_OWNER_SHIFT | /* owner = 10: emc */ 608 0 | /* RP = 0 */ 609 0 | /* ALIE = 0 */ 610 0 | /* RXGD = 0 */ 611 0 | /* PTLE = 0 */ 612 0 | /* CRCE = 0 */ 613 0 | /* RXINTR = 0 */ 614 0 /* length (filled in later) */); 615 /* Leave the last one alone, owned by the cpu -> stops transmission. */ 616 desc[0].nrxdsa = desc_addr + sizeof(*desc); 617 } 618 619 static void enable_rx(QTestState *qts, const EMCModule *mod, 620 const NPCM7xxEMCRxDesc *desc, size_t count, 621 uint32_t desc_addr, uint32_t mien_flags, 622 uint32_t mcmdr_flags) 623 { 624 /* 625 * Write the descriptor to guest memory. 626 * FWIW, IWBN if the docs said the buffer needs to be at least DMARFC 627 * bytes. 628 */ 629 for (size_t i = 0; i < count; ++i) { 630 emc_write_rx_desc(qts, desc + i, desc_addr + i * sizeof(*desc)); 631 } 632 633 /* Trigger receiving the packet. */ 634 /* The module must be reset before changing RXDLSA. */ 635 g_assert(emc_soft_reset(qts, mod)); 636 emc_write(qts, mod, REG_RXDLSA, desc_addr); 637 emc_write(qts, mod, REG_MIEN, REG_MIEN_ENRXGD | mien_flags); 638 639 /* 640 * We don't know what the device's macaddr is, so just accept all 641 * unicast packets (AUP). 642 */ 643 emc_write(qts, mod, REG_CAMCMR, REG_CAMCMR_AUP); 644 emc_write(qts, mod, REG_CAMEN, 1 << 0); 645 { 646 uint32_t mcmdr = emc_read(qts, mod, REG_MCMDR); 647 mcmdr |= REG_MCMDR_RXON | mcmdr_flags; 648 emc_write(qts, mod, REG_MCMDR, mcmdr); 649 } 650 } 651 652 static void emc_recv_verify(QTestState *qts, const EMCModule *mod, int fd, 653 bool with_irq, bool pump_rsdr) 654 { 655 NPCM7xxEMCRxDesc desc[NUM_RX_DESCRIPTORS]; 656 uint32_t desc_addr = DESC_ADDR; 657 uint32_t data_addr = DATA_ADDR; 658 int ret; 659 uint32_t expected_mask, expected_value; 660 NPCM7xxEMCRxDesc result_desc; 661 662 /* Prepare test data buffer. */ 663 const char test[RX_DATA_LEN] = "TEST"; 664 int len = htonl(sizeof(test)); 665 const struct iovec iov[] = { 666 { 667 .iov_base = &len, 668 .iov_len = sizeof(len), 669 },{ 670 .iov_base = (char *) test, 671 .iov_len = sizeof(test), 672 }, 673 }; 674 675 /* 676 * Reset the device BEFORE sending a test packet, otherwise the packet 677 * may get swallowed by an active device of an earlier test. 678 */ 679 init_rx_desc(&desc[0], NUM_RX_DESCRIPTORS, desc_addr, data_addr); 680 enable_rx(qts, mod, &desc[0], NUM_RX_DESCRIPTORS, desc_addr, 681 with_irq ? REG_MIEN_ENRXINTR : 0, 0); 682 683 /* 684 * If requested, prod the device to accept a packet. 685 * This isn't necessary, the linux driver doesn't do this. 686 * Test doing/not-doing this for robustness. 687 */ 688 if (pump_rsdr) { 689 emc_write(qts, mod, REG_RSDR, 1); 690 } 691 692 /* Send test packet to device's socket. */ 693 ret = iov_send(fd, iov, 2, 0, sizeof(len) + sizeof(test)); 694 g_assert_cmpint(ret, == , sizeof(test) + sizeof(len)); 695 696 /* Wait for RX interrupt. */ 697 if (with_irq) { 698 g_assert_true(emc_wait_irq(qts, mod, RX_STEP_COUNT, /*is_tx=*/false)); 699 } else { 700 g_assert_true(emc_wait_mista(qts, mod, RX_STEP_COUNT, REG_MISTA_RXGD)); 701 } 702 703 g_assert_cmphex(emc_read(qts, mod, REG_CRXDSA), ==, 704 desc_addr + sizeof(desc[0])); 705 706 expected_mask = 0xffff; 707 expected_value = (REG_MISTA_DENI | 708 REG_MISTA_RXGD | 709 REG_MISTA_RXINTR); 710 g_assert_cmphex((emc_read(qts, mod, REG_MISTA) & expected_mask), 711 ==, expected_value); 712 713 /* Read the descriptor back. */ 714 emc_read_rx_desc(qts, desc_addr, &result_desc); 715 /* Descriptor should be owned by cpu now. */ 716 g_assert((result_desc.status_and_length & RX_DESC_STATUS_OWNER_MASK) == 0); 717 /* Test the status bits, ignoring the length field. */ 718 expected_mask = 0xffff << 16; 719 expected_value = RX_DESC_STATUS_RXGD; 720 if (with_irq) { 721 expected_value |= RX_DESC_STATUS_RXINTR; 722 } 723 g_assert_cmphex((result_desc.status_and_length & expected_mask), ==, 724 expected_value); 725 g_assert_cmpint(RX_DESC_PKT_LEN(result_desc.status_and_length), ==, 726 RX_DATA_LEN + CRC_LENGTH); 727 728 { 729 char buffer[RX_DATA_LEN]; 730 qtest_memread(qts, data_addr, buffer, sizeof(buffer)); 731 g_assert_cmpstr(buffer, == , "TEST"); 732 } 733 } 734 735 static void emc_test_ptle(QTestState *qts, const EMCModule *mod, int fd) 736 { 737 NPCM7xxEMCRxDesc desc[NUM_RX_DESCRIPTORS]; 738 uint32_t desc_addr = DESC_ADDR; 739 uint32_t data_addr = DATA_ADDR; 740 int ret; 741 NPCM7xxEMCRxDesc result_desc; 742 uint32_t expected_mask, expected_value; 743 744 /* Prepare test data buffer. */ 745 #define PTLE_DATA_LEN 1600 746 char test_data[PTLE_DATA_LEN]; 747 int len = htonl(sizeof(test_data)); 748 const struct iovec iov[] = { 749 { 750 .iov_base = &len, 751 .iov_len = sizeof(len), 752 },{ 753 .iov_base = (char *) test_data, 754 .iov_len = sizeof(test_data), 755 }, 756 }; 757 memset(test_data, 42, sizeof(test_data)); 758 759 /* 760 * Reset the device BEFORE sending a test packet, otherwise the packet 761 * may get swallowed by an active device of an earlier test. 762 */ 763 init_rx_desc(&desc[0], NUM_RX_DESCRIPTORS, desc_addr, data_addr); 764 enable_rx(qts, mod, &desc[0], NUM_RX_DESCRIPTORS, desc_addr, 765 REG_MIEN_ENRXINTR, REG_MCMDR_ALP); 766 767 /* Send test packet to device's socket. */ 768 ret = iov_send(fd, iov, 2, 0, sizeof(len) + sizeof(test_data)); 769 g_assert_cmpint(ret, == , sizeof(test_data) + sizeof(len)); 770 771 /* Wait for RX interrupt. */ 772 g_assert_true(emc_wait_irq(qts, mod, RX_STEP_COUNT, /*is_tx=*/false)); 773 774 /* Read the descriptor back. */ 775 emc_read_rx_desc(qts, desc_addr, &result_desc); 776 /* Descriptor should be owned by cpu now. */ 777 g_assert((result_desc.status_and_length & RX_DESC_STATUS_OWNER_MASK) == 0); 778 /* Test the status bits, ignoring the length field. */ 779 expected_mask = 0xffff << 16; 780 expected_value = (RX_DESC_STATUS_RXGD | 781 RX_DESC_STATUS_PTLE | 782 RX_DESC_STATUS_RXINTR); 783 g_assert_cmphex((result_desc.status_and_length & expected_mask), ==, 784 expected_value); 785 g_assert_cmpint(RX_DESC_PKT_LEN(result_desc.status_and_length), ==, 786 PTLE_DATA_LEN + CRC_LENGTH); 787 788 { 789 char buffer[PTLE_DATA_LEN]; 790 qtest_memread(qts, data_addr, buffer, sizeof(buffer)); 791 g_assert(memcmp(buffer, test_data, PTLE_DATA_LEN) == 0); 792 } 793 } 794 795 static void test_tx(gconstpointer test_data) 796 { 797 const TestData *td = test_data; 798 GString *cmd_line = g_string_new("-machine quanta-gsj"); 799 int *test_sockets = packet_test_init(emc_module_index(td->module), 800 cmd_line); 801 QTestState *qts = qtest_init(cmd_line->str); 802 803 /* 804 * TODO: For pedantic correctness test_sockets[0] should be closed after 805 * the fork and before the exec, but that will require some harness 806 * improvements. 807 */ 808 close(test_sockets[1]); 809 /* Defensive programming */ 810 test_sockets[1] = -1; 811 812 qtest_irq_intercept_in(qts, "/machine/soc/a9mpcore/gic"); 813 814 emc_send_verify(qts, td->module, test_sockets[0], /*with_irq=*/false); 815 emc_send_verify(qts, td->module, test_sockets[0], /*with_irq=*/true); 816 817 qtest_quit(qts); 818 } 819 820 static void test_rx(gconstpointer test_data) 821 { 822 const TestData *td = test_data; 823 GString *cmd_line = g_string_new("-machine quanta-gsj"); 824 int *test_sockets = packet_test_init(emc_module_index(td->module), 825 cmd_line); 826 QTestState *qts = qtest_init(cmd_line->str); 827 828 /* 829 * TODO: For pedantic correctness test_sockets[0] should be closed after 830 * the fork and before the exec, but that will require some harness 831 * improvements. 832 */ 833 close(test_sockets[1]); 834 /* Defensive programming */ 835 test_sockets[1] = -1; 836 837 qtest_irq_intercept_in(qts, "/machine/soc/a9mpcore/gic"); 838 839 emc_recv_verify(qts, td->module, test_sockets[0], /*with_irq=*/false, 840 /*pump_rsdr=*/false); 841 emc_recv_verify(qts, td->module, test_sockets[0], /*with_irq=*/false, 842 /*pump_rsdr=*/true); 843 emc_recv_verify(qts, td->module, test_sockets[0], /*with_irq=*/true, 844 /*pump_rsdr=*/false); 845 emc_recv_verify(qts, td->module, test_sockets[0], /*with_irq=*/true, 846 /*pump_rsdr=*/true); 847 emc_test_ptle(qts, td->module, test_sockets[0]); 848 849 qtest_quit(qts); 850 } 851 #endif /* _WIN32 */ 852 853 static void emc_add_test(const char *name, const TestData* td, 854 GTestDataFunc fn) 855 { 856 g_autofree char *full_name = g_strdup_printf( 857 "npcm7xx_emc/emc[%d]/%s", emc_module_index(td->module), name); 858 qtest_add_data_func(full_name, td, fn); 859 } 860 #define add_test(name, td) emc_add_test(#name, td, test_##name) 861 862 int main(int argc, char **argv) 863 { 864 TestData test_data_list[ARRAY_SIZE(emc_module_list)]; 865 866 g_test_init(&argc, &argv, NULL); 867 868 for (int i = 0; i < ARRAY_SIZE(emc_module_list); ++i) { 869 TestData *td = &test_data_list[i]; 870 871 td->module = &emc_module_list[i]; 872 873 add_test(init, td); 874 #ifndef _WIN32 875 add_test(tx, td); 876 add_test(rx, td); 877 #endif 878 } 879 880 return g_test_run(); 881 } 882