1/*- 2 * Copyright (c) 2016 Chelsio Communications, Inc. 3 * All rights reserved. 4 * Written by: John Baldwin <jhb@FreeBSD.org> 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28#include <sys/cdefs.h> 29__FBSDID("$FreeBSD$"); 30 31#include "opt_inet.h" 32#include "opt_inet6.h" 33 34#include <sys/param.h> 35#include <sys/bus.h> 36#include <sys/conf.h> 37#include <sys/kernel.h> 38#include <sys/module.h> 39#include <sys/priv.h> 40#include <dev/pci/pcivar.h> 41#if defined(__i386__) || defined(__amd64__) 42#include <vm/vm.h> 43#include <vm/pmap.h> 44#endif 45 46#include "common/common.h" 47#include "common/t4_regs.h" 48#include "t4_ioctl.h" 49#include "t4_mp_ring.h" 50 51/* 52 * Some notes: 53 * 54 * The Virtual Interfaces are connected to an internal switch on the chip 55 * which allows VIs attached to the same port to talk to each other even when 56 * the port link is down. As a result, we might want to always report a 57 * VF's link as being "up". 58 * 59 * XXX: Add a TUNABLE and possible per-device sysctl for this? 60 */ 61 62struct intrs_and_queues { 63 uint16_t intr_type; /* MSI, or MSI-X */ 64 uint16_t nirq; /* Total # of vectors */ 65 uint16_t ntxq; /* # of NIC txq's for each port */ 66 uint16_t nrxq; /* # of NIC rxq's for each port */ 67}; 68 69struct { 70 uint16_t device; 71 char *desc; 72} t4vf_pciids[] = { 73 {0x4800, "Chelsio T440-dbg VF"}, 74 {0x4801, "Chelsio T420-CR VF"}, 75 {0x4802, "Chelsio T422-CR VF"}, 76 {0x4803, "Chelsio T440-CR VF"}, 77 {0x4804, "Chelsio T420-BCH VF"}, 78 {0x4805, "Chelsio T440-BCH VF"}, 79 {0x4806, "Chelsio T440-CH VF"}, 80 {0x4807, "Chelsio T420-SO VF"}, 81 {0x4808, "Chelsio T420-CX VF"}, 82 {0x4809, "Chelsio T420-BT VF"}, 83 {0x480a, "Chelsio T404-BT VF"}, 84 {0x480e, "Chelsio T440-LP-CR VF"}, 85}, t5vf_pciids[] = { 86 {0x5800, "Chelsio T580-dbg VF"}, 87 {0x5801, "Chelsio T520-CR VF"}, /* 2 x 10G */ 88 {0x5802, "Chelsio T522-CR VF"}, /* 2 x 10G, 2 X 1G */ 89 {0x5803, "Chelsio T540-CR VF"}, /* 4 x 10G */ 90 {0x5807, "Chelsio T520-SO VF"}, /* 2 x 10G, nomem */ 91 {0x5809, "Chelsio T520-BT VF"}, /* 2 x 10GBaseT */ 92 {0x580a, "Chelsio T504-BT VF"}, /* 4 x 1G */ 93 {0x580d, "Chelsio T580-CR VF"}, /* 2 x 40G */ 94 {0x580e, "Chelsio T540-LP-CR VF"}, /* 4 x 10G */ 95 {0x5810, "Chelsio T580-LP-CR VF"}, /* 2 x 40G */ 96 {0x5811, "Chelsio T520-LL-CR VF"}, /* 2 x 10G */ 97 {0x5812, "Chelsio T560-CR VF"}, /* 1 x 40G, 2 x 10G */ 98 {0x5814, "Chelsio T580-LP-SO-CR VF"}, /* 2 x 40G, nomem */ 99 {0x5815, "Chelsio T502-BT VF"}, /* 2 x 1G */ 100 {0x5818, "Chelsio T540-BT VF"}, /* 4 x 10GBaseT */ 101 {0x5819, "Chelsio T540-LP-BT VF"}, /* 4 x 10GBaseT */ 102 {0x581a, "Chelsio T540-SO-BT VF"}, /* 4 x 10GBaseT, nomem */ 103 {0x581b, "Chelsio T540-SO-CR VF"}, /* 4 x 10G, nomem */ 104}, t6vf_pciids[] = { 105 {0x6800, "Chelsio T6-DBG-25 VF"}, /* 2 x 10/25G, debug */ 106 {0x6801, "Chelsio T6225-CR VF"}, /* 2 x 10/25G */ 107 {0x6802, "Chelsio T6225-SO-CR VF"}, /* 2 x 10/25G, nomem */ 108 {0x6803, "Chelsio T6425-CR VF"}, /* 4 x 10/25G */ 109 {0x6804, "Chelsio T6425-SO-CR VF"}, /* 4 x 10/25G, nomem */ 110 {0x6805, "Chelsio T6225-OCP-SO VF"}, /* 2 x 10/25G, nomem */ 111 {0x6806, "Chelsio T62100-OCP-SO VF"}, /* 2 x 40/50/100G, nomem */ 112 {0x6807, "Chelsio T62100-LP-CR VF"}, /* 2 x 40/50/100G */ 113 {0x6808, "Chelsio T62100-SO-CR VF"}, /* 2 x 40/50/100G, nomem */ 114 {0x6809, "Chelsio T6210-BT VF"}, /* 2 x 10GBASE-T */ 115 {0x680d, "Chelsio T62100-CR VF"}, /* 2 x 40/50/100G */ 116 {0x6810, "Chelsio T6-DBG-100 VF"}, /* 2 x 40/50/100G, debug */ 117 {0x6811, "Chelsio T6225-LL-CR VF"}, /* 2 x 10/25G */ 118 {0x6814, "Chelsio T61100-OCP-SO VF"}, /* 1 x 40/50/100G, nomem */ 119 {0x6815, "Chelsio T6201-BT VF"}, /* 2 x 1000BASE-T */ 120 121 /* Custom */ 122 {0x6880, "Chelsio T6225 80 VF"}, 123 {0x6881, "Chelsio T62100 81 VF"}, 124 {0x6882, "Chelsio T6225-CR 82 VF"}, 125 {0x6883, "Chelsio T62100-CR 83 VF"}, 126 {0x6884, "Chelsio T64100-CR 84 VF"}, 127 {0x6885, "Chelsio T6240-SO 85 VF"}, 128 {0x6886, "Chelsio T6225-SO-CR 86 VF"}, 129 {0x6887, "Chelsio T6225-CR 87 VF"}, 130}; 131 132static d_ioctl_t t4vf_ioctl; 133 134static struct cdevsw t4vf_cdevsw = { 135 .d_version = D_VERSION, 136 .d_ioctl = t4vf_ioctl, 137 .d_name = "t4vf", 138}; 139 140static int 141t4vf_probe(device_t dev) 142{ 143 uint16_t d; 144 size_t i; 145 146 d = pci_get_device(dev); 147 for (i = 0; i < nitems(t4vf_pciids); i++) { 148 if (d == t4vf_pciids[i].device) { 149 device_set_desc(dev, t4vf_pciids[i].desc); 150 return (BUS_PROBE_DEFAULT); 151 } 152 } 153 return (ENXIO); 154} 155 156static int 157t5vf_probe(device_t dev) 158{ 159 uint16_t d; 160 size_t i; 161 162 d = pci_get_device(dev); 163 for (i = 0; i < nitems(t5vf_pciids); i++) { 164 if (d == t5vf_pciids[i].device) { 165 device_set_desc(dev, t5vf_pciids[i].desc); 166 return (BUS_PROBE_DEFAULT); 167 } 168 } 169 return (ENXIO); 170} 171 172static int 173t6vf_probe(device_t dev) 174{ 175 uint16_t d; 176 size_t i; 177 178 d = pci_get_device(dev); 179 for (i = 0; i < nitems(t6vf_pciids); i++) { 180 if (d == t6vf_pciids[i].device) { 181 device_set_desc(dev, t6vf_pciids[i].desc); 182 return (BUS_PROBE_DEFAULT); 183 } 184 } 185 return (ENXIO); 186} 187 188#define FW_PARAM_DEV(param) \ 189 (V_FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) | \ 190 V_FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_##param)) 191#define FW_PARAM_PFVF(param) \ 192 (V_FW_PARAMS_MNEM(FW_PARAMS_MNEM_PFVF) | \ 193 V_FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_PFVF_##param)) 194 195static int 196get_params__pre_init(struct adapter *sc) 197{ 198 int rc; 199 uint32_t param[3], val[3]; 200 201 param[0] = FW_PARAM_DEV(FWREV); 202 param[1] = FW_PARAM_DEV(TPREV); 203 param[2] = FW_PARAM_DEV(CCLK); 204 rc = -t4vf_query_params(sc, nitems(param), param, val); 205 if (rc != 0) { 206 device_printf(sc->dev, 207 "failed to query parameters (pre_init): %d.\n", rc); 208 return (rc); 209 } 210 211 sc->params.fw_vers = val[0]; 212 sc->params.tp_vers = val[1]; 213 sc->params.vpd.cclk = val[2]; 214 215 snprintf(sc->fw_version, sizeof(sc->fw_version), "%u.%u.%u.%u", 216 G_FW_HDR_FW_VER_MAJOR(sc->params.fw_vers), 217 G_FW_HDR_FW_VER_MINOR(sc->params.fw_vers), 218 G_FW_HDR_FW_VER_MICRO(sc->params.fw_vers), 219 G_FW_HDR_FW_VER_BUILD(sc->params.fw_vers)); 220 221 snprintf(sc->tp_version, sizeof(sc->tp_version), "%u.%u.%u.%u", 222 G_FW_HDR_FW_VER_MAJOR(sc->params.tp_vers), 223 G_FW_HDR_FW_VER_MINOR(sc->params.tp_vers), 224 G_FW_HDR_FW_VER_MICRO(sc->params.tp_vers), 225 G_FW_HDR_FW_VER_BUILD(sc->params.tp_vers)); 226 227 return (0); 228} 229 230static int 231get_params__post_init(struct adapter *sc) 232{ 233 int rc; 234 uint32_t param, val; 235 236 rc = -t4vf_get_sge_params(sc); 237 if (rc != 0) { 238 device_printf(sc->dev, 239 "unable to retrieve adapter SGE parameters: %d\n", rc); 240 return (rc); 241 } 242 243 rc = -t4vf_get_rss_glb_config(sc); 244 if (rc != 0) { 245 device_printf(sc->dev, 246 "unable to retrieve adapter RSS parameters: %d\n", rc); 247 return (rc); 248 } 249 if (sc->params.rss.mode != FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL) { 250 device_printf(sc->dev, 251 "unable to operate with global RSS mode %d\n", 252 sc->params.rss.mode); 253 return (EINVAL); 254 } 255 256 /* 257 * Grab our Virtual Interface resource allocation, extract the 258 * features that we're interested in and do a bit of sanity testing on 259 * what we discover. 260 */ 261 rc = -t4vf_get_vfres(sc); 262 if (rc != 0) { 263 device_printf(sc->dev, 264 "unable to get virtual interface resources: %d\n", rc); 265 return (rc); 266 } 267 268 /* 269 * Check for various parameter sanity issues. 270 */ 271 if (sc->params.vfres.pmask == 0) { 272 device_printf(sc->dev, "no port access configured/usable!\n"); 273 return (EINVAL); 274 } 275 if (sc->params.vfres.nvi == 0) { 276 device_printf(sc->dev, 277 "no virtual interfaces configured/usable!\n"); 278 return (EINVAL); 279 } 280 sc->params.portvec = sc->params.vfres.pmask; 281 282 param = FW_PARAM_PFVF(MAX_PKTS_PER_ETH_TX_PKTS_WR); 283 rc = -t4vf_query_params(sc, 1, ¶m, &val); 284 if (rc == 0) 285 sc->params.max_pkts_per_eth_tx_pkts_wr = val; 286 else 287 sc->params.max_pkts_per_eth_tx_pkts_wr = 14; 288 289 rc = t4_verify_chip_settings(sc); 290 if (rc != 0) 291 return (rc); 292 t4_init_rx_buf_info(sc); 293 294 return (0); 295} 296 297static int 298set_params__post_init(struct adapter *sc) 299{ 300 uint32_t param, val; 301 302 /* ask for encapsulated CPLs */ 303 param = FW_PARAM_PFVF(CPLFW4MSG_ENCAP); 304 val = 1; 305 (void)t4vf_set_params(sc, 1, ¶m, &val); 306 307 /* Enable 32b port caps if the firmware supports it. */ 308 param = FW_PARAM_PFVF(PORT_CAPS32); 309 val = 1; 310 if (t4vf_set_params(sc, 1, ¶m, &val) == 0) 311 sc->params.port_caps32 = 1; 312 313 return (0); 314} 315 316#undef FW_PARAM_PFVF 317#undef FW_PARAM_DEV 318 319static int 320cfg_itype_and_nqueues(struct adapter *sc, struct intrs_and_queues *iaq) 321{ 322 struct vf_resources *vfres; 323 int nrxq, ntxq, nports; 324 int itype, iq_avail, navail, rc; 325 326 /* 327 * Figure out the layout of queues across our VIs and ensure 328 * we can allocate enough interrupts for our layout. 329 */ 330 vfres = &sc->params.vfres; 331 nports = sc->params.nports; 332 bzero(iaq, sizeof(*iaq)); 333 334 for (itype = INTR_MSIX; itype != 0; itype >>= 1) { 335 if (itype == INTR_INTX) 336 continue; 337 338 if (itype == INTR_MSIX) 339 navail = pci_msix_count(sc->dev); 340 else 341 navail = pci_msi_count(sc->dev); 342 343 if (navail == 0) 344 continue; 345 346 iaq->intr_type = itype; 347 348 /* 349 * XXX: The Linux driver reserves an Ingress Queue for 350 * forwarded interrupts when using MSI (but not MSI-X). 351 * It seems it just always asks for 2 interrupts and 352 * forwards all rxqs to the forwarded interrupt. 353 * 354 * We must reserve one IRQ for the for the firmware 355 * event queue. 356 * 357 * Every rxq requires an ingress queue with a free 358 * list and interrupts and an egress queue. Every txq 359 * requires an ETH egress queue. 360 */ 361 iaq->nirq = T4VF_EXTRA_INTR; 362 363 /* 364 * First, determine how many queues we can allocate. 365 * Start by finding the upper bound on rxqs from the 366 * limit on ingress queues. 367 */ 368 iq_avail = vfres->niqflint - iaq->nirq; 369 if (iq_avail < nports) { 370 device_printf(sc->dev, 371 "Not enough ingress queues (%d) for %d ports\n", 372 vfres->niqflint, nports); 373 return (ENXIO); 374 } 375 376 /* 377 * Try to honor the cap on interrupts. If there aren't 378 * enough interrupts for at least one interrupt per 379 * port, then don't bother, we will just forward all 380 * interrupts to one interrupt in that case. 381 */ 382 if (iaq->nirq + nports <= navail) { 383 if (iq_avail > navail - iaq->nirq) 384 iq_avail = navail - iaq->nirq; 385 } 386 387 nrxq = nports * t4_nrxq; 388 if (nrxq > iq_avail) { 389 /* 390 * Too many ingress queues. Use what we can. 391 */ 392 nrxq = (iq_avail / nports) * nports; 393 } 394 KASSERT(nrxq <= iq_avail, ("too many ingress queues")); 395 396 /* 397 * Next, determine the upper bound on txqs from the limit 398 * on ETH queues. 399 */ 400 if (vfres->nethctrl < nports) { 401 device_printf(sc->dev, 402 "Not enough ETH queues (%d) for %d ports\n", 403 vfres->nethctrl, nports); 404 return (ENXIO); 405 } 406 407 ntxq = nports * t4_ntxq; 408 if (ntxq > vfres->nethctrl) { 409 /* 410 * Too many ETH queues. Use what we can. 411 */ 412 ntxq = (vfres->nethctrl / nports) * nports; 413 } 414 KASSERT(ntxq <= vfres->nethctrl, ("too many ETH queues")); 415 416 /* 417 * Finally, ensure we have enough egress queues. 418 */ 419 if (vfres->neq < nports * 2) { 420 device_printf(sc->dev, 421 "Not enough egress queues (%d) for %d ports\n", 422 vfres->neq, nports); 423 return (ENXIO); 424 } 425 if (nrxq + ntxq > vfres->neq) { 426 /* Just punt and use 1 for everything. */ 427 nrxq = ntxq = nports; 428 } 429 KASSERT(nrxq <= iq_avail, ("too many ingress queues")); 430 KASSERT(ntxq <= vfres->nethctrl, ("too many ETH queues")); 431 KASSERT(nrxq + ntxq <= vfres->neq, ("too many egress queues")); 432 433 /* 434 * Do we have enough interrupts? For MSI the interrupts 435 * have to be a power of 2 as well. 436 */ 437 iaq->nirq += nrxq; 438 iaq->ntxq = ntxq; 439 iaq->nrxq = nrxq; 440 if (iaq->nirq <= navail && 441 (itype != INTR_MSI || powerof2(iaq->nirq))) { 442 navail = iaq->nirq; 443 if (itype == INTR_MSIX) 444 rc = pci_alloc_msix(sc->dev, &navail); 445 else 446 rc = pci_alloc_msi(sc->dev, &navail); 447 if (rc != 0) { 448 device_printf(sc->dev, 449 "failed to allocate vectors:%d, type=%d, req=%d, rcvd=%d\n", 450 itype, rc, iaq->nirq, navail); 451 return (rc); 452 } 453 if (navail == iaq->nirq) { 454 return (0); 455 } 456 pci_release_msi(sc->dev); 457 } 458 459 /* Fall back to a single interrupt. */ 460 iaq->nirq = 1; 461 navail = iaq->nirq; 462 if (itype == INTR_MSIX) 463 rc = pci_alloc_msix(sc->dev, &navail); 464 else 465 rc = pci_alloc_msi(sc->dev, &navail); 466 if (rc != 0) 467 device_printf(sc->dev, 468 "failed to allocate vectors:%d, type=%d, req=%d, rcvd=%d\n", 469 itype, rc, iaq->nirq, navail); 470 return (rc); 471 } 472 473 device_printf(sc->dev, 474 "failed to find a usable interrupt type. " 475 "allowed=%d, msi-x=%d, msi=%d, intx=1", t4_intr_types, 476 pci_msix_count(sc->dev), pci_msi_count(sc->dev)); 477 478 return (ENXIO); 479} 480 481static int 482t4vf_attach(device_t dev) 483{ 484 struct adapter *sc; 485 int rc = 0, i, j, rqidx, tqidx, n, p, pmask; 486 struct make_dev_args mda; 487 struct intrs_and_queues iaq; 488 struct sge *s; 489 490 sc = device_get_softc(dev); 491 sc->dev = dev; 492 pci_enable_busmaster(dev); 493 pci_set_max_read_req(dev, 4096); 494 sc->params.pci.mps = pci_get_max_payload(dev); 495 496 sc->flags |= IS_VF; 497 TUNABLE_INT_FETCH("hw.cxgbe.dflags", &sc->debug_flags); 498 499 sc->sge_gts_reg = VF_SGE_REG(A_SGE_VF_GTS); 500 sc->sge_kdoorbell_reg = VF_SGE_REG(A_SGE_VF_KDOORBELL); 501 snprintf(sc->lockname, sizeof(sc->lockname), "%s", 502 device_get_nameunit(dev)); 503 mtx_init(&sc->sc_lock, sc->lockname, 0, MTX_DEF); 504 t4_add_adapter(sc); 505 506 mtx_init(&sc->sfl_lock, "starving freelists", 0, MTX_DEF); 507 TAILQ_INIT(&sc->sfl); 508 callout_init_mtx(&sc->sfl_callout, &sc->sfl_lock, 0); 509 510 mtx_init(&sc->reg_lock, "indirect register access", 0, MTX_DEF); 511 512 rc = t4_map_bars_0_and_4(sc); 513 if (rc != 0) 514 goto done; /* error message displayed already */ 515 516 rc = -t4vf_prep_adapter(sc); 517 if (rc != 0) 518 goto done; 519 520 t4_init_devnames(sc); 521 if (sc->names == NULL) { 522 rc = ENOTSUP; 523 goto done; /* error message displayed already */ 524 } 525 526 /* 527 * Leave the 'pf' and 'mbox' values as zero. This ensures 528 * that various firmware messages do not set the fields which 529 * is the correct thing to do for a VF. 530 */ 531 532 memset(sc->chan_map, 0xff, sizeof(sc->chan_map)); 533 534 make_dev_args_init(&mda); 535 mda.mda_devsw = &t4vf_cdevsw; 536 mda.mda_uid = UID_ROOT; 537 mda.mda_gid = GID_WHEEL; 538 mda.mda_mode = 0600; 539 mda.mda_si_drv1 = sc; 540 rc = make_dev_s(&mda, &sc->cdev, "%s", device_get_nameunit(dev)); 541 if (rc != 0) 542 device_printf(dev, "failed to create nexus char device: %d.\n", 543 rc); 544 545#if defined(__i386__) 546 if ((cpu_feature & CPUID_CX8) == 0) { 547 device_printf(dev, "64 bit atomics not available.\n"); 548 rc = ENOTSUP; 549 goto done; 550 } 551#endif 552 553 /* 554 * Some environments do not properly handle PCIE FLRs -- e.g. in Linux 555 * 2.6.31 and later we can't call pci_reset_function() in order to 556 * issue an FLR because of a self- deadlock on the device semaphore. 557 * Meanwhile, the OS infrastructure doesn't issue FLRs in all the 558 * cases where they're needed -- for instance, some versions of KVM 559 * fail to reset "Assigned Devices" when the VM reboots. Therefore we 560 * use the firmware based reset in order to reset any per function 561 * state. 562 */ 563 rc = -t4vf_fw_reset(sc); 564 if (rc != 0) { 565 device_printf(dev, "FW reset failed: %d\n", rc); 566 goto done; 567 } 568 sc->flags |= FW_OK; 569 570 /* 571 * Grab basic operational parameters. These will predominantly have 572 * been set up by the Physical Function Driver or will be hard coded 573 * into the adapter. We just have to live with them ... Note that 574 * we _must_ get our VPD parameters before our SGE parameters because 575 * we need to know the adapter's core clock from the VPD in order to 576 * properly decode the SGE Timer Values. 577 */ 578 rc = get_params__pre_init(sc); 579 if (rc != 0) 580 goto done; /* error message displayed already */ 581 rc = get_params__post_init(sc); 582 if (rc != 0) 583 goto done; /* error message displayed already */ 584 585 rc = set_params__post_init(sc); 586 if (rc != 0) 587 goto done; /* error message displayed already */ 588 589 rc = t4_map_bar_2(sc); 590 if (rc != 0) 591 goto done; /* error message displayed already */ 592 593 rc = t4_create_dma_tag(sc); 594 if (rc != 0) 595 goto done; /* error message displayed already */ 596 597 /* 598 * The number of "ports" which we support is equal to the number of 599 * Virtual Interfaces with which we've been provisioned. 600 */ 601 sc->params.nports = imin(sc->params.vfres.nvi, MAX_NPORTS); 602 603 /* 604 * We may have been provisioned with more VIs than the number of 605 * ports we're allowed to access (our Port Access Rights Mask). 606 * Just use a single VI for each port. 607 */ 608 sc->params.nports = imin(sc->params.nports, 609 bitcount32(sc->params.vfres.pmask)); 610 611#ifdef notyet 612 /* 613 * XXX: The Linux VF driver will lower nports if it thinks there 614 * are too few resources in vfres (niqflint, nethctrl, neq). 615 */ 616#endif 617 618 /* 619 * First pass over all the ports - allocate VIs and initialize some 620 * basic parameters like mac address, port type, etc. 621 */ 622 pmask = sc->params.vfres.pmask; 623 for_each_port(sc, i) { 624 struct port_info *pi; 625 uint8_t mac[ETHER_ADDR_LEN]; 626 627 pi = malloc(sizeof(*pi), M_CXGBE, M_ZERO | M_WAITOK); 628 sc->port[i] = pi; 629 630 /* These must be set before t4_port_init */ 631 pi->adapter = sc; 632 pi->port_id = i; 633 pi->nvi = 1; 634 pi->vi = malloc(sizeof(struct vi_info) * pi->nvi, M_CXGBE, 635 M_ZERO | M_WAITOK); 636 637 /* 638 * Allocate the "main" VI and initialize parameters 639 * like mac addr. 640 */ 641 rc = -t4_port_init(sc, sc->mbox, sc->pf, 0, i); 642 if (rc != 0) { 643 device_printf(dev, "unable to initialize port %d: %d\n", 644 i, rc); 645 free(pi->vi, M_CXGBE); 646 free(pi, M_CXGBE); 647 sc->port[i] = NULL; 648 goto done; 649 } 650 651 /* Prefer the MAC address set by the PF, if there is one. */ 652 n = 1; 653 p = ffs(pmask) - 1; 654 MPASS(p >= 0); 655 rc = t4vf_get_vf_mac(sc, p, &n, mac); 656 if (rc == 0 && n == 1) 657 t4_os_set_hw_addr(pi, mac); 658 pmask &= ~(1 << p); 659 660 /* No t4_link_start. */ 661 662 snprintf(pi->lockname, sizeof(pi->lockname), "%sp%d", 663 device_get_nameunit(dev), i); 664 mtx_init(&pi->pi_lock, pi->lockname, 0, MTX_DEF); 665 sc->chan_map[pi->tx_chan] = i; 666 667 /* All VIs on this port share this media. */ 668 ifmedia_init(&pi->media, IFM_IMASK, cxgbe_media_change, 669 cxgbe_media_status); 670 671 pi->dev = device_add_child(dev, sc->names->vf_ifnet_name, -1); 672 if (pi->dev == NULL) { 673 device_printf(dev, 674 "failed to add device for port %d.\n", i); 675 rc = ENXIO; 676 goto done; 677 } 678 pi->vi[0].dev = pi->dev; 679 device_set_softc(pi->dev, pi); 680 } 681 682 /* 683 * Interrupt type, # of interrupts, # of rx/tx queues, etc. 684 */ 685 rc = cfg_itype_and_nqueues(sc, &iaq); 686 if (rc != 0) 687 goto done; /* error message displayed already */ 688 689 sc->intr_type = iaq.intr_type; 690 sc->intr_count = iaq.nirq; 691 692 s = &sc->sge; 693 s->nrxq = sc->params.nports * iaq.nrxq; 694 s->ntxq = sc->params.nports * iaq.ntxq; 695 s->neq = s->ntxq + s->nrxq; /* the free list in an rxq is an eq */ 696 s->neq += sc->params.nports; /* ctrl queues: 1 per port */ 697 s->niq = s->nrxq + 1; /* 1 extra for firmware event queue */ 698 699 s->iqmap_sz = s->niq; 700 s->eqmap_sz = s->neq; 701 702 s->rxq = malloc(s->nrxq * sizeof(struct sge_rxq), M_CXGBE, 703 M_ZERO | M_WAITOK); 704 s->txq = malloc(s->ntxq * sizeof(struct sge_txq), M_CXGBE, 705 M_ZERO | M_WAITOK); 706 s->iqmap = malloc(s->iqmap_sz * sizeof(struct sge_iq *), M_CXGBE, 707 M_ZERO | M_WAITOK); 708 s->eqmap = malloc(s->eqmap_sz * sizeof(struct sge_eq *), M_CXGBE, 709 M_ZERO | M_WAITOK); 710 711 sc->irq = malloc(sc->intr_count * sizeof(struct irq), M_CXGBE, 712 M_ZERO | M_WAITOK); 713 714 /* 715 * Second pass over the ports. This time we know the number of rx and 716 * tx queues that each port should get. 717 */ 718 rqidx = tqidx = 0; 719 for_each_port(sc, i) { 720 struct port_info *pi = sc->port[i]; 721 struct vi_info *vi; 722 723 if (pi == NULL) 724 continue; 725 726 for_each_vi(pi, j, vi) { 727 vi->pi = pi; 728 vi->adapter = sc; 729 vi->qsize_rxq = t4_qsize_rxq; 730 vi->qsize_txq = t4_qsize_txq; 731 732 vi->first_rxq = rqidx; 733 vi->first_txq = tqidx; 734 vi->tmr_idx = t4_tmr_idx; 735 vi->pktc_idx = t4_pktc_idx; 736 vi->nrxq = j == 0 ? iaq.nrxq: 1; 737 vi->ntxq = j == 0 ? iaq.ntxq: 1; 738 739 rqidx += vi->nrxq; 740 tqidx += vi->ntxq; 741 742 vi->rsrv_noflowq = 0; 743 } 744 } 745 746 rc = t4_setup_intr_handlers(sc); 747 if (rc != 0) { 748 device_printf(dev, 749 "failed to setup interrupt handlers: %d\n", rc); 750 goto done; 751 } 752 753 rc = bus_generic_attach(dev); 754 if (rc != 0) { 755 device_printf(dev, 756 "failed to attach all child ports: %d\n", rc); 757 goto done; 758 } 759 760 device_printf(dev, 761 "%d ports, %d %s interrupt%s, %d eq, %d iq\n", 762 sc->params.nports, sc->intr_count, sc->intr_type == INTR_MSIX ? 763 "MSI-X" : "MSI", sc->intr_count > 1 ? "s" : "", sc->sge.neq, 764 sc->sge.niq); 765 766done: 767 if (rc != 0) 768 t4_detach_common(dev); 769 else 770 t4_sysctls(sc); 771 772 return (rc); 773} 774 775static void 776get_regs(struct adapter *sc, struct t4_regdump *regs, uint8_t *buf) 777{ 778 779 /* 0x3f is used as the revision for VFs. */ 780 regs->version = chip_id(sc) | (0x3f << 10); 781 t4_get_regs(sc, buf, regs->len); 782} 783 784static void 785t4_clr_vi_stats(struct adapter *sc) 786{ 787 int reg; 788 789 for (reg = A_MPS_VF_STAT_TX_VF_BCAST_BYTES_L; 790 reg <= A_MPS_VF_STAT_RX_VF_ERR_FRAMES_H; reg += 4) 791 t4_write_reg(sc, VF_MPS_REG(reg), 0); 792} 793 794static int 795t4vf_ioctl(struct cdev *dev, unsigned long cmd, caddr_t data, int fflag, 796 struct thread *td) 797{ 798 int rc; 799 struct adapter *sc = dev->si_drv1; 800 801 rc = priv_check(td, PRIV_DRIVER); 802 if (rc != 0) 803 return (rc); 804 805 switch (cmd) { 806 case CHELSIO_T4_GETREG: { 807 struct t4_reg *edata = (struct t4_reg *)data; 808 809 if ((edata->addr & 0x3) != 0 || edata->addr >= sc->mmio_len) 810 return (EFAULT); 811 812 if (edata->size == 4) 813 edata->val = t4_read_reg(sc, edata->addr); 814 else if (edata->size == 8) 815 edata->val = t4_read_reg64(sc, edata->addr); 816 else 817 return (EINVAL); 818 819 break; 820 } 821 case CHELSIO_T4_SETREG: { 822 struct t4_reg *edata = (struct t4_reg *)data; 823 824 if ((edata->addr & 0x3) != 0 || edata->addr >= sc->mmio_len) 825 return (EFAULT); 826 827 if (edata->size == 4) { 828 if (edata->val & 0xffffffff00000000) 829 return (EINVAL); 830 t4_write_reg(sc, edata->addr, (uint32_t) edata->val); 831 } else if (edata->size == 8) 832 t4_write_reg64(sc, edata->addr, edata->val); 833 else 834 return (EINVAL); 835 break; 836 } 837 case CHELSIO_T4_REGDUMP: { 838 struct t4_regdump *regs = (struct t4_regdump *)data; 839 int reglen = t4_get_regs_len(sc); 840 uint8_t *buf; 841 842 if (regs->len < reglen) { 843 regs->len = reglen; /* hint to the caller */ 844 return (ENOBUFS); 845 } 846 847 regs->len = reglen; 848 buf = malloc(reglen, M_CXGBE, M_WAITOK | M_ZERO); 849 get_regs(sc, regs, buf); 850 rc = copyout(buf, regs->data, reglen); 851 free(buf, M_CXGBE); 852 break; 853 } 854 case CHELSIO_T4_CLEAR_STATS: { 855 int i, v; 856 u_int port_id = *(uint32_t *)data; 857 struct port_info *pi; 858 struct vi_info *vi; 859 860 if (port_id >= sc->params.nports) 861 return (EINVAL); 862 pi = sc->port[port_id]; 863 864 /* MAC stats */ 865 pi->tx_parse_error = 0; 866 t4_clr_vi_stats(sc); 867 868 /* 869 * Since this command accepts a port, clear stats for 870 * all VIs on this port. 871 */ 872 for_each_vi(pi, v, vi) { 873 if (vi->flags & VI_INIT_DONE) { 874 struct sge_rxq *rxq; 875 struct sge_txq *txq; 876 877 for_each_rxq(vi, i, rxq) { 878#if defined(INET) || defined(INET6) 879 rxq->lro.lro_queued = 0; 880 rxq->lro.lro_flushed = 0; 881#endif 882 rxq->rxcsum = 0; 883 rxq->vlan_extraction = 0; 884 } 885 886 for_each_txq(vi, i, txq) { 887 txq->txcsum = 0; 888 txq->tso_wrs = 0; 889 txq->vlan_insertion = 0; 890 txq->imm_wrs = 0; 891 txq->sgl_wrs = 0; 892 txq->txpkt_wrs = 0; 893 txq->txpkts0_wrs = 0; 894 txq->txpkts1_wrs = 0; 895 txq->txpkts0_pkts = 0; 896 txq->txpkts1_pkts = 0; 897 txq->txpkts_flush = 0; 898 mp_ring_reset_stats(txq->r); 899 } 900 } 901 } 902 break; 903 } 904 case CHELSIO_T4_SCHED_CLASS: 905 rc = t4_set_sched_class(sc, (struct t4_sched_params *)data); 906 break; 907 case CHELSIO_T4_SCHED_QUEUE: 908 rc = t4_set_sched_queue(sc, (struct t4_sched_queue *)data); 909 break; 910 default: 911 rc = ENOTTY; 912 } 913 914 return (rc); 915} 916 917static device_method_t t4vf_methods[] = { 918 DEVMETHOD(device_probe, t4vf_probe), 919 DEVMETHOD(device_attach, t4vf_attach), 920 DEVMETHOD(device_detach, t4_detach_common), 921 922 DEVMETHOD_END 923}; 924 925static driver_t t4vf_driver = { 926 "t4vf", 927 t4vf_methods, 928 sizeof(struct adapter) 929}; 930 931static device_method_t t5vf_methods[] = { 932 DEVMETHOD(device_probe, t5vf_probe), 933 DEVMETHOD(device_attach, t4vf_attach), 934 DEVMETHOD(device_detach, t4_detach_common), 935 936 DEVMETHOD_END 937}; 938 939static driver_t t5vf_driver = { 940 "t5vf", 941 t5vf_methods, 942 sizeof(struct adapter) 943}; 944 945static device_method_t t6vf_methods[] = { 946 DEVMETHOD(device_probe, t6vf_probe), 947 DEVMETHOD(device_attach, t4vf_attach), 948 DEVMETHOD(device_detach, t4_detach_common), 949 950 DEVMETHOD_END 951}; 952 953static driver_t t6vf_driver = { 954 "t6vf", 955 t6vf_methods, 956 sizeof(struct adapter) 957}; 958 959static driver_t cxgbev_driver = { 960 "cxgbev", 961 cxgbe_methods, 962 sizeof(struct port_info) 963}; 964 965static driver_t cxlv_driver = { 966 "cxlv", 967 cxgbe_methods, 968 sizeof(struct port_info) 969}; 970 971static driver_t ccv_driver = { 972 "ccv", 973 cxgbe_methods, 974 sizeof(struct port_info) 975}; 976 977static devclass_t t4vf_devclass, t5vf_devclass, t6vf_devclass; 978static devclass_t cxgbev_devclass, cxlv_devclass, ccv_devclass; 979 980DRIVER_MODULE(t4vf, pci, t4vf_driver, t4vf_devclass, 0, 0); 981MODULE_VERSION(t4vf, 1); 982MODULE_DEPEND(t4vf, t4nex, 1, 1, 1); 983 984DRIVER_MODULE(t5vf, pci, t5vf_driver, t5vf_devclass, 0, 0); 985MODULE_VERSION(t5vf, 1); 986MODULE_DEPEND(t5vf, t5nex, 1, 1, 1); 987 988DRIVER_MODULE(t6vf, pci, t6vf_driver, t6vf_devclass, 0, 0); 989MODULE_VERSION(t6vf, 1); 990MODULE_DEPEND(t6vf, t6nex, 1, 1, 1); 991 992DRIVER_MODULE(cxgbev, t4vf, cxgbev_driver, cxgbev_devclass, 0, 0); 993MODULE_VERSION(cxgbev, 1); 994 995DRIVER_MODULE(cxlv, t5vf, cxlv_driver, cxlv_devclass, 0, 0); 996MODULE_VERSION(cxlv, 1); 997 998DRIVER_MODULE(ccv, t6vf, ccv_driver, ccv_devclass, 0, 0); 999MODULE_VERSION(ccv, 1); 1000