1/* ZD1211 USB-WLAN driver for Linux
2 *
3 * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
4 * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20#ifndef _ZD_USB_H
21#define _ZD_USB_H
22
23#include <linux/completion.h>
24#include <linux/netdevice.h>
25#include <linux/spinlock.h>
26#include <linux/skbuff.h>
27#include <linux/usb.h>
28
29#include "zd_def.h"
30
31#define ZD_USB_TX_HIGH  5
32#define ZD_USB_TX_LOW   2
33
34#define ZD_TX_TIMEOUT		(HZ * 5)
35#define ZD_TX_WATCHDOG_INTERVAL	round_jiffies_relative(HZ)
36#define ZD_RX_IDLE_INTERVAL	round_jiffies_relative(30 * HZ)
37
38enum devicetype {
39	DEVICE_ZD1211  = 0,
40	DEVICE_ZD1211B = 1,
41	DEVICE_INSTALLER = 2,
42};
43
44enum endpoints {
45	EP_CTRL	    = 0,
46	EP_DATA_OUT = 1,
47	EP_DATA_IN  = 2,
48	EP_INT_IN   = 3,
49	EP_REGS_OUT = 4,
50};
51
52enum {
53	USB_MAX_TRANSFER_SIZE		= 4096, /* bytes */
54	/* FIXME: The original driver uses this value. We have to check,
55	 * whether the MAX_TRANSFER_SIZE is sufficient and this needs only be
56	 * used if one combined frame is split over two USB transactions.
57	 */
58	USB_MAX_RX_SIZE			= 4800, /* bytes */
59	USB_MAX_IOWRITE16_COUNT		= 15,
60	USB_MAX_IOWRITE32_COUNT		= USB_MAX_IOWRITE16_COUNT/2,
61	USB_MAX_IOREAD16_COUNT		= 15,
62	USB_MAX_IOREAD32_COUNT		= USB_MAX_IOREAD16_COUNT/2,
63	USB_MIN_RFWRITE_BIT_COUNT	= 16,
64	USB_MAX_RFWRITE_BIT_COUNT	= 28,
65	USB_MAX_EP_INT_BUFFER		= 64,
66	USB_ZD1211B_BCD_DEVICE		= 0x4810,
67};
68
69enum control_requests {
70	USB_REQ_WRITE_REGS		= 0x21,
71	USB_REQ_READ_REGS		= 0x22,
72	USB_REQ_WRITE_RF		= 0x23,
73	USB_REQ_PROG_FLASH		= 0x24,
74	USB_REQ_EEPROM_START		= 0x0128, /* ? request is a byte */
75	USB_REQ_EEPROM_MID		= 0x28,
76	USB_REQ_EEPROM_END		= 0x0228, /* ? request is a byte */
77	USB_REQ_FIRMWARE_DOWNLOAD	= 0x30,
78	USB_REQ_FIRMWARE_CONFIRM	= 0x31,
79	USB_REQ_FIRMWARE_READ_DATA	= 0x32,
80};
81
82struct usb_req_read_regs {
83	__le16 id;
84	__le16 addr[0];
85} __packed;
86
87struct reg_data {
88	__le16 addr;
89	__le16 value;
90} __packed;
91
92struct usb_req_write_regs {
93	__le16 id;
94	struct reg_data reg_writes[0];
95} __packed;
96
97enum {
98	RF_IF_LE = 0x02,
99	RF_CLK   = 0x04,
100	RF_DATA	 = 0x08,
101};
102
103struct usb_req_rfwrite {
104	__le16 id;
105	__le16 value;
106	/* 1: 3683a */
107	/* 2: other (default) */
108	__le16 bits;
109	/* RF2595: 24 */
110	__le16 bit_values[0];
111	/* (ZD_CR203 & ~(RF_IF_LE | RF_CLK | RF_DATA)) | (bit ? RF_DATA : 0) */
112} __packed;
113
114/* USB interrupt */
115
116enum usb_int_id {
117	USB_INT_TYPE			= 0x01,
118	USB_INT_ID_REGS			= 0x90,
119	USB_INT_ID_RETRY_FAILED		= 0xa0,
120};
121
122enum usb_int_flags {
123	USB_INT_READ_REGS_EN		= 0x01,
124};
125
126struct usb_int_header {
127	u8 type;	/* must always be 1 */
128	u8 id;
129} __packed;
130
131struct usb_int_regs {
132	struct usb_int_header hdr;
133	struct reg_data regs[0];
134} __packed;
135
136struct usb_int_retry_fail {
137	struct usb_int_header hdr;
138	u8 new_rate;
139	u8 _dummy;
140	u8 addr[ETH_ALEN];
141	u8 ibss_wakeup_dest;
142} __packed;
143
144struct read_regs_int {
145	struct completion completion;
146	struct usb_req_read_regs *req;
147	unsigned int req_count;
148	/* Stores the USB int structure and contains the USB address of the
149	 * first requested register before request.
150	 */
151	u8 buffer[USB_MAX_EP_INT_BUFFER];
152	int length;
153	__le16 cr_int_addr;
154};
155
156struct zd_ioreq16 {
157	zd_addr_t addr;
158	u16 value;
159};
160
161struct zd_ioreq32 {
162	zd_addr_t addr;
163	u32 value;
164};
165
166struct zd_usb_interrupt {
167	struct read_regs_int read_regs;
168	spinlock_t lock;
169	struct urb *urb;
170	void *buffer;
171	dma_addr_t buffer_dma;
172	int interval;
173	atomic_t read_regs_enabled;
174	u8 read_regs_int_overridden:1;
175};
176
177static inline struct usb_int_regs *get_read_regs(struct zd_usb_interrupt *intr)
178{
179	return (struct usb_int_regs *)intr->read_regs.buffer;
180}
181
182#define RX_URBS_COUNT 5
183
184struct zd_usb_rx {
185	spinlock_t lock;
186	struct mutex setup_mutex;
187	struct delayed_work idle_work;
188	struct tasklet_struct reset_timer_tasklet;
189	u8 fragment[2 * USB_MAX_RX_SIZE];
190	unsigned int fragment_length;
191	unsigned int usb_packet_size;
192	struct urb **urbs;
193	int urbs_count;
194};
195
196/**
197 * struct zd_usb_tx - structure used for transmitting frames
198 * @enabled: atomic enabled flag, indicates whether tx is enabled
199 * @lock: lock for transmission
200 * @submitted: anchor for URBs sent to device
201 * @submitted_urbs: atomic integer that counts the URBs having sent to the
202 *	device, which haven't been completed
203 * @stopped: indicates whether higher level tx queues are stopped
204 */
205struct zd_usb_tx {
206	atomic_t enabled;
207	spinlock_t lock;
208	struct delayed_work watchdog_work;
209	struct sk_buff_head submitted_skbs;
210	struct usb_anchor submitted;
211	int submitted_urbs;
212	u8 stopped:1, watchdog_enabled:1;
213};
214
215/* Contains the usb parts. The structure doesn't require a lock because intf
216 * will not be changed after initialization.
217 */
218struct zd_usb {
219	struct zd_usb_interrupt intr;
220	struct zd_usb_rx rx;
221	struct zd_usb_tx tx;
222	struct usb_interface *intf;
223	struct usb_anchor submitted_cmds;
224	struct urb *urb_async_waiting;
225	int cmd_error;
226	u8 req_buf[64]; /* zd_usb_iowrite16v needs 62 bytes */
227	u8 is_zd1211b:1, initialized:1, was_running:1, in_async:1;
228};
229
230#define zd_usb_dev(usb) (&usb->intf->dev)
231
232static inline struct usb_device *zd_usb_to_usbdev(struct zd_usb *usb)
233{
234	return interface_to_usbdev(usb->intf);
235}
236
237static inline struct ieee80211_hw *zd_intf_to_hw(struct usb_interface *intf)
238{
239	return usb_get_intfdata(intf);
240}
241
242static inline struct ieee80211_hw *zd_usb_to_hw(struct zd_usb *usb)
243{
244	return zd_intf_to_hw(usb->intf);
245}
246
247void zd_usb_init(struct zd_usb *usb, struct ieee80211_hw *hw,
248	         struct usb_interface *intf);
249int zd_usb_init_hw(struct zd_usb *usb);
250void zd_usb_clear(struct zd_usb *usb);
251
252int zd_usb_scnprint_id(struct zd_usb *usb, char *buffer, size_t size);
253
254void zd_tx_watchdog_enable(struct zd_usb *usb);
255void zd_tx_watchdog_disable(struct zd_usb *usb);
256
257int zd_usb_enable_int(struct zd_usb *usb);
258void zd_usb_disable_int(struct zd_usb *usb);
259
260int zd_usb_enable_rx(struct zd_usb *usb);
261void zd_usb_disable_rx(struct zd_usb *usb);
262
263void zd_usb_reset_rx_idle_timer(struct zd_usb *usb);
264
265void zd_usb_enable_tx(struct zd_usb *usb);
266void zd_usb_disable_tx(struct zd_usb *usb);
267
268int zd_usb_tx(struct zd_usb *usb, struct sk_buff *skb);
269
270int zd_usb_ioread16v(struct zd_usb *usb, u16 *values,
271	         const zd_addr_t *addresses, unsigned int count);
272
273static inline int zd_usb_ioread16(struct zd_usb *usb, u16 *value,
274	                      const zd_addr_t addr)
275{
276	return zd_usb_ioread16v(usb, value, &addr, 1);
277}
278
279void zd_usb_iowrite16v_async_start(struct zd_usb *usb);
280int zd_usb_iowrite16v_async_end(struct zd_usb *usb, unsigned int timeout);
281int zd_usb_iowrite16v_async(struct zd_usb *usb, const struct zd_ioreq16 *ioreqs,
282			    unsigned int count);
283int zd_usb_iowrite16v(struct zd_usb *usb, const struct zd_ioreq16 *ioreqs,
284	              unsigned int count);
285
286int zd_usb_rfwrite(struct zd_usb *usb, u32 value, u8 bits);
287
288int zd_usb_read_fw(struct zd_usb *usb, zd_addr_t addr, u8 *data, u16 len);
289
290extern struct workqueue_struct *zd_workqueue;
291
292#endif /* _ZD_USB_H */
293