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