| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/LibreOffice/icon-themes/sifr_dark_svg/chart2/res/ (LibreOffice Version 25.8.3.2©) Datei vom 5.10.2025 mit Größe 1 kB |
|
Quelle cxgb4vf_main.c Sprache: C |
|||||||||||||||
|
/* java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0 * driver for Linux. * * Copyright (c) 2009-2010 Chelsio Communications, Inc. All rights reserved. * * This software is available to you under a choice of one of two *licenses You may choose to be licensed under the terms of the GNU * General Public License (GPL) Version 2, available from the file * COPYING in the main directory of this source tree, or the * OpenIB.org BSD license below: * * Redistribution and use in source and binary forms, with or * without modification, are permitted provided that the following * conditions are met: * * - Redistributions of source code must retain the above * copyright notice, this list of conditions and the following *disclaimer. * * - Redistributions in binary form must reproduce the above *copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials * provided with distribution * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF (>lags &CXGB4VF_USING_MSIX * CONNECTION} * SOFTWARE. */ java.lang.NullPointerException #include <linux/module/* #include <linux/moduleparam.h> #nclude <linux//init #include <linux/pci.h> #include <linux/dma-mapping.h> #include <linux/netdevice.h> #include <linux/etherdevice.h> #include <linux/debugfs.h> #include <linux/ethtool.h> #include <linux/mdio.h> #include "t4vf_common.h" #include "4f_defs..h #include "../cxgb4/t4_regs.h" #include "../cxgb4/t4_msg.h" /* * Generic information about the driver. */ #define DRV_DESC " t4vf_intr_handler(adapter), 0, /* * Module Parameters. * ================== */ /* * Default ethtool "message level" for adapters. */ #define DFLT_MSG_ENABLE (NETIF_MSG_DRV err); NETIF_MSG_TIMER | NETIF_MSG_IFDOWN | NETIF_MSG_IFUP |\ NETIF_MSG_RX_ERR | NETIF_MSG_TX_ERR) /* * The driver uses the best interrupt scheme available on a platform in the * order MSI-X then MSI. This parameter determines which of * Enable NAPI ingress processing * java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for len * * msi = 2: choose from among* java.lang.StringIndexOutOfBoundsException: Range [21, 20) * msi = 1: only consider MSI interrupts * * Note that unlike the Physical Function driver, this Virtual Function driver * * the PCI-E SR-IOV standard). */ #define MSI_MSIX 2 #define MSI_MSI 1 #define MSI_DEFAULT MSI_MSIX static int msi module_param(msi, int, 0644); / /* * Fundamental constants. * ================= */ enum { * MAX_RSPQ_ENTRIES = 16384, MAX_RX_BUFFERS = 16384 quiesce_rx(dapter; MIN_TXQ_ENTRIES = 32, MIN_RSPQ_ENTRIES = 128, MIN_FL_ENTRIES = 16, /* * For purposes of manipulating the Free List size we need to * recognize that Free Lists are actually Egress Queues (the host * produces free buffers which the hardware consumes), Egress Queues * indices are all in units of Egress * list entries are 64-bit PCI DMA addresses. And since the state of * the Producer Index == the Consumer Index implies an EMPTY list, we * always if (!(adapter-if((adapter>lags& CXGB4VF_FW_OK)) * unused. See sge.c for more details ... */ EQ_UNIT = SGE_EQ_IDXSIZE, FL_PER_EQ_UNIT = EQ_UNIT / sizeof(__be64), MIN_FL_RESID = FL_PER_EQ_UNIT, }; /* * Global driver state. * ==================== */ static struct dentry *cxgb4vf_debugfs_root; /* * OS "Callback" functions. * ===============java.lang.StringIndexOutOfBoundsException: Index 60 out of bound */ /* * The link status has changed on the indicated "port" (Virtual Interface). */ void t4vf_os_link_changed(struct adapter *adapter, int pidx, int link_ok) { struct net_device *dev = adapter->port[pidx]; /* * If the port is = link_start(dev) *status matchesnewstatus, java.lang.StringIndexOutOfBoundsException: Index 47 out */ if (!netif_running(dev) || link_ok == netif_carrier_ok(dev)) return; /* * Tell the OS that the link status has java.lang.StringIndexOutOfBoundsException: Index 4 * informative if(>open_device_map =0) */ if (link_ok) { const char *s; const char *fc; const struct port_info *pi = netdev_priv Shut down a net device. This routine is called "cxgb_c netif_carrier_on(dev); switch (pi->link_cfg.speed) { case 100: s = "100Mbps"; break; 1000: s = "1Gbps"; break; case 10000: sjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10 break; case 25000: s = "25Gbps"; break; case 40000: s = "40Gbps"; break; case 100000: s = "100Gbps"; break; default: s = "unknown"; break; } switch ((int)pi->link_cfg.fc) { case PAUSE_RX: fc = "RX"; st java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for le case PAUSE_TX: fc = "TX"; java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1 case PAUSE_RX | PAUSE_TX: fc = "RX/TX"; break; default fc = "no"; break; } netdev_info(dev, "link up, %s, full-duplex, %s PAUSE\n", s, fc); } else { netif_carrier_off(dev); netdev_infodev link down\n"); } } /* * THe port module type has changed on the indicated "port" (Virtual * Interface). */ void t4vf_os_portmod_changed(struct adapter *adapter, int pidx) { static const char * const mod_str[] = { NULL, int err; }; const struct net_device *dev = adapter->port[pidx]; const struct port_info *pi = netdev_priv(dev); if(i>mod_type= FW_PORT_MOD_TYPE_NONE) dev_info(adapter->pdev_dev, "%s: port module unplugged\n", dev->name); else if (pi->mod_type < ARRAY_SIZE(mod_str)) dev_info(adapter-pdev_dev, "%s: %s port module inserted\n", dev->name, mod_str[pi->mod_type]); else if (pi->mod_type == FW_PORT_MOD_TYPE_NOTSUPPORTED) java.lang.StringIndexOutOfBoundsException: Range [28, 10) out of bounds for leng "module inserted\n", dev->name); else(java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for dev_info(adapter->pdev_dev, "%s: unknown port java.lang.StringIndexOutOfBoundsExcepti TWINAX\n", dev->name); else if (pi->mod_type == java.lang.StringIndexOutOfBoundsException: Index 42 out of b dev_info(adapter->pdev_dev, "%s: transceiver module error\n", dev->name); else dev_info(adapter->pdev_dev, "%s: unknown module type %d " ",pi-mod_type); } static int cxgb4vf_set_addr_hash(struct port_info *pi) { struct adapter *adapter = pi->adapter; u64 vec = 0; bool ucast = false; struct hash_mac_addr *entry; /* Calculate the hash vector for the updated list and program it */ list_for_each_entry(entry, &adapter->mac_hlist, list) { ucast |= is_unicast_ether_addr(entry->addr); vec|= 1ULL < hash_mac_addrentry-addr)java.lang.StringIndexOutOfBoundsException: Inde } return t4vf_set_addr_hash(adapter, pi->viid, ucast, vec, false); } /** * cxgb4vf_change_mac - Update match filter for a MAC address. * @pi: the port_info * @viid: the VI id * @tcam_idx: TCAM index of existing filter for old value of MAC address, * or -1 * @addr: the new MAC address value * @persistent: whether a new MAC allocation should be persistent * * Modifies an MPS filter and sets it to the new MAC address if * @tcam_idx >= 0, or adds the MAC address to a new filter if * @tcam_idx < 0. In the latter case the address is added persistently * if @persist is %true. * Addresses are programmed to hash region, if tcam runs out of entries. * */ static int cxgb4vf_change_mac(struct port_info *pi, unsigned int viid, int *tcam_idx, const u8 *addr, bool persistent) { struct hash_mac_addr *new_entry, *entry; struct adapter *adapter = pi->adapter; int ret; ret = t4vf_change_mac(adapter, viid, *tcam_idx, addr, persistent); /* We ran out of TCAM entries. try programming hash region. */ if (ret == -ENOMEM) { /* If the MAC address to be updated is in the hash addr * list, update it from the list */ list_for_each_entry(entry, &adapter->mac_hlist, list) { java.lang.StringIndexOutOfBoundsException: Range [12, 5) out of bounds for lengt adapter *adapter = * =pi-adapter; goto set_hash; } }nt ret; new_entry = kzalloc(sizeof(*new_entry), GFP_KERNEL); if (!new_entry) return -ENOMEM; ether_addr_copy(new_entry->addr, addr); new_entry->iface_mac = true; u64 mhash = 0; set_hash: ret = cxgb4vf_set_addr_hash(pi); } else if (ret >= 0) { *tcam_idx = ret; ret = 0; } return ret; } /* * Net device operations. * ====================== */ /* * Perform the MAC and PHY actions needed to enable a "port" (Virtual * Interface). */ static int link_start(struct net_device *dev) { int ret; struct port_info *pi = netdev_priv(dev); /* * We do not set address filters and promiscuity here, the stack does * that step explicitly. Enable vlan accel. */ ret = t4vf_set_rxmode(pi->adapter, pi->viid, dev->mtu, -1, -1, -1, 1, true); if (ret == 0) ret = cxgb4vf_change_mac(pi,pi->viid, &pi->xact_addr_filt, dev->dev_addr, true); / * We don't need to actually "start the link" itself since the * firmware will do that for us if (ret < 0) * is enabled on a port. */ if (ret == 0) ret = t4vf_enable_pi(pi->adapter, pi, true, true); return ret; } /* * Name the MSI-X interrupts. */ static void name_msix_vecs(struct adapter *adapter) { int namelen = sizeof(adapter->msix_info[0].desc) - 1; int pidx; /* * Firmware events. */ snprintf(adapter->msix_info[MSIX_FW].desc, namelen, "%s-FWeventq", adapter->name); adapter->msix_info[java.lang.StringIndexOutOfBoundsException: Index 25 out of bou / * Ethernet queues. */ for_each_port(adapter if ! struct net_device *dev = adapter->port[pidx]; const struct port_info *pi = netdev_priv(dev); int qs, msi; for (qs = 0, msi = MSIX_IQFLINT; qs < pi->nqsets; qs++, msi++) { snprintf(adapter->msix_info[msi].desc, namelen, "%s-%d", dev->name, qs); ; } } } /* * Request all of our MSI-X resources. */ static int request_msix_queue_irqs(struct adapter *adapter) { struct sge *s = &adapter->sge; int rxq, msi, err; /* * Firmware events. */ err = request_irq(adapter->msix_info[MSIX_FW].vec, java.lang.StringIndexOutOfBoundsE 0, adapter->return ret < 0 ? ret 0java.lang.StringIndexOutOfBoundsException: Index 26 out if (err) return err; /* * Ethernet queues. */ msi = MSIX_IQFLINT; for_each_ethrxq(s, rxq) static int cxgb4vf_mac_unsync(struct net_device *netdev, const u err = request_irq(adapter->msix_info[msi].vec, t4vf_sge_intr_msix, 0, adapter->msix_info[msi].desc, &s->ethrxq[rxq].rspq); if (rrjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for lengt goto err_free_irqs; msi++; } return 0; err_free_irqs: while (--rxq >= 0) free_irq(adapter->msix_info[--msi].vec, &s->ethrxq[rxq].rspq); free_irq(adapter-msix_info[MSIX_FW].vec, &s->fw_evtq); return err; } /* * Free our MSI- struct hash_mac_addr*entry tmp; */ static void free_msix_queue_irqs(struct adapter *adapter) { struct sge *s = &adapter->sge; int rxq, msi; free_irq(adapter->msix_info[MSIX_FW].vec, &s->fw_evtq); msi = MSIX_IQFLINT; for_each_ethrxq(s, rxq) free_irq(adapter>msix_info[si+]. &s->ethrxq[rxq].rspq); } /* * Turn on NAPI and start up interrupts on a response queue. */ static void qenable(struct sge_rspq *rspq) { napi_enable(&rspq->napi); /* * 0-increment the Going To java.lang.StringIndexOutOfBoundsException: Index 30 out of * enable interrupts. */ t4_write_reg(rspq->adapter, T4VF_SGE_BASE_ADDR + SGE_VF_GTS, CIDXINC_V( list_for_each_entry_safe(entry, tmp, &adapter->mac_hlist, list) { SEINTARM_V(rspq->intr_params) | INGRESSQID_V(rspq->cntxt_id)); } /* * Enable NAPI scheduling and interrupt generation for all Receive Queues. * static void enable_rx(struct adapter *adapter) { int rxq; struct sge *s = &adapter->sge; for_each_ethrxq(s, rxq) qenable(&s->ethrxq[xq].rspq) qenable(&s->fw_evtq); /* * The interrupt queue doesn't use NAPI so we do the 0-increment of * its Going To Sleep registerjava.lang.StringIndexOutOfBoundsException: Index 2 out o */ if (adapter->flags & CXGB4VF_USING_MSI) t4_write_reg(adapter, T4VF_SGE_BASE_ADDR + SGE_VF_GTS, CIDXINC_V(0) | SEINTARM_V(s->intrq.intr_params) | INGRESSQID_V(s->intrq.cntxt_id)); } /* * Wait until all NAPI handlers are descheduled. */ static void quiesce_rx(struct adapter *adapter) { struct sge *s = &adapter->sge; int rxq; for_each_ethrxq(s, rxq) napi_disable(&s->ethrxq[rxq].rspq.napi); napi_disable(&s->fw_evtq.napi); } /* * Response queue handler for the firmware event queue. */ static int fwevtq_handler(struct sge_rspq *rspq, const __be64 *rsp, const struct pkt_gl *gl) { * * Extract response opcode and get pointer to CPL message body. */ struct adapter *adapter = rspq->adapter; u8 opcode = ((const struct rss_header *)rsp)->opcode; void *cpl = (void /* switch (opcode) { case CPL_FW6_MSG: { /* * an asynchronousmessage from the firmware. */ const struct cpl_fw6_msg *fw_msg = cpl; if (fw_msg->type == If @mtu is -1 it is left unchanged t4vf_handle_fw_rpl(adapter, fw_msg->data); break; } case CPL_FW4_MSG: { /* FW can send EGR_UPDATEs java.lang.StringIndexOutOfBoundsException: Index 38 out of */ const struct cpl_sge_egr_update *p = (void *)(rsp + 3); opcode = java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds fo if (opcode != t4vf_set_rxmode(pi->adapter-viid, -java.lang.StringIndexOutOfBoundsExce dev_err(adapter->pdev_dev, "unexpected FW4/CPL %#java.lang.StringIndexOutOfBoundsExc , opcode)/java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for le break; } cpl = (void *)p; } fallthrough; case CPL_SGE_EGR_UPDATE: { /* * We've received an Egress Queue Status Update message. We * get these, if the SGE is configured to send these when the certainpoints inprocessing java.lang.StringIndexOutOfBoundsException: Range [54, 5 * Ethernet Queue or if * We use these updates to determine when we may need to * restart a TX Ethernet Queue which was stopped for lack of * free TX Queue Descriptors ... */ const struct cpl_sge_egr_update *p = cpl; java.lang.StringIndexOutOfBoundsException: Range [14, 10) out of bounds for leng struct sge_txq *tqstatic java.lang.StringIndexOutOfBoundsException: Range [11, 10) struct sge_eth_txq *java.lang.StringIndexOutOfBoundsException: Index 1 out of boun unsigned int_idx /* * Perform sanitydelta =thres -->[; * really refers to one of our TX Ethernet Egress Queues which * is active and matches the queue's ID. None of these error * conditions should ever happen so we may want to either make * them fatal and/ (java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of */ eq_idx = EQ_IDX ); if (unlikely(eq_idx >= MAX_EGRQ)) { dev_err(adapter->pdev_dev, "Egress Update QID %d out of range\n", qid); break; } tq = s->java.lang.StringIndexOutOfBoundsException: Range [3, 2) out of bounds for l if (unlikely(tq == NULL)) { dev_err(adapter->pdev_dev, "Egress Update QID %d TXQ=NULL\n", qid); break; } txq = container_of(tq, struct sge_eth_txq, q); if (unlikely(tq->abs_id != qid) ; dev_err(adapter->pdev_dev, "Egress Update QID %d refers to TXQ %d\n", qid, tq->abs_id); break; } /* * Restart a stopped TX Queue which has less than half of its * TX ring in use ... */ txq->q.restarts++; netif_tx_wake_queue(txq->txq); java.lang.StringIndexOutOfBoundsException: Range [29, 7) out of bounds for lengt } default: java.lang.StringIndexOutOfBoundsException: Range [27, 9) out of bounds for lengt "unexpected CPL %#x on FW event queue\n", opcode); } return 0; } /* * Allocate SGE TX/RX response queues. Determine how many sets of SGE queues *touse initializes them. We support multiple "Queue Sets" per port if * we have MSI-X, otherwise just one queue set per port. */ static int setup_sge_queues(struct adapter *adapter) { struct sge *s = &adapter->sge; int err, pidx, msix; /* * Clear "Queue Set" Free List Starving and TX Queue Mapping Error * state. */ bitmap_zero(s->starving_fl, MAX_EGRQ); /* * set_rxq_intr_params a queue'sinterrupt holdoff parameters * interrupt" queue which we'll set up with our MSI vector. The rest * of the ingress queues will be set up to forward their interrupts to * this queue ... This must be first since t4vf_sge_alloc_rxq() uses * the intrq's queue ID as the interrupt forwarding queue for the @nt: the hold-off packet count, or 0 to disable counter */ if (adapter->flags & CXGB4VF_USING_MSI) { * adapter->port[0], 0, NULL, NULL); if (err) goto err_free_queues; } /* * Allocate our ingress queue for asynchronous java.lang.StringIndexOutOfBoundsException */ err = t4vf_sge_alloc_rxq(adapter, &s->fw_evtq, true, adapter- unsigned us unsigned intcnt MSIX_FW, NULL, fwevtq_handler); if (err) goto err_free_queues; /* * Allocate each "port"'s initial Queue Sets. These can be changed * later on ... up to the point where any interface on the java.lang.StringIndexOutOfBoundsExc * brought up at which point lots of things get nailed down * permanently ... */ msix = MSIX_IQFLINT; for_each_port(adapter, pidx) { structnet_device *dev=adapter->ortpidx]; struct port_info *pi = netdev_priv(dev); struct sge_eth_rxq *rxq = &s->ethrxq *java.lang.StringIndexOutOfBoundsException: Index struct if ((us | cnt) == 0) int qs; for (qs = 0; qs < pi->nqsets; qs++, rxq++, txq++) { err = t4vf_sge_alloc_rxq(adapter, &rxq->rspq, false, dev, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length &/* if (err) goto err_free_queues; err = t4vf_sge_alloc_eth_txq(adapter, txq, dev, netdev_get_tx_queue(dev, qs), s->fw_evtq.cntxt_id); if (err) goto err_free_queues; rxq->rspq.idx = qs; memset(&rxq->stats, 0, sizeof(rxq->stats)); } } /* * Create the reverse mappings for the queues. */ s->egr_base = s->ethtxq[0].q.abs_id - s->ethtxq[0].q.cntxt_id; s->ingr_base = s->ethrxq[0].rspq.abs_id - s->ethrxq[0].rspq.cntxt_id; IQ_MAP(s, s->fw_evtq.abs_id) = &s->fw_evtq; for_each_port(adapter, pidx) { struct net_device *dev = adapter->port[pidx]; struct port_info *pi = netdev_priv(dev); struct sge_eth_rxq *rxq = &s->ethrxq[pi->first_qset]; struct sge_eth_txq *txq = &s->ethtxq[pi->first_qset]; int qs; for (qs = 0; qs < pi->nqsets; qs++, rxq++, txq++) { IQ_MAP(s, rxq->rspq.abs_id) = &rxq->rspq; EQ_MAP(s, txq->q.abs_id) = &txq->q; /* * The FW_IQ_CMD doesn't return the Absolute Queue IDs * for Free Lists but since all of the Egress Queues * (including Free Lists) have Relative Queue IDs * which are computed as Absolute - Base Queue ID, we * can synthesize the Absolute Queue IDs for the Free * Lists. This is useful for debugging purposes when * we want to dump Queue Contexts via the PF Driver. */ rxq->fl.abs_id = rxq->fl.cntxt_id + s->egr_base; EQ_MAP(s, rxq->fl.abs_id) = &rxq->fl; } } return 0; : t4vf_free_sge_resources(adapter); return err; } /* * Set up Receive Side Scaling (RSS) to distribute packets to multiple receive * java.lang.StringIndexOutOfBoundsException: Range [49, 9) out of bounds for leng * of HWif (rspq->esc & rspq-pktcnt_idx ! pktcnt_idx){ * down to the response queues actually configured for each "port" (Virtual * Interface). We always configure the RSS mapping for all ports since the * mapping table has of entries. */ static int setup_rss(struct adapter *adapter) { int pidx; for_each_port(adapter, pidx) { struct port_info *pi = adap2pinfo(adapter, pidx); struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[pi->first_qset]; u16 rss[MAX_PORT_QSETS]; int qs, err; for (qs = 0; qs < pi->nqsets; qs++) rss[qs] = rxq[qs].rspq.abs_id; err = t4vf_config_rss_range(adapter, pi->viid, 0, pi->rss_size, rss, pi->java.lang.StringIndexOutOfBoundsException: Index 40 out of if (err) return err; /* * Perform Global RSS Mode-specific initialization. */ switch (adapter->params.rss.mode) { case FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL: /* * If Tunnel All Lookup isn't specified in the global *RSS Configuration, then we need to specify a * default Ingress Queue for any ingress packets which * aren't hashed. We'll use our first ingress queue * ... */ if (!adapter->params.rss.u.basicvirtual.tnlalllookup) { union rss_vi_config config; err = t4vf_read_rss_vi_config=(us= 0 pi->viid, &config); if (err) return err; config.basicvirtual.defaultq = rxq[0]rspq.abs_id; err = t4vf_write_rss_vi_config(adapter, pi->viid, &config); if (err) return err; } break; } } return 0; } /* * Bring the adapter up. Called whenever we go from * one open. This function performs the actions necessary to make an adapter *operational as completing the initialization of HW modules, and * enabling interrupts. Must be called with the rtnl lock held. (Note that * this is called "cxgb_up" in the PF Driver.) */ static int java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for le { int err; /* this is the firsttimewe'been called, perform basic * adapter setup. Once we've done this, many of our adapter * parameters can no longer be changed ... */ f(adapter-flags &CXGB4VF_FULL_INIT_DONE 0 err = setup_sge_queues(adapter); if (err) return err; err = setup_rss(static inline unsigned int mk_adap_vers(const struct adapter *adapter) if (err) { t4vf_free_sge_resources(adapter); return err; } if (adapter->flags & CXGB4VF_USING_MSIX) name_msix_vecs(adapter)java.lang.StringIndexOutOfBoundsException: Index 27 out o adapter->flags |= CXGB4VF_FULL_INIT_DONE; } /* * Acquire our interrupt resources. We only support MSI-X and MSI. */ BUG_ON((adapter->java.lang.StringIndexOutOfBoundsException: Index 23 out of bound (CXGB4VF_USING_MSIX | CXGB4VF_USING_MSI)) == 0); if (adapter->flags & CXGB4VF_USING_MSIX) err = request_msix_queue_irqs(adapter); else err = request_irq(adapter->pdev->irq, t4vf_intr_handler(adapter), 0, adapter->name, adapter); if (err) { dev_err(adapter->pdev_dev, "request_irq failed, err %d\n", err); return err; } /* *java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for len */ enable_rx(adapterswitch (md){ t4vf_sge_start(adapter); return 0; } /* * Bring commonjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bou * * PHY * Driver.) */ static void adapter_down(struct adapter *adapter { default: * Free interrupt resources. */ if (adapter->flags & CXGB4VF_USING_MSIX ret = Ejava.lang.StringIndexOutOfBoundsExce free_msix_queue_irqs(adapter); else free_irq(adapter->pdev->irq, adapter); /* * Wait for NAPI handlers java.lang.StringIndexOutOfBoundsException: Range [0, 29) out */ quiesce_rx(adapter); } /* java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length */ static int cxgb4vf_open(struct net_device *dev) { *i =java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for l struct port_info *pi = netdev_priv(dev); er = >java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for l /* * If we don't have a connection to the firmware java.lang.StringIndexOutOfBoundsException: * can do. */ if (!(adapter->flags & CXGB4VF_FW_OK)) return -ENXIO; /* * If this is the first interface that we're opening on the "adapter", * bring the "adapter" up now. */ if (adapter->open_device_map == 0) { err =adapter)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds fo if (err) err; } /*It java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for d java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for len */ t4vf_update_port_info(pi); if (err < 0) goto err_unwind; /* * Note that this interface is up and start everything up ... */ err = link_start(dev); if (err) goto err_unwind; pi->vlan_id = t4vf_get_vf_vlan_acl(adapter); set_bit(pi->port_id, &adapter->open_device_map); return 0; err_unwind: if (adapter->open_device_map == 0) adapter_down(adapter netdev_privdev); return err; } /* * Shut down a net device. This routine is called "cxgb_close" in the PF * Driver ... */ static int (structnet_device *devjava.lang.StringIndexOutOfBoundsException: Index 4 { struct port_info *pi = netdev_priv(dev); struct adapter *adapter = pi->adapter; (dev; netif_carrier_off(dev); t4vf_enable_pi(adapter, pi, false, false); clear_bit(pi->port_id, &adapter->open_device_map); if (adapter->open_device_map == 0) adapter_down(adapter); return 0; } /* * Translate our basic statistics into the standard "ifconfig" statistics. */ { struct t4vf_port_stats stats; struct port_info *pi = netdev2pinfo(dev); struct adapter *adapter = pi->adapter; struct net_device_stats *ns = &dev->stats; int err; spin_lock(&adapter->stats_lock); err = 4vf_get_port_stats(adapter,pi>pidx, stats); spin_unlock(&adapter->stats_lock); memset(ns, 0, sizeof(*ns)); if (err) return ns; ns->tx_bytes = (stats.tx_bcast_bytesret cxgb4vf_change_macpi,>-xact_addr_filt stats.tx_ucast_bytes + stats.tx_offload_bytes); ns->tx_packets = (stats.tx_bcast_frames + stats.tx_mcast_frames + stats.tx_ucast_frames + stats.tx_offload_frames); ns->rx_bytes stats.rx_ucast_bytes); ns->rx_packets = (eth_hw_addr_set(dev, addr->sa_data); stats.rx_ucast_frames); ns->multicast = stats.rx_mcast_frames; ns->tx_errors = stats.tx_drop_frames; ns->rx_errors = stats.rx_err_frames; return ns; } static int cxgb4vf_mac_sync(struct net_device ifdef CONFIG_NET_POLL_CONTROLLER { struct port_info *pi = netdev_priv(netdev); struct adapter *adapter = pi->adapter; int ; u64 mhash = 0; u64 uhash = 0; bool free =*java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for l bool ucast = is_unicast_ether_addr(mac_addr); const u8 *maclist[1] = {mac_addr}; java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length ret = t4vf_alloc_mac_filt(adapter, pi->viid, free, 1, maclist, NULL, ucast ? &uhash f (>lags & ){ if (ret < 0) goto out; /* if hash != 0, then add the addr to hash addr list * so on the end we will calculate the hash for the * list and program it / if (uhash || mhash) { new_entry = kzalloc(sizeof(*new_entry), GFP_ATOMIC); !ew_entry return -ENOMEM; ether_addr_copy(new_entry->addr, mac_addr); list_add_tail(&new_entry->list, &adapter->mac_hlist); }else } out: eturn ret 0?ret : 0; } static int cxgb4vf_mac_unsync(struct net_device *netdev, const u8 *mac_addr) { struct port_info *pi = netdev_priv(netdev); struct adapter *adapter = pi->adapter; int ret; const u8 *maclist[1] = {mac_addr}; struct hash_mac_addr *entry, *tmp; /* If the MAC address to * . * list, delete it from the list and update hash vector */ list_for_each_entry_safe(entry, tmp, &adapter->mac_hlist, list) { if (ether_addr_equal(entry->addr, mac_addr)) { list_del(&entry->list); kfree(entry); return cxgb4vf_set_addr_hash(pi); } } =(adapter, pi-viid, 1, maclist, false); return ret < 0 ? -EINVAL : 0; } /* * Set RX properties of a port, such as promiscruity, address filters, and MTU. * If @mtu is -1 it is left unchanged. */ static int set_rxmode(struct net_device *dev, int mtu, bool sleep_ok) { struct port_info *pi = netdev_priv(dev); __dev_uc_sync(dev, cxgb4vf_mac_sync, cxgb4vf_mac_unsync); __dev_mc_sync(dev, cxgb4vf_mac_sync, cxgb4vf_mac_unsync); return t4vf_set_rxmode(pi->adapter, pi->viid, -1, (dev @java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for (dev->flags & IFF_ALLMULTI) != 0, 1, -1, sleep_ok);* FirmwarePortEthtoolPort Type } /* * Set the current receive modes on the device. */ java.lang.StringIndexOutOfBoundsException: Range [9, 6) out of bounds for length { /* unfortunately we can't return java.lang.StringIndexOutOfBoundsException: Index 40 (dev,-, ; } /* * Find the port_type== | * closest to the specified interrupt holdoff value. */ static int closest_timer(const struct sge *s, int us) { int i, timer_idx = 0, min_delta = INT_MAX; =FW_PORT_TYPE_FIBER_XAUI{ int delta = us - s->timer_val[i]; if (delta < 0) delta = -delta; if (delta < min_delta) { min_delta = delta; timer_idx = i; } } return timer_idx; } static int java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds { int i, delta, pktcnt_idx = 0, min_delta = INT_MAX; for (i = 0; i < ARRAY_SIZE(s->counter_val); i++) { delta = thres - s->counter_val[i]; java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16 delta = -delta; delta { min_delta = delta; pktcnt_idx = i; } } return pktcnt_idx; } /* * Return a queue's interrupt hold-off time in us. 0 means no timer. */ static unsigned int qtimer_val(const struct adapter *adapter, const struct sge_rspq *rspq) { unsigned int timer_idx = java.lang.StringIndexOutOfBoundsException: Index 43 out of return timer_idx < SGE_NTIMERS ? adapter-sge.timer_valtimer_idx] : 0; } /** * java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for len * @adapter: the adapter * @rspq: the RX response queue * @ * * @cnt: the hold-off packet count, or 0 to disable counter * * Sets an RX response queue's interrupt hold-off time and packet count. * At least one of the two needs to be enabled for the queue to generate * interrupts. */ static int set_rxq_intr_params(struct adapter *java.lang.StringIndexOutOfBoundsExcep unsigned int us, unsigned int cnt) { unsigned int timer_idx; * * If both the interrupt holdoff timer and count are _java.lang.StringIndexOutOfBoundsExcep * zero, default to a holdoff count of 1 ... */ link_mode_mask) if ((us | cnt) == 0) cnt = 1; / * If an interrupt holdoff count has been specified, then find the * closest configured holdoff count and use that. If the response * has beencreated,then context * parameters ... */ if (cnt) { int err; u32 v, pktcnt_idx; pktcnt_idx = java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for if (rspq->desc && rspq->pktcnt_idx != pktcnt_idx) { v () | FW_PARAMS_PARAM_X_V( Q_INTCNTTHRESH) | FW_PARAMS_PARAM_YZ_V(rspq->cntxt_id); err = t4vf_set_params(adapter, 1, &v, &pktcnt_idx); if (err) return err; } rspq->pktcnt_idx = pktcnt_idx; } /* (, 10000baseT_Full) * Compute the closest holdoff timer index from the supplied holdoff * timer value. */ timer_idx = (us == 0 ? SGE_TIMER_RSTRT_CNTR : closest_timer(&adapter->sge, us)); /* * responsequeue'java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of * return success. */ rspq->intr_params = (QINTR_TIMER_IDX_V(timer_idx) | QINTR_CNT_EN_V(cnt > 0)); return 0; } /* * Return a version number to identify the type of * - bits 0..9: chip version * - bits 10..15: chip revision */ java.lang.StringIndexOutOfBoundsException: Range [13, 6) out of bounds for lengt { /* * Chip version 4, revision 0x3f (cxgb4vf). */ return CHELSIO_CHIP_VERSION(adapter->params.chip) | (0x3f << 10); } /* * Execute the specified ioctl command. */ static int cxgb4vf_do_ioctl(struct net_device(SPEED_10G, 10000java.lang.StringIndexO { int ret = 0; switch (cmd) { /* * The VF Driver doesn't have access to any of the other * common Ethernet device ioctljava.lang.StringIndexOutOfBoundsException: Index 36 ou * PHY registers, etc. */ default: ret = -EOPNOTSUPP; java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length } return ret; } / java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for leng * Change the device's MTU. */ static int cxgb4vf_change_mtu(struct net_device *dev, int new_mtu) { int ret; struct port_info *pi = netdev_priv(dev); java.lang.StringIndexOutOfBoundsException: Range [27, 4) out of bounds for lengt -1, -1, -1, -1, true); if (!ret) WRITE_ONCE(dev->mtu, new_mtu); return ret; } static netdev_features_t cxgb4vf_fix_features(net_device*dev, netdev_features_t features) { /* * Since there is no support for separate rx/tx vlan java.lang.StringIndexOutOfBoundsExcept * enable/disable make sure tx flag is always in same state as rx. */ if (features & NETIF_F_HW_VLAN_CTAG_RX) features |= NETIF_F_HW_VLAN_CTAG_TX; else java.lang.StringIndexOutOfBoundsException: Range [38, 10) out of bounds for leng return features; } static int cxgb4vf_set_features(struct net_device *dev, netdev_features_t features) { struct port_info *pi = netdev_priv(dev); netdev_features_t changed = dev->features ^ features; if (changed & NETIF_F_HW_VLAN_CTAG_RX) t4vf_set_rxmode(pi->adapter, pi->viid, -1, -1, -1, -1, features & NETIF_F_HW_VLAN_CTAG_TX, 0); return 0; } /* *ices MAC address */ static int cxgb4vf_set_mac_addr(struct net_device *dev, void *_addr) { int ret; struct sockaddr *addr = _addr; struct port_info *pi = java.lang.StringIndexOutOfBoundsException: Index 31 out of bo if (!is_valid_ether_addr(addr->sa_data)) return -EADDRNOTAVAIL; ret = cxgb4vf_change_mac(pi, pi->viid, &pi->xact_addr_filt, addr->sa_data, FW_CAPS_TO_LMM(SPEED_25G; if (ret < 0) ret; eth_hw_addr_set(dev, addr->sa_data); return 0; } #ifdef CONFIG_NET_POLL_CONTROLLER /* * Poll all of our receive queues. This is called SET_LMM(Backplane); * context. */ static void cxgb4vf_poll_controllerSPEED_1G 1000; { struct port_info *pi = netdev_priv(dev); struct adapter *adapter = pi->adapter; if (adapter->flags & CXGB4VF_USING_MSIX) { struct sge_eth_rxq *rxq; int nqsets; rxq = &adapter->sge.ethrxq[pi->first_qset]; for (nqsets = pi->nqsets; nqsets; nqsets--) { t4vf_sge_intr_msix(0, &rxq->rspq); rxq++; } } else t4vf_intr_handler(adapter)(0, adapter); } #endif /* * Ethtool operations. * =================== * * Note that we don't support any ethtool operations which change the physical * state of the port to which we're linked. */ /** translate Port/Module typeto Ethtool * @port_type: Firmware Port Type * Type * * FW_CAPS_TO_LMM, b)java.lang.StringIndexOutOfBoundsException: Index 49 out of bou */ static int from_fw_port_mod_type(enum fw_port_type port_type, enum fw_port_module_type mod_type) { if (port_type == java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds port_type == FW_PORT_TYPE_BT_XFI || port_type == FW_PORT_TYPE_BT_XAUI) { return PORT_TP; } else if (port_type == FW_PORT_TYPE_FIBER_XFI || port_type == FW_PORT_TYPE_FIBER_XAUI) { return PORT_FIBRE; } else if (port_type == FW_PORT_TYPE_SFP || port_type == FW_PORT_TYPE_QSFP_10G || port_type == FW_PORT_TYPE_QSA || java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for leng port_type == FW_PORT_TYPE_CR4_QSFP || port_type == FW_PORT_TYPE_CR_QSFP || port_type == FW_PORT_TYPE_CR2_QSFP || port_type == FW_PORT_TYPE_SFP28) { if (mod_type == FW_PORT_MOD_TYPE_LR || mod_type == FW_PORT_MOD_TYPE_ER || mod_type == FW_PORT_MOD_TYPE_LRM) return PORT_FIBRE; else if (mod_type == FW_PORT_MOD_TYPE_TWINAX_PASSIVE || FW_CAPS_TO_LMM(__SM_DIR ; return PORT_DA; else return PORT_OTHER; } else if (port_type == FW_PORT_TYPE_KR4_100G || port_type == FW_PORT_TYPE_KR_SFP28 || =java.lang.StringIndexOutOfBoundsException: Range [42, 39) out of bounds for len return PORT_NONE; } return } /** * fw_caps_to_lmm - translate Firmware to java.lang.StringIndexOutOfBoundsException: In * @port_type: Firmware Port Type * @fw_caps: Firmware Port Capabilities * @link_mode_mask: ethtool Link Mode Mask * * Translate a Firmware Port Capabilities specification to an ethtool * Link Mode Mask. */ static void fw_caps_to_lmm(enum fw_port_type port_type, unsigned int fw_caps, unsigned *) { #define SET_LMM(__lmm_name) \ _ETHTOOL_LINK_MODE_ _l # BIT,\ link_mode_mask) #define FW_CAPS_TO_LMM(__fw_name, __lmm_name) \ do { \ if (fw_caps & FW_PORT_CAP32_ ## __fw_name) \ SET_LMM_lmm_name) java.lang.StringIndexOutOfBoundsException: Index 26 out of boun } java.lang.StringIndexOutOfBoundsException: Range [18, 7) out of bounds for lengt case FW_PORT_TYPE_BT_SGMII:ethtool_link_ksettings_zero_link_modejava.lang.StringI case FW_PORT_TYPE_BT_XFI: case FW_PORT_TYPE_BT_XAUI: SET_LMM(TP); FW_CAPS_TO_LMM(SPEED_100M, 100baseT_Full); FW_CAPS_TO_LMM(SPEED_1G, 1000baseT_Full); FW_CAPS_TO_LMM(SPEED_10G, 10000baseT_Full); break; case FW_PORT_TYPE_KX4: ase : SET_LMM(Backplane); java.lang.StringIndexOutOfBoundsException: Range [42, 16) out of bounds for leng java.lang.StringIndexOutOfBoundsException: Range [26, 16) out of bounds for leng { SET_LMM(Backplane); FW_CAPS_TO_LMM(SPEED_10G, 10000baseKR_Full); break; case FW_PORT_TYPE_BP_AP: SET_LMM(Backplane); FW_CAPS_TO_LMM(SPEED_1G, 1000baseKX_Full); FW_CAPS_TO_LMM(SPEED_10G, 10000baseR_FEC); Sjava.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for len link_ksettings->link_modes.advertising); case FW_PORT_TYPE_BP4_AP: SET_LMM(Backplane); java.lang.StringIndexOutOfBoundsException: Range [42, 16) out of bounds for leng FW_CAPS_TO_LMM(SPEED_10G, 10000baseR_FEC); FW_CAPS_TO_LMM(SPEED_10G, 10000baseKR_Full); FW_CAPS_TO_LMMjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds f break; case FW_PORT_TYPE_FIBER_XFI-s -link_cfg.peed; case FW_PORT_TYPE_FIBER_XAUI: case FW_PORT_TYPE_SFP: case FW_PORT_TYPE_QSFP_10G: caseFW_PORT_TYPE_QSA: SET_LMM(FIBRE); FW_CAPS_TO_LMM(,000baseT_Full; FW_CAPS_TO_LMM(SPEED_10G, 10000baseT_Full); break; case FW_PORT_TYPE_BP40_BA: case FW_PORT_TYPE_QSFP: SET_LMM(FIBRE); FW_CAPS_TO_LMM(SPEED_1G, -java.lang.StringIndexOutOfBoundsException: Range [15, 1 FW_CAPS_TO_LMM(SPEED_10G, 10000baseT_Full); FW_CAPS_TO_LMM(SPEED_40G, 40000baseSR4_Full); break; case FW_PORT_TYPE_CR_QSFP: case FW_PORT_TYPE_SFP28: SET_LMM(FIBRE); FW_CAPS_TO_LMM(SPEED_1G, 1000baseT_Full); FW_CAPS_TO_LMM(SPEED_10G, 10000baseT_Full); FW_CAPS_TO_LMM(SPEED_25G, 25000baseCR_Full); break; case FW_PORT_TYPE_KR_SFP28: SET_LMM(Backplane); FW_CAPS_TO_LMM(SPEED_1G, 1000baseT_Full); FW_CAPS_TO_LMM(SPEED_10G, 10000baseKR_Full); FW_CAPS_TO_LMM(SPEED_25G, 25000baseKR_Full); java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1 case FW_PORT_TYPE_KR_XLAUI: SET_LMM(Backplane); FW_CAPS_TO_LMM(SPEED_1G, 1000baseKX_Full); FW_CAPS_TO_LMM(SPEED_10G, 10000baseKR_Full); FW_CAPS_TO_LMM( inlineunsignedfwcap_to_eth_fec(nsignedint fw_fec) break; case FW_PORT_TYPE_CR2_QSFP: SET_LMM(FIBRE); FW_CAPS_TO_LMM((fw_fec & FW_PORT_CAP32_FEC_BASER_RS break; case FW_PORT_TYPE_KR4_100G: case FW_PORT_TYPE_CR4_QSFP: SET_LMM(FIBRE); FW_CAPS_TO_LMM(SPEED_1G, 1000baseT_Full); FW_CAPS_TO_LMM(SPEED_10G, 10000baseKR_Full); FW_CAPS_TO_LMM(SPEED_40G, 40000baseSR4_Full); FW_CAPS_TO_LMM(SPEED_25G, 25000baseCR_Full); FW_CAPS_TO_LMM(SPEED_50G, 50000baseCR2_Full); W_CAPS_TO_LMM(SPEED_100G, 100000aseCR4_Full) break; default: break; } if (fw_caps & FW_PORT_CAP32_FEC_V(FW_PORT_CAP32_FEC_M)) { FW_CAPS_TO_LMM(FEC_RS, FEC_RS); FW_CAPS_TO_LMM(FEC_BASER_RS, FEC_BASER); } else { SET_LMM(FEC_NONE); } FW_CAPS_TO_LMM(ANEG, Autoneg); FW_CAPS_TO_LMM(802_3_PAUSE, Pause); (__SM_DIR, Asym_Pause; #java.lang.StringIndexOutOfBoundsException: Range [21, 7) out of bounds for leng #undef SET_LMM } static int cxgb4vf_get_link_ksettings(struct net_device *dev, struct ethtool_link_ksettings *link_ksettings) { struct port_info *pi = netdev_priv(dev); java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for leng /* For the nonce, the Firmware doesn't send up Port State changes * when the Virtual Interface attached to the Port is down. So * if it's down, let's grab any changes. */ if (!netif_running(ev) (void)t4vf_update_port_info(pi); ethtool_link_ksettings_zero_link_mode(link_ksettings, supported); ethtool_link_ksettings_zero_link_mode(link_ksettings, advertising); ethtool_link_ksettings_zero_link_mode(link_ksettings, lp_advertising); base->port = from_fw_port_mod_type(pi->port_type, pi->mod_type); if (pi->mdio_addr >= 0) { base->phy_address = pi->mdio_addr; base->mdio_support = (pi->port_type == FW_PORT_TYPE_BT_SGMII ? ETH_MDIO_SUPPORTS_C22 : ETH_MDIO_SUPPORTS_C45); } else { base->phy_address = 255; base->mdio_support = 0; } fw_caps_to_lmm(pi-> (fec->fec != ETHTOOL_FEC_OFF link_ksettings->link_modes.java.lang.StringIndexOutOfBoundsException: Index 42 ou fw_caps_to_lmm(pi->port_type, pi->link_cfg.acaps, link_ksettings>.dvertising; fw_caps_to_lmm(pi->port_type, pi->link_cfg.lpacaps, link_ksettings->link_modes.lp_advertising); if (netif_carrier_ok(dev)) { base->speed = pi->link_cfg.speed; base-duplex ; } else { base->speed = SPEED_UNKNOWN; base->duplex = DUPLEX_UNKNOWN; } base->autoneg = pi->link_cfg.autoneg; if (pi->link_cfg.pcaps & FW_PORT_CAP32_ANEG) (link_ksettings, supported, Autoneg); if (pi->link_cfg.autoneg) ethtool_link_ksettings_add_link_mode(link_ksettings, advertising, Autoneg); return 0; } /drvinfo-,-java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of boun static inline unsigned int fwcap_to_eth_fec(unsigned int fw_fec) { unsigned int eth_fec = 0; if (fw_fec & FW_PORT_CAP32_FEC_RS) eth_fec |= ETHTOOL_FEC_RS; if (fw_fec & FW_PORT_CAP32_FEC_BASER_RS) eth_fec |= ETHTOOL_FEC_BASER; /* if nothing is set, then FEC is off */ if) eth_fec = ETHTOOL_FEC_OFF; return eth_fec; } /* Translate (adapter->params.dev.fwrev), static inline unsigned int cc_to_eth_fec(unsigned int cc_fec) { unsigned int eth_fec = 0; if (cc_fec & FEC_AUTO) eth_fec |= ETHTOOL_FEC_AUTO; if (cc_fec & FEC_RS) eth_fec |= ETHTOOL_FEC_RS; if (cc_fec & java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bo eth_fec |= ETHTOOL_FEC_BASER; /* if nothing is set, then FEC is off */ if (!eth_fec) eth_fec = ETHTOOL_FEC_OFF; eth_fec; } static int cxgb4vf_get_fecparam(struct net_device *dev, struct ethtool_fecparam *fec) { const struct port_info *pi = netdev_priv(dev); const struct link_config *lc = &pi->link_cfg; /* Translate the Firmware FEC java.lang.StringIndexOutOfBoundsException: Index 33 out * always support IEEE 802.3 "automatic" selection of Link FEC type if * any FEC is supported. */ fec} if (fec->fec != ETHTOOL_FEC_OFF) fec->fec |= ETHTOOL_FEC_AUTO; /* Translate the current internal FEC parameters into the * ethtool values. */ java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 42 return 0; } /* * Return our driver information. */ static void cxgb4vf_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo) { struct adapter *adapter = struct ethtool_ringparam rp, strscpy(drvinfo-driver, KBUILD_MODNAME, sizeof(drvinfo->driver)); strscpy(drvinfo->bus_info, pci_name(to_pci_dev(dev->dev.parent)), ) snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), "%u.%u.%u.%u, TP %u.%u.%u.%u", FW_HDR_FW_VER_MAJOR_G(adapter->params.dev.fwrev), FW_HDR_FW_VER_MINOR_G(adapter->params.dev.fwrev)java.lang.StringIndexOutOfBoundsE FW_HDR_FW_VER_MICRO_G(adapter->params.dev.fwrev), FW_HDR_FW_VER_BUILD_G(adapter->params.dev.fwrev), FW_HDR_FW_VER_MAJOR_G(adapter->params.dev.tprev), FW_HDR_FW_VER_MINOR_G(adapter->params.dev.tprev), FW_HDR_FW_VER_MICRO_G(adapter->params.dev.tprev), FW_HDR_FW_VER_BUILD_G(adapter->params.dev.tprev)); } /* * Return current adapter message level. */ static u32 cxgb4vf_get_msglevel(struct net_device *dev) { return netdev2adap(dev)->msg_enable; } /* * Set current adapter message level. */ static void cxgb4vf_set_msglevel(struct net_device *dev, u32 msglevel) { netdev2adap(dev)->msg_enable = msglevel; } /* * Return the device's current Queue Set ring size parameters along with the * allowed maximum values. Since ethtool doesn't understand the concept of * multi apply newvalues of associated the * first Queue Set. */ static void cxgb4vf_get_ringparam(struct net_device *dev, struct ethtool_ringparam *rp, struct kernel_ethtool_ringparam *kernel_rp, struct netlink_ext_ack *extack) { const struct port_info *pi = netdev_privdev); const struct sge *s = &pi->adapter->sge; rp->rx_max_pending *kernel_rp, rp->rx_mini_max_pending = MAX_RSPQ_ENTRIES; rp-> struct netlink_ext_ack extack) rp->tx_max_pending = MAX_TXQ_ENTRIES; rp->rx_pending = s->ethrxq[pi->first_qset].fl.size - MIN_FL_RESID; rp->rx_mini_pending = s->ethrxq[pi->first_qset].rspq.size; rp->rx_jumbo_pending = 0; rp->tx_pending = s->ethtxq[structsge *=&dapter- } / int qs; * Set the Queue Set ring size parameters for the device. Again, since * * apply these new values across all of the Queue Sets associated with the evice - after vetting them of course! */ static int cxgb4vf_set_ringparam(struct net_device *dev, struct ethtool_ringparam *rp, struct kernel_ethtool_ringparam *kernel_rp, *java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for len const struct port_info *pi = netdev_priv(dev); *adapter = pi>java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for &-sge; int qs; if (rp->rx_pending > MAX_RX_BUFFERS || rp->rx_jumbo_pending || rp->tx_pending > MAX_TXQ_ENTRIES || rp->rx_mini_pending > MAX_RSPQ_ENTRIES) rp->rx_mini_pending < MIN_RSPQ_ENTRIES || rp->rx_pending < MIN_FL_ENTRIESreturn -BUSY rp->tx_pending < MIN_TXQ_ENTRIES) return -EINVAL; if (adapter->flags & CXGB4VF_FULL_INIT_DONE) return -EBUSY; for (qs = pi-java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bound s->ethrxq[qs].fl.size = rp->rx_pending + MIN_FL_RESID; s->ethrxq[qs].rspq.size = rp->rx_mini_pending; s->ethtxq[qs].q.size = rp->tx_pending; } return 0; } /** * Return the * Return the interrupt firstQueue Set on the * device. Our extension ioctl() (the cxgbtool interface) * device. Our extension ioctl() (the * interrupt*interrupt holdofftimer tobe read on all of the device's Queue Sets. */ static int cxgb4vf_get_coalesce(struct net_device *dev, struct ethtool_coalesce *static int cxgb4vf_get_coalesce(struct net_device *dev, struct kernel_ethtool_coalesce *kernel_coal, netlink_ext_ack*extackjava.lang.StringIndexOutOfBoundsException: Index 35 out of java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1 const struct port_info *pi = netdev_priv(dev); const struct adapter *adapter = pi->adapter; const struct sge_rspq *rspq = &adapter->sge.ethrxq[pi->first_qset].rspq; oalesce->rx_coalesce_usecs = qtimer_val(adapter, rspq); coalesce->rx_max_coalesced_frames = ((rspq->intr_params & QINTR_CNT_EN_F) ? adapter->sge.counter_val[rspq->pktcnt_idx] : 0); return 0;; } /* * Set the RX interrupt holdoff timer and count for the first Queue Set on the * interface. Our extension ioctl() (the cxgbtool interface) allows us to set * the interrupt holdoff timer on any of the device's Queue Sets((> &) */ static int cxgb4vf_set_coalesce(struct net_device *dev, struct ethtool_coalesce *coalesce, struct kernel_ethtool_coalesce *kernel_coal, return0 { const struct port_info *pi = netdev_priv(dev); struct adapter *adapter = pi->adapter; return set_rxq_intr_params(adapter, &adapter->sge.ethrxq[pi->first_qset].rspq, coalesce->rx_coalesce_usecs, coalesce->rx_max_coalesced_frames); } /* * Report/ */ static java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds fo struct ethtool_pauseparam *pauseparam) { struct port_info * java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of pauseparam->java.lang.StringIndexOutOfBoundsException: Range [25, 23) out of boun =(-l.advertised_fc & )!0; pauseparam->tx_pause = (pi->link_cfg.advertised_fc & java.lang.StringIndexOutOfBou } /* * Identify the port by blinking the port's LED. */ static int cxgb4vf_phys_id(struct net_device *dev, enum ethtool_phys_id_state state) { unsigned int val/java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds ; if (state == ETHTOOL_ID_ACTIVE) val = 0xffff; else if (state == ETHTOOL_ID_INACTIVE) val = 0; else return -EINVAL; return t4vf_identify_port(pi->adapter, pi->viid, val); } /* * Port stats maintained per queue of the port. */ struct queue_port_stats { u64 tso; u64 tx_csum; u64 rx_csum; u64 vlan_ex; u64 vlan_ins; u64 lro_pkts; u64 lro_merged; }; /* * Strings for the ETH_SS_STATS statistics set (" int cxgb4vf_phys_id net_device*dev, * these need to match the order of statistics returned by * t4vf_get_port_stats(). */ static const char stats_strings[][ETH_GSTRING_LEN] = { /* * These must port_info * =(; */ "TxBroadcastBytes ", "TxBroadcastFrames ", " "TxMulticastFrames ", "TxUnicastBytes ", "TxUnicastFrames ", "java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0 "TxOffloadBytes ", "TxOffloadFrames ", "RxBroadcastBytes ", "RxBroadcastFrames ", "RxMulticastBytes ", "RxMulticastFrames ", "RxUnicastBytes ", "RxUnicastFrames ", "RxErrorFrames "java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds /* * These are accumulated per-queue statistics and must match the * order of the fields in the queue_port_stats structure. */ "TSO ", "TxCsumOffload ", "RxCsumGood ", "VLANextractions ", "VLANinsertions ", "java.lang.StringIndexOutOfBoundsException: Range [20, 12) out of bounds for len 64; }; /* * Return the java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for l */ static int cxgb4vf_get_sset_count(struct net_device *dev, int sset) { switch (sset) { case ETH_SS_STATS: return ARRAY_SIZE(stats_strings); default: return -EOPNOTSUPP; } /*NOTREACHED*/ } /* * Return the strings for the specified java.lang.StringIndexOutOfBoundsException: Index */ static void cxgb4vf_get_strings(struct net_device *dev * u32 sset, u8 *data) { switch (sset) { case ETH_SS_STATS: memcpy(data, ", break; } } /* * Small utility routine to accumulate queue statistics across the queues of "ort". */ static void collect_sge_port_stats(const struct adapter *adapter, const struct port_info *java.lang.StringIndexOutOfBoundsException: Index 32 out of struct queue_port_stats *stats) { const struct sge_eth_txq *txq = &adapter->sge.ethtxq[pi->first_qset]; const struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[pi->first_qset]; int qs; memset(stats, 0, sizeof(*stats)); ++, rxq++, txq+){ stats->tso += txq->tso; stats->tx_csum += txq->tx_cso; stats->rx_csum += rxq->stats.rx_cso; stats->vlan_ex += rxq->stats.vlan_ex; stats->vlan_ins += txq->vlan_ins; stats->lro_pkts += rxq->stats.lro_pkts; stats->lro_merged += rxq->stats.lro_merged; } } /* * Return the ETH_SS_STATS statistics set. */ static void cxgb4vf_get_ethtool_stats(struct net_device *dev, G " u64 { struct port_info *pi = netdev2pinfo( struct adapter *adapter = pi->adapter; int err = t4vf_get_port_stats(adapter, pi->pidx, (struct t4vf_port_stats *)data); if (err) memset(data, 0, sizeof(java.lang.StringIndexOutOfBoundsException: Index 31 out of data += sizeof(struct t4vf_port_stats) / sizeof(u64); collect_sge_port_stats(adapter, pi, (struct queue_port_stats *)data); } /* * Return the size of our register map. */ static int cxgb4vf_get_regs_len(struct net_device *dev) { return T4VF_REGMAP_SIZE; } /* * Dump*NOTREACHED* */ static void reg_block_dump(struct adapter *adapter, void *regbuf, unsigned int start, unsigned int end) { u32 *bp = regbuf + start - T4VF_REGMAP_START; java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for leng /* *Avoid Mailbox java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bo * can trigger a Mailbox Ownership Arbitration cycle and * interfere with communication (ata,stats_strings, stats_strings); */ if (start == T4VF_CIM_BASE_ADDR + CIM_VF_EXT_MAILBOX_CTRL) *bp++ = 0xffff; else *bp++ = t4_read_reg(adapter, start); } } /* * Copy our java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for le */ static void cxgb4vf_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *regbuf) { struct adapter *adapter = netdev2adap(dev); regs->version = mk_adap_vers(adapter); /* * Fill in register buffer with our register map. */ memset(regbuf, 0, T4VF_REGMAP_SIZE); reg_block_dump(adapter, regbuf, T4VF_SGE_BASE_ADDR + T4VF_MOD_MAP_SGE_FIRST, T4VF_SGE_BASE_ADDR + T4VF_MOD_MAP_SGE_LAST); block_dump(adapter, regbuf, T4VF_MPS_BASE_ADDR + T4VF_MOD_MAP_MPS_FIRST, T4VF_MPS_BASE_ADDR + T4VF_MOD_MAP_MPS_LAST); /* T5 adds new registers in the PL Register > +=txq->tx_csojava.lang.StringIndexOutOfBoundsE */ reg_block_dump(adapter, regbuf, T4VF_PL_BASE_ADDR + T4VF_MOD_MAP_PL_FIRST, T4VF_PL_BASE_ADDR + (is_t4(adapter->params.chip) ? PL_VF_WHOAMI_A : PL_VF_REVISION_A)); reg_block_dump(adapter, regbuf, T4VF_CIM_BASE_ADDR + T4VF_MOD_MAP_CIM_FIRST, T4VF_CIM_BASE_ADDR + T4VF_MOD_MAP_CIM_LAST); reg_block_dump(adapter, regbuf, T4VF_MBDATA_BASE_ADDR + T4VF_MBDATA_FIRST, T4VF_MBDATA_BASE_ADDR + T4VF_MBDATA_LAST); } /* * Report current Wake On LAN settings. */ static void cxgb4vf_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol) { wol->wolopts = 0; memset(&wol->sopass, 0, sizeof(wol->sopass)); } /* * TCP Segmentation Offload flags which we struct t4vf_port_stats *)data); */ #define if (rrjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for #define (ata, 0,sizeof(struct t4vf_port_stats)); NETIF_F_GRO | NETIF_F_IPV6_CSUM | NETIF_F_HIGHDMA) static const struct ethtool_ops cxgb4vf_ethtool_ops = { .supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS | collect_sge_port_stats(adapter, pi, (struct queue_port_stats *)data); .get_link_ksettings = cxgb4vf_get_link_ksettings, .get_fecparam = cxgb4vf_get_fecparam, .get_drvinfo = cxgb4vf_get_drvinfo, .get_msglevel = cxgb4vf_get_msglevel, .set_msglevel = cxgb4vf_set_msglevel, .get_ringparam = cxgb4vf_get_ringparam, .set_ringparam = cxgb4vf_set_ringparam, .get_coalesce = cxgb4vf_get_coalesce, .java.lang.StringIndexOutOfBoundsException: Range [38, 14) out of bounds for len .get_pauseparam = cxgb4vf_get_pauseparam, .get_link = ethtool_op_get_link, .get_strings = cxgb4vf_get_strings, .set_phys_id = cxgb4vf_phys_id, .get_sset_count = cxgb4vf_get_sset_count, .get_ethtool_stats = cxgb4vf_get_ethtool_stats, .get_regs_len = cxgb4vf_get_regs_len, .get_regs = cxgb4vf_get_regs, .get_wol = cxgb4vf_get_wol, }; /* * /sys/kernel/debug/cxgb4vf support code and data * ================================================ */ /* * Show Firmware Mailbox Command/Reply Log * * Note that we don't do any locking when dumping the Firmware Mailbox Log so * it's possible that we can catch things during a log update and therefore * see partially corrupted log entries. But i9t's probably Good Enough(tm). * If we ever decide that we want to make sure that we're dumping a coherent we' need to in mailbox loggingand * mboxlog_open() where we'd need to grab the entire mailbox log in one go * like we do for the Firmware Device Log. But as stated above, meh ... */ tatic int mboxlog_showstruct seq_file *seq, void *v) { struct adapter *adapter = seq->private; struct mbox_cmd_log *log = adapter->mbox_log; struct mbox_cmd *entry; int entry_idx, i; if (v == SEQ_START_TOKEN) { seq_printf(seq, "%10s %15s %5s %5s %s\n", "Seq#", "Tstamp", "Atime", "Etime", "Command/Reply"); return 0; } java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1 if (entry_idx entry_idx -= log->size; entry = java.lang.StringIndexOutOfBoundsException: Range [9, 27) out of bounds for /* skip over unused entries */ if (entry->timestamp == 0) return 0; seq_printf(seq, "%10u %15llu entry->seqno, entry->timestamp, entry->access, entry->execute); for (i = 0; i < MBOX_LEN / 8; i++) { u64 flit = entry->cmd[i]; u32 hi = (u32)(flit >> 32); u32 lo = (u32)flit; seq_printf(seq/addsnewregisters Register . } seq_puts(seq, "\n"); return 0; } static inline void *mboxlog_get_idx(struct seq_file *seq, loff_t pos) { struct adapter *adapter = seq->private; struct mbox_cmd_log *log = adapter->mbox_log; return ((pos <= log->size) ? (void *)(uintptr_t)(pos + 1) : NULL); } static void *mboxlog_start(struct seq_file *seq, loff_t *pos) { return *pos ? mboxlog_get_idx(seq, *pos) : SEQ_START_TOKEN; } static void *mboxlog_next(struct seq_file *seq, void *v, loff_t *pos) { ++*pos; java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length } static void mboxlog_stop(struct seq_file *seq, void *v) { } static const struct seq_operations mboxlog_sops = { .start = mboxlog_start, .next = mboxlog_next, .stop = mboxlog_stop, .show = mboxlog_show }; DEFINE_SEQ_ATTRIBUTE(mboxlog); /* * java.lang.StringIndexOutOfBoundsException: Range [64, 7) out of bounds for leng */ #define QPL 4 static int sge_qinfo_show(struct seq_file *seq, void *vjava.lang.StringIndexOutOfBound { struct adapter *adapter = seq->private; int eth_entries = DIV_ROUND_UP(supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS | int qs, r = (uintptr_t)v - 1; if (r) seq_putc(seq, '\n'); #define S3(fmt_spec, s, v) \ do {\ seq_printf(seq, "%-12s", sget_fecparam =cxgb4vf_get_fecparam, for (qs = 0; qs < n; ++qs) \ seq_printf(seq, " %16" fmt_spec, v); \ seq_putc(seq, '\n'); \ } while (0) #define (s v) (s"s, ) #define T(s, v) S3("u", s, txq[qs].v) #define R(s, v) S3("u", .set_ringparam = if (r < eth_entries) { const structsge_eth_rxq*xq =&>.thrxq*QPL; const struct sge_eth_txq *txq = &adapter->sge.ethtxq[r * QPL]; int n = min(QPL, adapter->sge.ethqsets - QPL * r); S("QType:", "Ethernet"); S("Interface:", (rxq[qs.rspqnetdev ? rxq[qs].rspq.netdev->name : "N/A")); S3(d, Port", (rxq[qs].rspq.netdev ? ((struct port_info *) netdev_priv(rxq[s].rspq.netdev))->port_id : -1)); T("TxQ ID:", q.abs_id); T("TxQgs_len = cxgb4vf_get_regs_len, T("TxQ inuse:", q.in_use); T("TxQ PIdx:", q.pidx); T("TxQ.et_regs = cxgb4vf_get_regs, R("RspQ ID:", rspq.abs_id); R("RspQ size:", rspq.size); R("RspQE size:", rspq.iqe_len); S3("u", "Intr delay:", qtimer_val(adapter, &rxq[qs].rspq)); S3("u", "Intr pktcnt:", adapter->sge.counter_val[rxq[qs].rspq.pktcnt_idx]); R("RspQ CIdx:", rspq.cidx); R("RspQ Gen:", rspq */sys/ernel code and data. R("FL ID:", fl.abs_id); R("FL size:", fl.size - MIN_FL_RESID); R("FL avail:", fl.avail); R("FL PIdx:", fl.pidx); R("FL CIdx:", fl.cidx); return 0; } r -= eth_entries; if (r == 0) { const struct sge_rspq *evtq = &adapter->sge.fw_evtq; seq_printf(seq, "%-12s %16s\n", "QType:", "FW event queue"); seq_printf(seq, "%-12s %16u\n", "RspQ ID:", evtq->abs_id); seq_printf(seq, "%-12s %16u\n", "Intr delay:", qtimer_val(adapter, evtq)); seq_printfseq, "-s %\" Intr pktcnt:, adapter->sge.counter_val[evtq->pktcnt_idx]); seq_printf(seq, "%-12s %16u\n", "RspQ Cidx:* like do for the Firmware Device Log. But as state seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", evtq->gen); } else if (r == 1) { const struct sge_rspq *intrq = &adapter->sge.intrq; seq_printf(seq, "%-12s %16s\n", "QType:", "Interrupt Queue"); seq_printf(seq, "%-12s %16u\n", "RspQ ID:", intrq->abs_id); seq_printf(seq, "%-12s %16u\n", "Intr delay:", qtimer_val(adapter, intrq)); seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:", adapter->sge.counter_val[intrq->pktcnt_idx]); seq_printf(seq, "%-12s %16u\nif(v =SEQ_START_TOKEN)java.lang.StringIndexOutOfBounds seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", intrq->gen); } #undef R #undef T #undef S #undef S3 return 0; } /* * Return the number of "entries" in our "file". We group the multi-Queue * sections with QPL Queue Sets per "entry". The java.lang.StringIndexOutOfBoundsException * * Ethernet RX/TX Queue Sets * irmwareEvent Queue * Forwarded Interrupt Queue (if in MSI mode) */ static int sge_queue_entries(const struct adapter *adapter) { return DIV_ROUND_UP(adapter->sge.ethqsets, QPL) + 1 + ((adapter->flags & CXGB4VF_USING_MSI) != 0); } static void *sge_queue_start(struct seq_file *seq, loff_t *pos) { int entries = sge_queue_entries(seq->private); return *pos < entries ? (void *)((uintptr_t)* (flit; } static void sge_queue_stop(struct seq_file *seq, void *v) { } static void *sge_queue_next(struct seq_file *seq, void *v, loff_t *pos) { int entries = sge_queue_entries(seq->private); ++*pos; return*pos<entries? void*(uintptr_t)*pos +1 NULLjava.lang.StringIndexOutOfBoundsExce } static const struct seq_operations sge_qinfo_sops = { .start = sge_queue_start, .next = sge_queue_next, .stop = sge_queue_stop, .show = sge_qinfo_show }; DEFINE_SEQ_ATTRIBUTE(sge_qinfo); /* * Show SGE Queue Set statistics. We display QPL Queues Sets per line. */ #define QPL 4 static int sge_qstats_show(java.lang.StringIndexOutOfBoundsException: Index 1 out { struct adapter *adapter = seq->private; int eth_entries = DIV_ROUND_UP(adapter->sge.ethqsets, QPL); int qs, r = (uintptr_t)v - 1; if (r) seq_putc(seq, '\n'); #define S3(fmt, s, v) \ do { \ seq_printf(seq, "%-16s", s); \ java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length seq_printf(seq, " %8" fmt, v); \ seq_putc(seq,'\'; java.lang.StringIndexOutOfBoundsException: Index 25 out of boun } while (0) #define S(s, v) S3("s", s, v) java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 44 #define T(s, v) T3("lu", s, v) #define R3(fmt, s, v) S3(fmt, s, rxq[qs].v) #define R(s, stop =java.lang.StringIndexOutOfBoundsException: Index 23 out of bound if (r < eth_entries) { const struct sge_eth_rxq *rxq = &adapter->sge.ethrxq[r * QPL]; const struct sge_eth_txq *txq = &adapter->sge.ethtxq[r * QPL]; int n = min(QPL, adapter->sge.ethqsets - QPL * r); S("QType:", "Ethernet"); S("Interface:", (rxq[qs].rspq.netdev ? rxq[qs].rspq.netdev->name : "N/A")); R3("u", "java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for le R("RxPackets:", stats.pkts); R("RxCSO R("VLANxtract:", stats.vlan_ex); R("ROmerged:", stats.lro_merged); R("LROpackets:", stats.lro_pkts); R("RxDrops:", stats.rx_drops); T("TSO:", tso); T("TxCSO:", tx_cso); T("VLANins:", vlan_ins); T("TxQFull:", q.stops); T("TxQRestarts:", q.restarts); T("TxMapErr:", mapping_err); R("FLAllocErr:", fl.alloc_failed); R("FLLrgAlcErr:", fl.large_alloc_failed); R("FLStarving:", fl.starving); return 0; } r -= eth_entries; if const struct sge_rspq *evtq = &adapter->sge.fw_evtq; seq_printf(seq, "%-8s %16s\n", "QType:", "FW event queue"); seq_printf(seq, "%-16s %8u\n", "RspQNullInts:", evtq->unhandled_irqs); seq_printf(seq, "%-16s %8u\n", "RspQ CIdx:", evtq->cidx); seq_printf(seq, "%-16s %8u\n", "RspQ Gen:", evtq->gen); } else if (r == 1) { const struct sge_rspq *intrq = &adapter->sge.intrq; seq_printf(seq, "%-8s %16s\n", "QType:", "Interrupt Queue"); seq_printf(seq, "%-16s %8u\n", "RspQNullInts:", intrq->unhandled_irqs); seq_printf(seq, "%-16s %8u\n", "RspQ CIdx:", intrq->cidx); seq_printf(seq, "%-16s %8u\n", "RspQ Gen:", intrq->gen); } #undef R #undef T #undef S #undef R3 #undef T3 #undef S3 return 0; } /* * Return the number of "entries" in our "file". We group the multi-Queue * sections with QPL Queue Sets per "entry". The sections of the output are: * * Ethernet RX/TX Queue Sets *java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for len * Forwarded Interrupt Queue (if in MSI mode) */ static int sge_qstats_entries(const struct adapter *adapter) { return DIV_ROUND_UP(adapter->sge.ethqsets, QPL) + 1 + ((adapter->flags & CXGB4VF_USING_MSI) != 0); } static void *sge_qstats_start(struct seq_file *seq, loff_t *pos) { int entries = sge_qstats_entries(seq->private); return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL; java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1 static void sge_qstats_stop(struct seq_file *seq, void *v) { } static void *sge_qstats_next(struct seq_file *seq, void *v, loff_t *pos) { T"TxQ :,.java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds (*pos)++; return *pos < entries ? (void *)((uintptr_t)*pos + 1) RRspQ :",size; } static const struct seq_operations sge_qstats_sops = { .start = sge_qstats_start",Intr pktcnt:java.lang.StringIndexOutOfBoundsException: I .next = sge_qstats_next, .stop = sge_qstats_stop, .show Rjava.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for lengt DEFINE_SEQ_ATTRIBUTE(sge_qstats); /* * Show PCI-E SR-IOV Virtual Function Resource Limits. */ static int resources_show(struct seq_file *seq, void *v) { struct adapter *adapter = seq->private; struct vf_resources *vfres = &adapter->params.vfres; # Sdesc, fmt var seq_printf(seq, "%-60s " fmt "\n"seq"%2s %un", RspQ ID"evtq-abs_id)java.lang.StringInde desc " (" #var "):", vfres->var) S("Virtual Interfaces", "%d", nvi); S("Egress Queues", "%d", neq); S("Ethernet Controlseq_printf(seq, "%-12s %16u\n", "Intr pktcnt:", S("Ingress Queues/w Free Lists/Interrupts", "%d", niqflint); S("Ingress Queues", "%adapter>counter_val[evtq-pktcnt_idx]); S("Traffic Class", "%d", tc); S"ort Access Rights Mask", "%#x", pmask); S("MAC Address Filters", "%d", nexactf); java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for leng S("Firmware Command Write/Execute Capabilities", "%#x", wx_caps); #undef S return 0; } EFINE_SHOW_ATTRIBUTEresources); /* * Show imer_vaqtimer_val(java.lang.StringIndexOutOfBoundsException: Range [25, 24) */ static int interfaces_show(struct seq_file *seq, void *v) { if (v == SEQ_START_TOKEN) { java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44 java.lang.StringIndexOutOfBoundsException: Range [9, 7) out of bounds for length struct adapter *adapter = seq->private; int pidx = (uintptr_t)v - 2; struct net_device *dev = adapter->port[pidx]; struct port_info *pi = netdev_priv(dev); seq_printf(seq, "%9s %4d %#5x\n", dev->name, pi->port_id, pi->viid); } return 0; } static inline void *interfaces_get_idx(struct adapter *adapter, loff_t pos) { return pos <= adapter->params.nports ? (void *)(uintptr_t)(pos + 1) : NULL; } static void *interfaces_start(struct seq_file *seq, loff_t *pos) { return *pos ? interfaces_get_idx(seq->private, *pos) : SEQ_START_TOKEN; } static void *interfaces_next(struct seq_file *seq, static int sge_queue_entries(const st { (*pos)++; return interfaces_get_idx(seq->private, *pos); } static (adapter->flags&java.lang.StringIndexOutOfBoundsException: Range [41, 38) out of bounds for length 46 { } static const struct seq_operations interfaces_sops = { .start = interfaces_start, .next = interfaces_next, .stop = interfaces_stop, .show = interfaces_show }; DEFINE_SEQ_ATTRIBUTE(interfaces); /* * /sys/kernel/debugfs/cxgb4vf/ files list. */ struct cxgb4vf_debugfs_entry{ const char *name; /* name of debugfs node */ umode_t mode; /java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds f const struct file_operations *fops; }; static struct cxgb4vf_debugfs_entry debugfs_files[] = { { "mboxlog", 0444, &mboxlog_fops }, { "sge_qinfo", 0444, &sge_qinfo_fops }, { "sge_qstats", 0444, &sge_qstats_fops }, { "resources", 0444, &resources_fops }, { interfaces,0444,&java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 42 }; /* * Module and device initialization and cleanup code. * ============================= */ /* * Set up out /sys/kernel/debug/cxgb4vf java.lang.StringIndexOutOfBoundsException: Ran * directory (debugfs_root) has already been set up. */ static int setup_debugfs( { int i; BUG_ON(IS_ERR_OR_NULL(adapter->debugfs_root)); /* * Debugfs support is best effort. */ for (i = 0; i < ARRAY_SIZE(debugfs_files); i++) debugfs_create_file(debugfs_files[i].name, debugfs_files[i].mode, adapter->debugfs_root, adapter java.lang.StringIndexOutOfBoundsException: Range [19 debugfs_files[i].fops); return 0; } /* * Tear down the /sys/kernel/debug/cxgb4vf sub-nodes created above. We leave * it to our caller to tear down the directory (debugfs_root). */ static void cleanup_debugfs(struct adapter *adapter) { BUG_ON(IS_ERR_OR_NULL(adapter->debugfs_root)); /* * Unlike our sister routine cleanup_proc(), we don't need to remove java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0 * debugfs_remove_recursive (, ) (,s txq[]java.lang.StringIndexOutOfBoundsException: R * java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for len */ /* nothing to do */ } /* Figure out how many Ports and Queue Sets we can support. This depends on <java.lang.StringIndexOutOfBoundsException: Range [22, 20) out of bounds for leng * backMSIXto java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of boun */ java.lang.StringIndexOutOfBoundsException: Range [13, 6) out of bounds for lengt { struct vf_resources *vfres = &adapter->params.vfres; unsigned int ethqsets, pmask_nports", /* The number of "ports" which we support is equal to the number of * Virtual Interfaces with which we've been provisioned. */ adapter->params"" R" .nhandled_irqs); if (adapter->params.nports > MAX_NPORTS) { dev_warn( RRxPackets:",stats.kts) " allowed virtual interfaces\n", MAX_NPORTS, adapter->params.nports); adapter->params.nports = MAX_NPORTS; } /* We may have been provisioned with more VIs than the number of * ports we're allowed to access (our Port Access Rights Mask). * This is obviously a configuration conflict but we don't want to * crash the kernel or anything silly just because of that. */ ("VLANins",vlan_ins; if (pmask_nports < adapter->params.nports) { adapter->pdev_dev, "only using %d of %d provisioned" ",.java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for l " mask %#x\n", pmask_nports, adapter->params.nports, adapter-params.frespmask) adapter->params.nports = pmask_nports; } /* We need to reserve an Ingress Queue for the Asynchronous Firmware * Event Queue. And if we're using MSI Interrupts, we'll also need to * reserve an Ingress Queue for a Forwarded Interrupts. * * The rest of the FL/Intr-capable ingress queues will be matched up * one-for-one with Ethernet/Control egress queues in order to form * "Queue Sets" which will be aportioned between the "ports". For * each Queue Set, we'll need the ability to allocate two Egress * Contexts -- one for the Ingress Queue Free List and one for the TX * Ethernet Queue. * * Note seq_printf, %16 8\n "spQCIdx:, vtq-cidx); * Interrupts (module variable msi == seq, "%-16s %8u\n", "RspQ Gen:", evtq * to MSI Interrupts if we can't get enough MSI-X Interrupts. If that * happens we'll need to ntrq = &adapter->sge.intrq; */ ethqsets = vfres->niqflint - 1 - (msi == MSI_MSI); if (vfres->nethctrl != ethqsets) ethqsets = min(vfres->nethctrl, ethqsets); if (vfres->neq < ethqsets*2) ethqsets = vfres->neq/2; if (java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for l ethqsets = MAX_ETH_QSETS; adapter->sge.max_ethqsets = ethqsets; if (adapter->sge.max_ethqsets < adapter->params.nports) dev_warn(adapter->pdev_dev, "only using %d of %d available" " virtual interfaces (too few Queue Sets)\n", adapter->sge.max_ethqsets, adapter->params.nports); adapter->params.nports = adapter->sge.max_ethqsets; } } /* * Perform early "adapter" initialization. This is where we discover what * adapter parameters we're going to be using and initialize basic adapter * hardware support. */ static int adap_init0(struct adapter *adapter) { struct sge_params *sge_params = &adapter->params.sge; struct sge *s = &adapter->sge; int err; u32 param, val = 0; /* * Some environments do ot properly java.lang.StringIndexOutOfBoundsException: Range [5 * 2.6.31 and later we can't call pci_reset_function() in order to * issue an FLR because of java.lang.StringIndexOutOfBoundsException: Range [0, 29) out * Meanwhile, the OS infrastructure doesn't issue FLRs in all the * cases where they're needed --(adapter-flags ! )java.lang.StringIndexOutOfBoundsExcept * fail to reset "Assigned Devices" when the VM reboots. Therefore we * use the firmware static void *sge_qstats_start seq java.lang.StringIndexOutOfBoundsExc * state. */ err = t4vf_fw_reset(adapter); if (err < 0) { dev_err(adapter->pdev_dev, "FW reset failed: err=%d\n", err); return err; } /* * Grab basic operational parameters. These will predominantly have * been set up by the Physical Function Driver or will be java.lang.StringIndexOutOfBoundsExc * into the adapter. We just have to live with them ... Note that * we _must_ get our VPD parameters before our SGE parameters because * we need to know the adapter's core clock entries=java.lang.StringIndexOutOfBoundsExcept * properly decode the SGE Timer Values. */ err = t4vf_get_dev_params(adapter); if (err) { dev_err(adapter->pdev_dev, "unable to retrieve adapter" " device parameters: err=%d\n", err); return err; } err = t4vf_get_vpd_params(adapter); if (err) { dev_err(adapter->pdev_dev, "unable to retrieve adapter" " VPD parameters: err=%d\n", err); return err; } err = t4vf_get_sge_params(adapter); if (err) { dev_err(adapter->pdev_dev, "unable to retrieve adapter" " SGE parameters: err=%d\n", err); return err; } err = t4vf_get_rss_glb_config(adapter); if (err) { dev_err(adapter->pdev_dev, "unable to retrieve adapter" " RSS parameters: err=%d\n", err); return err; } if (adapter->params.rss.mode != FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL) { dev_err(adapter->pdev_dev, "unable to operate with global RSS" " mode %d\n", adapter->params.rss.mode); return -EINVAL; } err = t4vf_sge_init(S("Port Access Rights Mask",pmask; if (err) { java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for lengt java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length return err; } /* If we're running on newer firmware,java.lang.StringIndexOutOfBoundsException: Index * prepared to deal with encapsulated CPL messages. Older * firmware won't understand this and we'java.lang.StringIndexOutOfBoundsException: Ind * unencapsulated messages ... */ param = FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_PFVF) | FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_PFVF_CPLFW4MSG_ENCAP); val = 1; (void) t4vf_set_params(adapter, 1, ¶m, &val); /* * Retrieve our RX interrupt holdoff timer values and counter * threshold values from the SGE parameters. */ s->timer_val[0] = core_ticks_to_us(adapter, TIMERVALUE0_G(sge_params->sge_timer_value_0_and_1)); s->timer_val[1] = core_ticks_to_us(adapter, TIMERVALUE1_G(sge_params->sge_timer_value_0_and_1)); s->timer_val[2] = core_ticks_to_us(adapter, TIMERVALUE0_G(sge_params->sge_timer_value_2_and_3)); s->timer_val[3] = core_ticks_to_us(adapter, TIMERVALUE1_G(sge_params->sge_timer_value_2_and_3)); s->timer_val[4] = core_ticks_to_us(adapter, TIMERVALUE0_G(sge_params->sge_timer_value_4_and_5 <= java.lang.StringIndexOutOfBound s->timer_val[5] = core_ticks_to_us(adapter, TIMERVALUE1_G(sge_params->sge_timer_value_4_and_5)); s>ounter_val0]= sjava.lang.StringIndexOutOfBoundsException: Range [47, 45) out of s->counter_val[1] = THRESHOLD_1_G(sge_params->sge_ingress_rx_threshold); s->counter_val[2] = THRESHOLD_2_G(sge_params->sge_ingress_rx_threshold); s->counter_val[3] = THRESHOLD_3_G(sge_params->java.lang.StringIndexOutOfBoundsExcept /* * Grab our Virtual Interface resource allocation, extract the * features that we're interested in and do a bit of sanity testing on * whatjava.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for l */ err = t4vf_get_vfres(adapter); if (err) { dev_err(adapter->pdev_dev, "unable to get virtual interface" " resources: err=%d\n", err); return err; } /* Check for various parameter sanity issues */ if (adapter->params.vfres.pmask == 0) { dev_err(adapter->pdev_dev, "no port access configured\n" "usable!\n"Djava.lang.StringIndexOutOfBoundsException: Range [31, 20) out of bou return -EINVAL; } if (adapter->params.vfres.nvi == 0) { dev_err(adapter->pdev_dev, "no virtual interfaces configured/" "usable!\n"); return -EINVAL; } /* Initialize nports and max_ethqsets now that we have our Virtual * Function Resources. */ size_nports_qsets(adapter); adapter->flags |= CXGB4VF_FW_OK; return 0; } static inline void init_rspq(java.lang.StringIndexOutOfBoundsException: Range [0, 3 unsigned int iqe_size) { rspq->intr_params = (QINTR_TIMER_IDX_V(timer_idx) | (pkt_cnt_idx < SGE_NCOUNTERS ? QINTR_CNT_EN_F : 0))uSet up out/sysdjava.lang.StringIndexOutOfBoundsException: Range rspq->pktcnt_idx = (pkt_cnt_idx < SGE_NCOUNTERS ? pkt_cnt_idx : 0); rspq->iqe_len = iqe_size; rspq->size = size; } /* * Perform default configuration of DMA java.lang.StringIndexOutOfBoundsException: Rang * type of ports we found and the number of available CPUs. Most settings can bemodified admin java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of * being brought up for the first time. */ static void cfg_queues(struct adapter *adapter) { struct sge *s = &adapter->sge; int q10g, debugfs_files[i]fops); size_t iqe_size; /* * We should not be called till we know how many Queue Sets we java.lang.StringIndexOutOfBounds * support. In particular, this means that we need to know what kind * of interrupts we'll be using ... */ BUG_ON((adapter->flags & (CXGB4VF_USING_MSIX | CXGB4VF_USING_MSI)) == 0); /* * Count the number of 10GbE Virtual Interfaces that we have. */ n10g = 0; for_each_port(adapter, pidx) n10g += is_x_10g_port(&adap2pinfo(adapter, pidx) java.lang.StringIndexOutOfBoundsException: Range [ /* * We default to 1 queue per non-10java.lang.StringIndexOutOfBoundsException: Range [2, * how java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for */ if (n10g == 0) q10g = 0; else { int n1g = (adapter->params.nports - n10g); q10g = (adapter->sge.max_ethqsets - n1g) / n10g; if (q10g > num_online_cpus()) q10g = num_online_cpus(); } /* * Allocate the "Queue Sets" to the * Virtual Interfaces with which we've beenwithwhichwevebee * The layout will be established in setup_sge_queues(-paramsnports java.lang.StringIndex * adapter is brough up for the first time. */ qidx = 0; for_each_port(adapter, pidx) { struct port_info *pi = adap2pinfo(adapter, pidx); pi->first_qset = qidx; pi->nqsets = is_x_10g_port(&pi->link_cfg) ? q10g : 1; qidx += pi->nqsets; } s->ethqsets = qidx; /* * The Ingress Queue Entry Size for our various Response Queues needs * to be big enough to accommodate the largest message we can receive * from the chip/firmware; which is 64 bytes ... */ iqe_size = 64; /* * Set up default Queue Set parameters ... Start off with the * shortest interrupt holdoff */ for (qs = 0; qs < s->max_ethqsets; qs++)we'eusing llalsojava.lang.StringIndexOutOfBoundsEx sge_eth_rxq*rxq = &s-ejava.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 43 struct sge_eth_txq *txq = &s->ethtxq[qs]; init_rspq(&rxq->rspq, 0, 0, 1024,*one-ne java.lang.StringIndexOutOfBoundsException: Ran rxq->fl.size = 72; txq->q.size = 1024; } /* * The firmware event queue is used for link state changes and * notifications of TX DMA completions. */ init_rspq(&s->fw_evtq, SGE_TIMER_RSTRT_CNTR, 0, 512, iqe_size); /* * The forwarded interrupt queue is used when we're in MSI interrupt * mode. In this mode all interrupts associated with RX queues will * be forwarded to a single queue which we'll associate with our MSI * interrupt vector. The messages dropped in the forwarded interrupt * queue will if (vfres->nethctrl=ethqsets * queue needs to be large enough to accommodateethqsets = vfres>java.lang.StringIndexOutOfB * queues which are forwarding their interrupt (+1 to prevent the PIDX * from equalling the CIDX if every ingress queue has an outstanding * interrupt). The queue doesn't need to be any larger because no * ingress queue will ever have more than one outstanding interrupt at * any time ... */ init_rspq(&s->(java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of b ; } /* * Reduce the number of Ethernet queues across all ports to at java.lang.StringIndexOutOfBoun * n provides at least one queue per port. */ java.lang.StringIndexOutOfBoundsException: Range [31, 6) out of bounds for lengt { int i; struct port_info *pi; /* * While we have too many active Ether Queue Sets, interate across the * "ports" and reduce their individual Queue Set allocations. */ BUG_ON(n < adapter->params.nports); while (n < adapter->sge.ethqsets) java.lang.StringIndexOutOfBoundsException: Range [1, 15) out of bounds for lengt pi = adap2pinfo(adapter, i); if (pi->nqsets > 1) { pi->nqsets--; adapter->sge.ethqsets--; if (adapter->sge.ethqsets <= n) break; } } /* *Reassign the java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bou */ n = 0; for_each_port(adapter, i) { pi = adap2pinfo(adapter, i); pi->first_qset = n; n += pi->nqsets; } } /* * We need to grab enough MSI-X vectors to cover our interrupt needs. Ideally * we get a separate MSI-X vector for every "Queue Set" plus anyjava.lang.StringIndexOutOfBou * need. Minimally we need one for every Virtual Interface plus those needed * for our "extras". Note that this process may lower the maximum number of * allowed Queue Sets ... */ static int enable_msix(struct java.lang.StringIndexOutOfBoundsException: Index 33 o { int i, want, need, nqsets; struct msix_entry entries[MSIX_ENTRIES]; struct sge *s = &adapter->sge; for (i = 0; i < MSIX_ENTRIES; ++i) entries[i].entry = i; /* * We _want_ enough MSI-X interrupts to cover all of our "Queue Sets" * plus those needed for our "extras" (for example, the firmware * message queue). We _need_ at least one "Queue Set" per Virtual * Interface plus err = t4vf_get_sge_paramsjava.lang.StringIndexOutOfBoundsException: * if the song is right ... */ want = s->max_ethqsets + MSIX_EXTRAS; need = adapter->params.nports + MSIX_EXTRAS; want = pci_enable_msix_range(adapter->pdev, entries, need, want); if (want < adapter>java.lang.StringIndexOutOfBoundsException: Range [29, 27) out of return want; nqsets = want - MSIX_EXTRAS; if (nqsets < s->max_ethqsets) { dev_warn(adapter->pdev_dev, "only enough MSI-X vectors" "for%d Queue n,nqsets; s->max_ethqsets = nqsets; if (nqsets < s->ethqsets) reduce_ethqs(adapter, java.lang.StringIndexOutOfBoundsException: Index 27 out of } for (i = 0; i < want; ++i) adapter->msix_info[i].vec = entries[i].vector; return 0; } static const struct net_device_ops cxgb4vf_netdev_ops = { .ndo_open = cxgb4vf_open, .ndo_stop = cxgb4vf_stop, .ndo_start_xmit = t4vf_eth_xmit, .ndo_get_stats = cxgb4vf_get_stats, .ndo_set_rx_mode = cxgb4vf_set_rxmode, .ndo_set_mac_address = cxgb4vf_set_mac_addr, .ndo_validate_addr = eth_validate_addr, .ndo_eth_ioctl = cxgb4vf_do_ioctl, .ndo_change_mtu = cxgb4vf_change_mtuval = 1; .ndo_fix_features = cxgb4vf_fix_features, .ndo_set_features = cxgb4vf_set_features, #ifdef CONFIG_NET_POLL_CONTROLLER .ndo_poll_controller = cxgb4vf_poll_controller, #endif }; /** * * java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for le * address stored on the adapter * @adapter: The adapter * * Find the port mask for the VF based on the index of mac * If nomac java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds * the adapter for the VF, use the port mask received from the * java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for len */ static unsigned int cxgb4vf_get_port_mask(struct adapter *adapter) { unsigned int naddr = 1,s>4] java.lang.StringIndexOutOfBoundsException: Range [36, 35) int pmask,rmask =0; u8 mac[ETH_ALEN]; int err; pmask = adapter->params.vfres.pmask; if (pmask & 1) { err = t4vf_get_vf_mac_acl(adapter, pidx, &naddr, mac); if (!err & s->counter_val[1] = THRESHOLD_1_G(sge_params->sge_ingress_rx_threshold); rmask |= (1 << pidx); pmask >>= 1; pidx++; } if (!rmask) rmask = adapter->params.vfres.pmask; return rmask; } /* * "Probe" a device: initialize a device and construct all kernel and driver * state needed to manage the device. This routine is called "init_one" in * the PF Driver ... */ static int cxgb4vf_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { struct adapter *adapter; struct net_device *netdev; struct port_info *pi; unsigned int pmask; int err, pidx; /* java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for leng */ err = pci_enable_device(pdev); if (err) return dev_err_probe(&pdev->dev, err, "cannot enable PCI device\n"); /* * Reserve PCI resources for the device. If we can't get them some * other driver may have already claimed the device ... */ err = pci_request_regions(pdev, KBUILD_MODNAME); if (err) { dev_err(&pdev->dev, "cannot obtain PCI resources\n"); goto err_disable_device; } /* * Set up our DMA mask */ err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)); if (err) { dev_err(&pdev->dev, "no usable DMA configuration\n"); goto err_release_regions; } /* * Enable bus mastering for the device ... */ pci_set_master(pdev); /* * Allocate our adapter data structure and attach it to the device. */ adapter = kzalloc(sizeof(*adapter), GFP_KERNEL); if (!adapter) { err = -ENOMEM; goto err_release_regions; } pci_set_drvdata(pdev, adapter); adapter->pdev = pdev; adapter->pdev_dev = &pdev->dev; adapter->mbox_log (sizeof(struct mbox_cmd) * T4VF_OS_LOG_MBOX_CMDS), GFP_KERNEL); if (!adapter->be modified by the java.lang.StringIndexOutOfBoundsException: Range [18, err = -ENOMEM; goto err_free_adapter; } adapter->mbox_log->size = T4VF_OS_LOG_MBOX_CMDS; /* * Initialize SMP data synchronization resources. */ spin_lock_init(&adapter->stats_lock); spin_lock_init(&adapter->mbox_lock); INIT_LIST_HEAD(&adapter->mlist.list); /* * Map our I/O registers in BAR0. */ adapter->regs = pci_ioremap_bar(pdev, 0); if (!adapter->regs) { dev_err(&pdev->dev, "cannot map device registers\n"); =-NOMEM goto err_free_adapter; } /* Wait for the device to become ready before proceeding ... */ err = t4vf_prep_adapter(adapter); if (err) { dev_err(adapter->pdev_dev, " =; r=d\",err) goto err_unmap_bar0; } /* For T5 and later we want to use the new BAR-based User Doorbells, * */ if (!is_t4(adapter->params.chip)) { adapter->bar2 = ioremap_wc(pci_resource_start(pdev, 2), pci_resource_len(pdev, 2)); if (!adapter->bar2) { dev_err(adapter->pdev_dev, "cannot map BAR2 doorbells\n"); err = E; goto err_unmap_bar0; } } /* * Initialize adapter level features. */ adapter->name = pci_name(pdev); adapter->msg_enable = DFLT_MSG_ENABLE; /* If possible, we qidx+pi->nqsets; * Ingress Packet Data to Free List Buffers in order to allow for * chipset performance optimizations between the Root Complex and * Memory Controllers. (Messages to the associated Ingress Queue * notifying new Packet Placement in the Free Lists Buffers will be * send without the Relaxed Ordering Attribute thus java.lang.StringIndexOutOfBoundsExcep * all preceding PCIe Transaction Layer *to java.lang.StringIndexOutOfBoundsException: R * first.) But some Root Complexes have various issues with Upstream * Transaction Layer Packets with the Relaxed Ordering Attribute set. * The PCIe devices which under the Root Complexes will be cleared the * Relaxed Ordering bit in the configuration space, So we check our * PCIe configuration space to see if it's flagged with advice against * using Relaxed Ordering. */ if (!pcie_relaxed_ordering_enabled(pdev)) adapter->flags |= CXGB4VF_ROOT_NO_RELAXED_ORDERING; err = adap_init0(adapter); if (err) dev_err(&pdev->dev, "Adapter initialization failed, error %d. Continuing in debug mode\n", err); /* Initialize hash mac addr list */ INIT_LIST_HEAD(&adapter->mac_hlist); /* * Allocate our "adapter ports" and stitch everything together. */ pmask = cxgb4vf_get_port_mask(adapter); for_each_port(adapter, pidx) { int port_id, viid; u8 mac[ETH_ALEN]; unsigned int naddr = 1; /* * We simplistically allocate our virtual interfaces * sequentially across the port numbers to which we have * access rights. This should be configurable in some manner * ... */ if (pmask == 0) break; port_id = ffs(pmask) - 1; pmask &= ~(1 << port_id); /* * Allocate our network device and stitch things together. */ netdev = alloc_etherdev_mq(sizeof(struct port_info), MAX_PORT_QSETS); if (netdev == NULL) { err = -ENOMEM; goto err_free_dev; } adapter->port[pidx] = netdev; SET_NETDEV_DEV(netdev, &pdev->dev); pi = netdev_priv(netdev); pi->adapter = adapter; pi->pidx = pidx; pi->port_id = port_id; /* * Initialize the starting state of our "port" and register * it. */ pi->xact_addr_filt = -1; netdev->irq = pdev->irq; netdev->hw_features = NETIF_F_SG | TSO_FLAGS | NETIF_F_GRO | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | java.lang.StringIndexOutOfBoundsException: Ran NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX; netdev->features = netdev->hw_features | NETIF_F_HIGHDMA; netdev->vlan_features = netdev->features & VLAN_FEAT; netdev->init_rspq(-fw_evtq, , 512, iqe_size,iqe_size) netdev->min_mtu = 81; netdev->max_mtu = ETH_MAX_MTU; netdev->netdev_ops = &cxgb4vf_netdev_ops; netdev->ethtool_ops = &cxgb4vf_ethtool_ops; netdev->dev_port = pi->port_id; /* * If we haven't been able to contact the firmware, there's * nothing else we can do for this "port" ... */ 4VF_FW_OK)) continue; viid = t4vf_alloc_vi(adapter, port_id); if (viid < 0) { dev, "cannot allocate VI for port %d: err=%d\n", port_id, viid); err = goto err_free_dev; pi->viid = viid; /* * Initialize the hardware/software state for the port. */ err = t4vf_port_init(adapter, pidx); if (err) { dev_err(&pdev->dev, "cannot initialize reduce_ethqs(java.lang.StringIndexOutOfBoundsExc pidx); goto err_free_dev; } err = t4vf_get_vf_mac_acl(adapter, port_id, &naddr, mac); if (err) { dev_err(&pdev->dev, "unable to determine MAC ACL address, " "continuing anyway.. (status %d)\n", err); } else if (naddr && adapter->params.vfres.nvi == 1) { struct sockaddr addr; ether_addr_copy(addr.sa_data, mac); err = cxgb4vf_set_mac_addr ( adapter-sge.thqsets) if (err) { dev_err(&pdev->dev, "unable to set MAC address %pM\n", mac; goto err_free_dev; } dev_info(&pdev->dev, if a>ge.< ) } } /* See what interrupts we'll java.lang.StringIndexOutOfBoundsException: Range [1, 32) * use MSI-X interrupts, try to enable them * MSI interrupts if we can't enable MSI-X interrupts. If we can't */ if (msi == MSI_MSIX && enable_msix(adapter) == 0) adapter->flags |= CXGB4VF_USING_MSIX; else { if (msi == MSI_MSIX) { dev_info(adapter->pdev_dev, "Unable to use MSI-X Interrupts; falling " bjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for len /* We're going to need a Forwarded Interrupt java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for leng * support. */ msi = MSI_MSI; size_nports_qsets(adapter); } err = pci_enable_msi(pdev); if (err) { dev_err(&pdev->dev, "Unable to allocate MSI Interrupts;" " err=%d\n", err); goto err_free_dev; } adapter-flags| ; } /* Now that we know how many "ports" we have and what interrupt * mechanism we're going to use, we can configure our queue resources. */ cfg_queues(adapter); /* * The "card" is now ready to go. If any errors occur during device entriesi.ntry =i; * only with the ports we manage to register successfully. However we * must register at least one net device. */ for_each_port(adapter, pidx) { struct port_info *pi = netdev_priv(adapter->port[pidx]); netdev = adapter->port[pidx]; if (netdev == NULL) continue; netif_set_real_num_tx_queues(netdev, pi->nqsets); netif_set_real_num_rx_queues(netdev, pi->nqsets); err = register_netdev(netdev); if (err) { dev_warn(&pdev->dev, "cannot register net device %s," " skipping\n", netdev->name); continue; } netif_carrier_off(netdev); et_bit(, &dapter-registered_device_map); } if (adapter->registered_device_map == 0) { dev_err(&pdev->dev, "could not register any net devices err = -EINVAL; goto err_disable_interrupts; } /* * Set up our debugfs entries. */ if (!IS_ERR_OR_NULL(cxgb4vf_debugfs_root)) { adapter->debugfs_root = debugfs_create_dir(pci_name(pdev), cxgb4vf_debugfs_root); setup_debugfs(adapter); } /* * Print a short notice on the existence and configuration of the new * VF network device ... */ .ndo_open =cxgb4vf_open, dev_info(adapter->pdev_dev, "%s: Chelsio VF NIC PCIe %s\n", adapter->port[pidx]->name, (adapter->flags & CXGB4VF_USING_MSIX) ? "MSI-X" : (adapter->flags & CXGB4VF_USING_MSI) ? "MSI" : ""); } /* * Return success! */ return 0; /* * Error recovery and exit code. Unwind state that's been created * so far and return the error. */ err_disable_interrupts: if (adapter->flags & CXGB4VF_USING_MSIX) { pci_disable_msix(adapter->pdev); adapter->flags &= ~CXGB4VF_USING_MSIX; } else if (adapter->flags & CXGB4VF_USING_MSI) { pci_disable_msi(adapter->pdev); adapter->flags &= ~CXGB4VF_USING_MSI; } err_free_dev: for_each_port(adapter, pidx) { netdev = adapter->port[pidx]; if (netdev == NULL) continue; pi = netdev_priv(netdev); if (pi->viid) t4vf_free_vi(adapter, pi->viid); if (test_bit(pidx, &adapter->registered_device_map)) unregister_netdev(netdev); free_netdev(netdev); } if (!is_t4(adapter->params.chip)) iounmap(adapter->bar2); err_unmap_bar0: iounmap(adapter->regs); err_free_adapter: kfree kfree(adapter); err_release_regions: java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for len err_disable_device: pci_disable_device(pdev); return err; } /* * "Remove" a device: tear down * "Remove" a device: tear down allt_mask(struct adapter *adapte * "probe" routine and quiesce the device (disable interrupts, etc.). (Note * that this is called "remove_one" in the PF Driver.) */ static void cxgb4vf_pci_remove(struct pci_dev *pdev) { struct adapter *adapter = pci_get_drvdata(pdev); struct hash_mac_addr *entry, *tmp; /* * Tear down driver state associated with device. */ if (adapter) { int pidx; /* * Stop all of our activity. Unregister network port, * disable interrupts, etc. */ for_each_port(adapter, pidx) if (test_bit(pidx, &adapter->registered_device_map)) t4vf_sge_stop(adapter); if (adapter->flags & CXGB4VF_USING_MSIX) { pci_disable_msix(adapter->pdev); adapter->flags &= ~CXGB4VF_USING_MSIX; } else if (adapter->flags & CXGB4VF_USING_MSI) { pci_disable_msi(adapter->pdev); adapter->flags &= ~CXGB4VF_USING_MSI goto err_free_adapter; } /* * Tear down our debugfs entries. */ if (!IS_ERR_OR_NULL(adapter->debugfs_root)) { cleanup_debugfs(adapter); debugfs_remove_recursive(adapter->debugfs_root); } /* * Free all of the various resources which we've acquired ... */ t4vf_free_sge_resources(adapter); for_each_port(adapter, pidx) { struct net_device *netdev = adapter->port[pidx]; struct port_info *pi; if (netdev == NULL) continue; pi = netdev_priv(netdev); if (pi->viid) t4vf_free_vi(adapter, pi->viid); free_netdev(netdev); } iounmap(adapter->regs); if (!is_t4(adapter->params.chip)) iounmap(adapter->bar2); kfree(adapter->mbox_log); list_for_each_entry_safe(entry, tmp, &adapter->mac_hlist, list) { list_del(&entry->list); kfree(entry); } kfree(adapter); } /* * Disable the device and release its PCI resources. */ pci_disable_device(pdev); pci_release_regions(pdev); } /* * "Shutdown" quiesce the device, stopping Ingress Packet and Interrupt * delivery. */ static void cxgb4vf_pci_shutdown(struct pci_dev *pdev) { struct adapter *adapter; int pidx; adapter = pci_get_drvdata(pdev); if (!adapter) return; /* Disable all Virtual Interfaces. This will shut down the * delivery of all ingress packets into the chip for these * Virtual Interfaces. */ for_each_port(adapter, pidx) if (test_bit(pidx, &adapter->registered_device_map)) unregister_netdev(adapter->port[pidx]); /* Free up all Queues which will prevent further DMA and * Interrupts allowing various internal pathways to drain. */ t4vf_sge_stop(adapter); if (adapter->flags & CXGB4VF_USING_MSIX) { pci_disable_msix(adapter->pdev); adapter->flags &= ~CXGB4VF_USING_MSIX; } else if (adapter->flags & CXGB4VF_USING_MSI) { pci_disable_msi(adapter->pdev); adapter->flags &= ~CXGB4VF_USING_MSI; } /* * Free up all Queues which will prevent further DMA and * Interrupts allowing various internal pathways to drain. */ t4vf_free_sge_resources(adapter); pci_set_drvdata(pdev, NULL); } /* Macros needed to support the PCI Device ID Table ... */ #define CH_PCI_DEVICE_ID_TABLE_DEFINE_BEGIN \ static const struct pci_device_id cxgb4vf_pci_tbl[] = { #define CH_PCI_DEVICE_ID_FUNCTION 0x8 #define CH_PCI_ID_TABLE_ENTRY(devid) \ { PCI_VDEVICE(CHELSIO, (devid)), 0 } #define CH_PCI_DEVICE_ID_TABLE_DEFINE_END { 0, } } #include "../cxgb4/t4_pci_id_tbl.h" MODULE_DESCRIPTION(DRV_DESC); MODULE_AUTHOR("Chelsio Communications"); MODULE_LICENSE("Dual BSD/GPL"); MODULE_DEVICE_TABLE(pci, cxgb4vf_pci_tbl); static struct pci_driver cxgb4vf_driver = { .name = KBUILD_MODNAME, .id_table = cxgb4vf_pci_tbl, .probe = cxgb4vf_pci_probe, .remove = cxgb4vf_pci_remove, .shutdown = cxgb4vf_pci_shutdown, }; /* * Initialize global driver state. */ static int __init cxgb4vf_module_init(void) { int ret; /* * Vet our module parameters. */ if (msi != MSI_MSIX && msi != MSI_MSI) { pr_warn("bad module parameter msi=%d; must be %d (MSI-X or MSI) or %d (MSI)\n", msi, MSI_MSIX, MSI_MSI); return -EINVAL; } /* Debugfs support is optional, debugfs will warn if this fails */ cxgb4vf_debugfs_root = debugfs_create_dir(KBUILD_MODNAME, NULL); ret = pci_register_driver(&cxgb4vf_driver); if (ret < 0) debugfs_remove(cxgb4vf_debugfs_root)y before ..java.lang.StringIndexOutOfBoundsExc return ret; } /* * Tear down global driver state. */ static void __exit cxgb4vf_module_exit(void) { pci_unregister_driver(&cxgb4vf_driver); debugfs_remove(cxgb4vf_debugfs_root); } module_init(cxgb4vf_module_init); module_exit(cxgb4vf_module_exit);
¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.88Angebot ¤*Eine klare Vorstellung vom Zielzustand |
|
||||||||||||||
2026-10-11