Annotation of sys/dev/ic/acx.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: acx.c,v 1.76 2007/08/05 22:40:38 claudio Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2006 Jonathan Gray <jsg@openbsd.org>
! 5: *
! 6: * Permission to use, copy, modify, and distribute this software for any
! 7: * purpose with or without fee is hereby granted, provided that the above
! 8: * copyright notice and this permission notice appear in all copies.
! 9: *
! 10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
! 11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
! 13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
! 16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 17: */
! 18:
! 19: /*
! 20: * Copyright (c) 2006 The DragonFly Project. All rights reserved.
! 21: *
! 22: * This code is derived from software contributed to The DragonFly Project
! 23: * by Sepherosa Ziehau <sepherosa@gmail.com>
! 24: *
! 25: * Redistribution and use in source and binary forms, with or without
! 26: * modification, are permitted provided that the following conditions
! 27: * are met:
! 28: *
! 29: * 1. Redistributions of source code must retain the above copyright
! 30: * notice, this list of conditions and the following disclaimer.
! 31: * 2. Redistributions in binary form must reproduce the above copyright
! 32: * notice, this list of conditions and the following disclaimer in
! 33: * the documentation and/or other materials provided with the
! 34: * distribution.
! 35: * 3. Neither the name of The DragonFly Project nor the names of its
! 36: * contributors may be used to endorse or promote products derived
! 37: * from this software without specific, prior written permission.
! 38: *
! 39: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
! 40: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
! 41: * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
! 42: * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
! 43: * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
! 44: * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
! 45: * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
! 46: * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
! 47: * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
! 48: * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
! 49: * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 50: * SUCH DAMAGE.
! 51: */
! 52:
! 53: /*
! 54: * Copyright (c) 2003-2004 wlan.kewl.org Project
! 55: * All rights reserved.
! 56: *
! 57: * Redistribution and use in source and binary forms, with or without
! 58: * modification, are permitted provided that the following conditions
! 59: * are met:
! 60: *
! 61: * 1. Redistributions of source code must retain the above copyright
! 62: * notice, this list of conditions and the following disclaimer.
! 63: *
! 64: * 2. Redistributions in binary form must reproduce the above copyright
! 65: * notice, this list of conditions and the following disclaimer in the
! 66: * documentation and/or other materials provided with the distribution.
! 67: *
! 68: * 3. All advertising materials mentioning features or use of this software
! 69: * must display the following acknowledgement:
! 70: *
! 71: * This product includes software developed by the wlan.kewl.org Project.
! 72: *
! 73: * 4. Neither the name of the wlan.kewl.org Project nor the names of its
! 74: * contributors may be used to endorse or promote products derived from
! 75: * this software without specific prior written permission.
! 76: *
! 77: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
! 78: * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
! 79: * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
! 80: * THE wlan.kewl.org Project BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
! 81: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
! 82: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
! 83: * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
! 84: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
! 85: * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
! 86: * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 87: */
! 88:
! 89: #include <sys/cdefs.h>
! 90: #include "bpfilter.h"
! 91:
! 92: #include <sys/param.h>
! 93: #include <sys/systm.h>
! 94: #include <sys/kernel.h>
! 95: #include <sys/malloc.h>
! 96: #include <sys/mbuf.h>
! 97: #include <sys/proc.h>
! 98: #include <sys/socket.h>
! 99: #include <sys/sockio.h>
! 100: #include <sys/ioctl.h>
! 101: #include <sys/types.h>
! 102:
! 103: #include <machine/bus.h>
! 104: #include <machine/endian.h>
! 105: #include <machine/intr.h>
! 106:
! 107: #include <net/if.h>
! 108: #include <net/if_arp.h>
! 109: #include <net/if_dl.h>
! 110: #include <net/if_media.h>
! 111: #include <net/if_types.h>
! 112:
! 113: #if NBPFILTER > 0
! 114: #include <net/bpf.h>
! 115: #endif
! 116:
! 117: #ifdef INET
! 118: #include <netinet/in.h>
! 119: #include <netinet/in_systm.h>
! 120: #include <netinet/in_var.h>
! 121: #include <netinet/if_ether.h>
! 122: #include <netinet/ip.h>
! 123: #endif
! 124:
! 125: #include <net80211/ieee80211_var.h>
! 126: #include <net80211/ieee80211_amrr.h>
! 127: #include <net80211/ieee80211_radiotap.h>
! 128:
! 129: #include <dev/pci/pcireg.h>
! 130: #include <dev/pci/pcivar.h>
! 131: #include <dev/pci/pcidevs.h>
! 132:
! 133: #include <dev/ic/acxvar.h>
! 134: #include <dev/ic/acxreg.h>
! 135:
! 136: #ifdef ACX_DEBUG
! 137: int acxdebug = 0;
! 138: #endif
! 139:
! 140: int acx_attach(struct acx_softc *);
! 141: int acx_detach(void *);
! 142:
! 143: int acx_init(struct ifnet *);
! 144: int acx_stop(struct acx_softc *);
! 145: void acx_init_info_reg(struct acx_softc *);
! 146: int acx_config(struct acx_softc *);
! 147: int acx_read_config(struct acx_softc *, struct acx_config *);
! 148: int acx_write_config(struct acx_softc *, struct acx_config *);
! 149: int acx_rx_config(struct acx_softc *);
! 150: int acx_set_crypt_keys(struct acx_softc *);
! 151: void acx_next_scan(void *);
! 152:
! 153: void acx_start(struct ifnet *);
! 154: void acx_watchdog(struct ifnet *);
! 155:
! 156: int acx_ioctl(struct ifnet *, u_long, caddr_t);
! 157:
! 158: int acx_intr(void *);
! 159: void acx_disable_intr(struct acx_softc *);
! 160: void acx_enable_intr(struct acx_softc *);
! 161: void acx_txeof(struct acx_softc *);
! 162: void acx_txerr(struct acx_softc *, uint8_t);
! 163: void acx_rxeof(struct acx_softc *);
! 164:
! 165: int acx_dma_alloc(struct acx_softc *);
! 166: void acx_dma_free(struct acx_softc *);
! 167: int acx_init_tx_ring(struct acx_softc *);
! 168: int acx_init_rx_ring(struct acx_softc *);
! 169: int acx_newbuf(struct acx_softc *, struct acx_rxbuf *, int);
! 170: int acx_encap(struct acx_softc *, struct acx_txbuf *,
! 171: struct mbuf *, struct ieee80211_node *, int);
! 172:
! 173: int acx_reset(struct acx_softc *);
! 174:
! 175: int acx_set_null_tmplt(struct acx_softc *);
! 176: int acx_set_probe_req_tmplt(struct acx_softc *, const char *, int);
! 177: int acx_set_probe_resp_tmplt(struct acx_softc *, struct ieee80211_node *);
! 178: int acx_beacon_locate(struct mbuf *, u_int8_t);
! 179: int acx_set_beacon_tmplt(struct acx_softc *, struct ieee80211_node *);
! 180:
! 181: int acx_read_eeprom(struct acx_softc *, uint32_t, uint8_t *);
! 182: int acx_read_phyreg(struct acx_softc *, uint32_t, uint8_t *);
! 183: const char * acx_get_rf(int);
! 184: int acx_get_maxrssi(int);
! 185:
! 186: int acx_load_firmware(struct acx_softc *, uint32_t,
! 187: const uint8_t *, int);
! 188: int acx_load_radio_firmware(struct acx_softc *, const char *);
! 189: int acx_load_base_firmware(struct acx_softc *, const char *);
! 190:
! 191: struct ieee80211_node
! 192: *acx_node_alloc(struct ieee80211com *);
! 193: int acx_newstate(struct ieee80211com *, enum ieee80211_state, int);
! 194:
! 195: void acx_init_cmd_reg(struct acx_softc *);
! 196: int acx_join_bss(struct acx_softc *, uint8_t, struct ieee80211_node *);
! 197: int acx_set_channel(struct acx_softc *, uint8_t);
! 198: int acx_init_radio(struct acx_softc *, uint32_t, uint32_t);
! 199:
! 200: void acx_iter_func(void *, struct ieee80211_node *);
! 201: void acx_amrr_timeout(void *);
! 202: void acx_newassoc(struct ieee80211com *, struct ieee80211_node *, int);
! 203:
! 204: static int acx_chanscan_rate = 5; /* 5 channels per second */
! 205: int acx_beacon_intvl = 100; /* 100 TU */
! 206:
! 207: /*
! 208: * Possible values for the second parameter of acx_join_bss()
! 209: */
! 210: #define ACX_MODE_ADHOC 0
! 211: #define ACX_MODE_UNUSED 1
! 212: #define ACX_MODE_STA 2
! 213: #define ACX_MODE_AP 3
! 214:
! 215: struct cfdriver acx_cd = {
! 216: NULL, "acx", DV_IFNET
! 217: };
! 218:
! 219: int
! 220: acx_attach(struct acx_softc *sc)
! 221: {
! 222: struct ieee80211com *ic = &sc->sc_ic;
! 223: struct ifnet *ifp = &sc->sc_ic.ic_if;
! 224: int i, error;
! 225:
! 226: ifp->if_softc = sc;
! 227:
! 228: /* Initialize channel scanning timer */
! 229: timeout_set(&sc->sc_chanscan_timer, acx_next_scan, sc);
! 230:
! 231: /* Allocate busdma stuffs */
! 232: error = acx_dma_alloc(sc);
! 233: if (error)
! 234: return (error);
! 235:
! 236: /* Reset Hardware */
! 237: error = acx_reset(sc);
! 238: if (error)
! 239: return (error);
! 240:
! 241: /* Disable interrupts before firmware is loaded */
! 242: acx_disable_intr(sc);
! 243:
! 244: /* Get radio type and form factor */
! 245: #define EEINFO_RETRY_MAX 50
! 246: for (i = 0; i < EEINFO_RETRY_MAX; ++i) {
! 247: uint16_t ee_info;
! 248:
! 249: ee_info = CSR_READ_2(sc, ACXREG_EEPROM_INFO);
! 250: if (ACX_EEINFO_HAS_RADIO_TYPE(ee_info)) {
! 251: sc->sc_form_factor = ACX_EEINFO_FORM_FACTOR(ee_info);
! 252: sc->sc_radio_type = ACX_EEINFO_RADIO_TYPE(ee_info);
! 253: break;
! 254: }
! 255: DELAY(10000);
! 256: }
! 257: if (i == EEINFO_RETRY_MAX)
! 258: return (ENXIO);
! 259: #undef EEINFO_RETRY_MAX
! 260:
! 261: printf("%s: %s, radio %s (0x%02x)", sc->sc_dev.dv_xname,
! 262: (sc->sc_flags & ACX_FLAG_ACX111) ? "ACX111" : "ACX100",
! 263: acx_get_rf(sc->sc_radio_type), sc->sc_radio_type);
! 264:
! 265: #ifdef DUMP_EEPROM
! 266: for (i = 0; i < 0x40; ++i) {
! 267: uint8_t val;
! 268:
! 269: error = acx_read_eeprom(sc, i, &val);
! 270: if (i % 10 == 0)
! 271: printf("\n");
! 272: printf("%02x ", val);
! 273: }
! 274: printf("\n");
! 275: #endif /* DUMP_EEPROM */
! 276:
! 277: /* Get EEPROM version */
! 278: error = acx_read_eeprom(sc, ACX_EE_VERSION_OFS, &sc->sc_eeprom_ver);
! 279: if (error)
! 280: return (error);
! 281:
! 282: printf(", EEPROM ver %u", sc->sc_eeprom_ver);
! 283:
! 284: ifp->if_softc = sc;
! 285: ifp->if_init = acx_init;
! 286: ifp->if_ioctl = acx_ioctl;
! 287: ifp->if_start = acx_start;
! 288: ifp->if_watchdog = acx_watchdog;
! 289: ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST;
! 290: strlcpy(ifp->if_xname, sc->sc_dev.dv_xname, IFNAMSIZ);
! 291: IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN);
! 292: IFQ_SET_READY(&ifp->if_snd);
! 293:
! 294: /* Set channels */
! 295: for (i = 1; i <= 14; ++i) {
! 296: ic->ic_channels[i].ic_freq =
! 297: ieee80211_ieee2mhz(i, IEEE80211_CHAN_2GHZ);
! 298: ic->ic_channels[i].ic_flags = sc->chip_chan_flags;
! 299: }
! 300:
! 301: ic->ic_opmode = IEEE80211_M_STA;
! 302: ic->ic_state = IEEE80211_S_INIT;
! 303:
! 304: /*
! 305: * NOTE: Don't overwrite ic_caps set by chip specific code
! 306: */
! 307: ic->ic_caps =
! 308: IEEE80211_C_WEP | /* WEP */
! 309: IEEE80211_C_IBSS | /* IBSS mode */
! 310: IEEE80211_C_MONITOR | /* Monitor mode */
! 311: IEEE80211_C_HOSTAP | /* Access Point */
! 312: IEEE80211_C_SHPREAMBLE; /* Short preamble */
! 313:
! 314: /* Get station id */
! 315: for (i = 0; i < IEEE80211_ADDR_LEN; ++i) {
! 316: error = acx_read_eeprom(sc, sc->chip_ee_eaddr_ofs - i,
! 317: &ic->ic_myaddr[i]);
! 318: }
! 319:
! 320: printf(", address %s\n", ether_sprintf(ic->ic_myaddr));
! 321:
! 322: if_attach(ifp);
! 323: ieee80211_ifattach(ifp);
! 324:
! 325: /* Override node alloc */
! 326: ic->ic_node_alloc = acx_node_alloc;
! 327: ic->ic_newassoc = acx_newassoc;
! 328:
! 329: /* Override newstate */
! 330: sc->sc_newstate = ic->ic_newstate;
! 331: ic->ic_newstate = acx_newstate;
! 332:
! 333: /* Set maximal rssi */
! 334: ic->ic_max_rssi = acx_get_maxrssi(sc->sc_radio_type);
! 335:
! 336: ieee80211_media_init(ifp, ieee80211_media_change,
! 337: ieee80211_media_status);
! 338:
! 339: /* AMRR rate control */
! 340: sc->amrr.amrr_min_success_threshold = 1;
! 341: sc->amrr.amrr_max_success_threshold = 15;
! 342: timeout_set(&sc->amrr_ch, acx_amrr_timeout, sc);
! 343:
! 344: sc->sc_long_retry_limit = 4;
! 345: sc->sc_short_retry_limit = 7;
! 346: sc->sc_msdu_lifetime = 4096;
! 347:
! 348: #if NBPFILTER > 0
! 349: bpfattach(&sc->sc_drvbpf, ifp, DLT_IEEE802_11_RADIO,
! 350: sizeof(struct ieee80211_frame) + 64);
! 351:
! 352: sc->sc_rxtap_len = sizeof(sc->sc_rxtapu);
! 353: sc->sc_rxtap.wr_ihdr.it_len = htole16(sc->sc_rxtap_len);
! 354: sc->sc_rxtap.wr_ihdr.it_present = htole32(ACX_RX_RADIOTAP_PRESENT);
! 355:
! 356: sc->sc_txtap_len = sizeof(sc->sc_txtapu);
! 357: sc->sc_txtap.wt_ihdr.it_len = htole16(sc->sc_txtap_len);
! 358: sc->sc_txtap.wt_ihdr.it_present = htole32(ACX_TX_RADIOTAP_PRESENT);
! 359: #endif
! 360:
! 361: return (0);
! 362: }
! 363:
! 364: int
! 365: acx_detach(void *xsc)
! 366: {
! 367: struct acx_softc *sc = xsc;
! 368: struct ieee80211com *ic = &sc->sc_ic;
! 369: struct ifnet *ifp = &ic->ic_if;
! 370:
! 371: acx_stop(sc);
! 372: ieee80211_ifdetach(ifp);
! 373: if_detach(ifp);
! 374:
! 375: acx_dma_free(sc);
! 376:
! 377: return (0);
! 378: }
! 379:
! 380: int
! 381: acx_init(struct ifnet *ifp)
! 382: {
! 383: struct acx_softc *sc = ifp->if_softc;
! 384: struct ieee80211com *ic = &sc->sc_ic;
! 385: char fname[] = "tiacx111c16";
! 386: int error, combined = 0;
! 387:
! 388: error = acx_stop(sc);
! 389: if (error)
! 390: return (EIO);
! 391:
! 392: /* enable card if possible */
! 393: if (sc->sc_enable != NULL)
! 394: (*sc->sc_enable)(sc);
! 395:
! 396: error = acx_init_tx_ring(sc);
! 397: if (error) {
! 398: printf("%s: can't initialize TX ring\n",
! 399: sc->sc_dev.dv_xname);
! 400: goto back;
! 401: }
! 402:
! 403: error = acx_init_rx_ring(sc);
! 404: if (error) {
! 405: printf("%s: can't initialize RX ring\n",
! 406: sc->sc_dev.dv_xname);
! 407: goto back;
! 408: }
! 409:
! 410: if (sc->sc_flags & ACX_FLAG_ACX111) {
! 411: snprintf(fname, sizeof(fname), "tiacx111c%02X",
! 412: sc->sc_radio_type);
! 413: error = acx_load_base_firmware(sc, fname);
! 414:
! 415: if (!error)
! 416: combined = 1;
! 417: }
! 418:
! 419: if (!combined) {
! 420: snprintf(fname, sizeof(fname), "tiacx%s",
! 421: (sc->sc_flags & ACX_FLAG_ACX111) ? "111" : "100");
! 422: error = acx_load_base_firmware(sc, fname);
! 423: }
! 424:
! 425: if (error)
! 426: goto back;
! 427:
! 428: /*
! 429: * Initialize command and information registers
! 430: * NOTE: This should be done after base firmware is loaded
! 431: */
! 432: acx_init_cmd_reg(sc);
! 433: acx_init_info_reg(sc);
! 434:
! 435: sc->sc_flags |= ACX_FLAG_FW_LOADED;
! 436:
! 437: if (!combined) {
! 438: snprintf(fname, sizeof(fname), "tiacx%sr%02X",
! 439: (sc->sc_flags & ACX_FLAG_ACX111) ? "111" : "100",
! 440: sc->sc_radio_type);
! 441: error = acx_load_radio_firmware(sc, fname);
! 442:
! 443: if (error)
! 444: goto back;
! 445: }
! 446:
! 447: error = sc->chip_init(sc);
! 448: if (error)
! 449: goto back;
! 450:
! 451: /* Get and set device various configuration */
! 452: error = acx_config(sc);
! 453: if (error)
! 454: goto back;
! 455:
! 456: /* Setup crypto stuffs */
! 457: if (sc->sc_ic.ic_flags & IEEE80211_F_WEPON) {
! 458: error = acx_set_crypt_keys(sc);
! 459: if (error)
! 460: goto back;
! 461: }
! 462:
! 463: /* Turn on power led */
! 464: CSR_CLRB_2(sc, ACXREG_GPIO_OUT, sc->chip_gpio_pled);
! 465:
! 466: acx_enable_intr(sc);
! 467:
! 468: ifp->if_flags |= IFF_RUNNING;
! 469: ifp->if_flags &= ~IFF_OACTIVE;
! 470:
! 471: if (ic->ic_opmode != IEEE80211_M_MONITOR)
! 472: /* start background scanning */
! 473: ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
! 474: else
! 475: /* in monitor mode change directly into run state */
! 476: ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
! 477:
! 478: back:
! 479: if (error)
! 480: acx_stop(sc);
! 481:
! 482: return (0);
! 483: }
! 484:
! 485: void
! 486: acx_init_info_reg(struct acx_softc *sc)
! 487: {
! 488: sc->sc_info = CSR_READ_4(sc, ACXREG_INFO_REG_OFFSET);
! 489: sc->sc_info_param = sc->sc_info + ACX_INFO_REG_SIZE;
! 490: }
! 491:
! 492: int
! 493: acx_set_crypt_keys(struct acx_softc *sc)
! 494: {
! 495: struct ieee80211com *ic = &sc->sc_ic;
! 496: struct acx_conf_wep_txkey wep_txkey;
! 497: int i, error, got_wk = 0;
! 498:
! 499: for (i = 0; i < IEEE80211_WEP_NKID; ++i) {
! 500: struct ieee80211_key *k = &ic->ic_nw_keys[i];
! 501:
! 502: if (k->k_len == 0)
! 503: continue;
! 504:
! 505: if (sc->chip_hw_crypt) {
! 506: error = sc->chip_set_wepkey(sc, k, i);
! 507: if (error)
! 508: return (error);
! 509: got_wk = 1;
! 510: }
! 511: }
! 512:
! 513: if (!got_wk)
! 514: return (0);
! 515:
! 516: /* Set current WEP key index */
! 517: wep_txkey.wep_txkey = ic->ic_wep_txkey;
! 518: if (acx_set_conf(sc, ACX_CONF_WEP_TXKEY, &wep_txkey,
! 519: sizeof(wep_txkey)) != 0) {
! 520: printf("%s: set WEP txkey failed\n", sc->sc_dev.dv_xname);
! 521: return (ENXIO);
! 522: }
! 523:
! 524: return (0);
! 525: }
! 526:
! 527: void
! 528: acx_next_scan(void *arg)
! 529: {
! 530: struct acx_softc *sc = arg;
! 531: struct ieee80211com *ic = &sc->sc_ic;
! 532: struct ifnet *ifp = &ic->ic_if;
! 533:
! 534: if (ic->ic_state == IEEE80211_S_SCAN)
! 535: ieee80211_next_scan(ifp);
! 536: }
! 537:
! 538: int
! 539: acx_stop(struct acx_softc *sc)
! 540: {
! 541: struct ieee80211com *ic = &sc->sc_ic;
! 542: struct ifnet *ifp = &ic->ic_if;
! 543: struct acx_buf_data *bd = &sc->sc_buf_data;
! 544: struct acx_ring_data *rd = &sc->sc_ring_data;
! 545: int i, error;
! 546:
! 547: sc->sc_firmware_ver = 0;
! 548: sc->sc_hardware_id = 0;
! 549:
! 550: /* Reset hardware */
! 551: error = acx_reset(sc);
! 552: if (error)
! 553: return (error);
! 554:
! 555: /* Firmware no longer functions after hardware reset */
! 556: sc->sc_flags &= ~ACX_FLAG_FW_LOADED;
! 557:
! 558: acx_disable_intr(sc);
! 559:
! 560: /* Stop backgroud scanning */
! 561: timeout_del(&sc->sc_chanscan_timer);
! 562:
! 563: /* Turn off power led */
! 564: CSR_SETB_2(sc, ACXREG_GPIO_OUT, sc->chip_gpio_pled);
! 565:
! 566: /* Free TX mbuf */
! 567: for (i = 0; i < ACX_TX_DESC_CNT; ++i) {
! 568: struct acx_txbuf *buf;
! 569: struct ieee80211_node *ni;
! 570:
! 571: buf = &bd->tx_buf[i];
! 572:
! 573: if (buf->tb_mbuf != NULL) {
! 574: bus_dmamap_unload(sc->sc_dmat, buf->tb_mbuf_dmamap);
! 575: m_freem(buf->tb_mbuf);
! 576: buf->tb_mbuf = NULL;
! 577: }
! 578:
! 579: ni = (struct ieee80211_node *)buf->tb_node;
! 580: if (ni != NULL)
! 581: ieee80211_release_node(ic, ni);
! 582: buf->tb_node = NULL;
! 583: }
! 584:
! 585: /* Clear TX host descriptors */
! 586: bzero(rd->tx_ring, ACX_TX_RING_SIZE);
! 587:
! 588: /* Free RX mbuf */
! 589: for (i = 0; i < ACX_RX_DESC_CNT; ++i) {
! 590: if (bd->rx_buf[i].rb_mbuf != NULL) {
! 591: bus_dmamap_unload(sc->sc_dmat,
! 592: bd->rx_buf[i].rb_mbuf_dmamap);
! 593: m_freem(bd->rx_buf[i].rb_mbuf);
! 594: bd->rx_buf[i].rb_mbuf = NULL;
! 595: }
! 596: }
! 597:
! 598: /* Clear RX host descriptors */
! 599: bzero(rd->rx_ring, ACX_RX_RING_SIZE);
! 600:
! 601: ifp->if_timer = 0;
! 602: ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
! 603: ieee80211_new_state(&sc->sc_ic, IEEE80211_S_INIT, -1);
! 604:
! 605: /* disable card if possible */
! 606: if (sc->sc_disable != NULL)
! 607: (*sc->sc_disable)(sc);
! 608:
! 609: return (0);
! 610: }
! 611:
! 612: int
! 613: acx_config(struct acx_softc *sc)
! 614: {
! 615: struct acx_config conf;
! 616: int error;
! 617:
! 618: error = acx_read_config(sc, &conf);
! 619: if (error)
! 620: return (error);
! 621:
! 622: error = acx_write_config(sc, &conf);
! 623: if (error)
! 624: return (error);
! 625:
! 626: error = acx_rx_config(sc);
! 627: if (error)
! 628: return (error);
! 629:
! 630: if (acx_set_probe_req_tmplt(sc, "", 0) != 0) {
! 631: printf("%s: can't set probe req template "
! 632: "(empty ssid)\n", sc->sc_dev.dv_xname);
! 633: return (ENXIO);
! 634: }
! 635:
! 636: /* XXX for PM?? */
! 637: if (acx_set_null_tmplt(sc) != 0) {
! 638: printf("%s: can't set null data template\n",
! 639: sc->sc_dev.dv_xname);
! 640: return (ENXIO);
! 641: }
! 642:
! 643: return (0);
! 644: }
! 645:
! 646: int
! 647: acx_read_config(struct acx_softc *sc, struct acx_config *conf)
! 648: {
! 649: struct acx_conf_regdom reg_dom;
! 650: struct acx_conf_antenna ant;
! 651: struct acx_conf_fwrev fw_rev;
! 652: uint32_t fw_rev_no;
! 653: uint8_t sen;
! 654: int error;
! 655:
! 656: /* Get region domain */
! 657: if (acx_get_conf(sc, ACX_CONF_REGDOM, ®_dom, sizeof(reg_dom)) != 0) {
! 658: printf("%s: can't get region domain\n", sc->sc_dev.dv_xname);
! 659: return (ENXIO);
! 660: }
! 661: conf->regdom = reg_dom.regdom;
! 662: DPRINTF(("%s: regdom %02x\n", sc->sc_dev.dv_xname, reg_dom.regdom));
! 663:
! 664: /* Get antenna */
! 665: if (acx_get_conf(sc, ACX_CONF_ANTENNA, &ant, sizeof(ant)) != 0) {
! 666: printf("%s: can't get antenna\n", sc->sc_dev.dv_xname);
! 667: return (ENXIO);
! 668: }
! 669: conf->antenna = ant.antenna;
! 670: DPRINTF(("%s: antenna %02x\n", sc->sc_dev.dv_xname, ant.antenna));
! 671:
! 672: /* Get sensitivity XXX not used */
! 673: if (sc->sc_radio_type == ACX_RADIO_TYPE_MAXIM ||
! 674: sc->sc_radio_type == ACX_RADIO_TYPE_RFMD ||
! 675: sc->sc_radio_type == ACX_RADIO_TYPE_RALINK) {
! 676: error = acx_read_phyreg(sc, ACXRV_PHYREG_SENSITIVITY, &sen);
! 677: if (error) {
! 678: printf("%s: can't get sensitivity\n",
! 679: sc->sc_dev.dv_xname);
! 680: return (error);
! 681: }
! 682: } else
! 683: sen = 0;
! 684: DPRINTF(("%s: sensitivity %02x\n", sc->sc_dev.dv_xname, sen));
! 685:
! 686: /* Get firmware revision */
! 687: if (acx_get_conf(sc, ACX_CONF_FWREV, &fw_rev, sizeof(fw_rev)) != 0) {
! 688: printf("%s: can't get firmware revision\n",
! 689: sc->sc_dev.dv_xname);
! 690: return (ENXIO);
! 691: }
! 692:
! 693: if (strncmp(fw_rev.fw_rev, "Rev ", 4) != 0) {
! 694: printf("%s: strange revision string -- %s\n",
! 695: sc->sc_dev.dv_xname, fw_rev.fw_rev);
! 696: fw_rev_no = 0x01090407;
! 697: } else {
! 698: /*
! 699: * 01234
! 700: * "Rev xx.xx.xx.xx"
! 701: * ^ Start from here
! 702: */
! 703: fw_rev_no = fw_rev.fw_rev[0] << 24;
! 704: fw_rev_no |= fw_rev.fw_rev[1] << 16;
! 705: fw_rev_no |= fw_rev.fw_rev[2] << 8;
! 706: fw_rev_no |= fw_rev.fw_rev[3];
! 707: }
! 708: sc->sc_firmware_ver = fw_rev_no;
! 709: sc->sc_hardware_id = letoh32(fw_rev.hw_id);
! 710: DPRINTF(("%s: fw rev %08x, hw id %08x\n",
! 711: sc->sc_dev.dv_xname, sc->sc_firmware_ver, sc->sc_hardware_id));
! 712:
! 713: if (sc->chip_read_config != NULL) {
! 714: error = sc->chip_read_config(sc, conf);
! 715: if (error)
! 716: return (error);
! 717: }
! 718:
! 719: return (0);
! 720: }
! 721:
! 722: int
! 723: acx_write_config(struct acx_softc *sc, struct acx_config *conf)
! 724: {
! 725: struct acx_conf_nretry_short sretry;
! 726: struct acx_conf_nretry_long lretry;
! 727: struct acx_conf_msdu_lifetime msdu_lifetime;
! 728: struct acx_conf_rate_fallback rate_fb;
! 729: struct acx_conf_antenna ant;
! 730: struct acx_conf_regdom reg_dom;
! 731: struct ifnet *ifp = &sc->sc_ic.ic_if;
! 732: int error;
! 733:
! 734: /* Set number of long/short retry */
! 735: sretry.nretry = sc->sc_short_retry_limit;
! 736: if (acx_set_conf(sc, ACX_CONF_NRETRY_SHORT, &sretry,
! 737: sizeof(sretry)) != 0) {
! 738: printf("%s: can't set short retry limit\n", ifp->if_xname);
! 739: return (ENXIO);
! 740: }
! 741:
! 742: lretry.nretry = sc->sc_long_retry_limit;
! 743: if (acx_set_conf(sc, ACX_CONF_NRETRY_LONG, &lretry,
! 744: sizeof(lretry)) != 0) {
! 745: printf("%s: can't set long retry limit\n", ifp->if_xname);
! 746: return (ENXIO);
! 747: }
! 748:
! 749: /* Set MSDU lifetime */
! 750: msdu_lifetime.lifetime = htole32(sc->sc_msdu_lifetime);
! 751: if (acx_set_conf(sc, ACX_CONF_MSDU_LIFETIME, &msdu_lifetime,
! 752: sizeof(msdu_lifetime)) != 0) {
! 753: printf("%s: can't set MSDU lifetime\n", ifp->if_xname);
! 754: return (ENXIO);
! 755: }
! 756:
! 757: /* Enable rate fallback */
! 758: rate_fb.ratefb_enable = 1;
! 759: if (acx_set_conf(sc, ACX_CONF_RATE_FALLBACK, &rate_fb,
! 760: sizeof(rate_fb)) != 0) {
! 761: printf("%s: can't enable rate fallback\n", ifp->if_xname);
! 762: return (ENXIO);
! 763: }
! 764:
! 765: /* Set antenna */
! 766: ant.antenna = conf->antenna;
! 767: if (acx_set_conf(sc, ACX_CONF_ANTENNA, &ant, sizeof(ant)) != 0) {
! 768: printf("%s: can't set antenna\n", ifp->if_xname);
! 769: return (ENXIO);
! 770: }
! 771:
! 772: /* Set region domain */
! 773: reg_dom.regdom = conf->regdom;
! 774: if (acx_set_conf(sc, ACX_CONF_REGDOM, ®_dom, sizeof(reg_dom)) != 0) {
! 775: printf("%s: can't set region domain\n", ifp->if_xname);
! 776: return (ENXIO);
! 777: }
! 778:
! 779: if (sc->chip_write_config != NULL) {
! 780: error = sc->chip_write_config(sc, conf);
! 781: if (error)
! 782: return (error);
! 783: }
! 784:
! 785: return (0);
! 786: }
! 787:
! 788: int
! 789: acx_rx_config(struct acx_softc *sc)
! 790: {
! 791: struct ieee80211com *ic = &sc->sc_ic;
! 792: struct acx_conf_rxopt rx_opt;
! 793:
! 794: /* tell the RX receiver what frames we want to have */
! 795: rx_opt.opt1 = htole16(RXOPT1_INCL_RXBUF_HDR);
! 796: rx_opt.opt2 = htole16(
! 797: RXOPT2_RECV_ASSOC_REQ |
! 798: RXOPT2_RECV_AUTH |
! 799: RXOPT2_RECV_BEACON |
! 800: RXOPT2_RECV_CF |
! 801: RXOPT2_RECV_CTRL |
! 802: RXOPT2_RECV_DATA |
! 803: RXOPT2_RECV_MGMT |
! 804: RXOPT2_RECV_PROBE_REQ |
! 805: RXOPT2_RECV_PROBE_RESP |
! 806: RXOPT2_RECV_OTHER);
! 807:
! 808: /* in monitor mode go promiscuous */
! 809: if (ic->ic_opmode == IEEE80211_M_MONITOR) {
! 810: rx_opt.opt1 |= RXOPT1_PROMISC;
! 811: rx_opt.opt2 |= RXOPT2_RECV_BROKEN | RXOPT2_RECV_ACK;
! 812: } else
! 813: rx_opt.opt1 |= RXOPT1_FILT_FDEST;
! 814:
! 815: /* finally set the RX options */
! 816: if (acx_set_conf(sc, ACX_CONF_RXOPT, &rx_opt, sizeof(rx_opt)) != 0) {
! 817: printf("%s: can not set RX options!\n", sc->sc_dev.dv_xname);
! 818: return (ENXIO);
! 819: }
! 820:
! 821: return (0);
! 822: }
! 823:
! 824: int
! 825: acx_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
! 826: {
! 827: struct acx_softc *sc = ifp->if_softc;
! 828: struct ieee80211com *ic = &sc->sc_ic;
! 829: struct ifaddr *ifa;
! 830: struct ifreq *ifr;
! 831: int s, error = 0;
! 832: uint8_t chan;
! 833:
! 834: s = splnet();
! 835:
! 836: switch (cmd) {
! 837: case SIOCSIFADDR:
! 838: ifa = (struct ifaddr *)data;
! 839: ifp->if_flags |= IFF_UP;
! 840: #ifdef INET
! 841: if (ifa->ifa_addr->sa_family == AF_INET)
! 842: arp_ifinit(&ic->ic_ac, ifa);
! 843: #endif
! 844: /* FALLTHROUGH */
! 845: case SIOCSIFFLAGS:
! 846: if (ifp->if_flags & IFF_UP) {
! 847: if ((ifp->if_flags & IFF_RUNNING) == 0)
! 848: acx_init(ifp);
! 849: } else {
! 850: if (ifp->if_flags & IFF_RUNNING)
! 851: acx_stop(sc);
! 852: }
! 853: break;
! 854: case SIOCADDMULTI:
! 855: case SIOCDELMULTI:
! 856: ifr = (struct ifreq *)data;
! 857: error = (cmd == SIOCADDMULTI) ?
! 858: ether_addmulti(ifr, &ic->ic_ac) :
! 859: ether_delmulti(ifr, &ic->ic_ac);
! 860:
! 861: if (error == ENETRESET)
! 862: error = 0;
! 863: break;
! 864: case SIOCS80211CHANNEL:
! 865: /* allow fast channel switching in monitor mode */
! 866: error = ieee80211_ioctl(ifp, cmd, data);
! 867: if (error == ENETRESET &&
! 868: ic->ic_opmode == IEEE80211_M_MONITOR) {
! 869: if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) ==
! 870: (IFF_UP | IFF_RUNNING)) {
! 871: ic->ic_bss->ni_chan = ic->ic_ibss_chan;
! 872: chan = ieee80211_chan2ieee(ic,
! 873: ic->ic_bss->ni_chan);
! 874: (void)acx_set_channel(sc, chan);
! 875: }
! 876: error = 0;
! 877: }
! 878: break;
! 879: default:
! 880: error = ieee80211_ioctl(ifp, cmd, data);
! 881: break;
! 882: }
! 883:
! 884: if (error == ENETRESET) {
! 885: if ((ifp->if_flags & (IFF_RUNNING | IFF_UP)) ==
! 886: (IFF_RUNNING | IFF_UP))
! 887: acx_init(ifp);
! 888: error = 0;
! 889: }
! 890:
! 891: splx(s);
! 892:
! 893: return (error);
! 894: }
! 895:
! 896: void
! 897: acx_start(struct ifnet *ifp)
! 898: {
! 899: struct acx_softc *sc = ifp->if_softc;
! 900: struct ieee80211com *ic = &sc->sc_ic;
! 901: struct acx_buf_data *bd = &sc->sc_buf_data;
! 902: struct acx_txbuf *buf;
! 903: int trans, idx;
! 904:
! 905: if ((sc->sc_flags & ACX_FLAG_FW_LOADED) == 0 ||
! 906: (ifp->if_flags & IFF_RUNNING) == 0 ||
! 907: (ifp->if_flags & IFF_OACTIVE))
! 908: return;
! 909:
! 910: /*
! 911: * NOTE:
! 912: * We can't start from a random position that TX descriptor
! 913: * is free, since hardware will be confused by that.
! 914: * We have to follow the order of the TX ring.
! 915: */
! 916: idx = bd->tx_free_start;
! 917: trans = 0;
! 918: for (buf = &bd->tx_buf[idx]; buf->tb_mbuf == NULL;
! 919: buf = &bd->tx_buf[idx]) {
! 920: struct ieee80211_frame *wh;
! 921: struct ieee80211_node *ni = NULL;
! 922: struct mbuf *m;
! 923: int rate;
! 924:
! 925: IF_DEQUEUE(&ic->ic_mgtq, m);
! 926: if (m != NULL) {
! 927: ni = (struct ieee80211_node *)m->m_pkthdr.rcvif;
! 928: m->m_pkthdr.rcvif = NULL;
! 929:
! 930: /*
! 931: * probe response mgmt frames are handled by the
! 932: * firmware already. So, don't send them twice.
! 933: */
! 934: wh = mtod(m, struct ieee80211_frame *);
! 935: if ((wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) ==
! 936: IEEE80211_FC0_SUBTYPE_PROBE_RESP) {
! 937: if (ni != NULL)
! 938: ieee80211_release_node(ic, ni);
! 939: m_freem(m);
! 940: continue;
! 941: }
! 942:
! 943: /*
! 944: * mgmt frames are sent at the lowest available
! 945: * bit-rate.
! 946: */
! 947: rate = ni->ni_rates.rs_rates[0];
! 948: rate &= IEEE80211_RATE_VAL;
! 949: } else if (!IFQ_IS_EMPTY(&ifp->if_snd)) {
! 950: struct ether_header *eh;
! 951:
! 952: IFQ_DEQUEUE(&ifp->if_snd, m);
! 953: if (m == NULL)
! 954: break;
! 955:
! 956: if (ic->ic_state != IEEE80211_S_RUN) {
! 957: DPRINTF(("%s: data packet dropped due to "
! 958: "not RUN. Current state %d\n",
! 959: ifp->if_xname, ic->ic_state));
! 960: m_freem(m);
! 961: break;
! 962: }
! 963:
! 964: if (m->m_len < sizeof(struct ether_header)) {
! 965: m = m_pullup(m, sizeof(struct ether_header));
! 966: if (m == NULL) {
! 967: ifp->if_oerrors++;
! 968: continue;
! 969: }
! 970: }
! 971: eh = mtod(m, struct ether_header *);
! 972:
! 973: /* TODO power save */
! 974:
! 975: #if NBPFILTER > 0
! 976: if (ifp->if_bpf != NULL)
! 977: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_OUT);
! 978: #endif
! 979:
! 980: if ((m = ieee80211_encap(ifp, m, &ni)) == NULL) {
! 981: ifp->if_oerrors++;
! 982: continue;
! 983: }
! 984:
! 985: #if NBPFILTER > 0
! 986: if (ic->ic_rawbpf != NULL)
! 987: bpf_mtap(ic->ic_rawbpf, m, BPF_DIRECTION_OUT);
! 988: #endif
! 989:
! 990: if (ic->ic_fixed_rate != -1) {
! 991: rate = ic->ic_sup_rates[ic->ic_curmode].
! 992: rs_rates[ic->ic_fixed_rate];
! 993: } else
! 994: rate = ni->ni_rates.rs_rates[ni->ni_txrate];
! 995: rate &= IEEE80211_RATE_VAL;
! 996: } else
! 997: break;
! 998:
! 999: wh = mtod(m, struct ieee80211_frame *);
! 1000: if ((wh->i_fc[1] & IEEE80211_FC1_WEP) && !sc->chip_hw_crypt) {
! 1001: m = ieee80211_wep_crypt(ifp, m, 1);
! 1002: if (m == NULL) {
! 1003: ieee80211_release_node(ic, ni);
! 1004: m_freem(m);
! 1005: ifp->if_oerrors++;
! 1006: continue;
! 1007: }
! 1008: }
! 1009:
! 1010: #if NBPFILTER > 0
! 1011: if (sc->sc_drvbpf != NULL) {
! 1012: struct mbuf mb;
! 1013: struct acx_tx_radiotap_hdr *tap = &sc->sc_txtap;
! 1014:
! 1015: tap->wt_flags = 0;
! 1016: tap->wt_rate = rate;
! 1017: tap->wt_chan_freq =
! 1018: htole16(ic->ic_bss->ni_chan->ic_freq);
! 1019: tap->wt_chan_flags =
! 1020: htole16(ic->ic_bss->ni_chan->ic_flags);
! 1021:
! 1022: mb.m_data = (caddr_t)tap;
! 1023: mb.m_len = sc->sc_txtap_len;
! 1024: mb.m_next = m;
! 1025: mb.m_nextpkt = NULL;
! 1026: mb.m_type = 0;
! 1027: mb.m_flags = 0;
! 1028: bpf_mtap(sc->sc_drvbpf, &mb, BPF_DIRECTION_OUT);
! 1029: }
! 1030: #endif
! 1031:
! 1032: if (acx_encap(sc, buf, m, ni, rate) != 0) {
! 1033: /*
! 1034: * NOTE: `m' will be freed in acx_encap()
! 1035: * if we reach here.
! 1036: */
! 1037: if (ni != NULL)
! 1038: ieee80211_release_node(ic, ni);
! 1039: ifp->if_oerrors++;
! 1040: continue;
! 1041: }
! 1042:
! 1043: /*
! 1044: * NOTE:
! 1045: * 1) `m' should not be touched after acx_encap()
! 1046: * 2) `node' will be used to do TX rate control during
! 1047: * acx_txeof(), so it is not freed here. acx_txeof()
! 1048: * will free it for us
! 1049: */
! 1050: trans = 1;
! 1051: bd->tx_used_count++;
! 1052: idx = (idx + 1) % ACX_TX_DESC_CNT;
! 1053: }
! 1054: bd->tx_free_start = idx;
! 1055:
! 1056: if (bd->tx_used_count == ACX_TX_DESC_CNT)
! 1057: ifp->if_flags |= IFF_OACTIVE;
! 1058:
! 1059: if (trans && ifp->if_timer == 0)
! 1060: ifp->if_timer = 5;
! 1061: sc->sc_txtimer = 5;
! 1062: }
! 1063:
! 1064: void
! 1065: acx_watchdog(struct ifnet *ifp)
! 1066: {
! 1067: struct acx_softc *sc = ifp->if_softc;
! 1068:
! 1069: ifp->if_timer = 0;
! 1070:
! 1071: if ((ifp->if_flags & IFF_RUNNING) == 0)
! 1072: return;
! 1073:
! 1074: if (sc->sc_txtimer) {
! 1075: if (--sc->sc_txtimer == 0) {
! 1076: printf("%s: watchdog timeout\n", ifp->if_xname);
! 1077: acx_txeof(ifp->if_softc);
! 1078: ifp->if_oerrors++;
! 1079: return;
! 1080: }
! 1081: ifp->if_timer = 5;
! 1082: }
! 1083:
! 1084: ieee80211_watchdog(ifp);
! 1085: }
! 1086:
! 1087: int
! 1088: acx_intr(void *arg)
! 1089: {
! 1090: struct acx_softc *sc = arg;
! 1091: uint16_t intr_status;
! 1092:
! 1093: if ((sc->sc_flags & ACX_FLAG_FW_LOADED) == 0)
! 1094: return (0);
! 1095:
! 1096: intr_status = CSR_READ_2(sc, ACXREG_INTR_STATUS_CLR);
! 1097: if (intr_status == ACXRV_INTR_ALL) {
! 1098: /* not our interrupt */
! 1099: return (0);
! 1100: }
! 1101:
! 1102: intr_status &= sc->chip_intr_enable;
! 1103: if (intr_status == 0) {
! 1104: /* not interrupts we care about */
! 1105: return (1);
! 1106: }
! 1107:
! 1108: /* Acknowledge all interrupts */
! 1109: CSR_WRITE_2(sc, ACXREG_INTR_ACK, ACXRV_INTR_ALL);
! 1110:
! 1111: if (intr_status & ACXRV_INTR_TX_FINI)
! 1112: acx_txeof(sc);
! 1113:
! 1114: if (intr_status & ACXRV_INTR_RX_FINI)
! 1115: acx_rxeof(sc);
! 1116:
! 1117: return (1);
! 1118: }
! 1119:
! 1120: void
! 1121: acx_disable_intr(struct acx_softc *sc)
! 1122: {
! 1123: CSR_WRITE_2(sc, ACXREG_INTR_MASK, sc->chip_intr_disable);
! 1124: CSR_WRITE_2(sc, ACXREG_EVENT_MASK, 0);
! 1125: }
! 1126:
! 1127: void
! 1128: acx_enable_intr(struct acx_softc *sc)
! 1129: {
! 1130: /* Mask out interrupts that are not in the enable set */
! 1131: CSR_WRITE_2(sc, ACXREG_INTR_MASK, ~sc->chip_intr_enable);
! 1132: CSR_WRITE_2(sc, ACXREG_EVENT_MASK, ACXRV_EVENT_DISABLE);
! 1133: }
! 1134:
! 1135: void
! 1136: acx_txeof(struct acx_softc *sc)
! 1137: {
! 1138: struct acx_buf_data *bd;
! 1139: struct acx_txbuf *buf;
! 1140: struct ifnet *ifp;
! 1141: int idx;
! 1142:
! 1143: ifp = &sc->sc_ic.ic_if;
! 1144:
! 1145: bd = &sc->sc_buf_data;
! 1146: idx = bd->tx_used_start;
! 1147: for (buf = &bd->tx_buf[idx]; buf->tb_mbuf != NULL;
! 1148: buf = &bd->tx_buf[idx]) {
! 1149: uint8_t ctrl, error;
! 1150:
! 1151: ctrl = FW_TXDESC_GETFIELD_1(sc, buf, f_tx_ctrl);
! 1152: if ((ctrl & (DESC_CTRL_HOSTOWN | DESC_CTRL_ACXDONE)) !=
! 1153: (DESC_CTRL_HOSTOWN | DESC_CTRL_ACXDONE))
! 1154: break;
! 1155:
! 1156: bus_dmamap_unload(sc->sc_dmat, buf->tb_mbuf_dmamap);
! 1157: m_freem(buf->tb_mbuf);
! 1158: buf->tb_mbuf = NULL;
! 1159:
! 1160: error = FW_TXDESC_GETFIELD_1(sc, buf, f_tx_error);
! 1161: if (error) {
! 1162: acx_txerr(sc, error);
! 1163: ifp->if_oerrors++;
! 1164: } else
! 1165: ifp->if_opackets++;
! 1166:
! 1167: /* Update rate control statistics for the node */
! 1168: if (buf->tb_node != NULL) {
! 1169: struct ieee80211com *ic;
! 1170: struct ieee80211_node *ni;
! 1171: struct acx_node *wn;
! 1172: int ntries;
! 1173:
! 1174: ic = &sc->sc_ic;
! 1175: ni = (struct ieee80211_node *)buf->tb_node;
! 1176: wn = (struct acx_node *)ni;
! 1177: ntries = FW_TXDESC_GETFIELD_1(sc, buf, f_tx_rts_fail) +
! 1178: FW_TXDESC_GETFIELD_1(sc, buf, f_tx_ack_fail);
! 1179:
! 1180: wn->amn.amn_txcnt++;
! 1181: if (ntries > 0) {
! 1182: DPRINTFN(2, ("%s: tx intr ntries %d\n",
! 1183: sc->sc_dev.dv_xname, ntries));
! 1184: wn->amn.amn_retrycnt++;
! 1185: }
! 1186:
! 1187: ieee80211_release_node(ic, ni);
! 1188: buf->tb_node = NULL;
! 1189: }
! 1190:
! 1191: FW_TXDESC_SETFIELD_1(sc, buf, f_tx_ctrl, DESC_CTRL_HOSTOWN);
! 1192:
! 1193: bd->tx_used_count--;
! 1194:
! 1195: idx = (idx + 1) % ACX_TX_DESC_CNT;
! 1196: }
! 1197: bd->tx_used_start = idx;
! 1198:
! 1199: ifp->if_timer = bd->tx_used_count == 0 ? 0 : 5;
! 1200: sc->sc_txtimer = 0;
! 1201:
! 1202: if (bd->tx_used_count != ACX_TX_DESC_CNT) {
! 1203: ifp->if_flags &= ~IFF_OACTIVE;
! 1204: acx_start(ifp);
! 1205: }
! 1206: }
! 1207:
! 1208: void
! 1209: acx_txerr(struct acx_softc *sc, uint8_t err)
! 1210: {
! 1211: struct ifnet *ifp = &sc->sc_ic.ic_if;
! 1212: struct acx_stats *stats = &sc->sc_stats;
! 1213:
! 1214: if (err == DESC_ERR_EXCESSIVE_RETRY) {
! 1215: /*
! 1216: * This a common error (see comment below),
! 1217: * so print it using DPRINTF().
! 1218: */
! 1219: DPRINTF(("%s: TX failed -- excessive retry\n",
! 1220: sc->sc_dev.dv_xname));
! 1221: } else
! 1222: printf("%s: TX failed -- ", ifp->if_xname);
! 1223:
! 1224: /*
! 1225: * Although `err' looks like bitmask, it never
! 1226: * has multiple bits set.
! 1227: */
! 1228: switch (err) {
! 1229: #if 0
! 1230: case DESC_ERR_OTHER_FRAG:
! 1231: /* XXX what's this */
! 1232: printf("error in other fragment\n");
! 1233: stats->err_oth_frag++;
! 1234: break;
! 1235: #endif
! 1236: case DESC_ERR_ABORT:
! 1237: printf("aborted\n");
! 1238: stats->err_abort++;
! 1239: break;
! 1240: case DESC_ERR_PARAM:
! 1241: printf("wrong paramters in descriptor\n");
! 1242: stats->err_param++;
! 1243: break;
! 1244: case DESC_ERR_NO_WEPKEY:
! 1245: printf("WEP key missing\n");
! 1246: stats->err_no_wepkey++;
! 1247: break;
! 1248: case DESC_ERR_MSDU_TIMEOUT:
! 1249: printf("MSDU life timeout\n");
! 1250: stats->err_msdu_timeout++;
! 1251: break;
! 1252: case DESC_ERR_EXCESSIVE_RETRY:
! 1253: /*
! 1254: * Possible causes:
! 1255: * 1) Distance is too long
! 1256: * 2) Transmit failed (e.g. no MAC level ACK)
! 1257: * 3) Chip overheated (this should be rare)
! 1258: */
! 1259: stats->err_ex_retry++;
! 1260: break;
! 1261: case DESC_ERR_BUF_OVERFLOW:
! 1262: printf("buffer overflow\n");
! 1263: stats->err_buf_oflow++;
! 1264: break;
! 1265: case DESC_ERR_DMA:
! 1266: printf("DMA error\n");
! 1267: stats->err_dma++;
! 1268: break;
! 1269: default:
! 1270: printf("unknown error %d\n", err);
! 1271: stats->err_unkn++;
! 1272: break;
! 1273: }
! 1274: }
! 1275:
! 1276: void
! 1277: acx_rxeof(struct acx_softc *sc)
! 1278: {
! 1279: struct ieee80211com *ic = &sc->sc_ic;
! 1280: struct acx_ring_data *rd = &sc->sc_ring_data;
! 1281: struct acx_buf_data *bd = &sc->sc_buf_data;
! 1282: struct ifnet *ifp = &ic->ic_if;
! 1283: int idx, ready;
! 1284:
! 1285: bus_dmamap_sync(sc->sc_dmat, rd->rx_ring_dmamap, 0,
! 1286: rd->rx_ring_dmamap->dm_mapsize, BUS_DMASYNC_POSTREAD);
! 1287:
! 1288: /*
! 1289: * Locate first "ready" rx buffer,
! 1290: * start from last stopped position.
! 1291: */
! 1292: idx = bd->rx_scan_start;
! 1293: ready = 0;
! 1294: do {
! 1295: struct acx_rxbuf *buf;
! 1296:
! 1297: buf = &bd->rx_buf[idx];
! 1298: if ((buf->rb_desc->h_ctrl & htole16(DESC_CTRL_HOSTOWN)) &&
! 1299: (buf->rb_desc->h_status & htole32(DESC_STATUS_FULL))) {
! 1300: ready = 1;
! 1301: break;
! 1302: }
! 1303: idx = (idx + 1) % ACX_RX_DESC_CNT;
! 1304: } while (idx != bd->rx_scan_start);
! 1305:
! 1306: if (!ready)
! 1307: return;
! 1308:
! 1309: /*
! 1310: * NOTE: don't mess up `idx' here, it will
! 1311: * be used in the following code.
! 1312: */
! 1313: do {
! 1314: struct acx_rxbuf_hdr *head;
! 1315: struct acx_rxbuf *buf;
! 1316: struct mbuf *m;
! 1317: uint32_t desc_status;
! 1318: uint16_t desc_ctrl;
! 1319: int len, error;
! 1320:
! 1321: buf = &bd->rx_buf[idx];
! 1322:
! 1323: desc_ctrl = letoh16(buf->rb_desc->h_ctrl);
! 1324: desc_status = letoh32(buf->rb_desc->h_status);
! 1325: if (!(desc_ctrl & DESC_CTRL_HOSTOWN) ||
! 1326: !(desc_status & DESC_STATUS_FULL))
! 1327: break;
! 1328:
! 1329: bus_dmamap_sync(sc->sc_dmat, buf->rb_mbuf_dmamap, 0,
! 1330: buf->rb_mbuf_dmamap->dm_mapsize, BUS_DMASYNC_POSTREAD);
! 1331:
! 1332: m = buf->rb_mbuf;
! 1333:
! 1334: error = acx_newbuf(sc, buf, 0);
! 1335: if (error) {
! 1336: ifp->if_ierrors++;
! 1337: goto next;
! 1338: }
! 1339:
! 1340: head = mtod(m, struct acx_rxbuf_hdr *);
! 1341:
! 1342: len = letoh16(head->rbh_len) & ACX_RXBUF_LEN_MASK;
! 1343: if (len >= sizeof(struct ieee80211_frame_min) &&
! 1344: len < MCLBYTES) {
! 1345: struct ieee80211_frame *wh;
! 1346: struct ieee80211_node *ni;
! 1347:
! 1348: m_adj(m, sizeof(struct acx_rxbuf_hdr) +
! 1349: sc->chip_rxbuf_exhdr);
! 1350: wh = mtod(m, struct ieee80211_frame *);
! 1351:
! 1352: if ((wh->i_fc[1] & IEEE80211_FC1_WEP) &&
! 1353: sc->chip_hw_crypt) {
! 1354: /* Short circuit software WEP */
! 1355: wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
! 1356:
! 1357: /* Do chip specific RX buffer processing */
! 1358: if (sc->chip_proc_wep_rxbuf != NULL) {
! 1359: sc->chip_proc_wep_rxbuf(sc, m, &len);
! 1360: wh = mtod(m, struct ieee80211_frame *);
! 1361: }
! 1362: }
! 1363:
! 1364: m->m_len = m->m_pkthdr.len = len;
! 1365: m->m_pkthdr.rcvif = &ic->ic_if;
! 1366:
! 1367: #if NBPFILTER > 0
! 1368: if (sc->sc_drvbpf != NULL) {
! 1369: struct mbuf mb;
! 1370: struct acx_rx_radiotap_hdr *tap = &sc->sc_rxtap;
! 1371:
! 1372: tap->wr_flags = 0;
! 1373: tap->wr_chan_freq =
! 1374: htole16(ic->ic_bss->ni_chan->ic_freq);
! 1375: tap->wr_chan_flags =
! 1376: htole16(ic->ic_bss->ni_chan->ic_flags);
! 1377: tap->wr_rssi = head->rbh_level;
! 1378: tap->wr_max_rssi = ic->ic_max_rssi;
! 1379:
! 1380: mb.m_data = (caddr_t)tap;
! 1381: mb.m_len = sc->sc_rxtap_len;
! 1382: mb.m_next = m;
! 1383: mb.m_nextpkt = NULL;
! 1384: mb.m_type = 0;
! 1385: mb.m_flags = 0;
! 1386: bpf_mtap(sc->sc_drvbpf, &mb, BPF_DIRECTION_IN);
! 1387: }
! 1388: #endif
! 1389:
! 1390: ni = ieee80211_find_rxnode(ic, wh);
! 1391:
! 1392: ieee80211_input(ifp, m, ni, head->rbh_level,
! 1393: letoh32(head->rbh_time));
! 1394:
! 1395: ieee80211_release_node(ic, ni);
! 1396: ifp->if_ipackets++;
! 1397: } else {
! 1398: m_freem(m);
! 1399: ifp->if_ierrors++;
! 1400: }
! 1401:
! 1402: next:
! 1403: buf->rb_desc->h_ctrl = htole16(desc_ctrl & ~DESC_CTRL_HOSTOWN);
! 1404: buf->rb_desc->h_status = 0;
! 1405: bus_dmamap_sync(sc->sc_dmat, rd->rx_ring_dmamap, 0,
! 1406: rd->rx_ring_dmamap->dm_mapsize, BUS_DMASYNC_PREWRITE);
! 1407:
! 1408: idx = (idx + 1) % ACX_RX_DESC_CNT;
! 1409: } while (idx != bd->rx_scan_start);
! 1410:
! 1411: /*
! 1412: * Record the position so that next
! 1413: * time we can start from it.
! 1414: */
! 1415: bd->rx_scan_start = idx;
! 1416:
! 1417: /*
! 1418: * In HostAP mode, ieee80211_input() will enqueue packets in if_snd
! 1419: * without calling if_start().
! 1420: */
! 1421: if (!IFQ_IS_EMPTY(&ifp->if_snd) && !(ifp->if_flags & IFF_OACTIVE))
! 1422: (*ifp->if_start)(ifp);
! 1423: }
! 1424:
! 1425: int
! 1426: acx_reset(struct acx_softc *sc)
! 1427: {
! 1428: uint16_t reg;
! 1429:
! 1430: /* Halt ECPU */
! 1431: CSR_SETB_2(sc, ACXREG_ECPU_CTRL, ACXRV_ECPU_HALT);
! 1432:
! 1433: /* Software reset */
! 1434: reg = CSR_READ_2(sc, ACXREG_SOFT_RESET);
! 1435: CSR_WRITE_2(sc, ACXREG_SOFT_RESET, reg | ACXRV_SOFT_RESET);
! 1436: DELAY(100);
! 1437: CSR_WRITE_2(sc, ACXREG_SOFT_RESET, reg);
! 1438:
! 1439: /* Initialize EEPROM */
! 1440: CSR_SETB_2(sc, ACXREG_EEPROM_INIT, ACXRV_EEPROM_INIT);
! 1441: DELAY(50000);
! 1442:
! 1443: /* Test whether ECPU is stopped */
! 1444: reg = CSR_READ_2(sc, ACXREG_ECPU_CTRL);
! 1445: if (!(reg & ACXRV_ECPU_HALT)) {
! 1446: printf("%s: can't halt ECPU\n", sc->sc_dev.dv_xname);
! 1447: return (ENXIO);
! 1448: }
! 1449:
! 1450: return (0);
! 1451: }
! 1452:
! 1453: int
! 1454: acx_read_eeprom(struct acx_softc *sc, uint32_t offset, uint8_t *val)
! 1455: {
! 1456: int i;
! 1457: struct ifnet *ifp = &sc->sc_ic.ic_if;
! 1458:
! 1459: CSR_WRITE_4(sc, ACXREG_EEPROM_CONF, 0);
! 1460: CSR_WRITE_4(sc, ACXREG_EEPROM_ADDR, offset);
! 1461: CSR_WRITE_4(sc, ACXREG_EEPROM_CTRL, ACXRV_EEPROM_READ);
! 1462:
! 1463: #define EE_READ_RETRY_MAX 100
! 1464: for (i = 0; i < EE_READ_RETRY_MAX; ++i) {
! 1465: if (CSR_READ_2(sc, ACXREG_EEPROM_CTRL) == 0)
! 1466: break;
! 1467: DELAY(10000);
! 1468: }
! 1469: if (i == EE_READ_RETRY_MAX) {
! 1470: printf("%s: can't read EEPROM offset %x (timeout)\n",
! 1471: ifp->if_xname, offset);
! 1472: return (ETIMEDOUT);
! 1473: }
! 1474: #undef EE_READ_RETRY_MAX
! 1475:
! 1476: *val = CSR_READ_1(sc, ACXREG_EEPROM_DATA);
! 1477:
! 1478: return (0);
! 1479: }
! 1480:
! 1481: int
! 1482: acx_read_phyreg(struct acx_softc *sc, uint32_t reg, uint8_t *val)
! 1483: {
! 1484: struct ifnet *ifp = &sc->sc_ic.ic_if;
! 1485: int i;
! 1486:
! 1487: CSR_WRITE_4(sc, ACXREG_PHY_ADDR, reg);
! 1488: CSR_WRITE_4(sc, ACXREG_PHY_CTRL, ACXRV_PHY_READ);
! 1489:
! 1490: #define PHY_READ_RETRY_MAX 100
! 1491: for (i = 0; i < PHY_READ_RETRY_MAX; ++i) {
! 1492: if (CSR_READ_4(sc, ACXREG_PHY_CTRL) == 0)
! 1493: break;
! 1494: DELAY(10000);
! 1495: }
! 1496: if (i == PHY_READ_RETRY_MAX) {
! 1497: printf("%s: can't read phy reg %x (timeout)\n",
! 1498: ifp->if_xname, reg);
! 1499: return (ETIMEDOUT);
! 1500: }
! 1501: #undef PHY_READ_RETRY_MAX
! 1502:
! 1503: *val = CSR_READ_1(sc, ACXREG_PHY_DATA);
! 1504:
! 1505: return (0);
! 1506: }
! 1507:
! 1508: void
! 1509: acx_write_phyreg(struct acx_softc *sc, uint32_t reg, uint8_t val)
! 1510: {
! 1511: CSR_WRITE_4(sc, ACXREG_PHY_DATA, val);
! 1512: CSR_WRITE_4(sc, ACXREG_PHY_ADDR, reg);
! 1513: CSR_WRITE_4(sc, ACXREG_PHY_CTRL, ACXRV_PHY_WRITE);
! 1514: }
! 1515:
! 1516: int
! 1517: acx_load_base_firmware(struct acx_softc *sc, const char *name)
! 1518: {
! 1519: struct ifnet *ifp = &sc->sc_ic.ic_if;
! 1520: int i, error;
! 1521: uint8_t *ucode;
! 1522: size_t size;
! 1523:
! 1524: error = loadfirmware(name, &ucode, &size);
! 1525:
! 1526: if (error != 0) {
! 1527: printf("%s: error %d, could not read microcode %s!\n",
! 1528: ifp->if_xname, error, name);
! 1529: return (EIO);
! 1530: }
! 1531:
! 1532: /* Load base firmware */
! 1533: error = acx_load_firmware(sc, 0, ucode, size);
! 1534:
! 1535: free(ucode, M_DEVBUF);
! 1536:
! 1537: if (error) {
! 1538: printf("%s: can't load base firmware\n", ifp->if_xname);
! 1539: return error;
! 1540: }
! 1541: DPRINTF(("%s: base firmware loaded\n", sc->sc_dev.dv_xname));
! 1542:
! 1543: /* Start ECPU */
! 1544: CSR_WRITE_2(sc, ACXREG_ECPU_CTRL, ACXRV_ECPU_START);
! 1545:
! 1546: /* Wait for ECPU to be up */
! 1547: for (i = 0; i < 500; ++i) {
! 1548: uint16_t reg;
! 1549:
! 1550: reg = CSR_READ_2(sc, ACXREG_INTR_STATUS);
! 1551: if (reg & ACXRV_INTR_FCS_THRESH) {
! 1552: CSR_WRITE_2(sc, ACXREG_INTR_ACK, ACXRV_INTR_FCS_THRESH);
! 1553: return (0);
! 1554: }
! 1555: DELAY(10000);
! 1556: }
! 1557:
! 1558: printf("%s: can't initialize ECPU (timeout)\n", ifp->if_xname);
! 1559:
! 1560: return (ENXIO);
! 1561: }
! 1562:
! 1563: int
! 1564: acx_load_radio_firmware(struct acx_softc *sc, const char *name)
! 1565: {
! 1566: struct ifnet *ifp = &sc->sc_ic.ic_if;
! 1567: struct acx_conf_mmap mem_map;
! 1568: uint32_t radio_fw_ofs;
! 1569: int error;
! 1570: uint8_t *ucode;
! 1571: size_t size;
! 1572:
! 1573: error = loadfirmware(name, &ucode, &size);
! 1574:
! 1575: if (error != 0) {
! 1576: printf("%s: error %d, could not read microcode %s!\n",
! 1577: ifp->if_xname, error, name);
! 1578: return (EIO);
! 1579: }
! 1580:
! 1581: /*
! 1582: * Get the position, where base firmware is loaded, so that
! 1583: * radio firmware can be loaded after it.
! 1584: */
! 1585: if (acx_get_conf(sc, ACX_CONF_MMAP, &mem_map, sizeof(mem_map)) != 0) {
! 1586: free(ucode, M_DEVBUF);
! 1587: return (ENXIO);
! 1588: }
! 1589: radio_fw_ofs = letoh32(mem_map.code_end);
! 1590:
! 1591: /* Put ECPU into sleeping state, before loading radio firmware */
! 1592: if (acx_exec_command(sc, ACXCMD_SLEEP, NULL, 0, NULL, 0) != 0) {
! 1593: free(ucode, M_DEVBUF);
! 1594: return (ENXIO);
! 1595: }
! 1596:
! 1597: /* Load radio firmware */
! 1598: error = acx_load_firmware(sc, radio_fw_ofs, ucode, size);
! 1599:
! 1600: free(ucode, M_DEVBUF);
! 1601:
! 1602: if (error) {
! 1603: printf("%s: can't load radio firmware\n", ifp->if_xname);
! 1604: return (ENXIO);
! 1605: }
! 1606: DPRINTF(("%s: radio firmware loaded\n", sc->sc_dev.dv_xname));
! 1607:
! 1608: /* Wake up sleeping ECPU, after radio firmware is loaded */
! 1609: if (acx_exec_command(sc, ACXCMD_WAKEUP, NULL, 0, NULL, 0) != 0)
! 1610: return (ENXIO);
! 1611:
! 1612: /* Initialize radio */
! 1613: if (acx_init_radio(sc, radio_fw_ofs, size) != 0)
! 1614: return (ENXIO);
! 1615:
! 1616: /* Verify radio firmware's loading position */
! 1617: if (acx_get_conf(sc, ACX_CONF_MMAP, &mem_map, sizeof(mem_map)) != 0)
! 1618: return (ENXIO);
! 1619:
! 1620: if (letoh32(mem_map.code_end) != radio_fw_ofs + size) {
! 1621: printf("%s: loaded radio firmware position mismatch\n",
! 1622: ifp->if_xname);
! 1623: return (ENXIO);
! 1624: }
! 1625:
! 1626: DPRINTF(("%s: radio firmware initialized\n", sc->sc_dev.dv_xname));
! 1627:
! 1628: return (0);
! 1629: }
! 1630:
! 1631: int
! 1632: acx_load_firmware(struct acx_softc *sc, uint32_t offset, const uint8_t *data,
! 1633: int data_len)
! 1634: {
! 1635: struct ifnet *ifp = &sc->sc_ic.ic_if;
! 1636: const uint32_t *fw;
! 1637: u_int32_t csum = 0;
! 1638: int i, fw_len;
! 1639:
! 1640: for (i = 4; i < data_len; i++)
! 1641: csum += data[i];
! 1642:
! 1643: fw = (const uint32_t *)data;
! 1644:
! 1645: if (*fw != htole32(csum)) {
! 1646: printf("%s: firmware checksum 0x%x does not match 0x%x!\n",
! 1647: ifp->if_xname, *fw, htole32(csum));
! 1648: return (ENXIO);
! 1649: }
! 1650:
! 1651: /* skip csum + length */
! 1652: data += 8;
! 1653: data_len -= 8;
! 1654:
! 1655: fw = (const uint32_t *)data;
! 1656: fw_len = data_len / sizeof(uint32_t);
! 1657:
! 1658: /*
! 1659: * LOADFW_AUTO_INC only works with some older firmware:
! 1660: * 1) acx100's firmware
! 1661: * 2) acx111's firmware whose rev is 0x00010011
! 1662: */
! 1663:
! 1664: /* Load firmware */
! 1665: CSR_WRITE_4(sc, ACXREG_FWMEM_START, ACXRV_FWMEM_START_OP);
! 1666: #ifndef LOADFW_AUTO_INC
! 1667: CSR_WRITE_4(sc, ACXREG_FWMEM_CTRL, 0);
! 1668: #else
! 1669: CSR_WRITE_4(sc, ACXREG_FWMEM_CTRL, ACXRV_FWMEM_ADDR_AUTOINC);
! 1670: CSR_WRITE_4(sc, ACXREG_FWMEM_ADDR, offset);
! 1671: #endif
! 1672:
! 1673: for (i = 0; i < fw_len; ++i) {
! 1674: #ifndef LOADFW_AUTO_INC
! 1675: CSR_WRITE_4(sc, ACXREG_FWMEM_ADDR, offset + (i * 4));
! 1676: #endif
! 1677: CSR_WRITE_4(sc, ACXREG_FWMEM_DATA, betoh32(fw[i]));
! 1678: }
! 1679:
! 1680: /* Verify firmware */
! 1681: CSR_WRITE_4(sc, ACXREG_FWMEM_START, ACXRV_FWMEM_START_OP);
! 1682: #ifndef LOADFW_AUTO_INC
! 1683: CSR_WRITE_4(sc, ACXREG_FWMEM_CTRL, 0);
! 1684: #else
! 1685: CSR_WRITE_4(sc, ACXREG_FWMEM_CTRL, ACXRV_FWMEM_ADDR_AUTOINC);
! 1686: CSR_WRITE_4(sc, ACXREG_FWMEM_ADDR, offset);
! 1687: #endif
! 1688:
! 1689: for (i = 0; i < fw_len; ++i) {
! 1690: uint32_t val;
! 1691:
! 1692: #ifndef LOADFW_AUTO_INC
! 1693: CSR_WRITE_4(sc, ACXREG_FWMEM_ADDR, offset + (i * 4));
! 1694: #endif
! 1695: val = CSR_READ_4(sc, ACXREG_FWMEM_DATA);
! 1696: if (betoh32(fw[i]) != val) {
! 1697: printf("%s: firmware mismatch fw %08x loaded %08x\n",
! 1698: ifp->if_xname, fw[i], val);
! 1699: return (ENXIO);
! 1700: }
! 1701: }
! 1702:
! 1703: return (0);
! 1704: }
! 1705:
! 1706: struct ieee80211_node *
! 1707: acx_node_alloc(struct ieee80211com *ic)
! 1708: {
! 1709: struct acx_node *wn;
! 1710:
! 1711: wn = malloc(sizeof(struct acx_node), M_DEVBUF, M_NOWAIT);
! 1712: if (wn == NULL)
! 1713: return (NULL);
! 1714:
! 1715: bzero(wn, sizeof(struct acx_node));
! 1716:
! 1717: return ((struct ieee80211_node *)wn);
! 1718: }
! 1719:
! 1720: int
! 1721: acx_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
! 1722: {
! 1723: struct acx_softc *sc = ic->ic_if.if_softc;
! 1724: struct ifnet *ifp = &ic->ic_if;
! 1725: int error = 0;
! 1726:
! 1727: timeout_del(&sc->amrr_ch);
! 1728:
! 1729: switch (nstate) {
! 1730: case IEEE80211_S_INIT:
! 1731: break;
! 1732: case IEEE80211_S_SCAN: {
! 1733: uint8_t chan;
! 1734:
! 1735: chan = ieee80211_chan2ieee(ic, ic->ic_bss->ni_chan);
! 1736: (void)acx_set_channel(sc, chan);
! 1737:
! 1738: timeout_add(&sc->sc_chanscan_timer,
! 1739: hz / acx_chanscan_rate);
! 1740: }
! 1741: break;
! 1742: case IEEE80211_S_AUTH:
! 1743: if (ic->ic_opmode == IEEE80211_M_STA) {
! 1744: struct ieee80211_node *ni;
! 1745: #ifdef ACX_DEBUG
! 1746: int i;
! 1747: #endif
! 1748:
! 1749: ni = ic->ic_bss;
! 1750:
! 1751: if (acx_join_bss(sc, ACX_MODE_STA, ni) != 0) {
! 1752: printf("%s: join BSS failed\n", ifp->if_xname);
! 1753: error = 1;
! 1754: goto back;
! 1755: }
! 1756:
! 1757: DPRINTF(("%s: join BSS\n", sc->sc_dev.dv_xname));
! 1758: if (ic->ic_state == IEEE80211_S_ASSOC) {
! 1759: DPRINTF(("%s: change from assoc to run\n",
! 1760: sc->sc_dev.dv_xname));
! 1761: ic->ic_state = IEEE80211_S_RUN;
! 1762: }
! 1763:
! 1764: #ifdef ACX_DEBUG
! 1765: printf("%s: AP rates: ", sc->sc_dev.dv_xname);
! 1766: for (i = 0; i < ni->ni_rates.rs_nrates; ++i)
! 1767: printf("%d ", ni->ni_rates.rs_rates[i]);
! 1768: ieee80211_print_essid(ni->ni_essid, ni->ni_esslen);
! 1769: printf(" %s\n", ether_sprintf(ni->ni_bssid));
! 1770: #endif
! 1771: }
! 1772: break;
! 1773: case IEEE80211_S_RUN:
! 1774: if (ic->ic_opmode == IEEE80211_M_IBSS ||
! 1775: ic->ic_opmode == IEEE80211_M_HOSTAP) {
! 1776: struct ieee80211_node *ni;
! 1777: uint8_t chan;
! 1778:
! 1779: ni = ic->ic_bss;
! 1780: chan = ieee80211_chan2ieee(ic, ni->ni_chan);
! 1781:
! 1782: error = 1;
! 1783:
! 1784: if (acx_set_channel(sc, chan) != 0)
! 1785: goto back;
! 1786:
! 1787: if (acx_set_beacon_tmplt(sc, ni) != 0) {
! 1788: printf("%s: set beacon template failed\n",
! 1789: ifp->if_xname);
! 1790: goto back;
! 1791: }
! 1792:
! 1793: if (acx_set_probe_resp_tmplt(sc, ni) != 0) {
! 1794: printf("%s: set probe response template "
! 1795: "failed\n", ifp->if_xname);
! 1796: goto back;
! 1797: }
! 1798:
! 1799: if (ic->ic_opmode == IEEE80211_M_IBSS) {
! 1800: if (acx_join_bss(sc, ACX_MODE_ADHOC, ni) != 0) {
! 1801: printf("%s: join IBSS failed\n",
! 1802: ifp->if_xname);
! 1803: goto back;
! 1804: }
! 1805: } else {
! 1806: if (acx_join_bss(sc, ACX_MODE_AP, ni) != 0) {
! 1807: printf("%s: join HOSTAP failed\n",
! 1808: ifp->if_xname);
! 1809: goto back;
! 1810: }
! 1811: }
! 1812:
! 1813: DPRINTF(("%s: join IBSS\n", sc->sc_dev.dv_xname));
! 1814: error = 0;
! 1815: }
! 1816:
! 1817: /* fake a join to init the tx rate */
! 1818: if (ic->ic_opmode == IEEE80211_M_STA)
! 1819: acx_newassoc(ic, ic->ic_bss, 1);
! 1820:
! 1821: /* start automatic rate control timer */
! 1822: if (ic->ic_fixed_rate == -1)
! 1823: timeout_add(&sc->amrr_ch, hz / 2);
! 1824: break;
! 1825: default:
! 1826: break;
! 1827: }
! 1828:
! 1829: back:
! 1830: if (error) {
! 1831: /* XXX */
! 1832: nstate = IEEE80211_S_INIT;
! 1833: arg = -1;
! 1834: }
! 1835:
! 1836: return (sc->sc_newstate(ic, nstate, arg));
! 1837: }
! 1838:
! 1839: int
! 1840: acx_init_tmplt_ordered(struct acx_softc *sc)
! 1841: {
! 1842: union {
! 1843: struct acx_tmplt_beacon beacon;
! 1844: struct acx_tmplt_null_data null;
! 1845: struct acx_tmplt_probe_req preq;
! 1846: struct acx_tmplt_probe_resp presp;
! 1847: struct acx_tmplt_tim tim;
! 1848: } data;
! 1849:
! 1850: bzero(&data, sizeof(data));
! 1851: /*
! 1852: * NOTE:
! 1853: * Order of templates initialization:
! 1854: * 1) Probe request
! 1855: * 2) NULL data
! 1856: * 3) Beacon
! 1857: * 4) TIM
! 1858: * 5) Probe response
! 1859: * Above order is critical to get a correct memory map.
! 1860: */
! 1861: if (acx_set_tmplt(sc, ACXCMD_TMPLT_PROBE_REQ, &data.preq,
! 1862: sizeof(data.preq)) != 0)
! 1863: return (1);
! 1864:
! 1865: if (acx_set_tmplt(sc, ACXCMD_TMPLT_NULL_DATA, &data.null,
! 1866: sizeof(data.null)) != 0)
! 1867: return (1);
! 1868:
! 1869: if (acx_set_tmplt(sc, ACXCMD_TMPLT_BEACON, &data.beacon,
! 1870: sizeof(data.beacon)) != 0)
! 1871: return (1);
! 1872:
! 1873: if (acx_set_tmplt(sc, ACXCMD_TMPLT_TIM, &data.tim,
! 1874: sizeof(data.tim)) != 0)
! 1875: return (1);
! 1876:
! 1877: if (acx_set_tmplt(sc, ACXCMD_TMPLT_PROBE_RESP, &data.presp,
! 1878: sizeof(data.presp)) != 0)
! 1879: return (1);
! 1880:
! 1881: return (0);
! 1882: }
! 1883:
! 1884: int
! 1885: acx_dma_alloc(struct acx_softc *sc)
! 1886: {
! 1887: struct acx_ring_data *rd = &sc->sc_ring_data;
! 1888: struct acx_buf_data *bd = &sc->sc_buf_data;
! 1889: struct ifnet *ifp = &sc->sc_ic.ic_if;
! 1890: int i, error, nsegs;
! 1891:
! 1892: /* Allocate DMA stuffs for RX descriptors */
! 1893: error = bus_dmamap_create(sc->sc_dmat, ACX_RX_RING_SIZE, 1,
! 1894: ACX_RX_RING_SIZE, 0, BUS_DMA_NOWAIT, &rd->rx_ring_dmamap);
! 1895:
! 1896: if (error) {
! 1897: printf("%s: can't create rx ring dma tag\n",
! 1898: sc->sc_dev.dv_xname);
! 1899: return (error);
! 1900: }
! 1901:
! 1902: error = bus_dmamem_alloc(sc->sc_dmat, ACX_RX_RING_SIZE, PAGE_SIZE,
! 1903: 0, &rd->rx_ring_seg, 1, &nsegs, BUS_DMA_NOWAIT);
! 1904:
! 1905: if (error != 0) {
! 1906: printf("%s: can't allocate rx ring dma memory\n",
! 1907: sc->sc_dev.dv_xname);
! 1908: return (error);
! 1909: }
! 1910:
! 1911: error = bus_dmamem_map(sc->sc_dmat, &rd->rx_ring_seg, nsegs,
! 1912: ACX_RX_RING_SIZE, (caddr_t *)&rd->rx_ring,
! 1913: BUS_DMA_NOWAIT);
! 1914:
! 1915: if (error != 0) {
! 1916: printf("%s: could not map rx desc DMA memory\n",
! 1917: sc->sc_dev.dv_xname);
! 1918: return (error);
! 1919: }
! 1920:
! 1921: error = bus_dmamap_load(sc->sc_dmat, rd->rx_ring_dmamap,
! 1922: rd->rx_ring, ACX_RX_RING_SIZE, NULL, BUS_DMA_WAITOK);
! 1923:
! 1924: if (error) {
! 1925: printf("%s: can't get rx ring dma address\n",
! 1926: sc->sc_dev.dv_xname);
! 1927: bus_dmamem_free(sc->sc_dmat, &rd->rx_ring_seg, 1);
! 1928: return (error);
! 1929: }
! 1930:
! 1931: rd->rx_ring_paddr = rd->rx_ring_dmamap->dm_segs[0].ds_addr;
! 1932:
! 1933: /* Allocate DMA stuffs for TX descriptors */
! 1934: error = bus_dmamap_create(sc->sc_dmat, ACX_TX_RING_SIZE, 1,
! 1935: ACX_TX_RING_SIZE, 0, BUS_DMA_NOWAIT, &rd->tx_ring_dmamap);
! 1936:
! 1937: if (error) {
! 1938: printf("%s: can't create tx ring dma tag\n", ifp->if_xname);
! 1939: return (error);
! 1940: }
! 1941:
! 1942: error = bus_dmamem_alloc(sc->sc_dmat, ACX_TX_RING_SIZE, PAGE_SIZE,
! 1943: 0, &rd->tx_ring_seg, 1, &nsegs, BUS_DMA_NOWAIT);
! 1944:
! 1945: if (error) {
! 1946: printf("%s: can't allocate tx ring dma memory\n",
! 1947: ifp->if_xname);
! 1948: return (error);
! 1949: }
! 1950:
! 1951: error = bus_dmamem_map(sc->sc_dmat, &rd->tx_ring_seg, nsegs,
! 1952: ACX_TX_RING_SIZE, (caddr_t *)&rd->tx_ring, BUS_DMA_NOWAIT);
! 1953:
! 1954: if (error != 0) {
! 1955: printf("%s: could not map tx desc DMA memory\n",
! 1956: sc->sc_dev.dv_xname);
! 1957: return (error);
! 1958: }
! 1959:
! 1960: error = bus_dmamap_load(sc->sc_dmat, rd->tx_ring_dmamap,
! 1961: rd->tx_ring, ACX_TX_RING_SIZE, NULL, BUS_DMA_WAITOK);
! 1962:
! 1963: if (error) {
! 1964: printf("%s: can't get tx ring dma address\n", ifp->if_xname);
! 1965: bus_dmamem_free(sc->sc_dmat, &rd->tx_ring_seg, 1);
! 1966: return (error);
! 1967: }
! 1968:
! 1969: rd->tx_ring_paddr = rd->tx_ring_dmamap->dm_segs[0].ds_addr;
! 1970:
! 1971: /* Create a spare RX DMA map */
! 1972: error = bus_dmamap_create(sc->sc_dmat, MCLBYTES, 1, MCLBYTES,
! 1973: 0, 0, &bd->mbuf_tmp_dmamap);
! 1974:
! 1975: if (error) {
! 1976: printf("%s: can't create tmp mbuf dma map\n", ifp->if_xname);
! 1977: return (error);
! 1978: }
! 1979:
! 1980: /* Create DMA map for RX mbufs */
! 1981: for (i = 0; i < ACX_RX_DESC_CNT; ++i) {
! 1982: error = bus_dmamap_create(sc->sc_dmat, MCLBYTES, 1,
! 1983: MCLBYTES, 0, 0, &bd->rx_buf[i].rb_mbuf_dmamap);
! 1984: if (error) {
! 1985: printf("%s: can't create rx mbuf dma map (%d)\n",
! 1986: ifp->if_xname, i);
! 1987: return (error);
! 1988: }
! 1989: bd->rx_buf[i].rb_desc = &rd->rx_ring[i];
! 1990: }
! 1991:
! 1992: /* Create DMA map for TX mbufs */
! 1993: for (i = 0; i < ACX_TX_DESC_CNT; ++i) {
! 1994: error = bus_dmamap_create(sc->sc_dmat, MCLBYTES, 1,
! 1995: MCLBYTES, 0, 0, &bd->tx_buf[i].tb_mbuf_dmamap);
! 1996: if (error) {
! 1997: printf("%s: can't create tx mbuf dma map (%d)\n",
! 1998: ifp->if_xname, i);
! 1999: return (error);
! 2000: }
! 2001: bd->tx_buf[i].tb_desc1 = &rd->tx_ring[i * 2];
! 2002: bd->tx_buf[i].tb_desc2 = &rd->tx_ring[(i * 2) + 1];
! 2003: }
! 2004:
! 2005: return (0);
! 2006: }
! 2007:
! 2008: void
! 2009: acx_dma_free(struct acx_softc *sc)
! 2010: {
! 2011: struct acx_ring_data *rd = &sc->sc_ring_data;
! 2012: struct acx_buf_data *bd = &sc->sc_buf_data;
! 2013: int i;
! 2014:
! 2015: if (rd->rx_ring != NULL) {
! 2016: bus_dmamap_unload(sc->sc_dmat, rd->rx_ring_dmamap);
! 2017: bus_dmamem_free(sc->sc_dmat, &rd->rx_ring_seg, 1);
! 2018: }
! 2019:
! 2020: if (rd->tx_ring != NULL) {
! 2021: bus_dmamap_unload(sc->sc_dmat, rd->tx_ring_dmamap);
! 2022: bus_dmamem_free(sc->sc_dmat, &rd->tx_ring_seg, 1);
! 2023: }
! 2024:
! 2025: for (i = 0; i < ACX_RX_DESC_CNT; ++i) {
! 2026: if (bd->rx_buf[i].rb_desc != NULL) {
! 2027: if (bd->rx_buf[i].rb_mbuf != NULL) {
! 2028: bus_dmamap_unload(sc->sc_dmat,
! 2029: bd->rx_buf[i].rb_mbuf_dmamap);
! 2030: m_freem(bd->rx_buf[i].rb_mbuf);
! 2031: }
! 2032: bus_dmamap_destroy(sc->sc_dmat,
! 2033: bd->rx_buf[i].rb_mbuf_dmamap);
! 2034: }
! 2035: }
! 2036:
! 2037: for (i = 0; i < ACX_TX_DESC_CNT; ++i) {
! 2038: if (bd->tx_buf[i].tb_desc1 != NULL) {
! 2039: if (bd->tx_buf[i].tb_mbuf != NULL) {
! 2040: bus_dmamap_unload(sc->sc_dmat,
! 2041: bd->tx_buf[i].tb_mbuf_dmamap);
! 2042: m_freem(bd->tx_buf[i].tb_mbuf);
! 2043: }
! 2044: bus_dmamap_destroy(sc->sc_dmat,
! 2045: bd->tx_buf[i].tb_mbuf_dmamap);
! 2046: }
! 2047: }
! 2048:
! 2049: if (bd->mbuf_tmp_dmamap != NULL)
! 2050: bus_dmamap_destroy(sc->sc_dmat, bd->mbuf_tmp_dmamap);
! 2051: }
! 2052:
! 2053: int
! 2054: acx_init_tx_ring(struct acx_softc *sc)
! 2055: {
! 2056: struct acx_ring_data *rd;
! 2057: struct acx_buf_data *bd;
! 2058: uint32_t paddr;
! 2059: int i;
! 2060:
! 2061: rd = &sc->sc_ring_data;
! 2062: paddr = rd->tx_ring_paddr;
! 2063: for (i = 0; i < (ACX_TX_DESC_CNT * 2) - 1; ++i) {
! 2064: paddr += sizeof(struct acx_host_desc);
! 2065:
! 2066: bzero(&rd->tx_ring[i], sizeof(struct acx_host_desc));
! 2067: rd->tx_ring[i].h_ctrl = htole16(DESC_CTRL_HOSTOWN);
! 2068:
! 2069: if (i == (ACX_TX_DESC_CNT * 2) - 1)
! 2070: rd->tx_ring[i].h_next_desc = htole32(rd->tx_ring_paddr);
! 2071: else
! 2072: rd->tx_ring[i].h_next_desc = htole32(paddr);
! 2073: }
! 2074:
! 2075: bus_dmamap_sync(sc->sc_dmat, rd->tx_ring_dmamap, 0,
! 2076: rd->tx_ring_dmamap->dm_mapsize, BUS_DMASYNC_PREWRITE);
! 2077:
! 2078: bd = &sc->sc_buf_data;
! 2079: bd->tx_free_start = 0;
! 2080: bd->tx_used_start = 0;
! 2081: bd->tx_used_count = 0;
! 2082:
! 2083: return (0);
! 2084: }
! 2085:
! 2086: int
! 2087: acx_init_rx_ring(struct acx_softc *sc)
! 2088: {
! 2089: struct acx_ring_data *rd;
! 2090: struct acx_buf_data *bd;
! 2091: uint32_t paddr;
! 2092: int i;
! 2093:
! 2094: bd = &sc->sc_buf_data;
! 2095: rd = &sc->sc_ring_data;
! 2096: paddr = rd->rx_ring_paddr;
! 2097:
! 2098: for (i = 0; i < ACX_RX_DESC_CNT; ++i) {
! 2099: int error;
! 2100:
! 2101: paddr += sizeof(struct acx_host_desc);
! 2102: bzero(&rd->rx_ring[i], sizeof(struct acx_host_desc));
! 2103:
! 2104: error = acx_newbuf(sc, &bd->rx_buf[i], 1);
! 2105: if (error)
! 2106: return (error);
! 2107:
! 2108: if (i == ACX_RX_DESC_CNT - 1)
! 2109: rd->rx_ring[i].h_next_desc = htole32(rd->rx_ring_paddr);
! 2110: else
! 2111: rd->rx_ring[i].h_next_desc = htole32(paddr);
! 2112: }
! 2113:
! 2114: bus_dmamap_sync(sc->sc_dmat, rd->rx_ring_dmamap, 0,
! 2115: rd->rx_ring_dmamap->dm_mapsize, BUS_DMASYNC_PREWRITE);
! 2116:
! 2117: bd->rx_scan_start = 0;
! 2118:
! 2119: return (0);
! 2120: }
! 2121:
! 2122: int
! 2123: acx_newbuf(struct acx_softc *sc, struct acx_rxbuf *rb, int wait)
! 2124: {
! 2125: struct acx_buf_data *bd;
! 2126: struct mbuf *m;
! 2127: bus_dmamap_t map;
! 2128: uint32_t paddr;
! 2129: int error;
! 2130:
! 2131: bd = &sc->sc_buf_data;
! 2132:
! 2133: MGETHDR(m, wait ? M_WAITOK : M_DONTWAIT, MT_DATA);
! 2134: if (m == NULL)
! 2135: return (ENOBUFS);
! 2136:
! 2137: MCLGET(m, wait ? M_WAITOK : M_DONTWAIT);
! 2138: if (!(m->m_flags & M_EXT)) {
! 2139: m_freem(m);
! 2140: return (ENOBUFS);
! 2141: }
! 2142:
! 2143: m->m_len = m->m_pkthdr.len = MCLBYTES;
! 2144:
! 2145: error = bus_dmamap_load_mbuf(sc->sc_dmat, bd->mbuf_tmp_dmamap, m,
! 2146: wait ? BUS_DMA_WAITOK : BUS_DMA_NOWAIT);
! 2147: if (error) {
! 2148: m_freem(m);
! 2149: printf("%s: can't map rx mbuf %d\n",
! 2150: sc->sc_dev.dv_xname, error);
! 2151: return (error);
! 2152: }
! 2153:
! 2154: /* Unload originally mapped mbuf */
! 2155: if (rb->rb_mbuf != NULL)
! 2156: bus_dmamap_unload(sc->sc_dmat, rb->rb_mbuf_dmamap);
! 2157:
! 2158: /* Swap this dmamap with tmp dmamap */
! 2159: map = rb->rb_mbuf_dmamap;
! 2160: rb->rb_mbuf_dmamap = bd->mbuf_tmp_dmamap;
! 2161: bd->mbuf_tmp_dmamap = map;
! 2162: paddr = rb->rb_mbuf_dmamap->dm_segs[0].ds_addr;
! 2163:
! 2164: rb->rb_mbuf = m;
! 2165: rb->rb_desc->h_data_paddr = htole32(paddr);
! 2166: rb->rb_desc->h_data_len = htole16(m->m_len);
! 2167:
! 2168: bus_dmamap_sync(sc->sc_dmat, rb->rb_mbuf_dmamap, 0,
! 2169: rb->rb_mbuf_dmamap->dm_mapsize, BUS_DMASYNC_PREREAD);
! 2170:
! 2171: return (0);
! 2172: }
! 2173:
! 2174: int
! 2175: acx_encap(struct acx_softc *sc, struct acx_txbuf *txbuf, struct mbuf *m,
! 2176: struct ieee80211_node *ni, int rate)
! 2177: {
! 2178: struct acx_ring_data *rd = &sc->sc_ring_data;
! 2179: struct acx_node *node = (struct acx_node *)ni;
! 2180: struct ifnet *ifp = &sc->sc_ic.ic_if;
! 2181: uint32_t paddr;
! 2182: uint8_t ctrl;
! 2183: int error;
! 2184:
! 2185: if (txbuf->tb_mbuf != NULL)
! 2186: panic("free TX buf has mbuf installed\n");
! 2187:
! 2188: error = 0;
! 2189:
! 2190: if (m->m_pkthdr.len > MCLBYTES) {
! 2191: printf("%s: mbuf too big\n", ifp->if_xname);
! 2192: error = E2BIG;
! 2193: goto back;
! 2194: } else if (m->m_pkthdr.len < ACX_FRAME_HDRLEN) {
! 2195: printf("%s: mbuf too small\n", ifp->if_xname);
! 2196: error = EINVAL;
! 2197: goto back;
! 2198: }
! 2199:
! 2200: error = bus_dmamap_load_mbuf(sc->sc_dmat, txbuf->tb_mbuf_dmamap, m,
! 2201: BUS_DMA_NOWAIT);
! 2202:
! 2203: if (error && error != EFBIG) {
! 2204: printf("%s: can't map tx mbuf1 %d\n",
! 2205: sc->sc_dev.dv_xname, error);
! 2206: goto back;
! 2207: }
! 2208:
! 2209: if (error) { /* error == EFBIG */
! 2210: /* too many fragments, linearize */
! 2211: struct mbuf *mnew;
! 2212:
! 2213: error = 0;
! 2214:
! 2215: MGETHDR(mnew, M_DONTWAIT, MT_DATA);
! 2216: if (mnew == NULL) {
! 2217: m_freem(m);
! 2218: error = ENOBUFS;
! 2219: printf("%s: can't defrag tx mbuf\n", ifp->if_xname);
! 2220: goto back;
! 2221: }
! 2222:
! 2223: M_DUP_PKTHDR(mnew, m);
! 2224: if (m->m_pkthdr.len > MHLEN) {
! 2225: MCLGET(mnew, M_DONTWAIT);
! 2226: if (!(mnew->m_flags & M_EXT)) {
! 2227: m_freem(m);
! 2228: m_freem(mnew);
! 2229: error = ENOBUFS;
! 2230: }
! 2231: }
! 2232:
! 2233: if (error) {
! 2234: printf("%s: can't defrag tx mbuf\n", ifp->if_xname);
! 2235: goto back;
! 2236: }
! 2237:
! 2238: m_copydata(m, 0, m->m_pkthdr.len, mtod(mnew, caddr_t));
! 2239: m_freem(m);
! 2240: mnew->m_len = mnew->m_pkthdr.len;
! 2241: m = mnew;
! 2242:
! 2243: error = bus_dmamap_load_mbuf(sc->sc_dmat,
! 2244: txbuf->tb_mbuf_dmamap, m, BUS_DMA_NOWAIT);
! 2245: if (error) {
! 2246: printf("%s: can't map tx mbuf2 %d\n",
! 2247: sc->sc_dev.dv_xname, error);
! 2248: goto back;
! 2249: }
! 2250: }
! 2251:
! 2252: error = 0;
! 2253:
! 2254: bus_dmamap_sync(sc->sc_dmat, txbuf->tb_mbuf_dmamap, 0,
! 2255: txbuf->tb_mbuf_dmamap->dm_mapsize, BUS_DMASYNC_PREWRITE);
! 2256:
! 2257: txbuf->tb_mbuf = m;
! 2258: txbuf->tb_node = node;
! 2259: txbuf->tb_rate = rate;
! 2260:
! 2261: /*
! 2262: * TX buffers are accessed in following way:
! 2263: * acx_fw_txdesc -> acx_host_desc -> buffer
! 2264: *
! 2265: * It is quite strange that acx also queries acx_host_desc next to
! 2266: * the one we have assigned to acx_fw_txdesc even if first one's
! 2267: * acx_host_desc.h_data_len == acx_fw_txdesc.f_tx_len
! 2268: *
! 2269: * So we allocate two acx_host_desc for one acx_fw_txdesc and
! 2270: * assign the first acx_host_desc to acx_fw_txdesc
! 2271: *
! 2272: * For acx111
! 2273: * host_desc1.h_data_len = buffer_len
! 2274: * host_desc2.h_data_len = buffer_len - mac_header_len
! 2275: *
! 2276: * For acx100
! 2277: * host_desc1.h_data_len = mac_header_len
! 2278: * host_desc2.h_data_len = buffer_len - mac_header_len
! 2279: */
! 2280: paddr = txbuf->tb_mbuf_dmamap->dm_segs[0].ds_addr;
! 2281: txbuf->tb_desc1->h_data_paddr = htole32(paddr);
! 2282: txbuf->tb_desc2->h_data_paddr = htole32(paddr + ACX_FRAME_HDRLEN);
! 2283:
! 2284: txbuf->tb_desc1->h_data_len =
! 2285: htole16(sc->chip_txdesc1_len ? sc->chip_txdesc1_len
! 2286: : m->m_pkthdr.len);
! 2287: txbuf->tb_desc2->h_data_len =
! 2288: htole16(m->m_pkthdr.len - ACX_FRAME_HDRLEN);
! 2289:
! 2290: /*
! 2291: * NOTE:
! 2292: * We can't simply assign f_tx_ctrl, we will first read it back
! 2293: * and change it bit by bit
! 2294: */
! 2295: ctrl = FW_TXDESC_GETFIELD_1(sc, txbuf, f_tx_ctrl);
! 2296: ctrl |= sc->chip_fw_txdesc_ctrl; /* extra chip specific flags */
! 2297: ctrl &= ~(DESC_CTRL_HOSTOWN | DESC_CTRL_ACXDONE);
! 2298:
! 2299: FW_TXDESC_SETFIELD_2(sc, txbuf, f_tx_len, m->m_pkthdr.len);
! 2300: FW_TXDESC_SETFIELD_1(sc, txbuf, f_tx_error, 0);
! 2301: FW_TXDESC_SETFIELD_1(sc, txbuf, f_tx_ack_fail, 0);
! 2302: FW_TXDESC_SETFIELD_1(sc, txbuf, f_tx_rts_fail, 0);
! 2303: FW_TXDESC_SETFIELD_1(sc, txbuf, f_tx_rts_ok, 0);
! 2304: sc->chip_set_fw_txdesc_rate(sc, txbuf, rate);
! 2305:
! 2306: txbuf->tb_desc1->h_ctrl = 0;
! 2307: txbuf->tb_desc2->h_ctrl = 0;
! 2308: bus_dmamap_sync(sc->sc_dmat, rd->tx_ring_dmamap, 0,
! 2309: rd->tx_ring_dmamap->dm_mapsize, BUS_DMASYNC_PREWRITE);
! 2310:
! 2311: FW_TXDESC_SETFIELD_1(sc, txbuf, f_tx_ctrl2, 0);
! 2312: FW_TXDESC_SETFIELD_1(sc, txbuf, f_tx_ctrl, ctrl);
! 2313:
! 2314: /* Tell chip to inform us about TX completion */
! 2315: CSR_WRITE_2(sc, ACXREG_INTR_TRIG, ACXRV_TRIG_TX_FINI);
! 2316: back:
! 2317: if (error)
! 2318: m_freem(m);
! 2319:
! 2320: return (error);
! 2321: }
! 2322:
! 2323: int
! 2324: acx_set_null_tmplt(struct acx_softc *sc)
! 2325: {
! 2326: struct ieee80211com *ic = &sc->sc_ic;
! 2327: struct acx_tmplt_null_data n;
! 2328: struct ieee80211_frame *wh;
! 2329:
! 2330: bzero(&n, sizeof(n));
! 2331:
! 2332: wh = &n.data;
! 2333: wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_DATA |
! 2334: IEEE80211_FC0_SUBTYPE_NODATA;
! 2335: wh->i_fc[1] = IEEE80211_FC1_DIR_NODS;
! 2336: IEEE80211_ADDR_COPY(wh->i_addr1, etherbroadcastaddr);
! 2337: IEEE80211_ADDR_COPY(wh->i_addr2, ic->ic_myaddr);
! 2338: IEEE80211_ADDR_COPY(wh->i_addr3, etherbroadcastaddr);
! 2339:
! 2340: return (acx_set_tmplt(sc, ACXCMD_TMPLT_NULL_DATA, &n, sizeof(n)));
! 2341: }
! 2342:
! 2343: int
! 2344: acx_set_probe_req_tmplt(struct acx_softc *sc, const char *ssid, int ssid_len)
! 2345: {
! 2346: struct ieee80211com *ic = &sc->sc_ic;
! 2347: struct acx_tmplt_probe_req req;
! 2348: struct ieee80211_frame *wh;
! 2349: uint8_t *frm;
! 2350: int len;
! 2351:
! 2352: bzero(&req, sizeof(req));
! 2353:
! 2354: wh = &req.data.u_data.f;
! 2355: wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_MGT |
! 2356: IEEE80211_FC0_SUBTYPE_PROBE_REQ;
! 2357: wh->i_fc[1] = IEEE80211_FC1_DIR_NODS;
! 2358: IEEE80211_ADDR_COPY(wh->i_addr1, etherbroadcastaddr);
! 2359: IEEE80211_ADDR_COPY(wh->i_addr2, ic->ic_myaddr);
! 2360: IEEE80211_ADDR_COPY(wh->i_addr3, etherbroadcastaddr);
! 2361:
! 2362: frm = req.data.u_data.var;
! 2363: frm = ieee80211_add_ssid(frm, ssid, ssid_len);
! 2364: frm = ieee80211_add_rates(frm, &ic->ic_sup_rates[sc->chip_phymode]);
! 2365: frm = ieee80211_add_xrates(frm, &ic->ic_sup_rates[sc->chip_phymode]);
! 2366: len = frm - req.data.u_data.var;
! 2367:
! 2368: return (acx_set_tmplt(sc, ACXCMD_TMPLT_PROBE_REQ, &req,
! 2369: ACX_TMPLT_PROBE_REQ_SIZ(len)));
! 2370: }
! 2371:
! 2372: struct mbuf *ieee80211_get_probe_resp(struct ieee80211com *,
! 2373: struct ieee80211_node *);
! 2374:
! 2375: int
! 2376: acx_set_probe_resp_tmplt(struct acx_softc *sc, struct ieee80211_node *ni)
! 2377: {
! 2378: struct ieee80211com *ic = &sc->sc_ic;
! 2379: struct acx_tmplt_probe_resp resp;
! 2380: struct ieee80211_frame *wh;
! 2381: struct mbuf *m;
! 2382: int len;
! 2383:
! 2384: bzero(&resp, sizeof(resp));
! 2385:
! 2386: m = ieee80211_get_probe_resp(ic, ni);
! 2387: if (m == NULL)
! 2388: return (1);
! 2389: M_PREPEND(m, sizeof(struct ieee80211_frame), M_DONTWAIT);
! 2390: if (m == NULL)
! 2391: return (1);
! 2392: wh = mtod(m, struct ieee80211_frame *);
! 2393: wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_MGT |
! 2394: IEEE80211_FC0_SUBTYPE_PROBE_RESP;
! 2395: wh->i_fc[1] = IEEE80211_FC1_DIR_NODS;
! 2396: *(u_int16_t *)&wh->i_dur[0] = 0;
! 2397: IEEE80211_ADDR_COPY(wh->i_addr1, ni->ni_macaddr);
! 2398: IEEE80211_ADDR_COPY(wh->i_addr2, ic->ic_myaddr);
! 2399: IEEE80211_ADDR_COPY(wh->i_addr3, ni->ni_bssid);
! 2400: *(u_int16_t *)wh->i_seq = 0;
! 2401:
! 2402: m_copydata(m, 0, m->m_pkthdr.len, (caddr_t)&resp.data);
! 2403: len = m->m_pkthdr.len + sizeof(resp.size);
! 2404: m_freem(m);
! 2405:
! 2406: return (acx_set_tmplt(sc, ACXCMD_TMPLT_PROBE_RESP, &resp, len));
! 2407: }
! 2408:
! 2409: int
! 2410: acx_beacon_locate(struct mbuf *m, u_int8_t type)
! 2411: {
! 2412: int off;
! 2413: u_int8_t *frm;
! 2414: /*
! 2415: * beacon frame format
! 2416: * [8] time stamp
! 2417: * [2] beacon interval
! 2418: * [2] cabability information
! 2419: * from here on [tlv] values
! 2420: */
! 2421:
! 2422: if (m->m_len != m->m_pkthdr.len)
! 2423: panic("beacon not in contiguous mbuf");
! 2424:
! 2425: off = sizeof(struct ieee80211_frame) + 8 + 2 + 2;
! 2426: frm = mtod(m, u_int8_t *);
! 2427: for (; off + 1 < m->m_len; off += frm[off + 1] + 2) {
! 2428: if (frm[off] == type)
! 2429: return (off);
! 2430: }
! 2431: /* type not found */
! 2432: return (m->m_len);
! 2433: }
! 2434:
! 2435: int
! 2436: acx_set_beacon_tmplt(struct acx_softc *sc, struct ieee80211_node *ni)
! 2437: {
! 2438: struct ieee80211com *ic = &sc->sc_ic;
! 2439: struct acx_tmplt_beacon beacon;
! 2440: struct acx_tmplt_tim tim;
! 2441: struct mbuf *m;
! 2442: int len, off;
! 2443:
! 2444: bzero(&beacon, sizeof(beacon));
! 2445: bzero(&tim, sizeof(tim));
! 2446:
! 2447: m = ieee80211_beacon_alloc(ic, ni);
! 2448: if (m == NULL)
! 2449: return (1);
! 2450:
! 2451: off = acx_beacon_locate(m, IEEE80211_ELEMID_TIM);
! 2452:
! 2453: m_copydata(m, 0, off, (caddr_t)&beacon.data);
! 2454: len = off + sizeof(beacon.size);
! 2455:
! 2456: if (acx_set_tmplt(sc, ACXCMD_TMPLT_BEACON, &beacon, len) != 0) {
! 2457: m_freem(m);
! 2458: return (1);
! 2459: }
! 2460:
! 2461: len = m->m_pkthdr.len - off;
! 2462: if (len == 0) {
! 2463: /* no TIM field */
! 2464: m_freem(m);
! 2465: return (0);
! 2466: }
! 2467:
! 2468: m_copydata(m, off, len, (caddr_t)&tim.data);
! 2469: len += sizeof(beacon.size);
! 2470: m_freem(m);
! 2471:
! 2472: return (acx_set_tmplt(sc, ACXCMD_TMPLT_TIM, &tim, len));
! 2473: }
! 2474:
! 2475: void
! 2476: acx_init_cmd_reg(struct acx_softc *sc)
! 2477: {
! 2478: sc->sc_cmd = CSR_READ_4(sc, ACXREG_CMD_REG_OFFSET);
! 2479: sc->sc_cmd_param = sc->sc_cmd + ACX_CMD_REG_SIZE;
! 2480:
! 2481: /* Clear command & status */
! 2482: CMD_WRITE_4(sc, 0);
! 2483: }
! 2484:
! 2485: int
! 2486: acx_join_bss(struct acx_softc *sc, uint8_t mode, struct ieee80211_node *node)
! 2487: {
! 2488: uint8_t bj_buf[BSS_JOIN_BUFLEN];
! 2489: struct bss_join_hdr *bj;
! 2490: int i, dtim_intvl;
! 2491:
! 2492: bzero(bj_buf, sizeof(bj_buf));
! 2493: bj = (struct bss_join_hdr *)bj_buf;
! 2494:
! 2495: for (i = 0; i < IEEE80211_ADDR_LEN; ++i)
! 2496: bj->bssid[i] = node->ni_bssid[IEEE80211_ADDR_LEN - i - 1];
! 2497:
! 2498: bj->beacon_intvl = htole16(acx_beacon_intvl);
! 2499:
! 2500: /* TODO tunable */
! 2501: dtim_intvl = sc->sc_ic.ic_opmode == IEEE80211_M_IBSS ? 1 : 10;
! 2502: sc->chip_set_bss_join_param(sc, bj->chip_spec, dtim_intvl);
! 2503:
! 2504: bj->ndata_txrate = ACX_NDATA_TXRATE_2;
! 2505: bj->ndata_txopt = 0;
! 2506: bj->mode = mode;
! 2507: bj->channel = ieee80211_chan2ieee(&sc->sc_ic, node->ni_chan);
! 2508: bj->esslen = node->ni_esslen;
! 2509: bcopy(node->ni_essid, bj->essid, node->ni_esslen);
! 2510:
! 2511: DPRINTF(("%s: join BSS/IBSS on channel %d\n", sc->sc_dev.dv_xname,
! 2512: bj->channel));
! 2513: return (acx_exec_command(sc, ACXCMD_JOIN_BSS,
! 2514: bj, BSS_JOIN_PARAM_SIZE(bj), NULL, 0));
! 2515: }
! 2516:
! 2517: int
! 2518: acx_set_channel(struct acx_softc *sc, uint8_t chan)
! 2519: {
! 2520: if (acx_exec_command(sc, ACXCMD_ENABLE_TXCHAN, &chan, sizeof(chan),
! 2521: NULL, 0) != 0) {
! 2522: DPRINTF(("%s: setting TX channel %d failed\n",
! 2523: sc->sc_dev.dv_xname, chan));
! 2524: return (ENXIO);
! 2525: }
! 2526:
! 2527: if (acx_exec_command(sc, ACXCMD_ENABLE_RXCHAN, &chan, sizeof(chan),
! 2528: NULL, 0) != 0) {
! 2529: DPRINTF(("%s: setting RX channel %d failed\n",
! 2530: sc->sc_dev.dv_xname, chan));
! 2531: return (ENXIO);
! 2532: }
! 2533:
! 2534: return (0);
! 2535: }
! 2536:
! 2537: int
! 2538: acx_get_conf(struct acx_softc *sc, uint16_t conf_id, void *conf,
! 2539: uint16_t conf_len)
! 2540: {
! 2541: struct acx_conf *confcom;
! 2542:
! 2543: if (conf_len < sizeof(*confcom)) {
! 2544: printf("%s: %s configure data is too short\n",
! 2545: sc->sc_dev.dv_xname, __func__);
! 2546: return (1);
! 2547: }
! 2548:
! 2549: confcom = conf;
! 2550: confcom->conf_id = htole16(conf_id);
! 2551: confcom->conf_data_len = htole16(conf_len - sizeof(*confcom));
! 2552:
! 2553: return (acx_exec_command(sc, ACXCMD_GET_CONF, confcom, sizeof(*confcom),
! 2554: conf, conf_len));
! 2555: }
! 2556:
! 2557: int
! 2558: acx_set_conf(struct acx_softc *sc, uint16_t conf_id, void *conf,
! 2559: uint16_t conf_len)
! 2560: {
! 2561: struct acx_conf *confcom;
! 2562:
! 2563: if (conf_len < sizeof(*confcom)) {
! 2564: printf("%s: %s configure data is too short\n",
! 2565: sc->sc_dev.dv_xname, __func__);
! 2566: return (1);
! 2567: }
! 2568:
! 2569: confcom = conf;
! 2570: confcom->conf_id = htole16(conf_id);
! 2571: confcom->conf_data_len = htole16(conf_len - sizeof(*confcom));
! 2572:
! 2573: return (acx_exec_command(sc, ACXCMD_SET_CONF, conf, conf_len, NULL, 0));
! 2574: }
! 2575:
! 2576: int
! 2577: acx_set_tmplt(struct acx_softc *sc, uint16_t cmd, void *tmplt,
! 2578: uint16_t tmplt_len)
! 2579: {
! 2580: uint16_t *size;
! 2581:
! 2582: if (tmplt_len < sizeof(*size)) {
! 2583: printf("%s: %s template is too short\n",
! 2584: sc->sc_dev.dv_xname, __func__);
! 2585: return (1);
! 2586: }
! 2587:
! 2588: size = tmplt;
! 2589: *size = htole16(tmplt_len - sizeof(*size));
! 2590:
! 2591: return (acx_exec_command(sc, cmd, tmplt, tmplt_len, NULL, 0));
! 2592: }
! 2593:
! 2594: int
! 2595: acx_init_radio(struct acx_softc *sc, uint32_t radio_ofs, uint32_t radio_len)
! 2596: {
! 2597: struct radio_init r;
! 2598:
! 2599: r.radio_ofs = htole32(radio_ofs);
! 2600: r.radio_len = htole32(radio_len);
! 2601:
! 2602: return (acx_exec_command(sc, ACXCMD_INIT_RADIO, &r, sizeof(r), NULL,
! 2603: 0));
! 2604: }
! 2605:
! 2606: int
! 2607: acx_exec_command(struct acx_softc *sc, uint16_t cmd, void *param,
! 2608: uint16_t param_len, void *result, uint16_t result_len)
! 2609: {
! 2610: uint16_t status;
! 2611: int i, ret;
! 2612:
! 2613: if ((sc->sc_flags & ACX_FLAG_FW_LOADED) == 0) {
! 2614: printf("%s: cmd 0x%04x failed (base firmware not loaded)\n",
! 2615: sc->sc_dev.dv_xname, cmd);
! 2616: return (1);
! 2617: }
! 2618:
! 2619: ret = 0;
! 2620:
! 2621: if (param != NULL && param_len != 0) {
! 2622: /* Set command param */
! 2623: CMDPRM_WRITE_REGION_1(sc, param, param_len);
! 2624: }
! 2625:
! 2626: /* Set command */
! 2627: CMD_WRITE_4(sc, cmd);
! 2628:
! 2629: /* Exec command */
! 2630: CSR_WRITE_2(sc, ACXREG_INTR_TRIG, ACXRV_TRIG_CMD_FINI);
! 2631: DELAY(50);
! 2632:
! 2633: /* Wait for command to complete */
! 2634: if (cmd == ACXCMD_INIT_RADIO) {
! 2635: /* radio initialization is extremely long */
! 2636: tsleep(&cmd, 0, "rdinit", (300 * hz) / 1000); /* 300ms */
! 2637: }
! 2638:
! 2639: #define CMDWAIT_RETRY_MAX 1000
! 2640: for (i = 0; i < CMDWAIT_RETRY_MAX; ++i) {
! 2641: uint16_t reg;
! 2642:
! 2643: reg = CSR_READ_2(sc, ACXREG_INTR_STATUS);
! 2644: if (reg & ACXRV_INTR_CMD_FINI) {
! 2645: CSR_WRITE_2(sc, ACXREG_INTR_ACK, ACXRV_INTR_CMD_FINI);
! 2646: break;
! 2647: }
! 2648: DELAY(50);
! 2649: }
! 2650: if (i == CMDWAIT_RETRY_MAX) {
! 2651: printf("%s: cmd %04x failed (timeout)\n",
! 2652: sc->sc_dev.dv_xname, cmd);
! 2653: ret = 1;
! 2654: goto back;
! 2655: }
! 2656: #undef CMDWAIT_RETRY_MAX
! 2657:
! 2658: /* Get command exec status */
! 2659: status = (CMD_READ_4(sc) >> ACX_CMD_STATUS_SHIFT);
! 2660: if (status != ACX_CMD_STATUS_OK) {
! 2661: DPRINTF(("%s: cmd %04x failed\n", sc->sc_dev.dv_xname, cmd));
! 2662: ret = 1;
! 2663: goto back;
! 2664: }
! 2665:
! 2666: if (result != NULL && result_len != 0) {
! 2667: /* Get command result */
! 2668: CMDPRM_READ_REGION_1(sc, result, result_len);
! 2669: }
! 2670:
! 2671: back:
! 2672: CMD_WRITE_4(sc, 0);
! 2673:
! 2674: return (ret);
! 2675: }
! 2676:
! 2677: const char *
! 2678: acx_get_rf(int rev)
! 2679: {
! 2680: switch (rev) {
! 2681: case ACX_RADIO_TYPE_MAXIM: return "MAX2820";
! 2682: case ACX_RADIO_TYPE_RFMD: return "RFMD";
! 2683: case ACX_RADIO_TYPE_RALINK: return "Ralink";
! 2684: case ACX_RADIO_TYPE_RADIA: return "Radia";
! 2685: default: return "unknown";
! 2686: }
! 2687: }
! 2688:
! 2689: int
! 2690: acx_get_maxrssi(int radio)
! 2691: {
! 2692: switch (radio) {
! 2693: case ACX_RADIO_TYPE_MAXIM: return ACX_RADIO_RSSI_MAXIM;
! 2694: case ACX_RADIO_TYPE_RFMD: return ACX_RADIO_RSSI_RFMD;
! 2695: case ACX_RADIO_TYPE_RALINK: return ACX_RADIO_RSSI_RALINK;
! 2696: case ACX_RADIO_TYPE_RADIA: return ACX_RADIO_RSSI_RADIA;
! 2697: default: return ACX_RADIO_RSSI_UNKN;
! 2698: }
! 2699: }
! 2700:
! 2701: void
! 2702: acx_iter_func(void *arg, struct ieee80211_node *ni)
! 2703: {
! 2704: struct acx_softc *sc = arg;
! 2705: struct acx_node *wn = (struct acx_node *)ni;
! 2706:
! 2707: ieee80211_amrr_choose(&sc->amrr, ni, &wn->amn);
! 2708: }
! 2709:
! 2710: void
! 2711: acx_amrr_timeout(void *arg)
! 2712: {
! 2713: struct acx_softc *sc = arg;
! 2714: struct ieee80211com *ic = &sc->sc_ic;
! 2715:
! 2716: if (ic->ic_opmode == IEEE80211_M_STA)
! 2717: acx_iter_func(sc, ic->ic_bss);
! 2718: else
! 2719: ieee80211_iterate_nodes(ic, acx_iter_func, sc);
! 2720:
! 2721: timeout_add(&sc->amrr_ch, hz / 2);
! 2722: }
! 2723:
! 2724: void
! 2725: acx_newassoc(struct ieee80211com *ic, struct ieee80211_node *ni, int isnew)
! 2726: {
! 2727: struct acx_softc *sc = ic->ic_if.if_softc;
! 2728: int i;
! 2729:
! 2730: ieee80211_amrr_node_init(&sc->amrr, &((struct acx_node *)ni)->amn);
! 2731:
! 2732: /* set rate to some reasonable initial value */
! 2733: for (i = ni->ni_rates.rs_nrates - 1;
! 2734: i > 0 && (ni->ni_rates.rs_rates[i] & IEEE80211_RATE_VAL) > 72;
! 2735: i--);
! 2736: ni->ni_txrate = i;
! 2737: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to acx.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic