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 #include <linux/suspend.h> 24 25 #include <linux/mmc/sdio_ids.h> 26 #include <linux/mmc/sdio_func.h> 27 #include <linux/module.h> 28 #include <linux/devcoredump.h> 29 30 #include <net/bluetooth/bluetooth.h> 31 #include <net/bluetooth/hci_core.h> 32 33 #include "btmrvl_drv.h" 34 #include "btmrvl_sdio.h" 35 36 #define VERSION "1.0" 37 38 static struct memory_type_mapping mem_type_mapping_tbl[] = { 39 {"ITCM", NULL, 0, 0xF0}, 40 {"DTCM", NULL, 0, 0xF1}, 41 {"SQRAM", NULL, 0, 0xF2}, 42 {"APU", NULL, 0, 0xF3}, 43 {"CIU", NULL, 0, 0xF4}, 44 {"ICU", NULL, 0, 0xF5}, 45 {"MAC", NULL, 0, 0xF6}, 46 {"EXT7", NULL, 0, 0xF7}, 47 {"EXT8", NULL, 0, 0xF8}, 48 {"EXT9", NULL, 0, 0xF9}, 49 {"EXT10", NULL, 0, 0xFA}, 50 {"EXT11", NULL, 0, 0xFB}, 51 {"EXT12", NULL, 0, 0xFC}, 52 {"EXT13", NULL, 0, 0xFD}, 53 {"EXTLAST", NULL, 0, 0xFE}, 54 }; 55 56 static const struct of_device_id btmrvl_sdio_of_match_table[] = { 57 { .compatible = "marvell,sd8897-bt" }, 58 { .compatible = "marvell,sd8997-bt" }, 59 { } 60 }; 61 62 static irqreturn_t btmrvl_wake_irq_bt(int irq, void *priv) 63 { 64 struct btmrvl_sdio_card *card = priv; 65 struct btmrvl_plt_wake_cfg *cfg = card->plt_wake_cfg; 66 67 pr_info("%s: wake by bt", __func__); 68 cfg->wake_by_bt = true; 69 disable_irq_nosync(irq); 70 71 pm_wakeup_event(&card->func->dev, 0); 72 pm_system_wakeup(); 73 74 return IRQ_HANDLED; 75 } 76 77 /* This function parses device tree node using mmc subnode devicetree API. 78 * The device node is saved in card->plt_of_node. 79 * If the device tree node exists and includes interrupts attributes, this 80 * function will request platform specific wakeup interrupt. 81 */ 82 static int btmrvl_sdio_probe_of(struct device *dev, 83 struct btmrvl_sdio_card *card) 84 { 85 struct btmrvl_plt_wake_cfg *cfg; 86 int ret; 87 88 if (!dev->of_node || 89 !of_match_node(btmrvl_sdio_of_match_table, dev->of_node)) { 90 pr_err("sdio platform data not available"); 91 return -1; 92 } 93 94 card->plt_of_node = dev->of_node; 95 96 card->plt_wake_cfg = devm_kzalloc(dev, sizeof(*card->plt_wake_cfg), 97 GFP_KERNEL); 98 cfg = card->plt_wake_cfg; 99 if (cfg && card->plt_of_node) { 100 cfg->irq_bt = irq_of_parse_and_map(card->plt_of_node, 0); 101 if (!cfg->irq_bt) { 102 dev_err(dev, "fail to parse irq_bt from device tree"); 103 cfg->irq_bt = -1; 104 } else { 105 ret = devm_request_irq(dev, cfg->irq_bt, 106 btmrvl_wake_irq_bt, 107 0, "bt_wake", card); 108 if (ret) { 109 dev_err(dev, 110 "Failed to request irq_bt %d (%d)\n", 111 cfg->irq_bt, ret); 112 } 113 disable_irq(cfg->irq_bt); 114 } 115 } 116 117 return 0; 118 } 119 120 /* The btmrvl_sdio_remove() callback function is called 121 * when user removes this module from kernel space or ejects 122 * the card from the slot. The driver handles these 2 cases 123 * differently. 124 * If the user is removing the module, a MODULE_SHUTDOWN_REQ 125 * command is sent to firmware and interrupt will be disabled. 126 * If the card is removed, there is no need to send command 127 * or disable interrupt. 128 * 129 * The variable 'user_rmmod' is used to distinguish these two 130 * scenarios. This flag is initialized as FALSE in case the card 131 * is removed, and will be set to TRUE for module removal when 132 * module_exit function is called. 133 */ 134 static u8 user_rmmod; 135 static u8 sdio_ireg; 136 137 static const struct btmrvl_sdio_card_reg btmrvl_reg_8688 = { 138 .cfg = 0x03, 139 .host_int_mask = 0x04, 140 .host_intstatus = 0x05, 141 .card_status = 0x20, 142 .sq_read_base_addr_a0 = 0x10, 143 .sq_read_base_addr_a1 = 0x11, 144 .card_fw_status0 = 0x40, 145 .card_fw_status1 = 0x41, 146 .card_rx_len = 0x42, 147 .card_rx_unit = 0x43, 148 .io_port_0 = 0x00, 149 .io_port_1 = 0x01, 150 .io_port_2 = 0x02, 151 .int_read_to_clear = false, 152 }; 153 static const struct btmrvl_sdio_card_reg btmrvl_reg_87xx = { 154 .cfg = 0x00, 155 .host_int_mask = 0x02, 156 .host_intstatus = 0x03, 157 .card_status = 0x30, 158 .sq_read_base_addr_a0 = 0x40, 159 .sq_read_base_addr_a1 = 0x41, 160 .card_revision = 0x5c, 161 .card_fw_status0 = 0x60, 162 .card_fw_status1 = 0x61, 163 .card_rx_len = 0x62, 164 .card_rx_unit = 0x63, 165 .io_port_0 = 0x78, 166 .io_port_1 = 0x79, 167 .io_port_2 = 0x7a, 168 .int_read_to_clear = false, 169 }; 170 171 static const struct btmrvl_sdio_card_reg btmrvl_reg_8887 = { 172 .cfg = 0x00, 173 .host_int_mask = 0x08, 174 .host_intstatus = 0x0C, 175 .card_status = 0x5C, 176 .sq_read_base_addr_a0 = 0x6C, 177 .sq_read_base_addr_a1 = 0x6D, 178 .card_revision = 0xC8, 179 .card_fw_status0 = 0x88, 180 .card_fw_status1 = 0x89, 181 .card_rx_len = 0x8A, 182 .card_rx_unit = 0x8B, 183 .io_port_0 = 0xE4, 184 .io_port_1 = 0xE5, 185 .io_port_2 = 0xE6, 186 .int_read_to_clear = true, 187 .host_int_rsr = 0x04, 188 .card_misc_cfg = 0xD8, 189 }; 190 191 static const struct btmrvl_sdio_card_reg btmrvl_reg_8897 = { 192 .cfg = 0x00, 193 .host_int_mask = 0x02, 194 .host_intstatus = 0x03, 195 .card_status = 0x50, 196 .sq_read_base_addr_a0 = 0x60, 197 .sq_read_base_addr_a1 = 0x61, 198 .card_revision = 0xbc, 199 .card_fw_status0 = 0xc0, 200 .card_fw_status1 = 0xc1, 201 .card_rx_len = 0xc2, 202 .card_rx_unit = 0xc3, 203 .io_port_0 = 0xd8, 204 .io_port_1 = 0xd9, 205 .io_port_2 = 0xda, 206 .int_read_to_clear = true, 207 .host_int_rsr = 0x01, 208 .card_misc_cfg = 0xcc, 209 .fw_dump_ctrl = 0xe2, 210 .fw_dump_start = 0xe3, 211 .fw_dump_end = 0xea, 212 }; 213 214 static const struct btmrvl_sdio_card_reg btmrvl_reg_8997 = { 215 .cfg = 0x00, 216 .host_int_mask = 0x08, 217 .host_intstatus = 0x0c, 218 .card_status = 0x5c, 219 .sq_read_base_addr_a0 = 0xf8, 220 .sq_read_base_addr_a1 = 0xf9, 221 .card_revision = 0xc8, 222 .card_fw_status0 = 0xe8, 223 .card_fw_status1 = 0xe9, 224 .card_rx_len = 0xea, 225 .card_rx_unit = 0xeb, 226 .io_port_0 = 0xe4, 227 .io_port_1 = 0xe5, 228 .io_port_2 = 0xe6, 229 .int_read_to_clear = true, 230 .host_int_rsr = 0x04, 231 .card_misc_cfg = 0xD8, 232 .fw_dump_ctrl = 0xf0, 233 .fw_dump_start = 0xf1, 234 .fw_dump_end = 0xf8, 235 }; 236 237 static const struct btmrvl_sdio_device btmrvl_sdio_sd8688 = { 238 .helper = "mrvl/sd8688_helper.bin", 239 .firmware = "mrvl/sd8688.bin", 240 .reg = &btmrvl_reg_8688, 241 .support_pscan_win_report = false, 242 .sd_blksz_fw_dl = 64, 243 .supports_fw_dump = false, 244 }; 245 246 static const struct btmrvl_sdio_device btmrvl_sdio_sd8787 = { 247 .helper = NULL, 248 .firmware = "mrvl/sd8787_uapsta.bin", 249 .reg = &btmrvl_reg_87xx, 250 .support_pscan_win_report = false, 251 .sd_blksz_fw_dl = 256, 252 .supports_fw_dump = false, 253 }; 254 255 static const struct btmrvl_sdio_device btmrvl_sdio_sd8797 = { 256 .helper = NULL, 257 .firmware = "mrvl/sd8797_uapsta.bin", 258 .reg = &btmrvl_reg_87xx, 259 .support_pscan_win_report = false, 260 .sd_blksz_fw_dl = 256, 261 .supports_fw_dump = false, 262 }; 263 264 static const struct btmrvl_sdio_device btmrvl_sdio_sd8887 = { 265 .helper = NULL, 266 .firmware = "mrvl/sd8887_uapsta.bin", 267 .reg = &btmrvl_reg_8887, 268 .support_pscan_win_report = true, 269 .sd_blksz_fw_dl = 256, 270 .supports_fw_dump = false, 271 }; 272 273 static const struct btmrvl_sdio_device btmrvl_sdio_sd8897 = { 274 .helper = NULL, 275 .firmware = "mrvl/sd8897_uapsta.bin", 276 .reg = &btmrvl_reg_8897, 277 .support_pscan_win_report = true, 278 .sd_blksz_fw_dl = 256, 279 .supports_fw_dump = true, 280 }; 281 282 static const struct btmrvl_sdio_device btmrvl_sdio_sd8997 = { 283 .helper = NULL, 284 .firmware = "mrvl/sd8997_uapsta.bin", 285 .reg = &btmrvl_reg_8997, 286 .support_pscan_win_report = true, 287 .sd_blksz_fw_dl = 256, 288 .supports_fw_dump = true, 289 }; 290 291 static const struct sdio_device_id btmrvl_sdio_ids[] = { 292 /* Marvell SD8688 Bluetooth device */ 293 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, 0x9105), 294 .driver_data = (unsigned long)&btmrvl_sdio_sd8688 }, 295 /* Marvell SD8787 Bluetooth device */ 296 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, 0x911A), 297 .driver_data = (unsigned long)&btmrvl_sdio_sd8787 }, 298 /* Marvell SD8787 Bluetooth AMP device */ 299 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, 0x911B), 300 .driver_data = (unsigned long)&btmrvl_sdio_sd8787 }, 301 /* Marvell SD8797 Bluetooth device */ 302 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, 0x912A), 303 .driver_data = (unsigned long)&btmrvl_sdio_sd8797 }, 304 /* Marvell SD8887 Bluetooth device */ 305 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, 0x9136), 306 .driver_data = (unsigned long)&btmrvl_sdio_sd8887 }, 307 /* Marvell SD8897 Bluetooth device */ 308 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, 0x912E), 309 .driver_data = (unsigned long)&btmrvl_sdio_sd8897 }, 310 /* Marvell SD8997 Bluetooth device */ 311 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, 0x9142), 312 .driver_data = (unsigned long)&btmrvl_sdio_sd8997 }, 313 314 { } /* Terminating entry */ 315 }; 316 317 MODULE_DEVICE_TABLE(sdio, btmrvl_sdio_ids); 318 319 static int btmrvl_sdio_get_rx_unit(struct btmrvl_sdio_card *card) 320 { 321 u8 reg; 322 int ret; 323 324 reg = sdio_readb(card->func, card->reg->card_rx_unit, &ret); 325 if (!ret) 326 card->rx_unit = reg; 327 328 return ret; 329 } 330 331 static int btmrvl_sdio_read_fw_status(struct btmrvl_sdio_card *card, u16 *dat) 332 { 333 u8 fws0, fws1; 334 int ret; 335 336 *dat = 0; 337 338 fws0 = sdio_readb(card->func, card->reg->card_fw_status0, &ret); 339 if (ret) 340 return -EIO; 341 342 fws1 = sdio_readb(card->func, card->reg->card_fw_status1, &ret); 343 if (ret) 344 return -EIO; 345 346 *dat = (((u16) fws1) << 8) | fws0; 347 348 return 0; 349 } 350 351 static int btmrvl_sdio_read_rx_len(struct btmrvl_sdio_card *card, u16 *dat) 352 { 353 u8 reg; 354 int ret; 355 356 reg = sdio_readb(card->func, card->reg->card_rx_len, &ret); 357 if (!ret) 358 *dat = (u16) reg << card->rx_unit; 359 360 return ret; 361 } 362 363 static int btmrvl_sdio_enable_host_int_mask(struct btmrvl_sdio_card *card, 364 u8 mask) 365 { 366 int ret; 367 368 sdio_writeb(card->func, mask, card->reg->host_int_mask, &ret); 369 if (ret) { 370 BT_ERR("Unable to enable the host interrupt!"); 371 ret = -EIO; 372 } 373 374 return ret; 375 } 376 377 static int btmrvl_sdio_disable_host_int_mask(struct btmrvl_sdio_card *card, 378 u8 mask) 379 { 380 u8 host_int_mask; 381 int ret; 382 383 host_int_mask = sdio_readb(card->func, card->reg->host_int_mask, &ret); 384 if (ret) 385 return -EIO; 386 387 host_int_mask &= ~mask; 388 389 sdio_writeb(card->func, host_int_mask, card->reg->host_int_mask, &ret); 390 if (ret < 0) { 391 BT_ERR("Unable to disable the host interrupt!"); 392 return -EIO; 393 } 394 395 return 0; 396 } 397 398 static int btmrvl_sdio_poll_card_status(struct btmrvl_sdio_card *card, u8 bits) 399 { 400 unsigned int tries; 401 u8 status; 402 int ret; 403 404 for (tries = 0; tries < MAX_POLL_TRIES * 1000; tries++) { 405 status = sdio_readb(card->func, card->reg->card_status, &ret); 406 if (ret) 407 goto failed; 408 if ((status & bits) == bits) 409 return ret; 410 411 udelay(1); 412 } 413 414 ret = -ETIMEDOUT; 415 416 failed: 417 BT_ERR("FAILED! ret=%d", ret); 418 419 return ret; 420 } 421 422 static int btmrvl_sdio_verify_fw_download(struct btmrvl_sdio_card *card, 423 int pollnum) 424 { 425 u16 firmwarestat; 426 int tries, ret; 427 428 /* Wait for firmware to become ready */ 429 for (tries = 0; tries < pollnum; tries++) { 430 sdio_claim_host(card->func); 431 ret = btmrvl_sdio_read_fw_status(card, &firmwarestat); 432 sdio_release_host(card->func); 433 if (ret < 0) 434 continue; 435 436 if (firmwarestat == FIRMWARE_READY) 437 return 0; 438 439 msleep(100); 440 } 441 442 return -ETIMEDOUT; 443 } 444 445 static int btmrvl_sdio_download_helper(struct btmrvl_sdio_card *card) 446 { 447 const struct firmware *fw_helper = NULL; 448 const u8 *helper = NULL; 449 int ret; 450 void *tmphlprbuf = NULL; 451 int tmphlprbufsz, hlprblknow, helperlen; 452 u8 *helperbuf; 453 u32 tx_len; 454 455 ret = request_firmware(&fw_helper, card->helper, 456 &card->func->dev); 457 if ((ret < 0) || !fw_helper) { 458 BT_ERR("request_firmware(helper) failed, error code = %d", 459 ret); 460 ret = -ENOENT; 461 goto done; 462 } 463 464 helper = fw_helper->data; 465 helperlen = fw_helper->size; 466 467 BT_DBG("Downloading helper image (%d bytes), block size %d bytes", 468 helperlen, SDIO_BLOCK_SIZE); 469 470 tmphlprbufsz = ALIGN_SZ(BTM_UPLD_SIZE, BTSDIO_DMA_ALIGN); 471 472 tmphlprbuf = kzalloc(tmphlprbufsz, GFP_KERNEL); 473 if (!tmphlprbuf) { 474 BT_ERR("Unable to allocate buffer for helper." 475 " Terminating download"); 476 ret = -ENOMEM; 477 goto done; 478 } 479 480 helperbuf = (u8 *) ALIGN_ADDR(tmphlprbuf, BTSDIO_DMA_ALIGN); 481 482 /* Perform helper data transfer */ 483 tx_len = (FIRMWARE_TRANSFER_NBLOCK * SDIO_BLOCK_SIZE) 484 - SDIO_HEADER_LEN; 485 hlprblknow = 0; 486 487 do { 488 ret = btmrvl_sdio_poll_card_status(card, 489 CARD_IO_READY | DN_LD_CARD_RDY); 490 if (ret < 0) { 491 BT_ERR("Helper download poll status timeout @ %d", 492 hlprblknow); 493 goto done; 494 } 495 496 /* Check if there is more data? */ 497 if (hlprblknow >= helperlen) 498 break; 499 500 if (helperlen - hlprblknow < tx_len) 501 tx_len = helperlen - hlprblknow; 502 503 /* Little-endian */ 504 helperbuf[0] = ((tx_len & 0x000000ff) >> 0); 505 helperbuf[1] = ((tx_len & 0x0000ff00) >> 8); 506 helperbuf[2] = ((tx_len & 0x00ff0000) >> 16); 507 helperbuf[3] = ((tx_len & 0xff000000) >> 24); 508 509 memcpy(&helperbuf[SDIO_HEADER_LEN], &helper[hlprblknow], 510 tx_len); 511 512 /* Now send the data */ 513 ret = sdio_writesb(card->func, card->ioport, helperbuf, 514 FIRMWARE_TRANSFER_NBLOCK * SDIO_BLOCK_SIZE); 515 if (ret < 0) { 516 BT_ERR("IO error during helper download @ %d", 517 hlprblknow); 518 goto done; 519 } 520 521 hlprblknow += tx_len; 522 } while (true); 523 524 BT_DBG("Transferring helper image EOF block"); 525 526 memset(helperbuf, 0x0, SDIO_BLOCK_SIZE); 527 528 ret = sdio_writesb(card->func, card->ioport, helperbuf, 529 SDIO_BLOCK_SIZE); 530 if (ret < 0) { 531 BT_ERR("IO error in writing helper image EOF block"); 532 goto done; 533 } 534 535 ret = 0; 536 537 done: 538 kfree(tmphlprbuf); 539 release_firmware(fw_helper); 540 return ret; 541 } 542 543 static int btmrvl_sdio_download_fw_w_helper(struct btmrvl_sdio_card *card) 544 { 545 const struct firmware *fw_firmware = NULL; 546 const u8 *firmware = NULL; 547 int firmwarelen, tmpfwbufsz, ret; 548 unsigned int tries, offset; 549 u8 base0, base1; 550 void *tmpfwbuf = NULL; 551 u8 *fwbuf; 552 u16 len, blksz_dl = card->sd_blksz_fw_dl; 553 int txlen = 0, tx_blocks = 0, count = 0; 554 555 ret = request_firmware(&fw_firmware, card->firmware, 556 &card->func->dev); 557 if ((ret < 0) || !fw_firmware) { 558 BT_ERR("request_firmware(firmware) failed, error code = %d", 559 ret); 560 ret = -ENOENT; 561 goto done; 562 } 563 564 firmware = fw_firmware->data; 565 firmwarelen = fw_firmware->size; 566 567 BT_DBG("Downloading FW image (%d bytes)", firmwarelen); 568 569 tmpfwbufsz = ALIGN_SZ(BTM_UPLD_SIZE, BTSDIO_DMA_ALIGN); 570 tmpfwbuf = kzalloc(tmpfwbufsz, GFP_KERNEL); 571 if (!tmpfwbuf) { 572 BT_ERR("Unable to allocate buffer for firmware." 573 " Terminating download"); 574 ret = -ENOMEM; 575 goto done; 576 } 577 578 /* Ensure aligned firmware buffer */ 579 fwbuf = (u8 *) ALIGN_ADDR(tmpfwbuf, BTSDIO_DMA_ALIGN); 580 581 /* Perform firmware data transfer */ 582 offset = 0; 583 do { 584 ret = btmrvl_sdio_poll_card_status(card, 585 CARD_IO_READY | DN_LD_CARD_RDY); 586 if (ret < 0) { 587 BT_ERR("FW download with helper poll status" 588 " timeout @ %d", offset); 589 goto done; 590 } 591 592 /* Check if there is more data ? */ 593 if (offset >= firmwarelen) 594 break; 595 596 for (tries = 0; tries < MAX_POLL_TRIES; tries++) { 597 base0 = sdio_readb(card->func, 598 card->reg->sq_read_base_addr_a0, &ret); 599 if (ret) { 600 BT_ERR("BASE0 register read failed:" 601 " base0 = 0x%04X(%d)." 602 " Terminating download", 603 base0, base0); 604 ret = -EIO; 605 goto done; 606 } 607 base1 = sdio_readb(card->func, 608 card->reg->sq_read_base_addr_a1, &ret); 609 if (ret) { 610 BT_ERR("BASE1 register read failed:" 611 " base1 = 0x%04X(%d)." 612 " Terminating download", 613 base1, base1); 614 ret = -EIO; 615 goto done; 616 } 617 618 len = (((u16) base1) << 8) | base0; 619 if (len) 620 break; 621 622 udelay(10); 623 } 624 625 if (!len) 626 break; 627 else if (len > BTM_UPLD_SIZE) { 628 BT_ERR("FW download failure @%d, invalid length %d", 629 offset, len); 630 ret = -EINVAL; 631 goto done; 632 } 633 634 txlen = len; 635 636 if (len & BIT(0)) { 637 count++; 638 if (count > MAX_WRITE_IOMEM_RETRY) { 639 BT_ERR("FW download failure @%d, " 640 "over max retry count", offset); 641 ret = -EIO; 642 goto done; 643 } 644 BT_ERR("FW CRC error indicated by the helper: " 645 "len = 0x%04X, txlen = %d", len, txlen); 646 len &= ~BIT(0); 647 /* Set txlen to 0 so as to resend from same offset */ 648 txlen = 0; 649 } else { 650 count = 0; 651 652 /* Last block ? */ 653 if (firmwarelen - offset < txlen) 654 txlen = firmwarelen - offset; 655 656 tx_blocks = DIV_ROUND_UP(txlen, blksz_dl); 657 658 memcpy(fwbuf, &firmware[offset], txlen); 659 } 660 661 ret = sdio_writesb(card->func, card->ioport, fwbuf, 662 tx_blocks * blksz_dl); 663 664 if (ret < 0) { 665 BT_ERR("FW download, writesb(%d) failed @%d", 666 count, offset); 667 sdio_writeb(card->func, HOST_CMD53_FIN, 668 card->reg->cfg, &ret); 669 if (ret) 670 BT_ERR("writeb failed (CFG)"); 671 } 672 673 offset += txlen; 674 } while (true); 675 676 BT_INFO("FW download over, size %d bytes", offset); 677 678 ret = 0; 679 680 done: 681 kfree(tmpfwbuf); 682 release_firmware(fw_firmware); 683 return ret; 684 } 685 686 static int btmrvl_sdio_card_to_host(struct btmrvl_private *priv) 687 { 688 u16 buf_len = 0; 689 int ret, num_blocks, blksz; 690 struct sk_buff *skb = NULL; 691 u32 type; 692 u8 *payload = NULL; 693 struct hci_dev *hdev = priv->btmrvl_dev.hcidev; 694 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card; 695 696 if (!card || !card->func) { 697 BT_ERR("card or function is NULL!"); 698 ret = -EINVAL; 699 goto exit; 700 } 701 702 /* Read the length of data to be transferred */ 703 ret = btmrvl_sdio_read_rx_len(card, &buf_len); 704 if (ret < 0) { 705 BT_ERR("read rx_len failed"); 706 ret = -EIO; 707 goto exit; 708 } 709 710 blksz = SDIO_BLOCK_SIZE; 711 num_blocks = DIV_ROUND_UP(buf_len, blksz); 712 713 if (buf_len <= SDIO_HEADER_LEN 714 || (num_blocks * blksz) > ALLOC_BUF_SIZE) { 715 BT_ERR("invalid packet length: %d", buf_len); 716 ret = -EINVAL; 717 goto exit; 718 } 719 720 /* Allocate buffer */ 721 skb = bt_skb_alloc(num_blocks * blksz + BTSDIO_DMA_ALIGN, GFP_ATOMIC); 722 if (!skb) { 723 BT_ERR("No free skb"); 724 ret = -ENOMEM; 725 goto exit; 726 } 727 728 if ((unsigned long) skb->data & (BTSDIO_DMA_ALIGN - 1)) { 729 skb_put(skb, (unsigned long) skb->data & 730 (BTSDIO_DMA_ALIGN - 1)); 731 skb_pull(skb, (unsigned long) skb->data & 732 (BTSDIO_DMA_ALIGN - 1)); 733 } 734 735 payload = skb->data; 736 737 ret = sdio_readsb(card->func, payload, card->ioport, 738 num_blocks * blksz); 739 if (ret < 0) { 740 BT_ERR("readsb failed: %d", ret); 741 ret = -EIO; 742 goto exit; 743 } 744 745 /* This is SDIO specific header length: byte[2][1][0], type: byte[3] 746 * (HCI_COMMAND = 1, ACL_DATA = 2, SCO_DATA = 3, 0xFE = Vendor) 747 */ 748 749 buf_len = payload[0]; 750 buf_len |= payload[1] << 8; 751 buf_len |= payload[2] << 16; 752 753 if (buf_len > blksz * num_blocks) { 754 BT_ERR("Skip incorrect packet: hdrlen %d buffer %d", 755 buf_len, blksz * num_blocks); 756 ret = -EIO; 757 goto exit; 758 } 759 760 type = payload[3]; 761 762 switch (type) { 763 case HCI_ACLDATA_PKT: 764 case HCI_SCODATA_PKT: 765 case HCI_EVENT_PKT: 766 hci_skb_pkt_type(skb) = type; 767 skb_put(skb, buf_len); 768 skb_pull(skb, SDIO_HEADER_LEN); 769 770 if (type == HCI_EVENT_PKT) { 771 if (btmrvl_check_evtpkt(priv, skb)) 772 hci_recv_frame(hdev, skb); 773 } else { 774 hci_recv_frame(hdev, skb); 775 } 776 777 hdev->stat.byte_rx += buf_len; 778 break; 779 780 case MRVL_VENDOR_PKT: 781 hci_skb_pkt_type(skb) = HCI_VENDOR_PKT; 782 skb_put(skb, buf_len); 783 skb_pull(skb, SDIO_HEADER_LEN); 784 785 if (btmrvl_process_event(priv, skb)) 786 hci_recv_frame(hdev, skb); 787 788 hdev->stat.byte_rx += buf_len; 789 break; 790 791 default: 792 BT_ERR("Unknown packet type:%d", type); 793 BT_ERR("hex: %*ph", blksz * num_blocks, payload); 794 795 kfree_skb(skb); 796 skb = NULL; 797 break; 798 } 799 800 exit: 801 if (ret) { 802 hdev->stat.err_rx++; 803 kfree_skb(skb); 804 } 805 806 return ret; 807 } 808 809 static int btmrvl_sdio_process_int_status(struct btmrvl_private *priv) 810 { 811 ulong flags; 812 u8 ireg; 813 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card; 814 815 spin_lock_irqsave(&priv->driver_lock, flags); 816 ireg = sdio_ireg; 817 sdio_ireg = 0; 818 spin_unlock_irqrestore(&priv->driver_lock, flags); 819 820 sdio_claim_host(card->func); 821 if (ireg & DN_LD_HOST_INT_STATUS) { 822 if (priv->btmrvl_dev.tx_dnld_rdy) 823 BT_DBG("tx_done already received: " 824 " int_status=0x%x", ireg); 825 else 826 priv->btmrvl_dev.tx_dnld_rdy = true; 827 } 828 829 if (ireg & UP_LD_HOST_INT_STATUS) 830 btmrvl_sdio_card_to_host(priv); 831 832 sdio_release_host(card->func); 833 834 return 0; 835 } 836 837 static int btmrvl_sdio_read_to_clear(struct btmrvl_sdio_card *card, u8 *ireg) 838 { 839 struct btmrvl_adapter *adapter = card->priv->adapter; 840 int ret; 841 842 ret = sdio_readsb(card->func, adapter->hw_regs, 0, SDIO_BLOCK_SIZE); 843 if (ret) { 844 BT_ERR("sdio_readsb: read int hw_regs failed: %d", ret); 845 return ret; 846 } 847 848 *ireg = adapter->hw_regs[card->reg->host_intstatus]; 849 BT_DBG("hw_regs[%#x]=%#x", card->reg->host_intstatus, *ireg); 850 851 return 0; 852 } 853 854 static int btmrvl_sdio_write_to_clear(struct btmrvl_sdio_card *card, u8 *ireg) 855 { 856 int ret; 857 858 *ireg = sdio_readb(card->func, card->reg->host_intstatus, &ret); 859 if (ret) { 860 BT_ERR("sdio_readb: read int status failed: %d", ret); 861 return ret; 862 } 863 864 if (*ireg) { 865 /* 866 * DN_LD_HOST_INT_STATUS and/or UP_LD_HOST_INT_STATUS 867 * Clear the interrupt status register and re-enable the 868 * interrupt. 869 */ 870 BT_DBG("int_status = 0x%x", *ireg); 871 872 sdio_writeb(card->func, ~(*ireg) & (DN_LD_HOST_INT_STATUS | 873 UP_LD_HOST_INT_STATUS), 874 card->reg->host_intstatus, &ret); 875 if (ret) { 876 BT_ERR("sdio_writeb: clear int status failed: %d", ret); 877 return ret; 878 } 879 } 880 881 return 0; 882 } 883 884 static void btmrvl_sdio_interrupt(struct sdio_func *func) 885 { 886 struct btmrvl_private *priv; 887 struct btmrvl_sdio_card *card; 888 ulong flags; 889 u8 ireg = 0; 890 int ret; 891 892 card = sdio_get_drvdata(func); 893 if (!card || !card->priv) { 894 BT_ERR("sbi_interrupt(%p) card or priv is NULL, card=%p", 895 func, card); 896 return; 897 } 898 899 priv = card->priv; 900 901 if (priv->surprise_removed) 902 return; 903 904 if (card->reg->int_read_to_clear) 905 ret = btmrvl_sdio_read_to_clear(card, &ireg); 906 else 907 ret = btmrvl_sdio_write_to_clear(card, &ireg); 908 909 if (ret) 910 return; 911 912 spin_lock_irqsave(&priv->driver_lock, flags); 913 sdio_ireg |= ireg; 914 spin_unlock_irqrestore(&priv->driver_lock, flags); 915 916 btmrvl_interrupt(priv); 917 } 918 919 static int btmrvl_sdio_register_dev(struct btmrvl_sdio_card *card) 920 { 921 struct sdio_func *func; 922 u8 reg; 923 int ret = 0; 924 925 if (!card || !card->func) { 926 BT_ERR("Error: card or function is NULL!"); 927 ret = -EINVAL; 928 goto failed; 929 } 930 931 func = card->func; 932 933 sdio_claim_host(func); 934 935 ret = sdio_enable_func(func); 936 if (ret) { 937 BT_ERR("sdio_enable_func() failed: ret=%d", ret); 938 ret = -EIO; 939 goto release_host; 940 } 941 942 ret = sdio_claim_irq(func, btmrvl_sdio_interrupt); 943 if (ret) { 944 BT_ERR("sdio_claim_irq failed: ret=%d", ret); 945 ret = -EIO; 946 goto disable_func; 947 } 948 949 ret = sdio_set_block_size(card->func, SDIO_BLOCK_SIZE); 950 if (ret) { 951 BT_ERR("cannot set SDIO block size"); 952 ret = -EIO; 953 goto release_irq; 954 } 955 956 reg = sdio_readb(func, card->reg->io_port_0, &ret); 957 if (ret < 0) { 958 ret = -EIO; 959 goto release_irq; 960 } 961 962 card->ioport = reg; 963 964 reg = sdio_readb(func, card->reg->io_port_1, &ret); 965 if (ret < 0) { 966 ret = -EIO; 967 goto release_irq; 968 } 969 970 card->ioport |= (reg << 8); 971 972 reg = sdio_readb(func, card->reg->io_port_2, &ret); 973 if (ret < 0) { 974 ret = -EIO; 975 goto release_irq; 976 } 977 978 card->ioport |= (reg << 16); 979 980 BT_DBG("SDIO FUNC%d IO port: 0x%x", func->num, card->ioport); 981 982 if (card->reg->int_read_to_clear) { 983 reg = sdio_readb(func, card->reg->host_int_rsr, &ret); 984 if (ret < 0) { 985 ret = -EIO; 986 goto release_irq; 987 } 988 sdio_writeb(func, reg | 0x3f, card->reg->host_int_rsr, &ret); 989 if (ret < 0) { 990 ret = -EIO; 991 goto release_irq; 992 } 993 994 reg = sdio_readb(func, card->reg->card_misc_cfg, &ret); 995 if (ret < 0) { 996 ret = -EIO; 997 goto release_irq; 998 } 999 sdio_writeb(func, reg | 0x10, card->reg->card_misc_cfg, &ret); 1000 if (ret < 0) { 1001 ret = -EIO; 1002 goto release_irq; 1003 } 1004 } 1005 1006 sdio_set_drvdata(func, card); 1007 1008 sdio_release_host(func); 1009 1010 return 0; 1011 1012 release_irq: 1013 sdio_release_irq(func); 1014 1015 disable_func: 1016 sdio_disable_func(func); 1017 1018 release_host: 1019 sdio_release_host(func); 1020 1021 failed: 1022 return ret; 1023 } 1024 1025 static int btmrvl_sdio_unregister_dev(struct btmrvl_sdio_card *card) 1026 { 1027 if (card && card->func) { 1028 sdio_claim_host(card->func); 1029 sdio_release_irq(card->func); 1030 sdio_disable_func(card->func); 1031 sdio_release_host(card->func); 1032 sdio_set_drvdata(card->func, NULL); 1033 } 1034 1035 return 0; 1036 } 1037 1038 static int btmrvl_sdio_enable_host_int(struct btmrvl_sdio_card *card) 1039 { 1040 int ret; 1041 1042 if (!card || !card->func) 1043 return -EINVAL; 1044 1045 sdio_claim_host(card->func); 1046 1047 ret = btmrvl_sdio_enable_host_int_mask(card, HIM_ENABLE); 1048 1049 btmrvl_sdio_get_rx_unit(card); 1050 1051 sdio_release_host(card->func); 1052 1053 return ret; 1054 } 1055 1056 static int btmrvl_sdio_disable_host_int(struct btmrvl_sdio_card *card) 1057 { 1058 int ret; 1059 1060 if (!card || !card->func) 1061 return -EINVAL; 1062 1063 sdio_claim_host(card->func); 1064 1065 ret = btmrvl_sdio_disable_host_int_mask(card, HIM_DISABLE); 1066 1067 sdio_release_host(card->func); 1068 1069 return ret; 1070 } 1071 1072 static int btmrvl_sdio_host_to_card(struct btmrvl_private *priv, 1073 u8 *payload, u16 nb) 1074 { 1075 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card; 1076 int ret = 0; 1077 int blksz; 1078 int i = 0; 1079 u8 *buf = NULL; 1080 void *tmpbuf = NULL; 1081 int tmpbufsz; 1082 1083 if (!card || !card->func) { 1084 BT_ERR("card or function is NULL!"); 1085 return -EINVAL; 1086 } 1087 1088 blksz = DIV_ROUND_UP(nb, SDIO_BLOCK_SIZE) * SDIO_BLOCK_SIZE; 1089 1090 buf = payload; 1091 if ((unsigned long) payload & (BTSDIO_DMA_ALIGN - 1) || 1092 nb < blksz) { 1093 tmpbufsz = ALIGN_SZ(blksz, BTSDIO_DMA_ALIGN) + 1094 BTSDIO_DMA_ALIGN; 1095 tmpbuf = kzalloc(tmpbufsz, GFP_KERNEL); 1096 if (!tmpbuf) 1097 return -ENOMEM; 1098 buf = (u8 *) ALIGN_ADDR(tmpbuf, BTSDIO_DMA_ALIGN); 1099 memcpy(buf, payload, nb); 1100 } 1101 1102 sdio_claim_host(card->func); 1103 1104 do { 1105 /* Transfer data to card */ 1106 ret = sdio_writesb(card->func, card->ioport, buf, 1107 blksz); 1108 if (ret < 0) { 1109 i++; 1110 BT_ERR("i=%d writesb failed: %d", i, ret); 1111 BT_ERR("hex: %*ph", nb, payload); 1112 ret = -EIO; 1113 if (i > MAX_WRITE_IOMEM_RETRY) 1114 goto exit; 1115 } 1116 } while (ret); 1117 1118 priv->btmrvl_dev.tx_dnld_rdy = false; 1119 1120 exit: 1121 sdio_release_host(card->func); 1122 kfree(tmpbuf); 1123 1124 return ret; 1125 } 1126 1127 static int btmrvl_sdio_download_fw(struct btmrvl_sdio_card *card) 1128 { 1129 int ret; 1130 u8 fws0; 1131 int pollnum = MAX_POLL_TRIES; 1132 1133 if (!card || !card->func) { 1134 BT_ERR("card or function is NULL!"); 1135 return -EINVAL; 1136 } 1137 1138 if (!btmrvl_sdio_verify_fw_download(card, 1)) { 1139 BT_DBG("Firmware already downloaded!"); 1140 return 0; 1141 } 1142 1143 sdio_claim_host(card->func); 1144 1145 /* Check if other function driver is downloading the firmware */ 1146 fws0 = sdio_readb(card->func, card->reg->card_fw_status0, &ret); 1147 if (ret) { 1148 BT_ERR("Failed to read FW downloading status!"); 1149 ret = -EIO; 1150 goto done; 1151 } 1152 if (fws0) { 1153 BT_DBG("BT not the winner (%#x). Skip FW downloading", fws0); 1154 1155 /* Give other function more time to download the firmware */ 1156 pollnum *= 10; 1157 } else { 1158 if (card->helper) { 1159 ret = btmrvl_sdio_download_helper(card); 1160 if (ret) { 1161 BT_ERR("Failed to download helper!"); 1162 ret = -EIO; 1163 goto done; 1164 } 1165 } 1166 1167 if (btmrvl_sdio_download_fw_w_helper(card)) { 1168 BT_ERR("Failed to download firmware!"); 1169 ret = -EIO; 1170 goto done; 1171 } 1172 } 1173 1174 /* 1175 * winner or not, with this test the FW synchronizes when the 1176 * module can continue its initialization 1177 */ 1178 if (btmrvl_sdio_verify_fw_download(card, pollnum)) { 1179 BT_ERR("FW failed to be active in time!"); 1180 ret = -ETIMEDOUT; 1181 goto done; 1182 } 1183 1184 sdio_release_host(card->func); 1185 1186 return 0; 1187 1188 done: 1189 sdio_release_host(card->func); 1190 return ret; 1191 } 1192 1193 static int btmrvl_sdio_wakeup_fw(struct btmrvl_private *priv) 1194 { 1195 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card; 1196 int ret = 0; 1197 1198 if (!card || !card->func) { 1199 BT_ERR("card or function is NULL!"); 1200 return -EINVAL; 1201 } 1202 1203 sdio_claim_host(card->func); 1204 1205 sdio_writeb(card->func, HOST_POWER_UP, card->reg->cfg, &ret); 1206 1207 sdio_release_host(card->func); 1208 1209 BT_DBG("wake up firmware"); 1210 1211 return ret; 1212 } 1213 1214 static void btmrvl_sdio_dump_regs(struct btmrvl_private *priv) 1215 { 1216 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card; 1217 int ret = 0; 1218 unsigned int reg, reg_start, reg_end; 1219 char buf[256], *ptr; 1220 u8 loop, func, data; 1221 int MAX_LOOP = 2; 1222 1223 btmrvl_sdio_wakeup_fw(priv); 1224 sdio_claim_host(card->func); 1225 1226 for (loop = 0; loop < MAX_LOOP; loop++) { 1227 memset(buf, 0, sizeof(buf)); 1228 ptr = buf; 1229 1230 if (loop == 0) { 1231 /* Read the registers of SDIO function0 */ 1232 func = loop; 1233 reg_start = 0; 1234 reg_end = 9; 1235 } else { 1236 func = 2; 1237 reg_start = 0; 1238 reg_end = 0x09; 1239 } 1240 1241 ptr += sprintf(ptr, "SDIO Func%d (%#x-%#x): ", 1242 func, reg_start, reg_end); 1243 for (reg = reg_start; reg <= reg_end; reg++) { 1244 if (func == 0) 1245 data = sdio_f0_readb(card->func, reg, &ret); 1246 else 1247 data = sdio_readb(card->func, reg, &ret); 1248 1249 if (!ret) { 1250 ptr += sprintf(ptr, "%02x ", data); 1251 } else { 1252 ptr += sprintf(ptr, "ERR"); 1253 break; 1254 } 1255 } 1256 1257 BT_INFO("%s", buf); 1258 } 1259 1260 sdio_release_host(card->func); 1261 } 1262 1263 /* This function read/write firmware */ 1264 static enum 1265 rdwr_status btmrvl_sdio_rdwr_firmware(struct btmrvl_private *priv, 1266 u8 doneflag) 1267 { 1268 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card; 1269 int ret, tries; 1270 u8 ctrl_data = 0; 1271 1272 sdio_writeb(card->func, FW_DUMP_HOST_READY, card->reg->fw_dump_ctrl, 1273 &ret); 1274 1275 if (ret) { 1276 BT_ERR("SDIO write err"); 1277 return RDWR_STATUS_FAILURE; 1278 } 1279 1280 for (tries = 0; tries < MAX_POLL_TRIES; tries++) { 1281 ctrl_data = sdio_readb(card->func, card->reg->fw_dump_ctrl, 1282 &ret); 1283 1284 if (ret) { 1285 BT_ERR("SDIO read err"); 1286 return RDWR_STATUS_FAILURE; 1287 } 1288 1289 if (ctrl_data == FW_DUMP_DONE) 1290 break; 1291 if (doneflag && ctrl_data == doneflag) 1292 return RDWR_STATUS_DONE; 1293 if (ctrl_data != FW_DUMP_HOST_READY) { 1294 BT_INFO("The ctrl reg was changed, re-try again!"); 1295 sdio_writeb(card->func, FW_DUMP_HOST_READY, 1296 card->reg->fw_dump_ctrl, &ret); 1297 if (ret) { 1298 BT_ERR("SDIO write err"); 1299 return RDWR_STATUS_FAILURE; 1300 } 1301 } 1302 usleep_range(100, 200); 1303 } 1304 1305 if (ctrl_data == FW_DUMP_HOST_READY) { 1306 BT_ERR("Fail to pull ctrl_data"); 1307 return RDWR_STATUS_FAILURE; 1308 } 1309 1310 return RDWR_STATUS_SUCCESS; 1311 } 1312 1313 /* This function dump sdio register and memory data */ 1314 static void btmrvl_sdio_dump_firmware(struct btmrvl_private *priv) 1315 { 1316 struct btmrvl_sdio_card *card = priv->btmrvl_dev.card; 1317 int ret = 0; 1318 unsigned int reg, reg_start, reg_end; 1319 enum rdwr_status stat; 1320 u8 *dbg_ptr, *end_ptr, *fw_dump_data, *fw_dump_ptr; 1321 u8 dump_num = 0, idx, i, read_reg, doneflag = 0; 1322 u32 memory_size, fw_dump_len = 0; 1323 1324 /* dump sdio register first */ 1325 btmrvl_sdio_dump_regs(priv); 1326 1327 if (!card->supports_fw_dump) { 1328 BT_ERR("Firmware dump not supported for this card!"); 1329 return; 1330 } 1331 1332 for (idx = 0; idx < ARRAY_SIZE(mem_type_mapping_tbl); idx++) { 1333 struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx]; 1334 1335 if (entry->mem_ptr) { 1336 vfree(entry->mem_ptr); 1337 entry->mem_ptr = NULL; 1338 } 1339 entry->mem_size = 0; 1340 } 1341 1342 btmrvl_sdio_wakeup_fw(priv); 1343 sdio_claim_host(card->func); 1344 1345 BT_INFO("== btmrvl firmware dump start =="); 1346 1347 stat = btmrvl_sdio_rdwr_firmware(priv, doneflag); 1348 if (stat == RDWR_STATUS_FAILURE) 1349 goto done; 1350 1351 reg = card->reg->fw_dump_start; 1352 /* Read the number of the memories which will dump */ 1353 dump_num = sdio_readb(card->func, reg, &ret); 1354 1355 if (ret) { 1356 BT_ERR("SDIO read memory length err"); 1357 goto done; 1358 } 1359 1360 /* Read the length of every memory which will dump */ 1361 for (idx = 0; idx < dump_num; idx++) { 1362 struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx]; 1363 1364 stat = btmrvl_sdio_rdwr_firmware(priv, doneflag); 1365 if (stat == RDWR_STATUS_FAILURE) 1366 goto done; 1367 1368 memory_size = 0; 1369 reg = card->reg->fw_dump_start; 1370 for (i = 0; i < 4; i++) { 1371 read_reg = sdio_readb(card->func, reg, &ret); 1372 if (ret) { 1373 BT_ERR("SDIO read err"); 1374 goto done; 1375 } 1376 memory_size |= (read_reg << i*8); 1377 reg++; 1378 } 1379 1380 if (memory_size == 0) { 1381 BT_INFO("Firmware dump finished!"); 1382 sdio_writeb(card->func, FW_DUMP_READ_DONE, 1383 card->reg->fw_dump_ctrl, &ret); 1384 if (ret) { 1385 BT_ERR("SDIO Write MEMDUMP_FINISH ERR"); 1386 goto done; 1387 } 1388 break; 1389 } 1390 1391 BT_INFO("%s_SIZE=0x%x", entry->mem_name, memory_size); 1392 entry->mem_ptr = vzalloc(memory_size + 1); 1393 entry->mem_size = memory_size; 1394 if (!entry->mem_ptr) { 1395 BT_ERR("Vzalloc %s failed", entry->mem_name); 1396 goto done; 1397 } 1398 1399 fw_dump_len += (strlen("========Start dump ") + 1400 strlen(entry->mem_name) + 1401 strlen("========\n") + 1402 (memory_size + 1) + 1403 strlen("\n========End dump========\n")); 1404 1405 dbg_ptr = entry->mem_ptr; 1406 end_ptr = dbg_ptr + memory_size; 1407 1408 doneflag = entry->done_flag; 1409 BT_INFO("Start %s output, please wait...", 1410 entry->mem_name); 1411 1412 do { 1413 stat = btmrvl_sdio_rdwr_firmware(priv, doneflag); 1414 if (stat == RDWR_STATUS_FAILURE) 1415 goto done; 1416 1417 reg_start = card->reg->fw_dump_start; 1418 reg_end = card->reg->fw_dump_end; 1419 for (reg = reg_start; reg <= reg_end; reg++) { 1420 *dbg_ptr = sdio_readb(card->func, reg, &ret); 1421 if (ret) { 1422 BT_ERR("SDIO read err"); 1423 goto done; 1424 } 1425 if (dbg_ptr < end_ptr) 1426 dbg_ptr++; 1427 else 1428 BT_ERR("Allocated buffer not enough"); 1429 } 1430 1431 if (stat != RDWR_STATUS_DONE) { 1432 continue; 1433 } else { 1434 BT_INFO("%s done: size=0x%tx", 1435 entry->mem_name, 1436 dbg_ptr - entry->mem_ptr); 1437 break; 1438 } 1439 } while (1); 1440 } 1441 1442 BT_INFO("== btmrvl firmware dump end =="); 1443 1444 done: 1445 sdio_release_host(card->func); 1446 1447 if (fw_dump_len == 0) 1448 return; 1449 1450 fw_dump_data = vzalloc(fw_dump_len+1); 1451 if (!fw_dump_data) { 1452 BT_ERR("Vzalloc fw_dump_data fail!"); 1453 return; 1454 } 1455 fw_dump_ptr = fw_dump_data; 1456 1457 /* Dump all the memory data into single file, a userspace script will 1458 be used to split all the memory data to multiple files*/ 1459 BT_INFO("== btmrvl firmware dump to /sys/class/devcoredump start"); 1460 for (idx = 0; idx < dump_num; idx++) { 1461 struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx]; 1462 1463 if (entry->mem_ptr) { 1464 strcpy(fw_dump_ptr, "========Start dump "); 1465 fw_dump_ptr += strlen("========Start dump "); 1466 1467 strcpy(fw_dump_ptr, entry->mem_name); 1468 fw_dump_ptr += strlen(entry->mem_name); 1469 1470 strcpy(fw_dump_ptr, "========\n"); 1471 fw_dump_ptr += strlen("========\n"); 1472 1473 memcpy(fw_dump_ptr, entry->mem_ptr, entry->mem_size); 1474 fw_dump_ptr += entry->mem_size; 1475 1476 strcpy(fw_dump_ptr, "\n========End dump========\n"); 1477 fw_dump_ptr += strlen("\n========End dump========\n"); 1478 1479 vfree(mem_type_mapping_tbl[idx].mem_ptr); 1480 mem_type_mapping_tbl[idx].mem_ptr = NULL; 1481 } 1482 } 1483 1484 /* fw_dump_data will be free in device coredump release function 1485 after 5 min*/ 1486 dev_coredumpv(&card->func->dev, fw_dump_data, fw_dump_len, GFP_KERNEL); 1487 BT_INFO("== btmrvl firmware dump to /sys/class/devcoredump end"); 1488 } 1489 1490 static int btmrvl_sdio_probe(struct sdio_func *func, 1491 const struct sdio_device_id *id) 1492 { 1493 int ret = 0; 1494 struct btmrvl_private *priv = NULL; 1495 struct btmrvl_sdio_card *card = NULL; 1496 1497 BT_INFO("vendor=0x%x, device=0x%x, class=%d, fn=%d", 1498 id->vendor, id->device, id->class, func->num); 1499 1500 card = devm_kzalloc(&func->dev, sizeof(*card), GFP_KERNEL); 1501 if (!card) 1502 return -ENOMEM; 1503 1504 card->func = func; 1505 1506 if (id->driver_data) { 1507 struct btmrvl_sdio_device *data = (void *) id->driver_data; 1508 card->helper = data->helper; 1509 card->firmware = data->firmware; 1510 card->reg = data->reg; 1511 card->sd_blksz_fw_dl = data->sd_blksz_fw_dl; 1512 card->support_pscan_win_report = data->support_pscan_win_report; 1513 card->supports_fw_dump = data->supports_fw_dump; 1514 } 1515 1516 if (btmrvl_sdio_register_dev(card) < 0) { 1517 BT_ERR("Failed to register BT device!"); 1518 return -ENODEV; 1519 } 1520 1521 /* Disable the interrupts on the card */ 1522 btmrvl_sdio_disable_host_int(card); 1523 1524 if (btmrvl_sdio_download_fw(card)) { 1525 BT_ERR("Downloading firmware failed!"); 1526 ret = -ENODEV; 1527 goto unreg_dev; 1528 } 1529 1530 btmrvl_sdio_enable_host_int(card); 1531 1532 /* Device tree node parsing and platform specific configuration*/ 1533 btmrvl_sdio_probe_of(&func->dev, card); 1534 1535 priv = btmrvl_add_card(card); 1536 if (!priv) { 1537 BT_ERR("Initializing card failed!"); 1538 ret = -ENODEV; 1539 goto disable_host_int; 1540 } 1541 1542 card->priv = priv; 1543 1544 /* Initialize the interface specific function pointers */ 1545 priv->hw_host_to_card = btmrvl_sdio_host_to_card; 1546 priv->hw_wakeup_firmware = btmrvl_sdio_wakeup_fw; 1547 priv->hw_process_int_status = btmrvl_sdio_process_int_status; 1548 priv->firmware_dump = btmrvl_sdio_dump_firmware; 1549 1550 if (btmrvl_register_hdev(priv)) { 1551 BT_ERR("Register hdev failed!"); 1552 ret = -ENODEV; 1553 goto disable_host_int; 1554 } 1555 1556 return 0; 1557 1558 disable_host_int: 1559 btmrvl_sdio_disable_host_int(card); 1560 unreg_dev: 1561 btmrvl_sdio_unregister_dev(card); 1562 return ret; 1563 } 1564 1565 static void btmrvl_sdio_remove(struct sdio_func *func) 1566 { 1567 struct btmrvl_sdio_card *card; 1568 1569 if (func) { 1570 card = sdio_get_drvdata(func); 1571 if (card) { 1572 /* Send SHUTDOWN command & disable interrupt 1573 * if user removes the module. 1574 */ 1575 if (user_rmmod) { 1576 btmrvl_send_module_cfg_cmd(card->priv, 1577 MODULE_SHUTDOWN_REQ); 1578 btmrvl_sdio_disable_host_int(card); 1579 } 1580 BT_DBG("unregister dev"); 1581 card->priv->surprise_removed = true; 1582 btmrvl_sdio_unregister_dev(card); 1583 btmrvl_remove_card(card->priv); 1584 } 1585 } 1586 } 1587 1588 static int btmrvl_sdio_suspend(struct device *dev) 1589 { 1590 struct sdio_func *func = dev_to_sdio_func(dev); 1591 struct btmrvl_sdio_card *card; 1592 struct btmrvl_private *priv; 1593 mmc_pm_flag_t pm_flags; 1594 struct hci_dev *hcidev; 1595 1596 if (func) { 1597 pm_flags = sdio_get_host_pm_caps(func); 1598 BT_DBG("%s: suspend: PM flags = 0x%x", sdio_func_id(func), 1599 pm_flags); 1600 if (!(pm_flags & MMC_PM_KEEP_POWER)) { 1601 BT_ERR("%s: cannot remain alive while suspended", 1602 sdio_func_id(func)); 1603 return -ENOSYS; 1604 } 1605 card = sdio_get_drvdata(func); 1606 if (!card || !card->priv) { 1607 BT_ERR("card or priv structure is not valid"); 1608 return 0; 1609 } 1610 } else { 1611 BT_ERR("sdio_func is not specified"); 1612 return 0; 1613 } 1614 1615 /* Enable platform specific wakeup interrupt */ 1616 if (card->plt_wake_cfg && card->plt_wake_cfg->irq_bt >= 0) { 1617 card->plt_wake_cfg->wake_by_bt = false; 1618 enable_irq(card->plt_wake_cfg->irq_bt); 1619 enable_irq_wake(card->plt_wake_cfg->irq_bt); 1620 } 1621 1622 priv = card->priv; 1623 priv->adapter->is_suspending = true; 1624 hcidev = priv->btmrvl_dev.hcidev; 1625 BT_DBG("%s: SDIO suspend", hcidev->name); 1626 hci_suspend_dev(hcidev); 1627 1628 if (priv->adapter->hs_state != HS_ACTIVATED) { 1629 if (btmrvl_enable_hs(priv)) { 1630 BT_ERR("HS not activated, suspend failed!"); 1631 /* Disable platform specific wakeup interrupt */ 1632 if (card->plt_wake_cfg && 1633 card->plt_wake_cfg->irq_bt >= 0) { 1634 disable_irq_wake(card->plt_wake_cfg->irq_bt); 1635 disable_irq(card->plt_wake_cfg->irq_bt); 1636 } 1637 1638 priv->adapter->is_suspending = false; 1639 return -EBUSY; 1640 } 1641 } 1642 1643 priv->adapter->is_suspending = false; 1644 priv->adapter->is_suspended = true; 1645 1646 /* We will keep the power when hs enabled successfully */ 1647 if (priv->adapter->hs_state == HS_ACTIVATED) { 1648 BT_DBG("suspend with MMC_PM_KEEP_POWER"); 1649 return sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER); 1650 } 1651 1652 BT_DBG("suspend without MMC_PM_KEEP_POWER"); 1653 return 0; 1654 } 1655 1656 static int btmrvl_sdio_resume(struct device *dev) 1657 { 1658 struct sdio_func *func = dev_to_sdio_func(dev); 1659 struct btmrvl_sdio_card *card; 1660 struct btmrvl_private *priv; 1661 mmc_pm_flag_t pm_flags; 1662 struct hci_dev *hcidev; 1663 1664 if (func) { 1665 pm_flags = sdio_get_host_pm_caps(func); 1666 BT_DBG("%s: resume: PM flags = 0x%x", sdio_func_id(func), 1667 pm_flags); 1668 card = sdio_get_drvdata(func); 1669 if (!card || !card->priv) { 1670 BT_ERR("card or priv structure is not valid"); 1671 return 0; 1672 } 1673 } else { 1674 BT_ERR("sdio_func is not specified"); 1675 return 0; 1676 } 1677 priv = card->priv; 1678 1679 if (!priv->adapter->is_suspended) { 1680 BT_DBG("device already resumed"); 1681 return 0; 1682 } 1683 1684 priv->hw_wakeup_firmware(priv); 1685 priv->adapter->hs_state = HS_DEACTIVATED; 1686 hcidev = priv->btmrvl_dev.hcidev; 1687 BT_DBG("%s: HS DEACTIVATED in resume!", hcidev->name); 1688 priv->adapter->is_suspended = false; 1689 BT_DBG("%s: SDIO resume", hcidev->name); 1690 hci_resume_dev(hcidev); 1691 1692 /* Disable platform specific wakeup interrupt */ 1693 if (card->plt_wake_cfg && card->plt_wake_cfg->irq_bt >= 0) { 1694 disable_irq_wake(card->plt_wake_cfg->irq_bt); 1695 disable_irq(card->plt_wake_cfg->irq_bt); 1696 if (card->plt_wake_cfg->wake_by_bt) 1697 /* Undo our disable, since interrupt handler already 1698 * did this. 1699 */ 1700 enable_irq(card->plt_wake_cfg->irq_bt); 1701 } 1702 1703 return 0; 1704 } 1705 1706 static const struct dev_pm_ops btmrvl_sdio_pm_ops = { 1707 .suspend = btmrvl_sdio_suspend, 1708 .resume = btmrvl_sdio_resume, 1709 }; 1710 1711 static struct sdio_driver bt_mrvl_sdio = { 1712 .name = "btmrvl_sdio", 1713 .id_table = btmrvl_sdio_ids, 1714 .probe = btmrvl_sdio_probe, 1715 .remove = btmrvl_sdio_remove, 1716 .drv = { 1717 .owner = THIS_MODULE, 1718 .pm = &btmrvl_sdio_pm_ops, 1719 } 1720 }; 1721 1722 static int __init btmrvl_sdio_init_module(void) 1723 { 1724 if (sdio_register_driver(&bt_mrvl_sdio) != 0) { 1725 BT_ERR("SDIO Driver Registration Failed"); 1726 return -ENODEV; 1727 } 1728 1729 /* Clear the flag in case user removes the card. */ 1730 user_rmmod = 0; 1731 1732 return 0; 1733 } 1734 1735 static void __exit btmrvl_sdio_exit_module(void) 1736 { 1737 /* Set the flag as user is removing this module. */ 1738 user_rmmod = 1; 1739 1740 sdio_unregister_driver(&bt_mrvl_sdio); 1741 } 1742 1743 module_init(btmrvl_sdio_init_module); 1744 module_exit(btmrvl_sdio_exit_module); 1745 1746 MODULE_AUTHOR("Marvell International Ltd."); 1747 MODULE_DESCRIPTION("Marvell BT-over-SDIO driver ver " VERSION); 1748 MODULE_VERSION(VERSION); 1749 MODULE_LICENSE("GPL v2"); 1750 MODULE_FIRMWARE("mrvl/sd8688_helper.bin"); 1751 MODULE_FIRMWARE("mrvl/sd8688.bin"); 1752 MODULE_FIRMWARE("mrvl/sd8787_uapsta.bin"); 1753 MODULE_FIRMWARE("mrvl/sd8797_uapsta.bin"); 1754 MODULE_FIRMWARE("mrvl/sd8887_uapsta.bin"); 1755 MODULE_FIRMWARE("mrvl/sd8897_uapsta.bin"); 1756 MODULE_FIRMWARE("mrvl/sd8997_uapsta.bin"); 1757