Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Marvell BT-over-SDIO driver: SDIO interface related functions.
0004  *
0005  * Copyright (C) 2009, Marvell International Ltd.
0006  **/
0007 
0008 #include <linux/firmware.h>
0009 #include <linux/slab.h>
0010 #include <linux/suspend.h>
0011 
0012 #include <linux/mmc/sdio_ids.h>
0013 #include <linux/mmc/sdio_func.h>
0014 #include <linux/module.h>
0015 #include <linux/devcoredump.h>
0016 
0017 #include <net/bluetooth/bluetooth.h>
0018 #include <net/bluetooth/hci_core.h>
0019 
0020 #include "btmrvl_drv.h"
0021 #include "btmrvl_sdio.h"
0022 
0023 #define VERSION "1.0"
0024 
0025 static struct memory_type_mapping mem_type_mapping_tbl[] = {
0026     {"ITCM", NULL, 0, 0xF0},
0027     {"DTCM", NULL, 0, 0xF1},
0028     {"SQRAM", NULL, 0, 0xF2},
0029     {"APU", NULL, 0, 0xF3},
0030     {"CIU", NULL, 0, 0xF4},
0031     {"ICU", NULL, 0, 0xF5},
0032     {"MAC", NULL, 0, 0xF6},
0033     {"EXT7", NULL, 0, 0xF7},
0034     {"EXT8", NULL, 0, 0xF8},
0035     {"EXT9", NULL, 0, 0xF9},
0036     {"EXT10", NULL, 0, 0xFA},
0037     {"EXT11", NULL, 0, 0xFB},
0038     {"EXT12", NULL, 0, 0xFC},
0039     {"EXT13", NULL, 0, 0xFD},
0040     {"EXTLAST", NULL, 0, 0xFE},
0041 };
0042 
0043 static const struct of_device_id btmrvl_sdio_of_match_table[] = {
0044     { .compatible = "marvell,sd8897-bt" },
0045     { .compatible = "marvell,sd8997-bt" },
0046     { }
0047 };
0048 
0049 static irqreturn_t btmrvl_wake_irq_bt(int irq, void *priv)
0050 {
0051     struct btmrvl_sdio_card *card = priv;
0052     struct device *dev = &card->func->dev;
0053     struct btmrvl_plt_wake_cfg *cfg = card->plt_wake_cfg;
0054 
0055     dev_info(dev, "wake by bt\n");
0056     cfg->wake_by_bt = true;
0057     disable_irq_nosync(irq);
0058 
0059     pm_wakeup_event(dev, 0);
0060     pm_system_wakeup();
0061 
0062     return IRQ_HANDLED;
0063 }
0064 
0065 /* This function parses device tree node using mmc subnode devicetree API.
0066  * The device node is saved in card->plt_of_node.
0067  * If the device tree node exists and includes interrupts attributes, this
0068  * function will request platform specific wakeup interrupt.
0069  */
0070 static int btmrvl_sdio_probe_of(struct device *dev,
0071                 struct btmrvl_sdio_card *card)
0072 {
0073     struct btmrvl_plt_wake_cfg *cfg;
0074     int ret;
0075 
0076     if (!dev->of_node ||
0077         !of_match_node(btmrvl_sdio_of_match_table, dev->of_node)) {
0078         dev_info(dev, "sdio device tree data not available\n");
0079         return -1;
0080     }
0081 
0082     card->plt_of_node = dev->of_node;
0083 
0084     card->plt_wake_cfg = devm_kzalloc(dev, sizeof(*card->plt_wake_cfg),
0085                       GFP_KERNEL);
0086     cfg = card->plt_wake_cfg;
0087     if (cfg && card->plt_of_node) {
0088         cfg->irq_bt = irq_of_parse_and_map(card->plt_of_node, 0);
0089         if (!cfg->irq_bt) {
0090             dev_err(dev, "fail to parse irq_bt from device tree\n");
0091             cfg->irq_bt = -1;
0092         } else {
0093             ret = devm_request_irq(dev, cfg->irq_bt,
0094                            btmrvl_wake_irq_bt,
0095                            0, "bt_wake", card);
0096             if (ret) {
0097                 dev_err(dev,
0098                     "Failed to request irq_bt %d (%d)\n",
0099                     cfg->irq_bt, ret);
0100             }
0101 
0102             /* Configure wakeup (enabled by default) */
0103             device_init_wakeup(dev, true);
0104             disable_irq(cfg->irq_bt);
0105         }
0106     }
0107 
0108     return 0;
0109 }
0110 
0111 /* The btmrvl_sdio_remove() callback function is called
0112  * when user removes this module from kernel space or ejects
0113  * the card from the slot. The driver handles these 2 cases
0114  * differently.
0115  * If the user is removing the module, a MODULE_SHUTDOWN_REQ
0116  * command is sent to firmware and interrupt will be disabled.
0117  * If the card is removed, there is no need to send command
0118  * or disable interrupt.
0119  *
0120  * The variable 'user_rmmod' is used to distinguish these two
0121  * scenarios. This flag is initialized as FALSE in case the card
0122  * is removed, and will be set to TRUE for module removal when
0123  * module_exit function is called.
0124  */
0125 static u8 user_rmmod;
0126 static u8 sdio_ireg;
0127 
0128 static const struct btmrvl_sdio_card_reg btmrvl_reg_8688 = {
0129     .cfg = 0x03,
0130     .host_int_mask = 0x04,
0131     .host_intstatus = 0x05,
0132     .card_status = 0x20,
0133     .sq_read_base_addr_a0 = 0x10,
0134     .sq_read_base_addr_a1 = 0x11,
0135     .card_fw_status0 = 0x40,
0136     .card_fw_status1 = 0x41,
0137     .card_rx_len = 0x42,
0138     .card_rx_unit = 0x43,
0139     .io_port_0 = 0x00,
0140     .io_port_1 = 0x01,
0141     .io_port_2 = 0x02,
0142     .int_read_to_clear = false,
0143 };
0144 static const struct btmrvl_sdio_card_reg btmrvl_reg_87xx = {
0145     .cfg = 0x00,
0146     .host_int_mask = 0x02,
0147     .host_intstatus = 0x03,
0148     .card_status = 0x30,
0149     .sq_read_base_addr_a0 = 0x40,
0150     .sq_read_base_addr_a1 = 0x41,
0151     .card_revision = 0x5c,
0152     .card_fw_status0 = 0x60,
0153     .card_fw_status1 = 0x61,
0154     .card_rx_len = 0x62,
0155     .card_rx_unit = 0x63,
0156     .io_port_0 = 0x78,
0157     .io_port_1 = 0x79,
0158     .io_port_2 = 0x7a,
0159     .int_read_to_clear = false,
0160 };
0161 
0162 static const struct btmrvl_sdio_card_reg btmrvl_reg_8887 = {
0163     .cfg = 0x00,
0164     .host_int_mask = 0x08,
0165     .host_intstatus = 0x0C,
0166     .card_status = 0x5C,
0167     .sq_read_base_addr_a0 = 0x6C,
0168     .sq_read_base_addr_a1 = 0x6D,
0169     .card_revision = 0xC8,
0170     .card_fw_status0 = 0x88,
0171     .card_fw_status1 = 0x89,
0172     .card_rx_len = 0x8A,
0173     .card_rx_unit = 0x8B,
0174     .io_port_0 = 0xE4,
0175     .io_port_1 = 0xE5,
0176     .io_port_2 = 0xE6,
0177     .int_read_to_clear = true,
0178     .host_int_rsr = 0x04,
0179     .card_misc_cfg = 0xD8,
0180 };
0181 
0182 static const struct btmrvl_sdio_card_reg btmrvl_reg_8897 = {
0183     .cfg = 0x00,
0184     .host_int_mask = 0x02,
0185     .host_intstatus = 0x03,
0186     .card_status = 0x50,
0187     .sq_read_base_addr_a0 = 0x60,
0188     .sq_read_base_addr_a1 = 0x61,
0189     .card_revision = 0xbc,
0190     .card_fw_status0 = 0xc0,
0191     .card_fw_status1 = 0xc1,
0192     .card_rx_len = 0xc2,
0193     .card_rx_unit = 0xc3,
0194     .io_port_0 = 0xd8,
0195     .io_port_1 = 0xd9,
0196     .io_port_2 = 0xda,
0197     .int_read_to_clear = true,
0198     .host_int_rsr = 0x01,
0199     .card_misc_cfg = 0xcc,
0200     .fw_dump_ctrl = 0xe2,
0201     .fw_dump_start = 0xe3,
0202     .fw_dump_end = 0xea,
0203 };
0204 
0205 static const struct btmrvl_sdio_card_reg btmrvl_reg_89xx = {
0206     .cfg = 0x00,
0207     .host_int_mask = 0x08,
0208     .host_intstatus = 0x0c,
0209     .card_status = 0x5c,
0210     .sq_read_base_addr_a0 = 0xf8,
0211     .sq_read_base_addr_a1 = 0xf9,
0212     .card_revision = 0xc8,
0213     .card_fw_status0 = 0xe8,
0214     .card_fw_status1 = 0xe9,
0215     .card_rx_len = 0xea,
0216     .card_rx_unit = 0xeb,
0217     .io_port_0 = 0xe4,
0218     .io_port_1 = 0xe5,
0219     .io_port_2 = 0xe6,
0220     .int_read_to_clear = true,
0221     .host_int_rsr = 0x04,
0222     .card_misc_cfg = 0xd8,
0223     .fw_dump_ctrl = 0xf0,
0224     .fw_dump_start = 0xf1,
0225     .fw_dump_end = 0xf8,
0226 };
0227 
0228 static const struct btmrvl_sdio_device btmrvl_sdio_sd8688 = {
0229     .helper     = "mrvl/sd8688_helper.bin",
0230     .firmware   = "mrvl/sd8688.bin",
0231     .reg        = &btmrvl_reg_8688,
0232     .support_pscan_win_report = false,
0233     .sd_blksz_fw_dl = 64,
0234     .supports_fw_dump = false,
0235 };
0236 
0237 static const struct btmrvl_sdio_device btmrvl_sdio_sd8787 = {
0238     .helper     = NULL,
0239     .firmware   = "mrvl/sd8787_uapsta.bin",
0240     .reg        = &btmrvl_reg_87xx,
0241     .support_pscan_win_report = false,
0242     .sd_blksz_fw_dl = 256,
0243     .supports_fw_dump = false,
0244 };
0245 
0246 static const struct btmrvl_sdio_device btmrvl_sdio_sd8797 = {
0247     .helper     = NULL,
0248     .firmware   = "mrvl/sd8797_uapsta.bin",
0249     .reg        = &btmrvl_reg_87xx,
0250     .support_pscan_win_report = false,
0251     .sd_blksz_fw_dl = 256,
0252     .supports_fw_dump = false,
0253 };
0254 
0255 static const struct btmrvl_sdio_device btmrvl_sdio_sd8887 = {
0256     .helper     = NULL,
0257     .firmware   = "mrvl/sd8887_uapsta.bin",
0258     .reg        = &btmrvl_reg_8887,
0259     .support_pscan_win_report = true,
0260     .sd_blksz_fw_dl = 256,
0261     .supports_fw_dump = false,
0262 };
0263 
0264 static const struct btmrvl_sdio_device btmrvl_sdio_sd8897 = {
0265     .helper     = NULL,
0266     .firmware   = "mrvl/sd8897_uapsta.bin",
0267     .reg        = &btmrvl_reg_8897,
0268     .support_pscan_win_report = true,
0269     .sd_blksz_fw_dl = 256,
0270     .supports_fw_dump = true,
0271 };
0272 
0273 static const struct btmrvl_sdio_device btmrvl_sdio_sd8977 = {
0274     .helper         = NULL,
0275     .firmware       = "mrvl/sdsd8977_combo_v2.bin",
0276     .reg            = &btmrvl_reg_89xx,
0277     .support_pscan_win_report = true,
0278     .sd_blksz_fw_dl = 256,
0279     .supports_fw_dump = true,
0280 };
0281 
0282 static const struct btmrvl_sdio_device btmrvl_sdio_sd8987 = {
0283     .helper     = NULL,
0284     .firmware   = "mrvl/sd8987_uapsta.bin",
0285     .reg        = &btmrvl_reg_89xx,
0286     .support_pscan_win_report = true,
0287     .sd_blksz_fw_dl = 256,
0288     .supports_fw_dump = true,
0289 };
0290 
0291 static const struct btmrvl_sdio_device btmrvl_sdio_sd8997 = {
0292     .helper         = NULL,
0293     .firmware       = "mrvl/sdsd8997_combo_v4.bin",
0294     .reg            = &btmrvl_reg_89xx,
0295     .support_pscan_win_report = true,
0296     .sd_blksz_fw_dl = 256,
0297     .supports_fw_dump = true,
0298 };
0299 
0300 static const struct sdio_device_id btmrvl_sdio_ids[] = {
0301     /* Marvell SD8688 Bluetooth device */
0302     { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8688_BT),
0303             .driver_data = (unsigned long)&btmrvl_sdio_sd8688 },
0304     /* Marvell SD8787 Bluetooth device */
0305     { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8787_BT),
0306             .driver_data = (unsigned long)&btmrvl_sdio_sd8787 },
0307     /* Marvell SD8787 Bluetooth AMP device */
0308     { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8787_BT_AMP),
0309             .driver_data = (unsigned long)&btmrvl_sdio_sd8787 },
0310     /* Marvell SD8797 Bluetooth device */
0311     { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8797_BT),
0312             .driver_data = (unsigned long)&btmrvl_sdio_sd8797 },
0313     /* Marvell SD8887 Bluetooth device */
0314     { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8887_BT),
0315             .driver_data = (unsigned long)&btmrvl_sdio_sd8887 },
0316     /* Marvell SD8897 Bluetooth device */
0317     { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8897_BT),
0318             .driver_data = (unsigned long)&btmrvl_sdio_sd8897 },
0319     /* Marvell SD8977 Bluetooth device */
0320     { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8977_BT),
0321             .driver_data = (unsigned long)&btmrvl_sdio_sd8977 },
0322     /* Marvell SD8987 Bluetooth device */
0323     { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8987_BT),
0324             .driver_data = (unsigned long)&btmrvl_sdio_sd8987 },
0325     /* Marvell SD8997 Bluetooth device */
0326     { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8997_BT),
0327             .driver_data = (unsigned long)&btmrvl_sdio_sd8997 },
0328 
0329     { } /* Terminating entry */
0330 };
0331 
0332 MODULE_DEVICE_TABLE(sdio, btmrvl_sdio_ids);
0333 
0334 static int btmrvl_sdio_get_rx_unit(struct btmrvl_sdio_card *card)
0335 {
0336     u8 reg;
0337     int ret;
0338 
0339     reg = sdio_readb(card->func, card->reg->card_rx_unit, &ret);
0340     if (!ret)
0341         card->rx_unit = reg;
0342 
0343     return ret;
0344 }
0345 
0346 static int btmrvl_sdio_read_fw_status(struct btmrvl_sdio_card *card, u16 *dat)
0347 {
0348     u8 fws0, fws1;
0349     int ret;
0350 
0351     *dat = 0;
0352 
0353     fws0 = sdio_readb(card->func, card->reg->card_fw_status0, &ret);
0354     if (ret)
0355         return -EIO;
0356 
0357     fws1 = sdio_readb(card->func, card->reg->card_fw_status1, &ret);
0358     if (ret)
0359         return -EIO;
0360 
0361     *dat = (((u16) fws1) << 8) | fws0;
0362 
0363     return 0;
0364 }
0365 
0366 static int btmrvl_sdio_read_rx_len(struct btmrvl_sdio_card *card, u16 *dat)
0367 {
0368     u8 reg;
0369     int ret;
0370 
0371     reg = sdio_readb(card->func, card->reg->card_rx_len, &ret);
0372     if (!ret)
0373         *dat = (u16) reg << card->rx_unit;
0374 
0375     return ret;
0376 }
0377 
0378 static int btmrvl_sdio_enable_host_int_mask(struct btmrvl_sdio_card *card,
0379                                 u8 mask)
0380 {
0381     int ret;
0382 
0383     sdio_writeb(card->func, mask, card->reg->host_int_mask, &ret);
0384     if (ret) {
0385         BT_ERR("Unable to enable the host interrupt!");
0386         ret = -EIO;
0387     }
0388 
0389     return ret;
0390 }
0391 
0392 static int btmrvl_sdio_disable_host_int_mask(struct btmrvl_sdio_card *card,
0393                                 u8 mask)
0394 {
0395     u8 host_int_mask;
0396     int ret;
0397 
0398     host_int_mask = sdio_readb(card->func, card->reg->host_int_mask, &ret);
0399     if (ret)
0400         return -EIO;
0401 
0402     host_int_mask &= ~mask;
0403 
0404     sdio_writeb(card->func, host_int_mask, card->reg->host_int_mask, &ret);
0405     if (ret < 0) {
0406         BT_ERR("Unable to disable the host interrupt!");
0407         return -EIO;
0408     }
0409 
0410     return 0;
0411 }
0412 
0413 static int btmrvl_sdio_poll_card_status(struct btmrvl_sdio_card *card, u8 bits)
0414 {
0415     unsigned int tries;
0416     u8 status;
0417     int ret;
0418 
0419     for (tries = 0; tries < MAX_POLL_TRIES * 1000; tries++) {
0420         status = sdio_readb(card->func, card->reg->card_status, &ret);
0421         if (ret)
0422             goto failed;
0423         if ((status & bits) == bits)
0424             return ret;
0425 
0426         udelay(1);
0427     }
0428 
0429     ret = -ETIMEDOUT;
0430 
0431 failed:
0432     BT_ERR("FAILED! ret=%d", ret);
0433 
0434     return ret;
0435 }
0436 
0437 static int btmrvl_sdio_verify_fw_download(struct btmrvl_sdio_card *card,
0438                                 int pollnum)
0439 {
0440     u16 firmwarestat;
0441     int tries, ret;
0442 
0443      /* Wait for firmware to become ready */
0444     for (tries = 0; tries < pollnum; tries++) {
0445         sdio_claim_host(card->func);
0446         ret = btmrvl_sdio_read_fw_status(card, &firmwarestat);
0447         sdio_release_host(card->func);
0448         if (ret < 0)
0449             continue;
0450 
0451         if (firmwarestat == FIRMWARE_READY)
0452             return 0;
0453 
0454         msleep(100);
0455     }
0456 
0457     return -ETIMEDOUT;
0458 }
0459 
0460 static int btmrvl_sdio_download_helper(struct btmrvl_sdio_card *card)
0461 {
0462     const struct firmware *fw_helper = NULL;
0463     const u8 *helper = NULL;
0464     int ret;
0465     void *tmphlprbuf = NULL;
0466     int tmphlprbufsz, hlprblknow, helperlen;
0467     u8 *helperbuf;
0468     u32 tx_len;
0469 
0470     ret = request_firmware(&fw_helper, card->helper,
0471                         &card->func->dev);
0472     if ((ret < 0) || !fw_helper) {
0473         BT_ERR("request_firmware(helper) failed, error code = %d",
0474                                     ret);
0475         ret = -ENOENT;
0476         goto done;
0477     }
0478 
0479     helper = fw_helper->data;
0480     helperlen = fw_helper->size;
0481 
0482     BT_DBG("Downloading helper image (%d bytes), block size %d bytes",
0483                         helperlen, SDIO_BLOCK_SIZE);
0484 
0485     tmphlprbufsz = ALIGN_SZ(BTM_UPLD_SIZE, BTSDIO_DMA_ALIGN);
0486 
0487     tmphlprbuf = kzalloc(tmphlprbufsz, GFP_KERNEL);
0488     if (!tmphlprbuf) {
0489         BT_ERR("Unable to allocate buffer for helper."
0490             " Terminating download");
0491         ret = -ENOMEM;
0492         goto done;
0493     }
0494 
0495     helperbuf = (u8 *) ALIGN_ADDR(tmphlprbuf, BTSDIO_DMA_ALIGN);
0496 
0497     /* Perform helper data transfer */
0498     tx_len = (FIRMWARE_TRANSFER_NBLOCK * SDIO_BLOCK_SIZE)
0499             - SDIO_HEADER_LEN;
0500     hlprblknow = 0;
0501 
0502     do {
0503         ret = btmrvl_sdio_poll_card_status(card,
0504                         CARD_IO_READY | DN_LD_CARD_RDY);
0505         if (ret < 0) {
0506             BT_ERR("Helper download poll status timeout @ %d",
0507                 hlprblknow);
0508             goto done;
0509         }
0510 
0511         /* Check if there is more data? */
0512         if (hlprblknow >= helperlen)
0513             break;
0514 
0515         if (helperlen - hlprblknow < tx_len)
0516             tx_len = helperlen - hlprblknow;
0517 
0518         /* Little-endian */
0519         helperbuf[0] = ((tx_len & 0x000000ff) >> 0);
0520         helperbuf[1] = ((tx_len & 0x0000ff00) >> 8);
0521         helperbuf[2] = ((tx_len & 0x00ff0000) >> 16);
0522         helperbuf[3] = ((tx_len & 0xff000000) >> 24);
0523 
0524         memcpy(&helperbuf[SDIO_HEADER_LEN], &helper[hlprblknow],
0525                 tx_len);
0526 
0527         /* Now send the data */
0528         ret = sdio_writesb(card->func, card->ioport, helperbuf,
0529                 FIRMWARE_TRANSFER_NBLOCK * SDIO_BLOCK_SIZE);
0530         if (ret < 0) {
0531             BT_ERR("IO error during helper download @ %d",
0532                 hlprblknow);
0533             goto done;
0534         }
0535 
0536         hlprblknow += tx_len;
0537     } while (true);
0538 
0539     BT_DBG("Transferring helper image EOF block");
0540 
0541     memset(helperbuf, 0x0, SDIO_BLOCK_SIZE);
0542 
0543     ret = sdio_writesb(card->func, card->ioport, helperbuf,
0544                             SDIO_BLOCK_SIZE);
0545     if (ret < 0) {
0546         BT_ERR("IO error in writing helper image EOF block");
0547         goto done;
0548     }
0549 
0550     ret = 0;
0551 
0552 done:
0553     kfree(tmphlprbuf);
0554     release_firmware(fw_helper);
0555     return ret;
0556 }
0557 
0558 static int btmrvl_sdio_download_fw_w_helper(struct btmrvl_sdio_card *card)
0559 {
0560     const struct firmware *fw_firmware = NULL;
0561     const u8 *firmware = NULL;
0562     int firmwarelen, tmpfwbufsz, ret;
0563     unsigned int tries, offset;
0564     u8 base0, base1;
0565     void *tmpfwbuf = NULL;
0566     u8 *fwbuf;
0567     u16 len, blksz_dl = card->sd_blksz_fw_dl;
0568     int txlen = 0, tx_blocks = 0, count = 0;
0569 
0570     ret = request_firmware(&fw_firmware, card->firmware,
0571                             &card->func->dev);
0572     if ((ret < 0) || !fw_firmware) {
0573         BT_ERR("request_firmware(firmware) failed, error code = %d",
0574                                     ret);
0575         ret = -ENOENT;
0576         goto done;
0577     }
0578 
0579     firmware = fw_firmware->data;
0580     firmwarelen = fw_firmware->size;
0581 
0582     BT_DBG("Downloading FW image (%d bytes)", firmwarelen);
0583 
0584     tmpfwbufsz = ALIGN_SZ(BTM_UPLD_SIZE, BTSDIO_DMA_ALIGN);
0585     tmpfwbuf = kzalloc(tmpfwbufsz, GFP_KERNEL);
0586     if (!tmpfwbuf) {
0587         BT_ERR("Unable to allocate buffer for firmware."
0588                " Terminating download");
0589         ret = -ENOMEM;
0590         goto done;
0591     }
0592 
0593     /* Ensure aligned firmware buffer */
0594     fwbuf = (u8 *) ALIGN_ADDR(tmpfwbuf, BTSDIO_DMA_ALIGN);
0595 
0596     /* Perform firmware data transfer */
0597     offset = 0;
0598     do {
0599         ret = btmrvl_sdio_poll_card_status(card,
0600                     CARD_IO_READY | DN_LD_CARD_RDY);
0601         if (ret < 0) {
0602             BT_ERR("FW download with helper poll status"
0603                         " timeout @ %d", offset);
0604             goto done;
0605         }
0606 
0607         /* Check if there is more data ? */
0608         if (offset >= firmwarelen)
0609             break;
0610 
0611         for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
0612             base0 = sdio_readb(card->func,
0613                     card->reg->sq_read_base_addr_a0, &ret);
0614             if (ret) {
0615                 BT_ERR("BASE0 register read failed:"
0616                     " base0 = 0x%04X(%d)."
0617                     " Terminating download",
0618                     base0, base0);
0619                 ret = -EIO;
0620                 goto done;
0621             }
0622             base1 = sdio_readb(card->func,
0623                     card->reg->sq_read_base_addr_a1, &ret);
0624             if (ret) {
0625                 BT_ERR("BASE1 register read failed:"
0626                     " base1 = 0x%04X(%d)."
0627                     " Terminating download",
0628                     base1, base1);
0629                 ret = -EIO;
0630                 goto done;
0631             }
0632 
0633             len = (((u16) base1) << 8) | base0;
0634             if (len)
0635                 break;
0636 
0637             udelay(10);
0638         }
0639 
0640         if (!len)
0641             break;
0642         else if (len > BTM_UPLD_SIZE) {
0643             BT_ERR("FW download failure @%d, invalid length %d",
0644                                 offset, len);
0645             ret = -EINVAL;
0646             goto done;
0647         }
0648 
0649         txlen = len;
0650 
0651         if (len & BIT(0)) {
0652             count++;
0653             if (count > MAX_WRITE_IOMEM_RETRY) {
0654                 BT_ERR("FW download failure @%d, "
0655                     "over max retry count", offset);
0656                 ret = -EIO;
0657                 goto done;
0658             }
0659             BT_ERR("FW CRC error indicated by the helper: "
0660                 "len = 0x%04X, txlen = %d", len, txlen);
0661             len &= ~BIT(0);
0662             /* Set txlen to 0 so as to resend from same offset */
0663             txlen = 0;
0664         } else {
0665             count = 0;
0666 
0667             /* Last block ? */
0668             if (firmwarelen - offset < txlen)
0669                 txlen = firmwarelen - offset;
0670 
0671             tx_blocks = DIV_ROUND_UP(txlen, blksz_dl);
0672 
0673             memcpy(fwbuf, &firmware[offset], txlen);
0674         }
0675 
0676         ret = sdio_writesb(card->func, card->ioport, fwbuf,
0677                         tx_blocks * blksz_dl);
0678 
0679         if (ret < 0) {
0680             BT_ERR("FW download, writesb(%d) failed @%d",
0681                             count, offset);
0682             sdio_writeb(card->func, HOST_CMD53_FIN,
0683                         card->reg->cfg, &ret);
0684             if (ret)
0685                 BT_ERR("writeb failed (CFG)");
0686         }
0687 
0688         offset += txlen;
0689     } while (true);
0690 
0691     BT_INFO("FW download over, size %d bytes", offset);
0692 
0693     ret = 0;
0694 
0695 done:
0696     kfree(tmpfwbuf);
0697     release_firmware(fw_firmware);
0698     return ret;
0699 }
0700 
0701 static int btmrvl_sdio_card_to_host(struct btmrvl_private *priv)
0702 {
0703     u16 buf_len = 0;
0704     int ret, num_blocks, blksz;
0705     struct sk_buff *skb = NULL;
0706     u32 type;
0707     u8 *payload;
0708     struct hci_dev *hdev = priv->btmrvl_dev.hcidev;
0709     struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
0710 
0711     if (!card || !card->func) {
0712         BT_ERR("card or function is NULL!");
0713         ret = -EINVAL;
0714         goto exit;
0715     }
0716 
0717     /* Read the length of data to be transferred */
0718     ret = btmrvl_sdio_read_rx_len(card, &buf_len);
0719     if (ret < 0) {
0720         BT_ERR("read rx_len failed");
0721         ret = -EIO;
0722         goto exit;
0723     }
0724 
0725     blksz = SDIO_BLOCK_SIZE;
0726     num_blocks = DIV_ROUND_UP(buf_len, blksz);
0727 
0728     if (buf_len <= SDIO_HEADER_LEN
0729         || (num_blocks * blksz) > ALLOC_BUF_SIZE) {
0730         BT_ERR("invalid packet length: %d", buf_len);
0731         ret = -EINVAL;
0732         goto exit;
0733     }
0734 
0735     /* Allocate buffer */
0736     skb = bt_skb_alloc(num_blocks * blksz + BTSDIO_DMA_ALIGN, GFP_KERNEL);
0737     if (!skb) {
0738         BT_ERR("No free skb");
0739         ret = -ENOMEM;
0740         goto exit;
0741     }
0742 
0743     if ((unsigned long) skb->data & (BTSDIO_DMA_ALIGN - 1)) {
0744         skb_put(skb, (unsigned long) skb->data &
0745                     (BTSDIO_DMA_ALIGN - 1));
0746         skb_pull(skb, (unsigned long) skb->data &
0747                     (BTSDIO_DMA_ALIGN - 1));
0748     }
0749 
0750     payload = skb->data;
0751 
0752     ret = sdio_readsb(card->func, payload, card->ioport,
0753               num_blocks * blksz);
0754     if (ret < 0) {
0755         BT_ERR("readsb failed: %d", ret);
0756         ret = -EIO;
0757         goto exit;
0758     }
0759 
0760     /* This is SDIO specific header length: byte[2][1][0], type: byte[3]
0761      * (HCI_COMMAND = 1, ACL_DATA = 2, SCO_DATA = 3, 0xFE = Vendor)
0762      */
0763 
0764     buf_len = payload[0];
0765     buf_len |= payload[1] << 8;
0766     buf_len |= payload[2] << 16;
0767 
0768     if (buf_len > blksz * num_blocks) {
0769         BT_ERR("Skip incorrect packet: hdrlen %d buffer %d",
0770                buf_len, blksz * num_blocks);
0771         ret = -EIO;
0772         goto exit;
0773     }
0774 
0775     type = payload[3];
0776 
0777     switch (type) {
0778     case HCI_ACLDATA_PKT:
0779     case HCI_SCODATA_PKT:
0780     case HCI_EVENT_PKT:
0781         hci_skb_pkt_type(skb) = type;
0782         skb_put(skb, buf_len);
0783         skb_pull(skb, SDIO_HEADER_LEN);
0784 
0785         if (type == HCI_EVENT_PKT) {
0786             if (btmrvl_check_evtpkt(priv, skb))
0787                 hci_recv_frame(hdev, skb);
0788         } else {
0789             hci_recv_frame(hdev, skb);
0790         }
0791 
0792         hdev->stat.byte_rx += buf_len;
0793         break;
0794 
0795     case MRVL_VENDOR_PKT:
0796         hci_skb_pkt_type(skb) = HCI_VENDOR_PKT;
0797         skb_put(skb, buf_len);
0798         skb_pull(skb, SDIO_HEADER_LEN);
0799 
0800         if (btmrvl_process_event(priv, skb))
0801             hci_recv_frame(hdev, skb);
0802 
0803         hdev->stat.byte_rx += buf_len;
0804         break;
0805 
0806     default:
0807         BT_ERR("Unknown packet type:%d", type);
0808         BT_ERR("hex: %*ph", blksz * num_blocks, payload);
0809 
0810         kfree_skb(skb);
0811         skb = NULL;
0812         break;
0813     }
0814 
0815 exit:
0816     if (ret) {
0817         hdev->stat.err_rx++;
0818         kfree_skb(skb);
0819     }
0820 
0821     return ret;
0822 }
0823 
0824 static int btmrvl_sdio_process_int_status(struct btmrvl_private *priv)
0825 {
0826     ulong flags;
0827     u8 ireg;
0828     struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
0829 
0830     spin_lock_irqsave(&priv->driver_lock, flags);
0831     ireg = sdio_ireg;
0832     sdio_ireg = 0;
0833     spin_unlock_irqrestore(&priv->driver_lock, flags);
0834 
0835     sdio_claim_host(card->func);
0836     if (ireg & DN_LD_HOST_INT_STATUS) {
0837         if (priv->btmrvl_dev.tx_dnld_rdy)
0838             BT_DBG("tx_done already received: "
0839                 " int_status=0x%x", ireg);
0840         else
0841             priv->btmrvl_dev.tx_dnld_rdy = true;
0842     }
0843 
0844     if (ireg & UP_LD_HOST_INT_STATUS)
0845         btmrvl_sdio_card_to_host(priv);
0846 
0847     sdio_release_host(card->func);
0848 
0849     return 0;
0850 }
0851 
0852 static int btmrvl_sdio_read_to_clear(struct btmrvl_sdio_card *card, u8 *ireg)
0853 {
0854     struct btmrvl_adapter *adapter = card->priv->adapter;
0855     int ret;
0856 
0857     ret = sdio_readsb(card->func, adapter->hw_regs, 0, SDIO_BLOCK_SIZE);
0858     if (ret) {
0859         BT_ERR("sdio_readsb: read int hw_regs failed: %d", ret);
0860         return ret;
0861     }
0862 
0863     *ireg = adapter->hw_regs[card->reg->host_intstatus];
0864     BT_DBG("hw_regs[%#x]=%#x", card->reg->host_intstatus, *ireg);
0865 
0866     return 0;
0867 }
0868 
0869 static int btmrvl_sdio_write_to_clear(struct btmrvl_sdio_card *card, u8 *ireg)
0870 {
0871     int ret;
0872 
0873     *ireg = sdio_readb(card->func, card->reg->host_intstatus, &ret);
0874     if (ret) {
0875         BT_ERR("sdio_readb: read int status failed: %d", ret);
0876         return ret;
0877     }
0878 
0879     if (*ireg) {
0880         /*
0881          * DN_LD_HOST_INT_STATUS and/or UP_LD_HOST_INT_STATUS
0882          * Clear the interrupt status register and re-enable the
0883          * interrupt.
0884          */
0885         BT_DBG("int_status = 0x%x", *ireg);
0886 
0887         sdio_writeb(card->func, ~(*ireg) & (DN_LD_HOST_INT_STATUS |
0888                             UP_LD_HOST_INT_STATUS),
0889                 card->reg->host_intstatus, &ret);
0890         if (ret) {
0891             BT_ERR("sdio_writeb: clear int status failed: %d", ret);
0892             return ret;
0893         }
0894     }
0895 
0896     return 0;
0897 }
0898 
0899 static void btmrvl_sdio_interrupt(struct sdio_func *func)
0900 {
0901     struct btmrvl_private *priv;
0902     struct btmrvl_sdio_card *card;
0903     ulong flags;
0904     u8 ireg = 0;
0905     int ret;
0906 
0907     card = sdio_get_drvdata(func);
0908     if (!card || !card->priv) {
0909         BT_ERR("sbi_interrupt(%p) card or priv is NULL, card=%p",
0910                func, card);
0911         return;
0912     }
0913 
0914     priv = card->priv;
0915 
0916     if (priv->surprise_removed)
0917         return;
0918 
0919     if (card->reg->int_read_to_clear)
0920         ret = btmrvl_sdio_read_to_clear(card, &ireg);
0921     else
0922         ret = btmrvl_sdio_write_to_clear(card, &ireg);
0923 
0924     if (ret)
0925         return;
0926 
0927     spin_lock_irqsave(&priv->driver_lock, flags);
0928     sdio_ireg |= ireg;
0929     spin_unlock_irqrestore(&priv->driver_lock, flags);
0930 
0931     btmrvl_interrupt(priv);
0932 }
0933 
0934 static int btmrvl_sdio_register_dev(struct btmrvl_sdio_card *card)
0935 {
0936     struct sdio_func *func;
0937     u8 reg;
0938     int ret;
0939 
0940     if (!card || !card->func) {
0941         BT_ERR("Error: card or function is NULL!");
0942         ret = -EINVAL;
0943         goto failed;
0944     }
0945 
0946     func = card->func;
0947 
0948     sdio_claim_host(func);
0949 
0950     ret = sdio_enable_func(func);
0951     if (ret) {
0952         BT_ERR("sdio_enable_func() failed: ret=%d", ret);
0953         ret = -EIO;
0954         goto release_host;
0955     }
0956 
0957     ret = sdio_claim_irq(func, btmrvl_sdio_interrupt);
0958     if (ret) {
0959         BT_ERR("sdio_claim_irq failed: ret=%d", ret);
0960         ret = -EIO;
0961         goto disable_func;
0962     }
0963 
0964     ret = sdio_set_block_size(card->func, SDIO_BLOCK_SIZE);
0965     if (ret) {
0966         BT_ERR("cannot set SDIO block size");
0967         ret = -EIO;
0968         goto release_irq;
0969     }
0970 
0971     reg = sdio_readb(func, card->reg->io_port_0, &ret);
0972     if (ret < 0) {
0973         ret = -EIO;
0974         goto release_irq;
0975     }
0976 
0977     card->ioport = reg;
0978 
0979     reg = sdio_readb(func, card->reg->io_port_1, &ret);
0980     if (ret < 0) {
0981         ret = -EIO;
0982         goto release_irq;
0983     }
0984 
0985     card->ioport |= (reg << 8);
0986 
0987     reg = sdio_readb(func, card->reg->io_port_2, &ret);
0988     if (ret < 0) {
0989         ret = -EIO;
0990         goto release_irq;
0991     }
0992 
0993     card->ioport |= (reg << 16);
0994 
0995     BT_DBG("SDIO FUNC%d IO port: 0x%x", func->num, card->ioport);
0996 
0997     if (card->reg->int_read_to_clear) {
0998         reg = sdio_readb(func, card->reg->host_int_rsr, &ret);
0999         if (ret < 0) {
1000             ret = -EIO;
1001             goto release_irq;
1002         }
1003         sdio_writeb(func, reg | 0x3f, card->reg->host_int_rsr, &ret);
1004         if (ret < 0) {
1005             ret = -EIO;
1006             goto release_irq;
1007         }
1008 
1009         reg = sdio_readb(func, card->reg->card_misc_cfg, &ret);
1010         if (ret < 0) {
1011             ret = -EIO;
1012             goto release_irq;
1013         }
1014         sdio_writeb(func, reg | 0x10, card->reg->card_misc_cfg, &ret);
1015         if (ret < 0) {
1016             ret = -EIO;
1017             goto release_irq;
1018         }
1019     }
1020 
1021     sdio_set_drvdata(func, card);
1022 
1023     sdio_release_host(func);
1024 
1025     return 0;
1026 
1027 release_irq:
1028     sdio_release_irq(func);
1029 
1030 disable_func:
1031     sdio_disable_func(func);
1032 
1033 release_host:
1034     sdio_release_host(func);
1035 
1036 failed:
1037     return ret;
1038 }
1039 
1040 static int btmrvl_sdio_unregister_dev(struct btmrvl_sdio_card *card)
1041 {
1042     if (card && card->func) {
1043         sdio_claim_host(card->func);
1044         sdio_release_irq(card->func);
1045         sdio_disable_func(card->func);
1046         sdio_release_host(card->func);
1047         sdio_set_drvdata(card->func, NULL);
1048     }
1049 
1050     return 0;
1051 }
1052 
1053 static int btmrvl_sdio_enable_host_int(struct btmrvl_sdio_card *card)
1054 {
1055     int ret;
1056 
1057     if (!card || !card->func)
1058         return -EINVAL;
1059 
1060     sdio_claim_host(card->func);
1061 
1062     ret = btmrvl_sdio_enable_host_int_mask(card, HIM_ENABLE);
1063 
1064     btmrvl_sdio_get_rx_unit(card);
1065 
1066     sdio_release_host(card->func);
1067 
1068     return ret;
1069 }
1070 
1071 static int btmrvl_sdio_disable_host_int(struct btmrvl_sdio_card *card)
1072 {
1073     int ret;
1074 
1075     if (!card || !card->func)
1076         return -EINVAL;
1077 
1078     sdio_claim_host(card->func);
1079 
1080     ret = btmrvl_sdio_disable_host_int_mask(card, HIM_DISABLE);
1081 
1082     sdio_release_host(card->func);
1083 
1084     return ret;
1085 }
1086 
1087 static int btmrvl_sdio_host_to_card(struct btmrvl_private *priv,
1088                 u8 *payload, u16 nb)
1089 {
1090     struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
1091     int ret = 0;
1092     int blksz;
1093     int i = 0;
1094     u8 *buf = NULL;
1095     void *tmpbuf = NULL;
1096     int tmpbufsz;
1097 
1098     if (!card || !card->func) {
1099         BT_ERR("card or function is NULL!");
1100         return -EINVAL;
1101     }
1102 
1103     blksz = DIV_ROUND_UP(nb, SDIO_BLOCK_SIZE) * SDIO_BLOCK_SIZE;
1104 
1105     buf = payload;
1106     if ((unsigned long) payload & (BTSDIO_DMA_ALIGN - 1) ||
1107         nb < blksz) {
1108         tmpbufsz = ALIGN_SZ(blksz, BTSDIO_DMA_ALIGN) +
1109                BTSDIO_DMA_ALIGN;
1110         tmpbuf = kzalloc(tmpbufsz, GFP_KERNEL);
1111         if (!tmpbuf)
1112             return -ENOMEM;
1113         buf = (u8 *) ALIGN_ADDR(tmpbuf, BTSDIO_DMA_ALIGN);
1114         memcpy(buf, payload, nb);
1115     }
1116 
1117     sdio_claim_host(card->func);
1118 
1119     do {
1120         /* Transfer data to card */
1121         ret = sdio_writesb(card->func, card->ioport, buf,
1122                    blksz);
1123         if (ret < 0) {
1124             i++;
1125             BT_ERR("i=%d writesb failed: %d", i, ret);
1126             BT_ERR("hex: %*ph", nb, payload);
1127             ret = -EIO;
1128             if (i > MAX_WRITE_IOMEM_RETRY)
1129                 goto exit;
1130         }
1131     } while (ret);
1132 
1133     priv->btmrvl_dev.tx_dnld_rdy = false;
1134 
1135 exit:
1136     sdio_release_host(card->func);
1137     kfree(tmpbuf);
1138 
1139     return ret;
1140 }
1141 
1142 static int btmrvl_sdio_download_fw(struct btmrvl_sdio_card *card)
1143 {
1144     int ret;
1145     u8 fws0;
1146     int pollnum = MAX_POLL_TRIES;
1147 
1148     if (!card || !card->func) {
1149         BT_ERR("card or function is NULL!");
1150         return -EINVAL;
1151     }
1152 
1153     if (!btmrvl_sdio_verify_fw_download(card, 1)) {
1154         BT_DBG("Firmware already downloaded!");
1155         return 0;
1156     }
1157 
1158     sdio_claim_host(card->func);
1159 
1160     /* Check if other function driver is downloading the firmware */
1161     fws0 = sdio_readb(card->func, card->reg->card_fw_status0, &ret);
1162     if (ret) {
1163         BT_ERR("Failed to read FW downloading status!");
1164         ret = -EIO;
1165         goto done;
1166     }
1167     if (fws0) {
1168         BT_DBG("BT not the winner (%#x). Skip FW downloading", fws0);
1169 
1170         /* Give other function more time to download the firmware */
1171         pollnum *= 10;
1172     } else {
1173         if (card->helper) {
1174             ret = btmrvl_sdio_download_helper(card);
1175             if (ret) {
1176                 BT_ERR("Failed to download helper!");
1177                 ret = -EIO;
1178                 goto done;
1179             }
1180         }
1181 
1182         if (btmrvl_sdio_download_fw_w_helper(card)) {
1183             BT_ERR("Failed to download firmware!");
1184             ret = -EIO;
1185             goto done;
1186         }
1187     }
1188 
1189     /*
1190      * winner or not, with this test the FW synchronizes when the
1191      * module can continue its initialization
1192      */
1193     if (btmrvl_sdio_verify_fw_download(card, pollnum)) {
1194         BT_ERR("FW failed to be active in time!");
1195         ret = -ETIMEDOUT;
1196         goto done;
1197     }
1198 
1199     sdio_release_host(card->func);
1200 
1201     return 0;
1202 
1203 done:
1204     sdio_release_host(card->func);
1205     return ret;
1206 }
1207 
1208 static int btmrvl_sdio_wakeup_fw(struct btmrvl_private *priv)
1209 {
1210     struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
1211     int ret = 0;
1212 
1213     if (!card || !card->func) {
1214         BT_ERR("card or function is NULL!");
1215         return -EINVAL;
1216     }
1217 
1218     sdio_claim_host(card->func);
1219 
1220     sdio_writeb(card->func, HOST_POWER_UP, card->reg->cfg, &ret);
1221 
1222     sdio_release_host(card->func);
1223 
1224     BT_DBG("wake up firmware");
1225 
1226     return ret;
1227 }
1228 
1229 static void btmrvl_sdio_dump_regs(struct btmrvl_private *priv)
1230 {
1231     struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
1232     int ret = 0;
1233     unsigned int reg, reg_start, reg_end;
1234     char buf[256], *ptr;
1235     u8 loop, func, data;
1236     int MAX_LOOP = 2;
1237 
1238     btmrvl_sdio_wakeup_fw(priv);
1239     sdio_claim_host(card->func);
1240 
1241     for (loop = 0; loop < MAX_LOOP; loop++) {
1242         memset(buf, 0, sizeof(buf));
1243         ptr = buf;
1244 
1245         if (loop == 0) {
1246             /* Read the registers of SDIO function0 */
1247             func = loop;
1248             reg_start = 0;
1249             reg_end = 9;
1250         } else {
1251             func = 2;
1252             reg_start = 0;
1253             reg_end = 0x09;
1254         }
1255 
1256         ptr += sprintf(ptr, "SDIO Func%d (%#x-%#x): ",
1257                    func, reg_start, reg_end);
1258         for (reg = reg_start; reg <= reg_end; reg++) {
1259             if (func == 0)
1260                 data = sdio_f0_readb(card->func, reg, &ret);
1261             else
1262                 data = sdio_readb(card->func, reg, &ret);
1263 
1264             if (!ret) {
1265                 ptr += sprintf(ptr, "%02x ", data);
1266             } else {
1267                 ptr += sprintf(ptr, "ERR");
1268                 break;
1269             }
1270         }
1271 
1272         BT_INFO("%s", buf);
1273     }
1274 
1275     sdio_release_host(card->func);
1276 }
1277 
1278 /* This function read/write firmware */
1279 static enum
1280 rdwr_status btmrvl_sdio_rdwr_firmware(struct btmrvl_private *priv,
1281                       u8 doneflag)
1282 {
1283     struct btmrvl_sdio_card *card = priv->btmrvl_dev.card;
1284     int ret, tries;
1285     u8 ctrl_data = 0;
1286 
1287     sdio_writeb(card->func, FW_DUMP_HOST_READY, card->reg->fw_dump_ctrl,
1288             &ret);
1289 
1290     if (ret) {
1291         BT_ERR("SDIO write err");
1292         return RDWR_STATUS_FAILURE;
1293     }
1294 
1295     for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
1296         ctrl_data = sdio_readb(card->func, card->reg->fw_dump_ctrl,
1297                        &ret);
1298 
1299         if (ret) {
1300             BT_ERR("SDIO read err");
1301             return RDWR_STATUS_FAILURE;
1302         }
1303 
1304         if (ctrl_data == FW_DUMP_DONE)
1305             break;
1306         if (doneflag && ctrl_data == doneflag)
1307             return RDWR_STATUS_DONE;
1308         if (ctrl_data != FW_DUMP_HOST_READY) {
1309             BT_INFO("The ctrl reg was changed, re-try again!");
1310             sdio_writeb(card->func, FW_DUMP_HOST_READY,
1311                     card->reg->fw_dump_ctrl, &ret);
1312             if (ret) {
1313                 BT_ERR("SDIO write err");
1314                 return RDWR_STATUS_FAILURE;
1315             }
1316         }
1317         usleep_range(100, 200);
1318     }
1319 
1320     if (ctrl_data == FW_DUMP_HOST_READY) {
1321         BT_ERR("Fail to pull ctrl_data");
1322         return RDWR_STATUS_FAILURE;
1323     }
1324 
1325     return RDWR_STATUS_SUCCESS;
1326 }
1327 
1328 /* This function dump sdio register and memory data */
1329 static void btmrvl_sdio_coredump(struct device *dev)
1330 {
1331     struct sdio_func *func = dev_to_sdio_func(dev);
1332     struct btmrvl_sdio_card *card;
1333     struct btmrvl_private *priv;
1334     int ret = 0;
1335     unsigned int reg, reg_start, reg_end;
1336     enum rdwr_status stat;
1337     u8 *dbg_ptr, *end_ptr, *fw_dump_data, *fw_dump_ptr;
1338     u8 dump_num = 0, idx, i, read_reg, doneflag = 0;
1339     u32 memory_size, fw_dump_len = 0;
1340     int size = 0;
1341 
1342     card = sdio_get_drvdata(func);
1343     priv = card->priv;
1344 
1345     /* dump sdio register first */
1346     btmrvl_sdio_dump_regs(priv);
1347 
1348     if (!card->supports_fw_dump) {
1349         BT_ERR("Firmware dump not supported for this card!");
1350         return;
1351     }
1352 
1353     for (idx = 0; idx < ARRAY_SIZE(mem_type_mapping_tbl); idx++) {
1354         struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx];
1355 
1356         if (entry->mem_ptr) {
1357             vfree(entry->mem_ptr);
1358             entry->mem_ptr = NULL;
1359         }
1360         entry->mem_size = 0;
1361     }
1362 
1363     btmrvl_sdio_wakeup_fw(priv);
1364     sdio_claim_host(card->func);
1365 
1366     BT_INFO("== btmrvl firmware dump start ==");
1367 
1368     stat = btmrvl_sdio_rdwr_firmware(priv, doneflag);
1369     if (stat == RDWR_STATUS_FAILURE)
1370         goto done;
1371 
1372     reg = card->reg->fw_dump_start;
1373     /* Read the number of the memories which will dump */
1374     dump_num = sdio_readb(card->func, reg, &ret);
1375 
1376     if (ret) {
1377         BT_ERR("SDIO read memory length err");
1378         goto done;
1379     }
1380 
1381     /* Read the length of every memory which will dump */
1382     for (idx = 0; idx < dump_num; idx++) {
1383         struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx];
1384 
1385         stat = btmrvl_sdio_rdwr_firmware(priv, doneflag);
1386         if (stat == RDWR_STATUS_FAILURE)
1387             goto done;
1388 
1389         memory_size = 0;
1390         reg = card->reg->fw_dump_start;
1391         for (i = 0; i < 4; i++) {
1392             read_reg = sdio_readb(card->func, reg, &ret);
1393             if (ret) {
1394                 BT_ERR("SDIO read err");
1395                 goto done;
1396             }
1397             memory_size |= (read_reg << i*8);
1398             reg++;
1399         }
1400 
1401         if (memory_size == 0) {
1402             BT_INFO("Firmware dump finished!");
1403             sdio_writeb(card->func, FW_DUMP_READ_DONE,
1404                     card->reg->fw_dump_ctrl, &ret);
1405             if (ret) {
1406                 BT_ERR("SDIO Write MEMDUMP_FINISH ERR");
1407                 goto done;
1408             }
1409             break;
1410         }
1411 
1412         BT_INFO("%s_SIZE=0x%x", entry->mem_name, memory_size);
1413         entry->mem_ptr = vzalloc(memory_size + 1);
1414         entry->mem_size = memory_size;
1415         if (!entry->mem_ptr) {
1416             BT_ERR("Vzalloc %s failed", entry->mem_name);
1417             goto done;
1418         }
1419 
1420         fw_dump_len += (strlen("========Start dump ") +
1421                 strlen(entry->mem_name) +
1422                 strlen("========\n") +
1423                 (memory_size + 1) +
1424                 strlen("\n========End dump========\n"));
1425 
1426         dbg_ptr = entry->mem_ptr;
1427         end_ptr = dbg_ptr + memory_size;
1428 
1429         doneflag = entry->done_flag;
1430         BT_INFO("Start %s output, please wait...",
1431             entry->mem_name);
1432 
1433         do {
1434             stat = btmrvl_sdio_rdwr_firmware(priv, doneflag);
1435             if (stat == RDWR_STATUS_FAILURE)
1436                 goto done;
1437 
1438             reg_start = card->reg->fw_dump_start;
1439             reg_end = card->reg->fw_dump_end;
1440             for (reg = reg_start; reg <= reg_end; reg++) {
1441                 *dbg_ptr = sdio_readb(card->func, reg, &ret);
1442                 if (ret) {
1443                     BT_ERR("SDIO read err");
1444                     goto done;
1445                 }
1446                 if (dbg_ptr < end_ptr)
1447                     dbg_ptr++;
1448                 else
1449                     BT_ERR("Allocated buffer not enough");
1450             }
1451 
1452             if (stat == RDWR_STATUS_DONE) {
1453                 BT_INFO("%s done: size=0x%tx",
1454                     entry->mem_name,
1455                     dbg_ptr - entry->mem_ptr);
1456                 break;
1457             }
1458         } while (1);
1459     }
1460 
1461     BT_INFO("== btmrvl firmware dump end ==");
1462 
1463 done:
1464     sdio_release_host(card->func);
1465 
1466     if (fw_dump_len == 0)
1467         return;
1468 
1469     fw_dump_data = vzalloc(fw_dump_len + 1);
1470     if (!fw_dump_data) {
1471         BT_ERR("Vzalloc fw_dump_data fail!");
1472         return;
1473     }
1474     fw_dump_ptr = fw_dump_data;
1475 
1476     /* Dump all the memory data into single file, a userspace script will
1477      * be used to split all the memory data to multiple files
1478      */
1479     BT_INFO("== btmrvl firmware dump to /sys/class/devcoredump start");
1480     for (idx = 0; idx < dump_num; idx++) {
1481         struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx];
1482 
1483         if (entry->mem_ptr) {
1484             size += scnprintf(fw_dump_ptr + size,
1485                       fw_dump_len + 1 - size,
1486                       "========Start dump %s========\n",
1487                       entry->mem_name);
1488 
1489             memcpy(fw_dump_ptr + size, entry->mem_ptr,
1490                    entry->mem_size);
1491             size += entry->mem_size;
1492 
1493             size += scnprintf(fw_dump_ptr + size,
1494                       fw_dump_len + 1 - size,
1495                       "\n========End dump========\n");
1496 
1497             vfree(mem_type_mapping_tbl[idx].mem_ptr);
1498             mem_type_mapping_tbl[idx].mem_ptr = NULL;
1499         }
1500     }
1501 
1502     /* fw_dump_data will be free in device coredump release function
1503      * after 5 min
1504      */
1505     dev_coredumpv(&card->func->dev, fw_dump_data, fw_dump_len, GFP_KERNEL);
1506     BT_INFO("== btmrvl firmware dump to /sys/class/devcoredump end");
1507 }
1508 
1509 static int btmrvl_sdio_probe(struct sdio_func *func,
1510                     const struct sdio_device_id *id)
1511 {
1512     int ret = 0;
1513     struct btmrvl_private *priv = NULL;
1514     struct btmrvl_sdio_card *card = NULL;
1515 
1516     BT_INFO("vendor=0x%x, device=0x%x, class=%d, fn=%d",
1517             id->vendor, id->device, id->class, func->num);
1518 
1519     card = devm_kzalloc(&func->dev, sizeof(*card), GFP_KERNEL);
1520     if (!card)
1521         return -ENOMEM;
1522 
1523     card->func = func;
1524 
1525     if (id->driver_data) {
1526         struct btmrvl_sdio_device *data = (void *) id->driver_data;
1527         card->helper = data->helper;
1528         card->firmware = data->firmware;
1529         card->reg = data->reg;
1530         card->sd_blksz_fw_dl = data->sd_blksz_fw_dl;
1531         card->support_pscan_win_report = data->support_pscan_win_report;
1532         card->supports_fw_dump = data->supports_fw_dump;
1533     }
1534 
1535     if (btmrvl_sdio_register_dev(card) < 0) {
1536         BT_ERR("Failed to register BT device!");
1537         return -ENODEV;
1538     }
1539 
1540     /* Disable the interrupts on the card */
1541     btmrvl_sdio_disable_host_int(card);
1542 
1543     if (btmrvl_sdio_download_fw(card)) {
1544         BT_ERR("Downloading firmware failed!");
1545         ret = -ENODEV;
1546         goto unreg_dev;
1547     }
1548 
1549     btmrvl_sdio_enable_host_int(card);
1550 
1551     /* Device tree node parsing and platform specific configuration*/
1552     btmrvl_sdio_probe_of(&func->dev, card);
1553 
1554     priv = btmrvl_add_card(card);
1555     if (!priv) {
1556         BT_ERR("Initializing card failed!");
1557         ret = -ENODEV;
1558         goto disable_host_int;
1559     }
1560 
1561     card->priv = priv;
1562 
1563     /* Initialize the interface specific function pointers */
1564     priv->hw_host_to_card = btmrvl_sdio_host_to_card;
1565     priv->hw_wakeup_firmware = btmrvl_sdio_wakeup_fw;
1566     priv->hw_process_int_status = btmrvl_sdio_process_int_status;
1567 
1568     if (btmrvl_register_hdev(priv)) {
1569         BT_ERR("Register hdev failed!");
1570         ret = -ENODEV;
1571         goto disable_host_int;
1572     }
1573 
1574     return 0;
1575 
1576 disable_host_int:
1577     btmrvl_sdio_disable_host_int(card);
1578 unreg_dev:
1579     btmrvl_sdio_unregister_dev(card);
1580     return ret;
1581 }
1582 
1583 static void btmrvl_sdio_remove(struct sdio_func *func)
1584 {
1585     struct btmrvl_sdio_card *card;
1586 
1587     if (func) {
1588         card = sdio_get_drvdata(func);
1589         if (card) {
1590             /* Send SHUTDOWN command & disable interrupt
1591              * if user removes the module.
1592              */
1593             if (user_rmmod) {
1594                 btmrvl_send_module_cfg_cmd(card->priv,
1595                             MODULE_SHUTDOWN_REQ);
1596                 btmrvl_sdio_disable_host_int(card);
1597             }
1598 
1599             BT_DBG("unregister dev");
1600             card->priv->surprise_removed = true;
1601             btmrvl_sdio_unregister_dev(card);
1602             btmrvl_remove_card(card->priv);
1603         }
1604     }
1605 }
1606 
1607 static int btmrvl_sdio_suspend(struct device *dev)
1608 {
1609     struct sdio_func *func = dev_to_sdio_func(dev);
1610     struct btmrvl_sdio_card *card;
1611     struct btmrvl_private *priv;
1612     mmc_pm_flag_t pm_flags;
1613     struct hci_dev *hcidev;
1614 
1615     if (func) {
1616         pm_flags = sdio_get_host_pm_caps(func);
1617         BT_DBG("%s: suspend: PM flags = 0x%x", sdio_func_id(func),
1618                pm_flags);
1619         if (!(pm_flags & MMC_PM_KEEP_POWER)) {
1620             BT_ERR("%s: cannot remain alive while suspended",
1621                    sdio_func_id(func));
1622             return -ENOSYS;
1623         }
1624         card = sdio_get_drvdata(func);
1625         if (!card || !card->priv) {
1626             BT_ERR("card or priv structure is not valid");
1627             return 0;
1628         }
1629     } else {
1630         BT_ERR("sdio_func is not specified");
1631         return 0;
1632     }
1633 
1634     /* Enable platform specific wakeup interrupt */
1635     if (card->plt_wake_cfg && card->plt_wake_cfg->irq_bt >= 0 &&
1636         device_may_wakeup(dev)) {
1637         card->plt_wake_cfg->wake_by_bt = false;
1638         enable_irq(card->plt_wake_cfg->irq_bt);
1639         enable_irq_wake(card->plt_wake_cfg->irq_bt);
1640     }
1641 
1642     priv = card->priv;
1643     priv->adapter->is_suspending = true;
1644     hcidev = priv->btmrvl_dev.hcidev;
1645     BT_DBG("%s: SDIO suspend", hcidev->name);
1646     hci_suspend_dev(hcidev);
1647 
1648     if (priv->adapter->hs_state != HS_ACTIVATED) {
1649         if (btmrvl_enable_hs(priv)) {
1650             BT_ERR("HS not activated, suspend failed!");
1651             /* Disable platform specific wakeup interrupt */
1652             if (card->plt_wake_cfg &&
1653                 card->plt_wake_cfg->irq_bt >= 0 &&
1654                 device_may_wakeup(dev)) {
1655                 disable_irq_wake(card->plt_wake_cfg->irq_bt);
1656                 disable_irq(card->plt_wake_cfg->irq_bt);
1657             }
1658 
1659             priv->adapter->is_suspending = false;
1660             return -EBUSY;
1661         }
1662     }
1663 
1664     priv->adapter->is_suspending = false;
1665     priv->adapter->is_suspended = true;
1666 
1667     /* We will keep the power when hs enabled successfully */
1668     if (priv->adapter->hs_state == HS_ACTIVATED) {
1669         BT_DBG("suspend with MMC_PM_KEEP_POWER");
1670         return sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
1671     }
1672 
1673     BT_DBG("suspend without MMC_PM_KEEP_POWER");
1674     return 0;
1675 }
1676 
1677 static int btmrvl_sdio_resume(struct device *dev)
1678 {
1679     struct sdio_func *func = dev_to_sdio_func(dev);
1680     struct btmrvl_sdio_card *card;
1681     struct btmrvl_private *priv;
1682     mmc_pm_flag_t pm_flags;
1683     struct hci_dev *hcidev;
1684 
1685     if (func) {
1686         pm_flags = sdio_get_host_pm_caps(func);
1687         BT_DBG("%s: resume: PM flags = 0x%x", sdio_func_id(func),
1688                pm_flags);
1689         card = sdio_get_drvdata(func);
1690         if (!card || !card->priv) {
1691             BT_ERR("card or priv structure is not valid");
1692             return 0;
1693         }
1694     } else {
1695         BT_ERR("sdio_func is not specified");
1696         return 0;
1697     }
1698     priv = card->priv;
1699 
1700     if (!priv->adapter->is_suspended) {
1701         BT_DBG("device already resumed");
1702         return 0;
1703     }
1704 
1705     priv->hw_wakeup_firmware(priv);
1706     priv->adapter->hs_state = HS_DEACTIVATED;
1707     hcidev = priv->btmrvl_dev.hcidev;
1708     BT_DBG("%s: HS DEACTIVATED in resume!", hcidev->name);
1709     priv->adapter->is_suspended = false;
1710     BT_DBG("%s: SDIO resume", hcidev->name);
1711     hci_resume_dev(hcidev);
1712 
1713     /* Disable platform specific wakeup interrupt */
1714     if (card->plt_wake_cfg && card->plt_wake_cfg->irq_bt >= 0 &&
1715         device_may_wakeup(dev)) {
1716         disable_irq_wake(card->plt_wake_cfg->irq_bt);
1717         disable_irq(card->plt_wake_cfg->irq_bt);
1718         if (card->plt_wake_cfg->wake_by_bt)
1719             /* Undo our disable, since interrupt handler already
1720              * did this.
1721              */
1722             enable_irq(card->plt_wake_cfg->irq_bt);
1723     }
1724 
1725     return 0;
1726 }
1727 
1728 static const struct dev_pm_ops btmrvl_sdio_pm_ops = {
1729     .suspend    = btmrvl_sdio_suspend,
1730     .resume     = btmrvl_sdio_resume,
1731 };
1732 
1733 static struct sdio_driver bt_mrvl_sdio = {
1734     .name       = "btmrvl_sdio",
1735     .id_table   = btmrvl_sdio_ids,
1736     .probe      = btmrvl_sdio_probe,
1737     .remove     = btmrvl_sdio_remove,
1738     .drv = {
1739         .owner = THIS_MODULE,
1740         .coredump = btmrvl_sdio_coredump,
1741         .pm = &btmrvl_sdio_pm_ops,
1742     }
1743 };
1744 
1745 static int __init btmrvl_sdio_init_module(void)
1746 {
1747     if (sdio_register_driver(&bt_mrvl_sdio) != 0) {
1748         BT_ERR("SDIO Driver Registration Failed");
1749         return -ENODEV;
1750     }
1751 
1752     /* Clear the flag in case user removes the card. */
1753     user_rmmod = 0;
1754 
1755     return 0;
1756 }
1757 
1758 static void __exit btmrvl_sdio_exit_module(void)
1759 {
1760     /* Set the flag as user is removing this module. */
1761     user_rmmod = 1;
1762 
1763     sdio_unregister_driver(&bt_mrvl_sdio);
1764 }
1765 
1766 module_init(btmrvl_sdio_init_module);
1767 module_exit(btmrvl_sdio_exit_module);
1768 
1769 MODULE_AUTHOR("Marvell International Ltd.");
1770 MODULE_DESCRIPTION("Marvell BT-over-SDIO driver ver " VERSION);
1771 MODULE_VERSION(VERSION);
1772 MODULE_LICENSE("GPL v2");
1773 MODULE_FIRMWARE("mrvl/sd8688_helper.bin");
1774 MODULE_FIRMWARE("mrvl/sd8688.bin");
1775 MODULE_FIRMWARE("mrvl/sd8787_uapsta.bin");
1776 MODULE_FIRMWARE("mrvl/sd8797_uapsta.bin");
1777 MODULE_FIRMWARE("mrvl/sd8887_uapsta.bin");
1778 MODULE_FIRMWARE("mrvl/sd8897_uapsta.bin");
1779 MODULE_FIRMWARE("mrvl/sdsd8977_combo_v2.bin");
1780 MODULE_FIRMWARE("mrvl/sd8987_uapsta.bin");
1781 MODULE_FIRMWARE("mrvl/sdsd8997_combo_v4.bin");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!