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