/* * linux/drivers/net/wireless/libertas/if_sdio.c * * Copyright 2007-2008 Pierre Ossman * * Inspired by if_cs.c, Copyright 2007 Holger Schurig * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or (at * your option) any later version. * * This hardware has more or less no CMD53 support, so all registers * must be accessed using sdio_readb()/sdio_writeb(). * * Transfers must be in one transaction or the firmware goes bonkers. * This means that the transfer must either be small enough to do a * byte based transfer or it must be padded to a multiple of the * current block size. * * As SDIO is still new to the kernel, it is unfortunately common with * bugs in the host controllers related to that. One such bug is that * controllers cannot do transfers that aren't a multiple of 4 bytes. * If you don't have time to fix the host controller driver, you can * work around the problem by modifying if_sdio_host_to_card() and * if_sdio_card_to_host() to pad the data. */ #include <linux/kernel.h> #include <linux/moduleparam.h> #include <linux/slab.h> #include <linux/firmware.h> #include <linux/netdevice.h> #include <linux/delay.h> #include <linux/mmc/card.h> #include <linux/mmc/sdio_func.h> #include <linux/mmc/sdio_ids.h> #include <linux/mmc/sdio.h> #include <linux/mmc/host.h> #include "host.h" #include "decl.h" #include "defs.h" #include "dev.h" #include "cmd.h" #include "if_sdio.h" /* The if_sdio_remove() callback function is called when * user removes this module from kernel space or ejects * the card from the slot. The driver handles these 2 cases * differently for SD8688 combo chip. * If the user is removing the module, the FUNC_SHUTDOWN * command for SD8688 is sent to the firmware. * If the card is removed, there is no need to send this command. * * The variable 'user_rmmod' is used to distinguish these two * scenarios. This flag is initialized as FALSE in case the card * is removed, and will be set to TRUE for module removal when * module_exit function is called. */ static u8 user_rmmod; static char *lbs_helper_name = NULL; module_param_named(helper_name, lbs_helper_name, charp, 0644); static char *lbs_fw_name = NULL; module_param_named(fw_name, lbs_fw_name, charp, 0644); static const struct sdio_device_id if_sdio_ids[] = { { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_LIBERTAS) }, { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8688WLAN) }, { /* end: all zeroes */ }, }; MODULE_DEVICE_TABLE(sdio, if_sdio_ids); struct if_sdio_model { int model; const char *helper; const char *firmware; }; static struct if_sdio_model if_sdio_models[] = { { /* 8385 */ .model = IF_SDIO_MODEL_8385, .helper = "sd8385_helper.bin", .firmware = "sd8385.bin", }, { /* 8686 */ .model = IF_SDIO_MODEL_8686, .helper = "sd8686_helper.bin", .firmware = "sd8686.bin", }, { /* 8688 */ .model = IF_SDIO_MODEL_8688, .helper = "sd8688_helper.bin", .firmware = "sd8688.bin", }, }; MODULE_FIRMWARE("sd8385_helper.bin"); MODULE_FIRMWARE("sd8385.bin"); MODULE_FIRMWARE("sd8686_helper.bin"); MODULE_FIRMWARE("sd8686.bin"); MODULE_FIRMWARE("sd8688_helper.bin"); MODULE_FIRMWARE("sd8688.bin"); struct if_sdio_packet { struct if_sdio_packet *next; u16 nb; u8 buffer[0] __attribute__((aligned(4))); }; struct if_sdio_card { struct sdio_func *func; struct lbs_private *priv; int model; unsigned long ioport; unsigned int scratch_reg; const char *helper; const char *firmware; u8 buffer[65536]; spinlock_t lock; struct if_sdio_packet *packets; struct workqueue_struct *workqueue; struct work_struct packet_worker; u8 rx_unit; }; /********************************************************************/ /* I/O */ /********************************************************************/ /* * For SD8385/SD8686, this function reads firmware status after * the image is downloaded, or reads RX packet length when * interrupt (with IF_SDIO_H_INT_UPLD bit set) is received. * For SD8688, this function reads firmware status only. */ static u16 if_sdio_read_scratch(struct if_sdio_card *card, int *err) { int ret; u16 scratch; scratch = sdio_readb(card->func, card->scratch_reg, &ret); if (!ret) scratch |= sdio_readb(card->func, card->scratch_reg + 1, &ret) << 8; if (err) *err = ret; if (ret) return 0xffff; return scratch; } static u8 if_sdio_read_rx_unit(struct if_sdio_card *card) { int ret; u8 rx_unit; rx_unit = sdio_readb(card->func, IF_SDIO_RX_UNIT, &ret); if (ret) rx_unit = 0; return rx_unit; } static u16 if_sdio_read_rx_len(struct if_sdio_card *card, int *err) { int ret; u16 rx_len; switch (card->model) { case IF_SDIO_MODEL_8385: case IF_SDIO_MODEL_8686: rx_len = if_sdio_read_scratch(card, &ret); break; case IF_SDIO_MODEL_8688: default: /* for newer chipsets */ rx_len = sdio_readb(card->func, IF_SDIO_RX_LEN, &ret); if (!ret) rx_len <<= card->rx_unit; else rx_len = 0xffff; /* invalid length */ break; } if (err) *err = ret; return rx_len; } static int if_sdio_handle_cmd(struct if_sdio_card *card, u8 *buffer, unsigned size) { struct lbs_private *priv = card->priv; int ret; unsigned long flags; u8 i; lbs_deb_enter(LBS_DEB_SDIO); if (size > LBS_CMD_BUFFER_SIZE) { lbs_deb_sdio("response packet too large (%d bytes)\n", (int)size); ret = -E2BIG; goto out; } spin_lock_irqsave(&priv->driver_lock, flags); i = (priv->resp_idx == 0) ? 1 : 0; BUG_ON(priv->resp_len[i]); priv->resp_len[i] = size; memcpy(priv->resp_buf[i], buffer, size); lbs_notify_command_response(priv, i); spin_unlock_irqrestore(&card->priv->driver_lock, flags); ret = 0; out: lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); return ret; } static int if_sdio_handle_data(struct if_sdio_card *card, u8 *buffer, unsigned size) { int ret; struct sk_buff *skb; char *data; lbs_deb_enter(LBS_DEB_SDIO); if (size > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) { lbs_deb_sdio("response packet too large (%d bytes)\n", (int)size); ret = -E2BIG; goto out; } skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + NET_IP_ALIGN); if (!skb) { ret = -ENOMEM; goto out; } skb_reserve(skb, NET_IP_ALIGN); data = skb_put(skb, size); memcpy(data, buffer, size); lbs_process_rxed_packet(card->priv, skb); ret = 0; out: lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); return ret; } static int if_sdio_handle_event(struct if_sdio_card *card, u8 *buffer, unsigned size) { int ret; u32 event; lbs_deb_enter(LBS_DEB_SDIO); if (card->model == IF_SDIO_MODEL_8385) { event = sdio_readb(card->func, IF_SDIO_EVENT, &ret); if (ret) goto out; /* right shift 3 bits to get the event id */ event >>= 3; } else { if (size < 4) { lbs_deb_sdio("event packet too small (%d bytes)\n", (int)size); ret = -EINVAL; goto out; } event = buffer[3] << 24; event |= buffer[2] << 16; event |= buffer[1] << 8; event |= buffer[0] << 0; } lbs_queue_event(card->priv, event & 0xFF); ret = 0; out: lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); return ret; } static int if_sdio_wait_status(struct if_sdio_card *card, const u8 condition) { u8 status; unsigned long timeout; int ret = 0; timeout = jiffies + HZ; while (1) { status = sdio_readb(card->func, IF_SDIO_STATUS, &ret); if (ret) return ret; if ((status & condition) == condition) break; if (time_after(jiffies, timeout)) return -ETIMEDOUT; mdelay(1); } return ret; } static int if_sdio_card_to_host(struct if_sdio_card *card) { int ret; u16 size, type, chunk; lbs_deb_enter(LBS_DEB_SDIO); size = if_sdio_read_rx_len(card, &ret); if (ret) goto out; if (size < 4) { lbs_deb_sdio("invalid packet size (%d bytes) from firmware\n", (int)size); ret = -EINVAL; goto out; } ret = if_sdio_wait_status(card, IF_SDIO_IO_RDY); if (ret) goto out; /* * The transfer must be in one transaction or the firmware * goes suicidal. There's no way to guarantee that for all * controllers, but we can at least try. */ chunk = sdio_align_size(card->func, size); ret = sdio_readsb(card->func, card->buffer, card->ioport, chunk); if (ret) goto out; chunk = card->buffer[0] | (card->buffer[1] << 8); type = card->buffer[2] | (card->buffer[3] << 8); lbs_deb_sdio("packet of type %d and size %d bytes\n", (int)type, (int)chunk); if (chunk > size) { lbs_deb_sdio("packet fragment (%d > %d)\n", (int)chunk, (int)size); ret = -EINVAL; goto out; } if (chunk < size) { lbs_deb_sdio("packet fragment (%d < %d)\n", (int)chunk, (int)size); } switch (type) { case MVMS_CMD: ret = if_sdio_handle_cmd(card, card->buffer + 4, chunk - 4); if (ret) goto out; break; case MVMS_DAT: ret = if_sdio_handle_data(card, card->buffer + 4, chunk - 4); if (ret) goto out; break; case MVMS_EVENT: ret = if_sdio_handle_event(card, card->buffer + 4, chunk - 4); if (ret) goto out; break; default: lbs_deb_sdio("invalid type (%d) from firmware\n", (int)type); ret = -EINVAL; goto out; } out: if (ret) lbs_pr_err("problem fetching packet from firmware\n"); lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); return ret; } static void if_sdio_host_to_card_worker(struct work_struct *work) { struct if_sdio_card *card; struct if_sdio_packet *packet; int ret; unsigned long flags; lbs_deb_enter(LBS_DEB_SDIO); card = container_of(work, struct if_sdio_card, packet_worker); while (1) { spin_lock_irqsave(&card->lock, flags); packet = card->packets; if (packet) card->packets = packet->next; spin_unlock_irqrestore(&card->lock, flags); if (!packet) break; sdio_claim_host(card->func); ret = if_sdio_wait_status(card, IF_SDIO_IO_RDY); if (ret == 0) { ret = sdio_writesb(card->func, card->ioport, packet->buffer, packet->nb); } if (ret) lbs_pr_err("error %d sending packet to firmware\n", ret); sdio_release_host(card->func); kfree(packet); } lbs_deb_leave(LBS_DEB_SDIO); } /********************************************************************/ /* Firmware */ /********************************************************************/ #define FW_DL_READY_STATUS (IF_SDIO_IO_RDY | IF_SDIO_DL_RDY) static int if_sdio_prog_helper(struct if_sdio_card *card) { int ret; const struct firmware *fw; unsigned long timeout; u8 *chunk_buffer; u32 chunk_size; const u8 *firmware; size_t size; lbs_deb_enter(LBS_DEB_SDIO); ret = request_firmware(&fw, card->helper, &card->func->dev); if (ret) { lbs_pr_err("can't load helper firmware\n"); goto out; } chunk_buffer = kzalloc(64, GFP_KERNEL); if (!chunk_buffer) { ret = -ENOMEM; goto release_fw; } sdio_claim_host(card->func); ret = sdio_set_block_size(card->func, 32); if (ret) goto release; firmware = fw->data; size = fw->size; while (size) { ret = if_sdio_wait_status(card, FW_DL_READY_STATUS); if (ret) goto release; /* On some platforms (like Davinci) the chip needs more time * between helper blocks. */ mdelay(2); chunk_size = min(size, (size_t)60); *((__le32*)chunk_buffer) = cpu_to_le32(chunk_size); memcpy(chunk_buffer + 4, firmware, chunk_size); /* lbs_deb_sdio("sending %d bytes chunk\n", chunk_size); */ ret = sdio_writesb(card->func, card->ioport, chunk_buffer, 64); if (ret) goto release; firmware += chunk_size; size -= chunk_size; } /* an empty block marks the end of the transfer */ memset(chunk_buffer, 0, 4); ret = sdio_writesb(card->func, card->ioport, chunk_buffer, 64); if (ret) goto release; lbs_deb_sdio("waiting for helper to boot...\n"); /* wait for the helper to boot by looking at the size register */ timeout = jiffies + HZ; while (1) { u16 req_size; req_size = sdio_readb(card->func, IF_SDIO_RD_BASE, &ret); if (ret) goto release; req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1, &ret) << 8; if (ret) goto release; if (req_size != 0) break; if (time_after(jiffies, timeout)) { ret = -ETIMEDOUT; goto release; } msleep(10); } ret = 0; release: sdio_release_host(card->func); kfree(chunk_buffer); release_fw: release_firmware(fw); out: if (ret) lbs_pr_err("failed to load helper firmware\n"); lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); return ret; } static int if_sdio_prog_real(struct if_sdio_card *card) { int ret; const struct firmware *fw; unsigned long timeout; u8 *chunk_buffer; u32 chunk_size; const u8 *firmware; size_t size, req_size; lbs_deb_enter(LBS_DEB_SDIO); ret = request_firmware(&fw, card->firmware, &card->func->dev); if (ret) { lbs_pr_err("can't load firmware\n"); goto out; } chunk_buffer = kzalloc(512, GFP_KERNEL); if (!chunk_buffer) { ret = -ENOMEM; goto release_fw; } sdio_claim_host(card->func); ret = sdio_set_block_size(card->func, 32); if (ret) goto release; firmware = fw->data; size = fw->size; while (size) { ret = if_sdio_wait_status(card, FW_DL_READY_STATUS); if (ret) goto release; req_size = sdio_readb(card->func, IF_SDIO_RD_BASE, &ret); if (ret) goto release; req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1, &ret) << 8; if (ret) goto release; /* lbs_deb_sdio("firmware wants %d bytes\n", (int)req_size); */ if (req_size == 0) { lbs_deb_sdio("firmware helper gave up early\n"); ret = -EIO; goto release; } if (req_size & 0x01) { lbs_deb_sdio("firmware helper signalled error\n"); ret = -EIO; goto release; } if (req_size > size) req_size = size; while (req_size) { chunk_size = min(req_size, (size_t)512); memcpy(chunk_buffer, firmware, chunk_size); /* lbs_deb_sdio("sending %d bytes (%d bytes) chunk\n", chunk_size, (chunk_size + 31) / 32 * 32); */ ret = sdio_writesb(card->func, card->ioport, chunk_buffer, roundup(chunk_size, 32)); if (ret) goto release; firmware += chunk_size; size -= chunk_size; req_size -= chunk_size; } } ret = 0; lbs_deb_sdio("waiting for firmware to boot...\n"); /* wait for the firmware to boot */ timeout = jiffies + HZ; while (1) { u16 scratch; scratch = if_sdio_read_scratch(card, &ret); if (ret) goto release; if (scratch == IF_SDIO_FIRMWARE_OK) break; if (time_after(jiffies, timeout)) { ret = -ETIMEDOUT; goto release; } msleep(10); } ret = 0; release: sdio_release_host(card->func); kfree(chunk_buffer); release_fw: release_firmware(fw); out: if (ret) lbs_pr_err("failed to load firmware\n"); lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); return ret; } static int if_sdio_prog_firmware(struct if_sdio_card *card) { int ret; u16 scratch; lbs_deb_enter(LBS_DEB_SDIO); sdio_claim_host(card->func); scratch = if_sdio_read_scratch(card, &ret); sdio_release_host(card->func); if (ret) goto out; lbs_deb_sdio("firmware status = %#x\n", scratch); if (scratch == IF_SDIO_FIRMWARE_OK) { lbs_deb_sdio("firmware already loaded\n"); goto success; } ret = if_sdio_prog_helper(card); if (ret) goto out; ret = if_sdio_prog_real(card); if (ret) goto out; success: sdio_claim_host(card->func); sdio_set_block_size(card->func, IF_SDIO_BLOCK_SIZE); sdio_release_host(card->func); ret = 0; out: lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); return ret; } /*******************************************************************/ /* Libertas callbacks */ /*******************************************************************/ static int if_sdio_host_to_card(struct lbs_private *priv, u8 type, u8 *buf, u16 nb) { int ret; struct if_sdio_card *card; struct if_sdio_packet *packet, *cur; u16 size; unsigned long flags; lbs_deb_enter_args(LBS_DEB_SDIO, "type %d, bytes %d", type, nb); card = priv->card; if (nb > (65536 - sizeof(struct if_sdio_packet) - 4)) { ret = -EINVAL; goto out; } /* * The transfer must be in one transaction or the firmware * goes suicidal. There's no way to guarantee that for all * controllers, but we can at least try. */ size = sdio_align_size(card->func, nb + 4); packet = kzalloc(sizeof(struct if_sdio_packet) + size, GFP_ATOMIC); if (!packet) { ret = -ENOMEM; goto out; } packet->next = NULL; packet->nb = size; /* * SDIO specific header. */ packet->buffer[0] = (nb + 4) & 0xff; packet->buffer[1] = ((nb + 4) >> 8) & 0xff; packet->buffer[2] = type; packet->buffer[3] = 0; memcpy(packet->buffer + 4, buf, nb); spin_lock_irqsave(&card->lock, flags); if (!card->packets) card->packets = packet; else { cur = card->packets; while (cur->next) cur = cur->next; cur->next = packet; } switch (type) { case MVMS_CMD: priv->dnld_sent = DNLD_CMD_SENT; break; case MVMS_DAT: priv->dnld_sent = DNLD_DATA_SENT; break; default: lbs_deb_sdio("unknown packet type %d\n", (int)type); } spin_unlock_irqrestore(&card->lock, flags); queue_work(card->workqueue, &card->packet_worker); ret = 0; out: lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); return ret; } static int if_sdio_enter_deep_sleep(struct lbs_private *priv) { int ret = -1; struct cmd_header cmd; memset(&cmd, 0, sizeof(cmd)); lbs_deb_sdio("send DEEP_SLEEP command\n"); ret = __lbs_cmd(priv, CMD_802_11_DEEP_SLEEP, &cmd, sizeof(cmd), lbs_cmd_copyback, (unsigned long) &cmd); if (ret) lbs_pr_err("DEEP_SLEEP cmd failed\n"); mdelay(200); return ret; } static int if_sdio_exit_deep_sleep(struct lbs_private *priv) { struct if_sdio_card *card = priv->card; int ret = -1; lbs_deb_enter(LBS_DEB_SDIO); sdio_claim_host(card->func); sdio_writeb(card->func, HOST_POWER_UP, CONFIGURATION_REG, &ret); if (ret) lbs_pr_err("sdio_writeb failed!\n"); sdio_release_host(card->func); lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); return ret; } static int if_sdio_reset_deep_sleep_wakeup(struct lbs_private *priv) { struct if_sdio_card *card = priv->card; int ret = -1; lbs_deb_enter(LBS_DEB_SDIO); sdio_claim_host(card->func); sdio_writeb(card->func, 0, CONFIGURATION_REG, &ret); if (ret) lbs_pr_err("sdio_writeb failed!\n"); sdio_release_host(card->func); lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); return ret; } /*******************************************************************/ /* SDIO callbacks */ /*******************************************************************/ static void if_sdio_interrupt(struct sdio_func *func) { int ret; struct if_sdio_card *card; u8 cause; lbs_deb_enter(LBS_DEB_SDIO); card = sdio_get_drvdata(func); cause = sdio_readb(card->func, IF_SDIO_H_INT_STATUS, &ret); if (ret) goto out; lbs_deb_sdio("interrupt: 0x%X\n", (unsigned)cause); sdio_writeb(card->func, ~cause, IF_SDIO_H_INT_STATUS, &ret); if (ret) goto out; /* * Ignore the define name, this really means the card has * successfully received the command. */ card->priv->is_activity_detected = 1; if (cause & IF_SDIO_H_INT_DNLD) lbs_host_to_card_done(card->priv); if (cause & IF_SDIO_H_INT_UPLD) { ret = if_sdio_card_to_host(card); if (ret) goto out; } ret = 0; out: lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); } static int if_sdio_probe(struct sdio_func *func, const struct sdio_device_id *id) { struct if_sdio_card *card; struct lbs_private *priv; int ret, i; unsigned int model; struct if_sdio_packet *packet; struct mmc_host *host = func->card->host; lbs_deb_enter(LBS_DEB_SDIO); for (i = 0;i < func->card->num_info;i++) { if (sscanf(func->card->info[i], "802.11 SDIO ID: %x", &model) == 1) break; if (sscanf(func->card->info[i], "ID: %x", &model) == 1) break; if (!strcmp(func->card->info[i], "IBIS Wireless SDIO Card")) { model = IF_SDIO_MODEL_8385; break; } } if (i == func->card->num_info) { lbs_pr_err("unable to identify card model\n"); return -ENODEV; } card = kzalloc(sizeof(struct if_sdio_card), GFP_KERNEL); if (!card) return -ENOMEM; card->func = func; card->model = model; switch (card->model) { case IF_SDIO_MODEL_8385: card->scratch_reg = IF_SDIO_SCRATCH_OLD; break; case IF_SDIO_MODEL_8686: card->scratch_reg = IF_SDIO_SCRATCH; break; case IF_SDIO_MODEL_8688: default: /* for newer chipsets */ card->scratch_reg = IF_SDIO_FW_STATUS; break; } spin_lock_init(&card->lock); card->workqueue = create_workqueue("libertas_sdio"); INIT_WORK(&card->packet_worker, if_sdio_host_to_card_worker); for (i = 0;i < ARRAY_SIZE(if_sdio_models);i++) { if (card->model == if_sdio_models[i].model) break; } if (i == ARRAY_SIZE(if_sdio_models)) { lbs_pr_err("unknown card model 0x%x\n", card->model); ret = -ENODEV; goto free; } card->helper = if_sdio_models[i].helper; card->firmware = if_sdio_models[i].firmware; if (lbs_helper_name) { lbs_deb_sdio("overriding helper firmware: %s\n", lbs_helper_name); card->helper = lbs_helper_name; } if (lbs_fw_name) { lbs_deb_sdio("overriding firmware: %s\n", lbs_fw_name); card->firmware = lbs_fw_name; } sdio_claim_host(func); ret = sdio_enable_func(func); if (ret) goto release; ret = sdio_claim_irq(func, if_sdio_interrupt); if (ret) goto disable; /* For 1-bit transfers to the 8686 model, we need to enable the * interrupt flag in the CCCR register. Set the MMC_QUIRK_LENIENT_FN0 * bit to allow access to non-vendor registers. */ if ((card->model == IF_SDIO_MODEL_8686) && (host->caps & MMC_CAP_SDIO_IRQ) && (host->ios.bus_width == MMC_BUS_WIDTH_1)) { u8 reg; func->card->quirks |= MMC_QUIRK_LENIENT_FN0; reg = sdio_f0_readb(func, SDIO_CCCR_IF, &ret); if (ret) goto release_int; reg |= SDIO_BUS_ECSI; sdio_f0_writeb(func, reg, SDIO_CCCR_IF, &ret); if (ret) goto release_int; } card->ioport = sdio_readb(func, IF_SDIO_IOPORT, &ret); if (ret) goto release_int; card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 1, &ret) << 8; if (ret) goto release_int; card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 2, &ret) << 16; if (ret) goto release_int; sdio_release_host(func); sdio_set_drvdata(func, card); lbs_deb_sdio("class = 0x%X, vendor = 0x%X, " "device = 0x%X, model = 0x%X, ioport = 0x%X\n", func->class, func->vendor, func->device, model, (unsigned)card->ioport); ret = if_sdio_prog_firmware(card); if (ret) goto reclaim; priv = lbs_add_card(card, &func->dev); if (!priv) { ret = -ENOMEM; goto reclaim; } card->priv = priv; priv->card = card; priv->hw_host_to_card = if_sdio_host_to_card; priv->enter_deep_sleep = if_sdio_enter_deep_sleep; priv->exit_deep_sleep = if_sdio_exit_deep_sleep; priv->reset_deep_sleep_wakeup = if_sdio_reset_deep_sleep_wakeup; priv->fw_ready = 1; sdio_claim_host(func); /* * Get rx_unit if the chip is SD8688 or newer. * SD8385 & SD8686 do not have rx_unit. */ if ((card->model != IF_SDIO_MODEL_8385) && (card->model != IF_SDIO_MODEL_8686)) card->rx_unit = if_sdio_read_rx_unit(card); else card->rx_unit = 0; /* * Enable interrupts now that everything is set up */ sdio_writeb(func, 0x0f, IF_SDIO_H_INT_MASK, &ret); sdio_release_host(func); if (ret) goto reclaim; /* * FUNC_INIT is required for SD8688 WLAN/BT multiple functions */ if (card->model == IF_SDIO_MODEL_8688) { struct cmd_header cmd; memset(&cmd, 0, sizeof(cmd)); lbs_deb_sdio("send function INIT command\n"); if (__lbs_cmd(priv, CMD_FUNC_INIT, &cmd, sizeof(cmd), lbs_cmd_copyback, (unsigned long) &cmd)) lbs_pr_alert("CMD_FUNC_INIT cmd failed\n"); } ret = lbs_start_card(priv); if (ret) goto err_activate_card; out: lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); return ret; err_activate_card: flush_workqueue(card->workqueue); lbs_remove_card(priv); reclaim: sdio_claim_host(func); release_int: sdio_release_irq(func); disable: sdio_disable_func(func); release: sdio_release_host(func); free: destroy_workqueue(card->workqueue); while (card->packets) { packet = card->packets; card->packets = card->packets->next; kfree(packet); } kfree(card); goto out; } static void if_sdio_remove(struct sdio_func *func) { struct if_sdio_card *card; struct if_sdio_packet *packet; lbs_deb_enter(LBS_DEB_SDIO); card = sdio_get_drvdata(func); if (user_rmmod && (card->model == IF_SDIO_MODEL_8688)) { /* * FUNC_SHUTDOWN is required for SD8688 WLAN/BT * multiple functions */ struct cmd_header cmd; memset(&cmd, 0, sizeof(cmd)); lbs_deb_sdio("send function SHUTDOWN command\n"); if (__lbs_cmd(card->priv, CMD_FUNC_SHUTDOWN, &cmd, sizeof(cmd), lbs_cmd_copyback, (unsigned long) &cmd)) lbs_pr_alert("CMD_FUNC_SHUTDOWN cmd failed\n"); } lbs_deb_sdio("call remove card\n"); lbs_stop_card(card->priv); lbs_remove_card(card->priv); card->priv->surpriseremoved = 1; flush_workqueue(card->workqueue); destroy_workqueue(card->workqueue); sdio_claim_host(func); sdio_release_irq(func); sdio_disable_func(func); sdio_release_host(func); while (card->packets) { packet = card->packets; card->packets = card->packets->next; kfree(packet); } kfree(card); lbs_deb_leave(LBS_DEB_SDIO); } static int if_sdio_suspend(struct device *dev) { struct sdio_func *func = dev_to_sdio_func(dev); int ret; struct if_sdio_card *card = sdio_get_drvdata(func); mmc_pm_flag_t flags = sdio_get_host_pm_caps(func); lbs_pr_info("%s: suspend: PM flags = 0x%x\n", sdio_func_id(func), flags); /* If we aren't being asked to wake on anything, we should bail out * and let the SD stack power down the card. */ if (card->priv->wol_criteria == EHS_REMOVE_WAKEUP) { lbs_pr_info("Suspend without wake params -- " "powering down card."); return -ENOSYS; } if (!(flags & MMC_PM_KEEP_POWER)) { lbs_pr_err("%s: cannot remain alive while host is suspended\n", sdio_func_id(func)); return -ENOSYS; } ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER); if (ret) return ret; ret = lbs_suspend(card->priv); if (ret) return ret; return sdio_set_host_pm_flags(func, MMC_PM_WAKE_SDIO_IRQ); } static int if_sdio_resume(struct device *dev) { struct sdio_func *func = dev_to_sdio_func(dev); struct if_sdio_card *card = sdio_get_drvdata(func); int ret; lbs_pr_info("%s: resume: we're back\n", sdio_func_id(func)); ret = lbs_resume(card->priv); return ret; } static const struct dev_pm_ops if_sdio_pm_ops = { .suspend = if_sdio_suspend, .resume = if_sdio_resume, }; static struct sdio_driver if_sdio_driver = { .name = "libertas_sdio", .id_table = if_sdio_ids, .probe = if_sdio_probe, .remove = if_sdio_remove, .drv = { .pm = &if_sdio_pm_ops, }, }; /*******************************************************************/ /* Module functions */ /*******************************************************************/ static int __init if_sdio_init_module(void) { int ret = 0; lbs_deb_enter(LBS_DEB_SDIO); printk(KERN_INFO "libertas_sdio: Libertas SDIO driver\n"); printk(KERN_INFO "libertas_sdio: Copyright Pierre Ossman\n"); ret = sdio_register_driver(&if_sdio_driver); /* Clear the flag in case user removes the card. */ user_rmmod = 0; lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); return ret; } static void __exit if_sdio_exit_module(void) { lbs_deb_enter(LBS_DEB_SDIO); /* Set the flag as user is removing this module. */ user_rmmod = 1; sdio_unregister_driver(&if_sdio_driver); lbs_deb_leave(LBS_DEB_SDIO); } module_init(if_sdio_init_module); module_exit(if_sdio_exit_module); MODULE_DESCRIPTION("Libertas SDIO WLAN Driver"); MODULE_AUTHOR("Pierre Ossman"); MODULE_LICENSE("GPL");