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