Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  *  Driver for ZyDAS zd1201 based wireless USB devices.
0004  *
0005  *  Copyright (c) 2004, 2005 Jeroen Vreeken (pe1rxq@amsat.org)
0006  *
0007  *  Parts of this driver have been derived from a wlan-ng version
0008  *  modified by ZyDAS. They also made documentation available, thanks!
0009  *  Copyright (C) 1999 AbsoluteValue Systems, Inc.  All Rights Reserved.
0010  */
0011 
0012 #include <linux/module.h>
0013 #include <linux/usb.h>
0014 #include <linux/slab.h>
0015 #include <linux/netdevice.h>
0016 #include <linux/etherdevice.h>
0017 #include <linux/wireless.h>
0018 #include <net/cfg80211.h>
0019 #include <net/iw_handler.h>
0020 #include <linux/string.h>
0021 #include <linux/if_arp.h>
0022 #include <linux/firmware.h>
0023 #include "zd1201.h"
0024 
0025 static const struct usb_device_id zd1201_table[] = {
0026     {USB_DEVICE(0x0586, 0x3400)}, /* Peabird Wireless USB Adapter */
0027     {USB_DEVICE(0x0ace, 0x1201)}, /* ZyDAS ZD1201 Wireless USB Adapter */
0028     {USB_DEVICE(0x050d, 0x6051)}, /* Belkin F5D6051 usb  adapter */
0029     {USB_DEVICE(0x0db0, 0x6823)}, /* MSI UB11B usb  adapter */
0030     {USB_DEVICE(0x1044, 0x8004)}, /* Gigabyte GN-WLBZ101 */
0031     {USB_DEVICE(0x1044, 0x8005)}, /* GIGABYTE GN-WLBZ201 usb adapter */
0032     {}
0033 };
0034 
0035 static int ap;  /* Are we an AP or a normal station? */
0036 
0037 #define ZD1201_VERSION  "0.15"
0038 
0039 MODULE_AUTHOR("Jeroen Vreeken <pe1rxq@amsat.org>");
0040 MODULE_DESCRIPTION("Driver for ZyDAS ZD1201 based USB Wireless adapters");
0041 MODULE_VERSION(ZD1201_VERSION);
0042 MODULE_LICENSE("GPL");
0043 module_param(ap, int, 0);
0044 MODULE_PARM_DESC(ap, "If non-zero Access Point firmware will be loaded");
0045 MODULE_DEVICE_TABLE(usb, zd1201_table);
0046 
0047 
0048 static int zd1201_fw_upload(struct usb_device *dev, int apfw)
0049 {
0050     const struct firmware *fw_entry;
0051     const char *data;
0052     unsigned long len;
0053     int err;
0054     unsigned char ret;
0055     char *buf;
0056     char *fwfile;
0057 
0058     if (apfw)
0059         fwfile = "zd1201-ap.fw";
0060     else
0061         fwfile = "zd1201.fw";
0062 
0063     err = request_firmware(&fw_entry, fwfile, &dev->dev);
0064     if (err) {
0065         dev_err(&dev->dev, "Failed to load %s firmware file!\n", fwfile);
0066         dev_err(&dev->dev, "Make sure the hotplug firmware loader is installed.\n");
0067         dev_err(&dev->dev, "Goto http://linux-lc100020.sourceforge.net for more info.\n");
0068         return err;
0069     }
0070 
0071     data = fw_entry->data;
0072         len = fw_entry->size;
0073 
0074     buf = kmalloc(1024, GFP_ATOMIC);
0075     if (!buf) {
0076         err = -ENOMEM;
0077         goto exit;
0078     }
0079     
0080     while (len > 0) {
0081         int translen = (len > 1024) ? 1024 : len;
0082         memcpy(buf, data, translen);
0083 
0084         err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 0,
0085             USB_DIR_OUT | 0x40, 0, 0, buf, translen,
0086             ZD1201_FW_TIMEOUT);
0087         if (err < 0)
0088             goto exit;
0089 
0090         len -= translen;
0091         data += translen;
0092     }
0093                                         
0094     err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 0x2,
0095         USB_DIR_OUT | 0x40, 0, 0, NULL, 0, ZD1201_FW_TIMEOUT);
0096     if (err < 0)
0097         goto exit;
0098 
0099     err = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 0x4,
0100         USB_DIR_IN | 0x40, 0, 0, buf, sizeof(ret), ZD1201_FW_TIMEOUT);
0101     if (err < 0)
0102         goto exit;
0103 
0104     memcpy(&ret, buf, sizeof(ret));
0105 
0106     if (ret & 0x80) {
0107         err = -EIO;
0108         goto exit;
0109     }
0110 
0111     err = 0;
0112 exit:
0113     kfree(buf);
0114     release_firmware(fw_entry);
0115     return err;
0116 }
0117 
0118 MODULE_FIRMWARE("zd1201-ap.fw");
0119 MODULE_FIRMWARE("zd1201.fw");
0120 
0121 static void zd1201_usbfree(struct urb *urb)
0122 {
0123     struct zd1201 *zd = urb->context;
0124 
0125     switch(urb->status) {
0126         case -EILSEQ:
0127         case -ENODEV:
0128         case -ETIME:
0129         case -ENOENT:
0130         case -EPIPE:
0131         case -EOVERFLOW:
0132         case -ESHUTDOWN:
0133             dev_warn(&zd->usb->dev, "%s: urb failed: %d\n", 
0134                 zd->dev->name, urb->status);
0135     }
0136 
0137     kfree(urb->transfer_buffer);
0138     usb_free_urb(urb);
0139 }
0140 
0141 /* cmdreq message: 
0142     u32 type
0143     u16 cmd
0144     u16 parm0
0145     u16 parm1
0146     u16 parm2
0147     u8  pad[4]
0148 
0149     total: 4 + 2 + 2 + 2 + 2 + 4 = 16
0150 */
0151 static int zd1201_docmd(struct zd1201 *zd, int cmd, int parm0,
0152             int parm1, int parm2)
0153 {
0154     unsigned char *command;
0155     int ret;
0156     struct urb *urb;
0157 
0158     command = kmalloc(16, GFP_ATOMIC);
0159     if (!command)
0160         return -ENOMEM;
0161 
0162     *((__le32*)command) = cpu_to_le32(ZD1201_USB_CMDREQ);
0163     *((__le16*)&command[4]) = cpu_to_le16(cmd);
0164     *((__le16*)&command[6]) = cpu_to_le16(parm0);
0165     *((__le16*)&command[8]) = cpu_to_le16(parm1);
0166     *((__le16*)&command[10])= cpu_to_le16(parm2);
0167 
0168     urb = usb_alloc_urb(0, GFP_ATOMIC);
0169     if (!urb) {
0170         kfree(command);
0171         return -ENOMEM;
0172     }
0173     usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb, zd->endp_out2),
0174               command, 16, zd1201_usbfree, zd);
0175     ret = usb_submit_urb(urb, GFP_ATOMIC);
0176     if (ret) {
0177         kfree(command);
0178         usb_free_urb(urb);
0179     }
0180 
0181     return ret;
0182 }
0183 
0184 /* Callback after sending out a packet */
0185 static void zd1201_usbtx(struct urb *urb)
0186 {
0187     struct zd1201 *zd = urb->context;
0188     netif_wake_queue(zd->dev);
0189 }
0190 
0191 /* Incoming data */
0192 static void zd1201_usbrx(struct urb *urb)
0193 {
0194     struct zd1201 *zd = urb->context;
0195     int free = 0;
0196     unsigned char *data = urb->transfer_buffer;
0197     struct sk_buff *skb;
0198     unsigned char type;
0199 
0200     if (!zd)
0201         return;
0202 
0203     switch(urb->status) {
0204         case -EILSEQ:
0205         case -ENODEV:
0206         case -ETIME:
0207         case -ENOENT:
0208         case -EPIPE:
0209         case -EOVERFLOW:
0210         case -ESHUTDOWN:
0211             dev_warn(&zd->usb->dev, "%s: rx urb failed: %d\n",
0212                 zd->dev->name, urb->status);
0213             free = 1;
0214             goto exit;
0215     }
0216     
0217     if (urb->status != 0 || urb->actual_length == 0)
0218         goto resubmit;
0219 
0220     type = data[0];
0221     if (type == ZD1201_PACKET_EVENTSTAT || type == ZD1201_PACKET_RESOURCE) {
0222         memcpy(zd->rxdata, data, urb->actual_length);
0223         zd->rxlen = urb->actual_length;
0224         zd->rxdatas = 1;
0225         wake_up(&zd->rxdataq);
0226     }
0227     /* Info frame */
0228     if (type == ZD1201_PACKET_INQUIRE) {
0229         int i = 0;
0230         unsigned short infotype, copylen;
0231         infotype = le16_to_cpu(*(__le16*)&data[6]);
0232 
0233         if (infotype == ZD1201_INF_LINKSTATUS) {
0234             short linkstatus;
0235 
0236             linkstatus = le16_to_cpu(*(__le16*)&data[8]);
0237             switch(linkstatus) {
0238                 case 1:
0239                     netif_carrier_on(zd->dev);
0240                     break;
0241                 case 2:
0242                     netif_carrier_off(zd->dev);
0243                     break;
0244                 case 3:
0245                     netif_carrier_off(zd->dev);
0246                     break;
0247                 case 4:
0248                     netif_carrier_on(zd->dev);
0249                     break;
0250                 default:
0251                     netif_carrier_off(zd->dev);
0252             }
0253             goto resubmit;
0254         }
0255         if (infotype == ZD1201_INF_ASSOCSTATUS) {
0256             short status = le16_to_cpu(*(__le16*)(data+8));
0257             int event;
0258             union iwreq_data wrqu;
0259 
0260             switch (status) {
0261                 case ZD1201_ASSOCSTATUS_STAASSOC:
0262                 case ZD1201_ASSOCSTATUS_REASSOC:
0263                     event = IWEVREGISTERED;
0264                     break;
0265                 case ZD1201_ASSOCSTATUS_DISASSOC:
0266                 case ZD1201_ASSOCSTATUS_ASSOCFAIL:
0267                 case ZD1201_ASSOCSTATUS_AUTHFAIL:
0268                 default:
0269                     event = IWEVEXPIRED;
0270             }
0271             memcpy(wrqu.addr.sa_data, data+10, ETH_ALEN);
0272             wrqu.addr.sa_family = ARPHRD_ETHER;
0273 
0274             /* Send event to user space */
0275             wireless_send_event(zd->dev, event, &wrqu, NULL);
0276 
0277             goto resubmit;
0278         }
0279         if (infotype == ZD1201_INF_AUTHREQ) {
0280             union iwreq_data wrqu;
0281 
0282             memcpy(wrqu.addr.sa_data, data+8, ETH_ALEN);
0283             wrqu.addr.sa_family = ARPHRD_ETHER;
0284             /* There isn't a event that trully fits this request.
0285                We assume that userspace will be smart enough to
0286                see a new station being expired and sends back a
0287                authstation ioctl to authorize it. */
0288             wireless_send_event(zd->dev, IWEVEXPIRED, &wrqu, NULL);
0289             goto resubmit;
0290         }
0291         /* Other infotypes are handled outside this handler */
0292         zd->rxlen = 0;
0293         while (i < urb->actual_length) {
0294             copylen = le16_to_cpu(*(__le16*)&data[i+2]);
0295             /* Sanity check, sometimes we get junk */
0296             if (copylen+zd->rxlen > sizeof(zd->rxdata))
0297                 break;
0298             memcpy(zd->rxdata+zd->rxlen, data+i+4, copylen);
0299             zd->rxlen += copylen;
0300             i += 64;
0301         }
0302         if (i >= urb->actual_length) {
0303             zd->rxdatas = 1;
0304             wake_up(&zd->rxdataq);
0305         }
0306         goto  resubmit;
0307     }
0308     /* Actual data */
0309     if (data[urb->actual_length-1] == ZD1201_PACKET_RXDATA) {
0310         int datalen = urb->actual_length-1;
0311         unsigned short len, fc, seq;
0312 
0313         len = ntohs(*(__be16 *)&data[datalen-2]);
0314         if (len>datalen)
0315             len=datalen;
0316         fc = le16_to_cpu(*(__le16 *)&data[datalen-16]);
0317         seq = le16_to_cpu(*(__le16 *)&data[datalen-24]);
0318 
0319         if (zd->monitor) {
0320             if (datalen < 24)
0321                 goto resubmit;
0322             if (!(skb = dev_alloc_skb(datalen+24)))
0323                 goto resubmit;
0324             
0325             skb_put_data(skb, &data[datalen - 16], 2);
0326             skb_put_data(skb, &data[datalen - 2], 2);
0327             skb_put_data(skb, &data[datalen - 14], 6);
0328             skb_put_data(skb, &data[datalen - 22], 6);
0329             skb_put_data(skb, &data[datalen - 8], 6);
0330             skb_put_data(skb, &data[datalen - 24], 2);
0331             skb_put_data(skb, data, len);
0332             skb->protocol = eth_type_trans(skb, zd->dev);
0333             zd->dev->stats.rx_packets++;
0334             zd->dev->stats.rx_bytes += skb->len;
0335             netif_rx(skb);
0336             goto resubmit;
0337         }
0338             
0339         if ((seq & IEEE80211_SCTL_FRAG) ||
0340             (fc & IEEE80211_FCTL_MOREFRAGS)) {
0341             struct zd1201_frag *frag = NULL;
0342             char *ptr;
0343 
0344             if (datalen<14)
0345                 goto resubmit;
0346             if ((seq & IEEE80211_SCTL_FRAG) == 0) {
0347                 frag = kmalloc(sizeof(*frag), GFP_ATOMIC);
0348                 if (!frag)
0349                     goto resubmit;
0350                 skb = dev_alloc_skb(IEEE80211_MAX_DATA_LEN +14+2);
0351                 if (!skb) {
0352                     kfree(frag);
0353                     goto resubmit;
0354                 }
0355                 frag->skb = skb;
0356                 frag->seq = seq & IEEE80211_SCTL_SEQ;
0357                 skb_reserve(skb, 2);
0358                 skb_put_data(skb, &data[datalen - 14], 12);
0359                 skb_put_data(skb, &data[6], 2);
0360                 skb_put_data(skb, data + 8, len);
0361                 hlist_add_head(&frag->fnode, &zd->fraglist);
0362                 goto resubmit;
0363             }
0364             hlist_for_each_entry(frag, &zd->fraglist, fnode)
0365                 if (frag->seq == (seq&IEEE80211_SCTL_SEQ))
0366                     break;
0367             if (!frag)
0368                 goto resubmit;
0369             skb = frag->skb;
0370             ptr = skb_put(skb, len);
0371             if (ptr)
0372                 memcpy(ptr, data+8, len);
0373             if (fc & IEEE80211_FCTL_MOREFRAGS)
0374                 goto resubmit;
0375             hlist_del_init(&frag->fnode);
0376             kfree(frag);
0377         } else {
0378             if (datalen<14)
0379                 goto resubmit;
0380             skb = dev_alloc_skb(len + 14 + 2);
0381             if (!skb)
0382                 goto resubmit;
0383             skb_reserve(skb, 2);
0384             skb_put_data(skb, &data[datalen - 14], 12);
0385             skb_put_data(skb, &data[6], 2);
0386             skb_put_data(skb, data + 8, len);
0387         }
0388         skb->protocol = eth_type_trans(skb, zd->dev);
0389         zd->dev->stats.rx_packets++;
0390         zd->dev->stats.rx_bytes += skb->len;
0391         netif_rx(skb);
0392     }
0393 resubmit:
0394     memset(data, 0, ZD1201_RXSIZE);
0395 
0396     urb->status = 0;
0397     urb->dev = zd->usb;
0398     if(usb_submit_urb(urb, GFP_ATOMIC))
0399         free = 1;
0400 
0401 exit:
0402     if (free) {
0403         zd->rxlen = 0;
0404         zd->rxdatas = 1;
0405         wake_up(&zd->rxdataq);
0406         kfree(urb->transfer_buffer);
0407     }
0408 }
0409 
0410 static int zd1201_getconfig(struct zd1201 *zd, int rid, void *riddata,
0411     unsigned int riddatalen)
0412 {
0413     int err;
0414     int i = 0;
0415     int code;
0416     int rid_fid;
0417     int length;
0418     unsigned char *pdata;
0419 
0420     zd->rxdatas = 0;
0421     err = zd1201_docmd(zd, ZD1201_CMDCODE_ACCESS, rid, 0, 0);
0422     if (err)
0423         return err;
0424 
0425     wait_event_interruptible(zd->rxdataq, zd->rxdatas);
0426     if (!zd->rxlen)
0427         return -EIO;
0428 
0429     code = le16_to_cpu(*(__le16*)(&zd->rxdata[4]));
0430     rid_fid = le16_to_cpu(*(__le16*)(&zd->rxdata[6]));
0431     length = le16_to_cpu(*(__le16*)(&zd->rxdata[8]));
0432     if (length > zd->rxlen)
0433         length = zd->rxlen-6;
0434 
0435     /* If access bit is not on, then error */
0436     if ((code & ZD1201_ACCESSBIT) != ZD1201_ACCESSBIT || rid_fid != rid )
0437         return -EINVAL;
0438 
0439     /* Not enough buffer for allocating data */
0440     if (riddatalen != (length - 4)) {
0441         dev_dbg(&zd->usb->dev, "riddatalen mismatches, expected=%u, (packet=%u) length=%u, rid=0x%04X, rid_fid=0x%04X\n",
0442             riddatalen, zd->rxlen, length, rid, rid_fid);
0443         return -ENODATA;
0444     }
0445 
0446     zd->rxdatas = 0;
0447     /* Issue SetRxRid commnd */         
0448     err = zd1201_docmd(zd, ZD1201_CMDCODE_SETRXRID, rid, 0, length);
0449     if (err)
0450         return err;
0451 
0452     /* Receive RID record from resource packets */
0453     wait_event_interruptible(zd->rxdataq, zd->rxdatas);
0454     if (!zd->rxlen)
0455         return -EIO;
0456 
0457     if (zd->rxdata[zd->rxlen - 1] != ZD1201_PACKET_RESOURCE) {
0458         dev_dbg(&zd->usb->dev, "Packet type mismatch: 0x%x not 0x3\n",
0459             zd->rxdata[zd->rxlen-1]);
0460         return -EINVAL;
0461     }
0462 
0463     /* Set the data pointer and received data length */
0464     pdata = zd->rxdata;
0465     length = zd->rxlen;
0466 
0467     do {
0468         int actual_length;
0469 
0470         actual_length = (length > 64) ? 64 : length;
0471 
0472         if (pdata[0] != 0x3) {
0473             dev_dbg(&zd->usb->dev, "Rx Resource packet type error: %02X\n",
0474                 pdata[0]);
0475             return -EINVAL;
0476         }
0477 
0478         if (actual_length != 64) {
0479             /* Trim the last packet type byte */
0480             actual_length--;
0481         }
0482 
0483         /* Skip the 4 bytes header (RID length and RID) */
0484         if (i == 0) {
0485             pdata += 8;
0486             actual_length -= 8;
0487         } else {
0488             pdata += 4;
0489             actual_length -= 4;
0490         }
0491         
0492         memcpy(riddata, pdata, actual_length);
0493         riddata += actual_length;
0494         pdata += actual_length;
0495         length -= 64;
0496         i++;
0497     } while (length > 0);
0498 
0499     return 0;
0500 }
0501 
0502 /*
0503  *  resreq:
0504  *      byte    type
0505  *      byte    sequence
0506  *      u16 reserved
0507  *      byte    data[12]
0508  *  total: 16
0509  */
0510 static int zd1201_setconfig(struct zd1201 *zd, int rid, const void *buf, int len, int wait)
0511 {
0512     int err;
0513     unsigned char *request;
0514     int reqlen;
0515     char seq=0;
0516     struct urb *urb;
0517     gfp_t gfp_mask = wait ? GFP_NOIO : GFP_ATOMIC;
0518 
0519     len += 4;           /* first 4 are for header */
0520 
0521     zd->rxdatas = 0;
0522     zd->rxlen = 0;
0523     for (seq=0; len > 0; seq++) {
0524         request = kzalloc(16, gfp_mask);
0525         if (!request)
0526             return -ENOMEM;
0527         urb = usb_alloc_urb(0, gfp_mask);
0528         if (!urb) {
0529             kfree(request);
0530             return -ENOMEM;
0531         }
0532         reqlen = len>12 ? 12 : len;
0533         request[0] = ZD1201_USB_RESREQ;
0534         request[1] = seq;
0535         request[2] = 0;
0536         request[3] = 0;
0537         if (request[1] == 0) {
0538             /* add header */
0539             *(__le16*)&request[4] = cpu_to_le16((len-2+1)/2);
0540             *(__le16*)&request[6] = cpu_to_le16(rid);
0541             memcpy(request+8, buf, reqlen-4);
0542             buf += reqlen-4;
0543         } else {
0544             memcpy(request+4, buf, reqlen);
0545             buf += reqlen;
0546         }
0547 
0548         len -= reqlen;
0549 
0550         usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb,
0551             zd->endp_out2), request, 16, zd1201_usbfree, zd);
0552         err = usb_submit_urb(urb, gfp_mask);
0553         if (err)
0554             goto err;
0555     }
0556 
0557     request = kmalloc(16, gfp_mask);
0558     if (!request)
0559         return -ENOMEM;
0560     urb = usb_alloc_urb(0, gfp_mask);
0561     if (!urb) {
0562         kfree(request);
0563         return -ENOMEM;
0564     }
0565     *((__le32*)request) = cpu_to_le32(ZD1201_USB_CMDREQ);
0566     *((__le16*)&request[4]) = 
0567         cpu_to_le16(ZD1201_CMDCODE_ACCESS|ZD1201_ACCESSBIT);
0568     *((__le16*)&request[6]) = cpu_to_le16(rid);
0569     *((__le16*)&request[8]) = cpu_to_le16(0);
0570     *((__le16*)&request[10]) = cpu_to_le16(0);
0571     usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb, zd->endp_out2),
0572          request, 16, zd1201_usbfree, zd);
0573     err = usb_submit_urb(urb, gfp_mask);
0574     if (err)
0575         goto err;
0576     
0577     if (wait) {
0578         wait_event_interruptible(zd->rxdataq, zd->rxdatas);
0579         if (!zd->rxlen || le16_to_cpu(*(__le16*)&zd->rxdata[6]) != rid) {
0580             dev_dbg(&zd->usb->dev, "wrong or no RID received\n");
0581         }
0582     }
0583 
0584     return 0;
0585 err:
0586     kfree(request);
0587     usb_free_urb(urb);
0588     return err;
0589 }
0590 
0591 static inline int zd1201_getconfig16(struct zd1201 *zd, int rid, short *val)
0592 {
0593     int err;
0594     __le16 zdval;
0595 
0596     err = zd1201_getconfig(zd, rid, &zdval, sizeof(__le16));
0597     if (err)
0598         return err;
0599     *val = le16_to_cpu(zdval);
0600     return 0;
0601 }
0602 
0603 static inline int zd1201_setconfig16(struct zd1201 *zd, int rid, short val)
0604 {
0605     __le16 zdval = cpu_to_le16(val);
0606     return (zd1201_setconfig(zd, rid, &zdval, sizeof(__le16), 1));
0607 }
0608 
0609 static int zd1201_drvr_start(struct zd1201 *zd)
0610 {
0611     int err, i;
0612     short max;
0613     __le16 zdmax;
0614     unsigned char *buffer;
0615 
0616     buffer = kzalloc(ZD1201_RXSIZE, GFP_KERNEL);
0617     if (!buffer)
0618         return -ENOMEM;
0619 
0620     usb_fill_bulk_urb(zd->rx_urb, zd->usb, 
0621         usb_rcvbulkpipe(zd->usb, zd->endp_in), buffer, ZD1201_RXSIZE,
0622         zd1201_usbrx, zd);
0623 
0624     err = usb_submit_urb(zd->rx_urb, GFP_KERNEL);
0625     if (err)
0626         goto err_buffer;
0627 
0628     err = zd1201_docmd(zd, ZD1201_CMDCODE_INIT, 0, 0, 0);
0629     if (err)
0630         goto err_urb;
0631 
0632     err = zd1201_getconfig(zd, ZD1201_RID_CNFMAXTXBUFFERNUMBER, &zdmax,
0633         sizeof(__le16));
0634     if (err)
0635         goto err_urb;
0636 
0637     max = le16_to_cpu(zdmax);
0638     for (i=0; i<max; i++) {
0639         err = zd1201_docmd(zd, ZD1201_CMDCODE_ALLOC, 1514, 0, 0);
0640         if (err)
0641             goto err_urb;
0642     }
0643 
0644     return 0;
0645 
0646 err_urb:
0647     usb_kill_urb(zd->rx_urb);
0648     return err;
0649 err_buffer:
0650     kfree(buffer);
0651     return err;
0652 }
0653 
0654 /*  Magic alert: The firmware doesn't seem to like the MAC state being
0655  *  toggled in promisc (aka monitor) mode.
0656  *  (It works a number of times, but will halt eventually)
0657  *  So we turn it of before disabling and on after enabling if needed.
0658  */
0659 static int zd1201_enable(struct zd1201 *zd)
0660 {
0661     int err;
0662 
0663     if (zd->mac_enabled)
0664         return 0;
0665 
0666     err = zd1201_docmd(zd, ZD1201_CMDCODE_ENABLE, 0, 0, 0);
0667     if (!err)
0668         zd->mac_enabled = 1;
0669 
0670     if (zd->monitor)
0671         err = zd1201_setconfig16(zd, ZD1201_RID_PROMISCUOUSMODE, 1);
0672 
0673     return err;
0674 }
0675 
0676 static int zd1201_disable(struct zd1201 *zd)
0677 {
0678     int err;
0679 
0680     if (!zd->mac_enabled)
0681         return 0;
0682     if (zd->monitor) {
0683         err = zd1201_setconfig16(zd, ZD1201_RID_PROMISCUOUSMODE, 0);
0684         if (err)
0685             return err;
0686     }
0687 
0688     err = zd1201_docmd(zd, ZD1201_CMDCODE_DISABLE, 0, 0, 0);
0689     if (!err)
0690         zd->mac_enabled = 0;
0691     return err;
0692 }
0693 
0694 static int zd1201_mac_reset(struct zd1201 *zd)
0695 {
0696     if (!zd->mac_enabled)
0697         return 0;
0698     zd1201_disable(zd);
0699     return zd1201_enable(zd);
0700 }
0701 
0702 static int zd1201_join(struct zd1201 *zd, char *essid, int essidlen)
0703 {
0704     int err, val;
0705     char buf[IW_ESSID_MAX_SIZE+2];
0706 
0707     err = zd1201_disable(zd);
0708     if (err)
0709         return err;
0710 
0711     val = ZD1201_CNFAUTHENTICATION_OPENSYSTEM;
0712     val |= ZD1201_CNFAUTHENTICATION_SHAREDKEY;
0713     err = zd1201_setconfig16(zd, ZD1201_RID_CNFAUTHENTICATION, val);
0714     if (err)
0715         return err;
0716 
0717     *(__le16 *)buf = cpu_to_le16(essidlen);
0718     memcpy(buf+2, essid, essidlen);
0719     if (!zd->ap) {  /* Normal station */
0720         err = zd1201_setconfig(zd, ZD1201_RID_CNFDESIREDSSID, buf,
0721             IW_ESSID_MAX_SIZE+2, 1);
0722         if (err)
0723             return err;
0724     } else {    /* AP */
0725         err = zd1201_setconfig(zd, ZD1201_RID_CNFOWNSSID, buf,
0726             IW_ESSID_MAX_SIZE+2, 1);
0727         if (err)
0728             return err;
0729     }
0730 
0731     err = zd1201_setconfig(zd, ZD1201_RID_CNFOWNMACADDR, 
0732         zd->dev->dev_addr, zd->dev->addr_len, 1);
0733     if (err)
0734         return err;
0735 
0736     err = zd1201_enable(zd);
0737     if (err)
0738         return err;
0739 
0740     msleep(100);
0741     return 0;
0742 }
0743 
0744 static int zd1201_net_open(struct net_device *dev)
0745 {
0746     struct zd1201 *zd = netdev_priv(dev);
0747 
0748     /* Start MAC with wildcard if no essid set */
0749     if (!zd->mac_enabled)
0750         zd1201_join(zd, zd->essid, zd->essidlen);
0751     netif_start_queue(dev);
0752 
0753     return 0;
0754 }
0755 
0756 static int zd1201_net_stop(struct net_device *dev)
0757 {
0758     netif_stop_queue(dev);
0759     return 0;
0760 }
0761 
0762 /*
0763     RFC 1042 encapsulates Ethernet frames in 802.11 frames
0764     by prefixing them with 0xaa, 0xaa, 0x03) followed by a SNAP OID of 0
0765     (0x00, 0x00, 0x00). Zd requires an additional padding, copy
0766     of ethernet addresses, length of the standard RFC 1042 packet
0767     and a command byte (which is nul for tx).
0768     
0769     tx frame (from Wlan NG):
0770     RFC 1042:
0771         llc     0xAA 0xAA 0x03 (802.2 LLC)
0772         snap        0x00 0x00 0x00 (Ethernet encapsulated)
0773         type        2 bytes, Ethernet type field
0774         payload     (minus eth header)
0775     Zydas specific:
0776         padding     1B if (skb->len+8+1)%64==0
0777         Eth MAC addr    12 bytes, Ethernet MAC addresses
0778         length      2 bytes, RFC 1042 packet length 
0779                 (llc+snap+type+payload)
0780         zd      1 null byte, zd1201 packet type
0781  */
0782 static netdev_tx_t zd1201_hard_start_xmit(struct sk_buff *skb,
0783                         struct net_device *dev)
0784 {
0785     struct zd1201 *zd = netdev_priv(dev);
0786     unsigned char *txbuf = zd->txdata;
0787     int txbuflen, pad = 0, err;
0788     struct urb *urb = zd->tx_urb;
0789 
0790     if (!zd->mac_enabled || zd->monitor) {
0791         dev->stats.tx_dropped++;
0792         kfree_skb(skb);
0793         return NETDEV_TX_OK;
0794     }
0795     netif_stop_queue(dev);
0796 
0797     txbuflen = skb->len + 8 + 1;
0798     if (txbuflen%64 == 0) {
0799         pad = 1;
0800         txbuflen++;
0801     }
0802     txbuf[0] = 0xAA;
0803     txbuf[1] = 0xAA;
0804     txbuf[2] = 0x03;
0805     txbuf[3] = 0x00;    /* rfc1042 */
0806     txbuf[4] = 0x00;
0807     txbuf[5] = 0x00;
0808 
0809     skb_copy_from_linear_data_offset(skb, 12, txbuf + 6, skb->len - 12);
0810     if (pad)
0811         txbuf[skb->len-12+6]=0;
0812     skb_copy_from_linear_data(skb, txbuf + skb->len - 12 + 6 + pad, 12);
0813     *(__be16*)&txbuf[skb->len+6+pad] = htons(skb->len-12+6);
0814     txbuf[txbuflen-1] = 0;
0815 
0816     usb_fill_bulk_urb(urb, zd->usb, usb_sndbulkpipe(zd->usb, zd->endp_out),
0817         txbuf, txbuflen, zd1201_usbtx, zd);
0818 
0819     err = usb_submit_urb(zd->tx_urb, GFP_ATOMIC);
0820     if (err) {
0821         dev->stats.tx_errors++;
0822         netif_start_queue(dev);
0823     } else {
0824         dev->stats.tx_packets++;
0825         dev->stats.tx_bytes += skb->len;
0826     }
0827     kfree_skb(skb);
0828 
0829     return NETDEV_TX_OK;
0830 }
0831 
0832 static void zd1201_tx_timeout(struct net_device *dev, unsigned int txqueue)
0833 {
0834     struct zd1201 *zd = netdev_priv(dev);
0835 
0836     if (!zd)
0837         return;
0838     dev_warn(&zd->usb->dev, "%s: TX timeout, shooting down urb\n",
0839         dev->name);
0840     usb_unlink_urb(zd->tx_urb);
0841     dev->stats.tx_errors++;
0842     /* Restart the timeout to quiet the watchdog: */
0843     netif_trans_update(dev); /* prevent tx timeout */
0844 }
0845 
0846 static int zd1201_set_mac_address(struct net_device *dev, void *p)
0847 {
0848     struct sockaddr *addr = p;
0849     struct zd1201 *zd = netdev_priv(dev);
0850     int err;
0851 
0852     if (!zd)
0853         return -ENODEV;
0854 
0855     err = zd1201_setconfig(zd, ZD1201_RID_CNFOWNMACADDR, 
0856         addr->sa_data, dev->addr_len, 1);
0857     if (err)
0858         return err;
0859     eth_hw_addr_set(dev, addr->sa_data);
0860 
0861     return zd1201_mac_reset(zd);
0862 }
0863 
0864 static struct iw_statistics *zd1201_get_wireless_stats(struct net_device *dev)
0865 {
0866     struct zd1201 *zd = netdev_priv(dev);
0867 
0868     return &zd->iwstats;
0869 }
0870 
0871 static void zd1201_set_multicast(struct net_device *dev)
0872 {
0873     struct zd1201 *zd = netdev_priv(dev);
0874     struct netdev_hw_addr *ha;
0875     unsigned char reqbuf[ETH_ALEN*ZD1201_MAXMULTI];
0876     int i;
0877 
0878     if (netdev_mc_count(dev) > ZD1201_MAXMULTI)
0879         return;
0880 
0881     i = 0;
0882     netdev_for_each_mc_addr(ha, dev)
0883         memcpy(reqbuf + i++ * ETH_ALEN, ha->addr, ETH_ALEN);
0884     zd1201_setconfig(zd, ZD1201_RID_CNFGROUPADDRESS, reqbuf,
0885              netdev_mc_count(dev) * ETH_ALEN, 0);
0886 }
0887 
0888 static int zd1201_config_commit(struct net_device *dev, 
0889     struct iw_request_info *info, struct iw_point *data, char *essid)
0890 {
0891     struct zd1201 *zd = netdev_priv(dev);
0892 
0893     return zd1201_mac_reset(zd);
0894 }
0895 
0896 static int zd1201_get_name(struct net_device *dev,
0897     struct iw_request_info *info, char *name, char *extra)
0898 {
0899     strcpy(name, "IEEE 802.11b");
0900     return 0;
0901 }
0902 
0903 static int zd1201_set_freq(struct net_device *dev,
0904     struct iw_request_info *info, struct iw_freq *freq, char *extra)
0905 {
0906     struct zd1201 *zd = netdev_priv(dev);
0907     short channel = 0;
0908     int err;
0909 
0910     if (freq->e == 0)
0911         channel = freq->m;
0912     else
0913         channel = ieee80211_frequency_to_channel(freq->m);
0914 
0915     err = zd1201_setconfig16(zd, ZD1201_RID_CNFOWNCHANNEL, channel);
0916     if (err)
0917         return err;
0918 
0919     zd1201_mac_reset(zd);
0920 
0921     return 0;
0922 }
0923 
0924 static int zd1201_get_freq(struct net_device *dev,
0925     struct iw_request_info *info, struct iw_freq *freq, char *extra)
0926 {
0927     struct zd1201 *zd = netdev_priv(dev);
0928     short channel;
0929     int err;
0930 
0931     err = zd1201_getconfig16(zd, ZD1201_RID_CNFOWNCHANNEL, &channel);
0932     if (err)
0933         return err;
0934     freq->e = 0;
0935     freq->m = channel;
0936 
0937     return 0;
0938 }
0939 
0940 static int zd1201_set_mode(struct net_device *dev,
0941     struct iw_request_info *info, __u32 *mode, char *extra)
0942 {
0943     struct zd1201 *zd = netdev_priv(dev);
0944     short porttype, monitor = 0;
0945     unsigned char buffer[IW_ESSID_MAX_SIZE+2];
0946     int err;
0947 
0948     if (zd->ap) {
0949         if (*mode != IW_MODE_MASTER)
0950             return -EINVAL;
0951         return 0;
0952     }
0953 
0954     err = zd1201_setconfig16(zd, ZD1201_RID_PROMISCUOUSMODE, 0);
0955     if (err)
0956         return err;
0957     zd->dev->type = ARPHRD_ETHER;
0958     switch(*mode) {
0959         case IW_MODE_MONITOR:
0960             monitor = 1;
0961             zd->dev->type = ARPHRD_IEEE80211;
0962             /* Make sure we are no longer associated with by
0963                setting an 'impossible' essid.
0964                (otherwise we mess up firmware)
0965              */
0966             zd1201_join(zd, "\0-*#\0", 5);
0967             /* Put port in pIBSS */
0968             fallthrough;
0969         case 8: /* No pseudo-IBSS in wireless extensions (yet) */
0970             porttype = ZD1201_PORTTYPE_PSEUDOIBSS;
0971             break;
0972         case IW_MODE_ADHOC:
0973             porttype = ZD1201_PORTTYPE_IBSS;
0974             break;
0975         case IW_MODE_INFRA:
0976             porttype = ZD1201_PORTTYPE_BSS;
0977             break;
0978         default:
0979             return -EINVAL;
0980     }
0981 
0982     err = zd1201_setconfig16(zd, ZD1201_RID_CNFPORTTYPE, porttype);
0983     if (err)
0984         return err;
0985     if (zd->monitor && !monitor) {
0986             zd1201_disable(zd);
0987             *(__le16 *)buffer = cpu_to_le16(zd->essidlen);
0988             memcpy(buffer+2, zd->essid, zd->essidlen);
0989             err = zd1201_setconfig(zd, ZD1201_RID_CNFDESIREDSSID,
0990                 buffer, IW_ESSID_MAX_SIZE+2, 1);
0991             if (err)
0992                 return err;
0993     }
0994     zd->monitor = monitor;
0995     /* If monitor mode is set we don't actually turn it on here since it
0996      * is done during mac reset anyway (see zd1201_mac_enable).
0997      */
0998     zd1201_mac_reset(zd);
0999 
1000     return 0;
1001 }
1002 
1003 static int zd1201_get_mode(struct net_device *dev,
1004     struct iw_request_info *info, __u32 *mode, char *extra)
1005 {
1006     struct zd1201 *zd = netdev_priv(dev);
1007     short porttype;
1008     int err;
1009 
1010     err = zd1201_getconfig16(zd, ZD1201_RID_CNFPORTTYPE, &porttype);
1011     if (err)
1012         return err;
1013     switch(porttype) {
1014         case ZD1201_PORTTYPE_IBSS:
1015             *mode = IW_MODE_ADHOC;
1016             break;
1017         case ZD1201_PORTTYPE_BSS:
1018             *mode = IW_MODE_INFRA;
1019             break;
1020         case ZD1201_PORTTYPE_WDS:
1021             *mode = IW_MODE_REPEAT;
1022             break;
1023         case ZD1201_PORTTYPE_PSEUDOIBSS:
1024             *mode = 8;/* No Pseudo-IBSS... */
1025             break;
1026         case ZD1201_PORTTYPE_AP:
1027             *mode = IW_MODE_MASTER;
1028             break;
1029         default:
1030             dev_dbg(&zd->usb->dev, "Unknown porttype: %d\n",
1031                 porttype);
1032             *mode = IW_MODE_AUTO;
1033     }
1034     if (zd->monitor)
1035         *mode = IW_MODE_MONITOR;
1036 
1037     return 0;
1038 }
1039 
1040 static int zd1201_get_range(struct net_device *dev,
1041     struct iw_request_info *info, struct iw_point *wrq, char *extra)
1042 {
1043     struct iw_range *range = (struct iw_range *)extra;
1044 
1045     wrq->length = sizeof(struct iw_range);
1046     memset(range, 0, sizeof(struct iw_range));
1047     range->we_version_compiled = WIRELESS_EXT;
1048     range->we_version_source = WIRELESS_EXT;
1049 
1050     range->max_qual.qual = 128;
1051     range->max_qual.level = 128;
1052     range->max_qual.noise = 128;
1053     range->max_qual.updated = 7;
1054 
1055     range->encoding_size[0] = 5;
1056     range->encoding_size[1] = 13;
1057     range->num_encoding_sizes = 2;
1058     range->max_encoding_tokens = ZD1201_NUMKEYS;
1059 
1060     range->num_bitrates = 4;
1061     range->bitrate[0] = 1000000;
1062     range->bitrate[1] = 2000000;
1063     range->bitrate[2] = 5500000;
1064     range->bitrate[3] = 11000000;
1065 
1066     range->min_rts = 0;
1067     range->min_frag = ZD1201_FRAGMIN;
1068     range->max_rts = ZD1201_RTSMAX;
1069     range->min_frag = ZD1201_FRAGMAX;
1070 
1071     return 0;
1072 }
1073 
1074 /*  Little bit of magic here: we only get the quality if we poll
1075  *  for it, and we never get an actual request to trigger such
1076  *  a poll. Therefore we 'assume' that the user will soon ask for
1077  *  the stats after asking the bssid.
1078  */
1079 static int zd1201_get_wap(struct net_device *dev,
1080     struct iw_request_info *info, struct sockaddr *ap_addr, char *extra)
1081 {
1082     struct zd1201 *zd = netdev_priv(dev);
1083     unsigned char buffer[6];
1084 
1085     if (!zd1201_getconfig(zd, ZD1201_RID_COMMSQUALITY, buffer, 6)) {
1086         /* Unfortunately the quality and noise reported is useless.
1087            they seem to be accumulators that increase until you
1088            read them, unless we poll on a fixed interval we can't
1089            use them
1090          */
1091         /*zd->iwstats.qual.qual = le16_to_cpu(((__le16 *)buffer)[0]);*/
1092         zd->iwstats.qual.level = le16_to_cpu(((__le16 *)buffer)[1]);
1093         /*zd->iwstats.qual.noise = le16_to_cpu(((__le16 *)buffer)[2]);*/
1094         zd->iwstats.qual.updated = 2;
1095     }
1096 
1097     return zd1201_getconfig(zd, ZD1201_RID_CURRENTBSSID, ap_addr->sa_data, 6);
1098 }
1099 
1100 static int zd1201_set_scan(struct net_device *dev,
1101     struct iw_request_info *info, struct iw_point *srq, char *extra)
1102 {
1103     /* We do everything in get_scan */
1104     return 0;
1105 }
1106 
1107 static int zd1201_get_scan(struct net_device *dev,
1108     struct iw_request_info *info, struct iw_point *srq, char *extra)
1109 {
1110     struct zd1201 *zd = netdev_priv(dev);
1111     int err, i, j, enabled_save;
1112     struct iw_event iwe;
1113     char *cev = extra;
1114     char *end_buf = extra + IW_SCAN_MAX_DATA;
1115 
1116     /* No scanning in AP mode */
1117     if (zd->ap)
1118         return -EOPNOTSUPP;
1119 
1120     /* Scan doesn't seem to work if disabled */
1121     enabled_save = zd->mac_enabled;
1122     zd1201_enable(zd);
1123 
1124     zd->rxdatas = 0;
1125     err = zd1201_docmd(zd, ZD1201_CMDCODE_INQUIRE, 
1126          ZD1201_INQ_SCANRESULTS, 0, 0);
1127     if (err)
1128         return err;
1129 
1130     wait_event_interruptible(zd->rxdataq, zd->rxdatas);
1131     if (!zd->rxlen)
1132         return -EIO;
1133 
1134     if (le16_to_cpu(*(__le16*)&zd->rxdata[2]) != ZD1201_INQ_SCANRESULTS)
1135         return -EIO;
1136 
1137     for(i=8; i<zd->rxlen; i+=62) {
1138         iwe.cmd = SIOCGIWAP;
1139         iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1140         memcpy(iwe.u.ap_addr.sa_data, zd->rxdata+i+6, 6);
1141         cev = iwe_stream_add_event(info, cev, end_buf,
1142                        &iwe, IW_EV_ADDR_LEN);
1143 
1144         iwe.cmd = SIOCGIWESSID;
1145         iwe.u.data.length = zd->rxdata[i+16];
1146         iwe.u.data.flags = 1;
1147         cev = iwe_stream_add_point(info, cev, end_buf,
1148                        &iwe, zd->rxdata+i+18);
1149 
1150         iwe.cmd = SIOCGIWMODE;
1151         if (zd->rxdata[i+14]&0x01)
1152             iwe.u.mode = IW_MODE_MASTER;
1153         else
1154             iwe.u.mode = IW_MODE_ADHOC;
1155         cev = iwe_stream_add_event(info, cev, end_buf,
1156                        &iwe, IW_EV_UINT_LEN);
1157         
1158         iwe.cmd = SIOCGIWFREQ;
1159         iwe.u.freq.m = zd->rxdata[i+0];
1160         iwe.u.freq.e = 0;
1161         cev = iwe_stream_add_event(info, cev, end_buf,
1162                        &iwe, IW_EV_FREQ_LEN);
1163         
1164         iwe.cmd = SIOCGIWRATE;
1165         iwe.u.bitrate.fixed = 0;
1166         iwe.u.bitrate.disabled = 0;
1167         for (j=0; j<10; j++) if (zd->rxdata[i+50+j]) {
1168             iwe.u.bitrate.value = (zd->rxdata[i+50+j]&0x7f)*500000;
1169             cev = iwe_stream_add_event(info, cev, end_buf,
1170                            &iwe, IW_EV_PARAM_LEN);
1171         }
1172         
1173         iwe.cmd = SIOCGIWENCODE;
1174         iwe.u.data.length = 0;
1175         if (zd->rxdata[i+14]&0x10)
1176             iwe.u.data.flags = IW_ENCODE_ENABLED;
1177         else
1178             iwe.u.data.flags = IW_ENCODE_DISABLED;
1179         cev = iwe_stream_add_point(info, cev, end_buf, &iwe, NULL);
1180         
1181         iwe.cmd = IWEVQUAL;
1182         iwe.u.qual.qual = zd->rxdata[i+4];
1183         iwe.u.qual.noise= zd->rxdata[i+2]/10-100;
1184         iwe.u.qual.level = (256+zd->rxdata[i+4]*100)/255-100;
1185         iwe.u.qual.updated = 7;
1186         cev = iwe_stream_add_event(info, cev, end_buf,
1187                        &iwe, IW_EV_QUAL_LEN);
1188     }
1189 
1190     if (!enabled_save)
1191         zd1201_disable(zd);
1192 
1193     srq->length = cev - extra;
1194     srq->flags = 0;
1195 
1196     return 0;
1197 }
1198 
1199 static int zd1201_set_essid(struct net_device *dev,
1200     struct iw_request_info *info, struct iw_point *data, char *essid)
1201 {
1202     struct zd1201 *zd = netdev_priv(dev);
1203 
1204     if (data->length > IW_ESSID_MAX_SIZE)
1205         return -EINVAL;
1206     if (data->length < 1)
1207         data->length = 1;
1208     zd->essidlen = data->length;
1209     memset(zd->essid, 0, IW_ESSID_MAX_SIZE+1);
1210     memcpy(zd->essid, essid, data->length);
1211     return zd1201_join(zd, zd->essid, zd->essidlen);
1212 }
1213 
1214 static int zd1201_get_essid(struct net_device *dev,
1215     struct iw_request_info *info, struct iw_point *data, char *essid)
1216 {
1217     struct zd1201 *zd = netdev_priv(dev);
1218 
1219     memcpy(essid, zd->essid, zd->essidlen);
1220     data->flags = 1;
1221     data->length = zd->essidlen;
1222 
1223     return 0;
1224 }
1225 
1226 static int zd1201_get_nick(struct net_device *dev, struct iw_request_info *info,
1227     struct iw_point *data, char *nick)
1228 {
1229     strcpy(nick, "zd1201");
1230     data->flags = 1;
1231     data->length = strlen(nick);
1232     return 0;
1233 }
1234 
1235 static int zd1201_set_rate(struct net_device *dev,
1236     struct iw_request_info *info, struct iw_param *rrq, char *extra)
1237 {
1238     struct zd1201 *zd = netdev_priv(dev);
1239     short rate;
1240     int err;
1241 
1242     switch (rrq->value) {
1243         case 1000000:
1244             rate = ZD1201_RATEB1;
1245             break;
1246         case 2000000:
1247             rate = ZD1201_RATEB2;
1248             break;
1249         case 5500000:
1250             rate = ZD1201_RATEB5;
1251             break;
1252         case 11000000:
1253         default:
1254             rate = ZD1201_RATEB11;
1255             break;
1256     }
1257     if (!rrq->fixed) { /* Also enable all lower bitrates */
1258         rate |= rate-1;
1259     }
1260 
1261     err = zd1201_setconfig16(zd, ZD1201_RID_TXRATECNTL, rate);
1262     if (err)
1263         return err;
1264 
1265     return zd1201_mac_reset(zd);
1266 }
1267 
1268 static int zd1201_get_rate(struct net_device *dev,
1269     struct iw_request_info *info, struct iw_param *rrq, char *extra)
1270 {
1271     struct zd1201 *zd = netdev_priv(dev);
1272     short rate;
1273     int err;
1274 
1275     err = zd1201_getconfig16(zd, ZD1201_RID_CURRENTTXRATE, &rate);
1276     if (err)
1277         return err;
1278 
1279     switch(rate) {
1280         case 1:
1281             rrq->value = 1000000;
1282             break;
1283         case 2:
1284             rrq->value = 2000000;
1285             break;
1286         case 5:
1287             rrq->value = 5500000;
1288             break;
1289         case 11:
1290             rrq->value = 11000000;
1291             break;
1292         default:
1293             rrq->value = 0;
1294     }
1295     rrq->fixed = 0;
1296     rrq->disabled = 0;
1297 
1298     return 0;
1299 }
1300 
1301 static int zd1201_set_rts(struct net_device *dev, struct iw_request_info *info,
1302     struct iw_param *rts, char *extra)
1303 {
1304     struct zd1201 *zd = netdev_priv(dev);
1305     int err;
1306     short val = rts->value;
1307 
1308     if (rts->disabled || !rts->fixed)
1309         val = ZD1201_RTSMAX;
1310     if (val > ZD1201_RTSMAX)
1311         return -EINVAL;
1312     if (val < 0)
1313         return -EINVAL;
1314 
1315     err = zd1201_setconfig16(zd, ZD1201_RID_CNFRTSTHRESHOLD, val);
1316     if (err)
1317         return err;
1318     return zd1201_mac_reset(zd);
1319 }
1320 
1321 static int zd1201_get_rts(struct net_device *dev, struct iw_request_info *info,
1322     struct iw_param *rts, char *extra)
1323 {
1324     struct zd1201 *zd = netdev_priv(dev);
1325     short rtst;
1326     int err;
1327 
1328     err = zd1201_getconfig16(zd, ZD1201_RID_CNFRTSTHRESHOLD, &rtst);
1329     if (err)
1330         return err;
1331     rts->value = rtst;
1332     rts->disabled = (rts->value == ZD1201_RTSMAX);
1333     rts->fixed = 1;
1334 
1335     return 0;
1336 }
1337 
1338 static int zd1201_set_frag(struct net_device *dev, struct iw_request_info *info,
1339     struct iw_param *frag, char *extra)
1340 {
1341     struct zd1201 *zd = netdev_priv(dev);
1342     int err;
1343     short val = frag->value;
1344 
1345     if (frag->disabled || !frag->fixed)
1346         val = ZD1201_FRAGMAX;
1347     if (val > ZD1201_FRAGMAX)
1348         return -EINVAL;
1349     if (val < ZD1201_FRAGMIN)
1350         return -EINVAL;
1351     if (val & 1)
1352         return -EINVAL;
1353     err = zd1201_setconfig16(zd, ZD1201_RID_CNFFRAGTHRESHOLD, val);
1354     if (err)
1355         return err;
1356     return zd1201_mac_reset(zd);
1357 }
1358 
1359 static int zd1201_get_frag(struct net_device *dev, struct iw_request_info *info,
1360     struct iw_param *frag, char *extra)
1361 {
1362     struct zd1201 *zd = netdev_priv(dev);
1363     short fragt;
1364     int err;
1365 
1366     err = zd1201_getconfig16(zd, ZD1201_RID_CNFFRAGTHRESHOLD, &fragt);
1367     if (err)
1368         return err;
1369     frag->value = fragt;
1370     frag->disabled = (frag->value == ZD1201_FRAGMAX);
1371     frag->fixed = 1;
1372 
1373     return 0;
1374 }
1375 
1376 static int zd1201_set_retry(struct net_device *dev,
1377     struct iw_request_info *info, struct iw_param *rrq, char *extra)
1378 {
1379     return 0;
1380 }
1381 
1382 static int zd1201_get_retry(struct net_device *dev,
1383     struct iw_request_info *info, struct iw_param *rrq, char *extra)
1384 {
1385     return 0;
1386 }
1387 
1388 static int zd1201_set_encode(struct net_device *dev,
1389     struct iw_request_info *info, struct iw_point *erq, char *key)
1390 {
1391     struct zd1201 *zd = netdev_priv(dev);
1392     short i;
1393     int err, rid;
1394 
1395     if (erq->length > ZD1201_MAXKEYLEN)
1396         return -EINVAL;
1397 
1398     i = (erq->flags & IW_ENCODE_INDEX)-1;
1399     if (i == -1) {
1400         err = zd1201_getconfig16(zd,ZD1201_RID_CNFDEFAULTKEYID,&i);
1401         if (err)
1402             return err;
1403     } else {
1404         err = zd1201_setconfig16(zd, ZD1201_RID_CNFDEFAULTKEYID, i);
1405         if (err)
1406             return err;
1407     }
1408 
1409     if (i < 0 || i >= ZD1201_NUMKEYS)
1410         return -EINVAL;
1411 
1412     rid = ZD1201_RID_CNFDEFAULTKEY0 + i;
1413     err = zd1201_setconfig(zd, rid, key, erq->length, 1);
1414     if (err)
1415         return err;
1416     zd->encode_keylen[i] = erq->length;
1417     memcpy(zd->encode_keys[i], key, erq->length);
1418 
1419     i=0;
1420     if (!(erq->flags & IW_ENCODE_DISABLED & IW_ENCODE_MODE)) {
1421         i |= 0x01;
1422         zd->encode_enabled = 1;
1423     } else
1424         zd->encode_enabled = 0;
1425     if (erq->flags & IW_ENCODE_RESTRICTED & IW_ENCODE_MODE) {
1426         i |= 0x02;
1427         zd->encode_restricted = 1;
1428     } else
1429         zd->encode_restricted = 0;
1430     err = zd1201_setconfig16(zd, ZD1201_RID_CNFWEBFLAGS, i);
1431     if (err)
1432         return err;
1433 
1434     if (zd->encode_enabled)
1435         i = ZD1201_CNFAUTHENTICATION_SHAREDKEY;
1436     else
1437         i = ZD1201_CNFAUTHENTICATION_OPENSYSTEM;
1438     err = zd1201_setconfig16(zd, ZD1201_RID_CNFAUTHENTICATION, i);
1439     if (err)
1440         return err;
1441 
1442     return zd1201_mac_reset(zd);
1443 }
1444 
1445 static int zd1201_get_encode(struct net_device *dev,
1446     struct iw_request_info *info, struct iw_point *erq, char *key)
1447 {
1448     struct zd1201 *zd = netdev_priv(dev);
1449     short i;
1450     int err;
1451 
1452     if (zd->encode_enabled)
1453         erq->flags = IW_ENCODE_ENABLED;
1454     else
1455         erq->flags = IW_ENCODE_DISABLED;
1456     if (zd->encode_restricted)
1457         erq->flags |= IW_ENCODE_RESTRICTED;
1458     else
1459         erq->flags |= IW_ENCODE_OPEN;
1460 
1461     i = (erq->flags & IW_ENCODE_INDEX) -1;
1462     if (i == -1) {
1463         err = zd1201_getconfig16(zd, ZD1201_RID_CNFDEFAULTKEYID, &i);
1464         if (err)
1465             return err;
1466     }
1467     if (i<0 || i>= ZD1201_NUMKEYS)
1468         return -EINVAL;
1469 
1470     erq->flags |= i+1;
1471 
1472     erq->length = zd->encode_keylen[i];
1473     memcpy(key, zd->encode_keys[i], erq->length);
1474 
1475     return 0;
1476 }
1477 
1478 static int zd1201_set_power(struct net_device *dev, 
1479     struct iw_request_info *info, struct iw_param *vwrq, char *extra)
1480 {
1481     struct zd1201 *zd = netdev_priv(dev);
1482     short enabled, duration, level;
1483     int err;
1484 
1485     enabled = vwrq->disabled ? 0 : 1;
1486     if (enabled) {
1487         if (vwrq->flags & IW_POWER_PERIOD) {
1488             duration = vwrq->value;
1489             err = zd1201_setconfig16(zd, 
1490                 ZD1201_RID_CNFMAXSLEEPDURATION, duration);
1491             if (err)
1492                 return err;
1493             goto out;
1494         }
1495         if (vwrq->flags & IW_POWER_TIMEOUT) {
1496             err = zd1201_getconfig16(zd, 
1497                 ZD1201_RID_CNFMAXSLEEPDURATION, &duration);
1498             if (err)
1499                 return err;
1500             level = vwrq->value * 4 / duration;
1501             if (level > 4)
1502                 level = 4;
1503             if (level < 0)
1504                 level = 0;
1505             err = zd1201_setconfig16(zd, ZD1201_RID_CNFPMEPS,
1506                 level);
1507             if (err)
1508                 return err;
1509             goto out;
1510         }
1511         return -EINVAL;
1512     }
1513 out:
1514     return zd1201_setconfig16(zd, ZD1201_RID_CNFPMENABLED, enabled);
1515 }
1516 
1517 static int zd1201_get_power(struct net_device *dev,
1518     struct iw_request_info *info, struct iw_param *vwrq, char *extra)
1519 {
1520     struct zd1201 *zd = netdev_priv(dev);
1521     short enabled, level, duration;
1522     int err;
1523 
1524     err = zd1201_getconfig16(zd, ZD1201_RID_CNFPMENABLED, &enabled);
1525     if (err)
1526         return err;
1527     err = zd1201_getconfig16(zd, ZD1201_RID_CNFPMEPS, &level);
1528     if (err)
1529         return err;
1530     err = zd1201_getconfig16(zd, ZD1201_RID_CNFMAXSLEEPDURATION, &duration);
1531     if (err)
1532         return err;
1533     vwrq->disabled = enabled ? 0 : 1;
1534     if (vwrq->flags & IW_POWER_TYPE) {
1535         if (vwrq->flags & IW_POWER_PERIOD) {
1536             vwrq->value = duration;
1537             vwrq->flags = IW_POWER_PERIOD;
1538         } else {
1539             vwrq->value = duration * level / 4;
1540             vwrq->flags = IW_POWER_TIMEOUT;
1541         }
1542     }
1543     if (vwrq->flags & IW_POWER_MODE) {
1544         if (enabled && level)
1545             vwrq->flags = IW_POWER_UNICAST_R;
1546         else
1547             vwrq->flags = IW_POWER_ALL_R;
1548     }
1549 
1550     return 0;
1551 }
1552 
1553 
1554 static const iw_handler zd1201_iw_handler[] =
1555 {
1556     (iw_handler) zd1201_config_commit,  /* SIOCSIWCOMMIT */
1557     (iw_handler) zd1201_get_name,       /* SIOCGIWNAME */
1558     (iw_handler) NULL,          /* SIOCSIWNWID */
1559     (iw_handler) NULL,          /* SIOCGIWNWID */
1560     (iw_handler) zd1201_set_freq,       /* SIOCSIWFREQ */
1561     (iw_handler) zd1201_get_freq,       /* SIOCGIWFREQ */
1562     (iw_handler) zd1201_set_mode,       /* SIOCSIWMODE */
1563     (iw_handler) zd1201_get_mode,       /* SIOCGIWMODE */
1564     (iw_handler) NULL,                      /* SIOCSIWSENS */
1565     (iw_handler) NULL,                  /* SIOCGIWSENS */
1566     (iw_handler) NULL,          /* SIOCSIWRANGE */
1567     (iw_handler) zd1201_get_range,           /* SIOCGIWRANGE */
1568     (iw_handler) NULL,          /* SIOCSIWPRIV */
1569     (iw_handler) NULL,          /* SIOCGIWPRIV */
1570     (iw_handler) NULL,          /* SIOCSIWSTATS */
1571     (iw_handler) NULL,          /* SIOCGIWSTATS */
1572     (iw_handler) NULL,          /* SIOCSIWSPY */
1573     (iw_handler) NULL,          /* SIOCGIWSPY */
1574     (iw_handler) NULL,          /* -- hole -- */
1575     (iw_handler) NULL,          /* -- hole -- */
1576     (iw_handler) NULL/*zd1201_set_wap*/,        /* SIOCSIWAP */
1577     (iw_handler) zd1201_get_wap,        /* SIOCGIWAP */
1578     (iw_handler) NULL,          /* -- hole -- */
1579     (iw_handler) NULL,              /* SIOCGIWAPLIST */
1580     (iw_handler) zd1201_set_scan,       /* SIOCSIWSCAN */
1581     (iw_handler) zd1201_get_scan,       /* SIOCGIWSCAN */
1582     (iw_handler) zd1201_set_essid,      /* SIOCSIWESSID */
1583     (iw_handler) zd1201_get_essid,      /* SIOCGIWESSID */
1584     (iw_handler) NULL,              /* SIOCSIWNICKN */
1585     (iw_handler) zd1201_get_nick,       /* SIOCGIWNICKN */
1586     (iw_handler) NULL,          /* -- hole -- */
1587     (iw_handler) NULL,          /* -- hole -- */
1588     (iw_handler) zd1201_set_rate,       /* SIOCSIWRATE */
1589     (iw_handler) zd1201_get_rate,       /* SIOCGIWRATE */
1590     (iw_handler) zd1201_set_rts,        /* SIOCSIWRTS */
1591     (iw_handler) zd1201_get_rts,        /* SIOCGIWRTS */
1592     (iw_handler) zd1201_set_frag,       /* SIOCSIWFRAG */
1593     (iw_handler) zd1201_get_frag,       /* SIOCGIWFRAG */
1594     (iw_handler) NULL,              /* SIOCSIWTXPOW */
1595     (iw_handler) NULL,                  /* SIOCGIWTXPOW */
1596     (iw_handler) zd1201_set_retry,      /* SIOCSIWRETRY */
1597     (iw_handler) zd1201_get_retry,      /* SIOCGIWRETRY */
1598     (iw_handler) zd1201_set_encode,     /* SIOCSIWENCODE */
1599     (iw_handler) zd1201_get_encode,     /* SIOCGIWENCODE */
1600     (iw_handler) zd1201_set_power,      /* SIOCSIWPOWER */
1601     (iw_handler) zd1201_get_power,      /* SIOCGIWPOWER */
1602 };
1603 
1604 static int zd1201_set_hostauth(struct net_device *dev,
1605     struct iw_request_info *info, struct iw_param *rrq, char *extra)
1606 {
1607     struct zd1201 *zd = netdev_priv(dev);
1608 
1609     if (!zd->ap)
1610         return -EOPNOTSUPP;
1611 
1612     return zd1201_setconfig16(zd, ZD1201_RID_CNFHOSTAUTH, rrq->value);
1613 }
1614 
1615 static int zd1201_get_hostauth(struct net_device *dev,
1616     struct iw_request_info *info, struct iw_param *rrq, char *extra)
1617 {
1618     struct zd1201 *zd = netdev_priv(dev);
1619     short hostauth;
1620     int err;
1621 
1622     if (!zd->ap)
1623         return -EOPNOTSUPP;
1624 
1625     err = zd1201_getconfig16(zd, ZD1201_RID_CNFHOSTAUTH, &hostauth);
1626     if (err)
1627         return err;
1628     rrq->value = hostauth;
1629     rrq->fixed = 1;
1630 
1631     return 0;
1632 }
1633 
1634 static int zd1201_auth_sta(struct net_device *dev,
1635     struct iw_request_info *info, struct sockaddr *sta, char *extra)
1636 {
1637     struct zd1201 *zd = netdev_priv(dev);
1638     unsigned char buffer[10];
1639 
1640     if (!zd->ap)
1641         return -EOPNOTSUPP;
1642 
1643     memcpy(buffer, sta->sa_data, ETH_ALEN);
1644     *(short*)(buffer+6) = 0;    /* 0==success, 1==failure */
1645     *(short*)(buffer+8) = 0;
1646 
1647     return zd1201_setconfig(zd, ZD1201_RID_AUTHENTICATESTA, buffer, 10, 1);
1648 }
1649 
1650 static int zd1201_set_maxassoc(struct net_device *dev,
1651     struct iw_request_info *info, struct iw_param *rrq, char *extra)
1652 {
1653     struct zd1201 *zd = netdev_priv(dev);
1654 
1655     if (!zd->ap)
1656         return -EOPNOTSUPP;
1657 
1658     return zd1201_setconfig16(zd, ZD1201_RID_CNFMAXASSOCSTATIONS, rrq->value);
1659 }
1660 
1661 static int zd1201_get_maxassoc(struct net_device *dev,
1662     struct iw_request_info *info, struct iw_param *rrq, char *extra)
1663 {
1664     struct zd1201 *zd = netdev_priv(dev);
1665     short maxassoc;
1666     int err;
1667 
1668     if (!zd->ap)
1669         return -EOPNOTSUPP;
1670 
1671     err = zd1201_getconfig16(zd, ZD1201_RID_CNFMAXASSOCSTATIONS, &maxassoc);
1672     if (err)
1673         return err;
1674     rrq->value = maxassoc;
1675     rrq->fixed = 1;
1676 
1677     return 0;
1678 }
1679 
1680 static const iw_handler zd1201_private_handler[] = {
1681     (iw_handler) zd1201_set_hostauth,   /* ZD1201SIWHOSTAUTH */
1682     (iw_handler) zd1201_get_hostauth,   /* ZD1201GIWHOSTAUTH */
1683     (iw_handler) zd1201_auth_sta,       /* ZD1201SIWAUTHSTA */
1684     (iw_handler) NULL,          /* nothing to get */
1685     (iw_handler) zd1201_set_maxassoc,   /* ZD1201SIMAXASSOC */
1686     (iw_handler) zd1201_get_maxassoc,   /* ZD1201GIMAXASSOC */
1687 };
1688 
1689 static const struct iw_priv_args zd1201_private_args[] = {
1690     { ZD1201SIWHOSTAUTH, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1691         IW_PRIV_TYPE_NONE, "sethostauth" },
1692     { ZD1201GIWHOSTAUTH, IW_PRIV_TYPE_NONE,
1693         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethostauth" },
1694     { ZD1201SIWAUTHSTA, IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1,
1695         IW_PRIV_TYPE_NONE, "authstation" },
1696     { ZD1201SIWMAXASSOC, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1697         IW_PRIV_TYPE_NONE, "setmaxassoc" },
1698     { ZD1201GIWMAXASSOC, IW_PRIV_TYPE_NONE,
1699         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getmaxassoc" },
1700 };
1701 
1702 static const struct iw_handler_def zd1201_iw_handlers = {
1703     .num_standard       = ARRAY_SIZE(zd1201_iw_handler),
1704     .num_private        = ARRAY_SIZE(zd1201_private_handler),
1705     .num_private_args   = ARRAY_SIZE(zd1201_private_args),
1706     .standard       = (iw_handler *)zd1201_iw_handler,
1707     .private        = (iw_handler *)zd1201_private_handler,
1708     .private_args       = (struct iw_priv_args *) zd1201_private_args,
1709     .get_wireless_stats = zd1201_get_wireless_stats,
1710 };
1711 
1712 static const struct net_device_ops zd1201_netdev_ops = {
1713     .ndo_open       = zd1201_net_open,
1714     .ndo_stop       = zd1201_net_stop,
1715     .ndo_start_xmit     = zd1201_hard_start_xmit,
1716     .ndo_tx_timeout     = zd1201_tx_timeout,
1717     .ndo_set_rx_mode    = zd1201_set_multicast,
1718     .ndo_set_mac_address    = zd1201_set_mac_address,
1719     .ndo_validate_addr  = eth_validate_addr,
1720 };
1721 
1722 static int zd1201_probe(struct usb_interface *interface,
1723             const struct usb_device_id *id)
1724 {
1725     struct zd1201 *zd;
1726     struct net_device *dev;
1727     struct usb_device *usb;
1728     int err;
1729     short porttype;
1730     char buf[IW_ESSID_MAX_SIZE+2];
1731     u8 addr[ETH_ALEN];
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, addr, ETH_ALEN);
1783     if (err)
1784         goto err_start;
1785     eth_hw_addr_set(dev, addr);
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 
1815 err_start:
1816     /* Leave the device in reset state */
1817     zd1201_docmd(zd, ZD1201_CMDCODE_INIT, 0, 0, 0);
1818 err_zd:
1819     usb_free_urb(zd->tx_urb);
1820     usb_free_urb(zd->rx_urb);
1821     free_netdev(dev);
1822     return err;
1823 }
1824 
1825 static 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 
1858 static 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 
1873 static 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 
1895 static 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 
1905 module_usb_driver(zd1201_usb);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!