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 MODULE_FIRMWARE("zd1201-ap.fw");
116 MODULE_FIRMWARE("zd1201.fw");
118 static void zd1201_usbfree(struct urb
*urb
)
120 struct zd1201
*zd
= urb
->context
;
122 switch(urb
->status
) {
130 dev_warn(&zd
->usb
->dev
, "%s: urb failed: %d\n",
131 zd
->dev
->name
, urb
->status
);
134 kfree(urb
->transfer_buffer
);
147 total: 4 + 2 + 2 + 2 + 2 + 4 = 16
149 static int zd1201_docmd(struct zd1201
*zd
, int cmd
, int parm0
,
150 int parm1
, int parm2
)
152 unsigned char *command
;
156 command
= kmalloc(16, GFP_ATOMIC
);
160 *((__le32
*)command
) = cpu_to_le32(ZD1201_USB_CMDREQ
);
161 *((__le16
*)&command
[4]) = cpu_to_le16(cmd
);
162 *((__le16
*)&command
[6]) = cpu_to_le16(parm0
);
163 *((__le16
*)&command
[8]) = cpu_to_le16(parm1
);
164 *((__le16
*)&command
[10])= cpu_to_le16(parm2
);
166 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
171 usb_fill_bulk_urb(urb
, zd
->usb
, usb_sndbulkpipe(zd
->usb
, zd
->endp_out2
),
172 command
, 16, zd1201_usbfree
, zd
);
173 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
182 /* Callback after sending out a packet */
183 static void zd1201_usbtx(struct urb
*urb
)
185 struct zd1201
*zd
= urb
->context
;
186 netif_wake_queue(zd
->dev
);
191 static void zd1201_usbrx(struct urb
*urb
)
193 struct zd1201
*zd
= urb
->context
;
195 unsigned char *data
= urb
->transfer_buffer
;
202 switch(urb
->status
) {
210 dev_warn(&zd
->usb
->dev
, "%s: rx urb failed: %d\n",
211 zd
->dev
->name
, urb
->status
);
216 if (urb
->status
!= 0 || urb
->actual_length
== 0)
220 if (type
== ZD1201_PACKET_EVENTSTAT
|| type
== ZD1201_PACKET_RESOURCE
) {
221 memcpy(zd
->rxdata
, data
, urb
->actual_length
);
222 zd
->rxlen
= urb
->actual_length
;
224 wake_up(&zd
->rxdataq
);
227 if (type
== ZD1201_PACKET_INQUIRE
) {
229 unsigned short infotype
, framelen
, copylen
;
230 framelen
= le16_to_cpu(*(__le16
*)&data
[4]);
231 infotype
= le16_to_cpu(*(__le16
*)&data
[6]);
233 if (infotype
== ZD1201_INF_LINKSTATUS
) {
236 linkstatus
= le16_to_cpu(*(__le16
*)&data
[8]);
239 netif_carrier_on(zd
->dev
);
242 netif_carrier_off(zd
->dev
);
245 netif_carrier_off(zd
->dev
);
248 netif_carrier_on(zd
->dev
);
251 netif_carrier_off(zd
->dev
);
255 if (infotype
== ZD1201_INF_ASSOCSTATUS
) {
256 short status
= le16_to_cpu(*(__le16
*)(data
+8));
258 union iwreq_data wrqu
;
261 case ZD1201_ASSOCSTATUS_STAASSOC
:
262 case ZD1201_ASSOCSTATUS_REASSOC
:
263 event
= IWEVREGISTERED
;
265 case ZD1201_ASSOCSTATUS_DISASSOC
:
266 case ZD1201_ASSOCSTATUS_ASSOCFAIL
:
267 case ZD1201_ASSOCSTATUS_AUTHFAIL
:
271 memcpy(wrqu
.addr
.sa_data
, data
+10, ETH_ALEN
);
272 wrqu
.addr
.sa_family
= ARPHRD_ETHER
;
274 /* Send event to user space */
275 wireless_send_event(zd
->dev
, event
, &wrqu
, NULL
);
279 if (infotype
== ZD1201_INF_AUTHREQ
) {
280 union iwreq_data wrqu
;
282 memcpy(wrqu
.addr
.sa_data
, data
+8, ETH_ALEN
);
283 wrqu
.addr
.sa_family
= ARPHRD_ETHER
;
284 /* There isn't a event that trully fits this request.
285 We assume that userspace will be smart enough to
286 see a new station being expired and sends back a
287 authstation ioctl to authorize it. */
288 wireless_send_event(zd
->dev
, IWEVEXPIRED
, &wrqu
, NULL
);
291 /* Other infotypes are handled outside this handler */
293 while (i
< urb
->actual_length
) {
294 copylen
= le16_to_cpu(*(__le16
*)&data
[i
+2]);
295 /* Sanity check, sometimes we get junk */
296 if (copylen
+zd
->rxlen
> sizeof(zd
->rxdata
))
298 memcpy(zd
->rxdata
+zd
->rxlen
, data
+i
+4, copylen
);
299 zd
->rxlen
+= copylen
;
302 if (i
>= urb
->actual_length
) {
304 wake_up(&zd
->rxdataq
);
309 if (data
[urb
->actual_length
-1] == ZD1201_PACKET_RXDATA
) {
310 int datalen
= urb
->actual_length
-1;
311 unsigned short len
, fc
, seq
;
312 struct hlist_node
*node
;
314 len
= ntohs(*(__be16
*)&data
[datalen
-2]);
317 fc
= le16_to_cpu(*(__le16
*)&data
[datalen
-16]);
318 seq
= le16_to_cpu(*(__le16
*)&data
[datalen
-24]);
323 if (!(skb
= dev_alloc_skb(datalen
+24)))
326 memcpy(skb_put(skb
, 2), &data
[datalen
-16], 2);
327 memcpy(skb_put(skb
, 2), &data
[datalen
-2], 2);
328 memcpy(skb_put(skb
, 6), &data
[datalen
-14], 6);
329 memcpy(skb_put(skb
, 6), &data
[datalen
-22], 6);
330 memcpy(skb_put(skb
, 6), &data
[datalen
-8], 6);
331 memcpy(skb_put(skb
, 2), &data
[datalen
-24], 2);
332 memcpy(skb_put(skb
, len
), data
, len
);
333 skb
->protocol
= eth_type_trans(skb
, zd
->dev
);
334 zd
->dev
->stats
.rx_packets
++;
335 zd
->dev
->stats
.rx_bytes
+= skb
->len
;
340 if ((seq
& IEEE80211_SCTL_FRAG
) ||
341 (fc
& IEEE80211_FCTL_MOREFRAGS
)) {
342 struct zd1201_frag
*frag
= NULL
;
347 if ((seq
& IEEE80211_SCTL_FRAG
) == 0) {
348 frag
= kmalloc(sizeof(*frag
), GFP_ATOMIC
);
351 skb
= dev_alloc_skb(IEEE80211_MAX_DATA_LEN
+14+2);
357 frag
->seq
= seq
& IEEE80211_SCTL_SEQ
;
359 memcpy(skb_put(skb
, 12), &data
[datalen
-14], 12);
360 memcpy(skb_put(skb
, 2), &data
[6], 2);
361 memcpy(skb_put(skb
, len
), data
+8, len
);
362 hlist_add_head(&frag
->fnode
, &zd
->fraglist
);
365 hlist_for_each_entry(frag
, node
, &zd
->fraglist
, fnode
)
366 if (frag
->seq
== (seq
&IEEE80211_SCTL_SEQ
))
371 ptr
= skb_put(skb
, len
);
373 memcpy(ptr
, data
+8, len
);
374 if (fc
& IEEE80211_FCTL_MOREFRAGS
)
376 hlist_del_init(&frag
->fnode
);
381 skb
= dev_alloc_skb(len
+ 14 + 2);
385 memcpy(skb_put(skb
, 12), &data
[datalen
-14], 12);
386 memcpy(skb_put(skb
, 2), &data
[6], 2);
387 memcpy(skb_put(skb
, len
), data
+8, len
);
389 skb
->protocol
= eth_type_trans(skb
, zd
->dev
);
390 zd
->dev
->stats
.rx_packets
++;
391 zd
->dev
->stats
.rx_bytes
+= skb
->len
;
395 memset(data
, 0, ZD1201_RXSIZE
);
399 if(usb_submit_urb(urb
, GFP_ATOMIC
))
406 wake_up(&zd
->rxdataq
);
407 kfree(urb
->transfer_buffer
);
412 static int zd1201_getconfig(struct zd1201
*zd
, int rid
, void *riddata
,
413 unsigned int riddatalen
)
420 unsigned char *pdata
;
423 err
= zd1201_docmd(zd
, ZD1201_CMDCODE_ACCESS
, rid
, 0, 0);
427 wait_event_interruptible(zd
->rxdataq
, zd
->rxdatas
);
431 code
= le16_to_cpu(*(__le16
*)(&zd
->rxdata
[4]));
432 rid_fid
= le16_to_cpu(*(__le16
*)(&zd
->rxdata
[6]));
433 length
= le16_to_cpu(*(__le16
*)(&zd
->rxdata
[8]));
434 if (length
> zd
->rxlen
)
435 length
= zd
->rxlen
-6;
437 /* If access bit is not on, then error */
438 if ((code
& ZD1201_ACCESSBIT
) != ZD1201_ACCESSBIT
|| rid_fid
!= rid
)
441 /* Not enough buffer for allocating data */
442 if (riddatalen
!= (length
- 4)) {
443 dev_dbg(&zd
->usb
->dev
, "riddatalen mismatches, expected=%u, (packet=%u) length=%u, rid=0x%04X, rid_fid=0x%04X\n",
444 riddatalen
, zd
->rxlen
, length
, rid
, rid_fid
);
449 /* Issue SetRxRid commnd */
450 err
= zd1201_docmd(zd
, ZD1201_CMDCODE_SETRXRID
, rid
, 0, length
);
454 /* Receive RID record from resource packets */
455 wait_event_interruptible(zd
->rxdataq
, zd
->rxdatas
);
459 if (zd
->rxdata
[zd
->rxlen
- 1] != ZD1201_PACKET_RESOURCE
) {
460 dev_dbg(&zd
->usb
->dev
, "Packet type mismatch: 0x%x not 0x3\n",
461 zd
->rxdata
[zd
->rxlen
-1]);
465 /* Set the data pointer and received data length */
472 actual_length
= (length
> 64) ? 64 : length
;
474 if (pdata
[0] != 0x3) {
475 dev_dbg(&zd
->usb
->dev
, "Rx Resource packet type error: %02X\n",
480 if (actual_length
!= 64) {
481 /* Trim the last packet type byte */
485 /* Skip the 4 bytes header (RID length and RID) */
494 memcpy(riddata
, pdata
, actual_length
);
495 riddata
+= actual_length
;
496 pdata
+= actual_length
;
499 } while (length
> 0);
512 static int zd1201_setconfig(struct zd1201
*zd
, int rid
, void *buf
, int len
, int wait
)
515 unsigned char *request
;
519 gfp_t gfp_mask
= wait
? GFP_NOIO
: GFP_ATOMIC
;
521 len
+= 4; /* first 4 are for header */
525 for (seq
=0; len
> 0; seq
++) {
526 request
= kmalloc(16, gfp_mask
);
529 urb
= usb_alloc_urb(0, gfp_mask
);
534 memset(request
, 0, 16);
535 reqlen
= len
>12 ? 12 : len
;
536 request
[0] = ZD1201_USB_RESREQ
;
540 if (request
[1] == 0) {
542 *(__le16
*)&request
[4] = cpu_to_le16((len
-2+1)/2);
543 *(__le16
*)&request
[6] = cpu_to_le16(rid
);
544 memcpy(request
+8, buf
, reqlen
-4);
547 memcpy(request
+4, buf
, reqlen
);
553 usb_fill_bulk_urb(urb
, zd
->usb
, usb_sndbulkpipe(zd
->usb
,
554 zd
->endp_out2
), request
, 16, zd1201_usbfree
, zd
);
555 err
= usb_submit_urb(urb
, gfp_mask
);
560 request
= kmalloc(16, gfp_mask
);
563 urb
= usb_alloc_urb(0, gfp_mask
);
568 *((__le32
*)request
) = cpu_to_le32(ZD1201_USB_CMDREQ
);
569 *((__le16
*)&request
[4]) =
570 cpu_to_le16(ZD1201_CMDCODE_ACCESS
|ZD1201_ACCESSBIT
);
571 *((__le16
*)&request
[6]) = cpu_to_le16(rid
);
572 *((__le16
*)&request
[8]) = cpu_to_le16(0);
573 *((__le16
*)&request
[10]) = cpu_to_le16(0);
574 usb_fill_bulk_urb(urb
, zd
->usb
, usb_sndbulkpipe(zd
->usb
, zd
->endp_out2
),
575 request
, 16, zd1201_usbfree
, zd
);
576 err
= usb_submit_urb(urb
, gfp_mask
);
581 wait_event_interruptible(zd
->rxdataq
, zd
->rxdatas
);
582 if (!zd
->rxlen
|| le16_to_cpu(*(__le16
*)&zd
->rxdata
[6]) != rid
) {
583 dev_dbg(&zd
->usb
->dev
, "wrong or no RID received\n");
594 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 netdev_tx_t
zd1201_hard_start_xmit(struct sk_buff
*skb
,
786 struct net_device
*dev
)
788 struct zd1201
*zd
= netdev_priv(dev
);
789 unsigned char *txbuf
= zd
->txdata
;
790 int txbuflen
, pad
= 0, err
;
791 struct urb
*urb
= zd
->tx_urb
;
793 if (!zd
->mac_enabled
|| zd
->monitor
) {
794 dev
->stats
.tx_dropped
++;
798 netif_stop_queue(dev
);
800 txbuflen
= skb
->len
+ 8 + 1;
801 if (txbuflen
%64 == 0) {
808 txbuf
[3] = 0x00; /* rfc1042 */
812 skb_copy_from_linear_data_offset(skb
, 12, txbuf
+ 6, skb
->len
- 12);
814 txbuf
[skb
->len
-12+6]=0;
815 skb_copy_from_linear_data(skb
, txbuf
+ skb
->len
- 12 + 6 + pad
, 12);
816 *(__be16
*)&txbuf
[skb
->len
+6+pad
] = htons(skb
->len
-12+6);
817 txbuf
[txbuflen
-1] = 0;
819 usb_fill_bulk_urb(urb
, zd
->usb
, usb_sndbulkpipe(zd
->usb
, zd
->endp_out
),
820 txbuf
, txbuflen
, zd1201_usbtx
, zd
);
822 err
= usb_submit_urb(zd
->tx_urb
, GFP_ATOMIC
);
824 dev
->stats
.tx_errors
++;
825 netif_start_queue(dev
);
827 dev
->stats
.tx_packets
++;
828 dev
->stats
.tx_bytes
+= skb
->len
;
829 dev
->trans_start
= jiffies
;
836 static void zd1201_tx_timeout(struct net_device
*dev
)
838 struct zd1201
*zd
= netdev_priv(dev
);
842 dev_warn(&zd
->usb
->dev
, "%s: TX timeout, shooting down urb\n",
844 usb_unlink_urb(zd
->tx_urb
);
845 dev
->stats
.tx_errors
++;
846 /* Restart the timeout to quiet the watchdog: */
847 dev
->trans_start
= jiffies
;
850 static int zd1201_set_mac_address(struct net_device
*dev
, void *p
)
852 struct sockaddr
*addr
= p
;
853 struct zd1201
*zd
= netdev_priv(dev
);
859 err
= zd1201_setconfig(zd
, ZD1201_RID_CNFOWNMACADDR
,
860 addr
->sa_data
, dev
->addr_len
, 1);
863 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
865 return zd1201_mac_reset(zd
);
868 static struct iw_statistics
*zd1201_get_wireless_stats(struct net_device
*dev
)
870 struct zd1201
*zd
= netdev_priv(dev
);
875 static void zd1201_set_multicast(struct net_device
*dev
)
877 struct zd1201
*zd
= netdev_priv(dev
);
878 struct dev_mc_list
*mc
= dev
->mc_list
;
879 unsigned char reqbuf
[ETH_ALEN
*ZD1201_MAXMULTI
];
882 if (dev
->mc_count
> ZD1201_MAXMULTI
)
885 for (i
=0; i
<dev
->mc_count
; i
++) {
886 memcpy(reqbuf
+i
*ETH_ALEN
, mc
->dmi_addr
, ETH_ALEN
);
889 zd1201_setconfig(zd
, ZD1201_RID_CNFGROUPADDRESS
, reqbuf
,
890 dev
->mc_count
*ETH_ALEN
, 0);
894 static int zd1201_config_commit(struct net_device
*dev
,
895 struct iw_request_info
*info
, struct iw_point
*data
, char *essid
)
897 struct zd1201
*zd
= netdev_priv(dev
);
899 return zd1201_mac_reset(zd
);
902 static int zd1201_get_name(struct net_device
*dev
,
903 struct iw_request_info
*info
, char *name
, char *extra
)
905 strcpy(name
, "IEEE 802.11b");
909 static int zd1201_set_freq(struct net_device
*dev
,
910 struct iw_request_info
*info
, struct iw_freq
*freq
, char *extra
)
912 struct zd1201
*zd
= netdev_priv(dev
);
919 channel
= ieee80211_freq_to_dsss_chan(freq
->m
);
924 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFOWNCHANNEL
, channel
);
928 zd1201_mac_reset(zd
);
933 static int zd1201_get_freq(struct net_device
*dev
,
934 struct iw_request_info
*info
, struct iw_freq
*freq
, char *extra
)
936 struct zd1201
*zd
= netdev_priv(dev
);
940 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFOWNCHANNEL
, &channel
);
949 static int zd1201_set_mode(struct net_device
*dev
,
950 struct iw_request_info
*info
, __u32
*mode
, char *extra
)
952 struct zd1201
*zd
= netdev_priv(dev
);
953 short porttype
, monitor
= 0;
954 unsigned char buffer
[IW_ESSID_MAX_SIZE
+2];
958 if (*mode
!= IW_MODE_MASTER
)
963 err
= zd1201_setconfig16(zd
, ZD1201_RID_PROMISCUOUSMODE
, 0);
966 zd
->dev
->type
= ARPHRD_ETHER
;
968 case IW_MODE_MONITOR
:
970 zd
->dev
->type
= ARPHRD_IEEE80211
;
971 /* Make sure we are no longer associated with by
972 setting an 'impossible' essid.
973 (otherwise we mess up firmware)
975 zd1201_join(zd
, "\0-*#\0", 5);
976 /* Put port in pIBSS */
977 case 8: /* No pseudo-IBSS in wireless extensions (yet) */
978 porttype
= ZD1201_PORTTYPE_PSEUDOIBSS
;
981 porttype
= ZD1201_PORTTYPE_IBSS
;
984 porttype
= ZD1201_PORTTYPE_BSS
;
990 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFPORTTYPE
, porttype
);
993 if (zd
->monitor
&& !monitor
) {
995 *(__le16
*)buffer
= cpu_to_le16(zd
->essidlen
);
996 memcpy(buffer
+2, zd
->essid
, zd
->essidlen
);
997 err
= zd1201_setconfig(zd
, ZD1201_RID_CNFDESIREDSSID
,
998 buffer
, IW_ESSID_MAX_SIZE
+2, 1);
1002 zd
->monitor
= monitor
;
1003 /* If monitor mode is set we don't actually turn it on here since it
1004 * is done during mac reset anyway (see zd1201_mac_enable).
1006 zd1201_mac_reset(zd
);
1011 static int zd1201_get_mode(struct net_device
*dev
,
1012 struct iw_request_info
*info
, __u32
*mode
, char *extra
)
1014 struct zd1201
*zd
= netdev_priv(dev
);
1018 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFPORTTYPE
, &porttype
);
1022 case ZD1201_PORTTYPE_IBSS
:
1023 *mode
= IW_MODE_ADHOC
;
1025 case ZD1201_PORTTYPE_BSS
:
1026 *mode
= IW_MODE_INFRA
;
1028 case ZD1201_PORTTYPE_WDS
:
1029 *mode
= IW_MODE_REPEAT
;
1031 case ZD1201_PORTTYPE_PSEUDOIBSS
:
1032 *mode
= 8;/* No Pseudo-IBSS... */
1034 case ZD1201_PORTTYPE_AP
:
1035 *mode
= IW_MODE_MASTER
;
1038 dev_dbg(&zd
->usb
->dev
, "Unknown porttype: %d\n",
1040 *mode
= IW_MODE_AUTO
;
1043 *mode
= IW_MODE_MONITOR
;
1048 static int zd1201_get_range(struct net_device
*dev
,
1049 struct iw_request_info
*info
, struct iw_point
*wrq
, char *extra
)
1051 struct iw_range
*range
= (struct iw_range
*)extra
;
1053 wrq
->length
= sizeof(struct iw_range
);
1054 memset(range
, 0, sizeof(struct iw_range
));
1055 range
->we_version_compiled
= WIRELESS_EXT
;
1056 range
->we_version_source
= WIRELESS_EXT
;
1058 range
->max_qual
.qual
= 128;
1059 range
->max_qual
.level
= 128;
1060 range
->max_qual
.noise
= 128;
1061 range
->max_qual
.updated
= 7;
1063 range
->encoding_size
[0] = 5;
1064 range
->encoding_size
[1] = 13;
1065 range
->num_encoding_sizes
= 2;
1066 range
->max_encoding_tokens
= ZD1201_NUMKEYS
;
1068 range
->num_bitrates
= 4;
1069 range
->bitrate
[0] = 1000000;
1070 range
->bitrate
[1] = 2000000;
1071 range
->bitrate
[2] = 5500000;
1072 range
->bitrate
[3] = 11000000;
1075 range
->min_frag
= ZD1201_FRAGMIN
;
1076 range
->max_rts
= ZD1201_RTSMAX
;
1077 range
->min_frag
= ZD1201_FRAGMAX
;
1082 /* Little bit of magic here: we only get the quality if we poll
1083 * for it, and we never get an actual request to trigger such
1084 * a poll. Therefore we 'assume' that the user will soon ask for
1085 * the stats after asking the bssid.
1087 static int zd1201_get_wap(struct net_device
*dev
,
1088 struct iw_request_info
*info
, struct sockaddr
*ap_addr
, char *extra
)
1090 struct zd1201
*zd
= netdev_priv(dev
);
1091 unsigned char buffer
[6];
1093 if (!zd1201_getconfig(zd
, ZD1201_RID_COMMSQUALITY
, buffer
, 6)) {
1094 /* Unfortunately the quality and noise reported is useless.
1095 they seem to be accumulators that increase until you
1096 read them, unless we poll on a fixed interval we can't
1099 /*zd->iwstats.qual.qual = le16_to_cpu(((__le16 *)buffer)[0]);*/
1100 zd
->iwstats
.qual
.level
= le16_to_cpu(((__le16
*)buffer
)[1]);
1101 /*zd->iwstats.qual.noise = le16_to_cpu(((__le16 *)buffer)[2]);*/
1102 zd
->iwstats
.qual
.updated
= 2;
1105 return zd1201_getconfig(zd
, ZD1201_RID_CURRENTBSSID
, ap_addr
->sa_data
, 6);
1108 static int zd1201_set_scan(struct net_device
*dev
,
1109 struct iw_request_info
*info
, struct iw_point
*srq
, char *extra
)
1111 /* We do everything in get_scan */
1115 static int zd1201_get_scan(struct net_device
*dev
,
1116 struct iw_request_info
*info
, struct iw_point
*srq
, char *extra
)
1118 struct zd1201
*zd
= netdev_priv(dev
);
1119 int err
, i
, j
, enabled_save
;
1120 struct iw_event iwe
;
1122 char *end_buf
= extra
+ IW_SCAN_MAX_DATA
;
1124 /* No scanning in AP mode */
1128 /* Scan doesn't seem to work if disabled */
1129 enabled_save
= zd
->mac_enabled
;
1133 err
= zd1201_docmd(zd
, ZD1201_CMDCODE_INQUIRE
,
1134 ZD1201_INQ_SCANRESULTS
, 0, 0);
1138 wait_event_interruptible(zd
->rxdataq
, zd
->rxdatas
);
1142 if (le16_to_cpu(*(__le16
*)&zd
->rxdata
[2]) != ZD1201_INQ_SCANRESULTS
)
1145 for(i
=8; i
<zd
->rxlen
; i
+=62) {
1146 iwe
.cmd
= SIOCGIWAP
;
1147 iwe
.u
.ap_addr
.sa_family
= ARPHRD_ETHER
;
1148 memcpy(iwe
.u
.ap_addr
.sa_data
, zd
->rxdata
+i
+6, 6);
1149 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1150 &iwe
, IW_EV_ADDR_LEN
);
1152 iwe
.cmd
= SIOCGIWESSID
;
1153 iwe
.u
.data
.length
= zd
->rxdata
[i
+16];
1154 iwe
.u
.data
.flags
= 1;
1155 cev
= iwe_stream_add_point(info
, cev
, end_buf
,
1156 &iwe
, zd
->rxdata
+i
+18);
1158 iwe
.cmd
= SIOCGIWMODE
;
1159 if (zd
->rxdata
[i
+14]&0x01)
1160 iwe
.u
.mode
= IW_MODE_MASTER
;
1162 iwe
.u
.mode
= IW_MODE_ADHOC
;
1163 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1164 &iwe
, IW_EV_UINT_LEN
);
1166 iwe
.cmd
= SIOCGIWFREQ
;
1167 iwe
.u
.freq
.m
= zd
->rxdata
[i
+0];
1169 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1170 &iwe
, IW_EV_FREQ_LEN
);
1172 iwe
.cmd
= SIOCGIWRATE
;
1173 iwe
.u
.bitrate
.fixed
= 0;
1174 iwe
.u
.bitrate
.disabled
= 0;
1175 for (j
=0; j
<10; j
++) if (zd
->rxdata
[i
+50+j
]) {
1176 iwe
.u
.bitrate
.value
= (zd
->rxdata
[i
+50+j
]&0x7f)*500000;
1177 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1178 &iwe
, IW_EV_PARAM_LEN
);
1181 iwe
.cmd
= SIOCGIWENCODE
;
1182 iwe
.u
.data
.length
= 0;
1183 if (zd
->rxdata
[i
+14]&0x10)
1184 iwe
.u
.data
.flags
= IW_ENCODE_ENABLED
;
1186 iwe
.u
.data
.flags
= IW_ENCODE_DISABLED
;
1187 cev
= iwe_stream_add_point(info
, cev
, end_buf
, &iwe
, NULL
);
1190 iwe
.u
.qual
.qual
= zd
->rxdata
[i
+4];
1191 iwe
.u
.qual
.noise
= zd
->rxdata
[i
+2]/10-100;
1192 iwe
.u
.qual
.level
= (256+zd
->rxdata
[i
+4]*100)/255-100;
1193 iwe
.u
.qual
.updated
= 7;
1194 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1195 &iwe
, IW_EV_QUAL_LEN
);
1201 srq
->length
= cev
- extra
;
1207 static int zd1201_set_essid(struct net_device
*dev
,
1208 struct iw_request_info
*info
, struct iw_point
*data
, char *essid
)
1210 struct zd1201
*zd
= netdev_priv(dev
);
1212 if (data
->length
> IW_ESSID_MAX_SIZE
)
1214 if (data
->length
< 1)
1216 zd
->essidlen
= data
->length
;
1217 memset(zd
->essid
, 0, IW_ESSID_MAX_SIZE
+1);
1218 memcpy(zd
->essid
, essid
, data
->length
);
1219 return zd1201_join(zd
, zd
->essid
, zd
->essidlen
);
1222 static int zd1201_get_essid(struct net_device
*dev
,
1223 struct iw_request_info
*info
, struct iw_point
*data
, char *essid
)
1225 struct zd1201
*zd
= netdev_priv(dev
);
1227 memcpy(essid
, zd
->essid
, zd
->essidlen
);
1229 data
->length
= zd
->essidlen
;
1234 static int zd1201_get_nick(struct net_device
*dev
, struct iw_request_info
*info
,
1235 struct iw_point
*data
, char *nick
)
1237 strcpy(nick
, "zd1201");
1239 data
->length
= strlen(nick
);
1243 static int zd1201_set_rate(struct net_device
*dev
,
1244 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1246 struct zd1201
*zd
= netdev_priv(dev
);
1250 switch (rrq
->value
) {
1252 rate
= ZD1201_RATEB1
;
1255 rate
= ZD1201_RATEB2
;
1258 rate
= ZD1201_RATEB5
;
1262 rate
= ZD1201_RATEB11
;
1265 if (!rrq
->fixed
) { /* Also enable all lower bitrates */
1269 err
= zd1201_setconfig16(zd
, ZD1201_RID_TXRATECNTL
, rate
);
1273 return zd1201_mac_reset(zd
);
1276 static int zd1201_get_rate(struct net_device
*dev
,
1277 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1279 struct zd1201
*zd
= netdev_priv(dev
);
1283 err
= zd1201_getconfig16(zd
, ZD1201_RID_CURRENTTXRATE
, &rate
);
1289 rrq
->value
= 1000000;
1292 rrq
->value
= 2000000;
1295 rrq
->value
= 5500000;
1298 rrq
->value
= 11000000;
1309 static int zd1201_set_rts(struct net_device
*dev
, struct iw_request_info
*info
,
1310 struct iw_param
*rts
, char *extra
)
1312 struct zd1201
*zd
= netdev_priv(dev
);
1314 short val
= rts
->value
;
1316 if (rts
->disabled
|| !rts
->fixed
)
1317 val
= ZD1201_RTSMAX
;
1318 if (val
> ZD1201_RTSMAX
)
1323 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFRTSTHRESHOLD
, val
);
1326 return zd1201_mac_reset(zd
);
1329 static int zd1201_get_rts(struct net_device
*dev
, struct iw_request_info
*info
,
1330 struct iw_param
*rts
, char *extra
)
1332 struct zd1201
*zd
= netdev_priv(dev
);
1336 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFRTSTHRESHOLD
, &rtst
);
1340 rts
->disabled
= (rts
->value
== ZD1201_RTSMAX
);
1346 static int zd1201_set_frag(struct net_device
*dev
, struct iw_request_info
*info
,
1347 struct iw_param
*frag
, char *extra
)
1349 struct zd1201
*zd
= netdev_priv(dev
);
1351 short val
= frag
->value
;
1353 if (frag
->disabled
|| !frag
->fixed
)
1354 val
= ZD1201_FRAGMAX
;
1355 if (val
> ZD1201_FRAGMAX
)
1357 if (val
< ZD1201_FRAGMIN
)
1361 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFFRAGTHRESHOLD
, val
);
1364 return zd1201_mac_reset(zd
);
1367 static int zd1201_get_frag(struct net_device
*dev
, struct iw_request_info
*info
,
1368 struct iw_param
*frag
, char *extra
)
1370 struct zd1201
*zd
= netdev_priv(dev
);
1374 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFFRAGTHRESHOLD
, &fragt
);
1377 frag
->value
= fragt
;
1378 frag
->disabled
= (frag
->value
== ZD1201_FRAGMAX
);
1384 static int zd1201_set_retry(struct net_device
*dev
,
1385 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1390 static int zd1201_get_retry(struct net_device
*dev
,
1391 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1396 static int zd1201_set_encode(struct net_device
*dev
,
1397 struct iw_request_info
*info
, struct iw_point
*erq
, char *key
)
1399 struct zd1201
*zd
= netdev_priv(dev
);
1403 if (erq
->length
> ZD1201_MAXKEYLEN
)
1406 i
= (erq
->flags
& IW_ENCODE_INDEX
)-1;
1408 err
= zd1201_getconfig16(zd
,ZD1201_RID_CNFDEFAULTKEYID
,&i
);
1412 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFDEFAULTKEYID
, i
);
1417 if (i
< 0 || i
>= ZD1201_NUMKEYS
)
1420 rid
= ZD1201_RID_CNFDEFAULTKEY0
+ i
;
1421 err
= zd1201_setconfig(zd
, rid
, key
, erq
->length
, 1);
1424 zd
->encode_keylen
[i
] = erq
->length
;
1425 memcpy(zd
->encode_keys
[i
], key
, erq
->length
);
1428 if (!(erq
->flags
& IW_ENCODE_DISABLED
& IW_ENCODE_MODE
)) {
1430 zd
->encode_enabled
= 1;
1432 zd
->encode_enabled
= 0;
1433 if (erq
->flags
& IW_ENCODE_RESTRICTED
& IW_ENCODE_MODE
) {
1435 zd
->encode_restricted
= 1;
1437 zd
->encode_restricted
= 0;
1438 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFWEBFLAGS
, i
);
1442 if (zd
->encode_enabled
)
1443 i
= ZD1201_CNFAUTHENTICATION_SHAREDKEY
;
1445 i
= ZD1201_CNFAUTHENTICATION_OPENSYSTEM
;
1446 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFAUTHENTICATION
, i
);
1450 return zd1201_mac_reset(zd
);
1453 static int zd1201_get_encode(struct net_device
*dev
,
1454 struct iw_request_info
*info
, struct iw_point
*erq
, char *key
)
1456 struct zd1201
*zd
= netdev_priv(dev
);
1460 if (zd
->encode_enabled
)
1461 erq
->flags
= IW_ENCODE_ENABLED
;
1463 erq
->flags
= IW_ENCODE_DISABLED
;
1464 if (zd
->encode_restricted
)
1465 erq
->flags
|= IW_ENCODE_RESTRICTED
;
1467 erq
->flags
|= IW_ENCODE_OPEN
;
1469 i
= (erq
->flags
& IW_ENCODE_INDEX
) -1;
1471 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFDEFAULTKEYID
, &i
);
1475 if (i
<0 || i
>= ZD1201_NUMKEYS
)
1480 erq
->length
= zd
->encode_keylen
[i
];
1481 memcpy(key
, zd
->encode_keys
[i
], erq
->length
);
1486 static int zd1201_set_power(struct net_device
*dev
,
1487 struct iw_request_info
*info
, struct iw_param
*vwrq
, char *extra
)
1489 struct zd1201
*zd
= netdev_priv(dev
);
1490 short enabled
, duration
, level
;
1493 enabled
= vwrq
->disabled
? 0 : 1;
1495 if (vwrq
->flags
& IW_POWER_PERIOD
) {
1496 duration
= vwrq
->value
;
1497 err
= zd1201_setconfig16(zd
,
1498 ZD1201_RID_CNFMAXSLEEPDURATION
, duration
);
1503 if (vwrq
->flags
& IW_POWER_TIMEOUT
) {
1504 err
= zd1201_getconfig16(zd
,
1505 ZD1201_RID_CNFMAXSLEEPDURATION
, &duration
);
1508 level
= vwrq
->value
* 4 / duration
;
1513 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFPMEPS
,
1522 return zd1201_setconfig16(zd
, ZD1201_RID_CNFPMENABLED
, enabled
);
1525 static int zd1201_get_power(struct net_device
*dev
,
1526 struct iw_request_info
*info
, struct iw_param
*vwrq
, char *extra
)
1528 struct zd1201
*zd
= netdev_priv(dev
);
1529 short enabled
, level
, duration
;
1532 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFPMENABLED
, &enabled
);
1535 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFPMEPS
, &level
);
1538 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFMAXSLEEPDURATION
, &duration
);
1541 vwrq
->disabled
= enabled
? 0 : 1;
1542 if (vwrq
->flags
& IW_POWER_TYPE
) {
1543 if (vwrq
->flags
& IW_POWER_PERIOD
) {
1544 vwrq
->value
= duration
;
1545 vwrq
->flags
= IW_POWER_PERIOD
;
1547 vwrq
->value
= duration
* level
/ 4;
1548 vwrq
->flags
= IW_POWER_TIMEOUT
;
1551 if (vwrq
->flags
& IW_POWER_MODE
) {
1552 if (enabled
&& level
)
1553 vwrq
->flags
= IW_POWER_UNICAST_R
;
1555 vwrq
->flags
= IW_POWER_ALL_R
;
1562 static const iw_handler zd1201_iw_handler
[] =
1564 (iw_handler
) zd1201_config_commit
, /* SIOCSIWCOMMIT */
1565 (iw_handler
) zd1201_get_name
, /* SIOCGIWNAME */
1566 (iw_handler
) NULL
, /* SIOCSIWNWID */
1567 (iw_handler
) NULL
, /* SIOCGIWNWID */
1568 (iw_handler
) zd1201_set_freq
, /* SIOCSIWFREQ */
1569 (iw_handler
) zd1201_get_freq
, /* SIOCGIWFREQ */
1570 (iw_handler
) zd1201_set_mode
, /* SIOCSIWMODE */
1571 (iw_handler
) zd1201_get_mode
, /* SIOCGIWMODE */
1572 (iw_handler
) NULL
, /* SIOCSIWSENS */
1573 (iw_handler
) NULL
, /* SIOCGIWSENS */
1574 (iw_handler
) NULL
, /* SIOCSIWRANGE */
1575 (iw_handler
) zd1201_get_range
, /* SIOCGIWRANGE */
1576 (iw_handler
) NULL
, /* SIOCSIWPRIV */
1577 (iw_handler
) NULL
, /* SIOCGIWPRIV */
1578 (iw_handler
) NULL
, /* SIOCSIWSTATS */
1579 (iw_handler
) NULL
, /* SIOCGIWSTATS */
1580 (iw_handler
) NULL
, /* SIOCSIWSPY */
1581 (iw_handler
) NULL
, /* SIOCGIWSPY */
1582 (iw_handler
) NULL
, /* -- hole -- */
1583 (iw_handler
) NULL
, /* -- hole -- */
1584 (iw_handler
) NULL
/*zd1201_set_wap*/, /* SIOCSIWAP */
1585 (iw_handler
) zd1201_get_wap
, /* SIOCGIWAP */
1586 (iw_handler
) NULL
, /* -- hole -- */
1587 (iw_handler
) NULL
, /* SIOCGIWAPLIST */
1588 (iw_handler
) zd1201_set_scan
, /* SIOCSIWSCAN */
1589 (iw_handler
) zd1201_get_scan
, /* SIOCGIWSCAN */
1590 (iw_handler
) zd1201_set_essid
, /* SIOCSIWESSID */
1591 (iw_handler
) zd1201_get_essid
, /* SIOCGIWESSID */
1592 (iw_handler
) NULL
, /* SIOCSIWNICKN */
1593 (iw_handler
) zd1201_get_nick
, /* SIOCGIWNICKN */
1594 (iw_handler
) NULL
, /* -- hole -- */
1595 (iw_handler
) NULL
, /* -- hole -- */
1596 (iw_handler
) zd1201_set_rate
, /* SIOCSIWRATE */
1597 (iw_handler
) zd1201_get_rate
, /* SIOCGIWRATE */
1598 (iw_handler
) zd1201_set_rts
, /* SIOCSIWRTS */
1599 (iw_handler
) zd1201_get_rts
, /* SIOCGIWRTS */
1600 (iw_handler
) zd1201_set_frag
, /* SIOCSIWFRAG */
1601 (iw_handler
) zd1201_get_frag
, /* SIOCGIWFRAG */
1602 (iw_handler
) NULL
, /* SIOCSIWTXPOW */
1603 (iw_handler
) NULL
, /* SIOCGIWTXPOW */
1604 (iw_handler
) zd1201_set_retry
, /* SIOCSIWRETRY */
1605 (iw_handler
) zd1201_get_retry
, /* SIOCGIWRETRY */
1606 (iw_handler
) zd1201_set_encode
, /* SIOCSIWENCODE */
1607 (iw_handler
) zd1201_get_encode
, /* SIOCGIWENCODE */
1608 (iw_handler
) zd1201_set_power
, /* SIOCSIWPOWER */
1609 (iw_handler
) zd1201_get_power
, /* SIOCGIWPOWER */
1612 static int zd1201_set_hostauth(struct net_device
*dev
,
1613 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1615 struct zd1201
*zd
= netdev_priv(dev
);
1620 return zd1201_setconfig16(zd
, ZD1201_RID_CNFHOSTAUTH
, rrq
->value
);
1623 static int zd1201_get_hostauth(struct net_device
*dev
,
1624 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1626 struct zd1201
*zd
= netdev_priv(dev
);
1633 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFHOSTAUTH
, &hostauth
);
1636 rrq
->value
= hostauth
;
1642 static int zd1201_auth_sta(struct net_device
*dev
,
1643 struct iw_request_info
*info
, struct sockaddr
*sta
, char *extra
)
1645 struct zd1201
*zd
= netdev_priv(dev
);
1646 unsigned char buffer
[10];
1651 memcpy(buffer
, sta
->sa_data
, ETH_ALEN
);
1652 *(short*)(buffer
+6) = 0; /* 0==success, 1==failure */
1653 *(short*)(buffer
+8) = 0;
1655 return zd1201_setconfig(zd
, ZD1201_RID_AUTHENTICATESTA
, buffer
, 10, 1);
1658 static int zd1201_set_maxassoc(struct net_device
*dev
,
1659 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1661 struct zd1201
*zd
= netdev_priv(dev
);
1667 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFMAXASSOCSTATIONS
, rrq
->value
);
1673 static int zd1201_get_maxassoc(struct net_device
*dev
,
1674 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1676 struct zd1201
*zd
= netdev_priv(dev
);
1683 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFMAXASSOCSTATIONS
, &maxassoc
);
1686 rrq
->value
= maxassoc
;
1692 static const iw_handler zd1201_private_handler
[] = {
1693 (iw_handler
) zd1201_set_hostauth
, /* ZD1201SIWHOSTAUTH */
1694 (iw_handler
) zd1201_get_hostauth
, /* ZD1201GIWHOSTAUTH */
1695 (iw_handler
) zd1201_auth_sta
, /* ZD1201SIWAUTHSTA */
1696 (iw_handler
) NULL
, /* nothing to get */
1697 (iw_handler
) zd1201_set_maxassoc
, /* ZD1201SIMAXASSOC */
1698 (iw_handler
) zd1201_get_maxassoc
, /* ZD1201GIMAXASSOC */
1701 static const struct iw_priv_args zd1201_private_args
[] = {
1702 { ZD1201SIWHOSTAUTH
, IW_PRIV_TYPE_INT
| IW_PRIV_SIZE_FIXED
| 1,
1703 IW_PRIV_TYPE_NONE
, "sethostauth" },
1704 { ZD1201GIWHOSTAUTH
, IW_PRIV_TYPE_NONE
,
1705 IW_PRIV_TYPE_INT
| IW_PRIV_SIZE_FIXED
| 1, "gethostauth" },
1706 { ZD1201SIWAUTHSTA
, IW_PRIV_TYPE_ADDR
| IW_PRIV_SIZE_FIXED
| 1,
1707 IW_PRIV_TYPE_NONE
, "authstation" },
1708 { ZD1201SIWMAXASSOC
, IW_PRIV_TYPE_INT
| IW_PRIV_SIZE_FIXED
| 1,
1709 IW_PRIV_TYPE_NONE
, "setmaxassoc" },
1710 { ZD1201GIWMAXASSOC
, IW_PRIV_TYPE_NONE
,
1711 IW_PRIV_TYPE_INT
| IW_PRIV_SIZE_FIXED
| 1, "getmaxassoc" },
1714 static const struct iw_handler_def zd1201_iw_handlers
= {
1715 .num_standard
= ARRAY_SIZE(zd1201_iw_handler
),
1716 .num_private
= ARRAY_SIZE(zd1201_private_handler
),
1717 .num_private_args
= ARRAY_SIZE(zd1201_private_args
),
1718 .standard
= (iw_handler
*)zd1201_iw_handler
,
1719 .private = (iw_handler
*)zd1201_private_handler
,
1720 .private_args
= (struct iw_priv_args
*) zd1201_private_args
,
1721 .get_wireless_stats
= zd1201_get_wireless_stats
,
1724 static const struct net_device_ops zd1201_netdev_ops
= {
1725 .ndo_open
= zd1201_net_open
,
1726 .ndo_stop
= zd1201_net_stop
,
1727 .ndo_start_xmit
= zd1201_hard_start_xmit
,
1728 .ndo_tx_timeout
= zd1201_tx_timeout
,
1729 .ndo_set_multicast_list
= zd1201_set_multicast
,
1730 .ndo_set_mac_address
= zd1201_set_mac_address
,
1731 .ndo_change_mtu
= eth_change_mtu
,
1732 .ndo_validate_addr
= eth_validate_addr
,
1735 static int zd1201_probe(struct usb_interface
*interface
,
1736 const struct usb_device_id
*id
)
1739 struct net_device
*dev
;
1740 struct usb_device
*usb
;
1743 char buf
[IW_ESSID_MAX_SIZE
+2];
1745 usb
= interface_to_usbdev(interface
);
1747 dev
= alloc_etherdev(sizeof(*zd
));
1750 zd
= netdev_priv(dev
);
1756 init_waitqueue_head(&zd
->rxdataq
);
1757 INIT_HLIST_HEAD(&zd
->fraglist
);
1759 err
= zd1201_fw_upload(usb
, zd
->ap
);
1761 dev_err(&usb
->dev
, "zd1201 firmware upload failed: %d\n", err
);
1768 zd
->rx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
1769 zd
->tx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
1770 if (!zd
->rx_urb
|| !zd
->tx_urb
)
1774 err
= zd1201_drvr_start(zd
);
1778 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFMAXDATALEN
, 2312);
1782 err
= zd1201_setconfig16(zd
, ZD1201_RID_TXRATECNTL
,
1783 ZD1201_RATEB1
| ZD1201_RATEB2
| ZD1201_RATEB5
| ZD1201_RATEB11
);
1787 dev
->netdev_ops
= &zd1201_netdev_ops
;
1788 dev
->wireless_handlers
= &zd1201_iw_handlers
;
1789 dev
->watchdog_timeo
= ZD1201_TX_TIMEOUT
;
1790 strcpy(dev
->name
, "wlan%d");
1792 err
= zd1201_getconfig(zd
, ZD1201_RID_CNFOWNMACADDR
,
1793 dev
->dev_addr
, dev
->addr_len
);
1797 /* Set wildcard essid to match zd->essid */
1798 *(__le16
*)buf
= cpu_to_le16(0);
1799 err
= zd1201_setconfig(zd
, ZD1201_RID_CNFDESIREDSSID
, buf
,
1800 IW_ESSID_MAX_SIZE
+2, 1);
1805 porttype
= ZD1201_PORTTYPE_AP
;
1807 porttype
= ZD1201_PORTTYPE_BSS
;
1808 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFPORTTYPE
, porttype
);
1812 SET_NETDEV_DEV(dev
, &usb
->dev
);
1814 err
= register_netdev(dev
);
1817 dev_info(&usb
->dev
, "%s: ZD1201 USB Wireless interface\n",
1820 usb_set_intfdata(interface
, zd
);
1821 zd1201_enable(zd
); /* zd1201 likes to startup enabled, */
1822 zd1201_disable(zd
); /* interfering with all the wifis in range */
1826 /* Leave the device in reset state */
1827 zd1201_docmd(zd
, ZD1201_CMDCODE_INIT
, 0, 0, 0);
1829 usb_free_urb(zd
->tx_urb
);
1830 usb_free_urb(zd
->rx_urb
);
1835 static void zd1201_disconnect(struct usb_interface
*interface
)
1837 struct zd1201
*zd
=(struct zd1201
*)usb_get_intfdata(interface
);
1838 struct hlist_node
*node
, *node2
;
1839 struct zd1201_frag
*frag
;
1843 usb_set_intfdata(interface
, NULL
);
1845 hlist_for_each_entry_safe(frag
, node
, node2
, &zd
->fraglist
, fnode
) {
1846 hlist_del_init(&frag
->fnode
);
1847 kfree_skb(frag
->skb
);
1852 usb_kill_urb(zd
->tx_urb
);
1853 usb_free_urb(zd
->tx_urb
);
1856 usb_kill_urb(zd
->rx_urb
);
1857 usb_free_urb(zd
->rx_urb
);
1861 unregister_netdev(zd
->dev
);
1862 free_netdev(zd
->dev
);
1868 static int zd1201_suspend(struct usb_interface
*interface
,
1869 pm_message_t message
)
1871 struct zd1201
*zd
= usb_get_intfdata(interface
);
1873 netif_device_detach(zd
->dev
);
1875 zd
->was_enabled
= zd
->mac_enabled
;
1877 if (zd
->was_enabled
)
1878 return zd1201_disable(zd
);
1883 static int zd1201_resume(struct usb_interface
*interface
)
1885 struct zd1201
*zd
= usb_get_intfdata(interface
);
1887 if (!zd
|| !zd
->dev
)
1890 netif_device_attach(zd
->dev
);
1892 if (zd
->was_enabled
)
1893 return zd1201_enable(zd
);
1900 #define zd1201_suspend NULL
1901 #define zd1201_resume NULL
1905 static struct usb_driver zd1201_usb
= {
1907 .probe
= zd1201_probe
,
1908 .disconnect
= zd1201_disconnect
,
1909 .id_table
= zd1201_table
,
1910 .suspend
= zd1201_suspend
,
1911 .resume
= zd1201_resume
,
1914 static int __init
zd1201_init(void)
1916 return usb_register(&zd1201_usb
);
1919 static void __exit
zd1201_cleanup(void)
1921 usb_deregister(&zd1201_usb
);
1924 module_init(zd1201_init
);
1925 module_exit(zd1201_cleanup
);