PageRenderTime 125ms CodeModel.GetById 21ms app.highlight 91ms RepoModel.GetById 2ms app.codeStats 0ms

/drivers/net/wireless/zd1201.c

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