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 <net/iw_handler.h> 21#include <linux/string.h> 22#include <linux/if_arp.h> 23#include <linux/firmware.h> 24#include <net/ieee80211.h> 25#include "zd1201.h" 26 27static 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 36static int ap; /* Are we an AP or a normal station? */ 37 38#define ZD1201_VERSION "0.15" 39 40MODULE_AUTHOR("Jeroen Vreeken <pe1rxq@amsat.org>"); 41MODULE_DESCRIPTION("Driver for ZyDAS ZD1201 based USB Wireless adapters"); 42MODULE_VERSION(ZD1201_VERSION); 43MODULE_LICENSE("GPL"); 44module_param(ap, int, 0); 45MODULE_PARM_DESC(ap, "If non-zero Access Point firmware will be loaded"); 46MODULE_DEVICE_TABLE(usb, zd1201_table); 47 48 49static int zd1201_fw_upload(struct usb_device *dev, int apfw) 50{ 51 const struct firmware *fw_entry; 52 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; 109exit: 110 kfree(buf); 111 release_firmware(fw_entry); 112 return err; 113} 114 115static void zd1201_usbfree(struct urb *urb) 116{ 117 struct zd1201 *zd = urb->context; 118 119 switch(urb->status) { 120 case -EILSEQ: 121 case -ENODEV: 122 case -ETIME: 123 case -ENOENT: 124 case -EPIPE: 125 case -EOVERFLOW: 126 case -ESHUTDOWN: 127 dev_warn(&zd->usb->dev, "%s: urb failed: %d\n", 128 zd->dev->name, urb->status); 129 } 130 131 kfree(urb->transfer_buffer); 132 usb_free_urb(urb); 133 return; 134} 135 136/* cmdreq message: 137 u32 type 138 u16 cmd 139 u16 parm0 140 u16 parm1 141 u16 parm2 142 u8 pad[4] 143 144 total: 4 + 2 + 2 + 2 + 2 + 4 = 16 145*/ 146static int zd1201_docmd(struct zd1201 *zd, int cmd, int parm0, 147 int parm1, int parm2) 148{ 149 unsigned char *command; 150 int ret; 151 struct urb *urb; 152 153 command = kmalloc(16, GFP_ATOMIC); 154 if (!command) 155 return -ENOMEM; 156 157 *((__le32*)command) = cpu_to_le32(ZD1201_USB_CMDREQ); 158 *((__le16*)&command[4]) = cpu_to_le16(cmd); 159 *((__le16*)&command[6]) = cpu_to_le16(parm0); 160 *((__le16*)&command[8]) = cpu_to_le16(parm1); 161 *((__le16*)&command[10])= cpu_to_le16(parm2); 162 163 urb = usb_alloc_urb(0, GFP_ATOMIC); 164 if (!urb) { 165 kfree(command); 166 return -ENOMEM; 167 } 168 usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb, zd->endp_out2), 169 command, 16, zd1201_usbfree, zd); 170 ret = usb_submit_urb(urb, GFP_ATOMIC); 171 if (ret) { 172 kfree(command); 173 usb_free_urb(urb); 174 } 175 176 return ret; 177} 178 179/* Callback after sending out a packet */ 180static void zd1201_usbtx(struct urb *urb) 181{ 182 struct zd1201 *zd = urb->context; 183 netif_wake_queue(zd->dev); 184 return; 185} 186 187/* Incoming data */ 188static void zd1201_usbrx(struct urb *urb) 189{ 190 struct zd1201 *zd = urb->context; 191 int free = 0; 192 unsigned char *data = urb->transfer_buffer; 193 struct sk_buff *skb; 194 unsigned char type; 195 196 if (!zd) 197 return; 198 199 switch(urb->status) { 200 case -EILSEQ: 201 case -ENODEV: 202 case -ETIME: 203 case -ENOENT: 204 case -EPIPE: 205 case -EOVERFLOW: 206 case -ESHUTDOWN: 207 dev_warn(&zd->usb->dev, "%s: rx urb failed: %d\n", 208 zd->dev->name, urb->status); 209 free = 1; 210 goto exit; 211 } 212 213 if (urb->status != 0 || urb->actual_length == 0) 214 goto resubmit; 215 216 type = data[0]; 217 if (type == ZD1201_PACKET_EVENTSTAT || type == ZD1201_PACKET_RESOURCE) { 218 memcpy(zd->rxdata, data, urb->actual_length); 219 zd->rxlen = urb->actual_length; 220 zd->rxdatas = 1; 221 wake_up(&zd->rxdataq); 222 } 223 /* Info frame */ 224 if (type == ZD1201_PACKET_INQUIRE) { 225 int i = 0; 226 unsigned short infotype, framelen, copylen; 227 framelen = le16_to_cpu(*(__le16*)&data[4]); 228 infotype = le16_to_cpu(*(__le16*)&data[6]); 229 230 if (infotype == ZD1201_INF_LINKSTATUS) { 231 short linkstatus; 232 233 linkstatus = le16_to_cpu(*(__le16*)&data[8]); 234 switch(linkstatus) { 235 case 1: 236 netif_carrier_on(zd->dev); 237 break; 238 case 2: 239 netif_carrier_off(zd->dev); 240 break; 241 case 3: 242 netif_carrier_off(zd->dev); 243 break; 244 case 4: 245 netif_carrier_on(zd->dev); 246 break; 247 default: 248 netif_carrier_off(zd->dev); 249 } 250 goto resubmit; 251 } 252 if (infotype == ZD1201_INF_ASSOCSTATUS) { 253 short status = le16_to_cpu(*(__le16*)(data+8)); 254 int event; 255 union iwreq_data wrqu; 256 257 switch (status) { 258 case ZD1201_ASSOCSTATUS_STAASSOC: 259 case ZD1201_ASSOCSTATUS_REASSOC: 260 event = IWEVREGISTERED; 261 break; 262 case ZD1201_ASSOCSTATUS_DISASSOC: 263 case ZD1201_ASSOCSTATUS_ASSOCFAIL: 264 case ZD1201_ASSOCSTATUS_AUTHFAIL: 265 default: 266 event = IWEVEXPIRED; 267 } 268 memcpy(wrqu.addr.sa_data, data+10, ETH_ALEN); 269 wrqu.addr.sa_family = ARPHRD_ETHER; 270 271 /* Send event to user space */ 272 wireless_send_event(zd->dev, event, &wrqu, NULL); 273 274 goto resubmit; 275 } 276 if (infotype == ZD1201_INF_AUTHREQ) { 277 union iwreq_data wrqu; 278 279 memcpy(wrqu.addr.sa_data, data+8, ETH_ALEN); 280 wrqu.addr.sa_family = ARPHRD_ETHER; 281 /* There isn't a event that trully fits this request. 282 We assume that userspace will be smart enough to 283 see a new station being expired and sends back a 284 authstation ioctl to authorize it. */ 285 wireless_send_event(zd->dev, IWEVEXPIRED, &wrqu, NULL); 286 goto resubmit; 287 } 288 /* Other infotypes are handled outside this handler */ 289 zd->rxlen = 0; 290 while (i < urb->actual_length) { 291 copylen = le16_to_cpu(*(__le16*)&data[i+2]); 292 /* Sanity check, sometimes we get junk */ 293 if (copylen+zd->rxlen > sizeof(zd->rxdata)) 294 break; 295 memcpy(zd->rxdata+zd->rxlen, data+i+4, copylen); 296 zd->rxlen += copylen; 297 i += 64; 298 } 299 if (i >= urb->actual_length) { 300 zd->rxdatas = 1; 301 wake_up(&zd->rxdataq); 302 } 303 goto resubmit; 304 } 305 /* Actual data */ 306 if (data[urb->actual_length-1] == ZD1201_PACKET_RXDATA) { 307 int datalen = urb->actual_length-1; 308 unsigned short len, fc, seq; 309 struct hlist_node *node; 310 311 len = ntohs(*(__be16 *)&data[datalen-2]); 312 if (len>datalen) 313 len=datalen; 314 fc = le16_to_cpu(*(__le16 *)&data[datalen-16]); 315 seq = le16_to_cpu(*(__le16 *)&data[datalen-24]); 316 317 if (zd->monitor) { 318 if (datalen < 24) 319 goto resubmit; 320 if (!(skb = dev_alloc_skb(datalen+24))) 321 goto resubmit; 322 323 memcpy(skb_put(skb, 2), &data[datalen-16], 2); 324 memcpy(skb_put(skb, 2), &data[datalen-2], 2); 325 memcpy(skb_put(skb, 6), &data[datalen-14], 6); 326 memcpy(skb_put(skb, 6), &data[datalen-22], 6); 327 memcpy(skb_put(skb, 6), &data[datalen-8], 6); 328 memcpy(skb_put(skb, 2), &data[datalen-24], 2); 329 memcpy(skb_put(skb, len), data, len); 330 skb->dev->last_rx = jiffies; 331 skb->protocol = eth_type_trans(skb, zd->dev); 332 zd->stats.rx_packets++; 333 zd->stats.rx_bytes += skb->len; 334 netif_rx(skb); 335 goto resubmit; 336 } 337 338 if ((seq & IEEE80211_SCTL_FRAG) || 339 (fc & IEEE80211_FCTL_MOREFRAGS)) { 340 struct zd1201_frag *frag = NULL; 341 char *ptr; 342 343 if (datalen<14) 344 goto resubmit; 345 if ((seq & IEEE80211_SCTL_FRAG) == 0) { 346 frag = kmalloc(sizeof(*frag), GFP_ATOMIC); 347 if (!frag) 348 goto resubmit; 349 skb = dev_alloc_skb(IEEE80211_DATA_LEN +14+2); 350 if (!skb) { 351 kfree(frag); 352 goto resubmit; 353 } 354 frag->skb = skb; 355 frag->seq = seq & IEEE80211_SCTL_SEQ; 356 skb_reserve(skb, 2); 357 memcpy(skb_put(skb, 12), &data[datalen-14], 12); 358 memcpy(skb_put(skb, 2), &data[6], 2); 359 memcpy(skb_put(skb, len), data+8, len); 360 hlist_add_head(&frag->fnode, &zd->fraglist); 361 goto resubmit; 362 } 363 hlist_for_each_entry(frag, node, &zd->fraglist, fnode) 364 if (frag->seq == (seq&IEEE80211_SCTL_SEQ)) 365 break; 366 if (!frag) 367 goto resubmit; 368 skb = frag->skb; 369 ptr = skb_put(skb, len); 370 if (ptr) 371 memcpy(ptr, data+8, len); 372 if (fc & IEEE80211_FCTL_MOREFRAGS) 373 goto resubmit; 374 hlist_del_init(&frag->fnode); 375 kfree(frag); 376 } else { 377 if (datalen<14) 378 goto resubmit; 379 skb = dev_alloc_skb(len + 14 + 2); 380 if (!skb) 381 goto resubmit; 382 skb_reserve(skb, 2); 383 memcpy(skb_put(skb, 12), &data[datalen-14], 12); 384 memcpy(skb_put(skb, 2), &data[6], 2); 385 memcpy(skb_put(skb, len), data+8, len); 386 } 387 skb->dev->last_rx = jiffies; 388 skb->protocol = eth_type_trans(skb, zd->dev); 389 zd->stats.rx_packets++; 390 zd->stats.rx_bytes += skb->len; 391 netif_rx(skb); 392 } 393resubmit: 394 memset(data, 0, ZD1201_RXSIZE); 395 396 urb->status = 0; 397 urb->dev = zd->usb; 398 if(usb_submit_urb(urb, GFP_ATOMIC)) 399 free = 1; 400 401exit: 402 if (free) { 403 zd->rxlen = 0; 404 zd->rxdatas = 1; 405 wake_up(&zd->rxdataq); 406 kfree(urb->transfer_buffer); 407 } 408 return; 409} 410 411static 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 */ 511static 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; 587err: 588 kfree(request); 589 usb_free_urb(urb); 590 return err; 591} 592 593static 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 605static 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 611static 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 648err_urb: 649 usb_kill_urb(zd->rx_urb); 650 return err; 651err_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 */ 661static 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 678static 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 696static 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 704static 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 746static int zd1201_net_open(struct net_device *dev) 747{ 748 struct zd1201 *zd = (struct zd1201 *)dev->priv; 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 758static 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 */ 784static int zd1201_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) 785{ 786 struct zd1201 *zd = (struct zd1201 *)dev->priv; 787 unsigned char *txbuf = zd->txdata; 788 int txbuflen, pad = 0, err; 789 struct urb *urb = zd->tx_urb; 790 791 if (!zd->mac_enabled || zd->monitor) { 792 zd->stats.tx_dropped++; 793 kfree_skb(skb); 794 return 0; 795 } 796 netif_stop_queue(dev); 797 798 txbuflen = skb->len + 8 + 1; 799 if (txbuflen%64 == 0) { 800 pad = 1; 801 txbuflen++; 802 } 803 txbuf[0] = 0xAA; 804 txbuf[1] = 0xAA; 805 txbuf[2] = 0x03; 806 txbuf[3] = 0x00; /* rfc1042 */ 807 txbuf[4] = 0x00; 808 txbuf[5] = 0x00; 809 810 skb_copy_from_linear_data_offset(skb, 12, txbuf + 6, skb->len - 12); 811 if (pad) 812 txbuf[skb->len-12+6]=0; 813 skb_copy_from_linear_data(skb, txbuf + skb->len - 12 + 6 + pad, 12); 814 *(__be16*)&txbuf[skb->len+6+pad] = htons(skb->len-12+6); 815 txbuf[txbuflen-1] = 0; 816 817 usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb, zd->endp_out), 818 txbuf, txbuflen, zd1201_usbtx, zd); 819 820 err = usb_submit_urb(zd->tx_urb, GFP_ATOMIC); 821 if (err) { 822 zd->stats.tx_errors++; 823 netif_start_queue(dev); 824 return err; 825 } 826 zd->stats.tx_packets++; 827 zd->stats.tx_bytes += skb->len; 828 dev->trans_start = jiffies; 829 kfree_skb(skb); 830 831 return 0; 832} 833 834static void zd1201_tx_timeout(struct net_device *dev) 835{ 836 struct zd1201 *zd = (struct zd1201 *)dev->priv; 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 zd->stats.tx_errors++; 844 /* Restart the timeout to quiet the watchdog: */ 845 dev->trans_start = jiffies; 846} 847 848static int zd1201_set_mac_address(struct net_device *dev, void *p) 849{ 850 struct sockaddr *addr = p; 851 struct zd1201 *zd = (struct zd1201 *)dev->priv; 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 866static struct net_device_stats *zd1201_get_stats(struct net_device *dev) 867{ 868 struct zd1201 *zd = (struct zd1201 *)dev->priv; 869 870 return &zd->stats; 871} 872 873static struct iw_statistics *zd1201_get_wireless_stats(struct net_device *dev) 874{ 875 struct zd1201 *zd = (struct zd1201 *)dev->priv; 876 877 return &zd->iwstats; 878} 879 880static void zd1201_set_multicast(struct net_device *dev) 881{ 882 struct zd1201 *zd = (struct zd1201 *)dev->priv; 883 struct dev_mc_list *mc = dev->mc_list; 884 unsigned char reqbuf[ETH_ALEN*ZD1201_MAXMULTI]; 885 int i; 886 887 if (dev->mc_count > ZD1201_MAXMULTI) 888 return; 889 890 for (i=0; i<dev->mc_count; i++) { 891 memcpy(reqbuf+i*ETH_ALEN, mc->dmi_addr, ETH_ALEN); 892 mc = mc->next; 893 } 894 zd1201_setconfig(zd, ZD1201_RID_CNFGROUPADDRESS, reqbuf, 895 dev->mc_count*ETH_ALEN, 0); 896 897} 898 899static int zd1201_config_commit(struct net_device *dev, 900 struct iw_request_info *info, struct iw_point *data, char *essid) 901{ 902 struct zd1201 *zd = (struct zd1201 *)dev->priv; 903 904 return zd1201_mac_reset(zd); 905} 906 907static int zd1201_get_name(struct net_device *dev, 908 struct iw_request_info *info, char *name, char *extra) 909{ 910 strcpy(name, "IEEE 802.11b"); 911 return 0; 912} 913 914static int zd1201_set_freq(struct net_device *dev, 915 struct iw_request_info *info, struct iw_freq *freq, char *extra) 916{ 917 struct zd1201 *zd = (struct zd1201 *)dev->priv; 918 short channel = 0; 919 int err; 920 921 if (freq->e == 0) 922 channel = freq->m; 923 else { 924 if (freq->m >= 2482) 925 channel = 14; 926 if (freq->m >= 2407) 927 channel = (freq->m-2407)/5; 928 } 929 930 err = zd1201_setconfig16(zd, ZD1201_RID_CNFOWNCHANNEL, channel); 931 if (err) 932 return err; 933 934 zd1201_mac_reset(zd); 935 936 return 0; 937} 938 939static int zd1201_get_freq(struct net_device *dev, 940 struct iw_request_info *info, struct iw_freq *freq, char *extra) 941{ 942 struct zd1201 *zd = (struct zd1201 *)dev->priv; 943 short channel; 944 int err; 945 946 err = zd1201_getconfig16(zd, ZD1201_RID_CNFOWNCHANNEL, &channel); 947 if (err) 948 return err; 949 freq->e = 0; 950 freq->m = channel; 951 952 return 0; 953} 954 955static int zd1201_set_mode(struct net_device *dev, 956 struct iw_request_info *info, __u32 *mode, char *extra) 957{ 958 struct zd1201 *zd = (struct zd1201 *)dev->priv; 959 short porttype, monitor = 0; 960 unsigned char buffer[IW_ESSID_MAX_SIZE+2]; 961 int err; 962 963 if (zd->ap) { 964 if (*mode != IW_MODE_MASTER) 965 return -EINVAL; 966 return 0; 967 } 968 969 err = zd1201_setconfig16(zd, ZD1201_RID_PROMISCUOUSMODE, 0); 970 if (err) 971 return err; 972 zd->dev->type = ARPHRD_ETHER; 973 switch(*mode) { 974 case IW_MODE_MONITOR: 975 monitor = 1; 976 zd->dev->type = ARPHRD_IEEE80211; 977 /* Make sure we are no longer associated with by 978 setting an 'impossible' essid. 979 (otherwise we mess up firmware) 980 */ 981 zd1201_join(zd, "\0-*#\0", 5); 982 /* Put port in pIBSS */ 983 case 8: /* No pseudo-IBSS in wireless extensions (yet) */ 984 porttype = ZD1201_PORTTYPE_PSEUDOIBSS; 985 break; 986 case IW_MODE_ADHOC: 987 porttype = ZD1201_PORTTYPE_IBSS; 988 break; 989 case IW_MODE_INFRA: 990 porttype = ZD1201_PORTTYPE_BSS; 991 break; 992 default: 993 return -EINVAL; 994 } 995 996 err = zd1201_setconfig16(zd, ZD1201_RID_CNFPORTTYPE, porttype); 997 if (err) 998 return err; 999 if (zd->monitor && !monitor) { 1000 zd1201_disable(zd); 1001 *(__le16 *)buffer = cpu_to_le16(zd->essidlen); 1002 memcpy(buffer+2, zd->essid, zd->essidlen); 1003 err = zd1201_setconfig(zd, ZD1201_RID_CNFDESIREDSSID, 1004 buffer, IW_ESSID_MAX_SIZE+2, 1); 1005 if (err) 1006 return err; 1007 } 1008 zd->monitor = monitor; 1009 /* If monitor mode is set we don't actually turn it on here since it 1010 * is done during mac reset anyway (see zd1201_mac_enable). 1011 */ 1012 zd1201_mac_reset(zd); 1013 1014 return 0; 1015} 1016 1017static int zd1201_get_mode(struct net_device *dev, 1018 struct iw_request_info *info, __u32 *mode, char *extra) 1019{ 1020 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1021 short porttype; 1022 int err; 1023 1024 err = zd1201_getconfig16(zd, ZD1201_RID_CNFPORTTYPE, &porttype); 1025 if (err) 1026 return err; 1027 switch(porttype) { 1028 case ZD1201_PORTTYPE_IBSS: 1029 *mode = IW_MODE_ADHOC; 1030 break; 1031 case ZD1201_PORTTYPE_BSS: 1032 *mode = IW_MODE_INFRA; 1033 break; 1034 case ZD1201_PORTTYPE_WDS: 1035 *mode = IW_MODE_REPEAT; 1036 break; 1037 case ZD1201_PORTTYPE_PSEUDOIBSS: 1038 *mode = 8;/* No Pseudo-IBSS... */ 1039 break; 1040 case ZD1201_PORTTYPE_AP: 1041 *mode = IW_MODE_MASTER; 1042 break; 1043 default: 1044 dev_dbg(&zd->usb->dev, "Unknown porttype: %d\n", 1045 porttype); 1046 *mode = IW_MODE_AUTO; 1047 } 1048 if (zd->monitor) 1049 *mode = IW_MODE_MONITOR; 1050 1051 return 0; 1052} 1053 1054static int zd1201_get_range(struct net_device *dev, 1055 struct iw_request_info *info, struct iw_point *wrq, char *extra) 1056{ 1057 struct iw_range *range = (struct iw_range *)extra; 1058 1059 wrq->length = sizeof(struct iw_range); 1060 memset(range, 0, sizeof(struct iw_range)); 1061 range->we_version_compiled = WIRELESS_EXT; 1062 range->we_version_source = WIRELESS_EXT; 1063 1064 range->max_qual.qual = 128; 1065 range->max_qual.level = 128; 1066 range->max_qual.noise = 128; 1067 range->max_qual.updated = 7; 1068 1069 range->encoding_size[0] = 5; 1070 range->encoding_size[1] = 13; 1071 range->num_encoding_sizes = 2; 1072 range->max_encoding_tokens = ZD1201_NUMKEYS; 1073 1074 range->num_bitrates = 4; 1075 range->bitrate[0] = 1000000; 1076 range->bitrate[1] = 2000000; 1077 range->bitrate[2] = 5500000; 1078 range->bitrate[3] = 11000000; 1079 1080 range->min_rts = 0; 1081 range->min_frag = ZD1201_FRAGMIN; 1082 range->max_rts = ZD1201_RTSMAX; 1083 range->min_frag = ZD1201_FRAGMAX; 1084 1085 return 0; 1086} 1087 1088/* Little bit of magic here: we only get the quality if we poll 1089 * for it, and we never get an actual request to trigger such 1090 * a poll. Therefore we 'assume' that the user will soon ask for 1091 * the stats after asking the bssid. 1092 */ 1093static int zd1201_get_wap(struct net_device *dev, 1094 struct iw_request_info *info, struct sockaddr *ap_addr, char *extra) 1095{ 1096 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1097 unsigned char buffer[6]; 1098 1099 if (!zd1201_getconfig(zd, ZD1201_RID_COMMSQUALITY, buffer, 6)) { 1100 /* Unfortunately the quality and noise reported is useless. 1101 they seem to be accumulators that increase until you 1102 read them, unless we poll on a fixed interval we can't 1103 use them 1104 */ 1105 /*zd->iwstats.qual.qual = le16_to_cpu(((__le16 *)buffer)[0]);*/ 1106 zd->iwstats.qual.level = le16_to_cpu(((__le16 *)buffer)[1]); 1107 /*zd->iwstats.qual.noise = le16_to_cpu(((__le16 *)buffer)[2]);*/ 1108 zd->iwstats.qual.updated = 2; 1109 } 1110 1111 return zd1201_getconfig(zd, ZD1201_RID_CURRENTBSSID, ap_addr->sa_data, 6); 1112} 1113 1114static int zd1201_set_scan(struct net_device *dev, 1115 struct iw_request_info *info, struct iw_point *srq, char *extra) 1116{ 1117 /* We do everything in get_scan */ 1118 return 0; 1119} 1120 1121static int zd1201_get_scan(struct net_device *dev, 1122 struct iw_request_info *info, struct iw_point *srq, char *extra) 1123{ 1124 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1125 int err, i, j, enabled_save; 1126 struct iw_event iwe; 1127 char *cev = extra; 1128 char *end_buf = extra + IW_SCAN_MAX_DATA; 1129 1130 /* No scanning in AP mode */ 1131 if (zd->ap) 1132 return -EOPNOTSUPP; 1133 1134 /* Scan doesn't seem to work if disabled */ 1135 enabled_save = zd->mac_enabled; 1136 zd1201_enable(zd); 1137 1138 zd->rxdatas = 0; 1139 err = zd1201_docmd(zd, ZD1201_CMDCODE_INQUIRE, 1140 ZD1201_INQ_SCANRESULTS, 0, 0); 1141 if (err) 1142 return err; 1143 1144 wait_event_interruptible(zd->rxdataq, zd->rxdatas); 1145 if (!zd->rxlen) 1146 return -EIO; 1147 1148 if (le16_to_cpu(*(__le16*)&zd->rxdata[2]) != ZD1201_INQ_SCANRESULTS) 1149 return -EIO; 1150 1151 for(i=8; i<zd->rxlen; i+=62) { 1152 iwe.cmd = SIOCGIWAP; 1153 iwe.u.ap_addr.sa_family = ARPHRD_ETHER; 1154 memcpy(iwe.u.ap_addr.sa_data, zd->rxdata+i+6, 6); 1155 cev = iwe_stream_add_event(cev, end_buf, &iwe, IW_EV_ADDR_LEN); 1156 1157 iwe.cmd = SIOCGIWESSID; 1158 iwe.u.data.length = zd->rxdata[i+16]; 1159 iwe.u.data.flags = 1; 1160 cev = iwe_stream_add_point(cev, end_buf, &iwe, zd->rxdata+i+18); 1161 1162 iwe.cmd = SIOCGIWMODE; 1163 if (zd->rxdata[i+14]&0x01) 1164 iwe.u.mode = IW_MODE_MASTER; 1165 else 1166 iwe.u.mode = IW_MODE_ADHOC; 1167 cev = iwe_stream_add_event(cev, end_buf, &iwe, IW_EV_UINT_LEN); 1168 1169 iwe.cmd = SIOCGIWFREQ; 1170 iwe.u.freq.m = zd->rxdata[i+0]; 1171 iwe.u.freq.e = 0; 1172 cev = iwe_stream_add_event(cev, end_buf, &iwe, IW_EV_FREQ_LEN); 1173 1174 iwe.cmd = SIOCGIWRATE; 1175 iwe.u.bitrate.fixed = 0; 1176 iwe.u.bitrate.disabled = 0; 1177 for (j=0; j<10; j++) if (zd->rxdata[i+50+j]) { 1178 iwe.u.bitrate.value = (zd->rxdata[i+50+j]&0x7f)*500000; 1179 cev=iwe_stream_add_event(cev, end_buf, &iwe, 1180 IW_EV_PARAM_LEN); 1181 } 1182 1183 iwe.cmd = SIOCGIWENCODE; 1184 iwe.u.data.length = 0; 1185 if (zd->rxdata[i+14]&0x10) 1186 iwe.u.data.flags = IW_ENCODE_ENABLED; 1187 else 1188 iwe.u.data.flags = IW_ENCODE_DISABLED; 1189 cev = iwe_stream_add_point(cev, end_buf, &iwe, NULL); 1190 1191 iwe.cmd = IWEVQUAL; 1192 iwe.u.qual.qual = zd->rxdata[i+4]; 1193 iwe.u.qual.noise= zd->rxdata[i+2]/10-100; 1194 iwe.u.qual.level = (256+zd->rxdata[i+4]*100)/255-100; 1195 iwe.u.qual.updated = 7; 1196 cev = iwe_stream_add_event(cev, end_buf, &iwe, IW_EV_QUAL_LEN); 1197 } 1198 1199 if (!enabled_save) 1200 zd1201_disable(zd); 1201 1202 srq->length = cev - extra; 1203 srq->flags = 0; 1204 1205 return 0; 1206} 1207 1208static int zd1201_set_essid(struct net_device *dev, 1209 struct iw_request_info *info, struct iw_point *data, char *essid) 1210{ 1211 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1212 1213 if (data->length > IW_ESSID_MAX_SIZE) 1214 return -EINVAL; 1215 if (data->length < 1) 1216 data->length = 1; 1217 zd->essidlen = data->length; 1218 memset(zd->essid, 0, IW_ESSID_MAX_SIZE+1); 1219 memcpy(zd->essid, essid, data->length); 1220 return zd1201_join(zd, zd->essid, zd->essidlen); 1221} 1222 1223static int zd1201_get_essid(struct net_device *dev, 1224 struct iw_request_info *info, struct iw_point *data, char *essid) 1225{ 1226 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1227 1228 memcpy(essid, zd->essid, zd->essidlen); 1229 data->flags = 1; 1230 data->length = zd->essidlen; 1231 1232 return 0; 1233} 1234 1235static int zd1201_get_nick(struct net_device *dev, struct iw_request_info *info, 1236 struct iw_point *data, char *nick) 1237{ 1238 strcpy(nick, "zd1201"); 1239 data->flags = 1; 1240 data->length = strlen(nick); 1241 return 0; 1242} 1243 1244static int zd1201_set_rate(struct net_device *dev, 1245 struct iw_request_info *info, struct iw_param *rrq, char *extra) 1246{ 1247 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1248 short rate; 1249 int err; 1250 1251 switch (rrq->value) { 1252 case 1000000: 1253 rate = ZD1201_RATEB1; 1254 break; 1255 case 2000000: 1256 rate = ZD1201_RATEB2; 1257 break; 1258 case 5500000: 1259 rate = ZD1201_RATEB5; 1260 break; 1261 case 11000000: 1262 default: 1263 rate = ZD1201_RATEB11; 1264 break; 1265 } 1266 if (!rrq->fixed) { /* Also enable all lower bitrates */ 1267 rate |= rate-1; 1268 } 1269 1270 err = zd1201_setconfig16(zd, ZD1201_RID_TXRATECNTL, rate); 1271 if (err) 1272 return err; 1273 1274 return zd1201_mac_reset(zd); 1275} 1276 1277static int zd1201_get_rate(struct net_device *dev, 1278 struct iw_request_info *info, struct iw_param *rrq, char *extra) 1279{ 1280 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1281 short rate; 1282 int err; 1283 1284 err = zd1201_getconfig16(zd, ZD1201_RID_CURRENTTXRATE, &rate); 1285 if (err) 1286 return err; 1287 1288 switch(rate) { 1289 case 1: 1290 rrq->value = 1000000; 1291 break; 1292 case 2: 1293 rrq->value = 2000000; 1294 break; 1295 case 5: 1296 rrq->value = 5500000; 1297 break; 1298 case 11: 1299 rrq->value = 11000000; 1300 break; 1301 default: 1302 rrq->value = 0; 1303 } 1304 rrq->fixed = 0; 1305 rrq->disabled = 0; 1306 1307 return 0; 1308} 1309 1310static int zd1201_set_rts(struct net_device *dev, struct iw_request_info *info, 1311 struct iw_param *rts, char *extra) 1312{ 1313 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1314 int err; 1315 short val = rts->value; 1316 1317 if (rts->disabled || !rts->fixed) 1318 val = ZD1201_RTSMAX; 1319 if (val > ZD1201_RTSMAX) 1320 return -EINVAL; 1321 if (val < 0) 1322 return -EINVAL; 1323 1324 err = zd1201_setconfig16(zd, ZD1201_RID_CNFRTSTHRESHOLD, val); 1325 if (err) 1326 return err; 1327 return zd1201_mac_reset(zd); 1328} 1329 1330static int zd1201_get_rts(struct net_device *dev, struct iw_request_info *info, 1331 struct iw_param *rts, char *extra) 1332{ 1333 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1334 short rtst; 1335 int err; 1336 1337 err = zd1201_getconfig16(zd, ZD1201_RID_CNFRTSTHRESHOLD, &rtst); 1338 if (err) 1339 return err; 1340 rts->value = rtst; 1341 rts->disabled = (rts->value == ZD1201_RTSMAX); 1342 rts->fixed = 1; 1343 1344 return 0; 1345} 1346 1347static int zd1201_set_frag(struct net_device *dev, struct iw_request_info *info, 1348 struct iw_param *frag, char *extra) 1349{ 1350 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1351 int err; 1352 short val = frag->value; 1353 1354 if (frag->disabled || !frag->fixed) 1355 val = ZD1201_FRAGMAX; 1356 if (val > ZD1201_FRAGMAX) 1357 return -EINVAL; 1358 if (val < ZD1201_FRAGMIN) 1359 return -EINVAL; 1360 if (val & 1) 1361 return -EINVAL; 1362 err = zd1201_setconfig16(zd, ZD1201_RID_CNFFRAGTHRESHOLD, val); 1363 if (err) 1364 return err; 1365 return zd1201_mac_reset(zd); 1366} 1367 1368static int zd1201_get_frag(struct net_device *dev, struct iw_request_info *info, 1369 struct iw_param *frag, char *extra) 1370{ 1371 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1372 short fragt; 1373 int err; 1374 1375 err = zd1201_getconfig16(zd, ZD1201_RID_CNFFRAGTHRESHOLD, &fragt); 1376 if (err) 1377 return err; 1378 frag->value = fragt; 1379 frag->disabled = (frag->value == ZD1201_FRAGMAX); 1380 frag->fixed = 1; 1381 1382 return 0; 1383} 1384 1385static int zd1201_set_retry(struct net_device *dev, 1386 struct iw_request_info *info, struct iw_param *rrq, char *extra) 1387{ 1388 return 0; 1389} 1390 1391static int zd1201_get_retry(struct net_device *dev, 1392 struct iw_request_info *info, struct iw_param *rrq, char *extra) 1393{ 1394 return 0; 1395} 1396 1397static int zd1201_set_encode(struct net_device *dev, 1398 struct iw_request_info *info, struct iw_point *erq, char *key) 1399{ 1400 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1401 short i; 1402 int err, rid; 1403 1404 if (erq->length > ZD1201_MAXKEYLEN) 1405 return -EINVAL; 1406 1407 i = (erq->flags & IW_ENCODE_INDEX)-1; 1408 if (i == -1) { 1409 err = zd1201_getconfig16(zd,ZD1201_RID_CNFDEFAULTKEYID,&i); 1410 if (err) 1411 return err; 1412 } else { 1413 err = zd1201_setconfig16(zd, ZD1201_RID_CNFDEFAULTKEYID, i); 1414 if (err) 1415 return err; 1416 } 1417 1418 if (i < 0 || i >= ZD1201_NUMKEYS) 1419 return -EINVAL; 1420 1421 rid = ZD1201_RID_CNFDEFAULTKEY0 + i; 1422 err = zd1201_setconfig(zd, rid, key, erq->length, 1); 1423 if (err) 1424 return err; 1425 zd->encode_keylen[i] = erq->length; 1426 memcpy(zd->encode_keys[i], key, erq->length); 1427 1428 i=0; 1429 if (!(erq->flags & IW_ENCODE_DISABLED & IW_ENCODE_MODE)) { 1430 i |= 0x01; 1431 zd->encode_enabled = 1; 1432 } else 1433 zd->encode_enabled = 0; 1434 if (erq->flags & IW_ENCODE_RESTRICTED & IW_ENCODE_MODE) { 1435 i |= 0x02; 1436 zd->encode_restricted = 1; 1437 } else 1438 zd->encode_restricted = 0; 1439 err = zd1201_setconfig16(zd, ZD1201_RID_CNFWEBFLAGS, i); 1440 if (err) 1441 return err; 1442 1443 if (zd->encode_enabled) 1444 i = ZD1201_CNFAUTHENTICATION_SHAREDKEY; 1445 else 1446 i = ZD1201_CNFAUTHENTICATION_OPENSYSTEM; 1447 err = zd1201_setconfig16(zd, ZD1201_RID_CNFAUTHENTICATION, i); 1448 if (err) 1449 return err; 1450 1451 return zd1201_mac_reset(zd); 1452} 1453 1454static int zd1201_get_encode(struct net_device *dev, 1455 struct iw_request_info *info, struct iw_point *erq, char *key) 1456{ 1457 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1458 short i; 1459 int err; 1460 1461 if (zd->encode_enabled) 1462 erq->flags = IW_ENCODE_ENABLED; 1463 else 1464 erq->flags = IW_ENCODE_DISABLED; 1465 if (zd->encode_restricted) 1466 erq->flags |= IW_ENCODE_RESTRICTED; 1467 else 1468 erq->flags |= IW_ENCODE_OPEN; 1469 1470 i = (erq->flags & IW_ENCODE_INDEX) -1; 1471 if (i == -1) { 1472 err = zd1201_getconfig16(zd, ZD1201_RID_CNFDEFAULTKEYID, &i); 1473 if (err) 1474 return err; 1475 } 1476 if (i<0 || i>= ZD1201_NUMKEYS) 1477 return -EINVAL; 1478 1479 erq->flags |= i+1; 1480 1481 erq->length = zd->encode_keylen[i]; 1482 memcpy(key, zd->encode_keys[i], erq->length); 1483 1484 return 0; 1485} 1486 1487static int zd1201_set_power(struct net_device *dev, 1488 struct iw_request_info *info, struct iw_param *vwrq, char *extra) 1489{ 1490 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1491 short enabled, duration, level; 1492 int err; 1493 1494 enabled = vwrq->disabled ? 0 : 1; 1495 if (enabled) { 1496 if (vwrq->flags & IW_POWER_PERIOD) { 1497 duration = vwrq->value; 1498 err = zd1201_setconfig16(zd, 1499 ZD1201_RID_CNFMAXSLEEPDURATION, duration); 1500 if (err) 1501 return err; 1502 goto out; 1503 } 1504 if (vwrq->flags & IW_POWER_TIMEOUT) { 1505 err = zd1201_getconfig16(zd, 1506 ZD1201_RID_CNFMAXSLEEPDURATION, &duration); 1507 if (err) 1508 return err; 1509 level = vwrq->value * 4 / duration; 1510 if (level > 4) 1511 level = 4; 1512 if (level < 0) 1513 level = 0; 1514 err = zd1201_setconfig16(zd, ZD1201_RID_CNFPMEPS, 1515 level); 1516 if (err) 1517 return err; 1518 goto out; 1519 } 1520 return -EINVAL; 1521 } 1522out: 1523 return zd1201_setconfig16(zd, ZD1201_RID_CNFPMENABLED, enabled); 1524} 1525 1526static int zd1201_get_power(struct net_device *dev, 1527 struct iw_request_info *info, struct iw_param *vwrq, char *extra) 1528{ 1529 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1530 short enabled, level, duration; 1531 int err; 1532 1533 err = zd1201_getconfig16(zd, ZD1201_RID_CNFPMENABLED, &enabled); 1534 if (err) 1535 return err; 1536 err = zd1201_getconfig16(zd, ZD1201_RID_CNFPMEPS, &level); 1537 if (err) 1538 return err; 1539 err = zd1201_getconfig16(zd, ZD1201_RID_CNFMAXSLEEPDURATION, &duration); 1540 if (err) 1541 return err; 1542 vwrq->disabled = enabled ? 0 : 1; 1543 if (vwrq->flags & IW_POWER_TYPE) { 1544 if (vwrq->flags & IW_POWER_PERIOD) { 1545 vwrq->value = duration; 1546 vwrq->flags = IW_POWER_PERIOD; 1547 } else { 1548 vwrq->value = duration * level / 4; 1549 vwrq->flags = IW_POWER_TIMEOUT; 1550 } 1551 } 1552 if (vwrq->flags & IW_POWER_MODE) { 1553 if (enabled && level) 1554 vwrq->flags = IW_POWER_UNICAST_R; 1555 else 1556 vwrq->flags = IW_POWER_ALL_R; 1557 } 1558 1559 return 0; 1560} 1561 1562 1563static const iw_handler zd1201_iw_handler[] = 1564{ 1565 (iw_handler) zd1201_config_commit, /* SIOCSIWCOMMIT */ 1566 (iw_handler) zd1201_get_name, /* SIOCGIWNAME */ 1567 (iw_handler) NULL, /* SIOCSIWNWID */ 1568 (iw_handler) NULL, /* SIOCGIWNWID */ 1569 (iw_handler) zd1201_set_freq, /* SIOCSIWFREQ */ 1570 (iw_handler) zd1201_get_freq, /* SIOCGIWFREQ */ 1571 (iw_handler) zd1201_set_mode, /* SIOCSIWMODE */ 1572 (iw_handler) zd1201_get_mode, /* SIOCGIWMODE */ 1573 (iw_handler) NULL, /* SIOCSIWSENS */ 1574 (iw_handler) NULL, /* SIOCGIWSENS */ 1575 (iw_handler) NULL, /* SIOCSIWRANGE */ 1576 (iw_handler) zd1201_get_range, /* SIOCGIWRANGE */ 1577 (iw_handler) NULL, /* SIOCSIWPRIV */ 1578 (iw_handler) NULL, /* SIOCGIWPRIV */ 1579 (iw_handler) NULL, /* SIOCSIWSTATS */ 1580 (iw_handler) NULL, /* SIOCGIWSTATS */ 1581 (iw_handler) NULL, /* SIOCSIWSPY */ 1582 (iw_handler) NULL, /* SIOCGIWSPY */ 1583 (iw_handler) NULL, /* -- hole -- */ 1584 (iw_handler) NULL, /* -- hole -- */ 1585 (iw_handler) NULL/*zd1201_set_wap*/, /* SIOCSIWAP */ 1586 (iw_handler) zd1201_get_wap, /* SIOCGIWAP */ 1587 (iw_handler) NULL, /* -- hole -- */ 1588 (iw_handler) NULL, /* SIOCGIWAPLIST */ 1589 (iw_handler) zd1201_set_scan, /* SIOCSIWSCAN */ 1590 (iw_handler) zd1201_get_scan, /* SIOCGIWSCAN */ 1591 (iw_handler) zd1201_set_essid, /* SIOCSIWESSID */ 1592 (iw_handler) zd1201_get_essid, /* SIOCGIWESSID */ 1593 (iw_handler) NULL, /* SIOCSIWNICKN */ 1594 (iw_handler) zd1201_get_nick, /* SIOCGIWNICKN */ 1595 (iw_handler) NULL, /* -- hole -- */ 1596 (iw_handler) NULL, /* -- hole -- */ 1597 (iw_handler) zd1201_set_rate, /* SIOCSIWRATE */ 1598 (iw_handler) zd1201_get_rate, /* SIOCGIWRATE */ 1599 (iw_handler) zd1201_set_rts, /* SIOCSIWRTS */ 1600 (iw_handler) zd1201_get_rts, /* SIOCGIWRTS */ 1601 (iw_handler) zd1201_set_frag, /* SIOCSIWFRAG */ 1602 (iw_handler) zd1201_get_frag, /* SIOCGIWFRAG */ 1603 (iw_handler) NULL, /* SIOCSIWTXPOW */ 1604 (iw_handler) NULL, /* SIOCGIWTXPOW */ 1605 (iw_handler) zd1201_set_retry, /* SIOCSIWRETRY */ 1606 (iw_handler) zd1201_get_retry, /* SIOCGIWRETRY */ 1607 (iw_handler) zd1201_set_encode, /* SIOCSIWENCODE */ 1608 (iw_handler) zd1201_get_encode, /* SIOCGIWENCODE */ 1609 (iw_handler) zd1201_set_power, /* SIOCSIWPOWER */ 1610 (iw_handler) zd1201_get_power, /* SIOCGIWPOWER */ 1611}; 1612 1613static int zd1201_set_hostauth(struct net_device *dev, 1614 struct iw_request_info *info, struct iw_param *rrq, char *extra) 1615{ 1616 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1617 1618 if (!zd->ap) 1619 return -EOPNOTSUPP; 1620 1621 return zd1201_setconfig16(zd, ZD1201_RID_CNFHOSTAUTH, rrq->value); 1622} 1623 1624static int zd1201_get_hostauth(struct net_device *dev, 1625 struct iw_request_info *info, struct iw_param *rrq, char *extra) 1626{ 1627 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1628 short hostauth; 1629 int err; 1630 1631 if (!zd->ap) 1632 return -EOPNOTSUPP; 1633 1634 err = zd1201_getconfig16(zd, ZD1201_RID_CNFHOSTAUTH, &hostauth); 1635 if (err) 1636 return err; 1637 rrq->value = hostauth; 1638 rrq->fixed = 1; 1639 1640 return 0; 1641} 1642 1643static int zd1201_auth_sta(struct net_device *dev, 1644 struct iw_request_info *info, struct sockaddr *sta, char *extra) 1645{ 1646 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1647 unsigned char buffer[10]; 1648 1649 if (!zd->ap) 1650 return -EOPNOTSUPP; 1651 1652 memcpy(buffer, sta->sa_data, ETH_ALEN); 1653 *(short*)(buffer+6) = 0; /* 0==success, 1==failure */ 1654 *(short*)(buffer+8) = 0; 1655 1656 return zd1201_setconfig(zd, ZD1201_RID_AUTHENTICATESTA, buffer, 10, 1); 1657} 1658 1659static int zd1201_set_maxassoc(struct net_device *dev, 1660 struct iw_request_info *info, struct iw_param *rrq, char *extra) 1661{ 1662 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1663 int err; 1664 1665 if (!zd->ap) 1666 return -EOPNOTSUPP; 1667 1668 err = zd1201_setconfig16(zd, ZD1201_RID_CNFMAXASSOCSTATIONS, rrq->value); 1669 if (err) 1670 return err; 1671 return 0; 1672} 1673 1674static int zd1201_get_maxassoc(struct net_device *dev, 1675 struct iw_request_info *info, struct iw_param *rrq, char *extra) 1676{ 1677 struct zd1201 *zd = (struct zd1201 *)dev->priv; 1678 short maxassoc; 1679 int err; 1680 1681 if (!zd->ap) 1682 return -EOPNOTSUPP; 1683 1684 err = zd1201_getconfig16(zd, ZD1201_RID_CNFMAXASSOCSTATIONS, &maxassoc); 1685 if (err) 1686 return err; 1687 rrq->value = maxassoc; 1688 rrq->fixed = 1; 1689 1690 return 0; 1691} 1692 1693static const iw_handler zd1201_private_handler[] = { 1694 (iw_handler) zd1201_set_hostauth, /* ZD1201SIWHOSTAUTH */ 1695 (iw_handler) zd1201_get_hostauth, /* ZD1201GIWHOSTAUTH */ 1696 (iw_handler) zd1201_auth_sta, /* ZD1201SIWAUTHSTA */ 1697 (iw_handler) NULL, /* nothing to get */ 1698 (iw_handler) zd1201_set_maxassoc, /* ZD1201SIMAXASSOC */ 1699 (iw_handler) zd1201_get_maxassoc, /* ZD1201GIMAXASSOC */ 1700}; 1701 1702static const struct iw_priv_args zd1201_private_args[] = { 1703 { ZD1201SIWHOSTAUTH, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 1704 IW_PRIV_TYPE_NONE, "sethostauth" }, 1705 { ZD1201GIWHOSTAUTH, IW_PRIV_TYPE_NONE, 1706 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethostauth" }, 1707 { ZD1201SIWAUTHSTA, IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 1708 IW_PRIV_TYPE_NONE, "authstation" }, 1709 { ZD1201SIWMAXASSOC, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 1710 IW_PRIV_TYPE_NONE, "setmaxassoc" }, 1711 { ZD1201GIWMAXASSOC, IW_PRIV_TYPE_NONE, 1712 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getmaxassoc" }, 1713}; 1714 1715static const struct iw_handler_def zd1201_iw_handlers = { 1716 .num_standard = ARRAY_SIZE(zd1201_iw_handler), 1717 .num_private = ARRAY_SIZE(zd1201_private_handler), 1718 .num_private_args = ARRAY_SIZE(zd1201_private_args), 1719 .standard = (iw_handler *)zd1201_iw_handler, 1720 .private = (iw_handler *)zd1201_private_handler, 1721 .private_args = (struct iw_priv_args *) zd1201_private_args, 1722 .get_wireless_stats = zd1201_get_wireless_stats, 1723}; 1724 1725static int zd1201_probe(struct usb_interface *interface, 1726 const struct usb_device_id *id) 1727{ 1728 struct zd1201 *zd; 1729 struct usb_device *usb; 1730 int err; 1731 short porttype; 1732 char buf[IW_ESSID_MAX_SIZE+2]; 1733 1734 usb = interface_to_usbdev(interface); 1735 1736 zd = kzalloc(sizeof(struct zd1201), GFP_KERNEL); 1737 if (!zd) 1738 return -ENOMEM; 1739 zd->ap = ap; 1740 zd->usb = usb; 1741 zd->removed = 0; 1742 init_waitqueue_head(&zd->rxdataq); 1743 INIT_HLIST_HEAD(&zd->fraglist); 1744 1745 err = zd1201_fw_upload(usb, zd->ap); 1746 if (err) { 1747 dev_err(&usb->dev, "zd1201 firmware upload failed: %d\n", err); 1748 goto err_zd; 1749 } 1750 1751 zd->endp_in = 1; 1752 zd->endp_out = 1; 1753 zd->endp_out2 = 2; 1754 zd->rx_urb = usb_alloc_urb(0, GFP_KERNEL); 1755 zd->tx_urb = usb_alloc_urb(0, GFP_KERNEL); 1756 if (!zd->rx_urb || !zd->tx_urb) 1757 goto err_zd; 1758 1759 mdelay(100); 1760 err = zd1201_drvr_start(zd); 1761 if (err) 1762 goto err_zd; 1763 1764 err = zd1201_setconfig16(zd, ZD1201_RID_CNFMAXDATALEN, 2312); 1765 if (err) 1766 goto err_start; 1767 1768 err = zd1201_setconfig16(zd, ZD1201_RID_TXRATECNTL, 1769 ZD1201_RATEB1 | ZD1201_RATEB2 | ZD1201_RATEB5 | ZD1201_RATEB11); 1770 if (err) 1771 goto err_start; 1772 1773 zd->dev = alloc_etherdev(0); 1774 if (!zd->dev) 1775 goto err_start; 1776 1777 zd->dev->priv = zd; 1778 zd->dev->open = zd1201_net_open; 1779 zd->dev->stop = zd1201_net_stop; 1780 zd->dev->get_stats = zd1201_get_stats; 1781 zd->dev->wireless_handlers = 1782 (struct iw_handler_def *)&zd1201_iw_handlers; 1783 zd->dev->hard_start_xmit = zd1201_hard_start_xmit; 1784 zd->dev->watchdog_timeo = ZD1201_TX_TIMEOUT; 1785 zd->dev->tx_timeout = zd1201_tx_timeout; 1786 zd->dev->set_multicast_list = zd1201_set_multicast; 1787 zd->dev->set_mac_address = zd1201_set_mac_address; 1788 strcpy(zd->dev->name, "wlan%d"); 1789 1790 err = zd1201_getconfig(zd, ZD1201_RID_CNFOWNMACADDR, 1791 zd->dev->dev_addr, zd->dev->addr_len); 1792 if (err) 1793 goto err_net; 1794 1795 /* Set wildcard essid to match zd->essid */ 1796 *(__le16 *)buf = cpu_to_le16(0); 1797 err = zd1201_setconfig(zd, ZD1201_RID_CNFDESIREDSSID, buf, 1798 IW_ESSID_MAX_SIZE+2, 1); 1799 if (err) 1800 goto err_net; 1801 1802 if (zd->ap) 1803 porttype = ZD1201_PORTTYPE_AP; 1804 else 1805 porttype = ZD1201_PORTTYPE_BSS; 1806 err = zd1201_setconfig16(zd, ZD1201_RID_CNFPORTTYPE, porttype); 1807 if (err) 1808 goto err_net; 1809 1810 SET_NETDEV_DEV(zd->dev, &usb->dev); 1811 1812 err = register_netdev(zd->dev); 1813 if (err) 1814 goto err_net; 1815 dev_info(&usb->dev, "%s: ZD1201 USB Wireless interface\n", 1816 zd->dev->name); 1817 1818 usb_set_intfdata(interface, zd); 1819 zd1201_enable(zd); /* zd1201 likes to startup enabled, */ 1820 zd1201_disable(zd); /* interfering with all the wifis in range */ 1821 return 0; 1822 1823err_net: 1824 free_netdev(zd->dev); 1825err_start: 1826 /* Leave the device in reset state */ 1827 zd1201_docmd(zd, ZD1201_CMDCODE_INIT, 0, 0, 0); 1828err_zd: 1829 usb_free_urb(zd->tx_urb); 1830 usb_free_urb(zd->rx_urb); 1831 kfree(zd); 1832 return err; 1833} 1834 1835static 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 if (zd->dev) { 1845 unregister_netdev(zd->dev); 1846 free_netdev(zd->dev); 1847 } 1848 1849 hlist_for_each_entry_safe(frag, node, node2, &zd->fraglist, fnode) { 1850 hlist_del_init(&frag->fnode); 1851 kfree_skb(frag->skb); 1852 kfree(frag); 1853 } 1854 1855 if (zd->tx_urb) { 1856 usb_kill_urb(zd->tx_urb); 1857 usb_free_urb(zd->tx_urb); 1858 } 1859 if (zd->rx_urb) { 1860 usb_kill_urb(zd->rx_urb); 1861 usb_free_urb(zd->rx_urb); 1862 } 1863 kfree(zd); 1864} 1865 1866#ifdef CONFIG_PM 1867 1868static 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 1883static 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 1905static 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 1914static int __init zd1201_init(void) 1915{ 1916 return usb_register(&zd1201_usb); 1917} 1918 1919static void __exit zd1201_cleanup(void) 1920{ 1921 usb_deregister(&zd1201_usb); 1922} 1923 1924module_init(zd1201_init); 1925module_exit(zd1201_cleanup); 1926