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