phunix/minix/drivers/storage/mmc/emmc.c

#include <minix/blockdriver.h>
#include <minix/board.h>
#include <minix/log.h>
#include <minix/mmio.h>
#include <minix/spin.h>
#include <minix/syslib.h>

#include <sys/mman.h>

#include "omap_mmc.h"
#include "mmchost.h"
#include "sdmmcreg.h"

/* MINIX IRQ timeout. Twice the host controller data/busy timeout @ 48MHz. */
#define IRQ_TIMEOUT 5600000 /* 5,600,000 us */

#define MMCHS_TIMEOUT 500000 /* 500,000 us */

/* Reference clock frequency divisors: */
#define MMCHS_SD_SYSCTL_CLKD_400KHZ 240 /* 96MHz/400kHz */
#define MMCHS_SD_SYSCTL_CLKD_26MHZ    4 /* ceiling 96MHz/26MHz */
#define MMCHS_SD_SYSCTL_CLKD_52MHZ    2 /* ceiling 96MHz/52MHz */

/* The host SD_DATA register is 128 words (512B). */
#define SD_DATA_WLEN 128

/*
 * Card initialization timeout, twice the standard:
 * "The device must complete its initialization within 1 second of the first
 * CMD1 issued with a valid OCR range." (MMCA, 4.41)
 */
#define CARD_INI_TIMEOUT 2000000 /* 2,000,000 us */

/* Card EXT_CSD register fields. */
#define MMC_EXT_CSD_SEC_COUNT (*(uint32_t *)&card_ext_csd[212])
#define MMC_EXT_CSD_CARD_TYPE (card_ext_csd[196])
#define MMC_EXT_CSD_CARD_TYPE_HS_MMC_52MHZ (0x1 << 1)

/* Card intended operating voltage range: 2.7V to 3.6V */
#define MMC_OCR_VDD_RANGE 0x00FF8000

/* Error bits in the card status (R1) response. */
#define R1_ERROR_MASK 0xFDFFA080

/* Relative Card Address. Must be greater than 1. */
#define RCA 0x2

/* The card sector size is 512B. */
#define SEC_SIZE 512

/*
 * AM335x Control Module registers CONF_GPMC_ADn.
 * Configuration do multiplex CONF_GPMC_ADn to signals MMC1_DATn (Mode 1).
 */
#define CONF_GPMC_AD(N)  (0x800 + 4*(N))
#define CONF_GPMC_AD_MASK 0x7F
#define CONF_GPMC_AD_VAL  0x31

/* AM335x MMC1 memory map (physical start address and size). */
#define AM335X_MMC1_BASE_ADDR 0x481D8000
#define AM335X_MMC1_SIZE (4 << 10)
/* AM335x MMC1 interrupt number. */
#define AM335X_MMCSD1INT 28

static uint32_t bus_width;

/* AM335x MMCHS registers virtual addresses: virtual base + offset. */
static struct omap_mmchs_registers *reg;

/* Card registers. */
static uint32_t card_csd[4];
static uint8_t card_ext_csd[512];

static uint32_t card_write_protect;
static uint64_t card_size;

/* IRQ_HOOK_ID for SYS_IRQCTL kernel call. */
static int hook_id = 1;

/* Initialize the log system. */
static struct log log = {
	.name = "emmc",
	.log_level = LEVEL_INFO,
	.log_func = default_log,
};


/*
 * Spin until a register flag is set, or the time runs out.
 * Return the flag value.
 */
static uint32_t
spin_until_set(uint32_t address, uint32_t flag)
{
	spin_t s;
	int spin;
	uint32_t v;

	spin_init(&s, MMCHS_TIMEOUT);
	do {
		spin = spin_check(&s);
		v = (read32(address) & flag);
	} while ((v == 0) && (spin == TRUE));

	return v;
}

/*
 * Spin until a register flag is clear, or the time runs out.
 * Return the flag value.
 */
static uint32_t
spin_until_clear(uint32_t address, uint32_t flag)
{
	spin_t s;
	int spin;
	uint32_t v;

	spin_init(&s, MMCHS_TIMEOUT);
	do {
		spin = spin_check(&s);
		v = (read32(address) & flag);
	} while ((v != 0) && (spin == TRUE));

	return v;
}

/*
 * Change the bus clock frequency (divisor).
 * Return 0 on success, a negative integer on error.
 */
