// SPDX-License-Identifier: GPL-2.0-only /* * linux/drivers/mmc/core/core.c * * Copyright (C) 2003-2004 Russell King, All Rights Reserved. * SD support Copyright (C) 2004 Ian Molton, All Rights Reserved. * Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved. * MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved. */ #include <linux/module.h> #include <linux/init.h> #include <linux/interrupt.h> #include <linux/completion.h> #include <linux/device.h> #include <linux/delay.h> #include <linux/pagemap.h> #include <linux/err.h> #include <linux/leds.h> #include <linux/scatterlist.h> #include <linux/log2.h> #include <linux/pm_runtime.h> #include <linux/pm_wakeup.h> #include <linux/suspend.h> #include <linux/fault-inject.h> #include <linux/random.h> #include <linux/slab.h> #include <linux/of.h> #include <linux/mmc/card.h> #include <linux/mmc/host.h> #include <linux/mmc/mmc.h> #include <linux/mmc/sd.h> #include <linux/mmc/slot-gpio.h> #define CREATE_TRACE_POINTS #include <trace/events/mmc.h> #include "core.h" #include "card.h" #include "crypto.h" #include "bus.h" #include "host.h" #include "sdio_bus.h" #include "pwrseq.h" #include "mmc_ops.h" #include "sd_ops.h" #include "sdio_ops.h" /* The max erase timeout, used when host->max_busy_timeout isn't specified */ #define MMC_ERASE_TIMEOUT_MS … #define SD_DISCARD_TIMEOUT_MS … static const unsigned freqs[] = …; /* * Enabling software CRCs on the data blocks can be a significant (30%) * performance cost, and for other reasons may not always be desired. * So we allow it to be disabled. */ bool use_spi_crc = …; module_param(use_spi_crc, bool, 0); static int mmc_schedule_delayed_work(struct delayed_work *work, unsigned long delay) { … } #ifdef CONFIG_FAIL_MMC_REQUEST /* * Internal function. Inject random data errors. * If mmc_data is NULL no errors are injected. */ static void mmc_should_fail_request(struct mmc_host *host, struct mmc_request *mrq) { … } #else /* CONFIG_FAIL_MMC_REQUEST */ static inline void mmc_should_fail_request(struct mmc_host *host, struct mmc_request *mrq) { } #endif /* CONFIG_FAIL_MMC_REQUEST */ static inline void mmc_complete_cmd(struct mmc_request *mrq) { … } void mmc_command_done(struct mmc_host *host, struct mmc_request *mrq) { … } EXPORT_SYMBOL(…); /** * mmc_request_done - finish processing an MMC request * @host: MMC host which completed request * @mrq: MMC request which request * * MMC drivers should call this function when they have completed * their processing of a request. */ void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq) { … } EXPORT_SYMBOL(…); static void __mmc_start_request(struct mmc_host *host, struct mmc_request *mrq) { … } static void mmc_mrq_pr_debug(struct mmc_host *host, struct mmc_request *mrq, bool cqe) { … } static int mmc_mrq_prep(struct mmc_host *host, struct mmc_request *mrq) { … } int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq) { … } EXPORT_SYMBOL(…); static void mmc_wait_done(struct mmc_request *mrq) { … } static inline void mmc_wait_ongoing_tfr_cmd(struct mmc_host *host) { … } static int __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq) { … } void mmc_wait_for_req_done(struct mmc_host *host, struct mmc_request *mrq) { … } EXPORT_SYMBOL(…); /* * mmc_cqe_start_req - Start a CQE request. * @host: MMC host to start the request * @mrq: request to start * * Start the request, re-tuning if needed and it is possible. Returns an error * code if the request fails to start or -EBUSY if CQE is busy. */ int mmc_cqe_start_req(struct mmc_host *host, struct mmc_request *mrq) { … } EXPORT_SYMBOL(…); /** * mmc_cqe_request_done - CQE has finished processing an MMC request * @host: MMC host which completed request * @mrq: MMC request which completed * * CQE drivers should call this function when they have completed * their processing of a request. */ void mmc_cqe_request_done(struct mmc_host *host, struct mmc_request *mrq) { … } EXPORT_SYMBOL(…); /** * mmc_cqe_post_req - CQE post process of a completed MMC request * @host: MMC host * @mrq: MMC request to be processed */ void mmc_cqe_post_req(struct mmc_host *host, struct mmc_request *mrq) { … } EXPORT_SYMBOL(…); /* Arbitrary 1 second timeout */ #define MMC_CQE_RECOVERY_TIMEOUT … /* * mmc_cqe_recovery - Recover from CQE errors. * @host: MMC host to recover * * Recovery consists of stopping CQE, stopping eMMC, discarding the queue * in eMMC, and discarding the queue in CQE. CQE must call * mmc_cqe_request_done() on all requests. An error is returned if the eMMC * fails to discard its queue. */ int mmc_cqe_recovery(struct mmc_host *host) { … } EXPORT_SYMBOL(…); /** * mmc_is_req_done - Determine if a 'cap_cmd_during_tfr' request is done * @host: MMC host * @mrq: MMC request * * mmc_is_req_done() is used with requests that have * mrq->cap_cmd_during_tfr = true. mmc_is_req_done() must be called after * starting a request and before waiting for it to complete. That is, * either in between calls to mmc_start_req(), or after mmc_wait_for_req() * and before mmc_wait_for_req_done(). If it is called at other times the * result is not meaningful. */ bool mmc_is_req_done(struct mmc_host *host, struct mmc_request *mrq) { … } EXPORT_SYMBOL(…); /** * mmc_wait_for_req - start a request and wait for completion * @host: MMC host to start command * @mrq: MMC request to start * * Start a new MMC custom command request for a host, and wait * for the command to complete. In the case of 'cap_cmd_during_tfr' * requests, the transfer is ongoing and the caller can issue further * commands that do not use the data lines, and then wait by calling * mmc_wait_for_req_done(). * Does not attempt to parse the response. */ void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq) { … } EXPORT_SYMBOL(…); /** * mmc_wait_for_cmd - start a command and wait for completion * @host: MMC host to start command * @cmd: MMC command to start * @retries: maximum number of retries * * Start a new MMC command for a host, and wait for the command * to complete. Return any error that occurred while the command * was executing. Do not attempt to parse the response. */ int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries) { … } EXPORT_SYMBOL(…); /** * mmc_set_data_timeout - set the timeout for a data command * @data: data phase for command * @card: the MMC card associated with the data transfer * * Computes the data timeout parameters according to the * correct algorithm given the card type. */ void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card) { … } EXPORT_SYMBOL(…); /* * Allow claiming an already claimed host if the context is the same or there is * no context but the task is the same. */ static inline bool mmc_ctx_matches(struct mmc_host *host, struct mmc_ctx *ctx, struct task_struct *task) { … } static inline void mmc_ctx_set_claimer(struct mmc_host *host, struct mmc_ctx *ctx, struct task_struct *task) { … } /** * __mmc_claim_host - exclusively claim a host * @host: mmc host to claim * @ctx: context that claims the host or NULL in which case the default * context will be used * @abort: whether or not the operation should be aborted * * Claim a host for a set of operations. If @abort is non null and * dereference a non-zero value then this will return prematurely with * that non-zero value without acquiring the lock. Returns zero * with the lock held otherwise. */ int __mmc_claim_host(struct mmc_host *host, struct mmc_ctx *ctx, atomic_t *abort) { … } EXPORT_SYMBOL(…); /** * mmc_release_host - release a host * @host: mmc host to release * * Release a MMC host, allowing others to claim the host * for their operations. */ void mmc_release_host(struct mmc_host *host) { … } EXPORT_SYMBOL(…); /* * This is a helper function, which fetches a runtime pm reference for the * card device and also claims the host. */ void mmc_get_card(struct mmc_card *card, struct mmc_ctx *ctx) { … } EXPORT_SYMBOL(…); /* * This is a helper function, which releases the host and drops the runtime * pm reference for the card device. */ void mmc_put_card(struct mmc_card *card, struct mmc_ctx *ctx) { … } EXPORT_SYMBOL(…); /* * Internal function that does the actual ios call to the host driver, * optionally printing some debug output. */ static inline void mmc_set_ios(struct mmc_host *host) { … } /* * Control chip select pin on a host. */ void mmc_set_chip_select(struct mmc_host *host, int mode) { … } /* * Sets the host clock to the highest possible frequency that * is below "hz". */ void mmc_set_clock(struct mmc_host *host, unsigned int hz) { … } int mmc_execute_tuning(struct mmc_card *card) { … } /* * Change the bus mode (open drain/push-pull) of a host. */ void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode) { … } /* * Change data bus width of a host. */ void mmc_set_bus_width(struct mmc_host *host, unsigned int width) { … } /* * Set initial state after a power cycle or a hw_reset. */ void mmc_set_initial_state(struct mmc_host *host) { … } /** * mmc_vdd_to_ocrbitnum - Convert a voltage to the OCR bit number * @vdd: voltage (mV) * @low_bits: prefer low bits in boundary cases * * This function returns the OCR bit number according to the provided @vdd * value. If conversion is not possible a negative errno value returned. * * Depending on the @low_bits flag the function prefers low or high OCR bits * on boundary voltages. For example, * with @low_bits = true, 3300 mV translates to ilog2(MMC_VDD_32_33); * with @low_bits = false, 3300 mV translates to ilog2(MMC_VDD_33_34); * * Any value in the [1951:1999] range translates to the ilog2(MMC_VDD_20_21). */ static int mmc_vdd_to_ocrbitnum(int vdd, bool low_bits) { … } /** * mmc_vddrange_to_ocrmask - Convert a voltage range to the OCR mask * @vdd_min: minimum voltage value (mV) * @vdd_max: maximum voltage value (mV) * * This function returns the OCR mask bits according to the provided @vdd_min * and @vdd_max values. If conversion is not possible the function returns 0. * * Notes wrt boundary cases: * This function sets the OCR bits for all boundary voltages, for example * [3300:3400] range is translated to MMC_VDD_32_33 | MMC_VDD_33_34 | * MMC_VDD_34_35 mask. */ u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max) { … } static int mmc_of_get_func_num(struct device_node *node) { … } struct device_node *mmc_of_find_child_device(struct mmc_host *host, unsigned func_num) { … } /* * Mask off any voltages we don't support and select * the lowest voltage */ u32 mmc_select_voltage(struct mmc_host *host, u32 ocr) { … } int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage) { … } void mmc_set_initial_signal_voltage(struct mmc_host *host) { … } int mmc_host_set_uhs_voltage(struct mmc_host *host) { … } int mmc_set_uhs_voltage(struct mmc_host *host, u32 ocr) { … } /* * Select timing parameters for host. */ void mmc_set_timing(struct mmc_host *host, unsigned int timing) { … } /* * Select appropriate driver type for host. */ void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type) { … } int mmc_select_drive_strength(struct mmc_card *card, unsigned int max_dtr, int card_drv_type, int *drv_type) { … } /* * Apply power to the MMC stack. This is a two-stage process. * First, we enable power to the card without the clock running. * We then wait a bit for the power to stabilise. Finally, * enable the bus drivers and clock to the card. * * We must _NOT_ enable the clock prior to power stablising. * * If a host does all the power sequencing itself, ignore the * initial MMC_POWER_UP stage. */ void mmc_power_up(struct mmc_host *host, u32 ocr) { … } void mmc_power_off(struct mmc_host *host) { … } void mmc_power_cycle(struct mmc_host *host, u32 ocr) { … } /* * Assign a mmc bus handler to a host. Only one bus handler may control a * host at any given time. */ void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops) { … } /* * Remove the current bus handler from a host. */ void mmc_detach_bus(struct mmc_host *host) { … } void _mmc_detect_change(struct mmc_host *host, unsigned long delay, bool cd_irq) { … } /** * mmc_detect_change - process change of state on a MMC socket * @host: host which changed state. * @delay: optional delay to wait before detection (jiffies) * * MMC drivers should call this when they detect a card has been * inserted or removed. The MMC layer will confirm that any * present card is still functional, and initialize any newly * inserted. */ void mmc_detect_change(struct mmc_host *host, unsigned long delay) { … } EXPORT_SYMBOL(…); void mmc_init_erase(struct mmc_card *card) { … } static bool is_trim_arg(unsigned int arg) { … } static unsigned int mmc_mmc_erase_timeout(struct mmc_card *card, unsigned int arg, unsigned int qty) { … } static unsigned int mmc_sd_erase_timeout(struct mmc_card *card, unsigned int arg, unsigned int qty) { … } static unsigned int mmc_erase_timeout(struct mmc_card *card, unsigned int arg, unsigned int qty) { … } static int mmc_do_erase(struct mmc_card *card, unsigned int from, unsigned int to, unsigned int arg) { … } static unsigned int mmc_align_erase_size(struct mmc_card *card, unsigned int *from, unsigned int *to, unsigned int nr) { … } /** * mmc_erase - erase sectors. * @card: card to erase * @from: first sector to erase * @nr: number of sectors to erase * @arg: erase command argument * * Caller must claim host before calling this function. */ int mmc_erase(struct mmc_card *card, unsigned int from, unsigned int nr, unsigned int arg) { … } EXPORT_SYMBOL(…); int mmc_can_erase(struct mmc_card *card) { … } EXPORT_SYMBOL(…); int mmc_can_trim(struct mmc_card *card) { … } EXPORT_SYMBOL(…); int mmc_can_discard(struct mmc_card *card) { … } EXPORT_SYMBOL(…); int mmc_can_sanitize(struct mmc_card *card) { … } int mmc_can_secure_erase_trim(struct mmc_card *card) { … } EXPORT_SYMBOL(…); int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from, unsigned int nr) { … } EXPORT_SYMBOL(…); static unsigned int mmc_do_calc_max_discard(struct mmc_card *card, unsigned int arg) { … } unsigned int mmc_calc_max_discard(struct mmc_card *card) { … } EXPORT_SYMBOL(…); bool mmc_card_is_blockaddr(struct mmc_card *card) { … } EXPORT_SYMBOL(…); int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen) { … } EXPORT_SYMBOL(…); static void mmc_hw_reset_for_init(struct mmc_host *host) { … } /** * mmc_hw_reset - reset the card in hardware * @card: card to be reset * * Hard reset the card. This function is only for upper layers, like the * block layer or card drivers. You cannot use it in host drivers (struct * mmc_card might be gone then). * * Return: 0 on success, -errno on failure */ int mmc_hw_reset(struct mmc_card *card) { … } EXPORT_SYMBOL(…); int mmc_sw_reset(struct mmc_card *card) { … } EXPORT_SYMBOL(…); static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq) { … } int _mmc_detect_card_removed(struct mmc_host *host) { … } int mmc_detect_card_removed(struct mmc_host *host) { … } EXPORT_SYMBOL(…); int mmc_card_alternative_gpt_sector(struct mmc_card *card, sector_t *gpt_sector) { … } EXPORT_SYMBOL(…); void mmc_rescan(struct work_struct *work) { … } void mmc_start_host(struct mmc_host *host) { … } void __mmc_stop_host(struct mmc_host *host) { … } void mmc_stop_host(struct mmc_host *host) { … } static int __init mmc_init(void) { … } static void __exit mmc_exit(void) { … } subsys_initcall(mmc_init); module_exit(mmc_exit); MODULE_DESCRIPTION(…) …; MODULE_LICENSE(…) …;
Codebase Browser
linux