linux/drivers/mmc/core/mmc_ops.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  linux/drivers/mmc/core/mmc_ops.h
 *
 *  Copyright 2006-2007 Pierre Ossman
 */

#include <linux/slab.h>
#include <linux/export.h>
#include <linux/types.h>
#include <linux/scatterlist.h>

#include <linux/mmc/host.h>
#include <linux/mmc/card.h>
#include <linux/mmc/mmc.h>

#include "core.h"
#include "card.h"
#include "host.h"
#include "mmc_ops.h"

#define MMC_BKOPS_TIMEOUT_MS …
#define MMC_SANITIZE_TIMEOUT_MS …
#define MMC_OP_COND_PERIOD_US …
#define MMC_OP_COND_TIMEOUT_MS …

static const u8 tuning_blk_pattern_4bit[] = …;

static const u8 tuning_blk_pattern_8bit[] = …;

struct mmc_busy_data { … };

struct mmc_op_cond_busy_data { … };

int __mmc_send_status(struct mmc_card *card, u32 *status, unsigned int retries)
{ … }
EXPORT_SYMBOL_GPL(…);

int mmc_send_status(struct mmc_card *card, u32 *status)
{ … }
EXPORT_SYMBOL_GPL(…);

static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card)
{ … }

int mmc_select_card(struct mmc_card *card)
{ … }

int mmc_deselect_cards(struct mmc_host *host)
{ … }

/*
 * Write the value specified in the device tree or board code into the optional
 * 16 bit Driver Stage Register. This can be used to tune raise/fall times and
 * drive strength of the DAT and CMD outputs. The actual meaning of a given
 * value is hardware dependant.
 * The presence of the DSR register can be determined from the CSD register,
 * bit 76.
 */
int mmc_set_dsr(struct mmc_host *host)
{ … }

int mmc_go_idle(struct mmc_host *host)
{ … }

static int __mmc_send_op_cond_cb(void *cb_data, bool *busy)
{ … }

int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
{ … }

int mmc_set_relative_addr(struct mmc_card *card)
{ … }

static int
mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode)
{ … }

/*
 * NOTE: void *buf, caller for the buf is required to use DMA-capable
 * buffer or on-stack buffer (with some overhead in callee).
 */
int mmc_send_adtc_data(struct mmc_card *card, struct mmc_host *host, u32 opcode,
		       u32 args, void *buf, unsigned len)
{ … }

static int mmc_spi_send_cxd(struct mmc_host *host, u32 *cxd, u32 opcode)
{ … }

int mmc_send_csd(struct mmc_card *card, u32 *csd)
{ … }

int mmc_send_cid(struct mmc_host *host, u32 *cid)
{ … }

int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd)
{ … }
EXPORT_SYMBOL_GPL(…);

int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp)
{ … }

int mmc_spi_set_crc(struct mmc_host *host, int use_crc)
{ … }

static int mmc_switch_status_error(struct mmc_host *host, u32 status)
{ … }

/* Caller must hold re-tuning */
int mmc_switch_status(struct mmc_card *card, bool crc_err_fatal)
{ … }

static int mmc_busy_cb(void *cb_data, bool *busy)
{ … }

int __mmc_poll_for_busy(struct mmc_host *host, unsigned int period_us,
			unsigned int timeout_ms,
			int (*busy_cb)(void *cb_data, bool *busy),
			void *cb_data)
{ … }
EXPORT_SYMBOL_GPL(…);

int mmc_poll_for_busy(struct mmc_card *card, unsigned int timeout_ms,
		      bool retry_crc_err, enum mmc_busy_cmd busy_cmd)
{ … }
EXPORT_SYMBOL_GPL(…);

bool mmc_prepare_busy_cmd(struct mmc_host *host, struct mmc_command *cmd,
			  unsigned int timeout_ms)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 *	__mmc_switch - modify EXT_CSD register
 *	@card: the MMC card associated with the data transfer
 *	@set: cmd set values
 *	@index: EXT_CSD register index
 *	@value: value to program into EXT_CSD register
 *	@timeout_ms: timeout (ms) for operation performed by register write,
 *                   timeout of zero implies maximum possible timeout
 *	@timing: new timing to change to
 *	@send_status: send status cmd to poll for busy
 *	@retry_crc_err: retry when CRC errors when polling with CMD13 for busy
 *	@retries: number of retries
 *
 *	Modifies the EXT_CSD register for selected card.
 */
int __mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
		unsigned int timeout_ms, unsigned char timing,
		bool send_status, bool retry_crc_err, unsigned int retries)
{ … }

int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
		unsigned int timeout_ms)
{ … }
EXPORT_SYMBOL_GPL(…);

int mmc_send_tuning(struct mmc_host *host, u32 opcode, int *cmd_error)
{ … }
EXPORT_SYMBOL_GPL(…);

int mmc_send_abort_tuning(struct mmc_host *host, u32 opcode)
{ … }
EXPORT_SYMBOL_GPL(…);

static int
mmc_send_bus_test(struct mmc_card *card, struct mmc_host *host, u8 opcode,
		  u8 len)
{ … }

int mmc_bus_test(struct mmc_card *card, u8 bus_width)
{ … }

static int mmc_send_hpi_cmd(struct mmc_card *card)
{ … }

/**
 *	mmc_interrupt_hpi - Issue for High priority Interrupt
 *	@card: the MMC card associated with the HPI transfer
 *
 *	Issued High Priority Interrupt, and check for card status
 *	until out-of prg-state.
 */
static int mmc_interrupt_hpi(struct mmc_card *card)
{ … }

int mmc_can_ext_csd(struct mmc_card *card)
{ … }

static int mmc_read_bkops_status(struct mmc_card *card)
{ … }

/**
 *	mmc_run_bkops - Run BKOPS for supported cards
 *	@card: MMC card to run BKOPS for
 *
 *	Run background operations synchronously for cards having manual BKOPS
 *	enabled and in case it reports urgent BKOPS level.
*/
void mmc_run_bkops(struct mmc_card *card)
{ … }
EXPORT_SYMBOL(…);

static int mmc_cmdq_switch(struct mmc_card *card, bool enable)
{ … }

int mmc_cmdq_enable(struct mmc_card *card)
{ … }
EXPORT_SYMBOL_GPL(…);

int mmc_cmdq_disable(struct mmc_card *card)
{ … }
EXPORT_SYMBOL_GPL(…);

int mmc_sanitize(struct mmc_card *card, unsigned int timeout_ms)
{ … }
EXPORT_SYMBOL_GPL(…);