| #include "gl_os.h" |
| |
| #if (CFG_SDIO_1BIT_DATA_MODE == 1) |
| /* |
| * linux/drivers/mmc/core/core.c |
| * |
| * Copyright (C) 2003-2004 Russell King, All Rights Reserved. |
| * SD support Copyright (C) 2004 Ian Molton, All Rights Reserved. |
| * Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved. |
| * MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 as |
| * published by the Free Software Foundation. |
| */ |
| #include <linux/module.h> |
| #include <linux/init.h> |
| #include <linux/interrupt.h> |
| #include <linux/completion.h> |
| #include <linux/device.h> |
| #include <linux/delay.h> |
| #include <linux/pagemap.h> |
| #include <linux/err.h> |
| #include <linux/leds.h> |
| #include <linux/scatterlist.h> |
| #include <linux/log2.h> |
| #include <linux/regulator/consumer.h> |
| |
| #include <linux/mmc/card.h> |
| #include <linux/mmc/host.h> |
| #include <linux/mmc/mmc.h> |
| #include <linux/mmc/sd.h> |
| #include <linux/mmc/sdio.h> |
| |
| |
| #include "test_driver_sdio_ops.h" |
| |
| |
| /* |
| * Internal function that does the actual ios call to the host driver, |
| * optionally printing some debug output. |
| */ |
| static inline void mmc_set_ios(struct mmc_host *host) |
| { |
| struct mmc_ios *ios = &host->ios; |
| |
| pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u width %u timing %u\n", |
| mmc_hostname(host), ios->clock, ios->bus_mode, |
| ios->power_mode, ios->chip_select, ios->vdd, |
| ios->bus_width, ios->timing); |
| |
| host->ops->set_ios(host, ios); |
| } |
| |
| /* |
| * Control chip select pin on a host. |
| */ |
| void mmc_set_chip_select(struct mmc_host *host, int mode) |
| { |
| host->ios.chip_select = mode; |
| mmc_set_ios(host); |
| } |
| |
| /* |
| * Sets the host clock to the highest possible frequency that |
| * is below "hz". |
| */ |
| void mmc_set_clock(struct mmc_host *host, unsigned int hz) |
| { |
| WARN_ON(hz < host->f_min); |
| |
| if (hz > host->f_max) |
| hz = host->f_max; |
| |
| #if 1 |
| pr_debug("%s(): %dHz\n", __func__, hz); |
| #endif |
| |
| host->ios.clock = hz; |
| mmc_set_ios(host); |
| } |
| |
| /* |
| * Change the bus mode (open drain/push-pull) of a host. |
| */ |
| void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode) |
| { |
| host->ios.bus_mode = mode; |
| mmc_set_ios(host); |
| } |
| |
| /* |
| * Change data bus width of a host. |
| */ |
| void mmc_set_bus_width(struct mmc_host *host, unsigned int width) |
| { |
| host->ios.bus_width = width; |
| mmc_set_ios(host); |
| } |
| |
| /* |
| * Mask off any voltages we don't support and select |
| * the lowest voltage |
| */ |
| u32 mmc_select_voltage(struct mmc_host *host, u32 ocr) |
| { |
| int bit; |
| |
| ocr &= host->ocr_avail; |
| |
| bit = ffs(ocr); |
| if (bit) { |
| bit -= 1; |
| |
| ocr &= 3 << bit; |
| |
| host->ios.vdd = bit; |
| mmc_set_ios(host); |
| } else { |
| pr_warn("%s: host doesn't support card's voltages\n", |
| mmc_hostname(host)); |
| ocr = 0; |
| } |
| |
| return ocr; |
| } |
| |
| /* |
| * Select timing parameters for host. |
| */ |
| void mmc_set_timing(struct mmc_host *host, unsigned int timing) |
| { |
| host->ios.timing = timing; |
| mmc_set_ios(host); |
| } |
| |
| |
| static void mmc_power_off(struct mmc_host *host) |
| { |
| host->ios.clock = 0; |
| host->ios.vdd = 0; |
| if (!mmc_host_is_spi(host)) { |
| host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN; |
| host->ios.chip_select = MMC_CS_DONTCARE; |
| } |
| host->ios.power_mode = MMC_POWER_OFF; |
| host->ios.bus_width = MMC_BUS_WIDTH_1; |
| host->ios.timing = MMC_TIMING_LEGACY; |
| mmc_set_ios(host); |
| } |
| |
| /* |
| * Cleanup when the last reference to the bus operator is dropped. |
| */ |
| static void __mmc_release_bus(struct mmc_host *host) |
| { |
| BUG_ON(!host); |
| BUG_ON(host->bus_refs); |
| BUG_ON(!host->bus_dead); |
| |
| host->bus_ops = NULL; |
| } |
| |
| /* |
| * Increase reference count of bus operator |
| */ |
| static inline void mmc_bus_get(struct mmc_host *host) |
| { |
| unsigned long flags; |
| |
| spin_lock_irqsave(&host->lock, flags); |
| host->bus_refs++; |
| spin_unlock_irqrestore(&host->lock, flags); |
| } |
| |
| /* |
| * Decrease reference count of bus operator and free it if |
| * it is the last reference. |
| */ |
| static inline void mmc_bus_put(struct mmc_host *host) |
| { |
| unsigned long flags; |
| |
| spin_lock_irqsave(&host->lock, flags); |
| host->bus_refs--; |
| if ((host->bus_refs == 0) && host->bus_ops) |
| __mmc_release_bus(host); |
| spin_unlock_irqrestore(&host->lock, flags); |
| } |
| |
| /* |
| * Assign a mmc bus handler to a host. Only one bus handler may control a |
| * host at any given time. |
| */ |
| void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops) |
| { |
| unsigned long flags; |
| |
| BUG_ON(!host); |
| BUG_ON(!ops); |
| |
| WARN_ON(!host->claimed); |
| |
| spin_lock_irqsave(&host->lock, flags); |
| |
| BUG_ON(host->bus_ops); |
| BUG_ON(host->bus_refs); |
| |
| host->bus_ops = ops; |
| host->bus_refs = 1; |
| host->bus_dead = 0; |
| |
| spin_unlock_irqrestore(&host->lock, flags); |
| } |
| |
| /* |
| * Remove the current bus handler from a host. Assumes that there are |
| * no interesting cards left, so the bus is powered down. |
| */ |
| void mmc_detach_bus(struct mmc_host *host) |
| { |
| unsigned long flags; |
| |
| BUG_ON(!host); |
| |
| WARN_ON(!host->claimed); |
| WARN_ON(!host->bus_ops); |
| |
| spin_lock_irqsave(&host->lock, flags); |
| |
| host->bus_dead = 1; |
| |
| spin_unlock_irqrestore(&host->lock, flags); |
| |
| mmc_power_off(host); |
| |
| mmc_bus_put(host); |
| } |
| |
| int mmc_app_set_bus_width(struct mmc_card *card, int width) |
| { |
| int err; |
| struct mmc_command cmd; |
| |
| BUG_ON(!card); |
| BUG_ON(!card->host); |
| |
| memset(&cmd, 0, sizeof(struct mmc_command)); |
| |
| cmd.opcode = SD_APP_SET_BUS_WIDTH; |
| cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; |
| |
| switch (width) { |
| case MMC_BUS_WIDTH_1: |
| cmd.arg = SD_BUS_WIDTH_1; |
| break; |
| case MMC_BUS_WIDTH_4: |
| cmd.arg = SD_BUS_WIDTH_4; |
| break; |
| default: |
| return -EINVAL; |
| } |
| |
| err = mmc_wait_for_app_cmd(card->host, card, &cmd, MMC_CMD_RETRIES); |
| if (err) |
| return err; |
| |
| return 0; |
| } |
| |
| int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr) |
| { |
| struct mmc_command cmd; |
| int i, err = 0; |
| |
| BUG_ON(!host); |
| |
| memset(&cmd, 0, sizeof(struct mmc_command)); |
| |
| cmd.opcode = SD_APP_OP_COND; |
| if (mmc_host_is_spi(host)) |
| cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */ |
| else |
| cmd.arg = ocr; |
| cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR; |
| |
| for (i = 100; i; i--) { |
| err = mmc_wait_for_app_cmd(host, NULL, &cmd, MMC_CMD_RETRIES); |
| if (err) |
| break; |
| |
| /* if we're just probing, do a single pass */ |
| if (ocr == 0) |
| break; |
| |
| /* otherwise wait until reset completes */ |
| if (mmc_host_is_spi(host)) { |
| if (!(cmd.resp[0] & R1_SPI_IDLE)) |
| break; |
| } else { |
| if (cmd.resp[0] & MMC_CARD_BUSY) |
| break; |
| } |
| |
| err = -ETIMEDOUT; |
| |
| mmc_delay(10); |
| } |
| |
| if (rocr && !mmc_host_is_spi(host)) |
| *rocr = cmd.resp[0]; |
| |
| return err; |
| } |
| |
| int mmc_send_if_cond(struct mmc_host *host, u32 ocr) |
| { |
| struct mmc_command cmd; |
| int err; |
| static const u8 test_pattern = 0xAA; |
| u8 result_pattern; |
| |
| /* |
| * To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND |
| * before SD_APP_OP_COND. This command will harmlessly fail for |
| * SD 1.0 cards. |
| */ |
| cmd.opcode = SD_SEND_IF_COND; |
| cmd.arg = ((ocr & 0xFF8000) != 0) << 8 | test_pattern; |
| cmd.flags = MMC_RSP_SPI_R7 | MMC_RSP_R7 | MMC_CMD_BCR; |
| |
| err = mmc_wait_for_cmd(host, &cmd, 0); |
| if (err) |
| return err; |
| |
| if (mmc_host_is_spi(host)) |
| result_pattern = cmd.resp[1] & 0xFF; |
| else |
| result_pattern = cmd.resp[0] & 0xFF; |
| |
| if (result_pattern != test_pattern) |
| return -EIO; |
| |
| return 0; |
| } |
| |
| |
| |
| static int sdio_enable_wide(struct mmc_card *card) |
| { |
| int ret; |
| u8 ctrl; |
| |
| if (!(card->host->caps & MMC_CAP_4_BIT_DATA)) |
| return 0; |
| |
| |
| if (card->cccr.low_speed && !card->cccr.wide_bus) |
| return 0; |
| |
| |
| ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl); |
| if (ret) |
| return ret; |
| |
| |
| if ((ctrl & SDIO_BUS_WIDTH_MASK) == SDIO_BUS_WIDTH_RESERVED) |
| pr_warn("%s: SDIO_CCCR_IF is invalid: 0x%02x\n", |
| mmc_hostname(card->host), ctrl); |
| |
| /* set as 4-bit bus width */ |
| ctrl &= ~SDIO_BUS_WIDTH_MASK; |
| ctrl |= SDIO_BUS_WIDTH_4BIT; |
| |
| ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL); |
| if (ret) |
| return ret; |
| |
| return 1; |
| } |
| |
| |
| |
| /* |
| * Devices that remain active during a system suspend are |
| * put back into 1-bit mode. |
| */ |
| int sdio_disable_wide(struct mmc_card *card) |
| { |
| int ret; |
| u8 ctrl; |
| |
| if (!(card->host->caps & MMC_CAP_4_BIT_DATA)) |
| return 0; |
| |
| |
| if (card->cccr.low_speed && !card->cccr.wide_bus) |
| return 0; |
| |
| |
| ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl); |
| if (ret) |
| return ret; |
| |
| |
| if (!(ctrl & SDIO_BUS_WIDTH_4BIT)) |
| return 0; |
| |
| |
| ctrl &= ~SDIO_BUS_WIDTH_4BIT; |
| ctrl |= SDIO_BUS_ASYNC_INT; |
| |
| ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL); |
| if (ret) |
| return ret; |
| |
| |
| mmc_set_bus_width(card->host, MMC_BUS_WIDTH_1); |
| |
| return 0; |
| } |
| |
| |
| int sdio_enable_4bit_bus(struct mmc_card *card) |
| { |
| int err; |
| |
| if (card->type == MMC_TYPE_SDIO) |
| return sdio_enable_wide(card); |
| |
| |
| if ((card->host->caps & MMC_CAP_4_BIT_DATA) && |
| (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) { |
| |
| err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4); |
| if (err) |
| return err; |
| } else |
| return 0; |
| |
| |
| err = sdio_enable_wide(card); |
| if (err <= 0) |
| mmc_app_set_bus_width(card, MMC_BUS_WIDTH_1); |
| |
| return err; |
| } |
| #endif |