1 /************************************************************************** 2 3 Copyright (c) 2007-2009, Chelsio Inc. 4 All rights reserved. 5 6 Redistribution and use in source and binary forms, with or without 7 modification, are permitted provided that the following conditions are met: 8 9 1. Redistributions of source code must retain the above copyright notice, 10 this list of conditions and the following disclaimer. 11 12 2. Neither the name of the Chelsio Corporation nor the names of its 13 contributors may be used to endorse or promote products derived from 14 this software without specific prior written permission. 15 16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 17 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 20 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 POSSIBILITY OF SUCH DAMAGE. 27 28 ***************************************************************************/ 29 30 #include <sys/cdefs.h> 31 __FBSDID("$FreeBSD$"); 32 33 #include <sys/param.h> 34 #include <sys/systm.h> 35 #include <sys/kernel.h> 36 #include <sys/bus.h> 37 #include <sys/module.h> 38 #include <sys/pciio.h> 39 #include <sys/conf.h> 40 #include <machine/bus.h> 41 #include <machine/resource.h> 42 #include <sys/bus_dma.h> 43 #include <sys/ktr.h> 44 #include <sys/rman.h> 45 #include <sys/ioccom.h> 46 #include <sys/mbuf.h> 47 #include <sys/linker.h> 48 #include <sys/firmware.h> 49 #include <sys/socket.h> 50 #include <sys/sockio.h> 51 #include <sys/smp.h> 52 #include <sys/sysctl.h> 53 #include <sys/syslog.h> 54 #include <sys/queue.h> 55 #include <sys/taskqueue.h> 56 #include <sys/proc.h> 57 58 #include <net/bpf.h> 59 #include <net/ethernet.h> 60 #include <net/if.h> 61 #include <net/if_arp.h> 62 #include <net/if_dl.h> 63 #include <net/if_media.h> 64 #include <net/if_types.h> 65 #include <net/if_vlan_var.h> 66 67 #include <netinet/in_systm.h> 68 #include <netinet/in.h> 69 #include <netinet/if_ether.h> 70 #include <netinet/ip.h> 71 #include <netinet/ip.h> 72 #include <netinet/tcp.h> 73 #include <netinet/udp.h> 74 75 #include <dev/pci/pcireg.h> 76 #include <dev/pci/pcivar.h> 77 #include <dev/pci/pci_private.h> 78 79 #include <cxgb_include.h> 80 81 #ifdef PRIV_SUPPORTED 82 #include <sys/priv.h> 83 #endif 84 85 static int cxgb_setup_interrupts(adapter_t *); 86 static void cxgb_teardown_interrupts(adapter_t *); 87 static int cxgb_begin_op(struct port_info *, const char *); 88 static int cxgb_begin_detach(struct port_info *); 89 static int cxgb_end_op(struct port_info *); 90 static void cxgb_init(void *); 91 static int cxgb_init_synchronized(struct port_info *); 92 static int cxgb_uninit_synchronized(struct port_info *); 93 static int cxgb_ioctl(struct ifnet *, unsigned long, caddr_t); 94 static int cxgb_media_change(struct ifnet *); 95 static int cxgb_ifm_type(int); 96 static void cxgb_build_medialist(struct port_info *); 97 static void cxgb_media_status(struct ifnet *, struct ifmediareq *); 98 static int setup_sge_qsets(adapter_t *); 99 static void cxgb_async_intr(void *); 100 static void cxgb_ext_intr_handler(void *, int); 101 static void cxgb_tick_handler(void *, int); 102 static void cxgb_tick(void *); 103 static void setup_rss(adapter_t *sc); 104 105 /* Attachment glue for the PCI controller end of the device. Each port of 106 * the device is attached separately, as defined later. 107 */ 108 static int cxgb_controller_probe(device_t); 109 static int cxgb_controller_attach(device_t); 110 static int cxgb_controller_detach(device_t); 111 static void cxgb_free(struct adapter *); 112 static __inline void reg_block_dump(struct adapter *ap, uint8_t *buf, unsigned int start, 113 unsigned int end); 114 static void cxgb_get_regs(adapter_t *sc, struct ch_ifconf_regs *regs, uint8_t *buf); 115 static int cxgb_get_regs_len(void); 116 static int offload_open(struct port_info *pi); 117 static void touch_bars(device_t dev); 118 static int offload_close(struct t3cdev *tdev); 119 int t3_detect_link_fault(adapter_t *adapter, int port_id); 120 121 static device_method_t cxgb_controller_methods[] = { 122 DEVMETHOD(device_probe, cxgb_controller_probe), 123 DEVMETHOD(device_attach, cxgb_controller_attach), 124 DEVMETHOD(device_detach, cxgb_controller_detach), 125 126 /* bus interface */ 127 DEVMETHOD(bus_print_child, bus_generic_print_child), 128 DEVMETHOD(bus_driver_added, bus_generic_driver_added), 129 130 { 0, 0 } 131 }; 132 133 static driver_t cxgb_controller_driver = { 134 "cxgbc", 135 cxgb_controller_methods, 136 sizeof(struct adapter) 137 }; 138 139 static devclass_t cxgb_controller_devclass; 140 DRIVER_MODULE(cxgbc, pci, cxgb_controller_driver, cxgb_controller_devclass, 0, 0); 141 142 /* 143 * Attachment glue for the ports. Attachment is done directly to the 144 * controller device. 145 */ 146 static int cxgb_port_probe(device_t); 147 static int cxgb_port_attach(device_t); 148 static int cxgb_port_detach(device_t); 149 150 static device_method_t cxgb_port_methods[] = { 151 DEVMETHOD(device_probe, cxgb_port_probe), 152 DEVMETHOD(device_attach, cxgb_port_attach), 153 DEVMETHOD(device_detach, cxgb_port_detach), 154 { 0, 0 } 155 }; 156 157 static driver_t cxgb_port_driver = { 158 "cxgb", 159 cxgb_port_methods, 160 0 161 }; 162 163 static d_ioctl_t cxgb_extension_ioctl; 164 static d_open_t cxgb_extension_open; 165 static d_close_t cxgb_extension_close; 166 167 static struct cdevsw cxgb_cdevsw = { 168 .d_version = D_VERSION, 169 .d_flags = 0, 170 .d_open = cxgb_extension_open, 171 .d_close = cxgb_extension_close, 172 .d_ioctl = cxgb_extension_ioctl, 173 .d_name = "cxgb", 174 }; 175 176 static devclass_t cxgb_port_devclass; 177 DRIVER_MODULE(cxgb, cxgbc, cxgb_port_driver, cxgb_port_devclass, 0, 0); 178 179 /* 180 * The driver uses the best interrupt scheme available on a platform in the 181 * order MSI-X, MSI, legacy pin interrupts. This parameter determines which 182 * of these schemes the driver may consider as follows: 183 * 184 * msi = 2: choose from among all three options 185 * msi = 1 : only consider MSI and pin interrupts 186 * msi = 0: force pin interrupts 187 */ 188 static int msi_allowed = 2; 189 190 TUNABLE_INT("hw.cxgb.msi_allowed", &msi_allowed); 191 SYSCTL_NODE(_hw, OID_AUTO, cxgb, CTLFLAG_RD, 0, "CXGB driver parameters"); 192 SYSCTL_UINT(_hw_cxgb, OID_AUTO, msi_allowed, CTLFLAG_RDTUN, &msi_allowed, 0, 193 "MSI-X, MSI, INTx selector"); 194 195 /* 196 * The driver enables offload as a default. 197 * To disable it, use ofld_disable = 1. 198 */ 199 static int ofld_disable = 0; 200 TUNABLE_INT("hw.cxgb.ofld_disable", &ofld_disable); 201 SYSCTL_UINT(_hw_cxgb, OID_AUTO, ofld_disable, CTLFLAG_RDTUN, &ofld_disable, 0, 202 "disable ULP offload"); 203 204 /* 205 * The driver uses an auto-queue algorithm by default. 206 * To disable it and force a single queue-set per port, use multiq = 0 207 */ 208 static int multiq = 1; 209 TUNABLE_INT("hw.cxgb.multiq", &multiq); 210 SYSCTL_UINT(_hw_cxgb, OID_AUTO, multiq, CTLFLAG_RDTUN, &multiq, 0, 211 "use min(ncpus/ports, 8) queue-sets per port"); 212 213 /* 214 * By default the driver will not update the firmware unless 215 * it was compiled against a newer version 216 * 217 */ 218 static int force_fw_update = 0; 219 TUNABLE_INT("hw.cxgb.force_fw_update", &force_fw_update); 220 SYSCTL_UINT(_hw_cxgb, OID_AUTO, force_fw_update, CTLFLAG_RDTUN, &force_fw_update, 0, 221 "update firmware even if up to date"); 222 223 int cxgb_use_16k_clusters = 1; 224 TUNABLE_INT("hw.cxgb.use_16k_clusters", &cxgb_use_16k_clusters); 225 SYSCTL_UINT(_hw_cxgb, OID_AUTO, use_16k_clusters, CTLFLAG_RDTUN, 226 &cxgb_use_16k_clusters, 0, "use 16kB clusters for the jumbo queue "); 227 228 /* 229 * Tune the size of the output queue. 230 */ 231 int cxgb_snd_queue_len = IFQ_MAXLEN; 232 TUNABLE_INT("hw.cxgb.snd_queue_len", &cxgb_snd_queue_len); 233 SYSCTL_UINT(_hw_cxgb, OID_AUTO, snd_queue_len, CTLFLAG_RDTUN, 234 &cxgb_snd_queue_len, 0, "send queue size "); 235 236 237 enum { 238 MAX_TXQ_ENTRIES = 16384, 239 MAX_CTRL_TXQ_ENTRIES = 1024, 240 MAX_RSPQ_ENTRIES = 16384, 241 MAX_RX_BUFFERS = 16384, 242 MAX_RX_JUMBO_BUFFERS = 16384, 243 MIN_TXQ_ENTRIES = 4, 244 MIN_CTRL_TXQ_ENTRIES = 4, 245 MIN_RSPQ_ENTRIES = 32, 246 MIN_FL_ENTRIES = 32, 247 MIN_FL_JUMBO_ENTRIES = 32 248 }; 249 250 struct filter_info { 251 u32 sip; 252 u32 sip_mask; 253 u32 dip; 254 u16 sport; 255 u16 dport; 256 u32 vlan:12; 257 u32 vlan_prio:3; 258 u32 mac_hit:1; 259 u32 mac_idx:4; 260 u32 mac_vld:1; 261 u32 pkt_type:2; 262 u32 report_filter_id:1; 263 u32 pass:1; 264 u32 rss:1; 265 u32 qset:3; 266 u32 locked:1; 267 u32 valid:1; 268 }; 269 270 enum { FILTER_NO_VLAN_PRI = 7 }; 271 272 #define EEPROM_MAGIC 0x38E2F10C 273 274 #define PORT_MASK ((1 << MAX_NPORTS) - 1) 275 276 /* Table for probing the cards. The desc field isn't actually used */ 277 struct cxgb_ident { 278 uint16_t vendor; 279 uint16_t device; 280 int index; 281 char *desc; 282 } cxgb_identifiers[] = { 283 {PCI_VENDOR_ID_CHELSIO, 0x0020, 0, "PE9000"}, 284 {PCI_VENDOR_ID_CHELSIO, 0x0021, 1, "T302E"}, 285 {PCI_VENDOR_ID_CHELSIO, 0x0022, 2, "T310E"}, 286 {PCI_VENDOR_ID_CHELSIO, 0x0023, 3, "T320X"}, 287 {PCI_VENDOR_ID_CHELSIO, 0x0024, 1, "T302X"}, 288 {PCI_VENDOR_ID_CHELSIO, 0x0025, 3, "T320E"}, 289 {PCI_VENDOR_ID_CHELSIO, 0x0026, 2, "T310X"}, 290 {PCI_VENDOR_ID_CHELSIO, 0x0030, 2, "T3B10"}, 291 {PCI_VENDOR_ID_CHELSIO, 0x0031, 3, "T3B20"}, 292 {PCI_VENDOR_ID_CHELSIO, 0x0032, 1, "T3B02"}, 293 {PCI_VENDOR_ID_CHELSIO, 0x0033, 4, "T3B04"}, 294 {PCI_VENDOR_ID_CHELSIO, 0x0035, 6, "N310E"}, 295 {0, 0, 0, NULL} 296 }; 297 298 static int set_eeprom(struct port_info *pi, const uint8_t *data, int len, int offset); 299 300 301 static __inline char 302 t3rev2char(struct adapter *adapter) 303 { 304 char rev = 'z'; 305 306 switch(adapter->params.rev) { 307 case T3_REV_A: 308 rev = 'a'; 309 break; 310 case T3_REV_B: 311 case T3_REV_B2: 312 rev = 'b'; 313 break; 314 case T3_REV_C: 315 rev = 'c'; 316 break; 317 } 318 return rev; 319 } 320 321 static struct cxgb_ident * 322 cxgb_get_ident(device_t dev) 323 { 324 struct cxgb_ident *id; 325 326 for (id = cxgb_identifiers; id->desc != NULL; id++) { 327 if ((id->vendor == pci_get_vendor(dev)) && 328 (id->device == pci_get_device(dev))) { 329 return (id); 330 } 331 } 332 return (NULL); 333 } 334 335 static const struct adapter_info * 336 cxgb_get_adapter_info(device_t dev) 337 { 338 struct cxgb_ident *id; 339 const struct adapter_info *ai; 340 341 id = cxgb_get_ident(dev); 342 if (id == NULL) 343 return (NULL); 344 345 ai = t3_get_adapter_info(id->index); 346 347 return (ai); 348 } 349 350 static int 351 cxgb_controller_probe(device_t dev) 352 { 353 const struct adapter_info *ai; 354 char *ports, buf[80]; 355 int nports; 356 struct adapter *sc = device_get_softc(dev); 357 358 ai = cxgb_get_adapter_info(dev); 359 if (ai == NULL) 360 return (ENXIO); 361 362 nports = ai->nports0 + ai->nports1; 363 if (nports == 1) 364 ports = "port"; 365 else 366 ports = "ports"; 367 368 snprintf(buf, sizeof(buf), "%s %sNIC, rev: %d nports: %d %s", 369 ai->desc, is_offload(sc) ? "R" : "", 370 sc->params.rev, nports, ports); 371 device_set_desc_copy(dev, buf); 372 return (BUS_PROBE_DEFAULT); 373 } 374 375 #define FW_FNAME "cxgb_t3fw" 376 #define TPEEPROM_NAME "cxgb_t3%c_tp_eeprom" 377 #define TPSRAM_NAME "cxgb_t3%c_protocol_sram" 378 379 static int 380 upgrade_fw(adapter_t *sc) 381 { 382 #ifdef FIRMWARE_LATEST 383 const struct firmware *fw; 384 #else 385 struct firmware *fw; 386 #endif 387 int status; 388 389 if ((fw = firmware_get(FW_FNAME)) == NULL) { 390 device_printf(sc->dev, "Could not find firmware image %s\n", FW_FNAME); 391 return (ENOENT); 392 } else 393 device_printf(sc->dev, "updating firmware on card\n"); 394 status = t3_load_fw(sc, (const uint8_t *)fw->data, fw->datasize); 395 396 device_printf(sc->dev, "firmware update returned %s %d\n", (status == 0) ? "success" : "fail", status); 397 398 firmware_put(fw, FIRMWARE_UNLOAD); 399 400 return (status); 401 } 402 403 /* 404 * The cxgb_controller_attach function is responsible for the initial 405 * bringup of the device. Its responsibilities include: 406 * 407 * 1. Determine if the device supports MSI or MSI-X. 408 * 2. Allocate bus resources so that we can access the Base Address Register 409 * 3. Create and initialize mutexes for the controller and its control 410 * logic such as SGE and MDIO. 411 * 4. Call hardware specific setup routine for the adapter as a whole. 412 * 5. Allocate the BAR for doing MSI-X. 413 * 6. Setup the line interrupt iff MSI-X is not supported. 414 * 7. Create the driver's taskq. 415 * 8. Start one task queue service thread. 416 * 9. Check if the firmware and SRAM are up-to-date. They will be 417 * auto-updated later (before FULL_INIT_DONE), if required. 418 * 10. Create a child device for each MAC (port) 419 * 11. Initialize T3 private state. 420 * 12. Trigger the LED 421 * 13. Setup offload iff supported. 422 * 14. Reset/restart the tick callout. 423 * 15. Attach sysctls 424 * 425 * NOTE: Any modification or deviation from this list MUST be reflected in 426 * the above comment. Failure to do so will result in problems on various 427 * error conditions including link flapping. 428 */ 429 static int 430 cxgb_controller_attach(device_t dev) 431 { 432 device_t child; 433 const struct adapter_info *ai; 434 struct adapter *sc; 435 int i, error = 0; 436 uint32_t vers; 437 int port_qsets = 1; 438 #ifdef MSI_SUPPORTED 439 int msi_needed, reg; 440 #endif 441 char buf[80]; 442 443 sc = device_get_softc(dev); 444 sc->dev = dev; 445 sc->msi_count = 0; 446 ai = cxgb_get_adapter_info(dev); 447 448 /* 449 * XXX not really related but a recent addition 450 */ 451 #ifdef MSI_SUPPORTED 452 /* find the PCIe link width and set max read request to 4KB*/ 453 if (pci_find_extcap(dev, PCIY_EXPRESS, ®) == 0) { 454 uint16_t lnk, pectl; 455 lnk = pci_read_config(dev, reg + 0x12, 2); 456 sc->link_width = (lnk >> 4) & 0x3f; 457 458 pectl = pci_read_config(dev, reg + 0x8, 2); 459 pectl = (pectl & ~0x7000) | (5 << 12); 460 pci_write_config(dev, reg + 0x8, pectl, 2); 461 } 462 463 if (sc->link_width != 0 && sc->link_width <= 4 && 464 (ai->nports0 + ai->nports1) <= 2) { 465 device_printf(sc->dev, 466 "PCIe x%d Link, expect reduced performance\n", 467 sc->link_width); 468 } 469 #endif 470 touch_bars(dev); 471 pci_enable_busmaster(dev); 472 /* 473 * Allocate the registers and make them available to the driver. 474 * The registers that we care about for NIC mode are in BAR 0 475 */ 476 sc->regs_rid = PCIR_BAR(0); 477 if ((sc->regs_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, 478 &sc->regs_rid, RF_ACTIVE)) == NULL) { 479 device_printf(dev, "Cannot allocate BAR region 0\n"); 480 return (ENXIO); 481 } 482 sc->udbs_rid = PCIR_BAR(2); 483 sc->udbs_res = NULL; 484 if (is_offload(sc) && 485 ((sc->udbs_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, 486 &sc->udbs_rid, RF_ACTIVE)) == NULL)) { 487 device_printf(dev, "Cannot allocate BAR region 1\n"); 488 error = ENXIO; 489 goto out; 490 } 491 492 snprintf(sc->lockbuf, ADAPTER_LOCK_NAME_LEN, "cxgb controller lock %d", 493 device_get_unit(dev)); 494 ADAPTER_LOCK_INIT(sc, sc->lockbuf); 495 496 snprintf(sc->reglockbuf, ADAPTER_LOCK_NAME_LEN, "SGE reg lock %d", 497 device_get_unit(dev)); 498 snprintf(sc->mdiolockbuf, ADAPTER_LOCK_NAME_LEN, "cxgb mdio lock %d", 499 device_get_unit(dev)); 500 snprintf(sc->elmerlockbuf, ADAPTER_LOCK_NAME_LEN, "cxgb elmer lock %d", 501 device_get_unit(dev)); 502 503 MTX_INIT(&sc->sge.reg_lock, sc->reglockbuf, NULL, MTX_SPIN); 504 MTX_INIT(&sc->mdio_lock, sc->mdiolockbuf, NULL, MTX_DEF); 505 MTX_INIT(&sc->elmer_lock, sc->elmerlockbuf, NULL, MTX_DEF); 506 507 sc->bt = rman_get_bustag(sc->regs_res); 508 sc->bh = rman_get_bushandle(sc->regs_res); 509 sc->mmio_len = rman_get_size(sc->regs_res); 510 511 if (t3_prep_adapter(sc, ai, 1) < 0) { 512 printf("prep adapter failed\n"); 513 error = ENODEV; 514 goto out; 515 } 516 /* Allocate the BAR for doing MSI-X. If it succeeds, try to allocate 517 * enough messages for the queue sets. If that fails, try falling 518 * back to MSI. If that fails, then try falling back to the legacy 519 * interrupt pin model. 520 */ 521 #ifdef MSI_SUPPORTED 522 523 sc->msix_regs_rid = 0x20; 524 if ((msi_allowed >= 2) && 525 (sc->msix_regs_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, 526 &sc->msix_regs_rid, RF_ACTIVE)) != NULL) { 527 528 if (multiq) 529 port_qsets = min(SGE_QSETS/sc->params.nports, mp_ncpus); 530 msi_needed = sc->msi_count = sc->params.nports * port_qsets + 1; 531 532 if (pci_msix_count(dev) == 0 || 533 (error = pci_alloc_msix(dev, &sc->msi_count)) != 0 || 534 sc->msi_count != msi_needed) { 535 device_printf(dev, "alloc msix failed - " 536 "msi_count=%d, msi_needed=%d, err=%d; " 537 "will try MSI\n", sc->msi_count, 538 msi_needed, error); 539 sc->msi_count = 0; 540 port_qsets = 1; 541 pci_release_msi(dev); 542 bus_release_resource(dev, SYS_RES_MEMORY, 543 sc->msix_regs_rid, sc->msix_regs_res); 544 sc->msix_regs_res = NULL; 545 } else { 546 sc->flags |= USING_MSIX; 547 sc->cxgb_intr = cxgb_async_intr; 548 device_printf(dev, 549 "using MSI-X interrupts (%u vectors)\n", 550 sc->msi_count); 551 } 552 } 553 554 if ((msi_allowed >= 1) && (sc->msi_count == 0)) { 555 sc->msi_count = 1; 556 if ((error = pci_alloc_msi(dev, &sc->msi_count)) != 0) { 557 device_printf(dev, "alloc msi failed - " 558 "err=%d; will try INTx\n", error); 559 sc->msi_count = 0; 560 port_qsets = 1; 561 pci_release_msi(dev); 562 } else { 563 sc->flags |= USING_MSI; 564 sc->cxgb_intr = t3_intr_msi; 565 device_printf(dev, "using MSI interrupts\n"); 566 } 567 } 568 #endif 569 if (sc->msi_count == 0) { 570 device_printf(dev, "using line interrupts\n"); 571 sc->cxgb_intr = t3b_intr; 572 } 573 574 /* Create a private taskqueue thread for handling driver events */ 575 #ifdef TASKQUEUE_CURRENT 576 sc->tq = taskqueue_create("cxgb_taskq", M_NOWAIT, 577 taskqueue_thread_enqueue, &sc->tq); 578 #else 579 sc->tq = taskqueue_create_fast("cxgb_taskq", M_NOWAIT, 580 taskqueue_thread_enqueue, &sc->tq); 581 #endif 582 if (sc->tq == NULL) { 583 device_printf(dev, "failed to allocate controller task queue\n"); 584 goto out; 585 } 586 587 taskqueue_start_threads(&sc->tq, 1, PI_NET, "%s taskq", 588 device_get_nameunit(dev)); 589 TASK_INIT(&sc->ext_intr_task, 0, cxgb_ext_intr_handler, sc); 590 TASK_INIT(&sc->tick_task, 0, cxgb_tick_handler, sc); 591 592 593 /* Create a periodic callout for checking adapter status */ 594 callout_init(&sc->cxgb_tick_ch, TRUE); 595 596 if (t3_check_fw_version(sc) < 0 || force_fw_update) { 597 /* 598 * Warn user that a firmware update will be attempted in init. 599 */ 600 device_printf(dev, "firmware needs to be updated to version %d.%d.%d\n", 601 FW_VERSION_MAJOR, FW_VERSION_MINOR, FW_VERSION_MICRO); 602 sc->flags &= ~FW_UPTODATE; 603 } else { 604 sc->flags |= FW_UPTODATE; 605 } 606 607 if (t3_check_tpsram_version(sc) < 0) { 608 /* 609 * Warn user that a firmware update will be attempted in init. 610 */ 611 device_printf(dev, "SRAM needs to be updated to version %c-%d.%d.%d\n", 612 t3rev2char(sc), TP_VERSION_MAJOR, TP_VERSION_MINOR, TP_VERSION_MICRO); 613 sc->flags &= ~TPS_UPTODATE; 614 } else { 615 sc->flags |= TPS_UPTODATE; 616 } 617 618 /* 619 * Create a child device for each MAC. The ethernet attachment 620 * will be done in these children. 621 */ 622 for (i = 0; i < (sc)->params.nports; i++) { 623 struct port_info *pi; 624 625 if ((child = device_add_child(dev, "cxgb", -1)) == NULL) { 626 device_printf(dev, "failed to add child port\n"); 627 error = EINVAL; 628 goto out; 629 } 630 pi = &sc->port[i]; 631 pi->adapter = sc; 632 pi->nqsets = port_qsets; 633 pi->first_qset = i*port_qsets; 634 pi->port_id = i; 635 pi->tx_chan = i >= ai->nports0; 636 pi->txpkt_intf = pi->tx_chan ? 2 * (i - ai->nports0) + 1 : 2 * i; 637 sc->rxpkt_map[pi->txpkt_intf] = i; 638 sc->port[i].tx_chan = i >= ai->nports0; 639 sc->portdev[i] = child; 640 device_set_softc(child, pi); 641 } 642 if ((error = bus_generic_attach(dev)) != 0) 643 goto out; 644 645 /* initialize sge private state */ 646 t3_sge_init_adapter(sc); 647 648 t3_led_ready(sc); 649 650 cxgb_offload_init(); 651 if (is_offload(sc)) { 652 setbit(&sc->registered_device_map, OFFLOAD_DEVMAP_BIT); 653 cxgb_adapter_ofld(sc); 654 } 655 error = t3_get_fw_version(sc, &vers); 656 if (error) 657 goto out; 658 659 snprintf(&sc->fw_version[0], sizeof(sc->fw_version), "%d.%d.%d", 660 G_FW_VERSION_MAJOR(vers), G_FW_VERSION_MINOR(vers), 661 G_FW_VERSION_MICRO(vers)); 662 663 snprintf(buf, sizeof(buf), "%s\t E/C: %s S/N: %s", 664 ai->desc, 665 sc->params.vpd.ec, sc->params.vpd.sn); 666 device_set_desc_copy(dev, buf); 667 668 snprintf(&sc->port_types[0], sizeof(sc->port_types), "%x%x%x%x", 669 sc->params.vpd.port_type[0], sc->params.vpd.port_type[1], 670 sc->params.vpd.port_type[2], sc->params.vpd.port_type[3]); 671 672 device_printf(sc->dev, "Firmware Version %s\n", &sc->fw_version[0]); 673 callout_reset(&sc->cxgb_tick_ch, CXGB_TICKS(sc), cxgb_tick, sc); 674 t3_add_attach_sysctls(sc); 675 out: 676 if (error) 677 cxgb_free(sc); 678 679 return (error); 680 } 681 682 /* 683 * The cxgb_controller_detach routine is called with the device is 684 * unloaded from the system. 685 */ 686 687 static int 688 cxgb_controller_detach(device_t dev) 689 { 690 struct adapter *sc; 691 692 sc = device_get_softc(dev); 693 694 cxgb_free(sc); 695 696 return (0); 697 } 698 699 /* 700 * The cxgb_free() is called by the cxgb_controller_detach() routine 701 * to tear down the structures that were built up in 702 * cxgb_controller_attach(), and should be the final piece of work 703 * done when fully unloading the driver. 704 * 705 * 706 * 1. Shutting down the threads started by the cxgb_controller_attach() 707 * routine. 708 * 2. Stopping the lower level device and all callouts (cxgb_down_locked()). 709 * 3. Detaching all of the port devices created during the 710 * cxgb_controller_attach() routine. 711 * 4. Removing the device children created via cxgb_controller_attach(). 712 * 5. Releasing PCI resources associated with the device. 713 * 6. Turning off the offload support, iff it was turned on. 714 * 7. Destroying the mutexes created in cxgb_controller_attach(). 715 * 716 */ 717 static void 718 cxgb_free(struct adapter *sc) 719 { 720 int i; 721 722 ADAPTER_LOCK(sc); 723 sc->flags |= CXGB_SHUTDOWN; 724 ADAPTER_UNLOCK(sc); 725 726 /* 727 * Make sure all child devices are gone. 728 */ 729 bus_generic_detach(sc->dev); 730 for (i = 0; i < (sc)->params.nports; i++) { 731 if (sc->portdev[i] && 732 device_delete_child(sc->dev, sc->portdev[i]) != 0) 733 device_printf(sc->dev, "failed to delete child port\n"); 734 } 735 736 /* 737 * At this point, it is as if cxgb_port_detach has run on all ports, and 738 * cxgb_down has run on the adapter. All interrupts have been silenced, 739 * all open devices have been closed. 740 */ 741 KASSERT(sc->open_device_map == 0, ("%s: device(s) still open (%x)", 742 __func__, sc->open_device_map)); 743 for (i = 0; i < sc->params.nports; i++) { 744 KASSERT(sc->port[i].ifp == NULL, ("%s: port %i undead!", 745 __func__, i)); 746 } 747 748 /* 749 * Finish off the adapter's callouts. 750 */ 751 callout_drain(&sc->cxgb_tick_ch); 752 callout_drain(&sc->sge_timer_ch); 753 754 /* 755 * Release resources grabbed under FULL_INIT_DONE by cxgb_up. The 756 * sysctls are cleaned up by the kernel linker. 757 */ 758 if (sc->flags & FULL_INIT_DONE) { 759 t3_free_sge_resources(sc); 760 sc->flags &= ~FULL_INIT_DONE; 761 } 762 763 /* 764 * Release all interrupt resources. 765 */ 766 cxgb_teardown_interrupts(sc); 767 #ifdef MSI_SUPPORTED 768 if (sc->flags & (USING_MSI | USING_MSIX)) { 769 device_printf(sc->dev, "releasing msi message(s)\n"); 770 pci_release_msi(sc->dev); 771 } else { 772 device_printf(sc->dev, "no msi message to release\n"); 773 } 774 775 if (sc->msix_regs_res != NULL) { 776 bus_release_resource(sc->dev, SYS_RES_MEMORY, sc->msix_regs_rid, 777 sc->msix_regs_res); 778 } 779 #endif 780 781 /* 782 * Free the adapter's taskqueue. 783 */ 784 if (sc->tq != NULL) { 785 taskqueue_free(sc->tq); 786 sc->tq = NULL; 787 } 788 789 if (is_offload(sc)) { 790 clrbit(&sc->registered_device_map, OFFLOAD_DEVMAP_BIT); 791 cxgb_adapter_unofld(sc); 792 } 793 794 #ifdef notyet 795 if (sc->flags & CXGB_OFLD_INIT) 796 cxgb_offload_deactivate(sc); 797 #endif 798 free(sc->filters, M_DEVBUF); 799 t3_sge_free(sc); 800 801 cxgb_offload_exit(); 802 803 if (sc->udbs_res != NULL) 804 bus_release_resource(sc->dev, SYS_RES_MEMORY, sc->udbs_rid, 805 sc->udbs_res); 806 807 if (sc->regs_res != NULL) 808 bus_release_resource(sc->dev, SYS_RES_MEMORY, sc->regs_rid, 809 sc->regs_res); 810 811 MTX_DESTROY(&sc->mdio_lock); 812 MTX_DESTROY(&sc->sge.reg_lock); 813 MTX_DESTROY(&sc->elmer_lock); 814 ADAPTER_LOCK_DEINIT(sc); 815 } 816 817 /** 818 * setup_sge_qsets - configure SGE Tx/Rx/response queues 819 * @sc: the controller softc 820 * 821 * Determines how many sets of SGE queues to use and initializes them. 822 * We support multiple queue sets per port if we have MSI-X, otherwise 823 * just one queue set per port. 824 */ 825 static int 826 setup_sge_qsets(adapter_t *sc) 827 { 828 int i, j, err, irq_idx = 0, qset_idx = 0; 829 u_int ntxq = SGE_TXQ_PER_SET; 830 831 if ((err = t3_sge_alloc(sc)) != 0) { 832 device_printf(sc->dev, "t3_sge_alloc returned %d\n", err); 833 return (err); 834 } 835 836 if (sc->params.rev > 0 && !(sc->flags & USING_MSI)) 837 irq_idx = -1; 838 839 for (i = 0; i < (sc)->params.nports; i++) { 840 struct port_info *pi = &sc->port[i]; 841 842 for (j = 0; j < pi->nqsets; j++, qset_idx++) { 843 err = t3_sge_alloc_qset(sc, qset_idx, (sc)->params.nports, 844 (sc->flags & USING_MSIX) ? qset_idx + 1 : irq_idx, 845 &sc->params.sge.qset[qset_idx], ntxq, pi); 846 if (err) { 847 t3_free_sge_resources(sc); 848 device_printf(sc->dev, "t3_sge_alloc_qset failed with %d\n", 849 err); 850 return (err); 851 } 852 } 853 } 854 855 return (0); 856 } 857 858 static void 859 cxgb_teardown_interrupts(adapter_t *sc) 860 { 861 int i; 862 863 for (i = 0; i < SGE_QSETS; i++) { 864 if (sc->msix_intr_tag[i] == NULL) { 865 866 /* Should have been setup fully or not at all */ 867 KASSERT(sc->msix_irq_res[i] == NULL && 868 sc->msix_irq_rid[i] == 0, 869 ("%s: half-done interrupt (%d).", __func__, i)); 870 871 continue; 872 } 873 874 bus_teardown_intr(sc->dev, sc->msix_irq_res[i], 875 sc->msix_intr_tag[i]); 876 bus_release_resource(sc->dev, SYS_RES_IRQ, sc->msix_irq_rid[i], 877 sc->msix_irq_res[i]); 878 879 sc->msix_irq_res[i] = sc->msix_intr_tag[i] = NULL; 880 sc->msix_irq_rid[i] = 0; 881 } 882 883 if (sc->intr_tag) { 884 KASSERT(sc->irq_res != NULL, 885 ("%s: half-done interrupt.", __func__)); 886 887 bus_teardown_intr(sc->dev, sc->irq_res, sc->intr_tag); 888 bus_release_resource(sc->dev, SYS_RES_IRQ, sc->irq_rid, 889 sc->irq_res); 890 891 sc->irq_res = sc->intr_tag = NULL; 892 sc->irq_rid = 0; 893 } 894 } 895 896 static int 897 cxgb_setup_interrupts(adapter_t *sc) 898 { 899 struct resource *res; 900 void *tag; 901 int i, rid, err, intr_flag = sc->flags & (USING_MSI | USING_MSIX); 902 903 sc->irq_rid = intr_flag ? 1 : 0; 904 sc->irq_res = bus_alloc_resource_any(sc->dev, SYS_RES_IRQ, &sc->irq_rid, 905 RF_SHAREABLE | RF_ACTIVE); 906 if (sc->irq_res == NULL) { 907 device_printf(sc->dev, "Cannot allocate interrupt (%x, %u)\n", 908 intr_flag, sc->irq_rid); 909 err = EINVAL; 910 sc->irq_rid = 0; 911 } else { 912 err = bus_setup_intr(sc->dev, sc->irq_res, 913 INTR_MPSAFE | INTR_TYPE_NET, 914 #ifdef INTR_FILTERS 915 NULL, 916 #endif 917 sc->cxgb_intr, sc, &sc->intr_tag); 918 919 if (err) { 920 device_printf(sc->dev, 921 "Cannot set up interrupt (%x, %u, %d)\n", 922 intr_flag, sc->irq_rid, err); 923 bus_release_resource(sc->dev, SYS_RES_IRQ, sc->irq_rid, 924 sc->irq_res); 925 sc->irq_res = sc->intr_tag = NULL; 926 sc->irq_rid = 0; 927 } 928 } 929 930 /* That's all for INTx or MSI */ 931 if (!(intr_flag & USING_MSIX) || err) 932 return (err); 933 934 for (i = 0; i < sc->msi_count - 1; i++) { 935 rid = i + 2; 936 res = bus_alloc_resource_any(sc->dev, SYS_RES_IRQ, &rid, 937 RF_SHAREABLE | RF_ACTIVE); 938 if (res == NULL) { 939 device_printf(sc->dev, "Cannot allocate interrupt " 940 "for message %d\n", rid); 941 err = EINVAL; 942 break; 943 } 944 945 err = bus_setup_intr(sc->dev, res, INTR_MPSAFE | INTR_TYPE_NET, 946 #ifdef INTR_FILTERS 947 NULL, 948 #endif 949 t3_intr_msix, &sc->sge.qs[i], &tag); 950 if (err) { 951 device_printf(sc->dev, "Cannot set up interrupt " 952 "for message %d (%d)\n", rid, err); 953 bus_release_resource(sc->dev, SYS_RES_IRQ, rid, res); 954 break; 955 } 956 957 sc->msix_irq_rid[i] = rid; 958 sc->msix_irq_res[i] = res; 959 sc->msix_intr_tag[i] = tag; 960 } 961 962 if (err) 963 cxgb_teardown_interrupts(sc); 964 965 return (err); 966 } 967 968 969 static int 970 cxgb_port_probe(device_t dev) 971 { 972 struct port_info *p; 973 char buf[80]; 974 const char *desc; 975 976 p = device_get_softc(dev); 977 desc = p->phy.desc; 978 snprintf(buf, sizeof(buf), "Port %d %s", p->port_id, desc); 979 device_set_desc_copy(dev, buf); 980 return (0); 981 } 982 983 984 static int 985 cxgb_makedev(struct port_info *pi) 986 { 987 988 pi->port_cdev = make_dev(&cxgb_cdevsw, pi->ifp->if_dunit, 989 UID_ROOT, GID_WHEEL, 0600, if_name(pi->ifp)); 990 991 if (pi->port_cdev == NULL) 992 return (ENOMEM); 993 994 pi->port_cdev->si_drv1 = (void *)pi; 995 996 return (0); 997 } 998 999 #ifndef LRO_SUPPORTED 1000 #ifdef IFCAP_LRO 1001 #undef IFCAP_LRO 1002 #endif 1003 #define IFCAP_LRO 0x0 1004 #endif 1005 1006 #ifdef TSO_SUPPORTED 1007 #define CXGB_CAP (IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU | IFCAP_HWCSUM | IFCAP_VLAN_HWCSUM | IFCAP_TSO | IFCAP_JUMBO_MTU | IFCAP_LRO) 1008 /* Don't enable TSO6 yet */ 1009 #define CXGB_CAP_ENABLE (IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU | IFCAP_HWCSUM | IFCAP_VLAN_HWCSUM | IFCAP_TSO4 | IFCAP_JUMBO_MTU | IFCAP_LRO) 1010 #else 1011 #define CXGB_CAP (IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU | IFCAP_HWCSUM | IFCAP_JUMBO_MTU) 1012 /* Don't enable TSO6 yet */ 1013 #define CXGB_CAP_ENABLE (IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU | IFCAP_HWCSUM | IFCAP_JUMBO_MTU) 1014 #define IFCAP_TSO4 0x0 1015 #define IFCAP_TSO6 0x0 1016 #define CSUM_TSO 0x0 1017 #endif 1018 1019 1020 static int 1021 cxgb_port_attach(device_t dev) 1022 { 1023 struct port_info *p; 1024 struct ifnet *ifp; 1025 int err; 1026 struct adapter *sc; 1027 1028 1029 p = device_get_softc(dev); 1030 sc = p->adapter; 1031 snprintf(p->lockbuf, PORT_NAME_LEN, "cxgb port lock %d:%d", 1032 device_get_unit(device_get_parent(dev)), p->port_id); 1033 PORT_LOCK_INIT(p, p->lockbuf); 1034 1035 /* Allocate an ifnet object and set it up */ 1036 ifp = p->ifp = if_alloc(IFT_ETHER); 1037 if (ifp == NULL) { 1038 device_printf(dev, "Cannot allocate ifnet\n"); 1039 return (ENOMEM); 1040 } 1041 1042 /* 1043 * Note that there is currently no watchdog timer. 1044 */ 1045 if_initname(ifp, device_get_name(dev), device_get_unit(dev)); 1046 ifp->if_init = cxgb_init; 1047 ifp->if_softc = p; 1048 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1049 ifp->if_ioctl = cxgb_ioctl; 1050 ifp->if_start = cxgb_start; 1051 1052 1053 ifp->if_timer = 0; /* Disable ifnet watchdog */ 1054 ifp->if_watchdog = NULL; 1055 1056 ifp->if_snd.ifq_drv_maxlen = cxgb_snd_queue_len; 1057 IFQ_SET_MAXLEN(&ifp->if_snd, ifp->if_snd.ifq_drv_maxlen); 1058 IFQ_SET_READY(&ifp->if_snd); 1059 1060 ifp->if_hwassist = ifp->if_capabilities = ifp->if_capenable = 0; 1061 ifp->if_capabilities |= CXGB_CAP; 1062 ifp->if_capenable |= CXGB_CAP_ENABLE; 1063 ifp->if_hwassist |= (CSUM_TCP | CSUM_UDP | CSUM_IP | CSUM_TSO); 1064 /* 1065 * disable TSO on 4-port - it isn't supported by the firmware yet 1066 */ 1067 if (p->adapter->params.nports > 2) { 1068 ifp->if_capabilities &= ~(IFCAP_TSO4 | IFCAP_TSO6); 1069 ifp->if_capenable &= ~(IFCAP_TSO4 | IFCAP_TSO6); 1070 ifp->if_hwassist &= ~CSUM_TSO; 1071 } 1072 1073 ether_ifattach(ifp, p->hw_addr); 1074 ifp->if_transmit = cxgb_transmit; 1075 ifp->if_qflush = cxgb_qflush; 1076 1077 /* 1078 * Only default to jumbo frames on 10GigE 1079 */ 1080 if (p->adapter->params.nports <= 2) 1081 ifp->if_mtu = ETHERMTU_JUMBO; 1082 if ((err = cxgb_makedev(p)) != 0) { 1083 printf("makedev failed %d\n", err); 1084 return (err); 1085 } 1086 1087 /* Create a list of media supported by this port */ 1088 ifmedia_init(&p->media, IFM_IMASK, cxgb_media_change, 1089 cxgb_media_status); 1090 cxgb_build_medialist(p); 1091 1092 t3_sge_init_port(p); 1093 1094 return (err); 1095 } 1096 1097 /* 1098 * cxgb_port_detach() is called via the device_detach methods when 1099 * cxgb_free() calls the bus_generic_detach. It is responsible for 1100 * removing the device from the view of the kernel, i.e. from all 1101 * interfaces lists etc. This routine is only called when the driver is 1102 * being unloaded, not when the link goes down. 1103 */ 1104 static int 1105 cxgb_port_detach(device_t dev) 1106 { 1107 struct port_info *p; 1108 struct adapter *sc; 1109 int i; 1110 1111 p = device_get_softc(dev); 1112 sc = p->adapter; 1113 1114 cxgb_begin_detach(p); 1115 1116 if (p->port_cdev != NULL) 1117 destroy_dev(p->port_cdev); 1118 1119 cxgb_uninit_synchronized(p); 1120 ether_ifdetach(p->ifp); 1121 1122 for (i = p->first_qset; i < p->first_qset + p->nqsets; i++) { 1123 struct sge_qset *qs = &sc->sge.qs[i]; 1124 struct sge_txq *txq = &qs->txq[TXQ_ETH]; 1125 1126 callout_drain(&txq->txq_watchdog); 1127 callout_drain(&txq->txq_timer); 1128 } 1129 1130 PORT_LOCK_DEINIT(p); 1131 if_free(p->ifp); 1132 p->ifp = NULL; 1133 1134 cxgb_end_op(p); 1135 return (0); 1136 } 1137 1138 void 1139 t3_fatal_err(struct adapter *sc) 1140 { 1141 u_int fw_status[4]; 1142 1143 if (sc->flags & FULL_INIT_DONE) { 1144 t3_sge_stop(sc); 1145 t3_write_reg(sc, A_XGM_TX_CTRL, 0); 1146 t3_write_reg(sc, A_XGM_RX_CTRL, 0); 1147 t3_write_reg(sc, XGM_REG(A_XGM_TX_CTRL, 1), 0); 1148 t3_write_reg(sc, XGM_REG(A_XGM_RX_CTRL, 1), 0); 1149 t3_intr_disable(sc); 1150 } 1151 device_printf(sc->dev,"encountered fatal error, operation suspended\n"); 1152 if (!t3_cim_ctl_blk_read(sc, 0xa0, 4, fw_status)) 1153 device_printf(sc->dev, "FW_ status: 0x%x, 0x%x, 0x%x, 0x%x\n", 1154 fw_status[0], fw_status[1], fw_status[2], fw_status[3]); 1155 } 1156 1157 int 1158 t3_os_find_pci_capability(adapter_t *sc, int cap) 1159 { 1160 device_t dev; 1161 struct pci_devinfo *dinfo; 1162 pcicfgregs *cfg; 1163 uint32_t status; 1164 uint8_t ptr; 1165 1166 dev = sc->dev; 1167 dinfo = device_get_ivars(dev); 1168 cfg = &dinfo->cfg; 1169 1170 status = pci_read_config(dev, PCIR_STATUS, 2); 1171 if (!(status & PCIM_STATUS_CAPPRESENT)) 1172 return (0); 1173 1174 switch (cfg->hdrtype & PCIM_HDRTYPE) { 1175 case 0: 1176 case 1: 1177 ptr = PCIR_CAP_PTR; 1178 break; 1179 case 2: 1180 ptr = PCIR_CAP_PTR_2; 1181 break; 1182 default: 1183 return (0); 1184 break; 1185 } 1186 ptr = pci_read_config(dev, ptr, 1); 1187 1188 while (ptr != 0) { 1189 if (pci_read_config(dev, ptr + PCICAP_ID, 1) == cap) 1190 return (ptr); 1191 ptr = pci_read_config(dev, ptr + PCICAP_NEXTPTR, 1); 1192 } 1193 1194 return (0); 1195 } 1196 1197 int 1198 t3_os_pci_save_state(struct adapter *sc) 1199 { 1200 device_t dev; 1201 struct pci_devinfo *dinfo; 1202 1203 dev = sc->dev; 1204 dinfo = device_get_ivars(dev); 1205 1206 pci_cfg_save(dev, dinfo, 0); 1207 return (0); 1208 } 1209 1210 int 1211 t3_os_pci_restore_state(struct adapter *sc) 1212 { 1213 device_t dev; 1214 struct pci_devinfo *dinfo; 1215 1216 dev = sc->dev; 1217 dinfo = device_get_ivars(dev); 1218 1219 pci_cfg_restore(dev, dinfo); 1220 return (0); 1221 } 1222 1223 /** 1224 * t3_os_link_changed - handle link status changes 1225 * @adapter: the adapter associated with the link change 1226 * @port_id: the port index whose limk status has changed 1227 * @link_status: the new status of the link 1228 * @speed: the new speed setting 1229 * @duplex: the new duplex setting 1230 * @fc: the new flow-control setting 1231 * 1232 * This is the OS-dependent handler for link status changes. The OS 1233 * neutral handler takes care of most of the processing for these events, 1234 * then calls this handler for any OS-specific processing. 1235 */ 1236 void 1237 t3_os_link_changed(adapter_t *adapter, int port_id, int link_status, int speed, 1238 int duplex, int fc) 1239 { 1240 struct port_info *pi = &adapter->port[port_id]; 1241 struct ifnet *ifp = pi->ifp; 1242 1243 /* no race with detach, so ifp should always be good */ 1244 KASSERT(ifp, ("%s: if detached.", __func__)); 1245 1246 if (link_status) { 1247 ifp->if_baudrate = IF_Mbps(speed); 1248 if_link_state_change(ifp, LINK_STATE_UP); 1249 } else 1250 if_link_state_change(ifp, LINK_STATE_DOWN); 1251 } 1252 1253 /** 1254 * t3_os_phymod_changed - handle PHY module changes 1255 * @phy: the PHY reporting the module change 1256 * @mod_type: new module type 1257 * 1258 * This is the OS-dependent handler for PHY module changes. It is 1259 * invoked when a PHY module is removed or inserted for any OS-specific 1260 * processing. 1261 */ 1262 void t3_os_phymod_changed(struct adapter *adap, int port_id) 1263 { 1264 static const char *mod_str[] = { 1265 NULL, "SR", "LR", "LRM", "TWINAX", "TWINAX", "unknown" 1266 }; 1267 struct port_info *pi = &adap->port[port_id]; 1268 int mod = pi->phy.modtype; 1269 1270 if (mod != pi->media.ifm_cur->ifm_data) 1271 cxgb_build_medialist(pi); 1272 1273 if (mod == phy_modtype_none) 1274 if_printf(pi->ifp, "PHY module unplugged\n"); 1275 else { 1276 KASSERT(mod < ARRAY_SIZE(mod_str), 1277 ("invalid PHY module type %d", mod)); 1278 if_printf(pi->ifp, "%s PHY module inserted\n", mod_str[mod]); 1279 } 1280 } 1281 1282 /* 1283 * Interrupt-context handler for external (PHY) interrupts. 1284 */ 1285 void 1286 t3_os_ext_intr_handler(adapter_t *sc) 1287 { 1288 if (cxgb_debug) 1289 printf("t3_os_ext_intr_handler\n"); 1290 /* 1291 * Schedule a task to handle external interrupts as they may be slow 1292 * and we use a mutex to protect MDIO registers. We disable PHY 1293 * interrupts in the meantime and let the task reenable them when 1294 * it's done. 1295 */ 1296 if (sc->slow_intr_mask) { 1297 ADAPTER_LOCK(sc); 1298 sc->slow_intr_mask &= ~F_T3DBG; 1299 t3_write_reg(sc, A_PL_INT_ENABLE0, sc->slow_intr_mask); 1300 taskqueue_enqueue(sc->tq, &sc->ext_intr_task); 1301 ADAPTER_UNLOCK(sc); 1302 } 1303 } 1304 1305 void 1306 t3_os_set_hw_addr(adapter_t *adapter, int port_idx, u8 hw_addr[]) 1307 { 1308 1309 /* 1310 * The ifnet might not be allocated before this gets called, 1311 * as this is called early on in attach by t3_prep_adapter 1312 * save the address off in the port structure 1313 */ 1314 if (cxgb_debug) 1315 printf("set_hw_addr on idx %d addr %6D\n", port_idx, hw_addr, ":"); 1316 bcopy(hw_addr, adapter->port[port_idx].hw_addr, ETHER_ADDR_LEN); 1317 } 1318 1319 /* 1320 * Programs the XGMAC based on the settings in the ifnet. These settings 1321 * include MTU, MAC address, mcast addresses, etc. 1322 */ 1323 static void 1324 cxgb_update_mac_settings(struct port_info *p) 1325 { 1326 struct ifnet *ifp = p->ifp; 1327 struct t3_rx_mode rm; 1328 struct cmac *mac = &p->mac; 1329 int mtu, hwtagging; 1330 1331 PORT_LOCK_ASSERT_OWNED(p); 1332 1333 bcopy(IF_LLADDR(ifp), p->hw_addr, ETHER_ADDR_LEN); 1334 1335 mtu = ifp->if_mtu; 1336 if (ifp->if_capenable & IFCAP_VLAN_MTU) 1337 mtu += ETHER_VLAN_ENCAP_LEN; 1338 1339 hwtagging = (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0; 1340 1341 t3_mac_set_mtu(mac, mtu); 1342 t3_set_vlan_accel(p->adapter, 1 << p->tx_chan, hwtagging); 1343 t3_mac_set_address(mac, 0, p->hw_addr); 1344 t3_init_rx_mode(&rm, p); 1345 t3_mac_set_rx_mode(mac, &rm); 1346 } 1347 1348 1349 static int 1350 await_mgmt_replies(struct adapter *adap, unsigned long init_cnt, 1351 unsigned long n) 1352 { 1353 int attempts = 5; 1354 1355 while (adap->sge.qs[0].rspq.offload_pkts < init_cnt + n) { 1356 if (!--attempts) 1357 return (ETIMEDOUT); 1358 t3_os_sleep(10); 1359 } 1360 return 0; 1361 } 1362 1363 static int 1364 init_tp_parity(struct adapter *adap) 1365 { 1366 int i; 1367 struct mbuf *m; 1368 struct cpl_set_tcb_field *greq; 1369 unsigned long cnt = adap->sge.qs[0].rspq.offload_pkts; 1370 1371 t3_tp_set_offload_mode(adap, 1); 1372 1373 for (i = 0; i < 16; i++) { 1374 struct cpl_smt_write_req *req; 1375 1376 m = m_gethdr(M_WAITOK, MT_DATA); 1377 req = mtod(m, struct cpl_smt_write_req *); 1378 m->m_len = m->m_pkthdr.len = sizeof(*req); 1379 memset(req, 0, sizeof(*req)); 1380 req->wr.wrh_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD)); 1381 OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SMT_WRITE_REQ, i)); 1382 req->iff = i; 1383 t3_mgmt_tx(adap, m); 1384 } 1385 1386 for (i = 0; i < 2048; i++) { 1387 struct cpl_l2t_write_req *req; 1388 1389 m = m_gethdr(M_WAITOK, MT_DATA); 1390 req = mtod(m, struct cpl_l2t_write_req *); 1391 m->m_len = m->m_pkthdr.len = sizeof(*req); 1392 memset(req, 0, sizeof(*req)); 1393 req->wr.wrh_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD)); 1394 OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_L2T_WRITE_REQ, i)); 1395 req->params = htonl(V_L2T_W_IDX(i)); 1396 t3_mgmt_tx(adap, m); 1397 } 1398 1399 for (i = 0; i < 2048; i++) { 1400 struct cpl_rte_write_req *req; 1401 1402 m = m_gethdr(M_WAITOK, MT_DATA); 1403 req = mtod(m, struct cpl_rte_write_req *); 1404 m->m_len = m->m_pkthdr.len = sizeof(*req); 1405 memset(req, 0, sizeof(*req)); 1406 req->wr.wrh_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD)); 1407 OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_RTE_WRITE_REQ, i)); 1408 req->l2t_idx = htonl(V_L2T_W_IDX(i)); 1409 t3_mgmt_tx(adap, m); 1410 } 1411 1412 m = m_gethdr(M_WAITOK, MT_DATA); 1413 greq = mtod(m, struct cpl_set_tcb_field *); 1414 m->m_len = m->m_pkthdr.len = sizeof(*greq); 1415 memset(greq, 0, sizeof(*greq)); 1416 greq->wr.wrh_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD)); 1417 OPCODE_TID(greq) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, 0)); 1418 greq->mask = htobe64(1); 1419 t3_mgmt_tx(adap, m); 1420 1421 i = await_mgmt_replies(adap, cnt, 16 + 2048 + 2048 + 1); 1422 t3_tp_set_offload_mode(adap, 0); 1423 return (i); 1424 } 1425 1426 /** 1427 * setup_rss - configure Receive Side Steering (per-queue connection demux) 1428 * @adap: the adapter 1429 * 1430 * Sets up RSS to distribute packets to multiple receive queues. We 1431 * configure the RSS CPU lookup table to distribute to the number of HW 1432 * receive queues, and the response queue lookup table to narrow that 1433 * down to the response queues actually configured for each port. 1434 * We always configure the RSS mapping for two ports since the mapping 1435 * table has plenty of entries. 1436 */ 1437 static void 1438 setup_rss(adapter_t *adap) 1439 { 1440 int i; 1441 u_int nq[2]; 1442 uint8_t cpus[SGE_QSETS + 1]; 1443 uint16_t rspq_map[RSS_TABLE_SIZE]; 1444 1445 for (i = 0; i < SGE_QSETS; ++i) 1446 cpus[i] = i; 1447 cpus[SGE_QSETS] = 0xff; 1448 1449 nq[0] = nq[1] = 0; 1450 for_each_port(adap, i) { 1451 const struct port_info *pi = adap2pinfo(adap, i); 1452 1453 nq[pi->tx_chan] += pi->nqsets; 1454 } 1455 for (i = 0; i < RSS_TABLE_SIZE / 2; ++i) { 1456 rspq_map[i] = nq[0] ? i % nq[0] : 0; 1457 rspq_map[i + RSS_TABLE_SIZE / 2] = nq[1] ? i % nq[1] + nq[0] : 0; 1458 } 1459 /* Calculate the reverse RSS map table */ 1460 for (i = 0; i < RSS_TABLE_SIZE; ++i) 1461 if (adap->rrss_map[rspq_map[i]] == 0xff) 1462 adap->rrss_map[rspq_map[i]] = i; 1463 1464 t3_config_rss(adap, F_RQFEEDBACKENABLE | F_TNLLKPEN | F_TNLMAPEN | 1465 F_TNLPRTEN | F_TNL2TUPEN | F_TNL4TUPEN | F_OFDMAPEN | 1466 F_RRCPLMAPEN | V_RRCPLCPUSIZE(6) | F_HASHTOEPLITZ, 1467 cpus, rspq_map); 1468 1469 } 1470 1471 /* 1472 * Sends an mbuf to an offload queue driver 1473 * after dealing with any active network taps. 1474 */ 1475 static inline int 1476 offload_tx(struct t3cdev *tdev, struct mbuf *m) 1477 { 1478 int ret; 1479 1480 ret = t3_offload_tx(tdev, m); 1481 return (ret); 1482 } 1483 1484 static int 1485 write_smt_entry(struct adapter *adapter, int idx) 1486 { 1487 struct port_info *pi = &adapter->port[idx]; 1488 struct cpl_smt_write_req *req; 1489 struct mbuf *m; 1490 1491 if ((m = m_gethdr(M_NOWAIT, MT_DATA)) == NULL) 1492 return (ENOMEM); 1493 1494 req = mtod(m, struct cpl_smt_write_req *); 1495 m->m_pkthdr.len = m->m_len = sizeof(struct cpl_smt_write_req); 1496 1497 req->wr.wrh_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD)); 1498 OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SMT_WRITE_REQ, idx)); 1499 req->mtu_idx = NMTUS - 1; /* should be 0 but there's a T3 bug */ 1500 req->iff = idx; 1501 memset(req->src_mac1, 0, sizeof(req->src_mac1)); 1502 memcpy(req->src_mac0, pi->hw_addr, ETHER_ADDR_LEN); 1503 1504 m_set_priority(m, 1); 1505 1506 offload_tx(&adapter->tdev, m); 1507 1508 return (0); 1509 } 1510 1511 static int 1512 init_smt(struct adapter *adapter) 1513 { 1514 int i; 1515 1516 for_each_port(adapter, i) 1517 write_smt_entry(adapter, i); 1518 return 0; 1519 } 1520 1521 static void 1522 init_port_mtus(adapter_t *adapter) 1523 { 1524 unsigned int mtus = ETHERMTU | (ETHERMTU << 16); 1525 1526 t3_write_reg(adapter, A_TP_MTU_PORT_TABLE, mtus); 1527 } 1528 1529 static void 1530 send_pktsched_cmd(struct adapter *adap, int sched, int qidx, int lo, 1531 int hi, int port) 1532 { 1533 struct mbuf *m; 1534 struct mngt_pktsched_wr *req; 1535 1536 m = m_gethdr(M_DONTWAIT, MT_DATA); 1537 if (m) { 1538 req = mtod(m, struct mngt_pktsched_wr *); 1539 req->wr.wrh_hi = htonl(V_WR_OP(FW_WROPCODE_MNGT)); 1540 req->mngt_opcode = FW_MNGTOPCODE_PKTSCHED_SET; 1541 req->sched = sched; 1542 req->idx = qidx; 1543 req->min = lo; 1544 req->max = hi; 1545 req->binding = port; 1546 m->m_len = m->m_pkthdr.len = sizeof(*req); 1547 t3_mgmt_tx(adap, m); 1548 } 1549 } 1550 1551 static void 1552 bind_qsets(adapter_t *sc) 1553 { 1554 int i, j; 1555 1556 for (i = 0; i < (sc)->params.nports; ++i) { 1557 const struct port_info *pi = adap2pinfo(sc, i); 1558 1559 for (j = 0; j < pi->nqsets; ++j) { 1560 send_pktsched_cmd(sc, 1, pi->first_qset + j, -1, 1561 -1, pi->tx_chan); 1562 1563 } 1564 } 1565 } 1566 1567 static void 1568 update_tpeeprom(struct adapter *adap) 1569 { 1570 #ifdef FIRMWARE_LATEST 1571 const struct firmware *tpeeprom; 1572 #else 1573 struct firmware *tpeeprom; 1574 #endif 1575 1576 uint32_t version; 1577 unsigned int major, minor; 1578 int ret, len; 1579 char rev, name[32]; 1580 1581 t3_seeprom_read(adap, TP_SRAM_OFFSET, &version); 1582 1583 major = G_TP_VERSION_MAJOR(version); 1584 minor = G_TP_VERSION_MINOR(version); 1585 if (major == TP_VERSION_MAJOR && minor == TP_VERSION_MINOR) 1586 return; 1587 1588 rev = t3rev2char(adap); 1589 snprintf(name, sizeof(name), TPEEPROM_NAME, rev); 1590 1591 tpeeprom = firmware_get(name); 1592 if (tpeeprom == NULL) { 1593 device_printf(adap->dev, 1594 "could not load TP EEPROM: unable to load %s\n", 1595 name); 1596 return; 1597 } 1598 1599 len = tpeeprom->datasize - 4; 1600 1601 ret = t3_check_tpsram(adap, tpeeprom->data, tpeeprom->datasize); 1602 if (ret) 1603 goto release_tpeeprom; 1604 1605 if (len != TP_SRAM_LEN) { 1606 device_printf(adap->dev, 1607 "%s length is wrong len=%d expected=%d\n", name, 1608 len, TP_SRAM_LEN); 1609 return; 1610 } 1611 1612 ret = set_eeprom(&adap->port[0], tpeeprom->data, tpeeprom->datasize, 1613 TP_SRAM_OFFSET); 1614 1615 if (!ret) { 1616 device_printf(adap->dev, 1617 "Protocol SRAM image updated in EEPROM to %d.%d.%d\n", 1618 TP_VERSION_MAJOR, TP_VERSION_MINOR, TP_VERSION_MICRO); 1619 } else 1620 device_printf(adap->dev, 1621 "Protocol SRAM image update in EEPROM failed\n"); 1622 1623 release_tpeeprom: 1624 firmware_put(tpeeprom, FIRMWARE_UNLOAD); 1625 1626 return; 1627 } 1628 1629 static int 1630 update_tpsram(struct adapter *adap) 1631 { 1632 #ifdef FIRMWARE_LATEST 1633 const struct firmware *tpsram; 1634 #else 1635 struct firmware *tpsram; 1636 #endif 1637 int ret; 1638 char rev, name[32]; 1639 1640 rev = t3rev2char(adap); 1641 snprintf(name, sizeof(name), TPSRAM_NAME, rev); 1642 1643 update_tpeeprom(adap); 1644 1645 tpsram = firmware_get(name); 1646 if (tpsram == NULL){ 1647 device_printf(adap->dev, "could not load TP SRAM\n"); 1648 return (EINVAL); 1649 } else 1650 device_printf(adap->dev, "updating TP SRAM\n"); 1651 1652 ret = t3_check_tpsram(adap, tpsram->data, tpsram->datasize); 1653 if (ret) 1654 goto release_tpsram; 1655 1656 ret = t3_set_proto_sram(adap, tpsram->data); 1657 if (ret) 1658 device_printf(adap->dev, "loading protocol SRAM failed\n"); 1659 1660 release_tpsram: 1661 firmware_put(tpsram, FIRMWARE_UNLOAD); 1662 1663 return ret; 1664 } 1665 1666 /** 1667 * cxgb_up - enable the adapter 1668 * @adap: adapter being enabled 1669 * 1670 * Called when the first port is enabled, this function performs the 1671 * actions necessary to make an adapter operational, such as completing 1672 * the initialization of HW modules, and enabling interrupts. 1673 */ 1674 static int 1675 cxgb_up(struct adapter *sc) 1676 { 1677 int err = 0; 1678 1679 ADAPTER_LOCK_ASSERT_NOTOWNED(sc); 1680 KASSERT(sc->open_device_map == 0, ("%s: device(s) already open (%x)", 1681 __func__, sc->open_device_map)); 1682 1683 if ((sc->flags & FULL_INIT_DONE) == 0) { 1684 1685 if ((sc->flags & FW_UPTODATE) == 0) 1686 if ((err = upgrade_fw(sc))) 1687 goto out; 1688 1689 if ((sc->flags & TPS_UPTODATE) == 0) 1690 if ((err = update_tpsram(sc))) 1691 goto out; 1692 1693 err = t3_init_hw(sc, 0); 1694 if (err) 1695 goto out; 1696 1697 t3_set_reg_field(sc, A_TP_PARA_REG5, 0, F_RXDDPOFFINIT); 1698 t3_write_reg(sc, A_ULPRX_TDDP_PSZ, V_HPZ0(PAGE_SHIFT - 12)); 1699 1700 err = setup_sge_qsets(sc); 1701 if (err) 1702 goto out; 1703 1704 setup_rss(sc); 1705 1706 t3_intr_clear(sc); 1707 err = cxgb_setup_interrupts(sc); 1708 if (err) 1709 goto out; 1710 1711 t3_add_configured_sysctls(sc); 1712 sc->flags |= FULL_INIT_DONE; 1713 } 1714 1715 t3_intr_clear(sc); 1716 t3_sge_start(sc); 1717 t3_intr_enable(sc); 1718 1719 if (sc->params.rev >= T3_REV_C && !(sc->flags & TP_PARITY_INIT) && 1720 is_offload(sc) && init_tp_parity(sc) == 0) 1721 sc->flags |= TP_PARITY_INIT; 1722 1723 if (sc->flags & TP_PARITY_INIT) { 1724 t3_write_reg(sc, A_TP_INT_CAUSE, F_CMCACHEPERR | F_ARPLUTPERR); 1725 t3_write_reg(sc, A_TP_INT_ENABLE, 0x7fbfffff); 1726 } 1727 1728 if (!(sc->flags & QUEUES_BOUND)) { 1729 bind_qsets(sc); 1730 sc->flags |= QUEUES_BOUND; 1731 } 1732 1733 t3_sge_reset_adapter(sc); 1734 out: 1735 return (err); 1736 } 1737 1738 /* 1739 * Called when the last open device is closed. Does NOT undo all of cxgb_up's 1740 * work. Specifically, the resources grabbed under FULL_INIT_DONE are released 1741 * during controller_detach, not here. 1742 */ 1743 static void 1744 cxgb_down(struct adapter *sc) 1745 { 1746 ADAPTER_LOCK_ASSERT_NOTOWNED(sc); 1747 1748 t3_sge_stop(sc); 1749 t3_intr_disable(sc); 1750 } 1751 1752 static int 1753 offload_open(struct port_info *pi) 1754 { 1755 struct adapter *sc = pi->adapter; 1756 struct t3cdev *tdev = &sc->tdev; 1757 1758 ADAPTER_LOCK_ASSERT_NOTOWNED(sc); 1759 1760 setbit(&sc->open_device_map, OFFLOAD_DEVMAP_BIT); 1761 1762 t3_tp_set_offload_mode(sc, 1); 1763 tdev->lldev = pi->ifp; 1764 init_port_mtus(sc); 1765 t3_load_mtus(sc, sc->params.mtus, sc->params.a_wnd, sc->params.b_wnd, 1766 sc->params.rev == 0 ? sc->port[0].ifp->if_mtu : 0xffff); 1767 init_smt(sc); 1768 cxgb_add_clients(tdev); 1769 1770 return (0); 1771 } 1772 1773 static int 1774 offload_close(struct t3cdev *tdev) 1775 { 1776 struct adapter *adapter = tdev2adap(tdev); 1777 1778 if (!isset(&adapter->open_device_map, OFFLOAD_DEVMAP_BIT)) 1779 return (0); 1780 1781 /* Call back all registered clients */ 1782 cxgb_remove_clients(tdev); 1783 1784 tdev->lldev = NULL; 1785 cxgb_set_dummy_ops(tdev); 1786 t3_tp_set_offload_mode(adapter, 0); 1787 1788 clrbit(&adapter->open_device_map, OFFLOAD_DEVMAP_BIT); 1789 1790 return (0); 1791 } 1792 1793 /* 1794 * Begin a synchronized operation. If this call succeeds, it is guaranteed that 1795 * no one will remove the port or its ifp from underneath the caller. Caller is 1796 * also granted exclusive access to open_device_map. 1797 * 1798 * operation here means init, uninit, detach, and ioctl service. 1799 * 1800 * May fail. 1801 * EINTR (ctrl-c pressed during ifconfig for example). 1802 * ENXIO (port is about to detach - due to kldunload for example). 1803 */ 1804 int 1805 cxgb_begin_op(struct port_info *p, const char *wmsg) 1806 { 1807 int rc = 0; 1808 struct adapter *sc = p->adapter; 1809 1810 ADAPTER_LOCK(sc); 1811 1812 while (!IS_DOOMED(p) && IS_BUSY(sc)) { 1813 if (mtx_sleep(&sc->flags, &sc->lock, PCATCH, wmsg, 0)) { 1814 rc = EINTR; 1815 goto done; 1816 } 1817 } 1818 1819 if (IS_DOOMED(p)) 1820 rc = ENXIO; 1821 else if (!IS_BUSY(sc)) 1822 SET_BUSY(sc); 1823 else { 1824 KASSERT(0, ("%s: port %d, p->flags = %x , sc->flags = %x", 1825 __func__, p->port_id, p->flags, sc->flags)); 1826 rc = EDOOFUS; 1827 } 1828 1829 done: 1830 ADAPTER_UNLOCK(sc); 1831 return (rc); 1832 } 1833 1834 /* 1835 * End a synchronized operation. Read comment block above cxgb_begin_op. 1836 */ 1837 int 1838 cxgb_end_op(struct port_info *p) 1839 { 1840 struct adapter *sc = p->adapter; 1841 1842 ADAPTER_LOCK(sc); 1843 KASSERT(IS_BUSY(sc), ("%s: not busy.", __func__)); 1844 CLR_BUSY(sc); 1845 wakeup_one(&sc->flags); 1846 ADAPTER_UNLOCK(sc); 1847 1848 return (0); 1849 } 1850 1851 /* 1852 * Prepare for port detachment. Detach is a special kind of synchronized 1853 * operation. Also read comment before cxgb_begin_op. 1854 */ 1855 static int 1856 cxgb_begin_detach(struct port_info *p) 1857 { 1858 struct adapter *sc = p->adapter; 1859 1860 /* 1861 * Inform those waiting for this port that it is going to be destroyed 1862 * and they should not continue further. (They'll return with ENXIO). 1863 */ 1864 ADAPTER_LOCK(sc); 1865 SET_DOOMED(p); 1866 wakeup(&sc->flags); 1867 ADAPTER_UNLOCK(sc); 1868 1869 /* 1870 * Wait for in-progress operations. 1871 */ 1872 ADAPTER_LOCK(sc); 1873 while (IS_BUSY(sc)) { 1874 mtx_sleep(&sc->flags, &sc->lock, 0, "cxgbdtch", 0); 1875 } 1876 SET_BUSY(sc); 1877 ADAPTER_UNLOCK(sc); 1878 1879 return (0); 1880 } 1881 1882 /* 1883 * if_init for cxgb ports. 1884 */ 1885 static void 1886 cxgb_init(void *arg) 1887 { 1888 struct port_info *p = arg; 1889 1890 if (cxgb_begin_op(p, "cxgbinit")) 1891 return; 1892 1893 cxgb_init_synchronized(p); 1894 cxgb_end_op(p); 1895 } 1896 1897 static int 1898 cxgb_init_synchronized(struct port_info *p) 1899 { 1900 struct adapter *sc = p->adapter; 1901 struct ifnet *ifp = p->ifp; 1902 struct cmac *mac = &p->mac; 1903 int i, rc; 1904 1905 if (sc->open_device_map == 0) { 1906 if ((rc = cxgb_up(sc)) != 0) 1907 return (rc); 1908 1909 if (is_offload(sc) && !ofld_disable && offload_open(p)) 1910 log(LOG_WARNING, 1911 "Could not initialize offload capabilities\n"); 1912 } 1913 1914 PORT_LOCK(p); 1915 t3_port_intr_enable(sc, p->port_id); 1916 if (!mac->multiport) 1917 t3_mac_reset(mac); 1918 cxgb_update_mac_settings(p); 1919 t3_link_start(&p->phy, mac, &p->link_config); 1920 t3_mac_enable(mac, MAC_DIRECTION_RX | MAC_DIRECTION_TX); 1921 ifp->if_drv_flags |= IFF_DRV_RUNNING; 1922 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 1923 PORT_UNLOCK(p); 1924 1925 t3_link_changed(sc, p->port_id); 1926 1927 for (i = p->first_qset; i < p->first_qset + p->nqsets; i++) { 1928 struct sge_qset *qs = &sc->sge.qs[i]; 1929 struct sge_txq *txq = &qs->txq[TXQ_ETH]; 1930 1931 callout_reset_on(&txq->txq_watchdog, hz, cxgb_tx_watchdog, qs, 1932 txq->txq_watchdog.c_cpu); 1933 } 1934 1935 /* all ok */ 1936 setbit(&sc->open_device_map, p->port_id); 1937 1938 return (0); 1939 } 1940 1941 /* 1942 * Called on "ifconfig down", and from port_detach 1943 */ 1944 static int 1945 cxgb_uninit_synchronized(struct port_info *pi) 1946 { 1947 struct adapter *sc = pi->adapter; 1948 struct ifnet *ifp = pi->ifp; 1949 1950 /* 1951 * Clear this port's bit from the open device map, and then drain all 1952 * the tasks that can access/manipulate this port's port_info or ifp. 1953 * We disable this port's interrupts here and so the the slow/ext 1954 * interrupt tasks won't be enqueued. The tick task will continue to 1955 * be enqueued every second but the runs after this drain will not see 1956 * this port in the open device map. 1957 * 1958 * A well behaved task must take open_device_map into account and ignore 1959 * ports that are not open. 1960 */ 1961 clrbit(&sc->open_device_map, pi->port_id); 1962 t3_port_intr_disable(sc, pi->port_id); 1963 taskqueue_drain(sc->tq, &sc->slow_intr_task); 1964 taskqueue_drain(sc->tq, &sc->ext_intr_task); 1965 taskqueue_drain(sc->tq, &sc->tick_task); 1966 1967 PORT_LOCK(pi); 1968 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); 1969 1970 /* disable pause frames */ 1971 t3_set_reg_field(sc, A_XGM_TX_CFG + pi->mac.offset, F_TXPAUSEEN, 0); 1972 1973 /* Reset RX FIFO HWM */ 1974 t3_set_reg_field(sc, A_XGM_RXFIFO_CFG + pi->mac.offset, 1975 V_RXFIFOPAUSEHWM(M_RXFIFOPAUSEHWM), 0); 1976 1977 DELAY(100); 1978 1979 /* Wait for TXFIFO empty */ 1980 t3_wait_op_done(sc, A_XGM_TXFIFO_CFG + pi->mac.offset, 1981 F_TXFIFO_EMPTY, 1, 20, 5); 1982 1983 DELAY(100); 1984 t3_mac_disable(&pi->mac, MAC_DIRECTION_TX | MAC_DIRECTION_RX); 1985 1986 1987 pi->phy.ops->power_down(&pi->phy, 1); 1988 1989 PORT_UNLOCK(pi); 1990 1991 pi->link_config.link_ok = 0; 1992 t3_os_link_changed(sc, pi->port_id, 0, 0, 0, 0); 1993 1994 if ((sc->open_device_map & PORT_MASK) == 0) 1995 offload_close(&sc->tdev); 1996 1997 if (sc->open_device_map == 0) 1998 cxgb_down(pi->adapter); 1999 2000 return (0); 2001 } 2002 2003 #ifdef LRO_SUPPORTED 2004 /* 2005 * Mark lro enabled or disabled in all qsets for this port 2006 */ 2007 static int 2008 cxgb_set_lro(struct port_info *p, int enabled) 2009 { 2010 int i; 2011 struct adapter *adp = p->adapter; 2012 struct sge_qset *q; 2013 2014 PORT_LOCK_ASSERT_OWNED(p); 2015 for (i = 0; i < p->nqsets; i++) { 2016 q = &adp->sge.qs[p->first_qset + i]; 2017 q->lro.enabled = (enabled != 0); 2018 } 2019 return (0); 2020 } 2021 #endif 2022 2023 static int 2024 cxgb_ioctl(struct ifnet *ifp, unsigned long command, caddr_t data) 2025 { 2026 struct port_info *p = ifp->if_softc; 2027 struct ifreq *ifr = (struct ifreq *)data; 2028 int flags, error = 0, mtu, handle_unsynchronized = 0; 2029 uint32_t mask; 2030 2031 if ((error = cxgb_begin_op(p, "cxgbioct")) != 0) 2032 return (error); 2033 2034 /* 2035 * Only commands that should be handled within begin-op/end-op are 2036 * serviced in this switch statement. See handle_unsynchronized. 2037 */ 2038 switch (command) { 2039 case SIOCSIFMTU: 2040 mtu = ifr->ifr_mtu; 2041 if ((mtu < ETHERMIN) || (mtu > ETHERMTU_JUMBO)) { 2042 error = EINVAL; 2043 } else { 2044 ifp->if_mtu = mtu; 2045 PORT_LOCK(p); 2046 cxgb_update_mac_settings(p); 2047 PORT_UNLOCK(p); 2048 } 2049 2050 break; 2051 case SIOCSIFFLAGS: 2052 if (ifp->if_flags & IFF_UP) { 2053 if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 2054 flags = p->if_flags; 2055 if (((ifp->if_flags ^ flags) & IFF_PROMISC) || 2056 ((ifp->if_flags ^ flags) & IFF_ALLMULTI)) { 2057 PORT_LOCK(p); 2058 cxgb_update_mac_settings(p); 2059 PORT_UNLOCK(p); 2060 } 2061 } else 2062 error = cxgb_init_synchronized(p); 2063 p->if_flags = ifp->if_flags; 2064 } else if (ifp->if_drv_flags & IFF_DRV_RUNNING) 2065 error = cxgb_uninit_synchronized(p); 2066 2067 break; 2068 case SIOCADDMULTI: 2069 case SIOCDELMULTI: 2070 if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 2071 PORT_LOCK(p); 2072 cxgb_update_mac_settings(p); 2073 PORT_UNLOCK(p); 2074 } 2075 2076 break; 2077 case SIOCSIFCAP: 2078 mask = ifr->ifr_reqcap ^ ifp->if_capenable; 2079 if (mask & IFCAP_TXCSUM) { 2080 if (IFCAP_TXCSUM & ifp->if_capenable) { 2081 ifp->if_capenable &= ~(IFCAP_TXCSUM|IFCAP_TSO4); 2082 ifp->if_hwassist &= ~(CSUM_TCP | CSUM_UDP 2083 | CSUM_IP | CSUM_TSO); 2084 } else { 2085 ifp->if_capenable |= IFCAP_TXCSUM; 2086 ifp->if_hwassist |= (CSUM_TCP | CSUM_UDP 2087 | CSUM_IP); 2088 } 2089 } 2090 if (mask & IFCAP_RXCSUM) { 2091 ifp->if_capenable ^= IFCAP_RXCSUM; 2092 } 2093 if (mask & IFCAP_TSO4) { 2094 if (IFCAP_TSO4 & ifp->if_capenable) { 2095 ifp->if_capenable &= ~IFCAP_TSO4; 2096 ifp->if_hwassist &= ~CSUM_TSO; 2097 } else if (IFCAP_TXCSUM & ifp->if_capenable) { 2098 ifp->if_capenable |= IFCAP_TSO4; 2099 ifp->if_hwassist |= CSUM_TSO; 2100 } else 2101 error = EINVAL; 2102 } 2103 #ifdef LRO_SUPPORTED 2104 if (mask & IFCAP_LRO) { 2105 ifp->if_capenable ^= IFCAP_LRO; 2106 2107 /* Safe to do this even if cxgb_up not called yet */ 2108 cxgb_set_lro(p, ifp->if_capenable & IFCAP_LRO); 2109 } 2110 #endif 2111 if (mask & IFCAP_VLAN_HWTAGGING) { 2112 ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING; 2113 if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 2114 PORT_LOCK(p); 2115 cxgb_update_mac_settings(p); 2116 PORT_UNLOCK(p); 2117 } 2118 } 2119 if (mask & IFCAP_VLAN_MTU) { 2120 ifp->if_capenable ^= IFCAP_VLAN_MTU; 2121 if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 2122 PORT_LOCK(p); 2123 cxgb_update_mac_settings(p); 2124 PORT_UNLOCK(p); 2125 } 2126 } 2127 if (mask & IFCAP_VLAN_HWCSUM) { 2128 ifp->if_capenable ^= IFCAP_VLAN_HWCSUM; 2129 } 2130 2131 #ifdef VLAN_CAPABILITIES 2132 VLAN_CAPABILITIES(ifp); 2133 #endif 2134 break; 2135 default: 2136 handle_unsynchronized = 1; 2137 break; 2138 } 2139 2140 /* 2141 * We don't want to call anything outside the driver while inside a 2142 * begin-op/end-op block. If it calls us back (eg. ether_ioctl may 2143 * call cxgb_init) we may deadlock if the state is already marked busy. 2144 * 2145 * XXX: this probably opens a small race window with kldunload... 2146 */ 2147 cxgb_end_op(p); 2148 2149 /* The IS_DOOMED check is racy, we're clutching at straws here */ 2150 if (handle_unsynchronized && !IS_DOOMED(p)) { 2151 if (command == SIOCSIFMEDIA || command == SIOCGIFMEDIA) 2152 error = ifmedia_ioctl(ifp, ifr, &p->media, command); 2153 else 2154 error = ether_ioctl(ifp, command, data); 2155 } 2156 2157 return (error); 2158 } 2159 2160 static int 2161 cxgb_media_change(struct ifnet *ifp) 2162 { 2163 return (EOPNOTSUPP); 2164 } 2165 2166 /* 2167 * Translates phy->modtype to the correct Ethernet media subtype. 2168 */ 2169 static int 2170 cxgb_ifm_type(int mod) 2171 { 2172 switch (mod) { 2173 case phy_modtype_sr: 2174 return (IFM_10G_SR); 2175 case phy_modtype_lr: 2176 return (IFM_10G_LR); 2177 case phy_modtype_lrm: 2178 return (IFM_10G_LRM); 2179 case phy_modtype_twinax: 2180 return (IFM_10G_TWINAX); 2181 case phy_modtype_twinax_long: 2182 return (IFM_10G_TWINAX_LONG); 2183 case phy_modtype_none: 2184 return (IFM_NONE); 2185 case phy_modtype_unknown: 2186 return (IFM_UNKNOWN); 2187 } 2188 2189 KASSERT(0, ("%s: modtype %d unknown", __func__, mod)); 2190 return (IFM_UNKNOWN); 2191 } 2192 2193 /* 2194 * Rebuilds the ifmedia list for this port, and sets the current media. 2195 */ 2196 static void 2197 cxgb_build_medialist(struct port_info *p) 2198 { 2199 struct cphy *phy = &p->phy; 2200 struct ifmedia *media = &p->media; 2201 int mod = phy->modtype; 2202 int m = IFM_ETHER | IFM_FDX; 2203 2204 PORT_LOCK(p); 2205 2206 ifmedia_removeall(media); 2207 if (phy->caps & SUPPORTED_TP && phy->caps & SUPPORTED_Autoneg) { 2208 /* Copper (RJ45) */ 2209 2210 if (phy->caps & SUPPORTED_10000baseT_Full) 2211 ifmedia_add(media, m | IFM_10G_T, mod, NULL); 2212 2213 if (phy->caps & SUPPORTED_1000baseT_Full) 2214 ifmedia_add(media, m | IFM_1000_T, mod, NULL); 2215 2216 if (phy->caps & SUPPORTED_100baseT_Full) 2217 ifmedia_add(media, m | IFM_100_TX, mod, NULL); 2218 2219 if (phy->caps & SUPPORTED_10baseT_Full) 2220 ifmedia_add(media, m | IFM_10_T, mod, NULL); 2221 2222 ifmedia_add(media, IFM_ETHER | IFM_AUTO, mod, NULL); 2223 ifmedia_set(media, IFM_ETHER | IFM_AUTO); 2224 2225 } else if (phy->caps & SUPPORTED_TP) { 2226 /* Copper (CX4) */ 2227 2228 KASSERT(phy->caps & SUPPORTED_10000baseT_Full, 2229 ("%s: unexpected cap 0x%x", __func__, phy->caps)); 2230 2231 ifmedia_add(media, m | IFM_10G_CX4, mod, NULL); 2232 ifmedia_set(media, m | IFM_10G_CX4); 2233 2234 } else if (phy->caps & SUPPORTED_FIBRE && 2235 phy->caps & SUPPORTED_10000baseT_Full) { 2236 /* 10G optical (but includes SFP+ twinax) */ 2237 2238 m |= cxgb_ifm_type(mod); 2239 if (IFM_SUBTYPE(m) == IFM_NONE) 2240 m &= ~IFM_FDX; 2241 2242 ifmedia_add(media, m, mod, NULL); 2243 ifmedia_set(media, m); 2244 2245 } else if (phy->caps & SUPPORTED_FIBRE && 2246 phy->caps & SUPPORTED_1000baseT_Full) { 2247 /* 1G optical */ 2248 2249 /* XXX: Lie and claim to be SX, could actually be any 1G-X */ 2250 ifmedia_add(media, m | IFM_1000_SX, mod, NULL); 2251 ifmedia_set(media, m | IFM_1000_SX); 2252 2253 } else { 2254 KASSERT(0, ("%s: don't know how to handle 0x%x.", __func__, 2255 phy->caps)); 2256 } 2257 2258 PORT_UNLOCK(p); 2259 } 2260 2261 static void 2262 cxgb_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) 2263 { 2264 struct port_info *p = ifp->if_softc; 2265 struct ifmedia_entry *cur = p->media.ifm_cur; 2266 int speed = p->link_config.speed; 2267 2268 if (cur->ifm_data != p->phy.modtype) { 2269 cxgb_build_medialist(p); 2270 cur = p->media.ifm_cur; 2271 } 2272 2273 ifmr->ifm_status = IFM_AVALID; 2274 if (!p->link_config.link_ok) 2275 return; 2276 2277 ifmr->ifm_status |= IFM_ACTIVE; 2278 2279 /* 2280 * active and current will differ iff current media is autoselect. That 2281 * can happen only for copper RJ45. 2282 */ 2283 if (IFM_SUBTYPE(cur->ifm_media) != IFM_AUTO) 2284 return; 2285 KASSERT(p->phy.caps & SUPPORTED_TP && p->phy.caps & SUPPORTED_Autoneg, 2286 ("%s: unexpected PHY caps 0x%x", __func__, p->phy.caps)); 2287 2288 ifmr->ifm_active = IFM_ETHER | IFM_FDX; 2289 if (speed == SPEED_10000) 2290 ifmr->ifm_active |= IFM_10G_T; 2291 else if (speed == SPEED_1000) 2292 ifmr->ifm_active |= IFM_1000_T; 2293 else if (speed == SPEED_100) 2294 ifmr->ifm_active |= IFM_100_TX; 2295 else if (speed == SPEED_10) 2296 ifmr->ifm_active |= IFM_10_T; 2297 else 2298 KASSERT(0, ("%s: link up but speed unknown (%u)", __func__, 2299 speed)); 2300 } 2301 2302 static void 2303 cxgb_async_intr(void *data) 2304 { 2305 adapter_t *sc = data; 2306 2307 if (cxgb_debug) 2308 device_printf(sc->dev, "cxgb_async_intr\n"); 2309 /* 2310 * May need to sleep - defer to taskqueue 2311 */ 2312 taskqueue_enqueue(sc->tq, &sc->slow_intr_task); 2313 } 2314 2315 static void 2316 cxgb_ext_intr_handler(void *arg, int count) 2317 { 2318 adapter_t *sc = (adapter_t *)arg; 2319 2320 if (cxgb_debug) 2321 printf("cxgb_ext_intr_handler\n"); 2322 2323 t3_phy_intr_handler(sc); 2324 2325 /* Now reenable external interrupts */ 2326 ADAPTER_LOCK(sc); 2327 if (sc->slow_intr_mask) { 2328 sc->slow_intr_mask |= F_T3DBG; 2329 t3_write_reg(sc, A_PL_INT_CAUSE0, F_T3DBG); 2330 t3_write_reg(sc, A_PL_INT_ENABLE0, sc->slow_intr_mask); 2331 } 2332 ADAPTER_UNLOCK(sc); 2333 } 2334 2335 static void 2336 check_link_status(adapter_t *sc) 2337 { 2338 int i; 2339 2340 for (i = 0; i < (sc)->params.nports; ++i) { 2341 struct port_info *p = &sc->port[i]; 2342 2343 if (!isset(&sc->open_device_map, p->port_id)) 2344 continue; 2345 2346 if (p->link_fault || !(p->phy.caps & SUPPORTED_IRQ)) 2347 t3_link_changed(sc, i); 2348 } 2349 } 2350 2351 static void 2352 check_t3b2_mac(struct adapter *sc) 2353 { 2354 int i; 2355 2356 if (sc->flags & CXGB_SHUTDOWN) 2357 return; 2358 2359 for_each_port(sc, i) { 2360 struct port_info *p = &sc->port[i]; 2361 int status; 2362 #ifdef INVARIANTS 2363 struct ifnet *ifp = p->ifp; 2364 #endif 2365 2366 if (!isset(&sc->open_device_map, p->port_id)) 2367 continue; 2368 2369 KASSERT(ifp->if_drv_flags & IFF_DRV_RUNNING, 2370 ("%s: state mismatch (drv_flags %x, device_map %x)", 2371 __func__, ifp->if_drv_flags, sc->open_device_map)); 2372 2373 PORT_LOCK(p); 2374 status = t3b2_mac_watchdog_task(&p->mac); 2375 if (status == 1) 2376 p->mac.stats.num_toggled++; 2377 else if (status == 2) { 2378 struct cmac *mac = &p->mac; 2379 2380 cxgb_update_mac_settings(p); 2381 t3_link_start(&p->phy, mac, &p->link_config); 2382 t3_mac_enable(mac, MAC_DIRECTION_RX | MAC_DIRECTION_TX); 2383 t3_port_intr_enable(sc, p->port_id); 2384 p->mac.stats.num_resets++; 2385 } 2386 PORT_UNLOCK(p); 2387 } 2388 } 2389 2390 static void 2391 cxgb_tick(void *arg) 2392 { 2393 adapter_t *sc = (adapter_t *)arg; 2394 2395 if (sc->flags & CXGB_SHUTDOWN) 2396 return; 2397 2398 taskqueue_enqueue(sc->tq, &sc->tick_task); 2399 callout_reset(&sc->cxgb_tick_ch, CXGB_TICKS(sc), cxgb_tick, sc); 2400 } 2401 2402 static void 2403 cxgb_tick_handler(void *arg, int count) 2404 { 2405 adapter_t *sc = (adapter_t *)arg; 2406 const struct adapter_params *p = &sc->params; 2407 int i; 2408 uint32_t cause, reset; 2409 2410 if (sc->flags & CXGB_SHUTDOWN || !(sc->flags & FULL_INIT_DONE)) 2411 return; 2412 2413 check_link_status(sc); 2414 sc->check_task_cnt++; 2415 2416 if (p->rev == T3_REV_B2 && p->nports < 4 && sc->open_device_map) 2417 check_t3b2_mac(sc); 2418 2419 cause = t3_read_reg(sc, A_SG_INT_CAUSE); 2420 reset = 0; 2421 if (cause & F_FLEMPTY) { 2422 struct sge_qset *qs = &sc->sge.qs[0]; 2423 2424 i = 0; 2425 reset |= F_FLEMPTY; 2426 2427 cause = (t3_read_reg(sc, A_SG_RSPQ_FL_STATUS) >> 2428 S_FL0EMPTY) & 0xffff; 2429 while (cause) { 2430 qs->fl[i].empty += (cause & 1); 2431 if (i) 2432 qs++; 2433 i ^= 1; 2434 cause >>= 1; 2435 } 2436 } 2437 t3_write_reg(sc, A_SG_INT_CAUSE, reset); 2438 2439 for (i = 0; i < sc->params.nports; i++) { 2440 struct port_info *pi = &sc->port[i]; 2441 struct ifnet *ifp = pi->ifp; 2442 struct cmac *mac = &pi->mac; 2443 struct mac_stats *mstats = &mac->stats; 2444 2445 if (!isset(&sc->open_device_map, pi->port_id)) 2446 continue; 2447 2448 PORT_LOCK(pi); 2449 t3_mac_update_stats(mac); 2450 PORT_UNLOCK(pi); 2451 2452 ifp->if_opackets = 2453 mstats->tx_frames_64 + 2454 mstats->tx_frames_65_127 + 2455 mstats->tx_frames_128_255 + 2456 mstats->tx_frames_256_511 + 2457 mstats->tx_frames_512_1023 + 2458 mstats->tx_frames_1024_1518 + 2459 mstats->tx_frames_1519_max; 2460 2461 ifp->if_ipackets = 2462 mstats->rx_frames_64 + 2463 mstats->rx_frames_65_127 + 2464 mstats->rx_frames_128_255 + 2465 mstats->rx_frames_256_511 + 2466 mstats->rx_frames_512_1023 + 2467 mstats->rx_frames_1024_1518 + 2468 mstats->rx_frames_1519_max; 2469 2470 ifp->if_obytes = mstats->tx_octets; 2471 ifp->if_ibytes = mstats->rx_octets; 2472 ifp->if_omcasts = mstats->tx_mcast_frames; 2473 ifp->if_imcasts = mstats->rx_mcast_frames; 2474 2475 ifp->if_collisions = 2476 mstats->tx_total_collisions; 2477 2478 ifp->if_iqdrops = mstats->rx_cong_drops; 2479 2480 ifp->if_oerrors = 2481 mstats->tx_excess_collisions + 2482 mstats->tx_underrun + 2483 mstats->tx_len_errs + 2484 mstats->tx_mac_internal_errs + 2485 mstats->tx_excess_deferral + 2486 mstats->tx_fcs_errs; 2487 ifp->if_ierrors = 2488 mstats->rx_jabber + 2489 mstats->rx_data_errs + 2490 mstats->rx_sequence_errs + 2491 mstats->rx_runt + 2492 mstats->rx_too_long + 2493 mstats->rx_mac_internal_errs + 2494 mstats->rx_short + 2495 mstats->rx_fcs_errs; 2496 2497 if (mac->multiport) 2498 continue; 2499 2500 /* Count rx fifo overflows, once per second */ 2501 cause = t3_read_reg(sc, A_XGM_INT_CAUSE + mac->offset); 2502 reset = 0; 2503 if (cause & F_RXFIFO_OVERFLOW) { 2504 mac->stats.rx_fifo_ovfl++; 2505 reset |= F_RXFIFO_OVERFLOW; 2506 } 2507 t3_write_reg(sc, A_XGM_INT_CAUSE + mac->offset, reset); 2508 } 2509 } 2510 2511 static void 2512 touch_bars(device_t dev) 2513 { 2514 /* 2515 * Don't enable yet 2516 */ 2517 #if !defined(__LP64__) && 0 2518 u32 v; 2519 2520 pci_read_config_dword(pdev, PCI_BASE_ADDRESS_1, &v); 2521 pci_write_config_dword(pdev, PCI_BASE_ADDRESS_1, v); 2522 pci_read_config_dword(pdev, PCI_BASE_ADDRESS_3, &v); 2523 pci_write_config_dword(pdev, PCI_BASE_ADDRESS_3, v); 2524 pci_read_config_dword(pdev, PCI_BASE_ADDRESS_5, &v); 2525 pci_write_config_dword(pdev, PCI_BASE_ADDRESS_5, v); 2526 #endif 2527 } 2528 2529 static int 2530 set_eeprom(struct port_info *pi, const uint8_t *data, int len, int offset) 2531 { 2532 uint8_t *buf; 2533 int err = 0; 2534 u32 aligned_offset, aligned_len, *p; 2535 struct adapter *adapter = pi->adapter; 2536 2537 2538 aligned_offset = offset & ~3; 2539 aligned_len = (len + (offset & 3) + 3) & ~3; 2540 2541 if (aligned_offset != offset || aligned_len != len) { 2542 buf = malloc(aligned_len, M_DEVBUF, M_WAITOK|M_ZERO); 2543 if (!buf) 2544 return (ENOMEM); 2545 err = t3_seeprom_read(adapter, aligned_offset, (u32 *)buf); 2546 if (!err && aligned_len > 4) 2547 err = t3_seeprom_read(adapter, 2548 aligned_offset + aligned_len - 4, 2549 (u32 *)&buf[aligned_len - 4]); 2550 if (err) 2551 goto out; 2552 memcpy(buf + (offset & 3), data, len); 2553 } else 2554 buf = (uint8_t *)(uintptr_t)data; 2555 2556 err = t3_seeprom_wp(adapter, 0); 2557 if (err) 2558 goto out; 2559 2560 for (p = (u32 *)buf; !err && aligned_len; aligned_len -= 4, p++) { 2561 err = t3_seeprom_write(adapter, aligned_offset, *p); 2562 aligned_offset += 4; 2563 } 2564 2565 if (!err) 2566 err = t3_seeprom_wp(adapter, 1); 2567 out: 2568 if (buf != data) 2569 free(buf, M_DEVBUF); 2570 return err; 2571 } 2572 2573 2574 static int 2575 in_range(int val, int lo, int hi) 2576 { 2577 return val < 0 || (val <= hi && val >= lo); 2578 } 2579 2580 static int 2581 cxgb_extension_open(struct cdev *dev, int flags, int fmp, struct thread *td) 2582 { 2583 return (0); 2584 } 2585 2586 static int 2587 cxgb_extension_close(struct cdev *dev, int flags, int fmt, struct thread *td) 2588 { 2589 return (0); 2590 } 2591 2592 static int 2593 cxgb_extension_ioctl(struct cdev *dev, unsigned long cmd, caddr_t data, 2594 int fflag, struct thread *td) 2595 { 2596 int mmd, error = 0; 2597 struct port_info *pi = dev->si_drv1; 2598 adapter_t *sc = pi->adapter; 2599 2600 #ifdef PRIV_SUPPORTED 2601 if (priv_check(td, PRIV_DRIVER)) { 2602 if (cxgb_debug) 2603 printf("user does not have access to privileged ioctls\n"); 2604 return (EPERM); 2605 } 2606 #else 2607 if (suser(td)) { 2608 if (cxgb_debug) 2609 printf("user does not have access to privileged ioctls\n"); 2610 return (EPERM); 2611 } 2612 #endif 2613 2614 switch (cmd) { 2615 case CHELSIO_GET_MIIREG: { 2616 uint32_t val; 2617 struct cphy *phy = &pi->phy; 2618 struct ch_mii_data *mid = (struct ch_mii_data *)data; 2619 2620 if (!phy->mdio_read) 2621 return (EOPNOTSUPP); 2622 if (is_10G(sc)) { 2623 mmd = mid->phy_id >> 8; 2624 if (!mmd) 2625 mmd = MDIO_DEV_PCS; 2626 else if (mmd > MDIO_DEV_VEND2) 2627 return (EINVAL); 2628 2629 error = phy->mdio_read(sc, mid->phy_id & 0x1f, mmd, 2630 mid->reg_num, &val); 2631 } else 2632 error = phy->mdio_read(sc, mid->phy_id & 0x1f, 0, 2633 mid->reg_num & 0x1f, &val); 2634 if (error == 0) 2635 mid->val_out = val; 2636 break; 2637 } 2638 case CHELSIO_SET_MIIREG: { 2639 struct cphy *phy = &pi->phy; 2640 struct ch_mii_data *mid = (struct ch_mii_data *)data; 2641 2642 if (!phy->mdio_write) 2643 return (EOPNOTSUPP); 2644 if (is_10G(sc)) { 2645 mmd = mid->phy_id >> 8; 2646 if (!mmd) 2647 mmd = MDIO_DEV_PCS; 2648 else if (mmd > MDIO_DEV_VEND2) 2649 return (EINVAL); 2650 2651 error = phy->mdio_write(sc, mid->phy_id & 0x1f, 2652 mmd, mid->reg_num, mid->val_in); 2653 } else 2654 error = phy->mdio_write(sc, mid->phy_id & 0x1f, 0, 2655 mid->reg_num & 0x1f, 2656 mid->val_in); 2657 break; 2658 } 2659 case CHELSIO_SETREG: { 2660 struct ch_reg *edata = (struct ch_reg *)data; 2661 if ((edata->addr & 0x3) != 0 || edata->addr >= sc->mmio_len) 2662 return (EFAULT); 2663 t3_write_reg(sc, edata->addr, edata->val); 2664 break; 2665 } 2666 case CHELSIO_GETREG: { 2667 struct ch_reg *edata = (struct ch_reg *)data; 2668 if ((edata->addr & 0x3) != 0 || edata->addr >= sc->mmio_len) 2669 return (EFAULT); 2670 edata->val = t3_read_reg(sc, edata->addr); 2671 break; 2672 } 2673 case CHELSIO_GET_SGE_CONTEXT: { 2674 struct ch_cntxt *ecntxt = (struct ch_cntxt *)data; 2675 mtx_lock_spin(&sc->sge.reg_lock); 2676 switch (ecntxt->cntxt_type) { 2677 case CNTXT_TYPE_EGRESS: 2678 error = -t3_sge_read_ecntxt(sc, ecntxt->cntxt_id, 2679 ecntxt->data); 2680 break; 2681 case CNTXT_TYPE_FL: 2682 error = -t3_sge_read_fl(sc, ecntxt->cntxt_id, 2683 ecntxt->data); 2684 break; 2685 case CNTXT_TYPE_RSP: 2686 error = -t3_sge_read_rspq(sc, ecntxt->cntxt_id, 2687 ecntxt->data); 2688 break; 2689 case CNTXT_TYPE_CQ: 2690 error = -t3_sge_read_cq(sc, ecntxt->cntxt_id, 2691 ecntxt->data); 2692 break; 2693 default: 2694 error = EINVAL; 2695 break; 2696 } 2697 mtx_unlock_spin(&sc->sge.reg_lock); 2698 break; 2699 } 2700 case CHELSIO_GET_SGE_DESC: { 2701 struct ch_desc *edesc = (struct ch_desc *)data; 2702 int ret; 2703 if (edesc->queue_num >= SGE_QSETS * 6) 2704 return (EINVAL); 2705 ret = t3_get_desc(&sc->sge.qs[edesc->queue_num / 6], 2706 edesc->queue_num % 6, edesc->idx, edesc->data); 2707 if (ret < 0) 2708 return (EINVAL); 2709 edesc->size = ret; 2710 break; 2711 } 2712 case CHELSIO_GET_QSET_PARAMS: { 2713 struct qset_params *q; 2714 struct ch_qset_params *t = (struct ch_qset_params *)data; 2715 int q1 = pi->first_qset; 2716 int nqsets = pi->nqsets; 2717 int i; 2718 2719 if (t->qset_idx >= nqsets) 2720 return EINVAL; 2721 2722 i = q1 + t->qset_idx; 2723 q = &sc->params.sge.qset[i]; 2724 t->rspq_size = q->rspq_size; 2725 t->txq_size[0] = q->txq_size[0]; 2726 t->txq_size[1] = q->txq_size[1]; 2727 t->txq_size[2] = q->txq_size[2]; 2728 t->fl_size[0] = q->fl_size; 2729 t->fl_size[1] = q->jumbo_size; 2730 t->polling = q->polling; 2731 t->lro = q->lro; 2732 t->intr_lat = q->coalesce_usecs; 2733 t->cong_thres = q->cong_thres; 2734 t->qnum = i; 2735 2736 if (sc->flags & USING_MSIX) 2737 t->vector = rman_get_start(sc->msix_irq_res[i]); 2738 else 2739 t->vector = rman_get_start(sc->irq_res); 2740 2741 break; 2742 } 2743 case CHELSIO_GET_QSET_NUM: { 2744 struct ch_reg *edata = (struct ch_reg *)data; 2745 edata->val = pi->nqsets; 2746 break; 2747 } 2748 case CHELSIO_LOAD_FW: { 2749 uint8_t *fw_data; 2750 uint32_t vers; 2751 struct ch_mem_range *t = (struct ch_mem_range *)data; 2752 2753 /* 2754 * You're allowed to load a firmware only before FULL_INIT_DONE 2755 * 2756 * FW_UPTODATE is also set so the rest of the initialization 2757 * will not overwrite what was loaded here. This gives you the 2758 * flexibility to load any firmware (and maybe shoot yourself in 2759 * the foot). 2760 */ 2761 2762 ADAPTER_LOCK(sc); 2763 if (sc->open_device_map || sc->flags & FULL_INIT_DONE) { 2764 ADAPTER_UNLOCK(sc); 2765 return (EBUSY); 2766 } 2767 2768 fw_data = malloc(t->len, M_DEVBUF, M_NOWAIT); 2769 if (!fw_data) 2770 error = ENOMEM; 2771 else 2772 error = copyin(t->buf, fw_data, t->len); 2773 2774 if (!error) 2775 error = -t3_load_fw(sc, fw_data, t->len); 2776 2777 if (t3_get_fw_version(sc, &vers) == 0) { 2778 snprintf(&sc->fw_version[0], sizeof(sc->fw_version), 2779 "%d.%d.%d", G_FW_VERSION_MAJOR(vers), 2780 G_FW_VERSION_MINOR(vers), G_FW_VERSION_MICRO(vers)); 2781 } 2782 2783 if (!error) 2784 sc->flags |= FW_UPTODATE; 2785 2786 free(fw_data, M_DEVBUF); 2787 ADAPTER_UNLOCK(sc); 2788 break; 2789 } 2790 case CHELSIO_LOAD_BOOT: { 2791 uint8_t *boot_data; 2792 struct ch_mem_range *t = (struct ch_mem_range *)data; 2793 2794 boot_data = malloc(t->len, M_DEVBUF, M_NOWAIT); 2795 if (!boot_data) 2796 return ENOMEM; 2797 2798 error = copyin(t->buf, boot_data, t->len); 2799 if (!error) 2800 error = -t3_load_boot(sc, boot_data, t->len); 2801 2802 free(boot_data, M_DEVBUF); 2803 break; 2804 } 2805 case CHELSIO_GET_PM: { 2806 struct ch_pm *m = (struct ch_pm *)data; 2807 struct tp_params *p = &sc->params.tp; 2808 2809 if (!is_offload(sc)) 2810 return (EOPNOTSUPP); 2811 2812 m->tx_pg_sz = p->tx_pg_size; 2813 m->tx_num_pg = p->tx_num_pgs; 2814 m->rx_pg_sz = p->rx_pg_size; 2815 m->rx_num_pg = p->rx_num_pgs; 2816 m->pm_total = p->pmtx_size + p->chan_rx_size * p->nchan; 2817 2818 break; 2819 } 2820 case CHELSIO_SET_PM: { 2821 struct ch_pm *m = (struct ch_pm *)data; 2822 struct tp_params *p = &sc->params.tp; 2823 2824 if (!is_offload(sc)) 2825 return (EOPNOTSUPP); 2826 if (sc->flags & FULL_INIT_DONE) 2827 return (EBUSY); 2828 2829 if (!m->rx_pg_sz || (m->rx_pg_sz & (m->rx_pg_sz - 1)) || 2830 !m->tx_pg_sz || (m->tx_pg_sz & (m->tx_pg_sz - 1))) 2831 return (EINVAL); /* not power of 2 */ 2832 if (!(m->rx_pg_sz & 0x14000)) 2833 return (EINVAL); /* not 16KB or 64KB */ 2834 if (!(m->tx_pg_sz & 0x1554000)) 2835 return (EINVAL); 2836 if (m->tx_num_pg == -1) 2837 m->tx_num_pg = p->tx_num_pgs; 2838 if (m->rx_num_pg == -1) 2839 m->rx_num_pg = p->rx_num_pgs; 2840 if (m->tx_num_pg % 24 || m->rx_num_pg % 24) 2841 return (EINVAL); 2842 if (m->rx_num_pg * m->rx_pg_sz > p->chan_rx_size || 2843 m->tx_num_pg * m->tx_pg_sz > p->chan_tx_size) 2844 return (EINVAL); 2845 2846 p->rx_pg_size = m->rx_pg_sz; 2847 p->tx_pg_size = m->tx_pg_sz; 2848 p->rx_num_pgs = m->rx_num_pg; 2849 p->tx_num_pgs = m->tx_num_pg; 2850 break; 2851 } 2852 case CHELSIO_SETMTUTAB: { 2853 struct ch_mtus *m = (struct ch_mtus *)data; 2854 int i; 2855 2856 if (!is_offload(sc)) 2857 return (EOPNOTSUPP); 2858 if (offload_running(sc)) 2859 return (EBUSY); 2860 if (m->nmtus != NMTUS) 2861 return (EINVAL); 2862 if (m->mtus[0] < 81) /* accommodate SACK */ 2863 return (EINVAL); 2864 2865 /* 2866 * MTUs must be in ascending order 2867 */ 2868 for (i = 1; i < NMTUS; ++i) 2869 if (m->mtus[i] < m->mtus[i - 1]) 2870 return (EINVAL); 2871 2872 memcpy(sc->params.mtus, m->mtus, sizeof(sc->params.mtus)); 2873 break; 2874 } 2875 case CHELSIO_GETMTUTAB: { 2876 struct ch_mtus *m = (struct ch_mtus *)data; 2877 2878 if (!is_offload(sc)) 2879 return (EOPNOTSUPP); 2880 2881 memcpy(m->mtus, sc->params.mtus, sizeof(m->mtus)); 2882 m->nmtus = NMTUS; 2883 break; 2884 } 2885 case CHELSIO_GET_MEM: { 2886 struct ch_mem_range *t = (struct ch_mem_range *)data; 2887 struct mc7 *mem; 2888 uint8_t *useraddr; 2889 u64 buf[32]; 2890 2891 /* 2892 * Use these to avoid modifying len/addr in the the return 2893 * struct 2894 */ 2895 uint32_t len = t->len, addr = t->addr; 2896 2897 if (!is_offload(sc)) 2898 return (EOPNOTSUPP); 2899 if (!(sc->flags & FULL_INIT_DONE)) 2900 return (EIO); /* need the memory controllers */ 2901 if ((addr & 0x7) || (len & 0x7)) 2902 return (EINVAL); 2903 if (t->mem_id == MEM_CM) 2904 mem = &sc->cm; 2905 else if (t->mem_id == MEM_PMRX) 2906 mem = &sc->pmrx; 2907 else if (t->mem_id == MEM_PMTX) 2908 mem = &sc->pmtx; 2909 else 2910 return (EINVAL); 2911 2912 /* 2913 * Version scheme: 2914 * bits 0..9: chip version 2915 * bits 10..15: chip revision 2916 */ 2917 t->version = 3 | (sc->params.rev << 10); 2918 2919 /* 2920 * Read 256 bytes at a time as len can be large and we don't 2921 * want to use huge intermediate buffers. 2922 */ 2923 useraddr = (uint8_t *)t->buf; 2924 while (len) { 2925 unsigned int chunk = min(len, sizeof(buf)); 2926 2927 error = t3_mc7_bd_read(mem, addr / 8, chunk / 8, buf); 2928 if (error) 2929 return (-error); 2930 if (copyout(buf, useraddr, chunk)) 2931 return (EFAULT); 2932 useraddr += chunk; 2933 addr += chunk; 2934 len -= chunk; 2935 } 2936 break; 2937 } 2938 case CHELSIO_READ_TCAM_WORD: { 2939 struct ch_tcam_word *t = (struct ch_tcam_word *)data; 2940 2941 if (!is_offload(sc)) 2942 return (EOPNOTSUPP); 2943 if (!(sc->flags & FULL_INIT_DONE)) 2944 return (EIO); /* need MC5 */ 2945 return -t3_read_mc5_range(&sc->mc5, t->addr, 1, t->buf); 2946 break; 2947 } 2948 case CHELSIO_SET_TRACE_FILTER: { 2949 struct ch_trace *t = (struct ch_trace *)data; 2950 const struct trace_params *tp; 2951 2952 tp = (const struct trace_params *)&t->sip; 2953 if (t->config_tx) 2954 t3_config_trace_filter(sc, tp, 0, t->invert_match, 2955 t->trace_tx); 2956 if (t->config_rx) 2957 t3_config_trace_filter(sc, tp, 1, t->invert_match, 2958 t->trace_rx); 2959 break; 2960 } 2961 case CHELSIO_SET_PKTSCHED: { 2962 struct ch_pktsched_params *p = (struct ch_pktsched_params *)data; 2963 if (sc->open_device_map == 0) 2964 return (EAGAIN); 2965 send_pktsched_cmd(sc, p->sched, p->idx, p->min, p->max, 2966 p->binding); 2967 break; 2968 } 2969 case CHELSIO_IFCONF_GETREGS: { 2970 struct ch_ifconf_regs *regs = (struct ch_ifconf_regs *)data; 2971 int reglen = cxgb_get_regs_len(); 2972 uint8_t *buf = malloc(reglen, M_DEVBUF, M_NOWAIT); 2973 if (buf == NULL) { 2974 return (ENOMEM); 2975 } 2976 if (regs->len > reglen) 2977 regs->len = reglen; 2978 else if (regs->len < reglen) 2979 error = ENOBUFS; 2980 2981 if (!error) { 2982 cxgb_get_regs(sc, regs, buf); 2983 error = copyout(buf, regs->data, reglen); 2984 } 2985 free(buf, M_DEVBUF); 2986 2987 break; 2988 } 2989 case CHELSIO_SET_HW_SCHED: { 2990 struct ch_hw_sched *t = (struct ch_hw_sched *)data; 2991 unsigned int ticks_per_usec = core_ticks_per_usec(sc); 2992 2993 if ((sc->flags & FULL_INIT_DONE) == 0) 2994 return (EAGAIN); /* need TP to be initialized */ 2995 if (t->sched >= NTX_SCHED || !in_range(t->mode, 0, 1) || 2996 !in_range(t->channel, 0, 1) || 2997 !in_range(t->kbps, 0, 10000000) || 2998 !in_range(t->class_ipg, 0, 10000 * 65535 / ticks_per_usec) || 2999 !in_range(t->flow_ipg, 0, 3000 dack_ticks_to_usec(sc, 0x7ff))) 3001 return (EINVAL); 3002 3003 if (t->kbps >= 0) { 3004 error = t3_config_sched(sc, t->kbps, t->sched); 3005 if (error < 0) 3006 return (-error); 3007 } 3008 if (t->class_ipg >= 0) 3009 t3_set_sched_ipg(sc, t->sched, t->class_ipg); 3010 if (t->flow_ipg >= 0) { 3011 t->flow_ipg *= 1000; /* us -> ns */ 3012 t3_set_pace_tbl(sc, &t->flow_ipg, t->sched, 1); 3013 } 3014 if (t->mode >= 0) { 3015 int bit = 1 << (S_TX_MOD_TIMER_MODE + t->sched); 3016 3017 t3_set_reg_field(sc, A_TP_TX_MOD_QUEUE_REQ_MAP, 3018 bit, t->mode ? bit : 0); 3019 } 3020 if (t->channel >= 0) 3021 t3_set_reg_field(sc, A_TP_TX_MOD_QUEUE_REQ_MAP, 3022 1 << t->sched, t->channel << t->sched); 3023 break; 3024 } 3025 case CHELSIO_GET_EEPROM: { 3026 int i; 3027 struct ch_eeprom *e = (struct ch_eeprom *)data; 3028 uint8_t *buf = malloc(EEPROMSIZE, M_DEVBUF, M_NOWAIT); 3029 3030 if (buf == NULL) { 3031 return (ENOMEM); 3032 } 3033 e->magic = EEPROM_MAGIC; 3034 for (i = e->offset & ~3; !error && i < e->offset + e->len; i += 4) 3035 error = -t3_seeprom_read(sc, i, (uint32_t *)&buf[i]); 3036 3037 if (!error) 3038 error = copyout(buf + e->offset, e->data, e->len); 3039 3040 free(buf, M_DEVBUF); 3041 break; 3042 } 3043 case CHELSIO_CLEAR_STATS: { 3044 if (!(sc->flags & FULL_INIT_DONE)) 3045 return EAGAIN; 3046 3047 PORT_LOCK(pi); 3048 t3_mac_update_stats(&pi->mac); 3049 memset(&pi->mac.stats, 0, sizeof(pi->mac.stats)); 3050 PORT_UNLOCK(pi); 3051 break; 3052 } 3053 case CHELSIO_GET_UP_LA: { 3054 struct ch_up_la *la = (struct ch_up_la *)data; 3055 uint8_t *buf = malloc(LA_BUFSIZE, M_DEVBUF, M_NOWAIT); 3056 if (buf == NULL) { 3057 return (ENOMEM); 3058 } 3059 if (la->bufsize < LA_BUFSIZE) 3060 error = ENOBUFS; 3061 3062 if (!error) 3063 error = -t3_get_up_la(sc, &la->stopped, &la->idx, 3064 &la->bufsize, buf); 3065 if (!error) 3066 error = copyout(buf, la->data, la->bufsize); 3067 3068 free(buf, M_DEVBUF); 3069 break; 3070 } 3071 case CHELSIO_GET_UP_IOQS: { 3072 struct ch_up_ioqs *ioqs = (struct ch_up_ioqs *)data; 3073 uint8_t *buf = malloc(IOQS_BUFSIZE, M_DEVBUF, M_NOWAIT); 3074 uint32_t *v; 3075 3076 if (buf == NULL) { 3077 return (ENOMEM); 3078 } 3079 if (ioqs->bufsize < IOQS_BUFSIZE) 3080 error = ENOBUFS; 3081 3082 if (!error) 3083 error = -t3_get_up_ioqs(sc, &ioqs->bufsize, buf); 3084 3085 if (!error) { 3086 v = (uint32_t *)buf; 3087 3088 ioqs->bufsize -= 4 * sizeof(uint32_t); 3089 ioqs->ioq_rx_enable = *v++; 3090 ioqs->ioq_tx_enable = *v++; 3091 ioqs->ioq_rx_status = *v++; 3092 ioqs->ioq_tx_status = *v++; 3093 3094 error = copyout(v, ioqs->data, ioqs->bufsize); 3095 } 3096 3097 free(buf, M_DEVBUF); 3098 break; 3099 } 3100 default: 3101 return (EOPNOTSUPP); 3102 break; 3103 } 3104 3105 return (error); 3106 } 3107 3108 static __inline void 3109 reg_block_dump(struct adapter *ap, uint8_t *buf, unsigned int start, 3110 unsigned int end) 3111 { 3112 uint32_t *p = (uint32_t *)(buf + start); 3113 3114 for ( ; start <= end; start += sizeof(uint32_t)) 3115 *p++ = t3_read_reg(ap, start); 3116 } 3117 3118 #define T3_REGMAP_SIZE (3 * 1024) 3119 static int 3120 cxgb_get_regs_len(void) 3121 { 3122 return T3_REGMAP_SIZE; 3123 } 3124 3125 static void 3126 cxgb_get_regs(adapter_t *sc, struct ch_ifconf_regs *regs, uint8_t *buf) 3127 { 3128 3129 /* 3130 * Version scheme: 3131 * bits 0..9: chip version 3132 * bits 10..15: chip revision 3133 * bit 31: set for PCIe cards 3134 */ 3135 regs->version = 3 | (sc->params.rev << 10) | (is_pcie(sc) << 31); 3136 3137 /* 3138 * We skip the MAC statistics registers because they are clear-on-read. 3139 * Also reading multi-register stats would need to synchronize with the 3140 * periodic mac stats accumulation. Hard to justify the complexity. 3141 */ 3142 memset(buf, 0, cxgb_get_regs_len()); 3143 reg_block_dump(sc, buf, 0, A_SG_RSPQ_CREDIT_RETURN); 3144 reg_block_dump(sc, buf, A_SG_HI_DRB_HI_THRSH, A_ULPRX_PBL_ULIMIT); 3145 reg_block_dump(sc, buf, A_ULPTX_CONFIG, A_MPS_INT_CAUSE); 3146 reg_block_dump(sc, buf, A_CPL_SWITCH_CNTRL, A_CPL_MAP_TBL_DATA); 3147 reg_block_dump(sc, buf, A_SMB_GLOBAL_TIME_CFG, A_XGM_SERDES_STAT3); 3148 reg_block_dump(sc, buf, A_XGM_SERDES_STATUS0, 3149 XGM_REG(A_XGM_SERDES_STAT3, 1)); 3150 reg_block_dump(sc, buf, XGM_REG(A_XGM_SERDES_STATUS0, 1), 3151 XGM_REG(A_XGM_RX_SPI4_SOP_EOP_CNT, 1)); 3152 } 3153 3154 3155 MODULE_DEPEND(if_cxgb, cxgb_t3fw, 1, 1, 1); 3156