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, MCLBYTES, 153 1, MCLBYTES, 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_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); 170 if (rx_data->m == NULL) { 171 device_printf(sc->sc_dev, 172 "could not allocate rx mbuf\n"); 173 error = ENOMEM; 174 goto fail; 175 } 176 177 error = bus_dmamap_load(rx_ring->data_dmat, rx_data->map, 178 mtod(rx_data->m, void *), MCLBYTES, rtwn_pci_dma_map_addr, 179 &rx_data->paddr, BUS_DMA_NOWAIT); 180 if (error != 0) { 181 device_printf(sc->sc_dev, 182 "could not load rx buf DMA map"); 183 goto fail; 184 } 185 186 rtwn_pci_setup_rx_desc(pc, &rx_ring->desc[i], rx_data->paddr, 187 MCLBYTES, i); 188 } 189 rx_ring->cur = 0; 190 191 return (0); 192 193 fail: 194 rtwn_pci_free_rx_list(sc); 195 return (error); 196 } 197 198 static void 199 rtwn_pci_reset_rx_list(struct rtwn_softc *sc) 200 { 201 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 202 struct rtwn_rx_ring *rx_ring = &pc->rx_ring; 203 struct rtwn_rx_data *rx_data; 204 int i; 205 206 for (i = 0; i < RTWN_PCI_RX_LIST_COUNT; i++) { 207 rx_data = &rx_ring->rx_data[i]; 208 rtwn_pci_setup_rx_desc(pc, &rx_ring->desc[i], 209 rx_data->paddr, MCLBYTES, i); 210 } 211 rx_ring->cur = 0; 212 } 213 214 static void 215 rtwn_pci_free_rx_list(struct rtwn_softc *sc) 216 { 217 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 218 struct rtwn_rx_ring *rx_ring = &pc->rx_ring; 219 struct rtwn_rx_data *rx_data; 220 int i; 221 222 if (rx_ring->desc_dmat != NULL) { 223 if (rx_ring->desc != NULL) { 224 bus_dmamap_sync(rx_ring->desc_dmat, 225 rx_ring->desc_map, 226 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 227 bus_dmamap_unload(rx_ring->desc_dmat, 228 rx_ring->desc_map); 229 bus_dmamem_free(rx_ring->desc_dmat, rx_ring->desc, 230 rx_ring->desc_map); 231 rx_ring->desc = NULL; 232 } 233 bus_dma_tag_destroy(rx_ring->desc_dmat); 234 rx_ring->desc_dmat = NULL; 235 } 236 237 for (i = 0; i < RTWN_PCI_RX_LIST_COUNT; i++) { 238 rx_data = &rx_ring->rx_data[i]; 239 240 if (rx_data->m != NULL) { 241 bus_dmamap_sync(rx_ring->data_dmat, 242 rx_data->map, BUS_DMASYNC_POSTREAD); 243 bus_dmamap_unload(rx_ring->data_dmat, rx_data->map); 244 m_freem(rx_data->m); 245 rx_data->m = NULL; 246 } 247 bus_dmamap_destroy(rx_ring->data_dmat, rx_data->map); 248 rx_data->map = NULL; 249 } 250 if (rx_ring->data_dmat != NULL) { 251 bus_dma_tag_destroy(rx_ring->data_dmat); 252 rx_ring->data_dmat = NULL; 253 } 254 } 255 256 static int 257 rtwn_pci_alloc_tx_list(struct rtwn_softc *sc, int qid) 258 { 259 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 260 struct rtwn_tx_ring *tx_ring = &pc->tx_ring[qid]; 261 bus_size_t size; 262 int i, error; 263 264 size = sc->txdesc_len * RTWN_PCI_TX_LIST_COUNT; 265 error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), PAGE_SIZE, 0, 266 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 267 size, 1, size, 0, NULL, NULL, &tx_ring->desc_dmat); 268 if (error != 0) { 269 device_printf(sc->sc_dev, "could not create tx ring DMA tag\n"); 270 goto fail; 271 } 272 273 error = bus_dmamem_alloc(tx_ring->desc_dmat, &tx_ring->desc, 274 BUS_DMA_NOWAIT | BUS_DMA_ZERO, &tx_ring->desc_map); 275 if (error != 0) { 276 device_printf(sc->sc_dev, "can't map tx ring DMA memory\n"); 277 goto fail; 278 } 279 error = bus_dmamap_load(tx_ring->desc_dmat, tx_ring->desc_map, 280 tx_ring->desc, size, rtwn_pci_dma_map_addr, &tx_ring->paddr, 281 BUS_DMA_NOWAIT); 282 if (error != 0) { 283 device_printf(sc->sc_dev, "could not load desc DMA map\n"); 284 goto fail; 285 } 286 bus_dmamap_sync(tx_ring->desc_dmat, tx_ring->desc_map, 287 BUS_DMASYNC_PREWRITE); 288 289 error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0, 290 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, MCLBYTES, 291 1, MCLBYTES, 0, NULL, NULL, &tx_ring->data_dmat); 292 if (error != 0) { 293 device_printf(sc->sc_dev, "could not create tx buf DMA tag\n"); 294 goto fail; 295 } 296 297 for (i = 0; i < RTWN_PCI_TX_LIST_COUNT; i++) { 298 struct rtwn_tx_data *tx_data = &tx_ring->tx_data[i]; 299 void *tx_desc = (uint8_t *)tx_ring->desc + sc->txdesc_len * i; 300 uint32_t next_desc_addr = tx_ring->paddr + 301 sc->txdesc_len * ((i + 1) % RTWN_PCI_TX_LIST_COUNT); 302 303 rtwn_pci_setup_tx_desc(pc, tx_desc, next_desc_addr); 304 305 error = bus_dmamap_create(tx_ring->data_dmat, 0, &tx_data->map); 306 if (error != 0) { 307 device_printf(sc->sc_dev, 308 "could not create tx buf DMA map\n"); 309 return (error); 310 } 311 tx_data->m = NULL; 312 tx_data->ni = NULL; 313 } 314 return (0); 315 316 fail: 317 rtwn_pci_free_tx_list(sc, qid); 318 return (error); 319 } 320 321 static void 322 rtwn_pci_reset_tx_ring_stopped(struct rtwn_softc *sc, int qid) 323 { 324 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 325 struct rtwn_tx_ring *ring = &pc->tx_ring[qid]; 326 int i; 327 328 for (i = 0; i < RTWN_PCI_TX_LIST_COUNT; i++) { 329 struct rtwn_tx_data *data = &ring->tx_data[i]; 330 void *desc = (uint8_t *)ring->desc + sc->txdesc_len * i; 331 332 rtwn_pci_copy_tx_desc(pc, desc, NULL); 333 334 if (data->m != NULL) { 335 bus_dmamap_sync(ring->data_dmat, data->map, 336 BUS_DMASYNC_POSTWRITE); 337 bus_dmamap_unload(ring->data_dmat, data->map); 338 m_freem(data->m); 339 data->m = NULL; 340 } 341 if (data->ni != NULL) { 342 ieee80211_free_node(data->ni); 343 data->ni = NULL; 344 } 345 } 346 347 bus_dmamap_sync(ring->desc_dmat, ring->desc_map, 348 BUS_DMASYNC_POSTWRITE); 349 350 sc->qfullmsk &= ~(1 << qid); 351 ring->queued = 0; 352 ring->last = ring->cur = 0; 353 } 354 355 /* 356 * Clear entry 0 (or 1) in the beacon queue (other are not used). 357 */ 358 static void 359 rtwn_pci_reset_beacon_ring(struct rtwn_softc *sc, int id) 360 { 361 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 362 struct rtwn_tx_ring *ring = &pc->tx_ring[RTWN_PCI_BEACON_QUEUE]; 363 struct rtwn_tx_data *data = &ring->tx_data[id]; 364 struct rtwn_tx_desc_common *txd = (struct rtwn_tx_desc_common *) 365 ((uint8_t *)ring->desc + id * sc->txdesc_len); 366 367 bus_dmamap_sync(ring->desc_dmat, ring->desc_map, BUS_DMASYNC_POSTREAD); 368 if (txd->flags0 & RTWN_FLAGS0_OWN) { 369 /* Clear OWN bit. */ 370 txd->flags0 &= ~RTWN_FLAGS0_OWN; 371 bus_dmamap_sync(ring->desc_dmat, ring->desc_map, 372 BUS_DMASYNC_PREWRITE); 373 374 /* Unload mbuf. */ 375 bus_dmamap_sync(ring->data_dmat, data->map, 376 BUS_DMASYNC_POSTWRITE); 377 bus_dmamap_unload(ring->data_dmat, data->map); 378 } 379 } 380 381 /* 382 * Drop stale entries from Tx ring before the vap will be deleted. 383 * In case if vap is NULL just free everything and reset cur / last pointers. 384 */ 385 static void 386 rtwn_pci_reset_tx_list(struct rtwn_softc *sc, struct ieee80211vap *vap, 387 int qid) 388 { 389 int i; 390 391 if (vap == NULL) { 392 if (qid != RTWN_PCI_BEACON_QUEUE) { 393 /* 394 * Device was stopped; just clear all entries. 395 */ 396 rtwn_pci_reset_tx_ring_stopped(sc, qid); 397 } else { 398 for (i = 0; i < RTWN_PORT_COUNT; i++) 399 rtwn_pci_reset_beacon_ring(sc, i); 400 } 401 } else if (qid == RTWN_PCI_BEACON_QUEUE && 402 (vap->iv_opmode == IEEE80211_M_HOSTAP || 403 vap->iv_opmode == IEEE80211_M_IBSS)) { 404 struct rtwn_vap *uvp = RTWN_VAP(vap); 405 406 rtwn_pci_reset_beacon_ring(sc, uvp->id); 407 } else { 408 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 409 struct rtwn_tx_ring *ring = &pc->tx_ring[qid]; 410 411 for (i = 0; i < RTWN_PCI_TX_LIST_COUNT; i++) { 412 struct rtwn_tx_data *data = &ring->tx_data[i]; 413 if (data->ni != NULL && data->ni->ni_vap == vap) { 414 /* 415 * NB: if some vap is still running 416 * rtwn_pci_tx_done() will free the mbuf; 417 * otherwise, rtwn_stop() will reset all rings 418 * after device shutdown. 419 */ 420 ieee80211_free_node(data->ni); 421 data->ni = NULL; 422 } 423 } 424 } 425 } 426 427 static void 428 rtwn_pci_free_tx_list(struct rtwn_softc *sc, int qid) 429 { 430 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 431 struct rtwn_tx_ring *tx_ring = &pc->tx_ring[qid]; 432 struct rtwn_tx_data *tx_data; 433 int i; 434 435 if (tx_ring->desc_dmat != NULL) { 436 if (tx_ring->desc != NULL) { 437 bus_dmamap_sync(tx_ring->desc_dmat, 438 tx_ring->desc_map, BUS_DMASYNC_POSTWRITE); 439 bus_dmamap_unload(tx_ring->desc_dmat, 440 tx_ring->desc_map); 441 bus_dmamem_free(tx_ring->desc_dmat, tx_ring->desc, 442 tx_ring->desc_map); 443 } 444 bus_dma_tag_destroy(tx_ring->desc_dmat); 445 } 446 447 for (i = 0; i < RTWN_PCI_TX_LIST_COUNT; i++) { 448 tx_data = &tx_ring->tx_data[i]; 449 450 if (tx_data->m != NULL) { 451 bus_dmamap_sync(tx_ring->data_dmat, tx_data->map, 452 BUS_DMASYNC_POSTWRITE); 453 bus_dmamap_unload(tx_ring->data_dmat, tx_data->map); 454 m_freem(tx_data->m); 455 tx_data->m = NULL; 456 } 457 } 458 if (tx_ring->data_dmat != NULL) { 459 bus_dma_tag_destroy(tx_ring->data_dmat); 460 tx_ring->data_dmat = NULL; 461 } 462 463 sc->qfullmsk &= ~(1 << qid); 464 tx_ring->queued = 0; 465 tx_ring->last = tx_ring->cur = 0; 466 } 467 468 static void 469 rtwn_pci_reset_lists(struct rtwn_softc *sc, struct ieee80211vap *vap) 470 { 471 int i; 472 473 for (i = 0; i < RTWN_PCI_NTXQUEUES; i++) 474 rtwn_pci_reset_tx_list(sc, vap, i); 475 476 if (vap == NULL) { 477 sc->qfullmsk = 0; 478 rtwn_pci_reset_rx_list(sc); 479 } 480 } 481 482 static int 483 rtwn_pci_fw_write_block(struct rtwn_softc *sc, const uint8_t *buf, 484 uint16_t reg, int mlen) 485 { 486 int i; 487 488 for (i = 0; i < mlen; i++) 489 rtwn_pci_write_1(sc, reg++, buf[i]); 490 491 /* NB: cannot fail */ 492 return (0); 493 } 494 495 static uint16_t 496 rtwn_pci_get_qmap(struct rtwn_softc *sc) 497 { 498 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 499 500 KASSERT(pc->pc_qmap != 0, ("%s: qmap is not set!\n", __func__)); 501 502 return (pc->pc_qmap); 503 } 504 505 static void 506 rtwn_pci_set_desc_addr(struct rtwn_softc *sc) 507 { 508 struct rtwn_pci_softc *pc = RTWN_PCI_SOFTC(sc); 509 510 RTWN_DPRINTF(sc, RTWN_DEBUG_RESET, "%s: addresses:\n" 511 "bk: %08jX, be: %08jX, vi: %08jX, vo: %08jX\n" 512 "bcn: %08jX, mgt: %08jX, high: %08jX, rx: %08jX\n", 513 __func__, (uintmax_t)pc->tx_ring[RTWN_PCI_BK_QUEUE].paddr, 514 (uintmax_t)pc->tx_ring[RTWN_PCI_BE_QUEUE].paddr, 515 (uintmax_t)pc->tx_ring[RTWN_PCI_VI_QUEUE].paddr, 516 (uintmax_t)pc->tx_ring[RTWN_PCI_VO_QUEUE].paddr, 517 (uintmax_t)pc->tx_ring[RTWN_PCI_BEACON_QUEUE].paddr, 518 (uintmax_t)pc->tx_ring[RTWN_PCI_MGNT_QUEUE].paddr, 519 (uintmax_t)pc->tx_ring[RTWN_PCI_HIGH_QUEUE].paddr, 520 (uintmax_t)pc->rx_ring.paddr); 521 522 /* Set Tx Configuration Register. */ 523 rtwn_pci_write_4(sc, R92C_TCR, pc->tcr); 524 525 /* Configure Tx DMA. */ 526 rtwn_pci_write_4(sc, R92C_BKQ_DESA, 527 pc->tx_ring[RTWN_PCI_BK_QUEUE].paddr); 528 rtwn_pci_write_4(sc, R92C_BEQ_DESA, 529 pc->tx_ring[RTWN_PCI_BE_QUEUE].paddr); 530 rtwn_pci_write_4(sc, R92C_VIQ_DESA, 531 pc->tx_ring[RTWN_PCI_VI_QUEUE].paddr); 532 rtwn_pci_write_4(sc, R92C_VOQ_DESA, 533 pc->tx_ring[RTWN_PCI_VO_QUEUE].paddr); 534 rtwn_pci_write_4(sc, R92C_BCNQ_DESA, 535 pc->tx_ring[RTWN_PCI_BEACON_QUEUE].paddr); 536 rtwn_pci_write_4(sc, R92C_MGQ_DESA, 537 pc->tx_ring[RTWN_PCI_MGNT_QUEUE].paddr); 538 rtwn_pci_write_4(sc, R92C_HQ_DESA, 539 pc->tx_ring[RTWN_PCI_HIGH_QUEUE].paddr); 540 541 /* Configure Rx DMA. */ 542 rtwn_pci_write_4(sc, R92C_RX_DESA, pc->rx_ring.paddr); 543 } 544 545 static void 546 rtwn_pci_beacon_update_begin(struct rtwn_softc *sc, struct ieee80211vap *vap) 547 { 548 struct rtwn_vap *rvp = RTWN_VAP(vap); 549 550 RTWN_ASSERT_LOCKED(sc); 551 552 rtwn_beacon_enable(sc, rvp->id, 0); 553 } 554 555 static void 556 rtwn_pci_beacon_update_end(struct rtwn_softc *sc, struct ieee80211vap *vap) 557 { 558 struct rtwn_vap *rvp = RTWN_VAP(vap); 559 560 RTWN_ASSERT_LOCKED(sc); 561 562 if (rvp->curr_mode != R92C_MSR_NOLINK) 563 rtwn_beacon_enable(sc, rvp->id, 1); 564 } 565 566 static void 567 rtwn_pci_attach_methods(struct rtwn_softc *sc) 568 { 569 sc->sc_write_1 = rtwn_pci_write_1; 570 sc->sc_write_2 = rtwn_pci_write_2; 571 sc->sc_write_4 = rtwn_pci_write_4; 572 sc->sc_read_1 = rtwn_pci_read_1; 573 sc->sc_read_2 = rtwn_pci_read_2; 574 sc->sc_read_4 = rtwn_pci_read_4; 575 sc->sc_delay = rtwn_pci_delay; 576 sc->sc_tx_start = rtwn_pci_tx_start; 577 sc->sc_reset_lists = rtwn_pci_reset_lists; 578 sc->sc_abort_xfers = rtwn_nop_softc; 579 sc->sc_fw_write_block = rtwn_pci_fw_write_block; 580 sc->sc_get_qmap = rtwn_pci_get_qmap; 581 sc->sc_set_desc_addr = rtwn_pci_set_desc_addr; 582 sc->sc_drop_incorrect_tx = rtwn_nop_softc; 583 sc->sc_beacon_update_begin = rtwn_pci_beacon_update_begin; 584 sc->sc_beacon_update_end = rtwn_pci_beacon_update_end; 585 sc->sc_beacon_unload = rtwn_pci_reset_beacon_ring; 586 587 sc->bcn_check_interval = 25000; 588 } 589 590 static int 591 rtwn_pci_attach(device_t dev) 592 { 593 struct rtwn_pci_softc *pc = device_get_softc(dev); 594 struct rtwn_softc *sc = &pc->pc_sc; 595 struct ieee80211com *ic = &sc->sc_ic; 596 uint32_t lcsr; 597 int cap_off, i, error, rid; 598 599 if (matched_chip >= RTWN_CHIP_MAX_PCI) 600 return (ENXIO); 601 602 /* 603 * Get the offset of the PCI Express Capability Structure in PCI 604 * Configuration Space. 605 */ 606 error = pci_find_cap(dev, PCIY_EXPRESS, &cap_off); 607 if (error != 0) { 608 device_printf(dev, "PCIe capability structure not found!\n"); 609 return (error); 610 } 611 612 /* Enable bus-mastering. */ 613 pci_enable_busmaster(dev); 614 615 rid = PCIR_BAR(2); 616 pc->mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 617 RF_ACTIVE); 618 if (pc->mem == NULL) { 619 device_printf(dev, "can't map mem space\n"); 620 return (ENOMEM); 621 } 622 pc->pc_st = rman_get_bustag(pc->mem); 623 pc->pc_sh = rman_get_bushandle(pc->mem); 624 625 /* Install interrupt handler. */ 626 rid = 1; 627 if (pci_alloc_msi(dev, &rid) == 0) 628 rid = 1; 629 else 630 rid = 0; 631 pc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE | 632 (rid != 0 ? 0 : RF_SHAREABLE)); 633 if (pc->irq == NULL) { 634 device_printf(dev, "can't map interrupt\n"); 635 goto detach; 636 } 637 638 /* Disable PCIe Active State Power Management (ASPM). */ 639 lcsr = pci_read_config(dev, cap_off + PCIER_LINK_CTL, 4); 640 lcsr &= ~PCIEM_LINK_CTL_ASPMC; 641 pci_write_config(dev, cap_off + PCIER_LINK_CTL, lcsr, 4); 642 643 sc->sc_dev = dev; 644 ic->ic_name = device_get_nameunit(dev); 645 646 /* Need to be initialized early. */ 647 rtwn_sysctlattach(sc); 648 mtx_init(&sc->sc_mtx, ic->ic_name, MTX_NETWORK_LOCK, MTX_DEF); 649 650 rtwn_pci_attach_methods(sc); 651 /* XXX something similar to USB_GET_DRIVER_INFO() */ 652 rtwn_pci_attach_private(pc, matched_chip); 653 654 /* Allocate Tx/Rx buffers. */ 655 error = rtwn_pci_alloc_rx_list(sc); 656 if (error != 0) { 657 device_printf(dev, 658 "could not allocate Rx buffers, error %d\n", 659 error); 660 goto detach; 661 } 662 for (i = 0; i < RTWN_PCI_NTXQUEUES; i++) { 663 error = rtwn_pci_alloc_tx_list(sc, i); 664 if (error != 0) { 665 device_printf(dev, 666 "could not allocate Tx buffers, error %d\n", 667 error); 668 goto detach; 669 } 670 } 671 672 /* Generic attach. */ 673 error = rtwn_attach(sc); 674 if (error != 0) 675 goto detach; 676 677 /* 678 * Hook our interrupt after all initialization is complete. 679 */ 680 error = bus_setup_intr(dev, pc->irq, INTR_TYPE_NET | INTR_MPSAFE, 681 NULL, rtwn_pci_intr, sc, &pc->pc_ih); 682 if (error != 0) { 683 device_printf(dev, "can't establish interrupt, error %d\n", 684 error); 685 goto detach; 686 } 687 688 return (0); 689 690 detach: 691 rtwn_pci_detach(dev); /* failure */ 692 return (ENXIO); 693 } 694 695 static int 696 rtwn_pci_detach(device_t dev) 697 { 698 struct rtwn_pci_softc *pc = device_get_softc(dev); 699 struct rtwn_softc *sc = &pc->pc_sc; 700 int i; 701 702 /* Generic detach. */ 703 rtwn_detach(sc); 704 705 /* Uninstall interrupt handler. */ 706 if (pc->irq != NULL) { 707 bus_teardown_intr(dev, pc->irq, pc->pc_ih); 708 bus_release_resource(dev, SYS_RES_IRQ, rman_get_rid(pc->irq), 709 pc->irq); 710 pci_release_msi(dev); 711 } 712 713 /* Free Tx/Rx buffers. */ 714 for (i = 0; i < RTWN_PCI_NTXQUEUES; i++) 715 rtwn_pci_free_tx_list(sc, i); 716 rtwn_pci_free_rx_list(sc); 717 718 if (pc->mem != NULL) 719 bus_release_resource(dev, SYS_RES_MEMORY, 720 rman_get_rid(pc->mem), pc->mem); 721 722 rtwn_detach_private(sc); 723 mtx_destroy(&sc->sc_mtx); 724 725 return (0); 726 } 727 728 static int 729 rtwn_pci_shutdown(device_t self) 730 { 731 struct rtwn_pci_softc *pc = device_get_softc(self); 732 733 ieee80211_stop_all(&pc->pc_sc.sc_ic); 734 return (0); 735 } 736 737 static int 738 rtwn_pci_suspend(device_t self) 739 { 740 struct rtwn_pci_softc *pc = device_get_softc(self); 741 742 rtwn_suspend(&pc->pc_sc); 743 744 return (0); 745 } 746 747 static int 748 rtwn_pci_resume(device_t self) 749 { 750 struct rtwn_pci_softc *pc = device_get_softc(self); 751 752 rtwn_resume(&pc->pc_sc); 753 754 return (0); 755 } 756 757 static device_method_t rtwn_pci_methods[] = { 758 /* Device interface */ 759 DEVMETHOD(device_probe, rtwn_pci_probe), 760 DEVMETHOD(device_attach, rtwn_pci_attach), 761 DEVMETHOD(device_detach, rtwn_pci_detach), 762 DEVMETHOD(device_shutdown, rtwn_pci_shutdown), 763 DEVMETHOD(device_suspend, rtwn_pci_suspend), 764 DEVMETHOD(device_resume, rtwn_pci_resume), 765 766 DEVMETHOD_END 767 }; 768 769 static driver_t rtwn_pci_driver = { 770 "rtwn", 771 rtwn_pci_methods, 772 sizeof(struct rtwn_pci_softc) 773 }; 774 775 static devclass_t rtwn_pci_devclass; 776 777 DRIVER_MODULE(rtwn_pci, pci, rtwn_pci_driver, rtwn_pci_devclass, NULL, NULL); 778 MODULE_VERSION(rtwn_pci, 1); 779 MODULE_DEPEND(rtwn_pci, pci, 1, 1, 1); 780 MODULE_DEPEND(rtwn_pci, wlan, 1, 1, 1); 781 MODULE_DEPEND(rtwn_pci, rtwn, 2, 2, 2); 782