1 /* $OpenBSD: if_urtwn.c,v 1.16 2011/02/10 17:26:40 jakemsr Exp $ */ 2 3 /*- 4 * Copyright (c) 2010 Damien Bergamini <damien.bergamini@free.fr> 5 * Copyright (c) 2014 Kevin Lo <kevlo@FreeBSD.org> 6 * Copyright (c) 2016 Andriy Voskoboinyk <avos@FreeBSD.org> 7 * 8 * Permission to use, copy, modify, and distribute this software for any 9 * purpose with or without fee is hereby granted, provided that the above 10 * copyright notice and this permission notice appear in all copies. 11 * 12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 13 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 14 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 15 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 16 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 17 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 18 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 19 */ 20 21 #include <sys/cdefs.h> 22 __FBSDID("$FreeBSD$"); 23 24 #include <sys/param.h> 25 #include <sys/sysctl.h> 26 #include <sys/lock.h> 27 #include <sys/mutex.h> 28 #include <sys/mbuf.h> 29 #include <sys/kernel.h> 30 #include <sys/socket.h> 31 #include <sys/systm.h> 32 #include <sys/malloc.h> 33 #include <sys/module.h> 34 #include <sys/bus.h> 35 #include <sys/endian.h> 36 #include <sys/linker.h> 37 #include <sys/kdb.h> 38 39 #include <machine/bus.h> 40 #include <machine/resource.h> 41 #include <sys/rman.h> 42 43 #include <dev/pci/pcireg.h> 44 #include <dev/pci/pcivar.h> 45 46 #include <net/if.h> 47 #include <net/ethernet.h> 48 #include <net/if_media.h> 49 50 #include <net80211/ieee80211_var.h> 51 52 #include <dev/rtwn/if_rtwnreg.h> 53 #include <dev/rtwn/if_rtwnvar.h> 54 #include <dev/rtwn/if_rtwn_nop.h> 55 #include <dev/rtwn/if_rtwn_debug.h> 56 57 #include <dev/rtwn/pci/rtwn_pci_var.h> 58 59 #include <dev/rtwn/pci/rtwn_pci_attach.h> 60 #include <dev/rtwn/pci/rtwn_pci_reg.h> 61 #include <dev/rtwn/pci/rtwn_pci_rx.h> 62 #include <dev/rtwn/pci/rtwn_pci_tx.h> 63 64 #include <dev/rtwn/rtl8192c/pci/r92ce_reg.h> 65 #include <dev/rtwn/rtl8192c/pci/r92ce_rx_desc.h> 66 67 68 static device_probe_t rtwn_pci_probe; 69 static device_attach_t rtwn_pci_attach; 70 static device_detach_t rtwn_pci_detach; 71 static device_shutdown_t rtwn_pci_shutdown; 72 static device_suspend_t rtwn_pci_suspend; 73 static device_resume_t rtwn_pci_resume; 74 75 static int rtwn_pci_alloc_rx_list(struct rtwn_softc *); 76 static void rtwn_pci_reset_rx_list(struct rtwn_softc *); 77 static void rtwn_pci_free_rx_list(struct rtwn_softc *); 78 static int rtwn_pci_alloc_tx_list(struct rtwn_softc *, int); 79 static void rtwn_pci_reset_tx_ring_stopped(struct rtwn_softc *, int); 80 static void rtwn_pci_reset_beacon_ring(struct rtwn_softc *, int); 81 static void rtwn_pci_reset_tx_list(struct rtwn_softc *, 82 struct ieee80211vap *, int); 83 static void rtwn_pci_free_tx_list(struct rtwn_softc *, int); 84 static void rtwn_pci_reset_lists(struct rtwn_softc *, 85 struct ieee80211vap *); 86 static int rtwn_pci_fw_write_block(struct rtwn_softc *, 87 const uint8_t *, uint16_t, int); 88 static uint16_t rtwn_pci_get_qmap(struct rtwn_softc *); 89 static void rtwn_pci_set_desc_addr(struct rtwn_softc *); 90 static void rtwn_pci_beacon_update_begin(struct rtwn_softc *, 91 struct ieee80211vap *); 92 static void rtwn_pci_beacon_update_end(struct rtwn_softc *, 93 struct ieee80211vap *); 94 static void rtwn_pci_attach_methods(struct rtwn_softc *); 95 96 97 static int matched_chip = RTWN_CHIP_MAX_PCI; 98 99 static int 100 rtwn_pci_probe(device_t dev) 101 { 102 const struct rtwn_pci_ident *ident; 103 104 for (ident = rtwn_pci_ident_table; ident->name != NULL; ident++) { 105 if (pci_get_vendor(dev) == ident->vendor && 106 pci_get_device(dev) == ident->device) { 107 matched_chip = ident->chip; 108 device_set_desc(dev, ident->name); 109 return (BUS_PROBE_DEFAULT); 110 } 111 } 112 return (ENXIO); 113 } 114 115 static int 116 rtwn_pci_alloc_rx_list(struct rtwn_softc *sc) 117 { 118 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 119 struct rtwn_rx_ring *rx_ring = &pc->rx_ring; 120 struct rtwn_rx_data *rx_data; 121 bus_size_t size; 122 int i, error; 123 124 /* Allocate Rx descriptors. */ 125 size = sizeof(struct r92ce_rx_stat) * RTWN_PCI_RX_LIST_COUNT; 126 error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0, 127 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 128 size, 1, size, 0, NULL, NULL, &rx_ring->desc_dmat); 129 if (error != 0) { 130 device_printf(sc->sc_dev, "could not create rx desc DMA tag\n"); 131 goto fail; 132 } 133 134 error = bus_dmamem_alloc(rx_ring->desc_dmat, (void **)&rx_ring->desc, 135 BUS_DMA_NOWAIT | BUS_DMA_ZERO | BUS_DMA_COHERENT, 136 &rx_ring->desc_map); 137 if (error != 0) { 138 device_printf(sc->sc_dev, "could not allocate rx desc\n"); 139 goto fail; 140 } 141 error = bus_dmamap_load(rx_ring->desc_dmat, rx_ring->desc_map, 142 rx_ring->desc, size, rtwn_pci_dma_map_addr, &rx_ring->paddr, 0); 143 if (error != 0) { 144 device_printf(sc->sc_dev, "could not load rx desc DMA map\n"); 145 goto fail; 146 } 147 bus_dmamap_sync(rx_ring->desc_dmat, rx_ring->desc_map, 148 BUS_DMASYNC_PREWRITE); 149 150 /* Create RX buffer DMA tag. */ 151 error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0, 152 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 153 MJUMPAGESIZE, 1, MJUMPAGESIZE, 0, NULL, NULL, &rx_ring->data_dmat); 154 if (error != 0) { 155 device_printf(sc->sc_dev, "could not create rx buf DMA tag\n"); 156 goto fail; 157 } 158 159 /* Allocate Rx buffers. */ 160 for (i = 0; i < RTWN_PCI_RX_LIST_COUNT; i++) { 161 rx_data = &rx_ring->rx_data[i]; 162 error = bus_dmamap_create(rx_ring->data_dmat, 0, &rx_data->map); 163 if (error != 0) { 164 device_printf(sc->sc_dev, 165 "could not create rx buf DMA map\n"); 166 goto fail; 167 } 168 169 rx_data->m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, 170 MJUMPAGESIZE); 171 if (rx_data->m == NULL) { 172 device_printf(sc->sc_dev, 173 "could not allocate rx mbuf\n"); 174 error = ENOMEM; 175 goto fail; 176 } 177 178 error = bus_dmamap_load(rx_ring->data_dmat, rx_data->map, 179 mtod(rx_data->m, void *), MJUMPAGESIZE, 180 rtwn_pci_dma_map_addr, &rx_data->paddr, BUS_DMA_NOWAIT); 181 if (error != 0) { 182 device_printf(sc->sc_dev, 183 "could not load rx buf DMA map"); 184 goto fail; 185 } 186 187 rtwn_pci_setup_rx_desc(pc, &rx_ring->desc[i], rx_data->paddr, 188 MJUMPAGESIZE, i); 189 } 190 rx_ring->cur = 0; 191 192 return (0); 193 194 fail: 195 rtwn_pci_free_rx_list(sc); 196 return (error); 197 } 198 199 static void 200 rtwn_pci_reset_rx_list(struct rtwn_softc *sc) 201 { 202 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 203 struct rtwn_rx_ring *rx_ring = &pc->rx_ring; 204 struct rtwn_rx_data *rx_data; 205 int i; 206 207 for (i = 0; i < RTWN_PCI_RX_LIST_COUNT; i++) { 208 rx_data = &rx_ring->rx_data[i]; 209 rtwn_pci_setup_rx_desc(pc, &rx_ring->desc[i], 210 rx_data->paddr, MJUMPAGESIZE, i); 211 } 212 rx_ring->cur = 0; 213 } 214 215 static void 216 rtwn_pci_free_rx_list(struct rtwn_softc *sc) 217 { 218 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 219 struct rtwn_rx_ring *rx_ring = &pc->rx_ring; 220 struct rtwn_rx_data *rx_data; 221 int i; 222 223 if (rx_ring->desc_dmat != NULL) { 224 if (rx_ring->desc != NULL) { 225 bus_dmamap_sync(rx_ring->desc_dmat, 226 rx_ring->desc_map, 227 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 228 bus_dmamap_unload(rx_ring->desc_dmat, 229 rx_ring->desc_map); 230 bus_dmamem_free(rx_ring->desc_dmat, rx_ring->desc, 231 rx_ring->desc_map); 232 rx_ring->desc = NULL; 233 } 234 bus_dma_tag_destroy(rx_ring->desc_dmat); 235 rx_ring->desc_dmat = NULL; 236 } 237 238 for (i = 0; i < RTWN_PCI_RX_LIST_COUNT; i++) { 239 rx_data = &rx_ring->rx_data[i]; 240 241 if (rx_data->m != NULL) { 242 bus_dmamap_sync(rx_ring->data_dmat, 243 rx_data->map, BUS_DMASYNC_POSTREAD); 244 bus_dmamap_unload(rx_ring->data_dmat, rx_data->map); 245 m_freem(rx_data->m); 246 rx_data->m = NULL; 247 } 248 bus_dmamap_destroy(rx_ring->data_dmat, rx_data->map); 249 rx_data->map = NULL; 250 } 251 if (rx_ring->data_dmat != NULL) { 252 bus_dma_tag_destroy(rx_ring->data_dmat); 253 rx_ring->data_dmat = NULL; 254 } 255 } 256 257 static int 258 rtwn_pci_alloc_tx_list(struct rtwn_softc *sc, int qid) 259 { 260 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 261 struct rtwn_tx_ring *tx_ring = &pc->tx_ring[qid]; 262 bus_size_t size; 263 int i, error; 264 265 size = sc->txdesc_len * RTWN_PCI_TX_LIST_COUNT; 266 error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), PAGE_SIZE, 0, 267 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 268 size, 1, size, 0, NULL, NULL, &tx_ring->desc_dmat); 269 if (error != 0) { 270 device_printf(sc->sc_dev, "could not create tx ring DMA tag\n"); 271 goto fail; 272 } 273 274 error = bus_dmamem_alloc(tx_ring->desc_dmat, &tx_ring->desc, 275 BUS_DMA_NOWAIT | BUS_DMA_ZERO, &tx_ring->desc_map); 276 if (error != 0) { 277 device_printf(sc->sc_dev, "can't map tx ring DMA memory\n"); 278 goto fail; 279 } 280 error = bus_dmamap_load(tx_ring->desc_dmat, tx_ring->desc_map, 281 tx_ring->desc, size, rtwn_pci_dma_map_addr, &tx_ring->paddr, 282 BUS_DMA_NOWAIT); 283 if (error != 0) { 284 device_printf(sc->sc_dev, "could not load desc DMA map\n"); 285 goto fail; 286 } 287 bus_dmamap_sync(tx_ring->desc_dmat, tx_ring->desc_map, 288 BUS_DMASYNC_PREWRITE); 289 290 error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0, 291 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 292 MJUMPAGESIZE, 1, MJUMPAGESIZE, 0, NULL, NULL, &tx_ring->data_dmat); 293 if (error != 0) { 294 device_printf(sc->sc_dev, "could not create tx buf DMA tag\n"); 295 goto fail; 296 } 297 298 for (i = 0; i < RTWN_PCI_TX_LIST_COUNT; i++) { 299 struct rtwn_tx_data *tx_data = &tx_ring->tx_data[i]; 300 void *tx_desc = (uint8_t *)tx_ring->desc + sc->txdesc_len * i; 301 uint32_t next_desc_addr = tx_ring->paddr + 302 sc->txdesc_len * ((i + 1) % RTWN_PCI_TX_LIST_COUNT); 303 304 rtwn_pci_setup_tx_desc(pc, tx_desc, next_desc_addr); 305 306 error = bus_dmamap_create(tx_ring->data_dmat, 0, &tx_data->map); 307 if (error != 0) { 308 device_printf(sc->sc_dev, 309 "could not create tx buf DMA map\n"); 310 return (error); 311 } 312 tx_data->m = NULL; 313 tx_data->ni = NULL; 314 } 315 return (0); 316 317 fail: 318 rtwn_pci_free_tx_list(sc, qid); 319 return (error); 320 } 321 322 static void 323 rtwn_pci_reset_tx_ring_stopped(struct rtwn_softc *sc, int qid) 324 { 325 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 326 struct rtwn_tx_ring *ring = &pc->tx_ring[qid]; 327 int i; 328 329 for (i = 0; i < RTWN_PCI_TX_LIST_COUNT; i++) { 330 struct rtwn_tx_data *data = &ring->tx_data[i]; 331 void *desc = (uint8_t *)ring->desc + sc->txdesc_len * i; 332 333 rtwn_pci_copy_tx_desc(pc, desc, NULL); 334 335 if (data->m != NULL) { 336 bus_dmamap_sync(ring->data_dmat, data->map, 337 BUS_DMASYNC_POSTWRITE); 338 bus_dmamap_unload(ring->data_dmat, data->map); 339 m_freem(data->m); 340 data->m = NULL; 341 } 342 if (data->ni != NULL) { 343 ieee80211_free_node(data->ni); 344 data->ni = NULL; 345 } 346 } 347 348 bus_dmamap_sync(ring->desc_dmat, ring->desc_map, 349 BUS_DMASYNC_POSTWRITE); 350 351 sc->qfullmsk &= ~(1 << qid); 352 ring->queued = 0; 353 ring->last = ring->cur = 0; 354 } 355 356 /* 357 * Clear entry 0 (or 1) in the beacon queue (other are not used). 358 */ 359 static void 360 rtwn_pci_reset_beacon_ring(struct rtwn_softc *sc, int id) 361 { 362 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 363 struct rtwn_tx_ring *ring = &pc->tx_ring[RTWN_PCI_BEACON_QUEUE]; 364 struct rtwn_tx_data *data = &ring->tx_data[id]; 365 struct rtwn_tx_desc_common *txd = (struct rtwn_tx_desc_common *) 366 ((uint8_t *)ring->desc + id * sc->txdesc_len); 367 368 bus_dmamap_sync(ring->desc_dmat, ring->desc_map, BUS_DMASYNC_POSTREAD); 369 if (txd->flags0 & RTWN_FLAGS0_OWN) { 370 /* Clear OWN bit. */ 371 txd->flags0 &= ~RTWN_FLAGS0_OWN; 372 bus_dmamap_sync(ring->desc_dmat, ring->desc_map, 373 BUS_DMASYNC_PREWRITE); 374 375 /* Unload mbuf. */ 376 bus_dmamap_sync(ring->data_dmat, data->map, 377 BUS_DMASYNC_POSTWRITE); 378 bus_dmamap_unload(ring->data_dmat, data->map); 379 } 380 } 381 382 /* 383 * Drop stale entries from Tx ring before the vap will be deleted. 384 * In case if vap is NULL just free everything and reset cur / last pointers. 385 */ 386 static void 387 rtwn_pci_reset_tx_list(struct rtwn_softc *sc, struct ieee80211vap *vap, 388 int qid) 389 { 390 int i; 391 392 if (vap == NULL) { 393 if (qid != RTWN_PCI_BEACON_QUEUE) { 394 /* 395 * Device was stopped; just clear all entries. 396 */ 397 rtwn_pci_reset_tx_ring_stopped(sc, qid); 398 } else { 399 for (i = 0; i < RTWN_PORT_COUNT; i++) 400 rtwn_pci_reset_beacon_ring(sc, i); 401 } 402 } else if (qid == RTWN_PCI_BEACON_QUEUE && 403 (vap->iv_opmode == IEEE80211_M_HOSTAP || 404 vap->iv_opmode == IEEE80211_M_IBSS)) { 405 struct rtwn_vap *uvp = RTWN_VAP(vap); 406 407 rtwn_pci_reset_beacon_ring(sc, uvp->id); 408 } else { 409 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 410 struct rtwn_tx_ring *ring = &pc->tx_ring[qid]; 411 412 for (i = 0; i < RTWN_PCI_TX_LIST_COUNT; i++) { 413 struct rtwn_tx_data *data = &ring->tx_data[i]; 414 if (data->ni != NULL && data->ni->ni_vap == vap) { 415 /* 416 * NB: if some vap is still running 417 * rtwn_pci_tx_done() will free the mbuf; 418 * otherwise, rtwn_stop() will reset all rings 419 * after device shutdown. 420 */ 421 ieee80211_free_node(data->ni); 422 data->ni = NULL; 423 } 424 } 425 } 426 } 427 428 static void 429 rtwn_pci_free_tx_list(struct rtwn_softc *sc, int qid) 430 { 431 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 432 struct rtwn_tx_ring *tx_ring = &pc->tx_ring[qid]; 433 struct rtwn_tx_data *tx_data; 434 int i; 435 436 if (tx_ring->desc_dmat != NULL) { 437 if (tx_ring->desc != NULL) { 438 bus_dmamap_sync(tx_ring->desc_dmat, 439 tx_ring->desc_map, BUS_DMASYNC_POSTWRITE); 440 bus_dmamap_unload(tx_ring->desc_dmat, 441 tx_ring->desc_map); 442 bus_dmamem_free(tx_ring->desc_dmat, tx_ring->desc, 443 tx_ring->desc_map); 444 } 445 bus_dma_tag_destroy(tx_ring->desc_dmat); 446 } 447 448 for (i = 0; i < RTWN_PCI_TX_LIST_COUNT; i++) { 449 tx_data = &tx_ring->tx_data[i]; 450 451 if (tx_data->m != NULL) { 452 bus_dmamap_sync(tx_ring->data_dmat, tx_data->map, 453 BUS_DMASYNC_POSTWRITE); 454 bus_dmamap_unload(tx_ring->data_dmat, tx_data->map); 455 m_freem(tx_data->m); 456 tx_data->m = NULL; 457 } 458 } 459 if (tx_ring->data_dmat != NULL) { 460 bus_dma_tag_destroy(tx_ring->data_dmat); 461 tx_ring->data_dmat = NULL; 462 } 463 464 sc->qfullmsk &= ~(1 << qid); 465 tx_ring->queued = 0; 466 tx_ring->last = tx_ring->cur = 0; 467 } 468 469 static void 470 rtwn_pci_reset_lists(struct rtwn_softc *sc, struct ieee80211vap *vap) 471 { 472 int i; 473 474 for (i = 0; i < RTWN_PCI_NTXQUEUES; i++) 475 rtwn_pci_reset_tx_list(sc, vap, i); 476 477 if (vap == NULL) { 478 sc->qfullmsk = 0; 479 rtwn_pci_reset_rx_list(sc); 480 } 481 } 482 483 static int 484 rtwn_pci_fw_write_block(struct rtwn_softc *sc, const uint8_t *buf, 485 uint16_t reg, int mlen) 486 { 487 int i; 488 489 for (i = 0; i < mlen; i++) 490 rtwn_pci_write_1(sc, reg++, buf[i]); 491 492 /* NB: cannot fail */ 493 return (0); 494 } 495 496 static uint16_t 497 rtwn_pci_get_qmap(struct rtwn_softc *sc) 498 { 499 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 500 501 KASSERT(pc->pc_qmap != 0, ("%s: qmap is not set!\n", __func__)); 502 503 return (pc->pc_qmap); 504 } 505 506 static void 507 rtwn_pci_set_desc_addr(struct rtwn_softc *sc) 508 { 509 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 510 511 RTWN_DPRINTF(sc, RTWN_DEBUG_RESET, "%s: addresses:\n" 512 "bk: %08jX, be: %08jX, vi: %08jX, vo: %08jX\n" 513 "bcn: %08jX, mgt: %08jX, high: %08jX, rx: %08jX\n", 514 __func__, (uintmax_t)pc->tx_ring[RTWN_PCI_BK_QUEUE].paddr, 515 (uintmax_t)pc->tx_ring[RTWN_PCI_BE_QUEUE].paddr, 516 (uintmax_t)pc->tx_ring[RTWN_PCI_VI_QUEUE].paddr, 517 (uintmax_t)pc->tx_ring[RTWN_PCI_VO_QUEUE].paddr, 518 (uintmax_t)pc->tx_ring[RTWN_PCI_BEACON_QUEUE].paddr, 519 (uintmax_t)pc->tx_ring[RTWN_PCI_MGNT_QUEUE].paddr, 520 (uintmax_t)pc->tx_ring[RTWN_PCI_HIGH_QUEUE].paddr, 521 (uintmax_t)pc->rx_ring.paddr); 522 523 /* Set Tx Configuration Register. */ 524 rtwn_pci_write_4(sc, R92C_TCR, pc->tcr); 525 526 /* Configure Tx DMA. */ 527 rtwn_pci_write_4(sc, R92C_BKQ_DESA, 528 pc->tx_ring[RTWN_PCI_BK_QUEUE].paddr); 529 rtwn_pci_write_4(sc, R92C_BEQ_DESA, 530 pc->tx_ring[RTWN_PCI_BE_QUEUE].paddr); 531 rtwn_pci_write_4(sc, R92C_VIQ_DESA, 532 pc->tx_ring[RTWN_PCI_VI_QUEUE].paddr); 533 rtwn_pci_write_4(sc, R92C_VOQ_DESA, 534 pc->tx_ring[RTWN_PCI_VO_QUEUE].paddr); 535 rtwn_pci_write_4(sc, R92C_BCNQ_DESA, 536 pc->tx_ring[RTWN_PCI_BEACON_QUEUE].paddr); 537 rtwn_pci_write_4(sc, R92C_MGQ_DESA, 538 pc->tx_ring[RTWN_PCI_MGNT_QUEUE].paddr); 539 rtwn_pci_write_4(sc, R92C_HQ_DESA, 540 pc->tx_ring[RTWN_PCI_HIGH_QUEUE].paddr); 541 542 /* Configure Rx DMA. */ 543 rtwn_pci_write_4(sc, R92C_RX_DESA, pc->rx_ring.paddr); 544 } 545 546 static void 547 rtwn_pci_beacon_update_begin(struct rtwn_softc *sc, struct ieee80211vap *vap) 548 { 549 struct rtwn_vap *rvp = RTWN_VAP(vap); 550 551 RTWN_ASSERT_LOCKED(sc); 552 553 rtwn_beacon_enable(sc, rvp->id, 0); 554 } 555 556 static void 557 rtwn_pci_beacon_update_end(struct rtwn_softc *sc, struct ieee80211vap *vap) 558 { 559 struct rtwn_vap *rvp = RTWN_VAP(vap); 560 561 RTWN_ASSERT_LOCKED(sc); 562 563 if (rvp->curr_mode != R92C_MSR_NOLINK) 564 rtwn_beacon_enable(sc, rvp->id, 1); 565 } 566 567 static void 568 rtwn_pci_attach_methods(struct rtwn_softc *sc) 569 { 570 sc->sc_write_1 = rtwn_pci_write_1; 571 sc->sc_write_2 = rtwn_pci_write_2; 572 sc->sc_write_4 = rtwn_pci_write_4; 573 sc->sc_read_1 = rtwn_pci_read_1; 574 sc->sc_read_2 = rtwn_pci_read_2; 575 sc->sc_read_4 = rtwn_pci_read_4; 576 sc->sc_delay = rtwn_pci_delay; 577 sc->sc_tx_start = rtwn_pci_tx_start; 578 sc->sc_reset_lists = rtwn_pci_reset_lists; 579 sc->sc_abort_xfers = rtwn_nop_softc; 580 sc->sc_fw_write_block = rtwn_pci_fw_write_block; 581 sc->sc_get_qmap = rtwn_pci_get_qmap; 582 sc->sc_set_desc_addr = rtwn_pci_set_desc_addr; 583 sc->sc_drop_incorrect_tx = rtwn_nop_softc; 584 sc->sc_beacon_update_begin = rtwn_pci_beacon_update_begin; 585 sc->sc_beacon_update_end = rtwn_pci_beacon_update_end; 586 sc->sc_beacon_unload = rtwn_pci_reset_beacon_ring; 587 588 sc->bcn_check_interval = 25000; 589 } 590 591 static int 592 rtwn_pci_attach(device_t dev) 593 { 594 struct rtwn_pci_softc *pc = device_get_softc(dev); 595 struct rtwn_softc *sc = &pc->pc_sc; 596 struct ieee80211com *ic = &sc->sc_ic; 597 uint32_t lcsr; 598 int cap_off, i, error, rid; 599 600 if (matched_chip >= RTWN_CHIP_MAX_PCI) 601 return (ENXIO); 602 603 /* 604 * Get the offset of the PCI Express Capability Structure in PCI 605 * Configuration Space. 606 */ 607 error = pci_find_cap(dev, PCIY_EXPRESS, &cap_off); 608 if (error != 0) { 609 device_printf(dev, "PCIe capability structure not found!\n"); 610 return (error); 611 } 612 613 /* Enable bus-mastering. */ 614 pci_enable_busmaster(dev); 615 616 rid = PCIR_BAR(2); 617 pc->mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 618 RF_ACTIVE); 619 if (pc->mem == NULL) { 620 device_printf(dev, "can't map mem space\n"); 621 return (ENOMEM); 622 } 623 pc->pc_st = rman_get_bustag(pc->mem); 624 pc->pc_sh = rman_get_bushandle(pc->mem); 625 626 /* Install interrupt handler. */ 627 rid = 1; 628 if (pci_alloc_msi(dev, &rid) == 0) 629 rid = 1; 630 else 631 rid = 0; 632 pc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE | 633 (rid != 0 ? 0 : RF_SHAREABLE)); 634 if (pc->irq == NULL) { 635 device_printf(dev, "can't map interrupt\n"); 636 goto detach; 637 } 638 639 /* Disable PCIe Active State Power Management (ASPM). */ 640 lcsr = pci_read_config(dev, cap_off + PCIER_LINK_CTL, 4); 641 lcsr &= ~PCIEM_LINK_CTL_ASPMC; 642 pci_write_config(dev, cap_off + PCIER_LINK_CTL, lcsr, 4); 643 644 sc->sc_dev = dev; 645 ic->ic_name = device_get_nameunit(dev); 646 647 /* Need to be initialized early. */ 648 rtwn_sysctlattach(sc); 649 mtx_init(&sc->sc_mtx, ic->ic_name, MTX_NETWORK_LOCK, MTX_DEF); 650 651 rtwn_pci_attach_methods(sc); 652 /* XXX something similar to USB_GET_DRIVER_INFO() */ 653 rtwn_pci_attach_private(pc, matched_chip); 654 655 /* Allocate Tx/Rx buffers. */ 656 error = rtwn_pci_alloc_rx_list(sc); 657 if (error != 0) { 658 device_printf(dev, 659 "could not allocate Rx buffers, error %d\n", 660 error); 661 goto detach; 662 } 663 for (i = 0; i < RTWN_PCI_NTXQUEUES; i++) { 664 error = rtwn_pci_alloc_tx_list(sc, i); 665 if (error != 0) { 666 device_printf(dev, 667 "could not allocate Tx buffers, error %d\n", 668 error); 669 goto detach; 670 } 671 } 672 673 /* Generic attach. */ 674 error = rtwn_attach(sc); 675 if (error != 0) 676 goto detach; 677 678 /* 679 * Hook our interrupt after all initialization is complete. 680 */ 681 error = bus_setup_intr(dev, pc->irq, INTR_TYPE_NET | INTR_MPSAFE, 682 NULL, rtwn_pci_intr, sc, &pc->pc_ih); 683 if (error != 0) { 684 device_printf(dev, "can't establish interrupt, error %d\n", 685 error); 686 goto detach; 687 } 688 689 return (0); 690 691 detach: 692 rtwn_pci_detach(dev); /* failure */ 693 return (ENXIO); 694 } 695 696 static int 697 rtwn_pci_detach(device_t dev) 698 { 699 struct rtwn_pci_softc *pc = device_get_softc(dev); 700 struct rtwn_softc *sc = &pc->pc_sc; 701 int i; 702 703 /* Generic detach. */ 704 rtwn_detach(sc); 705 706 /* Uninstall interrupt handler. */ 707 if (pc->irq != NULL) { 708 bus_teardown_intr(dev, pc->irq, pc->pc_ih); 709 bus_release_resource(dev, SYS_RES_IRQ, rman_get_rid(pc->irq), 710 pc->irq); 711 pci_release_msi(dev); 712 } 713 714 /* Free Tx/Rx buffers. */ 715 for (i = 0; i < RTWN_PCI_NTXQUEUES; i++) 716 rtwn_pci_free_tx_list(sc, i); 717 rtwn_pci_free_rx_list(sc); 718 719 if (pc->mem != NULL) 720 bus_release_resource(dev, SYS_RES_MEMORY, 721 rman_get_rid(pc->mem), pc->mem); 722 723 rtwn_detach_private(sc); 724 mtx_destroy(&sc->sc_mtx); 725 726 return (0); 727 } 728 729 static int 730 rtwn_pci_shutdown(device_t self) 731 { 732 struct rtwn_pci_softc *pc = device_get_softc(self); 733 734 ieee80211_stop_all(&pc->pc_sc.sc_ic); 735 return (0); 736 } 737 738 static int 739 rtwn_pci_suspend(device_t self) 740 { 741 struct rtwn_pci_softc *pc = device_get_softc(self); 742 743 rtwn_suspend(&pc->pc_sc); 744 745 return (0); 746 } 747 748 static int 749 rtwn_pci_resume(device_t self) 750 { 751 struct rtwn_pci_softc *pc = device_get_softc(self); 752 753 rtwn_resume(&pc->pc_sc); 754 755 return (0); 756 } 757 758 static device_method_t rtwn_pci_methods[] = { 759 /* Device interface */ 760 DEVMETHOD(device_probe, rtwn_pci_probe), 761 DEVMETHOD(device_attach, rtwn_pci_attach), 762 DEVMETHOD(device_detach, rtwn_pci_detach), 763 DEVMETHOD(device_shutdown, rtwn_pci_shutdown), 764 DEVMETHOD(device_suspend, rtwn_pci_suspend), 765 DEVMETHOD(device_resume, rtwn_pci_resume), 766 767 DEVMETHOD_END 768 }; 769 770 static driver_t rtwn_pci_driver = { 771 "rtwn", 772 rtwn_pci_methods, 773 sizeof(struct rtwn_pci_softc) 774 }; 775 776 static devclass_t rtwn_pci_devclass; 777 778 DRIVER_MODULE(rtwn_pci, pci, rtwn_pci_driver, rtwn_pci_devclass, NULL, NULL); 779 MODULE_VERSION(rtwn_pci, 1); 780 MODULE_DEPEND(rtwn_pci, pci, 1, 1, 1); 781 MODULE_DEPEND(rtwn_pci, wlan, 1, 1, 1); 782 MODULE_DEPEND(rtwn_pci, rtwn, 2, 2, 2); 783