1 /* 2 * Copyright (c) 2002-2005 Sam Leffler, Errno Consulting 3 * Copyright (c) 2004-2005 Atheros Communications, Inc. 4 * Copyright (c) 2006 Devicescape Software, Inc. 5 * Copyright (c) 2007 Jiri Slaby <jirislaby (at) gmail.com> 6 * Copyright (c) 2007 Luis R. Rodriguez <mcgrof (at) winlab.rutgers.edu> 7 * 8 * Modified for gPXE, July 2009, by Joshua Oreman <oremanj (at) rwcr.net> 9 * Original from Linux kernel 2.6.30. 10 * 11 * All rights reserved. 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer, 18 * without modification. 19 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 20 * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any 21 * redistribution must be conditioned upon including a substantially 22 * similar Disclaimer requirement for further binary redistribution. 23 * 3. Neither the names of the above-listed copyright holders nor the names 24 * of any contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * Alternatively, this software may be distributed under the terms of the 28 * GNU General Public License ("GPL") version 2 as published by the Free 29 * Software Foundation. 30 * 31 * NO WARRANTY 32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 33 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 34 * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY 35 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 36 * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, 37 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 38 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 39 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 40 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 41 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 42 * THE POSSIBILITY OF SUCH DAMAGES. 43 * 44 */ 45 46 FILE_LICENCE ( BSD3 ); 47 48 #include <stdlib.h> 49 #include <gpxe/malloc.h> 50 #include <gpxe/timer.h> 51 #include <gpxe/netdevice.h> 52 #include <gpxe/pci.h> 53 #include <gpxe/pci_io.h> 54 55 #include "base.h" 56 #include "reg.h" 57 58 #define ATH5K_CALIB_INTERVAL 10 /* Calibrate PHY every 10 seconds */ 59 #define ATH5K_RETRIES 4 /* Number of times to retry packet sends */ 60 #define ATH5K_DESC_ALIGN 16 /* Alignment for TX/RX descriptors */ 61 62 /******************\ 63 * Internal defines * 64 \******************/ 65 66 /* Known PCI ids */ 67 static struct pci_device_id ath5k_nics[] = { 68 PCI_ROM(0x168c, 0x0207, "ath5210e", "Atheros 5210 early", AR5K_AR5210), 69 PCI_ROM(0x168c, 0x0007, "ath5210", "Atheros 5210", AR5K_AR5210), 70 PCI_ROM(0x168c, 0x0011, "ath5311", "Atheros 5311 (AHB)", AR5K_AR5211), 71 PCI_ROM(0x168c, 0x0012, "ath5211", "Atheros 5211", AR5K_AR5211), 72 PCI_ROM(0x168c, 0x0013, "ath5212", "Atheros 5212", AR5K_AR5212), 73 PCI_ROM(0xa727, 0x0013, "ath5212c","3com Ath 5212", AR5K_AR5212), 74 PCI_ROM(0x10b7, 0x0013, "rdag675", "3com 3CRDAG675", AR5K_AR5212), 75 PCI_ROM(0x168c, 0x1014, "ath5212m", "Ath 5212 miniPCI", AR5K_AR5212), 76 PCI_ROM(0x168c, 0x0014, "ath5212x14", "Atheros 5212 x14", AR5K_AR5212), 77 PCI_ROM(0x168c, 0x0015, "ath5212x15", "Atheros 5212 x15", AR5K_AR5212), 78 PCI_ROM(0x168c, 0x0016, "ath5212x16", "Atheros 5212 x16", AR5K_AR5212), 79 PCI_ROM(0x168c, 0x0017, "ath5212x17", "Atheros 5212 x17", AR5K_AR5212), 80 PCI_ROM(0x168c, 0x0018, "ath5212x18", "Atheros 5212 x18", AR5K_AR5212), 81 PCI_ROM(0x168c, 0x0019, "ath5212x19", "Atheros 5212 x19", AR5K_AR5212), 82 PCI_ROM(0x168c, 0x001a, "ath2413", "Atheros 2413 Griffin", AR5K_AR5212), 83 PCI_ROM(0x168c, 0x001b, "ath5413", "Atheros 5413 Eagle", AR5K_AR5212), 84 PCI_ROM(0x168c, 0x001c, "ath5212e", "Atheros 5212 PCI-E", AR5K_AR5212), 85 PCI_ROM(0x168c, 0x001d, "ath2417", "Atheros 2417 Nala", AR5K_AR5212), 86 }; 87 88 /* Known SREVs */ 89 static const struct ath5k_srev_name srev_names[] = { 90 { "5210", AR5K_VERSION_MAC, AR5K_SREV_AR5210 }, 91 { "5311", AR5K_VERSION_MAC, AR5K_SREV_AR5311 }, 92 { "5311A", AR5K_VERSION_MAC, AR5K_SREV_AR5311A }, 93 { "5311B", AR5K_VERSION_MAC, AR5K_SREV_AR5311B }, 94 { "5211", AR5K_VERSION_MAC, AR5K_SREV_AR5211 }, 95 { "5212", AR5K_VERSION_MAC, AR5K_SREV_AR5212 }, 96 { "5213", AR5K_VERSION_MAC, AR5K_SREV_AR5213 }, 97 { "5213A", AR5K_VERSION_MAC, AR5K_SREV_AR5213A }, 98 { "2413", AR5K_VERSION_MAC, AR5K_SREV_AR2413 }, 99 { "2414", AR5K_VERSION_MAC, AR5K_SREV_AR2414 }, 100 { "5424", AR5K_VERSION_MAC, AR5K_SREV_AR5424 }, 101 { "5413", AR5K_VERSION_MAC, AR5K_SREV_AR5413 }, 102 { "5414", AR5K_VERSION_MAC, AR5K_SREV_AR5414 }, 103 { "2415", AR5K_VERSION_MAC, AR5K_SREV_AR2415 }, 104 { "5416", AR5K_VERSION_MAC, AR5K_SREV_AR5416 }, 105 { "5418", AR5K_VERSION_MAC, AR5K_SREV_AR5418 }, 106 { "2425", AR5K_VERSION_MAC, AR5K_SREV_AR2425 }, 107 { "2417", AR5K_VERSION_MAC, AR5K_SREV_AR2417 }, 108 { "xxxxx", AR5K_VERSION_MAC, AR5K_SREV_UNKNOWN }, 109 { "5110", AR5K_VERSION_RAD, AR5K_SREV_RAD_5110 }, 110 { "5111", AR5K_VERSION_RAD, AR5K_SREV_RAD_5111 }, 111 { "5111A", AR5K_VERSION_RAD, AR5K_SREV_RAD_5111A }, 112 { "2111", AR5K_VERSION_RAD, AR5K_SREV_RAD_2111 }, 113 { "5112", AR5K_VERSION_RAD, AR5K_SREV_RAD_5112 }, 114 { "5112A", AR5K_VERSION_RAD, AR5K_SREV_RAD_5112A }, 115 { "5112B", AR5K_VERSION_RAD, AR5K_SREV_RAD_5112B }, 116 { "2112", AR5K_VERSION_RAD, AR5K_SREV_RAD_2112 }, 117 { "2112A", AR5K_VERSION_RAD, AR5K_SREV_RAD_2112A }, 118 { "2112B", AR5K_VERSION_RAD, AR5K_SREV_RAD_2112B }, 119 { "2413", AR5K_VERSION_RAD, AR5K_SREV_RAD_2413 }, 120 { "5413", AR5K_VERSION_RAD, AR5K_SREV_RAD_5413 }, 121 { "2316", AR5K_VERSION_RAD, AR5K_SREV_RAD_2316 }, 122 { "2317", AR5K_VERSION_RAD, AR5K_SREV_RAD_2317 }, 123 { "5424", AR5K_VERSION_RAD, AR5K_SREV_RAD_5424 }, 124 { "5133", AR5K_VERSION_RAD, AR5K_SREV_RAD_5133 }, 125 { "xxxxx", AR5K_VERSION_RAD, AR5K_SREV_UNKNOWN }, 126 }; 127 128 #define ATH5K_SPMBL_NO 1 129 #define ATH5K_SPMBL_YES 2 130 #define ATH5K_SPMBL_BOTH 3 131 132 static const struct { 133 u16 bitrate; 134 u8 short_pmbl; 135 u8 hw_code; 136 } ath5k_rates[] = { 137 { 10, ATH5K_SPMBL_BOTH, ATH5K_RATE_CODE_1M }, 138 { 20, ATH5K_SPMBL_NO, ATH5K_RATE_CODE_2M }, 139 { 55, ATH5K_SPMBL_NO, ATH5K_RATE_CODE_5_5M }, 140 { 110, ATH5K_SPMBL_NO, ATH5K_RATE_CODE_11M }, 141 { 60, ATH5K_SPMBL_BOTH, ATH5K_RATE_CODE_6M }, 142 { 90, ATH5K_SPMBL_BOTH, ATH5K_RATE_CODE_9M }, 143 { 120, ATH5K_SPMBL_BOTH, ATH5K_RATE_CODE_12M }, 144 { 180, ATH5K_SPMBL_BOTH, ATH5K_RATE_CODE_18M }, 145 { 240, ATH5K_SPMBL_BOTH, ATH5K_RATE_CODE_24M }, 146 { 360, ATH5K_SPMBL_BOTH, ATH5K_RATE_CODE_36M }, 147 { 480, ATH5K_SPMBL_BOTH, ATH5K_RATE_CODE_48M }, 148 { 540, ATH5K_SPMBL_BOTH, ATH5K_RATE_CODE_54M }, 149 { 20, ATH5K_SPMBL_YES, ATH5K_RATE_CODE_2M | AR5K_SET_SHORT_PREAMBLE }, 150 { 55, ATH5K_SPMBL_YES, ATH5K_RATE_CODE_5_5M | AR5K_SET_SHORT_PREAMBLE }, 151 { 110, ATH5K_SPMBL_YES, ATH5K_RATE_CODE_11M | AR5K_SET_SHORT_PREAMBLE }, 152 { 0, 0, 0 }, 153 }; 154 155 #define ATH5K_NR_RATES 15 156 157 /* 158 * Prototypes - PCI stack related functions 159 */ 160 static int ath5k_probe(struct pci_device *pdev, 161 const struct pci_device_id *id); 162 static void ath5k_remove(struct pci_device *pdev); 163 164 struct pci_driver ath5k_pci_driver __pci_driver = { 165 .ids = ath5k_nics, 166 .id_count = sizeof(ath5k_nics) / sizeof(ath5k_nics[0]), 167 .probe = ath5k_probe, 168 .remove = ath5k_remove, 169 }; 170 171 172 173 /* 174 * Prototypes - MAC 802.11 stack related functions 175 */ 176 static int ath5k_tx(struct net80211_device *dev, struct io_buffer *skb); 177 static int ath5k_reset(struct ath5k_softc *sc, struct net80211_channel *chan); 178 static int ath5k_reset_wake(struct ath5k_softc *sc); 179 static int ath5k_start(struct net80211_device *dev); 180 static void ath5k_stop(struct net80211_device *dev); 181 static int ath5k_config(struct net80211_device *dev, int changed); 182 static void ath5k_poll(struct net80211_device *dev); 183 static void ath5k_irq(struct net80211_device *dev, int enable); 184 185 static struct net80211_device_operations ath5k_ops = { 186 .open = ath5k_start, 187 .close = ath5k_stop, 188 .transmit = ath5k_tx, 189 .poll = ath5k_poll, 190 .irq = ath5k_irq, 191 .config = ath5k_config, 192 }; 193 194 /* 195 * Prototypes - Internal functions 196 */ 197 /* Attach detach */ 198 static int ath5k_attach(struct net80211_device *dev); 199 static void ath5k_detach(struct net80211_device *dev); 200 /* Channel/mode setup */ 201 static unsigned int ath5k_copy_channels(struct ath5k_hw *ah, 202 struct net80211_channel *channels, 203 unsigned int mode, 204 unsigned int max); 205 static int ath5k_setup_bands(struct net80211_device *dev); 206 static int ath5k_chan_set(struct ath5k_softc *sc, 207 struct net80211_channel *chan); 208 static void ath5k_setcurmode(struct ath5k_softc *sc, 209 unsigned int mode); 210 static void ath5k_mode_setup(struct ath5k_softc *sc); 211 212 /* Descriptor setup */ 213 static int ath5k_desc_alloc(struct ath5k_softc *sc); 214 static void ath5k_desc_free(struct ath5k_softc *sc); 215 /* Buffers setup */ 216 static int ath5k_rxbuf_setup(struct ath5k_softc *sc, struct ath5k_buf *bf); 217 static int ath5k_txbuf_setup(struct ath5k_softc *sc, struct ath5k_buf *bf); 218 219 static inline void ath5k_txbuf_free(struct ath5k_softc *sc, 220 struct ath5k_buf *bf) 221 { 222 if (!bf->iob) 223 return; 224 225 net80211_tx_complete(sc->dev, bf->iob, 0, ECANCELED); 226 bf->iob = NULL; 227 } 228 229 static inline void ath5k_rxbuf_free(struct ath5k_softc *sc __unused, 230 struct ath5k_buf *bf) 231 { 232 free_iob(bf->iob); 233 bf->iob = NULL; 234 } 235 236 /* Queues setup */ 237 static int ath5k_txq_setup(struct ath5k_softc *sc, 238 int qtype, int subtype); 239 static void ath5k_txq_drainq(struct ath5k_softc *sc, 240 struct ath5k_txq *txq); 241 static void ath5k_txq_cleanup(struct ath5k_softc *sc); 242 static void ath5k_txq_release(struct ath5k_softc *sc); 243 /* Rx handling */ 244 static int ath5k_rx_start(struct ath5k_softc *sc); 245 static void ath5k_rx_stop(struct ath5k_softc *sc); 246 /* Tx handling */ 247 static void ath5k_tx_processq(struct ath5k_softc *sc, 248 struct ath5k_txq *txq); 249 250 /* Interrupt handling */ 251 static int ath5k_init(struct ath5k_softc *sc); 252 static int ath5k_stop_hw(struct ath5k_softc *sc); 253 254 static void ath5k_calibrate(struct ath5k_softc *sc); 255 256 /* Filter */ 257 static void ath5k_configure_filter(struct ath5k_softc *sc); 258 259 /********************\ 260 * PCI Initialization * 261 \********************/ 262 263 #if DBGLVL_MAX 264 static const char * 265 ath5k_chip_name(enum ath5k_srev_type type, u16 val) 266 { 267 const char *name = "xxxxx"; 268 unsigned int i; 269 270 for (i = 0; i < ARRAY_SIZE(srev_names); i++) { 271 if (srev_names[i].sr_type != type) 272 continue; 273 274 if ((val & 0xf0) == srev_names[i].sr_val) 275 name = srev_names[i].sr_name; 276 277 if ((val & 0xff) == srev_names[i].sr_val) { 278 name = srev_names[i].sr_name; 279 break; 280 } 281 } 282 283 return name; 284 } 285 #endif 286 287 static int ath5k_probe(struct pci_device *pdev, 288 const struct pci_device_id *id) 289 { 290 void *mem; 291 struct ath5k_softc *sc; 292 struct net80211_device *dev; 293 int ret; 294 u8 csz; 295 296 adjust_pci_device(pdev); 297 298 /* 299 * Cache line size is used to size and align various 300 * structures used to communicate with the hardware. 301 */ 302 pci_read_config_byte(pdev, PCI_CACHE_LINE_SIZE, &csz); 303 if (csz == 0) { 304 /* 305 * We must have this setup properly for rx buffer 306 * DMA to work so force a reasonable value here if it 307 * comes up zero. 308 */ 309 csz = 16; 310 pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE, csz); 311 } 312 /* 313 * The default setting of latency timer yields poor results, 314 * set it to the value used by other systems. It may be worth 315 * tweaking this setting more. 316 */ 317 pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 0xa8); 318 319 /* 320 * Disable the RETRY_TIMEOUT register (0x41) to keep 321 * PCI Tx retries from interfering with C3 CPU state. 322 */ 323 pci_write_config_byte(pdev, 0x41, 0); 324 325 mem = ioremap(pdev->membase, 0x10000); 326 if (!mem) { 327 DBG("ath5k: cannot remap PCI memory region\n"); 328 ret = -EIO; 329 goto err; 330 } 331 332 /* 333 * Allocate dev (net80211 main struct) 334 * and dev->priv (driver private data) 335 */ 336 dev = net80211_alloc(sizeof(*sc)); 337 if (!dev) { 338 DBG("ath5k: cannot allocate 802.11 device\n"); 339 ret = -ENOMEM; 340 goto err_map; 341 } 342 343 /* Initialize driver private data */ 344 sc = dev->priv; 345 sc->dev = dev; 346 sc->pdev = pdev; 347 348 sc->hwinfo = zalloc(sizeof(*sc->hwinfo)); 349 if (!sc->hwinfo) { 350 DBG("ath5k: cannot allocate 802.11 hardware info structure\n"); 351 ret = -ENOMEM; 352 goto err_free; 353 } 354 355 sc->hwinfo->flags = NET80211_HW_RX_HAS_FCS; 356 sc->hwinfo->signal_type = NET80211_SIGNAL_DB; 357 sc->hwinfo->signal_max = 40; /* 35dB should give perfect 54Mbps */ 358 sc->hwinfo->channel_change_time = 5000; 359 360 /* Avoid working with the device until setup is complete */ 361 sc->status |= ATH_STAT_INVALID; 362 363 sc->iobase = mem; 364 sc->cachelsz = csz * 4; /* convert to bytes */ 365 366 DBG("ath5k: register base at %p (%08lx)\n", sc->iobase, pdev->membase); 367 DBG("ath5k: cache line size %d\n", sc->cachelsz); 368 369 /* Set private data */ 370 pci_set_drvdata(pdev, dev); 371 dev->netdev->dev = (struct device *)pdev; 372 373 /* Initialize device */ 374 ret = ath5k_hw_attach(sc, id->driver_data, &sc->ah); 375 if (ret) 376 goto err_free_hwinfo; 377 378 /* Finish private driver data initialization */ 379 ret = ath5k_attach(dev); 380 if (ret) 381 goto err_ah; 382 383 #if DBGLVL_MAX 384 DBG("Atheros AR%s chip found (MAC: 0x%x, PHY: 0x%x)\n", 385 ath5k_chip_name(AR5K_VERSION_MAC, sc->ah->ah_mac_srev), 386 sc->ah->ah_mac_srev, sc->ah->ah_phy_revision); 387 388 if (!sc->ah->ah_single_chip) { 389 /* Single chip radio (!RF5111) */ 390 if (sc->ah->ah_radio_5ghz_revision && 391 !sc->ah->ah_radio_2ghz_revision) { 392 /* No 5GHz support -> report 2GHz radio */ 393 if (!(sc->ah->ah_capabilities.cap_mode & AR5K_MODE_BIT_11A)) { 394 DBG("RF%s 2GHz radio found (0x%x)\n", 395 ath5k_chip_name(AR5K_VERSION_RAD, 396 sc->ah->ah_radio_5ghz_revision), 397 sc->ah->ah_radio_5ghz_revision); 398 /* No 2GHz support (5110 and some 399 * 5Ghz only cards) -> report 5Ghz radio */ 400 } else if (!(sc->ah->ah_capabilities.cap_mode & AR5K_MODE_BIT_11B)) { 401 DBG("RF%s 5GHz radio found (0x%x)\n", 402 ath5k_chip_name(AR5K_VERSION_RAD, 403 sc->ah->ah_radio_5ghz_revision), 404 sc->ah->ah_radio_5ghz_revision); 405 /* Multiband radio */ 406 } else { 407 DBG("RF%s multiband radio found (0x%x)\n", 408 ath5k_chip_name(AR5K_VERSION_RAD, 409 sc->ah->ah_radio_5ghz_revision), 410 sc->ah->ah_radio_5ghz_revision); 411 } 412 } 413 /* Multi chip radio (RF5111 - RF2111) -> 414 * report both 2GHz/5GHz radios */ 415 else if (sc->ah->ah_radio_5ghz_revision && 416 sc->ah->ah_radio_2ghz_revision) { 417 DBG("RF%s 5GHz radio found (0x%x)\n", 418 ath5k_chip_name(AR5K_VERSION_RAD, 419 sc->ah->ah_radio_5ghz_revision), 420 sc->ah->ah_radio_5ghz_revision); 421 DBG("RF%s 2GHz radio found (0x%x)\n", 422 ath5k_chip_name(AR5K_VERSION_RAD, 423 sc->ah->ah_radio_2ghz_revision), 424 sc->ah->ah_radio_2ghz_revision); 425 } 426 } 427 #endif 428 429 /* Ready to go */ 430 sc->status &= ~ATH_STAT_INVALID; 431 432 return 0; 433 err_ah: 434 ath5k_hw_detach(sc->ah); 435 err_free_hwinfo: 436 free(sc->hwinfo); 437 err_free: 438 net80211_free(dev); 439 err_map: 440 iounmap(mem); 441 err: 442 return ret; 443 } 444 445 static void ath5k_remove(struct pci_device *pdev) 446 { 447 struct net80211_device *dev = pci_get_drvdata(pdev); 448 struct ath5k_softc *sc = dev->priv; 449 450 ath5k_detach(dev); 451 ath5k_hw_detach(sc->ah); 452 iounmap(sc->iobase); 453 free(sc->hwinfo); 454 net80211_free(dev); 455 } 456 457 458 /***********************\ 459 * Driver Initialization * 460 \***********************/ 461 462 static int 463 ath5k_attach(struct net80211_device *dev) 464 { 465 struct ath5k_softc *sc = dev->priv; 466 struct ath5k_hw *ah = sc->ah; 467 int ret; 468 469 /* 470 * Collect the channel list. The 802.11 layer 471 * is resposible for filtering this list based 472 * on settings like the phy mode and regulatory 473 * domain restrictions. 474 */ 475 ret = ath5k_setup_bands(dev); 476 if (ret) { 477 DBG("ath5k: can't get channels\n"); 478 goto err; 479 } 480 481 /* NB: setup here so ath5k_rate_update is happy */ 482 if (ah->ah_modes & AR5K_MODE_BIT_11A) 483 ath5k_setcurmode(sc, AR5K_MODE_11A); 484 else 485 ath5k_setcurmode(sc, AR5K_MODE_11B); 486 487 /* 488 * Allocate tx+rx descriptors and populate the lists. 489 */ 490 ret = ath5k_desc_alloc(sc); 491 if (ret) { 492 DBG("ath5k: can't allocate descriptors\n"); 493 goto err; 494 } 495 496 /* 497 * Allocate hardware transmit queues. Note that hw functions 498 * handle reseting these queues at the needed time. 499 */ 500 ret = ath5k_txq_setup(sc, AR5K_TX_QUEUE_DATA, AR5K_WME_AC_BE); 501 if (ret) { 502 DBG("ath5k: can't setup xmit queue\n"); 503 goto err_desc; 504 } 505 506 sc->last_calib_ticks = currticks(); 507 508 ret = ath5k_eeprom_read_mac(ah, sc->hwinfo->hwaddr); 509 if (ret) { 510 DBG("ath5k: unable to read address from EEPROM: 0x%04x\n", 511 sc->pdev->device); 512 goto err_queues; 513 } 514 515 memset(sc->bssidmask, 0xff, ETH_ALEN); 516 ath5k_hw_set_bssid_mask(sc->ah, sc->bssidmask); 517 518 ret = net80211_register(sc->dev, &ath5k_ops, sc->hwinfo); 519 if (ret) { 520 DBG("ath5k: can't register ieee80211 hw\n"); 521 goto err_queues; 522 } 523 524 return 0; 525 err_queues: 526 ath5k_txq_release(sc); 527 err_desc: 528 ath5k_desc_free(sc); 529 err: 530 return ret; 531 } 532 533 static void 534 ath5k_detach(struct net80211_device *dev) 535 { 536 struct ath5k_softc *sc = dev->priv; 537 538 net80211_unregister(dev); 539 ath5k_desc_free(sc); 540 ath5k_txq_release(sc); 541 } 542 543 544 545 546 /********************\ 547 * Channel/mode setup * 548 \********************/ 549 550 /* 551 * Convert IEEE channel number to MHz frequency. 552 */ 553 static inline short 554 ath5k_ieee2mhz(short chan) 555 { 556 if (chan < 14) 557 return 2407 + 5 * chan; 558 if (chan == 14) 559 return 2484; 560 if (chan < 27) 561 return 2212 + 20 * chan; 562 return 5000 + 5 * chan; 563 } 564 565 static unsigned int 566 ath5k_copy_channels(struct ath5k_hw *ah, 567 struct net80211_channel *channels, 568 unsigned int mode, unsigned int max) 569 { 570 unsigned int i, count, size, chfreq, freq, ch; 571 572 if (!(ah->ah_modes & (1 << mode))) 573 return 0; 574 575 switch (mode) { 576 case AR5K_MODE_11A: 577 case AR5K_MODE_11A_TURBO: 578 /* 1..220, but 2GHz frequencies are filtered by check_channel */ 579 size = 220; 580 chfreq = CHANNEL_5GHZ; 581 break; 582 case AR5K_MODE_11B: 583 case AR5K_MODE_11G: 584 case AR5K_MODE_11G_TURBO: 585 size = 26; 586 chfreq = CHANNEL_2GHZ; 587 break; 588 default: 589 return 0; 590 } 591 592 for (i = 0, count = 0; i < size && max > 0; i++) { 593 ch = i + 1 ; 594 freq = ath5k_ieee2mhz(ch); 595 596 /* Check if channel is supported by the chipset */ 597 if (!ath5k_channel_ok(ah, freq, chfreq)) 598 continue; 599 600 /* Write channel info and increment counter */ 601 channels[count].center_freq = freq; 602 channels[count].maxpower = 0; /* use regulatory */ 603 channels[count].band = (chfreq == CHANNEL_2GHZ) ? 604 NET80211_BAND_2GHZ : NET80211_BAND_5GHZ; 605 switch (mode) { 606 case AR5K_MODE_11A: 607 case AR5K_MODE_11G: 608 channels[count].hw_value = chfreq | CHANNEL_OFDM; 609 break; 610 case AR5K_MODE_11A_TURBO: 611 case AR5K_MODE_11G_TURBO: 612 channels[count].hw_value = chfreq | 613 CHANNEL_OFDM | CHANNEL_TURBO; 614 break; 615 case AR5K_MODE_11B: 616 channels[count].hw_value = CHANNEL_B; 617 } 618 619 count++; 620 max--; 621 } 622 623 return count; 624 } 625 626 static int 627 ath5k_setup_bands(struct net80211_device *dev) 628 { 629 struct ath5k_softc *sc = dev->priv; 630 struct ath5k_hw *ah = sc->ah; 631 int max_c, count_c = 0; 632 int i; 633 int band; 634 635 max_c = sizeof(sc->hwinfo->channels) / sizeof(sc->hwinfo->channels[0]); 636 637 /* 2GHz band */ 638 if (sc->ah->ah_capabilities.cap_mode & AR5K_MODE_BIT_11G) { 639 /* G mode */ 640 band = NET80211_BAND_2GHZ; 641 sc->hwinfo->bands = NET80211_BAND_BIT_2GHZ; 642 sc->hwinfo->modes = (NET80211_MODE_G | NET80211_MODE_B); 643 644 for (i = 0; i < 12; i++) 645 sc->hwinfo->rates[band][i] = ath5k_rates[i].bitrate; 646 sc->hwinfo->nr_rates[band] = 12; 647 648 sc->hwinfo->nr_channels = 649 ath5k_copy_channels(ah, sc->hwinfo->channels, 650 AR5K_MODE_11G, max_c); 651 count_c = sc->hwinfo->nr_channels; 652 max_c -= count_c; 653 } else if (sc->ah->ah_capabilities.cap_mode & AR5K_MODE_BIT_11B) { 654 /* B mode */ 655 band = NET80211_BAND_2GHZ; 656 sc->hwinfo->bands = NET80211_BAND_BIT_2GHZ; 657 sc->hwinfo->modes = NET80211_MODE_B; 658 659 for (i = 0; i < 4; i++) 660 sc->hwinfo->rates[band][i] = ath5k_rates[i].bitrate; 661 sc->hwinfo->nr_rates[band] = 4; 662 663 sc->hwinfo->nr_channels = 664 ath5k_copy_channels(ah, sc->hwinfo->channels, 665 AR5K_MODE_11B, max_c); 666 count_c = sc->hwinfo->nr_channels; 667 max_c -= count_c; 668 } 669 670 /* 5GHz band, A mode */ 671 if (sc->ah->ah_capabilities.cap_mode & AR5K_MODE_BIT_11A) { 672 band = NET80211_BAND_5GHZ; 673 sc->hwinfo->bands |= NET80211_BAND_BIT_5GHZ; 674 sc->hwinfo->modes |= NET80211_MODE_A; 675 676 for (i = 0; i < 8; i++) 677 sc->hwinfo->rates[band][i] = ath5k_rates[i+4].bitrate; 678 sc->hwinfo->nr_rates[band] = 8; 679 680 sc->hwinfo->nr_channels = 681 ath5k_copy_channels(ah, sc->hwinfo->channels, 682 AR5K_MODE_11B, max_c); 683 count_c = sc->hwinfo->nr_channels; 684 max_c -= count_c; 685 } 686 687 return 0; 688 } 689 690 /* 691 * Set/change channels. If the channel is really being changed, 692 * it's done by reseting the chip. To accomplish this we must 693 * first cleanup any pending DMA, then restart stuff after a la 694 * ath5k_init. 695 */ 696 static int 697 ath5k_chan_set(struct ath5k_softc *sc, struct net80211_channel *chan) 698 { 699 if (chan->center_freq != sc->curchan->center_freq || 700 chan->hw_value != sc->curchan->hw_value) { 701 /* 702 * To switch channels clear any pending DMA operations; 703 * wait long enough for the RX fifo to drain, reset the 704 * hardware at the new frequency, and then re-enable 705 * the relevant bits of the h/w. 706 */ 707 DBG2("ath5k: resetting for channel change (%d -> %d MHz)\n", 708 sc->curchan->center_freq, chan->center_freq); 709 return ath5k_reset(sc, chan); 710 } 711 712 return 0; 713 } 714 715 static void 716 ath5k_setcurmode(struct ath5k_softc *sc, unsigned int mode) 717 { 718 sc->curmode = mode; 719 720 if (mode == AR5K_MODE_11A) { 721 sc->curband = NET80211_BAND_5GHZ; 722 } else { 723 sc->curband = NET80211_BAND_2GHZ; 724 } 725 } 726 727 static void 728 ath5k_mode_setup(struct ath5k_softc *sc) 729 { 730 struct ath5k_hw *ah = sc->ah; 731 u32 rfilt; 732 733 /* configure rx filter */ 734 rfilt = sc->filter_flags; 735 ath5k_hw_set_rx_filter(ah, rfilt); 736 737 if (ath5k_hw_hasbssidmask(ah)) 738 ath5k_hw_set_bssid_mask(ah, sc->bssidmask); 739 740 /* configure operational mode */ 741 ath5k_hw_set_opmode(ah); 742 743 ath5k_hw_set_mcast_filter(ah, 0, 0); 744 } 745 746 static inline int 747 ath5k_hw_rix_to_bitrate(int hw_rix) 748 { 749 int i; 750 751 for (i = 0; i < ATH5K_NR_RATES; i++) { 752 if (ath5k_rates[i].hw_code == hw_rix) 753 return ath5k_rates[i].bitrate; 754 } 755 756 DBG("ath5k: invalid rix %02x\n", hw_rix); 757 return 10; /* use lowest rate */ 758 } 759 760 int ath5k_bitrate_to_hw_rix(int bitrate) 761 { 762 int i; 763 764 for (i = 0; i < ATH5K_NR_RATES; i++) { 765 if (ath5k_rates[i].bitrate == bitrate) 766 return ath5k_rates[i].hw_code; 767 } 768 769 DBG("ath5k: invalid bitrate %d\n", bitrate); 770 return ATH5K_RATE_CODE_1M; /* use lowest rate */ 771 } 772 773 /***************\ 774 * Buffers setup * 775 \***************/ 776 777 static struct io_buffer * 778 ath5k_rx_iob_alloc(struct ath5k_softc *sc, u32 *iob_addr) 779 { 780 struct io_buffer *iob; 781 unsigned int off; 782 783 /* 784 * Allocate buffer with headroom_needed space for the 785 * fake physical layer header at the start. 786 */ 787 iob = alloc_iob(sc->rxbufsize + sc->cachelsz - 1); 788 789 if (!iob) { 790 DBG("ath5k: can't alloc iobuf of size %d\n", 791 sc->rxbufsize + sc->cachelsz - 1); 792 return NULL; 793 } 794 795 *iob_addr = virt_to_bus(iob->data); 796 797 /* 798 * Cache-line-align. This is important (for the 799 * 5210 at least) as not doing so causes bogus data 800 * in rx'd frames. 801 */ 802 off = *iob_addr % sc->cachelsz; 803 if (off != 0) { 804 iob_reserve(iob, sc->cachelsz - off); 805 *iob_addr += sc->cachelsz - off; 806 } 807 808 return iob; 809 } 810 811 static int 812 ath5k_rxbuf_setup(struct ath5k_softc *sc, struct ath5k_buf *bf) 813 { 814 struct ath5k_hw *ah = sc->ah; 815 struct io_buffer *iob = bf->iob; 816 struct ath5k_desc *ds; 817 818 if (!iob) { 819 iob = ath5k_rx_iob_alloc(sc, &bf->iobaddr); 820 if (!iob) 821 return -ENOMEM; 822 bf->iob = iob; 823 } 824 825 /* 826 * Setup descriptors. For receive we always terminate 827 * the descriptor list with a self-linked entry so we'll 828 * not get overrun under high load (as can happen with a 829 * 5212 when ANI processing enables PHY error frames). 830 * 831 * To insure the last descriptor is self-linked we create 832 * each descriptor as self-linked and add it to the end. As 833 * each additional descriptor is added the previous self-linked 834 * entry is ``fixed'' naturally. This should be safe even 835 * if DMA is happening. When processing RX interrupts we 836 * never remove/process the last, self-linked, entry on the 837 * descriptor list. This insures the hardware always has 838 * someplace to write a new frame. 839 */ 840 ds = bf->desc; 841 ds->ds_link = bf->daddr; /* link to self */ 842 ds->ds_data = bf->iobaddr; 843 if (ah->ah_setup_rx_desc(ah, ds, 844 iob_tailroom(iob), /* buffer size */ 845 0) != 0) { 846 DBG("ath5k: error setting up RX descriptor for %d bytes\n", iob_tailroom(iob)); 847 return -EINVAL; 848 } 849 850 if (sc->rxlink != NULL) 851 *sc->rxlink = bf->daddr; 852 sc->rxlink = &ds->ds_link; 853 return 0; 854 } 855 856 static int 857 ath5k_txbuf_setup(struct ath5k_softc *sc, struct ath5k_buf *bf) 858 { 859 struct ath5k_hw *ah = sc->ah; 860 struct ath5k_txq *txq = &sc->txq; 861 struct ath5k_desc *ds = bf->desc; 862 struct io_buffer *iob = bf->iob; 863 unsigned int pktlen, flags; 864 int ret; 865 u16 duration = 0; 866 u16 cts_rate = 0; 867 868 flags = AR5K_TXDESC_INTREQ | AR5K_TXDESC_CLRDMASK; 869 bf->iobaddr = virt_to_bus(iob->data); 870 pktlen = iob_len(iob); 871 872 /* FIXME: If we are in g mode and rate is a CCK rate 873 * subtract ah->ah_txpower.txp_cck_ofdm_pwr_delta 874 * from tx power (value is in dB units already) */ 875 if (sc->dev->phy_flags & NET80211_PHY_USE_PROTECTION) { 876 struct net80211_device *dev = sc->dev; 877 878 flags |= AR5K_TXDESC_CTSENA; 879 cts_rate = sc->hw_rtscts_rate; 880 duration = net80211_cts_duration(dev, pktlen); 881 } 882 ret = ah->ah_setup_tx_desc(ah, ds, pktlen, 883 IEEE80211_TYP_FRAME_HEADER_LEN, 884 AR5K_PKT_TYPE_NORMAL, sc->power_level * 2, 885 sc->hw_rate, ATH5K_RETRIES, 886 AR5K_TXKEYIX_INVALID, 0, flags, 887 cts_rate, duration); 888 if (ret) 889 return ret; 890 891 ds->ds_link = 0; 892 ds->ds_data = bf->iobaddr; 893 894 list_add_tail(&bf->list, &txq->q); 895 if (txq->link == NULL) /* is this first packet? */ 896 ath5k_hw_set_txdp(ah, txq->qnum, bf->daddr); 897 else /* no, so only link it */ 898 *txq->link = bf->daddr; 899 900 txq->link = &ds->ds_link; 901 ath5k_hw_start_tx_dma(ah, txq->qnum); 902 mb(); 903 904 return 0; 905 } 906 907 /*******************\ 908 * Descriptors setup * 909 \*******************/ 910 911 static int 912 ath5k_desc_alloc(struct ath5k_softc *sc) 913 { 914 struct ath5k_desc *ds; 915 struct ath5k_buf *bf; 916 u32 da; 917 unsigned int i; 918 int ret; 919 920 /* allocate descriptors */ 921 sc->desc_len = sizeof(struct ath5k_desc) * (ATH_TXBUF + ATH_RXBUF + 1); 922 sc->desc = malloc_dma(sc->desc_len, ATH5K_DESC_ALIGN); 923 if (sc->desc == NULL) { 924 DBG("ath5k: can't allocate descriptors\n"); 925 ret = -ENOMEM; 926 goto err; 927 } 928 memset(sc->desc, 0, sc->desc_len); 929 sc->desc_daddr = virt_to_bus(sc->desc); 930 931 ds = sc->desc; 932 da = sc->desc_daddr; 933 934 bf = calloc(ATH_TXBUF + ATH_RXBUF + 1, sizeof(struct ath5k_buf)); 935 if (bf == NULL) { 936 DBG("ath5k: can't allocate buffer pointers\n"); 937 ret = -ENOMEM; 938 goto err_free; 939 } 940 sc->bufptr = bf; 941 942 INIT_LIST_HEAD(&sc->rxbuf); 943 for (i = 0; i < ATH_RXBUF; i++, bf++, ds++, da += sizeof(*ds)) { 944 bf->desc = ds; 945 bf->daddr = da; 946 list_add_tail(&bf->list, &sc->rxbuf); 947 } 948 949 INIT_LIST_HEAD(&sc->txbuf); 950 sc->txbuf_len = ATH_TXBUF; 951 for (i = 0; i < ATH_TXBUF; i++, bf++, ds++, da += sizeof(*ds)) { 952 bf->desc = ds; 953 bf->daddr = da; 954 list_add_tail(&bf->list, &sc->txbuf); 955 } 956 957 return 0; 958 959 err_free: 960 free_dma(sc->desc, sc->desc_len); 961 err: 962 sc->desc = NULL; 963 return ret; 964 } 965 966 static void 967 ath5k_desc_free(struct ath5k_softc *sc) 968 { 969 struct ath5k_buf *bf; 970 971 list_for_each_entry(bf, &sc->txbuf, list) 972 ath5k_txbuf_free(sc, bf); 973 list_for_each_entry(bf, &sc->rxbuf, list) 974 ath5k_rxbuf_free(sc, bf); 975 976 /* Free memory associated with all descriptors */ 977 free_dma(sc->desc, sc->desc_len); 978 979 free(sc->bufptr); 980 sc->bufptr = NULL; 981 } 982 983 984 985 986 987 /**************\ 988 * Queues setup * 989 \**************/ 990 991 static int 992 ath5k_txq_setup(struct ath5k_softc *sc, int qtype, int subtype) 993 { 994 struct ath5k_hw *ah = sc->ah; 995 struct ath5k_txq *txq; 996 struct ath5k_txq_info qi = { 997 .tqi_subtype = subtype, 998 .tqi_aifs = AR5K_TXQ_USEDEFAULT, 999 .tqi_cw_min = AR5K_TXQ_USEDEFAULT, 1000 .tqi_cw_max = AR5K_TXQ_USEDEFAULT 1001 }; 1002 int qnum; 1003 1004 /* 1005 * Enable interrupts only for EOL and DESC conditions. 1006 * We mark tx descriptors to receive a DESC interrupt 1007 * when a tx queue gets deep; otherwise waiting for the 1008 * EOL to reap descriptors. Note that this is done to 1009 * reduce interrupt load and this only defers reaping 1010 * descriptors, never transmitting frames. Aside from 1011 * reducing interrupts this also permits more concurrency. 1012 * The only potential downside is if the tx queue backs 1013 * up in which case the top half of the kernel may backup 1014 * due to a lack of tx descriptors. 1015 */ 1016 qi.tqi_flags = AR5K_TXQ_FLAG_TXEOLINT_ENABLE | 1017 AR5K_TXQ_FLAG_TXDESCINT_ENABLE; 1018 qnum = ath5k_hw_setup_tx_queue(ah, qtype, &qi); 1019 if (qnum < 0) { 1020 DBG("ath5k: can't set up a TX queue\n"); 1021 return -EIO; 1022 } 1023 1024 txq = &sc->txq; 1025 if (!txq->setup) { 1026 txq->qnum = qnum; 1027 txq->link = NULL; 1028 INIT_LIST_HEAD(&txq->q); 1029 txq->setup = 1; 1030 } 1031 return 0; 1032 } 1033 1034 static void 1035 ath5k_txq_drainq(struct ath5k_softc *sc, struct ath5k_txq *txq) 1036 { 1037 struct ath5k_buf *bf, *bf0; 1038 1039 list_for_each_entry_safe(bf, bf0, &txq->q, list) { 1040 ath5k_txbuf_free(sc, bf); 1041 1042 list_del(&bf->list); 1043 list_add_tail(&bf->list, &sc->txbuf); 1044 sc->txbuf_len++; 1045 } 1046 txq->link = NULL; 1047 } 1048 1049 /* 1050 * Drain the transmit queues and reclaim resources. 1051 */ 1052 static void 1053 ath5k_txq_cleanup(struct ath5k_softc *sc) 1054 { 1055 struct ath5k_hw *ah = sc->ah; 1056 1057 if (!(sc->status & ATH_STAT_INVALID)) { 1058 /* don't touch the hardware if marked invalid */ 1059 if (sc->txq.setup) { 1060 ath5k_hw_stop_tx_dma(ah, sc->txq.qnum); 1061 DBG("ath5k: txq [%d] %x, link %p\n", 1062 sc->txq.qnum, 1063 ath5k_hw_get_txdp(ah, sc->txq.qnum), 1064 sc->txq.link); 1065 } 1066 } 1067 1068 if (sc->txq.setup) 1069 ath5k_txq_drainq(sc, &sc->txq); 1070 } 1071 1072 static void 1073 ath5k_txq_release(struct ath5k_softc *sc) 1074 { 1075 if (sc->txq.setup) { 1076 ath5k_hw_release_tx_queue(sc->ah); 1077 sc->txq.setup = 0; 1078 } 1079 } 1080 1081 1082 1083 1084 /*************\ 1085 * RX Handling * 1086 \*************/ 1087 1088 /* 1089 * Enable the receive h/w following a reset. 1090 */ 1091 static int 1092 ath5k_rx_start(struct ath5k_softc *sc) 1093 { 1094 struct ath5k_hw *ah = sc->ah; 1095 struct ath5k_buf *bf; 1096 int ret; 1097 1098 sc->rxbufsize = IEEE80211_MAX_LEN; 1099 if (sc->rxbufsize % sc->cachelsz != 0) 1100 sc->rxbufsize += sc->cachelsz - (sc->rxbufsize % sc->cachelsz); 1101 1102 sc->rxlink = NULL; 1103 1104 list_for_each_entry(bf, &sc->rxbuf, list) { 1105 ret = ath5k_rxbuf_setup(sc, bf); 1106 if (ret != 0) 1107 return ret; 1108 } 1109 1110 bf = list_entry(sc->rxbuf.next, struct ath5k_buf, list); 1111 1112 ath5k_hw_set_rxdp(ah, bf->daddr); 1113 ath5k_hw_start_rx_dma(ah); /* enable recv descriptors */ 1114 ath5k_mode_setup(sc); /* set filters, etc. */ 1115 ath5k_hw_start_rx_pcu(ah); /* re-enable PCU/DMA engine */ 1116 1117 return 0; 1118 } 1119 1120 /* 1121 * Disable the receive h/w in preparation for a reset. 1122 */ 1123 static void 1124 ath5k_rx_stop(struct ath5k_softc *sc) 1125 { 1126 struct ath5k_hw *ah = sc->ah; 1127 1128 ath5k_hw_stop_rx_pcu(ah); /* disable PCU */ 1129 ath5k_hw_set_rx_filter(ah, 0); /* clear recv filter */ 1130 ath5k_hw_stop_rx_dma(ah); /* disable DMA engine */ 1131 1132 sc->rxlink = NULL; /* just in case */ 1133 } 1134 1135 static void 1136 ath5k_handle_rx(struct ath5k_softc *sc) 1137 { 1138 struct ath5k_rx_status rs; 1139 struct io_buffer *iob, *next_iob; 1140 u32 next_iob_addr; 1141 struct ath5k_buf *bf, *bf_last; 1142 struct ath5k_desc *ds; 1143 int ret; 1144 1145 memset(&rs, 0, sizeof(rs)); 1146 1147 if (list_empty(&sc->rxbuf)) { 1148 DBG("ath5k: empty rx buf pool\n"); 1149 return; 1150 } 1151 1152 bf_last = list_entry(sc->rxbuf.prev, struct ath5k_buf, list); 1153 1154 do { 1155 bf = list_entry(sc->rxbuf.next, struct ath5k_buf, list); 1156 assert(bf->iob != NULL); 1157 iob = bf->iob; 1158 ds = bf->desc; 1159 1160 /* 1161 * last buffer must not be freed to ensure proper hardware 1162 * function. When the hardware finishes also a packet next to 1163 * it, we are sure, it doesn't use it anymore and we can go on. 1164 */ 1165 if (bf_last == bf) 1166 bf->flags |= 1; 1167 if (bf->flags) { 1168 struct ath5k_buf *bf_next = list_entry(bf->list.next, 1169 struct ath5k_buf, list); 1170 ret = sc->ah->ah_proc_rx_desc(sc->ah, bf_next->desc, 1171 &rs); 1172 if (ret) 1173 break; 1174 bf->flags &= ~1; 1175 /* skip the overwritten one (even status is martian) */ 1176 goto next; 1177 } 1178 1179 ret = sc->ah->ah_proc_rx_desc(sc->ah, ds, &rs); 1180 if (ret) { 1181 if (ret != -EINPROGRESS) { 1182 DBG("ath5k: error in processing rx desc: %s\n", 1183 strerror(ret)); 1184 net80211_rx_err(sc->dev, NULL, -ret); 1185 } else { 1186 /* normal return, reached end of 1187 available descriptors */ 1188 } 1189 return; 1190 } 1191 1192 if (rs.rs_more) { 1193 DBG("ath5k: unsupported fragmented rx\n"); 1194 goto next; 1195 } 1196 1197 if (rs.rs_status) { 1198 if (rs.rs_status & AR5K_RXERR_PHY) { 1199 /* These are uncommon, and may indicate a real problem. */ 1200 net80211_rx_err(sc->dev, NULL, EIO); 1201 goto next; 1202 } 1203 if (rs.rs_status & AR5K_RXERR_CRC) { 1204 /* These occur *all the time*. */ 1205 goto next; 1206 } 1207 if (rs.rs_status & AR5K_RXERR_DECRYPT) { 1208 /* 1209 * Decrypt error. If the error occurred 1210 * because there was no hardware key, then 1211 * let the frame through so the upper layers 1212 * can process it. This is necessary for 5210 1213 * parts which have no way to setup a ``clear'' 1214 * key cache entry. 1215 * 1216 * XXX do key cache faulting 1217 */ 1218 if (rs.rs_keyix == AR5K_RXKEYIX_INVALID && 1219 !(rs.rs_status & AR5K_RXERR_CRC)) 1220 goto accept; 1221 } 1222 1223 /* any other error, unhandled */ 1224 DBG("ath5k: packet rx status %x\n", rs.rs_status); 1225 goto next; 1226 } 1227 accept: 1228 next_iob = ath5k_rx_iob_alloc(sc, &next_iob_addr); 1229 1230 /* 1231 * If we can't replace bf->iob with a new iob under memory 1232 * pressure, just skip this packet 1233 */ 1234 if (!next_iob) { 1235 DBG("ath5k: dropping packet under memory pressure\n"); 1236 goto next; 1237 } 1238 1239 iob_put(iob, rs.rs_datalen); 1240 1241 /* The MAC header is padded to have 32-bit boundary if the 1242 * packet payload is non-zero. However, gPXE only 1243 * supports standard 802.11 packets with 24-byte 1244 * header, so no padding correction should be needed. 1245 */ 1246 1247 DBG2("ath5k: rx %d bytes, signal %d\n", rs.rs_datalen, 1248 rs.rs_rssi); 1249 1250 net80211_rx(sc->dev, iob, rs.rs_rssi, 1251 ath5k_hw_rix_to_bitrate(rs.rs_rate)); 1252 1253 bf->iob = next_iob; 1254 bf->iobaddr = next_iob_addr; 1255 next: 1256 list_del(&bf->list); 1257 list_add_tail(&bf->list, &sc->rxbuf); 1258 } while (ath5k_rxbuf_setup(sc, bf) == 0); 1259 } 1260 1261 1262 1263 1264 /*************\ 1265 * TX Handling * 1266 \*************/ 1267 1268 static void 1269 ath5k_tx_processq(struct ath5k_softc *sc, struct ath5k_txq *txq) 1270 { 1271 struct ath5k_tx_status ts; 1272 struct ath5k_buf *bf, *bf0; 1273 struct ath5k_desc *ds; 1274 struct io_buffer *iob; 1275 int ret; 1276 1277 memset(&ts, 0, sizeof(ts)); 1278 1279 list_for_each_entry_safe(bf, bf0, &txq->q, list) { 1280 ds = bf->desc; 1281 1282 ret = sc->ah->ah_proc_tx_desc(sc->ah, ds, &ts); 1283 if (ret) { 1284 if (ret != -EINPROGRESS) { 1285 DBG("ath5k: error in processing tx desc: %s\n", 1286 strerror(ret)); 1287 } else { 1288 /* normal return, reached end of tx completions */ 1289 } 1290 break; 1291 } 1292 1293 iob = bf->iob; 1294 bf->iob = NULL; 1295 1296 DBG2("ath5k: tx %d bytes complete, %d retries\n", 1297 iob_len(iob), ts.ts_retry[0]); 1298 1299 net80211_tx_complete(sc->dev, iob, ts.ts_retry[0], 1300 ts.ts_status ? EIO : 0); 1301 1302 list_del(&bf->list); 1303 list_add_tail(&bf->list, &sc->txbuf); 1304 sc->txbuf_len++; 1305 } 1306 1307 if (list_empty(&txq->q)) 1308 txq->link = NULL; 1309 } 1310 1311 static void 1312 ath5k_handle_tx(struct ath5k_softc *sc) 1313 { 1314 ath5k_tx_processq(sc, &sc->txq); 1315 } 1316 1317 1318 /********************\ 1319 * Interrupt handling * 1320 \********************/ 1321 1322 static void 1323 ath5k_irq(struct net80211_device *dev, int enable) 1324 { 1325 struct ath5k_softc *sc = dev->priv; 1326 struct ath5k_hw *ah = sc->ah; 1327 1328 sc->irq_ena = enable; 1329 ah->ah_ier = enable ? AR5K_IER_ENABLE : AR5K_IER_DISABLE; 1330 1331 ath5k_hw_reg_write(ah, ah->ah_ier, AR5K_IER); 1332 ath5k_hw_set_imr(ah, sc->imask); 1333 } 1334 1335 static int 1336 ath5k_init(struct ath5k_softc *sc) 1337 { 1338 struct ath5k_hw *ah = sc->ah; 1339 int ret, i; 1340 1341 /* 1342 * Stop anything previously setup. This is safe 1343 * no matter this is the first time through or not. 1344 */ 1345 ath5k_stop_hw(sc); 1346 1347 /* 1348 * The basic interface to setting the hardware in a good 1349 * state is ``reset''. On return the hardware is known to 1350 * be powered up and with interrupts disabled. This must 1351 * be followed by initialization of the appropriate bits 1352 * and then setup of the interrupt mask. 1353 */ 1354 sc->curchan = sc->dev->channels + sc->dev->channel; 1355 sc->curband = sc->curchan->band; 1356 sc->imask = AR5K_INT_RXOK | AR5K_INT_RXERR | AR5K_INT_RXEOL | 1357 AR5K_INT_RXORN | AR5K_INT_TXDESC | AR5K_INT_TXEOL | 1358 AR5K_INT_FATAL | AR5K_INT_GLOBAL; 1359 ret = ath5k_reset(sc, NULL); 1360 if (ret) 1361 goto done; 1362 1363 ath5k_rfkill_hw_start(ah); 1364 1365 /* 1366 * Reset the key cache since some parts do not reset the 1367 * contents on initial power up or resume from suspend. 1368 */ 1369 for (i = 0; i < AR5K_KEYTABLE_SIZE; i++) 1370 ath5k_hw_reset_key(ah, i); 1371 1372 /* Set ack to be sent at low bit-rates */ 1373 ath5k_hw_set_ack_bitrate_high(ah, 0); 1374 1375 ret = 0; 1376 done: 1377 mb(); 1378 return ret; 1379 } 1380 1381 static int 1382 ath5k_stop_hw(struct ath5k_softc *sc) 1383 { 1384 struct ath5k_hw *ah = sc->ah; 1385 1386 /* 1387 * Shutdown the hardware and driver: 1388 * stop output from above 1389 * disable interrupts 1390 * turn off timers 1391 * turn off the radio 1392 * clear transmit machinery 1393 * clear receive machinery 1394 * drain and release tx queues 1395 * reclaim beacon resources 1396 * power down hardware 1397 * 1398 * Note that some of this work is not possible if the 1399 * hardware is gone (invalid). 1400 */ 1401 1402 if (!(sc->status & ATH_STAT_INVALID)) { 1403 ath5k_hw_set_imr(ah, 0); 1404 } 1405 ath5k_txq_cleanup(sc); 1406 if (!(sc->status & ATH_STAT_INVALID)) { 1407 ath5k_rx_stop(sc); 1408 ath5k_hw_phy_disable(ah); 1409 } else 1410 sc->rxlink = NULL; 1411 1412 ath5k_rfkill_hw_stop(sc->ah); 1413 1414 return 0; 1415 } 1416 1417 static void 1418 ath5k_poll(struct net80211_device *dev) 1419 { 1420 struct ath5k_softc *sc = dev->priv; 1421 struct ath5k_hw *ah = sc->ah; 1422 enum ath5k_int status; 1423 unsigned int counter = 1000; 1424 1425 if (currticks() - sc->last_calib_ticks > 1426 ATH5K_CALIB_INTERVAL * ticks_per_sec()) { 1427 ath5k_calibrate(sc); 1428 sc->last_calib_ticks = currticks(); 1429 } 1430 1431 if ((sc->status & ATH_STAT_INVALID) || 1432 (sc->irq_ena && !ath5k_hw_is_intr_pending(ah))) 1433 return; 1434 1435 do { 1436 ath5k_hw_get_isr(ah, &status); /* NB: clears IRQ too */ 1437 DBGP("ath5k: status %#x/%#x\n", status, sc->imask); 1438 if (status & AR5K_INT_FATAL) { 1439 /* 1440 * Fatal errors are unrecoverable. 1441 * Typically these are caused by DMA errors. 1442 */ 1443 DBG("ath5k: fatal error, resetting\n"); 1444 ath5k_reset_wake(sc); 1445 } else if (status & AR5K_INT_RXORN) { 1446 DBG("ath5k: rx overrun, resetting\n"); 1447 ath5k_reset_wake(sc); 1448 } else { 1449 if (status & AR5K_INT_RXEOL) { 1450 /* 1451 * NB: the hardware should re-read the link when 1452 * RXE bit is written, but it doesn't work at 1453 * least on older hardware revs. 1454 */ 1455 DBG("ath5k: rx EOL\n"); 1456 sc->rxlink = NULL; 1457 } 1458 if (status & AR5K_INT_TXURN) { 1459 /* bump tx trigger level */ 1460 DBG("ath5k: tx underrun\n"); 1461 ath5k_hw_update_tx_triglevel(ah, 1); 1462 } 1463 if (status & (AR5K_INT_RXOK | AR5K_INT_RXERR)) 1464 ath5k_handle_rx(sc); 1465 if (status & (AR5K_INT_TXOK | AR5K_INT_TXDESC 1466 | AR5K_INT_TXERR | AR5K_INT_TXEOL)) 1467 ath5k_handle_tx(sc); 1468 } 1469 } while (ath5k_hw_is_intr_pending(ah) && counter-- > 0); 1470 1471 if (!counter) 1472 DBG("ath5k: too many interrupts, giving up for now\n"); 1473 } 1474 1475 /* 1476 * Periodically recalibrate the PHY to account 1477 * for temperature/environment changes. 1478 */ 1479 static void 1480 ath5k_calibrate(struct ath5k_softc *sc) 1481 { 1482 struct ath5k_hw *ah = sc->ah; 1483 1484 if (ath5k_hw_gainf_calibrate(ah) == AR5K_RFGAIN_NEED_CHANGE) { 1485 /* 1486 * Rfgain is out of bounds, reset the chip 1487 * to load new gain values. 1488 */ 1489 DBG("ath5k: resetting for calibration\n"); 1490 ath5k_reset_wake(sc); 1491 } 1492 if (ath5k_hw_phy_calibrate(ah, sc->curchan)) 1493 DBG("ath5k: calibration of channel %d failed\n", 1494 sc->curchan->channel_nr); 1495 } 1496 1497 1498 /********************\ 1499 * Net80211 functions * 1500 \********************/ 1501 1502 static int 1503 ath5k_tx(struct net80211_device *dev, struct io_buffer *iob) 1504 { 1505 struct ath5k_softc *sc = dev->priv; 1506 struct ath5k_buf *bf; 1507 int rc; 1508 1509 /* 1510 * The hardware expects the header padded to 4 byte boundaries. 1511 * gPXE only ever sends 24-byte headers, so no action necessary. 1512 */ 1513 1514 if (list_empty(&sc->txbuf)) { 1515 DBG("ath5k: dropping packet because no tx bufs available\n"); 1516 return -ENOBUFS; 1517 } 1518 1519 bf = list_entry(sc->txbuf.next, struct ath5k_buf, list); 1520 list_del(&bf->list); 1521 sc->txbuf_len--; 1522 1523 bf->iob = iob; 1524 1525 if ((rc = ath5k_txbuf_setup(sc, bf)) != 0) { 1526 bf->iob = NULL; 1527 list_add_tail(&bf->list, &sc->txbuf); 1528 sc->txbuf_len++; 1529 return rc; 1530 } 1531 return 0; 1532 } 1533 1534 /* 1535 * Reset the hardware. If chan is not NULL, then also pause rx/tx 1536 * and change to the given channel. 1537 */ 1538 static int 1539 ath5k_reset(struct ath5k_softc *sc, struct net80211_channel *chan) 1540 { 1541 struct ath5k_hw *ah = sc->ah; 1542 int ret; 1543 1544 if (chan) { 1545 ath5k_hw_set_imr(ah, 0); 1546 ath5k_txq_cleanup(sc); 1547 ath5k_rx_stop(sc); 1548 1549 sc->curchan = chan; 1550 sc->curband = chan->band; 1551 } 1552 1553 ret = ath5k_hw_reset(ah, sc->curchan, 1); 1554 if (ret) { 1555 DBG("ath5k: can't reset hardware: %s\n", strerror(ret)); 1556 return ret; 1557 } 1558 1559 ret = ath5k_rx_start(sc); 1560 if (ret) { 1561 DBG("ath5k: can't start rx logic: %s\n", strerror(ret)); 1562 return ret; 1563 } 1564 1565 /* 1566 * Change channels and update the h/w rate map if we're switching; 1567 * e.g. 11a to 11b/g. 1568 * 1569 * We may be doing a reset in response to an ioctl that changes the 1570 * channel so update any state that might change as a result. 1571 * 1572 * XXX needed? 1573 */ 1574 /* ath5k_chan_change(sc, c); */ 1575 1576 /* Reenable interrupts if necessary */ 1577 ath5k_irq(sc->dev, sc->irq_ena); 1578 1579 return 0; 1580 } 1581 1582 static int ath5k_reset_wake(struct ath5k_softc *sc) 1583 { 1584 return ath5k_reset(sc, sc->curchan); 1585 } 1586 1587 static int ath5k_start(struct net80211_device *dev) 1588 { 1589 struct ath5k_softc *sc = dev->priv; 1590 int ret; 1591 1592 if ((ret = ath5k_init(sc)) != 0) 1593 return ret; 1594 1595 sc->assoc = 0; 1596 ath5k_configure_filter(sc); 1597 ath5k_hw_set_lladdr(sc->ah, dev->netdev->ll_addr); 1598 1599 return 0; 1600 } 1601 1602 static void ath5k_stop(struct net80211_device *dev) 1603 { 1604 struct ath5k_softc *sc = dev->priv; 1605 u8 mac[ETH_ALEN] = {}; 1606 1607 ath5k_hw_set_lladdr(sc->ah, mac); 1608 1609 ath5k_stop_hw(sc); 1610 } 1611 1612 static int 1613 ath5k_config(struct net80211_device *dev, int changed) 1614 { 1615 struct ath5k_softc *sc = dev->priv; 1616 struct ath5k_hw *ah = sc->ah; 1617 struct net80211_channel *chan = &dev->channels[dev->channel]; 1618 int ret; 1619 1620 if (changed & NET80211_CFG_CHANNEL) { 1621 sc->power_level = chan->maxpower; 1622 if ((ret = ath5k_chan_set(sc, chan)) != 0) 1623 return ret; 1624 } 1625 1626 if ((changed & NET80211_CFG_RATE) || 1627 (changed & NET80211_CFG_PHY_PARAMS)) { 1628 int spmbl = ATH5K_SPMBL_NO; 1629 u16 rate = dev->rates[dev->rate]; 1630 u16 slowrate = dev->rates[dev->rtscts_rate]; 1631 int i; 1632 1633 if (dev->phy_flags & NET80211_PHY_USE_SHORT_PREAMBLE) 1634 spmbl = ATH5K_SPMBL_YES; 1635 1636 for (i = 0; i < ATH5K_NR_RATES; i++) { 1637 if (ath5k_rates[i].bitrate == rate && 1638 (ath5k_rates[i].short_pmbl & spmbl)) 1639 sc->hw_rate = ath5k_rates[i].hw_code; 1640 1641 if (ath5k_rates[i].bitrate == slowrate && 1642 (ath5k_rates[i].short_pmbl & spmbl)) 1643 sc->hw_rtscts_rate = ath5k_rates[i].hw_code; 1644 } 1645 } 1646 1647 if (changed & NET80211_CFG_ASSOC) { 1648 sc->assoc = !!(dev->state & NET80211_ASSOCIATED); 1649 if (sc->assoc) { 1650 memcpy(ah->ah_bssid, dev->bssid, ETH_ALEN); 1651 } else { 1652 memset(ah->ah_bssid, 0xff, ETH_ALEN); 1653 } 1654 ath5k_hw_set_associd(ah, ah->ah_bssid, 0); 1655 } 1656 1657 return 0; 1658 } 1659 1660 /* 1661 * o always accept unicast, broadcast, and multicast traffic 1662 * o multicast traffic for all BSSIDs will be enabled if mac80211 1663 * says it should be 1664 * o maintain current state of phy ofdm or phy cck error reception. 1665 * If the hardware detects any of these type of errors then 1666 * ath5k_hw_get_rx_filter() will pass to us the respective 1667 * hardware filters to be able to receive these type of frames. 1668 * o probe request frames are accepted only when operating in 1669 * hostap, adhoc, or monitor modes 1670 * o enable promiscuous mode according to the interface state 1671 * o accept beacons: 1672 * - when operating in adhoc mode so the 802.11 layer creates 1673 * node table entries for peers, 1674 * - when operating in station mode for collecting rssi data when 1675 * the station is otherwise quiet, or 1676 * - when scanning 1677 */ 1678 static void ath5k_configure_filter(struct ath5k_softc *sc) 1679 { 1680 struct ath5k_hw *ah = sc->ah; 1681 u32 mfilt[2], rfilt; 1682 1683 /* Enable all multicast */ 1684 mfilt[0] = ~0; 1685 mfilt[1] = ~0; 1686 1687 /* Enable data frames and beacons */ 1688 rfilt = (AR5K_RX_FILTER_UCAST | AR5K_RX_FILTER_BCAST | 1689 AR5K_RX_FILTER_MCAST | AR5K_RX_FILTER_BEACON); 1690 1691 /* Set filters */ 1692 ath5k_hw_set_rx_filter(ah, rfilt); 1693 1694 /* Set multicast bits */ 1695 ath5k_hw_set_mcast_filter(ah, mfilt[0], mfilt[1]); 1696 1697 /* Set the cached hw filter flags, this will alter actually 1698 * be set in HW */ 1699 sc->filter_flags = rfilt; 1700 } 1701
