drivers/bluetooth/btmrvl_sdio.c

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