/* * Copyright (c) 2003-2008 Chelsio, 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 the 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 OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt#include <linux/module.h>#include <linux/init.h>#include <linux/pci.h>#include <linux/dma-mapping.h>#include <linux/netdevice.h>#include <linux/etherdevice.h>#include <linux/if_vlan.h>#include <linux/mdio.h>#include <linux/sockios.h>#include <linux/workqueue.h>#include <linux/proc_fs.h>#include <linux/rtnetlink.h>#include <linux/firmware.h>#include <linux/log2.h>#include <linux/stringify.h>#include <linux/sched.h>#include <linux/slab.h>#include <linux/uaccess.h>#include <linux/nospec.h>#include "common.h" #include "cxgb3_ioctl.h" #include "regs.h" #include "cxgb3_offload.h" #include "version.h" #include "cxgb3_ctl_defs.h" #include "t3_cpl.h" #include "firmware_exports.h" enum {#define PORT_MASK ((1 << MAX_NPORTS) - 1)#define DFLT_MSG_ENABLE (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK | \#define EEPROM_MAGIC 0x38E2F10C#define CH_DEVICE(devid, idx) \static const struct pci_device_id cxgb3_pci_tbl[] = {/* PE9000 */ /* T302E */ /* T310E */ /* T320X */ /* T302X */ /* T320E */ /* T310X */ /* T3B10 */ /* T3B20 */ /* T3B02 */ /* T3C20-derived T3C10 */ /* S320E-CR */ /* N320E-G2 */ "Chelsio Communications" );"Dual BSD/GPL" );static int dflt_msg_enable = DFLT_MSG_ENABLE;int , 0644);"Chelsio T3 default message enable bitmap" );/* * The driver uses the best interrupt scheme available on a platform in the * order MSI-X, MSI, legacy pin interrupts. This parameter determines which * of these schemes the driver may consider as follows: * * msi = 2: choose from among all three options * msi = 1: only consider MSI and pin interrupts * msi = 0: force pin interrupts static int msi = 2;int , 0644);"whether to use MSI or MSI-X" );/* * The driver enables offload as a default. * To disable it, use ofld_disable = 1. static int ofld_disable = 0;int , 0644);"whether to enable offload at init time or not" );/* * We have work elements that we need to cancel when an interface is taken * down. Normally the work elements would be executed by keventd but that * can deadlock because of linkwatch. If our close method takes the rtnl * lock and linkwatch is ahead of our work elements in keventd, linkwatch * will block keventd as it needs the rtnl lock, and we'll deadlock waiting * for our work to complete. Get our own work queue to solve this. struct workqueue_struct *cxgb3_wq;/** * link_report - show link status and link speed/duplex * @dev: the port whose settings are to be reported * * Shows the link status, speed, and duplex of a port. static void link_report(struct net_device *dev)if (!netif_carrier_ok(dev))"link down\n" );else {const char *s = "10Mbps" ;const struct port_info *p = netdev_priv(dev);switch (p->link_config.speed) {case SPEED_10000:"10Gbps" ;break ;case SPEED_1000:"1000Mbps" ;break ;case SPEED_100:"100Mbps" ;break ;"link up, %s, %s-duplex\n" ,"full" : "half" );static void enable_tx_fifo_drain(struct adapter *adapter,struct port_info *pi)static void disable_tx_fifo_drain(struct adapter *adapter,struct port_info *pi)void t3_os_link_fault(struct adapter *adap, int port_id, int state)struct net_device *dev = adap->port[port_id];struct port_info *pi = netdev_priv(dev);if (state == netif_carrier_ok(dev))return ;if (state) {struct cmac *mac = &pi->mac;/* Clear local faults */ else {/* Flush TX FIFO */ /** * t3_os_link_changed - handle link status changes * @adapter: the adapter associated with the link change * @port_id: the port index whose limk status has changed * @link_stat: the new status of the link * @speed: the new speed setting * @duplex: the new duplex setting * @pause: the new flow-control setting * * This is the OS-dependent handler for link status changes. The OS * neutral handler takes care of most of the processing for these events, * then calls this handler for any OS-specific processing. void t3_os_link_changed(struct adapter *adapter, int port_id, int link_stat,int speed, int duplex, int pause)struct net_device *dev = adapter->port[port_id];struct port_info *pi = netdev_priv(dev);struct cmac *mac = &pi->mac;/* Skip changes from disabled ports. */ if (!netif_running(dev))return ;if (link_stat != netif_carrier_ok(dev)) {if (link_stat) {/* Clear local faults */ else {if (is_10G(adapter))/* Flush TX FIFO */ /** * t3_os_phymod_changed - handle PHY module changes * @adap: the adapter associated with the link change * @port_id: the port index whose limk status has changed * * This is the OS-dependent handler for PHY module changes. It is * invoked when a PHY module is removed or inserted for any OS-specific * processing. void t3_os_phymod_changed(struct adapter *adap, int port_id)static const char *mod_str[] = {"SR" , "LR" , "LRM" , "TWINAX" , "TWINAX" , "unknown" const struct net_device *dev = adap->port[port_id];const struct port_info *pi = netdev_priv(dev);if (pi->phy.modtype == phy_modtype_none)"PHY module unplugged\n" );else "%s PHY module inserted\n" ,static void cxgb_set_rxmode(struct net_device *dev)struct port_info *pi = netdev_priv(dev);/** * link_start - enable a port * @dev: the device to enable * * Performs the MAC and PHY actions needed to enable a port. static void link_start(struct net_device *dev)struct port_info *pi = netdev_priv(dev);struct cmac *mac = &pi->mac;static inline void cxgb_disable_msi(struct adapter *adapter)if (adapter->flags & USING_MSIX) {else if (adapter->flags & USING_MSI) {/* * Interrupt handler for asynchronous events used with MSI-X. static irqreturn_t t3_async_intr_handler(int irq, void *cookie)return IRQ_HANDLED;/* * Name the MSI-X interrupts. static void name_msix_vecs(struct adapter *adap)int i, j, msi_idx = 1;sizeof (adap->msix_info[0].desc));struct net_device *d = adap->port[j];const struct port_info *pi = netdev_priv(d);for (i = 0; i < pi->nqsets; i++, msi_idx++) {sizeof (adap->msix_info[0].desc),"%s-%d" , d->name, pi->first_qset + i);static int request_msix_data_irqs(struct adapter *adap)int i, j, err, qidx = 0;int nqsets = adap2pinfo(adap, i)->nqsets;for (j = 0; j < nqsets; ++j) {if (err) {while (--qidx >= 0)return err;return 0;static void free_irq_resources(struct adapter *adapter)if (adapter->flags & USING_MSIX) {int i, n = 0;for (i = 0; i < n; ++i)else static int await_mgmt_replies(struct adapter *adap, unsigned long init_cnt,unsigned long n)int attempts = 10;while (adap->sge.qs[0].rspq.offload_pkts < init_cnt + n) {if (!--attempts)return -ETIMEDOUT;return 0;static int init_tp_parity(struct adapter *adap)int i;struct sk_buff *skb;struct cpl_set_tcb_field *greq;unsigned long cnt = adap->sge.qs[0].rspq.offload_pkts;for (i = 0; i < 16; i++) {struct cpl_smt_write_req *req;sizeof (*req), GFP_KERNEL);if (!skb)if (!skb)goto alloc_skb_fail;sizeof (*req));if (skb == adap->nofail_skb) {sizeof (*greq), GFP_KERNEL);if (!adap->nofail_skb)goto alloc_skb_fail;for (i = 0; i < 2048; i++) {struct cpl_l2t_write_req *req;sizeof (*req), GFP_KERNEL);if (!skb)if (!skb)goto alloc_skb_fail;sizeof (*req));if (skb == adap->nofail_skb) {sizeof (*greq), GFP_KERNEL);if (!adap->nofail_skb)goto alloc_skb_fail;for (i = 0; i < 2048; i++) {struct cpl_rte_write_req *req;sizeof (*req), GFP_KERNEL);if (!skb)if (!skb)goto alloc_skb_fail;sizeof (*req));if (skb == adap->nofail_skb) {sizeof (*greq), GFP_KERNEL);if (!adap->nofail_skb)goto alloc_skb_fail;sizeof (*greq), GFP_KERNEL);if (!skb)if (!skb)goto alloc_skb_fail;sizeof (*greq));if (skb == adap->nofail_skb) {sizeof (*greq), GFP_KERNEL);return i;return -ENOMEM;/** * setup_rss - configure RSS * @adap: the adapter * * Sets up RSS to distribute packets to multiple receive queues. We * configure the RSS CPU lookup table to distribute to the number of HW * receive queues, and the response queue lookup table to narrow that * down to the response queues actually configured for each port. * We always configure the RSS mapping for two ports since the mapping * table has plenty of entries. static void setup_rss(struct adapter *adap)int i;unsigned int nq0 = adap2pinfo(adap, 0)->nqsets;unsigned int nq1 = adap->port[1] ? adap2pinfo(adap, 1)->nqsets : 1;for (i = 0; i < SGE_QSETS; ++i)/* terminator */ for (i = 0; i < RSS_TABLE_SIZE / 2; ++i) {/* terminator */ static void ring_dbs(struct adapter *adap)int i, j;for (i = 0; i < SGE_QSETS; i++) {struct sge_qset *qs = &adap->sge.qs[i];if (qs->adap)for (j = 0; j < SGE_TXQ_PER_SET; j++)static void init_napi(struct adapter *adap)int i;for (i = 0; i < SGE_QSETS; i++) {struct sge_qset *qs = &adap->sge.qs[i];if (qs->adap)/* * netif_napi_add() can be called only once per napi_struct because it * adds each new napi_struct to a list. Be careful not to call it a * second time, e.g., during EEH recovery, by making a note of it. /* * Wait until all NAPI handlers are descheduled. This includes the handlers of * both netdevices representing interfaces and the dummy ones for the extra * queues. static void quiesce_rx(struct adapter *adap)int i;for (i = 0; i < SGE_QSETS; i++)if (adap->sge.qs[i].adap)static void enable_all_napi(struct adapter *adap)int i;for (i = 0; i < SGE_QSETS; i++)if (adap->sge.qs[i].adap)/** * setup_sge_qsets - configure SGE Tx/Rx/response queues * @adap: the adapter * * Determines how many sets of SGE queues to use and 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_qsets(struct adapter *adap)int i, j, err, irq_idx = 0, qset_idx = 0;unsigned int ntxq = SGE_TXQ_PER_SET;if (adap->params.rev > 0 && !(adap->flags & USING_MSI))struct net_device *dev = adap->port[i];struct port_info *pi = netdev_priv(dev);for (j = 0; j < pi->nqsets; ++j, ++qset_idx) {if (err) {return err;return 0;static ssize_t attr_show(struct device *d, char *buf,struct net_device *, char *))/* Synchronize with ioctls that may shut down the device */ return len;static ssize_t attr_store(struct device *d,const char *buf, size_t len,struct net_device *, unsigned int ),unsigned int min_val, unsigned int max_val)unsigned int val;if (!capable(CAP_NET_ADMIN))return -EPERM;if (ret)return ret;if (val < min_val || val > max_val)return -EINVAL;if (!ret)return ret;#define CXGB3_SHOW(name, val_expr) \static ssize_t format_## name(struct net_device *dev, char *buf) \struct port_info *pi = netdev_priv(dev); \struct adapter *adap = pi->adapter; \return sprintf(buf, "%u\n" , val_expr); \static ssize_t show_## name(struct device *d, struct device_attribute *attr, \char *buf) \return attr_show(d, buf, format_## name); \static ssize_t set_nfilters(struct net_device *dev, unsigned int val)struct port_info *pi = netdev_priv(dev);struct adapter *adap = pi->adapter;int min_tids = is_offload(adap) ? MC5_MIN_TIDS : 0;if (adap->flags & FULL_INIT_DONE)return -EBUSY;if (val && adap->params.rev == 0)return -EINVAL;if (val > t3_mc5_size(&adap->mc5) - adap->params.mc5.nservers -return -EINVAL;return 0;static ssize_t store_nfilters(struct device *d, struct device_attribute *attr,const char *buf, size_t len)return attr_store(d, buf, len, set_nfilters, 0, ~0);static ssize_t set_nservers(struct net_device *dev, unsigned int val)struct port_info *pi = netdev_priv(dev);struct adapter *adap = pi->adapter;if (adap->flags & FULL_INIT_DONE)return -EBUSY;if (val > t3_mc5_size(&adap->mc5) - adap->params.mc5.nfilters -return -EINVAL;return 0;static ssize_t store_nservers(struct device *d, struct device_attribute *attr,const char *buf, size_t len)return attr_store(d, buf, len, set_nservers, 0, ~0);#define CXGB3_ATTR_R(name, val_expr) \static DEVICE_ATTR(name, 0444, show_## name, NULL)#define CXGB3_ATTR_RW(name, val_expr, store_method) \static DEVICE_ATTR(name, 0644, show_## name, store_method)static struct attribute *cxgb3_attrs[] = {static const struct attribute_group cxgb3_attr_group = {static ssize_t tm_attr_show(struct device *d,char *buf, int sched)struct port_info *pi = netdev_priv(to_net_dev(d));struct adapter *adap = pi->adapter;unsigned int v, addr, bpt, cpt;if (sched & 1)if (!cpt)"disabled\n" );else {"%u Kbps\n" , (v * bpt) / 125);return len;static ssize_t tm_attr_store(struct device *d,const char *buf, size_t len, int sched)struct port_info *pi = netdev_priv(to_net_dev(d));struct adapter *adap = pi->adapter;unsigned int val;if (!capable(CAP_NET_ADMIN))return -EPERM;if (ret)return ret;if (val > 10000000)return -EINVAL;if (!ret)return ret;#define TM_ATTR(name, sched) \static ssize_t show_## name(struct device *d, struct device_attribute *attr, \char *buf) \return tm_attr_show(d, buf, sched); \static ssize_t store_## name(struct device *d, struct device_attribute *attr, \const char *buf, size_t len) \return tm_attr_store(d, buf, len, sched); \static DEVICE_ATTR(name, 0644, show_## name, store_## name)static struct attribute *offload_attrs[] = {static const struct attribute_group offload_attr_group = {/* * Sends an sk_buff to an offload queue driver * after dealing with any active network taps. static inline int offload_tx(struct t3cdev *tdev, struct sk_buff *skb)int ret;return ret;static int write_smt_entry(struct adapter *adapter, int idx)struct cpl_smt_write_req *req;struct port_info *pi = netdev_priv(adapter->port[idx]);struct sk_buff *skb = alloc_skb(sizeof (*req), GFP_KERNEL);if (!skb)return -ENOMEM;sizeof (*req));/* should be 0 but there's a T3 bug */ return 0;static int init_smt(struct adapter *adapter)int i;return 0;static void init_port_mtus(struct adapter *adapter)unsigned int mtus = adapter->port[0]->mtu;if (adapter->port[1])static int send_pktsched_cmd(struct adapter *adap, int sched, int qidx, int lo,int hi, int port)struct sk_buff *skb;struct mngt_pktsched_wr *req;int ret;sizeof (*req), GFP_KERNEL);if (!skb)if (!skb)return -ENOMEM;sizeof (*req));if (skb == adap->nofail_skb) {sizeof (struct cpl_set_tcb_field),if (!adap->nofail_skb)return ret;static int bind_qsets(struct adapter *adap)int i, j, err = 0;const struct port_info *pi = adap2pinfo(adap, i);for (j = 0; j < pi->nqsets; ++j) {int ret = send_pktsched_cmd(adap, 1,if (ret)return err;#define FW_VERSION __stringify(FW_VERSION_MAJOR) "." \"." __stringify(FW_VERSION_MICRO)#define FW_FNAME "cxgb3/t3fw-" FW_VERSION ".bin" #define TPSRAM_VERSION __stringify(TP_VERSION_MAJOR) "." \"." __stringify(TP_VERSION_MICRO)#define TPSRAM_NAME "cxgb3/t3%c_psram-" TPSRAM_VERSION ".bin" #define AEL2005_OPT_EDC_NAME "cxgb3/ael2005_opt_edc.bin" #define AEL2005_TWX_EDC_NAME "cxgb3/ael2005_twx_edc.bin" #define AEL2020_TWX_EDC_NAME "cxgb3/ael2020_twx_edc.bin" "cxgb3/t3b_psram-" TPSRAM_VERSION ".bin" );"cxgb3/t3c_psram-" TPSRAM_VERSION ".bin" );static inline const char *get_edc_fw_name(int edc_idx)const char *fw_name = NULL;switch (edc_idx) {case EDC_OPT_AEL2005:break ;case EDC_TWX_AEL2005:break ;case EDC_TWX_AEL2020:break ;return fw_name;int t3_get_edc_fw(struct cphy *phy, int edc_idx, int size)struct adapter *adapter = phy->adapter;const struct firmware *fw;const char *fw_name;const __be32 *p;int i, ret = -EINVAL;if (fw_name)if (ret < 0) {"could not upgrade firmware: unable to load %s\n" ,return ret;/* check size, take checksum in account */ if (fw->size > size + 4) {"firmware image too large %u, expected %d\n" ,unsigned int )fw->size, size + 4);/* compute checksum */ const __be32 *)fw->data;for (csum = 0, i = 0; i < fw->size / sizeof (csum); i++)if (csum != 0xffffffff) {"corrupted firmware image, checksum %u\n" ,for (i = 0; i < size / 4 ; i++) {return ret;static int upgrade_fw(struct adapter *adap)int ret;const struct firmware *fw;struct device *dev = &adap->pdev->dev;if (ret < 0) {"could not upgrade firmware: unable to load %s\n" ,return ret;if (ret == 0)"successful upgrade to firmware %d.%d.%d\n" ,else "failed to upgrade to firmware %d.%d.%d\n" ,return ret;static inline char t3rev2char(struct adapter *adapter)char rev = 0;switch (adapter->params.rev) {case T3_REV_B:case T3_REV_B2:'b' ;break ;case T3_REV_C:'c' ;break ;return rev;static int update_tpsram(struct adapter *adap)const struct firmware *tpsram;char buf[64];struct device *dev = &adap->pdev->dev;int ret;char rev;if (!rev)return 0;sizeof (buf), TPSRAM_NAME, rev);if (ret < 0) {"could not load TP SRAM: unable to load %s\n" ,return ret;if (ret)goto release_tpsram;if (ret == 0)"successful update of protocol engine " "to %d.%d.%d\n" ,else "failed to update of protocol engine %d.%d.%d\n" ,if (ret)"loading protocol SRAM failed\n" );return ret;/** * t3_synchronize_rx - wait for current Rx processing on a port to complete * @adap: the adapter * @p: the port * * Ensures that current Rx processing on any of the queues associated with * the given port completes before returning. We do this by acquiring and * releasing the locks of the response queues associated with the port. static void t3_synchronize_rx(struct adapter *adap, const struct port_info *p)int i;for (i = p->first_qset; i < p->first_qset + p->nqsets; i++) {struct sge_rspq *q = &adap->sge.qs[i].rspq;static void cxgb_vlan_mode(struct net_device *dev, netdev_features_t features)struct port_info *pi = netdev_priv(dev);struct adapter *adapter = pi->adapter;if (adapter->params.rev > 0) {else {/* single control for all ports */ unsigned int i, have_vlans = features & NETIF_F_HW_VLAN_CTAG_RX;/** * cxgb_up - enable the adapter * @adap: adapter being enabled * * Called when the first port is enabled, this function performs the * actions necessary to make an adapter operational, such as completing * the initialization of HW modules, and enabling interrupts. * * Must be called with the rtnl lock held. static int cxgb_up(struct adapter *adap)int i, err;if (!(adap->flags & FULL_INIT_DONE)) {if (err == -EINVAL) {"FW upgrade to %d.%d.%d %s\n" ,"failed" : "succeeded" );if (err == -EINVAL) {"TP upgrade to %d.%d.%d %s\n" ,"failed" : "succeeded" );/* * Clear interrupts now to catch errors if t3_init_hw fails. * We clear them again later as initialization may trigger * conditions that can interrupt. if (err)goto out;if (err)goto out;if (!(adap->flags & NAPI_INIT))if (adap->flags & USING_MSIX) {if (err)goto irq_err;if (err) {goto irq_err;else {if (err)goto irq_err;if (adap->params.rev >= T3_REV_C && !(adap->flags & TP_PARITY_INIT) &&if (adap->flags & TP_PARITY_INIT) {if (!(adap->flags & QUEUES_BOUND)) {int ret = bind_qsets(adap);if (ret < 0) {"failed to bind qsets, err %d\n" , ret);goto out;return err;"request_irq failed, err %d\n" , err);goto out;/* * Release resources when all the ports and offloading have been stopped. static void cxgb_down(struct adapter *adapter, int on_wq)/* sync with PHY intr task */ if (!on_wq)/* wait for external IRQ handler */ static void schedule_chk_task(struct adapter *adap)unsigned int timeo;if (timeo)static int offload_open(struct net_device *dev)struct port_info *pi = netdev_priv(dev);struct adapter *adapter = pi->adapter;struct t3cdev *tdev = dev2t3cdev(dev);int adap_up = adapter->open_device_map & PORT_MASK;int err;if (test_and_set_bit(OFFLOAD_DEVMAP_BIT, &adapter->open_device_map))return 0;if (!adap_up && (err = cxgb_up(adapter)) < 0)goto out;if (err)goto out;if (sysfs_create_group(&tdev->lldev->dev.kobj, &offload_attr_group))"cannot create sysfs group\n" );/* Call back all registered clients */ /* restore them in case the offload module has changed them */ if (err) {return err;static int offload_close(struct t3cdev *tdev)struct adapter *adapter = tdev2adap(tdev);struct t3c_data *td = T3C_DATA(tdev);if (!test_bit(OFFLOAD_DEVMAP_BIT, &adapter->open_device_map))return 0;/* Call back all registered clients */ /* Flush work scheduled while releasing TIDs */ if (!adapter->open_device_map)return 0;static int cxgb_open(struct net_device *dev)struct port_info *pi = netdev_priv(dev);struct adapter *adapter = pi->adapter;int other_ports = adapter->open_device_map & PORT_MASK;int err;if (!adapter->open_device_map && (err = cxgb_up(adapter)) < 0)return err;if (is_offload(adapter) && !ofld_disable) {if (err)"Could not initialize offload capabilities\n" );if (err)return err;if (!other_ports)return 0;static int __cxgb_close(struct net_device *dev, int on_wq)struct port_info *pi = netdev_priv(dev);struct adapter *adapter = pi->adapter;if (!adapter->open_device_map)return 0;/* Stop link fault interrupts */ /* sync with update task */ if (!(adapter->open_device_map & PORT_MASK))if (!adapter->open_device_map)return 0;static int cxgb_close(struct net_device *dev)return __cxgb_close(dev, 0);static struct net_device_stats *cxgb_get_stats(struct net_device *dev)struct port_info *pi = netdev_priv(dev);struct adapter *adapter = pi->adapter;struct net_device_stats *ns = &dev->stats;const struct mac_stats *pstats;/* detailed rx_errors */ /* detailed tx_errors */ return ns;static u32 get_msglevel(struct net_device *dev)struct port_info *pi = netdev_priv(dev);struct adapter *adapter = pi->adapter;return adapter->msg_enable;static void set_msglevel(struct net_device *dev, u32 val)struct port_info *pi = netdev_priv(dev);struct adapter *adapter = pi->adapter;static const char stats_strings[][ETH_GSTRING_LEN] = {"TxOctetsOK " ,"TxFramesOK " ,"TxMulticastFramesOK" ,"TxBroadcastFramesOK" ,"TxPauseFrames " ,"TxUnderrun " ,"TxExtUnderrun " ,"TxFrames64 " ,"TxFrames65To127 " ,"TxFrames128To255 " ,"TxFrames256To511 " ,"TxFrames512To1023 " ,"TxFrames1024To1518 " ,"TxFrames1519ToMax " ,"RxOctetsOK " ,"RxFramesOK " ,"RxMulticastFramesOK" ,"RxBroadcastFramesOK" ,"RxPauseFrames " ,"RxFCSErrors " ,"RxSymbolErrors " ,"RxShortErrors " ,"RxJabberErrors " ,"RxLengthErrors " ,"RxFIFOoverflow " ,"RxFrames64 " ,"RxFrames65To127 " ,"RxFrames128To255 " ,"RxFrames256To511 " ,"RxFrames512To1023 " ,"RxFrames1024To1518 " ,"RxFrames1519ToMax " ,"PhyFIFOErrors " ,"TSO " ,"VLANextractions " ,"VLANinsertions " ,"TxCsumOffload " ,"RxCsumGood " ,"LroAggregated " ,"LroFlushed " ,"LroNoDesc " ,"RxDrops " ,"CheckTXEnToggled " ,"CheckResets " ,"LinkFaults " ,static int get_sset_count(struct net_device *dev, int sset)switch (sset) {case ETH_SS_STATS:return ARRAY_SIZE(stats_strings);default :return -EOPNOTSUPP;#define T3_REGMAP_SIZE (3 * 1024)static int get_regs_len(struct net_device *dev)return T3_REGMAP_SIZE;static int get_eeprom_len(struct net_device *dev)return EEPROMSIZE;static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)struct port_info *pi = netdev_priv(dev);struct adapter *adapter = pi->adapter;sizeof (info->driver));sizeof (info->bus_info));if (fw_vers)sizeof (info->fw_version),"%s %u.%u.%u TP %u.%u.%u" ,"T" : "N" ,static void get_strings(struct net_device *dev, u32 stringset, u8 * data)if (stringset == ETH_SS_STATS)sizeof (stats_strings));static unsigned long collect_sge_port_stats(struct adapter *adapter,struct port_info *p, int idx)int i;unsigned long tot = 0;for (i = p->first_qset; i < p->first_qset + p->nqsets; ++i)return tot;static void get_stats(struct net_device *dev, struct ethtool_stats *stats,struct port_info *pi = netdev_priv(dev);struct adapter *adapter = pi->adapter;const struct mac_stats *s;static inline void reg_block_dump(struct adapter *ap, void *buf,unsigned int start, unsigned int end)for (; start <= end; start += sizeof (u32))static void get_regs(struct net_device *dev, struct ethtool_regs *regs,void *buf)struct port_info *pi = netdev_priv(dev);struct adapter *ap = pi->adapter;/* * Version scheme: * bits 0..9: chip version * bits 10..15: chip revision * bit 31: set for PCIe cards /* * We skip the MAC statistics registers because they are clear-on-read. * Also reading multi-register stats would need to synchronize with the * periodic mac stats accumulation. Hard to justify the complexity. static int restart_autoneg(struct net_device *dev)struct port_info *p = netdev_priv(dev);if (!netif_running(dev))return -EAGAIN;if (p->link_config.autoneg != AUTONEG_ENABLE)return -EINVAL;return 0;static int set_phys_id(struct net_device *dev,enum ethtool_phys_id_state state)struct port_info *pi = netdev_priv(dev);struct adapter *adapter = pi->adapter;switch (state) {case ETHTOOL_ID_ACTIVE:return 1; /* cycle on/off once per second */ case ETHTOOL_ID_OFF:break ;case ETHTOOL_ID_ON:case ETHTOOL_ID_INACTIVE:return 0;static int get_link_ksettings(struct net_device *dev,struct ethtool_link_ksettings *cmd)struct port_info *p = netdev_priv(dev);if (netif_carrier_ok(dev)) {else {return 0;static int speed_duplex_to_caps(int speed, int duplex)int cap = 0;switch (speed) {case SPEED_10:if (duplex == DUPLEX_FULL)else break ;case SPEED_100:if (duplex == DUPLEX_FULL)else break ;case SPEED_1000:if (duplex == DUPLEX_FULL)else break ;case SPEED_10000:if (duplex == DUPLEX_FULL)return cap;#define ADVERTISED_MASK (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full | \static int set_link_ksettings(struct net_device *dev,const struct ethtool_link_ksettings *cmd)struct port_info *p = netdev_priv(dev);struct link_config *lc = &p->link_config;if (!(lc->supported & SUPPORTED_Autoneg)) {/* * PHY offers a single speed/duplex. See if that's what's * being requested. if (cmd->base.autoneg == AUTONEG_DISABLE) {int cap = speed_duplex_to_caps(speed, cmd->base.duplex);if (lc->supported & cap)return 0;return -EINVAL;if (cmd->base.autoneg == AUTONEG_DISABLE) {int cap = speed_duplex_to_caps(speed, cmd->base.duplex);if (!(lc->supported & cap) || (speed == SPEED_1000))return -EINVAL;else {if (!advertising)return -EINVAL;if (netif_running(dev))return 0;static void get_pauseparam(struct net_device *dev,struct ethtool_pauseparam *epause)struct port_info *p = netdev_priv(dev);static int set_pauseparam(struct net_device *dev,struct ethtool_pauseparam *epause)struct port_info *p = netdev_priv(dev);struct link_config *lc = &p->link_config;if (epause->autoneg == AUTONEG_DISABLE)else if (lc->supported & SUPPORTED_Autoneg)else return -EINVAL;if (epause->rx_pause)if (epause->tx_pause)if (lc->autoneg == AUTONEG_ENABLE) {if (netif_running(dev))else {if (netif_running(dev))return 0;static void get_sge_param(struct net_device *dev, struct ethtool_ringparam *e,struct kernel_ethtool_ringparam *kernel_e,struct netlink_ext_ack *extack)struct port_info *pi = netdev_priv(dev);struct adapter *adapter = pi->adapter;const struct qset_params *q = &adapter->params.sge.qset[pi->first_qset];static int set_sge_param(struct net_device *dev, struct ethtool_ringparam *e,struct kernel_ethtool_ringparam *kernel_e,struct netlink_ext_ack *extack)struct port_info *pi = netdev_priv(dev);struct adapter *adapter = pi->adapter;struct qset_params *q;int i;if (e->rx_pending > MAX_RX_BUFFERS ||return -EINVAL;if (adapter->flags & FULL_INIT_DONE)return -EBUSY;for (i = 0; i < pi->nqsets; ++i, ++q) {return 0;static int set_coalesce(struct net_device *dev, struct ethtool_coalesce *c,struct kernel_ethtool_coalesce *kernel_coal,struct netlink_ext_ack *extack)struct port_info *pi = netdev_priv(dev);struct adapter *adapter = pi->adapter;struct qset_params *qsp;struct sge_qset *qs;int i;if (c->rx_coalesce_usecs * 10 > M_NEWTIMER)return -EINVAL;for (i = 0; i < pi->nqsets; i++) {return 0;static int get_coalesce(struct net_device *dev, struct ethtool_coalesce *c,struct kernel_ethtool_coalesce *kernel_coal,struct netlink_ext_ack *extack)struct port_info *pi = netdev_priv(dev);struct adapter *adapter = pi->adapter;struct qset_params *q = adapter->params.sge.qset;return 0;static int get_eeprom(struct net_device *dev, struct ethtool_eeprom *e,struct port_info *pi = netdev_priv(dev);struct adapter *adapter = pi->adapter;int cnt;if (cnt < 0)return cnt;return 0;static int set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,struct port_info *pi = netdev_priv(dev);struct adapter *adapter = pi->adapter;int err;if (eeprom->magic != EEPROM_MAGIC)return -EINVAL;if (aligned_offset != eeprom->offset || aligned_len != eeprom->len) {if (!buf)return -ENOMEM;if (err < 0)goto out;else if (err)goto out;if (err >= 0)if (buf != data)return err < 0 ? err : 0;static void get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)sizeof (wol->sopass));static const struct ethtool_ops cxgb_ethtool_ops = {static int cxgb_in_range(int val, int lo, int hi)return val < 0 || (val <= hi && val >= lo);static int cxgb_siocdevprivate(struct net_device *dev,struct ifreq *ifreq,void __user *useraddr,int cmd)struct port_info *pi = netdev_priv(dev);struct adapter *adapter = pi->adapter;int ret;if (cmd != SIOCCHIOCTL)return -EOPNOTSUPP;if (copy_from_user(&cmd, useraddr, sizeof (cmd)))return -EFAULT;switch (cmd) {case CHELSIO_SET_QSET_PARAMS:{int i;struct qset_params *q;struct ch_qset_params t;int q1 = pi->first_qset;int nqsets = pi->nqsets;if (!capable(CAP_NET_ADMIN))return -EPERM;if (copy_from_user(&t, useraddr, sizeof (t)))return -EFAULT;if (t.cmd != CHELSIO_SET_QSET_PARAMS)return -EINVAL;if (t.qset_idx >= SGE_QSETS)return -EINVAL;if (!cxgb_in_range(t.intr_lat, 0, M_NEWTIMER) ||return -EINVAL;if ((adapter->flags & FULL_INIT_DONE) &&return -EBUSY;/* Allow setting of any available qset when offload enabled */ if (test_bit(OFFLOAD_DEVMAP_BIT, &adapter->open_device_map)) {if (t.qset_idx < q1)return -EINVAL;if (t.qset_idx > q1 + nqsets - 1)return -EINVAL;if (t.rspq_size >= 0)if (t.fl_size[0] >= 0)if (t.fl_size[1] >= 0)if (t.txq_size[0] >= 0)if (t.txq_size[1] >= 0)if (t.txq_size[2] >= 0)if (t.cong_thres >= 0)if (t.intr_lat >= 0) {struct sge_qset *qs =if (t.polling >= 0) {if (adapter->flags & USING_MSIX)else {/* No polling with INTx for T3A */ if (adapter->params.rev == 0 &&for (i = 0; i < SGE_QSETS; i++) {if (t.lro >= 0) {if (t.lro)else break ;case CHELSIO_GET_QSET_PARAMS:{struct qset_params *q;struct ch_qset_params t;int q1 = pi->first_qset;int nqsets = pi->nqsets;int i;if (copy_from_user(&t, useraddr, sizeof (t)))return -EFAULT;if (t.cmd != CHELSIO_GET_QSET_PARAMS)return -EINVAL;/* Display qsets for all ports when offload enabled */ if (test_bit(OFFLOAD_DEVMAP_BIT, &adapter->open_device_map)) {if (t.qset_idx >= nqsets)return -EINVAL;if (adapter->flags & USING_MSIX)else if (copy_to_user(useraddr, &t, sizeof (t)))return -EFAULT;break ;case CHELSIO_SET_QSET_NUM:{struct ch_reg edata;unsigned int i, first_qset = 0, other_qsets = 0;if (!capable(CAP_NET_ADMIN))return -EPERM;if (adapter->flags & FULL_INIT_DONE)return -EBUSY;if (copy_from_user(&edata, useraddr, sizeof (edata)))return -EFAULT;if (edata.cmd != CHELSIO_SET_QSET_NUM)return -EINVAL;if (edata.val < 1 ||return -EINVAL;if (adapter->port[i] && adapter->port[i] != dev)if (edata.val + other_qsets > SGE_QSETS)return -EINVAL;if (adapter->port[i]) {break ;case CHELSIO_GET_QSET_NUM:{struct ch_reg edata;sizeof (struct ch_reg));if (copy_to_user(useraddr, &edata, sizeof (edata)))return -EFAULT;break ;case CHELSIO_LOAD_FW:{struct ch_mem_range t;if (!capable(CAP_SYS_RAWIO))return -EPERM;if (copy_from_user(&t, useraddr, sizeof (t)))return -EFAULT;if (t.cmd != CHELSIO_LOAD_FW)return -EINVAL;/* Check t.len sanity ? */ sizeof (t), t.len);if (IS_ERR(fw_data))return PTR_ERR(fw_data);if (ret)return ret;break ;case CHELSIO_SETMTUTAB:{struct ch_mtus m;int i;if (!is_offload(adapter))return -EOPNOTSUPP;if (!capable(CAP_NET_ADMIN))return -EPERM;if (offload_running(adapter))return -EBUSY;if (copy_from_user(&m, useraddr, sizeof (m)))return -EFAULT;if (m.cmd != CHELSIO_SETMTUTAB)return -EINVAL;if (m.nmtus != NMTUS)return -EINVAL;if (m.mtus[0] < 81) /* accommodate SACK */ return -EINVAL;/* MTUs must be in ascending order */ for (i = 1; i < NMTUS; ++i)if (m.mtus[i] < m.mtus[i - 1])return -EINVAL;sizeof (adapter->params.mtus));break ;case CHELSIO_GET_PM:{struct tp_params *p = &adapter->params.tp;struct ch_pm m = {.cmd = CHELSIO_GET_PM };if (!is_offload(adapter))return -EOPNOTSUPP;if (copy_to_user(useraddr, &m, sizeof (m)))return -EFAULT;break ;case CHELSIO_SET_PM:{struct ch_pm m;struct tp_params *p = &adapter->params.tp;if (!is_offload(adapter))return -EOPNOTSUPP;if (!capable(CAP_NET_ADMIN))return -EPERM;if (adapter->flags & FULL_INIT_DONE)return -EBUSY;if (copy_from_user(&m, useraddr, sizeof (m)))return -EFAULT;if (m.cmd != CHELSIO_SET_PM)return -EINVAL;if (!is_power_of_2(m.rx_pg_sz) ||return -EINVAL; /* not power of 2 */ if (!(m.rx_pg_sz & 0x14000))return -EINVAL; /* not 16KB or 64KB */ if (!(m.tx_pg_sz & 0x1554000))return -EINVAL;if (m.tx_num_pg == -1)if (m.rx_num_pg == -1)if (m.tx_num_pg % 24 || m.rx_num_pg % 24)return -EINVAL;if (m.rx_num_pg * m.rx_pg_sz > p->chan_rx_size ||return -EINVAL;break ;case CHELSIO_GET_MEM:{struct ch_mem_range t;struct mc7 *mem;if (!is_offload(adapter))return -EOPNOTSUPP;if (!capable(CAP_NET_ADMIN))return -EPERM;if (!(adapter->flags & FULL_INIT_DONE))return -EIO; /* need the memory controllers */ if (copy_from_user(&t, useraddr, sizeof (t)))return -EFAULT;if (t.cmd != CHELSIO_GET_MEM)return -EINVAL;if ((t.addr & 7) || (t.len & 7))return -EINVAL;if (t.mem_id == MEM_CM)else if (t.mem_id == MEM_PMRX)else if (t.mem_id == MEM_PMTX)else return -EINVAL;/* * Version scheme: * bits 0..9: chip version * bits 10..15: chip revision if (copy_to_user(useraddr, &t, sizeof (t)))return -EFAULT;/* * Read 256 bytes at a time as len can be large and we don't * want to use huge intermediate buffers. sizeof (t); /* advance to start of buffer */ while (t.len) {unsigned int chunk =unsigned int , t.len, sizeof (buf));if (ret)return ret;if (copy_to_user(useraddr, buf, chunk))return -EFAULT;break ;case CHELSIO_SET_TRACE_FILTER:{struct ch_trace t;const struct trace_params *tp;if (!capable(CAP_NET_ADMIN))return -EPERM;if (!offload_running(adapter))return -EAGAIN;if (copy_from_user(&t, useraddr, sizeof (t)))return -EFAULT;if (t.cmd != CHELSIO_SET_TRACE_FILTER)return -EINVAL;const struct trace_params *)&t.sip;if (t.config_tx)if (t.config_rx)break ;default :return -EOPNOTSUPP;return 0;static int cxgb_ioctl(struct net_device *dev, struct ifreq *req, int cmd)struct mii_ioctl_data *data = if_mii(req);
Messung V0.5 C=95 H=93 G=93
¤ Dauer der Verarbeitung: 0.19 Sekunden
(vorverarbeitet)
¤ *© Formatika GbR, Deutschland
