linux/drivers/mmc/host/davinci_mmc.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * davinci_mmc.c - TI DaVinci MMC/SD/SDIO driver
 *
 * Copyright (C) 2006 Texas Instruments.
 *       Original author: Purushotam Kumar
 * Copyright (C) 2009 David Brownell
 */

#include <linux/module.h>
#include <linux/ioport.h>
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <linux/err.h>
#include <linux/cpufreq.h>
#include <linux/mmc/host.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/delay.h>
#include <linux/dmaengine.h>
#include <linux/dma-mapping.h>
#include <linux/mmc/mmc.h>
#include <linux/of.h>
#include <linux/mmc/slot-gpio.h>
#include <linux/interrupt.h>

#include <linux/platform_data/mmc-davinci.h>

/*
 * Register Definitions
 */
#define DAVINCI_MMCCTL
#define DAVINCI_MMCCLK
#define DAVINCI_MMCST0
#define DAVINCI_MMCST1
#define DAVINCI_MMCIM
#define DAVINCI_MMCTOR
#define DAVINCI_MMCTOD
#define DAVINCI_MMCBLEN
#define DAVINCI_MMCNBLK
#define DAVINCI_MMCNBLC
#define DAVINCI_MMCDRR
#define DAVINCI_MMCDXR
#define DAVINCI_MMCCMD
#define DAVINCI_MMCARGHL
#define DAVINCI_MMCRSP01
#define DAVINCI_MMCRSP23
#define DAVINCI_MMCRSP45
#define DAVINCI_MMCRSP67
#define DAVINCI_MMCDRSP
#define DAVINCI_MMCETOK
#define DAVINCI_MMCCIDX
#define DAVINCI_MMCCKC
#define DAVINCI_MMCTORC
#define DAVINCI_MMCTODC
#define DAVINCI_MMCBLNC
#define DAVINCI_SDIOCTL
#define DAVINCI_SDIOST0
#define DAVINCI_SDIOIEN
#define DAVINCI_SDIOIST
#define DAVINCI_MMCFIFOCTL

/* DAVINCI_MMCCTL definitions */
#define MMCCTL_DATRST
#define MMCCTL_CMDRST
#define MMCCTL_WIDTH_8_BIT
#define MMCCTL_WIDTH_4_BIT
#define MMCCTL_DATEG_DISABLED
#define MMCCTL_DATEG_RISING
#define MMCCTL_DATEG_FALLING
#define MMCCTL_DATEG_BOTH
#define MMCCTL_PERMDR_LE
#define MMCCTL_PERMDR_BE
#define MMCCTL_PERMDX_LE
#define MMCCTL_PERMDX_BE

/* DAVINCI_MMCCLK definitions */
#define MMCCLK_CLKEN
#define MMCCLK_CLKRT_MASK

/* IRQ bit definitions, for DAVINCI_MMCST0 and DAVINCI_MMCIM */
#define MMCST0_DATDNE
#define MMCST0_BSYDNE
#define MMCST0_RSPDNE
#define MMCST0_TOUTRD
#define MMCST0_TOUTRS
#define MMCST0_CRCWR
#define MMCST0_CRCRD
#define MMCST0_CRCRS
#define MMCST0_DXRDY
#define MMCST0_DRRDY
#define MMCST0_DATED
#define MMCST0_TRNDNE

/* DAVINCI_MMCST1 definitions */
#define MMCST1_BUSY

/* DAVINCI_MMCCMD definitions */
#define MMCCMD_CMD_MASK
#define MMCCMD_PPLEN
#define MMCCMD_BSYEXP
#define MMCCMD_RSPFMT_MASK
#define MMCCMD_RSPFMT_NONE
#define MMCCMD_RSPFMT_R1456
#define MMCCMD_RSPFMT_R2
#define MMCCMD_RSPFMT_R3
#define MMCCMD_DTRW
#define MMCCMD_STRMTP
#define MMCCMD_WDATX
#define MMCCMD_INITCK
#define MMCCMD_DCLR
#define MMCCMD_DMATRIG

/* DAVINCI_MMCFIFOCTL definitions */
#define MMCFIFOCTL_FIFORST
#define MMCFIFOCTL_FIFODIR_WR
#define MMCFIFOCTL_FIFODIR_RD
#define MMCFIFOCTL_FIFOLEV
#define MMCFIFOCTL_ACCWD_4
#define MMCFIFOCTL_ACCWD_3
#define MMCFIFOCTL_ACCWD_2
#define MMCFIFOCTL_ACCWD_1

/* DAVINCI_SDIOST0 definitions */
#define SDIOST0_DAT1_HI

/* DAVINCI_SDIOIEN definitions */
#define SDIOIEN_IOINTEN

/* DAVINCI_SDIOIST definitions */
#define SDIOIST_IOINT

/* MMCSD Init clock in Hz in opendrain mode */
#define MMCSD_INIT_CLOCK

