drivers/bluetooth/btmrvl_sdio.c

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