API tools faq
paste
Advertisement
Guest User

zd1201

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