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 */ 26 static u16 dev_oper_mode = DEV_OPMODE_STA_BT_DUAL; 27 module_param(dev_oper_mode, ushort, 0444); 28 MODULE_PARM_DESC(dev_oper_mode, DEV_OPMODE_PARAM_DESC); 29 30 static 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 */ 41 static 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 = (struct rsi_91x_usbdev *)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 */ 81 static 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 = (struct rsi_91x_usbdev *)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 */ 109 static int rsi_find_bulk_in_and_out_endpoints(struct usb_interface *interface, 110 struct rsi_hw *adapter) 111 { 112 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)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 */ 175 static 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 */ 220 static 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 */ 266 static 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 297 out: 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 307 static void rsi_rx_urb_kill(struct rsi_hw *adapter, u8 ep_num) 308 { 309 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)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 */ 324 static int rsi_rx_urb_submit(struct rsi_hw *adapter, u8 ep_num, gfp_t mem_flags) 325 { 326 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)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 #define RSI_MAX_RX_USB_PKT_SIZE 3000 334 skb = dev_alloc_skb(RSI_MAX_RX_USB_PKT_SIZE); 335 if (!skb) 336 return -ENOMEM; 337 skb_reserve(skb, MAX_DWORD_ALIGN_BYTES); 338 skb_put(skb, RSI_MAX_RX_USB_PKT_SIZE - MAX_DWORD_ALIGN_BYTES); 339 dword_align_bytes = (unsigned long)skb->data & 0x3f; 340 if (dword_align_bytes > 0) 341 skb_push(skb, dword_align_bytes); 342 urb->transfer_buffer = skb->data; 343 rx_cb->rx_skb = skb; 344 345 usb_fill_bulk_urb(urb, 346 dev->usbdev, 347 usb_rcvbulkpipe(dev->usbdev, 348 dev->bulkin_endpoint_addr[ep_num - 1]), 349 urb->transfer_buffer, 350 skb->len, 351 rsi_rx_done_handler, 352 rx_cb); 353 354 status = usb_submit_urb(urb, mem_flags); 355 if (status) { 356 rsi_dbg(ERR_ZONE, "%s: Failed in urb submission\n", __func__); 357 dev_kfree_skb(skb); 358 } 359 360 return status; 361 } 362 363 static int rsi_usb_read_register_multiple(struct rsi_hw *adapter, u32 addr, 364 u8 *data, u16 count) 365 { 366 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev; 367 u8 *buf; 368 u16 transfer; 369 int status; 370 371 if (!addr) 372 return -EINVAL; 373 374 buf = kzalloc(RSI_USB_BUF_SIZE, GFP_KERNEL); 375 if (!buf) 376 return -ENOMEM; 377 378 while (count) { 379 transfer = min_t(u16, count, RSI_USB_BUF_SIZE); 380 status = usb_control_msg(dev->usbdev, 381 usb_rcvctrlpipe(dev->usbdev, 0), 382 USB_VENDOR_REGISTER_READ, 383 RSI_USB_REQ_IN, 384 ((addr & 0xffff0000) >> 16), 385 (addr & 0xffff), (void *)buf, 386 transfer, USB_CTRL_GET_TIMEOUT); 387 if (status < 0) { 388 rsi_dbg(ERR_ZONE, 389 "Reg read failed with error code :%d\n", 390 status); 391 kfree(buf); 392 return status; 393 } 394 memcpy(data, buf, transfer); 395 count -= transfer; 396 data += transfer; 397 addr += transfer; 398 } 399 kfree(buf); 400 return 0; 401 } 402 403 /** 404 * rsi_usb_write_register_multiple() - This function writes multiple bytes of 405 * information to multiple registers. 406 * @adapter: Pointer to the adapter structure. 407 * @addr: Address of the register. 408 * @data: Pointer to the data that has to be written. 409 * @count: Number of multiple bytes to be written on to the registers. 410 * 411 * Return: status: 0 on success, a negative error code on failure. 412 */ 413 static int rsi_usb_write_register_multiple(struct rsi_hw *adapter, u32 addr, 414 u8 *data, u16 count) 415 { 416 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev; 417 u8 *buf; 418 u16 transfer; 419 int status = 0; 420 421 buf = kzalloc(RSI_USB_BUF_SIZE, GFP_KERNEL); 422 if (!buf) 423 return -ENOMEM; 424 425 while (count) { 426 transfer = min_t(u16, count, RSI_USB_BUF_SIZE); 427 memcpy(buf, data, transfer); 428 status = usb_control_msg(dev->usbdev, 429 usb_sndctrlpipe(dev->usbdev, 0), 430 USB_VENDOR_REGISTER_WRITE, 431 RSI_USB_REQ_OUT, 432 ((addr & 0xffff0000) >> 16), 433 (addr & 0xffff), 434 (void *)buf, 435 transfer, 436 USB_CTRL_SET_TIMEOUT); 437 if (status < 0) { 438 rsi_dbg(ERR_ZONE, 439 "Reg write failed with error code :%d\n", 440 status); 441 kfree(buf); 442 return status; 443 } 444 count -= transfer; 445 data += transfer; 446 addr += transfer; 447 } 448 449 kfree(buf); 450 return 0; 451 } 452 453 /** 454 *rsi_usb_host_intf_write_pkt() - This function writes the packet to the 455 * USB card. 456 * @adapter: Pointer to the adapter structure. 457 * @pkt: Pointer to the data to be written on to the card. 458 * @len: Length of the data to be written on to the card. 459 * 460 * Return: 0 on success, a negative error code on failure. 461 */ 462 static int rsi_usb_host_intf_write_pkt(struct rsi_hw *adapter, 463 u8 *pkt, 464 u32 len) 465 { 466 u32 queueno = ((pkt[1] >> 4) & 0x7); 467 u8 endpoint; 468 469 endpoint = ((queueno == RSI_WIFI_MGMT_Q || queueno == RSI_WIFI_DATA_Q || 470 queueno == RSI_COEX_Q) ? WLAN_EP : BT_EP); 471 472 return rsi_write_multiple(adapter, 473 endpoint, 474 (u8 *)pkt, 475 len); 476 } 477 478 static int rsi_usb_master_reg_read(struct rsi_hw *adapter, u32 reg, 479 u32 *value, u16 len) 480 { 481 struct usb_device *usbdev = 482 ((struct rsi_91x_usbdev *)adapter->rsi_dev)->usbdev; 483 u16 temp; 484 int ret; 485 486 ret = rsi_usb_reg_read(usbdev, reg, &temp, len); 487 if (ret < 0) 488 return ret; 489 *value = temp; 490 491 return 0; 492 } 493 494 static int rsi_usb_master_reg_write(struct rsi_hw *adapter, 495 unsigned long reg, 496 unsigned long value, u16 len) 497 { 498 struct usb_device *usbdev = 499 ((struct rsi_91x_usbdev *)adapter->rsi_dev)->usbdev; 500 501 return rsi_usb_reg_write(usbdev, reg, value, len); 502 } 503 504 static int rsi_usb_load_data_master_write(struct rsi_hw *adapter, 505 u32 base_address, 506 u32 instructions_sz, u16 block_size, 507 u8 *ta_firmware) 508 { 509 u16 num_blocks; 510 u32 cur_indx, i; 511 u8 temp_buf[256]; 512 int status; 513 514 num_blocks = instructions_sz / block_size; 515 rsi_dbg(INFO_ZONE, "num_blocks: %d\n", num_blocks); 516 517 for (cur_indx = 0, i = 0; i < num_blocks; i++, cur_indx += block_size) { 518 memcpy(temp_buf, ta_firmware + cur_indx, block_size); 519 status = rsi_usb_write_register_multiple(adapter, base_address, 520 (u8 *)(temp_buf), 521 block_size); 522 if (status < 0) 523 return status; 524 525 rsi_dbg(INFO_ZONE, "%s: loading block: %d\n", __func__, i); 526 base_address += block_size; 527 } 528 529 if (instructions_sz % block_size) { 530 memset(temp_buf, 0, block_size); 531 memcpy(temp_buf, ta_firmware + cur_indx, 532 instructions_sz % block_size); 533 status = rsi_usb_write_register_multiple 534 (adapter, base_address, 535 (u8 *)temp_buf, 536 instructions_sz % block_size); 537 if (status < 0) 538 return status; 539 rsi_dbg(INFO_ZONE, 540 "Written Last Block in Address 0x%x Successfully\n", 541 cur_indx); 542 } 543 return 0; 544 } 545 546 static struct rsi_host_intf_ops usb_host_intf_ops = { 547 .write_pkt = rsi_usb_host_intf_write_pkt, 548 .read_reg_multiple = rsi_usb_read_register_multiple, 549 .write_reg_multiple = rsi_usb_write_register_multiple, 550 .master_reg_read = rsi_usb_master_reg_read, 551 .master_reg_write = rsi_usb_master_reg_write, 552 .load_data_master_write = rsi_usb_load_data_master_write, 553 }; 554 555 /** 556 * rsi_deinit_usb_interface() - This function deinitializes the usb interface. 557 * @adapter: Pointer to the adapter structure. 558 * 559 * Return: None. 560 */ 561 static void rsi_deinit_usb_interface(struct rsi_hw *adapter) 562 { 563 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev; 564 565 rsi_kill_thread(&dev->rx_thread); 566 567 usb_free_urb(dev->rx_cb[0].rx_urb); 568 if (adapter->priv->coex_mode > 1) 569 usb_free_urb(dev->rx_cb[1].rx_urb); 570 571 kfree(dev->tx_buffer); 572 } 573 574 static int rsi_usb_init_rx(struct rsi_hw *adapter) 575 { 576 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev; 577 struct rx_usb_ctrl_block *rx_cb; 578 u8 idx, num_rx_cb; 579 580 num_rx_cb = (adapter->priv->coex_mode > 1 ? 2 : 1); 581 582 for (idx = 0; idx < num_rx_cb; idx++) { 583 rx_cb = &dev->rx_cb[idx]; 584 585 rx_cb->rx_urb = usb_alloc_urb(0, GFP_KERNEL); 586 if (!rx_cb->rx_urb) { 587 rsi_dbg(ERR_ZONE, "Failed alloc rx urb[%d]\n", idx); 588 goto err; 589 } 590 rx_cb->ep_num = idx + 1; 591 rx_cb->data = (void *)dev; 592 } 593 skb_queue_head_init(&dev->rx_q); 594 rsi_init_event(&dev->rx_thread.event); 595 if (rsi_create_kthread(adapter->priv, &dev->rx_thread, 596 rsi_usb_rx_thread, "RX-Thread")) { 597 rsi_dbg(ERR_ZONE, "%s: Unable to init rx thrd\n", __func__); 598 goto err; 599 } 600 601 return 0; 602 603 err: 604 usb_free_urb(dev->rx_cb[0].rx_urb); 605 if (adapter->priv->coex_mode > 1) 606 usb_free_urb(dev->rx_cb[1].rx_urb); 607 608 return -1; 609 } 610 611 /** 612 * rsi_init_usb_interface() - This function initializes the usb interface. 613 * @adapter: Pointer to the adapter structure. 614 * @pfunction: Pointer to USB interface structure. 615 * 616 * Return: 0 on success, a negative error code on failure. 617 */ 618 static int rsi_init_usb_interface(struct rsi_hw *adapter, 619 struct usb_interface *pfunction) 620 { 621 struct rsi_91x_usbdev *rsi_dev; 622 int status; 623 624 rsi_dev = kzalloc(sizeof(*rsi_dev), GFP_KERNEL); 625 if (!rsi_dev) 626 return -ENOMEM; 627 628 adapter->rsi_dev = rsi_dev; 629 rsi_dev->usbdev = interface_to_usbdev(pfunction); 630 rsi_dev->priv = (void *)adapter; 631 632 if (rsi_find_bulk_in_and_out_endpoints(pfunction, adapter)) { 633 status = -EINVAL; 634 goto fail_eps; 635 } 636 637 adapter->device = &pfunction->dev; 638 usb_set_intfdata(pfunction, adapter); 639 640 rsi_dev->tx_buffer = kmalloc(2048, GFP_KERNEL); 641 if (!rsi_dev->tx_buffer) { 642 status = -ENOMEM; 643 goto fail_eps; 644 } 645 646 if (rsi_usb_init_rx(adapter)) { 647 rsi_dbg(ERR_ZONE, "Failed to init RX handle\n"); 648 status = -ENOMEM; 649 goto fail_rx; 650 } 651 652 rsi_dev->tx_blk_size = 252; 653 adapter->block_size = rsi_dev->tx_blk_size; 654 655 /* Initializing function callbacks */ 656 adapter->check_hw_queue_status = rsi_usb_check_queue_status; 657 adapter->determine_event_timeout = rsi_usb_event_timeout; 658 adapter->rsi_host_intf = RSI_HOST_INTF_USB; 659 adapter->host_intf_ops = &usb_host_intf_ops; 660 661 #ifdef CONFIG_RSI_DEBUGFS 662 /* In USB, one less than the MAX_DEBUGFS_ENTRIES entries is required */ 663 adapter->num_debugfs_entries = (MAX_DEBUGFS_ENTRIES - 1); 664 #endif 665 666 rsi_dbg(INIT_ZONE, "%s: Enabled the interface\n", __func__); 667 return 0; 668 669 fail_rx: 670 kfree(rsi_dev->tx_buffer); 671 672 fail_eps: 673 674 return status; 675 } 676 677 static int usb_ulp_read_write(struct rsi_hw *adapter, u16 addr, u32 data, 678 u16 len_in_bits) 679 { 680 int ret; 681 682 ret = rsi_usb_master_reg_write 683 (adapter, RSI_GSPI_DATA_REG1, 684 ((addr << 6) | ((data >> 16) & 0xffff)), 2); 685 if (ret < 0) 686 return ret; 687 688 ret = rsi_usb_master_reg_write(adapter, RSI_GSPI_DATA_REG0, 689 (data & 0xffff), 2); 690 if (ret < 0) 691 return ret; 692 693 /* Initializing GSPI for ULP read/writes */ 694 rsi_usb_master_reg_write(adapter, RSI_GSPI_CTRL_REG0, 695 RSI_GSPI_CTRL_REG0_VALUE, 2); 696 697 ret = rsi_usb_master_reg_write(adapter, RSI_GSPI_CTRL_REG1, 698 ((len_in_bits - 1) | RSI_GSPI_TRIG), 2); 699 if (ret < 0) 700 return ret; 701 702 msleep(20); 703 704 return 0; 705 } 706 707 static int rsi_reset_card(struct rsi_hw *adapter) 708 { 709 int ret; 710 711 rsi_dbg(INFO_ZONE, "Resetting Card...\n"); 712 rsi_usb_master_reg_write(adapter, RSI_TA_HOLD_REG, 0xE, 4); 713 714 /* This msleep will ensure Thread-Arch processor to go to hold 715 * and any pending dma transfers to rf in device to finish. 716 */ 717 msleep(100); 718 719 ret = rsi_usb_master_reg_write(adapter, SWBL_REGOUT, 720 RSI_FW_WDT_DISABLE_REQ, 721 RSI_COMMON_REG_SIZE); 722 if (ret < 0) { 723 rsi_dbg(ERR_ZONE, "Disabling firmware watchdog timer failed\n"); 724 goto fail; 725 } 726 727 if (adapter->device_model != RSI_DEV_9116) { 728 ret = usb_ulp_read_write(adapter, RSI_WATCH_DOG_TIMER_1, 729 RSI_ULP_WRITE_2, 32); 730 if (ret < 0) 731 goto fail; 732 ret = usb_ulp_read_write(adapter, RSI_WATCH_DOG_TIMER_2, 733 RSI_ULP_WRITE_0, 32); 734 if (ret < 0) 735 goto fail; 736 ret = usb_ulp_read_write(adapter, RSI_WATCH_DOG_DELAY_TIMER_1, 737 RSI_ULP_WRITE_50, 32); 738 if (ret < 0) 739 goto fail; 740 ret = usb_ulp_read_write(adapter, RSI_WATCH_DOG_DELAY_TIMER_2, 741 RSI_ULP_WRITE_0, 32); 742 if (ret < 0) 743 goto fail; 744 ret = usb_ulp_read_write(adapter, RSI_WATCH_DOG_TIMER_ENABLE, 745 RSI_ULP_TIMER_ENABLE, 32); 746 if (ret < 0) 747 goto fail; 748 } else { 749 ret = rsi_usb_master_reg_write(adapter, 750 NWP_WWD_INTERRUPT_TIMER, 751 NWP_WWD_INT_TIMER_CLKS, 752 RSI_9116_REG_SIZE); 753 if (ret < 0) 754 goto fail; 755 ret = rsi_usb_master_reg_write(adapter, 756 NWP_WWD_SYSTEM_RESET_TIMER, 757 NWP_WWD_SYS_RESET_TIMER_CLKS, 758 RSI_9116_REG_SIZE); 759 if (ret < 0) 760 goto fail; 761 ret = rsi_usb_master_reg_write(adapter, 762 NWP_WWD_MODE_AND_RSTART, 763 NWP_WWD_TIMER_DISABLE, 764 RSI_9116_REG_SIZE); 765 if (ret < 0) 766 goto fail; 767 } 768 769 rsi_dbg(INFO_ZONE, "Reset card done\n"); 770 return ret; 771 772 fail: 773 rsi_dbg(ERR_ZONE, "Reset card failed\n"); 774 return ret; 775 } 776 777 /** 778 * rsi_probe() - This function is called by kernel when the driver provided 779 * Vendor and device IDs are matched. All the initialization 780 * work is done here. 781 * @pfunction: Pointer to the USB interface structure. 782 * @id: Pointer to the usb_device_id structure. 783 * 784 * Return: 0 on success, a negative error code on failure. 785 */ 786 static int rsi_probe(struct usb_interface *pfunction, 787 const struct usb_device_id *id) 788 { 789 struct rsi_hw *adapter; 790 struct rsi_91x_usbdev *dev; 791 u16 fw_status; 792 int status; 793 794 rsi_dbg(INIT_ZONE, "%s: Init function called\n", __func__); 795 796 adapter = rsi_91x_init(dev_oper_mode); 797 if (!adapter) { 798 rsi_dbg(ERR_ZONE, "%s: Failed to init os intf ops\n", 799 __func__); 800 return -ENOMEM; 801 } 802 adapter->rsi_host_intf = RSI_HOST_INTF_USB; 803 804 status = rsi_init_usb_interface(adapter, pfunction); 805 if (status) { 806 rsi_dbg(ERR_ZONE, "%s: Failed to init usb interface\n", 807 __func__); 808 goto err; 809 } 810 811 rsi_dbg(ERR_ZONE, "%s: Initialized os intf ops\n", __func__); 812 813 if (id->idProduct == RSI_USB_PID_9113) { 814 rsi_dbg(INIT_ZONE, "%s: 9113 module detected\n", __func__); 815 adapter->device_model = RSI_DEV_9113; 816 } else if (id->idProduct == RSI_USB_PID_9116) { 817 rsi_dbg(INIT_ZONE, "%s: 9116 module detected\n", __func__); 818 adapter->device_model = RSI_DEV_9116; 819 } else { 820 rsi_dbg(ERR_ZONE, "%s: Unsupported RSI device id 0x%x\n", 821 __func__, id->idProduct); 822 status = -ENODEV; 823 goto err1; 824 } 825 826 dev = (struct rsi_91x_usbdev *)adapter->rsi_dev; 827 828 status = rsi_usb_reg_read(dev->usbdev, FW_STATUS_REG, &fw_status, 2); 829 if (status < 0) 830 goto err1; 831 else 832 fw_status &= 1; 833 834 if (!fw_status) { 835 rsi_dbg(INIT_ZONE, "Loading firmware...\n"); 836 status = rsi_hal_device_init(adapter); 837 if (status) { 838 rsi_dbg(ERR_ZONE, "%s: Failed in device init\n", 839 __func__); 840 goto err1; 841 } 842 rsi_dbg(INIT_ZONE, "%s: Device Init Done\n", __func__); 843 } 844 845 status = rsi_rx_urb_submit(adapter, WLAN_EP, GFP_KERNEL); 846 if (status) 847 goto err1; 848 849 if (adapter->priv->coex_mode > 1) { 850 status = rsi_rx_urb_submit(adapter, BT_EP, GFP_KERNEL); 851 if (status) 852 goto err_kill_wlan_urb; 853 } 854 855 return 0; 856 857 err_kill_wlan_urb: 858 rsi_rx_urb_kill(adapter, WLAN_EP); 859 err1: 860 rsi_deinit_usb_interface(adapter); 861 err: 862 rsi_91x_deinit(adapter); 863 rsi_dbg(ERR_ZONE, "%s: Failed in probe...Exiting\n", __func__); 864 return status; 865 } 866 867 /** 868 * rsi_disconnect() - This function performs the reverse of the probe function, 869 * it deinitialize the driver structure. 870 * @pfunction: Pointer to the USB interface structure. 871 * 872 * Return: None. 873 */ 874 static void rsi_disconnect(struct usb_interface *pfunction) 875 { 876 struct rsi_hw *adapter = usb_get_intfdata(pfunction); 877 878 if (!adapter) 879 return; 880 881 rsi_mac80211_detach(adapter); 882 883 if (IS_ENABLED(CONFIG_RSI_COEX) && adapter->priv->coex_mode > 1 && 884 adapter->priv->bt_adapter) { 885 rsi_bt_ops.detach(adapter->priv->bt_adapter); 886 adapter->priv->bt_adapter = NULL; 887 } 888 889 if (adapter->priv->coex_mode > 1) 890 rsi_rx_urb_kill(adapter, BT_EP); 891 rsi_rx_urb_kill(adapter, WLAN_EP); 892 893 rsi_reset_card(adapter); 894 rsi_deinit_usb_interface(adapter); 895 rsi_91x_deinit(adapter); 896 897 rsi_dbg(INFO_ZONE, "%s: Deinitialization completed\n", __func__); 898 } 899 900 #ifdef CONFIG_PM 901 static int rsi_suspend(struct usb_interface *intf, pm_message_t message) 902 { 903 /* Not yet implemented */ 904 return -ENOSYS; 905 } 906 907 static int rsi_resume(struct usb_interface *intf) 908 { 909 /* Not yet implemented */ 910 return -ENOSYS; 911 } 912 #endif 913 914 static const struct usb_device_id rsi_dev_table[] = { 915 { USB_DEVICE(RSI_USB_VENDOR_ID, RSI_USB_PID_9113) }, 916 { USB_DEVICE(RSI_USB_VENDOR_ID, RSI_USB_PID_9116) }, 917 { /* Blank */}, 918 }; 919 920 static struct usb_driver rsi_driver = { 921 .name = "RSI-USB WLAN", 922 .probe = rsi_probe, 923 .disconnect = rsi_disconnect, 924 .id_table = rsi_dev_table, 925 #ifdef CONFIG_PM 926 .suspend = rsi_suspend, 927 .resume = rsi_resume, 928 #endif 929 }; 930 931 module_usb_driver(rsi_driver); 932 933 MODULE_AUTHOR("Redpine Signals Inc"); 934 MODULE_DESCRIPTION("Common USB layer for RSI drivers"); 935 MODULE_DEVICE_TABLE(usb, rsi_dev_table); 936 MODULE_FIRMWARE(FIRMWARE_RSI9113); 937 MODULE_VERSION("0.1"); 938 MODULE_LICENSE("Dual BSD/GPL"); 939