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/slab.h>
18 #include <linux/netdevice.h>
19 #include <linux/etherdevice.h>
20 #include <linux/wireless.h>
21 #include <linux/ieee80211.h>
22 #include <net/iw_handler.h>
23 #include <linux/string.h>
24 #include <linux/if_arp.h>
25 #include <linux/firmware.h>
28 static struct usb_device_id zd1201_table
[] = {
29 {USB_DEVICE(0x0586, 0x3400)}, /* Peabird Wireless USB Adapter */
30 {USB_DEVICE(0x0ace, 0x1201)}, /* ZyDAS ZD1201 Wireless USB Adapter */
31 {USB_DEVICE(0x050d, 0x6051)}, /* Belkin F5D6051 usb adapter */
32 {USB_DEVICE(0x0db0, 0x6823)}, /* MSI UB11B usb adapter */
33 {USB_DEVICE(0x1044, 0x8004)}, /* Gigabyte GN-WLBZ101 */
34 {USB_DEVICE(0x1044, 0x8005)}, /* GIGABYTE GN-WLBZ201 usb adapter */
38 static int ap
; /* Are we an AP or a normal station? */
40 #define ZD1201_VERSION "0.15"
42 MODULE_AUTHOR("Jeroen Vreeken <pe1rxq@amsat.org>");
43 MODULE_DESCRIPTION("Driver for ZyDAS ZD1201 based USB Wireless adapters");
44 MODULE_VERSION(ZD1201_VERSION
);
45 MODULE_LICENSE("GPL");
46 module_param(ap
, int, 0);
47 MODULE_PARM_DESC(ap
, "If non-zero Access Point firmware will be loaded");
48 MODULE_DEVICE_TABLE(usb
, zd1201_table
);
51 static int zd1201_fw_upload(struct usb_device
*dev
, int apfw
)
53 const struct firmware
*fw_entry
;
62 fwfile
= "zd1201-ap.fw";
66 err
= request_firmware(&fw_entry
, fwfile
, &dev
->dev
);
68 dev_err(&dev
->dev
, "Failed to load %s firmware file!\n", fwfile
);
69 dev_err(&dev
->dev
, "Make sure the hotplug firmware loader is installed.\n");
70 dev_err(&dev
->dev
, "Goto http://linux-lc100020.sourceforge.net for more info.\n");
74 data
= fw_entry
->data
;
77 buf
= kmalloc(1024, GFP_ATOMIC
);
82 int translen
= (len
> 1024) ? 1024 : len
;
83 memcpy(buf
, data
, translen
);
85 err
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), 0,
86 USB_DIR_OUT
| 0x40, 0, 0, buf
, translen
,
95 err
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), 0x2,
96 USB_DIR_OUT
| 0x40, 0, 0, NULL
, 0, ZD1201_FW_TIMEOUT
);
100 err
= usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), 0x4,
101 USB_DIR_IN
| 0x40, 0, 0, buf
, sizeof(ret
), ZD1201_FW_TIMEOUT
);
105 memcpy(&ret
, buf
, sizeof(ret
));
115 release_firmware(fw_entry
);
119 MODULE_FIRMWARE("zd1201-ap.fw");
120 MODULE_FIRMWARE("zd1201.fw");
122 static void zd1201_usbfree(struct urb
*urb
)
124 struct zd1201
*zd
= urb
->context
;
126 switch(urb
->status
) {
134 dev_warn(&zd
->usb
->dev
, "%s: urb failed: %d\n",
135 zd
->dev
->name
, urb
->status
);
138 kfree(urb
->transfer_buffer
);
150 total: 4 + 2 + 2 + 2 + 2 + 4 = 16
152 static int zd1201_docmd(struct zd1201
*zd
, int cmd
, int parm0
,
153 int parm1
, int parm2
)
155 unsigned char *command
;
159 command
= kmalloc(16, GFP_ATOMIC
);
163 *((__le32
*)command
) = cpu_to_le32(ZD1201_USB_CMDREQ
);
164 *((__le16
*)&command
[4]) = cpu_to_le16(cmd
);
165 *((__le16
*)&command
[6]) = cpu_to_le16(parm0
);
166 *((__le16
*)&command
[8]) = cpu_to_le16(parm1
);
167 *((__le16
*)&command
[10])= cpu_to_le16(parm2
);
169 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
174 usb_fill_bulk_urb(urb
, zd
->usb
, usb_sndbulkpipe(zd
->usb
, zd
->endp_out2
),
175 command
, 16, zd1201_usbfree
, zd
);
176 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
185 /* Callback after sending out a packet */
186 static void zd1201_usbtx(struct urb
*urb
)
188 struct zd1201
*zd
= urb
->context
;
189 netif_wake_queue(zd
->dev
);
193 static void zd1201_usbrx(struct urb
*urb
)
195 struct zd1201
*zd
= urb
->context
;
197 unsigned char *data
= urb
->transfer_buffer
;
204 switch(urb
->status
) {
212 dev_warn(&zd
->usb
->dev
, "%s: rx urb failed: %d\n",
213 zd
->dev
->name
, urb
->status
);
218 if (urb
->status
!= 0 || urb
->actual_length
== 0)
222 if (type
== ZD1201_PACKET_EVENTSTAT
|| type
== ZD1201_PACKET_RESOURCE
) {
223 memcpy(zd
->rxdata
, data
, urb
->actual_length
);
224 zd
->rxlen
= urb
->actual_length
;
226 wake_up(&zd
->rxdataq
);
229 if (type
== ZD1201_PACKET_INQUIRE
) {
231 unsigned short infotype
, framelen
, copylen
;
232 framelen
= le16_to_cpu(*(__le16
*)&data
[4]);
233 infotype
= le16_to_cpu(*(__le16
*)&data
[6]);
235 if (infotype
== ZD1201_INF_LINKSTATUS
) {
238 linkstatus
= le16_to_cpu(*(__le16
*)&data
[8]);
241 netif_carrier_on(zd
->dev
);
244 netif_carrier_off(zd
->dev
);
247 netif_carrier_off(zd
->dev
);
250 netif_carrier_on(zd
->dev
);
253 netif_carrier_off(zd
->dev
);
257 if (infotype
== ZD1201_INF_ASSOCSTATUS
) {
258 short status
= le16_to_cpu(*(__le16
*)(data
+8));
260 union iwreq_data wrqu
;
263 case ZD1201_ASSOCSTATUS_STAASSOC
:
264 case ZD1201_ASSOCSTATUS_REASSOC
:
265 event
= IWEVREGISTERED
;
267 case ZD1201_ASSOCSTATUS_DISASSOC
:
268 case ZD1201_ASSOCSTATUS_ASSOCFAIL
:
269 case ZD1201_ASSOCSTATUS_AUTHFAIL
:
273 memcpy(wrqu
.addr
.sa_data
, data
+10, ETH_ALEN
);
274 wrqu
.addr
.sa_family
= ARPHRD_ETHER
;
276 /* Send event to user space */
277 wireless_send_event(zd
->dev
, event
, &wrqu
, NULL
);
281 if (infotype
== ZD1201_INF_AUTHREQ
) {
282 union iwreq_data wrqu
;
284 memcpy(wrqu
.addr
.sa_data
, data
+8, ETH_ALEN
);
285 wrqu
.addr
.sa_family
= ARPHRD_ETHER
;
286 /* There isn't a event that trully fits this request.
287 We assume that userspace will be smart enough to
288 see a new station being expired and sends back a
289 authstation ioctl to authorize it. */
290 wireless_send_event(zd
->dev
, IWEVEXPIRED
, &wrqu
, NULL
);
293 /* Other infotypes are handled outside this handler */
295 while (i
< urb
->actual_length
) {
296 copylen
= le16_to_cpu(*(__le16
*)&data
[i
+2]);
297 /* Sanity check, sometimes we get junk */
298 if (copylen
+zd
->rxlen
> sizeof(zd
->rxdata
))
300 memcpy(zd
->rxdata
+zd
->rxlen
, data
+i
+4, copylen
);
301 zd
->rxlen
+= copylen
;
304 if (i
>= urb
->actual_length
) {
306 wake_up(&zd
->rxdataq
);
311 if (data
[urb
->actual_length
-1] == ZD1201_PACKET_RXDATA
) {
312 int datalen
= urb
->actual_length
-1;
313 unsigned short len
, fc
, seq
;
315 len
= ntohs(*(__be16
*)&data
[datalen
-2]);
318 fc
= le16_to_cpu(*(__le16
*)&data
[datalen
-16]);
319 seq
= le16_to_cpu(*(__le16
*)&data
[datalen
-24]);
324 if (!(skb
= dev_alloc_skb(datalen
+24)))
327 memcpy(skb_put(skb
, 2), &data
[datalen
-16], 2);
328 memcpy(skb_put(skb
, 2), &data
[datalen
-2], 2);
329 memcpy(skb_put(skb
, 6), &data
[datalen
-14], 6);
330 memcpy(skb_put(skb
, 6), &data
[datalen
-22], 6);
331 memcpy(skb_put(skb
, 6), &data
[datalen
-8], 6);
332 memcpy(skb_put(skb
, 2), &data
[datalen
-24], 2);
333 memcpy(skb_put(skb
, len
), data
, len
);
334 skb
->protocol
= eth_type_trans(skb
, zd
->dev
);
335 zd
->dev
->stats
.rx_packets
++;
336 zd
->dev
->stats
.rx_bytes
+= skb
->len
;
341 if ((seq
& IEEE80211_SCTL_FRAG
) ||
342 (fc
& IEEE80211_FCTL_MOREFRAGS
)) {
343 struct zd1201_frag
*frag
= NULL
;
348 if ((seq
& IEEE80211_SCTL_FRAG
) == 0) {
349 frag
= kmalloc(sizeof(*frag
), GFP_ATOMIC
);
352 skb
= dev_alloc_skb(IEEE80211_MAX_DATA_LEN
+14+2);
358 frag
->seq
= seq
& IEEE80211_SCTL_SEQ
;
360 memcpy(skb_put(skb
, 12), &data
[datalen
-14], 12);
361 memcpy(skb_put(skb
, 2), &data
[6], 2);
362 memcpy(skb_put(skb
, len
), data
+8, len
);
363 hlist_add_head(&frag
->fnode
, &zd
->fraglist
);
366 hlist_for_each_entry(frag
, &zd
->fraglist
, fnode
)
367 if (frag
->seq
== (seq
&IEEE80211_SCTL_SEQ
))
372 ptr
= skb_put(skb
, len
);
374 memcpy(ptr
, data
+8, len
);
375 if (fc
& IEEE80211_FCTL_MOREFRAGS
)
377 hlist_del_init(&frag
->fnode
);
382 skb
= dev_alloc_skb(len
+ 14 + 2);
386 memcpy(skb_put(skb
, 12), &data
[datalen
-14], 12);
387 memcpy(skb_put(skb
, 2), &data
[6], 2);
388 memcpy(skb_put(skb
, len
), data
+8, len
);
390 skb
->protocol
= eth_type_trans(skb
, zd
->dev
);
391 zd
->dev
->stats
.rx_packets
++;
392 zd
->dev
->stats
.rx_bytes
+= skb
->len
;
396 memset(data
, 0, ZD1201_RXSIZE
);
400 if(usb_submit_urb(urb
, GFP_ATOMIC
))
407 wake_up(&zd
->rxdataq
);
408 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
;
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 dev
->stats
.tx_errors
++;
845 /* Restart the timeout to quiet the watchdog: */
846 dev
->trans_start
= jiffies
; /* prevent tx timeout */
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 iw_statistics
*zd1201_get_wireless_stats(struct net_device
*dev
)
869 struct zd1201
*zd
= netdev_priv(dev
);
874 static void zd1201_set_multicast(struct net_device
*dev
)
876 struct zd1201
*zd
= netdev_priv(dev
);
877 struct netdev_hw_addr
*ha
;
878 unsigned char reqbuf
[ETH_ALEN
*ZD1201_MAXMULTI
];
881 if (netdev_mc_count(dev
) > ZD1201_MAXMULTI
)
885 netdev_for_each_mc_addr(ha
, dev
)
886 memcpy(reqbuf
+ i
++ * ETH_ALEN
, ha
->addr
, ETH_ALEN
);
887 zd1201_setconfig(zd
, ZD1201_RID_CNFGROUPADDRESS
, reqbuf
,
888 netdev_mc_count(dev
) * ETH_ALEN
, 0);
891 static int zd1201_config_commit(struct net_device
*dev
,
892 struct iw_request_info
*info
, struct iw_point
*data
, char *essid
)
894 struct zd1201
*zd
= netdev_priv(dev
);
896 return zd1201_mac_reset(zd
);
899 static int zd1201_get_name(struct net_device
*dev
,
900 struct iw_request_info
*info
, char *name
, char *extra
)
902 strcpy(name
, "IEEE 802.11b");
906 static int zd1201_set_freq(struct net_device
*dev
,
907 struct iw_request_info
*info
, struct iw_freq
*freq
, char *extra
)
909 struct zd1201
*zd
= netdev_priv(dev
);
916 channel
= ieee80211_freq_to_dsss_chan(freq
->m
);
921 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFOWNCHANNEL
, channel
);
925 zd1201_mac_reset(zd
);
930 static int zd1201_get_freq(struct net_device
*dev
,
931 struct iw_request_info
*info
, struct iw_freq
*freq
, char *extra
)
933 struct zd1201
*zd
= netdev_priv(dev
);
937 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFOWNCHANNEL
, &channel
);
946 static int zd1201_set_mode(struct net_device
*dev
,
947 struct iw_request_info
*info
, __u32
*mode
, char *extra
)
949 struct zd1201
*zd
= netdev_priv(dev
);
950 short porttype
, monitor
= 0;
951 unsigned char buffer
[IW_ESSID_MAX_SIZE
+2];
955 if (*mode
!= IW_MODE_MASTER
)
960 err
= zd1201_setconfig16(zd
, ZD1201_RID_PROMISCUOUSMODE
, 0);
963 zd
->dev
->type
= ARPHRD_ETHER
;
965 case IW_MODE_MONITOR
:
967 zd
->dev
->type
= ARPHRD_IEEE80211
;
968 /* Make sure we are no longer associated with by
969 setting an 'impossible' essid.
970 (otherwise we mess up firmware)
972 zd1201_join(zd
, "\0-*#\0", 5);
973 /* Put port in pIBSS */
974 case 8: /* No pseudo-IBSS in wireless extensions (yet) */
975 porttype
= ZD1201_PORTTYPE_PSEUDOIBSS
;
978 porttype
= ZD1201_PORTTYPE_IBSS
;
981 porttype
= ZD1201_PORTTYPE_BSS
;
987 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFPORTTYPE
, porttype
);
990 if (zd
->monitor
&& !monitor
) {
992 *(__le16
*)buffer
= cpu_to_le16(zd
->essidlen
);
993 memcpy(buffer
+2, zd
->essid
, zd
->essidlen
);
994 err
= zd1201_setconfig(zd
, ZD1201_RID_CNFDESIREDSSID
,
995 buffer
, IW_ESSID_MAX_SIZE
+2, 1);
999 zd
->monitor
= monitor
;
1000 /* If monitor mode is set we don't actually turn it on here since it
1001 * is done during mac reset anyway (see zd1201_mac_enable).
1003 zd1201_mac_reset(zd
);
1008 static int zd1201_get_mode(struct net_device
*dev
,
1009 struct iw_request_info
*info
, __u32
*mode
, char *extra
)
1011 struct zd1201
*zd
= netdev_priv(dev
);
1015 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFPORTTYPE
, &porttype
);
1019 case ZD1201_PORTTYPE_IBSS
:
1020 *mode
= IW_MODE_ADHOC
;
1022 case ZD1201_PORTTYPE_BSS
:
1023 *mode
= IW_MODE_INFRA
;
1025 case ZD1201_PORTTYPE_WDS
:
1026 *mode
= IW_MODE_REPEAT
;
1028 case ZD1201_PORTTYPE_PSEUDOIBSS
:
1029 *mode
= 8;/* No Pseudo-IBSS... */
1031 case ZD1201_PORTTYPE_AP
:
1032 *mode
= IW_MODE_MASTER
;
1035 dev_dbg(&zd
->usb
->dev
, "Unknown porttype: %d\n",
1037 *mode
= IW_MODE_AUTO
;
1040 *mode
= IW_MODE_MONITOR
;
1045 static int zd1201_get_range(struct net_device
*dev
,
1046 struct iw_request_info
*info
, struct iw_point
*wrq
, char *extra
)
1048 struct iw_range
*range
= (struct iw_range
*)extra
;
1050 wrq
->length
= sizeof(struct iw_range
);
1051 memset(range
, 0, sizeof(struct iw_range
));
1052 range
->we_version_compiled
= WIRELESS_EXT
;
1053 range
->we_version_source
= WIRELESS_EXT
;
1055 range
->max_qual
.qual
= 128;
1056 range
->max_qual
.level
= 128;
1057 range
->max_qual
.noise
= 128;
1058 range
->max_qual
.updated
= 7;
1060 range
->encoding_size
[0] = 5;
1061 range
->encoding_size
[1] = 13;
1062 range
->num_encoding_sizes
= 2;
1063 range
->max_encoding_tokens
= ZD1201_NUMKEYS
;
1065 range
->num_bitrates
= 4;
1066 range
->bitrate
[0] = 1000000;
1067 range
->bitrate
[1] = 2000000;
1068 range
->bitrate
[2] = 5500000;
1069 range
->bitrate
[3] = 11000000;
1072 range
->min_frag
= ZD1201_FRAGMIN
;
1073 range
->max_rts
= ZD1201_RTSMAX
;
1074 range
->min_frag
= ZD1201_FRAGMAX
;
1079 /* Little bit of magic here: we only get the quality if we poll
1080 * for it, and we never get an actual request to trigger such
1081 * a poll. Therefore we 'assume' that the user will soon ask for
1082 * the stats after asking the bssid.
1084 static int zd1201_get_wap(struct net_device
*dev
,
1085 struct iw_request_info
*info
, struct sockaddr
*ap_addr
, char *extra
)
1087 struct zd1201
*zd
= netdev_priv(dev
);
1088 unsigned char buffer
[6];
1090 if (!zd1201_getconfig(zd
, ZD1201_RID_COMMSQUALITY
, buffer
, 6)) {
1091 /* Unfortunately the quality and noise reported is useless.
1092 they seem to be accumulators that increase until you
1093 read them, unless we poll on a fixed interval we can't
1096 /*zd->iwstats.qual.qual = le16_to_cpu(((__le16 *)buffer)[0]);*/
1097 zd
->iwstats
.qual
.level
= le16_to_cpu(((__le16
*)buffer
)[1]);
1098 /*zd->iwstats.qual.noise = le16_to_cpu(((__le16 *)buffer)[2]);*/
1099 zd
->iwstats
.qual
.updated
= 2;
1102 return zd1201_getconfig(zd
, ZD1201_RID_CURRENTBSSID
, ap_addr
->sa_data
, 6);
1105 static int zd1201_set_scan(struct net_device
*dev
,
1106 struct iw_request_info
*info
, struct iw_point
*srq
, char *extra
)
1108 /* We do everything in get_scan */
1112 static int zd1201_get_scan(struct net_device
*dev
,
1113 struct iw_request_info
*info
, struct iw_point
*srq
, char *extra
)
1115 struct zd1201
*zd
= netdev_priv(dev
);
1116 int err
, i
, j
, enabled_save
;
1117 struct iw_event iwe
;
1119 char *end_buf
= extra
+ IW_SCAN_MAX_DATA
;
1121 /* No scanning in AP mode */
1125 /* Scan doesn't seem to work if disabled */
1126 enabled_save
= zd
->mac_enabled
;
1130 err
= zd1201_docmd(zd
, ZD1201_CMDCODE_INQUIRE
,
1131 ZD1201_INQ_SCANRESULTS
, 0, 0);
1135 wait_event_interruptible(zd
->rxdataq
, zd
->rxdatas
);
1139 if (le16_to_cpu(*(__le16
*)&zd
->rxdata
[2]) != ZD1201_INQ_SCANRESULTS
)
1142 for(i
=8; i
<zd
->rxlen
; i
+=62) {
1143 iwe
.cmd
= SIOCGIWAP
;
1144 iwe
.u
.ap_addr
.sa_family
= ARPHRD_ETHER
;
1145 memcpy(iwe
.u
.ap_addr
.sa_data
, zd
->rxdata
+i
+6, 6);
1146 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1147 &iwe
, IW_EV_ADDR_LEN
);
1149 iwe
.cmd
= SIOCGIWESSID
;
1150 iwe
.u
.data
.length
= zd
->rxdata
[i
+16];
1151 iwe
.u
.data
.flags
= 1;
1152 cev
= iwe_stream_add_point(info
, cev
, end_buf
,
1153 &iwe
, zd
->rxdata
+i
+18);
1155 iwe
.cmd
= SIOCGIWMODE
;
1156 if (zd
->rxdata
[i
+14]&0x01)
1157 iwe
.u
.mode
= IW_MODE_MASTER
;
1159 iwe
.u
.mode
= IW_MODE_ADHOC
;
1160 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1161 &iwe
, IW_EV_UINT_LEN
);
1163 iwe
.cmd
= SIOCGIWFREQ
;
1164 iwe
.u
.freq
.m
= zd
->rxdata
[i
+0];
1166 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1167 &iwe
, IW_EV_FREQ_LEN
);
1169 iwe
.cmd
= SIOCGIWRATE
;
1170 iwe
.u
.bitrate
.fixed
= 0;
1171 iwe
.u
.bitrate
.disabled
= 0;
1172 for (j
=0; j
<10; j
++) if (zd
->rxdata
[i
+50+j
]) {
1173 iwe
.u
.bitrate
.value
= (zd
->rxdata
[i
+50+j
]&0x7f)*500000;
1174 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1175 &iwe
, IW_EV_PARAM_LEN
);
1178 iwe
.cmd
= SIOCGIWENCODE
;
1179 iwe
.u
.data
.length
= 0;
1180 if (zd
->rxdata
[i
+14]&0x10)
1181 iwe
.u
.data
.flags
= IW_ENCODE_ENABLED
;
1183 iwe
.u
.data
.flags
= IW_ENCODE_DISABLED
;
1184 cev
= iwe_stream_add_point(info
, cev
, end_buf
, &iwe
, NULL
);
1187 iwe
.u
.qual
.qual
= zd
->rxdata
[i
+4];
1188 iwe
.u
.qual
.noise
= zd
->rxdata
[i
+2]/10-100;
1189 iwe
.u
.qual
.level
= (256+zd
->rxdata
[i
+4]*100)/255-100;
1190 iwe
.u
.qual
.updated
= 7;
1191 cev
= iwe_stream_add_event(info
, cev
, end_buf
,
1192 &iwe
, IW_EV_QUAL_LEN
);
1198 srq
->length
= cev
- extra
;
1204 static int zd1201_set_essid(struct net_device
*dev
,
1205 struct iw_request_info
*info
, struct iw_point
*data
, char *essid
)
1207 struct zd1201
*zd
= netdev_priv(dev
);
1209 if (data
->length
> IW_ESSID_MAX_SIZE
)
1211 if (data
->length
< 1)
1213 zd
->essidlen
= data
->length
;
1214 memset(zd
->essid
, 0, IW_ESSID_MAX_SIZE
+1);
1215 memcpy(zd
->essid
, essid
, data
->length
);
1216 return zd1201_join(zd
, zd
->essid
, zd
->essidlen
);
1219 static int zd1201_get_essid(struct net_device
*dev
,
1220 struct iw_request_info
*info
, struct iw_point
*data
, char *essid
)
1222 struct zd1201
*zd
= netdev_priv(dev
);
1224 memcpy(essid
, zd
->essid
, zd
->essidlen
);
1226 data
->length
= zd
->essidlen
;
1231 static int zd1201_get_nick(struct net_device
*dev
, struct iw_request_info
*info
,
1232 struct iw_point
*data
, char *nick
)
1234 strcpy(nick
, "zd1201");
1236 data
->length
= strlen(nick
);
1240 static int zd1201_set_rate(struct net_device
*dev
,
1241 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1243 struct zd1201
*zd
= netdev_priv(dev
);
1247 switch (rrq
->value
) {
1249 rate
= ZD1201_RATEB1
;
1252 rate
= ZD1201_RATEB2
;
1255 rate
= ZD1201_RATEB5
;
1259 rate
= ZD1201_RATEB11
;
1262 if (!rrq
->fixed
) { /* Also enable all lower bitrates */
1266 err
= zd1201_setconfig16(zd
, ZD1201_RID_TXRATECNTL
, rate
);
1270 return zd1201_mac_reset(zd
);
1273 static int zd1201_get_rate(struct net_device
*dev
,
1274 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1276 struct zd1201
*zd
= netdev_priv(dev
);
1280 err
= zd1201_getconfig16(zd
, ZD1201_RID_CURRENTTXRATE
, &rate
);
1286 rrq
->value
= 1000000;
1289 rrq
->value
= 2000000;
1292 rrq
->value
= 5500000;
1295 rrq
->value
= 11000000;
1306 static int zd1201_set_rts(struct net_device
*dev
, struct iw_request_info
*info
,
1307 struct iw_param
*rts
, char *extra
)
1309 struct zd1201
*zd
= netdev_priv(dev
);
1311 short val
= rts
->value
;
1313 if (rts
->disabled
|| !rts
->fixed
)
1314 val
= ZD1201_RTSMAX
;
1315 if (val
> ZD1201_RTSMAX
)
1320 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFRTSTHRESHOLD
, val
);
1323 return zd1201_mac_reset(zd
);
1326 static int zd1201_get_rts(struct net_device
*dev
, struct iw_request_info
*info
,
1327 struct iw_param
*rts
, char *extra
)
1329 struct zd1201
*zd
= netdev_priv(dev
);
1333 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFRTSTHRESHOLD
, &rtst
);
1337 rts
->disabled
= (rts
->value
== ZD1201_RTSMAX
);
1343 static int zd1201_set_frag(struct net_device
*dev
, struct iw_request_info
*info
,
1344 struct iw_param
*frag
, char *extra
)
1346 struct zd1201
*zd
= netdev_priv(dev
);
1348 short val
= frag
->value
;
1350 if (frag
->disabled
|| !frag
->fixed
)
1351 val
= ZD1201_FRAGMAX
;
1352 if (val
> ZD1201_FRAGMAX
)
1354 if (val
< ZD1201_FRAGMIN
)
1358 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFFRAGTHRESHOLD
, val
);
1361 return zd1201_mac_reset(zd
);
1364 static int zd1201_get_frag(struct net_device
*dev
, struct iw_request_info
*info
,
1365 struct iw_param
*frag
, char *extra
)
1367 struct zd1201
*zd
= netdev_priv(dev
);
1371 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFFRAGTHRESHOLD
, &fragt
);
1374 frag
->value
= fragt
;
1375 frag
->disabled
= (frag
->value
== ZD1201_FRAGMAX
);
1381 static int zd1201_set_retry(struct net_device
*dev
,
1382 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1387 static int zd1201_get_retry(struct net_device
*dev
,
1388 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1393 static int zd1201_set_encode(struct net_device
*dev
,
1394 struct iw_request_info
*info
, struct iw_point
*erq
, char *key
)
1396 struct zd1201
*zd
= netdev_priv(dev
);
1400 if (erq
->length
> ZD1201_MAXKEYLEN
)
1403 i
= (erq
->flags
& IW_ENCODE_INDEX
)-1;
1405 err
= zd1201_getconfig16(zd
,ZD1201_RID_CNFDEFAULTKEYID
,&i
);
1409 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFDEFAULTKEYID
, i
);
1414 if (i
< 0 || i
>= ZD1201_NUMKEYS
)
1417 rid
= ZD1201_RID_CNFDEFAULTKEY0
+ i
;
1418 err
= zd1201_setconfig(zd
, rid
, key
, erq
->length
, 1);
1421 zd
->encode_keylen
[i
] = erq
->length
;
1422 memcpy(zd
->encode_keys
[i
], key
, erq
->length
);
1425 if (!(erq
->flags
& IW_ENCODE_DISABLED
& IW_ENCODE_MODE
)) {
1427 zd
->encode_enabled
= 1;
1429 zd
->encode_enabled
= 0;
1430 if (erq
->flags
& IW_ENCODE_RESTRICTED
& IW_ENCODE_MODE
) {
1432 zd
->encode_restricted
= 1;
1434 zd
->encode_restricted
= 0;
1435 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFWEBFLAGS
, i
);
1439 if (zd
->encode_enabled
)
1440 i
= ZD1201_CNFAUTHENTICATION_SHAREDKEY
;
1442 i
= ZD1201_CNFAUTHENTICATION_OPENSYSTEM
;
1443 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFAUTHENTICATION
, i
);
1447 return zd1201_mac_reset(zd
);
1450 static int zd1201_get_encode(struct net_device
*dev
,
1451 struct iw_request_info
*info
, struct iw_point
*erq
, char *key
)
1453 struct zd1201
*zd
= netdev_priv(dev
);
1457 if (zd
->encode_enabled
)
1458 erq
->flags
= IW_ENCODE_ENABLED
;
1460 erq
->flags
= IW_ENCODE_DISABLED
;
1461 if (zd
->encode_restricted
)
1462 erq
->flags
|= IW_ENCODE_RESTRICTED
;
1464 erq
->flags
|= IW_ENCODE_OPEN
;
1466 i
= (erq
->flags
& IW_ENCODE_INDEX
) -1;
1468 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFDEFAULTKEYID
, &i
);
1472 if (i
<0 || i
>= ZD1201_NUMKEYS
)
1477 erq
->length
= zd
->encode_keylen
[i
];
1478 memcpy(key
, zd
->encode_keys
[i
], erq
->length
);
1483 static int zd1201_set_power(struct net_device
*dev
,
1484 struct iw_request_info
*info
, struct iw_param
*vwrq
, char *extra
)
1486 struct zd1201
*zd
= netdev_priv(dev
);
1487 short enabled
, duration
, level
;
1490 enabled
= vwrq
->disabled
? 0 : 1;
1492 if (vwrq
->flags
& IW_POWER_PERIOD
) {
1493 duration
= vwrq
->value
;
1494 err
= zd1201_setconfig16(zd
,
1495 ZD1201_RID_CNFMAXSLEEPDURATION
, duration
);
1500 if (vwrq
->flags
& IW_POWER_TIMEOUT
) {
1501 err
= zd1201_getconfig16(zd
,
1502 ZD1201_RID_CNFMAXSLEEPDURATION
, &duration
);
1505 level
= vwrq
->value
* 4 / duration
;
1510 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFPMEPS
,
1519 return zd1201_setconfig16(zd
, ZD1201_RID_CNFPMENABLED
, enabled
);
1522 static int zd1201_get_power(struct net_device
*dev
,
1523 struct iw_request_info
*info
, struct iw_param
*vwrq
, char *extra
)
1525 struct zd1201
*zd
= netdev_priv(dev
);
1526 short enabled
, level
, duration
;
1529 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFPMENABLED
, &enabled
);
1532 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFPMEPS
, &level
);
1535 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFMAXSLEEPDURATION
, &duration
);
1538 vwrq
->disabled
= enabled
? 0 : 1;
1539 if (vwrq
->flags
& IW_POWER_TYPE
) {
1540 if (vwrq
->flags
& IW_POWER_PERIOD
) {
1541 vwrq
->value
= duration
;
1542 vwrq
->flags
= IW_POWER_PERIOD
;
1544 vwrq
->value
= duration
* level
/ 4;
1545 vwrq
->flags
= IW_POWER_TIMEOUT
;
1548 if (vwrq
->flags
& IW_POWER_MODE
) {
1549 if (enabled
&& level
)
1550 vwrq
->flags
= IW_POWER_UNICAST_R
;
1552 vwrq
->flags
= IW_POWER_ALL_R
;
1559 static const iw_handler zd1201_iw_handler
[] =
1561 (iw_handler
) zd1201_config_commit
, /* SIOCSIWCOMMIT */
1562 (iw_handler
) zd1201_get_name
, /* SIOCGIWNAME */
1563 (iw_handler
) NULL
, /* SIOCSIWNWID */
1564 (iw_handler
) NULL
, /* SIOCGIWNWID */
1565 (iw_handler
) zd1201_set_freq
, /* SIOCSIWFREQ */
1566 (iw_handler
) zd1201_get_freq
, /* SIOCGIWFREQ */
1567 (iw_handler
) zd1201_set_mode
, /* SIOCSIWMODE */
1568 (iw_handler
) zd1201_get_mode
, /* SIOCGIWMODE */
1569 (iw_handler
) NULL
, /* SIOCSIWSENS */
1570 (iw_handler
) NULL
, /* SIOCGIWSENS */
1571 (iw_handler
) NULL
, /* SIOCSIWRANGE */
1572 (iw_handler
) zd1201_get_range
, /* SIOCGIWRANGE */
1573 (iw_handler
) NULL
, /* SIOCSIWPRIV */
1574 (iw_handler
) NULL
, /* SIOCGIWPRIV */
1575 (iw_handler
) NULL
, /* SIOCSIWSTATS */
1576 (iw_handler
) NULL
, /* SIOCGIWSTATS */
1577 (iw_handler
) NULL
, /* SIOCSIWSPY */
1578 (iw_handler
) NULL
, /* SIOCGIWSPY */
1579 (iw_handler
) NULL
, /* -- hole -- */
1580 (iw_handler
) NULL
, /* -- hole -- */
1581 (iw_handler
) NULL
/*zd1201_set_wap*/, /* SIOCSIWAP */
1582 (iw_handler
) zd1201_get_wap
, /* SIOCGIWAP */
1583 (iw_handler
) NULL
, /* -- hole -- */
1584 (iw_handler
) NULL
, /* SIOCGIWAPLIST */
1585 (iw_handler
) zd1201_set_scan
, /* SIOCSIWSCAN */
1586 (iw_handler
) zd1201_get_scan
, /* SIOCGIWSCAN */
1587 (iw_handler
) zd1201_set_essid
, /* SIOCSIWESSID */
1588 (iw_handler
) zd1201_get_essid
, /* SIOCGIWESSID */
1589 (iw_handler
) NULL
, /* SIOCSIWNICKN */
1590 (iw_handler
) zd1201_get_nick
, /* SIOCGIWNICKN */
1591 (iw_handler
) NULL
, /* -- hole -- */
1592 (iw_handler
) NULL
, /* -- hole -- */
1593 (iw_handler
) zd1201_set_rate
, /* SIOCSIWRATE */
1594 (iw_handler
) zd1201_get_rate
, /* SIOCGIWRATE */
1595 (iw_handler
) zd1201_set_rts
, /* SIOCSIWRTS */
1596 (iw_handler
) zd1201_get_rts
, /* SIOCGIWRTS */
1597 (iw_handler
) zd1201_set_frag
, /* SIOCSIWFRAG */
1598 (iw_handler
) zd1201_get_frag
, /* SIOCGIWFRAG */
1599 (iw_handler
) NULL
, /* SIOCSIWTXPOW */
1600 (iw_handler
) NULL
, /* SIOCGIWTXPOW */
1601 (iw_handler
) zd1201_set_retry
, /* SIOCSIWRETRY */
1602 (iw_handler
) zd1201_get_retry
, /* SIOCGIWRETRY */
1603 (iw_handler
) zd1201_set_encode
, /* SIOCSIWENCODE */
1604 (iw_handler
) zd1201_get_encode
, /* SIOCGIWENCODE */
1605 (iw_handler
) zd1201_set_power
, /* SIOCSIWPOWER */
1606 (iw_handler
) zd1201_get_power
, /* SIOCGIWPOWER */
1609 static int zd1201_set_hostauth(struct net_device
*dev
,
1610 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1612 struct zd1201
*zd
= netdev_priv(dev
);
1617 return zd1201_setconfig16(zd
, ZD1201_RID_CNFHOSTAUTH
, rrq
->value
);
1620 static int zd1201_get_hostauth(struct net_device
*dev
,
1621 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1623 struct zd1201
*zd
= netdev_priv(dev
);
1630 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFHOSTAUTH
, &hostauth
);
1633 rrq
->value
= hostauth
;
1639 static int zd1201_auth_sta(struct net_device
*dev
,
1640 struct iw_request_info
*info
, struct sockaddr
*sta
, char *extra
)
1642 struct zd1201
*zd
= netdev_priv(dev
);
1643 unsigned char buffer
[10];
1648 memcpy(buffer
, sta
->sa_data
, ETH_ALEN
);
1649 *(short*)(buffer
+6) = 0; /* 0==success, 1==failure */
1650 *(short*)(buffer
+8) = 0;
1652 return zd1201_setconfig(zd
, ZD1201_RID_AUTHENTICATESTA
, buffer
, 10, 1);
1655 static int zd1201_set_maxassoc(struct net_device
*dev
,
1656 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1658 struct zd1201
*zd
= netdev_priv(dev
);
1664 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFMAXASSOCSTATIONS
, rrq
->value
);
1670 static int zd1201_get_maxassoc(struct net_device
*dev
,
1671 struct iw_request_info
*info
, struct iw_param
*rrq
, char *extra
)
1673 struct zd1201
*zd
= netdev_priv(dev
);
1680 err
= zd1201_getconfig16(zd
, ZD1201_RID_CNFMAXASSOCSTATIONS
, &maxassoc
);
1683 rrq
->value
= maxassoc
;
1689 static const iw_handler zd1201_private_handler
[] = {
1690 (iw_handler
) zd1201_set_hostauth
, /* ZD1201SIWHOSTAUTH */
1691 (iw_handler
) zd1201_get_hostauth
, /* ZD1201GIWHOSTAUTH */
1692 (iw_handler
) zd1201_auth_sta
, /* ZD1201SIWAUTHSTA */
1693 (iw_handler
) NULL
, /* nothing to get */
1694 (iw_handler
) zd1201_set_maxassoc
, /* ZD1201SIMAXASSOC */
1695 (iw_handler
) zd1201_get_maxassoc
, /* ZD1201GIMAXASSOC */
1698 static const struct iw_priv_args zd1201_private_args
[] = {
1699 { ZD1201SIWHOSTAUTH
, IW_PRIV_TYPE_INT
| IW_PRIV_SIZE_FIXED
| 1,
1700 IW_PRIV_TYPE_NONE
, "sethostauth" },
1701 { ZD1201GIWHOSTAUTH
, IW_PRIV_TYPE_NONE
,
1702 IW_PRIV_TYPE_INT
| IW_PRIV_SIZE_FIXED
| 1, "gethostauth" },
1703 { ZD1201SIWAUTHSTA
, IW_PRIV_TYPE_ADDR
| IW_PRIV_SIZE_FIXED
| 1,
1704 IW_PRIV_TYPE_NONE
, "authstation" },
1705 { ZD1201SIWMAXASSOC
, IW_PRIV_TYPE_INT
| IW_PRIV_SIZE_FIXED
| 1,
1706 IW_PRIV_TYPE_NONE
, "setmaxassoc" },
1707 { ZD1201GIWMAXASSOC
, IW_PRIV_TYPE_NONE
,
1708 IW_PRIV_TYPE_INT
| IW_PRIV_SIZE_FIXED
| 1, "getmaxassoc" },
1711 static const struct iw_handler_def zd1201_iw_handlers
= {
1712 .num_standard
= ARRAY_SIZE(zd1201_iw_handler
),
1713 .num_private
= ARRAY_SIZE(zd1201_private_handler
),
1714 .num_private_args
= ARRAY_SIZE(zd1201_private_args
),
1715 .standard
= (iw_handler
*)zd1201_iw_handler
,
1716 .private = (iw_handler
*)zd1201_private_handler
,
1717 .private_args
= (struct iw_priv_args
*) zd1201_private_args
,
1718 .get_wireless_stats
= zd1201_get_wireless_stats
,
1721 static const struct net_device_ops zd1201_netdev_ops
= {
1722 .ndo_open
= zd1201_net_open
,
1723 .ndo_stop
= zd1201_net_stop
,
1724 .ndo_start_xmit
= zd1201_hard_start_xmit
,
1725 .ndo_tx_timeout
= zd1201_tx_timeout
,
1726 .ndo_set_rx_mode
= zd1201_set_multicast
,
1727 .ndo_set_mac_address
= zd1201_set_mac_address
,
1728 .ndo_change_mtu
= eth_change_mtu
,
1729 .ndo_validate_addr
= eth_validate_addr
,
1732 static int zd1201_probe(struct usb_interface
*interface
,
1733 const struct usb_device_id
*id
)
1736 struct net_device
*dev
;
1737 struct usb_device
*usb
;
1740 char buf
[IW_ESSID_MAX_SIZE
+2];
1742 usb
= interface_to_usbdev(interface
);
1744 dev
= alloc_etherdev(sizeof(*zd
));
1747 zd
= netdev_priv(dev
);
1753 init_waitqueue_head(&zd
->rxdataq
);
1754 INIT_HLIST_HEAD(&zd
->fraglist
);
1756 err
= zd1201_fw_upload(usb
, zd
->ap
);
1758 dev_err(&usb
->dev
, "zd1201 firmware upload failed: %d\n", err
);
1765 zd
->rx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
1766 zd
->tx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
1767 if (!zd
->rx_urb
|| !zd
->tx_urb
)
1771 err
= zd1201_drvr_start(zd
);
1775 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFMAXDATALEN
, 2312);
1779 err
= zd1201_setconfig16(zd
, ZD1201_RID_TXRATECNTL
,
1780 ZD1201_RATEB1
| ZD1201_RATEB2
| ZD1201_RATEB5
| ZD1201_RATEB11
);
1784 dev
->netdev_ops
= &zd1201_netdev_ops
;
1785 dev
->wireless_handlers
= &zd1201_iw_handlers
;
1786 dev
->watchdog_timeo
= ZD1201_TX_TIMEOUT
;
1787 strcpy(dev
->name
, "wlan%d");
1789 err
= zd1201_getconfig(zd
, ZD1201_RID_CNFOWNMACADDR
,
1790 dev
->dev_addr
, dev
->addr_len
);
1794 /* Set wildcard essid to match zd->essid */
1795 *(__le16
*)buf
= cpu_to_le16(0);
1796 err
= zd1201_setconfig(zd
, ZD1201_RID_CNFDESIREDSSID
, buf
,
1797 IW_ESSID_MAX_SIZE
+2, 1);
1802 porttype
= ZD1201_PORTTYPE_AP
;
1804 porttype
= ZD1201_PORTTYPE_BSS
;
1805 err
= zd1201_setconfig16(zd
, ZD1201_RID_CNFPORTTYPE
, porttype
);
1809 SET_NETDEV_DEV(dev
, &usb
->dev
);
1811 err
= register_netdev(dev
);
1814 dev_info(&usb
->dev
, "%s: ZD1201 USB Wireless interface\n",
1817 usb_set_intfdata(interface
, zd
);
1818 zd1201_enable(zd
); /* zd1201 likes to startup enabled, */
1819 zd1201_disable(zd
); /* interfering with all the wifis in range */
1823 /* Leave the device in reset state */
1824 zd1201_docmd(zd
, ZD1201_CMDCODE_INIT
, 0, 0, 0);
1826 usb_free_urb(zd
->tx_urb
);
1827 usb_free_urb(zd
->rx_urb
);
1832 static void zd1201_disconnect(struct usb_interface
*interface
)
1834 struct zd1201
*zd
= usb_get_intfdata(interface
);
1835 struct hlist_node
*node2
;
1836 struct zd1201_frag
*frag
;
1840 usb_set_intfdata(interface
, NULL
);
1842 hlist_for_each_entry_safe(frag
, node2
, &zd
->fraglist
, fnode
) {
1843 hlist_del_init(&frag
->fnode
);
1844 kfree_skb(frag
->skb
);
1849 usb_kill_urb(zd
->tx_urb
);
1850 usb_free_urb(zd
->tx_urb
);
1853 usb_kill_urb(zd
->rx_urb
);
1854 usb_free_urb(zd
->rx_urb
);
1858 unregister_netdev(zd
->dev
);
1859 free_netdev(zd
->dev
);
1865 static int zd1201_suspend(struct usb_interface
*interface
,
1866 pm_message_t message
)
1868 struct zd1201
*zd
= usb_get_intfdata(interface
);
1870 netif_device_detach(zd
->dev
);
1872 zd
->was_enabled
= zd
->mac_enabled
;
1874 if (zd
->was_enabled
)
1875 return zd1201_disable(zd
);
1880 static int zd1201_resume(struct usb_interface
*interface
)
1882 struct zd1201
*zd
= usb_get_intfdata(interface
);
1884 if (!zd
|| !zd
->dev
)
1887 netif_device_attach(zd
->dev
);
1889 if (zd
->was_enabled
)
1890 return zd1201_enable(zd
);
1897 #define zd1201_suspend NULL
1898 #define zd1201_resume NULL
1902 static struct usb_driver zd1201_usb
= {
1904 .probe
= zd1201_probe
,
1905 .disconnect
= zd1201_disconnect
,
1906 .id_table
= zd1201_table
,
1907 .suspend
= zd1201_suspend
,
1908 .resume
= zd1201_resume
,
1909 .disable_hub_initiated_lpm
= 1,
1912 module_usb_driver(zd1201_usb
);