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