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