static int
set_bus_clkd(uint32_t clkd)
{
	/*
	 * Disable the bus clock, set the clock divider, wait until the
	 * internal clock is stable, enable the bus clock.
	 */
	set32(reg->SYSCTL, MMCHS_SD_SYSCTL_CEN, MMCHS_SD_SYSCTL_CEN_DIS);
	set32(reg->SYSCTL, MMCHS_SD_SYSCTL_CLKD, clkd << 6);
	if (spin_until_set(reg->SYSCTL, MMCHS_SD_SYSCTL_ICS)
		== MMCHS_SD_SYSCTL_ICS_UNSTABLE)
		return -1;
	set32(reg->SYSCTL, MMCHS_SD_SYSCTL_CEN, MMCHS_SD_SYSCTL_CEN_EN);

	return 0;
}

/*
 * Receive an interrupt request.
 * Return 0 on success, a negative integer on error.
 */
static int
irq_receive(void)
{
	message m;
	int ipc_status;

	while (1) {
		if (driver_receive(ANY, &m, &ipc_status) != OK)
			return -1;
		if (is_ipc_notify(ipc_status)
			&& (_ENDPOINT_P(m.m_source) == CLOCK))
			return -1;
		if (is_ipc_notify(ipc_status)
			&& (_ENDPOINT_P(m.m_source) == HARDWARE))
			return 0;
		/*
		 * m will be discarded if the driver is out of memory.
		 */
		blockdriver_mq_queue(&m, ipc_status);
	}
}

/*
 * Wait for an interrupt request.
 * Return 0 on interrupt, a negative integer on error.
 */
static int
irq_wait(void)
{
	int r;

	if (sys_irqenable(&hook_id) != OK)
		return -1;
	sys_setalarm(micros_to_ticks(IRQ_TIMEOUT), 0);
	r = irq_receive();
	sys_setalarm(0, 0);
	if (r < 0)
		sys_irqdisable(&hook_id);

	return r;
}

/*
 * Software reset for mmc_cmd or mmc_dat line.
 */
static void
reset_mmchs_fsm(uint32_t line)
{
	/*
	 * "The proper procedure is: (a) Set to 1 to start reset,
	 * (b) Poll for 1 to identify start of reset, and
	 * (c) Poll for 0 to identify reset is complete." (AM335x TRM)
	 */
	set32(reg->SYSCTL, line, line);
	spin_until_set(reg->SYSCTL, line);
	spin_until_clear(reg->SYSCTL, line);
}

/*
 * Send a command to the card.
 * Return 0 on success, a negative integer on error.
 */
static int
send_cmd(uint32_t arg, uint32_t cmd)
{
	uint32_t stat;

	if (read32(reg->PSTATE)
		& (MMCHS_SD_PSTATE_DATI | MMCHS_SD_PSTATE_CMDI))
		return -1; /* Issuing of commands is not allowed. */
	write32(reg->ARG, arg);
	write32(reg->CMD, cmd);
	/* Wait for the command completion. */
	if (irq_wait() < 0)
		return -1;
	stat = read32(reg->SD_STAT);
	/*
	 * Clear only the command status/error bits. The transfer status/error
	 * bits (including ERRI) must be preserved.
	 */
	write32(reg->SD_STAT, MMCHS_SD_STAT_CIE
		| MMCHS_SD_STAT_CEB
		| MMCHS_SD_STAT_CCRC
		| MMCHS_SD_STAT_CTO
		| MMCHS_SD_STAT_CC);
	if (stat & MMCHS_SD_STAT_CTO) {
		reset_mmchs_fsm(MMCHS_SD_SYSCTL_SRC);
		return -1;
	}

	return 0;
}

/*
 * Send a command to the card, and check for errors in the response (R1).
 * Return 0 on success, a negative integer on error.
 */
static int
send_cmd_check_r1(uint32_t arg, uint32_t cmd)
{
	if (send_cmd(arg, cmd) < 0)
		return -1;
	/* Check for card errors in the card response (R1). */
	if (read32(reg->RSP10) & R1_ERROR_MASK)
		return -1;

	return 0;
}

/* Send CMD0 (GO_IDLE_STATE) command to the card. */
static int
go_idle_state(void)
{
	return send_cmd(MMC_GO_IDLE_STATE, MMC_GO_IDLE_STATE);
}

