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