?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
No empty .Rs/.Re
[netbsd-mini2440.git] / sys / dev / usb / if_atu.c
blob4de2186026977d745123b1877a1cf38e49b6d70d
1 /* $NetBSD: if_atu.c,v 1.33 2009/09/23 19:07:19 plunky 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@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.33 2009/09/23 19:07:19 plunky 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 <sys/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, void *);
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(device_t);
204 void atu_external_firmware(device_t);
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 int atu_match(device_t, cfdata_t, void *);
225 void atu_attach(device_t, device_t, void *);
226 int atu_detach(device_t, int);
227 int atu_activate(device_t, enum devact);
228 extern struct cfdriver atu_cd;
229 CFATTACH_DECL_NEW(atu, sizeof(struct atu_softc), atu_match, atu_attach,
230 atu_detach, atu_activate);
231
232 usbd_status
233 atu_usb_request(struct atu_softc *sc, u_int8_t type,
234 u_int8_t request, u_int16_t value, u_int16_t index, u_int16_t length,
235 u_int8_t *data)
236 {
237 usb_device_request_t req;
238 usbd_xfer_handle xfer;
239 usbd_status err;
240 int total_len = 0, s;
241
242 req.bmRequestType = type;
243 req.bRequest = request;
244 USETW(req.wValue, value);
245 USETW(req.wIndex, index);
246 USETW(req.wLength, length);
247
248 #ifdef ATU_DEBUG
249 if (atudebug) {
250 DPRINTFN(20, ("%s: req=%02x val=%02x ind=%02x "
251 "len=%02x\n", USBDEVNAME(sc->atu_dev), request,
252 value, index, length));
253 }
254 #endif /* ATU_DEBUG */
255
256 s = splnet();
257
258 xfer = usbd_alloc_xfer(sc->atu_udev);
259 usbd_setup_default_xfer(xfer, sc->atu_udev, 0, 500000, &req, data,
260 length, USBD_SHORT_XFER_OK, 0);
261
262 err = usbd_sync_transfer(xfer);
263
264 usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
265
266 #ifdef ATU_DEBUG
267 if (atudebug) {
268 if (type & UT_READ) {
269 DPRINTFN(20, ("%s: transfered 0x%x bytes in\n",
270 USBDEVNAME(sc->atu_dev), total_len));
271 } else {
272 if (total_len != length)
273 DPRINTF(("%s: wrote only %x bytes\n",
274 USBDEVNAME(sc->atu_dev), total_len));
275 }
276 }
277 #endif /* ATU_DEBUG */
278
279 usbd_free_xfer(xfer);
280
281 splx(s);
282 return(err);
283 }
284
285 int
286 atu_send_command(struct atu_softc *sc, u_int8_t *command, int size)
287 {
288 return atu_usb_request(sc, UT_WRITE_VENDOR_DEVICE, 0x0e, 0x0000,
289 0x0000, size, command);
290 }
291
292 int
293 atu_get_cmd_status(struct atu_softc *sc, u_int8_t cmd, u_int8_t *status)
294 {
295 /*
296 * all other drivers (including Windoze) request 40 bytes of status
297 * and get a short-xfer of just 6 bytes. we can save 34 bytes of
298 * buffer if we just request those 6 bytes in the first place :)
299 */
300 /*
301 return atu_usb_request(sc, UT_READ_VENDOR_INTERFACE, 0x22, cmd,
302 0x0000, 40, status);
303 */
304 return atu_usb_request(sc, UT_READ_VENDOR_INTERFACE, 0x22, cmd,
305 0x0000, 6, status);
306 }
307
308 int
309 atu_wait_completion(struct atu_softc *sc, u_int8_t cmd, u_int8_t *status)
310 {
311 int idle_count = 0, err;
312 u_int8_t statusreq[6];
313
314 DPRINTFN(15, ("%s: wait-completion: cmd=%02x\n",
315 USBDEVNAME(sc->atu_dev), cmd));
316
317 while (1) {
318 err = atu_get_cmd_status(sc, cmd, statusreq);
319 if (err)
320 return err;
321
322 #ifdef ATU_DEBUG
323 if (atudebug) {
324 DPRINTFN(20, ("%s: status=%s cmd=%02x\n",
325 USBDEVNAME(sc->atu_dev),
326 ether_sprintf(statusreq), cmd));
327 }
328 #endif /* ATU_DEBUG */
329
330 /*
331 * during normal operations waiting on STATUS_IDLE
332 * will never happen more than once
333 */
334 if ((statusreq[5] == STATUS_IDLE) && (idle_count++ > 20)) {
335 DPRINTF(("%s: idle_count > 20!\n",
336 USBDEVNAME(sc->atu_dev)));
337 return 0;
338 }
339
340 if ((statusreq[5] != STATUS_IN_PROGRESS) &&
341 (statusreq[5] != STATUS_IDLE)) {
342 if (status != NULL)
343 *status = statusreq[5];
344 return 0;
345 }
346 usbd_delay_ms(sc->atu_udev, 25);
347 }
348 }
349
350 int
351 atu_send_mib(struct atu_softc *sc, u_int8_t type, u_int8_t size,
352 u_int8_t index, void *data)
353 {
354 int err;
355 struct atu_cmd_set_mib request;
356
357 /*
358 * We don't construct a MIB packet first and then memcpy it into an
359 * Atmel-command-packet, we just construct it the right way at once :)
360 */
361
362 memset(&request, 0, sizeof(request));
363
364 request.AtCmd = CMD_SET_MIB;
365 USETW(request.AtSize, size + 4);
366
367 request.MIBType = type;
368 request.MIBSize = size;
369 request.MIBIndex = index;
370 request.MIBReserved = 0;
371
372 /*
373 * For 1 and 2 byte requests we assume a direct value,
374 * everything bigger than 2 bytes we assume a pointer to the data
375 */
376 switch (size) {
377 case 0:
378 break;
379 case 1:
380 request.data[0]=(long)data & 0x000000ff;
381 break;
382 case 2:
383 request.data[0]=(long)data & 0x000000ff;
384 request.data[1]=(long)data >> 8;
385 break;
386 default:
387 memcpy(request.data, data, size);
388 break;
389 }
390
391 err = atu_usb_request(sc, UT_WRITE_VENDOR_DEVICE, 0x0e, 0x0000,
392 0x0000, size+8, (uByte *)&request);
393 if (err)
394 return (err);
395
396 DPRINTFN(15, ("%s: sendmib : waitcompletion...\n",
397 USBDEVNAME(sc->atu_dev)));
398 return atu_wait_completion(sc, CMD_SET_MIB, NULL);
399 }
400
401 int
402 atu_get_mib(struct atu_softc *sc, u_int8_t type, u_int8_t size,
403 u_int8_t index, u_int8_t *buf)
404 {
405
406 /* linux/at76c503.c - 478 */
407 return atu_usb_request(sc, UT_READ_VENDOR_INTERFACE, 0x033,
408 type << 8, index, size, buf);
409 }
410
411 #if 0
412 int
413 atu_start_ibss(struct atu_softc *sc)
414 {
415 struct ieee80211com *ic = &sc->sc_ic;
416 int err;
417 struct atu_cmd_start_ibss Request;
418
419 Request.Cmd = CMD_START_IBSS;
420 Request.Reserved = 0;
421 Request.Size = sizeof(Request) - 4;
422
423 memset(Request.BSSID, 0x00, sizeof(Request.BSSID));
424 memset(Request.SSID, 0x00, sizeof(Request.SSID));
425 memcpy(Request.SSID, ic->ic_des_ssid, ic->ic_des_ssidlen);
426 Request.SSIDSize = ic->ic_des_ssidlen;
427 if (sc->atu_desired_channel != IEEE80211_CHAN_ANY)
428 Request.Channel = (u_int8_t)sc->atu_desired_channel;
429 else
430 Request.Channel = ATU_DEFAULT_CHANNEL;
431 Request.BSSType = AD_HOC_MODE;
432 memset(Request.Res, 0x00, sizeof(Request.Res));
433
434 /* Write config to adapter */
435 err = atu_send_command(sc, (u_int8_t *)&Request, sizeof(Request));
436 if (err) {
437 DPRINTF(("%s: start ibss failed!\n",
438 USBDEVNAME(sc->atu_dev)));
439 return err;
440 }
441
442 /* Wait for the adapter to do it's thing */
443 err = atu_wait_completion(sc, CMD_START_IBSS, NULL);
444 if (err) {
445 DPRINTF(("%s: error waiting for start_ibss\n",
446 USBDEVNAME(sc->atu_dev)));
447 return err;
448 }
449
450 /* Get the current BSSID */
451 err = atu_get_mib(sc, MIB_MAC_MGMT__CURRENT_BSSID, sc->atu_bssid);
452 if (err) {
453 DPRINTF(("%s: could not get BSSID!\n",
454 USBDEVNAME(sc->atu_dev)));
455 return err;
456 }
457
458 DPRINTF(("%s: started a new IBSS (BSSID=%s)\n",
459 USBDEVNAME(sc->atu_dev), ether_sprintf(sc->atu_bssid)));
460 return 0;
461 }
462 #endif
463
464 int
465 atu_start_scan(struct atu_softc *sc)
466 {
467 struct ieee80211com *ic = &sc->sc_ic;
468 struct atu_cmd_do_scan Scan;
469 usbd_status err;
470 int Cnt;
471
472 memset(&Scan, 0, sizeof(Scan));
473
474 Scan.Cmd = CMD_START_SCAN;
475 Scan.Reserved = 0;
476 USETW(Scan.Size, sizeof(Scan) - 4);
477
478 /* use the broadcast BSSID (in active scan) */
479 for (Cnt=0; Cnt<6; Cnt++)
480 Scan.BSSID[Cnt] = 0xff;
481
482 memset(Scan.SSID, 0x00, sizeof(Scan.SSID));
483 memcpy(Scan.SSID, ic->ic_des_essid, ic->ic_des_esslen);
484 Scan.SSID_Len = ic->ic_des_esslen;
485
486 /* default values for scan */
487 Scan.ScanType = ATU_SCAN_ACTIVE;
488 if (sc->atu_desired_channel != IEEE80211_CHAN_ANY)
489 Scan.Channel = (u_int8_t)sc->atu_desired_channel;
490 else
491 Scan.Channel = sc->atu_channel;
492
493 ic->ic_curchan = &ic->ic_channels[Scan.Channel];
494
495 /* we like scans to be quick :) */
496 /* the time we wait before sending probe's */
497 USETW(Scan.ProbeDelay, 0);
498 /* the time we stay on one channel */
499 USETW(Scan.MinChannelTime, 100);
500 USETW(Scan.MaxChannelTime, 200);
501 /* wether or not we scan all channels */
502 Scan.InternationalScan = 0xc1;
503
504 #ifdef ATU_DEBUG
505 if (atudebug) {
506 DPRINTFN(20, ("%s: scan cmd len=%02zx\n",
507 USBDEVNAME(sc->atu_dev), sizeof(Scan)));
508 }
509 #endif /* ATU_DEBUG */
510
511 /* Write config to adapter */
512 err = atu_send_command(sc, (u_int8_t *)&Scan, sizeof(Scan));
513 if (err)
514 return err;
515
516 /*
517 * We don't wait for the command to finish... the mgmt-thread will do
518 * that for us
519 */
520 /*
521 err = atu_wait_completion(sc, CMD_START_SCAN, NULL);
522 if (err)
523 return err;
524 */
525 return 0;
526 }
527
528 int
529 atu_switch_radio(struct atu_softc *sc, int state)
530 {
531 usbd_status err;
532 struct atu_cmd CmdRadio;
533
534 if (sc->atu_radio == RadioIntersil) {
535 /*
536 * Intersil doesn't seem to need/support switching the radio
537 * on/off
538 */
539 return 0;
540 }
541
542 memset(&CmdRadio, 0, sizeof(CmdRadio));
543 CmdRadio.Cmd = CMD_RADIO_ON;
544
545 if (sc->atu_radio_on != state) {
546 if (state == 0)
547 CmdRadio.Cmd = CMD_RADIO_OFF;
548
549 err = atu_send_command(sc, (u_int8_t *)&CmdRadio,
550 sizeof(CmdRadio));
551 if (err)
552 return err;
553
554 err = atu_wait_completion(sc, CmdRadio.Cmd, NULL);
555 if (err)
556 return err;
557
558 DPRINTFN(10, ("%s: radio turned %s\n",
559 USBDEVNAME(sc->atu_dev), state ? "on" : "off"));
560 sc->atu_radio_on = state;
561 }
562 return 0;
563 }
564
565 int
566 atu_initial_config(struct atu_softc *sc)
567 {
568 struct ieee80211com *ic = &sc->sc_ic;
569 u_int32_t i;
570 usbd_status err;
571 /* u_int8_t rates[4] = {0x82, 0x84, 0x8B, 0x96};*/
572 u_int8_t rates[4] = {0x82, 0x04, 0x0B, 0x16};
573 struct atu_cmd_card_config cmd;
574 u_int8_t reg_domain;
575
576 DPRINTFN(10, ("%s: sending mac-addr\n", USBDEVNAME(sc->atu_dev)));
577 err = atu_send_mib(sc, MIB_MAC_ADDR__ADDR, ic->ic_myaddr);
578 if (err) {
579 DPRINTF(("%s: error setting mac-addr\n",
580 USBDEVNAME(sc->atu_dev)));
581 return err;
582 }
583
584 /*
585 DPRINTF(("%s: sending reg-domain\n", USBDEVNAME(sc->atu_dev)));
586 err = atu_send_mib(sc, MIB_PHY__REG_DOMAIN, NR(0x30));
587 if (err) {
588 DPRINTF(("%s: error setting mac-addr\n",
589 USBDEVNAME(sc->atu_dev)));
590 return err;
591 }
592 */
593
594 memset(&cmd, 0, sizeof(cmd));
595 cmd.Cmd = CMD_STARTUP;
596 cmd.Reserved = 0;
597 USETW(cmd.Size, sizeof(cmd) - 4);
598
599 if (sc->atu_desired_channel != IEEE80211_CHAN_ANY)
600 cmd.Channel = (u_int8_t)sc->atu_desired_channel;
601 else
602 cmd.Channel = sc->atu_channel;
603 cmd.AutoRateFallback = 1;
604 memcpy(cmd.BasicRateSet, rates, 4);
605
606 /* ShortRetryLimit should be 7 according to 802.11 spec */
607 cmd.ShortRetryLimit = 7;
608 USETW(cmd.RTS_Threshold, 2347);
609 USETW(cmd.FragThreshold, 2346);
610
611 /* Doesn't seem to work, but we'll set it to 1 anyway */
612 cmd.PromiscuousMode = 1;
613
614 /* this goes into the beacon we transmit */
615 if (ic->ic_flags & IEEE80211_F_PRIVACY)
616 cmd.PrivacyInvoked = 1;
617 else
618 cmd.PrivacyInvoked = 0;
619
620 cmd.ExcludeUnencrypted = 0;
621
622 if (ic->ic_flags & IEEE80211_F_PRIVACY) {
623 switch (ic->ic_nw_keys[ic->ic_def_txkey].wk_keylen) {
624 case 5:
625 cmd.EncryptionType = ATU_WEP_40BITS;
626 break;
627 case 13:
628 cmd.EncryptionType = ATU_WEP_104BITS;
629 break;
630 default:
631 cmd.EncryptionType = ATU_WEP_OFF;
632 break;
633 }
634
635
636 cmd.WEP_DefaultKeyID = ic->ic_def_txkey;
637 for (i = 0; i < IEEE80211_WEP_NKID; i++) {
638 memcpy(cmd.WEP_DefaultKey[i], ic->ic_nw_keys[i].wk_key,
639 ic->ic_nw_keys[i].wk_keylen);
640 }
641 }
642
643 /* Setting the SSID here doesn't seem to do anything */
644 memset(cmd.SSID, 0x00, sizeof(cmd.SSID));
645 memcpy(cmd.SSID, ic->ic_des_essid, ic->ic_des_esslen);
646 cmd.SSID_Len = ic->ic_des_esslen;
647
648 cmd.ShortPreamble = 0;
649 USETW(cmd.BeaconPeriod, 100);
650 /* cmd.BeaconPeriod = 65535; */
651
652 /*
653 * TODO:
654 * read reg domain MIB_PHY @ 0x17 (1 byte), (reply = 0x30)
655 * we should do something usefull with this info. right now it's just
656 * ignored
657 */
658 err = atu_get_mib(sc, MIB_PHY__REG_DOMAIN, &reg_domain);
659 if (err) {
660 DPRINTF(("%s: could not get regdomain!\n",
661 USBDEVNAME(sc->atu_dev)));
662 } else {
663 DPRINTF(("%s: in reg domain 0x%x according to the "
664 "adapter\n", USBDEVNAME(sc->atu_dev), reg_domain));
665 }
666
667 #ifdef ATU_DEBUG
668 if (atudebug) {
669 DPRINTFN(20, ("%s: configlen=%02zx\n", USBDEVNAME(sc->atu_dev),
670 sizeof(cmd)));
671 }
672 #endif /* ATU_DEBUG */
673
674 /* Windoze : driver says exclude-unencrypted=1 & encr-type=1 */
675
676 err = atu_send_command(sc, (u_int8_t *)&cmd, sizeof(cmd));
677 if (err)
678 return err;
679 err = atu_wait_completion(sc, CMD_STARTUP, NULL);
680 if (err)
681 return err;
682
683 /* Turn on radio now */
684 err = atu_switch_radio(sc, 1);
685 if (err)
686 return err;
687
688 /* preamble type = short */
689 err = atu_send_mib(sc, MIB_LOCAL__PREAMBLE, NR(PREAMBLE_SHORT));
690 if (err)
691 return err;
692
693 /* frag = 1536 */
694 err = atu_send_mib(sc, MIB_MAC__FRAG, NR(2346));
695 if (err)
696 return err;
697
698 /* rts = 1536 */
699 err = atu_send_mib(sc, MIB_MAC__RTS, NR(2347));
700 if (err)
701 return err;
702
703 /* auto rate fallback = 1 */
704 err = atu_send_mib(sc, MIB_LOCAL__AUTO_RATE_FALLBACK, NR(1));
705 if (err)
706 return err;
707
708 /* power mode = full on, no power saving */
709 err = atu_send_mib(sc, MIB_MAC_MGMT__POWER_MODE,
710 NR(POWER_MODE_ACTIVE));
711 if (err)
712 return err;
713
714 DPRINTFN(10, ("%s: completed initial config\n",
715 USBDEVNAME(sc->atu_dev)));
716 return 0;
717 }
718
719 int
720 atu_join(struct atu_softc *sc, struct ieee80211_node *node)
721 {
722 struct atu_cmd_join join;
723 u_int8_t status = 0; /* XXX: GCC */
724 usbd_status err;
725
726 memset(&join, 0, sizeof(join));
727
728 join.Cmd = CMD_JOIN;
729 join.Reserved = 0x00;
730 USETW(join.Size, sizeof(join) - 4);
731
732 DPRINTFN(15, ("%s: pre-join sc->atu_bssid=%s\n",
733 USBDEVNAME(sc->atu_dev), ether_sprintf(sc->atu_bssid)));
734 DPRINTFN(15, ("%s: mode=%d\n", USBDEVNAME(sc->atu_dev),
735 sc->atu_mode));
736 memcpy(join.bssid, node->ni_bssid, IEEE80211_ADDR_LEN);
737 memset(join.essid, 0x00, 32);
738 memcpy(join.essid, node->ni_essid, node->ni_esslen);
739 join.essid_size = node->ni_esslen;
740 if (node->ni_capinfo & IEEE80211_CAPINFO_IBSS)
741 join.bss_type = AD_HOC_MODE;
742 else
743 join.bss_type = INFRASTRUCTURE_MODE;
744 join.channel = ieee80211_chan2ieee(&sc->sc_ic, node->ni_chan);
745
746 USETW(join.timeout, ATU_JOIN_TIMEOUT);
747 join.reserved = 0x00;
748
749 DPRINTFN(10, ("%s: trying to join BSSID=%s\n",
750 USBDEVNAME(sc->atu_dev), ether_sprintf(join.bssid)));
751 err = atu_send_command(sc, (u_int8_t *)&join, sizeof(join));
752 if (err) {
753 DPRINTF(("%s: ERROR trying to join IBSS\n",
754 USBDEVNAME(sc->atu_dev)));
755 return err;
756 }
757 err = atu_wait_completion(sc, CMD_JOIN, &status);
758 if (err) {
759 DPRINTF(("%s: error joining BSS!\n",
760 USBDEVNAME(sc->atu_dev)));
761 return err;
762 }
763 if (status != STATUS_COMPLETE) {
764 DPRINTF(("%s: error joining... [status=%02x]\n",
765 USBDEVNAME(sc->atu_dev), status));
766 return status;
767 } else {
768 DPRINTFN(10, ("%s: joined BSS\n", USBDEVNAME(sc->atu_dev)));
769 }
770 return err;
771 }
772
773 /*
774 * Get the state of the DFU unit
775 */
776 int8_t
777 atu_get_dfu_state(struct atu_softc *sc)
778 {
779 u_int8_t state;
780
781 if (atu_usb_request(sc, DFU_GETSTATE, 0, 0, 1, &state))
782 return -1;
783 return state;
784 }
785
786 /*
787 * Get MAC opmode
788 */
789 u_int8_t
790 atu_get_opmode(struct atu_softc *sc, u_int8_t *mode)
791 {
792
793 return atu_usb_request(sc, UT_READ_VENDOR_INTERFACE, 0x33, 0x0001,
794 0x0000, 1, mode);
795 }
796
797 /*
798 * Upload the internal firmware into the device
799 */
800 void
801 atu_internal_firmware(device_t arg)
802 {
803 struct atu_softc *sc = device_private(arg);
804 u_char state, *ptr = NULL, *firm = NULL, status[6];
805 int block_size, block = 0, err, i;
806 size_t bytes_left = 0;
807
808 /*
809 * Uploading firmware is done with the DFU (Device Firmware Upgrade)
810 * interface. See "Universal Serial Bus - Device Class Specification
811 * for Device Firmware Upgrade" pdf for details of the protocol.
812 * Maybe this could be moved to a separate 'firmware driver' once more
813 * device drivers need it... For now we'll just do it here.
814 *
815 * Just for your information, the Atmel's DFU descriptor looks like
816 * this:
817 *
818 * 07 size
819 * 21 type
820 * 01 capabilities : only firmware download, need reset
821 * after download
822 * 13 05 detach timeout : max 1299ms between DFU_DETACH and
823 * reset
824 * 00 04 max bytes of firmware per transaction : 1024
825 */
826
827 /* Choose the right firmware for the device */
828 for (i = 0; i < __arraycount(atu_radfirm); i++)
829 if (sc->atu_radio == atu_radfirm[i].atur_type) {
830 firm = atu_radfirm[i].atur_internal;
831 bytes_left = atu_radfirm[i].atur_internal_sz;
832 }
833
834 if (firm == NULL) {
835 aprint_error_dev(arg, "no firmware found\n");
836 return;
837 }
838
839 ptr = firm;
840 state = atu_get_dfu_state(sc);
841
842 while (block >= 0 && state > 0) {
843 switch (state) {
844 case DFUState_DnLoadSync:
845 /* get DFU status */
846 err = atu_usb_request(sc, DFU_GETSTATUS, 0, 0 , 6,
847 status);
848 if (err) {
849 DPRINTF(("%s: dfu_getstatus failed!\n",
850 USBDEVNAME(sc->atu_dev)));
851 return;
852 }
853 /* success means state => DnLoadIdle */
854 state = DFUState_DnLoadIdle;
855 continue;
856 break;
857
858 case DFUState_DFUIdle:
859 case DFUState_DnLoadIdle:
860 if (bytes_left>=DFU_MaxBlockSize)
861 block_size = DFU_MaxBlockSize;
862 else
863 block_size = bytes_left;
864 DPRINTFN(15, ("%s: firmware block %d\n",
865 USBDEVNAME(sc->atu_dev), block));
866
867 err = atu_usb_request(sc, DFU_DNLOAD, block++, 0,
868 block_size, ptr);
869 if (err) {
870 DPRINTF(("%s: dfu_dnload failed\n",
871 USBDEVNAME(sc->atu_dev)));
872 return;
873 }
874
875 ptr += block_size;
876 bytes_left -= block_size;
877 if (block_size == 0)
878 block = -1;
879 break;
880
881 default:
882 usbd_delay_ms(sc->atu_udev, 100);
883 DPRINTFN(20, ("%s: sleeping for a while\n",
884 USBDEVNAME(sc->atu_dev)));
885 break;
886 }
887
888 state = atu_get_dfu_state(sc);
889 }
890
891 if (state != DFUState_ManifestSync) {
892 DPRINTF(("%s: state != manifestsync... eek!\n",
893 USBDEVNAME(sc->atu_dev)));
894 }
895
896 err = atu_usb_request(sc, DFU_GETSTATUS, 0, 0, 6, status);
897 if (err) {
898 DPRINTF(("%s: dfu_getstatus failed!\n",
899 USBDEVNAME(sc->atu_dev)));
900 return;
901 }
902
903 DPRINTFN(15, ("%s: sending remap\n", USBDEVNAME(sc->atu_dev)));
904 err = atu_usb_request(sc, DFU_REMAP, 0, 0, 0, NULL);
905 if ((err) && (! sc->atu_quirk & ATU_QUIRK_NO_REMAP)) {
906 DPRINTF(("%s: remap failed!\n", USBDEVNAME(sc->atu_dev)));
907 return;
908 }
909
910 /* after a lot of trying and measuring I found out the device needs
911 * about 56 miliseconds after sending the remap command before
912 * it's ready to communicate again. So we'll wait just a little bit
913 * longer than that to be sure...
914 */
915 usbd_delay_ms(sc->atu_udev, 56+100);
916
917 aprint_error_dev(arg, "reattaching after firmware upload\n");
918 usb_needs_reattach(sc->atu_udev);
919 }
920
921 void
922 atu_external_firmware(device_t arg)
923 {
924 struct atu_softc *sc = device_private(arg);
925 u_char *ptr = NULL, *firm = NULL;
926 int block_size, block = 0, err, i;
927 size_t bytes_left = 0;
928
929 for (i = 0; i < __arraycount(atu_radfirm); i++)
930 if (sc->atu_radio == atu_radfirm[i].atur_type) {
931 firm = atu_radfirm[i].atur_external;
932 bytes_left = atu_radfirm[i].atur_external_sz;
933 }
934
935 if (firm == NULL) {
936 aprint_error_dev(arg, "no firmware found\n");
937 return;
938 }
939 ptr = firm;
940
941 while (bytes_left) {
942 if (bytes_left > 1024)
943 block_size = 1024;
944 else
945 block_size = bytes_left;
946
947 DPRINTFN(15, ("%s: block:%d size:%d\n",
948 USBDEVNAME(sc->atu_dev), block, block_size));
949 err = atu_usb_request(sc, UT_WRITE_VENDOR_DEVICE, 0x0e,
950 0x0802, block, block_size, ptr);
951 if (err) {
952 DPRINTF(("%s: could not load external firmware "
953 "block\n", USBDEVNAME(sc->atu_dev)));
954 return;
955 }
956
957 ptr += block_size;
958 block++;
959 bytes_left -= block_size;
960 }
961
962 err = atu_usb_request(sc, UT_WRITE_VENDOR_DEVICE, 0x0e, 0x0802,
963 block, 0, NULL);
964 if (err) {
965 DPRINTF(("%s: could not load last zero-length firmware "
966 "block\n", USBDEVNAME(sc->atu_dev)));
967 return;
968 }
969
970 /*
971 * The SMC2662w V.4 seems to require some time to do it's thing with
972 * the external firmware... 20 ms isn't enough, but 21 ms works 100
973 * times out of 100 tries. We'll wait a bit longer just to be sure
974 */
975 if (sc->atu_quirk & ATU_QUIRK_FW_DELAY)
976 usbd_delay_ms(sc->atu_udev, 21 + 100);
977
978 DPRINTFN(10, ("%s: external firmware upload done\n",
979 USBDEVNAME(sc->atu_dev)));
980 /* complete configuration after the firmwares have been uploaded */
981 atu_complete_attach(sc);
982 }
983
984 int
985 atu_get_card_config(struct atu_softc *sc)
986 {
987 struct ieee80211com *ic = &sc->sc_ic;
988 struct atu_rfmd_conf rfmd_conf;
989 struct atu_intersil_conf intersil_conf;
990 int err;
991
992 switch (sc->atu_radio) {
993
994 case RadioRFMD:
995 case RadioRFMD2958:
996 case RadioRFMD2958_SMC:
997 err = atu_usb_request(sc, UT_READ_VENDOR_INTERFACE, 0x33,
998 0x0a02, 0x0000, sizeof(rfmd_conf),
999 (u_int8_t *)&rfmd_conf);
1000 if (err) {
1001 DPRINTF(("%s: could not get rfmd config!\n",
1002 USBDEVNAME(sc->atu_dev)));
1003 return err;
1004 }
1005 memcpy(ic->ic_myaddr, rfmd_conf.MACAddr, IEEE80211_ADDR_LEN);
1006 break;
1007
1008 case RadioIntersil:
1009 err = atu_usb_request(sc, UT_READ_VENDOR_INTERFACE, 0x33,
1010 0x0902, 0x0000, sizeof(intersil_conf),
1011 (u_int8_t *)&intersil_conf);
1012 if (err) {
1013 DPRINTF(("%s: could not get intersil config!\n",
1014 USBDEVNAME(sc->atu_dev)));
1015 return err;
1016 }
1017 memcpy(ic->ic_myaddr, intersil_conf.MACAddr,
1018 IEEE80211_ADDR_LEN);
1019 break;
1020 }
1021 return 0;
1022 }
1023
1024 /*
1025 * Probe for an AT76c503 chip.
1026 */
1027 int
1028 atu_match(device_t parent, cfdata_t match, void *aux)
1029 {
1030 struct usb_attach_arg *uaa = aux;
1031 int i;
1032
1033 for (i = 0; i < __arraycount(atu_devs); i++) {
1034 struct atu_type *t = &atu_devs[i];
1035
1036 if (uaa->vendor == t->atu_vid &&
1037 uaa->product == t->atu_pid) {
1038 return(UMATCH_VENDOR_PRODUCT);
1039 }
1040 }
1041 return(UMATCH_NONE);
1042 }
1043
1044 int
1045 atu_media_change(struct ifnet *ifp)
1046 {
1047 struct atu_softc *sc = ifp->if_softc;
1048 struct ieee80211com *ic = &sc->sc_ic;
1049 int err, s;
1050
1051 DPRINTFN(10, ("%s: atu_media_change\n", USBDEVNAME(sc->atu_dev)));
1052
1053 err = ieee80211_media_change(ifp);
1054 if (err == ENETRESET) {
1055 if ((ifp->if_flags & (IFF_RUNNING|IFF_UP)) ==
1056 (IFF_RUNNING|IFF_UP)) {
1057 s = splnet();
1058 ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
1059 atu_initial_config(sc);
1060 ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
1061 splx(s);
1062 }
1063 err = 0;
1064 }
1065
1066 return (err);
1067 }
1068
1069 void
1070 atu_media_status(struct ifnet *ifp, struct ifmediareq *req)
1071 {
1072 #ifdef ATU_DEBUG
1073 struct atu_softc *sc = ifp->if_softc;
1074 #endif /* ATU_DEBUG */
1075
1076 DPRINTFN(10, ("%s: atu_media_status\n", USBDEVNAME(sc->atu_dev)));
1077
1078 ieee80211_media_status(ifp, req);
1079 }
1080
1081 void
1082 atu_task(void *arg)
1083 {
1084 struct atu_softc *sc = (struct atu_softc *)arg;
1085 struct ieee80211com *ic = &sc->sc_ic;
1086 usbd_status err;
1087 int s;
1088
1089 DPRINTFN(10, ("%s: atu_task\n", USBDEVNAME(sc->atu_dev)));
1090
1091 if (sc->sc_state != ATU_S_OK)
1092 return;
1093
1094 switch (sc->sc_cmd) {
1095 case ATU_C_SCAN:
1096
1097 err = atu_start_scan(sc);
1098 if (err) {
1099 DPRINTFN(1, ("%s: atu_task: couldn't start scan!\n",
1100 USBDEVNAME(sc->atu_dev)));
1101 return;
1102 }
1103
1104 err = atu_wait_completion(sc, CMD_START_SCAN, NULL);
1105 if (err) {
1106 DPRINTF(("%s: atu_task: error waiting for scan\n",
1107 USBDEVNAME(sc->atu_dev)));
1108 return;
1109 }
1110
1111 DPRINTF(("%s: ==========================> END OF SCAN!\n",
1112 USBDEVNAME(sc->atu_dev)));
1113
1114 s = splnet();
1115 ieee80211_next_scan(ic);
1116 splx(s);
1117
1118 DPRINTF(("%s: ----------------------======> END OF SCAN2!\n",
1119 USBDEVNAME(sc->atu_dev)));
1120 break;
1121
1122 case ATU_C_JOIN:
1123 atu_join(sc, ic->ic_bss);
1124 }
1125 }
1126
1127 int
1128 atu_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
1129 {
1130 struct ifnet *ifp = ic->ic_ifp;
1131 struct atu_softc *sc = ifp->if_softc;
1132 enum ieee80211_state ostate = ic->ic_state;
1133
1134 DPRINTFN(10, ("%s: atu_newstate: %s -> %s\n", USBDEVNAME(sc->atu_dev),
1135 ieee80211_state_name[ostate], ieee80211_state_name[nstate]));
1136
1137 switch (nstate) {
1138 case IEEE80211_S_SCAN:
1139 memcpy(ic->ic_chan_scan, ic->ic_chan_active,
1140 sizeof(ic->ic_chan_active));
1141 ieee80211_node_table_reset(&ic->ic_scan);
1142
1143 /* tell the event thread that we want a scan */
1144 sc->sc_cmd = ATU_C_SCAN;
1145 usb_add_task(sc->atu_udev, &sc->sc_task, USB_TASKQ_DRIVER);
1146
1147 /* handle this ourselves */
1148 ic->ic_state = nstate;
1149 return (0);
1150
1151 case IEEE80211_S_AUTH:
1152 case IEEE80211_S_RUN:
1153 if (ostate == IEEE80211_S_SCAN) {
1154 sc->sc_cmd = ATU_C_JOIN;
1155 usb_add_task(sc->atu_udev, &sc->sc_task,
1156 USB_TASKQ_DRIVER);
1157 }
1158 break;
1159 default:
1160 /* nothing to do */
1161 break;
1162 }
1163
1164 return (*sc->sc_newstate)(ic, nstate, arg);
1165 }
1166
1167 /*
1168 * Attach the interface. Allocate softc structures, do
1169 * setup and ethernet/BPF attach.
1170 */
1171 void
1172 atu_attach(device_t parent, device_t self, void *aux)
1173 {
1174 struct atu_softc *sc = device_private(self);
1175 struct usb_attach_arg *uaa = aux;
1176 char *devinfop;
1177 usbd_status err;
1178 usbd_device_handle dev = uaa->device;
1179 u_int8_t mode, channel;
1180 int i;
1181
1182 sc->atu_dev = self;
1183 sc->sc_state = ATU_S_UNCONFIG;
1184
1185 aprint_naive("\n");
1186 aprint_normal("\n");
1187
1188 devinfop = usbd_devinfo_alloc(dev, 0);
1189 aprint_normal_dev(self, "%s\n", devinfop);
1190 usbd_devinfo_free(devinfop);
1191
1192 err = usbd_set_config_no(dev, ATU_CONFIG_NO, 1);
1193 if (err) {
1194 aprint_error_dev(self, "setting config no failed\n");
1195 return;
1196 }
1197
1198 err = usbd_device2interface_handle(dev, ATU_IFACE_IDX, &sc->atu_iface);
1199 if (err) {
1200 aprint_error_dev(self, "getting interface handle failed\n");
1201 return;
1202 }
1203
1204 sc->atu_unit = device_unit(self);
1205 sc->atu_udev = dev;
1206
1207 /*
1208 * look up the radio_type for the device
1209 * basically does the same as USB_MATCH
1210 */
1211 for (i = 0; i < __arraycount(atu_devs); i++) {
1212 struct atu_type *t = &atu_devs[i];
1213
1214 if (uaa->vendor == t->atu_vid &&
1215 uaa->product == t->atu_pid) {
1216 sc->atu_radio = t->atu_radio;
1217 sc->atu_quirk = t->atu_quirk;
1218 }
1219 }
1220
1221 /*
1222 * Check in the interface descriptor if we're in DFU mode
1223 * If we're in DFU mode, we upload the external firmware
1224 * If we're not, the PC must have rebooted without power-cycling
1225 * the device.. I've tried this out, a reboot only requeres the
1226 * external firmware to be reloaded :)
1227 *
1228 * Hmm. The at76c505a doesn't report a DFU descriptor when it's
1229 * in DFU mode... Let's just try to get the opmode
1230 */
1231 err = atu_get_opmode(sc, &mode);
1232 DPRINTFN(20, ("%s: opmode: %d\n", USBDEVNAME(sc->atu_dev), mode));
1233 if (err || (mode != MODE_NETCARD && mode != MODE_NOFLASHNETCARD)) {
1234 DPRINTF(("%s: starting internal firmware download\n",
1235 USBDEVNAME(sc->atu_dev)));
1236
1237 atu_internal_firmware(sc->atu_dev);
1238 /*
1239 * atu_internal_firmware will cause a reset of the device
1240 * so we don't want to do any more configuration after this
1241 * point.
1242 */
1243 return;
1244 }
1245
1246 if (mode != MODE_NETCARD) {
1247 DPRINTFN(15, ("%s: device needs external firmware\n",
1248 USBDEVNAME(sc->atu_dev)));
1249
1250 if (mode != MODE_NOFLASHNETCARD) {
1251 DPRINTF(("%s: unexpected opmode=%d\n",
1252 USBDEVNAME(sc->atu_dev), mode));
1253 }
1254
1255 /*
1256 * There is no difference in opmode before and after external
1257 * firmware upload with the SMC2662 V.4 . So instead we'll try
1258 * to read the channel number. If we succeed, external
1259 * firmwaremust have been already uploaded...
1260 */
1261 if (sc->atu_radio != RadioIntersil) {
1262 err = atu_get_mib(sc, MIB_PHY__CHANNEL, &channel);
1263 if (!err) {
1264 DPRINTF(("%s: external firmware has already"
1265 " been downloaded\n",
1266 USBDEVNAME(sc->atu_dev)));
1267 atu_complete_attach(sc);
1268 return;
1269 }
1270 }
1271
1272 atu_external_firmware(sc->atu_dev);
1273
1274 /*
1275 * atu_external_firmware will call atu_complete_attach after
1276 * it's finished so we can just return.
1277 */
1278 } else {
1279 /* all the firmwares are in place, so complete the attach */
1280 atu_complete_attach(sc);
1281 }
1282
1283 return;
1284 }
1285
1286 void
1287 atu_complete_attach(struct atu_softc *sc)
1288 {
1289 struct ieee80211com *ic = &sc->sc_ic;
1290 struct ifnet *ifp = &sc->sc_if;
1291 usb_interface_descriptor_t *id;
1292 usb_endpoint_descriptor_t *ed;
1293 usbd_status err;
1294 int i;
1295 #ifdef ATU_DEBUG
1296 struct atu_fw fw;
1297 #endif
1298
1299 id = usbd_get_interface_descriptor(sc->atu_iface);
1300
1301 /* Find endpoints. */
1302 for (i = 0; i < id->bNumEndpoints; i++) {
1303 ed = usbd_interface2endpoint_descriptor(sc->atu_iface, i);
1304 if (!ed) {
1305 DPRINTF(("%s: num_endp:%d\n", USBDEVNAME(sc->atu_dev),
1306 sc->atu_iface->idesc->bNumEndpoints));
1307 DPRINTF(("%s: couldn't get ep %d\n",
1308 USBDEVNAME(sc->atu_dev), i));
1309 return;
1310 }
1311 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
1312 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
1313 sc->atu_ed[ATU_ENDPT_RX] = ed->bEndpointAddress;
1314 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
1315 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
1316 sc->atu_ed[ATU_ENDPT_TX] = ed->bEndpointAddress;
1317 }
1318 }
1319
1320 /* read device config & get MAC address */
1321 err = atu_get_card_config(sc);
1322 if (err) {
1323 aprint_error("\n%s: could not get card cfg!\n",
1324 device_xname(sc->atu_dev));
1325 return;
1326 }
1327
1328 #ifdef ATU_DEBUG
1329 /* DEBUG : try to get firmware version */
1330 err = atu_get_mib(sc, MIB_FW_VERSION, sizeof(fw), 0, (u_int8_t *)&fw);
1331 if (!err) {
1332 DPRINTFN(15, ("%s: firmware: maj:%d min:%d patch:%d "
1333 "build:%d\n", USBDEVNAME(sc->atu_dev), fw.major, fw.minor,
1334 fw.patch, fw.build));
1335 } else {
1336 DPRINTF(("%s: get firmware version failed\n",
1337 USBDEVNAME(sc->atu_dev)));
1338 }
1339 #endif /* ATU_DEBUG */
1340
1341 /* Show the world our MAC address */
1342 aprint_normal_dev(sc->atu_dev, "MAC address %s\n",
1343 ether_sprintf(ic->ic_myaddr));
1344
1345 sc->atu_cdata.atu_tx_inuse = 0;
1346 sc->atu_encrypt = ATU_WEP_OFF;
1347 sc->atu_wepkeylen = ATU_WEP_104BITS;
1348 sc->atu_wepkey = 0;
1349
1350 memset(sc->atu_bssid, 0, ETHER_ADDR_LEN);
1351 sc->atu_channel = ATU_DEFAULT_CHANNEL;
1352 sc->atu_desired_channel = IEEE80211_CHAN_ANY;
1353 sc->atu_mode = INFRASTRUCTURE_MODE;
1354
1355 ic->ic_ifp = ifp;
1356 ic->ic_phytype = IEEE80211_T_DS;
1357 ic->ic_opmode = IEEE80211_M_STA;
1358 ic->ic_state = IEEE80211_S_INIT;
1359 #ifdef FIXME
1360 ic->ic_caps = IEEE80211_C_IBSS | IEEE80211_C_WEP | IEEE80211_C_SCANALL;
1361 #else
1362 ic->ic_caps = IEEE80211_C_IBSS | IEEE80211_C_WEP;
1363 #endif
1364
1365 i = 0;
1366 ic->ic_sup_rates[IEEE80211_MODE_11B].rs_rates[i++] = 2;
1367 ic->ic_sup_rates[IEEE80211_MODE_11B].rs_rates[i++] = 4;
1368 ic->ic_sup_rates[IEEE80211_MODE_11B].rs_rates[i++] = 11;
1369 ic->ic_sup_rates[IEEE80211_MODE_11B].rs_rates[i++] = 22;
1370 ic->ic_sup_rates[IEEE80211_MODE_11B].rs_nrates = i;
1371
1372 for (i = 1; i <= 14; i++) {
1373 ic->ic_channels[i].ic_flags = IEEE80211_CHAN_B |
1374 IEEE80211_CHAN_PASSIVE;
1375 ic->ic_channels[i].ic_freq = ieee80211_ieee2mhz(i,
1376 ic->ic_channels[i].ic_flags);
1377 }
1378
1379 ic->ic_ibss_chan = &ic->ic_channels[0];
1380
1381 ifp->if_softc = sc;
1382 memcpy(ifp->if_xname, device_xname(sc->atu_dev), IFNAMSIZ);
1383 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1384 ifp->if_init = atu_init;
1385 ifp->if_stop = atu_stop;
1386 ifp->if_start = atu_start;
1387 ifp->if_ioctl = atu_ioctl;
1388 ifp->if_watchdog = atu_watchdog;
1389 ifp->if_mtu = ATU_DEFAULT_MTU;
1390 IFQ_SET_READY(&ifp->if_snd);
1391
1392 /* Call MI attach routine. */
1393 if_attach(ifp);
1394 ieee80211_ifattach(ic);
1395
1396 sc->sc_newstate = ic->ic_newstate;
1397 ic->ic_newstate = atu_newstate;
1398
1399 /* setup ifmedia interface */
1400 ieee80211_media_init(ic, atu_media_change, atu_media_status);
1401
1402 usb_init_task(&sc->sc_task, atu_task, sc);
1403
1404 sc->sc_state = ATU_S_OK;
1405 }
1406
1407 int
1408 atu_detach(device_t self, int flags)
1409 {
1410 struct atu_softc *sc = device_private(self);
1411 struct ifnet *ifp = &sc->sc_if;
1412
1413 DPRINTFN(10, ("%s: atu_detach state=%d\n", USBDEVNAME(sc->atu_dev),
1414 sc->sc_state));
1415
1416 if (sc->sc_state != ATU_S_UNCONFIG) {
1417 atu_stop(ifp, 1);
1418
1419 ieee80211_ifdetach(&sc->sc_ic);
1420 if_detach(ifp);
1421 }
1422
1423 return(0);
1424 }
1425
1426 int
1427 atu_activate(device_t self, enum devact act)
1428 {
1429 struct atu_softc *sc = device_private(self);
1430
1431 switch (act) {
1432 case DVACT_DEACTIVATE:
1433 if (sc->sc_state != ATU_S_UNCONFIG) {
1434 if_deactivate(&sc->atu_ec.ec_if);
1435 sc->sc_state = ATU_S_DEAD;
1436 }
1437 return 0;
1438 default:
1439 return EOPNOTSUPP;
1440 }
1441 }
1442
1443 /*
1444 * Initialize an RX descriptor and attach an MBUF cluster.
1445 */
1446 int
1447 atu_newbuf(struct atu_softc *sc, struct atu_chain *c, struct mbuf *m)
1448 {
1449 struct mbuf *m_new = NULL;
1450
1451 if (m == NULL) {
1452 MGETHDR(m_new, M_DONTWAIT, MT_DATA);
1453 if (m_new == NULL) {
1454 DPRINTF(("%s: no memory for rx list\n",
1455 USBDEVNAME(sc->atu_dev)));
1456 return(ENOBUFS);
1457 }
1458
1459 MCLGET(m_new, M_DONTWAIT);
1460 if (!(m_new->m_flags & M_EXT)) {
1461 DPRINTF(("%s: no memory for rx list\n",
1462 USBDEVNAME(sc->atu_dev)));
1463 m_freem(m_new);
1464 return(ENOBUFS);
1465 }
1466 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
1467 } else {
1468 m_new = m;
1469 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
1470 m_new->m_data = m_new->m_ext.ext_buf;
1471 }
1472 c->atu_mbuf = m_new;
1473 return(0);
1474 }
1475
1476 int
1477 atu_rx_list_init(struct atu_softc *sc)
1478 {
1479 struct atu_cdata *cd = &sc->atu_cdata;
1480 struct atu_chain *c;
1481 int i;
1482
1483 DPRINTFN(15, ("%s: atu_rx_list_init: enter\n",
1484 USBDEVNAME(sc->atu_dev)));
1485
1486 for (i = 0; i < ATU_RX_LIST_CNT; i++) {
1487 c = &cd->atu_rx_chain[i];
1488 c->atu_sc = sc;
1489 c->atu_idx = i;
1490 if (c->atu_xfer == NULL) {
1491 c->atu_xfer = usbd_alloc_xfer(sc->atu_udev);
1492 if (c->atu_xfer == NULL)
1493 return (ENOBUFS);
1494 c->atu_buf = usbd_alloc_buffer(c->atu_xfer,
1495 ATU_RX_BUFSZ);
1496 if (c->atu_buf == NULL) /* XXX free xfer */
1497 return (ENOBUFS);
1498 if (atu_newbuf(sc, c, NULL) == ENOBUFS) /* XXX free? */
1499 return(ENOBUFS);
1500 }
1501 }
1502 return (0);
1503 }
1504
1505 int
1506 atu_tx_list_init(struct atu_softc *sc)
1507 {
1508 struct atu_cdata *cd = &sc->atu_cdata;
1509 struct atu_chain *c;
1510 int i;
1511
1512 DPRINTFN(15, ("%s: atu_tx_list_init\n",
1513 USBDEVNAME(sc->atu_dev)));
1514
1515 SLIST_INIT(&cd->atu_tx_free);
1516 sc->atu_cdata.atu_tx_inuse = 0;
1517
1518 for (i = 0; i < ATU_TX_LIST_CNT; i++) {
1519 c = &cd->atu_tx_chain[i];
1520 c->atu_sc = sc;
1521 c->atu_idx = i;
1522 if (c->atu_xfer == NULL) {
1523 c->atu_xfer = usbd_alloc_xfer(sc->atu_udev);
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", device_xname(sc->atu_dev));
1932
1933 /* Init RX ring */
1934 if (atu_rx_list_init(sc))
1935 printf("%s: rx list init failed\n", device_xname(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, void *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 }
NetBSD on the FriendlyARM MINI2440