1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (c) 2015-2018 Atomic Rules LLC 3 */ 4 5 #include <unistd.h> 6 #include <sys/stat.h> 7 #include <dlfcn.h> 8 9 #include <rte_bus_pci.h> 10 #include <rte_ethdev_pci.h> 11 #include <rte_kvargs.h> 12 13 #include "rte_pmd_ark.h" 14 #include "ark_global.h" 15 #include "ark_logs.h" 16 #include "ark_ethdev_tx.h" 17 #include "ark_ethdev_rx.h" 18 #include "ark_mpu.h" 19 #include "ark_ddm.h" 20 #include "ark_udm.h" 21 #include "ark_rqp.h" 22 #include "ark_pktdir.h" 23 #include "ark_pktgen.h" 24 #include "ark_pktchkr.h" 25 26 /* Internal prototypes */ 27 static int eth_ark_check_args(struct ark_adapter *ark, const char *params); 28 static int eth_ark_dev_init(struct rte_eth_dev *dev); 29 static int ark_config_device(struct rte_eth_dev *dev); 30 static int eth_ark_dev_uninit(struct rte_eth_dev *eth_dev); 31 static int eth_ark_dev_configure(struct rte_eth_dev *dev); 32 static int eth_ark_dev_start(struct rte_eth_dev *dev); 33 static int eth_ark_dev_stop(struct rte_eth_dev *dev); 34 static int eth_ark_dev_close(struct rte_eth_dev *dev); 35 static int eth_ark_dev_info_get(struct rte_eth_dev *dev, 36 struct rte_eth_dev_info *dev_info); 37 static int eth_ark_dev_link_update(struct rte_eth_dev *dev, 38 int wait_to_complete); 39 static int eth_ark_dev_set_link_up(struct rte_eth_dev *dev); 40 static int eth_ark_dev_set_link_down(struct rte_eth_dev *dev); 41 static int eth_ark_dev_stats_get(struct rte_eth_dev *dev, 42 struct rte_eth_stats *stats); 43 static int eth_ark_dev_stats_reset(struct rte_eth_dev *dev); 44 static int eth_ark_set_default_mac_addr(struct rte_eth_dev *dev, 45 struct rte_ether_addr *mac_addr); 46 static int eth_ark_macaddr_add(struct rte_eth_dev *dev, 47 struct rte_ether_addr *mac_addr, 48 uint32_t index, 49 uint32_t pool); 50 static void eth_ark_macaddr_remove(struct rte_eth_dev *dev, 51 uint32_t index); 52 static int eth_ark_set_mtu(struct rte_eth_dev *dev, uint16_t size); 53 54 /* 55 * The packet generator is a functional block used to generate packet 56 * patterns for testing. It is not intended for nominal use. 57 */ 58 #define ARK_PKTGEN_ARG "Pkt_gen" 59 60 /* 61 * The packet checker is a functional block used to verify packet 62 * patterns for testing. It is not intended for nominal use. 63 */ 64 #define ARK_PKTCHKR_ARG "Pkt_chkr" 65 66 /* 67 * The packet director is used to select the internal ingress and 68 * egress packets paths during testing. It is not intended for 69 * nominal use. 70 */ 71 #define ARK_PKTDIR_ARG "Pkt_dir" 72 73 /* Devinfo configurations */ 74 #define ARK_RX_MAX_QUEUE (4096 * 4) 75 #define ARK_RX_MIN_QUEUE (512) 76 #define ARK_RX_MAX_PKT_LEN ((16 * 1024) - 128) 77 #define ARK_RX_MIN_BUFSIZE (1024) 78 79 #define ARK_TX_MAX_QUEUE (4096 * 4) 80 #define ARK_TX_MIN_QUEUE (256) 81 82 uint64_t ark_timestamp_rx_dynflag; 83 int ark_timestamp_dynfield_offset = -1; 84 85 int rte_pmd_ark_rx_userdata_dynfield_offset = -1; 86 int rte_pmd_ark_tx_userdata_dynfield_offset = -1; 87 88 static const char * const valid_arguments[] = { 89 ARK_PKTGEN_ARG, 90 ARK_PKTCHKR_ARG, 91 ARK_PKTDIR_ARG, 92 NULL 93 }; 94 95 static const struct rte_pci_id pci_id_ark_map[] = { 96 {RTE_PCI_DEVICE(0x1d6c, 0x100d)}, 97 {RTE_PCI_DEVICE(0x1d6c, 0x100e)}, 98 {.vendor_id = 0, /* sentinel */ }, 99 }; 100 101 static int 102 eth_ark_pci_probe(struct rte_pci_driver *pci_drv __rte_unused, 103 struct rte_pci_device *pci_dev) 104 { 105 struct rte_eth_dev *eth_dev; 106 int ret; 107 108 eth_dev = rte_eth_dev_pci_allocate(pci_dev, sizeof(struct ark_adapter)); 109 110 if (eth_dev == NULL) 111 return -ENOMEM; 112 113 ret = eth_ark_dev_init(eth_dev); 114 if (ret) 115 rte_eth_dev_release_port(eth_dev); 116 117 return ret; 118 } 119 120 static int 121 eth_ark_pci_remove(struct rte_pci_device *pci_dev) 122 { 123 return rte_eth_dev_pci_generic_remove(pci_dev, eth_ark_dev_uninit); 124 } 125 126 static struct rte_pci_driver rte_ark_pmd = { 127 .id_table = pci_id_ark_map, 128 .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_INTR_LSC, 129 .probe = eth_ark_pci_probe, 130 .remove = eth_ark_pci_remove, 131 }; 132 133 static const struct eth_dev_ops ark_eth_dev_ops = { 134 .dev_configure = eth_ark_dev_configure, 135 .dev_start = eth_ark_dev_start, 136 .dev_stop = eth_ark_dev_stop, 137 .dev_close = eth_ark_dev_close, 138 139 .dev_infos_get = eth_ark_dev_info_get, 140 141 .rx_queue_setup = eth_ark_dev_rx_queue_setup, 142 .tx_queue_setup = eth_ark_tx_queue_setup, 143 144 .link_update = eth_ark_dev_link_update, 145 .dev_set_link_up = eth_ark_dev_set_link_up, 146 .dev_set_link_down = eth_ark_dev_set_link_down, 147 148 .rx_queue_start = eth_ark_rx_start_queue, 149 .rx_queue_stop = eth_ark_rx_stop_queue, 150 151 .tx_queue_start = eth_ark_tx_queue_start, 152 .tx_queue_stop = eth_ark_tx_queue_stop, 153 154 .stats_get = eth_ark_dev_stats_get, 155 .stats_reset = eth_ark_dev_stats_reset, 156 157 .mac_addr_add = eth_ark_macaddr_add, 158 .mac_addr_remove = eth_ark_macaddr_remove, 159 .mac_addr_set = eth_ark_set_default_mac_addr, 160 161 .mtu_set = eth_ark_set_mtu, 162 }; 163 164 static int 165 check_for_ext(struct ark_adapter *ark) 166 { 167 int found = 0; 168 169 /* Get the env */ 170 const char *dllpath = getenv("ARK_EXT_PATH"); 171 172 if (dllpath == NULL) { 173 ARK_PMD_LOG(DEBUG, "EXT NO dll path specified\n"); 174 return 0; 175 } 176 ARK_PMD_LOG(NOTICE, "EXT found dll path at %s\n", dllpath); 177 178 /* Open and load the .so */ 179 ark->d_handle = dlopen(dllpath, RTLD_LOCAL | RTLD_LAZY); 180 if (ark->d_handle == NULL) { 181 ARK_PMD_LOG(ERR, "Could not load user extension %s\n", 182 dllpath); 183 return -1; 184 } 185 ARK_PMD_LOG(DEBUG, "SUCCESS: loaded user extension %s\n", 186 dllpath); 187 188 /* Get the entry points */ 189 ark->user_ext.dev_init = 190 (void *(*)(struct rte_eth_dev *, void *, int)) 191 dlsym(ark->d_handle, "dev_init"); 192 ARK_PMD_LOG(DEBUG, "device ext init pointer = %p\n", 193 ark->user_ext.dev_init); 194 ark->user_ext.dev_get_port_count = 195 (int (*)(struct rte_eth_dev *, void *)) 196 dlsym(ark->d_handle, "dev_get_port_count"); 197 ark->user_ext.dev_uninit = 198 (void (*)(struct rte_eth_dev *, void *)) 199 dlsym(ark->d_handle, "dev_uninit"); 200 ark->user_ext.dev_configure = 201 (int (*)(struct rte_eth_dev *, void *)) 202 dlsym(ark->d_handle, "dev_configure"); 203 ark->user_ext.dev_start = 204 (int (*)(struct rte_eth_dev *, void *)) 205 dlsym(ark->d_handle, "dev_start"); 206 ark->user_ext.dev_stop = 207 (void (*)(struct rte_eth_dev *, void *)) 208 dlsym(ark->d_handle, "dev_stop"); 209 ark->user_ext.dev_close = 210 (void (*)(struct rte_eth_dev *, void *)) 211 dlsym(ark->d_handle, "dev_close"); 212 ark->user_ext.link_update = 213 (int (*)(struct rte_eth_dev *, int, void *)) 214 dlsym(ark->d_handle, "link_update"); 215 ark->user_ext.dev_set_link_up = 216 (int (*)(struct rte_eth_dev *, void *)) 217 dlsym(ark->d_handle, "dev_set_link_up"); 218 ark->user_ext.dev_set_link_down = 219 (int (*)(struct rte_eth_dev *, void *)) 220 dlsym(ark->d_handle, "dev_set_link_down"); 221 ark->user_ext.stats_get = 222 (int (*)(struct rte_eth_dev *, struct rte_eth_stats *, 223 void *)) 224 dlsym(ark->d_handle, "stats_get"); 225 ark->user_ext.stats_reset = 226 (void (*)(struct rte_eth_dev *, void *)) 227 dlsym(ark->d_handle, "stats_reset"); 228 ark->user_ext.mac_addr_add = 229 (void (*)(struct rte_eth_dev *, struct rte_ether_addr *, 230 uint32_t, uint32_t, void *)) 231 dlsym(ark->d_handle, "mac_addr_add"); 232 ark->user_ext.mac_addr_remove = 233 (void (*)(struct rte_eth_dev *, uint32_t, void *)) 234 dlsym(ark->d_handle, "mac_addr_remove"); 235 ark->user_ext.mac_addr_set = 236 (void (*)(struct rte_eth_dev *, struct rte_ether_addr *, 237 void *)) 238 dlsym(ark->d_handle, "mac_addr_set"); 239 ark->user_ext.set_mtu = 240 (int (*)(struct rte_eth_dev *, uint16_t, 241 void *)) 242 dlsym(ark->d_handle, "set_mtu"); 243 244 return found; 245 } 246 247 static int 248 eth_ark_dev_init(struct rte_eth_dev *dev) 249 { 250 struct ark_adapter *ark = dev->data->dev_private; 251 struct rte_pci_device *pci_dev; 252 int ret; 253 int port_count = 1; 254 int p; 255 static const struct rte_mbuf_dynfield ark_tx_userdata_dynfield_desc = { 256 .name = RTE_PMD_ARK_TX_USERDATA_DYNFIELD_NAME, 257 .size = sizeof(rte_pmd_ark_tx_userdata_t), 258 .align = __alignof__(rte_pmd_ark_tx_userdata_t), 259 }; 260 static const struct rte_mbuf_dynfield ark_rx_userdata_dynfield_desc = { 261 .name = RTE_PMD_ARK_RX_USERDATA_DYNFIELD_NAME, 262 .size = sizeof(rte_pmd_ark_rx_userdata_t), 263 .align = __alignof__(rte_pmd_ark_rx_userdata_t), 264 }; 265 266 ark->eth_dev = dev; 267 268 ARK_PMD_LOG(DEBUG, "\n"); 269 270 /* Check to see if there is an extension that we need to load */ 271 ret = check_for_ext(ark); 272 if (ret) 273 return ret; 274 275 /* Extra mbuf fields for user data */ 276 if (RTE_PMD_ARK_TX_USERDATA_ENABLE) { 277 rte_pmd_ark_tx_userdata_dynfield_offset = 278 rte_mbuf_dynfield_register(&ark_tx_userdata_dynfield_desc); 279 if (rte_pmd_ark_tx_userdata_dynfield_offset < 0) { 280 ARK_PMD_LOG(ERR, 281 "Failed to register mbuf field for tx userdata\n"); 282 return -rte_errno; 283 } 284 ARK_PMD_LOG(INFO, "Registered TX-meta dynamic field at %d\n", 285 rte_pmd_ark_tx_userdata_dynfield_offset); 286 } 287 if (RTE_PMD_ARK_RX_USERDATA_ENABLE) { 288 rte_pmd_ark_rx_userdata_dynfield_offset = 289 rte_mbuf_dynfield_register(&ark_rx_userdata_dynfield_desc); 290 if (rte_pmd_ark_rx_userdata_dynfield_offset < 0) { 291 ARK_PMD_LOG(ERR, 292 "Failed to register mbuf field for rx userdata\n"); 293 return -rte_errno; 294 } 295 ARK_PMD_LOG(INFO, "Registered RX-meta dynamic field at %d\n", 296 rte_pmd_ark_rx_userdata_dynfield_offset); 297 } 298 299 pci_dev = RTE_ETH_DEV_TO_PCI(dev); 300 rte_eth_copy_pci_info(dev, pci_dev); 301 dev->data->dev_flags |= RTE_ETH_DEV_AUTOFILL_QUEUE_XSTATS; 302 303 /* Use dummy function until setup */ 304 dev->rx_pkt_burst = ð_ark_recv_pkts_noop; 305 dev->tx_pkt_burst = ð_ark_xmit_pkts_noop; 306 307 ark->bar0 = (uint8_t *)pci_dev->mem_resource[0].addr; 308 ark->a_bar = (uint8_t *)pci_dev->mem_resource[2].addr; 309 310 ark->sysctrl.v = (void *)&ark->bar0[ARK_SYSCTRL_BASE]; 311 ark->mpurx.v = (void *)&ark->bar0[ARK_MPU_RX_BASE]; 312 ark->udm.v = (void *)&ark->bar0[ARK_UDM_BASE]; 313 ark->mputx.v = (void *)&ark->bar0[ARK_MPU_TX_BASE]; 314 ark->ddm.v = (void *)&ark->bar0[ARK_DDM_BASE]; 315 ark->cmac.v = (void *)&ark->bar0[ARK_CMAC_BASE]; 316 ark->external.v = (void *)&ark->bar0[ARK_EXTERNAL_BASE]; 317 ark->pktdir.v = (void *)&ark->bar0[ARK_PKTDIR_BASE]; 318 ark->pktgen.v = (void *)&ark->bar0[ARK_PKTGEN_BASE]; 319 ark->pktchkr.v = (void *)&ark->bar0[ARK_PKTCHKR_BASE]; 320 321 ark->rqpacing = 322 (struct ark_rqpace_t *)(ark->bar0 + ARK_RCPACING_BASE); 323 ark->started = 0; 324 325 ARK_PMD_LOG(INFO, "Sys Ctrl Const = 0x%x HW Commit_ID: %08x\n", 326 ark->sysctrl.t32[4], 327 rte_be_to_cpu_32(ark->sysctrl.t32[0x20 / 4])); 328 ARK_PMD_LOG(NOTICE, "Arkville HW Commit_ID: %08x\n", 329 rte_be_to_cpu_32(ark->sysctrl.t32[0x20 / 4])); 330 331 /* If HW sanity test fails, return an error */ 332 if (ark->sysctrl.t32[4] != 0xcafef00d) { 333 ARK_PMD_LOG(ERR, 334 "HW Sanity test has failed, expected constant" 335 " 0x%x, read 0x%x (%s)\n", 336 0xcafef00d, 337 ark->sysctrl.t32[4], __func__); 338 return -1; 339 } 340 if (ark->sysctrl.t32[3] != 0) { 341 if (ark_rqp_lasped(ark->rqpacing)) { 342 ARK_PMD_LOG(ERR, "Arkville Evaluation System - " 343 "Timer has Expired\n"); 344 return -1; 345 } 346 ARK_PMD_LOG(WARNING, "Arkville Evaluation System - " 347 "Timer is Running\n"); 348 } 349 350 ARK_PMD_LOG(DEBUG, 351 "HW Sanity test has PASSED, expected constant" 352 " 0x%x, read 0x%x (%s)\n", 353 0xcafef00d, ark->sysctrl.t32[4], __func__); 354 355 /* We are a single function multi-port device. */ 356 ret = ark_config_device(dev); 357 if (ret) 358 return -1; 359 360 dev->dev_ops = &ark_eth_dev_ops; 361 dev->rx_queue_count = eth_ark_dev_rx_queue_count; 362 363 dev->data->mac_addrs = rte_zmalloc("ark", RTE_ETHER_ADDR_LEN, 0); 364 if (!dev->data->mac_addrs) { 365 ARK_PMD_LOG(ERR, 366 "Failed to allocated memory for storing mac address" 367 ); 368 } 369 370 if (ark->user_ext.dev_init) { 371 ark->user_data[dev->data->port_id] = 372 ark->user_ext.dev_init(dev, ark->a_bar, 0); 373 if (!ark->user_data[dev->data->port_id]) { 374 ARK_PMD_LOG(WARNING, 375 "Failed to initialize PMD extension!" 376 " continuing without it\n"); 377 memset(&ark->user_ext, 0, sizeof(struct ark_user_ext)); 378 dlclose(ark->d_handle); 379 } 380 } 381 382 if (pci_dev->device.devargs) 383 ret = eth_ark_check_args(ark, pci_dev->device.devargs->args); 384 else 385 ARK_PMD_LOG(INFO, "No Device args found\n"); 386 387 if (ret) 388 goto error; 389 /* 390 * We will create additional devices based on the number of requested 391 * ports 392 */ 393 if (ark->user_ext.dev_get_port_count) 394 port_count = 395 ark->user_ext.dev_get_port_count(dev, 396 ark->user_data[dev->data->port_id]); 397 ark->num_ports = port_count; 398 399 for (p = 0; p < port_count; p++) { 400 struct rte_eth_dev *eth_dev; 401 char name[RTE_ETH_NAME_MAX_LEN]; 402 403 snprintf(name, sizeof(name), "arketh%d", 404 dev->data->port_id + p); 405 406 if (p == 0) { 407 /* First port is already allocated by DPDK */ 408 eth_dev = ark->eth_dev; 409 rte_eth_dev_probing_finish(eth_dev); 410 continue; 411 } 412 413 /* reserve an ethdev entry */ 414 eth_dev = rte_eth_dev_allocate(name); 415 if (!eth_dev) { 416 ARK_PMD_LOG(ERR, 417 "Could not allocate eth_dev for port %d\n", 418 p); 419 goto error; 420 } 421 422 eth_dev->device = &pci_dev->device; 423 eth_dev->data->dev_private = ark; 424 eth_dev->dev_ops = ark->eth_dev->dev_ops; 425 eth_dev->tx_pkt_burst = ark->eth_dev->tx_pkt_burst; 426 eth_dev->rx_pkt_burst = ark->eth_dev->rx_pkt_burst; 427 428 rte_eth_copy_pci_info(eth_dev, pci_dev); 429 eth_dev->data->dev_flags |= RTE_ETH_DEV_AUTOFILL_QUEUE_XSTATS; 430 431 eth_dev->data->mac_addrs = rte_zmalloc(name, 432 RTE_ETHER_ADDR_LEN, 0); 433 if (!eth_dev->data->mac_addrs) { 434 ARK_PMD_LOG(ERR, 435 "Memory allocation for MAC failed!" 436 " Exiting.\n"); 437 goto error; 438 } 439 440 if (ark->user_ext.dev_init) { 441 ark->user_data[eth_dev->data->port_id] = 442 ark->user_ext.dev_init(dev, ark->a_bar, p); 443 } 444 445 rte_eth_dev_probing_finish(eth_dev); 446 } 447 448 return ret; 449 450 error: 451 rte_free(dev->data->mac_addrs); 452 dev->data->mac_addrs = NULL; 453 return -1; 454 } 455 456 /* 457 *Initial device configuration when device is opened 458 * setup the DDM, and UDM 459 * Called once per PCIE device 460 */ 461 static int 462 ark_config_device(struct rte_eth_dev *dev) 463 { 464 struct ark_adapter *ark = dev->data->dev_private; 465 uint16_t num_q, i; 466 struct ark_mpu_t *mpu; 467 468 /* 469 * Make sure that the packet director, generator and checker are in a 470 * known state 471 */ 472 ark->start_pg = 0; 473 ark->pg = ark_pktgen_init(ark->pktgen.v, 0, 1); 474 if (ark->pg == NULL) 475 return -1; 476 ark_pktgen_reset(ark->pg); 477 ark->pc = ark_pktchkr_init(ark->pktchkr.v, 0, 1); 478 if (ark->pc == NULL) 479 return -1; 480 ark_pktchkr_stop(ark->pc); 481 ark->pd = ark_pktdir_init(ark->pktdir.v); 482 if (ark->pd == NULL) 483 return -1; 484 485 /* Verify HW */ 486 if (ark_udm_verify(ark->udm.v)) 487 return -1; 488 if (ark_ddm_verify(ark->ddm.v)) 489 return -1; 490 491 /* UDM */ 492 if (ark_udm_reset(ark->udm.v)) { 493 ARK_PMD_LOG(ERR, "Unable to stop and reset UDM\n"); 494 return -1; 495 } 496 /* Keep in reset until the MPU are cleared */ 497 498 /* MPU reset */ 499 mpu = ark->mpurx.v; 500 num_q = ark_api_num_queues(mpu); 501 ark->rx_queues = num_q; 502 for (i = 0; i < num_q; i++) { 503 ark_mpu_reset(mpu); 504 mpu = RTE_PTR_ADD(mpu, ARK_MPU_QOFFSET); 505 } 506 507 ark_udm_stop(ark->udm.v, 0); 508 ark_udm_configure(ark->udm.v, 509 RTE_PKTMBUF_HEADROOM, 510 RTE_MBUF_DEFAULT_DATAROOM, 511 ARK_RX_WRITE_TIME_NS); 512 ark_udm_stats_reset(ark->udm.v); 513 ark_udm_stop(ark->udm.v, 0); 514 515 /* TX -- DDM */ 516 if (ark_ddm_stop(ark->ddm.v, 1)) 517 ARK_PMD_LOG(ERR, "Unable to stop DDM\n"); 518 519 mpu = ark->mputx.v; 520 num_q = ark_api_num_queues(mpu); 521 ark->tx_queues = num_q; 522 for (i = 0; i < num_q; i++) { 523 ark_mpu_reset(mpu); 524 mpu = RTE_PTR_ADD(mpu, ARK_MPU_QOFFSET); 525 } 526 527 ark_ddm_reset(ark->ddm.v); 528 ark_ddm_stats_reset(ark->ddm.v); 529 530 ark_ddm_stop(ark->ddm.v, 0); 531 ark_rqp_stats_reset(ark->rqpacing); 532 533 return 0; 534 } 535 536 static int 537 eth_ark_dev_uninit(struct rte_eth_dev *dev) 538 { 539 struct ark_adapter *ark = dev->data->dev_private; 540 541 if (rte_eal_process_type() != RTE_PROC_PRIMARY) 542 return 0; 543 544 if (ark->user_ext.dev_uninit) 545 ark->user_ext.dev_uninit(dev, 546 ark->user_data[dev->data->port_id]); 547 548 ark_pktgen_uninit(ark->pg); 549 ark_pktchkr_uninit(ark->pc); 550 551 return 0; 552 } 553 554 static int 555 eth_ark_dev_configure(struct rte_eth_dev *dev) 556 { 557 struct ark_adapter *ark = dev->data->dev_private; 558 int ret; 559 560 if (dev->data->dev_conf.rxmode.offloads & DEV_RX_OFFLOAD_TIMESTAMP) { 561 ret = rte_mbuf_dyn_rx_timestamp_register( 562 &ark_timestamp_dynfield_offset, 563 &ark_timestamp_rx_dynflag); 564 if (ret != 0) { 565 ARK_PMD_LOG(ERR, 566 "Failed to register Rx timestamp field/flag\n"); 567 return -rte_errno; 568 } 569 } 570 571 eth_ark_dev_set_link_up(dev); 572 if (ark->user_ext.dev_configure) 573 return ark->user_ext.dev_configure(dev, 574 ark->user_data[dev->data->port_id]); 575 return 0; 576 } 577 578 static void * 579 delay_pg_start(void *arg) 580 { 581 struct ark_adapter *ark = (struct ark_adapter *)arg; 582 583 /* This function is used exclusively for regression testing, We 584 * perform a blind sleep here to ensure that the external test 585 * application has time to setup the test before we generate packets 586 */ 587 usleep(100000); 588 ark_pktgen_run(ark->pg); 589 return NULL; 590 } 591 592 static int 593 eth_ark_dev_start(struct rte_eth_dev *dev) 594 { 595 struct ark_adapter *ark = dev->data->dev_private; 596 int i; 597 598 /* RX Side */ 599 /* start UDM */ 600 ark_udm_start(ark->udm.v); 601 602 for (i = 0; i < dev->data->nb_rx_queues; i++) 603 eth_ark_rx_start_queue(dev, i); 604 605 /* TX Side */ 606 for (i = 0; i < dev->data->nb_tx_queues; i++) 607 eth_ark_tx_queue_start(dev, i); 608 609 /* start DDM */ 610 ark_ddm_start(ark->ddm.v); 611 612 ark->started = 1; 613 /* set xmit and receive function */ 614 dev->rx_pkt_burst = ð_ark_recv_pkts; 615 dev->tx_pkt_burst = ð_ark_xmit_pkts; 616 617 if (ark->start_pg) 618 ark_pktchkr_run(ark->pc); 619 620 if (ark->start_pg && (dev->data->port_id == 0)) { 621 pthread_t thread; 622 623 /* Delay packet generatpr start allow the hardware to be ready 624 * This is only used for sanity checking with internal generator 625 */ 626 if (pthread_create(&thread, NULL, delay_pg_start, ark)) { 627 ARK_PMD_LOG(ERR, "Could not create pktgen " 628 "starter thread\n"); 629 return -1; 630 } 631 } 632 633 if (ark->user_ext.dev_start) 634 ark->user_ext.dev_start(dev, 635 ark->user_data[dev->data->port_id]); 636 637 return 0; 638 } 639 640 static int 641 eth_ark_dev_stop(struct rte_eth_dev *dev) 642 { 643 uint16_t i; 644 int status; 645 struct ark_adapter *ark = dev->data->dev_private; 646 struct ark_mpu_t *mpu; 647 648 if (ark->started == 0) 649 return 0; 650 ark->started = 0; 651 dev->data->dev_started = 0; 652 653 /* Stop the extension first */ 654 if (ark->user_ext.dev_stop) 655 ark->user_ext.dev_stop(dev, 656 ark->user_data[dev->data->port_id]); 657 658 /* Stop the packet generator */ 659 if (ark->start_pg) 660 ark_pktgen_pause(ark->pg); 661 662 dev->rx_pkt_burst = ð_ark_recv_pkts_noop; 663 dev->tx_pkt_burst = ð_ark_xmit_pkts_noop; 664 665 /* STOP TX Side */ 666 for (i = 0; i < dev->data->nb_tx_queues; i++) { 667 status = eth_ark_tx_queue_stop(dev, i); 668 if (status != 0) { 669 uint16_t port = dev->data->port_id; 670 ARK_PMD_LOG(ERR, 671 "tx_queue stop anomaly" 672 " port %u, queue %u\n", 673 port, i); 674 } 675 } 676 677 /* Stop DDM */ 678 /* Wait up to 0.1 second. each stop is up to 1000 * 10 useconds */ 679 for (i = 0; i < 10; i++) { 680 status = ark_ddm_stop(ark->ddm.v, 1); 681 if (status == 0) 682 break; 683 } 684 if (status || i != 0) { 685 ARK_PMD_LOG(ERR, "DDM stop anomaly. status:" 686 " %d iter: %u. (%s)\n", 687 status, 688 i, 689 __func__); 690 ark_ddm_dump(ark->ddm.v, "Stop anomaly"); 691 692 mpu = ark->mputx.v; 693 for (i = 0; i < ark->tx_queues; i++) { 694 ark_mpu_dump(mpu, "DDM failure dump", i); 695 mpu = RTE_PTR_ADD(mpu, ARK_MPU_QOFFSET); 696 } 697 } 698 699 /* STOP RX Side */ 700 /* Stop UDM multiple tries attempted */ 701 for (i = 0; i < 10; i++) { 702 status = ark_udm_stop(ark->udm.v, 1); 703 if (status == 0) 704 break; 705 } 706 if (status || i != 0) { 707 ARK_PMD_LOG(ERR, "UDM stop anomaly. status %d iter: %u. (%s)\n", 708 status, i, __func__); 709 ark_udm_dump(ark->udm.v, "Stop anomaly"); 710 711 mpu = ark->mpurx.v; 712 for (i = 0; i < ark->rx_queues; i++) { 713 ark_mpu_dump(mpu, "UDM Stop anomaly", i); 714 mpu = RTE_PTR_ADD(mpu, ARK_MPU_QOFFSET); 715 } 716 } 717 718 ark_udm_dump_stats(ark->udm.v, "Post stop"); 719 ark_udm_dump_perf(ark->udm.v, "Post stop"); 720 721 for (i = 0; i < dev->data->nb_rx_queues; i++) 722 eth_ark_rx_dump_queue(dev, i, __func__); 723 724 /* Stop the packet checker if it is running */ 725 if (ark->start_pg) { 726 ark_pktchkr_dump_stats(ark->pc); 727 ark_pktchkr_stop(ark->pc); 728 } 729 730 return 0; 731 } 732 733 static int 734 eth_ark_dev_close(struct rte_eth_dev *dev) 735 { 736 struct ark_adapter *ark = dev->data->dev_private; 737 uint16_t i; 738 739 if (rte_eal_process_type() != RTE_PROC_PRIMARY) 740 return 0; 741 742 if (ark->user_ext.dev_close) 743 ark->user_ext.dev_close(dev, 744 ark->user_data[dev->data->port_id]); 745 746 eth_ark_dev_stop(dev); 747 eth_ark_udm_force_close(dev); 748 749 /* 750 * TODO This should only be called once for the device during shutdown 751 */ 752 ark_rqp_dump(ark->rqpacing); 753 754 for (i = 0; i < dev->data->nb_tx_queues; i++) { 755 eth_ark_tx_queue_release(dev->data->tx_queues[i]); 756 dev->data->tx_queues[i] = 0; 757 } 758 759 for (i = 0; i < dev->data->nb_rx_queues; i++) { 760 eth_ark_dev_rx_queue_release(dev->data->rx_queues[i]); 761 dev->data->rx_queues[i] = 0; 762 } 763 764 return 0; 765 } 766 767 static int 768 eth_ark_dev_info_get(struct rte_eth_dev *dev, 769 struct rte_eth_dev_info *dev_info) 770 { 771 struct ark_adapter *ark = dev->data->dev_private; 772 struct ark_mpu_t *tx_mpu = RTE_PTR_ADD(ark->bar0, ARK_MPU_TX_BASE); 773 struct ark_mpu_t *rx_mpu = RTE_PTR_ADD(ark->bar0, ARK_MPU_RX_BASE); 774 uint16_t ports = ark->num_ports; 775 776 dev_info->max_rx_pktlen = ARK_RX_MAX_PKT_LEN; 777 dev_info->min_rx_bufsize = ARK_RX_MIN_BUFSIZE; 778 779 dev_info->max_rx_queues = ark_api_num_queues_per_port(rx_mpu, ports); 780 dev_info->max_tx_queues = ark_api_num_queues_per_port(tx_mpu, ports); 781 782 dev_info->rx_desc_lim = (struct rte_eth_desc_lim) { 783 .nb_max = ARK_RX_MAX_QUEUE, 784 .nb_min = ARK_RX_MIN_QUEUE, 785 .nb_align = ARK_RX_MIN_QUEUE}; /* power of 2 */ 786 787 dev_info->tx_desc_lim = (struct rte_eth_desc_lim) { 788 .nb_max = ARK_TX_MAX_QUEUE, 789 .nb_min = ARK_TX_MIN_QUEUE, 790 .nb_align = ARK_TX_MIN_QUEUE}; /* power of 2 */ 791 792 /* ARK PMD supports all line rates, how do we indicate that here ?? */ 793 dev_info->speed_capa = (ETH_LINK_SPEED_1G | 794 ETH_LINK_SPEED_10G | 795 ETH_LINK_SPEED_25G | 796 ETH_LINK_SPEED_40G | 797 ETH_LINK_SPEED_50G | 798 ETH_LINK_SPEED_100G); 799 800 dev_info->rx_offload_capa = DEV_RX_OFFLOAD_TIMESTAMP; 801 802 return 0; 803 } 804 805 static int 806 eth_ark_dev_link_update(struct rte_eth_dev *dev, int wait_to_complete) 807 { 808 ARK_PMD_LOG(DEBUG, "link status = %d\n", 809 dev->data->dev_link.link_status); 810 struct ark_adapter *ark = dev->data->dev_private; 811 812 if (ark->user_ext.link_update) { 813 return ark->user_ext.link_update 814 (dev, wait_to_complete, 815 ark->user_data[dev->data->port_id]); 816 } 817 return 0; 818 } 819 820 static int 821 eth_ark_dev_set_link_up(struct rte_eth_dev *dev) 822 { 823 dev->data->dev_link.link_status = 1; 824 struct ark_adapter *ark = dev->data->dev_private; 825 826 if (ark->user_ext.dev_set_link_up) 827 return ark->user_ext.dev_set_link_up(dev, 828 ark->user_data[dev->data->port_id]); 829 return 0; 830 } 831 832 static int 833 eth_ark_dev_set_link_down(struct rte_eth_dev *dev) 834 { 835 dev->data->dev_link.link_status = 0; 836 struct ark_adapter *ark = dev->data->dev_private; 837 838 if (ark->user_ext.dev_set_link_down) 839 return ark->user_ext.dev_set_link_down(dev, 840 ark->user_data[dev->data->port_id]); 841 return 0; 842 } 843 844 static int 845 eth_ark_dev_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats) 846 { 847 uint16_t i; 848 struct ark_adapter *ark = dev->data->dev_private; 849 850 stats->ipackets = 0; 851 stats->ibytes = 0; 852 stats->opackets = 0; 853 stats->obytes = 0; 854 stats->imissed = 0; 855 stats->oerrors = 0; 856 857 for (i = 0; i < dev->data->nb_tx_queues; i++) 858 eth_tx_queue_stats_get(dev->data->tx_queues[i], stats); 859 for (i = 0; i < dev->data->nb_rx_queues; i++) 860 eth_rx_queue_stats_get(dev->data->rx_queues[i], stats); 861 if (ark->user_ext.stats_get) 862 return ark->user_ext.stats_get(dev, stats, 863 ark->user_data[dev->data->port_id]); 864 return 0; 865 } 866 867 static int 868 eth_ark_dev_stats_reset(struct rte_eth_dev *dev) 869 { 870 uint16_t i; 871 struct ark_adapter *ark = dev->data->dev_private; 872 873 for (i = 0; i < dev->data->nb_tx_queues; i++) 874 eth_tx_queue_stats_reset(dev->data->tx_queues[i]); 875 for (i = 0; i < dev->data->nb_rx_queues; i++) 876 eth_rx_queue_stats_reset(dev->data->rx_queues[i]); 877 if (ark->user_ext.stats_reset) 878 ark->user_ext.stats_reset(dev, 879 ark->user_data[dev->data->port_id]); 880 881 return 0; 882 } 883 884 static int 885 eth_ark_macaddr_add(struct rte_eth_dev *dev, 886 struct rte_ether_addr *mac_addr, 887 uint32_t index, 888 uint32_t pool) 889 { 890 struct ark_adapter *ark = dev->data->dev_private; 891 892 if (ark->user_ext.mac_addr_add) { 893 ark->user_ext.mac_addr_add(dev, 894 mac_addr, 895 index, 896 pool, 897 ark->user_data[dev->data->port_id]); 898 return 0; 899 } 900 return -ENOTSUP; 901 } 902 903 static void 904 eth_ark_macaddr_remove(struct rte_eth_dev *dev, uint32_t index) 905 { 906 struct ark_adapter *ark = dev->data->dev_private; 907 908 if (ark->user_ext.mac_addr_remove) 909 ark->user_ext.mac_addr_remove(dev, index, 910 ark->user_data[dev->data->port_id]); 911 } 912 913 static int 914 eth_ark_set_default_mac_addr(struct rte_eth_dev *dev, 915 struct rte_ether_addr *mac_addr) 916 { 917 struct ark_adapter *ark = dev->data->dev_private; 918 919 if (ark->user_ext.mac_addr_set) { 920 ark->user_ext.mac_addr_set(dev, mac_addr, 921 ark->user_data[dev->data->port_id]); 922 return 0; 923 } 924 return -ENOTSUP; 925 } 926 927 static int 928 eth_ark_set_mtu(struct rte_eth_dev *dev, uint16_t size) 929 { 930 struct ark_adapter *ark = dev->data->dev_private; 931 932 if (ark->user_ext.set_mtu) 933 return ark->user_ext.set_mtu(dev, size, 934 ark->user_data[dev->data->port_id]); 935 936 return -ENOTSUP; 937 } 938 939 static inline int 940 process_pktdir_arg(const char *key, const char *value, 941 void *extra_args) 942 { 943 ARK_PMD_LOG(DEBUG, "key = %s, value = %s\n", 944 key, value); 945 struct ark_adapter *ark = 946 (struct ark_adapter *)extra_args; 947 948 ark->pkt_dir_v = strtol(value, NULL, 16); 949 ARK_PMD_LOG(DEBUG, "pkt_dir_v = 0x%x\n", ark->pkt_dir_v); 950 return 0; 951 } 952 953 static inline int 954 process_file_args(const char *key, const char *value, void *extra_args) 955 { 956 ARK_PMD_LOG(DEBUG, "key = %s, value = %s\n", 957 key, value); 958 char *args = (char *)extra_args; 959 960 /* Open the configuration file */ 961 FILE *file = fopen(value, "r"); 962 char line[ARK_MAX_ARG_LEN]; 963 int size = 0; 964 int first = 1; 965 966 if (file == NULL) { 967 ARK_PMD_LOG(ERR, "Unable to open " 968 "config file %s\n", value); 969 return -1; 970 } 971 972 while (fgets(line, sizeof(line), file)) { 973 size += strlen(line); 974 if (size >= ARK_MAX_ARG_LEN) { 975 ARK_PMD_LOG(ERR, "Unable to parse file %s args, " 976 "parameter list is too long\n", value); 977 fclose(file); 978 return -1; 979 } 980 if (first) { 981 strncpy(args, line, ARK_MAX_ARG_LEN); 982 first = 0; 983 } else { 984 strncat(args, line, ARK_MAX_ARG_LEN); 985 } 986 } 987 ARK_PMD_LOG(DEBUG, "file = %s\n", args); 988 fclose(file); 989 return 0; 990 } 991 992 static int 993 eth_ark_check_args(struct ark_adapter *ark, const char *params) 994 { 995 struct rte_kvargs *kvlist; 996 unsigned int k_idx; 997 struct rte_kvargs_pair *pair = NULL; 998 int ret = -1; 999 1000 kvlist = rte_kvargs_parse(params, valid_arguments); 1001 if (kvlist == NULL) 1002 return 0; 1003 1004 ark->pkt_gen_args[0] = 0; 1005 ark->pkt_chkr_args[0] = 0; 1006 1007 for (k_idx = 0; k_idx < kvlist->count; k_idx++) { 1008 pair = &kvlist->pairs[k_idx]; 1009 ARK_PMD_LOG(DEBUG, "**** Arg passed to PMD = %s:%s\n", 1010 pair->key, 1011 pair->value); 1012 } 1013 1014 if (rte_kvargs_process(kvlist, 1015 ARK_PKTDIR_ARG, 1016 &process_pktdir_arg, 1017 ark) != 0) { 1018 ARK_PMD_LOG(ERR, "Unable to parse arg %s\n", ARK_PKTDIR_ARG); 1019 goto free_kvlist; 1020 } 1021 1022 if (rte_kvargs_process(kvlist, 1023 ARK_PKTGEN_ARG, 1024 &process_file_args, 1025 ark->pkt_gen_args) != 0) { 1026 ARK_PMD_LOG(ERR, "Unable to parse arg %s\n", ARK_PKTGEN_ARG); 1027 goto free_kvlist; 1028 } 1029 1030 if (rte_kvargs_process(kvlist, 1031 ARK_PKTCHKR_ARG, 1032 &process_file_args, 1033 ark->pkt_chkr_args) != 0) { 1034 ARK_PMD_LOG(ERR, "Unable to parse arg %s\n", ARK_PKTCHKR_ARG); 1035 goto free_kvlist; 1036 } 1037 1038 ARK_PMD_LOG(INFO, "packet director set to 0x%x\n", ark->pkt_dir_v); 1039 /* Setup the packet director */ 1040 ark_pktdir_setup(ark->pd, ark->pkt_dir_v); 1041 1042 /* Setup the packet generator */ 1043 if (ark->pkt_gen_args[0]) { 1044 ARK_PMD_LOG(DEBUG, "Setting up the packet generator\n"); 1045 ark_pktgen_parse(ark->pkt_gen_args); 1046 ark_pktgen_reset(ark->pg); 1047 ark_pktgen_setup(ark->pg); 1048 ark->start_pg = 1; 1049 } 1050 1051 /* Setup the packet checker */ 1052 if (ark->pkt_chkr_args[0]) { 1053 ark_pktchkr_parse(ark->pkt_chkr_args); 1054 ark_pktchkr_setup(ark->pc); 1055 } 1056 1057 ret = 0; 1058 1059 free_kvlist: 1060 rte_kvargs_free(kvlist); 1061 1062 return ret; 1063 } 1064 1065 RTE_PMD_REGISTER_PCI(net_ark, rte_ark_pmd); 1066 RTE_PMD_REGISTER_KMOD_DEP(net_ark, "* igb_uio | uio_pci_generic "); 1067 RTE_PMD_REGISTER_PCI_TABLE(net_ark, pci_id_ark_map); 1068 RTE_PMD_REGISTER_PARAM_STRING(net_ark, 1069 ARK_PKTGEN_ARG "=<filename> " 1070 ARK_PKTCHKR_ARG "=<filename> " 1071 ARK_PKTDIR_ARG "=<bitmap>"); 1072 RTE_LOG_REGISTER(ark_logtype, pmd.net.ark, NOTICE); 1073