Annotation of sys/dev/ic/pgt.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: pgt.c,v 1.43 2007/07/18 18:10:31 damien Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2006 Claudio Jeker <claudio@openbsd.org>
! 5: * Copyright (c) 2006 Marcus Glocker <mglocker@openbsd.org>
! 6: *
! 7: * Permission to use, copy, modify, and distribute this software for any
! 8: * purpose with or without fee is hereby granted, provided that the above
! 9: * copyright notice and this permission notice appear in all copies.
! 10: *
! 11: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
! 12: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 13: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
! 14: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 15: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 16: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
! 17: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 18: */
! 19:
! 20: /*
! 21: * Copyright (c) 2004 Fujitsu Laboratories of America, Inc.
! 22: * Copyright (c) 2004 Brian Fundakowski Feldman
! 23: * All rights reserved.
! 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: * 1. Redistributions of source code must retain the above copyright
! 29: * notice, this list of conditions and the following disclaimer.
! 30: * 2. Redistributions in binary form must reproduce the above copyright
! 31: * notice, this list of conditions and the following disclaimer in the
! 32: * documentation and/or other materials provided with the distribution.
! 33: *
! 34: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
! 35: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 36: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 37: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
! 38: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 39: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 40: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 41: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 42: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 43: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 44: * SUCH DAMAGE.
! 45: */
! 46:
! 47: #include <sys/cdefs.h>
! 48: #include "bpfilter.h"
! 49:
! 50: #include <sys/param.h>
! 51: #include <sys/systm.h>
! 52: #include <sys/kernel.h>
! 53: #include <sys/malloc.h>
! 54: #include <sys/socket.h>
! 55: #include <sys/mbuf.h>
! 56: #include <sys/endian.h>
! 57: #include <sys/sockio.h>
! 58: #include <sys/sysctl.h>
! 59: #include <sys/kthread.h>
! 60: #include <sys/time.h>
! 61: #include <sys/ioctl.h>
! 62: #include <sys/device.h>
! 63:
! 64: #include <machine/bus.h>
! 65: #include <machine/endian.h>
! 66: #include <machine/intr.h>
! 67:
! 68: #include <net/if.h>
! 69: #include <net/if_arp.h>
! 70: #include <net/if_dl.h>
! 71: #include <net/if_llc.h>
! 72: #include <net/if_media.h>
! 73: #include <net/if_types.h>
! 74:
! 75: #if NBPFILTER > 0
! 76: #include <net/bpf.h>
! 77: #endif
! 78:
! 79: #ifdef INET
! 80: #include <netinet/in.h>
! 81: #include <netinet/in_systm.h>
! 82: #include <netinet/in_var.h>
! 83: #include <netinet/if_ether.h>
! 84: #include <netinet/ip.h>
! 85: #endif
! 86:
! 87: #include <net80211/ieee80211_var.h>
! 88: #include <net80211/ieee80211_radiotap.h>
! 89:
! 90: #include <dev/ic/pgtreg.h>
! 91: #include <dev/ic/pgtvar.h>
! 92:
! 93: #include <dev/ic/if_wireg.h>
! 94: #include <dev/ic/if_wi_ieee.h>
! 95: #include <dev/ic/if_wivar.h>
! 96:
! 97: #ifdef PGT_DEBUG
! 98: #define DPRINTF(x) do { printf x; } while (0)
! 99: #else
! 100: #define DPRINTF(x)
! 101: #endif
! 102:
! 103: #define SETOID(oid, var, size) { \
! 104: if (pgt_oid_set(sc, oid, var, size) != 0) \
! 105: break; \
! 106: }
! 107:
! 108: /*
! 109: * This is a driver for the Intersil Prism family of 802.11g network cards,
! 110: * based upon version 1.2 of the Linux driver and firmware found at
! 111: * http://www.prism54.org/.
! 112: */
! 113:
! 114: #define SCAN_TIMEOUT 5 /* 5 seconds */
! 115:
! 116: struct cfdriver pgt_cd = {
! 117: NULL, "pgt", DV_IFNET
! 118: };
! 119:
! 120: void pgt_media_status(struct ifnet *ifp, struct ifmediareq *imr);
! 121: int pgt_media_change(struct ifnet *ifp);
! 122: void pgt_write_memory_barrier(struct pgt_softc *);
! 123: uint32_t pgt_read_4(struct pgt_softc *, uint16_t);
! 124: void pgt_write_4(struct pgt_softc *, uint16_t, uint32_t);
! 125: void pgt_write_4_flush(struct pgt_softc *, uint16_t, uint32_t);
! 126: void pgt_debug_events(struct pgt_softc *, const char *);
! 127: uint32_t pgt_queue_frags_pending(struct pgt_softc *, enum pgt_queue);
! 128: void pgt_reinit_rx_desc_frag(struct pgt_softc *, struct pgt_desc *);
! 129: int pgt_load_tx_desc_frag(struct pgt_softc *, enum pgt_queue,
! 130: struct pgt_desc *);
! 131: void pgt_unload_tx_desc_frag(struct pgt_softc *, struct pgt_desc *);
! 132: int pgt_load_firmware(struct pgt_softc *);
! 133: void pgt_cleanup_queue(struct pgt_softc *, enum pgt_queue,
! 134: struct pgt_frag []);
! 135: int pgt_reset(struct pgt_softc *);
! 136: void pgt_stop(struct pgt_softc *, unsigned int);
! 137: void pgt_reboot(struct pgt_softc *);
! 138: void pgt_init_intr(struct pgt_softc *);
! 139: void pgt_update_intr(struct pgt_softc *, int);
! 140: struct mbuf
! 141: *pgt_ieee80211_encap(struct pgt_softc *, struct ether_header *,
! 142: struct mbuf *, struct ieee80211_node **);
! 143: void pgt_input_frames(struct pgt_softc *, struct mbuf *);
! 144: void pgt_wakeup_intr(struct pgt_softc *);
! 145: void pgt_sleep_intr(struct pgt_softc *);
! 146: void pgt_empty_traps(struct pgt_softc_kthread *);
! 147: void pgt_per_device_kthread(void *);
! 148: void pgt_async_reset(struct pgt_softc *);
! 149: void pgt_async_update(struct pgt_softc *);
! 150: void pgt_txdone(struct pgt_softc *, enum pgt_queue);
! 151: void pgt_rxdone(struct pgt_softc *, enum pgt_queue);
! 152: void pgt_trap_received(struct pgt_softc *, uint32_t, void *, size_t);
! 153: void pgt_mgmtrx_completion(struct pgt_softc *, struct pgt_mgmt_desc *);
! 154: struct mbuf
! 155: *pgt_datarx_completion(struct pgt_softc *, enum pgt_queue);
! 156: int pgt_oid_get(struct pgt_softc *, enum pgt_oid, void *, size_t);
! 157: int pgt_oid_retrieve(struct pgt_softc *, enum pgt_oid, void *, size_t);
! 158: int pgt_oid_set(struct pgt_softc *, enum pgt_oid, const void *, size_t);
! 159: void pgt_state_dump(struct pgt_softc *);
! 160: int pgt_mgmt_request(struct pgt_softc *, struct pgt_mgmt_desc *);
! 161: void pgt_desc_transmit(struct pgt_softc *, enum pgt_queue,
! 162: struct pgt_desc *, uint16_t, int);
! 163: void pgt_maybe_trigger(struct pgt_softc *, enum pgt_queue);
! 164: struct ieee80211_node
! 165: *pgt_ieee80211_node_alloc(struct ieee80211com *);
! 166: void pgt_ieee80211_newassoc(struct ieee80211com *,
! 167: struct ieee80211_node *, int);
! 168: void pgt_ieee80211_node_free(struct ieee80211com *,
! 169: struct ieee80211_node *);
! 170: void pgt_ieee80211_node_copy(struct ieee80211com *,
! 171: struct ieee80211_node *,
! 172: const struct ieee80211_node *);
! 173: int pgt_ieee80211_send_mgmt(struct ieee80211com *,
! 174: struct ieee80211_node *, int, int);
! 175: int pgt_net_attach(struct pgt_softc *);
! 176: void pgt_start(struct ifnet *);
! 177: int pgt_ioctl(struct ifnet *, u_long, caddr_t);
! 178: void pgt_obj_bss2scanres(struct pgt_softc *,
! 179: struct pgt_obj_bss *, struct wi_scan_res *, uint32_t);
! 180: void node_mark_active_ap(void *, struct ieee80211_node *);
! 181: void node_mark_active_adhoc(void *, struct ieee80211_node *);
! 182: void pgt_watchdog(struct ifnet *);
! 183: int pgt_init(struct ifnet *);
! 184: void pgt_update_hw_from_sw(struct pgt_softc *, int, int);
! 185: void pgt_hostap_handle_mlme(struct pgt_softc *, uint32_t,
! 186: struct pgt_obj_mlme *);
! 187: void pgt_update_sw_from_hw(struct pgt_softc *,
! 188: struct pgt_async_trap *, struct mbuf *);
! 189: int pgt_newstate(struct ieee80211com *, enum ieee80211_state, int);
! 190: int pgt_drain_tx_queue(struct pgt_softc *, enum pgt_queue);
! 191: int pgt_dma_alloc(struct pgt_softc *);
! 192: int pgt_dma_alloc_queue(struct pgt_softc *sc, enum pgt_queue pq);
! 193: void pgt_dma_free(struct pgt_softc *);
! 194: void pgt_dma_free_queue(struct pgt_softc *sc, enum pgt_queue pq);
! 195: void pgt_shutdown(void *);
! 196: void pgt_power(int, void *);
! 197:
! 198: void
! 199: pgt_write_memory_barrier(struct pgt_softc *sc)
! 200: {
! 201: bus_space_barrier(sc->sc_iotag, sc->sc_iohandle, 0, 0,
! 202: BUS_SPACE_BARRIER_WRITE);
! 203: }
! 204:
! 205: u_int32_t
! 206: pgt_read_4(struct pgt_softc *sc, uint16_t offset)
! 207: {
! 208: return (bus_space_read_4(sc->sc_iotag, sc->sc_iohandle, offset));
! 209: }
! 210:
! 211: void
! 212: pgt_write_4(struct pgt_softc *sc, uint16_t offset, uint32_t value)
! 213: {
! 214: bus_space_write_4(sc->sc_iotag, sc->sc_iohandle, offset, value);
! 215: }
! 216:
! 217: /*
! 218: * Write out 4 bytes and cause a PCI flush by reading back in on a
! 219: * harmless register.
! 220: */
! 221: void
! 222: pgt_write_4_flush(struct pgt_softc *sc, uint16_t offset, uint32_t value)
! 223: {
! 224: bus_space_write_4(sc->sc_iotag, sc->sc_iohandle, offset, value);
! 225: (void)bus_space_read_4(sc->sc_iotag, sc->sc_iohandle, PGT_REG_INT_EN);
! 226: }
! 227:
! 228: /*
! 229: * Print the state of events in the queues from an interrupt or a trigger.
! 230: */
! 231: void
! 232: pgt_debug_events(struct pgt_softc *sc, const char *when)
! 233: {
! 234: #define COUNT(i) \
! 235: letoh32(sc->sc_cb->pcb_driver_curfrag[i]) - \
! 236: letoh32(sc->sc_cb->pcb_device_curfrag[i])
! 237: if (sc->sc_debug & SC_DEBUG_EVENTS)
! 238: DPRINTF(("%s: ev%s: %u %u %u %u %u %u\n",
! 239: sc->sc_dev.dv_xname, when, COUNT(0), COUNT(1), COUNT(2),
! 240: COUNT(3), COUNT(4), COUNT(5)));
! 241: #undef COUNT
! 242: }
! 243:
! 244: uint32_t
! 245: pgt_queue_frags_pending(struct pgt_softc *sc, enum pgt_queue pq)
! 246: {
! 247: return (letoh32(sc->sc_cb->pcb_driver_curfrag[pq]) -
! 248: letoh32(sc->sc_cb->pcb_device_curfrag[pq]));
! 249: }
! 250:
! 251: void
! 252: pgt_reinit_rx_desc_frag(struct pgt_softc *sc, struct pgt_desc *pd)
! 253: {
! 254: pd->pd_fragp->pf_addr = htole32((uint32_t)pd->pd_dmaaddr);
! 255: pd->pd_fragp->pf_size = htole16(PGT_FRAG_SIZE);
! 256: pd->pd_fragp->pf_flags = 0;
! 257:
! 258: bus_dmamap_sync(sc->sc_dmat, pd->pd_dmam, 0, pd->pd_dmam->dm_mapsize,
! 259: BUS_DMASYNC_POSTWRITE);
! 260: }
! 261:
! 262: int
! 263: pgt_load_tx_desc_frag(struct pgt_softc *sc, enum pgt_queue pq,
! 264: struct pgt_desc *pd)
! 265: {
! 266: int error;
! 267:
! 268: error = bus_dmamap_load(sc->sc_dmat, pd->pd_dmam, pd->pd_mem,
! 269: PGT_FRAG_SIZE, NULL, BUS_DMA_NOWAIT);
! 270: if (error) {
! 271: DPRINTF(("%s: unable to load %s tx DMA: %d\n",
! 272: sc->sc_dev.dv_xname,
! 273: pgt_queue_is_data(pq) ? "data" : "mgmt", error));
! 274: return (error);
! 275: }
! 276: pd->pd_dmaaddr = pd->pd_dmam->dm_segs[0].ds_addr;
! 277: pd->pd_fragp->pf_addr = htole32((uint32_t)pd->pd_dmaaddr);
! 278: pd->pd_fragp->pf_size = htole16(PGT_FRAG_SIZE);
! 279: pd->pd_fragp->pf_flags = htole16(0);
! 280:
! 281: bus_dmamap_sync(sc->sc_dmat, pd->pd_dmam, 0, pd->pd_dmam->dm_mapsize,
! 282: BUS_DMASYNC_POSTWRITE);
! 283:
! 284: return (0);
! 285: }
! 286:
! 287: void
! 288: pgt_unload_tx_desc_frag(struct pgt_softc *sc, struct pgt_desc *pd)
! 289: {
! 290: bus_dmamap_unload(sc->sc_dmat, pd->pd_dmam);
! 291: pd->pd_dmaaddr = 0;
! 292: }
! 293:
! 294: int
! 295: pgt_load_firmware(struct pgt_softc *sc)
! 296: {
! 297: int error, reg, dirreg, fwoff, ucodeoff, fwlen;
! 298: uint8_t *ucode;
! 299: uint32_t *uc;
! 300: size_t size;
! 301: char *name;
! 302:
! 303: if (sc->sc_flags & SC_ISL3877)
! 304: name = "pgt-isl3877";
! 305: else
! 306: name = "pgt-isl3890"; /* includes isl3880 */
! 307:
! 308: error = loadfirmware(name, &ucode, &size);
! 309:
! 310: if (error != 0) {
! 311: DPRINTF(("%s: error %d, could not read microcode %s!\n",
! 312: sc->sc_dev.dv_xname, error, name));
! 313: return (EIO);
! 314: }
! 315:
! 316: if (size & 3) {
! 317: DPRINTF(("%s: bad firmware size %u\n",
! 318: sc->sc_dev.dv_xname, size));
! 319: free(ucode, M_DEVBUF);
! 320: return (EINVAL);
! 321: }
! 322:
! 323: pgt_reboot(sc);
! 324:
! 325: fwoff = 0;
! 326: ucodeoff = 0;
! 327: uc = (uint32_t *)ucode;
! 328: reg = PGT_FIRMWARE_INTERNAL_OFFSET;
! 329: while (fwoff < size) {
! 330: pgt_write_4_flush(sc, PGT_REG_DIR_MEM_BASE, reg);
! 331:
! 332: if ((size - fwoff) >= PGT_DIRECT_MEMORY_SIZE)
! 333: fwlen = PGT_DIRECT_MEMORY_SIZE;
! 334: else
! 335: fwlen = size - fwoff;
! 336:
! 337: dirreg = PGT_DIRECT_MEMORY_OFFSET;
! 338: while (fwlen > 4) {
! 339: pgt_write_4(sc, dirreg, uc[ucodeoff]);
! 340: fwoff += 4;
! 341: dirreg += 4;
! 342: reg += 4;
! 343: fwlen -= 4;
! 344: ucodeoff++;
! 345: }
! 346: pgt_write_4_flush(sc, dirreg, uc[ucodeoff]);
! 347: fwoff += 4;
! 348: dirreg += 4;
! 349: reg += 4;
! 350: fwlen -= 4;
! 351: ucodeoff++;
! 352: }
! 353: DPRINTF(("%s: %d bytes microcode loaded from %s\n",
! 354: sc->sc_dev.dv_xname, fwoff, name));
! 355:
! 356: reg = pgt_read_4(sc, PGT_REG_CTRL_STAT);
! 357: reg &= ~(PGT_CTRL_STAT_RESET | PGT_CTRL_STAT_CLOCKRUN);
! 358: reg |= PGT_CTRL_STAT_RAMBOOT;
! 359: pgt_write_4_flush(sc, PGT_REG_CTRL_STAT, reg);
! 360: pgt_write_memory_barrier(sc);
! 361: DELAY(PGT_WRITEIO_DELAY);
! 362:
! 363: reg |= PGT_CTRL_STAT_RESET;
! 364: pgt_write_4(sc, PGT_REG_CTRL_STAT, reg);
! 365: pgt_write_memory_barrier(sc);
! 366: DELAY(PGT_WRITEIO_DELAY);
! 367:
! 368: reg &= ~PGT_CTRL_STAT_RESET;
! 369: pgt_write_4(sc, PGT_REG_CTRL_STAT, reg);
! 370: pgt_write_memory_barrier(sc);
! 371: DELAY(PGT_WRITEIO_DELAY);
! 372:
! 373: free(ucode, M_DEVBUF);
! 374:
! 375: return (0);
! 376: }
! 377:
! 378: void
! 379: pgt_cleanup_queue(struct pgt_softc *sc, enum pgt_queue pq,
! 380: struct pgt_frag pqfrags[])
! 381: {
! 382: struct pgt_desc *pd;
! 383: unsigned int i;
! 384:
! 385: sc->sc_cb->pcb_device_curfrag[pq] = 0;
! 386: i = 0;
! 387: /* XXX why only freeq ??? */
! 388: TAILQ_FOREACH(pd, &sc->sc_freeq[pq], pd_link) {
! 389: pd->pd_fragnum = i;
! 390: pd->pd_fragp = &pqfrags[i];
! 391: if (pgt_queue_is_rx(pq))
! 392: pgt_reinit_rx_desc_frag(sc, pd);
! 393: i++;
! 394: }
! 395: sc->sc_freeq_count[pq] = i;
! 396: /*
! 397: * The ring buffer describes how many free buffers are available from
! 398: * the host (for receive queues) or how many are pending (for
! 399: * transmit queues).
! 400: */
! 401: if (pgt_queue_is_rx(pq))
! 402: sc->sc_cb->pcb_driver_curfrag[pq] = htole32(i);
! 403: else
! 404: sc->sc_cb->pcb_driver_curfrag[pq] = 0;
! 405: }
! 406:
! 407: /*
! 408: * Turn off interrupts, reset the device (possibly loading firmware),
! 409: * and put everything in a known state.
! 410: */
! 411: int
! 412: pgt_reset(struct pgt_softc *sc)
! 413: {
! 414: int error;
! 415:
! 416: /* disable all interrupts */
! 417: pgt_write_4_flush(sc, PGT_REG_INT_EN, 0);
! 418: DELAY(PGT_WRITEIO_DELAY);
! 419:
! 420: /*
! 421: * Set up the management receive queue, assuming there are no
! 422: * requests in progress.
! 423: */
! 424: bus_dmamap_sync(sc->sc_dmat, sc->sc_cbdmam, 0,
! 425: sc->sc_cbdmam->dm_mapsize,
! 426: BUS_DMASYNC_POSTREAD | BUS_DMASYNC_PREWRITE);
! 427: pgt_cleanup_queue(sc, PGT_QUEUE_DATA_LOW_RX,
! 428: &sc->sc_cb->pcb_data_low_rx[0]);
! 429: pgt_cleanup_queue(sc, PGT_QUEUE_DATA_LOW_TX,
! 430: &sc->sc_cb->pcb_data_low_tx[0]);
! 431: pgt_cleanup_queue(sc, PGT_QUEUE_DATA_HIGH_RX,
! 432: &sc->sc_cb->pcb_data_high_rx[0]);
! 433: pgt_cleanup_queue(sc, PGT_QUEUE_DATA_HIGH_TX,
! 434: &sc->sc_cb->pcb_data_high_tx[0]);
! 435: pgt_cleanup_queue(sc, PGT_QUEUE_MGMT_RX,
! 436: &sc->sc_cb->pcb_mgmt_rx[0]);
! 437: pgt_cleanup_queue(sc, PGT_QUEUE_MGMT_TX,
! 438: &sc->sc_cb->pcb_mgmt_tx[0]);
! 439: bus_dmamap_sync(sc->sc_dmat, sc->sc_cbdmam, 0,
! 440: sc->sc_cbdmam->dm_mapsize,
! 441: BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_PREREAD);
! 442:
! 443: /* load firmware */
! 444: if (sc->sc_flags & SC_NEEDS_FIRMWARE) {
! 445: error = pgt_load_firmware(sc);
! 446: if (error) {
! 447: printf("%s: firmware load failed\n",
! 448: sc->sc_dev.dv_xname);
! 449: return (error);
! 450: }
! 451: sc->sc_flags &= ~SC_NEEDS_FIRMWARE;
! 452: DPRINTF(("%s: firmware loaded\n", sc->sc_dev.dv_xname));
! 453: }
! 454:
! 455: /* upload the control block's DMA address */
! 456: pgt_write_4_flush(sc, PGT_REG_CTRL_BLK_BASE,
! 457: htole32((uint32_t)sc->sc_cbdmam->dm_segs[0].ds_addr));
! 458: DELAY(PGT_WRITEIO_DELAY);
! 459:
! 460: /* send a reset event */
! 461: pgt_write_4_flush(sc, PGT_REG_DEV_INT, PGT_DEV_INT_RESET);
! 462: DELAY(PGT_WRITEIO_DELAY);
! 463:
! 464: /* await only the initialization interrupt */
! 465: pgt_write_4_flush(sc, PGT_REG_INT_EN, PGT_INT_STAT_INIT);
! 466: DELAY(PGT_WRITEIO_DELAY);
! 467:
! 468: return (0);
! 469: }
! 470:
! 471: /*
! 472: * If we're trying to reset and the device has seemingly not been detached,
! 473: * we'll spend a minute seeing if we can't do the reset.
! 474: */
! 475: void
! 476: pgt_stop(struct pgt_softc *sc, unsigned int flag)
! 477: {
! 478: struct ieee80211com *ic;
! 479: unsigned int wokeup;
! 480: int tryagain = 0;
! 481:
! 482: ic = &sc->sc_ic;
! 483:
! 484: ic->ic_if.if_flags &= ~IFF_RUNNING;
! 485: sc->sc_flags |= SC_UNINITIALIZED;
! 486: sc->sc_flags |= flag;
! 487:
! 488: pgt_drain_tx_queue(sc, PGT_QUEUE_DATA_LOW_TX);
! 489: pgt_drain_tx_queue(sc, PGT_QUEUE_DATA_HIGH_TX);
! 490: pgt_drain_tx_queue(sc, PGT_QUEUE_MGMT_TX);
! 491:
! 492: trying_again:
! 493: /* disable all interrupts */
! 494: pgt_write_4_flush(sc, PGT_REG_INT_EN, 0);
! 495: DELAY(PGT_WRITEIO_DELAY);
! 496:
! 497: /* reboot card */
! 498: pgt_reboot(sc);
! 499:
! 500: do {
! 501: wokeup = 0;
! 502: /*
! 503: * We don't expect to be woken up, just to drop the lock
! 504: * and time out. Only tx queues can have anything valid
! 505: * on them outside of an interrupt.
! 506: */
! 507: while (!TAILQ_EMPTY(&sc->sc_mgmtinprog)) {
! 508: struct pgt_mgmt_desc *pmd;
! 509:
! 510: pmd = TAILQ_FIRST(&sc->sc_mgmtinprog);
! 511: TAILQ_REMOVE(&sc->sc_mgmtinprog, pmd, pmd_link);
! 512: pmd->pmd_error = ENETRESET;
! 513: wakeup_one(pmd);
! 514: if (sc->sc_debug & SC_DEBUG_MGMT)
! 515: DPRINTF(("%s: queue: mgmt %p <- %#x "
! 516: "(drained)\n", sc->sc_dev.dv_xname,
! 517: pmd, pmd->pmd_oid));
! 518: wokeup++;
! 519: }
! 520: if (wokeup > 0) {
! 521: if (flag == SC_NEEDS_RESET && sc->sc_flags & SC_DYING) {
! 522: sc->sc_flags &= ~flag;
! 523: return;
! 524: }
! 525: }
! 526: } while (wokeup > 0);
! 527:
! 528: if (flag == SC_NEEDS_RESET) {
! 529: int error;
! 530:
! 531: DPRINTF(("%s: resetting\n", sc->sc_dev.dv_xname));
! 532: sc->sc_flags &= ~SC_POWERSAVE;
! 533: sc->sc_flags |= SC_NEEDS_FIRMWARE;
! 534: error = pgt_reset(sc);
! 535: if (error == 0) {
! 536: tsleep(&sc->sc_flags, 0, "pgtres", hz);
! 537: if (sc->sc_flags & SC_UNINITIALIZED) {
! 538: printf("%s: not responding\n",
! 539: sc->sc_dev.dv_xname);
! 540: /* Thud. It was probably removed. */
! 541: if (tryagain)
! 542: panic("pgt went for lunch"); /* XXX */
! 543: tryagain = 1;
! 544: } else {
! 545: /* await all interrupts */
! 546: pgt_write_4_flush(sc, PGT_REG_INT_EN,
! 547: PGT_INT_STAT_SOURCES);
! 548: DELAY(PGT_WRITEIO_DELAY);
! 549: ic->ic_if.if_flags |= IFF_RUNNING;
! 550: }
! 551: }
! 552:
! 553: if (tryagain)
! 554: goto trying_again;
! 555:
! 556: sc->sc_flags &= ~flag;
! 557: if (ic->ic_if.if_flags & IFF_RUNNING)
! 558: pgt_update_hw_from_sw(sc,
! 559: ic->ic_state != IEEE80211_S_INIT,
! 560: ic->ic_opmode != IEEE80211_M_MONITOR);
! 561: }
! 562:
! 563: ic->ic_if.if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
! 564: ieee80211_new_state(&sc->sc_ic, IEEE80211_S_INIT, -1);
! 565: }
! 566:
! 567: void
! 568: pgt_attach(void *xsc)
! 569: {
! 570: struct pgt_softc *sc = xsc;
! 571: int error;
! 572:
! 573: /* debug flags */
! 574: //sc->sc_debug |= SC_DEBUG_QUEUES; /* super verbose */
! 575: //sc->sc_debug |= SC_DEBUG_MGMT;
! 576: sc->sc_debug |= SC_DEBUG_UNEXPECTED;
! 577: //sc->sc_debug |= SC_DEBUG_TRIGGER; /* verbose */
! 578: //sc->sc_debug |= SC_DEBUG_EVENTS; /* super verbose */
! 579: //sc->sc_debug |= SC_DEBUG_POWER;
! 580: sc->sc_debug |= SC_DEBUG_TRAP;
! 581: sc->sc_debug |= SC_DEBUG_LINK;
! 582: //sc->sc_debug |= SC_DEBUG_RXANNEX;
! 583: //sc->sc_debug |= SC_DEBUG_RXFRAG;
! 584: //sc->sc_debug |= SC_DEBUG_RXETHER;
! 585:
! 586: /* enable card if possible */
! 587: if (sc->sc_enable != NULL)
! 588: (*sc->sc_enable)(sc);
! 589:
! 590: error = pgt_dma_alloc(sc);
! 591: if (error)
! 592: return;
! 593:
! 594: sc->sc_ic.ic_if.if_softc = sc;
! 595: TAILQ_INIT(&sc->sc_mgmtinprog);
! 596: TAILQ_INIT(&sc->sc_kthread.sck_traps);
! 597: sc->sc_flags |= SC_NEEDS_FIRMWARE | SC_UNINITIALIZED;
! 598: sc->sc_80211_ioc_auth = IEEE80211_AUTH_OPEN;
! 599:
! 600: error = pgt_reset(sc);
! 601: if (error)
! 602: return;
! 603:
! 604: tsleep(&sc->sc_flags, 0, "pgtres", hz);
! 605: if (sc->sc_flags & SC_UNINITIALIZED) {
! 606: printf("%s: not responding\n", sc->sc_dev.dv_xname);
! 607: return;
! 608: } else {
! 609: /* await all interrupts */
! 610: pgt_write_4_flush(sc, PGT_REG_INT_EN, PGT_INT_STAT_SOURCES);
! 611: DELAY(PGT_WRITEIO_DELAY);
! 612: }
! 613:
! 614: error = pgt_net_attach(sc);
! 615: if (error)
! 616: return;
! 617:
! 618: if (kthread_create(pgt_per_device_kthread, sc, NULL,
! 619: sc->sc_dev.dv_xname) != 0)
! 620: return;
! 621:
! 622: ieee80211_new_state(&sc->sc_ic, IEEE80211_S_INIT, -1);
! 623: }
! 624:
! 625: int
! 626: pgt_detach(struct pgt_softc *sc)
! 627: {
! 628: if (sc->sc_flags & SC_NEEDS_FIRMWARE || sc->sc_flags & SC_UNINITIALIZED)
! 629: /* device was not initialized correctly, so leave early */
! 630: goto out;
! 631:
! 632: /* stop card */
! 633: pgt_stop(sc, SC_DYING);
! 634: pgt_reboot(sc);
! 635:
! 636: /*
! 637: * Disable shutdown and power hooks
! 638: */
! 639: if (sc->sc_shutdown_hook != NULL)
! 640: shutdownhook_disestablish(sc->sc_shutdown_hook);
! 641: if (sc->sc_power_hook != NULL)
! 642: powerhook_disestablish(sc->sc_power_hook);
! 643:
! 644: ieee80211_ifdetach(&sc->sc_ic.ic_if);
! 645: if_detach(&sc->sc_ic.ic_if);
! 646:
! 647: out:
! 648: /* disable card if possible */
! 649: if (sc->sc_disable != NULL)
! 650: (*sc->sc_disable)(sc);
! 651:
! 652: pgt_dma_free(sc);
! 653:
! 654: return (0);
! 655: }
! 656:
! 657: void
! 658: pgt_reboot(struct pgt_softc *sc)
! 659: {
! 660: uint32_t reg;
! 661:
! 662: reg = pgt_read_4(sc, PGT_REG_CTRL_STAT);
! 663: reg &= ~(PGT_CTRL_STAT_RESET | PGT_CTRL_STAT_RAMBOOT);
! 664: pgt_write_4(sc, PGT_REG_CTRL_STAT, reg);
! 665: pgt_write_memory_barrier(sc);
! 666: DELAY(PGT_WRITEIO_DELAY);
! 667:
! 668: reg |= PGT_CTRL_STAT_RESET;
! 669: pgt_write_4(sc, PGT_REG_CTRL_STAT, reg);
! 670: pgt_write_memory_barrier(sc);
! 671: DELAY(PGT_WRITEIO_DELAY);
! 672:
! 673: reg &= ~PGT_CTRL_STAT_RESET;
! 674: pgt_write_4(sc, PGT_REG_CTRL_STAT, reg);
! 675: pgt_write_memory_barrier(sc);
! 676: DELAY(PGT_RESET_DELAY);
! 677: }
! 678:
! 679: void
! 680: pgt_init_intr(struct pgt_softc *sc)
! 681: {
! 682: if ((sc->sc_flags & SC_UNINITIALIZED) == 0) {
! 683: if (sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 684: DPRINTF(("%s: spurious initialization\n",
! 685: sc->sc_dev.dv_xname));
! 686: } else {
! 687: sc->sc_flags &= ~SC_UNINITIALIZED;
! 688: wakeup(&sc->sc_flags);
! 689: }
! 690: }
! 691:
! 692: /*
! 693: * If called with a NULL last_nextpkt, only the mgmt queue will be checked
! 694: * for new packets.
! 695: */
! 696: void
! 697: pgt_update_intr(struct pgt_softc *sc, int hack)
! 698: {
! 699: /* priority order */
! 700: enum pgt_queue pqs[PGT_QUEUE_COUNT] = {
! 701: PGT_QUEUE_MGMT_TX, PGT_QUEUE_MGMT_RX,
! 702: PGT_QUEUE_DATA_HIGH_TX, PGT_QUEUE_DATA_HIGH_RX,
! 703: PGT_QUEUE_DATA_LOW_TX, PGT_QUEUE_DATA_LOW_RX
! 704: };
! 705: struct mbuf *m;
! 706: uint32_t npend;
! 707: unsigned int dirtycount;
! 708: int i;
! 709:
! 710: bus_dmamap_sync(sc->sc_dmat, sc->sc_cbdmam, 0,
! 711: sc->sc_cbdmam->dm_mapsize,
! 712: BUS_DMASYNC_POSTREAD | BUS_DMASYNC_PREWRITE);
! 713: pgt_debug_events(sc, "intr");
! 714: /*
! 715: * Check for completion of tx in their dirty queues.
! 716: * Check completion of rx into their dirty queues.
! 717: */
! 718: for (i = 0; i < PGT_QUEUE_COUNT; i++) {
! 719: size_t qdirty, qfree, qtotal;
! 720:
! 721: qdirty = sc->sc_dirtyq_count[pqs[i]];
! 722: qfree = sc->sc_freeq_count[pqs[i]];
! 723: qtotal = qdirty + qfree;
! 724: /*
! 725: * We want the wrap-around here.
! 726: */
! 727: if (pgt_queue_is_rx(pqs[i])) {
! 728: int data;
! 729:
! 730: data = pgt_queue_is_data(pqs[i]);
! 731: #ifdef PGT_BUGGY_INTERRUPT_RECOVERY
! 732: if (hack && data)
! 733: continue;
! 734: #endif
! 735: npend = pgt_queue_frags_pending(sc, pqs[i]);
! 736: /*
! 737: * Receive queues clean up below, so qfree must
! 738: * always be qtotal (qdirty is 0).
! 739: */
! 740: if (npend > qfree) {
! 741: if (sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 742: DPRINTF(("%s: rx queue [%u] "
! 743: "overflowed by %u\n",
! 744: sc->sc_dev.dv_xname, pqs[i],
! 745: npend - qfree));
! 746: sc->sc_flags |= SC_INTR_RESET;
! 747: break;
! 748: }
! 749: while (qfree-- > npend)
! 750: pgt_rxdone(sc, pqs[i]);
! 751: } else {
! 752: npend = pgt_queue_frags_pending(sc, pqs[i]);
! 753: if (npend > qdirty) {
! 754: if (sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 755: DPRINTF(("%s: tx queue [%u] "
! 756: "underflowed by %u\n",
! 757: sc->sc_dev.dv_xname, pqs[i],
! 758: npend - qdirty));
! 759: sc->sc_flags |= SC_INTR_RESET;
! 760: break;
! 761: }
! 762: /*
! 763: * If the free queue was empty, or the data transmit
! 764: * queue just became empty, wake up any waiters.
! 765: */
! 766: if (qdirty > npend) {
! 767: if (pgt_queue_is_data(pqs[i])) {
! 768: sc->sc_ic.ic_if.if_timer = 0;
! 769: sc->sc_ic.ic_if.if_flags &=
! 770: ~IFF_OACTIVE;
! 771: }
! 772: while (qdirty-- > npend)
! 773: pgt_txdone(sc, pqs[i]);
! 774: }
! 775: }
! 776: }
! 777:
! 778: /*
! 779: * This is the deferred completion for received management frames
! 780: * and where we queue network frames for stack input.
! 781: */
! 782: dirtycount = sc->sc_dirtyq_count[PGT_QUEUE_MGMT_RX];
! 783: while (!TAILQ_EMPTY(&sc->sc_dirtyq[PGT_QUEUE_MGMT_RX])) {
! 784: struct pgt_mgmt_desc *pmd;
! 785:
! 786: pmd = TAILQ_FIRST(&sc->sc_mgmtinprog);
! 787: /*
! 788: * If there is no mgmt request in progress or the operation
! 789: * returned is explicitly a trap, this pmd will essentially
! 790: * be ignored.
! 791: */
! 792: pgt_mgmtrx_completion(sc, pmd);
! 793: }
! 794: sc->sc_cb->pcb_driver_curfrag[PGT_QUEUE_MGMT_RX] =
! 795: htole32(dirtycount +
! 796: letoh32(sc->sc_cb->pcb_driver_curfrag[PGT_QUEUE_MGMT_RX]));
! 797:
! 798: dirtycount = sc->sc_dirtyq_count[PGT_QUEUE_DATA_HIGH_RX];
! 799: while (!TAILQ_EMPTY(&sc->sc_dirtyq[PGT_QUEUE_DATA_HIGH_RX])) {
! 800: if ((m = pgt_datarx_completion(sc, PGT_QUEUE_DATA_HIGH_RX)))
! 801: pgt_input_frames(sc, m);
! 802: }
! 803: sc->sc_cb->pcb_driver_curfrag[PGT_QUEUE_DATA_HIGH_RX] =
! 804: htole32(dirtycount +
! 805: letoh32(sc->sc_cb->pcb_driver_curfrag[PGT_QUEUE_DATA_HIGH_RX]));
! 806:
! 807: dirtycount = sc->sc_dirtyq_count[PGT_QUEUE_DATA_LOW_RX];
! 808: while (!TAILQ_EMPTY(&sc->sc_dirtyq[PGT_QUEUE_DATA_LOW_RX])) {
! 809: if ((m = pgt_datarx_completion(sc, PGT_QUEUE_DATA_LOW_RX)))
! 810: pgt_input_frames(sc, m);
! 811: }
! 812: sc->sc_cb->pcb_driver_curfrag[PGT_QUEUE_DATA_LOW_RX] =
! 813: htole32(dirtycount +
! 814: letoh32(sc->sc_cb->pcb_driver_curfrag[PGT_QUEUE_DATA_LOW_RX]));
! 815:
! 816: /*
! 817: * Write out what we've finished with.
! 818: */
! 819: bus_dmamap_sync(sc->sc_dmat, sc->sc_cbdmam, 0,
! 820: sc->sc_cbdmam->dm_mapsize,
! 821: BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_PREREAD);
! 822: }
! 823:
! 824: struct mbuf *
! 825: pgt_ieee80211_encap(struct pgt_softc *sc, struct ether_header *eh,
! 826: struct mbuf *m, struct ieee80211_node **ni)
! 827: {
! 828: struct ieee80211com *ic;
! 829: struct ieee80211_frame *frame;
! 830: struct llc *snap;
! 831:
! 832: ic = &sc->sc_ic;
! 833: if (ni != NULL && ic->ic_opmode == IEEE80211_M_MONITOR) {
! 834: *ni = ieee80211_ref_node(ic->ic_bss);
! 835: (*ni)->ni_inact = 0;
! 836: return (m);
! 837: }
! 838:
! 839: M_PREPEND(m, sizeof(*frame) + sizeof(*snap), M_DONTWAIT);
! 840: if (m != NULL)
! 841: m = m_pullup(m, sizeof(*frame) + sizeof(*snap));
! 842: if (m == NULL)
! 843: return (m);
! 844: frame = mtod(m, struct ieee80211_frame *);
! 845: snap = (struct llc *)&frame[1];
! 846: if (ni != NULL) {
! 847: if (ic->ic_opmode == IEEE80211_M_STA) {
! 848: *ni = ieee80211_ref_node(ic->ic_bss);
! 849: } else {
! 850: *ni = ieee80211_find_node(ic, eh->ether_shost);
! 851: /*
! 852: * Make up associations for ad-hoc mode. To support
! 853: * ad-hoc WPA, we'll need to maintain a bounded
! 854: * pool of ad-hoc stations.
! 855: */
! 856: if (*ni == NULL &&
! 857: ic->ic_opmode != IEEE80211_M_HOSTAP) {
! 858: *ni = ieee80211_dup_bss(ic, eh->ether_shost);
! 859: if (*ni != NULL) {
! 860: (*ni)->ni_associd = 1;
! 861: ic->ic_newassoc(ic, *ni, 1);
! 862: }
! 863: }
! 864: if (*ni == NULL) {
! 865: m_freem(m);
! 866: return (NULL);
! 867: }
! 868: }
! 869: (*ni)->ni_inact = 0;
! 870: }
! 871: snap->llc_dsap = snap->llc_ssap = LLC_SNAP_LSAP;
! 872: snap->llc_control = LLC_UI;
! 873: snap->llc_snap.org_code[0] = 0;
! 874: snap->llc_snap.org_code[1] = 0;
! 875: snap->llc_snap.org_code[2] = 0;
! 876: snap->llc_snap.ether_type = eh->ether_type;
! 877: frame->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_DATA;
! 878: /* Doesn't look like much of the 802.11 header is available. */
! 879: *(uint16_t *)frame->i_dur = *(uint16_t *)frame->i_seq = 0;
! 880: /*
! 881: * Translate the addresses; WDS is not handled.
! 882: */
! 883: switch (ic->ic_opmode) {
! 884: case IEEE80211_M_STA:
! 885: frame->i_fc[1] = IEEE80211_FC1_DIR_FROMDS;
! 886: IEEE80211_ADDR_COPY(frame->i_addr1, eh->ether_dhost);
! 887: IEEE80211_ADDR_COPY(frame->i_addr2, ic->ic_bss->ni_bssid);
! 888: IEEE80211_ADDR_COPY(frame->i_addr3, eh->ether_shost);
! 889: break;
! 890: case IEEE80211_M_IBSS:
! 891: case IEEE80211_M_AHDEMO:
! 892: frame->i_fc[1] = IEEE80211_FC1_DIR_NODS;
! 893: IEEE80211_ADDR_COPY(frame->i_addr1, eh->ether_dhost);
! 894: IEEE80211_ADDR_COPY(frame->i_addr2, eh->ether_shost);
! 895: IEEE80211_ADDR_COPY(frame->i_addr3, ic->ic_bss->ni_bssid);
! 896: break;
! 897: case IEEE80211_M_HOSTAP:
! 898: /* HostAP forwarding defaults to being done on firmware. */
! 899: frame->i_fc[1] = IEEE80211_FC1_DIR_TODS;
! 900: IEEE80211_ADDR_COPY(frame->i_addr1, ic->ic_bss->ni_bssid);
! 901: IEEE80211_ADDR_COPY(frame->i_addr2, eh->ether_shost);
! 902: IEEE80211_ADDR_COPY(frame->i_addr3, eh->ether_dhost);
! 903: break;
! 904: default:
! 905: break;
! 906: }
! 907: return (m);
! 908: }
! 909:
! 910: void
! 911: pgt_input_frames(struct pgt_softc *sc, struct mbuf *m)
! 912: {
! 913: struct ether_header eh;
! 914: struct ifnet *ifp;
! 915: struct ieee80211_channel *chan;
! 916: struct ieee80211_node *ni;
! 917: struct ieee80211com *ic;
! 918: struct pgt_rx_annex *pra;
! 919: struct pgt_rx_header *pha;
! 920: struct mbuf *next;
! 921: unsigned int n;
! 922: uint32_t rstamp;
! 923: uint8_t rate, rssi;
! 924:
! 925: ic = &sc->sc_ic;
! 926: ifp = &ic->ic_if;
! 927: for (next = m; m != NULL; m = next) {
! 928: next = m->m_nextpkt;
! 929: m->m_nextpkt = NULL;
! 930:
! 931: if (ic->ic_opmode == IEEE80211_M_MONITOR) {
! 932: if (m->m_len < sizeof(*pha)) {
! 933: m = m_pullup(m, sizeof(*pha));
! 934: if (m == NULL) {
! 935: if (sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 936: DPRINTF(("%s: m_pullup "
! 937: "failure\n",
! 938: sc->sc_dev.dv_xname));
! 939: ifp->if_ierrors++;
! 940: continue;
! 941: }
! 942: }
! 943: pha = mtod(m, struct pgt_rx_header *);
! 944: pra = NULL;
! 945: goto input;
! 946: }
! 947:
! 948: if (m->m_len < sizeof(*pra)) {
! 949: m = m_pullup(m, sizeof(*pra));
! 950: if (m == NULL) {
! 951: if (sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 952: DPRINTF(("%s: m_pullup failure\n",
! 953: sc->sc_dev.dv_xname));
! 954: ifp->if_ierrors++;
! 955: continue;
! 956: }
! 957: }
! 958: pra = mtod(m, struct pgt_rx_annex *);
! 959: pha = &pra->pra_header;
! 960: if (sc->sc_debug & SC_DEBUG_RXANNEX)
! 961: DPRINTF(("%s: rx annex: ? %04x "
! 962: "len %u clock %u flags %02x ? %02x rate %u ? %02x "
! 963: "freq %u ? %04x rssi %u pad %02x%02x%02x\n",
! 964: sc->sc_dev.dv_xname,
! 965: letoh16(pha->pra_unknown0),
! 966: letoh16(pha->pra_length),
! 967: letoh32(pha->pra_clock), pha->pra_flags,
! 968: pha->pra_unknown1, pha->pra_rate,
! 969: pha->pra_unknown2, letoh32(pha->pra_frequency),
! 970: pha->pra_unknown3, pha->pra_rssi,
! 971: pha->pra_pad[0], pha->pra_pad[1], pha->pra_pad[2]));
! 972: if (sc->sc_debug & SC_DEBUG_RXETHER)
! 973: DPRINTF(("%s: rx ether: %s < %s 0x%04x\n",
! 974: sc->sc_dev.dv_xname,
! 975: ether_sprintf(pra->pra_ether_dhost),
! 976: ether_sprintf(pra->pra_ether_shost),
! 977: ntohs(pra->pra_ether_type)));
! 978:
! 979: memcpy(eh.ether_dhost, pra->pra_ether_dhost, ETHER_ADDR_LEN);
! 980: memcpy(eh.ether_shost, pra->pra_ether_shost, ETHER_ADDR_LEN);
! 981: eh.ether_type = pra->pra_ether_type;
! 982:
! 983: input:
! 984: /*
! 985: * This flag is set if e.g. packet could not be decrypted.
! 986: */
! 987: if (pha->pra_flags & PRA_FLAG_BAD) {
! 988: ifp->if_ierrors++;
! 989: m_freem(m);
! 990: continue;
! 991: }
! 992:
! 993: /*
! 994: * After getting what we want, chop off the annex, then
! 995: * turn into something that looks like it really was
! 996: * 802.11.
! 997: */
! 998: rssi = pha->pra_rssi;
! 999: rstamp = letoh32(pha->pra_clock);
! 1000: rate = pha->pra_rate;
! 1001: n = ieee80211_mhz2ieee(letoh32(pha->pra_frequency), 0);
! 1002: if (n <= IEEE80211_CHAN_MAX)
! 1003: chan = &ic->ic_channels[n];
! 1004: else
! 1005: chan = ic->ic_bss->ni_chan;
! 1006: /* Send to 802.3 listeners. */
! 1007: if (pra) {
! 1008: m_adj(m, sizeof(*pra));
! 1009: } else
! 1010: m_adj(m, sizeof(*pha));
! 1011:
! 1012: m = pgt_ieee80211_encap(sc, &eh, m, &ni);
! 1013: if (m != NULL) {
! 1014: #if NBPFILTER > 0
! 1015: if (sc->sc_drvbpf != NULL) {
! 1016: struct mbuf mb;
! 1017: struct pgt_rx_radiotap_hdr *tap = &sc->sc_rxtap;
! 1018:
! 1019: tap->wr_flags = 0;
! 1020: tap->wr_chan_freq = htole16(chan->ic_freq);
! 1021: tap->wr_chan_flags = htole16(chan->ic_flags);
! 1022: tap->wr_rssi = rssi;
! 1023: tap->wr_max_rssi = ic->ic_max_rssi;
! 1024:
! 1025: mb.m_data = (caddr_t)tap;
! 1026: mb.m_len = sc->sc_rxtap_len;
! 1027: mb.m_next = m;
! 1028: mb.m_nextpkt = NULL;
! 1029: mb.m_type = 0;
! 1030: mb.m_flags = 0;
! 1031: bpf_mtap(sc->sc_drvbpf, &mb, BPF_DIRECTION_IN);
! 1032: }
! 1033: #endif
! 1034: ni->ni_rssi = rssi;
! 1035: ni->ni_rstamp = rstamp;
! 1036: ieee80211_input(ifp, m, ni, rssi, rstamp);
! 1037: /*
! 1038: * The frame may have caused the node to be marked for
! 1039: * reclamation (e.g. in response to a DEAUTH message)
! 1040: * so use free_node here instead of unref_node.
! 1041: */
! 1042: if (ni == ic->ic_bss)
! 1043: ieee80211_unref_node(&ni);
! 1044: else
! 1045: ieee80211_release_node(&sc->sc_ic, ni);
! 1046: } else {
! 1047: ifp->if_ierrors++;
! 1048: }
! 1049: }
! 1050: }
! 1051:
! 1052: void
! 1053: pgt_wakeup_intr(struct pgt_softc *sc)
! 1054: {
! 1055: int shouldupdate;
! 1056: int i;
! 1057:
! 1058: shouldupdate = 0;
! 1059: /* Check for any queues being empty before updating. */
! 1060: bus_dmamap_sync(sc->sc_dmat, sc->sc_cbdmam, 0,
! 1061: sc->sc_cbdmam->dm_mapsize,
! 1062: BUS_DMASYNC_POSTREAD);
! 1063: for (i = 0; !shouldupdate && i < PGT_QUEUE_COUNT; i++) {
! 1064: if (pgt_queue_is_tx(i))
! 1065: shouldupdate = pgt_queue_frags_pending(sc, i);
! 1066: else
! 1067: shouldupdate = pgt_queue_frags_pending(sc, i) <
! 1068: sc->sc_freeq_count[i];
! 1069: }
! 1070: if (!TAILQ_EMPTY(&sc->sc_mgmtinprog))
! 1071: shouldupdate = 1;
! 1072: if (sc->sc_debug & SC_DEBUG_POWER)
! 1073: DPRINTF(("%s: wakeup interrupt (update = %d)\n",
! 1074: sc->sc_dev.dv_xname, shouldupdate));
! 1075: sc->sc_flags &= ~SC_POWERSAVE;
! 1076: if (shouldupdate) {
! 1077: pgt_write_4_flush(sc, PGT_REG_DEV_INT, PGT_DEV_INT_UPDATE);
! 1078: DELAY(PGT_WRITEIO_DELAY);
! 1079: }
! 1080: }
! 1081:
! 1082: void
! 1083: pgt_sleep_intr(struct pgt_softc *sc)
! 1084: {
! 1085: int allowed;
! 1086: int i;
! 1087:
! 1088: allowed = 1;
! 1089: /* Check for any queues not being empty before allowing. */
! 1090: bus_dmamap_sync(sc->sc_dmat, sc->sc_cbdmam, 0,
! 1091: sc->sc_cbdmam->dm_mapsize,
! 1092: BUS_DMASYNC_POSTREAD);
! 1093: for (i = 0; allowed && i < PGT_QUEUE_COUNT; i++) {
! 1094: if (pgt_queue_is_tx(i))
! 1095: allowed = pgt_queue_frags_pending(sc, i) == 0;
! 1096: else
! 1097: allowed = pgt_queue_frags_pending(sc, i) >=
! 1098: sc->sc_freeq_count[i];
! 1099: }
! 1100: if (!TAILQ_EMPTY(&sc->sc_mgmtinprog))
! 1101: allowed = 0;
! 1102: if (sc->sc_debug & SC_DEBUG_POWER)
! 1103: DPRINTF(("%s: sleep interrupt (allowed = %d)\n",
! 1104: sc->sc_dev.dv_xname, allowed));
! 1105: if (allowed && sc->sc_ic.ic_flags & IEEE80211_F_PMGTON) {
! 1106: sc->sc_flags |= SC_POWERSAVE;
! 1107: pgt_write_4_flush(sc, PGT_REG_DEV_INT, PGT_DEV_INT_SLEEP);
! 1108: DELAY(PGT_WRITEIO_DELAY);
! 1109: }
! 1110: }
! 1111:
! 1112: void
! 1113: pgt_empty_traps(struct pgt_softc_kthread *sck)
! 1114: {
! 1115: struct pgt_async_trap *pa;
! 1116: struct mbuf *m;
! 1117:
! 1118: while (!TAILQ_EMPTY(&sck->sck_traps)) {
! 1119: pa = TAILQ_FIRST(&sck->sck_traps);
! 1120: TAILQ_REMOVE(&sck->sck_traps, pa, pa_link);
! 1121: m = pa->pa_mbuf;
! 1122: m_freem(m);
! 1123: }
! 1124: }
! 1125:
! 1126: void
! 1127: pgt_per_device_kthread(void *argp)
! 1128: {
! 1129: struct pgt_softc *sc;
! 1130: struct pgt_softc_kthread *sck;
! 1131: struct pgt_async_trap *pa;
! 1132: struct mbuf *m;
! 1133: int s;
! 1134:
! 1135: sc = argp;
! 1136: sck = &sc->sc_kthread;
! 1137: while (!sck->sck_exit) {
! 1138: if (!sck->sck_update && !sck->sck_reset &&
! 1139: TAILQ_EMPTY(&sck->sck_traps))
! 1140: tsleep(&sc->sc_kthread, 0, "pgtkth", 0);
! 1141: if (sck->sck_reset) {
! 1142: DPRINTF(("%s: [thread] async reset\n",
! 1143: sc->sc_dev.dv_xname));
! 1144: sck->sck_reset = 0;
! 1145: sck->sck_update = 0;
! 1146: pgt_empty_traps(sck);
! 1147: s = splnet();
! 1148: pgt_stop(sc, SC_NEEDS_RESET);
! 1149: splx(s);
! 1150: } else if (!TAILQ_EMPTY(&sck->sck_traps)) {
! 1151: DPRINTF(("%s: [thread] got a trap\n",
! 1152: sc->sc_dev.dv_xname));
! 1153: pa = TAILQ_FIRST(&sck->sck_traps);
! 1154: TAILQ_REMOVE(&sck->sck_traps, pa, pa_link);
! 1155: m = pa->pa_mbuf;
! 1156: m_adj(m, sizeof(*pa));
! 1157: pgt_update_sw_from_hw(sc, pa, m);
! 1158: m_freem(m);
! 1159: } else if (sck->sck_update) {
! 1160: sck->sck_update = 0;
! 1161: pgt_update_sw_from_hw(sc, NULL, NULL);
! 1162: }
! 1163: }
! 1164: pgt_empty_traps(sck);
! 1165: kthread_exit(0);
! 1166: }
! 1167:
! 1168: void
! 1169: pgt_async_reset(struct pgt_softc *sc)
! 1170: {
! 1171: if (sc->sc_flags & (SC_DYING | SC_NEEDS_RESET))
! 1172: return;
! 1173: sc->sc_kthread.sck_reset = 1;
! 1174: wakeup(&sc->sc_kthread);
! 1175: }
! 1176:
! 1177: void
! 1178: pgt_async_update(struct pgt_softc *sc)
! 1179: {
! 1180: if (sc->sc_flags & SC_DYING)
! 1181: return;
! 1182: sc->sc_kthread.sck_update = 1;
! 1183: wakeup(&sc->sc_kthread);
! 1184: }
! 1185:
! 1186: int
! 1187: pgt_intr(void *arg)
! 1188: {
! 1189: struct pgt_softc *sc;
! 1190: struct ifnet *ifp;
! 1191: u_int32_t reg;
! 1192:
! 1193: sc = arg;
! 1194: ifp = &sc->sc_ic.ic_if;
! 1195:
! 1196: /*
! 1197: * Here the Linux driver ands in the value of the INT_EN register,
! 1198: * and masks off everything but the documented interrupt bits. Why?
! 1199: *
! 1200: * Unknown bit 0x4000 is set upon initialization, 0x8000000 some
! 1201: * other times.
! 1202: */
! 1203: if (sc->sc_ic.ic_flags & IEEE80211_F_PMGTON &&
! 1204: sc->sc_flags & SC_POWERSAVE) {
! 1205: /*
! 1206: * Don't try handling the interrupt in sleep mode.
! 1207: */
! 1208: reg = pgt_read_4(sc, PGT_REG_CTRL_STAT);
! 1209: if (reg & PGT_CTRL_STAT_SLEEPMODE)
! 1210: return (0);
! 1211: }
! 1212: reg = pgt_read_4(sc, PGT_REG_INT_STAT);
! 1213: if (reg == 0)
! 1214: return (0); /* This interrupt is not from us */
! 1215:
! 1216: pgt_write_4_flush(sc, PGT_REG_INT_ACK, reg);
! 1217: if (reg & PGT_INT_STAT_INIT)
! 1218: pgt_init_intr(sc);
! 1219: if (reg & PGT_INT_STAT_UPDATE) {
! 1220: pgt_update_intr(sc, 0);
! 1221: /*
! 1222: * If we got an update, it's not really asleep.
! 1223: */
! 1224: sc->sc_flags &= ~SC_POWERSAVE;
! 1225: /*
! 1226: * Pretend I have any idea what the documentation
! 1227: * would say, and just give it a shot sending an
! 1228: * "update" after acknowledging the interrupt
! 1229: * bits and writing out the new control block.
! 1230: */
! 1231: pgt_write_4_flush(sc, PGT_REG_DEV_INT, PGT_DEV_INT_UPDATE);
! 1232: DELAY(PGT_WRITEIO_DELAY);
! 1233: }
! 1234: if (reg & PGT_INT_STAT_SLEEP && !(reg & PGT_INT_STAT_WAKEUP))
! 1235: pgt_sleep_intr(sc);
! 1236: if (reg & PGT_INT_STAT_WAKEUP)
! 1237: pgt_wakeup_intr(sc);
! 1238:
! 1239: if (sc->sc_flags & SC_INTR_RESET) {
! 1240: sc->sc_flags &= ~SC_INTR_RESET;
! 1241: pgt_async_reset(sc);
! 1242: }
! 1243:
! 1244: if (reg & ~PGT_INT_STAT_SOURCES && sc->sc_debug & SC_DEBUG_UNEXPECTED) {
! 1245: DPRINTF(("%s: unknown interrupt bits %#x (stat %#x)\n",
! 1246: sc->sc_dev.dv_xname,
! 1247: reg & ~PGT_INT_STAT_SOURCES,
! 1248: pgt_read_4(sc, PGT_REG_CTRL_STAT)));
! 1249: }
! 1250:
! 1251: if (!IFQ_IS_EMPTY(&ifp->if_snd))
! 1252: pgt_start(ifp);
! 1253:
! 1254: return (1);
! 1255: }
! 1256:
! 1257: void
! 1258: pgt_txdone(struct pgt_softc *sc, enum pgt_queue pq)
! 1259: {
! 1260: struct pgt_desc *pd;
! 1261:
! 1262: pd = TAILQ_FIRST(&sc->sc_dirtyq[pq]);
! 1263: TAILQ_REMOVE(&sc->sc_dirtyq[pq], pd, pd_link);
! 1264: sc->sc_dirtyq_count[pq]--;
! 1265: TAILQ_INSERT_TAIL(&sc->sc_freeq[pq], pd, pd_link);
! 1266: sc->sc_freeq_count[pq]++;
! 1267: bus_dmamap_sync(sc->sc_dmat, pd->pd_dmam, 0,
! 1268: pd->pd_dmam->dm_mapsize,
! 1269: BUS_DMASYNC_POSTREAD);
! 1270: /* Management frames want completion information. */
! 1271: if (sc->sc_debug & SC_DEBUG_QUEUES) {
! 1272: DPRINTF(("%s: queue: tx %u <- [%u]\n",
! 1273: sc->sc_dev.dv_xname, pd->pd_fragnum, pq));
! 1274: if (sc->sc_debug & SC_DEBUG_MGMT && pgt_queue_is_mgmt(pq)) {
! 1275: struct pgt_mgmt_frame *pmf;
! 1276:
! 1277: pmf = (struct pgt_mgmt_frame *)pd->pd_mem;
! 1278: DPRINTF(("%s: queue: txmgmt %p <- "
! 1279: "(ver %u, op %u, flags %#x)\n",
! 1280: sc->sc_dev.dv_xname,
! 1281: pd, pmf->pmf_version, pmf->pmf_operation,
! 1282: pmf->pmf_flags));
! 1283: }
! 1284: }
! 1285: pgt_unload_tx_desc_frag(sc, pd);
! 1286: }
! 1287:
! 1288: void
! 1289: pgt_rxdone(struct pgt_softc *sc, enum pgt_queue pq)
! 1290: {
! 1291: struct pgt_desc *pd;
! 1292:
! 1293: pd = TAILQ_FIRST(&sc->sc_freeq[pq]);
! 1294: TAILQ_REMOVE(&sc->sc_freeq[pq], pd, pd_link);
! 1295: sc->sc_freeq_count[pq]--;
! 1296: TAILQ_INSERT_TAIL(&sc->sc_dirtyq[pq], pd, pd_link);
! 1297: sc->sc_dirtyq_count[pq]++;
! 1298: bus_dmamap_sync(sc->sc_dmat, pd->pd_dmam, 0,
! 1299: pd->pd_dmam->dm_mapsize,
! 1300: BUS_DMASYNC_POSTREAD);
! 1301: if (sc->sc_debug & SC_DEBUG_QUEUES)
! 1302: DPRINTF(("%s: queue: rx %u <- [%u]\n",
! 1303: sc->sc_dev.dv_xname, pd->pd_fragnum, pq));
! 1304: if (sc->sc_debug & SC_DEBUG_UNEXPECTED &&
! 1305: pd->pd_fragp->pf_flags & ~htole16(PF_FLAG_MF))
! 1306: DPRINTF(("%s: unknown flags on rx [%u]: %#x\n",
! 1307: sc->sc_dev.dv_xname, pq, letoh16(pd->pd_fragp->pf_flags)));
! 1308: }
! 1309:
! 1310: /*
! 1311: * Traps are generally used for the firmware to report changes in state
! 1312: * back to the host. Mostly this processes changes in link state, but
! 1313: * it needs to also be used to initiate WPA and other authentication
! 1314: * schemes in terms of client (station) or server (access point).
! 1315: */
! 1316: void
! 1317: pgt_trap_received(struct pgt_softc *sc, uint32_t oid, void *trapdata,
! 1318: size_t size)
! 1319: {
! 1320: struct pgt_async_trap *pa;
! 1321: struct mbuf *m;
! 1322: char *p;
! 1323: size_t total;
! 1324:
! 1325: if (sc->sc_flags & SC_DYING)
! 1326: return;
! 1327:
! 1328: total = sizeof(oid) + size + sizeof(struct pgt_async_trap);
! 1329: if (total >= MINCLSIZE) {
! 1330: MGETHDR(m, M_DONTWAIT, MT_DATA);
! 1331: if (m == NULL)
! 1332: return;
! 1333: MCLGET(m, M_DONTWAIT);
! 1334: if (!(m->m_flags & M_EXT)) {
! 1335: m_freem(m);
! 1336: m = NULL;
! 1337: }
! 1338: } else
! 1339: m = m_get(M_DONTWAIT, MT_DATA);
! 1340:
! 1341: if (m == NULL)
! 1342: return;
! 1343: else
! 1344: m->m_len = total;
! 1345:
! 1346: pa = mtod(m, struct pgt_async_trap *);
! 1347: p = mtod(m, char *) + sizeof(*pa);
! 1348: *(uint32_t *)p = oid;
! 1349: p += sizeof(uint32_t);
! 1350: memcpy(p, trapdata, size);
! 1351: pa->pa_mbuf = m;
! 1352:
! 1353: TAILQ_INSERT_TAIL(&sc->sc_kthread.sck_traps, pa, pa_link);
! 1354: wakeup(&sc->sc_kthread);
! 1355: }
! 1356:
! 1357: /*
! 1358: * Process a completed management response (all requests should be
! 1359: * responded to, quickly) or an event (trap).
! 1360: */
! 1361: void
! 1362: pgt_mgmtrx_completion(struct pgt_softc *sc, struct pgt_mgmt_desc *pmd)
! 1363: {
! 1364: struct pgt_desc *pd;
! 1365: struct pgt_mgmt_frame *pmf;
! 1366: uint32_t oid, size;
! 1367:
! 1368: pd = TAILQ_FIRST(&sc->sc_dirtyq[PGT_QUEUE_MGMT_RX]);
! 1369: TAILQ_REMOVE(&sc->sc_dirtyq[PGT_QUEUE_MGMT_RX], pd, pd_link);
! 1370: sc->sc_dirtyq_count[PGT_QUEUE_MGMT_RX]--;
! 1371: TAILQ_INSERT_TAIL(&sc->sc_freeq[PGT_QUEUE_MGMT_RX],
! 1372: pd, pd_link);
! 1373: sc->sc_freeq_count[PGT_QUEUE_MGMT_RX]++;
! 1374: if (letoh16(pd->pd_fragp->pf_size) < sizeof(*pmf)) {
! 1375: if (sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 1376: DPRINTF(("%s: mgmt desc too small: %u\n",
! 1377: sc->sc_dev.dv_xname,
! 1378: letoh16(pd->pd_fragp->pf_size)));
! 1379: goto out_nopmd;
! 1380: }
! 1381: pmf = (struct pgt_mgmt_frame *)pd->pd_mem;
! 1382: if (pmf->pmf_version != PMF_VER) {
! 1383: if (sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 1384: DPRINTF(("%s: unknown mgmt version %u\n",
! 1385: sc->sc_dev.dv_xname, pmf->pmf_version));
! 1386: goto out_nopmd;
! 1387: }
! 1388: if (pmf->pmf_device != PMF_DEV) {
! 1389: if (sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 1390: DPRINTF(("%s: unknown mgmt dev %u\n",
! 1391: sc->sc_dev.dv_xname, pmf->pmf_device));
! 1392: goto out;
! 1393: }
! 1394: if (pmf->pmf_flags & ~PMF_FLAG_VALID) {
! 1395: if (sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 1396: DPRINTF(("%s: unknown mgmt flags %x\n",
! 1397: sc->sc_dev.dv_xname,
! 1398: pmf->pmf_flags & ~PMF_FLAG_VALID));
! 1399: goto out;
! 1400: }
! 1401: if (pmf->pmf_flags & PMF_FLAG_LE) {
! 1402: oid = letoh32(pmf->pmf_oid);
! 1403: size = letoh32(pmf->pmf_size);
! 1404: } else {
! 1405: oid = betoh32(pmf->pmf_oid);
! 1406: size = betoh32(pmf->pmf_size);
! 1407: }
! 1408: if (pmf->pmf_operation == PMF_OP_TRAP) {
! 1409: pmd = NULL; /* ignored */
! 1410: DPRINTF(("%s: mgmt trap received (op %u, oid %#x, len %u)\n",
! 1411: sc->sc_dev.dv_xname,
! 1412: pmf->pmf_operation, oid, size));
! 1413: pgt_trap_received(sc, oid, (char *)pmf + sizeof(*pmf),
! 1414: min(size, PGT_FRAG_SIZE - sizeof(*pmf)));
! 1415: goto out_nopmd;
! 1416: }
! 1417: if (pmd == NULL) {
! 1418: if (sc->sc_debug & (SC_DEBUG_UNEXPECTED | SC_DEBUG_MGMT))
! 1419: DPRINTF(("%s: spurious mgmt received "
! 1420: "(op %u, oid %#x, len %u)\n", sc->sc_dev.dv_xname,
! 1421: pmf->pmf_operation, oid, size));
! 1422: goto out_nopmd;
! 1423: }
! 1424: switch (pmf->pmf_operation) {
! 1425: case PMF_OP_RESPONSE:
! 1426: pmd->pmd_error = 0;
! 1427: break;
! 1428: case PMF_OP_ERROR:
! 1429: pmd->pmd_error = EPERM;
! 1430: goto out;
! 1431: default:
! 1432: if (sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 1433: DPRINTF(("%s: unknown mgmt op %u\n",
! 1434: sc->sc_dev.dv_xname, pmf->pmf_operation));
! 1435: pmd->pmd_error = EIO;
! 1436: goto out;
! 1437: }
! 1438: if (oid != pmd->pmd_oid) {
! 1439: if (sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 1440: DPRINTF(("%s: mgmt oid changed from %#x -> %#x\n",
! 1441: sc->sc_dev.dv_xname, pmd->pmd_oid, oid));
! 1442: pmd->pmd_oid = oid;
! 1443: }
! 1444: if (pmd->pmd_recvbuf != NULL) {
! 1445: if (size > PGT_FRAG_SIZE) {
! 1446: if (sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 1447: DPRINTF(("%s: mgmt oid %#x has bad size %u\n",
! 1448: sc->sc_dev.dv_xname, oid, size));
! 1449: pmd->pmd_error = EIO;
! 1450: goto out;
! 1451: }
! 1452: if (size > pmd->pmd_len)
! 1453: pmd->pmd_error = ENOMEM;
! 1454: else
! 1455: memcpy(pmd->pmd_recvbuf, (char *)pmf + sizeof(*pmf),
! 1456: size);
! 1457: pmd->pmd_len = size;
! 1458: }
! 1459:
! 1460: out:
! 1461: TAILQ_REMOVE(&sc->sc_mgmtinprog, pmd, pmd_link);
! 1462: wakeup_one(pmd);
! 1463: if (sc->sc_debug & SC_DEBUG_MGMT)
! 1464: DPRINTF(("%s: queue: mgmt %p <- (op %u, oid %#x, len %u)\n",
! 1465: sc->sc_dev.dv_xname, pmd, pmf->pmf_operation,
! 1466: pmd->pmd_oid, pmd->pmd_len));
! 1467: out_nopmd:
! 1468: pgt_reinit_rx_desc_frag(sc, pd);
! 1469: }
! 1470:
! 1471: /*
! 1472: * Queue packets for reception and defragmentation. I don't know now
! 1473: * whether the rx queue being full enough to start, but not finish,
! 1474: * queueing a fragmented packet, can happen.
! 1475: */
! 1476: struct mbuf *
! 1477: pgt_datarx_completion(struct pgt_softc *sc, enum pgt_queue pq)
! 1478: {
! 1479: struct ifnet *ifp;
! 1480: struct pgt_desc *pd;
! 1481: struct mbuf *top, **mp, *m;
! 1482: size_t datalen;
! 1483: uint16_t morefrags, dataoff;
! 1484: int tlen = 0;
! 1485:
! 1486: ifp = &sc->sc_ic.ic_if;
! 1487: m = NULL;
! 1488: top = NULL;
! 1489: mp = ⊤
! 1490:
! 1491: while ((pd = TAILQ_FIRST(&sc->sc_dirtyq[pq])) != NULL) {
! 1492: TAILQ_REMOVE(&sc->sc_dirtyq[pq], pd, pd_link);
! 1493: sc->sc_dirtyq_count[pq]--;
! 1494: datalen = letoh16(pd->pd_fragp->pf_size);
! 1495: dataoff = letoh32(pd->pd_fragp->pf_addr) - pd->pd_dmaaddr;
! 1496: morefrags = pd->pd_fragp->pf_flags & htole16(PF_FLAG_MF);
! 1497:
! 1498: if (sc->sc_debug & SC_DEBUG_RXFRAG)
! 1499: DPRINTF(("%s: rx frag: len %u memoff %u flags %x\n",
! 1500: sc->sc_dev.dv_xname, datalen, dataoff,
! 1501: pd->pd_fragp->pf_flags));
! 1502:
! 1503: /* Add the (two+?) bytes for the header. */
! 1504: if (datalen + dataoff > PGT_FRAG_SIZE) {
! 1505: if (sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 1506: DPRINTF(("%s data rx too big: %u\n",
! 1507: sc->sc_dev.dv_xname, datalen));
! 1508: goto fail;
! 1509: }
! 1510:
! 1511: if (m == NULL)
! 1512: MGETHDR(m, M_DONTWAIT, MT_DATA);
! 1513: else
! 1514: m = m_get(M_DONTWAIT, MT_DATA);
! 1515:
! 1516: if (m == NULL)
! 1517: goto fail;
! 1518: if (datalen >= MINCLSIZE) {
! 1519: MCLGET(m, M_DONTWAIT);
! 1520: if (!(m->m_flags & M_EXT)) {
! 1521: m_free(m);
! 1522: goto fail;
! 1523: }
! 1524: }
! 1525: bcopy(pd->pd_mem + dataoff, mtod(m, char *), datalen);
! 1526: m->m_len = datalen;
! 1527: tlen += datalen;
! 1528:
! 1529: *mp = m;
! 1530: mp = &m->m_next;
! 1531:
! 1532: TAILQ_INSERT_TAIL(&sc->sc_freeq[pq], pd, pd_link);
! 1533: sc->sc_freeq_count[pq]++;
! 1534: pgt_reinit_rx_desc_frag(sc, pd);
! 1535:
! 1536: if (!morefrags)
! 1537: break;
! 1538: }
! 1539:
! 1540: if (top) {
! 1541: ifp->if_ipackets++;
! 1542: top->m_pkthdr.len = tlen;
! 1543: top->m_pkthdr.rcvif = ifp;
! 1544: }
! 1545: return (top);
! 1546:
! 1547: fail:
! 1548: TAILQ_INSERT_TAIL(&sc->sc_freeq[pq], pd, pd_link);
! 1549: sc->sc_freeq_count[pq]++;
! 1550: pgt_reinit_rx_desc_frag(sc, pd);
! 1551:
! 1552: ifp->if_ierrors++;
! 1553: if (top)
! 1554: m_freem(top);
! 1555: return (NULL);
! 1556: }
! 1557:
! 1558: int
! 1559: pgt_oid_get(struct pgt_softc *sc, enum pgt_oid oid,
! 1560: void *arg, size_t arglen)
! 1561: {
! 1562: struct pgt_mgmt_desc pmd;
! 1563: int error;
! 1564:
! 1565: bzero(&pmd, sizeof(pmd));
! 1566: pmd.pmd_recvbuf = arg;
! 1567: pmd.pmd_len = arglen;
! 1568: pmd.pmd_oid = oid;
! 1569:
! 1570: error = pgt_mgmt_request(sc, &pmd);
! 1571: if (error == 0)
! 1572: error = pmd.pmd_error;
! 1573: if (error != 0 && error != EPERM && sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 1574: DPRINTF(("%s: failure getting oid %#x: %d\n",
! 1575: sc->sc_dev.dv_xname, oid, error));
! 1576:
! 1577: return (error);
! 1578: }
! 1579:
! 1580: int
! 1581: pgt_oid_retrieve(struct pgt_softc *sc, enum pgt_oid oid,
! 1582: void *arg, size_t arglen)
! 1583: {
! 1584: struct pgt_mgmt_desc pmd;
! 1585: int error;
! 1586:
! 1587: bzero(&pmd, sizeof(pmd));
! 1588: pmd.pmd_sendbuf = arg;
! 1589: pmd.pmd_recvbuf = arg;
! 1590: pmd.pmd_len = arglen;
! 1591: pmd.pmd_oid = oid;
! 1592:
! 1593: error = pgt_mgmt_request(sc, &pmd);
! 1594: if (error == 0)
! 1595: error = pmd.pmd_error;
! 1596: if (error != 0 && error != EPERM && sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 1597: DPRINTF(("%s: failure retrieving oid %#x: %d\n",
! 1598: sc->sc_dev.dv_xname, oid, error));
! 1599:
! 1600: return (error);
! 1601: }
! 1602:
! 1603: int
! 1604: pgt_oid_set(struct pgt_softc *sc, enum pgt_oid oid,
! 1605: const void *arg, size_t arglen)
! 1606: {
! 1607: struct pgt_mgmt_desc pmd;
! 1608: int error;
! 1609:
! 1610: bzero(&pmd, sizeof(pmd));
! 1611: pmd.pmd_sendbuf = arg;
! 1612: pmd.pmd_len = arglen;
! 1613: pmd.pmd_oid = oid;
! 1614:
! 1615: error = pgt_mgmt_request(sc, &pmd);
! 1616: if (error == 0)
! 1617: error = pmd.pmd_error;
! 1618: if (error != 0 && error != EPERM && sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 1619: DPRINTF(("%s: failure setting oid %#x: %d\n",
! 1620: sc->sc_dev.dv_xname, oid, error));
! 1621:
! 1622: return (error);
! 1623: }
! 1624:
! 1625: void
! 1626: pgt_state_dump(struct pgt_softc *sc)
! 1627: {
! 1628: printf("%s: state dump: control 0x%08x interrupt 0x%08x\n",
! 1629: sc->sc_dev.dv_xname,
! 1630: pgt_read_4(sc, PGT_REG_CTRL_STAT),
! 1631: pgt_read_4(sc, PGT_REG_INT_STAT));
! 1632:
! 1633: printf("%s: state dump: driver curfrag[]\n",
! 1634: sc->sc_dev.dv_xname);
! 1635:
! 1636: printf("%s: 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
! 1637: sc->sc_dev.dv_xname,
! 1638: letoh32(sc->sc_cb->pcb_driver_curfrag[0]),
! 1639: letoh32(sc->sc_cb->pcb_driver_curfrag[1]),
! 1640: letoh32(sc->sc_cb->pcb_driver_curfrag[2]),
! 1641: letoh32(sc->sc_cb->pcb_driver_curfrag[3]),
! 1642: letoh32(sc->sc_cb->pcb_driver_curfrag[4]),
! 1643: letoh32(sc->sc_cb->pcb_driver_curfrag[5]));
! 1644:
! 1645: printf("%s: state dump: device curfrag[]\n",
! 1646: sc->sc_dev.dv_xname);
! 1647:
! 1648: printf("%s: 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
! 1649: sc->sc_dev.dv_xname,
! 1650: letoh32(sc->sc_cb->pcb_device_curfrag[0]),
! 1651: letoh32(sc->sc_cb->pcb_device_curfrag[1]),
! 1652: letoh32(sc->sc_cb->pcb_device_curfrag[2]),
! 1653: letoh32(sc->sc_cb->pcb_device_curfrag[3]),
! 1654: letoh32(sc->sc_cb->pcb_device_curfrag[4]),
! 1655: letoh32(sc->sc_cb->pcb_device_curfrag[5]));
! 1656: }
! 1657:
! 1658: int
! 1659: pgt_mgmt_request(struct pgt_softc *sc, struct pgt_mgmt_desc *pmd)
! 1660: {
! 1661: struct pgt_desc *pd;
! 1662: struct pgt_mgmt_frame *pmf;
! 1663: int error, i;
! 1664:
! 1665: if (sc->sc_flags & (SC_DYING | SC_NEEDS_RESET))
! 1666: return (EIO);
! 1667: if (pmd->pmd_len > PGT_FRAG_SIZE - sizeof(*pmf))
! 1668: return (ENOMEM);
! 1669: pd = TAILQ_FIRST(&sc->sc_freeq[PGT_QUEUE_MGMT_TX]);
! 1670: if (pd == NULL)
! 1671: return (ENOMEM);
! 1672: error = pgt_load_tx_desc_frag(sc, PGT_QUEUE_MGMT_TX, pd);
! 1673: if (error)
! 1674: return (error);
! 1675: pmf = (struct pgt_mgmt_frame *)pd->pd_mem;
! 1676: pmf->pmf_version = PMF_VER;
! 1677: /* "get" and "retrieve" operations look the same */
! 1678: if (pmd->pmd_recvbuf != NULL)
! 1679: pmf->pmf_operation = PMF_OP_GET;
! 1680: else
! 1681: pmf->pmf_operation = PMF_OP_SET;
! 1682: pmf->pmf_oid = htobe32(pmd->pmd_oid);
! 1683: pmf->pmf_device = PMF_DEV;
! 1684: pmf->pmf_flags = 0;
! 1685: pmf->pmf_size = htobe32(pmd->pmd_len);
! 1686: /* "set" and "retrieve" operations both send data */
! 1687: if (pmd->pmd_sendbuf != NULL)
! 1688: memcpy((char *)pmf + sizeof(*pmf), pmd->pmd_sendbuf,
! 1689: pmd->pmd_len);
! 1690: else
! 1691: bzero((char *)pmf + sizeof(*pmf), pmd->pmd_len);
! 1692: pmd->pmd_error = EINPROGRESS;
! 1693: TAILQ_INSERT_TAIL(&sc->sc_mgmtinprog, pmd, pmd_link);
! 1694: if (sc->sc_debug & SC_DEBUG_MGMT)
! 1695: DPRINTF(("%s: queue: mgmt %p -> (op %u, oid %#x, len %u)\n",
! 1696: sc->sc_dev.dv_xname,
! 1697: pmd, pmf->pmf_operation,
! 1698: pmd->pmd_oid, pmd->pmd_len));
! 1699: pgt_desc_transmit(sc, PGT_QUEUE_MGMT_TX, pd,
! 1700: sizeof(*pmf) + pmd->pmd_len, 0);
! 1701: /*
! 1702: * Try for one second, triggering 10 times.
! 1703: *
! 1704: * Do our best to work around seemingly buggy CardBus controllers
! 1705: * on Soekris 4521 that fail to get interrupts with alarming
! 1706: * regularity: run as if an interrupt occurred and service every
! 1707: * queue except for mbuf reception.
! 1708: */
! 1709: i = 0;
! 1710: do {
! 1711: if (tsleep(pmd, 0, "pgtmgm", hz / 10) != EWOULDBLOCK)
! 1712: break;
! 1713: if (pmd->pmd_error != EINPROGRESS)
! 1714: break;
! 1715: if (sc->sc_flags & (SC_DYING | SC_NEEDS_RESET)) {
! 1716: pmd->pmd_error = EIO;
! 1717: TAILQ_REMOVE(&sc->sc_mgmtinprog, pmd, pmd_link);
! 1718: break;
! 1719: }
! 1720: if (i != 9)
! 1721: pgt_maybe_trigger(sc, PGT_QUEUE_MGMT_RX);
! 1722: #ifdef PGT_BUGGY_INTERRUPT_RECOVERY
! 1723: pgt_update_intr(sc, 0);
! 1724: #endif
! 1725: } while (i++ < 10);
! 1726:
! 1727: if (pmd->pmd_error == EINPROGRESS) {
! 1728: printf("%s: timeout waiting for management "
! 1729: "packet response to %#x\n",
! 1730: sc->sc_dev.dv_xname, pmd->pmd_oid);
! 1731: TAILQ_REMOVE(&sc->sc_mgmtinprog, pmd, pmd_link);
! 1732: if (sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 1733: pgt_state_dump(sc);
! 1734: pgt_async_reset(sc);
! 1735: error = ETIMEDOUT;
! 1736: } else
! 1737: error = 0;
! 1738:
! 1739: return (error);
! 1740: }
! 1741:
! 1742: void
! 1743: pgt_desc_transmit(struct pgt_softc *sc, enum pgt_queue pq, struct pgt_desc *pd,
! 1744: uint16_t len, int morecoming)
! 1745: {
! 1746: TAILQ_REMOVE(&sc->sc_freeq[pq], pd, pd_link);
! 1747: sc->sc_freeq_count[pq]--;
! 1748: TAILQ_INSERT_TAIL(&sc->sc_dirtyq[pq], pd, pd_link);
! 1749: sc->sc_dirtyq_count[pq]++;
! 1750: if (sc->sc_debug & SC_DEBUG_QUEUES)
! 1751: DPRINTF(("%s: queue: tx %u -> [%u]\n", sc->sc_dev.dv_xname,
! 1752: pd->pd_fragnum, pq));
! 1753: bus_dmamap_sync(sc->sc_dmat, sc->sc_cbdmam, 0,
! 1754: sc->sc_cbdmam->dm_mapsize,
! 1755: BUS_DMASYNC_POSTREAD | BUS_DMASYNC_PREWRITE);
! 1756: if (morecoming)
! 1757: pd->pd_fragp->pf_flags |= htole16(PF_FLAG_MF);
! 1758: pd->pd_fragp->pf_size = htole16(len);
! 1759: bus_dmamap_sync(sc->sc_dmat, pd->pd_dmam, 0,
! 1760: pd->pd_dmam->dm_mapsize,
! 1761: BUS_DMASYNC_POSTWRITE);
! 1762: sc->sc_cb->pcb_driver_curfrag[pq] =
! 1763: htole32(letoh32(sc->sc_cb->pcb_driver_curfrag[pq]) + 1);
! 1764: bus_dmamap_sync(sc->sc_dmat, sc->sc_cbdmam, 0,
! 1765: sc->sc_cbdmam->dm_mapsize,
! 1766: BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_PREREAD);
! 1767: if (!morecoming)
! 1768: pgt_maybe_trigger(sc, pq);
! 1769: }
! 1770:
! 1771: void
! 1772: pgt_maybe_trigger(struct pgt_softc *sc, enum pgt_queue pq)
! 1773: {
! 1774: unsigned int tries = 1000000 / PGT_WRITEIO_DELAY; /* one second */
! 1775: uint32_t reg;
! 1776:
! 1777: if (sc->sc_debug & SC_DEBUG_TRIGGER)
! 1778: DPRINTF(("%s: triggered by queue [%u]\n",
! 1779: sc->sc_dev.dv_xname, pq));
! 1780: pgt_debug_events(sc, "trig");
! 1781: if (sc->sc_flags & SC_POWERSAVE) {
! 1782: /* Magic values ahoy? */
! 1783: if (pgt_read_4(sc, PGT_REG_INT_STAT) == 0xabadface) {
! 1784: do {
! 1785: reg = pgt_read_4(sc, PGT_REG_CTRL_STAT);
! 1786: if (!(reg & PGT_CTRL_STAT_SLEEPMODE))
! 1787: DELAY(PGT_WRITEIO_DELAY);
! 1788: } while (tries-- != 0);
! 1789: if (!(reg & PGT_CTRL_STAT_SLEEPMODE)) {
! 1790: if (sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 1791: DPRINTF(("%s: timeout triggering from "
! 1792: "sleep mode\n",
! 1793: sc->sc_dev.dv_xname));
! 1794: pgt_async_reset(sc);
! 1795: return;
! 1796: }
! 1797: }
! 1798: pgt_write_4_flush(sc, PGT_REG_DEV_INT,
! 1799: PGT_DEV_INT_WAKEUP);
! 1800: DELAY(PGT_WRITEIO_DELAY);
! 1801: /* read the status back in */
! 1802: (void)pgt_read_4(sc, PGT_REG_CTRL_STAT);
! 1803: DELAY(PGT_WRITEIO_DELAY);
! 1804: } else {
! 1805: pgt_write_4_flush(sc, PGT_REG_DEV_INT, PGT_DEV_INT_UPDATE);
! 1806: DELAY(PGT_WRITEIO_DELAY);
! 1807: }
! 1808: }
! 1809:
! 1810: struct ieee80211_node *
! 1811: pgt_ieee80211_node_alloc(struct ieee80211com *ic)
! 1812: {
! 1813: struct pgt_ieee80211_node *pin;
! 1814:
! 1815: pin = malloc(sizeof(*pin), M_DEVBUF, M_NOWAIT);
! 1816: if (pin != NULL) {
! 1817: bzero(pin, sizeof *pin);
! 1818: pin->pin_dot1x_auth = PIN_DOT1X_UNAUTHORIZED;
! 1819: }
! 1820: return (struct ieee80211_node *)pin;
! 1821: }
! 1822:
! 1823: void
! 1824: pgt_ieee80211_newassoc(struct ieee80211com *ic, struct ieee80211_node *ni,
! 1825: int reallynew)
! 1826: {
! 1827: ieee80211_ref_node(ni);
! 1828: }
! 1829:
! 1830: void
! 1831: pgt_ieee80211_node_free(struct ieee80211com *ic, struct ieee80211_node *ni)
! 1832: {
! 1833: struct pgt_ieee80211_node *pin;
! 1834:
! 1835: pin = (struct pgt_ieee80211_node *)ni;
! 1836: free(pin, M_DEVBUF);
! 1837: }
! 1838:
! 1839: void
! 1840: pgt_ieee80211_node_copy(struct ieee80211com *ic, struct ieee80211_node *dst,
! 1841: const struct ieee80211_node *src)
! 1842: {
! 1843: const struct pgt_ieee80211_node *psrc;
! 1844: struct pgt_ieee80211_node *pdst;
! 1845:
! 1846: psrc = (const struct pgt_ieee80211_node *)src;
! 1847: pdst = (struct pgt_ieee80211_node *)dst;
! 1848: bcopy(psrc, pdst, sizeof(*psrc));
! 1849: }
! 1850:
! 1851: int
! 1852: pgt_ieee80211_send_mgmt(struct ieee80211com *ic, struct ieee80211_node *ni,
! 1853: int type, int arg)
! 1854: {
! 1855: return (EOPNOTSUPP);
! 1856: }
! 1857:
! 1858: int
! 1859: pgt_net_attach(struct pgt_softc *sc)
! 1860: {
! 1861: struct ieee80211com *ic = &sc->sc_ic;
! 1862: struct ifnet *ifp = &ic->ic_if;
! 1863: struct ieee80211_rateset *rs;
! 1864: uint8_t rates[IEEE80211_RATE_MAXSIZE];
! 1865: struct pgt_obj_buffer psbuffer;
! 1866: struct pgt_obj_frequencies *freqs;
! 1867: uint32_t phymode, country;
! 1868: unsigned int chan, i, j, firstchan = -1;
! 1869: int error;
! 1870:
! 1871: psbuffer.pob_size = htole32(PGT_FRAG_SIZE * PGT_PSM_BUFFER_FRAME_COUNT);
! 1872: psbuffer.pob_addr = htole32(sc->sc_psmdmam->dm_segs[0].ds_addr);
! 1873: error = pgt_oid_set(sc, PGT_OID_PSM_BUFFER, &psbuffer, sizeof(country));
! 1874: if (error)
! 1875: return (error);
! 1876: error = pgt_oid_get(sc, PGT_OID_PHY, &phymode, sizeof(phymode));
! 1877: if (error)
! 1878: return (error);
! 1879: error = pgt_oid_get(sc, PGT_OID_MAC_ADDRESS, ic->ic_myaddr,
! 1880: sizeof(ic->ic_myaddr));
! 1881: if (error)
! 1882: return (error);
! 1883: error = pgt_oid_get(sc, PGT_OID_COUNTRY, &country, sizeof(country));
! 1884: if (error)
! 1885: return (error);
! 1886:
! 1887: ifp->if_softc = sc;
! 1888: ifp->if_init = pgt_init;
! 1889: ifp->if_ioctl = pgt_ioctl;
! 1890: ifp->if_start = pgt_start;
! 1891: ifp->if_watchdog = pgt_watchdog;
! 1892: ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST;
! 1893: strlcpy(ifp->if_xname, sc->sc_dev.dv_xname, IFNAMSIZ);
! 1894:
! 1895: IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN);
! 1896: IFQ_SET_READY(&ifp->if_snd);
! 1897:
! 1898: /*
! 1899: * Set channels
! 1900: *
! 1901: * Prism hardware likes to report supported frequencies that are
! 1902: * not actually available for the country of origin.
! 1903: */
! 1904: j = sizeof(*freqs) + (IEEE80211_CHAN_MAX + 1) * sizeof(uint16_t);
! 1905: freqs = malloc(j, M_DEVBUF, M_WAITOK);
! 1906: error = pgt_oid_get(sc, PGT_OID_SUPPORTED_FREQUENCIES, freqs, j);
! 1907: if (error) {
! 1908: free(freqs, M_DEVBUF);
! 1909: return (error);
! 1910: }
! 1911:
! 1912: for (i = 0, j = letoh16(freqs->pof_count); i < j; i++) {
! 1913: chan = ieee80211_mhz2ieee(letoh16(freqs->pof_freqlist_mhz[i]),
! 1914: 0);
! 1915:
! 1916: if (chan > IEEE80211_CHAN_MAX) {
! 1917: printf("%s: reported bogus channel (%uMHz)\n",
! 1918: sc->sc_dev.dv_xname, chan);
! 1919: free(freqs, M_DEVBUF);
! 1920: return (EIO);
! 1921: }
! 1922:
! 1923: if (letoh16(freqs->pof_freqlist_mhz[i]) < 5000) {
! 1924: if (!(phymode & htole32(PGT_OID_PHY_2400MHZ)))
! 1925: continue;
! 1926: if (country == letoh32(PGT_COUNTRY_USA)) {
! 1927: if (chan >= 12 && chan <= 14)
! 1928: continue;
! 1929: }
! 1930: if (chan <= 14)
! 1931: ic->ic_channels[chan].ic_flags |=
! 1932: IEEE80211_CHAN_B;
! 1933: ic->ic_channels[chan].ic_flags |= IEEE80211_CHAN_PUREG;
! 1934: } else {
! 1935: if (!(phymode & htole32(PGT_OID_PHY_5000MHZ)))
! 1936: continue;
! 1937: ic->ic_channels[chan].ic_flags |= IEEE80211_CHAN_A;
! 1938: }
! 1939:
! 1940: ic->ic_channels[chan].ic_freq =
! 1941: letoh16(freqs->pof_freqlist_mhz[i]);
! 1942:
! 1943: if (firstchan == -1)
! 1944: firstchan = chan;
! 1945:
! 1946: DPRINTF(("%s: set channel %d to freq %uMHz\n",
! 1947: sc->sc_dev.dv_xname, chan,
! 1948: letoh16(freqs->pof_freqlist_mhz[i])));
! 1949: }
! 1950: free(freqs, M_DEVBUF);
! 1951: if (firstchan == -1) {
! 1952: printf("%s: no channels found\n", sc->sc_dev.dv_xname);
! 1953: return (EIO);
! 1954: }
! 1955:
! 1956: /*
! 1957: * Set rates
! 1958: */
! 1959: bzero(rates, sizeof(rates));
! 1960: error = pgt_oid_get(sc, PGT_OID_SUPPORTED_RATES, rates, sizeof(rates));
! 1961: if (error)
! 1962: return (error);
! 1963: for (i = 0; i < sizeof(rates) && rates[i] != 0; i++) {
! 1964: switch (rates[i]) {
! 1965: case 2:
! 1966: case 4:
! 1967: case 11:
! 1968: case 22:
! 1969: case 44: /* maybe */
! 1970: if (phymode & htole32(PGT_OID_PHY_2400MHZ)) {
! 1971: rs = &ic->ic_sup_rates[IEEE80211_MODE_11B];
! 1972: rs->rs_rates[rs->rs_nrates++] = rates[i];
! 1973: }
! 1974: default:
! 1975: if (phymode & htole32(PGT_OID_PHY_2400MHZ)) {
! 1976: rs = &ic->ic_sup_rates[IEEE80211_MODE_11G];
! 1977: rs->rs_rates[rs->rs_nrates++] = rates[i];
! 1978: }
! 1979: if (phymode & htole32(PGT_OID_PHY_5000MHZ)) {
! 1980: rs = &ic->ic_sup_rates[IEEE80211_MODE_11A];
! 1981: rs->rs_rates[rs->rs_nrates++] = rates[i];
! 1982: }
! 1983: rs = &ic->ic_sup_rates[IEEE80211_MODE_AUTO];
! 1984: rs->rs_rates[rs->rs_nrates++] = rates[i];
! 1985: }
! 1986: }
! 1987:
! 1988: ic->ic_caps = IEEE80211_C_WEP | IEEE80211_C_IBSS | IEEE80211_C_PMGT |
! 1989: IEEE80211_C_HOSTAP | IEEE80211_C_TXPMGT | IEEE80211_C_SHSLOT |
! 1990: IEEE80211_C_SHPREAMBLE | IEEE80211_C_MONITOR;
! 1991:
! 1992: ic->ic_opmode = IEEE80211_M_STA;
! 1993: ic->ic_state = IEEE80211_S_INIT;
! 1994:
! 1995: if_attach(ifp);
! 1996: ieee80211_ifattach(ifp);
! 1997:
! 1998: /* setup post-attach/pre-lateattach vector functions */
! 1999: sc->sc_newstate = ic->ic_newstate;
! 2000: ic->ic_newstate = pgt_newstate;
! 2001: ic->ic_node_alloc = pgt_ieee80211_node_alloc;
! 2002: ic->ic_newassoc = pgt_ieee80211_newassoc;
! 2003: ic->ic_node_free = pgt_ieee80211_node_free;
! 2004: ic->ic_node_copy = pgt_ieee80211_node_copy;
! 2005: ic->ic_send_mgmt = pgt_ieee80211_send_mgmt;
! 2006: ic->ic_max_rssi = 255; /* rssi is a u_int8_t */
! 2007:
! 2008: /* let net80211 handle switching around the media + resetting */
! 2009: ieee80211_media_init(ifp, pgt_media_change, pgt_media_status);
! 2010:
! 2011: #if NBPFILTER > 0
! 2012: bpfattach(&sc->sc_drvbpf, ifp, DLT_IEEE802_11_RADIO,
! 2013: sizeof(struct ieee80211_frame) + 64);
! 2014:
! 2015: sc->sc_rxtap_len = sizeof(sc->sc_rxtapu);
! 2016: sc->sc_rxtap.wr_ihdr.it_len = htole16(sc->sc_rxtap_len);
! 2017: sc->sc_rxtap.wr_ihdr.it_present = htole32(PGT_RX_RADIOTAP_PRESENT);
! 2018:
! 2019: sc->sc_txtap_len = sizeof(sc->sc_txtapu);
! 2020: sc->sc_txtap.wt_ihdr.it_len = htole16(sc->sc_txtap_len);
! 2021: sc->sc_txtap.wt_ihdr.it_present = htole32(PGT_TX_RADIOTAP_PRESENT);
! 2022: #endif
! 2023:
! 2024: /*
! 2025: * Enable shutdown and power hooks
! 2026: */
! 2027: sc->sc_shutdown_hook = shutdownhook_establish(pgt_shutdown, sc);
! 2028: if (sc->sc_shutdown_hook == NULL)
! 2029: printf("%s: WARNING: unable to establish shutdown hook\n",
! 2030: sc->sc_dev.dv_xname);
! 2031: sc->sc_power_hook = powerhook_establish(pgt_power, sc);
! 2032: if (sc->sc_power_hook == NULL)
! 2033: printf("%s: WARNING: unable to establish power hook\n",
! 2034: sc->sc_dev.dv_xname);
! 2035:
! 2036: return (0);
! 2037: }
! 2038:
! 2039: int
! 2040: pgt_media_change(struct ifnet *ifp)
! 2041: {
! 2042: struct pgt_softc *sc = ifp->if_softc;
! 2043: int error;
! 2044:
! 2045: error = ieee80211_media_change(ifp);
! 2046: if (error == ENETRESET) {
! 2047: pgt_update_hw_from_sw(sc, 0, 0);
! 2048: error = 0;
! 2049: }
! 2050:
! 2051: return (error);
! 2052: }
! 2053:
! 2054: void
! 2055: pgt_media_status(struct ifnet *ifp, struct ifmediareq *imr)
! 2056: {
! 2057: struct pgt_softc *sc = ifp->if_softc;
! 2058: struct ieee80211com *ic = &sc->sc_ic;
! 2059: uint32_t rate;
! 2060: int s;
! 2061:
! 2062: imr->ifm_status = 0;
! 2063: imr->ifm_active = IFM_IEEE80211 | IFM_NONE;
! 2064:
! 2065: if (!(ifp->if_flags & IFF_UP))
! 2066: return;
! 2067:
! 2068: s = splnet();
! 2069:
! 2070: if (ic->ic_fixed_rate != -1) {
! 2071: rate = ic->ic_sup_rates[ic->ic_curmode].
! 2072: rs_rates[ic->ic_fixed_rate] & IEEE80211_RATE_VAL;
! 2073: } else {
! 2074: if (pgt_oid_get(sc, PGT_OID_LINK_STATE, &rate, sizeof(rate)))
! 2075: return;
! 2076: rate = letoh32(rate);
! 2077: if (sc->sc_debug & SC_DEBUG_LINK) {
! 2078: DPRINTF(("%s: %s: link rate %u\n",
! 2079: sc->sc_dev.dv_xname, __func__, rate));
! 2080: }
! 2081: if (rate == 0)
! 2082: return;
! 2083: }
! 2084:
! 2085: imr->ifm_status = IFM_AVALID;
! 2086: imr->ifm_active = IFM_IEEE80211;
! 2087: if (ic->ic_state == IEEE80211_S_RUN)
! 2088: imr->ifm_status |= IFM_ACTIVE;
! 2089:
! 2090: imr->ifm_active |= ieee80211_rate2media(ic, rate, ic->ic_curmode);
! 2091:
! 2092: switch (ic->ic_opmode) {
! 2093: case IEEE80211_M_STA:
! 2094: break;
! 2095: case IEEE80211_M_IBSS:
! 2096: imr->ifm_active |= IFM_IEEE80211_ADHOC;
! 2097: break;
! 2098: case IEEE80211_M_AHDEMO:
! 2099: imr->ifm_active |= IFM_IEEE80211_ADHOC | IFM_FLAG0;
! 2100: break;
! 2101: case IEEE80211_M_HOSTAP:
! 2102: imr->ifm_active |= IFM_IEEE80211_HOSTAP;
! 2103: break;
! 2104: case IEEE80211_M_MONITOR:
! 2105: imr->ifm_active |= IFM_IEEE80211_MONITOR;
! 2106: break;
! 2107: default:
! 2108: break;
! 2109: }
! 2110:
! 2111: splx(s);
! 2112: }
! 2113:
! 2114: /*
! 2115: * Start data frames. Critical sections surround the boundary of
! 2116: * management frame transmission / transmission acknowledgement / response
! 2117: * and data frame transmission / transmission acknowledgement.
! 2118: */
! 2119: void
! 2120: pgt_start(struct ifnet *ifp)
! 2121: {
! 2122: struct pgt_softc *sc;
! 2123: struct ieee80211com *ic;
! 2124: struct pgt_desc *pd;
! 2125: struct mbuf *m;
! 2126: int error;
! 2127:
! 2128: sc = ifp->if_softc;
! 2129: ic = &sc->sc_ic;
! 2130:
! 2131: if (sc->sc_flags & (SC_DYING | SC_NEEDS_RESET) ||
! 2132: !(ifp->if_flags & IFF_RUNNING) ||
! 2133: ic->ic_state != IEEE80211_S_RUN) {
! 2134: return;
! 2135: }
! 2136:
! 2137: /*
! 2138: * Management packets should probably be MLME frames
! 2139: * (i.e. hostap "managed" mode); we don't touch the
! 2140: * net80211 management queue.
! 2141: */
! 2142: for (; sc->sc_dirtyq_count[PGT_QUEUE_DATA_LOW_TX] <
! 2143: PGT_QUEUE_FULL_THRESHOLD && !IFQ_IS_EMPTY(&ifp->if_snd);) {
! 2144: pd = TAILQ_FIRST(&sc->sc_freeq[PGT_QUEUE_DATA_LOW_TX]);
! 2145: IFQ_POLL(&ifp->if_snd, m);
! 2146: if (m == NULL)
! 2147: break;
! 2148: if (m->m_pkthdr.len <= PGT_FRAG_SIZE) {
! 2149: error = pgt_load_tx_desc_frag(sc,
! 2150: PGT_QUEUE_DATA_LOW_TX, pd);
! 2151: if (error)
! 2152: break;
! 2153: IFQ_DEQUEUE(&ifp->if_snd, m);
! 2154: m_copydata(m, 0, m->m_pkthdr.len, pd->pd_mem);
! 2155: pgt_desc_transmit(sc, PGT_QUEUE_DATA_LOW_TX,
! 2156: pd, m->m_pkthdr.len, 0);
! 2157: } else if (m->m_pkthdr.len <= PGT_FRAG_SIZE * 2) {
! 2158: struct pgt_desc *pd2;
! 2159:
! 2160: /*
! 2161: * Transmit a fragmented frame if there is
! 2162: * not enough room in one fragment; limit
! 2163: * to two fragments (802.11 itself couldn't
! 2164: * even support a full two.)
! 2165: */
! 2166: if (sc->sc_dirtyq_count[PGT_QUEUE_DATA_LOW_TX] + 2 >
! 2167: PGT_QUEUE_FULL_THRESHOLD)
! 2168: break;
! 2169: pd2 = TAILQ_NEXT(pd, pd_link);
! 2170: error = pgt_load_tx_desc_frag(sc,
! 2171: PGT_QUEUE_DATA_LOW_TX, pd);
! 2172: if (error == 0) {
! 2173: error = pgt_load_tx_desc_frag(sc,
! 2174: PGT_QUEUE_DATA_LOW_TX, pd2);
! 2175: if (error) {
! 2176: pgt_unload_tx_desc_frag(sc, pd);
! 2177: TAILQ_INSERT_HEAD(&sc->sc_freeq[
! 2178: PGT_QUEUE_DATA_LOW_TX], pd,
! 2179: pd_link);
! 2180: }
! 2181: }
! 2182: if (error)
! 2183: break;
! 2184: IFQ_DEQUEUE(&ifp->if_snd, m);
! 2185: m_copydata(m, 0, PGT_FRAG_SIZE, pd->pd_mem);
! 2186: pgt_desc_transmit(sc, PGT_QUEUE_DATA_LOW_TX,
! 2187: pd, PGT_FRAG_SIZE, 1);
! 2188: m_copydata(m, PGT_FRAG_SIZE,
! 2189: m->m_pkthdr.len - PGT_FRAG_SIZE, pd2->pd_mem);
! 2190: pgt_desc_transmit(sc, PGT_QUEUE_DATA_LOW_TX,
! 2191: pd2, m->m_pkthdr.len - PGT_FRAG_SIZE, 0);
! 2192: } else {
! 2193: IFQ_DEQUEUE(&ifp->if_snd, m);
! 2194: ifp->if_oerrors++;
! 2195: m_freem(m);
! 2196: m = NULL;
! 2197: }
! 2198: if (m != NULL) {
! 2199: struct ieee80211_node *ni;
! 2200: #if NBPFILTER > 0
! 2201: if (ifp->if_bpf != NULL)
! 2202: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_OUT);
! 2203: #endif
! 2204: ifp->if_opackets++;
! 2205: ifp->if_timer = 1;
! 2206: sc->sc_txtimer = 5;
! 2207: ni = ieee80211_find_txnode(&sc->sc_ic,
! 2208: mtod(m, struct ether_header *)->ether_dhost);
! 2209: if (ni != NULL) {
! 2210: ni->ni_inact = 0;
! 2211: if (ni != ic->ic_bss)
! 2212: ieee80211_release_node(&sc->sc_ic, ni);
! 2213: }
! 2214: #if NBPFILTER > 0
! 2215: if (sc->sc_drvbpf != NULL) {
! 2216: struct mbuf mb;
! 2217: struct ether_header eh;
! 2218: struct pgt_tx_radiotap_hdr *tap = &sc->sc_txtap;
! 2219:
! 2220: bcopy(mtod(m, struct ether_header *), &eh,
! 2221: sizeof(eh));
! 2222: m_adj(m, sizeof(eh));
! 2223: m = pgt_ieee80211_encap(sc, &eh, m, NULL);
! 2224:
! 2225: tap->wt_flags = 0;
! 2226: //tap->wt_rate = rate;
! 2227: tap->wt_rate = 0;
! 2228: tap->wt_chan_freq =
! 2229: htole16(ic->ic_bss->ni_chan->ic_freq);
! 2230: tap->wt_chan_flags =
! 2231: htole16(ic->ic_bss->ni_chan->ic_flags);
! 2232:
! 2233: if (m != NULL) {
! 2234: mb.m_data = (caddr_t)tap;
! 2235: mb.m_len = sc->sc_txtap_len;
! 2236: mb.m_next = m;
! 2237: mb.m_nextpkt = NULL;
! 2238: mb.m_type = 0;
! 2239: mb.m_flags = 0;
! 2240:
! 2241: bpf_mtap(sc->sc_drvbpf, &mb,
! 2242: BPF_DIRECTION_OUT);
! 2243: }
! 2244: }
! 2245: #endif
! 2246: if (m != NULL)
! 2247: m_freem(m);
! 2248: }
! 2249: }
! 2250: }
! 2251:
! 2252: int
! 2253: pgt_ioctl(struct ifnet *ifp, u_long cmd, caddr_t req)
! 2254: {
! 2255: struct pgt_softc *sc = ifp->if_softc;
! 2256: struct ifaddr *ifa;
! 2257: struct ifreq *ifr;
! 2258: struct wi_req *wreq;
! 2259: struct ieee80211_nodereq_all *na;
! 2260: struct ieee80211com *ic;
! 2261: struct pgt_obj_bsslist *pob;
! 2262: struct wi_scan_p2_hdr *p2hdr;
! 2263: struct wi_scan_res *res;
! 2264: uint32_t noise;
! 2265: int maxscan, i, j, s, error = 0;
! 2266:
! 2267: ic = &sc->sc_ic;
! 2268: ifr = (struct ifreq *)req;
! 2269:
! 2270: s = splnet();
! 2271: switch (cmd) {
! 2272: case SIOCS80211SCAN:
! 2273: /*
! 2274: * This chip scans always as soon as it gets initialized.
! 2275: */
! 2276:
! 2277: /*
! 2278: * Give us a bit time to scan in case we were not
! 2279: * initialized before and let the userland process wait.
! 2280: */
! 2281: tsleep(&sc->sc_flags, 0, "pgtsca", hz * SCAN_TIMEOUT);
! 2282:
! 2283: break;
! 2284: case SIOCG80211ALLNODES: {
! 2285: struct ieee80211_nodereq *nr = NULL;
! 2286: na = (struct ieee80211_nodereq_all *)req;
! 2287: wreq = malloc(sizeof(*wreq), M_DEVBUF, M_WAITOK);
! 2288: bzero(wreq, sizeof(*wreq));
! 2289:
! 2290: maxscan = PGT_OBJ_BSSLIST_NBSS;
! 2291: pob = malloc(sizeof(*pob) +
! 2292: sizeof(struct pgt_obj_bss) * maxscan, M_DEVBUF, M_WAITOK);
! 2293: error = pgt_oid_get(sc, PGT_OID_NOISE_FLOOR, &noise,
! 2294: sizeof(noise));
! 2295:
! 2296: if (error == 0) {
! 2297: noise = letoh32(noise);
! 2298: error = pgt_oid_get(sc, PGT_OID_BSS_LIST, pob,
! 2299: sizeof(*pob) +
! 2300: sizeof(struct pgt_obj_bss) * maxscan);
! 2301: }
! 2302:
! 2303: if (error == 0) {
! 2304: maxscan = min(PGT_OBJ_BSSLIST_NBSS,
! 2305: letoh32(pob->pob_count));
! 2306: maxscan = min(maxscan,
! 2307: (sizeof(wreq->wi_val) - sizeof(*p2hdr)) /
! 2308: WI_PRISM2_RES_SIZE);
! 2309: p2hdr = (struct wi_scan_p2_hdr *)&wreq->wi_val;
! 2310: p2hdr->wi_rsvd = 0;
! 2311: p2hdr->wi_reason = 1;
! 2312: wreq->wi_len = (maxscan * WI_PRISM2_RES_SIZE) / 2 +
! 2313: sizeof(*p2hdr) / 2;
! 2314: wreq->wi_type = WI_RID_SCAN_RES;
! 2315: }
! 2316:
! 2317: for (na->na_nodes = j = i = 0; i < maxscan &&
! 2318: (na->na_size >= j + sizeof(struct ieee80211_nodereq));
! 2319: i++) {
! 2320: /* allocate node space */
! 2321: if (nr == NULL)
! 2322: nr = malloc(sizeof(*nr), M_DEVBUF, M_WAITOK);
! 2323:
! 2324: /* get next BSS scan result */
! 2325: res = (struct wi_scan_res *)
! 2326: ((char *)&wreq->wi_val + sizeof(*p2hdr) +
! 2327: i * WI_PRISM2_RES_SIZE);
! 2328: pgt_obj_bss2scanres(sc, &pob->pob_bsslist[i],
! 2329: res, noise);
! 2330:
! 2331: /* copy it to node structure for ifconfig to read */
! 2332: bzero(nr, sizeof(*nr));
! 2333: IEEE80211_ADDR_COPY(nr->nr_macaddr, res->wi_bssid);
! 2334: IEEE80211_ADDR_COPY(nr->nr_bssid, res->wi_bssid);
! 2335: nr->nr_channel = letoh16(res->wi_chan);
! 2336: nr->nr_chan_flags = IEEE80211_CHAN_B;
! 2337: nr->nr_rssi = letoh16(res->wi_signal);
! 2338: nr->nr_max_rssi = 0; /* XXX */
! 2339: nr->nr_nwid_len = letoh16(res->wi_ssid_len);
! 2340: bcopy(res->wi_ssid, nr->nr_nwid, nr->nr_nwid_len);
! 2341: nr->nr_intval = letoh16(res->wi_interval);
! 2342: nr->nr_capinfo = letoh16(res->wi_capinfo);
! 2343: nr->nr_txrate = res->wi_rate == WI_WAVELAN_RES_1M ? 2 :
! 2344: (res->wi_rate == WI_WAVELAN_RES_2M ? 4 :
! 2345: (res->wi_rate == WI_WAVELAN_RES_5M ? 11 :
! 2346: (res->wi_rate == WI_WAVELAN_RES_11M ? 22 : 0)));
! 2347: nr->nr_nrates = 0;
! 2348: while (res->wi_srates[nr->nr_nrates] != 0) {
! 2349: nr->nr_rates[nr->nr_nrates] =
! 2350: res->wi_srates[nr->nr_nrates] &
! 2351: WI_VAR_SRATES_MASK;
! 2352: nr->nr_nrates++;
! 2353: }
! 2354: nr->nr_flags = 0;
! 2355: if (bcmp(nr->nr_macaddr, nr->nr_bssid,
! 2356: IEEE80211_ADDR_LEN) == 0)
! 2357: nr->nr_flags |= IEEE80211_NODEREQ_AP;
! 2358: error = copyout(nr, (caddr_t)na->na_node + j,
! 2359: sizeof(struct ieee80211_nodereq));
! 2360: if (error)
! 2361: break;
! 2362:
! 2363: /* point to next node entry */
! 2364: j += sizeof(struct ieee80211_nodereq);
! 2365: na->na_nodes++;
! 2366: }
! 2367: if (nr)
! 2368: free(nr, M_DEVBUF);
! 2369: free(pob, M_DEVBUF);
! 2370: break;
! 2371: }
! 2372: case SIOCSIFADDR:
! 2373: ifa = (struct ifaddr *)req;
! 2374: ifp->if_flags |= IFF_UP;
! 2375: #ifdef INET
! 2376: if (ifa->ifa_addr->sa_family == AF_INET)
! 2377: arp_ifinit(&sc->sc_ic.ic_ac, ifa);
! 2378: #endif
! 2379: /* FALLTHROUGH */
! 2380: case SIOCSIFFLAGS:
! 2381: if (ifp->if_flags & IFF_UP) {
! 2382: if ((ifp->if_flags & IFF_RUNNING) == 0) {
! 2383: pgt_init(ifp);
! 2384: error = ENETRESET;
! 2385: }
! 2386: } else {
! 2387: if (ifp->if_flags & IFF_RUNNING) {
! 2388: pgt_stop(sc, SC_NEEDS_RESET);
! 2389: error = ENETRESET;
! 2390: }
! 2391: }
! 2392: break;
! 2393: case SIOCADDMULTI:
! 2394: case SIOCDELMULTI:
! 2395: error = (cmd == SIOCADDMULTI) ?
! 2396: ether_addmulti(ifr, &ic->ic_ac) :
! 2397: ether_delmulti(ifr, &ic->ic_ac);
! 2398:
! 2399: if (error == ENETRESET)
! 2400: error = 0;
! 2401: break;
! 2402: case SIOCSIFMTU:
! 2403: if (ifr->ifr_mtu > PGT_FRAG_SIZE) {
! 2404: error = EINVAL;
! 2405: break;
! 2406: }
! 2407: /* FALLTHROUGH */
! 2408: default:
! 2409: error = ieee80211_ioctl(ifp, cmd, req);
! 2410: break;
! 2411: }
! 2412:
! 2413: if (error == ENETRESET) {
! 2414: pgt_update_hw_from_sw(sc, 0, 0);
! 2415: error = 0;
! 2416: }
! 2417: splx(s);
! 2418:
! 2419: return (error);
! 2420: }
! 2421:
! 2422: void
! 2423: pgt_obj_bss2scanres(struct pgt_softc *sc, struct pgt_obj_bss *pob,
! 2424: struct wi_scan_res *scanres, uint32_t noise)
! 2425: {
! 2426: struct ieee80211_rateset *rs;
! 2427: struct wi_scan_res ap;
! 2428: unsigned int i, n;
! 2429:
! 2430: rs = &sc->sc_ic.ic_sup_rates[IEEE80211_MODE_AUTO];
! 2431: bzero(&ap, sizeof(ap));
! 2432: ap.wi_chan = ieee80211_mhz2ieee(letoh16(pob->pob_channel), 0);
! 2433: ap.wi_noise = noise;
! 2434: ap.wi_signal = letoh16(pob->pob_rssi);
! 2435: IEEE80211_ADDR_COPY(ap.wi_bssid, pob->pob_address);
! 2436: ap.wi_interval = letoh16(pob->pob_beacon_period);
! 2437: ap.wi_capinfo = letoh16(pob->pob_capinfo);
! 2438: ap.wi_ssid_len = min(sizeof(ap.wi_ssid), pob->pob_ssid.pos_length);
! 2439: memcpy(ap.wi_ssid, pob->pob_ssid.pos_ssid, ap.wi_ssid_len);
! 2440: n = 0;
! 2441: for (i = 0; i < 16; i++) {
! 2442: if (letoh16(pob->pob_rates) & (1 << i)) {
! 2443: if (i > rs->rs_nrates)
! 2444: break;
! 2445: ap.wi_srates[n++] = ap.wi_rate = rs->rs_rates[i];
! 2446: if (n >= sizeof(ap.wi_srates) / sizeof(ap.wi_srates[0]))
! 2447: break;
! 2448: }
! 2449: }
! 2450: memcpy(scanres, &ap, WI_PRISM2_RES_SIZE);
! 2451: }
! 2452:
! 2453: void
! 2454: node_mark_active_ap(void *arg, struct ieee80211_node *ni)
! 2455: {
! 2456: /*
! 2457: * HostAP mode lets all nodes stick around unless
! 2458: * the firmware AP kicks them off.
! 2459: */
! 2460: ni->ni_inact = 0;
! 2461: }
! 2462:
! 2463: void
! 2464: node_mark_active_adhoc(void *arg, struct ieee80211_node *ni)
! 2465: {
! 2466: struct pgt_ieee80211_node *pin;
! 2467:
! 2468: /*
! 2469: * As there is no association in ad-hoc, we let links just
! 2470: * time out naturally as long they are not holding any private
! 2471: * configuration, such as 802.1x authorization.
! 2472: */
! 2473: pin = (struct pgt_ieee80211_node *)ni;
! 2474: if (pin->pin_dot1x_auth == PIN_DOT1X_AUTHORIZED)
! 2475: pin->pin_node.ni_inact = 0;
! 2476: }
! 2477:
! 2478: void
! 2479: pgt_watchdog(struct ifnet *ifp)
! 2480: {
! 2481: struct pgt_softc *sc;
! 2482:
! 2483: sc = ifp->if_softc;
! 2484: /*
! 2485: * Check for timed out transmissions (and make sure to set
! 2486: * this watchdog to fire again if there is still data in the
! 2487: * output device queue).
! 2488: */
! 2489: if (sc->sc_dirtyq_count[PGT_QUEUE_DATA_LOW_TX] != 0) {
! 2490: int count;
! 2491:
! 2492: ifp->if_timer = 1;
! 2493: if (sc->sc_txtimer && --sc->sc_txtimer == 0) {
! 2494: count = pgt_drain_tx_queue(sc, PGT_QUEUE_DATA_LOW_TX);
! 2495: if (sc->sc_debug & SC_DEBUG_UNEXPECTED)
! 2496: DPRINTF(("%s: timeout %d data transmissions\n",
! 2497: sc->sc_dev.dv_xname, count));
! 2498: }
! 2499: }
! 2500: if (sc->sc_flags & (SC_DYING | SC_NEEDS_RESET))
! 2501: return;
! 2502: /*
! 2503: * If we're goign to kick the device out of power-save mode
! 2504: * just to update the BSSID and such, we should not do it
! 2505: * very often; need to determine in what way to do that.
! 2506: */
! 2507: if (ifp->if_flags & IFF_RUNNING &&
! 2508: sc->sc_ic.ic_state != IEEE80211_S_INIT &&
! 2509: sc->sc_ic.ic_opmode != IEEE80211_M_MONITOR)
! 2510: pgt_async_update(sc);
! 2511:
! 2512: /*
! 2513: * As a firmware-based HostAP, we should not time out
! 2514: * nodes inside the driver additionally to the timeout
! 2515: * that exists in the firmware. The only things we
! 2516: * should have to deal with timing out when doing HostAP
! 2517: * are the privacy-related.
! 2518: */
! 2519: switch (sc->sc_ic.ic_opmode) {
! 2520: case IEEE80211_M_HOSTAP:
! 2521: ieee80211_iterate_nodes(&sc->sc_ic,
! 2522: node_mark_active_ap, NULL);
! 2523: break;
! 2524: case IEEE80211_M_IBSS:
! 2525: ieee80211_iterate_nodes(&sc->sc_ic,
! 2526: node_mark_active_adhoc, NULL);
! 2527: break;
! 2528: default:
! 2529: break;
! 2530: }
! 2531: ieee80211_watchdog(ifp);
! 2532: ifp->if_timer = 1;
! 2533: }
! 2534:
! 2535: int
! 2536: pgt_init(struct ifnet *ifp)
! 2537: {
! 2538: struct pgt_softc *sc = ifp->if_softc;
! 2539: struct ieee80211com *ic = &sc->sc_ic;
! 2540:
! 2541: /* set default channel */
! 2542: ic->ic_bss->ni_chan = ic->ic_ibss_chan;
! 2543:
! 2544: if (!(sc->sc_flags & (SC_DYING | SC_UNINITIALIZED)))
! 2545: pgt_update_hw_from_sw(sc,
! 2546: ic->ic_state != IEEE80211_S_INIT,
! 2547: ic->ic_opmode != IEEE80211_M_MONITOR);
! 2548:
! 2549: ifp->if_flags |= IFF_RUNNING;
! 2550: ifp->if_flags &= ~IFF_OACTIVE;
! 2551:
! 2552: /* Begin background scanning */
! 2553: ieee80211_new_state(&sc->sc_ic, IEEE80211_S_SCAN, -1);
! 2554:
! 2555: return (0);
! 2556: }
! 2557:
! 2558: /*
! 2559: * After most every configuration change, everything needs to be fully
! 2560: * reinitialized. For some operations (currently, WEP settings
! 2561: * in ad-hoc+802.1x mode), the change is "soft" and doesn't remove
! 2562: * "associations," and allows EAP authorization to occur again.
! 2563: * If keepassoc is specified, the reset operation should try to go
! 2564: * back to the BSS had before.
! 2565: */
! 2566: void
! 2567: pgt_update_hw_from_sw(struct pgt_softc *sc, int keepassoc, int keepnodes)
! 2568: {
! 2569: struct ieee80211com *ic = &sc->sc_ic;
! 2570: struct arpcom *ac = &ic->ic_ac;
! 2571: struct ifnet *ifp = &ac->ac_if;
! 2572: struct pgt_obj_key keyobj;
! 2573: struct pgt_obj_ssid essid;
! 2574: uint8_t availrates[IEEE80211_RATE_MAXSIZE + 1];
! 2575: uint32_t mode, bsstype, config, profile, channel, slot, preamble;
! 2576: uint32_t wep, exunencrypted, wepkey, dot1x, auth, mlme;
! 2577: unsigned int i;
! 2578: int success, shouldbeup, s;
! 2579:
! 2580: config = PGT_CONFIG_MANUAL_RUN | PGT_CONFIG_RX_ANNEX;
! 2581:
! 2582: /*
! 2583: * Promiscuous mode is currently a no-op since packets transmitted,
! 2584: * while in promiscuous mode, don't ever seem to go anywhere.
! 2585: */
! 2586: shouldbeup = ifp->if_flags & IFF_RUNNING && ifp->if_flags & IFF_UP;
! 2587:
! 2588: if (shouldbeup) {
! 2589: switch (ic->ic_opmode) {
! 2590: case IEEE80211_M_STA:
! 2591: if (ifp->if_flags & IFF_PROMISC)
! 2592: mode = PGT_MODE_CLIENT; /* what to do? */
! 2593: else
! 2594: mode = PGT_MODE_CLIENT;
! 2595: bsstype = PGT_BSS_TYPE_STA;
! 2596: dot1x = PGT_DOT1X_AUTH_ENABLED;
! 2597: break;
! 2598: case IEEE80211_M_IBSS:
! 2599: if (ifp->if_flags & IFF_PROMISC)
! 2600: mode = PGT_MODE_CLIENT; /* what to do? */
! 2601: else
! 2602: mode = PGT_MODE_CLIENT;
! 2603: bsstype = PGT_BSS_TYPE_IBSS;
! 2604: dot1x = PGT_DOT1X_AUTH_ENABLED;
! 2605: break;
! 2606: case IEEE80211_M_HOSTAP:
! 2607: mode = PGT_MODE_AP;
! 2608: bsstype = PGT_BSS_TYPE_STA;
! 2609: /*
! 2610: * For IEEE 802.1x, we need to authenticate and
! 2611: * authorize hosts from here on or they remain
! 2612: * associated but without the ability to send or
! 2613: * receive normal traffic to us (courtesy the
! 2614: * firmware AP implementation).
! 2615: */
! 2616: dot1x = PGT_DOT1X_AUTH_ENABLED;
! 2617: /*
! 2618: * WDS mode needs several things to work:
! 2619: * discovery of exactly how creating the WDS
! 2620: * links is meant to function, an interface
! 2621: * for this, and ability to encode or decode
! 2622: * the WDS frames.
! 2623: */
! 2624: if (sc->sc_wds)
! 2625: config |= PGT_CONFIG_WDS;
! 2626: break;
! 2627: case IEEE80211_M_MONITOR:
! 2628: mode = PGT_MODE_PROMISCUOUS;
! 2629: bsstype = PGT_BSS_TYPE_ANY;
! 2630: dot1x = PGT_DOT1X_AUTH_NONE;
! 2631: break;
! 2632: default:
! 2633: goto badopmode;
! 2634: }
! 2635: } else {
! 2636: badopmode:
! 2637: mode = PGT_MODE_CLIENT;
! 2638: bsstype = PGT_BSS_TYPE_NONE;
! 2639: }
! 2640:
! 2641: DPRINTF(("%s: current mode is ", sc->sc_dev.dv_xname));
! 2642: switch (ic->ic_curmode) {
! 2643: case IEEE80211_MODE_11A:
! 2644: profile = PGT_PROFILE_A_ONLY;
! 2645: preamble = PGT_OID_PREAMBLE_MODE_DYNAMIC;
! 2646: DPRINTF(("IEEE80211_MODE_11A\n"));
! 2647: break;
! 2648: case IEEE80211_MODE_11B:
! 2649: profile = PGT_PROFILE_B_ONLY;
! 2650: preamble = PGT_OID_PREAMBLE_MODE_LONG;
! 2651: DPRINTF(("IEEE80211_MODE_11B\n"));
! 2652: break;
! 2653: case IEEE80211_MODE_11G:
! 2654: profile = PGT_PROFILE_G_ONLY;
! 2655: preamble = PGT_OID_PREAMBLE_MODE_SHORT;
! 2656: DPRINTF(("IEEE80211_MODE_11G\n"));
! 2657: break;
! 2658: case IEEE80211_MODE_FH:
! 2659: /* FALLTHROUGH */
! 2660: case IEEE80211_MODE_TURBO: /* not handled */
! 2661: /* FALLTHROUGH */
! 2662: case IEEE80211_MODE_AUTO:
! 2663: profile = PGT_PROFILE_MIXED_G_WIFI;
! 2664: preamble = PGT_OID_PREAMBLE_MODE_DYNAMIC;
! 2665: DPRINTF(("IEEE80211_MODE_AUTO\n"));
! 2666: break;
! 2667: default:
! 2668: panic("unknown mode %d\n", ic->ic_curmode);
! 2669: }
! 2670:
! 2671: switch (sc->sc_80211_ioc_auth) {
! 2672: case IEEE80211_AUTH_NONE:
! 2673: auth = PGT_AUTH_MODE_NONE;
! 2674: break;
! 2675: case IEEE80211_AUTH_OPEN:
! 2676: auth = PGT_AUTH_MODE_OPEN;
! 2677: break;
! 2678: default:
! 2679: auth = PGT_AUTH_MODE_SHARED;
! 2680: break;
! 2681: }
! 2682:
! 2683: if (sc->sc_ic.ic_flags & IEEE80211_F_WEPON) {
! 2684: wep = 1;
! 2685: exunencrypted = 1;
! 2686: } else {
! 2687: wep = 0;
! 2688: exunencrypted = 0;
! 2689: }
! 2690:
! 2691: mlme = htole32(PGT_MLME_AUTO_LEVEL_AUTO);
! 2692: wep = htole32(wep);
! 2693: exunencrypted = htole32(exunencrypted);
! 2694: profile = htole32(profile);
! 2695: preamble = htole32(preamble);
! 2696: bsstype = htole32(bsstype);
! 2697: config = htole32(config);
! 2698: mode = htole32(mode);
! 2699:
! 2700: if (!wep || !sc->sc_dot1x)
! 2701: dot1x = PGT_DOT1X_AUTH_NONE;
! 2702: dot1x = htole32(dot1x);
! 2703: auth = htole32(auth);
! 2704:
! 2705: if (ic->ic_flags & IEEE80211_F_SHSLOT)
! 2706: slot = htole32(PGT_OID_SLOT_MODE_SHORT);
! 2707: else
! 2708: slot = htole32(PGT_OID_SLOT_MODE_DYNAMIC);
! 2709:
! 2710: if (ic->ic_des_chan == IEEE80211_CHAN_ANYC) {
! 2711: if (keepassoc)
! 2712: channel = 0;
! 2713: else
! 2714: channel = ieee80211_chan2ieee(ic, ic->ic_bss->ni_chan);
! 2715: } else
! 2716: channel = ieee80211_chan2ieee(ic, ic->ic_des_chan);
! 2717:
! 2718: DPRINTF(("%s: set rates", sc->sc_dev.dv_xname));
! 2719: for (i = 0; i < ic->ic_sup_rates[ic->ic_curmode].rs_nrates; i++) {
! 2720: availrates[i] = ic->ic_sup_rates[ic->ic_curmode].rs_rates[i];
! 2721: DPRINTF((" %d", availrates[i]));
! 2722: }
! 2723: DPRINTF(("\n"));
! 2724: availrates[i++] = 0;
! 2725:
! 2726: essid.pos_length = min(ic->ic_des_esslen, sizeof(essid.pos_ssid));
! 2727: memcpy(&essid.pos_ssid, ic->ic_des_essid, essid.pos_length);
! 2728:
! 2729: s = splnet();
! 2730: for (success = 0; success == 0; success = 1) {
! 2731: SETOID(PGT_OID_PROFILE, &profile, sizeof(profile));
! 2732: SETOID(PGT_OID_CONFIG, &config, sizeof(config));
! 2733: SETOID(PGT_OID_MLME_AUTO_LEVEL, &mlme, sizeof(mlme));
! 2734:
! 2735: if (!IEEE80211_ADDR_EQ(ic->ic_myaddr, ac->ac_enaddr)) {
! 2736: SETOID(PGT_OID_MAC_ADDRESS, ac->ac_enaddr,
! 2737: sizeof(ac->ac_enaddr));
! 2738: IEEE80211_ADDR_COPY(ic->ic_myaddr, ac->ac_enaddr);
! 2739: }
! 2740:
! 2741: SETOID(PGT_OID_MODE, &mode, sizeof(mode));
! 2742: SETOID(PGT_OID_BSS_TYPE, &bsstype, sizeof(bsstype));
! 2743:
! 2744: if (channel != 0 && channel != IEEE80211_CHAN_ANY)
! 2745: SETOID(PGT_OID_CHANNEL, &channel, sizeof(channel));
! 2746:
! 2747: if (ic->ic_flags & IEEE80211_F_DESBSSID) {
! 2748: SETOID(PGT_OID_BSSID, ic->ic_des_bssid,
! 2749: sizeof(ic->ic_des_bssid));
! 2750: } else if (keepassoc) {
! 2751: SETOID(PGT_OID_BSSID, ic->ic_bss->ni_bssid,
! 2752: sizeof(ic->ic_bss->ni_bssid));
! 2753: }
! 2754:
! 2755: SETOID(PGT_OID_SSID, &essid, sizeof(essid));
! 2756:
! 2757: if (ic->ic_des_esslen > 0)
! 2758: SETOID(PGT_OID_SSID_OVERRIDE, &essid, sizeof(essid));
! 2759:
! 2760: SETOID(PGT_OID_RATES, &availrates, i);
! 2761: SETOID(PGT_OID_EXTENDED_RATES, &availrates, i);
! 2762: SETOID(PGT_OID_PREAMBLE_MODE, &preamble, sizeof(preamble));
! 2763: SETOID(PGT_OID_SLOT_MODE, &slot, sizeof(slot));
! 2764: SETOID(PGT_OID_AUTH_MODE, &auth, sizeof(auth));
! 2765: SETOID(PGT_OID_EXCLUDE_UNENCRYPTED, &exunencrypted,
! 2766: sizeof(exunencrypted));
! 2767: SETOID(PGT_OID_DOT1X, &dot1x, sizeof(dot1x));
! 2768: SETOID(PGT_OID_PRIVACY_INVOKED, &wep, sizeof(wep));
! 2769: /*
! 2770: * Setting WEP key(s)
! 2771: */
! 2772: if (letoh32(wep) != 0) {
! 2773: keyobj.pok_type = PGT_OBJ_KEY_TYPE_WEP;
! 2774: /* key 1 */
! 2775: keyobj.pok_length = min(sizeof(keyobj.pok_key),
! 2776: IEEE80211_KEYBUF_SIZE);
! 2777: keyobj.pok_length = min(keyobj.pok_length,
! 2778: ic->ic_nw_keys[0].k_len);
! 2779: bcopy(ic->ic_nw_keys[0].k_key, keyobj.pok_key,
! 2780: keyobj.pok_length);
! 2781: SETOID(PGT_OID_DEFAULT_KEY0, &keyobj, sizeof(keyobj));
! 2782: /* key 2 */
! 2783: keyobj.pok_length = min(sizeof(keyobj.pok_key),
! 2784: IEEE80211_KEYBUF_SIZE);
! 2785: keyobj.pok_length = min(keyobj.pok_length,
! 2786: ic->ic_nw_keys[1].k_len);
! 2787: bcopy(ic->ic_nw_keys[1].k_key, keyobj.pok_key,
! 2788: keyobj.pok_length);
! 2789: SETOID(PGT_OID_DEFAULT_KEY1, &keyobj, sizeof(keyobj));
! 2790: /* key 3 */
! 2791: keyobj.pok_length = min(sizeof(keyobj.pok_key),
! 2792: IEEE80211_KEYBUF_SIZE);
! 2793: keyobj.pok_length = min(keyobj.pok_length,
! 2794: ic->ic_nw_keys[2].k_len);
! 2795: bcopy(ic->ic_nw_keys[2].k_key, keyobj.pok_key,
! 2796: keyobj.pok_length);
! 2797: SETOID(PGT_OID_DEFAULT_KEY2, &keyobj, sizeof(keyobj));
! 2798: /* key 4 */
! 2799: keyobj.pok_length = min(sizeof(keyobj.pok_key),
! 2800: IEEE80211_KEYBUF_SIZE);
! 2801: keyobj.pok_length = min(keyobj.pok_length,
! 2802: ic->ic_nw_keys[3].k_len);
! 2803: bcopy(ic->ic_nw_keys[3].k_key, keyobj.pok_key,
! 2804: keyobj.pok_length);
! 2805: SETOID(PGT_OID_DEFAULT_KEY3, &keyobj, sizeof(keyobj));
! 2806:
! 2807: wepkey = htole32(ic->ic_wep_txkey);
! 2808: SETOID(PGT_OID_DEFAULT_KEYNUM, &wepkey, sizeof(wepkey));
! 2809: }
! 2810: /* set mode again to commit */
! 2811: SETOID(PGT_OID_MODE, &mode, sizeof(mode));
! 2812: }
! 2813: splx(s);
! 2814:
! 2815: if (success) {
! 2816: if (shouldbeup && keepnodes)
! 2817: sc->sc_flags |= SC_NOFREE_ALLNODES;
! 2818: if (shouldbeup)
! 2819: ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
! 2820: else
! 2821: ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
! 2822: } else {
! 2823: printf("%s: problem setting modes\n", sc->sc_dev.dv_xname);
! 2824: ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
! 2825: }
! 2826: }
! 2827:
! 2828: void
! 2829: pgt_hostap_handle_mlme(struct pgt_softc *sc, uint32_t oid,
! 2830: struct pgt_obj_mlme *mlme)
! 2831: {
! 2832: struct ieee80211com *ic = &sc->sc_ic;
! 2833: struct pgt_ieee80211_node *pin;
! 2834: struct ieee80211_node *ni;
! 2835:
! 2836: ni = ieee80211_find_node(ic, mlme->pom_address);
! 2837: pin = (struct pgt_ieee80211_node *)ni;
! 2838: switch (oid) {
! 2839: case PGT_OID_DISASSOCIATE:
! 2840: if (ni != NULL)
! 2841: ieee80211_release_node(&sc->sc_ic, ni);
! 2842: break;
! 2843: case PGT_OID_ASSOCIATE:
! 2844: if (ni == NULL) {
! 2845: ni = ieee80211_dup_bss(ic, mlme->pom_address);
! 2846: if (ni == NULL)
! 2847: break;
! 2848: ic->ic_newassoc(ic, ni, 1);
! 2849: pin = (struct pgt_ieee80211_node *)ni;
! 2850: }
! 2851: ni->ni_associd = letoh16(mlme->pom_id);
! 2852: pin->pin_mlme_state = letoh16(mlme->pom_state);
! 2853: break;
! 2854: default:
! 2855: if (pin != NULL)
! 2856: pin->pin_mlme_state = letoh16(mlme->pom_state);
! 2857: break;
! 2858: }
! 2859: }
! 2860:
! 2861: /*
! 2862: * Either in response to an event or after a certain amount of time,
! 2863: * synchronize our idea of the network we're part of from the hardware.
! 2864: */
! 2865: void
! 2866: pgt_update_sw_from_hw(struct pgt_softc *sc, struct pgt_async_trap *pa,
! 2867: struct mbuf *args)
! 2868: {
! 2869: struct ieee80211com *ic = &sc->sc_ic;
! 2870: struct pgt_obj_ssid ssid;
! 2871: struct pgt_obj_bss bss;
! 2872: uint32_t channel, noise, ls;
! 2873: int error, s;
! 2874:
! 2875: if (pa != NULL) {
! 2876: struct pgt_obj_mlme *mlme;
! 2877: uint32_t oid;
! 2878:
! 2879: oid = *mtod(args, uint32_t *);
! 2880: m_adj(args, sizeof(uint32_t));
! 2881: if (sc->sc_debug & SC_DEBUG_TRAP)
! 2882: DPRINTF(("%s: trap: oid %#x len %u\n",
! 2883: sc->sc_dev.dv_xname, oid, args->m_len));
! 2884: switch (oid) {
! 2885: case PGT_OID_LINK_STATE:
! 2886: if (args->m_len < sizeof(uint32_t))
! 2887: break;
! 2888: ls = letoh32(*mtod(args, uint32_t *));
! 2889: if (sc->sc_debug & (SC_DEBUG_TRAP | SC_DEBUG_LINK))
! 2890: DPRINTF(("%s: %s: link rate %u\n",
! 2891: sc->sc_dev.dv_xname, __func__, ls));
! 2892: if (ls)
! 2893: ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
! 2894: else
! 2895: ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
! 2896: goto gotlinkstate;
! 2897: case PGT_OID_DEAUTHENTICATE:
! 2898: case PGT_OID_AUTHENTICATE:
! 2899: case PGT_OID_DISASSOCIATE:
! 2900: case PGT_OID_ASSOCIATE:
! 2901: if (args->m_len < sizeof(struct pgt_obj_mlme))
! 2902: break;
! 2903: mlme = mtod(args, struct pgt_obj_mlme *);
! 2904: if (sc->sc_debug & SC_DEBUG_TRAP)
! 2905: DPRINTF(("%s: mlme: address "
! 2906: "%s id 0x%02x state 0x%02x code 0x%02x\n",
! 2907: sc->sc_dev.dv_xname,
! 2908: ether_sprintf(mlme->pom_address),
! 2909: letoh16(mlme->pom_id),
! 2910: letoh16(mlme->pom_state),
! 2911: letoh16(mlme->pom_code)));
! 2912: if (ic->ic_opmode == IEEE80211_M_HOSTAP)
! 2913: pgt_hostap_handle_mlme(sc, oid, mlme);
! 2914: break;
! 2915: }
! 2916: return;
! 2917: }
! 2918: if (ic->ic_state == IEEE80211_S_SCAN) {
! 2919: s = splnet();
! 2920: error = pgt_oid_get(sc, PGT_OID_LINK_STATE, &ls, sizeof(ls));
! 2921: splx(s);
! 2922: if (error)
! 2923: return;
! 2924: DPRINTF(("%s: up_sw_from_hw: link %u\n", sc->sc_dev.dv_xname,
! 2925: htole32(ls)));
! 2926: if (ls != 0)
! 2927: ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
! 2928: }
! 2929:
! 2930: gotlinkstate:
! 2931: s = splnet();
! 2932: if (pgt_oid_get(sc, PGT_OID_NOISE_FLOOR, &noise, sizeof(noise)) != 0)
! 2933: goto out;
! 2934: sc->sc_noise = letoh32(noise);
! 2935: if (ic->ic_state == IEEE80211_S_RUN) {
! 2936: if (pgt_oid_get(sc, PGT_OID_CHANNEL, &channel,
! 2937: sizeof(channel)) != 0)
! 2938: goto out;
! 2939: channel = min(letoh32(channel), IEEE80211_CHAN_MAX);
! 2940: ic->ic_bss->ni_chan = &ic->ic_channels[channel];
! 2941: if (pgt_oid_get(sc, PGT_OID_BSSID, ic->ic_bss->ni_bssid,
! 2942: sizeof(ic->ic_bss->ni_bssid)) != 0)
! 2943: goto out;
! 2944: IEEE80211_ADDR_COPY(&bss.pob_address, ic->ic_bss->ni_bssid);
! 2945: error = pgt_oid_retrieve(sc, PGT_OID_BSS_FIND, &bss,
! 2946: sizeof(bss));
! 2947: if (error == 0)
! 2948: ic->ic_bss->ni_rssi = bss.pob_rssi;
! 2949: else if (error != EPERM)
! 2950: goto out;
! 2951: error = pgt_oid_get(sc, PGT_OID_SSID, &ssid, sizeof(ssid));
! 2952: if (error)
! 2953: goto out;
! 2954: ic->ic_bss->ni_esslen = min(ssid.pos_length,
! 2955: sizeof(ic->ic_bss->ni_essid));
! 2956: memcpy(ic->ic_bss->ni_essid, ssid.pos_ssid,
! 2957: ssid.pos_length);
! 2958: }
! 2959:
! 2960: out:
! 2961: splx(s);
! 2962: }
! 2963:
! 2964: int
! 2965: pgt_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
! 2966: {
! 2967: struct pgt_softc *sc = ic->ic_if.if_softc;
! 2968: enum ieee80211_state ostate;
! 2969:
! 2970: ostate = ic->ic_state;
! 2971:
! 2972: DPRINTF(("%s: newstate %s -> %s\n", sc->sc_dev.dv_xname,
! 2973: ieee80211_state_name[ostate], ieee80211_state_name[nstate]));
! 2974:
! 2975: switch (nstate) {
! 2976: case IEEE80211_S_INIT:
! 2977: if (sc->sc_dirtyq_count[PGT_QUEUE_DATA_LOW_TX] == 0)
! 2978: ic->ic_if.if_timer = 0;
! 2979: ic->ic_mgt_timer = 0;
! 2980: ic->ic_flags &= ~IEEE80211_F_SIBSS;
! 2981: if (ic->ic_wep_ctx != NULL) {
! 2982: free(ic->ic_wep_ctx, M_DEVBUF);
! 2983: ic->ic_wep_ctx = NULL;
! 2984: }
! 2985: ieee80211_free_allnodes(ic);
! 2986: break;
! 2987: case IEEE80211_S_SCAN:
! 2988: ic->ic_if.if_timer = 1;
! 2989: ic->ic_mgt_timer = 0;
! 2990: if (sc->sc_flags & SC_NOFREE_ALLNODES)
! 2991: sc->sc_flags &= ~SC_NOFREE_ALLNODES;
! 2992: else
! 2993: ieee80211_free_allnodes(ic);
! 2994:
! 2995: /* Just use any old channel; we override it anyway. */
! 2996: if (ic->ic_opmode == IEEE80211_M_HOSTAP)
! 2997: ieee80211_create_ibss(ic, ic->ic_ibss_chan);
! 2998: break;
! 2999: case IEEE80211_S_RUN:
! 3000: ic->ic_if.if_timer = 1;
! 3001: break;
! 3002: default:
! 3003: break;
! 3004: }
! 3005:
! 3006: return (sc->sc_newstate(ic, nstate, arg));
! 3007: }
! 3008:
! 3009: int
! 3010: pgt_drain_tx_queue(struct pgt_softc *sc, enum pgt_queue pq)
! 3011: {
! 3012: int wokeup = 0;
! 3013:
! 3014: bus_dmamap_sync(sc->sc_dmat, sc->sc_cbdmam, 0,
! 3015: sc->sc_cbdmam->dm_mapsize,
! 3016: BUS_DMASYNC_POSTREAD | BUS_DMASYNC_PREWRITE);
! 3017: sc->sc_cb->pcb_device_curfrag[pq] =
! 3018: sc->sc_cb->pcb_driver_curfrag[pq];
! 3019: bus_dmamap_sync(sc->sc_dmat, sc->sc_cbdmam, 0,
! 3020: sc->sc_cbdmam->dm_mapsize,
! 3021: BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_PREREAD);
! 3022: while (!TAILQ_EMPTY(&sc->sc_dirtyq[pq])) {
! 3023: struct pgt_desc *pd;
! 3024:
! 3025: pd = TAILQ_FIRST(&sc->sc_dirtyq[pq]);
! 3026: TAILQ_REMOVE(&sc->sc_dirtyq[pq], pd, pd_link);
! 3027: sc->sc_dirtyq_count[pq]--;
! 3028: TAILQ_INSERT_TAIL(&sc->sc_freeq[pq], pd, pd_link);
! 3029: sc->sc_freeq_count[pq]++;
! 3030: pgt_unload_tx_desc_frag(sc, pd);
! 3031: if (sc->sc_debug & SC_DEBUG_QUEUES)
! 3032: DPRINTF(("%s: queue: tx %u <- [%u] (drained)\n",
! 3033: sc->sc_dev.dv_xname, pd->pd_fragnum, pq));
! 3034: wokeup++;
! 3035: if (pgt_queue_is_data(pq))
! 3036: sc->sc_ic.ic_if.if_oerrors++;
! 3037: }
! 3038:
! 3039: return (wokeup);
! 3040: }
! 3041:
! 3042: int
! 3043: pgt_dma_alloc(struct pgt_softc *sc)
! 3044: {
! 3045: size_t size;
! 3046: int i, error, nsegs;
! 3047:
! 3048: for (i = 0; i < PGT_QUEUE_COUNT; i++) {
! 3049: TAILQ_INIT(&sc->sc_freeq[i]);
! 3050: TAILQ_INIT(&sc->sc_dirtyq[i]);
! 3051: }
! 3052:
! 3053: /*
! 3054: * control block
! 3055: */
! 3056: size = sizeof(struct pgt_control_block);
! 3057:
! 3058: error = bus_dmamap_create(sc->sc_dmat, size, 1, size, 0,
! 3059: BUS_DMA_NOWAIT, &sc->sc_cbdmam);
! 3060: if (error != 0) {
! 3061: printf("%s: can not create DMA tag for control block\n",
! 3062: sc->sc_dev.dv_xname);
! 3063: goto out;
! 3064: }
! 3065:
! 3066: error = bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE,
! 3067: 0, &sc->sc_cbdmas, 1, &nsegs, BUS_DMA_NOWAIT);
! 3068: if (error != 0) {
! 3069: printf("%s: can not allocate DMA memory for control block\n",
! 3070: sc->sc_dev.dv_xname);
! 3071: goto out;
! 3072: }
! 3073:
! 3074: error = bus_dmamem_map(sc->sc_dmat, &sc->sc_cbdmas, nsegs,
! 3075: size, (caddr_t *)&sc->sc_cb, BUS_DMA_NOWAIT);
! 3076: if (error != 0) {
! 3077: printf("%s: can not map DMA memory for control block\n",
! 3078: sc->sc_dev.dv_xname);
! 3079: goto out;
! 3080: }
! 3081: bzero(sc->sc_cb, size);
! 3082:
! 3083: error = bus_dmamap_load(sc->sc_dmat, sc->sc_cbdmam,
! 3084: sc->sc_cb, size, NULL, BUS_DMA_NOWAIT);
! 3085: if (error != 0) {
! 3086: printf("%s: can not load DMA map for control block\n",
! 3087: sc->sc_dev.dv_xname);
! 3088: goto out;
! 3089: }
! 3090:
! 3091: /*
! 3092: * powersave
! 3093: */
! 3094: size = PGT_FRAG_SIZE * PGT_PSM_BUFFER_FRAME_COUNT;
! 3095:
! 3096: error = bus_dmamap_create(sc->sc_dmat, size, 1, size, 0,
! 3097: BUS_DMA_ALLOCNOW, &sc->sc_psmdmam);
! 3098: if (error != 0) {
! 3099: printf("%s: can not create DMA tag for powersave\n",
! 3100: sc->sc_dev.dv_xname);
! 3101: goto out;
! 3102: }
! 3103:
! 3104: error = bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE,
! 3105: 0, &sc->sc_psmdmas, 1, &nsegs, BUS_DMA_NOWAIT);
! 3106: if (error != 0) {
! 3107: printf("%s: can not allocate DMA memory for powersave\n",
! 3108: sc->sc_dev.dv_xname);
! 3109: goto out;
! 3110: }
! 3111:
! 3112: error = bus_dmamem_map(sc->sc_dmat, &sc->sc_psmdmas, nsegs,
! 3113: size, (caddr_t *)&sc->sc_psmbuf, BUS_DMA_NOWAIT);
! 3114: if (error != 0) {
! 3115: printf("%s: can not map DMA memory for powersave\n",
! 3116: sc->sc_dev.dv_xname);
! 3117: goto out;
! 3118: }
! 3119: bzero(sc->sc_psmbuf, size);
! 3120:
! 3121: error = bus_dmamap_load(sc->sc_dmat, sc->sc_psmdmam,
! 3122: sc->sc_psmbuf, size, NULL, BUS_DMA_WAITOK);
! 3123: if (error != 0) {
! 3124: printf("%s: can not load DMA map for powersave\n",
! 3125: sc->sc_dev.dv_xname);
! 3126: goto out;
! 3127: }
! 3128:
! 3129: /*
! 3130: * fragments
! 3131: */
! 3132: error = pgt_dma_alloc_queue(sc, PGT_QUEUE_DATA_LOW_RX);
! 3133: if (error != 0)
! 3134: goto out;
! 3135:
! 3136: error = pgt_dma_alloc_queue(sc, PGT_QUEUE_DATA_LOW_TX);
! 3137: if (error != 0)
! 3138: goto out;
! 3139:
! 3140: error = pgt_dma_alloc_queue(sc, PGT_QUEUE_DATA_HIGH_RX);
! 3141: if (error != 0)
! 3142: goto out;
! 3143:
! 3144: error = pgt_dma_alloc_queue(sc, PGT_QUEUE_DATA_HIGH_TX);
! 3145: if (error != 0)
! 3146: goto out;
! 3147:
! 3148: error = pgt_dma_alloc_queue(sc, PGT_QUEUE_MGMT_RX);
! 3149: if (error != 0)
! 3150: goto out;
! 3151:
! 3152: error = pgt_dma_alloc_queue(sc, PGT_QUEUE_MGMT_TX);
! 3153: if (error != 0)
! 3154: goto out;
! 3155:
! 3156: out:
! 3157: if (error) {
! 3158: printf("%s: error in DMA allocation\n", sc->sc_dev.dv_xname);
! 3159: pgt_dma_free(sc);
! 3160: }
! 3161:
! 3162: return (error);
! 3163: }
! 3164:
! 3165: int
! 3166: pgt_dma_alloc_queue(struct pgt_softc *sc, enum pgt_queue pq)
! 3167: {
! 3168: struct pgt_desc *pd;
! 3169: struct pgt_frag *pcbqueue;
! 3170: size_t i, qsize;
! 3171: int error, nsegs;
! 3172:
! 3173: switch (pq) {
! 3174: case PGT_QUEUE_DATA_LOW_RX:
! 3175: pcbqueue = sc->sc_cb->pcb_data_low_rx;
! 3176: qsize = PGT_QUEUE_DATA_RX_SIZE;
! 3177: break;
! 3178: case PGT_QUEUE_DATA_LOW_TX:
! 3179: pcbqueue = sc->sc_cb->pcb_data_low_tx;
! 3180: qsize = PGT_QUEUE_DATA_TX_SIZE;
! 3181: break;
! 3182: case PGT_QUEUE_DATA_HIGH_RX:
! 3183: pcbqueue = sc->sc_cb->pcb_data_high_rx;
! 3184: qsize = PGT_QUEUE_DATA_RX_SIZE;
! 3185: break;
! 3186: case PGT_QUEUE_DATA_HIGH_TX:
! 3187: pcbqueue = sc->sc_cb->pcb_data_high_tx;
! 3188: qsize = PGT_QUEUE_DATA_TX_SIZE;
! 3189: break;
! 3190: case PGT_QUEUE_MGMT_RX:
! 3191: pcbqueue = sc->sc_cb->pcb_mgmt_rx;
! 3192: qsize = PGT_QUEUE_MGMT_SIZE;
! 3193: break;
! 3194: case PGT_QUEUE_MGMT_TX:
! 3195: pcbqueue = sc->sc_cb->pcb_mgmt_tx;
! 3196: qsize = PGT_QUEUE_MGMT_SIZE;
! 3197: break;
! 3198: }
! 3199:
! 3200: for (i = 0; i < qsize; i++) {
! 3201: pd = malloc(sizeof(*pd), M_DEVBUF, M_WAITOK);
! 3202:
! 3203: error = bus_dmamap_create(sc->sc_dmat, PGT_FRAG_SIZE, 1,
! 3204: PGT_FRAG_SIZE, 0, BUS_DMA_ALLOCNOW, &pd->pd_dmam);
! 3205: if (error != 0) {
! 3206: printf("%s: can not create DMA tag for fragment\n",
! 3207: sc->sc_dev.dv_xname);
! 3208: free(pd, M_DEVBUF);
! 3209: break;
! 3210: }
! 3211:
! 3212: error = bus_dmamem_alloc(sc->sc_dmat, PGT_FRAG_SIZE, PAGE_SIZE,
! 3213: 0, &pd->pd_dmas, 1, &nsegs, BUS_DMA_WAITOK);
! 3214: if (error != 0) {
! 3215: printf("%s: error alloc frag %u on queue %u\n",
! 3216: sc->sc_dev.dv_xname, i, pq);
! 3217: free(pd, M_DEVBUF);
! 3218: break;
! 3219: }
! 3220:
! 3221: error = bus_dmamem_map(sc->sc_dmat, &pd->pd_dmas, nsegs,
! 3222: PGT_FRAG_SIZE, (caddr_t *)&pd->pd_mem, BUS_DMA_WAITOK);
! 3223: if (error != 0) {
! 3224: printf("%s: error map frag %u on queue %u\n",
! 3225: sc->sc_dev.dv_xname, i, pq);
! 3226: free(pd, M_DEVBUF);
! 3227: break;
! 3228: }
! 3229:
! 3230: if (pgt_queue_is_rx(pq)) {
! 3231: error = bus_dmamap_load(sc->sc_dmat, pd->pd_dmam,
! 3232: pd->pd_mem, PGT_FRAG_SIZE, NULL, BUS_DMA_NOWAIT);
! 3233: if (error != 0) {
! 3234: printf("%s: error load frag %u on queue %u\n",
! 3235: sc->sc_dev.dv_xname, i, pq);
! 3236: bus_dmamem_free(sc->sc_dmat, &pd->pd_dmas,
! 3237: nsegs);
! 3238: free(pd, M_DEVBUF);
! 3239: break;
! 3240: }
! 3241: pd->pd_dmaaddr = pd->pd_dmam->dm_segs[0].ds_addr;
! 3242: }
! 3243: TAILQ_INSERT_TAIL(&sc->sc_freeq[pq], pd, pd_link);
! 3244: }
! 3245:
! 3246: return (error);
! 3247: }
! 3248:
! 3249: void
! 3250: pgt_dma_free(struct pgt_softc *sc)
! 3251: {
! 3252: /*
! 3253: * fragments
! 3254: */
! 3255: if (sc->sc_dmat != NULL) {
! 3256: pgt_dma_free_queue(sc, PGT_QUEUE_DATA_LOW_RX);
! 3257: pgt_dma_free_queue(sc, PGT_QUEUE_DATA_LOW_TX);
! 3258: pgt_dma_free_queue(sc, PGT_QUEUE_DATA_HIGH_RX);
! 3259: pgt_dma_free_queue(sc, PGT_QUEUE_DATA_HIGH_TX);
! 3260: pgt_dma_free_queue(sc, PGT_QUEUE_MGMT_RX);
! 3261: pgt_dma_free_queue(sc, PGT_QUEUE_MGMT_TX);
! 3262: }
! 3263:
! 3264: /*
! 3265: * powersave
! 3266: */
! 3267: if (sc->sc_psmbuf != NULL) {
! 3268: bus_dmamap_unload(sc->sc_dmat, sc->sc_psmdmam);
! 3269: bus_dmamem_free(sc->sc_dmat, &sc->sc_psmdmas, 1);
! 3270: sc->sc_psmbuf = NULL;
! 3271: sc->sc_psmdmam = NULL;
! 3272: }
! 3273:
! 3274: /*
! 3275: * control block
! 3276: */
! 3277: if (sc->sc_cb != NULL) {
! 3278: bus_dmamap_unload(sc->sc_dmat, sc->sc_cbdmam);
! 3279: bus_dmamem_free(sc->sc_dmat, &sc->sc_cbdmas, 1);
! 3280: sc->sc_cb = NULL;
! 3281: sc->sc_cbdmam = NULL;
! 3282: }
! 3283: }
! 3284:
! 3285: void
! 3286: pgt_dma_free_queue(struct pgt_softc *sc, enum pgt_queue pq)
! 3287: {
! 3288: struct pgt_desc *pd;
! 3289:
! 3290: while (!TAILQ_EMPTY(&sc->sc_freeq[pq])) {
! 3291: pd = TAILQ_FIRST(&sc->sc_freeq[pq]);
! 3292: TAILQ_REMOVE(&sc->sc_freeq[pq], pd, pd_link);
! 3293: if (pd->pd_dmam != NULL) {
! 3294: bus_dmamap_unload(sc->sc_dmat, pd->pd_dmam);
! 3295: pd->pd_dmam = NULL;
! 3296: }
! 3297: bus_dmamem_free(sc->sc_dmat, &pd->pd_dmas, 1);
! 3298: free(pd, M_DEVBUF);
! 3299: }
! 3300: }
! 3301:
! 3302: void
! 3303: pgt_shutdown(void *arg)
! 3304: {
! 3305: struct pgt_softc *sc = arg;
! 3306:
! 3307: DPRINTF(("%s: %s\n", sc->sc_dev.dv_xname, __func__));
! 3308:
! 3309: pgt_stop(sc, SC_DYING);
! 3310: }
! 3311:
! 3312: void
! 3313: pgt_power(int why, void *arg)
! 3314: {
! 3315: struct pgt_softc *sc = arg;
! 3316: struct ifnet *ifp = &sc->sc_ic.ic_if;
! 3317: int s;
! 3318:
! 3319: DPRINTF(("%s: %s(%d)\n", sc->sc_dev.dv_xname, __func__, why));
! 3320:
! 3321: s = splnet();
! 3322:
! 3323: switch (why) {
! 3324: case PWR_STANDBY:
! 3325: case PWR_SUSPEND:
! 3326: pgt_stop(sc, SC_NEEDS_RESET);
! 3327: pgt_update_hw_from_sw(sc, 0, 0);
! 3328:
! 3329: if (sc->sc_power != NULL)
! 3330: (*sc->sc_power)(sc, why);
! 3331: break;
! 3332: case PWR_RESUME:
! 3333: if (sc->sc_power != NULL)
! 3334: (*sc->sc_power)(sc, why);
! 3335:
! 3336: pgt_stop(sc, SC_NEEDS_RESET);
! 3337: pgt_update_hw_from_sw(sc, 0, 0);
! 3338:
! 3339: if ((ifp->if_flags & IFF_UP) &&
! 3340: !(ifp->if_flags & IFF_RUNNING)) {
! 3341: pgt_init(ifp);
! 3342: pgt_update_hw_from_sw(sc, 0, 0);
! 3343: }
! 3344: break;
! 3345: }
! 3346:
! 3347: splx(s);
! 3348: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to pgt.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic