| /* |
| * linux/drivers/mmc/host/msm_sdcc.c - Qualcomm MSM 7X00A SDCC Driver |
| * |
| * Copyright (C) 2007 Google Inc, |
| * Copyright (C) 2003 Deep Blue Solutions, Ltd, All Rights Reserved. |
| * Copyright (c) 2009-2012, Code Aurora Forum. 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. |
| * |
| * Based on mmci.c |
| * |
| * Author: San Mehat (san@android.com) |
| * |
| */ |
| |
| #include <linux/module.h> |
| #include <linux/moduleparam.h> |
| #include <linux/init.h> |
| #include <linux/ioport.h> |
| #include <linux/of.h> |
| #include <linux/of_gpio.h> |
| #include <linux/device.h> |
| #include <linux/interrupt.h> |
| #include <linux/irq.h> |
| #include <linux/delay.h> |
| #include <linux/err.h> |
| #include <linux/highmem.h> |
| #include <linux/log2.h> |
| #include <linux/mmc/host.h> |
| #include <linux/mmc/card.h> |
| #include <linux/mmc/mmc.h> |
| #include <linux/mmc/sdio.h> |
| #include <linux/clk.h> |
| #include <linux/scatterlist.h> |
| #include <linux/platform_device.h> |
| #include <linux/dma-mapping.h> |
| #include <linux/debugfs.h> |
| #include <linux/io.h> |
| #include <linux/memory.h> |
| #include <linux/pm_runtime.h> |
| #include <linux/wakelock.h> |
| #include <linux/gpio.h> |
| #include <linux/regulator/consumer.h> |
| #include <linux/slab.h> |
| #include <linux/pm_qos.h> |
| |
| #include <asm/cacheflush.h> |
| #include <asm/div64.h> |
| #include <asm/sizes.h> |
| |
| #include <asm/mach/mmc.h> |
| #include <mach/msm_iomap.h> |
| #include <mach/clk.h> |
| #include <mach/dma.h> |
| #include <mach/sdio_al.h> |
| #include <mach/mpm.h> |
| #include <mach/msm_bus.h> |
| |
| #include "msm_sdcc.h" |
| #include "msm_sdcc_dml.h" |
| |
| #define DRIVER_NAME "msm-sdcc" |
| |
| #define DBG(host, fmt, args...) \ |
| pr_debug("%s: %s: " fmt "\n", mmc_hostname(host->mmc), __func__ , args) |
| |
| #define IRQ_DEBUG 0 |
| #define SPS_SDCC_PRODUCER_PIPE_INDEX 1 |
| #define SPS_SDCC_CONSUMER_PIPE_INDEX 2 |
| #define SPS_CONS_PERIPHERAL 0 |
| #define SPS_PROD_PERIPHERAL 1 |
| /* Use SPS only if transfer size is more than this macro */ |
| #define SPS_MIN_XFER_SIZE MCI_FIFOSIZE |
| |
| #define MSM_MMC_BUS_VOTING_DELAY 200 /* msecs */ |
| |
| #if defined(CONFIG_DEBUG_FS) |
| static void msmsdcc_dbg_createhost(struct msmsdcc_host *); |
| static struct dentry *debugfs_dir; |
| static int msmsdcc_dbg_init(void); |
| #endif |
| |
| static int msmsdcc_prep_xfer(struct msmsdcc_host *host, struct mmc_data |
| *data); |
| |
| static u64 dma_mask = DMA_BIT_MASK(32); |
| static unsigned int msmsdcc_pwrsave = 1; |
| |
| static struct mmc_command dummy52cmd; |
| static struct mmc_request dummy52mrq = { |
| .cmd = &dummy52cmd, |
| .data = NULL, |
| .stop = NULL, |
| }; |
| static struct mmc_command dummy52cmd = { |
| .opcode = SD_IO_RW_DIRECT, |
| .flags = MMC_RSP_PRESENT, |
| .data = NULL, |
| .mrq = &dummy52mrq, |
| }; |
| /* |
| * An array holding the Tuning pattern to compare with when |
| * executing a tuning cycle. |
| */ |
| static const u32 tuning_block_64[] = { |
| 0x00FF0FFF, 0xCCC3CCFF, 0xFFCC3CC3, 0xEFFEFFFE, |
| 0xDDFFDFFF, 0xFBFFFBFF, 0xFF7FFFBF, 0xEFBDF777, |
| 0xF0FFF0FF, 0x3CCCFC0F, 0xCFCC33CC, 0xEEFFEFFF, |
| 0xFDFFFDFF, 0xFFBFFFDF, 0xFFF7FFBB, 0xDE7B7FF7 |
| }; |
| |
| static const u32 tuning_block_128[] = { |
| 0xFF00FFFF, 0x0000FFFF, 0xCCCCFFFF, 0xCCCC33CC, |
| 0xCC3333CC, 0xFFFFCCCC, 0xFFFFEEFF, 0xFFEEEEFF, |
| 0xFFDDFFFF, 0xDDDDFFFF, 0xBBFFFFFF, 0xBBFFFFFF, |
| 0xFFFFFFBB, 0xFFFFFF77, 0x77FF7777, 0xFFEEDDBB, |
| 0x00FFFFFF, 0x00FFFFFF, 0xCCFFFF00, 0xCC33CCCC, |
| 0x3333CCCC, 0xFFCCCCCC, 0xFFEEFFFF, 0xEEEEFFFF, |
| 0xDDFFFFFF, 0xDDFFFFFF, 0xFFFFFFDD, 0xFFFFFFBB, |
| 0xFFFFBBBB, 0xFFFF77FF, 0xFF7777FF, 0xEEDDBB77 |
| }; |
| |
| #if IRQ_DEBUG == 1 |
| static char *irq_status_bits[] = { "cmdcrcfail", "datcrcfail", "cmdtimeout", |
| "dattimeout", "txunderrun", "rxoverrun", |
| "cmdrespend", "cmdsent", "dataend", NULL, |
| "datablkend", "cmdactive", "txactive", |
| "rxactive", "txhalfempty", "rxhalffull", |
| "txfifofull", "rxfifofull", "txfifoempty", |
| "rxfifoempty", "txdataavlbl", "rxdataavlbl", |
| "sdiointr", "progdone", "atacmdcompl", |
| "sdiointrope", "ccstimeout", NULL, NULL, |
| NULL, NULL, NULL }; |
| |
| static void |
| msmsdcc_print_status(struct msmsdcc_host *host, char *hdr, uint32_t status) |
| { |
| int i; |
| |
| pr_debug("%s-%s ", mmc_hostname(host->mmc), hdr); |
| for (i = 0; i < 32; i++) { |
| if (status & (1 << i)) |
| pr_debug("%s ", irq_status_bits[i]); |
| } |
| pr_debug("\n"); |
| } |
| #endif |
| |
| static void |
| msmsdcc_start_command(struct msmsdcc_host *host, struct mmc_command *cmd, |
| u32 c); |
| static inline void msmsdcc_sync_reg_wr(struct msmsdcc_host *host); |
| static inline void msmsdcc_delay(struct msmsdcc_host *host); |
| static void msmsdcc_dump_sdcc_state(struct msmsdcc_host *host); |
| static void msmsdcc_sg_start(struct msmsdcc_host *host); |
| static int msmsdcc_vreg_reset(struct msmsdcc_host *host); |
| static int msmsdcc_runtime_resume(struct device *dev); |
| |
| static inline unsigned short msmsdcc_get_nr_sg(struct msmsdcc_host *host) |
| { |
| unsigned short ret = NR_SG; |
| |
| if (is_sps_mode(host)) { |
| ret = SPS_MAX_DESCS; |
| } else { /* DMA or PIO mode */ |
| if (NR_SG > MAX_NR_SG_DMA_PIO) |
| ret = MAX_NR_SG_DMA_PIO; |
| } |
| |
| return ret; |
| } |
| |
| /* Prevent idle power collapse(pc) while operating in peripheral mode */ |
| static void msmsdcc_pm_qos_update_latency(struct msmsdcc_host *host, int vote) |
| { |
| if (!host->cpu_dma_latency) |
| return; |
| |
| if (vote) |
| pm_qos_update_request(&host->pm_qos_req_dma, |
| host->cpu_dma_latency); |
| else |
| pm_qos_update_request(&host->pm_qos_req_dma, |
| PM_QOS_DEFAULT_VALUE); |
| } |
| |
| #ifdef CONFIG_MMC_MSM_SPS_SUPPORT |
| static int msmsdcc_sps_reset_ep(struct msmsdcc_host *host, |
| struct msmsdcc_sps_ep_conn_data *ep); |
| static int msmsdcc_sps_restore_ep(struct msmsdcc_host *host, |
| struct msmsdcc_sps_ep_conn_data *ep); |
| #else |
| static inline int msmsdcc_sps_init_ep_conn(struct msmsdcc_host *host, |
| struct msmsdcc_sps_ep_conn_data *ep, |
| bool is_producer) { return 0; } |
| static inline void msmsdcc_sps_exit_ep_conn(struct msmsdcc_host *host, |
| struct msmsdcc_sps_ep_conn_data *ep) { } |
| static inline int msmsdcc_sps_reset_ep(struct msmsdcc_host *host, |
| struct msmsdcc_sps_ep_conn_data *ep) |
| { |
| return 0; |
| } |
| static inline int msmsdcc_sps_restore_ep(struct msmsdcc_host *host, |
| struct msmsdcc_sps_ep_conn_data *ep) |
| { |
| return 0; |
| } |
| static inline int msmsdcc_sps_init(struct msmsdcc_host *host) { return 0; } |
| static inline void msmsdcc_sps_exit(struct msmsdcc_host *host) {} |
| #endif /* CONFIG_MMC_MSM_SPS_SUPPORT */ |
| |
| /** |
| * Apply soft reset to all SDCC BAM pipes |
| * |
| * This function applies soft reset to SDCC BAM pipe. |
| * |
| * This function should be called to recover from error |
| * conditions encountered during CMD/DATA tranfsers with card. |
| * |
| * @host - Pointer to driver's host structure |
| * |
| */ |
| static void msmsdcc_sps_pipes_reset_and_restore(struct msmsdcc_host *host) |
| { |
| int rc; |
| |
| /* Reset all SDCC BAM pipes */ |
| rc = msmsdcc_sps_reset_ep(host, &host->sps.prod); |
| if (rc) |
| pr_err("%s:msmsdcc_sps_reset_ep(prod) error=%d\n", |
| mmc_hostname(host->mmc), rc); |
| rc = msmsdcc_sps_reset_ep(host, &host->sps.cons); |
| if (rc) |
| pr_err("%s:msmsdcc_sps_reset_ep(cons) error=%d\n", |
| mmc_hostname(host->mmc), rc); |
| |
| if (host->sps.reset_device) { |
| rc = sps_device_reset(host->sps.bam_handle); |
| if (rc) |
| pr_err("%s: sps_device_reset error=%d\n", |
| mmc_hostname(host->mmc), rc); |
| host->sps.reset_device = false; |
| } |
| |
| /* Restore all BAM pipes connections */ |
| rc = msmsdcc_sps_restore_ep(host, &host->sps.prod); |
| if (rc) |
| pr_err("%s:msmsdcc_sps_restore_ep(prod) error=%d\n", |
| mmc_hostname(host->mmc), rc); |
| rc = msmsdcc_sps_restore_ep(host, &host->sps.cons); |
| if (rc) |
| pr_err("%s:msmsdcc_sps_restore_ep(cons) error=%d\n", |
| mmc_hostname(host->mmc), rc); |
| } |
| |
| /** |
| * Apply soft reset |
| * |
| * This function applies soft reset to SDCC core and DML core. |
| * |
| * This function should be called to recover from error |
| * conditions encountered with CMD/DATA tranfsers with card. |
| * |
| * Soft reset should only be used with SDCC controller v4. |
| * |
| * @host - Pointer to driver's host structure |
| * |
| */ |
| static void msmsdcc_soft_reset(struct msmsdcc_host *host) |
| { |
| /* |
| * Reset controller state machines without resetting |
| * configuration registers (MCI_POWER, MCI_CLK, MCI_INT_MASKn). |
| */ |
| if (is_sw_reset_save_config(host)) { |
| ktime_t start; |
| |
| writel_relaxed(readl_relaxed(host->base + MMCIPOWER) |
| | MCI_SW_RST_CFG, host->base + MMCIPOWER); |
| msmsdcc_sync_reg_wr(host); |
| |
| start = ktime_get(); |
| while (readl_relaxed(host->base + MMCIPOWER) & MCI_SW_RST_CFG) { |
| /* |
| * SW reset can take upto 10HCLK + 15MCLK cycles. |
| * Calculating based on min clk rates (hclk = 27MHz, |
| * mclk = 400KHz) it comes to ~40us. Let's poll for |
| * max. 1ms for reset completion. |
| */ |
| if (ktime_to_us(ktime_sub(ktime_get(), start)) > 1000) { |
| pr_err("%s: %s failed\n", |
| mmc_hostname(host->mmc), __func__); |
| BUG(); |
| } |
| } |
| } else { |
| writel_relaxed(0, host->base + MMCICOMMAND); |
| msmsdcc_sync_reg_wr(host); |
| writel_relaxed(0, host->base + MMCIDATACTRL); |
| msmsdcc_sync_reg_wr(host); |
| } |
| } |
| |
| static void msmsdcc_hard_reset(struct msmsdcc_host *host) |
| { |
| int ret; |
| |
| /* |
| * Reset SDCC controller to power on default state. |
| * Don't issue a reset request to clock control block if |
| * SDCC controller itself can support hard reset. |
| */ |
| if (is_sw_hard_reset(host)) { |
| ktime_t start; |
| |
| writel_relaxed(readl_relaxed(host->base + MMCIPOWER) |
| | MCI_SW_RST, host->base + MMCIPOWER); |
| msmsdcc_sync_reg_wr(host); |
| |
| start = ktime_get(); |
| while (readl_relaxed(host->base + MMCIPOWER) & MCI_SW_RST) { |
| /* |
| * See comment in msmsdcc_soft_reset() on choosing 1ms |
| * poll timeout. |
| */ |
| if (ktime_to_us(ktime_sub(ktime_get(), start)) > 1000) { |
| pr_err("%s: %s failed\n", |
| mmc_hostname(host->mmc), __func__); |
| BUG(); |
| } |
| } |
| } else { |
| ret = clk_reset(host->clk, CLK_RESET_ASSERT); |
| if (ret) |
| pr_err("%s: Clock assert failed at %u Hz" \ |
| " with err %d\n", mmc_hostname(host->mmc), |
| host->clk_rate, ret); |
| |
| ret = clk_reset(host->clk, CLK_RESET_DEASSERT); |
| if (ret) |
| pr_err("%s: Clock deassert failed at %u Hz" \ |
| " with err %d\n", mmc_hostname(host->mmc), |
| host->clk_rate, ret); |
| |
| mb(); |
| /* Give some delay for clock reset to propogate to controller */ |
| msmsdcc_delay(host); |
| } |
| } |
| |
| static void msmsdcc_reset_and_restore(struct msmsdcc_host *host) |
| { |
| if (is_soft_reset(host)) { |
| if (is_sps_mode(host)) { |
| /* Reset DML first */ |
| msmsdcc_dml_reset(host); |
| /* |
| * delay the SPS pipe reset in thread context as |
| * sps_connect/sps_disconnect APIs can be called |
| * only from non-atomic context. |
| */ |
| host->sps.pipe_reset_pending = true; |
| } |
| mb(); |
| msmsdcc_soft_reset(host); |
| |
| pr_debug("%s: Applied soft reset to Controller\n", |
| mmc_hostname(host->mmc)); |
| |
| if (is_sps_mode(host)) |
| msmsdcc_dml_init(host); |
| } else { |
| /* Give Clock reset (hard reset) to controller */ |
| u32 mci_clk = 0; |
| u32 mci_mask0 = 0; |
| |
| /* Save the controller state */ |
| mci_clk = readl_relaxed(host->base + MMCICLOCK); |
| mci_mask0 = readl_relaxed(host->base + MMCIMASK0); |
| host->pwr = readl_relaxed(host->base + MMCIPOWER); |
| mb(); |
| |
| msmsdcc_hard_reset(host); |
| pr_debug("%s: Controller has been reinitialized\n", |
| mmc_hostname(host->mmc)); |
| |
| /* Restore the contoller state */ |
| writel_relaxed(host->pwr, host->base + MMCIPOWER); |
| msmsdcc_sync_reg_wr(host); |
| writel_relaxed(mci_clk, host->base + MMCICLOCK); |
| msmsdcc_sync_reg_wr(host); |
| writel_relaxed(mci_mask0, host->base + MMCIMASK0); |
| mb(); /* no delay required after writing to MASK0 register */ |
| } |
| |
| if (host->dummy_52_needed) |
| host->dummy_52_needed = 0; |
| } |
| |
| static void msmsdcc_reset_dpsm(struct msmsdcc_host *host) |
| { |
| struct mmc_request *mrq = host->curr.mrq; |
| |
| if (!mrq || !mrq->cmd || (!mrq->data && !host->pending_dpsm_reset)) |
| goto out; |
| |
| /* |
| * For CMD24, if auto prog done is not supported defer |
| * dpsm reset until prog done is received. Otherwise, |
| * we poll here unnecessarily as TXACTIVE will not be |
| * deasserted until DAT0 goes high. |
| */ |
| if ((mrq->cmd->opcode == MMC_WRITE_BLOCK) && !is_auto_prog_done(host)) { |
| host->pending_dpsm_reset = true; |
| goto out; |
| } |
| |
| /* Make sure h/w (TX/RX) is inactive before resetting DPSM */ |
| if (is_wait_for_tx_rx_active(host)) { |
| ktime_t start = ktime_get(); |
| |
| while (readl_relaxed(host->base + MMCISTATUS) & |
| (MCI_TXACTIVE | MCI_RXACTIVE)) { |
| /* |
| * TX/RX active bits may be asserted for 4HCLK + 4MCLK |
| * cycles (~11us) after data transfer due to clock mux |
| * switching delays. Let's poll for 1ms and panic if |
| * still active. |
| */ |
| if (ktime_to_us(ktime_sub(ktime_get(), start)) > 1000) { |
| pr_err("%s: %s still active\n", |
| mmc_hostname(host->mmc), |
| readl_relaxed(host->base + MMCISTATUS) |
| & MCI_TXACTIVE ? "TX" : "RX"); |
| msmsdcc_dump_sdcc_state(host); |
| BUG(); |
| } |
| } |
| } |
| |
| writel_relaxed(0, host->base + MMCIDATACTRL); |
| msmsdcc_sync_reg_wr(host); /* Allow the DPSM to be reset */ |
| host->pending_dpsm_reset = false; |
| out: |
| return; |
| } |
| |
| static int |
| msmsdcc_request_end(struct msmsdcc_host *host, struct mmc_request *mrq) |
| { |
| int retval = 0; |
| |
| BUG_ON(host->curr.data); |
| |
| del_timer(&host->req_tout_timer); |
| |
| if (mrq->data) |
| mrq->data->bytes_xfered = host->curr.data_xfered; |
| if (mrq->cmd->error == -ETIMEDOUT) |
| mdelay(5); |
| |
| msmsdcc_reset_dpsm(host); |
| |
| /* Clear current request information as current request has ended */ |
| memset(&host->curr, 0, sizeof(struct msmsdcc_curr_req)); |
| |
| /* |
| * Need to drop the host lock here; mmc_request_done may call |
| * back into the driver... |
| */ |
| spin_unlock(&host->lock); |
| mmc_request_done(host->mmc, mrq); |
| spin_lock(&host->lock); |
| |
| return retval; |
| } |
| |
| static void |
| msmsdcc_stop_data(struct msmsdcc_host *host) |
| { |
| host->curr.data = NULL; |
| host->curr.got_dataend = 0; |
| host->curr.wait_for_auto_prog_done = false; |
| host->curr.got_auto_prog_done = false; |
| } |
| |
| static inline uint32_t msmsdcc_fifo_addr(struct msmsdcc_host *host) |
| { |
| return host->core_memres->start + MMCIFIFO; |
| } |
| |
| static inline unsigned int msmsdcc_get_min_sup_clk_rate( |
| struct msmsdcc_host *host); |
| |
| static inline void msmsdcc_sync_reg_wr(struct msmsdcc_host *host) |
| { |
| mb(); |
| if (!is_wait_for_reg_write(host)) |
| udelay(host->reg_write_delay); |
| else if (readl_relaxed(host->base + MCI_STATUS2) & |
| MCI_MCLK_REG_WR_ACTIVE) { |
| ktime_t start, diff; |
| |
| start = ktime_get(); |
| while (readl_relaxed(host->base + MCI_STATUS2) & |
| MCI_MCLK_REG_WR_ACTIVE) { |
| diff = ktime_sub(ktime_get(), start); |
| /* poll for max. 1 ms */ |
| if (ktime_to_us(diff) > 1000) { |
| pr_warning("%s: previous reg. write is" |
| " still active\n", |
| mmc_hostname(host->mmc)); |
| break; |
| } |
| } |
| } |
| } |
| |
| static inline void msmsdcc_delay(struct msmsdcc_host *host) |
| { |
| udelay(host->reg_write_delay); |
| |
| } |
| |
| static inline void |
| msmsdcc_start_command_exec(struct msmsdcc_host *host, u32 arg, u32 c) |
| { |
| writel_relaxed(arg, host->base + MMCIARGUMENT); |
| writel_relaxed(c, host->base + MMCICOMMAND); |
| /* |
| * As after sending the command, we don't write any of the |
| * controller registers and just wait for the |
| * CMD_RESPOND_END/CMD_SENT/Command failure notication |
| * from Controller. |
| */ |
| mb(); |
| } |
| |
| static void |
| msmsdcc_dma_exec_func(struct msm_dmov_cmd *cmd) |
| { |
| struct msmsdcc_host *host = (struct msmsdcc_host *)cmd->user; |
| |
| writel_relaxed(host->cmd_timeout, host->base + MMCIDATATIMER); |
| writel_relaxed((unsigned int)host->curr.xfer_size, |
| host->base + MMCIDATALENGTH); |
| writel_relaxed(host->cmd_datactrl, host->base + MMCIDATACTRL); |
| msmsdcc_sync_reg_wr(host); /* Force delay prior to ADM or command */ |
| |
| if (host->cmd_cmd) { |
| msmsdcc_start_command_exec(host, |
| (u32)host->cmd_cmd->arg, (u32)host->cmd_c); |
| } |
| } |
| |
| static void |
| msmsdcc_dma_complete_tlet(unsigned long data) |
| { |
| struct msmsdcc_host *host = (struct msmsdcc_host *)data; |
| unsigned long flags; |
| struct mmc_request *mrq; |
| |
| spin_lock_irqsave(&host->lock, flags); |
| mrq = host->curr.mrq; |
| BUG_ON(!mrq); |
| |
| if (!(host->dma.result & DMOV_RSLT_VALID)) { |
| pr_err("msmsdcc: Invalid DataMover result\n"); |
| goto out; |
| } |
| |
| if (host->dma.result & DMOV_RSLT_DONE) { |
| host->curr.data_xfered = host->curr.xfer_size; |
| host->curr.xfer_remain -= host->curr.xfer_size; |
| } else { |
| /* Error or flush */ |
| if (host->dma.result & DMOV_RSLT_ERROR) |
| pr_err("%s: DMA error (0x%.8x)\n", |
| mmc_hostname(host->mmc), host->dma.result); |
| if (host->dma.result & DMOV_RSLT_FLUSH) |
| pr_err("%s: DMA channel flushed (0x%.8x)\n", |
| mmc_hostname(host->mmc), host->dma.result); |
| pr_err("Flush data: %.8x %.8x %.8x %.8x %.8x %.8x\n", |
| host->dma.err.flush[0], host->dma.err.flush[1], |
| host->dma.err.flush[2], host->dma.err.flush[3], |
| host->dma.err.flush[4], |
| host->dma.err.flush[5]); |
| msmsdcc_reset_and_restore(host); |
| if (!mrq->data->error) |
| mrq->data->error = -EIO; |
| } |
| if (!mrq->data->host_cookie) |
| dma_unmap_sg(mmc_dev(host->mmc), host->dma.sg, |
| host->dma.num_ents, host->dma.dir); |
| |
| if (host->curr.user_pages) { |
| struct scatterlist *sg = host->dma.sg; |
| int i; |
| |
| for (i = 0; i < host->dma.num_ents; i++, sg++) |
| flush_dcache_page(sg_page(sg)); |
| } |
| |
| host->dma.sg = NULL; |
| host->dma.busy = 0; |
| |
| if ((host->curr.got_dataend && (!host->curr.wait_for_auto_prog_done || |
| (host->curr.wait_for_auto_prog_done && |
| host->curr.got_auto_prog_done))) || mrq->data->error) { |
| /* |
| * If we've already gotten our DATAEND / DATABLKEND |
| * for this request, then complete it through here. |
| */ |
| |
| if (!mrq->data->error) { |
| host->curr.data_xfered = host->curr.xfer_size; |
| host->curr.xfer_remain -= host->curr.xfer_size; |
| } |
| if (host->dummy_52_needed) { |
| mrq->data->bytes_xfered = host->curr.data_xfered; |
| host->dummy_52_sent = 1; |
| msmsdcc_start_command(host, &dummy52cmd, |
| MCI_CPSM_PROGENA); |
| goto out; |
| } |
| msmsdcc_stop_data(host); |
| if (!mrq->data->stop || mrq->cmd->error || |
| (mrq->sbc && !mrq->data->error)) { |
| mrq->data->bytes_xfered = host->curr.data_xfered; |
| msmsdcc_reset_dpsm(host); |
| del_timer(&host->req_tout_timer); |
| /* |
| * Clear current request information as current |
| * request has ended |
| */ |
| memset(&host->curr, 0, sizeof(struct msmsdcc_curr_req)); |
| spin_unlock_irqrestore(&host->lock, flags); |
| |
| mmc_request_done(host->mmc, mrq); |
| return; |
| } else if (mrq->data->stop && ((mrq->sbc && mrq->data->error) |
| || !mrq->sbc)) { |
| msmsdcc_start_command(host, mrq->data->stop, 0); |
| } |
| } |
| |
| out: |
| spin_unlock_irqrestore(&host->lock, flags); |
| return; |
| } |
| |
| #ifdef CONFIG_MMC_MSM_SPS_SUPPORT |
| /** |
| * Callback notification from SPS driver |
| * |
| * This callback function gets triggered called from |
| * SPS driver when requested SPS data transfer is |
| * completed. |
| * |
| * SPS driver invokes this callback in BAM irq context so |
| * SDCC driver schedule a tasklet for further processing |
| * this callback notification at later point of time in |
| * tasklet context and immediately returns control back |
| * to SPS driver. |
| * |
| * @nofity - Pointer to sps event notify sturcture |
| * |
| */ |
| static void |
| msmsdcc_sps_complete_cb(struct sps_event_notify *notify) |
| { |
| struct msmsdcc_host *host = |
| (struct msmsdcc_host *) |
| ((struct sps_event_notify *)notify)->user; |
| |
| host->sps.notify = *notify; |
| pr_debug("%s: %s: sps ev_id=%d, addr=0x%x, size=0x%x, flags=0x%x\n", |
| mmc_hostname(host->mmc), __func__, notify->event_id, |
| notify->data.transfer.iovec.addr, |
| notify->data.transfer.iovec.size, |
| notify->data.transfer.iovec.flags); |
| /* Schedule a tasklet for completing data transfer */ |
| tasklet_schedule(&host->sps.tlet); |
| } |
| |
| /** |
| * Tasklet handler for processing SPS callback event |
| * |
| * This function processing SPS event notification and |
| * checks if the SPS transfer is completed or not and |
| * then accordingly notifies status to MMC core layer. |
| * |
| * This function is called in tasklet context. |
| * |
| * @data - Pointer to sdcc driver data |
| * |
| */ |
| static void msmsdcc_sps_complete_tlet(unsigned long data) |
| { |
| unsigned long flags; |
| int i, rc; |
| u32 data_xfered = 0; |
| struct mmc_request *mrq; |
| struct sps_iovec iovec; |
| struct sps_pipe *sps_pipe_handle; |
| struct msmsdcc_host *host = (struct msmsdcc_host *)data; |
| struct sps_event_notify *notify = &host->sps.notify; |
| |
| spin_lock_irqsave(&host->lock, flags); |
| if (host->sps.dir == DMA_FROM_DEVICE) |
| sps_pipe_handle = host->sps.prod.pipe_handle; |
| else |
| sps_pipe_handle = host->sps.cons.pipe_handle; |
| mrq = host->curr.mrq; |
| |
| if (!mrq) { |
| spin_unlock_irqrestore(&host->lock, flags); |
| return; |
| } |
| |
| pr_debug("%s: %s: sps event_id=%d\n", |
| mmc_hostname(host->mmc), __func__, |
| notify->event_id); |
| |
| /* |
| * Got End of transfer event!!! Check if all of the data |
| * has been transferred? |
| */ |
| for (i = 0; i < host->sps.xfer_req_cnt; i++) { |
| rc = sps_get_iovec(sps_pipe_handle, &iovec); |
| if (rc) { |
| pr_err("%s: %s: sps_get_iovec() failed rc=%d, i=%d", |
| mmc_hostname(host->mmc), __func__, rc, i); |
| break; |
| } |
| data_xfered += iovec.size; |
| } |
| |
| if (data_xfered == host->curr.xfer_size) { |
| host->curr.data_xfered = host->curr.xfer_size; |
| host->curr.xfer_remain -= host->curr.xfer_size; |
| pr_debug("%s: Data xfer success. data_xfered=0x%x", |
| mmc_hostname(host->mmc), |
| host->curr.xfer_size); |
| } else { |
| pr_err("%s: Data xfer failed. data_xfered=0x%x," |
| " xfer_size=%d", mmc_hostname(host->mmc), |
| data_xfered, host->curr.xfer_size); |
| msmsdcc_reset_and_restore(host); |
| if (!mrq->data->error) |
| mrq->data->error = -EIO; |
| } |
| |
| /* Unmap sg buffers */ |
| if (!mrq->data->host_cookie) |
| dma_unmap_sg(mmc_dev(host->mmc), host->sps.sg, |
| host->sps.num_ents, host->sps.dir); |
| host->sps.sg = NULL; |
| host->sps.busy = 0; |
| |
| if ((host->curr.got_dataend && (!host->curr.wait_for_auto_prog_done || |
| (host->curr.wait_for_auto_prog_done && |
| host->curr.got_auto_prog_done))) || mrq->data->error) { |
| /* |
| * If we've already gotten our DATAEND / DATABLKEND |
| * for this request, then complete it through here. |
| */ |
| |
| if (!mrq->data->error) { |
| host->curr.data_xfered = host->curr.xfer_size; |
| host->curr.xfer_remain -= host->curr.xfer_size; |
| } |
| if (host->dummy_52_needed) { |
| mrq->data->bytes_xfered = host->curr.data_xfered; |
| host->dummy_52_sent = 1; |
| msmsdcc_start_command(host, &dummy52cmd, |
| MCI_CPSM_PROGENA); |
| spin_unlock_irqrestore(&host->lock, flags); |
| return; |
| } |
| msmsdcc_stop_data(host); |
| if (!mrq->data->stop || mrq->cmd->error || |
| (mrq->sbc && !mrq->data->error)) { |
| mrq->data->bytes_xfered = host->curr.data_xfered; |
| msmsdcc_reset_dpsm(host); |
| del_timer(&host->req_tout_timer); |
| /* |
| * Clear current request information as current |
| * request has ended |
| */ |
| memset(&host->curr, 0, sizeof(struct msmsdcc_curr_req)); |
| spin_unlock_irqrestore(&host->lock, flags); |
| |
| mmc_request_done(host->mmc, mrq); |
| return; |
| } else if (mrq->data->stop && ((mrq->sbc && mrq->data->error) |
| || !mrq->sbc)) { |
| msmsdcc_start_command(host, mrq->data->stop, 0); |
| } |
| } |
| spin_unlock_irqrestore(&host->lock, flags); |
| } |
| |
| /** |
| * Exit from current SPS data transfer |
| * |
| * This function exits from current SPS data transfer. |
| * |
| * This function should be called when error condition |
| * is encountered during data transfer. |
| * |
| * @host - Pointer to sdcc host structure |
| * |
| */ |
| static void msmsdcc_sps_exit_curr_xfer(struct msmsdcc_host *host) |
| { |
| struct mmc_request *mrq; |
| |
| mrq = host->curr.mrq; |
| BUG_ON(!mrq); |
| |
| msmsdcc_reset_and_restore(host); |
| if (!mrq->data->error) |
| mrq->data->error = -EIO; |
| |
| /* Unmap sg buffers */ |
| if (!mrq->data->host_cookie) |
| dma_unmap_sg(mmc_dev(host->mmc), host->sps.sg, |
| host->sps.num_ents, host->sps.dir); |
| |
| host->sps.sg = NULL; |
| host->sps.busy = 0; |
| if (host->curr.data) |
| msmsdcc_stop_data(host); |
| |
| if (!mrq->data->stop || mrq->cmd->error || |
| (mrq->sbc && !mrq->data->error)) |
| msmsdcc_request_end(host, mrq); |
| else if (mrq->data->stop && ((mrq->sbc && mrq->data->error) |
| || !mrq->sbc)) |
| msmsdcc_start_command(host, mrq->data->stop, 0); |
| |
| } |
| #else |
| static inline void msmsdcc_sps_complete_cb(struct sps_event_notify *notify) { } |
| static inline void msmsdcc_sps_complete_tlet(unsigned long data) { } |
| static inline void msmsdcc_sps_exit_curr_xfer(struct msmsdcc_host *host) { } |
| #endif /* CONFIG_MMC_MSM_SPS_SUPPORT */ |
| |
| static int msmsdcc_enable_cdr_cm_sdc4_dll(struct msmsdcc_host *host); |
| |
| static void |
| msmsdcc_dma_complete_func(struct msm_dmov_cmd *cmd, |
| unsigned int result, |
| struct msm_dmov_errdata *err) |
| { |
| struct msmsdcc_dma_data *dma_data = |
| container_of(cmd, struct msmsdcc_dma_data, hdr); |
| struct msmsdcc_host *host = dma_data->host; |
| |
| dma_data->result = result; |
| if (err) |
| memcpy(&dma_data->err, err, sizeof(struct msm_dmov_errdata)); |
| |
| tasklet_schedule(&host->dma_tlet); |
| } |
| |
| static bool msmsdcc_is_dma_possible(struct msmsdcc_host *host, |
| struct mmc_data *data) |
| { |
| bool ret = true; |
| u32 xfer_size = data->blksz * data->blocks; |
| |
| if (host->enforce_pio_mode) { |
| ret = false; |
| goto out; |
| } |
| if (is_sps_mode(host)) { |
| /* |
| * BAM Mode: Fall back on PIO if size is less |
| * than or equal to SPS_MIN_XFER_SIZE bytes. |
| */ |
| if (xfer_size <= SPS_MIN_XFER_SIZE) |
| ret = false; |
| } else if (is_dma_mode(host)) { |
| /* |
| * ADM Mode: Fall back on PIO if size is less than FIFO size |
| * or not integer multiple of FIFO size |
| */ |
| if (xfer_size % MCI_FIFOSIZE) |
| ret = false; |
| } else { |
| /* PIO Mode */ |
| ret = false; |
| } |
| out: |
| return ret; |
| } |
| |
| static int msmsdcc_config_dma(struct msmsdcc_host *host, struct mmc_data *data) |
| { |
| struct msmsdcc_nc_dmadata *nc; |
| dmov_box *box; |
| uint32_t rows; |
| unsigned int n; |
| int i, err = 0, box_cmd_cnt = 0; |
| struct scatterlist *sg = data->sg; |
| unsigned int len, offset; |
| |
| if ((host->dma.channel == -1) || (host->dma.crci == -1)) |
| return -ENOENT; |
| |
| BUG_ON((host->pdev_id < 1) || (host->pdev_id > 5)); |
| |
| host->dma.sg = data->sg; |
| host->dma.num_ents = data->sg_len; |
| |
| /* Prevent memory corruption */ |
| BUG_ON(host->dma.num_ents > msmsdcc_get_nr_sg(host)); |
| |
| nc = host->dma.nc; |
| |
| if (data->flags & MMC_DATA_READ) |
| host->dma.dir = DMA_FROM_DEVICE; |
| else |
| host->dma.dir = DMA_TO_DEVICE; |
| |
| if (!data->host_cookie) { |
| n = msmsdcc_prep_xfer(host, data); |
| if (unlikely(n < 0)) { |
| host->dma.sg = NULL; |
| host->dma.num_ents = 0; |
| return -ENOMEM; |
| } |
| } |
| |
| /* host->curr.user_pages = (data->flags & MMC_DATA_USERPAGE); */ |
| host->curr.user_pages = 0; |
| box = &nc->cmd[0]; |
| for (i = 0; i < host->dma.num_ents; i++) { |
| len = sg_dma_len(sg); |
| offset = 0; |
| |
| do { |
| /* Check if we can do DMA */ |
| if (!len || (box_cmd_cnt >= MMC_MAX_DMA_CMDS)) { |
| err = -ENOTSUPP; |
| goto unmap; |
| } |
| |
| box->cmd = CMD_MODE_BOX; |
| |
| if (len >= MMC_MAX_DMA_BOX_LENGTH) { |
| len = MMC_MAX_DMA_BOX_LENGTH; |
| len -= len % data->blksz; |
| } |
| rows = (len % MCI_FIFOSIZE) ? |
| (len / MCI_FIFOSIZE) + 1 : |
| (len / MCI_FIFOSIZE); |
| |
| if (data->flags & MMC_DATA_READ) { |
| box->src_row_addr = msmsdcc_fifo_addr(host); |
| box->dst_row_addr = sg_dma_address(sg) + offset; |
| box->src_dst_len = (MCI_FIFOSIZE << 16) | |
| (MCI_FIFOSIZE); |
| box->row_offset = MCI_FIFOSIZE; |
| box->num_rows = rows * ((1 << 16) + 1); |
| box->cmd |= CMD_SRC_CRCI(host->dma.crci); |
| } else { |
| box->src_row_addr = sg_dma_address(sg) + offset; |
| box->dst_row_addr = msmsdcc_fifo_addr(host); |
| box->src_dst_len = (MCI_FIFOSIZE << 16) | |
| (MCI_FIFOSIZE); |
| box->row_offset = (MCI_FIFOSIZE << 16); |
| box->num_rows = rows * ((1 << 16) + 1); |
| box->cmd |= CMD_DST_CRCI(host->dma.crci); |
| } |
| |
| offset += len; |
| len = sg_dma_len(sg) - offset; |
| box++; |
| box_cmd_cnt++; |
| } while (len); |
| sg++; |
| } |
| /* Mark last command */ |
| box--; |
| box->cmd |= CMD_LC; |
| |
| /* location of command block must be 64 bit aligned */ |
| BUG_ON(host->dma.cmd_busaddr & 0x07); |
| |
| nc->cmdptr = (host->dma.cmd_busaddr >> 3) | CMD_PTR_LP; |
| host->dma.hdr.cmdptr = DMOV_CMD_PTR_LIST | |
| DMOV_CMD_ADDR(host->dma.cmdptr_busaddr); |
| host->dma.hdr.complete_func = msmsdcc_dma_complete_func; |
| |
| /* Flush all data to memory before starting dma */ |
| mb(); |
| |
| unmap: |
| if (err) { |
| if (!data->host_cookie) |
| dma_unmap_sg(mmc_dev(host->mmc), host->dma.sg, |
| host->dma.num_ents, host->dma.dir); |
| pr_err("%s: cannot do DMA, fall back to PIO mode err=%d\n", |
| mmc_hostname(host->mmc), err); |
| } |
| |
| return err; |
| } |
| |
| static int msmsdcc_prep_xfer(struct msmsdcc_host *host, |
| struct mmc_data *data) |
| { |
| int rc = 0; |
| unsigned int dir; |
| |
| /* Prevent memory corruption */ |
| BUG_ON(data->sg_len > msmsdcc_get_nr_sg(host)); |
| |
| if (data->flags & MMC_DATA_READ) |
| dir = DMA_FROM_DEVICE; |
| else |
| dir = DMA_TO_DEVICE; |
| |
| /* Make sg buffers DMA ready */ |
| rc = dma_map_sg(mmc_dev(host->mmc), data->sg, data->sg_len, |
| dir); |
| |
| if (unlikely(rc != data->sg_len)) { |
| pr_err("%s: Unable to map in all sg elements, rc=%d\n", |
| mmc_hostname(host->mmc), rc); |
| rc = -ENOMEM; |
| goto dma_map_err; |
| } |
| |
| pr_debug("%s: %s: %s: sg_len=%d\n", |
| mmc_hostname(host->mmc), __func__, |
| dir == DMA_FROM_DEVICE ? "READ" : "WRITE", |
| data->sg_len); |
| |
| goto out; |
| |
| dma_map_err: |
| dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len, |
| data->flags); |
| out: |
| return rc; |
| } |
| #ifdef CONFIG_MMC_MSM_SPS_SUPPORT |
| /** |
| * Submits data transfer request to SPS driver |
| * |
| * This function make sg (scatter gather) data buffers |
| * DMA ready and then submits them to SPS driver for |
| * transfer. |
| * |
| * @host - Pointer to sdcc host structure |
| * @data - Pointer to mmc_data structure |
| * |
| * @return 0 if success else negative value |
| */ |
| static int msmsdcc_sps_start_xfer(struct msmsdcc_host *host, |
| struct mmc_data *data) |
| { |
| int rc = 0; |
| u32 flags; |
| int i; |
| u32 addr, len, data_cnt; |
| struct scatterlist *sg = data->sg; |
| struct sps_pipe *sps_pipe_handle; |
| |
| host->sps.sg = data->sg; |
| host->sps.num_ents = data->sg_len; |
| host->sps.xfer_req_cnt = 0; |
| if (data->flags & MMC_DATA_READ) { |
| host->sps.dir = DMA_FROM_DEVICE; |
| sps_pipe_handle = host->sps.prod.pipe_handle; |
| } else { |
| host->sps.dir = DMA_TO_DEVICE; |
| sps_pipe_handle = host->sps.cons.pipe_handle; |
| } |
| |
| if (!data->host_cookie) { |
| rc = msmsdcc_prep_xfer(host, data); |
| if (unlikely(rc < 0)) { |
| host->dma.sg = NULL; |
| host->dma.num_ents = 0; |
| goto out; |
| } |
| } |
| |
| for (i = 0; i < data->sg_len; i++) { |
| /* |
| * Check if this is the last buffer to transfer? |
| * If yes then set the INT and EOT flags. |
| */ |
| len = sg_dma_len(sg); |
| addr = sg_dma_address(sg); |
| flags = 0; |
| while (len > 0) { |
| if (len > SPS_MAX_DESC_SIZE) { |
| data_cnt = SPS_MAX_DESC_SIZE; |
| } else { |
| data_cnt = len; |
| if (i == data->sg_len - 1) |
| flags = SPS_IOVEC_FLAG_INT | |
| SPS_IOVEC_FLAG_EOT; |
| } |
| rc = sps_transfer_one(sps_pipe_handle, addr, |
| data_cnt, host, flags); |
| if (rc) { |
| pr_err("%s: sps_transfer_one() error! rc=%d," |
| " pipe=0x%x, sg=0x%x, sg_buf_no=%d\n", |
| mmc_hostname(host->mmc), rc, |
| (u32)sps_pipe_handle, (u32)sg, i); |
| goto dma_map_err; |
| } |
| addr += data_cnt; |
| len -= data_cnt; |
| host->sps.xfer_req_cnt++; |
| } |
| sg++; |
| } |
| goto out; |
| |
| dma_map_err: |
| /* unmap sg buffers */ |
| if (!data->host_cookie) |
| dma_unmap_sg(mmc_dev(host->mmc), host->sps.sg, |
| host->sps.num_ents, host->sps.dir); |
| out: |
| return rc; |
| } |
| #else |
| static int msmsdcc_sps_start_xfer(struct msmsdcc_host *host, |
| struct mmc_data *data) { return 0; } |
| #endif /* CONFIG_MMC_MSM_SPS_SUPPORT */ |
| |
| static void |
| msmsdcc_start_command_deferred(struct msmsdcc_host *host, |
| struct mmc_command *cmd, u32 *c) |
| { |
| DBG(host, "op %02x arg %08x flags %08x\n", |
| cmd->opcode, cmd->arg, cmd->flags); |
| |
| *c |= (cmd->opcode | MCI_CPSM_ENABLE); |
| |
| if (cmd->flags & MMC_RSP_PRESENT) { |
| if (cmd->flags & MMC_RSP_136) |
| *c |= MCI_CPSM_LONGRSP; |
| *c |= MCI_CPSM_RESPONSE; |
| } |
| |
| if (/*interrupt*/0) |
| *c |= MCI_CPSM_INTERRUPT; |
| |
| /* DAT_CMD bit should be set for all ADTC */ |
| if (mmc_cmd_type(cmd) == MMC_CMD_ADTC) |
| *c |= MCI_CSPM_DATCMD; |
| |
| /* Check if AUTO CMD19/CMD21 is required or not? */ |
| if (host->tuning_needed && |
| (host->en_auto_cmd19 || host->en_auto_cmd21)) { |
| /* |
| * For open ended block read operation (without CMD23), |
| * AUTO_CMD19/AUTO_CMD21 bit should be set while sending |
| * the READ command. |
| * For close ended block read operation (with CMD23), |
| * AUTO_CMD19/AUTO_CMD21 bit should be set while sending |
| * CMD23. |
| */ |
| if ((cmd->opcode == MMC_SET_BLOCK_COUNT && |
| host->curr.mrq->cmd->opcode == |
| MMC_READ_MULTIPLE_BLOCK) || |
| (!host->curr.mrq->sbc && |
| (cmd->opcode == MMC_READ_SINGLE_BLOCK || |
| cmd->opcode == MMC_READ_MULTIPLE_BLOCK))) { |
| msmsdcc_enable_cdr_cm_sdc4_dll(host); |
| if (host->en_auto_cmd19 && |
| host->mmc->ios.timing == MMC_TIMING_UHS_SDR104) |
| *c |= MCI_CSPM_AUTO_CMD19; |
| else if (host->en_auto_cmd21 && |
| host->mmc->ios.timing == MMC_TIMING_MMC_HS200) |
| *c |= MCI_CSPM_AUTO_CMD21; |
| } |
| } |
| |
| if (cmd->mrq->data && (cmd->mrq->data->flags & MMC_DATA_READ)) |
| writel_relaxed((readl_relaxed(host->base + |
| MCI_DLL_CONFIG) | MCI_CDR_EN), |
| host->base + MCI_DLL_CONFIG); |
| else |
| /* Clear CDR_EN bit for non read operations */ |
| writel_relaxed((readl_relaxed(host->base + |
| MCI_DLL_CONFIG) & ~MCI_CDR_EN), |
| host->base + MCI_DLL_CONFIG); |
| |
| if (((cmd->flags & MMC_RSP_R1B) == MMC_RSP_R1B) || |
| (cmd->opcode == MMC_SEND_STATUS && |
| !(cmd->flags & MMC_CMD_ADTC))) { |
| *c |= MCI_CPSM_PROGENA; |
| host->prog_enable = 1; |
| } |
| |
| if (cmd == cmd->mrq->stop) |
| *c |= MCI_CSPM_MCIABORT; |
| |
| if (host->curr.cmd != NULL) { |
| pr_err("%s: Overlapping command requests\n", |
| mmc_hostname(host->mmc)); |
| } |
| host->curr.cmd = cmd; |
| } |
| |
| static void |
| msmsdcc_start_data(struct msmsdcc_host *host, struct mmc_data *data, |
| struct mmc_command *cmd, u32 c) |
| { |
| unsigned int datactrl = 0, timeout; |
| unsigned long long clks; |
| void __iomem *base = host->base; |
| unsigned int pio_irqmask = 0; |
| |
| BUG_ON(!data->sg); |
| BUG_ON(!data->sg_len); |
| |
| host->curr.data = data; |
| host->curr.xfer_size = data->blksz * data->blocks; |
| host->curr.xfer_remain = host->curr.xfer_size; |
| host->curr.data_xfered = 0; |
| host->curr.got_dataend = 0; |
| host->curr.got_auto_prog_done = false; |
| |
| datactrl = MCI_DPSM_ENABLE | (data->blksz << 4); |
| |
| if (host->curr.wait_for_auto_prog_done) |
| datactrl |= MCI_AUTO_PROG_DONE; |
| |
| if (msmsdcc_is_dma_possible(host, data)) { |
| if (is_dma_mode(host) && !msmsdcc_config_dma(host, data)) { |
| datactrl |= MCI_DPSM_DMAENABLE; |
| } else if (is_sps_mode(host)) { |
| if (!msmsdcc_sps_start_xfer(host, data)) { |
| /* Now kick start DML transfer */ |
| mb(); |
| msmsdcc_dml_start_xfer(host, data); |
| datactrl |= MCI_DPSM_DMAENABLE; |
| host->sps.busy = 1; |
| } |
| } |
| } |
| |
| /* Is data transfer in PIO mode required? */ |
| if (!(datactrl & MCI_DPSM_DMAENABLE)) { |
| if (data->flags & MMC_DATA_READ) { |
| pio_irqmask = MCI_RXFIFOHALFFULLMASK; |
| if (host->curr.xfer_remain < MCI_FIFOSIZE) |
| pio_irqmask |= MCI_RXDATAAVLBLMASK; |
| } else |
| pio_irqmask = MCI_TXFIFOHALFEMPTYMASK | |
| MCI_TXFIFOEMPTYMASK; |
| |
| msmsdcc_sg_start(host); |
| } |
| |
| if (data->flags & MMC_DATA_READ) |
| datactrl |= (MCI_DPSM_DIRECTION | MCI_RX_DATA_PEND); |
| else if (host->curr.use_wr_data_pend) |
| datactrl |= MCI_DATA_PEND; |
| |
| clks = (unsigned long long)data->timeout_ns * host->clk_rate; |
| do_div(clks, 1000000000UL); |
| timeout = data->timeout_clks + (unsigned int)clks*2 ; |
| WARN(!timeout, |
| "%s: data timeout is zero. timeout_ns=0x%x, timeout_clks=0x%x\n", |
| mmc_hostname(host->mmc), data->timeout_ns, data->timeout_clks); |
| |
| if (is_dma_mode(host) && (datactrl & MCI_DPSM_DMAENABLE)) { |
| /* Use ADM (Application Data Mover) HW for Data transfer */ |
| /* Save parameters for the dma exec function */ |
| host->cmd_timeout = timeout; |
| host->cmd_pio_irqmask = pio_irqmask; |
| host->cmd_datactrl = datactrl; |
| host->cmd_cmd = cmd; |
| |
| host->dma.hdr.exec_func = msmsdcc_dma_exec_func; |
| host->dma.hdr.user = (void *)host; |
| host->dma.busy = 1; |
| |
| if (cmd) { |
| msmsdcc_start_command_deferred(host, cmd, &c); |
| host->cmd_c = c; |
| } |
| writel_relaxed((readl_relaxed(host->base + MMCIMASK0) & |
| (~(MCI_IRQ_PIO))) | host->cmd_pio_irqmask, |
| host->base + MMCIMASK0); |
| mb(); |
| msm_dmov_enqueue_cmd_ext(host->dma.channel, &host->dma.hdr); |
| } else { |
| /* SPS-BAM mode or PIO mode */ |
| writel_relaxed(timeout, base + MMCIDATATIMER); |
| |
| writel_relaxed(host->curr.xfer_size, base + MMCIDATALENGTH); |
| |
| writel_relaxed((readl_relaxed(host->base + MMCIMASK0) & |
| (~(MCI_IRQ_PIO))) | pio_irqmask, |
| host->base + MMCIMASK0); |
| writel_relaxed(datactrl, base + MMCIDATACTRL); |
| |
| if (cmd) { |
| /* Delay between data/command */ |
| msmsdcc_sync_reg_wr(host); |
| /* Daisy-chain the command if requested */ |
| msmsdcc_start_command(host, cmd, c); |
| } else { |
| /* |
| * We don't need delay after writing to DATA_CTRL |
| * register if we are not writing to CMD register |
| * immediately after this. As we already have delay |
| * before sending the command, we just need mb() here. |
| */ |
| mb(); |
| } |
| } |
| } |
| |
| static void |
| msmsdcc_start_command(struct msmsdcc_host *host, struct mmc_command *cmd, u32 c) |
| { |
| msmsdcc_start_command_deferred(host, cmd, &c); |
| msmsdcc_start_command_exec(host, cmd->arg, c); |
| } |
| |
| static void |
| msmsdcc_data_err(struct msmsdcc_host *host, struct mmc_data *data, |
| unsigned int status) |
| { |
| if ((status & MCI_DATACRCFAIL) || (status & MCI_DATATIMEOUT)) { |
| u32 opcode = data->mrq->cmd->opcode; |
| |
| if (!((!host->tuning_in_progress && opcode == MMC_BUS_TEST_W) |
| || (opcode == MMC_BUS_TEST_R) || |
| (host->tuning_in_progress && |
| (opcode == MMC_SEND_TUNING_BLOCK_HS200 || |
| opcode == MMC_SEND_TUNING_BLOCK)))) { |
| if (status & MCI_DATACRCFAIL) { |
| pr_err("%s: Data CRC error\n", |
| mmc_hostname(host->mmc)); |
| pr_err("%s: opcode 0x%.8x\n", __func__, opcode); |
| pr_err("%s: blksz %d, blocks %d\n", __func__, |
| data->blksz, data->blocks); |
| } else { |
| pr_err("%s: CMD%d: Data timeout. DAT0 => %d\n", |
| mmc_hostname(host->mmc), opcode, |
| (readl_relaxed(host->base |
| + MCI_TEST_INPUT) & 0x2) ? 1 : 0); |
| msmsdcc_dump_sdcc_state(host); |
| } |
| } |
| |
| /* |
| * CRC is optional for the bus test commands, not all |
| * cards respond back with CRC. However controller |
| * waits for the CRC and times out. Hence ignore the |
| * data timeouts during the Bustest. |
| */ |
| if (!((!host->tuning_in_progress && opcode == MMC_BUS_TEST_W) |
| || (opcode == MMC_BUS_TEST_R))) { |
| if (status & MCI_DATACRCFAIL) |
| data->error = -EILSEQ; |
| else |
| data->error = -ETIMEDOUT; |
| } |
| } else if (status & MCI_RXOVERRUN) { |
| pr_err("%s: RX overrun\n", mmc_hostname(host->mmc)); |
| data->error = -EIO; |
| } else if (status & MCI_TXUNDERRUN) { |
| pr_err("%s: TX underrun\n", mmc_hostname(host->mmc)); |
| data->error = -EIO; |
| } else { |
| pr_err("%s: Unknown error (0x%.8x)\n", |
| mmc_hostname(host->mmc), status); |
| data->error = -EIO; |
| } |
| |
| /* Dummy CMD52 is not needed when CMD53 has errors */ |
| if (host->dummy_52_needed) |
| host->dummy_52_needed = 0; |
| } |
| |
| static int |
| msmsdcc_pio_read(struct msmsdcc_host *host, char *buffer, unsigned int remain) |
| { |
| void __iomem *base = host->base; |
| uint32_t *ptr = (uint32_t *) buffer; |
| int count = 0; |
| |
| if (remain % 4) |
| remain = ((remain >> 2) + 1) << 2; |
| |
| while (readl_relaxed(base + MMCISTATUS) & MCI_RXDATAAVLBL) { |
| |
| *ptr = readl_relaxed(base + MMCIFIFO + (count % MCI_FIFOSIZE)); |
| ptr++; |
| count += sizeof(uint32_t); |
| |
| remain -= sizeof(uint32_t); |
| if (remain == 0) |
| break; |
| } |
| return count; |
| } |
| |
| static int |
| msmsdcc_pio_write(struct msmsdcc_host *host, char *buffer, |
| unsigned int remain) |
| { |
| void __iomem *base = host->base; |
| char *ptr = buffer; |
| unsigned int maxcnt = MCI_FIFOHALFSIZE; |
| |
| while (readl_relaxed(base + MMCISTATUS) & |
| (MCI_TXFIFOEMPTY | MCI_TXFIFOHALFEMPTY)) { |
| unsigned int count, sz; |
| |
| count = min(remain, maxcnt); |
| |
| sz = count % 4 ? (count >> 2) + 1 : (count >> 2); |
| writesl(base + MMCIFIFO, ptr, sz); |
| ptr += count; |
| remain -= count; |
| |
| if (remain == 0) |
| break; |
| } |
| mb(); |
| |
| return ptr - buffer; |
| } |
| |
| /* |
| * Copy up to a word (4 bytes) between a scatterlist |
| * and a temporary bounce buffer when the word lies across |
| * two pages. The temporary buffer can then be read to/ |
| * written from the FIFO once. |
| */ |
| static void _msmsdcc_sg_consume_word(struct msmsdcc_host *host) |
| { |
| struct msmsdcc_pio_data *pio = &host->pio; |
| unsigned int bytes_avail; |
| |
| if (host->curr.data->flags & MMC_DATA_READ) |
| memcpy(pio->sg_miter.addr, pio->bounce_buf, |
| pio->bounce_buf_len); |
| else |
| memcpy(pio->bounce_buf, pio->sg_miter.addr, |
| pio->bounce_buf_len); |
| |
| while (pio->bounce_buf_len != 4) { |
| if (!sg_miter_next(&pio->sg_miter)) |
| break; |
| bytes_avail = min_t(unsigned int, pio->sg_miter.length, |
| 4 - pio->bounce_buf_len); |
| if (host->curr.data->flags & MMC_DATA_READ) |
| memcpy(pio->sg_miter.addr, |
| &pio->bounce_buf[pio->bounce_buf_len], |
| bytes_avail); |
| else |
| memcpy(&pio->bounce_buf[pio->bounce_buf_len], |
| pio->sg_miter.addr, bytes_avail); |
| |
| pio->sg_miter.consumed = bytes_avail; |
| pio->bounce_buf_len += bytes_avail; |
| } |
| } |
| |
| /* |
| * Use sg_miter_next to return as many 4-byte aligned |
| * chunks as possible, using a temporary 4 byte buffer |
| * for alignment if necessary |
| */ |
| static int msmsdcc_sg_next(struct msmsdcc_host *host, char **buf, int *len) |
| { |
| struct msmsdcc_pio_data *pio = &host->pio; |
| unsigned int length, rlength; |
| char *buffer; |
| |
| if (!sg_miter_next(&pio->sg_miter)) |
| return 0; |
| |
| buffer = pio->sg_miter.addr; |
| length = pio->sg_miter.length; |
| |
| if (length < host->curr.xfer_remain) { |
| rlength = round_down(length, 4); |
| if (rlength) { |
| /* |
| * We have a 4-byte aligned chunk. |
| * The rounding will be reflected by |
| * a call to msmsdcc_sg_consumed |
| */ |
| length = rlength; |
| goto sg_next_end; |
| } |
| /* |
| * We have a length less than 4 bytes. Check to |
| * see if more buffer is available, and combine |
| * to make 4 bytes if possible. |
| */ |
| pio->bounce_buf_len = length; |
| memset(pio->bounce_buf, 0, 4); |
| |
| /* |
| * On a read, get 4 bytes from FIFO, and distribute |
| * (4-bouce_buf_len) bytes into consecutive |
| * sgl buffers when msmsdcc_sg_consumed is called |
| */ |
| if (host->curr.data->flags & MMC_DATA_READ) { |
| buffer = pio->bounce_buf; |
| length = 4; |
| goto sg_next_end; |
| } else { |
| _msmsdcc_sg_consume_word(host); |
| buffer = pio->bounce_buf; |
| length = pio->bounce_buf_len; |
| } |
| } |
| |
| sg_next_end: |
| *buf = buffer; |
| *len = length; |
| return 1; |
| } |
| |
| /* |
| * Update sg_miter.consumed based on how many bytes were |
| * consumed. If the bounce buffer was used to read from FIFO, |
| * redistribute into sgls. |
| */ |
| static void msmsdcc_sg_consumed(struct msmsdcc_host *host, |
| unsigned int length) |
| { |
| struct msmsdcc_pio_data *pio = &host->pio; |
| |
| if (host->curr.data->flags & MMC_DATA_READ) { |
| if (length > pio->sg_miter.consumed) |
| /* |
| * consumed 4 bytes, but sgl |
| * describes < 4 bytes |
| */ |
| _msmsdcc_sg_consume_word(host); |
| else |
| pio->sg_miter.consumed = length; |
| } else |
| if (length < pio->sg_miter.consumed) |
| pio->sg_miter.consumed = length; |
| } |
| |
| static void msmsdcc_sg_start(struct msmsdcc_host *host) |
| { |
| unsigned int sg_miter_flags = SG_MITER_ATOMIC; |
| |
| host->pio.bounce_buf_len = 0; |
| |
| if (host->curr.data->flags & MMC_DATA_READ) |
| sg_miter_flags |= SG_MITER_TO_SG; |
| else |
| sg_miter_flags |= SG_MITER_FROM_SG; |
| |
| sg_miter_start(&host->pio.sg_miter, host->curr.data->sg, |
| host->curr.data->sg_len, sg_miter_flags); |
| } |
| |
| static void msmsdcc_sg_stop(struct msmsdcc_host *host) |
| { |
| sg_miter_stop(&host->pio.sg_miter); |
| } |
| |
| static irqreturn_t |
| msmsdcc_pio_irq(int irq, void *dev_id) |
| { |
| struct msmsdcc_host *host = dev_id; |
| void __iomem *base = host->base; |
| uint32_t status; |
| unsigned long flags; |
| unsigned int remain; |
| char *buffer; |
| |
| spin_lock(&host->lock); |
| |
| status = readl_relaxed(base + MMCISTATUS); |
| |
| if (((readl_relaxed(host->base + MMCIMASK0) & status) & |
| (MCI_IRQ_PIO)) == 0) { |
| spin_unlock(&host->lock); |
| return IRQ_NONE; |
| } |
| #if IRQ_DEBUG |
| msmsdcc_print_status(host, "irq1-r", status); |
| #endif |
| local_irq_save(flags); |
| |
| do { |
| unsigned int len; |
| |
| if (!(status & (MCI_TXFIFOHALFEMPTY | MCI_TXFIFOEMPTY |
| | MCI_RXDATAAVLBL))) |
| break; |
| |
| if (!msmsdcc_sg_next(host, &buffer, &remain)) |
| break; |
| |
| len = 0; |
| if (status & MCI_RXACTIVE) |
| len = msmsdcc_pio_read(host, buffer, remain); |
| if (status & MCI_TXACTIVE) |
| len = msmsdcc_pio_write(host, buffer, remain); |
| |
| /* len might have aligned to 32bits above */ |
| if (len > remain) |
| len = remain; |
| |
| host->curr.xfer_remain -= len; |
| host->curr.data_xfered += len; |
| remain -= len; |
| msmsdcc_sg_consumed(host, len); |
| |
| if (remain) /* Done with this page? */ |
| break; /* Nope */ |
| |
| status = readl_relaxed(base + MMCISTATUS); |
| } while (1); |
| |
| msmsdcc_sg_stop(host); |
| local_irq_restore(flags); |
| |
| if (status & MCI_RXACTIVE && host->curr.xfer_remain < MCI_FIFOSIZE) { |
| writel_relaxed((readl_relaxed(host->base + MMCIMASK0) & |
| (~(MCI_IRQ_PIO))) | MCI_RXDATAAVLBLMASK, |
| host->base + MMCIMASK0); |
| if (!host->curr.xfer_remain) { |
| /* |
| * back to back write to MASK0 register don't need |
| * synchronization delay. |
| */ |
| writel_relaxed((readl_relaxed(host->base + MMCIMASK0) & |
| (~(MCI_IRQ_PIO))) | 0, host->base + MMCIMASK0); |
| } |
| mb(); |
| } else if (!host->curr.xfer_remain) { |
| writel_relaxed((readl_relaxed(host->base + MMCIMASK0) & |
| (~(MCI_IRQ_PIO))) | 0, host->base + MMCIMASK0); |
| mb(); |
| } |
| |
| spin_unlock(&host->lock); |
| |
| return IRQ_HANDLED; |
| } |
| |
| static void |
| msmsdcc_request_start(struct msmsdcc_host *host, struct mmc_request *mrq); |
| |
| static void msmsdcc_wait_for_rxdata(struct msmsdcc_host *host, |
| struct mmc_data *data) |
| { |
| u32 loop_cnt = 0; |
| |
| /* |
| * For read commands with data less than fifo size, it is possible to |
| * get DATAEND first and RXDATA_AVAIL might be set later because of |
| * synchronization delay through the asynchronous RX FIFO. Thus, for |
| * such cases, even after DATAEND interrupt is received software |
| * should poll for RXDATA_AVAIL until the requested data is read out |
| * of FIFO. This change is needed to get around this abnormal but |
| * sometimes expected behavior of SDCC3 controller. |
| * |
| * We can expect RXDATAAVAIL bit to be set after 6HCLK clock cycles |
| * after the data is loaded into RX FIFO. This would amount to less |
| * than a microsecond and thus looping for 1000 times is good enough |
| * for that delay. |
| */ |
| while (((int)host->curr.xfer_remain > 0) && (++loop_cnt < 1000)) { |
| if (readl_relaxed(host->base + MMCISTATUS) & MCI_RXDATAAVLBL) { |
| spin_unlock(&host->lock); |
| msmsdcc_pio_irq(1, host); |
| spin_lock(&host->lock); |
| } |
| } |
| if (loop_cnt == 1000) { |
| pr_info("%s: Timed out while polling for Rx Data\n", |
| mmc_hostname(host->mmc)); |
| data->error = -ETIMEDOUT; |
| msmsdcc_reset_and_restore(host); |
| } |
| } |
| |
| static void msmsdcc_do_cmdirq(struct msmsdcc_host *host, uint32_t status) |
| { |
| struct mmc_command *cmd = host->curr.cmd; |
| |
| host->curr.cmd = NULL; |
| if (mmc_resp_type(cmd)) |
| cmd->resp[0] = readl_relaxed(host->base + MMCIRESPONSE0); |
| /* |
| * Read rest of the response registers only if |
| * long response is expected for this command |
| */ |
| if (mmc_resp_type(cmd) & MMC_RSP_136) { |
| cmd->resp[1] = readl_relaxed(host->base + MMCIRESPONSE1); |
| cmd->resp[2] = readl_relaxed(host->base + MMCIRESPONSE2); |
| cmd->resp[3] = readl_relaxed(host->base + MMCIRESPONSE3); |
| } |
| |
| if (status & (MCI_CMDTIMEOUT | MCI_AUTOCMD19TIMEOUT)) { |
| pr_debug("%s: CMD%d: Command timeout\n", |
| mmc_hostname(host->mmc), cmd->opcode); |
| cmd->error = -ETIMEDOUT; |
| } else if ((status & MCI_CMDCRCFAIL && cmd->flags & MMC_RSP_CRC) && |
| !host->tuning_in_progress) { |
| pr_err("%s: CMD%d: Command CRC error\n", |
| mmc_hostname(host->mmc), cmd->opcode); |
| msmsdcc_dump_sdcc_state(host); |
| cmd->error = -EILSEQ; |
| } |
| |
| if (!cmd->error) { |
| if (cmd->cmd_timeout_ms > host->curr.req_tout_ms) { |
| host->curr.req_tout_ms = cmd->cmd_timeout_ms; |
| mod_timer(&host->req_tout_timer, (jiffies + |
| msecs_to_jiffies(host->curr.req_tout_ms))); |
| } |
| } |
| |
| if (!cmd->data || cmd->error) { |
| if (host->curr.data && host->dma.sg && |
| is_dma_mode(host)) |
| msm_dmov_flush(host->dma.channel, 0); |
| else if (host->curr.data && host->sps.sg && |
| is_sps_mode(host)) { |
| /* Stop current SPS transfer */ |
| msmsdcc_sps_exit_curr_xfer(host); |
| } |
| else if (host->curr.data) { /* Non DMA */ |
| msmsdcc_reset_and_restore(host); |
| msmsdcc_stop_data(host); |
| msmsdcc_request_end(host, cmd->mrq); |
| } else { /* host->data == NULL */ |
| if (!cmd->error && host->prog_enable) { |
| if (status & MCI_PROGDONE) { |
| host->prog_enable = 0; |
| msmsdcc_request_end(host, cmd->mrq); |
| } else |
| host->curr.cmd = cmd; |
| } else { |
| host->prog_enable = 0; |
| host->curr.wait_for_auto_prog_done = false; |
| if (host->dummy_52_needed) |
| host->dummy_52_needed = 0; |
| if (cmd->data && cmd->error) |
| msmsdcc_reset_and_restore(host); |
| msmsdcc_request_end(host, cmd->mrq); |
| } |
| } |
| } else if (cmd->data) { |
| if (cmd == host->curr.mrq->sbc) |
| msmsdcc_start_command(host, host->curr.mrq->cmd, 0); |
| else if ((cmd->data->flags & MMC_DATA_WRITE) && |
| !host->curr.use_wr_data_pend) |
| msmsdcc_start_data(host, cmd->data, NULL, 0); |
| } |
| } |
| |
| static irqreturn_t |
| msmsdcc_irq(int irq, void *dev_id) |
| { |
| struct msmsdcc_host *host = dev_id; |
| struct mmc_host *mmc = host->mmc; |
| u32 status; |
| int ret = 0; |
| int timer = 0; |
| |
| spin_lock(&host->lock); |
| |
| do { |
| struct mmc_command *cmd; |
| struct mmc_data *data; |
| |
| if (timer) { |
| timer = 0; |
| msmsdcc_delay(host); |
| } |
| |
| if (!atomic_read(&host->clks_on)) { |
| pr_debug("%s: %s: SDIO async irq received\n", |
| mmc_hostname(host->mmc), __func__); |
| |
| /* |
| * Only async interrupt can come when clocks are off, |
| * disable further interrupts and enable them when |
| * clocks are on. |
| */ |
| if (!host->sdcc_irq_disabled) { |
| disable_irq_nosync(irq); |
| host->sdcc_irq_disabled = 1; |
| } |
| |
| /* |
| * If mmc_card_wake_sdio_irq() is set, mmc core layer |
| * will take care of signaling sdio irq during |
| * mmc_sdio_resume(). |
| */ |
| if (host->sdcc_suspended) { |
| /* |
| * This is a wakeup interrupt so hold wakelock |
| * until SDCC resume is handled. |
| */ |
| wake_lock(&host->sdio_wlock); |
| } else { |
| if (!mmc->card || !mmc_card_sdio(mmc->card)) { |
| WARN(1, "%s: SDCC core interrupt received for non-SDIO cards when SDCC clocks are off\n", |
| mmc_hostname(mmc)); |
| ret = 1; |
| break; |
| } |
| spin_unlock(&host->lock); |
| mmc_signal_sdio_irq(host->mmc); |
| spin_lock(&host->lock); |
| } |
| ret = 1; |
| break; |
| } |
| |
| status = readl_relaxed(host->base + MMCISTATUS); |
| |
| if (((readl_relaxed(host->base + MMCIMASK0) & status) & |
| (~(MCI_IRQ_PIO))) == 0) |
| break; |
| |
| #if IRQ_DEBUG |
| msmsdcc_print_status(host, "irq0-r", status); |
| #endif |
| status &= readl_relaxed(host->base + MMCIMASK0); |
| writel_relaxed(status, host->base + MMCICLEAR); |
| /* Allow clear to take effect*/ |
| if (host->clk_rate <= |
| msmsdcc_get_min_sup_clk_rate(host)) |
| msmsdcc_sync_reg_wr(host); |
| #if IRQ_DEBUG |
| msmsdcc_print_status(host, "irq0-p", status); |
| #endif |
| |
| if (status & MCI_SDIOINTROPE) { |
| if (!mmc->card || mmc_card_sdio(mmc->card)) { |
| WARN(1, "%s: SDIO interrupt received for non-SDIO card\n", |
| mmc_hostname(mmc)); |
| ret = 1; |
| break; |
| } |
| if (host->sdcc_suspending) |
| wake_lock(&host->sdio_suspend_wlock); |
| spin_unlock(&host->lock); |
| mmc_signal_sdio_irq(host->mmc); |
| spin_lock(&host->lock); |
| } |
| data = host->curr.data; |
| |
| if (host->dummy_52_sent) { |
| if (status & (MCI_PROGDONE | MCI_CMDCRCFAIL | |
| MCI_CMDTIMEOUT)) { |
| if (status & MCI_CMDTIMEOUT) |
| pr_debug("%s: dummy CMD52 timeout\n", |
| mmc_hostname(host->mmc)); |
| if (status & MCI_CMDCRCFAIL) |
| pr_debug("%s: dummy CMD52 CRC failed\n", |
| mmc_hostname(host->mmc)); |
| host->dummy_52_sent = 0; |
| host->dummy_52_needed = 0; |
| if (data) { |
| msmsdcc_stop_data(host); |
| msmsdcc_request_end(host, data->mrq); |
| } |
| WARN(!data, "No data cmd for dummy CMD52\n"); |
| spin_unlock(&host->lock); |
| return IRQ_HANDLED; |
| } |
| break; |
| } |
| |
| /* |
| * Check for proper command response |
| */ |
| cmd = host->curr.cmd; |
| if ((status & (MCI_CMDSENT | MCI_CMDRESPEND | MCI_CMDCRCFAIL | |
| MCI_CMDTIMEOUT | MCI_PROGDONE | |
| MCI_AUTOCMD19TIMEOUT)) && host->curr.cmd) { |
| msmsdcc_do_cmdirq(host, status); |
| } |
| |
| if (host->curr.data) { |
| /* Check for data errors */ |
| if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT| |
| MCI_TXUNDERRUN|MCI_RXOVERRUN)) { |
| msmsdcc_data_err(host, data, status); |
| host->curr.data_xfered = 0; |
| if (host->dma.sg && is_dma_mode(host)) |
| msm_dmov_flush(host->dma.channel, 0); |
| else if (host->sps.sg && is_sps_mode(host)) { |
| /* Stop current SPS transfer */ |
| msmsdcc_sps_exit_curr_xfer(host); |
| } else { |
| msmsdcc_reset_and_restore(host); |
| if (host->curr.data) |
| msmsdcc_stop_data(host); |
| if (!data->stop || (host->curr.mrq->sbc |
| && !data->error)) |
| timer |= |
| msmsdcc_request_end(host, |
| data->mrq); |
| else if ((host->curr.mrq->sbc |
| && data->error) || |
| !host->curr.mrq->sbc) { |
| msmsdcc_start_command(host, |
| data->stop, |
| 0); |
| timer = 1; |
| } |
| } |
| } |
| |
| /* Check for prog done */ |
| if (host->curr.wait_for_auto_prog_done && |
| (status & MCI_PROGDONE)) |
| host->curr.got_auto_prog_done = true; |
| |
| /* Check for data done */ |
| if (!host->curr.got_dataend && (status & MCI_DATAEND)) |
| host->curr.got_dataend = 1; |
| |
| if (host->curr.got_dataend && |
| (!host->curr.wait_for_auto_prog_done || |
| (host->curr.wait_for_auto_prog_done && |
| host->curr.got_auto_prog_done))) { |
| /* |
| * If DMA is still in progress, we complete |
| * via the completion handler |
| */ |
| if (!host->dma.busy && !host->sps.busy) { |
| /* |
| * There appears to be an issue in the |
| * controller where if you request a |
| * small block transfer (< fifo size), |
| * you may get your DATAEND/DATABLKEND |
| * irq without the PIO data irq. |
| * |
| * Check to see if theres still data |
| * to be read, and simulate a PIO irq. |
| */ |
| if (data->flags & MMC_DATA_READ) |
| msmsdcc_wait_for_rxdata(host, |
| data); |
| if (!data->error) { |
| host->curr.data_xfered = |
| host->curr.xfer_size; |
| host->curr.xfer_remain -= |
| host->curr.xfer_size; |
| } |
| |
| if (!host->dummy_52_needed) { |
| msmsdcc_stop_data(host); |
| if (!data->stop || |
| (host->curr.mrq->sbc |
| && !data->error)) |
| msmsdcc_request_end( |
| host, |
| data->mrq); |
| else if ((host->curr.mrq->sbc |
| && data->error) || |
| !host->curr.mrq->sbc) { |
| msmsdcc_start_command( |
| host, |
| data->stop, 0); |
| timer = 1; |
| } |
| } else { |
| host->dummy_52_sent = 1; |
| msmsdcc_start_command(host, |
| &dummy52cmd, |
| MCI_CPSM_PROGENA); |
| } |
| } |
| } |
| } |
| |
| ret = 1; |
| } while (status); |
| |
| spin_unlock(&host->lock); |
| |
| return IRQ_RETVAL(ret); |
| } |
| |
| static void |
| msmsdcc_pre_req(struct mmc_host *mmc, struct mmc_request *mrq, |
| bool is_first_request) |
| { |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| struct mmc_data *data = mrq->data; |
| int rc = 0; |
| |
| if (unlikely(!data)) { |
| pr_err("%s: %s cannot prepare null data\n", mmc_hostname(mmc), |
| __func__); |
| return; |
| } |
| if (unlikely(data->host_cookie)) { |
| /* Very wrong */ |
| data->host_cookie = 0; |
| pr_err("%s: %s Request reposted for prepare\n", |
| mmc_hostname(mmc), __func__); |
| return; |
| } |
| |
| if (!msmsdcc_is_dma_possible(host, data)) |
| return; |
| |
| rc = msmsdcc_prep_xfer(host, data); |
| if (unlikely(rc < 0)) { |
| data->host_cookie = 0; |
| return; |
| } |
| |
| data->host_cookie = 1; |
| } |
| |
| static void |
| msmsdcc_post_req(struct mmc_host *mmc, struct mmc_request *mrq, int err) |
| { |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| unsigned int dir; |
| struct mmc_data *data = mrq->data; |
| |
| if (unlikely(!data)) { |
| pr_err("%s: %s cannot cleanup null data\n", mmc_hostname(mmc), |
| __func__); |
| return; |
| } |
| if (data->flags & MMC_DATA_READ) |
| dir = DMA_FROM_DEVICE; |
| else |
| dir = DMA_TO_DEVICE; |
| |
| if (data->host_cookie) |
| dma_unmap_sg(mmc_dev(host->mmc), data->sg, |
| data->sg_len, dir); |
| |
| data->host_cookie = 0; |
| } |
| |
| static void |
| msmsdcc_request_start(struct msmsdcc_host *host, struct mmc_request *mrq) |
| { |
| if (mrq->data) { |
| /* Queue/read data, daisy-chain command when data starts */ |
| if ((mrq->data->flags & MMC_DATA_READ) || |
| host->curr.use_wr_data_pend) |
| msmsdcc_start_data(host, mrq->data, |
| mrq->sbc ? mrq->sbc : mrq->cmd, |
| 0); |
| else |
| msmsdcc_start_command(host, |
| mrq->sbc ? mrq->sbc : mrq->cmd, |
| 0); |
| } else { |
| msmsdcc_start_command(host, mrq->cmd, 0); |
| } |
| } |
| |
| static void |
| msmsdcc_request(struct mmc_host *mmc, struct mmc_request *mrq) |
| { |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| unsigned long flags; |
| |
| /* |
| * Get the SDIO AL client out of LPM. |
| */ |
| WARN(host->dummy_52_sent, "Dummy CMD52 in progress\n"); |
| if (host->plat->is_sdio_al_client) |
| msmsdcc_sdio_al_lpm(mmc, false); |
| |
| /* check if sps pipe reset is pending? */ |
| if (is_sps_mode(host) && host->sps.pipe_reset_pending) { |
| msmsdcc_sps_pipes_reset_and_restore(host); |
| host->sps.pipe_reset_pending = false; |
| } |
| |
| spin_lock_irqsave(&host->lock, flags); |
| |
| if (host->eject) { |
| if (mrq->data && !(mrq->data->flags & MMC_DATA_READ)) { |
| mrq->cmd->error = 0; |
| mrq->data->bytes_xfered = mrq->data->blksz * |
| mrq->data->blocks; |
| } else |
| mrq->cmd->error = -ENOMEDIUM; |
| |
| spin_unlock_irqrestore(&host->lock, flags); |
| mmc_request_done(mmc, mrq); |
| return; |
| } |
| |
| /* |
| * Don't start the request if SDCC is not in proper state to handle it |
| */ |
| if (!host->pwr || !atomic_read(&host->clks_on) |
| || host->sdcc_irq_disabled) { |
| WARN(1, "%s: %s: SDCC is in bad state. don't process" |
| " new request (CMD%d)\n", mmc_hostname(host->mmc), |
| __func__, mrq->cmd->opcode); |
| msmsdcc_dump_sdcc_state(host); |
| mrq->cmd->error = -EIO; |
| if (mrq->data) { |
| mrq->data->error = -EIO; |
| mrq->data->bytes_xfered = 0; |
| } |
| spin_unlock_irqrestore(&host->lock, flags); |
| mmc_request_done(mmc, mrq); |
| return; |
| } |
| |
| WARN(host->curr.mrq, "%s: %s: New request (CMD%d) received while" |
| " other request (CMD%d) is in progress\n", |
| mmc_hostname(host->mmc), __func__, |
| mrq->cmd->opcode, host->curr.mrq->cmd->opcode); |
| |
| /* |
| * Set timeout value to 10 secs (or more in case of buggy cards) |
| */ |
| if ((mmc->card) && (mmc->card->quirks & MMC_QUIRK_INAND_DATA_TIMEOUT)) |
| host->curr.req_tout_ms = 20000; |
| else |
| host->curr.req_tout_ms = MSM_MMC_REQ_TIMEOUT; |
| /* |
| * Kick the software request timeout timer here with the timeout |
| * value identified above |
| */ |
| mod_timer(&host->req_tout_timer, |
| (jiffies + |
| msecs_to_jiffies(host->curr.req_tout_ms))); |
| |
| host->curr.mrq = mrq; |
| if (mrq->sbc) { |
| mrq->sbc->mrq = mrq; |
| mrq->sbc->data = mrq->data; |
| } |
| |
| if (mrq->data && (mrq->data->flags & MMC_DATA_WRITE)) { |
| if (is_auto_prog_done(host)) { |
| /* |
| * Auto-prog done will be enabled for following cases: |
| * mrq->sbc | mrq->stop |
| * _____________|________________ |
| * True | Don't care |
| * False | False (CMD24, ACMD25 use case) |
| */ |
| if (mrq->sbc || !mrq->stop) |
| host->curr.wait_for_auto_prog_done = true; |
| } else { |
| if ((mrq->cmd->opcode == SD_IO_RW_EXTENDED) || |
| (mrq->cmd->opcode == 54)) |
| host->dummy_52_needed = 1; |
| } |
| |
| if ((mrq->cmd->opcode == MMC_WRITE_BLOCK) || |
| (mrq->cmd->opcode == MMC_WRITE_MULTIPLE_BLOCK)) |
| host->curr.use_wr_data_pend = true; |
| } |
| |
| msmsdcc_request_start(host, mrq); |
| |
| spin_unlock_irqrestore(&host->lock, flags); |
| } |
| |
| static inline int msmsdcc_vreg_set_voltage(struct msm_mmc_reg_data *vreg, |
| int min_uV, int max_uV) |
| { |
| int rc = 0; |
| |
| if (vreg->set_voltage_sup) { |
| rc = regulator_set_voltage(vreg->reg, min_uV, max_uV); |
| if (rc) { |
| pr_err("%s: regulator_set_voltage(%s) failed." |
| " min_uV=%d, max_uV=%d, rc=%d\n", |
| __func__, vreg->name, min_uV, max_uV, rc); |
| } |
| } |
| |
| return rc; |
| } |
| |
| static inline int msmsdcc_vreg_get_voltage(struct msm_mmc_reg_data *vreg) |
| { |
| int rc = 0; |
| |
| rc = regulator_get_voltage(vreg->reg); |
| if (rc < 0) |
| pr_err("%s: regulator_get_voltage(%s) failed. rc=%d\n", |
| __func__, vreg->name, rc); |
| |
| return rc; |
| } |
| |
| static inline int msmsdcc_vreg_set_optimum_mode(struct msm_mmc_reg_data *vreg, |
| int uA_load) |
| { |
| int rc = 0; |
| |
| /* regulators that do not support regulator_set_voltage also |
| do not support regulator_set_optimum_mode */ |
| if (vreg->set_voltage_sup) { |
| rc = regulator_set_optimum_mode(vreg->reg, uA_load); |
| if (rc < 0) |
| pr_err("%s: regulator_set_optimum_mode(reg=%s, " |
| "uA_load=%d) failed. rc=%d\n", __func__, |
| vreg->name, uA_load, rc); |
| else |
| /* regulator_set_optimum_mode() can return non zero |
| * value even for success case. |
| */ |
| rc = 0; |
| } |
| |
| return rc; |
| } |
| |
| static inline int msmsdcc_vreg_init_reg(struct msm_mmc_reg_data *vreg, |
| struct device *dev) |
| { |
| int rc = 0; |
| |
| /* check if regulator is already initialized? */ |
| if (vreg->reg) |
| goto out; |
| |
| /* Get the regulator handle */ |
| vreg->reg = regulator_get(dev, vreg->name); |
| if (IS_ERR(vreg->reg)) { |
| rc = PTR_ERR(vreg->reg); |
| pr_err("%s: regulator_get(%s) failed. rc=%d\n", |
| __func__, vreg->name, rc); |
| goto out; |
| } |
| |
| if (regulator_count_voltages(vreg->reg) > 0) { |
| vreg->set_voltage_sup = 1; |
| /* sanity check */ |
| if (!vreg->high_vol_level || !vreg->hpm_uA) { |
| pr_err("%s: %s invalid constraints specified\n", |
| __func__, vreg->name); |
| rc = -EINVAL; |
| } |
| } |
| |
| out: |
| return rc; |
| } |
| |
| static inline void msmsdcc_vreg_deinit_reg(struct msm_mmc_reg_data *vreg) |
| { |
| if (vreg->reg) |
| regulator_put(vreg->reg); |
| } |
| |
| /* This init function should be called only once for each SDCC slot */ |
| static int msmsdcc_vreg_init(struct msmsdcc_host *host, bool is_init) |
| { |
| int rc = 0; |
| struct msm_mmc_slot_reg_data *curr_slot; |
| struct msm_mmc_reg_data *curr_vdd_reg, *curr_vdd_io_reg; |
| struct device *dev = mmc_dev(host->mmc); |
| |
| curr_slot = host->plat->vreg_data; |
| if (!curr_slot) |
| goto out; |
| |
| curr_vdd_reg = curr_slot->vdd_data; |
| curr_vdd_io_reg = curr_slot->vdd_io_data; |
| |
| if (is_init) { |
| /* |
| * Get the regulator handle from voltage regulator framework |
| * and then try to set the voltage level for the regulator |
| */ |
| if (curr_vdd_reg) { |
| rc = msmsdcc_vreg_init_reg(curr_vdd_reg, dev); |
| if (rc) |
| goto out; |
| } |
| if (curr_vdd_io_reg) { |
| rc = msmsdcc_vreg_init_reg(curr_vdd_io_reg, dev); |
| if (rc) |
| goto vdd_reg_deinit; |
| } |
| rc = msmsdcc_vreg_reset(host); |
| if (rc) |
| pr_err("msmsdcc.%d vreg reset failed (%d)\n", |
| host->pdev_id, rc); |
| goto out; |
| } else { |
| /* Deregister all regulators from regulator framework */ |
| goto vdd_io_reg_deinit; |
| } |
| vdd_io_reg_deinit: |
| if (curr_vdd_io_reg) |
| msmsdcc_vreg_deinit_reg(curr_vdd_io_reg); |
| vdd_reg_deinit: |
| if (curr_vdd_reg) |
| msmsdcc_vreg_deinit_reg(curr_vdd_reg); |
| out: |
| return rc; |
| } |
| |
| static int msmsdcc_vreg_enable(struct msm_mmc_reg_data *vreg) |
| { |
| int rc = 0; |
| |
| /* Put regulator in HPM (high power mode) */ |
| rc = msmsdcc_vreg_set_optimum_mode(vreg, vreg->hpm_uA); |
| if (rc < 0) |
| goto out; |
| |
| if (!vreg->is_enabled) { |
| /* Set voltage level */ |
| rc = msmsdcc_vreg_set_voltage(vreg, vreg->high_vol_level, |
| vreg->high_vol_level); |
| if (rc) |
| goto out; |
| |
| rc = regulator_enable(vreg->reg); |
| if (rc) { |
| pr_err("%s: regulator_enable(%s) failed. rc=%d\n", |
| __func__, vreg->name, rc); |
| goto out; |
| } |
| vreg->is_enabled = true; |
| } |
| |
| out: |
| return rc; |
| } |
| |
| static int msmsdcc_vreg_disable(struct msm_mmc_reg_data *vreg, bool is_init) |
| { |
| int rc = 0; |
| |
| /* Never disable regulator marked as always_on */ |
| if (vreg->is_enabled && !vreg->always_on) { |
| rc = regulator_disable(vreg->reg); |
| if (rc) { |
| pr_err("%s: regulator_disable(%s) failed. rc=%d\n", |
| __func__, vreg->name, rc); |
| goto out; |
| } |
| vreg->is_enabled = false; |
| |
| rc = msmsdcc_vreg_set_optimum_mode(vreg, 0); |
| if (rc < 0) |
| goto out; |
| |
| /* Set min. voltage level to 0 */ |
| rc = msmsdcc_vreg_set_voltage(vreg, 0, vreg->high_vol_level); |
| if (rc) |
| goto out; |
| } else if (vreg->is_enabled && vreg->always_on) { |
| if (!is_init && vreg->lpm_sup) { |
| /* Put always_on regulator in LPM (low power mode) */ |
| rc = msmsdcc_vreg_set_optimum_mode(vreg, vreg->lpm_uA); |
| if (rc < 0) |
| goto out; |
| } else if (is_init && vreg->reset_at_init) { |
| /** |
| * The regulator might not actually be disabled if it |
| * is shared and in use by other drivers. |
| */ |
| rc = regulator_disable(vreg->reg); |
| if (rc) { |
| pr_err("%s: regulator_disable(%s) failed at " \ |
| "bootup. rc=%d\n", __func__, |
| vreg->name, rc); |
| goto out; |
| } |
| vreg->is_enabled = false; |
| } |
| } |
| out: |
| return rc; |
| } |
| |
| static int msmsdcc_setup_vreg(struct msmsdcc_host *host, bool enable, |
| bool is_init) |
| { |
| int rc = 0, i; |
| struct msm_mmc_slot_reg_data *curr_slot; |
| struct msm_mmc_reg_data *vreg_table[2]; |
| |
| curr_slot = host->plat->vreg_data; |
| if (!curr_slot) { |
| pr_debug("%s: vreg info unavailable, assuming the slot is powered by always on domain\n", |
| mmc_hostname(host->mmc)); |
| goto out; |
| } |
| |
| vreg_table[0] = curr_slot->vdd_data; |
| vreg_table[1] = curr_slot->vdd_io_data; |
| |
| for (i = 0; i < ARRAY_SIZE(vreg_table); i++) { |
| if (vreg_table[i]) { |
| if (enable) |
| rc = msmsdcc_vreg_enable(vreg_table[i]); |
| else |
| rc = msmsdcc_vreg_disable(vreg_table[i], |
| is_init); |
| if (rc) |
| goto out; |
| } |
| } |
| out: |
| return rc; |
| } |
| |
| /* |
| * Reset vreg by ensuring it is off during probe. A call |
| * to enable vreg is needed to balance disable vreg |
| */ |
| static int msmsdcc_vreg_reset(struct msmsdcc_host *host) |
| { |
| int rc; |
| |
| rc = msmsdcc_setup_vreg(host, 1, true); |
| if (rc) |
| return rc; |
| rc = msmsdcc_setup_vreg(host, 0, true); |
| return rc; |
| } |
| |
| enum vdd_io_level { |
| /* set vdd_io_data->low_vol_level */ |
| VDD_IO_LOW, |
| /* set vdd_io_data->high_vol_level */ |
| VDD_IO_HIGH, |
| /* |
| * set whatever there in voltage_level (third argument) of |
| * msmsdcc_set_vdd_io_vol() function. |
| */ |
| VDD_IO_SET_LEVEL, |
| }; |
| |
| /* |
| * This function returns the current VDD IO voltage level. |
| * Returns negative value if it fails to read the voltage level |
| * Returns 0 if regulator was disabled or if VDD_IO (and VDD) |
| * regulator were not defined for host. |
| */ |
| static int msmsdcc_get_vdd_io_vol(struct msmsdcc_host *host) |
| { |
| int rc = 0; |
| |
| if (host->plat->vreg_data) { |
| struct msm_mmc_reg_data *io_reg = |
| host->plat->vreg_data->vdd_io_data; |
| |
| /* |
| * If vdd_io is not defined, then we can consider that |
| * IO voltage is same as VDD. |
| */ |
| if (!io_reg) |
| io_reg = host->plat->vreg_data->vdd_data; |
| |
| if (io_reg && io_reg->is_enabled) |
| rc = msmsdcc_vreg_get_voltage(io_reg); |
| } |
| |
| return rc; |
| } |
| |
| /* |
| * This function updates the IO pad power switch bit in MCI_CLK register |
| * based on currrent IO pad voltage level. |
| * NOTE: This function assumes that host lock was not taken by caller. |
| */ |
| static void msmsdcc_update_io_pad_pwr_switch(struct msmsdcc_host *host) |
| { |
| int rc = 0; |
| unsigned long flags; |
| |
| if (!is_io_pad_pwr_switch(host)) |
| return; |
| |
| rc = msmsdcc_get_vdd_io_vol(host); |
| |
| spin_lock_irqsave(&host->lock, flags); |
| /* |
| * Dual voltage pad is the SDCC's (chipset) functionality and not all |
| * the SDCC instances support the dual voltage pads. |
| * For dual-voltage pad (1.8v/3.3v), SW should set IO_PAD_PWR_SWITCH |
| * bit before using the pads in 1.8V mode. |
| * For regular, not dual-voltage pads (including eMMC 1.2v/1.8v pads), |
| * IO_PAD_PWR_SWITCH bit is a don't care. |
| * But we don't have an option to know (by reading some SDCC register) |
| * that a particular SDCC instance supports dual voltage pads or not, |
| * so we simply set the IO_PAD_PWR_SWITCH bit for low voltage IO |
| * (1.8v/1.2v). For regular (not dual-voltage pads), this bit value |
| * is anyway ignored. |
| */ |
| if (rc > 0 && rc < 2700000) |
| host->io_pad_pwr_switch = 1; |
| else |
| host->io_pad_pwr_switch = 0; |
| |
| if (atomic_read(&host->clks_on)) { |
| if (host->io_pad_pwr_switch) |
| writel_relaxed((readl_relaxed(host->base + MMCICLOCK) | |
| IO_PAD_PWR_SWITCH), |
| host->base + MMCICLOCK); |
| else |
| writel_relaxed((readl_relaxed(host->base + MMCICLOCK) & |
| ~IO_PAD_PWR_SWITCH), |
| host->base + MMCICLOCK); |
| msmsdcc_sync_reg_wr(host); |
| } |
| spin_unlock_irqrestore(&host->lock, flags); |
| } |
| |
| static int msmsdcc_set_vdd_io_vol(struct msmsdcc_host *host, |
| enum vdd_io_level level, |
| unsigned int voltage_level) |
| { |
| int rc = 0; |
| int set_level; |
| |
| if (host->plat->vreg_data) { |
| struct msm_mmc_reg_data *vdd_io_reg = |
| host->plat->vreg_data->vdd_io_data; |
| |
| if (vdd_io_reg && vdd_io_reg->is_enabled) { |
| switch (level) { |
| case VDD_IO_LOW: |
| set_level = vdd_io_reg->low_vol_level; |
| break; |
| case VDD_IO_HIGH: |
| set_level = vdd_io_reg->high_vol_level; |
| break; |
| case VDD_IO_SET_LEVEL: |
| set_level = voltage_level; |
| break; |
| default: |
| pr_err("%s: %s: invalid argument level = %d", |
| mmc_hostname(host->mmc), __func__, |
| level); |
| rc = -EINVAL; |
| goto out; |
| } |
| rc = msmsdcc_vreg_set_voltage(vdd_io_reg, |
| set_level, set_level); |
| } |
| } |
| |
| out: |
| return rc; |
| } |
| |
| static inline int msmsdcc_is_pwrsave(struct msmsdcc_host *host) |
| { |
| if (host->clk_rate > 400000 && msmsdcc_pwrsave) |
| return 1; |
| return 0; |
| } |
| |
| /* |
| * Any function calling msmsdcc_setup_clocks must |
| * acquire clk_mutex. May sleep. |
| */ |
| static int msmsdcc_setup_clocks(struct msmsdcc_host *host, bool enable) |
| { |
| int rc = 0; |
| |
| if (enable && !atomic_read(&host->clks_on)) { |
| if (!IS_ERR_OR_NULL(host->bus_clk)) { |
| rc = clk_prepare_enable(host->bus_clk); |
| if (rc) { |
| pr_err("%s: %s: failed to enable the bus-clock with error %d\n", |
| mmc_hostname(host->mmc), __func__, rc); |
| goto out; |
| } |
| } |
| if (!IS_ERR(host->pclk)) { |
| rc = clk_prepare_enable(host->pclk); |
| if (rc) { |
| pr_err("%s: %s: failed to enable the pclk with error %d\n", |
| mmc_hostname(host->mmc), __func__, rc); |
| goto disable_bus; |
| } |
| } |
| rc = clk_prepare_enable(host->clk); |
| if (rc) { |
| pr_err("%s: %s: failed to enable the host-clk with error %d\n", |
| mmc_hostname(host->mmc), __func__, rc); |
| goto disable_pclk; |
| } |
| mb(); |
| msmsdcc_delay(host); |
| atomic_set(&host->clks_on, 1); |
| } else if (!enable && atomic_read(&host->clks_on)) { |
| mb(); |
| msmsdcc_delay(host); |
| clk_disable_unprepare(host->clk); |
| if (!IS_ERR(host->pclk)) |
| clk_disable_unprepare(host->pclk); |
| if (!IS_ERR_OR_NULL(host->bus_clk)) |
| clk_disable_unprepare(host->bus_clk); |
| atomic_set(&host->clks_on, 0); |
| } |
| goto out; |
| |
| disable_pclk: |
| if (!IS_ERR_OR_NULL(host->pclk)) |
| clk_disable_unprepare(host->pclk); |
| disable_bus: |
| if (!IS_ERR_OR_NULL(host->bus_clk)) |
| clk_disable_unprepare(host->bus_clk); |
| out: |
| return rc; |
| } |
| |
| static inline unsigned int msmsdcc_get_sup_clk_rate(struct msmsdcc_host *host, |
| unsigned int req_clk) |
| { |
| unsigned int sel_clk = -1; |
| |
| if (req_clk < msmsdcc_get_min_sup_clk_rate(host)) { |
| sel_clk = msmsdcc_get_min_sup_clk_rate(host); |
| goto out; |
| } |
| |
| if (host->plat->sup_clk_table && host->plat->sup_clk_cnt) { |
| unsigned char cnt; |
| |
| for (cnt = 0; cnt < host->plat->sup_clk_cnt; cnt++) { |
| if (host->plat->sup_clk_table[cnt] > req_clk) |
| break; |
| else if (host->plat->sup_clk_table[cnt] == req_clk) { |
| sel_clk = host->plat->sup_clk_table[cnt]; |
| break; |
| } else |
| sel_clk = host->plat->sup_clk_table[cnt]; |
| } |
| } else { |
| if ((req_clk < host->plat->msmsdcc_fmax) && |
| (req_clk > host->plat->msmsdcc_fmid)) |
| sel_clk = host->plat->msmsdcc_fmid; |
| else |
| sel_clk = req_clk; |
| } |
| |
| out: |
| return sel_clk; |
| } |
| |
| static inline unsigned int msmsdcc_get_min_sup_clk_rate( |
| struct msmsdcc_host *host) |
| { |
| if (host->plat->sup_clk_table && host->plat->sup_clk_cnt) |
| return host->plat->sup_clk_table[0]; |
| else |
| return host->plat->msmsdcc_fmin; |
| } |
| |
| static inline unsigned int msmsdcc_get_max_sup_clk_rate( |
| struct msmsdcc_host *host) |
| { |
| if (host->plat->sup_clk_table && host->plat->sup_clk_cnt) |
| return host->plat->sup_clk_table[host->plat->sup_clk_cnt - 1]; |
| else |
| return host->plat->msmsdcc_fmax; |
| } |
| |
| static int msmsdcc_setup_gpio(struct msmsdcc_host *host, bool enable) |
| { |
| struct msm_mmc_gpio_data *curr; |
| int i, rc = 0; |
| |
| curr = host->plat->pin_data->gpio_data; |
| for (i = 0; i < curr->size; i++) { |
| if (!gpio_is_valid(curr->gpio[i].no)) { |
| rc = -EINVAL; |
| pr_err("%s: Invalid gpio = %d\n", |
| mmc_hostname(host->mmc), curr->gpio[i].no); |
| goto free_gpios; |
| } |
| if (enable) { |
| if (curr->gpio[i].is_always_on && |
| curr->gpio[i].is_enabled) |
| continue; |
| rc = gpio_request(curr->gpio[i].no, |
| curr->gpio[i].name); |
| if (rc) { |
| pr_err("%s: gpio_request(%d, %s) failed %d\n", |
| mmc_hostname(host->mmc), |
| curr->gpio[i].no, |
| curr->gpio[i].name, rc); |
| goto free_gpios; |
| } |
| curr->gpio[i].is_enabled = true; |
| } else { |
| if (curr->gpio[i].is_always_on) |
| continue; |
| gpio_free(curr->gpio[i].no); |
| curr->gpio[i].is_enabled = false; |
| } |
| } |
| goto out; |
| |
| free_gpios: |
| for (i--; i >= 0; i--) { |
| gpio_free(curr->gpio[i].no); |
| curr->gpio[i].is_enabled = false; |
| } |
| out: |
| return rc; |
| } |
| |
| static int msmsdcc_setup_pad(struct msmsdcc_host *host, bool enable) |
| { |
| struct msm_mmc_pad_data *curr; |
| int i; |
| |
| curr = host->plat->pin_data->pad_data; |
| for (i = 0; i < curr->drv->size; i++) { |
| if (enable) |
| msm_tlmm_set_hdrive(curr->drv->on[i].no, |
| curr->drv->on[i].val); |
| else |
| msm_tlmm_set_hdrive(curr->drv->off[i].no, |
| curr->drv->off[i].val); |
| } |
| |
| for (i = 0; i < curr->pull->size; i++) { |
| if (enable) |
| msm_tlmm_set_pull(curr->pull->on[i].no, |
| curr->pull->on[i].val); |
| else |
| msm_tlmm_set_pull(curr->pull->off[i].no, |
| curr->pull->off[i].val); |
| } |
| |
| return 0; |
| } |
| |
| static u32 msmsdcc_setup_pins(struct msmsdcc_host *host, bool enable) |
| { |
| int rc = 0; |
| |
| if (!host->plat->pin_data || host->plat->pin_data->cfg_sts == enable) |
| return 0; |
| |
| if (host->plat->pin_data->is_gpio) |
| rc = msmsdcc_setup_gpio(host, enable); |
| else |
| rc = msmsdcc_setup_pad(host, enable); |
| |
| if (!rc) |
| host->plat->pin_data->cfg_sts = enable; |
| |
| return rc; |
| } |
| |
| static int msmsdcc_cfg_mpm_sdiowakeup(struct msmsdcc_host *host, |
| unsigned mode) |
| { |
| int ret = 0; |
| unsigned int pin = host->plat->mpm_sdiowakeup_int; |
| |
| if (!pin) |
| return 0; |
| |
| switch (mode) { |
| case SDC_DAT1_DISABLE: |
| ret = msm_mpm_enable_pin(pin, 0); |
| break; |
| case SDC_DAT1_ENABLE: |
| ret = msm_mpm_set_pin_type(pin, IRQ_TYPE_LEVEL_LOW); |
| ret = msm_mpm_enable_pin(pin, 1); |
| break; |
| case SDC_DAT1_ENWAKE: |
| ret = msm_mpm_set_pin_wake(pin, 1); |
| break; |
| case SDC_DAT1_DISWAKE: |
| ret = msm_mpm_set_pin_wake(pin, 0); |
| break; |
| default: |
| ret = -EINVAL; |
| break; |
| } |
| |
| return ret; |
| } |
| |
| static u32 msmsdcc_setup_pwr(struct msmsdcc_host *host, struct mmc_ios *ios) |
| { |
| u32 pwr = 0; |
| int ret = 0; |
| struct mmc_host *mmc = host->mmc; |
| |
| if (host->plat->translate_vdd && !host->sdio_gpio_lpm) |
| ret = host->plat->translate_vdd(mmc_dev(mmc), ios->vdd); |
| else if (!host->plat->translate_vdd && !host->sdio_gpio_lpm) |
| ret = msmsdcc_setup_vreg(host, !!ios->vdd, false); |
| |
| if (ret) { |
| pr_err("%s: Failed to setup voltage regulators\n", |
| mmc_hostname(host->mmc)); |
| goto out; |
| } |
| |
| switch (ios->power_mode) { |
| case MMC_POWER_OFF: |
| pwr = MCI_PWR_OFF; |
| msmsdcc_cfg_mpm_sdiowakeup(host, SDC_DAT1_DISABLE); |
| /* |
| * If VDD IO rail is always on, set low voltage for VDD |
| * IO rail when slot is not in use (like when card is not |
| * present or during system suspend). |
| */ |
| msmsdcc_set_vdd_io_vol(host, VDD_IO_LOW, 0); |
| msmsdcc_update_io_pad_pwr_switch(host); |
| msmsdcc_setup_pins(host, false); |
| /* |
| * Reset the mask to prevent hitting any pending interrupts |
| * after powering up the card again. |
| */ |
| if (atomic_read(&host->clks_on)) { |
| writel_relaxed(0, host->base + MMCIMASK0); |
| mb(); |
| } |
| break; |
| case MMC_POWER_UP: |
| /* writing PWR_UP bit is redundant */ |
| pwr = MCI_PWR_UP; |
| msmsdcc_cfg_mpm_sdiowakeup(host, SDC_DAT1_ENABLE); |
| |
| msmsdcc_set_vdd_io_vol(host, VDD_IO_HIGH, 0); |
| msmsdcc_update_io_pad_pwr_switch(host); |
| msmsdcc_setup_pins(host, true); |
| break; |
| case MMC_POWER_ON: |
| pwr = MCI_PWR_ON; |
| break; |
| } |
| |
| out: |
| return pwr; |
| } |
| |
| static void msmsdcc_enable_irq_wake(struct msmsdcc_host *host) |
| { |
| unsigned int wakeup_irq; |
| |
| wakeup_irq = (host->plat->sdiowakeup_irq) ? |
| host->plat->sdiowakeup_irq : |
| host->core_irqres->start; |
| |
| if (!host->irq_wake_enabled) { |
| enable_irq_wake(wakeup_irq); |
| host->irq_wake_enabled = true; |
| } |
| } |
| |
| static void msmsdcc_disable_irq_wake(struct msmsdcc_host *host) |
| { |
| unsigned int wakeup_irq; |
| |
| wakeup_irq = (host->plat->sdiowakeup_irq) ? |
| host->plat->sdiowakeup_irq : |
| host->core_irqres->start; |
| |
| if (host->irq_wake_enabled) { |
| disable_irq_wake(wakeup_irq); |
| host->irq_wake_enabled = false; |
| } |
| } |
| |
| /* Returns required bandwidth in Bytes per Sec */ |
| static unsigned int msmsdcc_get_bw_required(struct msmsdcc_host *host, |
| struct mmc_ios *ios) |
| { |
| unsigned int bw; |
| |
| bw = host->clk_rate; |
| /* |
| * For DDR mode, SDCC controller clock will be at |
| * the double rate than the actual clock that goes to card. |
| */ |
| if (ios->bus_width == MMC_BUS_WIDTH_4) |
| bw /= 2; |
| else if (ios->bus_width == MMC_BUS_WIDTH_1) |
| bw /= 8; |
| |
| return bw; |
| } |
| |
| static int msmsdcc_msm_bus_get_vote_for_bw(struct msmsdcc_host *host, |
| unsigned int bw) |
| { |
| unsigned int *table = host->plat->msm_bus_voting_data->bw_vecs; |
| unsigned int size = host->plat->msm_bus_voting_data->bw_vecs_size; |
| int i; |
| |
| if (host->msm_bus_vote.is_max_bw_needed && bw) |
| return host->msm_bus_vote.max_bw_vote; |
| |
| for (i = 0; i < size; i++) { |
| if (bw <= table[i]) |
| break; |
| } |
| |
| if (i && (i == size)) |
| i--; |
| |
| return i; |
| } |
| |
| static int msmsdcc_msm_bus_register(struct msmsdcc_host *host) |
| { |
| int rc = 0; |
| struct msm_bus_scale_pdata *use_cases; |
| |
| if (host->plat->msm_bus_voting_data && |
| host->plat->msm_bus_voting_data->use_cases && |
| host->plat->msm_bus_voting_data->bw_vecs && |
| host->plat->msm_bus_voting_data->bw_vecs_size) { |
| use_cases = host->plat->msm_bus_voting_data->use_cases; |
| host->msm_bus_vote.client_handle = |
| msm_bus_scale_register_client(use_cases); |
| } else { |
| return 0; |
| } |
| |
| if (!host->msm_bus_vote.client_handle) { |
| pr_err("%s: msm_bus_scale_register_client() failed\n", |
| mmc_hostname(host->mmc)); |
| rc = -EFAULT; |
| } else { |
| /* cache the vote index for minimum and maximum bandwidth */ |
| host->msm_bus_vote.min_bw_vote = |
| msmsdcc_msm_bus_get_vote_for_bw(host, 0); |
| host->msm_bus_vote.max_bw_vote = |
| msmsdcc_msm_bus_get_vote_for_bw(host, UINT_MAX); |
| } |
| |
| return rc; |
| } |
| |
| static void msmsdcc_msm_bus_unregister(struct msmsdcc_host *host) |
| { |
| if (host->msm_bus_vote.client_handle) |
| msm_bus_scale_unregister_client( |
| host->msm_bus_vote.client_handle); |
| } |
| |
| /* |
| * This function must be called with host lock acquired. |
| * Caller of this function should also ensure that msm bus client |
| * handle is not null. |
| */ |
| static inline int msmsdcc_msm_bus_set_vote(struct msmsdcc_host *host, |
| int vote, |
| unsigned long flags) |
| { |
| int rc = 0; |
| |
| if (vote != host->msm_bus_vote.curr_vote) { |
| spin_unlock_irqrestore(&host->lock, flags); |
| rc = msm_bus_scale_client_update_request( |
| host->msm_bus_vote.client_handle, vote); |
| if (rc) |
| pr_err("%s: msm_bus_scale_client_update_request() failed." |
| " bus_client_handle=0x%x, vote=%d, err=%d\n", |
| mmc_hostname(host->mmc), |
| host->msm_bus_vote.client_handle, vote, rc); |
| spin_lock_irqsave(&host->lock, flags); |
| if (!rc) |
| host->msm_bus_vote.curr_vote = vote; |
| } |
| |
| return rc; |
| } |
| |
| /* |
| * Internal work. Work to set 0 bandwidth for msm bus. |
| */ |
| static void msmsdcc_msm_bus_work(struct work_struct *work) |
| { |
| struct msmsdcc_host *host = container_of(work, |
| struct msmsdcc_host, |
| msm_bus_vote.vote_work.work); |
| unsigned long flags; |
| |
| if (!host->msm_bus_vote.client_handle) |
| return; |
| |
| spin_lock_irqsave(&host->lock, flags); |
| /* don't vote for 0 bandwidth if any request is in progress */ |
| if (!host->curr.mrq) |
| msmsdcc_msm_bus_set_vote(host, |
| host->msm_bus_vote.min_bw_vote, flags); |
| else |
| pr_warning("%s: %s: SDCC transfer in progress. skipping" |
| " bus voting to 0 bandwidth\n", |
| mmc_hostname(host->mmc), __func__); |
| spin_unlock_irqrestore(&host->lock, flags); |
| } |
| |
| /* |
| * This function cancels any scheduled delayed work |
| * and sets the bus vote based on ios argument. |
| * If "ios" argument is NULL, bandwidth required is 0 else |
| * calculate the bandwidth based on ios parameters. |
| */ |
| static void msmsdcc_msm_bus_cancel_work_and_set_vote( |
| struct msmsdcc_host *host, |
| struct mmc_ios *ios) |
| { |
| unsigned long flags; |
| unsigned int bw; |
| int vote; |
| |
| if (!host->msm_bus_vote.client_handle) |
| return; |
| |
| bw = ios ? msmsdcc_get_bw_required(host, ios) : 0; |
| |
| cancel_delayed_work_sync(&host->msm_bus_vote.vote_work); |
| spin_lock_irqsave(&host->lock, flags); |
| vote = msmsdcc_msm_bus_get_vote_for_bw(host, bw); |
| msmsdcc_msm_bus_set_vote(host, vote, flags); |
| spin_unlock_irqrestore(&host->lock, flags); |
| } |
| |
| /* This function queues a work which will set the bandwidth requiement to 0 */ |
| static void msmsdcc_msm_bus_queue_work(struct msmsdcc_host *host) |
| { |
| unsigned long flags; |
| |
| if (!host->msm_bus_vote.client_handle) |
| return; |
| |
| spin_lock_irqsave(&host->lock, flags); |
| if (host->msm_bus_vote.min_bw_vote != host->msm_bus_vote.curr_vote) |
| queue_delayed_work(system_nrt_wq, |
| &host->msm_bus_vote.vote_work, |
| msecs_to_jiffies(MSM_MMC_BUS_VOTING_DELAY)); |
| spin_unlock_irqrestore(&host->lock, flags); |
| } |
| |
| static void |
| msmsdcc_cfg_sdio_wakeup(struct msmsdcc_host *host, bool enable_wakeup_irq) |
| { |
| struct mmc_host *mmc = host->mmc; |
| |
| /* |
| * SDIO_AL clients has different mechanism of handling LPM through |
| * sdio_al driver itself. The sdio wakeup interrupt is configured as |
| * part of that. Here, we are interested only in clients like WLAN. |
| */ |
| if (!(mmc->card && mmc_card_sdio(mmc->card)) |
| || host->plat->is_sdio_al_client) |
| goto out; |
| |
| if (!host->sdcc_suspended) { |
| /* |
| * When MSM is not in power collapse and we |
| * are disabling clocks, enable bit 22 in MASK0 |
| * to handle asynchronous SDIO interrupts. |
| */ |
| if (enable_wakeup_irq) { |
| writel_relaxed(MCI_SDIOINTMASK, host->base + MMCIMASK0); |
| mb(); |
| } else { |
| writel_relaxed(MCI_SDIOINTMASK, host->base + MMCICLEAR); |
| msmsdcc_sync_reg_wr(host); |
| } |
| goto out; |
| } else if (!mmc_card_wake_sdio_irq(mmc)) { |
| /* |
| * Wakeup MSM only if SDIO function drivers set |
| * MMC_PM_WAKE_SDIO_IRQ flag in their suspend call. |
| */ |
| goto out; |
| } |
| |
| if (enable_wakeup_irq) { |
| if (!host->plat->sdiowakeup_irq) { |
| /* |
| * When there is no gpio line that can be configured |
| * as wakeup interrupt handle it by configuring |
| * asynchronous sdio interrupts and DAT1 line. |
| */ |
| writel_relaxed(MCI_SDIOINTMASK, |
| host->base + MMCIMASK0); |
| mb(); |
| msmsdcc_cfg_mpm_sdiowakeup(host, SDC_DAT1_ENWAKE); |
| /* configure sdcc core interrupt as wakeup interrupt */ |
| msmsdcc_enable_irq_wake(host); |
| } else { |
| /* Let gpio line handle wakeup interrupt */ |
| writel_relaxed(0, host->base + MMCIMASK0); |
| mb(); |
| if (host->sdio_wakeupirq_disabled) { |
| host->sdio_wakeupirq_disabled = 0; |
| /* configure gpio line as wakeup interrupt */ |
| msmsdcc_enable_irq_wake(host); |
| enable_irq(host->plat->sdiowakeup_irq); |
| } |
| } |
| } else { |
| if (!host->plat->sdiowakeup_irq) { |
| /* |
| * We may not have cleared bit 22 in the interrupt |
| * handler as the clocks might be off at that time. |
| */ |
| writel_relaxed(MCI_SDIOINTMASK, host->base + MMCICLEAR); |
| msmsdcc_sync_reg_wr(host); |
| msmsdcc_cfg_mpm_sdiowakeup(host, SDC_DAT1_DISWAKE); |
| msmsdcc_disable_irq_wake(host); |
| } else if (!host->sdio_wakeupirq_disabled) { |
| disable_irq_nosync(host->plat->sdiowakeup_irq); |
| msmsdcc_disable_irq_wake(host); |
| host->sdio_wakeupirq_disabled = 1; |
| } |
| } |
| out: |
| return; |
| } |
| |
| static void |
| msmsdcc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) |
| { |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| u32 clk = 0, pwr = 0; |
| int rc; |
| unsigned long flags; |
| unsigned int clock; |
| |
| |
| /* |
| * Disable SDCC core interrupt until set_ios is completed. |
| * This avoids any race conditions with interrupt raised |
| * when turning on/off the clocks. One possible |
| * scenario is SDIO operational interrupt while the clock |
| * is turned off. |
| * host->lock is being released intermittently below. |
| * Thus, prevent concurrent access to host. |
| */ |
| |
| mutex_lock(&host->clk_mutex); |
| DBG(host, "ios->clock = %u\n", ios->clock); |
| spin_lock_irqsave(&host->lock, flags); |
| if (!host->sdcc_irq_disabled) { |
| disable_irq_nosync(host->core_irqres->start); |
| host->sdcc_irq_disabled = 1; |
| } |
| spin_unlock_irqrestore(&host->lock, flags); |
| |
| /* Make sure sdcc core irq is synchronized */ |
| synchronize_irq(host->core_irqres->start); |
| |
| pwr = msmsdcc_setup_pwr(host, ios); |
| |
| spin_lock_irqsave(&host->lock, flags); |
| if (ios->clock) { |
| spin_unlock_irqrestore(&host->lock, flags); |
| rc = msmsdcc_setup_clocks(host, true); |
| if (rc) |
| goto out; |
| spin_lock_irqsave(&host->lock, flags); |
| writel_relaxed(host->mci_irqenable, host->base + MMCIMASK0); |
| mb(); |
| msmsdcc_cfg_sdio_wakeup(host, false); |
| clock = msmsdcc_get_sup_clk_rate(host, ios->clock); |
| |
| /* |
| * For DDR50 mode, controller needs clock rate to be |
| * double than what is required on the SD card CLK pin. |
| */ |
| if (ios->timing == MMC_TIMING_UHS_DDR50) { |
| /* |
| * Make sure that we don't double the clock if |
| * doubled clock rate is already set |
| */ |
| if (!host->ddr_doubled_clk_rate || |
| (host->ddr_doubled_clk_rate && |
| (host->ddr_doubled_clk_rate != ios->clock))) { |
| host->ddr_doubled_clk_rate = |
| msmsdcc_get_sup_clk_rate( |
| host, (ios->clock * 2)); |
| clock = host->ddr_doubled_clk_rate; |
| } |
| } else { |
| host->ddr_doubled_clk_rate = 0; |
| } |
| |
| if (clock != host->clk_rate) { |
| spin_unlock_irqrestore(&host->lock, flags); |
| rc = clk_set_rate(host->clk, clock); |
| spin_lock_irqsave(&host->lock, flags); |
| if (rc < 0) |
| pr_err("%s: failed to set clk rate %u\n", |
| mmc_hostname(mmc), clock); |
| host->clk_rate = clock; |
| host->reg_write_delay = |
| (1 + ((3 * USEC_PER_SEC) / |
| (host->clk_rate ? host->clk_rate : |
| msmsdcc_get_min_sup_clk_rate(host)))); |
| } |
| /* |
| * give atleast 2 MCLK cycles delay for clocks |
| * and SDCC core to stabilize |
| */ |
| mb(); |
| msmsdcc_delay(host); |
| clk |= MCI_CLK_ENABLE; |
| } |
| if (ios->bus_width == MMC_BUS_WIDTH_8) |
| clk |= MCI_CLK_WIDEBUS_8; |
| else if (ios->bus_width == MMC_BUS_WIDTH_4) |
| clk |= MCI_CLK_WIDEBUS_4; |
| else |
| clk |= MCI_CLK_WIDEBUS_1; |
| |
| if (msmsdcc_is_pwrsave(host)) |
| clk |= MCI_CLK_PWRSAVE; |
| |
| clk |= MCI_CLK_FLOWENA; |
| |
| host->tuning_needed = 0; |
| /* |
| * Select the controller timing mode according |
| * to current bus speed mode |
| */ |
| if (host->clk_rate > (100 * 1000 * 1000) && |
| (ios->timing == MMC_TIMING_UHS_SDR104 || |
| ios->timing == MMC_TIMING_MMC_HS200)) { |
| /* Card clock frequency must be > 100MHz to enable tuning */ |
| clk |= (4 << 14); |
| host->tuning_needed = 1; |
| } else if (ios->timing == MMC_TIMING_UHS_DDR50) { |
| clk |= (3 << 14); |
| } else { |
| clk |= (2 << 14); /* feedback clock */ |
| } |
| |
| /* Select free running MCLK as input clock of cm_dll_sdc4 */ |
| clk |= (2 << 23); |
| |
| if (host->io_pad_pwr_switch) |
| clk |= IO_PAD_PWR_SWITCH; |
| |
| /* Don't write into registers if clocks are disabled */ |
| if (atomic_read(&host->clks_on)) { |
| if (readl_relaxed(host->base + MMCICLOCK) != clk) { |
| writel_relaxed(clk, host->base + MMCICLOCK); |
| msmsdcc_sync_reg_wr(host); |
| } |
| if (readl_relaxed(host->base + MMCIPOWER) != pwr) { |
| host->pwr = pwr; |
| writel_relaxed(pwr, host->base + MMCIPOWER); |
| msmsdcc_sync_reg_wr(host); |
| } |
| } |
| |
| if (!(clk & MCI_CLK_ENABLE) && atomic_read(&host->clks_on)) { |
| msmsdcc_cfg_sdio_wakeup(host, true); |
| spin_unlock_irqrestore(&host->lock, flags); |
| /* |
| * May get a wake-up interrupt the instant we disable the |
| * clocks. This would disable the wake-up interrupt. |
| */ |
| msmsdcc_setup_clocks(host, false); |
| spin_lock_irqsave(&host->lock, flags); |
| } |
| |
| if (host->tuning_in_progress) |
| WARN(!atomic_read(&host->clks_on), |
| "tuning_in_progress but SDCC clocks are OFF\n"); |
| |
| /* Let interrupts be disabled if the host is powered off */ |
| if (ios->power_mode != MMC_POWER_OFF && host->sdcc_irq_disabled) { |
| enable_irq(host->core_irqres->start); |
| host->sdcc_irq_disabled = 0; |
| } |
| spin_unlock_irqrestore(&host->lock, flags); |
| out: |
| mutex_unlock(&host->clk_mutex); |
| } |
| |
| int msmsdcc_set_pwrsave(struct mmc_host *mmc, int pwrsave) |
| { |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| u32 clk; |
| |
| clk = readl_relaxed(host->base + MMCICLOCK); |
| pr_debug("Changing to pwr_save=%d", pwrsave); |
| if (pwrsave && msmsdcc_is_pwrsave(host)) |
| clk |= MCI_CLK_PWRSAVE; |
| else |
| clk &= ~MCI_CLK_PWRSAVE; |
| writel_relaxed(clk, host->base + MMCICLOCK); |
| msmsdcc_sync_reg_wr(host); |
| |
| return 0; |
| } |
| |
| static int msmsdcc_get_ro(struct mmc_host *mmc) |
| { |
| int status = -ENOSYS; |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| |
| if (host->plat->wpswitch) { |
| status = host->plat->wpswitch(mmc_dev(mmc)); |
| } else if (gpio_is_valid(host->plat->wpswitch_gpio)) { |
| status = gpio_request(host->plat->wpswitch_gpio, |
| "SD_WP_Switch"); |
| if (status) { |
| pr_err("%s: %s: Failed to request GPIO %d\n", |
| mmc_hostname(mmc), __func__, |
| host->plat->wpswitch_gpio); |
| } else { |
| status = gpio_direction_input( |
| host->plat->wpswitch_gpio); |
| if (!status) { |
| /* |
| * Wait for atleast 300ms as debounce |
| * time for GPIO input to stabilize. |
| */ |
| msleep(300); |
| status = gpio_get_value_cansleep( |
| host->plat->wpswitch_gpio); |
| status ^= !host->plat->is_wpswitch_active_low; |
| } |
| gpio_free(host->plat->wpswitch_gpio); |
| } |
| } |
| |
| if (status < 0) |
| status = -ENOSYS; |
| pr_debug("%s: Card read-only status %d\n", __func__, status); |
| |
| return status; |
| } |
| |
| static void msmsdcc_enable_sdio_irq(struct mmc_host *mmc, int enable) |
| { |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| unsigned long flags; |
| |
| /* |
| * We may come here with clocks turned off in that case don't |
| * attempt to write into MASK0 register. While turning on the |
| * clocks mci_irqenable will be written to MASK0 register. |
| */ |
| |
| spin_lock_irqsave(&host->lock, flags); |
| if (enable) { |
| host->mci_irqenable |= MCI_SDIOINTOPERMASK; |
| if (atomic_read(&host->clks_on)) { |
| writel_relaxed(readl_relaxed(host->base + MMCIMASK0) | |
| MCI_SDIOINTOPERMASK, host->base + MMCIMASK0); |
| mb(); |
| } |
| } else { |
| host->mci_irqenable &= ~MCI_SDIOINTOPERMASK; |
| if (atomic_read(&host->clks_on)) { |
| writel_relaxed(readl_relaxed(host->base + MMCIMASK0) & |
| ~MCI_SDIOINTOPERMASK, host->base + MMCIMASK0); |
| mb(); |
| } |
| } |
| spin_unlock_irqrestore(&host->lock, flags); |
| } |
| |
| #ifdef CONFIG_PM_RUNTIME |
| static void msmsdcc_print_rpm_info(struct msmsdcc_host *host) |
| { |
| struct device *dev = mmc_dev(host->mmc); |
| |
| pr_err("%s: PM: sdcc_suspended=%d, pending_resume=%d, sdcc_suspending=%d\n", |
| mmc_hostname(host->mmc), host->sdcc_suspended, |
| host->pending_resume, host->sdcc_suspending); |
| pr_err("%s: RPM: runtime_status=%d, usage_count=%d," |
| " is_suspended=%d, disable_depth=%d, runtime_error=%d," |
| " request_pending=%d, request=%d\n", |
| mmc_hostname(host->mmc), dev->power.runtime_status, |
| atomic_read(&dev->power.usage_count), |
| dev->power.is_suspended, dev->power.disable_depth, |
| dev->power.runtime_error, dev->power.request_pending, |
| dev->power.request); |
| } |
| |
| static int msmsdcc_enable(struct mmc_host *mmc) |
| { |
| int rc = 0; |
| struct device *dev = mmc->parent; |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| |
| msmsdcc_pm_qos_update_latency(host, 1); |
| |
| if (mmc->card && mmc_card_sdio(mmc->card)) |
| goto out; |
| |
| if (host->sdcc_suspended && host->pending_resume) { |
| host->pending_resume = false; |
| pm_runtime_get_noresume(dev); |
| rc = msmsdcc_runtime_resume(dev); |
| goto skip_get_sync; |
| } |
| |
| if (dev->power.runtime_status == RPM_SUSPENDING) { |
| if (mmc->suspend_task == current) { |
| pm_runtime_get_noresume(dev); |
| goto out; |
| } |
| } else if (dev->power.runtime_status == RPM_RESUMING) { |
| pm_runtime_get_noresume(dev); |
| goto out; |
| } |
| |
| rc = pm_runtime_get_sync(dev); |
| |
| skip_get_sync: |
| if (rc < 0) { |
| WARN(1, "%s: %s: failed with error %d\n", mmc_hostname(mmc), |
| __func__, rc); |
| msmsdcc_print_rpm_info(host); |
| return rc; |
| } |
| out: |
| msmsdcc_msm_bus_cancel_work_and_set_vote(host, &mmc->ios); |
| return 0; |
| } |
| |
| static int msmsdcc_disable(struct mmc_host *mmc) |
| { |
| int rc; |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| |
| msmsdcc_pm_qos_update_latency(host, 0); |
| |
| if (mmc->card && mmc_card_sdio(mmc->card)) { |
| rc = 0; |
| goto out; |
| } |
| |
| if (host->plat->disable_runtime_pm) |
| return -ENOTSUPP; |
| |
| rc = pm_runtime_put_sync(mmc->parent); |
| |
| if (rc < 0) { |
| WARN(1, "%s: %s: failed with error %d\n", mmc_hostname(mmc), |
| __func__, rc); |
| msmsdcc_print_rpm_info(host); |
| return rc; |
| } |
| |
| out: |
| msmsdcc_msm_bus_queue_work(host); |
| return rc; |
| } |
| #else |
| static void msmsdcc_print_rpm_info(struct msmsdcc_host *host) {} |
| |
| static int msmsdcc_enable(struct mmc_host *mmc) |
| { |
| struct device *dev = mmc->parent; |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| int rc = 0; |
| |
| msmsdcc_pm_qos_update_latency(host, 1); |
| |
| if (mmc->card && mmc_card_sdio(mmc->card)) { |
| rc = 0; |
| goto out; |
| } |
| |
| if (host->sdcc_suspended && host->pending_resume) { |
| host->pending_resume = false; |
| rc = msmsdcc_runtime_resume(dev); |
| goto out; |
| } |
| |
| mutex_lock(&host->clk_mutex); |
| rc = msmsdcc_setup_clocks(host, true); |
| mutex_unlock(&host->clk_mutex); |
| |
| out: |
| if (rc < 0) { |
| pr_info("%s: %s: failed with error %d", mmc_hostname(mmc), |
| __func__, rc); |
| msmsdcc_pm_qos_update_latency(host, 0); |
| return rc; |
| } |
| msmsdcc_msm_bus_cancel_work_and_set_vote(host, &mmc->ios); |
| return 0; |
| } |
| |
| static int msmsdcc_disable(struct mmc_host *mmc) |
| { |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| int rc = 0; |
| |
| msmsdcc_pm_qos_update_latency(host, 0); |
| |
| if (mmc->card && mmc_card_sdio(mmc->card)) |
| goto out; |
| |
| mutex_lock(&host->clk_mutex); |
| rc = msmsdcc_setup_clocks(host, false); |
| mutex_unlock(&host->clk_mutex); |
| |
| if (rc) { |
| msmsdcc_pm_qos_update_latency(host, 1); |
| return rc; |
| } |
| out: |
| msmsdcc_msm_bus_queue_work(host); |
| return rc; |
| } |
| #endif |
| |
| static int msmsdcc_switch_io_voltage(struct mmc_host *mmc, |
| struct mmc_ios *ios) |
| { |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| unsigned long flags; |
| int rc = 0; |
| |
| switch (ios->signal_voltage) { |
| case MMC_SIGNAL_VOLTAGE_330: |
| /* Set VDD IO to high voltage range (2.7v - 3.6v) */ |
| rc = msmsdcc_set_vdd_io_vol(host, VDD_IO_HIGH, 0); |
| if (!rc) |
| msmsdcc_update_io_pad_pwr_switch(host); |
| goto out; |
| case MMC_SIGNAL_VOLTAGE_180: |
| break; |
| case MMC_SIGNAL_VOLTAGE_120: |
| /* |
| * For eMMC cards, VDD_IO voltage range must be changed |
| * only if it operates in HS200 SDR 1.2V mode or in |
| * DDR 1.2V mode. |
| */ |
| rc = msmsdcc_set_vdd_io_vol(host, VDD_IO_SET_LEVEL, 1200000); |
| if (!rc) |
| msmsdcc_update_io_pad_pwr_switch(host); |
| goto out; |
| default: |
| /* invalid selection. don't do anything */ |
| rc = -EINVAL; |
| goto out; |
| } |
| |
| /* |
| * If we are here means voltage switch from high voltage to |
| * low voltage is required |
| */ |
| spin_lock_irqsave(&host->lock, flags); |
| |
| /* |
| * Poll on MCIDATIN_3_0 and MCICMDIN bits of MCI_TEST_INPUT |
| * register until they become all zeros. |
| */ |
| if (readl_relaxed(host->base + MCI_TEST_INPUT) & (0xF << 1)) { |
| rc = -EAGAIN; |
| pr_err("%s: %s: MCIDATIN_3_0 is still not all zeros", |
| mmc_hostname(mmc), __func__); |
| goto out_unlock; |
| } |
| |
| /* Stop SD CLK output. */ |
| writel_relaxed((readl_relaxed(host->base + MMCICLOCK) | |
| MCI_CLK_PWRSAVE), host->base + MMCICLOCK); |
| msmsdcc_sync_reg_wr(host); |
| spin_unlock_irqrestore(&host->lock, flags); |
| |
| /* |
| * Switch VDD Io from high voltage range (2.7v - 3.6v) to |
| * low voltage range (1.7v - 1.95v). |
| */ |
| rc = msmsdcc_set_vdd_io_vol(host, VDD_IO_LOW, 0); |
| if (rc) |
| goto out; |
| |
| msmsdcc_update_io_pad_pwr_switch(host); |
| |
| /* Wait 5 ms for the voltage regulater in the card to become stable. */ |
| usleep_range(5000, 5500); |
| |
| spin_lock_irqsave(&host->lock, flags); |
| /* Disable PWRSAVE would make sure that SD CLK is always running */ |
| writel_relaxed((readl_relaxed(host->base + MMCICLOCK) |
| & ~MCI_CLK_PWRSAVE), host->base + MMCICLOCK); |
| msmsdcc_sync_reg_wr(host); |
| spin_unlock_irqrestore(&host->lock, flags); |
| |
| /* |
| * If MCIDATIN_3_0 and MCICMDIN bits of MCI_TEST_INPUT register |
| * don't become all ones within 1 ms then a Voltage Switch |
| * sequence has failed and a power cycle to the card is required. |
| * Otherwise Voltage Switch sequence is completed successfully. |
| */ |
| usleep_range(1000, 1500); |
| |
| spin_lock_irqsave(&host->lock, flags); |
| if ((readl_relaxed(host->base + MCI_TEST_INPUT) & (0xF << 1)) |
| != (0xF << 1)) { |
| pr_err("%s: %s: MCIDATIN_3_0 are still not all ones", |
| mmc_hostname(mmc), __func__); |
| rc = -EAGAIN; |
| goto out_unlock; |
| } |
| |
| out_unlock: |
| /* Enable PWRSAVE */ |
| writel_relaxed((readl_relaxed(host->base + MMCICLOCK) | |
| MCI_CLK_PWRSAVE), host->base + MMCICLOCK); |
| msmsdcc_sync_reg_wr(host); |
| spin_unlock_irqrestore(&host->lock, flags); |
| out: |
| return rc; |
| } |
| |
| static inline void msmsdcc_cm_sdc4_dll_set_freq(struct msmsdcc_host *host) |
| { |
| u32 mclk_freq = 0; |
| |
| /* Program the MCLK value to MCLK_FREQ bit field */ |
| if (host->clk_rate <= 112000000) |
| mclk_freq = 0; |
| else if (host->clk_rate <= 125000000) |
| mclk_freq = 1; |
| else if (host->clk_rate <= 137000000) |
| mclk_freq = 2; |
| else if (host->clk_rate <= 150000000) |
| mclk_freq = 3; |
| else if (host->clk_rate <= 162000000) |
| mclk_freq = 4; |
| else if (host->clk_rate <= 175000000) |
| mclk_freq = 5; |
| else if (host->clk_rate <= 187000000) |
| mclk_freq = 6; |
| else if (host->clk_rate <= 200000000) |
| mclk_freq = 7; |
| |
| writel_relaxed(((readl_relaxed(host->base + MCI_DLL_CONFIG) |
| & ~(7 << 24)) | (mclk_freq << 24)), |
| host->base + MCI_DLL_CONFIG); |
| } |
| |
| /* Initialize the DLL (Programmable Delay Line ) */ |
| static int msmsdcc_init_cm_sdc4_dll(struct msmsdcc_host *host) |
| { |
| int rc = 0; |
| unsigned long flags; |
| u32 wait_cnt; |
| |
| spin_lock_irqsave(&host->lock, flags); |
| /* |
| * Make sure that clock is always enabled when DLL |
| * tuning is in progress. Keeping PWRSAVE ON may |
| * turn off the clock. So let's disable the PWRSAVE |
| * here and re-enable it once tuning is completed. |
| */ |
| writel_relaxed((readl_relaxed(host->base + MMCICLOCK) |
| & ~MCI_CLK_PWRSAVE), host->base + MMCICLOCK); |
| msmsdcc_sync_reg_wr(host); |
| |
| /* Write 1 to DLL_RST bit of MCI_DLL_CONFIG register */ |
| writel_relaxed((readl_relaxed(host->base + MCI_DLL_CONFIG) |
| | MCI_DLL_RST), host->base + MCI_DLL_CONFIG); |
| |
| /* Write 1 to DLL_PDN bit of MCI_DLL_CONFIG register */ |
| writel_relaxed((readl_relaxed(host->base + MCI_DLL_CONFIG) |
| | MCI_DLL_PDN), host->base + MCI_DLL_CONFIG); |
| |
| msmsdcc_cm_sdc4_dll_set_freq(host); |
| |
| /* Write 0 to DLL_RST bit of MCI_DLL_CONFIG register */ |
| writel_relaxed((readl_relaxed(host->base + MCI_DLL_CONFIG) |
| & ~MCI_DLL_RST), host->base + MCI_DLL_CONFIG); |
| |
| /* Write 0 to DLL_PDN bit of MCI_DLL_CONFIG register */ |
| writel_relaxed((readl_relaxed(host->base + MCI_DLL_CONFIG) |
| & ~MCI_DLL_PDN), host->base + MCI_DLL_CONFIG); |
| |
| /* Set DLL_EN bit to 1. */ |
| writel_relaxed((readl_relaxed(host->base + MCI_DLL_CONFIG) |
| | MCI_DLL_EN), host->base + MCI_DLL_CONFIG); |
| |
| /* Set CK_OUT_EN bit to 1. */ |
| writel_relaxed((readl_relaxed(host->base + MCI_DLL_CONFIG) |
| | MCI_CK_OUT_EN), host->base + MCI_DLL_CONFIG); |
| |
| wait_cnt = 50; |
| /* Wait until DLL_LOCK bit of MCI_DLL_STATUS register becomes '1' */ |
| while (!(readl_relaxed(host->base + MCI_DLL_STATUS) & MCI_DLL_LOCK)) { |
| /* max. wait for 50us sec for LOCK bit to be set */ |
| if (--wait_cnt == 0) { |
| pr_err("%s: %s: DLL failed to LOCK\n", |
| mmc_hostname(host->mmc), __func__); |
| rc = -ETIMEDOUT; |
| goto out; |
| } |
| /* wait for 1us before polling again */ |
| udelay(1); |
| } |
| |
| out: |
| /* re-enable PWRSAVE */ |
| writel_relaxed((readl_relaxed(host->base + MMCICLOCK) | |
| MCI_CLK_PWRSAVE), host->base + MMCICLOCK); |
| msmsdcc_sync_reg_wr(host); |
| spin_unlock_irqrestore(&host->lock, flags); |
| |
| return rc; |
| } |
| |
| static inline int msmsdcc_dll_poll_ck_out_en(struct msmsdcc_host *host, |
| u8 poll) |
| { |
| int rc = 0; |
| u32 wait_cnt = 50; |
| u8 ck_out_en = 0; |
| |
| /* poll for MCI_CK_OUT_EN bit. max. poll time = 50us */ |
| ck_out_en = !!(readl_relaxed(host->base + MCI_DLL_CONFIG) & |
| MCI_CK_OUT_EN); |
| |
| while (ck_out_en != poll) { |
| if (--wait_cnt == 0) { |
| pr_err("%s: %s: CK_OUT_EN bit is not %d\n", |
| mmc_hostname(host->mmc), __func__, poll); |
| rc = -ETIMEDOUT; |
| goto out; |
| } |
| udelay(1); |
| |
| ck_out_en = !!(readl_relaxed(host->base + MCI_DLL_CONFIG) & |
| MCI_CK_OUT_EN); |
| } |
| out: |
| return rc; |
| } |
| |
| /* |
| * Enable a CDR circuit in CM_SDC4_DLL block to enable automatic |
| * calibration sequence. This function should be called before |
| * enabling AUTO_CMD19 bit in MCI_CMD register for block read |
| * commands (CMD17/CMD18). |
| * |
| * This function gets called when host spinlock acquired. |
| */ |
| static int msmsdcc_enable_cdr_cm_sdc4_dll(struct msmsdcc_host *host) |
| { |
| int rc = 0; |
| u32 config; |
| |
| config = readl_relaxed(host->base + MCI_DLL_CONFIG); |
| config |= MCI_CDR_EN; |
| config &= ~(MCI_CDR_EXT_EN | MCI_CK_OUT_EN); |
| writel_relaxed(config, host->base + MCI_DLL_CONFIG); |
| |
| /* Wait until CK_OUT_EN bit of MCI_DLL_CONFIG register becomes '0' */ |
| rc = msmsdcc_dll_poll_ck_out_en(host, 0); |
| if (rc) |
| goto err_out; |
| |
| /* Set CK_OUT_EN bit of MCI_DLL_CONFIG register to 1. */ |
| writel_relaxed((readl_relaxed(host->base + MCI_DLL_CONFIG) |
| | MCI_CK_OUT_EN), host->base + MCI_DLL_CONFIG); |
| |
| /* Wait until CK_OUT_EN bit of MCI_DLL_CONFIG register becomes '1' */ |
| rc = msmsdcc_dll_poll_ck_out_en(host, 1); |
| if (rc) |
| goto err_out; |
| |
| goto out; |
| |
| err_out: |
| pr_err("%s: %s: Failed\n", mmc_hostname(host->mmc), __func__); |
| out: |
| return rc; |
| } |
| |
| static int msmsdcc_config_cm_sdc4_dll_phase(struct msmsdcc_host *host, |
| u8 phase) |
| { |
| int rc = 0; |
| u8 grey_coded_phase_table[] = {0x0, 0x1, 0x3, 0x2, 0x6, 0x7, 0x5, 0x4, |
| 0xC, 0xD, 0xF, 0xE, 0xA, 0xB, 0x9, |
| 0x8}; |
| unsigned long flags; |
| u32 config; |
| |
| spin_lock_irqsave(&host->lock, flags); |
| |
| config = readl_relaxed(host->base + MCI_DLL_CONFIG); |
| config &= ~(MCI_CDR_EN | MCI_CK_OUT_EN); |
| config |= (MCI_CDR_EXT_EN | MCI_DLL_EN); |
| writel_relaxed(config, host->base + MCI_DLL_CONFIG); |
| |
| /* Wait until CK_OUT_EN bit of MCI_DLL_CONFIG register becomes '0' */ |
| rc = msmsdcc_dll_poll_ck_out_en(host, 0); |
| if (rc) |
| goto err_out; |
| |
| /* |
| * Write the selected DLL clock output phase (0 ... 15) |
| * to CDR_SELEXT bit field of MCI_DLL_CONFIG register. |
| */ |
| writel_relaxed(((readl_relaxed(host->base + MCI_DLL_CONFIG) |
| & ~(0xF << 20)) |
| | (grey_coded_phase_table[phase] << 20)), |
| host->base + MCI_DLL_CONFIG); |
| |
| /* Set CK_OUT_EN bit of MCI_DLL_CONFIG register to 1. */ |
| writel_relaxed((readl_relaxed(host->base + MCI_DLL_CONFIG) |
| | MCI_CK_OUT_EN), host->base + MCI_DLL_CONFIG); |
| |
| /* Wait until CK_OUT_EN bit of MCI_DLL_CONFIG register becomes '1' */ |
| rc = msmsdcc_dll_poll_ck_out_en(host, 1); |
| if (rc) |
| goto err_out; |
| |
| config = readl_relaxed(host->base + MCI_DLL_CONFIG); |
| config |= MCI_CDR_EN; |
| config &= ~MCI_CDR_EXT_EN; |
| writel_relaxed(config, host->base + MCI_DLL_CONFIG); |
| goto out; |
| |
| err_out: |
| pr_err("%s: %s: Failed to set DLL phase: %d\n", |
| mmc_hostname(host->mmc), __func__, phase); |
| out: |
| spin_unlock_irqrestore(&host->lock, flags); |
| return rc; |
| } |
| |
| /* |
| * Find out the greatest range of consecuitive selected |
| * DLL clock output phases that can be used as sampling |
| * setting for SD3.0 UHS-I card read operation (in SDR104 |
| * timing mode) or for eMMC4.5 card read operation (in HS200 |
| * timing mode). |
| * Select the 3/4 of the range and configure the DLL with the |
| * selected DLL clock output phase. |
| */ |
| static int find_most_appropriate_phase(struct msmsdcc_host *host, |
| u8 *phase_table, u8 total_phases) |
| { |
| #define MAX_PHASES 16 |
| int ret; |
| u8 ranges[MAX_PHASES][MAX_PHASES] = { {0}, {0} }; |
| u8 phases_per_row[MAX_PHASES] = {0}; |
| int row_index = 0, col_index = 0, selected_row_index = 0, curr_max = 0; |
| int i, cnt, phase_0_raw_index = 0, phase_15_raw_index = 0; |
| bool phase_0_found = false, phase_15_found = false; |
| |
| if (!total_phases || (total_phases > MAX_PHASES)) { |
| pr_err("%s: %s: invalid argument: total_phases=%d\n", |
| mmc_hostname(host->mmc), __func__, total_phases); |
| return -EINVAL; |
| } |
| |
| for (cnt = 0; cnt < total_phases; cnt++) { |
| ranges[row_index][col_index] = phase_table[cnt]; |
| phases_per_row[row_index] += 1; |
| col_index++; |
| |
| if ((cnt + 1) == total_phases) { |
| continue; |
| /* check if next phase in phase_table is consecutive or not */ |
| } else if ((phase_table[cnt] + 1) != phase_table[cnt + 1]) { |
| row_index++; |
| col_index = 0; |
| } |
| } |
| |
| if (row_index >= MAX_PHASES) |
| return -EINVAL; |
| |
| /* Check if phase-0 is present in first valid window? */ |
| if (!ranges[0][0]) { |
| phase_0_found = true; |
| phase_0_raw_index = 0; |
| /* Check if cycle exist between 2 valid windows */ |
| for (cnt = 1; cnt <= row_index; cnt++) { |
| if (phases_per_row[cnt]) { |
| for (i = 0; i < phases_per_row[cnt]; i++) { |
| if (ranges[cnt][i] == 15) { |
| phase_15_found = true; |
| phase_15_raw_index = cnt; |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| /* If 2 valid windows form cycle then merge them as single window */ |
| if (phase_0_found && phase_15_found) { |
| /* number of phases in raw where phase 0 is present */ |
| u8 phases_0 = phases_per_row[phase_0_raw_index]; |
| /* number of phases in raw where phase 15 is present */ |
| u8 phases_15 = phases_per_row[phase_15_raw_index]; |
| |
| if (phases_0 + phases_15 >= MAX_PHASES) |
| /* |
| * If there are more than 1 phase windows then total |
| * number of phases in both the windows should not be |
| * more than or equal to MAX_PHASES. |
| */ |
| return -EINVAL; |
| |
| /* Merge 2 cyclic windows */ |
| i = phases_15; |
| for (cnt = 0; cnt < phases_0; cnt++) { |
| ranges[phase_15_raw_index][i] = |
| ranges[phase_0_raw_index][cnt]; |
| if (++i >= MAX_PHASES) |
| break; |
| } |
| |
| phases_per_row[phase_0_raw_index] = 0; |
| phases_per_row[phase_15_raw_index] = phases_15 + phases_0; |
| } |
| |
| for (cnt = 0; cnt <= row_index; cnt++) { |
| if (phases_per_row[cnt] > curr_max) { |
| curr_max = phases_per_row[cnt]; |
| selected_row_index = cnt; |
| } |
| } |
| |
| i = ((curr_max * 3) / 4); |
| if (i) |
| i--; |
| |
| ret = (int)ranges[selected_row_index][i]; |
| |
| if (ret >= MAX_PHASES) { |
| ret = -EINVAL; |
| pr_err("%s: %s: invalid phase selected=%d\n", |
| mmc_hostname(host->mmc), __func__, ret); |
| } |
| |
| return ret; |
| } |
| |
| static int msmsdcc_execute_tuning(struct mmc_host *mmc, u32 opcode) |
| { |
| int rc = 0; |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| unsigned long flags; |
| u8 phase, *data_buf, tuned_phases[16], tuned_phase_cnt = 0; |
| const u32 *tuning_block_pattern = tuning_block_64; |
| int size = sizeof(tuning_block_64); /* Tuning pattern size in bytes */ |
| |
| pr_debug("%s: Enter %s\n", mmc_hostname(mmc), __func__); |
| |
| /* Tuning is only required for SDR104 modes */ |
| if (!host->tuning_needed) { |
| rc = 0; |
| goto exit; |
| } |
| |
| spin_lock_irqsave(&host->lock, flags); |
| WARN(!host->pwr, "SDCC power is turned off\n"); |
| WARN(!atomic_read(&host->clks_on), "SDCC clocks are turned off\n"); |
| WARN(host->sdcc_irq_disabled, "SDCC IRQ is disabled\n"); |
| |
| host->tuning_in_progress = 1; |
| if ((opcode == MMC_SEND_TUNING_BLOCK_HS200) && |
| (mmc->ios.bus_width == MMC_BUS_WIDTH_8)) { |
| tuning_block_pattern = tuning_block_128; |
| size = sizeof(tuning_block_128); |
| } |
| spin_unlock_irqrestore(&host->lock, flags); |
| |
| /* first of all reset the tuning block */ |
| rc = msmsdcc_init_cm_sdc4_dll(host); |
| if (rc) |
| goto out; |
| |
| data_buf = kmalloc(size, GFP_KERNEL); |
| if (!data_buf) { |
| rc = -ENOMEM; |
| goto out; |
| } |
| |
| phase = 0; |
| do { |
| struct mmc_command cmd = {0}; |
| struct mmc_data data = {0}; |
| struct mmc_request mrq = { |
| .cmd = &cmd, |
| .data = &data |
| }; |
| struct scatterlist sg; |
| |
| /* set the phase in delay line hw block */ |
| rc = msmsdcc_config_cm_sdc4_dll_phase(host, phase); |
| if (rc) |
| goto kfree; |
| |
| cmd.opcode = opcode; |
| cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC; |
| |
| data.blksz = size; |
| data.blocks = 1; |
| data.flags = MMC_DATA_READ; |
| data.timeout_ns = 1000 * 1000 * 1000; /* 1 sec */ |
| |
| data.sg = &sg; |
| data.sg_len = 1; |
| sg_init_one(&sg, data_buf, size); |
| memset(data_buf, 0, size); |
| mmc_wait_for_req(mmc, &mrq); |
| |
| if (!cmd.error && !data.error && |
| !memcmp(data_buf, tuning_block_pattern, size)) { |
| /* tuning is successful at this tuning point */ |
| tuned_phases[tuned_phase_cnt++] = phase; |
| pr_debug("%s: %s: found good phase = %d\n", |
| mmc_hostname(mmc), __func__, phase); |
| } |
| } while (++phase < 16); |
| |
| if (tuned_phase_cnt) { |
| rc = find_most_appropriate_phase(host, tuned_phases, |
| tuned_phase_cnt); |
| if (rc < 0) |
| goto kfree; |
| else |
| phase = (u8)rc; |
| |
| /* |
| * Finally set the selected phase in delay |
| * line hw block. |
| */ |
| rc = msmsdcc_config_cm_sdc4_dll_phase(host, phase); |
| if (rc) |
| goto kfree; |
| pr_debug("%s: %s: finally setting the tuning phase to %d\n", |
| mmc_hostname(mmc), __func__, phase); |
| } else { |
| /* tuning failed */ |
| pr_err("%s: %s: no tuning point found\n", |
| mmc_hostname(mmc), __func__); |
| msmsdcc_dump_sdcc_state(host); |
| rc = -EAGAIN; |
| } |
| |
| kfree: |
| kfree(data_buf); |
| out: |
| spin_lock_irqsave(&host->lock, flags); |
| host->tuning_in_progress = 0; |
| spin_unlock_irqrestore(&host->lock, flags); |
| exit: |
| pr_debug("%s: Exit %s\n", mmc_hostname(mmc), __func__); |
| return rc; |
| } |
| |
| /* |
| * Work around of the unavailability of a power_reset functionality in SD cards |
| * by turning the OFF & back ON the regulators supplying the SD card. |
| */ |
| void msmsdcc_hw_reset(struct mmc_host *mmc) |
| { |
| struct mmc_card *card = mmc->card; |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| int rc; |
| |
| /* Write-protection bits would be lost on a hardware reset in emmc */ |
| if (!card || !mmc_card_sd(card)) |
| return; |
| |
| /* |
| * Continuing on failing to disable regulator would lead to a panic |
| * anyway, since the commands would fail and console would be flooded |
| * with prints, eventually leading to a watchdog bark |
| */ |
| rc = msmsdcc_setup_vreg(host, false, false); |
| if (rc) { |
| pr_err("%s: %s disable regulator: failed: %d\n", |
| mmc_hostname(mmc), __func__, rc); |
| BUG_ON(rc); |
| } |
| |
| /* 10ms delay for the supply to reach the desired voltage level */ |
| usleep_range(10000, 12000); |
| |
| /* |
| * Continuing on failing to enable regulator would lead to a panic |
| * anyway, since the commands would fail and console would be flooded |
| * with prints, eventually leading to a watchdog bark |
| */ |
| rc = msmsdcc_setup_vreg(host, true, false); |
| if (rc) { |
| pr_err("%s: %s enable regulator: failed: %d\n", |
| mmc_hostname(mmc), __func__, rc); |
| BUG_ON(rc); |
| } |
| |
| /* 10ms delay for the supply to reach the desired voltage level */ |
| usleep_range(10000, 12000); |
| } |
| |
| static const struct mmc_host_ops msmsdcc_ops = { |
| .enable = msmsdcc_enable, |
| .disable = msmsdcc_disable, |
| .pre_req = msmsdcc_pre_req, |
| .post_req = msmsdcc_post_req, |
| .request = msmsdcc_request, |
| .set_ios = msmsdcc_set_ios, |
| .get_ro = msmsdcc_get_ro, |
| .enable_sdio_irq = msmsdcc_enable_sdio_irq, |
| .start_signal_voltage_switch = msmsdcc_switch_io_voltage, |
| .execute_tuning = msmsdcc_execute_tuning, |
| .hw_reset = msmsdcc_hw_reset, |
| }; |
| |
| static unsigned int |
| msmsdcc_slot_status(struct msmsdcc_host *host) |
| { |
| int status; |
| unsigned int gpio_no = host->plat->status_gpio; |
| |
| status = gpio_request(gpio_no, "SD_HW_Detect"); |
| if (status) { |
| pr_err("%s: %s: Failed to request GPIO %d\n", |
| mmc_hostname(host->mmc), __func__, gpio_no); |
| } else { |
| status = gpio_direction_input(gpio_no); |
| if (!status) { |
| status = gpio_get_value_cansleep(gpio_no); |
| if (host->plat->is_status_gpio_active_low) |
| status = !status; |
| } |
| gpio_free(gpio_no); |
| } |
| return status; |
| } |
| |
| static void |
| msmsdcc_check_status(unsigned long data) |
| { |
| struct msmsdcc_host *host = (struct msmsdcc_host *)data; |
| unsigned int status; |
| |
| if (host->plat->status || gpio_is_valid(host->plat->status_gpio)) { |
| if (host->plat->status) |
| status = host->plat->status(mmc_dev(host->mmc)); |
| else |
| status = msmsdcc_slot_status(host); |
| |
| host->eject = !status; |
| |
| if (status ^ host->oldstat) { |
| if (host->plat->status) |
| pr_info("%s: Slot status change detected " |
| "(%d -> %d)\n", |
| mmc_hostname(host->mmc), |
| host->oldstat, status); |
| else if (host->plat->is_status_gpio_active_low) |
| pr_info("%s: Slot status change detected " |
| "(%d -> %d) and the card detect GPIO" |
| " is ACTIVE_LOW\n", |
| mmc_hostname(host->mmc), |
| host->oldstat, status); |
| else |
| pr_info("%s: Slot status change detected " |
| "(%d -> %d) and the card detect GPIO" |
| " is ACTIVE_HIGH\n", |
| mmc_hostname(host->mmc), |
| host->oldstat, status); |
| mmc_detect_change(host->mmc, 0); |
| } |
| host->oldstat = status; |
| } else { |
| mmc_detect_change(host->mmc, 0); |
| } |
| } |
| |
| static irqreturn_t |
| msmsdcc_platform_status_irq(int irq, void *dev_id) |
| { |
| struct msmsdcc_host *host = dev_id; |
| |
| pr_debug("%s: %d\n", __func__, irq); |
| msmsdcc_check_status((unsigned long) host); |
| return IRQ_HANDLED; |
| } |
| |
| static irqreturn_t |
| msmsdcc_platform_sdiowakeup_irq(int irq, void *dev_id) |
| { |
| struct msmsdcc_host *host = dev_id; |
| |
| pr_debug("%s: SDIO Wake up IRQ : %d\n", mmc_hostname(host->mmc), irq); |
| spin_lock(&host->lock); |
| if (!host->sdio_wakeupirq_disabled) { |
| disable_irq_nosync(irq); |
| if (host->sdcc_suspended) { |
| wake_lock(&host->sdio_wlock); |
| msmsdcc_disable_irq_wake(host); |
| } |
| host->sdio_wakeupirq_disabled = 1; |
| } |
| if (host->plat->is_sdio_al_client) { |
| wake_lock(&host->sdio_wlock); |
| spin_unlock(&host->lock); |
| mmc_signal_sdio_irq(host->mmc); |
| goto out_unlocked; |
| } |
| spin_unlock(&host->lock); |
| |
| out_unlocked: |
| return IRQ_HANDLED; |
| } |
| |
| static void |
| msmsdcc_status_notify_cb(int card_present, void *dev_id) |
| { |
| struct msmsdcc_host *host = dev_id; |
| |
| pr_debug("%s: card_present %d\n", mmc_hostname(host->mmc), |
| card_present); |
| msmsdcc_check_status((unsigned long) host); |
| } |
| |
| static int |
| msmsdcc_init_dma(struct msmsdcc_host *host) |
| { |
| memset(&host->dma, 0, sizeof(struct msmsdcc_dma_data)); |
| host->dma.host = host; |
| host->dma.channel = -1; |
| host->dma.crci = -1; |
| |
| if (!host->dmares) |
| return -ENODEV; |
| |
| host->dma.nc = dma_alloc_coherent(NULL, |
| sizeof(struct msmsdcc_nc_dmadata), |
| &host->dma.nc_busaddr, |
| GFP_KERNEL); |
| if (host->dma.nc == NULL) { |
| pr_err("Unable to allocate DMA buffer\n"); |
| return -ENOMEM; |
| } |
| memset(host->dma.nc, 0x00, sizeof(struct msmsdcc_nc_dmadata)); |
| host->dma.cmd_busaddr = host->dma.nc_busaddr; |
| host->dma.cmdptr_busaddr = host->dma.nc_busaddr + |
| offsetof(struct msmsdcc_nc_dmadata, cmdptr); |
| host->dma.channel = host->dmares->start; |
| host->dma.crci = host->dma_crci_res->start; |
| |
| return 0; |
| } |
| |
| #ifdef CONFIG_MMC_MSM_SPS_SUPPORT |
| /** |
| * Allocate and Connect a SDCC peripheral's SPS endpoint |
| * |
| * This function allocates endpoint context and |
| * connect it with memory endpoint by calling |
| * appropriate SPS driver APIs. |
| * |
| * Also registers a SPS callback function with |
| * SPS driver |
| * |
| * This function should only be called once typically |
| * during driver probe. |
| * |
| * @host - Pointer to sdcc host structure |
| * @ep - Pointer to sps endpoint data structure |
| * @is_produce - 1 means Producer endpoint |
| * 0 means Consumer endpoint |
| * |
| * @return - 0 if successful else negative value. |
| * |
| */ |
| static int msmsdcc_sps_init_ep_conn(struct msmsdcc_host *host, |
| struct msmsdcc_sps_ep_conn_data *ep, |
| bool is_producer) |
| { |
| int rc = 0; |
| struct sps_pipe *sps_pipe_handle; |
| struct sps_connect *sps_config = &ep->config; |
| struct sps_register_event *sps_event = &ep->event; |
| |
| /* Allocate endpoint context */ |
| sps_pipe_handle = sps_alloc_endpoint(); |
| if (!sps_pipe_handle) { |
| pr_err("%s: sps_alloc_endpoint() failed!!! is_producer=%d", |
| mmc_hostname(host->mmc), is_producer); |
| rc = -ENOMEM; |
| goto out; |
| } |
| |
| /* Get default connection configuration for an endpoint */ |
| rc = sps_get_config(sps_pipe_handle, sps_config); |
| if (rc) { |
| pr_err("%s: sps_get_config() failed!!! pipe_handle=0x%x," |
| " rc=%d", mmc_hostname(host->mmc), |
| (u32)sps_pipe_handle, rc); |
| goto get_config_err; |
| } |
| |
| /* Modify the default connection configuration */ |
| if (is_producer) { |
| /* |
| * For SDCC producer transfer, source should be |
| * SDCC peripheral where as destination should |
| * be system memory. |
| */ |
| sps_config->source = host->sps.bam_handle; |
| sps_config->destination = SPS_DEV_HANDLE_MEM; |
| /* Producer pipe will handle this connection */ |
| sps_config->mode = SPS_MODE_SRC; |
| sps_config->options = |
| SPS_O_AUTO_ENABLE | SPS_O_EOT | SPS_O_ACK_TRANSFERS; |
| } else { |
| /* |
| * For SDCC consumer transfer, source should be |
| * system memory where as destination should |
| * SDCC peripheral |
| */ |
| sps_config->source = SPS_DEV_HANDLE_MEM; |
| sps_config->destination = host->sps.bam_handle; |
| sps_config->mode = SPS_MODE_DEST; |
| sps_config->options = |
| SPS_O_AUTO_ENABLE | SPS_O_EOT | SPS_O_ACK_TRANSFERS; |
| } |
| |
| /* Producer pipe index */ |
| sps_config->src_pipe_index = host->sps.src_pipe_index; |
| /* Consumer pipe index */ |
| sps_config->dest_pipe_index = host->sps.dest_pipe_index; |
| /* |
| * This event thresold value is only significant for BAM-to-BAM |
| * transfer. It's ignored for BAM-to-System mode transfer. |
| */ |
| sps_config->event_thresh = 0x10; |
| |
| /* Allocate maximum descriptor fifo size */ |
| sps_config->desc.size = SPS_MAX_DESC_FIFO_SIZE - |
| (SPS_MAX_DESC_FIFO_SIZE % SPS_MAX_DESC_LENGTH); |
| sps_config->desc.base = dma_alloc_coherent(mmc_dev(host->mmc), |
| sps_config->desc.size, |
| &sps_config->desc.phys_base, |
| GFP_KERNEL); |
| |
| if (!sps_config->desc.base) { |
| rc = -ENOMEM; |
| pr_err("%s: dma_alloc_coherent() failed!!! Can't allocate buffer\n" |
| , mmc_hostname(host->mmc)); |
| goto get_config_err; |
| } |
| memset(sps_config->desc.base, 0x00, sps_config->desc.size); |
| |
| /* Establish connection between peripheral and memory endpoint */ |
| rc = sps_connect(sps_pipe_handle, sps_config); |
| if (rc) { |
| pr_err("%s: sps_connect() failed!!! pipe_handle=0x%x," |
| " rc=%d", mmc_hostname(host->mmc), |
| (u32)sps_pipe_handle, rc); |
| goto sps_connect_err; |
| } |
| |
| sps_event->mode = SPS_TRIGGER_CALLBACK; |
| sps_event->options = SPS_O_EOT; |
| sps_event->callback = msmsdcc_sps_complete_cb; |
| sps_event->xfer_done = NULL; |
| sps_event->user = (void *)host; |
| |
| /* Register callback event for EOT (End of transfer) event. */ |
| rc = sps_register_event(sps_pipe_handle, sps_event); |
| if (rc) { |
| pr_err("%s: sps_connect() failed!!! pipe_handle=0x%x," |
| " rc=%d", mmc_hostname(host->mmc), |
| (u32)sps_pipe_handle, rc); |
| goto reg_event_err; |
| } |
| /* Now save the sps pipe handle */ |
| ep->pipe_handle = sps_pipe_handle; |
| pr_debug("%s: %s, success !!! %s: pipe_handle=0x%x," |
| " desc_fifo.phys_base=0x%x\n", mmc_hostname(host->mmc), |
| __func__, is_producer ? "READ" : "WRITE", |
| (u32)sps_pipe_handle, sps_config->desc.phys_base); |
| goto out; |
| |
| reg_event_err: |
| sps_disconnect(sps_pipe_handle); |
| sps_connect_err: |
| dma_free_coherent(mmc_dev(host->mmc), |
| sps_config->desc.size, |
| sps_config->desc.base, |
| sps_config->desc.phys_base); |
| get_config_err: |
| sps_free_endpoint(sps_pipe_handle); |
| out: |
| return rc; |
| } |
| |
| /** |
| * Disconnect and Deallocate a SDCC peripheral's SPS endpoint |
| * |
| * This function disconnect endpoint and deallocates |
| * endpoint context. |
| * |
| * This function should only be called once typically |
| * during driver remove. |
| * |
| * @host - Pointer to sdcc host structure |
| * @ep - Pointer to sps endpoint data structure |
| * |
| */ |
| static void msmsdcc_sps_exit_ep_conn(struct msmsdcc_host *host, |
| struct msmsdcc_sps_ep_conn_data *ep) |
| { |
| struct sps_pipe *sps_pipe_handle = ep->pipe_handle; |
| struct sps_connect *sps_config = &ep->config; |
| struct sps_register_event *sps_event = &ep->event; |
| |
| sps_event->xfer_done = NULL; |
| sps_event->callback = NULL; |
| sps_register_event(sps_pipe_handle, sps_event); |
| sps_disconnect(sps_pipe_handle); |
| dma_free_coherent(mmc_dev(host->mmc), |
| sps_config->desc.size, |
| sps_config->desc.base, |
| sps_config->desc.phys_base); |
| sps_free_endpoint(sps_pipe_handle); |
| } |
| |
| /** |
| * Reset SDCC peripheral's SPS endpoint |
| * |
| * This function disconnects an endpoint. |
| * |
| * This function should be called for reseting |
| * SPS endpoint when data transfer error is |
| * encountered during data transfer. This |
| * can be considered as soft reset to endpoint. |
| * |
| * This function should only be called if |
| * msmsdcc_sps_init() is already called. |
| * |
| * @host - Pointer to sdcc host structure |
| * @ep - Pointer to sps endpoint data structure |
| * |
| * @return - 0 if successful else negative value. |
| */ |
| static int msmsdcc_sps_reset_ep(struct msmsdcc_host *host, |
| struct msmsdcc_sps_ep_conn_data *ep) |
| { |
| int rc = 0; |
| struct sps_pipe *sps_pipe_handle = ep->pipe_handle; |
| |
| rc = sps_disconnect(sps_pipe_handle); |
| if (rc) { |
| pr_err("%s: %s: sps_disconnect() failed!!! pipe_handle=0x%x," |
| " rc=%d", mmc_hostname(host->mmc), __func__, |
| (u32)sps_pipe_handle, rc); |
| goto out; |
| } |
| out: |
| return rc; |
| } |
| |
| /** |
| * Restore SDCC peripheral's SPS endpoint |
| * |
| * This function connects an endpoint. |
| * |
| * This function should be called for restoring |
| * SPS endpoint after data transfer error is |
| * encountered during data transfer. This |
| * can be considered as soft reset to endpoint. |
| * |
| * This function should only be called if |
| * msmsdcc_sps_reset_ep() is called before. |
| * |
| * @host - Pointer to sdcc host structure |
| * @ep - Pointer to sps endpoint data structure |
| * |
| * @return - 0 if successful else negative value. |
| */ |
| static int msmsdcc_sps_restore_ep(struct msmsdcc_host *host, |
| struct msmsdcc_sps_ep_conn_data *ep) |
| { |
| int rc = 0; |
| struct sps_pipe *sps_pipe_handle = ep->pipe_handle; |
| struct sps_connect *sps_config = &ep->config; |
| struct sps_register_event *sps_event = &ep->event; |
| |
| /* Establish connection between peripheral and memory endpoint */ |
| rc = sps_connect(sps_pipe_handle, sps_config); |
| if (rc) { |
| pr_err("%s: %s: sps_connect() failed!!! pipe_handle=0x%x," |
| " rc=%d", mmc_hostname(host->mmc), __func__, |
| (u32)sps_pipe_handle, rc); |
| goto out; |
| } |
| |
| /* Register callback event for EOT (End of transfer) event. */ |
| rc = sps_register_event(sps_pipe_handle, sps_event); |
| if (rc) { |
| pr_err("%s: %s: sps_register_event() failed!!!" |
| " pipe_handle=0x%x, rc=%d", |
| mmc_hostname(host->mmc), __func__, |
| (u32)sps_pipe_handle, rc); |
| goto reg_event_err; |
| } |
| goto out; |
| |
| reg_event_err: |
| sps_disconnect(sps_pipe_handle); |
| out: |
| return rc; |
| } |
| |
| /** |
| * Handle BAM device's global error condition |
| * |
| * This is an error handler for the SDCC bam device |
| * |
| * This function is registered as a callback with SPS-BAM |
| * driver and will called in case there are an errors for |
| * the SDCC BAM deivce. Any error conditions in the BAM |
| * device are global and will be result in this function |
| * being called once per device. |
| * |
| * This function will be called from the sps driver's |
| * interrupt context. |
| * |
| * @sps_cb_case - indicates what error it is |
| * @user - Pointer to sdcc host structure |
| */ |
| static void |
| msmsdcc_sps_bam_global_irq_cb(enum sps_callback_case sps_cb_case, void *user) |
| { |
| struct msmsdcc_host *host = (struct msmsdcc_host *)user; |
| struct mmc_request *mrq; |
| unsigned long flags; |
| int32_t error = 0; |
| |
| BUG_ON(!host); |
| BUG_ON(!is_sps_mode(host)); |
| |
| if (sps_cb_case == SPS_CALLBACK_BAM_ERROR_IRQ) { |
| /** |
| * Reset the all endpoints along with reseting the sps device. |
| */ |
| host->sps.pipe_reset_pending = true; |
| host->sps.reset_device = true; |
| |
| pr_err("%s: BAM Global ERROR IRQ happened\n", |
| mmc_hostname(host->mmc)); |
| error = EAGAIN; |
| } else if (sps_cb_case == SPS_CALLBACK_BAM_HRESP_ERR_IRQ) { |
| /** |
| * This means that there was an AHB access error and |
| * the address we are trying to read/write is something |
| * we dont have priviliges to do so. |
| */ |
| pr_err("%s: BAM HRESP_ERR_IRQ happened\n", |
| mmc_hostname(host->mmc)); |
| error = EACCES; |
| } else { |
| /** |
| * This should not have happened ideally. If this happens |
| * there is some seriously wrong. |
| */ |
| pr_err("%s: BAM global IRQ callback received, type:%d\n", |
| mmc_hostname(host->mmc), (u32) sps_cb_case); |
| error = EIO; |
| } |
| |
| spin_lock_irqsave(&host->lock, flags); |
| |
| mrq = host->curr.mrq; |
| |
| if (mrq && mrq->cmd) { |
| msmsdcc_dump_sdcc_state(host); |
| |
| if (!mrq->cmd->error) |
| mrq->cmd->error = -error; |
| if (host->curr.data) { |
| if (mrq->data && !mrq->data->error) |
| mrq->data->error = -error; |
| host->curr.data_xfered = 0; |
| if (host->sps.sg && is_sps_mode(host)) { |
| /* Stop current SPS transfer */ |
| msmsdcc_sps_exit_curr_xfer(host); |
| } else { |
| /* this condition should not have happened */ |
| pr_err("%s: something is seriously wrong. "\ |
| "Funtion: %s, line: %d\n", |
| mmc_hostname(host->mmc), |
| __func__, __LINE__); |
| } |
| } else { |
| /* this condition should not have happened */ |
| pr_err("%s: something is seriously wrong. Funtion: "\ |
| "%s, line: %d\n", mmc_hostname(host->mmc), |
| __func__, __LINE__); |
| } |
| } |
| spin_unlock_irqrestore(&host->lock, flags); |
| } |
| |
| /** |
| * Initialize SPS HW connected with SDCC core |
| * |
| * This function register BAM HW resources with |
| * SPS driver and then initialize 2 SPS endpoints |
| * |
| * This function should only be called once typically |
| * during driver probe. |
| * |
| * @host - Pointer to sdcc host structure |
| * |
| * @return - 0 if successful else negative value. |
| * |
| */ |
| static int msmsdcc_sps_init(struct msmsdcc_host *host) |
| { |
| int rc = 0; |
| struct sps_bam_props bam = {0}; |
| |
| host->bam_base = ioremap(host->bam_memres->start, |
| resource_size(host->bam_memres)); |
| if (!host->bam_base) { |
| pr_err("%s: BAM ioremap() failed!!! phys_addr=0x%x," |
| " size=0x%x", mmc_hostname(host->mmc), |
| host->bam_memres->start, |
| (host->bam_memres->end - |
| host->bam_memres->start)); |
| rc = -ENOMEM; |
| goto out; |
| } |
| |
| bam.phys_addr = host->bam_memres->start; |
| bam.virt_addr = host->bam_base; |
| /* |
| * This event thresold value is only significant for BAM-to-BAM |
| * transfer. It's ignored for BAM-to-System mode transfer. |
| */ |
| bam.event_threshold = 0x10; /* Pipe event threshold */ |
| /* |
| * This threshold controls when the BAM publish |
| * the descriptor size on the sideband interface. |
| * SPS HW will be used for data transfer size even |
| * less than SDCC FIFO size. So let's set BAM summing |
| * thresold to SPS_MIN_XFER_SIZE bytes. |
| */ |
| bam.summing_threshold = SPS_MIN_XFER_SIZE; |
| /* SPS driver wll handle the SDCC BAM IRQ */ |
| bam.irq = (u32)host->bam_irqres->start; |
| bam.manage = SPS_BAM_MGR_LOCAL; |
| bam.callback = msmsdcc_sps_bam_global_irq_cb; |
| bam.user = (void *)host; |
| |
| pr_info("%s: bam physical base=0x%x\n", mmc_hostname(host->mmc), |
| (u32)bam.phys_addr); |
| pr_info("%s: bam virtual base=0x%x\n", mmc_hostname(host->mmc), |
| (u32)bam.virt_addr); |
| |
| /* Register SDCC Peripheral BAM device to SPS driver */ |
| rc = sps_register_bam_device(&bam, &host->sps.bam_handle); |
| if (rc) { |
| pr_err("%s: sps_register_bam_device() failed!!! err=%d", |
| mmc_hostname(host->mmc), rc); |
| goto reg_bam_err; |
| } |
| pr_info("%s: BAM device registered. bam_handle=0x%x", |
| mmc_hostname(host->mmc), host->sps.bam_handle); |
| |
| host->sps.src_pipe_index = SPS_SDCC_PRODUCER_PIPE_INDEX; |
| host->sps.dest_pipe_index = SPS_SDCC_CONSUMER_PIPE_INDEX; |
| |
| rc = msmsdcc_sps_init_ep_conn(host, &host->sps.prod, |
| SPS_PROD_PERIPHERAL); |
| if (rc) |
| goto sps_reset_err; |
| rc = msmsdcc_sps_init_ep_conn(host, &host->sps.cons, |
| SPS_CONS_PERIPHERAL); |
| if (rc) |
| goto cons_conn_err; |
| |
| pr_info("%s: Qualcomm MSM SDCC-BAM at 0x%016llx irq %d\n", |
| mmc_hostname(host->mmc), |
| (unsigned long long)host->bam_memres->start, |
| (unsigned int)host->bam_irqres->start); |
| goto out; |
| |
| cons_conn_err: |
| msmsdcc_sps_exit_ep_conn(host, &host->sps.prod); |
| sps_reset_err: |
| sps_deregister_bam_device(host->sps.bam_handle); |
| reg_bam_err: |
| iounmap(host->bam_base); |
| out: |
| return rc; |
| } |
| |
| /** |
| * De-initialize SPS HW connected with SDCC core |
| * |
| * This function deinitialize SPS endpoints and then |
| * deregisters BAM resources from SPS driver. |
| * |
| * This function should only be called once typically |
| * during driver remove. |
| * |
| * @host - Pointer to sdcc host structure |
| * |
| */ |
| static void msmsdcc_sps_exit(struct msmsdcc_host *host) |
| { |
| msmsdcc_sps_exit_ep_conn(host, &host->sps.cons); |
| msmsdcc_sps_exit_ep_conn(host, &host->sps.prod); |
| sps_deregister_bam_device(host->sps.bam_handle); |
| iounmap(host->bam_base); |
| } |
| #endif /* CONFIG_MMC_MSM_SPS_SUPPORT */ |
| |
| static ssize_t |
| show_polling(struct device *dev, struct device_attribute *attr, char *buf) |
| { |
| struct mmc_host *mmc = dev_get_drvdata(dev); |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| int poll; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&host->lock, flags); |
| poll = !!(mmc->caps & MMC_CAP_NEEDS_POLL); |
| spin_unlock_irqrestore(&host->lock, flags); |
| |
| return snprintf(buf, PAGE_SIZE, "%d\n", poll); |
| } |
| |
| static ssize_t |
| store_polling(struct device *dev, struct device_attribute *attr, |
| const char *buf, size_t count) |
| { |
| struct mmc_host *mmc = dev_get_drvdata(dev); |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| int value; |
| unsigned long flags; |
| |
| sscanf(buf, "%d", &value); |
| |
| spin_lock_irqsave(&host->lock, flags); |
| if (value) { |
| mmc->caps |= MMC_CAP_NEEDS_POLL; |
| mmc_detect_change(host->mmc, 0); |
| } else { |
| mmc->caps &= ~MMC_CAP_NEEDS_POLL; |
| } |
| #ifdef CONFIG_HAS_EARLYSUSPEND |
| host->polling_enabled = mmc->caps & MMC_CAP_NEEDS_POLL; |
| #endif |
| spin_unlock_irqrestore(&host->lock, flags); |
| return count; |
| } |
| |
| static ssize_t |
| show_sdcc_to_mem_max_bus_bw(struct device *dev, struct device_attribute *attr, |
| char *buf) |
| { |
| struct mmc_host *mmc = dev_get_drvdata(dev); |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| |
| return snprintf(buf, PAGE_SIZE, "%u\n", |
| host->msm_bus_vote.is_max_bw_needed); |
| } |
| |
| static ssize_t |
| store_sdcc_to_mem_max_bus_bw(struct device *dev, struct device_attribute *attr, |
| const char *buf, size_t count) |
| { |
| struct mmc_host *mmc = dev_get_drvdata(dev); |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| uint32_t value; |
| unsigned long flags; |
| |
| if (!kstrtou32(buf, 0, &value)) { |
| spin_lock_irqsave(&host->lock, flags); |
| host->msm_bus_vote.is_max_bw_needed = !!value; |
| spin_unlock_irqrestore(&host->lock, flags); |
| } |
| |
| return count; |
| } |
| |
| static ssize_t |
| show_idle_timeout(struct device *dev, struct device_attribute *attr, |
| char *buf) |
| { |
| struct mmc_host *mmc = dev_get_drvdata(dev); |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| |
| return snprintf(buf, PAGE_SIZE, "%u (Min 5 sec)\n", |
| host->idle_tout / 1000); |
| } |
| |
| static ssize_t |
| store_idle_timeout(struct device *dev, struct device_attribute *attr, |
| const char *buf, size_t count) |
| { |
| struct mmc_host *mmc = dev_get_drvdata(dev); |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| unsigned int long flags; |
| int timeout; /* in secs */ |
| |
| if (!kstrtou32(buf, 0, &timeout) |
| && (timeout > MSM_MMC_DEFAULT_IDLE_TIMEOUT / 1000)) { |
| spin_lock_irqsave(&host->lock, flags); |
| host->idle_tout = timeout * 1000; |
| spin_unlock_irqrestore(&host->lock, flags); |
| } |
| return count; |
| } |
| |
| static inline void set_auto_cmd_setting(struct device *dev, |
| const char *buf, |
| bool is_cmd19) |
| { |
| struct mmc_host *mmc = dev_get_drvdata(dev); |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| unsigned int long flags; |
| int temp; |
| |
| if (!kstrtou32(buf, 0, &temp)) { |
| spin_lock_irqsave(&host->lock, flags); |
| if (is_cmd19) |
| host->en_auto_cmd19 = !!temp; |
| else |
| host->en_auto_cmd21 = !!temp; |
| spin_unlock_irqrestore(&host->lock, flags); |
| } |
| } |
| |
| static ssize_t |
| show_enable_auto_cmd19(struct device *dev, struct device_attribute *attr, |
| char *buf) |
| { |
| struct mmc_host *mmc = dev_get_drvdata(dev); |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| |
| return snprintf(buf, PAGE_SIZE, "%d\n", host->en_auto_cmd19); |
| } |
| |
| static ssize_t |
| store_enable_auto_cmd19(struct device *dev, struct device_attribute *attr, |
| const char *buf, size_t count) |
| { |
| set_auto_cmd_setting(dev, buf, true); |
| |
| return count; |
| } |
| |
| static ssize_t |
| show_enable_auto_cmd21(struct device *dev, struct device_attribute *attr, |
| char *buf) |
| { |
| struct mmc_host *mmc = dev_get_drvdata(dev); |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| |
| return snprintf(buf, PAGE_SIZE, "%d\n", host->en_auto_cmd21); |
| } |
| |
| static ssize_t |
| store_enable_auto_cmd21(struct device *dev, struct device_attribute *attr, |
| const char *buf, size_t count) |
| { |
| set_auto_cmd_setting(dev, buf, false); |
| |
| return count; |
| } |
| |
| #ifdef CONFIG_HAS_EARLYSUSPEND |
| static void msmsdcc_early_suspend(struct early_suspend *h) |
| { |
| struct msmsdcc_host *host = |
| container_of(h, struct msmsdcc_host, early_suspend); |
| unsigned long flags; |
| |
| spin_lock_irqsave(&host->lock, flags); |
| host->polling_enabled = host->mmc->caps & MMC_CAP_NEEDS_POLL; |
| host->mmc->caps &= ~MMC_CAP_NEEDS_POLL; |
| spin_unlock_irqrestore(&host->lock, flags); |
| }; |
| static void msmsdcc_late_resume(struct early_suspend *h) |
| { |
| struct msmsdcc_host *host = |
| container_of(h, struct msmsdcc_host, early_suspend); |
| unsigned long flags; |
| |
| if (host->polling_enabled) { |
| spin_lock_irqsave(&host->lock, flags); |
| host->mmc->caps |= MMC_CAP_NEEDS_POLL; |
| mmc_detect_change(host->mmc, 0); |
| spin_unlock_irqrestore(&host->lock, flags); |
| } |
| }; |
| #endif |
| |
| static void msmsdcc_print_regs(const char *name, void __iomem *base, |
| u32 phys_base, unsigned int no_of_regs) |
| { |
| unsigned int i; |
| |
| if (!base) |
| return; |
| |
| pr_err("===== %s: Register Dumps @phys_base=0x%x, @virt_base=0x%x" |
| " =====\n", name, phys_base, (u32)base); |
| for (i = 0; i < no_of_regs; i = i + 4) { |
| pr_err("Reg=0x%.2x: 0x%.8x, 0x%.8x, 0x%.8x, 0x%.8x\n", i*4, |
| (u32)readl_relaxed(base + i*4), |
| (u32)readl_relaxed(base + ((i+1)*4)), |
| (u32)readl_relaxed(base + ((i+2)*4)), |
| (u32)readl_relaxed(base + ((i+3)*4))); |
| } |
| } |
| |
| static void msmsdcc_dump_sdcc_state(struct msmsdcc_host *host) |
| { |
| /* Dump current state of SDCC clocks, power and irq */ |
| pr_err("%s: SDCC PWR is %s\n", mmc_hostname(host->mmc), |
| (host->pwr ? "ON" : "OFF")); |
| pr_err("%s: SDCC clks are %s, MCLK rate=%d\n", |
| mmc_hostname(host->mmc), |
| (atomic_read(&host->clks_on) ? "ON" : "OFF"), |
| (u32)clk_get_rate(host->clk)); |
| pr_err("%s: SDCC irq is %s\n", mmc_hostname(host->mmc), |
| (host->sdcc_irq_disabled ? "disabled" : "enabled")); |
| |
| /* Now dump SDCC registers. Don't print FIFO registers */ |
| if (atomic_read(&host->clks_on)) { |
| msmsdcc_print_regs("SDCC-CORE", host->base, |
| host->core_memres->start, 28); |
| pr_err("%s: MCI_TEST_INPUT = 0x%.8x\n", |
| mmc_hostname(host->mmc), |
| readl_relaxed(host->base + MCI_TEST_INPUT)); |
| } |
| |
| if (host->curr.data) { |
| if (!msmsdcc_is_dma_possible(host, host->curr.data)) |
| pr_err("%s: PIO mode\n", mmc_hostname(host->mmc)); |
| else if (is_dma_mode(host)) |
| pr_err("%s: ADM mode: busy=%d, chnl=%d, crci=%d\n", |
| mmc_hostname(host->mmc), host->dma.busy, |
| host->dma.channel, host->dma.crci); |
| else if (is_sps_mode(host)) { |
| if (host->sps.busy && atomic_read(&host->clks_on)) |
| msmsdcc_print_regs("SDCC-DML", host->dml_base, |
| host->dml_memres->start, |
| 16); |
| pr_err("%s: SPS mode: busy=%d\n", |
| mmc_hostname(host->mmc), host->sps.busy); |
| } |
| |
| pr_err("%s: xfer_size=%d, data_xfered=%d, xfer_remain=%d\n", |
| mmc_hostname(host->mmc), host->curr.xfer_size, |
| host->curr.data_xfered, host->curr.xfer_remain); |
| } |
| |
| pr_err("%s: got_dataend=%d, prog_enable=%d," |
| " wait_for_auto_prog_done=%d, got_auto_prog_done=%d," |
| " req_tout_ms=%d\n", mmc_hostname(host->mmc), |
| host->curr.got_dataend, host->prog_enable, |
| host->curr.wait_for_auto_prog_done, |
| host->curr.got_auto_prog_done, host->curr.req_tout_ms); |
| msmsdcc_print_rpm_info(host); |
| } |
| |
| static void msmsdcc_req_tout_timer_hdlr(unsigned long data) |
| { |
| struct msmsdcc_host *host = (struct msmsdcc_host *)data; |
| struct mmc_request *mrq; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&host->lock, flags); |
| if (host->dummy_52_sent) { |
| pr_info("%s: %s: dummy CMD52 timeout\n", |
| mmc_hostname(host->mmc), __func__); |
| host->dummy_52_sent = 0; |
| } |
| |
| mrq = host->curr.mrq; |
| |
| if (mrq && mrq->cmd) { |
| pr_info("%s: CMD%d: Request timeout\n", mmc_hostname(host->mmc), |
| mrq->cmd->opcode); |
| msmsdcc_dump_sdcc_state(host); |
| |
| if (!mrq->cmd->error) |
| mrq->cmd->error = -ETIMEDOUT; |
| host->dummy_52_needed = 0; |
| if (host->curr.data) { |
| if (mrq->data && !mrq->data->error) |
| mrq->data->error = -ETIMEDOUT; |
| host->curr.data_xfered = 0; |
| if (host->dma.sg && is_dma_mode(host)) { |
| msm_dmov_flush(host->dma.channel, 0); |
| } else if (host->sps.sg && is_sps_mode(host)) { |
| /* Stop current SPS transfer */ |
| msmsdcc_sps_exit_curr_xfer(host); |
| } else { |
| msmsdcc_reset_and_restore(host); |
| msmsdcc_stop_data(host); |
| if (mrq->data && mrq->data->stop) |
| msmsdcc_start_command(host, |
| mrq->data->stop, 0); |
| else |
| msmsdcc_request_end(host, mrq); |
| } |
| } else { |
| host->prog_enable = 0; |
| host->curr.wait_for_auto_prog_done = false; |
| msmsdcc_reset_and_restore(host); |
| msmsdcc_request_end(host, mrq); |
| } |
| } |
| spin_unlock_irqrestore(&host->lock, flags); |
| } |
| |
| /* |
| * msmsdcc_dt_get_array - Wrapper fn to read an array of 32 bit integers |
| * |
| * @dev: device node from which the property value is to be read. |
| * @prop_name: name of the property to be searched. |
| * @out_array: filled array returned to caller |
| * @len: filled array size returned to caller |
| * @size: expected size of the array |
| * |
| * If expected "size" doesn't match with "len" an error is returned. If |
| * expected size is zero, the length of actual array is returned provided |
| * return value is zero. |
| * |
| * RETURNS: |
| * zero on success, negative error if failed. |
| */ |
| static int msmsdcc_dt_get_array(struct device *dev, const char *prop_name, |
| u32 **out_array, int *len, int size) |
| { |
| int ret = 0; |
| u32 *array = NULL; |
| struct device_node *np = dev->of_node; |
| |
| if (of_get_property(np, prop_name, len)) { |
| size_t sz; |
| sz = *len = *len / sizeof(*array); |
| |
| if (sz > 0 && !(size > 0 && (sz != size))) { |
| array = devm_kzalloc(dev, sz * sizeof(*array), |
| GFP_KERNEL); |
| if (!array) { |
| dev_err(dev, "%s: no memory\n", prop_name); |
| ret = -ENOMEM; |
| goto out; |
| } |
| |
| ret = of_property_read_u32_array(np, prop_name, |
| array, sz); |
| if (ret < 0) { |
| dev_err(dev, "%s: error reading array %d\n", |
| prop_name, ret); |
| goto out; |
| } |
| } else { |
| dev_err(dev, "%s invalid size\n", prop_name); |
| ret = -EINVAL; |
| goto out; |
| } |
| } else { |
| dev_err(dev, "%s not specified\n", prop_name); |
| ret = -EINVAL; |
| goto out; |
| } |
| *out_array = array; |
| out: |
| if (ret) |
| *len = 0; |
| return ret; |
| } |
| |
| static int msmsdcc_dt_get_pad_pull_info(struct device *dev, int id, |
| struct msm_mmc_pad_pull_data **pad_pull_data) |
| { |
| int ret = 0, base = 0, len, i; |
| u32 *tmp; |
| struct msm_mmc_pad_pull_data *pull_data; |
| struct msm_mmc_pad_pull *pull; |
| |
| switch (id) { |
| case 1: |
| base = TLMM_PULL_SDC1_CLK; |
| break; |
| case 2: |
| base = TLMM_PULL_SDC2_CLK; |
| break; |
| case 3: |
| base = TLMM_PULL_SDC3_CLK; |
| break; |
| case 4: |
| base = TLMM_PULL_SDC4_CLK; |
| break; |
| default: |
| dev_err(dev, "%s: Invalid slot id\n", __func__); |
| ret = -EINVAL; |
| goto err; |
| } |
| |
| pull_data = devm_kzalloc(dev, sizeof(struct msm_mmc_pad_pull_data), |
| GFP_KERNEL); |
| if (!pull_data) { |
| dev_err(dev, "No memory msm_mmc_pad_pull_data\n"); |
| ret = -ENOMEM; |
| goto err; |
| } |
| pull_data->size = 3; /* array size for clk, cmd, data */ |
| |
| /* Allocate on, off configs for clk, cmd, data */ |
| pull = devm_kzalloc(dev, 2 * pull_data->size *\ |
| sizeof(struct msm_mmc_pad_pull), GFP_KERNEL); |
| if (!pull) { |
| dev_err(dev, "No memory for msm_mmc_pad_pull\n"); |
| ret = -ENOMEM; |
| goto err; |
| } |
| pull_data->on = pull; |
| pull_data->off = pull + pull_data->size; |
| |
| ret = msmsdcc_dt_get_array(dev, "qcom,sdcc-pad-pull-on", |
| &tmp, &len, pull_data->size); |
| if (!ret) { |
| for (i = 0; i < len; i++) { |
| pull_data->on[i].no = base + i; |
| pull_data->on[i].val = tmp[i]; |
| dev_dbg(dev, "%s: val[%d]=0x%x\n", __func__, |
| i, pull_data->on[i].val); |
| } |
| } else { |
| goto err; |
| } |
| |
| ret = msmsdcc_dt_get_array(dev, "qcom,sdcc-pad-pull-off", |
| &tmp, &len, pull_data->size); |
| if (!ret) { |
| for (i = 0; i < len; i++) { |
| pull_data->off[i].no = base + i; |
| pull_data->off[i].val = tmp[i]; |
| dev_dbg(dev, "%s: val[%d]=0x%x\n", __func__, |
| i, pull_data->off[i].val); |
| } |
| } else { |
| goto err; |
| } |
| |
| *pad_pull_data = pull_data; |
| err: |
| return ret; |
| } |
| |
| static int msmsdcc_dt_get_pad_drv_info(struct device *dev, int id, |
| struct msm_mmc_pad_drv_data **pad_drv_data) |
| { |
| int ret = 0, base = 0, len, i; |
| u32 *tmp; |
| struct msm_mmc_pad_drv_data *drv_data; |
| struct msm_mmc_pad_drv *drv; |
| |
| switch (id) { |
| case 1: |
| base = TLMM_HDRV_SDC1_CLK; |
| break; |
| case 2: |
| base = TLMM_HDRV_SDC2_CLK; |
| break; |
| case 3: |
| base = TLMM_HDRV_SDC3_CLK; |
| break; |
| case 4: |
| base = TLMM_HDRV_SDC4_CLK; |
| break; |
| default: |
| dev_err(dev, "%s: Invalid slot id\n", __func__); |
| ret = -EINVAL; |
| goto err; |
| } |
| |
| drv_data = devm_kzalloc(dev, sizeof(struct msm_mmc_pad_drv_data), |
| GFP_KERNEL); |
| if (!drv_data) { |
| dev_err(dev, "No memory for msm_mmc_pad_drv_data\n"); |
| ret = -ENOMEM; |
| goto err; |
| } |
| drv_data->size = 3; /* array size for clk, cmd, data */ |
| |
| /* Allocate on, off configs for clk, cmd, data */ |
| drv = devm_kzalloc(dev, 2 * drv_data->size *\ |
| sizeof(struct msm_mmc_pad_drv), GFP_KERNEL); |
| if (!drv) { |
| dev_err(dev, "No memory msm_mmc_pad_drv\n"); |
| ret = -ENOMEM; |
| goto err; |
| } |
| drv_data->on = drv; |
| drv_data->off = drv + drv_data->size; |
| |
| ret = msmsdcc_dt_get_array(dev, "qcom,sdcc-pad-drv-on", |
| &tmp, &len, drv_data->size); |
| if (!ret) { |
| for (i = 0; i < len; i++) { |
| drv_data->on[i].no = base + i; |
| drv_data->on[i].val = tmp[i]; |
| dev_dbg(dev, "%s: val[%d]=0x%x\n", __func__, |
| i, drv_data->on[i].val); |
| } |
| } else { |
| goto err; |
| } |
| |
| ret = msmsdcc_dt_get_array(dev, "qcom,sdcc-pad-drv-off", |
| &tmp, &len, drv_data->size); |
| if (!ret) { |
| for (i = 0; i < len; i++) { |
| drv_data->off[i].no = base + i; |
| drv_data->off[i].val = tmp[i]; |
| dev_dbg(dev, "%s: val[%d]=0x%x\n", __func__, |
| i, drv_data->off[i].val); |
| } |
| } else { |
| goto err; |
| } |
| |
| *pad_drv_data = drv_data; |
| err: |
| return ret; |
| } |
| |
| static void msmsdcc_dt_get_cd_wp_gpio(struct device *dev, |
| struct mmc_platform_data *pdata) |
| { |
| enum of_gpio_flags flags = OF_GPIO_ACTIVE_LOW; |
| struct device_node *np = dev->of_node; |
| |
| pdata->status_gpio = of_get_named_gpio_flags(np, |
| "cd-gpios", 0, &flags); |
| if (gpio_is_valid(pdata->status_gpio)) { |
| struct platform_device *pdev = container_of(dev, |
| struct platform_device, dev); |
| pdata->status_irq = platform_get_irq_byname(pdev, "status_irq"); |
| pdata->is_status_gpio_active_low = flags & OF_GPIO_ACTIVE_LOW; |
| } |
| |
| pdata->wpswitch_gpio = of_get_named_gpio_flags(np, |
| "wp-gpios", 0, &flags); |
| if (gpio_is_valid(pdata->wpswitch_gpio)) |
| pdata->is_wpswitch_active_low = flags & OF_GPIO_ACTIVE_LOW; |
| } |
| |
| static int msmsdcc_dt_parse_gpio_info(struct device *dev, |
| struct mmc_platform_data *pdata) |
| { |
| int ret = 0, id = 0, cnt, i; |
| struct msm_mmc_pin_data *pin_data; |
| struct device_node *np = dev->of_node; |
| |
| msmsdcc_dt_get_cd_wp_gpio(dev, pdata); |
| |
| pin_data = devm_kzalloc(dev, sizeof(*pin_data), GFP_KERNEL); |
| if (!pin_data) { |
| dev_err(dev, "No memory for pin_data\n"); |
| ret = -ENOMEM; |
| goto err; |
| } |
| |
| cnt = of_gpio_count(np); |
| if (cnt > 0) { |
| pin_data->is_gpio = true; |
| |
| pin_data->gpio_data = devm_kzalloc(dev, |
| sizeof(struct msm_mmc_gpio_data), GFP_KERNEL); |
| if (!pin_data->gpio_data) { |
| dev_err(dev, "No memory for gpio_data\n"); |
| ret = -ENOMEM; |
| goto err; |
| } |
| pin_data->gpio_data->size = cnt; |
| pin_data->gpio_data->gpio = devm_kzalloc(dev, |
| cnt * sizeof(struct msm_mmc_gpio), GFP_KERNEL); |
| if (!pin_data->gpio_data->gpio) { |
| dev_err(dev, "No memory for gpio\n"); |
| ret = -ENOMEM; |
| goto err; |
| } |
| |
| for (i = 0; i < cnt; i++) { |
| const char *name = NULL; |
| char result[32]; |
| pin_data->gpio_data->gpio[i].no = of_get_gpio(np, i); |
| of_property_read_string_index(np, |
| "qcom,sdcc-gpio-names", i, &name); |
| |
| snprintf(result, 32, "%s-%s", |
| dev_name(dev), name ? name : "?"); |
| pin_data->gpio_data->gpio[i].name = result; |
| dev_dbg(dev, "%s: gpio[%s] = %d\n", __func__, |
| pin_data->gpio_data->gpio[i].name, |
| pin_data->gpio_data->gpio[i].no); |
| } |
| } else { |
| pin_data->pad_data = devm_kzalloc(dev, |
| sizeof(struct msm_mmc_pad_data), GFP_KERNEL); |
| if (!pin_data->pad_data) { |
| dev_err(dev, "No memory for pin_data->pad_data\n"); |
| ret = -ENOMEM; |
| goto err; |
| } |
| |
| of_property_read_u32(np, "cell-index", &id); |
| |
| ret = msmsdcc_dt_get_pad_pull_info(dev, id, |
| &pin_data->pad_data->pull); |
| if (ret) |
| goto err; |
| ret = msmsdcc_dt_get_pad_drv_info(dev, id, |
| &pin_data->pad_data->drv); |
| if (ret) |
| goto err; |
| } |
| |
| pdata->pin_data = pin_data; |
| err: |
| if (ret) |
| dev_err(dev, "%s failed with err %d\n", __func__, ret); |
| return ret; |
| } |
| |
| #define MAX_PROP_SIZE 32 |
| static int msmsdcc_dt_parse_vreg_info(struct device *dev, |
| struct msm_mmc_reg_data **vreg_data, const char *vreg_name) |
| { |
| int len, ret = 0; |
| const __be32 *prop; |
| char prop_name[MAX_PROP_SIZE]; |
| struct msm_mmc_reg_data *vreg; |
| struct device_node *np = dev->of_node; |
| |
| snprintf(prop_name, MAX_PROP_SIZE, "%s-supply", vreg_name); |
| if (of_parse_phandle(np, prop_name, 0)) { |
| vreg = devm_kzalloc(dev, sizeof(*vreg), GFP_KERNEL); |
| if (!vreg) { |
| dev_err(dev, "No memory for vreg: %s\n", vreg_name); |
| ret = -ENOMEM; |
| goto err; |
| } |
| |
| vreg->name = vreg_name; |
| |
| snprintf(prop_name, MAX_PROP_SIZE, |
| "qcom,sdcc-%s-always_on", vreg_name); |
| if (of_get_property(np, prop_name, NULL)) |
| vreg->always_on = true; |
| |
| snprintf(prop_name, MAX_PROP_SIZE, |
| "qcom,sdcc-%s-lpm_sup", vreg_name); |
| if (of_get_property(np, prop_name, NULL)) |
| vreg->lpm_sup = true; |
| |
| snprintf(prop_name, MAX_PROP_SIZE, |
| "qcom,sdcc-%s-voltage_level", vreg_name); |
| prop = of_get_property(np, prop_name, &len); |
| if (!prop || (len != (2 * sizeof(__be32)))) { |
| dev_warn(dev, "%s %s property\n", |
| prop ? "invalid format" : "no", prop_name); |
| } else { |
| vreg->low_vol_level = be32_to_cpup(&prop[0]); |
| vreg->high_vol_level = be32_to_cpup(&prop[1]); |
| } |
| |
| snprintf(prop_name, MAX_PROP_SIZE, |
| "qcom,sdcc-%s-current_level", vreg_name); |
| prop = of_get_property(np, prop_name, &len); |
| if (!prop || (len != (2 * sizeof(__be32)))) { |
| dev_warn(dev, "%s %s property\n", |
| prop ? "invalid format" : "no", prop_name); |
| } else { |
| vreg->lpm_uA = be32_to_cpup(&prop[0]); |
| vreg->hpm_uA = be32_to_cpup(&prop[1]); |
| } |
| |
| *vreg_data = vreg; |
| dev_dbg(dev, "%s: %s %s vol=[%d %d]uV, curr=[%d %d]uA\n", |
| vreg->name, vreg->always_on ? "always_on," : "", |
| vreg->lpm_sup ? "lpm_sup," : "", vreg->low_vol_level, |
| vreg->high_vol_level, vreg->lpm_uA, vreg->hpm_uA); |
| } |
| |
| err: |
| return ret; |
| } |
| |
| static struct mmc_platform_data *msmsdcc_populate_pdata(struct device *dev) |
| { |
| int i, ret; |
| struct mmc_platform_data *pdata; |
| struct device_node *np = dev->of_node; |
| u32 bus_width = 0, current_limit = 0; |
| u32 *clk_table, *sup_voltages; |
| int clk_table_len, sup_volt_len, len; |
| |
| pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); |
| if (!pdata) { |
| dev_err(dev, "could not allocate memory for platform data\n"); |
| goto err; |
| } |
| |
| of_property_read_u32(np, "qcom,sdcc-bus-width", &bus_width); |
| if (bus_width == 8) { |
| pdata->mmc_bus_width = MMC_CAP_8_BIT_DATA; |
| } else if (bus_width == 4) { |
| pdata->mmc_bus_width = MMC_CAP_4_BIT_DATA; |
| } else { |
| dev_notice(dev, "Invalid bus width, default to 1 bit mode\n"); |
| pdata->mmc_bus_width = 0; |
| } |
| |
| ret = msmsdcc_dt_get_array(dev, "qcom,sdcc-sup-voltages", |
| &sup_voltages, &sup_volt_len, 0); |
| if (!ret) { |
| for (i = 0; i < sup_volt_len; i += 2) { |
| u32 mask; |
| |
| mask = mmc_vddrange_to_ocrmask(sup_voltages[i], |
| sup_voltages[i + 1]); |
| if (!mask) |
| dev_err(dev, "Invalide voltage range %d\n", i); |
| pdata->ocr_mask |= mask; |
| } |
| dev_dbg(dev, "OCR mask=0x%x\n", pdata->ocr_mask); |
| } |
| |
| ret = msmsdcc_dt_get_array(dev, "qcom,sdcc-clk-rates", |
| &clk_table, &clk_table_len, 0); |
| if (!ret) { |
| pdata->sup_clk_table = clk_table; |
| pdata->sup_clk_cnt = clk_table_len; |
| } |
| |
| pdata->vreg_data = devm_kzalloc(dev, |
| sizeof(struct msm_mmc_slot_reg_data), GFP_KERNEL); |
| if (!pdata->vreg_data) { |
| dev_err(dev, "could not allocate memory for vreg_data\n"); |
| goto err; |
| } |
| |
| if (msmsdcc_dt_parse_vreg_info(dev, |
| &pdata->vreg_data->vdd_data, "vdd")) |
| goto err; |
| |
| if (msmsdcc_dt_parse_vreg_info(dev, |
| &pdata->vreg_data->vdd_io_data, "vdd-io")) |
| goto err; |
| |
| if (msmsdcc_dt_parse_gpio_info(dev, pdata)) |
| goto err; |
| |
| len = of_property_count_strings(np, "qcom,sdcc-bus-speed-mode"); |
| |
| for (i = 0; i < len; i++) { |
| const char *name = NULL; |
| |
| of_property_read_string_index(np, |
| "qcom,sdcc-bus-speed-mode", i, &name); |
| if (!name) |
| continue; |
| |
| if (!strncmp(name, "SDR12", sizeof("SDR12"))) |
| pdata->uhs_caps |= MMC_CAP_UHS_SDR12; |
| else if (!strncmp(name, "SDR25", sizeof("SDR25"))) |
| pdata->uhs_caps |= MMC_CAP_UHS_SDR25; |
| else if (!strncmp(name, "SDR50", sizeof("SDR50"))) |
| pdata->uhs_caps |= MMC_CAP_UHS_SDR50; |
| else if (!strncmp(name, "DDR50", sizeof("DDR50"))) |
| pdata->uhs_caps |= MMC_CAP_UHS_DDR50; |
| else if (!strncmp(name, "SDR104", sizeof("SDR104"))) |
| pdata->uhs_caps |= MMC_CAP_UHS_SDR104; |
| else if (!strncmp(name, "HS200_1p8v", sizeof("HS200_1p8v"))) |
| pdata->uhs_caps2 |= MMC_CAP2_HS200_1_8V_SDR; |
| else if (!strncmp(name, "HS200_1p2v", sizeof("HS200_1p2v"))) |
| pdata->uhs_caps2 |= MMC_CAP2_HS200_1_2V_SDR; |
| else if (!strncmp(name, "DDR_1p8v", sizeof("DDR_1p8v"))) |
| pdata->uhs_caps |= MMC_CAP_1_8V_DDR |
| | MMC_CAP_UHS_DDR50; |
| else if (!strncmp(name, "DDR_1p2v", sizeof("DDR_1p2v"))) |
| pdata->uhs_caps |= MMC_CAP_1_2V_DDR |
| | MMC_CAP_UHS_DDR50; |
| } |
| |
| of_property_read_u32(np, "qcom,sdcc-current-limit", ¤t_limit); |
| if (current_limit == 800) |
| pdata->uhs_caps |= MMC_CAP_MAX_CURRENT_800; |
| else if (current_limit == 600) |
| pdata->uhs_caps |= MMC_CAP_MAX_CURRENT_600; |
| else if (current_limit == 400) |
| pdata->uhs_caps |= MMC_CAP_MAX_CURRENT_400; |
| else if (current_limit == 200) |
| pdata->uhs_caps |= MMC_CAP_MAX_CURRENT_200; |
| |
| if (of_get_property(np, "qcom,sdcc-xpc", NULL)) |
| pdata->xpc_cap = true; |
| if (of_get_property(np, "qcom,sdcc-nonremovable", NULL)) |
| pdata->nonremovable = true; |
| if (of_get_property(np, "qcom,sdcc-disable_cmd23", NULL)) |
| pdata->disable_cmd23 = true; |
| |
| return pdata; |
| err: |
| return NULL; |
| } |
| |
| static int |
| msmsdcc_probe(struct platform_device *pdev) |
| { |
| struct mmc_platform_data *plat; |
| struct msmsdcc_host *host; |
| struct mmc_host *mmc; |
| unsigned long flags; |
| struct resource *core_irqres = NULL; |
| struct resource *bam_irqres = NULL; |
| struct resource *core_memres = NULL; |
| struct resource *dml_memres = NULL; |
| struct resource *bam_memres = NULL; |
| struct resource *dmares = NULL; |
| struct resource *dma_crci_res = NULL; |
| int ret = 0; |
| |
| if (pdev->dev.of_node) { |
| plat = msmsdcc_populate_pdata(&pdev->dev); |
| of_property_read_u32((&pdev->dev)->of_node, |
| "cell-index", &pdev->id); |
| } else { |
| plat = pdev->dev.platform_data; |
| } |
| |
| /* must have platform data */ |
| if (!plat) { |
| pr_err("%s: Platform data not available\n", __func__); |
| ret = -EINVAL; |
| goto out; |
| } |
| |
| if (pdev->id < 1 || pdev->id > 5) |
| return -EINVAL; |
| |
| if (plat->is_sdio_al_client && !plat->sdiowakeup_irq) { |
| pr_err("%s: No wakeup IRQ for sdio_al client\n", __func__); |
| return -EINVAL; |
| } |
| |
| if (pdev->resource == NULL || pdev->num_resources < 2) { |
| pr_err("%s: Invalid resource\n", __func__); |
| return -ENXIO; |
| } |
| |
| core_memres = platform_get_resource_byname(pdev, |
| IORESOURCE_MEM, "core_mem"); |
| bam_memres = platform_get_resource_byname(pdev, |
| IORESOURCE_MEM, "bam_mem"); |
| dml_memres = platform_get_resource_byname(pdev, |
| IORESOURCE_MEM, "dml_mem"); |
| core_irqres = platform_get_resource_byname(pdev, |
| IORESOURCE_IRQ, "core_irq"); |
| bam_irqres = platform_get_resource_byname(pdev, |
| IORESOURCE_IRQ, "bam_irq"); |
| dmares = platform_get_resource_byname(pdev, |
| IORESOURCE_DMA, "dma_chnl"); |
| dma_crci_res = platform_get_resource_byname(pdev, |
| IORESOURCE_DMA, "dma_crci"); |
| |
| if (!core_irqres || !core_memres) { |
| pr_err("%s: Invalid sdcc core resource\n", __func__); |
| return -ENXIO; |
| } |
| |
| /* |
| * Both BAM and DML memory resource should be preset. |
| * BAM IRQ resource should also be present. |
| */ |
| if ((bam_memres && !dml_memres) || |
| (!bam_memres && dml_memres) || |
| ((bam_memres && dml_memres) && !bam_irqres)) { |
| pr_err("%s: Invalid sdcc BAM/DML resource\n", __func__); |
| return -ENXIO; |
| } |
| |
| /* |
| * Setup our host structure |
| */ |
| mmc = mmc_alloc_host(sizeof(struct msmsdcc_host), &pdev->dev); |
| if (!mmc) { |
| ret = -ENOMEM; |
| goto out; |
| } |
| |
| host = mmc_priv(mmc); |
| host->pdev_id = pdev->id; |
| host->plat = plat; |
| host->mmc = mmc; |
| host->curr.cmd = NULL; |
| |
| if (!plat->disable_bam && bam_memres && dml_memres && bam_irqres) |
| set_hw_caps(host, MSMSDCC_SPS_BAM_SUP); |
| else if (dmares) |
| set_hw_caps(host, MSMSDCC_DMA_SUP); |
| |
| host->base = ioremap(core_memres->start, |
| resource_size(core_memres)); |
| if (!host->base) { |
| ret = -ENOMEM; |
| goto host_free; |
| } |
| |
| host->core_irqres = core_irqres; |
| host->bam_irqres = bam_irqres; |
| host->core_memres = core_memres; |
| host->dml_memres = dml_memres; |
| host->bam_memres = bam_memres; |
| host->dmares = dmares; |
| host->dma_crci_res = dma_crci_res; |
| spin_lock_init(&host->lock); |
| mutex_init(&host->clk_mutex); |
| |
| #ifdef CONFIG_MMC_EMBEDDED_SDIO |
| if (plat->embedded_sdio) |
| mmc_set_embedded_sdio_data(mmc, |
| &plat->embedded_sdio->cis, |
| &plat->embedded_sdio->cccr, |
| plat->embedded_sdio->funcs, |
| plat->embedded_sdio->num_funcs); |
| #endif |
| |
| tasklet_init(&host->dma_tlet, msmsdcc_dma_complete_tlet, |
| (unsigned long)host); |
| |
| tasklet_init(&host->sps.tlet, msmsdcc_sps_complete_tlet, |
| (unsigned long)host); |
| if (is_dma_mode(host)) { |
| /* Setup DMA */ |
| ret = msmsdcc_init_dma(host); |
| if (ret) |
| goto ioremap_free; |
| } else { |
| host->dma.channel = -1; |
| host->dma.crci = -1; |
| } |
| |
| /* |
| * Setup SDCC bus voter clock. |
| */ |
| host->bus_clk = clk_get(&pdev->dev, "bus_clk"); |
| if (!IS_ERR_OR_NULL(host->bus_clk)) { |
| /* Vote for max. clk rate for max. performance */ |
| ret = clk_set_rate(host->bus_clk, INT_MAX); |
| if (ret) |
| goto bus_clk_put; |
| ret = clk_prepare_enable(host->bus_clk); |
| if (ret) |
| goto bus_clk_put; |
| } |
| |
| /* |
| * Setup main peripheral bus clock |
| */ |
| host->pclk = clk_get(&pdev->dev, "iface_clk"); |
| if (!IS_ERR(host->pclk)) { |
| ret = clk_prepare_enable(host->pclk); |
| if (ret) |
| goto pclk_put; |
| |
| host->pclk_rate = clk_get_rate(host->pclk); |
| } |
| |
| /* |
| * Setup SDC MMC clock |
| */ |
| host->clk = clk_get(&pdev->dev, "core_clk"); |
| if (IS_ERR(host->clk)) { |
| ret = PTR_ERR(host->clk); |
| goto pclk_disable; |
| } |
| |
| ret = clk_set_rate(host->clk, msmsdcc_get_min_sup_clk_rate(host)); |
| if (ret) { |
| pr_err("%s: Clock rate set failed (%d)\n", __func__, ret); |
| goto clk_put; |
| } |
| |
| ret = clk_prepare_enable(host->clk); |
| if (ret) |
| goto clk_put; |
| |
| host->clk_rate = clk_get_rate(host->clk); |
| if (!host->clk_rate) |
| dev_err(&pdev->dev, "Failed to read MCLK\n"); |
| |
| set_default_hw_caps(host); |
| |
| /* |
| * Set the register write delay according to min. clock frequency |
| * supported and update later when the host->clk_rate changes. |
| */ |
| host->reg_write_delay = |
| (1 + ((3 * USEC_PER_SEC) / |
| msmsdcc_get_min_sup_clk_rate(host))); |
| |
| atomic_set(&host->clks_on, 1); |
| /* Apply Hard reset to SDCC to put it in power on default state */ |
| msmsdcc_hard_reset(host); |
| |
| #define MSM_MMC_DEFAULT_CPUDMA_LATENCY 200 /* usecs */ |
| /* pm qos request to prevent apps idle power collapse */ |
| if (host->plat->cpu_dma_latency) |
| host->cpu_dma_latency = host->plat->cpu_dma_latency; |
| else |
| host->cpu_dma_latency = MSM_MMC_DEFAULT_CPUDMA_LATENCY; |
| pm_qos_add_request(&host->pm_qos_req_dma, |
| PM_QOS_CPU_DMA_LATENCY, PM_QOS_DEFAULT_VALUE); |
| |
| ret = msmsdcc_msm_bus_register(host); |
| if (ret) |
| goto pm_qos_remove; |
| |
| if (host->msm_bus_vote.client_handle) |
| INIT_DELAYED_WORK(&host->msm_bus_vote.vote_work, |
| msmsdcc_msm_bus_work); |
| |
| ret = msmsdcc_vreg_init(host, true); |
| if (ret) { |
| pr_err("%s: msmsdcc_vreg_init() failed (%d)\n", __func__, ret); |
| goto clk_disable; |
| } |
| |
| |
| /* Clocks has to be running before accessing SPS/DML HW blocks */ |
| if (is_sps_mode(host)) { |
| /* Initialize SPS */ |
| ret = msmsdcc_sps_init(host); |
| if (ret) |
| goto vreg_deinit; |
| /* Initialize DML */ |
| ret = msmsdcc_dml_init(host); |
| if (ret) |
| goto sps_exit; |
| } |
| mmc_dev(mmc)->dma_mask = &dma_mask; |
| |
| /* |
| * Setup MMC host structure |
| */ |
| mmc->ops = &msmsdcc_ops; |
| mmc->f_min = msmsdcc_get_min_sup_clk_rate(host); |
| mmc->f_max = msmsdcc_get_max_sup_clk_rate(host); |
| mmc->ocr_avail = plat->ocr_mask; |
| mmc->clkgate_delay = MSM_MMC_CLK_GATE_DELAY; |
| |
| mmc->pm_caps |= MMC_PM_KEEP_POWER | MMC_PM_WAKE_SDIO_IRQ; |
| mmc->caps |= plat->mmc_bus_width; |
| mmc->caps |= MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED; |
| mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY | MMC_CAP_ERASE; |
| mmc->caps |= MMC_CAP_HW_RESET; |
| /* |
| * If we send the CMD23 before multi block write/read command |
| * then we need not to send CMD12 at the end of the transfer. |
| * If we don't send the CMD12 then only way to detect the PROG_DONE |
| * status is to use the AUTO_PROG_DONE status provided by SDCC4 |
| * controller. So let's enable the CMD23 for SDCC4 only. |
| */ |
| if (!plat->disable_cmd23 && is_auto_prog_done(host)) |
| mmc->caps |= MMC_CAP_CMD23; |
| |
| mmc->caps |= plat->uhs_caps; |
| mmc->caps2 |= plat->uhs_caps2; |
| /* |
| * XPC controls the maximum current in the default speed mode of SDXC |
| * card. XPC=0 means 100mA (max.) but speed class is not supported. |
| * XPC=1 means 150mA (max.) and speed class is supported. |
| */ |
| if (plat->xpc_cap) |
| mmc->caps |= (MMC_CAP_SET_XPC_330 | MMC_CAP_SET_XPC_300 | |
| MMC_CAP_SET_XPC_180); |
| |
| mmc->caps2 |= MMC_CAP2_PACKED_WR; |
| mmc->caps2 |= MMC_CAP2_PACKED_WR_CONTROL; |
| mmc->caps2 |= (MMC_CAP2_BOOTPART_NOACC | MMC_CAP2_DETECT_ON_ERR); |
| mmc->caps2 |= MMC_CAP2_SANITIZE; |
| mmc->caps2 |= MMC_CAP2_CACHE_CTRL; |
| mmc->caps2 |= MMC_CAP2_INIT_BKOPS; |
| |
| if (plat->nonremovable) |
| mmc->caps |= MMC_CAP_NONREMOVABLE; |
| mmc->caps |= MMC_CAP_SDIO_IRQ; |
| |
| if (plat->is_sdio_al_client) |
| mmc->pm_flags |= MMC_PM_IGNORE_PM_NOTIFY; |
| |
| mmc->max_segs = msmsdcc_get_nr_sg(host); |
| mmc->max_blk_size = MMC_MAX_BLK_SIZE; |
| mmc->max_blk_count = MMC_MAX_BLK_CNT; |
| |
| mmc->max_req_size = MMC_MAX_REQ_SIZE; |
| mmc->max_seg_size = mmc->max_req_size; |
| |
| writel_relaxed(0, host->base + MMCIMASK0); |
| writel_relaxed(MCI_CLEAR_STATIC_MASK, host->base + MMCICLEAR); |
| msmsdcc_sync_reg_wr(host); |
| |
| writel_relaxed(MCI_IRQENABLE, host->base + MMCIMASK0); |
| mb(); |
| host->mci_irqenable = MCI_IRQENABLE; |
| |
| ret = request_irq(core_irqres->start, msmsdcc_irq, IRQF_SHARED, |
| DRIVER_NAME " (cmd)", host); |
| if (ret) |
| goto dml_exit; |
| |
| ret = request_irq(core_irqres->start, msmsdcc_pio_irq, IRQF_SHARED, |
| DRIVER_NAME " (pio)", host); |
| if (ret) |
| goto irq_free; |
| |
| /* |
| * Enable SDCC IRQ only when host is powered on. Otherwise, this |
| * IRQ is un-necessarily being monitored by MPM (Modem power |
| * management block) during idle-power collapse. The MPM will be |
| * configured to monitor the DATA1 GPIO line with level-low trigger |
| * and thus depending on the GPIO status, it prevents TCXO shutdown |
| * during idle-power collapse. |
| */ |
| disable_irq(core_irqres->start); |
| host->sdcc_irq_disabled = 1; |
| |
| if (plat->sdiowakeup_irq) { |
| wake_lock_init(&host->sdio_wlock, WAKE_LOCK_SUSPEND, |
| mmc_hostname(mmc)); |
| ret = request_irq(plat->sdiowakeup_irq, |
| msmsdcc_platform_sdiowakeup_irq, |
| IRQF_SHARED | IRQF_TRIGGER_LOW, |
| DRIVER_NAME "sdiowakeup", host); |
| if (ret) { |
| pr_err("Unable to get sdio wakeup IRQ %d (%d)\n", |
| plat->sdiowakeup_irq, ret); |
| goto pio_irq_free; |
| } else { |
| spin_lock_irqsave(&host->lock, flags); |
| if (!host->sdio_wakeupirq_disabled) { |
| disable_irq_nosync(plat->sdiowakeup_irq); |
| host->sdio_wakeupirq_disabled = 1; |
| } |
| spin_unlock_irqrestore(&host->lock, flags); |
| } |
| } |
| |
| if (host->plat->mpm_sdiowakeup_int) { |
| wake_lock_init(&host->sdio_wlock, WAKE_LOCK_SUSPEND, |
| mmc_hostname(mmc)); |
| } |
| |
| wake_lock_init(&host->sdio_suspend_wlock, WAKE_LOCK_SUSPEND, |
| mmc_hostname(mmc)); |
| /* |
| * Setup card detect change |
| */ |
| |
| if (!plat->status_gpio) |
| plat->status_gpio = -ENOENT; |
| if (!plat->wpswitch_gpio) |
| plat->wpswitch_gpio = -ENOENT; |
| |
| if (plat->status || gpio_is_valid(plat->status_gpio)) { |
| if (plat->status) |
| host->oldstat = plat->status(mmc_dev(host->mmc)); |
| else |
| host->oldstat = msmsdcc_slot_status(host); |
| |
| host->eject = !host->oldstat; |
| } |
| |
| if (plat->status_irq) { |
| ret = request_threaded_irq(plat->status_irq, NULL, |
| msmsdcc_platform_status_irq, |
| plat->irq_flags, |
| DRIVER_NAME " (slot)", |
| host); |
| if (ret) { |
| pr_err("Unable to get slot IRQ %d (%d)\n", |
| plat->status_irq, ret); |
| goto sdiowakeup_irq_free; |
| } |
| } else if (plat->register_status_notify) { |
| plat->register_status_notify(msmsdcc_status_notify_cb, host); |
| } else if (!plat->status) |
| pr_err("%s: No card detect facilities available\n", |
| mmc_hostname(mmc)); |
| |
| mmc_set_drvdata(pdev, mmc); |
| |
| ret = pm_runtime_set_active(&(pdev)->dev); |
| if (ret < 0) |
| pr_info("%s: %s: failed with error %d", mmc_hostname(mmc), |
| __func__, ret); |
| /* |
| * There is no notion of suspend/resume for SD/MMC/SDIO |
| * cards. So host can be suspended/resumed with out |
| * worrying about its children. |
| */ |
| pm_suspend_ignore_children(&(pdev)->dev, true); |
| |
| /* |
| * MMC/SD/SDIO bus suspend/resume operations are defined |
| * only for the slots that will be used for non-removable |
| * media or for all slots when CONFIG_MMC_UNSAFE_RESUME is |
| * defined. Otherwise, they simply become card removal and |
| * insertion events during suspend and resume respectively. |
| * Hence, enable run-time PM only for slots for which bus |
| * suspend/resume operations are defined. |
| */ |
| #ifdef CONFIG_MMC_UNSAFE_RESUME |
| /* |
| * If this capability is set, MMC core will enable/disable host |
| * for every claim/release operation on a host. We use this |
| * notification to increment/decrement runtime pm usage count. |
| */ |
| pm_runtime_enable(&(pdev)->dev); |
| #else |
| if (mmc->caps & MMC_CAP_NONREMOVABLE) { |
| pm_runtime_enable(&(pdev)->dev); |
| } |
| #endif |
| host->idle_tout = MSM_MMC_DEFAULT_IDLE_TIMEOUT; |
| setup_timer(&host->req_tout_timer, msmsdcc_req_tout_timer_hdlr, |
| (unsigned long)host); |
| |
| mmc_add_host(mmc); |
| |
| #ifdef CONFIG_HAS_EARLYSUSPEND |
| host->early_suspend.suspend = msmsdcc_early_suspend; |
| host->early_suspend.resume = msmsdcc_late_resume; |
| host->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB; |
| register_early_suspend(&host->early_suspend); |
| #endif |
| |
| pr_info("%s: Qualcomm MSM SDCC-core at 0x%016llx irq %d,%d dma %d" |
| " dmacrcri %d\n", mmc_hostname(mmc), |
| (unsigned long long)core_memres->start, |
| (unsigned int) core_irqres->start, |
| (unsigned int) plat->status_irq, host->dma.channel, |
| host->dma.crci); |
| |
| pr_info("%s: Controller capabilities: 0x%.8x\n", |
| mmc_hostname(mmc), host->hw_caps); |
| pr_info("%s: 8 bit data mode %s\n", mmc_hostname(mmc), |
| (mmc->caps & MMC_CAP_8_BIT_DATA ? "enabled" : "disabled")); |
| pr_info("%s: 4 bit data mode %s\n", mmc_hostname(mmc), |
| (mmc->caps & MMC_CAP_4_BIT_DATA ? "enabled" : "disabled")); |
| pr_info("%s: polling status mode %s\n", mmc_hostname(mmc), |
| (mmc->caps & MMC_CAP_NEEDS_POLL ? "enabled" : "disabled")); |
| pr_info("%s: MMC clock %u -> %u Hz, PCLK %u Hz\n", |
| mmc_hostname(mmc), msmsdcc_get_min_sup_clk_rate(host), |
| msmsdcc_get_max_sup_clk_rate(host), host->pclk_rate); |
| pr_info("%s: Slot eject status = %d\n", mmc_hostname(mmc), |
| host->eject); |
| pr_info("%s: Power save feature enable = %d\n", |
| mmc_hostname(mmc), msmsdcc_pwrsave); |
| |
| if (is_dma_mode(host) && host->dma.channel != -1 |
| && host->dma.crci != -1) { |
| pr_info("%s: DM non-cached buffer at %p, dma_addr 0x%.8x\n", |
| mmc_hostname(mmc), host->dma.nc, host->dma.nc_busaddr); |
| pr_info("%s: DM cmd busaddr 0x%.8x, cmdptr busaddr 0x%.8x\n", |
| mmc_hostname(mmc), host->dma.cmd_busaddr, |
| host->dma.cmdptr_busaddr); |
| } else if (is_sps_mode(host)) { |
| pr_info("%s: SPS-BAM data transfer mode available\n", |
| mmc_hostname(mmc)); |
| } else |
| pr_info("%s: PIO transfer enabled\n", mmc_hostname(mmc)); |
| |
| #if defined(CONFIG_DEBUG_FS) |
| msmsdcc_dbg_createhost(host); |
| #endif |
| |
| host->max_bus_bw.show = show_sdcc_to_mem_max_bus_bw; |
| host->max_bus_bw.store = store_sdcc_to_mem_max_bus_bw; |
| sysfs_attr_init(&host->max_bus_bw.attr); |
| host->max_bus_bw.attr.name = "max_bus_bw"; |
| host->max_bus_bw.attr.mode = S_IRUGO | S_IWUSR; |
| ret = device_create_file(&pdev->dev, &host->max_bus_bw); |
| if (ret) |
| goto platform_irq_free; |
| |
| if (!plat->status_irq) { |
| host->polling.show = show_polling; |
| host->polling.store = store_polling; |
| sysfs_attr_init(&host->polling.attr); |
| host->polling.attr.name = "polling"; |
| host->polling.attr.mode = S_IRUGO | S_IWUSR; |
| ret = device_create_file(&pdev->dev, &host->polling); |
| if (ret) |
| goto remove_max_bus_bw_file; |
| } |
| host->idle_timeout.show = show_idle_timeout; |
| host->idle_timeout.store = store_idle_timeout; |
| sysfs_attr_init(&host->idle_timeout.attr); |
| host->idle_timeout.attr.name = "idle_timeout"; |
| host->idle_timeout.attr.mode = S_IRUGO | S_IWUSR; |
| ret = device_create_file(&pdev->dev, &host->idle_timeout); |
| if (ret) |
| goto remove_polling_file; |
| |
| if (!is_auto_cmd19(host)) |
| goto add_auto_cmd21_atrr; |
| |
| /* Sysfs entry for AUTO CMD19 control */ |
| host->auto_cmd19_attr.show = show_enable_auto_cmd19; |
| host->auto_cmd19_attr.store = store_enable_auto_cmd19; |
| sysfs_attr_init(&host->auto_cmd19_attr.attr); |
| host->auto_cmd19_attr.attr.name = "enable_auto_cmd19"; |
| host->auto_cmd19_attr.attr.mode = S_IRUGO | S_IWUSR; |
| ret = device_create_file(&pdev->dev, &host->auto_cmd19_attr); |
| if (ret) |
| goto remove_idle_timeout_file; |
| |
| add_auto_cmd21_atrr: |
| if (!is_auto_cmd21(host)) |
| goto exit; |
| |
| /* Sysfs entry for AUTO CMD21 control */ |
| host->auto_cmd21_attr.show = show_enable_auto_cmd21; |
| host->auto_cmd21_attr.store = store_enable_auto_cmd21; |
| sysfs_attr_init(&host->auto_cmd21_attr.attr); |
| host->auto_cmd21_attr.attr.name = "enable_auto_cmd21"; |
| host->auto_cmd21_attr.attr.mode = S_IRUGO | S_IWUSR; |
| ret = device_create_file(&pdev->dev, &host->auto_cmd21_attr); |
| if (ret) |
| goto remove_auto_cmd19_attr_file; |
| |
| exit: |
| return 0; |
| |
| remove_auto_cmd19_attr_file: |
| if (is_auto_cmd19(host)) |
| device_remove_file(&pdev->dev, &host->auto_cmd19_attr); |
| remove_idle_timeout_file: |
| device_remove_file(&pdev->dev, &host->idle_timeout); |
| remove_polling_file: |
| if (!plat->status_irq) |
| device_remove_file(&pdev->dev, &host->polling); |
| remove_max_bus_bw_file: |
| device_remove_file(&pdev->dev, &host->max_bus_bw); |
| platform_irq_free: |
| del_timer_sync(&host->req_tout_timer); |
| pm_runtime_disable(&(pdev)->dev); |
| pm_runtime_set_suspended(&(pdev)->dev); |
| |
| if (plat->status_irq) |
| free_irq(plat->status_irq, host); |
| sdiowakeup_irq_free: |
| wake_lock_destroy(&host->sdio_suspend_wlock); |
| if (plat->sdiowakeup_irq) |
| free_irq(plat->sdiowakeup_irq, host); |
| pio_irq_free: |
| if (plat->sdiowakeup_irq) |
| wake_lock_destroy(&host->sdio_wlock); |
| free_irq(core_irqres->start, host); |
| irq_free: |
| free_irq(core_irqres->start, host); |
| dml_exit: |
| if (is_sps_mode(host)) |
| msmsdcc_dml_exit(host); |
| sps_exit: |
| if (is_sps_mode(host)) |
| msmsdcc_sps_exit(host); |
| vreg_deinit: |
| msmsdcc_vreg_init(host, false); |
| clk_disable: |
| clk_disable(host->clk); |
| msmsdcc_msm_bus_unregister(host); |
| pm_qos_remove: |
| if (host->cpu_dma_latency) |
| pm_qos_remove_request(&host->pm_qos_req_dma); |
| clk_put: |
| clk_put(host->clk); |
| pclk_disable: |
| if (!IS_ERR(host->pclk)) |
| clk_disable_unprepare(host->pclk); |
| pclk_put: |
| if (!IS_ERR(host->pclk)) |
| clk_put(host->pclk); |
| if (!IS_ERR_OR_NULL(host->bus_clk)) |
| clk_disable_unprepare(host->bus_clk); |
| bus_clk_put: |
| if (!IS_ERR_OR_NULL(host->bus_clk)) |
| clk_put(host->bus_clk); |
| if (is_dma_mode(host)) { |
| if (host->dmares) |
| dma_free_coherent(NULL, |
| sizeof(struct msmsdcc_nc_dmadata), |
| host->dma.nc, host->dma.nc_busaddr); |
| } |
| ioremap_free: |
| iounmap(host->base); |
| host_free: |
| mmc_free_host(mmc); |
| out: |
| return ret; |
| } |
| |
| #ifdef CONFIG_DEBUG_FS |
| static void msmsdcc_remove_debugfs(struct msmsdcc_host *host) |
| { |
| debugfs_remove_recursive(host->debugfs_host_dir); |
| host->debugfs_host_dir = NULL; |
| } |
| #else |
| static void msmsdcc_remove_debugfs(msmsdcc_host *host) {} |
| #endif |
| |
| static int msmsdcc_remove(struct platform_device *pdev) |
| { |
| struct mmc_host *mmc = mmc_get_drvdata(pdev); |
| struct mmc_platform_data *plat; |
| struct msmsdcc_host *host; |
| |
| if (!mmc) |
| return -ENXIO; |
| |
| if (pm_runtime_suspended(&(pdev)->dev)) |
| pm_runtime_resume(&(pdev)->dev); |
| |
| host = mmc_priv(mmc); |
| |
| DBG(host, "Removing SDCC device = %d\n", pdev->id); |
| plat = host->plat; |
| |
| if (is_auto_cmd19(host)) |
| device_remove_file(&pdev->dev, &host->auto_cmd19_attr); |
| if (is_auto_cmd21(host)) |
| device_remove_file(&pdev->dev, &host->auto_cmd21_attr); |
| device_remove_file(&pdev->dev, &host->max_bus_bw); |
| if (!plat->status_irq) |
| device_remove_file(&pdev->dev, &host->polling); |
| device_remove_file(&pdev->dev, &host->idle_timeout); |
| |
| msmsdcc_remove_debugfs(host); |
| |
| del_timer_sync(&host->req_tout_timer); |
| tasklet_kill(&host->dma_tlet); |
| tasklet_kill(&host->sps.tlet); |
| mmc_remove_host(mmc); |
| |
| if (plat->status_irq) |
| free_irq(plat->status_irq, host); |
| |
| wake_lock_destroy(&host->sdio_suspend_wlock); |
| if (plat->sdiowakeup_irq) { |
| wake_lock_destroy(&host->sdio_wlock); |
| irq_set_irq_wake(plat->sdiowakeup_irq, 0); |
| free_irq(plat->sdiowakeup_irq, host); |
| } |
| |
| free_irq(host->core_irqres->start, host); |
| free_irq(host->core_irqres->start, host); |
| |
| clk_put(host->clk); |
| if (!IS_ERR(host->pclk)) |
| clk_put(host->pclk); |
| if (!IS_ERR_OR_NULL(host->bus_clk)) |
| clk_put(host->bus_clk); |
| |
| if (host->cpu_dma_latency) |
| pm_qos_remove_request(&host->pm_qos_req_dma); |
| |
| if (host->msm_bus_vote.client_handle) { |
| msmsdcc_msm_bus_cancel_work_and_set_vote(host, NULL); |
| msmsdcc_msm_bus_unregister(host); |
| } |
| |
| msmsdcc_vreg_init(host, false); |
| |
| if (is_dma_mode(host)) { |
| if (host->dmares) |
| dma_free_coherent(NULL, |
| sizeof(struct msmsdcc_nc_dmadata), |
| host->dma.nc, host->dma.nc_busaddr); |
| } |
| |
| if (is_sps_mode(host)) { |
| msmsdcc_dml_exit(host); |
| msmsdcc_sps_exit(host); |
| } |
| |
| iounmap(host->base); |
| mmc_free_host(mmc); |
| |
| #ifdef CONFIG_HAS_EARLYSUSPEND |
| unregister_early_suspend(&host->early_suspend); |
| #endif |
| pm_runtime_disable(&(pdev)->dev); |
| pm_runtime_set_suspended(&(pdev)->dev); |
| |
| return 0; |
| } |
| |
| #ifdef CONFIG_MSM_SDIO_AL |
| int msmsdcc_sdio_al_lpm(struct mmc_host *mmc, bool enable) |
| { |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| unsigned long flags; |
| int rc = 0; |
| |
| mutex_lock(&host->clk_mutex); |
| spin_lock_irqsave(&host->lock, flags); |
| pr_debug("%s: %sabling LPM\n", mmc_hostname(mmc), |
| enable ? "En" : "Dis"); |
| |
| if (enable) { |
| if (!host->sdcc_irq_disabled) { |
| writel_relaxed(0, host->base + MMCIMASK0); |
| disable_irq_nosync(host->core_irqres->start); |
| host->sdcc_irq_disabled = 1; |
| } |
| rc = msmsdcc_setup_clocks(host, false); |
| if (rc) |
| goto out; |
| |
| if (host->plat->sdio_lpm_gpio_setup && |
| !host->sdio_gpio_lpm) { |
| spin_unlock_irqrestore(&host->lock, flags); |
| host->plat->sdio_lpm_gpio_setup(mmc_dev(mmc), 0); |
| spin_lock_irqsave(&host->lock, flags); |
| host->sdio_gpio_lpm = 1; |
| } |
| |
| if (host->sdio_wakeupirq_disabled) { |
| msmsdcc_enable_irq_wake(host); |
| enable_irq(host->plat->sdiowakeup_irq); |
| host->sdio_wakeupirq_disabled = 0; |
| } |
| } else { |
| rc = msmsdcc_setup_clocks(host, true); |
| if (rc) |
| goto out; |
| |
| if (!host->sdio_wakeupirq_disabled) { |
| disable_irq_nosync(host->plat->sdiowakeup_irq); |
| host->sdio_wakeupirq_disabled = 1; |
| msmsdcc_disable_irq_wake(host); |
| } |
| |
| if (host->plat->sdio_lpm_gpio_setup && |
| host->sdio_gpio_lpm) { |
| spin_unlock_irqrestore(&host->lock, flags); |
| host->plat->sdio_lpm_gpio_setup(mmc_dev(mmc), 1); |
| spin_lock_irqsave(&host->lock, flags); |
| host->sdio_gpio_lpm = 0; |
| } |
| |
| if (host->sdcc_irq_disabled && atomic_read(&host->clks_on)) { |
| writel_relaxed(host->mci_irqenable, |
| host->base + MMCIMASK0); |
| mb(); |
| enable_irq(host->core_irqres->start); |
| host->sdcc_irq_disabled = 0; |
| } |
| } |
| out: |
| spin_unlock_irqrestore(&host->lock, flags); |
| mutex_unlock(&host->clk_mutex); |
| return rc; |
| } |
| #else |
| int msmsdcc_sdio_al_lpm(struct mmc_host *mmc, bool enable) |
| { |
| return 0; |
| } |
| #endif |
| |
| #ifdef CONFIG_PM |
| #ifdef CONFIG_MMC_CLKGATE |
| static inline void msmsdcc_gate_clock(struct msmsdcc_host *host) |
| { |
| struct mmc_host *mmc = host->mmc; |
| unsigned long flags; |
| |
| mmc_host_clk_hold(mmc); |
| spin_lock_irqsave(&mmc->clk_lock, flags); |
| mmc->clk_old = mmc->ios.clock; |
| mmc->ios.clock = 0; |
| mmc->clk_gated = true; |
| spin_unlock_irqrestore(&mmc->clk_lock, flags); |
| mmc_set_ios(mmc); |
| mmc_host_clk_release(mmc); |
| } |
| |
| static inline void msmsdcc_ungate_clock(struct msmsdcc_host *host) |
| { |
| struct mmc_host *mmc = host->mmc; |
| |
| mmc_host_clk_hold(mmc); |
| mmc->ios.clock = host->clk_rate; |
| mmc_set_ios(mmc); |
| mmc_host_clk_release(mmc); |
| } |
| #else |
| static inline void msmsdcc_gate_clock(struct msmsdcc_host *host) |
| { |
| struct mmc_host *mmc = host->mmc; |
| |
| mmc->ios.clock = 0; |
| mmc_set_ios(mmc); |
| } |
| |
| static inline void msmsdcc_ungate_clock(struct msmsdcc_host *host) |
| { |
| struct mmc_host *mmc = host->mmc; |
| |
| mmc->ios.clock = host->clk_rate; |
| mmc_set_ios(mmc); |
| } |
| #endif |
| |
| #if CONFIG_DEBUG_FS |
| static void msmsdcc_print_pm_stats(struct msmsdcc_host *host, ktime_t start, |
| const char *func) |
| { |
| ktime_t diff; |
| |
| if (host->print_pm_stats) { |
| diff = ktime_sub(ktime_get(), start); |
| pr_info("%s: %s: Completed in %llu usec\n", func, |
| mmc_hostname(host->mmc), (u64)ktime_to_us(diff)); |
| } |
| } |
| #else |
| static void msmsdcc_print_pm_stats(struct msmsdcc_host *host, ktime_t start, |
| const char *func) {} |
| #endif |
| |
| static int |
| msmsdcc_runtime_suspend(struct device *dev) |
| { |
| struct mmc_host *mmc = dev_get_drvdata(dev); |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| int rc = 0; |
| unsigned long flags; |
| ktime_t start = ktime_get(); |
| |
| if (host->plat->is_sdio_al_client) { |
| rc = 0; |
| goto out; |
| } |
| |
| pr_debug("%s: %s: start\n", mmc_hostname(mmc), __func__); |
| if (mmc) { |
| host->sdcc_suspending = 1; |
| mmc->suspend_task = current; |
| |
| /* |
| * MMC core thinks that host is disabled by now since |
| * runtime suspend is scheduled after msmsdcc_disable() |
| * is called. Thus, MMC core will try to enable the host |
| * while suspending it. This results in a synchronous |
| * runtime resume request while in runtime suspending |
| * context and hence inorder to complete this resume |
| * requet, it will wait for suspend to be complete, |
| * but runtime suspend also can not proceed further |
| * until the host is resumed. Thus, it leads to a hang. |
| * Hence, increase the pm usage count before suspending |
| * the host so that any resume requests after this will |
| * simple become pm usage counter increment operations. |
| */ |
| pm_runtime_get_noresume(dev); |
| /* If there is pending detect work abort runtime suspend */ |
| if (unlikely(work_busy(&mmc->detect.work))) |
| rc = -EAGAIN; |
| else |
| rc = mmc_suspend_host(mmc); |
| pm_runtime_put_noidle(dev); |
| |
| if (!rc) { |
| spin_lock_irqsave(&host->lock, flags); |
| host->sdcc_suspended = true; |
| spin_unlock_irqrestore(&host->lock, flags); |
| if (mmc->card && mmc_card_sdio(mmc->card) && |
| mmc->ios.clock) { |
| /* |
| * If SDIO function driver doesn't want |
| * to power off the card, atleast turn off |
| * clocks to allow deep sleep (TCXO shutdown). |
| */ |
| msmsdcc_gate_clock(host); |
| } |
| } |
| host->sdcc_suspending = 0; |
| mmc->suspend_task = NULL; |
| if (rc && wake_lock_active(&host->sdio_suspend_wlock)) |
| wake_unlock(&host->sdio_suspend_wlock); |
| } |
| pr_debug("%s: %s: ends with err=%d\n", mmc_hostname(mmc), __func__, rc); |
| out: |
| /* set bus bandwidth to 0 immediately */ |
| msmsdcc_msm_bus_cancel_work_and_set_vote(host, NULL); |
| msmsdcc_print_pm_stats(host, start, __func__); |
| return rc; |
| } |
| |
| static int |
| msmsdcc_runtime_resume(struct device *dev) |
| { |
| struct mmc_host *mmc = dev_get_drvdata(dev); |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| unsigned long flags; |
| ktime_t start = ktime_get(); |
| |
| if (host->plat->is_sdio_al_client) |
| goto out; |
| |
| pr_debug("%s: %s: start\n", mmc_hostname(mmc), __func__); |
| if (mmc) { |
| if (mmc->card && mmc_card_sdio(mmc->card) && |
| mmc_card_keep_power(mmc)) { |
| msmsdcc_ungate_clock(host); |
| } |
| |
| mmc_resume_host(mmc); |
| |
| /* |
| * FIXME: Clearing of flags must be handled in clients |
| * resume handler. |
| */ |
| spin_lock_irqsave(&host->lock, flags); |
| mmc->pm_flags = 0; |
| host->sdcc_suspended = false; |
| spin_unlock_irqrestore(&host->lock, flags); |
| |
| /* |
| * After resuming the host wait for sometime so that |
| * the SDIO work will be processed. |
| */ |
| if (mmc->card && mmc_card_sdio(mmc->card)) { |
| if ((host->plat->mpm_sdiowakeup_int || |
| host->plat->sdiowakeup_irq) && |
| wake_lock_active(&host->sdio_wlock)) |
| wake_lock_timeout(&host->sdio_wlock, 1); |
| } |
| |
| wake_unlock(&host->sdio_suspend_wlock); |
| } |
| host->pending_resume = false; |
| pr_debug("%s: %s: end\n", mmc_hostname(mmc), __func__); |
| out: |
| msmsdcc_print_pm_stats(host, start, __func__); |
| return 0; |
| } |
| |
| static int msmsdcc_runtime_idle(struct device *dev) |
| { |
| struct mmc_host *mmc = dev_get_drvdata(dev); |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| |
| if (host->plat->is_sdio_al_client) |
| return 0; |
| |
| /* Idle timeout is not configurable for now */ |
| pm_schedule_suspend(dev, host->idle_tout); |
| |
| return -EAGAIN; |
| } |
| |
| static int msmsdcc_pm_suspend(struct device *dev) |
| { |
| struct mmc_host *mmc = dev_get_drvdata(dev); |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| int rc = 0; |
| ktime_t start = ktime_get(); |
| |
| if (host->plat->is_sdio_al_client) { |
| rc = 0; |
| goto out; |
| } |
| if (host->plat->status_irq) |
| disable_irq(host->plat->status_irq); |
| |
| if (!pm_runtime_suspended(dev)) |
| rc = msmsdcc_runtime_suspend(dev); |
| out: |
| msmsdcc_print_pm_stats(host, start, __func__); |
| return rc; |
| } |
| |
| static int msmsdcc_suspend_noirq(struct device *dev) |
| { |
| struct mmc_host *mmc = dev_get_drvdata(dev); |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| int rc = 0; |
| |
| /* |
| * After platform suspend there may be active request |
| * which might have enabled clocks. For example, in SDIO |
| * case, ksdioirq thread might have scheduled after sdcc |
| * suspend but before system freeze. In that case abort |
| * suspend and retry instead of keeping the clocks on |
| * during suspend and not allowing TCXO. |
| */ |
| |
| if (atomic_read(&host->clks_on) && !host->plat->is_sdio_al_client) { |
| pr_warn("%s: clocks are on after suspend, aborting system " |
| "suspend\n", mmc_hostname(mmc)); |
| rc = -EAGAIN; |
| } |
| |
| return rc; |
| } |
| |
| static int msmsdcc_pm_resume(struct device *dev) |
| { |
| struct mmc_host *mmc = dev_get_drvdata(dev); |
| struct msmsdcc_host *host = mmc_priv(mmc); |
| int rc = 0; |
| ktime_t start = ktime_get(); |
| |
| if (host->plat->is_sdio_al_client) { |
| rc = 0; |
| goto out; |
| } |
| if (mmc->card && mmc_card_sdio(mmc->card)) |
| rc = msmsdcc_runtime_resume(dev); |
| /* |
| * As runtime PM is enabled before calling the device's platform resume |
| * callback, we use the pm_runtime_suspended API to know if SDCC is |
| * really runtime suspended or not and set the pending_resume flag only |
| * if its not runtime suspended. |
| */ |
| else if (!pm_runtime_suspended(dev)) |
| host->pending_resume = true; |
| |
| if (host->plat->status_irq) { |
| msmsdcc_check_status((unsigned long)host); |
| enable_irq(host->plat->status_irq); |
| } |
| out: |
| msmsdcc_print_pm_stats(host, start, __func__); |
| return rc; |
| } |
| |
| #else |
| static int msmsdcc_runtime_suspend(struct device *dev) |
| { |
| return 0; |
| } |
| static int msmsdcc_runtime_idle(struct device *dev) |
| { |
| return 0; |
| } |
| static int msmsdcc_pm_suspend(struct device *dev) |
| { |
| return 0; |
| } |
| static int msmsdcc_pm_resume(struct device *dev) |
| { |
| return 0; |
| } |
| static int msmsdcc_suspend_noirq(struct device *dev) |
| { |
| return 0; |
| } |
| static int msmsdcc_runtime_resume(struct device *dev) |
| { |
| return 0; |
| } |
| #endif |
| |
| static const struct dev_pm_ops msmsdcc_dev_pm_ops = { |
| .runtime_suspend = msmsdcc_runtime_suspend, |
| .runtime_resume = msmsdcc_runtime_resume, |
| .runtime_idle = msmsdcc_runtime_idle, |
| .suspend = msmsdcc_pm_suspend, |
| .resume = msmsdcc_pm_resume, |
| .suspend_noirq = msmsdcc_suspend_noirq, |
| }; |
| |
| static const struct of_device_id msmsdcc_dt_match[] = { |
| {.compatible = "qcom,msm-sdcc"}, |
| |
| }; |
| MODULE_DEVICE_TABLE(of, msmsdcc_dt_match); |
| |
| static struct platform_driver msmsdcc_driver = { |
| .probe = msmsdcc_probe, |
| .remove = msmsdcc_remove, |
| .driver = { |
| .name = "msm_sdcc", |
| .pm = &msmsdcc_dev_pm_ops, |
| .of_match_table = msmsdcc_dt_match, |
| }, |
| }; |
| |
| static int __init msmsdcc_init(void) |
| { |
| #if defined(CONFIG_DEBUG_FS) |
| int ret = 0; |
| ret = msmsdcc_dbg_init(); |
| if (ret) { |
| pr_err("Failed to create debug fs dir \n"); |
| return ret; |
| } |
| #endif |
| return platform_driver_register(&msmsdcc_driver); |
| } |
| |
| static void __exit msmsdcc_exit(void) |
| { |
| platform_driver_unregister(&msmsdcc_driver); |
| |
| #if defined(CONFIG_DEBUG_FS) |
| debugfs_remove(debugfs_dir); |
| #endif |
| } |
| |
| module_init(msmsdcc_init); |
| module_exit(msmsdcc_exit); |
| |
| MODULE_DESCRIPTION("Qualcomm Multimedia Card Interface driver"); |
| MODULE_LICENSE("GPL"); |
| |
| #if defined(CONFIG_DEBUG_FS) |
| static int msmsdcc_dbg_idle_tout_get(void *data, u64 *val) |
| { |
| struct msmsdcc_host *host = data; |
| |
| *val = host->idle_tout / 1000L; |
| return 0; |
| } |
| |
| static int msmsdcc_dbg_idle_tout_set(void *data, u64 val) |
| { |
| struct msmsdcc_host *host = data; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&host->lock, flags); |
| host->idle_tout = (u32)val * 1000; |
| spin_unlock_irqrestore(&host->lock, flags); |
| |
| return 0; |
| } |
| |
| DEFINE_SIMPLE_ATTRIBUTE(msmsdcc_dbg_idle_tout_ops, |
| msmsdcc_dbg_idle_tout_get, |
| msmsdcc_dbg_idle_tout_set, |
| "%llu\n"); |
| |
| static int msmsdcc_dbg_pio_mode_get(void *data, u64 *val) |
| { |
| struct msmsdcc_host *host = data; |
| |
| *val = (u64) host->enforce_pio_mode; |
| return 0; |
| } |
| |
| static int msmsdcc_dbg_pio_mode_set(void *data, u64 val) |
| { |
| struct msmsdcc_host *host = data; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&host->lock, flags); |
| host->enforce_pio_mode = !!val; |
| spin_unlock_irqrestore(&host->lock, flags); |
| |
| return 0; |
| } |
| |
| DEFINE_SIMPLE_ATTRIBUTE(msmsdcc_dbg_pio_mode_ops, |
| msmsdcc_dbg_pio_mode_get, |
| msmsdcc_dbg_pio_mode_set, |
| "%llu\n"); |
| |
| static int msmsdcc_dbg_pm_stats_get(void *data, u64 *val) |
| { |
| struct msmsdcc_host *host = data; |
| |
| *val = !!host->print_pm_stats; |
| return 0; |
| } |
| |
| static int msmsdcc_dbg_pm_stats_set(void *data, u64 val) |
| { |
| struct msmsdcc_host *host = data; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&host->lock, flags); |
| host->print_pm_stats = !!val; |
| spin_unlock_irqrestore(&host->lock, flags); |
| |
| return 0; |
| } |
| |
| DEFINE_SIMPLE_ATTRIBUTE(msmsdcc_dbg_pm_stats_ops, |
| msmsdcc_dbg_pm_stats_get, |
| msmsdcc_dbg_pm_stats_set, |
| "%llu\n"); |
| |
| static void msmsdcc_dbg_createhost(struct msmsdcc_host *host) |
| { |
| int err = 0; |
| |
| if (!debugfs_dir) |
| return; |
| |
| host->debugfs_host_dir = debugfs_create_dir( |
| mmc_hostname(host->mmc), debugfs_dir); |
| if (IS_ERR(host->debugfs_host_dir)) { |
| err = PTR_ERR(host->debugfs_host_dir); |
| host->debugfs_host_dir = NULL; |
| pr_err("%s: Failed to create debugfs dir for host with err=%d\n", |
| mmc_hostname(host->mmc), err); |
| return; |
| } |
| |
| host->debugfs_idle_tout = debugfs_create_file("idle_tout", |
| S_IRUSR | S_IWUSR, host->debugfs_host_dir, host, |
| &msmsdcc_dbg_idle_tout_ops); |
| |
| if (IS_ERR(host->debugfs_idle_tout)) { |
| err = PTR_ERR(host->debugfs_idle_tout); |
| host->debugfs_idle_tout = NULL; |
| pr_err("%s: Failed to create idle_tout debugfs entry with err=%d\n", |
| mmc_hostname(host->mmc), err); |
| } |
| |
| host->debugfs_pio_mode = debugfs_create_file("pio_mode", |
| S_IRUSR | S_IWUSR, host->debugfs_host_dir, host, |
| &msmsdcc_dbg_pio_mode_ops); |
| |
| if (IS_ERR(host->debugfs_pio_mode)) { |
| err = PTR_ERR(host->debugfs_pio_mode); |
| host->debugfs_pio_mode = NULL; |
| pr_err("%s: Failed to create pio_mode debugfs entry with err=%d\n", |
| mmc_hostname(host->mmc), err); |
| } |
| |
| host->debugfs_pm_stats = debugfs_create_file("pm_stats", |
| S_IRUSR | S_IWUSR, host->debugfs_host_dir, host, |
| &msmsdcc_dbg_pm_stats_ops); |
| if (IS_ERR(host->debugfs_pm_stats)) { |
| err = PTR_ERR(host->debugfs_pm_stats); |
| host->debugfs_pm_stats = NULL; |
| pr_err("%s: Failed to create pm_stats debugfs entry with err=%d\n", |
| mmc_hostname(host->mmc), err); |
| } |
| } |
| |
| static int __init msmsdcc_dbg_init(void) |
| { |
| int err; |
| |
| debugfs_dir = debugfs_create_dir("msm_sdcc", 0); |
| if (IS_ERR(debugfs_dir)) { |
| err = PTR_ERR(debugfs_dir); |
| debugfs_dir = NULL; |
| return err; |
| } |
| |
| return 0; |
| } |
| #endif |