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