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