1 /* 2 * Copyright 2008-2010 Cisco Systems, Inc. All rights reserved. 3 * Copyright 2007 Nuova Systems, Inc. All rights reserved. 4 * 5 * This program is free software; you may redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; version 2 of the License. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 10 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 11 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 12 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 13 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 14 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 15 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 16 * SOFTWARE. 17 * 18 */ 19 20 #include <linux/kernel.h> 21 #include <linux/errno.h> 22 #include <linux/types.h> 23 #include <linux/pci.h> 24 #include <linux/delay.h> 25 #include <linux/if_ether.h> 26 27 #include "vnic_resource.h" 28 #include "vnic_devcmd.h" 29 #include "vnic_dev.h" 30 #include "vnic_wq.h" 31 #include "vnic_stats.h" 32 #include "enic.h" 33 34 #define VNIC_MAX_RES_HDR_SIZE \ 35 (sizeof(struct vnic_resource_header) + \ 36 sizeof(struct vnic_resource) * RES_TYPE_MAX) 37 #define VNIC_RES_STRIDE 128 38 39 void *vnic_dev_priv(struct vnic_dev *vdev) 40 { 41 return vdev->priv; 42 } 43 44 static int vnic_dev_discover_res(struct vnic_dev *vdev, 45 struct vnic_dev_bar *bar, unsigned int num_bars) 46 { 47 struct vnic_resource_header __iomem *rh; 48 struct mgmt_barmap_hdr __iomem *mrh; 49 struct vnic_resource __iomem *r; 50 u8 type; 51 52 if (num_bars == 0) 53 return -EINVAL; 54 55 if (bar->len < VNIC_MAX_RES_HDR_SIZE) { 56 vdev_err("vNIC BAR0 res hdr length error\n"); 57 return -EINVAL; 58 } 59 60 rh = bar->vaddr; 61 mrh = bar->vaddr; 62 if (!rh) { 63 vdev_err("vNIC BAR0 res hdr not mem-mapped\n"); 64 return -EINVAL; 65 } 66 67 /* Check for mgmt vnic in addition to normal vnic */ 68 if ((ioread32(&rh->magic) != VNIC_RES_MAGIC) || 69 (ioread32(&rh->version) != VNIC_RES_VERSION)) { 70 if ((ioread32(&mrh->magic) != MGMTVNIC_MAGIC) || 71 (ioread32(&mrh->version) != MGMTVNIC_VERSION)) { 72 vdev_err("vNIC BAR0 res magic/version error exp (%lx/%lx) or (%lx/%lx), curr (%x/%x)\n", 73 VNIC_RES_MAGIC, VNIC_RES_VERSION, 74 MGMTVNIC_MAGIC, MGMTVNIC_VERSION, 75 ioread32(&rh->magic), ioread32(&rh->version)); 76 return -EINVAL; 77 } 78 } 79 80 if (ioread32(&mrh->magic) == MGMTVNIC_MAGIC) 81 r = (struct vnic_resource __iomem *)(mrh + 1); 82 else 83 r = (struct vnic_resource __iomem *)(rh + 1); 84 85 86 while ((type = ioread8(&r->type)) != RES_TYPE_EOL) { 87 88 u8 bar_num = ioread8(&r->bar); 89 u32 bar_offset = ioread32(&r->bar_offset); 90 u32 count = ioread32(&r->count); 91 u32 len; 92 93 r++; 94 95 if (bar_num >= num_bars) 96 continue; 97 98 if (!bar[bar_num].len || !bar[bar_num].vaddr) 99 continue; 100 101 switch (type) { 102 case RES_TYPE_WQ: 103 case RES_TYPE_RQ: 104 case RES_TYPE_CQ: 105 case RES_TYPE_INTR_CTRL: 106 /* each count is stride bytes long */ 107 len = count * VNIC_RES_STRIDE; 108 if (len + bar_offset > bar[bar_num].len) { 109 vdev_err("vNIC BAR0 resource %d out-of-bounds, offset 0x%x + size 0x%x > bar len 0x%lx\n", 110 type, bar_offset, len, 111 bar[bar_num].len); 112 return -EINVAL; 113 } 114 break; 115 case RES_TYPE_INTR_PBA_LEGACY: 116 case RES_TYPE_DEVCMD: 117 case RES_TYPE_DEVCMD2: 118 len = count; 119 break; 120 default: 121 continue; 122 } 123 124 vdev->res[type].count = count; 125 vdev->res[type].vaddr = (char __iomem *)bar[bar_num].vaddr + 126 bar_offset; 127 vdev->res[type].bus_addr = bar[bar_num].bus_addr + bar_offset; 128 } 129 130 return 0; 131 } 132 133 unsigned int vnic_dev_get_res_count(struct vnic_dev *vdev, 134 enum vnic_res_type type) 135 { 136 return vdev->res[type].count; 137 } 138 EXPORT_SYMBOL(vnic_dev_get_res_count); 139 140 void __iomem *vnic_dev_get_res(struct vnic_dev *vdev, enum vnic_res_type type, 141 unsigned int index) 142 { 143 if (!vdev->res[type].vaddr) 144 return NULL; 145 146 switch (type) { 147 case RES_TYPE_WQ: 148 case RES_TYPE_RQ: 149 case RES_TYPE_CQ: 150 case RES_TYPE_INTR_CTRL: 151 return (char __iomem *)vdev->res[type].vaddr + 152 index * VNIC_RES_STRIDE; 153 default: 154 return (char __iomem *)vdev->res[type].vaddr; 155 } 156 } 157 EXPORT_SYMBOL(vnic_dev_get_res); 158 159 static unsigned int vnic_dev_desc_ring_size(struct vnic_dev_ring *ring, 160 unsigned int desc_count, unsigned int desc_size) 161 { 162 /* The base address of the desc rings must be 512 byte aligned. 163 * Descriptor count is aligned to groups of 32 descriptors. A 164 * count of 0 means the maximum 4096 descriptors. Descriptor 165 * size is aligned to 16 bytes. 166 */ 167 168 unsigned int count_align = 32; 169 unsigned int desc_align = 16; 170 171 ring->base_align = 512; 172 173 if (desc_count == 0) 174 desc_count = 4096; 175 176 ring->desc_count = ALIGN(desc_count, count_align); 177 178 ring->desc_size = ALIGN(desc_size, desc_align); 179 180 ring->size = ring->desc_count * ring->desc_size; 181 ring->size_unaligned = ring->size + ring->base_align; 182 183 return ring->size_unaligned; 184 } 185 186 void vnic_dev_clear_desc_ring(struct vnic_dev_ring *ring) 187 { 188 memset(ring->descs, 0, ring->size); 189 } 190 191 int vnic_dev_alloc_desc_ring(struct vnic_dev *vdev, struct vnic_dev_ring *ring, 192 unsigned int desc_count, unsigned int desc_size) 193 { 194 vnic_dev_desc_ring_size(ring, desc_count, desc_size); 195 196 ring->descs_unaligned = pci_alloc_consistent(vdev->pdev, 197 ring->size_unaligned, 198 &ring->base_addr_unaligned); 199 200 if (!ring->descs_unaligned) { 201 vdev_err("Failed to allocate ring (size=%d), aborting\n", 202 (int)ring->size); 203 return -ENOMEM; 204 } 205 206 ring->base_addr = ALIGN(ring->base_addr_unaligned, 207 ring->base_align); 208 ring->descs = (u8 *)ring->descs_unaligned + 209 (ring->base_addr - ring->base_addr_unaligned); 210 211 vnic_dev_clear_desc_ring(ring); 212 213 ring->desc_avail = ring->desc_count - 1; 214 215 return 0; 216 } 217 218 void vnic_dev_free_desc_ring(struct vnic_dev *vdev, struct vnic_dev_ring *ring) 219 { 220 if (ring->descs) { 221 pci_free_consistent(vdev->pdev, 222 ring->size_unaligned, 223 ring->descs_unaligned, 224 ring->base_addr_unaligned); 225 ring->descs = NULL; 226 } 227 } 228 229 static int _vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd, 230 int wait) 231 { 232 struct vnic_devcmd __iomem *devcmd = vdev->devcmd; 233 unsigned int i; 234 int delay; 235 u32 status; 236 int err; 237 238 status = ioread32(&devcmd->status); 239 if (status == 0xFFFFFFFF) { 240 /* PCI-e target device is gone */ 241 return -ENODEV; 242 } 243 if (status & STAT_BUSY) { 244 vdev_neterr("Busy devcmd %d\n", _CMD_N(cmd)); 245 return -EBUSY; 246 } 247 248 if (_CMD_DIR(cmd) & _CMD_DIR_WRITE) { 249 for (i = 0; i < VNIC_DEVCMD_NARGS; i++) 250 writeq(vdev->args[i], &devcmd->args[i]); 251 wmb(); 252 } 253 254 iowrite32(cmd, &devcmd->cmd); 255 256 if ((_CMD_FLAGS(cmd) & _CMD_FLAGS_NOWAIT)) 257 return 0; 258 259 for (delay = 0; delay < wait; delay++) { 260 261 udelay(100); 262 263 status = ioread32(&devcmd->status); 264 if (status == 0xFFFFFFFF) { 265 /* PCI-e target device is gone */ 266 return -ENODEV; 267 } 268 269 if (!(status & STAT_BUSY)) { 270 271 if (status & STAT_ERROR) { 272 err = (int)readq(&devcmd->args[0]); 273 if (err == ERR_EINVAL && 274 cmd == CMD_CAPABILITY) 275 return -err; 276 if (err != ERR_ECMDUNKNOWN || 277 cmd != CMD_CAPABILITY) 278 vdev_neterr("Error %d devcmd %d\n", 279 err, _CMD_N(cmd)); 280 return -err; 281 } 282 283 if (_CMD_DIR(cmd) & _CMD_DIR_READ) { 284 rmb(); 285 for (i = 0; i < VNIC_DEVCMD_NARGS; i++) 286 vdev->args[i] = readq(&devcmd->args[i]); 287 } 288 289 return 0; 290 } 291 } 292 293 vdev_neterr("Timedout devcmd %d\n", _CMD_N(cmd)); 294 return -ETIMEDOUT; 295 } 296 297 static int _vnic_dev_cmd2(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd, 298 int wait) 299 { 300 struct devcmd2_controller *dc2c = vdev->devcmd2; 301 struct devcmd2_result *result; 302 u8 color; 303 unsigned int i; 304 int delay, err; 305 u32 fetch_index, new_posted; 306 u32 posted = dc2c->posted; 307 308 fetch_index = ioread32(&dc2c->wq_ctrl->fetch_index); 309 310 if (fetch_index == 0xFFFFFFFF) 311 return -ENODEV; 312 313 new_posted = (posted + 1) % DEVCMD2_RING_SIZE; 314 315 if (new_posted == fetch_index) { 316 vdev_neterr("devcmd2 %d: wq is full. fetch index: %u, posted index: %u\n", 317 _CMD_N(cmd), fetch_index, posted); 318 return -EBUSY; 319 } 320 dc2c->cmd_ring[posted].cmd = cmd; 321 dc2c->cmd_ring[posted].flags = 0; 322 323 if ((_CMD_FLAGS(cmd) & _CMD_FLAGS_NOWAIT)) 324 dc2c->cmd_ring[posted].flags |= DEVCMD2_FNORESULT; 325 if (_CMD_DIR(cmd) & _CMD_DIR_WRITE) 326 for (i = 0; i < VNIC_DEVCMD_NARGS; i++) 327 dc2c->cmd_ring[posted].args[i] = vdev->args[i]; 328 329 /* Adding write memory barrier prevents compiler and/or CPU reordering, 330 * thus avoiding descriptor posting before descriptor is initialized. 331 * Otherwise, hardware can read stale descriptor fields. 332 */ 333 wmb(); 334 iowrite32(new_posted, &dc2c->wq_ctrl->posted_index); 335 dc2c->posted = new_posted; 336 337 if (dc2c->cmd_ring[posted].flags & DEVCMD2_FNORESULT) 338 return 0; 339 340 result = dc2c->result + dc2c->next_result; 341 color = dc2c->color; 342 343 dc2c->next_result++; 344 if (dc2c->next_result == dc2c->result_size) { 345 dc2c->next_result = 0; 346 dc2c->color = dc2c->color ? 0 : 1; 347 } 348 349 for (delay = 0; delay < wait; delay++) { 350 if (result->color == color) { 351 if (result->error) { 352 err = result->error; 353 if (err != ERR_ECMDUNKNOWN || 354 cmd != CMD_CAPABILITY) 355 vdev_neterr("Error %d devcmd %d\n", 356 err, _CMD_N(cmd)); 357 return -err; 358 } 359 if (_CMD_DIR(cmd) & _CMD_DIR_READ) 360 for (i = 0; i < VNIC_DEVCMD2_NARGS; i++) 361 vdev->args[i] = result->results[i]; 362 363 return 0; 364 } 365 udelay(100); 366 } 367 368 vdev_neterr("devcmd %d timed out\n", _CMD_N(cmd)); 369 370 return -ETIMEDOUT; 371 } 372 373 static int vnic_dev_init_devcmd1(struct vnic_dev *vdev) 374 { 375 vdev->devcmd = vnic_dev_get_res(vdev, RES_TYPE_DEVCMD, 0); 376 if (!vdev->devcmd) 377 return -ENODEV; 378 vdev->devcmd_rtn = _vnic_dev_cmd; 379 380 return 0; 381 } 382 383 static int vnic_dev_init_devcmd2(struct vnic_dev *vdev) 384 { 385 int err; 386 unsigned int fetch_index; 387 388 if (vdev->devcmd2) 389 return 0; 390 391 vdev->devcmd2 = kzalloc(sizeof(*vdev->devcmd2), GFP_KERNEL); 392 if (!vdev->devcmd2) 393 return -ENOMEM; 394 395 vdev->devcmd2->color = 1; 396 vdev->devcmd2->result_size = DEVCMD2_RING_SIZE; 397 err = enic_wq_devcmd2_alloc(vdev, &vdev->devcmd2->wq, DEVCMD2_RING_SIZE, 398 DEVCMD2_DESC_SIZE); 399 if (err) 400 goto err_free_devcmd2; 401 402 fetch_index = ioread32(&vdev->devcmd2->wq.ctrl->fetch_index); 403 if (fetch_index == 0xFFFFFFFF) { /* check for hardware gone */ 404 vdev_err("Fatal error in devcmd2 init - hardware surprise removal"); 405 406 return -ENODEV; 407 } 408 409 enic_wq_init_start(&vdev->devcmd2->wq, 0, fetch_index, fetch_index, 0, 410 0); 411 vdev->devcmd2->posted = fetch_index; 412 vnic_wq_enable(&vdev->devcmd2->wq); 413 414 err = vnic_dev_alloc_desc_ring(vdev, &vdev->devcmd2->results_ring, 415 DEVCMD2_RING_SIZE, DEVCMD2_DESC_SIZE); 416 if (err) 417 goto err_free_wq; 418 419 vdev->devcmd2->result = vdev->devcmd2->results_ring.descs; 420 vdev->devcmd2->cmd_ring = vdev->devcmd2->wq.ring.descs; 421 vdev->devcmd2->wq_ctrl = vdev->devcmd2->wq.ctrl; 422 vdev->args[0] = (u64)vdev->devcmd2->results_ring.base_addr | 423 VNIC_PADDR_TARGET; 424 vdev->args[1] = DEVCMD2_RING_SIZE; 425 426 err = _vnic_dev_cmd2(vdev, CMD_INITIALIZE_DEVCMD2, 1000); 427 if (err) 428 goto err_free_desc_ring; 429 430 vdev->devcmd_rtn = _vnic_dev_cmd2; 431 432 return 0; 433 434 err_free_desc_ring: 435 vnic_dev_free_desc_ring(vdev, &vdev->devcmd2->results_ring); 436 err_free_wq: 437 vnic_wq_disable(&vdev->devcmd2->wq); 438 vnic_wq_free(&vdev->devcmd2->wq); 439 err_free_devcmd2: 440 kfree(vdev->devcmd2); 441 vdev->devcmd2 = NULL; 442 443 return err; 444 } 445 446 static void vnic_dev_deinit_devcmd2(struct vnic_dev *vdev) 447 { 448 vnic_dev_free_desc_ring(vdev, &vdev->devcmd2->results_ring); 449 vnic_wq_disable(&vdev->devcmd2->wq); 450 vnic_wq_free(&vdev->devcmd2->wq); 451 kfree(vdev->devcmd2); 452 } 453 454 static int vnic_dev_cmd_proxy(struct vnic_dev *vdev, 455 enum vnic_devcmd_cmd proxy_cmd, enum vnic_devcmd_cmd cmd, 456 u64 *a0, u64 *a1, int wait) 457 { 458 u32 status; 459 int err; 460 461 memset(vdev->args, 0, sizeof(vdev->args)); 462 463 vdev->args[0] = vdev->proxy_index; 464 vdev->args[1] = cmd; 465 vdev->args[2] = *a0; 466 vdev->args[3] = *a1; 467 468 err = vdev->devcmd_rtn(vdev, proxy_cmd, wait); 469 if (err) 470 return err; 471 472 status = (u32)vdev->args[0]; 473 if (status & STAT_ERROR) { 474 err = (int)vdev->args[1]; 475 if (err != ERR_ECMDUNKNOWN || 476 cmd != CMD_CAPABILITY) 477 vdev_neterr("Error %d proxy devcmd %d\n", err, 478 _CMD_N(cmd)); 479 return err; 480 } 481 482 *a0 = vdev->args[1]; 483 *a1 = vdev->args[2]; 484 485 return 0; 486 } 487 488 static int vnic_dev_cmd_no_proxy(struct vnic_dev *vdev, 489 enum vnic_devcmd_cmd cmd, u64 *a0, u64 *a1, int wait) 490 { 491 int err; 492 493 vdev->args[0] = *a0; 494 vdev->args[1] = *a1; 495 496 err = vdev->devcmd_rtn(vdev, cmd, wait); 497 498 *a0 = vdev->args[0]; 499 *a1 = vdev->args[1]; 500 501 return err; 502 } 503 504 void vnic_dev_cmd_proxy_by_index_start(struct vnic_dev *vdev, u16 index) 505 { 506 vdev->proxy = PROXY_BY_INDEX; 507 vdev->proxy_index = index; 508 } 509 510 void vnic_dev_cmd_proxy_end(struct vnic_dev *vdev) 511 { 512 vdev->proxy = PROXY_NONE; 513 vdev->proxy_index = 0; 514 } 515 516 int vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd, 517 u64 *a0, u64 *a1, int wait) 518 { 519 memset(vdev->args, 0, sizeof(vdev->args)); 520 521 switch (vdev->proxy) { 522 case PROXY_BY_INDEX: 523 return vnic_dev_cmd_proxy(vdev, CMD_PROXY_BY_INDEX, cmd, 524 a0, a1, wait); 525 case PROXY_BY_BDF: 526 return vnic_dev_cmd_proxy(vdev, CMD_PROXY_BY_BDF, cmd, 527 a0, a1, wait); 528 case PROXY_NONE: 529 default: 530 return vnic_dev_cmd_no_proxy(vdev, cmd, a0, a1, wait); 531 } 532 } 533 534 static int vnic_dev_capable(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd) 535 { 536 u64 a0 = (u32)cmd, a1 = 0; 537 int wait = 1000; 538 int err; 539 540 err = vnic_dev_cmd(vdev, CMD_CAPABILITY, &a0, &a1, wait); 541 542 return !(err || a0); 543 } 544 545 int vnic_dev_fw_info(struct vnic_dev *vdev, 546 struct vnic_devcmd_fw_info **fw_info) 547 { 548 u64 a0, a1 = 0; 549 int wait = 1000; 550 int err = 0; 551 552 if (!vdev->fw_info) { 553 vdev->fw_info = pci_zalloc_consistent(vdev->pdev, 554 sizeof(struct vnic_devcmd_fw_info), 555 &vdev->fw_info_pa); 556 if (!vdev->fw_info) 557 return -ENOMEM; 558 559 a0 = vdev->fw_info_pa; 560 a1 = sizeof(struct vnic_devcmd_fw_info); 561 562 /* only get fw_info once and cache it */ 563 if (vnic_dev_capable(vdev, CMD_MCPU_FW_INFO)) 564 err = vnic_dev_cmd(vdev, CMD_MCPU_FW_INFO, 565 &a0, &a1, wait); 566 else 567 err = vnic_dev_cmd(vdev, CMD_MCPU_FW_INFO_OLD, 568 &a0, &a1, wait); 569 } 570 571 *fw_info = vdev->fw_info; 572 573 return err; 574 } 575 576 int vnic_dev_spec(struct vnic_dev *vdev, unsigned int offset, unsigned int size, 577 void *value) 578 { 579 u64 a0, a1; 580 int wait = 1000; 581 int err; 582 583 a0 = offset; 584 a1 = size; 585 586 err = vnic_dev_cmd(vdev, CMD_DEV_SPEC, &a0, &a1, wait); 587 588 switch (size) { 589 case 1: *(u8 *)value = (u8)a0; break; 590 case 2: *(u16 *)value = (u16)a0; break; 591 case 4: *(u32 *)value = (u32)a0; break; 592 case 8: *(u64 *)value = a0; break; 593 default: BUG(); break; 594 } 595 596 return err; 597 } 598 599 int vnic_dev_stats_dump(struct vnic_dev *vdev, struct vnic_stats **stats) 600 { 601 u64 a0, a1; 602 int wait = 1000; 603 604 if (!vdev->stats) { 605 vdev->stats = pci_alloc_consistent(vdev->pdev, 606 sizeof(struct vnic_stats), &vdev->stats_pa); 607 if (!vdev->stats) 608 return -ENOMEM; 609 } 610 611 *stats = vdev->stats; 612 a0 = vdev->stats_pa; 613 a1 = sizeof(struct vnic_stats); 614 615 return vnic_dev_cmd(vdev, CMD_STATS_DUMP, &a0, &a1, wait); 616 } 617 618 int vnic_dev_close(struct vnic_dev *vdev) 619 { 620 u64 a0 = 0, a1 = 0; 621 int wait = 1000; 622 return vnic_dev_cmd(vdev, CMD_CLOSE, &a0, &a1, wait); 623 } 624 625 int vnic_dev_enable_wait(struct vnic_dev *vdev) 626 { 627 u64 a0 = 0, a1 = 0; 628 int wait = 1000; 629 630 if (vnic_dev_capable(vdev, CMD_ENABLE_WAIT)) 631 return vnic_dev_cmd(vdev, CMD_ENABLE_WAIT, &a0, &a1, wait); 632 else 633 return vnic_dev_cmd(vdev, CMD_ENABLE, &a0, &a1, wait); 634 } 635 636 int vnic_dev_disable(struct vnic_dev *vdev) 637 { 638 u64 a0 = 0, a1 = 0; 639 int wait = 1000; 640 return vnic_dev_cmd(vdev, CMD_DISABLE, &a0, &a1, wait); 641 } 642 643 int vnic_dev_open(struct vnic_dev *vdev, int arg) 644 { 645 u64 a0 = (u32)arg, a1 = 0; 646 int wait = 1000; 647 return vnic_dev_cmd(vdev, CMD_OPEN, &a0, &a1, wait); 648 } 649 650 int vnic_dev_open_done(struct vnic_dev *vdev, int *done) 651 { 652 u64 a0 = 0, a1 = 0; 653 int wait = 1000; 654 int err; 655 656 *done = 0; 657 658 err = vnic_dev_cmd(vdev, CMD_OPEN_STATUS, &a0, &a1, wait); 659 if (err) 660 return err; 661 662 *done = (a0 == 0); 663 664 return 0; 665 } 666 667 int vnic_dev_soft_reset(struct vnic_dev *vdev, int arg) 668 { 669 u64 a0 = (u32)arg, a1 = 0; 670 int wait = 1000; 671 return vnic_dev_cmd(vdev, CMD_SOFT_RESET, &a0, &a1, wait); 672 } 673 674 int vnic_dev_soft_reset_done(struct vnic_dev *vdev, int *done) 675 { 676 u64 a0 = 0, a1 = 0; 677 int wait = 1000; 678 int err; 679 680 *done = 0; 681 682 err = vnic_dev_cmd(vdev, CMD_SOFT_RESET_STATUS, &a0, &a1, wait); 683 if (err) 684 return err; 685 686 *done = (a0 == 0); 687 688 return 0; 689 } 690 691 int vnic_dev_hang_reset(struct vnic_dev *vdev, int arg) 692 { 693 u64 a0 = (u32)arg, a1 = 0; 694 int wait = 1000; 695 int err; 696 697 if (vnic_dev_capable(vdev, CMD_HANG_RESET)) { 698 return vnic_dev_cmd(vdev, CMD_HANG_RESET, 699 &a0, &a1, wait); 700 } else { 701 err = vnic_dev_soft_reset(vdev, arg); 702 if (err) 703 return err; 704 return vnic_dev_init(vdev, 0); 705 } 706 } 707 708 int vnic_dev_hang_reset_done(struct vnic_dev *vdev, int *done) 709 { 710 u64 a0 = 0, a1 = 0; 711 int wait = 1000; 712 int err; 713 714 *done = 0; 715 716 if (vnic_dev_capable(vdev, CMD_HANG_RESET_STATUS)) { 717 err = vnic_dev_cmd(vdev, CMD_HANG_RESET_STATUS, 718 &a0, &a1, wait); 719 if (err) 720 return err; 721 } else { 722 return vnic_dev_soft_reset_done(vdev, done); 723 } 724 725 *done = (a0 == 0); 726 727 return 0; 728 } 729 730 int vnic_dev_hang_notify(struct vnic_dev *vdev) 731 { 732 u64 a0, a1; 733 int wait = 1000; 734 return vnic_dev_cmd(vdev, CMD_HANG_NOTIFY, &a0, &a1, wait); 735 } 736 737 int vnic_dev_get_mac_addr(struct vnic_dev *vdev, u8 *mac_addr) 738 { 739 u64 a0, a1; 740 int wait = 1000; 741 int err, i; 742 743 for (i = 0; i < ETH_ALEN; i++) 744 mac_addr[i] = 0; 745 746 err = vnic_dev_cmd(vdev, CMD_GET_MAC_ADDR, &a0, &a1, wait); 747 if (err) 748 return err; 749 750 for (i = 0; i < ETH_ALEN; i++) 751 mac_addr[i] = ((u8 *)&a0)[i]; 752 753 return 0; 754 } 755 756 int vnic_dev_packet_filter(struct vnic_dev *vdev, int directed, int multicast, 757 int broadcast, int promisc, int allmulti) 758 { 759 u64 a0, a1 = 0; 760 int wait = 1000; 761 int err; 762 763 a0 = (directed ? CMD_PFILTER_DIRECTED : 0) | 764 (multicast ? CMD_PFILTER_MULTICAST : 0) | 765 (broadcast ? CMD_PFILTER_BROADCAST : 0) | 766 (promisc ? CMD_PFILTER_PROMISCUOUS : 0) | 767 (allmulti ? CMD_PFILTER_ALL_MULTICAST : 0); 768 769 err = vnic_dev_cmd(vdev, CMD_PACKET_FILTER, &a0, &a1, wait); 770 if (err) 771 vdev_neterr("Can't set packet filter\n"); 772 773 return err; 774 } 775 776 int vnic_dev_add_addr(struct vnic_dev *vdev, const u8 *addr) 777 { 778 u64 a0 = 0, a1 = 0; 779 int wait = 1000; 780 int err; 781 int i; 782 783 for (i = 0; i < ETH_ALEN; i++) 784 ((u8 *)&a0)[i] = addr[i]; 785 786 err = vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a0, &a1, wait); 787 if (err) 788 vdev_neterr("Can't add addr [%pM], %d\n", addr, err); 789 790 return err; 791 } 792 793 int vnic_dev_del_addr(struct vnic_dev *vdev, const u8 *addr) 794 { 795 u64 a0 = 0, a1 = 0; 796 int wait = 1000; 797 int err; 798 int i; 799 800 for (i = 0; i < ETH_ALEN; i++) 801 ((u8 *)&a0)[i] = addr[i]; 802 803 err = vnic_dev_cmd(vdev, CMD_ADDR_DEL, &a0, &a1, wait); 804 if (err) 805 vdev_neterr("Can't del addr [%pM], %d\n", addr, err); 806 807 return err; 808 } 809 810 int vnic_dev_set_ig_vlan_rewrite_mode(struct vnic_dev *vdev, 811 u8 ig_vlan_rewrite_mode) 812 { 813 u64 a0 = ig_vlan_rewrite_mode, a1 = 0; 814 int wait = 1000; 815 816 if (vnic_dev_capable(vdev, CMD_IG_VLAN_REWRITE_MODE)) 817 return vnic_dev_cmd(vdev, CMD_IG_VLAN_REWRITE_MODE, 818 &a0, &a1, wait); 819 else 820 return 0; 821 } 822 823 static int vnic_dev_notify_setcmd(struct vnic_dev *vdev, 824 void *notify_addr, dma_addr_t notify_pa, u16 intr) 825 { 826 u64 a0, a1; 827 int wait = 1000; 828 int r; 829 830 memset(notify_addr, 0, sizeof(struct vnic_devcmd_notify)); 831 vdev->notify = notify_addr; 832 vdev->notify_pa = notify_pa; 833 834 a0 = (u64)notify_pa; 835 a1 = ((u64)intr << 32) & 0x0000ffff00000000ULL; 836 a1 += sizeof(struct vnic_devcmd_notify); 837 838 r = vnic_dev_cmd(vdev, CMD_NOTIFY, &a0, &a1, wait); 839 vdev->notify_sz = (r == 0) ? (u32)a1 : 0; 840 return r; 841 } 842 843 int vnic_dev_notify_set(struct vnic_dev *vdev, u16 intr) 844 { 845 void *notify_addr; 846 dma_addr_t notify_pa; 847 848 if (vdev->notify || vdev->notify_pa) { 849 vdev_neterr("notify block %p still allocated", vdev->notify); 850 return -EINVAL; 851 } 852 853 notify_addr = pci_alloc_consistent(vdev->pdev, 854 sizeof(struct vnic_devcmd_notify), 855 ¬ify_pa); 856 if (!notify_addr) 857 return -ENOMEM; 858 859 return vnic_dev_notify_setcmd(vdev, notify_addr, notify_pa, intr); 860 } 861 862 static int vnic_dev_notify_unsetcmd(struct vnic_dev *vdev) 863 { 864 u64 a0, a1; 865 int wait = 1000; 866 int err; 867 868 a0 = 0; /* paddr = 0 to unset notify buffer */ 869 a1 = 0x0000ffff00000000ULL; /* intr num = -1 to unreg for intr */ 870 a1 += sizeof(struct vnic_devcmd_notify); 871 872 err = vnic_dev_cmd(vdev, CMD_NOTIFY, &a0, &a1, wait); 873 vdev->notify = NULL; 874 vdev->notify_pa = 0; 875 vdev->notify_sz = 0; 876 877 return err; 878 } 879 880 int vnic_dev_notify_unset(struct vnic_dev *vdev) 881 { 882 if (vdev->notify) { 883 pci_free_consistent(vdev->pdev, 884 sizeof(struct vnic_devcmd_notify), 885 vdev->notify, 886 vdev->notify_pa); 887 } 888 889 return vnic_dev_notify_unsetcmd(vdev); 890 } 891 892 static int vnic_dev_notify_ready(struct vnic_dev *vdev) 893 { 894 u32 *words; 895 unsigned int nwords = vdev->notify_sz / 4; 896 unsigned int i; 897 u32 csum; 898 899 if (!vdev->notify || !vdev->notify_sz) 900 return 0; 901 902 do { 903 csum = 0; 904 memcpy(&vdev->notify_copy, vdev->notify, vdev->notify_sz); 905 words = (u32 *)&vdev->notify_copy; 906 for (i = 1; i < nwords; i++) 907 csum += words[i]; 908 } while (csum != words[0]); 909 910 return 1; 911 } 912 913 int vnic_dev_init(struct vnic_dev *vdev, int arg) 914 { 915 u64 a0 = (u32)arg, a1 = 0; 916 int wait = 1000; 917 int r = 0; 918 919 if (vnic_dev_capable(vdev, CMD_INIT)) 920 r = vnic_dev_cmd(vdev, CMD_INIT, &a0, &a1, wait); 921 else { 922 vnic_dev_cmd(vdev, CMD_INIT_v1, &a0, &a1, wait); 923 if (a0 & CMD_INITF_DEFAULT_MAC) { 924 /* Emulate these for old CMD_INIT_v1 which 925 * didn't pass a0 so no CMD_INITF_*. 926 */ 927 vnic_dev_cmd(vdev, CMD_GET_MAC_ADDR, &a0, &a1, wait); 928 vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a0, &a1, wait); 929 } 930 } 931 return r; 932 } 933 934 int vnic_dev_deinit(struct vnic_dev *vdev) 935 { 936 u64 a0 = 0, a1 = 0; 937 int wait = 1000; 938 939 return vnic_dev_cmd(vdev, CMD_DEINIT, &a0, &a1, wait); 940 } 941 942 void vnic_dev_intr_coal_timer_info_default(struct vnic_dev *vdev) 943 { 944 /* Default: hardware intr coal timer is in units of 1.5 usecs */ 945 vdev->intr_coal_timer_info.mul = 2; 946 vdev->intr_coal_timer_info.div = 3; 947 vdev->intr_coal_timer_info.max_usec = 948 vnic_dev_intr_coal_timer_hw_to_usec(vdev, 0xffff); 949 } 950 951 int vnic_dev_intr_coal_timer_info(struct vnic_dev *vdev) 952 { 953 int wait = 1000; 954 int err; 955 956 memset(vdev->args, 0, sizeof(vdev->args)); 957 958 if (vnic_dev_capable(vdev, CMD_INTR_COAL_CONVERT)) 959 err = vdev->devcmd_rtn(vdev, CMD_INTR_COAL_CONVERT, wait); 960 else 961 err = ERR_ECMDUNKNOWN; 962 963 /* Use defaults when firmware doesn't support the devcmd at all or 964 * supports it for only specific hardware 965 */ 966 if ((err == ERR_ECMDUNKNOWN) || 967 (!err && !(vdev->args[0] && vdev->args[1] && vdev->args[2]))) { 968 vdev_netwarn("Using default conversion factor for interrupt coalesce timer\n"); 969 vnic_dev_intr_coal_timer_info_default(vdev); 970 return 0; 971 } 972 973 if (!err) { 974 vdev->intr_coal_timer_info.mul = (u32) vdev->args[0]; 975 vdev->intr_coal_timer_info.div = (u32) vdev->args[1]; 976 vdev->intr_coal_timer_info.max_usec = (u32) vdev->args[2]; 977 } 978 979 return err; 980 } 981 982 int vnic_dev_link_status(struct vnic_dev *vdev) 983 { 984 if (!vnic_dev_notify_ready(vdev)) 985 return 0; 986 987 return vdev->notify_copy.link_state; 988 } 989 990 u32 vnic_dev_port_speed(struct vnic_dev *vdev) 991 { 992 if (!vnic_dev_notify_ready(vdev)) 993 return 0; 994 995 return vdev->notify_copy.port_speed; 996 } 997 998 u32 vnic_dev_msg_lvl(struct vnic_dev *vdev) 999 { 1000 if (!vnic_dev_notify_ready(vdev)) 1001 return 0; 1002 1003 return vdev->notify_copy.msglvl; 1004 } 1005 1006 u32 vnic_dev_mtu(struct vnic_dev *vdev) 1007 { 1008 if (!vnic_dev_notify_ready(vdev)) 1009 return 0; 1010 1011 return vdev->notify_copy.mtu; 1012 } 1013 1014 void vnic_dev_set_intr_mode(struct vnic_dev *vdev, 1015 enum vnic_dev_intr_mode intr_mode) 1016 { 1017 vdev->intr_mode = intr_mode; 1018 } 1019 1020 enum vnic_dev_intr_mode vnic_dev_get_intr_mode( 1021 struct vnic_dev *vdev) 1022 { 1023 return vdev->intr_mode; 1024 } 1025 1026 u32 vnic_dev_intr_coal_timer_usec_to_hw(struct vnic_dev *vdev, u32 usec) 1027 { 1028 return (usec * vdev->intr_coal_timer_info.mul) / 1029 vdev->intr_coal_timer_info.div; 1030 } 1031 1032 u32 vnic_dev_intr_coal_timer_hw_to_usec(struct vnic_dev *vdev, u32 hw_cycles) 1033 { 1034 return (hw_cycles * vdev->intr_coal_timer_info.div) / 1035 vdev->intr_coal_timer_info.mul; 1036 } 1037 1038 u32 vnic_dev_get_intr_coal_timer_max(struct vnic_dev *vdev) 1039 { 1040 return vdev->intr_coal_timer_info.max_usec; 1041 } 1042 1043 void vnic_dev_unregister(struct vnic_dev *vdev) 1044 { 1045 if (vdev) { 1046 if (vdev->notify) 1047 pci_free_consistent(vdev->pdev, 1048 sizeof(struct vnic_devcmd_notify), 1049 vdev->notify, 1050 vdev->notify_pa); 1051 if (vdev->stats) 1052 pci_free_consistent(vdev->pdev, 1053 sizeof(struct vnic_stats), 1054 vdev->stats, vdev->stats_pa); 1055 if (vdev->fw_info) 1056 pci_free_consistent(vdev->pdev, 1057 sizeof(struct vnic_devcmd_fw_info), 1058 vdev->fw_info, vdev->fw_info_pa); 1059 if (vdev->devcmd2) 1060 vnic_dev_deinit_devcmd2(vdev); 1061 1062 kfree(vdev); 1063 } 1064 } 1065 EXPORT_SYMBOL(vnic_dev_unregister); 1066 1067 struct vnic_dev *vnic_dev_register(struct vnic_dev *vdev, 1068 void *priv, struct pci_dev *pdev, struct vnic_dev_bar *bar, 1069 unsigned int num_bars) 1070 { 1071 if (!vdev) { 1072 vdev = kzalloc(sizeof(struct vnic_dev), GFP_ATOMIC); 1073 if (!vdev) 1074 return NULL; 1075 } 1076 1077 vdev->priv = priv; 1078 vdev->pdev = pdev; 1079 1080 if (vnic_dev_discover_res(vdev, bar, num_bars)) 1081 goto err_out; 1082 1083 return vdev; 1084 1085 err_out: 1086 vnic_dev_unregister(vdev); 1087 return NULL; 1088 } 1089 EXPORT_SYMBOL(vnic_dev_register); 1090 1091 struct pci_dev *vnic_dev_get_pdev(struct vnic_dev *vdev) 1092 { 1093 return vdev->pdev; 1094 } 1095 EXPORT_SYMBOL(vnic_dev_get_pdev); 1096 1097 int vnic_devcmd_init(struct vnic_dev *vdev) 1098 { 1099 void __iomem *res; 1100 int err; 1101 1102 res = vnic_dev_get_res(vdev, RES_TYPE_DEVCMD2, 0); 1103 if (res) { 1104 err = vnic_dev_init_devcmd2(vdev); 1105 if (err) 1106 vdev_warn("DEVCMD2 init failed: %d, Using DEVCMD1", 1107 err); 1108 else 1109 return 0; 1110 } else { 1111 vdev_warn("DEVCMD2 resource not found (old firmware?) Using DEVCMD1\n"); 1112 } 1113 err = vnic_dev_init_devcmd1(vdev); 1114 if (err) 1115 vdev_err("DEVCMD1 initialization failed: %d", err); 1116 1117 return err; 1118 } 1119 1120 int vnic_dev_init_prov2(struct vnic_dev *vdev, u8 *buf, u32 len) 1121 { 1122 u64 a0, a1 = len; 1123 int wait = 1000; 1124 dma_addr_t prov_pa; 1125 void *prov_buf; 1126 int ret; 1127 1128 prov_buf = pci_alloc_consistent(vdev->pdev, len, &prov_pa); 1129 if (!prov_buf) 1130 return -ENOMEM; 1131 1132 memcpy(prov_buf, buf, len); 1133 1134 a0 = prov_pa; 1135 1136 ret = vnic_dev_cmd(vdev, CMD_INIT_PROV_INFO2, &a0, &a1, wait); 1137 1138 pci_free_consistent(vdev->pdev, len, prov_buf, prov_pa); 1139 1140 return ret; 1141 } 1142 1143 int vnic_dev_enable2(struct vnic_dev *vdev, int active) 1144 { 1145 u64 a0, a1 = 0; 1146 int wait = 1000; 1147 1148 a0 = (active ? CMD_ENABLE2_ACTIVE : 0); 1149 1150 return vnic_dev_cmd(vdev, CMD_ENABLE2, &a0, &a1, wait); 1151 } 1152 1153 static int vnic_dev_cmd_status(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd, 1154 int *status) 1155 { 1156 u64 a0 = cmd, a1 = 0; 1157 int wait = 1000; 1158 int ret; 1159 1160 ret = vnic_dev_cmd(vdev, CMD_STATUS, &a0, &a1, wait); 1161 if (!ret) 1162 *status = (int)a0; 1163 1164 return ret; 1165 } 1166 1167 int vnic_dev_enable2_done(struct vnic_dev *vdev, int *status) 1168 { 1169 return vnic_dev_cmd_status(vdev, CMD_ENABLE2, status); 1170 } 1171 1172 int vnic_dev_deinit_done(struct vnic_dev *vdev, int *status) 1173 { 1174 return vnic_dev_cmd_status(vdev, CMD_DEINIT, status); 1175 } 1176 1177 int vnic_dev_set_mac_addr(struct vnic_dev *vdev, u8 *mac_addr) 1178 { 1179 u64 a0, a1; 1180 int wait = 1000; 1181 int i; 1182 1183 for (i = 0; i < ETH_ALEN; i++) 1184 ((u8 *)&a0)[i] = mac_addr[i]; 1185 1186 return vnic_dev_cmd(vdev, CMD_SET_MAC_ADDR, &a0, &a1, wait); 1187 } 1188 1189 /* vnic_dev_classifier: Add/Delete classifier entries 1190 * @vdev: vdev of the device 1191 * @cmd: CLSF_ADD for Add filter 1192 * CLSF_DEL for Delete filter 1193 * @entry: In case of ADD filter, the caller passes the RQ number in this 1194 * variable. 1195 * 1196 * This function stores the filter_id returned by the firmware in the 1197 * same variable before return; 1198 * 1199 * In case of DEL filter, the caller passes the RQ number. Return 1200 * value is irrelevant. 1201 * @data: filter data 1202 */ 1203 int vnic_dev_classifier(struct vnic_dev *vdev, u8 cmd, u16 *entry, 1204 struct filter *data) 1205 { 1206 u64 a0, a1; 1207 int wait = 1000; 1208 dma_addr_t tlv_pa; 1209 int ret = -EINVAL; 1210 struct filter_tlv *tlv, *tlv_va; 1211 struct filter_action *action; 1212 u64 tlv_size; 1213 1214 if (cmd == CLSF_ADD) { 1215 tlv_size = sizeof(struct filter) + 1216 sizeof(struct filter_action) + 1217 2 * sizeof(struct filter_tlv); 1218 tlv_va = pci_alloc_consistent(vdev->pdev, tlv_size, &tlv_pa); 1219 if (!tlv_va) 1220 return -ENOMEM; 1221 tlv = tlv_va; 1222 a0 = tlv_pa; 1223 a1 = tlv_size; 1224 memset(tlv, 0, tlv_size); 1225 tlv->type = CLSF_TLV_FILTER; 1226 tlv->length = sizeof(struct filter); 1227 *(struct filter *)&tlv->val = *data; 1228 1229 tlv = (struct filter_tlv *)((char *)tlv + 1230 sizeof(struct filter_tlv) + 1231 sizeof(struct filter)); 1232 1233 tlv->type = CLSF_TLV_ACTION; 1234 tlv->length = sizeof(struct filter_action); 1235 action = (struct filter_action *)&tlv->val; 1236 action->type = FILTER_ACTION_RQ_STEERING; 1237 action->u.rq_idx = *entry; 1238 1239 ret = vnic_dev_cmd(vdev, CMD_ADD_FILTER, &a0, &a1, wait); 1240 *entry = (u16)a0; 1241 pci_free_consistent(vdev->pdev, tlv_size, tlv_va, tlv_pa); 1242 } else if (cmd == CLSF_DEL) { 1243 a0 = *entry; 1244 ret = vnic_dev_cmd(vdev, CMD_DEL_FILTER, &a0, &a1, wait); 1245 } 1246 1247 return ret; 1248 } 1249