Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit f988f272fe8de462045e9f298e5b7f1e39b2e53a

Authored by Mariusz Kozlowski
Committed by Greg Kroah-Hartman
1 parent 8fd31e1d85
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

usb: zd1201 free urb cleanup 

- usb_free_urb() cleanup

Signed-off-by: Mariusz Kozlowski <m.kozlowski@tuxland.pl>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

Showing 1 changed file with 2 additions and 4 deletions Inline Diff

drivers/net/wireless/zd1201.c
Diff comments   View file @ f988f27
1 /* 1 /*
2 * Driver for ZyDAS zd1201 based wireless USB devices. 2 * Driver for ZyDAS zd1201 based wireless USB devices.
3 * 3 *
4 * Copyright (c) 2004, 2005 Jeroen Vreeken (pe1rxq@amsat.org) 4 * Copyright (c) 2004, 2005 Jeroen Vreeken (pe1rxq@amsat.org)
5 * 5 *
6 * This program is free software; you can redistribute it and/or 6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License 7 * modify it under the terms of the GNU General Public License
8 * version 2 as published by the Free Software Foundation. 8 * version 2 as published by the Free Software Foundation.
9 * 9 *
10 * Parts of this driver have been derived from a wlan-ng version 10 * Parts of this driver have been derived from a wlan-ng version
11 * modified by ZyDAS. They also made documentation available, thanks! 11 * modified by ZyDAS. They also made documentation available, thanks!
12 * Copyright (C) 1999 AbsoluteValue Systems, Inc. All Rights Reserved. 12 * Copyright (C) 1999 AbsoluteValue Systems, Inc. All Rights Reserved.
13 */ 13 */
14 14
15 #include <linux/module.h> 15 #include <linux/module.h>
16 #include <linux/usb.h> 16 #include <linux/usb.h>
17 #include <linux/netdevice.h> 17 #include <linux/netdevice.h>
18 #include <linux/etherdevice.h> 18 #include <linux/etherdevice.h>
19 #include <linux/wireless.h> 19 #include <linux/wireless.h>
20 #include <net/iw_handler.h> 20 #include <net/iw_handler.h>
21 #include <linux/string.h> 21 #include <linux/string.h>
22 #include <linux/if_arp.h> 22 #include <linux/if_arp.h>
23 #include <linux/firmware.h> 23 #include <linux/firmware.h>
24 #include <net/ieee80211.h> 24 #include <net/ieee80211.h>
25 #include "zd1201.h" 25 #include "zd1201.h"
26 26
27 static struct usb_device_id zd1201_table[] = { 27 static struct usb_device_id zd1201_table[] = {
28 {USB_DEVICE(0x0586, 0x3400)}, /* Peabird Wireless USB Adapter */ 28 {USB_DEVICE(0x0586, 0x3400)}, /* Peabird Wireless USB Adapter */
29 {USB_DEVICE(0x0ace, 0x1201)}, /* ZyDAS ZD1201 Wireless USB Adapter */ 29 {USB_DEVICE(0x0ace, 0x1201)}, /* ZyDAS ZD1201 Wireless USB Adapter */
30 {USB_DEVICE(0x050d, 0x6051)}, /* Belkin F5D6051 usb adapter */ 30 {USB_DEVICE(0x050d, 0x6051)}, /* Belkin F5D6051 usb adapter */
31 {USB_DEVICE(0x0db0, 0x6823)}, /* MSI UB11B usb adapter */ 31 {USB_DEVICE(0x0db0, 0x6823)}, /* MSI UB11B usb adapter */
32 {USB_DEVICE(0x1044, 0x8005)}, /* GIGABYTE GN-WLBZ201 usb adapter */ 32 {USB_DEVICE(0x1044, 0x8005)}, /* GIGABYTE GN-WLBZ201 usb adapter */
33 {} 33 {}
34 }; 34 };
35 35
36 static int ap; /* Are we an AP or a normal station? */ 36 static int ap; /* Are we an AP or a normal station? */
37 37
38 #define ZD1201_VERSION "0.15" 38 #define ZD1201_VERSION "0.15"
39 39
40 MODULE_AUTHOR("Jeroen Vreeken <pe1rxq@amsat.org>"); 40 MODULE_AUTHOR("Jeroen Vreeken <pe1rxq@amsat.org>");
41 MODULE_DESCRIPTION("Driver for ZyDAS ZD1201 based USB Wireless adapters"); 41 MODULE_DESCRIPTION("Driver for ZyDAS ZD1201 based USB Wireless adapters");
42 MODULE_VERSION(ZD1201_VERSION); 42 MODULE_VERSION(ZD1201_VERSION);
43 MODULE_LICENSE("GPL"); 43 MODULE_LICENSE("GPL");
44 module_param(ap, int, 0); 44 module_param(ap, int, 0);
45 MODULE_PARM_DESC(ap, "If non-zero Access Point firmware will be loaded"); 45 MODULE_PARM_DESC(ap, "If non-zero Access Point firmware will be loaded");
46 MODULE_DEVICE_TABLE(usb, zd1201_table); 46 MODULE_DEVICE_TABLE(usb, zd1201_table);
47 47
48 48
49 static int zd1201_fw_upload(struct usb_device *dev, int apfw) 49 static int zd1201_fw_upload(struct usb_device *dev, int apfw)
50 { 50 {
51 const struct firmware *fw_entry; 51 const struct firmware *fw_entry;
52 char *data; 52 char *data;
53 unsigned long len; 53 unsigned long len;
54 int err; 54 int err;
55 unsigned char ret; 55 unsigned char ret;
56 char *buf; 56 char *buf;
57 char *fwfile; 57 char *fwfile;
58 58
59 if (apfw) 59 if (apfw)
60 fwfile = "zd1201-ap.fw"; 60 fwfile = "zd1201-ap.fw";
61 else 61 else
62 fwfile = "zd1201.fw"; 62 fwfile = "zd1201.fw";
63 63
64 err = request_firmware(&fw_entry, fwfile, &dev->dev); 64 err = request_firmware(&fw_entry, fwfile, &dev->dev);
65 if (err) { 65 if (err) {
66 dev_err(&dev->dev, "Failed to load %s firmware file!\n", fwfile); 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"); 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"); 68 dev_err(&dev->dev, "Goto http://linux-lc100020.sourceforge.net for more info.\n");
69 return err; 69 return err;
70 } 70 }
71 71
72 data = fw_entry->data; 72 data = fw_entry->data;
73 len = fw_entry->size; 73 len = fw_entry->size;
74 74
75 buf = kmalloc(1024, GFP_ATOMIC); 75 buf = kmalloc(1024, GFP_ATOMIC);
76 if (!buf) 76 if (!buf)
77 goto exit; 77 goto exit;
78 78
79 while (len > 0) { 79 while (len > 0) {
80 int translen = (len > 1024) ? 1024 : len; 80 int translen = (len > 1024) ? 1024 : len;
81 memcpy(buf, data, translen); 81 memcpy(buf, data, translen);
82 82
83 err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 0, 83 err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 0,
84 USB_DIR_OUT | 0x40, 0, 0, buf, translen, 84 USB_DIR_OUT | 0x40, 0, 0, buf, translen,
85 ZD1201_FW_TIMEOUT); 85 ZD1201_FW_TIMEOUT);
86 if (err < 0) 86 if (err < 0)
87 goto exit; 87 goto exit;
88 88
89 len -= translen; 89 len -= translen;
90 data += translen; 90 data += translen;
91 } 91 }
92 92
93 err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 0x2, 93 err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 0x2,
94 USB_DIR_OUT | 0x40, 0, 0, NULL, 0, ZD1201_FW_TIMEOUT); 94 USB_DIR_OUT | 0x40, 0, 0, NULL, 0, ZD1201_FW_TIMEOUT);
95 if (err < 0) 95 if (err < 0)
96 goto exit; 96 goto exit;
97 97
98 err = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 0x4, 98 err = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 0x4,
99 USB_DIR_IN | 0x40, 0,0, &ret, sizeof(ret), ZD1201_FW_TIMEOUT); 99 USB_DIR_IN | 0x40, 0,0, &ret, sizeof(ret), ZD1201_FW_TIMEOUT);
100 if (err < 0) 100 if (err < 0)
101 goto exit; 101 goto exit;
102 102
103 if (ret & 0x80) { 103 if (ret & 0x80) {
104 err = -EIO; 104 err = -EIO;
105 goto exit; 105 goto exit;
106 } 106 }
107 107
108 err = 0; 108 err = 0;
109 exit: 109 exit:
110 kfree(buf); 110 kfree(buf);
111 release_firmware(fw_entry); 111 release_firmware(fw_entry);
112 return err; 112 return err;
113 } 113 }
114 114
115 static void zd1201_usbfree(struct urb *urb) 115 static void zd1201_usbfree(struct urb *urb)
116 { 116 {
117 struct zd1201 *zd = urb->context; 117 struct zd1201 *zd = urb->context;
118 118
119 switch(urb->status) { 119 switch(urb->status) {
120 case -EILSEQ: 120 case -EILSEQ:
121 case -ENODEV: 121 case -ENODEV:
122 case -ETIME: 122 case -ETIME:
123 case -ENOENT: 123 case -ENOENT:
124 case -EPIPE: 124 case -EPIPE:
125 case -EOVERFLOW: 125 case -EOVERFLOW:
126 case -ESHUTDOWN: 126 case -ESHUTDOWN:
127 dev_warn(&zd->usb->dev, "%s: urb failed: %d\n", 127 dev_warn(&zd->usb->dev, "%s: urb failed: %d\n",
128 zd->dev->name, urb->status); 128 zd->dev->name, urb->status);
129 } 129 }
130 130
131 kfree(urb->transfer_buffer); 131 kfree(urb->transfer_buffer);
132 usb_free_urb(urb); 132 usb_free_urb(urb);
133 return; 133 return;
134 } 134 }
135 135
136 /* cmdreq message: 136 /* cmdreq message:
137 u32 type 137 u32 type
138 u16 cmd 138 u16 cmd
139 u16 parm0 139 u16 parm0
140 u16 parm1 140 u16 parm1
141 u16 parm2 141 u16 parm2
142 u8 pad[4] 142 u8 pad[4]
143 143
144 total: 4 + 2 + 2 + 2 + 2 + 4 = 16 144 total: 4 + 2 + 2 + 2 + 2 + 4 = 16
145 */ 145 */
146 static int zd1201_docmd(struct zd1201 *zd, int cmd, int parm0, 146 static int zd1201_docmd(struct zd1201 *zd, int cmd, int parm0,
147 int parm1, int parm2) 147 int parm1, int parm2)
148 { 148 {
149 unsigned char *command; 149 unsigned char *command;
150 int ret; 150 int ret;
151 struct urb *urb; 151 struct urb *urb;
152 152
153 command = kmalloc(16, GFP_ATOMIC); 153 command = kmalloc(16, GFP_ATOMIC);
154 if (!command) 154 if (!command)
155 return -ENOMEM; 155 return -ENOMEM;
156 156
157 *((__le32*)command) = cpu_to_le32(ZD1201_USB_CMDREQ); 157 *((__le32*)command) = cpu_to_le32(ZD1201_USB_CMDREQ);
158 *((__le16*)&command[4]) = cpu_to_le16(cmd); 158 *((__le16*)&command[4]) = cpu_to_le16(cmd);
159 *((__le16*)&command[6]) = cpu_to_le16(parm0); 159 *((__le16*)&command[6]) = cpu_to_le16(parm0);
160 *((__le16*)&command[8]) = cpu_to_le16(parm1); 160 *((__le16*)&command[8]) = cpu_to_le16(parm1);
161 *((__le16*)&command[10])= cpu_to_le16(parm2); 161 *((__le16*)&command[10])= cpu_to_le16(parm2);
162 162
163 urb = usb_alloc_urb(0, GFP_ATOMIC); 163 urb = usb_alloc_urb(0, GFP_ATOMIC);
164 if (!urb) { 164 if (!urb) {
165 kfree(command); 165 kfree(command);
166 return -ENOMEM; 166 return -ENOMEM;
167 } 167 }
168 usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb, zd->endp_out2), 168 usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb, zd->endp_out2),
169 command, 16, zd1201_usbfree, zd); 169 command, 16, zd1201_usbfree, zd);
170 ret = usb_submit_urb(urb, GFP_ATOMIC); 170 ret = usb_submit_urb(urb, GFP_ATOMIC);
171 if (ret) { 171 if (ret) {
172 kfree(command); 172 kfree(command);
173 usb_free_urb(urb); 173 usb_free_urb(urb);
174 } 174 }
175 175
176 return ret; 176 return ret;
177 } 177 }
178 178
179 /* Callback after sending out a packet */ 179 /* Callback after sending out a packet */
180 static void zd1201_usbtx(struct urb *urb) 180 static void zd1201_usbtx(struct urb *urb)
181 { 181 {
182 struct zd1201 *zd = urb->context; 182 struct zd1201 *zd = urb->context;
183 netif_wake_queue(zd->dev); 183 netif_wake_queue(zd->dev);
184 return; 184 return;
185 } 185 }
186 186
187 /* Incoming data */ 187 /* Incoming data */
188 static void zd1201_usbrx(struct urb *urb) 188 static void zd1201_usbrx(struct urb *urb)
189 { 189 {
190 struct zd1201 *zd = urb->context; 190 struct zd1201 *zd = urb->context;
191 int free = 0; 191 int free = 0;
192 unsigned char *data = urb->transfer_buffer; 192 unsigned char *data = urb->transfer_buffer;
193 struct sk_buff *skb; 193 struct sk_buff *skb;
194 unsigned char type; 194 unsigned char type;
195 195
196 if (!zd) 196 if (!zd)
197 return; 197 return;
198 198
199 switch(urb->status) { 199 switch(urb->status) {
200 case -EILSEQ: 200 case -EILSEQ:
201 case -ENODEV: 201 case -ENODEV:
202 case -ETIME: 202 case -ETIME:
203 case -ENOENT: 203 case -ENOENT:
204 case -EPIPE: 204 case -EPIPE:
205 case -EOVERFLOW: 205 case -EOVERFLOW:
206 case -ESHUTDOWN: 206 case -ESHUTDOWN:
207 dev_warn(&zd->usb->dev, "%s: rx urb failed: %d\n", 207 dev_warn(&zd->usb->dev, "%s: rx urb failed: %d\n",
208 zd->dev->name, urb->status); 208 zd->dev->name, urb->status);
209 free = 1; 209 free = 1;
210 goto exit; 210 goto exit;
211 } 211 }
212 212
213 if (urb->status != 0 || urb->actual_length == 0) 213 if (urb->status != 0 || urb->actual_length == 0)
214 goto resubmit; 214 goto resubmit;
215 215
216 type = data[0]; 216 type = data[0];
217 if (type == ZD1201_PACKET_EVENTSTAT || type == ZD1201_PACKET_RESOURCE) { 217 if (type == ZD1201_PACKET_EVENTSTAT || type == ZD1201_PACKET_RESOURCE) {
218 memcpy(zd->rxdata, data, urb->actual_length); 218 memcpy(zd->rxdata, data, urb->actual_length);
219 zd->rxlen = urb->actual_length; 219 zd->rxlen = urb->actual_length;
220 zd->rxdatas = 1; 220 zd->rxdatas = 1;
221 wake_up(&zd->rxdataq); 221 wake_up(&zd->rxdataq);
222 } 222 }
223 /* Info frame */ 223 /* Info frame */
224 if (type == ZD1201_PACKET_INQUIRE) { 224 if (type == ZD1201_PACKET_INQUIRE) {
225 int i = 0; 225 int i = 0;
226 unsigned short infotype, framelen, copylen; 226 unsigned short infotype, framelen, copylen;
227 framelen = le16_to_cpu(*(__le16*)&data[4]); 227 framelen = le16_to_cpu(*(__le16*)&data[4]);
228 infotype = le16_to_cpu(*(__le16*)&data[6]); 228 infotype = le16_to_cpu(*(__le16*)&data[6]);
229 229
230 if (infotype == ZD1201_INF_LINKSTATUS) { 230 if (infotype == ZD1201_INF_LINKSTATUS) {
231 short linkstatus; 231 short linkstatus;
232 232
233 linkstatus = le16_to_cpu(*(__le16*)&data[8]); 233 linkstatus = le16_to_cpu(*(__le16*)&data[8]);
234 switch(linkstatus) { 234 switch(linkstatus) {
235 case 1: 235 case 1:
236 netif_carrier_on(zd->dev); 236 netif_carrier_on(zd->dev);
237 break; 237 break;
238 case 2: 238 case 2:
239 netif_carrier_off(zd->dev); 239 netif_carrier_off(zd->dev);
240 break; 240 break;
241 case 3: 241 case 3:
242 netif_carrier_off(zd->dev); 242 netif_carrier_off(zd->dev);
243 break; 243 break;
244 case 4: 244 case 4:
245 netif_carrier_on(zd->dev); 245 netif_carrier_on(zd->dev);
246 break; 246 break;
247 default: 247 default:
248 netif_carrier_off(zd->dev); 248 netif_carrier_off(zd->dev);
249 } 249 }
250 goto resubmit; 250 goto resubmit;
251 } 251 }
252 if (infotype == ZD1201_INF_ASSOCSTATUS) { 252 if (infotype == ZD1201_INF_ASSOCSTATUS) {
253 short status = le16_to_cpu(*(__le16*)(data+8)); 253 short status = le16_to_cpu(*(__le16*)(data+8));
254 int event; 254 int event;
255 union iwreq_data wrqu; 255 union iwreq_data wrqu;
256 256
257 switch (status) { 257 switch (status) {
258 case ZD1201_ASSOCSTATUS_STAASSOC: 258 case ZD1201_ASSOCSTATUS_STAASSOC:
259 case ZD1201_ASSOCSTATUS_REASSOC: 259 case ZD1201_ASSOCSTATUS_REASSOC:
260 event = IWEVREGISTERED; 260 event = IWEVREGISTERED;
261 break; 261 break;
262 case ZD1201_ASSOCSTATUS_DISASSOC: 262 case ZD1201_ASSOCSTATUS_DISASSOC:
263 case ZD1201_ASSOCSTATUS_ASSOCFAIL: 263 case ZD1201_ASSOCSTATUS_ASSOCFAIL:
264 case ZD1201_ASSOCSTATUS_AUTHFAIL: 264 case ZD1201_ASSOCSTATUS_AUTHFAIL:
265 default: 265 default:
266 event = IWEVEXPIRED; 266 event = IWEVEXPIRED;
267 } 267 }
268 memcpy(wrqu.addr.sa_data, data+10, ETH_ALEN); 268 memcpy(wrqu.addr.sa_data, data+10, ETH_ALEN);
269 wrqu.addr.sa_family = ARPHRD_ETHER; 269 wrqu.addr.sa_family = ARPHRD_ETHER;
270 270
271 /* Send event to user space */ 271 /* Send event to user space */
272 wireless_send_event(zd->dev, event, &wrqu, NULL); 272 wireless_send_event(zd->dev, event, &wrqu, NULL);
273 273
274 goto resubmit; 274 goto resubmit;
275 } 275 }
276 if (infotype == ZD1201_INF_AUTHREQ) { 276 if (infotype == ZD1201_INF_AUTHREQ) {
277 union iwreq_data wrqu; 277 union iwreq_data wrqu;
278 278
279 memcpy(wrqu.addr.sa_data, data+8, ETH_ALEN); 279 memcpy(wrqu.addr.sa_data, data+8, ETH_ALEN);
280 wrqu.addr.sa_family = ARPHRD_ETHER; 280 wrqu.addr.sa_family = ARPHRD_ETHER;
281 /* There isn't a event that trully fits this request. 281 /* There isn't a event that trully fits this request.
282 We assume that userspace will be smart enough to 282 We assume that userspace will be smart enough to
283 see a new station being expired and sends back a 283 see a new station being expired and sends back a
284 authstation ioctl to authorize it. */ 284 authstation ioctl to authorize it. */
285 wireless_send_event(zd->dev, IWEVEXPIRED, &wrqu, NULL); 285 wireless_send_event(zd->dev, IWEVEXPIRED, &wrqu, NULL);
286 goto resubmit; 286 goto resubmit;
287 } 287 }
288 /* Other infotypes are handled outside this handler */ 288 /* Other infotypes are handled outside this handler */
289 zd->rxlen = 0; 289 zd->rxlen = 0;
290 while (i < urb->actual_length) { 290 while (i < urb->actual_length) {
291 copylen = le16_to_cpu(*(__le16*)&data[i+2]); 291 copylen = le16_to_cpu(*(__le16*)&data[i+2]);
292 /* Sanity check, sometimes we get junk */ 292 /* Sanity check, sometimes we get junk */
293 if (copylen+zd->rxlen > sizeof(zd->rxdata)) 293 if (copylen+zd->rxlen > sizeof(zd->rxdata))
294 break; 294 break;
295 memcpy(zd->rxdata+zd->rxlen, data+i+4, copylen); 295 memcpy(zd->rxdata+zd->rxlen, data+i+4, copylen);
296 zd->rxlen += copylen; 296 zd->rxlen += copylen;
297 i += 64; 297 i += 64;
298 } 298 }
299 if (i >= urb->actual_length) { 299 if (i >= urb->actual_length) {
300 zd->rxdatas = 1; 300 zd->rxdatas = 1;
301 wake_up(&zd->rxdataq); 301 wake_up(&zd->rxdataq);
302 } 302 }
303 goto resubmit; 303 goto resubmit;
304 } 304 }
305 /* Actual data */ 305 /* Actual data */
306 if (data[urb->actual_length-1] == ZD1201_PACKET_RXDATA) { 306 if (data[urb->actual_length-1] == ZD1201_PACKET_RXDATA) {
307 int datalen = urb->actual_length-1; 307 int datalen = urb->actual_length-1;
308 unsigned short len, fc, seq; 308 unsigned short len, fc, seq;
309 struct hlist_node *node; 309 struct hlist_node *node;
310 310
311 len = ntohs(*(__be16 *)&data[datalen-2]); 311 len = ntohs(*(__be16 *)&data[datalen-2]);
312 if (len>datalen) 312 if (len>datalen)
313 len=datalen; 313 len=datalen;
314 fc = le16_to_cpu(*(__le16 *)&data[datalen-16]); 314 fc = le16_to_cpu(*(__le16 *)&data[datalen-16]);
315 seq = le16_to_cpu(*(__le16 *)&data[datalen-24]); 315 seq = le16_to_cpu(*(__le16 *)&data[datalen-24]);
316 316
317 if (zd->monitor) { 317 if (zd->monitor) {
318 if (datalen < 24) 318 if (datalen < 24)
319 goto resubmit; 319 goto resubmit;
320 if (!(skb = dev_alloc_skb(datalen+24))) 320 if (!(skb = dev_alloc_skb(datalen+24)))
321 goto resubmit; 321 goto resubmit;
322 322
323 memcpy(skb_put(skb, 2), &data[datalen-16], 2); 323 memcpy(skb_put(skb, 2), &data[datalen-16], 2);
324 memcpy(skb_put(skb, 2), &data[datalen-2], 2); 324 memcpy(skb_put(skb, 2), &data[datalen-2], 2);
325 memcpy(skb_put(skb, 6), &data[datalen-14], 6); 325 memcpy(skb_put(skb, 6), &data[datalen-14], 6);
326 memcpy(skb_put(skb, 6), &data[datalen-22], 6); 326 memcpy(skb_put(skb, 6), &data[datalen-22], 6);
327 memcpy(skb_put(skb, 6), &data[datalen-8], 6); 327 memcpy(skb_put(skb, 6), &data[datalen-8], 6);
328 memcpy(skb_put(skb, 2), &data[datalen-24], 2); 328 memcpy(skb_put(skb, 2), &data[datalen-24], 2);
329 memcpy(skb_put(skb, len), data, len); 329 memcpy(skb_put(skb, len), data, len);
330 skb->dev = zd->dev; 330 skb->dev = zd->dev;
331 skb->dev->last_rx = jiffies; 331 skb->dev->last_rx = jiffies;
332 skb->protocol = eth_type_trans(skb, zd->dev); 332 skb->protocol = eth_type_trans(skb, zd->dev);
333 zd->stats.rx_packets++; 333 zd->stats.rx_packets++;
334 zd->stats.rx_bytes += skb->len; 334 zd->stats.rx_bytes += skb->len;
335 netif_rx(skb); 335 netif_rx(skb);
336 goto resubmit; 336 goto resubmit;
337 } 337 }
338 338
339 if ((seq & IEEE80211_SCTL_FRAG) || 339 if ((seq & IEEE80211_SCTL_FRAG) ||
340 (fc & IEEE80211_FCTL_MOREFRAGS)) { 340 (fc & IEEE80211_FCTL_MOREFRAGS)) {
341 struct zd1201_frag *frag = NULL; 341 struct zd1201_frag *frag = NULL;
342 char *ptr; 342 char *ptr;
343 343
344 if (datalen<14) 344 if (datalen<14)
345 goto resubmit; 345 goto resubmit;
346 if ((seq & IEEE80211_SCTL_FRAG) == 0) { 346 if ((seq & IEEE80211_SCTL_FRAG) == 0) {
347 frag = kmalloc(sizeof(*frag), GFP_ATOMIC); 347 frag = kmalloc(sizeof(*frag), GFP_ATOMIC);
348 if (!frag) 348 if (!frag)
349 goto resubmit; 349 goto resubmit;
350 skb = dev_alloc_skb(IEEE80211_DATA_LEN +14+2); 350 skb = dev_alloc_skb(IEEE80211_DATA_LEN +14+2);
351 if (!skb) { 351 if (!skb) {
352 kfree(frag); 352 kfree(frag);
353 goto resubmit; 353 goto resubmit;
354 } 354 }
355 frag->skb = skb; 355 frag->skb = skb;
356 frag->seq = seq & IEEE80211_SCTL_SEQ; 356 frag->seq = seq & IEEE80211_SCTL_SEQ;
357 skb_reserve(skb, 2); 357 skb_reserve(skb, 2);
358 memcpy(skb_put(skb, 12), &data[datalen-14], 12); 358 memcpy(skb_put(skb, 12), &data[datalen-14], 12);
359 memcpy(skb_put(skb, 2), &data[6], 2); 359 memcpy(skb_put(skb, 2), &data[6], 2);
360 memcpy(skb_put(skb, len), data+8, len); 360 memcpy(skb_put(skb, len), data+8, len);
361 hlist_add_head(&frag->fnode, &zd->fraglist); 361 hlist_add_head(&frag->fnode, &zd->fraglist);
362 goto resubmit; 362 goto resubmit;
363 } 363 }
364 hlist_for_each_entry(frag, node, &zd->fraglist, fnode) 364 hlist_for_each_entry(frag, node, &zd->fraglist, fnode)
365 if (frag->seq == (seq&IEEE80211_SCTL_SEQ)) 365 if (frag->seq == (seq&IEEE80211_SCTL_SEQ))
366 break; 366 break;
367 if (!frag) 367 if (!frag)
368 goto resubmit; 368 goto resubmit;
369 skb = frag->skb; 369 skb = frag->skb;
370 ptr = skb_put(skb, len); 370 ptr = skb_put(skb, len);
371 if (ptr) 371 if (ptr)
372 memcpy(ptr, data+8, len); 372 memcpy(ptr, data+8, len);
373 if (fc & IEEE80211_FCTL_MOREFRAGS) 373 if (fc & IEEE80211_FCTL_MOREFRAGS)
374 goto resubmit; 374 goto resubmit;
375 hlist_del_init(&frag->fnode); 375 hlist_del_init(&frag->fnode);
376 kfree(frag); 376 kfree(frag);
377 } else { 377 } else {
378 if (datalen<14) 378 if (datalen<14)
379 goto resubmit; 379 goto resubmit;
380 skb = dev_alloc_skb(len + 14 + 2); 380 skb = dev_alloc_skb(len + 14 + 2);
381 if (!skb) 381 if (!skb)
382 goto resubmit; 382 goto resubmit;
383 skb_reserve(skb, 2); 383 skb_reserve(skb, 2);
384 memcpy(skb_put(skb, 12), &data[datalen-14], 12); 384 memcpy(skb_put(skb, 12), &data[datalen-14], 12);
385 memcpy(skb_put(skb, 2), &data[6], 2); 385 memcpy(skb_put(skb, 2), &data[6], 2);
386 memcpy(skb_put(skb, len), data+8, len); 386 memcpy(skb_put(skb, len), data+8, len);
387 } 387 }
388 skb->dev = zd->dev; 388 skb->dev = zd->dev;
389 skb->dev->last_rx = jiffies; 389 skb->dev->last_rx = jiffies;
390 skb->protocol = eth_type_trans(skb, zd->dev); 390 skb->protocol = eth_type_trans(skb, zd->dev);
391 zd->stats.rx_packets++; 391 zd->stats.rx_packets++;
392 zd->stats.rx_bytes += skb->len; 392 zd->stats.rx_bytes += skb->len;
393 netif_rx(skb); 393 netif_rx(skb);
394 } 394 }
395 resubmit: 395 resubmit:
396 memset(data, 0, ZD1201_RXSIZE); 396 memset(data, 0, ZD1201_RXSIZE);
397 397
398 urb->status = 0; 398 urb->status = 0;
399 urb->dev = zd->usb; 399 urb->dev = zd->usb;
400 if(usb_submit_urb(urb, GFP_ATOMIC)) 400 if(usb_submit_urb(urb, GFP_ATOMIC))
401 free = 1; 401 free = 1;
402 402
403 exit: 403 exit:
404 if (free) { 404 if (free) {
405 zd->rxlen = 0; 405 zd->rxlen = 0;
406 zd->rxdatas = 1; 406 zd->rxdatas = 1;
407 wake_up(&zd->rxdataq); 407 wake_up(&zd->rxdataq);
408 kfree(urb->transfer_buffer); 408 kfree(urb->transfer_buffer);
409 } 409 }
410 return; 410 return;
411 } 411 }
412 412
413 static int zd1201_getconfig(struct zd1201 *zd, int rid, void *riddata, 413 static int zd1201_getconfig(struct zd1201 *zd, int rid, void *riddata,
414 unsigned int riddatalen) 414 unsigned int riddatalen)
415 { 415 {
416 int err; 416 int err;
417 int i = 0; 417 int i = 0;
418 int code; 418 int code;
419 int rid_fid; 419 int rid_fid;
420 int length; 420 int length;
421 unsigned char *pdata; 421 unsigned char *pdata;
422 422
423 zd->rxdatas = 0; 423 zd->rxdatas = 0;
424 err = zd1201_docmd(zd, ZD1201_CMDCODE_ACCESS, rid, 0, 0); 424 err = zd1201_docmd(zd, ZD1201_CMDCODE_ACCESS, rid, 0, 0);
425 if (err) 425 if (err)
426 return err; 426 return err;
427 427
428 wait_event_interruptible(zd->rxdataq, zd->rxdatas); 428 wait_event_interruptible(zd->rxdataq, zd->rxdatas);
429 if (!zd->rxlen) 429 if (!zd->rxlen)
430 return -EIO; 430 return -EIO;
431 431
432 code = le16_to_cpu(*(__le16*)(&zd->rxdata[4])); 432 code = le16_to_cpu(*(__le16*)(&zd->rxdata[4]));
433 rid_fid = le16_to_cpu(*(__le16*)(&zd->rxdata[6])); 433 rid_fid = le16_to_cpu(*(__le16*)(&zd->rxdata[6]));
434 length = le16_to_cpu(*(__le16*)(&zd->rxdata[8])); 434 length = le16_to_cpu(*(__le16*)(&zd->rxdata[8]));
435 if (length > zd->rxlen) 435 if (length > zd->rxlen)
436 length = zd->rxlen-6; 436 length = zd->rxlen-6;
437 437
438 /* If access bit is not on, then error */ 438 /* If access bit is not on, then error */
439 if ((code & ZD1201_ACCESSBIT) != ZD1201_ACCESSBIT || rid_fid != rid ) 439 if ((code & ZD1201_ACCESSBIT) != ZD1201_ACCESSBIT || rid_fid != rid )
440 return -EINVAL; 440 return -EINVAL;
441 441
442 /* Not enough buffer for allocating data */ 442 /* Not enough buffer for allocating data */
443 if (riddatalen != (length - 4)) { 443 if (riddatalen != (length - 4)) {
444 dev_dbg(&zd->usb->dev, "riddatalen mismatches, expected=%u, (packet=%u) length=%u, rid=0x%04X, rid_fid=0x%04X\n", 444 dev_dbg(&zd->usb->dev, "riddatalen mismatches, expected=%u, (packet=%u) length=%u, rid=0x%04X, rid_fid=0x%04X\n",
445 riddatalen, zd->rxlen, length, rid, rid_fid); 445 riddatalen, zd->rxlen, length, rid, rid_fid);
446 return -ENODATA; 446 return -ENODATA;
447 } 447 }
448 448
449 zd->rxdatas = 0; 449 zd->rxdatas = 0;
450 /* Issue SetRxRid commnd */ 450 /* Issue SetRxRid commnd */
451 err = zd1201_docmd(zd, ZD1201_CMDCODE_SETRXRID, rid, 0, length); 451 err = zd1201_docmd(zd, ZD1201_CMDCODE_SETRXRID, rid, 0, length);
452 if (err) 452 if (err)
453 return err; 453 return err;
454 454
455 /* Receive RID record from resource packets */ 455 /* Receive RID record from resource packets */
456 wait_event_interruptible(zd->rxdataq, zd->rxdatas); 456 wait_event_interruptible(zd->rxdataq, zd->rxdatas);
457 if (!zd->rxlen) 457 if (!zd->rxlen)
458 return -EIO; 458 return -EIO;
459 459
460 if (zd->rxdata[zd->rxlen - 1] != ZD1201_PACKET_RESOURCE) { 460 if (zd->rxdata[zd->rxlen - 1] != ZD1201_PACKET_RESOURCE) {
461 dev_dbg(&zd->usb->dev, "Packet type mismatch: 0x%x not 0x3\n", 461 dev_dbg(&zd->usb->dev, "Packet type mismatch: 0x%x not 0x3\n",
462 zd->rxdata[zd->rxlen-1]); 462 zd->rxdata[zd->rxlen-1]);
463 return -EINVAL; 463 return -EINVAL;
464 } 464 }
465 465
466 /* Set the data pointer and received data length */ 466 /* Set the data pointer and received data length */
467 pdata = zd->rxdata; 467 pdata = zd->rxdata;
468 length = zd->rxlen; 468 length = zd->rxlen;
469 469
470 do { 470 do {
471 int actual_length; 471 int actual_length;
472 472
473 actual_length = (length > 64) ? 64 : length; 473 actual_length = (length > 64) ? 64 : length;
474 474
475 if (pdata[0] != 0x3) { 475 if (pdata[0] != 0x3) {
476 dev_dbg(&zd->usb->dev, "Rx Resource packet type error: %02X\n", 476 dev_dbg(&zd->usb->dev, "Rx Resource packet type error: %02X\n",
477 pdata[0]); 477 pdata[0]);
478 return -EINVAL; 478 return -EINVAL;
479 } 479 }
480 480
481 if (actual_length != 64) { 481 if (actual_length != 64) {
482 /* Trim the last packet type byte */ 482 /* Trim the last packet type byte */
483 actual_length--; 483 actual_length--;
484 } 484 }
485 485
486 /* Skip the 4 bytes header (RID length and RID) */ 486 /* Skip the 4 bytes header (RID length and RID) */
487 if (i == 0) { 487 if (i == 0) {
488 pdata += 8; 488 pdata += 8;
489 actual_length -= 8; 489 actual_length -= 8;
490 } else { 490 } else {
491 pdata += 4; 491 pdata += 4;
492 actual_length -= 4; 492 actual_length -= 4;
493 } 493 }
494 494
495 memcpy(riddata, pdata, actual_length); 495 memcpy(riddata, pdata, actual_length);
496 riddata += actual_length; 496 riddata += actual_length;
497 pdata += actual_length; 497 pdata += actual_length;
498 length -= 64; 498 length -= 64;
499 i++; 499 i++;
500 } while (length > 0); 500 } while (length > 0);
501 501
502 return 0; 502 return 0;
503 } 503 }
504 504
505 /* 505 /*
506 * resreq: 506 * resreq:
507 * byte type 507 * byte type
508 * byte sequence 508 * byte sequence
509 * u16 reserved 509 * u16 reserved
510 * byte data[12] 510 * byte data[12]
511 * total: 16 511 * total: 16
512 */ 512 */
513 static int zd1201_setconfig(struct zd1201 *zd, int rid, void *buf, int len, int wait) 513 static int zd1201_setconfig(struct zd1201 *zd, int rid, void *buf, int len, int wait)
514 { 514 {
515 int err; 515 int err;
516 unsigned char *request; 516 unsigned char *request;
517 int reqlen; 517 int reqlen;
518 char seq=0; 518 char seq=0;
519 struct urb *urb; 519 struct urb *urb;
520 gfp_t gfp_mask = wait ? GFP_NOIO : GFP_ATOMIC; 520 gfp_t gfp_mask = wait ? GFP_NOIO : GFP_ATOMIC;
521 521
522 len += 4; /* first 4 are for header */ 522 len += 4; /* first 4 are for header */
523 523
524 zd->rxdatas = 0; 524 zd->rxdatas = 0;
525 zd->rxlen = 0; 525 zd->rxlen = 0;
526 for (seq=0; len > 0; seq++) { 526 for (seq=0; len > 0; seq++) {
527 request = kmalloc(16, gfp_mask); 527 request = kmalloc(16, gfp_mask);
528 if (!request) 528 if (!request)
529 return -ENOMEM; 529 return -ENOMEM;
530 urb = usb_alloc_urb(0, gfp_mask); 530 urb = usb_alloc_urb(0, gfp_mask);
531 if (!urb) { 531 if (!urb) {
532 kfree(request); 532 kfree(request);
533 return -ENOMEM; 533 return -ENOMEM;
534 } 534 }
535 memset(request, 0, 16); 535 memset(request, 0, 16);
536 reqlen = len>12 ? 12 : len; 536 reqlen = len>12 ? 12 : len;
537 request[0] = ZD1201_USB_RESREQ; 537 request[0] = ZD1201_USB_RESREQ;
538 request[1] = seq; 538 request[1] = seq;
539 request[2] = 0; 539 request[2] = 0;
540 request[3] = 0; 540 request[3] = 0;
541 if (request[1] == 0) { 541 if (request[1] == 0) {
542 /* add header */ 542 /* add header */
543 *(__le16*)&request[4] = cpu_to_le16((len-2+1)/2); 543 *(__le16*)&request[4] = cpu_to_le16((len-2+1)/2);
544 *(__le16*)&request[6] = cpu_to_le16(rid); 544 *(__le16*)&request[6] = cpu_to_le16(rid);
545 memcpy(request+8, buf, reqlen-4); 545 memcpy(request+8, buf, reqlen-4);
546 buf += reqlen-4; 546 buf += reqlen-4;
547 } else { 547 } else {
548 memcpy(request+4, buf, reqlen); 548 memcpy(request+4, buf, reqlen);
549 buf += reqlen; 549 buf += reqlen;
550 } 550 }
551 551
552 len -= reqlen; 552 len -= reqlen;
553 553
554 usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb, 554 usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb,
555 zd->endp_out2), request, 16, zd1201_usbfree, zd); 555 zd->endp_out2), request, 16, zd1201_usbfree, zd);
556 err = usb_submit_urb(urb, gfp_mask); 556 err = usb_submit_urb(urb, gfp_mask);
557 if (err) 557 if (err)
558 goto err; 558 goto err;
559 } 559 }
560 560
561 request = kmalloc(16, gfp_mask); 561 request = kmalloc(16, gfp_mask);
562 if (!request) 562 if (!request)
563 return -ENOMEM; 563 return -ENOMEM;
564 urb = usb_alloc_urb(0, gfp_mask); 564 urb = usb_alloc_urb(0, gfp_mask);
565 if (!urb) { 565 if (!urb) {
566 kfree(request); 566 kfree(request);
567 return -ENOMEM; 567 return -ENOMEM;
568 } 568 }
569 *((__le32*)request) = cpu_to_le32(ZD1201_USB_CMDREQ); 569 *((__le32*)request) = cpu_to_le32(ZD1201_USB_CMDREQ);
570 *((__le16*)&request[4]) = 570 *((__le16*)&request[4]) =
571 cpu_to_le16(ZD1201_CMDCODE_ACCESS|ZD1201_ACCESSBIT); 571 cpu_to_le16(ZD1201_CMDCODE_ACCESS|ZD1201_ACCESSBIT);
572 *((__le16*)&request[6]) = cpu_to_le16(rid); 572 *((__le16*)&request[6]) = cpu_to_le16(rid);
573 *((__le16*)&request[8]) = cpu_to_le16(0); 573 *((__le16*)&request[8]) = cpu_to_le16(0);
574 *((__le16*)&request[10]) = cpu_to_le16(0); 574 *((__le16*)&request[10]) = cpu_to_le16(0);
575 usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb, zd->endp_out2), 575 usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb, zd->endp_out2),
576 request, 16, zd1201_usbfree, zd); 576 request, 16, zd1201_usbfree, zd);
577 err = usb_submit_urb(urb, gfp_mask); 577 err = usb_submit_urb(urb, gfp_mask);
578 if (err) 578 if (err)
579 goto err; 579 goto err;
580 580
581 if (wait) { 581 if (wait) {
582 wait_event_interruptible(zd->rxdataq, zd->rxdatas); 582 wait_event_interruptible(zd->rxdataq, zd->rxdatas);
583 if (!zd->rxlen || le16_to_cpu(*(__le16*)&zd->rxdata[6]) != rid) { 583 if (!zd->rxlen || le16_to_cpu(*(__le16*)&zd->rxdata[6]) != rid) {
584 dev_dbg(&zd->usb->dev, "wrong or no RID received\n"); 584 dev_dbg(&zd->usb->dev, "wrong or no RID received\n");
585 } 585 }
586 } 586 }
587 587
588 return 0; 588 return 0;
589 err: 589 err:
590 kfree(request); 590 kfree(request);
591 usb_free_urb(urb); 591 usb_free_urb(urb);
592 return err; 592 return err;
593 } 593 }
594 594
595 static inline int zd1201_getconfig16(struct zd1201 *zd, int rid, short *val) 595 static inline int zd1201_getconfig16(struct zd1201 *zd, int rid, short *val)
596 { 596 {
597 int err; 597 int err;
598 __le16 zdval; 598 __le16 zdval;
599 599
600 err = zd1201_getconfig(zd, rid, &zdval, sizeof(__le16)); 600 err = zd1201_getconfig(zd, rid, &zdval, sizeof(__le16));
601 if (err) 601 if (err)
602 return err; 602 return err;
603 *val = le16_to_cpu(zdval); 603 *val = le16_to_cpu(zdval);
604 return 0; 604 return 0;
605 } 605 }
606 606
607 static inline int zd1201_setconfig16(struct zd1201 *zd, int rid, short val) 607 static inline int zd1201_setconfig16(struct zd1201 *zd, int rid, short val)
608 { 608 {
609 __le16 zdval = cpu_to_le16(val); 609 __le16 zdval = cpu_to_le16(val);
610 return (zd1201_setconfig(zd, rid, &zdval, sizeof(__le16), 1)); 610 return (zd1201_setconfig(zd, rid, &zdval, sizeof(__le16), 1));
611 } 611 }
612 612
613 static int zd1201_drvr_start(struct zd1201 *zd) 613 static int zd1201_drvr_start(struct zd1201 *zd)
614 { 614 {
615 int err, i; 615 int err, i;
616 short max; 616 short max;
617 __le16 zdmax; 617 __le16 zdmax;
618 unsigned char *buffer; 618 unsigned char *buffer;
619 619
620 buffer = kzalloc(ZD1201_RXSIZE, GFP_KERNEL); 620 buffer = kzalloc(ZD1201_RXSIZE, GFP_KERNEL);
621 if (!buffer) 621 if (!buffer)
622 return -ENOMEM; 622 return -ENOMEM;
623 623
624 usb_fill_bulk_urb(zd->rx_urb, zd->usb, 624 usb_fill_bulk_urb(zd->rx_urb, zd->usb,
625 usb_rcvbulkpipe(zd->usb, zd->endp_in), buffer, ZD1201_RXSIZE, 625 usb_rcvbulkpipe(zd->usb, zd->endp_in), buffer, ZD1201_RXSIZE,
626 zd1201_usbrx, zd); 626 zd1201_usbrx, zd);
627 627
628 err = usb_submit_urb(zd->rx_urb, GFP_KERNEL); 628 err = usb_submit_urb(zd->rx_urb, GFP_KERNEL);
629 if (err) 629 if (err)
630 goto err_buffer; 630 goto err_buffer;
631 631
632 err = zd1201_docmd(zd, ZD1201_CMDCODE_INIT, 0, 0, 0); 632 err = zd1201_docmd(zd, ZD1201_CMDCODE_INIT, 0, 0, 0);
633 if (err) 633 if (err)
634 goto err_urb; 634 goto err_urb;
635 635
636 err = zd1201_getconfig(zd, ZD1201_RID_CNFMAXTXBUFFERNUMBER, &zdmax, 636 err = zd1201_getconfig(zd, ZD1201_RID_CNFMAXTXBUFFERNUMBER, &zdmax,
637 sizeof(__le16)); 637 sizeof(__le16));
638 if (err) 638 if (err)
639 goto err_urb; 639 goto err_urb;
640 640
641 max = le16_to_cpu(zdmax); 641 max = le16_to_cpu(zdmax);
642 for (i=0; i<max; i++) { 642 for (i=0; i<max; i++) {
643 err = zd1201_docmd(zd, ZD1201_CMDCODE_ALLOC, 1514, 0, 0); 643 err = zd1201_docmd(zd, ZD1201_CMDCODE_ALLOC, 1514, 0, 0);
644 if (err) 644 if (err)
645 goto err_urb; 645 goto err_urb;
646 } 646 }
647 647
648 return 0; 648 return 0;
649 649
650 err_urb: 650 err_urb:
651 usb_kill_urb(zd->rx_urb); 651 usb_kill_urb(zd->rx_urb);
652 return err; 652 return err;
653 err_buffer: 653 err_buffer:
654 kfree(buffer); 654 kfree(buffer);
655 return err; 655 return err;
656 } 656 }
657 657
658 /* Magic alert: The firmware doesn't seem to like the MAC state being 658 /* Magic alert: The firmware doesn't seem to like the MAC state being
659 * toggled in promisc (aka monitor) mode. 659 * toggled in promisc (aka monitor) mode.
660 * (It works a number of times, but will halt eventually) 660 * (It works a number of times, but will halt eventually)
661 * So we turn it of before disabling and on after enabling if needed. 661 * So we turn it of before disabling and on after enabling if needed.
662 */ 662 */
663 static int zd1201_enable(struct zd1201 *zd) 663 static int zd1201_enable(struct zd1201 *zd)
664 { 664 {
665 int err; 665 int err;
666 666
667 if (zd->mac_enabled) 667 if (zd->mac_enabled)
668 return 0; 668 return 0;
669 669
670 err = zd1201_docmd(zd, ZD1201_CMDCODE_ENABLE, 0, 0, 0); 670 err = zd1201_docmd(zd, ZD1201_CMDCODE_ENABLE, 0, 0, 0);
671 if (!err) 671 if (!err)
672 zd->mac_enabled = 1; 672 zd->mac_enabled = 1;
673 673
674 if (zd->monitor) 674 if (zd->monitor)
675 err = zd1201_setconfig16(zd, ZD1201_RID_PROMISCUOUSMODE, 1); 675 err = zd1201_setconfig16(zd, ZD1201_RID_PROMISCUOUSMODE, 1);
676 676
677 return err; 677 return err;
678 } 678 }
679 679
680 static int zd1201_disable(struct zd1201 *zd) 680 static int zd1201_disable(struct zd1201 *zd)
681 { 681 {
682 int err; 682 int err;
683 683
684 if (!zd->mac_enabled) 684 if (!zd->mac_enabled)
685 return 0; 685 return 0;
686 if (zd->monitor) { 686 if (zd->monitor) {
687 err = zd1201_setconfig16(zd, ZD1201_RID_PROMISCUOUSMODE, 0); 687 err = zd1201_setconfig16(zd, ZD1201_RID_PROMISCUOUSMODE, 0);
688 if (err) 688 if (err)
689 return err; 689 return err;
690 } 690 }
691 691
692 err = zd1201_docmd(zd, ZD1201_CMDCODE_DISABLE, 0, 0, 0); 692 err = zd1201_docmd(zd, ZD1201_CMDCODE_DISABLE, 0, 0, 0);
693 if (!err) 693 if (!err)
694 zd->mac_enabled = 0; 694 zd->mac_enabled = 0;
695 return err; 695 return err;
696 } 696 }
697 697
698 static int zd1201_mac_reset(struct zd1201 *zd) 698 static int zd1201_mac_reset(struct zd1201 *zd)
699 { 699 {
700 if (!zd->mac_enabled) 700 if (!zd->mac_enabled)
701 return 0; 701 return 0;
702 zd1201_disable(zd); 702 zd1201_disable(zd);
703 return zd1201_enable(zd); 703 return zd1201_enable(zd);
704 } 704 }
705 705
706 static int zd1201_join(struct zd1201 *zd, char *essid, int essidlen) 706 static int zd1201_join(struct zd1201 *zd, char *essid, int essidlen)
707 { 707 {
708 int err, val; 708 int err, val;
709 char buf[IW_ESSID_MAX_SIZE+2]; 709 char buf[IW_ESSID_MAX_SIZE+2];
710 710
711 err = zd1201_disable(zd); 711 err = zd1201_disable(zd);
712 if (err) 712 if (err)
713 return err; 713 return err;
714 714
715 val = ZD1201_CNFAUTHENTICATION_OPENSYSTEM; 715 val = ZD1201_CNFAUTHENTICATION_OPENSYSTEM;
716 val |= ZD1201_CNFAUTHENTICATION_SHAREDKEY; 716 val |= ZD1201_CNFAUTHENTICATION_SHAREDKEY;
717 err = zd1201_setconfig16(zd, ZD1201_RID_CNFAUTHENTICATION, val); 717 err = zd1201_setconfig16(zd, ZD1201_RID_CNFAUTHENTICATION, val);
718 if (err) 718 if (err)
719 return err; 719 return err;
720 720
721 *(__le16 *)buf = cpu_to_le16(essidlen); 721 *(__le16 *)buf = cpu_to_le16(essidlen);
722 memcpy(buf+2, essid, essidlen); 722 memcpy(buf+2, essid, essidlen);
723 if (!zd->ap) { /* Normal station */ 723 if (!zd->ap) { /* Normal station */
724 err = zd1201_setconfig(zd, ZD1201_RID_CNFDESIREDSSID, buf, 724 err = zd1201_setconfig(zd, ZD1201_RID_CNFDESIREDSSID, buf,
725 IW_ESSID_MAX_SIZE+2, 1); 725 IW_ESSID_MAX_SIZE+2, 1);
726 if (err) 726 if (err)
727 return err; 727 return err;
728 } else { /* AP */ 728 } else { /* AP */
729 err = zd1201_setconfig(zd, ZD1201_RID_CNFOWNSSID, buf, 729 err = zd1201_setconfig(zd, ZD1201_RID_CNFOWNSSID, buf,
730 IW_ESSID_MAX_SIZE+2, 1); 730 IW_ESSID_MAX_SIZE+2, 1);
731 if (err) 731 if (err)
732 return err; 732 return err;
733 } 733 }
734 734
735 err = zd1201_setconfig(zd, ZD1201_RID_CNFOWNMACADDR, 735 err = zd1201_setconfig(zd, ZD1201_RID_CNFOWNMACADDR,
736 zd->dev->dev_addr, zd->dev->addr_len, 1); 736 zd->dev->dev_addr, zd->dev->addr_len, 1);
737 if (err) 737 if (err)
738 return err; 738 return err;
739 739
740 err = zd1201_enable(zd); 740 err = zd1201_enable(zd);
741 if (err) 741 if (err)
742 return err; 742 return err;
743 743
744 msleep(100); 744 msleep(100);
745 return 0; 745 return 0;
746 } 746 }
747 747
748 static int zd1201_net_open(struct net_device *dev) 748 static int zd1201_net_open(struct net_device *dev)
749 { 749 {
750 struct zd1201 *zd = (struct zd1201 *)dev->priv; 750 struct zd1201 *zd = (struct zd1201 *)dev->priv;
751 751
752 /* Start MAC with wildcard if no essid set */ 752 /* Start MAC with wildcard if no essid set */
753 if (!zd->mac_enabled) 753 if (!zd->mac_enabled)
754 zd1201_join(zd, zd->essid, zd->essidlen); 754 zd1201_join(zd, zd->essid, zd->essidlen);
755 netif_start_queue(dev); 755 netif_start_queue(dev);
756 756
757 return 0; 757 return 0;
758 } 758 }
759 759
760 static int zd1201_net_stop(struct net_device *dev) 760 static int zd1201_net_stop(struct net_device *dev)
761 { 761 {
762 netif_stop_queue(dev); 762 netif_stop_queue(dev);
763 return 0; 763 return 0;
764 } 764 }
765 765
766 /* 766 /*
767 RFC 1042 encapsulates Ethernet frames in 802.11 frames 767 RFC 1042 encapsulates Ethernet frames in 802.11 frames
768 by prefixing them with 0xaa, 0xaa, 0x03) followed by a SNAP OID of 0 768 by prefixing them with 0xaa, 0xaa, 0x03) followed by a SNAP OID of 0
769 (0x00, 0x00, 0x00). Zd requires an additional padding, copy 769 (0x00, 0x00, 0x00). Zd requires an additional padding, copy
770 of ethernet addresses, length of the standard RFC 1042 packet 770 of ethernet addresses, length of the standard RFC 1042 packet
771 and a command byte (which is nul for tx). 771 and a command byte (which is nul for tx).
772 772
773 tx frame (from Wlan NG): 773 tx frame (from Wlan NG):
774 RFC 1042: 774 RFC 1042:
775 llc 0xAA 0xAA 0x03 (802.2 LLC) 775 llc 0xAA 0xAA 0x03 (802.2 LLC)
776 snap 0x00 0x00 0x00 (Ethernet encapsulated) 776 snap 0x00 0x00 0x00 (Ethernet encapsulated)
777 type 2 bytes, Ethernet type field 777 type 2 bytes, Ethernet type field
778 payload (minus eth header) 778 payload (minus eth header)
779 Zydas specific: 779 Zydas specific:
780 padding 1B if (skb->len+8+1)%64==0 780 padding 1B if (skb->len+8+1)%64==0
781 Eth MAC addr 12 bytes, Ethernet MAC addresses 781 Eth MAC addr 12 bytes, Ethernet MAC addresses
782 length 2 bytes, RFC 1042 packet length 782 length 2 bytes, RFC 1042 packet length
783 (llc+snap+type+payload) 783 (llc+snap+type+payload)
784 zd 1 null byte, zd1201 packet type 784 zd 1 null byte, zd1201 packet type
785 */ 785 */
786 static int zd1201_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) 786 static int zd1201_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
787 { 787 {
788 struct zd1201 *zd = (struct zd1201 *)dev->priv; 788 struct zd1201 *zd = (struct zd1201 *)dev->priv;
789 unsigned char *txbuf = zd->txdata; 789 unsigned char *txbuf = zd->txdata;
790 int txbuflen, pad = 0, err; 790 int txbuflen, pad = 0, err;
791 struct urb *urb = zd->tx_urb; 791 struct urb *urb = zd->tx_urb;
792 792
793 if (!zd->mac_enabled || zd->monitor) { 793 if (!zd->mac_enabled || zd->monitor) {
794 zd->stats.tx_dropped++; 794 zd->stats.tx_dropped++;
795 kfree_skb(skb); 795 kfree_skb(skb);
796 return 0; 796 return 0;
797 } 797 }
798 netif_stop_queue(dev); 798 netif_stop_queue(dev);
799 799
800 txbuflen = skb->len + 8 + 1; 800 txbuflen = skb->len + 8 + 1;
801 if (txbuflen%64 == 0) { 801 if (txbuflen%64 == 0) {
802 pad = 1; 802 pad = 1;
803 txbuflen++; 803 txbuflen++;
804 } 804 }
805 txbuf[0] = 0xAA; 805 txbuf[0] = 0xAA;
806 txbuf[1] = 0xAA; 806 txbuf[1] = 0xAA;
807 txbuf[2] = 0x03; 807 txbuf[2] = 0x03;
808 txbuf[3] = 0x00; /* rfc1042 */ 808 txbuf[3] = 0x00; /* rfc1042 */
809 txbuf[4] = 0x00; 809 txbuf[4] = 0x00;
810 txbuf[5] = 0x00; 810 txbuf[5] = 0x00;
811 811
812 memcpy(txbuf+6, skb->data+12, skb->len-12); 812 memcpy(txbuf+6, skb->data+12, skb->len-12);
813 if (pad) 813 if (pad)
814 txbuf[skb->len-12+6]=0; 814 txbuf[skb->len-12+6]=0;
815 memcpy(txbuf+skb->len-12+6+pad, skb->data, 12); 815 memcpy(txbuf+skb->len-12+6+pad, skb->data, 12);
816 *(__be16*)&txbuf[skb->len+6+pad] = htons(skb->len-12+6); 816 *(__be16*)&txbuf[skb->len+6+pad] = htons(skb->len-12+6);
817 txbuf[txbuflen-1] = 0; 817 txbuf[txbuflen-1] = 0;
818 818
819 usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb, zd->endp_out), 819 usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb, zd->endp_out),
820 txbuf, txbuflen, zd1201_usbtx, zd); 820 txbuf, txbuflen, zd1201_usbtx, zd);
821 821
822 err = usb_submit_urb(zd->tx_urb, GFP_ATOMIC); 822 err = usb_submit_urb(zd->tx_urb, GFP_ATOMIC);
823 if (err) { 823 if (err) {
824 zd->stats.tx_errors++; 824 zd->stats.tx_errors++;
825 netif_start_queue(dev); 825 netif_start_queue(dev);
826 return err; 826 return err;
827 } 827 }
828 zd->stats.tx_packets++; 828 zd->stats.tx_packets++;
829 zd->stats.tx_bytes += skb->len; 829 zd->stats.tx_bytes += skb->len;
830 dev->trans_start = jiffies; 830 dev->trans_start = jiffies;
831 kfree_skb(skb); 831 kfree_skb(skb);
832 832
833 return 0; 833 return 0;
834 } 834 }
835 835
836 static void zd1201_tx_timeout(struct net_device *dev) 836 static void zd1201_tx_timeout(struct net_device *dev)
837 { 837 {
838 struct zd1201 *zd = (struct zd1201 *)dev->priv; 838 struct zd1201 *zd = (struct zd1201 *)dev->priv;
839 839
840 if (!zd) 840 if (!zd)
841 return; 841 return;
842 dev_warn(&zd->usb->dev, "%s: TX timeout, shooting down urb\n", 842 dev_warn(&zd->usb->dev, "%s: TX timeout, shooting down urb\n",
843 dev->name); 843 dev->name);
844 usb_unlink_urb(zd->tx_urb); 844 usb_unlink_urb(zd->tx_urb);
845 zd->stats.tx_errors++; 845 zd->stats.tx_errors++;
846 /* Restart the timeout to quiet the watchdog: */ 846 /* Restart the timeout to quiet the watchdog: */
847 dev->trans_start = jiffies; 847 dev->trans_start = jiffies;
848 } 848 }
849 849
850 static int zd1201_set_mac_address(struct net_device *dev, void *p) 850 static int zd1201_set_mac_address(struct net_device *dev, void *p)
851 { 851 {
852 struct sockaddr *addr = p; 852 struct sockaddr *addr = p;
853 struct zd1201 *zd = (struct zd1201 *)dev->priv; 853 struct zd1201 *zd = (struct zd1201 *)dev->priv;
854 int err; 854 int err;
855 855
856 if (!zd) 856 if (!zd)
857 return -ENODEV; 857 return -ENODEV;
858 858
859 err = zd1201_setconfig(zd, ZD1201_RID_CNFOWNMACADDR, 859 err = zd1201_setconfig(zd, ZD1201_RID_CNFOWNMACADDR,
860 addr->sa_data, dev->addr_len, 1); 860 addr->sa_data, dev->addr_len, 1);
861 if (err) 861 if (err)
862 return err; 862 return err;
863 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len); 863 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
864 864
865 return zd1201_mac_reset(zd); 865 return zd1201_mac_reset(zd);
866 } 866 }
867 867
868 static struct net_device_stats *zd1201_get_stats(struct net_device *dev) 868 static struct net_device_stats *zd1201_get_stats(struct net_device *dev)
869 { 869 {
870 struct zd1201 *zd = (struct zd1201 *)dev->priv; 870 struct zd1201 *zd = (struct zd1201 *)dev->priv;
871 871
872 return &zd->stats; 872 return &zd->stats;
873 } 873 }
874 874
875 static struct iw_statistics *zd1201_get_wireless_stats(struct net_device *dev) 875 static struct iw_statistics *zd1201_get_wireless_stats(struct net_device *dev)
876 { 876 {
877 struct zd1201 *zd = (struct zd1201 *)dev->priv; 877 struct zd1201 *zd = (struct zd1201 *)dev->priv;
878 878
879 return &zd->iwstats; 879 return &zd->iwstats;
880 } 880 }
881 881
882 static void zd1201_set_multicast(struct net_device *dev) 882 static void zd1201_set_multicast(struct net_device *dev)
883 { 883 {
884 struct zd1201 *zd = (struct zd1201 *)dev->priv; 884 struct zd1201 *zd = (struct zd1201 *)dev->priv;
885 struct dev_mc_list *mc = dev->mc_list; 885 struct dev_mc_list *mc = dev->mc_list;
886 unsigned char reqbuf[ETH_ALEN*ZD1201_MAXMULTI]; 886 unsigned char reqbuf[ETH_ALEN*ZD1201_MAXMULTI];
887 int i; 887 int i;
888 888
889 if (dev->mc_count > ZD1201_MAXMULTI) 889 if (dev->mc_count > ZD1201_MAXMULTI)
890 return; 890 return;
891 891
892 for (i=0; i<dev->mc_count; i++) { 892 for (i=0; i<dev->mc_count; i++) {
893 memcpy(reqbuf+i*ETH_ALEN, mc->dmi_addr, ETH_ALEN); 893 memcpy(reqbuf+i*ETH_ALEN, mc->dmi_addr, ETH_ALEN);
894 mc = mc->next; 894 mc = mc->next;
895 } 895 }
896 zd1201_setconfig(zd, ZD1201_RID_CNFGROUPADDRESS, reqbuf, 896 zd1201_setconfig(zd, ZD1201_RID_CNFGROUPADDRESS, reqbuf,
897 dev->mc_count*ETH_ALEN, 0); 897 dev->mc_count*ETH_ALEN, 0);
898 898
899 } 899 }
900 900
901 static int zd1201_config_commit(struct net_device *dev, 901 static int zd1201_config_commit(struct net_device *dev,
902 struct iw_request_info *info, struct iw_point *data, char *essid) 902 struct iw_request_info *info, struct iw_point *data, char *essid)
903 { 903 {
904 struct zd1201 *zd = (struct zd1201 *)dev->priv; 904 struct zd1201 *zd = (struct zd1201 *)dev->priv;
905 905
906 return zd1201_mac_reset(zd); 906 return zd1201_mac_reset(zd);
907 } 907 }
908 908
909 static int zd1201_get_name(struct net_device *dev, 909 static int zd1201_get_name(struct net_device *dev,
910 struct iw_request_info *info, char *name, char *extra) 910 struct iw_request_info *info, char *name, char *extra)
911 { 911 {
912 strcpy(name, "IEEE 802.11b"); 912 strcpy(name, "IEEE 802.11b");
913 return 0; 913 return 0;
914 } 914 }
915 915
916 static int zd1201_set_freq(struct net_device *dev, 916 static int zd1201_set_freq(struct net_device *dev,
917 struct iw_request_info *info, struct iw_freq *freq, char *extra) 917 struct iw_request_info *info, struct iw_freq *freq, char *extra)
918 { 918 {
919 struct zd1201 *zd = (struct zd1201 *)dev->priv; 919 struct zd1201 *zd = (struct zd1201 *)dev->priv;
920 short channel = 0; 920 short channel = 0;
921 int err; 921 int err;
922 922
923 if (freq->e == 0) 923 if (freq->e == 0)
924 channel = freq->m; 924 channel = freq->m;
925 else { 925 else {
926 if (freq->m >= 2482) 926 if (freq->m >= 2482)
927 channel = 14; 927 channel = 14;
928 if (freq->m >= 2407) 928 if (freq->m >= 2407)
929 channel = (freq->m-2407)/5; 929 channel = (freq->m-2407)/5;
930 } 930 }
931 931
932 err = zd1201_setconfig16(zd, ZD1201_RID_CNFOWNCHANNEL, channel); 932 err = zd1201_setconfig16(zd, ZD1201_RID_CNFOWNCHANNEL, channel);
933 if (err) 933 if (err)
934 return err; 934 return err;
935 935
936 zd1201_mac_reset(zd); 936 zd1201_mac_reset(zd);
937 937
938 return 0; 938 return 0;
939 } 939 }
940 940
941 static int zd1201_get_freq(struct net_device *dev, 941 static int zd1201_get_freq(struct net_device *dev,
942 struct iw_request_info *info, struct iw_freq *freq, char *extra) 942 struct iw_request_info *info, struct iw_freq *freq, char *extra)
943 { 943 {
944 struct zd1201 *zd = (struct zd1201 *)dev->priv; 944 struct zd1201 *zd = (struct zd1201 *)dev->priv;
945 short channel; 945 short channel;
946 int err; 946 int err;
947 947
948 err = zd1201_getconfig16(zd, ZD1201_RID_CNFOWNCHANNEL, &channel); 948 err = zd1201_getconfig16(zd, ZD1201_RID_CNFOWNCHANNEL, &channel);
949 if (err) 949 if (err)
950 return err; 950 return err;
951 freq->e = 0; 951 freq->e = 0;
952 freq->m = channel; 952 freq->m = channel;
953 953
954 return 0; 954 return 0;
955 } 955 }
956 956
957 static int zd1201_set_mode(struct net_device *dev, 957 static int zd1201_set_mode(struct net_device *dev,
958 struct iw_request_info *info, __u32 *mode, char *extra) 958 struct iw_request_info *info, __u32 *mode, char *extra)
959 { 959 {
960 struct zd1201 *zd = (struct zd1201 *)dev->priv; 960 struct zd1201 *zd = (struct zd1201 *)dev->priv;
961 short porttype, monitor = 0; 961 short porttype, monitor = 0;
962 unsigned char buffer[IW_ESSID_MAX_SIZE+2]; 962 unsigned char buffer[IW_ESSID_MAX_SIZE+2];
963 int err; 963 int err;
964 964
965 if (zd->ap) { 965 if (zd->ap) {
966 if (*mode != IW_MODE_MASTER) 966 if (*mode != IW_MODE_MASTER)
967 return -EINVAL; 967 return -EINVAL;
968 return 0; 968 return 0;
969 } 969 }
970 970
971 err = zd1201_setconfig16(zd, ZD1201_RID_PROMISCUOUSMODE, 0); 971 err = zd1201_setconfig16(zd, ZD1201_RID_PROMISCUOUSMODE, 0);
972 if (err) 972 if (err)
973 return err; 973 return err;
974 zd->dev->type = ARPHRD_ETHER; 974 zd->dev->type = ARPHRD_ETHER;
975 switch(*mode) { 975 switch(*mode) {
976 case IW_MODE_MONITOR: 976 case IW_MODE_MONITOR:
977 monitor = 1; 977 monitor = 1;
978 zd->dev->type = ARPHRD_IEEE80211; 978 zd->dev->type = ARPHRD_IEEE80211;
979 /* Make sure we are no longer associated with by 979 /* Make sure we are no longer associated with by
980 setting an 'impossible' essid. 980 setting an 'impossible' essid.
981 (otherwise we mess up firmware) 981 (otherwise we mess up firmware)
982 */ 982 */
983 zd1201_join(zd, "\0-*#\0", 5); 983 zd1201_join(zd, "\0-*#\0", 5);
984 /* Put port in pIBSS */ 984 /* Put port in pIBSS */
985 case 8: /* No pseudo-IBSS in wireless extensions (yet) */ 985 case 8: /* No pseudo-IBSS in wireless extensions (yet) */
986 porttype = ZD1201_PORTTYPE_PSEUDOIBSS; 986 porttype = ZD1201_PORTTYPE_PSEUDOIBSS;
987 break; 987 break;
988 case IW_MODE_ADHOC: 988 case IW_MODE_ADHOC:
989 porttype = ZD1201_PORTTYPE_IBSS; 989 porttype = ZD1201_PORTTYPE_IBSS;
990 break; 990 break;
991 case IW_MODE_INFRA: 991 case IW_MODE_INFRA:
992 porttype = ZD1201_PORTTYPE_BSS; 992 porttype = ZD1201_PORTTYPE_BSS;
993 break; 993 break;
994 default: 994 default:
995 return -EINVAL; 995 return -EINVAL;
996 } 996 }
997 997
998 err = zd1201_setconfig16(zd, ZD1201_RID_CNFPORTTYPE, porttype); 998 err = zd1201_setconfig16(zd, ZD1201_RID_CNFPORTTYPE, porttype);
999 if (err) 999 if (err)
1000 return err; 1000 return err;
1001 if (zd->monitor && !monitor) { 1001 if (zd->monitor && !monitor) {
1002 zd1201_disable(zd); 1002 zd1201_disable(zd);
1003 *(__le16 *)buffer = cpu_to_le16(zd->essidlen); 1003 *(__le16 *)buffer = cpu_to_le16(zd->essidlen);
1004 memcpy(buffer+2, zd->essid, zd->essidlen); 1004 memcpy(buffer+2, zd->essid, zd->essidlen);
1005 err = zd1201_setconfig(zd, ZD1201_RID_CNFDESIREDSSID, 1005 err = zd1201_setconfig(zd, ZD1201_RID_CNFDESIREDSSID,
1006 buffer, IW_ESSID_MAX_SIZE+2, 1); 1006 buffer, IW_ESSID_MAX_SIZE+2, 1);
1007 if (err) 1007 if (err)
1008 return err; 1008 return err;
1009 } 1009 }
1010 zd->monitor = monitor; 1010 zd->monitor = monitor;
1011 /* If monitor mode is set we don't actually turn it on here since it 1011 /* If monitor mode is set we don't actually turn it on here since it
1012 * is done during mac reset anyway (see zd1201_mac_enable). 1012 * is done during mac reset anyway (see zd1201_mac_enable).
1013 */ 1013 */
1014 zd1201_mac_reset(zd); 1014 zd1201_mac_reset(zd);
1015 1015
1016 return 0; 1016 return 0;
1017 } 1017 }
1018 1018
1019 static int zd1201_get_mode(struct net_device *dev, 1019 static int zd1201_get_mode(struct net_device *dev,
1020 struct iw_request_info *info, __u32 *mode, char *extra) 1020 struct iw_request_info *info, __u32 *mode, char *extra)
1021 { 1021 {
1022 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1022 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1023 short porttype; 1023 short porttype;
1024 int err; 1024 int err;
1025 1025
1026 err = zd1201_getconfig16(zd, ZD1201_RID_CNFPORTTYPE, &porttype); 1026 err = zd1201_getconfig16(zd, ZD1201_RID_CNFPORTTYPE, &porttype);
1027 if (err) 1027 if (err)
1028 return err; 1028 return err;
1029 switch(porttype) { 1029 switch(porttype) {
1030 case ZD1201_PORTTYPE_IBSS: 1030 case ZD1201_PORTTYPE_IBSS:
1031 *mode = IW_MODE_ADHOC; 1031 *mode = IW_MODE_ADHOC;
1032 break; 1032 break;
1033 case ZD1201_PORTTYPE_BSS: 1033 case ZD1201_PORTTYPE_BSS:
1034 *mode = IW_MODE_INFRA; 1034 *mode = IW_MODE_INFRA;
1035 break; 1035 break;
1036 case ZD1201_PORTTYPE_WDS: 1036 case ZD1201_PORTTYPE_WDS:
1037 *mode = IW_MODE_REPEAT; 1037 *mode = IW_MODE_REPEAT;
1038 break; 1038 break;
1039 case ZD1201_PORTTYPE_PSEUDOIBSS: 1039 case ZD1201_PORTTYPE_PSEUDOIBSS:
1040 *mode = 8;/* No Pseudo-IBSS... */ 1040 *mode = 8;/* No Pseudo-IBSS... */
1041 break; 1041 break;
1042 case ZD1201_PORTTYPE_AP: 1042 case ZD1201_PORTTYPE_AP:
1043 *mode = IW_MODE_MASTER; 1043 *mode = IW_MODE_MASTER;
1044 break; 1044 break;
1045 default: 1045 default:
1046 dev_dbg(&zd->usb->dev, "Unknown porttype: %d\n", 1046 dev_dbg(&zd->usb->dev, "Unknown porttype: %d\n",
1047 porttype); 1047 porttype);
1048 *mode = IW_MODE_AUTO; 1048 *mode = IW_MODE_AUTO;
1049 } 1049 }
1050 if (zd->monitor) 1050 if (zd->monitor)
1051 *mode = IW_MODE_MONITOR; 1051 *mode = IW_MODE_MONITOR;
1052 1052
1053 return 0; 1053 return 0;
1054 } 1054 }
1055 1055
1056 static int zd1201_get_range(struct net_device *dev, 1056 static int zd1201_get_range(struct net_device *dev,
1057 struct iw_request_info *info, struct iw_point *wrq, char *extra) 1057 struct iw_request_info *info, struct iw_point *wrq, char *extra)
1058 { 1058 {
1059 struct iw_range *range = (struct iw_range *)extra; 1059 struct iw_range *range = (struct iw_range *)extra;
1060 1060
1061 wrq->length = sizeof(struct iw_range); 1061 wrq->length = sizeof(struct iw_range);
1062 memset(range, 0, sizeof(struct iw_range)); 1062 memset(range, 0, sizeof(struct iw_range));
1063 range->we_version_compiled = WIRELESS_EXT; 1063 range->we_version_compiled = WIRELESS_EXT;
1064 range->we_version_source = WIRELESS_EXT; 1064 range->we_version_source = WIRELESS_EXT;
1065 1065
1066 range->max_qual.qual = 128; 1066 range->max_qual.qual = 128;
1067 range->max_qual.level = 128; 1067 range->max_qual.level = 128;
1068 range->max_qual.noise = 128; 1068 range->max_qual.noise = 128;
1069 range->max_qual.updated = 7; 1069 range->max_qual.updated = 7;
1070 1070
1071 range->encoding_size[0] = 5; 1071 range->encoding_size[0] = 5;
1072 range->encoding_size[1] = 13; 1072 range->encoding_size[1] = 13;
1073 range->num_encoding_sizes = 2; 1073 range->num_encoding_sizes = 2;
1074 range->max_encoding_tokens = ZD1201_NUMKEYS; 1074 range->max_encoding_tokens = ZD1201_NUMKEYS;
1075 1075
1076 range->num_bitrates = 4; 1076 range->num_bitrates = 4;
1077 range->bitrate[0] = 1000000; 1077 range->bitrate[0] = 1000000;
1078 range->bitrate[1] = 2000000; 1078 range->bitrate[1] = 2000000;
1079 range->bitrate[2] = 5500000; 1079 range->bitrate[2] = 5500000;
1080 range->bitrate[3] = 11000000; 1080 range->bitrate[3] = 11000000;
1081 1081
1082 range->min_rts = 0; 1082 range->min_rts = 0;
1083 range->min_frag = ZD1201_FRAGMIN; 1083 range->min_frag = ZD1201_FRAGMIN;
1084 range->max_rts = ZD1201_RTSMAX; 1084 range->max_rts = ZD1201_RTSMAX;
1085 range->min_frag = ZD1201_FRAGMAX; 1085 range->min_frag = ZD1201_FRAGMAX;
1086 1086
1087 return 0; 1087 return 0;
1088 } 1088 }
1089 1089
1090 /* Little bit of magic here: we only get the quality if we poll 1090 /* Little bit of magic here: we only get the quality if we poll
1091 * for it, and we never get an actual request to trigger such 1091 * for it, and we never get an actual request to trigger such
1092 * a poll. Therefore we 'assume' that the user will soon ask for 1092 * a poll. Therefore we 'assume' that the user will soon ask for
1093 * the stats after asking the bssid. 1093 * the stats after asking the bssid.
1094 */ 1094 */
1095 static int zd1201_get_wap(struct net_device *dev, 1095 static int zd1201_get_wap(struct net_device *dev,
1096 struct iw_request_info *info, struct sockaddr *ap_addr, char *extra) 1096 struct iw_request_info *info, struct sockaddr *ap_addr, char *extra)
1097 { 1097 {
1098 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1098 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1099 unsigned char buffer[6]; 1099 unsigned char buffer[6];
1100 1100
1101 if (!zd1201_getconfig(zd, ZD1201_RID_COMMSQUALITY, buffer, 6)) { 1101 if (!zd1201_getconfig(zd, ZD1201_RID_COMMSQUALITY, buffer, 6)) {
1102 /* Unfortunately the quality and noise reported is useless. 1102 /* Unfortunately the quality and noise reported is useless.
1103 they seem to be accumulators that increase until you 1103 they seem to be accumulators that increase until you
1104 read them, unless we poll on a fixed interval we can't 1104 read them, unless we poll on a fixed interval we can't
1105 use them 1105 use them
1106 */ 1106 */
1107 /*zd->iwstats.qual.qual = le16_to_cpu(((__le16 *)buffer)[0]);*/ 1107 /*zd->iwstats.qual.qual = le16_to_cpu(((__le16 *)buffer)[0]);*/
1108 zd->iwstats.qual.level = le16_to_cpu(((__le16 *)buffer)[1]); 1108 zd->iwstats.qual.level = le16_to_cpu(((__le16 *)buffer)[1]);
1109 /*zd->iwstats.qual.noise = le16_to_cpu(((__le16 *)buffer)[2]);*/ 1109 /*zd->iwstats.qual.noise = le16_to_cpu(((__le16 *)buffer)[2]);*/
1110 zd->iwstats.qual.updated = 2; 1110 zd->iwstats.qual.updated = 2;
1111 } 1111 }
1112 1112
1113 return zd1201_getconfig(zd, ZD1201_RID_CURRENTBSSID, ap_addr->sa_data, 6); 1113 return zd1201_getconfig(zd, ZD1201_RID_CURRENTBSSID, ap_addr->sa_data, 6);
1114 } 1114 }
1115 1115
1116 static int zd1201_set_scan(struct net_device *dev, 1116 static int zd1201_set_scan(struct net_device *dev,
1117 struct iw_request_info *info, struct iw_point *srq, char *extra) 1117 struct iw_request_info *info, struct iw_point *srq, char *extra)
1118 { 1118 {
1119 /* We do everything in get_scan */ 1119 /* We do everything in get_scan */
1120 return 0; 1120 return 0;
1121 } 1121 }
1122 1122
1123 static int zd1201_get_scan(struct net_device *dev, 1123 static int zd1201_get_scan(struct net_device *dev,
1124 struct iw_request_info *info, struct iw_point *srq, char *extra) 1124 struct iw_request_info *info, struct iw_point *srq, char *extra)
1125 { 1125 {
1126 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1126 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1127 int err, i, j, enabled_save; 1127 int err, i, j, enabled_save;
1128 struct iw_event iwe; 1128 struct iw_event iwe;
1129 char *cev = extra; 1129 char *cev = extra;
1130 char *end_buf = extra + IW_SCAN_MAX_DATA; 1130 char *end_buf = extra + IW_SCAN_MAX_DATA;
1131 1131
1132 /* No scanning in AP mode */ 1132 /* No scanning in AP mode */
1133 if (zd->ap) 1133 if (zd->ap)
1134 return -EOPNOTSUPP; 1134 return -EOPNOTSUPP;
1135 1135
1136 /* Scan doesn't seem to work if disabled */ 1136 /* Scan doesn't seem to work if disabled */
1137 enabled_save = zd->mac_enabled; 1137 enabled_save = zd->mac_enabled;
1138 zd1201_enable(zd); 1138 zd1201_enable(zd);
1139 1139
1140 zd->rxdatas = 0; 1140 zd->rxdatas = 0;
1141 err = zd1201_docmd(zd, ZD1201_CMDCODE_INQUIRE, 1141 err = zd1201_docmd(zd, ZD1201_CMDCODE_INQUIRE,
1142 ZD1201_INQ_SCANRESULTS, 0, 0); 1142 ZD1201_INQ_SCANRESULTS, 0, 0);
1143 if (err) 1143 if (err)
1144 return err; 1144 return err;
1145 1145
1146 wait_event_interruptible(zd->rxdataq, zd->rxdatas); 1146 wait_event_interruptible(zd->rxdataq, zd->rxdatas);
1147 if (!zd->rxlen) 1147 if (!zd->rxlen)
1148 return -EIO; 1148 return -EIO;
1149 1149
1150 if (le16_to_cpu(*(__le16*)&zd->rxdata[2]) != ZD1201_INQ_SCANRESULTS) 1150 if (le16_to_cpu(*(__le16*)&zd->rxdata[2]) != ZD1201_INQ_SCANRESULTS)
1151 return -EIO; 1151 return -EIO;
1152 1152
1153 for(i=8; i<zd->rxlen; i+=62) { 1153 for(i=8; i<zd->rxlen; i+=62) {
1154 iwe.cmd = SIOCGIWAP; 1154 iwe.cmd = SIOCGIWAP;
1155 iwe.u.ap_addr.sa_family = ARPHRD_ETHER; 1155 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1156 memcpy(iwe.u.ap_addr.sa_data, zd->rxdata+i+6, 6); 1156 memcpy(iwe.u.ap_addr.sa_data, zd->rxdata+i+6, 6);
1157 cev = iwe_stream_add_event(cev, end_buf, &iwe, IW_EV_ADDR_LEN); 1157 cev = iwe_stream_add_event(cev, end_buf, &iwe, IW_EV_ADDR_LEN);
1158 1158
1159 iwe.cmd = SIOCGIWESSID; 1159 iwe.cmd = SIOCGIWESSID;
1160 iwe.u.data.length = zd->rxdata[i+16]; 1160 iwe.u.data.length = zd->rxdata[i+16];
1161 iwe.u.data.flags = 1; 1161 iwe.u.data.flags = 1;
1162 cev = iwe_stream_add_point(cev, end_buf, &iwe, zd->rxdata+i+18); 1162 cev = iwe_stream_add_point(cev, end_buf, &iwe, zd->rxdata+i+18);
1163 1163
1164 iwe.cmd = SIOCGIWMODE; 1164 iwe.cmd = SIOCGIWMODE;
1165 if (zd->rxdata[i+14]&0x01) 1165 if (zd->rxdata[i+14]&0x01)
1166 iwe.u.mode = IW_MODE_MASTER; 1166 iwe.u.mode = IW_MODE_MASTER;
1167 else 1167 else
1168 iwe.u.mode = IW_MODE_ADHOC; 1168 iwe.u.mode = IW_MODE_ADHOC;
1169 cev = iwe_stream_add_event(cev, end_buf, &iwe, IW_EV_UINT_LEN); 1169 cev = iwe_stream_add_event(cev, end_buf, &iwe, IW_EV_UINT_LEN);
1170 1170
1171 iwe.cmd = SIOCGIWFREQ; 1171 iwe.cmd = SIOCGIWFREQ;
1172 iwe.u.freq.m = zd->rxdata[i+0]; 1172 iwe.u.freq.m = zd->rxdata[i+0];
1173 iwe.u.freq.e = 0; 1173 iwe.u.freq.e = 0;
1174 cev = iwe_stream_add_event(cev, end_buf, &iwe, IW_EV_FREQ_LEN); 1174 cev = iwe_stream_add_event(cev, end_buf, &iwe, IW_EV_FREQ_LEN);
1175 1175
1176 iwe.cmd = SIOCGIWRATE; 1176 iwe.cmd = SIOCGIWRATE;
1177 iwe.u.bitrate.fixed = 0; 1177 iwe.u.bitrate.fixed = 0;
1178 iwe.u.bitrate.disabled = 0; 1178 iwe.u.bitrate.disabled = 0;
1179 for (j=0; j<10; j++) if (zd->rxdata[i+50+j]) { 1179 for (j=0; j<10; j++) if (zd->rxdata[i+50+j]) {
1180 iwe.u.bitrate.value = (zd->rxdata[i+50+j]&0x7f)*500000; 1180 iwe.u.bitrate.value = (zd->rxdata[i+50+j]&0x7f)*500000;
1181 cev=iwe_stream_add_event(cev, end_buf, &iwe, 1181 cev=iwe_stream_add_event(cev, end_buf, &iwe,
1182 IW_EV_PARAM_LEN); 1182 IW_EV_PARAM_LEN);
1183 } 1183 }
1184 1184
1185 iwe.cmd = SIOCGIWENCODE; 1185 iwe.cmd = SIOCGIWENCODE;
1186 iwe.u.data.length = 0; 1186 iwe.u.data.length = 0;
1187 if (zd->rxdata[i+14]&0x10) 1187 if (zd->rxdata[i+14]&0x10)
1188 iwe.u.data.flags = IW_ENCODE_ENABLED; 1188 iwe.u.data.flags = IW_ENCODE_ENABLED;
1189 else 1189 else
1190 iwe.u.data.flags = IW_ENCODE_DISABLED; 1190 iwe.u.data.flags = IW_ENCODE_DISABLED;
1191 cev = iwe_stream_add_point(cev, end_buf, &iwe, NULL); 1191 cev = iwe_stream_add_point(cev, end_buf, &iwe, NULL);
1192 1192
1193 iwe.cmd = IWEVQUAL; 1193 iwe.cmd = IWEVQUAL;
1194 iwe.u.qual.qual = zd->rxdata[i+4]; 1194 iwe.u.qual.qual = zd->rxdata[i+4];
1195 iwe.u.qual.noise= zd->rxdata[i+2]/10-100; 1195 iwe.u.qual.noise= zd->rxdata[i+2]/10-100;
1196 iwe.u.qual.level = (256+zd->rxdata[i+4]*100)/255-100; 1196 iwe.u.qual.level = (256+zd->rxdata[i+4]*100)/255-100;
1197 iwe.u.qual.updated = 7; 1197 iwe.u.qual.updated = 7;
1198 cev = iwe_stream_add_event(cev, end_buf, &iwe, IW_EV_QUAL_LEN); 1198 cev = iwe_stream_add_event(cev, end_buf, &iwe, IW_EV_QUAL_LEN);
1199 } 1199 }
1200 1200
1201 if (!enabled_save) 1201 if (!enabled_save)
1202 zd1201_disable(zd); 1202 zd1201_disable(zd);
1203 1203
1204 srq->length = cev - extra; 1204 srq->length = cev - extra;
1205 srq->flags = 0; 1205 srq->flags = 0;
1206 1206
1207 return 0; 1207 return 0;
1208 } 1208 }
1209 1209
1210 static int zd1201_set_essid(struct net_device *dev, 1210 static int zd1201_set_essid(struct net_device *dev,
1211 struct iw_request_info *info, struct iw_point *data, char *essid) 1211 struct iw_request_info *info, struct iw_point *data, char *essid)
1212 { 1212 {
1213 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1213 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1214 1214
1215 if (data->length > IW_ESSID_MAX_SIZE) 1215 if (data->length > IW_ESSID_MAX_SIZE)
1216 return -EINVAL; 1216 return -EINVAL;
1217 if (data->length < 1) 1217 if (data->length < 1)
1218 data->length = 1; 1218 data->length = 1;
1219 zd->essidlen = data->length; 1219 zd->essidlen = data->length;
1220 memset(zd->essid, 0, IW_ESSID_MAX_SIZE+1); 1220 memset(zd->essid, 0, IW_ESSID_MAX_SIZE+1);
1221 memcpy(zd->essid, essid, data->length); 1221 memcpy(zd->essid, essid, data->length);
1222 return zd1201_join(zd, zd->essid, zd->essidlen); 1222 return zd1201_join(zd, zd->essid, zd->essidlen);
1223 } 1223 }
1224 1224
1225 static int zd1201_get_essid(struct net_device *dev, 1225 static int zd1201_get_essid(struct net_device *dev,
1226 struct iw_request_info *info, struct iw_point *data, char *essid) 1226 struct iw_request_info *info, struct iw_point *data, char *essid)
1227 { 1227 {
1228 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1228 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1229 1229
1230 memcpy(essid, zd->essid, zd->essidlen); 1230 memcpy(essid, zd->essid, zd->essidlen);
1231 data->flags = 1; 1231 data->flags = 1;
1232 data->length = zd->essidlen; 1232 data->length = zd->essidlen;
1233 1233
1234 return 0; 1234 return 0;
1235 } 1235 }
1236 1236
1237 static int zd1201_get_nick(struct net_device *dev, struct iw_request_info *info, 1237 static int zd1201_get_nick(struct net_device *dev, struct iw_request_info *info,
1238 struct iw_point *data, char *nick) 1238 struct iw_point *data, char *nick)
1239 { 1239 {
1240 strcpy(nick, "zd1201"); 1240 strcpy(nick, "zd1201");
1241 data->flags = 1; 1241 data->flags = 1;
1242 data->length = strlen(nick); 1242 data->length = strlen(nick);
1243 return 0; 1243 return 0;
1244 } 1244 }
1245 1245
1246 static int zd1201_set_rate(struct net_device *dev, 1246 static int zd1201_set_rate(struct net_device *dev,
1247 struct iw_request_info *info, struct iw_param *rrq, char *extra) 1247 struct iw_request_info *info, struct iw_param *rrq, char *extra)
1248 { 1248 {
1249 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1249 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1250 short rate; 1250 short rate;
1251 int err; 1251 int err;
1252 1252
1253 switch (rrq->value) { 1253 switch (rrq->value) {
1254 case 1000000: 1254 case 1000000:
1255 rate = ZD1201_RATEB1; 1255 rate = ZD1201_RATEB1;
1256 break; 1256 break;
1257 case 2000000: 1257 case 2000000:
1258 rate = ZD1201_RATEB2; 1258 rate = ZD1201_RATEB2;
1259 break; 1259 break;
1260 case 5500000: 1260 case 5500000:
1261 rate = ZD1201_RATEB5; 1261 rate = ZD1201_RATEB5;
1262 break; 1262 break;
1263 case 11000000: 1263 case 11000000:
1264 default: 1264 default:
1265 rate = ZD1201_RATEB11; 1265 rate = ZD1201_RATEB11;
1266 break; 1266 break;
1267 } 1267 }
1268 if (!rrq->fixed) { /* Also enable all lower bitrates */ 1268 if (!rrq->fixed) { /* Also enable all lower bitrates */
1269 rate |= rate-1; 1269 rate |= rate-1;
1270 } 1270 }
1271 1271
1272 err = zd1201_setconfig16(zd, ZD1201_RID_TXRATECNTL, rate); 1272 err = zd1201_setconfig16(zd, ZD1201_RID_TXRATECNTL, rate);
1273 if (err) 1273 if (err)
1274 return err; 1274 return err;
1275 1275
1276 return zd1201_mac_reset(zd); 1276 return zd1201_mac_reset(zd);
1277 } 1277 }
1278 1278
1279 static int zd1201_get_rate(struct net_device *dev, 1279 static int zd1201_get_rate(struct net_device *dev,
1280 struct iw_request_info *info, struct iw_param *rrq, char *extra) 1280 struct iw_request_info *info, struct iw_param *rrq, char *extra)
1281 { 1281 {
1282 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1282 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1283 short rate; 1283 short rate;
1284 int err; 1284 int err;
1285 1285
1286 err = zd1201_getconfig16(zd, ZD1201_RID_CURRENTTXRATE, &rate); 1286 err = zd1201_getconfig16(zd, ZD1201_RID_CURRENTTXRATE, &rate);
1287 if (err) 1287 if (err)
1288 return err; 1288 return err;
1289 1289
1290 switch(rate) { 1290 switch(rate) {
1291 case 1: 1291 case 1:
1292 rrq->value = 1000000; 1292 rrq->value = 1000000;
1293 break; 1293 break;
1294 case 2: 1294 case 2:
1295 rrq->value = 2000000; 1295 rrq->value = 2000000;
1296 break; 1296 break;
1297 case 5: 1297 case 5:
1298 rrq->value = 5500000; 1298 rrq->value = 5500000;
1299 break; 1299 break;
1300 case 11: 1300 case 11:
1301 rrq->value = 11000000; 1301 rrq->value = 11000000;
1302 break; 1302 break;
1303 default: 1303 default:
1304 rrq->value = 0; 1304 rrq->value = 0;
1305 } 1305 }
1306 rrq->fixed = 0; 1306 rrq->fixed = 0;
1307 rrq->disabled = 0; 1307 rrq->disabled = 0;
1308 1308
1309 return 0; 1309 return 0;
1310 } 1310 }
1311 1311
1312 static int zd1201_set_rts(struct net_device *dev, struct iw_request_info *info, 1312 static int zd1201_set_rts(struct net_device *dev, struct iw_request_info *info,
1313 struct iw_param *rts, char *extra) 1313 struct iw_param *rts, char *extra)
1314 { 1314 {
1315 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1315 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1316 int err; 1316 int err;
1317 short val = rts->value; 1317 short val = rts->value;
1318 1318
1319 if (rts->disabled || !rts->fixed) 1319 if (rts->disabled || !rts->fixed)
1320 val = ZD1201_RTSMAX; 1320 val = ZD1201_RTSMAX;
1321 if (val > ZD1201_RTSMAX) 1321 if (val > ZD1201_RTSMAX)
1322 return -EINVAL; 1322 return -EINVAL;
1323 if (val < 0) 1323 if (val < 0)
1324 return -EINVAL; 1324 return -EINVAL;
1325 1325
1326 err = zd1201_setconfig16(zd, ZD1201_RID_CNFRTSTHRESHOLD, val); 1326 err = zd1201_setconfig16(zd, ZD1201_RID_CNFRTSTHRESHOLD, val);
1327 if (err) 1327 if (err)
1328 return err; 1328 return err;
1329 return zd1201_mac_reset(zd); 1329 return zd1201_mac_reset(zd);
1330 } 1330 }
1331 1331
1332 static int zd1201_get_rts(struct net_device *dev, struct iw_request_info *info, 1332 static int zd1201_get_rts(struct net_device *dev, struct iw_request_info *info,
1333 struct iw_param *rts, char *extra) 1333 struct iw_param *rts, char *extra)
1334 { 1334 {
1335 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1335 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1336 short rtst; 1336 short rtst;
1337 int err; 1337 int err;
1338 1338
1339 err = zd1201_getconfig16(zd, ZD1201_RID_CNFRTSTHRESHOLD, &rtst); 1339 err = zd1201_getconfig16(zd, ZD1201_RID_CNFRTSTHRESHOLD, &rtst);
1340 if (err) 1340 if (err)
1341 return err; 1341 return err;
1342 rts->value = rtst; 1342 rts->value = rtst;
1343 rts->disabled = (rts->value == ZD1201_RTSMAX); 1343 rts->disabled = (rts->value == ZD1201_RTSMAX);
1344 rts->fixed = 1; 1344 rts->fixed = 1;
1345 1345
1346 return 0; 1346 return 0;
1347 } 1347 }
1348 1348
1349 static int zd1201_set_frag(struct net_device *dev, struct iw_request_info *info, 1349 static int zd1201_set_frag(struct net_device *dev, struct iw_request_info *info,
1350 struct iw_param *frag, char *extra) 1350 struct iw_param *frag, char *extra)
1351 { 1351 {
1352 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1352 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1353 int err; 1353 int err;
1354 short val = frag->value; 1354 short val = frag->value;
1355 1355
1356 if (frag->disabled || !frag->fixed) 1356 if (frag->disabled || !frag->fixed)
1357 val = ZD1201_FRAGMAX; 1357 val = ZD1201_FRAGMAX;
1358 if (val > ZD1201_FRAGMAX) 1358 if (val > ZD1201_FRAGMAX)
1359 return -EINVAL; 1359 return -EINVAL;
1360 if (val < ZD1201_FRAGMIN) 1360 if (val < ZD1201_FRAGMIN)
1361 return -EINVAL; 1361 return -EINVAL;
1362 if (val & 1) 1362 if (val & 1)
1363 return -EINVAL; 1363 return -EINVAL;
1364 err = zd1201_setconfig16(zd, ZD1201_RID_CNFFRAGTHRESHOLD, val); 1364 err = zd1201_setconfig16(zd, ZD1201_RID_CNFFRAGTHRESHOLD, val);
1365 if (err) 1365 if (err)
1366 return err; 1366 return err;
1367 return zd1201_mac_reset(zd); 1367 return zd1201_mac_reset(zd);
1368 } 1368 }
1369 1369
1370 static int zd1201_get_frag(struct net_device *dev, struct iw_request_info *info, 1370 static int zd1201_get_frag(struct net_device *dev, struct iw_request_info *info,
1371 struct iw_param *frag, char *extra) 1371 struct iw_param *frag, char *extra)
1372 { 1372 {
1373 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1373 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1374 short fragt; 1374 short fragt;
1375 int err; 1375 int err;
1376 1376
1377 err = zd1201_getconfig16(zd, ZD1201_RID_CNFFRAGTHRESHOLD, &fragt); 1377 err = zd1201_getconfig16(zd, ZD1201_RID_CNFFRAGTHRESHOLD, &fragt);
1378 if (err) 1378 if (err)
1379 return err; 1379 return err;
1380 frag->value = fragt; 1380 frag->value = fragt;
1381 frag->disabled = (frag->value == ZD1201_FRAGMAX); 1381 frag->disabled = (frag->value == ZD1201_FRAGMAX);
1382 frag->fixed = 1; 1382 frag->fixed = 1;
1383 1383
1384 return 0; 1384 return 0;
1385 } 1385 }
1386 1386
1387 static int zd1201_set_retry(struct net_device *dev, 1387 static int zd1201_set_retry(struct net_device *dev,
1388 struct iw_request_info *info, struct iw_param *rrq, char *extra) 1388 struct iw_request_info *info, struct iw_param *rrq, char *extra)
1389 { 1389 {
1390 return 0; 1390 return 0;
1391 } 1391 }
1392 1392
1393 static int zd1201_get_retry(struct net_device *dev, 1393 static int zd1201_get_retry(struct net_device *dev,
1394 struct iw_request_info *info, struct iw_param *rrq, char *extra) 1394 struct iw_request_info *info, struct iw_param *rrq, char *extra)
1395 { 1395 {
1396 return 0; 1396 return 0;
1397 } 1397 }
1398 1398
1399 static int zd1201_set_encode(struct net_device *dev, 1399 static int zd1201_set_encode(struct net_device *dev,
1400 struct iw_request_info *info, struct iw_point *erq, char *key) 1400 struct iw_request_info *info, struct iw_point *erq, char *key)
1401 { 1401 {
1402 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1402 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1403 short i; 1403 short i;
1404 int err, rid; 1404 int err, rid;
1405 1405
1406 if (erq->length > ZD1201_MAXKEYLEN) 1406 if (erq->length > ZD1201_MAXKEYLEN)
1407 return -EINVAL; 1407 return -EINVAL;
1408 1408
1409 i = (erq->flags & IW_ENCODE_INDEX)-1; 1409 i = (erq->flags & IW_ENCODE_INDEX)-1;
1410 if (i == -1) { 1410 if (i == -1) {
1411 err = zd1201_getconfig16(zd,ZD1201_RID_CNFDEFAULTKEYID,&i); 1411 err = zd1201_getconfig16(zd,ZD1201_RID_CNFDEFAULTKEYID,&i);
1412 if (err) 1412 if (err)
1413 return err; 1413 return err;
1414 } else { 1414 } else {
1415 err = zd1201_setconfig16(zd, ZD1201_RID_CNFDEFAULTKEYID, i); 1415 err = zd1201_setconfig16(zd, ZD1201_RID_CNFDEFAULTKEYID, i);
1416 if (err) 1416 if (err)
1417 return err; 1417 return err;
1418 } 1418 }
1419 1419
1420 if (i < 0 || i >= ZD1201_NUMKEYS) 1420 if (i < 0 || i >= ZD1201_NUMKEYS)
1421 return -EINVAL; 1421 return -EINVAL;
1422 1422
1423 rid = ZD1201_RID_CNFDEFAULTKEY0 + i; 1423 rid = ZD1201_RID_CNFDEFAULTKEY0 + i;
1424 err = zd1201_setconfig(zd, rid, key, erq->length, 1); 1424 err = zd1201_setconfig(zd, rid, key, erq->length, 1);
1425 if (err) 1425 if (err)
1426 return err; 1426 return err;
1427 zd->encode_keylen[i] = erq->length; 1427 zd->encode_keylen[i] = erq->length;
1428 memcpy(zd->encode_keys[i], key, erq->length); 1428 memcpy(zd->encode_keys[i], key, erq->length);
1429 1429
1430 i=0; 1430 i=0;
1431 if (!(erq->flags & IW_ENCODE_DISABLED & IW_ENCODE_MODE)) { 1431 if (!(erq->flags & IW_ENCODE_DISABLED & IW_ENCODE_MODE)) {
1432 i |= 0x01; 1432 i |= 0x01;
1433 zd->encode_enabled = 1; 1433 zd->encode_enabled = 1;
1434 } else 1434 } else
1435 zd->encode_enabled = 0; 1435 zd->encode_enabled = 0;
1436 if (erq->flags & IW_ENCODE_RESTRICTED & IW_ENCODE_MODE) { 1436 if (erq->flags & IW_ENCODE_RESTRICTED & IW_ENCODE_MODE) {
1437 i |= 0x02; 1437 i |= 0x02;
1438 zd->encode_restricted = 1; 1438 zd->encode_restricted = 1;
1439 } else 1439 } else
1440 zd->encode_restricted = 0; 1440 zd->encode_restricted = 0;
1441 err = zd1201_setconfig16(zd, ZD1201_RID_CNFWEBFLAGS, i); 1441 err = zd1201_setconfig16(zd, ZD1201_RID_CNFWEBFLAGS, i);
1442 if (err) 1442 if (err)
1443 return err; 1443 return err;
1444 1444
1445 if (zd->encode_enabled) 1445 if (zd->encode_enabled)
1446 i = ZD1201_CNFAUTHENTICATION_SHAREDKEY; 1446 i = ZD1201_CNFAUTHENTICATION_SHAREDKEY;
1447 else 1447 else
1448 i = ZD1201_CNFAUTHENTICATION_OPENSYSTEM; 1448 i = ZD1201_CNFAUTHENTICATION_OPENSYSTEM;
1449 err = zd1201_setconfig16(zd, ZD1201_RID_CNFAUTHENTICATION, i); 1449 err = zd1201_setconfig16(zd, ZD1201_RID_CNFAUTHENTICATION, i);
1450 if (err) 1450 if (err)
1451 return err; 1451 return err;
1452 1452
1453 return zd1201_mac_reset(zd); 1453 return zd1201_mac_reset(zd);
1454 } 1454 }
1455 1455
1456 static int zd1201_get_encode(struct net_device *dev, 1456 static int zd1201_get_encode(struct net_device *dev,
1457 struct iw_request_info *info, struct iw_point *erq, char *key) 1457 struct iw_request_info *info, struct iw_point *erq, char *key)
1458 { 1458 {
1459 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1459 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1460 short i; 1460 short i;
1461 int err; 1461 int err;
1462 1462
1463 if (zd->encode_enabled) 1463 if (zd->encode_enabled)
1464 erq->flags = IW_ENCODE_ENABLED; 1464 erq->flags = IW_ENCODE_ENABLED;
1465 else 1465 else
1466 erq->flags = IW_ENCODE_DISABLED; 1466 erq->flags = IW_ENCODE_DISABLED;
1467 if (zd->encode_restricted) 1467 if (zd->encode_restricted)
1468 erq->flags |= IW_ENCODE_RESTRICTED; 1468 erq->flags |= IW_ENCODE_RESTRICTED;
1469 else 1469 else
1470 erq->flags |= IW_ENCODE_OPEN; 1470 erq->flags |= IW_ENCODE_OPEN;
1471 1471
1472 i = (erq->flags & IW_ENCODE_INDEX) -1; 1472 i = (erq->flags & IW_ENCODE_INDEX) -1;
1473 if (i == -1) { 1473 if (i == -1) {
1474 err = zd1201_getconfig16(zd, ZD1201_RID_CNFDEFAULTKEYID, &i); 1474 err = zd1201_getconfig16(zd, ZD1201_RID_CNFDEFAULTKEYID, &i);
1475 if (err) 1475 if (err)
1476 return err; 1476 return err;
1477 } 1477 }
1478 if (i<0 || i>= ZD1201_NUMKEYS) 1478 if (i<0 || i>= ZD1201_NUMKEYS)
1479 return -EINVAL; 1479 return -EINVAL;
1480 1480
1481 erq->flags |= i+1; 1481 erq->flags |= i+1;
1482 1482
1483 erq->length = zd->encode_keylen[i]; 1483 erq->length = zd->encode_keylen[i];
1484 memcpy(key, zd->encode_keys[i], erq->length); 1484 memcpy(key, zd->encode_keys[i], erq->length);
1485 1485
1486 return 0; 1486 return 0;
1487 } 1487 }
1488 1488
1489 static int zd1201_set_power(struct net_device *dev, 1489 static int zd1201_set_power(struct net_device *dev,
1490 struct iw_request_info *info, struct iw_param *vwrq, char *extra) 1490 struct iw_request_info *info, struct iw_param *vwrq, char *extra)
1491 { 1491 {
1492 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1492 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1493 short enabled, duration, level; 1493 short enabled, duration, level;
1494 int err; 1494 int err;
1495 1495
1496 enabled = vwrq->disabled ? 0 : 1; 1496 enabled = vwrq->disabled ? 0 : 1;
1497 if (enabled) { 1497 if (enabled) {
1498 if (vwrq->flags & IW_POWER_PERIOD) { 1498 if (vwrq->flags & IW_POWER_PERIOD) {
1499 duration = vwrq->value; 1499 duration = vwrq->value;
1500 err = zd1201_setconfig16(zd, 1500 err = zd1201_setconfig16(zd,
1501 ZD1201_RID_CNFMAXSLEEPDURATION, duration); 1501 ZD1201_RID_CNFMAXSLEEPDURATION, duration);
1502 if (err) 1502 if (err)
1503 return err; 1503 return err;
1504 goto out; 1504 goto out;
1505 } 1505 }
1506 if (vwrq->flags & IW_POWER_TIMEOUT) { 1506 if (vwrq->flags & IW_POWER_TIMEOUT) {
1507 err = zd1201_getconfig16(zd, 1507 err = zd1201_getconfig16(zd,
1508 ZD1201_RID_CNFMAXSLEEPDURATION, &duration); 1508 ZD1201_RID_CNFMAXSLEEPDURATION, &duration);
1509 if (err) 1509 if (err)
1510 return err; 1510 return err;
1511 level = vwrq->value * 4 / duration; 1511 level = vwrq->value * 4 / duration;
1512 if (level > 4) 1512 if (level > 4)
1513 level = 4; 1513 level = 4;
1514 if (level < 0) 1514 if (level < 0)
1515 level = 0; 1515 level = 0;
1516 err = zd1201_setconfig16(zd, ZD1201_RID_CNFPMEPS, 1516 err = zd1201_setconfig16(zd, ZD1201_RID_CNFPMEPS,
1517 level); 1517 level);
1518 if (err) 1518 if (err)
1519 return err; 1519 return err;
1520 goto out; 1520 goto out;
1521 } 1521 }
1522 return -EINVAL; 1522 return -EINVAL;
1523 } 1523 }
1524 out: 1524 out:
1525 return zd1201_setconfig16(zd, ZD1201_RID_CNFPMENABLED, enabled); 1525 return zd1201_setconfig16(zd, ZD1201_RID_CNFPMENABLED, enabled);
1526 } 1526 }
1527 1527
1528 static int zd1201_get_power(struct net_device *dev, 1528 static int zd1201_get_power(struct net_device *dev,
1529 struct iw_request_info *info, struct iw_param *vwrq, char *extra) 1529 struct iw_request_info *info, struct iw_param *vwrq, char *extra)
1530 { 1530 {
1531 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1531 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1532 short enabled, level, duration; 1532 short enabled, level, duration;
1533 int err; 1533 int err;
1534 1534
1535 err = zd1201_getconfig16(zd, ZD1201_RID_CNFPMENABLED, &enabled); 1535 err = zd1201_getconfig16(zd, ZD1201_RID_CNFPMENABLED, &enabled);
1536 if (err) 1536 if (err)
1537 return err; 1537 return err;
1538 err = zd1201_getconfig16(zd, ZD1201_RID_CNFPMEPS, &level); 1538 err = zd1201_getconfig16(zd, ZD1201_RID_CNFPMEPS, &level);
1539 if (err) 1539 if (err)
1540 return err; 1540 return err;
1541 err = zd1201_getconfig16(zd, ZD1201_RID_CNFMAXSLEEPDURATION, &duration); 1541 err = zd1201_getconfig16(zd, ZD1201_RID_CNFMAXSLEEPDURATION, &duration);
1542 if (err) 1542 if (err)
1543 return err; 1543 return err;
1544 vwrq->disabled = enabled ? 0 : 1; 1544 vwrq->disabled = enabled ? 0 : 1;
1545 if (vwrq->flags & IW_POWER_TYPE) { 1545 if (vwrq->flags & IW_POWER_TYPE) {
1546 if (vwrq->flags & IW_POWER_PERIOD) { 1546 if (vwrq->flags & IW_POWER_PERIOD) {
1547 vwrq->value = duration; 1547 vwrq->value = duration;
1548 vwrq->flags = IW_POWER_PERIOD; 1548 vwrq->flags = IW_POWER_PERIOD;
1549 } else { 1549 } else {
1550 vwrq->value = duration * level / 4; 1550 vwrq->value = duration * level / 4;
1551 vwrq->flags = IW_POWER_TIMEOUT; 1551 vwrq->flags = IW_POWER_TIMEOUT;
1552 } 1552 }
1553 } 1553 }
1554 if (vwrq->flags & IW_POWER_MODE) { 1554 if (vwrq->flags & IW_POWER_MODE) {
1555 if (enabled && level) 1555 if (enabled && level)
1556 vwrq->flags = IW_POWER_UNICAST_R; 1556 vwrq->flags = IW_POWER_UNICAST_R;
1557 else 1557 else
1558 vwrq->flags = IW_POWER_ALL_R; 1558 vwrq->flags = IW_POWER_ALL_R;
1559 } 1559 }
1560 1560
1561 return 0; 1561 return 0;
1562 } 1562 }
1563 1563
1564 1564
1565 static const iw_handler zd1201_iw_handler[] = 1565 static const iw_handler zd1201_iw_handler[] =
1566 { 1566 {
1567 (iw_handler) zd1201_config_commit, /* SIOCSIWCOMMIT */ 1567 (iw_handler) zd1201_config_commit, /* SIOCSIWCOMMIT */
1568 (iw_handler) zd1201_get_name, /* SIOCGIWNAME */ 1568 (iw_handler) zd1201_get_name, /* SIOCGIWNAME */
1569 (iw_handler) NULL, /* SIOCSIWNWID */ 1569 (iw_handler) NULL, /* SIOCSIWNWID */
1570 (iw_handler) NULL, /* SIOCGIWNWID */ 1570 (iw_handler) NULL, /* SIOCGIWNWID */
1571 (iw_handler) zd1201_set_freq, /* SIOCSIWFREQ */ 1571 (iw_handler) zd1201_set_freq, /* SIOCSIWFREQ */
1572 (iw_handler) zd1201_get_freq, /* SIOCGIWFREQ */ 1572 (iw_handler) zd1201_get_freq, /* SIOCGIWFREQ */
1573 (iw_handler) zd1201_set_mode, /* SIOCSIWMODE */ 1573 (iw_handler) zd1201_set_mode, /* SIOCSIWMODE */
1574 (iw_handler) zd1201_get_mode, /* SIOCGIWMODE */ 1574 (iw_handler) zd1201_get_mode, /* SIOCGIWMODE */
1575 (iw_handler) NULL, /* SIOCSIWSENS */ 1575 (iw_handler) NULL, /* SIOCSIWSENS */
1576 (iw_handler) NULL, /* SIOCGIWSENS */ 1576 (iw_handler) NULL, /* SIOCGIWSENS */
1577 (iw_handler) NULL, /* SIOCSIWRANGE */ 1577 (iw_handler) NULL, /* SIOCSIWRANGE */
1578 (iw_handler) zd1201_get_range, /* SIOCGIWRANGE */ 1578 (iw_handler) zd1201_get_range, /* SIOCGIWRANGE */
1579 (iw_handler) NULL, /* SIOCSIWPRIV */ 1579 (iw_handler) NULL, /* SIOCSIWPRIV */
1580 (iw_handler) NULL, /* SIOCGIWPRIV */ 1580 (iw_handler) NULL, /* SIOCGIWPRIV */
1581 (iw_handler) NULL, /* SIOCSIWSTATS */ 1581 (iw_handler) NULL, /* SIOCSIWSTATS */
1582 (iw_handler) NULL, /* SIOCGIWSTATS */ 1582 (iw_handler) NULL, /* SIOCGIWSTATS */
1583 (iw_handler) NULL, /* SIOCSIWSPY */ 1583 (iw_handler) NULL, /* SIOCSIWSPY */
1584 (iw_handler) NULL, /* SIOCGIWSPY */ 1584 (iw_handler) NULL, /* SIOCGIWSPY */
1585 (iw_handler) NULL, /* -- hole -- */ 1585 (iw_handler) NULL, /* -- hole -- */
1586 (iw_handler) NULL, /* -- hole -- */ 1586 (iw_handler) NULL, /* -- hole -- */
1587 (iw_handler) NULL/*zd1201_set_wap*/, /* SIOCSIWAP */ 1587 (iw_handler) NULL/*zd1201_set_wap*/, /* SIOCSIWAP */
1588 (iw_handler) zd1201_get_wap, /* SIOCGIWAP */ 1588 (iw_handler) zd1201_get_wap, /* SIOCGIWAP */
1589 (iw_handler) NULL, /* -- hole -- */ 1589 (iw_handler) NULL, /* -- hole -- */
1590 (iw_handler) NULL, /* SIOCGIWAPLIST */ 1590 (iw_handler) NULL, /* SIOCGIWAPLIST */
1591 (iw_handler) zd1201_set_scan, /* SIOCSIWSCAN */ 1591 (iw_handler) zd1201_set_scan, /* SIOCSIWSCAN */
1592 (iw_handler) zd1201_get_scan, /* SIOCGIWSCAN */ 1592 (iw_handler) zd1201_get_scan, /* SIOCGIWSCAN */
1593 (iw_handler) zd1201_set_essid, /* SIOCSIWESSID */ 1593 (iw_handler) zd1201_set_essid, /* SIOCSIWESSID */
1594 (iw_handler) zd1201_get_essid, /* SIOCGIWESSID */ 1594 (iw_handler) zd1201_get_essid, /* SIOCGIWESSID */
1595 (iw_handler) NULL, /* SIOCSIWNICKN */ 1595 (iw_handler) NULL, /* SIOCSIWNICKN */
1596 (iw_handler) zd1201_get_nick, /* SIOCGIWNICKN */ 1596 (iw_handler) zd1201_get_nick, /* SIOCGIWNICKN */
1597 (iw_handler) NULL, /* -- hole -- */ 1597 (iw_handler) NULL, /* -- hole -- */
1598 (iw_handler) NULL, /* -- hole -- */ 1598 (iw_handler) NULL, /* -- hole -- */
1599 (iw_handler) zd1201_set_rate, /* SIOCSIWRATE */ 1599 (iw_handler) zd1201_set_rate, /* SIOCSIWRATE */
1600 (iw_handler) zd1201_get_rate, /* SIOCGIWRATE */ 1600 (iw_handler) zd1201_get_rate, /* SIOCGIWRATE */
1601 (iw_handler) zd1201_set_rts, /* SIOCSIWRTS */ 1601 (iw_handler) zd1201_set_rts, /* SIOCSIWRTS */
1602 (iw_handler) zd1201_get_rts, /* SIOCGIWRTS */ 1602 (iw_handler) zd1201_get_rts, /* SIOCGIWRTS */
1603 (iw_handler) zd1201_set_frag, /* SIOCSIWFRAG */ 1603 (iw_handler) zd1201_set_frag, /* SIOCSIWFRAG */
1604 (iw_handler) zd1201_get_frag, /* SIOCGIWFRAG */ 1604 (iw_handler) zd1201_get_frag, /* SIOCGIWFRAG */
1605 (iw_handler) NULL, /* SIOCSIWTXPOW */ 1605 (iw_handler) NULL, /* SIOCSIWTXPOW */
1606 (iw_handler) NULL, /* SIOCGIWTXPOW */ 1606 (iw_handler) NULL, /* SIOCGIWTXPOW */
1607 (iw_handler) zd1201_set_retry, /* SIOCSIWRETRY */ 1607 (iw_handler) zd1201_set_retry, /* SIOCSIWRETRY */
1608 (iw_handler) zd1201_get_retry, /* SIOCGIWRETRY */ 1608 (iw_handler) zd1201_get_retry, /* SIOCGIWRETRY */
1609 (iw_handler) zd1201_set_encode, /* SIOCSIWENCODE */ 1609 (iw_handler) zd1201_set_encode, /* SIOCSIWENCODE */
1610 (iw_handler) zd1201_get_encode, /* SIOCGIWENCODE */ 1610 (iw_handler) zd1201_get_encode, /* SIOCGIWENCODE */
1611 (iw_handler) zd1201_set_power, /* SIOCSIWPOWER */ 1611 (iw_handler) zd1201_set_power, /* SIOCSIWPOWER */
1612 (iw_handler) zd1201_get_power, /* SIOCGIWPOWER */ 1612 (iw_handler) zd1201_get_power, /* SIOCGIWPOWER */
1613 }; 1613 };
1614 1614
1615 static int zd1201_set_hostauth(struct net_device *dev, 1615 static int zd1201_set_hostauth(struct net_device *dev,
1616 struct iw_request_info *info, struct iw_param *rrq, char *extra) 1616 struct iw_request_info *info, struct iw_param *rrq, char *extra)
1617 { 1617 {
1618 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1618 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1619 1619
1620 if (!zd->ap) 1620 if (!zd->ap)
1621 return -EOPNOTSUPP; 1621 return -EOPNOTSUPP;
1622 1622
1623 return zd1201_setconfig16(zd, ZD1201_RID_CNFHOSTAUTH, rrq->value); 1623 return zd1201_setconfig16(zd, ZD1201_RID_CNFHOSTAUTH, rrq->value);
1624 } 1624 }
1625 1625
1626 static int zd1201_get_hostauth(struct net_device *dev, 1626 static int zd1201_get_hostauth(struct net_device *dev,
1627 struct iw_request_info *info, struct iw_param *rrq, char *extra) 1627 struct iw_request_info *info, struct iw_param *rrq, char *extra)
1628 { 1628 {
1629 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1629 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1630 short hostauth; 1630 short hostauth;
1631 int err; 1631 int err;
1632 1632
1633 if (!zd->ap) 1633 if (!zd->ap)
1634 return -EOPNOTSUPP; 1634 return -EOPNOTSUPP;
1635 1635
1636 err = zd1201_getconfig16(zd, ZD1201_RID_CNFHOSTAUTH, &hostauth); 1636 err = zd1201_getconfig16(zd, ZD1201_RID_CNFHOSTAUTH, &hostauth);
1637 if (err) 1637 if (err)
1638 return err; 1638 return err;
1639 rrq->value = hostauth; 1639 rrq->value = hostauth;
1640 rrq->fixed = 1; 1640 rrq->fixed = 1;
1641 1641
1642 return 0; 1642 return 0;
1643 } 1643 }
1644 1644
1645 static int zd1201_auth_sta(struct net_device *dev, 1645 static int zd1201_auth_sta(struct net_device *dev,
1646 struct iw_request_info *info, struct sockaddr *sta, char *extra) 1646 struct iw_request_info *info, struct sockaddr *sta, char *extra)
1647 { 1647 {
1648 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1648 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1649 unsigned char buffer[10]; 1649 unsigned char buffer[10];
1650 1650
1651 if (!zd->ap) 1651 if (!zd->ap)
1652 return -EOPNOTSUPP; 1652 return -EOPNOTSUPP;
1653 1653
1654 memcpy(buffer, sta->sa_data, ETH_ALEN); 1654 memcpy(buffer, sta->sa_data, ETH_ALEN);
1655 *(short*)(buffer+6) = 0; /* 0==success, 1==failure */ 1655 *(short*)(buffer+6) = 0; /* 0==success, 1==failure */
1656 *(short*)(buffer+8) = 0; 1656 *(short*)(buffer+8) = 0;
1657 1657
1658 return zd1201_setconfig(zd, ZD1201_RID_AUTHENTICATESTA, buffer, 10, 1); 1658 return zd1201_setconfig(zd, ZD1201_RID_AUTHENTICATESTA, buffer, 10, 1);
1659 } 1659 }
1660 1660
1661 static int zd1201_set_maxassoc(struct net_device *dev, 1661 static int zd1201_set_maxassoc(struct net_device *dev,
1662 struct iw_request_info *info, struct iw_param *rrq, char *extra) 1662 struct iw_request_info *info, struct iw_param *rrq, char *extra)
1663 { 1663 {
1664 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1664 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1665 int err; 1665 int err;
1666 1666
1667 if (!zd->ap) 1667 if (!zd->ap)
1668 return -EOPNOTSUPP; 1668 return -EOPNOTSUPP;
1669 1669
1670 err = zd1201_setconfig16(zd, ZD1201_RID_CNFMAXASSOCSTATIONS, rrq->value); 1670 err = zd1201_setconfig16(zd, ZD1201_RID_CNFMAXASSOCSTATIONS, rrq->value);
1671 if (err) 1671 if (err)
1672 return err; 1672 return err;
1673 return 0; 1673 return 0;
1674 } 1674 }
1675 1675
1676 static int zd1201_get_maxassoc(struct net_device *dev, 1676 static int zd1201_get_maxassoc(struct net_device *dev,
1677 struct iw_request_info *info, struct iw_param *rrq, char *extra) 1677 struct iw_request_info *info, struct iw_param *rrq, char *extra)
1678 { 1678 {
1679 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1679 struct zd1201 *zd = (struct zd1201 *)dev->priv;
1680 short maxassoc; 1680 short maxassoc;
1681 int err; 1681 int err;
1682 1682
1683 if (!zd->ap) 1683 if (!zd->ap)
1684 return -EOPNOTSUPP; 1684 return -EOPNOTSUPP;
1685 1685
1686 err = zd1201_getconfig16(zd, ZD1201_RID_CNFMAXASSOCSTATIONS, &maxassoc); 1686 err = zd1201_getconfig16(zd, ZD1201_RID_CNFMAXASSOCSTATIONS, &maxassoc);
1687 if (err) 1687 if (err)
1688 return err; 1688 return err;
1689 rrq->value = maxassoc; 1689 rrq->value = maxassoc;
1690 rrq->fixed = 1; 1690 rrq->fixed = 1;
1691 1691
1692 return 0; 1692 return 0;
1693 } 1693 }
1694 1694
1695 static const iw_handler zd1201_private_handler[] = { 1695 static const iw_handler zd1201_private_handler[] = {
1696 (iw_handler) zd1201_set_hostauth, /* ZD1201SIWHOSTAUTH */ 1696 (iw_handler) zd1201_set_hostauth, /* ZD1201SIWHOSTAUTH */
1697 (iw_handler) zd1201_get_hostauth, /* ZD1201GIWHOSTAUTH */ 1697 (iw_handler) zd1201_get_hostauth, /* ZD1201GIWHOSTAUTH */
1698 (iw_handler) zd1201_auth_sta, /* ZD1201SIWAUTHSTA */ 1698 (iw_handler) zd1201_auth_sta, /* ZD1201SIWAUTHSTA */
1699 (iw_handler) NULL, /* nothing to get */ 1699 (iw_handler) NULL, /* nothing to get */
1700 (iw_handler) zd1201_set_maxassoc, /* ZD1201SIMAXASSOC */ 1700 (iw_handler) zd1201_set_maxassoc, /* ZD1201SIMAXASSOC */
1701 (iw_handler) zd1201_get_maxassoc, /* ZD1201GIMAXASSOC */ 1701 (iw_handler) zd1201_get_maxassoc, /* ZD1201GIMAXASSOC */
1702 }; 1702 };
1703 1703
1704 static const struct iw_priv_args zd1201_private_args[] = { 1704 static const struct iw_priv_args zd1201_private_args[] = {
1705 { ZD1201SIWHOSTAUTH, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 1705 { ZD1201SIWHOSTAUTH, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1706 IW_PRIV_TYPE_NONE, "sethostauth" }, 1706 IW_PRIV_TYPE_NONE, "sethostauth" },
1707 { ZD1201GIWHOSTAUTH, IW_PRIV_TYPE_NONE, 1707 { ZD1201GIWHOSTAUTH, IW_PRIV_TYPE_NONE,
1708 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethostauth" }, 1708 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethostauth" },
1709 { ZD1201SIWAUTHSTA, IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 1709 { ZD1201SIWAUTHSTA, IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1,
1710 IW_PRIV_TYPE_NONE, "authstation" }, 1710 IW_PRIV_TYPE_NONE, "authstation" },
1711 { ZD1201SIWMAXASSOC, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 1711 { ZD1201SIWMAXASSOC, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1712 IW_PRIV_TYPE_NONE, "setmaxassoc" }, 1712 IW_PRIV_TYPE_NONE, "setmaxassoc" },
1713 { ZD1201GIWMAXASSOC, IW_PRIV_TYPE_NONE, 1713 { ZD1201GIWMAXASSOC, IW_PRIV_TYPE_NONE,
1714 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getmaxassoc" }, 1714 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getmaxassoc" },
1715 }; 1715 };
1716 1716
1717 static const struct iw_handler_def zd1201_iw_handlers = { 1717 static const struct iw_handler_def zd1201_iw_handlers = {
1718 .num_standard = ARRAY_SIZE(zd1201_iw_handler), 1718 .num_standard = ARRAY_SIZE(zd1201_iw_handler),
1719 .num_private = ARRAY_SIZE(zd1201_private_handler), 1719 .num_private = ARRAY_SIZE(zd1201_private_handler),
1720 .num_private_args = ARRAY_SIZE(zd1201_private_args), 1720 .num_private_args = ARRAY_SIZE(zd1201_private_args),
1721 .standard = (iw_handler *)zd1201_iw_handler, 1721 .standard = (iw_handler *)zd1201_iw_handler,
1722 .private = (iw_handler *)zd1201_private_handler, 1722 .private = (iw_handler *)zd1201_private_handler,
1723 .private_args = (struct iw_priv_args *) zd1201_private_args, 1723 .private_args = (struct iw_priv_args *) zd1201_private_args,
1724 .get_wireless_stats = zd1201_get_wireless_stats, 1724 .get_wireless_stats = zd1201_get_wireless_stats,
1725 }; 1725 };
1726 1726
1727 static int zd1201_probe(struct usb_interface *interface, 1727 static int zd1201_probe(struct usb_interface *interface,
1728 const struct usb_device_id *id) 1728 const struct usb_device_id *id)
1729 { 1729 {
1730 struct zd1201 *zd; 1730 struct zd1201 *zd;
1731 struct usb_device *usb; 1731 struct usb_device *usb;
1732 int err; 1732 int err;
1733 short porttype; 1733 short porttype;
1734 char buf[IW_ESSID_MAX_SIZE+2]; 1734 char buf[IW_ESSID_MAX_SIZE+2];
1735 1735
1736 usb = interface_to_usbdev(interface); 1736 usb = interface_to_usbdev(interface);
1737 1737
1738 zd = kzalloc(sizeof(struct zd1201), GFP_KERNEL); 1738 zd = kzalloc(sizeof(struct zd1201), GFP_KERNEL);
1739 if (!zd) 1739 if (!zd)
1740 return -ENOMEM; 1740 return -ENOMEM;
1741 zd->ap = ap; 1741 zd->ap = ap;
1742 zd->usb = usb; 1742 zd->usb = usb;
1743 zd->removed = 0; 1743 zd->removed = 0;
1744 init_waitqueue_head(&zd->rxdataq); 1744 init_waitqueue_head(&zd->rxdataq);
1745 INIT_HLIST_HEAD(&zd->fraglist); 1745 INIT_HLIST_HEAD(&zd->fraglist);
1746 1746
1747 err = zd1201_fw_upload(usb, zd->ap); 1747 err = zd1201_fw_upload(usb, zd->ap);
1748 if (err) { 1748 if (err) {
1749 dev_err(&usb->dev, "zd1201 firmware upload failed: %d\n", err); 1749 dev_err(&usb->dev, "zd1201 firmware upload failed: %d\n", err);
1750 goto err_zd; 1750 goto err_zd;
1751 } 1751 }
1752 1752
1753 zd->endp_in = 1; 1753 zd->endp_in = 1;
1754 zd->endp_out = 1; 1754 zd->endp_out = 1;
1755 zd->endp_out2 = 2; 1755 zd->endp_out2 = 2;
1756 zd->rx_urb = usb_alloc_urb(0, GFP_KERNEL); 1756 zd->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
1757 zd->tx_urb = usb_alloc_urb(0, GFP_KERNEL); 1757 zd->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
1758 if (!zd->rx_urb || !zd->tx_urb) 1758 if (!zd->rx_urb || !zd->tx_urb)
1759 goto err_zd; 1759 goto err_zd;
1760 1760
1761 mdelay(100); 1761 mdelay(100);
1762 err = zd1201_drvr_start(zd); 1762 err = zd1201_drvr_start(zd);
1763 if (err) 1763 if (err)
1764 goto err_zd; 1764 goto err_zd;
1765 1765
1766 err = zd1201_setconfig16(zd, ZD1201_RID_CNFMAXDATALEN, 2312); 1766 err = zd1201_setconfig16(zd, ZD1201_RID_CNFMAXDATALEN, 2312);
1767 if (err) 1767 if (err)
1768 goto err_start; 1768 goto err_start;
1769 1769
1770 err = zd1201_setconfig16(zd, ZD1201_RID_TXRATECNTL, 1770 err = zd1201_setconfig16(zd, ZD1201_RID_TXRATECNTL,
1771 ZD1201_RATEB1 | ZD1201_RATEB2 | ZD1201_RATEB5 | ZD1201_RATEB11); 1771 ZD1201_RATEB1 | ZD1201_RATEB2 | ZD1201_RATEB5 | ZD1201_RATEB11);
1772 if (err) 1772 if (err)
1773 goto err_start; 1773 goto err_start;
1774 1774
1775 zd->dev = alloc_etherdev(0); 1775 zd->dev = alloc_etherdev(0);
1776 if (!zd->dev) 1776 if (!zd->dev)
1777 goto err_start; 1777 goto err_start;
1778 1778
1779 zd->dev->priv = zd; 1779 zd->dev->priv = zd;
1780 zd->dev->open = zd1201_net_open; 1780 zd->dev->open = zd1201_net_open;
1781 zd->dev->stop = zd1201_net_stop; 1781 zd->dev->stop = zd1201_net_stop;
1782 zd->dev->get_stats = zd1201_get_stats; 1782 zd->dev->get_stats = zd1201_get_stats;
1783 zd->dev->wireless_handlers = 1783 zd->dev->wireless_handlers =
1784 (struct iw_handler_def *)&zd1201_iw_handlers; 1784 (struct iw_handler_def *)&zd1201_iw_handlers;
1785 zd->dev->hard_start_xmit = zd1201_hard_start_xmit; 1785 zd->dev->hard_start_xmit = zd1201_hard_start_xmit;
1786 zd->dev->watchdog_timeo = ZD1201_TX_TIMEOUT; 1786 zd->dev->watchdog_timeo = ZD1201_TX_TIMEOUT;
1787 zd->dev->tx_timeout = zd1201_tx_timeout; 1787 zd->dev->tx_timeout = zd1201_tx_timeout;
1788 zd->dev->set_multicast_list = zd1201_set_multicast; 1788 zd->dev->set_multicast_list = zd1201_set_multicast;
1789 zd->dev->set_mac_address = zd1201_set_mac_address; 1789 zd->dev->set_mac_address = zd1201_set_mac_address;
1790 strcpy(zd->dev->name, "wlan%d"); 1790 strcpy(zd->dev->name, "wlan%d");
1791 1791
1792 err = zd1201_getconfig(zd, ZD1201_RID_CNFOWNMACADDR, 1792 err = zd1201_getconfig(zd, ZD1201_RID_CNFOWNMACADDR,
1793 zd->dev->dev_addr, zd->dev->addr_len); 1793 zd->dev->dev_addr, zd->dev->addr_len);
1794 if (err) 1794 if (err)
1795 goto err_net; 1795 goto err_net;
1796 1796
1797 /* Set wildcard essid to match zd->essid */ 1797 /* Set wildcard essid to match zd->essid */
1798 *(__le16 *)buf = cpu_to_le16(0); 1798 *(__le16 *)buf = cpu_to_le16(0);
1799 err = zd1201_setconfig(zd, ZD1201_RID_CNFDESIREDSSID, buf, 1799 err = zd1201_setconfig(zd, ZD1201_RID_CNFDESIREDSSID, buf,
1800 IW_ESSID_MAX_SIZE+2, 1); 1800 IW_ESSID_MAX_SIZE+2, 1);
1801 if (err) 1801 if (err)
1802 goto err_net; 1802 goto err_net;
1803 1803
1804 if (zd->ap) 1804 if (zd->ap)
1805 porttype = ZD1201_PORTTYPE_AP; 1805 porttype = ZD1201_PORTTYPE_AP;
1806 else 1806 else
1807 porttype = ZD1201_PORTTYPE_BSS; 1807 porttype = ZD1201_PORTTYPE_BSS;
1808 err = zd1201_setconfig16(zd, ZD1201_RID_CNFPORTTYPE, porttype); 1808 err = zd1201_setconfig16(zd, ZD1201_RID_CNFPORTTYPE, porttype);
1809 if (err) 1809 if (err)
1810 goto err_net; 1810 goto err_net;
1811 1811
1812 SET_NETDEV_DEV(zd->dev, &usb->dev); 1812 SET_NETDEV_DEV(zd->dev, &usb->dev);
1813 1813
1814 err = register_netdev(zd->dev); 1814 err = register_netdev(zd->dev);
1815 if (err) 1815 if (err)
1816 goto err_net; 1816 goto err_net;
1817 dev_info(&usb->dev, "%s: ZD1201 USB Wireless interface\n", 1817 dev_info(&usb->dev, "%s: ZD1201 USB Wireless interface\n",
1818 zd->dev->name); 1818 zd->dev->name);
1819 1819
1820 usb_set_intfdata(interface, zd); 1820 usb_set_intfdata(interface, zd);
1821 zd1201_enable(zd); /* zd1201 likes to startup enabled, */ 1821 zd1201_enable(zd); /* zd1201 likes to startup enabled, */
1822 zd1201_disable(zd); /* interfering with all the wifis in range */ 1822 zd1201_disable(zd); /* interfering with all the wifis in range */
1823 return 0; 1823 return 0;
1824 1824
1825 err_net: 1825 err_net:
1826 free_netdev(zd->dev); 1826 free_netdev(zd->dev);
1827 err_start: 1827 err_start:
1828 /* Leave the device in reset state */ 1828 /* Leave the device in reset state */
1829 zd1201_docmd(zd, ZD1201_CMDCODE_INIT, 0, 0, 0); 1829 zd1201_docmd(zd, ZD1201_CMDCODE_INIT, 0, 0, 0);
1830 err_zd: 1830 err_zd:
1831 if (zd->tx_urb) 1831 usb_free_urb(zd->tx_urb);
1832 usb_free_urb(zd->tx_urb); 1832 usb_free_urb(zd->rx_urb);
1833 if (zd->rx_urb)
1834 usb_free_urb(zd->rx_urb);
1835 kfree(zd); 1833 kfree(zd);
1836 return err; 1834 return err;
1837 } 1835 }
1838 1836
1839 static void zd1201_disconnect(struct usb_interface *interface) 1837 static void zd1201_disconnect(struct usb_interface *interface)
1840 { 1838 {
1841 struct zd1201 *zd=(struct zd1201 *)usb_get_intfdata(interface); 1839 struct zd1201 *zd=(struct zd1201 *)usb_get_intfdata(interface);
1842 struct hlist_node *node, *node2; 1840 struct hlist_node *node, *node2;
1843 struct zd1201_frag *frag; 1841 struct zd1201_frag *frag;
1844 1842
1845 if (!zd) 1843 if (!zd)
1846 return; 1844 return;
1847 usb_set_intfdata(interface, NULL); 1845 usb_set_intfdata(interface, NULL);
1848 if (zd->dev) { 1846 if (zd->dev) {
1849 unregister_netdev(zd->dev); 1847 unregister_netdev(zd->dev);
1850 free_netdev(zd->dev); 1848 free_netdev(zd->dev);
1851 } 1849 }
1852 1850
1853 hlist_for_each_entry_safe(frag, node, node2, &zd->fraglist, fnode) { 1851 hlist_for_each_entry_safe(frag, node, node2, &zd->fraglist, fnode) {
1854 hlist_del_init(&frag->fnode); 1852 hlist_del_init(&frag->fnode);
1855 kfree_skb(frag->skb); 1853 kfree_skb(frag->skb);
1856 kfree(frag); 1854 kfree(frag);
1857 } 1855 }
1858 1856
1859 if (zd->tx_urb) { 1857 if (zd->tx_urb) {
1860 usb_kill_urb(zd->tx_urb); 1858 usb_kill_urb(zd->tx_urb);
1861 usb_free_urb(zd->tx_urb); 1859 usb_free_urb(zd->tx_urb);
1862 } 1860 }
1863 if (zd->rx_urb) { 1861 if (zd->rx_urb) {
1864 usb_kill_urb(zd->rx_urb); 1862 usb_kill_urb(zd->rx_urb);
1865 usb_free_urb(zd->rx_urb); 1863 usb_free_urb(zd->rx_urb);
1866 } 1864 }
1867 kfree(zd); 1865 kfree(zd);
1868 } 1866 }
1869 1867
1870 #ifdef CONFIG_PM 1868 #ifdef CONFIG_PM
1871 1869
1872 static int zd1201_suspend(struct usb_interface *interface, 1870 static int zd1201_suspend(struct usb_interface *interface,
1873 pm_message_t message) 1871 pm_message_t message)
1874 { 1872 {
1875 struct zd1201 *zd = usb_get_intfdata(interface); 1873 struct zd1201 *zd = usb_get_intfdata(interface);
1876 1874
1877 netif_device_detach(zd->dev); 1875 netif_device_detach(zd->dev);
1878 1876
1879 zd->was_enabled = zd->mac_enabled; 1877 zd->was_enabled = zd->mac_enabled;
1880 1878
1881 if (zd->was_enabled) 1879 if (zd->was_enabled)
1882 return zd1201_disable(zd); 1880 return zd1201_disable(zd);
1883 else 1881 else
1884 return 0; 1882 return 0;
1885 } 1883 }
1886 1884
1887 static int zd1201_resume(struct usb_interface *interface) 1885 static int zd1201_resume(struct usb_interface *interface)
1888 { 1886 {
1889 struct zd1201 *zd = usb_get_intfdata(interface); 1887 struct zd1201 *zd = usb_get_intfdata(interface);
1890 1888
1891 if (!zd || !zd->dev) 1889 if (!zd || !zd->dev)
1892 return -ENODEV; 1890 return -ENODEV;
1893 1891
1894 netif_device_attach(zd->dev); 1892 netif_device_attach(zd->dev);
1895 1893
1896 if (zd->was_enabled) 1894 if (zd->was_enabled)
1897 return zd1201_enable(zd); 1895 return zd1201_enable(zd);
1898 else 1896 else
1899 return 0; 1897 return 0;
1900 } 1898 }
1901 1899
1902 #else 1900 #else
1903 1901
1904 #define zd1201_suspend NULL 1902 #define zd1201_suspend NULL
1905 #define zd1201_resume NULL 1903 #define zd1201_resume NULL
1906 1904
1907 #endif 1905 #endif
1908 1906
1909 static struct usb_driver zd1201_usb = { 1907 static struct usb_driver zd1201_usb = {
1910 .name = "zd1201", 1908 .name = "zd1201",
1911 .probe = zd1201_probe, 1909 .probe = zd1201_probe,
1912 .disconnect = zd1201_disconnect, 1910 .disconnect = zd1201_disconnect,
1913 .id_table = zd1201_table, 1911 .id_table = zd1201_table,
1914 .suspend = zd1201_suspend, 1912 .suspend = zd1201_suspend,
1915 .resume = zd1201_resume, 1913 .resume = zd1201_resume,
1916 }; 1914 };
1917 1915
1918 static int __init zd1201_init(void) 1916 static int __init zd1201_init(void)
1919 { 1917 {
1920 return usb_register(&zd1201_usb); 1918 return usb_register(&zd1201_usb);
1921 } 1919 }
1922 1920
1923 static void __exit zd1201_cleanup(void) 1921 static void __exit zd1201_cleanup(void)
1924 { 1922 {
1925 usb_deregister(&zd1201_usb); 1923 usb_deregister(&zd1201_usb);
1926 } 1924 }
1927 1925
1928 module_init(zd1201_init); 1926 module_init(zd1201_init);
1929 module_exit(zd1201_cleanup); 1927 module_exit(zd1201_cleanup);
1930 1928