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 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 */ 83 static 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 */ 138 static u8 user_rmmod; 139 static u8 sdio_ireg; 140 141 static 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 }; 157 static 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 175 static 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 195 static 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 218 static 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 241 static 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 250 static 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 259 static 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 268 static 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 277 static 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 286 static 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 295 static 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 304 static 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 313 static 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 345 MODULE_DEVICE_TABLE(sdio, btmrvl_sdio_ids); 346 347 static 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 359 static 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 379 static 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 391 static 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 405 static 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 426 static 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 444 failed: 445 BT_ERR("FAILED! ret=%d", ret); 446 447 return ret; 448 } 449 450 static 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 473 static 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 565 done: 566 kfree(tmphlprbuf); 567 release_firmware(fw_helper); 568 return ret; 569 } 570 571 static 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 708 done: 709 kfree(tmpfwbuf); 710 release_firmware(fw_firmware); 711 return ret; 712 } 713 714 static 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 828 exit: 829 if (ret) { 830 hdev->stat.err_rx++; 831 kfree_skb(skb); 832 } 833 834 return ret; 835 } 836 837 static 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 865 static 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 882 static 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 912 static 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 947 static 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 1040 release_irq: 1041 sdio_release_irq(func); 1042 1043 disable_func: 1044 sdio_disable_func(func); 1045 1046 release_host: 1047 sdio_release_host(func); 1048 1049 failed: 1050 return ret; 1051 } 1052 1053 static 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 1066 static 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 1084 static 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 1100 static 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 1148 exit: 1149 sdio_release_host(card->func); 1150 kfree(tmpbuf); 1151 1152 return ret; 1153 } 1154 1155 static 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 1216 done: 1217 sdio_release_host(card->func); 1218 return ret; 1219 } 1220 1221 static 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 1242 static 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 */ 1292 static enum 1293 rdwr_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 */ 1342 static 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 int size = 0; 1354 1355 card = sdio_get_drvdata(func); 1356 priv = card->priv; 1357 1358 /* dump sdio register first */ 1359 btmrvl_sdio_dump_regs(priv); 1360 1361 if (!card->supports_fw_dump) { 1362 BT_ERR("Firmware dump not supported for this card!"); 1363 return; 1364 } 1365 1366 for (idx = 0; idx < ARRAY_SIZE(mem_type_mapping_tbl); idx++) { 1367 struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx]; 1368 1369 if (entry->mem_ptr) { 1370 vfree(entry->mem_ptr); 1371 entry->mem_ptr = NULL; 1372 } 1373 entry->mem_size = 0; 1374 } 1375 1376 btmrvl_sdio_wakeup_fw(priv); 1377 sdio_claim_host(card->func); 1378 1379 BT_INFO("== btmrvl firmware dump start =="); 1380 1381 stat = btmrvl_sdio_rdwr_firmware(priv, doneflag); 1382 if (stat == RDWR_STATUS_FAILURE) 1383 goto done; 1384 1385 reg = card->reg->fw_dump_start; 1386 /* Read the number of the memories which will dump */ 1387 dump_num = sdio_readb(card->func, reg, &ret); 1388 1389 if (ret) { 1390 BT_ERR("SDIO read memory length err"); 1391 goto done; 1392 } 1393 1394 /* Read the length of every memory which will dump */ 1395 for (idx = 0; idx < dump_num; idx++) { 1396 struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx]; 1397 1398 stat = btmrvl_sdio_rdwr_firmware(priv, doneflag); 1399 if (stat == RDWR_STATUS_FAILURE) 1400 goto done; 1401 1402 memory_size = 0; 1403 reg = card->reg->fw_dump_start; 1404 for (i = 0; i < 4; i++) { 1405 read_reg = sdio_readb(card->func, reg, &ret); 1406 if (ret) { 1407 BT_ERR("SDIO read err"); 1408 goto done; 1409 } 1410 memory_size |= (read_reg << i*8); 1411 reg++; 1412 } 1413 1414 if (memory_size == 0) { 1415 BT_INFO("Firmware dump finished!"); 1416 sdio_writeb(card->func, FW_DUMP_READ_DONE, 1417 card->reg->fw_dump_ctrl, &ret); 1418 if (ret) { 1419 BT_ERR("SDIO Write MEMDUMP_FINISH ERR"); 1420 goto done; 1421 } 1422 break; 1423 } 1424 1425 BT_INFO("%s_SIZE=0x%x", entry->mem_name, memory_size); 1426 entry->mem_ptr = vzalloc(memory_size + 1); 1427 entry->mem_size = memory_size; 1428 if (!entry->mem_ptr) { 1429 BT_ERR("Vzalloc %s failed", entry->mem_name); 1430 goto done; 1431 } 1432 1433 fw_dump_len += (strlen("========Start dump ") + 1434 strlen(entry->mem_name) + 1435 strlen("========\n") + 1436 (memory_size + 1) + 1437 strlen("\n========End dump========\n")); 1438 1439 dbg_ptr = entry->mem_ptr; 1440 end_ptr = dbg_ptr + memory_size; 1441 1442 doneflag = entry->done_flag; 1443 BT_INFO("Start %s output, please wait...", 1444 entry->mem_name); 1445 1446 do { 1447 stat = btmrvl_sdio_rdwr_firmware(priv, doneflag); 1448 if (stat == RDWR_STATUS_FAILURE) 1449 goto done; 1450 1451 reg_start = card->reg->fw_dump_start; 1452 reg_end = card->reg->fw_dump_end; 1453 for (reg = reg_start; reg <= reg_end; reg++) { 1454 *dbg_ptr = sdio_readb(card->func, reg, &ret); 1455 if (ret) { 1456 BT_ERR("SDIO read err"); 1457 goto done; 1458 } 1459 if (dbg_ptr < end_ptr) 1460 dbg_ptr++; 1461 else 1462 BT_ERR("Allocated buffer not enough"); 1463 } 1464 1465 if (stat == RDWR_STATUS_DONE) { 1466 BT_INFO("%s done: size=0x%tx", 1467 entry->mem_name, 1468 dbg_ptr - entry->mem_ptr); 1469 break; 1470 } 1471 } while (1); 1472 } 1473 1474 BT_INFO("== btmrvl firmware dump end =="); 1475 1476 done: 1477 sdio_release_host(card->func); 1478 1479 if (fw_dump_len == 0) 1480 return; 1481 1482 fw_dump_data = vzalloc(fw_dump_len + 1); 1483 if (!fw_dump_data) { 1484 BT_ERR("Vzalloc fw_dump_data fail!"); 1485 return; 1486 } 1487 fw_dump_ptr = fw_dump_data; 1488 1489 /* Dump all the memory data into single file, a userspace script will 1490 * be used to split all the memory data to multiple files 1491 */ 1492 BT_INFO("== btmrvl firmware dump to /sys/class/devcoredump start"); 1493 for (idx = 0; idx < dump_num; idx++) { 1494 struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx]; 1495 1496 if (entry->mem_ptr) { 1497 size += scnprintf(fw_dump_ptr + size, 1498 fw_dump_len + 1 - size, 1499 "========Start dump %s========\n", 1500 entry->mem_name); 1501 1502 memcpy(fw_dump_ptr + size, entry->mem_ptr, 1503 entry->mem_size); 1504 size += entry->mem_size; 1505 1506 size += scnprintf(fw_dump_ptr + size, 1507 fw_dump_len + 1 - size, 1508 "\n========End dump========\n"); 1509 1510 vfree(mem_type_mapping_tbl[idx].mem_ptr); 1511 mem_type_mapping_tbl[idx].mem_ptr = NULL; 1512 } 1513 } 1514 1515 /* fw_dump_data will be free in device coredump release function 1516 * after 5 min 1517 */ 1518 dev_coredumpv(&card->func->dev, fw_dump_data, fw_dump_len, GFP_KERNEL); 1519 BT_INFO("== btmrvl firmware dump to /sys/class/devcoredump end"); 1520 } 1521 1522 static int btmrvl_sdio_probe(struct sdio_func *func, 1523 const struct sdio_device_id *id) 1524 { 1525 int ret = 0; 1526 struct btmrvl_private *priv = NULL; 1527 struct btmrvl_sdio_card *card = NULL; 1528 1529 BT_INFO("vendor=0x%x, device=0x%x, class=%d, fn=%d", 1530 id->vendor, id->device, id->class, func->num); 1531 1532 card = devm_kzalloc(&func->dev, sizeof(*card), GFP_KERNEL); 1533 if (!card) 1534 return -ENOMEM; 1535 1536 card->func = func; 1537 1538 if (id->driver_data) { 1539 struct btmrvl_sdio_device *data = (void *) id->driver_data; 1540 card->helper = data->helper; 1541 card->firmware = data->firmware; 1542 card->reg = data->reg; 1543 card->sd_blksz_fw_dl = data->sd_blksz_fw_dl; 1544 card->support_pscan_win_report = data->support_pscan_win_report; 1545 card->supports_fw_dump = data->supports_fw_dump; 1546 } 1547 1548 if (btmrvl_sdio_register_dev(card) < 0) { 1549 BT_ERR("Failed to register BT device!"); 1550 return -ENODEV; 1551 } 1552 1553 /* Disable the interrupts on the card */ 1554 btmrvl_sdio_disable_host_int(card); 1555 1556 if (btmrvl_sdio_download_fw(card)) { 1557 BT_ERR("Downloading firmware failed!"); 1558 ret = -ENODEV; 1559 goto unreg_dev; 1560 } 1561 1562 btmrvl_sdio_enable_host_int(card); 1563 1564 /* Device tree node parsing and platform specific configuration*/ 1565 btmrvl_sdio_probe_of(&func->dev, card); 1566 1567 priv = btmrvl_add_card(card); 1568 if (!priv) { 1569 BT_ERR("Initializing card failed!"); 1570 ret = -ENODEV; 1571 goto disable_host_int; 1572 } 1573 1574 card->priv = priv; 1575 1576 /* Initialize the interface specific function pointers */ 1577 priv->hw_host_to_card = btmrvl_sdio_host_to_card; 1578 priv->hw_wakeup_firmware = btmrvl_sdio_wakeup_fw; 1579 priv->hw_process_int_status = btmrvl_sdio_process_int_status; 1580 1581 if (btmrvl_register_hdev(priv)) { 1582 BT_ERR("Register hdev failed!"); 1583 ret = -ENODEV; 1584 goto disable_host_int; 1585 } 1586 1587 return 0; 1588 1589 disable_host_int: 1590 btmrvl_sdio_disable_host_int(card); 1591 unreg_dev: 1592 btmrvl_sdio_unregister_dev(card); 1593 return ret; 1594 } 1595 1596 static void btmrvl_sdio_remove(struct sdio_func *func) 1597 { 1598 struct btmrvl_sdio_card *card; 1599 1600 if (func) { 1601 card = sdio_get_drvdata(func); 1602 if (card) { 1603 /* Send SHUTDOWN command & disable interrupt 1604 * if user removes the module. 1605 */ 1606 if (user_rmmod) { 1607 btmrvl_send_module_cfg_cmd(card->priv, 1608 MODULE_SHUTDOWN_REQ); 1609 btmrvl_sdio_disable_host_int(card); 1610 } 1611 1612 BT_DBG("unregister dev"); 1613 card->priv->surprise_removed = true; 1614 btmrvl_sdio_unregister_dev(card); 1615 btmrvl_remove_card(card->priv); 1616 } 1617 } 1618 } 1619 1620 static int btmrvl_sdio_suspend(struct device *dev) 1621 { 1622 struct sdio_func *func = dev_to_sdio_func(dev); 1623 struct btmrvl_sdio_card *card; 1624 struct btmrvl_private *priv; 1625 mmc_pm_flag_t pm_flags; 1626 struct hci_dev *hcidev; 1627 1628 if (func) { 1629 pm_flags = sdio_get_host_pm_caps(func); 1630 BT_DBG("%s: suspend: PM flags = 0x%x", sdio_func_id(func), 1631 pm_flags); 1632 if (!(pm_flags & MMC_PM_KEEP_POWER)) { 1633 BT_ERR("%s: cannot remain alive while suspended", 1634 sdio_func_id(func)); 1635 return -ENOSYS; 1636 } 1637 card = sdio_get_drvdata(func); 1638 if (!card || !card->priv) { 1639 BT_ERR("card or priv structure is not valid"); 1640 return 0; 1641 } 1642 } else { 1643 BT_ERR("sdio_func is not specified"); 1644 return 0; 1645 } 1646 1647 /* Enable platform specific wakeup interrupt */ 1648 if (card->plt_wake_cfg && card->plt_wake_cfg->irq_bt >= 0 && 1649 device_may_wakeup(dev)) { 1650 card->plt_wake_cfg->wake_by_bt = false; 1651 enable_irq(card->plt_wake_cfg->irq_bt); 1652 enable_irq_wake(card->plt_wake_cfg->irq_bt); 1653 } 1654 1655 priv = card->priv; 1656 priv->adapter->is_suspending = true; 1657 hcidev = priv->btmrvl_dev.hcidev; 1658 BT_DBG("%s: SDIO suspend", hcidev->name); 1659 hci_suspend_dev(hcidev); 1660 1661 if (priv->adapter->hs_state != HS_ACTIVATED) { 1662 if (btmrvl_enable_hs(priv)) { 1663 BT_ERR("HS not activated, suspend failed!"); 1664 /* Disable platform specific wakeup interrupt */ 1665 if (card->plt_wake_cfg && 1666 card->plt_wake_cfg->irq_bt >= 0 && 1667 device_may_wakeup(dev)) { 1668 disable_irq_wake(card->plt_wake_cfg->irq_bt); 1669 disable_irq(card->plt_wake_cfg->irq_bt); 1670 } 1671 1672 priv->adapter->is_suspending = false; 1673 return -EBUSY; 1674 } 1675 } 1676 1677 priv->adapter->is_suspending = false; 1678 priv->adapter->is_suspended = true; 1679 1680 /* We will keep the power when hs enabled successfully */ 1681 if (priv->adapter->hs_state == HS_ACTIVATED) { 1682 BT_DBG("suspend with MMC_PM_KEEP_POWER"); 1683 return sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER); 1684 } 1685 1686 BT_DBG("suspend without MMC_PM_KEEP_POWER"); 1687 return 0; 1688 } 1689 1690 static int btmrvl_sdio_resume(struct device *dev) 1691 { 1692 struct sdio_func *func = dev_to_sdio_func(dev); 1693 struct btmrvl_sdio_card *card; 1694 struct btmrvl_private *priv; 1695 mmc_pm_flag_t pm_flags; 1696 struct hci_dev *hcidev; 1697 1698 if (func) { 1699 pm_flags = sdio_get_host_pm_caps(func); 1700 BT_DBG("%s: resume: PM flags = 0x%x", sdio_func_id(func), 1701 pm_flags); 1702 card = sdio_get_drvdata(func); 1703 if (!card || !card->priv) { 1704 BT_ERR("card or priv structure is not valid"); 1705 return 0; 1706 } 1707 } else { 1708 BT_ERR("sdio_func is not specified"); 1709 return 0; 1710 } 1711 priv = card->priv; 1712 1713 if (!priv->adapter->is_suspended) { 1714 BT_DBG("device already resumed"); 1715 return 0; 1716 } 1717 1718 priv->hw_wakeup_firmware(priv); 1719 priv->adapter->hs_state = HS_DEACTIVATED; 1720 hcidev = priv->btmrvl_dev.hcidev; 1721 BT_DBG("%s: HS DEACTIVATED in resume!", hcidev->name); 1722 priv->adapter->is_suspended = false; 1723 BT_DBG("%s: SDIO resume", hcidev->name); 1724 hci_resume_dev(hcidev); 1725 1726 /* Disable platform specific wakeup interrupt */ 1727 if (card->plt_wake_cfg && card->plt_wake_cfg->irq_bt >= 0 && 1728 device_may_wakeup(dev)) { 1729 disable_irq_wake(card->plt_wake_cfg->irq_bt); 1730 disable_irq(card->plt_wake_cfg->irq_bt); 1731 if (card->plt_wake_cfg->wake_by_bt) 1732 /* Undo our disable, since interrupt handler already 1733 * did this. 1734 */ 1735 enable_irq(card->plt_wake_cfg->irq_bt); 1736 } 1737 1738 return 0; 1739 } 1740 1741 static const struct dev_pm_ops btmrvl_sdio_pm_ops = { 1742 .suspend = btmrvl_sdio_suspend, 1743 .resume = btmrvl_sdio_resume, 1744 }; 1745 1746 static struct sdio_driver bt_mrvl_sdio = { 1747 .name = "btmrvl_sdio", 1748 .id_table = btmrvl_sdio_ids, 1749 .probe = btmrvl_sdio_probe, 1750 .remove = btmrvl_sdio_remove, 1751 .drv = { 1752 .owner = THIS_MODULE, 1753 .coredump = btmrvl_sdio_coredump, 1754 .pm = &btmrvl_sdio_pm_ops, 1755 } 1756 }; 1757 1758 static int __init btmrvl_sdio_init_module(void) 1759 { 1760 if (sdio_register_driver(&bt_mrvl_sdio) != 0) { 1761 BT_ERR("SDIO Driver Registration Failed"); 1762 return -ENODEV; 1763 } 1764 1765 /* Clear the flag in case user removes the card. */ 1766 user_rmmod = 0; 1767 1768 return 0; 1769 } 1770 1771 static void __exit btmrvl_sdio_exit_module(void) 1772 { 1773 /* Set the flag as user is removing this module. */ 1774 user_rmmod = 1; 1775 1776 sdio_unregister_driver(&bt_mrvl_sdio); 1777 } 1778 1779 module_init(btmrvl_sdio_init_module); 1780 module_exit(btmrvl_sdio_exit_module); 1781 1782 MODULE_AUTHOR("Marvell International Ltd."); 1783 MODULE_DESCRIPTION("Marvell BT-over-SDIO driver ver " VERSION); 1784 MODULE_VERSION(VERSION); 1785 MODULE_LICENSE("GPL v2"); 1786 MODULE_FIRMWARE("mrvl/sd8688_helper.bin"); 1787 MODULE_FIRMWARE("mrvl/sd8688.bin"); 1788 MODULE_FIRMWARE("mrvl/sd8787_uapsta.bin"); 1789 MODULE_FIRMWARE("mrvl/sd8797_uapsta.bin"); 1790 MODULE_FIRMWARE("mrvl/sd8887_uapsta.bin"); 1791 MODULE_FIRMWARE("mrvl/sd8897_uapsta.bin"); 1792 MODULE_FIRMWARE("mrvl/sdsd8977_combo_v2.bin"); 1793 MODULE_FIRMWARE("mrvl/sd8987_uapsta.bin"); 1794 MODULE_FIRMWARE("mrvl/sdsd8997_combo_v4.bin"); 1795