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