forked from Minki/linux
baffab28b1
The clk patches added code to get and enable clocks in the respective driver probe functions. If the probe function failed for some reason after enabling the clock, the clock was not disabled again in many cases. Signed-off-by: Simon Baatz <gmbnomis@gmail.com> Signed-off-by: Andrew Lumm <andrew@lunn.ch>
940 lines
25 KiB
C
940 lines
25 KiB
C
/*
|
|
* Marvell MMC/SD/SDIO driver
|
|
*
|
|
* Authors: Maen Suleiman, Nicolas Pitre
|
|
* Copyright (C) 2008-2009 Marvell Ltd.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
#include <linux/io.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/mbus.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/dma-mapping.h>
|
|
#include <linux/scatterlist.h>
|
|
#include <linux/irq.h>
|
|
#include <linux/clk.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/mmc/host.h>
|
|
|
|
#include <asm/sizes.h>
|
|
#include <asm/unaligned.h>
|
|
#include <plat/mvsdio.h>
|
|
|
|
#include "mvsdio.h"
|
|
|
|
#define DRIVER_NAME "mvsdio"
|
|
|
|
static int maxfreq = MVSD_CLOCKRATE_MAX;
|
|
static int nodma;
|
|
|
|
struct mvsd_host {
|
|
void __iomem *base;
|
|
struct mmc_request *mrq;
|
|
spinlock_t lock;
|
|
unsigned int xfer_mode;
|
|
unsigned int intr_en;
|
|
unsigned int ctrl;
|
|
unsigned int pio_size;
|
|
void *pio_ptr;
|
|
unsigned int sg_frags;
|
|
unsigned int ns_per_clk;
|
|
unsigned int clock;
|
|
unsigned int base_clock;
|
|
struct timer_list timer;
|
|
struct mmc_host *mmc;
|
|
struct device *dev;
|
|
struct resource *res;
|
|
int irq;
|
|
struct clk *clk;
|
|
int gpio_card_detect;
|
|
int gpio_write_protect;
|
|
};
|
|
|
|
#define mvsd_write(offs, val) writel(val, iobase + (offs))
|
|
#define mvsd_read(offs) readl(iobase + (offs))
|
|
|
|
static int mvsd_setup_data(struct mvsd_host *host, struct mmc_data *data)
|
|
{
|
|
void __iomem *iobase = host->base;
|
|
unsigned int tmout;
|
|
int tmout_index;
|
|
|
|
/*
|
|
* Hardware weirdness. The FIFO_EMPTY bit of the HW_STATE
|
|
* register is sometimes not set before a while when some
|
|
* "unusual" data block sizes are used (such as with the SWITCH
|
|
* command), even despite the fact that the XFER_DONE interrupt
|
|
* was raised. And if another data transfer starts before
|
|
* this bit comes to good sense (which eventually happens by
|
|
* itself) then the new transfer simply fails with a timeout.
|
|
*/
|
|
if (!(mvsd_read(MVSD_HW_STATE) & (1 << 13))) {
|
|
unsigned long t = jiffies + HZ;
|
|
unsigned int hw_state, count = 0;
|
|
do {
|
|
if (time_after(jiffies, t)) {
|
|
dev_warn(host->dev, "FIFO_EMPTY bit missing\n");
|
|
break;
|
|
}
|
|
hw_state = mvsd_read(MVSD_HW_STATE);
|
|
count++;
|
|
} while (!(hw_state & (1 << 13)));
|
|
dev_dbg(host->dev, "*** wait for FIFO_EMPTY bit "
|
|
"(hw=0x%04x, count=%d, jiffies=%ld)\n",
|
|
hw_state, count, jiffies - (t - HZ));
|
|
}
|
|
|
|
/* If timeout=0 then maximum timeout index is used. */
|
|
tmout = DIV_ROUND_UP(data->timeout_ns, host->ns_per_clk);
|
|
tmout += data->timeout_clks;
|
|
tmout_index = fls(tmout - 1) - 12;
|
|
if (tmout_index < 0)
|
|
tmout_index = 0;
|
|
if (tmout_index > MVSD_HOST_CTRL_TMOUT_MAX)
|
|
tmout_index = MVSD_HOST_CTRL_TMOUT_MAX;
|
|
|
|
dev_dbg(host->dev, "data %s at 0x%08x: blocks=%d blksz=%d tmout=%u (%d)\n",
|
|
(data->flags & MMC_DATA_READ) ? "read" : "write",
|
|
(u32)sg_virt(data->sg), data->blocks, data->blksz,
|
|
tmout, tmout_index);
|
|
|
|
host->ctrl &= ~MVSD_HOST_CTRL_TMOUT_MASK;
|
|
host->ctrl |= MVSD_HOST_CTRL_TMOUT(tmout_index);
|
|
mvsd_write(MVSD_HOST_CTRL, host->ctrl);
|
|
mvsd_write(MVSD_BLK_COUNT, data->blocks);
|
|
mvsd_write(MVSD_BLK_SIZE, data->blksz);
|
|
|
|
if (nodma || (data->blksz | data->sg->offset) & 3) {
|
|
/*
|
|
* We cannot do DMA on a buffer which offset or size
|
|
* is not aligned on a 4-byte boundary.
|
|
*/
|
|
host->pio_size = data->blocks * data->blksz;
|
|
host->pio_ptr = sg_virt(data->sg);
|
|
if (!nodma)
|
|
pr_debug("%s: fallback to PIO for data "
|
|
"at 0x%p size %d\n",
|
|
mmc_hostname(host->mmc),
|
|
host->pio_ptr, host->pio_size);
|
|
return 1;
|
|
} else {
|
|
dma_addr_t phys_addr;
|
|
int dma_dir = (data->flags & MMC_DATA_READ) ?
|
|
DMA_FROM_DEVICE : DMA_TO_DEVICE;
|
|
host->sg_frags = dma_map_sg(mmc_dev(host->mmc), data->sg,
|
|
data->sg_len, dma_dir);
|
|
phys_addr = sg_dma_address(data->sg);
|
|
mvsd_write(MVSD_SYS_ADDR_LOW, (u32)phys_addr & 0xffff);
|
|
mvsd_write(MVSD_SYS_ADDR_HI, (u32)phys_addr >> 16);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static void mvsd_request(struct mmc_host *mmc, struct mmc_request *mrq)
|
|
{
|
|
struct mvsd_host *host = mmc_priv(mmc);
|
|
void __iomem *iobase = host->base;
|
|
struct mmc_command *cmd = mrq->cmd;
|
|
u32 cmdreg = 0, xfer = 0, intr = 0;
|
|
unsigned long flags;
|
|
|
|
BUG_ON(host->mrq != NULL);
|
|
host->mrq = mrq;
|
|
|
|
dev_dbg(host->dev, "cmd %d (hw state 0x%04x)\n",
|
|
cmd->opcode, mvsd_read(MVSD_HW_STATE));
|
|
|
|
cmdreg = MVSD_CMD_INDEX(cmd->opcode);
|
|
|
|
if (cmd->flags & MMC_RSP_BUSY)
|
|
cmdreg |= MVSD_CMD_RSP_48BUSY;
|
|
else if (cmd->flags & MMC_RSP_136)
|
|
cmdreg |= MVSD_CMD_RSP_136;
|
|
else if (cmd->flags & MMC_RSP_PRESENT)
|
|
cmdreg |= MVSD_CMD_RSP_48;
|
|
else
|
|
cmdreg |= MVSD_CMD_RSP_NONE;
|
|
|
|
if (cmd->flags & MMC_RSP_CRC)
|
|
cmdreg |= MVSD_CMD_CHECK_CMDCRC;
|
|
|
|
if (cmd->flags & MMC_RSP_OPCODE)
|
|
cmdreg |= MVSD_CMD_INDX_CHECK;
|
|
|
|
if (cmd->flags & MMC_RSP_PRESENT) {
|
|
cmdreg |= MVSD_UNEXPECTED_RESP;
|
|
intr |= MVSD_NOR_UNEXP_RSP;
|
|
}
|
|
|
|
if (mrq->data) {
|
|
struct mmc_data *data = mrq->data;
|
|
int pio;
|
|
|
|
cmdreg |= MVSD_CMD_DATA_PRESENT | MVSD_CMD_CHECK_DATACRC16;
|
|
xfer |= MVSD_XFER_MODE_HW_WR_DATA_EN;
|
|
if (data->flags & MMC_DATA_READ)
|
|
xfer |= MVSD_XFER_MODE_TO_HOST;
|
|
|
|
pio = mvsd_setup_data(host, data);
|
|
if (pio) {
|
|
xfer |= MVSD_XFER_MODE_PIO;
|
|
/* PIO section of mvsd_irq has comments on those bits */
|
|
if (data->flags & MMC_DATA_WRITE)
|
|
intr |= MVSD_NOR_TX_AVAIL;
|
|
else if (host->pio_size > 32)
|
|
intr |= MVSD_NOR_RX_FIFO_8W;
|
|
else
|
|
intr |= MVSD_NOR_RX_READY;
|
|
}
|
|
|
|
if (data->stop) {
|
|
struct mmc_command *stop = data->stop;
|
|
u32 cmd12reg = 0;
|
|
|
|
mvsd_write(MVSD_AUTOCMD12_ARG_LOW, stop->arg & 0xffff);
|
|
mvsd_write(MVSD_AUTOCMD12_ARG_HI, stop->arg >> 16);
|
|
|
|
if (stop->flags & MMC_RSP_BUSY)
|
|
cmd12reg |= MVSD_AUTOCMD12_BUSY;
|
|
if (stop->flags & MMC_RSP_OPCODE)
|
|
cmd12reg |= MVSD_AUTOCMD12_INDX_CHECK;
|
|
cmd12reg |= MVSD_AUTOCMD12_INDEX(stop->opcode);
|
|
mvsd_write(MVSD_AUTOCMD12_CMD, cmd12reg);
|
|
|
|
xfer |= MVSD_XFER_MODE_AUTO_CMD12;
|
|
intr |= MVSD_NOR_AUTOCMD12_DONE;
|
|
} else {
|
|
intr |= MVSD_NOR_XFER_DONE;
|
|
}
|
|
} else {
|
|
intr |= MVSD_NOR_CMD_DONE;
|
|
}
|
|
|
|
mvsd_write(MVSD_ARG_LOW, cmd->arg & 0xffff);
|
|
mvsd_write(MVSD_ARG_HI, cmd->arg >> 16);
|
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
|
|
|
host->xfer_mode &= MVSD_XFER_MODE_INT_CHK_EN;
|
|
host->xfer_mode |= xfer;
|
|
mvsd_write(MVSD_XFER_MODE, host->xfer_mode);
|
|
|
|
mvsd_write(MVSD_NOR_INTR_STATUS, ~MVSD_NOR_CARD_INT);
|
|
mvsd_write(MVSD_ERR_INTR_STATUS, 0xffff);
|
|
mvsd_write(MVSD_CMD, cmdreg);
|
|
|
|
host->intr_en &= MVSD_NOR_CARD_INT;
|
|
host->intr_en |= intr | MVSD_NOR_ERROR;
|
|
mvsd_write(MVSD_NOR_INTR_EN, host->intr_en);
|
|
mvsd_write(MVSD_ERR_INTR_EN, 0xffff);
|
|
|
|
mod_timer(&host->timer, jiffies + 5 * HZ);
|
|
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
|
}
|
|
|
|
static u32 mvsd_finish_cmd(struct mvsd_host *host, struct mmc_command *cmd,
|
|
u32 err_status)
|
|
{
|
|
void __iomem *iobase = host->base;
|
|
|
|
if (cmd->flags & MMC_RSP_136) {
|
|
unsigned int response[8], i;
|
|
for (i = 0; i < 8; i++)
|
|
response[i] = mvsd_read(MVSD_RSP(i));
|
|
cmd->resp[0] = ((response[0] & 0x03ff) << 22) |
|
|
((response[1] & 0xffff) << 6) |
|
|
((response[2] & 0xfc00) >> 10);
|
|
cmd->resp[1] = ((response[2] & 0x03ff) << 22) |
|
|
((response[3] & 0xffff) << 6) |
|
|
((response[4] & 0xfc00) >> 10);
|
|
cmd->resp[2] = ((response[4] & 0x03ff) << 22) |
|
|
((response[5] & 0xffff) << 6) |
|
|
((response[6] & 0xfc00) >> 10);
|
|
cmd->resp[3] = ((response[6] & 0x03ff) << 22) |
|
|
((response[7] & 0x3fff) << 8);
|
|
} else if (cmd->flags & MMC_RSP_PRESENT) {
|
|
unsigned int response[3], i;
|
|
for (i = 0; i < 3; i++)
|
|
response[i] = mvsd_read(MVSD_RSP(i));
|
|
cmd->resp[0] = ((response[2] & 0x003f) << (8 - 8)) |
|
|
((response[1] & 0xffff) << (14 - 8)) |
|
|
((response[0] & 0x03ff) << (30 - 8));
|
|
cmd->resp[1] = ((response[0] & 0xfc00) >> 10);
|
|
cmd->resp[2] = 0;
|
|
cmd->resp[3] = 0;
|
|
}
|
|
|
|
if (err_status & MVSD_ERR_CMD_TIMEOUT) {
|
|
cmd->error = -ETIMEDOUT;
|
|
} else if (err_status & (MVSD_ERR_CMD_CRC | MVSD_ERR_CMD_ENDBIT |
|
|
MVSD_ERR_CMD_INDEX | MVSD_ERR_CMD_STARTBIT)) {
|
|
cmd->error = -EILSEQ;
|
|
}
|
|
err_status &= ~(MVSD_ERR_CMD_TIMEOUT | MVSD_ERR_CMD_CRC |
|
|
MVSD_ERR_CMD_ENDBIT | MVSD_ERR_CMD_INDEX |
|
|
MVSD_ERR_CMD_STARTBIT);
|
|
|
|
return err_status;
|
|
}
|
|
|
|
static u32 mvsd_finish_data(struct mvsd_host *host, struct mmc_data *data,
|
|
u32 err_status)
|
|
{
|
|
void __iomem *iobase = host->base;
|
|
|
|
if (host->pio_ptr) {
|
|
host->pio_ptr = NULL;
|
|
host->pio_size = 0;
|
|
} else {
|
|
dma_unmap_sg(mmc_dev(host->mmc), data->sg, host->sg_frags,
|
|
(data->flags & MMC_DATA_READ) ?
|
|
DMA_FROM_DEVICE : DMA_TO_DEVICE);
|
|
}
|
|
|
|
if (err_status & MVSD_ERR_DATA_TIMEOUT)
|
|
data->error = -ETIMEDOUT;
|
|
else if (err_status & (MVSD_ERR_DATA_CRC | MVSD_ERR_DATA_ENDBIT))
|
|
data->error = -EILSEQ;
|
|
else if (err_status & MVSD_ERR_XFER_SIZE)
|
|
data->error = -EBADE;
|
|
err_status &= ~(MVSD_ERR_DATA_TIMEOUT | MVSD_ERR_DATA_CRC |
|
|
MVSD_ERR_DATA_ENDBIT | MVSD_ERR_XFER_SIZE);
|
|
|
|
dev_dbg(host->dev, "data done: blocks_left=%d, bytes_left=%d\n",
|
|
mvsd_read(MVSD_CURR_BLK_LEFT), mvsd_read(MVSD_CURR_BYTE_LEFT));
|
|
data->bytes_xfered =
|
|
(data->blocks - mvsd_read(MVSD_CURR_BLK_LEFT)) * data->blksz;
|
|
/* We can't be sure about the last block when errors are detected */
|
|
if (data->bytes_xfered && data->error)
|
|
data->bytes_xfered -= data->blksz;
|
|
|
|
/* Handle Auto cmd 12 response */
|
|
if (data->stop) {
|
|
unsigned int response[3], i;
|
|
for (i = 0; i < 3; i++)
|
|
response[i] = mvsd_read(MVSD_AUTO_RSP(i));
|
|
data->stop->resp[0] = ((response[2] & 0x003f) << (8 - 8)) |
|
|
((response[1] & 0xffff) << (14 - 8)) |
|
|
((response[0] & 0x03ff) << (30 - 8));
|
|
data->stop->resp[1] = ((response[0] & 0xfc00) >> 10);
|
|
data->stop->resp[2] = 0;
|
|
data->stop->resp[3] = 0;
|
|
|
|
if (err_status & MVSD_ERR_AUTOCMD12) {
|
|
u32 err_cmd12 = mvsd_read(MVSD_AUTOCMD12_ERR_STATUS);
|
|
dev_dbg(host->dev, "c12err 0x%04x\n", err_cmd12);
|
|
if (err_cmd12 & MVSD_AUTOCMD12_ERR_NOTEXE)
|
|
data->stop->error = -ENOEXEC;
|
|
else if (err_cmd12 & MVSD_AUTOCMD12_ERR_TIMEOUT)
|
|
data->stop->error = -ETIMEDOUT;
|
|
else if (err_cmd12)
|
|
data->stop->error = -EILSEQ;
|
|
err_status &= ~MVSD_ERR_AUTOCMD12;
|
|
}
|
|
}
|
|
|
|
return err_status;
|
|
}
|
|
|
|
static irqreturn_t mvsd_irq(int irq, void *dev)
|
|
{
|
|
struct mvsd_host *host = dev;
|
|
void __iomem *iobase = host->base;
|
|
u32 intr_status, intr_done_mask;
|
|
int irq_handled = 0;
|
|
|
|
intr_status = mvsd_read(MVSD_NOR_INTR_STATUS);
|
|
dev_dbg(host->dev, "intr 0x%04x intr_en 0x%04x hw_state 0x%04x\n",
|
|
intr_status, mvsd_read(MVSD_NOR_INTR_EN),
|
|
mvsd_read(MVSD_HW_STATE));
|
|
|
|
spin_lock(&host->lock);
|
|
|
|
/* PIO handling, if needed. Messy business... */
|
|
if (host->pio_size &&
|
|
(intr_status & host->intr_en &
|
|
(MVSD_NOR_RX_READY | MVSD_NOR_RX_FIFO_8W))) {
|
|
u16 *p = host->pio_ptr;
|
|
int s = host->pio_size;
|
|
while (s >= 32 && (intr_status & MVSD_NOR_RX_FIFO_8W)) {
|
|
readsw(iobase + MVSD_FIFO, p, 16);
|
|
p += 16;
|
|
s -= 32;
|
|
intr_status = mvsd_read(MVSD_NOR_INTR_STATUS);
|
|
}
|
|
/*
|
|
* Normally we'd use < 32 here, but the RX_FIFO_8W bit
|
|
* doesn't appear to assert when there is exactly 32 bytes
|
|
* (8 words) left to fetch in a transfer.
|
|
*/
|
|
if (s <= 32) {
|
|
while (s >= 4 && (intr_status & MVSD_NOR_RX_READY)) {
|
|
put_unaligned(mvsd_read(MVSD_FIFO), p++);
|
|
put_unaligned(mvsd_read(MVSD_FIFO), p++);
|
|
s -= 4;
|
|
intr_status = mvsd_read(MVSD_NOR_INTR_STATUS);
|
|
}
|
|
if (s && s < 4 && (intr_status & MVSD_NOR_RX_READY)) {
|
|
u16 val[2] = {0, 0};
|
|
val[0] = mvsd_read(MVSD_FIFO);
|
|
val[1] = mvsd_read(MVSD_FIFO);
|
|
memcpy(p, ((void *)&val) + 4 - s, s);
|
|
s = 0;
|
|
intr_status = mvsd_read(MVSD_NOR_INTR_STATUS);
|
|
}
|
|
if (s == 0) {
|
|
host->intr_en &=
|
|
~(MVSD_NOR_RX_READY | MVSD_NOR_RX_FIFO_8W);
|
|
mvsd_write(MVSD_NOR_INTR_EN, host->intr_en);
|
|
} else if (host->intr_en & MVSD_NOR_RX_FIFO_8W) {
|
|
host->intr_en &= ~MVSD_NOR_RX_FIFO_8W;
|
|
host->intr_en |= MVSD_NOR_RX_READY;
|
|
mvsd_write(MVSD_NOR_INTR_EN, host->intr_en);
|
|
}
|
|
}
|
|
dev_dbg(host->dev, "pio %d intr 0x%04x hw_state 0x%04x\n",
|
|
s, intr_status, mvsd_read(MVSD_HW_STATE));
|
|
host->pio_ptr = p;
|
|
host->pio_size = s;
|
|
irq_handled = 1;
|
|
} else if (host->pio_size &&
|
|
(intr_status & host->intr_en &
|
|
(MVSD_NOR_TX_AVAIL | MVSD_NOR_TX_FIFO_8W))) {
|
|
u16 *p = host->pio_ptr;
|
|
int s = host->pio_size;
|
|
/*
|
|
* The TX_FIFO_8W bit is unreliable. When set, bursting
|
|
* 16 halfwords all at once in the FIFO drops data. Actually
|
|
* TX_AVAIL does go off after only one word is pushed even if
|
|
* TX_FIFO_8W remains set.
|
|
*/
|
|
while (s >= 4 && (intr_status & MVSD_NOR_TX_AVAIL)) {
|
|
mvsd_write(MVSD_FIFO, get_unaligned(p++));
|
|
mvsd_write(MVSD_FIFO, get_unaligned(p++));
|
|
s -= 4;
|
|
intr_status = mvsd_read(MVSD_NOR_INTR_STATUS);
|
|
}
|
|
if (s < 4) {
|
|
if (s && (intr_status & MVSD_NOR_TX_AVAIL)) {
|
|
u16 val[2] = {0, 0};
|
|
memcpy(((void *)&val) + 4 - s, p, s);
|
|
mvsd_write(MVSD_FIFO, val[0]);
|
|
mvsd_write(MVSD_FIFO, val[1]);
|
|
s = 0;
|
|
intr_status = mvsd_read(MVSD_NOR_INTR_STATUS);
|
|
}
|
|
if (s == 0) {
|
|
host->intr_en &=
|
|
~(MVSD_NOR_TX_AVAIL | MVSD_NOR_TX_FIFO_8W);
|
|
mvsd_write(MVSD_NOR_INTR_EN, host->intr_en);
|
|
}
|
|
}
|
|
dev_dbg(host->dev, "pio %d intr 0x%04x hw_state 0x%04x\n",
|
|
s, intr_status, mvsd_read(MVSD_HW_STATE));
|
|
host->pio_ptr = p;
|
|
host->pio_size = s;
|
|
irq_handled = 1;
|
|
}
|
|
|
|
mvsd_write(MVSD_NOR_INTR_STATUS, intr_status);
|
|
|
|
intr_done_mask = MVSD_NOR_CARD_INT | MVSD_NOR_RX_READY |
|
|
MVSD_NOR_RX_FIFO_8W | MVSD_NOR_TX_FIFO_8W;
|
|
if (intr_status & host->intr_en & ~intr_done_mask) {
|
|
struct mmc_request *mrq = host->mrq;
|
|
struct mmc_command *cmd = mrq->cmd;
|
|
u32 err_status = 0;
|
|
|
|
del_timer(&host->timer);
|
|
host->mrq = NULL;
|
|
|
|
host->intr_en &= MVSD_NOR_CARD_INT;
|
|
mvsd_write(MVSD_NOR_INTR_EN, host->intr_en);
|
|
mvsd_write(MVSD_ERR_INTR_EN, 0);
|
|
|
|
spin_unlock(&host->lock);
|
|
|
|
if (intr_status & MVSD_NOR_UNEXP_RSP) {
|
|
cmd->error = -EPROTO;
|
|
} else if (intr_status & MVSD_NOR_ERROR) {
|
|
err_status = mvsd_read(MVSD_ERR_INTR_STATUS);
|
|
dev_dbg(host->dev, "err 0x%04x\n", err_status);
|
|
}
|
|
|
|
err_status = mvsd_finish_cmd(host, cmd, err_status);
|
|
if (mrq->data)
|
|
err_status = mvsd_finish_data(host, mrq->data, err_status);
|
|
if (err_status) {
|
|
pr_err("%s: unhandled error status %#04x\n",
|
|
mmc_hostname(host->mmc), err_status);
|
|
cmd->error = -ENOMSG;
|
|
}
|
|
|
|
mmc_request_done(host->mmc, mrq);
|
|
irq_handled = 1;
|
|
} else
|
|
spin_unlock(&host->lock);
|
|
|
|
if (intr_status & MVSD_NOR_CARD_INT) {
|
|
mmc_signal_sdio_irq(host->mmc);
|
|
irq_handled = 1;
|
|
}
|
|
|
|
if (irq_handled)
|
|
return IRQ_HANDLED;
|
|
|
|
pr_err("%s: unhandled interrupt status=0x%04x en=0x%04x "
|
|
"pio=%d\n", mmc_hostname(host->mmc), intr_status,
|
|
host->intr_en, host->pio_size);
|
|
return IRQ_NONE;
|
|
}
|
|
|
|
static void mvsd_timeout_timer(unsigned long data)
|
|
{
|
|
struct mvsd_host *host = (struct mvsd_host *)data;
|
|
void __iomem *iobase = host->base;
|
|
struct mmc_request *mrq;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
|
mrq = host->mrq;
|
|
if (mrq) {
|
|
pr_err("%s: Timeout waiting for hardware interrupt.\n",
|
|
mmc_hostname(host->mmc));
|
|
pr_err("%s: hw_state=0x%04x, intr_status=0x%04x "
|
|
"intr_en=0x%04x\n", mmc_hostname(host->mmc),
|
|
mvsd_read(MVSD_HW_STATE),
|
|
mvsd_read(MVSD_NOR_INTR_STATUS),
|
|
mvsd_read(MVSD_NOR_INTR_EN));
|
|
|
|
host->mrq = NULL;
|
|
|
|
mvsd_write(MVSD_SW_RESET, MVSD_SW_RESET_NOW);
|
|
|
|
host->xfer_mode &= MVSD_XFER_MODE_INT_CHK_EN;
|
|
mvsd_write(MVSD_XFER_MODE, host->xfer_mode);
|
|
|
|
host->intr_en &= MVSD_NOR_CARD_INT;
|
|
mvsd_write(MVSD_NOR_INTR_EN, host->intr_en);
|
|
mvsd_write(MVSD_ERR_INTR_EN, 0);
|
|
mvsd_write(MVSD_ERR_INTR_STATUS, 0xffff);
|
|
|
|
mrq->cmd->error = -ETIMEDOUT;
|
|
mvsd_finish_cmd(host, mrq->cmd, 0);
|
|
if (mrq->data) {
|
|
mrq->data->error = -ETIMEDOUT;
|
|
mvsd_finish_data(host, mrq->data, 0);
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
|
|
|
if (mrq)
|
|
mmc_request_done(host->mmc, mrq);
|
|
}
|
|
|
|
static irqreturn_t mvsd_card_detect_irq(int irq, void *dev)
|
|
{
|
|
struct mvsd_host *host = dev;
|
|
mmc_detect_change(host->mmc, msecs_to_jiffies(100));
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static void mvsd_enable_sdio_irq(struct mmc_host *mmc, int enable)
|
|
{
|
|
struct mvsd_host *host = mmc_priv(mmc);
|
|
void __iomem *iobase = host->base;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
|
if (enable) {
|
|
host->xfer_mode |= MVSD_XFER_MODE_INT_CHK_EN;
|
|
host->intr_en |= MVSD_NOR_CARD_INT;
|
|
} else {
|
|
host->xfer_mode &= ~MVSD_XFER_MODE_INT_CHK_EN;
|
|
host->intr_en &= ~MVSD_NOR_CARD_INT;
|
|
}
|
|
mvsd_write(MVSD_XFER_MODE, host->xfer_mode);
|
|
mvsd_write(MVSD_NOR_INTR_EN, host->intr_en);
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
|
}
|
|
|
|
static int mvsd_get_ro(struct mmc_host *mmc)
|
|
{
|
|
struct mvsd_host *host = mmc_priv(mmc);
|
|
|
|
if (host->gpio_write_protect)
|
|
return gpio_get_value(host->gpio_write_protect);
|
|
|
|
/*
|
|
* Board doesn't support read only detection; let the mmc core
|
|
* decide what to do.
|
|
*/
|
|
return -ENOSYS;
|
|
}
|
|
|
|
static void mvsd_power_up(struct mvsd_host *host)
|
|
{
|
|
void __iomem *iobase = host->base;
|
|
dev_dbg(host->dev, "power up\n");
|
|
mvsd_write(MVSD_NOR_INTR_EN, 0);
|
|
mvsd_write(MVSD_ERR_INTR_EN, 0);
|
|
mvsd_write(MVSD_SW_RESET, MVSD_SW_RESET_NOW);
|
|
mvsd_write(MVSD_XFER_MODE, 0);
|
|
mvsd_write(MVSD_NOR_STATUS_EN, 0xffff);
|
|
mvsd_write(MVSD_ERR_STATUS_EN, 0xffff);
|
|
mvsd_write(MVSD_NOR_INTR_STATUS, 0xffff);
|
|
mvsd_write(MVSD_ERR_INTR_STATUS, 0xffff);
|
|
}
|
|
|
|
static void mvsd_power_down(struct mvsd_host *host)
|
|
{
|
|
void __iomem *iobase = host->base;
|
|
dev_dbg(host->dev, "power down\n");
|
|
mvsd_write(MVSD_NOR_INTR_EN, 0);
|
|
mvsd_write(MVSD_ERR_INTR_EN, 0);
|
|
mvsd_write(MVSD_SW_RESET, MVSD_SW_RESET_NOW);
|
|
mvsd_write(MVSD_XFER_MODE, MVSD_XFER_MODE_STOP_CLK);
|
|
mvsd_write(MVSD_NOR_STATUS_EN, 0);
|
|
mvsd_write(MVSD_ERR_STATUS_EN, 0);
|
|
mvsd_write(MVSD_NOR_INTR_STATUS, 0xffff);
|
|
mvsd_write(MVSD_ERR_INTR_STATUS, 0xffff);
|
|
}
|
|
|
|
static void mvsd_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
|
|
{
|
|
struct mvsd_host *host = mmc_priv(mmc);
|
|
void __iomem *iobase = host->base;
|
|
u32 ctrl_reg = 0;
|
|
|
|
if (ios->power_mode == MMC_POWER_UP)
|
|
mvsd_power_up(host);
|
|
|
|
if (ios->clock == 0) {
|
|
mvsd_write(MVSD_XFER_MODE, MVSD_XFER_MODE_STOP_CLK);
|
|
mvsd_write(MVSD_CLK_DIV, MVSD_BASE_DIV_MAX);
|
|
host->clock = 0;
|
|
dev_dbg(host->dev, "clock off\n");
|
|
} else if (ios->clock != host->clock) {
|
|
u32 m = DIV_ROUND_UP(host->base_clock, ios->clock) - 1;
|
|
if (m > MVSD_BASE_DIV_MAX)
|
|
m = MVSD_BASE_DIV_MAX;
|
|
mvsd_write(MVSD_CLK_DIV, m);
|
|
host->clock = ios->clock;
|
|
host->ns_per_clk = 1000000000 / (host->base_clock / (m+1));
|
|
dev_dbg(host->dev, "clock=%d (%d), div=0x%04x\n",
|
|
ios->clock, host->base_clock / (m+1), m);
|
|
}
|
|
|
|
/* default transfer mode */
|
|
ctrl_reg |= MVSD_HOST_CTRL_BIG_ENDIAN;
|
|
ctrl_reg &= ~MVSD_HOST_CTRL_LSB_FIRST;
|
|
|
|
/* default to maximum timeout */
|
|
ctrl_reg |= MVSD_HOST_CTRL_TMOUT_MASK;
|
|
ctrl_reg |= MVSD_HOST_CTRL_TMOUT_EN;
|
|
|
|
if (ios->bus_mode == MMC_BUSMODE_PUSHPULL)
|
|
ctrl_reg |= MVSD_HOST_CTRL_PUSH_PULL_EN;
|
|
|
|
if (ios->bus_width == MMC_BUS_WIDTH_4)
|
|
ctrl_reg |= MVSD_HOST_CTRL_DATA_WIDTH_4_BITS;
|
|
|
|
/*
|
|
* The HI_SPEED_EN bit is causing trouble with many (but not all)
|
|
* high speed SD, SDHC and SDIO cards. Not enabling that bit
|
|
* makes all cards work. So let's just ignore that bit for now
|
|
* and revisit this issue if problems for not enabling this bit
|
|
* are ever reported.
|
|
*/
|
|
#if 0
|
|
if (ios->timing == MMC_TIMING_MMC_HS ||
|
|
ios->timing == MMC_TIMING_SD_HS)
|
|
ctrl_reg |= MVSD_HOST_CTRL_HI_SPEED_EN;
|
|
#endif
|
|
|
|
host->ctrl = ctrl_reg;
|
|
mvsd_write(MVSD_HOST_CTRL, ctrl_reg);
|
|
dev_dbg(host->dev, "ctrl 0x%04x: %s %s %s\n", ctrl_reg,
|
|
(ctrl_reg & MVSD_HOST_CTRL_PUSH_PULL_EN) ?
|
|
"push-pull" : "open-drain",
|
|
(ctrl_reg & MVSD_HOST_CTRL_DATA_WIDTH_4_BITS) ?
|
|
"4bit-width" : "1bit-width",
|
|
(ctrl_reg & MVSD_HOST_CTRL_HI_SPEED_EN) ?
|
|
"high-speed" : "");
|
|
|
|
if (ios->power_mode == MMC_POWER_OFF)
|
|
mvsd_power_down(host);
|
|
}
|
|
|
|
static const struct mmc_host_ops mvsd_ops = {
|
|
.request = mvsd_request,
|
|
.get_ro = mvsd_get_ro,
|
|
.set_ios = mvsd_set_ios,
|
|
.enable_sdio_irq = mvsd_enable_sdio_irq,
|
|
};
|
|
|
|
static void __init
|
|
mv_conf_mbus_windows(struct mvsd_host *host,
|
|
const struct mbus_dram_target_info *dram)
|
|
{
|
|
void __iomem *iobase = host->base;
|
|
int i;
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
writel(0, iobase + MVSD_WINDOW_CTRL(i));
|
|
writel(0, iobase + MVSD_WINDOW_BASE(i));
|
|
}
|
|
|
|
for (i = 0; i < dram->num_cs; i++) {
|
|
const struct mbus_dram_window *cs = dram->cs + i;
|
|
writel(((cs->size - 1) & 0xffff0000) |
|
|
(cs->mbus_attr << 8) |
|
|
(dram->mbus_dram_target_id << 4) | 1,
|
|
iobase + MVSD_WINDOW_CTRL(i));
|
|
writel(cs->base, iobase + MVSD_WINDOW_BASE(i));
|
|
}
|
|
}
|
|
|
|
static int __init mvsd_probe(struct platform_device *pdev)
|
|
{
|
|
struct mmc_host *mmc = NULL;
|
|
struct mvsd_host *host = NULL;
|
|
const struct mvsdio_platform_data *mvsd_data;
|
|
const struct mbus_dram_target_info *dram;
|
|
struct resource *r;
|
|
int ret, irq;
|
|
|
|
r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
irq = platform_get_irq(pdev, 0);
|
|
mvsd_data = pdev->dev.platform_data;
|
|
if (!r || irq < 0 || !mvsd_data)
|
|
return -ENXIO;
|
|
|
|
r = request_mem_region(r->start, SZ_1K, DRIVER_NAME);
|
|
if (!r)
|
|
return -EBUSY;
|
|
|
|
mmc = mmc_alloc_host(sizeof(struct mvsd_host), &pdev->dev);
|
|
if (!mmc) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
host = mmc_priv(mmc);
|
|
host->mmc = mmc;
|
|
host->dev = &pdev->dev;
|
|
host->res = r;
|
|
host->base_clock = mvsd_data->clock / 2;
|
|
|
|
mmc->ops = &mvsd_ops;
|
|
|
|
mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
|
|
mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ |
|
|
MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED;
|
|
|
|
mmc->f_min = DIV_ROUND_UP(host->base_clock, MVSD_BASE_DIV_MAX);
|
|
mmc->f_max = maxfreq;
|
|
|
|
mmc->max_blk_size = 2048;
|
|
mmc->max_blk_count = 65535;
|
|
|
|
mmc->max_segs = 1;
|
|
mmc->max_seg_size = mmc->max_blk_size * mmc->max_blk_count;
|
|
mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
|
|
|
|
spin_lock_init(&host->lock);
|
|
|
|
host->base = ioremap(r->start, SZ_4K);
|
|
if (!host->base) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
/* (Re-)program MBUS remapping windows if we are asked to. */
|
|
dram = mv_mbus_dram_info();
|
|
if (dram)
|
|
mv_conf_mbus_windows(host, dram);
|
|
|
|
mvsd_power_down(host);
|
|
|
|
ret = request_irq(irq, mvsd_irq, 0, DRIVER_NAME, host);
|
|
if (ret) {
|
|
pr_err("%s: cannot assign irq %d\n", DRIVER_NAME, irq);
|
|
goto out;
|
|
} else
|
|
host->irq = irq;
|
|
|
|
/* Not all platforms can gate the clock, so it is not
|
|
an error if the clock does not exists. */
|
|
host->clk = clk_get(&pdev->dev, NULL);
|
|
if (!IS_ERR(host->clk)) {
|
|
clk_prepare_enable(host->clk);
|
|
}
|
|
|
|
if (mvsd_data->gpio_card_detect) {
|
|
ret = gpio_request(mvsd_data->gpio_card_detect,
|
|
DRIVER_NAME " cd");
|
|
if (ret == 0) {
|
|
gpio_direction_input(mvsd_data->gpio_card_detect);
|
|
irq = gpio_to_irq(mvsd_data->gpio_card_detect);
|
|
ret = request_irq(irq, mvsd_card_detect_irq,
|
|
IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING,
|
|
DRIVER_NAME " cd", host);
|
|
if (ret == 0)
|
|
host->gpio_card_detect =
|
|
mvsd_data->gpio_card_detect;
|
|
else
|
|
gpio_free(mvsd_data->gpio_card_detect);
|
|
}
|
|
}
|
|
if (!host->gpio_card_detect)
|
|
mmc->caps |= MMC_CAP_NEEDS_POLL;
|
|
|
|
if (mvsd_data->gpio_write_protect) {
|
|
ret = gpio_request(mvsd_data->gpio_write_protect,
|
|
DRIVER_NAME " wp");
|
|
if (ret == 0) {
|
|
gpio_direction_input(mvsd_data->gpio_write_protect);
|
|
host->gpio_write_protect =
|
|
mvsd_data->gpio_write_protect;
|
|
}
|
|
}
|
|
|
|
setup_timer(&host->timer, mvsd_timeout_timer, (unsigned long)host);
|
|
platform_set_drvdata(pdev, mmc);
|
|
ret = mmc_add_host(mmc);
|
|
if (ret)
|
|
goto out;
|
|
|
|
pr_notice("%s: %s driver initialized, ",
|
|
mmc_hostname(mmc), DRIVER_NAME);
|
|
if (host->gpio_card_detect)
|
|
printk("using GPIO %d for card detection\n",
|
|
host->gpio_card_detect);
|
|
else
|
|
printk("lacking card detect (fall back to polling)\n");
|
|
return 0;
|
|
|
|
out:
|
|
if (host) {
|
|
if (host->irq)
|
|
free_irq(host->irq, host);
|
|
if (host->gpio_card_detect) {
|
|
free_irq(gpio_to_irq(host->gpio_card_detect), host);
|
|
gpio_free(host->gpio_card_detect);
|
|
}
|
|
if (host->gpio_write_protect)
|
|
gpio_free(host->gpio_write_protect);
|
|
if (host->base)
|
|
iounmap(host->base);
|
|
}
|
|
if (r)
|
|
release_resource(r);
|
|
if (mmc)
|
|
if (!IS_ERR_OR_NULL(host->clk)) {
|
|
clk_disable_unprepare(host->clk);
|
|
clk_put(host->clk);
|
|
}
|
|
mmc_free_host(mmc);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int __exit mvsd_remove(struct platform_device *pdev)
|
|
{
|
|
struct mmc_host *mmc = platform_get_drvdata(pdev);
|
|
|
|
if (mmc) {
|
|
struct mvsd_host *host = mmc_priv(mmc);
|
|
|
|
if (host->gpio_card_detect) {
|
|
free_irq(gpio_to_irq(host->gpio_card_detect), host);
|
|
gpio_free(host->gpio_card_detect);
|
|
}
|
|
mmc_remove_host(mmc);
|
|
free_irq(host->irq, host);
|
|
if (host->gpio_write_protect)
|
|
gpio_free(host->gpio_write_protect);
|
|
del_timer_sync(&host->timer);
|
|
mvsd_power_down(host);
|
|
iounmap(host->base);
|
|
release_resource(host->res);
|
|
|
|
if (!IS_ERR(host->clk)) {
|
|
clk_disable_unprepare(host->clk);
|
|
clk_put(host->clk);
|
|
}
|
|
mmc_free_host(mmc);
|
|
}
|
|
platform_set_drvdata(pdev, NULL);
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_PM
|
|
static int mvsd_suspend(struct platform_device *dev, pm_message_t state)
|
|
{
|
|
struct mmc_host *mmc = platform_get_drvdata(dev);
|
|
int ret = 0;
|
|
|
|
if (mmc)
|
|
ret = mmc_suspend_host(mmc);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int mvsd_resume(struct platform_device *dev)
|
|
{
|
|
struct mmc_host *mmc = platform_get_drvdata(dev);
|
|
int ret = 0;
|
|
|
|
if (mmc)
|
|
ret = mmc_resume_host(mmc);
|
|
|
|
return ret;
|
|
}
|
|
#else
|
|
#define mvsd_suspend NULL
|
|
#define mvsd_resume NULL
|
|
#endif
|
|
|
|
static struct platform_driver mvsd_driver = {
|
|
.remove = __exit_p(mvsd_remove),
|
|
.suspend = mvsd_suspend,
|
|
.resume = mvsd_resume,
|
|
.driver = {
|
|
.name = DRIVER_NAME,
|
|
},
|
|
};
|
|
|
|
static int __init mvsd_init(void)
|
|
{
|
|
return platform_driver_probe(&mvsd_driver, mvsd_probe);
|
|
}
|
|
|
|
static void __exit mvsd_exit(void)
|
|
{
|
|
platform_driver_unregister(&mvsd_driver);
|
|
}
|
|
|
|
module_init(mvsd_init);
|
|
module_exit(mvsd_exit);
|
|
|
|
/* maximum card clock frequency (default 50MHz) */
|
|
module_param(maxfreq, int, 0);
|
|
|
|
/* force PIO transfers all the time */
|
|
module_param(nodma, int, 0);
|
|
|
|
MODULE_AUTHOR("Maen Suleiman, Nicolas Pitre");
|
|
MODULE_DESCRIPTION("Marvell MMC,SD,SDIO Host Controller driver");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_ALIAS("platform:mvsdio");
|