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