Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Pierre Ossman | aaac1b4 | 2007-02-28 15:33:10 +0100 | [diff] [blame] | 2 | * linux/include/linux/mmc/core.h |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * |
| 4 | * This program is free software; you can redistribute it and/or modify |
| 5 | * it under the terms of the GNU General Public License version 2 as |
| 6 | * published by the Free Software Foundation. |
| 7 | */ |
Pierre Ossman | aaac1b4 | 2007-02-28 15:33:10 +0100 | [diff] [blame] | 8 | #ifndef LINUX_MMC_CORE_H |
| 9 | #define LINUX_MMC_CORE_H |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 10 | |
Venkat Gopalakrishnan | 5b172082 | 2013-02-12 16:13:05 -0800 | [diff] [blame] | 11 | #include <uapi/linux/mmc/core.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 12 | #include <linux/interrupt.h> |
Paul Gortmaker | 313162d | 2012-01-30 11:46:54 -0500 | [diff] [blame] | 13 | #include <linux/completion.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | |
| 15 | struct request; |
| 16 | struct mmc_data; |
| 17 | struct mmc_request; |
| 18 | |
| 19 | struct mmc_command { |
| 20 | u32 opcode; |
| 21 | u32 arg; |
Seungwon Jeon | ce39f9d | 2013-02-06 17:02:46 +0900 | [diff] [blame] | 22 | #define MMC_CMD23_ARG_REL_WR (1 << 31) |
| 23 | #define MMC_CMD23_ARG_PACKED ((0 << 31) | (1 << 30)) |
| 24 | #define MMC_CMD23_ARG_TAG_REQ (1 << 29) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 25 | u32 resp[4]; |
| 26 | unsigned int flags; /* expected response type */ |
Russell King | e922517 | 2006-02-02 12:23:12 +0000 | [diff] [blame] | 27 | |
Wolfram Sang | 51b50c9 | 2016-09-19 22:57:45 +0200 | [diff] [blame] | 28 | /* Can be used by core to poll after switch to MMC HS mode */ |
| 29 | #define MMC_RSP_R1_NO_CRC (MMC_RSP_PRESENT|MMC_RSP_OPCODE) |
| 30 | |
Russell King | e922517 | 2006-02-02 12:23:12 +0000 | [diff] [blame] | 31 | #define mmc_resp_type(cmd) ((cmd)->flags & (MMC_RSP_PRESENT|MMC_RSP_136|MMC_RSP_CRC|MMC_RSP_BUSY|MMC_RSP_OPCODE)) |
| 32 | |
| 33 | /* |
David Brownell | 9701858 | 2007-08-08 09:09:01 -0700 | [diff] [blame] | 34 | * These are the SPI response types for MMC, SD, and SDIO cards. |
| 35 | * Commands return R1, with maybe more info. Zero is an error type; |
| 36 | * callers must always provide the appropriate MMC_RSP_SPI_Rx flags. |
| 37 | */ |
| 38 | #define MMC_RSP_SPI_R1 (MMC_RSP_SPI_S1) |
| 39 | #define MMC_RSP_SPI_R1B (MMC_RSP_SPI_S1|MMC_RSP_SPI_BUSY) |
| 40 | #define MMC_RSP_SPI_R2 (MMC_RSP_SPI_S1|MMC_RSP_SPI_S2) |
| 41 | #define MMC_RSP_SPI_R3 (MMC_RSP_SPI_S1|MMC_RSP_SPI_B4) |
| 42 | #define MMC_RSP_SPI_R4 (MMC_RSP_SPI_S1|MMC_RSP_SPI_B4) |
| 43 | #define MMC_RSP_SPI_R5 (MMC_RSP_SPI_S1|MMC_RSP_SPI_S2) |
| 44 | #define MMC_RSP_SPI_R7 (MMC_RSP_SPI_S1|MMC_RSP_SPI_B4) |
| 45 | |
| 46 | #define mmc_spi_resp_type(cmd) ((cmd)->flags & \ |
| 47 | (MMC_RSP_SPI_S1|MMC_RSP_SPI_BUSY|MMC_RSP_SPI_S2|MMC_RSP_SPI_B4)) |
| 48 | |
| 49 | /* |
Russell King | e922517 | 2006-02-02 12:23:12 +0000 | [diff] [blame] | 50 | * These are the command types. |
| 51 | */ |
Russell King | 5bd546a | 2006-02-17 20:23:29 +0000 | [diff] [blame] | 52 | #define mmc_cmd_type(cmd) ((cmd)->flags & MMC_CMD_MASK) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | |
| 54 | unsigned int retries; /* max number of retries */ |
Ulf Hansson | f5c5179 | 2015-03-31 12:41:55 +0200 | [diff] [blame] | 55 | int error; /* command error */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 56 | |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 57 | /* |
| 58 | * Standard errno values are used for errors, but some have specific |
| 59 | * meaning in the MMC layer: |
| 60 | * |
| 61 | * ETIMEDOUT Card took too long to respond |
| 62 | * EILSEQ Basic format problem with the received or sent data |
| 63 | * (e.g. CRC check failed, incorrect opcode in response |
| 64 | * or bad end bit) |
| 65 | * EINVAL Request cannot be performed because of restrictions |
| 66 | * in hardware and/or the driver |
| 67 | * ENOMEDIUM Host can determine that the slot is empty and is |
| 68 | * actively failing requests |
| 69 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 70 | |
Ulf Hansson | 1d4d774 | 2014-01-08 15:06:08 +0100 | [diff] [blame] | 71 | unsigned int busy_timeout; /* busy detect timeout in ms */ |
Maya Erez | 775a936 | 2013-04-18 15:41:55 +0300 | [diff] [blame] | 72 | /* Set this flag only for blocking sanitize request */ |
| 73 | bool sanitize_busy; |
Subhash Jadavani | 7ad7ea8 | 2014-12-04 15:07:32 +0200 | [diff] [blame] | 74 | /* Set this flag only for blocking bkops request */ |
| 75 | bool bkops_busy; |
Adrian Hunter | dfe86cb | 2010-08-11 14:17:46 -0700 | [diff] [blame] | 76 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 77 | struct mmc_data *data; /* data segment associated with cmd */ |
Erik Hovland | 8573b80 | 2005-10-28 16:28:04 +0100 | [diff] [blame] | 78 | struct mmc_request *mrq; /* associated request */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | }; |
| 80 | |
| 81 | struct mmc_data { |
| 82 | unsigned int timeout_ns; /* data timeout (in ns, max 80ms) */ |
| 83 | unsigned int timeout_clks; /* data timeout (in clocks) */ |
Pavel Pisa | 2c171bf | 2006-05-19 21:48:03 +0100 | [diff] [blame] | 84 | unsigned int blksz; /* data block size */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | unsigned int blocks; /* number of blocks */ |
Ulf Hansson | f5c5179 | 2015-03-31 12:41:55 +0200 | [diff] [blame] | 86 | int error; /* data error */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 87 | unsigned int flags; |
| 88 | |
| 89 | #define MMC_DATA_WRITE (1 << 8) |
| 90 | #define MMC_DATA_READ (1 << 9) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 91 | |
| 92 | unsigned int bytes_xfered; |
| 93 | |
| 94 | struct mmc_command *stop; /* stop command */ |
Erik Hovland | 8573b80 | 2005-10-28 16:28:04 +0100 | [diff] [blame] | 95 | struct mmc_request *mrq; /* associated request */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | |
| 97 | unsigned int sg_len; /* size of scatter list */ |
Chaotian Jing | 2084890 | 2015-06-15 19:20:48 +0800 | [diff] [blame] | 98 | int sg_count; /* mapped sg entries */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 99 | struct scatterlist *sg; /* I/O scatter list */ |
Per Forlin | aa8b683 | 2011-07-01 18:55:22 +0200 | [diff] [blame] | 100 | s32 host_cookie; /* host private data */ |
Asutosh Das | f066541 | 2012-07-27 18:10:19 +0530 | [diff] [blame] | 101 | bool fault_injected; /* fault injected */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | }; |
| 103 | |
Konstantin Dorfman | 2220eed | 2013-01-14 14:28:17 -0500 | [diff] [blame] | 104 | struct mmc_host; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | struct mmc_request { |
Andrei Warkentin | d0c97cf | 2011-05-23 15:06:36 -0500 | [diff] [blame] | 106 | struct mmc_command *sbc; /* SET_BLOCK_COUNT for multiblock */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | struct mmc_command *cmd; |
| 108 | struct mmc_data *data; |
| 109 | struct mmc_command *stop; |
| 110 | |
Per Forlin | aa8b683 | 2011-07-01 18:55:22 +0200 | [diff] [blame] | 111 | struct completion completion; |
Adrian Hunter | 5163af5 | 2016-08-16 13:44:11 +0300 | [diff] [blame] | 112 | struct completion cmd_completion; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 113 | void (*done)(struct mmc_request *);/* completion function */ |
Konstantin Dorfman | 2220eed | 2013-01-14 14:28:17 -0500 | [diff] [blame] | 114 | struct mmc_host *host; |
Venkat Gopalakrishnan | e95d7bf | 2015-05-29 16:51:43 -0700 | [diff] [blame] | 115 | struct mmc_cmdq_req *cmdq_req; |
Sahitya Tummala | c44de84 | 2015-05-08 11:12:30 +0530 | [diff] [blame] | 116 | struct request *req; |
Adrian Hunter | 5163af5 | 2016-08-16 13:44:11 +0300 | [diff] [blame] | 117 | |
| 118 | /* Allow other commands during this ongoing data transfer or busy wait */ |
| 119 | bool cap_cmd_during_tfr; |
Mohan Srinivasan | e2d8878 | 2016-12-14 15:55:36 -0800 | [diff] [blame] | 120 | ktime_t io_start; |
| 121 | #ifdef CONFIG_BLOCK |
| 122 | int lat_hist_enabled; |
| 123 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | }; |
| 125 | |
Dov Levenglick | a029639 | 2015-06-24 19:51:58 +0300 | [diff] [blame] | 126 | struct mmc_bus_ops { |
| 127 | void (*remove)(struct mmc_host *); |
| 128 | void (*detect)(struct mmc_host *); |
| 129 | int (*pre_suspend)(struct mmc_host *); |
| 130 | int (*suspend)(struct mmc_host *); |
| 131 | int (*resume)(struct mmc_host *); |
| 132 | int (*runtime_suspend)(struct mmc_host *); |
| 133 | int (*runtime_resume)(struct mmc_host *); |
| 134 | int (*runtime_idle)(struct mmc_host *); |
| 135 | int (*power_save)(struct mmc_host *); |
| 136 | int (*power_restore)(struct mmc_host *); |
| 137 | int (*alive)(struct mmc_host *); |
| 138 | int (*shutdown)(struct mmc_host *); |
| 139 | int (*reset)(struct mmc_host *); |
| 140 | int (*change_bus_speed)(struct mmc_host *, unsigned long *); |
| 141 | }; |
| 142 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 143 | struct mmc_card; |
Per Forlin | aa8b683 | 2011-07-01 18:55:22 +0200 | [diff] [blame] | 144 | struct mmc_async_req; |
Venkat Gopalakrishnan | e95d7bf | 2015-05-29 16:51:43 -0700 | [diff] [blame] | 145 | struct mmc_cmdq_req; |
| 146 | |
Asutosh Das | 02e3086 | 2015-05-20 16:52:04 +0530 | [diff] [blame] | 147 | extern int mmc_cmdq_discard_queue(struct mmc_host *host, u32 tasks); |
Asutosh Das | 31150ae | 2015-05-21 17:21:07 +0530 | [diff] [blame] | 148 | extern int mmc_cmdq_halt(struct mmc_host *host, bool enable); |
Ritesh Harjani | cd62f1b | 2015-07-13 10:52:36 +0530 | [diff] [blame] | 149 | extern int mmc_cmdq_halt_on_empty_queue(struct mmc_host *host); |
Ritesh Harjani | 121cdec | 2015-09-27 21:51:01 +0530 | [diff] [blame] | 150 | extern void mmc_cmdq_post_req(struct mmc_host *host, int tag, int err); |
Venkat Gopalakrishnan | e95d7bf | 2015-05-29 16:51:43 -0700 | [diff] [blame] | 151 | extern int mmc_cmdq_start_req(struct mmc_host *host, |
| 152 | struct mmc_cmdq_req *cmdq_req); |
Asutosh Das | 5238e02 | 2015-04-23 16:00:45 +0530 | [diff] [blame] | 153 | extern int mmc_cmdq_prepare_flush(struct mmc_command *cmd); |
Sahitya Tummala | 9433a13 | 2015-06-09 09:38:36 +0530 | [diff] [blame] | 154 | extern int mmc_cmdq_wait_for_dcmd(struct mmc_host *host, |
| 155 | struct mmc_cmdq_req *cmdq_req); |
| 156 | extern int mmc_cmdq_erase(struct mmc_cmdq_req *cmdq_req, |
| 157 | struct mmc_card *card, unsigned int from, unsigned int nr, |
| 158 | unsigned int arg); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | |
Jaehoon Chung | 950d56a | 2012-09-17 08:42:02 +0000 | [diff] [blame] | 160 | extern int mmc_stop_bkops(struct mmc_card *); |
| 161 | extern int mmc_read_bkops_status(struct mmc_card *); |
Per Forlin | aa8b683 | 2011-07-01 18:55:22 +0200 | [diff] [blame] | 162 | extern struct mmc_async_req *mmc_start_req(struct mmc_host *, |
| 163 | struct mmc_async_req *, int *); |
Jaehoon Chung | eb0d8f1 | 2011-10-18 01:26:42 -0400 | [diff] [blame] | 164 | extern int mmc_interrupt_hpi(struct mmc_card *); |
Pierre Ossman | 67a61c4 | 2007-07-11 20:22:11 +0200 | [diff] [blame] | 165 | extern void mmc_wait_for_req(struct mmc_host *, struct mmc_request *); |
Adrian Hunter | 5163af5 | 2016-08-16 13:44:11 +0300 | [diff] [blame] | 166 | extern void mmc_wait_for_req_done(struct mmc_host *host, |
| 167 | struct mmc_request *mrq); |
| 168 | extern bool mmc_is_req_done(struct mmc_host *host, struct mmc_request *mrq); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 169 | extern int mmc_wait_for_cmd(struct mmc_host *, struct mmc_command *, int); |
John Calixto | cb87ea2 | 2011-04-26 18:56:29 -0400 | [diff] [blame] | 170 | extern int mmc_app_cmd(struct mmc_host *, struct mmc_card *); |
Pierre Ossman | da7fbe5 | 2006-12-24 22:46:55 +0100 | [diff] [blame] | 171 | extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *, |
Pierre Ossman | 335eadf | 2005-09-06 15:18:50 -0700 | [diff] [blame] | 172 | struct mmc_command *, int); |
Dov Levenglick | a029639 | 2015-06-24 19:51:58 +0300 | [diff] [blame] | 173 | extern void mmc_check_bkops(struct mmc_card *card); |
| 174 | extern void mmc_start_manual_bkops(struct mmc_card *card); |
Andrei Warkentin | d3a8d95 | 2011-04-11 16:13:43 -0500 | [diff] [blame] | 175 | extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int); |
Asutosh Das | 5238e02 | 2015-04-23 16:00:45 +0530 | [diff] [blame] | 176 | extern int __mmc_switch_cmdq_mode(struct mmc_command *cmd, u8 set, u8 index, |
| 177 | u8 value, unsigned int timeout_ms, |
| 178 | bool use_busy_signal, bool ignore_timeout); |
Chaotian Jing | 9979dbe | 2015-10-27 14:24:28 +0800 | [diff] [blame] | 179 | extern int mmc_send_tuning(struct mmc_host *host, u32 opcode, int *cmd_error); |
Ulf Hansson | e21aa51 | 2014-10-17 11:32:32 +0200 | [diff] [blame] | 180 | extern int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd); |
Dov Levenglick | a029639 | 2015-06-24 19:51:58 +0300 | [diff] [blame] | 181 | extern int mmc_set_auto_bkops(struct mmc_card *card, bool enable); |
Asutosh Das | af6a03e | 2017-03-30 14:41:16 -0700 | [diff] [blame] | 182 | extern int mmc_suspend_clk_scaling(struct mmc_host *host); |
Ankit Jain | 0d55bf0 | 2017-09-19 17:43:02 +0530 | [diff] [blame] | 183 | extern void mmc_flush_detect_work(struct mmc_host *host); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 184 | |
Adrian Hunter | dfe86cb | 2010-08-11 14:17:46 -0700 | [diff] [blame] | 185 | #define MMC_ERASE_ARG 0x00000000 |
| 186 | #define MMC_SECURE_ERASE_ARG 0x80000000 |
| 187 | #define MMC_TRIM_ARG 0x00000001 |
Kyungmin Park | b3bf915 | 2011-10-18 09:34:04 +0900 | [diff] [blame] | 188 | #define MMC_DISCARD_ARG 0x00000003 |
Adrian Hunter | dfe86cb | 2010-08-11 14:17:46 -0700 | [diff] [blame] | 189 | #define MMC_SECURE_TRIM1_ARG 0x80000001 |
| 190 | #define MMC_SECURE_TRIM2_ARG 0x80008000 |
| 191 | |
| 192 | #define MMC_SECURE_ARGS 0x80000000 |
| 193 | #define MMC_TRIM_ARGS 0x00008001 |
| 194 | |
| 195 | extern int mmc_erase(struct mmc_card *card, unsigned int from, unsigned int nr, |
| 196 | unsigned int arg); |
| 197 | extern int mmc_can_erase(struct mmc_card *card); |
| 198 | extern int mmc_can_trim(struct mmc_card *card); |
Kyungmin Park | b3bf915 | 2011-10-18 09:34:04 +0900 | [diff] [blame] | 199 | extern int mmc_can_discard(struct mmc_card *card); |
Kyungmin Park | d9ddd62 | 2011-10-14 14:15:48 +0900 | [diff] [blame] | 200 | extern int mmc_can_sanitize(struct mmc_card *card); |
Adrian Hunter | dfe86cb | 2010-08-11 14:17:46 -0700 | [diff] [blame] | 201 | extern int mmc_can_secure_erase_trim(struct mmc_card *card); |
| 202 | extern int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from, |
| 203 | unsigned int nr); |
Adrian Hunter | e056a1b | 2011-06-28 17:16:02 +0300 | [diff] [blame] | 204 | extern unsigned int mmc_calc_max_discard(struct mmc_card *card); |
Adrian Hunter | dfe86cb | 2010-08-11 14:17:46 -0700 | [diff] [blame] | 205 | |
Adrian Hunter | 0f8d8ea | 2010-08-24 13:20:26 +0300 | [diff] [blame] | 206 | extern int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen); |
Loic Pallardy | 67c79db | 2012-08-06 17:12:30 +0200 | [diff] [blame] | 207 | extern int mmc_set_blockcount(struct mmc_card *card, unsigned int blockcount, |
| 208 | bool is_rel_write); |
Adrian Hunter | b249951 | 2011-08-29 16:42:11 +0300 | [diff] [blame] | 209 | extern int mmc_hw_reset(struct mmc_host *host); |
Ritesh Harjani | c2f6cf0 | 2015-09-28 15:55:01 +0530 | [diff] [blame] | 210 | extern int mmc_cmdq_hw_reset(struct mmc_host *host); |
Adrian Hunter | b249951 | 2011-08-29 16:42:11 +0300 | [diff] [blame] | 211 | extern int mmc_can_reset(struct mmc_card *card); |
Adrian Hunter | 0f8d8ea | 2010-08-24 13:20:26 +0300 | [diff] [blame] | 212 | |
Pierre Ossman | b146d26 | 2007-07-24 19:16:54 +0200 | [diff] [blame] | 213 | extern void mmc_set_data_timeout(struct mmc_data *, const struct mmc_card *); |
Pierre Ossman | ad3868b | 2008-06-28 12:52:45 +0200 | [diff] [blame] | 214 | extern unsigned int mmc_align_data_size(struct mmc_card *, unsigned int); |
Russell King | d773d72 | 2006-09-07 15:57:12 +0100 | [diff] [blame] | 215 | |
Nicolas Pitre | 2342f33 | 2007-06-30 16:21:52 +0200 | [diff] [blame] | 216 | extern int __mmc_claim_host(struct mmc_host *host, atomic_t *abort); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 217 | extern void mmc_release_host(struct mmc_host *host); |
Veerabhadrarao Badiganti | bf795c5 | 2017-02-09 20:23:17 +0530 | [diff] [blame] | 218 | extern int mmc_try_claim_host(struct mmc_host *host, unsigned int delay); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 219 | |
Ulf Hansson | e94cfef | 2013-05-02 14:02:38 +0200 | [diff] [blame] | 220 | extern void mmc_get_card(struct mmc_card *card); |
| 221 | extern void mmc_put_card(struct mmc_card *card); |
Dov Levenglick | 2b67830 | 2015-07-01 14:24:20 +0300 | [diff] [blame] | 222 | extern void __mmc_put_card(struct mmc_card *card); |
Ulf Hansson | e94cfef | 2013-05-02 14:02:38 +0200 | [diff] [blame] | 223 | |
Sujit Reddy Thumma | 8ca66b4 | 2014-12-03 18:10:07 +0200 | [diff] [blame] | 224 | extern void mmc_set_ios(struct mmc_host *host); |
Seungwon Jeon | 881d1c2 | 2011-10-14 14:03:21 +0900 | [diff] [blame] | 225 | extern int mmc_flush_cache(struct mmc_card *); |
Sahitya Tummala | 61868a4 | 2015-05-28 16:54:19 +0530 | [diff] [blame] | 226 | extern int mmc_cache_barrier(struct mmc_card *); |
Seungwon Jeon | 881d1c2 | 2011-10-14 14:03:21 +0900 | [diff] [blame] | 227 | |
Adrian Hunter | d304950 | 2011-11-28 16:22:00 +0200 | [diff] [blame] | 228 | extern int mmc_detect_card_removed(struct mmc_host *host); |
| 229 | |
Dov Levenglick | ea221d4 | 2015-06-28 16:45:41 +0300 | [diff] [blame] | 230 | extern void mmc_blk_init_bkops_statistics(struct mmc_card *card); |
| 231 | |
Talel Shenhar | 339a4e1 | 2015-06-29 10:50:19 +0300 | [diff] [blame] | 232 | extern void mmc_deferred_scaling(struct mmc_host *host); |
| 233 | extern void mmc_cmdq_clk_scaling_start_busy(struct mmc_host *host, |
| 234 | bool lock_needed); |
| 235 | extern void mmc_cmdq_clk_scaling_stop_busy(struct mmc_host *host, |
| 236 | bool lock_needed, bool is_cmdq_dcmd); |
Wanhyeong Ryu | 608a998 | 2017-11-01 15:51:40 +0800 | [diff] [blame] | 237 | extern int mmc_recovery_fallback_lower_speed(struct mmc_host *host); |
Talel Shenhar | 339a4e1 | 2015-06-29 10:50:19 +0300 | [diff] [blame] | 238 | |
Nicolas Pitre | 2342f33 | 2007-06-30 16:21:52 +0200 | [diff] [blame] | 239 | /** |
| 240 | * mmc_claim_host - exclusively claim a host |
| 241 | * @host: mmc host to claim |
| 242 | * |
| 243 | * Claim a host for a set of operations. |
| 244 | */ |
| 245 | static inline void mmc_claim_host(struct mmc_host *host) |
| 246 | { |
| 247 | __mmc_claim_host(host, NULL); |
| 248 | } |
| 249 | |
Haijun Zhang | 6e9e318 | 2013-08-26 09:19:22 +0800 | [diff] [blame] | 250 | struct device_node; |
Anton Vorontsov | 86e8286 | 2008-11-26 22:54:17 +0300 | [diff] [blame] | 251 | extern u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max); |
Haijun Zhang | 6e9e318 | 2013-08-26 09:19:22 +0800 | [diff] [blame] | 252 | extern int mmc_of_parse_voltage(struct device_node *np, u32 *mask); |
Anton Vorontsov | 86e8286 | 2008-11-26 22:54:17 +0300 | [diff] [blame] | 253 | |
Robert P. J. Day | 100e918 | 2011-05-27 16:04:03 -0400 | [diff] [blame] | 254 | #endif /* LINUX_MMC_CORE_H */ |