1 /* 2 * This file is part of the Chelsio T4 PCI-E SR-IOV Virtual Function Ethernet 3 * driver for Linux. 4 * 5 * Copyright (c) 2009-2010 Chelsio Communications, Inc. All rights reserved. 6 * 7 * This software is available to you under a choice of one of two 8 * licenses. You may choose to be licensed under the terms of the GNU 9 * General Public License (GPL) Version 2, available from the file 10 * COPYING in the main directory of this source tree, or the 11 * OpenIB.org BSD license below: 12 * 13 * Redistribution and use in source and binary forms, with or 14 * without modification, are permitted provided that the following 15 * conditions are met: 16 * 17 * - Redistributions of source code must retain the above 18 * copyright notice, this list of conditions and the following 19 * disclaimer. 20 * 21 * - Redistributions in binary form must reproduce the above 22 * copyright notice, this list of conditions and the following 23 * disclaimer in the documentation and/or other materials 24 * provided with the distribution. 25 * 26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 27 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 29 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 30 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 31 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 32 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 33 * SOFTWARE. 34 */ 35 36 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 37 38 #include <linux/module.h> 39 #include <linux/moduleparam.h> 40 #include <linux/init.h> 41 #include <linux/pci.h> 42 #include <linux/dma-mapping.h> 43 #include <linux/netdevice.h> 44 #include <linux/etherdevice.h> 45 #include <linux/debugfs.h> 46 #include <linux/ethtool.h> 47 48 #include "t4vf_common.h" 49 #include "t4vf_defs.h" 50 51 #include "../cxgb4/t4_regs.h" 52 #include "../cxgb4/t4_msg.h" 53 54 /* 55 * Generic information about the driver. 56 */ 57 #define DRV_VERSION "2.0.0-ko" 58 #define DRV_DESC "Chelsio T4/T5 Virtual Function (VF) Network Driver" 59 60 /* 61 * Module Parameters. 62 * ================== 63 */ 64 65 /* 66 * Default ethtool "message level" for adapters. 67 */ 68 #define DFLT_MSG_ENABLE (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK | \ 69 NETIF_MSG_TIMER | NETIF_MSG_IFDOWN | NETIF_MSG_IFUP |\ 70 NETIF_MSG_RX_ERR | NETIF_MSG_TX_ERR) 71 72 static int dflt_msg_enable = DFLT_MSG_ENABLE; 73 74 module_param(dflt_msg_enable, int, 0644); 75 MODULE_PARM_DESC(dflt_msg_enable, 76 "default adapter ethtool message level bitmap"); 77 78 /* 79 * The driver uses the best interrupt scheme available on a platform in the 80 * order MSI-X then MSI. This parameter determines which of these schemes the 81 * driver may consider as follows: 82 * 83 * msi = 2: choose from among MSI-X and MSI 84 * msi = 1: only consider MSI interrupts 85 * 86 * Note that unlike the Physical Function driver, this Virtual Function driver 87 * does _not_ support legacy INTx interrupts (this limitation is mandated by 88 * the PCI-E SR-IOV standard). 89 */ 90 #define MSI_MSIX 2 91 #define MSI_MSI 1 92 #define MSI_DEFAULT MSI_MSIX 93 94 static int msi = MSI_DEFAULT; 95 96 module_param(msi, int, 0644); 97 MODULE_PARM_DESC(msi, "whether to use MSI-X or MSI"); 98 99 /* 100 * Fundamental constants. 101 * ====================== 102 */ 103 104 enum { 105 MAX_TXQ_ENTRIES = 16384, 106 MAX_RSPQ_ENTRIES = 16384, 107 MAX_RX_BUFFERS = 16384, 108 109 MIN_TXQ_ENTRIES = 32, 110 MIN_RSPQ_ENTRIES = 128, 111 MIN_FL_ENTRIES = 16, 112 113 /* 114 * For purposes of manipulating the Free List size we need to 115 * recognize that Free Lists are actually Egress Queues (the host 116 * produces free buffers which the hardware consumes), Egress Queues 117 * indices are all in units of Egress Context Units bytes, and free 118 * list entries are 64-bit PCI DMA addresses. And since the state of 119 * the Producer Index == the Consumer Index implies an EMPTY list, we 120 * always have at least one Egress Unit's worth of Free List entries 121 * unused. See sge.c for more details ... 122 */ 123 EQ_UNIT = SGE_EQ_IDXSIZE, 124 FL_PER_EQ_UNIT = EQ_UNIT / sizeof(__be64), 125 MIN_FL_RESID = FL_PER_EQ_UNIT, 126 }; 127 128 /* 129 * Global driver state. 130 * ==================== 131 */ 132 133 static struct dentry *cxgb4vf_debugfs_root; 134 135 /* 136 * OS "Callback" functions. 137 * ======================== 138 */ 139 140 /* 141 * The link status has changed on the indicated "port" (Virtual Interface). 142 */ 143 void t4vf_os_link_changed(struct adapter *adapter, int pidx, int link_ok) 144 { 145 struct net_device *dev = adapter->port[pidx]; 146 147 /* 148 * If the port is disabled or the current recorded "link up" 149 * status matches the new status, just return. 150 */ 151 if (!netif_running(dev) || link_ok == netif_carrier_ok(dev)) 152 return; 153 154 /* 155 * Tell the OS that the link status has changed and print a short 156 * informative message on the console about the event. 157 */ 158 if (link_ok) { 159 const char *s; 160 const char *fc; 161 const struct port_info *pi = netdev_priv(dev); 162 163 netif_carrier_on(dev); 164 165 switch (pi->link_cfg.speed) { 166 case 40000: 167 s = "40Gbps"; 168 break; 169 170 case 10000: 171 s = "10Gbps"; 172 break; 173 174 case 1000: 175 s = "1000Mbps"; 176 break; 177 178 case 100: 179 s = "100Mbps"; 180 break; 181 182 default: 183 s = "unknown"; 184 break; 185 } 186 187 switch (pi->link_cfg.fc) { 188 case PAUSE_RX: 189 fc = "RX"; 190 break; 191 192 case PAUSE_TX: 193 fc = "TX"; 194 break; 195 196 case PAUSE_RX|PAUSE_TX: 197 fc = "RX/TX"; 198 break; 199 200 default: 201 fc = "no"; 202 break; 203 } 204 205 netdev_info(dev, "link up, %s, full-duplex, %s PAUSE\n", s, fc); 206 } else { 207 netif_carrier_off(dev); 208 netdev_info(dev, "link down\n"); 209 } 210 } 211 212 /* 213 * Net device operations. 214 * ====================== 215 */ 216 217 218 219 220 /* 221 * Perform the MAC and PHY actions needed to enable a "port" (Virtual 222 * Interface). 223 */ 224 static int link_start(struct net_device *dev) 225 { 226 int ret; 227 struct port_info *pi = netdev_priv(dev); 228 229 /* 230 * We do not set address filters and promiscuity here, the stack does 231 * that step explicitly. Enable vlan accel. 232 */ 233 ret = t4vf_set_rxmode(pi->adapter, pi->viid, dev->mtu, -1, -1, -1, 1, 234 true); 235 if (ret == 0) { 236 ret = t4vf_change_mac(pi->adapter, pi->viid, 237 pi->xact_addr_filt, dev->dev_addr, true); 238 if (ret >= 0) { 239 pi->xact_addr_filt = ret; 240 ret = 0; 241 } 242 } 243 244 /* 245 * We don't need to actually "start the link" itself since the 246 * firmware will do that for us when the first Virtual Interface 247 * is enabled on a port. 248 */ 249 if (ret == 0) 250 ret = t4vf_enable_vi(pi->adapter, pi->viid, true, true); 251 return ret; 252 } 253 254 /* 255 * Name the MSI-X interrupts. 256 */ 257 static void name_msix_vecs(struct adapter *adapter) 258 { 259 int namelen = sizeof(adapter->msix_info[0].desc) - 1; 260 int pidx; 261 262 /* 263 * Firmware events. 264 */ 265 snprintf(adapter->msix_info[MSIX_FW].desc, namelen, 266 "%s-FWeventq", adapter->name); 267 adapter->msix_info[MSIX_FW].desc[namelen] = 0; 268 269 /* 270 * Ethernet queues. 271 */ 272 for_each_port(adapter, pidx) { 273 struct net_device *dev = adapter->port[pidx]; 274 const struct port_info *pi = netdev_priv(dev); 275 int qs, msi; 276 277 for (qs = 0, msi = MSIX_IQFLINT; qs < pi->nqsets; qs++, msi++) { 278 snprintf(adapter->msix_info[msi].desc, namelen, 279 "%s-%d", dev->name, qs); 280 adapter->msix_info[msi].desc[namelen] = 0; 281 } 282 } 283 } 284 285 /* 286 * Request all of our MSI-X resources. 287 */ 288 static int request_msix_queue_irqs(struct adapter *adapter) 289 { 290 struct sge *s = &adapter->sge; 291 int rxq, msi, err; 292 293 /* 294 * Firmware events. 295 */ 296 err = request_irq(adapter->msix_info[MSIX_FW].vec, t4vf_sge_intr_msix, 297 0, adapter->msix_info[MSIX_FW].desc, &s->fw_evtq); 298 if (err) 299 return err; 300 301 /* 302 * Ethernet queues. 303 */ 304 msi = MSIX_IQFLINT; 305 for_each_ethrxq(s, rxq) { 306 err = request_irq(adapter->msix_info[msi].vec, 307 t4vf_sge_intr_msix, 0, 308 adapter->msix_info[msi].desc, 309 &s->ethrxq[rxq].rspq); 310 if (err) 311 goto err_free_irqs; 312 msi++; 313 } 314 return 0; 315 316 err_free_irqs: 317 while (--rxq >= 0) 318 free_irq(adapter->msix_info[--msi].vec, &s->ethrxq[rxq].rspq); 319 free_irq(adapter->msix_info[MSIX_FW].vec, &s->fw_evtq); 320 return err; 321 } 322 323 /* 324 * Free our MSI-X resources. 325 */ 326 static void free_msix_queue_irqs(struct adapter *adapter) 327 { 328 struct sge *s = &adapter->sge; 329 int rxq, msi; 330 331 free_irq(adapter->msix_info[MSIX_FW].vec, &s->fw_evtq); 332 msi = MSIX_IQFLINT; 333 for_each_ethrxq(s, rxq) 334 free_irq(adapter->msix_info[msi++].vec, 335 &s->ethrxq[rxq].rspq); 336 } 337 338 /* 339 * Turn on NAPI and start up interrupts on a response queue. 340 */ 341 static void qenable(struct sge_rspq *rspq) 342 { 343 napi_enable(&rspq->napi); 344 345 /* 346 * 0-increment the Going To Sleep register to start the timer and 347 * enable interrupts. 348 */ 349 t4_write_reg(rspq->adapter, T4VF_SGE_BASE_ADDR + SGE_VF_GTS, 350 CIDXINC(0) | 351 SEINTARM(rspq->intr_params) | 352 INGRESSQID(rspq->cntxt_id)); 353 } 354 355 /* 356 * Enable NAPI scheduling and interrupt generation for all Receive Queues. 357 */ 358 static void enable_rx(struct adapter *adapter) 359 { 360 int rxq; 361 struct sge *s = &adapter->sge; 362 363 for_each_ethrxq(s, rxq) 364 qenable(&s->ethrxq[rxq].rspq); 365 qenable(&s->fw_evtq); 366 367 /* 368 * The interrupt queue doesn't use NAPI so we do the 0-increment of 369 * its Going To Sleep register here to get it started. 370 */ 371 if (adapter->flags & USING_MSI) 372 t4_write_reg(adapter, T4VF_SGE_BASE_ADDR + SGE_VF_GTS, 373 CIDXINC(0) | 374 SEINTARM(s->intrq.intr_params) | 375 INGRESSQID(s->intrq.cntxt_id)); 376 377 } 378 379 /* 380 * Wait until all NAPI handlers are descheduled. 381 */ 382 static void quiesce_rx(struct adapter *adapter) 383 { 384 struct sge *s = &adapter->sge; 385 int rxq; 386 387 for_each_ethrxq(s, rxq) 388 napi_disable(&s->ethrxq[rxq].rspq.napi); 389 napi_disable(&s->fw_evtq.napi); 390 } 391 392 /* 393 * Response queue handler for the firmware event queue. 394 */ 395 static int fwevtq_handler(struct sge_rspq *rspq, const __be64 *rsp, 396 const struct pkt_gl *gl) 397 { 398 /* 399 * Extract response opcode and get pointer to CPL message body. 400 */ 401 struct adapter *adapter = rspq->adapter; 402 u8 opcode = ((const struct rss_header *)rsp)->opcode; 403 void *cpl = (void *)(rsp + 1); 404 405 switch (opcode) { 406 case CPL_FW6_MSG: { 407 /* 408 * We've received an asynchronous message from the firmware. 409 */ 410 const struct cpl_fw6_msg *fw_msg = cpl; 411 if (fw_msg->type == FW6_TYPE_CMD_RPL) 412 t4vf_handle_fw_rpl(adapter, fw_msg->data); 413 break; 414 } 415 416 case CPL_FW4_MSG: { 417 /* FW can send EGR_UPDATEs encapsulated in a CPL_FW4_MSG. 418 */ 419 const struct cpl_sge_egr_update *p = (void *)(rsp + 3); 420 opcode = G_CPL_OPCODE(ntohl(p->opcode_qid)); 421 if (opcode != CPL_SGE_EGR_UPDATE) { 422 dev_err(adapter->pdev_dev, "unexpected FW4/CPL %#x on FW event queue\n" 423 , opcode); 424 break; 425 } 426 cpl = (void *)p; 427 /*FALLTHROUGH*/ 428 } 429 430 case CPL_SGE_EGR_UPDATE: { 431 /* 432 * We've received an Egress Queue Status Update message. We 433 * get these, if the SGE is configured to send these when the 434 * firmware passes certain points in processing our TX 435 * Ethernet Queue or if we make an explicit request for one. 436 * We use these updates to determine when we may need to 437 * restart a TX Ethernet Queue which was stopped for lack of 438 * free TX Queue Descriptors ... 439 */ 440 const struct cpl_sge_egr_update *p = cpl; 441 unsigned int qid = EGR_QID(be32_to_cpu(p->opcode_qid)); 442 struct sge *s = &adapter->sge; 443 struct sge_txq *tq; 444 struct sge_eth_txq *txq; 445 unsigned int eq_idx; 446 447 /* 448 * Perform sanity checking on the Queue ID to make sure it 449 * really refers to one of our TX Ethernet Egress Queues which 450 * is active and matches the queue's ID. None of these error 451 * conditions should ever happen so we may want to either make 452 * them fatal and/or conditionalized under DEBUG. 453 */ 454 eq_idx = EQ_IDX(s, qid); 455 if (unlikely(eq_idx >= MAX_EGRQ)) { 456 dev_err(adapter->pdev_dev, 457 "Egress Update QID %d out of range\n", qid); 458 break; 459 } 460 tq = s->egr_map[eq_idx]; 461 if (unlikely(tq == NULL)) { 462 dev_err(adapter->pdev_dev, 463 "Egress Update QID %d TXQ=NULL\n", qid); 464 break; 465 } 466 txq = container_of(tq, struct sge_eth_txq, q); 467 if (unlikely(tq->abs_id != qid)) { 468 dev_err(adapter->pdev_dev, 469 "Egress Update QID %d refers to TXQ %d\n", 470 qid, tq->abs_id); 471 break; 472 } 473 474 /* 475 * Restart a stopped TX Queue which has less than half of its 476 * TX ring in use ... 477 */ 478 txq->q.restarts++; 479 netif_tx_wake_queue(txq->txq); 480 break; 481 } 482 483 default: 484 dev_err(adapter->pdev_dev, 485 "unexpected CPL %#x on FW event queue\n", opcode); 486 } 487 488 return 0; 489 } 490 491 /* 492 * Allocate SGE TX/RX response queues. Determine how many sets of SGE queues 493 * to use and initializes them. We support multiple "Queue Sets" per port if 494 * we have MSI-X, otherwise just one queue set per port. 495 */ 496 static int setup_sge_queues(struct adapter *adapter) 497 { 498 struct sge *s = &adapter->sge; 499 int err, pidx, msix; 500 501 /* 502 * Clear "Queue Set" Free List Starving and TX Queue Mapping Error 503 * state. 504 */ 505 bitmap_zero(s->starving_fl, MAX_EGRQ); 506 507 /* 508 * If we're using MSI interrupt mode we need to set up a "forwarded 509 * interrupt" queue which we'll set up with our MSI vector. The rest 510 * of the ingress queues will be set up to forward their interrupts to 511 * this queue ... This must be first since t4vf_sge_alloc_rxq() uses 512 * the intrq's queue ID as the interrupt forwarding queue for the 513 * subsequent calls ... 514 */ 515 if (adapter->flags & USING_MSI) { 516 err = t4vf_sge_alloc_rxq(adapter, &s->intrq, false, 517 adapter->port[0], 0, NULL, NULL); 518 if (err) 519 goto err_free_queues; 520 } 521 522 /* 523 * Allocate our ingress queue for asynchronous firmware messages. 524 */ 525 err = t4vf_sge_alloc_rxq(adapter, &s->fw_evtq, true, adapter->port[0], 526 MSIX_FW, NULL, fwevtq_handler); 527 if (err) 528 goto err_free_queues; 529 530 /* 531 * Allocate each "port"'s initial Queue Sets. These can be changed 532 * later on ... up to the point where any interface on the adapter is 533 * brought up at which point lots of things get nailed down 534 * permanently ... 535 */ 536 msix = MSIX_IQFLINT; 537 for_each_port(adapter, pidx) { 538 struct net_device *dev = adapter->port[pidx]; 539 struct port_info *pi = netdev_priv(dev); 540 struct sge_eth_rxq *rxq = &s->ethrxq[pi->first_qset]; 541 struct sge_eth_txq *txq = &s->ethtxq[pi->first_qset]; 542 int qs; 543 544 for (qs = 0; qs < pi->nqsets; qs++, rxq++, txq++) { 545 err = t4vf_sge_alloc_rxq(adapter, &rxq->rspq, false, 546 dev, msix++, 547 &rxq->fl, t4vf_ethrx_handler); 548 if (err) 549 goto err_free_queues; 550 551 err = t4vf_sge_alloc_eth_txq(adapter, txq, dev, 552 netdev_get_tx_queue(dev, qs), 553 s->fw_evtq.cntxt_id); 554 if (err) 555 goto err_free_queues; 556 557 rxq->rspq.idx = qs; 558 memset(&rxq->stats, 0, sizeof(rxq->stats)); 559 } 560 } 561 562 /* 563 * Create the reverse mappings for the queues. 564 */ 565 s->egr_base = s->ethtxq[0].q.abs_id - s->ethtxq[0].q.cntxt_id; 566 s->ingr_base = s->ethrxq[0].rspq.abs_id - s->ethrxq[0].rspq.cntxt_id; 567 IQ_MAP(s, s->fw_evtq.abs_id) = &s->fw_evtq; 568 for_each_port(adapter, pidx) { 569 struct net_device *dev = adapter->port[pidx]; 570 struct port_info *pi = netdev_priv(dev); 571 struct sge_eth_rxq *rxq = &s->ethrxq[pi->first_qset]; 572 struct sge_eth_txq *txq = &s->ethtxq[pi->first_qset]; 573 int qs; 574 575 for (qs = 0; qs < pi->nqsets; qs++, rxq++, txq++) { 576 IQ_MAP(s, rxq->rspq.abs_id) = &rxq->rspq; 577 EQ_MAP(s, txq->q.abs_id) = &txq->q; 578 579 /* 580 * The FW_IQ_CMD doesn't return the Absolute Queue IDs 581 * for Free Lists but since all of the Egress Queues 582 * (including Free Lists) have Relative Queue IDs 583 * which are computed as Absolute - Base Queue ID, we 584 * can synthesize the Absolute Queue IDs for the Free 585 * Lists. This is useful for debugging purposes when 586 * we want to dump Queue Contexts via the PF Driver. 587 */ 588 rxq->fl.abs_id = rxq->fl.cntxt_id + s->egr_base; 589 EQ_MAP(s, rxq->fl.abs_id) = &rxq->fl; 590 } 591 } 592 return 0; 593 594 err_free_queues: 595 t4vf_free_sge_resources(adapter); 596 return err; 597 } 598 599 /* 600 * Set up Receive Side Scaling (RSS) to distribute packets to multiple receive 601 * queues. We configure the RSS CPU lookup table to distribute to the number 602 * of HW receive queues, and the response queue lookup table to narrow that 603 * down to the response queues actually configured for each "port" (Virtual 604 * Interface). We always configure the RSS mapping for all ports since the 605 * mapping table has plenty of entries. 606 */ 607 static int setup_rss(struct adapter *adapter) 608 { 609 int pidx; 610 611 for_each_port(adapter, pidx) { 612 struct port_info *pi = adap2pinfo(adapter, pidx); 613 struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[pi->first_qset]; 614 u16 rss[MAX_PORT_QSETS]; 615 int qs, err; 616 617 for (qs = 0; qs < pi->nqsets; qs++) 618 rss[qs] = rxq[qs].rspq.abs_id; 619 620 err = t4vf_config_rss_range(adapter, pi->viid, 621 0, pi->rss_size, rss, pi->nqsets); 622 if (err) 623 return err; 624 625 /* 626 * Perform Global RSS Mode-specific initialization. 627 */ 628 switch (adapter->params.rss.mode) { 629 case FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL: 630 /* 631 * If Tunnel All Lookup isn't specified in the global 632 * RSS Configuration, then we need to specify a 633 * default Ingress Queue for any ingress packets which 634 * aren't hashed. We'll use our first ingress queue 635 * ... 636 */ 637 if (!adapter->params.rss.u.basicvirtual.tnlalllookup) { 638 union rss_vi_config config; 639 err = t4vf_read_rss_vi_config(adapter, 640 pi->viid, 641 &config); 642 if (err) 643 return err; 644 config.basicvirtual.defaultq = 645 rxq[0].rspq.abs_id; 646 err = t4vf_write_rss_vi_config(adapter, 647 pi->viid, 648 &config); 649 if (err) 650 return err; 651 } 652 break; 653 } 654 } 655 656 return 0; 657 } 658 659 /* 660 * Bring the adapter up. Called whenever we go from no "ports" open to having 661 * one open. This function performs the actions necessary to make an adapter 662 * operational, such as completing the initialization of HW modules, and 663 * enabling interrupts. Must be called with the rtnl lock held. (Note that 664 * this is called "cxgb_up" in the PF Driver.) 665 */ 666 static int adapter_up(struct adapter *adapter) 667 { 668 int err; 669 670 /* 671 * If this is the first time we've been called, perform basic 672 * adapter setup. Once we've done this, many of our adapter 673 * parameters can no longer be changed ... 674 */ 675 if ((adapter->flags & FULL_INIT_DONE) == 0) { 676 err = setup_sge_queues(adapter); 677 if (err) 678 return err; 679 err = setup_rss(adapter); 680 if (err) { 681 t4vf_free_sge_resources(adapter); 682 return err; 683 } 684 685 if (adapter->flags & USING_MSIX) 686 name_msix_vecs(adapter); 687 adapter->flags |= FULL_INIT_DONE; 688 } 689 690 /* 691 * Acquire our interrupt resources. We only support MSI-X and MSI. 692 */ 693 BUG_ON((adapter->flags & (USING_MSIX|USING_MSI)) == 0); 694 if (adapter->flags & USING_MSIX) 695 err = request_msix_queue_irqs(adapter); 696 else 697 err = request_irq(adapter->pdev->irq, 698 t4vf_intr_handler(adapter), 0, 699 adapter->name, adapter); 700 if (err) { 701 dev_err(adapter->pdev_dev, "request_irq failed, err %d\n", 702 err); 703 return err; 704 } 705 706 /* 707 * Enable NAPI ingress processing and return success. 708 */ 709 enable_rx(adapter); 710 t4vf_sge_start(adapter); 711 return 0; 712 } 713 714 /* 715 * Bring the adapter down. Called whenever the last "port" (Virtual 716 * Interface) closed. (Note that this routine is called "cxgb_down" in the PF 717 * Driver.) 718 */ 719 static void adapter_down(struct adapter *adapter) 720 { 721 /* 722 * Free interrupt resources. 723 */ 724 if (adapter->flags & USING_MSIX) 725 free_msix_queue_irqs(adapter); 726 else 727 free_irq(adapter->pdev->irq, adapter); 728 729 /* 730 * Wait for NAPI handlers to finish. 731 */ 732 quiesce_rx(adapter); 733 } 734 735 /* 736 * Start up a net device. 737 */ 738 static int cxgb4vf_open(struct net_device *dev) 739 { 740 int err; 741 struct port_info *pi = netdev_priv(dev); 742 struct adapter *adapter = pi->adapter; 743 744 /* 745 * If this is the first interface that we're opening on the "adapter", 746 * bring the "adapter" up now. 747 */ 748 if (adapter->open_device_map == 0) { 749 err = adapter_up(adapter); 750 if (err) 751 return err; 752 } 753 754 /* 755 * Note that this interface is up and start everything up ... 756 */ 757 netif_set_real_num_tx_queues(dev, pi->nqsets); 758 err = netif_set_real_num_rx_queues(dev, pi->nqsets); 759 if (err) 760 goto err_unwind; 761 err = link_start(dev); 762 if (err) 763 goto err_unwind; 764 765 netif_tx_start_all_queues(dev); 766 set_bit(pi->port_id, &adapter->open_device_map); 767 return 0; 768 769 err_unwind: 770 if (adapter->open_device_map == 0) 771 adapter_down(adapter); 772 return err; 773 } 774 775 /* 776 * Shut down a net device. This routine is called "cxgb_close" in the PF 777 * Driver ... 778 */ 779 static int cxgb4vf_stop(struct net_device *dev) 780 { 781 struct port_info *pi = netdev_priv(dev); 782 struct adapter *adapter = pi->adapter; 783 784 netif_tx_stop_all_queues(dev); 785 netif_carrier_off(dev); 786 t4vf_enable_vi(adapter, pi->viid, false, false); 787 pi->link_cfg.link_ok = 0; 788 789 clear_bit(pi->port_id, &adapter->open_device_map); 790 if (adapter->open_device_map == 0) 791 adapter_down(adapter); 792 return 0; 793 } 794 795 /* 796 * Translate our basic statistics into the standard "ifconfig" statistics. 797 */ 798 static struct net_device_stats *cxgb4vf_get_stats(struct net_device *dev) 799 { 800 struct t4vf_port_stats stats; 801 struct port_info *pi = netdev2pinfo(dev); 802 struct adapter *adapter = pi->adapter; 803 struct net_device_stats *ns = &dev->stats; 804 int err; 805 806 spin_lock(&adapter->stats_lock); 807 err = t4vf_get_port_stats(adapter, pi->pidx, &stats); 808 spin_unlock(&adapter->stats_lock); 809 810 memset(ns, 0, sizeof(*ns)); 811 if (err) 812 return ns; 813 814 ns->tx_bytes = (stats.tx_bcast_bytes + stats.tx_mcast_bytes + 815 stats.tx_ucast_bytes + stats.tx_offload_bytes); 816 ns->tx_packets = (stats.tx_bcast_frames + stats.tx_mcast_frames + 817 stats.tx_ucast_frames + stats.tx_offload_frames); 818 ns->rx_bytes = (stats.rx_bcast_bytes + stats.rx_mcast_bytes + 819 stats.rx_ucast_bytes); 820 ns->rx_packets = (stats.rx_bcast_frames + stats.rx_mcast_frames + 821 stats.rx_ucast_frames); 822 ns->multicast = stats.rx_mcast_frames; 823 ns->tx_errors = stats.tx_drop_frames; 824 ns->rx_errors = stats.rx_err_frames; 825 826 return ns; 827 } 828 829 /* 830 * Collect up to maxaddrs worth of a netdevice's unicast addresses, starting 831 * at a specified offset within the list, into an array of addrss pointers and 832 * return the number collected. 833 */ 834 static inline unsigned int collect_netdev_uc_list_addrs(const struct net_device *dev, 835 const u8 **addr, 836 unsigned int offset, 837 unsigned int maxaddrs) 838 { 839 unsigned int index = 0; 840 unsigned int naddr = 0; 841 const struct netdev_hw_addr *ha; 842 843 for_each_dev_addr(dev, ha) 844 if (index++ >= offset) { 845 addr[naddr++] = ha->addr; 846 if (naddr >= maxaddrs) 847 break; 848 } 849 return naddr; 850 } 851 852 /* 853 * Collect up to maxaddrs worth of a netdevice's multicast addresses, starting 854 * at a specified offset within the list, into an array of addrss pointers and 855 * return the number collected. 856 */ 857 static inline unsigned int collect_netdev_mc_list_addrs(const struct net_device *dev, 858 const u8 **addr, 859 unsigned int offset, 860 unsigned int maxaddrs) 861 { 862 unsigned int index = 0; 863 unsigned int naddr = 0; 864 const struct netdev_hw_addr *ha; 865 866 netdev_for_each_mc_addr(ha, dev) 867 if (index++ >= offset) { 868 addr[naddr++] = ha->addr; 869 if (naddr >= maxaddrs) 870 break; 871 } 872 return naddr; 873 } 874 875 /* 876 * Configure the exact and hash address filters to handle a port's multicast 877 * and secondary unicast MAC addresses. 878 */ 879 static int set_addr_filters(const struct net_device *dev, bool sleep) 880 { 881 u64 mhash = 0; 882 u64 uhash = 0; 883 bool free = true; 884 unsigned int offset, naddr; 885 const u8 *addr[7]; 886 int ret; 887 const struct port_info *pi = netdev_priv(dev); 888 889 /* first do the secondary unicast addresses */ 890 for (offset = 0; ; offset += naddr) { 891 naddr = collect_netdev_uc_list_addrs(dev, addr, offset, 892 ARRAY_SIZE(addr)); 893 if (naddr == 0) 894 break; 895 896 ret = t4vf_alloc_mac_filt(pi->adapter, pi->viid, free, 897 naddr, addr, NULL, &uhash, sleep); 898 if (ret < 0) 899 return ret; 900 901 free = false; 902 } 903 904 /* next set up the multicast addresses */ 905 for (offset = 0; ; offset += naddr) { 906 naddr = collect_netdev_mc_list_addrs(dev, addr, offset, 907 ARRAY_SIZE(addr)); 908 if (naddr == 0) 909 break; 910 911 ret = t4vf_alloc_mac_filt(pi->adapter, pi->viid, free, 912 naddr, addr, NULL, &mhash, sleep); 913 if (ret < 0) 914 return ret; 915 free = false; 916 } 917 918 return t4vf_set_addr_hash(pi->adapter, pi->viid, uhash != 0, 919 uhash | mhash, sleep); 920 } 921 922 /* 923 * Set RX properties of a port, such as promiscruity, address filters, and MTU. 924 * If @mtu is -1 it is left unchanged. 925 */ 926 static int set_rxmode(struct net_device *dev, int mtu, bool sleep_ok) 927 { 928 int ret; 929 struct port_info *pi = netdev_priv(dev); 930 931 ret = set_addr_filters(dev, sleep_ok); 932 if (ret == 0) 933 ret = t4vf_set_rxmode(pi->adapter, pi->viid, -1, 934 (dev->flags & IFF_PROMISC) != 0, 935 (dev->flags & IFF_ALLMULTI) != 0, 936 1, -1, sleep_ok); 937 return ret; 938 } 939 940 /* 941 * Set the current receive modes on the device. 942 */ 943 static void cxgb4vf_set_rxmode(struct net_device *dev) 944 { 945 /* unfortunately we can't return errors to the stack */ 946 set_rxmode(dev, -1, false); 947 } 948 949 /* 950 * Find the entry in the interrupt holdoff timer value array which comes 951 * closest to the specified interrupt holdoff value. 952 */ 953 static int closest_timer(const struct sge *s, int us) 954 { 955 int i, timer_idx = 0, min_delta = INT_MAX; 956 957 for (i = 0; i < ARRAY_SIZE(s->timer_val); i++) { 958 int delta = us - s->timer_val[i]; 959 if (delta < 0) 960 delta = -delta; 961 if (delta < min_delta) { 962 min_delta = delta; 963 timer_idx = i; 964 } 965 } 966 return timer_idx; 967 } 968 969 static int closest_thres(const struct sge *s, int thres) 970 { 971 int i, delta, pktcnt_idx = 0, min_delta = INT_MAX; 972 973 for (i = 0; i < ARRAY_SIZE(s->counter_val); i++) { 974 delta = thres - s->counter_val[i]; 975 if (delta < 0) 976 delta = -delta; 977 if (delta < min_delta) { 978 min_delta = delta; 979 pktcnt_idx = i; 980 } 981 } 982 return pktcnt_idx; 983 } 984 985 /* 986 * Return a queue's interrupt hold-off time in us. 0 means no timer. 987 */ 988 static unsigned int qtimer_val(const struct adapter *adapter, 989 const struct sge_rspq *rspq) 990 { 991 unsigned int timer_idx = QINTR_TIMER_IDX_GET(rspq->intr_params); 992 993 return timer_idx < SGE_NTIMERS 994 ? adapter->sge.timer_val[timer_idx] 995 : 0; 996 } 997 998 /** 999 * set_rxq_intr_params - set a queue's interrupt holdoff parameters 1000 * @adapter: the adapter 1001 * @rspq: the RX response queue 1002 * @us: the hold-off time in us, or 0 to disable timer 1003 * @cnt: the hold-off packet count, or 0 to disable counter 1004 * 1005 * Sets an RX response queue's interrupt hold-off time and packet count. 1006 * At least one of the two needs to be enabled for the queue to generate 1007 * interrupts. 1008 */ 1009 static int set_rxq_intr_params(struct adapter *adapter, struct sge_rspq *rspq, 1010 unsigned int us, unsigned int cnt) 1011 { 1012 unsigned int timer_idx; 1013 1014 /* 1015 * If both the interrupt holdoff timer and count are specified as 1016 * zero, default to a holdoff count of 1 ... 1017 */ 1018 if ((us | cnt) == 0) 1019 cnt = 1; 1020 1021 /* 1022 * If an interrupt holdoff count has been specified, then find the 1023 * closest configured holdoff count and use that. If the response 1024 * queue has already been created, then update its queue context 1025 * parameters ... 1026 */ 1027 if (cnt) { 1028 int err; 1029 u32 v, pktcnt_idx; 1030 1031 pktcnt_idx = closest_thres(&adapter->sge, cnt); 1032 if (rspq->desc && rspq->pktcnt_idx != pktcnt_idx) { 1033 v = FW_PARAMS_MNEM(FW_PARAMS_MNEM_DMAQ) | 1034 FW_PARAMS_PARAM_X( 1035 FW_PARAMS_PARAM_DMAQ_IQ_INTCNTTHRESH) | 1036 FW_PARAMS_PARAM_YZ(rspq->cntxt_id); 1037 err = t4vf_set_params(adapter, 1, &v, &pktcnt_idx); 1038 if (err) 1039 return err; 1040 } 1041 rspq->pktcnt_idx = pktcnt_idx; 1042 } 1043 1044 /* 1045 * Compute the closest holdoff timer index from the supplied holdoff 1046 * timer value. 1047 */ 1048 timer_idx = (us == 0 1049 ? SGE_TIMER_RSTRT_CNTR 1050 : closest_timer(&adapter->sge, us)); 1051 1052 /* 1053 * Update the response queue's interrupt coalescing parameters and 1054 * return success. 1055 */ 1056 rspq->intr_params = (QINTR_TIMER_IDX(timer_idx) | 1057 (cnt > 0 ? QINTR_CNT_EN : 0)); 1058 return 0; 1059 } 1060 1061 /* 1062 * Return a version number to identify the type of adapter. The scheme is: 1063 * - bits 0..9: chip version 1064 * - bits 10..15: chip revision 1065 */ 1066 static inline unsigned int mk_adap_vers(const struct adapter *adapter) 1067 { 1068 /* 1069 * Chip version 4, revision 0x3f (cxgb4vf). 1070 */ 1071 return CHELSIO_CHIP_VERSION(adapter->params.chip) | (0x3f << 10); 1072 } 1073 1074 /* 1075 * Execute the specified ioctl command. 1076 */ 1077 static int cxgb4vf_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 1078 { 1079 int ret = 0; 1080 1081 switch (cmd) { 1082 /* 1083 * The VF Driver doesn't have access to any of the other 1084 * common Ethernet device ioctl()'s (like reading/writing 1085 * PHY registers, etc. 1086 */ 1087 1088 default: 1089 ret = -EOPNOTSUPP; 1090 break; 1091 } 1092 return ret; 1093 } 1094 1095 /* 1096 * Change the device's MTU. 1097 */ 1098 static int cxgb4vf_change_mtu(struct net_device *dev, int new_mtu) 1099 { 1100 int ret; 1101 struct port_info *pi = netdev_priv(dev); 1102 1103 /* accommodate SACK */ 1104 if (new_mtu < 81) 1105 return -EINVAL; 1106 1107 ret = t4vf_set_rxmode(pi->adapter, pi->viid, new_mtu, 1108 -1, -1, -1, -1, true); 1109 if (!ret) 1110 dev->mtu = new_mtu; 1111 return ret; 1112 } 1113 1114 static netdev_features_t cxgb4vf_fix_features(struct net_device *dev, 1115 netdev_features_t features) 1116 { 1117 /* 1118 * Since there is no support for separate rx/tx vlan accel 1119 * enable/disable make sure tx flag is always in same state as rx. 1120 */ 1121 if (features & NETIF_F_HW_VLAN_CTAG_RX) 1122 features |= NETIF_F_HW_VLAN_CTAG_TX; 1123 else 1124 features &= ~NETIF_F_HW_VLAN_CTAG_TX; 1125 1126 return features; 1127 } 1128 1129 static int cxgb4vf_set_features(struct net_device *dev, 1130 netdev_features_t features) 1131 { 1132 struct port_info *pi = netdev_priv(dev); 1133 netdev_features_t changed = dev->features ^ features; 1134 1135 if (changed & NETIF_F_HW_VLAN_CTAG_RX) 1136 t4vf_set_rxmode(pi->adapter, pi->viid, -1, -1, -1, -1, 1137 features & NETIF_F_HW_VLAN_CTAG_TX, 0); 1138 1139 return 0; 1140 } 1141 1142 /* 1143 * Change the devices MAC address. 1144 */ 1145 static int cxgb4vf_set_mac_addr(struct net_device *dev, void *_addr) 1146 { 1147 int ret; 1148 struct sockaddr *addr = _addr; 1149 struct port_info *pi = netdev_priv(dev); 1150 1151 if (!is_valid_ether_addr(addr->sa_data)) 1152 return -EADDRNOTAVAIL; 1153 1154 ret = t4vf_change_mac(pi->adapter, pi->viid, pi->xact_addr_filt, 1155 addr->sa_data, true); 1156 if (ret < 0) 1157 return ret; 1158 1159 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len); 1160 pi->xact_addr_filt = ret; 1161 return 0; 1162 } 1163 1164 #ifdef CONFIG_NET_POLL_CONTROLLER 1165 /* 1166 * Poll all of our receive queues. This is called outside of normal interrupt 1167 * context. 1168 */ 1169 static void cxgb4vf_poll_controller(struct net_device *dev) 1170 { 1171 struct port_info *pi = netdev_priv(dev); 1172 struct adapter *adapter = pi->adapter; 1173 1174 if (adapter->flags & USING_MSIX) { 1175 struct sge_eth_rxq *rxq; 1176 int nqsets; 1177 1178 rxq = &adapter->sge.ethrxq[pi->first_qset]; 1179 for (nqsets = pi->nqsets; nqsets; nqsets--) { 1180 t4vf_sge_intr_msix(0, &rxq->rspq); 1181 rxq++; 1182 } 1183 } else 1184 t4vf_intr_handler(adapter)(0, adapter); 1185 } 1186 #endif 1187 1188 /* 1189 * Ethtool operations. 1190 * =================== 1191 * 1192 * Note that we don't support any ethtool operations which change the physical 1193 * state of the port to which we're linked. 1194 */ 1195 1196 /* 1197 * Return current port link settings. 1198 */ 1199 static int cxgb4vf_get_settings(struct net_device *dev, 1200 struct ethtool_cmd *cmd) 1201 { 1202 const struct port_info *pi = netdev_priv(dev); 1203 1204 cmd->supported = pi->link_cfg.supported; 1205 cmd->advertising = pi->link_cfg.advertising; 1206 ethtool_cmd_speed_set(cmd, 1207 netif_carrier_ok(dev) ? pi->link_cfg.speed : -1); 1208 cmd->duplex = DUPLEX_FULL; 1209 1210 cmd->port = (cmd->supported & SUPPORTED_TP) ? PORT_TP : PORT_FIBRE; 1211 cmd->phy_address = pi->port_id; 1212 cmd->transceiver = XCVR_EXTERNAL; 1213 cmd->autoneg = pi->link_cfg.autoneg; 1214 cmd->maxtxpkt = 0; 1215 cmd->maxrxpkt = 0; 1216 return 0; 1217 } 1218 1219 /* 1220 * Return our driver information. 1221 */ 1222 static void cxgb4vf_get_drvinfo(struct net_device *dev, 1223 struct ethtool_drvinfo *drvinfo) 1224 { 1225 struct adapter *adapter = netdev2adap(dev); 1226 1227 strlcpy(drvinfo->driver, KBUILD_MODNAME, sizeof(drvinfo->driver)); 1228 strlcpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version)); 1229 strlcpy(drvinfo->bus_info, pci_name(to_pci_dev(dev->dev.parent)), 1230 sizeof(drvinfo->bus_info)); 1231 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), 1232 "%u.%u.%u.%u, TP %u.%u.%u.%u", 1233 FW_HDR_FW_VER_MAJOR_GET(adapter->params.dev.fwrev), 1234 FW_HDR_FW_VER_MINOR_GET(adapter->params.dev.fwrev), 1235 FW_HDR_FW_VER_MICRO_GET(adapter->params.dev.fwrev), 1236 FW_HDR_FW_VER_BUILD_GET(adapter->params.dev.fwrev), 1237 FW_HDR_FW_VER_MAJOR_GET(adapter->params.dev.tprev), 1238 FW_HDR_FW_VER_MINOR_GET(adapter->params.dev.tprev), 1239 FW_HDR_FW_VER_MICRO_GET(adapter->params.dev.tprev), 1240 FW_HDR_FW_VER_BUILD_GET(adapter->params.dev.tprev)); 1241 } 1242 1243 /* 1244 * Return current adapter message level. 1245 */ 1246 static u32 cxgb4vf_get_msglevel(struct net_device *dev) 1247 { 1248 return netdev2adap(dev)->msg_enable; 1249 } 1250 1251 /* 1252 * Set current adapter message level. 1253 */ 1254 static void cxgb4vf_set_msglevel(struct net_device *dev, u32 msglevel) 1255 { 1256 netdev2adap(dev)->msg_enable = msglevel; 1257 } 1258 1259 /* 1260 * Return the device's current Queue Set ring size parameters along with the 1261 * allowed maximum values. Since ethtool doesn't understand the concept of 1262 * multi-queue devices, we just return the current values associated with the 1263 * first Queue Set. 1264 */ 1265 static void cxgb4vf_get_ringparam(struct net_device *dev, 1266 struct ethtool_ringparam *rp) 1267 { 1268 const struct port_info *pi = netdev_priv(dev); 1269 const struct sge *s = &pi->adapter->sge; 1270 1271 rp->rx_max_pending = MAX_RX_BUFFERS; 1272 rp->rx_mini_max_pending = MAX_RSPQ_ENTRIES; 1273 rp->rx_jumbo_max_pending = 0; 1274 rp->tx_max_pending = MAX_TXQ_ENTRIES; 1275 1276 rp->rx_pending = s->ethrxq[pi->first_qset].fl.size - MIN_FL_RESID; 1277 rp->rx_mini_pending = s->ethrxq[pi->first_qset].rspq.size; 1278 rp->rx_jumbo_pending = 0; 1279 rp->tx_pending = s->ethtxq[pi->first_qset].q.size; 1280 } 1281 1282 /* 1283 * Set the Queue Set ring size parameters for the device. Again, since 1284 * ethtool doesn't allow for the concept of multiple queues per device, we'll 1285 * apply these new values across all of the Queue Sets associated with the 1286 * device -- after vetting them of course! 1287 */ 1288 static int cxgb4vf_set_ringparam(struct net_device *dev, 1289 struct ethtool_ringparam *rp) 1290 { 1291 const struct port_info *pi = netdev_priv(dev); 1292 struct adapter *adapter = pi->adapter; 1293 struct sge *s = &adapter->sge; 1294 int qs; 1295 1296 if (rp->rx_pending > MAX_RX_BUFFERS || 1297 rp->rx_jumbo_pending || 1298 rp->tx_pending > MAX_TXQ_ENTRIES || 1299 rp->rx_mini_pending > MAX_RSPQ_ENTRIES || 1300 rp->rx_mini_pending < MIN_RSPQ_ENTRIES || 1301 rp->rx_pending < MIN_FL_ENTRIES || 1302 rp->tx_pending < MIN_TXQ_ENTRIES) 1303 return -EINVAL; 1304 1305 if (adapter->flags & FULL_INIT_DONE) 1306 return -EBUSY; 1307 1308 for (qs = pi->first_qset; qs < pi->first_qset + pi->nqsets; qs++) { 1309 s->ethrxq[qs].fl.size = rp->rx_pending + MIN_FL_RESID; 1310 s->ethrxq[qs].rspq.size = rp->rx_mini_pending; 1311 s->ethtxq[qs].q.size = rp->tx_pending; 1312 } 1313 return 0; 1314 } 1315 1316 /* 1317 * Return the interrupt holdoff timer and count for the first Queue Set on the 1318 * device. Our extension ioctl() (the cxgbtool interface) allows the 1319 * interrupt holdoff timer to be read on all of the device's Queue Sets. 1320 */ 1321 static int cxgb4vf_get_coalesce(struct net_device *dev, 1322 struct ethtool_coalesce *coalesce) 1323 { 1324 const struct port_info *pi = netdev_priv(dev); 1325 const struct adapter *adapter = pi->adapter; 1326 const struct sge_rspq *rspq = &adapter->sge.ethrxq[pi->first_qset].rspq; 1327 1328 coalesce->rx_coalesce_usecs = qtimer_val(adapter, rspq); 1329 coalesce->rx_max_coalesced_frames = 1330 ((rspq->intr_params & QINTR_CNT_EN) 1331 ? adapter->sge.counter_val[rspq->pktcnt_idx] 1332 : 0); 1333 return 0; 1334 } 1335 1336 /* 1337 * Set the RX interrupt holdoff timer and count for the first Queue Set on the 1338 * interface. Our extension ioctl() (the cxgbtool interface) allows us to set 1339 * the interrupt holdoff timer on any of the device's Queue Sets. 1340 */ 1341 static int cxgb4vf_set_coalesce(struct net_device *dev, 1342 struct ethtool_coalesce *coalesce) 1343 { 1344 const struct port_info *pi = netdev_priv(dev); 1345 struct adapter *adapter = pi->adapter; 1346 1347 return set_rxq_intr_params(adapter, 1348 &adapter->sge.ethrxq[pi->first_qset].rspq, 1349 coalesce->rx_coalesce_usecs, 1350 coalesce->rx_max_coalesced_frames); 1351 } 1352 1353 /* 1354 * Report current port link pause parameter settings. 1355 */ 1356 static void cxgb4vf_get_pauseparam(struct net_device *dev, 1357 struct ethtool_pauseparam *pauseparam) 1358 { 1359 struct port_info *pi = netdev_priv(dev); 1360 1361 pauseparam->autoneg = (pi->link_cfg.requested_fc & PAUSE_AUTONEG) != 0; 1362 pauseparam->rx_pause = (pi->link_cfg.fc & PAUSE_RX) != 0; 1363 pauseparam->tx_pause = (pi->link_cfg.fc & PAUSE_TX) != 0; 1364 } 1365 1366 /* 1367 * Identify the port by blinking the port's LED. 1368 */ 1369 static int cxgb4vf_phys_id(struct net_device *dev, 1370 enum ethtool_phys_id_state state) 1371 { 1372 unsigned int val; 1373 struct port_info *pi = netdev_priv(dev); 1374 1375 if (state == ETHTOOL_ID_ACTIVE) 1376 val = 0xffff; 1377 else if (state == ETHTOOL_ID_INACTIVE) 1378 val = 0; 1379 else 1380 return -EINVAL; 1381 1382 return t4vf_identify_port(pi->adapter, pi->viid, val); 1383 } 1384 1385 /* 1386 * Port stats maintained per queue of the port. 1387 */ 1388 struct queue_port_stats { 1389 u64 tso; 1390 u64 tx_csum; 1391 u64 rx_csum; 1392 u64 vlan_ex; 1393 u64 vlan_ins; 1394 u64 lro_pkts; 1395 u64 lro_merged; 1396 }; 1397 1398 /* 1399 * Strings for the ETH_SS_STATS statistics set ("ethtool -S"). Note that 1400 * these need to match the order of statistics returned by 1401 * t4vf_get_port_stats(). 1402 */ 1403 static const char stats_strings[][ETH_GSTRING_LEN] = { 1404 /* 1405 * These must match the layout of the t4vf_port_stats structure. 1406 */ 1407 "TxBroadcastBytes ", 1408 "TxBroadcastFrames ", 1409 "TxMulticastBytes ", 1410 "TxMulticastFrames ", 1411 "TxUnicastBytes ", 1412 "TxUnicastFrames ", 1413 "TxDroppedFrames ", 1414 "TxOffloadBytes ", 1415 "TxOffloadFrames ", 1416 "RxBroadcastBytes ", 1417 "RxBroadcastFrames ", 1418 "RxMulticastBytes ", 1419 "RxMulticastFrames ", 1420 "RxUnicastBytes ", 1421 "RxUnicastFrames ", 1422 "RxErrorFrames ", 1423 1424 /* 1425 * These are accumulated per-queue statistics and must match the 1426 * order of the fields in the queue_port_stats structure. 1427 */ 1428 "TSO ", 1429 "TxCsumOffload ", 1430 "RxCsumGood ", 1431 "VLANextractions ", 1432 "VLANinsertions ", 1433 "GROPackets ", 1434 "GROMerged ", 1435 }; 1436 1437 /* 1438 * Return the number of statistics in the specified statistics set. 1439 */ 1440 static int cxgb4vf_get_sset_count(struct net_device *dev, int sset) 1441 { 1442 switch (sset) { 1443 case ETH_SS_STATS: 1444 return ARRAY_SIZE(stats_strings); 1445 default: 1446 return -EOPNOTSUPP; 1447 } 1448 /*NOTREACHED*/ 1449 } 1450 1451 /* 1452 * Return the strings for the specified statistics set. 1453 */ 1454 static void cxgb4vf_get_strings(struct net_device *dev, 1455 u32 sset, 1456 u8 *data) 1457 { 1458 switch (sset) { 1459 case ETH_SS_STATS: 1460 memcpy(data, stats_strings, sizeof(stats_strings)); 1461 break; 1462 } 1463 } 1464 1465 /* 1466 * Small utility routine to accumulate queue statistics across the queues of 1467 * a "port". 1468 */ 1469 static void collect_sge_port_stats(const struct adapter *adapter, 1470 const struct port_info *pi, 1471 struct queue_port_stats *stats) 1472 { 1473 const struct sge_eth_txq *txq = &adapter->sge.ethtxq[pi->first_qset]; 1474 const struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[pi->first_qset]; 1475 int qs; 1476 1477 memset(stats, 0, sizeof(*stats)); 1478 for (qs = 0; qs < pi->nqsets; qs++, rxq++, txq++) { 1479 stats->tso += txq->tso; 1480 stats->tx_csum += txq->tx_cso; 1481 stats->rx_csum += rxq->stats.rx_cso; 1482 stats->vlan_ex += rxq->stats.vlan_ex; 1483 stats->vlan_ins += txq->vlan_ins; 1484 stats->lro_pkts += rxq->stats.lro_pkts; 1485 stats->lro_merged += rxq->stats.lro_merged; 1486 } 1487 } 1488 1489 /* 1490 * Return the ETH_SS_STATS statistics set. 1491 */ 1492 static void cxgb4vf_get_ethtool_stats(struct net_device *dev, 1493 struct ethtool_stats *stats, 1494 u64 *data) 1495 { 1496 struct port_info *pi = netdev2pinfo(dev); 1497 struct adapter *adapter = pi->adapter; 1498 int err = t4vf_get_port_stats(adapter, pi->pidx, 1499 (struct t4vf_port_stats *)data); 1500 if (err) 1501 memset(data, 0, sizeof(struct t4vf_port_stats)); 1502 1503 data += sizeof(struct t4vf_port_stats) / sizeof(u64); 1504 collect_sge_port_stats(adapter, pi, (struct queue_port_stats *)data); 1505 } 1506 1507 /* 1508 * Return the size of our register map. 1509 */ 1510 static int cxgb4vf_get_regs_len(struct net_device *dev) 1511 { 1512 return T4VF_REGMAP_SIZE; 1513 } 1514 1515 /* 1516 * Dump a block of registers, start to end inclusive, into a buffer. 1517 */ 1518 static void reg_block_dump(struct adapter *adapter, void *regbuf, 1519 unsigned int start, unsigned int end) 1520 { 1521 u32 *bp = regbuf + start - T4VF_REGMAP_START; 1522 1523 for ( ; start <= end; start += sizeof(u32)) { 1524 /* 1525 * Avoid reading the Mailbox Control register since that 1526 * can trigger a Mailbox Ownership Arbitration cycle and 1527 * interfere with communication with the firmware. 1528 */ 1529 if (start == T4VF_CIM_BASE_ADDR + CIM_VF_EXT_MAILBOX_CTRL) 1530 *bp++ = 0xffff; 1531 else 1532 *bp++ = t4_read_reg(adapter, start); 1533 } 1534 } 1535 1536 /* 1537 * Copy our entire register map into the provided buffer. 1538 */ 1539 static void cxgb4vf_get_regs(struct net_device *dev, 1540 struct ethtool_regs *regs, 1541 void *regbuf) 1542 { 1543 struct adapter *adapter = netdev2adap(dev); 1544 1545 regs->version = mk_adap_vers(adapter); 1546 1547 /* 1548 * Fill in register buffer with our register map. 1549 */ 1550 memset(regbuf, 0, T4VF_REGMAP_SIZE); 1551 1552 reg_block_dump(adapter, regbuf, 1553 T4VF_SGE_BASE_ADDR + T4VF_MOD_MAP_SGE_FIRST, 1554 T4VF_SGE_BASE_ADDR + T4VF_MOD_MAP_SGE_LAST); 1555 reg_block_dump(adapter, regbuf, 1556 T4VF_MPS_BASE_ADDR + T4VF_MOD_MAP_MPS_FIRST, 1557 T4VF_MPS_BASE_ADDR + T4VF_MOD_MAP_MPS_LAST); 1558 1559 /* T5 adds new registers in the PL Register map. 1560 */ 1561 reg_block_dump(adapter, regbuf, 1562 T4VF_PL_BASE_ADDR + T4VF_MOD_MAP_PL_FIRST, 1563 T4VF_PL_BASE_ADDR + (is_t4(adapter->params.chip) 1564 ? A_PL_VF_WHOAMI : A_PL_VF_REVISION)); 1565 reg_block_dump(adapter, regbuf, 1566 T4VF_CIM_BASE_ADDR + T4VF_MOD_MAP_CIM_FIRST, 1567 T4VF_CIM_BASE_ADDR + T4VF_MOD_MAP_CIM_LAST); 1568 1569 reg_block_dump(adapter, regbuf, 1570 T4VF_MBDATA_BASE_ADDR + T4VF_MBDATA_FIRST, 1571 T4VF_MBDATA_BASE_ADDR + T4VF_MBDATA_LAST); 1572 } 1573 1574 /* 1575 * Report current Wake On LAN settings. 1576 */ 1577 static void cxgb4vf_get_wol(struct net_device *dev, 1578 struct ethtool_wolinfo *wol) 1579 { 1580 wol->supported = 0; 1581 wol->wolopts = 0; 1582 memset(&wol->sopass, 0, sizeof(wol->sopass)); 1583 } 1584 1585 /* 1586 * TCP Segmentation Offload flags which we support. 1587 */ 1588 #define TSO_FLAGS (NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN) 1589 1590 static const struct ethtool_ops cxgb4vf_ethtool_ops = { 1591 .get_settings = cxgb4vf_get_settings, 1592 .get_drvinfo = cxgb4vf_get_drvinfo, 1593 .get_msglevel = cxgb4vf_get_msglevel, 1594 .set_msglevel = cxgb4vf_set_msglevel, 1595 .get_ringparam = cxgb4vf_get_ringparam, 1596 .set_ringparam = cxgb4vf_set_ringparam, 1597 .get_coalesce = cxgb4vf_get_coalesce, 1598 .set_coalesce = cxgb4vf_set_coalesce, 1599 .get_pauseparam = cxgb4vf_get_pauseparam, 1600 .get_link = ethtool_op_get_link, 1601 .get_strings = cxgb4vf_get_strings, 1602 .set_phys_id = cxgb4vf_phys_id, 1603 .get_sset_count = cxgb4vf_get_sset_count, 1604 .get_ethtool_stats = cxgb4vf_get_ethtool_stats, 1605 .get_regs_len = cxgb4vf_get_regs_len, 1606 .get_regs = cxgb4vf_get_regs, 1607 .get_wol = cxgb4vf_get_wol, 1608 }; 1609 1610 /* 1611 * /sys/kernel/debug/cxgb4vf support code and data. 1612 * ================================================ 1613 */ 1614 1615 /* 1616 * Show SGE Queue Set information. We display QPL Queues Sets per line. 1617 */ 1618 #define QPL 4 1619 1620 static int sge_qinfo_show(struct seq_file *seq, void *v) 1621 { 1622 struct adapter *adapter = seq->private; 1623 int eth_entries = DIV_ROUND_UP(adapter->sge.ethqsets, QPL); 1624 int qs, r = (uintptr_t)v - 1; 1625 1626 if (r) 1627 seq_putc(seq, '\n'); 1628 1629 #define S3(fmt_spec, s, v) \ 1630 do {\ 1631 seq_printf(seq, "%-12s", s); \ 1632 for (qs = 0; qs < n; ++qs) \ 1633 seq_printf(seq, " %16" fmt_spec, v); \ 1634 seq_putc(seq, '\n'); \ 1635 } while (0) 1636 #define S(s, v) S3("s", s, v) 1637 #define T(s, v) S3("u", s, txq[qs].v) 1638 #define R(s, v) S3("u", s, rxq[qs].v) 1639 1640 if (r < eth_entries) { 1641 const struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[r * QPL]; 1642 const struct sge_eth_txq *txq = &adapter->sge.ethtxq[r * QPL]; 1643 int n = min(QPL, adapter->sge.ethqsets - QPL * r); 1644 1645 S("QType:", "Ethernet"); 1646 S("Interface:", 1647 (rxq[qs].rspq.netdev 1648 ? rxq[qs].rspq.netdev->name 1649 : "N/A")); 1650 S3("d", "Port:", 1651 (rxq[qs].rspq.netdev 1652 ? ((struct port_info *) 1653 netdev_priv(rxq[qs].rspq.netdev))->port_id 1654 : -1)); 1655 T("TxQ ID:", q.abs_id); 1656 T("TxQ size:", q.size); 1657 T("TxQ inuse:", q.in_use); 1658 T("TxQ PIdx:", q.pidx); 1659 T("TxQ CIdx:", q.cidx); 1660 R("RspQ ID:", rspq.abs_id); 1661 R("RspQ size:", rspq.size); 1662 R("RspQE size:", rspq.iqe_len); 1663 S3("u", "Intr delay:", qtimer_val(adapter, &rxq[qs].rspq)); 1664 S3("u", "Intr pktcnt:", 1665 adapter->sge.counter_val[rxq[qs].rspq.pktcnt_idx]); 1666 R("RspQ CIdx:", rspq.cidx); 1667 R("RspQ Gen:", rspq.gen); 1668 R("FL ID:", fl.abs_id); 1669 R("FL size:", fl.size - MIN_FL_RESID); 1670 R("FL avail:", fl.avail); 1671 R("FL PIdx:", fl.pidx); 1672 R("FL CIdx:", fl.cidx); 1673 return 0; 1674 } 1675 1676 r -= eth_entries; 1677 if (r == 0) { 1678 const struct sge_rspq *evtq = &adapter->sge.fw_evtq; 1679 1680 seq_printf(seq, "%-12s %16s\n", "QType:", "FW event queue"); 1681 seq_printf(seq, "%-12s %16u\n", "RspQ ID:", evtq->abs_id); 1682 seq_printf(seq, "%-12s %16u\n", "Intr delay:", 1683 qtimer_val(adapter, evtq)); 1684 seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:", 1685 adapter->sge.counter_val[evtq->pktcnt_idx]); 1686 seq_printf(seq, "%-12s %16u\n", "RspQ Cidx:", evtq->cidx); 1687 seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", evtq->gen); 1688 } else if (r == 1) { 1689 const struct sge_rspq *intrq = &adapter->sge.intrq; 1690 1691 seq_printf(seq, "%-12s %16s\n", "QType:", "Interrupt Queue"); 1692 seq_printf(seq, "%-12s %16u\n", "RspQ ID:", intrq->abs_id); 1693 seq_printf(seq, "%-12s %16u\n", "Intr delay:", 1694 qtimer_val(adapter, intrq)); 1695 seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:", 1696 adapter->sge.counter_val[intrq->pktcnt_idx]); 1697 seq_printf(seq, "%-12s %16u\n", "RspQ Cidx:", intrq->cidx); 1698 seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", intrq->gen); 1699 } 1700 1701 #undef R 1702 #undef T 1703 #undef S 1704 #undef S3 1705 1706 return 0; 1707 } 1708 1709 /* 1710 * Return the number of "entries" in our "file". We group the multi-Queue 1711 * sections with QPL Queue Sets per "entry". The sections of the output are: 1712 * 1713 * Ethernet RX/TX Queue Sets 1714 * Firmware Event Queue 1715 * Forwarded Interrupt Queue (if in MSI mode) 1716 */ 1717 static int sge_queue_entries(const struct adapter *adapter) 1718 { 1719 return DIV_ROUND_UP(adapter->sge.ethqsets, QPL) + 1 + 1720 ((adapter->flags & USING_MSI) != 0); 1721 } 1722 1723 static void *sge_queue_start(struct seq_file *seq, loff_t *pos) 1724 { 1725 int entries = sge_queue_entries(seq->private); 1726 1727 return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL; 1728 } 1729 1730 static void sge_queue_stop(struct seq_file *seq, void *v) 1731 { 1732 } 1733 1734 static void *sge_queue_next(struct seq_file *seq, void *v, loff_t *pos) 1735 { 1736 int entries = sge_queue_entries(seq->private); 1737 1738 ++*pos; 1739 return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL; 1740 } 1741 1742 static const struct seq_operations sge_qinfo_seq_ops = { 1743 .start = sge_queue_start, 1744 .next = sge_queue_next, 1745 .stop = sge_queue_stop, 1746 .show = sge_qinfo_show 1747 }; 1748 1749 static int sge_qinfo_open(struct inode *inode, struct file *file) 1750 { 1751 int res = seq_open(file, &sge_qinfo_seq_ops); 1752 1753 if (!res) { 1754 struct seq_file *seq = file->private_data; 1755 seq->private = inode->i_private; 1756 } 1757 return res; 1758 } 1759 1760 static const struct file_operations sge_qinfo_debugfs_fops = { 1761 .owner = THIS_MODULE, 1762 .open = sge_qinfo_open, 1763 .read = seq_read, 1764 .llseek = seq_lseek, 1765 .release = seq_release, 1766 }; 1767 1768 /* 1769 * Show SGE Queue Set statistics. We display QPL Queues Sets per line. 1770 */ 1771 #define QPL 4 1772 1773 static int sge_qstats_show(struct seq_file *seq, void *v) 1774 { 1775 struct adapter *adapter = seq->private; 1776 int eth_entries = DIV_ROUND_UP(adapter->sge.ethqsets, QPL); 1777 int qs, r = (uintptr_t)v - 1; 1778 1779 if (r) 1780 seq_putc(seq, '\n'); 1781 1782 #define S3(fmt, s, v) \ 1783 do { \ 1784 seq_printf(seq, "%-16s", s); \ 1785 for (qs = 0; qs < n; ++qs) \ 1786 seq_printf(seq, " %8" fmt, v); \ 1787 seq_putc(seq, '\n'); \ 1788 } while (0) 1789 #define S(s, v) S3("s", s, v) 1790 1791 #define T3(fmt, s, v) S3(fmt, s, txq[qs].v) 1792 #define T(s, v) T3("lu", s, v) 1793 1794 #define R3(fmt, s, v) S3(fmt, s, rxq[qs].v) 1795 #define R(s, v) R3("lu", s, v) 1796 1797 if (r < eth_entries) { 1798 const struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[r * QPL]; 1799 const struct sge_eth_txq *txq = &adapter->sge.ethtxq[r * QPL]; 1800 int n = min(QPL, adapter->sge.ethqsets - QPL * r); 1801 1802 S("QType:", "Ethernet"); 1803 S("Interface:", 1804 (rxq[qs].rspq.netdev 1805 ? rxq[qs].rspq.netdev->name 1806 : "N/A")); 1807 R3("u", "RspQNullInts:", rspq.unhandled_irqs); 1808 R("RxPackets:", stats.pkts); 1809 R("RxCSO:", stats.rx_cso); 1810 R("VLANxtract:", stats.vlan_ex); 1811 R("LROmerged:", stats.lro_merged); 1812 R("LROpackets:", stats.lro_pkts); 1813 R("RxDrops:", stats.rx_drops); 1814 T("TSO:", tso); 1815 T("TxCSO:", tx_cso); 1816 T("VLANins:", vlan_ins); 1817 T("TxQFull:", q.stops); 1818 T("TxQRestarts:", q.restarts); 1819 T("TxMapErr:", mapping_err); 1820 R("FLAllocErr:", fl.alloc_failed); 1821 R("FLLrgAlcErr:", fl.large_alloc_failed); 1822 R("FLStarving:", fl.starving); 1823 return 0; 1824 } 1825 1826 r -= eth_entries; 1827 if (r == 0) { 1828 const struct sge_rspq *evtq = &adapter->sge.fw_evtq; 1829 1830 seq_printf(seq, "%-8s %16s\n", "QType:", "FW event queue"); 1831 seq_printf(seq, "%-16s %8u\n", "RspQNullInts:", 1832 evtq->unhandled_irqs); 1833 seq_printf(seq, "%-16s %8u\n", "RspQ CIdx:", evtq->cidx); 1834 seq_printf(seq, "%-16s %8u\n", "RspQ Gen:", evtq->gen); 1835 } else if (r == 1) { 1836 const struct sge_rspq *intrq = &adapter->sge.intrq; 1837 1838 seq_printf(seq, "%-8s %16s\n", "QType:", "Interrupt Queue"); 1839 seq_printf(seq, "%-16s %8u\n", "RspQNullInts:", 1840 intrq->unhandled_irqs); 1841 seq_printf(seq, "%-16s %8u\n", "RspQ CIdx:", intrq->cidx); 1842 seq_printf(seq, "%-16s %8u\n", "RspQ Gen:", intrq->gen); 1843 } 1844 1845 #undef R 1846 #undef T 1847 #undef S 1848 #undef R3 1849 #undef T3 1850 #undef S3 1851 1852 return 0; 1853 } 1854 1855 /* 1856 * Return the number of "entries" in our "file". We group the multi-Queue 1857 * sections with QPL Queue Sets per "entry". The sections of the output are: 1858 * 1859 * Ethernet RX/TX Queue Sets 1860 * Firmware Event Queue 1861 * Forwarded Interrupt Queue (if in MSI mode) 1862 */ 1863 static int sge_qstats_entries(const struct adapter *adapter) 1864 { 1865 return DIV_ROUND_UP(adapter->sge.ethqsets, QPL) + 1 + 1866 ((adapter->flags & USING_MSI) != 0); 1867 } 1868 1869 static void *sge_qstats_start(struct seq_file *seq, loff_t *pos) 1870 { 1871 int entries = sge_qstats_entries(seq->private); 1872 1873 return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL; 1874 } 1875 1876 static void sge_qstats_stop(struct seq_file *seq, void *v) 1877 { 1878 } 1879 1880 static void *sge_qstats_next(struct seq_file *seq, void *v, loff_t *pos) 1881 { 1882 int entries = sge_qstats_entries(seq->private); 1883 1884 (*pos)++; 1885 return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL; 1886 } 1887 1888 static const struct seq_operations sge_qstats_seq_ops = { 1889 .start = sge_qstats_start, 1890 .next = sge_qstats_next, 1891 .stop = sge_qstats_stop, 1892 .show = sge_qstats_show 1893 }; 1894 1895 static int sge_qstats_open(struct inode *inode, struct file *file) 1896 { 1897 int res = seq_open(file, &sge_qstats_seq_ops); 1898 1899 if (res == 0) { 1900 struct seq_file *seq = file->private_data; 1901 seq->private = inode->i_private; 1902 } 1903 return res; 1904 } 1905 1906 static const struct file_operations sge_qstats_proc_fops = { 1907 .owner = THIS_MODULE, 1908 .open = sge_qstats_open, 1909 .read = seq_read, 1910 .llseek = seq_lseek, 1911 .release = seq_release, 1912 }; 1913 1914 /* 1915 * Show PCI-E SR-IOV Virtual Function Resource Limits. 1916 */ 1917 static int resources_show(struct seq_file *seq, void *v) 1918 { 1919 struct adapter *adapter = seq->private; 1920 struct vf_resources *vfres = &adapter->params.vfres; 1921 1922 #define S(desc, fmt, var) \ 1923 seq_printf(seq, "%-60s " fmt "\n", \ 1924 desc " (" #var "):", vfres->var) 1925 1926 S("Virtual Interfaces", "%d", nvi); 1927 S("Egress Queues", "%d", neq); 1928 S("Ethernet Control", "%d", nethctrl); 1929 S("Ingress Queues/w Free Lists/Interrupts", "%d", niqflint); 1930 S("Ingress Queues", "%d", niq); 1931 S("Traffic Class", "%d", tc); 1932 S("Port Access Rights Mask", "%#x", pmask); 1933 S("MAC Address Filters", "%d", nexactf); 1934 S("Firmware Command Read Capabilities", "%#x", r_caps); 1935 S("Firmware Command Write/Execute Capabilities", "%#x", wx_caps); 1936 1937 #undef S 1938 1939 return 0; 1940 } 1941 1942 static int resources_open(struct inode *inode, struct file *file) 1943 { 1944 return single_open(file, resources_show, inode->i_private); 1945 } 1946 1947 static const struct file_operations resources_proc_fops = { 1948 .owner = THIS_MODULE, 1949 .open = resources_open, 1950 .read = seq_read, 1951 .llseek = seq_lseek, 1952 .release = single_release, 1953 }; 1954 1955 /* 1956 * Show Virtual Interfaces. 1957 */ 1958 static int interfaces_show(struct seq_file *seq, void *v) 1959 { 1960 if (v == SEQ_START_TOKEN) { 1961 seq_puts(seq, "Interface Port VIID\n"); 1962 } else { 1963 struct adapter *adapter = seq->private; 1964 int pidx = (uintptr_t)v - 2; 1965 struct net_device *dev = adapter->port[pidx]; 1966 struct port_info *pi = netdev_priv(dev); 1967 1968 seq_printf(seq, "%9s %4d %#5x\n", 1969 dev->name, pi->port_id, pi->viid); 1970 } 1971 return 0; 1972 } 1973 1974 static inline void *interfaces_get_idx(struct adapter *adapter, loff_t pos) 1975 { 1976 return pos <= adapter->params.nports 1977 ? (void *)(uintptr_t)(pos + 1) 1978 : NULL; 1979 } 1980 1981 static void *interfaces_start(struct seq_file *seq, loff_t *pos) 1982 { 1983 return *pos 1984 ? interfaces_get_idx(seq->private, *pos) 1985 : SEQ_START_TOKEN; 1986 } 1987 1988 static void *interfaces_next(struct seq_file *seq, void *v, loff_t *pos) 1989 { 1990 (*pos)++; 1991 return interfaces_get_idx(seq->private, *pos); 1992 } 1993 1994 static void interfaces_stop(struct seq_file *seq, void *v) 1995 { 1996 } 1997 1998 static const struct seq_operations interfaces_seq_ops = { 1999 .start = interfaces_start, 2000 .next = interfaces_next, 2001 .stop = interfaces_stop, 2002 .show = interfaces_show 2003 }; 2004 2005 static int interfaces_open(struct inode *inode, struct file *file) 2006 { 2007 int res = seq_open(file, &interfaces_seq_ops); 2008 2009 if (res == 0) { 2010 struct seq_file *seq = file->private_data; 2011 seq->private = inode->i_private; 2012 } 2013 return res; 2014 } 2015 2016 static const struct file_operations interfaces_proc_fops = { 2017 .owner = THIS_MODULE, 2018 .open = interfaces_open, 2019 .read = seq_read, 2020 .llseek = seq_lseek, 2021 .release = seq_release, 2022 }; 2023 2024 /* 2025 * /sys/kernel/debugfs/cxgb4vf/ files list. 2026 */ 2027 struct cxgb4vf_debugfs_entry { 2028 const char *name; /* name of debugfs node */ 2029 umode_t mode; /* file system mode */ 2030 const struct file_operations *fops; 2031 }; 2032 2033 static struct cxgb4vf_debugfs_entry debugfs_files[] = { 2034 { "sge_qinfo", S_IRUGO, &sge_qinfo_debugfs_fops }, 2035 { "sge_qstats", S_IRUGO, &sge_qstats_proc_fops }, 2036 { "resources", S_IRUGO, &resources_proc_fops }, 2037 { "interfaces", S_IRUGO, &interfaces_proc_fops }, 2038 }; 2039 2040 /* 2041 * Module and device initialization and cleanup code. 2042 * ================================================== 2043 */ 2044 2045 /* 2046 * Set up out /sys/kernel/debug/cxgb4vf sub-nodes. We assume that the 2047 * directory (debugfs_root) has already been set up. 2048 */ 2049 static int setup_debugfs(struct adapter *adapter) 2050 { 2051 int i; 2052 2053 BUG_ON(IS_ERR_OR_NULL(adapter->debugfs_root)); 2054 2055 /* 2056 * Debugfs support is best effort. 2057 */ 2058 for (i = 0; i < ARRAY_SIZE(debugfs_files); i++) 2059 (void)debugfs_create_file(debugfs_files[i].name, 2060 debugfs_files[i].mode, 2061 adapter->debugfs_root, 2062 (void *)adapter, 2063 debugfs_files[i].fops); 2064 2065 return 0; 2066 } 2067 2068 /* 2069 * Tear down the /sys/kernel/debug/cxgb4vf sub-nodes created above. We leave 2070 * it to our caller to tear down the directory (debugfs_root). 2071 */ 2072 static void cleanup_debugfs(struct adapter *adapter) 2073 { 2074 BUG_ON(IS_ERR_OR_NULL(adapter->debugfs_root)); 2075 2076 /* 2077 * Unlike our sister routine cleanup_proc(), we don't need to remove 2078 * individual entries because a call will be made to 2079 * debugfs_remove_recursive(). We just need to clean up any ancillary 2080 * persistent state. 2081 */ 2082 /* nothing to do */ 2083 } 2084 2085 /* 2086 * Perform early "adapter" initialization. This is where we discover what 2087 * adapter parameters we're going to be using and initialize basic adapter 2088 * hardware support. 2089 */ 2090 static int adap_init0(struct adapter *adapter) 2091 { 2092 struct vf_resources *vfres = &adapter->params.vfres; 2093 struct sge_params *sge_params = &adapter->params.sge; 2094 struct sge *s = &adapter->sge; 2095 unsigned int ethqsets; 2096 int err; 2097 u32 param, val = 0; 2098 unsigned int chipid; 2099 2100 /* 2101 * Wait for the device to become ready before proceeding ... 2102 */ 2103 err = t4vf_wait_dev_ready(adapter); 2104 if (err) { 2105 dev_err(adapter->pdev_dev, "device didn't become ready:" 2106 " err=%d\n", err); 2107 return err; 2108 } 2109 2110 /* 2111 * Some environments do not properly handle PCIE FLRs -- e.g. in Linux 2112 * 2.6.31 and later we can't call pci_reset_function() in order to 2113 * issue an FLR because of a self- deadlock on the device semaphore. 2114 * Meanwhile, the OS infrastructure doesn't issue FLRs in all the 2115 * cases where they're needed -- for instance, some versions of KVM 2116 * fail to reset "Assigned Devices" when the VM reboots. Therefore we 2117 * use the firmware based reset in order to reset any per function 2118 * state. 2119 */ 2120 err = t4vf_fw_reset(adapter); 2121 if (err < 0) { 2122 dev_err(adapter->pdev_dev, "FW reset failed: err=%d\n", err); 2123 return err; 2124 } 2125 2126 adapter->params.chip = 0; 2127 switch (adapter->pdev->device >> 12) { 2128 case CHELSIO_T4: 2129 adapter->params.chip = CHELSIO_CHIP_CODE(CHELSIO_T4, 0); 2130 break; 2131 case CHELSIO_T5: 2132 chipid = G_REV(t4_read_reg(adapter, A_PL_VF_REV)); 2133 adapter->params.chip |= CHELSIO_CHIP_CODE(CHELSIO_T5, chipid); 2134 break; 2135 } 2136 2137 /* 2138 * Grab basic operational parameters. These will predominantly have 2139 * been set up by the Physical Function Driver or will be hard coded 2140 * into the adapter. We just have to live with them ... Note that 2141 * we _must_ get our VPD parameters before our SGE parameters because 2142 * we need to know the adapter's core clock from the VPD in order to 2143 * properly decode the SGE Timer Values. 2144 */ 2145 err = t4vf_get_dev_params(adapter); 2146 if (err) { 2147 dev_err(adapter->pdev_dev, "unable to retrieve adapter" 2148 " device parameters: err=%d\n", err); 2149 return err; 2150 } 2151 err = t4vf_get_vpd_params(adapter); 2152 if (err) { 2153 dev_err(adapter->pdev_dev, "unable to retrieve adapter" 2154 " VPD parameters: err=%d\n", err); 2155 return err; 2156 } 2157 err = t4vf_get_sge_params(adapter); 2158 if (err) { 2159 dev_err(adapter->pdev_dev, "unable to retrieve adapter" 2160 " SGE parameters: err=%d\n", err); 2161 return err; 2162 } 2163 err = t4vf_get_rss_glb_config(adapter); 2164 if (err) { 2165 dev_err(adapter->pdev_dev, "unable to retrieve adapter" 2166 " RSS parameters: err=%d\n", err); 2167 return err; 2168 } 2169 if (adapter->params.rss.mode != 2170 FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL) { 2171 dev_err(adapter->pdev_dev, "unable to operate with global RSS" 2172 " mode %d\n", adapter->params.rss.mode); 2173 return -EINVAL; 2174 } 2175 err = t4vf_sge_init(adapter); 2176 if (err) { 2177 dev_err(adapter->pdev_dev, "unable to use adapter parameters:" 2178 " err=%d\n", err); 2179 return err; 2180 } 2181 2182 /* If we're running on newer firmware, let it know that we're 2183 * prepared to deal with encapsulated CPL messages. Older 2184 * firmware won't understand this and we'll just get 2185 * unencapsulated messages ... 2186 */ 2187 param = FW_PARAMS_MNEM(FW_PARAMS_MNEM_PFVF) | 2188 FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_PFVF_CPLFW4MSG_ENCAP); 2189 val = 1; 2190 (void) t4vf_set_params(adapter, 1, ¶m, &val); 2191 2192 /* 2193 * Retrieve our RX interrupt holdoff timer values and counter 2194 * threshold values from the SGE parameters. 2195 */ 2196 s->timer_val[0] = core_ticks_to_us(adapter, 2197 TIMERVALUE0_GET(sge_params->sge_timer_value_0_and_1)); 2198 s->timer_val[1] = core_ticks_to_us(adapter, 2199 TIMERVALUE1_GET(sge_params->sge_timer_value_0_and_1)); 2200 s->timer_val[2] = core_ticks_to_us(adapter, 2201 TIMERVALUE0_GET(sge_params->sge_timer_value_2_and_3)); 2202 s->timer_val[3] = core_ticks_to_us(adapter, 2203 TIMERVALUE1_GET(sge_params->sge_timer_value_2_and_3)); 2204 s->timer_val[4] = core_ticks_to_us(adapter, 2205 TIMERVALUE0_GET(sge_params->sge_timer_value_4_and_5)); 2206 s->timer_val[5] = core_ticks_to_us(adapter, 2207 TIMERVALUE1_GET(sge_params->sge_timer_value_4_and_5)); 2208 2209 s->counter_val[0] = 2210 THRESHOLD_0_GET(sge_params->sge_ingress_rx_threshold); 2211 s->counter_val[1] = 2212 THRESHOLD_1_GET(sge_params->sge_ingress_rx_threshold); 2213 s->counter_val[2] = 2214 THRESHOLD_2_GET(sge_params->sge_ingress_rx_threshold); 2215 s->counter_val[3] = 2216 THRESHOLD_3_GET(sge_params->sge_ingress_rx_threshold); 2217 2218 /* 2219 * Grab our Virtual Interface resource allocation, extract the 2220 * features that we're interested in and do a bit of sanity testing on 2221 * what we discover. 2222 */ 2223 err = t4vf_get_vfres(adapter); 2224 if (err) { 2225 dev_err(adapter->pdev_dev, "unable to get virtual interface" 2226 " resources: err=%d\n", err); 2227 return err; 2228 } 2229 2230 /* 2231 * The number of "ports" which we support is equal to the number of 2232 * Virtual Interfaces with which we've been provisioned. 2233 */ 2234 adapter->params.nports = vfres->nvi; 2235 if (adapter->params.nports > MAX_NPORTS) { 2236 dev_warn(adapter->pdev_dev, "only using %d of %d allowed" 2237 " virtual interfaces\n", MAX_NPORTS, 2238 adapter->params.nports); 2239 adapter->params.nports = MAX_NPORTS; 2240 } 2241 2242 /* 2243 * We need to reserve a number of the ingress queues with Free List 2244 * and Interrupt capabilities for special interrupt purposes (like 2245 * asynchronous firmware messages, or forwarded interrupts if we're 2246 * using MSI). The rest of the FL/Intr-capable ingress queues will be 2247 * matched up one-for-one with Ethernet/Control egress queues in order 2248 * to form "Queue Sets" which will be aportioned between the "ports". 2249 * For each Queue Set, we'll need the ability to allocate two Egress 2250 * Contexts -- one for the Ingress Queue Free List and one for the TX 2251 * Ethernet Queue. 2252 */ 2253 ethqsets = vfres->niqflint - INGQ_EXTRAS; 2254 if (vfres->nethctrl != ethqsets) { 2255 dev_warn(adapter->pdev_dev, "unequal number of [available]" 2256 " ingress/egress queues (%d/%d); using minimum for" 2257 " number of Queue Sets\n", ethqsets, vfres->nethctrl); 2258 ethqsets = min(vfres->nethctrl, ethqsets); 2259 } 2260 if (vfres->neq < ethqsets*2) { 2261 dev_warn(adapter->pdev_dev, "Not enough Egress Contexts (%d)" 2262 " to support Queue Sets (%d); reducing allowed Queue" 2263 " Sets\n", vfres->neq, ethqsets); 2264 ethqsets = vfres->neq/2; 2265 } 2266 if (ethqsets > MAX_ETH_QSETS) { 2267 dev_warn(adapter->pdev_dev, "only using %d of %d allowed Queue" 2268 " Sets\n", MAX_ETH_QSETS, adapter->sge.max_ethqsets); 2269 ethqsets = MAX_ETH_QSETS; 2270 } 2271 if (vfres->niq != 0 || vfres->neq > ethqsets*2) { 2272 dev_warn(adapter->pdev_dev, "unused resources niq/neq (%d/%d)" 2273 " ignored\n", vfres->niq, vfres->neq - ethqsets*2); 2274 } 2275 adapter->sge.max_ethqsets = ethqsets; 2276 2277 /* 2278 * Check for various parameter sanity issues. Most checks simply 2279 * result in us using fewer resources than our provissioning but we 2280 * do need at least one "port" with which to work ... 2281 */ 2282 if (adapter->sge.max_ethqsets < adapter->params.nports) { 2283 dev_warn(adapter->pdev_dev, "only using %d of %d available" 2284 " virtual interfaces (too few Queue Sets)\n", 2285 adapter->sge.max_ethqsets, adapter->params.nports); 2286 adapter->params.nports = adapter->sge.max_ethqsets; 2287 } 2288 if (adapter->params.nports == 0) { 2289 dev_err(adapter->pdev_dev, "no virtual interfaces configured/" 2290 "usable!\n"); 2291 return -EINVAL; 2292 } 2293 return 0; 2294 } 2295 2296 static inline void init_rspq(struct sge_rspq *rspq, u8 timer_idx, 2297 u8 pkt_cnt_idx, unsigned int size, 2298 unsigned int iqe_size) 2299 { 2300 rspq->intr_params = (QINTR_TIMER_IDX(timer_idx) | 2301 (pkt_cnt_idx < SGE_NCOUNTERS ? QINTR_CNT_EN : 0)); 2302 rspq->pktcnt_idx = (pkt_cnt_idx < SGE_NCOUNTERS 2303 ? pkt_cnt_idx 2304 : 0); 2305 rspq->iqe_len = iqe_size; 2306 rspq->size = size; 2307 } 2308 2309 /* 2310 * Perform default configuration of DMA queues depending on the number and 2311 * type of ports we found and the number of available CPUs. Most settings can 2312 * be modified by the admin via ethtool and cxgbtool prior to the adapter 2313 * being brought up for the first time. 2314 */ 2315 static void cfg_queues(struct adapter *adapter) 2316 { 2317 struct sge *s = &adapter->sge; 2318 int q10g, n10g, qidx, pidx, qs; 2319 size_t iqe_size; 2320 2321 /* 2322 * We should not be called till we know how many Queue Sets we can 2323 * support. In particular, this means that we need to know what kind 2324 * of interrupts we'll be using ... 2325 */ 2326 BUG_ON((adapter->flags & (USING_MSIX|USING_MSI)) == 0); 2327 2328 /* 2329 * Count the number of 10GbE Virtual Interfaces that we have. 2330 */ 2331 n10g = 0; 2332 for_each_port(adapter, pidx) 2333 n10g += is_10g_port(&adap2pinfo(adapter, pidx)->link_cfg); 2334 2335 /* 2336 * We default to 1 queue per non-10G port and up to # of cores queues 2337 * per 10G port. 2338 */ 2339 if (n10g == 0) 2340 q10g = 0; 2341 else { 2342 int n1g = (adapter->params.nports - n10g); 2343 q10g = (adapter->sge.max_ethqsets - n1g) / n10g; 2344 if (q10g > num_online_cpus()) 2345 q10g = num_online_cpus(); 2346 } 2347 2348 /* 2349 * Allocate the "Queue Sets" to the various Virtual Interfaces. 2350 * The layout will be established in setup_sge_queues() when the 2351 * adapter is brough up for the first time. 2352 */ 2353 qidx = 0; 2354 for_each_port(adapter, pidx) { 2355 struct port_info *pi = adap2pinfo(adapter, pidx); 2356 2357 pi->first_qset = qidx; 2358 pi->nqsets = is_x_10g_port(&pi->link_cfg) ? q10g : 1; 2359 qidx += pi->nqsets; 2360 } 2361 s->ethqsets = qidx; 2362 2363 /* 2364 * The Ingress Queue Entry Size for our various Response Queues needs 2365 * to be big enough to accommodate the largest message we can receive 2366 * from the chip/firmware; which is 64 bytes ... 2367 */ 2368 iqe_size = 64; 2369 2370 /* 2371 * Set up default Queue Set parameters ... Start off with the 2372 * shortest interrupt holdoff timer. 2373 */ 2374 for (qs = 0; qs < s->max_ethqsets; qs++) { 2375 struct sge_eth_rxq *rxq = &s->ethrxq[qs]; 2376 struct sge_eth_txq *txq = &s->ethtxq[qs]; 2377 2378 init_rspq(&rxq->rspq, 0, 0, 1024, iqe_size); 2379 rxq->fl.size = 72; 2380 txq->q.size = 1024; 2381 } 2382 2383 /* 2384 * The firmware event queue is used for link state changes and 2385 * notifications of TX DMA completions. 2386 */ 2387 init_rspq(&s->fw_evtq, SGE_TIMER_RSTRT_CNTR, 0, 512, iqe_size); 2388 2389 /* 2390 * The forwarded interrupt queue is used when we're in MSI interrupt 2391 * mode. In this mode all interrupts associated with RX queues will 2392 * be forwarded to a single queue which we'll associate with our MSI 2393 * interrupt vector. The messages dropped in the forwarded interrupt 2394 * queue will indicate which ingress queue needs servicing ... This 2395 * queue needs to be large enough to accommodate all of the ingress 2396 * queues which are forwarding their interrupt (+1 to prevent the PIDX 2397 * from equalling the CIDX if every ingress queue has an outstanding 2398 * interrupt). The queue doesn't need to be any larger because no 2399 * ingress queue will ever have more than one outstanding interrupt at 2400 * any time ... 2401 */ 2402 init_rspq(&s->intrq, SGE_TIMER_RSTRT_CNTR, 0, MSIX_ENTRIES + 1, 2403 iqe_size); 2404 } 2405 2406 /* 2407 * Reduce the number of Ethernet queues across all ports to at most n. 2408 * n provides at least one queue per port. 2409 */ 2410 static void reduce_ethqs(struct adapter *adapter, int n) 2411 { 2412 int i; 2413 struct port_info *pi; 2414 2415 /* 2416 * While we have too many active Ether Queue Sets, interate across the 2417 * "ports" and reduce their individual Queue Set allocations. 2418 */ 2419 BUG_ON(n < adapter->params.nports); 2420 while (n < adapter->sge.ethqsets) 2421 for_each_port(adapter, i) { 2422 pi = adap2pinfo(adapter, i); 2423 if (pi->nqsets > 1) { 2424 pi->nqsets--; 2425 adapter->sge.ethqsets--; 2426 if (adapter->sge.ethqsets <= n) 2427 break; 2428 } 2429 } 2430 2431 /* 2432 * Reassign the starting Queue Sets for each of the "ports" ... 2433 */ 2434 n = 0; 2435 for_each_port(adapter, i) { 2436 pi = adap2pinfo(adapter, i); 2437 pi->first_qset = n; 2438 n += pi->nqsets; 2439 } 2440 } 2441 2442 /* 2443 * We need to grab enough MSI-X vectors to cover our interrupt needs. Ideally 2444 * we get a separate MSI-X vector for every "Queue Set" plus any extras we 2445 * need. Minimally we need one for every Virtual Interface plus those needed 2446 * for our "extras". Note that this process may lower the maximum number of 2447 * allowed Queue Sets ... 2448 */ 2449 static int enable_msix(struct adapter *adapter) 2450 { 2451 int i, want, need, nqsets; 2452 struct msix_entry entries[MSIX_ENTRIES]; 2453 struct sge *s = &adapter->sge; 2454 2455 for (i = 0; i < MSIX_ENTRIES; ++i) 2456 entries[i].entry = i; 2457 2458 /* 2459 * We _want_ enough MSI-X interrupts to cover all of our "Queue Sets" 2460 * plus those needed for our "extras" (for example, the firmware 2461 * message queue). We _need_ at least one "Queue Set" per Virtual 2462 * Interface plus those needed for our "extras". So now we get to see 2463 * if the song is right ... 2464 */ 2465 want = s->max_ethqsets + MSIX_EXTRAS; 2466 need = adapter->params.nports + MSIX_EXTRAS; 2467 2468 want = pci_enable_msix_range(adapter->pdev, entries, need, want); 2469 if (want < 0) 2470 return want; 2471 2472 nqsets = want - MSIX_EXTRAS; 2473 if (nqsets < s->max_ethqsets) { 2474 dev_warn(adapter->pdev_dev, "only enough MSI-X vectors" 2475 " for %d Queue Sets\n", nqsets); 2476 s->max_ethqsets = nqsets; 2477 if (nqsets < s->ethqsets) 2478 reduce_ethqs(adapter, nqsets); 2479 } 2480 for (i = 0; i < want; ++i) 2481 adapter->msix_info[i].vec = entries[i].vector; 2482 2483 return 0; 2484 } 2485 2486 static const struct net_device_ops cxgb4vf_netdev_ops = { 2487 .ndo_open = cxgb4vf_open, 2488 .ndo_stop = cxgb4vf_stop, 2489 .ndo_start_xmit = t4vf_eth_xmit, 2490 .ndo_get_stats = cxgb4vf_get_stats, 2491 .ndo_set_rx_mode = cxgb4vf_set_rxmode, 2492 .ndo_set_mac_address = cxgb4vf_set_mac_addr, 2493 .ndo_validate_addr = eth_validate_addr, 2494 .ndo_do_ioctl = cxgb4vf_do_ioctl, 2495 .ndo_change_mtu = cxgb4vf_change_mtu, 2496 .ndo_fix_features = cxgb4vf_fix_features, 2497 .ndo_set_features = cxgb4vf_set_features, 2498 #ifdef CONFIG_NET_POLL_CONTROLLER 2499 .ndo_poll_controller = cxgb4vf_poll_controller, 2500 #endif 2501 }; 2502 2503 /* 2504 * "Probe" a device: initialize a device and construct all kernel and driver 2505 * state needed to manage the device. This routine is called "init_one" in 2506 * the PF Driver ... 2507 */ 2508 static int cxgb4vf_pci_probe(struct pci_dev *pdev, 2509 const struct pci_device_id *ent) 2510 { 2511 int pci_using_dac; 2512 int err, pidx; 2513 unsigned int pmask; 2514 struct adapter *adapter; 2515 struct port_info *pi; 2516 struct net_device *netdev; 2517 2518 /* 2519 * Print our driver banner the first time we're called to initialize a 2520 * device. 2521 */ 2522 pr_info_once("%s - version %s\n", DRV_DESC, DRV_VERSION); 2523 2524 /* 2525 * Initialize generic PCI device state. 2526 */ 2527 err = pci_enable_device(pdev); 2528 if (err) { 2529 dev_err(&pdev->dev, "cannot enable PCI device\n"); 2530 return err; 2531 } 2532 2533 /* 2534 * Reserve PCI resources for the device. If we can't get them some 2535 * other driver may have already claimed the device ... 2536 */ 2537 err = pci_request_regions(pdev, KBUILD_MODNAME); 2538 if (err) { 2539 dev_err(&pdev->dev, "cannot obtain PCI resources\n"); 2540 goto err_disable_device; 2541 } 2542 2543 /* 2544 * Set up our DMA mask: try for 64-bit address masking first and 2545 * fall back to 32-bit if we can't get 64 bits ... 2546 */ 2547 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64)); 2548 if (err == 0) { 2549 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)); 2550 if (err) { 2551 dev_err(&pdev->dev, "unable to obtain 64-bit DMA for" 2552 " coherent allocations\n"); 2553 goto err_release_regions; 2554 } 2555 pci_using_dac = 1; 2556 } else { 2557 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)); 2558 if (err != 0) { 2559 dev_err(&pdev->dev, "no usable DMA configuration\n"); 2560 goto err_release_regions; 2561 } 2562 pci_using_dac = 0; 2563 } 2564 2565 /* 2566 * Enable bus mastering for the device ... 2567 */ 2568 pci_set_master(pdev); 2569 2570 /* 2571 * Allocate our adapter data structure and attach it to the device. 2572 */ 2573 adapter = kzalloc(sizeof(*adapter), GFP_KERNEL); 2574 if (!adapter) { 2575 err = -ENOMEM; 2576 goto err_release_regions; 2577 } 2578 pci_set_drvdata(pdev, adapter); 2579 adapter->pdev = pdev; 2580 adapter->pdev_dev = &pdev->dev; 2581 2582 /* 2583 * Initialize SMP data synchronization resources. 2584 */ 2585 spin_lock_init(&adapter->stats_lock); 2586 2587 /* 2588 * Map our I/O registers in BAR0. 2589 */ 2590 adapter->regs = pci_ioremap_bar(pdev, 0); 2591 if (!adapter->regs) { 2592 dev_err(&pdev->dev, "cannot map device registers\n"); 2593 err = -ENOMEM; 2594 goto err_free_adapter; 2595 } 2596 2597 /* 2598 * Initialize adapter level features. 2599 */ 2600 adapter->name = pci_name(pdev); 2601 adapter->msg_enable = dflt_msg_enable; 2602 err = adap_init0(adapter); 2603 if (err) 2604 goto err_unmap_bar; 2605 2606 /* 2607 * Allocate our "adapter ports" and stitch everything together. 2608 */ 2609 pmask = adapter->params.vfres.pmask; 2610 for_each_port(adapter, pidx) { 2611 int port_id, viid; 2612 2613 /* 2614 * We simplistically allocate our virtual interfaces 2615 * sequentially across the port numbers to which we have 2616 * access rights. This should be configurable in some manner 2617 * ... 2618 */ 2619 if (pmask == 0) 2620 break; 2621 port_id = ffs(pmask) - 1; 2622 pmask &= ~(1 << port_id); 2623 viid = t4vf_alloc_vi(adapter, port_id); 2624 if (viid < 0) { 2625 dev_err(&pdev->dev, "cannot allocate VI for port %d:" 2626 " err=%d\n", port_id, viid); 2627 err = viid; 2628 goto err_free_dev; 2629 } 2630 2631 /* 2632 * Allocate our network device and stitch things together. 2633 */ 2634 netdev = alloc_etherdev_mq(sizeof(struct port_info), 2635 MAX_PORT_QSETS); 2636 if (netdev == NULL) { 2637 t4vf_free_vi(adapter, viid); 2638 err = -ENOMEM; 2639 goto err_free_dev; 2640 } 2641 adapter->port[pidx] = netdev; 2642 SET_NETDEV_DEV(netdev, &pdev->dev); 2643 pi = netdev_priv(netdev); 2644 pi->adapter = adapter; 2645 pi->pidx = pidx; 2646 pi->port_id = port_id; 2647 pi->viid = viid; 2648 2649 /* 2650 * Initialize the starting state of our "port" and register 2651 * it. 2652 */ 2653 pi->xact_addr_filt = -1; 2654 netif_carrier_off(netdev); 2655 netdev->irq = pdev->irq; 2656 2657 netdev->hw_features = NETIF_F_SG | TSO_FLAGS | 2658 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | 2659 NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_RXCSUM; 2660 netdev->vlan_features = NETIF_F_SG | TSO_FLAGS | 2661 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | 2662 NETIF_F_HIGHDMA; 2663 netdev->features = netdev->hw_features | 2664 NETIF_F_HW_VLAN_CTAG_TX; 2665 if (pci_using_dac) 2666 netdev->features |= NETIF_F_HIGHDMA; 2667 2668 netdev->priv_flags |= IFF_UNICAST_FLT; 2669 2670 netdev->netdev_ops = &cxgb4vf_netdev_ops; 2671 netdev->ethtool_ops = &cxgb4vf_ethtool_ops; 2672 2673 /* 2674 * Initialize the hardware/software state for the port. 2675 */ 2676 err = t4vf_port_init(adapter, pidx); 2677 if (err) { 2678 dev_err(&pdev->dev, "cannot initialize port %d\n", 2679 pidx); 2680 goto err_free_dev; 2681 } 2682 } 2683 2684 /* 2685 * The "card" is now ready to go. If any errors occur during device 2686 * registration we do not fail the whole "card" but rather proceed 2687 * only with the ports we manage to register successfully. However we 2688 * must register at least one net device. 2689 */ 2690 for_each_port(adapter, pidx) { 2691 netdev = adapter->port[pidx]; 2692 if (netdev == NULL) 2693 continue; 2694 2695 err = register_netdev(netdev); 2696 if (err) { 2697 dev_warn(&pdev->dev, "cannot register net device %s," 2698 " skipping\n", netdev->name); 2699 continue; 2700 } 2701 2702 set_bit(pidx, &adapter->registered_device_map); 2703 } 2704 if (adapter->registered_device_map == 0) { 2705 dev_err(&pdev->dev, "could not register any net devices\n"); 2706 goto err_free_dev; 2707 } 2708 2709 /* 2710 * Set up our debugfs entries. 2711 */ 2712 if (!IS_ERR_OR_NULL(cxgb4vf_debugfs_root)) { 2713 adapter->debugfs_root = 2714 debugfs_create_dir(pci_name(pdev), 2715 cxgb4vf_debugfs_root); 2716 if (IS_ERR_OR_NULL(adapter->debugfs_root)) 2717 dev_warn(&pdev->dev, "could not create debugfs" 2718 " directory"); 2719 else 2720 setup_debugfs(adapter); 2721 } 2722 2723 /* 2724 * See what interrupts we'll be using. If we've been configured to 2725 * use MSI-X interrupts, try to enable them but fall back to using 2726 * MSI interrupts if we can't enable MSI-X interrupts. If we can't 2727 * get MSI interrupts we bail with the error. 2728 */ 2729 if (msi == MSI_MSIX && enable_msix(adapter) == 0) 2730 adapter->flags |= USING_MSIX; 2731 else { 2732 err = pci_enable_msi(pdev); 2733 if (err) { 2734 dev_err(&pdev->dev, "Unable to allocate %s interrupts;" 2735 " err=%d\n", 2736 msi == MSI_MSIX ? "MSI-X or MSI" : "MSI", err); 2737 goto err_free_debugfs; 2738 } 2739 adapter->flags |= USING_MSI; 2740 } 2741 2742 /* 2743 * Now that we know how many "ports" we have and what their types are, 2744 * and how many Queue Sets we can support, we can configure our queue 2745 * resources. 2746 */ 2747 cfg_queues(adapter); 2748 2749 /* 2750 * Print a short notice on the existence and configuration of the new 2751 * VF network device ... 2752 */ 2753 for_each_port(adapter, pidx) { 2754 dev_info(adapter->pdev_dev, "%s: Chelsio VF NIC PCIe %s\n", 2755 adapter->port[pidx]->name, 2756 (adapter->flags & USING_MSIX) ? "MSI-X" : 2757 (adapter->flags & USING_MSI) ? "MSI" : ""); 2758 } 2759 2760 /* 2761 * Return success! 2762 */ 2763 return 0; 2764 2765 /* 2766 * Error recovery and exit code. Unwind state that's been created 2767 * so far and return the error. 2768 */ 2769 2770 err_free_debugfs: 2771 if (!IS_ERR_OR_NULL(adapter->debugfs_root)) { 2772 cleanup_debugfs(adapter); 2773 debugfs_remove_recursive(adapter->debugfs_root); 2774 } 2775 2776 err_free_dev: 2777 for_each_port(adapter, pidx) { 2778 netdev = adapter->port[pidx]; 2779 if (netdev == NULL) 2780 continue; 2781 pi = netdev_priv(netdev); 2782 t4vf_free_vi(adapter, pi->viid); 2783 if (test_bit(pidx, &adapter->registered_device_map)) 2784 unregister_netdev(netdev); 2785 free_netdev(netdev); 2786 } 2787 2788 err_unmap_bar: 2789 iounmap(adapter->regs); 2790 2791 err_free_adapter: 2792 kfree(adapter); 2793 2794 err_release_regions: 2795 pci_release_regions(pdev); 2796 pci_clear_master(pdev); 2797 2798 err_disable_device: 2799 pci_disable_device(pdev); 2800 2801 return err; 2802 } 2803 2804 /* 2805 * "Remove" a device: tear down all kernel and driver state created in the 2806 * "probe" routine and quiesce the device (disable interrupts, etc.). (Note 2807 * that this is called "remove_one" in the PF Driver.) 2808 */ 2809 static void cxgb4vf_pci_remove(struct pci_dev *pdev) 2810 { 2811 struct adapter *adapter = pci_get_drvdata(pdev); 2812 2813 /* 2814 * Tear down driver state associated with device. 2815 */ 2816 if (adapter) { 2817 int pidx; 2818 2819 /* 2820 * Stop all of our activity. Unregister network port, 2821 * disable interrupts, etc. 2822 */ 2823 for_each_port(adapter, pidx) 2824 if (test_bit(pidx, &adapter->registered_device_map)) 2825 unregister_netdev(adapter->port[pidx]); 2826 t4vf_sge_stop(adapter); 2827 if (adapter->flags & USING_MSIX) { 2828 pci_disable_msix(adapter->pdev); 2829 adapter->flags &= ~USING_MSIX; 2830 } else if (adapter->flags & USING_MSI) { 2831 pci_disable_msi(adapter->pdev); 2832 adapter->flags &= ~USING_MSI; 2833 } 2834 2835 /* 2836 * Tear down our debugfs entries. 2837 */ 2838 if (!IS_ERR_OR_NULL(adapter->debugfs_root)) { 2839 cleanup_debugfs(adapter); 2840 debugfs_remove_recursive(adapter->debugfs_root); 2841 } 2842 2843 /* 2844 * Free all of the various resources which we've acquired ... 2845 */ 2846 t4vf_free_sge_resources(adapter); 2847 for_each_port(adapter, pidx) { 2848 struct net_device *netdev = adapter->port[pidx]; 2849 struct port_info *pi; 2850 2851 if (netdev == NULL) 2852 continue; 2853 2854 pi = netdev_priv(netdev); 2855 t4vf_free_vi(adapter, pi->viid); 2856 free_netdev(netdev); 2857 } 2858 iounmap(adapter->regs); 2859 kfree(adapter); 2860 } 2861 2862 /* 2863 * Disable the device and release its PCI resources. 2864 */ 2865 pci_disable_device(pdev); 2866 pci_clear_master(pdev); 2867 pci_release_regions(pdev); 2868 } 2869 2870 /* 2871 * "Shutdown" quiesce the device, stopping Ingress Packet and Interrupt 2872 * delivery. 2873 */ 2874 static void cxgb4vf_pci_shutdown(struct pci_dev *pdev) 2875 { 2876 struct adapter *adapter; 2877 int pidx; 2878 2879 adapter = pci_get_drvdata(pdev); 2880 if (!adapter) 2881 return; 2882 2883 /* Disable all Virtual Interfaces. This will shut down the 2884 * delivery of all ingress packets into the chip for these 2885 * Virtual Interfaces. 2886 */ 2887 for_each_port(adapter, pidx) 2888 if (test_bit(pidx, &adapter->registered_device_map)) 2889 unregister_netdev(adapter->port[pidx]); 2890 2891 /* Free up all Queues which will prevent further DMA and 2892 * Interrupts allowing various internal pathways to drain. 2893 */ 2894 t4vf_sge_stop(adapter); 2895 if (adapter->flags & USING_MSIX) { 2896 pci_disable_msix(adapter->pdev); 2897 adapter->flags &= ~USING_MSIX; 2898 } else if (adapter->flags & USING_MSI) { 2899 pci_disable_msi(adapter->pdev); 2900 adapter->flags &= ~USING_MSI; 2901 } 2902 2903 /* 2904 * Free up all Queues which will prevent further DMA and 2905 * Interrupts allowing various internal pathways to drain. 2906 */ 2907 t4vf_free_sge_resources(adapter); 2908 pci_set_drvdata(pdev, NULL); 2909 } 2910 2911 /* 2912 * PCI Device registration data structures. 2913 */ 2914 #define CH_DEVICE(devid) \ 2915 { PCI_VENDOR_ID_CHELSIO, devid, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 } 2916 2917 static const struct pci_device_id cxgb4vf_pci_tbl[] = { 2918 CH_DEVICE(0xb000), /* PE10K FPGA */ 2919 CH_DEVICE(0x4801), /* T420-cr */ 2920 CH_DEVICE(0x4802), /* T422-cr */ 2921 CH_DEVICE(0x4803), /* T440-cr */ 2922 CH_DEVICE(0x4804), /* T420-bch */ 2923 CH_DEVICE(0x4805), /* T440-bch */ 2924 CH_DEVICE(0x4806), /* T460-ch */ 2925 CH_DEVICE(0x4807), /* T420-so */ 2926 CH_DEVICE(0x4808), /* T420-cx */ 2927 CH_DEVICE(0x4809), /* T420-bt */ 2928 CH_DEVICE(0x480a), /* T404-bt */ 2929 CH_DEVICE(0x480d), /* T480-cr */ 2930 CH_DEVICE(0x480e), /* T440-lp-cr */ 2931 CH_DEVICE(0x4880), 2932 CH_DEVICE(0x4881), 2933 CH_DEVICE(0x4882), 2934 CH_DEVICE(0x4883), 2935 CH_DEVICE(0x4884), 2936 CH_DEVICE(0x4885), 2937 CH_DEVICE(0x4886), 2938 CH_DEVICE(0x4887), 2939 CH_DEVICE(0x4888), 2940 CH_DEVICE(0x5801), /* T520-cr */ 2941 CH_DEVICE(0x5802), /* T522-cr */ 2942 CH_DEVICE(0x5803), /* T540-cr */ 2943 CH_DEVICE(0x5804), /* T520-bch */ 2944 CH_DEVICE(0x5805), /* T540-bch */ 2945 CH_DEVICE(0x5806), /* T540-ch */ 2946 CH_DEVICE(0x5807), /* T520-so */ 2947 CH_DEVICE(0x5808), /* T520-cx */ 2948 CH_DEVICE(0x5809), /* T520-bt */ 2949 CH_DEVICE(0x580a), /* T504-bt */ 2950 CH_DEVICE(0x580b), /* T520-sr */ 2951 CH_DEVICE(0x580c), /* T504-bt */ 2952 CH_DEVICE(0x580d), /* T580-cr */ 2953 CH_DEVICE(0x580e), /* T540-lp-cr */ 2954 CH_DEVICE(0x580f), /* Amsterdam */ 2955 CH_DEVICE(0x5810), /* T580-lp-cr */ 2956 CH_DEVICE(0x5811), /* T520-lp-cr */ 2957 CH_DEVICE(0x5812), /* T560-cr */ 2958 CH_DEVICE(0x5813), /* T580-cr */ 2959 CH_DEVICE(0x5814), /* T580-so-cr */ 2960 CH_DEVICE(0x5815), /* T502-bt */ 2961 CH_DEVICE(0x5880), 2962 CH_DEVICE(0x5881), 2963 CH_DEVICE(0x5882), 2964 CH_DEVICE(0x5883), 2965 CH_DEVICE(0x5884), 2966 CH_DEVICE(0x5885), 2967 CH_DEVICE(0x5886), 2968 CH_DEVICE(0x5887), 2969 CH_DEVICE(0x5888), 2970 { 0, } 2971 }; 2972 2973 MODULE_DESCRIPTION(DRV_DESC); 2974 MODULE_AUTHOR("Chelsio Communications"); 2975 MODULE_LICENSE("Dual BSD/GPL"); 2976 MODULE_VERSION(DRV_VERSION); 2977 MODULE_DEVICE_TABLE(pci, cxgb4vf_pci_tbl); 2978 2979 static struct pci_driver cxgb4vf_driver = { 2980 .name = KBUILD_MODNAME, 2981 .id_table = cxgb4vf_pci_tbl, 2982 .probe = cxgb4vf_pci_probe, 2983 .remove = cxgb4vf_pci_remove, 2984 .shutdown = cxgb4vf_pci_shutdown, 2985 }; 2986 2987 /* 2988 * Initialize global driver state. 2989 */ 2990 static int __init cxgb4vf_module_init(void) 2991 { 2992 int ret; 2993 2994 /* 2995 * Vet our module parameters. 2996 */ 2997 if (msi != MSI_MSIX && msi != MSI_MSI) { 2998 pr_warn("bad module parameter msi=%d; must be %d (MSI-X or MSI) or %d (MSI)\n", 2999 msi, MSI_MSIX, MSI_MSI); 3000 return -EINVAL; 3001 } 3002 3003 /* Debugfs support is optional, just warn if this fails */ 3004 cxgb4vf_debugfs_root = debugfs_create_dir(KBUILD_MODNAME, NULL); 3005 if (IS_ERR_OR_NULL(cxgb4vf_debugfs_root)) 3006 pr_warn("could not create debugfs entry, continuing\n"); 3007 3008 ret = pci_register_driver(&cxgb4vf_driver); 3009 if (ret < 0 && !IS_ERR_OR_NULL(cxgb4vf_debugfs_root)) 3010 debugfs_remove(cxgb4vf_debugfs_root); 3011 return ret; 3012 } 3013 3014 /* 3015 * Tear down global driver state. 3016 */ 3017 static void __exit cxgb4vf_module_exit(void) 3018 { 3019 pci_unregister_driver(&cxgb4vf_driver); 3020 debugfs_remove(cxgb4vf_debugfs_root); 3021 } 3022 3023 module_init(cxgb4vf_module_init); 3024 module_exit(cxgb4vf_module_exit); 3025