if_atu.c revision 1.24.6.1
1 /* $NetBSD: if_atu.c,v 1.24.6.1 2007/05/22 14:57:36 itohy Exp $ */ 2 /* $OpenBSD: if_atu.c,v 1.48 2004/12/30 01:53:21 dlg Exp $ */ 3 /* 4 * Copyright (c) 2003, 2004 5 * Daan Vreeken <Danovitsch (at) Vitsch.net>. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Daan Vreeken. 18 * 4. Neither the name of the author nor the names of any co-contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY Daan Vreeken AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL Daan Vreeken OR THE VOICES IN HIS HEAD 26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 32 * THE POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 /* 36 * Atmel AT76c503 / AT76c503a / AT76c505 / AT76c505a USB WLAN driver 37 * version 0.5 - 2004-08-03 38 * 39 * Originally written by Daan Vreeken <Danovitsch @ Vitsch . net> 40 * http://vitsch.net/bsd/atuwi 41 * 42 * Contributed to by : 43 * Chris Whitehouse, Alistair Phillips, Peter Pilka, Martijn van Buul, 44 * Suihong Liang, Arjan van Leeuwen, Stuart Walsh 45 * 46 * Ported to OpenBSD by Theo de Raadt and David Gwynne. 47 * Ported to NetBSD by Jesse Off 48 */ 49 50 #include <sys/cdefs.h> 51 __KERNEL_RCSID(0, "$NetBSD: if_atu.c,v 1.24.6.1 2007/05/22 14:57:36 itohy Exp $"); 52 53 #include "bpfilter.h" 54 55 #include <sys/param.h> 56 #include <sys/sockio.h> 57 #include <sys/mbuf.h> 58 #include <sys/kernel.h> 59 #include <sys/socket.h> 60 #include <sys/systm.h> 61 #include <sys/malloc.h> 62 #include <sys/kthread.h> 63 #include <sys/queue.h> 64 #include <sys/device.h> 65 66 #include <machine/bus.h> 67 68 #include <dev/usb/usb.h> 69 #include <dev/usb/usbdi.h> 70 #include <dev/usb/usbdi_util.h> 71 #include <dev/usb/usbdivar.h> 72 73 #include <dev/usb/usbdevs.h> 74 75 #include <dev/microcode/atmel/atmel_intersil_fw.h> 76 #include <dev/microcode/atmel/atmel_rfmd2958-smc_fw.h> 77 #include <dev/microcode/atmel/atmel_rfmd2958_fw.h> 78 #include <dev/microcode/atmel/atmel_rfmd_fw.h> 79 80 #if NBPFILTER > 0 81 #include <net/bpf.h> 82 #include <net/bpfdesc.h> 83 #endif 84 85 #include <net/if.h> 86 #include <net/if_dl.h> 87 #include <net/if_media.h> 88 #include <net/if_ether.h> 89 90 #ifdef INET 91 #include <netinet/in.h> 92 #include <netinet/if_ether.h> 93 #endif 94 95 #include <net80211/ieee80211_var.h> 96 #include <net80211/ieee80211_radiotap.h> 97 98 #ifdef USB_DEBUG 99 #define ATU_DEBUG 100 #endif 101 102 #include <dev/usb/if_atureg.h> 103 104 #ifdef ATU_DEBUG 105 #define DPRINTF(x) do { if (atudebug) printf x; } while (0) 106 #define DPRINTFN(n,x) do { if (atudebug>(n)) printf x; } while (0) 107 int atudebug = 1; 108 #else 109 #define DPRINTF(x) 110 #define DPRINTFN(n,x) 111 #endif 112 113 /* 114 * Various supported device vendors/products/radio type. 115 */ 116 struct atu_type atu_devs[] = { 117 { USB_VENDOR_ATMEL, USB_PRODUCT_ATMEL_BW002, 118 RadioRFMD, ATU_NO_QUIRK }, 119 { USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_F5D6050, 120 RadioRFMD, ATU_NO_QUIRK }, 121 { USB_VENDOR_ATMEL, USB_PRODUCT_ATMEL_AT76C503A, 122 RadioIntersil, ATU_NO_QUIRK }, 123 { USB_VENDOR_LEXAR, USB_PRODUCT_LEXAR_2662WAR, 124 RadioRFMD, ATU_NO_QUIRK }, 125 /* Belkin F5D6050 */ 126 { USB_VENDOR_SMC3, USB_PRODUCT_SMC3_2662WUSB, 127 RadioRFMD, ATU_NO_QUIRK }, 128 { USB_VENDOR_LINKSYS2, USB_PRODUCT_LINKSYS2_WUSB11, 129 RadioRFMD, ATU_NO_QUIRK }, 130 { USB_VENDOR_LINKSYS3, USB_PRODUCT_LINKSYS3_WUSB11V28, 131 RadioRFMD2958, ATU_NO_QUIRK }, 132 { USB_VENDOR_NETGEAR2, USB_PRODUCT_NETGEAR2_MA101B, 133 RadioRFMD, ATU_NO_QUIRK }, 134 { USB_VENDOR_ACERP, USB_PRODUCT_ACERP_AWL400, 135 RadioRFMD, ATU_NO_QUIRK }, 136 { USB_VENDOR_ATMEL, USB_PRODUCT_ATMEL_WL1130, 137 RadioRFMD2958, ATU_NO_QUIRK }, 138 { USB_VENDOR_LINKSYS3, USB_PRODUCT_LINKSYS3_WUSB11V28, 139 RadioRFMD2958, ATU_NO_QUIRK }, 140 { USB_VENDOR_AINCOMM, USB_PRODUCT_AINCOMM_AWU2000B, 141 RadioRFMD2958, ATU_NO_QUIRK }, 142 /* SMC2662 V.4 */ 143 { USB_VENDOR_ATMEL, USB_PRODUCT_ATMEL_AT76C505A, 144 RadioRFMD2958_SMC, ATU_QUIRK_NO_REMAP | ATU_QUIRK_FW_DELAY }, 145 { USB_VENDOR_ACERP, USB_PRODUCT_ACERP_AWL300, 146 RadioIntersil, ATU_NO_QUIRK }, 147 { USB_VENDOR_OQO, USB_PRODUCT_OQO_WIFI01, 148 RadioRFMD2958_SMC, ATU_QUIRK_NO_REMAP | ATU_QUIRK_FW_DELAY }, 149 { USB_VENDOR_SMC3, USB_PRODUCT_SMC3_2662WV1, 150 RadioIntersil, ATU_NO_QUIRK }, 151 }; 152 153 struct atu_radfirm { 154 enum atu_radio_type atur_type; 155 unsigned char *atur_internal; 156 size_t atur_internal_sz; 157 unsigned char *atur_external; 158 size_t atur_external_sz; 159 } atu_radfirm[] = { 160 { RadioRFMD, 161 atmel_fw_rfmd_int, sizeof(atmel_fw_rfmd_int), 162 atmel_fw_rfmd_ext, sizeof(atmel_fw_rfmd_ext) }, 163 { RadioRFMD2958, 164 atmel_fw_rfmd2958_int, sizeof(atmel_fw_rfmd2958_int), 165 atmel_fw_rfmd2958_ext, sizeof(atmel_fw_rfmd2958_ext) }, 166 { RadioRFMD2958_SMC, 167 atmel_fw_rfmd2958_smc_int, sizeof(atmel_fw_rfmd2958_smc_int), 168 atmel_fw_rfmd2958_smc_ext, sizeof(atmel_fw_rfmd2958_smc_ext) }, 169 { RadioIntersil, 170 atmel_fw_intersil_int, sizeof(atmel_fw_intersil_int), 171 atmel_fw_intersil_ext, sizeof(atmel_fw_intersil_ext) } 172 }; 173 174 int atu_newbuf(struct atu_softc *, struct atu_chain *, struct mbuf *); 175 void atu_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status); 176 void atu_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status); 177 void atu_start(struct ifnet *); 178 int atu_ioctl(struct ifnet *, u_long, caddr_t); 179 int atu_init(struct ifnet *); 180 void atu_stop(struct ifnet *, int); 181 void atu_watchdog(struct ifnet *); 182 usbd_status atu_usb_request(struct atu_softc *sc, u_int8_t type, 183 u_int8_t request, u_int16_t value, u_int16_t index, 184 u_int16_t length, u_int8_t *data); 185 int atu_send_command(struct atu_softc *sc, u_int8_t *command, int size); 186 int atu_get_cmd_status(struct atu_softc *sc, u_int8_t cmd, 187 u_int8_t *status); 188 int atu_wait_completion(struct atu_softc *sc, u_int8_t cmd, 189 u_int8_t *status); 190 int atu_send_mib(struct atu_softc *sc, u_int8_t type, 191 u_int8_t size, u_int8_t index, void *data); 192 int atu_get_mib(struct atu_softc *sc, u_int8_t type, 193 u_int8_t size, u_int8_t index, u_int8_t *buf); 194 #if 0 195 int atu_start_ibss(struct atu_softc *sc); 196 #endif 197 int atu_start_scan(struct atu_softc *sc); 198 int atu_switch_radio(struct atu_softc *sc, int state); 199 int atu_initial_config(struct atu_softc *sc); 200 int atu_join(struct atu_softc *sc, struct ieee80211_node *node); 201 int8_t atu_get_dfu_state(struct atu_softc *sc); 202 u_int8_t atu_get_opmode(struct atu_softc *sc, u_int8_t *mode); 203 void atu_internal_firmware(struct device *); 204 void atu_external_firmware(struct device *); 205 int atu_get_card_config(struct atu_softc *sc); 206 int atu_media_change(struct ifnet *ifp); 207 void atu_media_status(struct ifnet *ifp, struct ifmediareq *req); 208 int atu_tx_list_init(struct atu_softc *); 209 int atu_rx_list_init(struct atu_softc *); 210 void atu_xfer_list_free(struct atu_softc *sc, struct atu_chain *ch, 211 int listlen); 212 213 #ifdef ATU_DEBUG 214 void atu_debug_print(struct atu_softc *sc); 215 #endif 216 217 void atu_task(void *); 218 int atu_newstate(struct ieee80211com *, enum ieee80211_state, int); 219 int atu_tx_start(struct atu_softc *, struct ieee80211_node *, 220 struct atu_chain *, struct mbuf *); 221 void atu_complete_attach(struct atu_softc *); 222 u_int8_t atu_calculate_padding(int); 223 224 USB_DECLARE_DRIVER(atu); 225 226 usbd_status 227 atu_usb_request(struct atu_softc *sc, u_int8_t type, 228 u_int8_t request, u_int16_t value, u_int16_t index, u_int16_t length, 229 u_int8_t *data) 230 { 231 usb_device_request_t req; 232 usbd_xfer_handle xfer; 233 usbd_status err; 234 int total_len = 0, s; 235 236 req.bmRequestType = type; 237 req.bRequest = request; 238 USETW(req.wValue, value); 239 USETW(req.wIndex, index); 240 USETW(req.wLength, length); 241 242 #ifdef ATU_DEBUG 243 if (atudebug) { 244 DPRINTFN(20, ("%s: req=%02x val=%02x ind=%02x " 245 "len=%02x\n", USBDEVNAME(sc->atu_dev), request, 246 value, index, length)); 247 } 248 #endif /* ATU_DEBUG */ 249 250 s = splnet(); 251 252 xfer = usbd_alloc_default_xfer(sc->atu_udev); 253 usbd_setup_default_xfer(xfer, sc->atu_udev, 0, 500000, &req, data, 254 length, USBD_SHORT_XFER_OK, 0); 255 256 err = usbd_sync_transfer(xfer); 257 258 usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL); 259 260 #ifdef ATU_DEBUG 261 if (atudebug) { 262 if (type & UT_READ) { 263 DPRINTFN(20, ("%s: transfered 0x%x bytes in\n", 264 USBDEVNAME(sc->atu_dev), total_len)); 265 } else { 266 if (total_len != length) 267 DPRINTF(("%s: wrote only %x bytes\n", 268 USBDEVNAME(sc->atu_dev), total_len)); 269 } 270 } 271 #endif /* ATU_DEBUG */ 272 273 usbd_free_xfer(xfer); 274 275 splx(s); 276 return(err); 277 } 278 279 int 280 atu_send_command(struct atu_softc *sc, u_int8_t *command, int size) 281 { 282 return atu_usb_request(sc, UT_WRITE_VENDOR_DEVICE, 0x0e, 0x0000, 283 0x0000, size, command); 284 } 285 286 int 287 atu_get_cmd_status(struct atu_softc *sc, u_int8_t cmd, u_int8_t *status) 288 { 289 /* 290 * all other drivers (including Windoze) request 40 bytes of status 291 * and get a short-xfer of just 6 bytes. we can save 34 bytes of 292 * buffer if we just request those 6 bytes in the first place :) 293 */ 294 /* 295 return atu_usb_request(sc, UT_READ_VENDOR_INTERFACE, 0x22, cmd, 296 0x0000, 40, status); 297 */ 298 return atu_usb_request(sc, UT_READ_VENDOR_INTERFACE, 0x22, cmd, 299 0x0000, 6, status); 300 } 301 302 int 303 atu_wait_completion(struct atu_softc *sc, u_int8_t cmd, u_int8_t *status) 304 { 305 int idle_count = 0, err; 306 u_int8_t statusreq[6]; 307 308 DPRINTFN(15, ("%s: wait-completion: cmd=%02x\n", 309 USBDEVNAME(sc->atu_dev), cmd)); 310 311 while (1) { 312 err = atu_get_cmd_status(sc, cmd, statusreq); 313 if (err) 314 return err; 315 316 #ifdef ATU_DEBUG 317 if (atudebug) { 318 DPRINTFN(20, ("%s: status=%s cmd=%02x\n", 319 USBDEVNAME(sc->atu_dev), 320 ether_sprintf(statusreq), cmd)); 321 } 322 #endif /* ATU_DEBUG */ 323 324 /* 325 * during normal operations waiting on STATUS_IDLE 326 * will never happen more than once 327 */ 328 if ((statusreq[5] == STATUS_IDLE) && (idle_count++ > 20)) { 329 DPRINTF(("%s: idle_count > 20!\n", 330 USBDEVNAME(sc->atu_dev))); 331 return 0; 332 } 333 334 if ((statusreq[5] != STATUS_IN_PROGRESS) && 335 (statusreq[5] != STATUS_IDLE)) { 336 if (status != NULL) 337 *status = statusreq[5]; 338 return 0; 339 } 340 usbd_delay_ms(sc->atu_udev, 25); 341 } 342 } 343 344 int 345 atu_send_mib(struct atu_softc *sc, u_int8_t type, u_int8_t size, 346 u_int8_t index, void *data) 347 { 348 int err; 349 struct atu_cmd_set_mib request; 350 351 /* 352 * We don't construct a MIB packet first and then memcpy it into an 353 * Atmel-command-packet, we just construct it the right way at once :) 354 */ 355 356 memset(&request, 0, sizeof(request)); 357 358 request.AtCmd = CMD_SET_MIB; 359 USETW(request.AtSize, size + 4); 360 361 request.MIBType = type; 362 request.MIBSize = size; 363 request.MIBIndex = index; 364 request.MIBReserved = 0; 365 366 /* 367 * For 1 and 2 byte requests we assume a direct value, 368 * everything bigger than 2 bytes we assume a pointer to the data 369 */ 370 switch (size) { 371 case 0: 372 break; 373 case 1: 374 request.data[0]=(long)data & 0x000000ff; 375 break; 376 case 2: 377 request.data[0]=(long)data & 0x000000ff; 378 request.data[1]=(long)data >> 8; 379 break; 380 default: 381 memcpy(request.data, data, size); 382 break; 383 } 384 385 err = atu_usb_request(sc, UT_WRITE_VENDOR_DEVICE, 0x0e, 0x0000, 386 0x0000, size+8, (uByte *)&request); 387 if (err) 388 return (err); 389 390 DPRINTFN(15, ("%s: sendmib : waitcompletion...\n", 391 USBDEVNAME(sc->atu_dev))); 392 return atu_wait_completion(sc, CMD_SET_MIB, NULL); 393 } 394 395 int 396 atu_get_mib(struct atu_softc *sc, u_int8_t type, u_int8_t size, 397 u_int8_t index, u_int8_t *buf) 398 { 399 400 /* linux/at76c503.c - 478 */ 401 return atu_usb_request(sc, UT_READ_VENDOR_INTERFACE, 0x033, 402 type << 8, index, size, buf); 403 } 404 405 #if 0 406 int 407 atu_start_ibss(struct atu_softc *sc) 408 { 409 struct ieee80211com *ic = &sc->sc_ic; 410 int err; 411 struct atu_cmd_start_ibss Request; 412 413 Request.Cmd = CMD_START_IBSS; 414 Request.Reserved = 0; 415 Request.Size = sizeof(Request) - 4; 416 417 memset(Request.BSSID, 0x00, sizeof(Request.BSSID)); 418 memset(Request.SSID, 0x00, sizeof(Request.SSID)); 419 memcpy(Request.SSID, ic->ic_des_ssid, ic->ic_des_ssidlen); 420 Request.SSIDSize = ic->ic_des_ssidlen; 421 if (sc->atu_desired_channel != IEEE80211_CHAN_ANY) 422 Request.Channel = (u_int8_t)sc->atu_desired_channel; 423 else 424 Request.Channel = ATU_DEFAULT_CHANNEL; 425 Request.BSSType = AD_HOC_MODE; 426 memset(Request.Res, 0x00, sizeof(Request.Res)); 427 428 /* Write config to adapter */ 429 err = atu_send_command(sc, (u_int8_t *)&Request, sizeof(Request)); 430 if (err) { 431 DPRINTF(("%s: start ibss failed!\n", 432 USBDEVNAME(sc->atu_dev))); 433 return err; 434 } 435 436 /* Wait for the adapter to do it's thing */ 437 err = atu_wait_completion(sc, CMD_START_IBSS, NULL); 438 if (err) { 439 DPRINTF(("%s: error waiting for start_ibss\n", 440 USBDEVNAME(sc->atu_dev))); 441 return err; 442 } 443 444 /* Get the current BSSID */ 445 err = atu_get_mib(sc, MIB_MAC_MGMT__CURRENT_BSSID, sc->atu_bssid); 446 if (err) { 447 DPRINTF(("%s: could not get BSSID!\n", 448 USBDEVNAME(sc->atu_dev))); 449 return err; 450 } 451 452 DPRINTF(("%s: started a new IBSS (BSSID=%s)\n", 453 USBDEVNAME(sc->atu_dev), ether_sprintf(sc->atu_bssid))); 454 return 0; 455 } 456 #endif 457 458 int 459 atu_start_scan(struct atu_softc *sc) 460 { 461 struct ieee80211com *ic = &sc->sc_ic; 462 struct atu_cmd_do_scan Scan; 463 usbd_status err; 464 int Cnt; 465 466 memset(&Scan, 0, sizeof(Scan)); 467 468 Scan.Cmd = CMD_START_SCAN; 469 Scan.Reserved = 0; 470 USETW(Scan.Size, sizeof(Scan) - 4); 471 472 /* use the broadcast BSSID (in active scan) */ 473 for (Cnt=0; Cnt<6; Cnt++) 474 Scan.BSSID[Cnt] = 0xff; 475 476 memset(Scan.SSID, 0x00, sizeof(Scan.SSID)); 477 memcpy(Scan.SSID, ic->ic_des_essid, ic->ic_des_esslen); 478 Scan.SSID_Len = ic->ic_des_esslen; 479 480 /* default values for scan */ 481 Scan.ScanType = ATU_SCAN_ACTIVE; 482 if (sc->atu_desired_channel != IEEE80211_CHAN_ANY) 483 Scan.Channel = (u_int8_t)sc->atu_desired_channel; 484 else 485 Scan.Channel = sc->atu_channel; 486 487 ic->ic_curchan = &ic->ic_channels[Scan.Channel]; 488 489 /* we like scans to be quick :) */ 490 /* the time we wait before sending probe's */ 491 USETW(Scan.ProbeDelay, 0); 492 /* the time we stay on one channel */ 493 USETW(Scan.MinChannelTime, 100); 494 USETW(Scan.MaxChannelTime, 200); 495 /* wether or not we scan all channels */ 496 Scan.InternationalScan = 0xc1; 497 498 #ifdef ATU_DEBUG 499 if (atudebug) { 500 DPRINTFN(20, ("%s: scan cmd len=%02lx\n", 501 USBDEVNAME(sc->atu_dev), (unsigned long)sizeof(Scan))); 502 } 503 #endif /* ATU_DEBUG */ 504 505 /* Write config to adapter */ 506 err = atu_send_command(sc, (u_int8_t *)&Scan, sizeof(Scan)); 507 if (err) 508 return err; 509 510 /* 511 * We don't wait for the command to finish... the mgmt-thread will do 512 * that for us 513 */ 514 /* 515 err = atu_wait_completion(sc, CMD_START_SCAN, NULL); 516 if (err) 517 return err; 518 */ 519 return 0; 520 } 521 522 int 523 atu_switch_radio(struct atu_softc *sc, int state) 524 { 525 usbd_status err; 526 struct atu_cmd CmdRadio; 527 528 if (sc->atu_radio == RadioIntersil) { 529 /* 530 * Intersil doesn't seem to need/support switching the radio 531 * on/off 532 */ 533 return 0; 534 } 535 536 memset(&CmdRadio, 0, sizeof(CmdRadio)); 537 CmdRadio.Cmd = CMD_RADIO_ON; 538 539 if (sc->atu_radio_on != state) { 540 if (state == 0) 541 CmdRadio.Cmd = CMD_RADIO_OFF; 542 543 err = atu_send_command(sc, (u_int8_t *)&CmdRadio, 544 sizeof(CmdRadio)); 545 if (err) 546 return err; 547 548 err = atu_wait_completion(sc, CmdRadio.Cmd, NULL); 549 if (err) 550 return err; 551 552 DPRINTFN(10, ("%s: radio turned %s\n", 553 USBDEVNAME(sc->atu_dev), state ? "on" : "off")); 554 sc->atu_radio_on = state; 555 } 556 return 0; 557 } 558 559 int 560 atu_initial_config(struct atu_softc *sc) 561 { 562 struct ieee80211com *ic = &sc->sc_ic; 563 u_int32_t i; 564 usbd_status err; 565 /* u_int8_t rates[4] = {0x82, 0x84, 0x8B, 0x96};*/ 566 u_int8_t rates[4] = {0x82, 0x04, 0x0B, 0x16}; 567 struct atu_cmd_card_config cmd; 568 u_int8_t reg_domain; 569 570 DPRINTFN(10, ("%s: sending mac-addr\n", USBDEVNAME(sc->atu_dev))); 571 err = atu_send_mib(sc, MIB_MAC_ADDR__ADDR, ic->ic_myaddr); 572 if (err) { 573 DPRINTF(("%s: error setting mac-addr\n", 574 USBDEVNAME(sc->atu_dev))); 575 return err; 576 } 577 578 /* 579 DPRINTF(("%s: sending reg-domain\n", USBDEVNAME(sc->atu_dev))); 580 err = atu_send_mib(sc, MIB_PHY__REG_DOMAIN, NR(0x30)); 581 if (err) { 582 DPRINTF(("%s: error setting mac-addr\n", 583 USBDEVNAME(sc->atu_dev))); 584 return err; 585 } 586 */ 587 588 memset(&cmd, 0, sizeof(cmd)); 589 cmd.Cmd = CMD_STARTUP; 590 cmd.Reserved = 0; 591 USETW(cmd.Size, sizeof(cmd) - 4); 592 593 if (sc->atu_desired_channel != IEEE80211_CHAN_ANY) 594 cmd.Channel = (u_int8_t)sc->atu_desired_channel; 595 else 596 cmd.Channel = sc->atu_channel; 597 cmd.AutoRateFallback = 1; 598 memcpy(cmd.BasicRateSet, rates, 4); 599 600 /* ShortRetryLimit should be 7 according to 802.11 spec */ 601 cmd.ShortRetryLimit = 7; 602 USETW(cmd.RTS_Threshold, 2347); 603 USETW(cmd.FragThreshold, 2346); 604 605 /* Doesn't seem to work, but we'll set it to 1 anyway */ 606 cmd.PromiscuousMode = 1; 607 608 /* this goes into the beacon we transmit */ 609 if (ic->ic_flags & IEEE80211_F_PRIVACY) 610 cmd.PrivacyInvoked = 1; 611 else 612 cmd.PrivacyInvoked = 0; 613 614 cmd.ExcludeUnencrypted = 0; 615 616 if (ic->ic_flags & IEEE80211_F_PRIVACY) { 617 switch (ic->ic_nw_keys[ic->ic_def_txkey].wk_keylen) { 618 case 5: 619 cmd.EncryptionType = ATU_WEP_40BITS; 620 break; 621 case 13: 622 cmd.EncryptionType = ATU_WEP_104BITS; 623 break; 624 default: 625 cmd.EncryptionType = ATU_WEP_OFF; 626 break; 627 } 628 629 630 cmd.WEP_DefaultKeyID = ic->ic_def_txkey; 631 for (i = 0; i < IEEE80211_WEP_NKID; i++) { 632 memcpy(cmd.WEP_DefaultKey[i], ic->ic_nw_keys[i].wk_key, 633 ic->ic_nw_keys[i].wk_keylen); 634 } 635 } 636 637 /* Setting the SSID here doesn't seem to do anything */ 638 memset(cmd.SSID, 0x00, sizeof(cmd.SSID)); 639 memcpy(cmd.SSID, ic->ic_des_essid, ic->ic_des_esslen); 640 cmd.SSID_Len = ic->ic_des_esslen; 641 642 cmd.ShortPreamble = 0; 643 USETW(cmd.BeaconPeriod, 100); 644 /* cmd.BeaconPeriod = 65535; */ 645 646 /* 647 * TODO: 648 * read reg domain MIB_PHY @ 0x17 (1 byte), (reply = 0x30) 649 * we should do something usefull with this info. right now it's just 650 * ignored 651 */ 652 err = atu_get_mib(sc, MIB_PHY__REG_DOMAIN, ®_domain); 653 if (err) { 654 DPRINTF(("%s: could not get regdomain!\n", 655 USBDEVNAME(sc->atu_dev))); 656 } else { 657 DPRINTF(("%s: in reg domain 0x%x according to the " 658 "adapter\n", USBDEVNAME(sc->atu_dev), reg_domain)); 659 } 660 661 #ifdef ATU_DEBUG 662 if (atudebug) { 663 DPRINTFN(20, ("%s: configlen=%02lx\n", USBDEVNAME(sc->atu_dev), 664 (unsigned long)sizeof(cmd))); 665 } 666 #endif /* ATU_DEBUG */ 667 668 /* Windoze : driver says exclude-unencrypted=1 & encr-type=1 */ 669 670 err = atu_send_command(sc, (u_int8_t *)&cmd, sizeof(cmd)); 671 if (err) 672 return err; 673 err = atu_wait_completion(sc, CMD_STARTUP, NULL); 674 if (err) 675 return err; 676 677 /* Turn on radio now */ 678 err = atu_switch_radio(sc, 1); 679 if (err) 680 return err; 681 682 /* preamble type = short */ 683 err = atu_send_mib(sc, MIB_LOCAL__PREAMBLE, NR(PREAMBLE_SHORT)); 684 if (err) 685 return err; 686 687 /* frag = 1536 */ 688 err = atu_send_mib(sc, MIB_MAC__FRAG, NR(2346)); 689 if (err) 690 return err; 691 692 /* rts = 1536 */ 693 err = atu_send_mib(sc, MIB_MAC__RTS, NR(2347)); 694 if (err) 695 return err; 696 697 /* auto rate fallback = 1 */ 698 err = atu_send_mib(sc, MIB_LOCAL__AUTO_RATE_FALLBACK, NR(1)); 699 if (err) 700 return err; 701 702 /* power mode = full on, no power saving */ 703 err = atu_send_mib(sc, MIB_MAC_MGMT__POWER_MODE, 704 NR(POWER_MODE_ACTIVE)); 705 if (err) 706 return err; 707 708 DPRINTFN(10, ("%s: completed initial config\n", 709 USBDEVNAME(sc->atu_dev))); 710 return 0; 711 } 712 713 int 714 atu_join(struct atu_softc *sc, struct ieee80211_node *node) 715 { 716 struct atu_cmd_join join; 717 u_int8_t status = 0; /* XXX: GCC */ 718 usbd_status err; 719 720 memset(&join, 0, sizeof(join)); 721 722 join.Cmd = CMD_JOIN; 723 join.Reserved = 0x00; 724 USETW(join.Size, sizeof(join) - 4); 725 726 DPRINTFN(15, ("%s: pre-join sc->atu_bssid=%s\n", 727 USBDEVNAME(sc->atu_dev), ether_sprintf(sc->atu_bssid))); 728 DPRINTFN(15, ("%s: mode=%d\n", USBDEVNAME(sc->atu_dev), 729 sc->atu_mode)); 730 memcpy(join.bssid, node->ni_bssid, IEEE80211_ADDR_LEN); 731 memset(join.essid, 0x00, 32); 732 memcpy(join.essid, node->ni_essid, node->ni_esslen); 733 join.essid_size = node->ni_esslen; 734 if (node->ni_capinfo & IEEE80211_CAPINFO_IBSS) 735 join.bss_type = AD_HOC_MODE; 736 else 737 join.bss_type = INFRASTRUCTURE_MODE; 738 join.channel = ieee80211_chan2ieee(&sc->sc_ic, node->ni_chan); 739 740 USETW(join.timeout, ATU_JOIN_TIMEOUT); 741 join.reserved = 0x00; 742 743 DPRINTFN(10, ("%s: trying to join BSSID=%s\n", 744 USBDEVNAME(sc->atu_dev), ether_sprintf(join.bssid))); 745 err = atu_send_command(sc, (u_int8_t *)&join, sizeof(join)); 746 if (err) { 747 DPRINTF(("%s: ERROR trying to join IBSS\n", 748 USBDEVNAME(sc->atu_dev))); 749 return err; 750 } 751 err = atu_wait_completion(sc, CMD_JOIN, &status); 752 if (err) { 753 DPRINTF(("%s: error joining BSS!\n", 754 USBDEVNAME(sc->atu_dev))); 755 return err; 756 } 757 if (status != STATUS_COMPLETE) { 758 DPRINTF(("%s: error joining... [status=%02x]\n", 759 USBDEVNAME(sc->atu_dev), status)); 760 return status; 761 } else { 762 DPRINTFN(10, ("%s: joined BSS\n", USBDEVNAME(sc->atu_dev))); 763 } 764 return err; 765 } 766 767 /* 768 * Get the state of the DFU unit 769 */ 770 int8_t 771 atu_get_dfu_state(struct atu_softc *sc) 772 { 773 u_int8_t state; 774 775 if (atu_usb_request(sc, DFU_GETSTATE, 0, 0, 1, &state)) 776 return -1; 777 return state; 778 } 779 780 /* 781 * Get MAC opmode 782 */ 783 u_int8_t 784 atu_get_opmode(struct atu_softc *sc, u_int8_t *mode) 785 { 786 787 return atu_usb_request(sc, UT_READ_VENDOR_INTERFACE, 0x33, 0x0001, 788 0x0000, 1, mode); 789 } 790 791 /* 792 * Upload the internal firmware into the device 793 */ 794 void 795 atu_internal_firmware(struct device *arg) 796 { 797 struct atu_softc *sc = (struct atu_softc *)arg; 798 u_char state, *ptr = NULL, *firm = NULL, status[6]; 799 int block_size, block = 0, err, i; 800 size_t bytes_left = 0; 801 802 /* 803 * Uploading firmware is done with the DFU (Device Firmware Upgrade) 804 * interface. See "Universal Serial Bus - Device Class Specification 805 * for Device Firmware Upgrade" pdf for details of the protocol. 806 * Maybe this could be moved to a separate 'firmware driver' once more 807 * device drivers need it... For now we'll just do it here. 808 * 809 * Just for your information, the Atmel's DFU descriptor looks like 810 * this: 811 * 812 * 07 size 813 * 21 type 814 * 01 capabilities : only firmware download, need reset 815 * after download 816 * 13 05 detach timeout : max 1299ms between DFU_DETACH and 817 * reset 818 * 00 04 max bytes of firmware per transaction : 1024 819 */ 820 821 /* Choose the right firmware for the device */ 822 for (i = 0; i < sizeof(atu_radfirm)/sizeof(atu_radfirm[0]); i++) 823 if (sc->atu_radio == atu_radfirm[i].atur_type) { 824 firm = atu_radfirm[i].atur_internal; 825 bytes_left = atu_radfirm[i].atur_internal_sz; 826 } 827 828 if (firm == NULL) { 829 printf("%s: no firmware found\n", USBDEVNAME(sc->atu_dev)); 830 return; 831 } 832 833 ptr = firm; 834 state = atu_get_dfu_state(sc); 835 836 while (block >= 0 && state > 0) { 837 switch (state) { 838 case DFUState_DnLoadSync: 839 /* get DFU status */ 840 err = atu_usb_request(sc, DFU_GETSTATUS, 0, 0 , 6, 841 status); 842 if (err) { 843 DPRINTF(("%s: dfu_getstatus failed!\n", 844 USBDEVNAME(sc->atu_dev))); 845 return; 846 } 847 /* success means state => DnLoadIdle */ 848 state = DFUState_DnLoadIdle; 849 continue; 850 break; 851 852 case DFUState_DFUIdle: 853 case DFUState_DnLoadIdle: 854 if (bytes_left>=DFU_MaxBlockSize) 855 block_size = DFU_MaxBlockSize; 856 else 857 block_size = bytes_left; 858 DPRINTFN(15, ("%s: firmware block %d\n", 859 USBDEVNAME(sc->atu_dev), block)); 860 861 err = atu_usb_request(sc, DFU_DNLOAD, block++, 0, 862 block_size, ptr); 863 if (err) { 864 DPRINTF(("%s: dfu_dnload failed\n", 865 USBDEVNAME(sc->atu_dev))); 866 return; 867 } 868 869 ptr += block_size; 870 bytes_left -= block_size; 871 if (block_size == 0) 872 block = -1; 873 break; 874 875 default: 876 usbd_delay_ms(sc->atu_udev, 100); 877 DPRINTFN(20, ("%s: sleeping for a while\n", 878 USBDEVNAME(sc->atu_dev))); 879 break; 880 } 881 882 state = atu_get_dfu_state(sc); 883 } 884 885 if (state != DFUState_ManifestSync) { 886 DPRINTF(("%s: state != manifestsync... eek!\n", 887 USBDEVNAME(sc->atu_dev))); 888 } 889 890 err = atu_usb_request(sc, DFU_GETSTATUS, 0, 0, 6, status); 891 if (err) { 892 DPRINTF(("%s: dfu_getstatus failed!\n", 893 USBDEVNAME(sc->atu_dev))); 894 return; 895 } 896 897 DPRINTFN(15, ("%s: sending remap\n", USBDEVNAME(sc->atu_dev))); 898 err = atu_usb_request(sc, DFU_REMAP, 0, 0, 0, NULL); 899 if ((err) && (! sc->atu_quirk & ATU_QUIRK_NO_REMAP)) { 900 DPRINTF(("%s: remap failed!\n", USBDEVNAME(sc->atu_dev))); 901 return; 902 } 903 904 /* after a lot of trying and measuring I found out the device needs 905 * about 56 miliseconds after sending the remap command before 906 * it's ready to communicate again. So we'll wait just a little bit 907 * longer than that to be sure... 908 */ 909 usbd_delay_ms(sc->atu_udev, 56+100); 910 911 printf("%s: reattaching after firmware upload\n", 912 USBDEVNAME(sc->atu_dev)); 913 usb_needs_reattach(sc->atu_udev); 914 } 915 916 void 917 atu_external_firmware(struct device *arg) 918 { 919 struct atu_softc *sc = (struct atu_softc *)arg; 920 u_char *ptr = NULL, *firm = NULL; 921 int block_size, block = 0, err, i; 922 size_t bytes_left = 0; 923 924 for (i = 0; i < sizeof(atu_radfirm)/sizeof(atu_radfirm[0]); i++) 925 if (sc->atu_radio == atu_radfirm[i].atur_type) { 926 firm = atu_radfirm[i].atur_external; 927 bytes_left = atu_radfirm[i].atur_external_sz; 928 } 929 930 if (firm == NULL) { 931 printf("%s: no firmware found\n", USBDEVNAME(sc->atu_dev)); 932 return; 933 } 934 ptr = firm; 935 936 while (bytes_left) { 937 if (bytes_left > 1024) 938 block_size = 1024; 939 else 940 block_size = bytes_left; 941 942 DPRINTFN(15, ("%s: block:%d size:%d\n", 943 USBDEVNAME(sc->atu_dev), block, block_size)); 944 err = atu_usb_request(sc, UT_WRITE_VENDOR_DEVICE, 0x0e, 945 0x0802, block, block_size, ptr); 946 if (err) { 947 DPRINTF(("%s: could not load external firmware " 948 "block\n", USBDEVNAME(sc->atu_dev))); 949 return; 950 } 951 952 ptr += block_size; 953 block++; 954 bytes_left -= block_size; 955 } 956 957 err = atu_usb_request(sc, UT_WRITE_VENDOR_DEVICE, 0x0e, 0x0802, 958 block, 0, NULL); 959 if (err) { 960 DPRINTF(("%s: could not load last zero-length firmware " 961 "block\n", USBDEVNAME(sc->atu_dev))); 962 return; 963 } 964 965 /* 966 * The SMC2662w V.4 seems to require some time to do it's thing with 967 * the external firmware... 20 ms isn't enough, but 21 ms works 100 968 * times out of 100 tries. We'll wait a bit longer just to be sure 969 */ 970 if (sc->atu_quirk & ATU_QUIRK_FW_DELAY) 971 usbd_delay_ms(sc->atu_udev, 21 + 100); 972 973 DPRINTFN(10, ("%s: external firmware upload done\n", 974 USBDEVNAME(sc->atu_dev))); 975 /* complete configuration after the firmwares have been uploaded */ 976 atu_complete_attach(sc); 977 } 978 979 int 980 atu_get_card_config(struct atu_softc *sc) 981 { 982 struct ieee80211com *ic = &sc->sc_ic; 983 struct atu_rfmd_conf rfmd_conf; 984 struct atu_intersil_conf intersil_conf; 985 int err; 986 987 switch (sc->atu_radio) { 988 989 case RadioRFMD: 990 case RadioRFMD2958: 991 case RadioRFMD2958_SMC: 992 err = atu_usb_request(sc, UT_READ_VENDOR_INTERFACE, 0x33, 993 0x0a02, 0x0000, sizeof(rfmd_conf), 994 (u_int8_t *)&rfmd_conf); 995 if (err) { 996 DPRINTF(("%s: could not get rfmd config!\n", 997 USBDEVNAME(sc->atu_dev))); 998 return err; 999 } 1000 memcpy(ic->ic_myaddr, rfmd_conf.MACAddr, IEEE80211_ADDR_LEN); 1001 break; 1002 1003 case RadioIntersil: 1004 err = atu_usb_request(sc, UT_READ_VENDOR_INTERFACE, 0x33, 1005 0x0902, 0x0000, sizeof(intersil_conf), 1006 (u_int8_t *)&intersil_conf); 1007 if (err) { 1008 DPRINTF(("%s: could not get intersil config!\n", 1009 USBDEVNAME(sc->atu_dev))); 1010 return err; 1011 } 1012 memcpy(ic->ic_myaddr, intersil_conf.MACAddr, 1013 IEEE80211_ADDR_LEN); 1014 break; 1015 } 1016 return 0; 1017 } 1018 1019 /* 1020 * Probe for an AT76c503 chip. 1021 */ 1022 USB_MATCH(atu) 1023 { 1024 USB_MATCH_START(atu, uaa); 1025 int i; 1026 1027 if (!uaa->iface) 1028 return(UMATCH_NONE); 1029 1030 for (i = 0; i < sizeof(atu_devs)/sizeof(atu_devs[0]); i++) { 1031 struct atu_type *t = &atu_devs[i]; 1032 1033 if (uaa->vendor == t->atu_vid && 1034 uaa->product == t->atu_pid) { 1035 return(UMATCH_VENDOR_PRODUCT); 1036 } 1037 } 1038 return(UMATCH_NONE); 1039 } 1040 1041 int 1042 atu_media_change(struct ifnet *ifp) 1043 { 1044 struct atu_softc *sc = ifp->if_softc; 1045 struct ieee80211com *ic = &sc->sc_ic; 1046 int err, s; 1047 1048 DPRINTFN(10, ("%s: atu_media_change\n", USBDEVNAME(sc->atu_dev))); 1049 1050 err = ieee80211_media_change(ifp); 1051 if (err == ENETRESET) { 1052 if ((ifp->if_flags & (IFF_RUNNING|IFF_UP)) == 1053 (IFF_RUNNING|IFF_UP)) { 1054 s = splnet(); 1055 ieee80211_new_state(ic, IEEE80211_S_INIT, -1); 1056 atu_initial_config(sc); 1057 ieee80211_new_state(ic, IEEE80211_S_SCAN, -1); 1058 splx(s); 1059 } 1060 err = 0; 1061 } 1062 1063 return (err); 1064 } 1065 1066 void 1067 atu_media_status(struct ifnet *ifp, struct ifmediareq *req) 1068 { 1069 #ifdef ATU_DEBUG 1070 struct atu_softc *sc = ifp->if_softc; 1071 #endif /* ATU_DEBUG */ 1072 1073 DPRINTFN(10, ("%s: atu_media_status\n", USBDEVNAME(sc->atu_dev))); 1074 1075 ieee80211_media_status(ifp, req); 1076 } 1077 1078 void 1079 atu_task(void *arg) 1080 { 1081 struct atu_softc *sc = (struct atu_softc *)arg; 1082 struct ieee80211com *ic = &sc->sc_ic; 1083 usbd_status err; 1084 int s; 1085 1086 DPRINTFN(10, ("%s: atu_task\n", USBDEVNAME(sc->atu_dev))); 1087 1088 if (sc->sc_state != ATU_S_OK) 1089 return; 1090 1091 switch (sc->sc_cmd) { 1092 case ATU_C_SCAN: 1093 1094 err = atu_start_scan(sc); 1095 if (err) { 1096 DPRINTFN(1, ("%s: atu_task: couldn't start scan!\n", 1097 USBDEVNAME(sc->atu_dev))); 1098 return; 1099 } 1100 1101 err = atu_wait_completion(sc, CMD_START_SCAN, NULL); 1102 if (err) { 1103 DPRINTF(("%s: atu_task: error waiting for scan\n", 1104 USBDEVNAME(sc->atu_dev))); 1105 return; 1106 } 1107 1108 DPRINTF(("%s: ==========================> END OF SCAN!\n", 1109 USBDEVNAME(sc->atu_dev))); 1110 1111 s = splnet(); 1112 ieee80211_next_scan(ic); 1113 splx(s); 1114 1115 DPRINTF(("%s: ----------------------======> END OF SCAN2!\n", 1116 USBDEVNAME(sc->atu_dev))); 1117 break; 1118 1119 case ATU_C_JOIN: 1120 atu_join(sc, ic->ic_bss); 1121 } 1122 } 1123 1124 int 1125 atu_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg) 1126 { 1127 struct ifnet *ifp = ic->ic_ifp; 1128 struct atu_softc *sc = ifp->if_softc; 1129 enum ieee80211_state ostate = ic->ic_state; 1130 1131 DPRINTFN(10, ("%s: atu_newstate: %s -> %s\n", USBDEVNAME(sc->atu_dev), 1132 ieee80211_state_name[ostate], ieee80211_state_name[nstate])); 1133 1134 switch (nstate) { 1135 case IEEE80211_S_SCAN: 1136 memcpy(ic->ic_chan_scan, ic->ic_chan_active, 1137 sizeof(ic->ic_chan_active)); 1138 ieee80211_node_table_reset(&ic->ic_scan); 1139 1140 /* tell the event thread that we want a scan */ 1141 sc->sc_cmd = ATU_C_SCAN; 1142 usb_add_task(sc->atu_udev, &sc->sc_task, USB_TASKQ_DRIVER); 1143 1144 /* handle this ourselves */ 1145 ic->ic_state = nstate; 1146 return (0); 1147 1148 case IEEE80211_S_AUTH: 1149 case IEEE80211_S_RUN: 1150 if (ostate == IEEE80211_S_SCAN) { 1151 sc->sc_cmd = ATU_C_JOIN; 1152 usb_add_task(sc->atu_udev, &sc->sc_task, 1153 USB_TASKQ_DRIVER); 1154 } 1155 break; 1156 default: 1157 /* nothing to do */ 1158 break; 1159 } 1160 1161 return (*sc->sc_newstate)(ic, nstate, arg); 1162 } 1163 1164 /* 1165 * Attach the interface. Allocate softc structures, do 1166 * setup and ethernet/BPF attach. 1167 */ 1168 USB_ATTACH(atu) 1169 { 1170 USB_ATTACH_START(atu, sc, uaa); 1171 char *devinfop; 1172 usbd_status err; 1173 usbd_device_handle dev = uaa->device; 1174 u_int8_t mode, channel; 1175 int i; 1176 1177 sc->sc_state = ATU_S_UNCONFIG; 1178 1179 devinfop = usbd_devinfo_alloc(dev, 0); 1180 USB_ATTACH_SETUP; 1181 printf("%s: %s\n", USBDEVNAME(sc->atu_dev), devinfop); 1182 usbd_devinfo_free(devinfop); 1183 1184 err = usbd_set_config_no(dev, ATU_CONFIG_NO, 1); 1185 if (err) { 1186 printf("%s: setting config no failed\n", 1187 USBDEVNAME(sc->atu_dev)); 1188 USB_ATTACH_ERROR_RETURN; 1189 } 1190 1191 err = usbd_device2interface_handle(dev, ATU_IFACE_IDX, &sc->atu_iface); 1192 if (err) { 1193 printf("%s: getting interface handle failed\n", 1194 USBDEVNAME(sc->atu_dev)); 1195 USB_ATTACH_ERROR_RETURN; 1196 } 1197 1198 sc->atu_unit = device_unit(self); 1199 sc->atu_udev = dev; 1200 1201 /* 1202 * look up the radio_type for the device 1203 * basically does the same as USB_MATCH 1204 */ 1205 for (i = 0; i < sizeof(atu_devs)/sizeof(atu_devs[0]); i++) { 1206 struct atu_type *t = &atu_devs[i]; 1207 1208 if (uaa->vendor == t->atu_vid && 1209 uaa->product == t->atu_pid) { 1210 sc->atu_radio = t->atu_radio; 1211 sc->atu_quirk = t->atu_quirk; 1212 } 1213 } 1214 1215 /* 1216 * Check in the interface descriptor if we're in DFU mode 1217 * If we're in DFU mode, we upload the external firmware 1218 * If we're not, the PC must have rebooted without power-cycling 1219 * the device.. I've tried this out, a reboot only requeres the 1220 * external firmware to be reloaded :) 1221 * 1222 * Hmm. The at76c505a doesn't report a DFU descriptor when it's 1223 * in DFU mode... Let's just try to get the opmode 1224 */ 1225 err = atu_get_opmode(sc, &mode); 1226 DPRINTFN(20, ("%s: opmode: %d\n", USBDEVNAME(sc->atu_dev), mode)); 1227 if (err || (mode != MODE_NETCARD && mode != MODE_NOFLASHNETCARD)) { 1228 DPRINTF(("%s: starting internal firmware download\n", 1229 USBDEVNAME(sc->atu_dev))); 1230 1231 atu_internal_firmware((struct device *)sc); 1232 /* 1233 * atu_internal_firmware will cause a reset of the device 1234 * so we don't want to do any more configuration after this 1235 * point. 1236 */ 1237 USB_ATTACH_SUCCESS_RETURN; 1238 } 1239 1240 uaa->iface = sc->atu_iface; 1241 1242 if (mode != MODE_NETCARD) { 1243 DPRINTFN(15, ("%s: device needs external firmware\n", 1244 USBDEVNAME(sc->atu_dev))); 1245 1246 if (mode != MODE_NOFLASHNETCARD) { 1247 DPRINTF(("%s: unexpected opmode=%d\n", 1248 USBDEVNAME(sc->atu_dev), mode)); 1249 } 1250 1251 /* 1252 * There is no difference in opmode before and after external 1253 * firmware upload with the SMC2662 V.4 . So instead we'll try 1254 * to read the channel number. If we succeed, external 1255 * firmwaremust have been already uploaded... 1256 */ 1257 if (sc->atu_radio != RadioIntersil) { 1258 err = atu_get_mib(sc, MIB_PHY__CHANNEL, &channel); 1259 if (!err) { 1260 DPRINTF(("%s: external firmware has already" 1261 " been downloaded\n", 1262 USBDEVNAME(sc->atu_dev))); 1263 atu_complete_attach(sc); 1264 USB_ATTACH_SUCCESS_RETURN; 1265 } 1266 } 1267 1268 atu_external_firmware((struct device *)sc); 1269 1270 /* 1271 * atu_external_firmware will call atu_complete_attach after 1272 * it's finished so we can just return. 1273 */ 1274 } else { 1275 /* all the firmwares are in place, so complete the attach */ 1276 atu_complete_attach(sc); 1277 } 1278 1279 USB_ATTACH_SUCCESS_RETURN; 1280 } 1281 1282 void 1283 atu_complete_attach(struct atu_softc *sc) 1284 { 1285 struct ieee80211com *ic = &sc->sc_ic; 1286 struct ifnet *ifp = &sc->sc_if; 1287 usb_interface_descriptor_t *id; 1288 usb_endpoint_descriptor_t *ed; 1289 usbd_status err; 1290 int i; 1291 #ifdef ATU_DEBUG 1292 struct atu_fw fw; 1293 #endif 1294 1295 id = usbd_get_interface_descriptor(sc->atu_iface); 1296 1297 /* Find endpoints. */ 1298 for (i = 0; i < id->bNumEndpoints; i++) { 1299 ed = usbd_interface2endpoint_descriptor(sc->atu_iface, i); 1300 if (!ed) { 1301 DPRINTF(("%s: num_endp:%d\n", USBDEVNAME(sc->atu_dev), 1302 sc->atu_iface->idesc->bNumEndpoints)); 1303 DPRINTF(("%s: couldn't get ep %d\n", 1304 USBDEVNAME(sc->atu_dev), i)); 1305 return; 1306 } 1307 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 1308 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 1309 sc->atu_ed[ATU_ENDPT_RX] = ed->bEndpointAddress; 1310 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && 1311 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 1312 sc->atu_ed[ATU_ENDPT_TX] = ed->bEndpointAddress; 1313 } 1314 } 1315 1316 /* read device config & get MAC address */ 1317 err = atu_get_card_config(sc); 1318 if (err) { 1319 printf("\n%s: could not get card cfg!\n", 1320 USBDEVNAME(sc->atu_dev)); 1321 return; 1322 } 1323 1324 #ifdef ATU_DEBUG 1325 /* DEBUG : try to get firmware version */ 1326 err = atu_get_mib(sc, MIB_FW_VERSION, sizeof(fw), 0, 1327 (u_int8_t *)&fw); 1328 if (!err) { 1329 DPRINTFN(15, ("%s: firmware: maj:%d min:%d patch:%d " 1330 "build:%d\n", USBDEVNAME(sc->atu_dev), fw.major, fw.minor, 1331 fw.patch, fw.build)); 1332 } else { 1333 DPRINTF(("%s: get firmware version failed\n", 1334 USBDEVNAME(sc->atu_dev))); 1335 } 1336 #endif /* ATU_DEBUG */ 1337 1338 /* Show the world our MAC address */ 1339 printf("%s: MAC address %s\n", USBDEVNAME(sc->atu_dev), 1340 ether_sprintf(ic->ic_myaddr)); 1341 1342 sc->atu_cdata.atu_tx_inuse = 0; 1343 sc->atu_encrypt = ATU_WEP_OFF; 1344 sc->atu_wepkeylen = ATU_WEP_104BITS; 1345 sc->atu_wepkey = 0; 1346 1347 bzero(sc->atu_bssid, ETHER_ADDR_LEN); 1348 sc->atu_channel = ATU_DEFAULT_CHANNEL; 1349 sc->atu_desired_channel = IEEE80211_CHAN_ANY; 1350 sc->atu_mode = INFRASTRUCTURE_MODE; 1351 1352 ic->ic_ifp = ifp; 1353 ic->ic_phytype = IEEE80211_T_DS; 1354 ic->ic_opmode = IEEE80211_M_STA; 1355 ic->ic_state = IEEE80211_S_INIT; 1356 #ifdef FIXME 1357 ic->ic_caps = IEEE80211_C_IBSS | IEEE80211_C_WEP | IEEE80211_C_SCANALL; 1358 #else 1359 ic->ic_caps = IEEE80211_C_IBSS | IEEE80211_C_WEP; 1360 #endif 1361 1362 i = 0; 1363 ic->ic_sup_rates[IEEE80211_MODE_11B].rs_rates[i++] = 2; 1364 ic->ic_sup_rates[IEEE80211_MODE_11B].rs_rates[i++] = 4; 1365 ic->ic_sup_rates[IEEE80211_MODE_11B].rs_rates[i++] = 11; 1366 ic->ic_sup_rates[IEEE80211_MODE_11B].rs_rates[i++] = 22; 1367 ic->ic_sup_rates[IEEE80211_MODE_11B].rs_nrates = i; 1368 1369 for (i = 1; i <= 14; i++) { 1370 ic->ic_channels[i].ic_flags = IEEE80211_CHAN_B | 1371 IEEE80211_CHAN_PASSIVE; 1372 ic->ic_channels[i].ic_freq = ieee80211_ieee2mhz(i, 1373 ic->ic_channels[i].ic_flags); 1374 } 1375 1376 ic->ic_ibss_chan = &ic->ic_channels[0]; 1377 1378 ifp->if_softc = sc; 1379 memcpy(ifp->if_xname, USBDEVNAME(sc->atu_dev), IFNAMSIZ); 1380 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1381 ifp->if_init = atu_init; 1382 ifp->if_stop = atu_stop; 1383 ifp->if_start = atu_start; 1384 ifp->if_ioctl = atu_ioctl; 1385 ifp->if_watchdog = atu_watchdog; 1386 ifp->if_mtu = ATU_DEFAULT_MTU; 1387 IFQ_SET_READY(&ifp->if_snd); 1388 1389 /* Call MI attach routine. */ 1390 if_attach(ifp); 1391 ieee80211_ifattach(ic); 1392 1393 sc->sc_newstate = ic->ic_newstate; 1394 ic->ic_newstate = atu_newstate; 1395 1396 /* setup ifmedia interface */ 1397 ieee80211_media_init(ic, atu_media_change, atu_media_status); 1398 1399 usb_init_task(&sc->sc_task, atu_task, sc); 1400 1401 sc->sc_state = ATU_S_OK; 1402 } 1403 1404 USB_DETACH(atu) 1405 { 1406 USB_DETACH_START(atu, sc); 1407 struct ifnet *ifp = &sc->sc_if; 1408 1409 DPRINTFN(10, ("%s: atu_detach state=%d\n", USBDEVNAME(sc->atu_dev), 1410 sc->sc_state)); 1411 1412 if (sc->sc_state != ATU_S_UNCONFIG) { 1413 atu_stop(ifp, 1); 1414 1415 ieee80211_ifdetach(&sc->sc_ic); 1416 if_detach(ifp); 1417 } 1418 1419 return(0); 1420 } 1421 1422 int 1423 atu_activate(device_ptr_t self, enum devact act) 1424 { 1425 struct atu_softc *sc = (struct atu_softc *)self; 1426 1427 switch (act) { 1428 case DVACT_ACTIVATE: 1429 return (EOPNOTSUPP); 1430 break; 1431 case DVACT_DEACTIVATE: 1432 if (sc->sc_state != ATU_S_UNCONFIG) { 1433 if_deactivate(&sc->atu_ec.ec_if); 1434 sc->sc_state = ATU_S_DEAD; 1435 } 1436 break; 1437 } 1438 return (0); 1439 } 1440 1441 /* 1442 * Initialize an RX descriptor and attach an MBUF cluster. 1443 */ 1444 int 1445 atu_newbuf(struct atu_softc *sc, struct atu_chain *c, struct mbuf *m) 1446 { 1447 struct mbuf *m_new = NULL; 1448 1449 if (m == NULL) { 1450 MGETHDR(m_new, M_DONTWAIT, MT_DATA); 1451 if (m_new == NULL) { 1452 DPRINTF(("%s: no memory for rx list\n", 1453 USBDEVNAME(sc->atu_dev))); 1454 return(ENOBUFS); 1455 } 1456 1457 MCLGET(m_new, M_DONTWAIT); 1458 if (!(m_new->m_flags & M_EXT)) { 1459 DPRINTF(("%s: no memory for rx list\n", 1460 USBDEVNAME(sc->atu_dev))); 1461 m_freem(m_new); 1462 return(ENOBUFS); 1463 } 1464 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES; 1465 } else { 1466 m_new = m; 1467 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES; 1468 m_new->m_data = m_new->m_ext.ext_buf; 1469 } 1470 c->atu_mbuf = m_new; 1471 return(0); 1472 } 1473 1474 int 1475 atu_rx_list_init(struct atu_softc *sc) 1476 { 1477 struct atu_cdata *cd = &sc->atu_cdata; 1478 struct atu_chain *c; 1479 int i; 1480 1481 DPRINTFN(15, ("%s: atu_rx_list_init: enter\n", 1482 USBDEVNAME(sc->atu_dev))); 1483 1484 for (i = 0; i < ATU_RX_LIST_CNT; i++) { 1485 c = &cd->atu_rx_chain[i]; 1486 c->atu_sc = sc; 1487 c->atu_idx = i; 1488 if (c->atu_xfer == NULL) { 1489 c->atu_xfer = usbd_alloc_xfer(sc->atu_udev, 1490 sc->atu_ep[ATU_ENDPT_RX]); 1491 if (c->atu_xfer == NULL) 1492 return (ENOBUFS); 1493 c->atu_buf = usbd_alloc_buffer(c->atu_xfer, 1494 ATU_RX_BUFSZ); 1495 if (c->atu_buf == NULL) /* XXX free xfer */ 1496 return (ENOBUFS); 1497 if (atu_newbuf(sc, c, NULL) == ENOBUFS) /* XXX free? */ 1498 return(ENOBUFS); 1499 } 1500 } 1501 return (0); 1502 } 1503 1504 int 1505 atu_tx_list_init(struct atu_softc *sc) 1506 { 1507 struct atu_cdata *cd = &sc->atu_cdata; 1508 struct atu_chain *c; 1509 int i; 1510 1511 DPRINTFN(15, ("%s: atu_tx_list_init\n", 1512 USBDEVNAME(sc->atu_dev))); 1513 1514 SLIST_INIT(&cd->atu_tx_free); 1515 sc->atu_cdata.atu_tx_inuse = 0; 1516 1517 for (i = 0; i < ATU_TX_LIST_CNT; i++) { 1518 c = &cd->atu_tx_chain[i]; 1519 c->atu_sc = sc; 1520 c->atu_idx = i; 1521 if (c->atu_xfer == NULL) { 1522 c->atu_xfer = usbd_alloc_xfer(sc->atu_udev, 1523 sc->atu_ep[ATU_ENDPT_TX]); 1524 if (c->atu_xfer == NULL) 1525 return(ENOBUFS); 1526 c->atu_mbuf = NULL; 1527 c->atu_buf = usbd_alloc_buffer(c->atu_xfer, 1528 ATU_TX_BUFSZ); 1529 if (c->atu_buf == NULL) 1530 return(ENOBUFS); /* XXX free xfer */ 1531 SLIST_INSERT_HEAD(&cd->atu_tx_free, c, atu_list); 1532 } 1533 } 1534 return(0); 1535 } 1536 1537 void 1538 atu_xfer_list_free(struct atu_softc *sc, struct atu_chain *ch, 1539 int listlen) 1540 { 1541 int i; 1542 1543 /* Free resources. */ 1544 for (i = 0; i < listlen; i++) { 1545 if (ch[i].atu_buf != NULL) 1546 ch[i].atu_buf = NULL; 1547 if (ch[i].atu_mbuf != NULL) { 1548 m_freem(ch[i].atu_mbuf); 1549 ch[i].atu_mbuf = NULL; 1550 } 1551 if (ch[i].atu_xfer != NULL) { 1552 usbd_free_xfer(ch[i].atu_xfer); 1553 ch[i].atu_xfer = NULL; 1554 } 1555 } 1556 } 1557 1558 /* 1559 * A frame has been uploaded: pass the resulting mbuf chain up to 1560 * the higher level protocols. 1561 */ 1562 void 1563 atu_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) 1564 { 1565 struct atu_chain *c = (struct atu_chain *)priv; 1566 struct atu_softc *sc = c->atu_sc; 1567 struct ieee80211com *ic = &sc->sc_ic; 1568 struct ifnet *ifp = &sc->sc_if; 1569 struct atu_rx_hdr *h; 1570 struct ieee80211_frame_min *wh; 1571 struct ieee80211_node *ni; 1572 struct mbuf *m; 1573 u_int32_t len; 1574 int s; 1575 1576 DPRINTFN(25, ("%s: atu_rxeof\n", USBDEVNAME(sc->atu_dev))); 1577 1578 if (sc->sc_state != ATU_S_OK) 1579 return; 1580 1581 if ((ifp->if_flags & (IFF_RUNNING|IFF_UP)) != (IFF_RUNNING|IFF_UP)) 1582 goto done; 1583 1584 if (status != USBD_NORMAL_COMPLETION) { 1585 DPRINTF(("%s: status != USBD_NORMAL_COMPLETION\n", 1586 USBDEVNAME(sc->atu_dev))); 1587 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) { 1588 return; 1589 } 1590 #if 0 1591 if (status == USBD_IOERROR) { 1592 DPRINTF(("%s: rx: EEK! lost device?\n", 1593 USBDEVNAME(sc->atu_dev))); 1594 1595 /* 1596 * My experience with USBD_IOERROR is that trying to 1597 * restart the transfer will always fail and we'll 1598 * keep on looping restarting transfers untill someone 1599 * pulls the plug of the device. 1600 * So we don't restart the transfer, but just let it 1601 * die... If someone knows of a situation where we can 1602 * recover from USBD_IOERROR, let me know. 1603 */ 1604 splx(s); 1605 return; 1606 } 1607 #endif /* 0 */ 1608 1609 if (usbd_ratecheck(&sc->atu_rx_notice)) { 1610 DPRINTF(("%s: usb error on rx: %s\n", 1611 USBDEVNAME(sc->atu_dev), usbd_errstr(status))); 1612 } 1613 if (status == USBD_STALLED) 1614 usbd_clear_endpoint_stall_async( 1615 sc->atu_ep[ATU_ENDPT_RX]); 1616 goto done; 1617 } 1618 1619 usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL); 1620 1621 if (len <= 1) { 1622 DPRINTF(("%s: atu_rxeof: too short\n", 1623 USBDEVNAME(sc->atu_dev))); 1624 goto done; 1625 } 1626 1627 h = (struct atu_rx_hdr *)c->atu_buf; 1628 len = UGETW(h->length) - 4; /* XXX magic number */ 1629 1630 m = c->atu_mbuf; 1631 memcpy(mtod(m, char *), c->atu_buf + ATU_RX_HDRLEN, len); 1632 m->m_pkthdr.rcvif = ifp; 1633 m->m_pkthdr.len = m->m_len = len; 1634 1635 wh = mtod(m, struct ieee80211_frame_min *); 1636 ni = ieee80211_find_rxnode(ic, wh); 1637 1638 ifp->if_ipackets++; 1639 1640 s = splnet(); 1641 1642 if (atu_newbuf(sc, c, NULL) == ENOBUFS) { 1643 ifp->if_ierrors++; 1644 goto done1; /* XXX if we can't allocate, why restart it? */ 1645 } 1646 1647 if (wh->i_fc[1] & IEEE80211_FC1_WEP) { 1648 /* 1649 * WEP is decrypted by hardware. Clear WEP bit 1650 * header for ieee80211_input(). 1651 */ 1652 wh->i_fc[1] &= ~IEEE80211_FC1_WEP; 1653 } 1654 1655 ieee80211_input(ic, m, ni, h->rssi, UGETDW(h->rx_time)); 1656 1657 ieee80211_free_node(ni); 1658 done1: 1659 splx(s); 1660 done: 1661 /* Setup new transfer. */ 1662 usbd_setup_xfer(c->atu_xfer, sc->atu_ep[ATU_ENDPT_RX], c, c->atu_buf, 1663 ATU_RX_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT, 1664 atu_rxeof); 1665 usbd_transfer(c->atu_xfer); 1666 } 1667 1668 /* 1669 * A frame was downloaded to the chip. It's safe for us to clean up 1670 * the list buffers. 1671 */ 1672 void 1673 atu_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, 1674 usbd_status status) 1675 { 1676 struct atu_chain *c = (struct atu_chain *)priv; 1677 struct atu_softc *sc = c->atu_sc; 1678 struct ifnet *ifp = &sc->sc_if; 1679 usbd_status err; 1680 int s; 1681 1682 DPRINTFN(25, ("%s: atu_txeof status=%d\n", USBDEVNAME(sc->atu_dev), 1683 status)); 1684 1685 if (c->atu_mbuf) { 1686 m_freem(c->atu_mbuf); 1687 c->atu_mbuf = NULL; 1688 } 1689 1690 if (status != USBD_NORMAL_COMPLETION) { 1691 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) 1692 return; 1693 1694 DPRINTF(("%s: usb error on tx: %s\n", USBDEVNAME(sc->atu_dev), 1695 usbd_errstr(status))); 1696 if (status == USBD_STALLED) 1697 usbd_clear_endpoint_stall_async(sc->atu_ep[ATU_ENDPT_TX]); 1698 return; 1699 } 1700 1701 usbd_get_xfer_status(c->atu_xfer, NULL, NULL, NULL, &err); 1702 1703 if (err) 1704 ifp->if_oerrors++; 1705 else 1706 ifp->if_opackets++; 1707 1708 s = splnet(); 1709 SLIST_INSERT_HEAD(&sc->atu_cdata.atu_tx_free, c, atu_list); 1710 sc->atu_cdata.atu_tx_inuse--; 1711 if (sc->atu_cdata.atu_tx_inuse == 0) 1712 ifp->if_timer = 0; 1713 ifp->if_flags &= ~IFF_OACTIVE; 1714 splx(s); 1715 1716 atu_start(ifp); 1717 } 1718 1719 u_int8_t 1720 atu_calculate_padding(int size) 1721 { 1722 size %= 64; 1723 1724 if (size < 50) 1725 return (50 - size); 1726 if (size >=61) 1727 return (64 + 50 - size); 1728 return (0); 1729 } 1730 1731 int 1732 atu_tx_start(struct atu_softc *sc, struct ieee80211_node *ni, 1733 struct atu_chain *c, struct mbuf *m) 1734 { 1735 int len; 1736 struct atu_tx_hdr *h; 1737 usbd_status err; 1738 u_int8_t pad; 1739 1740 DPRINTFN(25, ("%s: atu_tx_start\n", USBDEVNAME(sc->atu_dev))); 1741 1742 /* Don't try to send when we're shutting down the driver */ 1743 if (sc->sc_state != ATU_S_OK) { 1744 m_freem(m); 1745 return(EIO); 1746 } 1747 1748 /* 1749 * Copy the mbuf data into a contiguous buffer, leaving 1750 * enough room for the atmel headers 1751 */ 1752 len = m->m_pkthdr.len; 1753 1754 m_copydata(m, 0, m->m_pkthdr.len, c->atu_buf + ATU_TX_HDRLEN); 1755 1756 h = (struct atu_tx_hdr *)c->atu_buf; 1757 memset(h, 0, ATU_TX_HDRLEN); 1758 USETW(h->length, len); 1759 h->tx_rate = 4; /* XXX rate = auto */ 1760 len += ATU_TX_HDRLEN; 1761 1762 pad = atu_calculate_padding(len); 1763 len += pad; 1764 h->padding = pad; 1765 1766 c->atu_length = len; 1767 c->atu_mbuf = m; 1768 1769 usbd_setup_xfer(c->atu_xfer, sc->atu_ep[ATU_ENDPT_TX], 1770 c, c->atu_buf, c->atu_length, USBD_NO_COPY, ATU_TX_TIMEOUT, 1771 atu_txeof); 1772 1773 /* Let's get this thing into the air! */ 1774 c->atu_in_xfer = 1; 1775 err = usbd_transfer(c->atu_xfer); 1776 if (err != USBD_IN_PROGRESS) { 1777 DPRINTFN(25, ("%s: atu_tx_start, err=%d", 1778 USBDEVNAME(sc->atu_dev), err)); 1779 c->atu_mbuf = NULL; 1780 m_freem(m); 1781 return(EIO); 1782 } 1783 1784 return (0); 1785 } 1786 1787 void 1788 atu_start(struct ifnet *ifp) 1789 { 1790 struct atu_softc *sc = ifp->if_softc; 1791 struct ieee80211com *ic = &sc->sc_ic; 1792 struct atu_cdata *cd = &sc->atu_cdata; 1793 struct ieee80211_node *ni; 1794 struct atu_chain *c; 1795 struct mbuf *m = NULL; 1796 int s; 1797 1798 DPRINTFN(25, ("%s: atu_start: enter\n", USBDEVNAME(sc->atu_dev))); 1799 1800 if ((ifp->if_flags & IFF_RUNNING) == 0) { 1801 return; 1802 } 1803 if (ifp->if_flags & IFF_OACTIVE) { 1804 DPRINTFN(30, ("%s: atu_start: IFF_OACTIVE\n", 1805 USBDEVNAME(sc->atu_dev))); 1806 return; 1807 } 1808 1809 for (;;) { 1810 /* grab a TX buffer */ 1811 s = splnet(); 1812 c = SLIST_FIRST(&cd->atu_tx_free); 1813 if (c != NULL) { 1814 SLIST_REMOVE_HEAD(&cd->atu_tx_free, atu_list); 1815 cd->atu_tx_inuse++; 1816 if (cd->atu_tx_inuse == ATU_TX_LIST_CNT) 1817 ifp->if_flags |= IFF_OACTIVE; 1818 } 1819 splx(s); 1820 if (c == NULL) { 1821 DPRINTFN(10, ("%s: out of tx xfers\n", 1822 USBDEVNAME(sc->atu_dev))); 1823 ifp->if_flags |= IFF_OACTIVE; 1824 break; 1825 } 1826 1827 /* 1828 * Poll the management queue for frames, it has priority over 1829 * normal data frames. 1830 */ 1831 IF_DEQUEUE(&ic->ic_mgtq, m); 1832 if (m == NULL) { 1833 DPRINTFN(10, ("%s: atu_start: data packet\n", 1834 USBDEVNAME(sc->atu_dev))); 1835 if (ic->ic_state != IEEE80211_S_RUN) { 1836 DPRINTFN(25, ("%s: no data till running\n", 1837 USBDEVNAME(sc->atu_dev))); 1838 /* put the xfer back on the list */ 1839 s = splnet(); 1840 SLIST_INSERT_HEAD(&cd->atu_tx_free, c, 1841 atu_list); 1842 cd->atu_tx_inuse--; 1843 splx(s); 1844 break; 1845 } 1846 1847 IFQ_DEQUEUE(&ifp->if_snd, m); 1848 if (m == NULL) { 1849 DPRINTFN(25, ("%s: nothing to send\n", 1850 USBDEVNAME(sc->atu_dev))); 1851 s = splnet(); 1852 SLIST_INSERT_HEAD(&cd->atu_tx_free, c, 1853 atu_list); 1854 cd->atu_tx_inuse--; 1855 splx(s); 1856 break; 1857 } 1858 #if NBPFILTER > 0 1859 if (ifp->if_bpf) 1860 bpf_mtap(ifp->if_bpf, m); 1861 #endif 1862 ni = ieee80211_find_txnode(ic, 1863 mtod(m, struct ether_header *)->ether_dhost); 1864 if (ni == NULL) { 1865 m_freem(m); 1866 goto bad; 1867 } 1868 m = ieee80211_encap(ic, m, ni); 1869 if (m == NULL) 1870 goto bad; 1871 } else { 1872 DPRINTFN(25, ("%s: atu_start: mgmt packet\n", 1873 USBDEVNAME(sc->atu_dev))); 1874 1875 /* 1876 * Hack! The referenced node pointer is in the 1877 * rcvif field of the packet header. This is 1878 * placed there by ieee80211_mgmt_output because 1879 * we need to hold the reference with the frame 1880 * and there's no other way (other than packet 1881 * tags which we consider too expensive to use) 1882 * to pass it along. 1883 */ 1884 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif; 1885 m->m_pkthdr.rcvif = NULL; 1886 1887 /* sc->sc_stats.ast_tx_mgmt++; */ 1888 } 1889 1890 #if NBPFILTER > 0 1891 if (ic->ic_rawbpf) 1892 bpf_mtap(ic->ic_rawbpf, m); 1893 #endif 1894 1895 if (atu_tx_start(sc, ni, c, m)) { 1896 bad: 1897 s = splnet(); 1898 SLIST_INSERT_HEAD(&cd->atu_tx_free, c, 1899 atu_list); 1900 cd->atu_tx_inuse--; 1901 splx(s); 1902 /* ifp_if_oerrors++; */ 1903 if (ni != NULL) 1904 ieee80211_free_node(ni); 1905 continue; 1906 } 1907 ifp->if_timer = 5; 1908 } 1909 } 1910 1911 int 1912 atu_init(struct ifnet *ifp) 1913 { 1914 struct atu_softc *sc = ifp->if_softc; 1915 struct ieee80211com *ic = &sc->sc_ic; 1916 struct atu_chain *c; 1917 usbd_status err; 1918 int i, s; 1919 1920 s = splnet(); 1921 1922 DPRINTFN(10, ("%s: atu_init\n", USBDEVNAME(sc->atu_dev))); 1923 1924 if (ifp->if_flags & IFF_RUNNING) { 1925 splx(s); 1926 return(0); 1927 } 1928 1929 /* Init TX ring */ 1930 if (atu_tx_list_init(sc)) 1931 printf("%s: tx list init failed\n", USBDEVNAME(sc->atu_dev)); 1932 1933 /* Init RX ring */ 1934 if (atu_rx_list_init(sc)) 1935 printf("%s: rx list init failed\n", USBDEVNAME(sc->atu_dev)); 1936 1937 /* Load the multicast filter. */ 1938 /*atu_setmulti(sc); */ 1939 1940 /* Open RX and TX pipes. */ 1941 err = usbd_open_pipe(sc->atu_iface, sc->atu_ed[ATU_ENDPT_RX], 1942 USBD_EXCLUSIVE_USE, &sc->atu_ep[ATU_ENDPT_RX]); 1943 if (err) { 1944 DPRINTF(("%s: open rx pipe failed: %s\n", 1945 USBDEVNAME(sc->atu_dev), usbd_errstr(err))); 1946 splx(s); 1947 return(EIO); 1948 } 1949 1950 err = usbd_open_pipe(sc->atu_iface, sc->atu_ed[ATU_ENDPT_TX], 1951 USBD_EXCLUSIVE_USE, &sc->atu_ep[ATU_ENDPT_TX]); 1952 if (err) { 1953 DPRINTF(("%s: open tx pipe failed: %s\n", 1954 USBDEVNAME(sc->atu_dev), usbd_errstr(err))); 1955 splx(s); 1956 return(EIO); 1957 } 1958 1959 /* Start up the receive pipe. */ 1960 for (i = 0; i < ATU_RX_LIST_CNT; i++) { 1961 c = &sc->atu_cdata.atu_rx_chain[i]; 1962 1963 usbd_setup_xfer(c->atu_xfer, sc->atu_ep[ATU_ENDPT_RX], c, 1964 c->atu_buf, ATU_RX_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY, 1965 USBD_NO_TIMEOUT, atu_rxeof); 1966 usbd_transfer(c->atu_xfer); 1967 } 1968 1969 DPRINTFN(10, ("%s: starting up using MAC=%s\n", 1970 USBDEVNAME(sc->atu_dev), ether_sprintf(ic->ic_myaddr))); 1971 1972 /* Do initial setup */ 1973 err = atu_initial_config(sc); 1974 if (err) { 1975 DPRINTF(("%s: initial config failed!\n", 1976 USBDEVNAME(sc->atu_dev))); 1977 splx(s); 1978 return(EIO); 1979 } 1980 DPRINTFN(10, ("%s: initialised transceiver\n", 1981 USBDEVNAME(sc->atu_dev))); 1982 1983 /* sc->atu_rxfilt = ATU_RXFILT_UNICAST|ATU_RXFILT_BROADCAST; */ 1984 1985 /* If we want promiscuous mode, set the allframes bit. */ 1986 /* 1987 if (ifp->if_flags & IFF_PROMISC) 1988 sc->atu_rxfilt |= ATU_RXFILT_PROMISC; 1989 */ 1990 1991 ifp->if_flags |= IFF_RUNNING; 1992 ifp->if_flags &= ~IFF_OACTIVE; 1993 splx(s); 1994 1995 /* XXX the following HAS to be replaced */ 1996 s = splnet(); 1997 err = ieee80211_new_state(ic, IEEE80211_S_SCAN, -1); 1998 if (err) { 1999 DPRINTFN(1, ("%s: atu_init: error calling " 2000 "ieee80211_net_state", USBDEVNAME(sc->atu_dev))); 2001 } 2002 splx(s); 2003 2004 return 0; 2005 } 2006 2007 #ifdef ATU_DEBUG 2008 void 2009 atu_debug_print(struct atu_softc *sc) 2010 { 2011 usbd_status err; 2012 u_int8_t tmp[32]; 2013 2014 /* DEBUG */ 2015 if ((err = atu_get_mib(sc, MIB_MAC_MGMT__CURRENT_BSSID, tmp))) 2016 return; 2017 DPRINTF(("%s: DEBUG: current BSSID=%s\n", USBDEVNAME(sc->atu_dev), 2018 ether_sprintf(tmp))); 2019 2020 if ((err = atu_get_mib(sc, MIB_MAC_MGMT__BEACON_PERIOD, tmp))) 2021 return; 2022 DPRINTF(("%s: DEBUG: beacon period=%d\n", USBDEVNAME(sc->atu_dev), 2023 tmp[0])); 2024 2025 if ((err = atu_get_mib(sc, MIB_MAC_WEP__PRIVACY_INVOKED, tmp))) 2026 return; 2027 DPRINTF(("%s: DEBUG: privacy invoked=%d\n", USBDEVNAME(sc->atu_dev), 2028 tmp[0])); 2029 2030 if ((err = atu_get_mib(sc, MIB_MAC_WEP__ENCR_LEVEL, tmp))) 2031 return; 2032 DPRINTF(("%s: DEBUG: encr_level=%d\n", USBDEVNAME(sc->atu_dev), 2033 tmp[0])); 2034 2035 if ((err = atu_get_mib(sc, MIB_MAC_WEP__ICV_ERROR_COUNT, tmp))) 2036 return; 2037 DPRINTF(("%s: DEBUG: icv error count=%d\n", USBDEVNAME(sc->atu_dev), 2038 *(short *)tmp)); 2039 2040 if ((err = atu_get_mib(sc, MIB_MAC_WEP__EXCLUDED_COUNT, tmp))) 2041 return; 2042 DPRINTF(("%s: DEBUG: wep excluded count=%d\n", 2043 USBDEVNAME(sc->atu_dev), *(short *)tmp)); 2044 2045 if ((err = atu_get_mib(sc, MIB_MAC_MGMT__POWER_MODE, tmp))) 2046 return; 2047 DPRINTF(("%s: DEBUG: power mode=%d\n", USBDEVNAME(sc->atu_dev), 2048 tmp[0])); 2049 2050 if ((err = atu_get_mib(sc, MIB_PHY__CHANNEL, tmp))) 2051 return; 2052 DPRINTF(("%s: DEBUG: channel=%d\n", USBDEVNAME(sc->atu_dev), tmp[0])); 2053 2054 if ((err = atu_get_mib(sc, MIB_PHY__REG_DOMAIN, tmp))) 2055 return; 2056 DPRINTF(("%s: DEBUG: reg domain=%d\n", USBDEVNAME(sc->atu_dev), 2057 tmp[0])); 2058 2059 if ((err = atu_get_mib(sc, MIB_LOCAL__SSID_SIZE, tmp))) 2060 return; 2061 DPRINTF(("%s: DEBUG: ssid size=%d\n", USBDEVNAME(sc->atu_dev), 2062 tmp[0])); 2063 2064 if ((err = atu_get_mib(sc, MIB_LOCAL__BEACON_ENABLE, tmp))) 2065 return; 2066 DPRINTF(("%s: DEBUG: beacon enable=%d\n", USBDEVNAME(sc->atu_dev), 2067 tmp[0])); 2068 2069 if ((err = atu_get_mib(sc, MIB_LOCAL__AUTO_RATE_FALLBACK, tmp))) 2070 return; 2071 DPRINTF(("%s: DEBUG: auto rate fallback=%d\n", 2072 USBDEVNAME(sc->atu_dev), tmp[0])); 2073 2074 if ((err = atu_get_mib(sc, MIB_MAC_ADDR__ADDR, tmp))) 2075 return; 2076 DPRINTF(("%s: DEBUG: mac addr=%s\n", USBDEVNAME(sc->atu_dev), 2077 ether_sprintf(tmp))); 2078 2079 if ((err = atu_get_mib(sc, MIB_MAC__DESIRED_SSID, tmp))) 2080 return; 2081 DPRINTF(("%s: DEBUG: desired ssid=%s\n", USBDEVNAME(sc->atu_dev), 2082 tmp)); 2083 2084 if ((err = atu_get_mib(sc, MIB_MAC_MGMT__CURRENT_ESSID, tmp))) 2085 return; 2086 DPRINTF(("%s: DEBUG: current ESSID=%s\n", USBDEVNAME(sc->atu_dev), 2087 tmp)); 2088 } 2089 #endif /* ATU_DEBUG */ 2090 2091 int 2092 atu_ioctl(struct ifnet *ifp, u_long command, caddr_t data) 2093 { 2094 struct atu_softc *sc = ifp->if_softc; 2095 struct ifreq *ifr = (struct ifreq *)data; 2096 struct ieee80211com *ic = &sc->sc_ic; 2097 int err = 0, s; 2098 2099 s = splnet(); 2100 switch (command) { 2101 case SIOCSIFMEDIA: 2102 case SIOCGIFMEDIA: 2103 err = ifmedia_ioctl(ifp, ifr, &ic->ic_media, command); 2104 break; 2105 2106 default: 2107 DPRINTFN(15, ("%s: ieee80211_ioctl (%lu)\n", 2108 USBDEVNAME(sc->atu_dev), command)); 2109 err = ieee80211_ioctl(ic, command, data); 2110 break; 2111 } 2112 2113 if (err == ENETRESET) { 2114 if ((ifp->if_flags & (IFF_RUNNING|IFF_UP)) == 2115 (IFF_RUNNING|IFF_UP)) { 2116 DPRINTF(("%s: atu_ioctl(): netreset %lu\n", 2117 USBDEVNAME(sc->atu_dev), command)); 2118 ieee80211_new_state(ic, IEEE80211_S_INIT, -1); 2119 atu_initial_config(sc); 2120 ieee80211_new_state(ic, IEEE80211_S_SCAN, -1); 2121 } 2122 err = 0; 2123 } 2124 2125 splx(s); 2126 return (err); 2127 } 2128 2129 void 2130 atu_watchdog(struct ifnet *ifp) 2131 { 2132 struct atu_softc *sc = ifp->if_softc; 2133 struct atu_chain *c; 2134 usbd_status stat; 2135 int cnt, s; 2136 2137 DPRINTF(("%s: atu_watchdog\n", USBDEVNAME(sc->atu_dev))); 2138 2139 ifp->if_timer = 0; 2140 2141 if (sc->sc_state != ATU_S_OK || (ifp->if_flags & IFF_RUNNING) == 0) 2142 return; 2143 2144 sc = ifp->if_softc; 2145 s = splnet(); 2146 ifp->if_oerrors++; 2147 DPRINTF(("%s: watchdog timeout\n", USBDEVNAME(sc->atu_dev))); 2148 2149 /* 2150 * TODO: 2151 * we should change this since we have multiple TX tranfers... 2152 */ 2153 for (cnt = 0; cnt < ATU_TX_LIST_CNT; cnt++) { 2154 c = &sc->atu_cdata.atu_tx_chain[cnt]; 2155 if (c->atu_in_xfer) { 2156 usbd_get_xfer_status(c->atu_xfer, NULL, NULL, NULL, 2157 &stat); 2158 atu_txeof(c->atu_xfer, c, stat); 2159 } 2160 } 2161 2162 if (!IFQ_IS_EMPTY(&ifp->if_snd)) 2163 atu_start(ifp); 2164 splx(s); 2165 2166 ieee80211_watchdog(&sc->sc_ic); 2167 } 2168 2169 /* 2170 * Stop the adapter and free any mbufs allocated to the 2171 * RX and TX lists. 2172 */ 2173 void 2174 atu_stop(struct ifnet *ifp, int disable) 2175 { 2176 struct atu_softc *sc = ifp->if_softc; 2177 struct ieee80211com *ic = &sc->sc_ic; 2178 struct atu_cdata *cd; 2179 usbd_status err; 2180 int s; 2181 2182 s = splnet(); 2183 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 2184 ifp->if_timer = 0; 2185 2186 usb_rem_task(sc->atu_udev, &sc->sc_task); 2187 ieee80211_new_state(ic, IEEE80211_S_INIT, -1); 2188 2189 /* Stop transfers. */ 2190 if (sc->atu_ep[ATU_ENDPT_RX] != NULL) { 2191 err = usbd_abort_pipe(sc->atu_ep[ATU_ENDPT_RX]); 2192 if (err) { 2193 DPRINTF(("%s: abort rx pipe failed: %s\n", 2194 USBDEVNAME(sc->atu_dev), usbd_errstr(err))); 2195 } 2196 err = usbd_close_pipe(sc->atu_ep[ATU_ENDPT_RX]); 2197 if (err) { 2198 DPRINTF(("%s: close rx pipe failed: %s\n", 2199 USBDEVNAME(sc->atu_dev), usbd_errstr(err))); 2200 } 2201 sc->atu_ep[ATU_ENDPT_RX] = NULL; 2202 } 2203 2204 if (sc->atu_ep[ATU_ENDPT_TX] != NULL) { 2205 err = usbd_abort_pipe(sc->atu_ep[ATU_ENDPT_TX]); 2206 if (err) { 2207 DPRINTF(("%s: abort tx pipe failed: %s\n", 2208 USBDEVNAME(sc->atu_dev), usbd_errstr(err))); 2209 } 2210 err = usbd_close_pipe(sc->atu_ep[ATU_ENDPT_TX]); 2211 if (err) { 2212 DPRINTF(("%s: close tx pipe failed: %s\n", 2213 USBDEVNAME(sc->atu_dev), usbd_errstr(err))); 2214 } 2215 sc->atu_ep[ATU_ENDPT_TX] = NULL; 2216 } 2217 2218 /* Free RX/TX/MGMT list resources. */ 2219 cd = &sc->atu_cdata; 2220 atu_xfer_list_free(sc, cd->atu_rx_chain, ATU_RX_LIST_CNT); 2221 atu_xfer_list_free(sc, cd->atu_tx_chain, ATU_TX_LIST_CNT); 2222 2223 /* Let's be nice and turn off the radio before we leave */ 2224 atu_switch_radio(sc, 0); 2225 2226 splx(s); 2227 } 2228
Indexes created Fri Oct 17 03:10:13 GMT 2025