1291233Sadrian/*- 2291233Sadrian * Copyright (c) 2002-2009 Sam Leffler, Errno Consulting 3291233Sadrian * All rights reserved. 4291233Sadrian * 5291233Sadrian * Redistribution and use in source and binary forms, with or without 6291233Sadrian * modification, are permitted provided that the following conditions 7291233Sadrian * are met: 8291233Sadrian * 1. Redistributions of source code must retain the above copyright 9291233Sadrian * notice, this list of conditions and the following disclaimer, 10291233Sadrian * without modification. 11291233Sadrian * 2. Redistributions in binary form must reproduce at minimum a disclaimer 12291233Sadrian * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any 13291233Sadrian * redistribution must be conditioned upon including a substantially 14291233Sadrian * similar Disclaimer requirement for further binary redistribution. 15291233Sadrian * 16291233Sadrian * NO WARRANTY 17291233Sadrian * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18291233Sadrian * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19291233Sadrian * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY 20291233Sadrian * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 21291233Sadrian * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, 22291233Sadrian * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 23291233Sadrian * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24291233Sadrian * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 25291233Sadrian * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 26291233Sadrian * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 27291233Sadrian * THE POSSIBILITY OF SUCH DAMAGES. 28291233Sadrian */ 29291233Sadrian 30291233Sadrian#include <sys/cdefs.h> 31291233Sadrian__FBSDID("$FreeBSD$"); 32291233Sadrian 33291233Sadrian/* 34291233Sadrian * Driver for the Atheros Wireless LAN controller. 35291233Sadrian * 36291233Sadrian * This software is derived from work of Atsushi Onoe; his contribution 37291233Sadrian * is greatly appreciated. 38291233Sadrian */ 39291233Sadrian 40291233Sadrian#include "opt_inet.h" 41291233Sadrian#include "opt_ath.h" 42291233Sadrian/* 43291233Sadrian * This is needed for register operations which are performed 44291233Sadrian * by the driver - eg, calls to ath_hal_gettsf32(). 45291233Sadrian * 46291233Sadrian * It's also required for any AH_DEBUG checks in here, eg the 47291233Sadrian * module dependencies. 48291233Sadrian */ 49291233Sadrian#include "opt_ah.h" 50291233Sadrian#include "opt_wlan.h" 51291233Sadrian 52291233Sadrian#include <sys/param.h> 53291233Sadrian#include <sys/systm.h> 54291233Sadrian#include <sys/sysctl.h> 55291233Sadrian#include <sys/mbuf.h> 56291233Sadrian#include <sys/malloc.h> 57291233Sadrian#include <sys/lock.h> 58291233Sadrian#include <sys/mutex.h> 59291233Sadrian#include <sys/kernel.h> 60291233Sadrian#include <sys/socket.h> 61291233Sadrian#include <sys/sockio.h> 62291233Sadrian#include <sys/errno.h> 63291233Sadrian#include <sys/callout.h> 64291233Sadrian#include <sys/bus.h> 65291233Sadrian#include <sys/endian.h> 66291233Sadrian#include <sys/kthread.h> 67291233Sadrian#include <sys/taskqueue.h> 68291233Sadrian#include <sys/priv.h> 69291233Sadrian#include <sys/module.h> 70291233Sadrian#include <sys/ktr.h> 71291233Sadrian#include <sys/smp.h> /* for mp_ncpus */ 72291233Sadrian 73291233Sadrian#include <machine/bus.h> 74291233Sadrian 75291233Sadrian#include <net/if.h> 76291233Sadrian#include <net/if_var.h> 77291233Sadrian#include <net/if_dl.h> 78291233Sadrian#include <net/if_media.h> 79291233Sadrian#include <net/if_types.h> 80291233Sadrian#include <net/if_arp.h> 81291233Sadrian#include <net/ethernet.h> 82291233Sadrian#include <net/if_llc.h> 83291233Sadrian 84291233Sadrian#include <net80211/ieee80211_var.h> 85291233Sadrian#include <net80211/ieee80211_regdomain.h> 86291233Sadrian#ifdef IEEE80211_SUPPORT_SUPERG 87291233Sadrian#include <net80211/ieee80211_superg.h> 88291233Sadrian#endif 89291233Sadrian#ifdef IEEE80211_SUPPORT_TDMA 90291233Sadrian#include <net80211/ieee80211_tdma.h> 91291233Sadrian#endif 92291233Sadrian 93291233Sadrian#include <net/bpf.h> 94291233Sadrian 95291233Sadrian#ifdef INET 96291233Sadrian#include <netinet/in.h> 97291233Sadrian#include <netinet/if_ether.h> 98291233Sadrian#endif 99291233Sadrian 100291233Sadrian#include <dev/ath/if_athvar.h> 101291233Sadrian#include <dev/ath/ath_hal/ah_devid.h> /* XXX for softled */ 102291233Sadrian#include <dev/ath/ath_hal/ah_diagcodes.h> 103291233Sadrian 104291233Sadrian#include <dev/ath/if_ath_debug.h> 105291233Sadrian#include <dev/ath/if_ath_misc.h> 106291233Sadrian#if 0 107291233Sadrian#include <dev/ath/if_ath_tsf.h> 108291233Sadrian#include <dev/ath/if_ath_tx.h> 109291233Sadrian#include <dev/ath/if_ath_sysctl.h> 110291233Sadrian#include <dev/ath/if_ath_led.h> 111291233Sadrian#include <dev/ath/if_ath_keycache.h> 112291233Sadrian#include <dev/ath/if_ath_rx.h> 113291233Sadrian#include <dev/ath/if_ath_rx_edma.h> 114291233Sadrian#include <dev/ath/if_ath_tx_edma.h> 115291233Sadrian#include <dev/ath/if_ath_beacon.h> 116291233Sadrian#include <dev/ath/if_ath_btcoex.h> 117291233Sadrian#include <dev/ath/if_ath_spectral.h> 118291233Sadrian#include <dev/ath/if_ath_lna_div.h> 119291233Sadrian#include <dev/ath/if_athdfs.h> 120291233Sadrian#endif 121291233Sadrian#include <dev/ath/if_ath_descdma.h> 122291233Sadrian 123291233SadrianMALLOC_DECLARE(M_ATHDEV); 124291233Sadrian 125291233Sadrian/* 126291233Sadrian * This is the descriptor setup / busdma memory intialisation and 127291233Sadrian * teardown routines. 128291233Sadrian */ 129291233Sadrian 130291233Sadrianstatic void 131291233Sadrianath_load_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error) 132291233Sadrian{ 133291233Sadrian bus_addr_t *paddr = (bus_addr_t*) arg; 134291233Sadrian KASSERT(error == 0, ("error %u on bus_dma callback", error)); 135291233Sadrian *paddr = segs->ds_addr; 136291233Sadrian} 137291233Sadrian 138291233Sadrian/* 139291233Sadrian * Allocate the descriptors and appropriate DMA tag/setup. 140291233Sadrian * 141291233Sadrian * For some situations (eg EDMA TX completion), there isn't a requirement 142291233Sadrian * for the ath_buf entries to be allocated. 143291233Sadrian */ 144291233Sadrianint 145291233Sadrianath_descdma_alloc_desc(struct ath_softc *sc, 146291233Sadrian struct ath_descdma *dd, ath_bufhead *head, 147291233Sadrian const char *name, int ds_size, int ndesc) 148291233Sadrian{ 149291233Sadrian#define DS2PHYS(_dd, _ds) \ 150291233Sadrian ((_dd)->dd_desc_paddr + ((caddr_t)(_ds) - (caddr_t)(_dd)->dd_desc)) 151291233Sadrian#define ATH_DESC_4KB_BOUND_CHECK(_daddr, _len) \ 152291233Sadrian ((((u_int32_t)(_daddr) & 0xFFF) > (0x1000 - (_len))) ? 1 : 0) 153291233Sadrian int error; 154291233Sadrian 155291233Sadrian dd->dd_descsize = ds_size; 156291233Sadrian 157291233Sadrian DPRINTF(sc, ATH_DEBUG_RESET, 158291233Sadrian "%s: %s DMA: %u desc, %d bytes per descriptor\n", 159291233Sadrian __func__, name, ndesc, dd->dd_descsize); 160291233Sadrian 161291233Sadrian dd->dd_name = name; 162291233Sadrian dd->dd_desc_len = dd->dd_descsize * ndesc; 163291233Sadrian 164291233Sadrian /* 165291233Sadrian * Merlin work-around: 166291233Sadrian * Descriptors that cross the 4KB boundary can't be used. 167291233Sadrian * Assume one skipped descriptor per 4KB page. 168291233Sadrian */ 169291233Sadrian if (! ath_hal_split4ktrans(sc->sc_ah)) { 170291233Sadrian int numpages = dd->dd_desc_len / 4096; 171291233Sadrian dd->dd_desc_len += ds_size * numpages; 172291233Sadrian } 173291233Sadrian 174291233Sadrian /* 175291233Sadrian * Setup DMA descriptor area. 176291233Sadrian * 177291233Sadrian * BUS_DMA_ALLOCNOW is not used; we never use bounce 178291233Sadrian * buffers for the descriptors themselves. 179291233Sadrian */ 180291233Sadrian error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), /* parent */ 181291233Sadrian PAGE_SIZE, 0, /* alignment, bounds */ 182291233Sadrian BUS_SPACE_MAXADDR_32BIT, /* lowaddr */ 183291233Sadrian BUS_SPACE_MAXADDR, /* highaddr */ 184291233Sadrian NULL, NULL, /* filter, filterarg */ 185291233Sadrian dd->dd_desc_len, /* maxsize */ 186291233Sadrian 1, /* nsegments */ 187291233Sadrian dd->dd_desc_len, /* maxsegsize */ 188291233Sadrian 0, /* flags */ 189291233Sadrian NULL, /* lockfunc */ 190291233Sadrian NULL, /* lockarg */ 191291233Sadrian &dd->dd_dmat); 192291233Sadrian if (error != 0) { 193291233Sadrian device_printf(sc->sc_dev, 194291233Sadrian "cannot allocate %s DMA tag\n", dd->dd_name); 195291233Sadrian return error; 196291233Sadrian } 197291233Sadrian 198291233Sadrian /* allocate descriptors */ 199291233Sadrian error = bus_dmamem_alloc(dd->dd_dmat, (void**) &dd->dd_desc, 200291233Sadrian BUS_DMA_NOWAIT | BUS_DMA_COHERENT, 201291233Sadrian &dd->dd_dmamap); 202291233Sadrian if (error != 0) { 203291233Sadrian device_printf(sc->sc_dev, 204291233Sadrian "unable to alloc memory for %u %s descriptors, error %u\n", 205291233Sadrian ndesc, dd->dd_name, error); 206291233Sadrian goto fail1; 207291233Sadrian } 208291233Sadrian 209291233Sadrian error = bus_dmamap_load(dd->dd_dmat, dd->dd_dmamap, 210291233Sadrian dd->dd_desc, dd->dd_desc_len, 211291233Sadrian ath_load_cb, &dd->dd_desc_paddr, 212291233Sadrian BUS_DMA_NOWAIT); 213291233Sadrian if (error != 0) { 214291233Sadrian device_printf(sc->sc_dev, 215291233Sadrian "unable to map %s descriptors, error %u\n", 216291233Sadrian dd->dd_name, error); 217291233Sadrian goto fail2; 218291233Sadrian } 219291233Sadrian 220291233Sadrian DPRINTF(sc, ATH_DEBUG_RESET, "%s: %s DMA map: %p (%lu) -> %p (%lu)\n", 221291233Sadrian __func__, dd->dd_name, (uint8_t *) dd->dd_desc, 222291233Sadrian (u_long) dd->dd_desc_len, (caddr_t) dd->dd_desc_paddr, 223291233Sadrian /*XXX*/ (u_long) dd->dd_desc_len); 224291233Sadrian 225291233Sadrian return (0); 226291233Sadrian 227291233Sadrianfail2: 228291233Sadrian bus_dmamem_free(dd->dd_dmat, dd->dd_desc, dd->dd_dmamap); 229291233Sadrianfail1: 230291233Sadrian bus_dma_tag_destroy(dd->dd_dmat); 231291233Sadrian memset(dd, 0, sizeof(*dd)); 232291233Sadrian return error; 233291233Sadrian#undef DS2PHYS 234291233Sadrian#undef ATH_DESC_4KB_BOUND_CHECK 235291233Sadrian} 236291233Sadrian 237291233Sadrianint 238291233Sadrianath_descdma_setup(struct ath_softc *sc, 239291233Sadrian struct ath_descdma *dd, ath_bufhead *head, 240291233Sadrian const char *name, int ds_size, int nbuf, int ndesc) 241291233Sadrian{ 242291233Sadrian#define DS2PHYS(_dd, _ds) \ 243291233Sadrian ((_dd)->dd_desc_paddr + ((caddr_t)(_ds) - (caddr_t)(_dd)->dd_desc)) 244291233Sadrian#define ATH_DESC_4KB_BOUND_CHECK(_daddr, _len) \ 245291233Sadrian ((((u_int32_t)(_daddr) & 0xFFF) > (0x1000 - (_len))) ? 1 : 0) 246291233Sadrian uint8_t *ds; 247291233Sadrian struct ath_buf *bf; 248291233Sadrian int i, bsize, error; 249291233Sadrian 250291233Sadrian /* Allocate descriptors */ 251291233Sadrian error = ath_descdma_alloc_desc(sc, dd, head, name, ds_size, 252291233Sadrian nbuf * ndesc); 253291233Sadrian 254291233Sadrian /* Assume any errors during allocation were dealt with */ 255291233Sadrian if (error != 0) { 256291233Sadrian return (error); 257291233Sadrian } 258291233Sadrian 259291233Sadrian ds = (uint8_t *) dd->dd_desc; 260291233Sadrian 261291233Sadrian /* allocate rx buffers */ 262291233Sadrian bsize = sizeof(struct ath_buf) * nbuf; 263291233Sadrian bf = malloc(bsize, M_ATHDEV, M_NOWAIT | M_ZERO); 264291233Sadrian if (bf == NULL) { 265291233Sadrian device_printf(sc->sc_dev, 266291233Sadrian "malloc of %s buffers failed, size %u\n", 267291233Sadrian dd->dd_name, bsize); 268291233Sadrian goto fail3; 269291233Sadrian } 270291233Sadrian dd->dd_bufptr = bf; 271291233Sadrian 272291233Sadrian TAILQ_INIT(head); 273291233Sadrian for (i = 0; i < nbuf; i++, bf++, ds += (ndesc * dd->dd_descsize)) { 274291233Sadrian bf->bf_desc = (struct ath_desc *) ds; 275291233Sadrian bf->bf_daddr = DS2PHYS(dd, ds); 276291233Sadrian if (! ath_hal_split4ktrans(sc->sc_ah)) { 277291233Sadrian /* 278291233Sadrian * Merlin WAR: Skip descriptor addresses which 279291233Sadrian * cause 4KB boundary crossing along any point 280291233Sadrian * in the descriptor. 281291233Sadrian */ 282291233Sadrian if (ATH_DESC_4KB_BOUND_CHECK(bf->bf_daddr, 283291233Sadrian dd->dd_descsize)) { 284291233Sadrian /* Start at the next page */ 285291233Sadrian ds += 0x1000 - (bf->bf_daddr & 0xFFF); 286291233Sadrian bf->bf_desc = (struct ath_desc *) ds; 287291233Sadrian bf->bf_daddr = DS2PHYS(dd, ds); 288291233Sadrian } 289291233Sadrian } 290291233Sadrian error = bus_dmamap_create(sc->sc_dmat, BUS_DMA_NOWAIT, 291291233Sadrian &bf->bf_dmamap); 292291233Sadrian if (error != 0) { 293291233Sadrian device_printf(sc->sc_dev, "unable to create dmamap " 294291233Sadrian "for %s buffer %u, error %u\n", 295291233Sadrian dd->dd_name, i, error); 296291233Sadrian ath_descdma_cleanup(sc, dd, head); 297291233Sadrian return error; 298291233Sadrian } 299291233Sadrian bf->bf_lastds = bf->bf_desc; /* Just an initial value */ 300291233Sadrian TAILQ_INSERT_TAIL(head, bf, bf_list); 301291233Sadrian } 302291233Sadrian 303291233Sadrian /* 304291233Sadrian * XXX TODO: ensure that ds doesn't overflow the descriptor 305291233Sadrian * allocation otherwise weird stuff will occur and crash your 306291233Sadrian * machine. 307291233Sadrian */ 308291233Sadrian return 0; 309291233Sadrian /* XXX this should likely just call ath_descdma_cleanup() */ 310291233Sadrianfail3: 311291233Sadrian bus_dmamap_unload(dd->dd_dmat, dd->dd_dmamap); 312291233Sadrian bus_dmamem_free(dd->dd_dmat, dd->dd_desc, dd->dd_dmamap); 313291233Sadrian bus_dma_tag_destroy(dd->dd_dmat); 314291233Sadrian memset(dd, 0, sizeof(*dd)); 315291233Sadrian return error; 316291233Sadrian#undef DS2PHYS 317291233Sadrian#undef ATH_DESC_4KB_BOUND_CHECK 318291233Sadrian} 319291233Sadrian 320291233Sadrian/* 321291233Sadrian * Allocate ath_buf entries but no descriptor contents. 322291233Sadrian * 323291233Sadrian * This is for RX EDMA where the descriptors are the header part of 324291233Sadrian * the RX buffer. 325291233Sadrian */ 326291233Sadrianint 327291233Sadrianath_descdma_setup_rx_edma(struct ath_softc *sc, 328291233Sadrian struct ath_descdma *dd, ath_bufhead *head, 329291233Sadrian const char *name, int nbuf, int rx_status_len) 330291233Sadrian{ 331291233Sadrian struct ath_buf *bf; 332291233Sadrian int i, bsize, error; 333291233Sadrian 334291233Sadrian DPRINTF(sc, ATH_DEBUG_RESET, "%s: %s DMA: %u buffers\n", 335291233Sadrian __func__, name, nbuf); 336291233Sadrian 337291233Sadrian dd->dd_name = name; 338291233Sadrian /* 339291233Sadrian * This is (mostly) purely for show. We're not allocating any actual 340291233Sadrian * descriptors here as EDMA RX has the descriptor be part 341291233Sadrian * of the RX buffer. 342291233Sadrian * 343291233Sadrian * However, dd_desc_len is used by ath_descdma_free() to determine 344291233Sadrian * whether we have already freed this DMA mapping. 345291233Sadrian */ 346291233Sadrian dd->dd_desc_len = rx_status_len * nbuf; 347291233Sadrian dd->dd_descsize = rx_status_len; 348291233Sadrian 349291233Sadrian /* allocate rx buffers */ 350291233Sadrian bsize = sizeof(struct ath_buf) * nbuf; 351291233Sadrian bf = malloc(bsize, M_ATHDEV, M_NOWAIT | M_ZERO); 352291233Sadrian if (bf == NULL) { 353291233Sadrian device_printf(sc->sc_dev, 354291233Sadrian "malloc of %s buffers failed, size %u\n", 355291233Sadrian dd->dd_name, bsize); 356291233Sadrian error = ENOMEM; 357291233Sadrian goto fail3; 358291233Sadrian } 359291233Sadrian dd->dd_bufptr = bf; 360291233Sadrian 361291233Sadrian TAILQ_INIT(head); 362291233Sadrian for (i = 0; i < nbuf; i++, bf++) { 363291233Sadrian bf->bf_desc = NULL; 364291233Sadrian bf->bf_daddr = 0; 365291233Sadrian bf->bf_lastds = NULL; /* Just an initial value */ 366291233Sadrian 367291233Sadrian error = bus_dmamap_create(sc->sc_dmat, BUS_DMA_NOWAIT, 368291233Sadrian &bf->bf_dmamap); 369291233Sadrian if (error != 0) { 370291233Sadrian device_printf(sc->sc_dev, "unable to create dmamap " 371291233Sadrian "for %s buffer %u, error %u\n", 372291233Sadrian dd->dd_name, i, error); 373291233Sadrian ath_descdma_cleanup(sc, dd, head); 374291233Sadrian return error; 375291233Sadrian } 376291233Sadrian TAILQ_INSERT_TAIL(head, bf, bf_list); 377291233Sadrian } 378291233Sadrian return 0; 379291233Sadrianfail3: 380291233Sadrian memset(dd, 0, sizeof(*dd)); 381291233Sadrian return error; 382291233Sadrian} 383291233Sadrian 384291233Sadrianvoid 385291233Sadrianath_descdma_cleanup(struct ath_softc *sc, 386291233Sadrian struct ath_descdma *dd, ath_bufhead *head) 387291233Sadrian{ 388291233Sadrian struct ath_buf *bf; 389291233Sadrian struct ieee80211_node *ni; 390291233Sadrian int do_warning = 0; 391291233Sadrian 392291233Sadrian if (dd->dd_dmamap != 0) { 393291233Sadrian bus_dmamap_unload(dd->dd_dmat, dd->dd_dmamap); 394291233Sadrian bus_dmamem_free(dd->dd_dmat, dd->dd_desc, dd->dd_dmamap); 395291233Sadrian bus_dma_tag_destroy(dd->dd_dmat); 396291233Sadrian } 397291233Sadrian 398291233Sadrian if (head != NULL) { 399291233Sadrian TAILQ_FOREACH(bf, head, bf_list) { 400291233Sadrian if (bf->bf_m) { 401291233Sadrian /* 402291233Sadrian * XXX warn if there's buffers here. 403291233Sadrian * XXX it should have been freed by the 404291233Sadrian * owner! 405291233Sadrian */ 406291233Sadrian 407291233Sadrian if (do_warning == 0) { 408291233Sadrian do_warning = 1; 409291233Sadrian device_printf(sc->sc_dev, 410291233Sadrian "%s: %s: mbuf should've been" 411291233Sadrian " unmapped/freed!\n", 412291233Sadrian __func__, 413291233Sadrian dd->dd_name); 414291233Sadrian } 415291233Sadrian bus_dmamap_sync(sc->sc_dmat, bf->bf_dmamap, 416291233Sadrian BUS_DMASYNC_POSTREAD); 417291233Sadrian bus_dmamap_unload(sc->sc_dmat, bf->bf_dmamap); 418291233Sadrian m_freem(bf->bf_m); 419291233Sadrian bf->bf_m = NULL; 420291233Sadrian } 421291233Sadrian if (bf->bf_dmamap != NULL) { 422291233Sadrian bus_dmamap_destroy(sc->sc_dmat, bf->bf_dmamap); 423291233Sadrian bf->bf_dmamap = NULL; 424291233Sadrian } 425291233Sadrian ni = bf->bf_node; 426291233Sadrian bf->bf_node = NULL; 427291233Sadrian if (ni != NULL) { 428291233Sadrian /* 429291233Sadrian * Reclaim node reference. 430291233Sadrian */ 431291233Sadrian ieee80211_free_node(ni); 432291233Sadrian } 433291233Sadrian } 434291233Sadrian } 435291233Sadrian 436291233Sadrian if (head != NULL) 437291233Sadrian TAILQ_INIT(head); 438291233Sadrian 439291233Sadrian if (dd->dd_bufptr != NULL) 440291233Sadrian free(dd->dd_bufptr, M_ATHDEV); 441291233Sadrian memset(dd, 0, sizeof(*dd)); 442291233Sadrian} 443