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