Annotation of sys/dev/pcmcia/if_malo.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: if_malo.c,v 1.55 2007/08/14 22:33:17 mglocker Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2007 Marcus Glocker <mglocker@openbsd.org>
! 5: *
! 6: * Permission to use, copy, modify, and distribute this software for any
! 7: * purpose with or without fee is hereby granted, provided that the above
! 8: * copyright notice and this permission notice appear in all copies.
! 9: *
! 10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
! 11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
! 13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
! 16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 17: */
! 18:
! 19: #include "bpfilter.h"
! 20:
! 21: #include <sys/param.h>
! 22: #include <sys/proc.h>
! 23: #include <sys/systm.h>
! 24: #include <sys/kernel.h>
! 25: #include <sys/device.h>
! 26: #include <sys/timeout.h>
! 27: #include <sys/socket.h>
! 28: #include <sys/tree.h>
! 29: #include <sys/malloc.h>
! 30: #include <sys/sockio.h>
! 31: #include <sys/mbuf.h>
! 32:
! 33: #if NBPFILTER > 0
! 34: #include <net/bpf.h>
! 35: #endif
! 36:
! 37: #include <net/if.h>
! 38: #include <net/if_media.h>
! 39: #include <net/if_llc.h>
! 40:
! 41: #include <netinet/in.h>
! 42: #include <netinet/in_systm.h>
! 43: #include <netinet/if_ether.h>
! 44:
! 45: #include <net80211/ieee80211_var.h>
! 46: #include <net80211/ieee80211_radiotap.h>
! 47:
! 48: #include <machine/bus.h>
! 49: #include <machine/intr.h>
! 50:
! 51: #include <dev/pcmcia/pcmciareg.h>
! 52: #include <dev/pcmcia/pcmciavar.h>
! 53: #include <dev/pcmcia/pcmciadevs.h>
! 54:
! 55: #include <dev/pcmcia/if_malovar.h>
! 56: #include <dev/pcmcia/if_maloreg.h>
! 57:
! 58: /*
! 59: * Driver for the Marvell 88W8385 chip (Compact Flash).
! 60: */
! 61:
! 62: #ifdef CMALO_DEBUG
! 63: int cmalo_d = 1;
! 64: #define DPRINTF(l, x...) do { if ((l) <= cmalo_d) printf(x); } while (0)
! 65: #else
! 66: #define DPRINTF(l, x...)
! 67: #endif
! 68:
! 69: int malo_pcmcia_match(struct device *, void *, void *);
! 70: void malo_pcmcia_attach(struct device *, struct device *, void *);
! 71: int malo_pcmcia_detach(struct device *, int);
! 72: int malo_pcmcia_activate(struct device *, enum devact);
! 73:
! 74: void cmalo_attach(void *);
! 75: int cmalo_ioctl(struct ifnet *, u_long, caddr_t);
! 76: int cmalo_fw_load_helper(struct malo_softc *);
! 77: int cmalo_fw_load_main(struct malo_softc *);
! 78: int cmalo_init(struct ifnet *);
! 79: void cmalo_stop(struct malo_softc *);
! 80: int cmalo_media_change(struct ifnet *);
! 81: int cmalo_newstate(struct ieee80211com *, enum ieee80211_state, int);
! 82: void cmalo_detach(void *);
! 83: int cmalo_intr(void *);
! 84: void cmalo_intr_mask(struct malo_softc *, int);
! 85: void cmalo_rx(struct malo_softc *);
! 86: void cmalo_start(struct ifnet *);
! 87: void cmalo_watchdog(struct ifnet *);
! 88: int cmalo_tx(struct malo_softc *, struct mbuf *);
! 89: void cmalo_tx_done(struct malo_softc *);
! 90: void cmalo_event(struct malo_softc *);
! 91: void cmalo_select_network(struct malo_softc *);
! 92: void cmalo_reflect_network(struct malo_softc *);
! 93: int cmalo_wep(struct malo_softc *);
! 94:
! 95: void cmalo_hexdump(void *, int);
! 96: int cmalo_cmd_get_hwspec(struct malo_softc *);
! 97: int cmalo_cmd_rsp_hwspec(struct malo_softc *);
! 98: int cmalo_cmd_set_reset(struct malo_softc *);
! 99: int cmalo_cmd_set_scan(struct malo_softc *);
! 100: int cmalo_cmd_rsp_scan(struct malo_softc *);
! 101: int cmalo_parse_elements(struct malo_softc *, void *, int, int);
! 102: int cmalo_cmd_set_auth(struct malo_softc *);
! 103: int cmalo_cmd_set_wep(struct malo_softc *, uint16_t,
! 104: struct ieee80211_key *);
! 105: int cmalo_cmd_set_snmp(struct malo_softc *, uint16_t);
! 106: int cmalo_cmd_set_radio(struct malo_softc *, uint16_t);
! 107: int cmalo_cmd_set_channel(struct malo_softc *, uint16_t);
! 108: int cmalo_cmd_set_txpower(struct malo_softc *, int16_t);
! 109: int cmalo_cmd_set_antenna(struct malo_softc *, uint16_t);
! 110: int cmalo_cmd_set_macctrl(struct malo_softc *);
! 111: int cmalo_cmd_set_assoc(struct malo_softc *);
! 112: int cmalo_cmd_rsp_assoc(struct malo_softc *);
! 113: int cmalo_cmd_set_80211d(struct malo_softc *);
! 114: int cmalo_cmd_set_bgscan_config(struct malo_softc *);
! 115: int cmalo_cmd_set_bgscan_query(struct malo_softc *);
! 116: int cmalo_cmd_set_rate(struct malo_softc *);
! 117: int cmalo_cmd_request(struct malo_softc *, uint16_t, int);
! 118: int cmalo_cmd_response(struct malo_softc *);
! 119:
! 120: /*
! 121: * PCMCIA bus.
! 122: */
! 123: struct malo_pcmcia_softc {
! 124: struct malo_softc sc_malo;
! 125:
! 126: struct pcmcia_function *sc_pf;
! 127: struct pcmcia_io_handle sc_pcioh;
! 128: int sc_io_window;
! 129: void *sc_ih;
! 130: };
! 131:
! 132: struct cfattach malo_pcmcia_ca = {
! 133: sizeof(struct malo_pcmcia_softc),
! 134: malo_pcmcia_match,
! 135: malo_pcmcia_attach,
! 136: malo_pcmcia_detach,
! 137: malo_pcmcia_activate
! 138: };
! 139:
! 140: int
! 141: malo_pcmcia_match(struct device *parent, void *match, void *aux)
! 142: {
! 143: struct pcmcia_attach_args *pa = aux;
! 144:
! 145: if (pa->manufacturer == PCMCIA_VENDOR_AMBICOM &&
! 146: pa->product == PCMCIA_PRODUCT_AMBICOM_WL54CF)
! 147: return (1);
! 148:
! 149: return (0);
! 150: }
! 151:
! 152: void
! 153: malo_pcmcia_attach(struct device *parent, struct device *self, void *aux)
! 154: {
! 155: struct malo_pcmcia_softc *psc = (struct malo_pcmcia_softc *)self;
! 156: struct malo_softc *sc = &psc->sc_malo;
! 157: struct pcmcia_attach_args *pa = aux;
! 158: struct pcmcia_config_entry *cfe;
! 159: const char *intrstr = NULL;
! 160:
! 161: psc->sc_pf = pa->pf;
! 162: cfe = SIMPLEQ_FIRST(&pa->pf->cfe_head);
! 163:
! 164: /* enable card */
! 165: pcmcia_function_init(psc->sc_pf, cfe);
! 166: if (pcmcia_function_enable(psc->sc_pf)) {
! 167: printf(": can't enable function!\n");
! 168: return;
! 169: }
! 170:
! 171: /* allocate I/O space */
! 172: if (pcmcia_io_alloc(psc->sc_pf, 0,
! 173: cfe->iospace[0].length, cfe->iospace[0].length, &psc->sc_pcioh)) {
! 174: printf(": can't allocate i/o space!\n");
! 175: pcmcia_function_disable(psc->sc_pf);
! 176: return;
! 177: }
! 178:
! 179: /* map I/O space */
! 180: if (pcmcia_io_map(psc->sc_pf, PCMCIA_WIDTH_IO16, 0,
! 181: cfe->iospace[0].length, &psc->sc_pcioh, &psc->sc_io_window)) {
! 182: printf(": can't map i/o space!\n");
! 183: pcmcia_io_free(psc->sc_pf, &psc->sc_pcioh);
! 184: pcmcia_function_disable(psc->sc_pf);
! 185: return;
! 186: }
! 187: sc->sc_iot = psc->sc_pcioh.iot;
! 188: sc->sc_ioh = psc->sc_pcioh.ioh;
! 189:
! 190: printf(" port 0x%x/%d", psc->sc_pcioh.addr, psc->sc_pcioh.size);
! 191:
! 192: /* establish interrupt */
! 193: psc->sc_ih = pcmcia_intr_establish(psc->sc_pf, IPL_NET, cmalo_intr, sc,
! 194: sc->sc_dev.dv_xname);
! 195: if (psc->sc_ih == NULL) {
! 196: printf(": can't establish interrupt!\n");
! 197: return;
! 198: }
! 199: intrstr = pcmcia_intr_string(psc->sc_pf, psc->sc_ih);
! 200: if (intrstr != NULL) {
! 201: if (*intrstr != NULL)
! 202: printf(", %s", intrstr);
! 203: }
! 204: printf("\n");
! 205:
! 206: /* attach device */
! 207: if (rootvp == NULL)
! 208: mountroothook_establish(cmalo_attach, sc);
! 209: else
! 210: cmalo_attach(sc);
! 211: }
! 212:
! 213: int
! 214: malo_pcmcia_detach(struct device *dev, int flags)
! 215: {
! 216: struct malo_pcmcia_softc *psc = (struct malo_pcmcia_softc *)dev;
! 217: struct malo_softc *sc = &psc->sc_malo;
! 218:
! 219: cmalo_detach(sc);
! 220:
! 221: pcmcia_io_unmap(psc->sc_pf, psc->sc_io_window);
! 222: pcmcia_io_free(psc->sc_pf, &psc->sc_pcioh);
! 223:
! 224: return (0);
! 225: }
! 226:
! 227: int
! 228: malo_pcmcia_activate(struct device *dev, enum devact act)
! 229: {
! 230: struct malo_pcmcia_softc *psc = (struct malo_pcmcia_softc *)dev;
! 231: struct malo_softc *sc = &psc->sc_malo;
! 232: struct ieee80211com *ic = &sc->sc_ic;
! 233: struct ifnet *ifp = &ic->ic_if;
! 234: int s;
! 235:
! 236: s = splnet();
! 237: switch (act) {
! 238: case DVACT_ACTIVATE:
! 239: pcmcia_function_enable(psc->sc_pf);
! 240: psc->sc_ih = pcmcia_intr_establish(psc->sc_pf, IPL_NET,
! 241: cmalo_intr, sc, sc->sc_dev.dv_xname);
! 242: cmalo_init(ifp);
! 243: break;
! 244: case DVACT_DEACTIVATE:
! 245: ifp->if_timer = 0;
! 246: if (ifp->if_flags & IFF_RUNNING)
! 247: cmalo_stop(sc);
! 248: if (psc->sc_ih != NULL)
! 249: pcmcia_intr_disestablish(psc->sc_pf, psc->sc_ih);
! 250: pcmcia_function_disable(psc->sc_pf);
! 251: break;
! 252: }
! 253: splx(s);
! 254:
! 255: return (0);
! 256: }
! 257:
! 258: /*
! 259: * Driver.
! 260: */
! 261: void
! 262: cmalo_attach(void *arg)
! 263: {
! 264: struct malo_softc *sc = arg;
! 265: struct ieee80211com *ic = &sc->sc_ic;
! 266: struct ifnet *ifp = &sc->sc_ic.ic_if;
! 267: int i;
! 268:
! 269: /* disable interrupts */
! 270: cmalo_intr_mask(sc, 0);
! 271:
! 272: /* load firmware */
! 273: if (cmalo_fw_load_helper(sc) != 0)
! 274: return;
! 275: if (cmalo_fw_load_main(sc) != 0)
! 276: return;
! 277: sc->sc_flags |= MALO_FW_LOADED;
! 278:
! 279: /* allocate command buffer */
! 280: sc->sc_cmd = malloc(MALO_CMD_BUFFER_SIZE, M_DEVBUF, M_NOWAIT);
! 281:
! 282: /* allocate data buffer */
! 283: sc->sc_data = malloc(MCLBYTES, M_DEVBUF, M_NOWAIT);
! 284:
! 285: /* enable interrupts */
! 286: cmalo_intr_mask(sc, 1);
! 287:
! 288: /* we are context save here for FW commands */
! 289: sc->sc_cmd_ctxsave = 1;
! 290:
! 291: /* get hardware specs */
! 292: cmalo_cmd_get_hwspec(sc);
! 293:
! 294: /* setup interface */
! 295: ifp->if_softc = sc;
! 296: ifp->if_ioctl = cmalo_ioctl;
! 297: ifp->if_init = cmalo_init;
! 298: ifp->if_start = cmalo_start;
! 299: ifp->if_watchdog = cmalo_watchdog;
! 300: ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST;
! 301: strlcpy(ifp->if_xname, sc->sc_dev.dv_xname, IFNAMSIZ);
! 302: IFQ_SET_READY(&ifp->if_snd);
! 303:
! 304: ic->ic_opmode = IEEE80211_M_STA;
! 305: ic->ic_state = IEEE80211_S_INIT;
! 306: ic->ic_caps = IEEE80211_C_MONITOR | IEEE80211_C_WEP;
! 307:
! 308: ic->ic_sup_rates[IEEE80211_MODE_11B] = ieee80211_std_rateset_11b;
! 309: ic->ic_sup_rates[IEEE80211_MODE_11G] = ieee80211_std_rateset_11g;
! 310:
! 311: for (i = 0; i <= 14; i++) {
! 312: ic->ic_channels[i].ic_freq =
! 313: ieee80211_ieee2mhz(i, IEEE80211_CHAN_2GHZ);
! 314: ic->ic_channels[i].ic_flags =
! 315: IEEE80211_CHAN_B |
! 316: IEEE80211_CHAN_G;
! 317: }
! 318:
! 319: /* attach interface */
! 320: if_attach(ifp);
! 321: ieee80211_ifattach(ifp);
! 322:
! 323: sc->sc_newstate = ic->ic_newstate;
! 324: ic->ic_newstate = cmalo_newstate;
! 325: ieee80211_media_init(ifp, cmalo_media_change, ieee80211_media_status);
! 326:
! 327: /* second attach line */
! 328: printf("%s: address %s\n",
! 329: sc->sc_dev.dv_xname, ether_sprintf(ic->ic_myaddr));
! 330:
! 331: /* device attached */
! 332: sc->sc_flags |= MALO_DEVICE_ATTACHED;
! 333: }
! 334:
! 335: int
! 336: cmalo_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
! 337: {
! 338: struct malo_softc *sc = ifp->if_softc;
! 339: struct ieee80211com *ic = &sc->sc_ic;
! 340: struct ieee80211_nodereq_all *na;
! 341: struct ieee80211_nodereq *nr;
! 342: struct ifaddr *ifa;
! 343: struct ifreq *ifr;
! 344: int i, j, s, error = 0;
! 345:
! 346: s = splnet();
! 347:
! 348: switch (cmd) {
! 349: case SIOCSIFADDR:
! 350: ifa = (struct ifaddr *)data;
! 351: ifp->if_flags |= IFF_UP;
! 352: #ifdef INET
! 353: if (ifa->ifa_addr->sa_family == AF_INET)
! 354: arp_ifinit(&ic->ic_ac, ifa);
! 355: #endif
! 356: /* FALLTHROUGH */
! 357: case SIOCSIFFLAGS:
! 358: if (ifp->if_flags & IFF_UP) {
! 359: if ((ifp->if_flags & IFF_RUNNING) == 0)
! 360: cmalo_init(ifp);
! 361: } else {
! 362: if (ifp->if_flags & IFF_RUNNING)
! 363: cmalo_stop(sc);
! 364: }
! 365: break;
! 366: case SIOCADDMULTI:
! 367: case SIOCDELMULTI:
! 368: ifr = (struct ifreq *)data;
! 369: error = (cmd == SIOCADDMULTI) ?
! 370: ether_addmulti(ifr, &ic->ic_ac) :
! 371: ether_delmulti(ifr, &ic->ic_ac);
! 372: if (error == ENETRESET)
! 373: error = 0;
! 374: break;
! 375: case SIOCS80211SCAN:
! 376: cmalo_cmd_set_scan(sc);
! 377: break;
! 378: case SIOCG80211ALLNODES:
! 379: nr = NULL;
! 380: na = (struct ieee80211_nodereq_all *)data;
! 381:
! 382: if ((nr = malloc(sizeof(*nr), M_DEVBUF, M_WAITOK)) == NULL)
! 383: break;
! 384:
! 385: for (na->na_nodes = i = j = 0; i < sc->sc_net_num &&
! 386: (na->na_size >= j + sizeof(struct ieee80211_nodereq));
! 387: i++) {
! 388: bzero(nr, sizeof(*nr));
! 389:
! 390: IEEE80211_ADDR_COPY(nr->nr_macaddr,
! 391: sc->sc_net[i].bssid);
! 392: IEEE80211_ADDR_COPY(nr->nr_bssid,
! 393: sc->sc_net[i].bssid);
! 394: nr->nr_channel = sc->sc_net[i].channel;
! 395: nr->nr_chan_flags = IEEE80211_CHAN_B; /* XXX */
! 396: nr->nr_rssi = sc->sc_net[i].rssi;
! 397: nr->nr_max_rssi = 0; /* XXX */
! 398: nr->nr_nwid_len = strlen(sc->sc_net[i].ssid);
! 399: bcopy(sc->sc_net[i].ssid, nr->nr_nwid,
! 400: nr->nr_nwid_len);
! 401: nr->nr_intval = sc->sc_net[i].beaconintvl;
! 402: nr->nr_capinfo = sc->sc_net[i].capinfo;
! 403: nr->nr_flags |= IEEE80211_NODEREQ_AP;
! 404:
! 405: if (copyout(nr, (caddr_t)na->na_node + j,
! 406: sizeof(struct ieee80211_nodereq)))
! 407: break;
! 408:
! 409: j += sizeof(struct ieee80211_nodereq);
! 410: na->na_nodes++;
! 411: }
! 412:
! 413: if (nr)
! 414: free(nr, M_DEVBUF);
! 415: break;
! 416: default:
! 417: error = ieee80211_ioctl(ifp, cmd, data);
! 418: break;
! 419: }
! 420:
! 421: if (error == ENETRESET) {
! 422: if (ifp->if_flags & (IFF_UP | IFF_RUNNING))
! 423: cmalo_init(ifp);
! 424: error = 0;
! 425: }
! 426:
! 427: splx(s);
! 428:
! 429: return (error);
! 430: }
! 431:
! 432: int
! 433: cmalo_fw_load_helper(struct malo_softc *sc)
! 434: {
! 435: const char *name = "malo8385-h";
! 436: size_t usize;
! 437: uint8_t val8, *ucode;
! 438: uint16_t bsize, *uc;
! 439: int error, offset, i;
! 440:
! 441: /* verify if the card is ready for firmware download */
! 442: val8 = MALO_READ_1(sc, MALO_REG_SCRATCH);
! 443: if (val8 == MALO_VAL_SCRATCH_FW_LOADED)
! 444: /* firmware already loaded */
! 445: return (0);
! 446: if (val8 != MALO_VAL_SCRATCH_READY) {
! 447: /* bad register value */
! 448: printf("%s: device not ready for FW download!\n",
! 449: sc->sc_dev.dv_xname);
! 450: return (EIO);
! 451: }
! 452:
! 453: /* read helper firmware image */
! 454: if ((error = loadfirmware(name, &ucode, &usize)) != 0) {
! 455: printf("%s: can't read microcode %s (error %d)!\n",
! 456: sc->sc_dev.dv_xname, name, error);
! 457: return (EIO);
! 458: }
! 459:
! 460: /* download the helper firmware */
! 461: for (offset = 0; offset < usize; offset += bsize) {
! 462: if (usize - offset >= MALO_FW_HELPER_BSIZE)
! 463: bsize = MALO_FW_HELPER_BSIZE;
! 464: else
! 465: bsize = usize - offset;
! 466:
! 467: /* send a block in words and confirm it */
! 468: DPRINTF(3, "%s: download helper FW block (%d bytes, %d off)\n",
! 469: sc->sc_dev.dv_xname, bsize, offset);
! 470: MALO_WRITE_2(sc, MALO_REG_CMD_WRITE_LEN, bsize);
! 471: uc = (uint16_t *)(ucode + offset);
! 472: for (i = 0; i < bsize / 2; i++)
! 473: MALO_WRITE_2(sc, MALO_REG_CMD_WRITE, htole16(uc[i]));
! 474: MALO_WRITE_1(sc, MALO_REG_HOST_STATUS, MALO_VAL_CMD_DL_OVER);
! 475: MALO_WRITE_2(sc, MALO_REG_CARD_INTR_CAUSE,
! 476: MALO_VAL_CMD_DL_OVER);
! 477:
! 478: /* poll for an acknowledgement */
! 479: for (i = 0; i < 50; i++) {
! 480: if (MALO_READ_1(sc, MALO_REG_CARD_STATUS) ==
! 481: MALO_VAL_CMD_DL_OVER)
! 482: break;
! 483: delay(1000);
! 484: }
! 485: if (i == 50) {
! 486: printf("%s: timeout while helper FW block download!\n",
! 487: sc->sc_dev.dv_xname);
! 488: free(ucode, M_DEVBUF);
! 489: return (EIO);
! 490: }
! 491: }
! 492: free(ucode, M_DEVBUF);
! 493:
! 494: /* helper firmware download done */
! 495: MALO_WRITE_2(sc, MALO_REG_CMD_WRITE_LEN, 0);
! 496: MALO_WRITE_1(sc, MALO_REG_HOST_STATUS, MALO_VAL_CMD_DL_OVER);
! 497: MALO_WRITE_2(sc, MALO_REG_CARD_INTR_CAUSE, MALO_VAL_CMD_DL_OVER);
! 498: DPRINTF(1, "%s: helper FW downloaded\n", sc->sc_dev.dv_xname);
! 499:
! 500: return (0);
! 501: }
! 502:
! 503: int
! 504: cmalo_fw_load_main(struct malo_softc *sc)
! 505: {
! 506: const char *name = "malo8385-m";
! 507: size_t usize;
! 508: uint8_t *ucode;
! 509: uint16_t val16, bsize, *uc;
! 510: int error, offset, i, retry;
! 511:
! 512: /* read main firmware image */
! 513: if ((error = loadfirmware(name, &ucode, &usize)) != 0) {
! 514: printf("%s: can't read microcode %s (error %d)!\n",
! 515: sc->sc_dev.dv_xname, name, error);
! 516: return (EIO);
! 517: }
! 518:
! 519: /* verify if the helper firmware has been loaded correctly */
! 520: for (i = 0; i < 10; i++) {
! 521: if (MALO_READ_1(sc, MALO_REG_RBAL) == MALO_FW_HELPER_LOADED)
! 522: break;
! 523: delay(1000);
! 524: }
! 525: if (i == 10) {
! 526: printf("%s: helper FW not loaded!\n", sc->sc_dev.dv_xname);
! 527: free(ucode, M_DEVBUF);
! 528: return (EIO);
! 529: }
! 530: DPRINTF(1, "%s: helper FW loaded successfully\n", sc->sc_dev.dv_xname);
! 531:
! 532: /* download the main firmware */
! 533: for (offset = 0; offset < usize; offset += bsize) {
! 534: val16 = MALO_READ_2(sc, MALO_REG_RBAL);
! 535: /*
! 536: * If the helper firmware serves us an odd integer then
! 537: * something went wrong and we retry to download the last
! 538: * block until we receive a good integer again, or give up.
! 539: */
! 540: if (val16 & 0x0001) {
! 541: if (retry > MALO_FW_MAIN_MAXRETRY) {
! 542: printf("%s: main FW download failed!\n",
! 543: sc->sc_dev.dv_xname);
! 544: free(ucode, M_DEVBUF);
! 545: return (EIO);
! 546: }
! 547: retry++;
! 548: offset -= bsize;
! 549: } else {
! 550: retry = 0;
! 551: bsize = val16;
! 552: }
! 553:
! 554: /* send a block in words and confirm it */
! 555: DPRINTF(3, "%s: download main FW block (%d bytes, %d off)\n",
! 556: sc->sc_dev.dv_xname, bsize, offset);
! 557: MALO_WRITE_2(sc, MALO_REG_CMD_WRITE_LEN, bsize);
! 558: uc = (uint16_t *)(ucode + offset);
! 559: for (i = 0; i < bsize / 2; i++)
! 560: MALO_WRITE_2(sc, MALO_REG_CMD_WRITE, htole16(uc[i]));
! 561: MALO_WRITE_1(sc, MALO_REG_HOST_STATUS, MALO_VAL_CMD_DL_OVER);
! 562: MALO_WRITE_2(sc, MALO_REG_CARD_INTR_CAUSE,
! 563: MALO_VAL_CMD_DL_OVER);
! 564:
! 565: /* poll for an acknowledgement */
! 566: for (i = 0; i < 5000; i++) {
! 567: if (MALO_READ_1(sc, MALO_REG_CARD_STATUS) ==
! 568: MALO_VAL_CMD_DL_OVER)
! 569: break;
! 570: }
! 571: if (i == 5000) {
! 572: printf("%s: timeout while main FW block download!\n",
! 573: sc->sc_dev.dv_xname);
! 574: free(ucode, M_DEVBUF);
! 575: return (EIO);
! 576: }
! 577: }
! 578: free(ucode, M_DEVBUF);
! 579:
! 580: DPRINTF(1, "%s: main FW downloaded\n", sc->sc_dev.dv_xname);
! 581:
! 582: /* verify if the main firmware has been loaded correctly */
! 583: for (i = 0; i < 50; i++) {
! 584: if (MALO_READ_1(sc, MALO_REG_SCRATCH) ==
! 585: MALO_VAL_SCRATCH_FW_LOADED)
! 586: break;
! 587: delay(1000);
! 588: }
! 589: if (i == 50) {
! 590: printf("%s: main FW not loaded!\n", sc->sc_dev.dv_xname);
! 591: return (EIO);
! 592: }
! 593:
! 594: DPRINTF(1, "%s: main FW loaded successfully\n", sc->sc_dev.dv_xname);
! 595:
! 596: return (0);
! 597: }
! 598:
! 599: int
! 600: cmalo_init(struct ifnet *ifp)
! 601: {
! 602: struct malo_softc *sc = ifp->if_softc;
! 603: struct ieee80211com *ic = &sc->sc_ic;
! 604:
! 605: /* reload the firmware if necessary */
! 606: if (!(sc->sc_flags & MALO_FW_LOADED)) {
! 607: /* disable interrupts */
! 608: cmalo_intr_mask(sc, 0);
! 609:
! 610: /* load firmware */
! 611: if (cmalo_fw_load_helper(sc) != 0)
! 612: return (EIO);
! 613: if (cmalo_fw_load_main(sc) != 0)
! 614: return (EIO);
! 615: sc->sc_flags |= MALO_FW_LOADED;
! 616:
! 617: /* enable interrupts */
! 618: cmalo_intr_mask(sc, 1);
! 619: }
! 620:
! 621: /* reset association state flag */
! 622: sc->sc_flags &= ~MALO_ASSOC_FAILED;
! 623:
! 624: /* get current channel */
! 625: ic->ic_bss->ni_chan = ic->ic_ibss_chan;
! 626: sc->sc_curchan = ieee80211_chan2ieee(ic, ic->ic_bss->ni_chan);
! 627: DPRINTF(1, "%s: current channel is %d\n",
! 628: sc->sc_dev.dv_xname, sc->sc_curchan);
! 629:
! 630: /* setup device */
! 631: if (cmalo_cmd_set_macctrl(sc) != 0)
! 632: return (EIO);
! 633: if (cmalo_cmd_set_txpower(sc, 15) != 0)
! 634: return (EIO);
! 635: if (cmalo_cmd_set_antenna(sc, 1) != 0)
! 636: return (EIO);
! 637: if (cmalo_cmd_set_antenna(sc, 2) != 0)
! 638: return (EIO);
! 639: if (cmalo_cmd_set_radio(sc, 1) != 0)
! 640: return (EIO);
! 641: if (cmalo_cmd_set_channel(sc, sc->sc_curchan) != 0)
! 642: return (EIO);
! 643: if (cmalo_cmd_set_rate(sc) != 0)
! 644: return (EIO);
! 645: if (cmalo_cmd_set_snmp(sc, MALO_OID_RTSTRESH) != 0)
! 646: return (EIO);
! 647: if (cmalo_cmd_set_snmp(sc, MALO_OID_SHORTRETRY) != 0)
! 648: return (EIO);
! 649: if (cmalo_cmd_set_snmp(sc, MALO_OID_FRAGTRESH) != 0)
! 650: return (EIO);
! 651: if (sc->sc_ic.ic_flags & IEEE80211_F_WEPON) {
! 652: if (cmalo_wep(sc) != 0)
! 653: return (EIO);
! 654: }
! 655:
! 656: /* device up */
! 657: ifp->if_flags |= IFF_RUNNING;
! 658: ifp->if_flags &= ~IFF_OACTIVE;
! 659:
! 660: /* start network */
! 661: if (ic->ic_opmode != IEEE80211_M_MONITOR)
! 662: ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
! 663: if (sc->sc_flags & MALO_ASSOC_FAILED)
! 664: ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
! 665: else
! 666: ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
! 667:
! 668: /* we are not context save anymore for FW commands */
! 669: sc->sc_cmd_ctxsave = 0;
! 670:
! 671: return (0);
! 672: }
! 673:
! 674: void
! 675: cmalo_stop(struct malo_softc *sc)
! 676: {
! 677: struct ieee80211com *ic = &sc->sc_ic;
! 678: struct ifnet *ifp = &ic->ic_if;
! 679:
! 680: /* device down */
! 681: ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
! 682:
! 683: /* change device back to initial state */
! 684: ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
! 685:
! 686: /* reset device */
! 687: cmalo_cmd_set_reset(sc);
! 688: sc->sc_flags &= ~MALO_FW_LOADED;
! 689:
! 690: DPRINTF(1, "%s: device down\n", sc->sc_dev.dv_xname);
! 691: }
! 692:
! 693: int
! 694: cmalo_media_change(struct ifnet *ifp)
! 695: {
! 696: int error;
! 697:
! 698: if ((error = ieee80211_media_change(ifp) != ENETRESET))
! 699: return (error);
! 700:
! 701: if (ifp->if_flags & (IFF_UP | IFF_RUNNING))
! 702: cmalo_init(ifp);
! 703:
! 704: return (0);
! 705: }
! 706:
! 707: int
! 708: cmalo_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
! 709: {
! 710: struct malo_softc *sc = ic->ic_if.if_softc;
! 711: enum ieee80211_state ostate;
! 712:
! 713: ostate = ic->ic_state;
! 714:
! 715: if (ostate == nstate)
! 716: goto out;
! 717:
! 718: switch (nstate) {
! 719: case IEEE80211_S_INIT:
! 720: DPRINTF(1, "%s: newstate is IEEE80211_S_INIT\n",
! 721: sc->sc_dev.dv_xname);
! 722: break;
! 723: case IEEE80211_S_SCAN:
! 724: DPRINTF(1, "%s: newstate is IEEE80211_S_SCAN\n",
! 725: sc->sc_dev.dv_xname);
! 726: cmalo_cmd_set_scan(sc);
! 727: if (!sc->sc_net_num) {
! 728: /* no networks found */
! 729: DPRINTF(1, "%s: no networks found!\n",
! 730: sc->sc_dev.dv_xname);
! 731: break;
! 732: }
! 733: cmalo_select_network(sc);
! 734: cmalo_cmd_set_auth(sc);
! 735: cmalo_cmd_set_assoc(sc);
! 736: break;
! 737: case IEEE80211_S_AUTH:
! 738: DPRINTF(1, "%s: newstate is IEEE80211_S_AUTH\n",
! 739: sc->sc_dev.dv_xname);
! 740: break;
! 741: case IEEE80211_S_ASSOC:
! 742: DPRINTF(1, "%s: newstate is IEEE80211_S_ASSOC\n",
! 743: sc->sc_dev.dv_xname);
! 744: break;
! 745: case IEEE80211_S_RUN:
! 746: DPRINTF(1, "%s: newstate is IEEE80211_S_RUN\n",
! 747: sc->sc_dev.dv_xname);
! 748: cmalo_reflect_network(sc);
! 749: break;
! 750: default:
! 751: break;
! 752: }
! 753:
! 754: out:
! 755: return (sc->sc_newstate(ic, nstate, arg));
! 756: }
! 757:
! 758: void
! 759: cmalo_detach(void *arg)
! 760: {
! 761: struct malo_softc *sc = arg;
! 762: struct ieee80211com *ic = &sc->sc_ic;
! 763: struct ifnet *ifp = &ic->ic_if;
! 764:
! 765: if (!(sc->sc_flags & MALO_DEVICE_ATTACHED))
! 766: /* device was not properly attached */
! 767: return;
! 768:
! 769: /* free command buffer */
! 770: if (sc->sc_cmd != NULL)
! 771: free(sc->sc_cmd, M_DEVBUF);
! 772:
! 773: /* free data buffer */
! 774: if (sc->sc_data != NULL)
! 775: free(sc->sc_data, M_DEVBUF);
! 776:
! 777: /* detach inferface */
! 778: ieee80211_ifdetach(ifp);
! 779: if_detach(ifp);
! 780: }
! 781:
! 782: int
! 783: cmalo_intr(void *arg)
! 784: {
! 785: struct malo_softc *sc = arg;
! 786: uint16_t intr = 0;
! 787:
! 788: /* read interrupt reason */
! 789: intr = MALO_READ_2(sc, MALO_REG_HOST_INTR_CAUSE);
! 790: if (intr == 0) {
! 791: /* interrupt not for us */
! 792: return (0);
! 793: }
! 794: if (intr == 0xffff) {
! 795: /* card has been detached */
! 796: return (0);
! 797: }
! 798:
! 799: /* disable interrupts */
! 800: cmalo_intr_mask(sc, 0);
! 801:
! 802: /* acknowledge interrupt */
! 803: MALO_WRITE_2(sc, MALO_REG_HOST_INTR_CAUSE,
! 804: intr & MALO_VAL_HOST_INTR_MASK_ON);
! 805:
! 806: /* enable interrupts */
! 807: cmalo_intr_mask(sc, 1);
! 808:
! 809: DPRINTF(2, "%s: interrupt handler called (intr = 0x%04x)\n",
! 810: sc->sc_dev.dv_xname, intr);
! 811:
! 812: if (intr & MALO_VAL_HOST_INTR_TX)
! 813: /* TX frame sent */
! 814: cmalo_tx_done(sc);
! 815: if (intr & MALO_VAL_HOST_INTR_RX)
! 816: /* RX frame received */
! 817: cmalo_rx(sc);
! 818: if (intr & MALO_VAL_HOST_INTR_CMD) {
! 819: /* command response */
! 820: wakeup(sc);
! 821: if (!sc->sc_cmd_ctxsave)
! 822: cmalo_cmd_response(sc);
! 823: }
! 824: if (intr & MALO_VAL_HOST_INTR_EVENT)
! 825: /* event */
! 826: cmalo_event(sc);
! 827:
! 828: return (1);
! 829: }
! 830:
! 831: void
! 832: cmalo_intr_mask(struct malo_softc *sc, int enable)
! 833: {
! 834: uint16_t val16;
! 835:
! 836: val16 = MALO_READ_2(sc, MALO_REG_HOST_INTR_MASK);
! 837:
! 838: DPRINTF(3, "%s: intr mask changed from 0x%04x ",
! 839: sc->sc_dev.dv_xname, val16);
! 840:
! 841: if (enable)
! 842: MALO_WRITE_2(sc, MALO_REG_HOST_INTR_MASK,
! 843: val16 & ~MALO_VAL_HOST_INTR_MASK_ON);
! 844: else
! 845: MALO_WRITE_2(sc, MALO_REG_HOST_INTR_MASK,
! 846: val16 | MALO_VAL_HOST_INTR_MASK_ON);
! 847:
! 848: val16 = MALO_READ_2(sc, MALO_REG_HOST_INTR_MASK);
! 849:
! 850: DPRINTF(3, "to 0x%04x\n", val16);
! 851: }
! 852:
! 853: void
! 854: cmalo_rx(struct malo_softc *sc)
! 855: {
! 856: struct ieee80211com *ic = &sc->sc_ic;
! 857: struct ifnet *ifp = &ic->ic_if;
! 858: struct malo_rx_desc *rxdesc;
! 859: struct mbuf *m;
! 860: uint8_t *data;
! 861: uint16_t psize;
! 862: int i;
! 863:
! 864: splassert(IPL_NET);
! 865:
! 866: /* read the whole RX packet which is always 802.3 */
! 867: psize = MALO_READ_2(sc, MALO_REG_DATA_READ_LEN);
! 868: if (psize & 0x0001) {
! 869: MALO_READ_MULTI_2(sc, MALO_REG_DATA_READ, sc->sc_data,
! 870: psize - 1);
! 871: data = (uint8_t *)sc->sc_data;
! 872: data[psize - 1] = MALO_READ_1(sc, MALO_REG_DATA_READ);
! 873: } else
! 874: MALO_READ_MULTI_2(sc, MALO_REG_DATA_READ, sc->sc_data, psize);
! 875: MALO_WRITE_1(sc, MALO_REG_HOST_STATUS, MALO_VAL_RX_DL_OVER);
! 876: MALO_WRITE_2(sc, MALO_REG_CARD_INTR_CAUSE, MALO_VAL_RX_DL_OVER);
! 877:
! 878: /* access RX packet descriptor */
! 879: rxdesc = (struct malo_rx_desc *)sc->sc_data;
! 880: rxdesc->status = letoh16(rxdesc->status);
! 881: rxdesc->pkglen = letoh16(rxdesc->pkglen);
! 882: rxdesc->pkgoffset = letoh32(rxdesc->pkgoffset);
! 883:
! 884: DPRINTF(2, "RX status=%d, pkglen=%d, pkgoffset=%d\n",
! 885: rxdesc->status, rxdesc->pkglen, rxdesc->pkgoffset);
! 886:
! 887: if (rxdesc->status != MALO_RX_STATUS_OK)
! 888: /* RX packet is not OK */
! 889: return;
! 890:
! 891: /* remove the LLC / SNAP header */
! 892: data = sc->sc_data + rxdesc->pkgoffset;
! 893: i = (ETHER_ADDR_LEN * 2) + sizeof(struct llc);
! 894: bcopy(data + i, data + (ETHER_ADDR_LEN * 2), rxdesc->pkglen - i);
! 895: rxdesc->pkglen -= sizeof(struct llc);
! 896:
! 897: /* prepare mbuf */
! 898: m = m_devget(sc->sc_data + rxdesc->pkgoffset - ETHER_ALIGN,
! 899: rxdesc->pkglen + ETHER_ALIGN, 0, ifp, NULL);
! 900: m_adj(m, ETHER_ALIGN);
! 901:
! 902: #if NBPFILTER > 0
! 903: if (ifp->if_bpf)
! 904: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
! 905: #endif
! 906:
! 907: /* push the frame up to the network stack if not in monitor mode */
! 908: if (ic->ic_opmode != IEEE80211_M_MONITOR) {
! 909: ether_input_mbuf(ifp, m);
! 910: ifp->if_ipackets++;
! 911: }
! 912: }
! 913:
! 914: void
! 915: cmalo_start(struct ifnet *ifp)
! 916: {
! 917: struct malo_softc *sc = ifp->if_softc;
! 918: struct mbuf *m;
! 919:
! 920: /* don't transmit packets if interface is busy or down */
! 921: if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
! 922: return;
! 923:
! 924: IFQ_POLL(&ifp->if_snd, m);
! 925: if (m == NULL)
! 926: return;
! 927:
! 928: IFQ_DEQUEUE(&ifp->if_snd, m);
! 929:
! 930: #if NBPFILTER > 0
! 931: if (ifp->if_bpf)
! 932: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_OUT);
! 933: #endif
! 934:
! 935: if (cmalo_tx(sc, m) != 0)
! 936: ifp->if_oerrors++;
! 937: }
! 938:
! 939: void
! 940: cmalo_watchdog(struct ifnet *ifp)
! 941: {
! 942: DPRINTF(2, "watchdog timeout\n");
! 943:
! 944: /* accept TX packets again */
! 945: ifp->if_flags &= ~IFF_OACTIVE;
! 946: }
! 947:
! 948: int
! 949: cmalo_tx(struct malo_softc *sc, struct mbuf *m)
! 950: {
! 951: struct ifnet *ifp = &sc->sc_ic.ic_if;
! 952: struct malo_tx_desc *txdesc = sc->sc_data;
! 953: uint8_t *data;
! 954: uint16_t psize;
! 955:
! 956: splassert(IPL_NET);
! 957:
! 958: bzero(sc->sc_data, sizeof(*txdesc));
! 959: psize = sizeof(*txdesc) + m->m_pkthdr.len;
! 960: data = mtod(m, uint8_t *);
! 961:
! 962: /* prepare TX descriptor */
! 963: txdesc->pkgoffset = htole32(sizeof(*txdesc));
! 964: txdesc->pkglen = htole16(m->m_pkthdr.len);
! 965: bcopy(data, txdesc->dstaddrhigh, ETHER_ADDR_LEN);
! 966:
! 967: /* copy mbuf data to the buffer */
! 968: m_copydata(m, 0, m->m_pkthdr.len, sc->sc_data + sizeof(*txdesc));
! 969: m_freem(m);
! 970:
! 971: /* send TX packet to the device */
! 972: MALO_WRITE_2(sc, MALO_REG_DATA_WRITE_LEN, psize);
! 973: if (psize & 0x0001) {
! 974: MALO_WRITE_MULTI_2(sc, MALO_REG_DATA_WRITE, sc->sc_data,
! 975: psize - 1);
! 976: data = (uint8_t *)sc->sc_data;
! 977: MALO_WRITE_1(sc, MALO_REG_DATA_WRITE, data[psize - 1]);
! 978: } else
! 979: MALO_WRITE_MULTI_2(sc, MALO_REG_DATA_WRITE, sc->sc_data, psize);
! 980: MALO_WRITE_1(sc, MALO_REG_HOST_STATUS, MALO_VAL_TX_DL_OVER);
! 981: MALO_WRITE_2(sc, MALO_REG_CARD_INTR_CAUSE, MALO_VAL_TX_DL_OVER);
! 982:
! 983: ifp->if_flags |= IFF_OACTIVE;
! 984: ifp->if_timer = 5;
! 985:
! 986: DPRINTF(2, "%s: TX status=%d, pkglen=%d, pkgoffset=%d\n",
! 987: sc->sc_dev.dv_xname, txdesc->status, letoh16(txdesc->pkglen),
! 988: sizeof(*txdesc));
! 989:
! 990: return (0);
! 991: }
! 992:
! 993: void
! 994: cmalo_tx_done(struct malo_softc *sc)
! 995: {
! 996: struct ifnet *ifp = &sc->sc_ic.ic_if;
! 997:
! 998: splassert(IPL_NET);
! 999:
! 1000: DPRINTF(2, "%s: TX done\n", sc->sc_dev.dv_xname);
! 1001:
! 1002: ifp->if_opackets++;
! 1003: ifp->if_flags &= ~IFF_OACTIVE;
! 1004: ifp->if_timer = 0;
! 1005: cmalo_start(ifp);
! 1006: }
! 1007:
! 1008: void
! 1009: cmalo_event(struct malo_softc *sc)
! 1010: {
! 1011: uint16_t event;
! 1012:
! 1013: /* read event reason */
! 1014: event = MALO_READ_2(sc, MALO_REG_CARD_STATUS);
! 1015: event &= MALO_VAL_CARD_STATUS_MASK;
! 1016: event = event >> 8;
! 1017:
! 1018: switch (event) {
! 1019: case MALO_EVENT_DEAUTH:
! 1020: DPRINTF(1, "%s: got deauthentication event (0x%04x)\n",
! 1021: sc->sc_dev.dv_xname, event);
! 1022: /* try to associate again */
! 1023: cmalo_cmd_set_assoc(sc);
! 1024: break;
! 1025: case MALO_EVENT_DISASSOC:
! 1026: DPRINTF(1, "%s: got disassociation event (0x%04x)\n",
! 1027: sc->sc_dev.dv_xname, event);
! 1028: /* try to associate again */
! 1029: cmalo_cmd_set_assoc(sc);
! 1030: break;
! 1031: default:
! 1032: DPRINTF(1, "%s: got unknown event (0x%04x)\n",
! 1033: sc->sc_dev.dv_xname, event);
! 1034: break;
! 1035: }
! 1036:
! 1037: /* acknowledge event */
! 1038: MALO_WRITE_2(sc, MALO_REG_CARD_INTR_CAUSE, MALO_VAL_HOST_INTR_EVENT);
! 1039: }
! 1040:
! 1041: void
! 1042: cmalo_select_network(struct malo_softc *sc)
! 1043: {
! 1044: struct ieee80211com *ic = &sc->sc_ic;
! 1045: int i, best_rssi;
! 1046:
! 1047: /* reset last selected network */
! 1048: sc->sc_net_cur = 0;
! 1049:
! 1050: /* get desired network */
! 1051: if (ic->ic_des_esslen) {
! 1052: for (i = 0; i < sc->sc_net_num; i++) {
! 1053: if (!strcmp(ic->ic_des_essid, sc->sc_net[i].ssid)) {
! 1054: sc->sc_net_cur = i;
! 1055: DPRINTF(1, "%s: desired network found (%s)\n",
! 1056: sc->sc_dev.dv_xname, ic->ic_des_essid);
! 1057: return;
! 1058: }
! 1059: }
! 1060: DPRINTF(1, "%s: desired network not found in scan results "
! 1061: "(%s)!\n",
! 1062: sc->sc_dev.dv_xname, ic->ic_des_essid);
! 1063: }
! 1064:
! 1065: /* get network with best signal strength */
! 1066: best_rssi = sc->sc_net[0].rssi;
! 1067: for (i = 0; i < sc->sc_net_num; i++) {
! 1068: if (best_rssi < sc->sc_net[i].rssi) {
! 1069: best_rssi = sc->sc_net[i].rssi;
! 1070: sc->sc_net_cur = i;
! 1071: }
! 1072: }
! 1073: DPRINTF(1, "%s: best network found (%s)\n",
! 1074: sc->sc_dev.dv_xname, sc->sc_net[sc->sc_net_cur].ssid);
! 1075: }
! 1076:
! 1077: void
! 1078: cmalo_reflect_network(struct malo_softc *sc)
! 1079: {
! 1080: struct ieee80211com *ic = &sc->sc_ic;
! 1081: uint8_t chan;
! 1082:
! 1083: /* reflect active network to our 80211 stack */
! 1084:
! 1085: /* BSSID */
! 1086: IEEE80211_ADDR_COPY(ic->ic_bss->ni_bssid,
! 1087: sc->sc_net[sc->sc_net_cur].bssid);
! 1088:
! 1089: /* SSID */
! 1090: ic->ic_bss->ni_esslen = strlen(sc->sc_net[sc->sc_net_cur].ssid);
! 1091: bcopy(sc->sc_net[sc->sc_net_cur].ssid, ic->ic_bss->ni_essid,
! 1092: ic->ic_bss->ni_esslen);
! 1093:
! 1094: /* channel */
! 1095: chan = sc->sc_net[sc->sc_net_cur].channel;
! 1096: ic->ic_bss->ni_chan = &ic->ic_channels[chan];
! 1097: }
! 1098:
! 1099: int
! 1100: cmalo_wep(struct malo_softc *sc)
! 1101: {
! 1102: struct ieee80211com *ic = &sc->sc_ic;
! 1103: int i;
! 1104:
! 1105: for (i = 0; i < IEEE80211_WEP_NKID; i++) {
! 1106: struct ieee80211_key *key = &ic->ic_nw_keys[i];
! 1107:
! 1108: if (!key->k_len)
! 1109: continue;
! 1110:
! 1111: DPRINTF(1, "%s: setting wep key for index %d\n",
! 1112: sc->sc_dev.dv_xname, i);
! 1113:
! 1114: cmalo_cmd_set_wep(sc, i, key);
! 1115: }
! 1116:
! 1117: return (0);
! 1118: }
! 1119:
! 1120: void
! 1121: cmalo_hexdump(void *buf, int len)
! 1122: {
! 1123: #ifdef CMALO_DEBUG
! 1124: int i;
! 1125:
! 1126: if (cmalo_d >= 2) {
! 1127: for (i = 0; i < len; i++) {
! 1128: if (i % 16 == 0)
! 1129: printf("%s%5i:", i ? "\n" : "", i);
! 1130: if (i % 4 == 0)
! 1131: printf(" ");
! 1132: printf("%02x", (int)*((u_char *)buf + i));
! 1133: }
! 1134: printf("\n");
! 1135: }
! 1136: #endif
! 1137: }
! 1138:
! 1139: int
! 1140: cmalo_cmd_get_hwspec(struct malo_softc *sc)
! 1141: {
! 1142: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1143: struct malo_cmd_body_spec *body;
! 1144: uint16_t psize;
! 1145:
! 1146: bzero(sc->sc_cmd, MALO_CMD_BUFFER_SIZE);
! 1147: psize = sizeof(*hdr) + sizeof(*body);
! 1148:
! 1149: hdr->cmd = htole16(MALO_CMD_HWSPEC);
! 1150: hdr->size = htole16(sizeof(*body));
! 1151: hdr->seqnum = htole16(1);
! 1152: hdr->result = 0;
! 1153: body = (struct malo_cmd_body_spec *)(hdr + 1);
! 1154:
! 1155: /* set all bits for MAC address, otherwise we won't get one back */
! 1156: memset(body->macaddr, 0xff, ETHER_ADDR_LEN);
! 1157:
! 1158: /* process command request */
! 1159: if (cmalo_cmd_request(sc, psize, 0) != 0)
! 1160: return (EIO);
! 1161:
! 1162: /* process command repsonse */
! 1163: cmalo_cmd_response(sc);
! 1164:
! 1165: return (0);
! 1166: }
! 1167:
! 1168: int
! 1169: cmalo_cmd_rsp_hwspec(struct malo_softc *sc)
! 1170: {
! 1171: struct ieee80211com *ic = &sc->sc_ic;
! 1172: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1173: struct malo_cmd_body_spec *body;
! 1174: int i;
! 1175:
! 1176: body = (struct malo_cmd_body_spec *)(hdr + 1);
! 1177:
! 1178: /* get our MAC address */
! 1179: for (i = 0; i < ETHER_ADDR_LEN; i++)
! 1180: ic->ic_myaddr[i] = body->macaddr[i];
! 1181:
! 1182: return (0);
! 1183: }
! 1184:
! 1185: int
! 1186: cmalo_cmd_set_reset(struct malo_softc *sc)
! 1187: {
! 1188: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1189: uint16_t psize;
! 1190:
! 1191: bzero(sc->sc_cmd, MALO_CMD_BUFFER_SIZE);
! 1192: psize = sizeof(*hdr);
! 1193:
! 1194: hdr->cmd = htole16(MALO_CMD_RESET);
! 1195: hdr->size = 0;
! 1196: hdr->seqnum = htole16(1);
! 1197: hdr->result = 0;
! 1198:
! 1199: /* process command request */
! 1200: if (cmalo_cmd_request(sc, psize, 1) != 0)
! 1201: return (EIO);
! 1202:
! 1203: return (0);
! 1204: }
! 1205:
! 1206: int
! 1207: cmalo_cmd_set_scan(struct malo_softc *sc)
! 1208: {
! 1209: struct ieee80211com *ic = &sc->sc_ic;
! 1210: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1211: struct malo_cmd_body_scan *body;
! 1212: struct malo_cmd_tlv_ssid *body_ssid;
! 1213: struct malo_cmd_tlv_chanlist *body_chanlist;
! 1214: struct malo_cmd_tlv_rates *body_rates;
! 1215: //struct malo_cmd_tlv_numprobes *body_numprobes;
! 1216: uint16_t psize;
! 1217: int i;
! 1218:
! 1219: bzero(sc->sc_cmd, MALO_CMD_BUFFER_SIZE);
! 1220: psize = sizeof(*hdr) + sizeof(*body);
! 1221:
! 1222: hdr->cmd = htole16(MALO_CMD_SCAN);
! 1223: hdr->seqnum = htole16(1);
! 1224: hdr->result = 0;
! 1225: body = (struct malo_cmd_body_scan *)(hdr + 1);
! 1226:
! 1227: body->bsstype = 0x03; /* any BSS */
! 1228: memset(body->bssid, 0xff, ETHER_ADDR_LEN);
! 1229:
! 1230: body_ssid = sc->sc_cmd + psize;
! 1231: body_ssid->type = htole16(MALO_TLV_TYPE_SSID);
! 1232: body_ssid->size = htole16(0);
! 1233: psize += (sizeof(*body_ssid) - 1);
! 1234:
! 1235: body_chanlist = sc->sc_cmd + psize;
! 1236: body_chanlist->type = htole16(MALO_TLV_TYPE_CHANLIST);
! 1237: body_chanlist->size = htole16(sizeof(body_chanlist->data));
! 1238: for (i = 0; i < CHANNELS; i++) {
! 1239: body_chanlist->data[i].radiotype = 0x00;
! 1240: body_chanlist->data[i].channumber = (i + 1);
! 1241: body_chanlist->data[i].scantype = 0x00; /* active */
! 1242: body_chanlist->data[i].minscantime = htole16(0);
! 1243: body_chanlist->data[i].maxscantime = htole16(100);
! 1244: }
! 1245: psize += sizeof(*body_chanlist);
! 1246:
! 1247: body_rates = sc->sc_cmd + psize;
! 1248: body_rates->type = htole16(MALO_TLV_TYPE_RATES);
! 1249: body_rates->size =
! 1250: htole16(ic->ic_sup_rates[IEEE80211_MODE_11B].rs_nrates);
! 1251: bcopy(ic->ic_sup_rates[IEEE80211_MODE_11B].rs_rates, body_rates->data,
! 1252: ic->ic_sup_rates[IEEE80211_MODE_11B].rs_nrates);
! 1253: psize += (sizeof(*body_rates) - 1) + letoh16(body_rates->size);
! 1254: #if 0
! 1255: body_numprobes = sc->sc_cmd + psize;
! 1256: body_numprobes->type = htole16(MALO_TLV_TYPE_NUMPROBES);
! 1257: body_numprobes->size = htole16(2);
! 1258: body_numprobes->numprobes = htole16(1);
! 1259: psize += sizeof(*body_numprobes);
! 1260: #endif
! 1261: hdr->size = htole16(psize - sizeof(*hdr));
! 1262:
! 1263: /* process command request */
! 1264: if (cmalo_cmd_request(sc, psize, 0) != 0)
! 1265: return (EIO);
! 1266:
! 1267: /* process command repsonse */
! 1268: cmalo_cmd_response(sc);
! 1269:
! 1270: return (0);
! 1271: }
! 1272:
! 1273: int
! 1274: cmalo_cmd_rsp_scan(struct malo_softc *sc)
! 1275: {
! 1276: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1277: struct malo_cmd_body_rsp_scan *body;
! 1278: struct malo_cmd_body_rsp_scan_set *set;
! 1279: uint16_t psize;
! 1280: int i;
! 1281:
! 1282: bzero(sc->sc_net, sizeof(sc->sc_net));
! 1283: psize = sizeof(*hdr) + sizeof(*body);
! 1284:
! 1285: body = (struct malo_cmd_body_rsp_scan *)(hdr + 1);
! 1286:
! 1287: body->bufsize = letoh16(body->bufsize);
! 1288:
! 1289: DPRINTF(1, "bufsize=%d, APs=%d\n", body->bufsize, body->numofset);
! 1290: sc->sc_net_num = body->numofset;
! 1291:
! 1292: /* cycle through found networks */
! 1293: for (i = 0; i < body->numofset; i++) {
! 1294: set = (struct malo_cmd_body_rsp_scan_set *)(sc->sc_cmd + psize);
! 1295:
! 1296: set->size = letoh16(set->size);
! 1297: set->beaconintvl = letoh16(set->beaconintvl);
! 1298: set->capinfo = letoh16(set->capinfo);
! 1299:
! 1300: DPRINTF(1, "size=%d, bssid=%s, rssi=%d, beaconintvl=%d, "
! 1301: "capinfo=0x%04x\n",
! 1302: set->size, ether_sprintf(set->bssid), set->rssi,
! 1303: set->beaconintvl, set->capinfo);
! 1304:
! 1305: /* save scan results */
! 1306: bcopy(set->bssid, sc->sc_net[i].bssid, sizeof(set->bssid));
! 1307: bcopy(set->timestamp, sc->sc_net[i].timestamp,
! 1308: sizeof(set->timestamp));
! 1309: sc->sc_net[i].rssi = set->rssi;
! 1310: sc->sc_net[i].beaconintvl = set->beaconintvl;
! 1311: sc->sc_net[i].capinfo = set->capinfo;
! 1312: cmalo_parse_elements(sc, (set + 1),
! 1313: set->size - (sizeof(*set) - sizeof(set->size)), i);
! 1314:
! 1315: psize += (set->size + sizeof(set->size));
! 1316: }
! 1317:
! 1318: return (0);
! 1319: }
! 1320:
! 1321: int
! 1322: cmalo_parse_elements(struct malo_softc *sc, void *buf, int size, int pos)
! 1323: {
! 1324: uint8_t eid, len;
! 1325: int i;
! 1326:
! 1327: DPRINTF(2, "element_size=%d, element_pos=%d\n", size, pos);
! 1328:
! 1329: for (i = 0; i < size; ) {
! 1330: eid = *(uint8_t *)(buf + i);
! 1331: i++;
! 1332: len = *(uint8_t *)(buf + i);
! 1333: i++;
! 1334: DPRINTF(2, "eid=%d, len=%d, ", eid, len);
! 1335:
! 1336: switch (eid) {
! 1337: case IEEE80211_ELEMID_SSID:
! 1338: bcopy(buf + i, sc->sc_net[pos].ssid, len);
! 1339: DPRINTF(2, "ssid=%s\n", sc->sc_net[pos].ssid);
! 1340: break;
! 1341: case IEEE80211_ELEMID_RATES:
! 1342: bcopy(buf + i, sc->sc_net[pos].rates, len);
! 1343: DPRINTF(2, "rates\n");
! 1344: break;
! 1345: case IEEE80211_ELEMID_DSPARMS:
! 1346: sc->sc_net[pos].channel = *(uint8_t *)(buf + i);
! 1347: DPRINTF(2, "chnl=%d\n", sc->sc_net[pos].channel);
! 1348: break;
! 1349: default:
! 1350: DPRINTF(2, "unknown\n");
! 1351: break;
! 1352: }
! 1353:
! 1354: i += len;
! 1355: }
! 1356:
! 1357: return (0);
! 1358: }
! 1359:
! 1360: int
! 1361: cmalo_cmd_set_auth(struct malo_softc *sc)
! 1362: {
! 1363: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1364: struct malo_cmd_body_auth *body;
! 1365: uint16_t psize;
! 1366:
! 1367: bzero(sc->sc_cmd, MALO_CMD_BUFFER_SIZE);
! 1368: psize = sizeof(*hdr) + sizeof(*body);
! 1369:
! 1370: hdr->cmd = htole16(MALO_CMD_AUTH);
! 1371: hdr->size = htole16(sizeof(*body));
! 1372: hdr->seqnum = htole16(1);
! 1373: hdr->result = 0;
! 1374: body = (struct malo_cmd_body_auth *)(hdr + 1);
! 1375:
! 1376: bcopy(sc->sc_net[sc->sc_net_cur].bssid, body->peermac, ETHER_ADDR_LEN);
! 1377: body->authtype = 0;
! 1378:
! 1379: /* process command request */
! 1380: if (cmalo_cmd_request(sc, psize, 0) != 0)
! 1381: return (EIO);
! 1382:
! 1383: /* process command repsonse */
! 1384: cmalo_cmd_response(sc);
! 1385:
! 1386: return (0);
! 1387: }
! 1388:
! 1389: int
! 1390: cmalo_cmd_set_wep(struct malo_softc *sc, uint16_t index,
! 1391: struct ieee80211_key *key)
! 1392: {
! 1393: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1394: struct malo_cmd_body_wep *body;
! 1395: uint16_t psize;
! 1396:
! 1397: bzero(sc->sc_cmd, MALO_CMD_BUFFER_SIZE);
! 1398: psize = sizeof(*hdr) + sizeof(*body);
! 1399:
! 1400: hdr->cmd = htole16(MALO_CMD_WEP);
! 1401: hdr->size = htole16(sizeof(*body));
! 1402: hdr->seqnum = htole16(1);
! 1403: hdr->result = 0;
! 1404: body = (struct malo_cmd_body_wep *)(hdr + 1);
! 1405:
! 1406: body->action = htole16(MALO_WEP_ACTION_TYPE_ADD);
! 1407: body->key_index = htole16(index);
! 1408:
! 1409: if (body->key_index == 0) {
! 1410: if (key->k_len > 5)
! 1411: body->key_type_1 = MALO_WEP_KEY_TYPE_104BIT;
! 1412: else
! 1413: body->key_type_1 = MALO_WEP_KEY_TYPE_40BIT;
! 1414: bcopy(key->k_key, body->key_value_1, key->k_len);
! 1415: }
! 1416: if (body->key_index == 1) {
! 1417: if (key->k_len > 5)
! 1418: body->key_type_2 = MALO_WEP_KEY_TYPE_104BIT;
! 1419: else
! 1420: body->key_type_2 = MALO_WEP_KEY_TYPE_40BIT;
! 1421: bcopy(key->k_key, body->key_value_2, key->k_len);
! 1422: }
! 1423: if (body->key_index == 2) {
! 1424: if (key->k_len > 5)
! 1425: body->key_type_3 = MALO_WEP_KEY_TYPE_104BIT;
! 1426: else
! 1427: body->key_type_3 = MALO_WEP_KEY_TYPE_40BIT;
! 1428: bcopy(key->k_key, body->key_value_3, key->k_len);
! 1429: }
! 1430: if (body->key_index == 3) {
! 1431: if (key->k_len > 5)
! 1432: body->key_type_4 = MALO_WEP_KEY_TYPE_104BIT;
! 1433: else
! 1434: body->key_type_4 = MALO_WEP_KEY_TYPE_40BIT;
! 1435: bcopy(key->k_key, body->key_value_4, key->k_len);
! 1436: }
! 1437:
! 1438: /* process command request */
! 1439: if (cmalo_cmd_request(sc, psize, 0) != 0)
! 1440: return (EIO);
! 1441:
! 1442: /* process command repsonse */
! 1443: cmalo_cmd_response(sc);
! 1444:
! 1445: return (0);
! 1446: }
! 1447:
! 1448: int
! 1449: cmalo_cmd_set_snmp(struct malo_softc *sc, uint16_t oid)
! 1450: {
! 1451: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1452: struct malo_cmd_body_snmp *body;
! 1453: uint16_t psize;
! 1454:
! 1455: bzero(sc->sc_cmd, MALO_CMD_BUFFER_SIZE);
! 1456: psize = sizeof(*hdr) + sizeof(*body);
! 1457:
! 1458: hdr->cmd = htole16(MALO_CMD_SNMP);
! 1459: hdr->size = htole16(sizeof(*body));
! 1460: hdr->seqnum = htole16(1);
! 1461: hdr->result = 0;
! 1462: body = (struct malo_cmd_body_snmp *)(hdr + 1);
! 1463:
! 1464: body->action = htole16(1);
! 1465:
! 1466: switch (oid) {
! 1467: case MALO_OID_RTSTRESH:
! 1468: body->oid = htole16(MALO_OID_RTSTRESH);
! 1469: body->size = htole16(2);
! 1470: *(uint16_t *)body->data = htole16(2347);
! 1471: break;
! 1472: case MALO_OID_SHORTRETRY:
! 1473: body->oid = htole16(MALO_OID_SHORTRETRY);
! 1474: body->size = htole16(2);
! 1475: *(uint16_t *)body->data = htole16(4);
! 1476: break;
! 1477: case MALO_OID_FRAGTRESH:
! 1478: body->oid = htole16(MALO_OID_FRAGTRESH);
! 1479: body->size = htole16(2);
! 1480: *(uint16_t *)body->data = htole16(2346);
! 1481: break;
! 1482: case MALO_OID_80211D:
! 1483: body->oid = htole16(MALO_OID_80211D);
! 1484: body->size = htole16(2);
! 1485: *(uint16_t *)body->data = htole16(1);
! 1486: break;
! 1487: default:
! 1488: break;
! 1489: }
! 1490:
! 1491: /* process command request */
! 1492: if (cmalo_cmd_request(sc, psize, 0) != 0)
! 1493: return (EIO);
! 1494:
! 1495: /* process command repsonse */
! 1496: cmalo_cmd_response(sc);
! 1497:
! 1498: return (0);
! 1499: }
! 1500:
! 1501: int
! 1502: cmalo_cmd_set_radio(struct malo_softc *sc, uint16_t control)
! 1503: {
! 1504: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1505: struct malo_cmd_body_radio *body;
! 1506: uint16_t psize;
! 1507:
! 1508: bzero(sc->sc_cmd, MALO_CMD_BUFFER_SIZE);
! 1509: psize = sizeof(*hdr) + sizeof(*body);
! 1510:
! 1511: hdr->cmd = htole16(MALO_CMD_RADIO);
! 1512: hdr->size = htole16(sizeof(*body));
! 1513: hdr->seqnum = htole16(1);
! 1514: hdr->result = 0;
! 1515: body = (struct malo_cmd_body_radio *)(hdr + 1);
! 1516:
! 1517: body->action = htole16(1);
! 1518:
! 1519: if (control) {
! 1520: body->control = htole16(MALO_CMD_RADIO_ON);
! 1521: body->control |= htole16(MALO_CMD_RADIO_AUTO_P);
! 1522: }
! 1523:
! 1524: /* process command request */
! 1525: if (cmalo_cmd_request(sc, psize, 0) != 0)
! 1526: return (EIO);
! 1527:
! 1528: /* process command repsonse */
! 1529: cmalo_cmd_response(sc);
! 1530:
! 1531: return (0);
! 1532: }
! 1533:
! 1534: int
! 1535: cmalo_cmd_set_channel(struct malo_softc *sc, uint16_t channel)
! 1536: {
! 1537: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1538: struct malo_cmd_body_channel *body;
! 1539: uint16_t psize;
! 1540:
! 1541: bzero(sc->sc_cmd, MALO_CMD_BUFFER_SIZE);
! 1542: psize = sizeof(*hdr) + sizeof(*body);
! 1543:
! 1544: hdr->cmd = htole16(MALO_CMD_CHANNEL);
! 1545: hdr->size = htole16(sizeof(*body));
! 1546: hdr->seqnum = htole16(1);
! 1547: hdr->result = 0;
! 1548: body = (struct malo_cmd_body_channel *)(hdr + 1);
! 1549:
! 1550: body->action = htole16(1);
! 1551: body->channel = htole16(channel);
! 1552:
! 1553: /* process command request */
! 1554: if (cmalo_cmd_request(sc, psize, 0) != 0)
! 1555: return (EIO);
! 1556:
! 1557: /* process command repsonse */
! 1558: cmalo_cmd_response(sc);
! 1559:
! 1560: return (0);
! 1561: }
! 1562:
! 1563:
! 1564: int
! 1565: cmalo_cmd_set_txpower(struct malo_softc *sc, int16_t txpower)
! 1566: {
! 1567: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1568: struct malo_cmd_body_txpower *body;
! 1569: uint16_t psize;
! 1570:
! 1571: bzero(sc->sc_cmd, MALO_CMD_BUFFER_SIZE);
! 1572: psize = sizeof(*hdr) + sizeof(*body);
! 1573:
! 1574: hdr->cmd = htole16(MALO_CMD_TXPOWER);
! 1575: hdr->size = htole16(sizeof(*body));
! 1576: hdr->seqnum = htole16(1);
! 1577: hdr->result = 0;
! 1578: body = (struct malo_cmd_body_txpower *)(hdr + 1);
! 1579:
! 1580: body->action = htole16(1);
! 1581: body->txpower = htole16(txpower);
! 1582:
! 1583: /* process command request */
! 1584: if (cmalo_cmd_request(sc, psize, 0) != 0)
! 1585: return (EIO);
! 1586:
! 1587: /* process command repsonse */
! 1588: cmalo_cmd_response(sc);
! 1589:
! 1590: return (0);
! 1591: }
! 1592:
! 1593: int
! 1594: cmalo_cmd_set_antenna(struct malo_softc *sc, uint16_t action)
! 1595: {
! 1596: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1597: struct malo_cmd_body_antenna *body;
! 1598: uint16_t psize;
! 1599:
! 1600: bzero(sc->sc_cmd, MALO_CMD_BUFFER_SIZE);
! 1601: psize = sizeof(*hdr) + sizeof(*body);
! 1602:
! 1603: hdr->cmd = htole16(MALO_CMD_ANTENNA);
! 1604: hdr->size = htole16(sizeof(*body));
! 1605: hdr->seqnum = htole16(1);
! 1606: hdr->result = 0;
! 1607: body = (struct malo_cmd_body_antenna *)(hdr + 1);
! 1608:
! 1609: /* 1 = set RX, 2 = set TX */
! 1610: body->action = htole16(action);
! 1611:
! 1612: if (action == 1)
! 1613: /* set RX antenna */
! 1614: body->antenna_mode = htole16(0xffff);
! 1615: if (action == 2)
! 1616: /* set TX antenna */
! 1617: body->antenna_mode = htole16(2);
! 1618:
! 1619: /* process command request */
! 1620: if (cmalo_cmd_request(sc, psize, 0) != 0)
! 1621: return (EIO);
! 1622:
! 1623: /* process command repsonse */
! 1624: cmalo_cmd_response(sc);
! 1625:
! 1626: return (0);
! 1627: }
! 1628:
! 1629: int
! 1630: cmalo_cmd_set_macctrl(struct malo_softc *sc)
! 1631: {
! 1632: struct ieee80211com *ic = &sc->sc_ic;
! 1633: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1634: struct malo_cmd_body_macctrl *body;
! 1635: uint16_t psize;
! 1636:
! 1637: bzero(sc->sc_cmd, MALO_CMD_BUFFER_SIZE);
! 1638: psize = sizeof(*hdr) + sizeof(*body);
! 1639:
! 1640: hdr->cmd = htole16(MALO_CMD_MACCTRL);
! 1641: hdr->size = htole16(sizeof(*body));
! 1642: hdr->seqnum = htole16(1);
! 1643: hdr->result = 0;
! 1644: body = (struct malo_cmd_body_macctrl *)(hdr + 1);
! 1645:
! 1646: body->action = htole16(MALO_CMD_MACCTRL_RX_ON);
! 1647: body->action |= htole16(MALO_CMD_MACCTRL_TX_ON);
! 1648: if (ic->ic_opmode == IEEE80211_M_MONITOR)
! 1649: body->action |= htole16(MALO_CMD_MACCTRL_PROMISC_ON);
! 1650:
! 1651: /* process command request */
! 1652: if (cmalo_cmd_request(sc, psize, 0) != 0)
! 1653: return (EIO);
! 1654:
! 1655: /* process command repsonse */
! 1656: cmalo_cmd_response(sc);
! 1657:
! 1658: return (0);
! 1659: }
! 1660:
! 1661: int
! 1662: cmalo_cmd_set_assoc(struct malo_softc *sc)
! 1663: {
! 1664: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1665: struct malo_cmd_body_assoc *body;
! 1666: struct malo_cmd_tlv_ssid *body_ssid;
! 1667: struct malo_cmd_tlv_phy *body_phy;
! 1668: struct malo_cmd_tlv_cf *body_cf;
! 1669: struct malo_cmd_tlv_rates *body_rates;
! 1670: struct malo_cmd_tlv_passeid *body_passeid;
! 1671: uint16_t psize;
! 1672:
! 1673: bzero(sc->sc_cmd, MALO_CMD_BUFFER_SIZE);
! 1674: psize = sizeof(*hdr) + sizeof(*body);
! 1675:
! 1676: hdr->cmd = htole16(MALO_CMD_ASSOC);
! 1677: hdr->seqnum = htole16(1);
! 1678: hdr->result = 0;
! 1679: body = (struct malo_cmd_body_assoc *)(hdr + 1);
! 1680:
! 1681: bcopy(sc->sc_net[sc->sc_net_cur].bssid, body->peermac, ETHER_ADDR_LEN);
! 1682: body->capinfo = htole16(sc->sc_net[sc->sc_net_cur].capinfo);
! 1683: body->listenintrv = htole16(10);
! 1684:
! 1685: body_ssid = sc->sc_cmd + psize;
! 1686: body_ssid->type = htole16(MALO_TLV_TYPE_SSID);
! 1687: body_ssid->size = htole16(strlen(sc->sc_net[sc->sc_net_cur].ssid));
! 1688: bcopy(sc->sc_net[sc->sc_net_cur].ssid, body_ssid->data,
! 1689: letoh16(body_ssid->size));
! 1690: psize += (sizeof(*body_ssid) - 1) + letoh16(body_ssid->size);
! 1691:
! 1692: body_phy = sc->sc_cmd + psize;
! 1693: body_phy->type = htole16(MALO_TLV_TYPE_PHY);
! 1694: body_phy->size = htole16(1);
! 1695: bcopy(&sc->sc_net[sc->sc_net_cur].channel, body_phy->data, 1);
! 1696: psize += sizeof(*body_phy);
! 1697:
! 1698: body_cf = sc->sc_cmd + psize;
! 1699: body_cf->type = htole16(MALO_TLV_TYPE_CF);
! 1700: body_cf->size = htole16(0);
! 1701: psize += (sizeof(*body_cf) - 1);
! 1702:
! 1703: body_rates = sc->sc_cmd + psize;
! 1704: body_rates->type = htole16(MALO_TLV_TYPE_RATES);
! 1705: body_rates->size = htole16(strlen(sc->sc_net[sc->sc_net_cur].rates));
! 1706: bcopy(sc->sc_net[sc->sc_net_cur].rates, body_rates->data,
! 1707: letoh16(body_rates->size));
! 1708: psize += (sizeof(*body_rates) - 1) + letoh16(body_rates->size);
! 1709:
! 1710: /* hack to correct FW's wrong generated rates-element-id */
! 1711: body_passeid = sc->sc_cmd + psize;
! 1712: body_passeid->type = htole16(MALO_TLV_TYPE_PASSEID);
! 1713: body_passeid->size = body_rates->size;
! 1714: bcopy(body_rates->data, body_passeid->data, letoh16(body_rates->size));
! 1715: psize += (sizeof(*body_passeid) - 1) + letoh16(body_passeid->size);
! 1716:
! 1717: hdr->size = htole16(psize - sizeof(*hdr));
! 1718:
! 1719: /* process command request */
! 1720: if (!sc->sc_cmd_ctxsave) {
! 1721: if (cmalo_cmd_request(sc, psize, 1) != 0)
! 1722: return (EIO);
! 1723: return (0);
! 1724: }
! 1725: if (cmalo_cmd_request(sc, psize, 0) != 0)
! 1726: return (EIO);
! 1727:
! 1728: /* process command repsonse */
! 1729: cmalo_cmd_response(sc);
! 1730:
! 1731: return (0);
! 1732: }
! 1733:
! 1734: int
! 1735: cmalo_cmd_rsp_assoc(struct malo_softc *sc)
! 1736: {
! 1737: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1738: struct malo_cmd_body_rsp_assoc *body;
! 1739:
! 1740: body = (struct malo_cmd_body_rsp_assoc *)(hdr + 1);
! 1741:
! 1742: if (body->status) {
! 1743: DPRINTF(1, "%s: association failed (status %d)!\n",
! 1744: sc->sc_dev.dv_xname, body->status);
! 1745: sc->sc_flags |= MALO_ASSOC_FAILED;
! 1746: } else
! 1747: DPRINTF(1, "%s: association successful\n",
! 1748: sc->sc_dev.dv_xname, body->status);
! 1749:
! 1750: return (0);
! 1751: }
! 1752:
! 1753: int
! 1754: cmalo_cmd_set_80211d(struct malo_softc *sc)
! 1755: {
! 1756: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1757: struct malo_cmd_body_80211d *body;
! 1758: struct malo_cmd_tlv_80211d *body_80211d;
! 1759: uint16_t psize;
! 1760: int i;
! 1761:
! 1762: bzero(sc->sc_cmd, MALO_CMD_BUFFER_SIZE);
! 1763: psize = sizeof(*hdr) + sizeof(*body);
! 1764:
! 1765: hdr->cmd = htole16(MALO_CMD_80211D);
! 1766: hdr->seqnum = htole16(1);
! 1767: hdr->result = 0;
! 1768: body = (struct malo_cmd_body_80211d *)(hdr + 1);
! 1769:
! 1770: body->action = htole16(1);
! 1771:
! 1772: body_80211d = sc->sc_cmd + psize;
! 1773: body_80211d->type = htole16(MALO_TLV_TYPE_80211D);
! 1774: body_80211d->size = htole16(sizeof(body_80211d->data) +
! 1775: sizeof(body_80211d->countrycode));
! 1776: bcopy("EU ", body_80211d->countrycode,
! 1777: sizeof(body_80211d->countrycode));
! 1778: for (i = 0; i < CHANNELS; i++) {
! 1779: body_80211d->data[i].firstchannel = 1;
! 1780: body_80211d->data[i].numchannels = 12;
! 1781: body_80211d->data[i].maxtxpower = 10;
! 1782: }
! 1783: psize += sizeof(*body_80211d);
! 1784:
! 1785: hdr->size = htole16(psize - sizeof(*hdr));
! 1786:
! 1787: /* process command request */
! 1788: if (cmalo_cmd_request(sc, psize, 0) != 0)
! 1789: return (EIO);
! 1790:
! 1791: /* process command repsonse */
! 1792: cmalo_cmd_response(sc);
! 1793:
! 1794: return (0);
! 1795: }
! 1796:
! 1797: int
! 1798: cmalo_cmd_set_bgscan_config(struct malo_softc *sc)
! 1799: {
! 1800: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1801: struct malo_cmd_body_bgscan_config *body;
! 1802: uint16_t psize;
! 1803:
! 1804: bzero(sc->sc_cmd, MALO_CMD_BUFFER_SIZE);
! 1805: psize = sizeof(*hdr) + sizeof(*body);
! 1806:
! 1807: hdr->cmd = htole16(MALO_CMD_BGSCAN_CONFIG);
! 1808: hdr->size = htole16(sizeof(*body));
! 1809: hdr->seqnum = htole16(1);
! 1810: hdr->result = 0;
! 1811: body = (struct malo_cmd_body_bgscan_config *)(hdr + 1);
! 1812:
! 1813: body->action = htole16(1);
! 1814: body->enable = 1;
! 1815: body->bsstype = 0x03;
! 1816: body->chperscan = 12;
! 1817: body->scanintvl = htole32(100);
! 1818: body->maxscanres = htole16(12);
! 1819:
! 1820: /* process command request */
! 1821: if (cmalo_cmd_request(sc, psize, 0) != 0)
! 1822: return (EIO);
! 1823:
! 1824: /* process command repsonse */
! 1825: cmalo_cmd_response(sc);
! 1826:
! 1827: return (0);
! 1828: }
! 1829:
! 1830: int
! 1831: cmalo_cmd_set_bgscan_query(struct malo_softc *sc)
! 1832: {
! 1833: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1834: struct malo_cmd_body_bgscan_query *body;
! 1835: uint16_t psize;
! 1836:
! 1837: bzero(sc->sc_cmd, MALO_CMD_BUFFER_SIZE);
! 1838: psize = sizeof(*hdr) + sizeof(*body);
! 1839:
! 1840: hdr->cmd = htole16(MALO_CMD_BGSCAN_QUERY);
! 1841: hdr->size = htole16(sizeof(*body));
! 1842: hdr->seqnum = htole16(1);
! 1843: hdr->result = 0;
! 1844: body = (struct malo_cmd_body_bgscan_query *)(hdr + 1);
! 1845:
! 1846: body->flush = 0;
! 1847:
! 1848: /* process command request */
! 1849: if (cmalo_cmd_request(sc, psize, 0) != 0)
! 1850: return (EIO);
! 1851:
! 1852: /* process command repsonse */
! 1853: cmalo_cmd_response(sc);
! 1854:
! 1855: return (0);
! 1856: }
! 1857:
! 1858: int
! 1859: cmalo_cmd_set_rate(struct malo_softc *sc)
! 1860: {
! 1861: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1862: struct malo_cmd_body_rate *body;
! 1863: uint16_t psize;
! 1864:
! 1865: bzero(sc->sc_cmd, MALO_CMD_BUFFER_SIZE);
! 1866: psize = sizeof(*hdr) + sizeof(*body);
! 1867:
! 1868: hdr->cmd = htole16(MALO_CMD_RATE);
! 1869: hdr->size = htole16(sizeof(*body));
! 1870: hdr->seqnum = htole16(1);
! 1871: hdr->result = 0;
! 1872: body = (struct malo_cmd_body_rate *)(hdr + 1);
! 1873:
! 1874: body->action = htole16(1);
! 1875: body->hwauto = htole16(1);
! 1876: body->ratebitmap = htole16(0x1fff);
! 1877:
! 1878: /* process command request */
! 1879: if (cmalo_cmd_request(sc, psize, 0) != 0)
! 1880: return (EIO);
! 1881:
! 1882: /* process command repsonse */
! 1883: cmalo_cmd_response(sc);
! 1884:
! 1885: return (0);
! 1886: }
! 1887:
! 1888: int
! 1889: cmalo_cmd_request(struct malo_softc *sc, uint16_t psize, int no_response)
! 1890: {
! 1891: uint8_t *cmd;
! 1892:
! 1893: cmalo_hexdump(sc->sc_cmd, psize);
! 1894:
! 1895: /* send command request */
! 1896: MALO_WRITE_2(sc, MALO_REG_CMD_WRITE_LEN, psize);
! 1897: if (psize & 0x0001) {
! 1898: MALO_WRITE_MULTI_2(sc, MALO_REG_CMD_WRITE, sc->sc_cmd,
! 1899: psize - 1);
! 1900: cmd = (uint8_t *)sc->sc_cmd;
! 1901: MALO_WRITE_1(sc, MALO_REG_CMD_WRITE, cmd[psize - 1]);
! 1902: } else
! 1903: MALO_WRITE_MULTI_2(sc, MALO_REG_CMD_WRITE, sc->sc_cmd, psize);
! 1904: MALO_WRITE_1(sc, MALO_REG_HOST_STATUS, MALO_VAL_CMD_DL_OVER);
! 1905: MALO_WRITE_2(sc, MALO_REG_CARD_INTR_CAUSE, MALO_VAL_CMD_DL_OVER);
! 1906:
! 1907: if (no_response)
! 1908: /* we don't expect a response */
! 1909: return (0);
! 1910:
! 1911: /* wait for the command response */
! 1912: if (tsleep(sc, 0, "malocmd", 500)) {
! 1913: printf("%s: timeout while waiting for cmd response!\n",
! 1914: sc->sc_dev.dv_xname);
! 1915: return (EIO);
! 1916: }
! 1917:
! 1918: return (0);
! 1919: }
! 1920:
! 1921: int
! 1922: cmalo_cmd_response(struct malo_softc *sc)
! 1923: {
! 1924: struct malo_cmd_header *hdr = sc->sc_cmd;
! 1925: uint16_t psize;
! 1926: uint8_t *cmd;
! 1927: int s;
! 1928:
! 1929: s = splnet();
! 1930:
! 1931: bzero(sc->sc_cmd, MALO_CMD_BUFFER_SIZE);
! 1932:
! 1933: /* read the whole command response */
! 1934: psize = MALO_READ_2(sc, MALO_REG_CMD_READ_LEN);
! 1935: if (psize & 0x0001) {
! 1936: MALO_READ_MULTI_2(sc, MALO_REG_CMD_READ, sc->sc_cmd,
! 1937: psize - 1);
! 1938: cmd = (uint8_t *)sc->sc_cmd;
! 1939: cmd[psize - 1] = MALO_READ_1(sc, MALO_REG_CMD_READ);
! 1940: } else
! 1941: MALO_READ_MULTI_2(sc, MALO_REG_CMD_READ, sc->sc_cmd, psize);
! 1942:
! 1943: cmalo_hexdump(sc->sc_cmd, psize);
! 1944:
! 1945: /*
! 1946: * We convert the header values into the machines correct endianess,
! 1947: * so we don't have to letoh16() all over the code. The body is
! 1948: * kept in the cards order, little endian. We need to take care
! 1949: * about the body endianess in the corresponding response routines.
! 1950: */
! 1951: hdr->cmd = letoh16(hdr->cmd);
! 1952: hdr->size = letoh16(hdr->size);
! 1953: hdr->seqnum = letoh16(hdr->seqnum);
! 1954: hdr->result = letoh16(hdr->result);
! 1955:
! 1956: /* check for a valid command response */
! 1957: if (!(hdr->cmd & MALO_CMD_RESP)) {
! 1958: printf("%s: got invalid command response (0x%04x)!\n",
! 1959: sc->sc_dev.dv_xname, hdr->cmd);
! 1960: splx(s);
! 1961: return (EIO);
! 1962: }
! 1963: hdr->cmd &= ~MALO_CMD_RESP;
! 1964:
! 1965: /* association cmd response is special */
! 1966: if (hdr->cmd == 0x0012)
! 1967: hdr->cmd = MALO_CMD_ASSOC;
! 1968:
! 1969: /* to which command does the response belong */
! 1970: switch (hdr->cmd) {
! 1971: case MALO_CMD_HWSPEC:
! 1972: DPRINTF(1, "%s: got hwspec cmd response\n",
! 1973: sc->sc_dev.dv_xname);
! 1974: cmalo_cmd_rsp_hwspec(sc);
! 1975: break;
! 1976: case MALO_CMD_RESET:
! 1977: /* reset will not send back a response */
! 1978: break;
! 1979: case MALO_CMD_SCAN:
! 1980: DPRINTF(1, "%s: got scan cmd response\n",
! 1981: sc->sc_dev.dv_xname);
! 1982: cmalo_cmd_rsp_scan(sc);
! 1983: break;
! 1984: case MALO_CMD_AUTH:
! 1985: /* do nothing */
! 1986: DPRINTF(1, "%s: got auth cmd response\n",
! 1987: sc->sc_dev.dv_xname);
! 1988: break;
! 1989: case MALO_CMD_WEP:
! 1990: /* do nothing */
! 1991: DPRINTF(1, "%s: got wep cmd response\n",
! 1992: sc->sc_dev.dv_xname);
! 1993: break;
! 1994: case MALO_CMD_SNMP:
! 1995: /* do nothing */
! 1996: DPRINTF(1, "%s: got snmp cmd response\n",
! 1997: sc->sc_dev.dv_xname);
! 1998: break;
! 1999: case MALO_CMD_RADIO:
! 2000: /* do nothing */
! 2001: DPRINTF(1, "%s: got radio cmd response\n",
! 2002: sc->sc_dev.dv_xname);
! 2003: break;
! 2004: case MALO_CMD_CHANNEL:
! 2005: /* do nothing */
! 2006: DPRINTF(1, "%s: got channel cmd response\n",
! 2007: sc->sc_dev.dv_xname);
! 2008: break;
! 2009: case MALO_CMD_TXPOWER:
! 2010: /* do nothing */
! 2011: DPRINTF(1, "%s: got txpower cmd response\n",
! 2012: sc->sc_dev.dv_xname);
! 2013: break;
! 2014: case MALO_CMD_ANTENNA:
! 2015: /* do nothing */
! 2016: DPRINTF(1, "%s: got antenna cmd response\n",
! 2017: sc->sc_dev.dv_xname);
! 2018: break;
! 2019: case MALO_CMD_MACCTRL:
! 2020: /* do nothing */
! 2021: DPRINTF(1, "%s: got macctrl cmd response\n",
! 2022: sc->sc_dev.dv_xname);
! 2023: break;
! 2024: case MALO_CMD_ASSOC:
! 2025: /* do nothing */
! 2026: DPRINTF(1, "%s: got assoc cmd response\n",
! 2027: sc->sc_dev.dv_xname);
! 2028: cmalo_cmd_rsp_assoc(sc);
! 2029: break;
! 2030: case MALO_CMD_80211D:
! 2031: /* do nothing */
! 2032: DPRINTF(1, "%s: got 80211d cmd response\n",
! 2033: sc->sc_dev.dv_xname);
! 2034: break;
! 2035: case MALO_CMD_BGSCAN_CONFIG:
! 2036: /* do nothing */
! 2037: DPRINTF(1, "%s: got bgscan config cmd response\n",
! 2038: sc->sc_dev.dv_xname);
! 2039: break;
! 2040: case MALO_CMD_BGSCAN_QUERY:
! 2041: /* do nothing */
! 2042: DPRINTF(1, "%s: got bgscan query cmd response\n",
! 2043: sc->sc_dev.dv_xname);
! 2044: break;
! 2045: case MALO_CMD_RATE:
! 2046: /* do nothing */
! 2047: DPRINTF(1, "%s: got rate cmd response\n",
! 2048: sc->sc_dev.dv_xname);
! 2049: break;
! 2050: default:
! 2051: printf("%s: got unknown cmd response (0x%04x)!\n",
! 2052: sc->sc_dev.dv_xname, hdr->cmd);
! 2053: break;
! 2054: }
! 2055:
! 2056: splx(s);
! 2057:
! 2058: return (0);
! 2059: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_malo.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pcmcia