1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright 2008-2017 Cisco Systems, Inc. All rights reserved. 3 * Copyright 2007 Nuova Systems, Inc. All rights reserved. 4 */ 5 6 #include "enic.h" 7 #include "vnic_dev.h" 8 #include "vnic_resource.h" 9 #include "vnic_devcmd.h" 10 #include "vnic_nic.h" 11 #include "vnic_stats.h" 12 13 #define VNIC_MAX_RES_HDR_SIZE \ 14 (sizeof(struct vnic_resource_header) + \ 15 sizeof(struct vnic_resource) * RES_TYPE_MAX) 16 #define VNIC_RES_STRIDE 128 17 18 #define VNIC_MAX_FLOW_COUNTERS 2048 19 20 void *vnic_dev_priv(struct vnic_dev *vdev) 21 { 22 return vdev->priv; 23 } 24 25 void vnic_register_cbacks(struct vnic_dev *vdev, 26 void *(*alloc_consistent)(void *priv, size_t size, 27 bus_addr_t *dma_handle, struct iflib_dma_info *res,u8 *name), 28 void (*free_consistent)(void *priv, 29 size_t size, void *vaddr, 30 bus_addr_t dma_handle,struct iflib_dma_info *res)) 31 { 32 vdev->alloc_consistent = alloc_consistent; 33 vdev->free_consistent = free_consistent; 34 } 35 36 static int vnic_dev_discover_res(struct vnic_dev *vdev, 37 struct vnic_dev_bar *bar, unsigned int num_bars) 38 { 39 struct enic_softc *softc = vdev->softc; 40 struct vnic_resource_header __iomem *rh; 41 struct mgmt_barmap_hdr __iomem *mrh; 42 struct vnic_resource __iomem *r; 43 int r_offset; 44 u8 type; 45 46 if (num_bars == 0) 47 return -EINVAL; 48 49 rh = malloc(sizeof(*rh), M_DEVBUF, M_NOWAIT | M_ZERO); 50 mrh = malloc(sizeof(*mrh), M_DEVBUF, M_NOWAIT | M_ZERO); 51 if (!rh) { 52 pr_err("vNIC BAR0 res hdr not mem-mapped\n"); 53 free(rh, M_DEVBUF); 54 free(mrh, M_DEVBUF); 55 return -EINVAL; 56 } 57 58 /* Check for mgmt vnic in addition to normal vnic */ 59 ENIC_BUS_READ_REGION_4(softc, mem, 0, (void *)rh, sizeof(*rh) / 4); 60 ENIC_BUS_READ_REGION_4(softc, mem, 0, (void *)mrh, sizeof(*mrh) / 4); 61 if ((rh->magic != VNIC_RES_MAGIC) || 62 (rh->version != VNIC_RES_VERSION)) { 63 if ((mrh->magic != MGMTVNIC_MAGIC) || 64 mrh->version != MGMTVNIC_VERSION) { 65 pr_err("vNIC BAR0 res magic/version error " \ 66 "exp (%lx/%lx) or (%lx/%lx), curr (%x/%x)\n", 67 VNIC_RES_MAGIC, VNIC_RES_VERSION, 68 MGMTVNIC_MAGIC, MGMTVNIC_VERSION, 69 rh->magic, rh->version); 70 free(rh, M_DEVBUF); 71 free(mrh, M_DEVBUF); 72 return -EINVAL; 73 } 74 } 75 76 if (mrh->magic == MGMTVNIC_MAGIC) 77 r_offset = sizeof(*mrh); 78 else 79 r_offset = sizeof(*rh); 80 81 r = malloc(sizeof(*r), M_DEVBUF, M_NOWAIT | M_ZERO); 82 ENIC_BUS_READ_REGION_4(softc, mem, r_offset, (void *)r, sizeof(*r) / 4); 83 while ((type = r->type) != RES_TYPE_EOL) { 84 u8 bar_num = r->bar; 85 u32 bar_offset =r->bar_offset; 86 u32 count = r->count; 87 88 r_offset += sizeof(*r); 89 90 if (bar_num >= num_bars) 91 continue; 92 93 switch (type) { 94 case RES_TYPE_WQ: 95 case RES_TYPE_RQ: 96 case RES_TYPE_CQ: 97 case RES_TYPE_INTR_CTRL: 98 case RES_TYPE_INTR_PBA_LEGACY: 99 case RES_TYPE_DEVCMD: 100 break; 101 default: 102 ENIC_BUS_READ_REGION_4(softc, mem, r_offset, (void *)r, sizeof(*r) / 4); 103 continue; 104 } 105 106 vdev->res[type].count = count; 107 bcopy(&softc->mem, &vdev->res[type].bar, sizeof(softc->mem)); 108 vdev->res[type].bar.offset = bar_offset; 109 ENIC_BUS_READ_REGION_4(softc, mem, r_offset, (void *)r, sizeof(*r) / 4); 110 } 111 112 free(rh, M_DEVBUF); 113 free(mrh, M_DEVBUF); 114 free(r, M_DEVBUF); 115 return 0; 116 } 117 118 unsigned int vnic_dev_get_res_count(struct vnic_dev *vdev, 119 enum vnic_res_type type) 120 { 121 return vdev->res[type].count; 122 } 123 124 void __iomem *vnic_dev_get_res(struct vnic_dev *vdev, enum vnic_res_type type, 125 unsigned int index) 126 { 127 struct vnic_res *res; 128 129 if (!vdev->res[type].bar.tag) 130 return NULL; 131 132 res = malloc(sizeof(*res), M_DEVBUF, M_NOWAIT | M_ZERO); 133 bcopy(&vdev->res[type], res, sizeof(*res)); 134 135 switch (type) { 136 case RES_TYPE_WQ: 137 case RES_TYPE_RQ: 138 case RES_TYPE_CQ: 139 case RES_TYPE_INTR_CTRL: 140 res->bar.offset += 141 index * VNIC_RES_STRIDE; 142 default: 143 res->bar.offset += 0; 144 } 145 146 return res; 147 } 148 149 unsigned int vnic_dev_desc_ring_size(struct vnic_dev_ring *ring, 150 unsigned int desc_count, unsigned int desc_size) 151 { 152 /* The base address of the desc rings must be 512 byte aligned. 153 * Descriptor count is aligned to groups of 32 descriptors. A 154 * count of 0 means the maximum 4096 descriptors. Descriptor 155 * size is aligned to 16 bytes. 156 */ 157 158 unsigned int count_align = 32; 159 unsigned int desc_align = 16; 160 161 ring->base_align = 512; 162 163 if (desc_count == 0) 164 desc_count = 4096; 165 166 ring->desc_count = VNIC_ALIGN(desc_count, count_align); 167 168 ring->desc_size = VNIC_ALIGN(desc_size, desc_align); 169 170 ring->size = ring->desc_count * ring->desc_size; 171 ring->size_unaligned = ring->size + ring->base_align; 172 173 return ring->size_unaligned; 174 } 175 176 void vnic_dev_clear_desc_ring(struct vnic_dev_ring *ring) 177 { 178 memset(ring->descs, 0, ring->size); 179 } 180 181 static int _vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd, 182 int wait) 183 { 184 struct vnic_res __iomem *devcmd = vdev->devcmd; 185 int delay; 186 u32 status; 187 int err; 188 189 status = ENIC_BUS_READ_4(devcmd, DEVCMD_STATUS); 190 if (status == 0xFFFFFFFF) { 191 /* PCI-e target device is gone */ 192 return -ENODEV; 193 } 194 if (status & STAT_BUSY) { 195 196 pr_err("Busy devcmd %d\n", _CMD_N(cmd)); 197 return -EBUSY; 198 } 199 200 if (_CMD_DIR(cmd) & _CMD_DIR_WRITE) { 201 ENIC_BUS_WRITE_REGION_4(devcmd, DEVCMD_ARGS(0), (void *)&vdev->args[0], VNIC_DEVCMD_NARGS * 2); 202 } 203 204 ENIC_BUS_WRITE_4(devcmd, DEVCMD_CMD, cmd); 205 206 if ((_CMD_FLAGS(cmd) & _CMD_FLAGS_NOWAIT)) { 207 return 0; 208 } 209 210 for (delay = 0; delay < wait; delay++) { 211 212 udelay(100); 213 214 status = ENIC_BUS_READ_4(devcmd, DEVCMD_STATUS); 215 if (status == 0xFFFFFFFF) { 216 /* PCI-e target device is gone */ 217 return -ENODEV; 218 } 219 220 if (!(status & STAT_BUSY)) { 221 if (status & STAT_ERROR) { 222 err = -(int)ENIC_BUS_READ_8(devcmd, DEVCMD_ARGS(0)); 223 224 if (cmd != CMD_CAPABILITY) 225 pr_err("Devcmd %d failed " \ 226 "with error code %d\n", 227 _CMD_N(cmd), err); 228 return err; 229 } 230 231 if (_CMD_DIR(cmd) & _CMD_DIR_READ) { 232 ENIC_BUS_READ_REGION_4(devcmd, bar, DEVCMD_ARGS(0), (void *)&vdev->args[0], VNIC_DEVCMD_NARGS * 2); 233 } 234 235 return 0; 236 } 237 } 238 239 pr_err("Timedout devcmd %d\n", _CMD_N(cmd)); 240 return -ETIMEDOUT; 241 } 242 243 static int vnic_dev_cmd_proxy(struct vnic_dev *vdev, 244 enum vnic_devcmd_cmd proxy_cmd, enum vnic_devcmd_cmd cmd, 245 u64 *args, int nargs, int wait) 246 { 247 u32 status; 248 int err; 249 250 /* 251 * Proxy command consumes 2 arguments. One for proxy index, 252 * the other is for command to be proxied 253 */ 254 if (nargs > VNIC_DEVCMD_NARGS - 2) { 255 pr_err("number of args %d exceeds the maximum\n", nargs); 256 return -EINVAL; 257 } 258 memset(vdev->args, 0, sizeof(vdev->args)); 259 260 vdev->args[0] = vdev->proxy_index; 261 vdev->args[1] = cmd; 262 memcpy(&vdev->args[2], args, nargs * sizeof(args[0])); 263 264 err = _vnic_dev_cmd(vdev, proxy_cmd, wait); 265 if (err) 266 return err; 267 268 status = (u32)vdev->args[0]; 269 if (status & STAT_ERROR) { 270 err = (int)vdev->args[1]; 271 if (err != ERR_ECMDUNKNOWN || 272 cmd != CMD_CAPABILITY) 273 pr_err("Error %d proxy devcmd %d\n", err, _CMD_N(cmd)); 274 return err; 275 } 276 277 memcpy(args, &vdev->args[1], nargs * sizeof(args[0])); 278 279 return 0; 280 } 281 282 static int vnic_dev_cmd_no_proxy(struct vnic_dev *vdev, 283 enum vnic_devcmd_cmd cmd, u64 *args, int nargs, int wait) 284 { 285 int err; 286 287 if (nargs > VNIC_DEVCMD_NARGS) { 288 pr_err("number of args %d exceeds the maximum\n", nargs); 289 return -EINVAL; 290 } 291 memset(vdev->args, 0, sizeof(vdev->args)); 292 memcpy(vdev->args, args, nargs * sizeof(args[0])); 293 294 err = _vnic_dev_cmd(vdev, cmd, wait); 295 296 memcpy(args, vdev->args, nargs * sizeof(args[0])); 297 298 return err; 299 } 300 301 int vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd, 302 u64 *a0, u64 *a1, int wait) 303 { 304 u64 args[2]; 305 int err; 306 307 args[0] = *a0; 308 args[1] = *a1; 309 memset(vdev->args, 0, sizeof(vdev->args)); 310 311 switch (vdev->proxy) { 312 case PROXY_BY_INDEX: 313 err = vnic_dev_cmd_proxy(vdev, CMD_PROXY_BY_INDEX, cmd, 314 args, ARRAY_SIZE(args), wait); 315 break; 316 case PROXY_BY_BDF: 317 err = vnic_dev_cmd_proxy(vdev, CMD_PROXY_BY_BDF, cmd, 318 args, ARRAY_SIZE(args), wait); 319 break; 320 case PROXY_NONE: 321 default: 322 err = vnic_dev_cmd_no_proxy(vdev, cmd, args, 2, wait); 323 break; 324 } 325 326 if (err == 0) { 327 *a0 = args[0]; 328 *a1 = args[1]; 329 } 330 331 return err; 332 } 333 334 int vnic_dev_cmd_args(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd, 335 u64 *args, int nargs, int wait) 336 { 337 switch (vdev->proxy) { 338 case PROXY_BY_INDEX: 339 return vnic_dev_cmd_proxy(vdev, CMD_PROXY_BY_INDEX, cmd, 340 args, nargs, wait); 341 case PROXY_BY_BDF: 342 return vnic_dev_cmd_proxy(vdev, CMD_PROXY_BY_BDF, cmd, 343 args, nargs, wait); 344 case PROXY_NONE: 345 default: 346 return vnic_dev_cmd_no_proxy(vdev, cmd, args, nargs, wait); 347 } 348 } 349 350 static int vnic_dev_advanced_filters_cap(struct vnic_dev *vdev, u64 *args, 351 int nargs) 352 { 353 memset(args, 0, nargs * sizeof(*args)); 354 args[0] = CMD_ADD_ADV_FILTER; 355 args[1] = FILTER_CAP_MODE_V1_FLAG; 356 return vnic_dev_cmd_args(vdev, CMD_CAPABILITY, args, nargs, 1000); 357 } 358 359 int vnic_dev_capable_adv_filters(struct vnic_dev *vdev) 360 { 361 u64 a0 = CMD_ADD_ADV_FILTER, a1 = 0; 362 int wait = 1000; 363 int err; 364 365 err = vnic_dev_cmd(vdev, CMD_CAPABILITY, &a0, &a1, wait); 366 if (err) 367 return 0; 368 return (a1 >= (u32)FILTER_DPDK_1); 369 } 370 371 /* Determine the "best" filtering mode VIC is capaible of. Returns one of 3 372 * value or 0 on error: 373 * FILTER_DPDK_1- advanced filters availabile 374 * FILTER_USNIC_IP_FLAG - advanced filters but with the restriction that 375 * the IP layer must explicitly specified. I.e. cannot have a UDP 376 * filter that matches both IPv4 and IPv6. 377 * FILTER_IPV4_5TUPLE - fallback if either of the 2 above aren't available. 378 * all other filter types are not available. 379 * Retrun true in filter_tags if supported 380 */ 381 int vnic_dev_capable_filter_mode(struct vnic_dev *vdev, u32 *mode, 382 u8 *filter_actions) 383 { 384 u64 args[4]; 385 int err; 386 u32 max_level = 0; 387 388 err = vnic_dev_advanced_filters_cap(vdev, args, 4); 389 390 /* determine supported filter actions */ 391 *filter_actions = FILTER_ACTION_RQ_STEERING_FLAG; /* always available */ 392 if (args[2] == FILTER_CAP_MODE_V1) 393 *filter_actions = args[3]; 394 395 if (err || ((args[0] == 1) && (args[1] == 0))) { 396 /* Adv filter Command not supported or adv filters available but 397 * not enabled. Try the normal filter capability command. 398 */ 399 args[0] = CMD_ADD_FILTER; 400 args[1] = 0; 401 err = vnic_dev_cmd_args(vdev, CMD_CAPABILITY, args, 2, 1000); 402 if (err) 403 return err; 404 max_level = args[1]; 405 goto parse_max_level; 406 } else if (args[2] == FILTER_CAP_MODE_V1) { 407 /* parse filter capability mask in args[1] */ 408 if (args[1] & FILTER_DPDK_1_FLAG) 409 *mode = FILTER_DPDK_1; 410 else if (args[1] & FILTER_USNIC_IP_FLAG) 411 *mode = FILTER_USNIC_IP; 412 else if (args[1] & FILTER_IPV4_5TUPLE_FLAG) 413 *mode = FILTER_IPV4_5TUPLE; 414 return 0; 415 } 416 max_level = args[1]; 417 parse_max_level: 418 if (max_level >= (u32)FILTER_USNIC_IP) 419 *mode = FILTER_USNIC_IP; 420 else 421 *mode = FILTER_IPV4_5TUPLE; 422 return 0; 423 } 424 425 void vnic_dev_capable_udp_rss_weak(struct vnic_dev *vdev, bool *cfg_chk, 426 bool *weak) 427 { 428 u64 a0 = CMD_NIC_CFG, a1 = 0; 429 int wait = 1000; 430 int err; 431 432 *cfg_chk = false; 433 *weak = false; 434 err = vnic_dev_cmd(vdev, CMD_CAPABILITY, &a0, &a1, wait); 435 if (err == 0 && a0 != 0 && a1 != 0) { 436 *cfg_chk = true; 437 *weak = !!((a1 >> 32) & CMD_NIC_CFG_CAPF_UDP_WEAK); 438 } 439 } 440 441 int vnic_dev_capable(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd) 442 { 443 u64 a0 = (u32)cmd, a1 = 0; 444 int wait = 1000; 445 int err; 446 447 err = vnic_dev_cmd(vdev, CMD_CAPABILITY, &a0, &a1, wait); 448 449 return !(err || a0); 450 } 451 452 int vnic_dev_spec(struct vnic_dev *vdev, unsigned int offset, size_t size, 453 void *value) 454 { 455 u64 a0, a1; 456 int wait = 1000; 457 int err; 458 459 a0 = offset; 460 a1 = size; 461 462 err = vnic_dev_cmd(vdev, CMD_DEV_SPEC, &a0, &a1, wait); 463 464 switch (size) { 465 case 1: 466 *(u8 *)value = (u8)a0; 467 break; 468 case 2: 469 *(u16 *)value = (u16)a0; 470 break; 471 case 4: 472 *(u32 *)value = (u32)a0; 473 break; 474 case 8: 475 *(u64 *)value = a0; 476 break; 477 default: 478 BUG(); 479 break; 480 } 481 482 return err; 483 } 484 485 int vnic_dev_stats_clear(struct vnic_dev *vdev) 486 { 487 u64 a0 = 0, a1 = 0; 488 int wait = 1000; 489 490 return vnic_dev_cmd(vdev, CMD_STATS_CLEAR, &a0, &a1, wait); 491 } 492 493 int vnic_dev_stats_dump(struct vnic_dev *vdev, struct vnic_stats **stats) 494 { 495 u64 a0, a1; 496 int wait = 1000; 497 int rc; 498 499 if (!vdev->stats) 500 return -ENOMEM; 501 502 *stats = vdev->stats; 503 a0 = vdev->stats_res.idi_paddr; 504 a1 = sizeof(struct vnic_stats); 505 506 bus_dmamap_sync(vdev->stats_res.idi_tag, 507 vdev->stats_res.idi_map, 508 BUS_DMASYNC_POSTREAD); 509 rc = vnic_dev_cmd(vdev, CMD_STATS_DUMP, &a0, &a1, wait); 510 bus_dmamap_sync(vdev->stats_res.idi_tag, 511 vdev->stats_res.idi_map, 512 BUS_DMASYNC_PREREAD); 513 return (rc); 514 } 515 516 /* 517 * Configure counter DMA 518 */ 519 int vnic_dev_counter_dma_cfg(struct vnic_dev *vdev, u32 period, 520 u32 num_counters) 521 { 522 u64 args[3]; 523 int wait = 1000; 524 int err; 525 526 if (num_counters > VNIC_MAX_FLOW_COUNTERS) 527 return -ENOMEM; 528 if (period > 0 && (period < VNIC_COUNTER_DMA_MIN_PERIOD || 529 num_counters == 0)) 530 return -EINVAL; 531 532 args[0] = num_counters; 533 args[1] = vdev->flow_counters_res.idi_paddr; 534 args[2] = period; 535 bus_dmamap_sync(vdev->flow_counters_res.idi_tag, 536 vdev->flow_counters_res.idi_map, 537 BUS_DMASYNC_POSTREAD); 538 err = vnic_dev_cmd_args(vdev, CMD_COUNTER_DMA_CONFIG, args, 3, wait); 539 bus_dmamap_sync(vdev->flow_counters_res.idi_tag, 540 vdev->flow_counters_res.idi_map, 541 BUS_DMASYNC_PREREAD); 542 543 /* record if DMAs need to be stopped on close */ 544 if (!err) 545 vdev->flow_counters_dma_active = (num_counters != 0 && 546 period != 0); 547 548 return err; 549 } 550 551 int vnic_dev_close(struct vnic_dev *vdev) 552 { 553 u64 a0 = 0, a1 = 0; 554 int wait = 1000; 555 556 return vnic_dev_cmd(vdev, CMD_CLOSE, &a0, &a1, wait); 557 } 558 559 int vnic_dev_enable_wait(struct vnic_dev *vdev) 560 { 561 u64 a0 = 0, a1 = 0; 562 int wait = 1000; 563 564 if (vnic_dev_capable(vdev, CMD_ENABLE_WAIT)) 565 return vnic_dev_cmd(vdev, CMD_ENABLE_WAIT, &a0, &a1, wait); 566 else 567 return vnic_dev_cmd(vdev, CMD_ENABLE, &a0, &a1, wait); 568 } 569 570 int vnic_dev_disable(struct vnic_dev *vdev) 571 { 572 u64 a0 = 0, a1 = 0; 573 int wait = 1000; 574 575 return vnic_dev_cmd(vdev, CMD_DISABLE, &a0, &a1, wait); 576 } 577 578 int vnic_dev_open(struct vnic_dev *vdev, int arg) 579 { 580 u64 a0 = (u32)arg, a1 = 0; 581 int wait = 1000; 582 583 return vnic_dev_cmd(vdev, CMD_OPEN, &a0, &a1, wait); 584 } 585 586 int vnic_dev_open_done(struct vnic_dev *vdev, int *done) 587 { 588 u64 a0 = 0, a1 = 0; 589 int wait = 1000; 590 int err; 591 592 *done = 0; 593 594 err = vnic_dev_cmd(vdev, CMD_OPEN_STATUS, &a0, &a1, wait); 595 if (err) 596 return err; 597 598 *done = (a0 == 0); 599 600 return 0; 601 } 602 603 int vnic_dev_get_mac_addr(struct vnic_dev *vdev, u8 *mac_addr) 604 { 605 u64 a0 = 0, a1 = 0; 606 int wait = 1000; 607 int err, i; 608 609 for (i = 0; i < ETH_ALEN; i++) 610 mac_addr[i] = 0; 611 612 err = vnic_dev_cmd(vdev, CMD_GET_MAC_ADDR, &a0, &a1, wait); 613 if (err) 614 return err; 615 616 for (i = 0; i < ETH_ALEN; i++) 617 mac_addr[i] = ((u8 *)&a0)[i]; 618 619 return 0; 620 } 621 622 int vnic_dev_packet_filter(struct vnic_dev *vdev, int directed, int multicast, 623 int broadcast, int promisc, int allmulti) 624 { 625 u64 a0, a1 = 0; 626 int wait = 1000; 627 int err; 628 629 a0 = (directed ? CMD_PFILTER_DIRECTED : 0) | 630 (multicast ? CMD_PFILTER_MULTICAST : 0) | 631 (broadcast ? CMD_PFILTER_BROADCAST : 0) | 632 (promisc ? CMD_PFILTER_PROMISCUOUS : 0) | 633 (allmulti ? CMD_PFILTER_ALL_MULTICAST : 0); 634 635 err = vnic_dev_cmd(vdev, CMD_PACKET_FILTER, &a0, &a1, wait); 636 if (err) 637 pr_err("Can't set packet filter\n"); 638 639 return err; 640 } 641 642 int vnic_dev_add_addr(struct vnic_dev *vdev, u8 *addr) 643 { 644 u64 a0 = 0, a1 = 0; 645 int wait = 1000; 646 int err; 647 int i; 648 649 for (i = 0; i < ETH_ALEN; i++) 650 ((u8 *)&a0)[i] = addr[i]; 651 652 err = vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a0, &a1, wait); 653 if (err) 654 pr_err("Can't add addr [%02x:%02x:%02x:%02x:%02x:%02x], %d\n", 655 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], 656 err); 657 658 return err; 659 } 660 661 int vnic_dev_del_addr(struct vnic_dev *vdev, u8 *addr) 662 { 663 u64 a0 = 0, a1 = 0; 664 int wait = 1000; 665 int err; 666 int i; 667 668 for (i = 0; i < ETH_ALEN; i++) 669 ((u8 *)&a0)[i] = addr[i]; 670 671 err = vnic_dev_cmd(vdev, CMD_ADDR_DEL, &a0, &a1, wait); 672 if (err) 673 pr_err("Can't del addr [%02x:%02x:%02x:%02x:%02x:%02x], %d\n", 674 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], 675 err); 676 677 return err; 678 } 679 680 int vnic_dev_set_ig_vlan_rewrite_mode(struct vnic_dev *vdev, 681 u8 ig_vlan_rewrite_mode) 682 { 683 u64 a0 = ig_vlan_rewrite_mode, a1 = 0; 684 int wait = 1000; 685 686 if (vnic_dev_capable(vdev, CMD_IG_VLAN_REWRITE_MODE)) 687 return vnic_dev_cmd(vdev, CMD_IG_VLAN_REWRITE_MODE, 688 &a0, &a1, wait); 689 else 690 return 0; 691 } 692 693 void vnic_dev_set_reset_flag(struct vnic_dev *vdev, int state) 694 { 695 vdev->in_reset = state; 696 } 697 698 static inline int vnic_dev_in_reset(struct vnic_dev *vdev) 699 { 700 return vdev->in_reset; 701 } 702 703 int vnic_dev_notify_setcmd(struct vnic_dev *vdev, 704 void *notify_addr, bus_addr_t notify_pa, u16 intr) 705 { 706 u64 a0, a1; 707 int wait = 1000; 708 int r; 709 710 bus_dmamap_sync(vdev->notify_res.idi_tag, 711 vdev->notify_res.idi_map, 712 BUS_DMASYNC_PREWRITE); 713 memset(notify_addr, 0, sizeof(struct vnic_devcmd_notify)); 714 bus_dmamap_sync(vdev->notify_res.idi_tag, 715 vdev->notify_res.idi_map, 716 BUS_DMASYNC_POSTWRITE); 717 if (!vnic_dev_in_reset(vdev)) { 718 vdev->notify = notify_addr; 719 vdev->notify_pa = notify_pa; 720 } 721 722 a0 = (u64)notify_pa; 723 a1 = ((u64)intr << 32) & 0x0000ffff00000000ULL; 724 a1 += sizeof(struct vnic_devcmd_notify); 725 726 r = vnic_dev_cmd(vdev, CMD_NOTIFY, &a0, &a1, wait); 727 if (!vnic_dev_in_reset(vdev)) 728 vdev->notify_sz = (r == 0) ? (u32)a1 : 0; 729 730 return r; 731 } 732 733 int vnic_dev_notify_set(struct vnic_dev *vdev, u16 intr) 734 { 735 void *notify_addr = NULL; 736 bus_addr_t notify_pa = 0; 737 char name[NAME_MAX]; 738 static u32 instance; 739 740 if (vdev->notify || vdev->notify_pa) { 741 return vnic_dev_notify_setcmd(vdev, vdev->notify, 742 vdev->notify_pa, intr); 743 } 744 if (!vnic_dev_in_reset(vdev)) { 745 snprintf((char *)name, sizeof(name), 746 "vnic_notify-%u", instance++); 747 iflib_dma_alloc(vdev->softc->ctx, 748 sizeof(struct vnic_devcmd_notify), 749 &vdev->notify_res, BUS_DMA_NOWAIT); 750 notify_pa = vdev->notify_res.idi_paddr; 751 notify_addr = vdev->notify_res.idi_vaddr; 752 } 753 754 return vnic_dev_notify_setcmd(vdev, notify_addr, notify_pa, intr); 755 } 756 757 int vnic_dev_notify_unsetcmd(struct vnic_dev *vdev) 758 { 759 u64 a0, a1; 760 int wait = 1000; 761 int err; 762 763 a0 = 0; /* paddr = 0 to unset notify buffer */ 764 a1 = 0x0000ffff00000000ULL; /* intr num = -1 to unreg for intr */ 765 a1 += sizeof(struct vnic_devcmd_notify); 766 767 err = vnic_dev_cmd(vdev, CMD_NOTIFY, &a0, &a1, wait); 768 if (!vnic_dev_in_reset(vdev)) { 769 vdev->notify = NULL; 770 vdev->notify_pa = 0; 771 vdev->notify_sz = 0; 772 } 773 774 return err; 775 } 776 777 int vnic_dev_notify_unset(struct vnic_dev *vdev) 778 { 779 if (vdev->notify && !vnic_dev_in_reset(vdev)) { 780 iflib_dma_free(&vdev->notify_res); 781 } 782 783 return vnic_dev_notify_unsetcmd(vdev); 784 } 785 786 static int vnic_dev_notify_ready(struct vnic_dev *vdev) 787 { 788 u32 *words; 789 unsigned int nwords = vdev->notify_sz / 4; 790 unsigned int i; 791 u32 csum; 792 793 if (!vdev->notify || !vdev->notify_sz) 794 return 0; 795 796 do { 797 csum = 0; 798 bus_dmamap_sync(vdev->notify_res.idi_tag, 799 vdev->notify_res.idi_map, 800 BUS_DMASYNC_PREREAD); 801 memcpy(&vdev->notify_copy, vdev->notify, vdev->notify_sz); 802 bus_dmamap_sync(vdev->notify_res.idi_tag, 803 vdev->notify_res.idi_map, 804 BUS_DMASYNC_POSTREAD); 805 words = (u32 *)&vdev->notify_copy; 806 for (i = 1; i < nwords; i++) 807 csum += words[i]; 808 } while (csum != words[0]); 809 810 return 1; 811 } 812 813 int vnic_dev_init(struct vnic_dev *vdev, int arg) 814 { 815 u64 a0 = (u32)arg, a1 = 0; 816 int wait = 1000; 817 int r = 0; 818 819 if (vnic_dev_capable(vdev, CMD_INIT)) 820 r = vnic_dev_cmd(vdev, CMD_INIT, &a0, &a1, wait); 821 else { 822 vnic_dev_cmd(vdev, CMD_INIT_v1, &a0, &a1, wait); 823 if (a0 & CMD_INITF_DEFAULT_MAC) { 824 /* Emulate these for old CMD_INIT_v1 which 825 * didn't pass a0 so no CMD_INITF_*. 826 */ 827 vnic_dev_cmd(vdev, CMD_GET_MAC_ADDR, &a0, &a1, wait); 828 vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a0, &a1, wait); 829 } 830 } 831 return r; 832 } 833 834 void vnic_dev_intr_coal_timer_info_default(struct vnic_dev *vdev) 835 { 836 /* Default: hardware intr coal timer is in units of 1.5 usecs */ 837 vdev->intr_coal_timer_info.mul = 2; 838 vdev->intr_coal_timer_info.div = 3; 839 vdev->intr_coal_timer_info.max_usec = 840 vnic_dev_intr_coal_timer_hw_to_usec(vdev, 0xffff); 841 } 842 843 int vnic_dev_link_status(struct vnic_dev *vdev) 844 { 845 if (!vnic_dev_notify_ready(vdev)) 846 return 0; 847 848 return vdev->notify_copy.link_state; 849 } 850 851 u32 vnic_dev_port_speed(struct vnic_dev *vdev) 852 { 853 if (!vnic_dev_notify_ready(vdev)) 854 return 0; 855 856 return vdev->notify_copy.port_speed; 857 } 858 859 u32 vnic_dev_intr_coal_timer_usec_to_hw(struct vnic_dev *vdev, u32 usec) 860 { 861 return (usec * vdev->intr_coal_timer_info.mul) / 862 vdev->intr_coal_timer_info.div; 863 } 864 865 u32 vnic_dev_intr_coal_timer_hw_to_usec(struct vnic_dev *vdev, u32 hw_cycles) 866 { 867 return (hw_cycles * vdev->intr_coal_timer_info.div) / 868 vdev->intr_coal_timer_info.mul; 869 } 870 871 u32 vnic_dev_get_intr_coal_timer_max(struct vnic_dev *vdev) 872 { 873 return vdev->intr_coal_timer_info.max_usec; 874 } 875 876 u32 vnic_dev_mtu(struct vnic_dev *vdev) 877 { 878 if (!vnic_dev_notify_ready(vdev)) 879 return 0; 880 881 return vdev->notify_copy.mtu; 882 } 883 884 void vnic_dev_set_intr_mode(struct vnic_dev *vdev, 885 enum vnic_dev_intr_mode intr_mode) 886 { 887 vdev->intr_mode = intr_mode; 888 } 889 890 enum vnic_dev_intr_mode vnic_dev_get_intr_mode( 891 struct vnic_dev *vdev) 892 { 893 return vdev->intr_mode; 894 } 895 896 897 int vnic_dev_alloc_stats_mem(struct vnic_dev *vdev) 898 { 899 char name[NAME_MAX]; 900 static u32 instance; 901 struct enic_softc *softc; 902 903 softc = vdev->softc; 904 905 snprintf((char *)name, sizeof(name), "vnic_stats-%u", instance++); 906 iflib_dma_alloc(softc->ctx, sizeof(struct vnic_stats), &vdev->stats_res, 0); 907 vdev->stats = (struct vnic_stats *)vdev->stats_res.idi_vaddr; 908 return vdev->stats == NULL ? -ENOMEM : 0; 909 } 910 911 /* 912 * Initialize for up to VNIC_MAX_FLOW_COUNTERS 913 */ 914 int vnic_dev_alloc_counter_mem(struct vnic_dev *vdev) 915 { 916 char name[NAME_MAX]; 917 static u32 instance; 918 struct enic_softc *softc; 919 920 softc = vdev->softc; 921 922 snprintf((char *)name, sizeof(name), "vnic_flow_ctrs-%u", instance++); 923 iflib_dma_alloc(softc->ctx, sizeof(struct vnic_counter_counts) * VNIC_MAX_FLOW_COUNTERS, &vdev->flow_counters_res, 0); 924 vdev->flow_counters = (struct vnic_counter_counts *)vdev->flow_counters_res.idi_vaddr; 925 vdev->flow_counters_dma_active = 0; 926 return vdev->flow_counters == NULL ? -ENOMEM : 0; 927 } 928 929 struct vnic_dev *vnic_dev_register(struct vnic_dev *vdev, 930 struct enic_bar_info *mem, unsigned int num_bars) 931 { 932 if (vnic_dev_discover_res(vdev, NULL, num_bars)) 933 goto err_out; 934 935 vdev->devcmd = vnic_dev_get_res(vdev, RES_TYPE_DEVCMD, 0); 936 if (!vdev->devcmd) 937 goto err_out; 938 939 return vdev; 940 941 err_out: 942 return NULL; 943 } 944 945 /* 946 * vnic_dev_classifier: Add/Delete classifier entries 947 * @vdev: vdev of the device 948 * @cmd: CLSF_ADD for Add filter 949 * CLSF_DEL for Delete filter 950 * @entry: In case of ADD filter, the caller passes the RQ number in this 951 * variable. 952 * This function stores the filter_id returned by the 953 * firmware in the same variable before return; 954 * 955 * In case of DEL filter, the caller passes the RQ number. Return 956 * value is irrelevant. 957 * @data: filter data 958 * @action: action data 959 */ 960 961 int vnic_dev_overlay_offload_ctrl(struct vnic_dev *vdev, u8 overlay, u8 config) 962 { 963 u64 a0 = overlay; 964 u64 a1 = config; 965 int wait = 1000; 966 967 return vnic_dev_cmd(vdev, CMD_OVERLAY_OFFLOAD_CTRL, &a0, &a1, wait); 968 } 969 970 int vnic_dev_overlay_offload_cfg(struct vnic_dev *vdev, u8 overlay, 971 u16 vxlan_udp_port_number) 972 { 973 u64 a1 = vxlan_udp_port_number; 974 u64 a0 = overlay; 975 int wait = 1000; 976 977 return vnic_dev_cmd(vdev, CMD_OVERLAY_OFFLOAD_CFG, &a0, &a1, wait); 978 } 979 980 int vnic_dev_capable_vxlan(struct vnic_dev *vdev) 981 { 982 u64 a0 = VIC_FEATURE_VXLAN; 983 u64 a1 = 0; 984 int wait = 1000; 985 int ret; 986 987 ret = vnic_dev_cmd(vdev, CMD_GET_SUPP_FEATURE_VER, &a0, &a1, wait); 988 /* 1 if the NIC can do VXLAN for both IPv4 and IPv6 with multiple WQs */ 989 return ret == 0 && 990 (a1 & (FEATURE_VXLAN_IPV6 | FEATURE_VXLAN_MULTI_WQ)) == 991 (FEATURE_VXLAN_IPV6 | FEATURE_VXLAN_MULTI_WQ); 992 } 993 994 bool vnic_dev_counter_alloc(struct vnic_dev *vdev, uint32_t *idx) 995 { 996 u64 a0 = 0; 997 u64 a1 = 0; 998 int wait = 1000; 999 1000 if (vnic_dev_cmd(vdev, CMD_COUNTER_ALLOC, &a0, &a1, wait)) 1001 return false; 1002 *idx = (uint32_t)a0; 1003 return true; 1004 } 1005 1006 bool vnic_dev_counter_free(struct vnic_dev *vdev, uint32_t idx) 1007 { 1008 u64 a0 = idx; 1009 u64 a1 = 0; 1010 int wait = 1000; 1011 1012 return vnic_dev_cmd(vdev, CMD_COUNTER_FREE, &a0, &a1, 1013 wait) == 0; 1014 } 1015 1016 bool vnic_dev_counter_query(struct vnic_dev *vdev, uint32_t idx, 1017 bool reset, uint64_t *packets, uint64_t *bytes) 1018 { 1019 u64 a0 = idx; 1020 u64 a1 = reset ? 1 : 0; 1021 int wait = 1000; 1022 1023 if (reset) { 1024 /* query/reset returns updated counters */ 1025 if (vnic_dev_cmd(vdev, CMD_COUNTER_QUERY, &a0, &a1, wait)) 1026 return false; 1027 *packets = a0; 1028 *bytes = a1; 1029 } else { 1030 /* Get values DMA'd from the adapter */ 1031 *packets = vdev->flow_counters[idx].vcc_packets; 1032 *bytes = vdev->flow_counters[idx].vcc_bytes; 1033 } 1034 return true; 1035 } 1036 1037 device_t dev_from_vnic_dev(struct vnic_dev *vdev) { 1038 return (vdev->softc->dev); 1039 } 1040