Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  linux/drivers/net/wireless/libertas/if_sdio.c
0004  *
0005  *  Copyright 2007-2008 Pierre Ossman
0006  *
0007  * Inspired by if_cs.c, Copyright 2007 Holger Schurig
0008  *
0009  * This hardware has more or less no CMD53 support, so all registers
0010  * must be accessed using sdio_readb()/sdio_writeb().
0011  *
0012  * Transfers must be in one transaction or the firmware goes bonkers.
0013  * This means that the transfer must either be small enough to do a
0014  * byte based transfer or it must be padded to a multiple of the
0015  * current block size.
0016  *
0017  * As SDIO is still new to the kernel, it is unfortunately common with
0018  * bugs in the host controllers related to that. One such bug is that
0019  * controllers cannot do transfers that aren't a multiple of 4 bytes.
0020  * If you don't have time to fix the host controller driver, you can
0021  * work around the problem by modifying if_sdio_host_to_card() and
0022  * if_sdio_card_to_host() to pad the data.
0023  */
0024 
0025 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0026 
0027 #include <linux/kernel.h>
0028 #include <linux/module.h>
0029 #include <linux/slab.h>
0030 #include <linux/firmware.h>
0031 #include <linux/netdevice.h>
0032 #include <linux/delay.h>
0033 #include <linux/mmc/card.h>
0034 #include <linux/mmc/sdio_func.h>
0035 #include <linux/mmc/sdio_ids.h>
0036 #include <linux/mmc/sdio.h>
0037 #include <linux/mmc/host.h>
0038 #include <linux/pm_runtime.h>
0039 
0040 #include "host.h"
0041 #include "decl.h"
0042 #include "defs.h"
0043 #include "dev.h"
0044 #include "cmd.h"
0045 #include "if_sdio.h"
0046 
0047 static void if_sdio_interrupt(struct sdio_func *func);
0048 
0049 /* The if_sdio_remove() callback function is called when
0050  * user removes this module from kernel space or ejects
0051  * the card from the slot. The driver handles these 2 cases
0052  * differently for SD8688 combo chip.
0053  * If the user is removing the module, the FUNC_SHUTDOWN
0054  * command for SD8688 is sent to the firmware.
0055  * If the card is removed, there is no need to send this command.
0056  *
0057  * The variable 'user_rmmod' is used to distinguish these two
0058  * scenarios. This flag is initialized as FALSE in case the card
0059  * is removed, and will be set to TRUE for module removal when
0060  * module_exit function is called.
0061  */
0062 static u8 user_rmmod;
0063 
0064 static const struct sdio_device_id if_sdio_ids[] = {
0065     { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL,
0066             SDIO_DEVICE_ID_MARVELL_LIBERTAS) },
0067     { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL,
0068             SDIO_DEVICE_ID_MARVELL_8688_WLAN) },
0069     { /* end: all zeroes */             },
0070 };
0071 
0072 MODULE_DEVICE_TABLE(sdio, if_sdio_ids);
0073 
0074 #define MODEL_8385  0x04
0075 #define MODEL_8686  0x0b
0076 #define MODEL_8688  0x10
0077 
0078 static const struct lbs_fw_table fw_table[] = {
0079     { MODEL_8385, "libertas/sd8385_helper.bin", "libertas/sd8385.bin" },
0080     { MODEL_8385, "sd8385_helper.bin", "sd8385.bin" },
0081     { MODEL_8686, "libertas/sd8686_v9_helper.bin", "libertas/sd8686_v9.bin" },
0082     { MODEL_8686, "libertas/sd8686_v8_helper.bin", "libertas/sd8686_v8.bin" },
0083     { MODEL_8686, "sd8686_helper.bin", "sd8686.bin" },
0084     { MODEL_8688, "libertas/sd8688_helper.bin", "libertas/sd8688.bin" },
0085     { MODEL_8688, "sd8688_helper.bin", "sd8688.bin" },
0086     { 0, NULL, NULL }
0087 };
0088 MODULE_FIRMWARE("libertas/sd8385_helper.bin");
0089 MODULE_FIRMWARE("libertas/sd8385.bin");
0090 MODULE_FIRMWARE("sd8385_helper.bin");
0091 MODULE_FIRMWARE("sd8385.bin");
0092 MODULE_FIRMWARE("libertas/sd8686_v9_helper.bin");
0093 MODULE_FIRMWARE("libertas/sd8686_v9.bin");
0094 MODULE_FIRMWARE("libertas/sd8686_v8_helper.bin");
0095 MODULE_FIRMWARE("libertas/sd8686_v8.bin");
0096 MODULE_FIRMWARE("sd8686_helper.bin");
0097 MODULE_FIRMWARE("sd8686.bin");
0098 MODULE_FIRMWARE("libertas/sd8688_helper.bin");
0099 MODULE_FIRMWARE("libertas/sd8688.bin");
0100 MODULE_FIRMWARE("sd8688_helper.bin");
0101 MODULE_FIRMWARE("sd8688.bin");
0102 
0103 struct if_sdio_packet {
0104     struct if_sdio_packet   *next;
0105     u16         nb;
0106     u8          buffer[] __aligned(4);
0107 };
0108 
0109 struct if_sdio_card {
0110     struct sdio_func    *func;
0111     struct lbs_private  *priv;
0112 
0113     int         model;
0114     unsigned long       ioport;
0115     unsigned int        scratch_reg;
0116     bool            started;
0117     wait_queue_head_t   pwron_waitq;
0118 
0119     u8          buffer[65536] __attribute__((aligned(4)));
0120 
0121     spinlock_t      lock;
0122     struct if_sdio_packet   *packets;
0123 
0124     struct workqueue_struct *workqueue;
0125     struct work_struct  packet_worker;
0126 
0127     u8          rx_unit;
0128 };
0129 
0130 static void if_sdio_finish_power_on(struct if_sdio_card *card);
0131 static int if_sdio_power_off(struct if_sdio_card *card);
0132 
0133 /********************************************************************/
0134 /* I/O                                                              */
0135 /********************************************************************/
0136 
0137 /*
0138  *  For SD8385/SD8686, this function reads firmware status after
0139  *  the image is downloaded, or reads RX packet length when
0140  *  interrupt (with IF_SDIO_H_INT_UPLD bit set) is received.
0141  *  For SD8688, this function reads firmware status only.
0142  */
0143 static u16 if_sdio_read_scratch(struct if_sdio_card *card, int *err)
0144 {
0145     int ret;
0146     u16 scratch;
0147 
0148     scratch = sdio_readb(card->func, card->scratch_reg, &ret);
0149     if (!ret)
0150         scratch |= sdio_readb(card->func, card->scratch_reg + 1,
0151                     &ret) << 8;
0152 
0153     if (err)
0154         *err = ret;
0155 
0156     if (ret)
0157         return 0xffff;
0158 
0159     return scratch;
0160 }
0161 
0162 static u8 if_sdio_read_rx_unit(struct if_sdio_card *card)
0163 {
0164     int ret;
0165     u8 rx_unit;
0166 
0167     rx_unit = sdio_readb(card->func, IF_SDIO_RX_UNIT, &ret);
0168 
0169     if (ret)
0170         rx_unit = 0;
0171 
0172     return rx_unit;
0173 }
0174 
0175 static u16 if_sdio_read_rx_len(struct if_sdio_card *card, int *err)
0176 {
0177     int ret;
0178     u16 rx_len;
0179 
0180     switch (card->model) {
0181     case MODEL_8385:
0182     case MODEL_8686:
0183         rx_len = if_sdio_read_scratch(card, &ret);
0184         break;
0185     case MODEL_8688:
0186     default: /* for newer chipsets */
0187         rx_len = sdio_readb(card->func, IF_SDIO_RX_LEN, &ret);
0188         if (!ret)
0189             rx_len <<= card->rx_unit;
0190         else
0191             rx_len = 0xffff;    /* invalid length */
0192 
0193         break;
0194     }
0195 
0196     if (err)
0197         *err = ret;
0198 
0199     return rx_len;
0200 }
0201 
0202 static int if_sdio_handle_cmd(struct if_sdio_card *card,
0203         u8 *buffer, unsigned size)
0204 {
0205     struct lbs_private *priv = card->priv;
0206     int ret;
0207     unsigned long flags;
0208     u8 i;
0209 
0210     if (size > LBS_CMD_BUFFER_SIZE) {
0211         lbs_deb_sdio("response packet too large (%d bytes)\n",
0212             (int)size);
0213         ret = -E2BIG;
0214         goto out;
0215     }
0216 
0217     spin_lock_irqsave(&priv->driver_lock, flags);
0218 
0219     i = (priv->resp_idx == 0) ? 1 : 0;
0220     BUG_ON(priv->resp_len[i]);
0221     priv->resp_len[i] = size;
0222     memcpy(priv->resp_buf[i], buffer, size);
0223     lbs_notify_command_response(priv, i);
0224 
0225     spin_unlock_irqrestore(&priv->driver_lock, flags);
0226 
0227     ret = 0;
0228 
0229 out:
0230     return ret;
0231 }
0232 
0233 static int if_sdio_handle_data(struct if_sdio_card *card,
0234         u8 *buffer, unsigned size)
0235 {
0236     int ret;
0237     struct sk_buff *skb;
0238 
0239     if (size > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) {
0240         lbs_deb_sdio("response packet too large (%d bytes)\n",
0241             (int)size);
0242         ret = -E2BIG;
0243         goto out;
0244     }
0245 
0246     skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + NET_IP_ALIGN);
0247     if (!skb) {
0248         ret = -ENOMEM;
0249         goto out;
0250     }
0251 
0252     skb_reserve(skb, NET_IP_ALIGN);
0253 
0254     skb_put_data(skb, buffer, size);
0255 
0256     lbs_process_rxed_packet(card->priv, skb);
0257 
0258     ret = 0;
0259 
0260 out:
0261     return ret;
0262 }
0263 
0264 static int if_sdio_handle_event(struct if_sdio_card *card,
0265         u8 *buffer, unsigned size)
0266 {
0267     int ret;
0268     u32 event;
0269 
0270     if (card->model == MODEL_8385) {
0271         event = sdio_readb(card->func, IF_SDIO_EVENT, &ret);
0272         if (ret)
0273             goto out;
0274 
0275         /* right shift 3 bits to get the event id */
0276         event >>= 3;
0277     } else {
0278         if (size < 4) {
0279             lbs_deb_sdio("event packet too small (%d bytes)\n",
0280                 (int)size);
0281             ret = -EINVAL;
0282             goto out;
0283         }
0284         event = buffer[3] << 24;
0285         event |= buffer[2] << 16;
0286         event |= buffer[1] << 8;
0287         event |= buffer[0] << 0;
0288     }
0289 
0290     lbs_queue_event(card->priv, event & 0xFF);
0291     ret = 0;
0292 
0293 out:
0294     return ret;
0295 }
0296 
0297 static int if_sdio_wait_status(struct if_sdio_card *card, const u8 condition)
0298 {
0299     u8 status;
0300     unsigned long timeout;
0301     int ret = 0;
0302 
0303     timeout = jiffies + HZ;
0304     while (1) {
0305         status = sdio_readb(card->func, IF_SDIO_STATUS, &ret);
0306         if (ret)
0307             return ret;
0308         if ((status & condition) == condition)
0309             break;
0310         if (time_after(jiffies, timeout))
0311             return -ETIMEDOUT;
0312         mdelay(1);
0313     }
0314     return ret;
0315 }
0316 
0317 static int if_sdio_card_to_host(struct if_sdio_card *card)
0318 {
0319     int ret;
0320     u16 size, type, chunk;
0321 
0322     size = if_sdio_read_rx_len(card, &ret);
0323     if (ret)
0324         goto out;
0325 
0326     if (size < 4) {
0327         lbs_deb_sdio("invalid packet size (%d bytes) from firmware\n",
0328             (int)size);
0329         ret = -EINVAL;
0330         goto out;
0331     }
0332 
0333     ret = if_sdio_wait_status(card, IF_SDIO_IO_RDY);
0334     if (ret)
0335         goto out;
0336 
0337     /*
0338      * The transfer must be in one transaction or the firmware
0339      * goes suicidal. There's no way to guarantee that for all
0340      * controllers, but we can at least try.
0341      */
0342     chunk = sdio_align_size(card->func, size);
0343 
0344     ret = sdio_readsb(card->func, card->buffer, card->ioport, chunk);
0345     if (ret)
0346         goto out;
0347 
0348     chunk = card->buffer[0] | (card->buffer[1] << 8);
0349     type = card->buffer[2] | (card->buffer[3] << 8);
0350 
0351     lbs_deb_sdio("packet of type %d and size %d bytes\n",
0352         (int)type, (int)chunk);
0353 
0354     if (chunk > size) {
0355         lbs_deb_sdio("packet fragment (%d > %d)\n",
0356             (int)chunk, (int)size);
0357         ret = -EINVAL;
0358         goto out;
0359     }
0360 
0361     if (chunk < size) {
0362         lbs_deb_sdio("packet fragment (%d < %d)\n",
0363             (int)chunk, (int)size);
0364     }
0365 
0366     switch (type) {
0367     case MVMS_CMD:
0368         ret = if_sdio_handle_cmd(card, card->buffer + 4, chunk - 4);
0369         if (ret)
0370             goto out;
0371         break;
0372     case MVMS_DAT:
0373         ret = if_sdio_handle_data(card, card->buffer + 4, chunk - 4);
0374         if (ret)
0375             goto out;
0376         break;
0377     case MVMS_EVENT:
0378         ret = if_sdio_handle_event(card, card->buffer + 4, chunk - 4);
0379         if (ret)
0380             goto out;
0381         break;
0382     default:
0383         lbs_deb_sdio("invalid type (%d) from firmware\n",
0384                 (int)type);
0385         ret = -EINVAL;
0386         goto out;
0387     }
0388 
0389 out:
0390     if (ret)
0391         pr_err("problem fetching packet from firmware\n");
0392 
0393     return ret;
0394 }
0395 
0396 static void if_sdio_host_to_card_worker(struct work_struct *work)
0397 {
0398     struct if_sdio_card *card;
0399     struct if_sdio_packet *packet;
0400     int ret;
0401     unsigned long flags;
0402 
0403     card = container_of(work, struct if_sdio_card, packet_worker);
0404 
0405     while (1) {
0406         spin_lock_irqsave(&card->lock, flags);
0407         packet = card->packets;
0408         if (packet)
0409             card->packets = packet->next;
0410         spin_unlock_irqrestore(&card->lock, flags);
0411 
0412         if (!packet)
0413             break;
0414 
0415         sdio_claim_host(card->func);
0416 
0417         ret = if_sdio_wait_status(card, IF_SDIO_IO_RDY);
0418         if (ret == 0) {
0419             ret = sdio_writesb(card->func, card->ioport,
0420                        packet->buffer, packet->nb);
0421         }
0422 
0423         if (ret)
0424             pr_err("error %d sending packet to firmware\n", ret);
0425 
0426         sdio_release_host(card->func);
0427 
0428         kfree(packet);
0429     }
0430 }
0431 
0432 /********************************************************************/
0433 /* Firmware                                                         */
0434 /********************************************************************/
0435 
0436 #define FW_DL_READY_STATUS (IF_SDIO_IO_RDY | IF_SDIO_DL_RDY)
0437 
0438 static int if_sdio_prog_helper(struct if_sdio_card *card,
0439                 const struct firmware *fw)
0440 {
0441     int ret;
0442     unsigned long timeout;
0443     u8 *chunk_buffer;
0444     u32 chunk_size;
0445     const u8 *firmware;
0446     size_t size;
0447 
0448     chunk_buffer = kzalloc(64, GFP_KERNEL);
0449     if (!chunk_buffer) {
0450         ret = -ENOMEM;
0451         goto out;
0452     }
0453 
0454     sdio_claim_host(card->func);
0455 
0456     ret = sdio_set_block_size(card->func, 32);
0457     if (ret)
0458         goto release;
0459 
0460     firmware = fw->data;
0461     size = fw->size;
0462 
0463     while (size) {
0464         ret = if_sdio_wait_status(card, FW_DL_READY_STATUS);
0465         if (ret)
0466             goto release;
0467 
0468         /* On some platforms (like Davinci) the chip needs more time
0469          * between helper blocks.
0470          */
0471         mdelay(2);
0472 
0473         chunk_size = min_t(size_t, size, 60);
0474 
0475         *((__le32*)chunk_buffer) = cpu_to_le32(chunk_size);
0476         memcpy(chunk_buffer + 4, firmware, chunk_size);
0477 /*
0478         lbs_deb_sdio("sending %d bytes chunk\n", chunk_size);
0479 */
0480         ret = sdio_writesb(card->func, card->ioport,
0481                 chunk_buffer, 64);
0482         if (ret)
0483             goto release;
0484 
0485         firmware += chunk_size;
0486         size -= chunk_size;
0487     }
0488 
0489     /* an empty block marks the end of the transfer */
0490     memset(chunk_buffer, 0, 4);
0491     ret = sdio_writesb(card->func, card->ioport, chunk_buffer, 64);
0492     if (ret)
0493         goto release;
0494 
0495     lbs_deb_sdio("waiting for helper to boot...\n");
0496 
0497     /* wait for the helper to boot by looking at the size register */
0498     timeout = jiffies + HZ;
0499     while (1) {
0500         u16 req_size;
0501 
0502         req_size = sdio_readb(card->func, IF_SDIO_RD_BASE, &ret);
0503         if (ret)
0504             goto release;
0505 
0506         req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1, &ret) << 8;
0507         if (ret)
0508             goto release;
0509 
0510         if (req_size != 0)
0511             break;
0512 
0513         if (time_after(jiffies, timeout)) {
0514             ret = -ETIMEDOUT;
0515             goto release;
0516         }
0517 
0518         msleep(10);
0519     }
0520 
0521     ret = 0;
0522 
0523 release:
0524     sdio_release_host(card->func);
0525     kfree(chunk_buffer);
0526 
0527 out:
0528     if (ret)
0529         pr_err("failed to load helper firmware\n");
0530 
0531     return ret;
0532 }
0533 
0534 static int if_sdio_prog_real(struct if_sdio_card *card,
0535                 const struct firmware *fw)
0536 {
0537     int ret;
0538     unsigned long timeout;
0539     u8 *chunk_buffer;
0540     u32 chunk_size;
0541     const u8 *firmware;
0542     size_t size, req_size;
0543 
0544     chunk_buffer = kzalloc(512, GFP_KERNEL);
0545     if (!chunk_buffer) {
0546         ret = -ENOMEM;
0547         goto out;
0548     }
0549 
0550     sdio_claim_host(card->func);
0551 
0552     ret = sdio_set_block_size(card->func, 32);
0553     if (ret)
0554         goto release;
0555 
0556     firmware = fw->data;
0557     size = fw->size;
0558 
0559     while (size) {
0560         timeout = jiffies + HZ;
0561         while (1) {
0562             ret = if_sdio_wait_status(card, FW_DL_READY_STATUS);
0563             if (ret)
0564                 goto release;
0565 
0566             req_size = sdio_readb(card->func, IF_SDIO_RD_BASE,
0567                     &ret);
0568             if (ret)
0569                 goto release;
0570 
0571             req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1,
0572                     &ret) << 8;
0573             if (ret)
0574                 goto release;
0575 
0576             /*
0577              * For SD8688 wait until the length is not 0, 1 or 2
0578              * before downloading the first FW block,
0579              * since BOOT code writes the register to indicate the
0580              * helper/FW download winner,
0581              * the value could be 1 or 2 (Func1 or Func2).
0582              */
0583             if ((size != fw->size) || (req_size > 2))
0584                 break;
0585             if (time_after(jiffies, timeout)) {
0586                 ret = -ETIMEDOUT;
0587                 goto release;
0588             }
0589             mdelay(1);
0590         }
0591 
0592 /*
0593         lbs_deb_sdio("firmware wants %d bytes\n", (int)req_size);
0594 */
0595         if (req_size == 0) {
0596             lbs_deb_sdio("firmware helper gave up early\n");
0597             ret = -EIO;
0598             goto release;
0599         }
0600 
0601         if (req_size & 0x01) {
0602             lbs_deb_sdio("firmware helper signalled error\n");
0603             ret = -EIO;
0604             goto release;
0605         }
0606 
0607         if (req_size > size)
0608             req_size = size;
0609 
0610         while (req_size) {
0611             chunk_size = min_t(size_t, req_size, 512);
0612 
0613             memcpy(chunk_buffer, firmware, chunk_size);
0614 /*
0615             lbs_deb_sdio("sending %d bytes (%d bytes) chunk\n",
0616                 chunk_size, (chunk_size + 31) / 32 * 32);
0617 */
0618             ret = sdio_writesb(card->func, card->ioport,
0619                 chunk_buffer, roundup(chunk_size, 32));
0620             if (ret)
0621                 goto release;
0622 
0623             firmware += chunk_size;
0624             size -= chunk_size;
0625             req_size -= chunk_size;
0626         }
0627     }
0628 
0629     ret = 0;
0630 
0631     lbs_deb_sdio("waiting for firmware to boot...\n");
0632 
0633     /* wait for the firmware to boot */
0634     timeout = jiffies + HZ;
0635     while (1) {
0636         u16 scratch;
0637 
0638         scratch = if_sdio_read_scratch(card, &ret);
0639         if (ret)
0640             goto release;
0641 
0642         if (scratch == IF_SDIO_FIRMWARE_OK)
0643             break;
0644 
0645         if (time_after(jiffies, timeout)) {
0646             ret = -ETIMEDOUT;
0647             goto release;
0648         }
0649 
0650         msleep(10);
0651     }
0652 
0653     ret = 0;
0654 
0655 release:
0656     sdio_release_host(card->func);
0657     kfree(chunk_buffer);
0658 
0659 out:
0660     if (ret)
0661         pr_err("failed to load firmware\n");
0662 
0663     return ret;
0664 }
0665 
0666 static void if_sdio_do_prog_firmware(struct lbs_private *priv, int ret,
0667                      const struct firmware *helper,
0668                      const struct firmware *mainfw)
0669 {
0670     struct if_sdio_card *card = priv->card;
0671 
0672     if (ret) {
0673         pr_err("failed to find firmware (%d)\n", ret);
0674         return;
0675     }
0676 
0677     ret = if_sdio_prog_helper(card, helper);
0678     if (ret)
0679         return;
0680 
0681     lbs_deb_sdio("Helper firmware loaded\n");
0682 
0683     ret = if_sdio_prog_real(card, mainfw);
0684     if (ret)
0685         return;
0686 
0687     lbs_deb_sdio("Firmware loaded\n");
0688     if_sdio_finish_power_on(card);
0689 }
0690 
0691 static int if_sdio_prog_firmware(struct if_sdio_card *card)
0692 {
0693     int ret;
0694     u16 scratch;
0695 
0696     /*
0697      * Disable interrupts
0698      */
0699     sdio_claim_host(card->func);
0700     sdio_writeb(card->func, 0x00, IF_SDIO_H_INT_MASK, &ret);
0701     sdio_release_host(card->func);
0702 
0703     sdio_claim_host(card->func);
0704     scratch = if_sdio_read_scratch(card, &ret);
0705     sdio_release_host(card->func);
0706 
0707     lbs_deb_sdio("firmware status = %#x\n", scratch);
0708     lbs_deb_sdio("scratch ret = %d\n", ret);
0709 
0710     if (ret)
0711         goto out;
0712 
0713 
0714     /*
0715      * The manual clearly describes that FEDC is the right code to use
0716      * to detect firmware presence, but for SD8686 it is not that simple.
0717      * Scratch is also used to store the RX packet length, so we lose
0718      * the FEDC value early on. So we use a non-zero check in order
0719      * to validate firmware presence.
0720      * Additionally, the SD8686 in the Gumstix always has the high scratch
0721      * bit set, even when the firmware is not loaded. So we have to
0722      * exclude that from the test.
0723      */
0724     if (scratch == IF_SDIO_FIRMWARE_OK) {
0725         lbs_deb_sdio("firmware already loaded\n");
0726         if_sdio_finish_power_on(card);
0727         return 0;
0728     } else if ((card->model == MODEL_8686) && (scratch & 0x7fff)) {
0729         lbs_deb_sdio("firmware may be running\n");
0730         if_sdio_finish_power_on(card);
0731         return 0;
0732     }
0733 
0734     ret = lbs_get_firmware_async(card->priv, &card->func->dev, card->model,
0735                      fw_table, if_sdio_do_prog_firmware);
0736 
0737 out:
0738     return ret;
0739 }
0740 
0741 /********************************************************************/
0742 /* Power management                                                 */
0743 /********************************************************************/
0744 
0745 /* Finish power on sequence (after firmware is loaded) */
0746 static void if_sdio_finish_power_on(struct if_sdio_card *card)
0747 {
0748     struct sdio_func *func = card->func;
0749     struct lbs_private *priv = card->priv;
0750     int ret;
0751 
0752     sdio_claim_host(func);
0753     sdio_set_block_size(card->func, IF_SDIO_BLOCK_SIZE);
0754 
0755     /*
0756      * Get rx_unit if the chip is SD8688 or newer.
0757      * SD8385 & SD8686 do not have rx_unit.
0758      */
0759     if ((card->model != MODEL_8385)
0760             && (card->model != MODEL_8686))
0761         card->rx_unit = if_sdio_read_rx_unit(card);
0762     else
0763         card->rx_unit = 0;
0764 
0765     /*
0766      * Set up the interrupt handler late.
0767      *
0768      * If we set it up earlier, the (buggy) hardware generates a spurious
0769      * interrupt, even before the interrupt has been enabled, with
0770      * CCCR_INTx = 0.
0771      *
0772      * We register the interrupt handler late so that we can handle any
0773      * spurious interrupts, and also to avoid generation of that known
0774      * spurious interrupt in the first place.
0775      */
0776     ret = sdio_claim_irq(func, if_sdio_interrupt);
0777     if (ret)
0778         goto release;
0779 
0780     /*
0781      * Enable interrupts now that everything is set up
0782      */
0783     sdio_writeb(func, 0x0f, IF_SDIO_H_INT_MASK, &ret);
0784     if (ret)
0785         goto release_irq;
0786 
0787     sdio_release_host(func);
0788 
0789     /* Set fw_ready before queuing any commands so that
0790      * lbs_thread won't block from sending them to firmware.
0791      */
0792     priv->fw_ready = 1;
0793 
0794     /*
0795      * FUNC_INIT is required for SD8688 WLAN/BT multiple functions
0796      */
0797     if (card->model == MODEL_8688) {
0798         struct cmd_header cmd;
0799 
0800         memset(&cmd, 0, sizeof(cmd));
0801 
0802         lbs_deb_sdio("send function INIT command\n");
0803         if (__lbs_cmd(priv, CMD_FUNC_INIT, &cmd, sizeof(cmd),
0804                 lbs_cmd_copyback, (unsigned long) &cmd))
0805             netdev_alert(priv->dev, "CMD_FUNC_INIT cmd failed\n");
0806     }
0807 
0808     wake_up(&card->pwron_waitq);
0809 
0810     if (!card->started) {
0811         ret = lbs_start_card(priv);
0812         if_sdio_power_off(card);
0813         if (ret == 0) {
0814             card->started = true;
0815             /* Tell PM core that we don't need the card to be
0816              * powered now */
0817             pm_runtime_put(&func->dev);
0818         }
0819     }
0820 
0821     return;
0822 
0823 release_irq:
0824     sdio_release_irq(func);
0825 release:
0826     sdio_release_host(func);
0827 }
0828 
0829 static int if_sdio_power_on(struct if_sdio_card *card)
0830 {
0831     struct sdio_func *func = card->func;
0832     struct mmc_host *host = func->card->host;
0833     int ret;
0834 
0835     sdio_claim_host(func);
0836 
0837     ret = sdio_enable_func(func);
0838     if (ret)
0839         goto release;
0840 
0841     /* For 1-bit transfers to the 8686 model, we need to enable the
0842      * interrupt flag in the CCCR register. Set the MMC_QUIRK_LENIENT_FN0
0843      * bit to allow access to non-vendor registers. */
0844     if ((card->model == MODEL_8686) &&
0845         (host->caps & MMC_CAP_SDIO_IRQ) &&
0846         (host->ios.bus_width == MMC_BUS_WIDTH_1)) {
0847         u8 reg;
0848 
0849         func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
0850         reg = sdio_f0_readb(func, SDIO_CCCR_IF, &ret);
0851         if (ret)
0852             goto disable;
0853 
0854         reg |= SDIO_BUS_ECSI;
0855         sdio_f0_writeb(func, reg, SDIO_CCCR_IF, &ret);
0856         if (ret)
0857             goto disable;
0858     }
0859 
0860     card->ioport = sdio_readb(func, IF_SDIO_IOPORT, &ret);
0861     if (ret)
0862         goto disable;
0863 
0864     card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 1, &ret) << 8;
0865     if (ret)
0866         goto disable;
0867 
0868     card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 2, &ret) << 16;
0869     if (ret)
0870         goto disable;
0871 
0872     sdio_release_host(func);
0873     ret = if_sdio_prog_firmware(card);
0874     if (ret) {
0875         sdio_claim_host(func);
0876         goto disable;
0877     }
0878 
0879     return 0;
0880 
0881 disable:
0882     sdio_disable_func(func);
0883 release:
0884     sdio_release_host(func);
0885     return ret;
0886 }
0887 
0888 static int if_sdio_power_off(struct if_sdio_card *card)
0889 {
0890     struct sdio_func *func = card->func;
0891     struct lbs_private *priv = card->priv;
0892 
0893     priv->fw_ready = 0;
0894 
0895     sdio_claim_host(func);
0896     sdio_release_irq(func);
0897     sdio_disable_func(func);
0898     sdio_release_host(func);
0899     return 0;
0900 }
0901 
0902 
0903 /*******************************************************************/
0904 /* Libertas callbacks                                              */
0905 /*******************************************************************/
0906 
0907 static int if_sdio_host_to_card(struct lbs_private *priv,
0908         u8 type, u8 *buf, u16 nb)
0909 {
0910     int ret;
0911     struct if_sdio_card *card;
0912     struct if_sdio_packet *packet, *cur;
0913     u16 size;
0914     unsigned long flags;
0915 
0916     card = priv->card;
0917 
0918     if (nb > (65536 - sizeof(struct if_sdio_packet) - 4)) {
0919         ret = -EINVAL;
0920         goto out;
0921     }
0922 
0923     /*
0924      * The transfer must be in one transaction or the firmware
0925      * goes suicidal. There's no way to guarantee that for all
0926      * controllers, but we can at least try.
0927      */
0928     size = sdio_align_size(card->func, nb + 4);
0929 
0930     packet = kzalloc(sizeof(struct if_sdio_packet) + size,
0931             GFP_ATOMIC);
0932     if (!packet) {
0933         ret = -ENOMEM;
0934         goto out;
0935     }
0936 
0937     packet->next = NULL;
0938     packet->nb = size;
0939 
0940     /*
0941      * SDIO specific header.
0942      */
0943     packet->buffer[0] = (nb + 4) & 0xff;
0944     packet->buffer[1] = ((nb + 4) >> 8) & 0xff;
0945     packet->buffer[2] = type;
0946     packet->buffer[3] = 0;
0947 
0948     memcpy(packet->buffer + 4, buf, nb);
0949 
0950     spin_lock_irqsave(&card->lock, flags);
0951 
0952     if (!card->packets)
0953         card->packets = packet;
0954     else {
0955         cur = card->packets;
0956         while (cur->next)
0957             cur = cur->next;
0958         cur->next = packet;
0959     }
0960 
0961     switch (type) {
0962     case MVMS_CMD:
0963         priv->dnld_sent = DNLD_CMD_SENT;
0964         break;
0965     case MVMS_DAT:
0966         priv->dnld_sent = DNLD_DATA_SENT;
0967         break;
0968     default:
0969         lbs_deb_sdio("unknown packet type %d\n", (int)type);
0970     }
0971 
0972     spin_unlock_irqrestore(&card->lock, flags);
0973 
0974     queue_work(card->workqueue, &card->packet_worker);
0975 
0976     ret = 0;
0977 
0978 out:
0979     return ret;
0980 }
0981 
0982 static int if_sdio_enter_deep_sleep(struct lbs_private *priv)
0983 {
0984     int ret;
0985     struct cmd_header cmd;
0986 
0987     memset(&cmd, 0, sizeof(cmd));
0988 
0989     lbs_deb_sdio("send DEEP_SLEEP command\n");
0990     ret = __lbs_cmd(priv, CMD_802_11_DEEP_SLEEP, &cmd, sizeof(cmd),
0991             lbs_cmd_copyback, (unsigned long) &cmd);
0992     if (ret)
0993         netdev_err(priv->dev, "DEEP_SLEEP cmd failed\n");
0994 
0995     mdelay(200);
0996     return ret;
0997 }
0998 
0999 static int if_sdio_exit_deep_sleep(struct lbs_private *priv)
1000 {
1001     struct if_sdio_card *card = priv->card;
1002     int ret = -1;
1003 
1004     sdio_claim_host(card->func);
1005 
1006     sdio_writeb(card->func, HOST_POWER_UP, CONFIGURATION_REG, &ret);
1007     if (ret)
1008         netdev_err(priv->dev, "sdio_writeb failed!\n");
1009 
1010     sdio_release_host(card->func);
1011 
1012     return ret;
1013 }
1014 
1015 static int if_sdio_reset_deep_sleep_wakeup(struct lbs_private *priv)
1016 {
1017     struct if_sdio_card *card = priv->card;
1018     int ret = -1;
1019 
1020     sdio_claim_host(card->func);
1021 
1022     sdio_writeb(card->func, 0, CONFIGURATION_REG, &ret);
1023     if (ret)
1024         netdev_err(priv->dev, "sdio_writeb failed!\n");
1025 
1026     sdio_release_host(card->func);
1027 
1028     return ret;
1029 
1030 }
1031 
1032 static struct mmc_host *reset_host;
1033 
1034 static void if_sdio_reset_card_worker(struct work_struct *work)
1035 {
1036     /*
1037      * The actual reset operation must be run outside of lbs_thread. This
1038      * is because mmc_remove_host() will cause the device to be instantly
1039      * destroyed, and the libertas driver then needs to end lbs_thread,
1040      * leading to a deadlock.
1041      *
1042      * We run it in a workqueue totally independent from the if_sdio_card
1043      * instance for that reason.
1044      */
1045 
1046     pr_info("Resetting card...");
1047     mmc_remove_host(reset_host);
1048     mmc_add_host(reset_host);
1049 }
1050 static DECLARE_WORK(card_reset_work, if_sdio_reset_card_worker);
1051 
1052 static void if_sdio_reset_card(struct lbs_private *priv)
1053 {
1054     struct if_sdio_card *card = priv->card;
1055 
1056     if (work_pending(&card_reset_work))
1057         return;
1058 
1059     reset_host = card->func->card->host;
1060     schedule_work(&card_reset_work);
1061 }
1062 
1063 static int if_sdio_power_save(struct lbs_private *priv)
1064 {
1065     struct if_sdio_card *card = priv->card;
1066     int ret;
1067 
1068     flush_workqueue(card->workqueue);
1069 
1070     ret = if_sdio_power_off(card);
1071 
1072     /* Let runtime PM know the card is powered off */
1073     pm_runtime_put_sync(&card->func->dev);
1074 
1075     return ret;
1076 }
1077 
1078 static int if_sdio_power_restore(struct lbs_private *priv)
1079 {
1080     struct if_sdio_card *card = priv->card;
1081     int r;
1082 
1083     /* Make sure the card will not be powered off by runtime PM */
1084     pm_runtime_get_sync(&card->func->dev);
1085 
1086     r = if_sdio_power_on(card);
1087     if (r)
1088         return r;
1089 
1090     wait_event(card->pwron_waitq, priv->fw_ready);
1091     return 0;
1092 }
1093 
1094 
1095 /*******************************************************************/
1096 /* SDIO callbacks                                                  */
1097 /*******************************************************************/
1098 
1099 static void if_sdio_interrupt(struct sdio_func *func)
1100 {
1101     int ret;
1102     struct if_sdio_card *card;
1103     u8 cause;
1104 
1105     card = sdio_get_drvdata(func);
1106 
1107     cause = sdio_readb(card->func, IF_SDIO_H_INT_STATUS, &ret);
1108     if (ret || !cause)
1109         return;
1110 
1111     lbs_deb_sdio("interrupt: 0x%X\n", (unsigned)cause);
1112 
1113     sdio_writeb(card->func, ~cause, IF_SDIO_H_INT_STATUS, &ret);
1114     if (ret)
1115         return;
1116 
1117     /*
1118      * Ignore the define name, this really means the card has
1119      * successfully received the command.
1120      */
1121     card->priv->is_activity_detected = 1;
1122     if (cause & IF_SDIO_H_INT_DNLD)
1123         lbs_host_to_card_done(card->priv);
1124 
1125 
1126     if (cause & IF_SDIO_H_INT_UPLD) {
1127         ret = if_sdio_card_to_host(card);
1128         if (ret)
1129             return;
1130     }
1131 }
1132 
1133 static int if_sdio_probe(struct sdio_func *func,
1134         const struct sdio_device_id *id)
1135 {
1136     struct if_sdio_card *card;
1137     struct lbs_private *priv;
1138     int ret, i;
1139     unsigned int model;
1140     struct if_sdio_packet *packet;
1141 
1142     for (i = 0;i < func->card->num_info;i++) {
1143         if (sscanf(func->card->info[i],
1144                 "802.11 SDIO ID: %x", &model) == 1)
1145             break;
1146         if (sscanf(func->card->info[i],
1147                 "ID: %x", &model) == 1)
1148             break;
1149         if (!strcmp(func->card->info[i], "IBIS Wireless SDIO Card")) {
1150             model = MODEL_8385;
1151             break;
1152         }
1153     }
1154 
1155     if (i == func->card->num_info) {
1156         pr_err("unable to identify card model\n");
1157         return -ENODEV;
1158     }
1159 
1160     card = kzalloc(sizeof(struct if_sdio_card), GFP_KERNEL);
1161     if (!card)
1162         return -ENOMEM;
1163 
1164     card->func = func;
1165     card->model = model;
1166 
1167     switch (card->model) {
1168     case MODEL_8385:
1169         card->scratch_reg = IF_SDIO_SCRATCH_OLD;
1170         break;
1171     case MODEL_8686:
1172         card->scratch_reg = IF_SDIO_SCRATCH;
1173         break;
1174     case MODEL_8688:
1175     default: /* for newer chipsets */
1176         card->scratch_reg = IF_SDIO_FW_STATUS;
1177         break;
1178     }
1179 
1180     spin_lock_init(&card->lock);
1181     card->workqueue = alloc_workqueue("libertas_sdio", WQ_MEM_RECLAIM, 0);
1182     if (unlikely(!card->workqueue)) {
1183         ret = -ENOMEM;
1184         goto err_queue;
1185     }
1186     INIT_WORK(&card->packet_worker, if_sdio_host_to_card_worker);
1187     init_waitqueue_head(&card->pwron_waitq);
1188 
1189     /* Check if we support this card */
1190     for (i = 0; i < ARRAY_SIZE(fw_table); i++) {
1191         if (card->model == fw_table[i].model)
1192             break;
1193     }
1194     if (i == ARRAY_SIZE(fw_table)) {
1195         pr_err("unknown card model 0x%x\n", card->model);
1196         ret = -ENODEV;
1197         goto free;
1198     }
1199 
1200     sdio_set_drvdata(func, card);
1201 
1202     lbs_deb_sdio("class = 0x%X, vendor = 0x%X, "
1203             "device = 0x%X, model = 0x%X, ioport = 0x%X\n",
1204             func->class, func->vendor, func->device,
1205             model, (unsigned)card->ioport);
1206 
1207 
1208     priv = lbs_add_card(card, &func->dev);
1209     if (IS_ERR(priv)) {
1210         ret = PTR_ERR(priv);
1211         goto free;
1212     }
1213 
1214     card->priv = priv;
1215 
1216     priv->card = card;
1217     priv->hw_host_to_card = if_sdio_host_to_card;
1218     priv->enter_deep_sleep = if_sdio_enter_deep_sleep;
1219     priv->exit_deep_sleep = if_sdio_exit_deep_sleep;
1220     priv->reset_deep_sleep_wakeup = if_sdio_reset_deep_sleep_wakeup;
1221     priv->reset_card = if_sdio_reset_card;
1222     priv->power_save = if_sdio_power_save;
1223     priv->power_restore = if_sdio_power_restore;
1224     priv->is_polling = !(func->card->host->caps & MMC_CAP_SDIO_IRQ);
1225     ret = if_sdio_power_on(card);
1226     if (ret)
1227         goto err_activate_card;
1228 
1229 out:
1230     return ret;
1231 
1232 err_activate_card:
1233     flush_workqueue(card->workqueue);
1234     lbs_remove_card(priv);
1235 free:
1236     destroy_workqueue(card->workqueue);
1237 err_queue:
1238     while (card->packets) {
1239         packet = card->packets;
1240         card->packets = card->packets->next;
1241         kfree(packet);
1242     }
1243 
1244     kfree(card);
1245 
1246     goto out;
1247 }
1248 
1249 static void if_sdio_remove(struct sdio_func *func)
1250 {
1251     struct if_sdio_card *card;
1252     struct if_sdio_packet *packet;
1253 
1254     card = sdio_get_drvdata(func);
1255 
1256     /* Undo decrement done above in if_sdio_probe */
1257     pm_runtime_get_noresume(&func->dev);
1258 
1259     if (user_rmmod && (card->model == MODEL_8688)) {
1260         /*
1261          * FUNC_SHUTDOWN is required for SD8688 WLAN/BT
1262          * multiple functions
1263          */
1264         struct cmd_header cmd;
1265 
1266         memset(&cmd, 0, sizeof(cmd));
1267 
1268         lbs_deb_sdio("send function SHUTDOWN command\n");
1269         if (__lbs_cmd(card->priv, CMD_FUNC_SHUTDOWN,
1270                 &cmd, sizeof(cmd), lbs_cmd_copyback,
1271                 (unsigned long) &cmd))
1272             pr_alert("CMD_FUNC_SHUTDOWN cmd failed\n");
1273     }
1274 
1275 
1276     lbs_deb_sdio("call remove card\n");
1277     lbs_stop_card(card->priv);
1278     lbs_remove_card(card->priv);
1279 
1280     destroy_workqueue(card->workqueue);
1281 
1282     while (card->packets) {
1283         packet = card->packets;
1284         card->packets = card->packets->next;
1285         kfree(packet);
1286     }
1287 
1288     kfree(card);
1289 }
1290 
1291 static int if_sdio_suspend(struct device *dev)
1292 {
1293     struct sdio_func *func = dev_to_sdio_func(dev);
1294     struct if_sdio_card *card = sdio_get_drvdata(func);
1295     struct lbs_private *priv = card->priv;
1296     int ret;
1297 
1298     mmc_pm_flag_t flags = sdio_get_host_pm_caps(func);
1299     priv->power_up_on_resume = false;
1300 
1301     /* If we're powered off anyway, just let the mmc layer remove the
1302      * card. */
1303     if (!lbs_iface_active(priv)) {
1304         if (priv->fw_ready) {
1305             priv->power_up_on_resume = true;
1306             if_sdio_power_off(card);
1307         }
1308 
1309         return 0;
1310     }
1311 
1312     dev_info(dev, "%s: suspend: PM flags = 0x%x\n",
1313          sdio_func_id(func), flags);
1314 
1315     /* If we aren't being asked to wake on anything, we should bail out
1316      * and let the SD stack power down the card.
1317      */
1318     if (priv->wol_criteria == EHS_REMOVE_WAKEUP) {
1319         dev_info(dev, "Suspend without wake params -- powering down card\n");
1320         if (priv->fw_ready) {
1321             ret = lbs_suspend(priv);
1322             if (ret)
1323                 return ret;
1324 
1325             priv->power_up_on_resume = true;
1326             if_sdio_power_off(card);
1327         }
1328 
1329         return 0;
1330     }
1331 
1332     if (!(flags & MMC_PM_KEEP_POWER)) {
1333         dev_err(dev, "%s: cannot remain alive while host is suspended\n",
1334             sdio_func_id(func));
1335         return -ENOSYS;
1336     }
1337 
1338     ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
1339     if (ret)
1340         return ret;
1341 
1342     ret = lbs_suspend(priv);
1343     if (ret)
1344         return ret;
1345 
1346     return sdio_set_host_pm_flags(func, MMC_PM_WAKE_SDIO_IRQ);
1347 }
1348 
1349 static int if_sdio_resume(struct device *dev)
1350 {
1351     struct sdio_func *func = dev_to_sdio_func(dev);
1352     struct if_sdio_card *card = sdio_get_drvdata(func);
1353     int ret;
1354 
1355     dev_info(dev, "%s: resume: we're back\n", sdio_func_id(func));
1356 
1357     if (card->priv->power_up_on_resume) {
1358         if_sdio_power_on(card);
1359         wait_event(card->pwron_waitq, card->priv->fw_ready);
1360     }
1361 
1362     ret = lbs_resume(card->priv);
1363 
1364     return ret;
1365 }
1366 
1367 static const struct dev_pm_ops if_sdio_pm_ops = {
1368     .suspend    = if_sdio_suspend,
1369     .resume     = if_sdio_resume,
1370 };
1371 
1372 static struct sdio_driver if_sdio_driver = {
1373     .name       = "libertas_sdio",
1374     .id_table   = if_sdio_ids,
1375     .probe      = if_sdio_probe,
1376     .remove     = if_sdio_remove,
1377     .drv = {
1378         .pm = &if_sdio_pm_ops,
1379     },
1380 };
1381 
1382 /*******************************************************************/
1383 /* Module functions                                                */
1384 /*******************************************************************/
1385 
1386 static int __init if_sdio_init_module(void)
1387 {
1388     int ret = 0;
1389 
1390     printk(KERN_INFO "libertas_sdio: Libertas SDIO driver\n");
1391     printk(KERN_INFO "libertas_sdio: Copyright Pierre Ossman\n");
1392 
1393     ret = sdio_register_driver(&if_sdio_driver);
1394 
1395     /* Clear the flag in case user removes the card. */
1396     user_rmmod = 0;
1397 
1398     return ret;
1399 }
1400 
1401 static void __exit if_sdio_exit_module(void)
1402 {
1403     /* Set the flag as user is removing this module. */
1404     user_rmmod = 1;
1405 
1406     cancel_work_sync(&card_reset_work);
1407 
1408     sdio_unregister_driver(&if_sdio_driver);
1409 }
1410 
1411 module_init(if_sdio_init_module);
1412 module_exit(if_sdio_exit_module);
1413 
1414 MODULE_DESCRIPTION("Libertas SDIO WLAN Driver");
1415 MODULE_AUTHOR("Pierre Ossman");
1416 MODULE_LICENSE("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!