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