2 * Driver for ZyDAS zd1201 based wireless USB devices.
4 * Copyright (c) 2004, 2005 Jeroen Vreeken (pe1rxq@amsat.org)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * version 2 as published by the Free Software Foundation.
10 * Parts of this driver have been derived from a wlan-ng version
11 * modified by ZyDAS. They also made documentation available, thanks!
12 * Copyright (C) 1999 AbsoluteValue Systems, Inc. All Rights Reserved.
15 #include <linux/module.h>
16 #include <linux/usb.h>
17 #include <linux/netdevice.h>
18 #include <linux/etherdevice.h>
19 #include <linux/wireless.h>
20 #include <linux/ieee80211.h>
21 #include <net/iw_handler.h>
22 #include <linux/string.h>
23 #include <linux/if_arp.h>
24 #include <linux/firmware.h>
27 static struct usb_device_id zd1201_table
[] = {
28 {USB_DEVICE(0x0586, 0x3400)}, /* Peabird Wireless USB Adapter */
29 {USB_DEVICE(0x0ace, 0x1201)}, /* ZyDAS ZD1201 Wireless USB Adapter */
30 {USB_DEVICE(0x050d, 0x6051)}, /* Belkin F5D6051 usb adapter */
31 {USB_DEVICE(0x0db0, 0x6823)}, /* MSI UB11B usb adapter */
32 {USB_DEVICE(0x1044, 0x8005)}, /* GIGABYTE GN-WLBZ201 usb adapter */
36 static int ap
; /* Are we an AP or a normal station? */
38 #define ZD1201_VERSION "0.15"
40 MODULE_AUTHOR("Jeroen Vreeken <pe1rxq@amsat.org>");
41 MODULE_DESCRIPTION("Driver for ZyDAS ZD1201 based USB Wireless adapters");
42 MODULE_VERSION(ZD1201_VERSION
);
43 MODULE_LICENSE("GPL");
44 module_param(ap
, int, 0);
45 MODULE_PARM_DESC(ap
, "If non-zero Access Point firmware will be loaded");
46 MODULE_DEVICE_TABLE(usb
, zd1201_table
);
49 static int zd1201_fw_upload(struct usb_device
*dev
, int apfw
)
51 const struct firmware
*fw_entry
;
60 fwfile
= "zd1201-ap.fw";
64 err
= request_firmware(&fw_entry
, fwfile
, &dev
->dev
);
66 dev_err(&dev
->dev
, "Failed to load %s firmware file!\n", fwfile
);
67 dev_err(&dev
->dev
, "Make sure the hotplug firmware loader is installed.\n");
68 dev_err(&dev
->dev
, "Goto http://linux-lc100020.sourceforge.net for more info.\n");
72 data
= fw_entry
->data
;
75 buf
= kmalloc(1024, GFP_ATOMIC
);
80 int translen
= (len
> 1024) ? 1024 : len
;
81 memcpy(buf
, data
, translen
);
83 err
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), 0,
84 USB_DIR_OUT
| 0x40, 0, 0, buf
, translen
,
93 err
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), 0x2,
94 USB_DIR_OUT
| 0x40, 0, 0, NULL
, 0, ZD1201_FW_TIMEOUT
);
98 err
= usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), 0x4,
99 USB_DIR_IN
| 0x40, 0,0, &ret
, sizeof(ret
), ZD1201_FW_TIMEOUT
);
111 release_firmware(fw_entry
);
115 static void zd1201_usbfree(struct urb
*urb
)
117 struct zd1201
*zd
= urb
->context
;
119 switch(urb
->status
) {
127 dev_warn(&zd
->usb
->dev
, "%s: urb failed: %d\n",
128 zd
->dev
->name
, urb
->status
);
131 kfree(urb
->transfer_buffer
);
144 total: 4 + 2 + 2 + 2 + 2 + 4 = 16
146 static int zd1201_docmd(struct zd1201
*zd
, int cmd
, int parm0
,
147 int parm1
, int parm2
)
149 unsigned char *command
;
153 command
= kmalloc(16, GFP_ATOMIC
);
157 *((__le32
*)command
) = cpu_to_le32(ZD1201_USB_CMDREQ
);
158 *((__le16
*)&command
[4]) = cpu_to_le16(cmd
);
159 *((__le16
*)&command
[6]) = cpu_to_le16(parm0
);
160 *((__le16
*)&command
[8]) = cpu_to_le16(parm1
);
161 *((__le16
*)&command
[10])= cpu_to_le16(parm2
);
163 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
168 usb_fill_bulk_urb(urb
, zd
->usb
, usb_sndbulkpipe(zd
->usb
, zd
->endp_out2
),
169 command
, 16, zd1201_usbfree
, zd
);
170 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
179 /* Callback after sending out a packet */
180 static void zd1201_usbtx(struct urb
*urb
)
182 struct zd1201
*zd
= urb
->context
;
183 netif_wake_queue(zd
->dev
);
188 static void zd1201_usbrx(struct urb
*urb
)
190 struct zd1201
*zd
= urb
->context
;
192 unsigned char *data
= urb
->transfer_buffer
;
199 switch(urb
->status
) {
207 dev_warn(&zd
->usb
->dev
, "%s: rx urb failed: %d\n",
208 zd
->dev
->name
, urb
->status
);
213 if (urb
->status
!= 0 || urb
->actual_length
== 0)
217 if (type
== ZD1201_PACKET_EVENTSTAT
|| type
== ZD1201_PACKET_RESOURCE
) {
218 memcpy(zd
->rxdata
, data
, urb
->actual_length
);
219 zd
->rxlen
= urb
->actual_length
;
221 wake_up(&zd
->rxdataq
);
224 if (type
== ZD1201_PACKET_INQUIRE
) {
226 unsigned short infotype
, framelen
, copylen
;
227 framelen
= le16_to_cpu(*(__le16
*)&data
[4]);
228 infotype
= le16_to_cpu(*(__le16
*)&data
[6]);
230 if (infotype
== ZD1201_INF_LINKSTATUS
) {
233 linkstatus
= le16_to_cpu(*(__le16
*)&data
[8]);
236 netif_carrier_on(zd
->dev
);
239 netif_carrier_off(zd
->dev
);
242 netif_carrier_off(zd
->dev
);
245 netif_carrier_on(zd
->dev
);
248 netif_carrier_off(zd
->dev
);
252 if (infotype
== ZD1201_INF_ASSOCSTATUS
) {
253 short status
= le16_to_cpu(*(__le16
*)(data
+8));
255 union iwreq_data wrqu
;
258 case ZD1201_ASSOCSTATUS_STAASSOC
:
259 case ZD1201_ASSOCSTATUS_REASSOC
:
260 event
= IWEVREGISTERED
;
262 case ZD1201_ASSOCSTATUS_DISASSOC
:
263 case ZD1201_ASSOCSTATUS_ASSOCFAIL
:
264 case ZD1201_ASSOCSTATUS_AUTHFAIL
:
268 memcpy(wrqu
.addr
.sa_data
, data
+10, ETH_ALEN
);
269 wrqu
.addr
.sa_family
= ARPHRD_ETHER
;
271 /* Send event to user space */
272 wireless_send_event(zd
->dev
, event
, &wrqu
, NULL
);
276 if (infotype
== ZD1201_INF_AUTHREQ
) {
277 union iwreq_data wrqu
;
279 memcpy(wrqu
.addr
.sa_data
, data
+8, ETH_ALEN
);
280 wrqu
.addr
.sa_family
= ARPHRD_ETHER
;
281 /* There isn't a event that trully fits this request.
282 We assume that userspace will be smart enough to
283 see a new station being expired and sends back a
284 authstation ioctl to authorize it. */
285 wireless_send_event(zd
->dev
, IWEVEXPIRED
, &wrqu
, NULL
);
288 /* Other infotypes are handled outside this handler */
290 while (i
< urb
->actual_length
) {
291 copylen
= le16_to_cpu(*(__le16
*)&data
[i
+2]);
292 /* Sanity check, sometimes we get junk */
293 if (copylen
+zd
->rxlen
> sizeof(zd
->rxdata
))
295 memcpy(zd
->rxdata
+zd
->rxlen
, data
+i
+4, copylen
);
296 zd
->rxlen
+= copylen
;
299 if (i
>= urb
->actual_length
) {
301 wake_up(&zd
->rxdataq
);
306 if (data
[urb
->actual_length
-1] == ZD1201_PACKET_RXDATA
) {
307 int datalen
= urb
->actual_length
-1;
308 unsigned short len
, fc
, seq
;
309 struct hlist_node
*node
;
311 len
= ntohs(*(__be16
*)&data
[datalen
-2]);
314 fc
= le16_to_cpu(*(__le16
*)&data
[datalen
-16]);
315 seq
= le16_to_cpu(*(__le16
*)&data
[datalen
-24]);
320 if (!(skb
= dev_alloc_skb(datalen
+24)))
323 memcpy(skb_put(skb
, 2), &data
[datalen
-16], 2);
324 memcpy(skb_put(skb
, 2), &data
[datalen
-2], 2);
325 memcpy(skb_put(skb
, 6), &data
[datalen
-14], 6);
326 memcpy(skb_put(skb
, 6), &data
[datalen
-22], 6);
327 memcpy(skb_put(skb
, 6), &data
[datalen
-8], 6);
328 memcpy(skb_put(skb
, 2), &data
[datalen
-24], 2);
329 memcpy(skb_put(skb
, len
), data
, len
);
330 skb
->protocol
= eth_type_trans(skb
, zd
->dev
);
331 zd
->stats
.rx_packets
++;
332 zd
->stats
.rx_bytes
+= skb
->len
;
337 if ((seq
& IEEE80211_SCTL_FRAG
) ||
338 (fc
& IEEE80211_FCTL_MOREFRAGS
)) {
339 struct zd1201_frag
*frag
= NULL
;
344 if ((seq
& IEEE80211_SCTL_FRAG
) == 0) {
345 frag
= kmalloc(sizeof(*frag
), GFP_ATOMIC
);
348 skb
= dev_alloc_skb(IEEE80211_MAX_DATA_LEN
+14+2);
354 frag
->seq
= seq
& IEEE80211_SCTL_SEQ
;
356 memcpy(skb_put(skb
, 12), &data
[datalen
-14], 12);
357 memcpy(skb_put(skb
, 2), &data
[6], 2);
358 memcpy(skb_put(skb
, len
), data
+8, len
);
359 hlist_add_head(&frag
->fnode
, &zd
->fraglist
);
362 hlist_for_each_entry(frag
, node
, &zd
->fraglist
, fnode
)
363 if (frag
->seq
== (seq
&IEEE80211_SCTL_SEQ
))
368 ptr
= skb_put(skb
, len
);
370 memcpy(ptr
, data
+8, len
);
371 if (fc
& IEEE80211_FCTL_MOREFRAGS
)
373 hlist_del_init(&frag
->fnode
);
378 skb
= dev_alloc_skb(len
+ 14 + 2);
382 memcpy(skb_put(skb
, 12), &data
[datalen
-14], 12);
383 memcpy(skb_put(skb
, 2), &data
[6], 2);
384 memcpy(skb_put(skb
, len
), data
+8, len
);
386 skb
->protocol
= eth_type_trans(skb
, zd
->dev
);
387 zd
->stats
.rx_packets
++;
388 zd
->stats
.rx_bytes
+= skb
->len
;
392 memset(data
, 0, ZD1201_RXSIZE
);
396 if(usb_submit_urb(urb
, GFP_ATOMIC
))
403 wake_up(&zd
->rxdataq
);
404 kfree(urb
->transfer_buffer
);
409 static int zd1201_getconfig(struct zd1201
*zd
, int rid
, void *riddata
,
410 unsigned int riddatalen
)
417 unsigned char *pdata
;
420 err
= zd1201_docmd(zd
, ZD1201_CMDCODE_ACCESS
, rid
, 0, 0);
424 wait_event_interruptible(zd
->rxdataq
, zd
->rxdatas
);
428 code
= le16_to_cpu(*(__le16
*)(&zd
->rxdata
[4]));
429 rid_fid
= le16_to_cpu(*(__le16
*)(&zd
->rxdata
[6]));
430 length
= le16_to_cpu(*(__le16
*)(&zd
->rxdata
[8]));
431 if (length
> zd
->rxlen
)
432 length
= zd
->rxlen
-6;
434 /* If access bit is not on, then error */
435 if ((code
& ZD1201_ACCESSBIT
) != ZD1201_ACCESSBIT
|| rid_fid
!= rid
)
438 /* Not enough buffer for allocating data */
439 if (riddatalen
!= (length
- 4)) {
440 dev_dbg(&zd
->usb
->dev
, "riddatalen mismatches, expected=%u, (packet=%u) length=%u, rid=0x%04X, rid_fid=0x%04X\n",
441 riddatalen
, zd
->rxlen
, length
, rid
, rid_fid
);
446 /* Issue SetRxRid commnd */
447 err
= zd1201_docmd(zd
, ZD1201_CMDCODE_SETRXRID
, rid
, 0, length
);
451 /* Receive RID record from resource packets */
452 wait_event_interruptible(zd
->rxdataq
, zd
->rxdatas
);
456 if (zd
->rxdata
[zd
->rxlen
- 1] != ZD1201_PACKET_RESOURCE
) {
457 dev_dbg(&zd
->usb
->dev
, "Packet type mismatch: 0x%x not 0x3\n",
458 zd
->rxdata
[zd
->rxlen
-1]);
462 /* Set the data pointer and received data length */
469 actual_length
= (length
> 64) ? 64 : length
;
471 if (pdata
[0] != 0x3) {
472 dev_dbg(&zd
->usb
->dev
, "Rx Resource packet type error: %02X\n",
477 if (actual_length
!= 64) {
478 /* Trim the last packet type byte */
482 /* Skip the 4 bytes header (RID length and RID) */
491 memcpy(riddata
, pdata
, actual_length
);
492 riddata
+= actual_length
;
493 pdata
+= actual_length
;
496 } while (length
> 0);
509 static int zd1201_setconfig(struct zd1201
*zd
, int rid
, void *buf
, int len
, int wait
)
512 unsigned char *request
;
516 gfp_t gfp_mask
= wait
? GFP_NOIO
: GFP_ATOMIC
;
518 len
+= 4; /* first 4 are for header */
522 for (seq
=0; len
> 0; seq
++) {
523 request
= kmalloc(16, gfp_mask
);
526 urb
= usb_alloc_urb(0, gfp_mask
);
531 memset(request
, 0, 16);
532 reqlen
= len
>12 ? 12 : len
;
533 request
[0] = ZD1201_USB_RESREQ
;
537 if (request
[1] == 0) {
539 *(__le16
*)&request
[4] = cpu_to_le16((len
-2+1)/2);
540 *(__le16
*)&request
[6] = cpu_to_le16(rid
);
541 memcpy(request
+8, buf
, reqlen
-4);
544 memcpy(request
+4, buf
, reqlen
);
550 usb_fill_bulk_urb(urb
, zd
->usb
, usb_sndbulkpipe(zd
->usb
,
551 zd
->endp_out2
), request
, 16, zd1201_usbfree
, zd
);
552 err
= usb_submit_urb(urb
, gfp_mask
);
557 request
= kmalloc(16, gfp_mask
);
560 urb
= usb_alloc_urb(0, gfp_mask
);
565 *((__le32
*)request
) = cpu_to_le32(ZD1201_USB_CMDREQ
);
566 *((__le16
*)&request
[4]) =
567 cpu_to_le16(ZD1201_CMDCODE_ACCESS
|ZD1201_ACCESSBIT
);
568 *((__le16
*)&request
[6]) = cpu_to_le16(rid
);
569 *((__le16
*)&request
[8]) = cpu_to_le16(0);
570 *((__le16
*)&request
[10]) = cpu_to_le16(0);
571 usb_fill_bulk_urb(urb
, zd
->usb
, usb_sndbulkpipe(zd
->usb
, zd
->endp_out2
),
572 request
, 16, zd1201_usbfree
, zd
);
573 err
= usb_submit_urb(urb
, gfp_mask
);
578 wait_event_interruptible(zd
->rxdataq
, zd
->rxdatas
);
579 if (!zd
->rxlen
|| le16_to_cpu(*(__le16
*)&zd
->rxdata
[6]) != rid
) {
580 dev_dbg(&zd
->usb
->dev
, "wrong or no RID received\n");
591 static inline int zd1201_getconfig16(struct zd1201
*zd
, int rid
, short *val
)
596 err
= zd1201_getconfig(zd
, rid
, &zdval
, sizeof(__le16
));
599 *val
= le16_to_cpu(zdval
);
603 static inline int zd1201_setconfig16(struct zd1201
*zd
, int rid
, short val
)
605 __le16 zdval
= cpu_to_le16(val
);
606 return (zd1201_setconfig(zd
, rid
, &zdval
, sizeof(__le16
), 1));
609 static int zd1201_drvr_start(struct zd1201
*zd
)
614 unsigned char *buffer
;
616 buffer
= kzalloc(ZD1201_RXSIZE
, GFP_KERNEL
);
620 usb_fill_bulk_urb(zd
->rx_urb
, zd
->usb
,
621 usb_rcvbulkpipe(zd
->usb
, zd
->endp_in
), buffer
, ZD1201_RXSIZE
,
624 err
= usb_submit_urb(zd
->rx_urb
, GFP_KERNEL
);
628 err
= zd1201_docmd(zd
, ZD1201_CMDCODE_INIT
, 0, 0, 0);
632 err
= zd1201_getconfig(zd
, ZD1201_RID_CNFMAXTXBUFFERNUMBER
, &zdmax
,
637 max
= le16_to_cpu(zdmax
);
638 for (i
=0; i
<max
; i
++) {
639 err
= zd1201_docmd(zd
, ZD1201_CMDCODE_ALLOC
, 1514, 0, 0);
647 usb_kill_urb(zd
->rx_urb
);
654 /* Magic alert: The firmware doesn't seem to like the MAC state being
655 * toggled in promisc (aka monitor) mode.
656 * (It works a number of times, but will halt eventually)
657 * So we turn it of before disabling and on after enabling if needed.
659 static int zd1201_enable(struct zd1201
*zd
)
666 err
= zd1201_docmd(zd
, ZD1201_CMDCODE_ENABLE
, 0, 0, 0);
671 err
= zd1201_setconfig16(zd
, ZD1201_RID_PROMISCUOUSMODE
, 1);
676 static int zd1201_disable(struct zd1201
*zd
)
680 if (!zd
->mac_enabled
)
683 err
= zd1201_setconfig16(zd
, ZD1201_RID_PROMISCUOUSMODE
, 0);
688 err
= zd1201_docmd(zd
, ZD1201_CMDCODE_DISABLE
, 0, 0, 0);
694 static int zd1201_mac_reset(struct zd1201
*zd
)
696 if (!zd
->mac_enabled
)
699 return zd1201_enable(zd
);
702 static int zd1201_join(struct zd1201
*zd
, char *essid
, int essidlen
)
705 char buf
[IW_ESSID_MAX_SIZE
+2];
707 err
= zd1201_disable(zd
);
711 val
= ZD1201_CNFAUTHENTICATION_OPENSYSTEM
;
712 val
|= ZD1201_CNFAUTHENTICATION_SHAREDKEY
;
713 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFAUTHENTICATION
, val
);
717 *(__le16
*)buf
= cpu_to_le16(essidlen
);
718 memcpy(buf
+2, essid
, essidlen
);
719 if (!zd
->ap
) { /* Normal station */
720 err
= zd1201_setconfig(zd
, ZD1201_RID_CNFDESIREDSSID
, buf
,
721 IW_ESSID_MAX_SIZE
+2, 1);
725 err
= zd1201_setconfig(zd
, ZD1201_RID_CNFOWNSSID
, buf
,
726 IW_ESSID_MAX_SIZE
+2, 1);
731 err
= zd1201_setconfig(zd
, ZD1201_RID_CNFOWNMACADDR
,
732 zd
->dev
->dev_addr
, zd
->dev
->addr_len
, 1);
736 err
= zd1201_enable(zd
);
744 static int zd1201_net_open(struct net_device
*dev
)
746 struct zd1201
*zd
= netdev_priv(dev
);
748 /* Start MAC with wildcard if no essid set */
749 if (!zd
->mac_enabled
)
750 zd1201_join(zd
, zd
->essid
, zd
->essidlen
);
751 netif_start_queue(dev
);
756 static int zd1201_net_stop(struct net_device
*dev
)
758 netif_stop_queue(dev
);
763 RFC 1042 encapsulates Ethernet frames in 802.11 frames
764 by prefixing them with 0xaa, 0xaa, 0x03) followed by a SNAP OID of 0
765 (0x00, 0x00, 0x00). Zd requires an additional padding, copy
766 of ethernet addresses, length of the standard RFC 1042 packet
767 and a command byte (which is nul for tx).
769 tx frame (from Wlan NG):
771 llc 0xAA 0xAA 0x03 (802.2 LLC)
772 snap 0x00 0x00 0x00 (Ethernet encapsulated)
773 type 2 bytes, Ethernet type field
774 payload (minus eth header)
776 padding 1B if (skb->len+8+1)%64==0
777 Eth MAC addr 12 bytes, Ethernet MAC addresses
778 length 2 bytes, RFC 1042 packet length
779 (llc+snap+type+payload)
780 zd 1 null byte, zd1201 packet type
782 static int zd1201_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
784 struct zd1201
*zd
= netdev_priv(dev
);
785 unsigned char *txbuf
= zd
->txdata
;
786 int txbuflen
, pad
= 0, err
;
787 struct urb
*urb
= zd
->tx_urb
;
789 if (!zd
->mac_enabled
|| zd
->monitor
) {
790 zd
->stats
.tx_dropped
++;
794 netif_stop_queue(dev
);
796 txbuflen
= skb
->len
+ 8 + 1;
797 if (txbuflen
%64 == 0) {
804 txbuf
[3] = 0x00; /* rfc1042 */
808 skb_copy_from_linear_data_offset(skb
, 12, txbuf
+ 6, skb
->len
- 12);
810 txbuf
[skb
->len
-12+6]=0;
811 skb_copy_from_linear_data(skb
, txbuf
+ skb
->len
- 12 + 6 + pad
, 12);
812 *(__be16
*)&txbuf
[skb
->len
+6+pad
] = htons(skb
->len
-12+6);
813 txbuf
[txbuflen
-1] = 0;
815 usb_fill_bulk_urb(urb
, zd
->usb
, usb_sndbulkpipe(zd
->usb
, zd
->endp_out
),
816 txbuf
, txbuflen
, zd1201_usbtx
, zd
);
818 err
= usb_submit_urb(zd
->tx_urb
, GFP_ATOMIC
);
820 zd
->stats
.tx_errors
++;
821 netif_start_queue(dev
);
824 zd
->stats
.tx_packets
++;
825 zd
->stats
.tx_bytes
+= skb
->len
;
826 dev
->trans_start
= jiffies
;
832 static void zd1201_tx_timeout(struct net_device
*dev
)
834 struct zd1201
*zd
= netdev_priv(dev
);
838 dev_warn(&zd
->usb
->dev
, "%s: TX timeout, shooting down urb\n",
840 usb_unlink_urb(zd
->tx_urb
);
841 zd
->stats
.tx_errors
++;
842 /* Restart the timeout to quiet the watchdog: */
843 dev
->trans_start
= jiffies
;
846 static int zd1201_set_mac_address(struct net_device
*dev
, void *p
)
848 struct sockaddr
*addr
= p
;
849 struct zd1201
*zd
= netdev_priv(dev
);
855 err
= zd1201_setconfig(zd
, ZD1201_RID_CNFOWNMACADDR
,
856 addr
->sa_data
, dev
->addr_len
, 1);
859 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
861 return zd1201_mac_reset(zd
);
864 static struct net_device_stats
*zd1201_get_stats(struct net_device
*dev
)
866 struct zd1201
*zd
= netdev_priv(dev
);
871 static struct iw_statistics
*zd1201_get_wireless_stats(struct net_device
*dev
)
873 struct zd1201
*zd
= netdev_priv(dev
);
878 static void zd1201_set_multicast(struct net_device
*dev
)
880 struct zd1201
*zd
= netdev_priv(dev
);
881 struct dev_mc_list
*mc
= dev
->mc_list
;
882 unsigned char reqbuf
[ETH_ALEN
*ZD1201_MAXMULTI
];
885 if (dev
->mc_count
> ZD1201_MAXMULTI
)
888 for (i
=0; i
<dev
->mc_count
; i
++) {
889 memcpy(reqbuf
+i
*ETH_ALEN
, mc
->dmi_addr
, ETH_ALEN
);
892 zd1201_setconfig(zd
, ZD1201_RID_CNFGROUPADDRESS
, reqbuf
,
893 dev
->mc_count
*ETH_ALEN
, 0);
897 static int zd1201_config_commit(struct net_device
*dev
,
898 struct iw_request_info
*info
, struct iw_point
*data
, char *essid
)
900 struct zd1201
*zd
= netdev_priv(dev
);
902 return zd1201_mac_reset(zd
);
905 static int zd1201_get_name(struct net_device
*dev
,
906 struct iw_request_info
*info
, char *name
, char *extra
)
908 strcpy(name
, "IEEE 802.11b");
912 static int zd1201_set_freq(struct net_device
*dev
,
913 struct iw_request_info
*info
, struct iw_freq
*freq
, char *extra
)
915 struct zd1201
*zd
= netdev_priv(dev
);
922 channel
= ieee80211_freq_to_dsss_chan(freq
->m
);
927 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFOWNCHANNEL
, channel
);
931 zd1201_mac_reset(zd
);
936 static int zd1201_get_freq(struct net_device
*dev
,
937 struct iw_request_info
*info
, struct iw_freq
*freq
, char *extra
)
939 struct zd1201
*zd
= netdev_priv(dev
);
943 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFOWNCHANNEL
, &channel
);
952 static int zd1201_set_mode(struct net_device
*dev
,
953 struct iw_request_info
*info
, __u32
*mode
, char *extra
)
955 struct zd1201
*zd
= netdev_priv(dev
);
956 short porttype
, monitor
= 0;
957 unsigned char buffer
[IW_ESSID_MAX_SIZE
+2];
961 if (*mode
!= IW_MODE_MASTER
)
966 err
= zd1201_setconfig16(zd
, ZD1201_RID_PROMISCUOUSMODE
, 0);
969 zd
->dev
->type
= ARPHRD_ETHER
;
971 case IW_MODE_MONITOR
:
973 zd
->dev
->type
= ARPHRD_IEEE80211
;
974 /* Make sure we are no longer associated with by
975 setting an 'impossible' essid.
976 (otherwise we mess up firmware)
978 zd1201_join(zd
, "\0-*#\0", 5);
979 /* Put port in pIBSS */
980 case 8: /* No pseudo-IBSS in wireless extensions (yet) */
981 porttype
= ZD1201_PORTTYPE_PSEUDOIBSS
;
984 porttype
= ZD1201_PORTTYPE_IBSS
;
987 porttype
= ZD1201_PORTTYPE_BSS
;
993 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFPORTTYPE
, porttype
);
996 if (zd
->monitor
&& !monitor
) {
998 *(__le16
*)buffer
= cpu_to_le16(zd
->essidlen
);
999 memcpy(buffer
+2, zd
->essid
, zd
->essidlen
);
1000 err
= zd1201_setconfig(zd
, ZD1201_RID_CNFDESIREDSSID
,
1001 buffer
, IW_ESSID_MAX_SIZE
+2, 1);
1005 zd
->monitor
= monitor
;
1006 /* If monitor mode is set we don't actually turn it on here since it
1007 * is done during mac reset anyway (see zd1201_mac_enable).
1009 zd1201_mac_reset(zd
);
1014 static int zd1201_get_mode(struct net_device
*dev
,
1015 struct iw_request_info
*info
, __u32
*mode
, char *extra
)
1017 struct zd1201
*zd
= netdev_priv(dev
);
1021 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFPORTTYPE
, &porttype
);
1025 case ZD1201_PORTTYPE_IBSS
:
1026 *mode
= IW_MODE_ADHOC
;
1028 case ZD1201_PORTTYPE_BSS
:
1029 *mode
= IW_MODE_INFRA
;
1031 case ZD1201_PORTTYPE_WDS
:
1032 *mode
= IW_MODE_REPEAT
;
1034 case ZD1201_PORTTYPE_PSEUDOIBSS
:
1035 *mode
= 8;/* No Pseudo-IBSS... */
1037 case ZD1201_PORTTYPE_AP
:
1038 *mode
= IW_MODE_MASTER
;
1041 dev_dbg(&zd
->usb
->dev
, "Unknown porttype: %d\n",
1043 *mode
= IW_MODE_AUTO
;
1046 *mode
= IW_MODE_MONITOR
;
1051 static int zd1201_get_range(struct net_device
*dev
,
1052 struct iw_request_info
*info
, struct iw_point
*wrq
, char *extra
)
1054 struct iw_range
*range
= (struct iw_range
*)extra
;
1056 wrq
->length
= sizeof(struct iw_range
);
1057 memset(range
, 0, sizeof(struct iw_range
));
1058 range
->we_version_compiled
= WIRELESS_EXT
;
1059 range
->we_version_source
= WIRELESS_EXT
;
1061 range
->max_qual
.qual
= 128;
1062 range
->max_qual
.level
= 128;
1063 range
->max_qual
.noise
= 128;
1064 range
->max_qual
.updated
= 7;
1066 range
->encoding_size
[0] = 5;
1067 range
->encoding_size
[1] = 13;
1068 range
->num_encoding_sizes
= 2;
1069 range
->max_encoding_tokens
= ZD1201_NUMKEYS
;
1071 range
->num_bitrates
= 4;
1072 range
->bitrate
[0] = 1000000;
1073 range
->bitrate
[1] = 2000000;
1074 range
->bitrate
[2] = 5500000;
1075 range
->bitrate
[3] = 11000000;
1078 range
->min_frag
= ZD1201_FRAGMIN
;
1079 range
->max_rts
= ZD1201_RTSMAX
;
1080 range
->min_frag
= ZD1201_FRAGMAX
;
1085 /* Little bit of magic here: we only get the quality if we poll
1086 * for it, and we never get an actual request to trigger such
1087 * a poll. Therefore we 'assume' that the user will soon ask for
1088 * the stats after asking the bssid.
1090 static int zd1201_get_wap(struct net_device
*dev
,
1091 struct iw_request_info
*info
, struct sockaddr
*ap_addr
, char *extra
)
1093 struct zd1201
*zd
= netdev_priv(dev
);
1094 unsigned char buffer
[6];
1096 if (!zd1201_getconfig(zd
, ZD1201_RID_COMMSQUALITY
, buffer
, 6)) {
1097 /* Unfortunately the quality and noise reported is useless.
1098 they seem to be accumulators that increase until you
1099 read them, unless we poll on a fixed interval we can't
1102 /*zd->iwstats.qual.qual = le16_to_cpu(((__le16 *)buffer)[0]);*/
1103 zd
->iwstats
.qual
.level
= le16_to_cpu(((__le16
*)buffer
)[1]);
1104 /*zd->iwstats.qual.noise = le16_to_cpu(((__le16 *)buffer)[2]);*/
1105 zd
->iwstats
.qual
.updated
= 2;
1108 return zd1201_getconfig(zd
, ZD1201_RID_CURRENTBSSID
, ap_addr
->sa_data
, 6);
1111 static int zd1201_set_scan(struct net_device
*dev
,
1112 struct iw_request_info
*info
, struct iw_point
*srq
, char *extra
)
1114 /* We do everything in get_scan */
1118 static int zd1201_get_scan(struct net_device
*dev
,
1119 struct iw_request_info
*info
, struct iw_point
*srq
, char *extra
)
1121 struct zd1201
*zd
= netdev_priv(dev
);
1122 int err
, i
, j
, enabled_save
;
1123 struct iw_event iwe
;
1125 char *end_buf
= extra
+ IW_SCAN_MAX_DATA
;
1127 /* No scanning in AP mode */
1131 /* Scan doesn't seem to work if disabled */
1132 enabled_save
= zd
->mac_enabled
;
1136 err
= zd1201_docmd(zd
, ZD1201_CMDCODE_INQUIRE
,
1137 ZD1201_INQ_SCANRESULTS
, 0, 0);
1141 wait_event_interruptible(zd
->rxdataq
, zd
->rxdatas
);
1145 if (le16_to_cpu(*(__le16
*)&zd
->rxdata
[2]) != ZD1201_INQ_SCANRESULTS
)
1148 for(i
=8; i
<zd
->rxlen
; i
+=62) {
1149 iwe
.cmd
= SIOCGIWAP
;
1150 iwe
.u
.ap_addr
.sa_family
= ARPHRD_ETHER
;
1151 memcpy(iwe
.u
.ap_addr
.sa_data
, zd
->rxdata
+i
+6, 6);
1152 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1153 &iwe
, IW_EV_ADDR_LEN
);
1155 iwe
.cmd
= SIOCGIWESSID
;
1156 iwe
.u
.data
.length
= zd
->rxdata
[i
+16];
1157 iwe
.u
.data
.flags
= 1;
1158 cev
= iwe_stream_add_point(info
, cev
, end_buf
,
1159 &iwe
, zd
->rxdata
+i
+18);
1161 iwe
.cmd
= SIOCGIWMODE
;
1162 if (zd
->rxdata
[i
+14]&0x01)
1163 iwe
.u
.mode
= IW_MODE_MASTER
;
1165 iwe
.u
.mode
= IW_MODE_ADHOC
;
1166 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1167 &iwe
, IW_EV_UINT_LEN
);
1169 iwe
.cmd
= SIOCGIWFREQ
;
1170 iwe
.u
.freq
.m
= zd
->rxdata
[i
+0];
1172 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1173 &iwe
, IW_EV_FREQ_LEN
);
1175 iwe
.cmd
= SIOCGIWRATE
;
1176 iwe
.u
.bitrate
.fixed
= 0;
1177 iwe
.u
.bitrate
.disabled
= 0;
1178 for (j
=0; j
<10; j
++) if (zd
->rxdata
[i
+50+j
]) {
1179 iwe
.u
.bitrate
.value
= (zd
->rxdata
[i
+50+j
]&0x7f)*500000;
1180 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1181 &iwe
, IW_EV_PARAM_LEN
);
1184 iwe
.cmd
= SIOCGIWENCODE
;
1185 iwe
.u
.data
.length
= 0;
1186 if (zd
->rxdata
[i
+14]&0x10)
1187 iwe
.u
.data
.flags
= IW_ENCODE_ENABLED
;
1189 iwe
.u
.data
.flags
= IW_ENCODE_DISABLED
;
1190 cev
= iwe_stream_add_point(info
, cev
, end_buf
, &iwe
, NULL
);
1193 iwe
.u
.qual
.qual
= zd
->rxdata
[i
+4];
1194 iwe
.u
.qual
.noise
= zd
->rxdata
[i
+2]/10-100;
1195 iwe
.u
.qual
.level
= (256+zd
->rxdata
[i
+4]*100)/255-100;
1196 iwe
.u
.qual
.updated
= 7;
1197 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1198 &iwe
, IW_EV_QUAL_LEN
);
1204 srq
->length
= cev
- extra
;
1210 static int zd1201_set_essid(struct net_device
*dev
,
1211 struct iw_request_info
*info
, struct iw_point
*data
, char *essid
)
1213 struct zd1201
*zd
= netdev_priv(dev
);
1215 if (data
->length
> IW_ESSID_MAX_SIZE
)
1217 if (data
->length
< 1)
1219 zd
->essidlen
= data
->length
;
1220 memset(zd
->essid
, 0, IW_ESSID_MAX_SIZE
+1);
1221 memcpy(zd
->essid
, essid
, data
->length
);
1222 return zd1201_join(zd
, zd
->essid
, zd
->essidlen
);
1225 static int zd1201_get_essid(struct net_device
*dev
,
1226 struct iw_request_info
*info
, struct iw_point
*data
, char *essid
)
1228 struct zd1201
*zd
= netdev_priv(dev
);
1230 memcpy(essid
, zd
->essid
, zd
->essidlen
);
1232 data
->length
= zd
->essidlen
;
1237 static int zd1201_get_nick(struct net_device
*dev
, struct iw_request_info
*info
,
1238 struct iw_point
*data
, char *nick
)
1240 strcpy(nick
, "zd1201");
1242 data
->length
= strlen(nick
);
1246 static int zd1201_set_rate(struct net_device
*dev
,
1247 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1249 struct zd1201
*zd
= netdev_priv(dev
);
1253 switch (rrq
->value
) {
1255 rate
= ZD1201_RATEB1
;
1258 rate
= ZD1201_RATEB2
;
1261 rate
= ZD1201_RATEB5
;
1265 rate
= ZD1201_RATEB11
;
1268 if (!rrq
->fixed
) { /* Also enable all lower bitrates */
1272 err
= zd1201_setconfig16(zd
, ZD1201_RID_TXRATECNTL
, rate
);
1276 return zd1201_mac_reset(zd
);
1279 static int zd1201_get_rate(struct net_device
*dev
,
1280 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1282 struct zd1201
*zd
= netdev_priv(dev
);
1286 err
= zd1201_getconfig16(zd
, ZD1201_RID_CURRENTTXRATE
, &rate
);
1292 rrq
->value
= 1000000;
1295 rrq
->value
= 2000000;
1298 rrq
->value
= 5500000;
1301 rrq
->value
= 11000000;
1312 static int zd1201_set_rts(struct net_device
*dev
, struct iw_request_info
*info
,
1313 struct iw_param
*rts
, char *extra
)
1315 struct zd1201
*zd
= netdev_priv(dev
);
1317 short val
= rts
->value
;
1319 if (rts
->disabled
|| !rts
->fixed
)
1320 val
= ZD1201_RTSMAX
;
1321 if (val
> ZD1201_RTSMAX
)
1326 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFRTSTHRESHOLD
, val
);
1329 return zd1201_mac_reset(zd
);
1332 static int zd1201_get_rts(struct net_device
*dev
, struct iw_request_info
*info
,
1333 struct iw_param
*rts
, char *extra
)
1335 struct zd1201
*zd
= netdev_priv(dev
);
1339 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFRTSTHRESHOLD
, &rtst
);
1343 rts
->disabled
= (rts
->value
== ZD1201_RTSMAX
);
1349 static int zd1201_set_frag(struct net_device
*dev
, struct iw_request_info
*info
,
1350 struct iw_param
*frag
, char *extra
)
1352 struct zd1201
*zd
= netdev_priv(dev
);
1354 short val
= frag
->value
;
1356 if (frag
->disabled
|| !frag
->fixed
)
1357 val
= ZD1201_FRAGMAX
;
1358 if (val
> ZD1201_FRAGMAX
)
1360 if (val
< ZD1201_FRAGMIN
)
1364 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFFRAGTHRESHOLD
, val
);
1367 return zd1201_mac_reset(zd
);
1370 static int zd1201_get_frag(struct net_device
*dev
, struct iw_request_info
*info
,
1371 struct iw_param
*frag
, char *extra
)
1373 struct zd1201
*zd
= netdev_priv(dev
);
1377 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFFRAGTHRESHOLD
, &fragt
);
1380 frag
->value
= fragt
;
1381 frag
->disabled
= (frag
->value
== ZD1201_FRAGMAX
);
1387 static int zd1201_set_retry(struct net_device
*dev
,
1388 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1393 static int zd1201_get_retry(struct net_device
*dev
,
1394 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1399 static int zd1201_set_encode(struct net_device
*dev
,
1400 struct iw_request_info
*info
, struct iw_point
*erq
, char *key
)
1402 struct zd1201
*zd
= netdev_priv(dev
);
1406 if (erq
->length
> ZD1201_MAXKEYLEN
)
1409 i
= (erq
->flags
& IW_ENCODE_INDEX
)-1;
1411 err
= zd1201_getconfig16(zd
,ZD1201_RID_CNFDEFAULTKEYID
,&i
);
1415 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFDEFAULTKEYID
, i
);
1420 if (i
< 0 || i
>= ZD1201_NUMKEYS
)
1423 rid
= ZD1201_RID_CNFDEFAULTKEY0
+ i
;
1424 err
= zd1201_setconfig(zd
, rid
, key
, erq
->length
, 1);
1427 zd
->encode_keylen
[i
] = erq
->length
;
1428 memcpy(zd
->encode_keys
[i
], key
, erq
->length
);
1431 if (!(erq
->flags
& IW_ENCODE_DISABLED
& IW_ENCODE_MODE
)) {
1433 zd
->encode_enabled
= 1;
1435 zd
->encode_enabled
= 0;
1436 if (erq
->flags
& IW_ENCODE_RESTRICTED
& IW_ENCODE_MODE
) {
1438 zd
->encode_restricted
= 1;
1440 zd
->encode_restricted
= 0;
1441 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFWEBFLAGS
, i
);
1445 if (zd
->encode_enabled
)
1446 i
= ZD1201_CNFAUTHENTICATION_SHAREDKEY
;
1448 i
= ZD1201_CNFAUTHENTICATION_OPENSYSTEM
;
1449 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFAUTHENTICATION
, i
);
1453 return zd1201_mac_reset(zd
);
1456 static int zd1201_get_encode(struct net_device
*dev
,
1457 struct iw_request_info
*info
, struct iw_point
*erq
, char *key
)
1459 struct zd1201
*zd
= netdev_priv(dev
);
1463 if (zd
->encode_enabled
)
1464 erq
->flags
= IW_ENCODE_ENABLED
;
1466 erq
->flags
= IW_ENCODE_DISABLED
;
1467 if (zd
->encode_restricted
)
1468 erq
->flags
|= IW_ENCODE_RESTRICTED
;
1470 erq
->flags
|= IW_ENCODE_OPEN
;
1472 i
= (erq
->flags
& IW_ENCODE_INDEX
) -1;
1474 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFDEFAULTKEYID
, &i
);
1478 if (i
<0 || i
>= ZD1201_NUMKEYS
)
1483 erq
->length
= zd
->encode_keylen
[i
];
1484 memcpy(key
, zd
->encode_keys
[i
], erq
->length
);
1489 static int zd1201_set_power(struct net_device
*dev
,
1490 struct iw_request_info
*info
, struct iw_param
*vwrq
, char *extra
)
1492 struct zd1201
*zd
= netdev_priv(dev
);
1493 short enabled
, duration
, level
;
1496 enabled
= vwrq
->disabled
? 0 : 1;
1498 if (vwrq
->flags
& IW_POWER_PERIOD
) {
1499 duration
= vwrq
->value
;
1500 err
= zd1201_setconfig16(zd
,
1501 ZD1201_RID_CNFMAXSLEEPDURATION
, duration
);
1506 if (vwrq
->flags
& IW_POWER_TIMEOUT
) {
1507 err
= zd1201_getconfig16(zd
,
1508 ZD1201_RID_CNFMAXSLEEPDURATION
, &duration
);
1511 level
= vwrq
->value
* 4 / duration
;
1516 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFPMEPS
,
1525 return zd1201_setconfig16(zd
, ZD1201_RID_CNFPMENABLED
, enabled
);
1528 static int zd1201_get_power(struct net_device
*dev
,
1529 struct iw_request_info
*info
, struct iw_param
*vwrq
, char *extra
)
1531 struct zd1201
*zd
= netdev_priv(dev
);
1532 short enabled
, level
, duration
;
1535 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFPMENABLED
, &enabled
);
1538 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFPMEPS
, &level
);
1541 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFMAXSLEEPDURATION
, &duration
);
1544 vwrq
->disabled
= enabled
? 0 : 1;
1545 if (vwrq
->flags
& IW_POWER_TYPE
) {
1546 if (vwrq
->flags
& IW_POWER_PERIOD
) {
1547 vwrq
->value
= duration
;
1548 vwrq
->flags
= IW_POWER_PERIOD
;
1550 vwrq
->value
= duration
* level
/ 4;
1551 vwrq
->flags
= IW_POWER_TIMEOUT
;
1554 if (vwrq
->flags
& IW_POWER_MODE
) {
1555 if (enabled
&& level
)
1556 vwrq
->flags
= IW_POWER_UNICAST_R
;
1558 vwrq
->flags
= IW_POWER_ALL_R
;
1565 static const iw_handler zd1201_iw_handler
[] =
1567 (iw_handler
) zd1201_config_commit
, /* SIOCSIWCOMMIT */
1568 (iw_handler
) zd1201_get_name
, /* SIOCGIWNAME */
1569 (iw_handler
) NULL
, /* SIOCSIWNWID */
1570 (iw_handler
) NULL
, /* SIOCGIWNWID */
1571 (iw_handler
) zd1201_set_freq
, /* SIOCSIWFREQ */
1572 (iw_handler
) zd1201_get_freq
, /* SIOCGIWFREQ */
1573 (iw_handler
) zd1201_set_mode
, /* SIOCSIWMODE */
1574 (iw_handler
) zd1201_get_mode
, /* SIOCGIWMODE */
1575 (iw_handler
) NULL
, /* SIOCSIWSENS */
1576 (iw_handler
) NULL
, /* SIOCGIWSENS */
1577 (iw_handler
) NULL
, /* SIOCSIWRANGE */
1578 (iw_handler
) zd1201_get_range
, /* SIOCGIWRANGE */
1579 (iw_handler
) NULL
, /* SIOCSIWPRIV */
1580 (iw_handler
) NULL
, /* SIOCGIWPRIV */
1581 (iw_handler
) NULL
, /* SIOCSIWSTATS */
1582 (iw_handler
) NULL
, /* SIOCGIWSTATS */
1583 (iw_handler
) NULL
, /* SIOCSIWSPY */
1584 (iw_handler
) NULL
, /* SIOCGIWSPY */
1585 (iw_handler
) NULL
, /* -- hole -- */
1586 (iw_handler
) NULL
, /* -- hole -- */
1587 (iw_handler
) NULL
/*zd1201_set_wap*/, /* SIOCSIWAP */
1588 (iw_handler
) zd1201_get_wap
, /* SIOCGIWAP */
1589 (iw_handler
) NULL
, /* -- hole -- */
1590 (iw_handler
) NULL
, /* SIOCGIWAPLIST */
1591 (iw_handler
) zd1201_set_scan
, /* SIOCSIWSCAN */
1592 (iw_handler
) zd1201_get_scan
, /* SIOCGIWSCAN */
1593 (iw_handler
) zd1201_set_essid
, /* SIOCSIWESSID */
1594 (iw_handler
) zd1201_get_essid
, /* SIOCGIWESSID */
1595 (iw_handler
) NULL
, /* SIOCSIWNICKN */
1596 (iw_handler
) zd1201_get_nick
, /* SIOCGIWNICKN */
1597 (iw_handler
) NULL
, /* -- hole -- */
1598 (iw_handler
) NULL
, /* -- hole -- */
1599 (iw_handler
) zd1201_set_rate
, /* SIOCSIWRATE */
1600 (iw_handler
) zd1201_get_rate
, /* SIOCGIWRATE */
1601 (iw_handler
) zd1201_set_rts
, /* SIOCSIWRTS */
1602 (iw_handler
) zd1201_get_rts
, /* SIOCGIWRTS */
1603 (iw_handler
) zd1201_set_frag
, /* SIOCSIWFRAG */
1604 (iw_handler
) zd1201_get_frag
, /* SIOCGIWFRAG */
1605 (iw_handler
) NULL
, /* SIOCSIWTXPOW */
1606 (iw_handler
) NULL
, /* SIOCGIWTXPOW */
1607 (iw_handler
) zd1201_set_retry
, /* SIOCSIWRETRY */
1608 (iw_handler
) zd1201_get_retry
, /* SIOCGIWRETRY */
1609 (iw_handler
) zd1201_set_encode
, /* SIOCSIWENCODE */
1610 (iw_handler
) zd1201_get_encode
, /* SIOCGIWENCODE */
1611 (iw_handler
) zd1201_set_power
, /* SIOCSIWPOWER */
1612 (iw_handler
) zd1201_get_power
, /* SIOCGIWPOWER */
1615 static int zd1201_set_hostauth(struct net_device
*dev
,
1616 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1618 struct zd1201
*zd
= netdev_priv(dev
);
1623 return zd1201_setconfig16(zd
, ZD1201_RID_CNFHOSTAUTH
, rrq
->value
);
1626 static int zd1201_get_hostauth(struct net_device
*dev
,
1627 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1629 struct zd1201
*zd
= netdev_priv(dev
);
1636 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFHOSTAUTH
, &hostauth
);
1639 rrq
->value
= hostauth
;
1645 static int zd1201_auth_sta(struct net_device
*dev
,
1646 struct iw_request_info
*info
, struct sockaddr
*sta
, char *extra
)
1648 struct zd1201
*zd
= netdev_priv(dev
);
1649 unsigned char buffer
[10];
1654 memcpy(buffer
, sta
->sa_data
, ETH_ALEN
);
1655 *(short*)(buffer
+6) = 0; /* 0==success, 1==failure */
1656 *(short*)(buffer
+8) = 0;
1658 return zd1201_setconfig(zd
, ZD1201_RID_AUTHENTICATESTA
, buffer
, 10, 1);
1661 static int zd1201_set_maxassoc(struct net_device
*dev
,
1662 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1664 struct zd1201
*zd
= netdev_priv(dev
);
1670 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFMAXASSOCSTATIONS
, rrq
->value
);
1676 static int zd1201_get_maxassoc(struct net_device
*dev
,
1677 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1679 struct zd1201
*zd
= netdev_priv(dev
);
1686 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFMAXASSOCSTATIONS
, &maxassoc
);
1689 rrq
->value
= maxassoc
;
1695 static const iw_handler zd1201_private_handler
[] = {
1696 (iw_handler
) zd1201_set_hostauth
, /* ZD1201SIWHOSTAUTH */
1697 (iw_handler
) zd1201_get_hostauth
, /* ZD1201GIWHOSTAUTH */
1698 (iw_handler
) zd1201_auth_sta
, /* ZD1201SIWAUTHSTA */
1699 (iw_handler
) NULL
, /* nothing to get */
1700 (iw_handler
) zd1201_set_maxassoc
, /* ZD1201SIMAXASSOC */
1701 (iw_handler
) zd1201_get_maxassoc
, /* ZD1201GIMAXASSOC */
1704 static const struct iw_priv_args zd1201_private_args
[] = {
1705 { ZD1201SIWHOSTAUTH
, IW_PRIV_TYPE_INT
| IW_PRIV_SIZE_FIXED
| 1,
1706 IW_PRIV_TYPE_NONE
, "sethostauth" },
1707 { ZD1201GIWHOSTAUTH
, IW_PRIV_TYPE_NONE
,
1708 IW_PRIV_TYPE_INT
| IW_PRIV_SIZE_FIXED
| 1, "gethostauth" },
1709 { ZD1201SIWAUTHSTA
, IW_PRIV_TYPE_ADDR
| IW_PRIV_SIZE_FIXED
| 1,
1710 IW_PRIV_TYPE_NONE
, "authstation" },
1711 { ZD1201SIWMAXASSOC
, IW_PRIV_TYPE_INT
| IW_PRIV_SIZE_FIXED
| 1,
1712 IW_PRIV_TYPE_NONE
, "setmaxassoc" },
1713 { ZD1201GIWMAXASSOC
, IW_PRIV_TYPE_NONE
,
1714 IW_PRIV_TYPE_INT
| IW_PRIV_SIZE_FIXED
| 1, "getmaxassoc" },
1717 static const struct iw_handler_def zd1201_iw_handlers
= {
1718 .num_standard
= ARRAY_SIZE(zd1201_iw_handler
),
1719 .num_private
= ARRAY_SIZE(zd1201_private_handler
),
1720 .num_private_args
= ARRAY_SIZE(zd1201_private_args
),
1721 .standard
= (iw_handler
*)zd1201_iw_handler
,
1722 .private = (iw_handler
*)zd1201_private_handler
,
1723 .private_args
= (struct iw_priv_args
*) zd1201_private_args
,
1724 .get_wireless_stats
= zd1201_get_wireless_stats
,
1727 static int zd1201_probe(struct usb_interface
*interface
,
1728 const struct usb_device_id
*id
)
1731 struct net_device
*dev
;
1732 struct usb_device
*usb
;
1735 char buf
[IW_ESSID_MAX_SIZE
+2];
1737 usb
= interface_to_usbdev(interface
);
1739 dev
= alloc_etherdev(sizeof(*zd
));
1742 zd
= netdev_priv(dev
);
1748 init_waitqueue_head(&zd
->rxdataq
);
1749 INIT_HLIST_HEAD(&zd
->fraglist
);
1751 err
= zd1201_fw_upload(usb
, zd
->ap
);
1753 dev_err(&usb
->dev
, "zd1201 firmware upload failed: %d\n", err
);
1760 zd
->rx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
1761 zd
->tx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
1762 if (!zd
->rx_urb
|| !zd
->tx_urb
)
1766 err
= zd1201_drvr_start(zd
);
1770 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFMAXDATALEN
, 2312);
1774 err
= zd1201_setconfig16(zd
, ZD1201_RID_TXRATECNTL
,
1775 ZD1201_RATEB1
| ZD1201_RATEB2
| ZD1201_RATEB5
| ZD1201_RATEB11
);
1779 dev
->open
= zd1201_net_open
;
1780 dev
->stop
= zd1201_net_stop
;
1781 dev
->get_stats
= zd1201_get_stats
;
1782 dev
->wireless_handlers
=
1783 (struct iw_handler_def
*)&zd1201_iw_handlers
;
1784 dev
->hard_start_xmit
= zd1201_hard_start_xmit
;
1785 dev
->watchdog_timeo
= ZD1201_TX_TIMEOUT
;
1786 dev
->tx_timeout
= zd1201_tx_timeout
;
1787 dev
->set_multicast_list
= zd1201_set_multicast
;
1788 dev
->set_mac_address
= zd1201_set_mac_address
;
1789 strcpy(dev
->name
, "wlan%d");
1791 err
= zd1201_getconfig(zd
, ZD1201_RID_CNFOWNMACADDR
,
1792 dev
->dev_addr
, dev
->addr_len
);
1796 /* Set wildcard essid to match zd->essid */
1797 *(__le16
*)buf
= cpu_to_le16(0);
1798 err
= zd1201_setconfig(zd
, ZD1201_RID_CNFDESIREDSSID
, buf
,
1799 IW_ESSID_MAX_SIZE
+2, 1);
1804 porttype
= ZD1201_PORTTYPE_AP
;
1806 porttype
= ZD1201_PORTTYPE_BSS
;
1807 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFPORTTYPE
, porttype
);
1811 SET_NETDEV_DEV(dev
, &usb
->dev
);
1813 err
= register_netdev(dev
);
1816 dev_info(&usb
->dev
, "%s: ZD1201 USB Wireless interface\n",
1819 usb_set_intfdata(interface
, zd
);
1820 zd1201_enable(zd
); /* zd1201 likes to startup enabled, */
1821 zd1201_disable(zd
); /* interfering with all the wifis in range */
1825 /* Leave the device in reset state */
1826 zd1201_docmd(zd
, ZD1201_CMDCODE_INIT
, 0, 0, 0);
1828 usb_free_urb(zd
->tx_urb
);
1829 usb_free_urb(zd
->rx_urb
);
1834 static void zd1201_disconnect(struct usb_interface
*interface
)
1836 struct zd1201
*zd
=(struct zd1201
*)usb_get_intfdata(interface
);
1837 struct hlist_node
*node
, *node2
;
1838 struct zd1201_frag
*frag
;
1842 usb_set_intfdata(interface
, NULL
);
1844 hlist_for_each_entry_safe(frag
, node
, node2
, &zd
->fraglist
, fnode
) {
1845 hlist_del_init(&frag
->fnode
);
1846 kfree_skb(frag
->skb
);
1851 usb_kill_urb(zd
->tx_urb
);
1852 usb_free_urb(zd
->tx_urb
);
1855 usb_kill_urb(zd
->rx_urb
);
1856 usb_free_urb(zd
->rx_urb
);
1860 unregister_netdev(zd
->dev
);
1861 free_netdev(zd
->dev
);
1867 static int zd1201_suspend(struct usb_interface
*interface
,
1868 pm_message_t message
)
1870 struct zd1201
*zd
= usb_get_intfdata(interface
);
1872 netif_device_detach(zd
->dev
);
1874 zd
->was_enabled
= zd
->mac_enabled
;
1876 if (zd
->was_enabled
)
1877 return zd1201_disable(zd
);
1882 static int zd1201_resume(struct usb_interface
*interface
)
1884 struct zd1201
*zd
= usb_get_intfdata(interface
);
1886 if (!zd
|| !zd
->dev
)
1889 netif_device_attach(zd
->dev
);
1891 if (zd
->was_enabled
)
1892 return zd1201_enable(zd
);
1899 #define zd1201_suspend NULL
1900 #define zd1201_resume NULL
1904 static struct usb_driver zd1201_usb
= {
1906 .probe
= zd1201_probe
,
1907 .disconnect
= zd1201_disconnect
,
1908 .id_table
= zd1201_table
,
1909 .suspend
= zd1201_suspend
,
1910 .resume
= zd1201_resume
,
1913 static int __init
zd1201_init(void)
1915 return usb_register(&zd1201_usb
);
1918 static void __exit
zd1201_cleanup(void)
1920 usb_deregister(&zd1201_usb
);
1923 module_init(zd1201_init
);
1924 module_exit(zd1201_cleanup
);