Initial commit: Linux kernel 4.19 for Unplugged OS

This commit is contained in:
ziv committed 2025-10-06 13:52:42 +00:00
commit d30235b04c
80519 files changed
+35800681

No files matched your search

File diff suppressed because it is too large. Load diff
+117
View File
@@ -0,0 +1,117 @@
# SPDX-License-Identifier: GPL-2.0
#
# Makefile for MMC/SD host controller drivers
#
obj-$(CONFIG_MMC_ARMMMCI) += armmmci.o
armmmci-y := mmci.o
armmmci-$(CONFIG_MMC_QCOM_DML) += mmci_qcom_dml.o
obj-$(CONFIG_MMC_PXA) += pxamci.o
obj-$(CONFIG_MMC_MXC) += mxcmmc.o
obj-$(CONFIG_MMC_MXS) += mxs-mmc.o
obj-$(CONFIG_MMC_SDHCI) += sdhci.o
obj-$(CONFIG_MMC_SDHCI_PCI) += sdhci-pci.o
sdhci-pci-y += sdhci-pci-core.o sdhci-pci-o2micro.o sdhci-pci-arasan.o \
sdhci-pci-dwc-mshc.o
obj-$(subst m,y,$(CONFIG_MMC_SDHCI_PCI)) += sdhci-pci-data.o
obj-$(CONFIG_MMC_SDHCI_ACPI) += sdhci-acpi.o
obj-$(CONFIG_MMC_SDHCI_PXAV3) += sdhci-pxav3.o
obj-$(CONFIG_MMC_SDHCI_PXAV2) += sdhci-pxav2.o
obj-$(CONFIG_MMC_SDHCI_S3C) += sdhci-s3c.o
obj-$(CONFIG_MMC_SDHCI_SIRF) += sdhci-sirf.o
obj-$(CONFIG_MMC_SDHCI_F_SDH30) += sdhci_f_sdh30.o
obj-$(CONFIG_MMC_SDHCI_SPEAR) += sdhci-spear.o
obj-$(CONFIG_MMC_WBSD) += wbsd.o
obj-$(CONFIG_MMC_AU1X) += au1xmmc.o
obj-$(CONFIG_MMC_MTK) += mtk-sd.o mtk-sd-dbg.o
ccflags-y += -I$(srctree)/drivers/devfreq/
obj-$(CONFIG_MMC_MTK_SDIO) += mtk-sdio.o mtk-sdio-proc.o
obj-$(CONFIG_MMC_OMAP) += omap.o
obj-$(CONFIG_MMC_OMAP_HS) += omap_hsmmc.o
obj-$(CONFIG_MMC_ATMELMCI) += atmel-mci.o
obj-$(CONFIG_MMC_TIFM_SD) += tifm_sd.o
obj-$(CONFIG_MMC_MVSDIO) += mvsdio.o
obj-$(CONFIG_MMC_DAVINCI) += davinci_mmc.o
obj-$(CONFIG_MMC_GOLDFISH) += android-goldfish.o
obj-$(CONFIG_MMC_SPI) += mmc_spi.o
ifeq ($(CONFIG_OF),y)
obj-$(CONFIG_MMC_SPI) += of_mmc_spi.o
endif
obj-$(CONFIG_MMC_S3C) += s3cmci.o
obj-$(CONFIG_MMC_SDRICOH_CS) += sdricoh_cs.o
obj-$(CONFIG_MMC_TMIO) += tmio_mmc.o
obj-$(CONFIG_MMC_TMIO_CORE) += tmio_mmc_core.o
obj-$(CONFIG_MMC_SDHI) += renesas_sdhi_core.o
obj-$(CONFIG_MMC_SDHI_SYS_DMAC) += renesas_sdhi_sys_dmac.o
obj-$(CONFIG_MMC_SDHI_INTERNAL_DMAC) += renesas_sdhi_internal_dmac.o
obj-$(CONFIG_MMC_CB710) += cb710-mmc.o
obj-$(CONFIG_MMC_VIA_SDMMC) += via-sdmmc.o
octeon-mmc-objs := cavium.o cavium-octeon.o
obj-$(CONFIG_MMC_CAVIUM_OCTEON) += octeon-mmc.o
thunderx-mmc-objs := cavium.o cavium-thunderx.o
obj-$(CONFIG_MMC_CAVIUM_THUNDERX) += thunderx-mmc.o
obj-$(CONFIG_MMC_DW) += dw_mmc.o
obj-$(CONFIG_MMC_DW_PLTFM) += dw_mmc-pltfm.o
obj-$(CONFIG_MMC_DW_BLUEFIELD) += dw_mmc-bluefield.o
obj-$(CONFIG_MMC_DW_EXYNOS) += dw_mmc-exynos.o
obj-$(CONFIG_MMC_DW_HI3798CV200) += dw_mmc-hi3798cv200.o
obj-$(CONFIG_MMC_DW_K3) += dw_mmc-k3.o
obj-$(CONFIG_MMC_DW_PCI) += dw_mmc-pci.o
obj-$(CONFIG_MMC_DW_ROCKCHIP) += dw_mmc-rockchip.o
obj-$(CONFIG_MMC_DW_ZX) += dw_mmc-zx.o
obj-$(CONFIG_MMC_SH_MMCIF) += sh_mmcif.o
obj-$(CONFIG_MMC_JZ4740) += jz4740_mmc.o
obj-$(CONFIG_MMC_VUB300) += vub300.o
obj-$(CONFIG_MMC_USHC) += ushc.o
obj-$(CONFIG_MMC_WMT) += wmt-sdmmc.o
obj-$(CONFIG_MMC_MESON_GX) += meson-gx-mmc.o
obj-$(CONFIG_MMC_MESON_MX_SDIO) += meson-mx-sdio.o
obj-$(CONFIG_MMC_MOXART) += moxart-mmc.o
obj-$(CONFIG_MMC_SUNXI) += sunxi-mmc.o
obj-$(CONFIG_MMC_USDHI6ROL0) += usdhi6rol0.o
obj-$(CONFIG_MMC_TOSHIBA_PCI) += toshsd.o
obj-$(CONFIG_MMC_BCM2835) += bcm2835.o
obj-$(CONFIG_MMC_REALTEK_PCI) += rtsx_pci_sdmmc.o
obj-$(CONFIG_MMC_REALTEK_USB) += rtsx_usb_sdmmc.o
obj-$(CONFIG_MMC_SDHCI_PLTFM) += sdhci-pltfm.o
obj-$(CONFIG_MMC_SDHCI_CADENCE) += sdhci-cadence.o
obj-$(CONFIG_MMC_SDHCI_CNS3XXX) += sdhci-cns3xxx.o
obj-$(CONFIG_MMC_SDHCI_ESDHC_IMX) += sdhci-esdhc-imx.o
obj-$(CONFIG_MMC_SDHCI_DOVE) += sdhci-dove.o
obj-$(CONFIG_MMC_SDHCI_TEGRA) += sdhci-tegra.o
obj-$(CONFIG_MMC_SDHCI_OF_ARASAN) += sdhci-of-arasan.o
obj-$(CONFIG_MMC_SDHCI_OF_AT91) += sdhci-of-at91.o
obj-$(CONFIG_MMC_SDHCI_OF_ESDHC) += sdhci-of-esdhc.o
obj-$(CONFIG_MMC_SDHCI_OF_HLWD) += sdhci-of-hlwd.o
obj-$(CONFIG_MMC_SDHCI_OF_DWCMSHC) += sdhci-of-dwcmshc.o
obj-$(CONFIG_MMC_SDHCI_BCM_KONA) += sdhci-bcm-kona.o
obj-$(CONFIG_MMC_SDHCI_IPROC) += sdhci-iproc.o
obj-$(CONFIG_MMC_SDHCI_MSM) += sdhci-msm.o
obj-$(CONFIG_MMC_SDHCI_ST) += sdhci-st.o
obj-$(CONFIG_MMC_SDHCI_MICROCHIP_PIC32) += sdhci-pic32.o
obj-$(CONFIG_MMC_SDHCI_BRCMSTB) += sdhci-brcmstb.o
obj-$(CONFIG_MMC_SDHCI_OMAP) += sdhci-omap.o
obj-$(CONFIG_MMC_CQHCI) += cqhci-core.o
cqhci-core-y += cqhci.o
cqhci-core-$(CONFIG_MMC_CRYPTO) += cqhci-crypto.o
ifeq ($(CONFIG_CB710_DEBUG),y)
CFLAGS-cb710-mmc += -DDEBUG
endif
obj-$(CONFIG_MMC_MTK_PRO) += mediatek/
ifeq ($(CONFIG_MTK_EMMC_HW_CQ), y)
ccflags-y += -I$(srctree)/drivers/mmc/core
ccflags-y += -I$(srctree)/drivers/mmc/host/mediatek/ComboA
ccflags-y += -I$(srctree)/drivers/mmc/host/mediatek/ComboA/$(CONFIG_MTK_PLATFORM)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat/$(MTK_PLATFORM)/include
ccflags-y += -I$(srctree)/drivers/misc/mediatek/base/power/include
ccflags-y += -I$(srctree)/drivers/devfreq
obj-y += cmdq_hci.o
endif
ccflags-y += -I$(srctree)/drivers/char/rpmb/
obj-$(CONFIG_MMC_SDHCI_XENON) += sdhci-xenon-driver.o
sdhci-xenon-driver-y += sdhci-xenon.o sdhci-xenon-phy.o
+556
View File
@@ -0,0 +1,556 @@
/*
* Copyright 2007, Google Inc.
* Copyright 2012, Intel Inc.
*
* based on omap.c driver, which was
* Copyright (C) 2004 Nokia Corporation
* Written by Tuukka Tikkanen and Juha Yrjölä <juha.yrjola@nokia.com>
* Misc hacks here and there by Tony Lindgren <tony@atomide.com>
* Other hacks (DMA, SD, etc) by David Brownell
*
* 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/platform_device.h>
#include <linux/major.h>
#include <linux/types.h>
#include <linux/pci.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/hdreg.h>
#include <linux/kdev_t.h>
#include <linux/blkdev.h>
#include <linux/mutex.h>
#include <linux/scatterlist.h>
#include <linux/mmc/mmc.h>
#include <linux/mmc/sdio.h>
#include <linux/mmc/host.h>
#include <linux/mmc/card.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/ioport.h>
#include <linux/dma-mapping.h>
#include <linux/delay.h>
#include <linux/spinlock.h>
#include <linux/timer.h>
#include <linux/clk.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <asm/types.h>
#include <linux/uaccess.h>
#define DRIVER_NAME "goldfish_mmc"
#define BUFFER_SIZE 16384
#define GOLDFISH_MMC_READ(host, addr) (readl(host->reg_base + addr))
#define GOLDFISH_MMC_WRITE(host, addr, x) (writel(x, host->reg_base + addr))
enum {
/* status register */
MMC_INT_STATUS = 0x00,
/* set this to enable IRQ */
MMC_INT_ENABLE = 0x04,
/* set this to specify buffer address */
MMC_SET_BUFFER = 0x08,
/* MMC command number */
MMC_CMD = 0x0C,
/* MMC argument */
MMC_ARG = 0x10,
/* MMC response (or R2 bits 0 - 31) */
MMC_RESP_0 = 0x14,
/* MMC R2 response bits 32 - 63 */
MMC_RESP_1 = 0x18,
/* MMC R2 response bits 64 - 95 */
MMC_RESP_2 = 0x1C,
/* MMC R2 response bits 96 - 127 */
MMC_RESP_3 = 0x20,
MMC_BLOCK_LENGTH = 0x24,
MMC_BLOCK_COUNT = 0x28,
/* MMC state flags */
MMC_STATE = 0x2C,
/* MMC_INT_STATUS bits */
MMC_STAT_END_OF_CMD = 1U << 0,
MMC_STAT_END_OF_DATA = 1U << 1,
MMC_STAT_STATE_CHANGE = 1U << 2,
MMC_STAT_CMD_TIMEOUT = 1U << 3,
/* MMC_STATE bits */
MMC_STATE_INSERTED = 1U << 0,
MMC_STATE_READ_ONLY = 1U << 1,
};
/*
* Command types
*/
#define OMAP_MMC_CMDTYPE_BC 0
#define OMAP_MMC_CMDTYPE_BCR 1
#define OMAP_MMC_CMDTYPE_AC 2
#define OMAP_MMC_CMDTYPE_ADTC 3
struct goldfish_mmc_host {
struct mmc_request *mrq;
struct mmc_command *cmd;
struct mmc_data *data;
struct mmc_host *mmc;
struct device *dev;
unsigned char id; /* 16xx chips have 2 MMC blocks */
void *virt_base;
unsigned int phys_base;
int irq;
unsigned char bus_mode;
unsigned char hw_bus_mode;
unsigned int sg_len;
unsigned dma_done:1;
unsigned dma_in_use:1;
void __iomem *reg_base;
};
static inline int
goldfish_mmc_cover_is_open(struct goldfish_mmc_host *host)
{
return 0;
}
static ssize_t
goldfish_mmc_show_cover_switch(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct goldfish_mmc_host *host = dev_get_drvdata(dev);
return sprintf(buf, "%s\n", goldfish_mmc_cover_is_open(host) ? "open" :
"closed");
}
static DEVICE_ATTR(cover_switch, S_IRUGO, goldfish_mmc_show_cover_switch, NULL);
static void
goldfish_mmc_start_command(struct goldfish_mmc_host *host, struct mmc_command *cmd)
{
u32 cmdreg;
u32 resptype;
u32 cmdtype;
host->cmd = cmd;
resptype = 0;
cmdtype = 0;
/* Our hardware needs to know exact type */
switch (mmc_resp_type(cmd)) {
case MMC_RSP_NONE:
break;
case MMC_RSP_R1:
case MMC_RSP_R1B:
/* resp 1, 1b, 6, 7 */
resptype = 1;
break;
case MMC_RSP_R2:
resptype = 2;
break;
case MMC_RSP_R3:
resptype = 3;
break;
default:
dev_err(mmc_dev(host->mmc),
"Invalid response type: %04x\n", mmc_resp_type(cmd));
break;
}
if (mmc_cmd_type(cmd) == MMC_CMD_ADTC)
cmdtype = OMAP_MMC_CMDTYPE_ADTC;
else if (mmc_cmd_type(cmd) == MMC_CMD_BC)
cmdtype = OMAP_MMC_CMDTYPE_BC;
else if (mmc_cmd_type(cmd) == MMC_CMD_BCR)
cmdtype = OMAP_MMC_CMDTYPE_BCR;
else
cmdtype = OMAP_MMC_CMDTYPE_AC;
cmdreg = cmd->opcode | (resptype << 8) | (cmdtype << 12);
if (host->bus_mode == MMC_BUSMODE_OPENDRAIN)
cmdreg |= 1 << 6;
if (cmd->flags & MMC_RSP_BUSY)
cmdreg |= 1 << 11;
if (host->data && !(host->data->flags & MMC_DATA_WRITE))
cmdreg |= 1 << 15;
GOLDFISH_MMC_WRITE(host, MMC_ARG, cmd->arg);
GOLDFISH_MMC_WRITE(host, MMC_CMD, cmdreg);
}
static void goldfish_mmc_xfer_done(struct goldfish_mmc_host *host,
struct mmc_data *data)
{
if (host->dma_in_use) {
enum dma_data_direction dma_data_dir;
dma_data_dir = mmc_get_dma_dir(data);
if (dma_data_dir == DMA_FROM_DEVICE) {
/*
* We don't really have DMA, so we need
* to copy from our platform driver buffer
*/
sg_copy_from_buffer(data->sg, 1, host->virt_base,
data->sg->length);
}
host->data->bytes_xfered += data->sg->length;
dma_unmap_sg(mmc_dev(host->mmc), data->sg, host->sg_len,
dma_data_dir);
}
host->data = NULL;
host->sg_len = 0;
/*
* NOTE: MMC layer will sometimes poll-wait CMD13 next, issuing
* dozens of requests until the card finishes writing data.
* It'd be cheaper to just wait till an EOFB interrupt arrives...
*/
if (!data->stop) {
host->mrq = NULL;
mmc_request_done(host->mmc, data->mrq);
return;
}
goldfish_mmc_start_command(host, data->stop);
}
static void goldfish_mmc_end_of_data(struct goldfish_mmc_host *host,
struct mmc_data *data)
{
if (!host->dma_in_use) {
goldfish_mmc_xfer_done(host, data);
return;
}
if (host->dma_done)
goldfish_mmc_xfer_done(host, data);
}
static void goldfish_mmc_cmd_done(struct goldfish_mmc_host *host,
struct mmc_command *cmd)
{
host->cmd = NULL;
if (cmd->flags & MMC_RSP_PRESENT) {
if (cmd->flags & MMC_RSP_136) {
/* response type 2 */
cmd->resp[3] =
GOLDFISH_MMC_READ(host, MMC_RESP_0);
cmd->resp[2] =
GOLDFISH_MMC_READ(host, MMC_RESP_1);
cmd->resp[1] =
GOLDFISH_MMC_READ(host, MMC_RESP_2);
cmd->resp[0] =
GOLDFISH_MMC_READ(host, MMC_RESP_3);
} else {
/* response types 1, 1b, 3, 4, 5, 6 */
cmd->resp[0] =
GOLDFISH_MMC_READ(host, MMC_RESP_0);
}
}
if (host->data == NULL || cmd->error) {
host->mrq = NULL;
mmc_request_done(host->mmc, cmd->mrq);
}
}
static irqreturn_t goldfish_mmc_irq(int irq, void *dev_id)
{
struct goldfish_mmc_host *host = (struct goldfish_mmc_host *)dev_id;
u16 status;
int end_command = 0;
int end_transfer = 0;
int state_changed = 0;
int cmd_timeout = 0;
while ((status = GOLDFISH_MMC_READ(host, MMC_INT_STATUS)) != 0) {
GOLDFISH_MMC_WRITE(host, MMC_INT_STATUS, status);
if (status & MMC_STAT_END_OF_CMD)
end_command = 1;
if (status & MMC_STAT_END_OF_DATA)
end_transfer = 1;
if (status & MMC_STAT_STATE_CHANGE)
state_changed = 1;
if (status & MMC_STAT_CMD_TIMEOUT) {
end_command = 0;
cmd_timeout = 1;
}
}
if (cmd_timeout) {
struct mmc_request *mrq = host->mrq;
mrq->cmd->error = -ETIMEDOUT;
host->mrq = NULL;
mmc_request_done(host->mmc, mrq);
}
if (end_command)
goldfish_mmc_cmd_done(host, host->cmd);
if (end_transfer) {
host->dma_done = 1;
goldfish_mmc_end_of_data(host, host->data);
} else if (host->data != NULL) {
/*
* WORKAROUND -- after porting this driver from 2.6 to 3.4,
* during device initialization, cases where host->data is
* non-null but end_transfer is false would occur. Doing
* nothing in such cases results in no further interrupts,
* and initialization failure.
* TODO -- find the real cause.
*/
host->dma_done = 1;
goldfish_mmc_end_of_data(host, host->data);
}
if (state_changed) {
u32 state = GOLDFISH_MMC_READ(host, MMC_STATE);
pr_info("%s: Card detect now %d\n", __func__,
(state & MMC_STATE_INSERTED));
mmc_detect_change(host->mmc, 0);
}
if (!end_command && !end_transfer && !state_changed && !cmd_timeout) {
status = GOLDFISH_MMC_READ(host, MMC_INT_STATUS);
dev_info(mmc_dev(host->mmc),"spurious irq 0x%04x\n", status);
if (status != 0) {
GOLDFISH_MMC_WRITE(host, MMC_INT_STATUS, status);
GOLDFISH_MMC_WRITE(host, MMC_INT_ENABLE, 0);
}
}
return IRQ_HANDLED;
}
static void goldfish_mmc_prepare_data(struct goldfish_mmc_host *host,
struct mmc_request *req)
{
struct mmc_data *data = req->data;
int block_size;
unsigned sg_len;
enum dma_data_direction dma_data_dir;
host->data = data;
if (data == NULL) {
GOLDFISH_MMC_WRITE(host, MMC_BLOCK_LENGTH, 0);
GOLDFISH_MMC_WRITE(host, MMC_BLOCK_COUNT, 0);
host->dma_in_use = 0;
return;
}
block_size = data->blksz;
GOLDFISH_MMC_WRITE(host, MMC_BLOCK_COUNT, data->blocks - 1);
GOLDFISH_MMC_WRITE(host, MMC_BLOCK_LENGTH, block_size - 1);
/*
* Cope with calling layer confusion; it issues "single
* block" writes using multi-block scatterlists.
*/
sg_len = (data->blocks == 1) ? 1 : data->sg_len;
dma_data_dir = mmc_get_dma_dir(data);
host->sg_len = dma_map_sg(mmc_dev(host->mmc), data->sg,
sg_len, dma_data_dir);
host->dma_done = 0;
host->dma_in_use = 1;
if (dma_data_dir == DMA_TO_DEVICE) {
/*
* We don't really have DMA, so we need to copy to our
* platform driver buffer
*/
sg_copy_to_buffer(data->sg, 1, host->virt_base,
data->sg->length);
}
}
static void goldfish_mmc_request(struct mmc_host *mmc, struct mmc_request *req)
{
struct goldfish_mmc_host *host = mmc_priv(mmc);
WARN_ON(host->mrq != NULL);
host->mrq = req;
goldfish_mmc_prepare_data(host, req);
goldfish_mmc_start_command(host, req->cmd);
/*
* This is to avoid accidentally being detected as an SDIO card
* in mmc_attach_sdio().
*/
if (req->cmd->opcode == SD_IO_SEND_OP_COND &&
req->cmd->flags == (MMC_RSP_SPI_R4 | MMC_RSP_R4 | MMC_CMD_BCR))
req->cmd->error = -EINVAL;
}
static void goldfish_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
{
struct goldfish_mmc_host *host = mmc_priv(mmc);
host->bus_mode = ios->bus_mode;
host->hw_bus_mode = host->bus_mode;
}
static int goldfish_mmc_get_ro(struct mmc_host *mmc)
{
uint32_t state;
struct goldfish_mmc_host *host = mmc_priv(mmc);
state = GOLDFISH_MMC_READ(host, MMC_STATE);
return ((state & MMC_STATE_READ_ONLY) != 0);
}
static const struct mmc_host_ops goldfish_mmc_ops = {
.request = goldfish_mmc_request,
.set_ios = goldfish_mmc_set_ios,
.get_ro = goldfish_mmc_get_ro,
};
static int goldfish_mmc_probe(struct platform_device *pdev)
{
struct mmc_host *mmc;
struct goldfish_mmc_host *host = NULL;
struct resource *res;
int ret = 0;
int irq;
dma_addr_t buf_addr;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
irq = platform_get_irq(pdev, 0);
if (res == NULL || irq < 0)
return -ENXIO;
mmc = mmc_alloc_host(sizeof(struct goldfish_mmc_host), &pdev->dev);
if (mmc == NULL) {
ret = -ENOMEM;
goto err_alloc_host_failed;
}
host = mmc_priv(mmc);
host->mmc = mmc;
pr_err("mmc: Mapping %lX to %lX\n", (long)res->start, (long)res->end);
host->reg_base = ioremap(res->start, resource_size(res));
if (host->reg_base == NULL) {
ret = -ENOMEM;
goto ioremap_failed;
}
host->virt_base = dma_alloc_coherent(&pdev->dev, BUFFER_SIZE,
&buf_addr, GFP_KERNEL);
if (host->virt_base == 0) {
ret = -ENOMEM;
goto dma_alloc_failed;
}
host->phys_base = buf_addr;
host->id = pdev->id;
host->irq = irq;
mmc->ops = &goldfish_mmc_ops;
mmc->f_min = 400000;
mmc->f_max = 24000000;
mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
mmc->caps = MMC_CAP_4_BIT_DATA;
/* Use scatterlist DMA to reduce per-transfer costs.
* NOTE max_seg_size assumption that small blocks aren't
* normally used (except e.g. for reading SD registers).
*/
mmc->max_segs = 32;
mmc->max_blk_size = 2048; /* MMC_BLOCK_LENGTH is 11 bits (+1) */
mmc->max_blk_count = 2048; /* MMC_BLOCK_COUNT is 11 bits (+1) */
mmc->max_req_size = BUFFER_SIZE;
mmc->max_seg_size = mmc->max_req_size;
ret = request_irq(host->irq, goldfish_mmc_irq, 0, DRIVER_NAME, host);
if (ret) {
dev_err(&pdev->dev, "Failed IRQ Adding goldfish MMC\n");
goto err_request_irq_failed;
}
host->dev = &pdev->dev;
platform_set_drvdata(pdev, host);
ret = device_create_file(&pdev->dev, &dev_attr_cover_switch);
if (ret)
dev_warn(mmc_dev(host->mmc),
"Unable to create sysfs attributes\n");
GOLDFISH_MMC_WRITE(host, MMC_SET_BUFFER, host->phys_base);
GOLDFISH_MMC_WRITE(host, MMC_INT_ENABLE,
MMC_STAT_END_OF_CMD | MMC_STAT_END_OF_DATA |
MMC_STAT_STATE_CHANGE | MMC_STAT_CMD_TIMEOUT);
mmc_add_host(mmc);
return 0;
err_request_irq_failed:
dma_free_coherent(&pdev->dev, BUFFER_SIZE, host->virt_base,
host->phys_base);
dma_alloc_failed:
iounmap(host->reg_base);
ioremap_failed:
mmc_free_host(host->mmc);
err_alloc_host_failed:
return ret;
}
static int goldfish_mmc_remove(struct platform_device *pdev)
{
struct goldfish_mmc_host *host = platform_get_drvdata(pdev);
BUG_ON(host == NULL);
mmc_remove_host(host->mmc);
free_irq(host->irq, host);
dma_free_coherent(&pdev->dev, BUFFER_SIZE, host->virt_base, host->phys_base);
iounmap(host->reg_base);
mmc_free_host(host->mmc);
return 0;
}
static struct platform_driver goldfish_mmc_driver = {
.probe = goldfish_mmc_probe,
.remove = goldfish_mmc_remove,
.driver = {
.name = DRIVER_NAME,
},
};
module_platform_driver(goldfish_mmc_driver);
MODULE_LICENSE("GPL v2");
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+349
View File
@@ -0,0 +1,349 @@
/*
* Driver for MMC and SSD cards for Cavium OCTEON SOCs.
*
* This file is subject to the terms and conditions of the GNU General Public
* License. See the file "COPYING" in the main directory of this archive
* for more details.
*
* Copyright (C) 2012-2017 Cavium Inc.
*/
#include <linux/dma-mapping.h>
#include <linux/gpio/consumer.h>
#include <linux/interrupt.h>
#include <linux/mmc/mmc.h>
#include <linux/mmc/slot-gpio.h>
#include <linux/module.h>
#include <linux/of_platform.h>
#include <asm/octeon/octeon.h>
#include "cavium.h"
#define CVMX_MIO_BOOT_CTL CVMX_ADD_IO_SEG(0x00011800000000D0ull)
/*
* The l2c* functions below are used for the EMMC-17978 workaround.
*
* Due to a bug in the design of the MMC bus hardware, the 2nd to last
* cache block of a DMA read must be locked into the L2 Cache.
* Otherwise, data corruption may occur.
*/
static inline void *phys_to_ptr(u64 address)
{
return (void *)(address | (1ull << 63)); /* XKPHYS */
}
/*
* Lock a single line into L2. The line is zeroed before locking
* to make sure no dram accesses are made.
*/
static void l2c_lock_line(u64 addr)
{
char *addr_ptr = phys_to_ptr(addr);
asm volatile (
"cache 31, %[line]" /* Unlock the line */
::[line] "m" (*addr_ptr));
}
/* Unlock a single line in the L2 cache. */
static void l2c_unlock_line(u64 addr)
{
char *addr_ptr = phys_to_ptr(addr);
asm volatile (
"cache 23, %[line]" /* Unlock the line */
::[line] "m" (*addr_ptr));
}
/* Locks a memory region in the L2 cache. */
static void l2c_lock_mem_region(u64 start, u64 len)
{
u64 end;
/* Round start/end to cache line boundaries */
end = ALIGN(start + len - 1, CVMX_CACHE_LINE_SIZE);
start = ALIGN(start, CVMX_CACHE_LINE_SIZE);
while (start <= end) {
l2c_lock_line(start);
start += CVMX_CACHE_LINE_SIZE;
}
asm volatile("sync");
}
/* Unlock a memory region in the L2 cache. */
static void l2c_unlock_mem_region(u64 start, u64 len)
{
u64 end;
/* Round start/end to cache line boundaries */
end = ALIGN(start + len - 1, CVMX_CACHE_LINE_SIZE);
start = ALIGN(start, CVMX_CACHE_LINE_SIZE);
while (start <= end) {
l2c_unlock_line(start);
start += CVMX_CACHE_LINE_SIZE;
}
}
static void octeon_mmc_acquire_bus(struct cvm_mmc_host *host)
{
if (!host->has_ciu3) {
down(&octeon_bootbus_sem);
/* For CN70XX, switch the MMC controller onto the bus. */
if (OCTEON_IS_MODEL(OCTEON_CN70XX))
writeq(0, (void __iomem *)CVMX_MIO_BOOT_CTL);
} else {
down(&host->mmc_serializer);
}
}
static void octeon_mmc_release_bus(struct cvm_mmc_host *host)
{
if (!host->has_ciu3)
up(&octeon_bootbus_sem);
else
up(&host->mmc_serializer);
}
static void octeon_mmc_int_enable(struct cvm_mmc_host *host, u64 val)
{
writeq(val, host->base + MIO_EMM_INT(host));
if (!host->has_ciu3)
writeq(val, host->base + MIO_EMM_INT_EN(host));
}
static void octeon_mmc_set_shared_power(struct cvm_mmc_host *host, int dir)
{
if (dir == 0)
if (!atomic_dec_return(&host->shared_power_users))
gpiod_set_value_cansleep(host->global_pwr_gpiod, 0);
if (dir == 1)
if (atomic_inc_return(&host->shared_power_users) == 1)
gpiod_set_value_cansleep(host->global_pwr_gpiod, 1);
}
static void octeon_mmc_dmar_fixup(struct cvm_mmc_host *host,
struct mmc_command *cmd,
struct mmc_data *data,
u64 addr)
{
if (cmd->opcode != MMC_WRITE_MULTIPLE_BLOCK)
return;
if (data->blksz * data->blocks <= 1024)
return;
host->n_minus_one = addr + (data->blksz * data->blocks) - 1024;
l2c_lock_mem_region(host->n_minus_one, 512);
}
static void octeon_mmc_dmar_fixup_done(struct cvm_mmc_host *host)
{
if (!host->n_minus_one)
return;
l2c_unlock_mem_region(host->n_minus_one, 512);
host->n_minus_one = 0;
}
static int octeon_mmc_probe(struct platform_device *pdev)
{
struct device_node *cn, *node = pdev->dev.of_node;
struct cvm_mmc_host *host;
struct resource *res;
void __iomem *base;
int mmc_irq[9];
int i, ret = 0;
u64 val;
host = devm_kzalloc(&pdev->dev, sizeof(*host), GFP_KERNEL);
if (!host)
return -ENOMEM;
spin_lock_init(&host->irq_handler_lock);
sema_init(&host->mmc_serializer, 1);
host->dev = &pdev->dev;
host->acquire_bus = octeon_mmc_acquire_bus;
host->release_bus = octeon_mmc_release_bus;
host->int_enable = octeon_mmc_int_enable;
host->set_shared_power = octeon_mmc_set_shared_power;
if (OCTEON_IS_MODEL(OCTEON_CN6XXX) ||
OCTEON_IS_MODEL(OCTEON_CNF7XXX)) {
host->dmar_fixup = octeon_mmc_dmar_fixup;
host->dmar_fixup_done = octeon_mmc_dmar_fixup_done;
}
host->sys_freq = octeon_get_io_clock_rate();
if (of_device_is_compatible(node, "cavium,octeon-7890-mmc")) {
host->big_dma_addr = true;
host->need_irq_handler_lock = true;
host->has_ciu3 = true;
host->use_sg = true;
/*
* First seven are the EMM_INT bits 0..6, then two for
* the EMM_DMA_INT bits
*/
for (i = 0; i < 9; i++) {
mmc_irq[i] = platform_get_irq(pdev, i);
if (mmc_irq[i] < 0)
return mmc_irq[i];
/* work around legacy u-boot device trees */
irq_set_irq_type(mmc_irq[i], IRQ_TYPE_EDGE_RISING);
}
} else {
host->big_dma_addr = false;
host->need_irq_handler_lock = false;
host->has_ciu3 = false;
/* First one is EMM second DMA */
for (i = 0; i < 2; i++) {
mmc_irq[i] = platform_get_irq(pdev, i);
if (mmc_irq[i] < 0)
return mmc_irq[i];
}
}
host->last_slot = -1;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev, "Platform resource[0] is missing\n");
return -ENXIO;
}
base = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(base))
return PTR_ERR(base);
host->base = (void __iomem *)base;
host->reg_off = 0;
res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
if (!res) {
dev_err(&pdev->dev, "Platform resource[1] is missing\n");
return -EINVAL;
}
base = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(base))
return PTR_ERR(base);
host->dma_base = (void __iomem *)base;
/*
* To keep the register addresses shared we intentionaly use
* a negative offset here, first register used on Octeon therefore
* starts at 0x20 (MIO_EMM_DMA_CFG).
*/
host->reg_off_dma = -0x20;
ret = dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
if (ret)
return ret;
/*
* Clear out any pending interrupts that may be left over from
* bootloader.
*/
val = readq(host->base + MIO_EMM_INT(host));
writeq(val, host->base + MIO_EMM_INT(host));
if (host->has_ciu3) {
/* Only CMD_DONE, DMA_DONE, CMD_ERR, DMA_ERR */
for (i = 1; i <= 4; i++) {
ret = devm_request_irq(&pdev->dev, mmc_irq[i],
cvm_mmc_interrupt,
0, cvm_mmc_irq_names[i], host);
if (ret < 0) {
dev_err(&pdev->dev, "Error: devm_request_irq %d\n",
mmc_irq[i]);
return ret;
}
}
} else {
ret = devm_request_irq(&pdev->dev, mmc_irq[0],
cvm_mmc_interrupt, 0, KBUILD_MODNAME,
host);
if (ret < 0) {
dev_err(&pdev->dev, "Error: devm_request_irq %d\n",
mmc_irq[0]);
return ret;
}
}
host->global_pwr_gpiod = devm_gpiod_get_optional(&pdev->dev,
"power",
GPIOD_OUT_HIGH);
if (IS_ERR(host->global_pwr_gpiod)) {
dev_err(&pdev->dev, "Invalid power GPIO\n");
return PTR_ERR(host->global_pwr_gpiod);
}
platform_set_drvdata(pdev, host);
i = 0;
for_each_child_of_node(node, cn) {
host->slot_pdev[i] =
of_platform_device_create(cn, NULL, &pdev->dev);
if (!host->slot_pdev[i]) {
i++;
continue;
}
ret = cvm_mmc_of_slot_probe(&host->slot_pdev[i]->dev, host);
if (ret) {
dev_err(&pdev->dev, "Error populating slots\n");
octeon_mmc_set_shared_power(host, 0);
goto error;
}
i++;
}
return 0;
error:
for (i = 0; i < CAVIUM_MAX_MMC; i++) {
if (host->slot[i])
cvm_mmc_of_slot_remove(host->slot[i]);
if (host->slot_pdev[i])
of_platform_device_destroy(&host->slot_pdev[i]->dev, NULL);
}
return ret;
}
static int octeon_mmc_remove(struct platform_device *pdev)
{
struct cvm_mmc_host *host = platform_get_drvdata(pdev);
u64 dma_cfg;
int i;
for (i = 0; i < CAVIUM_MAX_MMC; i++)
if (host->slot[i])
cvm_mmc_of_slot_remove(host->slot[i]);
dma_cfg = readq(host->dma_base + MIO_EMM_DMA_CFG(host));
dma_cfg &= ~MIO_EMM_DMA_CFG_EN;
writeq(dma_cfg, host->dma_base + MIO_EMM_DMA_CFG(host));
octeon_mmc_set_shared_power(host, 0);
return 0;
}
static const struct of_device_id octeon_mmc_match[] = {
{
.compatible = "cavium,octeon-6130-mmc",
},
{
.compatible = "cavium,octeon-7890-mmc",
},
{},
};
MODULE_DEVICE_TABLE(of, octeon_mmc_match);
static struct platform_driver octeon_mmc_driver = {
.probe = octeon_mmc_probe,
.remove = octeon_mmc_remove,
.driver = {
.name = KBUILD_MODNAME,
.of_match_table = octeon_mmc_match,
},
};
module_platform_driver(octeon_mmc_driver);
MODULE_AUTHOR("Cavium Inc. <support@cavium.com>");
MODULE_DESCRIPTION("Low-level driver for Cavium OCTEON MMC/SSD card");
MODULE_LICENSE("GPL");
+197
View File
@@ -0,0 +1,197 @@
/*
* Driver for MMC and SSD cards for Cavium ThunderX SOCs.
*
* This file is subject to the terms and conditions of the GNU General Public
* License. See the file "COPYING" in the main directory of this archive
* for more details.
*
* Copyright (C) 2016 Cavium Inc.
*/
#include <linux/device.h>
#include <linux/dma-mapping.h>
#include <linux/interrupt.h>
#include <linux/mmc/mmc.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/pci.h>
#include "cavium.h"
static void thunder_mmc_acquire_bus(struct cvm_mmc_host *host)
{
down(&host->mmc_serializer);
}
static void thunder_mmc_release_bus(struct cvm_mmc_host *host)
{
up(&host->mmc_serializer);
}
static void thunder_mmc_int_enable(struct cvm_mmc_host *host, u64 val)
{
writeq(val, host->base + MIO_EMM_INT(host));
writeq(val, host->base + MIO_EMM_INT_EN_SET(host));
}
static int thunder_mmc_register_interrupts(struct cvm_mmc_host *host,
struct pci_dev *pdev)
{
int nvec, ret, i;
nvec = pci_alloc_irq_vectors(pdev, 1, 9, PCI_IRQ_MSIX);
if (nvec < 0)
return nvec;
/* register interrupts */
for (i = 0; i < nvec; i++) {
ret = devm_request_irq(&pdev->dev, pci_irq_vector(pdev, i),
cvm_mmc_interrupt,
0, cvm_mmc_irq_names[i], host);
if (ret)
return ret;
}
return 0;
}
static int thunder_mmc_probe(struct pci_dev *pdev,
const struct pci_device_id *id)
{
struct device_node *node = pdev->dev.of_node;
struct device *dev = &pdev->dev;
struct device_node *child_node;
struct cvm_mmc_host *host;
int ret, i = 0;
host = devm_kzalloc(dev, sizeof(*host), GFP_KERNEL);
if (!host)
return -ENOMEM;
pci_set_drvdata(pdev, host);
ret = pcim_enable_device(pdev);
if (ret)
return ret;
ret = pci_request_regions(pdev, KBUILD_MODNAME);
if (ret)
return ret;
host->base = pcim_iomap(pdev, 0, pci_resource_len(pdev, 0));
if (!host->base)
return -EINVAL;
/* On ThunderX these are identical */
host->dma_base = host->base;
host->reg_off = 0x2000;
host->reg_off_dma = 0x160;
host->clk = devm_clk_get(dev, NULL);
if (IS_ERR(host->clk))
return PTR_ERR(host->clk);
ret = clk_prepare_enable(host->clk);
if (ret)
return ret;
host->sys_freq = clk_get_rate(host->clk);
spin_lock_init(&host->irq_handler_lock);
sema_init(&host->mmc_serializer, 1);
host->dev = dev;
host->acquire_bus = thunder_mmc_acquire_bus;
host->release_bus = thunder_mmc_release_bus;
host->int_enable = thunder_mmc_int_enable;
host->use_sg = true;
host->big_dma_addr = true;
host->need_irq_handler_lock = true;
host->last_slot = -1;
ret = dma_set_mask(dev, DMA_BIT_MASK(48));
if (ret)
goto error;
/*
* Clear out any pending interrupts that may be left over from
* bootloader. Writing 1 to the bits clears them.
*/
writeq(127, host->base + MIO_EMM_INT_EN(host));
writeq(3, host->base + MIO_EMM_DMA_INT_ENA_W1C(host));
/* Clear DMA FIFO */
writeq(BIT_ULL(16), host->base + MIO_EMM_DMA_FIFO_CFG(host));
ret = thunder_mmc_register_interrupts(host, pdev);
if (ret)
goto error;
for_each_child_of_node(node, child_node) {
/*
* mmc_of_parse and devm* require one device per slot.
* Create a dummy device per slot and set the node pointer to
* the slot. The easiest way to get this is using
* of_platform_device_create.
*/
if (of_device_is_compatible(child_node, "mmc-slot")) {
host->slot_pdev[i] = of_platform_device_create(child_node, NULL,
&pdev->dev);
if (!host->slot_pdev[i])
continue;
ret = cvm_mmc_of_slot_probe(&host->slot_pdev[i]->dev, host);
if (ret)
goto error;
}
i++;
}
dev_info(dev, "probed\n");
return 0;
error:
for (i = 0; i < CAVIUM_MAX_MMC; i++) {
if (host->slot[i])
cvm_mmc_of_slot_remove(host->slot[i]);
if (host->slot_pdev[i]) {
get_device(&host->slot_pdev[i]->dev);
of_platform_device_destroy(&host->slot_pdev[i]->dev, NULL);
put_device(&host->slot_pdev[i]->dev);
}
}
clk_disable_unprepare(host->clk);
return ret;
}
static void thunder_mmc_remove(struct pci_dev *pdev)
{
struct cvm_mmc_host *host = pci_get_drvdata(pdev);
u64 dma_cfg;
int i;
for (i = 0; i < CAVIUM_MAX_MMC; i++)
if (host->slot[i])
cvm_mmc_of_slot_remove(host->slot[i]);
dma_cfg = readq(host->dma_base + MIO_EMM_DMA_CFG(host));
dma_cfg &= ~MIO_EMM_DMA_CFG_EN;
writeq(dma_cfg, host->dma_base + MIO_EMM_DMA_CFG(host));
clk_disable_unprepare(host->clk);
}
static const struct pci_device_id thunder_mmc_id_table[] = {
{ PCI_DEVICE(PCI_VENDOR_ID_CAVIUM, 0xa010) },
{ 0, } /* end of table */
};
static struct pci_driver thunder_mmc_driver = {
.name = KBUILD_MODNAME,
.id_table = thunder_mmc_id_table,
.probe = thunder_mmc_probe,
.remove = thunder_mmc_remove,
};
module_pci_driver(thunder_mmc_driver);
MODULE_AUTHOR("Cavium Inc.");
MODULE_DESCRIPTION("Cavium ThunderX eMMC Driver");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(pci, thunder_mmc_id_table);
File diff suppressed because it is too large. Load diff
+215
View File
@@ -0,0 +1,215 @@
/*
* Driver for MMC and SSD cards for Cavium OCTEON and ThunderX SOCs.
*
* This file is subject to the terms and conditions of the GNU General Public
* License. See the file "COPYING" in the main directory of this archive
* for more details.
*
* Copyright (C) 2012-2017 Cavium Inc.
*/
#ifndef _CAVIUM_MMC_H_
#define _CAVIUM_MMC_H_
#include <linux/bitops.h>
#include <linux/clk.h>
#include <linux/gpio/consumer.h>
#include <linux/io.h>
#include <linux/mmc/host.h>
#include <linux/of.h>
#include <linux/scatterlist.h>
#include <linux/semaphore.h>
#define CAVIUM_MAX_MMC 4
/* DMA register addresses */
#define MIO_EMM_DMA_FIFO_CFG(x) (0x00 + x->reg_off_dma)
#define MIO_EMM_DMA_FIFO_ADR(x) (0x10 + x->reg_off_dma)
#define MIO_EMM_DMA_FIFO_CMD(x) (0x18 + x->reg_off_dma)
#define MIO_EMM_DMA_CFG(x) (0x20 + x->reg_off_dma)
#define MIO_EMM_DMA_ADR(x) (0x28 + x->reg_off_dma)
#define MIO_EMM_DMA_INT(x) (0x30 + x->reg_off_dma)
#define MIO_EMM_DMA_INT_W1S(x) (0x38 + x->reg_off_dma)
#define MIO_EMM_DMA_INT_ENA_W1S(x) (0x40 + x->reg_off_dma)
#define MIO_EMM_DMA_INT_ENA_W1C(x) (0x48 + x->reg_off_dma)
/* register addresses */
#define MIO_EMM_CFG(x) (0x00 + x->reg_off)
#define MIO_EMM_SWITCH(x) (0x48 + x->reg_off)
#define MIO_EMM_DMA(x) (0x50 + x->reg_off)
#define MIO_EMM_CMD(x) (0x58 + x->reg_off)
#define MIO_EMM_RSP_STS(x) (0x60 + x->reg_off)
#define MIO_EMM_RSP_LO(x) (0x68 + x->reg_off)
#define MIO_EMM_RSP_HI(x) (0x70 + x->reg_off)
#define MIO_EMM_INT(x) (0x78 + x->reg_off)
#define MIO_EMM_INT_EN(x) (0x80 + x->reg_off)
#define MIO_EMM_WDOG(x) (0x88 + x->reg_off)
#define MIO_EMM_SAMPLE(x) (0x90 + x->reg_off)
#define MIO_EMM_STS_MASK(x) (0x98 + x->reg_off)
#define MIO_EMM_RCA(x) (0xa0 + x->reg_off)
#define MIO_EMM_INT_EN_SET(x) (0xb0 + x->reg_off)
#define MIO_EMM_INT_EN_CLR(x) (0xb8 + x->reg_off)
#define MIO_EMM_BUF_IDX(x) (0xe0 + x->reg_off)
#define MIO_EMM_BUF_DAT(x) (0xe8 + x->reg_off)
struct cvm_mmc_host {
struct device *dev;
void __iomem *base;
void __iomem *dma_base;
int reg_off;
int reg_off_dma;
u64 emm_cfg;
u64 n_minus_one; /* OCTEON II workaround location */
int last_slot;
struct clk *clk;
int sys_freq;
struct mmc_request *current_req;
struct sg_mapping_iter smi;
bool dma_active;
bool use_sg;
bool has_ciu3;
bool big_dma_addr;
bool need_irq_handler_lock;
spinlock_t irq_handler_lock;
struct semaphore mmc_serializer;
struct gpio_desc *global_pwr_gpiod;
atomic_t shared_power_users;
struct cvm_mmc_slot *slot[CAVIUM_MAX_MMC];
struct platform_device *slot_pdev[CAVIUM_MAX_MMC];
void (*set_shared_power)(struct cvm_mmc_host *, int);
void (*acquire_bus)(struct cvm_mmc_host *);
void (*release_bus)(struct cvm_mmc_host *);
void (*int_enable)(struct cvm_mmc_host *, u64);
/* required on some MIPS models */
void (*dmar_fixup)(struct cvm_mmc_host *, struct mmc_command *,
struct mmc_data *, u64);
void (*dmar_fixup_done)(struct cvm_mmc_host *);
};
struct cvm_mmc_slot {
struct mmc_host *mmc; /* slot-level mmc_core object */
struct cvm_mmc_host *host; /* common hw for all slots */
u64 clock;
u64 cached_switch;
u64 cached_rca;
unsigned int cmd_cnt; /* sample delay */
unsigned int dat_cnt; /* sample delay */
int bus_id;
};
struct cvm_mmc_cr_type {
u8 ctype;
u8 rtype;
};
struct cvm_mmc_cr_mods {
u8 ctype_xor;
u8 rtype_xor;
};
/* Bitfield definitions */
#define MIO_EMM_DMA_FIFO_CFG_CLR BIT_ULL(16)
#define MIO_EMM_DMA_FIFO_CFG_INT_LVL GENMASK_ULL(12, 8)
#define MIO_EMM_DMA_FIFO_CFG_COUNT GENMASK_ULL(4, 0)
#define MIO_EMM_DMA_FIFO_CMD_RW BIT_ULL(62)
#define MIO_EMM_DMA_FIFO_CMD_INTDIS BIT_ULL(60)
#define MIO_EMM_DMA_FIFO_CMD_SWAP32 BIT_ULL(59)
#define MIO_EMM_DMA_FIFO_CMD_SWAP16 BIT_ULL(58)
#define MIO_EMM_DMA_FIFO_CMD_SWAP8 BIT_ULL(57)
#define MIO_EMM_DMA_FIFO_CMD_ENDIAN BIT_ULL(56)
#define MIO_EMM_DMA_FIFO_CMD_SIZE GENMASK_ULL(55, 36)
#define MIO_EMM_CMD_SKIP_BUSY BIT_ULL(62)
#define MIO_EMM_CMD_BUS_ID GENMASK_ULL(61, 60)
#define MIO_EMM_CMD_VAL BIT_ULL(59)
#define MIO_EMM_CMD_DBUF BIT_ULL(55)
#define MIO_EMM_CMD_OFFSET GENMASK_ULL(54, 49)
#define MIO_EMM_CMD_CTYPE_XOR GENMASK_ULL(42, 41)
#define MIO_EMM_CMD_RTYPE_XOR GENMASK_ULL(40, 38)
#define MIO_EMM_CMD_IDX GENMASK_ULL(37, 32)
#define MIO_EMM_CMD_ARG GENMASK_ULL(31, 0)
#define MIO_EMM_DMA_SKIP_BUSY BIT_ULL(62)
#define MIO_EMM_DMA_BUS_ID GENMASK_ULL(61, 60)
#define MIO_EMM_DMA_VAL BIT_ULL(59)
#define MIO_EMM_DMA_SECTOR BIT_ULL(58)
#define MIO_EMM_DMA_DAT_NULL BIT_ULL(57)
#define MIO_EMM_DMA_THRES GENMASK_ULL(56, 51)
#define MIO_EMM_DMA_REL_WR BIT_ULL(50)
#define MIO_EMM_DMA_RW BIT_ULL(49)
#define MIO_EMM_DMA_MULTI BIT_ULL(48)
#define MIO_EMM_DMA_BLOCK_CNT GENMASK_ULL(47, 32)
#define MIO_EMM_DMA_CARD_ADDR GENMASK_ULL(31, 0)
#define MIO_EMM_DMA_CFG_EN BIT_ULL(63)
#define MIO_EMM_DMA_CFG_RW BIT_ULL(62)
#define MIO_EMM_DMA_CFG_CLR BIT_ULL(61)
#define MIO_EMM_DMA_CFG_SWAP32 BIT_ULL(59)
#define MIO_EMM_DMA_CFG_SWAP16 BIT_ULL(58)
#define MIO_EMM_DMA_CFG_SWAP8 BIT_ULL(57)
#define MIO_EMM_DMA_CFG_ENDIAN BIT_ULL(56)
#define MIO_EMM_DMA_CFG_SIZE GENMASK_ULL(55, 36)
#define MIO_EMM_DMA_CFG_ADR GENMASK_ULL(35, 0)
#define MIO_EMM_INT_SWITCH_ERR BIT_ULL(6)
#define MIO_EMM_INT_SWITCH_DONE BIT_ULL(5)
#define MIO_EMM_INT_DMA_ERR BIT_ULL(4)
#define MIO_EMM_INT_CMD_ERR BIT_ULL(3)
#define MIO_EMM_INT_DMA_DONE BIT_ULL(2)
#define MIO_EMM_INT_CMD_DONE BIT_ULL(1)
#define MIO_EMM_INT_BUF_DONE BIT_ULL(0)
#define MIO_EMM_RSP_STS_BUS_ID GENMASK_ULL(61, 60)
#define MIO_EMM_RSP_STS_CMD_VAL BIT_ULL(59)
#define MIO_EMM_RSP_STS_SWITCH_VAL BIT_ULL(58)
#define MIO_EMM_RSP_STS_DMA_VAL BIT_ULL(57)
#define MIO_EMM_RSP_STS_DMA_PEND BIT_ULL(56)
#define MIO_EMM_RSP_STS_DBUF_ERR BIT_ULL(28)
#define MIO_EMM_RSP_STS_DBUF BIT_ULL(23)
#define MIO_EMM_RSP_STS_BLK_TIMEOUT BIT_ULL(22)
#define MIO_EMM_RSP_STS_BLK_CRC_ERR BIT_ULL(21)
#define MIO_EMM_RSP_STS_RSP_BUSYBIT BIT_ULL(20)
#define MIO_EMM_RSP_STS_STP_TIMEOUT BIT_ULL(19)
#define MIO_EMM_RSP_STS_STP_CRC_ERR BIT_ULL(18)
#define MIO_EMM_RSP_STS_STP_BAD_STS BIT_ULL(17)
#define MIO_EMM_RSP_STS_STP_VAL BIT_ULL(16)
#define MIO_EMM_RSP_STS_RSP_TIMEOUT BIT_ULL(15)
#define MIO_EMM_RSP_STS_RSP_CRC_ERR BIT_ULL(14)
#define MIO_EMM_RSP_STS_RSP_BAD_STS BIT_ULL(13)
#define MIO_EMM_RSP_STS_RSP_VAL BIT_ULL(12)
#define MIO_EMM_RSP_STS_RSP_TYPE GENMASK_ULL(11, 9)
#define MIO_EMM_RSP_STS_CMD_TYPE GENMASK_ULL(8, 7)
#define MIO_EMM_RSP_STS_CMD_IDX GENMASK_ULL(6, 1)
#define MIO_EMM_RSP_STS_CMD_DONE BIT_ULL(0)
#define MIO_EMM_SAMPLE_CMD_CNT GENMASK_ULL(25, 16)
#define MIO_EMM_SAMPLE_DAT_CNT GENMASK_ULL(9, 0)
#define MIO_EMM_SWITCH_BUS_ID GENMASK_ULL(61, 60)
#define MIO_EMM_SWITCH_EXE BIT_ULL(59)
#define MIO_EMM_SWITCH_ERR0 BIT_ULL(58)
#define MIO_EMM_SWITCH_ERR1 BIT_ULL(57)
#define MIO_EMM_SWITCH_ERR2 BIT_ULL(56)
#define MIO_EMM_SWITCH_HS_TIMING BIT_ULL(48)
#define MIO_EMM_SWITCH_BUS_WIDTH GENMASK_ULL(42, 40)
#define MIO_EMM_SWITCH_POWER_CLASS GENMASK_ULL(35, 32)
#define MIO_EMM_SWITCH_CLK_HI GENMASK_ULL(31, 16)
#define MIO_EMM_SWITCH_CLK_LO GENMASK_ULL(15, 0)
/* Protoypes */
irqreturn_t cvm_mmc_interrupt(int irq, void *dev_id);
int cvm_mmc_of_slot_probe(struct device *dev, struct cvm_mmc_host *host);
int cvm_mmc_of_slot_remove(struct cvm_mmc_slot *slot);
extern const char *cvm_mmc_irq_names[];
#endif
+780
View File
@@ -0,0 +1,780 @@
/*
* cb710/mmc.c
*
* Copyright by Michał Mirosław, 2008-2009
*
* 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/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/delay.h>
#include "cb710-mmc.h"
static const u8 cb710_clock_divider_log2[8] = {
/* 1, 2, 4, 8, 16, 32, 128, 512 */
0, 1, 2, 3, 4, 5, 7, 9
};
#define CB710_MAX_DIVIDER_IDX \
(ARRAY_SIZE(cb710_clock_divider_log2) - 1)
static const u8 cb710_src_freq_mhz[16] = {
33, 10, 20, 25, 30, 35, 40, 45,
50, 55, 60, 65, 70, 75, 80, 85
};
static void cb710_mmc_select_clock_divider(struct mmc_host *mmc, int hz)
{
struct cb710_slot *slot = cb710_mmc_to_slot(mmc);
struct pci_dev *pdev = cb710_slot_to_chip(slot)->pdev;
u32 src_freq_idx;
u32 divider_idx;
int src_hz;
/* on CB710 in HP nx9500:
* src_freq_idx == 0
* indexes 1-7 work as written in the table
* indexes 0,8-15 give no clock output
*/
pci_read_config_dword(pdev, 0x48, &src_freq_idx);
src_freq_idx = (src_freq_idx >> 16) & 0xF;
src_hz = cb710_src_freq_mhz[src_freq_idx] * 1000000;
for (divider_idx = 0; divider_idx < CB710_MAX_DIVIDER_IDX; ++divider_idx) {
if (hz >= src_hz >> cb710_clock_divider_log2[divider_idx])
break;
}
if (src_freq_idx)
divider_idx |= 0x8;
else if (divider_idx == 0)
divider_idx = 1;
cb710_pci_update_config_reg(pdev, 0x40, ~0xF0000000, divider_idx << 28);
dev_dbg(cb710_slot_dev(slot),
"clock set to %d Hz, wanted %d Hz; src_freq_idx = %d, divider_idx = %d|%d\n",
src_hz >> cb710_clock_divider_log2[divider_idx & 7],
hz, src_freq_idx, divider_idx & 7, divider_idx & 8);
}
static void __cb710_mmc_enable_irq(struct cb710_slot *slot,
unsigned short enable, unsigned short mask)
{
/* clear global IE
* - it gets set later if any interrupt sources are enabled */
mask |= CB710_MMC_IE_IRQ_ENABLE;
/* look like interrupt is fired whenever
* WORD[0x0C] & WORD[0x10] != 0;
* -> bit 15 port 0x0C seems to be global interrupt enable
*/
enable = (cb710_read_port_16(slot, CB710_MMC_IRQ_ENABLE_PORT)
& ~mask) | enable;
if (enable)
enable |= CB710_MMC_IE_IRQ_ENABLE;
cb710_write_port_16(slot, CB710_MMC_IRQ_ENABLE_PORT, enable);
}
static void cb710_mmc_enable_irq(struct cb710_slot *slot,
unsigned short enable, unsigned short mask)
{
struct cb710_mmc_reader *reader = mmc_priv(cb710_slot_to_mmc(slot));
unsigned long flags;
spin_lock_irqsave(&reader->irq_lock, flags);
/* this is the only thing irq_lock protects */
__cb710_mmc_enable_irq(slot, enable, mask);
spin_unlock_irqrestore(&reader->irq_lock, flags);
}
static void cb710_mmc_reset_events(struct cb710_slot *slot)
{
cb710_write_port_8(slot, CB710_MMC_STATUS0_PORT, 0xFF);
cb710_write_port_8(slot, CB710_MMC_STATUS1_PORT, 0xFF);
cb710_write_port_8(slot, CB710_MMC_STATUS2_PORT, 0xFF);
}
static void cb710_mmc_enable_4bit_data(struct cb710_slot *slot, int enable)
{
if (enable)
cb710_modify_port_8(slot, CB710_MMC_CONFIG1_PORT,
CB710_MMC_C1_4BIT_DATA_BUS, 0);
else
cb710_modify_port_8(slot, CB710_MMC_CONFIG1_PORT,
0, CB710_MMC_C1_4BIT_DATA_BUS);
}
static int cb710_check_event(struct cb710_slot *slot, u8 what)
{
u16 status;
status = cb710_read_port_16(slot, CB710_MMC_STATUS_PORT);
if (status & CB710_MMC_S0_FIFO_UNDERFLOW) {
/* it is just a guess, so log it */
dev_dbg(cb710_slot_dev(slot),
"CHECK : ignoring bit 6 in status %04X\n", status);
cb710_write_port_8(slot, CB710_MMC_STATUS0_PORT,
CB710_MMC_S0_FIFO_UNDERFLOW);
status &= ~CB710_MMC_S0_FIFO_UNDERFLOW;
}
if (status & CB710_MMC_STATUS_ERROR_EVENTS) {
dev_dbg(cb710_slot_dev(slot),
"CHECK : returning EIO on status %04X\n", status);
cb710_write_port_8(slot, CB710_MMC_STATUS0_PORT, status & 0xFF);
cb710_write_port_8(slot, CB710_MMC_STATUS1_PORT,
CB710_MMC_S1_RESET);
return -EIO;
}
/* 'what' is a bit in MMC_STATUS1 */
if ((status >> 8) & what) {
cb710_write_port_8(slot, CB710_MMC_STATUS1_PORT, what);
return 1;
}
return 0;
}
static int cb710_wait_for_event(struct cb710_slot *slot, u8 what)
{
int err = 0;
unsigned limit = 2000000; /* FIXME: real timeout */
#ifdef CONFIG_CB710_DEBUG
u32 e, x;
e = cb710_read_port_32(slot, CB710_MMC_STATUS_PORT);
#endif
while (!(err = cb710_check_event(slot, what))) {
if (!--limit) {
cb710_dump_regs(cb710_slot_to_chip(slot),
CB710_DUMP_REGS_MMC);
err = -ETIMEDOUT;
break;
}
udelay(1);
}
#ifdef CONFIG_CB710_DEBUG
x = cb710_read_port_32(slot, CB710_MMC_STATUS_PORT);
limit = 2000000 - limit;
if (limit > 100)
dev_dbg(cb710_slot_dev(slot),
"WAIT10: waited %d loops, what %d, entry val %08X, exit val %08X\n",
limit, what, e, x);
#endif
return err < 0 ? err : 0;
}
static int cb710_wait_while_busy(struct cb710_slot *slot, uint8_t mask)
{
unsigned limit = 500000; /* FIXME: real timeout */
int err = 0;
#ifdef CONFIG_CB710_DEBUG
u32 e, x;
e = cb710_read_port_32(slot, CB710_MMC_STATUS_PORT);
#endif
while (cb710_read_port_8(slot, CB710_MMC_STATUS2_PORT) & mask) {
if (!--limit) {
cb710_dump_regs(cb710_slot_to_chip(slot),
CB710_DUMP_REGS_MMC);
err = -ETIMEDOUT;
break;
}
udelay(1);
}
#ifdef CONFIG_CB710_DEBUG
x = cb710_read_port_32(slot, CB710_MMC_STATUS_PORT);
limit = 500000 - limit;
if (limit > 100)
dev_dbg(cb710_slot_dev(slot),
"WAIT12: waited %d loops, mask %02X, entry val %08X, exit val %08X\n",
limit, mask, e, x);
#endif
return err;
}
static void cb710_mmc_set_transfer_size(struct cb710_slot *slot,
size_t count, size_t blocksize)
{
cb710_wait_while_busy(slot, CB710_MMC_S2_BUSY_20);
cb710_write_port_32(slot, CB710_MMC_TRANSFER_SIZE_PORT,
((count - 1) << 16)|(blocksize - 1));
dev_vdbg(cb710_slot_dev(slot), "set up for %zu block%s of %zu bytes\n",
count, count == 1 ? "" : "s", blocksize);
}
static void cb710_mmc_fifo_hack(struct cb710_slot *slot)
{
/* without this, received data is prepended with 8-bytes of zeroes */
u32 r1, r2;
int ok = 0;
r1 = cb710_read_port_32(slot, CB710_MMC_DATA_PORT);
r2 = cb710_read_port_32(slot, CB710_MMC_DATA_PORT);
if (cb710_read_port_8(slot, CB710_MMC_STATUS0_PORT)
& CB710_MMC_S0_FIFO_UNDERFLOW) {
cb710_write_port_8(slot, CB710_MMC_STATUS0_PORT,
CB710_MMC_S0_FIFO_UNDERFLOW);
ok = 1;
}
dev_dbg(cb710_slot_dev(slot),
"FIFO-read-hack: expected STATUS0 bit was %s\n",
ok ? "set." : "NOT SET!");
dev_dbg(cb710_slot_dev(slot),
"FIFO-read-hack: dwords ignored: %08X %08X - %s\n",
r1, r2, (r1|r2) ? "BAD (NOT ZERO)!" : "ok");
}
static int cb710_mmc_receive_pio(struct cb710_slot *slot,
struct sg_mapping_iter *miter, size_t dw_count)
{
if (!(cb710_read_port_8(slot, CB710_MMC_STATUS2_PORT) & CB710_MMC_S2_FIFO_READY)) {
int err = cb710_wait_for_event(slot,
CB710_MMC_S1_PIO_TRANSFER_DONE);
if (err)
return err;
}
cb710_sg_dwiter_write_from_io(miter,
slot->iobase + CB710_MMC_DATA_PORT, dw_count);
return 0;
}
static bool cb710_is_transfer_size_supported(struct mmc_data *data)
{
return !(data->blksz & 15 && (data->blocks != 1 || data->blksz != 8));
}
static int cb710_mmc_receive(struct cb710_slot *slot, struct mmc_data *data)
{
struct sg_mapping_iter miter;
size_t len, blocks = data->blocks;
int err = 0;
/* TODO: I don't know how/if the hardware handles non-16B-boundary blocks
* except single 8B block */
if (unlikely(data->blksz & 15 && (data->blocks != 1 || data->blksz != 8)))
return -EINVAL;
sg_miter_start(&miter, data->sg, data->sg_len, SG_MITER_TO_SG);
cb710_modify_port_8(slot, CB710_MMC_CONFIG2_PORT,
15, CB710_MMC_C2_READ_PIO_SIZE_MASK);
cb710_mmc_fifo_hack(slot);
while (blocks-- > 0) {
len = data->blksz;
while (len >= 16) {
err = cb710_mmc_receive_pio(slot, &miter, 4);
if (err)
goto out;
len -= 16;
}
if (!len)
continue;
cb710_modify_port_8(slot, CB710_MMC_CONFIG2_PORT,
len - 1, CB710_MMC_C2_READ_PIO_SIZE_MASK);
len = (len >= 8) ? 4 : 2;
err = cb710_mmc_receive_pio(slot, &miter, len);
if (err)
goto out;
}
out:
sg_miter_stop(&miter);
return err;
}
static int cb710_mmc_send(struct cb710_slot *slot, struct mmc_data *data)
{
struct sg_mapping_iter miter;
size_t len, blocks = data->blocks;
int err = 0;
/* TODO: I don't know how/if the hardware handles multiple
* non-16B-boundary blocks */
if (unlikely(data->blocks > 1 && data->blksz & 15))
return -EINVAL;
sg_miter_start(&miter, data->sg, data->sg_len, SG_MITER_FROM_SG);
cb710_modify_port_8(slot, CB710_MMC_CONFIG2_PORT,
0, CB710_MMC_C2_READ_PIO_SIZE_MASK);
while (blocks-- > 0) {
len = (data->blksz + 15) >> 4;
do {
if (!(cb710_read_port_8(slot, CB710_MMC_STATUS2_PORT)
& CB710_MMC_S2_FIFO_EMPTY)) {
err = cb710_wait_for_event(slot,
CB710_MMC_S1_PIO_TRANSFER_DONE);
if (err)
goto out;
}
cb710_sg_dwiter_read_to_io(&miter,
slot->iobase + CB710_MMC_DATA_PORT, 4);
} while (--len);
}
out:
sg_miter_stop(&miter);
return err;
}
static u16 cb710_encode_cmd_flags(struct cb710_mmc_reader *reader,
struct mmc_command *cmd)
{
unsigned int flags = cmd->flags;
u16 cb_flags = 0;
/* Windows driver returned 0 for commands for which no response
* is expected. It happened that there were only two such commands
* used: MMC_GO_IDLE_STATE and MMC_GO_INACTIVE_STATE so it might
* as well be a bug in that driver.
*
* Original driver set bit 14 for MMC/SD application
* commands. There's no difference 'on the wire' and
* it apparently works without it anyway.
*/
switch (flags & MMC_CMD_MASK) {
case MMC_CMD_AC: cb_flags = CB710_MMC_CMD_AC; break;
case MMC_CMD_ADTC: cb_flags = CB710_MMC_CMD_ADTC; break;
case MMC_CMD_BC: cb_flags = CB710_MMC_CMD_BC; break;
case MMC_CMD_BCR: cb_flags = CB710_MMC_CMD_BCR; break;
}
if (flags & MMC_RSP_BUSY)
cb_flags |= CB710_MMC_RSP_BUSY;
cb_flags |= cmd->opcode << CB710_MMC_CMD_CODE_SHIFT;
if (cmd->data && (cmd->data->flags & MMC_DATA_READ))
cb_flags |= CB710_MMC_DATA_READ;
if (flags & MMC_RSP_PRESENT) {
/* Windows driver set 01 at bits 4,3 except for
* MMC_SET_BLOCKLEN where it set 10. Maybe the
* hardware can do something special about this
* command? The original driver looks buggy/incomplete
* anyway so we ignore this for now.
*
* I assume that 00 here means no response is expected.
*/
cb_flags |= CB710_MMC_RSP_PRESENT;
if (flags & MMC_RSP_136)
cb_flags |= CB710_MMC_RSP_136;
if (!(flags & MMC_RSP_CRC))
cb_flags |= CB710_MMC_RSP_NO_CRC;
}
return cb_flags;
}
static void cb710_receive_response(struct cb710_slot *slot,
struct mmc_command *cmd)
{
unsigned rsp_opcode, wanted_opcode;
/* Looks like final byte with CRC is always stripped (same as SDHCI) */
if (cmd->flags & MMC_RSP_136) {
u32 resp[4];
resp[0] = cb710_read_port_32(slot, CB710_MMC_RESPONSE3_PORT);
resp[1] = cb710_read_port_32(slot, CB710_MMC_RESPONSE2_PORT);
resp[2] = cb710_read_port_32(slot, CB710_MMC_RESPONSE1_PORT);
resp[3] = cb710_read_port_32(slot, CB710_MMC_RESPONSE0_PORT);
rsp_opcode = resp[0] >> 24;
cmd->resp[0] = (resp[0] << 8)|(resp[1] >> 24);
cmd->resp[1] = (resp[1] << 8)|(resp[2] >> 24);
cmd->resp[2] = (resp[2] << 8)|(resp[3] >> 24);
cmd->resp[3] = (resp[3] << 8);
} else {
rsp_opcode = cb710_read_port_32(slot, CB710_MMC_RESPONSE1_PORT) & 0x3F;
cmd->resp[0] = cb710_read_port_32(slot, CB710_MMC_RESPONSE0_PORT);
}
wanted_opcode = (cmd->flags & MMC_RSP_OPCODE) ? cmd->opcode : 0x3F;
if (rsp_opcode != wanted_opcode)
cmd->error = -EILSEQ;
}
static int cb710_mmc_transfer_data(struct cb710_slot *slot,
struct mmc_data *data)
{
int error, to;
if (data->flags & MMC_DATA_READ)
error = cb710_mmc_receive(slot, data);
else
error = cb710_mmc_send(slot, data);
to = cb710_wait_for_event(slot, CB710_MMC_S1_DATA_TRANSFER_DONE);
if (!error)
error = to;
if (!error)
data->bytes_xfered = data->blksz * data->blocks;
return error;
}
static int cb710_mmc_command(struct mmc_host *mmc, struct mmc_command *cmd)
{
struct cb710_slot *slot = cb710_mmc_to_slot(mmc);
struct cb710_mmc_reader *reader = mmc_priv(mmc);
struct mmc_data *data = cmd->data;
u16 cb_cmd = cb710_encode_cmd_flags(reader, cmd);
dev_dbg(cb710_slot_dev(slot), "cmd request: 0x%04X\n", cb_cmd);
if (data) {
if (!cb710_is_transfer_size_supported(data)) {
data->error = -EINVAL;
return -1;
}
cb710_mmc_set_transfer_size(slot, data->blocks, data->blksz);
}
cb710_wait_while_busy(slot, CB710_MMC_S2_BUSY_20|CB710_MMC_S2_BUSY_10);
cb710_write_port_16(slot, CB710_MMC_CMD_TYPE_PORT, cb_cmd);
cb710_wait_while_busy(slot, CB710_MMC_S2_BUSY_20);
cb710_write_port_32(slot, CB710_MMC_CMD_PARAM_PORT, cmd->arg);
cb710_mmc_reset_events(slot);
cb710_wait_while_busy(slot, CB710_MMC_S2_BUSY_20);
cb710_modify_port_8(slot, CB710_MMC_CONFIG0_PORT, 0x01, 0);
cmd->error = cb710_wait_for_event(slot, CB710_MMC_S1_COMMAND_SENT);
if (cmd->error)
return -1;
if (cmd->flags & MMC_RSP_PRESENT) {
cb710_receive_response(slot, cmd);
if (cmd->error)
return -1;
}
if (data)
data->error = cb710_mmc_transfer_data(slot, data);
return 0;
}
static void cb710_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
{
struct cb710_slot *slot = cb710_mmc_to_slot(mmc);
struct cb710_mmc_reader *reader = mmc_priv(mmc);
WARN_ON(reader->mrq != NULL);
reader->mrq = mrq;
cb710_mmc_enable_irq(slot, CB710_MMC_IE_TEST_MASK, 0);
if (!cb710_mmc_command(mmc, mrq->cmd) && mrq->stop)
cb710_mmc_command(mmc, mrq->stop);
tasklet_schedule(&reader->finish_req_tasklet);
}
static int cb710_mmc_powerup(struct cb710_slot *slot)
{
#ifdef CONFIG_CB710_DEBUG
struct cb710_chip *chip = cb710_slot_to_chip(slot);
#endif
int err;
/* a lot of magic for now */
dev_dbg(cb710_slot_dev(slot), "bus powerup\n");
cb710_dump_regs(chip, CB710_DUMP_REGS_MMC);
err = cb710_wait_while_busy(slot, CB710_MMC_S2_BUSY_20);
if (unlikely(err))
return err;
cb710_modify_port_8(slot, CB710_MMC_CONFIG1_PORT, 0x80, 0);
cb710_modify_port_8(slot, CB710_MMC_CONFIG3_PORT, 0x80, 0);
cb710_dump_regs(chip, CB710_DUMP_REGS_MMC);
mdelay(1);
dev_dbg(cb710_slot_dev(slot), "after delay 1\n");
cb710_dump_regs(chip, CB710_DUMP_REGS_MMC);
err = cb710_wait_while_busy(slot, CB710_MMC_S2_BUSY_20);
if (unlikely(err))
return err;
cb710_modify_port_8(slot, CB710_MMC_CONFIG1_PORT, 0x09, 0);
cb710_dump_regs(chip, CB710_DUMP_REGS_MMC);
mdelay(1);
dev_dbg(cb710_slot_dev(slot), "after delay 2\n");
cb710_dump_regs(chip, CB710_DUMP_REGS_MMC);
err = cb710_wait_while_busy(slot, CB710_MMC_S2_BUSY_20);
if (unlikely(err))
return err;
cb710_modify_port_8(slot, CB710_MMC_CONFIG1_PORT, 0, 0x08);
cb710_dump_regs(chip, CB710_DUMP_REGS_MMC);
mdelay(2);
dev_dbg(cb710_slot_dev(slot), "after delay 3\n");
cb710_dump_regs(chip, CB710_DUMP_REGS_MMC);
cb710_modify_port_8(slot, CB710_MMC_CONFIG0_PORT, 0x06, 0);
cb710_modify_port_8(slot, CB710_MMC_CONFIG1_PORT, 0x70, 0);
cb710_modify_port_8(slot, CB710_MMC_CONFIG2_PORT, 0x80, 0);
cb710_modify_port_8(slot, CB710_MMC_CONFIG3_PORT, 0x03, 0);
cb710_dump_regs(chip, CB710_DUMP_REGS_MMC);
err = cb710_wait_while_busy(slot, CB710_MMC_S2_BUSY_20);
if (unlikely(err))
return err;
/* This port behaves weird: quick byte reads of 0x08,0x09 return
* 0xFF,0x00 after writing 0xFFFF to 0x08; it works correctly when
* read/written from userspace... What am I missing here?
* (it doesn't depend on write-to-read delay) */
cb710_write_port_16(slot, CB710_MMC_CONFIGB_PORT, 0xFFFF);
cb710_modify_port_8(slot, CB710_MMC_CONFIG0_PORT, 0x06, 0);
cb710_dump_regs(chip, CB710_DUMP_REGS_MMC);
dev_dbg(cb710_slot_dev(slot), "bus powerup finished\n");
return cb710_check_event(slot, 0);
}
static void cb710_mmc_powerdown(struct cb710_slot *slot)
{
cb710_modify_port_8(slot, CB710_MMC_CONFIG1_PORT, 0, 0x81);
cb710_modify_port_8(slot, CB710_MMC_CONFIG3_PORT, 0, 0x80);
}
static void cb710_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
{
struct cb710_slot *slot = cb710_mmc_to_slot(mmc);
struct cb710_mmc_reader *reader = mmc_priv(mmc);
int err;
cb710_mmc_select_clock_divider(mmc, ios->clock);
if (ios->power_mode != reader->last_power_mode)
switch (ios->power_mode) {
case MMC_POWER_ON:
err = cb710_mmc_powerup(slot);
if (err) {
dev_warn(cb710_slot_dev(slot),
"powerup failed (%d)- retrying\n", err);
cb710_mmc_powerdown(slot);
udelay(1);
err = cb710_mmc_powerup(slot);
if (err)
dev_warn(cb710_slot_dev(slot),
"powerup retry failed (%d) - expect errors\n",
err);
}
reader->last_power_mode = MMC_POWER_ON;
break;
case MMC_POWER_OFF:
cb710_mmc_powerdown(slot);
reader->last_power_mode = MMC_POWER_OFF;
break;
case MMC_POWER_UP:
default:
/* ignore */;
}
cb710_mmc_enable_4bit_data(slot, ios->bus_width != MMC_BUS_WIDTH_1);
cb710_mmc_enable_irq(slot, CB710_MMC_IE_TEST_MASK, 0);
}
static int cb710_mmc_get_ro(struct mmc_host *mmc)
{
struct cb710_slot *slot = cb710_mmc_to_slot(mmc);
return cb710_read_port_8(slot, CB710_MMC_STATUS3_PORT)
& CB710_MMC_S3_WRITE_PROTECTED;
}
static int cb710_mmc_get_cd(struct mmc_host *mmc)
{
struct cb710_slot *slot = cb710_mmc_to_slot(mmc);
return cb710_read_port_8(slot, CB710_MMC_STATUS3_PORT)
& CB710_MMC_S3_CARD_DETECTED;
}
static int cb710_mmc_irq_handler(struct cb710_slot *slot)
{
struct mmc_host *mmc = cb710_slot_to_mmc(slot);
struct cb710_mmc_reader *reader = mmc_priv(mmc);
u32 status, config1, config2, irqen;
status = cb710_read_port_32(slot, CB710_MMC_STATUS_PORT);
irqen = cb710_read_port_32(slot, CB710_MMC_IRQ_ENABLE_PORT);
config2 = cb710_read_port_32(slot, CB710_MMC_CONFIGB_PORT);
config1 = cb710_read_port_32(slot, CB710_MMC_CONFIG_PORT);
dev_dbg(cb710_slot_dev(slot), "interrupt; status: %08X, "
"ie: %08X, c2: %08X, c1: %08X\n",
status, irqen, config2, config1);
if (status & (CB710_MMC_S1_CARD_CHANGED << 8)) {
/* ack the event */
cb710_write_port_8(slot, CB710_MMC_STATUS1_PORT,
CB710_MMC_S1_CARD_CHANGED);
if ((irqen & CB710_MMC_IE_CISTATUS_MASK)
== CB710_MMC_IE_CISTATUS_MASK)
mmc_detect_change(mmc, HZ/5);
} else {
dev_dbg(cb710_slot_dev(slot), "unknown interrupt (test)\n");
spin_lock(&reader->irq_lock);
__cb710_mmc_enable_irq(slot, 0, CB710_MMC_IE_TEST_MASK);
spin_unlock(&reader->irq_lock);
}
return 1;
}
static void cb710_mmc_finish_request_tasklet(unsigned long data)
{
struct mmc_host *mmc = (void *)data;
struct cb710_mmc_reader *reader = mmc_priv(mmc);
struct mmc_request *mrq = reader->mrq;
reader->mrq = NULL;
mmc_request_done(mmc, mrq);
}
static const struct mmc_host_ops cb710_mmc_host = {
.request = cb710_mmc_request,
.set_ios = cb710_mmc_set_ios,
.get_ro = cb710_mmc_get_ro,
.get_cd = cb710_mmc_get_cd,
};
#ifdef CONFIG_PM
static int cb710_mmc_suspend(struct platform_device *pdev, pm_message_t state)
{
struct cb710_slot *slot = cb710_pdev_to_slot(pdev);
cb710_mmc_enable_irq(slot, 0, ~0);
return 0;
}
static int cb710_mmc_resume(struct platform_device *pdev)
{
struct cb710_slot *slot = cb710_pdev_to_slot(pdev);
cb710_mmc_enable_irq(slot, 0, ~0);
return 0;
}
#endif /* CONFIG_PM */
static int cb710_mmc_init(struct platform_device *pdev)
{
struct cb710_slot *slot = cb710_pdev_to_slot(pdev);
struct cb710_chip *chip = cb710_slot_to_chip(slot);
struct mmc_host *mmc;
struct cb710_mmc_reader *reader;
int err;
u32 val;
mmc = mmc_alloc_host(sizeof(*reader), cb710_slot_dev(slot));
if (!mmc)
return -ENOMEM;
platform_set_drvdata(pdev, mmc);
/* harmless (maybe) magic */
pci_read_config_dword(chip->pdev, 0x48, &val);
val = cb710_src_freq_mhz[(val >> 16) & 0xF];
dev_dbg(cb710_slot_dev(slot), "source frequency: %dMHz\n", val);
val *= 1000000;
mmc->ops = &cb710_mmc_host;
mmc->f_max = val;
mmc->f_min = val >> cb710_clock_divider_log2[CB710_MAX_DIVIDER_IDX];
mmc->ocr_avail = MMC_VDD_32_33|MMC_VDD_33_34;
mmc->caps = MMC_CAP_4_BIT_DATA;
reader = mmc_priv(mmc);
tasklet_init(&reader->finish_req_tasklet,
cb710_mmc_finish_request_tasklet, (unsigned long)mmc);
spin_lock_init(&reader->irq_lock);
cb710_dump_regs(chip, CB710_DUMP_REGS_MMC);
cb710_mmc_enable_irq(slot, 0, ~0);
cb710_set_irq_handler(slot, cb710_mmc_irq_handler);
err = mmc_add_host(mmc);
if (unlikely(err))
goto err_free_mmc;
dev_dbg(cb710_slot_dev(slot), "mmc_hostname is %s\n",
mmc_hostname(mmc));
cb710_mmc_enable_irq(slot, CB710_MMC_IE_CARD_INSERTION_STATUS, 0);
return 0;
err_free_mmc:
dev_dbg(cb710_slot_dev(slot), "mmc_add_host() failed: %d\n", err);
cb710_set_irq_handler(slot, NULL);
mmc_free_host(mmc);
return err;
}
static int cb710_mmc_exit(struct platform_device *pdev)
{
struct cb710_slot *slot = cb710_pdev_to_slot(pdev);
struct mmc_host *mmc = cb710_slot_to_mmc(slot);
struct cb710_mmc_reader *reader = mmc_priv(mmc);
cb710_mmc_enable_irq(slot, 0, CB710_MMC_IE_CARD_INSERTION_STATUS);
mmc_remove_host(mmc);
/* IRQs should be disabled now, but let's stay on the safe side */
cb710_mmc_enable_irq(slot, 0, ~0);
cb710_set_irq_handler(slot, NULL);
/* clear config ports - just in case */
cb710_write_port_32(slot, CB710_MMC_CONFIG_PORT, 0);
cb710_write_port_16(slot, CB710_MMC_CONFIGB_PORT, 0);
tasklet_kill(&reader->finish_req_tasklet);
mmc_free_host(mmc);
return 0;
}
static struct platform_driver cb710_mmc_driver = {
.driver.name = "cb710-mmc",
.probe = cb710_mmc_init,
.remove = cb710_mmc_exit,
#ifdef CONFIG_PM
.suspend = cb710_mmc_suspend,
.resume = cb710_mmc_resume,
#endif
};
module_platform_driver(cb710_mmc_driver);
MODULE_AUTHOR("Michał Mirosław <mirq-linux@rere.qmqm.pl>");
MODULE_DESCRIPTION("ENE CB710 memory card reader driver - MMC/SD part");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:cb710-mmc");
+103
View File
@@ -0,0 +1,103 @@
/*
* cb710/cb710-mmc.h
*
* Copyright by Michał Mirosław, 2008-2009
*
* 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.
*/
#ifndef LINUX_CB710_MMC_H
#define LINUX_CB710_MMC_H
#include <linux/cb710.h>
/* per-MMC-reader structure */
struct cb710_mmc_reader {
struct tasklet_struct finish_req_tasklet;
struct mmc_request *mrq;
spinlock_t irq_lock;
unsigned char last_power_mode;
};
/* some device struct walking */
static inline struct mmc_host *cb710_slot_to_mmc(struct cb710_slot *slot)
{
return platform_get_drvdata(&slot->pdev);
}
static inline struct cb710_slot *cb710_mmc_to_slot(struct mmc_host *mmc)
{
struct platform_device *pdev = to_platform_device(mmc_dev(mmc));
return cb710_pdev_to_slot(pdev);
}
/* registers (this might be all wrong ;) */
#define CB710_MMC_DATA_PORT 0x00
#define CB710_MMC_CONFIG_PORT 0x04
#define CB710_MMC_CONFIG0_PORT 0x04
#define CB710_MMC_CONFIG1_PORT 0x05
#define CB710_MMC_C1_4BIT_DATA_BUS 0x40
#define CB710_MMC_CONFIG2_PORT 0x06
#define CB710_MMC_C2_READ_PIO_SIZE_MASK 0x0F /* N-1 */
#define CB710_MMC_CONFIG3_PORT 0x07
#define CB710_MMC_CONFIGB_PORT 0x08
#define CB710_MMC_IRQ_ENABLE_PORT 0x0C
#define CB710_MMC_IE_TEST_MASK 0x00BF
#define CB710_MMC_IE_CARD_INSERTION_STATUS 0x1000
#define CB710_MMC_IE_IRQ_ENABLE 0x8000
#define CB710_MMC_IE_CISTATUS_MASK \
(CB710_MMC_IE_CARD_INSERTION_STATUS|CB710_MMC_IE_IRQ_ENABLE)
#define CB710_MMC_STATUS_PORT 0x10
#define CB710_MMC_STATUS_ERROR_EVENTS 0x60FF
#define CB710_MMC_STATUS0_PORT 0x10
#define CB710_MMC_S0_FIFO_UNDERFLOW 0x40
#define CB710_MMC_STATUS1_PORT 0x11
#define CB710_MMC_S1_COMMAND_SENT 0x01
#define CB710_MMC_S1_DATA_TRANSFER_DONE 0x02
#define CB710_MMC_S1_PIO_TRANSFER_DONE 0x04
#define CB710_MMC_S1_CARD_CHANGED 0x10
#define CB710_MMC_S1_RESET 0x20
#define CB710_MMC_STATUS2_PORT 0x12
#define CB710_MMC_S2_FIFO_READY 0x01
#define CB710_MMC_S2_FIFO_EMPTY 0x02
#define CB710_MMC_S2_BUSY_10 0x10
#define CB710_MMC_S2_BUSY_20 0x20
#define CB710_MMC_STATUS3_PORT 0x13
#define CB710_MMC_S3_CARD_DETECTED 0x02
#define CB710_MMC_S3_WRITE_PROTECTED 0x04
#define CB710_MMC_CMD_TYPE_PORT 0x14
#define CB710_MMC_RSP_TYPE_MASK 0x0007
#define CB710_MMC_RSP_R1 (0)
#define CB710_MMC_RSP_136 (5)
#define CB710_MMC_RSP_NO_CRC (2)
#define CB710_MMC_RSP_PRESENT_MASK 0x0018
#define CB710_MMC_RSP_NONE (0 << 3)
#define CB710_MMC_RSP_PRESENT (1 << 3)
#define CB710_MMC_RSP_PRESENT_X (2 << 3)
#define CB710_MMC_CMD_TYPE_MASK 0x0060
#define CB710_MMC_CMD_BC (0 << 5)
#define CB710_MMC_CMD_BCR (1 << 5)
#define CB710_MMC_CMD_AC (2 << 5)
#define CB710_MMC_CMD_ADTC (3 << 5)
#define CB710_MMC_DATA_READ 0x0080
#define CB710_MMC_CMD_CODE_MASK 0x3F00
#define CB710_MMC_CMD_CODE_SHIFT 8
#define CB710_MMC_IS_APP_CMD 0x4000
#define CB710_MMC_RSP_BUSY 0x8000
#define CB710_MMC_CMD_PARAM_PORT 0x18
#define CB710_MMC_TRANSFER_SIZE_PORT 0x1C
#define CB710_MMC_RESPONSE0_PORT 0x20
#define CB710_MMC_RESPONSE1_PORT 0x24
#define CB710_MMC_RESPONSE2_PORT 0x28
#define CB710_MMC_RESPONSE3_PORT 0x2C
#endif /* LINUX_CB710_MMC_H */
+264
View File
@@ -0,0 +1,264 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright 2020 Google LLC
*/
#include <linux/blk-crypto.h>
#include <linux/keyslot-manager.h>
#include <linux/mmc/host.h>
#include "cqhci-crypto.h"
#define CQHCI_CRYPTO_CONFIG_INDEX(x) (((u64)(x) & 0xFF) << 32)
#define CQHCI_CRYPTO_ENABLE_BIT (((u64)1) << 47)
/* Blk-crypto modes supported by CQHCI MMC crypto */
static const struct cqhci_crypto_alg_entry {
enum cqhci_crypto_alg cqhci_alg;
enum cqhci_crypto_key_size cqhci_key_size;
} cqhci_crypto_algs[BLK_ENCRYPTION_MODE_MAX] = {
[BLK_ENCRYPTION_MODE_AES_256_XTS] = {
.cqhci_alg = CQHCI_CRYPTO_ALG_AES_XTS,
.cqhci_key_size = CQHCI_CRYPTO_KEY_SIZE_256,
},
};
static void cqhci_crypto_program_key(struct cqhci_host *host,
const union cqhci_crypto_cfg_entry *cfg,
int slot)
{
u32 slot_offset = host->crypto_cfg_register + slot * sizeof(*cfg);
int i;
msdc_ungate_clock(host->mmc);
/* Ensure that CFGE is cleared before programming the key */
cqhci_writel(host, 0, slot_offset + 16 * sizeof(cfg->reg_val[0]));
for (i = 0; i < 16; i++) {
cqhci_writel(host, le32_to_cpu(cfg->reg_val[i]),
slot_offset + i * sizeof(cfg->reg_val[0]));
}
/* Write dword 17 */
cqhci_writel(host, le32_to_cpu(cfg->reg_val[17]),
slot_offset + 17 * sizeof(cfg->reg_val[0]));
/* Write dword 16 */
cqhci_writel(host, le32_to_cpu(cfg->reg_val[16]),
slot_offset + 16 * sizeof(cfg->reg_val[0]));
msdc_gate_clock(host->mmc);
}
static int cqhci_crypto_keyslot_program(struct keyslot_manager *ksm,
const struct blk_crypto_key *key,
unsigned int slot)
{
struct cqhci_host *host = keyslot_manager_private(ksm);
const union cqhci_crypto_cap_entry *ccap_array = host->crypto_cap_array;
const struct cqhci_crypto_alg_entry *alg =
&cqhci_crypto_algs[key->crypto_mode];
u8 data_unit_mask = key->data_unit_size / 512;
int i;
int cap_idx = -1;
union cqhci_crypto_cfg_entry cfg = { { 0 } };
BUILD_BUG_ON(CQHCI_CRYPTO_KEY_SIZE_INVALID != 0);
for (i = 0; i < host->crypto_capabilities.num_crypto_cap; i++) {
if (ccap_array[i].algorithm_id == alg->cqhci_alg &&
ccap_array[i].key_size == alg->cqhci_key_size &&
(ccap_array[i].sdus_mask & data_unit_mask)) {
cap_idx = i;
break;
}
}
if (WARN_ON(cap_idx < 0))
return -EOPNOTSUPP;
cfg.data_unit_size = data_unit_mask;
#ifdef CONFIG_MMC_CRYPTO_LEGACY
/* used fsrypt v2 in OTA fscrypt v1 environment */
if (key->hie_duint_size != 4096)
cfg.data_unit_size = 1;
#endif
cfg.crypto_cap_idx = cap_idx;
cfg.config_enable = CQHCI_CRYPTO_CONFIGURATION_ENABLE;
if (ccap_array[cap_idx].algorithm_id == CQHCI_CRYPTO_ALG_AES_XTS) {
/* In XTS mode, the blk_crypto_key's size is already doubled */
memcpy(cfg.crypto_key, key->raw, key->size/2);
memcpy(cfg.crypto_key + CQHCI_CRYPTO_KEY_MAX_SIZE/2,
key->raw + key->size/2, key->size/2);
} else {
memcpy(cfg.crypto_key, key->raw, key->size);
}
cqhci_crypto_program_key(host, &cfg, slot);
memzero_explicit(&cfg, sizeof(cfg));
return 0;
}
static void cqhci_crypto_clear_keyslot(struct cqhci_host *host, int slot)
{
/*
* Clear the crypto cfg on the device. Clearing CFGE
* might not be sufficient, so just clear the entire cfg.
*/
union cqhci_crypto_cfg_entry cfg = { { 0 } };
cqhci_crypto_program_key(host, &cfg, slot);
}
static int cqhci_crypto_keyslot_evict(struct keyslot_manager *ksm,
const struct blk_crypto_key *key,
unsigned int slot)
{
cqhci_crypto_clear_keyslot(keyslot_manager_private(ksm), slot);
return 0;
}
static const struct keyslot_mgmt_ll_ops cqhci_ksm_ops = {
.keyslot_program = cqhci_crypto_keyslot_program,
.keyslot_evict = cqhci_crypto_keyslot_evict,
};
bool cqhci_crypto_enable(struct cqhci_host *host)
{
if (!(host->mmc->caps2 & MMC_CAP2_CRYPTO))
return false;
/* Reset might clear all keys, so reprogram all the keys. */
if (host->mmc->ksm)
keyslot_manager_reprogram_all_keys(host->mmc->ksm);
return true;
}
static enum blk_crypto_mode_num
cqhci_find_blk_crypto_mode(union cqhci_crypto_cap_entry cap)
{
int i;
for (i = 0; i < ARRAY_SIZE(cqhci_crypto_algs); i++) {
BUILD_BUG_ON(CQHCI_CRYPTO_KEY_SIZE_INVALID != 0);
if (cqhci_crypto_algs[i].cqhci_alg == cap.algorithm_id &&
cqhci_crypto_algs[i].cqhci_key_size == cap.key_size) {
return i;
}
}
return BLK_ENCRYPTION_MODE_INVALID;
}
/**
* cqhci_host_init_crypto - Read crypto capabilities, init crypto fields in host
* @host: Per adapter instance
*
* Return: 0 if crypto was initialized, or is not supported, else a -errno value
*/
int cqhci_host_init_crypto(struct cqhci_host *host)
{
int cap_idx = 0;
int err = 0;
enum blk_crypto_mode_num blk_mode_num;
int slot = 0;
struct device *dev = &host->mmc->class_dev;
unsigned int crypto_modes_supported[BLK_ENCRYPTION_MODE_MAX] = {0};
int num_keyslots;
struct keyslot_manager *ksm;
if (host->mmc->ksm)
return 0;
/*
* Don't use crypto if the vendor specific driver doesn't set the
* standard crypto capability bit *or* the hardware doesn't advertise
* that crypto is supported.
*/
if (!(host->mmc->caps2 & MMC_CAP2_CRYPTO) ||
!(cqhci_readl(host, CQHCI_CAP) & CQHCI_CAP_CS))
return 0;
host->crypto_capabilities.reg_val =
cpu_to_le32(cqhci_readl(host, CQHCI_CCAP));
host->crypto_cfg_register =
(u32)host->crypto_capabilities.config_array_ptr * 0x100;
host->crypto_cap_array =
devm_kcalloc(dev, host->crypto_capabilities.num_crypto_cap,
sizeof(host->crypto_cap_array[0]), GFP_KERNEL);
if (!host->crypto_cap_array) {
err = -ENOMEM;
goto out;
}
for (cap_idx = 0; cap_idx < host->crypto_capabilities.num_crypto_cap;
cap_idx++) {
host->crypto_cap_array[cap_idx].reg_val =
cpu_to_le32(cqhci_readl(host, CQHCI_CRYPTOCAP +
cap_idx * sizeof(__le32)));
blk_mode_num = cqhci_find_blk_crypto_mode(
host->crypto_cap_array[cap_idx]);
if (blk_mode_num == BLK_ENCRYPTION_MODE_INVALID)
continue;
crypto_modes_supported[blk_mode_num] |=
host->crypto_cap_array[cap_idx].sdus_mask * 512;
}
/* The actual number of configurations supported is (CFGC+1) */
num_keyslots = host->crypto_capabilities.config_count + 1;
ksm = keyslot_manager_create(dev, num_keyslots,
&cqhci_ksm_ops,
BLK_CRYPTO_FEATURE_STANDARD_KEYS,
crypto_modes_supported, host);
if (!ksm) {
err = -ENOMEM;
goto out_free_caps;
}
/* eMMC 5.2 only support 4 bytes DUN */
keyslot_manager_set_max_dun_bytes(ksm, 4);
host->mmc->ksm = ksm;
for (slot = 0; slot < num_keyslots; slot++)
cqhci_crypto_clear_keyslot(host, slot);
/* CQHCI crypto uses 128-bit task descriptor */
host->caps |= CQHCI_TASK_DESC_SZ_128;
return 0;
out_free_caps:
devm_kfree(dev, host->crypto_cap_array);
out:
/* Indicate that init failed by clearing MMC_CAP2_CRYPTO */
host->mmc->caps2 &= ~MMC_CAP2_CRYPTO;
return err;
}
int cqhci_prep_crypto_desc(struct mmc_request *mrq, __le64 *task_desc)
{
u64 crypto_desc = 0;
if (mmc_request_crypto_enabled(mrq)) {
/* eMMC v5.2 only supports 32 bits for DUN */
if (WARN_ON_ONCE(upper_32_bits(mrq->data_unit_num) != 0))
return -EINVAL;
crypto_desc = lower_32_bits(mrq->data_unit_num) |
CQHCI_CRYPTO_CONFIG_INDEX(mrq->crypto_key_slot) |
CQHCI_CRYPTO_ENABLE_BIT;
}
/*
* Assign upper 64bits data of 128 bits task descriptor
* with the crypto context
*/
task_desc[1] = cpu_to_le64(crypto_desc);
return 0;
}
void cqhci_crypto_recovery_finish(struct cqhci_host *host)
{
/* Reset/Recovery might clear all keys, so reprogram all the keys. */
keyslot_manager_reprogram_all_keys(host->mmc->ksm);
}
+43
View File
@@ -0,0 +1,43 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright 2020 Google LLC
*/
#ifndef LINUX_MMC_CQHCI_CRYPTO_H
#define LINUX_MMC_CQHCI_CRYPTO_H
#include "cqhci.h"
#ifdef CONFIG_MMC_CRYPTO
bool cqhci_crypto_enable(struct cqhci_host *host);
int cqhci_host_init_crypto(struct cqhci_host *host);
int cqhci_prep_crypto_desc(struct mmc_request *mrq, __le64 *task_desc);
void cqhci_crypto_recovery_finish(struct cqhci_host *host);
#else /* CONFIG_MMC_CRYPTO */
static inline bool cqhci_crypto_enable(struct cqhci_host *host)
{
return false;
}
static inline int cqhci_host_init_crypto(struct cqhci_host *host)
{
return 0;
}
static inline int cqhci_prep_crypto_desc(struct mmc_request *mrq,
__le64 *task_desc)
{
return 0;
}
static inline void cqhci_crypto_recovery_finish(struct cqhci_host *host) { }
#endif /* CONFIG_MMC_CRYPTO */
#endif /* LINUX_MMC_CQHCI_CRYPTO_H */
File diff suppressed because it is too large. Load diff
+314
View File
@@ -0,0 +1,314 @@
/* Copyright (c) 2015, The Linux Foundation. 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 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#ifndef LINUX_MMC_CQHCI_H
#define LINUX_MMC_CQHCI_H
#include <linux/compiler.h>
#include <linux/bitops.h>
#include <linux/spinlock_types.h>
#include <linux/types.h>
#include <linux/completion.h>
#include <linux/wait.h>
#include <linux/irqreturn.h>
#include <asm/io.h>
/* registers */
/* version */
#define CQHCI_VER 0x00
#define CQHCI_VER_MAJOR(x) (((x) & GENMASK(11, 8)) >> 8)
#define CQHCI_VER_MINOR1(x) (((x) & GENMASK(7, 4)) >> 4)
#define CQHCI_VER_MINOR2(x) ((x) & GENMASK(3, 0))
/* capabilities */
#define CQHCI_CAP 0x04
#define CQHCI_CAP_CS (1 << 28)
#define CQHCI_CCAP 0x100
#define CQHCI_CRYPTOCAP 0x104
/* configuration */
#define CQHCI_CFG 0x08
#define CQHCI_DCMD 0x00001000
#define CQHCI_TASK_DESC_SZ 0x00000100
#define CQHCI_ENABLE 0x00000001
#define CQHCI_CRYPTO_ENABLE 0x00000002
/* control */
#define CQHCI_CTL 0x0C
#define CQHCI_CLEAR_ALL_TASKS 0x00000100
#define CQHCI_HALT 0x00000001
/* interrupt status */
#define CQHCI_IS 0x10
#define CQHCI_IS_HAC BIT(0)
#define CQHCI_IS_TCC BIT(1)
#define CQHCI_IS_RED BIT(2)
#define CQHCI_IS_TCL BIT(3)
#define CQHCI_IS_MASK (CQHCI_IS_TCC | CQHCI_IS_RED)
/* interrupt status enable */
#define CQHCI_ISTE 0x14
/* interrupt signal enable */
#define CQHCI_ISGE 0x18
/* interrupt coalescing */
#define CQHCI_IC 0x1C
#define CQHCI_IC_ENABLE BIT(31)
#define CQHCI_IC_RESET BIT(16)
#define CQHCI_IC_ICCTHWEN BIT(15)
#define CQHCI_IC_ICCTH(x) (((x) & 0x1F) << 8)
#define CQHCI_IC_ICTOVALWEN BIT(7)
#define CQHCI_IC_ICTOVAL(x) ((x) & 0x7F)
/* task list base address */
#define CQHCI_TDLBA 0x20
/* task list base address upper */
#define CQHCI_TDLBAU 0x24
/* door-bell */
#define CQHCI_TDBR 0x28
/* task completion notification */
#define CQHCI_TCN 0x2C
/* device queue status */
#define CQHCI_DQS 0x30
/* device pending tasks */
#define CQHCI_DPT 0x34
/* task clear */
#define CQHCI_TCLR 0x38
/* send status config 1 */
#define CQHCI_SSC1 0x40
/* send status config 2 */
#define CQHCI_SSC2 0x44
/* response for dcmd */
#define CQHCI_CRDCT 0x48
/* response mode error mask */
#define CQHCI_RMEM 0x50
/* task error info */
#define CQHCI_TERRI 0x54
#define CQHCI_TERRI_C_INDEX(x) ((x) & GENMASK(5, 0))
#define CQHCI_TERRI_C_TASK(x) (((x) & GENMASK(12, 8)) >> 8)
#define CQHCI_TERRI_C_VALID(x) ((x) & BIT(15))
#define CQHCI_TERRI_D_INDEX(x) (((x) & GENMASK(21, 16)) >> 16)
#define CQHCI_TERRI_D_TASK(x) (((x) & GENMASK(28, 24)) >> 24)
#define CQHCI_TERRI_D_VALID(x) ((x) & BIT(31))
/* command response index */
#define CQHCI_CRI 0x58
/* command response argument */
#define CQHCI_CRA 0x5C
#define CQHCI_CRNQP 0x70
#define CQHCI_CRNQDUN 0x74
#define CQHCI_CRNQIS 0x78
#define CQHCI_CRNQIE 0x7c
#define CQHCI_INT_ALL 0xF
#define CQHCI_IC_DEFAULT_ICCTH 31
#define CQHCI_IC_DEFAULT_ICTOVAL 1
/* attribute fields */
#define CQHCI_VALID(x) (((x) & 1) << 0)
#define CQHCI_END(x) (((x) & 1) << 1)
#define CQHCI_INT(x) (((x) & 1) << 2)
#define CQHCI_ACT(x) (((x) & 0x7) << 3)
/* data command task descriptor fields */
#define CQHCI_FORCED_PROG(x) (((x) & 1) << 6)
#define CQHCI_CONTEXT(x) (((x) & 0xF) << 7)
#define CQHCI_DATA_TAG(x) (((x) & 1) << 11)
#define CQHCI_DATA_DIR(x) (((x) & 1) << 12)
#define CQHCI_PRIORITY(x) (((x) & 1) << 13)
#define CQHCI_QBAR(x) (((x) & 1) << 14)
#define CQHCI_REL_WRITE(x) (((x) & 1) << 15)
#define CQHCI_BLK_COUNT(x) (((x) & 0xFFFF) << 16)
#define CQHCI_BLK_ADDR(x) (((x) & 0xFFFFFFFF) << 32)
/* direct command task descriptor fields */
#define CQHCI_CMD_INDEX(x) (((x) & 0x3F) << 16)
#define CQHCI_CMD_TIMING(x) (((x) & 1) << 22)
#define CQHCI_RESP_TYPE(x) (((x) & 0x3) << 23)
/* transfer descriptor fields */
#define CQHCI_DAT_LENGTH(x) (((x) & 0xFFFF) << 16)
#define CQHCI_DAT_ADDR_LO(x) (((x) & 0xFFFFFFFF) << 32)
#define CQHCI_DAT_ADDR_HI(x) (((x) & 0xFFFFFFFF) << 0)
/* CCAP - Crypto Capability 100h */
union cqhci_crypto_capabilities {
__le32 reg_val;
struct {
u8 num_crypto_cap;
u8 config_count;
u8 reserved;
u8 config_array_ptr;
};
};
enum cqhci_crypto_key_size {
CQHCI_CRYPTO_KEY_SIZE_INVALID = 0,
CQHCI_CRYPTO_KEY_SIZE_128 = 1,
CQHCI_CRYPTO_KEY_SIZE_192 = 2,
CQHCI_CRYPTO_KEY_SIZE_256 = 3,
CQHCI_CRYPTO_KEY_SIZE_512 = 4,
};
enum cqhci_crypto_alg {
CQHCI_CRYPTO_ALG_AES_XTS = 0,
CQHCI_CRYPTO_ALG_BITLOCKER_AES_CBC = 1,
CQHCI_CRYPTO_ALG_AES_ECB = 2,
CQHCI_CRYPTO_ALG_ESSIV_AES_CBC = 3,
};
/* x-CRYPTOCAP - Crypto Capability X */
union cqhci_crypto_cap_entry {
__le32 reg_val;
struct {
u8 algorithm_id;
u8 sdus_mask; /* Supported data unit size mask */
u8 key_size;
u8 reserved;
};
};
#define CQHCI_CRYPTO_CONFIGURATION_ENABLE (1 << 7)
#define CQHCI_CRYPTO_KEY_MAX_SIZE 64
/* x-CRYPTOCFG - Crypto Configuration X */
union cqhci_crypto_cfg_entry {
__le32 reg_val[32];
struct {
u8 crypto_key[CQHCI_CRYPTO_KEY_MAX_SIZE];
/* 4KB/512 = 8 */
u8 data_unit_size;
u8 crypto_cap_idx;
u8 reserved_1;
u8 config_enable;
u8 reserved_multi_host;
u8 reserved_2;
u8 vsb[2];
u8 reserved_3[56];
};
};
struct cqhci_host_ops;
struct mmc_host;
struct cqhci_slot;
struct cqhci_host {
const struct cqhci_host_ops *ops;
void __iomem *mmio;
struct mmc_host *mmc;
spinlock_t lock;
/* relative card address of device */
unsigned int rca;
/* 64 bit DMA */
bool dma64;
int num_slots;
int qcnt;
u32 dcmd_slot;
u32 caps;
#define CQHCI_TASK_DESC_SZ_128 0x1
u32 quirks;
#define CQHCI_QUIRK_SHORT_TXFR_DESC_SZ (1 << 0)
#define CQHCI_QUIRK_DIS_BEFORE_NON_CQ_CMD (1 << 1)
bool enabled;
bool halted;
bool init_done;
bool activated;
bool waiting_for_idle;
bool recovery_halt;
size_t desc_size;
size_t data_size;
u8 *desc_base;
/* total descriptor size */
u8 slot_sz;
/* 64/128 bit depends on CQHCI_CFG */
u8 task_desc_len;
/* 64 bit on 32-bit arch, 128 bit on 64-bit */
u8 link_desc_len;
u8 *trans_desc_base;
/* same length as transfer descriptor */
u8 trans_desc_len;
dma_addr_t desc_dma_base;
dma_addr_t trans_desc_dma_base;
struct completion halt_comp;
wait_queue_head_t wait_queue;
struct cqhci_slot *slot;
#ifdef CONFIG_MMC_CRYPTO
union cqhci_crypto_capabilities crypto_capabilities;
union cqhci_crypto_cap_entry *crypto_cap_array;
u32 crypto_cfg_register;
#endif
};
struct cqhci_host_ops {
void (*dumpregs)(struct mmc_host *mmc);
void (*write_l)(struct cqhci_host *host, u32 val, int reg);
u32 (*read_l)(struct cqhci_host *host, int reg);
void (*enable)(struct mmc_host *mmc);
void (*disable)(struct mmc_host *mmc, bool recovery);
};
static inline void cqhci_writel(struct cqhci_host *host, u32 val, int reg)
{
if (unlikely(host->ops->write_l))
host->ops->write_l(host, val, reg);
else
writel_relaxed(val, host->mmio + reg);
}
static inline u32 cqhci_readl(struct cqhci_host *host, int reg)
{
if (unlikely(host->ops->read_l))
return host->ops->read_l(host, reg);
else
return readl_relaxed(host->mmio + reg);
}
struct platform_device;
irqreturn_t cqhci_irq(struct mmc_host *mmc, u32 intmask, int cmd_error,
int data_error);
int cqhci_init(struct cqhci_host *cq_host, struct mmc_host *mmc, bool dma64);
struct cqhci_host *cqhci_pltfm_init(struct platform_device *pdev);
int cqhci_suspend(struct mmc_host *mmc);
int cqhci_resume(struct mmc_host *mmc);
void msdc_gate_clock(struct mmc_host *mmc);
void msdc_ungate_clock(struct mmc_host *mmc);
#endif
File diff suppressed because it is too large. Load diff
+76
View File
@@ -0,0 +1,76 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2018 Mellanox Technologies.
*/
#include <linux/bitfield.h>
#include <linux/bitops.h>
#include <linux/mmc/host.h>
#include <linux/mmc/mmc.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include "dw_mmc.h"
#include "dw_mmc-pltfm.h"
#define UHS_REG_EXT_SAMPLE_MASK GENMASK(22, 16)
#define UHS_REG_EXT_DRIVE_MASK GENMASK(29, 23)
#define BLUEFIELD_UHS_REG_EXT_SAMPLE 2
#define BLUEFIELD_UHS_REG_EXT_DRIVE 4
static void dw_mci_bluefield_set_ios(struct dw_mci *host, struct mmc_ios *ios)
{
u32 reg;
/* Update the Drive and Sample fields in register UHS_REG_EXT. */
reg = mci_readl(host, UHS_REG_EXT);
reg &= ~UHS_REG_EXT_SAMPLE_MASK;
reg |= FIELD_PREP(UHS_REG_EXT_SAMPLE_MASK,
BLUEFIELD_UHS_REG_EXT_SAMPLE);
reg &= ~UHS_REG_EXT_DRIVE_MASK;
reg |= FIELD_PREP(UHS_REG_EXT_DRIVE_MASK, BLUEFIELD_UHS_REG_EXT_DRIVE);
mci_writel(host, UHS_REG_EXT, reg);
}
static const struct dw_mci_drv_data bluefield_drv_data = {
.set_ios = dw_mci_bluefield_set_ios
};
static const struct of_device_id dw_mci_bluefield_match[] = {
{ .compatible = "mellanox,bluefield-dw-mshc",
.data = &bluefield_drv_data },
{},
};
MODULE_DEVICE_TABLE(of, dw_mci_bluefield_match);
static int dw_mci_bluefield_probe(struct platform_device *pdev)
{
const struct dw_mci_drv_data *drv_data = NULL;
const struct of_device_id *match;
if (pdev->dev.of_node) {
match = of_match_node(dw_mci_bluefield_match,
pdev->dev.of_node);
drv_data = match->data;
}
return dw_mci_pltfm_register(pdev, drv_data);
}
static struct platform_driver dw_mci_bluefield_pltfm_driver = {
.probe = dw_mci_bluefield_probe,
.remove = dw_mci_pltfm_remove,
.driver = {
.name = "dwmmc_bluefield",
.of_match_table = dw_mci_bluefield_match,
.pm = &dw_mci_pltfm_pmops,
},
};
module_platform_driver(dw_mci_bluefield_pltfm_driver);
MODULE_DESCRIPTION("BlueField DW Multimedia Card driver");
MODULE_AUTHOR("Mellanox Technologies");
MODULE_LICENSE("GPL v2");
+596
View File
@@ -0,0 +1,596 @@
/*
* Exynos Specific Extensions for Synopsys DW Multimedia Card Interface driver
*
* Copyright (C) 2012, Samsung Electronics Co., Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <linux/mmc/host.h>
#include <linux/mmc/mmc.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/pm_runtime.h>
#include <linux/slab.h>
#include "dw_mmc.h"
#include "dw_mmc-pltfm.h"
#include "dw_mmc-exynos.h"
/* Variations in Exynos specific dw-mshc controller */
enum dw_mci_exynos_type {
DW_MCI_TYPE_EXYNOS4210,
DW_MCI_TYPE_EXYNOS4412,
DW_MCI_TYPE_EXYNOS5250,
DW_MCI_TYPE_EXYNOS5420,
DW_MCI_TYPE_EXYNOS5420_SMU,
DW_MCI_TYPE_EXYNOS7,
DW_MCI_TYPE_EXYNOS7_SMU,
};
/* Exynos implementation specific driver private data */
struct dw_mci_exynos_priv_data {
enum dw_mci_exynos_type ctrl_type;
u8 ciu_div;
u32 sdr_timing;
u32 ddr_timing;
u32 hs400_timing;
u32 tuned_sample;
u32 cur_speed;
u32 dqs_delay;
u32 saved_dqs_en;
u32 saved_strobe_ctrl;
};
static struct dw_mci_exynos_compatible {
char *compatible;
enum dw_mci_exynos_type ctrl_type;
} exynos_compat[] = {
{
.compatible = "samsung,exynos4210-dw-mshc",
.ctrl_type = DW_MCI_TYPE_EXYNOS4210,
}, {
.compatible = "samsung,exynos4412-dw-mshc",
.ctrl_type = DW_MCI_TYPE_EXYNOS4412,
}, {
.compatible = "samsung,exynos5250-dw-mshc",
.ctrl_type = DW_MCI_TYPE_EXYNOS5250,
}, {
.compatible = "samsung,exynos5420-dw-mshc",
.ctrl_type = DW_MCI_TYPE_EXYNOS5420,
}, {
.compatible = "samsung,exynos5420-dw-mshc-smu",
.ctrl_type = DW_MCI_TYPE_EXYNOS5420_SMU,
}, {
.compatible = "samsung,exynos7-dw-mshc",
.ctrl_type = DW_MCI_TYPE_EXYNOS7,
}, {
.compatible = "samsung,exynos7-dw-mshc-smu",
.ctrl_type = DW_MCI_TYPE_EXYNOS7_SMU,
},
};
static inline u8 dw_mci_exynos_get_ciu_div(struct dw_mci *host)
{
struct dw_mci_exynos_priv_data *priv = host->priv;
if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS4412)
return EXYNOS4412_FIXED_CIU_CLK_DIV;
else if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS4210)
return EXYNOS4210_FIXED_CIU_CLK_DIV;
else if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
return SDMMC_CLKSEL_GET_DIV(mci_readl(host, CLKSEL64)) + 1;
else
return SDMMC_CLKSEL_GET_DIV(mci_readl(host, CLKSEL)) + 1;
}
static void dw_mci_exynos_config_smu(struct dw_mci *host)
{
struct dw_mci_exynos_priv_data *priv = host->priv;
/*
* If Exynos is provided the Security management,
* set for non-ecryption mode at this time.
*/
if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS5420_SMU ||
priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU) {
mci_writel(host, MPSBEGIN0, 0);
mci_writel(host, MPSEND0, SDMMC_ENDING_SEC_NR_MAX);
mci_writel(host, MPSCTRL0, SDMMC_MPSCTRL_SECURE_WRITE_BIT |
SDMMC_MPSCTRL_NON_SECURE_READ_BIT |
SDMMC_MPSCTRL_VALID |
SDMMC_MPSCTRL_NON_SECURE_WRITE_BIT);
}
}
static int dw_mci_exynos_priv_init(struct dw_mci *host)
{
struct dw_mci_exynos_priv_data *priv = host->priv;
dw_mci_exynos_config_smu(host);
if (priv->ctrl_type >= DW_MCI_TYPE_EXYNOS5420) {
priv->saved_strobe_ctrl = mci_readl(host, HS400_DLINE_CTRL);
priv->saved_dqs_en = mci_readl(host, HS400_DQS_EN);
priv->saved_dqs_en |= AXI_NON_BLOCKING_WR;
mci_writel(host, HS400_DQS_EN, priv->saved_dqs_en);
if (!priv->dqs_delay)
priv->dqs_delay =
DQS_CTRL_GET_RD_DELAY(priv->saved_strobe_ctrl);
}
host->bus_hz /= (priv->ciu_div + 1);
return 0;
}
static void dw_mci_exynos_set_clksel_timing(struct dw_mci *host, u32 timing)
{
struct dw_mci_exynos_priv_data *priv = host->priv;
u32 clksel;
if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
clksel = mci_readl(host, CLKSEL64);
else
clksel = mci_readl(host, CLKSEL);
clksel = (clksel & ~SDMMC_CLKSEL_TIMING_MASK) | timing;
if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
mci_writel(host, CLKSEL64, clksel);
else
mci_writel(host, CLKSEL, clksel);
/*
* Exynos4412 and Exynos5250 extends the use of CMD register with the
* use of bit 29 (which is reserved on standard MSHC controllers) for
* optionally bypassing the HOLD register for command and data. The
* HOLD register should be bypassed in case there is no phase shift
* applied on CMD/DATA that is sent to the card.
*/
if (!SDMMC_CLKSEL_GET_DRV_WD3(clksel) && host->slot)
set_bit(DW_MMC_CARD_NO_USE_HOLD, &host->slot->flags);
}
#ifdef CONFIG_PM
static int dw_mci_exynos_runtime_resume(struct device *dev)
{
struct dw_mci *host = dev_get_drvdata(dev);
int ret;
ret = dw_mci_runtime_resume(dev);
if (ret)
return ret;
dw_mci_exynos_config_smu(host);
return ret;
}
#endif /* CONFIG_PM */
#ifdef CONFIG_PM_SLEEP
/**
* dw_mci_exynos_suspend_noirq - Exynos-specific suspend code
*
* This ensures that device will be in runtime active state in
* dw_mci_exynos_resume_noirq after calling pm_runtime_force_resume()
*/
static int dw_mci_exynos_suspend_noirq(struct device *dev)
{
pm_runtime_get_noresume(dev);
return pm_runtime_force_suspend(dev);
}
/**
* dw_mci_exynos_resume_noirq - Exynos-specific resume code
*
* On exynos5420 there is a silicon errata that will sometimes leave the
* WAKEUP_INT bit in the CLKSEL register asserted. This bit is 1 to indicate
* that it fired and we can clear it by writing a 1 back. Clear it to prevent
* interrupts from going off constantly.
*
* We run this code on all exynos variants because it doesn't hurt.
*/
static int dw_mci_exynos_resume_noirq(struct device *dev)
{
struct dw_mci *host = dev_get_drvdata(dev);
struct dw_mci_exynos_priv_data *priv = host->priv;
u32 clksel;
int ret;
ret = pm_runtime_force_resume(dev);
if (ret)
return ret;
if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
clksel = mci_readl(host, CLKSEL64);
else
clksel = mci_readl(host, CLKSEL);
if (clksel & SDMMC_CLKSEL_WAKEUP_INT) {
if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
mci_writel(host, CLKSEL64, clksel);
else
mci_writel(host, CLKSEL, clksel);
}
pm_runtime_put(dev);
return 0;
}
#endif /* CONFIG_PM_SLEEP */
static void dw_mci_exynos_config_hs400(struct dw_mci *host, u32 timing)
{
struct dw_mci_exynos_priv_data *priv = host->priv;
u32 dqs, strobe;
/*
* Not supported to configure register
* related to HS400
*/
if (priv->ctrl_type < DW_MCI_TYPE_EXYNOS5420) {
if (timing == MMC_TIMING_MMC_HS400)
dev_warn(host->dev,
"cannot configure HS400, unsupported chipset\n");
return;
}
dqs = priv->saved_dqs_en;
strobe = priv->saved_strobe_ctrl;
if (timing == MMC_TIMING_MMC_HS400) {
dqs |= DATA_STROBE_EN;
strobe = DQS_CTRL_RD_DELAY(strobe, priv->dqs_delay);
} else {
dqs &= ~DATA_STROBE_EN;
}
mci_writel(host, HS400_DQS_EN, dqs);
mci_writel(host, HS400_DLINE_CTRL, strobe);
}
static void dw_mci_exynos_adjust_clock(struct dw_mci *host, unsigned int wanted)
{
struct dw_mci_exynos_priv_data *priv = host->priv;
unsigned long actual;
u8 div;
int ret;
/*
* Don't care if wanted clock is zero or
* ciu clock is unavailable
*/
if (!wanted || IS_ERR(host->ciu_clk))
return;
/* Guaranteed minimum frequency for cclkin */
if (wanted < EXYNOS_CCLKIN_MIN)
wanted = EXYNOS_CCLKIN_MIN;
if (wanted == priv->cur_speed)
return;
div = dw_mci_exynos_get_ciu_div(host);
ret = clk_set_rate(host->ciu_clk, wanted * div);
if (ret)
dev_warn(host->dev,
"failed to set clk-rate %u error: %d\n",
wanted * div, ret);
actual = clk_get_rate(host->ciu_clk);
host->bus_hz = actual / div;
priv->cur_speed = wanted;
host->current_speed = 0;
}
static void dw_mci_exynos_set_ios(struct dw_mci *host, struct mmc_ios *ios)
{
struct dw_mci_exynos_priv_data *priv = host->priv;
unsigned int wanted = ios->clock;
u32 timing = ios->timing, clksel;
switch (timing) {
case MMC_TIMING_MMC_HS400:
/* Update tuned sample timing */
clksel = SDMMC_CLKSEL_UP_SAMPLE(
priv->hs400_timing, priv->tuned_sample);
wanted <<= 1;
break;
case MMC_TIMING_MMC_DDR52:
clksel = priv->ddr_timing;
/* Should be double rate for DDR mode */
if (ios->bus_width == MMC_BUS_WIDTH_8)
wanted <<= 1;
break;
default:
clksel = priv->sdr_timing;
}
/* Set clock timing for the requested speed mode*/
dw_mci_exynos_set_clksel_timing(host, clksel);
/* Configure setting for HS400 */
dw_mci_exynos_config_hs400(host, timing);
/* Configure clock rate */
dw_mci_exynos_adjust_clock(host, wanted);
}
static int dw_mci_exynos_parse_dt(struct dw_mci *host)
{
struct dw_mci_exynos_priv_data *priv;
struct device_node *np = host->dev->of_node;
u32 timing[2];
u32 div = 0;
int idx;
int ret;
priv = devm_kzalloc(host->dev, sizeof(*priv), GFP_KERNEL);
if (!priv)
return -ENOMEM;
for (idx = 0; idx < ARRAY_SIZE(exynos_compat); idx++) {
if (of_device_is_compatible(np, exynos_compat[idx].compatible))
priv->ctrl_type = exynos_compat[idx].ctrl_type;
}
if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS4412)
priv->ciu_div = EXYNOS4412_FIXED_CIU_CLK_DIV - 1;
else if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS4210)
priv->ciu_div = EXYNOS4210_FIXED_CIU_CLK_DIV - 1;
else {
of_property_read_u32(np, "samsung,dw-mshc-ciu-div", &div);
priv->ciu_div = div;
}
ret = of_property_read_u32_array(np,
"samsung,dw-mshc-sdr-timing", timing, 2);
if (ret)
return ret;
priv->sdr_timing = SDMMC_CLKSEL_TIMING(timing[0], timing[1], div);
ret = of_property_read_u32_array(np,
"samsung,dw-mshc-ddr-timing", timing, 2);
if (ret)
return ret;
priv->ddr_timing = SDMMC_CLKSEL_TIMING(timing[0], timing[1], div);
ret = of_property_read_u32_array(np,
"samsung,dw-mshc-hs400-timing", timing, 2);
if (!ret && of_property_read_u32(np,
"samsung,read-strobe-delay", &priv->dqs_delay))
dev_dbg(host->dev,
"read-strobe-delay is not found, assuming usage of default value\n");
priv->hs400_timing = SDMMC_CLKSEL_TIMING(timing[0], timing[1],
HS400_FIXED_CIU_CLK_DIV);
host->priv = priv;
return 0;
}
static inline u8 dw_mci_exynos_get_clksmpl(struct dw_mci *host)
{
struct dw_mci_exynos_priv_data *priv = host->priv;
if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
return SDMMC_CLKSEL_CCLK_SAMPLE(mci_readl(host, CLKSEL64));
else
return SDMMC_CLKSEL_CCLK_SAMPLE(mci_readl(host, CLKSEL));
}
static inline void dw_mci_exynos_set_clksmpl(struct dw_mci *host, u8 sample)
{
u32 clksel;
struct dw_mci_exynos_priv_data *priv = host->priv;
if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
clksel = mci_readl(host, CLKSEL64);
else
clksel = mci_readl(host, CLKSEL);
clksel = SDMMC_CLKSEL_UP_SAMPLE(clksel, sample);
if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
mci_writel(host, CLKSEL64, clksel);
else
mci_writel(host, CLKSEL, clksel);
}
static inline u8 dw_mci_exynos_move_next_clksmpl(struct dw_mci *host)
{
struct dw_mci_exynos_priv_data *priv = host->priv;
u32 clksel;
u8 sample;
if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
clksel = mci_readl(host, CLKSEL64);
else
clksel = mci_readl(host, CLKSEL);
sample = (clksel + 1) & 0x7;
clksel = SDMMC_CLKSEL_UP_SAMPLE(clksel, sample);
if (priv->ctrl_type == DW_MCI_TYPE_EXYNOS7 ||
priv->ctrl_type == DW_MCI_TYPE_EXYNOS7_SMU)
mci_writel(host, CLKSEL64, clksel);
else
mci_writel(host, CLKSEL, clksel);
return sample;
}
static s8 dw_mci_exynos_get_best_clksmpl(u8 candiates)
{
const u8 iter = 8;
u8 __c;
s8 i, loc = -1;
for (i = 0; i < iter; i++) {
__c = ror8(candiates, i);
if ((__c & 0xc7) == 0xc7) {
loc = i;
goto out;
}
}
for (i = 0; i < iter; i++) {
__c = ror8(candiates, i);
if ((__c & 0x83) == 0x83) {
loc = i;
goto out;
}
}
out:
return loc;
}
static int dw_mci_exynos_execute_tuning(struct dw_mci_slot *slot, u32 opcode)
{
struct dw_mci *host = slot->host;
struct dw_mci_exynos_priv_data *priv = host->priv;
struct mmc_host *mmc = slot->mmc;
u8 start_smpl, smpl, candiates = 0;
s8 found = -1;
int ret = 0;
start_smpl = dw_mci_exynos_get_clksmpl(host);
do {
mci_writel(host, TMOUT, ~0);
smpl = dw_mci_exynos_move_next_clksmpl(host);
if (!mmc_send_tuning(mmc, opcode, NULL))
candiates |= (1 << smpl);
} while (start_smpl != smpl);
found = dw_mci_exynos_get_best_clksmpl(candiates);
if (found >= 0) {
dw_mci_exynos_set_clksmpl(host, found);
priv->tuned_sample = found;
} else {
ret = -EIO;
}
return ret;
}
static int dw_mci_exynos_prepare_hs400_tuning(struct dw_mci *host,
struct mmc_ios *ios)
{
struct dw_mci_exynos_priv_data *priv = host->priv;
dw_mci_exynos_set_clksel_timing(host, priv->hs400_timing);
dw_mci_exynos_adjust_clock(host, (ios->clock) << 1);
return 0;
}
/* Common capabilities of Exynos4/Exynos5 SoC */
static unsigned long exynos_dwmmc_caps[4] = {
MMC_CAP_1_8V_DDR | MMC_CAP_8_BIT_DATA | MMC_CAP_CMD23,
MMC_CAP_CMD23,
MMC_CAP_CMD23,
MMC_CAP_CMD23,
};
static const struct dw_mci_drv_data exynos_drv_data = {
.caps = exynos_dwmmc_caps,
.num_caps = ARRAY_SIZE(exynos_dwmmc_caps),
.init = dw_mci_exynos_priv_init,
.set_ios = dw_mci_exynos_set_ios,
.parse_dt = dw_mci_exynos_parse_dt,
.execute_tuning = dw_mci_exynos_execute_tuning,
.prepare_hs400_tuning = dw_mci_exynos_prepare_hs400_tuning,
};
static const struct of_device_id dw_mci_exynos_match[] = {
{ .compatible = "samsung,exynos4412-dw-mshc",
.data = &exynos_drv_data, },
{ .compatible = "samsung,exynos5250-dw-mshc",
.data = &exynos_drv_data, },
{ .compatible = "samsung,exynos5420-dw-mshc",
.data = &exynos_drv_data, },
{ .compatible = "samsung,exynos5420-dw-mshc-smu",
.data = &exynos_drv_data, },
{ .compatible = "samsung,exynos7-dw-mshc",
.data = &exynos_drv_data, },
{ .compatible = "samsung,exynos7-dw-mshc-smu",
.data = &exynos_drv_data, },
{},
};
MODULE_DEVICE_TABLE(of, dw_mci_exynos_match);
static int dw_mci_exynos_probe(struct platform_device *pdev)
{
const struct dw_mci_drv_data *drv_data;
const struct of_device_id *match;
int ret;
match = of_match_node(dw_mci_exynos_match, pdev->dev.of_node);
drv_data = match->data;
pm_runtime_get_noresume(&pdev->dev);
pm_runtime_set_active(&pdev->dev);
pm_runtime_enable(&pdev->dev);
ret = dw_mci_pltfm_register(pdev, drv_data);
if (ret) {
pm_runtime_disable(&pdev->dev);
pm_runtime_set_suspended(&pdev->dev);
pm_runtime_put_noidle(&pdev->dev);
return ret;
}
return 0;
}
static int dw_mci_exynos_remove(struct platform_device *pdev)
{
pm_runtime_disable(&pdev->dev);
pm_runtime_set_suspended(&pdev->dev);
pm_runtime_put_noidle(&pdev->dev);
return dw_mci_pltfm_remove(pdev);
}
static const struct dev_pm_ops dw_mci_exynos_pmops = {
SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(dw_mci_exynos_suspend_noirq,
dw_mci_exynos_resume_noirq)
SET_RUNTIME_PM_OPS(dw_mci_runtime_suspend,
dw_mci_exynos_runtime_resume,
NULL)
};
static struct platform_driver dw_mci_exynos_pltfm_driver = {
.probe = dw_mci_exynos_probe,
.remove = dw_mci_exynos_remove,
.driver = {
.name = "dwmmc_exynos",
.of_match_table = dw_mci_exynos_match,
.pm = &dw_mci_exynos_pmops,
},
};
module_platform_driver(dw_mci_exynos_pltfm_driver);
MODULE_DESCRIPTION("Samsung Specific DW-MSHC Driver Extension");
MODULE_AUTHOR("Thomas Abraham <thomas.ab@samsung.com");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:dwmmc_exynos");
+73
View File
@@ -0,0 +1,73 @@
/*
* Exynos Specific Extensions for Synopsys DW Multimedia Card Interface driver
*
* Copyright (C) 2012-2014 Samsung Electronics Co., Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#ifndef _DW_MMC_EXYNOS_H_
#define _DW_MMC_EXYNOS_H_
#define SDMMC_CLKSEL 0x09C
#define SDMMC_CLKSEL64 0x0A8
/* Extended Register's Offset */
#define SDMMC_HS400_DQS_EN 0x180
#define SDMMC_HS400_ASYNC_FIFO_CTRL 0x184
#define SDMMC_HS400_DLINE_CTRL 0x188
/* CLKSEL register defines */
#define SDMMC_CLKSEL_CCLK_SAMPLE(x) (((x) & 7) << 0)
#define SDMMC_CLKSEL_CCLK_DRIVE(x) (((x) & 7) << 16)
#define SDMMC_CLKSEL_CCLK_DIVIDER(x) (((x) & 7) << 24)
#define SDMMC_CLKSEL_GET_DRV_WD3(x) (((x) >> 16) & 0x7)
#define SDMMC_CLKSEL_GET_DIV(x) (((x) >> 24) & 0x7)
#define SDMMC_CLKSEL_UP_SAMPLE(x, y) (((x) & ~SDMMC_CLKSEL_CCLK_SAMPLE(7)) |\
SDMMC_CLKSEL_CCLK_SAMPLE(y))
#define SDMMC_CLKSEL_TIMING(x, y, z) (SDMMC_CLKSEL_CCLK_SAMPLE(x) | \
SDMMC_CLKSEL_CCLK_DRIVE(y) | \
SDMMC_CLKSEL_CCLK_DIVIDER(z))
#define SDMMC_CLKSEL_TIMING_MASK SDMMC_CLKSEL_TIMING(0x7, 0x7, 0x7)
#define SDMMC_CLKSEL_WAKEUP_INT BIT(11)
/* RCLK_EN register defines */
#define DATA_STROBE_EN BIT(0)
#define AXI_NON_BLOCKING_WR BIT(7)
/* DLINE_CTRL register defines */
#define DQS_CTRL_RD_DELAY(x, y) (((x) & ~0x3FF) | ((y) & 0x3FF))
#define DQS_CTRL_GET_RD_DELAY(x) ((x) & 0x3FF)
/* Protector Register */
#define SDMMC_EMMCP_BASE 0x1000
#define SDMMC_MPSECURITY (SDMMC_EMMCP_BASE + 0x0010)
#define SDMMC_MPSBEGIN0 (SDMMC_EMMCP_BASE + 0x0200)
#define SDMMC_MPSEND0 (SDMMC_EMMCP_BASE + 0x0204)
#define SDMMC_MPSCTRL0 (SDMMC_EMMCP_BASE + 0x020C)
/* SMU control defines */
#define SDMMC_MPSCTRL_SECURE_READ_BIT BIT(7)
#define SDMMC_MPSCTRL_SECURE_WRITE_BIT BIT(6)
#define SDMMC_MPSCTRL_NON_SECURE_READ_BIT BIT(5)
#define SDMMC_MPSCTRL_NON_SECURE_WRITE_BIT BIT(4)
#define SDMMC_MPSCTRL_USE_FUSE_KEY BIT(3)
#define SDMMC_MPSCTRL_ECB_MODE BIT(2)
#define SDMMC_MPSCTRL_ENCRYPTION BIT(1)
#define SDMMC_MPSCTRL_VALID BIT(0)
/* Maximum number of Ending sector */
#define SDMMC_ENDING_SEC_NR_MAX 0xFFFFFFFF
/* Fixed clock divider */
#define EXYNOS4210_FIXED_CIU_CLK_DIV 2
#define EXYNOS4412_FIXED_CIU_CLK_DIV 4
#define HS400_FIXED_CIU_CLK_DIV 1
/* Minimal required clock frequency for cclkin, unit: HZ */
#define EXYNOS_CCLKIN_MIN 50000000
#endif /* _DW_MMC_EXYNOS_H_ */
+202
View File
@@ -0,0 +1,202 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2018 HiSilicon Technologies Co., Ltd.
*/
#include <linux/clk.h>
#include <linux/mfd/syscon.h>
#include <linux/mmc/host.h>
#include <linux/module.h>
#include <linux/of_address.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>
#include "dw_mmc.h"
#include "dw_mmc-pltfm.h"
#define ALL_INT_CLR 0x1ffff
struct hi3798cv200_priv {
struct clk *sample_clk;
struct clk *drive_clk;
};
static void dw_mci_hi3798cv200_set_ios(struct dw_mci *host, struct mmc_ios *ios)
{
struct hi3798cv200_priv *priv = host->priv;
u32 val;
val = mci_readl(host, UHS_REG);
if (ios->timing == MMC_TIMING_MMC_DDR52 ||
ios->timing == MMC_TIMING_UHS_DDR50)
val |= SDMMC_UHS_DDR;
else
val &= ~SDMMC_UHS_DDR;
mci_writel(host, UHS_REG, val);
val = mci_readl(host, ENABLE_SHIFT);
if (ios->timing == MMC_TIMING_MMC_DDR52)
val |= SDMMC_ENABLE_PHASE;
else
val &= ~SDMMC_ENABLE_PHASE;
mci_writel(host, ENABLE_SHIFT, val);
val = mci_readl(host, DDR_REG);
if (ios->timing == MMC_TIMING_MMC_HS400)
val |= SDMMC_DDR_HS400;
else
val &= ~SDMMC_DDR_HS400;
mci_writel(host, DDR_REG, val);
if (ios->timing == MMC_TIMING_MMC_HS ||
ios->timing == MMC_TIMING_LEGACY)
clk_set_phase(priv->drive_clk, 180);
else if (ios->timing == MMC_TIMING_MMC_HS200)
clk_set_phase(priv->drive_clk, 135);
}
static int dw_mci_hi3798cv200_execute_tuning(struct dw_mci_slot *slot,
u32 opcode)
{
int degrees[] = { 0, 45, 90, 135, 180, 225, 270, 315 };
struct dw_mci *host = slot->host;
struct hi3798cv200_priv *priv = host->priv;
int raise_point = -1, fall_point = -1;
int err, prev_err = -1;
int found = 0;
int i;
for (i = 0; i < ARRAY_SIZE(degrees); i++) {
clk_set_phase(priv->sample_clk, degrees[i]);
mci_writel(host, RINTSTS, ALL_INT_CLR);
err = mmc_send_tuning(slot->mmc, opcode, NULL);
if (!err)
found = 1;
if (i > 0) {
if (err && !prev_err)
fall_point = i - 1;
if (!err && prev_err)
raise_point = i;
}
if (raise_point != -1 && fall_point != -1)
goto tuning_out;
prev_err = err;
err = 0;
}
tuning_out:
if (found) {
if (raise_point == -1)
raise_point = 0;
if (fall_point == -1)
fall_point = ARRAY_SIZE(degrees) - 1;
if (fall_point < raise_point) {
if ((raise_point + fall_point) >
(ARRAY_SIZE(degrees) - 1))
i = fall_point / 2;
else
i = (raise_point + ARRAY_SIZE(degrees) - 1) / 2;
} else {
i = (raise_point + fall_point) / 2;
}
clk_set_phase(priv->sample_clk, degrees[i]);
dev_dbg(host->dev, "Tuning clk_sample[%d, %d], set[%d]\n",
raise_point, fall_point, degrees[i]);
} else {
dev_err(host->dev, "No valid clk_sample shift! use default\n");
err = -EINVAL;
}
mci_writel(host, RINTSTS, ALL_INT_CLR);
return err;
}
static int dw_mci_hi3798cv200_init(struct dw_mci *host)
{
struct hi3798cv200_priv *priv;
int ret;
priv = devm_kzalloc(host->dev, sizeof(*priv), GFP_KERNEL);
if (!priv)
return -ENOMEM;
priv->sample_clk = devm_clk_get(host->dev, "ciu-sample");
if (IS_ERR(priv->sample_clk)) {
dev_err(host->dev, "failed to get ciu-sample clock\n");
return PTR_ERR(priv->sample_clk);
}
priv->drive_clk = devm_clk_get(host->dev, "ciu-drive");
if (IS_ERR(priv->drive_clk)) {
dev_err(host->dev, "failed to get ciu-drive clock\n");
return PTR_ERR(priv->drive_clk);
}
ret = clk_prepare_enable(priv->sample_clk);
if (ret) {
dev_err(host->dev, "failed to enable ciu-sample clock\n");
return ret;
}
ret = clk_prepare_enable(priv->drive_clk);
if (ret) {
dev_err(host->dev, "failed to enable ciu-drive clock\n");
goto disable_sample_clk;
}
host->priv = priv;
return 0;
disable_sample_clk:
clk_disable_unprepare(priv->sample_clk);
return ret;
}
static const struct dw_mci_drv_data hi3798cv200_data = {
.init = dw_mci_hi3798cv200_init,
.set_ios = dw_mci_hi3798cv200_set_ios,
.execute_tuning = dw_mci_hi3798cv200_execute_tuning,
};
static int dw_mci_hi3798cv200_probe(struct platform_device *pdev)
{
return dw_mci_pltfm_register(pdev, &hi3798cv200_data);
}
static int dw_mci_hi3798cv200_remove(struct platform_device *pdev)
{
struct dw_mci *host = platform_get_drvdata(pdev);
struct hi3798cv200_priv *priv = host->priv;
clk_disable_unprepare(priv->drive_clk);
clk_disable_unprepare(priv->sample_clk);
return dw_mci_pltfm_remove(pdev);
}
static const struct of_device_id dw_mci_hi3798cv200_match[] = {
{ .compatible = "hisilicon,hi3798cv200-dw-mshc", },
{},
};
MODULE_DEVICE_TABLE(of, dw_mci_hi3798cv200_match);
static struct platform_driver dw_mci_hi3798cv200_driver = {
.probe = dw_mci_hi3798cv200_probe,
.remove = dw_mci_hi3798cv200_remove,
.driver = {
.name = "dwmmc_hi3798cv200",
.of_match_table = dw_mci_hi3798cv200_match,
},
};
module_platform_driver(dw_mci_hi3798cv200_driver);
MODULE_DESCRIPTION("HiSilicon Hi3798CV200 Specific DW-MSHC Driver Extension");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:dwmmc_hi3798cv200");
+489
View File
@@ -0,0 +1,489 @@
/*
* Copyright (c) 2013 Linaro Ltd.
* Copyright (c) 2013 Hisilicon Limited.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#include <linux/bitops.h>
#include <linux/bitfield.h>
#include <linux/clk.h>
#include <linux/mfd/syscon.h>
#include <linux/mmc/host.h>
#include <linux/module.h>
#include <linux/of_address.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>
#include "dw_mmc.h"
#include "dw_mmc-pltfm.h"
/*
* hi6220 sd only support io voltage 1.8v and 3v
* Also need config AO_SCTRL_SEL18 accordingly
*/
#define AO_SCTRL_SEL18 BIT(10)
#define AO_SCTRL_CTRL3 0x40C
#define DWMMC_SDIO_ID 2
#define SOC_SCTRL_SCPERCTRL5 (0x314)
#define SDCARD_IO_SEL18 BIT(2)
#define SDCARD_RD_THRESHOLD (512)
#define GENCLK_DIV (7)
#define GPIO_CLK_ENABLE BIT(16)
#define GPIO_CLK_DIV_MASK GENMASK(11, 8)
#define GPIO_USE_SAMPLE_DLY_MASK GENMASK(13, 13)
#define UHS_REG_EXT_SAMPLE_PHASE_MASK GENMASK(20, 16)
#define UHS_REG_EXT_SAMPLE_DRVPHASE_MASK GENMASK(25, 21)
#define UHS_REG_EXT_SAMPLE_DLY_MASK GENMASK(30, 26)
#define TIMING_MODE 3
#define TIMING_CFG_NUM 10
#define NUM_PHASES (40)
#define ENABLE_SHIFT_MIN_SMPL (4)
#define ENABLE_SHIFT_MAX_SMPL (12)
#define USE_DLY_MIN_SMPL (11)
#define USE_DLY_MAX_SMPL (14)
struct k3_priv {
int ctrl_id;
u32 cur_speed;
struct regmap *reg;
};
static unsigned long dw_mci_hi6220_caps[] = {
MMC_CAP_CMD23,
MMC_CAP_CMD23,
0
};
struct hs_timing {
u32 drv_phase;
u32 smpl_dly;
u32 smpl_phase_max;
u32 smpl_phase_min;
};
static struct hs_timing hs_timing_cfg[TIMING_MODE][TIMING_CFG_NUM] = {
{ /* reserved */ },
{ /* SD */
{7, 0, 15, 15,}, /* 0: LEGACY 400k */
{6, 0, 4, 4,}, /* 1: MMC_HS */
{6, 0, 3, 3,}, /* 2: SD_HS */
{6, 0, 15, 15,}, /* 3: SDR12 */
{6, 0, 2, 2,}, /* 4: SDR25 */
{4, 0, 11, 0,}, /* 5: SDR50 */
{6, 4, 15, 0,}, /* 6: SDR104 */
{0}, /* 7: DDR50 */
{0}, /* 8: DDR52 */
{0}, /* 9: HS200 */
},
{ /* SDIO */
{7, 0, 15, 15,}, /* 0: LEGACY 400k */
{0}, /* 1: MMC_HS */
{6, 0, 15, 15,}, /* 2: SD_HS */
{6, 0, 15, 15,}, /* 3: SDR12 */
{6, 0, 0, 0,}, /* 4: SDR25 */
{4, 0, 12, 0,}, /* 5: SDR50 */
{5, 4, 15, 0,}, /* 6: SDR104 */
{0}, /* 7: DDR50 */
{0}, /* 8: DDR52 */
{0}, /* 9: HS200 */
}
};
static void dw_mci_k3_set_ios(struct dw_mci *host, struct mmc_ios *ios)
{
int ret;
ret = clk_set_rate(host->ciu_clk, ios->clock);
if (ret)
dev_warn(host->dev, "failed to set rate %uHz\n", ios->clock);
host->bus_hz = clk_get_rate(host->ciu_clk);
}
static const struct dw_mci_drv_data k3_drv_data = {
.set_ios = dw_mci_k3_set_ios,
};
static int dw_mci_hi6220_parse_dt(struct dw_mci *host)
{
struct k3_priv *priv;
priv = devm_kzalloc(host->dev, sizeof(*priv), GFP_KERNEL);
if (!priv)
return -ENOMEM;
priv->reg = syscon_regmap_lookup_by_phandle(host->dev->of_node,
"hisilicon,peripheral-syscon");
if (IS_ERR(priv->reg))
priv->reg = NULL;
priv->ctrl_id = of_alias_get_id(host->dev->of_node, "mshc");
if (priv->ctrl_id < 0)
priv->ctrl_id = 0;
if (priv->ctrl_id >= TIMING_MODE)
return -EINVAL;
host->priv = priv;
return 0;
}
static int dw_mci_hi6220_switch_voltage(struct mmc_host *mmc, struct mmc_ios *ios)
{
struct dw_mci_slot *slot = mmc_priv(mmc);
struct k3_priv *priv;
struct dw_mci *host;
int min_uv, max_uv;
int ret;
host = slot->host;
priv = host->priv;
if (!priv || !priv->reg)
return 0;
if (ios->signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
ret = regmap_update_bits(priv->reg, AO_SCTRL_CTRL3,
AO_SCTRL_SEL18, 0);
min_uv = 3000000;
max_uv = 3000000;
} else if (ios->signal_voltage == MMC_SIGNAL_VOLTAGE_180) {
ret = regmap_update_bits(priv->reg, AO_SCTRL_CTRL3,
AO_SCTRL_SEL18, AO_SCTRL_SEL18);
min_uv = 1800000;
max_uv = 1800000;
} else {
dev_dbg(host->dev, "voltage not supported\n");
return -EINVAL;
}
if (ret) {
dev_dbg(host->dev, "switch voltage failed\n");
return ret;
}
if (IS_ERR_OR_NULL(mmc->supply.vqmmc))
return 0;
ret = regulator_set_voltage(mmc->supply.vqmmc, min_uv, max_uv);
if (ret) {
dev_dbg(host->dev, "Regulator set error %d: %d - %d\n",
ret, min_uv, max_uv);
return ret;
}
return 0;
}
static void dw_mci_hi6220_set_ios(struct dw_mci *host, struct mmc_ios *ios)
{
int ret;
unsigned int clock;
clock = (ios->clock <= 25000000) ? 25000000 : ios->clock;
ret = clk_set_rate(host->biu_clk, clock);
if (ret)
dev_warn(host->dev, "failed to set rate %uHz\n", clock);
host->bus_hz = clk_get_rate(host->biu_clk);
}
static int dw_mci_hi6220_execute_tuning(struct dw_mci_slot *slot, u32 opcode)
{
return 0;
}
static const struct dw_mci_drv_data hi6220_data = {
.caps = dw_mci_hi6220_caps,
.num_caps = ARRAY_SIZE(dw_mci_hi6220_caps),
.switch_voltage = dw_mci_hi6220_switch_voltage,
.set_ios = dw_mci_hi6220_set_ios,
.parse_dt = dw_mci_hi6220_parse_dt,
.execute_tuning = dw_mci_hi6220_execute_tuning,
};
static void dw_mci_hs_set_timing(struct dw_mci *host, int timing,
int smpl_phase)
{
u32 drv_phase;
u32 smpl_dly;
u32 use_smpl_dly = 0;
u32 enable_shift = 0;
u32 reg_value;
int ctrl_id;
struct k3_priv *priv;
priv = host->priv;
ctrl_id = priv->ctrl_id;
drv_phase = hs_timing_cfg[ctrl_id][timing].drv_phase;
smpl_dly = hs_timing_cfg[ctrl_id][timing].smpl_dly;
if (smpl_phase == -1)
smpl_phase = (hs_timing_cfg[ctrl_id][timing].smpl_phase_max +
hs_timing_cfg[ctrl_id][timing].smpl_phase_min) / 2;
switch (timing) {
case MMC_TIMING_UHS_SDR104:
if (smpl_phase >= USE_DLY_MIN_SMPL &&
smpl_phase <= USE_DLY_MAX_SMPL)
use_smpl_dly = 1;
/* fallthrough */
case MMC_TIMING_UHS_SDR50:
if (smpl_phase >= ENABLE_SHIFT_MIN_SMPL &&
smpl_phase <= ENABLE_SHIFT_MAX_SMPL)
enable_shift = 1;
break;
}
mci_writel(host, GPIO, 0x0);
usleep_range(5, 10);
reg_value = FIELD_PREP(UHS_REG_EXT_SAMPLE_PHASE_MASK, smpl_phase) |
FIELD_PREP(UHS_REG_EXT_SAMPLE_DLY_MASK, smpl_dly) |
FIELD_PREP(UHS_REG_EXT_SAMPLE_DRVPHASE_MASK, drv_phase);
mci_writel(host, UHS_REG_EXT, reg_value);
mci_writel(host, ENABLE_SHIFT, enable_shift);
reg_value = FIELD_PREP(GPIO_CLK_DIV_MASK, GENCLK_DIV) |
FIELD_PREP(GPIO_USE_SAMPLE_DLY_MASK, use_smpl_dly);
mci_writel(host, GPIO, (unsigned int)reg_value | GPIO_CLK_ENABLE);
/* We should delay 1ms wait for timing setting finished. */
usleep_range(1000, 2000);
}
static int dw_mci_hi3660_init(struct dw_mci *host)
{
mci_writel(host, CDTHRCTL, SDMMC_SET_THLD(SDCARD_RD_THRESHOLD,
SDMMC_CARD_RD_THR_EN));
dw_mci_hs_set_timing(host, MMC_TIMING_LEGACY, -1);
host->bus_hz /= (GENCLK_DIV + 1);
return 0;
}
static int dw_mci_set_sel18(struct dw_mci *host, bool set)
{
int ret;
unsigned int val;
struct k3_priv *priv;
priv = host->priv;
val = set ? SDCARD_IO_SEL18 : 0;
ret = regmap_update_bits(priv->reg, SOC_SCTRL_SCPERCTRL5,
SDCARD_IO_SEL18, val);
if (ret) {
dev_err(host->dev, "sel18 %u error\n", val);
return ret;
}
return 0;
}
static void dw_mci_hi3660_set_ios(struct dw_mci *host, struct mmc_ios *ios)
{
int ret;
unsigned long wanted;
unsigned long actual;
struct k3_priv *priv = host->priv;
if (!ios->clock || ios->clock == priv->cur_speed)
return;
wanted = ios->clock * (GENCLK_DIV + 1);
ret = clk_set_rate(host->ciu_clk, wanted);
if (ret) {
dev_err(host->dev, "failed to set rate %luHz\n", wanted);
return;
}
actual = clk_get_rate(host->ciu_clk);
dw_mci_hs_set_timing(host, ios->timing, -1);
host->bus_hz = actual / (GENCLK_DIV + 1);
host->current_speed = 0;
priv->cur_speed = host->bus_hz;
}
static int dw_mci_get_best_clksmpl(unsigned int sample_flag)
{
int i;
int interval;
unsigned int v;
unsigned int len;
unsigned int range_start = 0;
unsigned int range_length = 0;
unsigned int middle_range = 0;
if (!sample_flag)
return -EIO;
if (~sample_flag == 0)
return 0;
i = ffs(sample_flag) - 1;
/*
* A clock cycle is divided into 32 phases,
* each of which is represented by a bit,
* finding the optimal phase.
*/
while (i < 32) {
v = ror32(sample_flag, i);
len = ffs(~v) - 1;
if (len > range_length) {
range_length = len;
range_start = i;
}
interval = ffs(v >> len) - 1;
if (interval < 0)
break;
i += len + interval;
}
middle_range = range_start + range_length / 2;
if (middle_range >= 32)
middle_range %= 32;
return middle_range;
}
static int dw_mci_hi3660_execute_tuning(struct dw_mci_slot *slot, u32 opcode)
{
int i = 0;
struct dw_mci *host = slot->host;
struct mmc_host *mmc = slot->mmc;
int smpl_phase = 0;
u32 tuning_sample_flag = 0;
int best_clksmpl = 0;
for (i = 0; i < NUM_PHASES; ++i, ++smpl_phase) {
smpl_phase %= 32;
mci_writel(host, TMOUT, ~0);
dw_mci_hs_set_timing(host, mmc->ios.timing, smpl_phase);
if (!mmc_send_tuning(mmc, opcode, NULL))
tuning_sample_flag |= (1 << smpl_phase);
else
tuning_sample_flag &= ~(1 << smpl_phase);
}
best_clksmpl = dw_mci_get_best_clksmpl(tuning_sample_flag);
if (best_clksmpl < 0) {
dev_err(host->dev, "All phases bad!\n");
return -EIO;
}
dw_mci_hs_set_timing(host, mmc->ios.timing, best_clksmpl);
dev_info(host->dev, "tuning ok best_clksmpl %u tuning_sample_flag %x\n",
best_clksmpl, tuning_sample_flag);
return 0;
}
static int dw_mci_hi3660_switch_voltage(struct mmc_host *mmc,
struct mmc_ios *ios)
{
int ret = 0;
struct dw_mci_slot *slot = mmc_priv(mmc);
struct k3_priv *priv;
struct dw_mci *host;
host = slot->host;
priv = host->priv;
if (!priv || !priv->reg)
return 0;
if (priv->ctrl_id == DWMMC_SDIO_ID)
return 0;
if (ios->signal_voltage == MMC_SIGNAL_VOLTAGE_330)
ret = dw_mci_set_sel18(host, 0);
else if (ios->signal_voltage == MMC_SIGNAL_VOLTAGE_180)
ret = dw_mci_set_sel18(host, 1);
if (ret)
return ret;
if (!IS_ERR(mmc->supply.vqmmc)) {
ret = mmc_regulator_set_vqmmc(mmc, ios);
if (ret) {
dev_err(host->dev, "Regulator set error %d\n", ret);
return ret;
}
}
return 0;
}
static const struct dw_mci_drv_data hi3660_data = {
.init = dw_mci_hi3660_init,
.set_ios = dw_mci_hi3660_set_ios,
.parse_dt = dw_mci_hi6220_parse_dt,
.execute_tuning = dw_mci_hi3660_execute_tuning,
.switch_voltage = dw_mci_hi3660_switch_voltage,
};
static const struct of_device_id dw_mci_k3_match[] = {
{ .compatible = "hisilicon,hi3660-dw-mshc", .data = &hi3660_data, },
{ .compatible = "hisilicon,hi4511-dw-mshc", .data = &k3_drv_data, },
{ .compatible = "hisilicon,hi6220-dw-mshc", .data = &hi6220_data, },
{},
};
MODULE_DEVICE_TABLE(of, dw_mci_k3_match);
static int dw_mci_k3_probe(struct platform_device *pdev)
{
const struct dw_mci_drv_data *drv_data;
const struct of_device_id *match;
match = of_match_node(dw_mci_k3_match, pdev->dev.of_node);
drv_data = match->data;
return dw_mci_pltfm_register(pdev, drv_data);
}
static const struct dev_pm_ops dw_mci_k3_dev_pm_ops = {
SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
pm_runtime_force_resume)
SET_RUNTIME_PM_OPS(dw_mci_runtime_suspend,
dw_mci_runtime_resume,
NULL)
};
static struct platform_driver dw_mci_k3_pltfm_driver = {
.probe = dw_mci_k3_probe,
.remove = dw_mci_pltfm_remove,
.driver = {
.name = "dwmmc_k3",
.of_match_table = dw_mci_k3_match,
.pm = &dw_mci_k3_dev_pm_ops,
},
};
module_platform_driver(dw_mci_k3_pltfm_driver);
MODULE_DESCRIPTION("K3 Specific DW-MSHC Driver Extension");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:dwmmc_k3");
+109
View File
@@ -0,0 +1,109 @@
/*
* Synopsys DesignWare Multimedia Card PCI Interface driver
*
* Copyright (C) 2012 Vayavya Labs Pvt. Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/pci.h>
#include <linux/pm_runtime.h>
#include <linux/slab.h>
#include <linux/mmc/host.h>
#include <linux/mmc/mmc.h>
#include "dw_mmc.h"
#define PCI_BAR_NO 2
#define SYNOPSYS_DW_MCI_VENDOR_ID 0x700
#define SYNOPSYS_DW_MCI_DEVICE_ID 0x1107
/* Defining the Capabilities */
#define DW_MCI_CAPABILITIES (MMC_CAP_4_BIT_DATA | MMC_CAP_MMC_HIGHSPEED |\
MMC_CAP_SD_HIGHSPEED | MMC_CAP_8_BIT_DATA |\
MMC_CAP_SDIO_IRQ)
static struct dw_mci_board pci_board_data = {
.caps = DW_MCI_CAPABILITIES,
.bus_hz = 33 * 1000 * 1000,
.detect_delay_ms = 200,
.fifo_depth = 32,
};
static int dw_mci_pci_probe(struct pci_dev *pdev,
const struct pci_device_id *entries)
{
struct dw_mci *host;
int ret;
ret = pcim_enable_device(pdev);
if (ret)
return ret;
host = devm_kzalloc(&pdev->dev, sizeof(struct dw_mci), GFP_KERNEL);
if (!host)
return -ENOMEM;
host->irq = pdev->irq;
host->irq_flags = IRQF_SHARED;
host->dev = &pdev->dev;
host->pdata = &pci_board_data;
ret = pcim_iomap_regions(pdev, 1 << PCI_BAR_NO, pci_name(pdev));
if (ret)
return ret;
host->regs = pcim_iomap_table(pdev)[PCI_BAR_NO];
pci_set_master(pdev);
ret = dw_mci_probe(host);
if (ret)
return ret;
pci_set_drvdata(pdev, host);
return 0;
}
static void dw_mci_pci_remove(struct pci_dev *pdev)
{
struct dw_mci *host = pci_get_drvdata(pdev);
dw_mci_remove(host);
}
static const struct dev_pm_ops dw_mci_pci_dev_pm_ops = {
SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
pm_runtime_force_resume)
SET_RUNTIME_PM_OPS(dw_mci_runtime_suspend,
dw_mci_runtime_resume,
NULL)
};
static const struct pci_device_id dw_mci_pci_id[] = {
{ PCI_DEVICE(SYNOPSYS_DW_MCI_VENDOR_ID, SYNOPSYS_DW_MCI_DEVICE_ID) },
{}
};
MODULE_DEVICE_TABLE(pci, dw_mci_pci_id);
static struct pci_driver dw_mci_pci_driver = {
.name = "dw_mmc_pci",
.id_table = dw_mci_pci_id,
.probe = dw_mci_pci_probe,
.remove = dw_mci_pci_remove,
.driver = {
.pm = &dw_mci_pci_dev_pm_ops,
},
};
module_pci_driver(dw_mci_pci_driver);
MODULE_DESCRIPTION("DW Multimedia Card PCI Interface driver");
MODULE_AUTHOR("Shashidhar Hiremath <shashidharh@vayavyalabs.com>");
MODULE_LICENSE("GPL v2");
+115
View File
@@ -0,0 +1,115 @@
/*
* Synopsys DesignWare Multimedia Card Interface driver
*
* Copyright (C) 2009 NXP Semiconductors
* Copyright (C) 2009, 2010 Imagination Technologies Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#include <linux/err.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/slab.h>
#include <linux/mmc/host.h>
#include <linux/mmc/mmc.h>
#include <linux/of.h>
#include <linux/clk.h>
#include "dw_mmc.h"
#include "dw_mmc-pltfm.h"
int dw_mci_pltfm_register(struct platform_device *pdev,
const struct dw_mci_drv_data *drv_data)
{
struct dw_mci *host;
struct resource *regs;
host = devm_kzalloc(&pdev->dev, sizeof(struct dw_mci), GFP_KERNEL);
if (!host)
return -ENOMEM;
host->irq = platform_get_irq(pdev, 0);
if (host->irq < 0)
return host->irq;
host->drv_data = drv_data;
host->dev = &pdev->dev;
host->irq_flags = 0;
host->pdata = pdev->dev.platform_data;
regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
host->regs = devm_ioremap_resource(&pdev->dev, regs);
if (IS_ERR(host->regs))
return PTR_ERR(host->regs);
/* Get registers' physical base address */
host->phy_regs = regs->start;
platform_set_drvdata(pdev, host);
return dw_mci_probe(host);
}
EXPORT_SYMBOL_GPL(dw_mci_pltfm_register);
const struct dev_pm_ops dw_mci_pltfm_pmops = {
SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
pm_runtime_force_resume)
SET_RUNTIME_PM_OPS(dw_mci_runtime_suspend,
dw_mci_runtime_resume,
NULL)
};
EXPORT_SYMBOL_GPL(dw_mci_pltfm_pmops);
static const struct of_device_id dw_mci_pltfm_match[] = {
{ .compatible = "snps,dw-mshc", },
{ .compatible = "altr,socfpga-dw-mshc", },
{ .compatible = "img,pistachio-dw-mshc", },
{},
};
MODULE_DEVICE_TABLE(of, dw_mci_pltfm_match);
static int dw_mci_pltfm_probe(struct platform_device *pdev)
{
const struct dw_mci_drv_data *drv_data = NULL;
const struct of_device_id *match;
if (pdev->dev.of_node) {
match = of_match_node(dw_mci_pltfm_match, pdev->dev.of_node);
drv_data = match->data;
}
return dw_mci_pltfm_register(pdev, drv_data);
}
int dw_mci_pltfm_remove(struct platform_device *pdev)
{
struct dw_mci *host = platform_get_drvdata(pdev);
dw_mci_remove(host);
return 0;
}
EXPORT_SYMBOL_GPL(dw_mci_pltfm_remove);
static struct platform_driver dw_mci_pltfm_driver = {
.probe = dw_mci_pltfm_probe,
.remove = dw_mci_pltfm_remove,
.driver = {
.name = "dw_mmc",
.of_match_table = dw_mci_pltfm_match,
.pm = &dw_mci_pltfm_pmops,
},
};
module_platform_driver(dw_mci_pltfm_driver);
MODULE_DESCRIPTION("DW Multimedia Card Interface driver");
MODULE_AUTHOR("NXP Semiconductor VietNam");
MODULE_AUTHOR("Imagination Technologies Ltd");
MODULE_LICENSE("GPL v2");
+20
View File
@@ -0,0 +1,20 @@
/*
* Synopsys DesignWare Multimedia Card Interface Platform driver
*
* Copyright (C) 2012, Samsung Electronics Co., Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#ifndef _DW_MMC_PLTFM_H_
#define _DW_MMC_PLTFM_H_
extern int dw_mci_pltfm_register(struct platform_device *pdev,
const struct dw_mci_drv_data *drv_data);
extern int dw_mci_pltfm_remove(struct platform_device *pdev);
extern const struct dev_pm_ops dw_mci_pltfm_pmops;
#endif /* _DW_MMC_PLTFM_H_ */
+400
View File
@@ -0,0 +1,400 @@
/*
* Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <linux/mmc/host.h>
#include <linux/of_address.h>
#include <linux/mmc/slot-gpio.h>
#include <linux/pm_runtime.h>
#include <linux/slab.h>
#include "dw_mmc.h"
#include "dw_mmc-pltfm.h"
#define RK3288_CLKGEN_DIV 2
struct dw_mci_rockchip_priv_data {
struct clk *drv_clk;
struct clk *sample_clk;
int default_sample_phase;
int num_phases;
};
static void dw_mci_rk3288_set_ios(struct dw_mci *host, struct mmc_ios *ios)
{
struct dw_mci_rockchip_priv_data *priv = host->priv;
int ret;
unsigned int cclkin;
u32 bus_hz;
if (ios->clock == 0)
return;
/*
* cclkin: source clock of mmc controller
* bus_hz: card interface clock generated by CLKGEN
* bus_hz = cclkin / RK3288_CLKGEN_DIV
* ios->clock = (div == 0) ? bus_hz : (bus_hz / (2 * div))
*
* Note: div can only be 0 or 1, but div must be set to 1 for eMMC
* DDR52 8-bit mode.
*/
if (ios->bus_width == MMC_BUS_WIDTH_8 &&
ios->timing == MMC_TIMING_MMC_DDR52)
cclkin = 2 * ios->clock * RK3288_CLKGEN_DIV;
else
cclkin = ios->clock * RK3288_CLKGEN_DIV;
ret = clk_set_rate(host->ciu_clk, cclkin);
if (ret)
dev_warn(host->dev, "failed to set rate %uHz\n", ios->clock);
bus_hz = clk_get_rate(host->ciu_clk) / RK3288_CLKGEN_DIV;
if (bus_hz != host->bus_hz) {
host->bus_hz = bus_hz;
/* force dw_mci_setup_bus() */
host->current_speed = 0;
}
/* Make sure we use phases which we can enumerate with */
if (!IS_ERR(priv->sample_clk))
clk_set_phase(priv->sample_clk, priv->default_sample_phase);
/*
* Set the drive phase offset based on speed mode to achieve hold times.
*
* NOTE: this is _not_ a value that is dynamically tuned and is also
* _not_ a value that will vary from board to board. It is a value
* that could vary between different SoC models if they had massively
* different output clock delays inside their dw_mmc IP block (delay_o),
* but since it's OK to overshoot a little we don't need to do complex
* calculations and can pick values that will just work for everyone.
*
* When picking values we'll stick with picking 0/90/180/270 since
* those can be made very accurately on all known Rockchip SoCs.
*
* Note that these values match values from the DesignWare Databook
* tables for the most part except for SDR12 and "ID mode". For those
* two modes the databook calculations assume a clock in of 50MHz. As
* seen above, we always use a clock in rate that is exactly the
* card's input clock (times RK3288_CLKGEN_DIV, but that gets divided
* back out before the controller sees it).
*
* From measurement of a single device, it appears that delay_o is
* about .5 ns. Since we try to leave a bit of margin, it's expected
* that numbers here will be fine even with much larger delay_o
* (the 1.4 ns assumed by the DesignWare Databook would result in the
* same results, for instance).
*/
if (!IS_ERR(priv->drv_clk)) {
int phase;
/*
* In almost all cases a 90 degree phase offset will provide
* sufficient hold times across all valid input clock rates
* assuming delay_o is not absurd for a given SoC. We'll use
* that as a default.
*/
phase = 90;
switch (ios->timing) {
case MMC_TIMING_MMC_DDR52:
/*
* Since clock in rate with MMC_DDR52 is doubled when
* bus width is 8 we need to double the phase offset
* to get the same timings.
*/
if (ios->bus_width == MMC_BUS_WIDTH_8)
phase = 180;
break;
case MMC_TIMING_UHS_SDR104:
case MMC_TIMING_MMC_HS200:
/*
* In the case of 150 MHz clock (typical max for
* Rockchip SoCs), 90 degree offset will add a delay
* of 1.67 ns. That will meet min hold time of .8 ns
* as long as clock output delay is < .87 ns. On
* SoCs measured this seems to be OK, but it doesn't
* hurt to give margin here, so we use 180.
*/
phase = 180;
break;
}
clk_set_phase(priv->drv_clk, phase);
}
}
#define TUNING_ITERATION_TO_PHASE(i, num_phases) \
(DIV_ROUND_UP((i) * 360, num_phases))
static int dw_mci_rk3288_execute_tuning(struct dw_mci_slot *slot, u32 opcode)
{
struct dw_mci *host = slot->host;
struct dw_mci_rockchip_priv_data *priv = host->priv;
struct mmc_host *mmc = slot->mmc;
int ret = 0;
int i;
bool v, prev_v = 0, first_v;
struct range_t {
int start;
int end; /* inclusive */
};
struct range_t *ranges;
unsigned int range_count = 0;
int longest_range_len = -1;
int longest_range = -1;
int middle_phase;
if (IS_ERR(priv->sample_clk)) {
dev_err(host->dev, "Tuning clock (sample_clk) not defined.\n");
return -EIO;
}
ranges = kmalloc_array(priv->num_phases / 2 + 1,
sizeof(*ranges), GFP_KERNEL);
if (!ranges)
return -ENOMEM;
/* Try each phase and extract good ranges */
for (i = 0; i < priv->num_phases; ) {
clk_set_phase(priv->sample_clk,
TUNING_ITERATION_TO_PHASE(i, priv->num_phases));
v = !mmc_send_tuning(mmc, opcode, NULL);
if (i == 0)
first_v = v;
if ((!prev_v) && v) {
range_count++;
ranges[range_count-1].start = i;
}
if (v) {
ranges[range_count-1].end = i;
i++;
} else if (i == priv->num_phases - 1) {
/* No extra skipping rules if we're at the end */
i++;
} else {
/*
* No need to check too close to an invalid
* one since testing bad phases is slow. Skip
* 20 degrees.
*/
i += DIV_ROUND_UP(20 * priv->num_phases, 360);
/* Always test the last one */
if (i >= priv->num_phases)
i = priv->num_phases - 1;
}
prev_v = v;
}
if (range_count == 0) {
dev_warn(host->dev, "All phases bad!");
ret = -EIO;
goto free;
}
/* wrap around case, merge the end points */
if ((range_count > 1) && first_v && v) {
ranges[0].start = ranges[range_count-1].start;
range_count--;
}
if (ranges[0].start == 0 && ranges[0].end == priv->num_phases - 1) {
clk_set_phase(priv->sample_clk, priv->default_sample_phase);
dev_info(host->dev, "All phases work, using default phase %d.",
priv->default_sample_phase);
goto free;
}
/* Find the longest range */
for (i = 0; i < range_count; i++) {
int len = (ranges[i].end - ranges[i].start + 1);
if (len < 0)
len += priv->num_phases;
if (longest_range_len < len) {
longest_range_len = len;
longest_range = i;
}
dev_dbg(host->dev, "Good phase range %d-%d (%d len)\n",
TUNING_ITERATION_TO_PHASE(ranges[i].start,
priv->num_phases),
TUNING_ITERATION_TO_PHASE(ranges[i].end,
priv->num_phases),
len
);
}
dev_dbg(host->dev, "Best phase range %d-%d (%d len)\n",
TUNING_ITERATION_TO_PHASE(ranges[longest_range].start,
priv->num_phases),
TUNING_ITERATION_TO_PHASE(ranges[longest_range].end,
priv->num_phases),
longest_range_len
);
middle_phase = ranges[longest_range].start + longest_range_len / 2;
middle_phase %= priv->num_phases;
dev_info(host->dev, "Successfully tuned phase to %d\n",
TUNING_ITERATION_TO_PHASE(middle_phase, priv->num_phases));
clk_set_phase(priv->sample_clk,
TUNING_ITERATION_TO_PHASE(middle_phase,
priv->num_phases));
free:
kfree(ranges);
return ret;
}
static int dw_mci_rk3288_parse_dt(struct dw_mci *host)
{
struct device_node *np = host->dev->of_node;
struct dw_mci_rockchip_priv_data *priv;
priv = devm_kzalloc(host->dev, sizeof(*priv), GFP_KERNEL);
if (!priv)
return -ENOMEM;
if (of_property_read_u32(np, "rockchip,desired-num-phases",
&priv->num_phases))
priv->num_phases = 360;
if (of_property_read_u32(np, "rockchip,default-sample-phase",
&priv->default_sample_phase))
priv->default_sample_phase = 0;
priv->drv_clk = devm_clk_get(host->dev, "ciu-drive");
if (IS_ERR(priv->drv_clk))
dev_dbg(host->dev, "ciu-drive not available\n");
priv->sample_clk = devm_clk_get(host->dev, "ciu-sample");
if (IS_ERR(priv->sample_clk))
dev_dbg(host->dev, "ciu-sample not available\n");
host->priv = priv;
return 0;
}
static int dw_mci_rockchip_init(struct dw_mci *host)
{
/* It is slot 8 on Rockchip SoCs */
host->sdio_id0 = 8;
if (of_device_is_compatible(host->dev->of_node,
"rockchip,rk3288-dw-mshc"))
host->bus_hz /= RK3288_CLKGEN_DIV;
return 0;
}
/* Common capabilities of RK3288 SoC */
static unsigned long dw_mci_rk3288_dwmmc_caps[4] = {
MMC_CAP_CMD23,
MMC_CAP_CMD23,
MMC_CAP_CMD23,
MMC_CAP_CMD23,
};
static const struct dw_mci_drv_data rk2928_drv_data = {
.init = dw_mci_rockchip_init,
};
static const struct dw_mci_drv_data rk3288_drv_data = {
.caps = dw_mci_rk3288_dwmmc_caps,
.num_caps = ARRAY_SIZE(dw_mci_rk3288_dwmmc_caps),
.set_ios = dw_mci_rk3288_set_ios,
.execute_tuning = dw_mci_rk3288_execute_tuning,
.parse_dt = dw_mci_rk3288_parse_dt,
.init = dw_mci_rockchip_init,
};
static const struct of_device_id dw_mci_rockchip_match[] = {
{ .compatible = "rockchip,rk2928-dw-mshc",
.data = &rk2928_drv_data },
{ .compatible = "rockchip,rk3288-dw-mshc",
.data = &rk3288_drv_data },
{},
};
MODULE_DEVICE_TABLE(of, dw_mci_rockchip_match);
static int dw_mci_rockchip_probe(struct platform_device *pdev)
{
const struct dw_mci_drv_data *drv_data;
const struct of_device_id *match;
int ret;
if (!pdev->dev.of_node)
return -ENODEV;
match = of_match_node(dw_mci_rockchip_match, pdev->dev.of_node);
drv_data = match->data;
pm_runtime_get_noresume(&pdev->dev);
pm_runtime_set_active(&pdev->dev);
pm_runtime_enable(&pdev->dev);
pm_runtime_set_autosuspend_delay(&pdev->dev, 50);
pm_runtime_use_autosuspend(&pdev->dev);
ret = dw_mci_pltfm_register(pdev, drv_data);
if (ret) {
pm_runtime_disable(&pdev->dev);
pm_runtime_set_suspended(&pdev->dev);
pm_runtime_put_noidle(&pdev->dev);
return ret;
}
pm_runtime_put_autosuspend(&pdev->dev);
return 0;
}
static int dw_mci_rockchip_remove(struct platform_device *pdev)
{
pm_runtime_get_sync(&pdev->dev);
pm_runtime_disable(&pdev->dev);
pm_runtime_put_noidle(&pdev->dev);
return dw_mci_pltfm_remove(pdev);
}
static const struct dev_pm_ops dw_mci_rockchip_dev_pm_ops = {
SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
pm_runtime_force_resume)
SET_RUNTIME_PM_OPS(dw_mci_runtime_suspend,
dw_mci_runtime_resume,
NULL)
};
static struct platform_driver dw_mci_rockchip_pltfm_driver = {
.probe = dw_mci_rockchip_probe,
.remove = dw_mci_rockchip_remove,
.driver = {
.name = "dwmmc_rockchip",
.of_match_table = dw_mci_rockchip_match,
.pm = &dw_mci_rockchip_dev_pm_ops,
},
};
module_platform_driver(dw_mci_rockchip_pltfm_driver);
MODULE_AUTHOR("Addy Ke <addy.ke@rock-chips.com>");
MODULE_DESCRIPTION("Rockchip Specific DW-MSHC Driver Extension");
MODULE_ALIAS("platform:dwmmc_rockchip");
MODULE_LICENSE("GPL v2");
+242
View File
@@ -0,0 +1,242 @@
/*
* ZX Specific Extensions for Synopsys DW Multimedia Card Interface driver
*
* Copyright (C) 2016, Linaro Ltd.
* Copyright (C) 2016, ZTE Corp.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#include <linux/clk.h>
#include <linux/mfd/syscon.h>
#include <linux/mmc/host.h>
#include <linux/mmc/mmc.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
#include <linux/slab.h>
#include "dw_mmc.h"
#include "dw_mmc-pltfm.h"
#include "dw_mmc-zx.h"
struct dw_mci_zx_priv_data {
struct regmap *sysc_base;
};
enum delay_type {
DELAY_TYPE_READ, /* read dqs delay */
DELAY_TYPE_CLK, /* clk sample delay */
};
static int dw_mci_zx_emmc_set_delay(struct dw_mci *host, unsigned int delay,
enum delay_type dflag)
{
struct dw_mci_zx_priv_data *priv = host->priv;
struct regmap *sysc_base = priv->sysc_base;
unsigned int clksel;
unsigned int loop = 1000;
int ret;
if (!sysc_base)
return -EINVAL;
ret = regmap_update_bits(sysc_base, LB_AON_EMMC_CFG_REG0,
PARA_HALF_CLK_MODE | PARA_DLL_BYPASS_MODE |
PARA_PHASE_DET_SEL_MASK |
PARA_DLL_LOCK_NUM_MASK |
DLL_REG_SET | PARA_DLL_START_MASK,
PARA_DLL_START(4) | PARA_DLL_LOCK_NUM(4));
if (ret)
return ret;
ret = regmap_read(sysc_base, LB_AON_EMMC_CFG_REG1, &clksel);
if (ret)
return ret;
if (dflag == DELAY_TYPE_CLK) {
clksel &= ~CLK_SAMP_DELAY_MASK;
clksel |= CLK_SAMP_DELAY(delay);
} else {
clksel &= ~READ_DQS_DELAY_MASK;
clksel |= READ_DQS_DELAY(delay);
}
regmap_write(sysc_base, LB_AON_EMMC_CFG_REG1, clksel);
regmap_update_bits(sysc_base, LB_AON_EMMC_CFG_REG0,
PARA_DLL_START_MASK | PARA_DLL_LOCK_NUM_MASK |
DLL_REG_SET,
PARA_DLL_START(4) | PARA_DLL_LOCK_NUM(4) |
DLL_REG_SET);
do {
ret = regmap_read(sysc_base, LB_AON_EMMC_CFG_REG2, &clksel);
if (ret)
return ret;
} while (--loop && !(clksel & ZX_DLL_LOCKED));
if (!loop) {
dev_err(host->dev, "Error: %s dll lock fail\n", __func__);
return -EIO;
}
return 0;
}
static int dw_mci_zx_emmc_execute_tuning(struct dw_mci_slot *slot, u32 opcode)
{
struct dw_mci *host = slot->host;
struct mmc_host *mmc = slot->mmc;
int ret, len = 0, start = 0, end = 0, delay, best = 0;
for (delay = 1; delay < 128; delay++) {
ret = dw_mci_zx_emmc_set_delay(host, delay, DELAY_TYPE_CLK);
if (!ret && mmc_send_tuning(mmc, opcode, NULL)) {
if (start >= 0) {
end = delay - 1;
/* check and update longest good range */
if ((end - start) > len) {
best = (start + end) >> 1;
len = end - start;
}
}
start = -1;
end = 0;
continue;
}
if (start < 0)
start = delay;
}
if (start >= 0) {
end = delay - 1;
if ((end - start) > len) {
best = (start + end) >> 1;
len = end - start;
}
}
if (best < 0)
return -EIO;
dev_info(host->dev, "%s best range: start %d end %d\n", __func__,
start, end);
return dw_mci_zx_emmc_set_delay(host, best, DELAY_TYPE_CLK);
}
static int dw_mci_zx_prepare_hs400_tuning(struct dw_mci *host,
struct mmc_ios *ios)
{
int ret;
/* config phase shift as 90 degree */
ret = dw_mci_zx_emmc_set_delay(host, 32, DELAY_TYPE_READ);
if (ret < 0)
return -EIO;
return 0;
}
static int dw_mci_zx_execute_tuning(struct dw_mci_slot *slot, u32 opcode)
{
struct dw_mci *host = slot->host;
if (host->verid == 0x290a) /* only for emmc */
return dw_mci_zx_emmc_execute_tuning(slot, opcode);
/* TODO: Add 0x210a dedicated tuning for sd/sdio */
return 0;
}
static int dw_mci_zx_parse_dt(struct dw_mci *host)
{
struct device_node *np = host->dev->of_node;
struct device_node *node;
struct dw_mci_zx_priv_data *priv;
struct regmap *sysc_base;
int ret;
/* syscon is needed only by emmc */
node = of_parse_phandle(np, "zte,aon-syscon", 0);
if (node) {
sysc_base = syscon_node_to_regmap(node);
of_node_put(node);
if (IS_ERR(sysc_base)) {
ret = PTR_ERR(sysc_base);
if (ret != -EPROBE_DEFER)
dev_err(host->dev, "Can't get syscon: %d\n",
ret);
return ret;
}
} else {
return 0;
}
priv = devm_kzalloc(host->dev, sizeof(*priv), GFP_KERNEL);
if (!priv)
return -ENOMEM;
priv->sysc_base = sysc_base;
host->priv = priv;
return 0;
}
static unsigned long zx_dwmmc_caps[3] = {
MMC_CAP_CMD23,
MMC_CAP_CMD23,
MMC_CAP_CMD23,
};
static const struct dw_mci_drv_data zx_drv_data = {
.caps = zx_dwmmc_caps,
.num_caps = ARRAY_SIZE(zx_dwmmc_caps),
.execute_tuning = dw_mci_zx_execute_tuning,
.prepare_hs400_tuning = dw_mci_zx_prepare_hs400_tuning,
.parse_dt = dw_mci_zx_parse_dt,
};
static const struct of_device_id dw_mci_zx_match[] = {
{ .compatible = "zte,zx296718-dw-mshc", .data = &zx_drv_data},
{},
};
MODULE_DEVICE_TABLE(of, dw_mci_zx_match);
static int dw_mci_zx_probe(struct platform_device *pdev)
{
const struct dw_mci_drv_data *drv_data;
const struct of_device_id *match;
match = of_match_node(dw_mci_zx_match, pdev->dev.of_node);
drv_data = match->data;
return dw_mci_pltfm_register(pdev, drv_data);
}
static const struct dev_pm_ops dw_mci_zx_dev_pm_ops = {
SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
pm_runtime_force_resume)
SET_RUNTIME_PM_OPS(dw_mci_runtime_suspend,
dw_mci_runtime_resume,
NULL)
};
static struct platform_driver dw_mci_zx_pltfm_driver = {
.probe = dw_mci_zx_probe,
.remove = dw_mci_pltfm_remove,
.driver = {
.name = "dwmmc_zx",
.of_match_table = dw_mci_zx_match,
.pm = &dw_mci_zx_dev_pm_ops,
},
};
module_platform_driver(dw_mci_zx_pltfm_driver);
MODULE_DESCRIPTION("ZTE emmc/sd driver");
MODULE_LICENSE("GPL v2");
+32
View File
@@ -0,0 +1,32 @@
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _DW_MMC_ZX_H_
#define _DW_MMC_ZX_H_
/* ZX296718 SoC specific DLL register offset. */
#define LB_AON_EMMC_CFG_REG0 0x1B0
#define LB_AON_EMMC_CFG_REG1 0x1B4
#define LB_AON_EMMC_CFG_REG2 0x1B8
/* LB_AON_EMMC_CFG_REG0 register defines */
#define PARA_DLL_START(x) ((x) & 0xFF)
#define PARA_DLL_START_MASK 0xFF
#define DLL_REG_SET BIT(8)
#define PARA_DLL_LOCK_NUM(x) (((x) & 7) << 16)
#define PARA_DLL_LOCK_NUM_MASK (7 << 16)
#define PARA_PHASE_DET_SEL(x) (((x) & 7) << 20)
#define PARA_PHASE_DET_SEL_MASK (7 << 20)
#define PARA_DLL_BYPASS_MODE BIT(23)
#define PARA_HALF_CLK_MODE BIT(24)
/* LB_AON_EMMC_CFG_REG1 register defines */
#define READ_DQS_DELAY(x) ((x) & 0x7F)
#define READ_DQS_DELAY_MASK (0x7F)
#define READ_DQS_BYPASS_MODE BIT(7)
#define CLK_SAMP_DELAY(x) (((x) & 0x7F) << 8)
#define CLK_SAMP_DELAY_MASK (0x7F << 8)
#define CLK_SAMP_BYPASS_MODE BIT(15)
/* LB_AON_EMMC_CFG_REG2 register defines */
#define ZX_DLL_LOCKED BIT(2)
#endif /* _DW_MMC_ZX_H_ */
File diff suppressed because it is too large. Load diff
+571
View File
@@ -0,0 +1,571 @@
/*
* Synopsys DesignWare Multimedia Card Interface driver
* (Based on NXP driver for lpc 31xx)
*
* Copyright (C) 2009 NXP Semiconductors
* Copyright (C) 2009, 2010 Imagination Technologies Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#ifndef _DW_MMC_H_
#define _DW_MMC_H_
#include <linux/scatterlist.h>
#include <linux/mmc/core.h>
#include <linux/dmaengine.h>
#include <linux/reset.h>
#include <linux/interrupt.h>
enum dw_mci_state {
STATE_IDLE = 0,
STATE_SENDING_CMD,
STATE_SENDING_DATA,
STATE_DATA_BUSY,
STATE_SENDING_STOP,
STATE_DATA_ERROR,
STATE_SENDING_CMD11,
STATE_WAITING_CMD11_DONE,
};
enum {
EVENT_CMD_COMPLETE = 0,
EVENT_XFER_COMPLETE,
EVENT_DATA_COMPLETE,
EVENT_DATA_ERROR,
};
enum dw_mci_cookie {
COOKIE_UNMAPPED,
COOKIE_PRE_MAPPED, /* mapped by pre_req() of dwmmc */
COOKIE_MAPPED, /* mapped by prepare_data() of dwmmc */
};
struct mmc_data;
enum {
TRANS_MODE_PIO = 0,
TRANS_MODE_IDMAC,
TRANS_MODE_EDMAC
};
struct dw_mci_dma_slave {
struct dma_chan *ch;
enum dma_transfer_direction direction;
};
/**
* struct dw_mci - MMC controller state shared between all slots
* @lock: Spinlock protecting the queue and associated data.
* @irq_lock: Spinlock protecting the INTMASK setting.
* @regs: Pointer to MMIO registers.
* @fifo_reg: Pointer to MMIO registers for data FIFO
* @sg: Scatterlist entry currently being processed by PIO code, if any.
* @sg_miter: PIO mapping scatterlist iterator.
* @mrq: The request currently being processed on @slot,
* or NULL if the controller is idle.
* @cmd: The command currently being sent to the card, or NULL.
* @data: The data currently being transferred, or NULL if no data
* transfer is in progress.
* @stop_abort: The command currently prepared for stoping transfer.
* @prev_blksz: The former transfer blksz record.
* @timing: Record of current ios timing.
* @use_dma: Which DMA channel is in use for the current transfer, zero
* denotes PIO mode.
* @using_dma: Whether DMA is in use for the current transfer.
* @dma_64bit_address: Whether DMA supports 64-bit address mode or not.
* @sg_dma: Bus address of DMA buffer.
* @sg_cpu: Virtual address of DMA buffer.
* @dma_ops: Pointer to platform-specific DMA callbacks.
* @cmd_status: Snapshot of SR taken upon completion of the current
* @ring_size: Buffer size for idma descriptors.
* command. Only valid when EVENT_CMD_COMPLETE is pending.
* @dms: structure of slave-dma private data.
* @phy_regs: physical address of controller's register map
* @data_status: Snapshot of SR taken upon completion of the current
* data transfer. Only valid when EVENT_DATA_COMPLETE or
* EVENT_DATA_ERROR is pending.
* @stop_cmdr: Value to be loaded into CMDR when the stop command is
* to be sent.
* @dir_status: Direction of current transfer.
* @tasklet: Tasklet running the request state machine.
* @pending_events: Bitmask of events flagged by the interrupt handler
* to be processed by the tasklet.
* @completed_events: Bitmask of events which the state machine has
* processed.
* @state: Tasklet state.
* @queue: List of slots waiting for access to the controller.
* @bus_hz: The rate of @mck in Hz. This forms the basis for MMC bus
* rate and timeout calculations.
* @current_speed: Configured rate of the controller.
* @fifoth_val: The value of FIFOTH register.
* @verid: Denote Version ID.
* @dev: Device associated with the MMC controller.
* @pdata: Platform data associated with the MMC controller.
* @drv_data: Driver specific data for identified variant of the controller
* @priv: Implementation defined private data.
* @biu_clk: Pointer to bus interface unit clock instance.
* @ciu_clk: Pointer to card interface unit clock instance.
* @slot: Slots sharing this MMC controller.
* @fifo_depth: depth of FIFO.
* @data_addr_override: override fifo reg offset with this value.
* @wm_aligned: force fifo watermark equal with data length in PIO mode.
* Set as true if alignment is needed.
* @data_shift: log2 of FIFO item size.
* @part_buf_start: Start index in part_buf.
* @part_buf_count: Bytes of partial data in part_buf.
* @part_buf: Simple buffer for partial fifo reads/writes.
* @push_data: Pointer to FIFO push function.
* @pull_data: Pointer to FIFO pull function.
* @vqmmc_enabled: Status of vqmmc, should be true or false.
* @irq_flags: The flags to be passed to request_irq.
* @irq: The irq value to be passed to request_irq.
* @sdio_id0: Number of slot0 in the SDIO interrupt registers.
* @cmd11_timer: Timer for SD3.0 voltage switch over scheme.
* @cto_timer: Timer for broken command transfer over scheme.
* @dto_timer: Timer for broken data transfer over scheme.
*
* Locking
* =======
*
* @lock is a softirq-safe spinlock protecting @queue as well as
* @slot, @mrq and @state. These must always be updated
* at the same time while holding @lock.
* The @mrq field of struct dw_mci_slot is also protected by @lock,
* and must always be written at the same time as the slot is added to
* @queue.
*
* @irq_lock is an irq-safe spinlock protecting the INTMASK register
* to allow the interrupt handler to modify it directly. Held for only long
* enough to read-modify-write INTMASK and no other locks are grabbed when
* holding this one.
*
* @pending_events and @completed_events are accessed using atomic bit
* operations, so they don't need any locking.
*
* None of the fields touched by the interrupt handler need any
* locking. However, ordering is important: Before EVENT_DATA_ERROR or
* EVENT_DATA_COMPLETE is set in @pending_events, all data-related
* interrupts must be disabled and @data_status updated with a
* snapshot of SR. Similarly, before EVENT_CMD_COMPLETE is set, the
* CMDRDY interrupt must be disabled and @cmd_status updated with a
* snapshot of SR, and before EVENT_XFER_COMPLETE can be set, the
* bytes_xfered field of @data must be written. This is ensured by
* using barriers.
*/
struct dw_mci {
spinlock_t lock;
spinlock_t irq_lock;
void __iomem *regs;
void __iomem *fifo_reg;
u32 data_addr_override;
bool wm_aligned;
struct scatterlist *sg;
struct sg_mapping_iter sg_miter;
struct mmc_request *mrq;
struct mmc_command *cmd;
struct mmc_data *data;
struct mmc_command stop_abort;
unsigned int prev_blksz;
unsigned char timing;
/* DMA interface members*/
int use_dma;
int using_dma;
int dma_64bit_address;
dma_addr_t sg_dma;
void *sg_cpu;
const struct dw_mci_dma_ops *dma_ops;
/* For idmac */
unsigned int ring_size;
/* For edmac */
struct dw_mci_dma_slave *dms;
/* Registers's physical base address */
resource_size_t phy_regs;
u32 cmd_status;
u32 data_status;
u32 stop_cmdr;
u32 dir_status;
struct tasklet_struct tasklet;
unsigned long pending_events;
unsigned long completed_events;
enum dw_mci_state state;
struct list_head queue;
u32 bus_hz;
u32 current_speed;
u32 fifoth_val;
u16 verid;
struct device *dev;
struct dw_mci_board *pdata;
const struct dw_mci_drv_data *drv_data;
void *priv;
struct clk *biu_clk;
struct clk *ciu_clk;
struct dw_mci_slot *slot;
/* FIFO push and pull */
int fifo_depth;
int data_shift;
u8 part_buf_start;
u8 part_buf_count;
union {
u16 part_buf16;
u32 part_buf32;
u64 part_buf;
};
void (*push_data)(struct dw_mci *host, void *buf, int cnt);
void (*pull_data)(struct dw_mci *host, void *buf, int cnt);
bool vqmmc_enabled;
unsigned long irq_flags; /* IRQ flags */
int irq;
int sdio_id0;
struct timer_list cmd11_timer;
struct timer_list cto_timer;
struct timer_list dto_timer;
};
/* DMA ops for Internal/External DMAC interface */
struct dw_mci_dma_ops {
/* DMA Ops */
int (*init)(struct dw_mci *host);
int (*start)(struct dw_mci *host, unsigned int sg_len);
void (*complete)(void *host);
void (*stop)(struct dw_mci *host);
void (*cleanup)(struct dw_mci *host);
void (*exit)(struct dw_mci *host);
};
struct dma_pdata;
/* Board platform data */
struct dw_mci_board {
unsigned int bus_hz; /* Clock speed at the cclk_in pad */
u32 caps; /* Capabilities */
u32 caps2; /* More capabilities */
u32 pm_caps; /* PM capabilities */
/*
* Override fifo depth. If 0, autodetect it from the FIFOTH register,
* but note that this may not be reliable after a bootloader has used
* it.
*/
unsigned int fifo_depth;
/* delay in mS before detecting cards after interrupt */
u32 detect_delay_ms;
struct reset_control *rstc;
struct dw_mci_dma_ops *dma_ops;
struct dma_pdata *data;
};
#define DW_MMC_240A 0x240a
#define DW_MMC_280A 0x280a
#define SDMMC_CTRL 0x000
#define SDMMC_PWREN 0x004
#define SDMMC_CLKDIV 0x008
#define SDMMC_CLKSRC 0x00c
#define SDMMC_CLKENA 0x010
#define SDMMC_TMOUT 0x014
#define SDMMC_CTYPE 0x018
#define SDMMC_BLKSIZ 0x01c
#define SDMMC_BYTCNT 0x020
#define SDMMC_INTMASK 0x024
#define SDMMC_CMDARG 0x028
#define SDMMC_CMD 0x02c
#define SDMMC_RESP0 0x030
#define SDMMC_RESP1 0x034
#define SDMMC_RESP2 0x038
#define SDMMC_RESP3 0x03c
#define SDMMC_MINTSTS 0x040
#define SDMMC_RINTSTS 0x044
#define SDMMC_STATUS 0x048
#define SDMMC_FIFOTH 0x04c
#define SDMMC_CDETECT 0x050
#define SDMMC_WRTPRT 0x054
#define SDMMC_GPIO 0x058
#define SDMMC_TCBCNT 0x05c
#define SDMMC_TBBCNT 0x060
#define SDMMC_DEBNCE 0x064
#define SDMMC_USRID 0x068
#define SDMMC_VERID 0x06c
#define SDMMC_HCON 0x070
#define SDMMC_UHS_REG 0x074
#define SDMMC_RST_N 0x078
#define SDMMC_BMOD 0x080
#define SDMMC_PLDMND 0x084
#define SDMMC_DBADDR 0x088
#define SDMMC_IDSTS 0x08c
#define SDMMC_IDINTEN 0x090
#define SDMMC_DSCADDR 0x094
#define SDMMC_BUFADDR 0x098
#define SDMMC_CDTHRCTL 0x100
#define SDMMC_UHS_REG_EXT 0x108
#define SDMMC_DDR_REG 0x10c
#define SDMMC_ENABLE_SHIFT 0x110
#define SDMMC_DATA(x) (x)
/*
* Registers to support idmac 64-bit address mode
*/
#define SDMMC_DBADDRL 0x088
#define SDMMC_DBADDRU 0x08c
#define SDMMC_IDSTS64 0x090
#define SDMMC_IDINTEN64 0x094
#define SDMMC_DSCADDRL 0x098
#define SDMMC_DSCADDRU 0x09c
#define SDMMC_BUFADDRL 0x0A0
#define SDMMC_BUFADDRU 0x0A4
/*
* Data offset is difference according to Version
* Lower than 2.40a : data register offest is 0x100
*/
#define DATA_OFFSET 0x100
#define DATA_240A_OFFSET 0x200
/* shift bit field */
#define _SBF(f, v) ((v) << (f))
/* Control register defines */
#define SDMMC_CTRL_USE_IDMAC BIT(25)
#define SDMMC_CTRL_CEATA_INT_EN BIT(11)
#define SDMMC_CTRL_SEND_AS_CCSD BIT(10)
#define SDMMC_CTRL_SEND_CCSD BIT(9)
#define SDMMC_CTRL_ABRT_READ_DATA BIT(8)
#define SDMMC_CTRL_SEND_IRQ_RESP BIT(7)
#define SDMMC_CTRL_READ_WAIT BIT(6)
#define SDMMC_CTRL_DMA_ENABLE BIT(5)
#define SDMMC_CTRL_INT_ENABLE BIT(4)
#define SDMMC_CTRL_DMA_RESET BIT(2)
#define SDMMC_CTRL_FIFO_RESET BIT(1)
#define SDMMC_CTRL_RESET BIT(0)
/* Clock Enable register defines */
#define SDMMC_CLKEN_LOW_PWR BIT(16)
#define SDMMC_CLKEN_ENABLE BIT(0)
/* time-out register defines */
#define SDMMC_TMOUT_DATA(n) _SBF(8, (n))
#define SDMMC_TMOUT_DATA_MSK 0xFFFFFF00
#define SDMMC_TMOUT_RESP(n) ((n) & 0xFF)
#define SDMMC_TMOUT_RESP_MSK 0xFF
/* card-type register defines */
#define SDMMC_CTYPE_8BIT BIT(16)
#define SDMMC_CTYPE_4BIT BIT(0)
#define SDMMC_CTYPE_1BIT 0
/* Interrupt status & mask register defines */
#define SDMMC_INT_SDIO(n) BIT(16 + (n))
#define SDMMC_INT_EBE BIT(15)
#define SDMMC_INT_ACD BIT(14)
#define SDMMC_INT_SBE BIT(13)
#define SDMMC_INT_HLE BIT(12)
#define SDMMC_INT_FRUN BIT(11)
#define SDMMC_INT_HTO BIT(10)
#define SDMMC_INT_VOLT_SWITCH BIT(10) /* overloads bit 10! */
#define SDMMC_INT_DRTO BIT(9)
#define SDMMC_INT_RTO BIT(8)
#define SDMMC_INT_DCRC BIT(7)
#define SDMMC_INT_RCRC BIT(6)
#define SDMMC_INT_RXDR BIT(5)
#define SDMMC_INT_TXDR BIT(4)
#define SDMMC_INT_DATA_OVER BIT(3)
#define SDMMC_INT_CMD_DONE BIT(2)
#define SDMMC_INT_RESP_ERR BIT(1)
#define SDMMC_INT_CD BIT(0)
#define SDMMC_INT_ERROR 0xbfc2
/* Command register defines */
#define SDMMC_CMD_START BIT(31)
#define SDMMC_CMD_USE_HOLD_REG BIT(29)
#define SDMMC_CMD_VOLT_SWITCH BIT(28)
#define SDMMC_CMD_CCS_EXP BIT(23)
#define SDMMC_CMD_CEATA_RD BIT(22)
#define SDMMC_CMD_UPD_CLK BIT(21)
#define SDMMC_CMD_INIT BIT(15)
#define SDMMC_CMD_STOP BIT(14)
#define SDMMC_CMD_PRV_DAT_WAIT BIT(13)
#define SDMMC_CMD_SEND_STOP BIT(12)
#define SDMMC_CMD_STRM_MODE BIT(11)
#define SDMMC_CMD_DAT_WR BIT(10)
#define SDMMC_CMD_DAT_EXP BIT(9)
#define SDMMC_CMD_RESP_CRC BIT(8)
#define SDMMC_CMD_RESP_LONG BIT(7)
#define SDMMC_CMD_RESP_EXP BIT(6)
#define SDMMC_CMD_INDX(n) ((n) & 0x1F)
/* Status register defines */
#define SDMMC_GET_FCNT(x) (((x)>>17) & 0x1FFF)
#define SDMMC_STATUS_DMA_REQ BIT(31)
#define SDMMC_STATUS_BUSY BIT(9)
/* FIFOTH register defines */
#define SDMMC_SET_FIFOTH(m, r, t) (((m) & 0x7) << 28 | \
((r) & 0xFFF) << 16 | \
((t) & 0xFFF))
/* HCON register defines */
#define DMA_INTERFACE_IDMA (0x0)
#define DMA_INTERFACE_DWDMA (0x1)
#define DMA_INTERFACE_GDMA (0x2)
#define DMA_INTERFACE_NODMA (0x3)
#define SDMMC_GET_TRANS_MODE(x) (((x)>>16) & 0x3)
#define SDMMC_GET_SLOT_NUM(x) ((((x)>>1) & 0x1F) + 1)
#define SDMMC_GET_HDATA_WIDTH(x) (((x)>>7) & 0x7)
#define SDMMC_GET_ADDR_CONFIG(x) (((x)>>27) & 0x1)
/* Internal DMAC interrupt defines */
#define SDMMC_IDMAC_INT_AI BIT(9)
#define SDMMC_IDMAC_INT_NI BIT(8)
#define SDMMC_IDMAC_INT_CES BIT(5)
#define SDMMC_IDMAC_INT_DU BIT(4)
#define SDMMC_IDMAC_INT_FBE BIT(2)
#define SDMMC_IDMAC_INT_RI BIT(1)
#define SDMMC_IDMAC_INT_TI BIT(0)
/* Internal DMAC bus mode bits */
#define SDMMC_IDMAC_ENABLE BIT(7)
#define SDMMC_IDMAC_FB BIT(1)
#define SDMMC_IDMAC_SWRESET BIT(0)
/* H/W reset */
#define SDMMC_RST_HWACTIVE 0x1
/* Version ID register define */
#define SDMMC_GET_VERID(x) ((x) & 0xFFFF)
/* Card read threshold */
#define SDMMC_SET_THLD(v, x) (((v) & 0xFFF) << 16 | (x))
#define SDMMC_CARD_WR_THR_EN BIT(2)
#define SDMMC_CARD_RD_THR_EN BIT(0)
/* UHS-1 register defines */
#define SDMMC_UHS_DDR BIT(16)
#define SDMMC_UHS_18V BIT(0)
/* DDR register defines */
#define SDMMC_DDR_HS400 BIT(31)
/* Enable shift register defines */
#define SDMMC_ENABLE_PHASE BIT(0)
/* All ctrl reset bits */
#define SDMMC_CTRL_ALL_RESET_FLAGS \
(SDMMC_CTRL_RESET | SDMMC_CTRL_FIFO_RESET | SDMMC_CTRL_DMA_RESET)
/* FIFO register access macros. These should not change the data endian-ness
* as they are written to memory to be dealt with by the upper layers
*/
#define mci_fifo_readw(__reg) __raw_readw(__reg)
#define mci_fifo_readl(__reg) __raw_readl(__reg)
#define mci_fifo_readq(__reg) __raw_readq(__reg)
#define mci_fifo_writew(__value, __reg) __raw_writew(__reg, __value)
#define mci_fifo_writel(__value, __reg) __raw_writel(__reg, __value)
#define mci_fifo_writeq(__value, __reg) __raw_writeq(__reg, __value)
/* Register access macros */
#define mci_readl(dev, reg) \
readl_relaxed((dev)->regs + SDMMC_##reg)
#define mci_writel(dev, reg, value) \
writel_relaxed((value), (dev)->regs + SDMMC_##reg)
/* 16-bit FIFO access macros */
#define mci_readw(dev, reg) \
readw_relaxed((dev)->regs + SDMMC_##reg)
#define mci_writew(dev, reg, value) \
writew_relaxed((value), (dev)->regs + SDMMC_##reg)
/* 64-bit FIFO access macros */
#ifdef readq
#define mci_readq(dev, reg) \
readq_relaxed((dev)->regs + SDMMC_##reg)
#define mci_writeq(dev, reg, value) \
writeq_relaxed((value), (dev)->regs + SDMMC_##reg)
#else
/*
* Dummy readq implementation for architectures that don't define it.
*
* We would assume that none of these architectures would configure
* the IP block with a 64bit FIFO width, so this code will never be
* executed on those machines. Defining these macros here keeps the
* rest of the code free from ifdefs.
*/
#define mci_readq(dev, reg) \
(*(volatile u64 __force *)((dev)->regs + SDMMC_##reg))
#define mci_writeq(dev, reg, value) \
(*(volatile u64 __force *)((dev)->regs + SDMMC_##reg) = (value))
#define __raw_writeq(__value, __reg) \
(*(volatile u64 __force *)(__reg) = (__value))
#define __raw_readq(__reg) (*(volatile u64 __force *)(__reg))
#endif
extern int dw_mci_probe(struct dw_mci *host);
extern void dw_mci_remove(struct dw_mci *host);
#ifdef CONFIG_PM
extern int dw_mci_runtime_suspend(struct device *device);
extern int dw_mci_runtime_resume(struct device *device);
#endif
/**
* struct dw_mci_slot - MMC slot state
* @mmc: The mmc_host representing this slot.
* @host: The MMC controller this slot is using.
* @ctype: Card type for this slot.
* @mrq: mmc_request currently being processed or waiting to be
* processed, or NULL when the slot is idle.
* @queue_node: List node for placing this node in the @queue list of
* &struct dw_mci.
* @clock: Clock rate configured by set_ios(). Protected by host->lock.
* @__clk_old: The last clock value that was requested from core.
* Keeping track of this helps us to avoid spamming the console.
* @flags: Random state bits associated with the slot.
* @id: Number of this slot.
* @sdio_id: Number of this slot in the SDIO interrupt registers.
*/
struct dw_mci_slot {
struct mmc_host *mmc;
struct dw_mci *host;
u32 ctype;
struct mmc_request *mrq;
struct list_head queue_node;
unsigned int clock;
unsigned int __clk_old;
unsigned long flags;
#define DW_MMC_CARD_PRESENT 0
#define DW_MMC_CARD_NEED_INIT 1
#define DW_MMC_CARD_NO_LOW_PWR 2
#define DW_MMC_CARD_NO_USE_HOLD 3
#define DW_MMC_CARD_NEEDS_POLL 4
int id;
int sdio_id;
};
/**
* dw_mci driver data - dw-mshc implementation specific driver data.
* @caps: mmc subsystem specified capabilities of the controller(s).
* @num_caps: number of capabilities specified by @caps.
* @init: early implementation specific initialization.
* @set_ios: handle bus specific extensions.
* @parse_dt: parse implementation specific device tree properties.
* @execute_tuning: implementation specific tuning procedure.
*
* Provide controller implementation specific extensions. The usage of this
* data structure is fully optional and usage of each member in this structure
* is optional as well.
*/
struct dw_mci_drv_data {
unsigned long *caps;
u32 num_caps;
int (*init)(struct dw_mci *host);
void (*set_ios)(struct dw_mci *host, struct mmc_ios *ios);
int (*parse_dt)(struct dw_mci *host);
int (*execute_tuning)(struct dw_mci_slot *slot, u32 opcode);
int (*prepare_hs400_tuning)(struct dw_mci *host,
struct mmc_ios *ios);
int (*switch_voltage)(struct mmc_host *mmc,
struct mmc_ios *ios);
};
#endif /* _DW_MMC_H_ */
File diff suppressed because it is too large. Load diff
+70
View File
@@ -0,0 +1,70 @@
#
# Copyright (C) 2019 MediaTek Inc.
#
# 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.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
#add kernel source code path as head file search path
MTK_PLATFORM := $(subst ",,$(CONFIG_MTK_PLATFORM))
ifeq (y, $(filter y, $(CONFIG_MACH_MT6893)))
MMC_FOLDER := mt6885
else
MMC_FOLDER := $(MTK_PLATFORM)
endif
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat/$(MTK_PLATFORM)/include
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat
ccflags-y += -I$(srctree)/drivers/misc/mediatek/base/power/$(MTK_PLATFORM)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/base/power/include
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/
#workaround for include mmc/card/queue.h and mmc/core/core.h
ccflags-y += -I$(srctree)/drivers
ccflags-y += -I$(srctree)/drivers/mmc/host/mediatek/ComboA/$(MMC_FOLDER)
ifeq ($(CONFIG_MTK_PLATFORM), "mt6761")
ccflags-y += -I$(srctree)/drivers/mmc/host/mediatek/ComboA/mt6765
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6357
ccflags-y += -I$(srctree)/drivers/devfreq
msdc-y += mt6765/msdc_cust.o
msdc-y += mt6765/autok_dvfs.o
else
ccflags-y += -I$(srctree)/drivers/mmc/host/mediatek/ComboA/$(MMC_FOLDER)
msdc-y += $(MMC_FOLDER)/msdc_cust.o
msdc-y += $(MTK_PLATFORM)/autok_dvfs.o
endif
ifeq ($(CONFIG_MTK_PLATFORM), "mt6765")
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6357
ccflags-y += -I$(srctree)/drivers/devfreq
endif
ifeq ($(CONFIG_MTK_HW_FDE_AES),y)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/fde_aes/$(subst ",,$(CONFIG_MTK_PLATFORM))
endif
ccflags-y += -Wno-error=unused-function
obj-$(CONFIG_MMC_MTK_PRO) += msdc.o
msdc-y += sd.o
msdc-y += dbg.o
msdc-y += msdc_tune.o
msdc-y += autok.o
ifeq ($(CONFIG_MMC_CRYPTO),y)
msdc-y += sw-cqhci-crypto.o
endif
ifeq ($(CONFIG_FPGA_EARLY_PORTING),y)
msdc-y += $(MTK_PLATFORM)/msdc_fpga_io.o
endif
File diff suppressed because it is too large. Load diff
+392
View File
@@ -0,0 +1,392 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _AUTOK_H_
#define _AUTOK_H_
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/completion.h>
#include <linux/scatterlist.h>
#include <linux/mmc/card.h>
#include <linux/mmc/core.h>
#include <linux/mmc/host.h>
#include <linux/mmc/mmc.h>
#include <linux/mmc/sd.h>
#include <linux/mmc/sdio.h>
struct msdc_host;
#define E_RES_PASS (0)
#define E_RES_CMD_TMO (1<<0)
#define E_RES_RSP_CRC (1<<1)
#define E_RES_DAT_CRC (1<<2)
#define E_RES_DAT_TMO (1<<3)
#define E_RES_W_CRC (1<<4)
#define E_RES_ERR (1<<5)
#define E_RES_START (1<<6)
#define E_RES_PW_SMALL (1<<7)
#define E_RES_KEEP_OLD (1<<8)
#define E_RES_CMP_ERR (1<<9)
#define E_RES_FATAL_ERR (1<<10)
#define E_RESULT_MAX
#define MERGE_CMD (1<<0)
#define MERGE_DAT (1<<1)
#define MERGE_DS_DAT (1<<2)
#define MERGE_DS_CMD (1<<3)
#define MERGE_DEVICE_D_RX (1<<4)
#define MERGE_DEVICE_C_RX (1<<5)
#define MERGE_HOST_D_TX (1<<6)
#define MERGE_HOST_C_TX (1<<7)
#define MERGE_HOST_CLK_TX (1<<8)
#define MERGE_HS200_SDR104 (MERGE_CMD | MERGE_DAT)
#define MERGE_HS400 (MERGE_CMD | MERGE_DS_DAT)
#define MERGE_DDR208 (MERGE_CMD \
| MERGE_DS_DAT \
| MERGE_DEVICE_D_RX \
| MERGE_HOST_D_TX)
#ifndef NULL
#define NULL 0
#endif
#ifndef TRUE
#define TRUE (0 == 0)
#endif
#ifndef FALSE
#define FALSE (0 != 0)
#endif
#define AUTOK_DBG_OFF 0
#define AUTOK_DBG_ERROR 1
#define AUTOK_DBG_RES 2
#define AUTOK_DBG_WARN 3
#define AUTOK_DBG_TRACE 4
#define AUTOK_DBG_LOUD 5
extern unsigned int autok_debug_level;
#define AUTOK_DBGPRINT(_level, _fmt ...) \
({ \
if (autok_debug_level >= _level) { \
pr_info(_fmt); \
} \
})
#define AUTOK_RAWPRINT(_fmt ...) \
({ \
pr_info(_fmt); \
})
enum ERROR_TYPE {
CMD_ERROR = 0,
DATA_ERROR,
CRC_STATUS_ERROR,
};
enum TUNE_TX_TYPE {
TX_CMD = 0,
TX_DATA,
};
enum AUTOK_PARAM {
/* command response sample selection
* (MSDC_SMPL_RISING, MSDC_SMPL_FALLING)
*/
CMD_EDGE,
/* cmd response async fifo out edge select */
CMD_FIFO_EDGE,
/* read data sample selection
* (MSDC_SMPL_RISING, MSDC_SMPL_FALLING)
*/
RDATA_EDGE,
/* read data async fifo out edge select */
RD_FIFO_EDGE,
/* write data crc status async fifo out edge select */
WD_FIFO_EDGE,
/* [Data Tune]CMD Pad RX Delay Line1 Control.
* This register is used to
* fine-tune CMD pad macro respose latch timing.
* Total 32 stages[Data Tune]
*/
CMD_RD_D_DLY1,
/* [Data Tune]CMD Pad RX Delay Line1 Sel-> delay cell1 enable */
CMD_RD_D_DLY1_SEL,
/* [Data Tune]CMD Pad RX Delay Line2 Control. This register is used to
* fine-tune CMD pad macro respose latch timing.
* Total 32 stages[Data Tune]
*/
CMD_RD_D_DLY2,
/* [Data Tune]CMD Pad RX Delay Line1 Sel-> delay cell2 enable */
CMD_RD_D_DLY2_SEL,
/* [Data Tune]DAT Pad RX Delay Line1 Control (for MSDC RD),
* Total 32 stages [Data Tune]
*/
DAT_RD_D_DLY1,
/* [Data Tune]DAT Pad RX Delay Line1 Sel-> delay cell1 enable */
DAT_RD_D_DLY1_SEL,
/* [Data Tune]DAT Pad RX Delay Line2 Control (for MSDC RD),
* Total 32 stages [Data Tune]
*/
DAT_RD_D_DLY2,
/* [Data Tune]DAT Pad RX Delay Line2 Sel-> delay cell2 enable */
DAT_RD_D_DLY2_SEL,
/* Internal MSDC clock phase selection. Total 8 stages,
* each stage can delay 1 clock period of msdc_src_ck
*/
INT_DAT_LATCH_CK,
/* DS Pad Z clk delay count, range: 0~63, Z dly1(0~31)+Z dly2(0~31) */
EMMC50_DS_Z_DLY1,
/* DS Pad Z clk del sel: [dly2_sel:dly1_sel] -> [0,1]:
* dly1 enable [1,2]:dl2 & dly1 enable ,else :no dly enable
*/
EMMC50_DS_Z_DLY1_SEL,
/* DS Pad Z clk delay count, range: 0~63, Z dly1(0~31)+Z dly2(0~31) */
EMMC50_DS_Z_DLY2,
/* DS Pad Z clk del sel: [dly2_sel:dly1_sel] -> [0,1]:
* dly1 enable [1,2]:dl2 & dly1 enable ,else :no dly enable,
*/
EMMC50_DS_Z_DLY2_SEL,
/* DS Pad Z_DLY clk delay count, range: 0~31 */
EMMC50_DS_ZDLY_DLY,
/* eMMC50 CMD TX dly */
EMMC50_CMD_TX_DLY,
/* eMMC50 DATA TX dly */
EMMC50_DATA0_TX_DLY,
EMMC50_DATA1_TX_DLY,
EMMC50_DATA2_TX_DLY,
EMMC50_DATA3_TX_DLY,
EMMC50_DATA4_TX_DLY,
EMMC50_DATA5_TX_DLY,
EMMC50_DATA6_TX_DLY,
EMMC50_DATA7_TX_DLY,
/* CLK Pad TX Delay Control. This register is used to
* add delay to CLK phase. Total 32 stages
*/
PAD_CLK_TXDLY_AUTOK,
TUNING_PARAM_COUNT,
/* CMD scan result */
CMD_SCAN_R0,
CMD_SCAN_R1,
CMD_SCAN_R2,
CMD_SCAN_R3,
CMD_SCAN_R4,
CMD_SCAN_R5,
CMD_SCAN_R6,
CMD_SCAN_R7,
CMD_SCAN_F0,
CMD_SCAN_F1,
CMD_SCAN_F2,
CMD_SCAN_F3,
CMD_SCAN_F4,
CMD_SCAN_F5,
CMD_SCAN_F6,
CMD_SCAN_F7,
/* DATA scan result */
DAT_SCAN_R0,
DAT_SCAN_R1,
DAT_SCAN_R2,
DAT_SCAN_R3,
DAT_SCAN_R4,
DAT_SCAN_R5,
DAT_SCAN_R6,
DAT_SCAN_R7,
DAT_SCAN_F0,
DAT_SCAN_F1,
DAT_SCAN_F2,
DAT_SCAN_F3,
DAT_SCAN_F4,
DAT_SCAN_F5,
DAT_SCAN_F6,
DAT_SCAN_F7,
/* DS CMD scan result */
DS_CMD_SCAN_0,
DS_CMD_SCAN_1,
DS_CMD_SCAN_2,
DS_CMD_SCAN_3,
DS_CMD_SCAN_4,
DS_CMD_SCAN_5,
DS_CMD_SCAN_6,
DS_CMD_SCAN_7,
/* DS DAT scan result */
DS_DAT_SCAN_0,
DS_DAT_SCAN_1,
DS_DAT_SCAN_2,
DS_DAT_SCAN_3,
DS_DAT_SCAN_4,
DS_DAT_SCAN_5,
DS_DAT_SCAN_6,
DS_DAT_SCAN_7,
/* Device CMD RX result */
D_CMD_SCAN_0,
D_CMD_SCAN_1,
D_CMD_SCAN_2,
D_CMD_SCAN_3,
/* Device DATA RX result */
D_DATA_SCAN_0,
D_DATA_SCAN_1,
D_DATA_SCAN_2,
D_DATA_SCAN_3,
/* Host CMD TX result */
H_CMD_SCAN_0,
H_CMD_SCAN_1,
H_CMD_SCAN_2,
H_CMD_SCAN_3,
/* Host DATA TX result */
H_DATA_SCAN_0,
H_DATA_SCAN_1,
H_DATA_SCAN_2,
H_DATA_SCAN_3,
/* AUTOK version */
AUTOK_VER0,
AUTOK_VER1,
AUTOK_VER2,
AUTOK_VER3,
CMD_MAX_WIN,
DAT_MAX_WIN,
DS_MAX_WIN,
DEV_D_RX_MAX_WIN,
DEV_C_RX_MAX_WIN,
H_D_TX_MAX_WIN,
H_C_TX_MAX_WIN,
H_CLK_TX_MAX_WIN,
TUNING_PARA_SCAN_COUNT,
/* Data line rising/falling latch
* fine tune selection in read transaction.
* 1'b0: All data line share one value indicated
* by MSDC_IOCON.R_D_SMPL.
* 1'b1: Each data line has its own selection value indicated by
* Data line (x): MSDC_IOCON.R_D(x)_SMPL
*/
READ_DATA_SMPL_SEL,
/* Data line rising/falling latch
* fine tune selection in write transaction.
* 1'b0: All data line share one value indicated by
* MSDC_IOCON.W_D_SMPL.
* 1'b1: Each data line has its own selection value
* indicated by Data line (x): MSDC_IOCON.W_D(x)_SMPL
*/
WRITE_DATA_SMPL_SEL,
/* Data line delay line fine tune selection.
*1'b0: All data line share one delay
* selection value indicated by PAD_TUNE.PAD_DAT_RD_RXDLY.
* 1'b1: Each data line has its
* own delay selection value indicated by
* Data line (x): DAT_RD_DLY(x).DAT0_RD_DLY
*/
DATA_DLYLINE_SEL,
/* [Data Tune]CMD & DATA Pin tune Data Selection[Data Tune Sel] */
MSDC_DAT_TUNE_SEL,
/* [Async_FIFO Mode Sel For Write Path] */
MSDC_WCRC_ASYNC_FIFO_SEL,
/* [Async_FIFO Mode Sel For CMD Path] */
MSDC_RESP_ASYNC_FIFO_SEL,
/* Write Path Mux for emmc50 function & emmc45 function ,
* Only emmc50 design valid,[1-eMMC50, 0-eMMC45]
*/
EMMC50_WDATA_MUX_EN,
/* CMD Path Mux for emmc50 function & emmc45 function ,
* Only emmc50 design valid,[1-eMMC50, 0-eMMC45]
*/
EMMC50_CMD_MUX_EN,
/* CMD response DS latch or internal clk latch */
EMMC50_CMD_RESP_LATCH,
/* write data crc status async fifo output edge select */
EMMC50_WDATA_EDGE,
/* CKBUF in CKGEN Delay Selection. Total 32 stages */
CKGEN_MSDC_DLY_SEL,
/* CMD response turn around period.
*The turn around cycle = CMD_RSP_TA_CNTR + 2,
* Only for USH104 mode, this register should be
* set to 0 in non-UHS104 mode
*/
CMD_RSP_TA_CNTR,
/* Write data and CRC status turn around period.
* The turn around cycle = WRDAT_CRCS_TA_CNTR + 2,
* Only for USH104 mode, this register should be set to 0
* in non-UHS104 mode
*/
WRDAT_CRCS_TA_CNTR,
SDC_RX_ENHANCE,
TOTAL_PARAM_COUNT
};
/**********************************************************
* Function Declaration *
**********************************************************/
extern int autok_path_sel(struct msdc_host *host);
extern int autok_init_ddr208(struct msdc_host *host);
extern int autok_init_sdr104(struct msdc_host *host);
extern int autok_init_hs200(struct msdc_host *host);
extern int autok_init_hs400(struct msdc_host *host);
extern int autok_offline_tuning_clk_TX(struct msdc_host *host,
unsigned int opcode);
extern int autok_offline_tuning_TX(struct msdc_host *host, u8 *res);
extern int autok_offline_tuning_device_RX(struct msdc_host *host, u8 *res);
extern void autok_msdc_tx_setting(struct msdc_host *host, struct mmc_ios *ios);
extern void autok_low_speed_switch_edge(struct msdc_host *host,
struct mmc_ios *ios, enum ERROR_TYPE error_type);
extern void autok_tuning_parameter_init(struct msdc_host *host, u8 *res);
extern int autok_sdio30_plus_tuning(struct msdc_host *host, u8 *res);
extern int autok_execute_tuning(struct msdc_host *host, u8 *res);
extern int hs200_execute_tuning(struct msdc_host *host, u8 *res);
extern int hs200_execute_tuning_cmd(struct msdc_host *host, u8 *res);
extern int hs400_execute_tuning(struct msdc_host *host, u8 *res);
extern int hs400_execute_tuning_cmd(struct msdc_host *host, u8 *res);
extern int autok_vcore_merge_sel(struct msdc_host *host,
unsigned int merge_cap);
#endif /* _AUTOK_H_ */
File diff suppressed because it is too large. Load diff
+187
View File
@@ -0,0 +1,187 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_MSDC_DEUBG__
#define __MT_MSDC_DEUBG__
#include "mtk_sd.h"
#include <linux/seq_file.h>
/* #define MTK_MSDC_ERROR_TUNE_DEBUG */
enum {
SD_TOOL_ZONE = 0,
SD_TOOL_DMA_SIZE = 1,
SD_TOOL_SDIO_PROFILE = 3,
SD_TOOL_REG_ACCESS = 5,
SD_TOOL_SET_DRIVING = 6,
RW_BIT_BY_BIT_COMPARE = 8,
SMP_TEST_ON_ONE_HOST = 9,
SMP_TEST_ON_ALL_HOST = 10,
SD_TOOL_MSDC_HOST_MODE = 11,
SD_TOOL_DMA_STATUS = 12,
SD_TOOL_ENABLE_SLEW_RATE = 13,
SD_TOOL_ENABLE_SMT = 14,
MMC_PERF_DEBUG = 15,
MMC_PERF_DEBUG_PRINT = 16,
SD_TOOL_SET_RDTDSEL = 17,
MSDC_READ_WRITE = 20,
MMC_ERROR_TUNE = 21,
MMC_EDC_EMMC_CACHE = 22,
MMC_DUMP_GPD = 23,
MMC_ETT_TUNE = 24,
MMC_CRC_STRESS = 25,
ENABLE_AXI_MODULE = 26,
DO_AUTOK_OFFLINE_TUNE_TX = 29,
SDIO_AUTOK_RESULT = 30,
MMC_CMDQ_STATUS = 31,
SD_TOOL_TOP_REG_ACCESS = 32,
};
/* Debug message event */
#define DBG_EVT_NONE (0) /* No event */
#define DBG_EVT_DMA (1 << 0) /* DMA related event */
#define DBG_EVT_CMD (1 << 1) /* MSDC CMD related event */
#define DBG_EVT_RSP (1 << 2) /* MSDC CMD RSP related event */
#define DBG_EVT_INT (1 << 3) /* MSDC INT event */
#define DBG_EVT_CFG (1 << 4) /* MSDC CFG event */
#define DBG_EVT_FUC (1 << 5) /* Function event */
#define DBG_EVT_OPS (1 << 6) /* Read/Write operation event */
#define DBG_EVT_FIO (1 << 7) /* FIFO operation event */
#define DBG_EVT_WRN (1 << 8) /* Warning event */
#define DBG_EVT_PWR (1 << 9) /* Power event */
#define DBG_EVT_CLK (1 << 10) /* Clock gate/ungate operation */
#define DBG_EVT_CHE (1 << 11) /* eMMC cache feature operation */
/* ==================================================== */
#define DBG_EVT_RW (1 << 12) /* Trace the Read/Write Command */
#define DBG_EVT_NRW (1 << 13) /* Trace other Command */
#define DBG_EVT_ALL (0xffffffff)
#define DBG_EVT_MASK (DBG_EVT_ALL)
#define TAGMSDC "msdc"
#define N_MSG(evt, fmt, args...) \
do { \
if ((DBG_EVT_##evt) & sd_debug_zone[host->id]) { \
pr_info(TAGMSDC"%d -> "fmt" <- %s() : L<%d> PID<%s><0x%x>\n", \
host->id, ##args, __func__, __LINE__, \
current->comm, current->pid); \
} \
} while (0)
#ifndef MTK_MMC_PRINT_PERIOD
#define ERR_MSG(fmt, args...) \
pr_info(TAGMSDC"%d -> "fmt" <- %s() : L<%d> PID<%s><0x%x>\n", \
host->id, ##args, __func__, __LINE__, current->comm, \
current->pid)
#else
#define MAX_PRINT_PERIOD (500000000) /* 500ms */
#define MAX_PRINT_NUMS_OVER_PERIOD (50)
#define ERR_MSG(fmt, args...) \
do { \
if (print_nums == 0) { \
print_nums++; \
msdc_print_start_time = sched_clock(); \
pr_info(TAGMSDC"MSDC", TAG"%d -> "fmt" <- %s() : L<%d> " \
"PID<%s><0x%x>\n", \
host->id, ##args, __func__, __LINE__, \
current->comm, current->pid); \
} else { \
msdc_print_end_time = sched_clock(); \
if ((msdc_print_end_time - msdc_print_start_time) >= \
MAX_PRINT_PERIOD) { \
pr_info( \
TAGMSDC"MSDC", TAG"%d -> "fmt" <- %s() : L<%d> " \
"PID<%s><0x%x>\n", \
host->id, ##args, __func__, __LINE__, \
current->comm, current->pid); \
print_nums = 0; \
} \
if (print_nums <= MAX_PRINT_NUMS_OVER_PERIOD) { \
pr_info(TAGMSDC"MSDC", TAG"%d -> "fmt" <- %s() : " \
"L<%d> PID<%s><0x%x>\n", \
host->id, ##args, __func__, \
__LINE__, current->comm, current->pid); \
print_nums++; \
} \
} \
} while (0)
#endif
#define INIT_MSG(fmt, args...) \
pr_info(TAGMSDC"%d -> "fmt" <- %s() : L<%d> PID<%s><0x%x>\n", \
host->id, ##args, __func__, __LINE__, current->comm, \
current->pid)
#define INFO_MSG(fmt, args...) \
pr_debug(TAGMSDC"%d -> "fmt" <- %s() : L<%d> PID<%s><0x%x>\n", \
host->id, ##args, __func__, __LINE__, current->comm, \
current->pid)
#ifdef MTK_MMC_PRINT_IRQ_MSG
/* PID in ISR in not corrent */
#define IRQ_MSG(fmt, args...) \
pr_info(TAGMSDC"%d -> "fmt" <- %s() : L<%d>\n", \
host->id, ##args, __func__, __LINE__)
#else
#define IRQ_MSG(fmt, args...)
#endif
/*
* snprintf may return a value of size or "more" to indicate
* that the output was truncated, thus be careful of "more"
* case.
*/
#define SPREAD_PRINTF(buff, size, evt, fmt, args...) \
do { \
if (buff && size && *(size)) { \
unsigned long var = snprintf(*(buff), *(size), fmt, ##args); \
if (var > 0) { \
if (var > *(size)) \
var = *(size); \
*(size) -= var; \
*(buff) += var; \
} \
} \
if (evt) \
seq_printf(evt, fmt, ##args); \
if (!buff && !evt) { \
pr_info(fmt, ##args); \
} \
} while (0)
#define MAGIC_CQHCI_DBG_TYPE 5
#define MAGIC_CQHCI_DBG_NUM_L 100
#define MAGIC_CQHCI_DBG_NUM_U 200
#define MAGIC_CQHCI_DBG_NUM_RI 500
#define MAGIC_CQHCI_DBG_TYPE_DCMD 60
/* softirq type */
#define MAGIC_CQHCI_DBG_TYPE_SIRQ 70
void msdc_dump_gpd_bd(int id);
int msdc_debug_proc_init(void);
int msdc_debug_proc_init_bootdevice(void);
#ifdef MTK_MMC_SDIO_DEBUG
void msdc_performance(u32 opcode, u32 sizes, u32 bRx, u32 ticks);
void sdio_get_time(struct mmc_request *mrq, struct timespec *time_now);
void sdio_calc_time(struct mmc_request *mrq, struct timespec *time_start);
#endif
void msdc_error_tune_debug1(struct msdc_host *host,
struct mmc_command *cmd, struct mmc_command *sbc, u32 *intsts);
void msdc_error_tune_debug2(struct msdc_host *host,
struct mmc_command *stop, u32 *intsts);
int multi_rw_compare(struct seq_file *m, int host_num,
uint address, int count, uint type, int multi_thread);
void dbg_add_host_log(struct mmc_host *mmc, int type, int cmd, int arg);
void dbg_add_sirq_log(struct mmc_host *mmc, int type,
int cmd, int arg, int cpu, unsigned long active_reqs);
void mmc_cmd_dump(char **buff, unsigned long *size, struct seq_file *m,
struct mmc_host *mmc, u32 latest_cnt);
void msdc_dump_host_state(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host);
#endif
@@ -0,0 +1,185 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifdef pr_fmt
#undef pr_fmt
#endif
#define pr_fmt(fmt) "["KBUILD_MODNAME"]" fmt
#include <generated/autoconf.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/printk.h>
#include <linux/mm_types.h>
#include <mt-plat/mtk_boot.h>
#include "mtk_sd.h"
#include <mmc/core/queue.h>
#include <mmc/core/core.h>
#include "dbg.h"
u64 msdc_get_user_capacity(struct msdc_host *host)
{
u64 capacity = 0;
u32 legacy_capacity = 0;
struct mmc_card *card;
if (host && host->mmc && host->mmc->card)
card = host->mmc->card;
else
return 0;
card = host->mmc->card;
if (mmc_card_mmc(card)) {
if (card->csd.read_blkbits) {
legacy_capacity =
(2 << (card->csd.read_blkbits - 1))
* card->csd.capacity;
} else {
legacy_capacity = card->csd.capacity;
ERR_MSG("XXX read_blkbits = 0 XXX");
}
capacity =
(u64)(card->ext_csd.sectors) * 512 > legacy_capacity ?
(u64)(card->ext_csd.sectors) * 512 : legacy_capacity;
} else if (mmc_card_sd(card)) {
capacity = (u64) (card->csd.capacity)
<< (card->csd.read_blkbits);
}
return capacity;
}
u32 msdc_get_other_capacity(struct msdc_host *host, char *name)
{
u32 device_other_capacity = 0;
int i;
struct mmc_card *card;
if (host && host->mmc && host->mmc->card)
card = host->mmc->card;
else
return 0;
for (i = 0; i < card->nr_parts; i++) {
if (!name) {
device_other_capacity += card->part[i].size;
} else if (strcmp(name, card->part[i].name) == 0) {
device_other_capacity = card->part[i].size;
break;
}
}
return device_other_capacity;
}
int msdc_get_part_info(unsigned char *name, struct hd_struct *part)
{
struct disk_part_iter piter;
struct hd_struct *l_part;
struct gendisk *disk;
int ret = 0, partno;
dev_t devt;
devt = blk_lookup_devt("mmcblk0", 0);
disk = get_gendisk(devt, &partno);
if (!disk)
return 0;
disk_part_iter_init(&piter, disk, 0);
while ((l_part = disk_part_iter_next(&piter))) {
if (!strncmp(l_part->info->volname, name, strlen(name))) {
memcpy(part, l_part, sizeof(struct hd_struct));
ret = 1;
break;
}
}
disk_part_iter_exit(&piter);
return ret;
}
#ifdef MTK_MSDC_USE_CACHE
unsigned long long g_cache_part_start;
unsigned long long g_cache_part_end;
unsigned long long g_usrdata_part_start;
unsigned long long g_usrdata_part_end;
static struct delayed_work get_cache_info;
int msdc_can_apply_cache(unsigned long long start_addr,
unsigned int size)
{
if (!g_cache_part_start && !g_cache_part_end &&
!g_usrdata_part_start && !g_usrdata_part_end)
return 0;
/* if cache, userdata partition are connected,
* so check it as an area, else do check them separately
*/
if (g_cache_part_end == g_usrdata_part_start) {
if ((start_addr < g_cache_part_start) ||
(start_addr + size >= g_usrdata_part_end)) {
return 0;
}
} else {
if (((start_addr < g_cache_part_start) ||
(start_addr + size >= g_cache_part_end))
&& ((start_addr < g_usrdata_part_start) ||
(start_addr + size >= g_usrdata_part_end))) {
return 0;
}
}
return 1;
}
void msdc_get_cache_region(struct work_struct *work)
{
struct hd_struct part = {0};
static int retry;
if (msdc_get_part_info("cache", &part)) {
g_cache_part_start = part.start_sect;
g_cache_part_end = g_cache_part_start + part.nr_sects;
}
memset(&part, 0, sizeof(struct hd_struct));
if (msdc_get_part_info("userdata", &part)) {
g_usrdata_part_start = part.start_sect;
g_usrdata_part_end = g_usrdata_part_start + part.nr_sects;
}
pr_info("cache(0x%llX~0x%llX, usrdata(0x%llX~0x%llX)\n",
g_cache_part_start, g_cache_part_end,
g_usrdata_part_start, g_usrdata_part_end);
if ((!g_cache_part_start || !g_cache_part_end ||
!g_usrdata_part_start || !g_usrdata_part_end) &&
retry++ < 5) {
/* re-schedule, if part info not ready */
pr_info("part info not ready re-schedule(%d) %s\n",
retry, __func__);
schedule_delayed_work(&get_cache_info, msecs_to_jiffies(1000));
}
}
EXPORT_SYMBOL(msdc_get_cache_region);
static int __init init_get_cache_work(void)
{
int boot_type;
boot_type = get_boot_type();
if (boot_type != BOOTDEV_SDMMC)
return 0;
INIT_DELAYED_WORK(&get_cache_info, msdc_get_cache_region);
schedule_delayed_work(&get_cache_info, msecs_to_jiffies(500));
return 0;
}
late_initcall_sync(init_get_cache_work);
#endif
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,501 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifdef pr_fmt
#undef pr_fmt
#endif
#define pr_fmt(fmt) "["KBUILD_MODNAME"]" fmt
#include <linux/gpio.h>
#include <linux/delay.h>
#include "mtk_sd.h"
#include <mmc/core/core.h>
#include <mmc/core/card.h>
#include "dbg.h"
#include "autok.h"
#include "autok_dvfs.h"
void msdc_sdio_restore_after_resume(struct msdc_host *host)
{
}
void msdc_save_timing_setting(struct msdc_host *host)
{
struct msdc_hw *hw = host->hw;
void __iomem *base = host->base, *base_top;
int i;
MSDC_GET_FIELD(MSDC_IOCON, MSDC_IOCON_RSPL, hw->cmd_edge);
MSDC_GET_FIELD(MSDC_IOCON, MSDC_IOCON_R_D_SMPL, hw->rdata_edge);
MSDC_GET_FIELD(MSDC_IOCON, MSDC_IOCON_W_D_SMPL, hw->wdata_edge);
// this is for suspend only
host->saved_para.sdc_cfg = MSDC_READ32(SDC_CFG);
host->saved_para.iocon = MSDC_READ32(MSDC_IOCON);
host->saved_para.emmc50_cfg0 = MSDC_READ32(EMMC50_CFG0);
host->saved_para.pb0 = MSDC_READ32(MSDC_PATCH_BIT0);
host->saved_para.pb1 = MSDC_READ32(MSDC_PATCH_BIT1);
host->saved_para.pb2 = MSDC_READ32(MSDC_PATCH_BIT2);
host->saved_para.sdc_fifo_cfg = MSDC_READ32(SDC_FIFO_CFG);
host->saved_para.sdc_adv_cfg0 = MSDC_READ32(SDC_ADV_CFG0);
if (host->base_top) {
base_top = host->base_top;
host->saved_para.emmc_top_control
= MSDC_READ32(EMMC_TOP_CONTROL);
host->saved_para.emmc_top_cmd
= MSDC_READ32(EMMC_TOP_CMD);
host->saved_para.top_emmc50_pad_ctl0
= MSDC_READ32(TOP_EMMC50_PAD_CTL0);
host->saved_para.top_emmc50_pad_ds_tune
= MSDC_READ32(TOP_EMMC50_PAD_DS_TUNE);
for (i = 0; i < 8; i++) {
host->saved_para.top_emmc50_pad_dat_tune[i]
= MSDC_READ32(TOP_EMMC50_PAD_DAT0_TUNE + i * 4);
}
} else {
host->saved_para.pad_tune0 = MSDC_READ32(MSDC_PAD_TUNE0);
host->saved_para.pad_tune1 = MSDC_READ32(MSDC_PAD_TUNE1);
}
}
void msdc_set_bad_card_and_remove(struct msdc_host *host)
{
unsigned long flags;
if (host == NULL) {
pr_info("WARN: host is NULL");
return;
}
if (host->card_inserted) {
host->block_bad_card = 1;
host->card_inserted = 0;
}
if ((host->mmc == NULL) || (host->mmc->card == NULL)) {
ERR_MSG("WARN: mmc or card is NULL");
return;
}
if (host->mmc->card) {
spin_lock_irqsave(&host->remove_bad_card, flags);
mmc_card_set_removed(host->mmc->card);
spin_unlock_irqrestore(&host->remove_bad_card, flags);
#ifndef CONFIG_GPIOLIB
ERR_MSG("Cannot get gpio %d level", cd_gpio);
#else
if (!(host->mmc->caps & MMC_CAP_NONREMOVABLE)) {
ERR_MSG("Schedule mmc_rescan");
mmc_detect_change(host->mmc, msecs_to_jiffies(200));
} else
#endif
{
/*
* prevent from calling device_del with mmcqd/X,
* it will cause dead lock
*/
ERR_MSG("Schedule msdc_remove_card");
schedule_delayed_work(&host->remove_card,
msecs_to_jiffies(200));
}
if (host->block_bad_card)
ERR_MSG(
"Remove the bad card, block_bad_card=%d, card_inserted=%d",
host->block_bad_card, host->card_inserted);
}
}
void msdc_ops_set_bad_card_and_remove(struct mmc_host *mmc)
{
struct msdc_host *host = mmc_priv(mmc);
msdc_set_bad_card_and_remove(host);
}
void msdc_remove_card(struct work_struct *work)
{
struct msdc_host *host =
container_of(work, struct msdc_host, remove_card.work);
if (!host->mmc || !host->mmc->card) {
ERR_MSG("WARN: mmc or card is NULL");
return;
}
ERR_MSG("Remove card");
mmc_claim_host(host->mmc);
mmc_remove_card(host->mmc->card);
host->mmc->card = NULL;
mmc_detach_bus(host->mmc);
mmc_power_off(host->mmc);
mmc_release_host(host->mmc);
}
int msdc_data_timeout_cont_chk(struct msdc_host *host)
{
if ((host->hw->host_function == MSDC_SD) &&
(host->data_timeout_cont >= MSDC_MAX_DATA_TIMEOUT_CONTINUOUS)) {
ERR_MSG("force remove bad card, data timeout continuous %d",
host->data_timeout_cont);
msdc_set_bad_card_and_remove(host);
return 1;
}
return 0;
}
int emmc_reinit_tuning(struct mmc_host *mmc)
{
struct msdc_host *host = mmc_priv(mmc);
void __iomem *base = host->base;
u32 div = 0;
u32 mode = 0;
unsigned int caps_hw_reset = 0;
if (!mmc->card) {
pr_notice("mmc card = NULL, skip reset tuning\n");
return -1;
}
/* Switch to DDR/HS mode */
if (mmc->card->mmc_avail_type
& (EXT_CSD_CARD_TYPE_HS200 | EXT_CSD_CARD_TYPE_HS400)) {
mmc->card->mmc_avail_type &=
~(EXT_CSD_CARD_TYPE_HS200|EXT_CSD_CARD_TYPE_HS400);
pr_notice("msdc%d: switch to DDR/HS mode, reinit card\n",
host->id);
if (mmc->caps & MMC_CAP_HW_RESET) {
caps_hw_reset = 1;
} else {
caps_hw_reset = 0;
mmc->caps |= MMC_CAP_HW_RESET;
}
mmc->ios.timing = MMC_TIMING_LEGACY;
mmc->ios.clock = 260000;
msdc_ops_set_ios(mmc, &mmc->ios);
host->hs400_mode = false;
if (mmc_hw_reset(mmc))
pr_notice("msdc%d fail to switch to DDR/HS mode\n",
host->id);
/* restore MMC_CAP_HW_RESET */
if (!caps_hw_reset)
mmc->caps &= ~MMC_CAP_HW_RESET;
goto done;
}
/* Reduce to lower frequency */
MSDC_GET_FIELD(MSDC_CFG, MSDC_CFG_CKDIV, div);
MSDC_GET_FIELD(MSDC_CFG, MSDC_CFG_CKMOD, mode);
div += 1;
if (div > EMMC_MAX_FREQ_DIV) {
pr_notice("msdc%d: max lower freq: %d\n", host->id, div);
return 1;
}
msdc_clk_stable(host, mode, div, 0);
host->sclk = (div == 0) ? host->hclk / 4 : host->hclk / (4 * div);
pr_notice("msdc%d: reduce frequence to %dMhz\n",
host->id, host->sclk / 1000000);
done:
return 0;
}
int sdcard_hw_reset(struct mmc_host *mmc)
{
struct msdc_host *host = mmc_priv(mmc);
int ret = 0;
int level = 1;
#ifdef CONFIG_GPIOLIB
level = __gpio_get_value(cd_gpio);
#endif
host->card_inserted = (host->hw->cd_level == level) ? 1 : 0;
if (!(host->card_inserted)) {
pr_notice("card is not inserted!\n");
msdc_set_bad_card_and_remove(host);
ret = -1;
return ret;
}
/* power reset sdcard */
mmc->ios.timing = MMC_TIMING_LEGACY;
/* do not set same as HOST_MIN_MCLK
* or else it will be set as block_bad_card when power off
*/
mmc->ios.clock = 300000;
msdc_ops_set_ios(mmc, &mmc->ios);
ret = mmc_hw_reset(mmc);
if (ret) {
if (++host->power_cycle_cnt
> MSDC_MAX_POWER_CYCLE_FAIL_CONTINUOUS)
msdc_set_bad_card_and_remove(host);
pr_notice(
"msdc%d power reset (%d) failed, block_bad_card = %d\n",
host->id, host->power_cycle_cnt, host->block_bad_card);
} else {
host->power_cycle_cnt = 0;
pr_notice("msdc%d power reset success\n", host->id);
}
return ret;
}
/* SDcard will change speed mode and power reset
* UHS card
* UHS_SDR104 --> UHS_DDR50 --> UHS_SDR50 --> UHS_SDR25
* HS card
* 50MHz --> 25MHz --> 12.5MHz --> 6.25MHz
*/
int sdcard_reset_tuning(struct mmc_host *mmc)
{
struct msdc_host *host = mmc_priv(mmc);
char *remove_cap;
int ret = 0;
if (!mmc->card) {
pr_notice("mmc card = NULL, skip reset tuning\n");
return -1;
}
if (mmc_card_uhs(mmc->card)) {
if (mmc->card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104) {
mmc->card->sw_caps.sd3_bus_mode &= ~SD_MODE_UHS_SDR104;
remove_cap = "UHS_SDR104";
} else if (mmc->card->sw_caps.sd3_bus_mode
& SD_MODE_UHS_DDR50) {
mmc->card->sw_caps.sd3_bus_mode &= ~SD_MODE_UHS_DDR50;
remove_cap = "UHS_DDR50";
} else if (mmc->card->sw_caps.sd3_bus_mode
& SD_MODE_UHS_SDR50) {
mmc->card->sw_caps.sd3_bus_mode &= ~SD_MODE_UHS_SDR50;
remove_cap = "UHS_SDR50";
} else if (mmc->card->sw_caps.sd3_bus_mode
& SD_MODE_UHS_SDR25) {
mmc->card->sw_caps.sd3_bus_mode &= ~SD_MODE_UHS_SDR25;
remove_cap = "UHS_SDR25";
} else {
remove_cap = "none";
}
pr_notice("msdc%d: remove %s mode then reinit card\n", host->id,
remove_cap);
} else if (mmc_card_hs(mmc->card)) {
if (mmc->card->sw_caps.hs_max_dtr >= HIGH_SPEED_MAX_DTR / 4)
mmc->card->sw_caps.hs_max_dtr /= 2;
pr_notice("msdc%d: set hs speed %dhz then reinit card\n",
host->id, mmc->card->sw_caps.hs_max_dtr);
} else {
pr_notice("msdc%d: ds card just reinit card\n", host->id);
}
/* force remove card for continuous data timeout */
ret = msdc_data_timeout_cont_chk(host);
if (ret) {
ret = -1;
goto done;
}
/* power cycle sdcard */
ret = sdcard_hw_reset(mmc);
if (ret) {
ret = -1;
goto done;
}
done:
return ret;
}
void msdc_restore_timing_setting(struct msdc_host *host)
{
void __iomem *base = host->base, *base_top = host->base_top;
int emmc = (host->hw->host_function == MSDC_EMMC) ? 1 : 0;
int i;
autok_path_sel(host);
MSDC_WRITE32(SDC_CFG, host->saved_para.sdc_cfg);
MSDC_WRITE32(MSDC_IOCON, host->saved_para.iocon);
if (!host->base_top) {
MSDC_WRITE32(MSDC_PAD_TUNE0, host->saved_para.pad_tune0);
MSDC_WRITE32(MSDC_PAD_TUNE1, host->saved_para.pad_tune1);
}
MSDC_WRITE32(MSDC_PATCH_BIT0, host->saved_para.pb0);
MSDC_WRITE32(MSDC_PATCH_BIT1, host->saved_para.pb1);
MSDC_WRITE32(MSDC_PATCH_BIT2, host->saved_para.pb2);
MSDC_WRITE32(SDC_FIFO_CFG, host->saved_para.sdc_fifo_cfg);
MSDC_WRITE32(SDC_ADV_CFG0, host->saved_para.sdc_adv_cfg0);
if (emmc && !host->base_top) {
/* FIX ME: sdio shall add extra check for sdio3.0+ */
MSDC_SET_FIELD(EMMC50_PAD_DS_TUNE, MSDC_EMMC50_PAD_DS_TUNE_DLY1,
host->saved_para.ds_dly1);
MSDC_SET_FIELD(EMMC50_PAD_DS_TUNE, MSDC_EMMC50_PAD_DS_TUNE_DLY3,
host->saved_para.ds_dly3);
MSDC_WRITE32(EMMC50_PAD_CMD_TUNE,
host->saved_para.emmc50_pad_cmd_tune);
MSDC_WRITE32(EMMC50_PAD_DAT01_TUNE,
host->saved_para.emmc50_dat01);
MSDC_WRITE32(EMMC50_PAD_DAT23_TUNE,
host->saved_para.emmc50_dat23);
MSDC_WRITE32(EMMC50_PAD_DAT45_TUNE,
host->saved_para.emmc50_dat45);
MSDC_WRITE32(EMMC50_PAD_DAT67_TUNE,
host->saved_para.emmc50_dat67);
}
if (emmc)
MSDC_WRITE32(EMMC50_CFG0, host->saved_para.emmc50_cfg0);
if (host->base_top) {
MSDC_WRITE32(EMMC_TOP_CONTROL,
host->saved_para.emmc_top_control);
MSDC_WRITE32(EMMC_TOP_CMD,
host->saved_para.emmc_top_cmd);
MSDC_WRITE32(TOP_EMMC50_PAD_CTL0,
host->saved_para.top_emmc50_pad_ctl0);
MSDC_WRITE32(TOP_EMMC50_PAD_DS_TUNE,
host->saved_para.top_emmc50_pad_ds_tune);
for (i = 0; i < 8; i++) {
MSDC_WRITE32(TOP_EMMC50_PAD_DAT0_TUNE + i * 4,
host->saved_para.top_emmc50_pad_dat_tune[i]);
}
}
if (host->use_hw_dvfs == 1)
msdc_dvfs_reg_restore(host);
}
void msdc_init_tune_path(struct msdc_host *host, unsigned char timing)
{
void __iomem *base = host->base, *base_top = host->base_top;
MSDC_WRITE32(MSDC_PAD_TUNE0, 0x00000000);
if (host->base_top) {
/* FIX ME: toggle these fields accroding to timing */
/* FIX ME: maybe unnecessary if autok can take care */
MSDC_CLR_BIT32(EMMC_TOP_CONTROL, DATA_K_VALUE_SEL);
MSDC_CLR_BIT32(EMMC_TOP_CONTROL, DELAY_EN);
MSDC_CLR_BIT32(EMMC_TOP_CONTROL, PAD_DAT_RD_RXDLY);
MSDC_CLR_BIT32(EMMC_TOP_CONTROL, PAD_DAT_RD_RXDLY_SEL);
MSDC_CLR_BIT32(EMMC_TOP_CONTROL, PAD_RXDLY_SEL);
MSDC_CLR_BIT32(EMMC_TOP_CMD, PAD_CMD_RXDLY);
MSDC_CLR_BIT32(EMMC_TOP_CMD, PAD_CMD_RD_RXDLY_SEL);
MSDC_CLR_BIT32(TOP_EMMC50_PAD_CTL0, PAD_CLK_TXDLY);
}
MSDC_CLR_BIT32(MSDC_IOCON, MSDC_IOCON_DDLSEL);
MSDC_CLR_BIT32(MSDC_IOCON, MSDC_IOCON_R_D_SMPL_SEL);
MSDC_CLR_BIT32(MSDC_IOCON, MSDC_IOCON_R_D_SMPL);
if (timing == MMC_TIMING_MMC_HS400) {
MSDC_CLR_BIT32(MSDC_PAD_TUNE0, MSDC_PAD_TUNE0_DATRRDLYSEL);
MSDC_CLR_BIT32(MSDC_PAD_TUNE1, MSDC_PAD_TUNE1_DATRRDLY2SEL);
if (host->base_top) {
/* FIX ME: maybe unnecessary if autok can take care */
MSDC_CLR_BIT32(EMMC_TOP_CONTROL, PAD_DAT_RD_RXDLY_SEL);
MSDC_CLR_BIT32(EMMC_TOP_CONTROL, PAD_DAT_RD_RXDLY2_SEL);
}
} else {
MSDC_SET_BIT32(MSDC_PAD_TUNE0, MSDC_PAD_TUNE0_DATRRDLYSEL);
MSDC_CLR_BIT32(MSDC_PAD_TUNE1, MSDC_PAD_TUNE1_DATRRDLY2SEL);
if (host->base_top) {
/* FIX ME: maybe unnecessary if autok can take care */
MSDC_SET_BIT32(EMMC_TOP_CONTROL, PAD_DAT_RD_RXDLY_SEL);
MSDC_CLR_BIT32(EMMC_TOP_CONTROL, PAD_DAT_RD_RXDLY2_SEL);
}
}
if (timing == MMC_TIMING_MMC_HS400)
MSDC_CLR_BIT32(MSDC_PATCH_BIT2, MSDC_PB2_CFGCRCSTS);
else
MSDC_SET_BIT32(MSDC_PATCH_BIT2, MSDC_PB2_CFGCRCSTS);
MSDC_CLR_BIT32(MSDC_IOCON, MSDC_IOCON_W_D_SMPL_SEL);
MSDC_CLR_BIT32(MSDC_PATCH_BIT2, MSDC_PB2_CFGRESP);
MSDC_SET_BIT32(MSDC_PAD_TUNE0, MSDC_PAD_TUNE0_CMDRRDLYSEL);
MSDC_CLR_BIT32(MSDC_PAD_TUNE1, MSDC_PAD_TUNE1_CMDRRDLY2SEL);
if ((timing == MMC_TIMING_MMC_HS400) && (host->base_top)) {
/* FIX ME: maybe unnecessary if autok can take care */
MSDC_SET_BIT32(EMMC_TOP_CMD, PAD_CMD_RD_RXDLY_SEL);
MSDC_CLR_BIT32(EMMC_TOP_CMD, PAD_CMD_RD_RXDLY2_SEL);
}
MSDC_CLR_BIT32(EMMC50_CFG0, MSDC_EMMC50_CFG_CMD_RESP_SEL);
autok_path_sel(host);
}
void msdc_init_tune_setting(struct msdc_host *host)
{
void __iomem *base = host->base, *base_top = host->base_top;
u32 val;
/* FIX ME: check if always convered by autok */
MSDC_SET_FIELD(MSDC_PAD_TUNE0, MSDC_PAD_TUNE0_CLKTXDLY,
MSDC_CLKTXDLY);
if (host->base_top) {
MSDC_SET_FIELD(TOP_EMMC50_PAD_CTL0, PAD_CLK_TXDLY,
MSDC_CLKTXDLY);
MSDC_SET_FIELD(EMMC_TOP_CONTROL,
(PAD_DAT_RD_RXDLY2 | PAD_DAT_RD_RXDLY), 0);
MSDC_SET_FIELD(EMMC_TOP_CMD,
(PAD_CMD_RXDLY2 | PAD_CMD_RXDLY), 0);
MSDC_SET_FIELD(TOP_EMMC50_PAD_DS_TUNE,
(PAD_DS_DLY3 | PAD_DS_DLY2 | PAD_DS_DLY1), 0);
}
/* Reserve MSDC_IOCON_DDR50CKD bit, clear all other bits */
val = MSDC_READ32(MSDC_IOCON) & MSDC_IOCON_DDR50CKD;
MSDC_WRITE32(MSDC_IOCON, val);
MSDC_WRITE32(MSDC_DAT_RDDLY0, 0x00000000);
MSDC_WRITE32(MSDC_DAT_RDDLY1, 0x00000000);
MSDC_WRITE32(MSDC_PATCH_BIT0, MSDC_PB0_DEFAULT_VAL);
MSDC_WRITE32(MSDC_PATCH_BIT1, MSDC_PB1_DEFAULT_VAL);
/* Fix HS400 mode */
MSDC_CLR_BIT32(EMMC50_CFG0, MSDC_EMMC50_CFG_TXSKEW_SEL);
MSDC_SET_BIT32(MSDC_PATCH_BIT1, MSDC_PB1_DDR_CMD_FIX_SEL);
/* DDR50 mode */
MSDC_SET_BIT32(MSDC_PATCH_BIT2, MSDC_PB2_DDR50SEL);
/* 64T + 48T cmd <-> resp */
MSDC_SET_FIELD(MSDC_PATCH_BIT2, MSDC_PB2_RESPWAITCNT,
MSDC_PB2_DEFAULT_RESPWAITCNT);
MSDC_SET_FIELD(MSDC_PATCH_BIT2, MSDC_PB2_RESPSTENSEL,
MSDC_PB2_DEFAULT_RESPSTENSEL);
MSDC_SET_FIELD(MSDC_PATCH_BIT2, MSDC_PB2_CRCSTSENSEL,
MSDC_PB2_DEFAULT_CRCSTSENSEL);
/* FIX ME: check if can be moved to msdc_cust.c */
#ifdef CONFIG_MACH_MT6799
if (CHIP_IS_VER2())
SET_EMMC50_CFG_END_BIT_CHK_CNT(EMMC50_CFG_END_BIT_CHK_CNT);
#endif
autok_path_sel(host);
}
void msdc_ios_tune_setting(struct msdc_host *host, struct mmc_ios *ios)
{
autok_msdc_tx_setting(host, ios);
}
@@ -0,0 +1,310 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _AUTOK_CUST_H_
#define _AUTOK_CUST_H_
#define AUTOK_VERSION (0x17080217)
struct AUTOK_PLAT_PARA_TX {
unsigned int chip_hw_ver;
u8 msdc0_hs400_clktx;
u8 msdc0_hs400_cmdtx;
u8 msdc0_hs400_dat0tx;
u8 msdc0_hs400_dat1tx;
u8 msdc0_hs400_dat2tx;
u8 msdc0_hs400_dat3tx;
u8 msdc0_hs400_dat4tx;
u8 msdc0_hs400_dat5tx;
u8 msdc0_hs400_dat6tx;
u8 msdc0_hs400_dat7tx;
u8 msdc0_hs400_txskew;
u8 msdc0_ddr_ckd;
u8 msdc1_ddr_ckd;
u8 msdc2_ddr_ckd;
u8 msdc0_clktx;
u8 msdc0_cmdtx;
u8 msdc0_dat0tx;
u8 msdc0_dat1tx;
u8 msdc0_dat2tx;
u8 msdc0_dat3tx;
u8 msdc0_dat4tx;
u8 msdc0_dat5tx;
u8 msdc0_dat6tx;
u8 msdc0_dat7tx;
u8 msdc0_txskew;
u8 msdc1_clktx;
u8 msdc1_sdr104_clktx;
u8 msdc2_clktx;
u8 sdio30_plus_clktx;
u8 sdio30_plus_cmdtx;
u8 sdio30_plus_dat0tx;
u8 sdio30_plus_dat1tx;
u8 sdio30_plus_dat2tx;
u8 sdio30_plus_dat3tx;
u8 msdc0_duty_bypass;
u8 msdc0_hl_duty_sel;
u8 msdc1_duty_bypass;
u8 msdc1_hl_duty_sel;
u8 msdc2_duty_bypass;
u8 msdc2_hl_duty_sel;
};
struct AUTOK_PLAT_PARA_RX {
unsigned int chip_hw_ver;
u8 ckgen_val;
u8 latch_en_cmd_hs400;
u8 latch_en_crc_hs400;
u8 latch_en_cmd_hs200;
u8 latch_en_crc_hs200;
u8 latch_en_cmd_ddr208;
u8 latch_en_crc_ddr208;
u8 latch_en_cmd_sd_sdr104;
u8 latch_en_crc_sd_sdr104;
u8 latch_en_cmd_sdio_sdr104;
u8 latch_en_crc_sdio_sdr104;
u8 latch_en_cmd_hs;
u8 latch_en_crc_hs;
u8 cmd_ta_val;
u8 crc_ta_val;
u8 busy_ma_val;
u8 new_water_hs400;
u8 new_water_hs200;
u8 new_water_ddr208;
u8 new_water_sdr104;
u8 new_water_hs;
u8 new_stop_hs400;
u8 new_stop_hs200;
u8 new_stop_ddr208;
u8 new_stop_sdr104;
u8 new_stop_hs;
u8 old_water_hs400;
u8 old_water_hs200;
u8 old_water_ddr208;
u8 old_water_sdr104;
u8 old_water_hs;
u8 old_stop_hs400;
u8 old_stop_hs200;
u8 old_stop_ddr208;
u8 old_stop_sdr104;
u8 old_stop_hs;
u8 read_dat_cnt_hs400;
u8 read_dat_cnt_ddr208;
u8 end_bit_chk_cnt_hs400;
u8 end_bit_chk_cnt_ddr208;
u8 latchck_switch_cnt_hs400;
u8 latchck_switch_cnt_ddr208;
u8 ds_dly3_hs400;
u8 ds_dly3_ddr208;
};
struct AUTOK_PLAT_PARA_MISC {
unsigned int chip_hw_ver;
u8 latch_ck_emmc_times;
u8 latch_ck_sdio_times;
u8 latch_ck_sd_times;
u8 emmc_data_tx_tune;
u8 data_tx_separate_tune;
};
struct AUTOK_PLAT_TOP_CTRL {
u8 msdc0_rx_enhance_top;
u8 msdc1_rx_enhance_top;
u8 msdc2_rx_enhance_top;
};
struct AUTOK_PLAT_FUNC {
unsigned int chip_hw_ver;
u8 new_path_hs400;
u8 new_path_hs200;
u8 new_path_ddr208;
u8 new_path_sdr104;
u8 new_path_hs;
u8 multi_sync;
u8 rx_enhance;
u8 r1b_check;
u8 ddr50_fix;
u8 fifo_1k;
u8 latch_enhance;
u8 msdc0_bypass_duty_modify;
u8 msdc1_bypass_duty_modify;
u8 msdc2_bypass_duty_modify;
};
#define get_platform_para_tx(autok_para_tx) \
do { \
autok_para_tx.msdc0_hs400_clktx = 0; \
autok_para_tx.msdc0_hs400_cmdtx = 0; \
autok_para_tx.msdc0_hs400_dat0tx = 0; \
autok_para_tx.msdc0_hs400_dat1tx = 0; \
autok_para_tx.msdc0_hs400_dat2tx = 0; \
autok_para_tx.msdc0_hs400_dat3tx = 0; \
autok_para_tx.msdc0_hs400_dat4tx = 0; \
autok_para_tx.msdc0_hs400_dat5tx = 0; \
autok_para_tx.msdc0_hs400_dat6tx = 0; \
autok_para_tx.msdc0_hs400_dat7tx = 0; \
autok_para_tx.msdc0_hs400_txskew = 0; \
autok_para_tx.msdc0_ddr_ckd = 1; \
autok_para_tx.msdc1_ddr_ckd = 0; \
autok_para_tx.msdc2_ddr_ckd = 1; \
autok_para_tx.msdc0_clktx = 0; \
autok_para_tx.msdc0_cmdtx = 0; \
autok_para_tx.msdc0_dat0tx = 0; \
autok_para_tx.msdc0_dat1tx = 0; \
autok_para_tx.msdc0_dat2tx = 0; \
autok_para_tx.msdc0_dat3tx = 0; \
autok_para_tx.msdc0_dat4tx = 0; \
autok_para_tx.msdc0_dat5tx = 0; \
autok_para_tx.msdc0_dat6tx = 0; \
autok_para_tx.msdc0_dat7tx = 0; \
autok_para_tx.msdc0_txskew = 0; \
autok_para_tx.msdc1_clktx = 0; \
autok_para_tx.msdc1_sdr104_clktx = 0; \
autok_para_tx.msdc2_clktx = 0; \
autok_para_tx.sdio30_plus_clktx = 0; \
autok_para_tx.sdio30_plus_cmdtx = 0; \
autok_para_tx.sdio30_plus_dat0tx = 0; \
autok_para_tx.sdio30_plus_dat1tx = 0; \
autok_para_tx.sdio30_plus_dat2tx = 0; \
autok_para_tx.sdio30_plus_dat3tx = 0; \
autok_para_tx.msdc0_duty_bypass = 0; \
autok_para_tx.msdc0_hl_duty_sel = 0; \
autok_para_tx.msdc1_duty_bypass = 0; \
autok_para_tx.msdc1_hl_duty_sel = 0; \
autok_para_tx.msdc2_duty_bypass = 0; \
autok_para_tx.msdc2_hl_duty_sel = 0; \
} while (0)
#define get_platform_para_rx(autok_para_rx) \
do { \
autok_para_rx.ckgen_val = 0; \
autok_para_rx.latch_en_cmd_hs400 = 2; \
autok_para_rx.latch_en_crc_hs400 = 2; \
autok_para_rx.latch_en_cmd_hs200 = 1; \
autok_para_rx.latch_en_crc_hs200 = 1; \
autok_para_rx.latch_en_cmd_ddr208 = 2; \
autok_para_rx.latch_en_crc_ddr208 = 2; \
autok_para_rx.latch_en_cmd_sd_sdr104 = 1; \
autok_para_rx.latch_en_crc_sd_sdr104 = 1; \
autok_para_rx.latch_en_cmd_sdio_sdr104 = 1; \
autok_para_rx.latch_en_crc_sdio_sdr104 = 1; \
autok_para_rx.latch_en_cmd_hs = 1; \
autok_para_rx.latch_en_crc_hs = 1; \
autok_para_rx.cmd_ta_val = 0; \
autok_para_rx.crc_ta_val = 0; \
autok_para_rx.busy_ma_val = 1; \
autok_para_rx.new_water_hs400 = 8; \
autok_para_rx.new_stop_hs400 = 3; \
autok_para_rx.new_water_hs200 = 0; \
autok_para_rx.new_stop_hs200 = 6; \
autok_para_rx.new_water_ddr208 = 8; \
autok_para_rx.new_stop_ddr208 = 3; \
autok_para_rx.new_water_sdr104 = 0; \
autok_para_rx.new_stop_sdr104 = 6; \
autok_para_rx.new_water_hs = 8; \
autok_para_rx.new_stop_hs = 3; \
autok_para_rx.old_water_hs400 = 8; \
autok_para_rx.old_stop_hs400 = 3; \
autok_para_rx.old_water_hs200 = 0; \
autok_para_rx.old_stop_hs200 = 6; \
autok_para_rx.old_water_ddr208 = 8; \
autok_para_rx.old_stop_ddr208 = 3; \
autok_para_rx.old_water_sdr104 = 0; \
autok_para_rx.old_stop_sdr104 = 6; \
autok_para_rx.old_water_hs = 8; \
autok_para_rx.old_stop_hs = 3; \
autok_para_rx.read_dat_cnt_hs400 = 1; \
autok_para_rx.read_dat_cnt_ddr208 = 1; \
autok_para_rx.end_bit_chk_cnt_hs400 = 3; \
autok_para_rx.end_bit_chk_cnt_ddr208 = 3; \
autok_para_rx.latchck_switch_cnt_hs400 = 3; \
autok_para_rx.latchck_switch_cnt_ddr208 = 3; \
autok_para_rx.ds_dly3_hs400 = 12; \
autok_para_rx.ds_dly3_ddr208 = 20; \
} while (0)
#define get_platform_para_misc(autok_para_misc) \
do { \
autok_para_misc.latch_ck_emmc_times = 10; \
autok_para_misc.latch_ck_sdio_times = 20; \
autok_para_misc.latch_ck_sd_times = 20; \
autok_para_misc.emmc_data_tx_tune = 1; \
autok_para_misc.data_tx_separate_tune = 0; \
} while (0)
#define get_platform_top_ctrl(autok_top_ctrl) \
do { \
autok_top_ctrl.msdc0_rx_enhance_top = 1; \
autok_top_ctrl.msdc1_rx_enhance_top = 1; \
autok_top_ctrl.msdc2_rx_enhance_top = 0; \
} while (0)
/*
* emmc_data_tx_tune:0 use cmd24;1 use cmd23+cmd25;2:use cmdq cmd
*/
#define get_platform_func(autok_para_func) \
do { \
autok_para_func.new_path_hs400 = 1; \
autok_para_func.new_path_hs200 = 1; \
autok_para_func.new_path_ddr208 = 1; \
autok_para_func.new_path_sdr104 = 1; \
autok_para_func.new_path_hs = 1; \
autok_para_func.multi_sync = 1; \
autok_para_func.rx_enhance = 1; \
autok_para_func.msdc0_bypass_duty_modify = 1; \
autok_para_func.msdc1_bypass_duty_modify = 0; \
autok_para_func.msdc2_bypass_duty_modify = 0; \
} while (0)
#define PORT0_PB0_RD_DAT_SEL_VALID
#define PORT1_PB0_RD_DAT_SEL_VALID
#define PORT3_PB0_RD_DAT_SEL_VALID
#define MMC_QUE_TASK_PARAMS_RD 441
#define MMC_QUE_TASK_PARAMS_WR 440
#define MMC_SWITCH_CQ_EN 601
#define MMC_SWITCH_CQ_DIS 600
/*
* reg define
*/
#define AUTOK_SDC_RX_ENH_EN (0x1 << 20) /* RW */
#define AUTOK_TOP_SDC_RX_ENHANCE_EN (0x1 << 15) /* RW */
/**********************************************************
* Feature Control Defination *
**********************************************************/
#define AUTOK_EMMC_OFFLINE_TUNE_TX_ENABLE 0
#define AUTOK_SD_CARD_OFFLINE_TUNE_TX_ENABLE 0
#define AUTOK_SDIO_OFFLINE_TUNE_TX_ENABLE 1
#define AUTOK_OFFLINE_CMD_H_TX_ENABLE 0
#define AUTOK_OFFLINE_DAT_H_TX_ENABLE 1
#define AUTOK_OFFLINE_CMD_D_RX_ENABLE 0
#define AUTOK_OFFLINE_DAT_D_RX_ENABLE 1
#define AUTOK_OFFLINE_TUNE_DEVICE_RX_ENABLE 1
#define AUTOK_PARAM_DUMP_ENABLE 0
#define SINGLE_EDGE_ONLINE_TUNE 0
#define SDIO_PLUS_CMD_TUNE 1
#define STOP_CLK_NEW_PATH 0
#define DS_DLY3_SCAN 0
#define CHIP_DENALI_3_DAT_TUNE 0
#endif /* _AUTOK_CUST_H_ */
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,90 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _AUTOK_DVFS_H_
#define _AUTOK_DVFS_H_
#define VCOREFS_READY
#include "autok.h"
#ifdef VCOREFS_READY
#include <mtk_vcorefs_manager.h>
#include <mtk_spm_vcore_dvfs.h>
enum AUTOK_VCORE {
AUTOK_VCORE_LEVEL0 = 0,
AUTOK_VCORE_LEVEL1,
AUTOK_VCORE_LEVEL2,
AUTOK_VCORE_LEVEL3,
AUTOK_VCORE_MERGE,
AUTOK_VCORE_NUM = AUTOK_VCORE_MERGE
};
#else
enum dvfs_opp {
OPP_UNREQ = -1,
OPP_0 = 0,
OPP_1,
OPP_2,
OPP_3,
NUM_OPP,
};
/* define as any value is ok, just for build pass */
#define KIR_SDIO 1
#define KIR_AUTOK_EMMC 9
#define KIR_AUTOK_SDIO 10
#define KIR_AUTOK_SD 11
#define is_vcorefs_can_work() -1
#define vcorefs_request_dvfs_opp(a, b) 0
#define vcorefs_get_hw_opp() OPP_0
#define spm_msdc_dvfs_setting(a, b)
#define AUTOK_VCORE_LEVEL0 0
#define AUTOK_VCORE_LEVEL1 0
#define AUTOK_VCORE_LEVEL2 0
#define AUTOK_VCORE_LEVEL3 0
#define AUTOK_VCORE_MERGE 0
#define AUTOK_VCORE_NUM 1
#endif
#define MSDC_DVFS_TIMEOUT (HZ/10 * 5) /* 100ms x5 */
#define BACKUP_REG_COUNT_SDIO 14
#define BACKUP_REG_COUNT_EMMC_INTERNAL 5
#define BACKUP_REG_COUNT_EMMC_TOP 12
#define BACKUP_REG_COUNT_EMMC \
(BACKUP_REG_COUNT_EMMC_INTERNAL + BACKUP_REG_COUNT_EMMC_TOP)
#define MSDC_DVFS_SET_SIZE 0x48
#define MSDC_TOP_SET_SIZE 0x30
/* Enable later@Peter */
/* #define SDIO_HW_DVFS_CONDITIONAL */
/**********************************************************
* Function Declaration *
**********************************************************/
extern int sdio_autok_res_exist(struct msdc_host *host);
extern int sdio_autok_res_apply(struct msdc_host *host, int vcore);
extern int sdio_autok_res_save(struct msdc_host *host, int vcore, u8 *res);
extern void sdio_autok_wait_dvfs_ready(void);
extern int emmc_execute_dvfs_autok(struct msdc_host *host, u32 opcode);
extern int sd_execute_dvfs_autok(struct msdc_host *host, u32 opcode);
extern void sdio_execute_dvfs_autok(struct msdc_host *host);
extern int autok_res_check(u8 *res_h, u8 *res_l);
extern void msdc_dump_autok(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host);
extern void msdc_dvfs_reg_backup_init(struct msdc_host *host);
extern void msdc_dvfs_reg_restore(struct msdc_host *host);
extern void msdc_dump_autok(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host);
extern int msdc_vcorefs_get_hw_opp(struct msdc_host *host);
#endif /* _AUTOK_DVFS_H_ */
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,549 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MSDC_CUST_MT6739_H_
#define _MSDC_CUST_MT6739_H_
#include <dt-bindings/mmc/mt6739-msdc.h>
#include <dt-bindings/clock/mt6739-clk.h>
#include <mtk_spm_resource_req.h>
/**************************************************************/
/* Section 1: Device Tree */
/**************************************************************/
/* Names used for device tree lookup */
#define DT_COMPATIBLE_NAME "mediatek,msdc"
#define MSDC0_CLK_NAME "msdc0-clock"
#define MSDC0_HCLK_NAME "msdc0-hclock"
#define MSDC1_CLK_NAME "msdc1-clock"
#define MSDC1_HCLK_NAME "msdc1-hclock"
#define MSDC0_IOCFG_NAME "mediatek,io_cfg_lt"
#define MSDC1_IOCFG_NAME "mediatek,io_cfg_lb"
/**************************************************************/
/* Section 2: Power */
/**************************************************************/
#define POWER_READY
#ifdef POWER_READY
#if !defined(FPGA_PLATFORM)
#include <mt-plat/upmu_common.h>
#define REG_VEMC_VOSEL_CAL PMIC_RG_VEMC_VOCAL_ADDR
#define REG_VEMC_VOSEL PMIC_RG_VEMC_VOSEL_ADDR
#define REG_VEMC_EN PMIC_RG_LDO_VEMC_EN_ADDR /* TBC */
#define REG_VMC_VOSEL_CAL PMIC_RG_VMC_VOCAL_ADDR
#define REG_VMC_VOSEL PMIC_RG_VMC_VOSEL_ADDR
#define REG_VMC_EN PMIC_RG_LDO_VMC_EN_ADDR /* TBC */
#define REG_VMCH_VOSEL_CAL PMIC_RG_VMCH_VOCAL_ADDR
#define REG_VMCH_VOSEL PMIC_RG_VMCH_VOSEL_ADDR
#define REG_VMCH_EN PMIC_RG_LDO_VMCH_EN_ADDR /* TBC */
#define MASK_VEMC_VOSEL_CAL PMIC_RG_VEMC_VOCAL_MASK
#define SHIFT_VEMC_VOSEL_CAL PMIC_RG_VEMC_VOCAL_SHIFT
#define FIELD_VEMC_VOSEL_CAL (MASK_VEMC_VOSEL_CAL \
<< SHIFT_VEMC_VOSEL_CAL)
#define MASK_VEMC_VOSEL PMIC_RG_VEMC_VOSEL_MASK
#define SHIFT_VEMC_VOSEL PMIC_RG_VEMC_VOSEL_SHIFT
#define FIELD_VEMC_VOSEL (MASK_VEMC_VOSEL << SHIFT_VEMC_VOSEL)
#define MASK_VEMC_EN PMIC_RG_LDO_VEMC_EN_MASK
#define SHIFT_VEMC_EN PMIC_RG_LDO_VEMC_EN_SHIFT
#define FIELD_VEMC_EN (MASK_VEMC_EN << SHIFT_VEMC_EN)
#define MASK_VMC_VOSEL_CAL PMIC_RG_VMC_VOCAL_MASK
#define SHIFT_VMC_VOSEL_CAL PMIC_RG_VMC_VOCAL_SHIFT
#define FIELD_VMC_VOSEL_CAL (MASK_VMC_VOSEL_CAL \
<< SHIFT_VMC_VOSEL_CAL)
#define MASK_VMC_VOSEL PMIC_RG_VMC_VOSEL_MASK
#define SHIFT_VMC_VOSEL PMIC_RG_VMC_VOSEL_SHIFT
#define FIELD_VMC_VOSEL (MASK_VMC_VOSEL << SHIFT_VMC_VOSEL)
#define MASK_VMC_EN PMIC_RG_LDO_VMC_EN_MASK
#define SHIFT_VMC_EN PMIC_RG_LDO_VMC_EN_SHIFT
#define FIELD_VMC_EN (MASK_VMC_EN << SHIFT_VMC_EN)
#define MASK_VMCH_VOSEL_CAL PMIC_RG_VMCH_VOCAL_MASK
#define SHIFT_VMCH_VOSEL_CAL PMIC_RG_VMCH_VOCAL_SHIFT
#define FIELD_VMCH_VOSEL_CAL (MASK_VMCH_VOSEL_CAL \
<< SHIFT_VMCH_VOSEL_CAL)
#define MASK_VMCH_VOSEL PMIC_RG_VMCH_VOSEL_MASK
#define SHIFT_VMCH_VOSEL PMIC_RG_VMCH_VOSEL_SHIFT
#define FIELD_VMCH_VOSEL (MASK_VMCH_VOSEL << SHIFT_VMCH_VOSEL)
#define MASK_VMCH_EN PMIC_RG_LDO_VMCH_EN_MASK
#define SHIFT_VMCH_EN PMIC_RG_LDO_VMCH_EN_SHIFT
#define FIELD_VMCH_EN (MASK_VMCH_EN << SHIFT_VMCH_EN)
#define REG_VMCH_OC_RAW_STATUS PMIC_RG_INT_RAW_STATUS_VMCH_OC_ADDR
#define MASK_VMCH_OC_RAW_STATUS PMIC_RG_INT_RAW_STATUS_VMCH_OC_MASK
#define SHIFT_VMCH_OC_RAW_STATUS PMIC_RG_INT_RAW_STATUS_VMCH_OC_SHIFT
#define FIELD_VMCH_OC_RAW_STATUS (MASK_VMCH_OC_RAW_STATUS << SHIFT_VMCH_OC_RAW_STATUS)
#define REG_VMCH_OC_STATUS PMIC_RG_INT_STATUS_VMCH_OC_ADDR
#define MASK_VMCH_OC_STATUS PMIC_RG_INT_STATUS_VMCH_OC_MASK
#define SHIFT_VMCH_OC_STATUS PMIC_RG_INT_STATUS_VMCH_OC_SHIFT
#define FIELD_VMCH_OC_STATUS (MASK_VMCH_OC_STATUS << SHIFT_VMCH_OC_STATUS)
#define REG_VMCH_OC_EN PMIC_RG_INT_EN_VMCH_OC_ADDR
#define MASK_VMCH_OC_EN PMIC_RG_INT_EN_VMCH_OC_MASK
#define SHIFT_VMCH_OC_EN PMIC_RG_INT_EN_VMCH_OC_SHIFT
#define FIELD_VMCH_OC_EN (MASK_VMCH_OC_EN << SHIFT_VMCH_OC_EN)
#define REG_VMCH_OC_MASK PMIC_RG_INT_MASK_VMCH_OC_ADDR
#define MASK_VMCH_OC_MASK PMIC_RG_INT_MASK_VMCH_OC_MASK
#define SHIFT_VMCH_OC_MASK PMIC_RG_INT_MASK_VMCH_OC_SHIFT
#define FIELD_VMCH_OC_MASK (MASK_VMCH_OC_MASK << SHIFT_VMCH_OC_MASK)
#define VEMC_VOSEL_CAL_mV(cal) ((cal >= 0) ? ((cal)/10) : 0)
#define VEMC_VOSEL_2V9 (0x2)
#define VEMC_VOSEL_3V (0x3)
#define VEMC_VOSEL_3V3 (0x5)
#define VMC_VOSEL_CAL_mV(cal) ((cal >= 0) ? ((cal)/10) : 0)
#define VMC_VOSEL_1V8 (0x4)
#define VMC_VOSEL_2V9 (0xa)
#define VMC_VOSEL_3V (0xb)
#define VMC_VOSEL_3V3 (0xd)
#define VMCH_VOSEL_CAL_mV(cal) ((cal >= 0) ? ((cal)/10) : 0)
#define VMCH_VOSEL_2V9 (0x2)
#define VMCH_VOSEL_3V (0x3)
#define VMCH_VOSEL_3V3 (0x5)
#define REG_VCORE_VOSEL 0x1522
#define MASK_VCORE_VOSEL 0x7F
#define SHIFT_VCORE_VOSEL 0
#define VCORE_MIN_UV 518750
#define VCORE_STEP_UV 6250
#define REG_VIO18_VOCAL 0x1C4C
#define MASK_VIO18_VOCAL 0xF
#define SHIFT_VIO18_VOCAL 0
#define VIO18_VOCAL_mV(cal) ((cal >= 0) ? ((cal)/10) : 0)
#define VIO18_VOSEL_1V8 (0xc)
/* Note: 6357 does not support 1.7V VIO18 */
#endif
#endif /* POWER_READY */
#define SD_POWER_DEFAULT_ON (0)
#define EMMC_VOL_ACTUAL VOL_3000
#define SD_VOL_ACTUAL VOL_3000
#define SD1V8_VOL_ACTUAL VOL_1860
/**************************************************************/
/* Section 3: Clock */
/**************************************************************/
#if !defined(FPGA_PLATFORM)
/* MSDCPLL register offset */
#define MSDCPLL_CON0_OFFSET (0x250)
#define MSDCPLL_CON1_OFFSET (0x254)
#define MSDCPLL_CON2_OFFSET (0x258)
#define MSDCPLL_PWR_CON0_OFFSET (0x25c)
#endif
#define MSDCPLL_FREQ 400000000
#define MSDC0_SRC_0 260000
#define MSDC0_SRC_1 MSDCPLL_FREQ
#define MSDC0_SRC_2 182000000
#define MSDC0_SRC_3 78000000
#define MSDC0_SRC_4 312000000
#define MSDC0_SRC_5 273000000
#define MSDC0_SRC_6 249600000
#define MSDC0_SRC_7 156000000
#define MSDC1_SRC_0 260000
#define MSDC1_SRC_1 (MSDCPLL_FREQ/2)
#define MSDC1_SRC_2 208000000
#define MSDC1_SRC_3 182000000
#define MSDC1_SRC_4 136500000
#define MSDC1_SRC_5 156000000
#define MSDC1_SRC_6 48000000
#define MSDC1_SRC_7 91000000
#define MSDC_SRC_FPGA 12000000
/* FIX ME */
#define CLOCK_READY
#ifdef CLOCK_READY
#define MSDC0_CG_NAME MTK_CG_PERI2_RG_MSDC0_CK_PDN_AP_NORM_STA
#define MSDC1_CG_NAME MTK_CG_PERI2_RG_MSDC1_CK_PDN_STA
#endif
/**************************************************************/
/* Section 4: GPIO and Pad */
/**************************************************************/
/*--------------------------------------------------------------------------*/
/* MSDC0~1 GPIO and IO Pad Configuration Base */
/*--------------------------------------------------------------------------*/
#define MSDC_GPIO_BASE gpio_base /* 0x10005000 */
#define MSDC0_IO_CFG_BASE (msdc_io_cfg_bases[0]) /* 0x10002000 */
#define MSDC1_IO_CFG_BASE (msdc_io_cfg_bases[1]) /* 0x10002400 */
/*--------------------------------------------------------------------------*/
/* MSDC GPIO Related Register */
/*--------------------------------------------------------------------------*/
/* MSDC0 */
#define MSDC0_GPIO_MODE4 (MSDC_GPIO_BASE + 0x340)
#define MSDC0_GPIO_MODE5 (MSDC_GPIO_BASE + 0x350)
#define MSDC0_GPIO_MODE6 (MSDC_GPIO_BASE + 0x360)
#define MSDC0_GPIO_DRV0_ADDR (MSDC0_IO_CFG_BASE + 0x0)
#define MSDC0_GPIO_DRV1_ADDR (MSDC0_IO_CFG_BASE + 0x10)
#define MSDC0_GPIO_IES_ADDR (MSDC0_IO_CFG_BASE + 0x30)
#define MSDC0_GPIO_PUPD_ADDR (MSDC0_IO_CFG_BASE + 0x40)
#define MSDC0_GPIO_R0_ADDR (MSDC0_IO_CFG_BASE + 0x50)
#define MSDC0_GPIO_R1_ADDR (MSDC0_IO_CFG_BASE + 0x60)
#define MSDC0_GPIO_RDSEL0_ADDR (MSDC0_IO_CFG_BASE + 0x70)
#define MSDC0_GPIO_RDSEL1_ADDR (MSDC0_IO_CFG_BASE + 0x80)
#define MSDC0_GPIO_SMT_ADDR (MSDC0_IO_CFG_BASE + 0x90)
#define MSDC0_GPIO_SR_ADDR (MSDC1_IO_CFG_BASE + 0xA0)
#define MSDC0_GPIO_TDSEL_ADDR (MSDC0_IO_CFG_BASE + 0xB0)
/* MSDC1 */
#define MSDC1_GPIO_MODE8 (MSDC_GPIO_BASE + 0x380)
#define MSDC1_GPIO_MODE9 (MSDC_GPIO_BASE + 0x390)
#define MSDC1_GPIO_DRV_ADDR (MSDC1_IO_CFG_BASE + 0x0)
#define MSDC1_GPIO_IES_ADDR (MSDC1_IO_CFG_BASE + 0x20)
#define MSDC1_GPIO_PUPD_ADDR (MSDC1_IO_CFG_BASE + 0x30)
#define MSDC1_GPIO_R0_ADDR (MSDC1_IO_CFG_BASE + 0x50)
#define MSDC1_GPIO_R1_ADDR (MSDC1_IO_CFG_BASE + 0x60)
#define MSDC1_GPIO_RDSEL_ADDR (MSDC1_IO_CFG_BASE + 0x70)
#define MSDC1_GPIO_SMT_ADDR (MSDC1_IO_CFG_BASE + 0x90)
#define MSDC1_GPIO_SR_ADDR (MSDC1_IO_CFG_BASE + 0xA0)
#define MSDC1_GPIO_TDSEL_ADDR (MSDC1_IO_CFG_BASE + 0xB0)
/*
* MSDC0 GPIO and PAD register and bitfields definition
*/
/* MSDC0_GPIO_MODE4, 001b is msdc mode */
#define MSDC0_MODE_CMD_MASK (0x7 << 24)
#define MSDC0_MODE_DSL_MASK (0x7 << 28)
/* MSDC0_GPIO_MODE5, 001b is msdc mode*/
#define MSDC0_MODE_CLK_MASK (0x7 << 0)
#define MSDC0_MODE_DAT0_MASK (0x7 << 4)
#define MSDC0_MODE_DAT1_MASK (0x7 << 8)
#define MSDC0_MODE_DAT2_MASK (0x7 << 12)
#define MSDC0_MODE_DAT3_MASK (0x7 << 16)
#define MSDC0_MODE_DAT4_MASK (0x7 << 20)
#define MSDC0_MODE_DAT5_MASK (0x7 << 24)
#define MSDC0_MODE_DAT6_MASK (0x7 << 28)
/* MSDC0_GPIO_MODE6, 001b is msdc mode */
#define MSDC0_MODE_DAT7_MASK (0x7 << 0)
#define MSDC0_MODE_RSTB_MASK (0x7 << 4)
/* MSDC0 IES mask*/
#define MSDC0_IES_CLK_MASK (0x1 << 6)
#define MSDC0_IES_CMD_MASK (0x1 << 7)
#define MSDC0_IES_DAT_MASK (0xff << 8)
#define MSDC0_IES_DAT0_MASK (0x1 << 8)
#define MSDC0_IES_DAT1_MASK (0x1 << 9)
#define MSDC0_IES_DAT2_MASK (0x1 << 10)
#define MSDC0_IES_DAT3_MASK (0x1 << 11)
#define MSDC0_IES_DAT4_MASK (0x1 << 12)
#define MSDC0_IES_DAT5_MASK (0x1 << 13)
#define MSDC0_IES_DAT6_MASK (0x1 << 14)
#define MSDC0_IES_DAT7_MASK (0x1 << 15)
#define MSDC0_IES_DSL_MASK (0x1 << 16)
#define MSDC0_IES_RSTB_MASK (0x1 << 17)
#define MSDC0_IES_ALL_MASK (0xfff << 6)
/* MSDC0 SMT mask*/
#define MSDC0_SMT_CLK_MASK (0x1 << 1)
#define MSDC0_SMT_CMD_MASK (0x1 << 2)
#define MSDC0_SMT_DAT_MASK (0x1 << 3)
#define MSDC0_SMT_DSL_MASK (0x1 << 4)
#define MSDC0_SMT_RSTB_MASK (0x1 << 5)
#define MSDC0_SMT_ALL_MASK (0x1f << 1)
/* MSDC0 TDSEL mask*/
#define MSDC0_TDSEL_CLK_MASK (0xf << 4)
#define MSDC0_TDSEL_CMD_MASK (0xf << 8)
#define MSDC0_TDSEL_DAT_MASK (0xf << 12)
#define MSDC0_TDSEL_DSL_MASK (0xf << 16)
#define MSDC0_TDSEL_RSTB_MASK (0xf << 20)
#define MSDC0_TDSEL_ALL_MASK (0xfffff << 4)
/* MSDC0 RDSEL mask*/
#define MSDC0_RDSEL_CLK_MASK (0x3f << 6)
#define MSDC0_RDSEL_CMD_MASK (0x3f << 12)
#define MSDC0_RDSEL_DAT_MASK (0x3f << 18)
#define MSDC0_RDSEL_DSL_MASK (0x3f << 24)
#define MSDC0_RDSEL0_ALL_MASK (0xffffff << 6)
#define MSDC0_RDSEL_RSTB_MASK (0x3f << 0)
#define MSDC0_RDSEL1_ALL_MASK (0x3f << 0)
/* MSDC0 SR mask*/
#define MSDC0_SR_CLK_MASK (0x1 << 6)
#define MSDC0_SR_CMD_MASK (0x1 << 7)
#define MSDC0_SR_DAT_MASK (0xff << 8)
#define MSDC0_SR_DAT0_MASK (0x1 << 8)
#define MSDC0_SR_DAT1_MASK (0x1 << 9)
#define MSDC0_SR_DAT2_MASK (0x1 << 10)
#define MSDC0_SR_DAT3_MASK (0x1 << 11)
#define MSDC0_SR_DAT4_MASK (0x1 << 12)
#define MSDC0_SR_DAT5_MASK (0x1 << 13)
#define MSDC0_SR_DAT6_MASK (0x1 << 14)
#define MSDC0_SR_DAT7_MASK (0x1 << 15)
#define MSDC0_SR_DSL_MASK (0x1 << 16)
#define MSDC0_SR_RSTB_MASK (0x1 << 17)
#define MSDC0_SR_ALL_MASK (0xfff << 6)
/* MSDC0 DRV mask*/
#define MSDC0_DRV_CMD_MASK (0x7 << 18)
#define MSDC0_DRV_CLK_MASK (0x7 << 21)
#define MSDC0_DRV_DAT0_MASK (0x7 << 24)
#define MSDC0_DRV_DAT1_MASK (0x7 << 27)
#define MSDC0_DRV0_ALL_MASK (0xfff << 18)
#define MSDC0_DRV_DAT2_MASK (0x7 << 0)
#define MSDC0_DRV_DAT3_MASK (0x7 << 3)
#define MSDC0_DRV_DAT4_MASK (0x7 << 6)
#define MSDC0_DRV_DAT5_MASK (0x7 << 9)
#define MSDC0_DRV_DAT6_MASK (0x7 << 12)
#define MSDC0_DRV_DAT7_MASK (0x7 << 15)
#define MSDC0_DRV_DSL_MASK (0x7 << 18)
#define MSDC0_DRV_RSTB_MASK (0x7 << 21)
#define MSDC0_DRV1_ALL_MASK (0xffffff << 0)
/* MSDC0 PUPD mask */
#define MSDC0_PUPD_CLK_MASK (0x1 << 6)
#define MSDC0_PUPD_CMD_MASK (0x1 << 7)
#define MSDC0_PUPD_DAT_MASK (0xff << 8)
#define MSDC0_PUPD_DAT0_MASK (0x1 << 8)
#define MSDC0_PUPD_DAT1_MASK (0x1 << 9)
#define MSDC0_PUPD_DAT2_MASK (0x1 << 10)
#define MSDC0_PUPD_DAT3_MASK (0x1 << 11)
#define MSDC0_PUPD_DAT4_MASK (0x1 << 12)
#define MSDC0_PUPD_DAT5_MASK (0x1 << 13)
#define MSDC0_PUPD_DAT6_MASK (0x1 << 14)
#define MSDC0_PUPD_DAT7_MASK (0x1 << 15)
#define MSDC0_PUPD_DSL_MASK (0x7 << 16)
#define MSDC0_PUPD_RSTB_MASK (0x7 << 17)
#define MSDC0_PUPD_MASK_WITH_RSTB (0xFFF << 6)
#define MSDC0_PUPD_ALL_MASK (0x7FF << 6)
/* MSDC0 R0 mask */
#define MSDC0_R0_CLK_MASK (0x1 << 6)
#define MSDC0_R0_CMD_MASK (0x1 << 7)
#define MSDC0_R0_DAT_MASK (0xff << 8)
#define MSDC0_R0_DAT0_MASK (0x1 << 8)
#define MSDC0_R0_DAT1_MASK (0x1 << 9)
#define MSDC0_R0_DAT2_MASK (0x1 << 10)
#define MSDC0_R0_DAT3_MASK (0x1 << 11)
#define MSDC0_R0_DAT4_MASK (0x1 << 12)
#define MSDC0_R0_DAT5_MASK (0x1 << 13)
#define MSDC0_R0_DAT6_MASK (0x1 << 14)
#define MSDC0_R0_DAT7_MASK (0x1 << 15)
#define MSDC0_R0_DSL_MASK (0x7 << 16)
#define MSDC0_R0_RSTB_MASK (0x7 << 17)
#define MSDC0_R0_MASK_WITH_RSTB (0xFFF << 6)
#define MSDC0_R0_ALL_MASK (0x7FF << 6)
/* MSDC0 R1 mask */
#define MSDC0_R1_CLK_MASK (0x1 << 6)
#define MSDC0_R1_CMD_MASK (0x1 << 7)
#define MSDC0_R1_DAT_MASK (0xff << 8)
#define MSDC0_R1_DAT0_MASK (0x1 << 8)
#define MSDC0_R1_DAT1_MASK (0x1 << 9)
#define MSDC0_R1_DAT2_MASK (0x1 << 10)
#define MSDC0_R1_DAT3_MASK (0x1 << 11)
#define MSDC0_R1_DAT4_MASK (0x1 << 12)
#define MSDC0_R1_DAT5_MASK (0x1 << 13)
#define MSDC0_R1_DAT6_MASK (0x1 << 14)
#define MSDC0_R1_DAT7_MASK (0x1 << 15)
#define MSDC0_R1_DSL_MASK (0x7 << 16)
#define MSDC0_R1_RSTB_MASK (0x7 << 17)
#define MSDC0_R1_MASK_WITH_RSTB (0xFFF << 6)
#define MSDC0_R1_ALL_MASK (0x7FF << 6)
/*
* MSDC1 GPIO and PAD register and bitfields definition
*/
/* MSDC1_GPIO_MODE8, 0001b is msdc mode */
#define MSDC1_MODE_CMD_MASK (0x7 << 28)
/* MSDC1_GPIO_MODE9, 0001b is msdc mode */
#define MSDC1_MODE_CLK_MASK (0x7 << 0)
#define MSDC1_MODE_DAT0_MASK (0x7 << 4)
#define MSDC1_MODE_DAT1_MASK (0x7 << 8)
#define MSDC1_MODE_DAT2_MASK (0x7 << 12)
#define MSDC1_MODE_DAT3_MASK (0x7 << 16)
/* MSDC1 IES mask*/
#define MSDC1_IES_CLK_MASK (0x1 << 2)
#define MSDC1_IES_CMD_MASK (0x1 << 3)
#define MSDC1_IES_DAT_MASK (0xf << 4)
#define MSDC1_IES_DAT0_MASK (0x1 << 4)
#define MSDC1_IES_DAT1_MASK (0x1 << 5)
#define MSDC1_IES_DAT2_MASK (0x1 << 6)
#define MSDC1_IES_DAT3_MASK (0x1 << 7)
#define MSDC1_IES_ALL_MASK (0x3f << 2)
/* MSDC1 SMT mask*/
#define MSDC1_SMT_CLK_MASK (0x1 << 1)
#define MSDC1_SMT_CMD_MASK (0x1 << 2)
#define MSDC1_SMT_DAT_MASK (0x1 << 3)
#define MSDC1_SMT_ALL_MASK (0x7 << 1)
/* MSDC1 TDSEL mask*/
#define MSDC1_TDSEL_DAT_MASK (0xf << 4)
#define MSDC1_TDSEL_CMD_MASK (0xf << 8)
#define MSDC1_TDSEL_CLK_MASK (0xf << 12)
#define MSDC1_TDSEL_ALL_MASK (0xfff << 4)
/* MSDC1 RDSEL mask*/
#define MSDC1_RDSEL_CLK_MASK (0x3f << 6)
#define MSDC1_RDSEL_CMD_MASK (0x3f << 12)
#define MSDC1_RDSEL_DAT_MASK (0x3f << 18)
#define MSDC1_RDSEL_ALL_MASK (0x3ffff << 6)
/* MSDC1 SR mask*/
#define MSDC1_SR_CLK_MASK (0x1 << 2)
#define MSDC1_SR_CMD_MASK (0x1 << 3)
#define MSDC1_SR_DAT_MASK (0x1 << 4)
#define MSDC1_SR_DAT0_MASK (0x1 << 4)
#define MSDC1_SR_DAT1_MASK (0x1 << 5)
#define MSDC1_SR_DAT2_MASK (0x1 << 6)
#define MSDC1_SR_DAT3_MASK (0x1 << 7)
#define MSDC1_SR_ALL_MASK (0x3f << 2)
/* MSDC1 DRV mask*/
#define MSDC1_DRV_CLK_MASK (0x7 << 3)
#define MSDC1_DRV_CMD_MASK (0x7 << 6)
#define MSDC1_DRV_DAT_MASK (0x7 << 9)
#define MSDC1_DRV_ALL_MASK (0x1ff << 3)
/* MSDC1 PUPD mask */
#define MSDC1_PUPD_CLK_MASK (0x7 << 2)
#define MSDC1_PUPD_CMD_MASK (0x7 << 3)
#define MSDC1_PUPD_DAT0_MASK (0x7 << 4)
#define MSDC1_PUPD_DAT1_MASK (0x7 << 5)
#define MSDC1_PUPD_DAT2_MASK (0x7 << 6)
#define MSDC1_PUPD_DAT3_MASK (0x7 << 7)
#define MSDC1_PUPD_ALL_MASK (0x3F << 2)
/* MSDC1 R0 mask */
#define MSDC1_R0_CLK_MASK (0x7 << 2)
#define MSDC1_R0_CMD_MASK (0x7 << 3)
#define MSDC1_R0_DAT0_MASK (0x7 << 4)
#define MSDC1_R0_DAT1_MASK (0x7 << 5)
#define MSDC1_R0_DAT2_MASK (0x7 << 6)
#define MSDC1_R0_DAT3_MASK (0x7 << 7)
#define MSDC1_R0_ALL_MASK (0x3F << 2)
/* MSDC1 R1 mask */
#define MSDC1_R1_CLK_MASK (0x7 << 2)
#define MSDC1_R1_CMD_MASK (0x7 << 3)
#define MSDC1_R1_DAT0_MASK (0x7 << 4)
#define MSDC1_R1_DAT1_MASK (0x7 << 5)
#define MSDC1_R1_DAT2_MASK (0x7 << 6)
#define MSDC1_R1_DAT3_MASK (0x7 << 7)
#define MSDC1_R1_ALL_MASK (0x3F << 2)
/* FOR msdc_io_check() */
#define MSDC1_PUPD_DAT0_ADDR (MSDC1_GPIO_PUPD_ADDR)
#define MSDC1_PUPD_DAT1_ADDR (MSDC1_GPIO_PUPD_ADDR)
#define MSDC1_PUPD_DAT2_ADDR (MSDC1_GPIO_PUPD_ADDR)
/**************************************************************/
/* Section 5: Adjustable Driver Parameter */
/**************************************************************/
#define HOST_MAX_BLKSZ (2048)
#define MSDC_OCR_AVAIL (MMC_VDD_28_29 | MMC_VDD_29_30 | MMC_VDD_30_31 | MMC_VDD_31_32 | MMC_VDD_32_33)
/* data timeout counter. 1048576 * 3 sclk. */
#define DEFAULT_DTOC (3)
#define MAX_DMA_CNT (4 * 1024 * 1024)
/* a WIFI transaction may be 50K */
#define MAX_DMA_CNT_SDIO (0xFFFFFFFF - 255)
/* a LTE transaction may be 128K */
#define MAX_HW_SGMTS (MAX_BD_NUM)
#define MAX_PHY_SGMTS (MAX_BD_NUM)
#define MAX_SGMT_SZ (MAX_DMA_CNT)
#define MAX_SGMT_SZ_SDIO (MAX_DMA_CNT_SDIO)
#define HOST_MAX_NUM (2)
#ifdef CONFIG_PWR_LOSS_MTK_TEST
#define MAX_REQ_SZ (512 * 65536)
#else
#define MAX_REQ_SZ (512 * 1024)
#endif
#ifdef FPGA_PLATFORM
#define HOST_MAX_MCLK (200000000)
#else
#define HOST_MAX_MCLK (200000000)
#endif
#define HOST_MIN_MCLK (260000)
/* SD card, bad card handling settings */
/* if continuous data timeout reach the limit */
/* driver will force remove card */
#define MSDC_MAX_DATA_TIMEOUT_CONTINUOUS (100)
/* if continuous power cycle fail reach the limit */
/* driver will force remove card */
#define MSDC_MAX_POWER_CYCLE_FAIL_CONTINUOUS (3)
/* sdcard esd recovery */
/* power reset sdcard when sdcard hang from esd */
#define SDCARD_ESD_RECOVERY
/* #define MSDC_HQA */
/* #define SDIO_HQA */
/**************************************************************/
/* Section 6: BBChip-depenent Tunnig Parameter */
/**************************************************************/
#define EMMC_MAX_FREQ_DIV 4 /* lower frequence to 12.5M */
#define MSDC_CLKTXDLY 0
#define MSDC0_DDR50_DDRCKD 1 /* FIX ME: may be removed */
#define VOL_CHG_CNT_DEFAULT_VAL 0x1F4 /* =500 */
#define MSDC_PB0_DEFAULT_VAL 0x403C0007
#define MSDC_PB1_DEFAULT_VAL 0xFFE60349
#define MSDC_PB2_DEFAULT_RESPWAITCNT 0x3
#define MSDC_PB2_DEFAULT_RESPSTENSEL 0x1
#define MSDC_PB2_DEFAULT_CRCSTSENSEL 0x1
#if defined(FPGA_PLATFORM)
#undef MSDC_PB2_DEFAULT_CRCSTSENSEL
#define MSDC_PB2_DEFAULT_CRCSTSENSEL 0
#endif
#define EMMC50_CFG_END_BIT_CHK_CNT 0x3
/**************************************************************/
/* Section 7: SDIO host */
/**************************************************************/
#ifdef CONFIG_MTK_COMBO_COMM
#include <mt-plat/mtk_wcn_cmb_stub.h>
#define CFG_DEV_SDIO 3
#endif
/**************************************************************/
/* Section 8: ECO Variation */
/**************************************************************/
#if !defined(FPGA_PLATFORM)
#include <mt-plat/mtk_chip.h>
#else
#define mt_get_chip_hw_ver() 0
/* #define CHIP_SW_VER_01 0 */
#endif
/* FIXME: check if the following lines are used on MT6739 */
#define ENABLE_HW_DVFS_WITH_CLK_OFF() \
MSDC_SET_BIT32(MSDC_CFG, MSDC_CFG_DVFS_IDLE)
#define DISABLE_HW_DVFS_WITH_CLK_OFF() \
MSDC_CLR_BIT32(MSDC_CFG, MSDC_CFG_DVFS_IDLE)
#define ENABLE_SDC_RX_ENH() \
MSDC_SET_BIT32(SDC_ADV_CFG0, SDC_ADV_CFG0_SDC_RX_ENH_EN)
#define DISABLE_SDC_RX_ENH() \
MSDC_CLR_BIT32(SDC_ADV_CFG0, SDC_ADV_CFG0_SDC_RX_ENH_EN)
#define SET_EMMC50_CFG_END_BIT_CHK_CNT(CNT) \
MSDC_SET_FIELD(EMMC50_CFG0, MSDC_EMMC50_CFG_END_BIT_CHK_CNT, CNT)
#endif /* _MSDC_CUST_MT6739_H_ */
@@ -0,0 +1,181 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MSDC_IO_H_
#define _MSDC_IO_H_
/**************************************************************/
/* Section 1: Device Tree */
/**************************************************************/
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
extern const struct of_device_id msdc_of_ids[];
extern unsigned int cd_gpio;
int msdc_dt_init(struct platform_device *pdev, struct mmc_host *mmc);
/**************************************************************/
/* Section 2: Power */
/**************************************************************/
int msdc_sd_power_switch(struct msdc_host *host, u32 on);
void msdc_set_host_power_control(struct msdc_host *host);
#if !defined(FPGA_PLATFORM)
void msdc_pmic_force_vcore_pwm(bool enable);
int msdc_oc_check(struct msdc_host *host, u32 en);
int msdc_io_check(struct msdc_host *host);
void msdc_sd_power_off(void);
void msdc_dump_ldo_sts(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host);
void msdc_HQA_set_voltage(struct msdc_host *host);
#else
#define msdc_power_calibration_init(host)
#define msdc_pmic_force_vcore_pwm(enable)
void msdc_fpga_pwr_init(void);
#define msdc_oc_check(msdc_host, en) (0)
#define msdc_io_check(msdc_host) (1)
extern void msdc_fpga_power(struct msdc_host *host, u32 on);
#define msdc_emmc_power msdc_fpga_power
#define msdc_sd_power msdc_fpga_power
#define msdc_sdio_power msdc_fpga_power
#define msdc_sd_power_off()
#define msdc_dump_ldo_sts(buff, size, m, host)
#endif
/**************************************************************/
/* Section 3: Clock */
/**************************************************************/
#include <linux/clk.h>
#if defined(FPGA_PLATFORM)
extern u32 hclks_msdc[];
#define msdc_dump_dvfs_reg(buff, size, m, host)
#define msdc_dump_clock_sts(buff, size, m, host)
#define msdc_get_hclk(host, src) MSDC_SRC_FPGA
static inline int msdc_clk_enable(struct msdc_host *host) { return 0; }
#define msdc_clk_disable(host)
#define msdc_get_ccf_clk_pointer(pdev, host) (0)
#define msdc_clk_enable_and_stable(host)
#endif
#if !defined(FPGA_PLATFORM)
extern u32 *hclks_msdc_all[];
extern void msdc_dump_dvfs_reg(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host);
void msdc_dump_clock_sts(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host);
#define msdc_get_hclk(id, src) hclks_msdc_all[id][src]
int msdc_get_ccf_clk_pointer(struct platform_device *pdev,
struct msdc_host *host);
void msdc_clk_enable_and_stable(struct msdc_host *host);
#define msdc_clk_enable(host) \
do { \
(void)clk_enable(host->clk_ctl); \
if (host->hclk_ctl) \
(void)clk_enable(host->hclk_ctl); \
} while (0)
#define msdc_clk_disable(host) \
do { \
clk_disable(host->clk_ctl); \
if (host->hclk_ctl) \
clk_disable(host->hclk_ctl); \
} while (0)
#endif
#define msdc_clk_prepare_enable(host) msdc_clk_enable(host)
#define msdc_clk_disable_unprepare(host) msdc_clk_disable(host)
/**************************************************************/
/* Section 4: GPIO and Pad */
/**************************************************************/
/*******************************************************************************
*PINMUX and GPIO definition
******************************************************************************/
#define MSDC_PIN_PULL_NONE (0)
#define MSDC_PIN_PULL_DOWN (1)
#define MSDC_PIN_PULL_UP (2)
#define MSDC_PIN_KEEP (3)
#define MSDC_TDRDSEL_SLEEP (0)
#define MSDC_TDRDSEL_3V (1)
#define MSDC_TDRDSEL_1V8 (2)
#define MSDC_TDRDSEL_CUST (3)
#ifndef FPGA_PLATFORM
void msdc_set_driving_by_id(u32 id, struct msdc_hw_driving *driving);
void msdc_get_driving_by_id(u32 id, struct msdc_hw_driving *driving);
void msdc_set_ies_by_id(u32 id, int set_ies);
void msdc_set_sr_by_id(u32 id, int clk, int cmd, int dat, int rst, int ds);
void msdc_set_smt_by_id(u32 id, int set_smt);
void msdc_set_tdsel_by_id(u32 id, u32 flag, u32 value);
void msdc_set_rdsel_by_id(u32 id, u32 flag, u32 value);
void msdc_get_tdsel_by_id(u32 id, u32 *value);
void msdc_get_rdsel_by_id(u32 id, u32 *value);
void msdc_dump_vcore(char **buff, unsigned long *size, struct seq_file *m);
void msdc_dump_padctl_by_id(char **buff, unsigned long *size,
struct seq_file *m, u32 id);
void msdc_pin_config_by_id(u32 id, u32 mode);
void msdc_set_pin_mode(struct msdc_host *host);
#else
#define msdc_set_driving_by_id(id, driving)
#define msdc_get_driving_by_id(id, driving)
#define msdc_set_ies_by_id(id, set_ies)
#define msdc_set_sr_by_id(id, clk, cmd, dat, rst, ds)
#define msdc_set_smt_by_id(id, set_smt)
#define msdc_set_tdsel_by_id(id, flag, value)
#define msdc_set_rdsel_by_id(id, flag, value)
#define msdc_get_tdsel_by_id(id, value)
#define msdc_get_rdsel_by_id(id, value)
#define msdc_dump_vcore(buff, size, m)
#define msdc_dump_padctl_by_id(buff, size, m, id)
#define msdc_pin_config_by_id(id, mode)
#define msdc_set_pin_mode(host)
#endif
#define msdc_get_driving(host, driving) \
msdc_get_driving_by_id(host->id, driving)
#define msdc_set_driving(host, driving) \
msdc_set_driving_by_id(host->id, driving)
#define msdc_set_ies(host, set_ies) \
msdc_set_ies_by_id(host->id, set_ies)
#define msdc_set_sr(host, clk, cmd, dat, rst, ds) \
msdc_set_sr_by_id(host->id, clk, cmd, dat, rst, ds)
#define msdc_set_smt(host, set_smt) \
msdc_set_smt_by_id(host->id, set_smt)
#define msdc_set_tdsel(host, flag, value) \
msdc_set_tdsel_by_id(host->id, flag, value)
#define msdc_set_rdsel(host, flag, value) \
msdc_set_rdsel_by_id(host->id, flag, value)
#define msdc_get_tdsel(host, value) \
msdc_get_tdsel_by_id(host->id, value)
#define msdc_get_rdsel(host, value) \
msdc_get_rdsel_by_id(host->id, value)
#define msdc_dump_padctl(buff, size, m, host) \
msdc_dump_padctl_by_id(buff, size, m, host->id)
#define msdc_pin_config(host, mode) \
msdc_pin_config_by_id(host->id, mode)
#endif /* end of _MSDC_IO_H_ */
@@ -0,0 +1,323 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _AUTOK_CUST_H_
#define _AUTOK_CUST_H_
#define AUTOK_VERSION (0x17122120)
#if defined(CONFIG_MACH_MT6761)
#define MSDC1_CLKTX 4
#define CHK_CNT_HS400 6
#define SWITCH_CNT_HS400 4
#else
#define MSDC1_CLKTX 0
#define CHK_CNT_HS400 3
#define SWITCH_CNT_HS400 5
#endif
struct AUTOK_PLAT_PARA_TX {
/* chip_hw_ver: in case E2's tune values
* are different, no use if no E2
*/
unsigned int chip_hw_ver;
u8 msdc0_hs400_clktx;
u8 msdc0_hs400_cmdtx;
u8 msdc0_hs400_dat0tx;
u8 msdc0_hs400_dat1tx;
u8 msdc0_hs400_dat2tx;
u8 msdc0_hs400_dat3tx;
u8 msdc0_hs400_dat4tx;
u8 msdc0_hs400_dat5tx;
u8 msdc0_hs400_dat6tx;
u8 msdc0_hs400_dat7tx;
u8 msdc0_hs400_txskew;
u8 msdc0_ddr_ckd;
u8 msdc1_ddr_ckd;
u8 msdc2_ddr_ckd;
u8 msdc0_clktx;
u8 msdc0_cmdtx;
u8 msdc0_dat0tx;
u8 msdc0_dat1tx;
u8 msdc0_dat2tx;
u8 msdc0_dat3tx;
u8 msdc0_dat4tx;
u8 msdc0_dat5tx;
u8 msdc0_dat6tx;
u8 msdc0_dat7tx;
u8 msdc0_txskew;
u8 msdc1_clktx;
u8 msdc1_sdr104_clktx;
u8 msdc2_clktx;
u8 sdio30_plus_clktx;
u8 sdio30_plus_cmdtx;
u8 sdio30_plus_dat0tx;
u8 sdio30_plus_dat1tx;
u8 sdio30_plus_dat2tx;
u8 sdio30_plus_dat3tx;
u8 msdc0_duty_bypass;
u8 msdc0_hl_duty_sel;
u8 msdc1_duty_bypass;
u8 msdc1_hl_duty_sel;
u8 msdc2_duty_bypass;
u8 msdc2_hl_duty_sel;
};
struct AUTOK_PLAT_PARA_RX {
unsigned int chip_hw_ver;
u8 ckgen_val;
u8 latch_en_cmd_hs400;
u8 latch_en_crc_hs400;
u8 latch_en_cmd_hs200;
u8 latch_en_crc_hs200;
u8 latch_en_cmd_ddr208;
u8 latch_en_crc_ddr208;
u8 latch_en_cmd_sd_sdr104;
u8 latch_en_crc_sd_sdr104;
u8 latch_en_cmd_sdio_sdr104;
u8 latch_en_crc_sdio_sdr104;
u8 latch_en_cmd_hs;
u8 latch_en_crc_hs;
u8 cmd_ta_val;
u8 crc_ta_val;
u8 busy_ma_val;
u8 new_water_hs400;
u8 new_water_hs200;
u8 new_water_ddr208;
u8 new_water_sdr104;
u8 new_water_hs;
u8 new_stop_hs400;
u8 new_stop_hs200;
u8 new_stop_ddr208;
u8 new_stop_sdr104;
u8 new_stop_hs;
u8 old_water_hs400;
u8 old_water_hs200;
u8 old_water_ddr208;
u8 old_water_sdr104;
u8 old_water_hs;
u8 old_stop_hs400;
u8 old_stop_hs200;
u8 old_stop_ddr208;
u8 old_stop_sdr104;
u8 old_stop_hs;
u8 read_dat_cnt_hs400;
u8 read_dat_cnt_ddr208;
u8 end_bit_chk_cnt_hs400;
u8 end_bit_chk_cnt_ddr208;
u8 latchck_switch_cnt_hs400;
u8 latchck_switch_cnt_ddr208;
u8 ds_dly3_hs400;
u8 ds_dly3_ddr208;
};
struct AUTOK_PLAT_PARA_MISC {
unsigned int chip_hw_ver;
u8 latch_ck_emmc_times;
u8 latch_ck_sdio_times;
u8 latch_ck_sd_times;
u8 emmc_data_tx_tune;
u8 data_tx_separate_tune;
};
struct AUTOK_PLAT_TOP_CTRL {
u8 msdc0_rx_enhance_top;
u8 msdc1_rx_enhance_top;
u8 msdc2_rx_enhance_top;
};
struct AUTOK_PLAT_FUNC {
unsigned int chip_hw_ver;
u8 new_path_hs400;
u8 new_path_hs200;
u8 new_path_ddr208;
u8 new_path_sdr104;
u8 new_path_hs;
u8 multi_sync;
u8 rx_enhance;
u8 r1b_check;
u8 ddr50_fix;
u8 fifo_1k;
u8 latch_enhance;
u8 msdc0_bypass_duty_modify;
u8 msdc1_bypass_duty_modify;
u8 msdc2_bypass_duty_modify;
};
#define get_platform_para_tx(autok_para_tx) \
do { \
autok_para_tx.msdc0_hs400_clktx = 0; \
autok_para_tx.msdc0_hs400_cmdtx = 0; \
autok_para_tx.msdc0_hs400_dat0tx = 0; \
autok_para_tx.msdc0_hs400_dat1tx = 0; \
autok_para_tx.msdc0_hs400_dat2tx = 0; \
autok_para_tx.msdc0_hs400_dat3tx = 0; \
autok_para_tx.msdc0_hs400_dat4tx = 0; \
autok_para_tx.msdc0_hs400_dat5tx = 0; \
autok_para_tx.msdc0_hs400_dat6tx = 0; \
autok_para_tx.msdc0_hs400_dat7tx = 0; \
autok_para_tx.msdc0_hs400_txskew = 0; \
autok_para_tx.msdc0_ddr_ckd = 1; \
autok_para_tx.msdc1_ddr_ckd = 0; \
autok_para_tx.msdc2_ddr_ckd = 1; \
autok_para_tx.msdc0_clktx = 0; \
autok_para_tx.msdc0_cmdtx = 0; \
autok_para_tx.msdc0_dat0tx = 0; \
autok_para_tx.msdc0_dat1tx = 0; \
autok_para_tx.msdc0_dat2tx = 0; \
autok_para_tx.msdc0_dat3tx = 0; \
autok_para_tx.msdc0_dat4tx = 0; \
autok_para_tx.msdc0_dat5tx = 0; \
autok_para_tx.msdc0_dat6tx = 0; \
autok_para_tx.msdc0_dat7tx = 0; \
autok_para_tx.msdc0_txskew = 0; \
autok_para_tx.msdc1_clktx = MSDC1_CLKTX; \
autok_para_tx.msdc1_sdr104_clktx = MSDC1_CLKTX; \
autok_para_tx.msdc2_clktx = 0; \
autok_para_tx.sdio30_plus_clktx = 0; \
autok_para_tx.sdio30_plus_cmdtx = 0; \
autok_para_tx.sdio30_plus_dat0tx = 0; \
autok_para_tx.sdio30_plus_dat1tx = 0; \
autok_para_tx.sdio30_plus_dat2tx = 0; \
autok_para_tx.sdio30_plus_dat3tx = 0; \
autok_para_tx.msdc0_duty_bypass = 0; \
autok_para_tx.msdc0_hl_duty_sel = 0; \
autok_para_tx.msdc1_duty_bypass = 0; \
autok_para_tx.msdc1_hl_duty_sel = 0; \
autok_para_tx.msdc2_duty_bypass = 0; \
autok_para_tx.msdc2_hl_duty_sel = 0; \
} while (0)
#define get_platform_para_rx(autok_para_rx) \
do { \
autok_para_rx.ckgen_val = 0; \
autok_para_rx.latch_en_cmd_hs400 = 2; \
autok_para_rx.latch_en_crc_hs400 = 2; \
autok_para_rx.latch_en_cmd_hs200 = 1; \
autok_para_rx.latch_en_crc_hs200 = 1; \
autok_para_rx.latch_en_cmd_ddr208 = 2; \
autok_para_rx.latch_en_crc_ddr208 = 2; \
autok_para_rx.latch_en_cmd_sd_sdr104 = 1; \
autok_para_rx.latch_en_crc_sd_sdr104 = 1; \
autok_para_rx.latch_en_cmd_sdio_sdr104 = 1; \
autok_para_rx.latch_en_crc_sdio_sdr104 = 1; \
autok_para_rx.latch_en_cmd_hs = 1; \
autok_para_rx.latch_en_crc_hs = 1; \
autok_para_rx.cmd_ta_val = 0; \
autok_para_rx.crc_ta_val = 0; \
autok_para_rx.busy_ma_val = 1; \
autok_para_rx.new_water_hs400 = 8; \
autok_para_rx.new_stop_hs400 = 3; \
autok_para_rx.new_water_hs200 = 0; \
autok_para_rx.new_stop_hs200 = 6; \
autok_para_rx.new_water_ddr208 = 8; \
autok_para_rx.new_stop_ddr208 = 3; \
autok_para_rx.new_water_sdr104 = 0; \
autok_para_rx.new_stop_sdr104 = 6; \
autok_para_rx.new_water_hs = 8; \
autok_para_rx.new_stop_hs = 3; \
autok_para_rx.old_water_hs400 = 8; \
autok_para_rx.old_stop_hs400 = 3; \
autok_para_rx.old_water_hs200 = 0; \
autok_para_rx.old_stop_hs200 = 6; \
autok_para_rx.old_water_ddr208 = 8; \
autok_para_rx.old_stop_ddr208 = 3; \
autok_para_rx.old_water_sdr104 = 0; \
autok_para_rx.old_stop_sdr104 = 6; \
autok_para_rx.old_water_hs = 8; \
autok_para_rx.old_stop_hs = 3; \
autok_para_rx.read_dat_cnt_hs400 = 1; \
autok_para_rx.read_dat_cnt_ddr208 = 1; \
autok_para_rx.end_bit_chk_cnt_hs400 = CHK_CNT_HS400; \
autok_para_rx.end_bit_chk_cnt_ddr208 = 3; \
autok_para_rx.latchck_switch_cnt_hs400 = SWITCH_CNT_HS400; \
autok_para_rx.latchck_switch_cnt_ddr208 = 3; \
autok_para_rx.ds_dly3_hs400 = 20; \
autok_para_rx.ds_dly3_ddr208 = 20; \
} while (0)
#define get_platform_para_misc(autok_para_misc) \
do { \
autok_para_misc.latch_ck_emmc_times = 10; \
autok_para_misc.latch_ck_sdio_times = 20; \
autok_para_misc.latch_ck_sd_times = 20; \
autok_para_misc.emmc_data_tx_tune = 1; \
autok_para_misc.data_tx_separate_tune = 0; \
} while (0)
#define get_platform_top_ctrl(autok_top_ctrl) \
do { \
autok_top_ctrl.msdc0_rx_enhance_top = 1; \
autok_top_ctrl.msdc1_rx_enhance_top = 1; \
autok_top_ctrl.msdc2_rx_enhance_top = 0; \
} while (0)
/*
* emmc_data_tx_tune:0 use cmd24;1 use cmd23+cmd25;2:use cmdq cmd
*/
#define get_platform_func(autok_para_func) \
do { \
autok_para_func.new_path_hs400 = 1; \
autok_para_func.new_path_hs200 = 1; \
autok_para_func.new_path_ddr208 = 1; \
autok_para_func.new_path_sdr104 = 1; \
autok_para_func.new_path_hs = 1; \
autok_para_func.multi_sync = 1; \
autok_para_func.rx_enhance = 1; \
autok_para_func.msdc0_bypass_duty_modify = 0; \
autok_para_func.msdc1_bypass_duty_modify = 0; \
autok_para_func.msdc2_bypass_duty_modify = 0; \
} while (0)
#define PORT0_PB0_RD_DAT_SEL_VALID
#define PORT1_PB0_RD_DAT_SEL_VALID
#define PORT3_PB0_RD_DAT_SEL_VALID
#define MMC_QUE_TASK_PARAMS_RD 441
#define MMC_QUE_TASK_PARAMS_WR 440
#define MMC_SWITCH_CQ_EN 601
#define MMC_SWITCH_CQ_DIS 600
/*
* reg define
*/
#define AUTOK_SDC_RX_ENH_EN (0x1 << 20) /* RW */
#define AUTOK_TOP_SDC_RX_ENHANCE_EN (0x1 << 15) /* RW */
/**********************************************************
* Feature Control Defination *
**********************************************************/
#define AUTOK_EMMC_OFFLINE_TUNE_TX_ENABLE 0
#define AUTOK_SD_CARD_OFFLINE_TUNE_TX_ENABLE 0
#define AUTOK_SDIO_OFFLINE_TUNE_TX_ENABLE 1
#define AUTOK_OFFLINE_CMD_H_TX_ENABLE 0
#define AUTOK_OFFLINE_DAT_H_TX_ENABLE 1
#define AUTOK_OFFLINE_CMD_D_RX_ENABLE 0
#define AUTOK_OFFLINE_DAT_D_RX_ENABLE 1
#define AUTOK_OFFLINE_TUNE_DEVICE_RX_ENABLE 1
#define AUTOK_PARAM_DUMP_ENABLE 0
#define SINGLE_EDGE_ONLINE_TUNE 0
#define SDIO_PLUS_CMD_TUNE 1
#define STOP_CLK_NEW_PATH 0
#define DS_DLY3_SCAN 0
#define CHIP_DENALI_3_DAT_TUNE 0
#endif /* _AUTOK_CUST_H_ */
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,60 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _AUTOK_DVFS_H_
#define _AUTOK_DVFS_H_
#include "msdc_cust.h"
#include "autok.h"
//#define VCOREFS_READY
#if defined(VCOREFS_READY)
#include <linux/pm_qos.h>
#include "helio-dvfsrc-opp.h"
#endif
enum AUTOK_VCORE {
AUTOK_VCORE_LEVEL0 = 0,
AUTOK_VCORE_LEVEL1,
AUTOK_VCORE_LEVEL2,
AUTOK_VCORE_LEVEL3,
AUTOK_VCORE_MERGE,
AUTOK_VCORE_NUM = AUTOK_VCORE_MERGE
};
#define MSDC_DVFS_TIMEOUT (HZ/100 * 5) /* 10ms x5 */
#define MSDC_DVFS_SET_SIZE 0x48
#define MSDC_TOP_SET_SIZE 0x30
#define SDIO_DVFS_TIMEOUT (HZ/100 * 5) /* 10ms x5 */
/* Enable later@Peter */
/* #define SDIO_HW_DVFS_CONDITIONAL */
/**********************************************************
* Function Declaration *
**********************************************************/
extern int sdio_autok_res_exist(struct msdc_host *host);
extern int sdio_autok_res_apply(struct msdc_host *host, int vcore);
extern int sdio_autok_res_save(struct msdc_host *host, int vcore, u8 *res);
extern void sdio_autok_wait_dvfs_ready(void);
extern int emmc_execute_dvfs_autok(struct msdc_host *host, u32 opcode);
extern int sd_execute_dvfs_autok(struct msdc_host *host, u32 opcode);
extern void sdio_execute_dvfs_autok(struct msdc_host *host);
extern int autok_res_check(u8 *res_h, u8 *res_l);
extern void sdio_set_hw_dvfs(int vcore, int done, struct msdc_host *host);
extern void sdio_dvfs_reg_restore(struct msdc_host *host);
extern void msdc_dump_autok(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host);
extern void msdc_dvfs_reg_backup_init(struct msdc_host *host);
extern void msdc_dvfs_reg_restore(struct msdc_host *host);
#ifdef SD_RUNTIME_AUTOK_MERGE
extern int sd_runtime_autok_merge(struct msdc_host *host);
#endif
#ifdef EMMC_RUNTIME_AUTOK_MERGE
extern int emmc_runtime_autok_merge(u32 opcode);
#endif
#endif /* _AUTOK_DVFS_H_ */
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,208 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MSDC_CUST_MT6765_H_
#define _MSDC_CUST_MT6765_H_
#ifdef CONFIG_FPGA_EARLY_PORTING
#define FPGA_PLATFORM
#else
/* #define MTK_MSDC_BRINGUP_DEBUG */
#endif
#if defined(CONFIG_MACH_MT6765)
#include <dt-bindings/mmc/mt6765-msdc.h>
#else
#include <dt-bindings/mmc/mt6761-msdc.h>
#endif
/* #define CONFIG_MTK_MSDC_BRING_UP_BYPASS */
#if !defined(FPGA_PLATFORM)
#if defined(CONFIG_MACH_MT6765)
#include <dt-bindings/clock/mt6765-clk.h>
#else
#include <dt-bindings/clock/mt6761-clk.h>
#endif
#endif
#ifndef CONFIG_MTK_MSDC_BRING_UP_BYPASS
//#include <mtk_spm_resource_req.h>
#endif
/**************************************************************/
/* Section 1: Device Tree */
/**************************************************************/
/* Names used for device tree lookup */
#define DT_COMPATIBLE_NAME "mediatek,msdc"
#define MSDC0_CLK_NAME "msdc0-clock"
#if defined(CONFIG_MTK_HW_FDE) || defined(CONFIG_MMC_CRYPTO)
#define MSDC0_AES_CLK_NAME "msdc0-aes-clock"
#endif
#define MSDC0_HCLK_NAME "msdc0-hclock"
#define MSDC1_CLK_NAME "msdc1-clock"
#define MSDC1_HCLK_NAME "msdc1-hclock"
#define MSDC3_CLK_NAME "msdc3-clock"
#define MSDC3_HCLK_NAME "msdc3-hclock"
#define MSDC0_IOCFG_NAME "mediatek,io_cfg_lt"
#define MSDC1_IOCFG_NAME "mediatek,io_cfg_lb"
/**************************************************************/
/* Section 2: Power */
/**************************************************************/
#define SD_POWER_DEFAULT_ON (0)
#include <mt-plat/upmu_common.h>
#define EMMC_VOL_ACTUAL VOL_3000
#define SD_VOL_ACTUAL VOL_3000
/**************************************************************/
/* Section 3: Clock */
/**************************************************************/
#define MSDCPLL_FREQ 800000000
/* list the other value by clock owners' clock table doc if needed */
#define MSDC0_SRC_0 260000
#define MSDC0_SRC_1 (MSDCPLL_FREQ/2)
#define MSDC1_SRC_0 260000
#define MSDC1_SRC_1 208000000
#define MSDC1_SRC_2 (MSDCPLL_FREQ/4)
#define MSDC3_SRC_0 260000
#define MSDC3_SRC_1 208000000
#define MSDC3_SRC_2 (MSDCPLL_FREQ/2)
#define MSDC3_SRC_3 156000000
#define MSDC3_SRC_4 182000000
#define MSDC3_SRC_5 312000000
#define MSDC3_SRC_6 364000000
#define MSDC3_SRC_7 (MSDCPLL_FREQ/4)
#define MSDC_SRC_FPGA 12000000
/**************************************************************/
/* Section 4: GPIO and Pad */
/**************************************************************/
/*--------------------------------------------------------------------------*/
/* MSDC0~1 GPIO and IO Pad Configuration Base */
/*--------------------------------------------------------------------------*/
#define MSDC_GPIO_BASE gpio_base /* 0x10005000 */
#define MSDC0_IO_PAD_BASE (msdc_io_cfg_bases[0]) /* 0x10002000 */
#define MSDC1_IO_PAD_BASE (msdc_io_cfg_bases[1]) /* 0x10002400 */
/*--------------------------------------------------------------------------*/
/* MSDC GPIO Related Register */
/*--------------------------------------------------------------------------*/
/* MSDC0 */
#define MSDC0_GPIO_MODE0 (MSDC_GPIO_BASE + 0x3f0)
#define MSDC0_GPIO_MODE1 (MSDC_GPIO_BASE + 0x400)
#define MSDC0_GPIO_MODE_TRAP (MSDC_GPIO_BASE + 0x6f0)
#define MSDC0_GPIO_IES (MSDC0_IO_PAD_BASE + 0x10)
#define MSDC0_GPIO_SMT (MSDC0_IO_PAD_BASE + 0x80)
#define MSDC0_GPIO_TDSEL (MSDC0_IO_PAD_BASE + 0x90)
#define MSDC0_GPIO_RDSEL (MSDC0_IO_PAD_BASE + 0x70)
#define MSDC0_GPIO_DRV (MSDC0_IO_PAD_BASE + 0)
#define MSDC0_GPIO_PUPD (MSDC0_IO_PAD_BASE + 0x30)
#define MSDC0_GPIO_R0 (MSDC0_IO_PAD_BASE + 0x50)
#define MSDC0_GPIO_R1 (MSDC0_IO_PAD_BASE + 0x60)
/* MSDC1 */
#define MSDC1_GPIO_MODE0 (MSDC_GPIO_BASE + 0x330)
#define MSDC1_GPIO_MODE1 (MSDC_GPIO_BASE + 0x340)
#define MSDC1_GPIO_IES (MSDC1_IO_PAD_BASE + 0x20)
#define MSDC1_GPIO_SMT (MSDC1_IO_PAD_BASE + 0xb0)
#define MSDC1_GPIO_TDSEL (MSDC1_IO_PAD_BASE + 0xd0)
#define MSDC1_GPIO_RDSEL (MSDC1_IO_PAD_BASE + 0x90)
#define MSDC1_GPIO_DRV (MSDC1_IO_PAD_BASE + 0)
#define MSDC1_GPIO_SR (MSDC1_IO_PAD_BASE + 0xc0)
#define MSDC1_GPIO_PUPD (MSDC1_IO_PAD_BASE + 0x50)
#define MSDC1_GPIO_R0 (MSDC1_IO_PAD_BASE + 0x70)
#define MSDC1_GPIO_R1 (MSDC1_IO_PAD_BASE + 0x80)
/**************************************************************/
/* Section 5: Adjustable Driver Parameter */
/**************************************************************/
#define HOST_MAX_BLKSZ (2048)
#define MSDC_OCR_AVAIL\
(MMC_VDD_28_29 | MMC_VDD_29_30 | MMC_VDD_30_31 \
| MMC_VDD_31_32 | MMC_VDD_32_33)
/* data timeout counter. 1048576 * 3 sclk. */
#define DEFAULT_DTOC (3)
#define MAX_DMA_CNT (4 * 1024 * 1024)
/* a WIFI transaction may be 50K */
#define MAX_DMA_CNT_SDIO (0xFFFFFFFF - 255)
/* a LTE transaction may be 128K */
#define MAX_HW_SGMTS (MAX_BD_NUM)
#define MAX_PHY_SGMTS (MAX_BD_NUM)
#define MAX_SGMT_SZ (MAX_DMA_CNT)
#define MAX_SGMT_SZ_SDIO (MAX_DMA_CNT_SDIO)
#define HOST_MAX_NUM (2)
#ifdef CONFIG_PWR_LOSS_MTK_TEST
#define MAX_REQ_SZ (512 * 65536)
#else
#define MAX_REQ_SZ (512 * 1024)
#endif
#ifdef FPGA_PLATFORM
#define HOST_MAX_MCLK (200000000)
#else
#define HOST_MAX_MCLK (200000000)
#endif
#define HOST_MIN_MCLK (260000)
/* SD card, bad card handling settings */
/* if continuous data timeout reach the limit */
/* driver will force remove card */
#define MSDC_MAX_DATA_TIMEOUT_CONTINUOUS (100)
/* if continuous power cycle fail reach the limit */
/* driver will force remove card */
#define MSDC_MAX_POWER_CYCLE_FAIL_CONTINUOUS (3)
#define SDCARD_ESD_RECOVERY
/* #define MSDC_HQA */
/* sd read/write crc error happen in mt6885 when vcore changes,
* sd can't support autok merge by fix vcore(like emmc),
* so add runtime autok merge function
*/
#define SD_RUNTIME_AUTOK_MERGE
/* fix vcore in kernel will affect other module,
* use emmc runtime autok merge intead of the original emmc autok
*/
#define EMMC_RUNTIME_AUTOK_MERGE
/**************************************************************/
/* Section 6: BBChip-depenent Tunnig Parameter */
/**************************************************************/
#define EMMC_MAX_FREQ_DIV 4 /* lower frequence to 12.5M */
#define MSDC_CLKTXDLY 0
#define MSDC0_DDR50_DDRCKD 1 /* FIX ME: may be removed */
#define VOL_CHG_CNT_DEFAULT_VAL 0x1F4 /* =500 */
/* hw diff: 0xB0[0]=1 */
#define MSDC_PB0_DEFAULT_VAL 0x403C0007
#define MSDC_PB1_DEFAULT_VAL 0xFFFA0349
#define MSDC_PB2_DEFAULT_RESPWAITCNT 0x3
#define MSDC_PB2_DEFAULT_RESPSTENSEL 0x1
#define MSDC_PB2_DEFAULT_CRCSTSENSEL 0x1
#endif /* _MSDC_CUST_MT6765_H_ */
@@ -0,0 +1,137 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifdef pr_fmt
#undef pr_fmt
#endif
#define pr_fmt(fmt) "["KBUILD_MODNAME"]" fmt
#include <linux/io.h>
#include "mtk_sd.h"
#define FPGA_PWR_GPIO (0x10001E84)
#define FPGA_PWR_GPIO_EO (0x10001E88)
static void __iomem *fpga_pwr_gpio;
static void __iomem *fpga_pwr_gpio_eo;
#define PWR_GPIO (fpga_pwr_gpio)
#define PWR_GPIO_EO (fpga_pwr_gpio_eo)
#define PWR_MASK_VOL_33 (1 << 10)
#define PWR_MASK_VOL_18 (1 << 9)
#define PWR_MASK_CARD (1 << 8)
#define PWR_MASK_VOL_33_MASK (~(1 << 10))
#define PWR_MASK_CARD_MASK (~(1 << 8))
#define PWR_MASK_VOL_18_MASK (~(1 << 9))
void msdc_set_pwr_gpio_dir(void __iomem *fpga_pwr_gpio,
void __iomem *fpga_pwr_gpio_eo)
{
u16 l_val;
l_val = MSDC_READ16(PWR_GPIO_EO);
MSDC_WRITE16(PWR_GPIO_EO,
(l_val | /* PWR_GPIO_L4_DIR | */
PWR_MASK_CARD | PWR_MASK_VOL_33 | PWR_MASK_VOL_18));
l_val = MSDC_READ16(PWR_GPIO_EO);
pr_debug("[%s]: pwr gpio dir = 0x%x\n", __func__, l_val);
}
void msdc_fpga_pwr_init(void)
{
if (fpga_pwr_gpio == NULL) {
fpga_pwr_gpio = ioremap(FPGA_PWR_GPIO, 8);
if (fpga_pwr_gpio == NULL) {
pr_notice("[%s] msdc ioremap error\n", __func__);
WARN_ON(1);
}
fpga_pwr_gpio_eo = fpga_pwr_gpio + 0x4;
pr_notice("FPGA PWR_GPIO, PWR_GPIO_EO address 0x%p, 0x%p\n",
fpga_pwr_gpio, fpga_pwr_gpio_eo);
}
msdc_set_pwr_gpio_dir(fpga_pwr_gpio, fpga_pwr_gpio_eo);
}
bool hwPowerOn_fpga(void)
{
u16 l_val;
l_val = MSDC_READ16(PWR_GPIO);
#ifdef CONFIG_MTK_EMMC_SUPPORT
MSDC_WRITE16(PWR_GPIO, (l_val | PWR_MASK_VOL_18 | PWR_MASK_CARD));
/* | PWR_GPIO_L4_DIR)); */
#else
MSDC_WRITE16(PWR_GPIO, (l_val | PWR_MASK_VOL_33 | PWR_MASK_CARD));
/* | PWR_GPIO_L4_DIR)); */
#endif
l_val = MSDC_READ16(PWR_GPIO);
pr_debug("[%s]: pwr gpio = 0x%x\n", __func__, l_val);
return true;
}
EXPORT_SYMBOL(hwPowerOn_fpga);
bool hwPowerSwitch_fpga(void)
{
u16 l_val;
l_val = MSDC_READ16(PWR_GPIO);
MSDC_WRITE16(PWR_GPIO, (l_val & ~(PWR_MASK_VOL_33)));
l_val = MSDC_READ16(PWR_GPIO);
MSDC_WRITE16(PWR_GPIO, (l_val | PWR_MASK_VOL_18));
l_val = MSDC_READ16(PWR_GPIO);
pr_debug("[%s]: pwr gpio = 0x%x\n", __func__, l_val);
return true;
}
EXPORT_SYMBOL(hwPowerSwitch_fpga);
bool hwPowerDown_fpga(void)
{
u16 l_val;
l_val = MSDC_READ16(PWR_GPIO);
#ifdef CONFIG_MTK_EMMC_SUPPORT
MSDC_WRITE16(PWR_GPIO,
(l_val & ~(PWR_MASK_VOL_18 | PWR_MASK_CARD)));
#else
MSDC_WRITE16(PWR_GPIO,
(l_val & ~(PWR_MASK_VOL_18 | PWR_MASK_VOL_33 | PWR_MASK_CARD)));
#endif
l_val = MSDC_READ16(PWR_GPIO);
pr_debug("[%s]: pwr gpio = 0x%x\n", __func__, l_val);
return true;
}
EXPORT_SYMBOL(hwPowerDown_fpga);
void msdc_fpga_power(struct msdc_host *host, u32 on)
{
if (on)
hwPowerOn_fpga();
else
hwPowerDown_fpga();
}
void msdc_sd_power_switch(struct msdc_host *host, u32 on)
{
if (on)
hwPowerSwitch_fpga();
}
void msdc_select_clksrc(struct msdc_host *host, int clksrc)
{
host->hclk = msdc_get_hclk(host->id, clksrc);
host->hw->clk_src = clksrc;
pr_notice("[%s]: msdc%d select clk_src as %d(%dKHz)\n", __func__,
host->id, clksrc, host->hclk/1000);
}
/* do we need sync object or not */
void msdc_clk_status(int *status)
{
}
@@ -0,0 +1,184 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MSDC_IO_H_
#define _MSDC_IO_H_
/**************************************************************/
/* Section 1: Device Tree */
/**************************************************************/
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
extern const struct of_device_id msdc_of_ids[];
extern unsigned int cd_gpio;
int msdc_dt_init(struct platform_device *pdev, struct mmc_host *mmc);
/**************************************************************/
/* Section 2: Power */
/**************************************************************/
int msdc_sd_power_switch(struct msdc_host *host, u32 on);
void msdc_set_host_power_control(struct msdc_host *host);
void msdc_pmic_force_vcore_pwm(bool enable);
void msdc_sd_power_off(void);
#if !defined(FPGA_PLATFORM)
int msdc_oc_check(struct msdc_host *host, u32 en);
int msdc_io_check(struct msdc_host *host);
void msdc_dump_ldo_sts(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host);
void msdc_HQA_set_voltage(struct msdc_host *host);
#else
#define msdc_power_calibration_init(host)
void msdc_fpga_pwr_init(void);
#define msdc_oc_check(msdc_host, en) (0)
#define msdc_io_check(msdc_host) (1)
extern void msdc_fpga_power(struct msdc_host *host, u32 on);
#define msdc_emmc_power msdc_fpga_power
#define msdc_sd_power msdc_fpga_power
#define msdc_sdio_power msdc_fpga_power
#define msdc_dump_ldo_sts(buff, size, m, host)
#endif
/**************************************************************/
/* Section 3: Clock */
/**************************************************************/
#include <linux/clk.h>
#if defined(FPGA_PLATFORM)
extern u32 hclks_msdc[];
#define msdc_dump_dvfs_reg(buff, size, m, host)
#define msdc_dump_clock_sts(buff, size, m, host)
#define msdc_get_hclk(host, src) MSDC_SRC_FPGA
static inline int msdc_clk_enable(struct msdc_host *host) { return 0; }
#define msdc_clk_disable(host)
#define msdc_get_ccf_clk_pointer(pdev, host) (0)
#define msdc_clk_enable_and_stable(host)
#endif
#if !defined(FPGA_PLATFORM)
extern u32 *hclks_msdc_all[];
extern void msdc_dump_dvfs_reg(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host);
void msdc_dump_clock_sts(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host);
#define msdc_get_hclk(id, src) hclks_msdc_all[id][src]
#ifndef CONFIG_MTK_MSDC_BRING_UP_BYPASS
#define msdc_clk_enable(host) \
do { \
(void)clk_enable(host->clk_ctl); \
if (host->aes_clk_ctl) \
(void)clk_enable(host->aes_clk_ctl); \
if (host->hclk_ctl) \
(void)clk_enable(host->hclk_ctl); \
} while (0)
#define msdc_clk_disable(host) \
do { \
clk_disable(host->clk_ctl); \
if (host->aes_clk_ctl) \
clk_disable(host->aes_clk_ctl); \
if (host->hclk_ctl) \
clk_disable(host->hclk_ctl); \
} while (0)
#else
#define msdc_clk_enable(host)
#define msdc_clk_disable(host)
#endif
int msdc_get_ccf_clk_pointer(struct platform_device *pdev,
struct msdc_host *host);
void msdc_clk_enable_and_stable(struct msdc_host *host);
#endif
/**************************************************************/
/* Section 4: GPIO and Pad */
/**************************************************************/
/*******************************************************************************
*PINMUX and GPIO definition
******************************************************************************/
#define MSDC_PIN_PULL_NONE (0)
#define MSDC_PIN_PULL_DOWN (1)
#define MSDC_PIN_PULL_UP (2)
#define MSDC_PIN_KEEP (3)
#define MSDC_TDRDSEL_SLEEP (0)
#define MSDC_TDRDSEL_3V (1)
#define MSDC_TDRDSEL_1V8 (2)
#define MSDC_TDRDSEL_CUST (3)
#ifndef FPGA_PLATFORM
void msdc_set_driving_by_id(u32 id, struct msdc_hw_driving *driving);
void msdc_get_driving_by_id(u32 id, struct msdc_hw_driving *driving);
void msdc_set_ies_by_id(u32 id, int set_ies);
void msdc_set_sr_by_id(u32 id, int clk, int cmd, int dat, int rst, int ds);
void msdc_set_smt_by_id(u32 id, int set_smt);
void msdc_set_tdsel_by_id(u32 id, u32 flag, u32 value);
void msdc_set_rdsel_by_id(u32 id, u32 flag, u32 value);
void msdc_get_tdsel_by_id(u32 id, u32 *value);
void msdc_get_rdsel_by_id(u32 id, u32 *value);
void msdc_dump_vcore(char **buff, unsigned long *size, struct seq_file *m);
void msdc_dump_padctl_by_id(char **buff, unsigned long *size,
struct seq_file *m, u32 id);
void msdc_pin_config_by_id(u32 id, u32 mode);
void msdc_set_pin_mode(struct msdc_host *host);
#else
#define msdc_set_driving_by_id(id, driving)
#define msdc_get_driving_by_id(id, driving)
#define msdc_set_ies_by_id(id, set_ies)
#define msdc_set_sr_by_id(id, clk, cmd, dat, rst, ds)
#define msdc_set_smt_by_id(id, set_smt)
#define msdc_set_tdsel_by_id(id, flag, value)
#define msdc_set_rdsel_by_id(id, flag, value)
#define msdc_get_tdsel_by_id(id, value)
#define msdc_get_rdsel_by_id(id, value)
#define msdc_dump_vcore(buff, size, m)
#define msdc_dump_padctl_by_id(buff, size, m, id)
#define msdc_pin_config_by_id(id, mode)
#define msdc_set_pin_mode(host)
#endif
#define msdc_get_driving(host, driving) \
msdc_get_driving_by_id(host->id, driving)
#define msdc_set_driving(host, driving) \
msdc_set_driving_by_id(host->id, driving)
#define msdc_set_ies(host, set_ies) \
msdc_set_ies_by_id(host->id, set_ies)
#define msdc_set_sr(host, clk, cmd, dat, rst, ds) \
msdc_set_sr_by_id(host->id, clk, cmd, dat, rst, ds)
#define msdc_set_smt(host, set_smt) \
msdc_set_smt_by_id(host->id, set_smt)
#define msdc_set_tdsel(host, flag, value) \
msdc_set_tdsel_by_id(host->id, flag, value)
#define msdc_set_rdsel(host, flag, value) \
msdc_set_rdsel_by_id(host->id, flag, value)
#define msdc_get_tdsel(host, value) \
msdc_get_tdsel_by_id(host->id, value)
#define msdc_get_rdsel(host, value) \
msdc_get_rdsel_by_id(host->id, value)
#define msdc_dump_padctl(buff, size, m, host) \
msdc_dump_padctl_by_id(buff, size, m, host->id)
#define msdc_pin_config(host, mode) \
msdc_pin_config_by_id(host->id, mode)
#endif /* end of _MSDC_IO_H_ */
@@ -0,0 +1,350 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
//#include <linux/hie.h>
#include <linux/arm-smccc.h>
#include <linux/soc/mediatek/mtk_sip_svc.h>
/* map from AES Spec */
enum {
MSDC_CRYPTO_XTS_AES = 4,
MSDC_CRYPTO_AES_CBC_ESSIV = 9,
MSDC_CRYPTO_BITLOCKER = 17,
MSDC_CRYPTO_AES_ECB = 0,
MSDC_CRYPTO_AES_CBC = 1,
MSDC_CRYPTO_AES_CTR = 2,
MSDC_CRYPTO_AES_CBC_MAC = 3,
} aes_mode;
enum {
BIT_128 = 0,
BIT_192 = 1,
BIT_256 = 2,
BIT_0 = 4,
};
#ifndef CONFIG_HIE
u64 hie_get_iv(struct request *req)
{
return 0;
}
#endif
static void msdc_crypto_switch_config(struct msdc_host *host,
struct request *req,
u32 block_address, u32 dir)
{
void __iomem *base = host->base;
u32 aes_mode_current = 0, aes_sw_reg = 0;
u32 ctr[4] = {0};
unsigned long polling_tmo = 0;
u64 hw_hie_iv_num = 0;
/* 1. set ctr */
aes_sw_reg = MSDC_READ32(EMMC52_AES_EN);
hw_hie_iv_num = hie_get_iv(req);
if (aes_sw_reg & EMMC52_AES_SWITCH_VALID0)
MSDC_GET_FIELD(EMMC52_AES_CFG_GP0,
EMMC52_AES_MODE_0, aes_mode_current);
else if (aes_sw_reg & EMMC52_AES_SWITCH_VALID1)
MSDC_GET_FIELD(EMMC52_AES_CFG_GP1,
EMMC52_AES_MODE_1, aes_mode_current);
else {
pr_notice("MSDC: EMMC52_AES_SWITCH_VALID error in msdc reg\n");
WARN_ON(1);
return;
}
switch (aes_mode_current) {
case MSDC_CRYPTO_XTS_AES:
case MSDC_CRYPTO_AES_CBC_ESSIV:
case MSDC_CRYPTO_BITLOCKER:
{
if (hw_hie_iv_num) {
ctr[0] = hw_hie_iv_num & 0xffffffff;
ctr[1] = (hw_hie_iv_num >> 32) & 0xffffffff;
} else {
ctr[0] = block_address;
}
break;
}
case MSDC_CRYPTO_AES_ECB:
case MSDC_CRYPTO_AES_CBC:
break;
case MSDC_CRYPTO_AES_CTR:
{
if (hw_hie_iv_num) {
ctr[0] = hw_hie_iv_num & 0xffffffff;
ctr[1] = (hw_hie_iv_num >> 32) & 0xffffffff;
} else {
ctr[0] = block_address;
}
break;
}
case MSDC_CRYPTO_AES_CBC_MAC:
break;
default:
pr_notice("msdc unknown aes mode\n");
WARN_ON(1);
return;
}
if (aes_sw_reg & EMMC52_AES_SWITCH_VALID0) {
MSDC_WRITE32(EMMC52_AES_CTR0_GP0, ctr[0]);
MSDC_WRITE32(EMMC52_AES_CTR1_GP0, ctr[1]);
MSDC_WRITE32(EMMC52_AES_CTR2_GP0, ctr[2]);
MSDC_WRITE32(EMMC52_AES_CTR3_GP0, ctr[3]);
} else {
MSDC_WRITE32(EMMC52_AES_CTR0_GP1, ctr[0]);
MSDC_WRITE32(EMMC52_AES_CTR1_GP1, ctr[1]);
MSDC_WRITE32(EMMC52_AES_CTR2_GP1, ctr[2]);
MSDC_WRITE32(EMMC52_AES_CTR3_GP1, ctr[3]);
}
/* 2. enable AES path */
MSDC_CLR_BIT32(EMMC52_AES_SWST, EMMC52_AES_BYPASS);
/* 3. AES switch start (flush the configure) */
if (dir == DMA_TO_DEVICE) {
MSDC_SET_BIT32(EMMC52_AES_SWST, EMMC52_AES_SWITCH_START_ENC);
polling_tmo = jiffies + POLLING_BUSY;
while (MSDC_READ32(EMMC52_AES_SWST)
& EMMC52_AES_SWITCH_START_ENC) {
if (time_after(jiffies, polling_tmo)) {
pr_notice(
"msdc%d, error: trigger AES ENC timeout!\n",
host->id);
WARN_ON(1);
}
}
} else {
MSDC_SET_BIT32(EMMC52_AES_SWST, EMMC52_AES_SWITCH_START_DEC);
polling_tmo = jiffies + POLLING_BUSY;
while (MSDC_READ32(EMMC52_AES_SWST)
& EMMC52_AES_SWITCH_START_DEC) {
if (time_after(jiffies, polling_tmo)) {
pr_notice(
"msdc%d, error: trigger DEC AES DEC timeout!\n",
host->id);
WARN_ON(1);
}
}
}
}
static void msdc_pre_crypto(struct mmc_host *mmc, struct mmc_request *mrq)
{
struct msdc_host *host = mmc_priv(mmc);
struct mmc_command *cmd = mrq->cmd;
u32 dir = DMA_FROM_DEVICE;
u32 blk_addr = 0;
u32 is_fde = 0, is_fbe = 0;
#if defined(CONFIG_MTK_HW_FDE)
unsigned int key_idx;
struct arm_smccc_res res;
#endif
#ifdef CONFIG_HIE
int err;
#endif
struct request *req = NULL;
struct mmc_queue_req *mq_rq = NULL;
struct mmc_blk_request *brq;
#ifdef CONFIG_MTK_EMMC_CQ_SUPPORT
struct mmc_async_req *areq;
#endif
if (!host->hw || !mmc->card)
return;
if (host->hw->host_function != MSDC_EMMC)
return;
#ifdef CONFIG_MTK_EMMC_CQ_SUPPORT
/* CMDQ Command */
if (check_mmc_cmd4647(cmd->opcode)) {
areq = mmc->areq_que[(cmd->arg >> 16) & 0x1f];
mq_rq = container_of(areq, struct mmc_queue_req, areq);
blk_addr = mq_rq->brq.que.arg;
req = mmc_queue_req_to_req(mq_rq);
goto check_hw_crypto;
}
#endif
/* Normal Read Write Command */
if (mrq->is_mmc_req &&
(check_mmc_cmd1718(cmd->opcode) ||
check_mmc_cmd2425(cmd->opcode))) {
brq = container_of(mrq, struct mmc_blk_request, mrq);
mq_rq = container_of(brq, struct mmc_queue_req, brq);
blk_addr = cmd->arg;
req = mmc_queue_req_to_req(mq_rq);
goto check_hw_crypto;
}
return;
check_hw_crypto:
dir = cmd->data->flags & MMC_DATA_READ ?
DMA_FROM_DEVICE : DMA_TO_DEVICE;
#if defined(CONFIG_MTK_HW_FDE)
if (req->bio && req->bio->bi_hw_fde) {
is_fde = 1;
key_idx = req->bio->bi_key_idx;
}
#endif
#ifdef CONFIG_HIE
if (hie_request_crypted(req))
is_fbe = 1;
#endif
if (is_fde || is_fbe) {
#if defined(CONFIG_MTK_HW_FDE)
if (is_fde &&
(!host->is_crypto_init ||
(host->key_idx != key_idx))) {
/* fde init */
arm_smccc_smc(MTK_SIP_KERNEL_HW_FDE_MSDC_CTL,
(1 << 3), 4, 1, 0, 0, 0, 0, &res);
host->is_crypto_init = true;
host->key_idx = key_idx;
}
#endif
#ifdef CONFIG_HIE
if (is_fbe) {
if (!host->is_crypto_init) {
/* fbe init */
arm_smccc_smc(MTK_SIP_KERNEL_HW_FDE_MSDC_CTL,
(1 << 0), 4, 1, 0, 0, 0, 0, &res);
host->is_crypto_init = true;
}
if (dir == DMA_TO_DEVICE)
err = hie_encrypt(msdc_hie_get_dev(), req,
host);
else
err = hie_decrypt(msdc_hie_get_dev(), req,
host);
if (err) {
err = -EIO;
ERR_MSG(
"%s: fail in crypto hook, req: %p, err %d\n",
__func__, req, err);
WARN_ON(1);
return;
}
if (hie_is_nocrypt())
return;
if (hie_is_dummy()) {
struct mmc_data *data = cmd->data;
if (dir == DMA_TO_DEVICE &&
msdc_use_async_dma(data->host_cookie)) {
dma_unmap_sg(mmc_dev(mmc), data->sg,
data->sg_len, dir);
dma_map_sg(mmc_dev(mmc), data->sg,
data->sg_len, dir);
}
return;
}
}
#endif
if (!mmc_card_blockaddr(mmc->card))
blk_addr = blk_addr >> 9;
/* Check data size with 16bytes */
WARN_ON(host->dma.xfersz & 0xf);
/* Check data addressw with 16bytes alignment */
WARN_ON((host->dma.gpd_addr & 0xf)
|| (host->dma.bd_addr & 0xf));
msdc_crypto_switch_config(host, req, blk_addr, dir);
}
}
static void msdc_post_crypto(struct msdc_host *host)
{
void __iomem *base = host->base;
/* disable AES path by set bypass bit */
MSDC_SET_BIT32(EMMC52_AES_SWST, EMMC52_AES_BYPASS);
}
#ifdef CONFIG_HIE
/* configure request for HIE */
static int msdc_hie_cfg_request(unsigned int mode, const char *key,
int len, struct request *req, void *priv)
{
struct msdc_host *host = (struct msdc_host *)priv;
void __iomem *base = host->base;
u32 iv[4] = {0}, aes_key[8] = {0}, aes_tkey[8] = {0};
u32 data_unit_size, i, half_len;
u8 key_bit, aes_mode;
if (mode & BC_AES_256_XTS) {
aes_mode = MSDC_CRYPTO_XTS_AES;
key_bit = BIT_256;
WARN_ON(len != 64);
} else if (mode & BC_AES_128_XTS) {
aes_mode = MSDC_CRYPTO_XTS_AES;
key_bit = BIT_128;
WARN_ON(len != 32);
} else {
ERR_MSG("%s: unknown mode 0x%x\n", __func__, mode);
WARN_ON(1);
return -EIO;
}
/*
* limit half_len as u32 * 8
* prevent local buffer overflow
*/
half_len = min_t(u32, len / 2, sizeof(u32) * 8);
/* Split key into key & tkey */
memcpy(aes_key, &key[0], half_len);
memcpy(aes_tkey, &key[half_len], half_len);
/* eMMC block size 512bytes */
data_unit_size = (1 << 9);
/* AES config */
MSDC_WRITE32(EMMC52_AES_CFG_GP1,
(data_unit_size << 16 | key_bit << 8 | aes_mode << 0));
/* IV */
for (i = 0; i < 4; i++)
MSDC_WRITE32((EMMC52_AES_IV0_GP1 + i * 4), iv[i]);
/* KEY */
for (i = 0; i < 8; i++)
MSDC_WRITE32((EMMC52_AES_KEY0_GP1 + i * 4), aes_key[i]);
/* TKEY */
for (i = 0; i < 8; i++)
MSDC_WRITE32((EMMC52_AES_TKEY0_GP1 + i * 4), aes_tkey[i]);
return 0;
}
struct hie_dev msdc_hie_dev = {
.name = "msdc",
.mode = (BC_AES_256_XTS | BC_AES_128_XTS),
.encrypt = msdc_hie_cfg_request,
.decrypt = msdc_hie_cfg_request,
.priv = NULL,
};
struct hie_dev *msdc_hie_get_dev(void)
{
return &msdc_hie_dev;
}
static void msdc_hie_register(struct msdc_host *host)
{
if (host->hw->host_function == MSDC_EMMC)
hie_register_device(&msdc_hie_dev);
}
#endif
@@ -0,0 +1,314 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _AUTOK_CUST_H_
#define _AUTOK_CUST_H_
#define AUTOK_VERSION (0x18110817)
struct AUTOK_PLAT_PARA_TX {
unsigned int chip_hw_ver;
u8 msdc0_hs400_clktx;
u8 msdc0_hs400_cmdtx;
u8 msdc0_hs400_dat0tx;
u8 msdc0_hs400_dat1tx;
u8 msdc0_hs400_dat2tx;
u8 msdc0_hs400_dat3tx;
u8 msdc0_hs400_dat4tx;
u8 msdc0_hs400_dat5tx;
u8 msdc0_hs400_dat6tx;
u8 msdc0_hs400_dat7tx;
u8 msdc0_hs400_txskew;
u8 msdc0_ddr_ckd;
u8 msdc1_ddr_ckd;
u8 msdc2_ddr_ckd;
u8 msdc0_clktx;
u8 msdc0_cmdtx;
u8 msdc0_dat0tx;
u8 msdc0_dat1tx;
u8 msdc0_dat2tx;
u8 msdc0_dat3tx;
u8 msdc0_dat4tx;
u8 msdc0_dat5tx;
u8 msdc0_dat6tx;
u8 msdc0_dat7tx;
u8 msdc0_txskew;
u8 msdc1_clktx;
u8 msdc1_sdr104_clktx;
u8 msdc2_clktx;
u8 sdio30_plus_clktx;
u8 sdio30_plus_cmdtx;
u8 sdio30_plus_dat0tx;
u8 sdio30_plus_dat1tx;
u8 sdio30_plus_dat2tx;
u8 sdio30_plus_dat3tx;
u8 msdc0_duty_bypass;
u8 msdc0_hl_duty_sel;
u8 msdc1_duty_bypass;
u8 msdc1_hl_duty_sel;
u8 msdc2_duty_bypass;
u8 msdc2_hl_duty_sel;
};
struct AUTOK_PLAT_PARA_RX {
unsigned int chip_hw_ver;
u8 ckgen_val;
u8 latch_en_cmd_hs400;
u8 latch_en_crc_hs400;
u8 latch_en_cmd_hs200;
u8 latch_en_crc_hs200;
u8 latch_en_cmd_ddr208;
u8 latch_en_crc_ddr208;
u8 latch_en_cmd_sd_sdr104;
u8 latch_en_crc_sd_sdr104;
u8 latch_en_cmd_sdio_sdr104;
u8 latch_en_crc_sdio_sdr104;
u8 latch_en_cmd_hs;
u8 latch_en_crc_hs;
u8 cmd_ta_val;
u8 crc_ta_val;
u8 busy_ma_val;
u8 new_water_hs400;
u8 new_water_hs200;
u8 new_water_ddr208;
u8 new_water_sdr104;
u8 new_water_hs;
u8 new_stop_hs400;
u8 new_stop_hs200;
u8 new_stop_ddr208;
u8 new_stop_sdr104;
u8 new_stop_hs;
u8 old_water_hs400;
u8 old_water_hs200;
u8 old_water_ddr208;
u8 old_water_sdr104;
u8 old_water_hs;
u8 old_stop_hs400;
u8 old_stop_hs200;
u8 old_stop_ddr208;
u8 old_stop_sdr104;
u8 old_stop_hs;
u8 read_dat_cnt_hs400;
u8 read_dat_cnt_ddr208;
u8 end_bit_chk_cnt_hs400;
u8 end_bit_chk_cnt_ddr208;
u8 latchck_switch_cnt_hs400;
u8 latchck_switch_cnt_ddr208;
u8 ds_dly3_hs400;
u8 ds_dly3_ddr208;
};
struct AUTOK_PLAT_PARA_MISC {
unsigned int chip_hw_ver;
u8 latch_ck_emmc_times;
u8 latch_ck_sdio_times;
u8 latch_ck_sd_times;
u8 emmc_data_tx_tune;
u8 data_tx_separate_tune;
};
struct AUTOK_PLAT_TOP_CTRL {
u8 msdc0_rx_enhance_top;
u8 msdc1_rx_enhance_top;
u8 msdc2_rx_enhance_top;
};
struct AUTOK_PLAT_FUNC {
unsigned int chip_hw_ver;
u8 new_path_hs400;
u8 new_path_hs200;
u8 new_path_ddr208;
u8 new_path_sdr104;
u8 new_path_hs;
u8 multi_sync;
u8 rx_enhance;
u8 r1b_check;
u8 ddr50_fix;
u8 fifo_1k;
u8 latch_enhance;
u8 msdc0_bypass_duty_modify;
u8 msdc1_bypass_duty_modify;
u8 msdc2_bypass_duty_modify;
};
#define get_platform_para_tx(autok_para_tx) \
do { \
autok_para_tx.msdc0_hs400_clktx = 0; \
autok_para_tx.msdc0_hs400_cmdtx = 0; \
autok_para_tx.msdc0_hs400_dat0tx = 0; \
autok_para_tx.msdc0_hs400_dat1tx = 0; \
autok_para_tx.msdc0_hs400_dat2tx = 0; \
autok_para_tx.msdc0_hs400_dat3tx = 0; \
autok_para_tx.msdc0_hs400_dat4tx = 0; \
autok_para_tx.msdc0_hs400_dat5tx = 0; \
autok_para_tx.msdc0_hs400_dat6tx = 0; \
autok_para_tx.msdc0_hs400_dat7tx = 0; \
autok_para_tx.msdc0_hs400_txskew = 0; \
autok_para_tx.msdc0_ddr_ckd = 1; \
autok_para_tx.msdc1_ddr_ckd = 0; \
autok_para_tx.msdc2_ddr_ckd = 1; \
autok_para_tx.msdc0_clktx = 0; \
autok_para_tx.msdc0_cmdtx = 0; \
autok_para_tx.msdc0_dat0tx = 0; \
autok_para_tx.msdc0_dat1tx = 0; \
autok_para_tx.msdc0_dat2tx = 0; \
autok_para_tx.msdc0_dat3tx = 0; \
autok_para_tx.msdc0_dat4tx = 0; \
autok_para_tx.msdc0_dat5tx = 0; \
autok_para_tx.msdc0_dat6tx = 0; \
autok_para_tx.msdc0_dat7tx = 0; \
autok_para_tx.msdc0_txskew = 0; \
autok_para_tx.msdc1_clktx = 0; \
autok_para_tx.msdc1_sdr104_clktx = 0; \
autok_para_tx.msdc2_clktx = 0; \
autok_para_tx.sdio30_plus_clktx = 0; \
autok_para_tx.sdio30_plus_cmdtx = 0; \
autok_para_tx.sdio30_plus_dat0tx = 0; \
autok_para_tx.sdio30_plus_dat1tx = 0; \
autok_para_tx.sdio30_plus_dat2tx = 0; \
autok_para_tx.sdio30_plus_dat3tx = 0; \
autok_para_tx.msdc0_duty_bypass = 0; \
autok_para_tx.msdc0_hl_duty_sel = 0; \
autok_para_tx.msdc1_duty_bypass = 0; \
autok_para_tx.msdc1_hl_duty_sel = 0; \
autok_para_tx.msdc2_duty_bypass = 0; \
autok_para_tx.msdc2_hl_duty_sel = 0; \
} while (0)
#define get_platform_para_rx(autok_para_rx) \
do { \
autok_para_rx.ckgen_val = 0; \
autok_para_rx.latch_en_cmd_hs400 = 3; \
autok_para_rx.latch_en_crc_hs400 = 3; \
autok_para_rx.latch_en_cmd_hs200 = 2; \
autok_para_rx.latch_en_crc_hs200 = 2; \
autok_para_rx.latch_en_cmd_ddr208 = 4; \
autok_para_rx.latch_en_crc_ddr208 = 4; \
autok_para_rx.latch_en_cmd_sd_sdr104 = 1; \
autok_para_rx.latch_en_crc_sd_sdr104 = 1; \
autok_para_rx.latch_en_cmd_sdio_sdr104 = 2; \
autok_para_rx.latch_en_crc_sdio_sdr104 = 2; \
autok_para_rx.latch_en_cmd_hs = 1; \
autok_para_rx.latch_en_crc_hs = 1; \
autok_para_rx.cmd_ta_val = 0; \
autok_para_rx.crc_ta_val = 0; \
autok_para_rx.busy_ma_val = 1; \
autok_para_rx.new_water_hs400 = 8; \
autok_para_rx.new_stop_hs400 = 3; \
autok_para_rx.new_water_hs200 = 0; \
autok_para_rx.new_stop_hs200 = 6; \
autok_para_rx.new_water_ddr208 = 8; \
autok_para_rx.new_stop_ddr208 = 3; \
autok_para_rx.new_water_sdr104 = 0; \
autok_para_rx.new_stop_sdr104 = 6; \
autok_para_rx.new_water_hs = 8; \
autok_para_rx.new_stop_hs = 3; \
autok_para_rx.old_water_hs400 = 8; \
autok_para_rx.old_stop_hs400 = 3; \
autok_para_rx.old_water_hs200 = 0; \
autok_para_rx.old_stop_hs200 = 6; \
autok_para_rx.old_water_ddr208 = 8; \
autok_para_rx.old_stop_ddr208 = 3; \
autok_para_rx.old_water_sdr104 = 0; \
autok_para_rx.old_stop_sdr104 = 6; \
autok_para_rx.old_water_hs = 8; \
autok_para_rx.old_stop_hs = 3; \
autok_para_rx.read_dat_cnt_hs400 = 7; \
autok_para_rx.read_dat_cnt_ddr208 = 0; \
autok_para_rx.end_bit_chk_cnt_hs400 = 14; \
autok_para_rx.end_bit_chk_cnt_ddr208 = 0; \
autok_para_rx.latchck_switch_cnt_hs400 = 6; \
autok_para_rx.latchck_switch_cnt_ddr208 = 0; \
autok_para_rx.ds_dly3_hs400 = 20; \
autok_para_rx.ds_dly3_ddr208 = 0; \
} while (0)
#define get_platform_para_misc(autok_para_misc) \
do { \
autok_para_misc.latch_ck_emmc_times = 10; \
autok_para_misc.latch_ck_sdio_times = 20; \
autok_para_misc.latch_ck_sd_times = 20; \
autok_para_misc.emmc_data_tx_tune = 1; \
autok_para_misc.data_tx_separate_tune = 0; \
} while (0)
#define get_platform_top_ctrl(autok_top_ctrl) \
do { \
autok_top_ctrl.msdc0_rx_enhance_top = 1; \
autok_top_ctrl.msdc1_rx_enhance_top = 1; \
autok_top_ctrl.msdc2_rx_enhance_top = 0; \
} while (0)
/*
* emmc_data_tx_tune:0 use cmd24;1 use cmd23+cmd25;2:use cmdq cmd
*/
#define get_platform_func(autok_para_func) \
do { \
autok_para_func.new_path_hs400 = 1; \
autok_para_func.new_path_hs200 = 1; \
autok_para_func.new_path_ddr208 = 1; \
autok_para_func.new_path_sdr104 = 1; \
autok_para_func.new_path_hs = 1; \
autok_para_func.multi_sync = 1; \
autok_para_func.rx_enhance = 1; \
autok_para_func.r1b_check = 1; \
autok_para_func.ddr50_fix = 1; \
autok_para_func.fifo_1k = 1; \
autok_para_func.latch_enhance = 1; \
autok_para_func.msdc0_bypass_duty_modify = 1; \
autok_para_func.msdc1_bypass_duty_modify = 0; \
autok_para_func.msdc2_bypass_duty_modify = 0; \
} while (0)
#define PORT0_PB0_RD_DAT_SEL_VALID
#define PORT1_PB0_RD_DAT_SEL_VALID
#define PORT3_PB0_RD_DAT_SEL_VALID
#define MMC_QUE_TASK_PARAMS_RD 441
#define MMC_QUE_TASK_PARAMS_WR 440
#define MMC_SWITCH_CQ_EN 601
#define MMC_SWITCH_CQ_DIS 600
/*
* reg define
*/
#define AUTOK_SDC_RX_ENH_EN (0x1 << 20) /* RW */
#define AUTOK_TOP_SDC_RX_ENHANCE_EN (0x1 << 15) /* RW */
/**********************************************************
* Feature Control Defination *
**********************************************************/
#define AUTOK_EMMC_OFFLINE_TUNE_TX_ENABLE 0
#define AUTOK_SD_CARD_OFFLINE_TUNE_TX_ENABLE 0
#define AUTOK_SDIO_OFFLINE_TUNE_TX_ENABLE 1
#define AUTOK_OFFLINE_CMD_H_TX_ENABLE 0
#define AUTOK_OFFLINE_DAT_H_TX_ENABLE 1
#define AUTOK_OFFLINE_CMD_D_RX_ENABLE 0
#define AUTOK_OFFLINE_DAT_D_RX_ENABLE 1
#define AUTOK_OFFLINE_TUNE_DEVICE_RX_ENABLE 1
#define AUTOK_PARAM_DUMP_ENABLE 0
#define SINGLE_EDGE_ONLINE_TUNE 0
#define SDIO_PLUS_CMD_TUNE 1
#define STOP_CLK_NEW_PATH 0
#define DS_DLY3_SCAN 0
#define CHIP_DENALI_3_DAT_TUNE 0
#endif /* _AUTOK_CUST_H_ */
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,57 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _AUTOK_DVFS_H_
#define _AUTOK_DVFS_H_
#include "msdc_cust.h"
#include "autok.h"
#define VCOREFS_READY
#if defined(VCOREFS_READY)
#include <linux/pm_qos.h>
#include "helio-dvfsrc-opp.h"
#endif
enum AUTOK_VCORE {
AUTOK_VCORE_LEVEL0 = 0,
AUTOK_VCORE_LEVEL1,
AUTOK_VCORE_LEVEL2,
AUTOK_VCORE_LEVEL3,
AUTOK_VCORE_MERGE,
AUTOK_VCORE_NUM = AUTOK_VCORE_MERGE
};
#define MSDC_DVFS_TIMEOUT (HZ/100 * 5) /* 10ms x5 */
#define MSDC_DVFS_SET_SIZE 0x48
#define MSDC_TOP_SET_SIZE 0x30
#define SDIO_DVFS_TIMEOUT (HZ/100 * 5) /* 10ms x5 */
/* Enable later@Peter */
/* #define SDIO_HW_DVFS_CONDITIONAL */
/**********************************************************
* Function Declaration *
**********************************************************/
extern int sdio_autok_res_exist(struct msdc_host *host);
extern int sdio_autok_res_apply(struct msdc_host *host, int vcore);
extern int sdio_autok_res_save(struct msdc_host *host, int vcore, u8 *res);
extern void sdio_autok_wait_dvfs_ready(void);
extern int emmc_execute_dvfs_autok(struct msdc_host *host, u32 opcode);
extern int sd_execute_dvfs_autok(struct msdc_host *host, u32 opcode);
extern void sdio_execute_dvfs_autok(struct msdc_host *host);
extern int autok_res_check(u8 *res_h, u8 *res_l);
extern void sdio_set_hw_dvfs(int vcore, int done, struct msdc_host *host);
extern void sdio_dvfs_reg_restore(struct msdc_host *host);
extern void msdc_dump_autok(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host);
extern void msdc_dvfs_reg_backup_init(struct msdc_host *host);
extern void msdc_dvfs_reg_restore(struct msdc_host *host);
#ifdef SD_RUNTIME_AUTOK_MERGE
extern int sd_runtime_autok_merge(struct msdc_host *host);
#endif
#endif /* _AUTOK_DVFS_H_ */
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,524 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MSDC_CUST_MT6885_H_
#define _MSDC_CUST_MT6885_H_
#ifdef CONFIG_FPGA_EARLY_PORTING
#define FPGA_PLATFORM
#else
/* #define MTK_MSDC_BRINGUP_DEBUG */
#endif
#include <dt-bindings/mmc/mt6885-msdc.h>
//#define CONFIG_MTK_MSDC_BRING_UP_BYPASS
#if !defined(FPGA_PLATFORM)
#include <dt-bindings/clock/mt6885-clk.h>
#endif
/**************************************************************/
/* Section 1: Device Tree */
/**************************************************************/
/* Names used for device tree lookup */
#define DT_COMPATIBLE_NAME "mediatek,msdc"
#define MSDC0_CLK_NAME "msdc0-clock"
#if defined(CONFIG_MTK_HW_FDE) || defined(CONFIG_MMC_CRYPTO)
#define MSDC0_AES_CLK_NAME "msdc0-aes-clock"
#endif
#define MSDC0_HCLK_NAME "msdc0-hclock"
#define MSDC1_CLK_NAME "msdc1-clock"
#define MSDC1_HCLK_NAME "msdc1-hclock"
#define MSDC0_IOCFG_NAME "mediatek,iocfg_tm"
#define MSDC1_IOCFG_NAME "mediatek,iocfg_lm"
#define MSDC1_A_IOCFG_NAME "mediatek,iocfg_rm"
/**************************************************************/
/* Section 2: Power */
/**************************************************************/
#define SD_POWER_DEFAULT_ON (0)
#if !defined(FPGA_PLATFORM)
#include <mt-plat/upmu_common.h>
#define REG_VEMC_VOSEL_CAL PMIC_RG_VEMC_VOCAL_0_ADDR
#define MASK_VEMC_VOSEL_CAL PMIC_RG_VEMC_VOCAL_0_MASK
#define SHIFT_VEMC_VOSEL_CAL PMIC_RG_VEMC_VOCAL_0_SHIFT
#define FIELD_VEMC_VOSEL_CAL (MASK_VEMC_VOSEL_CAL \
<< SHIFT_VEMC_VOSEL_CAL)
#define REG_VEMC_VOSEL PMIC_RG_VEMC_VOSEL_0_ADDR
#define MASK_VEMC_VOSEL PMIC_RG_VEMC_VOSEL_0_MASK
#define SHIFT_VEMC_VOSEL PMIC_RG_VEMC_VOSEL_0_SHIFT
#define FIELD_VEMC_VOSEL (MASK_VEMC_VOSEL << SHIFT_VEMC_VOSEL)
#define REG_VEMC_EN PMIC_RG_LDO_VEMC_EN_ADDR
#define MASK_VEMC_EN PMIC_RG_LDO_VEMC_EN_MASK
#define SHIFT_VEMC_EN PMIC_RG_LDO_VEMC_EN_SHIFT
#define FIELD_VEMC_EN (MASK_VEMC_EN << SHIFT_VEMC_EN)
#define REG_VMC_VOSEL_CAL PMIC_RG_VMC_VOCAL_ADDR
#define MASK_VMC_VOSEL_CAL PMIC_RG_VMC_VOCAL_MASK
#define SHIFT_VMC_VOSEL_CAL PMIC_RG_VMC_VOCAL_SHIFT
#define FIELD_VMC_VOSEL_CAL (MASK_VMC_VOSEL_CAL \
<< SHIFT_VMC_VOSEL_CAL)
#define REG_VMC_VOSEL PMIC_RG_VMC_VOSEL_ADDR
#define MASK_VMC_VOSEL PMIC_RG_VMC_VOSEL_MASK
#define SHIFT_VMC_VOSEL PMIC_RG_VMC_VOSEL_SHIFT
#define FIELD_VMC_VOSEL (MASK_VMC_VOSEL << SHIFT_VMC_VOSEL)
#define REG_VMC_EN PMIC_RG_LDO_VMC_EN_ADDR
#define MASK_VMC_EN PMIC_RG_LDO_VMC_EN_MASK
#define SHIFT_VMC_EN PMIC_RG_LDO_VMC_EN_SHIFT
#define FIELD_VMC_EN (MASK_VMC_EN << SHIFT_VMC_EN)
#define REG_VMCH_VOSEL_CAL PMIC_RG_VMCH_VOCAL_ADDR
#define MASK_VMCH_VOSEL_CAL PMIC_RG_VMCH_VOCAL_MASK
#define SHIFT_VMCH_VOSEL_CAL PMIC_RG_VMCH_VOCAL_SHIFT
#define FIELD_VMCH_VOSEL_CAL (MASK_VMCH_VOSEL_CAL \
<< SHIFT_VMCH_VOSEL_CAL)
#define REG_VMCH_VOSEL PMIC_RG_VMCH_VOSEL_ADDR
#define MASK_VMCH_VOSEL PMIC_RG_VMCH_VOSEL_MASK
#define SHIFT_VMCH_VOSEL PMIC_RG_VMCH_VOSEL_SHIFT
#define FIELD_VMCH_VOSEL (MASK_VMCH_VOSEL << SHIFT_VMCH_VOSEL)
#define REG_VMCH_EN PMIC_RG_LDO_VMCH_EN_ADDR
#define MASK_VMCH_EN PMIC_RG_LDO_VMCH_EN_MASK
#define SHIFT_VMCH_EN PMIC_RG_LDO_VMCH_EN_SHIFT
#define FIELD_VMCH_EN (MASK_VMCH_EN << SHIFT_VMCH_EN)
#define REG_VMCH_OC_RAW_STATUS PMIC_RG_INT_RAW_STATUS_VMCH_OC_ADDR
#define MASK_VMCH_OC_RAW_STATUS PMIC_RG_INT_RAW_STATUS_VMCH_OC_MASK
#define SHIFT_VMCH_OC_RAW_STATUS PMIC_RG_INT_RAW_STATUS_VMCH_OC_SHIFT
#define FIELD_VMCH_OC_RAW_STATUS (MASK_VMCH_OC_RAW_STATUS \
<< SHIFT_VMCH_OC_RAW_STATUS)
#define REG_VMCH_OC_STATUS PMIC_RG_INT_STATUS_VMCH_OC_ADDR
#define MASK_VMCH_OC_STATUS PMIC_RG_INT_STATUS_VMCH_OC_MASK
#define SHIFT_VMCH_OC_STATUS PMIC_RG_INT_STATUS_VMCH_OC_SHIFT
#define FIELD_VMCH_OC_STATUS (MASK_VMCH_OC_STATUS << SHIFT_VMCH_OC_STATUS)
#define VEMC_VOSEL_CAL_mV(cal) ((cal >= 0) ? ((cal)/10) : 0)
#define VEMC_VOSEL_2V9 (10)
#define VEMC_VOSEL_3V (11)
#define VEMC_VOSEL_3V3 (13)
#define VMC_VOSEL_CAL_mV(cal) ((cal >= 0) ? ((cal)/10) : 0)
#define VMC_VOSEL_1V8 (4)
#define VMC_VOSEL_2V9 (10)
#define VMC_VOSEL_3V (11)
#define VMC_VOSEL_3V3 (13)
#define VMCH_VOSEL_CAL_mV(cal) ((cal >= 0) ? ((cal)/10) : 0)
#define VMCH_VOSEL_2V9 (2)
#define VMCH_VOSEL_3V (3)
#define VMCH_VOSEL_3V3 (5)
#endif
#define EMMC_VOL_ACTUAL VOL_3000
#define SD_VOL_ACTUAL VOL_3000
/**************************************************************/
/* Section 3: Clock */
/**************************************************************/
#if !defined(FPGA_PLATFORM)
/* MSDCPLL register offset */
#define MSDCPLL_CON0_OFFSET (0x350)
#define MSDCPLL_CON1_OFFSET (0x354)
#define MSDCPLL_CON2_OFFSET (0x358)
#define MSDCPLL_PWR_CON0_OFFSET (0x35c)
#endif
#define MSDCPLL_FREQ 400000000
#define MSDC0_SRC_0 26000000
#define MSDC0_SRC_1 MSDCPLL_FREQ
#define MSDC0_SRC_2 (MSDCPLL_FREQ/2)
#define MSDC0_SRC_3 156000000
#define MSDC0_SRC_4 182000000
#define MSDC0_SRC_5 312000000
#define MSDC1_SRC_0 26000000
#define MSDC1_SRC_1 208000000
#define MSDC1_SRC_2 182000000
#define MSDC1_SRC_3 156000000
#define MSDC1_SRC_4 (MSDCPLL_FREQ/2)
#define MSDC_SRC_FPGA 12000000
/**************************************************************/
/* Section 4: GPIO and Pad */
/**************************************************************/
/*--------------------------------------------------------------------------*/
/* MSDC0~1 GPIO and IO Pad Configuration Base */
/*--------------------------------------------------------------------------*/
/* 0x10005000 */
#define MSDC_GPIO_BASE gpio_base
/*0x11F3_0000*/
#define MSDC0_IO_PAD_BASE (msdc_io_cfg_bases[0])
/*0x11E2_0000*/
#define MSDC1_IO_PAD_BASE (msdc_io_cfg_bases[1])
/*--------------------------------------------------------------------------*/
/* MSDC GPIO Related Register */
/*--------------------------------------------------------------------------*/
/* MSDC0 */
#define MSDC0_GPIO_MODE22 (MSDC_GPIO_BASE + 0x460)
#define MSDC0_GPIO_MODE23 (MSDC_GPIO_BASE + 0x470)
#define MSDC0_GPIO_MODE24 (MSDC_GPIO_BASE + 0x480)
#define MSDC0_GPIO_DRV0 (MSDC0_IO_PAD_BASE + 0x00)
#define MSDC0_GPIO_IES (MSDC0_IO_PAD_BASE + 0x50)
#define MSDC0_GPIO_PUPD0 (MSDC0_IO_PAD_BASE + 0x80)
#define MSDC0_GPIO_R0 (MSDC0_IO_PAD_BASE + 0xA0)
#define MSDC0_GPIO_R1 (MSDC0_IO_PAD_BASE + 0xB0)
#define MSDC0_GPIO_RDSEL0 (MSDC0_IO_PAD_BASE + 0xC0)
#define MSDC0_GPIO_RDSEL0_1 (MSDC0_IO_PAD_BASE + 0xD0)
#define MSDC0_GPIO_SMT (MSDC0_IO_PAD_BASE + 0xF0)
#define MSDC0_GPIO_TDSEL0 (MSDC0_IO_PAD_BASE + 0x100)
/* MSDC1 */
#define MSDC1_GPIO_MODE6 (MSDC_GPIO_BASE + 0x360)
#define MSDC1_GPIO_MODE7 (MSDC_GPIO_BASE + 0x370)
#define MSDC1_GPIO_DRV0 (MSDC1_IO_PAD_BASE + 0x00)
#define MSDC1_GPIO_IES (MSDC1_IO_PAD_BASE + 0x20)
#define MSDC1_GPIO_PUPD0 (MSDC1_IO_PAD_BASE + 0x40)
#define MSDC1_GPIO_R0 (MSDC1_IO_PAD_BASE + 0x60)
#define MSDC1_GPIO_R1 (MSDC1_IO_PAD_BASE + 0x70)
#define MSDC1_GPIO_RDSEL0 (MSDC1_IO_PAD_BASE + 0x80)
#define MSDC1_GPIO_SMT (MSDC1_IO_PAD_BASE + 0x90)
#define MSDC1_GPIO_SR (MSDC1_IO_PAD_BASE + 0xA0)
#define MSDC1_GPIO_TDSEL0 (MSDC1_IO_PAD_BASE + 0xB0)
#define MSDC1_GPIO_TDSEL0_1 (MSDC1_IO_PAD_BASE + 0xC0)
/* MSDC1_PADA */
#define MSDC1_GPIO_MISC (MSDC_GPIO_BASE + 0x600)
#define MSDC1_GPIO_MODE1 (MSDC_GPIO_BASE + 0x310)
#define MSDC1_GPIO_DRV0_A (MSDC1_IO_PAD_BASE + 0x00)
#define MSDC1_GPIO_IES_A (MSDC1_IO_PAD_BASE + 0x20)
#define MSDC1_GPIO_PUPD0_A (MSDC1_IO_PAD_BASE + 0x40)
#define MSDC1_GPIO_R0_A (MSDC1_IO_PAD_BASE + 0x60)
#define MSDC1_GPIO_R1_A (MSDC1_IO_PAD_BASE + 0x70)
#define MSDC1_GPIO_RDSEL0_A (MSDC1_IO_PAD_BASE + 0x80)
#define MSDC1_GPIO_SMT_A (MSDC1_IO_PAD_BASE + 0x90)
#define MSDC1_GPIO_SR (MSDC1_IO_PAD_BASE + 0xA0)
#define MSDC1_GPIO_TDSEL0_A (MSDC1_IO_PAD_BASE + 0xB0)
/*
* MSDC0 GPIO and PAD register and bitfields definition
*/
/* MSDC0_GPIO_MODE22, 001b is msdc mode*/
#define MSDC0_MODE_CMD_MASK (0x7 << 28)
/* MSDC0_GPIO_MODE23, 001b is msdc mode */
#define MSDC0_MODE_DSL_MASK (0x7 << 28)
#define MSDC0_MODE_DAT7_MASK (0x7 << 24)
#define MSDC0_MODE_DAT5_MASK (0x7 << 20)
#define MSDC0_MODE_DAT1_MASK (0x7 << 16)
#define MSDC0_MODE_DAT6_MASK (0x7 << 12)
#define MSDC0_MODE_DAT4_MASK (0x7 << 8)
#define MSDC0_MODE_DAT2_MASK (0x7 << 4)
#define MSDC0_MODE_DAT0_MASK (0x7 << 0)
/* MSDC0_GPIO_MODE24, 001b is msdc mode */
#define MSDC0_MODE_RSTB_MASK (0x7 << 8)
#define MSDC0_MODE_DAT3_MASK (0x7 << 4)
#define MSDC0_MODE_CLK_MASK (0x7 << 0)
/* MSDC0 IES mask */
#define MSDC0_IES_RSTB_MASK (0x1 << 29)
#define MSDC0_IES_DSL_MASK (0x1 << 28)
#define MSDC0_IES_DAT_MASK (0xFF << 20)
#define MSDC0_IES_CMD_MASK (0x1 << 19)
#define MSDC0_IES_CLK_MASK (0x1 << 18)
#define MSDC0_IES_ALL_MASK (0xFFF << 18)
/* MSDC0 SMT mask */
#define MSDC0_SMT_DSL_MASK (0x1 << 5)
#define MSDC0_SMT_DAT_MASK (0x1 << 4)
#define MSDC0_SMT_CMD_MASK (0x1 << 3)
#define MSDC0_SMT_CLK_MASK (0x1 << 2)
#define MSDC0_SMT_ALL_MASK (0xF << 2)
/* MSDC0 TDSEL0 mask */
#define MSDC0_TDSEL0_DSL_MASK (0xF << 24)
#define MSDC0_TDSEL0_DAT_MASK (0xF << 20)
#define MSDC0_TDSEL0_CMD_MASK (0xF << 16)
#define MSDC0_TDSEL0_CLK_MASK (0xF << 12)
#define MSDC0_TDSEL0_ALL_MASK (0xFFFF << 12)
/* MSDC0 RDSEL0 mask */
#define MSDC0_RDSEL0_RSTB_MASK (0x3F << 0)
#define MSDC0_RDSEL0_DSL_MASK (0x3F << 24)
#define MSDC0_RDSEL0_DAT_MASK (0x3F << 18)
#define MSDC0_RDSEL0_CMD_MASK (0x3F << 12)
#define MSDC0_RDSEL0_CLK_MASK (0x3F << 6)
#define MSDC0_RDSEL0_ALL_MASK_0 (0xFFFFFF << 6)
#define MSDC0_RDSEL0_ALL_MASK_1 (0x3F << 0)
/* MSDC0 DRV0 mask */
#define MSDC0_DRV0_DSL_MASK (0x7 << 15)
#define MSDC0_DRV0_DAT_MASK (0x7 << 12)
#define MSDC0_DRV0_CMD_MASK (0x7 << 9)
#define MSDC0_DRV0_CLK_MASK (0x7 << 6)
#define MSDC0_DRV0_ALL_MASK (0xFFF << 6)
/* MSDC0 PUPD mask*/
#define MSDC0_PUPD_RSTB_MASK (0x1 << 11)
#define MSDC0_PUPD_DSL_MASK (0x1 << 10)
#define MSDC0_PUPD_DAT7_MASK (0x1 << 9)
#define MSDC0_PUPD_DAT6_MASK (0x1 << 8)
#define MSDC0_PUPD_DAT5_MASK (0x1 << 7)
#define MSDC0_PUPD_DAT4_MASK (0x1 << 6)
#define MSDC0_PUPD_DAT3_MASK (0x1 << 5)
#define MSDC0_PUPD_DAT2_MASK (0x1 << 4)
#define MSDC0_PUPD_DAT1_MASK (0x1 << 3)
#define MSDC0_PUPD_DAT0_MASK (0x1 << 2)
#define MSDC0_PUPD_CMD_MASK (0x1 << 1)
#define MSDC0_PUPD_CLK_MASK (0x1 << 0)
#define MSDC0_PUPD_DAT_MASK (0xFF << 2)
#define MSDC0_PUPD_ALL_MASK (0x7FF << 0)
/* MSDC0 R0 mask*/
#define MSDC0_R0_RSTB_MASK (0x1 << 11)
#define MSDC0_R0_DSL_MASK (0x1 << 10)
#define MSDC0_R0_DAT7_MASK (0x1 << 9)
#define MSDC0_R0_DAT6_MASK (0x1 << 8)
#define MSDC0_R0_DAT5_MASK (0x1 << 7)
#define MSDC0_R0_DAT4_MASK (0x1 << 6)
#define MSDC0_R0_DAT3_MASK (0x1 << 5)
#define MSDC0_R0_DAT2_MASK (0x1 << 4)
#define MSDC0_R0_DAT1_MASK (0x1 << 3)
#define MSDC0_R0_DAT0_MASK (0x1 << 2)
#define MSDC0_R0_CMD_MASK (0x1 << 1)
#define MSDC0_R0_CLK_MASK (0x1 << 0)
#define MSDC0_R0_DAT_MASK (0xFF << 2)
#define MSDC0_R0_ALL_MASK (0x7FF << 0)
/* MSDC0 R1 mask*/
#define MSDC0_R1_RSTB_MASK (0x1 << 11)
#define MSDC0_R1_DSL_MASK (0x1 << 10)
#define MSDC0_R1_DAT7_MASK (0x1 << 9)
#define MSDC0_R1_DAT6_MASK (0x1 << 8)
#define MSDC0_R1_DAT5_MASK (0x1 << 7)
#define MSDC0_R1_DAT4_MASK (0x1 << 6)
#define MSDC0_R1_DAT3_MASK (0x1 << 5)
#define MSDC0_R1_DAT2_MASK (0x1 << 4)
#define MSDC0_R1_DAT1_MASK (0x1 << 3)
#define MSDC0_R1_DAT0_MASK (0x1 << 2)
#define MSDC0_R1_CMD_MASK (0x1 << 1)
#define MSDC0_R1_CLK_MASK (0x1 << 0)
#define MSDC0_R1_DAT_MASK (0xFF << 2)
#define MSDC0_R1_ALL_MASK (0x7FF << 0)
/*
* MSDC1 GPIO and PAD register and bitfields definition
*/
/* MSDC1_GPIO_MODE6, 0001b is msdc mode */
#define MSDC1_MODE_CMD_MASK (0x7 << 16)
#define MSDC1_MODE_CLK_MASK (0x7 << 12)
/* MSDC1_GPIO_MODE7, 0001b is msdc mode */
#define MSDC1_MODE_DAT1_MASK (0x7 << 0)
#define MSDC1_MODE_DAT2_MASK (0x7 << 28)
#define MSDC1_MODE_DAT0_MASK (0x7 << 24)
#define MSDC1_MODE_DAT3_MASK (0x7 << 20)
/* MSDC1 IES mask*/
#define MSDC1_IES_DAT_MASK (0xF << 18)
#define MSDC1_IES_CMD_MASK (0x1 << 17)
#define MSDC1_IES_CLK_MASK (0x1 << 16)
#define MSDC1_IES_ALL_MASK (0x3F << 16)
/* MSDC1 SMT mask*/
#define MSDC1_SMT_DAT_MASK (0x1 << 8)
#define MSDC1_SMT_CMD_MASK (0x1 << 7)
#define MSDC1_SMT_CLK_MASK (0x1 << 6)
#define MSDC1_SMT_ALL_MASK (0x7 << 6)
/* MSDC1 TDSEL0 mask*/
#define MSDC1_TDSEL0_DAT_MASK (0xF << 0)
#define MSDC1_TDSEL0_CMD_MASK (0xF << 28)
#define MSDC1_TDSEL0_CLK_MASK (0xF << 24)
#define MSDC1_TDSEL0_ALL_MASK (0xFF << 24)
/* MSDC1 RDSEL0 mask*/
#define MSDC1_RDSEL0_DAT_MASK (0x3F << 24)
#define MSDC1_RDSEL0_CMD_MASK (0x3F << 18)
#define MSDC1_RDSEL0_CLK_MASK (0x3F << 12)
#define MSDC1_RDSEL0_ALL_MASK (0x3FFFF << 12)
/* MSDC1 DRV0 mask*/
#define MSDC1_DRV0_DAT_MASK (0x7 << 24)
#define MSDC1_DRV0_CMD_MASK (0x7 << 21)
#define MSDC1_DRV0_CLK_MASK (0x7 << 18)
#define MSDC1_DRV0_ALL_MASK (0x1FF << 18)
/* MSDC1 PUPD mask*/
#define MSDC1_PUPD_DAT3_MASK (0x1 << 5)
#define MSDC1_PUPD_DAT2_MASK (0x1 << 4)
#define MSDC1_PUPD_DAT1_MASK (0x1 << 3)
#define MSDC1_PUPD_DAT0_MASK (0x1 << 2)
#define MSDC1_PUPD_CMD_MASK (0x1 << 1)
#define MSDC1_PUPD_CLK_MASK (0x1 << 0)
#define MSDC1_PUPD_ALL_MASK (0x3F << 0)
/* MSDC1 R0 mask*/
#define MSDC1_R0_DAT3_MASK (0x1 << 5)
#define MSDC1_R0_DAT2_MASK (0x1 << 4)
#define MSDC1_R0_DAT1_MASK (0x1 << 3)
#define MSDC1_R0_DAT0_MASK (0x1 << 2)
#define MSDC1_R0_CMD_MASK (0x1 << 1)
#define MSDC1_R0_CLK_MASK (0x1 << 0)
#define MSDC1_R0_ALL_MASK (0x3F << 0)
/* MSDC1 R1 mask*/
#define MSDC1_R1_DAT3_MASK (0x1 << 5)
#define MSDC1_R1_DAT2_MASK (0x1 << 4)
#define MSDC1_R1_DAT1_MASK (0x1 << 3)
#define MSDC1_R1_DAT0_MASK (0x1 << 2)
#define MSDC1_R1_CMD_MASK (0x1 << 1)
#define MSDC1_R1_CLK_MASK (0x1 << 0)
#define MSDC1_R1_ALL_MASK (0x3F << 0)
/* FOR msdc_io_check() */
#define MSDC1_PUPD_DAT0_ADDR MSDC1_GPIO_PUPD0
#define MSDC1_PUPD_DAT1_ADDR MSDC1_GPIO_PUPD0
#define MSDC1_PUPD_DAT2_ADDR MSDC1_GPIO_PUPD0
#define MSDC1_R0_DAT0_ADDR MSDC1_GPIO_R0
#define MSDC1_R0_DAT1_ADDR MSDC1_GPIO_R0
#define MSDC1_R0_DAT2_ADDR MSDC1_GPIO_R0
#define MSDC1_R1_DAT0_ADDR MSDC1_GPIO_R1
#define MSDC1_R1_DAT1_ADDR MSDC1_GPIO_R1
#define MSDC1_R1_DAT2_ADDR MSDC1_GPIO_R1
#define MSDC1_PU (0)
#define MSDC1_PD (1)
#define MSDC1_8K (1)
/* MSDC1_A_PIN_MUX_SEL */
#define MSDC1_PIN_MUX_SEL_MASK_A (0x1 << 9)
/*MSDC1_GPIO_MODE1, 0001b is msdc mode */
#define MSDC1_MODE_DAT1_A_MASK (0x7 << 28)
#define MSDC1_MODE_DAT2_A_MASK (0x7 << 24)
#define MSDC1_MODE_DAT0_A_MASK (0x7 << 20)
#define MSDC1_MODE_DAT3_A_MASK (0x7 << 16)
#define MSDC1_MODE_CMD_A_MASK (0x7 << 12)
#define MSDC1_MODE_CLK_A_MASK (0x7 << 8)
/* MSDC1_A IES mask*/
#define MSDC1_IES_ALL_MASK_A (0x3F << 9)
/* MSDC1_A SMT mask*/
#define MSDC1_SMT_ALL_MASK_A (0x1 << 4)
/* MSDC1_A TDSEL0 mask*/
#define MSDC1_TDSEL0_DAT_MASK_A (0xF << 16)
#define MSDC1_TDSEL0_CMD_MASK_A (0xF << 16)
#define MSDC1_TDSEL0_CLK_MASK_A (0xF << 16)
/* MSDC1_A RDSEL0 mask*/
#define MSDC1_RDSEL0_DAT_MASK_A (0x3F << 8)
#define MSDC1_RDSEL0_CMD_MASK_A (0x3F << 8)
#define MSDC1_RDSEL0_CLK_MASK_A (0x3F << 8)
/* MSDC1_A DRV0 mask*/
#define MSDC1_DRV0_DAT1_MASK_A (0x7 << 12)
#define MSDC1_DRV0_DAT2_MASK_A (0x7 << 12)
#define MSDC1_DRV0_DAT0_MASK_A (0x7 << 12)
#define MSDC1_DRV0_DAT3_MASK_A (0x7 << 12)
#define MSDC1_DRV0_CMD_MASK_A (0x7 << 12)
#define MSDC1_DRV0_CLK_MASK_A (0x7 << 12)
/* MSDC1_A PUPD mask*/
#define MSDC1_PUPD_DAT1_MASK_A (0x1 << 5)
#define MSDC1_PUPD_DAT2_MASK_A (0x1 << 4)
#define MSDC1_PUPD_DAT0_MASK_A (0x1 << 3)
#define MSDC1_PUPD_DAT3_MASK_A (0x1 << 2)
#define MSDC1_PUPD_CMD_MASK_A (0x1 << 1)
#define MSDC1_PUPD_CLK_MASK_A (0x1 << 0)
#define MSDC1_PUPD_ALL_MASK_A (0x3F << 0)
/* MSDC1_A R0 mask*/
#define MSDC1_R0_DAT1_MASK_A (0x1 << 5)
#define MSDC1_R0_DAT2_MASK_A (0x1 << 4)
#define MSDC1_R0_DAT0_MASK_A (0x1 << 3)
#define MSDC1_R0_DAT3_MASK_A (0x1 << 2)
#define MSDC1_R0_CMD_MASK_A (0x1 << 1)
#define MSDC1_R0_CLK_MASK_A (0x1 << 0)
#define MSDC1_R0_ALL_MASK_A (0x3F << 0)
/* MSDC1_A R1 mask*/
#define MSDC1_R1_DAT1_MASK_A (0x1 << 5)
#define MSDC1_R1_DAT2_MASK_A (0x1 << 4)
#define MSDC1_R1_DAT0_MASK_A (0x1 << 3)
#define MSDC1_R1_DAT3_MASK_A (0x1 << 2)
#define MSDC1_R1_CMD_MASK_A (0x1 << 1)
#define MSDC1_R1_CLK_MASK_A (0x1 << 0)
#define MSDC1_R1_ALL_MASK_A (0x3F << 0)
/* FOR msdc1_A_io_check() */
#define MSDC1_PUPD_DAT0_ADDR_A MSDC1_GPIO_PUPD0_A
#define MSDC1_PUPD_DAT1_ADDR_A MSDC1_GPIO_PUPD0_A
#define MSDC1_PUPD_DAT2_ADDR_A MSDC1_GPIO_PUPD0_A
#define MSDC1_R0_DAT0_ADDR_A MSDC1_GPIO_R0_A
#define MSDC1_R0_DAT1_ADDR_A MSDC1_GPIO_R0_A
#define MSDC1_R0_DAT2_ADDR_A MSDC1_GPIO_R0_A
#define MSDC1_R1_DAT0_ADDR_A MSDC1_GPIO_R1_A
#define MSDC1_R1_DAT1_ADDR_A MSDC1_GPIO_R1_A
#define MSDC1_R1_DAT2_ADDR_A MSDC1_GPIO_R1_A
/**************************************************************/
/* Section 5: Adjustable Driver Parameter */
/**************************************************************/
#define HOST_MAX_BLKSZ (2048)
#define MSDC_OCR_AVAIL\
(MMC_VDD_28_29 | MMC_VDD_29_30 | MMC_VDD_30_31 \
| MMC_VDD_31_32 | MMC_VDD_32_33)
/* data timeout counter. 1048576 * 3 sclk. */
#define DEFAULT_DTOC (3)
#define MAX_DMA_CNT (4 * 1024 * 1024)
/* a WIFI transaction may be 50K */
#define MAX_DMA_CNT_SDIO (0xFFFFFFFF - 255)
/* a LTE transaction may be 128K */
#define MAX_HW_SGMTS (MAX_BD_NUM)
#define MAX_PHY_SGMTS (MAX_BD_NUM)
#define MAX_SGMT_SZ (MAX_DMA_CNT)
#define MAX_SGMT_SZ_SDIO (MAX_DMA_CNT_SDIO)
#define HOST_MAX_NUM (2)
#ifdef CONFIG_PWR_LOSS_MTK_TEST
#define MAX_REQ_SZ (512 * 65536)
#else
#define MAX_REQ_SZ (512 * 1024)
#endif
#ifdef FPGA_PLATFORM
#define HOST_MAX_MCLK (200000000)
#else
#define HOST_MAX_MCLK (200000000)
#endif
#define HOST_MIN_MCLK (260000)
/* SD card, bad card handling settings */
/* if continuous data timeout reach the limit */
/* driver will force remove card */
#define MSDC_MAX_DATA_TIMEOUT_CONTINUOUS (100)
/* if continuous power cycle fail reach the limit */
/* driver will force remove card */
#define MSDC_MAX_POWER_CYCLE_FAIL_CONTINUOUS (3)
/* sdcard esd recovery */
/* power reset sdcard when sdcard hang from esd */
#define SDCARD_ESD_RECOVERY
/* #define MSDC_HQA */
/* #define SDIO_HQA */
/* sd read/write crc error happen in mt6885 when vcore changes,
* sd can't support autok merge by fix vcore(like emmc),
* so add runtime autok merge function
*/
#define SD_RUNTIME_AUTOK_MERGE
/**************************************************************/
/* Section 6: BBChip-depenent Tunnig Parameter */
/**************************************************************/
#define EMMC_MAX_FREQ_DIV 4 /* lower frequence to 12.5M */
#define MSDC_CLKTXDLY 0
#define MSDC0_DDR50_DDRCKD 1 /* FIX ME: may be removed */
#define VOL_CHG_CNT_DEFAULT_VAL 0x1F4 /* =500 */
#define MSDC_PB0_DEFAULT_VAL 0x403C0006
#define MSDC_PB1_DEFAULT_VAL 0xFFE20349
#define MSDC_PB2_DEFAULT_RESPWAITCNT 0x3
#define MSDC_PB2_DEFAULT_RESPSTENSEL 0x1
#define MSDC_PB2_DEFAULT_CRCSTSENSEL 0x1
#endif /* _MSDC_CUST_MT6885_H_ */
@@ -0,0 +1,145 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifdef pr_fmt
#undef pr_fmt
#endif
#define pr_fmt(fmt) "["KBUILD_MODNAME"]" fmt
#include <linux/io.h>
#include "mtk_sd.h"
#include <mt-plat/mtk_boot.h>
#define FPGA_PWR_GPIO (0x10001E84)
#define FPGA_PWR_GPIO_EO (0x10001E88)
static void __iomem *fpga_pwr_gpio;
static void __iomem *fpga_pwr_gpio_eo;
#define PWR_GPIO (fpga_pwr_gpio)
#define PWR_GPIO_EO (fpga_pwr_gpio_eo)
#define PWR_MASK_VOL_33 (1 << 10)
#define PWR_MASK_VOL_18 (1 << 9)
#define PWR_MASK_CARD (1 << 8)
#define PWR_MASK_VOL_33_MASK (~(1 << 10))
#define PWR_MASK_CARD_MASK (~(1 << 8))
#define PWR_MASK_VOL_18_MASK (~(1 << 9))
void msdc_set_pwr_gpio_dir(void __iomem *fpga_pwr_gpio,
void __iomem *fpga_pwr_gpio_eo)
{
u16 l_val;
l_val = MSDC_READ16(PWR_GPIO_EO);
MSDC_WRITE16(PWR_GPIO_EO,
(l_val | /* PWR_GPIO_L4_DIR | */
PWR_MASK_CARD | PWR_MASK_VOL_33 | PWR_MASK_VOL_18));
l_val = MSDC_READ16(PWR_GPIO_EO);
pr_debug("[%s]: pwr gpio dir = 0x%x\n", __func__, l_val);
}
void msdc_fpga_pwr_init(void)
{
if (fpga_pwr_gpio == NULL) {
fpga_pwr_gpio = ioremap(FPGA_PWR_GPIO, 8);
if (fpga_pwr_gpio == NULL) {
pr_notice("[%s] msdc ioremap error\n", __func__);
WARN_ON(1);
}
fpga_pwr_gpio_eo = fpga_pwr_gpio + 0x4;
pr_notice("FPGA PWR_GPIO, PWR_GPIO_EO address 0x%p, 0x%p\n",
fpga_pwr_gpio, fpga_pwr_gpio_eo);
}
msdc_set_pwr_gpio_dir(fpga_pwr_gpio, fpga_pwr_gpio_eo);
}
bool hwPowerOn_fpga(void)
{
u16 l_val;
int boot_type;
l_val = MSDC_READ16(PWR_GPIO);
boot_type = get_boot_type();
if (boot_type == BOOTDEV_SDMMC) {
MSDC_WRITE16(PWR_GPIO,
(l_val | PWR_MASK_VOL_18 | PWR_MASK_CARD));
} else {
MSDC_WRITE16(PWR_GPIO,
(l_val | PWR_MASK_VOL_33 | PWR_MASK_CARD));
}
l_val = MSDC_READ16(PWR_GPIO);
pr_debug("[%s]: pwr gpio = 0x%x\n", __func__, l_val);
return true;
}
EXPORT_SYMBOL(hwPowerOn_fpga);
bool hwPowerSwitch_fpga(void)
{
u16 l_val;
l_val = MSDC_READ16(PWR_GPIO);
MSDC_WRITE16(PWR_GPIO, (l_val & ~(PWR_MASK_VOL_33)));
l_val = MSDC_READ16(PWR_GPIO);
MSDC_WRITE16(PWR_GPIO, (l_val | PWR_MASK_VOL_18));
l_val = MSDC_READ16(PWR_GPIO);
pr_debug("[%s]: pwr gpio = 0x%x\n", __func__, l_val);
return true;
}
EXPORT_SYMBOL(hwPowerSwitch_fpga);
bool hwPowerDown_fpga(void)
{
u16 l_val;
int boot_type;
l_val = MSDC_READ16(PWR_GPIO);
boot_type = get_boot_type();
if (boot_type == BOOTDEV_SDMMC) {
MSDC_WRITE16(PWR_GPIO,
(l_val & ~(PWR_MASK_VOL_18 | PWR_MASK_CARD)));
} else {
MSDC_WRITE16(PWR_GPIO,
(l_val & ~(PWR_MASK_VOL_18 |
PWR_MASK_VOL_33 | PWR_MASK_CARD)));
}
l_val = MSDC_READ16(PWR_GPIO);
pr_debug("[%s]: pwr gpio = 0x%x\n", __func__, l_val);
return true;
}
EXPORT_SYMBOL(hwPowerDown_fpga);
void msdc_fpga_power(struct msdc_host *host, u32 on)
{
if (on)
hwPowerOn_fpga();
else
hwPowerDown_fpga();
}
void msdc_sd_power_switch(struct msdc_host *host, u32 on)
{
if (on)
hwPowerSwitch_fpga();
}
void msdc_select_clksrc(struct msdc_host *host, int clksrc)
{
host->hclk = msdc_get_hclk(host->id, clksrc);
host->hw->clk_src = clksrc;
pr_notice("[%s]: msdc%d select clk_src as %d(%dKHz)\n", __func__,
host->id, clksrc, host->hclk/1000);
}
/* do we need sync object or not */
void msdc_clk_status(int *status)
{
}
@@ -0,0 +1,202 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MSDC_IO_H_
#define _MSDC_IO_H_
/**************************************************************/
/* Section 1: Device Tree */
/**************************************************************/
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
extern const struct of_device_id msdc_of_ids[];
extern unsigned int cd_gpio;
int msdc_dt_init(struct platform_device *pdev, struct mmc_host *mmc);
/**************************************************************/
/* Section 2: Power */
/**************************************************************/
void msdc_sd_power_switch(struct msdc_host *host, u32 on);
void msdc_set_host_power_control(struct msdc_host *host);
void msdc_pmic_force_vcore_pwm(bool enable);
void msdc_sd_power_off(void);
#if !defined(FPGA_PLATFORM)
int msdc_oc_check(struct msdc_host *host, u32 en);
int msdc_io_check(struct msdc_host *host);
void msdc_dump_ldo_sts(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host);
void msdc_HQA_set_voltage(struct msdc_host *host);
#else
#define msdc_power_calibration_init(host)
void msdc_fpga_pwr_init(void);
#define msdc_oc_check(msdc_host, en) (0)
#define msdc_io_check(msdc_host) (1)
extern void msdc_fpga_power(struct msdc_host *host, u32 on);
#define msdc_emmc_power msdc_fpga_power
#define msdc_sd_power msdc_fpga_power
#define msdc_sdio_power msdc_fpga_power
#define msdc_dump_ldo_sts(buff, size, m, host)
#endif
/**************************************************************/
/* Section 3: Clock */
/**************************************************************/
#include <linux/clk.h>
#if defined(FPGA_PLATFORM)
extern u32 hclks_msdc[];
#define msdc_dump_dvfs_reg(buff, size, m, host)
#define msdc_dump_clock_sts(buff, size, m, host)
#define msdc_get_hclk(host, src) MSDC_SRC_FPGA
static inline int msdc_clk_enable(struct msdc_host *host) { return 0; }
#define msdc_clk_disable(host)
#define msdc_get_ccf_clk_pointer(pdev, host) (0)
#define msdc_clk_enable_and_stable(host)
#endif
#if !defined(FPGA_PLATFORM)
extern u32 *hclks_msdc_all[];
extern void msdc_dump_dvfs_reg(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host);
void msdc_dump_clock_sts(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host);
#define msdc_get_hclk(id, src) hclks_msdc_all[id][src]
#ifndef CONFIG_MTK_MSDC_BRING_UP_BYPASS
#define msdc_clk_enable(host) \
do { \
(void)clk_enable(host->clk_ctl); \
if (host->aes_clk_ctl) \
(void)clk_enable(host->aes_clk_ctl); \
if (host->hclk_ctl) \
(void)clk_enable(host->hclk_ctl); \
} while (0)
#define msdc_clk_disable(host) \
do { \
clk_disable(host->clk_ctl); \
if (host->aes_clk_ctl) \
clk_disable(host->aes_clk_ctl); \
if (host->hclk_ctl) \
clk_disable(host->hclk_ctl); \
} while (0)
#define msdc_clk_prepare_enable(host) \
do { \
(void)clk_prepare_enable(host->clk_ctl); \
if (host->aes_clk_ctl) \
(void)clk_prepare_enable(host->aes_clk_ctl); \
if (host->hclk_ctl) \
(void)clk_prepare_enable(host->hclk_ctl); \
} while (0)
#define msdc_clk_disable_unprepare(host) \
do { \
clk_disable_unprepare(host->clk_ctl); \
if (host->aes_clk_ctl) \
clk_disable_unprepare(host->aes_clk_ctl); \
if (host->hclk_ctl) \
clk_disable_unprepare(host->hclk_ctl); \
} while (0)
#else
#define msdc_clk_enable(host)
#define msdc_clk_disable(host)
#define msdc_clk_prepare_enable(host)
#define msdc_clk_disable_unprepare(host)
#endif
int msdc_get_ccf_clk_pointer(struct platform_device *pdev,
struct msdc_host *host);
void msdc_clk_enable_and_stable(struct msdc_host *host);
#endif
/**************************************************************/
/* Section 4: GPIO and Pad */
/**************************************************************/
/*******************************************************************************
*PINMUX and GPIO definition
******************************************************************************/
#define MSDC_PIN_PULL_NONE (0)
#define MSDC_PIN_PULL_DOWN (1)
#define MSDC_PIN_PULL_UP (2)
#define MSDC_PIN_KEEP (3)
#define MSDC_TDRDSEL_SLEEP (0)
#define MSDC_TDRDSEL_3V (1)
#define MSDC_TDRDSEL_1V8 (2)
#define MSDC_TDRDSEL_CUST (3)
#ifndef FPGA_PLATFORM
void msdc_set_driving_by_id(u32 id, struct msdc_hw_driving *driving);
void msdc_get_driving_by_id(u32 id, struct msdc_hw_driving *driving);
void msdc_set_ies_by_id(u32 id, int set_ies);
void msdc_set_sr_by_id(u32 id, int clk, int cmd, int dat, int rst, int ds);
void msdc_set_smt_by_id(u32 id, int set_smt);
void msdc_set_tdsel_by_id(u32 id, u32 flag, u32 value);
void msdc_set_rdsel_by_id(u32 id, u32 flag, u32 value);
void msdc_get_tdsel_by_id(u32 id, u32 *value);
void msdc_get_rdsel_by_id(u32 id, u32 *value);
void msdc_dump_vcore(char **buff, unsigned long *size, struct seq_file *m);
void msdc_dump_padctl_by_id(char **buff, unsigned long *size,
struct seq_file *m, u32 id);
void msdc_pin_config_by_id(u32 id, u32 mode);
void msdc_set_pin_mode(struct msdc_host *host);
#else
#define msdc_set_driving_by_id(id, driving)
#define msdc_get_driving_by_id(id, driving)
#define msdc_set_ies_by_id(id, set_ies)
#define msdc_set_sr_by_id(id, clk, cmd, dat, rst, ds)
#define msdc_set_smt_by_id(id, set_smt)
#define msdc_set_tdsel_by_id(id, flag, value)
#define msdc_set_rdsel_by_id(id, flag, value)
#define msdc_get_tdsel_by_id(id, value)
#define msdc_get_rdsel_by_id(id, value)
#define msdc_dump_vcore(buff, size, m)
#define msdc_dump_padctl_by_id(buff, size, m, id)
#define msdc_pin_config_by_id(id, mode)
#define msdc_set_pin_mode(host)
#endif
#define msdc_get_driving(host, driving) \
msdc_get_driving_by_id(host->id, driving)
#define msdc_set_driving(host, driving) \
msdc_set_driving_by_id(host->id, driving)
#define msdc_set_ies(host, set_ies) \
msdc_set_ies_by_id(host->id, set_ies)
#define msdc_set_sr(host, clk, cmd, dat, rst, ds) \
msdc_set_sr_by_id(host->id, clk, cmd, dat, rst, ds)
#define msdc_set_smt(host, set_smt) \
msdc_set_smt_by_id(host->id, set_smt)
#define msdc_set_tdsel(host, flag, value) \
msdc_set_tdsel_by_id(host->id, flag, value)
#define msdc_set_rdsel(host, flag, value) \
msdc_set_rdsel_by_id(host->id, flag, value)
#define msdc_get_tdsel(host, value) \
msdc_get_tdsel_by_id(host->id, value)
#define msdc_get_rdsel(host, value) \
msdc_get_rdsel_by_id(host->id, value)
#define msdc_dump_padctl(buff, size, m, host) \
msdc_dump_padctl_by_id(buff, size, m, host->id)
#define msdc_pin_config(host, mode) \
msdc_pin_config_by_id(host->id, mode)
#endif /* end of _MSDC_IO_H_ */
@@ -0,0 +1,607 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/hie.h>
#include "mtk_secure_api.h"
#include <mmc/core/queue.h>
/* map from AES Spec */
enum {
MSDC_CRYPTO_XTS_AES = 4,
MSDC_CRYPTO_AES_CBC_ESSIV = 9,
MSDC_CRYPTO_BITLOCKER = 17,
MSDC_CRYPTO_AES_ECB = 0,
MSDC_CRYPTO_AES_CBC = 1,
MSDC_CRYPTO_AES_CTR = 2,
MSDC_CRYPTO_AES_CBC_MAC = 3,
} aes_mode;
enum {
BIT_128 = 0,
BIT_192 = 1,
BIT_256 = 2,
BIT_0 = 4,
};
#if defined(CONFIG_MTK_HW_FDE)
static inline bool check_fde_mode(struct request *req,
unsigned int *key_idx)
{
if (req->bio && req->bio->bi_hw_fde) {
if (key_idx)
*key_idx = req->bio->bi_key_idx;
return true;
}
return false;
}
#else
static inline bool check_fde_mode(struct request *req,
unsigned int *key_idx)
{
return false;
}
#endif
static inline bool check_fbe_mode(struct request *req)
{
if (hie_request_crypted(req))
return true;
return false;
}
static void msdc_enable_crypto(struct msdc_host *host)
{
void __iomem *base = host->base;
/* enable AES path by clr bypass bit */
MSDC_CLR_BIT32(EMMC52_AES_SWST, EMMC52_AES_BYPASS);
}
static void msdc_disable_crypto(struct msdc_host *host)
{
void __iomem *base = host->base;
/* disable AES path by set bypass bit */
MSDC_SET_BIT32(EMMC52_AES_SWST, EMMC52_AES_BYPASS);
}
#ifdef CONFIG_MTK_EMMC_HW_CQ
/* HCI crypto start */
/* crypto context fields in cmdq data command task descriptor */
#define DATA_UNIT_NUM(x) (((u64)(x) & 0xFFFFFFFF) << 0)
#define CRYPTO_CONFIG_INDEX(x) (((u64)(x) & 0xFF) << 32)
#define CRYPTO_ENABLE(x) (((u64)(x) & 0x1) << 47)
union cqhci_cpt_capx {
u32 capx_raw;
struct {
u8 alg_id;
u8 du_size;
u8 key_size;
u8 resv;
} capx;
};
/* multi_host/resv1/vsb/resv2 don't use,
*just for use the same structure as UFS
*/
union cqhci_cap_cfg {
u32 cfgx_raw[32];
struct {
u32 key[16];
u8 du_size;
u8 cap_id;
u16 resv0:15;
u16 cfg_en:1;
u8 mu1ti_host;
u8 resv1;
u16 vsb;
u32 resv2[14];
} cfgx;
};
struct cqhci_crypto {
u32 cfg_id;
u32 cap_id;
union cqhci_cpt_cap cap;
union cqhci_cpt_capx capx;
union cqhci_cap_cfg cfg;
};
/* capability id */
enum {
CQHCI_CRYPTO_AES_XTS_128 = 0,
CQHCI_CRYPTO_AES_XTS_256 = 1,
CQHCI_CRYPTO_BITLOCKER_AES_CBC_128 = 2,
CQHCI_CRYPTO_BITLOCKER_AES_CBC_256 = 3,
CQHCI_CRYPTO_AES_ECB_128 = 4,
CQHCI_CRYPTO_AES_ECB_192 = 5,
CQHCI_CRYPTO_AES_ECB_256 = 6,
CQHCI_CRYPTO_ESSIV_AES_CBC_128 = 7,
CQHCI_CRYPTO_ESSIV_AES_CBC_192 = 8,
CQHCI_CRYPTO_ESSIV_AES_CBC_256 = 9,
};
/* data unit size */
enum {
CQHCI_CRYPTO_DU_SIZE_512B = 0,
};
static int msdc_cqhci_fde_init(struct msdc_host *host,
unsigned int key_idx)
{
if ((!host->is_crypto_init ||
(host->key_idx != key_idx))) {
/* cqhci fde init */
mt_secure_call(MTK_SIP_KERNEL_HW_FDE_MSDC_CTL,
(1 << 5), 4, 1, 0);
host->is_crypto_init = true;
host->key_idx = key_idx;
}
return 0;
}
static int msdc_cqhci_fbe_init(struct msdc_host *host,
struct request *req)
{
int err = 0;
if (!host->is_crypto_init) {
/* fbe init */
mt_secure_call(MTK_SIP_KERNEL_HW_FDE_MSDC_CTL,
(1 << 0), 4, 1, 0);
host->is_crypto_init = true;
}
if (rq_data_dir(req) == WRITE)
err = hie_encrypt(msdc_hie_get_dev(),
req, host);
else
err = hie_decrypt(msdc_hie_get_dev(),
req, host);
if (err) {
err = -EIO;
ERR_MSG("%s %d: req: %p, err %d\n",
__func__, __LINE__, req, err);
WARN_ON(1);
}
return err;
}
static int msdc_cqhci_crypto_cfg(struct mmc_host *mmc,
struct mmc_request *mrq, u32 slot, u64 *ctx)
{
struct msdc_host *host = mmc_priv(mmc);
sector_t lba = 0;
unsigned int key_idx;
int err = 0, cc_idx = slot;
bool c_en = false;
struct request *req;
if (WARN_ON(!mrq))
return -EINVAL;
req = mrq->req;
if (req) {
lba = blk_rq_pos(req);
if (check_fde_mode(req, &key_idx)) {
err = msdc_cqhci_fde_init(host, key_idx);
/* use slot 0 for fde mode */
cc_idx = 0;
c_en = true;
} else if (check_fbe_mode(req)) {
u64 hw_hie_iv_num;
err = msdc_cqhci_fbe_init(host, req);
cc_idx = slot;
c_en = true;
hw_hie_iv_num = hie_get_iv(req);
if (hw_hie_iv_num)
lba = hw_hie_iv_num;
}
}
if (ctx)
*ctx = DATA_UNIT_NUM(lba) |
CRYPTO_CONFIG_INDEX(cc_idx) |
CRYPTO_ENABLE(!!c_en);
return err;
}
#endif
static void msdc_crypto_switch_config(struct msdc_host *host,
struct request *req,
u32 block_address, u32 dir)
{
void __iomem *base = host->base;
u32 aes_mode_current = 0, aes_sw_reg = 0;
u32 ctr[4] = {0};
unsigned long polling_tmo = 0;
u64 hw_hie_iv_num = 0;
/* 1. set ctr */
aes_sw_reg = MSDC_READ32(EMMC52_AES_EN);
hw_hie_iv_num = hie_get_iv(req);
if (aes_sw_reg & EMMC52_AES_SWITCH_VALID0)
MSDC_GET_FIELD(EMMC52_AES_CFG_GP0,
EMMC52_AES_MODE_0, aes_mode_current);
else if (aes_sw_reg & EMMC52_AES_SWITCH_VALID1)
MSDC_GET_FIELD(EMMC52_AES_CFG_GP1,
EMMC52_AES_MODE_1, aes_mode_current);
else {
pr_info("msdc: EMMC52_AES_SWITCH_VALID error\n");
WARN_ON(1);
return;
}
switch (aes_mode_current) {
case MSDC_CRYPTO_XTS_AES:
case MSDC_CRYPTO_AES_CBC_ESSIV:
case MSDC_CRYPTO_BITLOCKER:
{
if (hw_hie_iv_num) {
ctr[0] = hw_hie_iv_num & 0xffffffff;
#ifndef CONFIG_MTK_EMMC_HW_CQ
ctr[1] = (hw_hie_iv_num >> 32) & 0xffffffff;
#endif
} else {
ctr[0] = block_address;
}
break;
}
case MSDC_CRYPTO_AES_ECB:
case MSDC_CRYPTO_AES_CBC:
break;
case MSDC_CRYPTO_AES_CTR:
{
if (hw_hie_iv_num) {
ctr[0] = hw_hie_iv_num & 0xffffffff;
ctr[1] = (hw_hie_iv_num >> 32) & 0xffffffff;
} else {
ctr[0] = block_address;
}
break;
}
case MSDC_CRYPTO_AES_CBC_MAC:
break;
default:
pr_info("msdc unknown aes mode\n");
WARN_ON(1);
return;
}
if (aes_sw_reg & EMMC52_AES_SWITCH_VALID0) {
MSDC_WRITE32(EMMC52_AES_CTR0_GP0, ctr[0]);
MSDC_WRITE32(EMMC52_AES_CTR1_GP0, ctr[1]);
MSDC_WRITE32(EMMC52_AES_CTR2_GP0, ctr[2]);
MSDC_WRITE32(EMMC52_AES_CTR3_GP0, ctr[3]);
} else {
MSDC_WRITE32(EMMC52_AES_CTR0_GP1, ctr[0]);
MSDC_WRITE32(EMMC52_AES_CTR1_GP1, ctr[1]);
MSDC_WRITE32(EMMC52_AES_CTR2_GP1, ctr[2]);
MSDC_WRITE32(EMMC52_AES_CTR3_GP1, ctr[3]);
}
/* 2. enable AES path */
msdc_enable_crypto(host);
/* 3. AES switch start (flush the configure) */
if (dir == DMA_TO_DEVICE) {
MSDC_SET_BIT32(EMMC52_AES_SWST,
EMMC52_AES_SWITCH_START_ENC);
polling_tmo = jiffies + POLLING_BUSY;
while (MSDC_READ32(EMMC52_AES_SWST) &
EMMC52_AES_SWITCH_START_ENC) {
if (time_after(jiffies, polling_tmo)) {
pr_info("msdc%d trigger AES ENC tmo!\n",
host->id);
WARN_ON(1);
}
}
} else {
MSDC_SET_BIT32(EMMC52_AES_SWST,
EMMC52_AES_SWITCH_START_DEC);
polling_tmo = jiffies + POLLING_BUSY;
while (MSDC_READ32(EMMC52_AES_SWST) &
EMMC52_AES_SWITCH_START_DEC) {
if (time_after(jiffies, polling_tmo)) {
pr_info("msdc%d trigger AES DEC tmo!\n",
host->id);
WARN_ON(1);
}
}
}
}
static void msdc_pre_crypto(struct mmc_host *mmc, struct mmc_request *mrq)
{
struct msdc_host *host = mmc_priv(mmc);
struct mmc_command *cmd = mrq->cmd;
u32 dir = DMA_FROM_DEVICE;
u32 blk_addr = 0;
u32 is_fde = 0, is_fbe = 0;
unsigned int key_idx;
int err;
struct mmc_blk_request *brq;
struct mmc_queue_req *mq_rq = NULL;
#ifdef CONFIG_MTK_EMMC_CQ_SUPPORT
struct mmc_async_req *areq;
#endif
struct request *req = NULL;
if (!host->hw || !mmc->card)
return;
if (host->hw->host_function != MSDC_EMMC)
return;
#ifdef CONFIG_MTK_EMMC_CQ_SUPPORT
/* CMDQ Command */
if (check_mmc_cmd4647(cmd->opcode)) {
areq = mmc->areq_que[(cmd->arg >> 16) & 0x1f];
mq_rq = container_of(areq, struct mmc_queue_req, areq);
blk_addr = mq_rq->brq.que.arg;
req = mmc_queue_req_to_req(mq_rq);
goto check_hw_crypto;
}
#endif
/* Normal Read Write Command */
if (mrq->is_mmc_req &&
(check_mmc_cmd1718(cmd->opcode) ||
check_mmc_cmd2425(cmd->opcode))) {
brq = container_of(mrq, struct mmc_blk_request, mrq);
mq_rq = container_of(brq, struct mmc_queue_req, brq);
blk_addr = cmd->arg;
req = mmc_queue_req_to_req(mq_rq);
goto check_hw_crypto;
}
return;
check_hw_crypto:
dir = cmd->data->flags & MMC_DATA_READ ?
DMA_FROM_DEVICE : DMA_TO_DEVICE;
if (check_fde_mode(req, &key_idx))
is_fde = 1;
else if (check_fbe_mode(req))
is_fbe = 1;
if (is_fde || is_fbe) {
if (is_fde &&
(!host->is_crypto_init ||
(host->key_idx != key_idx))) {
/* fde init */
mt_secure_call(MTK_SIP_KERNEL_HW_FDE_MSDC_CTL,
(1 << 3), 4, 1, 0);
host->is_crypto_init = true;
host->key_idx = key_idx;
}
if (is_fbe) {
if (!host->is_crypto_init) {
/* fbe init */
mt_secure_call(MTK_SIP_KERNEL_HW_FDE_MSDC_CTL,
(1 << 0), 4, 1, 0);
host->is_crypto_init = true;
}
if (dir == DMA_TO_DEVICE)
err = hie_encrypt(msdc_hie_get_dev(), req,
host);
else
err = hie_decrypt(msdc_hie_get_dev(), req,
host);
if (err) {
err = -EIO;
ERR_MSG(
"%s: fail in crypto hook, req: %p, err %d\n",
__func__, req, err);
WARN_ON(1);
return;
}
if (hie_is_nocrypt())
return;
if (hie_is_dummy()) {
struct mmc_data *data = cmd->data;
if (dir == DMA_TO_DEVICE &&
msdc_use_async_dma(data->host_cookie)) {
dma_unmap_sg(mmc_dev(mmc), data->sg,
data->sg_len, dir);
dma_map_sg(mmc_dev(mmc), data->sg,
data->sg_len, dir);
}
return;
}
}
if (!mmc_card_blockaddr(mmc->card))
blk_addr = blk_addr >> 9;
/* Check data size with 16bytes */
WARN_ON(host->dma.xfersz & 0xf);
/* Check data addressw with 16bytes alignment */
WARN_ON((host->dma.gpd_addr & 0xf)
|| (host->dma.bd_addr & 0xf));
msdc_crypto_switch_config(host, req, blk_addr, dir);
}
}
static void msdc_post_crypto(struct msdc_host *host)
{
msdc_disable_crypto(host);
}
#ifdef CONFIG_MTK_EMMC_HW_CQ
static int _msdc_hie_cqhci_cfg(unsigned int mode, const char *key,
int len, struct request *req, void *priv)
{
struct msdc_host *host = (struct msdc_host *)priv;
struct mmc_host *mmc = host->mmc;
struct cmdq_host *cq_host = (struct cmdq_host *)mmc_cmdq_private(mmc);
u32 addr, i, cpt_mode, cc_idx;
union cqhci_cpt_cap cpt_cap;
union cqhci_cap_cfg cpt_cfg;
if (mode & BC_AES_256_XTS) {
cpt_mode = CQHCI_CRYPTO_AES_XTS_256;
WARN_ON(len != 64);
} else if (mode & BC_AES_128_XTS) {
cpt_mode = CQHCI_CRYPTO_AES_XTS_128;
WARN_ON(len != 32);
} else {
ERR_MSG("%s: unknown mode 0x%x\n", __func__, mode);
WARN_ON(1);
return -EIO;
}
memset(&cpt_cfg, 0, sizeof(cpt_cfg));
/* init key */
if (len > 64) {
pr_notice("Key size is over %d bits\n", len * 8);
len = 64;
}
memcpy((void *)&(cpt_cfg.cfgx.key[0]), &key[0], len);
#ifdef _CQHCI_DEBUG
for (i = 0; i < len / 4; i++) {
pr_notice("%s: REG[%02d] = 0x%x\n", __func__, i,
cpt_cfg.cfgx.key[i]);
}
#endif
/* cc idx is same as slot no. or tag no. */
cc_idx = req->tag;
/* enable this cfg */
cpt_cfg.cfgx.cfg_en = 1;
/* init capability id */
cpt_cfg.cfgx.cap_id = (u8)cpt_mode;
/* init data unit size: fixed as 512 * 2^0) for eMMC */
cpt_cfg.cfgx.du_size = (1 << CQHCI_CRYPTO_DU_SIZE_512B);
/*
* Get address of cfg[cfg_id], this is also
* address of key in cfg[cfg_id].
*/
cpt_cap.cap_raw = cmdq_readl(cq_host, CRCAP);
addr = (cpt_cap.cap.cfg_ptr << 8) + (u32)(cc_idx << 7);
/* write configuration only to register */
for (i = 0; i < 32; i++) {
cmdq_writel(cq_host, cpt_cfg.cfgx_raw[i],
(addr + i * 4));
#ifdef _CQHCI_DEBUG
pr_notice("%s: (%d)REG[0x%x]=0x%x\n",
__func__, cc_idx,
(addr + i * 4),
cpt_cfg.cfgx_raw[i]);
#endif
}
return 0;
}
#endif
static int _msdc_hie_cfg(unsigned int mode, const char *key,
int len, struct request *req, void *priv)
{
struct msdc_host *host = (struct msdc_host *)priv;
void __iomem *base = host->base;
u32 iv[4] = {0}, aes_key[8] = {0}, aes_tkey[8] = {0};
u32 data_unit_size, i, half_len;
u8 key_bit, aes_mode;
if (mode & BC_AES_256_XTS) {
aes_mode = MSDC_CRYPTO_XTS_AES;
key_bit = BIT_256;
WARN_ON(len != 64);
} else if (mode & BC_AES_128_XTS) {
aes_mode = MSDC_CRYPTO_XTS_AES;
key_bit = BIT_128;
WARN_ON(len != 32);
} else {
ERR_MSG("%s: unknown mode 0x%x\n", __func__, mode);
WARN_ON(1);
return -EIO;
}
/*
* limit half_len as u32 * 8
* prevent local buffer overflow
*/
half_len = min_t(u32, len / 2, sizeof(u32) * 8);
/* Split key into key & tkey */
memcpy(aes_key, &key[0], half_len);
memcpy(aes_tkey, &key[half_len], half_len);
/* eMMC block size 512bytes */
data_unit_size = (1 << 9);
/* AES config */
MSDC_WRITE32(EMMC52_AES_CFG_GP1,
(data_unit_size << 16 | key_bit << 8 | aes_mode << 0));
/* IV */
for (i = 0; i < 4; i++)
MSDC_WRITE32((EMMC52_AES_IV0_GP1 + i * 4), iv[i]);
/* KEY */
for (i = 0; i < 8; i++)
MSDC_WRITE32((EMMC52_AES_KEY0_GP1 + i * 4), aes_key[i]);
/* TKEY */
for (i = 0; i < 8; i++)
MSDC_WRITE32((EMMC52_AES_TKEY0_GP1 + i * 4), aes_tkey[i]);
return 0;
}
/* configure request for HIE */
static int msdc_hie_cfg_request(unsigned int mode, const char *key,
int len, struct request *req, void *priv)
{
#ifdef CONFIG_MTK_EMMC_HW_CQ
struct msdc_host *host = (struct msdc_host *)priv;
if (mmc_card_cmdq(host->mmc->card))
_msdc_hie_cqhci_cfg(mode, key, len, req, priv);
else
#endif
_msdc_hie_cfg(mode, key, len, req, priv);
return 0;
}
struct hie_dev msdc_hie_dev = {
.name = "msdc",
.mode = (BC_AES_256_XTS | BC_AES_128_XTS),
.encrypt = msdc_hie_cfg_request,
.decrypt = msdc_hie_cfg_request,
.priv = NULL,
};
struct hie_dev *msdc_hie_get_dev(void)
{
return &msdc_hie_dev;
}
static void msdc_hie_register(struct msdc_host *host)
{
if (host->hw->host_function == MSDC_EMMC)
hie_register_device(&msdc_hie_dev);
}
+775
View File
@@ -0,0 +1,775 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef MT_SD_H
#define MT_SD_H
#ifdef CONFIG_FPGA_EARLY_PORTING
#ifndef FPGA_PLATFORM
#define FPGA_PLATFORM
#endif
#else
/* #define MTK_MSDC_BRINGUP_DEBUG */
#endif
#include <mt-plat/sync_write.h>
#include <linux/bitops.h>
#include <linux/mmc/host.h>
#include <linux/mmc/mmc.h>
#include <linux/pm_qos.h>
#include "msdc_cust.h"
#include "autok.h"
#include "autok_dvfs.h"
#include "sw-cqhci-crypto.h"
#if defined(CONFIG_MTK_HW_FDE) && defined(CONFIG_MTK_HW_FDE_AES)
#include <fde_aes.h>
#include <fde_aes_dbg.h>
#endif
#if defined(CONFIG_MTK_EMMC_CQ_SUPPORT) && defined(CONFIG_MTK_EMMC_HW_CQ)
#error "MTK_EMMC_CQ_SUPPORT & MTK_EMMC_HW_CQ cannot define at the same time."
#endif
#ifdef CONFIG_PWR_LOSS_MTK_TEST
#include <mach/power_loss_test.h>
#else
#define MVG_EMMC_CHECK_BUSY_AND_RESET(...)
#define MVG_EMMC_SETUP(...)
#define MVG_EMMC_RESET(...)
#define MVG_EMMC_WRITE_MATCH(...)
#define MVG_EMMC_ERASE_MATCH(...)
#define MVG_EMMC_ERASE_RESET(...)
#define MVG_EMMC_DECLARE_INT32(...)
#endif
/* #define MSDC_SWITCH_MODE_WHEN_ERROR */
#define TUNE_NONE (0) /* No need tune */
#define TUNE_ASYNC_CMD (0x1 << 0) /* async transfer cmd crc */
#define TUNE_ASYNC_DATA_WRITE (0x1 << 1) /* async transfer data crc */
#define TUNE_ASYNC_DATA_READ (0x1 << 2) /* async transfer data crc */
#define TUNE_LEGACY_CMD (0x1 << 3) /* legacy transfer cmd crc */
#define TUNE_LEGACY_DATA_WRITE (0x1 << 4) /* legacy transfer data crc */
#define TUNE_LEGACY_DATA_READ (0x1 << 5) /* legacy transfer data crc */
#define TUNE_LEGACY_CMD_TMO (0x1 << 6) /* legacy transfer cmd tmo */
#define TUNE_AUTOK_PASS (0x1 << 7) /* autok pass flag */
#ifdef CONFIG_MTK_MMC_DEBUG
#define MSDC_DMA_ADDR_DEBUG
/* #define MTK_MSDC_LOW_IO_DEBUG */
#ifdef CONFIG_MTK_EMMC_HW_CQ
#undef MTK_MSDC_LOW_IO_DEBUG
#endif
#endif
/* #define MTK_MMC_SDIO_DEBUG */
#define MTK_MSDC_USE_CMD23
#if !defined(CONFIG_PWR_LOSS_MTK_TEST) && defined(MTK_MSDC_USE_CMD23) \
|| defined(CONFIG_MTK_EMMC_HW_CQ)
//#define MTK_MSDC_USE_CACHE
#endif
#ifdef MTK_MSDC_USE_CMD23
#define MSDC_USE_AUTO_CMD23 (1)
#endif
/* ================================= */
#define MAX_GPD_NUM (1 + 1) /* one null gpd */
#define MAX_BD_NUM (128)
#define MAX_BD_PER_GPD (MAX_BD_NUM)
#define CLK_SRC_MAX_NUM (1)
#define SDIO_ERROR_BYPASS
/* #define SDIO_EARLY_SETTING_RESTORE */
/* #define MMC_K44_RETUNE */
/* #define MTK_MSDC_DUMP_FIFO */
/*--------------------------------------------------------------------------*/
/* Common Macro */
/*--------------------------------------------------------------------------*/
#define REG_ADDR(x) (base + OFFSET_##x)
#define REG_ADDR_TOP(x) (base_top + OFFSET_##x)
/*--------------------------------------------------------------------------*/
/* Common Definition */
/*--------------------------------------------------------------------------*/
#define MSDC_FIFO_SZ (128)
#define MSDC_FIFO_THD (64) /* (128) */
#define MSDC_NUM (4)
/* No memory stick mode, 0 use to gate clock */
#define MSDC_MS (0)
#define MSDC_SDMMC (1)
#define MSDC_MODE_UNKNOWN (0)
#define MSDC_MODE_PIO (1)
#define MSDC_MODE_DMA_BASIC (2)
#define MSDC_MODE_DMA_DESC (3)
#define MSDC_BUS_1BITS (0)
#define MSDC_BUS_4BITS (1)
#define MSDC_BUS_8BITS (2)
#define MSDC_BRUST_8B (3)
#define MSDC_BRUST_16B (4)
#define MSDC_BRUST_32B (5)
#define MSDC_BRUST_64B (6)
#define MSDC_AUTOCMD12 (0x0001)
#define MSDC_AUTOCMD23 (0x0002)
#define MSDC_AUTOCMD19 (0x0003)
#define MSDC_AUTOCMD53 (0x0004)
enum {
RESP_NONE = 0,
RESP_R1,
RESP_R2,
RESP_R3,
RESP_R4,
RESP_R5,
RESP_R6,
RESP_R7,
RESP_R1B
};
#include "msdc_reg.h"
/* MSDC_CFG[START_BIT] value */
#define START_AT_RISING (0x0)
#define START_AT_FALLING (0x1)
#define START_AT_RISING_AND_FALLING (0x2)
#define START_AT_RISING_OR_FALLING (0x3)
#define TYPE_CMD_RESP_EDGE (0)
#define TYPE_WRITE_CRC_EDGE (1)
#define TYPE_READ_DATA_EDGE (2)
#define CARD_READY_FOR_DATA (1<<8)
#define CARD_CURRENT_STATE(x) ((x&0x00001E00)>>9)
#define REQ_CMD_EIO (0x1 << 0)
#define REQ_CMD_TMO (0x1 << 1)
#define REQ_DAT_ERR (0x1 << 2)
#define REQ_STOP_EIO (0x1 << 3)
#define REQ_STOP_TMO (0x1 << 4)
#define REQ_CMD23_EIO (0x1 << 5)
#define REQ_CMD23_TMO (0x1 << 6)
#define REQ_CRC_STATUS_ERR (0x1 << 7)
typedef void (*sdio_irq_handler_t)(void *); /* external irq handler */
typedef void (*pm_callback_t)(pm_message_t state, void *data);
#define MSDC_CD_PIN_EN (1 << 0) /* card detection pin is wired */
#define MSDC_WP_PIN_EN (1 << 1) /* write protection pin is wired */
#define MSDC_RST_PIN_EN (1 << 2) /* emmc reset pin is wired */
#define MSDC_SDIO_IRQ (1 << 3) /* use internal sdio irq (bus) */
#define MSDC_EXT_SDIO_IRQ (1 << 4) /* use external sdio irq */
#define MSDC_REMOVABLE (1 << 5) /* removable slot */
#define MSDC_SDIO_DDR208 (1 << 7) /* ddr208 mode used by 6632 */
#define MSDC_VMCH_FASTOFF (1 << 8) /* vmch fastoff when plug ot card */
/* for some board, need SD power always on!! or cannot recognize the sd card*/
#define MSDC_SD_NEED_POWER (1 << 31)
#define MSDC_BOOT_EN (1)
struct msdc_hw_driving {
unsigned char cmd_drv; /* command pad driving */
unsigned char dat_drv; /* data pad driving */
unsigned char clk_drv; /* clock pad driving */
unsigned char rst_drv; /* RST-N pad driving */
unsigned char ds_drv; /* eMMC5.0 DS pad driving */
};
struct msdc_hw {
unsigned char clk_src; /* host clock source */
unsigned char cmd_edge; /* command latch edge */
unsigned char rdata_edge; /* read data latch edge */
unsigned char wdata_edge; /* write data latch edge */
struct msdc_hw_driving *driving_applied;
struct msdc_hw_driving driving;
struct msdc_hw_driving driving_sdr104;
struct msdc_hw_driving driving_sdr50;
struct msdc_hw_driving driving_ddr50;
struct msdc_hw_driving driving_hs400;
struct msdc_hw_driving driving_hs200;
unsigned long flags; /* hardware capability flags */
unsigned char boot; /* define boot host */
unsigned char host_function; /* define host function */
unsigned char cd_level; /* card detection level */
/* external sdio irq operations */
void (*request_sdio_eirq)(sdio_irq_handler_t sdio_irq_handler,
void *data);
void (*enable_sdio_eirq)(void);
void (*disable_sdio_eirq)(void);
/* power management callback for external module */
void (*register_pm)(pm_callback_t pm_cb, void *data);
};
/*--------------------------------------------------------------------------*/
/* Descriptor Structure */
/*--------------------------------------------------------------------------*/
struct gpd_t {
u32 hwo:1; /* could be changed by hw */
u32 bdp:1;
u32 rsv0:6;
u32 chksum:8;
u32 intr:1;
u32 rsv1:7;
u32 nexth4:4;
u32 ptrh4:4;
u32 next;
u32 ptr;
u32 buflen:24;
u32 extlen:8;
};
struct bd_t {
u32 eol:1;
u32 rsv0:7;
u32 chksum:8;
u32 rsv1:1;
u32 blkpad:1;
u32 dwpad:1;
u32 rsv2:5;
u32 nexth4:4;
u32 ptrh4:4;
u32 next;
u32 ptr;
u32 buflen:24;
u32 rsv3:8;
};
#define DMA_FLAG_NONE (0x00000000)
#define DMA_FLAG_EN_CHKSUM (0x00000001)
#define DMA_FLAG_PAD_BLOCK (0x00000002)
#define DMA_FLAG_PAD_DWORD (0x00000004)
struct msdc_dma {
u32 flags; /* flags */
u32 xfersz; /* xfer size in bytes */
u32 sglen; /* size of scatter list */
u32 blklen; /* block size */
struct scatterlist *sg; /* I/O scatter list */
u8 mode; /* dma mode */
u8 burstsz; /* burst size */
u8 intr; /* dma done interrupt */
struct gpd_t *gpd; /* pointer to gpd array */
struct bd_t *bd; /* pointer to bd array */
dma_addr_t gpd_addr; /* the physical address of gpd array */
dma_addr_t bd_addr; /* the physical address of bd array */
u32 used_gpd; /* the number of used gpd elements */
u32 used_bd; /* the number of used bd elements */
};
/* FIX ME, consider to move it into msdc_tune.c */
struct msdc_saved_para {
u32 pad_tune0;
u32 pad_tune1;
u8 suspend_flag;
u32 msdc_cfg;
u32 sdc_cfg;
u32 iocon;
u8 timing;
u32 hz;
u8 inten_sdio_irq;
u8 ds_dly1;
u8 ds_dly3;
u32 emmc50_pad_cmd_tune;
u32 emmc50_dat01;
u32 emmc50_dat23;
u32 emmc50_dat45;
u32 emmc50_dat67;
u32 emmc50_cfg0;
u32 pb0;
u32 pb1;
u32 pb2;
u32 sdc_fifo_cfg;
u32 sdc_adv_cfg0;
/* msdc top reg */
u32 emmc_top_control;
u32 emmc_top_cmd;
u32 top_emmc50_pad_ctl0;
u32 top_emmc50_pad_ds_tune;
u32 top_emmc50_pad_dat_tune[8];
};
struct msdc_host {
struct msdc_hw *hw;
struct mmc_host *mmc; /* mmc structure */
struct mmc_command *cmd;
struct mmc_data *data;
struct mmc_request *mrq;
ulong *pio_kaddr;
int err_cmd;
int cmd_rsp;
int error;
spinlock_t lock; /* mutex */
spinlock_t reg_lock;
/* to solve removing bad card
* race condition with hot-plug enable
*/
spinlock_t remove_bad_card;
#ifdef CONFIG_MTK_EMMC_HW_CQ
spinlock_t cmd_dump_lock;
#endif
/* avoid race condition at DAT1 interrupt case*/
spinlock_t sdio_irq_lock;
int clk_gate_count;
struct semaphore sem;
u32 blksz; /* host block size */
void __iomem *base; /* host base address */
void __iomem *base_top; /* base address for msdc_top*/
int id; /* host id */
u32 xfer_size; /* total transferred size */
struct msdc_dma dma; /* dma channel */
u64 dma_mask;
int dma_xfer; /* dma transfer mode */
u32 timeout_ns; /* data timeout ns */
u32 timeout_clks; /* data timeout clks */
atomic_t abort; /* abort transfer */
int irq; /* host interrupt */
struct delayed_work set_vcore_workq;
struct completion autok_done;
struct completion xfer_done;
u32 mclk; /* mmc subsystem clock */
u32 hclk; /* host clock speed */
u32 sclk; /* SD/MS clock speed */
u8 timing; /* timing specification used */
u8 power_mode; /* host power mode */
u8 bus_width;
u8 card_inserted; /* card inserted ? */
u8 autocmd;
u8 app_cmd; /* for app command */
u32 app_cmd_arg;
u32 intsts; /* raw insts */
bool use_cmd_intr; /* cmd intr mode */
struct completion cmd_done;
u32 busy_timeout_ms;/* check device busy */
u32 max_busy_timeout_ms;
int pin_state; /* for hw trapping */
u32 sw_timeout;
#ifdef SDCARD_ESD_RECOVERY
/* cmd13 contunous timeout, clear when any other cmd succeed */
u32 cmd13_timeout_cont;
#endif
u32 data_timeout_cont; /* data continuous timeout */
bool tuning_in_progress;
u32 need_tune;
int autok_error;
int reautok_times;
int power_cycle_cnt;
bool is_autok_done;
u8 use_hw_dvfs;
u8 lock_vcore;
/************************ +1 for merge ****************************************/
u8 autok_res[AUTOK_VCORE_NUM+1][TUNING_PARA_SCAN_COUNT];
u16 dvfs_reg_backup_cnt;
u16 dvfs_reg_backup_cnt_top;
u32 *dvfs_reg_backup;
u16 *dvfs_reg_offsets;
u16 *dvfs_reg_offsets_src;
u16 *dvfs_reg_offsets_top;
u32 device_status;
int tune_smpl_times;
u32 tune_latch_ck_cnt;
struct msdc_saved_para saved_para;
struct wakeup_source *trans_lock;
bool block_bad_card;
struct delayed_work remove_card; /* remove bad card */
u32 data_timeout_ms; /* timeout ms for worker */
struct delayed_work data_timeout_work; /* data timeout worker */
#ifdef SDIO_ERROR_BYPASS
int sdio_error; /* sdio error can't recovery */
#endif
void (*power_control)(struct msdc_host *host, u32 on);
int (*power_switch)(struct msdc_host *host, u32 on);
u32 power_io;
u32 power_flash;
struct pm_qos_request msdc_pm_qos_req; /* use for pm qos */
struct clk *clk_ctl;
struct clk *aes_clk_ctl;
struct clk *hclk_ctl;
struct delayed_work work_init; /* for init mmc_host */
struct delayed_work work_sdio; /* for DVFS kickoff */
struct platform_device *pdev;
int prev_cmd_cause_dump;
#ifdef CONFIG_MTK_EMMC_CQ_SUPPORT
atomic_t cq_error_need_stop;
#endif
#if defined(CONFIG_MTK_HW_FDE) \
&& !defined(CONFIG_MTK_HW_FDE_AES)
bool is_crypto_init;
u32 key_idx;
#endif
u32 dma_cnt;
u64 start_dma_time;
u64 stop_dma_time;
/* flag to record if eMMC will enter hs400 mode */
bool hs400_mode;
#ifdef CONFIG_MTK_EMMC_HW_CQ
struct cmdq_host *cq_host;
#endif
};
enum {
OPER_TYPE_READ,
OPER_TYPE_WRITE,
OPER_TYPE_NUM
};
struct dma_addr {
u32 start_address;
u32 size;
u8 end;
struct dma_addr *next;
};
static inline unsigned int uffs(unsigned int x)
{
unsigned int r = 1;
if (!x)
return 0;
if (!(x & 0xffff)) {
x >>= 16;
r += 16;
}
if (!(x & 0xff)) {
x >>= 8;
r += 8;
}
if (!(x & 0xf)) {
x >>= 4;
r += 4;
}
if (!(x & 3)) {
x >>= 2;
r += 2;
}
if (!(x & 1)) {
x >>= 1;
r += 1;
}
return r;
}
#define MSDC_READ8(reg) __raw_readb(reg)
#define MSDC_READ16(reg) __raw_readw(reg)
#define MSDC_READ32(reg) __raw_readl(reg)
#define MSDC_WRITE8(reg, val) mt_reg_sync_writeb(val, reg)
#define MSDC_WRITE16(reg, val) mt_reg_sync_writew(val, reg)
#define MSDC_WRITE32(reg, val) mt_reg_sync_writel(val, reg)
#define UNSTUFF_BITS(resp, start, size) \
({ \
const int __size = size; \
const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \
const int __off = 3 - ((start) / 32); \
const int __shft = (start) & 31; \
u32 __res; \
__res = resp[__off] >> __shft; \
if (__size + __shft > 32) \
__res |= resp[__off-1] << ((32 - __shft) % 32); \
__res & __mask; \
})
#define MSDC_SET_BIT32(reg, bs) \
do { \
unsigned int tv = MSDC_READ32(reg);\
tv |= (u32)(bs); \
MSDC_WRITE32(reg, tv); \
} while (0)
#define MSDC_CLR_BIT32(reg, bs) \
do { \
unsigned int tv = MSDC_READ32(reg);\
tv &= ~((u32)(bs)); \
MSDC_WRITE32(reg, tv); \
} while (0)
#define MSDC_SET_FIELD(reg, field, val) \
do { \
unsigned int tv = MSDC_READ32(reg); \
tv &= ~(field); \
tv |= ((val) << (uffs((unsigned int)field) - 1)); \
MSDC_WRITE32(reg, tv); \
} while (0)
#define MSDC_GET_FIELD(reg, field, val) \
do { \
unsigned int tv = MSDC_READ32(reg); \
val = ((tv & (field)) >> (uffs((unsigned int)field) - 1)); \
} while (0)
#define GET_FIELD(reg, field_shift, field_mask, val) \
(val = (reg >> field_shift) & field_mask)
#define sdc_is_busy() (MSDC_READ32(SDC_STS) & SDC_STS_SDCBUSY)
#define sdc_is_cmd_busy() (MSDC_READ32(SDC_STS) & SDC_STS_CMDBUSY)
#ifdef CONFIG_MTK_EMMC_CQ_SUPPORT
#define sdc_send_cmdq_cmd(opcode, arg) \
do { \
MSDC_SET_FIELD(EMMC51_CFG0, MSDC_EMMC51_CFG_CMDQEN \
| MSDC_EMMC51_CFG_NUM | MSDC_EMMC51_CFG_RSPTYPE \
| MSDC_EMMC51_CFG_DTYPE, (0x81) | (opcode << 1)); \
MSDC_WRITE32(SDC_ARG, (arg)); \
MSDC_WRITE32(SDC_CMD, (0x0)); \
} while (0)
#endif
#define sdc_send_cmd(cmd, arg) \
do { \
MSDC_WRITE32(SDC_ARG, (arg)); \
MSDC_WRITE32(SDC_CMD, (cmd)); \
} while (0)
#define msdc_retry(expr, retry, cnt, id) \
do { \
int backup = cnt; \
while (retry) { \
if (!(expr)) \
break; \
if (cnt-- == 0) { \
retry--; mdelay(1); cnt = backup; \
} \
} \
if (retry == 0) { \
msdc_dump_info(NULL, 0, NULL, id); \
} \
WARN_ON(retry == 0); \
} while (0)
#define msdc_reset(id) \
do { \
int retry = 3, cnt = 1000; \
MSDC_SET_BIT32(MSDC_CFG, MSDC_CFG_RST); \
msdc_retry(MSDC_READ32(MSDC_CFG) & MSDC_CFG_RST, retry, \
cnt, id); \
} while (0)
#define msdc_clr_int() \
do { \
u32 val = MSDC_READ32(MSDC_INT); \
MSDC_WRITE32(MSDC_INT, val); \
} while (0)
#define msdc_reset_hw(id) \
do { \
msdc_reset(id); \
msdc_clr_fifo(id); \
msdc_clr_int(); \
} while (0)
#define msdc_txfifocnt() ((MSDC_READ32(MSDC_FIFOCS) \
& MSDC_FIFOCS_TXCNT) >> 16)
#define msdc_rxfifocnt() ((MSDC_READ32(MSDC_FIFOCS) \
& MSDC_FIFOCS_RXCNT) >> 0)
#define msdc_fifo_write32(v) MSDC_WRITE32(MSDC_TXDATA, (v))
#define msdc_fifo_write8(v) MSDC_WRITE8(MSDC_TXDATA, (v))
#define msdc_fifo_read32() MSDC_READ32(MSDC_RXDATA)
#define msdc_fifo_read8() MSDC_READ8(MSDC_RXDATA)
/* can modify to read h/w register.*/
/* #define is_card_present(h) \
* ((MSDC_READ32(MSDC_PS) & MSDC_PS_CDSTS) ? 0 : 1);
*/
#define is_card_present(h) (((struct msdc_host *)(h))->card_inserted)
#define is_card_sdio(h) (((struct msdc_host *)(h))->hw->register_pm)
#define CMD_TIMEOUT (HZ/10 * 5) /* 100ms x5 */
#define CMD_CQ_TIMEOUT (HZ * 3)
#define DAT_TIMEOUT (HZ * 5) /* 1000ms x5 */
#define POLLING_BUSY (HZ * 3)
#define POLLING_PINS (HZ*20 / 1000) /* 20ms */
/* data timeout for worker */
#define DATA_TIMEOUT_MS (1000 * 30) /* 30s */
extern struct msdc_host *mtk_msdc_host[];
extern unsigned int msdc_latest_transfer_mode[HOST_MAX_NUM];
extern u32 latest_int_status[];
extern unsigned int msdc_latest_op[];
extern unsigned int sd_register_zone[];
#ifdef MSDC_DMA_ADDR_DEBUG
extern struct dma_addr msdc_latest_dma_address[MAX_BD_PER_GPD];
#endif
extern int g_dma_debug[HOST_MAX_NUM];
extern u32 g_emmc_mode_switch;
enum {
MODE_PIO = 0,
MODE_DMA = 1,
MODE_SIZE_DEP = 2,
MODE_NONE = 3,
};
extern unsigned int sd_debug_zone[];
extern u32 drv_mode[];
extern u32 dma_size[];
extern int dma_force[];
extern u32 sdio_pro_enable;
extern bool emmc_sleep_failed;
extern int msdc_rsp[];
extern u16 msdc_offsets[];
extern u16 msdc_offsets_top[];
/**********************************************************/
/* Functions */
/**********************************************************/
#include "msdc_io.h"
/* Function provided by sd.c */
int msdc_clk_stable(struct msdc_host *host, u32 mode, u32 div,
u32 hs400_src);
void msdc_clr_fifo(unsigned int id);
unsigned int msdc_do_command(struct msdc_host *host,
struct mmc_command *cmd, unsigned long timeout);
void msdc_dump_info(char **buff, unsigned long *size, struct seq_file *m,
u32 id);
void msdc_dump_register(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host);
void msdc_dump_register_core(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host);
int msdc_execute_tuning(struct mmc_host *mmc, u32 opcode);
int msdc_error_tuning(struct mmc_host *mmc, struct mmc_request *mrq);
int msdc_cache_ctrl(struct msdc_host *host, unsigned int enable,
u32 *status);
int msdc_get_card_status(struct mmc_host *mmc, struct msdc_host *host,
u32 *status);
int msdc_get_dma_status(int host_id);
void msdc_ops_set_ios(struct mmc_host *mmc, struct mmc_ios *ios);
void msdc_select_clksrc(struct msdc_host *host, int clksrc);
void msdc_send_stop(struct msdc_host *host);
void msdc_set_mclk(struct msdc_host *host, unsigned char timing, u32 hz);
void msdc_set_smpl(struct msdc_host *host, u32 clock_mode, u8 mode, u8 type,
u8 *edge);
void msdc_set_smpl_all(struct msdc_host *host, u32 clock_mode);
void msdc_set_check_endbit(struct msdc_host *host, bool enable);
int msdc_switch_part(struct msdc_host *host, char part_id);
#ifdef CONFIG_MTK_EMMC_CQ_SUPPORT
unsigned int msdc_do_cmdq_command(struct msdc_host *host,
struct mmc_command *cmd,
unsigned long timeout);
#endif
/* Function provided by msdc_partition.c */
int msdc_can_apply_cache(unsigned long long start_addr,
unsigned int size);
int msdc_check_otp_ops(unsigned int opcode, unsigned long long start_addr,
unsigned int size);
int msdc_get_part_info(unsigned char *name, struct hd_struct *part);
u64 msdc_get_user_capacity(struct msdc_host *host);
u32 msdc_get_other_capacity(struct msdc_host *host, char *name);
/* Function provided by msdc_tune.c */
int sdcard_hw_reset(struct mmc_host *mmc);
int sdcard_reset_tuning(struct mmc_host *mmc);
int emmc_reinit_tuning(struct mmc_host *mmc);
void msdc_init_tune_setting(struct msdc_host *host);
void msdc_ios_tune_setting(struct msdc_host *host, struct mmc_ios *ios);
void msdc_init_tune_path(struct msdc_host *host, unsigned char timing);
void msdc_sdio_restore_after_resume(struct msdc_host *host);
void msdc_restore_timing_setting(struct msdc_host *host);
void msdc_save_timing_setting(struct msdc_host *host);
void msdc_set_bad_card_and_remove(struct msdc_host *host);
void msdc_remove_card(struct work_struct *work);
void msdc_ops_set_bad_card_and_remove(struct mmc_host *mmc);
/* Function provided by mmc/core/sd.c */
/* FIX ME: maybe removed in kernel 4.4 */
int mmc_sd_power_cycle(struct mmc_host *host, u32 ocr,
struct mmc_card *card);
/* Function provided by mmc/core/bus.c */
void mmc_remove_card(struct mmc_card *card);
#define check_mmc_cache_ctrl(card) \
(card && mmc_card_mmc(card) && (card->ext_csd.cache_ctrl & 0x1))
#define check_mmc_cache_flush_cmd(cmd) \
((cmd->opcode == MMC_SWITCH) && \
(((cmd->arg >> 16) & 0xFF) == EXT_CSD_FLUSH_CACHE) && \
(((cmd->arg >> 8) & 0x1)))
#define check_mmc_cmd001213(opcode) \
((opcode == MMC_GO_IDLE_STATE) || \
(opcode == MMC_STOP_TRANSMISSION) || \
(opcode == MMC_SEND_STATUS))
#define check_mmc_cmd081921(opcode) \
((opcode == MMC_SEND_EXT_CSD) || \
(opcode == MMC_SEND_TUNING_BLOCK) || \
(opcode == MMC_SEND_TUNING_BLOCK_HS200))
#define check_mmc_cmd1718(opcode) \
((opcode == MMC_READ_MULTIPLE_BLOCK) || \
(opcode == MMC_READ_SINGLE_BLOCK))
#define check_mmc_cmd2425(opcode) \
((opcode == MMC_WRITE_MULTIPLE_BLOCK) || \
(opcode == MMC_WRITE_BLOCK))
#define check_mmc_cmd1825(opcode) \
((opcode == MMC_READ_MULTIPLE_BLOCK) || \
(opcode == MMC_WRITE_MULTIPLE_BLOCK))
#define check_mmc_cmd4445(opcode) \
((opcode == MMC_QUE_TASK_PARAMS) || \
(opcode == MMC_QUE_TASK_ADDR))
#define check_mmc_cmd46(opcode) \
(opcode == MMC_EXECUTE_READ_TASK)
#define check_mmc_cmd47(opcode) \
(opcode == MMC_EXECUTE_WRITE_TASK)
#define check_mmc_cmd4647(opcode) \
((opcode == MMC_EXECUTE_READ_TASK) || \
(opcode == MMC_EXECUTE_WRITE_TASK))
#define check_mmc_cmd48(opcode) \
(opcode == MMC_CMDQ_TASK_MGMT)
#define check_mmc_cmd44(x) \
((x) && \
((x)->opcode == MMC_QUE_TASK_PARAMS))
#define check_mmc_cmd13_sqs(x) \
(((x)->opcode == MMC_SEND_STATUS) && \
((x)->arg & (1 << 15)))
#define check_mmc_cmd47(opcode) \
(opcode == MMC_EXECUTE_WRITE_TASK)
#define check_mmc_cmd_r1b(opcode) \
((opcode == MMC_SWITCH) || \
(opcode == MMC_CMDQ_TASK_MGMT))
#endif /* end of MT_SD_H */
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,206 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2019 MediaTek Inc.
*/
#include "mtk_sd.h"
static int msdc_complete_mqr_crypto(struct mmc_host *host)
{
struct msdc_host *ll_host = mmc_priv(host);
/* only for non-cqe, cqe needs nothing */
if ((readl(ll_host->base + MSDC_AES_SWST)
& MSDC_AES_BYPASS) == 0)
/* disable AES path by set bypass bit */
MSDC_SET_BIT32(ll_host->base + MSDC_AES_SWST, MSDC_AES_BYPASS);
return 0;
}
/* non-cqe only set IV here */
static int set_crypto(struct msdc_host *host,
u64 data_unit_num, int ddir)
{
u32 aes_mode_current = 0;
u32 ctr[4] = {0};
unsigned long polling_tmo = 0;
aes_mode_current = MSDC_AES_MODE_1 &
readl(host->base + MSDC_AES_CFG_GP1);
switch (aes_mode_current) {
case MSDC_CRYPTO_ALG_AES_XTS:
{
ctr[0] = data_unit_num & 0xffffffff;
if ((data_unit_num >> 32) & 0xffffffff)
ctr[1] = (data_unit_num >> 32) & 0xffffffff;
break;
}
default:
pr_notice("msdc unknown aes mode 0x%x\n", aes_mode_current);
msdc_dump_info(NULL, 0, NULL, host->id);
WARN_ON(1);
return -EINVAL;
}
/* 1. set IV */
writel(ctr[0], host->base + MSDC_AES_CTR0_GP1);
writel(ctr[1], host->base + MSDC_AES_CTR1_GP1);
writel(ctr[2], host->base + MSDC_AES_CTR2_GP1);
writel(ctr[3], host->base + MSDC_AES_CTR3_GP1);
/* 2. enable AES path */
MSDC_CLR_BIT32(host->base + MSDC_AES_SWST, MSDC_AES_BYPASS);
/* 3. AES switch start (flush the configure) */
if (ddir == WRITE) {
MSDC_SET_BIT32(host->base + MSDC_AES_SWST,
MSDC_AES_SWITCH_START_ENC);
polling_tmo = jiffies + HZ*3;
while (readl(host->base + MSDC_AES_SWST)
& MSDC_AES_SWITCH_START_ENC) {
if (time_after(jiffies, polling_tmo)) {
pr_notice(
"msdc error: trigger AES ENC timeout!\n");
WARN_ON(1);
return -EINVAL;
}
}
} else {
MSDC_SET_BIT32(host->base + MSDC_AES_SWST,
MSDC_AES_SWITCH_START_DEC);
polling_tmo = jiffies + HZ*3;
while (readl(host->base + MSDC_AES_SWST)
& MSDC_AES_SWITCH_START_DEC) {
if (time_after(jiffies, polling_tmo)) {
pr_notice(
"msdc error: trigger AES DEC timeout!\n");
WARN_ON(1);
return -EINVAL;
}
}
}
return 0;
}
/* only non-cqe uses this to set key */
static void msdc_crypto_program_key(struct mmc_host *host,
u32 *key, u32 *tkey, u32 config)
{
struct msdc_host *ll_host = mmc_priv(host);
int i;
int iv[4] = {0};
if (!ll_host || !ll_host->base)
return;
/* disable AES path firstly if need for safety */
msdc_complete_mqr_crypto(host);
if (unlikely(!*key && !tkey)) {
/* disable AES path by set bypass bit */
MSDC_SET_BIT32(ll_host->base + MSDC_AES_SWST, MSDC_AES_BYPASS);
return;
}
/* switch crypto engine to MSDC */
/* write AES config */
MSDC_WRITE32(ll_host->base + MSDC_AES_CFG_GP1, 0);
MSDC_SET_BIT32(ll_host->base + MSDC_AES_CFG_GP1, config);
if (!(readl(ll_host->base + MSDC_AES_CFG_GP1)))
pr_notice("%s write config fail %d!!\n", __func__, config);
/* IV */
for (i = 0; i < 4; i++)
writel(iv[i], ll_host->base + (MSDC_AES_IV0_GP1 + i * 4));
/* KEY */
for (i = 0; i < 8; i++)
writel(key[i], ll_host->base + (MSDC_AES_KEY_GP1 + i * 4));
/* TKEY */
for (i = 0; i < 8; i++)
writel(tkey[i], ll_host->base + (MSDC_AES_TKEY_GP1 + i * 4));
}
/* set crypto information */
static int msdc_prepare_mqr_crypto(struct mmc_host *host,
u64 data_unit_num, int ddir, int tag, int slot)
{
u32 data_unit_size;
u32 aes_config;
struct msdc_host *ll_host = mmc_priv(host);
u32 aes_key[8] = {0}, aes_tkey[8] = {0};
data_unit_size = host->crypto_cfgs[slot].data_unit_size * 512;
if (data_unit_size > 4096) {
WARN_ON(1);
return -EDOM;
}
/* There is only one cap in sw-cqhci */
aes_config = (data_unit_size) << 16 |
host->crypto_cap_array[0].key_size << 8 |
host->crypto_cap_array[0].algorithm_id << 0;
memcpy(aes_key,
&(host->crypto_cfgs[slot].crypto_key[0]),
MMC_CRYPTO_KEY_MAX_SIZE/2);
memcpy(aes_tkey,
&(host->crypto_cfgs[slot].crypto_key[MMC_CRYPTO_KEY_MAX_SIZE/2]),
MMC_CRYPTO_KEY_MAX_SIZE/2);
/* low layer set key: key had been set in upper layer */
msdc_crypto_program_key(host, aes_key, aes_tkey, aes_config);
/* switch crypto engine to MSDC */
return set_crypto(ll_host, data_unit_num, ddir);
}
static void msdc_init_crypto(struct mmc_host *host)
{
if (host->caps2 & (MMC_CAP2_CQE | MMC_CAP2_CQE_DCMD)) {
WARN_ON(1);
} else {
host->crypto_capabilities.config_count = 32;
/* in non-CQHCI, support only one */
host->crypto_capabilities.num_crypto_cap = 1;
}
}
static int msdc_get_crypto_capabilities(struct mmc_host *host)
{
u8 cap_idx;
/* CQE shouldn't go here */
WARN_ON(host->caps2 & (MMC_CAP2_CQE | MMC_CAP2_CQE_DCMD));
/*
* non-cqe has only one algorithm
* algorithm_id : AES-XTS (04)
* sdus_mask: support 512 & 4096 (09)
* key_size: 256bits (02)
* reserved: 0x5A (meaningless)
* please noted that we used 0x5A to distinguish non-cqe and cqe
*/
cap_idx = 0;
host->crypto_cap_array[cap_idx].reg_val =
((u32)0x5A020904 & 0xFFFFFFFF);
return 0;
}
static const struct mmc_crypto_variant_ops crypto_var_ops = {
.host_init_crypto = msdc_init_crypto,
.get_crypto_capabilities = msdc_get_crypto_capabilities,
.prepare_mqr_crypto = msdc_prepare_mqr_crypto,
.host_program_key = msdc_crypto_program_key,
.complete_mqr_crypto = msdc_complete_mqr_crypto,
};
void msdc_crypto_init_vops(struct mmc_host *host)
{
host->crypto_vops = &crypto_var_ops;
}
@@ -0,0 +1,81 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2019 MediaTek Inc.
*/
#ifndef _MSDC_CRYPTO_H
#define _MSDC_CRYPTO_H
/* Crypto */
#define PERI_FDI_AES_SI_CTRL 0x448
#define MSDC_AES_EN 0x600
#define MSDC_AES_SWST 0x670
#define MSDC_AES_CFG_GP1 0x674
#define MSDC_AES_KEY_GP1 0x6A0
#define MSDC_AES_TKEY_GP1 0x6C0
#define MSDC_AES_IV0_GP1 0x680
#define MSDC_AES_CTR0_GP1 0x690
#define MSDC_AES_CTR1_GP1 0x694
#define MSDC_AES_CTR2_GP1 0x698
#define MSDC_AES_CTR3_GP1 0x69C
/* Crypto CQE */
#define MSDC_CRCAP 0x100
/* Crypto context fields in CQHCI data command task descriptor */
#define DATA_UNIT_NUM(x) (((u64)(x) & 0xFFFFFFFF) << 0)
#define CRYPTO_CONFIG_INDEX(x) (((u64)(x) & 0xFF) << 32)
#define CRYPTO_ENABLE(x) (((u64)(x) & 0x1) << 47)
/* Crypto ATF */
#define MTK_SIP_KERNEL_HW_FDE_MSDC_CTL_AARCH32 (0x82000273 | 0x00000000)
#define MTK_SIP_KERNEL_HW_FDE_MSDC_CTL_AARCH64 (0xC2000273 | 0x40000000)
/* CQE */
#define CQ_TASK_DESC_TASK_PARAMS_SIZE 8
#define CQ_TASK_DESC_CE_PARAMS_SIZE 8
/*--------------------------------------------------------------------------*/
/* Register Mask */
/*--------------------------------------------------------------------------*/
/* Crypto */
#define PERI_AES_CTRL_MSDC0_EN (4) /* RW */
#define MSDC_AES_MODE_1 (0x1F << 0) /* RW */
#define MSDC_AES_BYPASS (1 << 2) /* RW */
#define MSDC_AES_SWITCH_START_ENC (1 << 0) /* RW */
#define MSDC_AES_SWITCH_START_DEC (1 << 1) /* RW */
#define MSDC_AES_ON (0x1 << 0) /* RW */
#define MSDC_AES_SWITCH_VALID0 (0x1 << 1) /* RW */
#define MSDC_AES_SWITCH_VALID1 (0x1 << 2) /* RW */
#define MSDC_AES_CLK_DIV_SEL (0x7 << 4) /* RW */
/*--------------------------------------------------------------------------*/
/* Crypto CQE */
/*--------------------------------------------------------------------------*/
union cqhci_cpt_cap {
u32 cap_raw;
struct {
u8 cap_cnt;
u8 cfg_cnt;
u8 resv;
u8 cfg_ptr;
} cap;
};
/*--------------------------------------------------------------------------*/
/* enum */
/*--------------------------------------------------------------------------*/
enum msdc_crypto_alg {
MSDC_CRYPTO_ALG_BITLOCKER_AES_CBC = 1,
MSDC_CRYPTO_ALG_AES_ECB = 2,
MSDC_CRYPTO_ALG_ESSIV_AES_CBC = 3,
MSDC_CRYPTO_ALG_AES_XTS = 4,
};
#ifdef CONFIG_MMC_CRYPTO
void msdc_crypto_init_vops(struct mmc_host *host);
#else
static inline void msdc_crypto_init_vops(struct mmc_host *host) { return ; }
#endif
#endif /* _MSDC_CRYPTO_H */
+11
View File
@@ -0,0 +1,11 @@
#
# MTK MSDC Driver Configs
#
config MTK_MMC_DEBUG
bool "enable msdc debug buffer"
depends on MMC_MTK_PRO||MMC_MTK_SDIO
help
This is an option for use by developers;
Customer can disable it to save a few megabytes of memory。
If y, then enable msdc debug buffer.
+61
View File
@@ -0,0 +1,61 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# 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.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
#
# Makefile for Mediatek(R) MMC/SD host controller drivers
#
#add kernel source code path as head file search path
MTK_PLATFORM := $(subst ",,$(CONFIG_MTK_PLATFORM))
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat/$(MTK_PLATFORM)/include
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat
ccflags-y += -I$(srctree)/drivers/misc/mediatek/base/power/$(MTK_PLATFORM)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/base/power/include
#obj-$(CONFIG_MMC_MTK_PRO) += $(subst ",,$(CONFIG_MTK_PLATFORM))/
ifeq ($(CONFIG_MTK_HW_FDE_AES),y)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/fde_aes/$(MTK_PLATFORM)
endif
ifeq ($(CONFIG_TRUSTONIC_TEE_SUPPORT),y)
include $(srctree)/drivers/tee/gud/Makefile.include
ccflags-y += -I$(srctree)/drivers/mmc/host/mediatek/rpmb/drrpmb/public
ccflags-y += -I$(srctree)/drivers/mmc/host/mediatek/rpmb/drrpmb_gp/public
ccflags-y += -I$(srctree)/drivers/mmc/host/mediatek/rpmb/tlrpmb/public
endif
ccflags-y += -I$(srctree)
#workaround for include mmc/card/queue.h and mmc/core/core.h
ccflags-y += -I$(srctree)/drivers
ccflags-y += -I$(srctree)/drivers/mmc/host/mediatek/$(MTK_PLATFORM)
ifeq ($(CONFIG_MTK_PLATFORM), "mt6765")
ccflags-y += -I$(srctree)/drivers/mmc/host/mediatek/ComboA
ccflags-y += -I$(srctree)/drivers/mmc/host/mediatek/ComboA/mt6765
obj-$(CONFIG_MMC_MTK_PRO) += ComboA/
endif
ifeq ($(CONFIG_MTK_PLATFORM), "mt6761")
ccflags-y += -I$(srctree)/drivers/mmc/host/mediatek/ComboA
ccflags-y += -I$(srctree)/drivers/mmc/host/mediatek/ComboA/mt6765
obj-$(CONFIG_MMC_MTK_PRO) += ComboA/
endif
ifeq ($(CONFIG_MTK_PLATFORM), "mt6739")
ccflags-y += -I$(srctree)/drivers/mmc/host/mediatek/ComboA
ccflags-y += -I$(srctree)/drivers/mmc/host/mediatek/ComboA/mt6739
obj-$(CONFIG_MMC_MTK_PRO) += ComboA/
endif
@@ -0,0 +1,52 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2020 MediaTek Inc.
*/
/**
* @file dci.h
* @brief Contains DCI (Driver Control
* Interface) definitions and data structures
*
*/
#ifndef __DCI_H__
#define __DCI_H__
typedef uint32_t dciCommandId_t;
typedef uint32_t dciResponseId_t;
typedef uint32_t dciReturnCode_t;
/**< Responses have bit 31 set */
#define RSP_ID_MASK (1U << 31)
#define RSP_ID(cmdId) (((uint32_t)(cmdId)) | RSP_ID_MASK)
#define IS_CMD(cmdId) ((((uint32_t)(cmdId)) & RSP_ID_MASK) == 0)
#define IS_RSP(cmdId) ((((uint32_t)(cmdId)) & RSP_ID_MASK) == RSP_ID_MASK)
/**
* Return codes of driver commands.
*/
#define RET_OK 0
#define RET_ERR_UNKNOWN_CMD 1
#define RET_ERR_NOT_SUPPORTED 2
#define RET_ERR_INTERNAL_ERROR 3
/* ... add more error codes when needed */
/**
* DCI command header.
*/
struct dciCommandHeader_t {
dciCommandId_t commandId; /**< Command ID */
};
/**
* DCI response header.
*/
struct dciResponseHeader_t {
/**< Response ID (must be command ID | RSP_ID_MASK )*/
dciResponseId_t responseId;
dciReturnCode_t returnCode; /**< Return code of command */
};
#endif
@@ -0,0 +1,91 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2020 MediaTek Inc.
*/
/**
* @file drrpmb_Api.h
* @brief Contains DCI command definitions and data structures
*
*/
#ifndef __DRRPMBAPI_H__
#define __DRRPMBAPI_H__
#include "dci.h"
/*
* Command ID's
*/
#define DCI_RPMB_CMD_READ_DATA 1
#define DCI_RPMB_CMD_GET_WCNT 2
#define DCI_RPMB_CMD_WRITE_DATA 3
#define DCI_RPMB_CMD_PROGRAM_KEY 4
/*... add more command ids when needed */
/**
* command message.
*
* @param len Length of the data to process.
* @param data Data to be processed
*/
struct cmd_t {
struct dciCommandHeader_t header; /**< Command header */
uint32_t len; /**< Length of data to process */
};
/**
* Response structure
*/
struct rsp_t {
struct dciResponseHeader_t header; /**< Response header */
uint32_t len;
};
/*
* Alternative access flow to improve performance. (this is customization)
*/
#define RPMB_MULTI_BLOCK_ACCESS 1
#if RPMB_MULTI_BLOCK_ACCESS
#define MAX_RPMB_TRANSFER_BLK (16)
/* 8KB(16blks) per requests. */
#define MAX_RPMB_REQUEST_SIZE (512*MAX_RPMB_TRANSFER_BLK)
#else
#define MAX_RPMB_TRANSFER_BLK (1)
/* 512B(1blks) per requests. */
#define MAX_RPMB_REQUEST_SIZE (512*MAX_RPMB_TRANSFER_BLK)
#endif
struct rpmb_req_t {
uint8_t frame[MAX_RPMB_REQUEST_SIZE];
uint32_t frameLen;
uint16_t type;
uint16_t addr;
uint16_t blks;
uint16_t result;
};
/*
* DCI message data.
*/
struct dciMessage_t {
union {
struct cmd_t command;
struct rsp_t response;
};
struct rpmb_req_t request;
};
/*
* Driver UUID. Update accordingly after reserving UUID
*/
#define RPMB_UUID { { 7, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
#endif
@@ -0,0 +1,25 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2020 MediaTek Inc.
*/
/**
* @file drrpmb_Api.h
* @brief Contains DCI command definitions and data structures
*
*/
#ifndef __DRRPMBGPAPI_H__
#define __DRRPMBGPAPI_H__
#include "dci.h"
/*
* Driver UUID. Update accordingly after reserving UUID
*/
#define RPMB_GP_UUID { { 7, 0x15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
#endif
File diff suppressed because it is too large. Load diff
+772
View File
@@ -0,0 +1,772 @@
/*
* meson-mx-sdio.c - Meson6, Meson8 and Meson8b SDIO/MMC Host Controller
*
* Copyright (C) 2015 Endless Mobile, Inc.
* Author: Carlo Caione <carlo@endlessm.com>
* Copyright (C) 2017 Martin Blumenstingl <martin.blumenstingl@googlemail.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*/
#include <linux/bitfield.h>
#include <linux/clk.h>
#include <linux/clk-provider.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/dma-mapping.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/ioport.h>
#include <linux/platform_device.h>
#include <linux/of_platform.h>
#include <linux/timer.h>
#include <linux/types.h>
#include <linux/mmc/host.h>
#include <linux/mmc/mmc.h>
#include <linux/mmc/sdio.h>
#include <linux/mmc/slot-gpio.h>
#define MESON_MX_SDIO_ARGU 0x00
#define MESON_MX_SDIO_SEND 0x04
#define MESON_MX_SDIO_SEND_COMMAND_INDEX_MASK GENMASK(7, 0)
#define MESON_MX_SDIO_SEND_CMD_RESP_BITS_MASK GENMASK(15, 8)
#define MESON_MX_SDIO_SEND_RESP_WITHOUT_CRC7 BIT(16)
#define MESON_MX_SDIO_SEND_RESP_HAS_DATA BIT(17)
#define MESON_MX_SDIO_SEND_RESP_CRC7_FROM_8 BIT(18)
#define MESON_MX_SDIO_SEND_CHECK_DAT0_BUSY BIT(19)
#define MESON_MX_SDIO_SEND_DATA BIT(20)
#define MESON_MX_SDIO_SEND_USE_INT_WINDOW BIT(21)
#define MESON_MX_SDIO_SEND_REPEAT_PACKAGE_TIMES_MASK GENMASK(31, 24)
#define MESON_MX_SDIO_CONF 0x08
#define MESON_MX_SDIO_CONF_CMD_CLK_DIV_SHIFT 0
#define MESON_MX_SDIO_CONF_CMD_CLK_DIV_WIDTH 10
#define MESON_MX_SDIO_CONF_CMD_DISABLE_CRC BIT(10)
#define MESON_MX_SDIO_CONF_CMD_OUT_AT_POSITIVE_EDGE BIT(11)
#define MESON_MX_SDIO_CONF_CMD_ARGUMENT_BITS_MASK GENMASK(17, 12)
#define MESON_MX_SDIO_CONF_RESP_LATCH_AT_NEGATIVE_EDGE BIT(18)
#define MESON_MX_SDIO_CONF_DATA_LATCH_AT_NEGATIVE_EDGE BIT(19)
#define MESON_MX_SDIO_CONF_BUS_WIDTH BIT(20)
#define MESON_MX_SDIO_CONF_M_ENDIAN_MASK GENMASK(22, 21)
#define MESON_MX_SDIO_CONF_WRITE_NWR_MASK GENMASK(28, 23)
#define MESON_MX_SDIO_CONF_WRITE_CRC_OK_STATUS_MASK GENMASK(31, 29)
#define MESON_MX_SDIO_IRQS 0x0c
#define MESON_MX_SDIO_IRQS_STATUS_STATE_MACHINE_MASK GENMASK(3, 0)
#define MESON_MX_SDIO_IRQS_CMD_BUSY BIT(4)
#define MESON_MX_SDIO_IRQS_RESP_CRC7_OK BIT(5)
#define MESON_MX_SDIO_IRQS_DATA_READ_CRC16_OK BIT(6)
#define MESON_MX_SDIO_IRQS_DATA_WRITE_CRC16_OK BIT(7)
#define MESON_MX_SDIO_IRQS_IF_INT BIT(8)
#define MESON_MX_SDIO_IRQS_CMD_INT BIT(9)
#define MESON_MX_SDIO_IRQS_STATUS_INFO_MASK GENMASK(15, 12)
#define MESON_MX_SDIO_IRQS_TIMING_OUT_INT BIT(16)
#define MESON_MX_SDIO_IRQS_AMRISC_TIMING_OUT_INT_EN BIT(17)
#define MESON_MX_SDIO_IRQS_ARC_TIMING_OUT_INT_EN BIT(18)
#define MESON_MX_SDIO_IRQS_TIMING_OUT_COUNT_MASK GENMASK(31, 19)
#define MESON_MX_SDIO_IRQC 0x10
#define MESON_MX_SDIO_IRQC_ARC_IF_INT_EN BIT(3)
#define MESON_MX_SDIO_IRQC_ARC_CMD_INT_EN BIT(4)
#define MESON_MX_SDIO_IRQC_IF_CONFIG_MASK GENMASK(7, 6)
#define MESON_MX_SDIO_IRQC_FORCE_DATA_CLK BIT(8)
#define MESON_MX_SDIO_IRQC_FORCE_DATA_CMD BIT(9)
#define MESON_MX_SDIO_IRQC_FORCE_DATA_DAT_MASK GENMASK(13, 10)
#define MESON_MX_SDIO_IRQC_SOFT_RESET BIT(15)
#define MESON_MX_SDIO_IRQC_FORCE_HALT BIT(30)
#define MESON_MX_SDIO_IRQC_HALT_HOLE BIT(31)
#define MESON_MX_SDIO_MULT 0x14
#define MESON_MX_SDIO_MULT_PORT_SEL_MASK GENMASK(1, 0)
#define MESON_MX_SDIO_MULT_MEMORY_STICK_ENABLE BIT(2)
#define MESON_MX_SDIO_MULT_MEMORY_STICK_SCLK_ALWAYS BIT(3)
#define MESON_MX_SDIO_MULT_STREAM_ENABLE BIT(4)
#define MESON_MX_SDIO_MULT_STREAM_8BITS_MODE BIT(5)
#define MESON_MX_SDIO_MULT_WR_RD_OUT_INDEX BIT(8)
#define MESON_MX_SDIO_MULT_DAT0_DAT1_SWAPPED BIT(10)
#define MESON_MX_SDIO_MULT_DAT1_DAT0_SWAPPED BIT(11)
#define MESON_MX_SDIO_MULT_RESP_READ_INDEX_MASK GENMASK(15, 12)
#define MESON_MX_SDIO_ADDR 0x18
#define MESON_MX_SDIO_EXT 0x1c
#define MESON_MX_SDIO_EXT_DATA_RW_NUMBER_MASK GENMASK(29, 16)
#define MESON_MX_SDIO_BOUNCE_REQ_SIZE (128 * 1024)
#define MESON_MX_SDIO_RESPONSE_CRC16_BITS (16 - 1)
#define MESON_MX_SDIO_MAX_SLOTS 3
struct meson_mx_mmc_host {
struct device *controller_dev;
struct clk *parent_clk;
struct clk *core_clk;
struct clk_divider cfg_div;
struct clk *cfg_div_clk;
struct clk_fixed_factor fixed_factor;
struct clk *fixed_factor_clk;
void __iomem *base;
int irq;
spinlock_t irq_lock;
struct timer_list cmd_timeout;
unsigned int slot_id;
struct mmc_host *mmc;
struct mmc_request *mrq;
struct mmc_command *cmd;
int error;
};
static void meson_mx_mmc_mask_bits(struct mmc_host *mmc, char reg, u32 mask,
u32 val)
{
struct meson_mx_mmc_host *host = mmc_priv(mmc);
u32 regval;
regval = readl(host->base + reg);
regval &= ~mask;
regval |= (val & mask);
writel(regval, host->base + reg);
}
static void meson_mx_mmc_soft_reset(struct meson_mx_mmc_host *host)
{
writel(MESON_MX_SDIO_IRQC_SOFT_RESET, host->base + MESON_MX_SDIO_IRQC);
udelay(2);
}
static struct mmc_command *meson_mx_mmc_get_next_cmd(struct mmc_command *cmd)
{
if (cmd->opcode == MMC_SET_BLOCK_COUNT && !cmd->error)
return cmd->mrq->cmd;
else if (mmc_op_multi(cmd->opcode) &&
(!cmd->mrq->sbc || cmd->error || cmd->data->error))
return cmd->mrq->stop;
else
return NULL;
}
static void meson_mx_mmc_start_cmd(struct mmc_host *mmc,
struct mmc_command *cmd)
{
struct meson_mx_mmc_host *host = mmc_priv(mmc);
unsigned int pack_size;
unsigned long irqflags, timeout;
u32 mult, send = 0, ext = 0;
host->cmd = cmd;
if (cmd->busy_timeout)
timeout = msecs_to_jiffies(cmd->busy_timeout);
else
timeout = msecs_to_jiffies(1000);
switch (mmc_resp_type(cmd)) {
case MMC_RSP_R1:
case MMC_RSP_R1B:
case MMC_RSP_R3:
/* 7 (CMD) + 32 (response) + 7 (CRC) -1 */
send |= FIELD_PREP(MESON_MX_SDIO_SEND_CMD_RESP_BITS_MASK, 45);
break;
case MMC_RSP_R2:
/* 7 (CMD) + 120 (response) + 7 (CRC) -1 */
send |= FIELD_PREP(MESON_MX_SDIO_SEND_CMD_RESP_BITS_MASK, 133);
send |= MESON_MX_SDIO_SEND_RESP_CRC7_FROM_8;
break;
default:
break;
}
if (!(cmd->flags & MMC_RSP_CRC))
send |= MESON_MX_SDIO_SEND_RESP_WITHOUT_CRC7;
if (cmd->flags & MMC_RSP_BUSY)
send |= MESON_MX_SDIO_SEND_CHECK_DAT0_BUSY;
if (cmd->data) {
send |= FIELD_PREP(MESON_MX_SDIO_SEND_REPEAT_PACKAGE_TIMES_MASK,
(cmd->data->blocks - 1));
pack_size = cmd->data->blksz * BITS_PER_BYTE;
if (mmc->ios.bus_width == MMC_BUS_WIDTH_4)
pack_size += MESON_MX_SDIO_RESPONSE_CRC16_BITS * 4;
else
pack_size += MESON_MX_SDIO_RESPONSE_CRC16_BITS * 1;
ext |= FIELD_PREP(MESON_MX_SDIO_EXT_DATA_RW_NUMBER_MASK,
pack_size);
if (cmd->data->flags & MMC_DATA_WRITE)
send |= MESON_MX_SDIO_SEND_DATA;
else
send |= MESON_MX_SDIO_SEND_RESP_HAS_DATA;
cmd->data->bytes_xfered = 0;
}
send |= FIELD_PREP(MESON_MX_SDIO_SEND_COMMAND_INDEX_MASK,
(0x40 | cmd->opcode));
spin_lock_irqsave(&host->irq_lock, irqflags);
mult = readl(host->base + MESON_MX_SDIO_MULT);
mult &= ~MESON_MX_SDIO_MULT_PORT_SEL_MASK;
mult |= FIELD_PREP(MESON_MX_SDIO_MULT_PORT_SEL_MASK, host->slot_id);
mult |= BIT(31);
writel(mult, host->base + MESON_MX_SDIO_MULT);
/* enable the CMD done interrupt */
meson_mx_mmc_mask_bits(mmc, MESON_MX_SDIO_IRQC,
MESON_MX_SDIO_IRQC_ARC_CMD_INT_EN,
MESON_MX_SDIO_IRQC_ARC_CMD_INT_EN);
/* clear pending interrupts */
meson_mx_mmc_mask_bits(mmc, MESON_MX_SDIO_IRQS,
MESON_MX_SDIO_IRQS_CMD_INT,
MESON_MX_SDIO_IRQS_CMD_INT);
writel(cmd->arg, host->base + MESON_MX_SDIO_ARGU);
writel(ext, host->base + MESON_MX_SDIO_EXT);
writel(send, host->base + MESON_MX_SDIO_SEND);
spin_unlock_irqrestore(&host->irq_lock, irqflags);
mod_timer(&host->cmd_timeout, jiffies + timeout);
}
static void meson_mx_mmc_request_done(struct meson_mx_mmc_host *host)
{
struct mmc_request *mrq;
mrq = host->mrq;
if (host->cmd->error)
meson_mx_mmc_soft_reset(host);
host->mrq = NULL;
host->cmd = NULL;
mmc_request_done(host->mmc, mrq);
}
static void meson_mx_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
{
struct meson_mx_mmc_host *host = mmc_priv(mmc);
unsigned short vdd = ios->vdd;
unsigned long clk_rate = ios->clock;
switch (ios->bus_width) {
case MMC_BUS_WIDTH_1:
meson_mx_mmc_mask_bits(mmc, MESON_MX_SDIO_CONF,
MESON_MX_SDIO_CONF_BUS_WIDTH, 0);
break;
case MMC_BUS_WIDTH_4:
meson_mx_mmc_mask_bits(mmc, MESON_MX_SDIO_CONF,
MESON_MX_SDIO_CONF_BUS_WIDTH,
MESON_MX_SDIO_CONF_BUS_WIDTH);
break;
case MMC_BUS_WIDTH_8:
default:
dev_err(mmc_dev(mmc), "unsupported bus width: %d\n",
ios->bus_width);
host->error = -EINVAL;
return;
}
host->error = clk_set_rate(host->cfg_div_clk, ios->clock);
if (host->error) {
dev_warn(mmc_dev(mmc),
"failed to set MMC clock to %lu: %d\n",
clk_rate, host->error);
return;
}
mmc->actual_clock = clk_get_rate(host->cfg_div_clk);
switch (ios->power_mode) {
case MMC_POWER_OFF:
vdd = 0;
/* fall-through: */
case MMC_POWER_UP:
if (!IS_ERR(mmc->supply.vmmc)) {
host->error = mmc_regulator_set_ocr(mmc,
mmc->supply.vmmc,
vdd);
if (host->error)
return;
}
break;
}
}
static int meson_mx_mmc_map_dma(struct mmc_host *mmc, struct mmc_request *mrq)
{
struct mmc_data *data = mrq->data;
int dma_len;
struct scatterlist *sg;
if (!data)
return 0;
sg = data->sg;
if (sg->offset & 3 || sg->length & 3) {
dev_err(mmc_dev(mmc),
"unaligned scatterlist: offset %x length %d\n",
sg->offset, sg->length);
return -EINVAL;
}
dma_len = dma_map_sg(mmc_dev(mmc), data->sg, data->sg_len,
mmc_get_dma_dir(data));
if (dma_len <= 0) {
dev_err(mmc_dev(mmc), "dma_map_sg failed\n");
return -ENOMEM;
}
return 0;
}
static void meson_mx_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
{
struct meson_mx_mmc_host *host = mmc_priv(mmc);
struct mmc_command *cmd = mrq->cmd;
if (!host->error)
host->error = meson_mx_mmc_map_dma(mmc, mrq);
if (host->error) {
cmd->error = host->error;
mmc_request_done(mmc, mrq);
return;
}
host->mrq = mrq;
if (mrq->data)
writel(sg_dma_address(mrq->data->sg),
host->base + MESON_MX_SDIO_ADDR);
if (mrq->sbc)
meson_mx_mmc_start_cmd(mmc, mrq->sbc);
else
meson_mx_mmc_start_cmd(mmc, mrq->cmd);
}
static void meson_mx_mmc_read_response(struct mmc_host *mmc,
struct mmc_command *cmd)
{
struct meson_mx_mmc_host *host = mmc_priv(mmc);
u32 mult;
int i, resp[4];
mult = readl(host->base + MESON_MX_SDIO_MULT);
mult |= MESON_MX_SDIO_MULT_WR_RD_OUT_INDEX;
mult &= ~MESON_MX_SDIO_MULT_RESP_READ_INDEX_MASK;
mult |= FIELD_PREP(MESON_MX_SDIO_MULT_RESP_READ_INDEX_MASK, 0);
writel(mult, host->base + MESON_MX_SDIO_MULT);
if (cmd->flags & MMC_RSP_136) {
for (i = 0; i <= 3; i++)
resp[3 - i] = readl(host->base + MESON_MX_SDIO_ARGU);
cmd->resp[0] = (resp[0] << 8) | ((resp[1] >> 24) & 0xff);
cmd->resp[1] = (resp[1] << 8) | ((resp[2] >> 24) & 0xff);
cmd->resp[2] = (resp[2] << 8) | ((resp[3] >> 24) & 0xff);
cmd->resp[3] = (resp[3] << 8);
} else if (cmd->flags & MMC_RSP_PRESENT) {
cmd->resp[0] = readl(host->base + MESON_MX_SDIO_ARGU);
}
}
static irqreturn_t meson_mx_mmc_process_cmd_irq(struct meson_mx_mmc_host *host,
u32 irqs, u32 send)
{
struct mmc_command *cmd = host->cmd;
/*
* NOTE: even though it shouldn't happen we sometimes get command
* interrupts twice (at least this is what it looks like). Ideally
* we find out why this happens and warn here as soon as it occurs.
*/
if (!cmd)
return IRQ_HANDLED;
cmd->error = 0;
meson_mx_mmc_read_response(host->mmc, cmd);
if (cmd->data) {
if (!((irqs & MESON_MX_SDIO_IRQS_DATA_READ_CRC16_OK) ||
(irqs & MESON_MX_SDIO_IRQS_DATA_WRITE_CRC16_OK)))
cmd->error = -EILSEQ;
} else {
if (!((irqs & MESON_MX_SDIO_IRQS_RESP_CRC7_OK) ||
(send & MESON_MX_SDIO_SEND_RESP_WITHOUT_CRC7)))
cmd->error = -EILSEQ;
}
return IRQ_WAKE_THREAD;
}
static irqreturn_t meson_mx_mmc_irq(int irq, void *data)
{
struct meson_mx_mmc_host *host = (void *) data;
u32 irqs, send;
unsigned long irqflags;
irqreturn_t ret;
spin_lock_irqsave(&host->irq_lock, irqflags);
irqs = readl(host->base + MESON_MX_SDIO_IRQS);
send = readl(host->base + MESON_MX_SDIO_SEND);
if (irqs & MESON_MX_SDIO_IRQS_CMD_INT)
ret = meson_mx_mmc_process_cmd_irq(host, irqs, send);
else
ret = IRQ_HANDLED;
/* finally ACK all pending interrupts */
writel(irqs, host->base + MESON_MX_SDIO_IRQS);
spin_unlock_irqrestore(&host->irq_lock, irqflags);
return ret;
}
static irqreturn_t meson_mx_mmc_irq_thread(int irq, void *irq_data)
{
struct meson_mx_mmc_host *host = (void *) irq_data;
struct mmc_command *cmd = host->cmd, *next_cmd;
if (WARN_ON(!cmd))
return IRQ_HANDLED;
del_timer_sync(&host->cmd_timeout);
if (cmd->data) {
dma_unmap_sg(mmc_dev(host->mmc), cmd->data->sg,
cmd->data->sg_len,
mmc_get_dma_dir(cmd->data));
cmd->data->bytes_xfered = cmd->data->blksz * cmd->data->blocks;
}
next_cmd = meson_mx_mmc_get_next_cmd(cmd);
if (next_cmd)
meson_mx_mmc_start_cmd(host->mmc, next_cmd);
else
meson_mx_mmc_request_done(host);
return IRQ_HANDLED;
}
static void meson_mx_mmc_timeout(struct timer_list *t)
{
struct meson_mx_mmc_host *host = from_timer(host, t, cmd_timeout);
unsigned long irqflags;
u32 irqc;
spin_lock_irqsave(&host->irq_lock, irqflags);
/* disable the CMD interrupt */
irqc = readl(host->base + MESON_MX_SDIO_IRQC);
irqc &= ~MESON_MX_SDIO_IRQC_ARC_CMD_INT_EN;
writel(irqc, host->base + MESON_MX_SDIO_IRQC);
spin_unlock_irqrestore(&host->irq_lock, irqflags);
/*
* skip the timeout handling if the interrupt handler already processed
* the command.
*/
if (!host->cmd)
return;
dev_dbg(mmc_dev(host->mmc),
"Timeout on CMD%u (IRQS = 0x%08x, ARGU = 0x%08x)\n",
host->cmd->opcode, readl(host->base + MESON_MX_SDIO_IRQS),
readl(host->base + MESON_MX_SDIO_ARGU));
host->cmd->error = -ETIMEDOUT;
meson_mx_mmc_request_done(host);
}
static struct mmc_host_ops meson_mx_mmc_ops = {
.request = meson_mx_mmc_request,
.set_ios = meson_mx_mmc_set_ios,
.get_cd = mmc_gpio_get_cd,
.get_ro = mmc_gpio_get_ro,
};
static struct platform_device *meson_mx_mmc_slot_pdev(struct device *parent)
{
struct device_node *slot_node;
struct platform_device *pdev;
/*
* TODO: the MMC core framework currently does not support
* controllers with multiple slots properly. So we only register
* the first slot for now
*/
slot_node = of_get_compatible_child(parent->of_node, "mmc-slot");
if (!slot_node) {
dev_warn(parent, "no 'mmc-slot' sub-node found\n");
return ERR_PTR(-ENOENT);
}
pdev = of_platform_device_create(slot_node, NULL, parent);
of_node_put(slot_node);
return pdev;
}
static int meson_mx_mmc_add_host(struct meson_mx_mmc_host *host)
{
struct mmc_host *mmc = host->mmc;
struct device *slot_dev = mmc_dev(mmc);
int ret;
if (of_property_read_u32(slot_dev->of_node, "reg", &host->slot_id)) {
dev_err(slot_dev, "missing 'reg' property\n");
return -EINVAL;
}
if (host->slot_id >= MESON_MX_SDIO_MAX_SLOTS) {
dev_err(slot_dev, "invalid 'reg' property value %d\n",
host->slot_id);
return -EINVAL;
}
/* Get regulators and the supported OCR mask */
ret = mmc_regulator_get_supply(mmc);
if (ret)
return ret;
mmc->max_req_size = MESON_MX_SDIO_BOUNCE_REQ_SIZE;
mmc->max_seg_size = mmc->max_req_size;
mmc->max_blk_count =
FIELD_GET(MESON_MX_SDIO_SEND_REPEAT_PACKAGE_TIMES_MASK,
0xffffffff);
mmc->max_blk_size = FIELD_GET(MESON_MX_SDIO_EXT_DATA_RW_NUMBER_MASK,
0xffffffff);
mmc->max_blk_size -= (4 * MESON_MX_SDIO_RESPONSE_CRC16_BITS);
mmc->max_blk_size /= BITS_PER_BYTE;
/* Get the min and max supported clock rates */
mmc->f_min = clk_round_rate(host->cfg_div_clk, 1);
mmc->f_max = clk_round_rate(host->cfg_div_clk,
clk_get_rate(host->parent_clk));
mmc->caps |= MMC_CAP_ERASE | MMC_CAP_CMD23 | MMC_CAP_WAIT_WHILE_BUSY;
mmc->ops = &meson_mx_mmc_ops;
ret = mmc_of_parse(mmc);
if (ret)
return ret;
ret = mmc_add_host(mmc);
if (ret)
return ret;
return 0;
}
static int meson_mx_mmc_register_clks(struct meson_mx_mmc_host *host)
{
struct clk_init_data init;
const char *clk_div_parent, *clk_fixed_factor_parent;
clk_fixed_factor_parent = __clk_get_name(host->parent_clk);
init.name = devm_kasprintf(host->controller_dev, GFP_KERNEL,
"%s#fixed_factor",
dev_name(host->controller_dev));
if (!init.name)
return -ENOMEM;
init.ops = &clk_fixed_factor_ops;
init.flags = 0;
init.parent_names = &clk_fixed_factor_parent;
init.num_parents = 1;
host->fixed_factor.div = 2;
host->fixed_factor.mult = 1;
host->fixed_factor.hw.init = &init;
host->fixed_factor_clk = devm_clk_register(host->controller_dev,
&host->fixed_factor.hw);
if (WARN_ON(IS_ERR(host->fixed_factor_clk)))
return PTR_ERR(host->fixed_factor_clk);
clk_div_parent = __clk_get_name(host->fixed_factor_clk);
init.name = devm_kasprintf(host->controller_dev, GFP_KERNEL,
"%s#div", dev_name(host->controller_dev));
if (!init.name)
return -ENOMEM;
init.ops = &clk_divider_ops;
init.flags = CLK_SET_RATE_PARENT;
init.parent_names = &clk_div_parent;
init.num_parents = 1;
host->cfg_div.reg = host->base + MESON_MX_SDIO_CONF;
host->cfg_div.shift = MESON_MX_SDIO_CONF_CMD_CLK_DIV_SHIFT;
host->cfg_div.width = MESON_MX_SDIO_CONF_CMD_CLK_DIV_WIDTH;
host->cfg_div.hw.init = &init;
host->cfg_div.flags = CLK_DIVIDER_ALLOW_ZERO;
host->cfg_div_clk = devm_clk_register(host->controller_dev,
&host->cfg_div.hw);
if (WARN_ON(IS_ERR(host->cfg_div_clk)))
return PTR_ERR(host->cfg_div_clk);
return 0;
}
static int meson_mx_mmc_probe(struct platform_device *pdev)
{
struct platform_device *slot_pdev;
struct mmc_host *mmc;
struct meson_mx_mmc_host *host;
struct resource *res;
int ret, irq;
u32 conf;
slot_pdev = meson_mx_mmc_slot_pdev(&pdev->dev);
if (!slot_pdev)
return -ENODEV;
else if (IS_ERR(slot_pdev))
return PTR_ERR(slot_pdev);
mmc = mmc_alloc_host(sizeof(*host), &slot_pdev->dev);
if (!mmc) {
ret = -ENOMEM;
goto error_unregister_slot_pdev;
}
host = mmc_priv(mmc);
host->mmc = mmc;
host->controller_dev = &pdev->dev;
spin_lock_init(&host->irq_lock);
timer_setup(&host->cmd_timeout, meson_mx_mmc_timeout, 0);
platform_set_drvdata(pdev, host);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
host->base = devm_ioremap_resource(host->controller_dev, res);
if (IS_ERR(host->base)) {
ret = PTR_ERR(host->base);
goto error_free_mmc;
}
irq = platform_get_irq(pdev, 0);
ret = devm_request_threaded_irq(host->controller_dev, irq,
meson_mx_mmc_irq,
meson_mx_mmc_irq_thread, IRQF_ONESHOT,
NULL, host);
if (ret)
goto error_free_mmc;
host->core_clk = devm_clk_get(host->controller_dev, "core");
if (IS_ERR(host->core_clk)) {
ret = PTR_ERR(host->core_clk);
goto error_free_mmc;
}
host->parent_clk = devm_clk_get(host->controller_dev, "clkin");
if (IS_ERR(host->parent_clk)) {
ret = PTR_ERR(host->parent_clk);
goto error_free_mmc;
}
ret = meson_mx_mmc_register_clks(host);
if (ret)
goto error_free_mmc;
ret = clk_prepare_enable(host->core_clk);
if (ret) {
dev_err(host->controller_dev, "Failed to enable core clock\n");
goto error_free_mmc;
}
ret = clk_prepare_enable(host->cfg_div_clk);
if (ret) {
dev_err(host->controller_dev, "Failed to enable MMC clock\n");
goto error_disable_core_clk;
}
conf = 0;
conf |= FIELD_PREP(MESON_MX_SDIO_CONF_CMD_ARGUMENT_BITS_MASK, 39);
conf |= FIELD_PREP(MESON_MX_SDIO_CONF_M_ENDIAN_MASK, 0x3);
conf |= FIELD_PREP(MESON_MX_SDIO_CONF_WRITE_NWR_MASK, 0x2);
conf |= FIELD_PREP(MESON_MX_SDIO_CONF_WRITE_CRC_OK_STATUS_MASK, 0x2);
writel(conf, host->base + MESON_MX_SDIO_CONF);
meson_mx_mmc_soft_reset(host);
ret = meson_mx_mmc_add_host(host);
if (ret)
goto error_disable_clks;
return 0;
error_disable_clks:
clk_disable_unprepare(host->cfg_div_clk);
error_disable_core_clk:
clk_disable_unprepare(host->core_clk);
error_free_mmc:
mmc_free_host(mmc);
error_unregister_slot_pdev:
of_platform_device_destroy(&slot_pdev->dev, NULL);
return ret;
}
static int meson_mx_mmc_remove(struct platform_device *pdev)
{
struct meson_mx_mmc_host *host = platform_get_drvdata(pdev);
struct device *slot_dev = mmc_dev(host->mmc);
del_timer_sync(&host->cmd_timeout);
mmc_remove_host(host->mmc);
of_platform_device_destroy(slot_dev, NULL);
clk_disable_unprepare(host->cfg_div_clk);
clk_disable_unprepare(host->core_clk);
mmc_free_host(host->mmc);
return 0;
}
static const struct of_device_id meson_mx_mmc_of_match[] = {
{ .compatible = "amlogic,meson8-sdio", },
{ .compatible = "amlogic,meson8b-sdio", },
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, meson_mx_mmc_of_match);
static struct platform_driver meson_mx_mmc_driver = {
.probe = meson_mx_mmc_probe,
.remove = meson_mx_mmc_remove,
.driver = {
.name = "meson-mx-sdio",
.of_match_table = of_match_ptr(meson_mx_mmc_of_match),
},
};
module_platform_driver(meson_mx_mmc_driver);
MODULE_DESCRIPTION("Meson6, Meson8 and Meson8b SDIO/MMC Host Driver");
MODULE_AUTHOR("Carlo Caione <carlo@endlessm.com>");
MODULE_AUTHOR("Martin Blumenstingl <martin.blumenstingl@googlemail.com>");
MODULE_LICENSE("GPL v2");
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+340
View File
@@ -0,0 +1,340 @@
/*
* linux/drivers/mmc/host/mmci.h - ARM PrimeCell MMCI PL180/1 driver
*
* Copyright (C) 2003 Deep Blue Solutions, Ltd, 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.
*/
#define MMCIPOWER 0x000
#define MCI_PWR_OFF 0x00
#define MCI_PWR_UP 0x02
#define MCI_PWR_ON 0x03
#define MCI_OD (1 << 6)
#define MCI_ROD (1 << 7)
/*
* The ST Micro version does not have ROD and reuse the voltage registers for
* direction settings.
*/
#define MCI_ST_DATA2DIREN (1 << 2)
#define MCI_ST_CMDDIREN (1 << 3)
#define MCI_ST_DATA0DIREN (1 << 4)
#define MCI_ST_DATA31DIREN (1 << 5)
#define MCI_ST_FBCLKEN (1 << 7)
#define MCI_ST_DATA74DIREN (1 << 8)
#define MMCICLOCK 0x004
#define MCI_CLK_ENABLE (1 << 8)
#define MCI_CLK_PWRSAVE (1 << 9)
#define MCI_CLK_BYPASS (1 << 10)
#define MCI_4BIT_BUS (1 << 11)
/*
* 8bit wide buses, hardware flow contronl, negative edges and clock inversion
* supported in ST Micro U300 and Ux500 versions
*/
#define MCI_ST_8BIT_BUS (1 << 12)
#define MCI_ST_U300_HWFCEN (1 << 13)
#define MCI_ST_UX500_NEG_EDGE (1 << 13)
#define MCI_ST_UX500_HWFCEN (1 << 14)
#define MCI_ST_UX500_CLK_INV (1 << 15)
/* Modified PL180 on Versatile Express platform */
#define MCI_ARM_HWFCEN (1 << 12)
/* Modified on Qualcomm Integrations */
#define MCI_QCOM_CLK_WIDEBUS_8 (BIT(10) | BIT(11))
#define MCI_QCOM_CLK_FLOWENA BIT(12)
#define MCI_QCOM_CLK_INVERTOUT BIT(13)
/* select in latch data and command in */
#define MCI_QCOM_CLK_SELECT_IN_FBCLK BIT(15)
#define MCI_QCOM_CLK_SELECT_IN_DDR_MODE (BIT(14) | BIT(15))
#define MMCIARGUMENT 0x008
/* The command register controls the Command Path State Machine (CPSM) */
#define MMCICOMMAND 0x00c
#define MCI_CPSM_RESPONSE BIT(6)
#define MCI_CPSM_LONGRSP BIT(7)
#define MCI_CPSM_INTERRUPT BIT(8)
#define MCI_CPSM_PENDING BIT(9)
#define MCI_CPSM_ENABLE BIT(10)
/* Command register flag extenstions in the ST Micro versions */
#define MCI_CPSM_ST_SDIO_SUSP BIT(11)
#define MCI_CPSM_ST_ENCMD_COMPL BIT(12)
#define MCI_CPSM_ST_NIEN BIT(13)
#define MCI_CPSM_ST_CE_ATACMD BIT(14)
/* Command register flag extensions in the Qualcomm versions */
#define MCI_CPSM_QCOM_PROGENA BIT(11)
#define MCI_CPSM_QCOM_DATCMD BIT(12)
#define MCI_CPSM_QCOM_MCIABORT BIT(13)
#define MCI_CPSM_QCOM_CCSENABLE BIT(14)
#define MCI_CPSM_QCOM_CCSDISABLE BIT(15)
#define MCI_CPSM_QCOM_AUTO_CMD19 BIT(16)
#define MCI_CPSM_QCOM_AUTO_CMD21 BIT(21)
#define MMCIRESPCMD 0x010
#define MMCIRESPONSE0 0x014
#define MMCIRESPONSE1 0x018
#define MMCIRESPONSE2 0x01c
#define MMCIRESPONSE3 0x020
#define MMCIDATATIMER 0x024
#define MMCIDATALENGTH 0x028
/* The data control register controls the Data Path State Machine (DPSM) */
#define MMCIDATACTRL 0x02c
#define MCI_DPSM_ENABLE BIT(0)
#define MCI_DPSM_DIRECTION BIT(1)
#define MCI_DPSM_MODE BIT(2)
#define MCI_DPSM_DMAENABLE BIT(3)
#define MCI_DPSM_BLOCKSIZE BIT(4)
/* Control register extensions in the ST Micro U300 and Ux500 versions */
#define MCI_DPSM_ST_RWSTART BIT(8)
#define MCI_DPSM_ST_RWSTOP BIT(9)
#define MCI_DPSM_ST_RWMOD BIT(10)
#define MCI_DPSM_ST_SDIOEN BIT(11)
/* Control register extensions in the ST Micro Ux500 versions */
#define MCI_DPSM_ST_DMAREQCTL BIT(12)
#define MCI_DPSM_ST_DBOOTMODEEN BIT(13)
#define MCI_DPSM_ST_BUSYMODE BIT(14)
#define MCI_DPSM_ST_DDRMODE BIT(15)
/* Control register extensions in the Qualcomm versions */
#define MCI_DPSM_QCOM_DATA_PEND BIT(17)
#define MCI_DPSM_QCOM_RX_DATA_PEND BIT(20)
#define MMCIDATACNT 0x030
#define MMCISTATUS 0x034
#define MCI_CMDCRCFAIL (1 << 0)
#define MCI_DATACRCFAIL (1 << 1)
#define MCI_CMDTIMEOUT (1 << 2)
#define MCI_DATATIMEOUT (1 << 3)
#define MCI_TXUNDERRUN (1 << 4)
#define MCI_RXOVERRUN (1 << 5)
#define MCI_CMDRESPEND (1 << 6)
#define MCI_CMDSENT (1 << 7)
#define MCI_DATAEND (1 << 8)
#define MCI_STARTBITERR (1 << 9)
#define MCI_DATABLOCKEND (1 << 10)
#define MCI_CMDACTIVE (1 << 11)
#define MCI_TXACTIVE (1 << 12)
#define MCI_RXACTIVE (1 << 13)
#define MCI_TXFIFOHALFEMPTY (1 << 14)
#define MCI_RXFIFOHALFFULL (1 << 15)
#define MCI_TXFIFOFULL (1 << 16)
#define MCI_RXFIFOFULL (1 << 17)
#define MCI_TXFIFOEMPTY (1 << 18)
#define MCI_RXFIFOEMPTY (1 << 19)
#define MCI_TXDATAAVLBL (1 << 20)
#define MCI_RXDATAAVLBL (1 << 21)
/* Extended status bits for the ST Micro variants */
#define MCI_ST_SDIOIT (1 << 22)
#define MCI_ST_CEATAEND (1 << 23)
#define MCI_ST_CARDBUSY (1 << 24)
#define MMCICLEAR 0x038
#define MCI_CMDCRCFAILCLR (1 << 0)
#define MCI_DATACRCFAILCLR (1 << 1)
#define MCI_CMDTIMEOUTCLR (1 << 2)
#define MCI_DATATIMEOUTCLR (1 << 3)
#define MCI_TXUNDERRUNCLR (1 << 4)
#define MCI_RXOVERRUNCLR (1 << 5)
#define MCI_CMDRESPENDCLR (1 << 6)
#define MCI_CMDSENTCLR (1 << 7)
#define MCI_DATAENDCLR (1 << 8)
#define MCI_STARTBITERRCLR (1 << 9)
#define MCI_DATABLOCKENDCLR (1 << 10)
/* Extended status bits for the ST Micro variants */
#define MCI_ST_SDIOITC (1 << 22)
#define MCI_ST_CEATAENDC (1 << 23)
#define MCI_ST_BUSYENDC (1 << 24)
#define MMCIMASK0 0x03c
#define MCI_CMDCRCFAILMASK (1 << 0)
#define MCI_DATACRCFAILMASK (1 << 1)
#define MCI_CMDTIMEOUTMASK (1 << 2)
#define MCI_DATATIMEOUTMASK (1 << 3)
#define MCI_TXUNDERRUNMASK (1 << 4)
#define MCI_RXOVERRUNMASK (1 << 5)
#define MCI_CMDRESPENDMASK (1 << 6)
#define MCI_CMDSENTMASK (1 << 7)
#define MCI_DATAENDMASK (1 << 8)
#define MCI_STARTBITERRMASK (1 << 9)
#define MCI_DATABLOCKENDMASK (1 << 10)
#define MCI_CMDACTIVEMASK (1 << 11)
#define MCI_TXACTIVEMASK (1 << 12)
#define MCI_RXACTIVEMASK (1 << 13)
#define MCI_TXFIFOHALFEMPTYMASK (1 << 14)
#define MCI_RXFIFOHALFFULLMASK (1 << 15)
#define MCI_TXFIFOFULLMASK (1 << 16)
#define MCI_RXFIFOFULLMASK (1 << 17)
#define MCI_TXFIFOEMPTYMASK (1 << 18)
#define MCI_RXFIFOEMPTYMASK (1 << 19)
#define MCI_TXDATAAVLBLMASK (1 << 20)
#define MCI_RXDATAAVLBLMASK (1 << 21)
/* Extended status bits for the ST Micro variants */
#define MCI_ST_SDIOITMASK (1 << 22)
#define MCI_ST_CEATAENDMASK (1 << 23)
#define MCI_ST_BUSYENDMASK (1 << 24)
#define MMCIMASK1 0x040
#define MMCIFIFOCNT 0x048
#define MMCIFIFO 0x080 /* to 0x0bc */
#define MCI_IRQENABLE \
(MCI_CMDCRCFAILMASK | MCI_DATACRCFAILMASK | MCI_CMDTIMEOUTMASK | \
MCI_DATATIMEOUTMASK | MCI_TXUNDERRUNMASK | MCI_RXOVERRUNMASK | \
MCI_CMDRESPENDMASK | MCI_CMDSENTMASK)
/* These interrupts are directed to IRQ1 when two IRQ lines are available */
#define MCI_IRQ1MASK \
(MCI_RXFIFOHALFFULLMASK | MCI_RXDATAAVLBLMASK | \
MCI_TXFIFOHALFEMPTYMASK)
#define NR_SG 128
#define MMCI_PINCTRL_STATE_OPENDRAIN "opendrain"
struct clk;
struct dma_chan;
struct mmci_host;
/**
* struct variant_data - MMCI variant-specific quirks
* @clkreg: default value for MCICLOCK register
* @clkreg_enable: enable value for MMCICLOCK register
* @clkreg_8bit_bus_enable: enable value for 8 bit bus
* @clkreg_neg_edge_enable: enable value for inverted data/cmd output
* @datalength_bits: number of bits in the MMCIDATALENGTH register
* @fifosize: number of bytes that can be written when MMCI_TXFIFOEMPTY
* is asserted (likewise for RX)
* @fifohalfsize: number of bytes that can be written when MCI_TXFIFOHALFEMPTY
* is asserted (likewise for RX)
* @data_cmd_enable: enable value for data commands.
* @st_sdio: enable ST specific SDIO logic
* @st_clkdiv: true if using a ST-specific clock divider algorithm
* @datactrl_mask_ddrmode: ddr mode mask in datactrl register.
* @blksz_datactrl16: true if Block size is at b16..b30 position in datactrl register
* @blksz_datactrl4: true if Block size is at b4..b16 position in datactrl
* register
* @datactrl_mask_sdio: SDIO enable mask in datactrl register
* @pwrreg_powerup: power up value for MMCIPOWER register
* @f_max: maximum clk frequency supported by the controller.
* @signal_direction: input/out direction of bus signals can be indicated
* @pwrreg_clkgate: MMCIPOWER register must be used to gate the clock
* @busy_detect: true if the variant supports busy detection on DAT0.
* @busy_dpsm_flag: bitmask enabling busy detection in the DPSM
* @busy_detect_flag: bitmask identifying the bit in the MMCISTATUS register
* indicating that the card is busy
* @busy_detect_mask: bitmask identifying the bit in the MMCIMASK0 to mask for
* getting busy end detection interrupts
* @pwrreg_nopower: bits in MMCIPOWER don't controls ext. power supply
* @explicit_mclk_control: enable explicit mclk control in driver.
* @qcom_fifo: enables qcom specific fifo pio read logic.
* @qcom_dml: enables qcom specific dma glue for dma transfers.
* @reversed_irq_handling: handle data irq before cmd irq.
* @mmcimask1: true if variant have a MMCIMASK1 register.
* @start_err: bitmask identifying the STARTBITERR bit inside MMCISTATUS
* register.
* @opendrain: bitmask identifying the OPENDRAIN bit inside MMCIPOWER register
*/
struct variant_data {
unsigned int clkreg;
unsigned int clkreg_enable;
unsigned int clkreg_8bit_bus_enable;
unsigned int clkreg_neg_edge_enable;
unsigned int datalength_bits;
unsigned int fifosize;
unsigned int fifohalfsize;
unsigned int data_cmd_enable;
unsigned int datactrl_mask_ddrmode;
unsigned int datactrl_mask_sdio;
bool st_sdio;
bool st_clkdiv;
bool blksz_datactrl16;
bool blksz_datactrl4;
u32 pwrreg_powerup;
u32 f_max;
bool signal_direction;
bool pwrreg_clkgate;
bool busy_detect;
u32 busy_dpsm_flag;
u32 busy_detect_flag;
u32 busy_detect_mask;
bool pwrreg_nopower;
bool explicit_mclk_control;
bool qcom_fifo;
bool qcom_dml;
bool reversed_irq_handling;
bool mmcimask1;
u32 start_err;
u32 opendrain;
void (*init)(struct mmci_host *host);
};
/* mmci variant callbacks */
struct mmci_host_ops {
void (*dma_setup)(struct mmci_host *host);
};
struct mmci_host_next {
struct dma_async_tx_descriptor *dma_desc;
struct dma_chan *dma_chan;
s32 cookie;
};
struct mmci_host {
phys_addr_t phybase;
void __iomem *base;
struct mmc_request *mrq;
struct mmc_command *cmd;
struct mmc_data *data;
struct mmc_host *mmc;
struct clk *clk;
bool singleirq;
spinlock_t lock;
unsigned int mclk;
/* cached value of requested clk in set_ios */
unsigned int clock_cache;
unsigned int cclk;
u32 pwr_reg;
u32 pwr_reg_add;
u32 clk_reg;
u32 datactrl_reg;
u32 busy_status;
u32 mask1_reg;
bool vqmmc_enabled;
struct mmci_platform_data *plat;
struct mmci_host_ops *ops;
struct variant_data *variant;
struct pinctrl *pinctrl;
struct pinctrl_state *pins_default;
struct pinctrl_state *pins_opendrain;
u8 hw_designer;
u8 hw_revision:4;
struct timer_list timer;
unsigned int oldstat;
/* pio stuff */
struct sg_mapping_iter sg_miter;
unsigned int size;
int (*get_rx_fifocnt)(struct mmci_host *h, u32 status, int remain);
#ifdef CONFIG_DMA_ENGINE
/* DMA stuff */
struct dma_chan *dma_current;
struct dma_chan *dma_rx_channel;
struct dma_chan *dma_tx_channel;
struct dma_async_tx_descriptor *dma_desc_current;
struct mmci_host_next next_data;
bool dma_in_progress;
#define dma_inprogress(host) ((host)->dma_in_progress)
#else
#define dma_inprogress(host) (0)
#endif
};
+187
View File
@@ -0,0 +1,187 @@
/*
*
* Copyright (c) 2011, The Linux Foundation. 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 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#include <linux/of.h>
#include <linux/of_dma.h>
#include <linux/bitops.h>
#include <linux/mmc/host.h>
#include <linux/mmc/card.h>
#include "mmci.h"
/* Registers */
#define DML_CONFIG 0x00
#define PRODUCER_CRCI_MSK GENMASK(1, 0)
#define PRODUCER_CRCI_DISABLE 0
#define PRODUCER_CRCI_X_SEL BIT(0)
#define PRODUCER_CRCI_Y_SEL BIT(1)
#define CONSUMER_CRCI_MSK GENMASK(3, 2)
#define CONSUMER_CRCI_DISABLE 0
#define CONSUMER_CRCI_X_SEL BIT(2)
#define CONSUMER_CRCI_Y_SEL BIT(3)
#define PRODUCER_TRANS_END_EN BIT(4)
#define BYPASS BIT(16)
#define DIRECT_MODE BIT(17)
#define INFINITE_CONS_TRANS BIT(18)
#define DML_SW_RESET 0x08
#define DML_PRODUCER_START 0x0c
#define DML_CONSUMER_START 0x10
#define DML_PRODUCER_PIPE_LOGICAL_SIZE 0x14
#define DML_CONSUMER_PIPE_LOGICAL_SIZE 0x18
#define DML_PIPE_ID 0x1c
#define PRODUCER_PIPE_ID_SHFT 0
#define PRODUCER_PIPE_ID_MSK GENMASK(4, 0)
#define CONSUMER_PIPE_ID_SHFT 16
#define CONSUMER_PIPE_ID_MSK GENMASK(20, 16)
#define DML_PRODUCER_BAM_BLOCK_SIZE 0x24
#define DML_PRODUCER_BAM_TRANS_SIZE 0x28
/* other definitions */
#define PRODUCER_PIPE_LOGICAL_SIZE 4096
#define CONSUMER_PIPE_LOGICAL_SIZE 4096
#define DML_OFFSET 0x800
void dml_start_xfer(struct mmci_host *host, struct mmc_data *data)
{
u32 config;
void __iomem *base = host->base + DML_OFFSET;
if (data->flags & MMC_DATA_READ) {
/* Read operation: configure DML for producer operation */
/* Set producer CRCI-x and disable consumer CRCI */
config = readl_relaxed(base + DML_CONFIG);
config = (config & ~PRODUCER_CRCI_MSK) | PRODUCER_CRCI_X_SEL;
config = (config & ~CONSUMER_CRCI_MSK) | CONSUMER_CRCI_DISABLE;
writel_relaxed(config, base + DML_CONFIG);
/* Set the Producer BAM block size */
writel_relaxed(data->blksz, base + DML_PRODUCER_BAM_BLOCK_SIZE);
/* Set Producer BAM Transaction size */
writel_relaxed(data->blocks * data->blksz,
base + DML_PRODUCER_BAM_TRANS_SIZE);
/* Set Producer Transaction End bit */
config = readl_relaxed(base + DML_CONFIG);
config |= PRODUCER_TRANS_END_EN;
writel_relaxed(config, base + DML_CONFIG);
/* Trigger producer */
writel_relaxed(1, base + DML_PRODUCER_START);
} else {
/* Write operation: configure DML for consumer operation */
/* Set consumer CRCI-x and disable producer CRCI*/
config = readl_relaxed(base + DML_CONFIG);
config = (config & ~CONSUMER_CRCI_MSK) | CONSUMER_CRCI_X_SEL;
config = (config & ~PRODUCER_CRCI_MSK) | PRODUCER_CRCI_DISABLE;
writel_relaxed(config, base + DML_CONFIG);
/* Clear Producer Transaction End bit */
config = readl_relaxed(base + DML_CONFIG);
config &= ~PRODUCER_TRANS_END_EN;
writel_relaxed(config, base + DML_CONFIG);
/* Trigger consumer */
writel_relaxed(1, base + DML_CONSUMER_START);
}
/* make sure the dml is configured before dma is triggered */
wmb();
}
static int of_get_dml_pipe_index(struct device_node *np, const char *name)
{
int index;
struct of_phandle_args dma_spec;
index = of_property_match_string(np, "dma-names", name);
if (index < 0)
return -ENODEV;
if (of_parse_phandle_with_args(np, "dmas", "#dma-cells", index,
&dma_spec))
return -ENODEV;
if (dma_spec.args_count)
return dma_spec.args[0];
return -ENODEV;
}
/* Initialize the dml hardware connected to SD Card controller */
static void qcom_dma_setup(struct mmci_host *host)
{
u32 config;
void __iomem *base;
int consumer_id, producer_id;
struct device_node *np = host->mmc->parent->of_node;
consumer_id = of_get_dml_pipe_index(np, "tx");
producer_id = of_get_dml_pipe_index(np, "rx");
if (producer_id < 0 || consumer_id < 0) {
host->variant->qcom_dml = false;
return;
}
base = host->base + DML_OFFSET;
/* Reset the DML block */
writel_relaxed(1, base + DML_SW_RESET);
/* Disable the producer and consumer CRCI */
config = (PRODUCER_CRCI_DISABLE | CONSUMER_CRCI_DISABLE);
/*
* Disable the bypass mode. Bypass mode will only be used
* if data transfer is to happen in PIO mode and don't
* want the BAM interface to connect with SDCC-DML.
*/
config &= ~BYPASS;
/*
* Disable direct mode as we don't DML to MASTER the AHB bus.
* BAM connected with DML should MASTER the AHB bus.
*/
config &= ~DIRECT_MODE;
/*
* Disable infinite mode transfer as we won't be doing any
* infinite size data transfers. All data transfer will be
* of finite data size.
*/
config &= ~INFINITE_CONS_TRANS;
writel_relaxed(config, base + DML_CONFIG);
/*
* Initialize the logical BAM pipe size for producer
* and consumer.
*/
writel_relaxed(PRODUCER_PIPE_LOGICAL_SIZE,
base + DML_PRODUCER_PIPE_LOGICAL_SIZE);
writel_relaxed(CONSUMER_PIPE_LOGICAL_SIZE,
base + DML_CONSUMER_PIPE_LOGICAL_SIZE);
/* Initialize Producer/consumer pipe id */
writel_relaxed(producer_id | (consumer_id << CONSUMER_PIPE_ID_SHFT),
base + DML_PIPE_ID);
/* Make sure dml initialization is finished */
mb();
}
static struct mmci_host_ops qcom_variant_ops = {
.dma_setup = qcom_dma_setup,
};
void qcom_variant_init(struct mmci_host *host)
{
host->ops = &qcom_variant_ops;
}
+30
View File
@@ -0,0 +1,30 @@
/*
*
* Copyright (c) 2011, The Linux Foundation. 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 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#ifndef __MMC_QCOM_DML_H__
#define __MMC_QCOM_DML_H__
#ifdef CONFIG_MMC_QCOM_DML
void qcom_variant_init(struct mmci_host *host);
void dml_start_xfer(struct mmci_host *host, struct mmc_data *data);
#else
static inline void qcom_variant_init(struct mmci_host *host)
{
}
static inline void dml_start_xfer(struct mmci_host *host, struct mmc_data *data)
{
}
#endif /* CONFIG_MMC_QCOM_DML */
#endif /* __MMC_QCOM_DML_H__ */
+728
View File
@@ -0,0 +1,728 @@
/*
* MOXA ART MMC host driver.
*
* Copyright (C) 2014 Jonas Jensen
*
* Jonas Jensen <jonas.jensen@gmail.com>
*
* Based on code from
* Moxa Technologies Co., Ltd. <www.moxa.com>
*
* This file is licensed under the terms of the GNU General Public
* License version 2. This program is licensed "as is" without any
* warranty of any kind, whether express or implied.
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/blkdev.h>
#include <linux/dma-mapping.h>
#include <linux/dmaengine.h>
#include <linux/mmc/host.h>
#include <linux/mmc/sd.h>
#include <linux/sched.h>
#include <linux/io.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/clk.h>
#include <linux/bitops.h>
#include <linux/of_dma.h>
#include <linux/spinlock.h>
#define REG_COMMAND 0
#define REG_ARGUMENT 4
#define REG_RESPONSE0 8
#define REG_RESPONSE1 12
#define REG_RESPONSE2 16
#define REG_RESPONSE3 20
#define REG_RESPONSE_COMMAND 24
#define REG_DATA_CONTROL 28
#define REG_DATA_TIMER 32
#define REG_DATA_LENGTH 36
#define REG_STATUS 40
#define REG_CLEAR 44
#define REG_INTERRUPT_MASK 48
#define REG_POWER_CONTROL 52
#define REG_CLOCK_CONTROL 56
#define REG_BUS_WIDTH 60
#define REG_DATA_WINDOW 64
#define REG_FEATURE 68
#define REG_REVISION 72
/* REG_COMMAND */
#define CMD_SDC_RESET BIT(10)
#define CMD_EN BIT(9)
#define CMD_APP_CMD BIT(8)
#define CMD_LONG_RSP BIT(7)
#define CMD_NEED_RSP BIT(6)
#define CMD_IDX_MASK 0x3f
/* REG_RESPONSE_COMMAND */
#define RSP_CMD_APP BIT(6)
#define RSP_CMD_IDX_MASK 0x3f
/* REG_DATA_CONTROL */
#define DCR_DATA_FIFO_RESET BIT(8)
#define DCR_DATA_THRES BIT(7)
#define DCR_DATA_EN BIT(6)
#define DCR_DMA_EN BIT(5)
#define DCR_DATA_WRITE BIT(4)
#define DCR_BLK_SIZE 0x0f
/* REG_DATA_LENGTH */
#define DATA_LEN_MASK 0xffffff
/* REG_STATUS */
#define WRITE_PROT BIT(12)
#define CARD_DETECT BIT(11)
/* 1-10 below can be sent to either registers, interrupt or clear. */
#define CARD_CHANGE BIT(10)
#define FIFO_ORUN BIT(9)
#define FIFO_URUN BIT(8)
#define DATA_END BIT(7)
#define CMD_SENT BIT(6)
#define DATA_CRC_OK BIT(5)
#define RSP_CRC_OK BIT(4)
#define DATA_TIMEOUT BIT(3)
#define RSP_TIMEOUT BIT(2)
#define DATA_CRC_FAIL BIT(1)
#define RSP_CRC_FAIL BIT(0)
#define MASK_RSP (RSP_TIMEOUT | RSP_CRC_FAIL | \
RSP_CRC_OK | CARD_DETECT | CMD_SENT)
#define MASK_DATA (DATA_CRC_OK | DATA_END | \
DATA_CRC_FAIL | DATA_TIMEOUT)
#define MASK_INTR_PIO (FIFO_URUN | FIFO_ORUN | CARD_CHANGE)
/* REG_POWER_CONTROL */
#define SD_POWER_ON BIT(4)
#define SD_POWER_MASK 0x0f
/* REG_CLOCK_CONTROL */
#define CLK_HISPD BIT(9)
#define CLK_OFF BIT(8)
#define CLK_SD BIT(7)
#define CLK_DIV_MASK 0x7f
/* REG_BUS_WIDTH */
#define BUS_WIDTH_8 BIT(2)
#define BUS_WIDTH_4 BIT(1)
#define BUS_WIDTH_1 BIT(0)
#define MMC_VDD_360 23
#define MIN_POWER (MMC_VDD_360 - SD_POWER_MASK)
#define MAX_RETRIES 500000
struct moxart_host {
spinlock_t lock;
void __iomem *base;
phys_addr_t reg_phys;
struct dma_chan *dma_chan_tx;
struct dma_chan *dma_chan_rx;
struct dma_async_tx_descriptor *tx_desc;
struct mmc_host *mmc;
struct mmc_request *mrq;
struct scatterlist *cur_sg;
struct completion dma_complete;
struct completion pio_complete;
u32 num_sg;
u32 data_remain;
u32 data_len;
u32 fifo_width;
u32 timeout;
u32 rate;
long sysclk;
bool have_dma;
bool is_removed;
};
static inline void moxart_init_sg(struct moxart_host *host,
struct mmc_data *data)
{
host->cur_sg = data->sg;
host->num_sg = data->sg_len;
host->data_remain = host->cur_sg->length;
if (host->data_remain > host->data_len)
host->data_remain = host->data_len;
}
static inline int moxart_next_sg(struct moxart_host *host)
{
int remain;
struct mmc_data *data = host->mrq->cmd->data;
host->cur_sg++;
host->num_sg--;
if (host->num_sg > 0) {
host->data_remain = host->cur_sg->length;
remain = host->data_len - data->bytes_xfered;
if (remain > 0 && remain < host->data_remain)
host->data_remain = remain;
}
return host->num_sg;
}
static int moxart_wait_for_status(struct moxart_host *host,
u32 mask, u32 *status)
{
int ret = -ETIMEDOUT;
u32 i;
for (i = 0; i < MAX_RETRIES; i++) {
*status = readl(host->base + REG_STATUS);
if (!(*status & mask)) {
udelay(5);
continue;
}
writel(*status & mask, host->base + REG_CLEAR);
ret = 0;
break;
}
if (ret)
dev_err(mmc_dev(host->mmc), "timed out waiting for status\n");
return ret;
}
static void moxart_send_command(struct moxart_host *host,
struct mmc_command *cmd)
{
u32 status, cmdctrl;
writel(RSP_TIMEOUT | RSP_CRC_OK |
RSP_CRC_FAIL | CMD_SENT, host->base + REG_CLEAR);
writel(cmd->arg, host->base + REG_ARGUMENT);
cmdctrl = cmd->opcode & CMD_IDX_MASK;
if (cmdctrl == SD_APP_SET_BUS_WIDTH || cmdctrl == SD_APP_OP_COND ||
cmdctrl == SD_APP_SEND_SCR || cmdctrl == SD_APP_SD_STATUS ||
cmdctrl == SD_APP_SEND_NUM_WR_BLKS)
cmdctrl |= CMD_APP_CMD;
if (cmd->flags & MMC_RSP_PRESENT)
cmdctrl |= CMD_NEED_RSP;
if (cmd->flags & MMC_RSP_136)
cmdctrl |= CMD_LONG_RSP;
writel(cmdctrl | CMD_EN, host->base + REG_COMMAND);
if (moxart_wait_for_status(host, MASK_RSP, &status) == -ETIMEDOUT)
cmd->error = -ETIMEDOUT;
if (status & RSP_TIMEOUT) {
cmd->error = -ETIMEDOUT;
return;
}
if (status & RSP_CRC_FAIL) {
cmd->error = -EIO;
return;
}
if (status & RSP_CRC_OK) {
if (cmd->flags & MMC_RSP_136) {
cmd->resp[3] = readl(host->base + REG_RESPONSE0);
cmd->resp[2] = readl(host->base + REG_RESPONSE1);
cmd->resp[1] = readl(host->base + REG_RESPONSE2);
cmd->resp[0] = readl(host->base + REG_RESPONSE3);
} else {
cmd->resp[0] = readl(host->base + REG_RESPONSE0);
}
}
}
static void moxart_dma_complete(void *param)
{
struct moxart_host *host = param;
complete(&host->dma_complete);
}
static void moxart_transfer_dma(struct mmc_data *data, struct moxart_host *host)
{
u32 len, dir_slave;
long dma_time;
struct dma_async_tx_descriptor *desc = NULL;
struct dma_chan *dma_chan;
if (host->data_len == data->bytes_xfered)
return;
if (data->flags & MMC_DATA_WRITE) {
dma_chan = host->dma_chan_tx;
dir_slave = DMA_MEM_TO_DEV;
} else {
dma_chan = host->dma_chan_rx;
dir_slave = DMA_DEV_TO_MEM;
}
len = dma_map_sg(dma_chan->device->dev, data->sg,
data->sg_len, mmc_get_dma_dir(data));
if (len > 0) {
desc = dmaengine_prep_slave_sg(dma_chan, data->sg,
len, dir_slave,
DMA_PREP_INTERRUPT |
DMA_CTRL_ACK);
} else {
dev_err(mmc_dev(host->mmc), "dma_map_sg returned zero length\n");
}
if (desc) {
host->tx_desc = desc;
desc->callback = moxart_dma_complete;
desc->callback_param = host;
dmaengine_submit(desc);
dma_async_issue_pending(dma_chan);
}
data->bytes_xfered += host->data_remain;
dma_time = wait_for_completion_interruptible_timeout(
&host->dma_complete, host->timeout);
dma_unmap_sg(dma_chan->device->dev,
data->sg, data->sg_len,
mmc_get_dma_dir(data));
}
static void moxart_transfer_pio(struct moxart_host *host)
{
struct mmc_data *data = host->mrq->cmd->data;
u32 *sgp, len = 0, remain, status;
if (host->data_len == data->bytes_xfered)
return;
sgp = sg_virt(host->cur_sg);
remain = host->data_remain;
if (data->flags & MMC_DATA_WRITE) {
while (remain > 0) {
if (moxart_wait_for_status(host, FIFO_URUN, &status)
== -ETIMEDOUT) {
data->error = -ETIMEDOUT;
complete(&host->pio_complete);
return;
}
for (len = 0; len < remain && len < host->fifo_width;) {
iowrite32(*sgp, host->base + REG_DATA_WINDOW);
sgp++;
len += 4;
}
remain -= len;
}
} else {
while (remain > 0) {
if (moxart_wait_for_status(host, FIFO_ORUN, &status)
== -ETIMEDOUT) {
data->error = -ETIMEDOUT;
complete(&host->pio_complete);
return;
}
for (len = 0; len < remain && len < host->fifo_width;) {
/* SCR data must be read in big endian. */
if (data->mrq->cmd->opcode == SD_APP_SEND_SCR)
*sgp = ioread32be(host->base +
REG_DATA_WINDOW);
else
*sgp = ioread32(host->base +
REG_DATA_WINDOW);
sgp++;
len += 4;
}
remain -= len;
}
}
data->bytes_xfered += host->data_remain - remain;
host->data_remain = remain;
if (host->data_len != data->bytes_xfered)
moxart_next_sg(host);
else
complete(&host->pio_complete);
}
static void moxart_prepare_data(struct moxart_host *host)
{
struct mmc_data *data = host->mrq->cmd->data;
u32 datactrl;
int blksz_bits;
if (!data)
return;
host->data_len = data->blocks * data->blksz;
blksz_bits = ffs(data->blksz) - 1;
BUG_ON(1 << blksz_bits != data->blksz);
moxart_init_sg(host, data);
datactrl = DCR_DATA_EN | (blksz_bits & DCR_BLK_SIZE);
if (data->flags & MMC_DATA_WRITE)
datactrl |= DCR_DATA_WRITE;
if ((host->data_len > host->fifo_width) && host->have_dma)
datactrl |= DCR_DMA_EN;
writel(DCR_DATA_FIFO_RESET, host->base + REG_DATA_CONTROL);
writel(MASK_DATA | FIFO_URUN | FIFO_ORUN, host->base + REG_CLEAR);
writel(host->rate, host->base + REG_DATA_TIMER);
writel(host->data_len, host->base + REG_DATA_LENGTH);
writel(datactrl, host->base + REG_DATA_CONTROL);
}
static void moxart_request(struct mmc_host *mmc, struct mmc_request *mrq)
{
struct moxart_host *host = mmc_priv(mmc);
long pio_time;
unsigned long flags;
u32 status;
spin_lock_irqsave(&host->lock, flags);
init_completion(&host->dma_complete);
init_completion(&host->pio_complete);
host->mrq = mrq;
if (readl(host->base + REG_STATUS) & CARD_DETECT) {
mrq->cmd->error = -ETIMEDOUT;
goto request_done;
}
moxart_prepare_data(host);
moxart_send_command(host, host->mrq->cmd);
if (mrq->cmd->data) {
if ((host->data_len > host->fifo_width) && host->have_dma) {
writel(CARD_CHANGE, host->base + REG_INTERRUPT_MASK);
spin_unlock_irqrestore(&host->lock, flags);
moxart_transfer_dma(mrq->cmd->data, host);
spin_lock_irqsave(&host->lock, flags);
} else {
writel(MASK_INTR_PIO, host->base + REG_INTERRUPT_MASK);
spin_unlock_irqrestore(&host->lock, flags);
/* PIO transfers start from interrupt. */
pio_time = wait_for_completion_interruptible_timeout(
&host->pio_complete, host->timeout);
spin_lock_irqsave(&host->lock, flags);
}
if (host->is_removed) {
dev_err(mmc_dev(host->mmc), "card removed\n");
mrq->cmd->error = -ETIMEDOUT;
goto request_done;
}
if (moxart_wait_for_status(host, MASK_DATA, &status)
== -ETIMEDOUT) {
mrq->cmd->data->error = -ETIMEDOUT;
goto request_done;
}
if (status & DATA_CRC_FAIL)
mrq->cmd->data->error = -ETIMEDOUT;
if (mrq->cmd->data->stop)
moxart_send_command(host, mrq->cmd->data->stop);
}
request_done:
spin_unlock_irqrestore(&host->lock, flags);
mmc_request_done(host->mmc, mrq);
}
static irqreturn_t moxart_irq(int irq, void *devid)
{
struct moxart_host *host = (struct moxart_host *)devid;
u32 status;
unsigned long flags;
spin_lock_irqsave(&host->lock, flags);
status = readl(host->base + REG_STATUS);
if (status & CARD_CHANGE) {
host->is_removed = status & CARD_DETECT;
if (host->is_removed && host->have_dma) {
dmaengine_terminate_all(host->dma_chan_tx);
dmaengine_terminate_all(host->dma_chan_rx);
}
host->mrq = NULL;
writel(MASK_INTR_PIO, host->base + REG_CLEAR);
writel(CARD_CHANGE, host->base + REG_INTERRUPT_MASK);
mmc_detect_change(host->mmc, 0);
}
if (status & (FIFO_ORUN | FIFO_URUN) && host->mrq)
moxart_transfer_pio(host);
spin_unlock_irqrestore(&host->lock, flags);
return IRQ_HANDLED;
}
static void moxart_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
{
struct moxart_host *host = mmc_priv(mmc);
unsigned long flags;
u8 power, div;
u32 ctrl;
spin_lock_irqsave(&host->lock, flags);
if (ios->clock) {
for (div = 0; div < CLK_DIV_MASK; ++div) {
if (ios->clock >= host->sysclk / (2 * (div + 1)))
break;
}
ctrl = CLK_SD | div;
host->rate = host->sysclk / (2 * (div + 1));
if (host->rate > host->sysclk)
ctrl |= CLK_HISPD;
writel(ctrl, host->base + REG_CLOCK_CONTROL);
}
if (ios->power_mode == MMC_POWER_OFF) {
writel(readl(host->base + REG_POWER_CONTROL) & ~SD_POWER_ON,
host->base + REG_POWER_CONTROL);
} else {
if (ios->vdd < MIN_POWER)
power = 0;
else
power = ios->vdd - MIN_POWER;
writel(SD_POWER_ON | (u32) power,
host->base + REG_POWER_CONTROL);
}
switch (ios->bus_width) {
case MMC_BUS_WIDTH_4:
writel(BUS_WIDTH_4, host->base + REG_BUS_WIDTH);
break;
case MMC_BUS_WIDTH_8:
writel(BUS_WIDTH_8, host->base + REG_BUS_WIDTH);
break;
default:
writel(BUS_WIDTH_1, host->base + REG_BUS_WIDTH);
break;
}
spin_unlock_irqrestore(&host->lock, flags);
}
static int moxart_get_ro(struct mmc_host *mmc)
{
struct moxart_host *host = mmc_priv(mmc);
return !!(readl(host->base + REG_STATUS) & WRITE_PROT);
}
static const struct mmc_host_ops moxart_ops = {
.request = moxart_request,
.set_ios = moxart_set_ios,
.get_ro = moxart_get_ro,
};
static int moxart_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->of_node;
struct resource res_mmc;
struct mmc_host *mmc;
struct moxart_host *host = NULL;
struct dma_slave_config cfg;
struct clk *clk;
void __iomem *reg_mmc;
int irq, ret;
u32 i;
mmc = mmc_alloc_host(sizeof(struct moxart_host), dev);
if (!mmc) {
dev_err(dev, "mmc_alloc_host failed\n");
ret = -ENOMEM;
goto out;
}
ret = of_address_to_resource(node, 0, &res_mmc);
if (ret) {
dev_err(dev, "of_address_to_resource failed\n");
goto out;
}
irq = irq_of_parse_and_map(node, 0);
if (irq <= 0) {
dev_err(dev, "irq_of_parse_and_map failed\n");
ret = -EINVAL;
goto out;
}
clk = devm_clk_get(dev, NULL);
if (IS_ERR(clk)) {
ret = PTR_ERR(clk);
goto out;
}
reg_mmc = devm_ioremap_resource(dev, &res_mmc);
if (IS_ERR(reg_mmc)) {
ret = PTR_ERR(reg_mmc);
goto out;
}
ret = mmc_of_parse(mmc);
if (ret)
goto out;
host = mmc_priv(mmc);
host->mmc = mmc;
host->base = reg_mmc;
host->reg_phys = res_mmc.start;
host->timeout = msecs_to_jiffies(1000);
host->sysclk = clk_get_rate(clk);
host->fifo_width = readl(host->base + REG_FEATURE) << 2;
host->dma_chan_tx = dma_request_slave_channel_reason(dev, "tx");
host->dma_chan_rx = dma_request_slave_channel_reason(dev, "rx");
spin_lock_init(&host->lock);
mmc->ops = &moxart_ops;
mmc->f_max = DIV_ROUND_CLOSEST(host->sysclk, 2);
mmc->f_min = DIV_ROUND_CLOSEST(host->sysclk, CLK_DIV_MASK * 2);
mmc->ocr_avail = 0xffff00; /* Support 2.0v - 3.6v power. */
if (IS_ERR(host->dma_chan_tx) || IS_ERR(host->dma_chan_rx)) {
if (PTR_ERR(host->dma_chan_tx) == -EPROBE_DEFER ||
PTR_ERR(host->dma_chan_rx) == -EPROBE_DEFER) {
ret = -EPROBE_DEFER;
goto out;
}
dev_dbg(dev, "PIO mode transfer enabled\n");
host->have_dma = false;
} else {
dev_dbg(dev, "DMA channels found (%p,%p)\n",
host->dma_chan_tx, host->dma_chan_rx);
host->have_dma = true;
cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
cfg.direction = DMA_MEM_TO_DEV;
cfg.src_addr = 0;
cfg.dst_addr = host->reg_phys + REG_DATA_WINDOW;
dmaengine_slave_config(host->dma_chan_tx, &cfg);
cfg.direction = DMA_DEV_TO_MEM;
cfg.src_addr = host->reg_phys + REG_DATA_WINDOW;
cfg.dst_addr = 0;
dmaengine_slave_config(host->dma_chan_rx, &cfg);
}
switch ((readl(host->base + REG_BUS_WIDTH) >> 3) & 3) {
case 1:
mmc->caps |= MMC_CAP_4_BIT_DATA;
break;
case 2:
mmc->caps |= MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA;
break;
default:
break;
}
writel(0, host->base + REG_INTERRUPT_MASK);
writel(CMD_SDC_RESET, host->base + REG_COMMAND);
for (i = 0; i < MAX_RETRIES; i++) {
if (!(readl(host->base + REG_COMMAND) & CMD_SDC_RESET))
break;
udelay(5);
}
ret = devm_request_irq(dev, irq, moxart_irq, 0, "moxart-mmc", host);
if (ret)
goto out;
dev_set_drvdata(dev, mmc);
mmc_add_host(mmc);
dev_dbg(dev, "IRQ=%d, FIFO is %d bytes\n", irq, host->fifo_width);
return 0;
out:
if (mmc)
mmc_free_host(mmc);
return ret;
}
static int moxart_remove(struct platform_device *pdev)
{
struct mmc_host *mmc = dev_get_drvdata(&pdev->dev);
struct moxart_host *host = mmc_priv(mmc);
dev_set_drvdata(&pdev->dev, NULL);
if (mmc) {
if (!IS_ERR(host->dma_chan_tx))
dma_release_channel(host->dma_chan_tx);
if (!IS_ERR(host->dma_chan_rx))
dma_release_channel(host->dma_chan_rx);
mmc_remove_host(mmc);
mmc_free_host(mmc);
writel(0, host->base + REG_INTERRUPT_MASK);
writel(0, host->base + REG_POWER_CONTROL);
writel(readl(host->base + REG_CLOCK_CONTROL) | CLK_OFF,
host->base + REG_CLOCK_CONTROL);
}
return 0;
}
static const struct of_device_id moxart_mmc_match[] = {
{ .compatible = "moxa,moxart-mmc" },
{ .compatible = "faraday,ftsdc010" },
{ }
};
MODULE_DEVICE_TABLE(of, moxart_mmc_match);
static struct platform_driver moxart_mmc_driver = {
.probe = moxart_probe,
.remove = moxart_remove,
.driver = {
.name = "mmc-moxart",
.of_match_table = moxart_mmc_match,
},
};
module_platform_driver(moxart_mmc_driver);
MODULE_ALIAS("platform:mmc-moxart");
MODULE_DESCRIPTION("MOXA ART MMC driver");
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Jonas Jensen <jonas.jensen@gmail.com>");
+262
View File
@@ -0,0 +1,262 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_MSDC_H__
#define __MT_MSDC_H__
#include <mt-plat/sync_write.h>
#if defined(CONFIG_MACH_MT6768) && defined(CONFIG_MTK_PMQOS)
#include <linux/soc/mediatek/mtk-pm-qos.h>
#endif
#define HOST_MAX_NUM (2)
#define TUNE_NONE (0) /* No need tune */
#define TUNE_CMD_CRC (0x1 << 0) /* transfer cmd crc */
#define TUNE_DATA_WRITE (0x1 << 1) /* transfer data crc */
#define TUNE_DATA_READ (0x1 << 2) /* transfer data crc */
#define TUNE_CMD_TMO (0x1 << 3) /* transfer cmd tmo */
#define TUNE_AUTOK_PASS (0x1 << 4) /* autok pass flag */
enum {
MODE_PIO = 0,
MODE_DMA = 1,
MODE_SIZE_DEP = 2,
MODE_NONE = 3,
};
static inline unsigned int uffs(unsigned int x)
{
unsigned int r = 1;
if (!x)
return 0;
if (!(x & 0xffff)) {
x >>= 16;
r += 16;
}
if (!(x & 0xff)) {
x >>= 8;
r += 8;
}
if (!(x & 0xf)) {
x >>= 4;
r += 4;
}
if (!(x & 3)) {
x >>= 2;
r += 2;
}
if (!(x & 1)) {
x >>= 1;
r += 1;
}
return r;
}
#define MSDC_READ8(reg) __raw_readb(reg)
#define MSDC_READ16(reg) __raw_readw(reg)
#define MSDC_READ32(reg) __raw_readl(reg)
#define MSDC_WRITE8(reg, val) mt_reg_sync_writeb(val, reg)
#define MSDC_WRITE16(reg, val) mt_reg_sync_writew(val, reg)
#define MSDC_WRITE32(reg, val) mt_reg_sync_writel(val, reg)
#define UNSTUFF_BITS(resp, start, size) \
({ \
const int __size = size; \
const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \
const int __off = 3 - ((start) / 32); \
const int __shft = (start) & 31; \
u32 __res; \
__res = resp[__off] >> __shft; \
if (__size + __shft > 32) \
__res |= resp[__off-1] << ((32 - __shft) % 32); \
__res & __mask; \
})
#define MSDC_SET_BIT32(reg, bs) \
do { \
unsigned int tv = MSDC_READ32(reg);\
tv |= (u32)(bs); \
MSDC_WRITE32(reg, tv); \
} while (0)
#define MSDC_CLR_BIT32(reg, bs) \
do { \
unsigned int tv = MSDC_READ32(reg);\
tv &= ~((u32)(bs)); \
MSDC_WRITE32(reg, tv); \
} while (0)
#define MSDC_SET_FIELD(reg, field, val) \
do { \
unsigned int tv = MSDC_READ32(reg); \
tv &= ~(field); \
tv |= ((val) << (uffs((unsigned int)field) - 1)); \
MSDC_WRITE32(reg, tv); \
} while (0)
#define MSDC_GET_FIELD(reg, field, val) \
do { \
unsigned int tv = MSDC_READ32(reg); \
val = ((tv & (field)) >> (uffs((unsigned int)field) - 1)); \
} while (0)
#define GET_FIELD(reg, field_shift, field_mask, val) \
(val = (reg >> field_shift) & field_mask)
struct mt_gpdma_desc {
u32 gpd_info;
#define GPDMA_DESC_HWO (0x1 << 0)
#define GPDMA_DESC_BDP (0x1 << 1)
#define GPDMA_DESC_CHECKSUM (0xff << 8) /* bit8 ~ bit15 */
#define GPDMA_DESC_INT (0x1 << 16)
#define GPDMA_DESC_NEXT_H4 (0xf << 24)
#define GPDMA_DESC_PTR_H4 (0xf << 28)
u32 next;
u32 ptr;
u32 gpd_data_len;
#define GPDMA_DESC_BUFLEN (0xffff) /* bit0 ~ bit15 */
#define GPDMA_DESC_EXTLEN (0xff << 16) /* bit16 ~ bit23 */
u32 arg;
u32 blknum;
u32 cmd;
};
struct mt_bdma_desc {
u32 bd_info;
#define BDMA_DESC_EOL (0x1 << 0)
#define BDMA_DESC_CHECKSUM (0xff << 8) /* bit8 ~ bit15 */
#define BDMA_DESC_BLKPAD (0x1 << 17)
#define BDMA_DESC_DWPAD (0x1 << 18)
#define BDMA_DESC_NEXT_H4 (0xf << 24)
#define BDMA_DESC_PTR_H4 (0xf << 28)
u32 next;
u32 ptr;
u32 bd_data_len;
#define BDMA_DESC_BUFLEN (0xffff) /* bit0 ~ bit15 */
#define BDMA_DESC_BUFLEN_EXT (0xffffff) /* bit0 ~ bit23 */
};
struct msdc_dma {
struct scatterlist *sg; /* I/O scatter list */
struct mt_gpdma_desc *gpd; /* pointer to gpd array */
struct mt_bdma_desc *bd; /* pointer to bd array */
dma_addr_t gpd_addr; /* the physical address of gpd array */
dma_addr_t bd_addr; /* the physical address of bd array */
};
struct msdc_save_para {
u32 msdc_cfg;
u32 iocon;
u32 sdc_cfg;
u32 pad_tune;
u32 patch_bit0;
u32 patch_bit1;
u32 patch_bit2;
u32 pad_ds_tune;
u32 pad_cmd_tune;
u32 emmc50_cfg0;
u32 emmc50_cfg3;
u32 sdc_fifo_cfg;
u32 emmc_top_control;
u32 emmc_top_cmd;
u32 emmc50_pad_ds_tune;
};
struct msdc_tune_para {
u32 iocon;
u32 pad_tune;
u32 pad_cmd_tune;
u32 emmc_top_control;
u32 emmc_top_cmd;
};
struct msdc_host {
struct device *dev;
const struct mtk_mmc_compatible *dev_comp;
struct mmc_host *mmc; /* mmc structure */
int cmd_rsp;
spinlock_t lock;
struct mmc_request *mrq;
struct mmc_command *cmd;
struct mmc_data *data;
int error;
void __iomem *base; /* host base address */
void __iomem *top_base; /* host top register base address */
struct msdc_dma dma; /* dma channel */
u64 dma_mask;
u32 timeout_ns; /* data timeout ns */
u32 timeout_clks; /* data timeout clks */
struct pinctrl *pinctrl;
struct pinctrl_state *pins_default;
struct pinctrl_state *pins_uhs;
struct pinctrl_state *pins_pull_down;
struct delayed_work req_timeout;
int irq; /* host interrupt */
struct clk *src_clk; /* msdc source clock */
struct clk *h_clk; /* msdc h_clk */
struct clk *bus_clk; /* bus clock which used to access register */
struct clk *src_clk_cg; /* msdc source clock control gate */
struct clk *crypto_clk; /* msdc crypto clock */
void __iomem *crypto_clk_base; /*dbg use: for dump aes clk cg*/
u32 mclk; /* mmc subsystem clock frequency */
u32 src_clk_freq; /* source clock frequency */
#ifdef CONFIG_MACH_MT8173
u32 sclk; /* SD/MS bus clock frequency */
#endif
unsigned char timing;
bool vqmmc_enabled;
#ifdef CONFIG_MACH_MT8173
u32 host_id;
#endif
u32 latch_ck;
u32 hs400_ds_delay;
u32 hs400_ds_dly3;
u32 hs200_cmd_int_delay; /* cmd internal delay for HS200/SDR104 */
u32 hs400_cmd_int_delay; /* cmd internal delay for HS400 */
#ifdef CONFIG_MACH_MT8173
u32 hs200_cmd_resp_sel; /* cmd response sample selection */
/* valid after tune response && final delay != 0xffffffff */
bool tune_response_valid;
u8 tune_response_delay; /* saved tune response value */
#endif
bool hs400_cmd_resp_sel_rising;
/* cmd response sample selection for HS400 */
bool hs400_mode; /* current eMMC will run at hs400 mode */
bool hs400_tuning; /* hs400 mode online tuning */
bool cqhci; /* support eMMC hw cmdq */
bool is_autok_done;
bool internal_cd; /* Use internal card-detect logic */
bool block_bad_card;
u8 card_inserted; /* the status of card inserted */
int retune_times;
u32 need_tune;
int power_cycle_cnt;
u32 data_timeout_cont; /* data continuous timeout */
struct msdc_save_para save_para; /* used when gate HCLK */
struct msdc_tune_para def_tune_para; /* default tune setting */
struct msdc_tune_para saved_tune_para; /* tune result of CMD21/CMD19 */
struct cqhci_host *cq_host;
#if defined(CONFIG_MACH_MT6768) && defined(CONFIG_MTK_PMQOS)
struct mtk_pm_qos_request pm_qos;
#endif
};
#endif
+481
View File
@@ -0,0 +1,481 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifdef pr_fmt
#undef pr_fmt
#endif
#define pr_fmt(fmt) "["KBUILD_MODNAME"]" fmt
#include <linux/sched.h>
#include <linux/kthread.h>
#include <linux/delay.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <mt-plat/mtk_boot_common.h>
#include <linux/io.h>
#include <linux/scatterlist.h>
#include <linux/gpio.h>
#include <linux/sched/clock.h>
#include <linux/mmc/mmc.h>
#include "mtk-msdc.h"
#include <../core/core.h>
#include <../core/card.h>
#include <../core/mmc_ops.h>
#include "mtk-sd-dbg.h"
struct msdc_host *mtk_msdc_host[] = { NULL, NULL, NULL};
static int enable_msdc_debug = 1;
static unsigned char cmd_buf[256];
#define dbg_max_cnt (40000)
#define MSDC_AEE_BUFFER_SIZE (300 * 1024)
struct dbg_run_host_log {
unsigned long long time_sec;
unsigned long long time_usec;
int type;
int cmd;
int arg;
int cpu;
unsigned long active_reqs;
int skip;
};
struct dbg_task_log {
u32 address;
unsigned long long size;
};
struct dbg_dma_cmd_log {
unsigned long long time;
int cmd;
int arg;
};
static struct dbg_run_host_log dbg_run_host_log_dat[dbg_max_cnt];
static struct dbg_dma_cmd_log dbg_dma_cmd_log_dat;
static struct dbg_task_log dbg_task_log_dat[32];
char msdc_aee_buffer[MSDC_AEE_BUFFER_SIZE];
static int dbg_host_cnt;
static unsigned int print_cpu_test = UINT_MAX;
void msdc_debug_set_host(struct mmc_host *mmc)
{
if (!mmc){
pr_info("mmc is null\n");
return;
}
if(mmc->index >=0 && mmc->index <= HOST_MAX_NUM)
mtk_msdc_host[mmc->index] = mmc_priv(mmc);
else
pr_info("error:index=%d\n",mmc->index);
}
EXPORT_SYMBOL_GPL(msdc_debug_set_host);
/*
* type 0: cmd; type 1: rsp; type 3: dma end
* when type 3: arg 0: no data crc error; arg 1: data crc error
* @cpu, current CPU ID
* @reserved, userd for softirq dump "data_active_reqs"
*/
inline void __dbg_add_host_log(struct mmc_host *mmc, int type,
int cmd, int arg, int cpu, unsigned long reserved)
{
unsigned long long t, tn;
unsigned long long nanosec_rem;
#ifdef CONFIG_MTK_EMMC_HW_CQ
unsigned long flags;
#endif
static int last_cmd, last_arg, skip;
int l_skip = 0;
struct msdc_host *host = mmc_priv(mmc);
static int tag = -1;
/* only log msdc0 */
if (!host || mmc->index != 0)
return;
t = cpu_clock(print_cpu_test);
#ifdef CONFIG_MTK_EMMC_HW_CQ
spin_lock_irqsave(&host->cmd_dump_lock, flags);
#endif
switch (type) {
case 0: /* normal - cmd */
tn = t;
nanosec_rem = do_div(t, 1000000000)/1000;
if (cmd == 44) {
tag = (arg >> 16) & 0x1f;
dbg_task_log_dat[tag].size = arg & 0xffff;
} else if (cmd == 45) {
dbg_task_log_dat[tag].address = arg;
} else if (cmd == 46 || cmd == 47) {
dbg_dma_cmd_log_dat.time = tn;
dbg_dma_cmd_log_dat.cmd = cmd;
dbg_dma_cmd_log_dat.arg = arg;
}
dbg_run_host_log_dat[dbg_host_cnt].time_sec = t;
dbg_run_host_log_dat[dbg_host_cnt].time_usec = nanosec_rem;
dbg_run_host_log_dat[dbg_host_cnt].type = type;
dbg_run_host_log_dat[dbg_host_cnt].cmd = cmd;
dbg_run_host_log_dat[dbg_host_cnt].arg = arg;
dbg_run_host_log_dat[dbg_host_cnt].skip = l_skip;
dbg_host_cnt++;
if (dbg_host_cnt >= dbg_max_cnt)
dbg_host_cnt = 0;
break;
case 1: /* normal -rsp */
case 5: /* cqhci - data */
case 6: /* cqhci - rsp */
case 60: /* cqhci - dcmd */
case 61: /* cqhci - dcmd resp */
nanosec_rem = do_div(t, 1000000000)/1000;
/*skip log if last cmd rsp are the same*/
if (last_cmd == cmd &&
last_arg == arg && cmd == 13) {
skip++;
if (dbg_host_cnt == 0)
dbg_host_cnt = dbg_max_cnt;
/*remove type = 0, command*/
dbg_host_cnt--;
break;
}
last_cmd = cmd;
last_arg = arg;
l_skip = skip;
skip = 0;
dbg_run_host_log_dat[dbg_host_cnt].time_sec = t;
dbg_run_host_log_dat[dbg_host_cnt].time_usec = nanosec_rem;
dbg_run_host_log_dat[dbg_host_cnt].type = type;
dbg_run_host_log_dat[dbg_host_cnt].cmd = cmd;
dbg_run_host_log_dat[dbg_host_cnt].arg = arg;
dbg_run_host_log_dat[dbg_host_cnt].skip = l_skip;
dbg_host_cnt++;
if (dbg_host_cnt >= dbg_max_cnt)
dbg_host_cnt = 0;
break;
/* add softirq record */
case MAGIC_CQHCI_DBG_TYPE_SIRQ:
tn = t;
nanosec_rem = do_div(t, 1000000000)/1000;
dbg_run_host_log_dat[dbg_host_cnt].time_sec = t;
dbg_run_host_log_dat[dbg_host_cnt].time_usec = nanosec_rem;
dbg_run_host_log_dat[dbg_host_cnt].type = type;
dbg_run_host_log_dat[dbg_host_cnt].cmd = cmd;
dbg_run_host_log_dat[dbg_host_cnt].arg = arg;
dbg_run_host_log_dat[dbg_host_cnt].skip = l_skip;
dbg_run_host_log_dat[dbg_host_cnt].cpu = cpu;
dbg_run_host_log_dat[dbg_host_cnt].active_reqs = reserved;
dbg_host_cnt++;
if (dbg_host_cnt >= dbg_max_cnt)
dbg_host_cnt = 0;
break;
default:
break;
}
#ifdef CONFIG_MTK_EMMC_HW_CQ
spin_unlock_irqrestore(&host->cmd_dump_lock, flags);
#endif
}
/* all cases which except softirq of IO */
void dbg_add_host_log(struct mmc_host *mmc, int type,
int cmd, int arg)
{
if(enable_msdc_debug == 1)
__dbg_add_host_log(mmc, type, cmd, arg, -1, 0);
}
void mmc_cmd_dump(char **buff, unsigned long *size, struct seq_file *m,
struct mmc_host *mmc, u32 latest_cnt)
{
int i, j;
int tag = -1;
int is_read, is_rel, is_fprg;
unsigned long long time_sec, time_usec;
int type, cmd, arg, skip, cnt, cpu;
unsigned long active_reqs;
struct msdc_host *host;
u32 dump_cnt;
#ifdef CONFIG_MTK_EMMC_HW_CQ
unsigned long curr_state;
#endif
if (!mmc || !mmc->card)
return;
/* only dump msdc0 */
host = mmc_priv(mmc);
if (!host || mmc->index != 0)
return;
dump_cnt = min_t(u32, latest_cnt, dbg_max_cnt);
i = dbg_host_cnt - 1;
if (i < 0)
i = dbg_max_cnt - 1;
for (j = 0; j < dump_cnt; j++) {
time_sec = dbg_run_host_log_dat[i].time_sec;
time_usec = dbg_run_host_log_dat[i].time_usec;
type = dbg_run_host_log_dat[i].type;
cmd = dbg_run_host_log_dat[i].cmd;
arg = dbg_run_host_log_dat[i].arg;
skip = dbg_run_host_log_dat[i].skip;
if (dbg_run_host_log_dat[i].type == 70) {
cpu = dbg_run_host_log_dat[i].cpu;
active_reqs = dbg_run_host_log_dat[i].active_reqs;
} else {
cpu = -1;
active_reqs = 0;
}
if (cmd == 44 && !type) {
cnt = arg & 0xffff;
tag = (arg >> 16) & 0x1f;
is_read = (arg >> 30) & 0x1;
is_rel = (arg >> 31) & 0x1;
is_fprg = (arg >> 24) & 0x1;
SPREAD_PRINTF(buff, size, m,
"%03d [%5llu.%06llu]%2d %3d %08x id=%02d %s cnt=%d %d %d\n",
j, time_sec, time_usec,
type, cmd, arg, tag,
is_read ? "R" : "W",
cnt, is_rel, is_fprg);
} else if ((cmd == 46 || cmd == 47) && !type) {
tag = (arg >> 16) & 0x1f;
SPREAD_PRINTF(buff, size, m,
"%03d [%5llu.%06llu]%2d %3d %08x id=%02d\n",
j, time_sec, time_usec,
type, cmd, arg, tag);
} else
SPREAD_PRINTF(buff, size, m,
"%03d [%5llu.%06llu]%2d %3d %08x(%d) (%d) (0x%08lx) (%d)\n",
j, time_sec, time_usec,
type, cmd, arg, arg, skip, active_reqs, cpu);
i--;
if (i < 0)
i = dbg_max_cnt - 1;
}
#ifdef CONFIG_MTK_EMMC_CQ_SUPPORT
SPREAD_PRINTF(buff, size, m,
"areq_cnt:%d, task_id_index %08lx, cq_wait_rdy:%d, cq_rdy_cnt:%d\n",
atomic_read(&mmc->areq_cnt),
mmc->task_id_index,
atomic_read(&mmc->cq_wait_rdy),
atomic_read(&mmc->cq_rdy_cnt));
#endif
#ifdef CONFIG_MTK_EMMC_HW_CQ
curr_state = mmc->cmdq_ctx.curr_state;
SPREAD_PRINTF(buff, size, m,
"active_reqs : 0x%lx\n",
mmc->cmdq_ctx.active_reqs);
SPREAD_PRINTF(buff, size, m,
"curr_state : 0x%lx\n",
curr_state);
SPREAD_PRINTF(buff, size, m,
"%s %s %s %s %s\n",
curr_state & (1 << CMDQ_STATE_ERR) ?
"ERR":"",
curr_state & (1 << CMDQ_STATE_DCMD_ACTIVE) ?
"DCMD_ACTIVE":"",
curr_state & (1 << CMDQ_STATE_HALT) ?
"HALT":"",
curr_state & (1 << CMDQ_STATE_CQ_DISABLE) ?
"CQ_DISABLE":"",
curr_state & (1 << CMDQ_STATE_REQ_TIMED_OUT) ?
"REQ_TIMED_OUT":"");
SPREAD_PRINTF(buff, size, m,
"part_curr : %d\n",
mmc->card->part_curr);
#endif
SPREAD_PRINTF(buff, size, m,
"claimed(%d), claim_cnt(%d), claimer pid(%d), comm %s\n",
mmc->claimed, mmc->claim_cnt,
mmc->claimer && mmc->claimer->task ?
mmc->claimer->task->pid : 0,
mmc->claimer && mmc->claimer->task ?
mmc->claimer->task->comm : "NULL");
}
void msdc_dump_host_state(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host)
{
void __iomem *base = host->base;
SPREAD_PRINTF(buff, size, m,
"enable_msdc_debug : %d\n", enable_msdc_debug);
/* add log description*/
SPREAD_PRINTF(buff, size, m,
"column 1 : log number(Reverse order);\n");
SPREAD_PRINTF(buff, size, m,
"column 2 : kernel time\n");
SPREAD_PRINTF(buff, size, m,
"column 3 : type(0-cmd, 1-resp, 5-cqhci cmd, 60-cqhci dcmd doorbell,");
SPREAD_PRINTF(buff, size, m,
"61-cqhci dcmd complete(irq in), 70-cqhci softirq in);\n");
SPREAD_PRINTF(buff, size, m,
"column 4&5 : cmd index&arg(1XX-task XX's task descriptor low 32bit, ");
SPREAD_PRINTF(buff, size, m,
"2XX-task XX's task descriptor high 32bit, ");
SPREAD_PRINTF(buff, size, m,
"5XX-task XX's task completion(irq in), ");
SPREAD_PRINTF(buff, size, m,
"others index-command index(non 70 type) or cmd/data error(70 type)) ");
SPREAD_PRINTF(buff, size, m,
"others arg-command arg(non 70 type) or cmdq_req->tag(70 type));\n");
SPREAD_PRINTF(buff, size, m,
"column 6 : repeat count(The role of problem analysis is low);\n");
SPREAD_PRINTF(buff, size, m,
"column 7 : record data_active_reqs;\n");
SPREAD_PRINTF(buff, size, m,
"column 8 : only record softirq's running CPU id(only for 70 type);\n");
}
static void msdc_proc_dump(struct seq_file *m, u32 id)
{
struct msdc_host *host = mtk_msdc_host[id];
if (host == NULL) {
pr_info("====== Null msdc%d, dump skipped ======\n", id);
return;
}
msdc_dump_host_state(NULL, NULL, m, host);
mmc_cmd_dump(NULL, NULL, m, host->mmc, dbg_max_cnt);
}
void get_msdc_aee_buffer(unsigned long *vaddr, unsigned long *size)
{
struct msdc_host *host = mtk_msdc_host[0];
unsigned long free_size = MSDC_AEE_BUFFER_SIZE;
char *buff;
if (host == NULL) {
pr_info("====== Null msdc, dump skipped ======\n");
return;
}
buff = msdc_aee_buffer;
msdc_dump_host_state(&buff, &free_size, NULL, host);
mmc_cmd_dump(&buff, &free_size, NULL, host->mmc, dbg_max_cnt);
/* retrun start location */
*vaddr = (unsigned long)msdc_aee_buffer;
*size = MSDC_AEE_BUFFER_SIZE - free_size;
}
EXPORT_SYMBOL(get_msdc_aee_buffer);
int g_count;
/* ========== driver proc interface =========== */
static int msdc_debug_proc_show(struct seq_file *m, void *v)
{
int cmd = -1;
int sscanf_num;
int p1, p2, p3, p4, p5, p6, p7, p8;
int id, zone;
int mode;
int thread_num, compare_count, multi_address;
void __iomem *base = NULL;
ulong data_for_wr;
unsigned int offset = 0;
unsigned int reg_value;
int spd_mode = MMC_TIMING_LEGACY;
struct msdc_host *host = NULL;
#ifdef MSDC_DMA_ADDR_DEBUG
struct dma_addr *dma_address, *p_dma_address;
#endif
int dma_status;
#ifdef MTK_MMC_SDIO_DEBUG
u8 *res;
int vcore;
#endif
/* default dump info for aee */
seq_puts(m, "==== msdc debug info for aee ====\n");
msdc_proc_dump(m, 0);
return 0;
}
static ssize_t msdc_debug_proc_write(struct file *file, const char *buf,
size_t count, loff_t *data)
{
int ret;
if (count == 0)
return -1;
if (count > 255)
count = 255;
g_count = count;
ret = copy_from_user(cmd_buf, buf, count);
if (ret < 0)
return -1;
switch (cmd_buf[0]) {
case 0x31:
enable_msdc_debug = 1;
break;
default :
enable_msdc_debug = 0;
break;
}
pr_info("enable_msdc_debug=%d\n", enable_msdc_debug);
return count;
}
static int msdc_proc_open(struct inode *inode, struct file *file)
{
return single_open(file, msdc_debug_proc_show, inode->i_private);
}
static const struct file_operations msdc_proc_fops = {
.open = msdc_proc_open,
.write = msdc_debug_proc_write,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
#ifndef USER_BUILD_KERNEL
#define PROC_PERM 0660
#else
#define PROC_PERM 0440
#endif
int msdc_debug_proc_init(void)
{
kuid_t uid;
kgid_t gid;
struct proc_dir_entry *prEntry;
#ifdef USER_BUILD_KERNEL
enable_msdc_debug = 0;
#else
enable_msdc_debug = 1;
#endif
uid = make_kuid(&init_user_ns, 0);
gid = make_kgid(&init_user_ns, 1001);
prEntry = proc_create("msdc_debug", PROC_PERM, NULL, &msdc_proc_fops);
if (prEntry)
proc_set_user(prEntry, uid, gid);
else
pr_info("[%s]: failed to create /proc/msdc_debug\n",
__func__);
return 0;
}
EXPORT_SYMBOL_GPL(msdc_debug_proc_init);
+161
View File
@@ -0,0 +1,161 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_MSDC_DEUBG__
#define __MT_MSDC_DEUBG__
#include "mtk-msdc.h"
#include <linux/seq_file.h>
/* #define MTK_MSDC_ERROR_TUNE_DEBUG */
enum {
SD_TOOL_ZONE = 0,
SD_TOOL_DMA_SIZE = 1,
SD_TOOL_SDIO_PROFILE = 3,
SD_TOOL_REG_ACCESS = 5,
SD_TOOL_SET_DRIVING = 6,
RW_BIT_BY_BIT_COMPARE = 8,
SMP_TEST_ON_ONE_HOST = 9,
SMP_TEST_ON_ALL_HOST = 10,
SD_TOOL_MSDC_HOST_MODE = 11,
SD_TOOL_DMA_STATUS = 12,
SD_TOOL_ENABLE_SLEW_RATE = 13,
SD_TOOL_ENABLE_SMT = 14,
MMC_PERF_DEBUG = 15,
MMC_PERF_DEBUG_PRINT = 16,
SD_TOOL_SET_RDTDSEL = 17,
MSDC_READ_WRITE = 20,
MMC_ERROR_TUNE = 21,
MMC_EDC_EMMC_CACHE = 22,
MMC_DUMP_GPD = 23,
MMC_ETT_TUNE = 24,
MMC_CRC_STRESS = 25,
ENABLE_AXI_MODULE = 26,
DO_AUTOK_OFFLINE_TUNE_TX = 29,
SDIO_AUTOK_RESULT = 30,
MMC_CMDQ_STATUS = 31,
SD_TOOL_TOP_REG_ACCESS = 32,
};
/* Debug message event */
#define DBG_EVT_NONE (0) /* No event */
#define DBG_EVT_DMA (1 << 0) /* DMA related event */
#define DBG_EVT_CMD (1 << 1) /* MSDC CMD related event */
#define DBG_EVT_RSP (1 << 2) /* MSDC CMD RSP related event */
#define DBG_EVT_INT (1 << 3) /* MSDC INT event */
#define DBG_EVT_CFG (1 << 4) /* MSDC CFG event */
#define DBG_EVT_FUC (1 << 5) /* Function event */
#define DBG_EVT_OPS (1 << 6) /* Read/Write operation event */
#define DBG_EVT_FIO (1 << 7) /* FIFO operation event */
#define DBG_EVT_WRN (1 << 8) /* Warning event */
#define DBG_EVT_PWR (1 << 9) /* Power event */
#define DBG_EVT_CLK (1 << 10) /* Clock gate/ungate operation */
#define DBG_EVT_CHE (1 << 11) /* eMMC cache feature operation */
/* ==================================================== */
#define DBG_EVT_RW (1 << 12) /* Trace the Read/Write Command */
#define DBG_EVT_NRW (1 << 13) /* Trace other Command */
#define DBG_EVT_ALL (0xffffffff)
#define DBG_EVT_MASK (DBG_EVT_ALL)
#define TAGMSDC "msdc"
#ifndef MTK_MMC_PRINT_PERIOD
#define ERR_MSG(fmt, args...) \
pr_info(TAGMSDC"%d -> "fmt" <- %s() : L<%d> PID<%s><0x%x>\n", \
host->id, ##args, __func__, __LINE__, current->comm, \
current->pid)
#else
#define MAX_PRINT_PERIOD (500000000) /* 500ms */
#define MAX_PRINT_NUMS_OVER_PERIOD (50)
#define ERR_MSG(fmt, args...) \
do { \
if (print_nums == 0) { \
print_nums++; \
msdc_print_start_time = sched_clock(); \
pr_info(TAGMSDC"MSDC", TAG"%d -> "fmt" <- %s() : L<%d> " \
"PID<%s><0x%x>\n", \
host->id, ##args, __func__, __LINE__, \
current->comm, current->pid); \
} else { \
msdc_print_end_time = sched_clock(); \
if ((msdc_print_end_time - msdc_print_start_time) >= \
MAX_PRINT_PERIOD) { \
pr_info( \
TAGMSDC"MSDC", TAG"%d -> "fmt" <- %s() : L<%d> " \
"PID<%s><0x%x>\n", \
host->id, ##args, __func__, __LINE__, \
current->comm, current->pid); \
print_nums = 0; \
} \
if (print_nums <= MAX_PRINT_NUMS_OVER_PERIOD) { \
pr_info(TAGMSDC"MSDC", TAG"%d -> "fmt" <- %s() : " \
"L<%d> PID<%s><0x%x>\n", \
host->id, ##args, __func__, \
__LINE__, current->comm, current->pid); \
print_nums++; \
} \
} \
} while (0)
#endif
#define INIT_MSG(fmt, args...) \
pr_info(TAGMSDC"%d -> "fmt" <- %s() : L<%d> PID<%s><0x%x>\n", \
host->id, ##args, __func__, __LINE__, current->comm, \
current->pid)
#define INFO_MSG(fmt, args...) \
pr_debug(TAGMSDC"%d -> "fmt" <- %s() : L<%d> PID<%s><0x%x>\n", \
host->id, ##args, __func__, __LINE__, current->comm, \
current->pid)
#ifdef MTK_MMC_PRINT_IRQ_MSG
/* PID in ISR in not corrent */
#define IRQ_MSG(fmt, args...) \
pr_info(TAGMSDC"%d -> "fmt" <- %s() : L<%d>\n", \
host->id, ##args, __func__, __LINE__)
#else
#define IRQ_MSG(fmt, args...)
#endif
/*
* snprintf may return a value of size or "more" to indicate
* that the output was truncated, thus be careful of "more"
* case.
*/
#define SPREAD_PRINTF(buff, size, evt, fmt, args...) \
do { \
if (buff && size && *(size)) { \
unsigned long var = snprintf(*(buff), *(size), fmt, ##args); \
if (var > 0) { \
if (var > *(size)) \
var = *(size); \
*(size) -= var; \
*(buff) += var; \
} \
} \
if (evt) \
seq_printf(evt, fmt, ##args); \
if (!buff && !evt) { \
pr_info(fmt, ##args); \
} \
} while (0)
#define MAGIC_CQHCI_DBG_TYPE 5
#define MAGIC_CQHCI_DBG_NUM_L 100
#define MAGIC_CQHCI_DBG_NUM_U 200
#define MAGIC_CQHCI_DBG_NUM_RI 500
#define MAGIC_CQHCI_DBG_TYPE_DCMD 60
/* softirq type */
#define MAGIC_CQHCI_DBG_TYPE_SIRQ 70
void msdc_debug_set_host(struct mmc_host *mmc);
int msdc_debug_proc_init(void);
void dbg_add_host_log(struct mmc_host *mmc, int type, int cmd, int arg);
void mmc_cmd_dump(char **buff, unsigned long *size, struct seq_file *m,
struct mmc_host *mmc, u32 latest_cnt);
void msdc_dump_host_state(char **buff, unsigned long *size,
struct seq_file *m, struct msdc_host *host);
#endif
File diff suppressed because it is too large. Load diff
+604
View File
@@ -0,0 +1,604 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2014-2021 MediaTek Inc.
* Author: Chaotian.Jing <chaotian.jing@mediatek.com>
*/
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/kthread.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <linux/random.h>
#include <linux/string.h>
#include <linux/uaccess.h>
#include <linux/mmc/host.h>
#include <linux/vmalloc.h>
#include <linux/fs.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/time.h>
#include <linux/mmc/card.h>
#include <linux/mmc/core.h>
#include <linux/mmc/host.h>
#include <linux/mmc/mmc.h>
#include <linux/mmc/sd.h>
#include <linux/mmc/sdio.h>
#include <linux/mmc/sdio_func.h>
#define SDIO_CCCR_MTK_DDR208 0xF2
#define SUCCESS 0
#define FAIL 1
enum {
Read = 0,
Write = 1,
Tune = 2,
Hqa_read = 3,
Hqa_write = 4,
Reset = 5,
Stress_read = 6,
Stress_write = 7,
Stress_test = 8,
Func_ctrl = 9,
Desense_read,
Desense_write
};
static struct mmc_host *host;
/**
* define some count timer.
*/
#define KAL_TIME_INTERVAL_DECLARATION() struct timeval __rTs, __rTe
#define KAL_REC_TIME_START() do_gettimeofday(&__rTs)
#define KAL_REC_TIME_END() do_gettimeofday(&__rTe)
#define KAL_GET_TIME_INTERVAL() \
((__rTe.tv_sec * USEC_PER_SEC + __rTe.tv_usec) - \
(__rTs.tv_sec * USEC_PER_SEC + __rTs.tv_usec))
/**
* sdio_proc_show dispaly the common cccr and cis.
*/
static int sdio_proc_show(struct seq_file *m, void *v)
{
struct mmc_card *card;
struct sdio_cccr cccr;
WARN_ON(!host);
card = host->card;
cccr = card->cccr;
seq_puts(m, "\n=========================================\n");
seq_puts(m, "common cccr:\n");
seq_printf(m, "sdio_vsn:%x, sd_vsn:%x, multi_block%x.\n"
"low_speed:%x, wide_bus:%x, hight_power:%x.\n"
"high_speed:%x, disable_cd:%x.\n",
cccr.sdio_vsn, cccr.sd_vsn, cccr.multi_block,
cccr.low_speed, cccr.wide_bus, cccr.high_power,
cccr.high_speed, cccr.disable_cd);
seq_puts(m, "common cis:\n");
seq_printf(m, "vendor: %x, device:%x, blksize:%x, max_dtr:%x\n",
card->cis.vendor, card->cis.device,
card->cis.blksize, card->cis.max_dtr);
seq_puts(m, "read cmd format:\n");
seq_puts(m, "echo 0 0xReg 0xfunction> /proc/sdio\n");
seq_puts(m, "write cmd format:\n");
seq_puts(m, "echo 1 0xReg 0xfunction 0xValue> /proc/sdio\n");
seq_puts(m, "tune cmd format:\n");
seq_puts(m, "echo 2 0xloop_cycles > /proc/sdio\n");
seq_puts(m, "multi read cmd format:\n");
seq_puts(m, "echo 3 0x13 0x0 > /proc/sdio\n");
seq_puts(m, "multi write cmd format:\n");
seq_puts(m, "echo 4 0x13 0x0 0xvalue > /proc/sdio\n");
seq_puts(m, "Notice:value is the read result!\n");
seq_puts(m, "reset sdio cmd format:\n");
seq_puts(m, "echo 5 0x0 0x0 > /proc/sdio\n");
seq_puts(m, "throughput read cmd format:\n");
seq_puts(m, "echo 6 0xb0 0x1 > /proc/sdio\n");
seq_puts(m, "throughtput write cmd format:\n");
seq_puts(m, "echo 7 0xb0 0x1 > /proc/sdio\n");
seq_puts(m, "stress test cmd format:\n");
seq_puts(m, "echo 8 0x0 0x1 > /proc/sdio\n");
seq_puts(m, "function enable cmd format:\n");
seq_puts(m, "echo 9 0x0/0x1 0xfunc_number > /proc/sdio\n");
seq_puts(m, "de-sense read cmd format:\n");
seq_puts(m, "echo a 0xb0 0x1 > /proc/sdio\n");
seq_puts(m, "de-sense write cmd format:\n");
seq_puts(m, "echo b 0xb0 0x1 > /proc/sdio\n");
seq_puts(m, "=========================================\n");
return 0;
}
static int sdio_tuning(void)
{
int err = 0;
err = mmc_send_tuning(host, MMC_SEND_TUNING_BLOCK, NULL);
return err;
}
/*
* This function can be used to do HQA.SDIO SHPA for read.
* HQA: for SDR104 mode, it is better to set 0xb8(func1) to 0x5a.
* HQA: for SD3.0 plus, it is better to set 0xb8(func1) to 0x33cc.
*/
static int multi_read(struct sdio_func *func, struct mmc_host *host)
{
int err, i;
u32 data, value, count_rw = 0;
unsigned long total = 0;
unsigned char *fac_buf = NULL;
KAL_TIME_INTERVAL_DECLARATION();
__kernel_suseconds_t usec;
func->cur_blksize = 0x200;
fac_buf = kmalloc(0x400, GFP_KERNEL);
if (!fac_buf)
return FAIL;
/* This function can be used to do HQA.SDIO SHPA */
data = sdio_f0_readb(func, SDIO_CCCR_MTK_DDR208, &err);
if (err) {
kfree(fac_buf);
return FAIL;
} else if ((data & 0x3) == 0x3) {
value = 0x33cc33cc;
err = sdio_writesb(func, 0x0, &value, 0x4);
dev_info(mmc_dev(host), "[sd3.0+]: value is 0x33cc\n");
} else {
value = 0x5a5a5a5a;
//err = sdio_writesb(func, 0x0, &value, 0x4);
dev_info(mmc_dev(host), "[sd3.0]: value is 0x5a5a\n");
}
//value = 0;
//err = sdio_readsb(func, &value, 0x0, 0x4);
i = 0;
/* byte to bit */
total = 0x400 * 0x10;
do {
if (i % 0x10 == 0)
KAL_REC_TIME_START();
//dev_info(mmc_dev(host),
//"[sd3.0]: value is 0x5a5a try read\n");
err = sdio_readsb(func, fac_buf, 0x0, 0x400);
//dev_info(mmc_dev(host),
//"[sd3.0]: value is 0x5a5a try read end\n");
if (err)
count_rw = count_rw + 1;
i = i + 1;
if ((i / 0x10) && (i % 0x10 == 0)) {
KAL_REC_TIME_END();
usec = KAL_GET_TIME_INTERVAL();
dev_info(mmc_dev(host), "read: %lu Kbps, err:%x.\n",
total / (usec / USEC_PER_MSEC), count_rw);
}
} while (i < 0x10);
kfree(fac_buf);
return SUCCESS;
}
/**
* This function can be used to do de-sense.HQA.SHPA for write.
* HQA: for SDR104 mode, it is better to set 0xb8(func1) to 0x5a.
* HQA: for SD3.0 plus, it is better to set 0xb8(func1) to 0x33cc.
* de_sense: data is random or not.
*/
static int multi_write(struct sdio_func *func, struct mmc_host *host,
int de_sense)
{
int err, i;
u32 data, count_rw = 0;
unsigned long total = 0;
unsigned char *fac_buf = NULL;
KAL_TIME_INTERVAL_DECLARATION();
__kernel_suseconds_t usec;
func->cur_blksize = 0x200;
fac_buf = kmalloc(0x400, GFP_KERNEL);
if (!fac_buf)
return FAIL;
/* This function can be used to do de-sense.HQA.SHPA */
data = sdio_f0_readb(func, SDIO_CCCR_MTK_DDR208, &err);
if (err) {
kfree(fac_buf);
return FAIL;
}
if (de_sense) {
//err = wait_for_random_bytes();
if (!err)
dev_info(mmc_dev(host),
"wait random bytes success.\n");
//get_random_bytes(fac_buf, 0x10000);
} else {
memset(fac_buf, 0x5a, 0x400);
dev_info(mmc_dev(host), "[sd3.0]: value is 0x5a5a\n");
}
i = 0;
/* byte to bit */
total = 0x400 * 0x10;
do {
if (i % 0x10 == 0)
KAL_REC_TIME_START();
err = sdio_writesb(func, 0x0, fac_buf, 0x400);
if (err)
count_rw = count_rw + 1;
i = i + 1;
if ((i / 0x10) && (i % 0x10 == 0)) {
KAL_REC_TIME_END();
usec = KAL_GET_TIME_INTERVAL();
dev_info(mmc_dev(host), "write: %lu Kbps, err:%x\n",
total / (usec / USEC_PER_MSEC), count_rw);
}
} while (i < 0x10);
kfree(fac_buf);
return SUCCESS;
}
static int sdio_stress_test(struct sdio_func *func, struct mmc_host *host)
{
int ret;
while (1) {
ret = multi_write(func, host, 0);
sdio_release_host(func);
if (ret)
return ret;
msleep(20);
sdio_claim_host(func);
ret = multi_read(func, host);
if (ret)
return ret;
}
}
/**
* sdio_proc_write - read/write sdio function register.
*/
static ssize_t sdio_proc_write(struct file *file, const char *buf,
size_t count, loff_t *f_pos)
{
struct mmc_card *card;
struct sdio_func *func;
struct mmc_ios *ios;
char *cmd_buf, *str_hand;
unsigned char *fac_buf = NULL;
unsigned int cmd, addr, fn, value, hqa_result, offset, option;
unsigned char result;
int i = 0, ret;
unsigned long count_r = 0, count_w = 0, total = 0;
KAL_TIME_INTERVAL_DECLARATION();
__kernel_suseconds_t usec;
WARN_ON(!host);
ios = &host->ios;
card = host->card;
cmd_buf = kzalloc((count + 1), GFP_KERNEL);
if (!cmd_buf)
return count;
str_hand = kzalloc(2, GFP_KERNEL);
if (!str_hand) {
kfree(cmd_buf);
return count;
}
func = kzalloc(sizeof(struct sdio_func), GFP_KERNEL);
if (!func) {
kfree(cmd_buf);
kfree(str_hand);
return count;
}
ret = copy_from_user(cmd_buf, buf, count);
if (ret < 0)
goto end;
*(cmd_buf + count) = '\0';
ret = sscanf(cmd_buf, "%x %x %x %x %x %x",
&cmd, &addr, &fn, &value, &offset, &option);
if (ret == 0) {
ret = sscanf(cmd_buf, "%s", str_hand);
if (ret == 0)
dev_info(mmc_dev(host), "please enter cmd.\n");
goto end;
}
if (cmd == Tune)
fn = 0;
/* Judge whether request fn is over the max functions. */
if (fn > card->sdio_funcs) {
dev_info(mmc_dev(host), "the fn is over the max sdio funcs.\n");
goto end;
}
if (fn) {
/**
* The test read/write api don't need more func
* information. So we just use the card & func->num
* to the new struct func.
*/
if (card->sdio_func[fn - 1]) {
func->card = card;
func->num = card->sdio_func[fn - 1]->num;
func->tuples = card->sdio_func[fn - 1]->tuples;
func->tmpbuf = card->sdio_func[fn - 1]->tmpbuf;
hqa_result = card->sdio_func[fn - 1]->max_blksize;
func->max_blksize = hqa_result;
if ((cmd == Hqa_read) || (cmd == Hqa_write)) {
func->cur_blksize = 8;
} else if ((cmd == Stress_write) ||
(cmd == Stress_read) ||
(cmd == Desense_write) ||
(cmd == Desense_read)) {
func->cur_blksize = 0x200;
fac_buf = kmalloc(0x40000, GFP_KERNEL);
if (!fac_buf)
goto end;
memset(fac_buf, 0x3c, 0x40000);
} else {
func->cur_blksize = 1;
}
} else {
dev_info(mmc_dev(host), "func %d is null,.\n", fn);
}
} else {
/**
* function 0 should not need struct func.
* but the api need the parameter, so we create
* the a new func for function 0.
*/
func->card = card;
func->tuples = card->tuples;
func->num = 0;
func->max_blksize = 16;
if ((cmd == Hqa_read) || (cmd == Hqa_write))
func->cur_blksize = 16;
else
func->cur_blksize = 1;
func->tmpbuf = kmalloc(func->cur_blksize, GFP_KERNEL);
if (!func->tmpbuf)
goto end;
memset(func->tmpbuf, 0, func->cur_blksize);
}
sdio_claim_host(func);
switch (cmd) {
case Read:
dev_info(mmc_dev(host), "read addr:%x, fn:%d.\n", addr, fn);
ret = 0;
if (fn == 0)
result = sdio_f0_readb(func, addr, &ret);
else
result = sdio_readb(func, addr, &ret);
if (ret)
dev_info(mmc_dev(host), "Read fail(%d).\n", ret);
else
dev_info(mmc_dev(host), "f%d reg(%x) is 0x%02x.\n",
func->num, addr, result);
break;
case Write:
dev_info(mmc_dev(host), "write addr:%x, value:%x, fn:%d.\n",
addr, (u8)value, fn);
ret = 0;
if (fn == 0)
/* (0xF0 - 0xFF) are permiited for func0 */
sdio_f0_writeb(func, (u8)value, addr, &ret);
else
sdio_writeb(func, (u8)value, addr, &ret);
if (ret)
dev_info(mmc_dev(host), "write fail(%d).\n", ret);
else
dev_info(mmc_dev(host), "write success(%d).\n", ret);
break;
case Tune:
value = 0;
do {
result = sdio_tuning();
if (result)
value = value + 1;
i = i + 1;
} while (i < 64);
if (value)
dev_info(mmc_dev(host), "test fail.\n");
else
dev_info(mmc_dev(host), "test well.\n");
break;
case Hqa_read:
dev_info(mmc_dev(host), "read addr:%x, fn %d\n", addr, fn);
hqa_result = 0;
ret = 0;
hqa_result = sdio_readl(func, addr, &ret);
if (ret)
dev_info(mmc_dev(host), "Read f%d reg(%x) fail(%d).\n",
func->num, addr, ret);
dev_info(mmc_dev(host), "Read result: 0x%02x.\n", hqa_result);
break;
case Hqa_write:
dev_info(mmc_dev(host), "write addr:%x, value:%x, fn %d\n",
addr, value, fn);
hqa_result = 0;
ret = 0;
sdio_writel(func, value, addr, &ret);
if (ret)
dev_info(mmc_dev(host), "write f%d reg(%x) fail(%d).\n",
func->num, addr, ret);
dev_info(mmc_dev(host), "write success(%d).\n", ret);
break;
case Reset:
mmc_hw_reset(host);
break;
case Stress_read:
i = 0;
/* byte to bit */
total = 0x6400000 * 8;
dev_info(mmc_dev(host), "START test SDIO read throughput\n");
KAL_REC_TIME_START();
do {
ret = sdio_readsb(func, fac_buf, addr, 0x40000);
if (ret)
count_r = count_r + 1;
i = i + 1;
} while (i < 0x1900);
KAL_REC_TIME_END();
usec = KAL_GET_TIME_INTERVAL();
dev_info(mmc_dev(host), "%lu Kbps, err:%lx\n",
total / (usec / USEC_PER_MSEC) * 0x10, count_r);
break;
case Stress_write:
i = 0;
/* byte to bit */
total = 0x6400000 * 8;
dev_info(mmc_dev(host), "START test SDIO write throughput\n");
KAL_REC_TIME_START();
do {
ret = sdio_writesb(func, addr, fac_buf, 0x40000);
if (ret)
count_w = count_w + 1;
i = i + 1;
} while (i < 0x1900);
KAL_REC_TIME_END();
usec = KAL_GET_TIME_INTERVAL();
dev_info(mmc_dev(host), "%lu Kbps, err:%lx\n",
total / (usec / USEC_PER_MSEC) * 0x10, count_w);
break;
case Stress_test:
ret = sdio_stress_test(func, host);
if (ret) {
dev_info(mmc_dev(host), "IO Stress Test Fail!!!\n");
sdio_release_host(func);
goto end;
}
break;
case Func_ctrl:
/* addr is func ctrl value in this case*/
if (addr)
ret = sdio_enable_func(func);
else
ret = sdio_disable_func(func);
break;
case Desense_read:
i = 0;
memset(fac_buf, 0x3c, 0x40000);
// init 0xb0 to pattern 0x3c firstly
ret = sdio_writesb(func, 0xb8, fac_buf, 0x40000);
dev_info(mmc_dev(host), "START test SDIO read, pattern: 0x3c\n");
dev_info(mmc_dev(host), "reading data..\n");
do {
ret = sdio_readsb(func, fac_buf, addr, 0x40000);
if (ret)
count_r = count_r + 1;
i = i + 1;
} while (i < 0x1900);
i = 0;
dev_info(mmc_dev(host), "Get data start with:\n");
for (; i < 0x10; i++) {
//if (i && !(i%8))
// dev_info(mmc_dev(host), "\n");
dev_info(mmc_dev(host), "0x%x ", ((int *)fac_buf)[i]);
}
dev_info(mmc_dev(host), "stop reading data..\n");
break;
case Desense_write:
i = 0;
dev_info(mmc_dev(host), "Generating random data...\n");
get_random_bytes(fac_buf, 0x40000);
dev_info(mmc_dev(host), "random data start with:\n");
for (; i < 0x10; i++) {
//if (i && !(i%8))
// dev_info(mmc_dev(host), "\n");
dev_info(mmc_dev(host), "0x%x ", ((int *)fac_buf)[i]);
}
i = 0;
dev_info(mmc_dev(host), "START SDIO desensen write test, pattern: random\n");
dev_info(mmc_dev(host), "writing random data...\n");
do {
ret = sdio_writesb(func, addr, fac_buf, 0x40000);
if (ret)
count_w = count_w + 1;
i = i + 1;
} while (i < 0x1900);
dev_info(mmc_dev(host), "stop writing data..\n");
break;
default:
dev_info(mmc_dev(host), "cmd is not valid.\n");
break;
}
sdio_release_host(func);
end:
kfree(str_hand);
kfree(cmd_buf);
kfree(func);
return count;
}
/**
* open function show some stable information.
*/
static int sdio_proc_open(struct inode *inode, struct file *file)
{
return single_open(file, sdio_proc_show, inode->i_private);
}
/**
* sdio pre is our own function.
* seq or single pre is the kernel function.
*/
static const struct file_operations sdio_proc_fops = {
.owner = THIS_MODULE,
.open = sdio_proc_open,
.release = single_release,
.write = sdio_proc_write,
.read = seq_read,
.llseek = seq_lseek,
};
int sdio_proc_init(struct mmc_host *host_init)
{
struct proc_dir_entry *prEntry;
host = host_init;
prEntry = proc_create("sdio", 0660, NULL, &sdio_proc_fops);
if (prEntry)
dev_info(mmc_dev(host), "/proc/sdio is created.\n");
else
dev_info(mmc_dev(host), "create /proc/sdio failed.\n");
return 0;
}
File diff suppressed because it is too large. Load diff
+770
View File
@@ -0,0 +1,770 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2014-2021 MediaTek Inc.
* Author: Chaotian.Jing <chaotian.jing@mediatek.com>
*/
#ifdef CONFIG_PM_DEVFREQ
#include <linux/pm_qos.h>
#ifdef CONFIG_MACH_MT8168
#include "helio-dvfsrc-opp-mt8168.h"
#else
#ifdef CONFIG_MACH_MT8183
#include "helio-dvfsrc-opp-mt8183.h"
#endif
#endif
#endif
#define MAX_BD_NUM 1024
/* ddr208 mode used by SDIO3.0 plus */
#define MSDC_SDIO_DDR208 (1 << 7)
/*--------------------------------------------------------------------------*/
/* Common Definition */
/*--------------------------------------------------------------------------*/
#define MSDC_BUS_1BITS 0x0
#define MSDC_BUS_4BITS 0x1
#define MSDC_BUS_8BITS 0x2
#define MSDC_BURST_64B 0x6
/*--------------------------------------------------------------------------*/
/* Base Register Offset */
/*--------------------------------------------------------------------------*/
#define MSDC_CFG 0x0
#define MSDC_IOCON 0x04
#define MSDC_PS 0x08
#define MSDC_INT 0x0c
#define MSDC_INTEN 0x10
#define MSDC_FIFOCS 0x14
#define MSDC_TXDATA 0x18
#define MSDC_RXDATA 0x1c
#define SDC_CFG 0x30
#define SDC_CMD 0x34
#define SDC_ARG 0x38
#define SDC_STS 0x3c
#define SDC_RESP0 0x40
#define SDC_RESP1 0x44
#define SDC_RESP2 0x48
#define SDC_RESP3 0x4c
#define SDC_BLK_NUM 0x50
#define SDC_ADV_CFG0 0x64
#define EMMC_IOCON 0x7c
#define SDC_ACMD_RESP 0x80
#define DMA_SA_H4BIT 0x8c
#define MSDC_DMA_SA 0x90
#define MSDC_DMA_CTRL 0x98
#define MSDC_DMA_CFG 0x9c
#define MSDC_DBG_SEL 0xa0
#define MSDC_DBG_OUT 0xa4
#define MSDC_DMA_LEN 0xa8
#define MSDC_PATCH_BIT0 0xb0
#define MSDC_PATCH_BIT1 0xb4
#define MSDC_PATCH_BIT2 0xb8
#define DAT0_TUNE_CRC 0xc0
#define DAT1_TUNE_CRC 0xc4
#define DAT2_TUNE_CRC 0xc8
#define DAT3_TUNE_CRC 0xcc
#define CMD_TUNE_CRC 0xd0
#define SDIO_TUNE_WIND 0xd4
#define MSDC_PAD_TUNE0 0xf0
#define MSDC_HW_DBG 0x110
#define MSDC_VERSION 0x114
#define MSDC_ECO_VER 0x118
#define SDC_FIFO_CFG 0x228
/*--------------------------------------------------------------------------*/
/* for mt8173 mt8135 Only */
/*--------------------------------------------------------------------------*/
#define MSDC_PAD_TUNE 0xec
/*--------------------------------------------------------------------------*/
/* for IC with no top register */
/*--------------------------------------------------------------------------*/
#define MSDC_PAD_TUNE1 0xf4
#define PAD_DS_TUNE 0x188
#define PAD_CMD_TUNE 0x18c
#define EMMC50_PAD_DAT01_TUNE 0x190
#define EMMC50_PAD_DAT23_TUNE 0x194
#define EMMC50_PAD_DAT45_TUNE 0x198
#define EMMC50_PAD_DAT67_TUNE 0x19c
#define EMMC50_CFG0 0x208
#define EMMC50_CFG1 0x20c
#define EMMC50_CFG2 0x21c
#define EMMC50_CFG3 0x220
#define EMMC50_CFG4 0x224
#define MAX_REGISTER_ADDR 0x228
/*--------------------------------------------------------------------------*/
/* Top Register Offset */
/*--------------------------------------------------------------------------*/
#define SD_TOP_CONTROL (0x00)
#define SD_TOP_CMD (0x04)
#define SD_PAD_CTRL0 (0x08)
#define SD50_PAD_DAT0_TUNE (0x10)
#define SD50_PAD_DAT1_TUNE (0x14)
#define SD50_PAD_DAT2_TUNE (0x18)
#define SD50_PAD_DAT3_TUNE (0x1c)
/*--------------------------------------------------------------------------*/
/* Register Mask */
/*--------------------------------------------------------------------------*/
/* MSDC_CFG mask */
#define MSDC_CFG_MODE (0x1 << 0) /* RW */
#define MSDC_CFG_CKPDN (0x1 << 1) /* RW */
#define MSDC_CFG_RST (0x1 << 2) /* RW */
#define MSDC_CFG_PIO (0x1 << 3) /* RW */
#define MSDC_CFG_CKDRVEN (0x1 << 4) /* RW */
#define MSDC_CFG_BV18SDT (0x1 << 5) /* RW */
#define MSDC_CFG_BV18PSS (0x1 << 6) /* R */
#define MSDC_CFG_CKSTB (0x1 << 7) /* R */
#define MSDC_CFG_CKDIV (0xff << 8) /* RW */
#define MSDC_CFG_CKMOD (0x3 << 16) /* RW */
#define MSDC_CFG_HS400_CK_MODE (0x1 << 18) /* RW */
#define MSDC_CFG_HS400_CK_MODE_EXTRA (0x1 << 22) /* RW */
#define MSDC_CFG_CKDIV_EXTRA (0xfff << 8) /* RW */
#define MSDC_CFG_CKMOD_EXTRA (0x3 << 20) /* RW */
/* MSDC_IOCON mask */
#define MSDC_IOCON_SDR104CKS (0x1 << 0) /* RW */
#define MSDC_IOCON_RSPL (0x1 << 1) /* RW */
#define MSDC_IOCON_DSPL (0x1 << 2) /* RW */
#define MSDC_IOCON_DDLSEL (0x1 << 3) /* RW */
#define MSDC_IOCON_DDR50CKD (0x1 << 4) /* RW */
#define MSDC_IOCON_DSPLSEL (0x1 << 5) /* RW */
#define MSDC_IOCON_W_DSPL (0x1 << 8) /* RW */
#define MSDC_IOCON_D0SPL (0x1 << 16) /* RW */
#define MSDC_IOCON_D1SPL (0x1 << 17) /* RW */
#define MSDC_IOCON_D2SPL (0x1 << 18) /* RW */
#define MSDC_IOCON_D3SPL (0x1 << 19) /* RW */
#define MSDC_IOCON_D4SPL (0x1 << 20) /* RW */
#define MSDC_IOCON_D5SPL (0x1 << 21) /* RW */
#define MSDC_IOCON_D6SPL (0x1 << 22) /* RW */
#define MSDC_IOCON_D7SPL (0x1 << 23) /* RW */
#define MSDC_IOCON_RISCSZ (0x3 << 24) /* RW */
/* MSDC_PS mask */
#define MSDC_PS_CDEN (0x1 << 0) /* RW */
#define MSDC_PS_CDSTS (0x1 << 1) /* R */
#define MSDC_PS_CDDEBOUNCE (0xf << 12) /* RW */
#define MSDC_PS_DAT (0xff << 16) /* R */
#define MSDC_PS_CMD (0x1 << 24) /* R */
#define MSDC_PS_WP (0x1 << 31) /* R */
/* MSDC_INT mask */
#define MSDC_INT_MMCIRQ (0x1 << 0) /* W1C */
#define MSDC_INT_CDSC (0x1 << 1) /* W1C */
#define MSDC_INT_ACMDRDY (0x1 << 3) /* W1C */
#define MSDC_INT_ACMDTMO (0x1 << 4) /* W1C */
#define MSDC_INT_ACMDCRCERR (0x1 << 5) /* W1C */
#define MSDC_INT_DMAQ_EMPTY (0x1 << 6) /* W1C */
#define MSDC_INT_SDIOIRQ (0x1 << 7) /* W1C */
#define MSDC_INT_CMDRDY (0x1 << 8) /* W1C */
#define MSDC_INT_CMDTMO (0x1 << 9) /* W1C */
#define MSDC_INT_RSPCRCERR (0x1 << 10) /* W1C */
#define MSDC_INT_CSTA (0x1 << 11) /* R */
#define MSDC_INT_XFER_COMPL (0x1 << 12) /* W1C */
#define MSDC_INT_DXFER_DONE (0x1 << 13) /* W1C */
#define MSDC_INT_DATTMO (0x1 << 14) /* W1C */
#define MSDC_INT_DATCRCERR (0x1 << 15) /* W1C */
#define MSDC_INT_ACMD19_DONE (0x1 << 16) /* W1C */
#define MSDC_INT_DMA_BDCSERR (0x1 << 17) /* W1C */
#define MSDC_INT_DMA_GPDCSERR (0x1 << 18) /* W1C */
#define MSDC_INT_DMA_PROTECT (0x1 << 19) /* W1C */
/* MSDC_INTEN mask */
#define MSDC_INTEN_MMCIRQ (0x1 << 0) /* RW */
#define MSDC_INTEN_CDSC (0x1 << 1) /* RW */
#define MSDC_INTEN_ACMDRDY (0x1 << 3) /* RW */
#define MSDC_INTEN_ACMDTMO (0x1 << 4) /* RW */
#define MSDC_INTEN_ACMDCRCERR (0x1 << 5) /* RW */
#define MSDC_INTEN_DMAQ_EMPTY (0x1 << 6) /* RW */
#define MSDC_INTEN_SDIOIRQ (0x1 << 7) /* RW */
#define MSDC_INTEN_CMDRDY (0x1 << 8) /* RW */
#define MSDC_INTEN_CMDTMO (0x1 << 9) /* RW */
#define MSDC_INTEN_RSPCRCERR (0x1 << 10) /* RW */
#define MSDC_INTEN_CSTA (0x1 << 11) /* RW */
#define MSDC_INTEN_XFER_COMPL (0x1 << 12) /* RW */
#define MSDC_INTEN_DXFER_DONE (0x1 << 13) /* RW */
#define MSDC_INTEN_DATTMO (0x1 << 14) /* RW */
#define MSDC_INTEN_DATCRCERR (0x1 << 15) /* RW */
#define MSDC_INTEN_ACMD19_DONE (0x1 << 16) /* RW */
#define MSDC_INTEN_DMA_BDCSERR (0x1 << 17) /* RW */
#define MSDC_INTEN_DMA_GPDCSERR (0x1 << 18) /* RW */
#define MSDC_INTEN_DMA_PROTECT (0x1 << 19) /* RW */
/* MSDC_FIFOCS mask */
#define MSDC_FIFOCS_RXCNT (0xff << 0) /* R */
#define MSDC_FIFOCS_TXCNT (0xff << 16) /* R */
#define MSDC_FIFOCS_CLR (0x1 << 31) /* RW */
/* SDC_CFG mask */
#define SDC_CFG_SDIOINTWKUP (0x1 << 0) /* RW */
#define SDC_CFG_INSWKUP (0x1 << 1) /* RW */
#define SDC_CFG_BUSWIDTH (0x3 << 16) /* RW */
#define SDC_CFG_SDIO (0x1 << 19) /* RW */
#define SDC_CFG_SDIOIDE (0x1 << 20) /* RW */
#define SDC_CFG_INTATGAP (0x1 << 21) /* RW */
#define SDC_CFG_DTOC (0xff << 24) /* RW */
/* SDC_STS mask */
#define SDC_STS_SDCBUSY (0x1 << 0) /* RW */
#define SDC_STS_CMDBUSY (0x1 << 1) /* RW */
#define SDC_STS_SWR_COMPL (0x1 << 31) /* RW */
/* SDC_ADV_CFG0 mask */
#define SDC_CMD_RESP_CRC (0x7f << 0) /* RW */
#define SDC_RX_ENHANCE_EN (0x1 << 20) /* RW */
/* DMA_SA_H4BIT mask */
#define DMA_ADDR_HIGH_4BIT (0xf << 0) /* RW */
/* MSDC_DMA_CTRL mask */
#define MSDC_DMA_CTRL_START (0x1 << 0) /* W */
#define MSDC_DMA_CTRL_STOP (0x1 << 1) /* W */
#define MSDC_DMA_CTRL_RESUME (0x1 << 2) /* W */
#define MSDC_DMA_CTRL_MODE (0x1 << 8) /* RW */
#define MSDC_DMA_CTRL_LASTBUF (0x1 << 10) /* RW */
#define MSDC_DMA_CTRL_BRUSTSZ (0x7 << 12) /* RW */
/* MSDC_DMA_CFG mask */
#define MSDC_DMA_CFG_STS (0x1 << 0) /* R */
#define MSDC_DMA_CFG_DECSEN (0x1 << 1) /* RW */
#define MSDC_DMA_CFG_AHBHPROT2 (0x2 << 8) /* RW */
#define MSDC_DMA_CFG_ACTIVEEN (0x2 << 12) /* RW */
#define MSDC_DMA_CFG_CS12B16B (0x1 << 16) /* RW */
/* MSDC_PATCH_BIT0 mask */
#define MSDC_PB0_RESV1 (0x1 << 0)
#define MSDC_PB0_EN_8BITSUP (0x1 << 1)
#define MSDC_PB0_DIS_RECMDWR (0x1 << 2)
#define MSDC_PB0_RD_DAT_SEL (0x1 << 3)
#define MSDC_PB0_RESV2 (0x3 << 4)
#define MSDC_PB0_DESCUP (0x1 << 6)
#define MSDC_PB0_INT_DAT_LATCH_CK_SEL (0x7 << 7)
#define MSDC_PB0_CKGEN_MSDC_DLY_SEL (0x1F<<10)
#define MSDC_PB0_FIFORD_DIS (0x1 << 15)
#define MSDC_PB0_BLKNUM_SEL (0x1 << 16)
#define MSDC_PB0_SDIO_INTCSEL (0x1 << 17)
#define MSDC_PB0_SDC_BSYDLY (0xf << 18)
#define MSDC_PB0_SDC_WDOD (0xf << 22)
#define MSDC_PB0_CMDIDRTSEL (0x1 << 26)
#define MSDC_PB0_CMDFAILSEL (0x1 << 27)
#define MSDC_PB0_SDIO_INTDLYSEL (0x1 << 28)
#define MSDC_PB0_SPCPUSH (0x1 << 29)
#define MSDC_PB0_DETWR_CRCTMO (0x1 << 30)
#define MSDC_PB0_EN_DRVRSP (0x1UL << 31)
/* MSDC_PATCH_BIT1 mask */
#define MSDC_PB1_WRDAT_CRCS_TA_CNTR (0x7 << 0)
#define MSDC_PB1_CMD_RSP_TA_CNTR (0x7 << 3)
#define MSDC_PB1_GET_BUSY_MA (0x1 << 6)
#define MSDC_PB1_GET_CRC_MA (0x1 << 7)
#define MSDC_PB1_STOP_DLY_SEL (0xf << 8)
#define MSDC_PB1_BIAS_EN18IO_28NM (0x1 << 12)
#define MSDC_PB1_BIAS_EXT_28NM (0x1 << 13)
#define MSDC_PB1_RESV2 (0x1 << 14)
#define MSDC_PB1_DDR_CMD_FIX_SEL (0x1 << 14)
#define MSDC_PB1_RESET_GDMA (0x1 << 15)
#define MSDC_PB1_SINGLE_BURST (0x1 << 16)
#define MSDC_PB1_FROCE_STOP (0x1 << 17)
#define MSDC_PB1_POP_MARK_WATER (0x1 << 19)
#define MSDC_PB1_STATE_CLEAR (0x1 << 20)
#define MSDC_PB1_DCM_EN (0x1 << 21)
#define MSDC_PB1_AXI_WRAP_CKEN (0x1 << 22)
#define MSDC_PB1_CKCLK_GDMA_EN (0x1 << 23)
#define MSDC_PB1_CKSPCEN (0x1 << 24)
#define MSDC_PB1_CKPSCEN (0x1 << 25)
#define MSDC_PB1_CKVOLDETEN (0x1 << 26)
#define MSDC_PB1_CKACMDEN (0x1 << 27)
#define MSDC_PB1_CKSDEN (0x1 << 28)
#define MSDC_PB1_CKWCTLEN (0x1 << 29)
#define MSDC_PB1_CKRCTLEN (0x1 << 30)
#define MSDC_PB1_CKSHBFFEN (0x1UL << 31)
/* MSDC_PATCH_BIT2 mask */
#define MSDC_PB2_ENHANCEGPD (0x1 << 0)
#define MSDC_PB2_SUPPORT64G (0x1 << 1)
#define MSDC_PB2_RESPWAITCNT (0x3 << 2)
#define MSDC_PB2_CFGRDATCNT (0x1f << 4)
#define MSDC_PB2_CFGRDAT (0x1 << 9)
#define MSDC_PB2_INTCRESPSEL (0x1 << 11)
#define MSDC_PB2_CFGRESPCNT (0x7 << 12)
#define MSDC_PB2_CFGRESP (0x1 << 15)
#define MSDC_PB2_DDR50_SEL (0x1 << 19) /* RW */
#define MSDC_PB2_RESPSTENSEL (0x7 << 16)
#define MSDC_PB2_POPENCNT (0xf << 20)
#define MSDC_PB2_CFG_CRCSTS_SEL (0x1 << 24)
#define MSDC_PB2_CFGCRCSTSEDGE (0x1 << 25)
#define MSDC_PB2_CFGCRCSTSCNT (0x3 << 26)
#define MSDC_PB2_CFGCRCSTS (0x1 << 28)
#define MSDC_PB2_CRCSTSENSEL (0x7UL << 29)
#define MSDC_MASK_ACMD53_CRC_ERR_INTR (0x1<<4)
#define MSDC_ACMD53_FAIL_ONE_SHOT (0X1<<5)
/* MSDC_PAD_TUNE mask */
#define MSDC_PAD_TUNE0_DATWRDLY (0x1F << 0) /* RW */
#define MSDC_PAD_TUNE0_DELAYEN (0x1 << 7) /* RW */
#define MSDC_PAD_TUNE0_DATRRDLY (0x1F << 8) /* RW */
#define MSDC_PAD_TUNE0_DATRRDLYSEL (0x1 << 13) /* RW */
#define MSDC_PAD_TUNE0_RXDLYSEL (0x1 << 15) /* RW */
#define MSDC_PAD_TUNE0_CMDRDLY (0x1F << 16) /* RW */
#define MSDC_PAD_TUNE0_CMDRRDLYSEL (0x1 << 21) /* RW */
#define MSDC_PAD_TUNE0_CMDRRDLY (0x1FUL << 22) /* RW */
#define MSDC_PAD_TUNE0_CLKTXDLY (0x1FUL << 27) /* RW */
/* MSDC_PAD_TUNE1 mask */
#define MSDC_PAD_TUNE1_DATRRDLY2 (0x1F << 8) /* RW */
#define MSDC_PAD_TUNE1_DATRRDLY2SEL (0x1 << 13) /* RW */
#define MSDC_PAD_TUNE1_CMDRDLY2 (0x1F << 16) /* RW */
#define MSDC_PAD_TUNE1_CMDRRDLY2SEL (0x1 << 21) /* RW */
/* MSDC_DAT_RDDLY0/1/2/3 mask */
#define MSDC_DAT_RDDLY0_D3 (0x1F << 0) /* RW */
#define MSDC_DAT_RDDLY0_D2 (0x1F << 8) /* RW */
#define MSDC_DAT_RDDLY0_D1 (0x1F << 16) /* RW */
#define MSDC_DAT_RDDLY0_D0 (0x1FUL << 24) /* RW */
#define MSDC_DAT_RDDLY1_D7 (0x1F << 0) /* RW */
#define MSDC_DAT_RDDLY1_D6 (0x1F << 8) /* RW */
#define MSDC_DAT_RDDLY1_D5 (0x1F << 16) /* RW */
#define MSDC_DAT_RDDLY1_D4 (0x1FUL << 24) /* RW */
#define MSDC_DAT_RDDLY2_D3 (0x1F << 0) /* RW */
#define MSDC_DAT_RDDLY2_D2 (0x1F << 8) /* RW */
#define MSDC_DAT_RDDLY2_D1 (0x1F << 16) /* RW */
#define MSDC_DAT_RDDLY2_D0 (0x1FUL << 24) /* RW */
#define MSDC_DAT_RDDLY3_D7 (0x1F << 0) /* RW */
#define MSDC_DAT_RDDLY3_D6 (0x1F << 8) /* RW */
#define MSDC_DAT_RDDLY3_D5 (0x1F << 16) /* RW */
#define MSDC_DAT_RDDLY3_D4 (0x1FUL << 24) /* RW */
/* MSDC_HW_DBG_SEL mask */
#define MSDC_HW_DBG0_SEL (0xFF << 0)
#define MSDC_HW_DBG1_SEL (0x3F << 8)
#define MSDC_HW_DBG2_SEL (0xFF << 16)
#define MSDC_HW_DBG3_SEL (0x3F << 24)
#define MSDC_HW_DBG_WRAPTYPE_SEL (0x1 << 30)
#define MSDC_PAD_TUNE_DATWRDLY (0x1f << 0) /* RW */
#define MSDC_PAD_TUNE_DATRRDLY (0x1f << 8) /* RW */
#define MSDC_PAD_TUNE_CMDRDLY (0x1f << 16) /* RW */
#define MSDC_PAD_TUNE_CMDRRDLY (0x1f << 22) /* RW */
#define MSDC_PAD_TUNE_CLKTDLY (0x1f << 27) /* RW */
#define MSDC_PAD_TUNE_RXDLYSEL (0x1 << 15) /* RW */
#define MSDC_PAD_TUNE_RD_SEL (0x1 << 13) /* RW */
#define MSDC_PAD_TUNE_CMD_SEL (0x1 << 21) /* RW */
#define PAD_DS_TUNE_DLY1 (0x1f << 2) /* RW */
#define PAD_DS_TUNE_DLY2 (0x1f << 7) /* RW */
#define PAD_DS_TUNE_DLY3 (0x1f << 12) /* RW */
#define PAD_CMD_TUNE_RX_DLY3 (0x1f << 1) /* RW */
#define EMMC50_CFG_PADCMD_LATCHCK (0x1 << 0) /* RW */
#define EMMC50_CFG_CRCSTS_EDGE (0x1 << 3) /* RW */
#define EMMC50_CFG_CFCSTS_SEL (0x1 << 4) /* RW */
#define EMMC50_CFG3_OUTS_WR (0x1f << 0) /* RW */
#define SDC_FIFO_CFG_WRVALIDSEL (0x1 << 24) /* RW */
#define SDC_FIFO_CFG_RDVALIDSEL (0x1 << 25) /* RW */
/* SD_TOP_CONTROL mask */
#define PAD_RXDLY_SEL (0x1 << 0) /* RW */
#define DELAY_EN (0x1 << 1) /* RW */
#define PAD_DAT_RD_RXDLY2 (0x1F << 2) /* RW */
#define PAD_DAT_RD_RXDLY (0x1F << 7) /* RW */
#define PAD_DAT_RD_RXDLY2_SEL (0x1 << 12) /* RW */
#define PAD_DAT_RD_RXDLY_SEL (0x1 << 13) /* RW */
#define DATA_K_VALUE_SEL (0x1 << 14) /* RW */
#define SDC_RX_ENH_EN (0x1 << 15) /* TW */
/* SD_TOP_CMD mask */
#define PAD_CMD_RXDLY2 (0x1F << 0) /* RW */
#define PAD_CMD_RXDLY (0x1F << 5) /* RW */
#define PAD_CMD_RD_RXDLY2_SEL (0x1 << 10) /* RW */
#define PAD_CMD_RD_RXDLY_SEL (0x1 << 11) /* RW */
#define PAD_CMD_TX_DLY (0x1F << 12) /* RW */
/* TOP_SD50_PAD_CTL0 mask */
#define MSDC_PAD_CLK_TXDLY (0x1F << 10) /* RW */
/* TOP_SD50_PAD_DS_TUNE mask */
#define PAD_DS_DLY3 (0x1F << 0) /* RW */
#define PAD_DS_DLY2 (0x1F << 5) /* RW */
#define PAD_DS_DLY1 (0x1F << 10) /* RW */
#define PAD_DS_DLY2_SEL (0x1 << 15) /* RW */
#define PAD_DS_DLY_SEL (0x1 << 16) /* RW */
#define REQ_CMD_EIO (0x1 << 0)
#define REQ_CMD_TMO (0x1 << 1)
#define REQ_DAT_ERR (0x1 << 2)
#define REQ_STOP_EIO (0x1 << 3)
#define REQ_STOP_TMO (0x1 << 4)
#define REQ_CMD_BUSY (0x1 << 5)
#define MSDC_PREPARE_FLAG (0x1 << 0)
#define MSDC_ASYNC_FLAG (0x1 << 1)
#define MSDC_MMAP_FLAG (0x1 << 2)
#define MTK_MMC_AUTOSUSPEND_DELAY 50
#define CMD_TIMEOUT (HZ/10 * 5) /* 100ms x5 */
#define DAT_TIMEOUT (HZ * 5) /* 1000ms x5 */
#define PAD_DELAY_MAX 32 /* PAD delay cells */
/* SDIO3.0 PLUS mask */
#define SDIO_CCCR_MTK_DDR208 0xF2
#define SDIO_MTK_DDR208 0x3
#define SDIO_MTK_DDR208_SUPPORT 0x2
/*--------------------------------------------------------------------------*/
/* Descriptor Structure */
/*--------------------------------------------------------------------------*/
struct mt_gpdma_desc {
u32 gpd_info;
#define GPDMA_DESC_HWO (0x1 << 0)
#define GPDMA_DESC_BDP (0x1 << 1)
#define GPDMA_DESC_CHECKSUM (0xff << 8) /* bit8 ~ bit15 */
#define GPDMA_DESC_INT (0x1 << 16)
#define GPDMA_DESC_NEXT_H4 (0xf << 24)
#define GPDMA_DESC_PTR_H4 (0xf << 28)
u32 next;
u32 ptr;
u32 gpd_data_len;
#define GPDMA_DESC_BUFLEN (0xffff) /* bit0 ~ bit15 */
#define GPDMA_DESC_EXTLEN (0xff << 16) /* bit16 ~ bit23 */
u32 arg;
u32 blknum;
u32 cmd;
};
struct mt_bdma_desc {
u32 bd_info;
#define BDMA_DESC_EOL (0x1 << 0)
#define BDMA_DESC_CHECKSUM (0xff << 8) /* bit8 ~ bit15 */
#define BDMA_DESC_BLKPAD (0x1 << 17)
#define BDMA_DESC_DWPAD (0x1 << 18)
#define BDMA_DESC_NEXT_H4 (0xf << 24)
#define BDMA_DESC_PTR_H4 (0xf << 28)
u32 next;
u32 ptr;
u32 bd_data_len;
#define BDMA_DESC_BUFLEN (0xffff) /* bit0 ~ bit15 */
#define BDMA_DESC_BUFLEN_EXT (0xffffff) /* bit0 ~ bit23 */
};
struct msdc_dma {
struct scatterlist *sg; /* I/O scatter list */
struct mt_gpdma_desc *gpd; /* pointer to gpd array */
struct mt_bdma_desc *bd; /* pointer to bd array */
dma_addr_t gpd_addr; /* the physical address of gpd array */
dma_addr_t bd_addr; /* the physical address of bd array */
};
struct msdc_save_para {
u32 msdc_cfg;
u32 msdc_inten;
u32 iocon;
u32 sdc_cfg;
u32 pad_tune;
u32 patch_bit0;
u32 patch_bit1;
u32 patch_bit2;
u32 pad_ds_tune;
u32 pad_cmd_tune;
u32 emmc50_cfg0;
u32 emmc50_cfg3;
u32 sdc_fifo_cfg;
u32 sd_top_control;
u32 sd_top_cmd;
};
struct mtk_mmc_compatible {
u8 clk_div_bits;
bool hs400_tune; /* only used for MT8173 */
u32 pad_tune_reg;
bool async_fifo;
bool data_tune;
bool busy_check;
bool stop_clk_fix;
bool enhance_rx;
bool support_64g;
bool tune_resp_data_together;
bool v3_plus;
};
struct msdc_tune_para {
u32 iocon;
u32 pad_tune;
u32 pad_cmd_tune;
u32 sd_top_control;
u32 sd_top_cmd;
};
struct msdc_delay_phase {
u8 maxlen;
u8 start;
u8 final_phase;
};
struct msdc_host {
struct device *dev;
const struct mtk_mmc_compatible *dev_comp;
struct mmc_host *mmc; /* mmc structure */
int cmd_rsp;
spinlock_t lock;
struct mmc_request *mrq;
struct mmc_command *cmd;
struct mmc_data *data;
int error;
void __iomem *base; /* host base address */
void __iomem *top_base; /* host top register base address */
struct msdc_dma dma; /* dma channel */
u64 dma_mask;
u32 timeout_ns; /* data timeout ns */
u32 timeout_clks; /* data timeout clks */
struct pinctrl *pinctrl;
struct pinctrl_state *pins_default;
struct pinctrl_state *pins_uhs;
struct pinctrl_state *pins_eint;
struct pinctrl_state *pins_dat1;
struct delayed_work req_timeout;
int irq; /* host interrupt */
int eint_irq; /* device interrupt */
int sdio_irq_cnt; /* irq enable cnt */
struct clk *ext_clk; /* msdc0 AP clock */
struct clk *bus_clk; /* msdc bus clock */
struct clk *src_clk; /* msdc source clock */
struct clk *h_clk; /* msdc h_clk */
struct clk *src_clk_cg; /* msdc source clock control gate */
struct clk *h_clk_cg; /* msdc h_clk control gate */
u32 mclk; /* mmc subsystem clock frequency */
u32 src_clk_freq; /* source clock frequency */
u32 sclk; /* SD/MS bus clock frequency */
unsigned char timing;
bool vqmmc_enabled;
u32 latch_ck;
u32 hs400_ds_delay;
u32 hs200_cmd_int_delay; /* cmd internal delay for HS200/SDR104 */
u32 hs400_cmd_int_delay; /* cmd internal delay for HS400 */
bool hs400_cmd_resp_sel_rising;
/* cmd response sample selection for HS400 */
bool hs400_mode; /* current eMMC will run at hs400 mode */
bool is_ddr208;
bool no_sdio_incr1;
struct msdc_save_para save_para; /* used when gate HCLK */
struct msdc_tune_para def_tune_para; /* default tune setting */
struct msdc_tune_para saved_tune_para; /* tune result of CMD21/CMD19 */
#ifdef CONFIG_PM_DEVFREQ
struct pm_qos_request pm_qos;
#endif
};
static const struct mtk_mmc_compatible mt8135_compat = {
.clk_div_bits = 8,
.hs400_tune = false,
.pad_tune_reg = MSDC_PAD_TUNE,
.async_fifo = false,
.data_tune = false,
.busy_check = false,
.stop_clk_fix = false,
.enhance_rx = false,
.support_64g = false,
.tune_resp_data_together = false,
.v3_plus = true,
};
static const struct mtk_mmc_compatible mt8173_compat = {
.clk_div_bits = 8,
.hs400_tune = true,
.pad_tune_reg = MSDC_PAD_TUNE,
.async_fifo = false,
.data_tune = false,
.busy_check = false,
.stop_clk_fix = false,
.enhance_rx = false,
.support_64g = false,
.tune_resp_data_together = false,
.v3_plus = true,
};
static const struct mtk_mmc_compatible mt8167_compat = {
.clk_div_bits = 12,
.hs400_tune = false,
.pad_tune_reg = MSDC_PAD_TUNE0,
.async_fifo = true,
.data_tune = true,
.busy_check = true,
.stop_clk_fix = true,
.enhance_rx = false,
.support_64g = false,
.tune_resp_data_together = true,
.v3_plus = false,
};
static const struct mtk_mmc_compatible mt8168_compat = {
.clk_div_bits = 12,
.hs400_tune = false,
.pad_tune_reg = MSDC_PAD_TUNE0,
.async_fifo = true,
.data_tune = true,
.busy_check = true,
.stop_clk_fix = true,
.enhance_rx = true,
.support_64g = true,
.tune_resp_data_together = true,
.v3_plus = true,
};
static const struct mtk_mmc_compatible mt2701_compat = {
.clk_div_bits = 12,
.hs400_tune = false,
.pad_tune_reg = MSDC_PAD_TUNE0,
.async_fifo = true,
.data_tune = true,
.busy_check = false,
.stop_clk_fix = false,
.enhance_rx = false,
.support_64g = false,
.tune_resp_data_together = false,
.v3_plus = true,
};
static const struct mtk_mmc_compatible mt2712_compat = {
.clk_div_bits = 12,
.hs400_tune = false,
.pad_tune_reg = MSDC_PAD_TUNE0,
.async_fifo = true,
.data_tune = true,
.busy_check = true,
.stop_clk_fix = true,
.enhance_rx = true,
.support_64g = true,
.tune_resp_data_together = true,
.v3_plus = false,
};
static const struct mtk_mmc_compatible mt8695_compat = {
.clk_div_bits = 12,
.hs400_tune = false,
.pad_tune_reg = MSDC_PAD_TUNE0,
.async_fifo = true,
.data_tune = true,
.busy_check = true,
.stop_clk_fix = true,
.enhance_rx = true,
.support_64g = false,
.tune_resp_data_together = true,
.v3_plus = true,
};
static const struct mtk_mmc_compatible mt8512_compat = {
.clk_div_bits = 12,
.hs400_tune = false,
.pad_tune_reg = MSDC_PAD_TUNE0,
.async_fifo = true,
.data_tune = true,
.busy_check = true,
.stop_clk_fix = true,
.enhance_rx = true,
.support_64g = false,
.tune_resp_data_together = true,
.v3_plus = true,
};
static const struct mtk_mmc_compatible mt8518_compat = {
.clk_div_bits = 12,
.hs400_tune = false,
.pad_tune_reg = MSDC_PAD_TUNE0,
.async_fifo = true,
.data_tune = true,
.busy_check = true,
.stop_clk_fix = true,
.enhance_rx = true,
.support_64g = false,
.tune_resp_data_together = true,
.v3_plus = true,
};
static const struct mtk_mmc_compatible mt7622_compat = {
.clk_div_bits = 12,
.hs400_tune = false,
.pad_tune_reg = MSDC_PAD_TUNE0,
.async_fifo = true,
.data_tune = true,
.busy_check = true,
.stop_clk_fix = true,
.enhance_rx = true,
.support_64g = false,
.tune_resp_data_together = false,
.v3_plus = true,
};
static const struct mtk_mmc_compatible mt8183_compat = {
.clk_div_bits = 12,
.hs400_tune = false,
.pad_tune_reg = MSDC_PAD_TUNE0,
.async_fifo = true,
.data_tune = true,
.busy_check = true,
.stop_clk_fix = true,
.enhance_rx = true,
.support_64g = true,
.tune_resp_data_together = true,
.v3_plus = true,
};
static const struct mtk_mmc_compatible mt8195_compat = {
.clk_div_bits = 12,
.hs400_tune = false,
.pad_tune_reg = MSDC_PAD_TUNE0,
.async_fifo = true,
.data_tune = true,
.busy_check = true,
.stop_clk_fix = true,
.enhance_rx = true,
.support_64g = true,
.tune_resp_data_together = true,
.v3_plus = true,
};
static const struct mtk_mmc_compatible mt8696_compat = {
.clk_div_bits = 12,
.hs400_tune = false,
.pad_tune_reg = MSDC_PAD_TUNE0,
.async_fifo = true,
.data_tune = true,
.busy_check = true,
.stop_clk_fix = true,
.enhance_rx = true,
.support_64g = true,
.tune_resp_data_together = true,
.v3_plus = true,
};
static const struct mtk_mmc_compatible mt8139_compat = {
.clk_div_bits = 12,
.hs400_tune = false,
.pad_tune_reg = MSDC_PAD_TUNE0,
.async_fifo = true,
.data_tune = true,
.busy_check = true,
.stop_clk_fix = true,
.enhance_rx = true,
.support_64g = true,
.tune_resp_data_together = true,
.v3_plus = true,
};
+849
View File
@@ -0,0 +1,849 @@
/*
* 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/of_irq.h>
#include <linux/mmc/host.h>
#include <linux/mmc/slot-gpio.h>
#include <asm/sizes.h>
#include <asm/unaligned.h>
#include "mvsdio.h"
#define DRIVER_NAME "mvsdio"
static int maxfreq;
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 clk *clk;
};
#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 {
hw_state = mvsd_read(MVSD_HW_STATE);
if (time_after(jiffies, t)) {
dev_warn(host->dev, "FIFO_EMPTY bit missing\n");
break;
}
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 ||
((!(data->flags & MMC_DATA_READ) && data->sg->offset & 0x3f))) {
/*
* We cannot do DMA on a buffer which offset or size
* is not aligned on a 4-byte boundary.
*
* It also appears the host to card DMA can corrupt
* data when the buffer is not aligned on a 64 byte
* boundary.
*/
host->pio_size = data->blocks * data->blksz;
host->pio_ptr = sg_virt(data->sg);
if (!nodma)
dev_dbg(host->dev, "fallback to PIO for data at 0x%p size %d\n",
host->pio_ptr, host->pio_size);
return 1;
} else {
dma_addr_t phys_addr;
host->sg_frags = dma_map_sg(mmc_dev(host->mmc),
data->sg, data->sg_len,
mmc_get_dma_dir(data));
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;
unsigned int timeout;
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);
timeout = cmd->busy_timeout ? cmd->busy_timeout : 5000;
mod_timer(&host->timer, jiffies + msecs_to_jiffies(timeout));
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,
mmc_get_dma_dir(data));
}
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));
/*
* It looks like, SDIO IP can issue one late, spurious irq
* although all irqs should be disabled. To work around this,
* bail out early, if we didn't expect any irqs to occur.
*/
if (!mvsd_read(MVSD_NOR_INTR_EN) && !mvsd_read(MVSD_ERR_INTR_EN)) {
dev_dbg(host->dev, "spurious irq detected intr 0x%04x intr_en 0x%04x erri 0x%04x erri_en 0x%04x\n",
mvsd_read(MVSD_NOR_INTR_STATUS),
mvsd_read(MVSD_NOR_INTR_EN),
mvsd_read(MVSD_ERR_INTR_STATUS),
mvsd_read(MVSD_ERR_INTR_EN));
return IRQ_HANDLED;
}
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) {
dev_err(host->dev, "unhandled error status %#04x\n",
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;
dev_err(host->dev, "unhandled interrupt status=0x%04x en=0x%04x pio=%d\n",
intr_status, host->intr_en, host->pio_size);
return IRQ_NONE;
}
static void mvsd_timeout_timer(struct timer_list *t)
{
struct mvsd_host *host = from_timer(host, t, timer);
void __iomem *iobase = host->base;
struct mmc_request *mrq;
unsigned long flags;
spin_lock_irqsave(&host->lock, flags);
mrq = host->mrq;
if (mrq) {
dev_err(host->dev, "Timeout waiting for hardware interrupt.\n");
dev_err(host->dev, "hw_state=0x%04x, intr_status=0x%04x intr_en=0x%04x\n",
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 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 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 = mmc_gpio_get_ro,
.set_ios = mvsd_set_ios,
.enable_sdio_irq = mvsd_enable_sdio_irq,
};
static void
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 mvsd_probe(struct platform_device *pdev)
{
struct device_node *np = pdev->dev.of_node;
struct mmc_host *mmc = NULL;
struct mvsd_host *host = NULL;
const struct mbus_dram_target_info *dram;
struct resource *r;
int ret, irq;
if (!np) {
dev_err(&pdev->dev, "no DT node\n");
return -ENODEV;
}
r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
irq = platform_get_irq(pdev, 0);
if (!r || irq < 0)
return -ENXIO;
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;
/*
* Some non-DT platforms do not pass a clock, and the clock
* frequency is passed through platform_data. On DT platforms,
* a clock must always be passed, even if there is no gatable
* clock associated to the SDIO interface (it can simply be a
* fixed rate clock).
*/
host->clk = devm_clk_get(&pdev->dev, NULL);
if (IS_ERR(host->clk)) {
dev_err(&pdev->dev, "no clock associated\n");
ret = -EINVAL;
goto out;
}
clk_prepare_enable(host->clk);
mmc->ops = &mvsd_ops;
mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
mmc->f_min = DIV_ROUND_UP(host->base_clock, MVSD_BASE_DIV_MAX);
mmc->f_max = MVSD_CLOCKRATE_MAX;
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;
host->base_clock = clk_get_rate(host->clk) / 2;
ret = mmc_of_parse(mmc);
if (ret < 0)
goto out;
if (maxfreq)
mmc->f_max = maxfreq;
mmc->caps |= MMC_CAP_ERASE;
spin_lock_init(&host->lock);
host->base = devm_ioremap_resource(&pdev->dev, r);
if (IS_ERR(host->base)) {
ret = PTR_ERR(host->base);
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 = devm_request_irq(&pdev->dev, irq, mvsd_irq, 0, DRIVER_NAME, host);
if (ret) {
dev_err(&pdev->dev, "cannot assign irq %d\n", irq);
goto out;
}
timer_setup(&host->timer, mvsd_timeout_timer, 0);
platform_set_drvdata(pdev, mmc);
ret = mmc_add_host(mmc);
if (ret)
goto out;
if (!(mmc->caps & MMC_CAP_NEEDS_POLL))
dev_dbg(&pdev->dev, "using GPIO for card detection\n");
else
dev_dbg(&pdev->dev, "lacking card detect (fall back to polling)\n");
return 0;
out:
if (mmc) {
if (!IS_ERR(host->clk))
clk_disable_unprepare(host->clk);
mmc_free_host(mmc);
}
return ret;
}
static int mvsd_remove(struct platform_device *pdev)
{
struct mmc_host *mmc = platform_get_drvdata(pdev);
struct mvsd_host *host = mmc_priv(mmc);
mmc_remove_host(mmc);
del_timer_sync(&host->timer);
mvsd_power_down(host);
if (!IS_ERR(host->clk))
clk_disable_unprepare(host->clk);
mmc_free_host(mmc);
return 0;
}
static const struct of_device_id mvsdio_dt_ids[] = {
{ .compatible = "marvell,orion-sdio" },
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, mvsdio_dt_ids);
static struct platform_driver mvsd_driver = {
.probe = mvsd_probe,
.remove = mvsd_remove,
.driver = {
.name = DRIVER_NAME,
.of_match_table = mvsdio_dt_ids,
},
};
module_platform_driver(mvsd_driver);
/* 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");
+190
View File
@@ -0,0 +1,190 @@
/*
* Copyright (C) 2008 Marvell Semiconductors, 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.
*/
#ifndef __MVSDIO_H
#define __MVSDIO_H
/*
* Clock rates
*/
#define MVSD_CLOCKRATE_MAX 50000000
#define MVSD_BASE_DIV_MAX 0x7ff
/*
* Register offsets
*/
#define MVSD_SYS_ADDR_LOW 0x000
#define MVSD_SYS_ADDR_HI 0x004
#define MVSD_BLK_SIZE 0x008
#define MVSD_BLK_COUNT 0x00c
#define MVSD_ARG_LOW 0x010
#define MVSD_ARG_HI 0x014
#define MVSD_XFER_MODE 0x018
#define MVSD_CMD 0x01c
#define MVSD_RSP(i) (0x020 + ((i)<<2))
#define MVSD_RSP0 0x020
#define MVSD_RSP1 0x024
#define MVSD_RSP2 0x028
#define MVSD_RSP3 0x02c
#define MVSD_RSP4 0x030
#define MVSD_RSP5 0x034
#define MVSD_RSP6 0x038
#define MVSD_RSP7 0x03c
#define MVSD_FIFO 0x040
#define MVSD_RSP_CRC7 0x044
#define MVSD_HW_STATE 0x048
#define MVSD_HOST_CTRL 0x050
#define MVSD_BLK_GAP_CTRL 0x054
#define MVSD_CLK_CTRL 0x058
#define MVSD_SW_RESET 0x05c
#define MVSD_NOR_INTR_STATUS 0x060
#define MVSD_ERR_INTR_STATUS 0x064
#define MVSD_NOR_STATUS_EN 0x068
#define MVSD_ERR_STATUS_EN 0x06c
#define MVSD_NOR_INTR_EN 0x070
#define MVSD_ERR_INTR_EN 0x074
#define MVSD_AUTOCMD12_ERR_STATUS 0x078
#define MVSD_CURR_BYTE_LEFT 0x07c
#define MVSD_CURR_BLK_LEFT 0x080
#define MVSD_AUTOCMD12_ARG_LOW 0x084
#define MVSD_AUTOCMD12_ARG_HI 0x088
#define MVSD_AUTOCMD12_CMD 0x08c
#define MVSD_AUTO_RSP(i) (0x090 + ((i)<<2))
#define MVSD_AUTO_RSP0 0x090
#define MVSD_AUTO_RSP1 0x094
#define MVSD_AUTO_RSP2 0x098
#define MVSD_CLK_DIV 0x128
#define MVSD_WINDOW_CTRL(i) (0x108 + ((i) << 3))
#define MVSD_WINDOW_BASE(i) (0x10c + ((i) << 3))
/*
* MVSD_CMD
*/
#define MVSD_CMD_RSP_NONE (0 << 0)
#define MVSD_CMD_RSP_136 (1 << 0)
#define MVSD_CMD_RSP_48 (2 << 0)
#define MVSD_CMD_RSP_48BUSY (3 << 0)
#define MVSD_CMD_CHECK_DATACRC16 (1 << 2)
#define MVSD_CMD_CHECK_CMDCRC (1 << 3)
#define MVSD_CMD_INDX_CHECK (1 << 4)
#define MVSD_CMD_DATA_PRESENT (1 << 5)
#define MVSD_UNEXPECTED_RESP (1 << 7)
#define MVSD_CMD_INDEX(x) ((x) << 8)
/*
* MVSD_AUTOCMD12_CMD
*/
#define MVSD_AUTOCMD12_BUSY (1 << 0)
#define MVSD_AUTOCMD12_INDX_CHECK (1 << 1)
#define MVSD_AUTOCMD12_INDEX(x) ((x) << 8)
/*
* MVSD_XFER_MODE
*/
#define MVSD_XFER_MODE_WR_DATA_START (1 << 0)
#define MVSD_XFER_MODE_HW_WR_DATA_EN (1 << 1)
#define MVSD_XFER_MODE_AUTO_CMD12 (1 << 2)
#define MVSD_XFER_MODE_INT_CHK_EN (1 << 3)
#define MVSD_XFER_MODE_TO_HOST (1 << 4)
#define MVSD_XFER_MODE_STOP_CLK (1 << 5)
#define MVSD_XFER_MODE_PIO (1 << 6)
/*
* MVSD_HOST_CTRL
*/
#define MVSD_HOST_CTRL_PUSH_PULL_EN (1 << 0)
#define MVSD_HOST_CTRL_CARD_TYPE_MEM_ONLY (0 << 1)
#define MVSD_HOST_CTRL_CARD_TYPE_IO_ONLY (1 << 1)
#define MVSD_HOST_CTRL_CARD_TYPE_IO_MEM_COMBO (2 << 1)
#define MVSD_HOST_CTRL_CARD_TYPE_IO_MMC (3 << 1)
#define MVSD_HOST_CTRL_CARD_TYPE_MASK (3 << 1)
#define MVSD_HOST_CTRL_BIG_ENDIAN (1 << 3)
#define MVSD_HOST_CTRL_LSB_FIRST (1 << 4)
#define MVSD_HOST_CTRL_DATA_WIDTH_4_BITS (1 << 9)
#define MVSD_HOST_CTRL_HI_SPEED_EN (1 << 10)
#define MVSD_HOST_CTRL_TMOUT_MAX 0xf
#define MVSD_HOST_CTRL_TMOUT_MASK (0xf << 11)
#define MVSD_HOST_CTRL_TMOUT(x) ((x) << 11)
#define MVSD_HOST_CTRL_TMOUT_EN (1 << 15)
/*
* MVSD_SW_RESET
*/
#define MVSD_SW_RESET_NOW (1 << 8)
/*
* Normal interrupt status bits
*/
#define MVSD_NOR_CMD_DONE (1 << 0)
#define MVSD_NOR_XFER_DONE (1 << 1)
#define MVSD_NOR_BLK_GAP_EVT (1 << 2)
#define MVSD_NOR_DMA_DONE (1 << 3)
#define MVSD_NOR_TX_AVAIL (1 << 4)
#define MVSD_NOR_RX_READY (1 << 5)
#define MVSD_NOR_CARD_INT (1 << 8)
#define MVSD_NOR_READ_WAIT_ON (1 << 9)
#define MVSD_NOR_RX_FIFO_8W (1 << 10)
#define MVSD_NOR_TX_FIFO_8W (1 << 11)
#define MVSD_NOR_SUSPEND_ON (1 << 12)
#define MVSD_NOR_AUTOCMD12_DONE (1 << 13)
#define MVSD_NOR_UNEXP_RSP (1 << 14)
#define MVSD_NOR_ERROR (1 << 15)
/*
* Error status bits
*/
#define MVSD_ERR_CMD_TIMEOUT (1 << 0)
#define MVSD_ERR_CMD_CRC (1 << 1)
#define MVSD_ERR_CMD_ENDBIT (1 << 2)
#define MVSD_ERR_CMD_INDEX (1 << 3)
#define MVSD_ERR_DATA_TIMEOUT (1 << 4)
#define MVSD_ERR_DATA_CRC (1 << 5)
#define MVSD_ERR_DATA_ENDBIT (1 << 6)
#define MVSD_ERR_AUTOCMD12 (1 << 8)
#define MVSD_ERR_CMD_STARTBIT (1 << 9)
#define MVSD_ERR_XFER_SIZE (1 << 10)
#define MVSD_ERR_RESP_T_BIT (1 << 11)
#define MVSD_ERR_CRC_ENDBIT (1 << 12)
#define MVSD_ERR_CRC_STARTBIT (1 << 13)
#define MVSD_ERR_CRC_STATUS (1 << 14)
/*
* CMD12 error status bits
*/
#define MVSD_AUTOCMD12_ERR_NOTEXE (1 << 0)
#define MVSD_AUTOCMD12_ERR_TIMEOUT (1 << 1)
#define MVSD_AUTOCMD12_ERR_CRC (1 << 2)
#define MVSD_AUTOCMD12_ERR_ENDBIT (1 << 3)
#define MVSD_AUTOCMD12_ERR_INDEX (1 << 4)
#define MVSD_AUTOCMD12_ERR_RESP_T_BIT (1 << 5)
#define MVSD_AUTOCMD12_ERR_RESP_STARTBIT (1 << 6)
#endif
File diff suppressed because it is too large. Load diff
+755
View File
@@ -0,0 +1,755 @@
/*
* Portions copyright (C) 2003 Russell King, PXA MMCI Driver
* Portions copyright (C) 2004-2005 Pierre Ossman, W83L51xD SD/MMC driver
*
* Copyright 2008 Embedded Alley Solutions, Inc.
* Copyright 2009-2011 Freescale Semiconductor, Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/ioport.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_gpio.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/dma-mapping.h>
#include <linux/dmaengine.h>
#include <linux/highmem.h>
#include <linux/clk.h>
#include <linux/err.h>
#include <linux/completion.h>
#include <linux/mmc/host.h>
#include <linux/mmc/mmc.h>
#include <linux/mmc/sdio.h>
#include <linux/mmc/slot-gpio.h>
#include <linux/gpio.h>
#include <linux/regulator/consumer.h>
#include <linux/module.h>
#include <linux/stmp_device.h>
#include <linux/spi/mxs-spi.h>
#define DRIVER_NAME "mxs-mmc"
#define MXS_MMC_IRQ_BITS (BM_SSP_CTRL1_SDIO_IRQ | \
BM_SSP_CTRL1_RESP_ERR_IRQ | \
BM_SSP_CTRL1_RESP_TIMEOUT_IRQ | \
BM_SSP_CTRL1_DATA_TIMEOUT_IRQ | \
BM_SSP_CTRL1_DATA_CRC_IRQ | \
BM_SSP_CTRL1_FIFO_UNDERRUN_IRQ | \
BM_SSP_CTRL1_RECV_TIMEOUT_IRQ | \
BM_SSP_CTRL1_FIFO_OVERRUN_IRQ)
/* card detect polling timeout */
#define MXS_MMC_DETECT_TIMEOUT (HZ/2)
struct mxs_mmc_host {
struct mxs_ssp ssp;
struct mmc_host *mmc;
struct mmc_request *mrq;
struct mmc_command *cmd;
struct mmc_data *data;
unsigned char bus_width;
spinlock_t lock;
int sdio_irq_en;
bool broken_cd;
};
static int mxs_mmc_get_cd(struct mmc_host *mmc)
{
struct mxs_mmc_host *host = mmc_priv(mmc);
struct mxs_ssp *ssp = &host->ssp;
int present, ret;
if (host->broken_cd)
return -ENOSYS;
ret = mmc_gpio_get_cd(mmc);
if (ret >= 0)
return ret;
present = mmc->caps & MMC_CAP_NEEDS_POLL ||
!(readl(ssp->base + HW_SSP_STATUS(ssp)) &
BM_SSP_STATUS_CARD_DETECT);
if (mmc->caps2 & MMC_CAP2_CD_ACTIVE_HIGH)
present = !present;
return present;
}
static int mxs_mmc_reset(struct mxs_mmc_host *host)
{
struct mxs_ssp *ssp = &host->ssp;
u32 ctrl0, ctrl1;
int ret;
ret = stmp_reset_block(ssp->base);
if (ret)
return ret;
ctrl0 = BM_SSP_CTRL0_IGNORE_CRC;
ctrl1 = BF_SSP(0x3, CTRL1_SSP_MODE) |
BF_SSP(0x7, CTRL1_WORD_LENGTH) |
BM_SSP_CTRL1_DMA_ENABLE |
BM_SSP_CTRL1_POLARITY |
BM_SSP_CTRL1_RECV_TIMEOUT_IRQ_EN |
BM_SSP_CTRL1_DATA_CRC_IRQ_EN |
BM_SSP_CTRL1_DATA_TIMEOUT_IRQ_EN |
BM_SSP_CTRL1_RESP_TIMEOUT_IRQ_EN |
BM_SSP_CTRL1_RESP_ERR_IRQ_EN;
writel(BF_SSP(0xffff, TIMING_TIMEOUT) |
BF_SSP(2, TIMING_CLOCK_DIVIDE) |
BF_SSP(0, TIMING_CLOCK_RATE),
ssp->base + HW_SSP_TIMING(ssp));
if (host->sdio_irq_en) {
ctrl0 |= BM_SSP_CTRL0_SDIO_IRQ_CHECK;
ctrl1 |= BM_SSP_CTRL1_SDIO_IRQ_EN;
}
writel(ctrl0, ssp->base + HW_SSP_CTRL0);
writel(ctrl1, ssp->base + HW_SSP_CTRL1(ssp));
return 0;
}
static void mxs_mmc_start_cmd(struct mxs_mmc_host *host,
struct mmc_command *cmd);
static void mxs_mmc_request_done(struct mxs_mmc_host *host)
{
struct mmc_command *cmd = host->cmd;
struct mmc_data *data = host->data;
struct mmc_request *mrq = host->mrq;
struct mxs_ssp *ssp = &host->ssp;
if (mmc_resp_type(cmd) & MMC_RSP_PRESENT) {
if (mmc_resp_type(cmd) & MMC_RSP_136) {
cmd->resp[3] = readl(ssp->base + HW_SSP_SDRESP0(ssp));
cmd->resp[2] = readl(ssp->base + HW_SSP_SDRESP1(ssp));
cmd->resp[1] = readl(ssp->base + HW_SSP_SDRESP2(ssp));
cmd->resp[0] = readl(ssp->base + HW_SSP_SDRESP3(ssp));
} else {
cmd->resp[0] = readl(ssp->base + HW_SSP_SDRESP0(ssp));
}
}
if (cmd == mrq->sbc) {
/* Finished CMD23, now send actual command. */
mxs_mmc_start_cmd(host, mrq->cmd);
return;
} else if (data) {
dma_unmap_sg(mmc_dev(host->mmc), data->sg,
data->sg_len, ssp->dma_dir);
/*
* If there was an error on any block, we mark all
* data blocks as being in error.
*/
if (!data->error)
data->bytes_xfered = data->blocks * data->blksz;
else
data->bytes_xfered = 0;
host->data = NULL;
if (data->stop && (data->error || !mrq->sbc)) {
mxs_mmc_start_cmd(host, mrq->stop);
return;
}
}
host->mrq = NULL;
mmc_request_done(host->mmc, mrq);
}
static void mxs_mmc_dma_irq_callback(void *param)
{
struct mxs_mmc_host *host = param;
mxs_mmc_request_done(host);
}
static irqreturn_t mxs_mmc_irq_handler(int irq, void *dev_id)
{
struct mxs_mmc_host *host = dev_id;
struct mmc_command *cmd = host->cmd;
struct mmc_data *data = host->data;
struct mxs_ssp *ssp = &host->ssp;
u32 stat;
spin_lock(&host->lock);
stat = readl(ssp->base + HW_SSP_CTRL1(ssp));
writel(stat & MXS_MMC_IRQ_BITS,
ssp->base + HW_SSP_CTRL1(ssp) + STMP_OFFSET_REG_CLR);
spin_unlock(&host->lock);
if ((stat & BM_SSP_CTRL1_SDIO_IRQ) && (stat & BM_SSP_CTRL1_SDIO_IRQ_EN))
mmc_signal_sdio_irq(host->mmc);
if (stat & BM_SSP_CTRL1_RESP_TIMEOUT_IRQ)
cmd->error = -ETIMEDOUT;
else if (stat & BM_SSP_CTRL1_RESP_ERR_IRQ)
cmd->error = -EIO;
if (data) {
if (stat & (BM_SSP_CTRL1_DATA_TIMEOUT_IRQ |
BM_SSP_CTRL1_RECV_TIMEOUT_IRQ))
data->error = -ETIMEDOUT;
else if (stat & BM_SSP_CTRL1_DATA_CRC_IRQ)
data->error = -EILSEQ;
else if (stat & (BM_SSP_CTRL1_FIFO_UNDERRUN_IRQ |
BM_SSP_CTRL1_FIFO_OVERRUN_IRQ))
data->error = -EIO;
}
return IRQ_HANDLED;
}
static struct dma_async_tx_descriptor *mxs_mmc_prep_dma(
struct mxs_mmc_host *host, unsigned long flags)
{
struct mxs_ssp *ssp = &host->ssp;
struct dma_async_tx_descriptor *desc;
struct mmc_data *data = host->data;
struct scatterlist * sgl;
unsigned int sg_len;
if (data) {
/* data */
dma_map_sg(mmc_dev(host->mmc), data->sg,
data->sg_len, ssp->dma_dir);
sgl = data->sg;
sg_len = data->sg_len;
} else {
/* pio */
sgl = (struct scatterlist *) ssp->ssp_pio_words;
sg_len = SSP_PIO_NUM;
}
desc = dmaengine_prep_slave_sg(ssp->dmach,
sgl, sg_len, ssp->slave_dirn, flags);
if (desc) {
desc->callback = mxs_mmc_dma_irq_callback;
desc->callback_param = host;
} else {
if (data)
dma_unmap_sg(mmc_dev(host->mmc), data->sg,
data->sg_len, ssp->dma_dir);
}
return desc;
}
static void mxs_mmc_bc(struct mxs_mmc_host *host)
{
struct mxs_ssp *ssp = &host->ssp;
struct mmc_command *cmd = host->cmd;
struct dma_async_tx_descriptor *desc;
u32 ctrl0, cmd0, cmd1;
ctrl0 = BM_SSP_CTRL0_ENABLE | BM_SSP_CTRL0_IGNORE_CRC;
cmd0 = BF_SSP(cmd->opcode, CMD0_CMD) | BM_SSP_CMD0_APPEND_8CYC;
cmd1 = cmd->arg;
if (host->sdio_irq_en) {
ctrl0 |= BM_SSP_CTRL0_SDIO_IRQ_CHECK;
cmd0 |= BM_SSP_CMD0_CONT_CLKING_EN | BM_SSP_CMD0_SLOW_CLKING_EN;
}
ssp->ssp_pio_words[0] = ctrl0;
ssp->ssp_pio_words[1] = cmd0;
ssp->ssp_pio_words[2] = cmd1;
ssp->dma_dir = DMA_NONE;
ssp->slave_dirn = DMA_TRANS_NONE;
desc = mxs_mmc_prep_dma(host, DMA_CTRL_ACK);
if (!desc)
goto out;
dmaengine_submit(desc);
dma_async_issue_pending(ssp->dmach);
return;
out:
dev_warn(mmc_dev(host->mmc),
"%s: failed to prep dma\n", __func__);
}
static void mxs_mmc_ac(struct mxs_mmc_host *host)
{
struct mxs_ssp *ssp = &host->ssp;
struct mmc_command *cmd = host->cmd;
struct dma_async_tx_descriptor *desc;
u32 ignore_crc, get_resp, long_resp;
u32 ctrl0, cmd0, cmd1;
ignore_crc = (mmc_resp_type(cmd) & MMC_RSP_CRC) ?
0 : BM_SSP_CTRL0_IGNORE_CRC;
get_resp = (mmc_resp_type(cmd) & MMC_RSP_PRESENT) ?
BM_SSP_CTRL0_GET_RESP : 0;
long_resp = (mmc_resp_type(cmd) & MMC_RSP_136) ?
BM_SSP_CTRL0_LONG_RESP : 0;
ctrl0 = BM_SSP_CTRL0_ENABLE | ignore_crc | get_resp | long_resp;
cmd0 = BF_SSP(cmd->opcode, CMD0_CMD);
cmd1 = cmd->arg;
if (cmd->opcode == MMC_STOP_TRANSMISSION)
cmd0 |= BM_SSP_CMD0_APPEND_8CYC;
if (host->sdio_irq_en) {
ctrl0 |= BM_SSP_CTRL0_SDIO_IRQ_CHECK;
cmd0 |= BM_SSP_CMD0_CONT_CLKING_EN | BM_SSP_CMD0_SLOW_CLKING_EN;
}
ssp->ssp_pio_words[0] = ctrl0;
ssp->ssp_pio_words[1] = cmd0;
ssp->ssp_pio_words[2] = cmd1;
ssp->dma_dir = DMA_NONE;
ssp->slave_dirn = DMA_TRANS_NONE;
desc = mxs_mmc_prep_dma(host, DMA_CTRL_ACK);
if (!desc)
goto out;
dmaengine_submit(desc);
dma_async_issue_pending(ssp->dmach);
return;
out:
dev_warn(mmc_dev(host->mmc),
"%s: failed to prep dma\n", __func__);
}
static unsigned short mxs_ns_to_ssp_ticks(unsigned clock_rate, unsigned ns)
{
const unsigned int ssp_timeout_mul = 4096;
/*
* Calculate ticks in ms since ns are large numbers
* and might overflow
*/
const unsigned int clock_per_ms = clock_rate / 1000;
const unsigned int ms = ns / 1000;
const unsigned int ticks = ms * clock_per_ms;
const unsigned int ssp_ticks = ticks / ssp_timeout_mul;
WARN_ON(ssp_ticks == 0);
return ssp_ticks;
}
static void mxs_mmc_adtc(struct mxs_mmc_host *host)
{
struct mmc_command *cmd = host->cmd;
struct mmc_data *data = cmd->data;
struct dma_async_tx_descriptor *desc;
struct scatterlist *sgl = data->sg, *sg;
unsigned int sg_len = data->sg_len;
unsigned int i;
unsigned short dma_data_dir, timeout;
enum dma_transfer_direction slave_dirn;
unsigned int data_size = 0, log2_blksz;
unsigned int blocks = data->blocks;
struct mxs_ssp *ssp = &host->ssp;
u32 ignore_crc, get_resp, long_resp, read;
u32 ctrl0, cmd0, cmd1, val;
ignore_crc = (mmc_resp_type(cmd) & MMC_RSP_CRC) ?
0 : BM_SSP_CTRL0_IGNORE_CRC;
get_resp = (mmc_resp_type(cmd) & MMC_RSP_PRESENT) ?
BM_SSP_CTRL0_GET_RESP : 0;
long_resp = (mmc_resp_type(cmd) & MMC_RSP_136) ?
BM_SSP_CTRL0_LONG_RESP : 0;
if (data->flags & MMC_DATA_WRITE) {
dma_data_dir = DMA_TO_DEVICE;
slave_dirn = DMA_MEM_TO_DEV;
read = 0;
} else {
dma_data_dir = DMA_FROM_DEVICE;
slave_dirn = DMA_DEV_TO_MEM;
read = BM_SSP_CTRL0_READ;
}
ctrl0 = BF_SSP(host->bus_width, CTRL0_BUS_WIDTH) |
ignore_crc | get_resp | long_resp |
BM_SSP_CTRL0_DATA_XFER | read |
BM_SSP_CTRL0_WAIT_FOR_IRQ |
BM_SSP_CTRL0_ENABLE;
cmd0 = BF_SSP(cmd->opcode, CMD0_CMD);
/* get logarithm to base 2 of block size for setting register */
log2_blksz = ilog2(data->blksz);
/*
* take special care of the case that data size from data->sg
* is not equal to blocks x blksz
*/
for_each_sg(sgl, sg, sg_len, i)
data_size += sg->length;
if (data_size != data->blocks * data->blksz)
blocks = 1;
/* xfer count, block size and count need to be set differently */
if (ssp_is_old(ssp)) {
ctrl0 |= BF_SSP(data_size, CTRL0_XFER_COUNT);
cmd0 |= BF_SSP(log2_blksz, CMD0_BLOCK_SIZE) |
BF_SSP(blocks - 1, CMD0_BLOCK_COUNT);
} else {
writel(data_size, ssp->base + HW_SSP_XFER_SIZE);
writel(BF_SSP(log2_blksz, BLOCK_SIZE_BLOCK_SIZE) |
BF_SSP(blocks - 1, BLOCK_SIZE_BLOCK_COUNT),
ssp->base + HW_SSP_BLOCK_SIZE);
}
if (cmd->opcode == SD_IO_RW_EXTENDED)
cmd0 |= BM_SSP_CMD0_APPEND_8CYC;
cmd1 = cmd->arg;
if (host->sdio_irq_en) {
ctrl0 |= BM_SSP_CTRL0_SDIO_IRQ_CHECK;
cmd0 |= BM_SSP_CMD0_CONT_CLKING_EN | BM_SSP_CMD0_SLOW_CLKING_EN;
}
/* set the timeout count */
timeout = mxs_ns_to_ssp_ticks(ssp->clk_rate, data->timeout_ns);
val = readl(ssp->base + HW_SSP_TIMING(ssp));
val &= ~(BM_SSP_TIMING_TIMEOUT);
val |= BF_SSP(timeout, TIMING_TIMEOUT);
writel(val, ssp->base + HW_SSP_TIMING(ssp));
/* pio */
ssp->ssp_pio_words[0] = ctrl0;
ssp->ssp_pio_words[1] = cmd0;
ssp->ssp_pio_words[2] = cmd1;
ssp->dma_dir = DMA_NONE;
ssp->slave_dirn = DMA_TRANS_NONE;
desc = mxs_mmc_prep_dma(host, 0);
if (!desc)
goto out;
/* append data sg */
WARN_ON(host->data != NULL);
host->data = data;
ssp->dma_dir = dma_data_dir;
ssp->slave_dirn = slave_dirn;
desc = mxs_mmc_prep_dma(host, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
if (!desc)
goto out;
dmaengine_submit(desc);
dma_async_issue_pending(ssp->dmach);
return;
out:
dev_warn(mmc_dev(host->mmc),
"%s: failed to prep dma\n", __func__);
}
static void mxs_mmc_start_cmd(struct mxs_mmc_host *host,
struct mmc_command *cmd)
{
host->cmd = cmd;
switch (mmc_cmd_type(cmd)) {
case MMC_CMD_BC:
mxs_mmc_bc(host);
break;
case MMC_CMD_BCR:
mxs_mmc_ac(host);
break;
case MMC_CMD_AC:
mxs_mmc_ac(host);
break;
case MMC_CMD_ADTC:
mxs_mmc_adtc(host);
break;
default:
dev_warn(mmc_dev(host->mmc),
"%s: unknown MMC command\n", __func__);
break;
}
}
static void mxs_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
{
struct mxs_mmc_host *host = mmc_priv(mmc);
WARN_ON(host->mrq != NULL);
host->mrq = mrq;
if (mrq->sbc)
mxs_mmc_start_cmd(host, mrq->sbc);
else
mxs_mmc_start_cmd(host, mrq->cmd);
}
static void mxs_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
{
struct mxs_mmc_host *host = mmc_priv(mmc);
if (ios->bus_width == MMC_BUS_WIDTH_8)
host->bus_width = 2;
else if (ios->bus_width == MMC_BUS_WIDTH_4)
host->bus_width = 1;
else
host->bus_width = 0;
if (ios->clock)
mxs_ssp_set_clk_rate(&host->ssp, ios->clock);
}
static void mxs_mmc_enable_sdio_irq(struct mmc_host *mmc, int enable)
{
struct mxs_mmc_host *host = mmc_priv(mmc);
struct mxs_ssp *ssp = &host->ssp;
unsigned long flags;
spin_lock_irqsave(&host->lock, flags);
host->sdio_irq_en = enable;
if (enable) {
writel(BM_SSP_CTRL0_SDIO_IRQ_CHECK,
ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);
writel(BM_SSP_CTRL1_SDIO_IRQ_EN,
ssp->base + HW_SSP_CTRL1(ssp) + STMP_OFFSET_REG_SET);
} else {
writel(BM_SSP_CTRL0_SDIO_IRQ_CHECK,
ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_CLR);
writel(BM_SSP_CTRL1_SDIO_IRQ_EN,
ssp->base + HW_SSP_CTRL1(ssp) + STMP_OFFSET_REG_CLR);
}
spin_unlock_irqrestore(&host->lock, flags);
if (enable && readl(ssp->base + HW_SSP_STATUS(ssp)) &
BM_SSP_STATUS_SDIO_IRQ)
mmc_signal_sdio_irq(host->mmc);
}
static const struct mmc_host_ops mxs_mmc_ops = {
.request = mxs_mmc_request,
.get_ro = mmc_gpio_get_ro,
.get_cd = mxs_mmc_get_cd,
.set_ios = mxs_mmc_set_ios,
.enable_sdio_irq = mxs_mmc_enable_sdio_irq,
};
static const struct platform_device_id mxs_ssp_ids[] = {
{
.name = "imx23-mmc",
.driver_data = IMX23_SSP,
}, {
.name = "imx28-mmc",
.driver_data = IMX28_SSP,
}, {
/* sentinel */
}
};
MODULE_DEVICE_TABLE(platform, mxs_ssp_ids);
static const struct of_device_id mxs_mmc_dt_ids[] = {
{ .compatible = "fsl,imx23-mmc", .data = (void *) IMX23_SSP, },
{ .compatible = "fsl,imx28-mmc", .data = (void *) IMX28_SSP, },
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, mxs_mmc_dt_ids);
static int mxs_mmc_probe(struct platform_device *pdev)
{
const struct of_device_id *of_id =
of_match_device(mxs_mmc_dt_ids, &pdev->dev);
struct device_node *np = pdev->dev.of_node;
struct mxs_mmc_host *host;
struct mmc_host *mmc;
struct resource *iores;
int ret = 0, irq_err;
struct regulator *reg_vmmc;
struct mxs_ssp *ssp;
irq_err = platform_get_irq(pdev, 0);
if (irq_err < 0)
return irq_err;
mmc = mmc_alloc_host(sizeof(struct mxs_mmc_host), &pdev->dev);
if (!mmc)
return -ENOMEM;
host = mmc_priv(mmc);
ssp = &host->ssp;
ssp->dev = &pdev->dev;
iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
ssp->base = devm_ioremap_resource(&pdev->dev, iores);
if (IS_ERR(ssp->base)) {
ret = PTR_ERR(ssp->base);
goto out_mmc_free;
}
ssp->devid = (enum mxs_ssp_id) of_id->data;
host->mmc = mmc;
host->sdio_irq_en = 0;
reg_vmmc = devm_regulator_get(&pdev->dev, "vmmc");
if (!IS_ERR(reg_vmmc)) {
ret = regulator_enable(reg_vmmc);
if (ret) {
dev_err(&pdev->dev,
"Failed to enable vmmc regulator: %d\n", ret);
goto out_mmc_free;
}
}
ssp->clk = devm_clk_get(&pdev->dev, NULL);
if (IS_ERR(ssp->clk)) {
ret = PTR_ERR(ssp->clk);
goto out_mmc_free;
}
ret = clk_prepare_enable(ssp->clk);
if (ret)
goto out_mmc_free;
ret = mxs_mmc_reset(host);
if (ret) {
dev_err(&pdev->dev, "Failed to reset mmc: %d\n", ret);
goto out_clk_disable;
}
ssp->dmach = dma_request_slave_channel(&pdev->dev, "rx-tx");
if (!ssp->dmach) {
dev_err(mmc_dev(host->mmc),
"%s: failed to request dma\n", __func__);
ret = -ENODEV;
goto out_clk_disable;
}
/* set mmc core parameters */
mmc->ops = &mxs_mmc_ops;
mmc->caps = MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED |
MMC_CAP_SDIO_IRQ | MMC_CAP_NEEDS_POLL | MMC_CAP_CMD23;
host->broken_cd = of_property_read_bool(np, "broken-cd");
mmc->f_min = 400000;
mmc->f_max = 288000000;
ret = mmc_of_parse(mmc);
if (ret)
goto out_free_dma;
mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
mmc->max_segs = 52;
mmc->max_blk_size = 1 << 0xf;
mmc->max_blk_count = (ssp_is_old(ssp)) ? 0xff : 0xffffff;
mmc->max_req_size = (ssp_is_old(ssp)) ? 0xffff : 0xffffffff;
mmc->max_seg_size = dma_get_max_seg_size(ssp->dmach->device->dev);
platform_set_drvdata(pdev, mmc);
spin_lock_init(&host->lock);
ret = devm_request_irq(&pdev->dev, irq_err, mxs_mmc_irq_handler, 0,
dev_name(&pdev->dev), host);
if (ret)
goto out_free_dma;
ret = mmc_add_host(mmc);
if (ret)
goto out_free_dma;
dev_info(mmc_dev(host->mmc), "initialized\n");
return 0;
out_free_dma:
dma_release_channel(ssp->dmach);
out_clk_disable:
clk_disable_unprepare(ssp->clk);
out_mmc_free:
mmc_free_host(mmc);
return ret;
}
static int mxs_mmc_remove(struct platform_device *pdev)
{
struct mmc_host *mmc = platform_get_drvdata(pdev);
struct mxs_mmc_host *host = mmc_priv(mmc);
struct mxs_ssp *ssp = &host->ssp;
mmc_remove_host(mmc);
if (ssp->dmach)
dma_release_channel(ssp->dmach);
clk_disable_unprepare(ssp->clk);
mmc_free_host(mmc);
return 0;
}
#ifdef CONFIG_PM_SLEEP
static int mxs_mmc_suspend(struct device *dev)
{
struct mmc_host *mmc = dev_get_drvdata(dev);
struct mxs_mmc_host *host = mmc_priv(mmc);
struct mxs_ssp *ssp = &host->ssp;
clk_disable_unprepare(ssp->clk);
return 0;
}
static int mxs_mmc_resume(struct device *dev)
{
struct mmc_host *mmc = dev_get_drvdata(dev);
struct mxs_mmc_host *host = mmc_priv(mmc);
struct mxs_ssp *ssp = &host->ssp;
return clk_prepare_enable(ssp->clk);
}
#endif
static SIMPLE_DEV_PM_OPS(mxs_mmc_pm_ops, mxs_mmc_suspend, mxs_mmc_resume);
static struct platform_driver mxs_mmc_driver = {
.probe = mxs_mmc_probe,
.remove = mxs_mmc_remove,
.id_table = mxs_ssp_ids,
.driver = {
.name = DRIVER_NAME,
.pm = &mxs_mmc_pm_ops,
.of_match_table = mxs_mmc_dt_ids,
},
};
module_platform_driver(mxs_mmc_driver);
MODULE_DESCRIPTION("FREESCALE MXS MMC peripheral");
MODULE_AUTHOR("Freescale Semiconductor");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:" DRIVER_NAME);
+157
View File
@@ -0,0 +1,157 @@
/*
* OpenFirmware bindings for the MMC-over-SPI driver
*
* Copyright (c) MontaVista Software, Inc. 2008.
*
* Author: Anton Vorontsov <avorontsov@ru.mvista.com>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/irq.h>
#include <linux/gpio.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/spi/spi.h>
#include <linux/spi/mmc_spi.h>
#include <linux/mmc/core.h>
#include <linux/mmc/host.h>
/* For archs that don't support NO_IRQ (such as mips), provide a dummy value */
#ifndef NO_IRQ
#define NO_IRQ 0
#endif
MODULE_LICENSE("GPL");
enum {
CD_GPIO = 0,
WP_GPIO,
NUM_GPIOS,
};
struct of_mmc_spi {
int gpios[NUM_GPIOS];
bool alow_gpios[NUM_GPIOS];
int detect_irq;
struct mmc_spi_platform_data pdata;
};
static struct of_mmc_spi *to_of_mmc_spi(struct device *dev)
{
return container_of(dev->platform_data, struct of_mmc_spi, pdata);
}
static int of_mmc_spi_init(struct device *dev,
irqreturn_t (*irqhandler)(int, void *), void *mmc)
{
struct of_mmc_spi *oms = to_of_mmc_spi(dev);
return request_threaded_irq(oms->detect_irq, NULL, irqhandler,
IRQF_ONESHOT, dev_name(dev), mmc);
}
static void of_mmc_spi_exit(struct device *dev, void *mmc)
{
struct of_mmc_spi *oms = to_of_mmc_spi(dev);
free_irq(oms->detect_irq, mmc);
}
struct mmc_spi_platform_data *mmc_spi_get_pdata(struct spi_device *spi)
{
struct device *dev = &spi->dev;
struct device_node *np = dev->of_node;
struct of_mmc_spi *oms;
const __be32 *voltage_ranges;
int num_ranges;
int i;
if (dev->platform_data || !np)
return dev->platform_data;
oms = kzalloc(sizeof(*oms), GFP_KERNEL);
if (!oms)
return NULL;
voltage_ranges = of_get_property(np, "voltage-ranges", &num_ranges);
num_ranges = num_ranges / sizeof(*voltage_ranges) / 2;
if (!voltage_ranges || !num_ranges) {
dev_err(dev, "OF: voltage-ranges unspecified\n");
goto err_ocr;
}
for (i = 0; i < num_ranges; i++) {
const int j = i * 2;
u32 mask;
mask = mmc_vddrange_to_ocrmask(be32_to_cpu(voltage_ranges[j]),
be32_to_cpu(voltage_ranges[j + 1]));
if (!mask) {
dev_err(dev, "OF: voltage-range #%d is invalid\n", i);
goto err_ocr;
}
oms->pdata.ocr_mask |= mask;
}
for (i = 0; i < ARRAY_SIZE(oms->gpios); i++) {
enum of_gpio_flags gpio_flags;
oms->gpios[i] = of_get_gpio_flags(np, i, &gpio_flags);
if (!gpio_is_valid(oms->gpios[i]))
continue;
if (gpio_flags & OF_GPIO_ACTIVE_LOW)
oms->alow_gpios[i] = true;
}
if (gpio_is_valid(oms->gpios[CD_GPIO])) {
oms->pdata.cd_gpio = oms->gpios[CD_GPIO];
oms->pdata.flags |= MMC_SPI_USE_CD_GPIO;
if (!oms->alow_gpios[CD_GPIO])
oms->pdata.caps2 |= MMC_CAP2_CD_ACTIVE_HIGH;
}
if (gpio_is_valid(oms->gpios[WP_GPIO])) {
oms->pdata.ro_gpio = oms->gpios[WP_GPIO];
oms->pdata.flags |= MMC_SPI_USE_RO_GPIO;
if (!oms->alow_gpios[WP_GPIO])
oms->pdata.caps2 |= MMC_CAP2_RO_ACTIVE_HIGH;
}
oms->detect_irq = irq_of_parse_and_map(np, 0);
if (oms->detect_irq != 0) {
oms->pdata.init = of_mmc_spi_init;
oms->pdata.exit = of_mmc_spi_exit;
} else {
oms->pdata.caps |= MMC_CAP_NEEDS_POLL;
}
dev->platform_data = &oms->pdata;
return dev->platform_data;
err_ocr:
kfree(oms);
return NULL;
}
EXPORT_SYMBOL(mmc_spi_get_pdata);
void mmc_spi_put_pdata(struct spi_device *spi)
{
struct device *dev = &spi->dev;
struct device_node *np = dev->of_node;
struct of_mmc_spi *oms = to_of_mmc_spi(dev);
if (!dev->platform_data || !np)
return;
kfree(oms);
dev->platform_data = NULL;
}
EXPORT_SYMBOL(mmc_spi_put_pdata);
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+839
View File
@@ -0,0 +1,839 @@
/*
* linux/drivers/mmc/host/pxa.c - PXA MMCI driver
*
* Copyright (C) 2003 Russell King, 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.
*
* This hardware is really sick:
* - No way to clear interrupts.
* - Have to turn off the clock whenever we touch the device.
* - Doesn't tell you how many data blocks were transferred.
* Yuck!
*
* 1 and 3 byte data transfers not supported
* max block length up to 1023
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/ioport.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/dmaengine.h>
#include <linux/dma-mapping.h>
#include <linux/clk.h>
#include <linux/err.h>
#include <linux/mmc/host.h>
#include <linux/mmc/slot-gpio.h>
#include <linux/io.h>
#include <linux/regulator/consumer.h>
#include <linux/gpio.h>
#include <linux/gfp.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/of_device.h>
#include <asm/sizes.h>
#include <mach/hardware.h>
#include <linux/platform_data/mmc-pxamci.h>
#include "pxamci.h"
#define DRIVER_NAME "pxa2xx-mci"
#define NR_SG 1
#define CLKRT_OFF (~0)
#define mmc_has_26MHz() (cpu_is_pxa300() || cpu_is_pxa310() \
|| cpu_is_pxa935())
struct pxamci_host {
struct mmc_host *mmc;
spinlock_t lock;
struct resource *res;
void __iomem *base;
struct clk *clk;
unsigned long clkrate;
unsigned int clkrt;
unsigned int cmdat;
unsigned int imask;
unsigned int power_mode;
unsigned long detect_delay_ms;
struct pxamci_platform_data *pdata;
struct mmc_request *mrq;
struct mmc_command *cmd;
struct mmc_data *data;
struct dma_chan *dma_chan_rx;
struct dma_chan *dma_chan_tx;
dma_cookie_t dma_cookie;
unsigned int dma_len;
unsigned int dma_dir;
};
static int pxamci_init_ocr(struct pxamci_host *host)
{
struct mmc_host *mmc = host->mmc;
int ret;
ret = mmc_regulator_get_supply(mmc);
if (ret < 0)
return ret;
if (IS_ERR(mmc->supply.vmmc)) {
/* fall-back to platform data */
mmc->ocr_avail = host->pdata ?
host->pdata->ocr_mask :
MMC_VDD_32_33 | MMC_VDD_33_34;
}
return 0;
}
static inline int pxamci_set_power(struct pxamci_host *host,
unsigned char power_mode,
unsigned int vdd)
{
struct mmc_host *mmc = host->mmc;
struct regulator *supply = mmc->supply.vmmc;
int on;
if (!IS_ERR(supply))
return mmc_regulator_set_ocr(mmc, supply, vdd);
if (host->pdata &&
gpio_is_valid(host->pdata->gpio_power)) {
on = ((1 << vdd) & host->pdata->ocr_mask);
gpio_set_value(host->pdata->gpio_power,
!!on ^ host->pdata->gpio_power_invert);
}
if (host->pdata && host->pdata->setpower)
return host->pdata->setpower(mmc_dev(host->mmc), vdd);
return 0;
}
static void pxamci_stop_clock(struct pxamci_host *host)
{
if (readl(host->base + MMC_STAT) & STAT_CLK_EN) {
unsigned long timeout = 10000;
unsigned int v;
writel(STOP_CLOCK, host->base + MMC_STRPCL);
do {
v = readl(host->base + MMC_STAT);
if (!(v & STAT_CLK_EN))
break;
udelay(1);
} while (timeout--);
if (v & STAT_CLK_EN)
dev_err(mmc_dev(host->mmc), "unable to stop clock\n");
}
}
static void pxamci_enable_irq(struct pxamci_host *host, unsigned int mask)
{
unsigned long flags;
spin_lock_irqsave(&host->lock, flags);
host->imask &= ~mask;
writel(host->imask, host->base + MMC_I_MASK);
spin_unlock_irqrestore(&host->lock, flags);
}
static void pxamci_disable_irq(struct pxamci_host *host, unsigned int mask)
{
unsigned long flags;
spin_lock_irqsave(&host->lock, flags);
host->imask |= mask;
writel(host->imask, host->base + MMC_I_MASK);
spin_unlock_irqrestore(&host->lock, flags);
}
static void pxamci_dma_irq(void *param);
static void pxamci_setup_data(struct pxamci_host *host, struct mmc_data *data)
{
struct dma_async_tx_descriptor *tx;
enum dma_transfer_direction direction;
struct dma_slave_config config;
struct dma_chan *chan;
unsigned int nob = data->blocks;
unsigned long long clks;
unsigned int timeout;
int ret;
host->data = data;
writel(nob, host->base + MMC_NOB);
writel(data->blksz, host->base + MMC_BLKLEN);
clks = (unsigned long long)data->timeout_ns * host->clkrate;
do_div(clks, 1000000000UL);
timeout = (unsigned int)clks + (data->timeout_clks << host->clkrt);
writel((timeout + 255) / 256, host->base + MMC_RDTO);
memset(&config, 0, sizeof(config));
config.src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
config.dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
config.src_addr = host->res->start + MMC_RXFIFO;
config.dst_addr = host->res->start + MMC_TXFIFO;
config.src_maxburst = 32;
config.dst_maxburst = 32;
if (data->flags & MMC_DATA_READ) {
host->dma_dir = DMA_FROM_DEVICE;
direction = DMA_DEV_TO_MEM;
chan = host->dma_chan_rx;
} else {
host->dma_dir = DMA_TO_DEVICE;
direction = DMA_MEM_TO_DEV;
chan = host->dma_chan_tx;
}
config.direction = direction;
ret = dmaengine_slave_config(chan, &config);
if (ret < 0) {
dev_err(mmc_dev(host->mmc), "dma slave config failed\n");
return;
}
host->dma_len = dma_map_sg(chan->device->dev, data->sg, data->sg_len,
host->dma_dir);
tx = dmaengine_prep_slave_sg(chan, data->sg, host->dma_len, direction,
DMA_PREP_INTERRUPT);
if (!tx) {
dev_err(mmc_dev(host->mmc), "prep_slave_sg() failed\n");
return;
}
if (!(data->flags & MMC_DATA_READ)) {
tx->callback = pxamci_dma_irq;
tx->callback_param = host;
}
host->dma_cookie = dmaengine_submit(tx);
/*
* workaround for erratum #91:
* only start DMA now if we are doing a read,
* otherwise we wait until CMD/RESP has finished
* before starting DMA.
*/
if (!cpu_is_pxa27x() || data->flags & MMC_DATA_READ)
dma_async_issue_pending(chan);
}
static void pxamci_start_cmd(struct pxamci_host *host, struct mmc_command *cmd, unsigned int cmdat)
{
WARN_ON(host->cmd != NULL);
host->cmd = cmd;
if (cmd->flags & MMC_RSP_BUSY)
cmdat |= CMDAT_BUSY;
#define RSP_TYPE(x) ((x) & ~(MMC_RSP_BUSY|MMC_RSP_OPCODE))
switch (RSP_TYPE(mmc_resp_type(cmd))) {
case RSP_TYPE(MMC_RSP_R1): /* r1, r1b, r6, r7 */
cmdat |= CMDAT_RESP_SHORT;
break;
case RSP_TYPE(MMC_RSP_R3):
cmdat |= CMDAT_RESP_R3;
break;
case RSP_TYPE(MMC_RSP_R2):
cmdat |= CMDAT_RESP_R2;
break;
default:
break;
}
writel(cmd->opcode, host->base + MMC_CMD);
writel(cmd->arg >> 16, host->base + MMC_ARGH);
writel(cmd->arg & 0xffff, host->base + MMC_ARGL);
writel(cmdat, host->base + MMC_CMDAT);
writel(host->clkrt, host->base + MMC_CLKRT);
writel(START_CLOCK, host->base + MMC_STRPCL);
pxamci_enable_irq(host, END_CMD_RES);
}
static void pxamci_finish_request(struct pxamci_host *host, struct mmc_request *mrq)
{
host->mrq = NULL;
host->cmd = NULL;
host->data = NULL;
mmc_request_done(host->mmc, mrq);
}
static int pxamci_cmd_done(struct pxamci_host *host, unsigned int stat)
{
struct mmc_command *cmd = host->cmd;
int i;
u32 v;
if (!cmd)
return 0;
host->cmd = NULL;
/*
* Did I mention this is Sick. We always need to
* discard the upper 8 bits of the first 16-bit word.
*/
v = readl(host->base + MMC_RES) & 0xffff;
for (i = 0; i < 4; i++) {
u32 w1 = readl(host->base + MMC_RES) & 0xffff;
u32 w2 = readl(host->base + MMC_RES) & 0xffff;
cmd->resp[i] = v << 24 | w1 << 8 | w2 >> 8;
v = w2;
}
if (stat & STAT_TIME_OUT_RESPONSE) {
cmd->error = -ETIMEDOUT;
} else if (stat & STAT_RES_CRC_ERR && cmd->flags & MMC_RSP_CRC) {
/*
* workaround for erratum #42:
* Intel PXA27x Family Processor Specification Update Rev 001
* A bogus CRC error can appear if the msb of a 136 bit
* response is a one.
*/
if (cpu_is_pxa27x() &&
(cmd->flags & MMC_RSP_136 && cmd->resp[0] & 0x80000000))
pr_debug("ignoring CRC from command %d - *risky*\n", cmd->opcode);
else
cmd->error = -EILSEQ;
}
pxamci_disable_irq(host, END_CMD_RES);
if (host->data && !cmd->error) {
pxamci_enable_irq(host, DATA_TRAN_DONE);
/*
* workaround for erratum #91, if doing write
* enable DMA late
*/
if (cpu_is_pxa27x() && host->data->flags & MMC_DATA_WRITE)
dma_async_issue_pending(host->dma_chan_tx);
} else {
pxamci_finish_request(host, host->mrq);
}
return 1;
}
static int pxamci_data_done(struct pxamci_host *host, unsigned int stat)
{
struct mmc_data *data = host->data;
struct dma_chan *chan;
if (!data)
return 0;
if (data->flags & MMC_DATA_READ)
chan = host->dma_chan_rx;
else
chan = host->dma_chan_tx;
dma_unmap_sg(chan->device->dev,
data->sg, data->sg_len, host->dma_dir);
if (stat & STAT_READ_TIME_OUT)
data->error = -ETIMEDOUT;
else if (stat & (STAT_CRC_READ_ERROR|STAT_CRC_WRITE_ERROR))
data->error = -EILSEQ;
/*
* There appears to be a hardware design bug here. There seems to
* be no way to find out how much data was transferred to the card.
* This means that if there was an error on any block, we mark all
* data blocks as being in error.
*/
if (!data->error)
data->bytes_xfered = data->blocks * data->blksz;
else
data->bytes_xfered = 0;
pxamci_disable_irq(host, DATA_TRAN_DONE);
host->data = NULL;
if (host->mrq->stop) {
pxamci_stop_clock(host);
pxamci_start_cmd(host, host->mrq->stop, host->cmdat);
} else {
pxamci_finish_request(host, host->mrq);
}
return 1;
}
static irqreturn_t pxamci_irq(int irq, void *devid)
{
struct pxamci_host *host = devid;
unsigned int ireg;
int handled = 0;
ireg = readl(host->base + MMC_I_REG) & ~readl(host->base + MMC_I_MASK);
if (ireg) {
unsigned stat = readl(host->base + MMC_STAT);
pr_debug("PXAMCI: irq %08x stat %08x\n", ireg, stat);
if (ireg & END_CMD_RES)
handled |= pxamci_cmd_done(host, stat);
if (ireg & DATA_TRAN_DONE)
handled |= pxamci_data_done(host, stat);
if (ireg & SDIO_INT) {
mmc_signal_sdio_irq(host->mmc);
handled = 1;
}
}
return IRQ_RETVAL(handled);
}
static void pxamci_request(struct mmc_host *mmc, struct mmc_request *mrq)
{
struct pxamci_host *host = mmc_priv(mmc);
unsigned int cmdat;
WARN_ON(host->mrq != NULL);
host->mrq = mrq;
pxamci_stop_clock(host);
cmdat = host->cmdat;
host->cmdat &= ~CMDAT_INIT;
if (mrq->data) {
pxamci_setup_data(host, mrq->data);
cmdat &= ~CMDAT_BUSY;
cmdat |= CMDAT_DATAEN | CMDAT_DMAEN;
if (mrq->data->flags & MMC_DATA_WRITE)
cmdat |= CMDAT_WRITE;
}
pxamci_start_cmd(host, mrq->cmd, cmdat);
}
static int pxamci_get_ro(struct mmc_host *mmc)
{
struct pxamci_host *host = mmc_priv(mmc);
if (host->pdata && gpio_is_valid(host->pdata->gpio_card_ro))
return mmc_gpio_get_ro(mmc);
if (host->pdata && host->pdata->get_ro)
return !!host->pdata->get_ro(mmc_dev(mmc));
/*
* Board doesn't support read only detection; let the mmc core
* decide what to do.
*/
return -ENOSYS;
}
static void pxamci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
{
struct pxamci_host *host = mmc_priv(mmc);
if (ios->clock) {
unsigned long rate = host->clkrate;
unsigned int clk = rate / ios->clock;
if (host->clkrt == CLKRT_OFF)
clk_prepare_enable(host->clk);
if (ios->clock == 26000000) {
/* to support 26MHz */
host->clkrt = 7;
} else {
/* to handle (19.5MHz, 26MHz) */
if (!clk)
clk = 1;
/*
* clk might result in a lower divisor than we
* desire. check for that condition and adjust
* as appropriate.
*/
if (rate / clk > ios->clock)
clk <<= 1;
host->clkrt = fls(clk) - 1;
}
/*
* we write clkrt on the next command
*/
} else {
pxamci_stop_clock(host);
if (host->clkrt != CLKRT_OFF) {
host->clkrt = CLKRT_OFF;
clk_disable_unprepare(host->clk);
}
}
if (host->power_mode != ios->power_mode) {
int ret;
host->power_mode = ios->power_mode;
ret = pxamci_set_power(host, ios->power_mode, ios->vdd);
if (ret) {
dev_err(mmc_dev(mmc), "unable to set power\n");
/*
* The .set_ios() function in the mmc_host_ops
* struct return void, and failing to set the
* power should be rare so we print an error and
* return here.
*/
return;
}
if (ios->power_mode == MMC_POWER_ON)
host->cmdat |= CMDAT_INIT;
}
if (ios->bus_width == MMC_BUS_WIDTH_4)
host->cmdat |= CMDAT_SD_4DAT;
else
host->cmdat &= ~CMDAT_SD_4DAT;
dev_dbg(mmc_dev(mmc), "PXAMCI: clkrt = %x cmdat = %x\n",
host->clkrt, host->cmdat);
}
static void pxamci_enable_sdio_irq(struct mmc_host *host, int enable)
{
struct pxamci_host *pxa_host = mmc_priv(host);
if (enable)
pxamci_enable_irq(pxa_host, SDIO_INT);
else
pxamci_disable_irq(pxa_host, SDIO_INT);
}
static const struct mmc_host_ops pxamci_ops = {
.request = pxamci_request,
.get_cd = mmc_gpio_get_cd,
.get_ro = pxamci_get_ro,
.set_ios = pxamci_set_ios,
.enable_sdio_irq = pxamci_enable_sdio_irq,
};
static void pxamci_dma_irq(void *param)
{
struct pxamci_host *host = param;
struct dma_tx_state state;
enum dma_status status;
struct dma_chan *chan;
unsigned long flags;
spin_lock_irqsave(&host->lock, flags);
if (!host->data)
goto out_unlock;
if (host->data->flags & MMC_DATA_READ)
chan = host->dma_chan_rx;
else
chan = host->dma_chan_tx;
status = dmaengine_tx_status(chan, host->dma_cookie, &state);
if (likely(status == DMA_COMPLETE)) {
writel(BUF_PART_FULL, host->base + MMC_PRTBUF);
} else {
pr_err("%s: DMA error on %s channel\n", mmc_hostname(host->mmc),
host->data->flags & MMC_DATA_READ ? "rx" : "tx");
host->data->error = -EIO;
pxamci_data_done(host, 0);
}
out_unlock:
spin_unlock_irqrestore(&host->lock, flags);
}
static irqreturn_t pxamci_detect_irq(int irq, void *devid)
{
struct pxamci_host *host = mmc_priv(devid);
mmc_detect_change(devid, msecs_to_jiffies(host->detect_delay_ms));
return IRQ_HANDLED;
}
#ifdef CONFIG_OF
static const struct of_device_id pxa_mmc_dt_ids[] = {
{ .compatible = "marvell,pxa-mmc" },
{ }
};
MODULE_DEVICE_TABLE(of, pxa_mmc_dt_ids);
static int pxamci_of_init(struct platform_device *pdev,
struct mmc_host *mmc)
{
struct device_node *np = pdev->dev.of_node;
struct pxamci_host *host = mmc_priv(mmc);
u32 tmp;
int ret;
if (!np)
return 0;
/* pxa-mmc specific */
if (of_property_read_u32(np, "pxa-mmc,detect-delay-ms", &tmp) == 0)
host->detect_delay_ms = tmp;
ret = mmc_of_parse(mmc);
if (ret < 0)
return ret;
return 0;
}
#else
static int pxamci_of_init(struct platform_device *pdev,
struct mmc_host *mmc)
{
return 0;
}
#endif
static int pxamci_probe(struct platform_device *pdev)
{
struct mmc_host *mmc;
struct pxamci_host *host = NULL;
struct device *dev = &pdev->dev;
struct resource *r;
int ret, irq;
r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
irq = platform_get_irq(pdev, 0);
if (irq < 0)
return irq;
mmc = mmc_alloc_host(sizeof(struct pxamci_host), dev);
if (!mmc) {
ret = -ENOMEM;
goto out;
}
mmc->ops = &pxamci_ops;
/*
* We can do SG-DMA, but we don't because we never know how much
* data we successfully wrote to the card.
*/
mmc->max_segs = NR_SG;
/*
* Our hardware DMA can handle a maximum of one page per SG entry.
*/
mmc->max_seg_size = PAGE_SIZE;
/*
* Block length register is only 10 bits before PXA27x.
*/
mmc->max_blk_size = cpu_is_pxa25x() ? 1023 : 2048;
/*
* Block count register is 16 bits.
*/
mmc->max_blk_count = 65535;
ret = pxamci_of_init(pdev, mmc);
if (ret)
return ret;
host = mmc_priv(mmc);
host->mmc = mmc;
host->pdata = pdev->dev.platform_data;
host->clkrt = CLKRT_OFF;
host->clk = devm_clk_get(dev, NULL);
if (IS_ERR(host->clk)) {
ret = PTR_ERR(host->clk);
host->clk = NULL;
goto out;
}
host->clkrate = clk_get_rate(host->clk);
/*
* Calculate minimum clock rate, rounding up.
*/
mmc->f_min = (host->clkrate + 63) / 64;
mmc->f_max = (mmc_has_26MHz()) ? 26000000 : host->clkrate;
ret = pxamci_init_ocr(host);
if (ret < 0)
return ret;
mmc->caps = 0;
host->cmdat = 0;
if (!cpu_is_pxa25x()) {
mmc->caps |= MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ;
host->cmdat |= CMDAT_SDIO_INT_EN;
if (mmc_has_26MHz())
mmc->caps |= MMC_CAP_MMC_HIGHSPEED |
MMC_CAP_SD_HIGHSPEED;
}
spin_lock_init(&host->lock);
host->res = r;
host->imask = MMC_I_MASK_ALL;
host->base = devm_ioremap_resource(dev, r);
if (IS_ERR(host->base)) {
ret = PTR_ERR(host->base);
goto out;
}
/*
* Ensure that the host controller is shut down, and setup
* with our defaults.
*/
pxamci_stop_clock(host);
writel(0, host->base + MMC_SPI);
writel(64, host->base + MMC_RESTO);
writel(host->imask, host->base + MMC_I_MASK);
ret = devm_request_irq(dev, irq, pxamci_irq, 0,
DRIVER_NAME, host);
if (ret)
goto out;
platform_set_drvdata(pdev, mmc);
host->dma_chan_rx = dma_request_slave_channel(dev, "rx");
if (host->dma_chan_rx == NULL) {
dev_err(dev, "unable to request rx dma channel\n");
ret = -ENODEV;
goto out;
}
host->dma_chan_tx = dma_request_slave_channel(dev, "tx");
if (host->dma_chan_tx == NULL) {
dev_err(dev, "unable to request tx dma channel\n");
ret = -ENODEV;
goto out;
}
if (host->pdata) {
int gpio_cd = host->pdata->gpio_card_detect;
int gpio_ro = host->pdata->gpio_card_ro;
int gpio_power = host->pdata->gpio_power;
host->detect_delay_ms = host->pdata->detect_delay_ms;
if (gpio_is_valid(gpio_power)) {
ret = devm_gpio_request(dev, gpio_power,
"mmc card power");
if (ret) {
dev_err(dev,
"Failed requesting gpio_power %d\n",
gpio_power);
goto out;
}
gpio_direction_output(gpio_power,
host->pdata->gpio_power_invert);
}
if (gpio_is_valid(gpio_ro)) {
ret = mmc_gpio_request_ro(mmc, gpio_ro);
if (ret) {
dev_err(dev,
"Failed requesting gpio_ro %d\n",
gpio_ro);
goto out;
} else {
mmc->caps2 |= host->pdata->gpio_card_ro_invert ?
0 : MMC_CAP2_RO_ACTIVE_HIGH;
}
}
if (gpio_is_valid(gpio_cd))
ret = mmc_gpio_request_cd(mmc, gpio_cd, 0);
if (ret) {
dev_err(dev, "Failed requesting gpio_cd %d\n",
gpio_cd);
goto out;
}
if (host->pdata->init)
host->pdata->init(dev, pxamci_detect_irq, mmc);
if (gpio_is_valid(gpio_power) && host->pdata->setpower)
dev_warn(dev, "gpio_power and setpower() both defined\n");
if (gpio_is_valid(gpio_ro) && host->pdata->get_ro)
dev_warn(dev, "gpio_ro and get_ro() both defined\n");
}
mmc_add_host(mmc);
return 0;
out:
if (host) {
if (host->dma_chan_rx)
dma_release_channel(host->dma_chan_rx);
if (host->dma_chan_tx)
dma_release_channel(host->dma_chan_tx);
}
if (mmc)
mmc_free_host(mmc);
return ret;
}
static int pxamci_remove(struct platform_device *pdev)
{
struct mmc_host *mmc = platform_get_drvdata(pdev);
if (mmc) {
struct pxamci_host *host = mmc_priv(mmc);
mmc_remove_host(mmc);
if (host->pdata && host->pdata->exit)
host->pdata->exit(&pdev->dev, mmc);
pxamci_stop_clock(host);
writel(TXFIFO_WR_REQ|RXFIFO_RD_REQ|CLK_IS_OFF|STOP_CMD|
END_CMD_RES|PRG_DONE|DATA_TRAN_DONE,
host->base + MMC_I_MASK);
dmaengine_terminate_all(host->dma_chan_rx);
dmaengine_terminate_all(host->dma_chan_tx);
dma_release_channel(host->dma_chan_rx);
dma_release_channel(host->dma_chan_tx);
mmc_free_host(mmc);
}
return 0;
}
static struct platform_driver pxamci_driver = {
.probe = pxamci_probe,
.remove = pxamci_remove,
.driver = {
.name = DRIVER_NAME,
.of_match_table = of_match_ptr(pxa_mmc_dt_ids),
},
};
module_platform_driver(pxamci_driver);
MODULE_DESCRIPTION("PXA Multimedia Card Interface Driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:pxa2xx-mci");
+91
View File
@@ -0,0 +1,91 @@
/* SPDX-License-Identifier: GPL-2.0 */
#define MMC_STRPCL 0x0000
#define STOP_CLOCK (1 << 0)
#define START_CLOCK (2 << 0)
#define MMC_STAT 0x0004
#define STAT_END_CMD_RES (1 << 13)
#define STAT_PRG_DONE (1 << 12)
#define STAT_DATA_TRAN_DONE (1 << 11)
#define STAT_CLK_EN (1 << 8)
#define STAT_RECV_FIFO_FULL (1 << 7)
#define STAT_XMIT_FIFO_EMPTY (1 << 6)
#define STAT_RES_CRC_ERR (1 << 5)
#define STAT_SPI_READ_ERROR_TOKEN (1 << 4)
#define STAT_CRC_READ_ERROR (1 << 3)
#define STAT_CRC_WRITE_ERROR (1 << 2)
#define STAT_TIME_OUT_RESPONSE (1 << 1)
#define STAT_READ_TIME_OUT (1 << 0)
#define MMC_CLKRT 0x0008 /* 3 bit */
#define MMC_SPI 0x000c
#define SPI_CS_ADDRESS (1 << 3)
#define SPI_CS_EN (1 << 2)
#define CRC_ON (1 << 1)
#define SPI_EN (1 << 0)
#define MMC_CMDAT 0x0010
#define CMDAT_SDIO_INT_EN (1 << 11)
#define CMDAT_SD_4DAT (1 << 8)
#define CMDAT_DMAEN (1 << 7)
#define CMDAT_INIT (1 << 6)
#define CMDAT_BUSY (1 << 5)
#define CMDAT_STREAM (1 << 4) /* 1 = stream */
#define CMDAT_WRITE (1 << 3) /* 1 = write */
#define CMDAT_DATAEN (1 << 2)
#define CMDAT_RESP_NONE (0 << 0)
#define CMDAT_RESP_SHORT (1 << 0)
#define CMDAT_RESP_R2 (2 << 0)
#define CMDAT_RESP_R3 (3 << 0)
#define MMC_RESTO 0x0014 /* 7 bit */
#define MMC_RDTO 0x0018 /* 16 bit */
#define MMC_BLKLEN 0x001c /* 10 bit */
#define MMC_NOB 0x0020 /* 16 bit */
#define MMC_PRTBUF 0x0024
#define BUF_PART_FULL (1 << 0)
#define MMC_I_MASK 0x0028
/*PXA27x MMC interrupts*/
#define SDIO_SUSPEND_ACK (1 << 12)
#define SDIO_INT (1 << 11)
#define RD_STALLED (1 << 10)
#define RES_ERR (1 << 9)
#define DAT_ERR (1 << 8)
#define TINT (1 << 7)
/*PXA2xx MMC interrupts*/
#define TXFIFO_WR_REQ (1 << 6)
#define RXFIFO_RD_REQ (1 << 5)
#define CLK_IS_OFF (1 << 4)
#define STOP_CMD (1 << 3)
#define END_CMD_RES (1 << 2)
#define PRG_DONE (1 << 1)
#define DATA_TRAN_DONE (1 << 0)
#if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx)
#define MMC_I_MASK_ALL 0x00001fff
#else
#define MMC_I_MASK_ALL 0x0000007f
#endif
#define MMC_I_REG 0x002c
/* same as MMC_I_MASK */
#define MMC_CMD 0x0030
#define MMC_ARGH 0x0034 /* 16 bit */
#define MMC_ARGL 0x0038 /* 16 bit */
#define MMC_RES 0x003c /* 16 bit */
#define MMC_RXFIFO 0x0040 /* 8 bit */
#define MMC_TXFIFO 0x0044 /* 8 bit */
+63
View File
@@ -0,0 +1,63 @@
/*
* Renesas Mobile SDHI
*
* Copyright (C) 2017 Horms Solutions Ltd., Simon Horman
* Copyright (C) 2017 Renesas Electronics Corporation
*
* 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.
*/
#ifndef RENESAS_SDHI_H
#define RENESAS_SDHI_H
#include <linux/platform_device.h>
#include "tmio_mmc.h"
struct renesas_sdhi_scc {
unsigned long clk_rate; /* clock rate for SDR104 */
u32 tap; /* sampling clock position for SDR104 */
};
struct renesas_sdhi_of_data {
unsigned long tmio_flags;
u32 tmio_ocr_mask;
unsigned long capabilities;
unsigned long capabilities2;
enum dma_slave_buswidth dma_buswidth;
dma_addr_t dma_rx_offset;
unsigned int bus_shift;
int scc_offset;
struct renesas_sdhi_scc *taps;
int taps_num;
unsigned int max_blk_count;
unsigned short max_segs;
};
struct tmio_mmc_dma {
enum dma_slave_buswidth dma_buswidth;
bool (*filter)(struct dma_chan *chan, void *arg);
void (*enable)(struct tmio_mmc_host *host, bool enable);
struct completion dma_dataend;
struct tasklet_struct dma_complete;
};
struct renesas_sdhi {
struct clk *clk;
struct clk *clk_cd;
struct tmio_mmc_data mmc_data;
struct tmio_mmc_dma dma_priv;
struct pinctrl *pinctrl;
struct pinctrl_state *pins_default, *pins_uhs;
void __iomem *scc_ctl;
u32 scc_tappos;
};
#define host_to_priv(host) \
container_of((host)->pdata, struct renesas_sdhi, mmc_data)
int renesas_sdhi_probe(struct platform_device *pdev,
const struct tmio_mmc_dma_ops *dma_ops);
int renesas_sdhi_remove(struct platform_device *pdev);
#endif
+773
View File
@@ -0,0 +1,773 @@
/*
* Renesas SDHI
*
* Copyright (C) 2015-17 Renesas Electronics Corporation
* Copyright (C) 2016-17 Sang Engineering, Wolfram Sang
* Copyright (C) 2016-17 Horms Solutions, Simon Horman
* Copyright (C) 2009 Magnus Damm
*
* 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 "Compaq ASIC3 support":
*
* Copyright 2001 Compaq Computer Corporation.
* Copyright 2004-2005 Phil Blundell
* Copyright 2007-2008 OpenedHand Ltd.
*
* Authors: Phil Blundell <pb@handhelds.org>,
* Samuel Ortiz <sameo@openedhand.com>
*
*/
#include <linux/kernel.h>
#include <linux/clk.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/platform_device.h>
#include <linux/mmc/host.h>
#include <linux/mmc/slot-gpio.h>
#include <linux/mfd/tmio.h>
#include <linux/sh_dma.h>
#include <linux/delay.h>
#include <linux/pinctrl/consumer.h>
#include <linux/pinctrl/pinctrl-state.h>
#include <linux/regulator/consumer.h>
#include "renesas_sdhi.h"
#include "tmio_mmc.h"
#define HOST_MODE 0xe4
#define SDHI_VER_GEN2_SDR50 0x490c
#define SDHI_VER_RZ_A1 0x820b
/* very old datasheets said 0x490c for SDR104, too. They are wrong! */
#define SDHI_VER_GEN2_SDR104 0xcb0d
#define SDHI_VER_GEN3_SD 0xcc10
#define SDHI_VER_GEN3_SDMMC 0xcd10
static void renesas_sdhi_sdbuf_width(struct tmio_mmc_host *host, int width)
{
u32 val;
/*
* see also
* renesas_sdhi_of_data :: dma_buswidth
*/
switch (sd_ctrl_read16(host, CTL_VERSION)) {
case SDHI_VER_GEN2_SDR50:
val = (width == 32) ? 0x0001 : 0x0000;
break;
case SDHI_VER_GEN2_SDR104:
val = (width == 32) ? 0x0000 : 0x0001;
break;
case SDHI_VER_GEN3_SD:
case SDHI_VER_GEN3_SDMMC:
if (width == 64)
val = 0x0000;
else if (width == 32)
val = 0x0101;
else
val = 0x0001;
break;
default:
/* nothing to do */
return;
}
sd_ctrl_write16(host, HOST_MODE, val);
}
static int renesas_sdhi_clk_enable(struct tmio_mmc_host *host)
{
struct mmc_host *mmc = host->mmc;
struct renesas_sdhi *priv = host_to_priv(host);
int ret = clk_prepare_enable(priv->clk);
if (ret < 0)
return ret;
ret = clk_prepare_enable(priv->clk_cd);
if (ret < 0) {
clk_disable_unprepare(priv->clk);
return ret;
}
/*
* The clock driver may not know what maximum frequency
* actually works, so it should be set with the max-frequency
* property which will already have been read to f_max. If it
* was missing, assume the current frequency is the maximum.
*/
if (!mmc->f_max)
mmc->f_max = clk_get_rate(priv->clk);
/*
* Minimum frequency is the minimum input clock frequency
* divided by our maximum divider.
*/
mmc->f_min = max(clk_round_rate(priv->clk, 1) / 512, 1L);
/* enable 16bit data access on SDBUF as default */
renesas_sdhi_sdbuf_width(host, 16);
return 0;
}
static unsigned int renesas_sdhi_clk_update(struct tmio_mmc_host *host,
unsigned int new_clock)
{
struct renesas_sdhi *priv = host_to_priv(host);
unsigned int freq, diff, best_freq = 0, diff_min = ~0;
int i, ret;
/* tested only on R-Car Gen2+ currently; may work for others */
if (!(host->pdata->flags & TMIO_MMC_MIN_RCAR2))
return clk_get_rate(priv->clk);
/*
* We want the bus clock to be as close as possible to, but no
* greater than, new_clock. As we can divide by 1 << i for
* any i in [0, 9] we want the input clock to be as close as
* possible, but no greater than, new_clock << i.
*/
for (i = min(9, ilog2(UINT_MAX / new_clock)); i >= 0; i--) {
freq = clk_round_rate(priv->clk, new_clock << i);
if (freq > (new_clock << i)) {
/* Too fast; look for a slightly slower option */
freq = clk_round_rate(priv->clk,
(new_clock << i) / 4 * 3);
if (freq > (new_clock << i))
continue;
}
diff = new_clock - (freq >> i);
if (diff <= diff_min) {
best_freq = freq;
diff_min = diff;
}
}
ret = clk_set_rate(priv->clk, best_freq);
return ret == 0 ? best_freq : clk_get_rate(priv->clk);
}
static void renesas_sdhi_clk_disable(struct tmio_mmc_host *host)
{
struct renesas_sdhi *priv = host_to_priv(host);
clk_disable_unprepare(priv->clk);
clk_disable_unprepare(priv->clk_cd);
}
static int renesas_sdhi_card_busy(struct mmc_host *mmc)
{
struct tmio_mmc_host *host = mmc_priv(mmc);
return !(sd_ctrl_read16_and_16_as_32(host, CTL_STATUS) &
TMIO_STAT_DAT0);
}
static int renesas_sdhi_start_signal_voltage_switch(struct mmc_host *mmc,
struct mmc_ios *ios)
{
struct tmio_mmc_host *host = mmc_priv(mmc);
struct renesas_sdhi *priv = host_to_priv(host);
struct pinctrl_state *pin_state;
int ret;
switch (ios->signal_voltage) {
case MMC_SIGNAL_VOLTAGE_330:
pin_state = priv->pins_default;
break;
case MMC_SIGNAL_VOLTAGE_180:
pin_state = priv->pins_uhs;
break;
default:
return -EINVAL;
}
/*
* If anything is missing, assume signal voltage is fixed at
* 3.3V and succeed/fail accordingly.
*/
if (IS_ERR(priv->pinctrl) || IS_ERR(pin_state))
return ios->signal_voltage ==
MMC_SIGNAL_VOLTAGE_330 ? 0 : -EINVAL;
ret = mmc_regulator_set_vqmmc(host->mmc, ios);
if (ret)
return ret;
return pinctrl_select_state(priv->pinctrl, pin_state);
}
/* SCC registers */
#define SH_MOBILE_SDHI_SCC_DTCNTL 0x000
#define SH_MOBILE_SDHI_SCC_TAPSET 0x002
#define SH_MOBILE_SDHI_SCC_DT2FF 0x004
#define SH_MOBILE_SDHI_SCC_CKSEL 0x006
#define SH_MOBILE_SDHI_SCC_RVSCNTL 0x008
#define SH_MOBILE_SDHI_SCC_RVSREQ 0x00A
#define SH_MOBILE_SDHI_SCC_TMPPORT2 0x00E
/* Definitions for values the SH_MOBILE_SDHI_SCC_DTCNTL register */
#define SH_MOBILE_SDHI_SCC_DTCNTL_TAPEN BIT(0)
#define SH_MOBILE_SDHI_SCC_DTCNTL_TAPNUM_SHIFT 16
#define SH_MOBILE_SDHI_SCC_DTCNTL_TAPNUM_MASK 0xff
/* Definitions for values the SH_MOBILE_SDHI_SCC_CKSEL register */
#define SH_MOBILE_SDHI_SCC_CKSEL_DTSEL BIT(0)
/* Definitions for values the SH_MOBILE_SDHI_SCC_RVSCNTL register */
#define SH_MOBILE_SDHI_SCC_RVSCNTL_RVSEN BIT(0)
/* Definitions for values the SH_MOBILE_SDHI_SCC_RVSREQ register */
#define SH_MOBILE_SDHI_SCC_RVSREQ_RVSERR BIT(2)
/* Definitions for values the SH_MOBILE_SDHI_SCC_TMPPORT2 register */
#define SH_MOBILE_SDHI_SCC_TMPPORT2_HS400OSEL BIT(4)
#define SH_MOBILE_SDHI_SCC_TMPPORT2_HS400EN BIT(31)
static inline u32 sd_scc_read32(struct tmio_mmc_host *host,
struct renesas_sdhi *priv, int addr)
{
return readl(priv->scc_ctl + (addr << host->bus_shift));
}
static inline void sd_scc_write32(struct tmio_mmc_host *host,
struct renesas_sdhi *priv,
int addr, u32 val)
{
writel(val, priv->scc_ctl + (addr << host->bus_shift));
}
static unsigned int renesas_sdhi_init_tuning(struct tmio_mmc_host *host)
{
struct renesas_sdhi *priv;
priv = host_to_priv(host);
/* Initialize SCC */
sd_ctrl_write32_as_16_and_16(host, CTL_STATUS, 0x0);
sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, ~CLK_CTL_SCLKEN &
sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
/* set sampling clock selection range */
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_DTCNTL,
SH_MOBILE_SDHI_SCC_DTCNTL_TAPEN |
0x8 << SH_MOBILE_SDHI_SCC_DTCNTL_TAPNUM_SHIFT);
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_CKSEL,
SH_MOBILE_SDHI_SCC_CKSEL_DTSEL |
sd_scc_read32(host, priv, SH_MOBILE_SDHI_SCC_CKSEL));
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_RVSCNTL,
~SH_MOBILE_SDHI_SCC_RVSCNTL_RVSEN &
sd_scc_read32(host, priv, SH_MOBILE_SDHI_SCC_RVSCNTL));
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_DT2FF, priv->scc_tappos);
sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, CLK_CTL_SCLKEN |
sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
/* Read TAPNUM */
return (sd_scc_read32(host, priv, SH_MOBILE_SDHI_SCC_DTCNTL) >>
SH_MOBILE_SDHI_SCC_DTCNTL_TAPNUM_SHIFT) &
SH_MOBILE_SDHI_SCC_DTCNTL_TAPNUM_MASK;
}
static void renesas_sdhi_prepare_tuning(struct tmio_mmc_host *host,
unsigned long tap)
{
struct renesas_sdhi *priv = host_to_priv(host);
/* Set sampling clock position */
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_TAPSET, tap);
}
static void renesas_sdhi_hs400_complete(struct tmio_mmc_host *host)
{
struct renesas_sdhi *priv = host_to_priv(host);
sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, ~CLK_CTL_SCLKEN &
sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
/* Set HS400 mode */
sd_ctrl_write16(host, CTL_SDIF_MODE, 0x0001 |
sd_ctrl_read16(host, CTL_SDIF_MODE));
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_TMPPORT2,
(SH_MOBILE_SDHI_SCC_TMPPORT2_HS400EN |
SH_MOBILE_SDHI_SCC_TMPPORT2_HS400OSEL) |
sd_scc_read32(host, priv, SH_MOBILE_SDHI_SCC_TMPPORT2));
/* Set the sampling clock selection range of HS400 mode */
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_DTCNTL,
SH_MOBILE_SDHI_SCC_DTCNTL_TAPEN |
0x4 << SH_MOBILE_SDHI_SCC_DTCNTL_TAPNUM_SHIFT);
if (host->pdata->flags & TMIO_MMC_HAVE_4TAP_HS400)
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_TAPSET,
host->tap_set / 2);
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_CKSEL,
SH_MOBILE_SDHI_SCC_CKSEL_DTSEL |
sd_scc_read32(host, priv, SH_MOBILE_SDHI_SCC_CKSEL));
sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, CLK_CTL_SCLKEN |
sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
}
static void renesas_sdhi_reset_scc(struct tmio_mmc_host *host,
struct renesas_sdhi *priv)
{
sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, ~CLK_CTL_SCLKEN &
sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_CKSEL,
~SH_MOBILE_SDHI_SCC_CKSEL_DTSEL &
sd_scc_read32(host, priv,
SH_MOBILE_SDHI_SCC_CKSEL));
}
static void renesas_sdhi_disable_scc(struct tmio_mmc_host *host)
{
struct renesas_sdhi *priv = host_to_priv(host);
renesas_sdhi_reset_scc(host, priv);
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_DTCNTL,
~SH_MOBILE_SDHI_SCC_DTCNTL_TAPEN &
sd_scc_read32(host, priv,
SH_MOBILE_SDHI_SCC_DTCNTL));
sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, CLK_CTL_SCLKEN |
sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
}
static void renesas_sdhi_reset_hs400_mode(struct tmio_mmc_host *host,
struct renesas_sdhi *priv)
{
sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, ~CLK_CTL_SCLKEN &
sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
/* Reset HS400 mode */
sd_ctrl_write16(host, CTL_SDIF_MODE, ~0x0001 &
sd_ctrl_read16(host, CTL_SDIF_MODE));
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_TMPPORT2,
~(SH_MOBILE_SDHI_SCC_TMPPORT2_HS400EN |
SH_MOBILE_SDHI_SCC_TMPPORT2_HS400OSEL) &
sd_scc_read32(host, priv, SH_MOBILE_SDHI_SCC_TMPPORT2));
sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, CLK_CTL_SCLKEN |
sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
}
static void renesas_sdhi_prepare_hs400_tuning(struct tmio_mmc_host *host)
{
renesas_sdhi_reset_hs400_mode(host, host_to_priv(host));
}
#define SH_MOBILE_SDHI_MAX_TAP 3
static int renesas_sdhi_select_tuning(struct tmio_mmc_host *host)
{
struct renesas_sdhi *priv = host_to_priv(host);
unsigned long tap_cnt; /* counter of tuning success */
unsigned long tap_start;/* start position of tuning success */
unsigned long tap_end; /* end position of tuning success */
unsigned long ntap; /* temporary counter of tuning success */
unsigned long i;
/* Clear SCC_RVSREQ */
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_RVSREQ, 0);
/*
* When tuning CMD19 is issued twice for each tap, merge the
* result requiring the tap to be good in both runs before
* considering it for tuning selection.
*/
for (i = 0; i < host->tap_num * 2; i++) {
int offset = host->tap_num * (i < host->tap_num ? 1 : -1);
if (!test_bit(i, host->taps))
clear_bit(i + offset, host->taps);
}
/*
* Find the longest consecutive run of successful probes. If that
* is more than SH_MOBILE_SDHI_MAX_TAP probes long then use the
* center index as the tap.
*/
tap_cnt = 0;
ntap = 0;
tap_start = 0;
tap_end = 0;
for (i = 0; i < host->tap_num * 2; i++) {
if (test_bit(i, host->taps)) {
ntap++;
} else {
if (ntap > tap_cnt) {
tap_start = i - ntap;
tap_end = i - 1;
tap_cnt = ntap;
}
ntap = 0;
}
}
if (ntap > tap_cnt) {
tap_start = i - ntap;
tap_end = i - 1;
tap_cnt = ntap;
}
if (tap_cnt >= SH_MOBILE_SDHI_MAX_TAP)
host->tap_set = (tap_start + tap_end) / 2 % host->tap_num;
else
return -EIO;
/* Set SCC */
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_TAPSET, host->tap_set);
/* Enable auto re-tuning */
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_RVSCNTL,
SH_MOBILE_SDHI_SCC_RVSCNTL_RVSEN |
sd_scc_read32(host, priv, SH_MOBILE_SDHI_SCC_RVSCNTL));
return 0;
}
static bool renesas_sdhi_check_scc_error(struct tmio_mmc_host *host)
{
struct renesas_sdhi *priv = host_to_priv(host);
/* Check SCC error */
if (sd_scc_read32(host, priv, SH_MOBILE_SDHI_SCC_RVSCNTL) &
SH_MOBILE_SDHI_SCC_RVSCNTL_RVSEN &&
sd_scc_read32(host, priv, SH_MOBILE_SDHI_SCC_RVSREQ) &
SH_MOBILE_SDHI_SCC_RVSREQ_RVSERR) {
/* Clear SCC error */
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_RVSREQ, 0);
return true;
}
return false;
}
static void renesas_sdhi_hw_reset(struct tmio_mmc_host *host)
{
struct renesas_sdhi *priv;
priv = host_to_priv(host);
renesas_sdhi_reset_scc(host, priv);
renesas_sdhi_reset_hs400_mode(host, priv);
sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, CLK_CTL_SCLKEN |
sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_RVSCNTL,
~SH_MOBILE_SDHI_SCC_RVSCNTL_RVSEN &
sd_scc_read32(host, priv, SH_MOBILE_SDHI_SCC_RVSCNTL));
sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_RVSCNTL,
~SH_MOBILE_SDHI_SCC_RVSCNTL_RVSEN &
sd_scc_read32(host, priv, SH_MOBILE_SDHI_SCC_RVSCNTL));
}
static int renesas_sdhi_wait_idle(struct tmio_mmc_host *host, u32 bit)
{
int timeout = 1000;
/* CBSY is set when busy, SCLKDIVEN is cleared when busy */
u32 wait_state = (bit == TMIO_STAT_CMD_BUSY ? TMIO_STAT_CMD_BUSY : 0);
while (--timeout && (sd_ctrl_read16_and_16_as_32(host, CTL_STATUS)
& bit) == wait_state)
udelay(1);
if (!timeout) {
dev_warn(&host->pdev->dev, "timeout waiting for SD bus idle\n");
return -EBUSY;
}
return 0;
}
static int renesas_sdhi_write16_hook(struct tmio_mmc_host *host, int addr)
{
u32 bit = TMIO_STAT_SCLKDIVEN;
switch (addr) {
case CTL_SD_CMD:
case CTL_STOP_INTERNAL_ACTION:
case CTL_XFER_BLK_COUNT:
case CTL_SD_XFER_LEN:
case CTL_SD_MEM_CARD_OPT:
case CTL_TRANSACTION_CTL:
case CTL_DMA_ENABLE:
case HOST_MODE:
if (host->pdata->flags & TMIO_MMC_HAVE_CBSY)
bit = TMIO_STAT_CMD_BUSY;
/* fallthrough */
case CTL_SD_CARD_CLK_CTL:
return renesas_sdhi_wait_idle(host, bit);
}
return 0;
}
static int renesas_sdhi_multi_io_quirk(struct mmc_card *card,
unsigned int direction, int blk_size)
{
/*
* In Renesas controllers, when performing a
* multiple block read of one or two blocks,
* depending on the timing with which the
* response register is read, the response
* value may not be read properly.
* Use single block read for this HW bug
*/
if ((direction == MMC_DATA_READ) &&
blk_size == 2)
return 1;
return blk_size;
}
static void renesas_sdhi_enable_dma(struct tmio_mmc_host *host, bool enable)
{
/* Iff regs are 8 byte apart, sdbuf is 64 bit. Otherwise always 32. */
int width = (host->bus_shift == 2) ? 64 : 32;
sd_ctrl_write16(host, CTL_DMA_ENABLE, enable ? DMA_ENABLE_DMASDRW : 0);
renesas_sdhi_sdbuf_width(host, enable ? width : 16);
}
int renesas_sdhi_probe(struct platform_device *pdev,
const struct tmio_mmc_dma_ops *dma_ops)
{
struct tmio_mmc_data *mmd = pdev->dev.platform_data;
const struct renesas_sdhi_of_data *of_data;
struct tmio_mmc_data *mmc_data;
struct tmio_mmc_dma *dma_priv;
struct tmio_mmc_host *host;
struct renesas_sdhi *priv;
struct resource *res;
int irq, ret, i;
u16 ver;
of_data = of_device_get_match_data(&pdev->dev);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res)
return -EINVAL;
priv = devm_kzalloc(&pdev->dev, sizeof(struct renesas_sdhi),
GFP_KERNEL);
if (!priv)
return -ENOMEM;
mmc_data = &priv->mmc_data;
dma_priv = &priv->dma_priv;
priv->clk = devm_clk_get(&pdev->dev, NULL);
if (IS_ERR(priv->clk)) {
ret = PTR_ERR(priv->clk);
dev_err(&pdev->dev, "cannot get clock: %d\n", ret);
return ret;
}
/*
* Some controllers provide a 2nd clock just to run the internal card
* detection logic. Unfortunately, the existing driver architecture does
* not support a separation of clocks for runtime PM usage. When
* native hotplug is used, the tmio driver assumes that the core
* must continue to run for card detect to stay active, so we cannot
* disable it.
* Additionally, it is prohibited to supply a clock to the core but not
* to the card detect circuit. That leaves us with if separate clocks
* are presented, we must treat them both as virtually 1 clock.
*/
priv->clk_cd = devm_clk_get(&pdev->dev, "cd");
if (IS_ERR(priv->clk_cd))
priv->clk_cd = NULL;
priv->pinctrl = devm_pinctrl_get(&pdev->dev);
if (!IS_ERR(priv->pinctrl)) {
priv->pins_default = pinctrl_lookup_state(priv->pinctrl,
PINCTRL_STATE_DEFAULT);
priv->pins_uhs = pinctrl_lookup_state(priv->pinctrl,
"state_uhs");
}
host = tmio_mmc_host_alloc(pdev, mmc_data);
if (IS_ERR(host))
return PTR_ERR(host);
if (of_data) {
mmc_data->flags |= of_data->tmio_flags;
mmc_data->ocr_mask = of_data->tmio_ocr_mask;
mmc_data->capabilities |= of_data->capabilities;
mmc_data->capabilities2 |= of_data->capabilities2;
mmc_data->dma_rx_offset = of_data->dma_rx_offset;
mmc_data->max_blk_count = of_data->max_blk_count;
mmc_data->max_segs = of_data->max_segs;
dma_priv->dma_buswidth = of_data->dma_buswidth;
host->bus_shift = of_data->bus_shift;
}
host->write16_hook = renesas_sdhi_write16_hook;
host->clk_enable = renesas_sdhi_clk_enable;
host->clk_update = renesas_sdhi_clk_update;
host->clk_disable = renesas_sdhi_clk_disable;
host->multi_io_quirk = renesas_sdhi_multi_io_quirk;
host->dma_ops = dma_ops;
/* For some SoC, we disable internal WP. GPIO may override this */
if (mmc_can_gpio_ro(host->mmc))
mmc_data->capabilities2 &= ~MMC_CAP2_NO_WRITE_PROTECT;
/* SDR speeds are only available on Gen2+ */
if (mmc_data->flags & TMIO_MMC_MIN_RCAR2) {
/* card_busy caused issues on r8a73a4 (pre-Gen2) CD-less SDHI */
host->ops.card_busy = renesas_sdhi_card_busy;
host->ops.start_signal_voltage_switch =
renesas_sdhi_start_signal_voltage_switch;
/* SDR and HS200/400 registers requires HW reset */
if (of_data && of_data->scc_offset) {
priv->scc_ctl = host->ctl + of_data->scc_offset;
host->mmc->caps |= MMC_CAP_HW_RESET;
host->hw_reset = renesas_sdhi_hw_reset;
}
}
/* Orginally registers were 16 bit apart, could be 32 or 64 nowadays */
if (!host->bus_shift && resource_size(res) > 0x100) /* old way to determine the shift */
host->bus_shift = 1;
if (mmd)
*mmc_data = *mmd;
dma_priv->filter = shdma_chan_filter;
dma_priv->enable = renesas_sdhi_enable_dma;
mmc_data->alignment_shift = 1; /* 2-byte alignment */
mmc_data->capabilities |= MMC_CAP_MMC_HIGHSPEED;
/*
* All SDHI blocks support 2-byte and larger block sizes in 4-bit
* bus width mode.
*/
mmc_data->flags |= TMIO_MMC_BLKSZ_2BYTES;
/*
* All SDHI blocks support SDIO IRQ signalling.
*/
mmc_data->flags |= TMIO_MMC_SDIO_IRQ;
/* All SDHI have CMD12 control bit */
mmc_data->flags |= TMIO_MMC_HAVE_CMD12_CTRL;
/* All SDHI have SDIO status bits which must be 1 */
mmc_data->flags |= TMIO_MMC_SDIO_STATUS_SETBITS;
ret = renesas_sdhi_clk_enable(host);
if (ret)
goto efree;
ver = sd_ctrl_read16(host, CTL_VERSION);
/* GEN2_SDR104 is first known SDHI to use 32bit block count */
if (ver < SDHI_VER_GEN2_SDR104 && mmc_data->max_blk_count > U16_MAX)
mmc_data->max_blk_count = U16_MAX;
ret = tmio_mmc_host_probe(host);
if (ret < 0)
goto edisclk;
/* One Gen2 SDHI incarnation does NOT have a CBSY bit */
if (ver == SDHI_VER_GEN2_SDR50)
mmc_data->flags &= ~TMIO_MMC_HAVE_CBSY;
/* Enable tuning iff we have an SCC and a supported mode */
if (of_data && of_data->scc_offset &&
(host->mmc->caps & MMC_CAP_UHS_SDR104 ||
host->mmc->caps2 & (MMC_CAP2_HS200_1_8V_SDR |
MMC_CAP2_HS400_1_8V))) {
const struct renesas_sdhi_scc *taps = of_data->taps;
bool hit = false;
for (i = 0; i < of_data->taps_num; i++) {
if (taps[i].clk_rate == 0 ||
taps[i].clk_rate == host->mmc->f_max) {
priv->scc_tappos = taps->tap;
hit = true;
break;
}
}
if (!hit)
dev_warn(&host->pdev->dev, "Unknown clock rate for SDR104\n");
host->init_tuning = renesas_sdhi_init_tuning;
host->prepare_tuning = renesas_sdhi_prepare_tuning;
host->select_tuning = renesas_sdhi_select_tuning;
host->check_scc_error = renesas_sdhi_check_scc_error;
host->prepare_hs400_tuning =
renesas_sdhi_prepare_hs400_tuning;
host->hs400_downgrade = renesas_sdhi_disable_scc;
host->hs400_complete = renesas_sdhi_hs400_complete;
}
i = 0;
while (1) {
irq = platform_get_irq(pdev, i);
if (irq < 0)
break;
i++;
ret = devm_request_irq(&pdev->dev, irq, tmio_mmc_irq, 0,
dev_name(&pdev->dev), host);
if (ret)
goto eirq;
}
/* There must be at least one IRQ source */
if (!i) {
ret = irq;
goto eirq;
}
dev_info(&pdev->dev, "%s base at 0x%08lx max clock rate %u MHz\n",
mmc_hostname(host->mmc), (unsigned long)
(platform_get_resource(pdev, IORESOURCE_MEM, 0)->start),
host->mmc->f_max / 1000000);
return ret;
eirq:
tmio_mmc_host_remove(host);
edisclk:
renesas_sdhi_clk_disable(host);
efree:
tmio_mmc_host_free(host);
return ret;
}
EXPORT_SYMBOL_GPL(renesas_sdhi_probe);
int renesas_sdhi_remove(struct platform_device *pdev)
{
struct tmio_mmc_host *host = platform_get_drvdata(pdev);
tmio_mmc_host_remove(host);
renesas_sdhi_clk_disable(host);
tmio_mmc_host_free(host);
return 0;
}
EXPORT_SYMBOL_GPL(renesas_sdhi_remove);
MODULE_LICENSE("GPL v2");
@@ -0,0 +1,360 @@
/*
* DMA support for Internal DMAC with SDHI SD/SDIO controller
*
* Copyright (C) 2016-17 Renesas Electronics Corporation
* Copyright (C) 2016-17 Horms Solutions, Simon Horman
*
* 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/bitops.h>
#include <linux/device.h>
#include <linux/dma-mapping.h>
#include <linux/io-64-nonatomic-hi-lo.h>
#include <linux/mfd/tmio.h>
#include <linux/mmc/host.h>
#include <linux/mod_devicetable.h>
#include <linux/module.h>
#include <linux/pagemap.h>
#include <linux/scatterlist.h>
#include <linux/sys_soc.h>
#include "renesas_sdhi.h"
#include "tmio_mmc.h"
#define DM_CM_DTRAN_MODE 0x820
#define DM_CM_DTRAN_CTRL 0x828
#define DM_CM_RST 0x830
#define DM_CM_INFO1 0x840
#define DM_CM_INFO1_MASK 0x848
#define DM_CM_INFO2 0x850
#define DM_CM_INFO2_MASK 0x858
#define DM_DTRAN_ADDR 0x880
/* DM_CM_DTRAN_MODE */
#define DTRAN_MODE_CH_NUM_CH0 0 /* "downstream" = for write commands */
#define DTRAN_MODE_CH_NUM_CH1 BIT(16) /* "uptream" = for read commands */
#define DTRAN_MODE_BUS_WID_TH (BIT(5) | BIT(4))
#define DTRAN_MODE_ADDR_MODE BIT(0) /* 1 = Increment address */
/* DM_CM_DTRAN_CTRL */
#define DTRAN_CTRL_DM_START BIT(0)
/* DM_CM_RST */
#define RST_DTRANRST1 BIT(9)
#define RST_DTRANRST0 BIT(8)
#define RST_RESERVED_BITS GENMASK_ULL(31, 0)
/* DM_CM_INFO1 and DM_CM_INFO1_MASK */
#define INFO1_CLEAR 0
#define INFO1_MASK_CLEAR GENMASK_ULL(31, 0)
#define INFO1_DTRANEND1 BIT(17)
#define INFO1_DTRANEND0 BIT(16)
/* DM_CM_INFO2 and DM_CM_INFO2_MASK */
#define INFO2_MASK_CLEAR GENMASK_ULL(31, 0)
#define INFO2_DTRANERR1 BIT(17)
#define INFO2_DTRANERR0 BIT(16)
/*
* Specification of this driver:
* - host->chan_{rx,tx} will be used as a flag of enabling/disabling the dma
* - Since this SDHI DMAC register set has 16 but 32-bit width, we
* need a custom accessor.
*/
static unsigned long global_flags;
/*
* Workaround for avoiding to use RX DMAC by multiple channels.
* On R-Car H3 ES1.* and M3-W ES1.0, when multiple SDHI channels use
* RX DMAC simultaneously, sometimes hundreds of bytes data are not
* stored into the system memory even if the DMAC interrupt happened.
* So, this driver then uses one RX DMAC channel only.
*/
#define SDHI_INTERNAL_DMAC_ONE_RX_ONLY 0
#define SDHI_INTERNAL_DMAC_RX_IN_USE 1
/* Definitions for sampling clocks */
static struct renesas_sdhi_scc rcar_gen3_scc_taps[] = {
{
.clk_rate = 0,
.tap = 0x00000300,
},
};
static const struct renesas_sdhi_of_data of_rcar_r8a7795_compatible = {
.tmio_flags = TMIO_MMC_HAS_IDLE_WAIT | TMIO_MMC_CLK_ACTUAL |
TMIO_MMC_HAVE_CBSY | TMIO_MMC_MIN_RCAR2 |
TMIO_MMC_HAVE_4TAP_HS400,
.capabilities = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ |
MMC_CAP_CMD23,
.capabilities2 = MMC_CAP2_NO_WRITE_PROTECT,
.bus_shift = 2,
.scc_offset = 0x1000,
.taps = rcar_gen3_scc_taps,
.taps_num = ARRAY_SIZE(rcar_gen3_scc_taps),
/* DMAC can handle 0xffffffff blk count but only 1 segment */
.max_blk_count = 0xffffffff,
.max_segs = 1,
};
static const struct renesas_sdhi_of_data of_rcar_gen3_compatible = {
.tmio_flags = TMIO_MMC_HAS_IDLE_WAIT | TMIO_MMC_CLK_ACTUAL |
TMIO_MMC_HAVE_CBSY | TMIO_MMC_MIN_RCAR2,
.capabilities = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ |
MMC_CAP_CMD23,
.capabilities2 = MMC_CAP2_NO_WRITE_PROTECT,
.bus_shift = 2,
.scc_offset = 0x1000,
.taps = rcar_gen3_scc_taps,
.taps_num = ARRAY_SIZE(rcar_gen3_scc_taps),
/* DMAC can handle 0xffffffff blk count but only 1 segment */
.max_blk_count = 0xffffffff,
.max_segs = 1,
};
static const struct of_device_id renesas_sdhi_internal_dmac_of_match[] = {
{ .compatible = "renesas,sdhi-r8a7795", .data = &of_rcar_r8a7795_compatible, },
{ .compatible = "renesas,sdhi-r8a7796", .data = &of_rcar_r8a7795_compatible, },
{ .compatible = "renesas,rcar-gen3-sdhi", .data = &of_rcar_gen3_compatible, },
{},
};
MODULE_DEVICE_TABLE(of, renesas_sdhi_internal_dmac_of_match);
static void
renesas_sdhi_internal_dmac_dm_write(struct tmio_mmc_host *host,
int addr, u64 val)
{
writeq(val, host->ctl + addr);
}
static void
renesas_sdhi_internal_dmac_enable_dma(struct tmio_mmc_host *host, bool enable)
{
struct renesas_sdhi *priv = host_to_priv(host);
if (!host->chan_tx || !host->chan_rx)
return;
if (!enable)
renesas_sdhi_internal_dmac_dm_write(host, DM_CM_INFO1,
INFO1_CLEAR);
if (priv->dma_priv.enable)
priv->dma_priv.enable(host, enable);
}
static void
renesas_sdhi_internal_dmac_abort_dma(struct tmio_mmc_host *host) {
u64 val = RST_DTRANRST1 | RST_DTRANRST0;
renesas_sdhi_internal_dmac_enable_dma(host, false);
renesas_sdhi_internal_dmac_dm_write(host, DM_CM_RST,
RST_RESERVED_BITS & ~val);
renesas_sdhi_internal_dmac_dm_write(host, DM_CM_RST,
RST_RESERVED_BITS | val);
clear_bit(SDHI_INTERNAL_DMAC_RX_IN_USE, &global_flags);
renesas_sdhi_internal_dmac_enable_dma(host, true);
}
static void
renesas_sdhi_internal_dmac_dataend_dma(struct tmio_mmc_host *host) {
struct renesas_sdhi *priv = host_to_priv(host);
tasklet_schedule(&priv->dma_priv.dma_complete);
}
static void
renesas_sdhi_internal_dmac_start_dma(struct tmio_mmc_host *host,
struct mmc_data *data)
{
struct scatterlist *sg = host->sg_ptr;
u32 dtran_mode = DTRAN_MODE_BUS_WID_TH | DTRAN_MODE_ADDR_MODE;
if (!dma_map_sg(&host->pdev->dev, sg, host->sg_len,
mmc_get_dma_dir(data)))
goto force_pio;
/* This DMAC cannot handle if buffer is not 128-bytes alignment */
if (!IS_ALIGNED(sg_dma_address(sg), 128))
goto force_pio_with_unmap;
if (data->flags & MMC_DATA_READ) {
dtran_mode |= DTRAN_MODE_CH_NUM_CH1;
if (test_bit(SDHI_INTERNAL_DMAC_ONE_RX_ONLY, &global_flags) &&
test_and_set_bit(SDHI_INTERNAL_DMAC_RX_IN_USE, &global_flags))
goto force_pio_with_unmap;
} else {
dtran_mode |= DTRAN_MODE_CH_NUM_CH0;
}
renesas_sdhi_internal_dmac_enable_dma(host, true);
/* set dma parameters */
renesas_sdhi_internal_dmac_dm_write(host, DM_CM_DTRAN_MODE,
dtran_mode);
renesas_sdhi_internal_dmac_dm_write(host, DM_DTRAN_ADDR,
sg_dma_address(sg));
return;
force_pio_with_unmap:
dma_unmap_sg(&host->pdev->dev, sg, host->sg_len, mmc_get_dma_dir(data));
force_pio:
host->force_pio = true;
renesas_sdhi_internal_dmac_enable_dma(host, false);
}
static void renesas_sdhi_internal_dmac_issue_tasklet_fn(unsigned long arg)
{
struct tmio_mmc_host *host = (struct tmio_mmc_host *)arg;
tmio_mmc_enable_mmc_irqs(host, TMIO_STAT_DATAEND);
/* start the DMAC */
renesas_sdhi_internal_dmac_dm_write(host, DM_CM_DTRAN_CTRL,
DTRAN_CTRL_DM_START);
}
static bool renesas_sdhi_internal_dmac_complete(struct tmio_mmc_host *host)
{
enum dma_data_direction dir;
if (!host->data)
return false;
if (host->data->flags & MMC_DATA_READ)
dir = DMA_FROM_DEVICE;
else
dir = DMA_TO_DEVICE;
renesas_sdhi_internal_dmac_enable_dma(host, false);
dma_unmap_sg(&host->pdev->dev, host->sg_ptr, host->sg_len, dir);
if (dir == DMA_FROM_DEVICE)
clear_bit(SDHI_INTERNAL_DMAC_RX_IN_USE, &global_flags);
return true;
}
static void renesas_sdhi_internal_dmac_complete_tasklet_fn(unsigned long arg)
{
struct tmio_mmc_host *host = (struct tmio_mmc_host *)arg;
spin_lock_irq(&host->lock);
if (!renesas_sdhi_internal_dmac_complete(host))
goto out;
tmio_mmc_do_data_irq(host);
out:
spin_unlock_irq(&host->lock);
}
static void
renesas_sdhi_internal_dmac_request_dma(struct tmio_mmc_host *host,
struct tmio_mmc_data *pdata)
{
struct renesas_sdhi *priv = host_to_priv(host);
/* Disable DMAC interrupts, we don't use them */
renesas_sdhi_internal_dmac_dm_write(host, DM_CM_INFO1_MASK,
INFO1_MASK_CLEAR);
renesas_sdhi_internal_dmac_dm_write(host, DM_CM_INFO2_MASK,
INFO2_MASK_CLEAR);
/* Each value is set to non-zero to assume "enabling" each DMA */
host->chan_rx = host->chan_tx = (void *)0xdeadbeaf;
tasklet_init(&priv->dma_priv.dma_complete,
renesas_sdhi_internal_dmac_complete_tasklet_fn,
(unsigned long)host);
tasklet_init(&host->dma_issue,
renesas_sdhi_internal_dmac_issue_tasklet_fn,
(unsigned long)host);
}
static void
renesas_sdhi_internal_dmac_release_dma(struct tmio_mmc_host *host)
{
/* Each value is set to zero to assume "disabling" each DMA */
host->chan_rx = host->chan_tx = NULL;
}
static const struct tmio_mmc_dma_ops renesas_sdhi_internal_dmac_dma_ops = {
.start = renesas_sdhi_internal_dmac_start_dma,
.enable = renesas_sdhi_internal_dmac_enable_dma,
.request = renesas_sdhi_internal_dmac_request_dma,
.release = renesas_sdhi_internal_dmac_release_dma,
.abort = renesas_sdhi_internal_dmac_abort_dma,
.dataend = renesas_sdhi_internal_dmac_dataend_dma,
};
/*
* Whitelist of specific R-Car Gen3 SoC ES versions to use this DMAC
* implementation as others may use a different implementation.
*/
static const struct soc_device_attribute gen3_soc_whitelist[] = {
/* specific ones */
{ .soc_id = "r8a7795", .revision = "ES1.*",
.data = (void *)BIT(SDHI_INTERNAL_DMAC_ONE_RX_ONLY) },
{ .soc_id = "r8a7796", .revision = "ES1.0",
.data = (void *)BIT(SDHI_INTERNAL_DMAC_ONE_RX_ONLY) },
/* generic ones */
{ .soc_id = "r8a774a1" },
{ .soc_id = "r8a7795" },
{ .soc_id = "r8a7796" },
{ .soc_id = "r8a77965" },
{ .soc_id = "r8a77980" },
{ .soc_id = "r8a77995" },
{ /* sentinel */ }
};
static int renesas_sdhi_internal_dmac_probe(struct platform_device *pdev)
{
const struct soc_device_attribute *soc = soc_device_match(gen3_soc_whitelist);
struct device *dev = &pdev->dev;
if (!soc)
return -ENODEV;
global_flags |= (unsigned long)soc->data;
dev->dma_parms = devm_kzalloc(dev, sizeof(*dev->dma_parms), GFP_KERNEL);
if (!dev->dma_parms)
return -ENOMEM;
/* value is max of SD_SECCNT. Confirmed by HW engineers */
dma_set_max_seg_size(dev, 0xffffffff);
return renesas_sdhi_probe(pdev, &renesas_sdhi_internal_dmac_dma_ops);
}
static const struct dev_pm_ops renesas_sdhi_internal_dmac_dev_pm_ops = {
SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
pm_runtime_force_resume)
SET_RUNTIME_PM_OPS(tmio_mmc_host_runtime_suspend,
tmio_mmc_host_runtime_resume,
NULL)
};
static struct platform_driver renesas_internal_dmac_sdhi_driver = {
.driver = {
.name = "renesas_sdhi_internal_dmac",
.pm = &renesas_sdhi_internal_dmac_dev_pm_ops,
.of_match_table = renesas_sdhi_internal_dmac_of_match,
},
.probe = renesas_sdhi_internal_dmac_probe,
.remove = renesas_sdhi_remove,
};
module_platform_driver(renesas_internal_dmac_sdhi_driver);
MODULE_DESCRIPTION("Renesas SDHI driver for internal DMAC");
MODULE_AUTHOR("Yoshihiro Shimoda");
MODULE_LICENSE("GPL v2");
+533
View File
@@ -0,0 +1,533 @@
/*
* DMA support use of SYS DMAC with SDHI SD/SDIO controller
*
* Copyright (C) 2016-17 Renesas Electronics Corporation
* Copyright (C) 2016-17 Sang Engineering, Wolfram Sang
* Copyright (C) 2017 Horms Solutions, Simon Horman
* Copyright (C) 2010-2011 Guennadi Liakhovetski
*
* 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/device.h>
#include <linux/dma-mapping.h>
#include <linux/dmaengine.h>
#include <linux/mfd/tmio.h>
#include <linux/mmc/host.h>
#include <linux/mod_devicetable.h>
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/pagemap.h>
#include <linux/scatterlist.h>
#include <linux/sys_soc.h>
#include "renesas_sdhi.h"
#include "tmio_mmc.h"
#define TMIO_MMC_MIN_DMA_LEN 8
static const struct renesas_sdhi_of_data of_default_cfg = {
.tmio_flags = TMIO_MMC_HAS_IDLE_WAIT,
};
static const struct renesas_sdhi_of_data of_rz_compatible = {
.tmio_flags = TMIO_MMC_HAS_IDLE_WAIT | TMIO_MMC_32BIT_DATA_PORT |
TMIO_MMC_HAVE_CBSY,
.tmio_ocr_mask = MMC_VDD_32_33,
.capabilities = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ,
};
static const struct renesas_sdhi_of_data of_rcar_gen1_compatible = {
.tmio_flags = TMIO_MMC_HAS_IDLE_WAIT | TMIO_MMC_CLK_ACTUAL,
.capabilities = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ,
.capabilities2 = MMC_CAP2_NO_WRITE_PROTECT,
};
/* Definitions for sampling clocks */
static struct renesas_sdhi_scc rcar_gen2_scc_taps[] = {
{
.clk_rate = 156000000,
.tap = 0x00000703,
},
{
.clk_rate = 0,
.tap = 0x00000300,
},
};
static const struct renesas_sdhi_of_data of_rcar_gen2_compatible = {
.tmio_flags = TMIO_MMC_HAS_IDLE_WAIT | TMIO_MMC_CLK_ACTUAL |
TMIO_MMC_HAVE_CBSY | TMIO_MMC_MIN_RCAR2,
.capabilities = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ |
MMC_CAP_CMD23,
.capabilities2 = MMC_CAP2_NO_WRITE_PROTECT,
.dma_buswidth = DMA_SLAVE_BUSWIDTH_4_BYTES,
.dma_rx_offset = 0x2000,
.scc_offset = 0x0300,
.taps = rcar_gen2_scc_taps,
.taps_num = ARRAY_SIZE(rcar_gen2_scc_taps),
.max_blk_count = 0xffffffff,
};
/* Definitions for sampling clocks */
static struct renesas_sdhi_scc rcar_gen3_scc_taps[] = {
{
.clk_rate = 0,
.tap = 0x00000300,
},
};
static const struct renesas_sdhi_of_data of_rcar_r8a7795_compatible = {
.tmio_flags = TMIO_MMC_HAS_IDLE_WAIT | TMIO_MMC_CLK_ACTUAL |
TMIO_MMC_HAVE_CBSY | TMIO_MMC_MIN_RCAR2 |
TMIO_MMC_HAVE_4TAP_HS400,
.capabilities = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ |
MMC_CAP_CMD23,
.capabilities2 = MMC_CAP2_NO_WRITE_PROTECT,
.bus_shift = 2,
.scc_offset = 0x1000,
.taps = rcar_gen3_scc_taps,
.taps_num = ARRAY_SIZE(rcar_gen3_scc_taps),
};
static const struct renesas_sdhi_of_data of_rcar_gen3_compatible = {
.tmio_flags = TMIO_MMC_HAS_IDLE_WAIT | TMIO_MMC_CLK_ACTUAL |
TMIO_MMC_HAVE_CBSY | TMIO_MMC_MIN_RCAR2,
.capabilities = MMC_CAP_SD_HIGHSPEED | MMC_CAP_SDIO_IRQ |
MMC_CAP_CMD23,
.capabilities2 = MMC_CAP2_NO_WRITE_PROTECT,
.bus_shift = 2,
.scc_offset = 0x1000,
.taps = rcar_gen3_scc_taps,
.taps_num = ARRAY_SIZE(rcar_gen3_scc_taps),
};
static const struct of_device_id renesas_sdhi_sys_dmac_of_match[] = {
{ .compatible = "renesas,sdhi-sh73a0", .data = &of_default_cfg, },
{ .compatible = "renesas,sdhi-r8a73a4", .data = &of_default_cfg, },
{ .compatible = "renesas,sdhi-r8a7740", .data = &of_default_cfg, },
{ .compatible = "renesas,sdhi-r7s72100", .data = &of_rz_compatible, },
{ .compatible = "renesas,sdhi-r8a7778", .data = &of_rcar_gen1_compatible, },
{ .compatible = "renesas,sdhi-r8a7779", .data = &of_rcar_gen1_compatible, },
{ .compatible = "renesas,sdhi-r8a7743", .data = &of_rcar_gen2_compatible, },
{ .compatible = "renesas,sdhi-r8a7745", .data = &of_rcar_gen2_compatible, },
{ .compatible = "renesas,sdhi-r8a7790", .data = &of_rcar_gen2_compatible, },
{ .compatible = "renesas,sdhi-r8a7791", .data = &of_rcar_gen2_compatible, },
{ .compatible = "renesas,sdhi-r8a7792", .data = &of_rcar_gen2_compatible, },
{ .compatible = "renesas,sdhi-r8a7793", .data = &of_rcar_gen2_compatible, },
{ .compatible = "renesas,sdhi-r8a7794", .data = &of_rcar_gen2_compatible, },
{ .compatible = "renesas,sdhi-r8a7795", .data = &of_rcar_r8a7795_compatible, },
{ .compatible = "renesas,sdhi-r8a7796", .data = &of_rcar_r8a7795_compatible, },
{ .compatible = "renesas,rcar-gen1-sdhi", .data = &of_rcar_gen1_compatible, },
{ .compatible = "renesas,rcar-gen2-sdhi", .data = &of_rcar_gen2_compatible, },
{ .compatible = "renesas,rcar-gen3-sdhi", .data = &of_rcar_gen3_compatible, },
{ .compatible = "renesas,sdhi-shmobile" },
{},
};
MODULE_DEVICE_TABLE(of, renesas_sdhi_sys_dmac_of_match);
static void renesas_sdhi_sys_dmac_enable_dma(struct tmio_mmc_host *host,
bool enable)
{
struct renesas_sdhi *priv = host_to_priv(host);
if (!host->chan_tx || !host->chan_rx)
return;
if (priv->dma_priv.enable)
priv->dma_priv.enable(host, enable);
}
static void renesas_sdhi_sys_dmac_abort_dma(struct tmio_mmc_host *host)
{
renesas_sdhi_sys_dmac_enable_dma(host, false);
if (host->chan_rx)
dmaengine_terminate_all(host->chan_rx);
if (host->chan_tx)
dmaengine_terminate_all(host->chan_tx);
renesas_sdhi_sys_dmac_enable_dma(host, true);
}
static void renesas_sdhi_sys_dmac_dataend_dma(struct tmio_mmc_host *host)
{
struct renesas_sdhi *priv = host_to_priv(host);
complete(&priv->dma_priv.dma_dataend);
}
static void renesas_sdhi_sys_dmac_dma_callback(void *arg)
{
struct tmio_mmc_host *host = arg;
struct renesas_sdhi *priv = host_to_priv(host);
spin_lock_irq(&host->lock);
if (!host->data)
goto out;
if (host->data->flags & MMC_DATA_READ)
dma_unmap_sg(host->chan_rx->device->dev,
host->sg_ptr, host->sg_len,
DMA_FROM_DEVICE);
else
dma_unmap_sg(host->chan_tx->device->dev,
host->sg_ptr, host->sg_len,
DMA_TO_DEVICE);
spin_unlock_irq(&host->lock);
wait_for_completion(&priv->dma_priv.dma_dataend);
spin_lock_irq(&host->lock);
tmio_mmc_do_data_irq(host);
out:
spin_unlock_irq(&host->lock);
}
static void renesas_sdhi_sys_dmac_start_dma_rx(struct tmio_mmc_host *host)
{
struct renesas_sdhi *priv = host_to_priv(host);
struct scatterlist *sg = host->sg_ptr, *sg_tmp;
struct dma_async_tx_descriptor *desc = NULL;
struct dma_chan *chan = host->chan_rx;
dma_cookie_t cookie;
int ret, i;
bool aligned = true, multiple = true;
unsigned int align = (1 << host->pdata->alignment_shift) - 1;
for_each_sg(sg, sg_tmp, host->sg_len, i) {
if (sg_tmp->offset & align)
aligned = false;
if (sg_tmp->length & align) {
multiple = false;
break;
}
}
if ((!aligned && (host->sg_len > 1 || sg->length > PAGE_SIZE ||
(align & PAGE_MASK))) || !multiple) {
ret = -EINVAL;
goto pio;
}
if (sg->length < TMIO_MMC_MIN_DMA_LEN) {
host->force_pio = true;
return;
}
/* The only sg element can be unaligned, use our bounce buffer then */
if (!aligned) {
sg_init_one(&host->bounce_sg, host->bounce_buf, sg->length);
host->sg_ptr = &host->bounce_sg;
sg = host->sg_ptr;
}
ret = dma_map_sg(chan->device->dev, sg, host->sg_len, DMA_FROM_DEVICE);
if (ret > 0)
desc = dmaengine_prep_slave_sg(chan, sg, ret, DMA_DEV_TO_MEM,
DMA_CTRL_ACK);
if (desc) {
reinit_completion(&priv->dma_priv.dma_dataend);
desc->callback = renesas_sdhi_sys_dmac_dma_callback;
desc->callback_param = host;
cookie = dmaengine_submit(desc);
if (cookie < 0) {
desc = NULL;
ret = cookie;
}
}
pio:
if (!desc) {
/* DMA failed, fall back to PIO */
renesas_sdhi_sys_dmac_enable_dma(host, false);
if (ret >= 0)
ret = -EIO;
host->chan_rx = NULL;
dma_release_channel(chan);
/* Free the Tx channel too */
chan = host->chan_tx;
if (chan) {
host->chan_tx = NULL;
dma_release_channel(chan);
}
dev_warn(&host->pdev->dev,
"DMA failed: %d, falling back to PIO\n", ret);
}
}
static void renesas_sdhi_sys_dmac_start_dma_tx(struct tmio_mmc_host *host)
{
struct renesas_sdhi *priv = host_to_priv(host);
struct scatterlist *sg = host->sg_ptr, *sg_tmp;
struct dma_async_tx_descriptor *desc = NULL;
struct dma_chan *chan = host->chan_tx;
dma_cookie_t cookie;
int ret, i;
bool aligned = true, multiple = true;
unsigned int align = (1 << host->pdata->alignment_shift) - 1;
for_each_sg(sg, sg_tmp, host->sg_len, i) {
if (sg_tmp->offset & align)
aligned = false;
if (sg_tmp->length & align) {
multiple = false;
break;
}
}
if ((!aligned && (host->sg_len > 1 || sg->length > PAGE_SIZE ||
(align & PAGE_MASK))) || !multiple) {
ret = -EINVAL;
goto pio;
}
if (sg->length < TMIO_MMC_MIN_DMA_LEN) {
host->force_pio = true;
return;
}
/* The only sg element can be unaligned, use our bounce buffer then */
if (!aligned) {
unsigned long flags;
void *sg_vaddr = tmio_mmc_kmap_atomic(sg, &flags);
sg_init_one(&host->bounce_sg, host->bounce_buf, sg->length);
memcpy(host->bounce_buf, sg_vaddr, host->bounce_sg.length);
tmio_mmc_kunmap_atomic(sg, &flags, sg_vaddr);
host->sg_ptr = &host->bounce_sg;
sg = host->sg_ptr;
}
ret = dma_map_sg(chan->device->dev, sg, host->sg_len, DMA_TO_DEVICE);
if (ret > 0)
desc = dmaengine_prep_slave_sg(chan, sg, ret, DMA_MEM_TO_DEV,
DMA_CTRL_ACK);
if (desc) {
reinit_completion(&priv->dma_priv.dma_dataend);
desc->callback = renesas_sdhi_sys_dmac_dma_callback;
desc->callback_param = host;
cookie = dmaengine_submit(desc);
if (cookie < 0) {
desc = NULL;
ret = cookie;
}
}
pio:
if (!desc) {
/* DMA failed, fall back to PIO */
renesas_sdhi_sys_dmac_enable_dma(host, false);
if (ret >= 0)
ret = -EIO;
host->chan_tx = NULL;
dma_release_channel(chan);
/* Free the Rx channel too */
chan = host->chan_rx;
if (chan) {
host->chan_rx = NULL;
dma_release_channel(chan);
}
dev_warn(&host->pdev->dev,
"DMA failed: %d, falling back to PIO\n", ret);
}
}
static void renesas_sdhi_sys_dmac_start_dma(struct tmio_mmc_host *host,
struct mmc_data *data)
{
if (data->flags & MMC_DATA_READ) {
if (host->chan_rx)
renesas_sdhi_sys_dmac_start_dma_rx(host);
} else {
if (host->chan_tx)
renesas_sdhi_sys_dmac_start_dma_tx(host);
}
}
static void renesas_sdhi_sys_dmac_issue_tasklet_fn(unsigned long priv)
{
struct tmio_mmc_host *host = (struct tmio_mmc_host *)priv;
struct dma_chan *chan = NULL;
spin_lock_irq(&host->lock);
if (host->data) {
if (host->data->flags & MMC_DATA_READ)
chan = host->chan_rx;
else
chan = host->chan_tx;
}
spin_unlock_irq(&host->lock);
tmio_mmc_enable_mmc_irqs(host, TMIO_STAT_DATAEND);
if (chan)
dma_async_issue_pending(chan);
}
static void renesas_sdhi_sys_dmac_request_dma(struct tmio_mmc_host *host,
struct tmio_mmc_data *pdata)
{
struct renesas_sdhi *priv = host_to_priv(host);
/* We can only either use DMA for both Tx and Rx or not use it at all */
if (!host->pdev->dev.of_node &&
(!pdata->chan_priv_tx || !pdata->chan_priv_rx))
return;
if (!host->chan_tx && !host->chan_rx) {
struct resource *res = platform_get_resource(host->pdev,
IORESOURCE_MEM, 0);
struct dma_slave_config cfg = {};
dma_cap_mask_t mask;
int ret;
if (!res)
return;
dma_cap_zero(mask);
dma_cap_set(DMA_SLAVE, mask);
host->chan_tx = dma_request_slave_channel_compat(mask,
priv->dma_priv.filter, pdata->chan_priv_tx,
&host->pdev->dev, "tx");
dev_dbg(&host->pdev->dev, "%s: TX: got channel %p\n", __func__,
host->chan_tx);
if (!host->chan_tx)
return;
cfg.direction = DMA_MEM_TO_DEV;
cfg.dst_addr = res->start +
(CTL_SD_DATA_PORT << host->bus_shift);
cfg.dst_addr_width = priv->dma_priv.dma_buswidth;
if (!cfg.dst_addr_width)
cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;
cfg.src_addr = 0;
ret = dmaengine_slave_config(host->chan_tx, &cfg);
if (ret < 0)
goto ecfgtx;
host->chan_rx = dma_request_slave_channel_compat(mask,
priv->dma_priv.filter, pdata->chan_priv_rx,
&host->pdev->dev, "rx");
dev_dbg(&host->pdev->dev, "%s: RX: got channel %p\n", __func__,
host->chan_rx);
if (!host->chan_rx)
goto ereqrx;
cfg.direction = DMA_DEV_TO_MEM;
cfg.src_addr = cfg.dst_addr + host->pdata->dma_rx_offset;
cfg.src_addr_width = priv->dma_priv.dma_buswidth;
if (!cfg.src_addr_width)
cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;
cfg.dst_addr = 0;
ret = dmaengine_slave_config(host->chan_rx, &cfg);
if (ret < 0)
goto ecfgrx;
host->bounce_buf = (u8 *)__get_free_page(GFP_KERNEL | GFP_DMA);
if (!host->bounce_buf)
goto ebouncebuf;
init_completion(&priv->dma_priv.dma_dataend);
tasklet_init(&host->dma_issue,
renesas_sdhi_sys_dmac_issue_tasklet_fn,
(unsigned long)host);
}
renesas_sdhi_sys_dmac_enable_dma(host, true);
return;
ebouncebuf:
ecfgrx:
dma_release_channel(host->chan_rx);
host->chan_rx = NULL;
ereqrx:
ecfgtx:
dma_release_channel(host->chan_tx);
host->chan_tx = NULL;
}
static void renesas_sdhi_sys_dmac_release_dma(struct tmio_mmc_host *host)
{
if (host->chan_tx) {
struct dma_chan *chan = host->chan_tx;
host->chan_tx = NULL;
dma_release_channel(chan);
}
if (host->chan_rx) {
struct dma_chan *chan = host->chan_rx;
host->chan_rx = NULL;
dma_release_channel(chan);
}
if (host->bounce_buf) {
free_pages((unsigned long)host->bounce_buf, 0);
host->bounce_buf = NULL;
}
}
static const struct tmio_mmc_dma_ops renesas_sdhi_sys_dmac_dma_ops = {
.start = renesas_sdhi_sys_dmac_start_dma,
.enable = renesas_sdhi_sys_dmac_enable_dma,
.request = renesas_sdhi_sys_dmac_request_dma,
.release = renesas_sdhi_sys_dmac_release_dma,
.abort = renesas_sdhi_sys_dmac_abort_dma,
.dataend = renesas_sdhi_sys_dmac_dataend_dma,
};
/*
* Whitelist of specific R-Car Gen3 SoC ES versions to use this DMAC
* implementation. Currently empty as all supported ES versions use
* the internal DMAC.
*/
static const struct soc_device_attribute gen3_soc_whitelist[] = {
{ /* sentinel */ }
};
static int renesas_sdhi_sys_dmac_probe(struct platform_device *pdev)
{
if ((of_device_get_match_data(&pdev->dev) == &of_rcar_gen3_compatible ||
of_device_get_match_data(&pdev->dev) == &of_rcar_r8a7795_compatible) &&
!soc_device_match(gen3_soc_whitelist))
return -ENODEV;
return renesas_sdhi_probe(pdev, &renesas_sdhi_sys_dmac_dma_ops);
}
static const struct dev_pm_ops renesas_sdhi_sys_dmac_dev_pm_ops = {
SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
pm_runtime_force_resume)
SET_RUNTIME_PM_OPS(tmio_mmc_host_runtime_suspend,
tmio_mmc_host_runtime_resume,
NULL)
};
static struct platform_driver renesas_sys_dmac_sdhi_driver = {
.driver = {
.name = "sh_mobile_sdhi",
.pm = &renesas_sdhi_sys_dmac_dev_pm_ops,
.of_match_table = renesas_sdhi_sys_dmac_of_match,
},
.probe = renesas_sdhi_sys_dmac_probe,
.remove = renesas_sdhi_remove,
};
module_platform_driver(renesas_sys_dmac_sdhi_driver);
MODULE_DESCRIPTION("Renesas SDHI driver");
MODULE_AUTHOR("Magnus Damm");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:sh_mobile_sdhi");
File diff suppressed because it is too large. Load diff
Loaded 100 of 80519 files, more files were not shown because too many files have changed in this diff. Show more