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
)
599 err
= zd1201_getconfig(zd
, rid
, &zdval
, sizeof(__le16
));
602 *val
= le16_to_cpu(zdval
);
606 static inline int zd1201_setconfig16(struct zd1201
*zd
, int rid
, short val
)
608 __le16 zdval
= cpu_to_le16(val
);
609 return (zd1201_setconfig(zd
, rid
, &zdval
, sizeof(__le16
), 1));
612 static int zd1201_drvr_start(struct zd1201
*zd
)
617 unsigned char *buffer
;
619 buffer
= kzalloc(ZD1201_RXSIZE
, GFP_KERNEL
);
623 usb_fill_bulk_urb(zd
->rx_urb
, zd
->usb
,
624 usb_rcvbulkpipe(zd
->usb
, zd
->endp_in
), buffer
, ZD1201_RXSIZE
,
627 err
= usb_submit_urb(zd
->rx_urb
, GFP_KERNEL
);
631 err
= zd1201_docmd(zd
, ZD1201_CMDCODE_INIT
, 0, 0, 0);
635 err
= zd1201_getconfig(zd
, ZD1201_RID_CNFMAXTXBUFFERNUMBER
, &zdmax
,
640 max
= le16_to_cpu(zdmax
);
641 for (i
=0; i
<max
; i
++) {
642 err
= zd1201_docmd(zd
, ZD1201_CMDCODE_ALLOC
, 1514, 0, 0);
650 usb_kill_urb(zd
->rx_urb
);
657 /* Magic alert: The firmware doesn't seem to like the MAC state being
658 * toggled in promisc (aka monitor) mode.
659 * (It works a number of times, but will halt eventually)
660 * So we turn it of before disabling and on after enabling if needed.
662 static int zd1201_enable(struct zd1201
*zd
)
669 err
= zd1201_docmd(zd
, ZD1201_CMDCODE_ENABLE
, 0, 0, 0);
674 err
= zd1201_setconfig16(zd
, ZD1201_RID_PROMISCUOUSMODE
, 1);
679 static int zd1201_disable(struct zd1201
*zd
)
683 if (!zd
->mac_enabled
)
686 err
= zd1201_setconfig16(zd
, ZD1201_RID_PROMISCUOUSMODE
, 0);
691 err
= zd1201_docmd(zd
, ZD1201_CMDCODE_DISABLE
, 0, 0, 0);
697 static int zd1201_mac_reset(struct zd1201
*zd
)
699 if (!zd
->mac_enabled
)
702 return zd1201_enable(zd
);
705 static int zd1201_join(struct zd1201
*zd
, char *essid
, int essidlen
)
708 char buf
[IW_ESSID_MAX_SIZE
+2];
710 err
= zd1201_disable(zd
);
714 val
= ZD1201_CNFAUTHENTICATION_OPENSYSTEM
;
715 val
|= ZD1201_CNFAUTHENTICATION_SHAREDKEY
;
716 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFAUTHENTICATION
, val
);
720 *(__le16
*)buf
= cpu_to_le16(essidlen
);
721 memcpy(buf
+2, essid
, essidlen
);
722 if (!zd
->ap
) { /* Normal station */
723 err
= zd1201_setconfig(zd
, ZD1201_RID_CNFDESIREDSSID
, buf
,
724 IW_ESSID_MAX_SIZE
+2, 1);
728 err
= zd1201_setconfig(zd
, ZD1201_RID_CNFOWNSSID
, buf
,
729 IW_ESSID_MAX_SIZE
+2, 1);
734 err
= zd1201_setconfig(zd
, ZD1201_RID_CNFOWNMACADDR
,
735 zd
->dev
->dev_addr
, zd
->dev
->addr_len
, 1);
739 err
= zd1201_enable(zd
);
747 static int zd1201_net_open(struct net_device
*dev
)
749 struct zd1201
*zd
= netdev_priv(dev
);
751 /* Start MAC with wildcard if no essid set */
752 if (!zd
->mac_enabled
)
753 zd1201_join(zd
, zd
->essid
, zd
->essidlen
);
754 netif_start_queue(dev
);
759 static int zd1201_net_stop(struct net_device
*dev
)
761 netif_stop_queue(dev
);
766 RFC 1042 encapsulates Ethernet frames in 802.11 frames
767 by prefixing them with 0xaa, 0xaa, 0x03) followed by a SNAP OID of 0
768 (0x00, 0x00, 0x00). Zd requires an additional padding, copy
769 of ethernet addresses, length of the standard RFC 1042 packet
770 and a command byte (which is nul for tx).
772 tx frame (from Wlan NG):
774 llc 0xAA 0xAA 0x03 (802.2 LLC)
775 snap 0x00 0x00 0x00 (Ethernet encapsulated)
776 type 2 bytes, Ethernet type field
777 payload (minus eth header)
779 padding 1B if (skb->len+8+1)%64==0
780 Eth MAC addr 12 bytes, Ethernet MAC addresses
781 length 2 bytes, RFC 1042 packet length
782 (llc+snap+type+payload)
783 zd 1 null byte, zd1201 packet type
785 static int zd1201_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
787 struct zd1201
*zd
= netdev_priv(dev
);
788 unsigned char *txbuf
= zd
->txdata
;
789 int txbuflen
, pad
= 0, err
;
790 struct urb
*urb
= zd
->tx_urb
;
792 if (!zd
->mac_enabled
|| zd
->monitor
) {
793 zd
->stats
.tx_dropped
++;
797 netif_stop_queue(dev
);
799 txbuflen
= skb
->len
+ 8 + 1;
800 if (txbuflen
%64 == 0) {
807 txbuf
[3] = 0x00; /* rfc1042 */
811 skb_copy_from_linear_data_offset(skb
, 12, txbuf
+ 6, skb
->len
- 12);
813 txbuf
[skb
->len
-12+6]=0;
814 skb_copy_from_linear_data(skb
, txbuf
+ skb
->len
- 12 + 6 + pad
, 12);
815 *(__be16
*)&txbuf
[skb
->len
+6+pad
] = htons(skb
->len
-12+6);
816 txbuf
[txbuflen
-1] = 0;
818 usb_fill_bulk_urb(urb
, zd
->usb
, usb_sndbulkpipe(zd
->usb
, zd
->endp_out
),
819 txbuf
, txbuflen
, zd1201_usbtx
, zd
);
821 err
= usb_submit_urb(zd
->tx_urb
, GFP_ATOMIC
);
823 zd
->stats
.tx_errors
++;
824 netif_start_queue(dev
);
827 zd
->stats
.tx_packets
++;
828 zd
->stats
.tx_bytes
+= skb
->len
;
829 dev
->trans_start
= jiffies
;
835 static void zd1201_tx_timeout(struct net_device
*dev
)
837 struct zd1201
*zd
= netdev_priv(dev
);
841 dev_warn(&zd
->usb
->dev
, "%s: TX timeout, shooting down urb\n",
843 usb_unlink_urb(zd
->tx_urb
);
844 zd
->stats
.tx_errors
++;
845 /* Restart the timeout to quiet the watchdog: */
846 dev
->trans_start
= jiffies
;
849 static int zd1201_set_mac_address(struct net_device
*dev
, void *p
)
851 struct sockaddr
*addr
= p
;
852 struct zd1201
*zd
= netdev_priv(dev
);
858 err
= zd1201_setconfig(zd
, ZD1201_RID_CNFOWNMACADDR
,
859 addr
->sa_data
, dev
->addr_len
, 1);
862 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
864 return zd1201_mac_reset(zd
);
867 static struct net_device_stats
*zd1201_get_stats(struct net_device
*dev
)
869 struct zd1201
*zd
= netdev_priv(dev
);
874 static struct iw_statistics
*zd1201_get_wireless_stats(struct net_device
*dev
)
876 struct zd1201
*zd
= netdev_priv(dev
);
881 static void zd1201_set_multicast(struct net_device
*dev
)
883 struct zd1201
*zd
= netdev_priv(dev
);
884 struct dev_mc_list
*mc
= dev
->mc_list
;
885 unsigned char reqbuf
[ETH_ALEN
*ZD1201_MAXMULTI
];
888 if (dev
->mc_count
> ZD1201_MAXMULTI
)
891 for (i
=0; i
<dev
->mc_count
; i
++) {
892 memcpy(reqbuf
+i
*ETH_ALEN
, mc
->dmi_addr
, ETH_ALEN
);
895 zd1201_setconfig(zd
, ZD1201_RID_CNFGROUPADDRESS
, reqbuf
,
896 dev
->mc_count
*ETH_ALEN
, 0);
900 static int zd1201_config_commit(struct net_device
*dev
,
901 struct iw_request_info
*info
, struct iw_point
*data
, char *essid
)
903 struct zd1201
*zd
= netdev_priv(dev
);
905 return zd1201_mac_reset(zd
);
908 static int zd1201_get_name(struct net_device
*dev
,
909 struct iw_request_info
*info
, char *name
, char *extra
)
911 strcpy(name
, "IEEE 802.11b");
915 static int zd1201_set_freq(struct net_device
*dev
,
916 struct iw_request_info
*info
, struct iw_freq
*freq
, char *extra
)
918 struct zd1201
*zd
= netdev_priv(dev
);
928 channel
= (freq
->m
-2407)/5;
931 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFOWNCHANNEL
, channel
);
935 zd1201_mac_reset(zd
);
940 static int zd1201_get_freq(struct net_device
*dev
,
941 struct iw_request_info
*info
, struct iw_freq
*freq
, char *extra
)
943 struct zd1201
*zd
= netdev_priv(dev
);
947 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFOWNCHANNEL
, &channel
);
956 static int zd1201_set_mode(struct net_device
*dev
,
957 struct iw_request_info
*info
, __u32
*mode
, char *extra
)
959 struct zd1201
*zd
= netdev_priv(dev
);
960 short porttype
, monitor
= 0;
961 unsigned char buffer
[IW_ESSID_MAX_SIZE
+2];
965 if (*mode
!= IW_MODE_MASTER
)
970 err
= zd1201_setconfig16(zd
, ZD1201_RID_PROMISCUOUSMODE
, 0);
973 zd
->dev
->type
= ARPHRD_ETHER
;
975 case IW_MODE_MONITOR
:
977 zd
->dev
->type
= ARPHRD_IEEE80211
;
978 /* Make sure we are no longer associated with by
979 setting an 'impossible' essid.
980 (otherwise we mess up firmware)
982 zd1201_join(zd
, "\0-*#\0", 5);
983 /* Put port in pIBSS */
984 case 8: /* No pseudo-IBSS in wireless extensions (yet) */
985 porttype
= ZD1201_PORTTYPE_PSEUDOIBSS
;
988 porttype
= ZD1201_PORTTYPE_IBSS
;
991 porttype
= ZD1201_PORTTYPE_BSS
;
997 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFPORTTYPE
, porttype
);
1000 if (zd
->monitor
&& !monitor
) {
1002 *(__le16
*)buffer
= cpu_to_le16(zd
->essidlen
);
1003 memcpy(buffer
+2, zd
->essid
, zd
->essidlen
);
1004 err
= zd1201_setconfig(zd
, ZD1201_RID_CNFDESIREDSSID
,
1005 buffer
, IW_ESSID_MAX_SIZE
+2, 1);
1009 zd
->monitor
= monitor
;
1010 /* If monitor mode is set we don't actually turn it on here since it
1011 * is done during mac reset anyway (see zd1201_mac_enable).
1013 zd1201_mac_reset(zd
);
1018 static int zd1201_get_mode(struct net_device
*dev
,
1019 struct iw_request_info
*info
, __u32
*mode
, char *extra
)
1021 struct zd1201
*zd
= netdev_priv(dev
);
1025 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFPORTTYPE
, &porttype
);
1029 case ZD1201_PORTTYPE_IBSS
:
1030 *mode
= IW_MODE_ADHOC
;
1032 case ZD1201_PORTTYPE_BSS
:
1033 *mode
= IW_MODE_INFRA
;
1035 case ZD1201_PORTTYPE_WDS
:
1036 *mode
= IW_MODE_REPEAT
;
1038 case ZD1201_PORTTYPE_PSEUDOIBSS
:
1039 *mode
= 8;/* No Pseudo-IBSS... */
1041 case ZD1201_PORTTYPE_AP
:
1042 *mode
= IW_MODE_MASTER
;
1045 dev_dbg(&zd
->usb
->dev
, "Unknown porttype: %d\n",
1047 *mode
= IW_MODE_AUTO
;
1050 *mode
= IW_MODE_MONITOR
;
1055 static int zd1201_get_range(struct net_device
*dev
,
1056 struct iw_request_info
*info
, struct iw_point
*wrq
, char *extra
)
1058 struct iw_range
*range
= (struct iw_range
*)extra
;
1060 wrq
->length
= sizeof(struct iw_range
);
1061 memset(range
, 0, sizeof(struct iw_range
));
1062 range
->we_version_compiled
= WIRELESS_EXT
;
1063 range
->we_version_source
= WIRELESS_EXT
;
1065 range
->max_qual
.qual
= 128;
1066 range
->max_qual
.level
= 128;
1067 range
->max_qual
.noise
= 128;
1068 range
->max_qual
.updated
= 7;
1070 range
->encoding_size
[0] = 5;
1071 range
->encoding_size
[1] = 13;
1072 range
->num_encoding_sizes
= 2;
1073 range
->max_encoding_tokens
= ZD1201_NUMKEYS
;
1075 range
->num_bitrates
= 4;
1076 range
->bitrate
[0] = 1000000;
1077 range
->bitrate
[1] = 2000000;
1078 range
->bitrate
[2] = 5500000;
1079 range
->bitrate
[3] = 11000000;
1082 range
->min_frag
= ZD1201_FRAGMIN
;
1083 range
->max_rts
= ZD1201_RTSMAX
;
1084 range
->min_frag
= ZD1201_FRAGMAX
;
1089 /* Little bit of magic here: we only get the quality if we poll
1090 * for it, and we never get an actual request to trigger such
1091 * a poll. Therefore we 'assume' that the user will soon ask for
1092 * the stats after asking the bssid.
1094 static int zd1201_get_wap(struct net_device
*dev
,
1095 struct iw_request_info
*info
, struct sockaddr
*ap_addr
, char *extra
)
1097 struct zd1201
*zd
= netdev_priv(dev
);
1098 unsigned char buffer
[6];
1100 if (!zd1201_getconfig(zd
, ZD1201_RID_COMMSQUALITY
, buffer
, 6)) {
1101 /* Unfortunately the quality and noise reported is useless.
1102 they seem to be accumulators that increase until you
1103 read them, unless we poll on a fixed interval we can't
1106 /*zd->iwstats.qual.qual = le16_to_cpu(((__le16 *)buffer)[0]);*/
1107 zd
->iwstats
.qual
.level
= le16_to_cpu(((__le16
*)buffer
)[1]);
1108 /*zd->iwstats.qual.noise = le16_to_cpu(((__le16 *)buffer)[2]);*/
1109 zd
->iwstats
.qual
.updated
= 2;
1112 return zd1201_getconfig(zd
, ZD1201_RID_CURRENTBSSID
, ap_addr
->sa_data
, 6);
1115 static int zd1201_set_scan(struct net_device
*dev
,
1116 struct iw_request_info
*info
, struct iw_point
*srq
, char *extra
)
1118 /* We do everything in get_scan */
1122 static int zd1201_get_scan(struct net_device
*dev
,
1123 struct iw_request_info
*info
, struct iw_point
*srq
, char *extra
)
1125 struct zd1201
*zd
= netdev_priv(dev
);
1126 int err
, i
, j
, enabled_save
;
1127 struct iw_event iwe
;
1129 char *end_buf
= extra
+ IW_SCAN_MAX_DATA
;
1131 /* No scanning in AP mode */
1135 /* Scan doesn't seem to work if disabled */
1136 enabled_save
= zd
->mac_enabled
;
1140 err
= zd1201_docmd(zd
, ZD1201_CMDCODE_INQUIRE
,
1141 ZD1201_INQ_SCANRESULTS
, 0, 0);
1145 wait_event_interruptible(zd
->rxdataq
, zd
->rxdatas
);
1149 if (le16_to_cpu(*(__le16
*)&zd
->rxdata
[2]) != ZD1201_INQ_SCANRESULTS
)
1152 for(i
=8; i
<zd
->rxlen
; i
+=62) {
1153 iwe
.cmd
= SIOCGIWAP
;
1154 iwe
.u
.ap_addr
.sa_family
= ARPHRD_ETHER
;
1155 memcpy(iwe
.u
.ap_addr
.sa_data
, zd
->rxdata
+i
+6, 6);
1156 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1157 &iwe
, IW_EV_ADDR_LEN
);
1159 iwe
.cmd
= SIOCGIWESSID
;
1160 iwe
.u
.data
.length
= zd
->rxdata
[i
+16];
1161 iwe
.u
.data
.flags
= 1;
1162 cev
= iwe_stream_add_point(info
, cev
, end_buf
,
1163 &iwe
, zd
->rxdata
+i
+18);
1165 iwe
.cmd
= SIOCGIWMODE
;
1166 if (zd
->rxdata
[i
+14]&0x01)
1167 iwe
.u
.mode
= IW_MODE_MASTER
;
1169 iwe
.u
.mode
= IW_MODE_ADHOC
;
1170 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1171 &iwe
, IW_EV_UINT_LEN
);
1173 iwe
.cmd
= SIOCGIWFREQ
;
1174 iwe
.u
.freq
.m
= zd
->rxdata
[i
+0];
1176 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1177 &iwe
, IW_EV_FREQ_LEN
);
1179 iwe
.cmd
= SIOCGIWRATE
;
1180 iwe
.u
.bitrate
.fixed
= 0;
1181 iwe
.u
.bitrate
.disabled
= 0;
1182 for (j
=0; j
<10; j
++) if (zd
->rxdata
[i
+50+j
]) {
1183 iwe
.u
.bitrate
.value
= (zd
->rxdata
[i
+50+j
]&0x7f)*500000;
1184 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1185 &iwe
, IW_EV_PARAM_LEN
);
1188 iwe
.cmd
= SIOCGIWENCODE
;
1189 iwe
.u
.data
.length
= 0;
1190 if (zd
->rxdata
[i
+14]&0x10)
1191 iwe
.u
.data
.flags
= IW_ENCODE_ENABLED
;
1193 iwe
.u
.data
.flags
= IW_ENCODE_DISABLED
;
1194 cev
= iwe_stream_add_point(info
, cev
, end_buf
, &iwe
, NULL
);
1197 iwe
.u
.qual
.qual
= zd
->rxdata
[i
+4];
1198 iwe
.u
.qual
.noise
= zd
->rxdata
[i
+2]/10-100;
1199 iwe
.u
.qual
.level
= (256+zd
->rxdata
[i
+4]*100)/255-100;
1200 iwe
.u
.qual
.updated
= 7;
1201 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1202 &iwe
, IW_EV_QUAL_LEN
);
1208 srq
->length
= cev
- extra
;
1214 static int zd1201_set_essid(struct net_device
*dev
,
1215 struct iw_request_info
*info
, struct iw_point
*data
, char *essid
)
1217 struct zd1201
*zd
= netdev_priv(dev
);
1219 if (data
->length
> IW_ESSID_MAX_SIZE
)
1221 if (data
->length
< 1)
1223 zd
->essidlen
= data
->length
;
1224 memset(zd
->essid
, 0, IW_ESSID_MAX_SIZE
+1);
1225 memcpy(zd
->essid
, essid
, data
->length
);
1226 return zd1201_join(zd
, zd
->essid
, zd
->essidlen
);
1229 static int zd1201_get_essid(struct net_device
*dev
,
1230 struct iw_request_info
*info
, struct iw_point
*data
, char *essid
)
1232 struct zd1201
*zd
= netdev_priv(dev
);
1234 memcpy(essid
, zd
->essid
, zd
->essidlen
);
1236 data
->length
= zd
->essidlen
;
1241 static int zd1201_get_nick(struct net_device
*dev
, struct iw_request_info
*info
,
1242 struct iw_point
*data
, char *nick
)
1244 strcpy(nick
, "zd1201");
1246 data
->length
= strlen(nick
);
1250 static int zd1201_set_rate(struct net_device
*dev
,
1251 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1253 struct zd1201
*zd
= netdev_priv(dev
);
1257 switch (rrq
->value
) {
1259 rate
= ZD1201_RATEB1
;
1262 rate
= ZD1201_RATEB2
;
1265 rate
= ZD1201_RATEB5
;
1269 rate
= ZD1201_RATEB11
;
1272 if (!rrq
->fixed
) { /* Also enable all lower bitrates */
1276 err
= zd1201_setconfig16(zd
, ZD1201_RID_TXRATECNTL
, rate
);
1280 return zd1201_mac_reset(zd
);
1283 static int zd1201_get_rate(struct net_device
*dev
,
1284 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1286 struct zd1201
*zd
= netdev_priv(dev
);
1290 err
= zd1201_getconfig16(zd
, ZD1201_RID_CURRENTTXRATE
, &rate
);
1296 rrq
->value
= 1000000;
1299 rrq
->value
= 2000000;
1302 rrq
->value
= 5500000;
1305 rrq
->value
= 11000000;
1316 static int zd1201_set_rts(struct net_device
*dev
, struct iw_request_info
*info
,
1317 struct iw_param
*rts
, char *extra
)
1319 struct zd1201
*zd
= netdev_priv(dev
);
1321 short val
= rts
->value
;
1323 if (rts
->disabled
|| !rts
->fixed
)
1324 val
= ZD1201_RTSMAX
;
1325 if (val
> ZD1201_RTSMAX
)
1330 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFRTSTHRESHOLD
, val
);
1333 return zd1201_mac_reset(zd
);
1336 static int zd1201_get_rts(struct net_device
*dev
, struct iw_request_info
*info
,
1337 struct iw_param
*rts
, char *extra
)
1339 struct zd1201
*zd
= netdev_priv(dev
);
1343 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFRTSTHRESHOLD
, &rtst
);
1347 rts
->disabled
= (rts
->value
== ZD1201_RTSMAX
);
1353 static int zd1201_set_frag(struct net_device
*dev
, struct iw_request_info
*info
,
1354 struct iw_param
*frag
, char *extra
)
1356 struct zd1201
*zd
= netdev_priv(dev
);
1358 short val
= frag
->value
;
1360 if (frag
->disabled
|| !frag
->fixed
)
1361 val
= ZD1201_FRAGMAX
;
1362 if (val
> ZD1201_FRAGMAX
)
1364 if (val
< ZD1201_FRAGMIN
)
1368 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFFRAGTHRESHOLD
, val
);
1371 return zd1201_mac_reset(zd
);
1374 static int zd1201_get_frag(struct net_device
*dev
, struct iw_request_info
*info
,
1375 struct iw_param
*frag
, char *extra
)
1377 struct zd1201
*zd
= netdev_priv(dev
);
1381 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFFRAGTHRESHOLD
, &fragt
);
1384 frag
->value
= fragt
;
1385 frag
->disabled
= (frag
->value
== ZD1201_FRAGMAX
);
1391 static int zd1201_set_retry(struct net_device
*dev
,
1392 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1397 static int zd1201_get_retry(struct net_device
*dev
,
1398 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1403 static int zd1201_set_encode(struct net_device
*dev
,
1404 struct iw_request_info
*info
, struct iw_point
*erq
, char *key
)
1406 struct zd1201
*zd
= netdev_priv(dev
);
1410 if (erq
->length
> ZD1201_MAXKEYLEN
)
1413 i
= (erq
->flags
& IW_ENCODE_INDEX
)-1;
1415 err
= zd1201_getconfig16(zd
,ZD1201_RID_CNFDEFAULTKEYID
,&i
);
1419 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFDEFAULTKEYID
, i
);
1424 if (i
< 0 || i
>= ZD1201_NUMKEYS
)
1427 rid
= ZD1201_RID_CNFDEFAULTKEY0
+ i
;
1428 err
= zd1201_setconfig(zd
, rid
, key
, erq
->length
, 1);
1431 zd
->encode_keylen
[i
] = erq
->length
;
1432 memcpy(zd
->encode_keys
[i
], key
, erq
->length
);
1435 if (!(erq
->flags
& IW_ENCODE_DISABLED
& IW_ENCODE_MODE
)) {
1437 zd
->encode_enabled
= 1;
1439 zd
->encode_enabled
= 0;
1440 if (erq
->flags
& IW_ENCODE_RESTRICTED
& IW_ENCODE_MODE
) {
1442 zd
->encode_restricted
= 1;
1444 zd
->encode_restricted
= 0;
1445 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFWEBFLAGS
, i
);
1449 if (zd
->encode_enabled
)
1450 i
= ZD1201_CNFAUTHENTICATION_SHAREDKEY
;
1452 i
= ZD1201_CNFAUTHENTICATION_OPENSYSTEM
;
1453 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFAUTHENTICATION
, i
);
1457 return zd1201_mac_reset(zd
);
1460 static int zd1201_get_encode(struct net_device
*dev
,
1461 struct iw_request_info
*info
, struct iw_point
*erq
, char *key
)
1463 struct zd1201
*zd
= netdev_priv(dev
);
1467 if (zd
->encode_enabled
)
1468 erq
->flags
= IW_ENCODE_ENABLED
;
1470 erq
->flags
= IW_ENCODE_DISABLED
;
1471 if (zd
->encode_restricted
)
1472 erq
->flags
|= IW_ENCODE_RESTRICTED
;
1474 erq
->flags
|= IW_ENCODE_OPEN
;
1476 i
= (erq
->flags
& IW_ENCODE_INDEX
) -1;
1478 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFDEFAULTKEYID
, &i
);
1482 if (i
<0 || i
>= ZD1201_NUMKEYS
)
1487 erq
->length
= zd
->encode_keylen
[i
];
1488 memcpy(key
, zd
->encode_keys
[i
], erq
->length
);
1493 static int zd1201_set_power(struct net_device
*dev
,
1494 struct iw_request_info
*info
, struct iw_param
*vwrq
, char *extra
)
1496 struct zd1201
*zd
= netdev_priv(dev
);
1497 short enabled
, duration
, level
;
1500 enabled
= vwrq
->disabled
? 0 : 1;
1502 if (vwrq
->flags
& IW_POWER_PERIOD
) {
1503 duration
= vwrq
->value
;
1504 err
= zd1201_setconfig16(zd
,
1505 ZD1201_RID_CNFMAXSLEEPDURATION
, duration
);
1510 if (vwrq
->flags
& IW_POWER_TIMEOUT
) {
1511 err
= zd1201_getconfig16(zd
,
1512 ZD1201_RID_CNFMAXSLEEPDURATION
, &duration
);
1515 level
= vwrq
->value
* 4 / duration
;
1520 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFPMEPS
,
1529 return zd1201_setconfig16(zd
, ZD1201_RID_CNFPMENABLED
, enabled
);
1532 static int zd1201_get_power(struct net_device
*dev
,
1533 struct iw_request_info
*info
, struct iw_param
*vwrq
, char *extra
)
1535 struct zd1201
*zd
= netdev_priv(dev
);
1536 short enabled
, level
, duration
;
1539 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFPMENABLED
, &enabled
);
1542 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFPMEPS
, &level
);
1545 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFMAXSLEEPDURATION
, &duration
);
1548 vwrq
->disabled
= enabled
? 0 : 1;
1549 if (vwrq
->flags
& IW_POWER_TYPE
) {
1550 if (vwrq
->flags
& IW_POWER_PERIOD
) {
1551 vwrq
->value
= duration
;
1552 vwrq
->flags
= IW_POWER_PERIOD
;
1554 vwrq
->value
= duration
* level
/ 4;
1555 vwrq
->flags
= IW_POWER_TIMEOUT
;
1558 if (vwrq
->flags
& IW_POWER_MODE
) {
1559 if (enabled
&& level
)
1560 vwrq
->flags
= IW_POWER_UNICAST_R
;
1562 vwrq
->flags
= IW_POWER_ALL_R
;
1569 static const iw_handler zd1201_iw_handler
[] =
1571 (iw_handler
) zd1201_config_commit
, /* SIOCSIWCOMMIT */
1572 (iw_handler
) zd1201_get_name
, /* SIOCGIWNAME */
1573 (iw_handler
) NULL
, /* SIOCSIWNWID */
1574 (iw_handler
) NULL
, /* SIOCGIWNWID */
1575 (iw_handler
) zd1201_set_freq
, /* SIOCSIWFREQ */
1576 (iw_handler
) zd1201_get_freq
, /* SIOCGIWFREQ */
1577 (iw_handler
) zd1201_set_mode
, /* SIOCSIWMODE */
1578 (iw_handler
) zd1201_get_mode
, /* SIOCGIWMODE */
1579 (iw_handler
) NULL
, /* SIOCSIWSENS */
1580 (iw_handler
) NULL
, /* SIOCGIWSENS */
1581 (iw_handler
) NULL
, /* SIOCSIWRANGE */
1582 (iw_handler
) zd1201_get_range
, /* SIOCGIWRANGE */
1583 (iw_handler
) NULL
, /* SIOCSIWPRIV */
1584 (iw_handler
) NULL
, /* SIOCGIWPRIV */
1585 (iw_handler
) NULL
, /* SIOCSIWSTATS */
1586 (iw_handler
) NULL
, /* SIOCGIWSTATS */
1587 (iw_handler
) NULL
, /* SIOCSIWSPY */
1588 (iw_handler
) NULL
, /* SIOCGIWSPY */
1589 (iw_handler
) NULL
, /* -- hole -- */
1590 (iw_handler
) NULL
, /* -- hole -- */
1591 (iw_handler
) NULL
/*zd1201_set_wap*/, /* SIOCSIWAP */
1592 (iw_handler
) zd1201_get_wap
, /* SIOCGIWAP */
1593 (iw_handler
) NULL
, /* -- hole -- */
1594 (iw_handler
) NULL
, /* SIOCGIWAPLIST */
1595 (iw_handler
) zd1201_set_scan
, /* SIOCSIWSCAN */
1596 (iw_handler
) zd1201_get_scan
, /* SIOCGIWSCAN */
1597 (iw_handler
) zd1201_set_essid
, /* SIOCSIWESSID */
1598 (iw_handler
) zd1201_get_essid
, /* SIOCGIWESSID */
1599 (iw_handler
) NULL
, /* SIOCSIWNICKN */
1600 (iw_handler
) zd1201_get_nick
, /* SIOCGIWNICKN */
1601 (iw_handler
) NULL
, /* -- hole -- */
1602 (iw_handler
) NULL
, /* -- hole -- */
1603 (iw_handler
) zd1201_set_rate
, /* SIOCSIWRATE */
1604 (iw_handler
) zd1201_get_rate
, /* SIOCGIWRATE */
1605 (iw_handler
) zd1201_set_rts
, /* SIOCSIWRTS */
1606 (iw_handler
) zd1201_get_rts
, /* SIOCGIWRTS */
1607 (iw_handler
) zd1201_set_frag
, /* SIOCSIWFRAG */
1608 (iw_handler
) zd1201_get_frag
, /* SIOCGIWFRAG */
1609 (iw_handler
) NULL
, /* SIOCSIWTXPOW */
1610 (iw_handler
) NULL
, /* SIOCGIWTXPOW */
1611 (iw_handler
) zd1201_set_retry
, /* SIOCSIWRETRY */
1612 (iw_handler
) zd1201_get_retry
, /* SIOCGIWRETRY */
1613 (iw_handler
) zd1201_set_encode
, /* SIOCSIWENCODE */
1614 (iw_handler
) zd1201_get_encode
, /* SIOCGIWENCODE */
1615 (iw_handler
) zd1201_set_power
, /* SIOCSIWPOWER */
1616 (iw_handler
) zd1201_get_power
, /* SIOCGIWPOWER */
1619 static int zd1201_set_hostauth(struct net_device
*dev
,
1620 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1622 struct zd1201
*zd
= netdev_priv(dev
);
1627 return zd1201_setconfig16(zd
, ZD1201_RID_CNFHOSTAUTH
, rrq
->value
);
1630 static int zd1201_get_hostauth(struct net_device
*dev
,
1631 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1633 struct zd1201
*zd
= netdev_priv(dev
);
1640 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFHOSTAUTH
, &hostauth
);
1643 rrq
->value
= hostauth
;
1649 static int zd1201_auth_sta(struct net_device
*dev
,
1650 struct iw_request_info
*info
, struct sockaddr
*sta
, char *extra
)
1652 struct zd1201
*zd
= netdev_priv(dev
);
1653 unsigned char buffer
[10];
1658 memcpy(buffer
, sta
->sa_data
, ETH_ALEN
);
1659 *(short*)(buffer
+6) = 0; /* 0==success, 1==failure */
1660 *(short*)(buffer
+8) = 0;
1662 return zd1201_setconfig(zd
, ZD1201_RID_AUTHENTICATESTA
, buffer
, 10, 1);
1665 static int zd1201_set_maxassoc(struct net_device
*dev
,
1666 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1668 struct zd1201
*zd
= netdev_priv(dev
);
1674 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFMAXASSOCSTATIONS
, rrq
->value
);
1680 static int zd1201_get_maxassoc(struct net_device
*dev
,
1681 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1683 struct zd1201
*zd
= netdev_priv(dev
);
1690 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFMAXASSOCSTATIONS
, &maxassoc
);
1693 rrq
->value
= maxassoc
;
1699 static const iw_handler zd1201_private_handler
[] = {
1700 (iw_handler
) zd1201_set_hostauth
, /* ZD1201SIWHOSTAUTH */
1701 (iw_handler
) zd1201_get_hostauth
, /* ZD1201GIWHOSTAUTH */
1702 (iw_handler
) zd1201_auth_sta
, /* ZD1201SIWAUTHSTA */
1703 (iw_handler
) NULL
, /* nothing to get */
1704 (iw_handler
) zd1201_set_maxassoc
, /* ZD1201SIMAXASSOC */
1705 (iw_handler
) zd1201_get_maxassoc
, /* ZD1201GIMAXASSOC */
1708 static const struct iw_priv_args zd1201_private_args
[] = {
1709 { ZD1201SIWHOSTAUTH
, IW_PRIV_TYPE_INT
| IW_PRIV_SIZE_FIXED
| 1,
1710 IW_PRIV_TYPE_NONE
, "sethostauth" },
1711 { ZD1201GIWHOSTAUTH
, IW_PRIV_TYPE_NONE
,
1712 IW_PRIV_TYPE_INT
| IW_PRIV_SIZE_FIXED
| 1, "gethostauth" },
1713 { ZD1201SIWAUTHSTA
, IW_PRIV_TYPE_ADDR
| IW_PRIV_SIZE_FIXED
| 1,
1714 IW_PRIV_TYPE_NONE
, "authstation" },
1715 { ZD1201SIWMAXASSOC
, IW_PRIV_TYPE_INT
| IW_PRIV_SIZE_FIXED
| 1,
1716 IW_PRIV_TYPE_NONE
, "setmaxassoc" },
1717 { ZD1201GIWMAXASSOC
, IW_PRIV_TYPE_NONE
,
1718 IW_PRIV_TYPE_INT
| IW_PRIV_SIZE_FIXED
| 1, "getmaxassoc" },
1721 static const struct iw_handler_def zd1201_iw_handlers
= {
1722 .num_standard
= ARRAY_SIZE(zd1201_iw_handler
),
1723 .num_private
= ARRAY_SIZE(zd1201_private_handler
),
1724 .num_private_args
= ARRAY_SIZE(zd1201_private_args
),
1725 .standard
= (iw_handler
*)zd1201_iw_handler
,
1726 .private = (iw_handler
*)zd1201_private_handler
,
1727 .private_args
= (struct iw_priv_args
*) zd1201_private_args
,
1728 .get_wireless_stats
= zd1201_get_wireless_stats
,
1731 static int zd1201_probe(struct usb_interface
*interface
,
1732 const struct usb_device_id
*id
)
1735 struct net_device
*dev
;
1736 struct usb_device
*usb
;
1739 char buf
[IW_ESSID_MAX_SIZE
+2];
1741 usb
= interface_to_usbdev(interface
);
1743 dev
= alloc_etherdev(sizeof(*zd
));
1746 zd
= netdev_priv(dev
);
1752 init_waitqueue_head(&zd
->rxdataq
);
1753 INIT_HLIST_HEAD(&zd
->fraglist
);
1755 err
= zd1201_fw_upload(usb
, zd
->ap
);
1757 dev_err(&usb
->dev
, "zd1201 firmware upload failed: %d\n", err
);
1764 zd
->rx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
1765 zd
->tx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
1766 if (!zd
->rx_urb
|| !zd
->tx_urb
)
1770 err
= zd1201_drvr_start(zd
);
1774 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFMAXDATALEN
, 2312);
1778 err
= zd1201_setconfig16(zd
, ZD1201_RID_TXRATECNTL
,
1779 ZD1201_RATEB1
| ZD1201_RATEB2
| ZD1201_RATEB5
| ZD1201_RATEB11
);
1783 dev
->open
= zd1201_net_open
;
1784 dev
->stop
= zd1201_net_stop
;
1785 dev
->get_stats
= zd1201_get_stats
;
1786 dev
->wireless_handlers
=
1787 (struct iw_handler_def
*)&zd1201_iw_handlers
;
1788 dev
->hard_start_xmit
= zd1201_hard_start_xmit
;
1789 dev
->watchdog_timeo
= ZD1201_TX_TIMEOUT
;
1790 dev
->tx_timeout
= zd1201_tx_timeout
;
1791 dev
->set_multicast_list
= zd1201_set_multicast
;
1792 dev
->set_mac_address
= zd1201_set_mac_address
;
1793 strcpy(dev
->name
, "wlan%d");
1795 err
= zd1201_getconfig(zd
, ZD1201_RID_CNFOWNMACADDR
,
1796 dev
->dev_addr
, dev
->addr_len
);
1800 /* Set wildcard essid to match zd->essid */
1801 *(__le16
*)buf
= cpu_to_le16(0);
1802 err
= zd1201_setconfig(zd
, ZD1201_RID_CNFDESIREDSSID
, buf
,
1803 IW_ESSID_MAX_SIZE
+2, 1);
1808 porttype
= ZD1201_PORTTYPE_AP
;
1810 porttype
= ZD1201_PORTTYPE_BSS
;
1811 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFPORTTYPE
, porttype
);
1815 SET_NETDEV_DEV(dev
, &usb
->dev
);
1817 err
= register_netdev(dev
);
1820 dev_info(&usb
->dev
, "%s: ZD1201 USB Wireless interface\n",
1823 usb_set_intfdata(interface
, zd
);
1824 zd1201_enable(zd
); /* zd1201 likes to startup enabled, */
1825 zd1201_disable(zd
); /* interfering with all the wifis in range */
1829 /* Leave the device in reset state */
1830 zd1201_docmd(zd
, ZD1201_CMDCODE_INIT
, 0, 0, 0);
1832 usb_free_urb(zd
->tx_urb
);
1833 usb_free_urb(zd
->rx_urb
);
1838 static void zd1201_disconnect(struct usb_interface
*interface
)
1840 struct zd1201
*zd
=(struct zd1201
*)usb_get_intfdata(interface
);
1841 struct hlist_node
*node
, *node2
;
1842 struct zd1201_frag
*frag
;
1846 usb_set_intfdata(interface
, NULL
);
1848 hlist_for_each_entry_safe(frag
, node
, node2
, &zd
->fraglist
, fnode
) {
1849 hlist_del_init(&frag
->fnode
);
1850 kfree_skb(frag
->skb
);
1855 usb_kill_urb(zd
->tx_urb
);
1856 usb_free_urb(zd
->tx_urb
);
1859 usb_kill_urb(zd
->rx_urb
);
1860 usb_free_urb(zd
->rx_urb
);
1864 unregister_netdev(zd
->dev
);
1865 free_netdev(zd
->dev
);
1871 static int zd1201_suspend(struct usb_interface
*interface
,
1872 pm_message_t message
)
1874 struct zd1201
*zd
= usb_get_intfdata(interface
);
1876 netif_device_detach(zd
->dev
);
1878 zd
->was_enabled
= zd
->mac_enabled
;
1880 if (zd
->was_enabled
)
1881 return zd1201_disable(zd
);
1886 static int zd1201_resume(struct usb_interface
*interface
)
1888 struct zd1201
*zd
= usb_get_intfdata(interface
);
1890 if (!zd
|| !zd
->dev
)
1893 netif_device_attach(zd
->dev
);
1895 if (zd
->was_enabled
)
1896 return zd1201_enable(zd
);
1903 #define zd1201_suspend NULL
1904 #define zd1201_resume NULL
1908 static struct usb_driver zd1201_usb
= {
1910 .probe
= zd1201_probe
,
1911 .disconnect
= zd1201_disconnect
,
1912 .id_table
= zd1201_table
,
1913 .suspend
= zd1201_suspend
,
1914 .resume
= zd1201_resume
,
1917 static int __init
zd1201_init(void)
1919 return usb_register(&zd1201_usb
);
1922 static void __exit
zd1201_cleanup(void)
1924 usb_deregister(&zd1201_usb
);
1927 module_init(zd1201_init
);
1928 module_exit(zd1201_cleanup
);