1b6d90eb7SKip Macy /************************************************************************** 2b6d90eb7SKip Macy 3f2d8ff04SGeorge V. Neville-Neil Copyright (c) 2007-2009, Chelsio Inc. 4b6d90eb7SKip Macy All rights reserved. 5b6d90eb7SKip Macy 6b6d90eb7SKip Macy Redistribution and use in source and binary forms, with or without 7b6d90eb7SKip Macy modification, are permitted provided that the following conditions are met: 8b6d90eb7SKip Macy 9b6d90eb7SKip Macy 1. Redistributions of source code must retain the above copyright notice, 10b6d90eb7SKip Macy this list of conditions and the following disclaimer. 11b6d90eb7SKip Macy 12d722cab4SKip Macy 2. Neither the name of the Chelsio Corporation nor the names of its 13b6d90eb7SKip Macy contributors may be used to endorse or promote products derived from 14b6d90eb7SKip Macy this software without specific prior written permission. 15b6d90eb7SKip Macy 16b6d90eb7SKip Macy THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 17b6d90eb7SKip Macy AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18b6d90eb7SKip Macy IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19b6d90eb7SKip Macy ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 20b6d90eb7SKip Macy LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21b6d90eb7SKip Macy CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22b6d90eb7SKip Macy SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23b6d90eb7SKip Macy INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24b6d90eb7SKip Macy CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25b6d90eb7SKip Macy ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26b6d90eb7SKip Macy POSSIBILITY OF SUCH DAMAGE. 27b6d90eb7SKip Macy 28b6d90eb7SKip Macy ***************************************************************************/ 29b6d90eb7SKip Macy 30b6d90eb7SKip Macy #include <sys/cdefs.h> 31b6d90eb7SKip Macy __FBSDID("$FreeBSD$"); 32b6d90eb7SKip Macy 33b6d90eb7SKip Macy #include <sys/param.h> 34b6d90eb7SKip Macy #include <sys/systm.h> 35b6d90eb7SKip Macy #include <sys/kernel.h> 36b6d90eb7SKip Macy #include <sys/bus.h> 37b6d90eb7SKip Macy #include <sys/module.h> 38b6d90eb7SKip Macy #include <sys/pciio.h> 39b6d90eb7SKip Macy #include <sys/conf.h> 40b6d90eb7SKip Macy #include <machine/bus.h> 41b6d90eb7SKip Macy #include <machine/resource.h> 42b6d90eb7SKip Macy #include <sys/bus_dma.h> 438e10660fSKip Macy #include <sys/ktr.h> 44b6d90eb7SKip Macy #include <sys/rman.h> 45b6d90eb7SKip Macy #include <sys/ioccom.h> 46b6d90eb7SKip Macy #include <sys/mbuf.h> 47b6d90eb7SKip Macy #include <sys/linker.h> 48b6d90eb7SKip Macy #include <sys/firmware.h> 49b6d90eb7SKip Macy #include <sys/socket.h> 50b6d90eb7SKip Macy #include <sys/sockio.h> 51b6d90eb7SKip Macy #include <sys/smp.h> 52b6d90eb7SKip Macy #include <sys/sysctl.h> 538090c9f5SKip Macy #include <sys/syslog.h> 54b6d90eb7SKip Macy #include <sys/queue.h> 55b6d90eb7SKip Macy #include <sys/taskqueue.h> 568090c9f5SKip Macy #include <sys/proc.h> 57b6d90eb7SKip Macy 58b6d90eb7SKip Macy #include <net/bpf.h> 59b6d90eb7SKip Macy #include <net/ethernet.h> 60b6d90eb7SKip Macy #include <net/if.h> 61b6d90eb7SKip Macy #include <net/if_arp.h> 62b6d90eb7SKip Macy #include <net/if_dl.h> 63b6d90eb7SKip Macy #include <net/if_media.h> 64b6d90eb7SKip Macy #include <net/if_types.h> 654af83c8cSKip Macy #include <net/if_vlan_var.h> 66b6d90eb7SKip Macy 67b6d90eb7SKip Macy #include <netinet/in_systm.h> 68b6d90eb7SKip Macy #include <netinet/in.h> 69b6d90eb7SKip Macy #include <netinet/if_ether.h> 70b6d90eb7SKip Macy #include <netinet/ip.h> 71b6d90eb7SKip Macy #include <netinet/ip.h> 72b6d90eb7SKip Macy #include <netinet/tcp.h> 73b6d90eb7SKip Macy #include <netinet/udp.h> 74b6d90eb7SKip Macy 75b6d90eb7SKip Macy #include <dev/pci/pcireg.h> 76b6d90eb7SKip Macy #include <dev/pci/pcivar.h> 77b6d90eb7SKip Macy #include <dev/pci/pci_private.h> 78b6d90eb7SKip Macy 7910faa568SKip Macy #include <cxgb_include.h> 80b6d90eb7SKip Macy 81b6d90eb7SKip Macy #ifdef PRIV_SUPPORTED 82b6d90eb7SKip Macy #include <sys/priv.h> 83b6d90eb7SKip Macy #endif 84b6d90eb7SKip Macy 85e3503bc9SGeorge V. Neville-Neil static int cxgb_setup_interrupts(adapter_t *); 86e3503bc9SGeorge V. Neville-Neil static void cxgb_teardown_interrupts(adapter_t *); 87b6d90eb7SKip Macy static void cxgb_init(void *); 88b302b77cSNavdeep Parhar static int cxgb_init_locked(struct port_info *); 89b302b77cSNavdeep Parhar static int cxgb_uninit_locked(struct port_info *); 903f345a5dSKip Macy static int cxgb_uninit_synchronized(struct port_info *); 91b6d90eb7SKip Macy static int cxgb_ioctl(struct ifnet *, unsigned long, caddr_t); 92b6d90eb7SKip Macy static int cxgb_media_change(struct ifnet *); 93837f41b0SGeorge V. Neville-Neil static int cxgb_ifm_type(int); 942975f787SNavdeep Parhar static void cxgb_build_medialist(struct port_info *); 95b6d90eb7SKip Macy static void cxgb_media_status(struct ifnet *, struct ifmediareq *); 96b6d90eb7SKip Macy static int setup_sge_qsets(adapter_t *); 97b6d90eb7SKip Macy static void cxgb_async_intr(void *); 98bb38cd2fSKip Macy static void cxgb_tick_handler(void *, int); 99b6d90eb7SKip Macy static void cxgb_tick(void *); 100bd1a9fbaSNavdeep Parhar static void link_check_callout(void *); 101bd1a9fbaSNavdeep Parhar static void check_link_status(void *, int); 102b6d90eb7SKip Macy static void setup_rss(adapter_t *sc); 103d6da8362SNavdeep Parhar static int alloc_filters(struct adapter *); 104d6da8362SNavdeep Parhar static int setup_hw_filters(struct adapter *); 105d6da8362SNavdeep Parhar static int set_filter(struct adapter *, int, const struct filter_info *); 106d6da8362SNavdeep Parhar static inline void mk_set_tcb_field(struct cpl_set_tcb_field *, unsigned int, 107d6da8362SNavdeep Parhar unsigned int, u64, u64); 108d6da8362SNavdeep Parhar static inline void set_tcb_field_ulp(struct cpl_set_tcb_field *, unsigned int, 109d6da8362SNavdeep Parhar unsigned int, u64, u64); 110b6d90eb7SKip Macy 111b6d90eb7SKip Macy /* Attachment glue for the PCI controller end of the device. Each port of 112b6d90eb7SKip Macy * the device is attached separately, as defined later. 113b6d90eb7SKip Macy */ 114b6d90eb7SKip Macy static int cxgb_controller_probe(device_t); 115b6d90eb7SKip Macy static int cxgb_controller_attach(device_t); 116b6d90eb7SKip Macy static int cxgb_controller_detach(device_t); 117b6d90eb7SKip Macy static void cxgb_free(struct adapter *); 118b6d90eb7SKip Macy static __inline void reg_block_dump(struct adapter *ap, uint8_t *buf, unsigned int start, 119b6d90eb7SKip Macy unsigned int end); 1201ffd6e58SKip Macy static void cxgb_get_regs(adapter_t *sc, struct ch_ifconf_regs *regs, uint8_t *buf); 121b6d90eb7SKip Macy static int cxgb_get_regs_len(void); 122d722cab4SKip Macy static int offload_open(struct port_info *pi); 1237ac2e6c3SKip Macy static void touch_bars(device_t dev); 1243e96c7e7SKip Macy static int offload_close(struct t3cdev *tdev); 125c01f2b83SNavdeep Parhar static void cxgb_update_mac_settings(struct port_info *p); 126b6d90eb7SKip Macy 127b6d90eb7SKip Macy static device_method_t cxgb_controller_methods[] = { 128b6d90eb7SKip Macy DEVMETHOD(device_probe, cxgb_controller_probe), 129b6d90eb7SKip Macy DEVMETHOD(device_attach, cxgb_controller_attach), 130b6d90eb7SKip Macy DEVMETHOD(device_detach, cxgb_controller_detach), 131b6d90eb7SKip Macy 132b6d90eb7SKip Macy /* bus interface */ 133b6d90eb7SKip Macy DEVMETHOD(bus_print_child, bus_generic_print_child), 134b6d90eb7SKip Macy DEVMETHOD(bus_driver_added, bus_generic_driver_added), 135b6d90eb7SKip Macy 136b6d90eb7SKip Macy { 0, 0 } 137b6d90eb7SKip Macy }; 138b6d90eb7SKip Macy 139b6d90eb7SKip Macy static driver_t cxgb_controller_driver = { 140b6d90eb7SKip Macy "cxgbc", 141b6d90eb7SKip Macy cxgb_controller_methods, 142b6d90eb7SKip Macy sizeof(struct adapter) 143b6d90eb7SKip Macy }; 144b6d90eb7SKip Macy 145b6d90eb7SKip Macy static devclass_t cxgb_controller_devclass; 146b6d90eb7SKip Macy DRIVER_MODULE(cxgbc, pci, cxgb_controller_driver, cxgb_controller_devclass, 0, 0); 147b6d90eb7SKip Macy 148b6d90eb7SKip Macy /* 149b6d90eb7SKip Macy * Attachment glue for the ports. Attachment is done directly to the 150b6d90eb7SKip Macy * controller device. 151b6d90eb7SKip Macy */ 152b6d90eb7SKip Macy static int cxgb_port_probe(device_t); 153b6d90eb7SKip Macy static int cxgb_port_attach(device_t); 154b6d90eb7SKip Macy static int cxgb_port_detach(device_t); 155b6d90eb7SKip Macy 156b6d90eb7SKip Macy static device_method_t cxgb_port_methods[] = { 157b6d90eb7SKip Macy DEVMETHOD(device_probe, cxgb_port_probe), 158b6d90eb7SKip Macy DEVMETHOD(device_attach, cxgb_port_attach), 159b6d90eb7SKip Macy DEVMETHOD(device_detach, cxgb_port_detach), 160b6d90eb7SKip Macy { 0, 0 } 161b6d90eb7SKip Macy }; 162b6d90eb7SKip Macy 163b6d90eb7SKip Macy static driver_t cxgb_port_driver = { 164b6d90eb7SKip Macy "cxgb", 165b6d90eb7SKip Macy cxgb_port_methods, 166b6d90eb7SKip Macy 0 167b6d90eb7SKip Macy }; 168b6d90eb7SKip Macy 169b6d90eb7SKip Macy static d_ioctl_t cxgb_extension_ioctl; 170ef72318fSKip Macy static d_open_t cxgb_extension_open; 171ef72318fSKip Macy static d_close_t cxgb_extension_close; 172ef72318fSKip Macy 173ef72318fSKip Macy static struct cdevsw cxgb_cdevsw = { 174ef72318fSKip Macy .d_version = D_VERSION, 175ef72318fSKip Macy .d_flags = 0, 176ef72318fSKip Macy .d_open = cxgb_extension_open, 177ef72318fSKip Macy .d_close = cxgb_extension_close, 178ef72318fSKip Macy .d_ioctl = cxgb_extension_ioctl, 179ef72318fSKip Macy .d_name = "cxgb", 180ef72318fSKip Macy }; 181b6d90eb7SKip Macy 182b6d90eb7SKip Macy static devclass_t cxgb_port_devclass; 183b6d90eb7SKip Macy DRIVER_MODULE(cxgb, cxgbc, cxgb_port_driver, cxgb_port_devclass, 0, 0); 184b6d90eb7SKip Macy 185b6d90eb7SKip Macy /* 186b6d90eb7SKip Macy * The driver uses the best interrupt scheme available on a platform in the 187b6d90eb7SKip Macy * order MSI-X, MSI, legacy pin interrupts. This parameter determines which 188b6d90eb7SKip Macy * of these schemes the driver may consider as follows: 189b6d90eb7SKip Macy * 190b6d90eb7SKip Macy * msi = 2: choose from among all three options 191b6d90eb7SKip Macy * msi = 1 : only consider MSI and pin interrupts 192b6d90eb7SKip Macy * msi = 0: force pin interrupts 193b6d90eb7SKip Macy */ 194693d746cSKip Macy static int msi_allowed = 2; 195cebf6b9fSKip Macy 196b6d90eb7SKip Macy TUNABLE_INT("hw.cxgb.msi_allowed", &msi_allowed); 197b6d90eb7SKip Macy SYSCTL_NODE(_hw, OID_AUTO, cxgb, CTLFLAG_RD, 0, "CXGB driver parameters"); 198*deceab87SMatthew D Fleming SYSCTL_INT(_hw_cxgb, OID_AUTO, msi_allowed, CTLFLAG_RDTUN, &msi_allowed, 0, 199b6d90eb7SKip Macy "MSI-X, MSI, INTx selector"); 200d722cab4SKip Macy 20164c43db5SKip Macy /* 202d722cab4SKip Macy * The driver enables offload as a default. 203d722cab4SKip Macy * To disable it, use ofld_disable = 1. 204d722cab4SKip Macy */ 205d722cab4SKip Macy static int ofld_disable = 0; 206d722cab4SKip Macy TUNABLE_INT("hw.cxgb.ofld_disable", &ofld_disable); 207*deceab87SMatthew D Fleming SYSCTL_INT(_hw_cxgb, OID_AUTO, ofld_disable, CTLFLAG_RDTUN, &ofld_disable, 0, 208d722cab4SKip Macy "disable ULP offload"); 209d722cab4SKip Macy 210d722cab4SKip Macy /* 211d722cab4SKip Macy * The driver uses an auto-queue algorithm by default. 212a02573bcSKip Macy * To disable it and force a single queue-set per port, use multiq = 0 21364c43db5SKip Macy */ 214a02573bcSKip Macy static int multiq = 1; 215a02573bcSKip Macy TUNABLE_INT("hw.cxgb.multiq", &multiq); 216*deceab87SMatthew D Fleming SYSCTL_INT(_hw_cxgb, OID_AUTO, multiq, CTLFLAG_RDTUN, &multiq, 0, 217a02573bcSKip Macy "use min(ncpus/ports, 8) queue-sets per port"); 218f001b63dSKip Macy 219404825a7SKip Macy /* 220a02573bcSKip Macy * By default the driver will not update the firmware unless 221a02573bcSKip Macy * it was compiled against a newer version 222a02573bcSKip Macy * 223404825a7SKip Macy */ 224404825a7SKip Macy static int force_fw_update = 0; 225404825a7SKip Macy TUNABLE_INT("hw.cxgb.force_fw_update", &force_fw_update); 226*deceab87SMatthew D Fleming SYSCTL_INT(_hw_cxgb, OID_AUTO, force_fw_update, CTLFLAG_RDTUN, &force_fw_update, 0, 227404825a7SKip Macy "update firmware even if up to date"); 228f001b63dSKip Macy 22997ae3bc3SNavdeep Parhar int cxgb_use_16k_clusters = -1; 230f001b63dSKip Macy TUNABLE_INT("hw.cxgb.use_16k_clusters", &cxgb_use_16k_clusters); 23197ae3bc3SNavdeep Parhar SYSCTL_INT(_hw_cxgb, OID_AUTO, use_16k_clusters, CTLFLAG_RDTUN, 232f001b63dSKip Macy &cxgb_use_16k_clusters, 0, "use 16kB clusters for the jumbo queue "); 233f001b63dSKip Macy 23402c7d9a6SGeorge V. Neville-Neil /* 23502c7d9a6SGeorge V. Neville-Neil * Tune the size of the output queue. 23602c7d9a6SGeorge V. Neville-Neil */ 23702c7d9a6SGeorge V. Neville-Neil int cxgb_snd_queue_len = IFQ_MAXLEN; 23802c7d9a6SGeorge V. Neville-Neil TUNABLE_INT("hw.cxgb.snd_queue_len", &cxgb_snd_queue_len); 239*deceab87SMatthew D Fleming SYSCTL_INT(_hw_cxgb, OID_AUTO, snd_queue_len, CTLFLAG_RDTUN, 24002c7d9a6SGeorge V. Neville-Neil &cxgb_snd_queue_len, 0, "send queue size "); 24102c7d9a6SGeorge V. Neville-Neil 2423a2c6562SNavdeep Parhar static int nfilters = -1; 2433a2c6562SNavdeep Parhar TUNABLE_INT("hw.cxgb.nfilters", &nfilters); 2443a2c6562SNavdeep Parhar SYSCTL_INT(_hw_cxgb, OID_AUTO, nfilters, CTLFLAG_RDTUN, 2453a2c6562SNavdeep Parhar &nfilters, 0, "max number of entries in the filter table"); 24602c7d9a6SGeorge V. Neville-Neil 247b6d90eb7SKip Macy enum { 248b6d90eb7SKip Macy MAX_TXQ_ENTRIES = 16384, 249b6d90eb7SKip Macy MAX_CTRL_TXQ_ENTRIES = 1024, 250b6d90eb7SKip Macy MAX_RSPQ_ENTRIES = 16384, 251b6d90eb7SKip Macy MAX_RX_BUFFERS = 16384, 252b6d90eb7SKip Macy MAX_RX_JUMBO_BUFFERS = 16384, 253b6d90eb7SKip Macy MIN_TXQ_ENTRIES = 4, 254b6d90eb7SKip Macy MIN_CTRL_TXQ_ENTRIES = 4, 255b6d90eb7SKip Macy MIN_RSPQ_ENTRIES = 32, 2565c5df3daSKip Macy MIN_FL_ENTRIES = 32, 2575c5df3daSKip Macy MIN_FL_JUMBO_ENTRIES = 32 258b6d90eb7SKip Macy }; 259b6d90eb7SKip Macy 260ac3a6d9cSKip Macy struct filter_info { 261ac3a6d9cSKip Macy u32 sip; 262ac3a6d9cSKip Macy u32 sip_mask; 263ac3a6d9cSKip Macy u32 dip; 264ac3a6d9cSKip Macy u16 sport; 265ac3a6d9cSKip Macy u16 dport; 266ac3a6d9cSKip Macy u32 vlan:12; 267ac3a6d9cSKip Macy u32 vlan_prio:3; 268ac3a6d9cSKip Macy u32 mac_hit:1; 269ac3a6d9cSKip Macy u32 mac_idx:4; 270ac3a6d9cSKip Macy u32 mac_vld:1; 271ac3a6d9cSKip Macy u32 pkt_type:2; 272ac3a6d9cSKip Macy u32 report_filter_id:1; 273ac3a6d9cSKip Macy u32 pass:1; 274ac3a6d9cSKip Macy u32 rss:1; 275ac3a6d9cSKip Macy u32 qset:3; 276ac3a6d9cSKip Macy u32 locked:1; 277ac3a6d9cSKip Macy u32 valid:1; 278ac3a6d9cSKip Macy }; 279ac3a6d9cSKip Macy 280ac3a6d9cSKip Macy enum { FILTER_NO_VLAN_PRI = 7 }; 281ac3a6d9cSKip Macy 2821ffd6e58SKip Macy #define EEPROM_MAGIC 0x38E2F10C 2831ffd6e58SKip Macy 284b6d90eb7SKip Macy #define PORT_MASK ((1 << MAX_NPORTS) - 1) 285b6d90eb7SKip Macy 286b6d90eb7SKip Macy /* Table for probing the cards. The desc field isn't actually used */ 287b6d90eb7SKip Macy struct cxgb_ident { 288b6d90eb7SKip Macy uint16_t vendor; 289b6d90eb7SKip Macy uint16_t device; 290b6d90eb7SKip Macy int index; 291b6d90eb7SKip Macy char *desc; 292b6d90eb7SKip Macy } cxgb_identifiers[] = { 293b6d90eb7SKip Macy {PCI_VENDOR_ID_CHELSIO, 0x0020, 0, "PE9000"}, 294b6d90eb7SKip Macy {PCI_VENDOR_ID_CHELSIO, 0x0021, 1, "T302E"}, 295b6d90eb7SKip Macy {PCI_VENDOR_ID_CHELSIO, 0x0022, 2, "T310E"}, 296b6d90eb7SKip Macy {PCI_VENDOR_ID_CHELSIO, 0x0023, 3, "T320X"}, 297b6d90eb7SKip Macy {PCI_VENDOR_ID_CHELSIO, 0x0024, 1, "T302X"}, 298b6d90eb7SKip Macy {PCI_VENDOR_ID_CHELSIO, 0x0025, 3, "T320E"}, 299b6d90eb7SKip Macy {PCI_VENDOR_ID_CHELSIO, 0x0026, 2, "T310X"}, 300b6d90eb7SKip Macy {PCI_VENDOR_ID_CHELSIO, 0x0030, 2, "T3B10"}, 301b6d90eb7SKip Macy {PCI_VENDOR_ID_CHELSIO, 0x0031, 3, "T3B20"}, 302b6d90eb7SKip Macy {PCI_VENDOR_ID_CHELSIO, 0x0032, 1, "T3B02"}, 303ef72318fSKip Macy {PCI_VENDOR_ID_CHELSIO, 0x0033, 4, "T3B04"}, 304c01f2b83SNavdeep Parhar {PCI_VENDOR_ID_CHELSIO, 0x0035, 6, "T3C10"}, 305c01f2b83SNavdeep Parhar {PCI_VENDOR_ID_CHELSIO, 0x0036, 3, "S320E-CR"}, 306c01f2b83SNavdeep Parhar {PCI_VENDOR_ID_CHELSIO, 0x0037, 7, "N320E-G2"}, 307b6d90eb7SKip Macy {0, 0, 0, NULL} 308b6d90eb7SKip Macy }; 309b6d90eb7SKip Macy 310ac3a6d9cSKip Macy static int set_eeprom(struct port_info *pi, const uint8_t *data, int len, int offset); 311ac3a6d9cSKip Macy 3128e10660fSKip Macy 3138090c9f5SKip Macy static __inline char 314ac3a6d9cSKip Macy t3rev2char(struct adapter *adapter) 315ac3a6d9cSKip Macy { 316ac3a6d9cSKip Macy char rev = 'z'; 317ac3a6d9cSKip Macy 318ac3a6d9cSKip Macy switch(adapter->params.rev) { 319ac3a6d9cSKip Macy case T3_REV_A: 320ac3a6d9cSKip Macy rev = 'a'; 321ac3a6d9cSKip Macy break; 322ac3a6d9cSKip Macy case T3_REV_B: 323ac3a6d9cSKip Macy case T3_REV_B2: 324ac3a6d9cSKip Macy rev = 'b'; 325ac3a6d9cSKip Macy break; 326ac3a6d9cSKip Macy case T3_REV_C: 327ac3a6d9cSKip Macy rev = 'c'; 328ac3a6d9cSKip Macy break; 329ac3a6d9cSKip Macy } 330ac3a6d9cSKip Macy return rev; 331ac3a6d9cSKip Macy } 332ac3a6d9cSKip Macy 333b6d90eb7SKip Macy static struct cxgb_ident * 334b6d90eb7SKip Macy cxgb_get_ident(device_t dev) 335b6d90eb7SKip Macy { 336b6d90eb7SKip Macy struct cxgb_ident *id; 337b6d90eb7SKip Macy 338b6d90eb7SKip Macy for (id = cxgb_identifiers; id->desc != NULL; id++) { 339b6d90eb7SKip Macy if ((id->vendor == pci_get_vendor(dev)) && 340b6d90eb7SKip Macy (id->device == pci_get_device(dev))) { 341b6d90eb7SKip Macy return (id); 342b6d90eb7SKip Macy } 343b6d90eb7SKip Macy } 344b6d90eb7SKip Macy return (NULL); 345b6d90eb7SKip Macy } 346b6d90eb7SKip Macy 347b6d90eb7SKip Macy static const struct adapter_info * 348b6d90eb7SKip Macy cxgb_get_adapter_info(device_t dev) 349b6d90eb7SKip Macy { 350b6d90eb7SKip Macy struct cxgb_ident *id; 351b6d90eb7SKip Macy const struct adapter_info *ai; 352b6d90eb7SKip Macy 353b6d90eb7SKip Macy id = cxgb_get_ident(dev); 354b6d90eb7SKip Macy if (id == NULL) 355b6d90eb7SKip Macy return (NULL); 356b6d90eb7SKip Macy 357b6d90eb7SKip Macy ai = t3_get_adapter_info(id->index); 358b6d90eb7SKip Macy 359b6d90eb7SKip Macy return (ai); 360b6d90eb7SKip Macy } 361b6d90eb7SKip Macy 362b6d90eb7SKip Macy static int 363b6d90eb7SKip Macy cxgb_controller_probe(device_t dev) 364b6d90eb7SKip Macy { 365b6d90eb7SKip Macy const struct adapter_info *ai; 366b6d90eb7SKip Macy char *ports, buf[80]; 367ef72318fSKip Macy int nports; 368b6d90eb7SKip Macy 369b6d90eb7SKip Macy ai = cxgb_get_adapter_info(dev); 370b6d90eb7SKip Macy if (ai == NULL) 371b6d90eb7SKip Macy return (ENXIO); 372b6d90eb7SKip Macy 373ef72318fSKip Macy nports = ai->nports0 + ai->nports1; 374ef72318fSKip Macy if (nports == 1) 375b6d90eb7SKip Macy ports = "port"; 376b6d90eb7SKip Macy else 377b6d90eb7SKip Macy ports = "ports"; 378b6d90eb7SKip Macy 3797ead19d4SNavdeep Parhar snprintf(buf, sizeof(buf), "%s, %d %s", ai->desc, nports, ports); 380b6d90eb7SKip Macy device_set_desc_copy(dev, buf); 381b6d90eb7SKip Macy return (BUS_PROBE_DEFAULT); 382b6d90eb7SKip Macy } 383b6d90eb7SKip Macy 384404825a7SKip Macy #define FW_FNAME "cxgb_t3fw" 3850c1ff9c6SGeorge V. Neville-Neil #define TPEEPROM_NAME "cxgb_t3%c_tp_eeprom" 3860c1ff9c6SGeorge V. Neville-Neil #define TPSRAM_NAME "cxgb_t3%c_protocol_sram" 387ac3a6d9cSKip Macy 388b6d90eb7SKip Macy static int 389d722cab4SKip Macy upgrade_fw(adapter_t *sc) 390b6d90eb7SKip Macy { 391b6d90eb7SKip Macy const struct firmware *fw; 392b6d90eb7SKip Macy int status; 393a9da6d23SNavdeep Parhar u32 vers; 394b6d90eb7SKip Macy 395404825a7SKip Macy if ((fw = firmware_get(FW_FNAME)) == NULL) { 396404825a7SKip Macy device_printf(sc->dev, "Could not find firmware image %s\n", FW_FNAME); 397d722cab4SKip Macy return (ENOENT); 398ac3a6d9cSKip Macy } else 399a9da6d23SNavdeep Parhar device_printf(sc->dev, "installing firmware on card\n"); 400b6d90eb7SKip Macy status = t3_load_fw(sc, (const uint8_t *)fw->data, fw->datasize); 401b6d90eb7SKip Macy 402a9da6d23SNavdeep Parhar if (status != 0) { 403a9da6d23SNavdeep Parhar device_printf(sc->dev, "failed to install firmware: %d\n", 404a9da6d23SNavdeep Parhar status); 405a9da6d23SNavdeep Parhar } else { 406a9da6d23SNavdeep Parhar t3_get_fw_version(sc, &vers); 407a9da6d23SNavdeep Parhar snprintf(&sc->fw_version[0], sizeof(sc->fw_version), "%d.%d.%d", 408a9da6d23SNavdeep Parhar G_FW_VERSION_MAJOR(vers), G_FW_VERSION_MINOR(vers), 409a9da6d23SNavdeep Parhar G_FW_VERSION_MICRO(vers)); 410a9da6d23SNavdeep Parhar } 411ac3a6d9cSKip Macy 412b6d90eb7SKip Macy firmware_put(fw, FIRMWARE_UNLOAD); 413b6d90eb7SKip Macy 414b6d90eb7SKip Macy return (status); 415b6d90eb7SKip Macy } 416b6d90eb7SKip Macy 4173cf138bbSGeorge V. Neville-Neil /* 4183cf138bbSGeorge V. Neville-Neil * The cxgb_controller_attach function is responsible for the initial 4193cf138bbSGeorge V. Neville-Neil * bringup of the device. Its responsibilities include: 4203cf138bbSGeorge V. Neville-Neil * 4213cf138bbSGeorge V. Neville-Neil * 1. Determine if the device supports MSI or MSI-X. 4223cf138bbSGeorge V. Neville-Neil * 2. Allocate bus resources so that we can access the Base Address Register 4233cf138bbSGeorge V. Neville-Neil * 3. Create and initialize mutexes for the controller and its control 4243cf138bbSGeorge V. Neville-Neil * logic such as SGE and MDIO. 4253cf138bbSGeorge V. Neville-Neil * 4. Call hardware specific setup routine for the adapter as a whole. 4263cf138bbSGeorge V. Neville-Neil * 5. Allocate the BAR for doing MSI-X. 4273cf138bbSGeorge V. Neville-Neil * 6. Setup the line interrupt iff MSI-X is not supported. 4283cf138bbSGeorge V. Neville-Neil * 7. Create the driver's taskq. 429c2009a4cSGeorge V. Neville-Neil * 8. Start one task queue service thread. 430c2009a4cSGeorge V. Neville-Neil * 9. Check if the firmware and SRAM are up-to-date. They will be 431c2009a4cSGeorge V. Neville-Neil * auto-updated later (before FULL_INIT_DONE), if required. 4323cf138bbSGeorge V. Neville-Neil * 10. Create a child device for each MAC (port) 4333cf138bbSGeorge V. Neville-Neil * 11. Initialize T3 private state. 4343cf138bbSGeorge V. Neville-Neil * 12. Trigger the LED 4353cf138bbSGeorge V. Neville-Neil * 13. Setup offload iff supported. 4363cf138bbSGeorge V. Neville-Neil * 14. Reset/restart the tick callout. 4373cf138bbSGeorge V. Neville-Neil * 15. Attach sysctls 4383cf138bbSGeorge V. Neville-Neil * 4393cf138bbSGeorge V. Neville-Neil * NOTE: Any modification or deviation from this list MUST be reflected in 4403cf138bbSGeorge V. Neville-Neil * the above comment. Failure to do so will result in problems on various 4413cf138bbSGeorge V. Neville-Neil * error conditions including link flapping. 4423cf138bbSGeorge V. Neville-Neil */ 443b6d90eb7SKip Macy static int 444b6d90eb7SKip Macy cxgb_controller_attach(device_t dev) 445b6d90eb7SKip Macy { 446b6d90eb7SKip Macy device_t child; 447b6d90eb7SKip Macy const struct adapter_info *ai; 448b6d90eb7SKip Macy struct adapter *sc; 4492de1fa86SKip Macy int i, error = 0; 450b6d90eb7SKip Macy uint32_t vers; 451693d746cSKip Macy int port_qsets = 1; 4522de1fa86SKip Macy int msi_needed, reg; 4535197f3abSGeorge V. Neville-Neil char buf[80]; 4545197f3abSGeorge V. Neville-Neil 455b6d90eb7SKip Macy sc = device_get_softc(dev); 456b6d90eb7SKip Macy sc->dev = dev; 457d722cab4SKip Macy sc->msi_count = 0; 4582de1fa86SKip Macy ai = cxgb_get_adapter_info(dev); 459b6d90eb7SKip Macy 460fc01c613SKip Macy /* find the PCIe link width and set max read request to 4KB*/ 461fc01c613SKip Macy if (pci_find_extcap(dev, PCIY_EXPRESS, ®) == 0) { 462b739a509SJohn Baldwin uint16_t lnk; 463fc01c613SKip Macy 464b739a509SJohn Baldwin lnk = pci_read_config(dev, reg + PCIR_EXPRESS_LINK_STA, 2); 465b739a509SJohn Baldwin sc->link_width = (lnk & PCIM_LINK_STA_WIDTH) >> 4; 466b739a509SJohn Baldwin if (sc->link_width < 8 && 467b739a509SJohn Baldwin (ai->caps & SUPPORTED_10000baseT_Full)) { 468fc01c613SKip Macy device_printf(sc->dev, 469ac6b4cf1SKip Macy "PCIe x%d Link, expect reduced performance\n", 470fc01c613SKip Macy sc->link_width); 471fc01c613SKip Macy } 472e83ec3e5SNavdeep Parhar 473b739a509SJohn Baldwin pci_set_max_read_req(dev, 4096); 474b739a509SJohn Baldwin } 475b739a509SJohn Baldwin 4767ac2e6c3SKip Macy touch_bars(dev); 477b6d90eb7SKip Macy pci_enable_busmaster(dev); 478b6d90eb7SKip Macy /* 479b6d90eb7SKip Macy * Allocate the registers and make them available to the driver. 480b6d90eb7SKip Macy * The registers that we care about for NIC mode are in BAR 0 481b6d90eb7SKip Macy */ 482b6d90eb7SKip Macy sc->regs_rid = PCIR_BAR(0); 483b6d90eb7SKip Macy if ((sc->regs_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, 484b6d90eb7SKip Macy &sc->regs_rid, RF_ACTIVE)) == NULL) { 4858e10660fSKip Macy device_printf(dev, "Cannot allocate BAR region 0\n"); 486b6d90eb7SKip Macy return (ENXIO); 487b6d90eb7SKip Macy } 4888e10660fSKip Macy sc->udbs_rid = PCIR_BAR(2); 4897f15419bSGeorge V. Neville-Neil sc->udbs_res = NULL; 4907f15419bSGeorge V. Neville-Neil if (is_offload(sc) && 4917f15419bSGeorge V. Neville-Neil ((sc->udbs_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, 4927f15419bSGeorge V. Neville-Neil &sc->udbs_rid, RF_ACTIVE)) == NULL)) { 4938e10660fSKip Macy device_printf(dev, "Cannot allocate BAR region 1\n"); 4948e10660fSKip Macy error = ENXIO; 4958e10660fSKip Macy goto out; 4968e10660fSKip Macy } 497b6d90eb7SKip Macy 498bb38cd2fSKip Macy snprintf(sc->lockbuf, ADAPTER_LOCK_NAME_LEN, "cxgb controller lock %d", 499bb38cd2fSKip Macy device_get_unit(dev)); 500bb38cd2fSKip Macy ADAPTER_LOCK_INIT(sc, sc->lockbuf); 501bb38cd2fSKip Macy 502bb38cd2fSKip Macy snprintf(sc->reglockbuf, ADAPTER_LOCK_NAME_LEN, "SGE reg lock %d", 503bb38cd2fSKip Macy device_get_unit(dev)); 504bb38cd2fSKip Macy snprintf(sc->mdiolockbuf, ADAPTER_LOCK_NAME_LEN, "cxgb mdio lock %d", 505bb38cd2fSKip Macy device_get_unit(dev)); 506bb38cd2fSKip Macy snprintf(sc->elmerlockbuf, ADAPTER_LOCK_NAME_LEN, "cxgb elmer lock %d", 507bb38cd2fSKip Macy device_get_unit(dev)); 508bb38cd2fSKip Macy 5098e10660fSKip Macy MTX_INIT(&sc->sge.reg_lock, sc->reglockbuf, NULL, MTX_SPIN); 510bb38cd2fSKip Macy MTX_INIT(&sc->mdio_lock, sc->mdiolockbuf, NULL, MTX_DEF); 511bb38cd2fSKip Macy MTX_INIT(&sc->elmer_lock, sc->elmerlockbuf, NULL, MTX_DEF); 512b6d90eb7SKip Macy 513b6d90eb7SKip Macy sc->bt = rman_get_bustag(sc->regs_res); 514b6d90eb7SKip Macy sc->bh = rman_get_bushandle(sc->regs_res); 515b6d90eb7SKip Macy sc->mmio_len = rman_get_size(sc->regs_res); 516b6d90eb7SKip Macy 517c01f2b83SNavdeep Parhar for (i = 0; i < MAX_NPORTS; i++) 518c01f2b83SNavdeep Parhar sc->port[i].adapter = sc; 519c01f2b83SNavdeep Parhar 52024cdd067SKip Macy if (t3_prep_adapter(sc, ai, 1) < 0) { 521ef72318fSKip Macy printf("prep adapter failed\n"); 52224cdd067SKip Macy error = ENODEV; 52324cdd067SKip Macy goto out; 52424cdd067SKip Macy } 525b6d90eb7SKip Macy /* Allocate the BAR for doing MSI-X. If it succeeds, try to allocate 526b6d90eb7SKip Macy * enough messages for the queue sets. If that fails, try falling 527b6d90eb7SKip Macy * back to MSI. If that fails, then try falling back to the legacy 528b6d90eb7SKip Macy * interrupt pin model. 529b6d90eb7SKip Macy */ 530b6d90eb7SKip Macy sc->msix_regs_rid = 0x20; 531b6d90eb7SKip Macy if ((msi_allowed >= 2) && 532b6d90eb7SKip Macy (sc->msix_regs_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, 533b6d90eb7SKip Macy &sc->msix_regs_rid, RF_ACTIVE)) != NULL) { 534b6d90eb7SKip Macy 535e3503bc9SGeorge V. Neville-Neil if (multiq) 536e3503bc9SGeorge V. Neville-Neil port_qsets = min(SGE_QSETS/sc->params.nports, mp_ncpus); 537e3503bc9SGeorge V. Neville-Neil msi_needed = sc->msi_count = sc->params.nports * port_qsets + 1; 538693d746cSKip Macy 539e3503bc9SGeorge V. Neville-Neil if (pci_msix_count(dev) == 0 || 540e3503bc9SGeorge V. Neville-Neil (error = pci_alloc_msix(dev, &sc->msi_count)) != 0 || 541e3503bc9SGeorge V. Neville-Neil sc->msi_count != msi_needed) { 542e3503bc9SGeorge V. Neville-Neil device_printf(dev, "alloc msix failed - " 543e3503bc9SGeorge V. Neville-Neil "msi_count=%d, msi_needed=%d, err=%d; " 544e3503bc9SGeorge V. Neville-Neil "will try MSI\n", sc->msi_count, 545d722cab4SKip Macy msi_needed, error); 546d722cab4SKip Macy sc->msi_count = 0; 547e3503bc9SGeorge V. Neville-Neil port_qsets = 1; 548b6d90eb7SKip Macy pci_release_msi(dev); 549b6d90eb7SKip Macy bus_release_resource(dev, SYS_RES_MEMORY, 550b6d90eb7SKip Macy sc->msix_regs_rid, sc->msix_regs_res); 551b6d90eb7SKip Macy sc->msix_regs_res = NULL; 552b6d90eb7SKip Macy } else { 553b6d90eb7SKip Macy sc->flags |= USING_MSIX; 554e3503bc9SGeorge V. Neville-Neil sc->cxgb_intr = cxgb_async_intr; 555e3503bc9SGeorge V. Neville-Neil device_printf(dev, 556e3503bc9SGeorge V. Neville-Neil "using MSI-X interrupts (%u vectors)\n", 557e3503bc9SGeorge V. Neville-Neil sc->msi_count); 558b6d90eb7SKip Macy } 559b6d90eb7SKip Macy } 560b6d90eb7SKip Macy 561d722cab4SKip Macy if ((msi_allowed >= 1) && (sc->msi_count == 0)) { 562d722cab4SKip Macy sc->msi_count = 1; 563e3503bc9SGeorge V. Neville-Neil if ((error = pci_alloc_msi(dev, &sc->msi_count)) != 0) { 564e3503bc9SGeorge V. Neville-Neil device_printf(dev, "alloc msi failed - " 565e3503bc9SGeorge V. Neville-Neil "err=%d; will try INTx\n", error); 566d722cab4SKip Macy sc->msi_count = 0; 567e3503bc9SGeorge V. Neville-Neil port_qsets = 1; 568b6d90eb7SKip Macy pci_release_msi(dev); 569b6d90eb7SKip Macy } else { 570b6d90eb7SKip Macy sc->flags |= USING_MSI; 571f0a542f8SKip Macy sc->cxgb_intr = t3_intr_msi; 572e3503bc9SGeorge V. Neville-Neil device_printf(dev, "using MSI interrupts\n"); 573b6d90eb7SKip Macy } 574b6d90eb7SKip Macy } 575d722cab4SKip Macy if (sc->msi_count == 0) { 576693d746cSKip Macy device_printf(dev, "using line interrupts\n"); 577f0a542f8SKip Macy sc->cxgb_intr = t3b_intr; 578b6d90eb7SKip Macy } 579b6d90eb7SKip Macy 580b6d90eb7SKip Macy /* Create a private taskqueue thread for handling driver events */ 581b6d90eb7SKip Macy sc->tq = taskqueue_create("cxgb_taskq", M_NOWAIT, 582b6d90eb7SKip Macy taskqueue_thread_enqueue, &sc->tq); 583b6d90eb7SKip Macy if (sc->tq == NULL) { 584b6d90eb7SKip Macy device_printf(dev, "failed to allocate controller task queue\n"); 585b6d90eb7SKip Macy goto out; 586b6d90eb7SKip Macy } 587b6d90eb7SKip Macy 588b6d90eb7SKip Macy taskqueue_start_threads(&sc->tq, 1, PI_NET, "%s taskq", 589b6d90eb7SKip Macy device_get_nameunit(dev)); 590bb38cd2fSKip Macy TASK_INIT(&sc->tick_task, 0, cxgb_tick_handler, sc); 591b6d90eb7SKip Macy 592b6d90eb7SKip Macy 593b6d90eb7SKip Macy /* Create a periodic callout for checking adapter status */ 594bb38cd2fSKip Macy callout_init(&sc->cxgb_tick_ch, TRUE); 595b6d90eb7SKip Macy 596f2d8ff04SGeorge V. Neville-Neil if (t3_check_fw_version(sc) < 0 || force_fw_update) { 597b6d90eb7SKip Macy /* 598b6d90eb7SKip Macy * Warn user that a firmware update will be attempted in init. 599b6d90eb7SKip Macy */ 600d722cab4SKip Macy device_printf(dev, "firmware needs to be updated to version %d.%d.%d\n", 601d722cab4SKip Macy FW_VERSION_MAJOR, FW_VERSION_MINOR, FW_VERSION_MICRO); 602b6d90eb7SKip Macy sc->flags &= ~FW_UPTODATE; 603b6d90eb7SKip Macy } else { 604b6d90eb7SKip Macy sc->flags |= FW_UPTODATE; 605b6d90eb7SKip Macy } 606b6d90eb7SKip Macy 607f2d8ff04SGeorge V. Neville-Neil if (t3_check_tpsram_version(sc) < 0) { 608ac3a6d9cSKip Macy /* 609ac3a6d9cSKip Macy * Warn user that a firmware update will be attempted in init. 610ac3a6d9cSKip Macy */ 611ac3a6d9cSKip Macy device_printf(dev, "SRAM needs to be updated to version %c-%d.%d.%d\n", 612ac3a6d9cSKip Macy t3rev2char(sc), TP_VERSION_MAJOR, TP_VERSION_MINOR, TP_VERSION_MICRO); 613ac3a6d9cSKip Macy sc->flags &= ~TPS_UPTODATE; 614ac3a6d9cSKip Macy } else { 615ac3a6d9cSKip Macy sc->flags |= TPS_UPTODATE; 616ac3a6d9cSKip Macy } 617ac3a6d9cSKip Macy 618b6d90eb7SKip Macy /* 619b6d90eb7SKip Macy * Create a child device for each MAC. The ethernet attachment 620b6d90eb7SKip Macy * will be done in these children. 621b6d90eb7SKip Macy */ 622693d746cSKip Macy for (i = 0; i < (sc)->params.nports; i++) { 6237ac2e6c3SKip Macy struct port_info *pi; 6247ac2e6c3SKip Macy 625b6d90eb7SKip Macy if ((child = device_add_child(dev, "cxgb", -1)) == NULL) { 626b6d90eb7SKip Macy device_printf(dev, "failed to add child port\n"); 627b6d90eb7SKip Macy error = EINVAL; 628b6d90eb7SKip Macy goto out; 629b6d90eb7SKip Macy } 6307ac2e6c3SKip Macy pi = &sc->port[i]; 6317ac2e6c3SKip Macy pi->adapter = sc; 6327ac2e6c3SKip Macy pi->nqsets = port_qsets; 6337ac2e6c3SKip Macy pi->first_qset = i*port_qsets; 6347ac2e6c3SKip Macy pi->port_id = i; 6357ac2e6c3SKip Macy pi->tx_chan = i >= ai->nports0; 6367ac2e6c3SKip Macy pi->txpkt_intf = pi->tx_chan ? 2 * (i - ai->nports0) + 1 : 2 * i; 6377ac2e6c3SKip Macy sc->rxpkt_map[pi->txpkt_intf] = i; 6388090c9f5SKip Macy sc->port[i].tx_chan = i >= ai->nports0; 639ac3a6d9cSKip Macy sc->portdev[i] = child; 6407ac2e6c3SKip Macy device_set_softc(child, pi); 641b6d90eb7SKip Macy } 642b6d90eb7SKip Macy if ((error = bus_generic_attach(dev)) != 0) 643b6d90eb7SKip Macy goto out; 644b6d90eb7SKip Macy 645b6d90eb7SKip Macy /* initialize sge private state */ 646ef72318fSKip Macy t3_sge_init_adapter(sc); 647b6d90eb7SKip Macy 648b6d90eb7SKip Macy t3_led_ready(sc); 649b6d90eb7SKip Macy 650d722cab4SKip Macy cxgb_offload_init(); 651d722cab4SKip Macy if (is_offload(sc)) { 652d722cab4SKip Macy setbit(&sc->registered_device_map, OFFLOAD_DEVMAP_BIT); 653d722cab4SKip Macy cxgb_adapter_ofld(sc); 654d722cab4SKip Macy } 655b6d90eb7SKip Macy error = t3_get_fw_version(sc, &vers); 656b6d90eb7SKip Macy if (error) 657b6d90eb7SKip Macy goto out; 658b6d90eb7SKip Macy 659d722cab4SKip Macy snprintf(&sc->fw_version[0], sizeof(sc->fw_version), "%d.%d.%d", 660d722cab4SKip Macy G_FW_VERSION_MAJOR(vers), G_FW_VERSION_MINOR(vers), 661d722cab4SKip Macy G_FW_VERSION_MICRO(vers)); 662b6d90eb7SKip Macy 6637ead19d4SNavdeep Parhar snprintf(buf, sizeof(buf), "%s %sNIC\t E/C: %s S/N: %s", 6647ead19d4SNavdeep Parhar ai->desc, is_offload(sc) ? "R" : "", 6655197f3abSGeorge V. Neville-Neil sc->params.vpd.ec, sc->params.vpd.sn); 6665197f3abSGeorge V. Neville-Neil device_set_desc_copy(dev, buf); 6675197f3abSGeorge V. Neville-Neil 6680bbdea77SGeorge V. Neville-Neil snprintf(&sc->port_types[0], sizeof(sc->port_types), "%x%x%x%x", 6690bbdea77SGeorge V. Neville-Neil sc->params.vpd.port_type[0], sc->params.vpd.port_type[1], 6700bbdea77SGeorge V. Neville-Neil sc->params.vpd.port_type[2], sc->params.vpd.port_type[3]); 6710bbdea77SGeorge V. Neville-Neil 6728e10660fSKip Macy device_printf(sc->dev, "Firmware Version %s\n", &sc->fw_version[0]); 673bd1a9fbaSNavdeep Parhar callout_reset(&sc->cxgb_tick_ch, hz, cxgb_tick, sc); 6748090c9f5SKip Macy t3_add_attach_sysctls(sc); 675b6d90eb7SKip Macy out: 676b6d90eb7SKip Macy if (error) 677b6d90eb7SKip Macy cxgb_free(sc); 678b6d90eb7SKip Macy 679b6d90eb7SKip Macy return (error); 680b6d90eb7SKip Macy } 681b6d90eb7SKip Macy 6823cf138bbSGeorge V. Neville-Neil /* 683c2009a4cSGeorge V. Neville-Neil * The cxgb_controller_detach routine is called with the device is 6843cf138bbSGeorge V. Neville-Neil * unloaded from the system. 6853cf138bbSGeorge V. Neville-Neil */ 6863cf138bbSGeorge V. Neville-Neil 687b6d90eb7SKip Macy static int 688b6d90eb7SKip Macy cxgb_controller_detach(device_t dev) 689b6d90eb7SKip Macy { 690b6d90eb7SKip Macy struct adapter *sc; 691b6d90eb7SKip Macy 692b6d90eb7SKip Macy sc = device_get_softc(dev); 693b6d90eb7SKip Macy 694b6d90eb7SKip Macy cxgb_free(sc); 695b6d90eb7SKip Macy 696b6d90eb7SKip Macy return (0); 697b6d90eb7SKip Macy } 698b6d90eb7SKip Macy 6993cf138bbSGeorge V. Neville-Neil /* 7003cf138bbSGeorge V. Neville-Neil * The cxgb_free() is called by the cxgb_controller_detach() routine 7013cf138bbSGeorge V. Neville-Neil * to tear down the structures that were built up in 7023cf138bbSGeorge V. Neville-Neil * cxgb_controller_attach(), and should be the final piece of work 703c2009a4cSGeorge V. Neville-Neil * done when fully unloading the driver. 7043cf138bbSGeorge V. Neville-Neil * 7053cf138bbSGeorge V. Neville-Neil * 7063cf138bbSGeorge V. Neville-Neil * 1. Shutting down the threads started by the cxgb_controller_attach() 7073cf138bbSGeorge V. Neville-Neil * routine. 7083cf138bbSGeorge V. Neville-Neil * 2. Stopping the lower level device and all callouts (cxgb_down_locked()). 7093cf138bbSGeorge V. Neville-Neil * 3. Detaching all of the port devices created during the 7103cf138bbSGeorge V. Neville-Neil * cxgb_controller_attach() routine. 7113cf138bbSGeorge V. Neville-Neil * 4. Removing the device children created via cxgb_controller_attach(). 712e3503bc9SGeorge V. Neville-Neil * 5. Releasing PCI resources associated with the device. 7133cf138bbSGeorge V. Neville-Neil * 6. Turning off the offload support, iff it was turned on. 7143cf138bbSGeorge V. Neville-Neil * 7. Destroying the mutexes created in cxgb_controller_attach(). 7153cf138bbSGeorge V. Neville-Neil * 7163cf138bbSGeorge V. Neville-Neil */ 717b6d90eb7SKip Macy static void 718b6d90eb7SKip Macy cxgb_free(struct adapter *sc) 719b6d90eb7SKip Macy { 720b6d90eb7SKip Macy int i; 721b6d90eb7SKip Macy 7228e10660fSKip Macy ADAPTER_LOCK(sc); 7238e10660fSKip Macy sc->flags |= CXGB_SHUTDOWN; 7248e10660fSKip Macy ADAPTER_UNLOCK(sc); 7258e10660fSKip Macy 7263cf138bbSGeorge V. Neville-Neil /* 7273f345a5dSKip Macy * Make sure all child devices are gone. 7283cf138bbSGeorge V. Neville-Neil */ 7293cf138bbSGeorge V. Neville-Neil bus_generic_detach(sc->dev); 7303cf138bbSGeorge V. Neville-Neil for (i = 0; i < (sc)->params.nports; i++) { 731c2009a4cSGeorge V. Neville-Neil if (sc->portdev[i] && 732c2009a4cSGeorge V. Neville-Neil device_delete_child(sc->dev, sc->portdev[i]) != 0) 7333cf138bbSGeorge V. Neville-Neil device_printf(sc->dev, "failed to delete child port\n"); 7343cf138bbSGeorge V. Neville-Neil } 735d722cab4SKip Macy 7363f345a5dSKip Macy /* 7373f345a5dSKip Macy * At this point, it is as if cxgb_port_detach has run on all ports, and 7383f345a5dSKip Macy * cxgb_down has run on the adapter. All interrupts have been silenced, 7393f345a5dSKip Macy * all open devices have been closed. 7403f345a5dSKip Macy */ 7413f345a5dSKip Macy KASSERT(sc->open_device_map == 0, ("%s: device(s) still open (%x)", 7423f345a5dSKip Macy __func__, sc->open_device_map)); 7433f345a5dSKip Macy for (i = 0; i < sc->params.nports; i++) { 7443f345a5dSKip Macy KASSERT(sc->port[i].ifp == NULL, ("%s: port %i undead!", 7453f345a5dSKip Macy __func__, i)); 7463f345a5dSKip Macy } 747e3503bc9SGeorge V. Neville-Neil 7483f345a5dSKip Macy /* 7493f345a5dSKip Macy * Finish off the adapter's callouts. 7503f345a5dSKip Macy */ 7513f345a5dSKip Macy callout_drain(&sc->cxgb_tick_ch); 7523f345a5dSKip Macy callout_drain(&sc->sge_timer_ch); 7533f345a5dSKip Macy 7543f345a5dSKip Macy /* 7553f345a5dSKip Macy * Release resources grabbed under FULL_INIT_DONE by cxgb_up. The 7563f345a5dSKip Macy * sysctls are cleaned up by the kernel linker. 7573f345a5dSKip Macy */ 7583f345a5dSKip Macy if (sc->flags & FULL_INIT_DONE) { 7593f345a5dSKip Macy t3_free_sge_resources(sc); 7603f345a5dSKip Macy sc->flags &= ~FULL_INIT_DONE; 7613f345a5dSKip Macy } 7623f345a5dSKip Macy 7633f345a5dSKip Macy /* 7643f345a5dSKip Macy * Release all interrupt resources. 7653f345a5dSKip Macy */ 7663f345a5dSKip Macy cxgb_teardown_interrupts(sc); 767d722cab4SKip Macy if (sc->flags & (USING_MSI | USING_MSIX)) { 768d722cab4SKip Macy device_printf(sc->dev, "releasing msi message(s)\n"); 769d722cab4SKip Macy pci_release_msi(sc->dev); 770d722cab4SKip Macy } else { 771d722cab4SKip Macy device_printf(sc->dev, "no msi message to release\n"); 772d722cab4SKip Macy } 773e3503bc9SGeorge V. Neville-Neil 774d722cab4SKip Macy if (sc->msix_regs_res != NULL) { 775d722cab4SKip Macy bus_release_resource(sc->dev, SYS_RES_MEMORY, sc->msix_regs_rid, 776d722cab4SKip Macy sc->msix_regs_res); 777d722cab4SKip Macy } 778d722cab4SKip Macy 7793f345a5dSKip Macy /* 7803f345a5dSKip Macy * Free the adapter's taskqueue. 7813f345a5dSKip Macy */ 7828e10660fSKip Macy if (sc->tq != NULL) { 7837ac2e6c3SKip Macy taskqueue_free(sc->tq); 7848e10660fSKip Macy sc->tq = NULL; 7858e10660fSKip Macy } 7868e10660fSKip Macy 787d722cab4SKip Macy if (is_offload(sc)) { 7883f345a5dSKip Macy clrbit(&sc->registered_device_map, OFFLOAD_DEVMAP_BIT); 789d722cab4SKip Macy cxgb_adapter_unofld(sc); 7903f345a5dSKip Macy } 7913f345a5dSKip Macy 79246b0a854SKip Macy #ifdef notyet 7938e10660fSKip Macy if (sc->flags & CXGB_OFLD_INIT) 7948e10660fSKip Macy cxgb_offload_deactivate(sc); 79546b0a854SKip Macy #endif 796ac3a6d9cSKip Macy free(sc->filters, M_DEVBUF); 797b6d90eb7SKip Macy t3_sge_free(sc); 798b6d90eb7SKip Macy 799bb38cd2fSKip Macy cxgb_offload_exit(); 800bb38cd2fSKip Macy 8018e10660fSKip Macy if (sc->udbs_res != NULL) 8028e10660fSKip Macy bus_release_resource(sc->dev, SYS_RES_MEMORY, sc->udbs_rid, 8038e10660fSKip Macy sc->udbs_res); 8048e10660fSKip Macy 805b6d90eb7SKip Macy if (sc->regs_res != NULL) 806b6d90eb7SKip Macy bus_release_resource(sc->dev, SYS_RES_MEMORY, sc->regs_rid, 807b6d90eb7SKip Macy sc->regs_res); 808b6d90eb7SKip Macy 809bb38cd2fSKip Macy MTX_DESTROY(&sc->mdio_lock); 810bb38cd2fSKip Macy MTX_DESTROY(&sc->sge.reg_lock); 811bb38cd2fSKip Macy MTX_DESTROY(&sc->elmer_lock); 812bb38cd2fSKip Macy ADAPTER_LOCK_DEINIT(sc); 813b6d90eb7SKip Macy } 814b6d90eb7SKip Macy 815b6d90eb7SKip Macy /** 816b6d90eb7SKip Macy * setup_sge_qsets - configure SGE Tx/Rx/response queues 817b6d90eb7SKip Macy * @sc: the controller softc 818b6d90eb7SKip Macy * 819b6d90eb7SKip Macy * Determines how many sets of SGE queues to use and initializes them. 820b6d90eb7SKip Macy * We support multiple queue sets per port if we have MSI-X, otherwise 821b6d90eb7SKip Macy * just one queue set per port. 822b6d90eb7SKip Macy */ 823b6d90eb7SKip Macy static int 824b6d90eb7SKip Macy setup_sge_qsets(adapter_t *sc) 825b6d90eb7SKip Macy { 8265c5df3daSKip Macy int i, j, err, irq_idx = 0, qset_idx = 0; 827d722cab4SKip Macy u_int ntxq = SGE_TXQ_PER_SET; 828b6d90eb7SKip Macy 829b6d90eb7SKip Macy if ((err = t3_sge_alloc(sc)) != 0) { 830693d746cSKip Macy device_printf(sc->dev, "t3_sge_alloc returned %d\n", err); 831b6d90eb7SKip Macy return (err); 832b6d90eb7SKip Macy } 833b6d90eb7SKip Macy 834b6d90eb7SKip Macy if (sc->params.rev > 0 && !(sc->flags & USING_MSI)) 835b6d90eb7SKip Macy irq_idx = -1; 836b6d90eb7SKip Macy 8375c5df3daSKip Macy for (i = 0; i < (sc)->params.nports; i++) { 838b6d90eb7SKip Macy struct port_info *pi = &sc->port[i]; 839b6d90eb7SKip Macy 8407ac2e6c3SKip Macy for (j = 0; j < pi->nqsets; j++, qset_idx++) { 841693d746cSKip Macy err = t3_sge_alloc_qset(sc, qset_idx, (sc)->params.nports, 842b6d90eb7SKip Macy (sc->flags & USING_MSIX) ? qset_idx + 1 : irq_idx, 843b6d90eb7SKip Macy &sc->params.sge.qset[qset_idx], ntxq, pi); 844b6d90eb7SKip Macy if (err) { 845b6d90eb7SKip Macy t3_free_sge_resources(sc); 8467ac2e6c3SKip Macy device_printf(sc->dev, "t3_sge_alloc_qset failed with %d\n", 8477ac2e6c3SKip Macy err); 848b6d90eb7SKip Macy return (err); 849b6d90eb7SKip Macy } 850b6d90eb7SKip Macy } 851b6d90eb7SKip Macy } 852b6d90eb7SKip Macy 853b6d90eb7SKip Macy return (0); 854b6d90eb7SKip Macy } 855b6d90eb7SKip Macy 856ef72318fSKip Macy static void 857e3503bc9SGeorge V. Neville-Neil cxgb_teardown_interrupts(adapter_t *sc) 858ef72318fSKip Macy { 859e3503bc9SGeorge V. Neville-Neil int i; 860ef72318fSKip Macy 861e3503bc9SGeorge V. Neville-Neil for (i = 0; i < SGE_QSETS; i++) { 862e3503bc9SGeorge V. Neville-Neil if (sc->msix_intr_tag[i] == NULL) { 863ef72318fSKip Macy 864e3503bc9SGeorge V. Neville-Neil /* Should have been setup fully or not at all */ 865e3503bc9SGeorge V. Neville-Neil KASSERT(sc->msix_irq_res[i] == NULL && 866e3503bc9SGeorge V. Neville-Neil sc->msix_irq_rid[i] == 0, 867e3503bc9SGeorge V. Neville-Neil ("%s: half-done interrupt (%d).", __func__, i)); 868e3503bc9SGeorge V. Neville-Neil 869e3503bc9SGeorge V. Neville-Neil continue; 870e3503bc9SGeorge V. Neville-Neil } 871e3503bc9SGeorge V. Neville-Neil 872ef72318fSKip Macy bus_teardown_intr(sc->dev, sc->msix_irq_res[i], 873ef72318fSKip Macy sc->msix_intr_tag[i]); 874e3503bc9SGeorge V. Neville-Neil bus_release_resource(sc->dev, SYS_RES_IRQ, sc->msix_irq_rid[i], 875e3503bc9SGeorge V. Neville-Neil sc->msix_irq_res[i]); 876e3503bc9SGeorge V. Neville-Neil 877e3503bc9SGeorge V. Neville-Neil sc->msix_irq_res[i] = sc->msix_intr_tag[i] = NULL; 878e3503bc9SGeorge V. Neville-Neil sc->msix_irq_rid[i] = 0; 879ef72318fSKip Macy } 880e3503bc9SGeorge V. Neville-Neil 881e3503bc9SGeorge V. Neville-Neil if (sc->intr_tag) { 882e3503bc9SGeorge V. Neville-Neil KASSERT(sc->irq_res != NULL, 883e3503bc9SGeorge V. Neville-Neil ("%s: half-done interrupt.", __func__)); 884e3503bc9SGeorge V. Neville-Neil 885e3503bc9SGeorge V. Neville-Neil bus_teardown_intr(sc->dev, sc->irq_res, sc->intr_tag); 886e3503bc9SGeorge V. Neville-Neil bus_release_resource(sc->dev, SYS_RES_IRQ, sc->irq_rid, 887e3503bc9SGeorge V. Neville-Neil sc->irq_res); 888e3503bc9SGeorge V. Neville-Neil 889e3503bc9SGeorge V. Neville-Neil sc->irq_res = sc->intr_tag = NULL; 890e3503bc9SGeorge V. Neville-Neil sc->irq_rid = 0; 891ef72318fSKip Macy } 892ef72318fSKip Macy } 893ef72318fSKip Macy 894b6d90eb7SKip Macy static int 895e3503bc9SGeorge V. Neville-Neil cxgb_setup_interrupts(adapter_t *sc) 896b6d90eb7SKip Macy { 897e3503bc9SGeorge V. Neville-Neil struct resource *res; 898e3503bc9SGeorge V. Neville-Neil void *tag; 899e3503bc9SGeorge V. Neville-Neil int i, rid, err, intr_flag = sc->flags & (USING_MSI | USING_MSIX); 900b6d90eb7SKip Macy 901e3503bc9SGeorge V. Neville-Neil sc->irq_rid = intr_flag ? 1 : 0; 902e3503bc9SGeorge V. Neville-Neil sc->irq_res = bus_alloc_resource_any(sc->dev, SYS_RES_IRQ, &sc->irq_rid, 903e3503bc9SGeorge V. Neville-Neil RF_SHAREABLE | RF_ACTIVE); 904e3503bc9SGeorge V. Neville-Neil if (sc->irq_res == NULL) { 905e3503bc9SGeorge V. Neville-Neil device_printf(sc->dev, "Cannot allocate interrupt (%x, %u)\n", 906e3503bc9SGeorge V. Neville-Neil intr_flag, sc->irq_rid); 907e3503bc9SGeorge V. Neville-Neil err = EINVAL; 908e3503bc9SGeorge V. Neville-Neil sc->irq_rid = 0; 909e3503bc9SGeorge V. Neville-Neil } else { 910e3503bc9SGeorge V. Neville-Neil err = bus_setup_intr(sc->dev, sc->irq_res, 911e83ec3e5SNavdeep Parhar INTR_MPSAFE | INTR_TYPE_NET, NULL, 912e3503bc9SGeorge V. Neville-Neil sc->cxgb_intr, sc, &sc->intr_tag); 913a02573bcSKip Macy 914e3503bc9SGeorge V. Neville-Neil if (err) { 915e3503bc9SGeorge V. Neville-Neil device_printf(sc->dev, 916e3503bc9SGeorge V. Neville-Neil "Cannot set up interrupt (%x, %u, %d)\n", 917e3503bc9SGeorge V. Neville-Neil intr_flag, sc->irq_rid, err); 918e3503bc9SGeorge V. Neville-Neil bus_release_resource(sc->dev, SYS_RES_IRQ, sc->irq_rid, 919e3503bc9SGeorge V. Neville-Neil sc->irq_res); 920e3503bc9SGeorge V. Neville-Neil sc->irq_res = sc->intr_tag = NULL; 921e3503bc9SGeorge V. Neville-Neil sc->irq_rid = 0; 922b6d90eb7SKip Macy } 923b6d90eb7SKip Macy } 924693d746cSKip Macy 925e3503bc9SGeorge V. Neville-Neil /* That's all for INTx or MSI */ 926e3503bc9SGeorge V. Neville-Neil if (!(intr_flag & USING_MSIX) || err) 927e3503bc9SGeorge V. Neville-Neil return (err); 928e3503bc9SGeorge V. Neville-Neil 929e3503bc9SGeorge V. Neville-Neil for (i = 0; i < sc->msi_count - 1; i++) { 930e3503bc9SGeorge V. Neville-Neil rid = i + 2; 931e3503bc9SGeorge V. Neville-Neil res = bus_alloc_resource_any(sc->dev, SYS_RES_IRQ, &rid, 932e3503bc9SGeorge V. Neville-Neil RF_SHAREABLE | RF_ACTIVE); 933e3503bc9SGeorge V. Neville-Neil if (res == NULL) { 934e3503bc9SGeorge V. Neville-Neil device_printf(sc->dev, "Cannot allocate interrupt " 935e3503bc9SGeorge V. Neville-Neil "for message %d\n", rid); 936e3503bc9SGeorge V. Neville-Neil err = EINVAL; 937e3503bc9SGeorge V. Neville-Neil break; 938b6d90eb7SKip Macy } 939b6d90eb7SKip Macy 940e3503bc9SGeorge V. Neville-Neil err = bus_setup_intr(sc->dev, res, INTR_MPSAFE | INTR_TYPE_NET, 941e83ec3e5SNavdeep Parhar NULL, t3_intr_msix, &sc->sge.qs[i], &tag); 942e3503bc9SGeorge V. Neville-Neil if (err) { 943e3503bc9SGeorge V. Neville-Neil device_printf(sc->dev, "Cannot set up interrupt " 944e3503bc9SGeorge V. Neville-Neil "for message %d (%d)\n", rid, err); 945e3503bc9SGeorge V. Neville-Neil bus_release_resource(sc->dev, SYS_RES_IRQ, rid, res); 946e3503bc9SGeorge V. Neville-Neil break; 947e3503bc9SGeorge V. Neville-Neil } 948e3503bc9SGeorge V. Neville-Neil 949e3503bc9SGeorge V. Neville-Neil sc->msix_irq_rid[i] = rid; 950e3503bc9SGeorge V. Neville-Neil sc->msix_irq_res[i] = res; 951e3503bc9SGeorge V. Neville-Neil sc->msix_intr_tag[i] = tag; 952e3503bc9SGeorge V. Neville-Neil } 953e3503bc9SGeorge V. Neville-Neil 954e3503bc9SGeorge V. Neville-Neil if (err) 955e3503bc9SGeorge V. Neville-Neil cxgb_teardown_interrupts(sc); 956e3503bc9SGeorge V. Neville-Neil 957e3503bc9SGeorge V. Neville-Neil return (err); 958e3503bc9SGeorge V. Neville-Neil } 959e3503bc9SGeorge V. Neville-Neil 960e3503bc9SGeorge V. Neville-Neil 961b6d90eb7SKip Macy static int 962b6d90eb7SKip Macy cxgb_port_probe(device_t dev) 963b6d90eb7SKip Macy { 964b6d90eb7SKip Macy struct port_info *p; 965b6d90eb7SKip Macy char buf[80]; 9668e10660fSKip Macy const char *desc; 967b6d90eb7SKip Macy 968b6d90eb7SKip Macy p = device_get_softc(dev); 9698e10660fSKip Macy desc = p->phy.desc; 9708e10660fSKip Macy snprintf(buf, sizeof(buf), "Port %d %s", p->port_id, desc); 971b6d90eb7SKip Macy device_set_desc_copy(dev, buf); 972b6d90eb7SKip Macy return (0); 973b6d90eb7SKip Macy } 974b6d90eb7SKip Macy 975b6d90eb7SKip Macy 976b6d90eb7SKip Macy static int 977b6d90eb7SKip Macy cxgb_makedev(struct port_info *pi) 978b6d90eb7SKip Macy { 979b6d90eb7SKip Macy 980ef72318fSKip Macy pi->port_cdev = make_dev(&cxgb_cdevsw, pi->ifp->if_dunit, 98106eace63SNavdeep Parhar UID_ROOT, GID_WHEEL, 0600, "%s", if_name(pi->ifp)); 982b6d90eb7SKip Macy 983b6d90eb7SKip Macy if (pi->port_cdev == NULL) 984b6d90eb7SKip Macy return (ENOMEM); 985b6d90eb7SKip Macy 986b6d90eb7SKip Macy pi->port_cdev->si_drv1 = (void *)pi; 987b6d90eb7SKip Macy 988b6d90eb7SKip Macy return (0); 989b6d90eb7SKip Macy } 990b6d90eb7SKip Macy 991e83ec3e5SNavdeep Parhar #define CXGB_CAP (IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU | IFCAP_HWCSUM | \ 992f9c6e164SNavdeep Parhar IFCAP_VLAN_HWCSUM | IFCAP_TSO | IFCAP_JUMBO_MTU | IFCAP_LRO | \ 9932caefebbSNavdeep Parhar IFCAP_VLAN_HWTSO | IFCAP_LINKSTATE) 994e83ec3e5SNavdeep Parhar #define CXGB_CAP_ENABLE (CXGB_CAP & ~IFCAP_TSO6) 995b6d90eb7SKip Macy 996b6d90eb7SKip Macy static int 997b6d90eb7SKip Macy cxgb_port_attach(device_t dev) 998b6d90eb7SKip Macy { 999b6d90eb7SKip Macy struct port_info *p; 1000b6d90eb7SKip Macy struct ifnet *ifp; 10012975f787SNavdeep Parhar int err; 10028e10660fSKip Macy struct adapter *sc; 10038e10660fSKip Macy 1004b6d90eb7SKip Macy p = device_get_softc(dev); 10058e10660fSKip Macy sc = p->adapter; 1006bb38cd2fSKip Macy snprintf(p->lockbuf, PORT_NAME_LEN, "cxgb port lock %d:%d", 10076b68e276SKip Macy device_get_unit(device_get_parent(dev)), p->port_id); 1008bb38cd2fSKip Macy PORT_LOCK_INIT(p, p->lockbuf); 1009b6d90eb7SKip Macy 1010bd1a9fbaSNavdeep Parhar callout_init(&p->link_check_ch, CALLOUT_MPSAFE); 1011bd1a9fbaSNavdeep Parhar TASK_INIT(&p->link_check_task, 0, check_link_status, p); 1012bd1a9fbaSNavdeep Parhar 1013b6d90eb7SKip Macy /* Allocate an ifnet object and set it up */ 1014b6d90eb7SKip Macy ifp = p->ifp = if_alloc(IFT_ETHER); 1015b6d90eb7SKip Macy if (ifp == NULL) { 1016b6d90eb7SKip Macy device_printf(dev, "Cannot allocate ifnet\n"); 1017b6d90eb7SKip Macy return (ENOMEM); 1018b6d90eb7SKip Macy } 1019b6d90eb7SKip Macy 1020b6d90eb7SKip Macy if_initname(ifp, device_get_name(dev), device_get_unit(dev)); 1021b6d90eb7SKip Macy ifp->if_init = cxgb_init; 1022b6d90eb7SKip Macy ifp->if_softc = p; 1023b6d90eb7SKip Macy ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1024b6d90eb7SKip Macy ifp->if_ioctl = cxgb_ioctl; 1025b6d90eb7SKip Macy ifp->if_start = cxgb_start; 10268090c9f5SKip Macy 1027e50d35e6SMaxim Sobolev ifp->if_snd.ifq_drv_maxlen = max(cxgb_snd_queue_len, ifqmaxlen); 1028b6d90eb7SKip Macy IFQ_SET_MAXLEN(&ifp->if_snd, ifp->if_snd.ifq_drv_maxlen); 1029b6d90eb7SKip Macy IFQ_SET_READY(&ifp->if_snd); 1030b6d90eb7SKip Macy 1031e83ec3e5SNavdeep Parhar ifp->if_capabilities = CXGB_CAP; 1032e83ec3e5SNavdeep Parhar ifp->if_capenable = CXGB_CAP_ENABLE; 1033e83ec3e5SNavdeep Parhar ifp->if_hwassist = CSUM_TCP | CSUM_UDP | CSUM_IP | CSUM_TSO; 1034e83ec3e5SNavdeep Parhar 1035ac3a6d9cSKip Macy /* 1036e83ec3e5SNavdeep Parhar * Disable TSO on 4-port - it isn't supported by the firmware. 1037ac3a6d9cSKip Macy */ 1038e83ec3e5SNavdeep Parhar if (sc->params.nports > 2) { 1039f9c6e164SNavdeep Parhar ifp->if_capabilities &= ~(IFCAP_TSO | IFCAP_VLAN_HWTSO); 1040f9c6e164SNavdeep Parhar ifp->if_capenable &= ~(IFCAP_TSO | IFCAP_VLAN_HWTSO); 1041ac3a6d9cSKip Macy ifp->if_hwassist &= ~CSUM_TSO; 1042ac3a6d9cSKip Macy } 1043b6d90eb7SKip Macy 1044b6d90eb7SKip Macy ether_ifattach(ifp, p->hw_addr); 10453f345a5dSKip Macy ifp->if_transmit = cxgb_transmit; 10463f345a5dSKip Macy ifp->if_qflush = cxgb_qflush; 10473cf138bbSGeorge V. Neville-Neil 1048e83ec3e5SNavdeep Parhar #ifdef DEFAULT_JUMBO 1049e83ec3e5SNavdeep Parhar if (sc->params.nports <= 2) 10504af83c8cSKip Macy ifp->if_mtu = ETHERMTU_JUMBO; 1051e83ec3e5SNavdeep Parhar #endif 1052b6d90eb7SKip Macy if ((err = cxgb_makedev(p)) != 0) { 1053b6d90eb7SKip Macy printf("makedev failed %d\n", err); 1054b6d90eb7SKip Macy return (err); 1055b6d90eb7SKip Macy } 10562975f787SNavdeep Parhar 10572975f787SNavdeep Parhar /* Create a list of media supported by this port */ 1058b6d90eb7SKip Macy ifmedia_init(&p->media, IFM_IMASK, cxgb_media_change, 1059b6d90eb7SKip Macy cxgb_media_status); 10602975f787SNavdeep Parhar cxgb_build_medialist(p); 1061ef72318fSKip Macy 1062ef72318fSKip Macy t3_sge_init_port(p); 1063f2d8ff04SGeorge V. Neville-Neil 10643cf138bbSGeorge V. Neville-Neil return (err); 1065b6d90eb7SKip Macy } 1066b6d90eb7SKip Macy 10673cf138bbSGeorge V. Neville-Neil /* 10683cf138bbSGeorge V. Neville-Neil * cxgb_port_detach() is called via the device_detach methods when 10693cf138bbSGeorge V. Neville-Neil * cxgb_free() calls the bus_generic_detach. It is responsible for 10703cf138bbSGeorge V. Neville-Neil * removing the device from the view of the kernel, i.e. from all 10713cf138bbSGeorge V. Neville-Neil * interfaces lists etc. This routine is only called when the driver is 10723cf138bbSGeorge V. Neville-Neil * being unloaded, not when the link goes down. 10733cf138bbSGeorge V. Neville-Neil */ 1074b6d90eb7SKip Macy static int 1075b6d90eb7SKip Macy cxgb_port_detach(device_t dev) 1076b6d90eb7SKip Macy { 1077b6d90eb7SKip Macy struct port_info *p; 10783cf138bbSGeorge V. Neville-Neil struct adapter *sc; 10793f345a5dSKip Macy int i; 1080b6d90eb7SKip Macy 1081b6d90eb7SKip Macy p = device_get_softc(dev); 10823cf138bbSGeorge V. Neville-Neil sc = p->adapter; 10833cf138bbSGeorge V. Neville-Neil 1084b302b77cSNavdeep Parhar /* Tell cxgb_ioctl and if_init that the port is going away */ 1085b302b77cSNavdeep Parhar ADAPTER_LOCK(sc); 1086b302b77cSNavdeep Parhar SET_DOOMED(p); 1087b302b77cSNavdeep Parhar wakeup(&sc->flags); 1088b302b77cSNavdeep Parhar while (IS_BUSY(sc)) 1089b302b77cSNavdeep Parhar mtx_sleep(&sc->flags, &sc->lock, 0, "cxgbdtch", 0); 1090b302b77cSNavdeep Parhar SET_BUSY(sc); 1091b302b77cSNavdeep Parhar ADAPTER_UNLOCK(sc); 10923f345a5dSKip Macy 10933cf138bbSGeorge V. Neville-Neil if (p->port_cdev != NULL) 10943cf138bbSGeorge V. Neville-Neil destroy_dev(p->port_cdev); 10953cf138bbSGeorge V. Neville-Neil 10963f345a5dSKip Macy cxgb_uninit_synchronized(p); 10973cf138bbSGeorge V. Neville-Neil ether_ifdetach(p->ifp); 1098d722cab4SKip Macy 10993f345a5dSKip Macy for (i = p->first_qset; i < p->first_qset + p->nqsets; i++) { 11003f345a5dSKip Macy struct sge_qset *qs = &sc->sge.qs[i]; 11013f345a5dSKip Macy struct sge_txq *txq = &qs->txq[TXQ_ETH]; 1102d722cab4SKip Macy 11033f345a5dSKip Macy callout_drain(&txq->txq_watchdog); 11043f345a5dSKip Macy callout_drain(&txq->txq_timer); 11053cf138bbSGeorge V. Neville-Neil } 11063cf138bbSGeorge V. Neville-Neil 11077ac2e6c3SKip Macy PORT_LOCK_DEINIT(p); 1108b6d90eb7SKip Macy if_free(p->ifp); 11093f345a5dSKip Macy p->ifp = NULL; 1110b6d90eb7SKip Macy 1111b302b77cSNavdeep Parhar ADAPTER_LOCK(sc); 1112b302b77cSNavdeep Parhar CLR_BUSY(sc); 1113b302b77cSNavdeep Parhar wakeup_one(&sc->flags); 1114b302b77cSNavdeep Parhar ADAPTER_UNLOCK(sc); 1115b6d90eb7SKip Macy return (0); 1116b6d90eb7SKip Macy } 1117b6d90eb7SKip Macy 1118b6d90eb7SKip Macy void 1119b6d90eb7SKip Macy t3_fatal_err(struct adapter *sc) 1120b6d90eb7SKip Macy { 1121b6d90eb7SKip Macy u_int fw_status[4]; 1122b6d90eb7SKip Macy 11235c5df3daSKip Macy if (sc->flags & FULL_INIT_DONE) { 11245c5df3daSKip Macy t3_sge_stop(sc); 11255c5df3daSKip Macy t3_write_reg(sc, A_XGM_TX_CTRL, 0); 11265c5df3daSKip Macy t3_write_reg(sc, A_XGM_RX_CTRL, 0); 11275c5df3daSKip Macy t3_write_reg(sc, XGM_REG(A_XGM_TX_CTRL, 1), 0); 11285c5df3daSKip Macy t3_write_reg(sc, XGM_REG(A_XGM_RX_CTRL, 1), 0); 11295c5df3daSKip Macy t3_intr_disable(sc); 11305c5df3daSKip Macy } 1131b6d90eb7SKip Macy device_printf(sc->dev,"encountered fatal error, operation suspended\n"); 1132b6d90eb7SKip Macy if (!t3_cim_ctl_blk_read(sc, 0xa0, 4, fw_status)) 1133b6d90eb7SKip Macy device_printf(sc->dev, "FW_ status: 0x%x, 0x%x, 0x%x, 0x%x\n", 1134b6d90eb7SKip Macy fw_status[0], fw_status[1], fw_status[2], fw_status[3]); 1135b6d90eb7SKip Macy } 1136b6d90eb7SKip Macy 1137b6d90eb7SKip Macy int 1138b6d90eb7SKip Macy t3_os_find_pci_capability(adapter_t *sc, int cap) 1139b6d90eb7SKip Macy { 1140b6d90eb7SKip Macy device_t dev; 1141b6d90eb7SKip Macy struct pci_devinfo *dinfo; 1142b6d90eb7SKip Macy pcicfgregs *cfg; 1143b6d90eb7SKip Macy uint32_t status; 1144b6d90eb7SKip Macy uint8_t ptr; 1145b6d90eb7SKip Macy 1146b6d90eb7SKip Macy dev = sc->dev; 1147b6d90eb7SKip Macy dinfo = device_get_ivars(dev); 1148b6d90eb7SKip Macy cfg = &dinfo->cfg; 1149b6d90eb7SKip Macy 1150b6d90eb7SKip Macy status = pci_read_config(dev, PCIR_STATUS, 2); 1151b6d90eb7SKip Macy if (!(status & PCIM_STATUS_CAPPRESENT)) 1152b6d90eb7SKip Macy return (0); 1153b6d90eb7SKip Macy 1154b6d90eb7SKip Macy switch (cfg->hdrtype & PCIM_HDRTYPE) { 1155b6d90eb7SKip Macy case 0: 1156b6d90eb7SKip Macy case 1: 1157b6d90eb7SKip Macy ptr = PCIR_CAP_PTR; 1158b6d90eb7SKip Macy break; 1159b6d90eb7SKip Macy case 2: 1160b6d90eb7SKip Macy ptr = PCIR_CAP_PTR_2; 1161b6d90eb7SKip Macy break; 1162b6d90eb7SKip Macy default: 1163b6d90eb7SKip Macy return (0); 1164b6d90eb7SKip Macy break; 1165b6d90eb7SKip Macy } 1166b6d90eb7SKip Macy ptr = pci_read_config(dev, ptr, 1); 1167b6d90eb7SKip Macy 1168b6d90eb7SKip Macy while (ptr != 0) { 1169b6d90eb7SKip Macy if (pci_read_config(dev, ptr + PCICAP_ID, 1) == cap) 1170b6d90eb7SKip Macy return (ptr); 1171b6d90eb7SKip Macy ptr = pci_read_config(dev, ptr + PCICAP_NEXTPTR, 1); 1172b6d90eb7SKip Macy } 1173b6d90eb7SKip Macy 1174b6d90eb7SKip Macy return (0); 1175b6d90eb7SKip Macy } 1176b6d90eb7SKip Macy 1177b6d90eb7SKip Macy int 1178b6d90eb7SKip Macy t3_os_pci_save_state(struct adapter *sc) 1179b6d90eb7SKip Macy { 1180b6d90eb7SKip Macy device_t dev; 1181b6d90eb7SKip Macy struct pci_devinfo *dinfo; 1182b6d90eb7SKip Macy 1183b6d90eb7SKip Macy dev = sc->dev; 1184b6d90eb7SKip Macy dinfo = device_get_ivars(dev); 1185b6d90eb7SKip Macy 1186b6d90eb7SKip Macy pci_cfg_save(dev, dinfo, 0); 1187b6d90eb7SKip Macy return (0); 1188b6d90eb7SKip Macy } 1189b6d90eb7SKip Macy 1190b6d90eb7SKip Macy int 1191b6d90eb7SKip Macy t3_os_pci_restore_state(struct adapter *sc) 1192b6d90eb7SKip Macy { 1193b6d90eb7SKip Macy device_t dev; 1194b6d90eb7SKip Macy struct pci_devinfo *dinfo; 1195b6d90eb7SKip Macy 1196b6d90eb7SKip Macy dev = sc->dev; 1197b6d90eb7SKip Macy dinfo = device_get_ivars(dev); 1198b6d90eb7SKip Macy 1199b6d90eb7SKip Macy pci_cfg_restore(dev, dinfo); 1200b6d90eb7SKip Macy return (0); 1201b6d90eb7SKip Macy } 1202b6d90eb7SKip Macy 1203b6d90eb7SKip Macy /** 1204b6d90eb7SKip Macy * t3_os_link_changed - handle link status changes 1205c01f2b83SNavdeep Parhar * @sc: the adapter associated with the link change 1206c01f2b83SNavdeep Parhar * @port_id: the port index whose link status has changed 120719905d6dSKip Macy * @link_status: the new status of the link 1208b6d90eb7SKip Macy * @speed: the new speed setting 1209b6d90eb7SKip Macy * @duplex: the new duplex setting 1210b6d90eb7SKip Macy * @fc: the new flow-control setting 1211b6d90eb7SKip Macy * 1212b6d90eb7SKip Macy * This is the OS-dependent handler for link status changes. The OS 1213b6d90eb7SKip Macy * neutral handler takes care of most of the processing for these events, 1214b6d90eb7SKip Macy * then calls this handler for any OS-specific processing. 1215b6d90eb7SKip Macy */ 1216b6d90eb7SKip Macy void 1217b6d90eb7SKip Macy t3_os_link_changed(adapter_t *adapter, int port_id, int link_status, int speed, 1218c01f2b83SNavdeep Parhar int duplex, int fc, int mac_was_reset) 1219b6d90eb7SKip Macy { 1220b6d90eb7SKip Macy struct port_info *pi = &adapter->port[port_id]; 12213f345a5dSKip Macy struct ifnet *ifp = pi->ifp; 12223f345a5dSKip Macy 12233f345a5dSKip Macy /* no race with detach, so ifp should always be good */ 12243f345a5dSKip Macy KASSERT(ifp, ("%s: if detached.", __func__)); 1225b6d90eb7SKip Macy 1226c01f2b83SNavdeep Parhar /* Reapply mac settings if they were lost due to a reset */ 1227c01f2b83SNavdeep Parhar if (mac_was_reset) { 1228c01f2b83SNavdeep Parhar PORT_LOCK(pi); 1229c01f2b83SNavdeep Parhar cxgb_update_mac_settings(pi); 1230c01f2b83SNavdeep Parhar PORT_UNLOCK(pi); 1231c01f2b83SNavdeep Parhar } 1232c01f2b83SNavdeep Parhar 1233d722cab4SKip Macy if (link_status) { 12343f345a5dSKip Macy ifp->if_baudrate = IF_Mbps(speed); 12353f345a5dSKip Macy if_link_state_change(ifp, LINK_STATE_UP); 12360bbdea77SGeorge V. Neville-Neil } else 12373f345a5dSKip Macy if_link_state_change(ifp, LINK_STATE_DOWN); 1238d722cab4SKip Macy } 1239b6d90eb7SKip Macy 12409b4de886SKip Macy /** 12419b4de886SKip Macy * t3_os_phymod_changed - handle PHY module changes 12429b4de886SKip Macy * @phy: the PHY reporting the module change 12439b4de886SKip Macy * @mod_type: new module type 12449b4de886SKip Macy * 12459b4de886SKip Macy * This is the OS-dependent handler for PHY module changes. It is 12469b4de886SKip Macy * invoked when a PHY module is removed or inserted for any OS-specific 12479b4de886SKip Macy * processing. 12489b4de886SKip Macy */ 12499b4de886SKip Macy void t3_os_phymod_changed(struct adapter *adap, int port_id) 12509b4de886SKip Macy { 12519b4de886SKip Macy static const char *mod_str[] = { 1252cd5c70b2SNavdeep Parhar NULL, "SR", "LR", "LRM", "TWINAX", "TWINAX-L", "unknown" 12539b4de886SKip Macy }; 12549b4de886SKip Macy struct port_info *pi = &adap->port[port_id]; 12552975f787SNavdeep Parhar int mod = pi->phy.modtype; 12569b4de886SKip Macy 12572975f787SNavdeep Parhar if (mod != pi->media.ifm_cur->ifm_data) 12582975f787SNavdeep Parhar cxgb_build_medialist(pi); 12592975f787SNavdeep Parhar 12602975f787SNavdeep Parhar if (mod == phy_modtype_none) 12612975f787SNavdeep Parhar if_printf(pi->ifp, "PHY module unplugged\n"); 12629b4de886SKip Macy else { 12632975f787SNavdeep Parhar KASSERT(mod < ARRAY_SIZE(mod_str), 12642975f787SNavdeep Parhar ("invalid PHY module type %d", mod)); 12652975f787SNavdeep Parhar if_printf(pi->ifp, "%s PHY module inserted\n", mod_str[mod]); 12669b4de886SKip Macy } 12679b4de886SKip Macy } 12689b4de886SKip Macy 1269b6d90eb7SKip Macy void 1270b6d90eb7SKip Macy t3_os_set_hw_addr(adapter_t *adapter, int port_idx, u8 hw_addr[]) 1271b6d90eb7SKip Macy { 1272b6d90eb7SKip Macy 1273b6d90eb7SKip Macy /* 1274b6d90eb7SKip Macy * The ifnet might not be allocated before this gets called, 1275b6d90eb7SKip Macy * as this is called early on in attach by t3_prep_adapter 1276b6d90eb7SKip Macy * save the address off in the port structure 1277b6d90eb7SKip Macy */ 1278b6d90eb7SKip Macy if (cxgb_debug) 1279b6d90eb7SKip Macy printf("set_hw_addr on idx %d addr %6D\n", port_idx, hw_addr, ":"); 1280b6d90eb7SKip Macy bcopy(hw_addr, adapter->port[port_idx].hw_addr, ETHER_ADDR_LEN); 1281b6d90eb7SKip Macy } 1282b6d90eb7SKip Macy 12833f345a5dSKip Macy /* 12843f345a5dSKip Macy * Programs the XGMAC based on the settings in the ifnet. These settings 12853f345a5dSKip Macy * include MTU, MAC address, mcast addresses, etc. 1286b6d90eb7SKip Macy */ 1287b6d90eb7SKip Macy static void 12883f345a5dSKip Macy cxgb_update_mac_settings(struct port_info *p) 1289b6d90eb7SKip Macy { 12903f345a5dSKip Macy struct ifnet *ifp = p->ifp; 1291b6d90eb7SKip Macy struct t3_rx_mode rm; 1292b6d90eb7SKip Macy struct cmac *mac = &p->mac; 12934af83c8cSKip Macy int mtu, hwtagging; 1294b6d90eb7SKip Macy 12953f345a5dSKip Macy PORT_LOCK_ASSERT_OWNED(p); 1296b6d90eb7SKip Macy 12974af83c8cSKip Macy bcopy(IF_LLADDR(ifp), p->hw_addr, ETHER_ADDR_LEN); 12984af83c8cSKip Macy 12994af83c8cSKip Macy mtu = ifp->if_mtu; 13004af83c8cSKip Macy if (ifp->if_capenable & IFCAP_VLAN_MTU) 13014af83c8cSKip Macy mtu += ETHER_VLAN_ENCAP_LEN; 13024af83c8cSKip Macy 13034af83c8cSKip Macy hwtagging = (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0; 13044af83c8cSKip Macy 13054af83c8cSKip Macy t3_mac_set_mtu(mac, mtu); 13064af83c8cSKip Macy t3_set_vlan_accel(p->adapter, 1 << p->tx_chan, hwtagging); 1307b6d90eb7SKip Macy t3_mac_set_address(mac, 0, p->hw_addr); 13083f345a5dSKip Macy t3_init_rx_mode(&rm, p); 1309b6d90eb7SKip Macy t3_mac_set_rx_mode(mac, &rm); 1310b6d90eb7SKip Macy } 1311b6d90eb7SKip Macy 13128e10660fSKip Macy 13138e10660fSKip Macy static int 13148e10660fSKip Macy await_mgmt_replies(struct adapter *adap, unsigned long init_cnt, 13158e10660fSKip Macy unsigned long n) 13168e10660fSKip Macy { 13178e10660fSKip Macy int attempts = 5; 13188e10660fSKip Macy 13198e10660fSKip Macy while (adap->sge.qs[0].rspq.offload_pkts < init_cnt + n) { 13208e10660fSKip Macy if (!--attempts) 13218e10660fSKip Macy return (ETIMEDOUT); 13228e10660fSKip Macy t3_os_sleep(10); 13238e10660fSKip Macy } 13248e10660fSKip Macy return 0; 13258e10660fSKip Macy } 13268e10660fSKip Macy 13278e10660fSKip Macy static int 13288e10660fSKip Macy init_tp_parity(struct adapter *adap) 13298e10660fSKip Macy { 13308e10660fSKip Macy int i; 13318e10660fSKip Macy struct mbuf *m; 13328e10660fSKip Macy struct cpl_set_tcb_field *greq; 13338e10660fSKip Macy unsigned long cnt = adap->sge.qs[0].rspq.offload_pkts; 13348e10660fSKip Macy 13358e10660fSKip Macy t3_tp_set_offload_mode(adap, 1); 13368e10660fSKip Macy 13378e10660fSKip Macy for (i = 0; i < 16; i++) { 13388e10660fSKip Macy struct cpl_smt_write_req *req; 13398e10660fSKip Macy 13408e10660fSKip Macy m = m_gethdr(M_WAITOK, MT_DATA); 13418e10660fSKip Macy req = mtod(m, struct cpl_smt_write_req *); 13428e10660fSKip Macy m->m_len = m->m_pkthdr.len = sizeof(*req); 13438e10660fSKip Macy memset(req, 0, sizeof(*req)); 13443f345a5dSKip Macy req->wr.wrh_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD)); 13458e10660fSKip Macy OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SMT_WRITE_REQ, i)); 13468e10660fSKip Macy req->iff = i; 13478e10660fSKip Macy t3_mgmt_tx(adap, m); 13488e10660fSKip Macy } 13498e10660fSKip Macy 13508e10660fSKip Macy for (i = 0; i < 2048; i++) { 13518e10660fSKip Macy struct cpl_l2t_write_req *req; 13528e10660fSKip Macy 13538e10660fSKip Macy m = m_gethdr(M_WAITOK, MT_DATA); 13548e10660fSKip Macy req = mtod(m, struct cpl_l2t_write_req *); 13558e10660fSKip Macy m->m_len = m->m_pkthdr.len = sizeof(*req); 13568e10660fSKip Macy memset(req, 0, sizeof(*req)); 13573f345a5dSKip Macy req->wr.wrh_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD)); 13588e10660fSKip Macy OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_L2T_WRITE_REQ, i)); 13598e10660fSKip Macy req->params = htonl(V_L2T_W_IDX(i)); 13608e10660fSKip Macy t3_mgmt_tx(adap, m); 13618e10660fSKip Macy } 13628e10660fSKip Macy 13638e10660fSKip Macy for (i = 0; i < 2048; i++) { 13648e10660fSKip Macy struct cpl_rte_write_req *req; 13658e10660fSKip Macy 13668e10660fSKip Macy m = m_gethdr(M_WAITOK, MT_DATA); 13678e10660fSKip Macy req = mtod(m, struct cpl_rte_write_req *); 13688e10660fSKip Macy m->m_len = m->m_pkthdr.len = sizeof(*req); 13698e10660fSKip Macy memset(req, 0, sizeof(*req)); 13703f345a5dSKip Macy req->wr.wrh_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD)); 13718e10660fSKip Macy OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_RTE_WRITE_REQ, i)); 13728e10660fSKip Macy req->l2t_idx = htonl(V_L2T_W_IDX(i)); 13738e10660fSKip Macy t3_mgmt_tx(adap, m); 13748e10660fSKip Macy } 13758e10660fSKip Macy 13768e10660fSKip Macy m = m_gethdr(M_WAITOK, MT_DATA); 13778e10660fSKip Macy greq = mtod(m, struct cpl_set_tcb_field *); 13788e10660fSKip Macy m->m_len = m->m_pkthdr.len = sizeof(*greq); 13798e10660fSKip Macy memset(greq, 0, sizeof(*greq)); 13803f345a5dSKip Macy greq->wr.wrh_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD)); 13818e10660fSKip Macy OPCODE_TID(greq) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, 0)); 13828e10660fSKip Macy greq->mask = htobe64(1); 13838e10660fSKip Macy t3_mgmt_tx(adap, m); 13848e10660fSKip Macy 13858e10660fSKip Macy i = await_mgmt_replies(adap, cnt, 16 + 2048 + 2048 + 1); 13868e10660fSKip Macy t3_tp_set_offload_mode(adap, 0); 13878e10660fSKip Macy return (i); 13888e10660fSKip Macy } 13898e10660fSKip Macy 1390b6d90eb7SKip Macy /** 1391b6d90eb7SKip Macy * setup_rss - configure Receive Side Steering (per-queue connection demux) 1392b6d90eb7SKip Macy * @adap: the adapter 1393b6d90eb7SKip Macy * 1394b6d90eb7SKip Macy * Sets up RSS to distribute packets to multiple receive queues. We 1395b6d90eb7SKip Macy * configure the RSS CPU lookup table to distribute to the number of HW 1396b6d90eb7SKip Macy * receive queues, and the response queue lookup table to narrow that 1397b6d90eb7SKip Macy * down to the response queues actually configured for each port. 1398b6d90eb7SKip Macy * We always configure the RSS mapping for two ports since the mapping 1399b6d90eb7SKip Macy * table has plenty of entries. 1400b6d90eb7SKip Macy */ 1401b6d90eb7SKip Macy static void 1402b6d90eb7SKip Macy setup_rss(adapter_t *adap) 1403b6d90eb7SKip Macy { 1404b6d90eb7SKip Macy int i; 1405ac3a6d9cSKip Macy u_int nq[2]; 1406b6d90eb7SKip Macy uint8_t cpus[SGE_QSETS + 1]; 1407b6d90eb7SKip Macy uint16_t rspq_map[RSS_TABLE_SIZE]; 14085c5df3daSKip Macy 1409b6d90eb7SKip Macy for (i = 0; i < SGE_QSETS; ++i) 1410b6d90eb7SKip Macy cpus[i] = i; 1411b6d90eb7SKip Macy cpus[SGE_QSETS] = 0xff; 1412b6d90eb7SKip Macy 14137ac2e6c3SKip Macy nq[0] = nq[1] = 0; 14147ac2e6c3SKip Macy for_each_port(adap, i) { 14157ac2e6c3SKip Macy const struct port_info *pi = adap2pinfo(adap, i); 14167ac2e6c3SKip Macy 14177ac2e6c3SKip Macy nq[pi->tx_chan] += pi->nqsets; 14187ac2e6c3SKip Macy } 1419b6d90eb7SKip Macy for (i = 0; i < RSS_TABLE_SIZE / 2; ++i) { 14208e10660fSKip Macy rspq_map[i] = nq[0] ? i % nq[0] : 0; 14218e10660fSKip Macy rspq_map[i + RSS_TABLE_SIZE / 2] = nq[1] ? i % nq[1] + nq[0] : 0; 1422b6d90eb7SKip Macy } 14236b2eaa83SJohn Baldwin 1424ac3a6d9cSKip Macy /* Calculate the reverse RSS map table */ 14256b2eaa83SJohn Baldwin for (i = 0; i < SGE_QSETS; ++i) 14266b2eaa83SJohn Baldwin adap->rrss_map[i] = 0xff; 1427ac3a6d9cSKip Macy for (i = 0; i < RSS_TABLE_SIZE; ++i) 1428ac3a6d9cSKip Macy if (adap->rrss_map[rspq_map[i]] == 0xff) 1429ac3a6d9cSKip Macy adap->rrss_map[rspq_map[i]] = i; 1430b6d90eb7SKip Macy 1431b6d90eb7SKip Macy t3_config_rss(adap, F_RQFEEDBACKENABLE | F_TNLLKPEN | F_TNLMAPEN | 1432ac3a6d9cSKip Macy F_TNLPRTEN | F_TNL2TUPEN | F_TNL4TUPEN | F_OFDMAPEN | 14338e10660fSKip Macy F_RRCPLMAPEN | V_RRCPLCPUSIZE(6) | F_HASHTOEPLITZ, 14348e10660fSKip Macy cpus, rspq_map); 1435ac3a6d9cSKip Macy 1436b6d90eb7SKip Macy } 1437b6d90eb7SKip Macy 1438d722cab4SKip Macy /* 1439d722cab4SKip Macy * Sends an mbuf to an offload queue driver 1440d722cab4SKip Macy * after dealing with any active network taps. 1441d722cab4SKip Macy */ 1442d722cab4SKip Macy static inline int 14433e96c7e7SKip Macy offload_tx(struct t3cdev *tdev, struct mbuf *m) 1444d722cab4SKip Macy { 1445d722cab4SKip Macy int ret; 1446d722cab4SKip Macy 1447d722cab4SKip Macy ret = t3_offload_tx(tdev, m); 1448ef72318fSKip Macy return (ret); 1449d722cab4SKip Macy } 1450d722cab4SKip Macy 1451d722cab4SKip Macy static int 1452d722cab4SKip Macy write_smt_entry(struct adapter *adapter, int idx) 1453d722cab4SKip Macy { 1454d722cab4SKip Macy struct port_info *pi = &adapter->port[idx]; 1455d722cab4SKip Macy struct cpl_smt_write_req *req; 1456d722cab4SKip Macy struct mbuf *m; 1457d722cab4SKip Macy 1458d722cab4SKip Macy if ((m = m_gethdr(M_NOWAIT, MT_DATA)) == NULL) 1459d722cab4SKip Macy return (ENOMEM); 1460d722cab4SKip Macy 1461d722cab4SKip Macy req = mtod(m, struct cpl_smt_write_req *); 14628090c9f5SKip Macy m->m_pkthdr.len = m->m_len = sizeof(struct cpl_smt_write_req); 14638090c9f5SKip Macy 14643f345a5dSKip Macy req->wr.wrh_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD)); 1465d722cab4SKip Macy OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SMT_WRITE_REQ, idx)); 1466d722cab4SKip Macy req->mtu_idx = NMTUS - 1; /* should be 0 but there's a T3 bug */ 1467d722cab4SKip Macy req->iff = idx; 1468d722cab4SKip Macy memset(req->src_mac1, 0, sizeof(req->src_mac1)); 1469d722cab4SKip Macy memcpy(req->src_mac0, pi->hw_addr, ETHER_ADDR_LEN); 1470d722cab4SKip Macy 1471d722cab4SKip Macy m_set_priority(m, 1); 1472d722cab4SKip Macy 1473d722cab4SKip Macy offload_tx(&adapter->tdev, m); 1474d722cab4SKip Macy 1475d722cab4SKip Macy return (0); 1476d722cab4SKip Macy } 1477d722cab4SKip Macy 1478d722cab4SKip Macy static int 1479d722cab4SKip Macy init_smt(struct adapter *adapter) 1480d722cab4SKip Macy { 1481d722cab4SKip Macy int i; 1482d722cab4SKip Macy 1483d722cab4SKip Macy for_each_port(adapter, i) 1484d722cab4SKip Macy write_smt_entry(adapter, i); 1485d722cab4SKip Macy return 0; 1486d722cab4SKip Macy } 1487d722cab4SKip Macy 1488d722cab4SKip Macy static void 1489d722cab4SKip Macy init_port_mtus(adapter_t *adapter) 1490d722cab4SKip Macy { 14913f345a5dSKip Macy unsigned int mtus = ETHERMTU | (ETHERMTU << 16); 1492d722cab4SKip Macy 1493d722cab4SKip Macy t3_write_reg(adapter, A_TP_MTU_PORT_TABLE, mtus); 1494d722cab4SKip Macy } 1495d722cab4SKip Macy 1496b6d90eb7SKip Macy static void 1497b6d90eb7SKip Macy send_pktsched_cmd(struct adapter *adap, int sched, int qidx, int lo, 1498b6d90eb7SKip Macy int hi, int port) 1499b6d90eb7SKip Macy { 1500b6d90eb7SKip Macy struct mbuf *m; 1501b6d90eb7SKip Macy struct mngt_pktsched_wr *req; 1502b6d90eb7SKip Macy 1503ac3a6d9cSKip Macy m = m_gethdr(M_DONTWAIT, MT_DATA); 150420fe52b8SKip Macy if (m) { 1505d722cab4SKip Macy req = mtod(m, struct mngt_pktsched_wr *); 15063f345a5dSKip Macy req->wr.wrh_hi = htonl(V_WR_OP(FW_WROPCODE_MNGT)); 1507b6d90eb7SKip Macy req->mngt_opcode = FW_MNGTOPCODE_PKTSCHED_SET; 1508b6d90eb7SKip Macy req->sched = sched; 1509b6d90eb7SKip Macy req->idx = qidx; 1510b6d90eb7SKip Macy req->min = lo; 1511b6d90eb7SKip Macy req->max = hi; 1512b6d90eb7SKip Macy req->binding = port; 1513b6d90eb7SKip Macy m->m_len = m->m_pkthdr.len = sizeof(*req); 1514b6d90eb7SKip Macy t3_mgmt_tx(adap, m); 1515b6d90eb7SKip Macy } 151620fe52b8SKip Macy } 1517b6d90eb7SKip Macy 1518b6d90eb7SKip Macy static void 1519b6d90eb7SKip Macy bind_qsets(adapter_t *sc) 1520b6d90eb7SKip Macy { 1521b6d90eb7SKip Macy int i, j; 1522b6d90eb7SKip Macy 1523b6d90eb7SKip Macy for (i = 0; i < (sc)->params.nports; ++i) { 1524b6d90eb7SKip Macy const struct port_info *pi = adap2pinfo(sc, i); 1525b6d90eb7SKip Macy 15265c5df3daSKip Macy for (j = 0; j < pi->nqsets; ++j) { 1527b6d90eb7SKip Macy send_pktsched_cmd(sc, 1, pi->first_qset + j, -1, 15285c5df3daSKip Macy -1, pi->tx_chan); 15295c5df3daSKip Macy 15305c5df3daSKip Macy } 1531b6d90eb7SKip Macy } 1532b6d90eb7SKip Macy } 1533b6d90eb7SKip Macy 1534ac3a6d9cSKip Macy static void 1535ac3a6d9cSKip Macy update_tpeeprom(struct adapter *adap) 1536ac3a6d9cSKip Macy { 1537ac3a6d9cSKip Macy const struct firmware *tpeeprom; 15382de1fa86SKip Macy 1539ac3a6d9cSKip Macy uint32_t version; 1540ac3a6d9cSKip Macy unsigned int major, minor; 1541ac3a6d9cSKip Macy int ret, len; 1542f2d8ff04SGeorge V. Neville-Neil char rev, name[32]; 1543ac3a6d9cSKip Macy 1544ac3a6d9cSKip Macy t3_seeprom_read(adap, TP_SRAM_OFFSET, &version); 1545ac3a6d9cSKip Macy 1546ac3a6d9cSKip Macy major = G_TP_VERSION_MAJOR(version); 1547ac3a6d9cSKip Macy minor = G_TP_VERSION_MINOR(version); 1548ac3a6d9cSKip Macy if (major == TP_VERSION_MAJOR && minor == TP_VERSION_MINOR) 1549ac3a6d9cSKip Macy return; 1550ac3a6d9cSKip Macy 1551ac3a6d9cSKip Macy rev = t3rev2char(adap); 1552f2d8ff04SGeorge V. Neville-Neil snprintf(name, sizeof(name), TPEEPROM_NAME, rev); 1553ac3a6d9cSKip Macy 1554f2d8ff04SGeorge V. Neville-Neil tpeeprom = firmware_get(name); 1555ac3a6d9cSKip Macy if (tpeeprom == NULL) { 15560c1ff9c6SGeorge V. Neville-Neil device_printf(adap->dev, 15570c1ff9c6SGeorge V. Neville-Neil "could not load TP EEPROM: unable to load %s\n", 15580c1ff9c6SGeorge V. Neville-Neil name); 1559ac3a6d9cSKip Macy return; 1560ac3a6d9cSKip Macy } 1561ac3a6d9cSKip Macy 1562ac3a6d9cSKip Macy len = tpeeprom->datasize - 4; 1563ac3a6d9cSKip Macy 1564ac3a6d9cSKip Macy ret = t3_check_tpsram(adap, tpeeprom->data, tpeeprom->datasize); 1565ac3a6d9cSKip Macy if (ret) 1566ac3a6d9cSKip Macy goto release_tpeeprom; 1567ac3a6d9cSKip Macy 1568ac3a6d9cSKip Macy if (len != TP_SRAM_LEN) { 15690c1ff9c6SGeorge V. Neville-Neil device_printf(adap->dev, 15700c1ff9c6SGeorge V. Neville-Neil "%s length is wrong len=%d expected=%d\n", name, 15710c1ff9c6SGeorge V. Neville-Neil len, TP_SRAM_LEN); 1572ac3a6d9cSKip Macy return; 1573ac3a6d9cSKip Macy } 1574ac3a6d9cSKip Macy 1575ac3a6d9cSKip Macy ret = set_eeprom(&adap->port[0], tpeeprom->data, tpeeprom->datasize, 1576ac3a6d9cSKip Macy TP_SRAM_OFFSET); 1577ac3a6d9cSKip Macy 1578ac3a6d9cSKip Macy if (!ret) { 1579ac3a6d9cSKip Macy device_printf(adap->dev, 1580ac3a6d9cSKip Macy "Protocol SRAM image updated in EEPROM to %d.%d.%d\n", 1581ac3a6d9cSKip Macy TP_VERSION_MAJOR, TP_VERSION_MINOR, TP_VERSION_MICRO); 1582ac3a6d9cSKip Macy } else 15830c1ff9c6SGeorge V. Neville-Neil device_printf(adap->dev, 15840c1ff9c6SGeorge V. Neville-Neil "Protocol SRAM image update in EEPROM failed\n"); 1585ac3a6d9cSKip Macy 1586ac3a6d9cSKip Macy release_tpeeprom: 1587ac3a6d9cSKip Macy firmware_put(tpeeprom, FIRMWARE_UNLOAD); 1588ac3a6d9cSKip Macy 1589ac3a6d9cSKip Macy return; 1590ac3a6d9cSKip Macy } 1591ac3a6d9cSKip Macy 1592ac3a6d9cSKip Macy static int 1593ac3a6d9cSKip Macy update_tpsram(struct adapter *adap) 1594ac3a6d9cSKip Macy { 1595ac3a6d9cSKip Macy const struct firmware *tpsram; 1596ac3a6d9cSKip Macy int ret; 1597f2d8ff04SGeorge V. Neville-Neil char rev, name[32]; 1598ac3a6d9cSKip Macy 1599ac3a6d9cSKip Macy rev = t3rev2char(adap); 1600f2d8ff04SGeorge V. Neville-Neil snprintf(name, sizeof(name), TPSRAM_NAME, rev); 1601ac3a6d9cSKip Macy 1602ac3a6d9cSKip Macy update_tpeeprom(adap); 1603ac3a6d9cSKip Macy 1604f2d8ff04SGeorge V. Neville-Neil tpsram = firmware_get(name); 1605ac3a6d9cSKip Macy if (tpsram == NULL){ 160664a37133SKip Macy device_printf(adap->dev, "could not load TP SRAM\n"); 1607ac3a6d9cSKip Macy return (EINVAL); 1608ac3a6d9cSKip Macy } else 160964a37133SKip Macy device_printf(adap->dev, "updating TP SRAM\n"); 1610ac3a6d9cSKip Macy 1611ac3a6d9cSKip Macy ret = t3_check_tpsram(adap, tpsram->data, tpsram->datasize); 1612ac3a6d9cSKip Macy if (ret) 1613ac3a6d9cSKip Macy goto release_tpsram; 1614ac3a6d9cSKip Macy 1615ac3a6d9cSKip Macy ret = t3_set_proto_sram(adap, tpsram->data); 1616ac3a6d9cSKip Macy if (ret) 1617ac3a6d9cSKip Macy device_printf(adap->dev, "loading protocol SRAM failed\n"); 1618ac3a6d9cSKip Macy 1619ac3a6d9cSKip Macy release_tpsram: 1620ac3a6d9cSKip Macy firmware_put(tpsram, FIRMWARE_UNLOAD); 1621ac3a6d9cSKip Macy 1622ac3a6d9cSKip Macy return ret; 1623ac3a6d9cSKip Macy } 1624ac3a6d9cSKip Macy 1625d722cab4SKip Macy /** 1626d722cab4SKip Macy * cxgb_up - enable the adapter 1627d722cab4SKip Macy * @adap: adapter being enabled 1628d722cab4SKip Macy * 1629d722cab4SKip Macy * Called when the first port is enabled, this function performs the 1630d722cab4SKip Macy * actions necessary to make an adapter operational, such as completing 1631d722cab4SKip Macy * the initialization of HW modules, and enabling interrupts. 1632d722cab4SKip Macy */ 1633d722cab4SKip Macy static int 1634d722cab4SKip Macy cxgb_up(struct adapter *sc) 1635d722cab4SKip Macy { 1636d722cab4SKip Macy int err = 0; 16373a2c6562SNavdeep Parhar unsigned int mxf = t3_mc5_size(&sc->mc5) - MC5_MIN_TIDS; 1638d722cab4SKip Macy 16393f345a5dSKip Macy KASSERT(sc->open_device_map == 0, ("%s: device(s) already open (%x)", 16403f345a5dSKip Macy __func__, sc->open_device_map)); 16413f345a5dSKip Macy 1642d722cab4SKip Macy if ((sc->flags & FULL_INIT_DONE) == 0) { 1643d722cab4SKip Macy 1644b302b77cSNavdeep Parhar ADAPTER_LOCK_ASSERT_NOTOWNED(sc); 1645b302b77cSNavdeep Parhar 1646d722cab4SKip Macy if ((sc->flags & FW_UPTODATE) == 0) 1647ac3a6d9cSKip Macy if ((err = upgrade_fw(sc))) 1648d722cab4SKip Macy goto out; 16493f345a5dSKip Macy 1650ac3a6d9cSKip Macy if ((sc->flags & TPS_UPTODATE) == 0) 1651ac3a6d9cSKip Macy if ((err = update_tpsram(sc))) 1652ac3a6d9cSKip Macy goto out; 16533f345a5dSKip Macy 16543a2c6562SNavdeep Parhar if (is_offload(sc) && nfilters != 0) { 1655d6da8362SNavdeep Parhar sc->params.mc5.nservers = 0; 16563a2c6562SNavdeep Parhar 16573a2c6562SNavdeep Parhar if (nfilters < 0) 16583a2c6562SNavdeep Parhar sc->params.mc5.nfilters = mxf; 16593a2c6562SNavdeep Parhar else 16603a2c6562SNavdeep Parhar sc->params.mc5.nfilters = min(nfilters, mxf); 1661d6da8362SNavdeep Parhar } 1662d6da8362SNavdeep Parhar 1663d722cab4SKip Macy err = t3_init_hw(sc, 0); 1664d722cab4SKip Macy if (err) 1665d722cab4SKip Macy goto out; 1666d722cab4SKip Macy 16678e10660fSKip Macy t3_set_reg_field(sc, A_TP_PARA_REG5, 0, F_RXDDPOFFINIT); 1668d722cab4SKip Macy t3_write_reg(sc, A_ULPRX_TDDP_PSZ, V_HPZ0(PAGE_SHIFT - 12)); 1669d722cab4SKip Macy 1670d722cab4SKip Macy err = setup_sge_qsets(sc); 1671d722cab4SKip Macy if (err) 1672d722cab4SKip Macy goto out; 1673d722cab4SKip Macy 1674d6da8362SNavdeep Parhar alloc_filters(sc); 1675d722cab4SKip Macy setup_rss(sc); 1676e3503bc9SGeorge V. Neville-Neil 1677e3503bc9SGeorge V. Neville-Neil t3_intr_clear(sc); 1678e3503bc9SGeorge V. Neville-Neil err = cxgb_setup_interrupts(sc); 1679e3503bc9SGeorge V. Neville-Neil if (err) 1680e3503bc9SGeorge V. Neville-Neil goto out; 1681e3503bc9SGeorge V. Neville-Neil 16828090c9f5SKip Macy t3_add_configured_sysctls(sc); 1683d722cab4SKip Macy sc->flags |= FULL_INIT_DONE; 1684d722cab4SKip Macy } 1685d722cab4SKip Macy 1686d722cab4SKip Macy t3_intr_clear(sc); 1687d722cab4SKip Macy t3_sge_start(sc); 1688d722cab4SKip Macy t3_intr_enable(sc); 1689d722cab4SKip Macy 16908e10660fSKip Macy if (sc->params.rev >= T3_REV_C && !(sc->flags & TP_PARITY_INIT) && 16918e10660fSKip Macy is_offload(sc) && init_tp_parity(sc) == 0) 16928e10660fSKip Macy sc->flags |= TP_PARITY_INIT; 16938e10660fSKip Macy 16948e10660fSKip Macy if (sc->flags & TP_PARITY_INIT) { 16953f345a5dSKip Macy t3_write_reg(sc, A_TP_INT_CAUSE, F_CMCACHEPERR | F_ARPLUTPERR); 16968e10660fSKip Macy t3_write_reg(sc, A_TP_INT_ENABLE, 0x7fbfffff); 16978e10660fSKip Macy } 16988e10660fSKip Macy 16995c5df3daSKip Macy if (!(sc->flags & QUEUES_BOUND)) { 1700d722cab4SKip Macy bind_qsets(sc); 1701d6da8362SNavdeep Parhar setup_hw_filters(sc); 1702d722cab4SKip Macy sc->flags |= QUEUES_BOUND; 1703ac3a6d9cSKip Macy } 17043f345a5dSKip Macy 17053f345a5dSKip Macy t3_sge_reset_adapter(sc); 1706d722cab4SKip Macy out: 1707d722cab4SKip Macy return (err); 1708d722cab4SKip Macy } 1709d722cab4SKip Macy 1710d722cab4SKip Macy /* 17113f345a5dSKip Macy * Called when the last open device is closed. Does NOT undo all of cxgb_up's 17123f345a5dSKip Macy * work. Specifically, the resources grabbed under FULL_INIT_DONE are released 17133f345a5dSKip Macy * during controller_detach, not here. 1714d722cab4SKip Macy */ 1715d722cab4SKip Macy static void 17163f345a5dSKip Macy cxgb_down(struct adapter *sc) 1717d722cab4SKip Macy { 1718d722cab4SKip Macy t3_sge_stop(sc); 1719d722cab4SKip Macy t3_intr_disable(sc); 1720d722cab4SKip Macy } 1721d722cab4SKip Macy 1722d722cab4SKip Macy static int 1723d722cab4SKip Macy offload_open(struct port_info *pi) 1724d722cab4SKip Macy { 17253f345a5dSKip Macy struct adapter *sc = pi->adapter; 17263f345a5dSKip Macy struct t3cdev *tdev = &sc->tdev; 1727af9b081cSKip Macy 17283f345a5dSKip Macy setbit(&sc->open_device_map, OFFLOAD_DEVMAP_BIT); 1729d722cab4SKip Macy 17303f345a5dSKip Macy t3_tp_set_offload_mode(sc, 1); 17318090c9f5SKip Macy tdev->lldev = pi->ifp; 17323f345a5dSKip Macy init_port_mtus(sc); 17333f345a5dSKip Macy t3_load_mtus(sc, sc->params.mtus, sc->params.a_wnd, sc->params.b_wnd, 17343f345a5dSKip Macy sc->params.rev == 0 ? sc->port[0].ifp->if_mtu : 0xffff); 17353f345a5dSKip Macy init_smt(sc); 1736ed0fb18dSKip Macy cxgb_add_clients(tdev); 1737ed0fb18dSKip Macy 17383f345a5dSKip Macy return (0); 1739d722cab4SKip Macy } 17408090c9f5SKip Macy 1741d722cab4SKip Macy static int 17428090c9f5SKip Macy offload_close(struct t3cdev *tdev) 1743d722cab4SKip Macy { 1744d722cab4SKip Macy struct adapter *adapter = tdev2adap(tdev); 1745d722cab4SKip Macy 17468e10660fSKip Macy if (!isset(&adapter->open_device_map, OFFLOAD_DEVMAP_BIT)) 1747ef72318fSKip Macy return (0); 1748d722cab4SKip Macy 1749ed0fb18dSKip Macy /* Call back all registered clients */ 1750ed0fb18dSKip Macy cxgb_remove_clients(tdev); 1751ed0fb18dSKip Macy 1752d722cab4SKip Macy tdev->lldev = NULL; 1753d722cab4SKip Macy cxgb_set_dummy_ops(tdev); 1754d722cab4SKip Macy t3_tp_set_offload_mode(adapter, 0); 17553f345a5dSKip Macy 1756d722cab4SKip Macy clrbit(&adapter->open_device_map, OFFLOAD_DEVMAP_BIT); 1757d722cab4SKip Macy 1758ef72318fSKip Macy return (0); 1759d722cab4SKip Macy } 17608090c9f5SKip Macy 17613f345a5dSKip Macy /* 17623f345a5dSKip Macy * if_init for cxgb ports. 17633f345a5dSKip Macy */ 1764b6d90eb7SKip Macy static void 1765b6d90eb7SKip Macy cxgb_init(void *arg) 1766b6d90eb7SKip Macy { 1767b6d90eb7SKip Macy struct port_info *p = arg; 1768b302b77cSNavdeep Parhar struct adapter *sc = p->adapter; 1769b6d90eb7SKip Macy 1770b302b77cSNavdeep Parhar ADAPTER_LOCK(sc); 1771b302b77cSNavdeep Parhar cxgb_init_locked(p); /* releases adapter lock */ 1772b302b77cSNavdeep Parhar ADAPTER_LOCK_ASSERT_NOTOWNED(sc); 17733f345a5dSKip Macy } 17743f345a5dSKip Macy 17753f345a5dSKip Macy static int 1776b302b77cSNavdeep Parhar cxgb_init_locked(struct port_info *p) 17773f345a5dSKip Macy { 17783f345a5dSKip Macy struct adapter *sc = p->adapter; 17793f345a5dSKip Macy struct ifnet *ifp = p->ifp; 17803f345a5dSKip Macy struct cmac *mac = &p->mac; 178161cb6c90SNavdeep Parhar int i, rc = 0, may_sleep = 0, gave_up_lock = 0; 1782b302b77cSNavdeep Parhar 1783b302b77cSNavdeep Parhar ADAPTER_LOCK_ASSERT_OWNED(sc); 1784b302b77cSNavdeep Parhar 1785b302b77cSNavdeep Parhar while (!IS_DOOMED(p) && IS_BUSY(sc)) { 178661cb6c90SNavdeep Parhar gave_up_lock = 1; 1787b302b77cSNavdeep Parhar if (mtx_sleep(&sc->flags, &sc->lock, PCATCH, "cxgbinit", 0)) { 1788b302b77cSNavdeep Parhar rc = EINTR; 1789b302b77cSNavdeep Parhar goto done; 1790b302b77cSNavdeep Parhar } 1791b302b77cSNavdeep Parhar } 1792b302b77cSNavdeep Parhar if (IS_DOOMED(p)) { 1793b302b77cSNavdeep Parhar rc = ENXIO; 1794b302b77cSNavdeep Parhar goto done; 1795b302b77cSNavdeep Parhar } 1796b302b77cSNavdeep Parhar KASSERT(!IS_BUSY(sc), ("%s: controller busy.", __func__)); 1797b302b77cSNavdeep Parhar 1798b302b77cSNavdeep Parhar /* 1799b302b77cSNavdeep Parhar * The code that runs during one-time adapter initialization can sleep 1800b302b77cSNavdeep Parhar * so it's important not to hold any locks across it. 1801b302b77cSNavdeep Parhar */ 1802b302b77cSNavdeep Parhar may_sleep = sc->flags & FULL_INIT_DONE ? 0 : 1; 1803b302b77cSNavdeep Parhar 1804b302b77cSNavdeep Parhar if (may_sleep) { 1805b302b77cSNavdeep Parhar SET_BUSY(sc); 180661cb6c90SNavdeep Parhar gave_up_lock = 1; 1807b302b77cSNavdeep Parhar ADAPTER_UNLOCK(sc); 1808b302b77cSNavdeep Parhar } 18093f345a5dSKip Macy 18103f345a5dSKip Macy if (sc->open_device_map == 0) { 18113f345a5dSKip Macy if ((rc = cxgb_up(sc)) != 0) 1812b302b77cSNavdeep Parhar goto done; 18133f345a5dSKip Macy 18143f345a5dSKip Macy if (is_offload(sc) && !ofld_disable && offload_open(p)) 1815d722cab4SKip Macy log(LOG_WARNING, 1816d722cab4SKip Macy "Could not initialize offload capabilities\n"); 1817d722cab4SKip Macy } 18180bbdea77SGeorge V. Neville-Neil 18193f345a5dSKip Macy PORT_LOCK(p); 1820b302b77cSNavdeep Parhar if (isset(&sc->open_device_map, p->port_id) && 1821b302b77cSNavdeep Parhar (ifp->if_drv_flags & IFF_DRV_RUNNING)) { 1822b302b77cSNavdeep Parhar PORT_UNLOCK(p); 1823b302b77cSNavdeep Parhar goto done; 1824b302b77cSNavdeep Parhar } 18250bbdea77SGeorge V. Neville-Neil t3_port_intr_enable(sc, p->port_id); 18263f345a5dSKip Macy if (!mac->multiport) 1827c01f2b83SNavdeep Parhar t3_mac_init(mac); 18283f345a5dSKip Macy cxgb_update_mac_settings(p); 18293f345a5dSKip Macy t3_link_start(&p->phy, mac, &p->link_config); 18303f345a5dSKip Macy t3_mac_enable(mac, MAC_DIRECTION_RX | MAC_DIRECTION_TX); 1831b6d90eb7SKip Macy ifp->if_drv_flags |= IFF_DRV_RUNNING; 1832b6d90eb7SKip Macy ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 18333f345a5dSKip Macy PORT_UNLOCK(p); 18343f345a5dSKip Macy 18353f345a5dSKip Macy for (i = p->first_qset; i < p->first_qset + p->nqsets; i++) { 18363f345a5dSKip Macy struct sge_qset *qs = &sc->sge.qs[i]; 18373f345a5dSKip Macy struct sge_txq *txq = &qs->txq[TXQ_ETH]; 18383f345a5dSKip Macy 18393f345a5dSKip Macy callout_reset_on(&txq->txq_watchdog, hz, cxgb_tx_watchdog, qs, 18403f345a5dSKip Macy txq->txq_watchdog.c_cpu); 1841b6d90eb7SKip Macy } 1842b6d90eb7SKip Macy 18433f345a5dSKip Macy /* all ok */ 18443f345a5dSKip Macy setbit(&sc->open_device_map, p->port_id); 1845bd1a9fbaSNavdeep Parhar callout_reset(&p->link_check_ch, 1846bd1a9fbaSNavdeep Parhar p->phy.caps & SUPPORTED_LINK_IRQ ? hz * 3 : hz / 4, 1847bd1a9fbaSNavdeep Parhar link_check_callout, p); 1848b6d90eb7SKip Macy 1849b302b77cSNavdeep Parhar done: 1850b302b77cSNavdeep Parhar if (may_sleep) { 1851b302b77cSNavdeep Parhar ADAPTER_LOCK(sc); 1852b302b77cSNavdeep Parhar KASSERT(IS_BUSY(sc), ("%s: controller not busy.", __func__)); 1853b302b77cSNavdeep Parhar CLR_BUSY(sc); 1854b302b77cSNavdeep Parhar } 185561cb6c90SNavdeep Parhar if (gave_up_lock) 185661cb6c90SNavdeep Parhar wakeup_one(&sc->flags); 1857b302b77cSNavdeep Parhar ADAPTER_UNLOCK(sc); 1858b302b77cSNavdeep Parhar return (rc); 1859b302b77cSNavdeep Parhar } 1860b302b77cSNavdeep Parhar 1861b302b77cSNavdeep Parhar static int 1862b302b77cSNavdeep Parhar cxgb_uninit_locked(struct port_info *p) 1863b302b77cSNavdeep Parhar { 1864b302b77cSNavdeep Parhar struct adapter *sc = p->adapter; 1865b302b77cSNavdeep Parhar int rc; 1866b302b77cSNavdeep Parhar 1867b302b77cSNavdeep Parhar ADAPTER_LOCK_ASSERT_OWNED(sc); 1868b302b77cSNavdeep Parhar 1869b302b77cSNavdeep Parhar while (!IS_DOOMED(p) && IS_BUSY(sc)) { 1870b302b77cSNavdeep Parhar if (mtx_sleep(&sc->flags, &sc->lock, PCATCH, "cxgbunin", 0)) { 1871b302b77cSNavdeep Parhar rc = EINTR; 1872b302b77cSNavdeep Parhar goto done; 1873b302b77cSNavdeep Parhar } 1874b302b77cSNavdeep Parhar } 1875b302b77cSNavdeep Parhar if (IS_DOOMED(p)) { 1876b302b77cSNavdeep Parhar rc = ENXIO; 1877b302b77cSNavdeep Parhar goto done; 1878b302b77cSNavdeep Parhar } 1879b302b77cSNavdeep Parhar KASSERT(!IS_BUSY(sc), ("%s: controller busy.", __func__)); 1880b302b77cSNavdeep Parhar SET_BUSY(sc); 1881b302b77cSNavdeep Parhar ADAPTER_UNLOCK(sc); 1882b302b77cSNavdeep Parhar 1883b302b77cSNavdeep Parhar rc = cxgb_uninit_synchronized(p); 1884b302b77cSNavdeep Parhar 1885b302b77cSNavdeep Parhar ADAPTER_LOCK(sc); 1886b302b77cSNavdeep Parhar KASSERT(IS_BUSY(sc), ("%s: controller not busy.", __func__)); 1887b302b77cSNavdeep Parhar CLR_BUSY(sc); 1888b302b77cSNavdeep Parhar wakeup_one(&sc->flags); 1889b302b77cSNavdeep Parhar done: 1890b302b77cSNavdeep Parhar ADAPTER_UNLOCK(sc); 1891b302b77cSNavdeep Parhar return (rc); 1892b6d90eb7SKip Macy } 1893b6d90eb7SKip Macy 18943f345a5dSKip Macy /* 18953f345a5dSKip Macy * Called on "ifconfig down", and from port_detach 18963f345a5dSKip Macy */ 18973f345a5dSKip Macy static int 18983f345a5dSKip Macy cxgb_uninit_synchronized(struct port_info *pi) 1899b6d90eb7SKip Macy { 19003f345a5dSKip Macy struct adapter *sc = pi->adapter; 19013f345a5dSKip Macy struct ifnet *ifp = pi->ifp; 1902b6d90eb7SKip Macy 19033f345a5dSKip Macy /* 1904b302b77cSNavdeep Parhar * taskqueue_drain may cause a deadlock if the adapter lock is held. 1905b302b77cSNavdeep Parhar */ 1906b302b77cSNavdeep Parhar ADAPTER_LOCK_ASSERT_NOTOWNED(sc); 1907b302b77cSNavdeep Parhar 1908b302b77cSNavdeep Parhar /* 19093f345a5dSKip Macy * Clear this port's bit from the open device map, and then drain all 19103f345a5dSKip Macy * the tasks that can access/manipulate this port's port_info or ifp. 19113f345a5dSKip Macy * We disable this port's interrupts here and so the the slow/ext 19123f345a5dSKip Macy * interrupt tasks won't be enqueued. The tick task will continue to 19133f345a5dSKip Macy * be enqueued every second but the runs after this drain will not see 19143f345a5dSKip Macy * this port in the open device map. 19153f345a5dSKip Macy * 19163f345a5dSKip Macy * A well behaved task must take open_device_map into account and ignore 19173f345a5dSKip Macy * ports that are not open. 19183f345a5dSKip Macy */ 19193f345a5dSKip Macy clrbit(&sc->open_device_map, pi->port_id); 19203f345a5dSKip Macy t3_port_intr_disable(sc, pi->port_id); 19213f345a5dSKip Macy taskqueue_drain(sc->tq, &sc->slow_intr_task); 19223f345a5dSKip Macy taskqueue_drain(sc->tq, &sc->tick_task); 192377f07749SKip Macy 1924bd1a9fbaSNavdeep Parhar callout_drain(&pi->link_check_ch); 1925bd1a9fbaSNavdeep Parhar taskqueue_drain(sc->tq, &pi->link_check_task); 1926bd1a9fbaSNavdeep Parhar 19273f345a5dSKip Macy PORT_LOCK(pi); 1928d722cab4SKip Macy ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); 1929b6d90eb7SKip Macy 193019905d6dSKip Macy /* disable pause frames */ 19313f345a5dSKip Macy t3_set_reg_field(sc, A_XGM_TX_CFG + pi->mac.offset, F_TXPAUSEEN, 0); 1932bb38cd2fSKip Macy 193319905d6dSKip Macy /* Reset RX FIFO HWM */ 19343f345a5dSKip Macy t3_set_reg_field(sc, A_XGM_RXFIFO_CFG + pi->mac.offset, 193519905d6dSKip Macy V_RXFIFOPAUSEHWM(M_RXFIFOPAUSEHWM), 0); 193619905d6dSKip Macy 1937a9c23ef0SNavdeep Parhar DELAY(100 * 1000); 193819905d6dSKip Macy 193919905d6dSKip Macy /* Wait for TXFIFO empty */ 19403f345a5dSKip Macy t3_wait_op_done(sc, A_XGM_TXFIFO_CFG + pi->mac.offset, 194119905d6dSKip Macy F_TXFIFO_EMPTY, 1, 20, 5); 194219905d6dSKip Macy 1943a9c23ef0SNavdeep Parhar DELAY(100 * 1000); 1944a9c23ef0SNavdeep Parhar t3_mac_disable(&pi->mac, MAC_DIRECTION_RX); 194519905d6dSKip Macy 19463f345a5dSKip Macy 194719905d6dSKip Macy pi->phy.ops->power_down(&pi->phy, 1); 1948bb38cd2fSKip Macy 19493f345a5dSKip Macy PORT_UNLOCK(pi); 1950b6d90eb7SKip Macy 19513f345a5dSKip Macy pi->link_config.link_ok = 0; 1952c01f2b83SNavdeep Parhar t3_os_link_changed(sc, pi->port_id, 0, 0, 0, 0, 0); 1953ef72318fSKip Macy 19543f345a5dSKip Macy if ((sc->open_device_map & PORT_MASK) == 0) 19553f345a5dSKip Macy offload_close(&sc->tdev); 19563f345a5dSKip Macy 19573f345a5dSKip Macy if (sc->open_device_map == 0) 19583f345a5dSKip Macy cxgb_down(pi->adapter); 19593f345a5dSKip Macy 19603f345a5dSKip Macy return (0); 1961ef72318fSKip Macy } 1962ef72318fSKip Macy 196325292debSKip Macy /* 196425292debSKip Macy * Mark lro enabled or disabled in all qsets for this port 196525292debSKip Macy */ 196625292debSKip Macy static int 196725292debSKip Macy cxgb_set_lro(struct port_info *p, int enabled) 196825292debSKip Macy { 196925292debSKip Macy int i; 197025292debSKip Macy struct adapter *adp = p->adapter; 197125292debSKip Macy struct sge_qset *q; 197225292debSKip Macy 197325292debSKip Macy for (i = 0; i < p->nqsets; i++) { 197425292debSKip Macy q = &adp->sge.qs[p->first_qset + i]; 197525292debSKip Macy q->lro.enabled = (enabled != 0); 197625292debSKip Macy } 197725292debSKip Macy return (0); 197825292debSKip Macy } 197925292debSKip Macy 1980ef72318fSKip Macy static int 1981b6d90eb7SKip Macy cxgb_ioctl(struct ifnet *ifp, unsigned long command, caddr_t data) 1982b6d90eb7SKip Macy { 1983b6d90eb7SKip Macy struct port_info *p = ifp->if_softc; 1984b302b77cSNavdeep Parhar struct adapter *sc = p->adapter; 1985b6d90eb7SKip Macy struct ifreq *ifr = (struct ifreq *)data; 1986b302b77cSNavdeep Parhar int flags, error = 0, mtu; 1987b6d90eb7SKip Macy uint32_t mask; 1988b6d90eb7SKip Macy 1989b6d90eb7SKip Macy switch (command) { 1990b6d90eb7SKip Macy case SIOCSIFMTU: 1991b302b77cSNavdeep Parhar ADAPTER_LOCK(sc); 1992b302b77cSNavdeep Parhar error = IS_DOOMED(p) ? ENXIO : (IS_BUSY(sc) ? EBUSY : 0); 1993b302b77cSNavdeep Parhar if (error) { 1994b302b77cSNavdeep Parhar fail: 1995b302b77cSNavdeep Parhar ADAPTER_UNLOCK(sc); 1996b302b77cSNavdeep Parhar return (error); 1997b302b77cSNavdeep Parhar } 1998b302b77cSNavdeep Parhar 19993f345a5dSKip Macy mtu = ifr->ifr_mtu; 20003f345a5dSKip Macy if ((mtu < ETHERMIN) || (mtu > ETHERMTU_JUMBO)) { 20013f345a5dSKip Macy error = EINVAL; 20023f345a5dSKip Macy } else { 20033f345a5dSKip Macy ifp->if_mtu = mtu; 20048e10660fSKip Macy PORT_LOCK(p); 20053f345a5dSKip Macy cxgb_update_mac_settings(p); 20064f6a96aeSKip Macy PORT_UNLOCK(p); 20078e10660fSKip Macy } 2008b302b77cSNavdeep Parhar ADAPTER_UNLOCK(sc); 2009b6d90eb7SKip Macy break; 2010b6d90eb7SKip Macy case SIOCSIFFLAGS: 2011b302b77cSNavdeep Parhar ADAPTER_LOCK(sc); 2012b302b77cSNavdeep Parhar if (IS_DOOMED(p)) { 2013b302b77cSNavdeep Parhar error = ENXIO; 2014b302b77cSNavdeep Parhar goto fail; 2015b302b77cSNavdeep Parhar } 2016ef72318fSKip Macy if (ifp->if_flags & IFF_UP) { 2017b6d90eb7SKip Macy if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 2018b6d90eb7SKip Macy flags = p->if_flags; 2019b6d90eb7SKip Macy if (((ifp->if_flags ^ flags) & IFF_PROMISC) || 20203f345a5dSKip Macy ((ifp->if_flags ^ flags) & IFF_ALLMULTI)) { 2021b302b77cSNavdeep Parhar if (IS_BUSY(sc)) { 2022b302b77cSNavdeep Parhar error = EBUSY; 2023b302b77cSNavdeep Parhar goto fail; 2024b302b77cSNavdeep Parhar } 20253f345a5dSKip Macy PORT_LOCK(p); 20263f345a5dSKip Macy cxgb_update_mac_settings(p); 20273f345a5dSKip Macy PORT_UNLOCK(p); 20283f345a5dSKip Macy } 2029b302b77cSNavdeep Parhar ADAPTER_UNLOCK(sc); 2030b6d90eb7SKip Macy } else 2031b302b77cSNavdeep Parhar error = cxgb_init_locked(p); 2032b6d90eb7SKip Macy p->if_flags = ifp->if_flags; 2033bb38cd2fSKip Macy } else if (ifp->if_drv_flags & IFF_DRV_RUNNING) 2034b302b77cSNavdeep Parhar error = cxgb_uninit_locked(p); 20353c0e59deSNavdeep Parhar else 20363c0e59deSNavdeep Parhar ADAPTER_UNLOCK(sc); 2037bb38cd2fSKip Macy 2038b302b77cSNavdeep Parhar ADAPTER_LOCK_ASSERT_NOTOWNED(sc); 2039b6d90eb7SKip Macy break; 20408e10660fSKip Macy case SIOCADDMULTI: 20418e10660fSKip Macy case SIOCDELMULTI: 2042b302b77cSNavdeep Parhar ADAPTER_LOCK(sc); 2043b302b77cSNavdeep Parhar error = IS_DOOMED(p) ? ENXIO : (IS_BUSY(sc) ? EBUSY : 0); 2044b302b77cSNavdeep Parhar if (error) 2045b302b77cSNavdeep Parhar goto fail; 2046b302b77cSNavdeep Parhar 20478e10660fSKip Macy if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 2048837f41b0SGeorge V. Neville-Neil PORT_LOCK(p); 20493f345a5dSKip Macy cxgb_update_mac_settings(p); 2050837f41b0SGeorge V. Neville-Neil PORT_UNLOCK(p); 20513f345a5dSKip Macy } 2052b302b77cSNavdeep Parhar ADAPTER_UNLOCK(sc); 20533f345a5dSKip Macy 2054b6d90eb7SKip Macy break; 2055b6d90eb7SKip Macy case SIOCSIFCAP: 2056b302b77cSNavdeep Parhar ADAPTER_LOCK(sc); 2057b302b77cSNavdeep Parhar error = IS_DOOMED(p) ? ENXIO : (IS_BUSY(sc) ? EBUSY : 0); 2058b302b77cSNavdeep Parhar if (error) 2059b302b77cSNavdeep Parhar goto fail; 2060b302b77cSNavdeep Parhar 2061b6d90eb7SKip Macy mask = ifr->ifr_reqcap ^ ifp->if_capenable; 2062b6d90eb7SKip Macy if (mask & IFCAP_TXCSUM) { 2063f9c6e164SNavdeep Parhar ifp->if_capenable ^= IFCAP_TXCSUM; 2064f9c6e164SNavdeep Parhar ifp->if_hwassist ^= (CSUM_TCP | CSUM_UDP | CSUM_IP); 2065f9c6e164SNavdeep Parhar 2066f9c6e164SNavdeep Parhar if (IFCAP_TSO & ifp->if_capenable && 2067f9c6e164SNavdeep Parhar !(IFCAP_TXCSUM & ifp->if_capenable)) { 2068f9c6e164SNavdeep Parhar ifp->if_capenable &= ~IFCAP_TSO; 2069b6d90eb7SKip Macy ifp->if_hwassist &= ~CSUM_TSO; 2070f9c6e164SNavdeep Parhar if_printf(ifp, 2071f9c6e164SNavdeep Parhar "tso disabled due to -txcsum.\n"); 2072f9c6e164SNavdeep Parhar } 2073f9c6e164SNavdeep Parhar } 2074f9c6e164SNavdeep Parhar if (mask & IFCAP_RXCSUM) 2075f9c6e164SNavdeep Parhar ifp->if_capenable ^= IFCAP_RXCSUM; 2076f9c6e164SNavdeep Parhar if (mask & IFCAP_TSO4) { 2077f9c6e164SNavdeep Parhar ifp->if_capenable ^= IFCAP_TSO4; 2078f9c6e164SNavdeep Parhar 2079f9c6e164SNavdeep Parhar if (IFCAP_TSO & ifp->if_capenable) { 2080f9c6e164SNavdeep Parhar if (IFCAP_TXCSUM & ifp->if_capenable) 2081b6d90eb7SKip Macy ifp->if_hwassist |= CSUM_TSO; 2082f9c6e164SNavdeep Parhar else { 2083f9c6e164SNavdeep Parhar ifp->if_capenable &= ~IFCAP_TSO; 2084f9c6e164SNavdeep Parhar ifp->if_hwassist &= ~CSUM_TSO; 2085f9c6e164SNavdeep Parhar if_printf(ifp, 2086f9c6e164SNavdeep Parhar "enable txcsum first.\n"); 2087f9c6e164SNavdeep Parhar error = EAGAIN; 2088f9c6e164SNavdeep Parhar } 20893f345a5dSKip Macy } else 2090f9c6e164SNavdeep Parhar ifp->if_hwassist &= ~CSUM_TSO; 2091b6d90eb7SKip Macy } 209225292debSKip Macy if (mask & IFCAP_LRO) { 209325292debSKip Macy ifp->if_capenable ^= IFCAP_LRO; 209425292debSKip Macy 209525292debSKip Macy /* Safe to do this even if cxgb_up not called yet */ 209625292debSKip Macy cxgb_set_lro(p, ifp->if_capenable & IFCAP_LRO); 209725292debSKip Macy } 20984af83c8cSKip Macy if (mask & IFCAP_VLAN_HWTAGGING) { 20994af83c8cSKip Macy ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING; 21003f345a5dSKip Macy if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 21013f345a5dSKip Macy PORT_LOCK(p); 21023f345a5dSKip Macy cxgb_update_mac_settings(p); 21033f345a5dSKip Macy PORT_UNLOCK(p); 21043f345a5dSKip Macy } 21054af83c8cSKip Macy } 21064af83c8cSKip Macy if (mask & IFCAP_VLAN_MTU) { 21074af83c8cSKip Macy ifp->if_capenable ^= IFCAP_VLAN_MTU; 21083f345a5dSKip Macy if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 21093f345a5dSKip Macy PORT_LOCK(p); 21103f345a5dSKip Macy cxgb_update_mac_settings(p); 21113f345a5dSKip Macy PORT_UNLOCK(p); 21123f345a5dSKip Macy } 21134af83c8cSKip Macy } 2114f9c6e164SNavdeep Parhar if (mask & IFCAP_VLAN_HWTSO) 2115f9c6e164SNavdeep Parhar ifp->if_capenable ^= IFCAP_VLAN_HWTSO; 2116b302b77cSNavdeep Parhar if (mask & IFCAP_VLAN_HWCSUM) 21174af83c8cSKip Macy ifp->if_capenable ^= IFCAP_VLAN_HWCSUM; 21184af83c8cSKip Macy 21194af83c8cSKip Macy #ifdef VLAN_CAPABILITIES 21204af83c8cSKip Macy VLAN_CAPABILITIES(ifp); 21214af83c8cSKip Macy #endif 2122b302b77cSNavdeep Parhar ADAPTER_UNLOCK(sc); 2123b302b77cSNavdeep Parhar break; 2124b302b77cSNavdeep Parhar case SIOCSIFMEDIA: 2125b302b77cSNavdeep Parhar case SIOCGIFMEDIA: 2126b302b77cSNavdeep Parhar error = ifmedia_ioctl(ifp, ifr, &p->media, command); 2127b6d90eb7SKip Macy break; 2128b6d90eb7SKip Macy default: 21293f345a5dSKip Macy error = ether_ioctl(ifp, command, data); 21303f345a5dSKip Macy } 21313f345a5dSKip Macy 2132b6d90eb7SKip Macy return (error); 2133b6d90eb7SKip Macy } 2134b6d90eb7SKip Macy 2135b6d90eb7SKip Macy static int 2136b6d90eb7SKip Macy cxgb_media_change(struct ifnet *ifp) 2137b6d90eb7SKip Macy { 21382975f787SNavdeep Parhar return (EOPNOTSUPP); 2139b6d90eb7SKip Macy } 2140b6d90eb7SKip Macy 2141837f41b0SGeorge V. Neville-Neil /* 21422975f787SNavdeep Parhar * Translates phy->modtype to the correct Ethernet media subtype. 2143837f41b0SGeorge V. Neville-Neil */ 2144837f41b0SGeorge V. Neville-Neil static int 21452975f787SNavdeep Parhar cxgb_ifm_type(int mod) 2146837f41b0SGeorge V. Neville-Neil { 21472975f787SNavdeep Parhar switch (mod) { 2148837f41b0SGeorge V. Neville-Neil case phy_modtype_sr: 21492975f787SNavdeep Parhar return (IFM_10G_SR); 2150837f41b0SGeorge V. Neville-Neil case phy_modtype_lr: 21512975f787SNavdeep Parhar return (IFM_10G_LR); 2152837f41b0SGeorge V. Neville-Neil case phy_modtype_lrm: 21532975f787SNavdeep Parhar return (IFM_10G_LRM); 2154837f41b0SGeorge V. Neville-Neil case phy_modtype_twinax: 21552975f787SNavdeep Parhar return (IFM_10G_TWINAX); 2156837f41b0SGeorge V. Neville-Neil case phy_modtype_twinax_long: 21572975f787SNavdeep Parhar return (IFM_10G_TWINAX_LONG); 2158837f41b0SGeorge V. Neville-Neil case phy_modtype_none: 21592975f787SNavdeep Parhar return (IFM_NONE); 2160837f41b0SGeorge V. Neville-Neil case phy_modtype_unknown: 21612975f787SNavdeep Parhar return (IFM_UNKNOWN); 2162837f41b0SGeorge V. Neville-Neil } 2163837f41b0SGeorge V. Neville-Neil 21642975f787SNavdeep Parhar KASSERT(0, ("%s: modtype %d unknown", __func__, mod)); 21652975f787SNavdeep Parhar return (IFM_UNKNOWN); 21662975f787SNavdeep Parhar } 21672975f787SNavdeep Parhar 21682975f787SNavdeep Parhar /* 21692975f787SNavdeep Parhar * Rebuilds the ifmedia list for this port, and sets the current media. 21702975f787SNavdeep Parhar */ 21712975f787SNavdeep Parhar static void 21722975f787SNavdeep Parhar cxgb_build_medialist(struct port_info *p) 21732975f787SNavdeep Parhar { 21742975f787SNavdeep Parhar struct cphy *phy = &p->phy; 21752975f787SNavdeep Parhar struct ifmedia *media = &p->media; 21762975f787SNavdeep Parhar int mod = phy->modtype; 21772975f787SNavdeep Parhar int m = IFM_ETHER | IFM_FDX; 21782975f787SNavdeep Parhar 21792975f787SNavdeep Parhar PORT_LOCK(p); 21802975f787SNavdeep Parhar 21812975f787SNavdeep Parhar ifmedia_removeall(media); 21822975f787SNavdeep Parhar if (phy->caps & SUPPORTED_TP && phy->caps & SUPPORTED_Autoneg) { 21832975f787SNavdeep Parhar /* Copper (RJ45) */ 21842975f787SNavdeep Parhar 21852975f787SNavdeep Parhar if (phy->caps & SUPPORTED_10000baseT_Full) 21862975f787SNavdeep Parhar ifmedia_add(media, m | IFM_10G_T, mod, NULL); 21872975f787SNavdeep Parhar 21882975f787SNavdeep Parhar if (phy->caps & SUPPORTED_1000baseT_Full) 21892975f787SNavdeep Parhar ifmedia_add(media, m | IFM_1000_T, mod, NULL); 21902975f787SNavdeep Parhar 21912975f787SNavdeep Parhar if (phy->caps & SUPPORTED_100baseT_Full) 21922975f787SNavdeep Parhar ifmedia_add(media, m | IFM_100_TX, mod, NULL); 21932975f787SNavdeep Parhar 21942975f787SNavdeep Parhar if (phy->caps & SUPPORTED_10baseT_Full) 21952975f787SNavdeep Parhar ifmedia_add(media, m | IFM_10_T, mod, NULL); 21962975f787SNavdeep Parhar 21972975f787SNavdeep Parhar ifmedia_add(media, IFM_ETHER | IFM_AUTO, mod, NULL); 21982975f787SNavdeep Parhar ifmedia_set(media, IFM_ETHER | IFM_AUTO); 21992975f787SNavdeep Parhar 22002975f787SNavdeep Parhar } else if (phy->caps & SUPPORTED_TP) { 22012975f787SNavdeep Parhar /* Copper (CX4) */ 22022975f787SNavdeep Parhar 22032975f787SNavdeep Parhar KASSERT(phy->caps & SUPPORTED_10000baseT_Full, 22042975f787SNavdeep Parhar ("%s: unexpected cap 0x%x", __func__, phy->caps)); 22052975f787SNavdeep Parhar 22062975f787SNavdeep Parhar ifmedia_add(media, m | IFM_10G_CX4, mod, NULL); 22072975f787SNavdeep Parhar ifmedia_set(media, m | IFM_10G_CX4); 22082975f787SNavdeep Parhar 22092975f787SNavdeep Parhar } else if (phy->caps & SUPPORTED_FIBRE && 22102975f787SNavdeep Parhar phy->caps & SUPPORTED_10000baseT_Full) { 22112975f787SNavdeep Parhar /* 10G optical (but includes SFP+ twinax) */ 22122975f787SNavdeep Parhar 22132975f787SNavdeep Parhar m |= cxgb_ifm_type(mod); 22142975f787SNavdeep Parhar if (IFM_SUBTYPE(m) == IFM_NONE) 22152975f787SNavdeep Parhar m &= ~IFM_FDX; 22162975f787SNavdeep Parhar 22172975f787SNavdeep Parhar ifmedia_add(media, m, mod, NULL); 22182975f787SNavdeep Parhar ifmedia_set(media, m); 22192975f787SNavdeep Parhar 22202975f787SNavdeep Parhar } else if (phy->caps & SUPPORTED_FIBRE && 22212975f787SNavdeep Parhar phy->caps & SUPPORTED_1000baseT_Full) { 22222975f787SNavdeep Parhar /* 1G optical */ 22232975f787SNavdeep Parhar 22242975f787SNavdeep Parhar /* XXX: Lie and claim to be SX, could actually be any 1G-X */ 22252975f787SNavdeep Parhar ifmedia_add(media, m | IFM_1000_SX, mod, NULL); 22262975f787SNavdeep Parhar ifmedia_set(media, m | IFM_1000_SX); 22272975f787SNavdeep Parhar 22282975f787SNavdeep Parhar } else { 22292975f787SNavdeep Parhar KASSERT(0, ("%s: don't know how to handle 0x%x.", __func__, 22302975f787SNavdeep Parhar phy->caps)); 22312975f787SNavdeep Parhar } 22322975f787SNavdeep Parhar 22332975f787SNavdeep Parhar PORT_UNLOCK(p); 2234837f41b0SGeorge V. Neville-Neil } 2235837f41b0SGeorge V. Neville-Neil 2236b6d90eb7SKip Macy static void 2237b6d90eb7SKip Macy cxgb_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) 2238b6d90eb7SKip Macy { 2239b6d90eb7SKip Macy struct port_info *p = ifp->if_softc; 2240837f41b0SGeorge V. Neville-Neil struct ifmedia_entry *cur = p->media.ifm_cur; 22412975f787SNavdeep Parhar int speed = p->link_config.speed; 2242837f41b0SGeorge V. Neville-Neil 2243837f41b0SGeorge V. Neville-Neil if (cur->ifm_data != p->phy.modtype) { 22442975f787SNavdeep Parhar cxgb_build_medialist(p); 22452975f787SNavdeep Parhar cur = p->media.ifm_cur; 2246837f41b0SGeorge V. Neville-Neil } 2247b6d90eb7SKip Macy 2248b6d90eb7SKip Macy ifmr->ifm_status = IFM_AVALID; 2249b6d90eb7SKip Macy if (!p->link_config.link_ok) 2250b6d90eb7SKip Macy return; 2251b6d90eb7SKip Macy 2252b6d90eb7SKip Macy ifmr->ifm_status |= IFM_ACTIVE; 2253b6d90eb7SKip Macy 22542975f787SNavdeep Parhar /* 22552975f787SNavdeep Parhar * active and current will differ iff current media is autoselect. That 22562975f787SNavdeep Parhar * can happen only for copper RJ45. 22572975f787SNavdeep Parhar */ 22582975f787SNavdeep Parhar if (IFM_SUBTYPE(cur->ifm_media) != IFM_AUTO) 22592975f787SNavdeep Parhar return; 22602975f787SNavdeep Parhar KASSERT(p->phy.caps & SUPPORTED_TP && p->phy.caps & SUPPORTED_Autoneg, 22612975f787SNavdeep Parhar ("%s: unexpected PHY caps 0x%x", __func__, p->phy.caps)); 2262ef72318fSKip Macy 22632975f787SNavdeep Parhar ifmr->ifm_active = IFM_ETHER | IFM_FDX; 22642975f787SNavdeep Parhar if (speed == SPEED_10000) 22652975f787SNavdeep Parhar ifmr->ifm_active |= IFM_10G_T; 22662975f787SNavdeep Parhar else if (speed == SPEED_1000) 22672975f787SNavdeep Parhar ifmr->ifm_active |= IFM_1000_T; 22682975f787SNavdeep Parhar else if (speed == SPEED_100) 22692975f787SNavdeep Parhar ifmr->ifm_active |= IFM_100_TX; 22702975f787SNavdeep Parhar else if (speed == SPEED_10) 22712975f787SNavdeep Parhar ifmr->ifm_active |= IFM_10_T; 2272b6d90eb7SKip Macy else 22732975f787SNavdeep Parhar KASSERT(0, ("%s: link up but speed unknown (%u)", __func__, 22742975f787SNavdeep Parhar speed)); 2275b6d90eb7SKip Macy } 2276b6d90eb7SKip Macy 2277b6d90eb7SKip Macy static void 2278b6d90eb7SKip Macy cxgb_async_intr(void *data) 2279b6d90eb7SKip Macy { 2280693d746cSKip Macy adapter_t *sc = data; 2281693d746cSKip Macy 22822c32b502SNavdeep Parhar t3_write_reg(sc, A_PL_INT_ENABLE0, 0); 22832c32b502SNavdeep Parhar (void) t3_read_reg(sc, A_PL_INT_ENABLE0); 2284bb38cd2fSKip Macy taskqueue_enqueue(sc->tq, &sc->slow_intr_task); 2285b6d90eb7SKip Macy } 2286b6d90eb7SKip Macy 2287bd1a9fbaSNavdeep Parhar static void 2288bd1a9fbaSNavdeep Parhar link_check_callout(void *arg) 2289c01f2b83SNavdeep Parhar { 2290bd1a9fbaSNavdeep Parhar struct port_info *pi = arg; 2291bd1a9fbaSNavdeep Parhar struct adapter *sc = pi->adapter; 2292c01f2b83SNavdeep Parhar 2293bd1a9fbaSNavdeep Parhar if (!isset(&sc->open_device_map, pi->port_id)) 2294bd1a9fbaSNavdeep Parhar return; 2295c01f2b83SNavdeep Parhar 2296bd1a9fbaSNavdeep Parhar taskqueue_enqueue(sc->tq, &pi->link_check_task); 2297c01f2b83SNavdeep Parhar } 2298c01f2b83SNavdeep Parhar 2299b6d90eb7SKip Macy static void 2300bd1a9fbaSNavdeep Parhar check_link_status(void *arg, int pending) 2301b6d90eb7SKip Macy { 2302bd1a9fbaSNavdeep Parhar struct port_info *pi = arg; 2303bd1a9fbaSNavdeep Parhar struct adapter *sc = pi->adapter; 2304b6d90eb7SKip Macy 2305bd1a9fbaSNavdeep Parhar if (!isset(&sc->open_device_map, pi->port_id)) 2306bd1a9fbaSNavdeep Parhar return; 2307b6d90eb7SKip Macy 2308bd1a9fbaSNavdeep Parhar t3_link_changed(sc, pi->port_id); 23093f345a5dSKip Macy 2310bd1a9fbaSNavdeep Parhar if (pi->link_fault || !(pi->phy.caps & SUPPORTED_LINK_IRQ)) 2311bd1a9fbaSNavdeep Parhar callout_reset(&pi->link_check_ch, hz, link_check_callout, pi); 2312b6d90eb7SKip Macy } 2313bd1a9fbaSNavdeep Parhar 2314bd1a9fbaSNavdeep Parhar void 2315bd1a9fbaSNavdeep Parhar t3_os_link_intr(struct port_info *pi) 2316bd1a9fbaSNavdeep Parhar { 2317bd1a9fbaSNavdeep Parhar /* 2318bd1a9fbaSNavdeep Parhar * Schedule a link check in the near future. If the link is flapping 2319bd1a9fbaSNavdeep Parhar * rapidly we'll keep resetting the callout and delaying the check until 2320bd1a9fbaSNavdeep Parhar * things stabilize a bit. 2321bd1a9fbaSNavdeep Parhar */ 2322bd1a9fbaSNavdeep Parhar callout_reset(&pi->link_check_ch, hz / 4, link_check_callout, pi); 2323b6d90eb7SKip Macy } 2324b6d90eb7SKip Macy 2325577e9bbeSKip Macy static void 23263f345a5dSKip Macy check_t3b2_mac(struct adapter *sc) 2327577e9bbeSKip Macy { 2328577e9bbeSKip Macy int i; 2329577e9bbeSKip Macy 23303f345a5dSKip Macy if (sc->flags & CXGB_SHUTDOWN) 23318e10660fSKip Macy return; 23328e10660fSKip Macy 23333f345a5dSKip Macy for_each_port(sc, i) { 23343f345a5dSKip Macy struct port_info *p = &sc->port[i]; 2335577e9bbeSKip Macy int status; 23363f345a5dSKip Macy #ifdef INVARIANTS 23373f345a5dSKip Macy struct ifnet *ifp = p->ifp; 23383f345a5dSKip Macy #endif 2339577e9bbeSKip Macy 2340c01f2b83SNavdeep Parhar if (!isset(&sc->open_device_map, p->port_id) || p->link_fault || 2341c01f2b83SNavdeep Parhar !p->link_config.link_ok) 2342577e9bbeSKip Macy continue; 2343577e9bbeSKip Macy 23443f345a5dSKip Macy KASSERT(ifp->if_drv_flags & IFF_DRV_RUNNING, 23453f345a5dSKip Macy ("%s: state mismatch (drv_flags %x, device_map %x)", 23463f345a5dSKip Macy __func__, ifp->if_drv_flags, sc->open_device_map)); 23473f345a5dSKip Macy 2348577e9bbeSKip Macy PORT_LOCK(p); 2349577e9bbeSKip Macy status = t3b2_mac_watchdog_task(&p->mac); 2350577e9bbeSKip Macy if (status == 1) 2351577e9bbeSKip Macy p->mac.stats.num_toggled++; 2352577e9bbeSKip Macy else if (status == 2) { 2353577e9bbeSKip Macy struct cmac *mac = &p->mac; 2354577e9bbeSKip Macy 23553f345a5dSKip Macy cxgb_update_mac_settings(p); 2356577e9bbeSKip Macy t3_link_start(&p->phy, mac, &p->link_config); 2357577e9bbeSKip Macy t3_mac_enable(mac, MAC_DIRECTION_RX | MAC_DIRECTION_TX); 23583f345a5dSKip Macy t3_port_intr_enable(sc, p->port_id); 2359577e9bbeSKip Macy p->mac.stats.num_resets++; 2360577e9bbeSKip Macy } 2361577e9bbeSKip Macy PORT_UNLOCK(p); 2362577e9bbeSKip Macy } 2363577e9bbeSKip Macy } 2364577e9bbeSKip Macy 2365577e9bbeSKip Macy static void 2366577e9bbeSKip Macy cxgb_tick(void *arg) 2367577e9bbeSKip Macy { 2368577e9bbeSKip Macy adapter_t *sc = (adapter_t *)arg; 23698090c9f5SKip Macy 23708e10660fSKip Macy if (sc->flags & CXGB_SHUTDOWN) 23718090c9f5SKip Macy return; 2372577e9bbeSKip Macy 2373bb38cd2fSKip Macy taskqueue_enqueue(sc->tq, &sc->tick_task); 2374bd1a9fbaSNavdeep Parhar callout_reset(&sc->cxgb_tick_ch, hz, cxgb_tick, sc); 2375bb38cd2fSKip Macy } 2376bb38cd2fSKip Macy 2377bb38cd2fSKip Macy static void 2378bb38cd2fSKip Macy cxgb_tick_handler(void *arg, int count) 2379bb38cd2fSKip Macy { 2380bb38cd2fSKip Macy adapter_t *sc = (adapter_t *)arg; 2381bb38cd2fSKip Macy const struct adapter_params *p = &sc->params; 2382706cb31fSKip Macy int i; 2383f2d8ff04SGeorge V. Neville-Neil uint32_t cause, reset; 2384bb38cd2fSKip Macy 23850bbdea77SGeorge V. Neville-Neil if (sc->flags & CXGB_SHUTDOWN || !(sc->flags & FULL_INIT_DONE)) 23868e10660fSKip Macy return; 23878e10660fSKip Macy 2388f35c2d65SKip Macy if (p->rev == T3_REV_B2 && p->nports < 4 && sc->open_device_map) 2389f35c2d65SKip Macy check_t3b2_mac(sc); 2390f35c2d65SKip Macy 2391489ca05bSNavdeep Parhar cause = t3_read_reg(sc, A_SG_INT_CAUSE) & (F_RSPQSTARVE | F_FLEMPTY); 2392489ca05bSNavdeep Parhar if (cause) { 2393f2d8ff04SGeorge V. Neville-Neil struct sge_qset *qs = &sc->sge.qs[0]; 2394489ca05bSNavdeep Parhar uint32_t mask, v; 2395f2d8ff04SGeorge V. Neville-Neil 2396489ca05bSNavdeep Parhar v = t3_read_reg(sc, A_SG_RSPQ_FL_STATUS) & ~0xff00; 2397f2d8ff04SGeorge V. Neville-Neil 2398489ca05bSNavdeep Parhar mask = 1; 2399489ca05bSNavdeep Parhar for (i = 0; i < SGE_QSETS; i++) { 2400489ca05bSNavdeep Parhar if (v & mask) 2401489ca05bSNavdeep Parhar qs[i].rspq.starved++; 2402489ca05bSNavdeep Parhar mask <<= 1; 2403f2d8ff04SGeorge V. Neville-Neil } 2404489ca05bSNavdeep Parhar 2405489ca05bSNavdeep Parhar mask <<= SGE_QSETS; /* skip RSPQXDISABLED */ 2406489ca05bSNavdeep Parhar 2407489ca05bSNavdeep Parhar for (i = 0; i < SGE_QSETS * 2; i++) { 2408489ca05bSNavdeep Parhar if (v & mask) { 2409489ca05bSNavdeep Parhar qs[i / 2].fl[i % 2].empty++; 2410f2d8ff04SGeorge V. Neville-Neil } 2411489ca05bSNavdeep Parhar mask <<= 1; 2412489ca05bSNavdeep Parhar } 2413489ca05bSNavdeep Parhar 2414489ca05bSNavdeep Parhar /* clear */ 2415489ca05bSNavdeep Parhar t3_write_reg(sc, A_SG_RSPQ_FL_STATUS, v); 2416489ca05bSNavdeep Parhar t3_write_reg(sc, A_SG_INT_CAUSE, cause); 2417489ca05bSNavdeep Parhar } 2418f2d8ff04SGeorge V. Neville-Neil 2419ceac50ebSKip Macy for (i = 0; i < sc->params.nports; i++) { 2420ceac50ebSKip Macy struct port_info *pi = &sc->port[i]; 2421ceac50ebSKip Macy struct ifnet *ifp = pi->ifp; 2422f2d8ff04SGeorge V. Neville-Neil struct cmac *mac = &pi->mac; 2423f2d8ff04SGeorge V. Neville-Neil struct mac_stats *mstats = &mac->stats; 242492f61ecbSNavdeep Parhar int drops, j; 24253f345a5dSKip Macy 24263f345a5dSKip Macy if (!isset(&sc->open_device_map, pi->port_id)) 24273f345a5dSKip Macy continue; 24283f345a5dSKip Macy 2429f35c2d65SKip Macy PORT_LOCK(pi); 2430f2d8ff04SGeorge V. Neville-Neil t3_mac_update_stats(mac); 2431f35c2d65SKip Macy PORT_UNLOCK(pi); 2432f35c2d65SKip Macy 243392f61ecbSNavdeep Parhar ifp->if_opackets = mstats->tx_frames; 243492f61ecbSNavdeep Parhar ifp->if_ipackets = mstats->rx_frames; 2435ceac50ebSKip Macy ifp->if_obytes = mstats->tx_octets; 2436ceac50ebSKip Macy ifp->if_ibytes = mstats->rx_octets; 2437ceac50ebSKip Macy ifp->if_omcasts = mstats->tx_mcast_frames; 2438ceac50ebSKip Macy ifp->if_imcasts = mstats->rx_mcast_frames; 243992f61ecbSNavdeep Parhar ifp->if_collisions = mstats->tx_total_collisions; 2440ceac50ebSKip Macy ifp->if_iqdrops = mstats->rx_cong_drops; 2441ceac50ebSKip Macy 244292f61ecbSNavdeep Parhar drops = 0; 244392f61ecbSNavdeep Parhar for (j = pi->first_qset; j < pi->first_qset + pi->nqsets; j++) 244492f61ecbSNavdeep Parhar drops += sc->sge.qs[j].txq[TXQ_ETH].txq_mr->br_drops; 244592f61ecbSNavdeep Parhar ifp->if_snd.ifq_drops = drops; 244692f61ecbSNavdeep Parhar 2447ceac50ebSKip Macy ifp->if_oerrors = 2448ceac50ebSKip Macy mstats->tx_excess_collisions + 2449ceac50ebSKip Macy mstats->tx_underrun + 2450ceac50ebSKip Macy mstats->tx_len_errs + 2451ceac50ebSKip Macy mstats->tx_mac_internal_errs + 2452ceac50ebSKip Macy mstats->tx_excess_deferral + 2453ceac50ebSKip Macy mstats->tx_fcs_errs; 2454ceac50ebSKip Macy ifp->if_ierrors = 2455ceac50ebSKip Macy mstats->rx_jabber + 2456ceac50ebSKip Macy mstats->rx_data_errs + 2457ceac50ebSKip Macy mstats->rx_sequence_errs + 2458ceac50ebSKip Macy mstats->rx_runt + 2459ceac50ebSKip Macy mstats->rx_too_long + 2460ceac50ebSKip Macy mstats->rx_mac_internal_errs + 2461ceac50ebSKip Macy mstats->rx_short + 2462ceac50ebSKip Macy mstats->rx_fcs_errs; 2463f2d8ff04SGeorge V. Neville-Neil 2464f2d8ff04SGeorge V. Neville-Neil if (mac->multiport) 2465f2d8ff04SGeorge V. Neville-Neil continue; 2466f2d8ff04SGeorge V. Neville-Neil 2467f2d8ff04SGeorge V. Neville-Neil /* Count rx fifo overflows, once per second */ 2468f2d8ff04SGeorge V. Neville-Neil cause = t3_read_reg(sc, A_XGM_INT_CAUSE + mac->offset); 2469f2d8ff04SGeorge V. Neville-Neil reset = 0; 2470f2d8ff04SGeorge V. Neville-Neil if (cause & F_RXFIFO_OVERFLOW) { 2471f2d8ff04SGeorge V. Neville-Neil mac->stats.rx_fifo_ovfl++; 2472f2d8ff04SGeorge V. Neville-Neil reset |= F_RXFIFO_OVERFLOW; 2473f2d8ff04SGeorge V. Neville-Neil } 2474f2d8ff04SGeorge V. Neville-Neil t3_write_reg(sc, A_XGM_INT_CAUSE + mac->offset, reset); 2475ceac50ebSKip Macy } 2476577e9bbeSKip Macy } 2477577e9bbeSKip Macy 24787ac2e6c3SKip Macy static void 24797ac2e6c3SKip Macy touch_bars(device_t dev) 24807ac2e6c3SKip Macy { 24817ac2e6c3SKip Macy /* 24827ac2e6c3SKip Macy * Don't enable yet 24837ac2e6c3SKip Macy */ 24847ac2e6c3SKip Macy #if !defined(__LP64__) && 0 24857ac2e6c3SKip Macy u32 v; 24867ac2e6c3SKip Macy 24877ac2e6c3SKip Macy pci_read_config_dword(pdev, PCI_BASE_ADDRESS_1, &v); 24887ac2e6c3SKip Macy pci_write_config_dword(pdev, PCI_BASE_ADDRESS_1, v); 24897ac2e6c3SKip Macy pci_read_config_dword(pdev, PCI_BASE_ADDRESS_3, &v); 24907ac2e6c3SKip Macy pci_write_config_dword(pdev, PCI_BASE_ADDRESS_3, v); 24917ac2e6c3SKip Macy pci_read_config_dword(pdev, PCI_BASE_ADDRESS_5, &v); 24927ac2e6c3SKip Macy pci_write_config_dword(pdev, PCI_BASE_ADDRESS_5, v); 24937ac2e6c3SKip Macy #endif 24947ac2e6c3SKip Macy } 24957ac2e6c3SKip Macy 2496ac3a6d9cSKip Macy static int 2497ac3a6d9cSKip Macy set_eeprom(struct port_info *pi, const uint8_t *data, int len, int offset) 2498ac3a6d9cSKip Macy { 2499ac3a6d9cSKip Macy uint8_t *buf; 2500ac3a6d9cSKip Macy int err = 0; 2501ac3a6d9cSKip Macy u32 aligned_offset, aligned_len, *p; 2502ac3a6d9cSKip Macy struct adapter *adapter = pi->adapter; 2503ac3a6d9cSKip Macy 2504ac3a6d9cSKip Macy 2505ac3a6d9cSKip Macy aligned_offset = offset & ~3; 2506ac3a6d9cSKip Macy aligned_len = (len + (offset & 3) + 3) & ~3; 2507ac3a6d9cSKip Macy 2508ac3a6d9cSKip Macy if (aligned_offset != offset || aligned_len != len) { 2509ac3a6d9cSKip Macy buf = malloc(aligned_len, M_DEVBUF, M_WAITOK|M_ZERO); 2510ac3a6d9cSKip Macy if (!buf) 2511ac3a6d9cSKip Macy return (ENOMEM); 2512ac3a6d9cSKip Macy err = t3_seeprom_read(adapter, aligned_offset, (u32 *)buf); 2513ac3a6d9cSKip Macy if (!err && aligned_len > 4) 2514ac3a6d9cSKip Macy err = t3_seeprom_read(adapter, 2515ac3a6d9cSKip Macy aligned_offset + aligned_len - 4, 2516ac3a6d9cSKip Macy (u32 *)&buf[aligned_len - 4]); 2517ac3a6d9cSKip Macy if (err) 2518ac3a6d9cSKip Macy goto out; 2519ac3a6d9cSKip Macy memcpy(buf + (offset & 3), data, len); 2520ac3a6d9cSKip Macy } else 2521ac3a6d9cSKip Macy buf = (uint8_t *)(uintptr_t)data; 2522ac3a6d9cSKip Macy 2523ac3a6d9cSKip Macy err = t3_seeprom_wp(adapter, 0); 2524ac3a6d9cSKip Macy if (err) 2525ac3a6d9cSKip Macy goto out; 2526ac3a6d9cSKip Macy 2527ac3a6d9cSKip Macy for (p = (u32 *)buf; !err && aligned_len; aligned_len -= 4, p++) { 2528ac3a6d9cSKip Macy err = t3_seeprom_write(adapter, aligned_offset, *p); 2529ac3a6d9cSKip Macy aligned_offset += 4; 2530ac3a6d9cSKip Macy } 2531ac3a6d9cSKip Macy 2532ac3a6d9cSKip Macy if (!err) 2533ac3a6d9cSKip Macy err = t3_seeprom_wp(adapter, 1); 2534ac3a6d9cSKip Macy out: 2535ac3a6d9cSKip Macy if (buf != data) 2536ac3a6d9cSKip Macy free(buf, M_DEVBUF); 2537ac3a6d9cSKip Macy return err; 2538ac3a6d9cSKip Macy } 2539ac3a6d9cSKip Macy 2540ac3a6d9cSKip Macy 2541b6d90eb7SKip Macy static int 2542b6d90eb7SKip Macy in_range(int val, int lo, int hi) 2543b6d90eb7SKip Macy { 2544b6d90eb7SKip Macy return val < 0 || (val <= hi && val >= lo); 2545b6d90eb7SKip Macy } 2546b6d90eb7SKip Macy 2547b6d90eb7SKip Macy static int 254800b4e54aSWarner Losh cxgb_extension_open(struct cdev *dev, int flags, int fmp, struct thread *td) 2549ef72318fSKip Macy { 2550ef72318fSKip Macy return (0); 2551ef72318fSKip Macy } 2552ef72318fSKip Macy 2553ef72318fSKip Macy static int 255400b4e54aSWarner Losh cxgb_extension_close(struct cdev *dev, int flags, int fmt, struct thread *td) 2555ef72318fSKip Macy { 2556ef72318fSKip Macy return (0); 2557ef72318fSKip Macy } 2558ef72318fSKip Macy 2559ef72318fSKip Macy static int 2560b6d90eb7SKip Macy cxgb_extension_ioctl(struct cdev *dev, unsigned long cmd, caddr_t data, 2561b6d90eb7SKip Macy int fflag, struct thread *td) 2562b6d90eb7SKip Macy { 2563b6d90eb7SKip Macy int mmd, error = 0; 2564b6d90eb7SKip Macy struct port_info *pi = dev->si_drv1; 2565b6d90eb7SKip Macy adapter_t *sc = pi->adapter; 2566b6d90eb7SKip Macy 2567b6d90eb7SKip Macy #ifdef PRIV_SUPPORTED 2568b6d90eb7SKip Macy if (priv_check(td, PRIV_DRIVER)) { 2569b6d90eb7SKip Macy if (cxgb_debug) 2570b6d90eb7SKip Macy printf("user does not have access to privileged ioctls\n"); 2571b6d90eb7SKip Macy return (EPERM); 2572b6d90eb7SKip Macy } 2573b6d90eb7SKip Macy #else 2574b6d90eb7SKip Macy if (suser(td)) { 2575b6d90eb7SKip Macy if (cxgb_debug) 2576b6d90eb7SKip Macy printf("user does not have access to privileged ioctls\n"); 2577b6d90eb7SKip Macy return (EPERM); 2578b6d90eb7SKip Macy } 2579b6d90eb7SKip Macy #endif 2580b6d90eb7SKip Macy 2581b6d90eb7SKip Macy switch (cmd) { 25821ffd6e58SKip Macy case CHELSIO_GET_MIIREG: { 2583b6d90eb7SKip Macy uint32_t val; 2584b6d90eb7SKip Macy struct cphy *phy = &pi->phy; 25851ffd6e58SKip Macy struct ch_mii_data *mid = (struct ch_mii_data *)data; 2586b6d90eb7SKip Macy 2587b6d90eb7SKip Macy if (!phy->mdio_read) 2588b6d90eb7SKip Macy return (EOPNOTSUPP); 2589b6d90eb7SKip Macy if (is_10G(sc)) { 2590b6d90eb7SKip Macy mmd = mid->phy_id >> 8; 2591b6d90eb7SKip Macy if (!mmd) 2592b6d90eb7SKip Macy mmd = MDIO_DEV_PCS; 25930c1ff9c6SGeorge V. Neville-Neil else if (mmd > MDIO_DEV_VEND2) 2594ac3a6d9cSKip Macy return (EINVAL); 2595b6d90eb7SKip Macy 2596b6d90eb7SKip Macy error = phy->mdio_read(sc, mid->phy_id & 0x1f, mmd, 2597b6d90eb7SKip Macy mid->reg_num, &val); 2598b6d90eb7SKip Macy } else 2599b6d90eb7SKip Macy error = phy->mdio_read(sc, mid->phy_id & 0x1f, 0, 2600b6d90eb7SKip Macy mid->reg_num & 0x1f, &val); 2601b6d90eb7SKip Macy if (error == 0) 2602b6d90eb7SKip Macy mid->val_out = val; 2603b6d90eb7SKip Macy break; 2604b6d90eb7SKip Macy } 26051ffd6e58SKip Macy case CHELSIO_SET_MIIREG: { 2606b6d90eb7SKip Macy struct cphy *phy = &pi->phy; 26071ffd6e58SKip Macy struct ch_mii_data *mid = (struct ch_mii_data *)data; 2608b6d90eb7SKip Macy 2609b6d90eb7SKip Macy if (!phy->mdio_write) 2610b6d90eb7SKip Macy return (EOPNOTSUPP); 2611b6d90eb7SKip Macy if (is_10G(sc)) { 2612b6d90eb7SKip Macy mmd = mid->phy_id >> 8; 2613b6d90eb7SKip Macy if (!mmd) 2614b6d90eb7SKip Macy mmd = MDIO_DEV_PCS; 26150c1ff9c6SGeorge V. Neville-Neil else if (mmd > MDIO_DEV_VEND2) 2616b6d90eb7SKip Macy return (EINVAL); 2617b6d90eb7SKip Macy 2618b6d90eb7SKip Macy error = phy->mdio_write(sc, mid->phy_id & 0x1f, 2619b6d90eb7SKip Macy mmd, mid->reg_num, mid->val_in); 2620b6d90eb7SKip Macy } else 2621b6d90eb7SKip Macy error = phy->mdio_write(sc, mid->phy_id & 0x1f, 0, 2622b6d90eb7SKip Macy mid->reg_num & 0x1f, 2623b6d90eb7SKip Macy mid->val_in); 2624b6d90eb7SKip Macy break; 2625b6d90eb7SKip Macy } 2626b6d90eb7SKip Macy case CHELSIO_SETREG: { 2627b6d90eb7SKip Macy struct ch_reg *edata = (struct ch_reg *)data; 2628b6d90eb7SKip Macy if ((edata->addr & 0x3) != 0 || edata->addr >= sc->mmio_len) 2629b6d90eb7SKip Macy return (EFAULT); 2630b6d90eb7SKip Macy t3_write_reg(sc, edata->addr, edata->val); 2631b6d90eb7SKip Macy break; 2632b6d90eb7SKip Macy } 2633b6d90eb7SKip Macy case CHELSIO_GETREG: { 2634b6d90eb7SKip Macy struct ch_reg *edata = (struct ch_reg *)data; 2635b6d90eb7SKip Macy if ((edata->addr & 0x3) != 0 || edata->addr >= sc->mmio_len) 2636b6d90eb7SKip Macy return (EFAULT); 2637b6d90eb7SKip Macy edata->val = t3_read_reg(sc, edata->addr); 2638b6d90eb7SKip Macy break; 2639b6d90eb7SKip Macy } 2640b6d90eb7SKip Macy case CHELSIO_GET_SGE_CONTEXT: { 2641b6d90eb7SKip Macy struct ch_cntxt *ecntxt = (struct ch_cntxt *)data; 26428e10660fSKip Macy mtx_lock_spin(&sc->sge.reg_lock); 2643b6d90eb7SKip Macy switch (ecntxt->cntxt_type) { 2644b6d90eb7SKip Macy case CNTXT_TYPE_EGRESS: 26451ffd6e58SKip Macy error = -t3_sge_read_ecntxt(sc, ecntxt->cntxt_id, 2646b6d90eb7SKip Macy ecntxt->data); 2647b6d90eb7SKip Macy break; 2648b6d90eb7SKip Macy case CNTXT_TYPE_FL: 26491ffd6e58SKip Macy error = -t3_sge_read_fl(sc, ecntxt->cntxt_id, 2650b6d90eb7SKip Macy ecntxt->data); 2651b6d90eb7SKip Macy break; 2652b6d90eb7SKip Macy case CNTXT_TYPE_RSP: 26531ffd6e58SKip Macy error = -t3_sge_read_rspq(sc, ecntxt->cntxt_id, 2654b6d90eb7SKip Macy ecntxt->data); 2655b6d90eb7SKip Macy break; 2656b6d90eb7SKip Macy case CNTXT_TYPE_CQ: 26571ffd6e58SKip Macy error = -t3_sge_read_cq(sc, ecntxt->cntxt_id, 2658b6d90eb7SKip Macy ecntxt->data); 2659b6d90eb7SKip Macy break; 2660b6d90eb7SKip Macy default: 2661b6d90eb7SKip Macy error = EINVAL; 2662b6d90eb7SKip Macy break; 2663b6d90eb7SKip Macy } 26648e10660fSKip Macy mtx_unlock_spin(&sc->sge.reg_lock); 2665b6d90eb7SKip Macy break; 2666b6d90eb7SKip Macy } 2667b6d90eb7SKip Macy case CHELSIO_GET_SGE_DESC: { 2668b6d90eb7SKip Macy struct ch_desc *edesc = (struct ch_desc *)data; 2669b6d90eb7SKip Macy int ret; 2670b6d90eb7SKip Macy if (edesc->queue_num >= SGE_QSETS * 6) 2671b6d90eb7SKip Macy return (EINVAL); 2672b6d90eb7SKip Macy ret = t3_get_desc(&sc->sge.qs[edesc->queue_num / 6], 2673b6d90eb7SKip Macy edesc->queue_num % 6, edesc->idx, edesc->data); 2674b6d90eb7SKip Macy if (ret < 0) 2675b6d90eb7SKip Macy return (EINVAL); 2676b6d90eb7SKip Macy edesc->size = ret; 2677b6d90eb7SKip Macy break; 2678b6d90eb7SKip Macy } 2679b6d90eb7SKip Macy case CHELSIO_GET_QSET_PARAMS: { 2680b6d90eb7SKip Macy struct qset_params *q; 2681b6d90eb7SKip Macy struct ch_qset_params *t = (struct ch_qset_params *)data; 26821ffd6e58SKip Macy int q1 = pi->first_qset; 26831ffd6e58SKip Macy int nqsets = pi->nqsets; 26841ffd6e58SKip Macy int i; 2685b6d90eb7SKip Macy 26861ffd6e58SKip Macy if (t->qset_idx >= nqsets) 26871ffd6e58SKip Macy return EINVAL; 2688b6d90eb7SKip Macy 26891ffd6e58SKip Macy i = q1 + t->qset_idx; 26901ffd6e58SKip Macy q = &sc->params.sge.qset[i]; 2691b6d90eb7SKip Macy t->rspq_size = q->rspq_size; 2692b6d90eb7SKip Macy t->txq_size[0] = q->txq_size[0]; 2693b6d90eb7SKip Macy t->txq_size[1] = q->txq_size[1]; 2694b6d90eb7SKip Macy t->txq_size[2] = q->txq_size[2]; 2695b6d90eb7SKip Macy t->fl_size[0] = q->fl_size; 2696b6d90eb7SKip Macy t->fl_size[1] = q->jumbo_size; 2697b6d90eb7SKip Macy t->polling = q->polling; 26981ffd6e58SKip Macy t->lro = q->lro; 26994af83c8cSKip Macy t->intr_lat = q->coalesce_usecs; 2700b6d90eb7SKip Macy t->cong_thres = q->cong_thres; 27011ffd6e58SKip Macy t->qnum = i; 2702b6d90eb7SKip Macy 27031d609d51SNavdeep Parhar if ((sc->flags & FULL_INIT_DONE) == 0) 27041d609d51SNavdeep Parhar t->vector = 0; 27051d609d51SNavdeep Parhar else if (sc->flags & USING_MSIX) 27061ffd6e58SKip Macy t->vector = rman_get_start(sc->msix_irq_res[i]); 27071ffd6e58SKip Macy else 27081ffd6e58SKip Macy t->vector = rman_get_start(sc->irq_res); 27091ffd6e58SKip Macy 2710b6d90eb7SKip Macy break; 2711b6d90eb7SKip Macy } 2712b6d90eb7SKip Macy case CHELSIO_GET_QSET_NUM: { 2713b6d90eb7SKip Macy struct ch_reg *edata = (struct ch_reg *)data; 2714b6d90eb7SKip Macy edata->val = pi->nqsets; 2715b6d90eb7SKip Macy break; 2716b6d90eb7SKip Macy } 27171ffd6e58SKip Macy case CHELSIO_LOAD_FW: { 27181ffd6e58SKip Macy uint8_t *fw_data; 27191ffd6e58SKip Macy uint32_t vers; 27201ffd6e58SKip Macy struct ch_mem_range *t = (struct ch_mem_range *)data; 27211ffd6e58SKip Macy 27221ffd6e58SKip Macy /* 27231ffd6e58SKip Macy * You're allowed to load a firmware only before FULL_INIT_DONE 27241ffd6e58SKip Macy * 27251ffd6e58SKip Macy * FW_UPTODATE is also set so the rest of the initialization 27261ffd6e58SKip Macy * will not overwrite what was loaded here. This gives you the 27271ffd6e58SKip Macy * flexibility to load any firmware (and maybe shoot yourself in 27281ffd6e58SKip Macy * the foot). 27291ffd6e58SKip Macy */ 27301ffd6e58SKip Macy 27311ffd6e58SKip Macy ADAPTER_LOCK(sc); 27321ffd6e58SKip Macy if (sc->open_device_map || sc->flags & FULL_INIT_DONE) { 27331ffd6e58SKip Macy ADAPTER_UNLOCK(sc); 27341ffd6e58SKip Macy return (EBUSY); 27351ffd6e58SKip Macy } 27361ffd6e58SKip Macy 27371ffd6e58SKip Macy fw_data = malloc(t->len, M_DEVBUF, M_NOWAIT); 27381ffd6e58SKip Macy if (!fw_data) 27391ffd6e58SKip Macy error = ENOMEM; 27401ffd6e58SKip Macy else 27411ffd6e58SKip Macy error = copyin(t->buf, fw_data, t->len); 27421ffd6e58SKip Macy 27431ffd6e58SKip Macy if (!error) 27441ffd6e58SKip Macy error = -t3_load_fw(sc, fw_data, t->len); 27451ffd6e58SKip Macy 27461ffd6e58SKip Macy if (t3_get_fw_version(sc, &vers) == 0) { 27471ffd6e58SKip Macy snprintf(&sc->fw_version[0], sizeof(sc->fw_version), 27481ffd6e58SKip Macy "%d.%d.%d", G_FW_VERSION_MAJOR(vers), 27491ffd6e58SKip Macy G_FW_VERSION_MINOR(vers), G_FW_VERSION_MICRO(vers)); 27501ffd6e58SKip Macy } 27511ffd6e58SKip Macy 27521ffd6e58SKip Macy if (!error) 27531ffd6e58SKip Macy sc->flags |= FW_UPTODATE; 27541ffd6e58SKip Macy 27551ffd6e58SKip Macy free(fw_data, M_DEVBUF); 27561ffd6e58SKip Macy ADAPTER_UNLOCK(sc); 2757b6d90eb7SKip Macy break; 27581ffd6e58SKip Macy } 27591ffd6e58SKip Macy case CHELSIO_LOAD_BOOT: { 27601ffd6e58SKip Macy uint8_t *boot_data; 27611ffd6e58SKip Macy struct ch_mem_range *t = (struct ch_mem_range *)data; 27621ffd6e58SKip Macy 27631ffd6e58SKip Macy boot_data = malloc(t->len, M_DEVBUF, M_NOWAIT); 27641ffd6e58SKip Macy if (!boot_data) 27651ffd6e58SKip Macy return ENOMEM; 27661ffd6e58SKip Macy 27671ffd6e58SKip Macy error = copyin(t->buf, boot_data, t->len); 27681ffd6e58SKip Macy if (!error) 27691ffd6e58SKip Macy error = -t3_load_boot(sc, boot_data, t->len); 27701ffd6e58SKip Macy 27711ffd6e58SKip Macy free(boot_data, M_DEVBUF); 27721ffd6e58SKip Macy break; 27731ffd6e58SKip Macy } 27741ffd6e58SKip Macy case CHELSIO_GET_PM: { 27751ffd6e58SKip Macy struct ch_pm *m = (struct ch_pm *)data; 27761ffd6e58SKip Macy struct tp_params *p = &sc->params.tp; 27771ffd6e58SKip Macy 27781ffd6e58SKip Macy if (!is_offload(sc)) 27791ffd6e58SKip Macy return (EOPNOTSUPP); 27801ffd6e58SKip Macy 27811ffd6e58SKip Macy m->tx_pg_sz = p->tx_pg_size; 27821ffd6e58SKip Macy m->tx_num_pg = p->tx_num_pgs; 27831ffd6e58SKip Macy m->rx_pg_sz = p->rx_pg_size; 27841ffd6e58SKip Macy m->rx_num_pg = p->rx_num_pgs; 27851ffd6e58SKip Macy m->pm_total = p->pmtx_size + p->chan_rx_size * p->nchan; 27861ffd6e58SKip Macy 27871ffd6e58SKip Macy break; 27881ffd6e58SKip Macy } 27891ffd6e58SKip Macy case CHELSIO_SET_PM: { 27901ffd6e58SKip Macy struct ch_pm *m = (struct ch_pm *)data; 27911ffd6e58SKip Macy struct tp_params *p = &sc->params.tp; 27921ffd6e58SKip Macy 27931ffd6e58SKip Macy if (!is_offload(sc)) 27941ffd6e58SKip Macy return (EOPNOTSUPP); 27951ffd6e58SKip Macy if (sc->flags & FULL_INIT_DONE) 27961ffd6e58SKip Macy return (EBUSY); 27971ffd6e58SKip Macy 27981ffd6e58SKip Macy if (!m->rx_pg_sz || (m->rx_pg_sz & (m->rx_pg_sz - 1)) || 27991ffd6e58SKip Macy !m->tx_pg_sz || (m->tx_pg_sz & (m->tx_pg_sz - 1))) 28001ffd6e58SKip Macy return (EINVAL); /* not power of 2 */ 28011ffd6e58SKip Macy if (!(m->rx_pg_sz & 0x14000)) 28021ffd6e58SKip Macy return (EINVAL); /* not 16KB or 64KB */ 28031ffd6e58SKip Macy if (!(m->tx_pg_sz & 0x1554000)) 28041ffd6e58SKip Macy return (EINVAL); 28051ffd6e58SKip Macy if (m->tx_num_pg == -1) 28061ffd6e58SKip Macy m->tx_num_pg = p->tx_num_pgs; 28071ffd6e58SKip Macy if (m->rx_num_pg == -1) 28081ffd6e58SKip Macy m->rx_num_pg = p->rx_num_pgs; 28091ffd6e58SKip Macy if (m->tx_num_pg % 24 || m->rx_num_pg % 24) 28101ffd6e58SKip Macy return (EINVAL); 28111ffd6e58SKip Macy if (m->rx_num_pg * m->rx_pg_sz > p->chan_rx_size || 28121ffd6e58SKip Macy m->tx_num_pg * m->tx_pg_sz > p->chan_tx_size) 28131ffd6e58SKip Macy return (EINVAL); 28141ffd6e58SKip Macy 28151ffd6e58SKip Macy p->rx_pg_size = m->rx_pg_sz; 28161ffd6e58SKip Macy p->tx_pg_size = m->tx_pg_sz; 28171ffd6e58SKip Macy p->rx_num_pgs = m->rx_num_pg; 28181ffd6e58SKip Macy p->tx_num_pgs = m->tx_num_pg; 28191ffd6e58SKip Macy break; 28201ffd6e58SKip Macy } 2821d722cab4SKip Macy case CHELSIO_SETMTUTAB: { 2822d722cab4SKip Macy struct ch_mtus *m = (struct ch_mtus *)data; 2823d722cab4SKip Macy int i; 2824d722cab4SKip Macy 2825d722cab4SKip Macy if (!is_offload(sc)) 2826d722cab4SKip Macy return (EOPNOTSUPP); 2827d722cab4SKip Macy if (offload_running(sc)) 2828d722cab4SKip Macy return (EBUSY); 2829d722cab4SKip Macy if (m->nmtus != NMTUS) 2830d722cab4SKip Macy return (EINVAL); 2831d722cab4SKip Macy if (m->mtus[0] < 81) /* accommodate SACK */ 2832d722cab4SKip Macy return (EINVAL); 2833d722cab4SKip Macy 2834d722cab4SKip Macy /* 2835d722cab4SKip Macy * MTUs must be in ascending order 2836d722cab4SKip Macy */ 2837d722cab4SKip Macy for (i = 1; i < NMTUS; ++i) 2838d722cab4SKip Macy if (m->mtus[i] < m->mtus[i - 1]) 2839d722cab4SKip Macy return (EINVAL); 2840d722cab4SKip Macy 28411ffd6e58SKip Macy memcpy(sc->params.mtus, m->mtus, sizeof(sc->params.mtus)); 2842d722cab4SKip Macy break; 2843d722cab4SKip Macy } 2844d722cab4SKip Macy case CHELSIO_GETMTUTAB: { 2845d722cab4SKip Macy struct ch_mtus *m = (struct ch_mtus *)data; 2846d722cab4SKip Macy 2847d722cab4SKip Macy if (!is_offload(sc)) 2848d722cab4SKip Macy return (EOPNOTSUPP); 2849d722cab4SKip Macy 2850d722cab4SKip Macy memcpy(m->mtus, sc->params.mtus, sizeof(m->mtus)); 2851d722cab4SKip Macy m->nmtus = NMTUS; 2852d722cab4SKip Macy break; 2853d722cab4SKip Macy } 2854b6d90eb7SKip Macy case CHELSIO_GET_MEM: { 2855b6d90eb7SKip Macy struct ch_mem_range *t = (struct ch_mem_range *)data; 2856b6d90eb7SKip Macy struct mc7 *mem; 2857b6d90eb7SKip Macy uint8_t *useraddr; 2858b6d90eb7SKip Macy u64 buf[32]; 2859b6d90eb7SKip Macy 28601ffd6e58SKip Macy /* 28611ffd6e58SKip Macy * Use these to avoid modifying len/addr in the the return 28621ffd6e58SKip Macy * struct 28631ffd6e58SKip Macy */ 28641ffd6e58SKip Macy uint32_t len = t->len, addr = t->addr; 28651ffd6e58SKip Macy 2866b6d90eb7SKip Macy if (!is_offload(sc)) 2867b6d90eb7SKip Macy return (EOPNOTSUPP); 2868b6d90eb7SKip Macy if (!(sc->flags & FULL_INIT_DONE)) 2869b6d90eb7SKip Macy return (EIO); /* need the memory controllers */ 28701ffd6e58SKip Macy if ((addr & 0x7) || (len & 0x7)) 2871b6d90eb7SKip Macy return (EINVAL); 2872b6d90eb7SKip Macy if (t->mem_id == MEM_CM) 2873b6d90eb7SKip Macy mem = &sc->cm; 2874b6d90eb7SKip Macy else if (t->mem_id == MEM_PMRX) 2875b6d90eb7SKip Macy mem = &sc->pmrx; 2876b6d90eb7SKip Macy else if (t->mem_id == MEM_PMTX) 2877b6d90eb7SKip Macy mem = &sc->pmtx; 2878b6d90eb7SKip Macy else 2879b6d90eb7SKip Macy return (EINVAL); 2880b6d90eb7SKip Macy 2881b6d90eb7SKip Macy /* 2882b6d90eb7SKip Macy * Version scheme: 2883b6d90eb7SKip Macy * bits 0..9: chip version 2884b6d90eb7SKip Macy * bits 10..15: chip revision 2885b6d90eb7SKip Macy */ 2886b6d90eb7SKip Macy t->version = 3 | (sc->params.rev << 10); 2887b6d90eb7SKip Macy 2888b6d90eb7SKip Macy /* 2889b6d90eb7SKip Macy * Read 256 bytes at a time as len can be large and we don't 2890b6d90eb7SKip Macy * want to use huge intermediate buffers. 2891b6d90eb7SKip Macy */ 28928090c9f5SKip Macy useraddr = (uint8_t *)t->buf; 28931ffd6e58SKip Macy while (len) { 28941ffd6e58SKip Macy unsigned int chunk = min(len, sizeof(buf)); 2895b6d90eb7SKip Macy 28961ffd6e58SKip Macy error = t3_mc7_bd_read(mem, addr / 8, chunk / 8, buf); 2897b6d90eb7SKip Macy if (error) 2898b6d90eb7SKip Macy return (-error); 2899b6d90eb7SKip Macy if (copyout(buf, useraddr, chunk)) 2900b6d90eb7SKip Macy return (EFAULT); 2901b6d90eb7SKip Macy useraddr += chunk; 29021ffd6e58SKip Macy addr += chunk; 29031ffd6e58SKip Macy len -= chunk; 2904b6d90eb7SKip Macy } 2905b6d90eb7SKip Macy break; 2906b6d90eb7SKip Macy } 2907d722cab4SKip Macy case CHELSIO_READ_TCAM_WORD: { 2908d722cab4SKip Macy struct ch_tcam_word *t = (struct ch_tcam_word *)data; 2909d722cab4SKip Macy 2910d722cab4SKip Macy if (!is_offload(sc)) 2911d722cab4SKip Macy return (EOPNOTSUPP); 2912ac3a6d9cSKip Macy if (!(sc->flags & FULL_INIT_DONE)) 2913ac3a6d9cSKip Macy return (EIO); /* need MC5 */ 2914d722cab4SKip Macy return -t3_read_mc5_range(&sc->mc5, t->addr, 1, t->buf); 2915d722cab4SKip Macy break; 2916d722cab4SKip Macy } 2917b6d90eb7SKip Macy case CHELSIO_SET_TRACE_FILTER: { 2918b6d90eb7SKip Macy struct ch_trace *t = (struct ch_trace *)data; 2919b6d90eb7SKip Macy const struct trace_params *tp; 2920b6d90eb7SKip Macy 2921b6d90eb7SKip Macy tp = (const struct trace_params *)&t->sip; 2922b6d90eb7SKip Macy if (t->config_tx) 2923b6d90eb7SKip Macy t3_config_trace_filter(sc, tp, 0, t->invert_match, 2924b6d90eb7SKip Macy t->trace_tx); 2925b6d90eb7SKip Macy if (t->config_rx) 2926b6d90eb7SKip Macy t3_config_trace_filter(sc, tp, 1, t->invert_match, 2927b6d90eb7SKip Macy t->trace_rx); 2928b6d90eb7SKip Macy break; 2929b6d90eb7SKip Macy } 2930b6d90eb7SKip Macy case CHELSIO_SET_PKTSCHED: { 2931b6d90eb7SKip Macy struct ch_pktsched_params *p = (struct ch_pktsched_params *)data; 2932b6d90eb7SKip Macy if (sc->open_device_map == 0) 2933b6d90eb7SKip Macy return (EAGAIN); 2934b6d90eb7SKip Macy send_pktsched_cmd(sc, p->sched, p->idx, p->min, p->max, 2935b6d90eb7SKip Macy p->binding); 2936b6d90eb7SKip Macy break; 2937b6d90eb7SKip Macy } 2938b6d90eb7SKip Macy case CHELSIO_IFCONF_GETREGS: { 29391ffd6e58SKip Macy struct ch_ifconf_regs *regs = (struct ch_ifconf_regs *)data; 2940b6d90eb7SKip Macy int reglen = cxgb_get_regs_len(); 29411ffd6e58SKip Macy uint8_t *buf = malloc(reglen, M_DEVBUF, M_NOWAIT); 2942b6d90eb7SKip Macy if (buf == NULL) { 2943b6d90eb7SKip Macy return (ENOMEM); 2944b6d90eb7SKip Macy } 29451ffd6e58SKip Macy if (regs->len > reglen) 29461ffd6e58SKip Macy regs->len = reglen; 29471ffd6e58SKip Macy else if (regs->len < reglen) 2948f2d8ff04SGeorge V. Neville-Neil error = ENOBUFS; 29491ffd6e58SKip Macy 29501ffd6e58SKip Macy if (!error) { 2951b6d90eb7SKip Macy cxgb_get_regs(sc, regs, buf); 2952b6d90eb7SKip Macy error = copyout(buf, regs->data, reglen); 29531ffd6e58SKip Macy } 2954b6d90eb7SKip Macy free(buf, M_DEVBUF); 2955b6d90eb7SKip Macy 2956b6d90eb7SKip Macy break; 2957b6d90eb7SKip Macy } 2958d722cab4SKip Macy case CHELSIO_SET_HW_SCHED: { 2959d722cab4SKip Macy struct ch_hw_sched *t = (struct ch_hw_sched *)data; 2960d722cab4SKip Macy unsigned int ticks_per_usec = core_ticks_per_usec(sc); 2961d722cab4SKip Macy 2962d722cab4SKip Macy if ((sc->flags & FULL_INIT_DONE) == 0) 2963d722cab4SKip Macy return (EAGAIN); /* need TP to be initialized */ 2964d722cab4SKip Macy if (t->sched >= NTX_SCHED || !in_range(t->mode, 0, 1) || 2965d722cab4SKip Macy !in_range(t->channel, 0, 1) || 2966d722cab4SKip Macy !in_range(t->kbps, 0, 10000000) || 2967d722cab4SKip Macy !in_range(t->class_ipg, 0, 10000 * 65535 / ticks_per_usec) || 2968d722cab4SKip Macy !in_range(t->flow_ipg, 0, 2969d722cab4SKip Macy dack_ticks_to_usec(sc, 0x7ff))) 2970d722cab4SKip Macy return (EINVAL); 2971d722cab4SKip Macy 2972d722cab4SKip Macy if (t->kbps >= 0) { 2973d722cab4SKip Macy error = t3_config_sched(sc, t->kbps, t->sched); 2974d722cab4SKip Macy if (error < 0) 2975d722cab4SKip Macy return (-error); 2976d722cab4SKip Macy } 2977d722cab4SKip Macy if (t->class_ipg >= 0) 2978d722cab4SKip Macy t3_set_sched_ipg(sc, t->sched, t->class_ipg); 2979d722cab4SKip Macy if (t->flow_ipg >= 0) { 2980d722cab4SKip Macy t->flow_ipg *= 1000; /* us -> ns */ 2981d722cab4SKip Macy t3_set_pace_tbl(sc, &t->flow_ipg, t->sched, 1); 2982d722cab4SKip Macy } 2983d722cab4SKip Macy if (t->mode >= 0) { 2984d722cab4SKip Macy int bit = 1 << (S_TX_MOD_TIMER_MODE + t->sched); 2985d722cab4SKip Macy 2986d722cab4SKip Macy t3_set_reg_field(sc, A_TP_TX_MOD_QUEUE_REQ_MAP, 2987d722cab4SKip Macy bit, t->mode ? bit : 0); 2988d722cab4SKip Macy } 2989d722cab4SKip Macy if (t->channel >= 0) 2990d722cab4SKip Macy t3_set_reg_field(sc, A_TP_TX_MOD_QUEUE_REQ_MAP, 2991d722cab4SKip Macy 1 << t->sched, t->channel << t->sched); 2992d722cab4SKip Macy break; 2993d722cab4SKip Macy } 29941ffd6e58SKip Macy case CHELSIO_GET_EEPROM: { 29951ffd6e58SKip Macy int i; 29961ffd6e58SKip Macy struct ch_eeprom *e = (struct ch_eeprom *)data; 29971ffd6e58SKip Macy uint8_t *buf = malloc(EEPROMSIZE, M_DEVBUF, M_NOWAIT); 29981ffd6e58SKip Macy 29991ffd6e58SKip Macy if (buf == NULL) { 30001ffd6e58SKip Macy return (ENOMEM); 30011ffd6e58SKip Macy } 30021ffd6e58SKip Macy e->magic = EEPROM_MAGIC; 30031ffd6e58SKip Macy for (i = e->offset & ~3; !error && i < e->offset + e->len; i += 4) 30041ffd6e58SKip Macy error = -t3_seeprom_read(sc, i, (uint32_t *)&buf[i]); 30051ffd6e58SKip Macy 30061ffd6e58SKip Macy if (!error) 30071ffd6e58SKip Macy error = copyout(buf + e->offset, e->data, e->len); 30081ffd6e58SKip Macy 30091ffd6e58SKip Macy free(buf, M_DEVBUF); 30101ffd6e58SKip Macy break; 30111ffd6e58SKip Macy } 30121ffd6e58SKip Macy case CHELSIO_CLEAR_STATS: { 30131ffd6e58SKip Macy if (!(sc->flags & FULL_INIT_DONE)) 30141ffd6e58SKip Macy return EAGAIN; 30151ffd6e58SKip Macy 30161ffd6e58SKip Macy PORT_LOCK(pi); 30171ffd6e58SKip Macy t3_mac_update_stats(&pi->mac); 30181ffd6e58SKip Macy memset(&pi->mac.stats, 0, sizeof(pi->mac.stats)); 30191ffd6e58SKip Macy PORT_UNLOCK(pi); 30201ffd6e58SKip Macy break; 30211ffd6e58SKip Macy } 3022f2d8ff04SGeorge V. Neville-Neil case CHELSIO_GET_UP_LA: { 3023f2d8ff04SGeorge V. Neville-Neil struct ch_up_la *la = (struct ch_up_la *)data; 3024f2d8ff04SGeorge V. Neville-Neil uint8_t *buf = malloc(LA_BUFSIZE, M_DEVBUF, M_NOWAIT); 3025f2d8ff04SGeorge V. Neville-Neil if (buf == NULL) { 3026f2d8ff04SGeorge V. Neville-Neil return (ENOMEM); 3027f2d8ff04SGeorge V. Neville-Neil } 3028f2d8ff04SGeorge V. Neville-Neil if (la->bufsize < LA_BUFSIZE) 3029f2d8ff04SGeorge V. Neville-Neil error = ENOBUFS; 3030f2d8ff04SGeorge V. Neville-Neil 3031f2d8ff04SGeorge V. Neville-Neil if (!error) 3032f2d8ff04SGeorge V. Neville-Neil error = -t3_get_up_la(sc, &la->stopped, &la->idx, 3033f2d8ff04SGeorge V. Neville-Neil &la->bufsize, buf); 3034f2d8ff04SGeorge V. Neville-Neil if (!error) 3035f2d8ff04SGeorge V. Neville-Neil error = copyout(buf, la->data, la->bufsize); 3036f2d8ff04SGeorge V. Neville-Neil 3037f2d8ff04SGeorge V. Neville-Neil free(buf, M_DEVBUF); 3038f2d8ff04SGeorge V. Neville-Neil break; 3039f2d8ff04SGeorge V. Neville-Neil } 3040f2d8ff04SGeorge V. Neville-Neil case CHELSIO_GET_UP_IOQS: { 3041f2d8ff04SGeorge V. Neville-Neil struct ch_up_ioqs *ioqs = (struct ch_up_ioqs *)data; 3042f2d8ff04SGeorge V. Neville-Neil uint8_t *buf = malloc(IOQS_BUFSIZE, M_DEVBUF, M_NOWAIT); 3043f2d8ff04SGeorge V. Neville-Neil uint32_t *v; 3044f2d8ff04SGeorge V. Neville-Neil 3045f2d8ff04SGeorge V. Neville-Neil if (buf == NULL) { 3046f2d8ff04SGeorge V. Neville-Neil return (ENOMEM); 3047f2d8ff04SGeorge V. Neville-Neil } 3048f2d8ff04SGeorge V. Neville-Neil if (ioqs->bufsize < IOQS_BUFSIZE) 3049f2d8ff04SGeorge V. Neville-Neil error = ENOBUFS; 3050f2d8ff04SGeorge V. Neville-Neil 3051f2d8ff04SGeorge V. Neville-Neil if (!error) 3052f2d8ff04SGeorge V. Neville-Neil error = -t3_get_up_ioqs(sc, &ioqs->bufsize, buf); 3053f2d8ff04SGeorge V. Neville-Neil 3054f2d8ff04SGeorge V. Neville-Neil if (!error) { 3055f2d8ff04SGeorge V. Neville-Neil v = (uint32_t *)buf; 3056f2d8ff04SGeorge V. Neville-Neil 3057f2d8ff04SGeorge V. Neville-Neil ioqs->ioq_rx_enable = *v++; 3058f2d8ff04SGeorge V. Neville-Neil ioqs->ioq_tx_enable = *v++; 3059f2d8ff04SGeorge V. Neville-Neil ioqs->ioq_rx_status = *v++; 3060f2d8ff04SGeorge V. Neville-Neil ioqs->ioq_tx_status = *v++; 3061f2d8ff04SGeorge V. Neville-Neil 3062f2d8ff04SGeorge V. Neville-Neil error = copyout(v, ioqs->data, ioqs->bufsize); 3063f2d8ff04SGeorge V. Neville-Neil } 3064f2d8ff04SGeorge V. Neville-Neil 3065f2d8ff04SGeorge V. Neville-Neil free(buf, M_DEVBUF); 3066f2d8ff04SGeorge V. Neville-Neil break; 3067f2d8ff04SGeorge V. Neville-Neil } 3068d6da8362SNavdeep Parhar case CHELSIO_SET_FILTER: { 3069d6da8362SNavdeep Parhar struct ch_filter *f = (struct ch_filter *)data;; 3070d6da8362SNavdeep Parhar struct filter_info *p; 3071d6da8362SNavdeep Parhar unsigned int nfilters = sc->params.mc5.nfilters; 3072d6da8362SNavdeep Parhar 3073d6da8362SNavdeep Parhar if (!is_offload(sc)) 3074d6da8362SNavdeep Parhar return (EOPNOTSUPP); /* No TCAM */ 3075d6da8362SNavdeep Parhar if (!(sc->flags & FULL_INIT_DONE)) 3076d6da8362SNavdeep Parhar return (EAGAIN); /* mc5 not setup yet */ 3077d6da8362SNavdeep Parhar if (nfilters == 0) 3078d6da8362SNavdeep Parhar return (EBUSY); /* TOE will use TCAM */ 3079d6da8362SNavdeep Parhar 3080d6da8362SNavdeep Parhar /* sanity checks */ 3081d6da8362SNavdeep Parhar if (f->filter_id >= nfilters || 3082d6da8362SNavdeep Parhar (f->val.dip && f->mask.dip != 0xffffffff) || 3083d6da8362SNavdeep Parhar (f->val.sport && f->mask.sport != 0xffff) || 3084d6da8362SNavdeep Parhar (f->val.dport && f->mask.dport != 0xffff) || 3085d6da8362SNavdeep Parhar (f->val.vlan && f->mask.vlan != 0xfff) || 3086d6da8362SNavdeep Parhar (f->val.vlan_prio && 3087d6da8362SNavdeep Parhar f->mask.vlan_prio != FILTER_NO_VLAN_PRI) || 3088d6da8362SNavdeep Parhar (f->mac_addr_idx != 0xffff && f->mac_addr_idx > 15) || 3089d6da8362SNavdeep Parhar f->qset >= SGE_QSETS || 3090d6da8362SNavdeep Parhar sc->rrss_map[f->qset] >= RSS_TABLE_SIZE) 3091d6da8362SNavdeep Parhar return (EINVAL); 3092d6da8362SNavdeep Parhar 3093d6da8362SNavdeep Parhar /* Was allocated with M_WAITOK */ 3094d6da8362SNavdeep Parhar KASSERT(sc->filters, ("filter table NULL\n")); 3095d6da8362SNavdeep Parhar 3096d6da8362SNavdeep Parhar p = &sc->filters[f->filter_id]; 3097d6da8362SNavdeep Parhar if (p->locked) 3098d6da8362SNavdeep Parhar return (EPERM); 3099d6da8362SNavdeep Parhar 3100d6da8362SNavdeep Parhar bzero(p, sizeof(*p)); 3101d6da8362SNavdeep Parhar p->sip = f->val.sip; 3102d6da8362SNavdeep Parhar p->sip_mask = f->mask.sip; 3103d6da8362SNavdeep Parhar p->dip = f->val.dip; 3104d6da8362SNavdeep Parhar p->sport = f->val.sport; 3105d6da8362SNavdeep Parhar p->dport = f->val.dport; 3106d6da8362SNavdeep Parhar p->vlan = f->mask.vlan ? f->val.vlan : 0xfff; 3107d6da8362SNavdeep Parhar p->vlan_prio = f->mask.vlan_prio ? (f->val.vlan_prio & 6) : 3108d6da8362SNavdeep Parhar FILTER_NO_VLAN_PRI; 3109d6da8362SNavdeep Parhar p->mac_hit = f->mac_hit; 3110d6da8362SNavdeep Parhar p->mac_vld = f->mac_addr_idx != 0xffff; 3111d6da8362SNavdeep Parhar p->mac_idx = f->mac_addr_idx; 3112d6da8362SNavdeep Parhar p->pkt_type = f->proto; 3113d6da8362SNavdeep Parhar p->report_filter_id = f->want_filter_id; 3114d6da8362SNavdeep Parhar p->pass = f->pass; 3115d6da8362SNavdeep Parhar p->rss = f->rss; 3116d6da8362SNavdeep Parhar p->qset = f->qset; 3117d6da8362SNavdeep Parhar 3118d6da8362SNavdeep Parhar error = set_filter(sc, f->filter_id, p); 3119d6da8362SNavdeep Parhar if (error == 0) 3120d6da8362SNavdeep Parhar p->valid = 1; 3121d6da8362SNavdeep Parhar break; 3122d6da8362SNavdeep Parhar } 3123d6da8362SNavdeep Parhar case CHELSIO_DEL_FILTER: { 3124d6da8362SNavdeep Parhar struct ch_filter *f = (struct ch_filter *)data; 3125d6da8362SNavdeep Parhar struct filter_info *p; 3126d6da8362SNavdeep Parhar unsigned int nfilters = sc->params.mc5.nfilters; 3127d6da8362SNavdeep Parhar 3128d6da8362SNavdeep Parhar if (!is_offload(sc)) 3129d6da8362SNavdeep Parhar return (EOPNOTSUPP); 3130d6da8362SNavdeep Parhar if (!(sc->flags & FULL_INIT_DONE)) 3131d6da8362SNavdeep Parhar return (EAGAIN); 3132d6da8362SNavdeep Parhar if (nfilters == 0 || sc->filters == NULL) 3133d6da8362SNavdeep Parhar return (EINVAL); 3134d6da8362SNavdeep Parhar if (f->filter_id >= nfilters) 3135d6da8362SNavdeep Parhar return (EINVAL); 3136d6da8362SNavdeep Parhar 3137d6da8362SNavdeep Parhar p = &sc->filters[f->filter_id]; 3138d6da8362SNavdeep Parhar if (p->locked) 3139d6da8362SNavdeep Parhar return (EPERM); 3140d6da8362SNavdeep Parhar if (!p->valid) 3141d6da8362SNavdeep Parhar return (EFAULT); /* Read "Bad address" as "Bad index" */ 3142d6da8362SNavdeep Parhar 3143d6da8362SNavdeep Parhar bzero(p, sizeof(*p)); 3144d6da8362SNavdeep Parhar p->sip = p->sip_mask = 0xffffffff; 3145d6da8362SNavdeep Parhar p->vlan = 0xfff; 3146d6da8362SNavdeep Parhar p->vlan_prio = FILTER_NO_VLAN_PRI; 3147d6da8362SNavdeep Parhar p->pkt_type = 1; 3148d6da8362SNavdeep Parhar error = set_filter(sc, f->filter_id, p); 3149d6da8362SNavdeep Parhar break; 3150d6da8362SNavdeep Parhar } 3151d6da8362SNavdeep Parhar case CHELSIO_GET_FILTER: { 3152d6da8362SNavdeep Parhar struct ch_filter *f = (struct ch_filter *)data; 3153d6da8362SNavdeep Parhar struct filter_info *p; 3154d6da8362SNavdeep Parhar unsigned int i, nfilters = sc->params.mc5.nfilters; 3155d6da8362SNavdeep Parhar 3156d6da8362SNavdeep Parhar if (!is_offload(sc)) 3157d6da8362SNavdeep Parhar return (EOPNOTSUPP); 3158d6da8362SNavdeep Parhar if (!(sc->flags & FULL_INIT_DONE)) 3159d6da8362SNavdeep Parhar return (EAGAIN); 3160d6da8362SNavdeep Parhar if (nfilters == 0 || sc->filters == NULL) 3161d6da8362SNavdeep Parhar return (EINVAL); 3162d6da8362SNavdeep Parhar 3163d6da8362SNavdeep Parhar i = f->filter_id == 0xffffffff ? 0 : f->filter_id + 1; 3164d6da8362SNavdeep Parhar for (; i < nfilters; i++) { 3165d6da8362SNavdeep Parhar p = &sc->filters[i]; 3166d6da8362SNavdeep Parhar if (!p->valid) 3167d6da8362SNavdeep Parhar continue; 3168d6da8362SNavdeep Parhar 3169d6da8362SNavdeep Parhar bzero(f, sizeof(*f)); 3170d6da8362SNavdeep Parhar 3171d6da8362SNavdeep Parhar f->filter_id = i; 3172d6da8362SNavdeep Parhar f->val.sip = p->sip; 3173d6da8362SNavdeep Parhar f->mask.sip = p->sip_mask; 3174d6da8362SNavdeep Parhar f->val.dip = p->dip; 3175d6da8362SNavdeep Parhar f->mask.dip = p->dip ? 0xffffffff : 0; 3176d6da8362SNavdeep Parhar f->val.sport = p->sport; 3177d6da8362SNavdeep Parhar f->mask.sport = p->sport ? 0xffff : 0; 3178d6da8362SNavdeep Parhar f->val.dport = p->dport; 3179d6da8362SNavdeep Parhar f->mask.dport = p->dport ? 0xffff : 0; 3180d6da8362SNavdeep Parhar f->val.vlan = p->vlan == 0xfff ? 0 : p->vlan; 3181d6da8362SNavdeep Parhar f->mask.vlan = p->vlan == 0xfff ? 0 : 0xfff; 3182d6da8362SNavdeep Parhar f->val.vlan_prio = p->vlan_prio == FILTER_NO_VLAN_PRI ? 3183d6da8362SNavdeep Parhar 0 : p->vlan_prio; 3184d6da8362SNavdeep Parhar f->mask.vlan_prio = p->vlan_prio == FILTER_NO_VLAN_PRI ? 3185d6da8362SNavdeep Parhar 0 : FILTER_NO_VLAN_PRI; 3186d6da8362SNavdeep Parhar f->mac_hit = p->mac_hit; 3187d6da8362SNavdeep Parhar f->mac_addr_idx = p->mac_vld ? p->mac_idx : 0xffff; 3188d6da8362SNavdeep Parhar f->proto = p->pkt_type; 3189d6da8362SNavdeep Parhar f->want_filter_id = p->report_filter_id; 3190d6da8362SNavdeep Parhar f->pass = p->pass; 3191d6da8362SNavdeep Parhar f->rss = p->rss; 3192d6da8362SNavdeep Parhar f->qset = p->qset; 3193d6da8362SNavdeep Parhar 3194d6da8362SNavdeep Parhar break; 3195d6da8362SNavdeep Parhar } 3196d6da8362SNavdeep Parhar 3197d6da8362SNavdeep Parhar if (i == nfilters) 3198d6da8362SNavdeep Parhar f->filter_id = 0xffffffff; 3199d6da8362SNavdeep Parhar break; 3200d6da8362SNavdeep Parhar } 3201b6d90eb7SKip Macy default: 3202b6d90eb7SKip Macy return (EOPNOTSUPP); 3203b6d90eb7SKip Macy break; 3204b6d90eb7SKip Macy } 3205b6d90eb7SKip Macy 3206b6d90eb7SKip Macy return (error); 3207b6d90eb7SKip Macy } 3208b6d90eb7SKip Macy 3209b6d90eb7SKip Macy static __inline void 3210b6d90eb7SKip Macy reg_block_dump(struct adapter *ap, uint8_t *buf, unsigned int start, 3211b6d90eb7SKip Macy unsigned int end) 3212b6d90eb7SKip Macy { 32131ffd6e58SKip Macy uint32_t *p = (uint32_t *)(buf + start); 3214b6d90eb7SKip Macy 3215b6d90eb7SKip Macy for ( ; start <= end; start += sizeof(uint32_t)) 3216b6d90eb7SKip Macy *p++ = t3_read_reg(ap, start); 3217b6d90eb7SKip Macy } 3218b6d90eb7SKip Macy 3219b6d90eb7SKip Macy #define T3_REGMAP_SIZE (3 * 1024) 3220b6d90eb7SKip Macy static int 3221b6d90eb7SKip Macy cxgb_get_regs_len(void) 3222b6d90eb7SKip Macy { 3223b6d90eb7SKip Macy return T3_REGMAP_SIZE; 3224b6d90eb7SKip Macy } 3225b6d90eb7SKip Macy 3226b6d90eb7SKip Macy static void 32271ffd6e58SKip Macy cxgb_get_regs(adapter_t *sc, struct ch_ifconf_regs *regs, uint8_t *buf) 3228b6d90eb7SKip Macy { 3229b6d90eb7SKip Macy 3230b6d90eb7SKip Macy /* 3231b6d90eb7SKip Macy * Version scheme: 3232b6d90eb7SKip Macy * bits 0..9: chip version 3233b6d90eb7SKip Macy * bits 10..15: chip revision 3234b6d90eb7SKip Macy * bit 31: set for PCIe cards 3235b6d90eb7SKip Macy */ 3236b6d90eb7SKip Macy regs->version = 3 | (sc->params.rev << 10) | (is_pcie(sc) << 31); 3237b6d90eb7SKip Macy 3238b6d90eb7SKip Macy /* 3239b6d90eb7SKip Macy * We skip the MAC statistics registers because they are clear-on-read. 3240b6d90eb7SKip Macy * Also reading multi-register stats would need to synchronize with the 3241b6d90eb7SKip Macy * periodic mac stats accumulation. Hard to justify the complexity. 3242b6d90eb7SKip Macy */ 32431ffd6e58SKip Macy memset(buf, 0, cxgb_get_regs_len()); 3244b6d90eb7SKip Macy reg_block_dump(sc, buf, 0, A_SG_RSPQ_CREDIT_RETURN); 3245b6d90eb7SKip Macy reg_block_dump(sc, buf, A_SG_HI_DRB_HI_THRSH, A_ULPRX_PBL_ULIMIT); 3246b6d90eb7SKip Macy reg_block_dump(sc, buf, A_ULPTX_CONFIG, A_MPS_INT_CAUSE); 3247b6d90eb7SKip Macy reg_block_dump(sc, buf, A_CPL_SWITCH_CNTRL, A_CPL_MAP_TBL_DATA); 3248b6d90eb7SKip Macy reg_block_dump(sc, buf, A_SMB_GLOBAL_TIME_CFG, A_XGM_SERDES_STAT3); 3249b6d90eb7SKip Macy reg_block_dump(sc, buf, A_XGM_SERDES_STATUS0, 3250b6d90eb7SKip Macy XGM_REG(A_XGM_SERDES_STAT3, 1)); 3251b6d90eb7SKip Macy reg_block_dump(sc, buf, XGM_REG(A_XGM_SERDES_STATUS0, 1), 3252b6d90eb7SKip Macy XGM_REG(A_XGM_RX_SPI4_SOP_EOP_CNT, 1)); 3253b6d90eb7SKip Macy } 3254404825a7SKip Macy 3255d6da8362SNavdeep Parhar static int 3256d6da8362SNavdeep Parhar alloc_filters(struct adapter *sc) 3257d6da8362SNavdeep Parhar { 3258d6da8362SNavdeep Parhar struct filter_info *p; 3259d6da8362SNavdeep Parhar unsigned int nfilters = sc->params.mc5.nfilters; 3260d6da8362SNavdeep Parhar 3261d6da8362SNavdeep Parhar if (nfilters == 0) 3262d6da8362SNavdeep Parhar return (0); 3263d6da8362SNavdeep Parhar 3264d6da8362SNavdeep Parhar p = malloc(sizeof(*p) * nfilters, M_DEVBUF, M_WAITOK | M_ZERO); 3265d6da8362SNavdeep Parhar sc->filters = p; 3266d6da8362SNavdeep Parhar 3267d6da8362SNavdeep Parhar p = &sc->filters[nfilters - 1]; 3268d6da8362SNavdeep Parhar p->vlan = 0xfff; 3269d6da8362SNavdeep Parhar p->vlan_prio = FILTER_NO_VLAN_PRI; 3270d6da8362SNavdeep Parhar p->pass = p->rss = p->valid = p->locked = 1; 3271d6da8362SNavdeep Parhar 3272d6da8362SNavdeep Parhar return (0); 3273d6da8362SNavdeep Parhar } 3274d6da8362SNavdeep Parhar 3275d6da8362SNavdeep Parhar static int 3276d6da8362SNavdeep Parhar setup_hw_filters(struct adapter *sc) 3277d6da8362SNavdeep Parhar { 3278d6da8362SNavdeep Parhar int i, rc; 3279d6da8362SNavdeep Parhar unsigned int nfilters = sc->params.mc5.nfilters; 3280d6da8362SNavdeep Parhar 3281d6da8362SNavdeep Parhar if (!sc->filters) 3282d6da8362SNavdeep Parhar return (0); 3283d6da8362SNavdeep Parhar 3284d6da8362SNavdeep Parhar t3_enable_filters(sc); 3285d6da8362SNavdeep Parhar 3286d6da8362SNavdeep Parhar for (i = rc = 0; i < nfilters && !rc; i++) { 3287d6da8362SNavdeep Parhar if (sc->filters[i].locked) 3288d6da8362SNavdeep Parhar rc = set_filter(sc, i, &sc->filters[i]); 3289d6da8362SNavdeep Parhar } 3290d6da8362SNavdeep Parhar 3291d6da8362SNavdeep Parhar return (rc); 3292d6da8362SNavdeep Parhar } 3293d6da8362SNavdeep Parhar 3294d6da8362SNavdeep Parhar static int 3295d6da8362SNavdeep Parhar set_filter(struct adapter *sc, int id, const struct filter_info *f) 3296d6da8362SNavdeep Parhar { 3297d6da8362SNavdeep Parhar int len; 3298d6da8362SNavdeep Parhar struct mbuf *m; 3299d6da8362SNavdeep Parhar struct ulp_txpkt *txpkt; 3300d6da8362SNavdeep Parhar struct work_request_hdr *wr; 3301d6da8362SNavdeep Parhar struct cpl_pass_open_req *oreq; 3302d6da8362SNavdeep Parhar struct cpl_set_tcb_field *sreq; 3303d6da8362SNavdeep Parhar 3304d6da8362SNavdeep Parhar len = sizeof(*wr) + sizeof(*oreq) + 2 * sizeof(*sreq); 3305d6da8362SNavdeep Parhar KASSERT(len <= MHLEN, ("filter request too big for an mbuf")); 3306d6da8362SNavdeep Parhar 3307d6da8362SNavdeep Parhar id += t3_mc5_size(&sc->mc5) - sc->params.mc5.nroutes - 3308d6da8362SNavdeep Parhar sc->params.mc5.nfilters; 3309d6da8362SNavdeep Parhar 3310d6da8362SNavdeep Parhar m = m_gethdr(M_WAITOK, MT_DATA); 3311d6da8362SNavdeep Parhar m->m_len = m->m_pkthdr.len = len; 3312d6da8362SNavdeep Parhar bzero(mtod(m, char *), len); 3313d6da8362SNavdeep Parhar 3314d6da8362SNavdeep Parhar wr = mtod(m, struct work_request_hdr *); 3315d6da8362SNavdeep Parhar wr->wrh_hi = htonl(V_WR_OP(FW_WROPCODE_BYPASS) | F_WR_ATOMIC); 3316d6da8362SNavdeep Parhar 3317d6da8362SNavdeep Parhar oreq = (struct cpl_pass_open_req *)(wr + 1); 3318d6da8362SNavdeep Parhar txpkt = (struct ulp_txpkt *)oreq; 3319d6da8362SNavdeep Parhar txpkt->cmd_dest = htonl(V_ULPTX_CMD(ULP_TXPKT)); 3320d6da8362SNavdeep Parhar txpkt->len = htonl(V_ULPTX_NFLITS(sizeof(*oreq) / 8)); 3321d6da8362SNavdeep Parhar OPCODE_TID(oreq) = htonl(MK_OPCODE_TID(CPL_PASS_OPEN_REQ, id)); 3322d6da8362SNavdeep Parhar oreq->local_port = htons(f->dport); 3323d6da8362SNavdeep Parhar oreq->peer_port = htons(f->sport); 3324d6da8362SNavdeep Parhar oreq->local_ip = htonl(f->dip); 3325d6da8362SNavdeep Parhar oreq->peer_ip = htonl(f->sip); 3326d6da8362SNavdeep Parhar oreq->peer_netmask = htonl(f->sip_mask); 3327d6da8362SNavdeep Parhar oreq->opt0h = 0; 3328d6da8362SNavdeep Parhar oreq->opt0l = htonl(F_NO_OFFLOAD); 3329d6da8362SNavdeep Parhar oreq->opt1 = htonl(V_MAC_MATCH_VALID(f->mac_vld) | 3330d6da8362SNavdeep Parhar V_CONN_POLICY(CPL_CONN_POLICY_FILTER) | 3331d6da8362SNavdeep Parhar V_VLAN_PRI(f->vlan_prio >> 1) | 3332d6da8362SNavdeep Parhar V_VLAN_PRI_VALID(f->vlan_prio != FILTER_NO_VLAN_PRI) | 3333d6da8362SNavdeep Parhar V_PKT_TYPE(f->pkt_type) | V_OPT1_VLAN(f->vlan) | 3334d6da8362SNavdeep Parhar V_MAC_MATCH(f->mac_idx | (f->mac_hit << 4))); 3335d6da8362SNavdeep Parhar 3336d6da8362SNavdeep Parhar sreq = (struct cpl_set_tcb_field *)(oreq + 1); 3337d6da8362SNavdeep Parhar set_tcb_field_ulp(sreq, id, 1, 0x1800808000ULL, 3338d6da8362SNavdeep Parhar (f->report_filter_id << 15) | (1 << 23) | 3339d6da8362SNavdeep Parhar ((u64)f->pass << 35) | ((u64)!f->rss << 36)); 3340d6da8362SNavdeep Parhar set_tcb_field_ulp(sreq + 1, id, 0, 0xffffffff, (2 << 19) | 1); 3341d6da8362SNavdeep Parhar t3_mgmt_tx(sc, m); 3342d6da8362SNavdeep Parhar 3343d6da8362SNavdeep Parhar if (f->pass && !f->rss) { 3344d6da8362SNavdeep Parhar len = sizeof(*sreq); 3345d6da8362SNavdeep Parhar m = m_gethdr(M_WAITOK, MT_DATA); 3346d6da8362SNavdeep Parhar m->m_len = m->m_pkthdr.len = len; 3347d6da8362SNavdeep Parhar bzero(mtod(m, char *), len); 3348d6da8362SNavdeep Parhar sreq = mtod(m, struct cpl_set_tcb_field *); 3349d6da8362SNavdeep Parhar sreq->wr.wrh_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD)); 3350d6da8362SNavdeep Parhar mk_set_tcb_field(sreq, id, 25, 0x3f80000, 3351d6da8362SNavdeep Parhar (u64)sc->rrss_map[f->qset] << 19); 3352d6da8362SNavdeep Parhar t3_mgmt_tx(sc, m); 3353d6da8362SNavdeep Parhar } 3354d6da8362SNavdeep Parhar return 0; 3355d6da8362SNavdeep Parhar } 3356d6da8362SNavdeep Parhar 3357d6da8362SNavdeep Parhar static inline void 3358d6da8362SNavdeep Parhar mk_set_tcb_field(struct cpl_set_tcb_field *req, unsigned int tid, 3359d6da8362SNavdeep Parhar unsigned int word, u64 mask, u64 val) 3360d6da8362SNavdeep Parhar { 3361d6da8362SNavdeep Parhar OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, tid)); 3362d6da8362SNavdeep Parhar req->reply = V_NO_REPLY(1); 3363d6da8362SNavdeep Parhar req->cpu_idx = 0; 3364d6da8362SNavdeep Parhar req->word = htons(word); 3365d6da8362SNavdeep Parhar req->mask = htobe64(mask); 3366d6da8362SNavdeep Parhar req->val = htobe64(val); 3367d6da8362SNavdeep Parhar } 3368d6da8362SNavdeep Parhar 3369d6da8362SNavdeep Parhar static inline void 3370d6da8362SNavdeep Parhar set_tcb_field_ulp(struct cpl_set_tcb_field *req, unsigned int tid, 3371d6da8362SNavdeep Parhar unsigned int word, u64 mask, u64 val) 3372d6da8362SNavdeep Parhar { 3373d6da8362SNavdeep Parhar struct ulp_txpkt *txpkt = (struct ulp_txpkt *)req; 3374d6da8362SNavdeep Parhar 3375d6da8362SNavdeep Parhar txpkt->cmd_dest = htonl(V_ULPTX_CMD(ULP_TXPKT)); 3376d6da8362SNavdeep Parhar txpkt->len = htonl(V_ULPTX_NFLITS(sizeof(*req) / 8)); 3377d6da8362SNavdeep Parhar mk_set_tcb_field(req, tid, word, mask, val); 3378d6da8362SNavdeep Parhar } 3379