1/* 2 Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com> 3 <http://rt2x00.serialmonkey.com> 4 5 This program is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 2 of the License, or 8 (at your option) any later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; if not, write to the 17 Free Software Foundation, Inc., 18 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 19 */ 20 21/* 22 Module: rt2x00usb 23 Abstract: Data structures for the rt2x00usb module. 24 */ 25 26#ifndef RT2X00USB_H 27#define RT2X00USB_H 28 29#include <linux/usb.h> 30 31#define to_usb_device_intf(d) \ 32({ \ 33 struct usb_interface *intf = to_usb_interface(d); \ 34 interface_to_usbdev(intf); \ 35}) 36 37/* 38 * This variable should be used with the 39 * usb_driver structure initialization. 40 */ 41#define USB_DEVICE_DATA(__ops) .driver_info = (kernel_ulong_t)(__ops) 42 43/* 44 * For USB vendor requests we need to pass a timeout 45 * time in ms, for this we use the REGISTER_TIMEOUT, 46 * however when loading firmware a higher value is 47 * required. In that case we use the REGISTER_TIMEOUT_FIRMWARE. 48 */ 49#define REGISTER_TIMEOUT 500 50#define REGISTER_TIMEOUT_FIRMWARE 1000 51 52/** 53 * REGISTER_TIMEOUT16 - Determine the timeout for 16bit register access 54 * @__datalen: Data length 55 */ 56#define REGISTER_TIMEOUT16(__datalen) \ 57 ( REGISTER_TIMEOUT * ((__datalen) / sizeof(u16)) ) 58 59/** 60 * REGISTER_TIMEOUT32 - Determine the timeout for 32bit register access 61 * @__datalen: Data length 62 */ 63#define REGISTER_TIMEOUT32(__datalen) \ 64 ( REGISTER_TIMEOUT * ((__datalen) / sizeof(u32)) ) 65 66/* 67 * Cache size 68 */ 69#define CSR_CACHE_SIZE 64 70 71/* 72 * USB request types. 73 */ 74#define USB_VENDOR_REQUEST ( USB_TYPE_VENDOR | USB_RECIP_DEVICE ) 75#define USB_VENDOR_REQUEST_IN ( USB_DIR_IN | USB_VENDOR_REQUEST ) 76#define USB_VENDOR_REQUEST_OUT ( USB_DIR_OUT | USB_VENDOR_REQUEST ) 77 78/** 79 * enum rt2x00usb_vendor_request: USB vendor commands. 80 */ 81enum rt2x00usb_vendor_request { 82 USB_DEVICE_MODE = 1, 83 USB_SINGLE_WRITE = 2, 84 USB_SINGLE_READ = 3, 85 USB_MULTI_WRITE = 6, 86 USB_MULTI_READ = 7, 87 USB_EEPROM_WRITE = 8, 88 USB_EEPROM_READ = 9, 89 USB_LED_CONTROL = 10, /* RT73USB */ 90 USB_RX_CONTROL = 12, 91}; 92 93/** 94 * enum rt2x00usb_mode_offset: Device modes offset. 95 */ 96enum rt2x00usb_mode_offset { 97 USB_MODE_RESET = 1, 98 USB_MODE_UNPLUG = 2, 99 USB_MODE_FUNCTION = 3, 100 USB_MODE_TEST = 4, 101 USB_MODE_SLEEP = 7, /* RT73USB */ 102 USB_MODE_FIRMWARE = 8, /* RT73USB */ 103 USB_MODE_WAKEUP = 9, /* RT73USB */ 104}; 105 106/** 107 * rt2x00usb_vendor_request - Send register command to device 108 * @rt2x00dev: Pointer to &struct rt2x00_dev 109 * @request: USB vendor command (See &enum rt2x00usb_vendor_request) 110 * @requesttype: Request type &USB_VENDOR_REQUEST_* 111 * @offset: Register offset to perform action on 112 * @value: Value to write to device 113 * @buffer: Buffer where information will be read/written to by device 114 * @buffer_length: Size of &buffer 115 * @timeout: Operation timeout 116 * 117 * This is the main function to communicate with the device, 118 * the &buffer argument _must_ either be NULL or point to 119 * a buffer allocated by kmalloc. Failure to do so can lead 120 * to unexpected behavior depending on the architecture. 121 */ 122int rt2x00usb_vendor_request(struct rt2x00_dev *rt2x00dev, 123 const u8 request, const u8 requesttype, 124 const u16 offset, const u16 value, 125 void *buffer, const u16 buffer_length, 126 const int timeout); 127 128/** 129 * rt2x00usb_vendor_request_buff - Send register command to device (buffered) 130 * @rt2x00dev: Pointer to &struct rt2x00_dev 131 * @request: USB vendor command (See &enum rt2x00usb_vendor_request) 132 * @requesttype: Request type &USB_VENDOR_REQUEST_* 133 * @offset: Register offset to perform action on 134 * @buffer: Buffer where information will be read/written to by device 135 * @buffer_length: Size of &buffer 136 * @timeout: Operation timeout 137 * 138 * This function will use a previously with kmalloc allocated cache 139 * to communicate with the device. The contents of the buffer pointer 140 * will be copied to this cache when writing, or read from the cache 141 * when reading. 142 * Buffers send to &rt2x00usb_vendor_request _must_ be allocated with 143 * kmalloc. Hence the reason for using a previously allocated cache 144 * which has been allocated properly. 145 */ 146int rt2x00usb_vendor_request_buff(struct rt2x00_dev *rt2x00dev, 147 const u8 request, const u8 requesttype, 148 const u16 offset, void *buffer, 149 const u16 buffer_length, const int timeout); 150 151/** 152 * rt2x00usb_vendor_request_buff - Send register command to device (buffered) 153 * @rt2x00dev: Pointer to &struct rt2x00_dev 154 * @request: USB vendor command (See &enum rt2x00usb_vendor_request) 155 * @requesttype: Request type &USB_VENDOR_REQUEST_* 156 * @offset: Register offset to perform action on 157 * @buffer: Buffer where information will be read/written to by device 158 * @buffer_length: Size of &buffer 159 * @timeout: Operation timeout 160 * 161 * A version of &rt2x00usb_vendor_request_buff which must be called 162 * if the usb_cache_mutex is already held. 163 */ 164int rt2x00usb_vendor_req_buff_lock(struct rt2x00_dev *rt2x00dev, 165 const u8 request, const u8 requesttype, 166 const u16 offset, void *buffer, 167 const u16 buffer_length, const int timeout); 168 169/** 170 * rt2x00usb_vendor_request_sw - Send single register command to device 171 * @rt2x00dev: Pointer to &struct rt2x00_dev 172 * @request: USB vendor command (See &enum rt2x00usb_vendor_request) 173 * @offset: Register offset to perform action on 174 * @value: Value to write to device 175 * @timeout: Operation timeout 176 * 177 * Simple wrapper around rt2x00usb_vendor_request to write a single 178 * command to the device. Since we don't use the buffer argument we 179 * don't have to worry about kmalloc here. 180 */ 181static inline int rt2x00usb_vendor_request_sw(struct rt2x00_dev *rt2x00dev, 182 const u8 request, 183 const u16 offset, 184 const u16 value, 185 const int timeout) 186{ 187 return rt2x00usb_vendor_request(rt2x00dev, request, 188 USB_VENDOR_REQUEST_OUT, offset, 189 value, NULL, 0, timeout); 190} 191 192/** 193 * rt2x00usb_eeprom_read - Read eeprom from device 194 * @rt2x00dev: Pointer to &struct rt2x00_dev 195 * @eeprom: Pointer to eeprom array to store the information in 196 * @length: Number of bytes to read from the eeprom 197 * 198 * Simple wrapper around rt2x00usb_vendor_request to read the eeprom 199 * from the device. Note that the eeprom argument _must_ be allocated using 200 * kmalloc for correct handling inside the kernel USB layer. 201 */ 202static inline int rt2x00usb_eeprom_read(struct rt2x00_dev *rt2x00dev, 203 __le16 *eeprom, const u16 length) 204{ 205 return rt2x00usb_vendor_request(rt2x00dev, USB_EEPROM_READ, 206 USB_VENDOR_REQUEST_IN, 0, 0, 207 eeprom, length, 208 REGISTER_TIMEOUT16(length)); 209} 210 211/** 212 * rt2x00usb_register_read - Read 32bit register word 213 * @rt2x00dev: Device pointer, see &struct rt2x00_dev. 214 * @offset: Register offset 215 * @value: Pointer to where register contents should be stored 216 * 217 * This function is a simple wrapper for 32bit register access 218 * through rt2x00usb_vendor_request_buff(). 219 */ 220static inline void rt2x00usb_register_read(struct rt2x00_dev *rt2x00dev, 221 const unsigned int offset, 222 u32 *value) 223{ 224 __le32 reg; 225 rt2x00usb_vendor_request_buff(rt2x00dev, USB_MULTI_READ, 226 USB_VENDOR_REQUEST_IN, offset, 227 ®, sizeof(reg), REGISTER_TIMEOUT); 228 *value = le32_to_cpu(reg); 229} 230 231/** 232 * rt2x00usb_register_read_lock - Read 32bit register word 233 * @rt2x00dev: Device pointer, see &struct rt2x00_dev. 234 * @offset: Register offset 235 * @value: Pointer to where register contents should be stored 236 * 237 * This function is a simple wrapper for 32bit register access 238 * through rt2x00usb_vendor_req_buff_lock(). 239 */ 240static inline void rt2x00usb_register_read_lock(struct rt2x00_dev *rt2x00dev, 241 const unsigned int offset, 242 u32 *value) 243{ 244 __le32 reg; 245 rt2x00usb_vendor_req_buff_lock(rt2x00dev, USB_MULTI_READ, 246 USB_VENDOR_REQUEST_IN, offset, 247 ®, sizeof(reg), REGISTER_TIMEOUT); 248 *value = le32_to_cpu(reg); 249} 250 251/** 252 * rt2x00usb_register_multiread - Read 32bit register words 253 * @rt2x00dev: Device pointer, see &struct rt2x00_dev. 254 * @offset: Register offset 255 * @value: Pointer to where register contents should be stored 256 * @length: Length of the data 257 * 258 * This function is a simple wrapper for 32bit register access 259 * through rt2x00usb_vendor_request_buff(). 260 */ 261static inline void rt2x00usb_register_multiread(struct rt2x00_dev *rt2x00dev, 262 const unsigned int offset, 263 void *value, const u32 length) 264{ 265 rt2x00usb_vendor_request_buff(rt2x00dev, USB_MULTI_READ, 266 USB_VENDOR_REQUEST_IN, offset, 267 value, length, 268 REGISTER_TIMEOUT32(length)); 269} 270 271/** 272 * rt2x00usb_register_write - Write 32bit register word 273 * @rt2x00dev: Device pointer, see &struct rt2x00_dev. 274 * @offset: Register offset 275 * @value: Data which should be written 276 * 277 * This function is a simple wrapper for 32bit register access 278 * through rt2x00usb_vendor_request_buff(). 279 */ 280static inline void rt2x00usb_register_write(struct rt2x00_dev *rt2x00dev, 281 const unsigned int offset, 282 u32 value) 283{ 284 __le32 reg = cpu_to_le32(value); 285 rt2x00usb_vendor_request_buff(rt2x00dev, USB_MULTI_WRITE, 286 USB_VENDOR_REQUEST_OUT, offset, 287 ®, sizeof(reg), REGISTER_TIMEOUT); 288} 289 290/** 291 * rt2x00usb_register_write_lock - Write 32bit register word 292 * @rt2x00dev: Device pointer, see &struct rt2x00_dev. 293 * @offset: Register offset 294 * @value: Data which should be written 295 * 296 * This function is a simple wrapper for 32bit register access 297 * through rt2x00usb_vendor_req_buff_lock(). 298 */ 299static inline void rt2x00usb_register_write_lock(struct rt2x00_dev *rt2x00dev, 300 const unsigned int offset, 301 u32 value) 302{ 303 __le32 reg = cpu_to_le32(value); 304 rt2x00usb_vendor_req_buff_lock(rt2x00dev, USB_MULTI_WRITE, 305 USB_VENDOR_REQUEST_OUT, offset, 306 ®, sizeof(reg), REGISTER_TIMEOUT); 307} 308 309/** 310 * rt2x00usb_register_multiwrite - Write 32bit register words 311 * @rt2x00dev: Device pointer, see &struct rt2x00_dev. 312 * @offset: Register offset 313 * @value: Data which should be written 314 * @length: Length of the data 315 * 316 * This function is a simple wrapper for 32bit register access 317 * through rt2x00usb_vendor_request_buff(). 318 */ 319static inline void rt2x00usb_register_multiwrite(struct rt2x00_dev *rt2x00dev, 320 const unsigned int offset, 321 const void *value, 322 const u32 length) 323{ 324 rt2x00usb_vendor_request_buff(rt2x00dev, USB_MULTI_WRITE, 325 USB_VENDOR_REQUEST_OUT, offset, 326 (void *)value, length, 327 REGISTER_TIMEOUT32(length)); 328} 329 330/** 331 * rt2x00usb_regbusy_read - Read from register with busy check 332 * @rt2x00dev: Device pointer, see &struct rt2x00_dev. 333 * @offset: Register offset 334 * @field: Field to check if register is busy 335 * @reg: Pointer to where register contents should be stored 336 * 337 * This function will read the given register, and checks if the 338 * register is busy. If it is, it will sleep for a couple of 339 * microseconds before reading the register again. If the register 340 * is not read after a certain timeout, this function will return 341 * FALSE. 342 */ 343int rt2x00usb_regbusy_read(struct rt2x00_dev *rt2x00dev, 344 const unsigned int offset, 345 const struct rt2x00_field32 field, 346 u32 *reg); 347 348/* 349 * Radio handlers 350 */ 351void rt2x00usb_disable_radio(struct rt2x00_dev *rt2x00dev); 352 353/** 354 * struct queue_entry_priv_usb: Per entry USB specific information 355 * 356 * @urb: Urb structure used for device communication. 357 */ 358struct queue_entry_priv_usb { 359 struct urb *urb; 360}; 361 362/** 363 * struct queue_entry_priv_usb_bcn: Per TX entry USB specific information 364 * 365 * The first section should match &struct queue_entry_priv_usb exactly. 366 * rt2500usb can use this structure to send a guardian byte when working 367 * with beacons. 368 * 369 * @urb: Urb structure used for device communication. 370 * @guardian_data: Set to 0, used for sending the guardian data. 371 * @guardian_urb: Urb structure used to send the guardian data. 372 */ 373struct queue_entry_priv_usb_bcn { 374 struct urb *urb; 375 376 unsigned int guardian_data; 377 struct urb *guardian_urb; 378}; 379 380/** 381 * rt2x00usb_kick_tx_queue - Kick data queue 382 * @rt2x00dev: Pointer to &struct rt2x00_dev 383 * @qid: Data queue to kick 384 * 385 * This will walk through all entries of the queue and push all pending 386 * frames to the hardware as a single burst. 387 */ 388void rt2x00usb_kick_tx_queue(struct rt2x00_dev *rt2x00dev, 389 const enum data_queue_qid qid); 390 391/** 392 * rt2x00usb_kill_tx_queue - Kill data queue 393 * @rt2x00dev: Pointer to &struct rt2x00_dev 394 * @qid: Data queue to kill 395 * 396 * This will walk through all entries of the queue and kill all 397 * previously kicked frames before they can be send. 398 */ 399void rt2x00usb_kill_tx_queue(struct rt2x00_dev *rt2x00dev, 400 const enum data_queue_qid qid); 401 402/** 403 * rt2x00usb_watchdog - Watchdog for USB communication 404 * @rt2x00dev: Pointer to &struct rt2x00_dev 405 * 406 * Check the health of the USB communication and determine 407 * if timeouts have occured. If this is the case, this function 408 * will reset all communication to restore functionality again. 409 */ 410void rt2x00usb_watchdog(struct rt2x00_dev *rt2x00dev); 411 412/* 413 * Device initialization handlers. 414 */ 415void rt2x00usb_clear_entry(struct queue_entry *entry); 416int rt2x00usb_initialize(struct rt2x00_dev *rt2x00dev); 417void rt2x00usb_uninitialize(struct rt2x00_dev *rt2x00dev); 418 419/* 420 * USB driver handlers. 421 */ 422int rt2x00usb_probe(struct usb_interface *usb_intf, 423 const struct usb_device_id *id); 424void rt2x00usb_disconnect(struct usb_interface *usb_intf); 425#ifdef CONFIG_PM 426int rt2x00usb_suspend(struct usb_interface *usb_intf, pm_message_t state); 427int rt2x00usb_resume(struct usb_interface *usb_intf); 428#else 429#define rt2x00usb_suspend NULL 430#define rt2x00usb_resume NULL 431#endif /* CONFIG_PM */ 432 433#endif /* RT2X00USB_H */ 434