1418 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * linux/drivers/net/wireless/libertas/if_sdio.c4 *5 * Copyright 2007-2008 Pierre Ossman6 *7 * Inspired by if_cs.c, Copyright 2007 Holger Schurig8 *9 * This hardware has more or less no CMD53 support, so all registers10 * must be accessed using sdio_readb()/sdio_writeb().11 *12 * Transfers must be in one transaction or the firmware goes bonkers.13 * This means that the transfer must either be small enough to do a14 * byte based transfer or it must be padded to a multiple of the15 * current block size.16 *17 * As SDIO is still new to the kernel, it is unfortunately common with18 * bugs in the host controllers related to that. One such bug is that19 * controllers cannot do transfers that aren't a multiple of 4 bytes.20 * If you don't have time to fix the host controller driver, you can21 * work around the problem by modifying if_sdio_host_to_card() and22 * if_sdio_card_to_host() to pad the data.23 */24 25#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt26 27#include <linux/kernel.h>28#include <linux/module.h>29#include <linux/slab.h>30#include <linux/firmware.h>31#include <linux/netdevice.h>32#include <linux/delay.h>33#include <linux/mmc/card.h>34#include <linux/mmc/sdio_func.h>35#include <linux/mmc/sdio_ids.h>36#include <linux/mmc/sdio.h>37#include <linux/mmc/host.h>38#include <linux/pm_runtime.h>39 40#include "host.h"41#include "decl.h"42#include "defs.h"43#include "dev.h"44#include "cmd.h"45#include "if_sdio.h"46 47static void if_sdio_interrupt(struct sdio_func *func);48 49/* The if_sdio_remove() callback function is called when50 * user removes this module from kernel space or ejects51 * the card from the slot. The driver handles these 2 cases52 * differently for SD8688 combo chip.53 * If the user is removing the module, the FUNC_SHUTDOWN54 * command for SD8688 is sent to the firmware.55 * If the card is removed, there is no need to send this command.56 *57 * The variable 'user_rmmod' is used to distinguish these two58 * scenarios. This flag is initialized as FALSE in case the card59 * is removed, and will be set to TRUE for module removal when60 * module_exit function is called.61 */62static u8 user_rmmod;63 64static const struct sdio_device_id if_sdio_ids[] = {65 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL,66 SDIO_DEVICE_ID_MARVELL_LIBERTAS) },67 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL,68 SDIO_DEVICE_ID_MARVELL_8688_WLAN) },69 { /* end: all zeroes */ },70};71 72MODULE_DEVICE_TABLE(sdio, if_sdio_ids);73 74#define MODEL_8385 0x0475#define MODEL_8686 0x0b76#define MODEL_8688 0x1077 78static const struct lbs_fw_table fw_table[] = {79 { MODEL_8385, "libertas/sd8385_helper.bin", "libertas/sd8385.bin" },80 { MODEL_8385, "sd8385_helper.bin", "sd8385.bin" },81 { MODEL_8686, "libertas/sd8686_v9_helper.bin", "libertas/sd8686_v9.bin" },82 { MODEL_8686, "libertas/sd8686_v8_helper.bin", "libertas/sd8686_v8.bin" },83 { MODEL_8686, "sd8686_helper.bin", "sd8686.bin" },84 { MODEL_8688, "libertas/sd8688_helper.bin", "libertas/sd8688.bin" },85 { MODEL_8688, "sd8688_helper.bin", "sd8688.bin" },86 { 0, NULL, NULL }87};88MODULE_FIRMWARE("libertas/sd8385_helper.bin");89MODULE_FIRMWARE("libertas/sd8385.bin");90MODULE_FIRMWARE("sd8385_helper.bin");91MODULE_FIRMWARE("sd8385.bin");92MODULE_FIRMWARE("libertas/sd8686_v9_helper.bin");93MODULE_FIRMWARE("libertas/sd8686_v9.bin");94MODULE_FIRMWARE("libertas/sd8686_v8_helper.bin");95MODULE_FIRMWARE("libertas/sd8686_v8.bin");96MODULE_FIRMWARE("sd8686_helper.bin");97MODULE_FIRMWARE("sd8686.bin");98MODULE_FIRMWARE("libertas/sd8688_helper.bin");99MODULE_FIRMWARE("libertas/sd8688.bin");100MODULE_FIRMWARE("sd8688_helper.bin");101MODULE_FIRMWARE("sd8688.bin");102 103struct if_sdio_packet {104 struct list_head list;105 u16 nb;106 u8 buffer[] __aligned(4);107};108 109struct if_sdio_card {110 struct sdio_func *func;111 struct lbs_private *priv;112 113 int model;114 unsigned long ioport;115 unsigned int scratch_reg;116 bool started;117 wait_queue_head_t pwron_waitq;118 119 u8 buffer[65536] __attribute__((aligned(4)));120 121 spinlock_t lock;122 struct list_head packets;123 124 struct workqueue_struct *workqueue;125 struct work_struct packet_worker;126 struct work_struct reset_worker;127 128 u8 rx_unit;129};130 131static void if_sdio_finish_power_on(struct if_sdio_card *card);132static int if_sdio_power_off(struct if_sdio_card *card);133 134/********************************************************************/135/* I/O */136/********************************************************************/137 138/*139 * For SD8385/SD8686, this function reads firmware status after140 * the image is downloaded, or reads RX packet length when141 * interrupt (with IF_SDIO_H_INT_UPLD bit set) is received.142 * For SD8688, this function reads firmware status only.143 */144static u16 if_sdio_read_scratch(struct if_sdio_card *card, int *err)145{146 int ret;147 u16 scratch;148 149 scratch = sdio_readb(card->func, card->scratch_reg, &ret);150 if (!ret)151 scratch |= sdio_readb(card->func, card->scratch_reg + 1,152 &ret) << 8;153 154 if (err)155 *err = ret;156 157 if (ret)158 return 0xffff;159 160 return scratch;161}162 163static u8 if_sdio_read_rx_unit(struct if_sdio_card *card)164{165 int ret;166 u8 rx_unit;167 168 rx_unit = sdio_readb(card->func, IF_SDIO_RX_UNIT, &ret);169 170 if (ret)171 rx_unit = 0;172 173 return rx_unit;174}175 176static u16 if_sdio_read_rx_len(struct if_sdio_card *card, int *err)177{178 int ret;179 u16 rx_len;180 181 switch (card->model) {182 case MODEL_8385:183 case MODEL_8686:184 rx_len = if_sdio_read_scratch(card, &ret);185 break;186 case MODEL_8688:187 default: /* for newer chipsets */188 rx_len = sdio_readb(card->func, IF_SDIO_RX_LEN, &ret);189 if (!ret)190 rx_len <<= card->rx_unit;191 else192 rx_len = 0xffff; /* invalid length */193 194 break;195 }196 197 if (err)198 *err = ret;199 200 return rx_len;201}202 203static int if_sdio_handle_cmd(struct if_sdio_card *card,204 u8 *buffer, unsigned size)205{206 struct lbs_private *priv = card->priv;207 int ret;208 unsigned long flags;209 u8 i;210 211 if (size > LBS_CMD_BUFFER_SIZE) {212 lbs_deb_sdio("response packet too large (%d bytes)\n",213 (int)size);214 ret = -E2BIG;215 goto out;216 }217 218 spin_lock_irqsave(&priv->driver_lock, flags);219 220 i = (priv->resp_idx == 0) ? 1 : 0;221 BUG_ON(priv->resp_len[i]);222 priv->resp_len[i] = size;223 memcpy(priv->resp_buf[i], buffer, size);224 lbs_notify_command_response(priv, i);225 226 spin_unlock_irqrestore(&priv->driver_lock, flags);227 228 ret = 0;229 230out:231 return ret;232}233 234static int if_sdio_handle_data(struct if_sdio_card *card,235 u8 *buffer, unsigned size)236{237 int ret;238 struct sk_buff *skb;239 240 if (size > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) {241 lbs_deb_sdio("response packet too large (%d bytes)\n",242 (int)size);243 ret = -E2BIG;244 goto out;245 }246 247 skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + NET_IP_ALIGN);248 if (!skb) {249 ret = -ENOMEM;250 goto out;251 }252 253 skb_reserve(skb, NET_IP_ALIGN);254 255 skb_put_data(skb, buffer, size);256 257 lbs_process_rxed_packet(card->priv, skb);258 259 ret = 0;260 261out:262 return ret;263}264 265static int if_sdio_handle_event(struct if_sdio_card *card,266 u8 *buffer, unsigned size)267{268 int ret;269 u32 event;270 271 if (card->model == MODEL_8385) {272 event = sdio_readb(card->func, IF_SDIO_EVENT, &ret);273 if (ret)274 goto out;275 276 /* right shift 3 bits to get the event id */277 event >>= 3;278 } else {279 if (size < 4) {280 lbs_deb_sdio("event packet too small (%d bytes)\n",281 (int)size);282 ret = -EINVAL;283 goto out;284 }285 event = buffer[3] << 24;286 event |= buffer[2] << 16;287 event |= buffer[1] << 8;288 event |= buffer[0] << 0;289 }290 291 lbs_queue_event(card->priv, event & 0xFF);292 ret = 0;293 294out:295 return ret;296}297 298static int if_sdio_wait_status(struct if_sdio_card *card, const u8 condition)299{300 u8 status;301 unsigned long timeout;302 int ret = 0;303 304 timeout = jiffies + HZ;305 while (1) {306 status = sdio_readb(card->func, IF_SDIO_STATUS, &ret);307 if (ret)308 return ret;309 if ((status & condition) == condition)310 break;311 if (time_after(jiffies, timeout))312 return -ETIMEDOUT;313 mdelay(1);314 }315 return ret;316}317 318static int if_sdio_card_to_host(struct if_sdio_card *card)319{320 int ret;321 u16 size, type, chunk;322 323 size = if_sdio_read_rx_len(card, &ret);324 if (ret)325 goto out;326 327 if (size < 4) {328 lbs_deb_sdio("invalid packet size (%d bytes) from firmware\n",329 (int)size);330 ret = -EINVAL;331 goto out;332 }333 334 ret = if_sdio_wait_status(card, IF_SDIO_IO_RDY);335 if (ret)336 goto out;337 338 /*339 * The transfer must be in one transaction or the firmware340 * goes suicidal. There's no way to guarantee that for all341 * controllers, but we can at least try.342 */343 chunk = sdio_align_size(card->func, size);344 345 ret = sdio_readsb(card->func, card->buffer, card->ioport, chunk);346 if (ret)347 goto out;348 349 chunk = card->buffer[0] | (card->buffer[1] << 8);350 type = card->buffer[2] | (card->buffer[3] << 8);351 352 lbs_deb_sdio("packet of type %d and size %d bytes\n",353 (int)type, (int)chunk);354 355 if (chunk > size) {356 lbs_deb_sdio("packet fragment (%d > %d)\n",357 (int)chunk, (int)size);358 ret = -EINVAL;359 goto out;360 }361 362 if (chunk < size) {363 lbs_deb_sdio("packet fragment (%d < %d)\n",364 (int)chunk, (int)size);365 }366 367 switch (type) {368 case MVMS_CMD:369 ret = if_sdio_handle_cmd(card, card->buffer + 4, chunk - 4);370 if (ret)371 goto out;372 break;373 case MVMS_DAT:374 ret = if_sdio_handle_data(card, card->buffer + 4, chunk - 4);375 if (ret)376 goto out;377 break;378 case MVMS_EVENT:379 ret = if_sdio_handle_event(card, card->buffer + 4, chunk - 4);380 if (ret)381 goto out;382 break;383 default:384 lbs_deb_sdio("invalid type (%d) from firmware\n",385 (int)type);386 ret = -EINVAL;387 goto out;388 }389 390out:391 if (ret)392 pr_err("problem fetching packet from firmware\n");393 394 return ret;395}396 397static void if_sdio_host_to_card_worker(struct work_struct *work)398{399 struct if_sdio_card *card;400 struct if_sdio_packet *packet;401 int ret;402 unsigned long flags;403 404 card = container_of(work, struct if_sdio_card, packet_worker);405 406 while (1) {407 spin_lock_irqsave(&card->lock, flags);408 packet = list_first_entry_or_null(&card->packets,409 struct if_sdio_packet, list);410 if (packet)411 list_del(&packet->list);412 spin_unlock_irqrestore(&card->lock, flags);413 414 if (!packet)415 break;416 417 sdio_claim_host(card->func);418 419 ret = if_sdio_wait_status(card, IF_SDIO_IO_RDY);420 if (ret == 0) {421 ret = sdio_writesb(card->func, card->ioport,422 packet->buffer, packet->nb);423 }424 425 if (ret)426 pr_err("error %d sending packet to firmware\n", ret);427 428 sdio_release_host(card->func);429 430 kfree(packet);431 }432}433 434/********************************************************************/435/* Firmware */436/********************************************************************/437 438#define FW_DL_READY_STATUS (IF_SDIO_IO_RDY | IF_SDIO_DL_RDY)439 440static int if_sdio_prog_helper(struct if_sdio_card *card,441 const struct firmware *fw)442{443 int ret;444 unsigned long timeout;445 u8 *chunk_buffer;446 u32 chunk_size;447 const u8 *firmware;448 size_t size;449 450 chunk_buffer = kzalloc(64, GFP_KERNEL);451 if (!chunk_buffer) {452 ret = -ENOMEM;453 goto out;454 }455 456 sdio_claim_host(card->func);457 458 ret = sdio_set_block_size(card->func, 32);459 if (ret)460 goto release;461 462 firmware = fw->data;463 size = fw->size;464 465 while (size) {466 ret = if_sdio_wait_status(card, FW_DL_READY_STATUS);467 if (ret)468 goto release;469 470 /* On some platforms (like Davinci) the chip needs more time471 * between helper blocks.472 */473 mdelay(2);474 475 chunk_size = min_t(size_t, size, 60);476 477 *((__le32*)chunk_buffer) = cpu_to_le32(chunk_size);478 memcpy(chunk_buffer + 4, firmware, chunk_size);479/*480 lbs_deb_sdio("sending %d bytes chunk\n", chunk_size);481*/482 ret = sdio_writesb(card->func, card->ioport,483 chunk_buffer, 64);484 if (ret)485 goto release;486 487 firmware += chunk_size;488 size -= chunk_size;489 }490 491 /* an empty block marks the end of the transfer */492 memset(chunk_buffer, 0, 4);493 ret = sdio_writesb(card->func, card->ioport, chunk_buffer, 64);494 if (ret)495 goto release;496 497 lbs_deb_sdio("waiting for helper to boot...\n");498 499 /* wait for the helper to boot by looking at the size register */500 timeout = jiffies + HZ;501 while (1) {502 u16 req_size;503 504 req_size = sdio_readb(card->func, IF_SDIO_RD_BASE, &ret);505 if (ret)506 goto release;507 508 req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1, &ret) << 8;509 if (ret)510 goto release;511 512 if (req_size != 0)513 break;514 515 if (time_after(jiffies, timeout)) {516 ret = -ETIMEDOUT;517 goto release;518 }519 520 msleep(10);521 }522 523 ret = 0;524 525release:526 sdio_release_host(card->func);527 kfree(chunk_buffer);528 529out:530 if (ret)531 pr_err("failed to load helper firmware\n");532 533 return ret;534}535 536static int if_sdio_prog_real(struct if_sdio_card *card,537 const struct firmware *fw)538{539 int ret;540 unsigned long timeout;541 u8 *chunk_buffer;542 u32 chunk_size;543 const u8 *firmware;544 size_t size, req_size;545 546 chunk_buffer = kzalloc(512, GFP_KERNEL);547 if (!chunk_buffer) {548 ret = -ENOMEM;549 goto out;550 }551 552 sdio_claim_host(card->func);553 554 ret = sdio_set_block_size(card->func, 32);555 if (ret)556 goto release;557 558 firmware = fw->data;559 size = fw->size;560 561 while (size) {562 timeout = jiffies + HZ;563 while (1) {564 ret = if_sdio_wait_status(card, FW_DL_READY_STATUS);565 if (ret)566 goto release;567 568 req_size = sdio_readb(card->func, IF_SDIO_RD_BASE,569 &ret);570 if (ret)571 goto release;572 573 req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1,574 &ret) << 8;575 if (ret)576 goto release;577 578 /*579 * For SD8688 wait until the length is not 0, 1 or 2580 * before downloading the first FW block,581 * since BOOT code writes the register to indicate the582 * helper/FW download winner,583 * the value could be 1 or 2 (Func1 or Func2).584 */585 if ((size != fw->size) || (req_size > 2))586 break;587 if (time_after(jiffies, timeout)) {588 ret = -ETIMEDOUT;589 goto release;590 }591 mdelay(1);592 }593 594/*595 lbs_deb_sdio("firmware wants %d bytes\n", (int)req_size);596*/597 if (req_size == 0) {598 lbs_deb_sdio("firmware helper gave up early\n");599 ret = -EIO;600 goto release;601 }602 603 if (req_size & 0x01) {604 lbs_deb_sdio("firmware helper signalled error\n");605 ret = -EIO;606 goto release;607 }608 609 if (req_size > size)610 req_size = size;611 612 while (req_size) {613 chunk_size = min_t(size_t, req_size, 512);614 615 memcpy(chunk_buffer, firmware, chunk_size);616/*617 lbs_deb_sdio("sending %d bytes (%d bytes) chunk\n",618 chunk_size, (chunk_size + 31) / 32 * 32);619*/620 ret = sdio_writesb(card->func, card->ioport,621 chunk_buffer, roundup(chunk_size, 32));622 if (ret)623 goto release;624 625 firmware += chunk_size;626 size -= chunk_size;627 req_size -= chunk_size;628 }629 }630 631 ret = 0;632 633 lbs_deb_sdio("waiting for firmware to boot...\n");634 635 /* wait for the firmware to boot */636 timeout = jiffies + HZ;637 while (1) {638 u16 scratch;639 640 scratch = if_sdio_read_scratch(card, &ret);641 if (ret)642 goto release;643 644 if (scratch == IF_SDIO_FIRMWARE_OK)645 break;646 647 if (time_after(jiffies, timeout)) {648 ret = -ETIMEDOUT;649 goto release;650 }651 652 msleep(10);653 }654 655 ret = 0;656 657release:658 sdio_release_host(card->func);659 kfree(chunk_buffer);660 661out:662 if (ret)663 pr_err("failed to load firmware\n");664 665 return ret;666}667 668static void if_sdio_do_prog_firmware(struct lbs_private *priv, int ret,669 const struct firmware *helper,670 const struct firmware *mainfw)671{672 struct if_sdio_card *card = priv->card;673 674 if (ret) {675 pr_err("failed to find firmware (%d)\n", ret);676 return;677 }678 679 ret = if_sdio_prog_helper(card, helper);680 if (ret)681 return;682 683 lbs_deb_sdio("Helper firmware loaded\n");684 685 ret = if_sdio_prog_real(card, mainfw);686 if (ret)687 return;688 689 lbs_deb_sdio("Firmware loaded\n");690 if_sdio_finish_power_on(card);691}692 693static int if_sdio_prog_firmware(struct if_sdio_card *card)694{695 int ret;696 u16 scratch;697 698 /*699 * Disable interrupts700 */701 sdio_claim_host(card->func);702 sdio_writeb(card->func, 0x00, IF_SDIO_H_INT_MASK, &ret);703 sdio_release_host(card->func);704 705 sdio_claim_host(card->func);706 scratch = if_sdio_read_scratch(card, &ret);707 sdio_release_host(card->func);708 709 lbs_deb_sdio("firmware status = %#x\n", scratch);710 lbs_deb_sdio("scratch ret = %d\n", ret);711 712 if (ret)713 goto out;714 715 716 /*717 * The manual clearly describes that FEDC is the right code to use718 * to detect firmware presence, but for SD8686 it is not that simple.719 * Scratch is also used to store the RX packet length, so we lose720 * the FEDC value early on. So we use a non-zero check in order721 * to validate firmware presence.722 * Additionally, the SD8686 in the Gumstix always has the high scratch723 * bit set, even when the firmware is not loaded. So we have to724 * exclude that from the test.725 */726 if (scratch == IF_SDIO_FIRMWARE_OK) {727 lbs_deb_sdio("firmware already loaded\n");728 if_sdio_finish_power_on(card);729 return 0;730 } else if ((card->model == MODEL_8686) && (scratch & 0x7fff)) {731 lbs_deb_sdio("firmware may be running\n");732 if_sdio_finish_power_on(card);733 return 0;734 }735 736 ret = lbs_get_firmware_async(card->priv, &card->func->dev, card->model,737 fw_table, if_sdio_do_prog_firmware);738 739out:740 return ret;741}742 743/********************************************************************/744/* Power management */745/********************************************************************/746 747/* Finish power on sequence (after firmware is loaded) */748static void if_sdio_finish_power_on(struct if_sdio_card *card)749{750 struct sdio_func *func = card->func;751 struct lbs_private *priv = card->priv;752 int ret;753 754 sdio_claim_host(func);755 sdio_set_block_size(card->func, IF_SDIO_BLOCK_SIZE);756 757 /*758 * Get rx_unit if the chip is SD8688 or newer.759 * SD8385 & SD8686 do not have rx_unit.760 */761 if ((card->model != MODEL_8385)762 && (card->model != MODEL_8686))763 card->rx_unit = if_sdio_read_rx_unit(card);764 else765 card->rx_unit = 0;766 767 /*768 * Set up the interrupt handler late.769 *770 * If we set it up earlier, the (buggy) hardware generates a spurious771 * interrupt, even before the interrupt has been enabled, with772 * CCCR_INTx = 0.773 *774 * We register the interrupt handler late so that we can handle any775 * spurious interrupts, and also to avoid generation of that known776 * spurious interrupt in the first place.777 */778 ret = sdio_claim_irq(func, if_sdio_interrupt);779 if (ret)780 goto release;781 782 /*783 * Enable interrupts now that everything is set up784 */785 sdio_writeb(func, 0x0f, IF_SDIO_H_INT_MASK, &ret);786 if (ret)787 goto release_irq;788 789 sdio_release_host(func);790 791 /* Set fw_ready before queuing any commands so that792 * lbs_thread won't block from sending them to firmware.793 */794 priv->fw_ready = 1;795 796 /*797 * FUNC_INIT is required for SD8688 WLAN/BT multiple functions798 */799 if (card->model == MODEL_8688) {800 struct cmd_header cmd;801 802 memset(&cmd, 0, sizeof(cmd));803 804 lbs_deb_sdio("send function INIT command\n");805 if (__lbs_cmd(priv, CMD_FUNC_INIT, &cmd, sizeof(cmd),806 lbs_cmd_copyback, (unsigned long) &cmd))807 netdev_alert(priv->dev, "CMD_FUNC_INIT cmd failed\n");808 }809 810 wake_up(&card->pwron_waitq);811 812 if (!card->started) {813 ret = lbs_start_card(priv);814 if_sdio_power_off(card);815 if (ret == 0) {816 card->started = true;817 /* Tell PM core that we don't need the card to be818 * powered now */819 pm_runtime_put(&func->dev);820 }821 }822 823 return;824 825release_irq:826 sdio_release_irq(func);827release:828 sdio_release_host(func);829}830 831static int if_sdio_power_on(struct if_sdio_card *card)832{833 struct sdio_func *func = card->func;834 struct mmc_host *host = func->card->host;835 int ret;836 837 sdio_claim_host(func);838 839 ret = sdio_enable_func(func);840 if (ret)841 goto release;842 843 /* For 1-bit transfers to the 8686 model, we need to enable the844 * interrupt flag in the CCCR register. Set the MMC_QUIRK_LENIENT_FN0845 * bit to allow access to non-vendor registers. */846 if ((card->model == MODEL_8686) &&847 (host->caps & MMC_CAP_SDIO_IRQ) &&848 (host->ios.bus_width == MMC_BUS_WIDTH_1)) {849 u8 reg;850 851 func->card->quirks |= MMC_QUIRK_LENIENT_FN0;852 reg = sdio_f0_readb(func, SDIO_CCCR_IF, &ret);853 if (ret)854 goto disable;855 856 reg |= SDIO_BUS_ECSI;857 sdio_f0_writeb(func, reg, SDIO_CCCR_IF, &ret);858 if (ret)859 goto disable;860 }861 862 card->ioport = sdio_readb(func, IF_SDIO_IOPORT, &ret);863 if (ret)864 goto disable;865 866 card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 1, &ret) << 8;867 if (ret)868 goto disable;869 870 card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 2, &ret) << 16;871 if (ret)872 goto disable;873 874 sdio_release_host(func);875 ret = if_sdio_prog_firmware(card);876 if (ret) {877 sdio_claim_host(func);878 goto disable;879 }880 881 return 0;882 883disable:884 sdio_disable_func(func);885release:886 sdio_release_host(func);887 return ret;888}889 890static int if_sdio_power_off(struct if_sdio_card *card)891{892 struct sdio_func *func = card->func;893 struct lbs_private *priv = card->priv;894 895 priv->fw_ready = 0;896 897 sdio_claim_host(func);898 sdio_release_irq(func);899 sdio_disable_func(func);900 sdio_release_host(func);901 return 0;902}903 904 905/*******************************************************************/906/* Libertas callbacks */907/*******************************************************************/908 909static int if_sdio_host_to_card(struct lbs_private *priv,910 u8 type, u8 *buf, u16 nb)911{912 int ret;913 struct if_sdio_card *card;914 struct if_sdio_packet *packet;915 u16 size;916 unsigned long flags;917 918 card = priv->card;919 920 if (nb > (65536 - sizeof(struct if_sdio_packet) - 4)) {921 ret = -EINVAL;922 goto out;923 }924 925 /*926 * The transfer must be in one transaction or the firmware927 * goes suicidal. There's no way to guarantee that for all928 * controllers, but we can at least try.929 */930 size = sdio_align_size(card->func, nb + 4);931 932 packet = kzalloc(sizeof(struct if_sdio_packet) + size,933 GFP_ATOMIC);934 if (!packet) {935 ret = -ENOMEM;936 goto out;937 }938 939 packet->nb = size;940 941 /*942 * SDIO specific header.943 */944 packet->buffer[0] = (nb + 4) & 0xff;945 packet->buffer[1] = ((nb + 4) >> 8) & 0xff;946 packet->buffer[2] = type;947 packet->buffer[3] = 0;948 949 memcpy(packet->buffer + 4, buf, nb);950 951 spin_lock_irqsave(&card->lock, flags);952 953 list_add_tail(&packet->list, &card->packets);954 955 switch (type) {956 case MVMS_CMD:957 priv->dnld_sent = DNLD_CMD_SENT;958 break;959 case MVMS_DAT:960 priv->dnld_sent = DNLD_DATA_SENT;961 break;962 default:963 lbs_deb_sdio("unknown packet type %d\n", (int)type);964 }965 966 spin_unlock_irqrestore(&card->lock, flags);967 968 queue_work(card->workqueue, &card->packet_worker);969 970 ret = 0;971 972out:973 return ret;974}975 976static int if_sdio_enter_deep_sleep(struct lbs_private *priv)977{978 int ret;979 struct cmd_header cmd;980 981 memset(&cmd, 0, sizeof(cmd));982 983 lbs_deb_sdio("send DEEP_SLEEP command\n");984 ret = __lbs_cmd(priv, CMD_802_11_DEEP_SLEEP, &cmd, sizeof(cmd),985 lbs_cmd_copyback, (unsigned long) &cmd);986 if (ret)987 netdev_err(priv->dev, "DEEP_SLEEP cmd failed\n");988 989 mdelay(200);990 return ret;991}992 993static int if_sdio_exit_deep_sleep(struct lbs_private *priv)994{995 struct if_sdio_card *card = priv->card;996 int ret = -1;997 998 sdio_claim_host(card->func);999 1000 sdio_writeb(card->func, HOST_POWER_UP, CONFIGURATION_REG, &ret);1001 if (ret)1002 netdev_err(priv->dev, "sdio_writeb failed!\n");1003 1004 sdio_release_host(card->func);1005 1006 return ret;1007}1008 1009static int if_sdio_reset_deep_sleep_wakeup(struct lbs_private *priv)1010{1011 struct if_sdio_card *card = priv->card;1012 int ret = -1;1013 1014 sdio_claim_host(card->func);1015 1016 sdio_writeb(card->func, 0, CONFIGURATION_REG, &ret);1017 if (ret)1018 netdev_err(priv->dev, "sdio_writeb failed!\n");1019 1020 sdio_release_host(card->func);1021 1022 return ret;1023 1024}1025 1026static void if_sdio_reset_card_worker(struct work_struct *work)1027{1028 int ret;1029 const char *name;1030 struct device *dev;1031 struct if_sdio_card *card;1032 struct mmc_host *reset_host;1033 1034 card = container_of(work, struct if_sdio_card, reset_worker);1035 reset_host = card->func->card->host;1036 name = card->priv->dev->name;1037 dev = &card->func->dev;1038 1039 /*1040 * The actual reset operation must be run outside of lbs_thread. This1041 * is because mmc_remove_host() will cause the device to be instantly1042 * destroyed, and the libertas driver then needs to end lbs_thread,1043 * leading to a deadlock.1044 *1045 * We run it in a workqueue totally independent from the if_sdio_card1046 * instance for that reason.1047 */1048 1049 dev_info(dev, "resetting card %s...", name);1050 mmc_remove_host(reset_host);1051 ret = mmc_add_host(reset_host);1052 if (ret)1053 dev_err(dev, "%s: can't add mmc host, error %d\n", name, ret);1054}1055 1056static void if_sdio_reset_card(struct lbs_private *priv)1057{1058 struct if_sdio_card *card = priv->card;1059 1060 if (!work_pending(&card->reset_worker))1061 schedule_work(&card->reset_worker);1062}1063 1064static int if_sdio_power_save(struct lbs_private *priv)1065{1066 struct if_sdio_card *card = priv->card;1067 int ret;1068 1069 flush_workqueue(card->workqueue);1070 1071 ret = if_sdio_power_off(card);1072 1073 /* Let runtime PM know the card is powered off */1074 pm_runtime_put_sync(&card->func->dev);1075 1076 return ret;1077}1078 1079static int if_sdio_power_restore(struct lbs_private *priv)1080{1081 struct if_sdio_card *card = priv->card;1082 int r;1083 1084 /* Make sure the card will not be powered off by runtime PM */1085 pm_runtime_get_sync(&card->func->dev);1086 1087 r = if_sdio_power_on(card);1088 if (r)1089 return r;1090 1091 wait_event(card->pwron_waitq, priv->fw_ready);1092 return 0;1093}1094 1095 1096/*******************************************************************/1097/* SDIO callbacks */1098/*******************************************************************/1099 1100static void if_sdio_interrupt(struct sdio_func *func)1101{1102 int ret;1103 struct if_sdio_card *card;1104 u8 cause;1105 1106 card = sdio_get_drvdata(func);1107 1108 cause = sdio_readb(card->func, IF_SDIO_H_INT_STATUS, &ret);1109 if (ret || !cause)1110 return;1111 1112 lbs_deb_sdio("interrupt: 0x%X\n", (unsigned)cause);1113 1114 sdio_writeb(card->func, ~cause, IF_SDIO_H_INT_STATUS, &ret);1115 if (ret)1116 return;1117 1118 /*1119 * Ignore the define name, this really means the card has1120 * successfully received the command.1121 */1122 card->priv->is_activity_detected = 1;1123 if (cause & IF_SDIO_H_INT_DNLD)1124 lbs_host_to_card_done(card->priv);1125 1126 1127 if (cause & IF_SDIO_H_INT_UPLD) {1128 ret = if_sdio_card_to_host(card);1129 if (ret)1130 return;1131 }1132}1133 1134static int if_sdio_probe(struct sdio_func *func,1135 const struct sdio_device_id *id)1136{1137 struct if_sdio_card *card;1138 struct lbs_private *priv;1139 int ret, i;1140 unsigned int model;1141 struct if_sdio_packet *packet, *tmp;1142 1143 for (i = 0;i < func->card->num_info;i++) {1144 if (sscanf(func->card->info[i],1145 "802.11 SDIO ID: %x", &model) == 1)1146 break;1147 if (sscanf(func->card->info[i],1148 "ID: %x", &model) == 1)1149 break;1150 if (!strcmp(func->card->info[i], "IBIS Wireless SDIO Card")) {1151 model = MODEL_8385;1152 break;1153 }1154 }1155 1156 if (i == func->card->num_info) {1157 pr_err("unable to identify card model\n");1158 return -ENODEV;1159 }1160 1161 card = kzalloc(sizeof(struct if_sdio_card), GFP_KERNEL);1162 if (!card)1163 return -ENOMEM;1164 1165 card->func = func;1166 card->model = model;1167 1168 switch (card->model) {1169 case MODEL_8385:1170 card->scratch_reg = IF_SDIO_SCRATCH_OLD;1171 break;1172 case MODEL_8686:1173 card->scratch_reg = IF_SDIO_SCRATCH;1174 break;1175 case MODEL_8688:1176 default: /* for newer chipsets */1177 card->scratch_reg = IF_SDIO_FW_STATUS;1178 break;1179 }1180 1181 spin_lock_init(&card->lock);1182 INIT_LIST_HEAD(&card->packets);1183 1184 card->workqueue = alloc_workqueue("libertas_sdio", WQ_MEM_RECLAIM, 0);1185 if (unlikely(!card->workqueue)) {1186 ret = -ENOMEM;1187 goto err_queue;1188 }1189 1190 INIT_WORK(&card->reset_worker, if_sdio_reset_card_worker);1191 INIT_WORK(&card->packet_worker, if_sdio_host_to_card_worker);1192 init_waitqueue_head(&card->pwron_waitq);1193 1194 /* Check if we support this card */1195 for (i = 0; i < ARRAY_SIZE(fw_table); i++) {1196 if (card->model == fw_table[i].model)1197 break;1198 }1199 if (i == ARRAY_SIZE(fw_table)) {1200 pr_err("unknown card model 0x%x\n", card->model);1201 ret = -ENODEV;1202 goto free;1203 }1204 1205 sdio_set_drvdata(func, card);1206 1207 lbs_deb_sdio("class = 0x%X, vendor = 0x%X, "1208 "device = 0x%X, model = 0x%X, ioport = 0x%X\n",1209 func->class, func->vendor, func->device,1210 model, (unsigned)card->ioport);1211 1212 1213 priv = lbs_add_card(card, &func->dev);1214 if (IS_ERR(priv)) {1215 ret = PTR_ERR(priv);1216 goto free;1217 }1218 1219 card->priv = priv;1220 1221 priv->card = card;1222 priv->hw_host_to_card = if_sdio_host_to_card;1223 priv->enter_deep_sleep = if_sdio_enter_deep_sleep;1224 priv->exit_deep_sleep = if_sdio_exit_deep_sleep;1225 priv->reset_deep_sleep_wakeup = if_sdio_reset_deep_sleep_wakeup;1226 priv->reset_card = if_sdio_reset_card;1227 priv->power_save = if_sdio_power_save;1228 priv->power_restore = if_sdio_power_restore;1229 priv->is_polling = !(func->card->host->caps & MMC_CAP_SDIO_IRQ);1230 ret = if_sdio_power_on(card);1231 if (ret)1232 goto err_activate_card;1233 1234out:1235 return ret;1236 1237err_activate_card:1238 flush_workqueue(card->workqueue);1239 lbs_remove_card(priv);1240free:1241 cancel_work_sync(&card->packet_worker);1242 cancel_work_sync(&card->reset_worker);1243 destroy_workqueue(card->workqueue);1244err_queue:1245 list_for_each_entry_safe(packet, tmp, &card->packets, list)1246 kfree(packet);1247 1248 kfree(card);1249 1250 goto out;1251}1252 1253static void if_sdio_remove(struct sdio_func *func)1254{1255 struct if_sdio_card *card;1256 struct if_sdio_packet *packet, *tmp;1257 1258 card = sdio_get_drvdata(func);1259 1260 /* Undo decrement done above in if_sdio_probe */1261 pm_runtime_get_noresume(&func->dev);1262 1263 if (user_rmmod && (card->model == MODEL_8688)) {1264 /*1265 * FUNC_SHUTDOWN is required for SD8688 WLAN/BT1266 * multiple functions1267 */1268 struct cmd_header cmd;1269 1270 memset(&cmd, 0, sizeof(cmd));1271 1272 lbs_deb_sdio("send function SHUTDOWN command\n");1273 if (__lbs_cmd(card->priv, CMD_FUNC_SHUTDOWN,1274 &cmd, sizeof(cmd), lbs_cmd_copyback,1275 (unsigned long) &cmd))1276 pr_alert("CMD_FUNC_SHUTDOWN cmd failed\n");1277 }1278 1279 1280 lbs_deb_sdio("call remove card\n");1281 lbs_stop_card(card->priv);1282 lbs_remove_card(card->priv);1283 1284 cancel_work_sync(&card->packet_worker);1285 cancel_work_sync(&card->reset_worker);1286 destroy_workqueue(card->workqueue);1287 1288 list_for_each_entry_safe(packet, tmp, &card->packets, list)1289 kfree(packet);1290 1291 kfree(card);1292}1293 1294static int if_sdio_suspend(struct device *dev)1295{1296 struct sdio_func *func = dev_to_sdio_func(dev);1297 struct if_sdio_card *card = sdio_get_drvdata(func);1298 struct lbs_private *priv = card->priv;1299 int ret;1300 1301 mmc_pm_flag_t flags = sdio_get_host_pm_caps(func);1302 priv->power_up_on_resume = false;1303 1304 /* If we're powered off anyway, just let the mmc layer remove the1305 * card. */1306 if (!lbs_iface_active(priv)) {1307 if (priv->fw_ready) {1308 priv->power_up_on_resume = true;1309 if_sdio_power_off(card);1310 }1311 1312 return 0;1313 }1314 1315 dev_info(dev, "%s: suspend: PM flags = 0x%x\n",1316 sdio_func_id(func), flags);1317 1318 /* If we aren't being asked to wake on anything, we should bail out1319 * and let the SD stack power down the card.1320 */1321 if (priv->wol_criteria == EHS_REMOVE_WAKEUP) {1322 dev_info(dev, "Suspend without wake params -- powering down card\n");1323 if (priv->fw_ready) {1324 ret = lbs_suspend(priv);1325 if (ret)1326 return ret;1327 1328 priv->power_up_on_resume = true;1329 if_sdio_power_off(card);1330 }1331 1332 return 0;1333 }1334 1335 if (!(flags & MMC_PM_KEEP_POWER)) {1336 dev_err(dev, "%s: cannot remain alive while host is suspended\n",1337 sdio_func_id(func));1338 return -ENOSYS;1339 }1340 1341 ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);1342 if (ret)1343 return ret;1344 1345 ret = lbs_suspend(priv);1346 if (ret)1347 return ret;1348 1349 return sdio_set_host_pm_flags(func, MMC_PM_WAKE_SDIO_IRQ);1350}1351 1352static int if_sdio_resume(struct device *dev)1353{1354 struct sdio_func *func = dev_to_sdio_func(dev);1355 struct if_sdio_card *card = sdio_get_drvdata(func);1356 int ret;1357 1358 dev_info(dev, "%s: resume: we're back\n", sdio_func_id(func));1359 1360 if (card->priv->power_up_on_resume) {1361 if_sdio_power_on(card);1362 wait_event(card->pwron_waitq, card->priv->fw_ready);1363 }1364 1365 ret = lbs_resume(card->priv);1366 1367 return ret;1368}1369 1370static const struct dev_pm_ops if_sdio_pm_ops = {1371 .suspend = if_sdio_suspend,1372 .resume = if_sdio_resume,1373};1374 1375static struct sdio_driver if_sdio_driver = {1376 .name = "libertas_sdio",1377 .id_table = if_sdio_ids,1378 .probe = if_sdio_probe,1379 .remove = if_sdio_remove,1380 .drv = {1381 .pm = &if_sdio_pm_ops,1382 },1383};1384 1385/*******************************************************************/1386/* Module functions */1387/*******************************************************************/1388 1389static int __init if_sdio_init_module(void)1390{1391 int ret = 0;1392 1393 printk(KERN_INFO "libertas_sdio: Libertas SDIO driver\n");1394 printk(KERN_INFO "libertas_sdio: Copyright Pierre Ossman\n");1395 1396 ret = sdio_register_driver(&if_sdio_driver);1397 1398 /* Clear the flag in case user removes the card. */1399 user_rmmod = 0;1400 1401 return ret;1402}1403 1404static void __exit if_sdio_exit_module(void)1405{1406 /* Set the flag as user is removing this module. */1407 user_rmmod = 1;1408 1409 sdio_unregister_driver(&if_sdio_driver);1410}1411 1412module_init(if_sdio_init_module);1413module_exit(if_sdio_exit_module);1414 1415MODULE_DESCRIPTION("Libertas SDIO WLAN Driver");1416MODULE_AUTHOR("Pierre Ossman");1417MODULE_LICENSE("GPL");1418