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