Lines Matching defs:zd
121 struct zd1201 *zd = urb->context;
131 dev_warn(&zd->usb->dev, "%s: urb failed: %d\n",
132 zd->dev->name, urb->status);
149 static int zd1201_docmd(struct zd1201 *zd, int cmd, int parm0,
171 usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb, zd->endp_out2),
172 command, 16, zd1201_usbfree, zd);
185 struct zd1201 *zd = urb->context;
186 netif_wake_queue(zd->dev);
192 struct zd1201 *zd = urb->context;
198 if (!zd)
209 dev_warn(&zd->usb->dev, "%s: rx urb failed: %d\n",
210 zd->dev->name, urb->status);
220 memcpy(zd->rxdata, data, urb->actual_length);
221 zd->rxlen = urb->actual_length;
222 zd->rxdatas = 1;
223 wake_up(&zd->rxdataq);
238 netif_carrier_on(zd->dev);
241 netif_carrier_off(zd->dev);
244 netif_carrier_off(zd->dev);
247 netif_carrier_on(zd->dev);
250 netif_carrier_off(zd->dev);
274 wireless_send_event(zd->dev, event, &wrqu, NULL);
287 wireless_send_event(zd->dev, IWEVEXPIRED, &wrqu, NULL);
291 zd->rxlen = 0;
295 if (copylen+zd->rxlen > sizeof(zd->rxdata))
297 memcpy(zd->rxdata+zd->rxlen, data+i+4, copylen);
298 zd->rxlen += copylen;
302 zd->rxdatas = 1;
303 wake_up(&zd->rxdataq);
319 if (zd->monitor) {
332 skb->protocol = eth_type_trans(skb, zd->dev);
333 zd->dev->stats.rx_packets++;
334 zd->dev->stats.rx_bytes += skb->len;
361 hlist_add_head(&frag->fnode, &zd->fraglist);
364 hlist_for_each_entry(frag, node, &zd->fraglist, fnode)
388 skb->protocol = eth_type_trans(skb, zd->dev);
389 zd->dev->stats.rx_packets++;
390 zd->dev->stats.rx_bytes += skb->len;
397 urb->dev = zd->usb;
403 zd->rxlen = 0;
404 zd->rxdatas = 1;
405 wake_up(&zd->rxdataq);
410 static int zd1201_getconfig(struct zd1201 *zd, int rid, void *riddata,
420 zd->rxdatas = 0;
421 err = zd1201_docmd(zd, ZD1201_CMDCODE_ACCESS, rid, 0, 0);
425 wait_event_interruptible(zd->rxdataq, zd->rxdatas);
426 if (!zd->rxlen)
429 code = le16_to_cpu(*(__le16*)(&zd->rxdata[4]));
430 rid_fid = le16_to_cpu(*(__le16*)(&zd->rxdata[6]));
431 length = le16_to_cpu(*(__le16*)(&zd->rxdata[8]));
432 if (length > zd->rxlen)
433 length = zd->rxlen-6;
441 dev_dbg(&zd->usb->dev, "riddatalen mismatches, expected=%u, (packet=%u) length=%u, rid=0x%04X, rid_fid=0x%04X\n",
442 riddatalen, zd->rxlen, length, rid, rid_fid);
446 zd->rxdatas = 0;
448 err = zd1201_docmd(zd, ZD1201_CMDCODE_SETRXRID, rid, 0, length);
453 wait_event_interruptible(zd->rxdataq, zd->rxdatas);
454 if (!zd->rxlen)
457 if (zd->rxdata[zd->rxlen - 1] != ZD1201_PACKET_RESOURCE) {
458 dev_dbg(&zd->usb->dev, "Packet type mismatch: 0x%x not 0x3\n",
459 zd->rxdata[zd->rxlen-1]);
464 pdata = zd->rxdata;
465 length = zd->rxlen;
473 dev_dbg(&zd->usb->dev, "Rx Resource packet type error: %02X\n",
510 static int zd1201_setconfig(struct zd1201 *zd, int rid, void *buf, int len, int wait)
521 zd->rxdatas = 0;
522 zd->rxlen = 0;
551 usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb,
552 zd->endp_out2), request, 16, zd1201_usbfree, zd);
572 usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb, zd->endp_out2),
573 request, 16, zd1201_usbfree, zd);
579 wait_event_interruptible(zd->rxdataq, zd->rxdatas);
580 if (!zd->rxlen || le16_to_cpu(*(__le16*)&zd->rxdata[6]) != rid) {
581 dev_dbg(&zd->usb->dev, "wrong or no RID received\n");
592 static inline int zd1201_getconfig16(struct zd1201 *zd, int rid, short *val)
597 err = zd1201_getconfig(zd, rid, &zdval, sizeof(__le16));
604 static inline int zd1201_setconfig16(struct zd1201 *zd, int rid, short val)
607 return (zd1201_setconfig(zd, rid, &zdval, sizeof(__le16), 1));
610 static int zd1201_drvr_start(struct zd1201 *zd)
621 usb_fill_bulk_urb(zd->rx_urb, zd->usb,
622 usb_rcvbulkpipe(zd->usb, zd->endp_in), buffer, ZD1201_RXSIZE,
623 zd1201_usbrx, zd);
625 err = usb_submit_urb(zd->rx_urb, GFP_KERNEL);
629 err = zd1201_docmd(zd, ZD1201_CMDCODE_INIT, 0, 0, 0);
633 err = zd1201_getconfig(zd, ZD1201_RID_CNFMAXTXBUFFERNUMBER, &zdmax,
640 err = zd1201_docmd(zd, ZD1201_CMDCODE_ALLOC, 1514, 0, 0);
648 usb_kill_urb(zd->rx_urb);
660 static int zd1201_enable(struct zd1201 *zd)
664 if (zd->mac_enabled)
667 err = zd1201_docmd(zd, ZD1201_CMDCODE_ENABLE, 0, 0, 0);
669 zd->mac_enabled = 1;
671 if (zd->monitor)
672 err = zd1201_setconfig16(zd, ZD1201_RID_PROMISCUOUSMODE, 1);
677 static int zd1201_disable(struct zd1201 *zd)
681 if (!zd->mac_enabled)
683 if (zd->monitor) {
684 err = zd1201_setconfig16(zd, ZD1201_RID_PROMISCUOUSMODE, 0);
689 err = zd1201_docmd(zd, ZD1201_CMDCODE_DISABLE, 0, 0, 0);
691 zd->mac_enabled = 0;
695 static int zd1201_mac_reset(struct zd1201 *zd)
697 if (!zd->mac_enabled)
699 zd1201_disable(zd);
700 return zd1201_enable(zd);
703 static int zd1201_join(struct zd1201 *zd, char *essid, int essidlen)
708 err = zd1201_disable(zd);
714 err = zd1201_setconfig16(zd, ZD1201_RID_CNFAUTHENTICATION, val);
720 if (!zd->ap) { /* Normal station */
721 err = zd1201_setconfig(zd, ZD1201_RID_CNFDESIREDSSID, buf,
726 err = zd1201_setconfig(zd, ZD1201_RID_CNFOWNSSID, buf,
732 err = zd1201_setconfig(zd, ZD1201_RID_CNFOWNMACADDR,
733 zd->dev->dev_addr, zd->dev->addr_len, 1);
737 err = zd1201_enable(zd);
747 struct zd1201 *zd = netdev_priv(dev);
750 if (!zd->mac_enabled)
751 zd1201_join(zd, zd->essid, zd->essidlen);
781 zd 1 null byte, zd1201 packet type
786 struct zd1201 *zd = netdev_priv(dev);
787 unsigned char *txbuf = zd->txdata;
789 struct urb *urb = zd->tx_urb;
791 if (!zd->mac_enabled || zd->monitor) {
817 usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb, zd->endp_out),
818 txbuf, txbuflen, zd1201_usbtx, zd);
820 err = usb_submit_urb(zd->tx_urb, GFP_ATOMIC);
835 struct zd1201 *zd = netdev_priv(dev);
837 if (!zd)
839 dev_warn(&zd->usb->dev, "%s: TX timeout, shooting down urb\n",
841 usb_unlink_urb(zd->tx_urb);
850 struct zd1201 *zd = netdev_priv(dev);
853 if (!zd)
856 err = zd1201_setconfig(zd, ZD1201_RID_CNFOWNMACADDR,
862 return zd1201_mac_reset(zd);
867 struct zd1201 *zd = netdev_priv(dev);
869 return &zd->iwstats;
874 struct zd1201 *zd = netdev_priv(dev);
885 zd1201_setconfig(zd, ZD1201_RID_CNFGROUPADDRESS, reqbuf,
892 struct zd1201 *zd = netdev_priv(dev);
894 return zd1201_mac_reset(zd);
907 struct zd1201 *zd = netdev_priv(dev);
919 err = zd1201_setconfig16(zd, ZD1201_RID_CNFOWNCHANNEL, channel);
923 zd1201_mac_reset(zd);
931 struct zd1201 *zd = netdev_priv(dev);
935 err = zd1201_getconfig16(zd, ZD1201_RID_CNFOWNCHANNEL, &channel);
947 struct zd1201 *zd = netdev_priv(dev);
952 if (zd->ap) {
958 err = zd1201_setconfig16(zd, ZD1201_RID_PROMISCUOUSMODE, 0);
961 zd->dev->type = ARPHRD_ETHER;
965 zd->dev->type = ARPHRD_IEEE80211;
970 zd1201_join(zd, "\0-*#\0", 5);
985 err = zd1201_setconfig16(zd, ZD1201_RID_CNFPORTTYPE, porttype);
988 if (zd->monitor && !monitor) {
989 zd1201_disable(zd);
990 *(__le16 *)buffer = cpu_to_le16(zd->essidlen);
991 memcpy(buffer+2, zd->essid, zd->essidlen);
992 err = zd1201_setconfig(zd, ZD1201_RID_CNFDESIREDSSID,
997 zd->monitor = monitor;
1001 zd1201_mac_reset(zd);
1009 struct zd1201 *zd = netdev_priv(dev);
1013 err = zd1201_getconfig16(zd, ZD1201_RID_CNFPORTTYPE, &porttype);
1033 dev_dbg(&zd->usb->dev, "Unknown porttype: %d\n",
1037 if (zd->monitor)
1085 struct zd1201 *zd = netdev_priv(dev);
1088 if (!zd1201_getconfig(zd, ZD1201_RID_COMMSQUALITY, buffer, 6)) {
1094 /*zd->iwstats.qual.qual = le16_to_cpu(((__le16 *)buffer)[0]);*/
1095 zd->iwstats.qual.level = le16_to_cpu(((__le16 *)buffer)[1]);
1096 /*zd->iwstats.qual.noise = le16_to_cpu(((__le16 *)buffer)[2]);*/
1097 zd->iwstats.qual.updated = 2;
1100 return zd1201_getconfig(zd, ZD1201_RID_CURRENTBSSID, ap_addr->sa_data, 6);
1113 struct zd1201 *zd = netdev_priv(dev);
1120 if (zd->ap)
1124 enabled_save = zd->mac_enabled;
1125 zd1201_enable(zd);
1127 zd->rxdatas = 0;
1128 err = zd1201_docmd(zd, ZD1201_CMDCODE_INQUIRE,
1133 wait_event_interruptible(zd->rxdataq, zd->rxdatas);
1134 if (!zd->rxlen)
1137 if (le16_to_cpu(*(__le16*)&zd->rxdata[2]) != ZD1201_INQ_SCANRESULTS)
1140 for(i=8; i<zd->rxlen; i+=62) {
1143 memcpy(iwe.u.ap_addr.sa_data, zd->rxdata+i+6, 6);
1148 iwe.u.data.length = zd->rxdata[i+16];
1151 &iwe, zd->rxdata+i+18);
1154 if (zd->rxdata[i+14]&0x01)
1162 iwe.u.freq.m = zd->rxdata[i+0];
1170 for (j=0; j<10; j++) if (zd->rxdata[i+50+j]) {
1171 iwe.u.bitrate.value = (zd->rxdata[i+50+j]&0x7f)*500000;
1178 if (zd->rxdata[i+14]&0x10)
1185 iwe.u.qual.qual = zd->rxdata[i+4];
1186 iwe.u.qual.noise= zd->rxdata[i+2]/10-100;
1187 iwe.u.qual.level = (256+zd->rxdata[i+4]*100)/255-100;
1194 zd1201_disable(zd);
1205 struct zd1201 *zd = netdev_priv(dev);
1211 zd->essidlen = data->length;
1212 memset(zd->essid, 0, IW_ESSID_MAX_SIZE+1);
1213 memcpy(zd->essid, essid, data->length);
1214 return zd1201_join(zd, zd->essid, zd->essidlen);
1220 struct zd1201 *zd = netdev_priv(dev);
1222 memcpy(essid, zd->essid, zd->essidlen);
1224 data->length = zd->essidlen;
1241 struct zd1201 *zd = netdev_priv(dev);
1264 err = zd1201_setconfig16(zd, ZD1201_RID_TXRATECNTL, rate);
1268 return zd1201_mac_reset(zd);
1274 struct zd1201 *zd = netdev_priv(dev);
1278 err = zd1201_getconfig16(zd, ZD1201_RID_CURRENTTXRATE, &rate);
1307 struct zd1201 *zd = netdev_priv(dev);
1318 err = zd1201_setconfig16(zd, ZD1201_RID_CNFRTSTHRESHOLD, val);
1321 return zd1201_mac_reset(zd);
1327 struct zd1201 *zd = netdev_priv(dev);
1331 err = zd1201_getconfig16(zd, ZD1201_RID_CNFRTSTHRESHOLD, &rtst);
1344 struct zd1201 *zd = netdev_priv(dev);
1356 err = zd1201_setconfig16(zd, ZD1201_RID_CNFFRAGTHRESHOLD, val);
1359 return zd1201_mac_reset(zd);
1365 struct zd1201 *zd = netdev_priv(dev);
1369 err = zd1201_getconfig16(zd, ZD1201_RID_CNFFRAGTHRESHOLD, &fragt);
1394 struct zd1201 *zd = netdev_priv(dev);
1403 err = zd1201_getconfig16(zd,ZD1201_RID_CNFDEFAULTKEYID,&i);
1407 err = zd1201_setconfig16(zd, ZD1201_RID_CNFDEFAULTKEYID, i);
1416 err = zd1201_setconfig(zd, rid, key, erq->length, 1);
1419 zd->encode_keylen[i] = erq->length;
1420 memcpy(zd->encode_keys[i], key, erq->length);
1425 zd->encode_enabled = 1;
1427 zd->encode_enabled = 0;
1430 zd->encode_restricted = 1;
1432 zd->encode_restricted = 0;
1433 err = zd1201_setconfig16(zd, ZD1201_RID_CNFWEBFLAGS, i);
1437 if (zd->encode_enabled)
1441 err = zd1201_setconfig16(zd, ZD1201_RID_CNFAUTHENTICATION, i);
1445 return zd1201_mac_reset(zd);
1451 struct zd1201 *zd = netdev_priv(dev);
1455 if (zd->encode_enabled)
1459 if (zd->encode_restricted)
1466 err = zd1201_getconfig16(zd, ZD1201_RID_CNFDEFAULTKEYID, &i);
1475 erq->length = zd->encode_keylen[i];
1476 memcpy(key, zd->encode_keys[i], erq->length);
1484 struct zd1201 *zd = netdev_priv(dev);
1492 err = zd1201_setconfig16(zd,
1499 err = zd1201_getconfig16(zd,
1508 err = zd1201_setconfig16(zd, ZD1201_RID_CNFPMEPS,
1517 return zd1201_setconfig16(zd, ZD1201_RID_CNFPMENABLED, enabled);
1523 struct zd1201 *zd = netdev_priv(dev);
1527 err = zd1201_getconfig16(zd, ZD1201_RID_CNFPMENABLED, &enabled);
1530 err = zd1201_getconfig16(zd, ZD1201_RID_CNFPMEPS, &level);
1533 err = zd1201_getconfig16(zd, ZD1201_RID_CNFMAXSLEEPDURATION, &duration);
1610 struct zd1201 *zd = netdev_priv(dev);
1612 if (!zd->ap)
1615 return zd1201_setconfig16(zd, ZD1201_RID_CNFHOSTAUTH, rrq->value);
1621 struct zd1201 *zd = netdev_priv(dev);
1625 if (!zd->ap)
1628 err = zd1201_getconfig16(zd, ZD1201_RID_CNFHOSTAUTH, &hostauth);
1640 struct zd1201 *zd = netdev_priv(dev);
1643 if (!zd->ap)
1650 return zd1201_setconfig(zd, ZD1201_RID_AUTHENTICATESTA, buffer, 10, 1);
1656 struct zd1201 *zd = netdev_priv(dev);
1659 if (!zd->ap)
1662 err = zd1201_setconfig16(zd, ZD1201_RID_CNFMAXASSOCSTATIONS, rrq->value);
1671 struct zd1201 *zd = netdev_priv(dev);
1675 if (!zd->ap)
1678 err = zd1201_getconfig16(zd, ZD1201_RID_CNFMAXASSOCSTATIONS, &maxassoc);
1733 struct zd1201 *zd;
1742 dev = alloc_etherdev(sizeof(*zd));
1745 zd = netdev_priv(dev);
1746 zd->dev = dev;
1748 zd->ap = ap;
1749 zd->usb = usb;
1750 zd->removed = 0;
1751 init_waitqueue_head(&zd->rxdataq);
1752 INIT_HLIST_HEAD(&zd->fraglist);
1754 err = zd1201_fw_upload(usb, zd->ap);
1760 zd->endp_in = 1;
1761 zd->endp_out = 1;
1762 zd->endp_out2 = 2;
1763 zd->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
1764 zd->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
1765 if (!zd->rx_urb || !zd->tx_urb)
1769 err = zd1201_drvr_start(zd);
1773 err = zd1201_setconfig16(zd, ZD1201_RID_CNFMAXDATALEN, 2312);
1777 err = zd1201_setconfig16(zd, ZD1201_RID_TXRATECNTL,
1787 err = zd1201_getconfig(zd, ZD1201_RID_CNFOWNMACADDR,
1792 /* Set wildcard essid to match zd->essid */
1794 err = zd1201_setconfig(zd, ZD1201_RID_CNFDESIREDSSID, buf,
1799 if (zd->ap)
1803 err = zd1201_setconfig16(zd, ZD1201_RID_CNFPORTTYPE, porttype);
1815 usb_set_intfdata(interface, zd);
1816 zd1201_enable(zd); /* zd1201 likes to startup enabled, */
1817 zd1201_disable(zd); /* interfering with all the wifis in range */
1822 zd1201_docmd(zd, ZD1201_CMDCODE_INIT, 0, 0, 0);
1824 usb_free_urb(zd->tx_urb);
1825 usb_free_urb(zd->rx_urb);
1832 struct zd1201 *zd=(struct zd1201 *)usb_get_intfdata(interface);
1836 if (!zd)
1840 hlist_for_each_entry_safe(frag, node, node2, &zd->fraglist, fnode) {
1846 if (zd->tx_urb) {
1847 usb_kill_urb(zd->tx_urb);
1848 usb_free_urb(zd->tx_urb);
1850 if (zd->rx_urb) {
1851 usb_kill_urb(zd->rx_urb);
1852 usb_free_urb(zd->rx_urb);
1855 if (zd->dev) {
1856 unregister_netdev(zd->dev);
1857 free_netdev(zd->dev);
1866 struct zd1201 *zd = usb_get_intfdata(interface);
1868 netif_device_detach(zd->dev);
1870 zd->was_enabled = zd->mac_enabled;
1872 if (zd->was_enabled)
1873 return zd1201_disable(zd);
1880 struct zd1201 *zd = usb_get_intfdata(interface);
1882 if (!zd || !zd->dev)
1885 netif_device_attach(zd->dev);
1887 if (zd->was_enabled)
1888 return zd1201_enable(zd);