/* Send CMD1 (SEND_OP_COND) command to the card. */
static int
send_op_cond(void)
{
	uint32_t cmd;

	/* The driver is capable of handling sector type of addressing. */
	cmd = MMCHS_SD_CMD_INDX_CMD(MMC_SEND_OP_COND)
		| MMCHS_SD_CMD_RSP_TYPE_48B;
	return send_cmd((MMC_OCR_HCS | MMC_OCR_VDD_RANGE), cmd);
}

/* Send CMD2 (ALL_SEND_CID) command to the card. */
static int
all_send_cid(void)
{
	uint32_t cmd;

	cmd = MMCHS_SD_CMD_INDX_CMD(MMC_ALL_SEND_CID)
		| MMCHS_SD_CMD_CCCE_ENABLE
		| MMCHS_SD_CMD_RSP_TYPE_136B;
	return send_cmd(0, cmd);
}

/* Send CMD3 (SET_RELATIVE_ADDR) command to the card. */
static int
set_relative_addr(void)
{
	uint32_t cmd;

	cmd = MMCHS_SD_CMD_INDX_CMD(MMC_SET_RELATIVE_ADDR)
		| MMCHS_SD_CMD_CICE_ENABLE
		| MMCHS_SD_CMD_CCCE_ENABLE
		| MMCHS_SD_CMD_RSP_TYPE_48B;
	return send_cmd_check_r1(MMC_ARG_RCA(RCA), cmd);
}

/* Send CMD6 (SWITCH) command to the card. */
static int
mmc_switch(uint32_t access, uint32_t index, uint32_t value)
{
	uint32_t arg, cmd;

	/* SWITCH argument: [25:24] Access, [23:16] Index, [15:8] Value. */
	arg = (access << 24) | (index << 16) | (value << 8);
	cmd = MMCHS_SD_CMD_INDX_CMD(MMC_SWITCH)
		| MMCHS_SD_CMD_CICE_ENABLE
		| MMCHS_SD_CMD_CCCE_ENABLE
		| MMCHS_SD_CMD_RSP_TYPE_48B_BUSY;
	return send_cmd_check_r1(arg, cmd);
}

/* Send CMD7 (SELECT_CARD) command to the card. */
static int
select_card(void)
{
	uint32_t cmd;

	cmd = MMCHS_SD_CMD_INDX_CMD(MMC_SELECT_CARD)
		| MMCHS_SD_CMD_CICE_ENABLE
		| MMCHS_SD_CMD_CCCE_ENABLE
		| MMCHS_SD_CMD_RSP_TYPE_48B;
	return send_cmd_check_r1(MMC_ARG_RCA(RCA), cmd);
}

/* Send CMD8 (SEND_EXT_CSD) command to the card. */
static int
send_ext_csd(void)
{
	uint32_t cmd;

	cmd = MMCHS_SD_CMD_INDX_CMD(MMC_SEND_EXT_CSD)
		| MMCHS_SD_CMD_DP_DATA
		| MMCHS_SD_CMD_CICE_ENABLE
		| MMCHS_SD_CMD_CCCE_ENABLE
		| MMCHS_SD_CMD_RSP_TYPE_48B
		| MMCHS_SD_CMD_DDIR_READ;
	return send_cmd_check_r1(0, cmd);
}

/* Send CMD9 (SEND_CSD) command to the card. */
static int
send_csd(void)
{
	uint32_t cmd;

	cmd = MMCHS_SD_CMD_INDX_CMD(MMC_SEND_CSD)
		| MMCHS_SD_CMD_CCCE_ENABLE
		| MMCHS_SD_CMD_RSP_TYPE_136B;
	return send_cmd(MMC_ARG_RCA(RCA), cmd);
}

/* Send CMD13 (SEND_STATUS) command to the card. */
static int
send_status(void)
{
	uint32_t cmd;

	cmd = MMCHS_SD_CMD_INDX_CMD(MMC_SEND_STATUS)
		| MMCHS_SD_CMD_CICE_ENABLE
		| MMCHS_SD_CMD_CCCE_ENABLE
		| MMCHS_SD_CMD_RSP_TYPE_48B;
	return send_cmd_check_r1(MMC_ARG_RCA(RCA), cmd);
}

/* Send CMD16 (SET_BLOCKLEN) command to the card. */
static int
set_blocklen(void)
{
	uint32_t cmd;

	/* Set block length to sector size (512B). */
	cmd = MMCHS_SD_CMD_INDX_CMD(MMC_SET_BLOCKLEN)
		| MMCHS_SD_CMD_CICE_ENABLE
		| MMCHS_SD_CMD_CCCE_ENABLE
		| MMCHS_SD_CMD_RSP_TYPE_48B;
	return send_cmd_check_r1(SEC_SIZE, cmd);
}

/* Send CMD17 (READ_SINGLE_BLOCK) to the card. */
static int
read_single_block(uint32_t addr)
{
	uint32_t cmd;

	cmd = MMCHS_SD_CMD_INDX_CMD(MMC_READ_BLOCK_SINGLE)
		| MMCHS_SD_CMD_DP_DATA
		| MMCHS_SD_CMD_CICE_ENABLE
		| MMCHS_SD_CMD_CCCE_ENABLE
		| MMCHS_SD_CMD_RSP_TYPE_48B
		| MMCHS_SD_CMD_DDIR_READ;
	return send_cmd_check_r1(addr, cmd);
}

/* Send CMD24 (WRITE_BLOCK) to the card. */
static int
write_block(uint32_t addr)
{
	uint32_t cmd;

	cmd = MMCHS_SD_CMD_INDX_CMD(MMC_WRITE_BLOCK_SINGLE)
		| MMCHS_SD_CMD_DP_DATA
		| MMCHS_SD_CMD_CICE_ENABLE
		| MMCHS_SD_CMD_CCCE_ENABLE
		| MMCHS_SD_CMD_RSP_TYPE_48B
		| MMCHS_SD_CMD_DDIR_WRITE;
	return send_cmd_check_r1(addr, cmd);
}

/*
 * Repeat CMD1 until the card is ready, or the time runs out.
 * Return 0 on ready, a negative integer on error.
 */
static int
repeat_send_op_cond(void)
{
	spin_t s;
	int spin;
	uint32_t card_ocr;

	spin_init(&s, CARD_INI_TIMEOUT);
	do {
		spin = spin_check(&s);
		if (send_op_cond() < 0)
			return -1;
		card_ocr = read32(reg->RSP10);
	} while (((card_ocr & MMC_OCR_MEM_READY) == 0) && (spin == TRUE));

	if ((card_ocr & MMC_OCR_MEM_READY) == 0)
		return -1; /* Card is still busy. */

	return 0;
}

/*
 * Read (receive) the busy signal from the card.
 * Return 0 on success, a negative integer on error.
 */
static int
read_busy(void)
{
	uint32_t stat;
	/*
	 * The busy signal is optional, but the host controller will assert
	 * SD_STAT[1] TC even if the card does not send it.
	 */
	if (irq_wait() < 0)
		return -1;
	stat = read32(reg->SD_STAT);
	write32(reg->SD_STAT, MMCHS_SD_STAT_DCRC
		| MMCHS_SD_STAT_DTO
		| MMCHS_SD_STAT_TC);
	if (stat & MMCHS_SD_STAT_ERRI) {
		reset_mmchs_fsm(MMCHS_SD_SYSCTL_SRD);
		return -1;
	}

	return 0;
}

/*
 * Read (receive) data from the card.
 * Return 0 on success, a negative integer on error.
 */
static int
read_data(uint32_t *data)
{
	uint32_t stat, i;

	/* Wait for BRR interrupt. */
	if (irq_wait() < 0)
		return -1;
	if (read32(reg->SD_STAT) & MMCHS_SD_STAT_BRR) {
		write32(reg->SD_STAT, MMCHS_SD_STAT_BRR);
		for (i=SD_DATA_WLEN; i>0; i--)
			*data++ = read32(reg->DATA);
	}

	/* Wait for TC or ERRI interrupt. */
	if (irq_wait() < 0)
		return -1;
	stat = read32(reg->SD_STAT);
	write32(reg->SD_STAT, MMCHS_SD_STAT_DEB
		| MMCHS_SD_STAT_DCRC
		| MMCHS_SD_STAT_DTO
		| MMCHS_SD_STAT_TC);
	if (stat & MMCHS_SD_STAT_ERRI) {
		reset_mmchs_fsm(MMCHS_SD_SYSCTL_SRD);
		return -1;
	}

	return 0;
}

/*
 * Write (send) data to the card.
 * Return 0 on success, a negative integer on error.
 */
static int
write_data(uint32_t *data)
{
	uint32_t stat, i;

	/* Wait for BWR interrupt. */
	if (irq_wait() < 0)
		return -1;
	if (read32(reg->SD_STAT) & MMCHS_SD_STAT_BWR) {
		write32(reg->SD_STAT, MMCHS_SD_STAT_BWR);
		for (i=SD_DATA_WLEN; i>0; i--)
			write32(reg->DATA, *data++);
	}

	/* Wait for TC or ERRI interrupt. */
	if (irq_wait() < 0)
		return -1;
	stat = read32(reg->SD_STAT);
	write32(reg->SD_STAT, MMCHS_SD_STAT_DEB
		| MMCHS_SD_STAT_DCRC
		| MMCHS_SD_STAT_DTO
		| MMCHS_SD_STAT_TC);
	if (stat & MMCHS_SD_STAT_ERRI) {
		reset_mmchs_fsm(MMCHS_SD_SYSCTL_SRD);
		return -1;
	}

	return 0;
}

/*
 * Read a block from the card.
 * Return 0 on success, a negative integer on error.
 */
static int
cim_read_block(uint32_t addr, uint32_t *data)
{
	/* Send CMD17. */
	if (read_single_block(addr) < 0)
		return -1;
	/* Read from the host buffer. */
	return read_data(data);
}

/*
 * Write a block to the card.
 * Return 0 on success, a negative integer on error.
 */
static int
cim_write_block(uint32_t addr, uint32_t *data)
{
	/* Send CMD24. */
	if (write_block(addr) < 0)
		return -1;
	/* Write into the host buffer. */
	if (write_data(data) < 0)
		return -1;
	/* CMD13. Check the result of the write operation. */
	return send_status();
}


/*
 * Interface to the MINIX block device driver.
 */
static int
emmc_host_set_instance(struct mmc_host *host, int instance)
{
	if (instance != 0)
		return EIO;
	return 0;
}

/*
 * Initialize the driver and kernel structures.
 * Return 0 on success, a negative integer on error.
 */
static int
minix_init(void)
{
	struct minix_mem_range mr;
	uint32_t v_base;

	/*
	 * On the BeagleBone Black, the eMMC device is connected to MMC1.
	 * Add the MMC1 memory address range to the process' resources.
	 */
	mr.mr_base  = AM335X_MMC1_BASE_ADDR;
	mr.mr_limit = AM335X_MMC1_BASE_ADDR + AM335X_MMC1_SIZE - 1;
	if (sys_privctl(SELF, SYS_PRIV_ADD_MEM, &mr) != OK)
		return -1;

	/* Map the MMC1 physical base address to a virtual address. */
	v_base = (uint32_t)vm_map_phys(SELF, (void *)mr.mr_base,
		AM335X_MMC1_SIZE);
	if (v_base == (uint32_t)MAP_FAILED)
		return -1;

	/* Set the registers virtual addresses. */
	reg = &regs_v1;
	reg->SYSCONFIG += v_base;
	reg->SYSSTATUS += v_base;
	reg->CON       += v_base;
	reg->BLK       += v_base;
	reg->ARG       += v_base;
	reg->CMD       += v_base;
	reg->RSP10     += v_base;
	reg->RSP32     += v_base;
	reg->RSP54     += v_base;
	reg->RSP76     += v_base;
	reg->DATA      += v_base;
	reg->PSTATE    += v_base;
	reg->HCTL      += v_base;
	reg->SYSCTL    += v_base;
	reg->SD_STAT   += v_base;
	reg->IE        += v_base;
	reg->ISE       += v_base;

	/* Register the MMC1 interrupt number. */
	if (sys_irqsetpolicy(AM335X_MMCSD1INT, 0, &hook_id) != OK)
		return -1;

	return 0;
}

/*
 * Configure the Control Module registers CONF_GPMC_AD4-7.
 * Multiplex pins GPMC_AD4-7 to signals MMC1_DAT4-7 (Mode 1).
 * Return 0 on success, a negative integer on error.
 */
static int
conf_gpmc_ad(void)
{
	uint32_t i;

	for (i=4; i<8; i++) {
		if (sys_padconf(CONF_GPMC_AD(i), CONF_GPMC_AD_MASK,
			CONF_GPMC_AD_VAL) != OK)
			return -1;
	}
	return 0;
}

/*
 * Interface to the MINIX block device driver.
 * Host controller initialization.
 * Return 0 on success, a negative integer on error.
 */
static int
emmc_host_init(struct mmc_host *host)
{
	struct machine machine;

	/* The eMMC is present on the BBB only. */
	sys_getmachine(&machine);
	if (!BOARD_IS_BBB(machine.board_id))
		return -1;

	/* Initialize the driver and kernel structures. */
	if (minix_init() < 0)
		return -1;

	/*
	 * Multiplex pins GPMC_AD4-7 to signals MMC1_DAT4-7 (Mode 1), in order
	 * to allow the use of 8-bit mode.
	 * U-Boot multiplexes only pins GPMC_AD0-3 to signals MMC1_DAT0-3.
	 */
	if (conf_gpmc_ad() < 0)
		bus_width = EXT_CSD_BUS_WIDTH_4;
	else
		bus_width = EXT_CSD_BUS_WIDTH_8;

	/* Reset the host controller. */
	set32(reg->SYSCONFIG, MMCHS_SD_SYSCONFIG_SOFTRESET,
		MMCHS_SD_SYSCONFIG_SOFTRESET);
	if (spin_until_set(reg->SYSSTATUS, MMCHS_SD_SYSSTATUS_RESETDONE)
		!= MMCHS_SD_SYSSTATUS_RESETDONE)
		return -1;

	/*
	 * SD_CAPA: "The host driver shall not modify this register after the
	 * initialization." (AM335x TRM)
	 */

	/*
	 * Set the bus voltage to 3V, and turn the bus power on.
	 * On the BeagleBone Black, the bus voltage is pulled up to 3.3V, but
	 * the MMCHS supports only 1.8V or 3V.
	 */
	set32(reg->HCTL, MMCHS_SD_HCTL_SDVS, MMCHS_SD_HCTL_SDVS_VS30);
	set32(reg->HCTL, MMCHS_SD_HCTL_SDBP, MMCHS_SD_HCTL_SDBP_ON);
	if (spin_until_set(reg->HCTL, MMCHS_SD_HCTL_SDBP)
		== MMCHS_SD_HCTL_SDBP_OFF)
		return -1;

	/* Set the bus clock frequency to FOD (400kHz). */
	set32(reg->SYSCTL, MMCHS_SD_SYSCTL_CLKD,
		MMCHS_SD_SYSCTL_CLKD_400KHZ << 6);

	/* Set data and busy time-out: ~2,6s @ 400kHz.*/
	set32(reg->SYSCTL, MMCHS_SD_SYSCTL_DTO, MMCHS_SD_SYSCTL_DTO_2POW20);

	/* Enable the internal clock. */
	set32(reg->SYSCTL, MMCHS_SD_SYSCTL_ICE, MMCHS_SD_SYSCTL_ICE_EN);
	if (spin_until_set(reg->SYSCTL, MMCHS_SD_SYSCTL_ICS)
		== MMCHS_SD_SYSCTL_ICS_UNSTABLE)
		return -1;

	/* Enable the bus clock. */
	set32(reg->SYSCTL, MMCHS_SD_SYSCTL_CEN, MMCHS_SD_SYSCTL_CEN_EN);

	/*
	 * Set the internal clock gating strategy to automatic, and enable
	 * Smart Idle mode. The host controller does not implement wake-up
	 * request (SWAKEUP pin is not connected).
	 */
	set32(reg->SYSCONFIG, MMCHS_SD_SYSCONFIG_AUTOIDLE,
		MMCHS_SD_SYSCONFIG_AUTOIDLE_EN);
	set32(reg->SYSCONFIG, MMCHS_SD_SYSCONFIG_SIDLEMODE,
		MMCHS_SD_SYSCONFIG_SIDLEMODE_IDLE);

	/* The driver reads and writes single 512B blocks. */
	set32(reg->BLK, MMCHS_SD_BLK_BLEN, SEC_SIZE);

	/* Enable interrupt status and requests. */
	write32(reg->IE, MMCHS_SD_IE_ERROR_MASK
		| MMCHS_SD_IE_BRR_ENABLE_ENABLE
		| MMCHS_SD_IE_BWR_ENABLE_ENABLE
		| MMCHS_SD_IE_TC_ENABLE_ENABLE
		| MMCHS_SD_IE_CC_ENABLE_ENABLE);
	write32(reg->ISE, MMCHS_SD_IE_ERROR_MASK
		| MMCHS_SD_IE_BRR_ENABLE_ENABLE
		| MMCHS_SD_IE_BWR_ENABLE_ENABLE
		| MMCHS_SD_IE_TC_ENABLE_ENABLE
		| MMCHS_SD_IE_CC_ENABLE_ENABLE);

	return 0;
}

/*
 * Interface to the MINIX block device driver.
 * Set the log level.
 */
static void
emmc_set_log_level(int level)
{
	log.log_level = level;
}


/*
 * Interface to the MINIX block device driver.
 * Unused, but declared in mmchost.h.
 */
#if 0
static int
emmc_host_reset(struct mmc_host *host)
{
	return 0;
}
#endif

/*
 * Interface to the MINIX block device driver.
 * Card detection.
 */
static int
emmc_card_detect(struct sd_slot *slot)
{
	/* The card is detected during card initialization. */
	return 1;
}

/*
 * Interface to the MINIX block device driver.
 * Card initialization. Also, finish the MMCHS initialization.
 * Return NULL on error.
 */
static struct sd_card *
emmc_card_initialize(struct sd_slot *slot)
{
	uint32_t clkd;

	/* CMD0 */
	if (go_idle_state() < 0)
		return NULL;

	/*
	 * Set the MMC_CMD line to open drain.
	 * "The host starts the card identification process in open-drain mode
	 * with the identification clock rate FOD." (MMCA, 4.41)
	 */
	set32(reg->CON, MMCHS_SD_CON_OD, MMCHS_SD_CON_OD_OD);

	/* CMD1 */
	if (repeat_send_op_cond() < 0)
		return NULL;

	/* CMD2. The driver has no use for the CID. */
	if (all_send_cid() < 0)
		return NULL;

	/* CMD3 */
	if (set_relative_addr() < 0)
		return NULL;

	/*
	 * Set the MMC_CMD line to push-pull.
	 * "When the card is in Stand-by State, communication over the CMD and
	 * DAT lines will be performed in push-pull mode." (MMCA, 4.41)
	 */
	set32(reg->CON, MMCHS_SD_CON_OD, MMCHS_SD_CON_OD_PP);

	/* CMD9 */
	if (send_csd() < 0)
		return NULL;
	card_csd[0] = read32(reg->RSP10);
	card_csd[1] = read32(reg->RSP32);
	card_csd[2] = read32(reg->RSP54);
	card_csd[3] = read32(reg->RSP76);

	/* Card capacity for cards up to 2GB of density. */
	card_size = (uint64_t)MMC_CSD_CAPACITY(card_csd)
		<< MMC_CSD_READ_BL_LEN(card_csd);

	card_write_protect = (SD_CSD_PERM_WRITE_PROTECT(card_csd)
		| SD_CSD_TMP_WRITE_PROTECT(card_csd));
	if (card_write_protect)
		log_info(&log, "the eMMC is write protected\n");

	/* CMD7 */
	if (select_card() < 0)
		return NULL;

	/* CMD8 */
	if (send_ext_csd() < 0)
		return NULL;
	/* Receive the Extended CSD register. */
	if (read_data((uint32_t *)card_ext_csd) < 0)
		return NULL;

	/* Card capacity for densities greater than 2GB. */
	if (MMC_EXT_CSD_SEC_COUNT > 0)
		card_size = (uint64_t)MMC_EXT_CSD_SEC_COUNT * SEC_SIZE;

	/* CMD6. Switch to high-speed mode: EXT_CSD[185] HS_TIMING = 1. */
	if (mmc_switch(MMC_SWITCH_MODE_WRITE_BYTE, EXT_CSD_HS_TIMING, 1) < 0)
		return NULL;
	/* Wait for the (optional) busy signal. */
	if (read_busy() < 0)
		return NULL;
	/* CMD13. Check the result of the SWITCH operation. */
	if (send_status() < 0)
		return NULL;

	/* Change the bus clock frequency. */
	if (MMC_EXT_CSD_CARD_TYPE & MMC_EXT_CSD_CARD_TYPE_HS_MMC_52MHZ)
		clkd = MMCHS_SD_SYSCTL_CLKD_52MHZ; /* 48 MHz */
	else
		clkd = MMCHS_SD_SYSCTL_CLKD_26MHZ; /* 24 MHz */
	if (set_bus_clkd(clkd) < 0)
		return NULL;

	/* Set data and busy time-out: ~ 2,8s @ 48MHz.*/
	set32(reg->SYSCTL, MMCHS_SD_SYSCTL_DTO, MMCHS_SD_SYSCTL_DTO_2POW27);

	/* CMD6. Set data bus width. */
	if (mmc_switch(MMC_SWITCH_MODE_WRITE_BYTE, EXT_CSD_BUS_WIDTH,
		bus_width) < 0)
		return NULL;
	/* Wait for the (optional) busy signal. */
	if (read_busy() < 0)
		return NULL;
	/* CMD13. Check the result of the SWITCH operation. */
	if (send_status() < 0)
		return NULL;

	/* Host controller: set data bus width. */
	if (bus_width == EXT_CSD_BUS_WIDTH_4)
		set32(reg->HCTL, MMCHS_SD_HCTL_DTW, MMCHS_SD_HCTL_DTW_4BIT);
	else
		set32(reg->CON, MMCHS_SD_CON_DW8, MMCHS_SD_CON_DW8_8BITS);

	/* CMD16. Set block length to sector size (512B). */
	if (set_blocklen() < 0)
		return NULL;

	/* Initialize the block device driver structures. */
	slot->card.blk_size  = SEC_SIZE;
	slot->card.blk_count = card_size / SEC_SIZE;
	slot->card.state     = SD_MODE_DATA_TRANSFER_MODE;
	slot->card.open_ct   = 0;
	memset(slot->card.part,    0, sizeof(slot->card.part));
	memset(slot->card.subpart, 0, sizeof(slot->card.subpart));
	slot->card.part[0].dv_size = card_size;

	return &(slot->card);
}

/*
 * Interface to the MINIX block device driver.
 * Card release.
 */
static int
emmc_card_release(struct sd_card *card)
{
	/* Decrements the "in-use count." */
	card->open_ct--;

	/*
	 * The block special file is closed, but the driver does not need to
	 * "release" the eMMC, even if the driver is unloaded.
	 */

	return 0;
}

/*
 * Interface to the MINIX block device driver.
 * Handle unexpected interrupts.
 */
static void
emmc_hw_intr(unsigned int irqs)
{
	log_warn(&log, "register SD_STAT == 0x%08x\n", reg->SD_STAT);
}

/*
 * Interface to the MINIX block device driver.
 * Read/write blocks.
 * Return the number of blocks read/written, or a negative integer on error.
 */
static int
emmc_read_write(int (*cim_read_write)(uint32_t, uint32_t *),
	uint32_t blknr, uint32_t count, unsigned char *buf)
{
	int blocks, r;
	uint32_t addr;

	blocks = 0; /* count of blocks read/written. */
	r = 0;
	while ((count > 0) && (r == 0)) {
		/*
		 * Data address for media =< 2GB is byte address, and data
		 * address for media > 2GB is sector address.
		 */
		if (card_size <= (2U << 30))
			addr = blknr * SEC_SIZE;
		else
			addr = blknr;

		r = (*cim_read_write)(addr, (uint32_t *)buf);
		if (r == 0) {
			blknr++;
			count--;
			buf += SEC_SIZE;
			blocks++;
		}
		else if (blocks == 0)
			blocks = r;
	}

	return blocks;
}

/*
 * Interface to the MINIX block device driver.
 * Read blocks.
 */
static int
emmc_read(struct sd_card *card,
	uint32_t blknr, uint32_t count, unsigned char *buf)
{
	return emmc_read_write(&cim_read_block, blknr, count, buf);
}

/*
 * Interface to the MINIX block device driver.
 * Write blocks.
 */
static int
emmc_write(struct sd_card *card,
	uint32_t blknr, uint32_t count, unsigned char *buf)
{
	if (card_write_protect)
		return -1; /* The card is write protected. */
	return emmc_read_write(&cim_write_block, blknr, count, buf);
}

/*
 * Interface to the MINIX block device driver.
 * Driver interface registration.
 */
void
host_initialize_host_structure_mmchs(struct mmc_host *host)
{
	uint32_t i;

	/* Register the driver interface at the block device driver. */
	host->host_set_instance = &emmc_host_set_instance;
	host->host_init =         &emmc_host_init;
	host->set_log_level =     &emmc_set_log_level;
	host->host_reset =        NULL;
	host->card_detect =       &emmc_card_detect;
	host->card_initialize =   &emmc_card_initialize;
	host->card_release =      &emmc_card_release;
	host->hw_intr =           &emmc_hw_intr;
	host->read =              &emmc_read;
	host->write =             &emmc_write;
	for (i=0; i<MAX_SD_SLOTS; i++) {
		host->slot[i].host = host;
		host->slot[i].card.state = SD_MODE_UNINITIALIZED;
		host->slot[i].card.slot = &host->slot[i];
	}
}

/*
 * Interface to the MINIX block device driver.
 * Unused, but declared in mmchost.h.
 */
void
host_initialize_host_structure_dummy(struct mmc_host *host)
{
}