Back to home page

OSCL-LXR
 
 

     

0001 /*
0002  * Copyright (c) 2014 Redpine Signals Inc.
0003  *
0004  * Permission to use, copy, modify, and/or distribute this software for any
0005  * purpose with or without fee is hereby granted, provided that the above
0006  * copyright notice and this permission notice appear in all copies.
0007  *
0008  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
0009  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
0010  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
0011  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
0012  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
0013  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
0014  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
0015  *
0016  */
0017 
0018 #include <linux/module.h>
0019 #include <linux/types.h>
0020 #include <net/rsi_91x.h>
0021 #include "rsi_usb.h"
0022 #include "rsi_hal.h"
0023 #include "rsi_coex.h"
0024 
0025 /* Default operating mode is wlan STA + BT */
0026 static u16 dev_oper_mode = DEV_OPMODE_STA_BT_DUAL;
0027 module_param(dev_oper_mode, ushort, 0444);
0028 MODULE_PARM_DESC(dev_oper_mode, DEV_OPMODE_PARAM_DESC);
0029 
0030 static int rsi_rx_urb_submit(struct rsi_hw *adapter, u8 ep_num, gfp_t flags);
0031 
0032 /**
0033  * rsi_usb_card_write() - This function writes to the USB Card.
0034  * @adapter: Pointer to the adapter structure.
0035  * @buf: Pointer to the buffer from where the data has to be taken.
0036  * @len: Length to be written.
0037  * @endpoint: Type of endpoint.
0038  *
0039  * Return: status: 0 on success, a negative error code on failure.
0040  */
0041 static int rsi_usb_card_write(struct rsi_hw *adapter,
0042                   u8 *buf,
0043                   u16 len,
0044                   u8 endpoint)
0045 {
0046     struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
0047     int status;
0048     u8 *seg = dev->tx_buffer;
0049     int transfer;
0050     int ep = dev->bulkout_endpoint_addr[endpoint - 1];
0051 
0052     memset(seg, 0, len + RSI_USB_TX_HEAD_ROOM);
0053     memcpy(seg + RSI_USB_TX_HEAD_ROOM, buf, len);
0054     len += RSI_USB_TX_HEAD_ROOM;
0055     transfer = len;
0056     status = usb_bulk_msg(dev->usbdev,
0057                   usb_sndbulkpipe(dev->usbdev, ep),
0058                   (void *)seg,
0059                   (int)len,
0060                   &transfer,
0061                   USB_CTRL_SET_TIMEOUT);
0062 
0063     if (status < 0) {
0064         rsi_dbg(ERR_ZONE,
0065             "Card write failed with error code :%10d\n", status);
0066         dev->write_fail = 1;
0067     }
0068     return status;
0069 }
0070 
0071 /**
0072  * rsi_write_multiple() - This function writes multiple bytes of information
0073  *            to the USB card.
0074  * @adapter: Pointer to the adapter structure.
0075  * @endpoint: Type of endpoint.
0076  * @data: Pointer to the data that has to be written.
0077  * @count: Number of multiple bytes to be written.
0078  *
0079  * Return: 0 on success, a negative error code on failure.
0080  */
0081 static int rsi_write_multiple(struct rsi_hw *adapter,
0082                   u8 endpoint,
0083                   u8 *data,
0084                   u32 count)
0085 {
0086     struct rsi_91x_usbdev *dev;
0087 
0088     if (!adapter)
0089         return -ENODEV;
0090 
0091     if (endpoint == 0)
0092         return -EINVAL;
0093 
0094     dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
0095     if (dev->write_fail)
0096         return -ENETDOWN;
0097 
0098     return rsi_usb_card_write(adapter, data, count, endpoint);
0099 }
0100 
0101 /**
0102  * rsi_find_bulk_in_and_out_endpoints() - This function initializes the bulk
0103  *                    endpoints to the device.
0104  * @interface: Pointer to the USB interface structure.
0105  * @adapter: Pointer to the adapter structure.
0106  *
0107  * Return: ret_val: 0 on success, -ENOMEM on failure.
0108  */
0109 static int rsi_find_bulk_in_and_out_endpoints(struct usb_interface *interface,
0110                           struct rsi_hw *adapter)
0111 {
0112     struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
0113     struct usb_host_interface *iface_desc;
0114     struct usb_endpoint_descriptor *endpoint;
0115     __le16 buffer_size;
0116     int ii, bin_found = 0, bout_found = 0;
0117 
0118     iface_desc = interface->cur_altsetting;
0119 
0120     for (ii = 0; ii < iface_desc->desc.bNumEndpoints; ++ii) {
0121         endpoint = &(iface_desc->endpoint[ii].desc);
0122 
0123         if (!dev->bulkin_endpoint_addr[bin_found] &&
0124             (endpoint->bEndpointAddress & USB_DIR_IN) &&
0125             ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
0126             USB_ENDPOINT_XFER_BULK)) {
0127             buffer_size = endpoint->wMaxPacketSize;
0128             dev->bulkin_size[bin_found] = buffer_size;
0129             dev->bulkin_endpoint_addr[bin_found] =
0130                 endpoint->bEndpointAddress;
0131             bin_found++;
0132         }
0133 
0134         if (!dev->bulkout_endpoint_addr[bout_found] &&
0135             !(endpoint->bEndpointAddress & USB_DIR_IN) &&
0136             ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
0137             USB_ENDPOINT_XFER_BULK)) {
0138             buffer_size = endpoint->wMaxPacketSize;
0139             dev->bulkout_endpoint_addr[bout_found] =
0140                 endpoint->bEndpointAddress;
0141             dev->bulkout_size[bout_found] = buffer_size;
0142             bout_found++;
0143         }
0144 
0145         if (bin_found >= MAX_BULK_EP || bout_found >= MAX_BULK_EP)
0146             break;
0147     }
0148 
0149     if (!(dev->bulkin_endpoint_addr[0] && dev->bulkout_endpoint_addr[0])) {
0150         dev_err(&interface->dev, "missing wlan bulk endpoints\n");
0151         return -EINVAL;
0152     }
0153 
0154     if (adapter->priv->coex_mode > 1) {
0155         if (!dev->bulkin_endpoint_addr[1]) {
0156             dev_err(&interface->dev, "missing bt bulk-in endpoint\n");
0157             return -EINVAL;
0158         }
0159     }
0160 
0161     return 0;
0162 }
0163 
0164 #define RSI_USB_REQ_OUT (USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE)
0165 #define RSI_USB_REQ_IN  (USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE)
0166 
0167 /* rsi_usb_reg_read() - This function reads data from given register address.
0168  * @usbdev: Pointer to the usb_device structure.
0169  * @reg: Address of the register to be read.
0170  * @value: Value to be read.
0171  * @len: length of data to be read.
0172  *
0173  * Return: status: 0 on success, a negative error code on failure.
0174  */
0175 static int rsi_usb_reg_read(struct usb_device *usbdev,
0176                 u32 reg,
0177                 u16 *value,
0178                 u16 len)
0179 {
0180     u8 *buf;
0181     int status = -ENOMEM;
0182 
0183     if (len > RSI_USB_CTRL_BUF_SIZE)
0184         return -EINVAL;
0185 
0186     buf  = kmalloc(RSI_USB_CTRL_BUF_SIZE, GFP_KERNEL);
0187     if (!buf)
0188         return status;
0189 
0190     status = usb_control_msg(usbdev,
0191                  usb_rcvctrlpipe(usbdev, 0),
0192                  USB_VENDOR_REGISTER_READ,
0193                  RSI_USB_REQ_IN,
0194                  ((reg & 0xffff0000) >> 16), (reg & 0xffff),
0195                  (void *)buf,
0196                  len,
0197                  USB_CTRL_GET_TIMEOUT);
0198 
0199     *value = (buf[0] | (buf[1] << 8));
0200     if (status < 0) {
0201         rsi_dbg(ERR_ZONE,
0202             "%s: Reg read failed with error code :%d\n",
0203             __func__, status);
0204     }
0205     kfree(buf);
0206 
0207     return status;
0208 }
0209 
0210 /**
0211  * rsi_usb_reg_write() - This function writes the given data into the given
0212  *           register address.
0213  * @usbdev: Pointer to the usb_device structure.
0214  * @reg: Address of the register.
0215  * @value: Value to write.
0216  * @len: Length of data to be written.
0217  *
0218  * Return: status: 0 on success, a negative error code on failure.
0219  */
0220 static int rsi_usb_reg_write(struct usb_device *usbdev,
0221                  u32 reg,
0222                  u32 value,
0223                  u16 len)
0224 {
0225     u8 *usb_reg_buf;
0226     int status = -ENOMEM;
0227 
0228     if (len > RSI_USB_CTRL_BUF_SIZE)
0229         return -EINVAL;
0230 
0231     usb_reg_buf  = kmalloc(RSI_USB_CTRL_BUF_SIZE, GFP_KERNEL);
0232     if (!usb_reg_buf)
0233         return status;
0234 
0235     usb_reg_buf[0] = (cpu_to_le32(value) & 0x00ff);
0236     usb_reg_buf[1] = (cpu_to_le32(value) & 0xff00) >> 8;
0237     usb_reg_buf[2] = (cpu_to_le32(value) & 0x00ff0000) >> 16;
0238     usb_reg_buf[3] = (cpu_to_le32(value) & 0xff000000) >> 24;
0239 
0240     status = usb_control_msg(usbdev,
0241                  usb_sndctrlpipe(usbdev, 0),
0242                  USB_VENDOR_REGISTER_WRITE,
0243                  RSI_USB_REQ_OUT,
0244                  ((cpu_to_le32(reg) & 0xffff0000) >> 16),
0245                  (cpu_to_le32(reg) & 0xffff),
0246                  (void *)usb_reg_buf,
0247                  len,
0248                  USB_CTRL_SET_TIMEOUT);
0249     if (status < 0) {
0250         rsi_dbg(ERR_ZONE,
0251             "%s: Reg write failed with error code :%d\n",
0252             __func__, status);
0253     }
0254     kfree(usb_reg_buf);
0255 
0256     return status;
0257 }
0258 
0259 /**
0260  * rsi_rx_done_handler() - This function is called when a packet is received
0261  *             from USB stack. This is callback to receive done.
0262  * @urb: Received URB.
0263  *
0264  * Return: None.
0265  */
0266 static void rsi_rx_done_handler(struct urb *urb)
0267 {
0268     struct rx_usb_ctrl_block *rx_cb = urb->context;
0269     struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)rx_cb->data;
0270     int status = -EINVAL;
0271 
0272     if (!rx_cb->rx_skb)
0273         return;
0274 
0275     if (urb->status) {
0276         dev_kfree_skb(rx_cb->rx_skb);
0277         rx_cb->rx_skb = NULL;
0278         return;
0279     }
0280 
0281     if (urb->actual_length <= 0 ||
0282         urb->actual_length > rx_cb->rx_skb->len) {
0283         rsi_dbg(INFO_ZONE, "%s: Invalid packet length = %d\n",
0284             __func__, urb->actual_length);
0285         goto out;
0286     }
0287     if (skb_queue_len(&dev->rx_q) >= RSI_MAX_RX_PKTS) {
0288         rsi_dbg(INFO_ZONE, "Max RX packets reached\n");
0289         goto out;
0290     }
0291     skb_trim(rx_cb->rx_skb, urb->actual_length);
0292     skb_queue_tail(&dev->rx_q, rx_cb->rx_skb);
0293 
0294     rsi_set_event(&dev->rx_thread.event);
0295     status = 0;
0296 
0297 out:
0298     if (rsi_rx_urb_submit(dev->priv, rx_cb->ep_num, GFP_ATOMIC))
0299         rsi_dbg(ERR_ZONE, "%s: Failed in urb submission", __func__);
0300 
0301     if (status) {
0302         dev_kfree_skb(rx_cb->rx_skb);
0303         rx_cb->rx_skb = NULL;
0304     }
0305 }
0306 
0307 static void rsi_rx_urb_kill(struct rsi_hw *adapter, u8 ep_num)
0308 {
0309     struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
0310     struct rx_usb_ctrl_block *rx_cb = &dev->rx_cb[ep_num - 1];
0311     struct urb *urb = rx_cb->rx_urb;
0312 
0313     usb_kill_urb(urb);
0314 }
0315 
0316 /**
0317  * rsi_rx_urb_submit() - This function submits the given URB to the USB stack.
0318  * @adapter: Pointer to the adapter structure.
0319  * @ep_num: Endpoint number.
0320  * @mem_flags: The type of memory to allocate.
0321  *
0322  * Return: 0 on success, a negative error code on failure.
0323  */
0324 static int rsi_rx_urb_submit(struct rsi_hw *adapter, u8 ep_num, gfp_t mem_flags)
0325 {
0326     struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
0327     struct rx_usb_ctrl_block *rx_cb = &dev->rx_cb[ep_num - 1];
0328     struct urb *urb = rx_cb->rx_urb;
0329     int status;
0330     struct sk_buff *skb;
0331     u8 dword_align_bytes = 0;
0332 
0333     skb = dev_alloc_skb(RSI_MAX_RX_USB_PKT_SIZE);
0334     if (!skb)
0335         return -ENOMEM;
0336     skb_reserve(skb, MAX_DWORD_ALIGN_BYTES);
0337     skb_put(skb, RSI_MAX_RX_USB_PKT_SIZE - MAX_DWORD_ALIGN_BYTES);
0338     dword_align_bytes = (unsigned long)skb->data & 0x3f;
0339     if (dword_align_bytes > 0)
0340         skb_push(skb, dword_align_bytes);
0341     urb->transfer_buffer = skb->data;
0342     rx_cb->rx_skb = skb;
0343 
0344     usb_fill_bulk_urb(urb,
0345               dev->usbdev,
0346               usb_rcvbulkpipe(dev->usbdev,
0347               dev->bulkin_endpoint_addr[ep_num - 1]),
0348               urb->transfer_buffer,
0349               skb->len,
0350               rsi_rx_done_handler,
0351               rx_cb);
0352 
0353     status = usb_submit_urb(urb, mem_flags);
0354     if (status) {
0355         rsi_dbg(ERR_ZONE, "%s: Failed in urb submission\n", __func__);
0356         dev_kfree_skb(skb);
0357     }
0358 
0359     return status;
0360 }
0361 
0362 static int rsi_usb_read_register_multiple(struct rsi_hw *adapter, u32 addr,
0363                       u8 *data, u16 count)
0364 {
0365     struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
0366     u8 *buf;
0367     u16 transfer;
0368     int status;
0369 
0370     if (!addr)
0371         return -EINVAL;
0372 
0373     buf = kzalloc(RSI_USB_BUF_SIZE, GFP_KERNEL);
0374     if (!buf)
0375         return -ENOMEM;
0376 
0377     while (count) {
0378         transfer = min_t(u16, count, RSI_USB_BUF_SIZE);
0379         status = usb_control_msg(dev->usbdev,
0380                      usb_rcvctrlpipe(dev->usbdev, 0),
0381                      USB_VENDOR_REGISTER_READ,
0382                      RSI_USB_REQ_IN,
0383                      ((addr & 0xffff0000) >> 16),
0384                      (addr & 0xffff), (void *)buf,
0385                      transfer, USB_CTRL_GET_TIMEOUT);
0386         if (status < 0) {
0387             rsi_dbg(ERR_ZONE,
0388                 "Reg read failed with error code :%d\n",
0389                  status);
0390             kfree(buf);
0391             return status;
0392         }
0393         memcpy(data, buf, transfer);
0394         count -= transfer;
0395         data += transfer;
0396         addr += transfer;
0397     }
0398     kfree(buf);
0399     return 0;
0400 }
0401 
0402 /**
0403  * rsi_usb_write_register_multiple() - This function writes multiple bytes of
0404  *                     information to multiple registers.
0405  * @adapter: Pointer to the adapter structure.
0406  * @addr: Address of the register.
0407  * @data: Pointer to the data that has to be written.
0408  * @count: Number of multiple bytes to be written on to the registers.
0409  *
0410  * Return: status: 0 on success, a negative error code on failure.
0411  */
0412 static int rsi_usb_write_register_multiple(struct rsi_hw *adapter, u32 addr,
0413                        u8 *data, u16 count)
0414 {
0415     struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
0416     u8 *buf;
0417     u16 transfer;
0418     int status = 0;
0419 
0420     buf = kzalloc(RSI_USB_BUF_SIZE, GFP_KERNEL);
0421     if (!buf)
0422         return -ENOMEM;
0423 
0424     while (count) {
0425         transfer = min_t(u16, count, RSI_USB_BUF_SIZE);
0426         memcpy(buf, data, transfer);
0427         status = usb_control_msg(dev->usbdev,
0428                      usb_sndctrlpipe(dev->usbdev, 0),
0429                      USB_VENDOR_REGISTER_WRITE,
0430                      RSI_USB_REQ_OUT,
0431                      ((addr & 0xffff0000) >> 16),
0432                      (addr & 0xffff),
0433                      (void *)buf,
0434                      transfer,
0435                      USB_CTRL_SET_TIMEOUT);
0436         if (status < 0) {
0437             rsi_dbg(ERR_ZONE,
0438                 "Reg write failed with error code :%d\n",
0439                 status);
0440             kfree(buf);
0441             return status;
0442         }
0443         count -= transfer;
0444         data += transfer;
0445         addr += transfer;
0446     }
0447 
0448     kfree(buf);
0449     return 0;
0450 }
0451 
0452 /**
0453  *rsi_usb_host_intf_write_pkt() - This function writes the packet to the
0454  *                 USB card.
0455  * @adapter: Pointer to the adapter structure.
0456  * @pkt: Pointer to the data to be written on to the card.
0457  * @len: Length of the data to be written on to the card.
0458  *
0459  * Return: 0 on success, a negative error code on failure.
0460  */
0461 static int rsi_usb_host_intf_write_pkt(struct rsi_hw *adapter,
0462                        u8 *pkt,
0463                        u32 len)
0464 {
0465     u32 queueno = ((pkt[1] >> 4) & 0x7);
0466     u8 endpoint;
0467 
0468     endpoint = ((queueno == RSI_WIFI_MGMT_Q || queueno == RSI_WIFI_DATA_Q ||
0469              queueno == RSI_COEX_Q) ? WLAN_EP : BT_EP);
0470 
0471     return rsi_write_multiple(adapter,
0472                   endpoint,
0473                   (u8 *)pkt,
0474                   len);
0475 }
0476 
0477 static int rsi_usb_master_reg_read(struct rsi_hw *adapter, u32 reg,
0478                    u32 *value, u16 len)
0479 {
0480     struct usb_device *usbdev =
0481         ((struct rsi_91x_usbdev *)adapter->rsi_dev)->usbdev;
0482     u16 temp;
0483     int ret;
0484 
0485     ret = rsi_usb_reg_read(usbdev, reg, &temp, len);
0486     if (ret < 0)
0487         return ret;
0488     *value = temp;
0489 
0490     return 0;
0491 }
0492 
0493 static int rsi_usb_master_reg_write(struct rsi_hw *adapter,
0494                     unsigned long reg,
0495                     unsigned long value, u16 len)
0496 {
0497     struct usb_device *usbdev =
0498         ((struct rsi_91x_usbdev *)adapter->rsi_dev)->usbdev;
0499 
0500     return rsi_usb_reg_write(usbdev, reg, value, len);
0501 }
0502 
0503 static int rsi_usb_load_data_master_write(struct rsi_hw *adapter,
0504                       u32 base_address,
0505                       u32 instructions_sz, u16 block_size,
0506                       u8 *ta_firmware)
0507 {
0508     u16 num_blocks;
0509     u32 cur_indx, i;
0510     u8 temp_buf[256];
0511     int status;
0512 
0513     num_blocks = instructions_sz / block_size;
0514     rsi_dbg(INFO_ZONE, "num_blocks: %d\n", num_blocks);
0515 
0516     for (cur_indx = 0, i = 0; i < num_blocks; i++, cur_indx += block_size) {
0517         memcpy(temp_buf, ta_firmware + cur_indx, block_size);
0518         status = rsi_usb_write_register_multiple(adapter, base_address,
0519                              (u8 *)(temp_buf),
0520                              block_size);
0521         if (status < 0)
0522             return status;
0523 
0524         rsi_dbg(INFO_ZONE, "%s: loading block: %d\n", __func__, i);
0525         base_address += block_size;
0526     }
0527 
0528     if (instructions_sz % block_size) {
0529         memset(temp_buf, 0, block_size);
0530         memcpy(temp_buf, ta_firmware + cur_indx,
0531                instructions_sz % block_size);
0532         status = rsi_usb_write_register_multiple
0533                         (adapter, base_address,
0534                          (u8 *)temp_buf,
0535                          instructions_sz % block_size);
0536         if (status < 0)
0537             return status;
0538         rsi_dbg(INFO_ZONE,
0539             "Written Last Block in Address 0x%x Successfully\n",
0540             cur_indx);
0541     }
0542     return 0;
0543 }
0544 
0545 static struct rsi_host_intf_ops usb_host_intf_ops = {
0546     .write_pkt      = rsi_usb_host_intf_write_pkt,
0547     .read_reg_multiple  = rsi_usb_read_register_multiple,
0548     .write_reg_multiple = rsi_usb_write_register_multiple,
0549     .master_reg_read    = rsi_usb_master_reg_read,
0550     .master_reg_write   = rsi_usb_master_reg_write,
0551     .load_data_master_write = rsi_usb_load_data_master_write,
0552 };
0553 
0554 /**
0555  * rsi_deinit_usb_interface() - This function deinitializes the usb interface.
0556  * @adapter: Pointer to the adapter structure.
0557  *
0558  * Return: None.
0559  */
0560 static void rsi_deinit_usb_interface(struct rsi_hw *adapter)
0561 {
0562     struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
0563 
0564     rsi_kill_thread(&dev->rx_thread);
0565 
0566     usb_free_urb(dev->rx_cb[0].rx_urb);
0567     if (adapter->priv->coex_mode > 1)
0568         usb_free_urb(dev->rx_cb[1].rx_urb);
0569 
0570     kfree(dev->tx_buffer);
0571 }
0572 
0573 static int rsi_usb_init_rx(struct rsi_hw *adapter)
0574 {
0575     struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
0576     struct rx_usb_ctrl_block *rx_cb;
0577     u8 idx, num_rx_cb;
0578 
0579     num_rx_cb = (adapter->priv->coex_mode > 1 ? 2 : 1);
0580 
0581     for (idx = 0; idx < num_rx_cb; idx++) {
0582         rx_cb = &dev->rx_cb[idx];
0583 
0584         rx_cb->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
0585         if (!rx_cb->rx_urb) {
0586             rsi_dbg(ERR_ZONE, "Failed alloc rx urb[%d]\n", idx);
0587             goto err;
0588         }
0589         rx_cb->ep_num = idx + 1;
0590         rx_cb->data = (void *)dev;
0591     }
0592     skb_queue_head_init(&dev->rx_q);
0593     rsi_init_event(&dev->rx_thread.event);
0594     if (rsi_create_kthread(adapter->priv, &dev->rx_thread,
0595                    rsi_usb_rx_thread, "RX-Thread")) {
0596         rsi_dbg(ERR_ZONE, "%s: Unable to init rx thrd\n", __func__);
0597         goto err;
0598     }
0599 
0600     return 0;
0601 
0602 err:
0603     usb_free_urb(dev->rx_cb[0].rx_urb);
0604     if (adapter->priv->coex_mode > 1)
0605         usb_free_urb(dev->rx_cb[1].rx_urb);
0606 
0607     return -1;
0608 }
0609 
0610 /**
0611  * rsi_init_usb_interface() - This function initializes the usb interface.
0612  * @adapter: Pointer to the adapter structure.
0613  * @pfunction: Pointer to USB interface structure.
0614  *
0615  * Return: 0 on success, a negative error code on failure.
0616  */
0617 static int rsi_init_usb_interface(struct rsi_hw *adapter,
0618                   struct usb_interface *pfunction)
0619 {
0620     struct rsi_91x_usbdev *rsi_dev;
0621     int status;
0622 
0623     rsi_dev = kzalloc(sizeof(*rsi_dev), GFP_KERNEL);
0624     if (!rsi_dev)
0625         return -ENOMEM;
0626 
0627     adapter->rsi_dev = rsi_dev;
0628     rsi_dev->usbdev = interface_to_usbdev(pfunction);
0629     rsi_dev->priv = (void *)adapter;
0630 
0631     if (rsi_find_bulk_in_and_out_endpoints(pfunction, adapter)) {
0632         status = -EINVAL;
0633         goto fail_eps;
0634     }
0635 
0636     adapter->device = &pfunction->dev;
0637     usb_set_intfdata(pfunction, adapter);
0638 
0639     rsi_dev->tx_buffer = kmalloc(2048, GFP_KERNEL);
0640     if (!rsi_dev->tx_buffer) {
0641         status = -ENOMEM;
0642         goto fail_eps;
0643     }
0644 
0645     if (rsi_usb_init_rx(adapter)) {
0646         rsi_dbg(ERR_ZONE, "Failed to init RX handle\n");
0647         status = -ENOMEM;
0648         goto fail_rx;
0649     }
0650 
0651     rsi_dev->tx_blk_size = 252;
0652     adapter->block_size = rsi_dev->tx_blk_size;
0653 
0654     /* Initializing function callbacks */
0655     adapter->check_hw_queue_status = rsi_usb_check_queue_status;
0656     adapter->determine_event_timeout = rsi_usb_event_timeout;
0657     adapter->rsi_host_intf = RSI_HOST_INTF_USB;
0658     adapter->host_intf_ops = &usb_host_intf_ops;
0659 
0660 #ifdef CONFIG_RSI_DEBUGFS
0661     /* In USB, one less than the MAX_DEBUGFS_ENTRIES entries is required */
0662     adapter->num_debugfs_entries = (MAX_DEBUGFS_ENTRIES - 1);
0663 #endif
0664 
0665     rsi_dbg(INIT_ZONE, "%s: Enabled the interface\n", __func__);
0666     return 0;
0667 
0668 fail_rx:
0669     kfree(rsi_dev->tx_buffer);
0670 
0671 fail_eps:
0672 
0673     return status;
0674 }
0675 
0676 static int usb_ulp_read_write(struct rsi_hw *adapter, u16 addr, u32 data,
0677                   u16 len_in_bits)
0678 {
0679     int ret;
0680 
0681     ret = rsi_usb_master_reg_write
0682             (adapter, RSI_GSPI_DATA_REG1,
0683              ((addr << 6) | ((data >> 16) & 0xffff)), 2);
0684     if (ret < 0)
0685         return ret;
0686 
0687     ret = rsi_usb_master_reg_write(adapter, RSI_GSPI_DATA_REG0,
0688                        (data & 0xffff), 2);
0689     if (ret < 0)
0690         return ret;
0691 
0692     /* Initializing GSPI for ULP read/writes */
0693     rsi_usb_master_reg_write(adapter, RSI_GSPI_CTRL_REG0,
0694                  RSI_GSPI_CTRL_REG0_VALUE, 2);
0695 
0696     ret = rsi_usb_master_reg_write(adapter, RSI_GSPI_CTRL_REG1,
0697                        ((len_in_bits - 1) | RSI_GSPI_TRIG), 2);
0698     if (ret < 0)
0699         return ret;
0700 
0701     msleep(20);
0702 
0703     return 0;
0704 }
0705 
0706 static int rsi_reset_card(struct rsi_hw *adapter)
0707 {
0708     int ret;
0709 
0710     rsi_dbg(INFO_ZONE, "Resetting Card...\n");
0711     rsi_usb_master_reg_write(adapter, RSI_TA_HOLD_REG, 0xE, 4);
0712 
0713     /* This msleep will ensure Thread-Arch processor to go to hold
0714      * and any pending dma transfers to rf in device to finish.
0715      */
0716     msleep(100);
0717 
0718     ret = rsi_usb_master_reg_write(adapter, SWBL_REGOUT,
0719                        RSI_FW_WDT_DISABLE_REQ,
0720                        RSI_COMMON_REG_SIZE);
0721     if (ret < 0) {
0722         rsi_dbg(ERR_ZONE, "Disabling firmware watchdog timer failed\n");
0723         goto fail;
0724     }
0725 
0726     if (adapter->device_model != RSI_DEV_9116) {
0727         ret = usb_ulp_read_write(adapter, RSI_WATCH_DOG_TIMER_1,
0728                      RSI_ULP_WRITE_2, 32);
0729         if (ret < 0)
0730             goto fail;
0731         ret = usb_ulp_read_write(adapter, RSI_WATCH_DOG_TIMER_2,
0732                      RSI_ULP_WRITE_0, 32);
0733         if (ret < 0)
0734             goto fail;
0735         ret = usb_ulp_read_write(adapter, RSI_WATCH_DOG_DELAY_TIMER_1,
0736                      RSI_ULP_WRITE_50, 32);
0737         if (ret < 0)
0738             goto fail;
0739         ret = usb_ulp_read_write(adapter, RSI_WATCH_DOG_DELAY_TIMER_2,
0740                      RSI_ULP_WRITE_0, 32);
0741         if (ret < 0)
0742             goto fail;
0743         ret = usb_ulp_read_write(adapter, RSI_WATCH_DOG_TIMER_ENABLE,
0744                      RSI_ULP_TIMER_ENABLE, 32);
0745         if (ret < 0)
0746             goto fail;
0747     } else {
0748         ret = rsi_usb_master_reg_write(adapter,
0749                            NWP_WWD_INTERRUPT_TIMER,
0750                            NWP_WWD_INT_TIMER_CLKS,
0751                            RSI_9116_REG_SIZE);
0752         if (ret < 0)
0753             goto fail;
0754         ret = rsi_usb_master_reg_write(adapter,
0755                            NWP_WWD_SYSTEM_RESET_TIMER,
0756                            NWP_WWD_SYS_RESET_TIMER_CLKS,
0757                            RSI_9116_REG_SIZE);
0758         if (ret < 0)
0759             goto fail;
0760         ret = rsi_usb_master_reg_write(adapter,
0761                            NWP_WWD_MODE_AND_RSTART,
0762                            NWP_WWD_TIMER_DISABLE,
0763                            RSI_9116_REG_SIZE);
0764         if (ret < 0)
0765             goto fail;
0766     }
0767 
0768     rsi_dbg(INFO_ZONE, "Reset card done\n");
0769     return ret;
0770 
0771 fail:
0772     rsi_dbg(ERR_ZONE, "Reset card failed\n");
0773     return ret;
0774 }
0775 
0776 /**
0777  * rsi_probe() - This function is called by kernel when the driver provided
0778  *       Vendor and device IDs are matched. All the initialization
0779  *       work is done here.
0780  * @pfunction: Pointer to the USB interface structure.
0781  * @id: Pointer to the usb_device_id structure.
0782  *
0783  * Return: 0 on success, a negative error code on failure.
0784  */
0785 static int rsi_probe(struct usb_interface *pfunction,
0786              const struct usb_device_id *id)
0787 {
0788     struct rsi_hw *adapter;
0789     struct rsi_91x_usbdev *dev;
0790     u16 fw_status;
0791     int status;
0792 
0793     rsi_dbg(INIT_ZONE, "%s: Init function called\n", __func__);
0794 
0795     adapter = rsi_91x_init(dev_oper_mode);
0796     if (!adapter) {
0797         rsi_dbg(ERR_ZONE, "%s: Failed to init os intf ops\n",
0798             __func__);
0799         return -ENOMEM;
0800     }
0801     adapter->rsi_host_intf = RSI_HOST_INTF_USB;
0802 
0803     status = rsi_init_usb_interface(adapter, pfunction);
0804     if (status) {
0805         rsi_dbg(ERR_ZONE, "%s: Failed to init usb interface\n",
0806             __func__);
0807         goto err;
0808     }
0809 
0810     rsi_dbg(ERR_ZONE, "%s: Initialized os intf ops\n", __func__);
0811 
0812     if (id->idProduct == RSI_USB_PID_9113) {
0813         rsi_dbg(INIT_ZONE, "%s: 9113 module detected\n", __func__);
0814         adapter->device_model = RSI_DEV_9113;
0815     } else if (id->idProduct == RSI_USB_PID_9116) {
0816         rsi_dbg(INIT_ZONE, "%s: 9116 module detected\n", __func__);
0817         adapter->device_model = RSI_DEV_9116;
0818     } else {
0819         rsi_dbg(ERR_ZONE, "%s: Unsupported RSI device id 0x%x\n",
0820             __func__, id->idProduct);
0821         status = -ENODEV;
0822         goto err1;
0823     }
0824 
0825     dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
0826 
0827     status = rsi_usb_reg_read(dev->usbdev, FW_STATUS_REG, &fw_status, 2);
0828     if (status < 0)
0829         goto err1;
0830     else
0831         fw_status &= 1;
0832 
0833     if (!fw_status) {
0834         rsi_dbg(INIT_ZONE, "Loading firmware...\n");
0835         status = rsi_hal_device_init(adapter);
0836         if (status) {
0837             rsi_dbg(ERR_ZONE, "%s: Failed in device init\n",
0838                 __func__);
0839             goto err1;
0840         }
0841         rsi_dbg(INIT_ZONE, "%s: Device Init Done\n", __func__);
0842     }
0843 
0844     status = rsi_rx_urb_submit(adapter, WLAN_EP, GFP_KERNEL);
0845     if (status)
0846         goto err1;
0847 
0848     if (adapter->priv->coex_mode > 1) {
0849         status = rsi_rx_urb_submit(adapter, BT_EP, GFP_KERNEL);
0850         if (status)
0851             goto err_kill_wlan_urb;
0852     }
0853 
0854     return 0;
0855 
0856 err_kill_wlan_urb:
0857     rsi_rx_urb_kill(adapter, WLAN_EP);
0858 err1:
0859     rsi_deinit_usb_interface(adapter);
0860 err:
0861     rsi_91x_deinit(adapter);
0862     rsi_dbg(ERR_ZONE, "%s: Failed in probe...Exiting\n", __func__);
0863     return status;
0864 }
0865 
0866 /**
0867  * rsi_disconnect() - This function performs the reverse of the probe function,
0868  *            it deinitialize the driver structure.
0869  * @pfunction: Pointer to the USB interface structure.
0870  *
0871  * Return: None.
0872  */
0873 static void rsi_disconnect(struct usb_interface *pfunction)
0874 {
0875     struct rsi_hw *adapter = usb_get_intfdata(pfunction);
0876 
0877     if (!adapter)
0878         return;
0879 
0880     rsi_mac80211_detach(adapter);
0881 
0882     if (IS_ENABLED(CONFIG_RSI_COEX) && adapter->priv->coex_mode > 1 &&
0883         adapter->priv->bt_adapter) {
0884         rsi_bt_ops.detach(adapter->priv->bt_adapter);
0885         adapter->priv->bt_adapter = NULL;
0886     }
0887 
0888     if (adapter->priv->coex_mode > 1)
0889         rsi_rx_urb_kill(adapter, BT_EP);
0890     rsi_rx_urb_kill(adapter, WLAN_EP);
0891 
0892     rsi_reset_card(adapter);
0893     rsi_deinit_usb_interface(adapter);
0894     rsi_91x_deinit(adapter);
0895 
0896     rsi_dbg(INFO_ZONE, "%s: Deinitialization completed\n", __func__);
0897 }
0898 
0899 #ifdef CONFIG_PM
0900 static int rsi_suspend(struct usb_interface *intf, pm_message_t message)
0901 {
0902     /* Not yet implemented */
0903     return -ENOSYS;
0904 }
0905 
0906 static int rsi_resume(struct usb_interface *intf)
0907 {
0908     /* Not yet implemented */
0909     return -ENOSYS;
0910 }
0911 #endif
0912 
0913 static const struct usb_device_id rsi_dev_table[] = {
0914     { USB_DEVICE(RSI_USB_VENDOR_ID, RSI_USB_PID_9113) },
0915     { USB_DEVICE(RSI_USB_VENDOR_ID, RSI_USB_PID_9116) },
0916     { /* Blank */},
0917 };
0918 
0919 static struct usb_driver rsi_driver = {
0920     .name       = "RSI-USB WLAN",
0921     .probe      = rsi_probe,
0922     .disconnect = rsi_disconnect,
0923     .id_table   = rsi_dev_table,
0924 #ifdef CONFIG_PM
0925     .suspend    = rsi_suspend,
0926     .resume     = rsi_resume,
0927 #endif
0928 };
0929 
0930 module_usb_driver(rsi_driver);
0931 
0932 MODULE_AUTHOR("Redpine Signals Inc");
0933 MODULE_DESCRIPTION("Common USB layer for RSI drivers");
0934 MODULE_DEVICE_TABLE(usb, rsi_dev_table);
0935 MODULE_FIRMWARE(FIRMWARE_RSI9113);
0936 MODULE_VERSION("0.1");
0937 MODULE_LICENSE("Dual BSD/GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!