Loading...
1/*
2 * Copyright (c) 2014 Redpine Signals Inc.
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 *
16 */
17
18#include <linux/module.h>
19#include <linux/types.h>
20#include <net/rsi_91x.h>
21#include "rsi_usb.h"
22#include "rsi_hal.h"
23#include "rsi_coex.h"
24
25/* Default operating mode is wlan STA + BT */
26static u16 dev_oper_mode = DEV_OPMODE_STA_BT_DUAL;
27module_param(dev_oper_mode, ushort, 0444);
28MODULE_PARM_DESC(dev_oper_mode, DEV_OPMODE_PARAM_DESC);
29
30static int rsi_rx_urb_submit(struct rsi_hw *adapter, u8 ep_num, gfp_t flags);
31
32/**
33 * rsi_usb_card_write() - This function writes to the USB Card.
34 * @adapter: Pointer to the adapter structure.
35 * @buf: Pointer to the buffer from where the data has to be taken.
36 * @len: Length to be written.
37 * @endpoint: Type of endpoint.
38 *
39 * Return: status: 0 on success, a negative error code on failure.
40 */
41static int rsi_usb_card_write(struct rsi_hw *adapter,
42 u8 *buf,
43 u16 len,
44 u8 endpoint)
45{
46 struct rsi_91x_usbdev *dev = adapter->rsi_dev;
47 int status;
48 u8 *seg = dev->tx_buffer;
49 int transfer;
50 int ep = dev->bulkout_endpoint_addr[endpoint - 1];
51
52 memset(seg, 0, len + RSI_USB_TX_HEAD_ROOM);
53 memcpy(seg + RSI_USB_TX_HEAD_ROOM, buf, len);
54 len += RSI_USB_TX_HEAD_ROOM;
55 transfer = len;
56 status = usb_bulk_msg(dev->usbdev,
57 usb_sndbulkpipe(dev->usbdev, ep),
58 (void *)seg,
59 (int)len,
60 &transfer,
61 USB_CTRL_SET_TIMEOUT);
62
63 if (status < 0) {
64 rsi_dbg(ERR_ZONE,
65 "Card write failed with error code :%10d\n", status);
66 dev->write_fail = 1;
67 }
68 return status;
69}
70
71/**
72 * rsi_write_multiple() - This function writes multiple bytes of information
73 * to the USB card.
74 * @adapter: Pointer to the adapter structure.
75 * @endpoint: Type of endpoint.
76 * @data: Pointer to the data that has to be written.
77 * @count: Number of multiple bytes to be written.
78 *
79 * Return: 0 on success, a negative error code on failure.
80 */
81static int rsi_write_multiple(struct rsi_hw *adapter,
82 u8 endpoint,
83 u8 *data,
84 u32 count)
85{
86 struct rsi_91x_usbdev *dev;
87
88 if (!adapter)
89 return -ENODEV;
90
91 if (endpoint == 0)
92 return -EINVAL;
93
94 dev = adapter->rsi_dev;
95 if (dev->write_fail)
96 return -ENETDOWN;
97
98 return rsi_usb_card_write(adapter, data, count, endpoint);
99}
100
101/**
102 * rsi_find_bulk_in_and_out_endpoints() - This function initializes the bulk
103 * endpoints to the device.
104 * @interface: Pointer to the USB interface structure.
105 * @adapter: Pointer to the adapter structure.
106 *
107 * Return: ret_val: 0 on success, -ENOMEM on failure.
108 */
109static int rsi_find_bulk_in_and_out_endpoints(struct usb_interface *interface,
110 struct rsi_hw *adapter)
111{
112 struct rsi_91x_usbdev *dev = adapter->rsi_dev;
113 struct usb_host_interface *iface_desc;
114 struct usb_endpoint_descriptor *endpoint;
115 __le16 buffer_size;
116 int ii, bin_found = 0, bout_found = 0;
117
118 iface_desc = interface->cur_altsetting;
119
120 for (ii = 0; ii < iface_desc->desc.bNumEndpoints; ++ii) {
121 endpoint = &(iface_desc->endpoint[ii].desc);
122
123 if (!dev->bulkin_endpoint_addr[bin_found] &&
124 (endpoint->bEndpointAddress & USB_DIR_IN) &&
125 ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
126 USB_ENDPOINT_XFER_BULK)) {
127 buffer_size = endpoint->wMaxPacketSize;
128 dev->bulkin_size[bin_found] = buffer_size;
129 dev->bulkin_endpoint_addr[bin_found] =
130 endpoint->bEndpointAddress;
131 bin_found++;
132 }
133
134 if (!dev->bulkout_endpoint_addr[bout_found] &&
135 !(endpoint->bEndpointAddress & USB_DIR_IN) &&
136 ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
137 USB_ENDPOINT_XFER_BULK)) {
138 buffer_size = endpoint->wMaxPacketSize;
139 dev->bulkout_endpoint_addr[bout_found] =
140 endpoint->bEndpointAddress;
141 dev->bulkout_size[bout_found] = buffer_size;
142 bout_found++;
143 }
144
145 if (bin_found >= MAX_BULK_EP || bout_found >= MAX_BULK_EP)
146 break;
147 }
148
149 if (!(dev->bulkin_endpoint_addr[0] && dev->bulkout_endpoint_addr[0])) {
150 dev_err(&interface->dev, "missing wlan bulk endpoints\n");
151 return -EINVAL;
152 }
153
154 if (adapter->priv->coex_mode > 1) {
155 if (!dev->bulkin_endpoint_addr[1]) {
156 dev_err(&interface->dev, "missing bt bulk-in endpoint\n");
157 return -EINVAL;
158 }
159 }
160
161 return 0;
162}
163
164#define RSI_USB_REQ_OUT (USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE)
165#define RSI_USB_REQ_IN (USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE)
166
167/* rsi_usb_reg_read() - This function reads data from given register address.
168 * @usbdev: Pointer to the usb_device structure.
169 * @reg: Address of the register to be read.
170 * @value: Value to be read.
171 * @len: length of data to be read.
172 *
173 * Return: status: 0 on success, a negative error code on failure.
174 */
175static int rsi_usb_reg_read(struct usb_device *usbdev,
176 u32 reg,
177 u16 *value,
178 u16 len)
179{
180 u8 *buf;
181 int status = -ENOMEM;
182
183 if (len > RSI_USB_CTRL_BUF_SIZE)
184 return -EINVAL;
185
186 buf = kmalloc(RSI_USB_CTRL_BUF_SIZE, GFP_KERNEL);
187 if (!buf)
188 return status;
189
190 status = usb_control_msg(usbdev,
191 usb_rcvctrlpipe(usbdev, 0),
192 USB_VENDOR_REGISTER_READ,
193 RSI_USB_REQ_IN,
194 ((reg & 0xffff0000) >> 16), (reg & 0xffff),
195 (void *)buf,
196 len,
197 USB_CTRL_GET_TIMEOUT);
198
199 *value = (buf[0] | (buf[1] << 8));
200 if (status < 0) {
201 rsi_dbg(ERR_ZONE,
202 "%s: Reg read failed with error code :%d\n",
203 __func__, status);
204 }
205 kfree(buf);
206
207 return status;
208}
209
210/**
211 * rsi_usb_reg_write() - This function writes the given data into the given
212 * register address.
213 * @usbdev: Pointer to the usb_device structure.
214 * @reg: Address of the register.
215 * @value: Value to write.
216 * @len: Length of data to be written.
217 *
218 * Return: status: 0 on success, a negative error code on failure.
219 */
220static int rsi_usb_reg_write(struct usb_device *usbdev,
221 u32 reg,
222 u32 value,
223 u16 len)
224{
225 u8 *usb_reg_buf;
226 int status = -ENOMEM;
227
228 if (len > RSI_USB_CTRL_BUF_SIZE)
229 return -EINVAL;
230
231 usb_reg_buf = kmalloc(RSI_USB_CTRL_BUF_SIZE, GFP_KERNEL);
232 if (!usb_reg_buf)
233 return status;
234
235 usb_reg_buf[0] = (cpu_to_le32(value) & 0x00ff);
236 usb_reg_buf[1] = (cpu_to_le32(value) & 0xff00) >> 8;
237 usb_reg_buf[2] = (cpu_to_le32(value) & 0x00ff0000) >> 16;
238 usb_reg_buf[3] = (cpu_to_le32(value) & 0xff000000) >> 24;
239
240 status = usb_control_msg(usbdev,
241 usb_sndctrlpipe(usbdev, 0),
242 USB_VENDOR_REGISTER_WRITE,
243 RSI_USB_REQ_OUT,
244 ((cpu_to_le32(reg) & 0xffff0000) >> 16),
245 (cpu_to_le32(reg) & 0xffff),
246 (void *)usb_reg_buf,
247 len,
248 USB_CTRL_SET_TIMEOUT);
249 if (status < 0) {
250 rsi_dbg(ERR_ZONE,
251 "%s: Reg write failed with error code :%d\n",
252 __func__, status);
253 }
254 kfree(usb_reg_buf);
255
256 return status;
257}
258
259/**
260 * rsi_rx_done_handler() - This function is called when a packet is received
261 * from USB stack. This is callback to receive done.
262 * @urb: Received URB.
263 *
264 * Return: None.
265 */
266static void rsi_rx_done_handler(struct urb *urb)
267{
268 struct rx_usb_ctrl_block *rx_cb = urb->context;
269 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)rx_cb->data;
270 int status = -EINVAL;
271
272 if (!rx_cb->rx_skb)
273 return;
274
275 if (urb->status) {
276 dev_kfree_skb(rx_cb->rx_skb);
277 rx_cb->rx_skb = NULL;
278 return;
279 }
280
281 if (urb->actual_length <= 0 ||
282 urb->actual_length > rx_cb->rx_skb->len) {
283 rsi_dbg(INFO_ZONE, "%s: Invalid packet length = %d\n",
284 __func__, urb->actual_length);
285 goto out;
286 }
287 if (skb_queue_len(&dev->rx_q) >= RSI_MAX_RX_PKTS) {
288 rsi_dbg(INFO_ZONE, "Max RX packets reached\n");
289 goto out;
290 }
291 skb_trim(rx_cb->rx_skb, urb->actual_length);
292 skb_queue_tail(&dev->rx_q, rx_cb->rx_skb);
293
294 rsi_set_event(&dev->rx_thread.event);
295 status = 0;
296
297out:
298 if (rsi_rx_urb_submit(dev->priv, rx_cb->ep_num, GFP_ATOMIC))
299 rsi_dbg(ERR_ZONE, "%s: Failed in urb submission", __func__);
300
301 if (status) {
302 dev_kfree_skb(rx_cb->rx_skb);
303 rx_cb->rx_skb = NULL;
304 }
305}
306
307static void rsi_rx_urb_kill(struct rsi_hw *adapter, u8 ep_num)
308{
309 struct rsi_91x_usbdev *dev = adapter->rsi_dev;
310 struct rx_usb_ctrl_block *rx_cb = &dev->rx_cb[ep_num - 1];
311 struct urb *urb = rx_cb->rx_urb;
312
313 usb_kill_urb(urb);
314}
315
316/**
317 * rsi_rx_urb_submit() - This function submits the given URB to the USB stack.
318 * @adapter: Pointer to the adapter structure.
319 * @ep_num: Endpoint number.
320 * @mem_flags: The type of memory to allocate.
321 *
322 * Return: 0 on success, a negative error code on failure.
323 */
324static int rsi_rx_urb_submit(struct rsi_hw *adapter, u8 ep_num, gfp_t mem_flags)
325{
326 struct rsi_91x_usbdev *dev = adapter->rsi_dev;
327 struct rx_usb_ctrl_block *rx_cb = &dev->rx_cb[ep_num - 1];
328 struct urb *urb = rx_cb->rx_urb;
329 int status;
330 struct sk_buff *skb;
331 u8 dword_align_bytes = 0;
332
333 skb = dev_alloc_skb(RSI_MAX_RX_USB_PKT_SIZE);
334 if (!skb)
335 return -ENOMEM;
336 skb_reserve(skb, MAX_DWORD_ALIGN_BYTES);
337 skb_put(skb, RSI_MAX_RX_USB_PKT_SIZE - MAX_DWORD_ALIGN_BYTES);
338 dword_align_bytes = (unsigned long)skb->data & 0x3f;
339 if (dword_align_bytes > 0)
340 skb_push(skb, dword_align_bytes);
341 urb->transfer_buffer = skb->data;
342 rx_cb->rx_skb = skb;
343
344 usb_fill_bulk_urb(urb,
345 dev->usbdev,
346 usb_rcvbulkpipe(dev->usbdev,
347 dev->bulkin_endpoint_addr[ep_num - 1]),
348 urb->transfer_buffer,
349 skb->len,
350 rsi_rx_done_handler,
351 rx_cb);
352
353 status = usb_submit_urb(urb, mem_flags);
354 if (status) {
355 rsi_dbg(ERR_ZONE, "%s: Failed in urb submission\n", __func__);
356 dev_kfree_skb(skb);
357 }
358
359 return status;
360}
361
362static int rsi_usb_read_register_multiple(struct rsi_hw *adapter, u32 addr,
363 u8 *data, u16 count)
364{
365 struct rsi_91x_usbdev *dev = adapter->rsi_dev;
366 u8 *buf;
367 u16 transfer;
368 int status;
369
370 if (!addr)
371 return -EINVAL;
372
373 buf = kzalloc(RSI_USB_BUF_SIZE, GFP_KERNEL);
374 if (!buf)
375 return -ENOMEM;
376
377 while (count) {
378 transfer = min_t(u16, count, RSI_USB_BUF_SIZE);
379 status = usb_control_msg(dev->usbdev,
380 usb_rcvctrlpipe(dev->usbdev, 0),
381 USB_VENDOR_REGISTER_READ,
382 RSI_USB_REQ_IN,
383 ((addr & 0xffff0000) >> 16),
384 (addr & 0xffff), (void *)buf,
385 transfer, USB_CTRL_GET_TIMEOUT);
386 if (status < 0) {
387 rsi_dbg(ERR_ZONE,
388 "Reg read failed with error code :%d\n",
389 status);
390 kfree(buf);
391 return status;
392 }
393 memcpy(data, buf, transfer);
394 count -= transfer;
395 data += transfer;
396 addr += transfer;
397 }
398 kfree(buf);
399 return 0;
400}
401
402/**
403 * rsi_usb_write_register_multiple() - This function writes multiple bytes of
404 * information to multiple registers.
405 * @adapter: Pointer to the adapter structure.
406 * @addr: Address of the register.
407 * @data: Pointer to the data that has to be written.
408 * @count: Number of multiple bytes to be written on to the registers.
409 *
410 * Return: status: 0 on success, a negative error code on failure.
411 */
412static int rsi_usb_write_register_multiple(struct rsi_hw *adapter, u32 addr,
413 u8 *data, u16 count)
414{
415 struct rsi_91x_usbdev *dev = adapter->rsi_dev;
416 u8 *buf;
417 u16 transfer;
418 int status = 0;
419
420 buf = kzalloc(RSI_USB_BUF_SIZE, GFP_KERNEL);
421 if (!buf)
422 return -ENOMEM;
423
424 while (count) {
425 transfer = min_t(u16, count, RSI_USB_BUF_SIZE);
426 memcpy(buf, data, transfer);
427 status = usb_control_msg(dev->usbdev,
428 usb_sndctrlpipe(dev->usbdev, 0),
429 USB_VENDOR_REGISTER_WRITE,
430 RSI_USB_REQ_OUT,
431 ((addr & 0xffff0000) >> 16),
432 (addr & 0xffff),
433 (void *)buf,
434 transfer,
435 USB_CTRL_SET_TIMEOUT);
436 if (status < 0) {
437 rsi_dbg(ERR_ZONE,
438 "Reg write failed with error code :%d\n",
439 status);
440 kfree(buf);
441 return status;
442 }
443 count -= transfer;
444 data += transfer;
445 addr += transfer;
446 }
447
448 kfree(buf);
449 return 0;
450}
451
452/**
453 *rsi_usb_host_intf_write_pkt() - This function writes the packet to the
454 * USB card.
455 * @adapter: Pointer to the adapter structure.
456 * @pkt: Pointer to the data to be written on to the card.
457 * @len: Length of the data to be written on to the card.
458 *
459 * Return: 0 on success, a negative error code on failure.
460 */
461static int rsi_usb_host_intf_write_pkt(struct rsi_hw *adapter,
462 u8 *pkt,
463 u32 len)
464{
465 u32 queueno = ((pkt[1] >> 4) & 0x7);
466 u8 endpoint;
467
468 endpoint = ((queueno == RSI_WIFI_MGMT_Q || queueno == RSI_WIFI_DATA_Q ||
469 queueno == RSI_COEX_Q) ? WLAN_EP : BT_EP);
470
471 return rsi_write_multiple(adapter,
472 endpoint,
473 (u8 *)pkt,
474 len);
475}
476
477static int rsi_usb_master_reg_read(struct rsi_hw *adapter, u32 reg,
478 u32 *value, u16 len)
479{
480 struct usb_device *usbdev =
481 ((struct rsi_91x_usbdev *)adapter->rsi_dev)->usbdev;
482 u16 temp;
483 int ret;
484
485 ret = rsi_usb_reg_read(usbdev, reg, &temp, len);
486 if (ret < 0)
487 return ret;
488 *value = temp;
489
490 return 0;
491}
492
493static int rsi_usb_master_reg_write(struct rsi_hw *adapter,
494 unsigned long reg,
495 unsigned long value, u16 len)
496{
497 struct usb_device *usbdev =
498 ((struct rsi_91x_usbdev *)adapter->rsi_dev)->usbdev;
499
500 return rsi_usb_reg_write(usbdev, reg, value, len);
501}
502
503static int rsi_usb_load_data_master_write(struct rsi_hw *adapter,
504 u32 base_address,
505 u32 instructions_sz, u16 block_size,
506 u8 *ta_firmware)
507{
508 u16 num_blocks;
509 u32 cur_indx, i;
510 u8 temp_buf[256];
511 int status;
512
513 num_blocks = instructions_sz / block_size;
514 rsi_dbg(INFO_ZONE, "num_blocks: %d\n", num_blocks);
515
516 for (cur_indx = 0, i = 0; i < num_blocks; i++, cur_indx += block_size) {
517 memcpy(temp_buf, ta_firmware + cur_indx, block_size);
518 status = rsi_usb_write_register_multiple(adapter, base_address,
519 (u8 *)(temp_buf),
520 block_size);
521 if (status < 0)
522 return status;
523
524 rsi_dbg(INFO_ZONE, "%s: loading block: %d\n", __func__, i);
525 base_address += block_size;
526 }
527
528 if (instructions_sz % block_size) {
529 memset(temp_buf, 0, block_size);
530 memcpy(temp_buf, ta_firmware + cur_indx,
531 instructions_sz % block_size);
532 status = rsi_usb_write_register_multiple
533 (adapter, base_address,
534 (u8 *)temp_buf,
535 instructions_sz % block_size);
536 if (status < 0)
537 return status;
538 rsi_dbg(INFO_ZONE,
539 "Written Last Block in Address 0x%x Successfully\n",
540 cur_indx);
541 }
542 return 0;
543}
544
545static struct rsi_host_intf_ops usb_host_intf_ops = {
546 .write_pkt = rsi_usb_host_intf_write_pkt,
547 .read_reg_multiple = rsi_usb_read_register_multiple,
548 .write_reg_multiple = rsi_usb_write_register_multiple,
549 .master_reg_read = rsi_usb_master_reg_read,
550 .master_reg_write = rsi_usb_master_reg_write,
551 .load_data_master_write = rsi_usb_load_data_master_write,
552};
553
554/**
555 * rsi_deinit_usb_interface() - This function deinitializes the usb interface.
556 * @adapter: Pointer to the adapter structure.
557 *
558 * Return: None.
559 */
560static void rsi_deinit_usb_interface(struct rsi_hw *adapter)
561{
562 struct rsi_91x_usbdev *dev = adapter->rsi_dev;
563
564 rsi_kill_thread(&dev->rx_thread);
565
566 usb_free_urb(dev->rx_cb[0].rx_urb);
567 if (adapter->priv->coex_mode > 1)
568 usb_free_urb(dev->rx_cb[1].rx_urb);
569
570 kfree(dev->tx_buffer);
571}
572
573static int rsi_usb_init_rx(struct rsi_hw *adapter)
574{
575 struct rsi_91x_usbdev *dev = adapter->rsi_dev;
576 struct rx_usb_ctrl_block *rx_cb;
577 u8 idx, num_rx_cb;
578
579 num_rx_cb = (adapter->priv->coex_mode > 1 ? 2 : 1);
580
581 for (idx = 0; idx < num_rx_cb; idx++) {
582 rx_cb = &dev->rx_cb[idx];
583
584 rx_cb->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
585 if (!rx_cb->rx_urb) {
586 rsi_dbg(ERR_ZONE, "Failed alloc rx urb[%d]\n", idx);
587 goto err;
588 }
589 rx_cb->ep_num = idx + 1;
590 rx_cb->data = (void *)dev;
591 }
592 skb_queue_head_init(&dev->rx_q);
593 rsi_init_event(&dev->rx_thread.event);
594 if (rsi_create_kthread(adapter->priv, &dev->rx_thread,
595 rsi_usb_rx_thread, "RX-Thread")) {
596 rsi_dbg(ERR_ZONE, "%s: Unable to init rx thrd\n", __func__);
597 goto err;
598 }
599
600 return 0;
601
602err:
603 usb_free_urb(dev->rx_cb[0].rx_urb);
604 if (adapter->priv->coex_mode > 1)
605 usb_free_urb(dev->rx_cb[1].rx_urb);
606
607 return -1;
608}
609
610/**
611 * rsi_init_usb_interface() - This function initializes the usb interface.
612 * @adapter: Pointer to the adapter structure.
613 * @pfunction: Pointer to USB interface structure.
614 *
615 * Return: 0 on success, a negative error code on failure.
616 */
617static int rsi_init_usb_interface(struct rsi_hw *adapter,
618 struct usb_interface *pfunction)
619{
620 struct rsi_91x_usbdev *rsi_dev;
621 int status;
622
623 rsi_dev = kzalloc(sizeof(*rsi_dev), GFP_KERNEL);
624 if (!rsi_dev)
625 return -ENOMEM;
626
627 adapter->rsi_dev = rsi_dev;
628 rsi_dev->usbdev = interface_to_usbdev(pfunction);
629 rsi_dev->priv = (void *)adapter;
630
631 if (rsi_find_bulk_in_and_out_endpoints(pfunction, adapter)) {
632 status = -EINVAL;
633 goto fail_eps;
634 }
635
636 adapter->device = &pfunction->dev;
637 usb_set_intfdata(pfunction, adapter);
638
639 rsi_dev->tx_buffer = kmalloc(2048, GFP_KERNEL);
640 if (!rsi_dev->tx_buffer) {
641 status = -ENOMEM;
642 goto fail_eps;
643 }
644
645 if (rsi_usb_init_rx(adapter)) {
646 rsi_dbg(ERR_ZONE, "Failed to init RX handle\n");
647 status = -ENOMEM;
648 goto fail_rx;
649 }
650
651 rsi_dev->tx_blk_size = 252;
652 adapter->block_size = rsi_dev->tx_blk_size;
653
654 /* Initializing function callbacks */
655 adapter->check_hw_queue_status = rsi_usb_check_queue_status;
656 adapter->determine_event_timeout = rsi_usb_event_timeout;
657 adapter->rsi_host_intf = RSI_HOST_INTF_USB;
658 adapter->host_intf_ops = &usb_host_intf_ops;
659
660#ifdef CONFIG_RSI_DEBUGFS
661 /* In USB, one less than the MAX_DEBUGFS_ENTRIES entries is required */
662 adapter->num_debugfs_entries = (MAX_DEBUGFS_ENTRIES - 1);
663#endif
664
665 rsi_dbg(INIT_ZONE, "%s: Enabled the interface\n", __func__);
666 return 0;
667
668fail_rx:
669 kfree(rsi_dev->tx_buffer);
670
671fail_eps:
672
673 return status;
674}
675
676static int usb_ulp_read_write(struct rsi_hw *adapter, u16 addr, u32 data,
677 u16 len_in_bits)
678{
679 int ret;
680
681 ret = rsi_usb_master_reg_write
682 (adapter, RSI_GSPI_DATA_REG1,
683 ((addr << 6) | ((data >> 16) & 0xffff)), 2);
684 if (ret < 0)
685 return ret;
686
687 ret = rsi_usb_master_reg_write(adapter, RSI_GSPI_DATA_REG0,
688 (data & 0xffff), 2);
689 if (ret < 0)
690 return ret;
691
692 /* Initializing GSPI for ULP read/writes */
693 rsi_usb_master_reg_write(adapter, RSI_GSPI_CTRL_REG0,
694 RSI_GSPI_CTRL_REG0_VALUE, 2);
695
696 ret = rsi_usb_master_reg_write(adapter, RSI_GSPI_CTRL_REG1,
697 ((len_in_bits - 1) | RSI_GSPI_TRIG), 2);
698 if (ret < 0)
699 return ret;
700
701 msleep(20);
702
703 return 0;
704}
705
706static int rsi_reset_card(struct rsi_hw *adapter)
707{
708 int ret;
709
710 rsi_dbg(INFO_ZONE, "Resetting Card...\n");
711 rsi_usb_master_reg_write(adapter, RSI_TA_HOLD_REG, 0xE, 4);
712
713 /* This msleep will ensure Thread-Arch processor to go to hold
714 * and any pending dma transfers to rf in device to finish.
715 */
716 msleep(100);
717
718 ret = rsi_usb_master_reg_write(adapter, SWBL_REGOUT,
719 RSI_FW_WDT_DISABLE_REQ,
720 RSI_COMMON_REG_SIZE);
721 if (ret < 0) {
722 rsi_dbg(ERR_ZONE, "Disabling firmware watchdog timer failed\n");
723 goto fail;
724 }
725
726 if (adapter->device_model != RSI_DEV_9116) {
727 ret = usb_ulp_read_write(adapter, RSI_WATCH_DOG_TIMER_1,
728 RSI_ULP_WRITE_2, 32);
729 if (ret < 0)
730 goto fail;
731 ret = usb_ulp_read_write(adapter, RSI_WATCH_DOG_TIMER_2,
732 RSI_ULP_WRITE_0, 32);
733 if (ret < 0)
734 goto fail;
735 ret = usb_ulp_read_write(adapter, RSI_WATCH_DOG_DELAY_TIMER_1,
736 RSI_ULP_WRITE_50, 32);
737 if (ret < 0)
738 goto fail;
739 ret = usb_ulp_read_write(adapter, RSI_WATCH_DOG_DELAY_TIMER_2,
740 RSI_ULP_WRITE_0, 32);
741 if (ret < 0)
742 goto fail;
743 ret = usb_ulp_read_write(adapter, RSI_WATCH_DOG_TIMER_ENABLE,
744 RSI_ULP_TIMER_ENABLE, 32);
745 if (ret < 0)
746 goto fail;
747 } else {
748 ret = rsi_usb_master_reg_write(adapter,
749 NWP_WWD_INTERRUPT_TIMER,
750 NWP_WWD_INT_TIMER_CLKS,
751 RSI_9116_REG_SIZE);
752 if (ret < 0)
753 goto fail;
754 ret = rsi_usb_master_reg_write(adapter,
755 NWP_WWD_SYSTEM_RESET_TIMER,
756 NWP_WWD_SYS_RESET_TIMER_CLKS,
757 RSI_9116_REG_SIZE);
758 if (ret < 0)
759 goto fail;
760 ret = rsi_usb_master_reg_write(adapter,
761 NWP_WWD_MODE_AND_RSTART,
762 NWP_WWD_TIMER_DISABLE,
763 RSI_9116_REG_SIZE);
764 if (ret < 0)
765 goto fail;
766 }
767
768 rsi_dbg(INFO_ZONE, "Reset card done\n");
769 return ret;
770
771fail:
772 rsi_dbg(ERR_ZONE, "Reset card failed\n");
773 return ret;
774}
775
776/**
777 * rsi_probe() - This function is called by kernel when the driver provided
778 * Vendor and device IDs are matched. All the initialization
779 * work is done here.
780 * @pfunction: Pointer to the USB interface structure.
781 * @id: Pointer to the usb_device_id structure.
782 *
783 * Return: 0 on success, a negative error code on failure.
784 */
785static int rsi_probe(struct usb_interface *pfunction,
786 const struct usb_device_id *id)
787{
788 struct rsi_hw *adapter;
789 struct rsi_91x_usbdev *dev;
790 u16 fw_status;
791 int status;
792
793 rsi_dbg(INIT_ZONE, "%s: Init function called\n", __func__);
794
795 adapter = rsi_91x_init(dev_oper_mode);
796 if (!adapter) {
797 rsi_dbg(ERR_ZONE, "%s: Failed to init os intf ops\n",
798 __func__);
799 return -ENOMEM;
800 }
801 adapter->rsi_host_intf = RSI_HOST_INTF_USB;
802
803 status = rsi_init_usb_interface(adapter, pfunction);
804 if (status) {
805 rsi_dbg(ERR_ZONE, "%s: Failed to init usb interface\n",
806 __func__);
807 goto err;
808 }
809
810 rsi_dbg(ERR_ZONE, "%s: Initialized os intf ops\n", __func__);
811
812 if (id->idProduct == RSI_USB_PID_9113) {
813 rsi_dbg(INIT_ZONE, "%s: 9113 module detected\n", __func__);
814 adapter->device_model = RSI_DEV_9113;
815 } else if (id->idProduct == RSI_USB_PID_9116) {
816 rsi_dbg(INIT_ZONE, "%s: 9116 module detected\n", __func__);
817 adapter->device_model = RSI_DEV_9116;
818 } else {
819 rsi_dbg(ERR_ZONE, "%s: Unsupported RSI device id 0x%x\n",
820 __func__, id->idProduct);
821 status = -ENODEV;
822 goto err1;
823 }
824
825 dev = adapter->rsi_dev;
826
827 status = rsi_usb_reg_read(dev->usbdev, FW_STATUS_REG, &fw_status, 2);
828 if (status < 0)
829 goto err1;
830 else
831 fw_status &= 1;
832
833 if (!fw_status) {
834 rsi_dbg(INIT_ZONE, "Loading firmware...\n");
835 status = rsi_hal_device_init(adapter);
836 if (status) {
837 rsi_dbg(ERR_ZONE, "%s: Failed in device init\n",
838 __func__);
839 goto err1;
840 }
841 rsi_dbg(INIT_ZONE, "%s: Device Init Done\n", __func__);
842 }
843
844 status = rsi_rx_urb_submit(adapter, WLAN_EP, GFP_KERNEL);
845 if (status)
846 goto err1;
847
848 if (adapter->priv->coex_mode > 1) {
849 status = rsi_rx_urb_submit(adapter, BT_EP, GFP_KERNEL);
850 if (status)
851 goto err_kill_wlan_urb;
852 }
853
854 return 0;
855
856err_kill_wlan_urb:
857 rsi_rx_urb_kill(adapter, WLAN_EP);
858err1:
859 rsi_deinit_usb_interface(adapter);
860err:
861 rsi_91x_deinit(adapter);
862 rsi_dbg(ERR_ZONE, "%s: Failed in probe...Exiting\n", __func__);
863 return status;
864}
865
866/**
867 * rsi_disconnect() - This function performs the reverse of the probe function,
868 * it deinitialize the driver structure.
869 * @pfunction: Pointer to the USB interface structure.
870 *
871 * Return: None.
872 */
873static void rsi_disconnect(struct usb_interface *pfunction)
874{
875 struct rsi_hw *adapter = usb_get_intfdata(pfunction);
876
877 if (!adapter)
878 return;
879
880 rsi_mac80211_detach(adapter);
881
882 if (IS_ENABLED(CONFIG_RSI_COEX) && adapter->priv->coex_mode > 1 &&
883 adapter->priv->bt_adapter) {
884 rsi_bt_ops.detach(adapter->priv->bt_adapter);
885 adapter->priv->bt_adapter = NULL;
886 }
887
888 if (adapter->priv->coex_mode > 1)
889 rsi_rx_urb_kill(adapter, BT_EP);
890 rsi_rx_urb_kill(adapter, WLAN_EP);
891
892 rsi_reset_card(adapter);
893 rsi_deinit_usb_interface(adapter);
894 rsi_91x_deinit(adapter);
895
896 rsi_dbg(INFO_ZONE, "%s: Deinitialization completed\n", __func__);
897}
898
899#ifdef CONFIG_PM
900static int rsi_suspend(struct usb_interface *intf, pm_message_t message)
901{
902 /* Not yet implemented */
903 return -ENOSYS;
904}
905
906static int rsi_resume(struct usb_interface *intf)
907{
908 /* Not yet implemented */
909 return -ENOSYS;
910}
911#endif
912
913static const struct usb_device_id rsi_dev_table[] = {
914 { USB_DEVICE(RSI_USB_VENDOR_ID, RSI_USB_PID_9113) },
915 { USB_DEVICE(RSI_USB_VENDOR_ID, RSI_USB_PID_9116) },
916 { /* Blank */},
917};
918
919static struct usb_driver rsi_driver = {
920 .name = "RSI-USB WLAN",
921 .probe = rsi_probe,
922 .disconnect = rsi_disconnect,
923 .id_table = rsi_dev_table,
924#ifdef CONFIG_PM
925 .suspend = rsi_suspend,
926 .resume = rsi_resume,
927#endif
928};
929
930module_usb_driver(rsi_driver);
931
932MODULE_AUTHOR("Redpine Signals Inc");
933MODULE_DESCRIPTION("Common USB layer for RSI drivers");
934MODULE_DEVICE_TABLE(usb, rsi_dev_table);
935MODULE_FIRMWARE(FIRMWARE_RSI9113);
936MODULE_VERSION("0.1");
937MODULE_LICENSE("Dual BSD/GPL");
1/**
2 * Copyright (c) 2014 Redpine Signals Inc.
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 *
16 */
17
18#include <linux/module.h>
19#include "rsi_usb.h"
20
21/**
22 * rsi_usb_card_write() - This function writes to the USB Card.
23 * @adapter: Pointer to the adapter structure.
24 * @buf: Pointer to the buffer from where the data has to be taken.
25 * @len: Length to be written.
26 * @endpoint: Type of endpoint.
27 *
28 * Return: status: 0 on success, a negative error code on failure.
29 */
30static int rsi_usb_card_write(struct rsi_hw *adapter,
31 void *buf,
32 u16 len,
33 u8 endpoint)
34{
35 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
36 int status;
37 s32 transfer;
38
39 status = usb_bulk_msg(dev->usbdev,
40 usb_sndbulkpipe(dev->usbdev,
41 dev->bulkout_endpoint_addr[endpoint - 1]),
42 buf,
43 len,
44 &transfer,
45 HZ * 5);
46
47 if (status < 0) {
48 rsi_dbg(ERR_ZONE,
49 "Card write failed with error code :%10d\n", status);
50 dev->write_fail = 1;
51 }
52 return status;
53}
54
55/**
56 * rsi_write_multiple() - This function writes multiple bytes of information
57 * to the USB card.
58 * @adapter: Pointer to the adapter structure.
59 * @addr: Address of the register.
60 * @data: Pointer to the data that has to be written.
61 * @count: Number of multiple bytes to be written.
62 *
63 * Return: 0 on success, a negative error code on failure.
64 */
65static int rsi_write_multiple(struct rsi_hw *adapter,
66 u8 endpoint,
67 u8 *data,
68 u32 count)
69{
70 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
71 u8 *seg = dev->tx_buffer;
72
73 if (dev->write_fail)
74 return 0;
75
76 if (endpoint == MGMT_EP) {
77 memset(seg, 0, RSI_USB_TX_HEAD_ROOM);
78 memcpy(seg + RSI_USB_TX_HEAD_ROOM, data, count);
79 } else {
80 seg = ((u8 *)data - RSI_USB_TX_HEAD_ROOM);
81 }
82
83 return rsi_usb_card_write(adapter,
84 seg,
85 count + RSI_USB_TX_HEAD_ROOM,
86 endpoint);
87}
88
89/**
90 * rsi_find_bulk_in_and_out_endpoints() - This function initializes the bulk
91 * endpoints to the device.
92 * @interface: Pointer to the USB interface structure.
93 * @adapter: Pointer to the adapter structure.
94 *
95 * Return: ret_val: 0 on success, -ENOMEM on failure.
96 */
97static int rsi_find_bulk_in_and_out_endpoints(struct usb_interface *interface,
98 struct rsi_hw *adapter)
99{
100 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
101 struct usb_host_interface *iface_desc;
102 struct usb_endpoint_descriptor *endpoint;
103 __le16 buffer_size;
104 int ii, bep_found = 0;
105
106 iface_desc = &(interface->altsetting[0]);
107
108 for (ii = 0; ii < iface_desc->desc.bNumEndpoints; ++ii) {
109 endpoint = &(iface_desc->endpoint[ii].desc);
110
111 if ((!(dev->bulkin_endpoint_addr)) &&
112 (endpoint->bEndpointAddress & USB_DIR_IN) &&
113 ((endpoint->bmAttributes &
114 USB_ENDPOINT_XFERTYPE_MASK) ==
115 USB_ENDPOINT_XFER_BULK)) {
116 buffer_size = endpoint->wMaxPacketSize;
117 dev->bulkin_size = buffer_size;
118 dev->bulkin_endpoint_addr =
119 endpoint->bEndpointAddress;
120 }
121
122 if (!dev->bulkout_endpoint_addr[bep_found] &&
123 !(endpoint->bEndpointAddress & USB_DIR_IN) &&
124 ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
125 USB_ENDPOINT_XFER_BULK)) {
126 dev->bulkout_endpoint_addr[bep_found] =
127 endpoint->bEndpointAddress;
128 buffer_size = endpoint->wMaxPacketSize;
129 dev->bulkout_size[bep_found] = buffer_size;
130 bep_found++;
131 }
132
133 if (bep_found >= MAX_BULK_EP)
134 break;
135 }
136
137 if (!(dev->bulkin_endpoint_addr) &&
138 (dev->bulkout_endpoint_addr[0]))
139 return -EINVAL;
140
141 return 0;
142}
143
144/* rsi_usb_reg_read() - This function reads data from given register address.
145 * @usbdev: Pointer to the usb_device structure.
146 * @reg: Address of the register to be read.
147 * @value: Value to be read.
148 * @len: length of data to be read.
149 *
150 * Return: status: 0 on success, a negative error code on failure.
151 */
152static int rsi_usb_reg_read(struct usb_device *usbdev,
153 u32 reg,
154 u16 *value,
155 u16 len)
156{
157 u8 *buf;
158 int status = -ENOMEM;
159
160 buf = kmalloc(0x04, GFP_KERNEL);
161 if (!buf)
162 return status;
163
164 status = usb_control_msg(usbdev,
165 usb_rcvctrlpipe(usbdev, 0),
166 USB_VENDOR_REGISTER_READ,
167 USB_TYPE_VENDOR,
168 ((reg & 0xffff0000) >> 16), (reg & 0xffff),
169 (void *)buf,
170 len,
171 HZ * 5);
172
173 *value = (buf[0] | (buf[1] << 8));
174 if (status < 0) {
175 rsi_dbg(ERR_ZONE,
176 "%s: Reg read failed with error code :%d\n",
177 __func__, status);
178 }
179 kfree(buf);
180
181 return status;
182}
183
184/**
185 * rsi_usb_reg_write() - This function writes the given data into the given
186 * register address.
187 * @usbdev: Pointer to the usb_device structure.
188 * @reg: Address of the register.
189 * @value: Value to write.
190 * @len: Length of data to be written.
191 *
192 * Return: status: 0 on success, a negative error code on failure.
193 */
194static int rsi_usb_reg_write(struct usb_device *usbdev,
195 u32 reg,
196 u16 value,
197 u16 len)
198{
199 u8 *usb_reg_buf;
200 int status = -ENOMEM;
201
202 usb_reg_buf = kmalloc(0x04, GFP_KERNEL);
203 if (!usb_reg_buf)
204 return status;
205
206 usb_reg_buf[0] = (value & 0x00ff);
207 usb_reg_buf[1] = (value & 0xff00) >> 8;
208 usb_reg_buf[2] = 0x0;
209 usb_reg_buf[3] = 0x0;
210
211 status = usb_control_msg(usbdev,
212 usb_sndctrlpipe(usbdev, 0),
213 USB_VENDOR_REGISTER_WRITE,
214 USB_TYPE_VENDOR,
215 ((reg & 0xffff0000) >> 16),
216 (reg & 0xffff),
217 (void *)usb_reg_buf,
218 len,
219 HZ * 5);
220 if (status < 0) {
221 rsi_dbg(ERR_ZONE,
222 "%s: Reg write failed with error code :%d\n",
223 __func__, status);
224 }
225 kfree(usb_reg_buf);
226
227 return status;
228}
229
230/**
231 * rsi_rx_done_handler() - This function is called when a packet is received
232 * from USB stack. This is callback to recieve done.
233 * @urb: Received URB.
234 *
235 * Return: None.
236 */
237static void rsi_rx_done_handler(struct urb *urb)
238{
239 struct rsi_hw *adapter = urb->context;
240 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
241
242 if (urb->status)
243 return;
244
245 rsi_set_event(&dev->rx_thread.event);
246}
247
248/**
249 * rsi_rx_urb_submit() - This function submits the given URB to the USB stack.
250 * @adapter: Pointer to the adapter structure.
251 *
252 * Return: 0 on success, a negative error code on failure.
253 */
254static int rsi_rx_urb_submit(struct rsi_hw *adapter)
255{
256 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
257 struct urb *urb = dev->rx_usb_urb[0];
258 int status;
259
260 usb_fill_bulk_urb(urb,
261 dev->usbdev,
262 usb_rcvbulkpipe(dev->usbdev,
263 dev->bulkin_endpoint_addr),
264 urb->transfer_buffer,
265 3000,
266 rsi_rx_done_handler,
267 adapter);
268
269 status = usb_submit_urb(urb, GFP_KERNEL);
270 if (status)
271 rsi_dbg(ERR_ZONE, "%s: Failed in urb submission\n", __func__);
272
273 return status;
274}
275
276/**
277 * rsi_usb_write_register_multiple() - This function writes multiple bytes of
278 * information to multiple registers.
279 * @adapter: Pointer to the adapter structure.
280 * @addr: Address of the register.
281 * @data: Pointer to the data that has to be written.
282 * @count: Number of multiple bytes to be written on to the registers.
283 *
284 * Return: status: 0 on success, a negative error code on failure.
285 */
286int rsi_usb_write_register_multiple(struct rsi_hw *adapter,
287 u32 addr,
288 u8 *data,
289 u32 count)
290{
291 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
292 u8 *buf;
293 u8 transfer;
294 int status = 0;
295
296 buf = kzalloc(4096, GFP_KERNEL);
297 if (!buf)
298 return -ENOMEM;
299
300 while (count) {
301 transfer = (u8)(min_t(u32, count, 4096));
302 memcpy(buf, data, transfer);
303 status = usb_control_msg(dev->usbdev,
304 usb_sndctrlpipe(dev->usbdev, 0),
305 USB_VENDOR_REGISTER_WRITE,
306 USB_TYPE_VENDOR,
307 ((addr & 0xffff0000) >> 16),
308 (addr & 0xffff),
309 (void *)buf,
310 transfer,
311 HZ * 5);
312 if (status < 0) {
313 rsi_dbg(ERR_ZONE,
314 "Reg write failed with error code :%d\n",
315 status);
316 } else {
317 count -= transfer;
318 data += transfer;
319 addr += transfer;
320 }
321 }
322
323 kfree(buf);
324 return 0;
325}
326
327/**
328 *rsi_usb_host_intf_write_pkt() - This function writes the packet to the
329 * USB card.
330 * @adapter: Pointer to the adapter structure.
331 * @pkt: Pointer to the data to be written on to the card.
332 * @len: Length of the data to be written on to the card.
333 *
334 * Return: 0 on success, a negative error code on failure.
335 */
336static int rsi_usb_host_intf_write_pkt(struct rsi_hw *adapter,
337 u8 *pkt,
338 u32 len)
339{
340 u32 queueno = ((pkt[1] >> 4) & 0xf);
341 u8 endpoint;
342
343 endpoint = ((queueno == RSI_WIFI_MGMT_Q) ? MGMT_EP : DATA_EP);
344
345 return rsi_write_multiple(adapter,
346 endpoint,
347 (u8 *)pkt,
348 len);
349}
350
351/**
352 * rsi_deinit_usb_interface() - This function deinitializes the usb interface.
353 * @adapter: Pointer to the adapter structure.
354 *
355 * Return: None.
356 */
357static void rsi_deinit_usb_interface(struct rsi_hw *adapter)
358{
359 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
360
361 rsi_kill_thread(&dev->rx_thread);
362 usb_free_urb(dev->rx_usb_urb[0]);
363 kfree(adapter->priv->rx_data_pkt);
364 kfree(dev->tx_buffer);
365}
366
367/**
368 * rsi_init_usb_interface() - This function initializes the usb interface.
369 * @adapter: Pointer to the adapter structure.
370 * @pfunction: Pointer to USB interface structure.
371 *
372 * Return: 0 on success, a negative error code on failure.
373 */
374static int rsi_init_usb_interface(struct rsi_hw *adapter,
375 struct usb_interface *pfunction)
376{
377 struct rsi_91x_usbdev *rsi_dev;
378 struct rsi_common *common = adapter->priv;
379 int status;
380
381 rsi_dev = kzalloc(sizeof(*rsi_dev), GFP_KERNEL);
382 if (!rsi_dev)
383 return -ENOMEM;
384
385 adapter->rsi_dev = rsi_dev;
386 rsi_dev->usbdev = interface_to_usbdev(pfunction);
387
388 if (rsi_find_bulk_in_and_out_endpoints(pfunction, adapter))
389 return -EINVAL;
390
391 adapter->device = &pfunction->dev;
392 usb_set_intfdata(pfunction, adapter);
393
394 common->rx_data_pkt = kmalloc(2048, GFP_KERNEL);
395 if (!common->rx_data_pkt) {
396 rsi_dbg(ERR_ZONE, "%s: Failed to allocate memory\n",
397 __func__);
398 return -ENOMEM;
399 }
400
401 rsi_dev->tx_buffer = kmalloc(2048, GFP_KERNEL);
402 if (!rsi_dev->tx_buffer) {
403 status = -ENOMEM;
404 goto fail_tx;
405 }
406 rsi_dev->rx_usb_urb[0] = usb_alloc_urb(0, GFP_KERNEL);
407 if (!rsi_dev->rx_usb_urb[0]) {
408 status = -ENOMEM;
409 goto fail_rx;
410 }
411 rsi_dev->rx_usb_urb[0]->transfer_buffer = adapter->priv->rx_data_pkt;
412 rsi_dev->tx_blk_size = 252;
413
414 /* Initializing function callbacks */
415 adapter->rx_urb_submit = rsi_rx_urb_submit;
416 adapter->host_intf_write_pkt = rsi_usb_host_intf_write_pkt;
417 adapter->check_hw_queue_status = rsi_usb_check_queue_status;
418 adapter->determine_event_timeout = rsi_usb_event_timeout;
419
420 rsi_init_event(&rsi_dev->rx_thread.event);
421 status = rsi_create_kthread(common, &rsi_dev->rx_thread,
422 rsi_usb_rx_thread, "RX-Thread");
423 if (status) {
424 rsi_dbg(ERR_ZONE, "%s: Unable to init rx thrd\n", __func__);
425 goto fail_thread;
426 }
427
428#ifdef CONFIG_RSI_DEBUGFS
429 /* In USB, one less than the MAX_DEBUGFS_ENTRIES entries is required */
430 adapter->num_debugfs_entries = (MAX_DEBUGFS_ENTRIES - 1);
431#endif
432
433 rsi_dbg(INIT_ZONE, "%s: Enabled the interface\n", __func__);
434 return 0;
435
436fail_thread:
437 usb_free_urb(rsi_dev->rx_usb_urb[0]);
438fail_rx:
439 kfree(rsi_dev->tx_buffer);
440fail_tx:
441 kfree(common->rx_data_pkt);
442 return status;
443}
444
445/**
446 * rsi_probe() - This function is called by kernel when the driver provided
447 * Vendor and device IDs are matched. All the initialization
448 * work is done here.
449 * @pfunction: Pointer to the USB interface structure.
450 * @id: Pointer to the usb_device_id structure.
451 *
452 * Return: 0 on success, a negative error code on failure.
453 */
454static int rsi_probe(struct usb_interface *pfunction,
455 const struct usb_device_id *id)
456{
457 struct rsi_hw *adapter;
458 struct rsi_91x_usbdev *dev;
459 u16 fw_status;
460 int status;
461
462 rsi_dbg(INIT_ZONE, "%s: Init function called\n", __func__);
463
464 adapter = rsi_91x_init();
465 if (!adapter) {
466 rsi_dbg(ERR_ZONE, "%s: Failed to init os intf ops\n",
467 __func__);
468 return -ENOMEM;
469 }
470
471 status = rsi_init_usb_interface(adapter, pfunction);
472 if (status) {
473 rsi_dbg(ERR_ZONE, "%s: Failed to init usb interface\n",
474 __func__);
475 goto err;
476 }
477
478 rsi_dbg(ERR_ZONE, "%s: Initialized os intf ops\n", __func__);
479
480 dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
481
482 status = rsi_usb_reg_read(dev->usbdev, FW_STATUS_REG, &fw_status, 2);
483 if (status)
484 goto err1;
485 else
486 fw_status &= 1;
487
488 if (!fw_status) {
489 status = rsi_usb_device_init(adapter->priv);
490 if (status) {
491 rsi_dbg(ERR_ZONE, "%s: Failed in device init\n",
492 __func__);
493 goto err1;
494 }
495
496 status = rsi_usb_reg_write(dev->usbdev,
497 USB_INTERNAL_REG_1,
498 RSI_USB_READY_MAGIC_NUM, 1);
499 if (status)
500 goto err1;
501 rsi_dbg(INIT_ZONE, "%s: Performed device init\n", __func__);
502 }
503
504 status = rsi_rx_urb_submit(adapter);
505 if (status)
506 goto err1;
507
508 return 0;
509err1:
510 rsi_deinit_usb_interface(adapter);
511err:
512 rsi_91x_deinit(adapter);
513 rsi_dbg(ERR_ZONE, "%s: Failed in probe...Exiting\n", __func__);
514 return status;
515}
516
517/**
518 * rsi_disconnect() - This function performs the reverse of the probe function,
519 * it deintialize the driver structure.
520 * @pfunction: Pointer to the USB interface structure.
521 *
522 * Return: None.
523 */
524static void rsi_disconnect(struct usb_interface *pfunction)
525{
526 struct rsi_hw *adapter = usb_get_intfdata(pfunction);
527
528 if (!adapter)
529 return;
530
531 rsi_mac80211_detach(adapter);
532 rsi_deinit_usb_interface(adapter);
533 rsi_91x_deinit(adapter);
534
535 rsi_dbg(INFO_ZONE, "%s: Deinitialization completed\n", __func__);
536}
537
538#ifdef CONFIG_PM
539static int rsi_suspend(struct usb_interface *intf, pm_message_t message)
540{
541 /* Not yet implemented */
542 return -ENOSYS;
543}
544
545static int rsi_resume(struct usb_interface *intf)
546{
547 /* Not yet implemented */
548 return -ENOSYS;
549}
550#endif
551
552static const struct usb_device_id rsi_dev_table[] = {
553 { USB_DEVICE(0x0303, 0x0100) },
554 { USB_DEVICE(0x041B, 0x0301) },
555 { USB_DEVICE(0x041B, 0x0201) },
556 { USB_DEVICE(0x041B, 0x9330) },
557 { /* Blank */},
558};
559
560static struct usb_driver rsi_driver = {
561 .name = "RSI-USB WLAN",
562 .probe = rsi_probe,
563 .disconnect = rsi_disconnect,
564 .id_table = rsi_dev_table,
565#ifdef CONFIG_PM
566 .suspend = rsi_suspend,
567 .resume = rsi_resume,
568#endif
569};
570
571module_usb_driver(rsi_driver);
572
573MODULE_AUTHOR("Redpine Signals Inc");
574MODULE_DESCRIPTION("Common USB layer for RSI drivers");
575MODULE_SUPPORTED_DEVICE("RSI-91x");
576MODULE_DEVICE_TABLE(usb, rsi_dev_table);
577MODULE_FIRMWARE(FIRMWARE_RSI9113);
578MODULE_VERSION("0.1");
579MODULE_LICENSE("Dual BSD/GPL");