Back to home page

OSCL-LXR
 
 

     

0001 /*
0002  * Copyright (c) 2014 Redpine Signals Inc.
0003  *
0004  * Permission to use, copy, modify, and/or distribute this software for any
0005  * purpose with or without fee is hereby granted, provided that the above
0006  * copyright notice and this permission notice appear in all copies.
0007  *
0008  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
0009  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
0010  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
0011  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
0012  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
0013  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
0014  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
0015  *
0016  */
0017 
0018 #include <linux/module.h>
0019 #include "rsi_sdio.h"
0020 #include "rsi_common.h"
0021 #include "rsi_coex.h"
0022 #include "rsi_hal.h"
0023 
0024 /* Default operating mode is wlan STA + BT */
0025 static u16 dev_oper_mode = DEV_OPMODE_STA_BT_DUAL;
0026 module_param(dev_oper_mode, ushort, 0444);
0027 MODULE_PARM_DESC(dev_oper_mode, DEV_OPMODE_PARAM_DESC);
0028 
0029 /**
0030  * rsi_sdio_set_cmd52_arg() - This function prepares cmd 52 read/write arg.
0031  * @rw: Read/write
0032  * @func: function number
0033  * @raw: indicates whether to perform read after write
0034  * @address: address to which to read/write
0035  * @writedata: data to write
0036  *
0037  * Return: argument
0038  */
0039 static u32 rsi_sdio_set_cmd52_arg(bool rw,
0040                   u8 func,
0041                   u8 raw,
0042                   u32 address,
0043                   u8 writedata)
0044 {
0045     return ((rw & 1) << 31) | ((func & 0x7) << 28) |
0046         ((raw & 1) << 27) | (1 << 26) |
0047         ((address & 0x1FFFF) << 9) | (1 << 8) |
0048         (writedata & 0xFF);
0049 }
0050 
0051 /**
0052  * rsi_cmd52writebyte() - This function issues cmd52 byte write onto the card.
0053  * @card: Pointer to the mmc_card.
0054  * @address: Address to write.
0055  * @byte: Data to write.
0056  *
0057  * Return: Write status.
0058  */
0059 static int rsi_cmd52writebyte(struct mmc_card *card,
0060                   u32 address,
0061                   u8 byte)
0062 {
0063     struct mmc_command io_cmd;
0064     u32 arg;
0065 
0066     memset(&io_cmd, 0, sizeof(io_cmd));
0067     arg = rsi_sdio_set_cmd52_arg(1, 0, 0, address, byte);
0068     io_cmd.opcode = SD_IO_RW_DIRECT;
0069     io_cmd.arg = arg;
0070     io_cmd.flags = MMC_RSP_R5 | MMC_CMD_AC;
0071 
0072     return mmc_wait_for_cmd(card->host, &io_cmd, 0);
0073 }
0074 
0075 /**
0076  * rsi_cmd52readbyte() - This function issues cmd52 byte read onto the card.
0077  * @card: Pointer to the mmc_card.
0078  * @address: Address to read from.
0079  * @byte: Variable to store read value.
0080  *
0081  * Return: Read status.
0082  */
0083 static int rsi_cmd52readbyte(struct mmc_card *card,
0084                  u32 address,
0085                  u8 *byte)
0086 {
0087     struct mmc_command io_cmd;
0088     u32 arg;
0089     int err;
0090 
0091     memset(&io_cmd, 0, sizeof(io_cmd));
0092     arg = rsi_sdio_set_cmd52_arg(0, 0, 0, address, 0);
0093     io_cmd.opcode = SD_IO_RW_DIRECT;
0094     io_cmd.arg = arg;
0095     io_cmd.flags = MMC_RSP_R5 | MMC_CMD_AC;
0096 
0097     err = mmc_wait_for_cmd(card->host, &io_cmd, 0);
0098     if ((!err) && (byte))
0099         *byte =  io_cmd.resp[0] & 0xFF;
0100     return err;
0101 }
0102 
0103 /**
0104  * rsi_issue_sdiocommand() - This function issues sdio commands.
0105  * @func: Pointer to the sdio_func structure.
0106  * @opcode: Opcode value.
0107  * @arg: Arguments to pass.
0108  * @flags: Flags which are set.
0109  * @resp: Pointer to store response.
0110  *
0111  * Return: err: command status as 0 or -1.
0112  */
0113 static int rsi_issue_sdiocommand(struct sdio_func *func,
0114                  u32 opcode,
0115                  u32 arg,
0116                  u32 flags,
0117                  u32 *resp)
0118 {
0119     struct mmc_command cmd;
0120     struct mmc_host *host;
0121     int err;
0122 
0123     host = func->card->host;
0124 
0125     memset(&cmd, 0, sizeof(struct mmc_command));
0126     cmd.opcode = opcode;
0127     cmd.arg = arg;
0128     cmd.flags = flags;
0129     err = mmc_wait_for_cmd(host, &cmd, 3);
0130 
0131     if ((!err) && (resp))
0132         *resp = cmd.resp[0];
0133 
0134     return err;
0135 }
0136 
0137 /**
0138  * rsi_handle_interrupt() - This function is called upon the occurrence
0139  *              of an interrupt.
0140  * @function: Pointer to the sdio_func structure.
0141  *
0142  * Return: None.
0143  */
0144 static void rsi_handle_interrupt(struct sdio_func *function)
0145 {
0146     struct rsi_hw *adapter = sdio_get_drvdata(function);
0147     struct rsi_91x_sdiodev *dev =
0148         (struct rsi_91x_sdiodev *)adapter->rsi_dev;
0149 
0150     if (adapter->priv->fsm_state == FSM_FW_NOT_LOADED)
0151         return;
0152 
0153     rsi_set_event(&dev->rx_thread.event);
0154 }
0155 
0156 /**
0157  * rsi_reset_card() - This function resets and re-initializes the card.
0158  * @pfunction: Pointer to the sdio_func structure.
0159  *
0160  * Return: None.
0161  */
0162 static void rsi_reset_card(struct sdio_func *pfunction)
0163 {
0164     int ret = 0;
0165     int err;
0166     struct mmc_card *card = pfunction->card;
0167     struct mmc_host *host = card->host;
0168     u8 cmd52_resp;
0169     u32 clock, resp, i;
0170     u16 rca;
0171 
0172     /* Reset 9110 chip */
0173     ret = rsi_cmd52writebyte(pfunction->card,
0174                  SDIO_CCCR_ABORT,
0175                  (1 << 3));
0176 
0177     /* Card will not send any response as it is getting reset immediately
0178      * Hence expect a timeout status from host controller
0179      */
0180     if (ret != -ETIMEDOUT)
0181         rsi_dbg(ERR_ZONE, "%s: Reset failed : %d\n", __func__, ret);
0182 
0183     /* Wait for few milli seconds to get rid of residue charges if any */
0184     msleep(20);
0185 
0186     /* Initialize the SDIO card */
0187     host->ios.chip_select = MMC_CS_DONTCARE;
0188     host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
0189     host->ios.power_mode = MMC_POWER_UP;
0190     host->ios.bus_width = MMC_BUS_WIDTH_1;
0191     host->ios.timing = MMC_TIMING_LEGACY;
0192     host->ops->set_ios(host, &host->ios);
0193 
0194     /*
0195      * This delay should be sufficient to allow the power supply
0196      * to reach the minimum voltage.
0197      */
0198     msleep(20);
0199 
0200     host->ios.clock = host->f_min;
0201     host->ios.power_mode = MMC_POWER_ON;
0202     host->ops->set_ios(host, &host->ios);
0203 
0204     /*
0205      * This delay must be at least 74 clock sizes, or 1 ms, or the
0206      * time required to reach a stable voltage.
0207      */
0208     msleep(20);
0209 
0210     /* Issue CMD0. Goto idle state */
0211     host->ios.chip_select = MMC_CS_HIGH;
0212     host->ops->set_ios(host, &host->ios);
0213     msleep(20);
0214     err = rsi_issue_sdiocommand(pfunction,
0215                     MMC_GO_IDLE_STATE,
0216                     0,
0217                     (MMC_RSP_NONE | MMC_CMD_BC),
0218                     NULL);
0219     host->ios.chip_select = MMC_CS_DONTCARE;
0220     host->ops->set_ios(host, &host->ios);
0221     msleep(20);
0222     host->use_spi_crc = 0;
0223 
0224     if (err)
0225         rsi_dbg(ERR_ZONE, "%s: CMD0 failed : %d\n", __func__, err);
0226 
0227     /* Issue CMD5, arg = 0 */
0228     err = rsi_issue_sdiocommand(pfunction,  SD_IO_SEND_OP_COND, 0,
0229                     (MMC_RSP_R4 | MMC_CMD_BCR), &resp);
0230     if (err)
0231         rsi_dbg(ERR_ZONE, "%s: CMD5 failed : %d\n",
0232             __func__, err);
0233     card->ocr = resp;
0234     /* Issue CMD5, arg = ocr. Wait till card is ready  */
0235     for (i = 0; i < 100; i++) {
0236         err = rsi_issue_sdiocommand(pfunction, SD_IO_SEND_OP_COND,
0237                         card->ocr,
0238                         (MMC_RSP_R4 | MMC_CMD_BCR), &resp);
0239         if (err) {
0240             rsi_dbg(ERR_ZONE, "%s: CMD5 failed : %d\n",
0241                 __func__, err);
0242             break;
0243         }
0244 
0245         if (resp & MMC_CARD_BUSY)
0246             break;
0247         msleep(20);
0248     }
0249 
0250     if ((i == 100) || (err)) {
0251         rsi_dbg(ERR_ZONE, "%s: card in not ready : %d %d\n",
0252             __func__, i, err);
0253         return;
0254     }
0255 
0256     /* Issue CMD3, get RCA */
0257     err = rsi_issue_sdiocommand(pfunction,
0258                     SD_SEND_RELATIVE_ADDR,
0259                     0,
0260                     (MMC_RSP_R6 | MMC_CMD_BCR),
0261                     &resp);
0262     if (err) {
0263         rsi_dbg(ERR_ZONE, "%s: CMD3 failed : %d\n", __func__, err);
0264         return;
0265     }
0266     rca = resp >> 16;
0267     host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
0268     host->ops->set_ios(host, &host->ios);
0269 
0270     /* Issue CMD7, select card  */
0271     err = rsi_issue_sdiocommand(pfunction,
0272                     MMC_SELECT_CARD,
0273                     (rca << 16),
0274                     (MMC_RSP_R1 | MMC_CMD_AC),
0275                     NULL);
0276     if (err) {
0277         rsi_dbg(ERR_ZONE, "%s: CMD7 failed : %d\n", __func__, err);
0278         return;
0279     }
0280 
0281     /* Enable high speed */
0282     if (card->host->caps & MMC_CAP_SD_HIGHSPEED) {
0283         rsi_dbg(ERR_ZONE, "%s: Set high speed mode\n", __func__);
0284         err = rsi_cmd52readbyte(card, SDIO_CCCR_SPEED, &cmd52_resp);
0285         if (err) {
0286             rsi_dbg(ERR_ZONE, "%s: CCCR speed reg read failed: %d\n",
0287                 __func__, err);
0288         } else {
0289             err = rsi_cmd52writebyte(card,
0290                          SDIO_CCCR_SPEED,
0291                          (cmd52_resp | SDIO_SPEED_EHS));
0292             if (err) {
0293                 rsi_dbg(ERR_ZONE,
0294                     "%s: CCR speed regwrite failed %d\n",
0295                     __func__, err);
0296                 return;
0297             }
0298             host->ios.timing = MMC_TIMING_SD_HS;
0299             host->ops->set_ios(host, &host->ios);
0300         }
0301     }
0302 
0303     /* Set clock */
0304     if (mmc_card_hs(card))
0305         clock = 50000000;
0306     else
0307         clock = card->cis.max_dtr;
0308 
0309     if (clock > host->f_max)
0310         clock = host->f_max;
0311 
0312     host->ios.clock = clock;
0313     host->ops->set_ios(host, &host->ios);
0314 
0315     if (card->host->caps & MMC_CAP_4_BIT_DATA) {
0316         /* CMD52: Set bus width & disable card detect resistor */
0317         err = rsi_cmd52writebyte(card,
0318                      SDIO_CCCR_IF,
0319                      (SDIO_BUS_CD_DISABLE |
0320                       SDIO_BUS_WIDTH_4BIT));
0321         if (err) {
0322             rsi_dbg(ERR_ZONE, "%s: Set bus mode failed : %d\n",
0323                 __func__, err);
0324             return;
0325         }
0326         host->ios.bus_width = MMC_BUS_WIDTH_4;
0327         host->ops->set_ios(host, &host->ios);
0328     }
0329 }
0330 
0331 /**
0332  * rsi_setclock() - This function sets the clock frequency.
0333  * @adapter: Pointer to the adapter structure.
0334  * @freq: Clock frequency.
0335  *
0336  * Return: None.
0337  */
0338 static void rsi_setclock(struct rsi_hw *adapter, u32 freq)
0339 {
0340     struct rsi_91x_sdiodev *dev =
0341         (struct rsi_91x_sdiodev *)adapter->rsi_dev;
0342     struct mmc_host *host = dev->pfunction->card->host;
0343     u32 clock;
0344 
0345     clock = freq * 1000;
0346     if (clock > host->f_max)
0347         clock = host->f_max;
0348     host->ios.clock = clock;
0349     host->ops->set_ios(host, &host->ios);
0350 }
0351 
0352 /**
0353  * rsi_setblocklength() - This function sets the host block length.
0354  * @adapter: Pointer to the adapter structure.
0355  * @length: Block length to be set.
0356  *
0357  * Return: status: 0 on success, -1 on failure.
0358  */
0359 static int rsi_setblocklength(struct rsi_hw *adapter, u32 length)
0360 {
0361     struct rsi_91x_sdiodev *dev =
0362         (struct rsi_91x_sdiodev *)adapter->rsi_dev;
0363     int status;
0364     rsi_dbg(INIT_ZONE, "%s: Setting the block length\n", __func__);
0365 
0366     status = sdio_set_block_size(dev->pfunction, length);
0367     dev->pfunction->max_blksize = 256;
0368     adapter->block_size = dev->pfunction->max_blksize;
0369 
0370     rsi_dbg(INFO_ZONE,
0371         "%s: Operational blk length is %d\n", __func__, length);
0372     return status;
0373 }
0374 
0375 /**
0376  * rsi_setupcard() - This function queries and sets the card's features.
0377  * @adapter: Pointer to the adapter structure.
0378  *
0379  * Return: status: 0 on success, -1 on failure.
0380  */
0381 static int rsi_setupcard(struct rsi_hw *adapter)
0382 {
0383     struct rsi_91x_sdiodev *dev =
0384         (struct rsi_91x_sdiodev *)adapter->rsi_dev;
0385     int status = 0;
0386 
0387     rsi_setclock(adapter, 50000);
0388 
0389     dev->tx_blk_size = 256;
0390     status = rsi_setblocklength(adapter, dev->tx_blk_size);
0391     if (status)
0392         rsi_dbg(ERR_ZONE,
0393             "%s: Unable to set block length\n", __func__);
0394     return status;
0395 }
0396 
0397 /**
0398  * rsi_sdio_read_register() - This function reads one byte of information
0399  *                from a register.
0400  * @adapter: Pointer to the adapter structure.
0401  * @addr: Address of the register.
0402  * @data: Pointer to the data that stores the data read.
0403  *
0404  * Return: 0 on success, -1 on failure.
0405  */
0406 int rsi_sdio_read_register(struct rsi_hw *adapter,
0407                u32 addr,
0408                u8 *data)
0409 {
0410     struct rsi_91x_sdiodev *dev =
0411         (struct rsi_91x_sdiodev *)adapter->rsi_dev;
0412     u8 fun_num = 0;
0413     int status;
0414 
0415     if (likely(dev->sdio_irq_task != current))
0416         sdio_claim_host(dev->pfunction);
0417 
0418     if (fun_num == 0)
0419         *data = sdio_f0_readb(dev->pfunction, addr, &status);
0420     else
0421         *data = sdio_readb(dev->pfunction, addr, &status);
0422 
0423     if (likely(dev->sdio_irq_task != current))
0424         sdio_release_host(dev->pfunction);
0425 
0426     return status;
0427 }
0428 
0429 /**
0430  * rsi_sdio_write_register() - This function writes one byte of information
0431  *                 into a register.
0432  * @adapter: Pointer to the adapter structure.
0433  * @function: Function Number.
0434  * @addr: Address of the register.
0435  * @data: Pointer to the data tha has to be written.
0436  *
0437  * Return: 0 on success, -1 on failure.
0438  */
0439 int rsi_sdio_write_register(struct rsi_hw *adapter,
0440                 u8 function,
0441                 u32 addr,
0442                 u8 *data)
0443 {
0444     struct rsi_91x_sdiodev *dev =
0445         (struct rsi_91x_sdiodev *)adapter->rsi_dev;
0446     int status = 0;
0447 
0448     if (likely(dev->sdio_irq_task != current))
0449         sdio_claim_host(dev->pfunction);
0450 
0451     if (function == 0)
0452         sdio_f0_writeb(dev->pfunction, *data, addr, &status);
0453     else
0454         sdio_writeb(dev->pfunction, *data, addr, &status);
0455 
0456     if (likely(dev->sdio_irq_task != current))
0457         sdio_release_host(dev->pfunction);
0458 
0459     return status;
0460 }
0461 
0462 /**
0463  * rsi_sdio_ack_intr() - This function acks the interrupt received.
0464  * @adapter: Pointer to the adapter structure.
0465  * @int_bit: Interrupt bit to write into register.
0466  *
0467  * Return: None.
0468  */
0469 void rsi_sdio_ack_intr(struct rsi_hw *adapter, u8 int_bit)
0470 {
0471     int status;
0472     status = rsi_sdio_write_register(adapter,
0473                      1,
0474                      (SDIO_FUN1_INTR_CLR_REG |
0475                       RSI_SD_REQUEST_MASTER),
0476                      &int_bit);
0477     if (status)
0478         rsi_dbg(ERR_ZONE, "%s: unable to send ack\n", __func__);
0479 }
0480 
0481 
0482 
0483 /**
0484  * rsi_sdio_read_register_multiple() - This function read multiple bytes of
0485  *                     information from the SD card.
0486  * @adapter: Pointer to the adapter structure.
0487  * @addr: Address of the register.
0488  * @count: Number of multiple bytes to be read.
0489  * @data: Pointer to the read data.
0490  *
0491  * Return: 0 on success, -1 on failure.
0492  */
0493 static int rsi_sdio_read_register_multiple(struct rsi_hw *adapter,
0494                        u32 addr,
0495                        u8 *data,
0496                        u16 count)
0497 {
0498     struct rsi_91x_sdiodev *dev =
0499         (struct rsi_91x_sdiodev *)adapter->rsi_dev;
0500     u32 status;
0501 
0502     if (likely(dev->sdio_irq_task != current))
0503         sdio_claim_host(dev->pfunction);
0504 
0505     status =  sdio_readsb(dev->pfunction, data, addr, count);
0506 
0507     if (likely(dev->sdio_irq_task != current))
0508         sdio_release_host(dev->pfunction);
0509 
0510     if (status != 0)
0511         rsi_dbg(ERR_ZONE, "%s: Synch Cmd53 read failed\n", __func__);
0512     return status;
0513 }
0514 
0515 /**
0516  * rsi_sdio_write_register_multiple() - This function writes multiple bytes of
0517  *                  information to the SD card.
0518  * @adapter: Pointer to the adapter structure.
0519  * @addr: Address of the register.
0520  * @data: Pointer to the data that has to be written.
0521  * @count: Number of multiple bytes to be written.
0522  *
0523  * Return: 0 on success, -1 on failure.
0524  */
0525 int rsi_sdio_write_register_multiple(struct rsi_hw *adapter,
0526                      u32 addr,
0527                      u8 *data,
0528                      u16 count)
0529 {
0530     struct rsi_91x_sdiodev *dev =
0531         (struct rsi_91x_sdiodev *)adapter->rsi_dev;
0532     int status;
0533 
0534     if (dev->write_fail > 1) {
0535         rsi_dbg(ERR_ZONE, "%s: Stopping card writes\n", __func__);
0536         return 0;
0537     } else if (dev->write_fail == 1) {
0538         /**
0539          * Assuming it is a CRC failure, we want to allow another
0540          *  card write
0541          */
0542         rsi_dbg(ERR_ZONE, "%s: Continue card writes\n", __func__);
0543         dev->write_fail++;
0544     }
0545 
0546     if (likely(dev->sdio_irq_task != current))
0547         sdio_claim_host(dev->pfunction);
0548 
0549     status = sdio_writesb(dev->pfunction, addr, data, count);
0550 
0551     if (likely(dev->sdio_irq_task != current))
0552         sdio_release_host(dev->pfunction);
0553 
0554     if (status) {
0555         rsi_dbg(ERR_ZONE, "%s: Synch Cmd53 write failed %d\n",
0556             __func__, status);
0557         dev->write_fail = 2;
0558     } else {
0559         memcpy(dev->prev_desc, data, FRAME_DESC_SZ);
0560     }
0561     return status;
0562 }
0563 
0564 static int rsi_sdio_load_data_master_write(struct rsi_hw *adapter,
0565                        u32 base_address,
0566                        u32 instructions_sz,
0567                        u16 block_size,
0568                        u8 *ta_firmware)
0569 {
0570     u32 num_blocks, offset, i;
0571     u16 msb_address, lsb_address;
0572     u8 *temp_buf;
0573     int status;
0574 
0575     num_blocks = instructions_sz / block_size;
0576     msb_address = base_address >> 16;
0577 
0578     rsi_dbg(INFO_ZONE, "ins_size: %d, num_blocks: %d\n",
0579         instructions_sz, num_blocks);
0580 
0581     temp_buf = kmalloc(block_size, GFP_KERNEL);
0582     if (!temp_buf)
0583         return -ENOMEM;
0584 
0585     /* Loading DM ms word in the sdio slave */
0586     status = rsi_sdio_master_access_msword(adapter, msb_address);
0587     if (status < 0) {
0588         rsi_dbg(ERR_ZONE, "%s: Unable to set ms word reg\n", __func__);
0589         goto out_free;
0590     }
0591 
0592     for (offset = 0, i = 0; i < num_blocks; i++, offset += block_size) {
0593         memcpy(temp_buf, ta_firmware + offset, block_size);
0594         lsb_address = (u16)base_address;
0595         status = rsi_sdio_write_register_multiple
0596                     (adapter,
0597                      lsb_address | RSI_SD_REQUEST_MASTER,
0598                      temp_buf, block_size);
0599         if (status < 0) {
0600             rsi_dbg(ERR_ZONE, "%s: failed to write\n", __func__);
0601             goto out_free;
0602         }
0603         rsi_dbg(INFO_ZONE, "%s: loading block: %d\n", __func__, i);
0604         base_address += block_size;
0605 
0606         if ((base_address >> 16) != msb_address) {
0607             msb_address += 1;
0608 
0609             /* Loading DM ms word in the sdio slave */
0610             status = rsi_sdio_master_access_msword(adapter,
0611                                    msb_address);
0612             if (status < 0) {
0613                 rsi_dbg(ERR_ZONE,
0614                     "%s: Unable to set ms word reg\n",
0615                     __func__);
0616                 goto out_free;
0617             }
0618         }
0619     }
0620 
0621     if (instructions_sz % block_size) {
0622         memset(temp_buf, 0, block_size);
0623         memcpy(temp_buf, ta_firmware + offset,
0624                instructions_sz % block_size);
0625         lsb_address = (u16)base_address;
0626         status = rsi_sdio_write_register_multiple
0627                     (adapter,
0628                      lsb_address | RSI_SD_REQUEST_MASTER,
0629                      temp_buf,
0630                      instructions_sz % block_size);
0631         if (status < 0)
0632             goto out_free;
0633         rsi_dbg(INFO_ZONE,
0634             "Written Last Block in Address 0x%x Successfully\n",
0635             offset | RSI_SD_REQUEST_MASTER);
0636     }
0637 
0638     status = 0;
0639 out_free:
0640     kfree(temp_buf);
0641     return status;
0642 }
0643 
0644 #define FLASH_SIZE_ADDR                 0x04000016
0645 static int rsi_sdio_master_reg_read(struct rsi_hw *adapter, u32 addr,
0646                     u32 *read_buf, u16 size)
0647 {
0648     u32 addr_on_bus, *data;
0649     u16 ms_addr;
0650     int status;
0651 
0652     data = kzalloc(RSI_MASTER_REG_BUF_SIZE, GFP_KERNEL);
0653     if (!data)
0654         return -ENOMEM;
0655 
0656     ms_addr = (addr >> 16);
0657     status = rsi_sdio_master_access_msword(adapter, ms_addr);
0658     if (status < 0) {
0659         rsi_dbg(ERR_ZONE,
0660             "%s: Unable to set ms word to common reg\n",
0661             __func__);
0662         goto err;
0663     }
0664     addr &= 0xFFFF;
0665 
0666     addr_on_bus = (addr & 0xFF000000);
0667     if ((addr_on_bus == (FLASH_SIZE_ADDR & 0xFF000000)) ||
0668         (addr_on_bus == 0x0))
0669         addr_on_bus = (addr & ~(0x3));
0670     else
0671         addr_on_bus = addr;
0672 
0673     /* Bring TA out of reset */
0674     status = rsi_sdio_read_register_multiple
0675                     (adapter,
0676                      (addr_on_bus | RSI_SD_REQUEST_MASTER),
0677                      (u8 *)data, 4);
0678     if (status < 0) {
0679         rsi_dbg(ERR_ZONE, "%s: AHB register read failed\n", __func__);
0680         goto err;
0681     }
0682     if (size == 2) {
0683         if ((addr & 0x3) == 0)
0684             *read_buf = *data;
0685         else
0686             *read_buf  = (*data >> 16);
0687         *read_buf = (*read_buf & 0xFFFF);
0688     } else if (size == 1) {
0689         if ((addr & 0x3) == 0)
0690             *read_buf = *data;
0691         else if ((addr & 0x3) == 1)
0692             *read_buf = (*data >> 8);
0693         else if ((addr & 0x3) == 2)
0694             *read_buf = (*data >> 16);
0695         else
0696             *read_buf = (*data >> 24);
0697         *read_buf = (*read_buf & 0xFF);
0698     } else {
0699         *read_buf = *data;
0700     }
0701 
0702 err:
0703     kfree(data);
0704     return status;
0705 }
0706 
0707 static int rsi_sdio_master_reg_write(struct rsi_hw *adapter,
0708                      unsigned long addr,
0709                      unsigned long data, u16 size)
0710 {
0711     unsigned long *data_aligned;
0712     int status;
0713 
0714     data_aligned = kzalloc(RSI_MASTER_REG_BUF_SIZE, GFP_KERNEL);
0715     if (!data_aligned)
0716         return -ENOMEM;
0717 
0718     if (size == 2) {
0719         *data_aligned = ((data << 16) | (data & 0xFFFF));
0720     } else if (size == 1) {
0721         u32 temp_data = data & 0xFF;
0722 
0723         *data_aligned = ((temp_data << 24) | (temp_data << 16) |
0724                  (temp_data << 8) | temp_data);
0725     } else {
0726         *data_aligned = data;
0727     }
0728     size = 4;
0729 
0730     status = rsi_sdio_master_access_msword(adapter, (addr >> 16));
0731     if (status < 0) {
0732         rsi_dbg(ERR_ZONE,
0733             "%s: Unable to set ms word to common reg\n",
0734             __func__);
0735         kfree(data_aligned);
0736         return -EIO;
0737     }
0738     addr = addr & 0xFFFF;
0739 
0740     /* Bring TA out of reset */
0741     status = rsi_sdio_write_register_multiple
0742                     (adapter,
0743                      (addr | RSI_SD_REQUEST_MASTER),
0744                      (u8 *)data_aligned, size);
0745     if (status < 0)
0746         rsi_dbg(ERR_ZONE,
0747             "%s: Unable to do AHB reg write\n", __func__);
0748 
0749     kfree(data_aligned);
0750     return status;
0751 }
0752 
0753 /**
0754  * rsi_sdio_host_intf_write_pkt() - This function writes the packet to device.
0755  * @adapter: Pointer to the adapter structure.
0756  * @pkt: Pointer to the data to be written on to the device.
0757  * @len: length of the data to be written on to the device.
0758  *
0759  * Return: 0 on success, -1 on failure.
0760  */
0761 static int rsi_sdio_host_intf_write_pkt(struct rsi_hw *adapter,
0762                     u8 *pkt,
0763                     u32 len)
0764 {
0765     struct rsi_91x_sdiodev *dev =
0766         (struct rsi_91x_sdiodev *)adapter->rsi_dev;
0767     u32 block_size = dev->tx_blk_size;
0768     u32 num_blocks, address, length;
0769     u32 queueno;
0770     int status;
0771 
0772     queueno = ((pkt[1] >> 4) & 0xf);
0773     if (queueno == RSI_BT_MGMT_Q || queueno == RSI_BT_DATA_Q)
0774         queueno = RSI_BT_Q;
0775 
0776     num_blocks = len / block_size;
0777 
0778     if (len % block_size)
0779         num_blocks++;
0780 
0781     address = (num_blocks * block_size | (queueno << 12));
0782     length  = num_blocks * block_size;
0783 
0784     status = rsi_sdio_write_register_multiple(adapter,
0785                           address,
0786                           (u8 *)pkt,
0787                           length);
0788     if (status)
0789         rsi_dbg(ERR_ZONE, "%s: Unable to write onto the card: %d\n",
0790             __func__, status);
0791     rsi_dbg(DATA_TX_ZONE, "%s: Successfully written onto card\n", __func__);
0792     return status;
0793 }
0794 
0795 /**
0796  * rsi_sdio_host_intf_read_pkt() - This function reads the packet
0797  *                 from the device.
0798  * @adapter: Pointer to the adapter data structure.
0799  * @pkt: Pointer to the packet data to be read from the device.
0800  * @length: Length of the data to be read from the device.
0801  *
0802  * Return: 0 on success, -1 on failure.
0803  */
0804 int rsi_sdio_host_intf_read_pkt(struct rsi_hw *adapter,
0805                 u8 *pkt,
0806                 u32 length)
0807 {
0808     int status = -EINVAL;
0809 
0810     if (!length) {
0811         rsi_dbg(ERR_ZONE, "%s: Pkt size is zero\n", __func__);
0812         return status;
0813     }
0814 
0815     status = rsi_sdio_read_register_multiple(adapter,
0816                          length,
0817                          (u8 *)pkt,
0818                          length); /*num of bytes*/
0819 
0820     if (status)
0821         rsi_dbg(ERR_ZONE, "%s: Failed to read frame: %d\n", __func__,
0822             status);
0823     return status;
0824 }
0825 
0826 /**
0827  * rsi_init_sdio_interface() - This function does init specific to SDIO.
0828  *
0829  * @adapter: Pointer to the adapter data structure.
0830  * @pfunction: Pointer to the sdio_func structure.
0831  *
0832  * Return: 0 on success, -1 on failure.
0833  */
0834 static int rsi_init_sdio_interface(struct rsi_hw *adapter,
0835                    struct sdio_func *pfunction)
0836 {
0837     struct rsi_91x_sdiodev *rsi_91x_dev;
0838     int status;
0839 
0840     rsi_91x_dev = kzalloc(sizeof(*rsi_91x_dev), GFP_KERNEL);
0841     if (!rsi_91x_dev)
0842         return -ENOMEM;
0843 
0844     adapter->rsi_dev = rsi_91x_dev;
0845 
0846     sdio_claim_host(pfunction);
0847 
0848     pfunction->enable_timeout = 100;
0849     status = sdio_enable_func(pfunction);
0850     if (status) {
0851         rsi_dbg(ERR_ZONE, "%s: Failed to enable interface\n", __func__);
0852         sdio_release_host(pfunction);
0853         return status;
0854     }
0855 
0856     rsi_dbg(INIT_ZONE, "%s: Enabled the interface\n", __func__);
0857 
0858     rsi_91x_dev->pfunction = pfunction;
0859     adapter->device = &pfunction->dev;
0860 
0861     sdio_set_drvdata(pfunction, adapter);
0862 
0863     status = rsi_setupcard(adapter);
0864     if (status) {
0865         rsi_dbg(ERR_ZONE, "%s: Failed to setup card\n", __func__);
0866         goto fail;
0867     }
0868 
0869     rsi_dbg(INIT_ZONE, "%s: Setup card successfully\n", __func__);
0870 
0871     status = rsi_init_sdio_slave_regs(adapter);
0872     if (status) {
0873         rsi_dbg(ERR_ZONE, "%s: Failed to init slave regs\n", __func__);
0874         goto fail;
0875     }
0876     sdio_release_host(pfunction);
0877 
0878     adapter->determine_event_timeout = rsi_sdio_determine_event_timeout;
0879     adapter->check_hw_queue_status = rsi_sdio_check_buffer_status;
0880 
0881 #ifdef CONFIG_RSI_DEBUGFS
0882     adapter->num_debugfs_entries = MAX_DEBUGFS_ENTRIES;
0883 #endif
0884     return 0;
0885 fail:
0886     sdio_disable_func(pfunction);
0887     sdio_release_host(pfunction);
0888     return status;
0889 }
0890 
0891 static int rsi_sdio_reinit_device(struct rsi_hw *adapter)
0892 {
0893     struct rsi_91x_sdiodev *sdev = adapter->rsi_dev;
0894     struct sdio_func *pfunction = sdev->pfunction;
0895     int ii;
0896 
0897     for (ii = 0; ii < NUM_SOFT_QUEUES; ii++)
0898         skb_queue_purge(&adapter->priv->tx_queue[ii]);
0899 
0900     /* Initialize device again */
0901     sdio_claim_host(pfunction);
0902 
0903     sdio_release_irq(pfunction);
0904     rsi_reset_card(pfunction);
0905 
0906     sdio_enable_func(pfunction);
0907     rsi_setupcard(adapter);
0908     rsi_init_sdio_slave_regs(adapter);
0909     sdio_claim_irq(pfunction, rsi_handle_interrupt);
0910     rsi_hal_device_init(adapter);
0911 
0912     sdio_release_host(pfunction);
0913 
0914     return 0;
0915 }
0916 
0917 static int rsi_sdio_ta_reset(struct rsi_hw *adapter)
0918 {
0919     int status;
0920     u32 addr;
0921     u8 *data;
0922 
0923     data = kzalloc(RSI_9116_REG_SIZE, GFP_KERNEL);
0924     if (!data)
0925         return -ENOMEM;
0926 
0927     status = rsi_sdio_master_access_msword(adapter, TA_BASE_ADDR);
0928     if (status < 0) {
0929         rsi_dbg(ERR_ZONE,
0930             "Unable to set ms word to common reg\n");
0931         goto err;
0932     }
0933 
0934     rsi_dbg(INIT_ZONE, "%s: Bring TA out of reset\n", __func__);
0935     put_unaligned_le32(TA_HOLD_THREAD_VALUE, data);
0936     addr = TA_HOLD_THREAD_REG | RSI_SD_REQUEST_MASTER;
0937     status = rsi_sdio_write_register_multiple(adapter, addr,
0938                           (u8 *)data,
0939                           RSI_9116_REG_SIZE);
0940     if (status < 0) {
0941         rsi_dbg(ERR_ZONE, "Unable to hold TA threads\n");
0942         goto err;
0943     }
0944 
0945     put_unaligned_le32(TA_SOFT_RST_CLR, data);
0946     addr = TA_SOFT_RESET_REG | RSI_SD_REQUEST_MASTER;
0947     status = rsi_sdio_write_register_multiple(adapter, addr,
0948                           (u8 *)data,
0949                           RSI_9116_REG_SIZE);
0950     if (status < 0) {
0951         rsi_dbg(ERR_ZONE, "Unable to get TA out of reset\n");
0952         goto err;
0953     }
0954 
0955     put_unaligned_le32(TA_PC_ZERO, data);
0956     addr = TA_TH0_PC_REG | RSI_SD_REQUEST_MASTER;
0957     status = rsi_sdio_write_register_multiple(adapter, addr,
0958                           (u8 *)data,
0959                           RSI_9116_REG_SIZE);
0960     if (status < 0) {
0961         rsi_dbg(ERR_ZONE, "Unable to Reset TA PC value\n");
0962         status = -EINVAL;
0963         goto err;
0964     }
0965 
0966     put_unaligned_le32(TA_RELEASE_THREAD_VALUE, data);
0967     addr = TA_RELEASE_THREAD_REG | RSI_SD_REQUEST_MASTER;
0968     status = rsi_sdio_write_register_multiple(adapter, addr,
0969                           (u8 *)data,
0970                           RSI_9116_REG_SIZE);
0971     if (status < 0) {
0972         rsi_dbg(ERR_ZONE, "Unable to release TA threads\n");
0973         goto err;
0974     }
0975 
0976     status = rsi_sdio_master_access_msword(adapter, MISC_CFG_BASE_ADDR);
0977     if (status < 0) {
0978         rsi_dbg(ERR_ZONE, "Unable to set ms word to common reg\n");
0979         goto err;
0980     }
0981     rsi_dbg(INIT_ZONE, "***** TA Reset done *****\n");
0982 
0983 err:
0984     kfree(data);
0985     return status;
0986 }
0987 
0988 static struct rsi_host_intf_ops sdio_host_intf_ops = {
0989     .write_pkt      = rsi_sdio_host_intf_write_pkt,
0990     .read_pkt       = rsi_sdio_host_intf_read_pkt,
0991     .master_access_msword   = rsi_sdio_master_access_msword,
0992     .read_reg_multiple  = rsi_sdio_read_register_multiple,
0993     .write_reg_multiple = rsi_sdio_write_register_multiple,
0994     .master_reg_read    = rsi_sdio_master_reg_read,
0995     .master_reg_write   = rsi_sdio_master_reg_write,
0996     .load_data_master_write = rsi_sdio_load_data_master_write,
0997     .reinit_device          = rsi_sdio_reinit_device,
0998     .ta_reset       = rsi_sdio_ta_reset,
0999 };
1000 
1001 /**
1002  * rsi_probe() - This function is called by kernel when the driver provided
1003  *       Vendor and device IDs are matched. All the initialization
1004  *       work is done here.
1005  * @pfunction: Pointer to the sdio_func structure.
1006  * @id: Pointer to sdio_device_id structure.
1007  *
1008  * Return: 0 on success, 1 on failure.
1009  */
1010 static int rsi_probe(struct sdio_func *pfunction,
1011              const struct sdio_device_id *id)
1012 {
1013     struct rsi_hw *adapter;
1014     struct rsi_91x_sdiodev *sdev;
1015     int status = -EINVAL;
1016 
1017     rsi_dbg(INIT_ZONE, "%s: Init function called\n", __func__);
1018 
1019     adapter = rsi_91x_init(dev_oper_mode);
1020     if (!adapter) {
1021         rsi_dbg(ERR_ZONE, "%s: Failed to init os intf ops\n",
1022             __func__);
1023         return -EINVAL;
1024     }
1025     adapter->rsi_host_intf = RSI_HOST_INTF_SDIO;
1026     adapter->host_intf_ops = &sdio_host_intf_ops;
1027 
1028     if (rsi_init_sdio_interface(adapter, pfunction)) {
1029         rsi_dbg(ERR_ZONE, "%s: Failed to init sdio interface\n",
1030             __func__);
1031         status = -EIO;
1032         goto fail_free_adapter;
1033     }
1034 
1035     if (pfunction->device == SDIO_DEVICE_ID_RSI_9113) {
1036         rsi_dbg(ERR_ZONE, "%s: 9113 module detected\n", __func__);
1037         adapter->device_model = RSI_DEV_9113;
1038     } else  if (pfunction->device == SDIO_DEVICE_ID_RSI_9116) {
1039         rsi_dbg(ERR_ZONE, "%s: 9116 module detected\n", __func__);
1040         adapter->device_model = RSI_DEV_9116;
1041     } else {
1042         rsi_dbg(ERR_ZONE,
1043             "%s: Unsupported RSI device id 0x%x\n", __func__,
1044             pfunction->device);
1045         goto fail_free_adapter;
1046     }
1047 
1048     sdev = (struct rsi_91x_sdiodev *)adapter->rsi_dev;
1049     rsi_init_event(&sdev->rx_thread.event);
1050     status = rsi_create_kthread(adapter->priv, &sdev->rx_thread,
1051                     rsi_sdio_rx_thread, "SDIO-RX-Thread");
1052     if (status) {
1053         rsi_dbg(ERR_ZONE, "%s: Unable to init rx thrd\n", __func__);
1054         goto fail_kill_thread;
1055     }
1056 
1057     sdio_claim_host(pfunction);
1058     if (sdio_claim_irq(pfunction, rsi_handle_interrupt)) {
1059         rsi_dbg(ERR_ZONE, "%s: Failed to request IRQ\n", __func__);
1060         sdio_release_host(pfunction);
1061         status = -EIO;
1062         goto fail_claim_irq;
1063     }
1064     sdio_release_host(pfunction);
1065     rsi_dbg(INIT_ZONE, "%s: Registered Interrupt handler\n", __func__);
1066 
1067     if (rsi_hal_device_init(adapter)) {
1068         rsi_dbg(ERR_ZONE, "%s: Failed in device init\n", __func__);
1069         status = -EINVAL;
1070         goto fail_dev_init;
1071     }
1072     rsi_dbg(INFO_ZONE, "===> RSI Device Init Done <===\n");
1073 
1074     if (rsi_sdio_master_access_msword(adapter, MISC_CFG_BASE_ADDR)) {
1075         rsi_dbg(ERR_ZONE, "%s: Unable to set ms word reg\n", __func__);
1076         status = -EIO;
1077         goto fail_dev_init;
1078     }
1079 
1080     adapter->priv->hibernate_resume = false;
1081     adapter->priv->reinit_hw = false;
1082     return 0;
1083 
1084 fail_dev_init:
1085     sdio_claim_host(pfunction);
1086     sdio_release_irq(pfunction);
1087     sdio_release_host(pfunction);
1088 fail_claim_irq:
1089     rsi_kill_thread(&sdev->rx_thread);
1090 fail_kill_thread:
1091     sdio_claim_host(pfunction);
1092     sdio_disable_func(pfunction);
1093     sdio_release_host(pfunction);
1094 fail_free_adapter:
1095     rsi_91x_deinit(adapter);
1096     rsi_dbg(ERR_ZONE, "%s: Failed in probe...Exiting\n", __func__);
1097     return status;
1098 }
1099 
1100 static void ulp_read_write(struct rsi_hw *adapter, u16 addr, u32 data,
1101                u16 len_in_bits)
1102 {
1103     rsi_sdio_master_reg_write(adapter, RSI_GSPI_DATA_REG1,
1104                   ((addr << 6) | ((data >> 16) & 0xffff)), 2);
1105     rsi_sdio_master_reg_write(adapter, RSI_GSPI_DATA_REG0,
1106                   (data & 0xffff), 2);
1107     rsi_sdio_master_reg_write(adapter, RSI_GSPI_CTRL_REG0,
1108                   RSI_GSPI_CTRL_REG0_VALUE, 2);
1109     rsi_sdio_master_reg_write(adapter, RSI_GSPI_CTRL_REG1,
1110                   ((len_in_bits - 1) | RSI_GSPI_TRIG), 2);
1111     msleep(20);
1112 }
1113 
1114 /*This function resets and re-initializes the chip.*/
1115 static void rsi_reset_chip(struct rsi_hw *adapter)
1116 {
1117     u8 *data;
1118     u8 sdio_interrupt_status = 0;
1119     u8 request = 1;
1120     int ret;
1121 
1122     data = kzalloc(sizeof(u32), GFP_KERNEL);
1123     if (!data)
1124         return;
1125 
1126     rsi_dbg(INFO_ZONE, "Writing disable to wakeup register\n");
1127     ret =  rsi_sdio_write_register(adapter, 0, SDIO_WAKEUP_REG, &request);
1128     if (ret < 0) {
1129         rsi_dbg(ERR_ZONE,
1130             "%s: Failed to write SDIO wakeup register\n", __func__);
1131         goto err;
1132     }
1133     msleep(20);
1134     ret =  rsi_sdio_read_register(adapter, RSI_FN1_INT_REGISTER,
1135                       &sdio_interrupt_status);
1136     if (ret < 0) {
1137         rsi_dbg(ERR_ZONE, "%s: Failed to Read Intr Status Register\n",
1138             __func__);
1139         goto err;
1140     }
1141     rsi_dbg(INFO_ZONE, "%s: Intr Status Register value = %d\n",
1142         __func__, sdio_interrupt_status);
1143 
1144     /* Put Thread-Arch processor on hold */
1145     if (rsi_sdio_master_access_msword(adapter, TA_BASE_ADDR)) {
1146         rsi_dbg(ERR_ZONE,
1147             "%s: Unable to set ms word to common reg\n",
1148             __func__);
1149         goto err;
1150     }
1151 
1152     put_unaligned_le32(TA_HOLD_THREAD_VALUE, data);
1153     if (rsi_sdio_write_register_multiple(adapter, TA_HOLD_THREAD_REG |
1154                          RSI_SD_REQUEST_MASTER,
1155                          data, 4)) {
1156         rsi_dbg(ERR_ZONE,
1157             "%s: Unable to hold Thread-Arch processor threads\n",
1158             __func__);
1159         goto err;
1160     }
1161 
1162     /* This msleep will ensure Thread-Arch processor to go to hold
1163      * and any pending dma transfers to rf spi in device to finish.
1164      */
1165     msleep(100);
1166     if (adapter->device_model != RSI_DEV_9116) {
1167         ulp_read_write(adapter, RSI_ULP_RESET_REG, RSI_ULP_WRITE_0, 32);
1168         ulp_read_write(adapter,
1169                    RSI_WATCH_DOG_TIMER_1, RSI_ULP_WRITE_2, 32);
1170         ulp_read_write(adapter, RSI_WATCH_DOG_TIMER_2, RSI_ULP_WRITE_0,
1171                    32);
1172         ulp_read_write(adapter, RSI_WATCH_DOG_DELAY_TIMER_1,
1173                    RSI_ULP_WRITE_50, 32);
1174         ulp_read_write(adapter, RSI_WATCH_DOG_DELAY_TIMER_2,
1175                    RSI_ULP_WRITE_0, 32);
1176         ulp_read_write(adapter, RSI_WATCH_DOG_TIMER_ENABLE,
1177                    RSI_ULP_TIMER_ENABLE, 32);
1178     } else {
1179         if ((rsi_sdio_master_reg_write(adapter,
1180                            NWP_WWD_INTERRUPT_TIMER,
1181                            NWP_WWD_INT_TIMER_CLKS,
1182                            RSI_9116_REG_SIZE)) < 0) {
1183             rsi_dbg(ERR_ZONE, "Failed to write to intr timer\n");
1184         }
1185         if ((rsi_sdio_master_reg_write(adapter,
1186                            NWP_WWD_SYSTEM_RESET_TIMER,
1187                            NWP_WWD_SYS_RESET_TIMER_CLKS,
1188                            RSI_9116_REG_SIZE)) < 0) {
1189             rsi_dbg(ERR_ZONE,
1190                 "Failed to write to system reset timer\n");
1191         }
1192         if ((rsi_sdio_master_reg_write(adapter,
1193                            NWP_WWD_MODE_AND_RSTART,
1194                            NWP_WWD_TIMER_DISABLE,
1195                            RSI_9116_REG_SIZE)) < 0) {
1196             rsi_dbg(ERR_ZONE,
1197                 "Failed to write to mode and restart\n");
1198         }
1199         rsi_dbg(ERR_ZONE, "***** Watch Dog Reset Successful *****\n");
1200     }
1201     /* This msleep will be sufficient for the ulp
1202      * read write operations to complete for chip reset.
1203      */
1204     msleep(500);
1205 err:
1206     kfree(data);
1207     return;
1208 }
1209 
1210 /**
1211  * rsi_disconnect() - This function performs the reverse of the probe function.
1212  * @pfunction: Pointer to the sdio_func structure.
1213  *
1214  * Return: void.
1215  */
1216 static void rsi_disconnect(struct sdio_func *pfunction)
1217 {
1218     struct rsi_hw *adapter = sdio_get_drvdata(pfunction);
1219     struct rsi_91x_sdiodev *dev;
1220 
1221     if (!adapter)
1222         return;
1223 
1224     dev = (struct rsi_91x_sdiodev *)adapter->rsi_dev;
1225 
1226     rsi_kill_thread(&dev->rx_thread);
1227     sdio_claim_host(pfunction);
1228     sdio_release_irq(pfunction);
1229     sdio_release_host(pfunction);
1230     mdelay(10);
1231 
1232     rsi_mac80211_detach(adapter);
1233     mdelay(10);
1234 
1235     if (IS_ENABLED(CONFIG_RSI_COEX) && adapter->priv->coex_mode > 1 &&
1236         adapter->priv->bt_adapter) {
1237         rsi_bt_ops.detach(adapter->priv->bt_adapter);
1238         adapter->priv->bt_adapter = NULL;
1239     }
1240 
1241     /* Reset Chip */
1242     rsi_reset_chip(adapter);
1243 
1244     /* Resetting to take care of the case, where-in driver is re-loaded */
1245     sdio_claim_host(pfunction);
1246     rsi_reset_card(pfunction);
1247     sdio_disable_func(pfunction);
1248     sdio_release_host(pfunction);
1249     dev->write_fail = 2;
1250     rsi_91x_deinit(adapter);
1251     rsi_dbg(ERR_ZONE, "##### RSI SDIO device disconnected #####\n");
1252 
1253 }
1254 
1255 #ifdef CONFIG_PM
1256 static int rsi_set_sdio_pm_caps(struct rsi_hw *adapter)
1257 {
1258     struct rsi_91x_sdiodev *dev =
1259         (struct rsi_91x_sdiodev *)adapter->rsi_dev;
1260     struct sdio_func *func = dev->pfunction;
1261     int ret;
1262 
1263     ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
1264     if (ret)
1265         rsi_dbg(ERR_ZONE, "Set sdio keep pwr flag failed: %d\n", ret);
1266 
1267     return ret;
1268 }
1269 
1270 static int rsi_sdio_disable_interrupts(struct sdio_func *pfunc)
1271 {
1272     struct rsi_hw *adapter = sdio_get_drvdata(pfunc);
1273     u8 isr_status = 0, data = 0;
1274     int ret;
1275     unsigned long t1;
1276 
1277     rsi_dbg(INFO_ZONE, "Waiting for interrupts to be cleared..");
1278     t1 = jiffies;
1279     do {
1280         rsi_sdio_read_register(adapter, RSI_FN1_INT_REGISTER,
1281                        &isr_status);
1282         rsi_dbg(INFO_ZONE, ".");
1283     } while ((isr_status) && (jiffies_to_msecs(jiffies - t1) < 20));
1284     rsi_dbg(INFO_ZONE, "Interrupts cleared\n");
1285 
1286     sdio_claim_host(pfunc);
1287     ret = rsi_cmd52readbyte(pfunc->card, RSI_INT_ENABLE_REGISTER, &data);
1288     if (ret < 0) {
1289         rsi_dbg(ERR_ZONE,
1290             "%s: Failed to read int enable register\n",
1291             __func__);
1292         goto done;
1293     }
1294 
1295     data &= RSI_INT_ENABLE_MASK;
1296     ret = rsi_cmd52writebyte(pfunc->card, RSI_INT_ENABLE_REGISTER, data);
1297     if (ret < 0) {
1298         rsi_dbg(ERR_ZONE,
1299             "%s: Failed to write to int enable register\n",
1300             __func__);
1301         goto done;
1302     }
1303     ret = rsi_cmd52readbyte(pfunc->card, RSI_INT_ENABLE_REGISTER, &data);
1304     if (ret < 0) {
1305         rsi_dbg(ERR_ZONE,
1306             "%s: Failed to read int enable register\n",
1307             __func__);
1308         goto done;
1309     }
1310     rsi_dbg(INFO_ZONE, "int enable reg content = %x\n", data);
1311 
1312 done:
1313     sdio_release_host(pfunc);
1314     return ret;
1315 }
1316 
1317 static int rsi_sdio_enable_interrupts(struct sdio_func *pfunc)
1318 {
1319     u8 data;
1320     int ret;
1321     struct rsi_hw *adapter = sdio_get_drvdata(pfunc);
1322     struct rsi_common *common = adapter->priv;
1323 
1324     sdio_claim_host(pfunc);
1325     ret = rsi_cmd52readbyte(pfunc->card, RSI_INT_ENABLE_REGISTER, &data);
1326     if (ret < 0) {
1327         rsi_dbg(ERR_ZONE,
1328             "%s: Failed to read int enable register\n", __func__);
1329         goto done;
1330     }
1331 
1332     data |= ~RSI_INT_ENABLE_MASK & 0xff;
1333 
1334     ret = rsi_cmd52writebyte(pfunc->card, RSI_INT_ENABLE_REGISTER, data);
1335     if (ret < 0) {
1336         rsi_dbg(ERR_ZONE,
1337             "%s: Failed to write to int enable register\n",
1338             __func__);
1339         goto done;
1340     }
1341 
1342     if ((common->wow_flags & RSI_WOW_ENABLED) &&
1343         (common->wow_flags & RSI_WOW_NO_CONNECTION))
1344         rsi_dbg(ERR_ZONE,
1345             "##### Device can not wake up through WLAN\n");
1346 
1347     ret = rsi_cmd52readbyte(pfunc->card, RSI_INT_ENABLE_REGISTER, &data);
1348     if (ret < 0) {
1349         rsi_dbg(ERR_ZONE,
1350             "%s: Failed to read int enable register\n", __func__);
1351         goto done;
1352     }
1353     rsi_dbg(INFO_ZONE, "int enable reg content = %x\n", data);
1354 
1355 done:
1356     sdio_release_host(pfunc);
1357     return ret;
1358 }
1359 
1360 static int rsi_suspend(struct device *dev)
1361 {
1362     int ret;
1363     struct sdio_func *pfunction = dev_to_sdio_func(dev);
1364     struct rsi_hw *adapter = sdio_get_drvdata(pfunction);
1365     struct rsi_common *common;
1366 
1367     if (!adapter) {
1368         rsi_dbg(ERR_ZONE, "Device is not ready\n");
1369         return -ENODEV;
1370     }
1371     common = adapter->priv;
1372     rsi_sdio_disable_interrupts(pfunction);
1373 
1374     ret = rsi_set_sdio_pm_caps(adapter);
1375     if (ret)
1376         rsi_dbg(INFO_ZONE,
1377             "Setting power management caps failed\n");
1378     common->fsm_state = FSM_CARD_NOT_READY;
1379 
1380     return 0;
1381 }
1382 
1383 static int rsi_resume(struct device *dev)
1384 {
1385     struct sdio_func *pfunction = dev_to_sdio_func(dev);
1386     struct rsi_hw *adapter = sdio_get_drvdata(pfunction);
1387     struct rsi_common *common = adapter->priv;
1388 
1389     common->fsm_state = FSM_MAC_INIT_DONE;
1390     rsi_sdio_enable_interrupts(pfunction);
1391 
1392     return 0;
1393 }
1394 
1395 static int rsi_freeze(struct device *dev)
1396 {
1397     int ret;
1398     struct sdio_func *pfunction = dev_to_sdio_func(dev);
1399     struct rsi_hw *adapter = sdio_get_drvdata(pfunction);
1400     struct rsi_common *common;
1401     struct rsi_91x_sdiodev *sdev;
1402 
1403     rsi_dbg(INFO_ZONE, "SDIO Bus freeze ===>\n");
1404 
1405     if (!adapter) {
1406         rsi_dbg(ERR_ZONE, "Device is not ready\n");
1407         return -ENODEV;
1408     }
1409     common = adapter->priv;
1410     sdev = (struct rsi_91x_sdiodev *)adapter->rsi_dev;
1411 
1412     if ((common->wow_flags & RSI_WOW_ENABLED) &&
1413         (common->wow_flags & RSI_WOW_NO_CONNECTION))
1414         rsi_dbg(ERR_ZONE,
1415             "##### Device can not wake up through WLAN\n");
1416 
1417     if (IS_ENABLED(CONFIG_RSI_COEX) && common->coex_mode > 1 &&
1418         common->bt_adapter) {
1419         rsi_bt_ops.detach(common->bt_adapter);
1420         common->bt_adapter = NULL;
1421     }
1422 
1423     ret = rsi_sdio_disable_interrupts(pfunction);
1424 
1425     if (sdev->write_fail)
1426         rsi_dbg(INFO_ZONE, "###### Device is not ready #######\n");
1427 
1428     ret = rsi_set_sdio_pm_caps(adapter);
1429     if (ret)
1430         rsi_dbg(INFO_ZONE, "Setting power management caps failed\n");
1431 
1432     rsi_dbg(INFO_ZONE, "***** RSI module freezed *****\n");
1433 
1434     return 0;
1435 }
1436 
1437 static int rsi_thaw(struct device *dev)
1438 {
1439     struct sdio_func *pfunction = dev_to_sdio_func(dev);
1440     struct rsi_hw *adapter = sdio_get_drvdata(pfunction);
1441     struct rsi_common *common = adapter->priv;
1442 
1443     rsi_dbg(ERR_ZONE, "SDIO Bus thaw =====>\n");
1444 
1445     common->hibernate_resume = true;
1446     common->fsm_state = FSM_CARD_NOT_READY;
1447     common->iface_down = true;
1448 
1449     rsi_sdio_enable_interrupts(pfunction);
1450 
1451     rsi_dbg(INFO_ZONE, "***** RSI module thaw done *****\n");
1452 
1453     return 0;
1454 }
1455 
1456 static void rsi_shutdown(struct device *dev)
1457 {
1458     struct sdio_func *pfunction = dev_to_sdio_func(dev);
1459     struct rsi_hw *adapter = sdio_get_drvdata(pfunction);
1460     struct rsi_91x_sdiodev *sdev =
1461         (struct rsi_91x_sdiodev *)adapter->rsi_dev;
1462     struct ieee80211_hw *hw = adapter->hw;
1463 
1464     rsi_dbg(ERR_ZONE, "SDIO Bus shutdown =====>\n");
1465 
1466     if (hw) {
1467         struct cfg80211_wowlan *wowlan = hw->wiphy->wowlan_config;
1468 
1469         if (rsi_config_wowlan(adapter, wowlan))
1470             rsi_dbg(ERR_ZONE, "Failed to configure WoWLAN\n");
1471     }
1472 
1473     if (IS_ENABLED(CONFIG_RSI_COEX) && adapter->priv->coex_mode > 1 &&
1474         adapter->priv->bt_adapter) {
1475         rsi_bt_ops.detach(adapter->priv->bt_adapter);
1476         adapter->priv->bt_adapter = NULL;
1477     }
1478 
1479     rsi_sdio_disable_interrupts(sdev->pfunction);
1480 
1481     if (sdev->write_fail)
1482         rsi_dbg(INFO_ZONE, "###### Device is not ready #######\n");
1483 
1484     if (rsi_set_sdio_pm_caps(adapter))
1485         rsi_dbg(INFO_ZONE, "Setting power management caps failed\n");
1486 
1487     rsi_dbg(INFO_ZONE, "***** RSI module shut down *****\n");
1488 }
1489 
1490 static int rsi_restore(struct device *dev)
1491 {
1492     struct sdio_func *pfunction = dev_to_sdio_func(dev);
1493     struct rsi_hw *adapter = sdio_get_drvdata(pfunction);
1494     struct rsi_common *common = adapter->priv;
1495 
1496     rsi_dbg(INFO_ZONE, "SDIO Bus restore ======>\n");
1497     common->hibernate_resume = true;
1498     common->fsm_state = FSM_FW_NOT_LOADED;
1499     common->iface_down = true;
1500 
1501     adapter->sc_nvifs = 0;
1502     adapter->ps_state = PS_NONE;
1503 
1504     common->wow_flags = 0;
1505     common->iface_down = false;
1506 
1507     rsi_dbg(INFO_ZONE, "RSI module restored\n");
1508 
1509     return 0;
1510 }
1511 static const struct dev_pm_ops rsi_pm_ops = {
1512     .suspend = rsi_suspend,
1513     .resume_noirq = rsi_resume,
1514     .freeze = rsi_freeze,
1515     .thaw = rsi_thaw,
1516     .restore = rsi_restore,
1517 };
1518 #endif
1519 
1520 static const struct sdio_device_id rsi_dev_table[] =  {
1521     { SDIO_DEVICE(SDIO_VENDOR_ID_RSI, SDIO_DEVICE_ID_RSI_9113) },
1522     { SDIO_DEVICE(SDIO_VENDOR_ID_RSI, SDIO_DEVICE_ID_RSI_9116) },
1523     { /* Blank */},
1524 };
1525 
1526 static struct sdio_driver rsi_driver = {
1527     .name       = "RSI-SDIO WLAN",
1528     .probe      = rsi_probe,
1529     .remove     = rsi_disconnect,
1530     .id_table   = rsi_dev_table,
1531 #ifdef CONFIG_PM
1532     .drv = {
1533         .pm = &rsi_pm_ops,
1534         .shutdown   = rsi_shutdown,
1535     }
1536 #endif
1537 };
1538 
1539 /**
1540  * rsi_module_init() - This function registers the sdio module.
1541  * @void: Void.
1542  *
1543  * Return: 0 on success.
1544  */
1545 static int rsi_module_init(void)
1546 {
1547     int ret;
1548 
1549     ret = sdio_register_driver(&rsi_driver);
1550     rsi_dbg(INIT_ZONE, "%s: Registering driver\n", __func__);
1551     return ret;
1552 }
1553 
1554 /**
1555  * rsi_module_exit() - This function unregisters the sdio module.
1556  * @void: Void.
1557  *
1558  * Return: None.
1559  */
1560 static void rsi_module_exit(void)
1561 {
1562     sdio_unregister_driver(&rsi_driver);
1563     rsi_dbg(INFO_ZONE, "%s: Unregistering driver\n", __func__);
1564 }
1565 
1566 module_init(rsi_module_init);
1567 module_exit(rsi_module_exit);
1568 
1569 MODULE_AUTHOR("Redpine Signals Inc");
1570 MODULE_DESCRIPTION("Common SDIO layer for RSI drivers");
1571 MODULE_DEVICE_TABLE(sdio, rsi_dev_table);
1572 MODULE_FIRMWARE(FIRMWARE_RSI9113);
1573 MODULE_VERSION("0.1");
1574 MODULE_LICENSE("Dual BSD/GPL");
[ 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!