libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/at91/at91sam9g45/drivers/at91_mci.c

911 lines
24 KiB
C
Raw Permalink Blame History

/*
* Copyright (c) 2006-2021, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2011-07-25 weety first version
*/
#include <rtthread.h>
#include <rthw.h>
#include <drivers/dev_mmcsd_core.h>
#include <at91sam9g45.h>
#include "at91_mci.h"
#define USE_SLOT_B
//#define RT_MCI_DBG
#ifdef RT_MCI_DBG
#define mci_dbg(fmt, ...) rt_kprintf(fmt, ##__VA_ARGS__)
#else
#define mci_dbg(fmt, ...)
#endif
#define MMU_NOCACHE_ADDR(a) ((rt_uint32_t)a | (1UL<<31))
extern void mmu_clean_dcache(rt_uint32_t buffer, rt_uint32_t size);
extern void mmu_invalidate_dcache(rt_uint32_t buffer, rt_uint32_t size);
#define AT91C_MCI_ERRORS (AT91C_MCI_RINDE | AT91C_MCI_RDIRE | AT91C_MCI_RCRCE \
| AT91C_MCI_RENDE | AT91C_MCI_RTOE | AT91C_MCI_DCRCE \
| AT91C_MCI_DTOE | AT91C_MCI_OVRE | AT91C_MCI_UNRE)
#define at91_mci_read(reg) readl(AT91C_BASE_MCI + (reg))
#define at91_mci_write(reg, val) writel((val), AT91C_BASE_MCI + (reg))
#define REQ_ST_INIT (1U << 0)
#define REQ_ST_CMD (1U << 1)
#define REQ_ST_STOP (1U << 2)
struct at91_mci {
struct rt_mmcsd_host *host;
struct rt_mmcsd_req *req;
struct rt_mmcsd_cmd *cmd;
struct rt_timer timer;
//struct rt_semaphore sem_ack;
rt_uint32_t *buf;
rt_uint32_t current_status;
};
/*
* Reset the controller and restore most of the state
*/
static void at91_reset_host()
{
rt_uint32_t mr;
rt_uint32_t sdcr;
rt_uint32_t dtor;
rt_uint32_t imr;
rt_uint32_t level;
level = rt_hw_interrupt_disable();
imr = at91_mci_read(AT91C_MCI_IMR);
at91_mci_write(AT91C_MCI_IDR, 0xffffffff);
/* save current state */
mr = at91_mci_read(AT91C_MCI_MR) & 0x7fff;
sdcr = at91_mci_read(AT91C_MCI_SDCR);
dtor = at91_mci_read(AT91C_MCI_DTOR);
/* reset the controller */
at91_mci_write(AT91C_MCI_CR, AT91C_MCI_MCIDIS | AT91C_MCI_SWRST);
/* restore state */
at91_mci_write(AT91C_MCI_CR, AT91C_MCI_MCIEN);
at91_mci_write(AT91C_MCI_MR, mr);
at91_mci_write(AT91C_MCI_SDCR, sdcr);
at91_mci_write(AT91C_MCI_DTOR, dtor);
at91_mci_write(AT91C_MCI_IER, imr);
/* make sure sdio interrupts will fire */
at91_mci_read(AT91C_MCI_SR);
rt_hw_interrupt_enable(level);
}
/*
* Enable the controller
*/
static void at91_mci_enable()
{
rt_uint32_t mr;
at91_mci_write(AT91C_MCI_CR, AT91C_MCI_MCIEN);
at91_mci_write(AT91C_MCI_IDR, 0xffffffff);
at91_mci_write(AT91C_MCI_DTOR, AT91C_MCI_DTOMUL_1M | AT91C_MCI_DTOCYC);
mr = AT91C_MCI_PDCMODE | 0x34a;
mr |= AT91C_MCI_RDPROOF | AT91C_MCI_WRPROOF;
at91_mci_write(AT91C_MCI_MR, mr);
/* use Slot A or B (only one at same time) */
at91_mci_write(AT91C_MCI_SDCR, 1); /* use slot b */
}
/*
* Disable the controller
*/
static void at91_mci_disable()
{
at91_mci_write(AT91C_MCI_CR, AT91C_MCI_MCIDIS | AT91C_MCI_SWRST);
}
static void at91_timeout_timer(void *data)
{
struct at91_mci *mci;
mci = (struct at91_mci *)data;
if (mci->req)
{
rt_kprintf("Timeout waiting end of packet\n");
if (mci->current_status == REQ_ST_CMD)
{
if (mci->req->cmd && mci->req->data)
{
mci->req->data->err = -RT_ETIMEOUT;
}
else
{
if (mci->req->cmd)
mci->req->cmd->err = -RT_ETIMEOUT;
}
}
else if (mci->current_status == REQ_ST_STOP)
{
mci->req->stop->err = -RT_ETIMEOUT;
}
at91_reset_host();
mmcsd_req_complete(mci->host);
}
}
/*
* Prepare a dma read
*/
static void at91_mci_init_dma_read(struct at91_mci *mci)
{
rt_uint8_t i;
struct rt_mmcsd_cmd *cmd;
struct rt_mmcsd_data *data;
rt_uint32_t length;
mci_dbg("pre dma read\n");
cmd = mci->cmd;
if (!cmd)
{
mci_dbg("no command\n");
return;
}
data = cmd->data;
if (!data)
{
mci_dbg("no data\n");
return;
}
for (i = 0; i < 1; i++)
{
/* Check to see if this needs filling */
if (i == 0)
{
if (at91_mci_read(AT91C_PDC_RCR) != 0)
{
mci_dbg("Transfer active in current\n");
continue;
}
}
else {
if (at91_mci_read(AT91C_PDC_RNCR) != 0)
{
mci_dbg("Transfer active in next\n");
continue;
}
}
length = data->blksize * data->blks;
mci_dbg("dma address = %08X, length = %d\n", data->buf, length);
if (i == 0)
{
at91_mci_write(AT91C_PDC_RPR, (rt_uint32_t)(data->buf));
at91_mci_write(AT91C_PDC_RCR, (data->blksize & 0x3) ? length : length / 4);
}
else
{
at91_mci_write(AT91C_PDC_RNPR, (rt_uint32_t)(data->buf));
at91_mci_write(AT91C_PDC_RNCR, (data->blksize & 0x3) ? length : length / 4);
}
}
mci_dbg("pre dma read done\n");
}
/*
* Send a command
*/
static void at91_mci_send_command(struct at91_mci *mci, struct rt_mmcsd_cmd *cmd)
{
rt_uint32_t cmdr, mr;
rt_uint32_t block_length;
struct rt_mmcsd_data *data = cmd->data;
struct rt_mmcsd_host *host = mci->host;
rt_uint32_t blocks;
rt_uint32_t ier = 0;
rt_uint32_t length;
mci->cmd = cmd;
/* Needed for leaving busy state before CMD1 */
if ((at91_mci_read(AT91C_MCI_SR) & AT91C_MCI_RTOE) && (cmd->cmd_code == 1))
{
mci_dbg("Clearing timeout\n");
at91_mci_write(AT91C_MCI_ARGR, 0);
at91_mci_write(AT91C_MCI_CMDR, AT91C_MCI_OPDCMD);
while (!(at91_mci_read(AT91C_MCI_SR) & AT91C_MCI_CMDRDY))
{
/* spin */
mci_dbg("Clearing: SR = %08X\n", at91_mci_read(AT91C_MCI_SR));
}
}
cmdr = cmd->cmd_code;
if (resp_type(cmd) == RESP_NONE)
cmdr |= AT91C_MCI_RSPTYP_NONE;
else
{
/* if a response is expected then allow maximum response latancy */
cmdr |= AT91C_MCI_MAXLAT;
/* set 136 bit response for R2, 48 bit response otherwise */
if (resp_type(cmd) == RESP_R2)
cmdr |= AT91C_MCI_RSPTYP_136;
else
cmdr |= AT91C_MCI_RSPTYP_48;
}
if (data)
{
block_length = data->blksize;
blocks = data->blks;
/* always set data start - also set direction flag for read */
if (data->flags & DATA_DIR_READ)
cmdr |= (AT91C_MCI_TRDIR | AT91C_MCI_TRCMD_START);
else if (data->flags & DATA_DIR_WRITE)
cmdr |= AT91C_MCI_TRCMD_START;
if (data->flags & DATA_STREAM)
cmdr |= AT91C_MCI_TRTYP_STREAM;
if (data->blks > 1)
cmdr |= AT91C_MCI_TRTYP_MULTIPLE;
}
else
{
block_length = 0;
blocks = 0;
}
/*if (cmd->cmd_code == GO_IDLE_STATE)
{
cmdr |= AT91C_MCI_SPCMD_INIT;
}*/
if (cmd->cmd_code == STOP_TRANSMISSION)
cmdr |= AT91C_MCI_TRCMD_STOP;
if (host->io_cfg.bus_mode == MMCSD_BUSMODE_OPENDRAIN)
cmdr |= AT91C_MCI_OPDCMD;
/*
* Set the arguments and send the command
*/
mci_dbg("Sending command %d as %08X, arg = %08X, blocks = %d, length = %d (MR = %08X)\n",
cmd->cmd_code, cmdr, cmd->arg, blocks, block_length, at91_mci_read(AT91C_MCI_MR));
if (!data)
{
at91_mci_write(AT91C_PDC_PTCR, AT91C_PDC_TXTDIS | AT91C_PDC_RXTDIS);
at91_mci_write(AT91C_PDC_RPR, 0);
at91_mci_write(AT91C_PDC_RCR, 0);
at91_mci_write(AT91C_PDC_RNPR, 0);
at91_mci_write(AT91C_PDC_RNCR, 0);
at91_mci_write(AT91C_PDC_TPR, 0);
at91_mci_write(AT91C_PDC_TCR, 0);
at91_mci_write(AT91C_PDC_TNPR, 0);
at91_mci_write(AT91C_PDC_TNCR, 0);
ier = AT91C_MCI_CMDRDY;
}
else
{
/* zero block length and PDC mode */
mr = at91_mci_read(AT91C_MCI_MR) & 0x5fff;
mr |= (data->blksize & 0x3) ? AT91C_MCI_PDCFBYTE : 0;
mr |= (block_length << 16);
mr |= AT91C_MCI_PDCMODE;
at91_mci_write(AT91C_MCI_MR, mr);
at91_mci_write(AT91C_MCI_BLKR,
AT91C_MCI_BLKR_BCNT(blocks) |
AT91C_MCI_BLKR_BLKLEN(block_length));
/*
* Disable the PDC controller
*/
at91_mci_write(AT91C_PDC_PTCR, AT91C_PDC_RXTDIS | AT91C_PDC_TXTDIS);
if (cmdr & AT91C_MCI_TRCMD_START)
{
if (cmdr & AT91C_MCI_TRDIR)
{
/*
* Handle a read
*/
mmu_invalidate_dcache((rt_uint32_t)data->buf, data->blksize*data->blks);
at91_mci_init_dma_read(mci);
ier = AT91C_MCI_ENDRX /* | AT91C_MCI_RXBUFF */;
}
else
{
/*
* Handle a write
*/
length = block_length * blocks;
/*
* at91mci MCI1 rev2xx Data Write Operation and
* number of bytes erratum
*/
if (length < 12)
{
length = 12;
mci->buf = rt_malloc(length);
if (!mci->buf)
{
rt_kprintf("rt alloc tx buffer failed\n");
cmd->err = -RT_ENOMEM;
mmcsd_req_complete(mci->host);
return;
}
rt_memset(mci->buf, 0, 12);
rt_memcpy(mci->buf, data->buf, length);
mmu_clean_dcache((rt_uint32_t)mci->buf, length);
at91_mci_write(AT91C_PDC_TPR, (rt_uint32_t)(mci->buf));
at91_mci_write(AT91C_PDC_TCR, (data->blksize & 0x3) ?
length : length / 4);
}
else
{
mmu_clean_dcache((rt_uint32_t)data->buf, data->blksize*data->blks);
at91_mci_write(AT91C_PDC_TPR, (rt_uint32_t)(data->buf));
at91_mci_write(AT91C_PDC_TCR, (data->blksize & 0x3) ?
length : length / 4);
}
mci_dbg("Transmitting %d bytes\n", length);
ier = AT91C_MCI_CMDRDY;
}
}
}
/*
* Send the command and then enable the PDC - not the other way round as
* the data sheet says
*/
at91_mci_write(AT91C_MCI_ARGR, cmd->arg);
at91_mci_write(AT91C_MCI_CMDR, cmdr);
if (cmdr & AT91C_MCI_TRCMD_START)
{
if (cmdr & AT91C_MCI_TRDIR)
at91_mci_write(AT91C_PDC_PTCR, AT91C_PDC_RXTEN);
}
/* Enable selected interrupts */
at91_mci_write(AT91C_MCI_IER, AT91C_MCI_ERRORS | ier);
}
/*
* Process the next step in the request
*/
static void at91_mci_process_next(struct at91_mci *mci)
{
if (mci->current_status == REQ_ST_INIT)
{
mci->current_status = REQ_ST_CMD;
at91_mci_send_command(mci, mci->req->cmd);
}
else if ((mci->current_status == REQ_ST_CMD) && mci->req->stop)
{
mci->current_status = REQ_ST_STOP;
at91_mci_send_command(mci, mci->req->stop);
}
else
{
rt_timer_stop(&mci->timer);
/* the mci controller hangs after some transfers,
* and the workaround is to reset it after each transfer.
*/
at91_reset_host();
mmcsd_req_complete(mci->host);
}
}
/*
* Handle an MMC request
*/
static void at91_mci_request(struct rt_mmcsd_host *host, struct rt_mmcsd_req *req)
{
rt_uint32_t timeout = RT_TICK_PER_SECOND;
struct at91_mci *mci = host->private_data;
mci->req = req;
mci->current_status = REQ_ST_INIT;
rt_timer_control(&mci->timer, RT_TIMER_CTRL_SET_TIME, (void*)&timeout);
rt_timer_start(&mci->timer);
at91_mci_process_next(mci);
}
/*
* Handle transmitted data
*/
static void at91_mci_handle_transmitted(struct at91_mci *mci)
{
struct rt_mmcsd_cmd *cmd;
struct rt_mmcsd_data *data;
mci_dbg("Handling the transmit\n");
/* Disable the transfer */
at91_mci_write(AT91C_PDC_PTCR, AT91C_PDC_RXTDIS | AT91C_PDC_TXTDIS);
/* Now wait for cmd ready */
at91_mci_write(AT91C_MCI_IDR, AT91C_MCI_TXBUFE);
cmd = mci->cmd;
if (!cmd) return;
data = cmd->data;
if (!data) return;
if (data->blks > 1)
{
mci_dbg("multiple write : wait for BLKE...\n");
at91_mci_write(AT91C_MCI_IER, AT91C_MCI_BLKE);
} else
at91_mci_write(AT91C_MCI_IER, AT91C_MCI_NOTBUSY);
}
/*
* Handle after a dma read
*/
static void at91_mci_post_dma_read(struct at91_mci *mci)
{
struct rt_mmcsd_cmd *cmd;
struct rt_mmcsd_data *data;
mci_dbg("post dma read\n");
cmd = mci->cmd;
if (!cmd)
{
mci_dbg("no command\n");
return;
}
data = cmd->data;
if (!data)
{
mci_dbg("no data\n");
return;
}
at91_mci_write(AT91C_MCI_IDR, AT91C_MCI_ENDRX);
at91_mci_write(AT91C_MCI_IER, AT91C_MCI_RXBUFF);
mci_dbg("post dma read done\n");
}
/*Handle after command sent ready*/
static int at91_mci_handle_cmdrdy(struct at91_mci *mci)
{
if (!mci->cmd)
return 1;
else if (!mci->cmd->data)
{
if (mci->current_status == REQ_ST_STOP)
{
/*After multi block write, we must wait for NOTBUSY*/
at91_mci_write(AT91C_MCI_IER, AT91C_MCI_NOTBUSY);
}
else return 1;
}
else if (mci->cmd->data->flags & DATA_DIR_WRITE)
{
/*After sendding multi-block-write command, start DMA transfer*/
at91_mci_write(AT91C_MCI_IER, AT91C_MCI_TXBUFE | AT91C_MCI_BLKE);
at91_mci_write(AT91C_PDC_PTCR, AT91C_PDC_TXTEN);
}
/* command not completed, have to wait */
return 0;
}
/*
* Handle a command that has been completed
*/
static void at91_mci_completed_command(struct at91_mci *mci, rt_uint32_t status)
{
struct rt_mmcsd_cmd *cmd = mci->cmd;
struct rt_mmcsd_data *data = cmd->data;
at91_mci_write(AT91C_MCI_IDR, 0xffffffff & ~(AT91C_MCI_SDIOIRQA | AT91C_MCI_SDIOIRQB));
cmd->resp[0] = at91_mci_read(AT91C_MCI_RSPR(0));
cmd->resp[1] = at91_mci_read(AT91C_MCI_RSPR(1));
cmd->resp[2] = at91_mci_read(AT91C_MCI_RSPR(2));
cmd->resp[3] = at91_mci_read(AT91C_MCI_RSPR(3));
if (mci->buf)
{
//rt_memcpy(data->buf, mci->buf, data->blksize*data->blks);
rt_free(mci->buf);
mci->buf = RT_NULL;
}
mci_dbg("Status = %08X/%08x [%08X %08X %08X %08X]\n",
status, at91_mci_read(AT91C_MCI_SR),
cmd->resp[0], cmd->resp[1], cmd->resp[2], cmd->resp[3]);
if (status & AT91C_MCI_ERRORS)
{
if ((status & AT91C_MCI_RCRCE) && (resp_type(cmd) & (RESP_R3|RESP_R4)))
{
cmd->err = 0;
}
else
{
if (status & (AT91C_MCI_DTOE | AT91C_MCI_DCRCE))
{
if (data)
{
if (status & AT91C_MCI_DTOE)
data->err = -RT_ETIMEOUT;
else if (status & AT91C_MCI_DCRCE)
data->err = -RT_ERROR;
}
}
else
{
if (status & AT91C_MCI_RTOE)
cmd->err = -RT_ETIMEOUT;
else if (status & AT91C_MCI_RCRCE)
cmd->err = -RT_ERROR;
else
cmd->err = -RT_ERROR;
}
rt_kprintf("error detected and set to %d/%d (cmd = %d)\n",
cmd->err, data ? data->err : 0,
cmd->cmd_code);
}
}
else
cmd->err = 0;
at91_mci_process_next(mci);
}
/*
* Handle an interrupt
*/
static void at91_mci_irq(int irq, void *param)
{
struct at91_mci *mci = (struct at91_mci *)param;
rt_int32_t completed = 0;
rt_uint32_t int_status, int_mask;
int_status = at91_mci_read(AT91C_MCI_SR);
int_mask = at91_mci_read(AT91C_MCI_IMR);
mci_dbg("MCI irq: status = %08X, %08X, %08X\n", int_status, int_mask,
int_status & int_mask);
int_status = int_status & int_mask;
if (int_status & AT91C_MCI_ERRORS)
{
completed = 1;
if (int_status & AT91C_MCI_UNRE)
mci_dbg("MMC: Underrun error\n");
if (int_status & AT91C_MCI_OVRE)
mci_dbg("MMC: Overrun error\n");
if (int_status & AT91C_MCI_DTOE)
mci_dbg("MMC: Data timeout\n");
if (int_status & AT91C_MCI_DCRCE)
mci_dbg("MMC: CRC error in data\n");
if (int_status & AT91C_MCI_RTOE)
mci_dbg("MMC: Response timeout\n");
if (int_status & AT91C_MCI_RENDE)
mci_dbg("MMC: Response end bit error\n");
if (int_status & AT91C_MCI_RCRCE)
mci_dbg("MMC: Response CRC error\n");
if (int_status & AT91C_MCI_RDIRE)
mci_dbg("MMC: Response direction error\n");
if (int_status & AT91C_MCI_RINDE)
mci_dbg("MMC: Response index error\n");
}
else
{
/* Only continue processing if no errors */
if (int_status & AT91C_MCI_TXBUFE)
{
mci_dbg("TX buffer empty\n");
at91_mci_handle_transmitted(mci);
}
if (int_status & AT91C_MCI_ENDRX)
{
mci_dbg("ENDRX\n");
at91_mci_post_dma_read(mci);
}
if (int_status & AT91C_MCI_RXBUFF)
{
mci_dbg("RX buffer full\n");
at91_mci_write(AT91C_PDC_PTCR, AT91C_PDC_RXTDIS | AT91C_PDC_TXTDIS);
at91_mci_write(AT91C_MCI_IDR, AT91C_MCI_RXBUFF | AT91C_MCI_ENDRX);
completed = 1;
}
if (int_status & AT91C_MCI_ENDTX)
mci_dbg("Transmit has ended\n");
if (int_status & AT91C_MCI_NOTBUSY)
{
mci_dbg("Card is ready\n");
//at91_mci_update_bytes_xfered(host);
completed = 1;
}
if (int_status & AT91C_MCI_DTIP)
mci_dbg("Data transfer in progress\n");
if (int_status & AT91C_MCI_BLKE)
{
mci_dbg("Block transfer has ended\n");
if (mci->req->data && mci->req->data->blks > 1)
{
/* multi block write : complete multi write
* command and send stop */
completed = 1;
}
else
{
at91_mci_write(AT91C_MCI_IER, AT91C_MCI_NOTBUSY);
}
}
/*if (int_status & AT91C_MCI_SDIOIRQA)
rt_mmcsd_signal_sdio_irq(host->mmc);*/
if (int_status & AT91C_MCI_SDIOIRQB)
sdio_irq_wakeup(mci->host);
if (int_status & AT91C_MCI_TXRDY)
mci_dbg("Ready to transmit\n");
if (int_status & AT91C_MCI_RXRDY)
mci_dbg("Ready to receive\n");
if (int_status & AT91C_MCI_CMDRDY)
{
mci_dbg("Command ready\n");
completed = at91_mci_handle_cmdrdy(mci);
}
}
if (completed)
{
mci_dbg("Completed command\n");
at91_mci_write(AT91C_MCI_IDR, 0xffffffff & ~(AT91C_MCI_SDIOIRQA | AT91C_MCI_SDIOIRQB));
at91_mci_completed_command(mci, int_status);
}
else
at91_mci_write(AT91C_MCI_IDR, int_status & ~(AT91C_MCI_SDIOIRQA | AT91C_MCI_SDIOIRQB));
}
/*
* Set the IOCFG
*/
static void at91_mci_set_iocfg(struct rt_mmcsd_host *host, struct rt_mmcsd_io_cfg *io_cfg)
{
rt_uint32_t clkdiv;
//struct at91_mci *mci = host->private_data;
rt_uint32_t at91_master_clock = clk_get_rate(clk_get("mck"));
if (io_cfg->clock == 0)
{
/* Disable the MCI controller */
at91_mci_write(AT91C_MCI_CR, AT91C_MCI_MCIDIS);
clkdiv = 0;
}
else
{
/* Enable the MCI controller */
at91_mci_write(AT91C_MCI_CR, AT91C_MCI_MCIEN);
if ((at91_master_clock % (io_cfg->clock * 2)) == 0)
clkdiv = ((at91_master_clock / io_cfg->clock) / 2) - 1;
else
clkdiv = (at91_master_clock / io_cfg->clock) / 2;
mci_dbg("clkdiv = %d. mcck = %ld\n", clkdiv,
at91_master_clock / (2 * (clkdiv + 1)));
}
if (io_cfg->bus_width == MMCSD_BUS_WIDTH_4)
{
mci_dbg("MMC: Setting controller bus width to 4\n");
at91_mci_write(AT91C_MCI_SDCR, at91_mci_read(AT91C_MCI_SDCR) | AT91C_MCI_SDCBUS);
}
else
{
mci_dbg("MMC: Setting controller bus width to 1\n");
at91_mci_write(AT91C_MCI_SDCR, at91_mci_read(AT91C_MCI_SDCR) & ~AT91C_MCI_SDCBUS);
}
/* Set the clock divider */
at91_mci_write(AT91C_MCI_MR, (at91_mci_read(AT91C_MCI_MR) & ~AT91C_MCI_CLKDIV) | clkdiv);
/* maybe switch power to the card */
switch (io_cfg->power_mode)
{
case MMCSD_POWER_OFF:
break;
case MMCSD_POWER_UP:
break;
case MMCSD_POWER_ON:
/*at91_mci_write(AT91C_MCI_ARGR, 0);
at91_mci_write(AT91C_MCI_CMDR, 0|AT91C_MCI_SPCMD_INIT|AT91C_MCI_OPDCMD);
mci_dbg("MCI_SR=0x%08x\n", at91_mci_read(AT91C_MCI_SR));
while (!(at91_mci_read(AT91C_MCI_SR) & AT91C_MCI_CMDRDY))
{
}
mci_dbg("at91 mci power on\n");*/
break;
default:
rt_kprintf("unknown power_mode %d\n", io_cfg->power_mode);
break;
}
}
static void at91_mci_enable_sdio_irq(struct rt_mmcsd_host *host, rt_int32_t enable)
{
at91_mci_write(enable ? AT91C_MCI_IER : AT91C_MCI_IDR, AT91C_MCI_SDIOIRQB);
}
static const struct rt_mmcsd_host_ops ops = {
at91_mci_request,
at91_mci_set_iocfg,
RT_NULL,
at91_mci_enable_sdio_irq,
};
void at91_mci_detect(int irq, void *param)
{
rt_kprintf("mmcsd gpio detected\n");
}
static void mci_gpio_init()
{
#ifdef USE_SLOT_B
AT91C_BASE_PIOA->PIO_PUER = (1 << 0)|(1 << 1)|(1 << 3)|(1 << 4)|(1 << 5);
AT91C_BASE_PIOA->PIO_PUDR = (1 << 8);
AT91C_BASE_PIOA->PIO_BSR = (1 << 0)|(1 << 1)|(1 << 3)|(1 << 4)|(1 << 5);
AT91C_BASE_PIOA->PIO_ASR = (1 << 8);
AT91C_BASE_PIOA->PIO_PDR = (1 << 0)|(1 << 1)|(1 << 3)|(1 << 4)|(1 << 5)|(1 << 8);
AT91C_BASE_PIOA->PIO_IDR = (1 << 6)|(1 << 7);
AT91C_BASE_PIOA->PIO_PUER = (1 << 6)|(1 << 7);
AT91C_BASE_PIOA->PIO_ODR = (1 << 6)|(1 << 7);
AT91C_BASE_PIOA->PIO_PER = (1 << 6)|(1 << 7);
#else
AT91C_BASE_PIOA->PIO_PUER = (1 << 6)|(1 << 7)|(1 << 9)|(1 << 10)|(1 << 11);
AT91C_BASE_PIOA->PIO_ASR = (1 << 6)|(1 << 7)|(1 << 9)|(1 << 10)|(1 << 11)|(1 << 8);
AT91C_BASE_PIOA->PIO_PDR = (1 << 6)|(1 << 7)|(1 << 9)|(1 << 10)|(1 << 11)|(1 << 8);
#endif
}
int at91_mci_init(void)
{
struct rt_mmcsd_host *host;
struct at91_mci *mci;
host = mmcsd_alloc_host();
if (!host)
{
return -RT_ERROR;
}
mci = rt_malloc(sizeof(struct at91_mci));
if (!mci)
{
rt_kprintf("alloc mci failed\n");
goto err;
}
rt_memset(mci, 0, sizeof(struct at91_mci));
host->ops = &ops;
host->freq_min = 375000;
host->freq_max = 25000000;
host->valid_ocr = VDD_32_33 | VDD_33_34;
host->flags = MMCSD_BUSWIDTH_4 | MMCSD_MUTBLKWRITE | \
MMCSD_SUP_HIGHSPEED | MMCSD_SUP_SDIO_IRQ;
host->max_seg_size = 65535;
host->max_dma_segs = 2;
host->max_blk_size = 512;
host->max_blk_count = 4096;
mci->host = host;
mci_gpio_init();
AT91C_BASE_PMC->AT91C_PMC_PCER = 1 << AT91C_ID_MCI; //enable MCI clock
at91_mci_disable();
at91_mci_enable();
/* instal interrupt */
rt_hw_interrupt_install(AT91SAM9260_ID_MCI, at91_mci_irq,
(void *)mci, "MMC");
rt_hw_interrupt_umask(AT91SAM9260_ID_MCI);
rt_hw_interrupt_install(gpio_to_irq(AT91C_PIN_PA7),
at91_mci_detect, RT_NULL, "MMC_DETECT");
rt_hw_interrupt_umask(gpio_to_irq(AT91C_PIN_PA7));
rt_timer_init(&mci->timer, "mci_timer",
at91_timeout_timer,
mci,
RT_TICK_PER_SECOND,
RT_TIMER_FLAG_PERIODIC);
//rt_timer_start(&mci->timer);
//rt_sem_init(&mci->sem_ack, "sd_ack", 0, RT_IPC_FLAG_FIFO);
host->private_data = mci;
mmcsd_change(host);
return 0;
err:
mmcsd_free_host(host);
return -RT_ENOMEM;
}
INIT_DEVICE_EXPORT(at91_mci_init);
#include "finsh.h"
FINSH_FUNCTION_EXPORT(at91_mci_init, at91sam9260 sd init);
void mci_dump(void)
{
rt_uint32_t i;
rt_kprintf("PIOA_PSR=0x%08x\n", readl(AT91C_PIOA+PIO_PSR));
rt_kprintf("PIOA_ABSR=0x%08x\n", readl(AT91C_PIOA+PIO_ABSR));
rt_kprintf("PIOA_PUSR=0x%08x\n", readl(AT91C_PIOA+PIO_PUSR));
for (i = 0; i <= 0x4c; i += 4) {
rt_kprintf("0x%08x:0x%08x\n", AT91SAM9260_BASE_MCI+i, at91_mci_read(i));
}
}
FINSH_FUNCTION_EXPORT(mci_dump, dump register for mci);
View Git Blame Copy Permalink