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