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