/*
 * One scatterlist dma "segment" is at most MAX_CCNT rw_threshold units,
 * and we handle up to MAX_NR_SG segments.  MMC_BLOCK_BOUNCE kicks in only
 * for drivers with max_segs == 1, making the segments bigger (64KB)
 * than the page or two that's otherwise typical. nr_sg (passed from
 * platform data) == 16 gives at least the same throughput boost, using
 * EDMA transfer linkage instead of spending CPU time copying pages.
 */
#define MAX_CCNT

#define MAX_NR_SG

static unsigned rw_threshold =;
module_param(rw_threshold, uint, S_IRUGO);
MODULE_PARM_DESC();

static unsigned poll_threshold =;
module_param(poll_threshold, uint, S_IRUGO);
MODULE_PARM_DESC();

static unsigned poll_loopcount =;
module_param(poll_loopcount, uint, S_IRUGO);
MODULE_PARM_DESC();

static unsigned use_dma =;
module_param(use_dma, uint, 0);
MODULE_PARM_DESC();

struct mmc_davinci_host {};

static irqreturn_t mmc_davinci_irq(int irq, void *dev_id);

/* PIO only */
static void davinci_fifo_data_trans(struct mmc_davinci_host *host,
					unsigned int n)
{}

static void mmc_davinci_start_command(struct mmc_davinci_host *host,
		struct mmc_command *cmd)
{}

/*----------------------------------------------------------------------*/

/* DMA infrastructure */

static void davinci_abort_dma(struct mmc_davinci_host *host)
{}

static int mmc_davinci_send_dma_request(struct mmc_davinci_host *host,
		struct mmc_data *data)
{}

static int mmc_davinci_start_dma_transfer(struct mmc_davinci_host *host,
		struct mmc_data *data)
{}

static void davinci_release_dma_channels(struct mmc_davinci_host *host)
{}

static int davinci_acquire_dma_channels(struct mmc_davinci_host *host)
{}

/*----------------------------------------------------------------------*/

static void
mmc_davinci_prepare_data(struct mmc_davinci_host *host, struct mmc_request *req)
{}

static void mmc_davinci_request(struct mmc_host *mmc, struct mmc_request *req)
{}

static unsigned int calculate_freq_for_card(struct mmc_davinci_host *host,
	unsigned int mmc_req_freq)
{}

static void calculate_clk_divider(struct mmc_host *mmc, struct mmc_ios *ios)
{}

static void mmc_davinci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
{}

static void
mmc_davinci_xfer_done(struct mmc_davinci_host *host, struct mmc_data *data)
{}

static void mmc_davinci_cmd_done(struct mmc_davinci_host *host,
				 struct mmc_command *cmd)
{}

static inline void mmc_davinci_reset_ctrl(struct mmc_davinci_host *host,
								int val)
{}

static void
davinci_abort_data(struct mmc_davinci_host *host, struct mmc_data *data)
{}

static irqreturn_t mmc_davinci_sdio_irq(int irq, void *dev_id)
{}

static irqreturn_t mmc_davinci_irq(int irq, void *dev_id)
{}

static int mmc_davinci_get_cd(struct mmc_host *mmc)
{}

static int mmc_davinci_get_ro(struct mmc_host *mmc)
{}

static void mmc_davinci_enable_sdio_irq(struct mmc_host *mmc, int enable)
{}

static const struct mmc_host_ops mmc_davinci_ops =;

/*----------------------------------------------------------------------*/

#ifdef CONFIG_CPU_FREQ
static int mmc_davinci_cpufreq_transition(struct notifier_block *nb,
				     unsigned long val, void *data)
{}

static inline int mmc_davinci_cpufreq_register(struct mmc_davinci_host *host)
{}

static inline void mmc_davinci_cpufreq_deregister(struct mmc_davinci_host *host)
{}
#else
static inline int mmc_davinci_cpufreq_register(struct mmc_davinci_host *host)
{
	return 0;
}

static inline void mmc_davinci_cpufreq_deregister(struct mmc_davinci_host *host)
{
}
#endif
static void init_mmcsd_host(struct mmc_davinci_host *host)
{}

static const struct platform_device_id davinci_mmc_devtype[] =;
MODULE_DEVICE_TABLE(platform, davinci_mmc_devtype);

static const struct of_device_id davinci_mmc_dt_ids[] =;
MODULE_DEVICE_TABLE(of, davinci_mmc_dt_ids);

static int mmc_davinci_parse_pdata(struct mmc_host *mmc)
{}

static int davinci_mmcsd_probe(struct platform_device *pdev)
{}

static void davinci_mmcsd_remove(struct platform_device *pdev)
{}

#ifdef CONFIG_PM
static int davinci_mmcsd_suspend(struct device *dev)
{}

static int davinci_mmcsd_resume(struct device *dev)
{}

static const struct dev_pm_ops davinci_mmcsd_pm =;

#define davinci_mmcsd_pm_ops
#else
#define davinci_mmcsd_pm_ops
#endif

static struct platform_driver davinci_mmcsd_driver =;

module_platform_driver();

MODULE_AUTHOR();
MODULE_LICENSE();
MODULE_DESCRIPTION();
MODULE_ALIAS();