btmrvl_sdio.c revision 0d3674084c89130bcaf15b1a69881b31f198ee72
1/** 2 * Marvell BT-over-SDIO driver: SDIO interface related functions. 3 * 4 * Copyright (C) 2009, Marvell International Ltd. 5 * 6 * This software file (the "File") is distributed by Marvell International 7 * Ltd. under the terms of the GNU General Public License Version 2, June 1991 8 * (the "License"). You may use, redistribute and/or modify this File in 9 * accordance with the terms and conditions of the License, a copy of which 10 * is available by writing to the Free Software Foundation, Inc., 11 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the 12 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. 13 * 14 * 15 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE 17 * ARE EXPRESSLY DISCLAIMED. The License provides additional details about 18 * this warranty disclaimer. 19 **/ 20 21#include <linux/firmware.h> 22#include <linux/slab.h> 23 24#include <linux/mmc/sdio_ids.h> 25#include <linux/mmc/sdio_func.h> 26#include <linux/module.h> 27 28#include <net/bluetooth/bluetooth.h> 29#include <net/bluetooth/hci_core.h> 30 31#include "btmrvl_drv.h" 32#include "btmrvl_sdio.h" 33 34#define VERSION "1.0" 35 36/* The btmrvl_sdio_remove() callback function is called 37 * when user removes this module from kernel space or ejects 38 * the card from the slot. The driver handles these 2 cases 39 * differently. 40 * If the user is removing the module, a MODULE_SHUTDOWN_REQ 41 * command is sent to firmware and interrupt will be disabled. 42 * If the card is removed, there is no need to send command 43 * or disable interrupt. 44 * 45 * The variable 'user_rmmod' is used to distinguish these two 46 * scenarios. This flag is initialized as FALSE in case the card 47 * is removed, and will be set to TRUE for module removal when 48 * module_exit function is called. 49 */ 50static u8 user_rmmod; 51static u8 sdio_ireg; 52 53static const struct btmrvl_sdio_card_reg btmrvl_reg_8688 = { 54 .cfg = 0x03, 55 .host_int_mask = 0x04, 56 .host_intstatus = 0x05, 57 .card_status = 0x20, 58 .sq_read_base_addr_a0 = 0x10, 59 .sq_read_base_addr_a1 = 0x11, 60 .card_fw_status0 = 0x40, 61 .card_fw_status1 = 0x41, 62 .card_rx_len = 0x42, 63 .card_rx_unit = 0x43, 64 .io_port_0 = 0x00, 65 .io_port_1 = 0x01, 66 .io_port_2 = 0x02, 67 .int_read_to_clear = false, 68}; 69static const struct btmrvl_sdio_card_reg btmrvl_reg_87xx = { 70 .cfg = 0x00, 71 .host_int_mask = 0x02, 72 .host_intstatus = 0x03, 73 .card_status = 0x30, 74 .sq_read_base_addr_a0 = 0x40, 75 .sq_read_base_addr_a1 = 0x41, 76 .card_revision = 0x5c, 77 .card_fw_status0 = 0x60, 78 .card_fw_status1 = 0x61, 79 .card_rx_len = 0x62, 80 .card_rx_unit = 0x63, 81 .io_port_0 = 0x78, 82 .io_port_1 = 0x79, 83 .io_port_2 = 0x7a, 84 .int_read_to_clear = false, 85}; 86 87static const struct btmrvl_sdio_card_reg btmrvl_reg_88xx = { 88 .cfg = 0x00, 89 .host_int_mask = 0x02, 90 .host_intstatus = 0x03, 91 .card_status = 0x50, 92 .sq_read_base_addr_a0 = 0x60, 93 .sq_read_base_addr_a1 = 0x61, 94 .card_revision = 0xbc, 95 .card_fw_status0 = 0xc0, 96 .card_fw_status1 = 0xc1, 97 .card_rx_len = 0xc2, 98 .card_rx_unit = 0xc3, 99 .io_port_0 = 0xd8, 100 .io_port_1 = 0xd9, 101 .io_port_2 = 0xda, 102 .int_read_to_clear = true, 103 .host_int_rsr = 0x01, 104 .card_misc_cfg = 0xcc, 105}; 106 107static const struct btmrvl_sdio_device btmrvl_sdio_sd8688 = { 108 .helper = "mrvl/sd8688_helper.bin", 109 .firmware = "mrvl/sd8688.bin", 110 .reg = &btmrvl_reg_8688, 111 .sd_blksz_fw_dl = 64, 112}; 113 114static const struct btmrvl_sdio_device btmrvl_sdio_sd8787 = { 115 .helper = NULL, 116 .firmware = "mrvl/sd8787_uapsta.bin", 117 .reg = &btmrvl_reg_87xx, 118 .sd_blksz_fw_dl = 256, 119}; 120 121static const struct btmrvl_sdio_device btmrvl_sdio_sd8797 = { 122 .helper = NULL, 123 .firmware = "mrvl/sd8797_uapsta.bin", 124 .reg = &btmrvl_reg_87xx, 125 .sd_blksz_fw_dl = 256, 126}; 127 128static const struct btmrvl_sdio_device btmrvl_sdio_sd8897 = { 129 .helper = NULL, 130 .firmware = "mrvl/sd8897_uapsta.bin", 131 .reg = &btmrvl_reg_88xx, 132 .sd_blksz_fw_dl = 256, 133}; 134 135static const struct sdio_device_id btmrvl_sdio_ids[] = { 136 /* Marvell SD8688 Bluetooth device */ 137 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, 0x9105), 138 .driver_data = (unsigned long) &btmrvl_sdio_sd8688 }, 139 /* Marvell SD8787 Bluetooth device */ 140 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, 0x911A), 141 .driver_data = (unsigned long) &btmrvl_sdio_sd8787 }, 142 /* Marvell SD8787 Bluetooth AMP device */ 143 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, 0x911B), 144 .driver_data = (unsigned long) &btmrvl_sdio_sd8787 }, 145 /* Marvell SD8797 Bluetooth device */ 146 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, 0x912A), 147 .driver_data = (unsigned long) &btmrvl_sdio_sd8797 }, 148 /* Marvell SD8897 Bluetooth device */ 149 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, 0x912E), 150 .driver_data = (unsigned long) &btmrvl_sdio_sd8897 }, 151 152 { } /* Terminating entry */ 153}; 154 155MODULE_DEVICE_TABLE(sdio, btmrvl_sdio_ids); 156 157static int btmrvl_sdio_get_rx_unit(struct btmrvl_sdio_card *card) 158{ 159 u8 reg; 160 int ret; 161 162 reg = sdio_readb(card->func, card->reg->card_rx_unit, &ret); 163 if (!ret) 164 card->rx_unit = reg; 165 166 return ret; 167} 168 169static int btmrvl_sdio_read_fw_status(struct btmrvl_sdio_card *card, u16 *dat) 170{ 171 u8 fws0, fws1; 172 int ret; 173 174 *dat = 0; 175 176 fws0 = sdio_readb(card->func, card->reg->card_fw_status0, &ret); 177 if (ret) 178 return -EIO; 179 180 fws1 = sdio_readb(card->func, card->reg->card_fw_status1, &ret); 181 if (ret) 182 return -EIO; 183 184 *dat = (((u16) fws1) << 8) | fws0; 185 186 return 0; 187} 188 189static int btmrvl_sdio_read_rx_len(struct btmrvl_sdio_card *card, u16 *dat) 190{ 191 u8 reg; 192 int ret; 193 194 reg = sdio_readb(card->func, card->reg->card_rx_len, &ret); 195 if (!ret) 196 *dat = (u16) reg << card->rx_unit; 197 198 return ret; 199} 200 201static int btmrvl_sdio_enable_host_int_mask(struct btmrvl_sdio_card *card, 202 u8 mask) 203{ 204 int ret; 205 206 sdio_writeb(card->func, mask, card->reg->host_int_mask, &ret); 207 if (ret) { 208 BT_ERR("Unable to enable the host interrupt!"); 209 ret = -EIO; 210 } 211 212 return ret; 213} 214 215static int btmrvl_sdio_disable_host_int_mask(struct btmrvl_sdio_card *card, 216 u8 mask) 217{ 218 u8 host_int_mask; 219 int ret; 220 221 host_int_mask = sdio_readb(card->func, card->reg->host_int_mask, &ret); 222 if (ret) 223 return -EIO; 224 225 host_int_mask &= ~mask; 226 227 sdio_writeb(card->func, host_int_mask, card->reg->host_int_mask, &ret); 228 if (ret < 0) { 229 BT_ERR("Unable to disable the host interrupt!"); 230 return -EIO; 231 } 232 233 return 0; 234} 235 236static int btmrvl_sdio_poll_card_status(struct btmrvl_sdio_card *card, u8 bits) 237{ 238 unsigned int tries; 239 u8 status; 240 int ret; 241 242 for (tries = 0; tries < MAX_POLL_TRIES * 1000; tries++) { 243 status = sdio_readb(card->func, card->reg->card_status, &ret); 244 if (ret) 245 goto failed; 246 if ((status & bits) == bits) 247 return ret; 248 249 udelay(1); 250 } 251 252 ret = -ETIMEDOUT; 253 254failed: 255 BT_ERR("FAILED! ret=%d", ret); 256 257 return ret; 258} 259 260static int btmrvl_sdio_verify_fw_download(struct btmrvl_sdio_card *card, 261 int pollnum) 262{ 263 u16 firmwarestat; 264 int tries, ret; 265 266 /* Wait for firmware to become ready */ 267 for (tries = 0; tries < pollnum; tries++) { 268 sdio_claim_host(card->func); 269 ret = btmrvl_sdio_read_fw_status(card, &firmwarestat); 270 sdio_release_host(card->func); 271 if (ret < 0) 272 continue; 273 274 if (firmwarestat == FIRMWARE_READY) 275 return 0; 276 277 msleep(10); 278 } 279 280 return -ETIMEDOUT; 281} 282 283static int btmrvl_sdio_download_helper(struct btmrvl_sdio_card *card) 284{ 285 const struct firmware *fw_helper = NULL; 286 const u8 *helper = NULL; 287 int ret; 288 void *tmphlprbuf = NULL; 289 int tmphlprbufsz, hlprblknow, helperlen; 290 u8 *helperbuf; 291 u32 tx_len; 292 293 ret = request_firmware(&fw_helper, card->helper, 294 &card->func->dev); 295 if ((ret < 0) || !fw_helper) { 296 BT_ERR("request_firmware(helper) failed, error code = %d", 297 ret); 298 ret = -ENOENT; 299 goto done; 300 } 301 302 helper = fw_helper->data; 303 helperlen = fw_helper->size; 304 305 BT_DBG("Downloading helper image (%d bytes), block size %d bytes", 306 helperlen, SDIO_BLOCK_SIZE); 307 308 tmphlprbufsz = ALIGN_SZ(BTM_UPLD_SIZE, BTSDIO_DMA_ALIGN); 309 310 tmphlprbuf = kzalloc(tmphlprbufsz, GFP_KERNEL); 311 if (!tmphlprbuf) { 312 BT_ERR("Unable to allocate buffer for helper." 313 " Terminating download"); 314 ret = -ENOMEM; 315 goto done; 316 } 317 318 helperbuf = (u8 *) ALIGN_ADDR(tmphlprbuf, BTSDIO_DMA_ALIGN); 319 320 /* Perform helper data transfer */ 321 tx_len = (FIRMWARE_TRANSFER_NBLOCK * SDIO_BLOCK_SIZE) 322 - SDIO_HEADER_LEN; 323 hlprblknow = 0; 324 325 do { 326 ret = btmrvl_sdio_poll_card_status(card, 327 CARD_IO_READY | DN_LD_CARD_RDY); 328 if (ret < 0) { 329 BT_ERR("Helper download poll status timeout @ %d", 330 hlprblknow); 331 goto done; 332 } 333 334 /* Check if there is more data? */ 335 if (hlprblknow >= helperlen) 336 break; 337 338 if (helperlen - hlprblknow < tx_len) 339 tx_len = helperlen - hlprblknow; 340 341 /* Little-endian */ 342 helperbuf[0] = ((tx_len & 0x000000ff) >> 0); 343 helperbuf[1] = ((tx_len & 0x0000ff00) >> 8); 344 helperbuf[2] = ((tx_len & 0x00ff0000) >> 16); 345 helperbuf[3] = ((tx_len & 0xff000000) >> 24); 346 347 memcpy(&helperbuf[SDIO_HEADER_LEN], &helper[hlprblknow], 348 tx_len); 349 350 /* Now send the data */ 351 ret = sdio_writesb(card->func, card->ioport, helperbuf, 352 FIRMWARE_TRANSFER_NBLOCK * SDIO_BLOCK_SIZE); 353 if (ret < 0) { 354 BT_ERR("IO error during helper download @ %d", 355 hlprblknow); 356 goto done; 357 } 358 359 hlprblknow += tx_len; 360 } while (true); 361 362 BT_DBG("Transferring helper image EOF block"); 363 364 memset(helperbuf, 0x0, SDIO_BLOCK_SIZE); 365 366 ret = sdio_writesb(card->func, card->ioport, helperbuf, 367 SDIO_BLOCK_SIZE); 368 if (ret < 0) { 369 BT_ERR("IO error in writing helper image EOF block"); 370 goto done; 371 } 372 373 ret = 0; 374 375done: 376 kfree(tmphlprbuf); 377 release_firmware(fw_helper); 378 return ret; 379} 380 381static int btmrvl_sdio_download_fw_w_helper(struct btmrvl_sdio_card *card) 382{ 383 const struct firmware *fw_firmware = NULL; 384 const u8 *firmware = NULL; 385 int firmwarelen, tmpfwbufsz, ret; 386 unsigned int tries, offset; 387 u8 base0, base1; 388 void *tmpfwbuf = NULL; 389 u8 *fwbuf; 390 u16 len, blksz_dl = card->sd_blksz_fw_dl; 391 int txlen = 0, tx_blocks = 0, count = 0; 392 393 ret = request_firmware(&fw_firmware, card->firmware, 394 &card->func->dev); 395 if ((ret < 0) || !fw_firmware) { 396 BT_ERR("request_firmware(firmware) failed, error code = %d", 397 ret); 398 ret = -ENOENT; 399 goto done; 400 } 401 402 firmware = fw_firmware->data; 403 firmwarelen = fw_firmware->size; 404 405 BT_DBG("Downloading FW image (%d bytes)", firmwarelen); 406 407 tmpfwbufsz = ALIGN_SZ(BTM_UPLD_SIZE, BTSDIO_DMA_ALIGN); 408 tmpfwbuf = kzalloc(tmpfwbufsz, GFP_KERNEL); 409 if (!tmpfwbuf) { 410 BT_ERR("Unable to allocate buffer for firmware." 411 " Terminating download"); 412 ret = -ENOMEM; 413 goto done; 414 } 415 416 /* Ensure aligned firmware buffer */ 417 fwbuf = (u8 *) ALIGN_ADDR(tmpfwbuf, BTSDIO_DMA_ALIGN); 418 419 /* Perform firmware data transfer */ 420 offset = 0; 421 do { 422 ret = btmrvl_sdio_poll_card_status(card, 423 CARD_IO_READY | DN_LD_CARD_RDY); 424 if (ret < 0) { 425 BT_ERR("FW download with helper poll status" 426 " timeout @ %d", offset); 427 goto done; 428 } 429 430 /* Check if there is more data ? */ 431 if (offset >= firmwarelen) 432 break; 433 434 for (tries = 0; tries < MAX_POLL_TRIES; tries++) { 435 base0 = sdio_readb(card->func, 436 card->reg->sq_read_base_addr_a0, &ret); 437 if (ret) { 438 BT_ERR("BASE0 register read failed:" 439 " base0 = 0x%04X(%d)." 440 " Terminating download", 441 base0, base0); 442 ret = -EIO; 443 goto done; 444 } 445 base1 = sdio_readb(card->func, 446 card->reg->sq_read_base_addr_a1, &ret); 447 if (ret) { 448 BT_ERR("BASE1 register read failed:" 449 " base1 = 0x%04X(%d)." 450 " Terminating download", 451 base1, base1); 452 ret = -EIO; 453 goto done; 454 } 455 456 len = (((u16) base1) << 8) | base0; 457 if (len) 458 break; 459 460 udelay(10); 461 } 462 463 if (!len) 464 break; 465 else if (len > BTM_UPLD_SIZE) { 466 BT_ERR("FW download failure @%d, invalid length %d", 467 offset, len); 468 ret = -EINVAL; 469 goto done; 470 } 471 472 txlen = len; 473 474 if (len & BIT(0)) { 475 count++; 476 if (count > MAX_WRITE_IOMEM_RETRY) { 477 BT_ERR("FW download failure @%d, " 478 "over max retry count", offset); 479 ret = -EIO; 480 goto done; 481 } 482 BT_ERR("FW CRC error indicated by the helper: " 483 "len = 0x%04X, txlen = %d", len, txlen); 484 len &= ~BIT(0); 485 /* Set txlen to 0 so as to resend from same offset */ 486 txlen = 0; 487 } else { 488 count = 0; 489 490 /* Last block ? */ 491 if (firmwarelen - offset < txlen) 492 txlen = firmwarelen - offset; 493 494 tx_blocks = DIV_ROUND_UP(txlen, blksz_dl); 495 496 memcpy(fwbuf, &firmware[offset], txlen); 497 } 498 499 ret = sdio_writesb(card->func, card->ioport, fwbuf, 500 tx_blocks * blksz_dl); 501 502 if (ret < 0) { 503 BT_ERR("FW download, writesb(%d) failed @%d", 504 count, offset); 505 sdio_writeb(card->func, HOST_CMD53_FIN, 506 card->reg->cfg, &ret); 507 if (ret) 508 BT_ERR("writeb failed (CFG)"); 509 } 510 511 offset += txlen; 512 } while (true); 513 514 BT_DBG("FW download over, size %d bytes", offset); 515 516 ret = 0; 517 518done: 519 kfree(tmpfwbuf); 520 release_firmware(fw_firmware); 521 return ret; 522} 523 524static int btmrvl_sdio_card_to_host(struct btmrvl_private *priv) 525{ 526 u16 buf_len = 0; 527 int ret, num_blocks, blksz; 528 struct sk_buff *skb = NULL; 529 u32 type; 530 u8 *payload = NULL; 531 struct hci_dev *hdev = priv->btmrvl_dev.hcidev; 532 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card; 533 534 if (!card || !card->func) { 535 BT_ERR("card or function is NULL!"); 536 ret = -EINVAL; 537 goto exit; 538 } 539 540 /* Read the length of data to be transferred */ 541 ret = btmrvl_sdio_read_rx_len(card, &buf_len); 542 if (ret < 0) { 543 BT_ERR("read rx_len failed"); 544 ret = -EIO; 545 goto exit; 546 } 547 548 blksz = SDIO_BLOCK_SIZE; 549 num_blocks = DIV_ROUND_UP(buf_len, blksz); 550 551 if (buf_len <= SDIO_HEADER_LEN 552 || (num_blocks * blksz) > ALLOC_BUF_SIZE) { 553 BT_ERR("invalid packet length: %d", buf_len); 554 ret = -EINVAL; 555 goto exit; 556 } 557 558 /* Allocate buffer */ 559 skb = bt_skb_alloc(num_blocks * blksz + BTSDIO_DMA_ALIGN, GFP_ATOMIC); 560 if (skb == NULL) { 561 BT_ERR("No free skb"); 562 ret = -ENOMEM; 563 goto exit; 564 } 565 566 if ((unsigned long) skb->data & (BTSDIO_DMA_ALIGN - 1)) { 567 skb_put(skb, (unsigned long) skb->data & 568 (BTSDIO_DMA_ALIGN - 1)); 569 skb_pull(skb, (unsigned long) skb->data & 570 (BTSDIO_DMA_ALIGN - 1)); 571 } 572 573 payload = skb->data; 574 575 ret = sdio_readsb(card->func, payload, card->ioport, 576 num_blocks * blksz); 577 if (ret < 0) { 578 BT_ERR("readsb failed: %d", ret); 579 ret = -EIO; 580 goto exit; 581 } 582 583 /* This is SDIO specific header length: byte[2][1][0], type: byte[3] 584 * (HCI_COMMAND = 1, ACL_DATA = 2, SCO_DATA = 3, 0xFE = Vendor) 585 */ 586 587 buf_len = payload[0]; 588 buf_len |= payload[1] << 8; 589 buf_len |= payload[2] << 16; 590 591 if (buf_len > blksz * num_blocks) { 592 BT_ERR("Skip incorrect packet: hdrlen %d buffer %d", 593 buf_len, blksz * num_blocks); 594 ret = -EIO; 595 goto exit; 596 } 597 598 type = payload[3]; 599 600 switch (type) { 601 case HCI_ACLDATA_PKT: 602 case HCI_SCODATA_PKT: 603 case HCI_EVENT_PKT: 604 bt_cb(skb)->pkt_type = type; 605 skb_put(skb, buf_len); 606 skb_pull(skb, SDIO_HEADER_LEN); 607 608 if (type == HCI_EVENT_PKT) { 609 if (btmrvl_check_evtpkt(priv, skb)) 610 hci_recv_frame(hdev, skb); 611 } else { 612 hci_recv_frame(hdev, skb); 613 } 614 615 hdev->stat.byte_rx += buf_len; 616 break; 617 618 case MRVL_VENDOR_PKT: 619 bt_cb(skb)->pkt_type = HCI_VENDOR_PKT; 620 skb_put(skb, buf_len); 621 skb_pull(skb, SDIO_HEADER_LEN); 622 623 if (btmrvl_process_event(priv, skb)) 624 hci_recv_frame(hdev, skb); 625 626 hdev->stat.byte_rx += buf_len; 627 break; 628 629 default: 630 BT_ERR("Unknown packet type:%d", type); 631 BT_ERR("hex: %*ph", blksz * num_blocks, payload); 632 633 kfree_skb(skb); 634 skb = NULL; 635 break; 636 } 637 638exit: 639 if (ret) { 640 hdev->stat.err_rx++; 641 kfree_skb(skb); 642 } 643 644 return ret; 645} 646 647static int btmrvl_sdio_process_int_status(struct btmrvl_private *priv) 648{ 649 ulong flags; 650 u8 ireg; 651 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card; 652 653 spin_lock_irqsave(&priv->driver_lock, flags); 654 ireg = sdio_ireg; 655 sdio_ireg = 0; 656 spin_unlock_irqrestore(&priv->driver_lock, flags); 657 658 sdio_claim_host(card->func); 659 if (ireg & DN_LD_HOST_INT_STATUS) { 660 if (priv->btmrvl_dev.tx_dnld_rdy) 661 BT_DBG("tx_done already received: " 662 " int_status=0x%x", ireg); 663 else 664 priv->btmrvl_dev.tx_dnld_rdy = true; 665 } 666 667 if (ireg & UP_LD_HOST_INT_STATUS) 668 btmrvl_sdio_card_to_host(priv); 669 670 sdio_release_host(card->func); 671 672 return 0; 673} 674 675static int btmrvl_sdio_read_to_clear(struct btmrvl_sdio_card *card, u8 *ireg) 676{ 677 struct btmrvl_adapter *adapter = card->priv->adapter; 678 int ret; 679 680 ret = sdio_readsb(card->func, adapter->hw_regs, 0, SDIO_BLOCK_SIZE); 681 if (ret) { 682 BT_ERR("sdio_readsb: read int hw_regs failed: %d", ret); 683 return ret; 684 } 685 686 *ireg = adapter->hw_regs[card->reg->host_intstatus]; 687 BT_DBG("hw_regs[%#x]=%#x", card->reg->host_intstatus, *ireg); 688 689 return 0; 690} 691 692static int btmrvl_sdio_write_to_clear(struct btmrvl_sdio_card *card, u8 *ireg) 693{ 694 int ret; 695 696 *ireg = sdio_readb(card->func, card->reg->host_intstatus, &ret); 697 if (ret) { 698 BT_ERR("sdio_readb: read int status failed: %d", ret); 699 return ret; 700 } 701 702 if (*ireg) { 703 /* 704 * DN_LD_HOST_INT_STATUS and/or UP_LD_HOST_INT_STATUS 705 * Clear the interrupt status register and re-enable the 706 * interrupt. 707 */ 708 BT_DBG("int_status = 0x%x", *ireg); 709 710 sdio_writeb(card->func, ~(*ireg) & (DN_LD_HOST_INT_STATUS | 711 UP_LD_HOST_INT_STATUS), 712 card->reg->host_intstatus, &ret); 713 if (ret) { 714 BT_ERR("sdio_writeb: clear int status failed: %d", ret); 715 return ret; 716 } 717 } 718 719 return 0; 720} 721 722static void btmrvl_sdio_interrupt(struct sdio_func *func) 723{ 724 struct btmrvl_private *priv; 725 struct btmrvl_sdio_card *card; 726 ulong flags; 727 u8 ireg = 0; 728 int ret; 729 730 card = sdio_get_drvdata(func); 731 if (!card || !card->priv) { 732 BT_ERR("sbi_interrupt(%p) card or priv is " 733 "NULL, card=%p\n", func, card); 734 return; 735 } 736 737 priv = card->priv; 738 739 if (card->reg->int_read_to_clear) 740 ret = btmrvl_sdio_read_to_clear(card, &ireg); 741 else 742 ret = btmrvl_sdio_write_to_clear(card, &ireg); 743 744 if (ret) 745 return; 746 747 spin_lock_irqsave(&priv->driver_lock, flags); 748 sdio_ireg |= ireg; 749 spin_unlock_irqrestore(&priv->driver_lock, flags); 750 751 btmrvl_interrupt(priv); 752} 753 754static int btmrvl_sdio_register_dev(struct btmrvl_sdio_card *card) 755{ 756 struct sdio_func *func; 757 u8 reg; 758 int ret = 0; 759 760 if (!card || !card->func) { 761 BT_ERR("Error: card or function is NULL!"); 762 ret = -EINVAL; 763 goto failed; 764 } 765 766 func = card->func; 767 768 sdio_claim_host(func); 769 770 ret = sdio_enable_func(func); 771 if (ret) { 772 BT_ERR("sdio_enable_func() failed: ret=%d", ret); 773 ret = -EIO; 774 goto release_host; 775 } 776 777 ret = sdio_claim_irq(func, btmrvl_sdio_interrupt); 778 if (ret) { 779 BT_ERR("sdio_claim_irq failed: ret=%d", ret); 780 ret = -EIO; 781 goto disable_func; 782 } 783 784 ret = sdio_set_block_size(card->func, SDIO_BLOCK_SIZE); 785 if (ret) { 786 BT_ERR("cannot set SDIO block size"); 787 ret = -EIO; 788 goto release_irq; 789 } 790 791 reg = sdio_readb(func, card->reg->io_port_0, &ret); 792 if (ret < 0) { 793 ret = -EIO; 794 goto release_irq; 795 } 796 797 card->ioport = reg; 798 799 reg = sdio_readb(func, card->reg->io_port_1, &ret); 800 if (ret < 0) { 801 ret = -EIO; 802 goto release_irq; 803 } 804 805 card->ioport |= (reg << 8); 806 807 reg = sdio_readb(func, card->reg->io_port_2, &ret); 808 if (ret < 0) { 809 ret = -EIO; 810 goto release_irq; 811 } 812 813 card->ioport |= (reg << 16); 814 815 BT_DBG("SDIO FUNC%d IO port: 0x%x", func->num, card->ioport); 816 817 if (card->reg->int_read_to_clear) { 818 reg = sdio_readb(func, card->reg->host_int_rsr, &ret); 819 if (ret < 0) { 820 ret = -EIO; 821 goto release_irq; 822 } 823 sdio_writeb(func, reg | 0x3f, card->reg->host_int_rsr, &ret); 824 if (ret < 0) { 825 ret = -EIO; 826 goto release_irq; 827 } 828 829 reg = sdio_readb(func, card->reg->card_misc_cfg, &ret); 830 if (ret < 0) { 831 ret = -EIO; 832 goto release_irq; 833 } 834 sdio_writeb(func, reg | 0x10, card->reg->card_misc_cfg, &ret); 835 if (ret < 0) { 836 ret = -EIO; 837 goto release_irq; 838 } 839 } 840 841 sdio_set_drvdata(func, card); 842 843 sdio_release_host(func); 844 845 return 0; 846 847release_irq: 848 sdio_release_irq(func); 849 850disable_func: 851 sdio_disable_func(func); 852 853release_host: 854 sdio_release_host(func); 855 856failed: 857 return ret; 858} 859 860static int btmrvl_sdio_unregister_dev(struct btmrvl_sdio_card *card) 861{ 862 if (card && card->func) { 863 sdio_claim_host(card->func); 864 sdio_release_irq(card->func); 865 sdio_disable_func(card->func); 866 sdio_release_host(card->func); 867 sdio_set_drvdata(card->func, NULL); 868 } 869 870 return 0; 871} 872 873static int btmrvl_sdio_enable_host_int(struct btmrvl_sdio_card *card) 874{ 875 int ret; 876 877 if (!card || !card->func) 878 return -EINVAL; 879 880 sdio_claim_host(card->func); 881 882 ret = btmrvl_sdio_enable_host_int_mask(card, HIM_ENABLE); 883 884 btmrvl_sdio_get_rx_unit(card); 885 886 sdio_release_host(card->func); 887 888 return ret; 889} 890 891static int btmrvl_sdio_disable_host_int(struct btmrvl_sdio_card *card) 892{ 893 int ret; 894 895 if (!card || !card->func) 896 return -EINVAL; 897 898 sdio_claim_host(card->func); 899 900 ret = btmrvl_sdio_disable_host_int_mask(card, HIM_DISABLE); 901 902 sdio_release_host(card->func); 903 904 return ret; 905} 906 907static int btmrvl_sdio_host_to_card(struct btmrvl_private *priv, 908 u8 *payload, u16 nb) 909{ 910 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card; 911 int ret = 0; 912 int buf_block_len; 913 int blksz; 914 int i = 0; 915 u8 *buf = NULL; 916 void *tmpbuf = NULL; 917 int tmpbufsz; 918 919 if (!card || !card->func) { 920 BT_ERR("card or function is NULL!"); 921 return -EINVAL; 922 } 923 924 buf = payload; 925 if ((unsigned long) payload & (BTSDIO_DMA_ALIGN - 1)) { 926 tmpbufsz = ALIGN_SZ(nb, BTSDIO_DMA_ALIGN); 927 tmpbuf = kzalloc(tmpbufsz, GFP_KERNEL); 928 if (!tmpbuf) 929 return -ENOMEM; 930 buf = (u8 *) ALIGN_ADDR(tmpbuf, BTSDIO_DMA_ALIGN); 931 memcpy(buf, payload, nb); 932 } 933 934 blksz = SDIO_BLOCK_SIZE; 935 buf_block_len = DIV_ROUND_UP(nb, blksz); 936 937 sdio_claim_host(card->func); 938 939 do { 940 /* Transfer data to card */ 941 ret = sdio_writesb(card->func, card->ioport, buf, 942 buf_block_len * blksz); 943 if (ret < 0) { 944 i++; 945 BT_ERR("i=%d writesb failed: %d", i, ret); 946 BT_ERR("hex: %*ph", nb, payload); 947 ret = -EIO; 948 if (i > MAX_WRITE_IOMEM_RETRY) 949 goto exit; 950 } 951 } while (ret); 952 953 priv->btmrvl_dev.tx_dnld_rdy = false; 954 955exit: 956 sdio_release_host(card->func); 957 kfree(tmpbuf); 958 959 return ret; 960} 961 962static int btmrvl_sdio_download_fw(struct btmrvl_sdio_card *card) 963{ 964 int ret; 965 u8 fws0; 966 int pollnum = MAX_POLL_TRIES; 967 968 if (!card || !card->func) { 969 BT_ERR("card or function is NULL!"); 970 return -EINVAL; 971 } 972 973 if (!btmrvl_sdio_verify_fw_download(card, 1)) { 974 BT_DBG("Firmware already downloaded!"); 975 return 0; 976 } 977 978 sdio_claim_host(card->func); 979 980 /* Check if other function driver is downloading the firmware */ 981 fws0 = sdio_readb(card->func, card->reg->card_fw_status0, &ret); 982 if (ret) { 983 BT_ERR("Failed to read FW downloading status!"); 984 ret = -EIO; 985 goto done; 986 } 987 if (fws0) { 988 BT_DBG("BT not the winner (%#x). Skip FW downloading", fws0); 989 990 /* Give other function more time to download the firmware */ 991 pollnum *= 10; 992 } else { 993 if (card->helper) { 994 ret = btmrvl_sdio_download_helper(card); 995 if (ret) { 996 BT_ERR("Failed to download helper!"); 997 ret = -EIO; 998 goto done; 999 } 1000 } 1001 1002 if (btmrvl_sdio_download_fw_w_helper(card)) { 1003 BT_ERR("Failed to download firmware!"); 1004 ret = -EIO; 1005 goto done; 1006 } 1007 } 1008 1009 sdio_release_host(card->func); 1010 1011 /* 1012 * winner or not, with this test the FW synchronizes when the 1013 * module can continue its initialization 1014 */ 1015 if (btmrvl_sdio_verify_fw_download(card, pollnum)) { 1016 BT_ERR("FW failed to be active in time!"); 1017 return -ETIMEDOUT; 1018 } 1019 1020 return 0; 1021 1022done: 1023 sdio_release_host(card->func); 1024 return ret; 1025} 1026 1027static int btmrvl_sdio_wakeup_fw(struct btmrvl_private *priv) 1028{ 1029 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card; 1030 int ret = 0; 1031 1032 if (!card || !card->func) { 1033 BT_ERR("card or function is NULL!"); 1034 return -EINVAL; 1035 } 1036 1037 sdio_claim_host(card->func); 1038 1039 sdio_writeb(card->func, HOST_POWER_UP, card->reg->cfg, &ret); 1040 1041 sdio_release_host(card->func); 1042 1043 BT_DBG("wake up firmware"); 1044 1045 return ret; 1046} 1047 1048static int btmrvl_sdio_probe(struct sdio_func *func, 1049 const struct sdio_device_id *id) 1050{ 1051 int ret = 0; 1052 struct btmrvl_private *priv = NULL; 1053 struct btmrvl_sdio_card *card = NULL; 1054 1055 BT_INFO("vendor=0x%x, device=0x%x, class=%d, fn=%d", 1056 id->vendor, id->device, id->class, func->num); 1057 1058 card = devm_kzalloc(&func->dev, sizeof(*card), GFP_KERNEL); 1059 if (!card) 1060 return -ENOMEM; 1061 1062 card->func = func; 1063 1064 if (id->driver_data) { 1065 struct btmrvl_sdio_device *data = (void *) id->driver_data; 1066 card->helper = data->helper; 1067 card->firmware = data->firmware; 1068 card->reg = data->reg; 1069 card->sd_blksz_fw_dl = data->sd_blksz_fw_dl; 1070 } 1071 1072 if (btmrvl_sdio_register_dev(card) < 0) { 1073 BT_ERR("Failed to register BT device!"); 1074 return -ENODEV; 1075 } 1076 1077 /* Disable the interrupts on the card */ 1078 btmrvl_sdio_disable_host_int(card); 1079 1080 if (btmrvl_sdio_download_fw(card)) { 1081 BT_ERR("Downloading firmware failed!"); 1082 ret = -ENODEV; 1083 goto unreg_dev; 1084 } 1085 1086 btmrvl_sdio_enable_host_int(card); 1087 1088 priv = btmrvl_add_card(card); 1089 if (!priv) { 1090 BT_ERR("Initializing card failed!"); 1091 ret = -ENODEV; 1092 goto disable_host_int; 1093 } 1094 1095 card->priv = priv; 1096 1097 /* Initialize the interface specific function pointers */ 1098 priv->hw_host_to_card = btmrvl_sdio_host_to_card; 1099 priv->hw_wakeup_firmware = btmrvl_sdio_wakeup_fw; 1100 priv->hw_process_int_status = btmrvl_sdio_process_int_status; 1101 1102 if (btmrvl_register_hdev(priv)) { 1103 BT_ERR("Register hdev failed!"); 1104 ret = -ENODEV; 1105 goto disable_host_int; 1106 } 1107 1108 return 0; 1109 1110disable_host_int: 1111 btmrvl_sdio_disable_host_int(card); 1112unreg_dev: 1113 btmrvl_sdio_unregister_dev(card); 1114 return ret; 1115} 1116 1117static void btmrvl_sdio_remove(struct sdio_func *func) 1118{ 1119 struct btmrvl_sdio_card *card; 1120 1121 if (func) { 1122 card = sdio_get_drvdata(func); 1123 if (card) { 1124 /* Send SHUTDOWN command & disable interrupt 1125 * if user removes the module. 1126 */ 1127 if (user_rmmod) { 1128 btmrvl_send_module_cfg_cmd(card->priv, 1129 MODULE_SHUTDOWN_REQ); 1130 btmrvl_sdio_disable_host_int(card); 1131 } 1132 BT_DBG("unregester dev"); 1133 btmrvl_sdio_unregister_dev(card); 1134 btmrvl_remove_card(card->priv); 1135 } 1136 } 1137} 1138 1139static int btmrvl_sdio_suspend(struct device *dev) 1140{ 1141 struct sdio_func *func = dev_to_sdio_func(dev); 1142 struct btmrvl_sdio_card *card; 1143 struct btmrvl_private *priv; 1144 mmc_pm_flag_t pm_flags; 1145 struct hci_dev *hcidev; 1146 1147 if (func) { 1148 pm_flags = sdio_get_host_pm_caps(func); 1149 BT_DBG("%s: suspend: PM flags = 0x%x", sdio_func_id(func), 1150 pm_flags); 1151 if (!(pm_flags & MMC_PM_KEEP_POWER)) { 1152 BT_ERR("%s: cannot remain alive while suspended", 1153 sdio_func_id(func)); 1154 return -ENOSYS; 1155 } 1156 card = sdio_get_drvdata(func); 1157 if (!card || !card->priv) { 1158 BT_ERR("card or priv structure is not valid"); 1159 return 0; 1160 } 1161 } else { 1162 BT_ERR("sdio_func is not specified"); 1163 return 0; 1164 } 1165 1166 priv = card->priv; 1167 1168 if (priv->adapter->hs_state != HS_ACTIVATED) { 1169 if (btmrvl_enable_hs(priv)) { 1170 BT_ERR("HS not actived, suspend failed!"); 1171 return -EBUSY; 1172 } 1173 } 1174 hcidev = priv->btmrvl_dev.hcidev; 1175 BT_DBG("%s: SDIO suspend", hcidev->name); 1176 hci_suspend_dev(hcidev); 1177 skb_queue_purge(&priv->adapter->tx_queue); 1178 1179 priv->adapter->is_suspended = true; 1180 1181 /* We will keep the power when hs enabled successfully */ 1182 if (priv->adapter->hs_state == HS_ACTIVATED) { 1183 BT_DBG("suspend with MMC_PM_KEEP_POWER"); 1184 return sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER); 1185 } else { 1186 BT_DBG("suspend without MMC_PM_KEEP_POWER"); 1187 return 0; 1188 } 1189} 1190 1191static int btmrvl_sdio_resume(struct device *dev) 1192{ 1193 struct sdio_func *func = dev_to_sdio_func(dev); 1194 struct btmrvl_sdio_card *card; 1195 struct btmrvl_private *priv; 1196 mmc_pm_flag_t pm_flags; 1197 struct hci_dev *hcidev; 1198 1199 if (func) { 1200 pm_flags = sdio_get_host_pm_caps(func); 1201 BT_DBG("%s: resume: PM flags = 0x%x", sdio_func_id(func), 1202 pm_flags); 1203 card = sdio_get_drvdata(func); 1204 if (!card || !card->priv) { 1205 BT_ERR("card or priv structure is not valid"); 1206 return 0; 1207 } 1208 } else { 1209 BT_ERR("sdio_func is not specified"); 1210 return 0; 1211 } 1212 priv = card->priv; 1213 1214 if (!priv->adapter->is_suspended) { 1215 BT_DBG("device already resumed"); 1216 return 0; 1217 } 1218 1219 priv->adapter->is_suspended = false; 1220 hcidev = priv->btmrvl_dev.hcidev; 1221 BT_DBG("%s: SDIO resume", hcidev->name); 1222 hci_resume_dev(hcidev); 1223 priv->hw_wakeup_firmware(priv); 1224 priv->adapter->hs_state = HS_DEACTIVATED; 1225 BT_DBG("%s: HS DEACTIVATED in resume!", hcidev->name); 1226 1227 return 0; 1228} 1229 1230static const struct dev_pm_ops btmrvl_sdio_pm_ops = { 1231 .suspend = btmrvl_sdio_suspend, 1232 .resume = btmrvl_sdio_resume, 1233}; 1234 1235static struct sdio_driver bt_mrvl_sdio = { 1236 .name = "btmrvl_sdio", 1237 .id_table = btmrvl_sdio_ids, 1238 .probe = btmrvl_sdio_probe, 1239 .remove = btmrvl_sdio_remove, 1240 .drv = { 1241 .owner = THIS_MODULE, 1242 .pm = &btmrvl_sdio_pm_ops, 1243 } 1244}; 1245 1246static int __init btmrvl_sdio_init_module(void) 1247{ 1248 if (sdio_register_driver(&bt_mrvl_sdio) != 0) { 1249 BT_ERR("SDIO Driver Registration Failed"); 1250 return -ENODEV; 1251 } 1252 1253 /* Clear the flag in case user removes the card. */ 1254 user_rmmod = 0; 1255 1256 return 0; 1257} 1258 1259static void __exit btmrvl_sdio_exit_module(void) 1260{ 1261 /* Set the flag as user is removing this module. */ 1262 user_rmmod = 1; 1263 1264 sdio_unregister_driver(&bt_mrvl_sdio); 1265} 1266 1267module_init(btmrvl_sdio_init_module); 1268module_exit(btmrvl_sdio_exit_module); 1269 1270MODULE_AUTHOR("Marvell International Ltd."); 1271MODULE_DESCRIPTION("Marvell BT-over-SDIO driver ver " VERSION); 1272MODULE_VERSION(VERSION); 1273MODULE_LICENSE("GPL v2"); 1274MODULE_FIRMWARE("mrvl/sd8688_helper.bin"); 1275MODULE_FIRMWARE("mrvl/sd8688.bin"); 1276MODULE_FIRMWARE("mrvl/sd8787_uapsta.bin"); 1277MODULE_FIRMWARE("mrvl/sd8797_uapsta.bin"); 1278MODULE_FIRMWARE("mrvl/sd8897_uapsta.bin"); 1279