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