2019-06-04 16:11:33 +08:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-only */
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* linux/include/linux/mmc/card.h
|
|
|
|
|
*
|
|
|
|
|
* Card driver specific definitions.
|
|
|
|
|
*/
|
|
|
|
|
#ifndef LINUX_MMC_CARD_H
|
|
|
|
|
#define LINUX_MMC_CARD_H
|
|
|
|
|
|
2012-01-31 00:46:54 +08:00
|
|
|
#include <linux/device.h>
|
2011-04-12 06:02:15 +08:00
|
|
|
#include <linux/mod_devicetable.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
struct mmc_cid {
|
|
|
|
|
unsigned int manfid;
|
|
|
|
|
char prod_name[8];
|
2013-02-28 04:19:17 +08:00
|
|
|
unsigned char prv;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int serial;
|
|
|
|
|
unsigned short oemid;
|
|
|
|
|
unsigned short year;
|
|
|
|
|
unsigned char hwrev;
|
|
|
|
|
unsigned char fwrev;
|
|
|
|
|
unsigned char month;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct mmc_csd {
|
2010-08-11 09:01:36 +08:00
|
|
|
unsigned char structure;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned char mmca_vsn;
|
|
|
|
|
unsigned short cmdclass;
|
2017-08-02 11:12:42 +08:00
|
|
|
unsigned short taac_clks;
|
|
|
|
|
unsigned int taac_ns;
|
2011-05-05 14:49:03 +08:00
|
|
|
unsigned int c_size;
|
2006-05-03 00:24:59 +08:00
|
|
|
unsigned int r2w_factor;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int max_dtr;
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-12 05:17:46 +08:00
|
|
|
unsigned int erase_size; /* In sectors */
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int read_blkbits;
|
2006-01-04 06:38:44 +08:00
|
|
|
unsigned int write_blkbits;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int capacity;
|
2006-01-04 06:38:44 +08:00
|
|
|
unsigned int read_partial:1,
|
|
|
|
|
read_misalign:1,
|
2006-01-04 20:40:39 +08:00
|
|
|
write_partial:1,
|
2014-08-19 16:45:51 +08:00
|
|
|
write_misalign:1,
|
|
|
|
|
dsr_imp:1;
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
2006-10-21 18:35:02 +08:00
|
|
|
struct mmc_ext_csd {
|
2009-09-23 07:44:34 +08:00
|
|
|
u8 rev;
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-12 05:17:46 +08:00
|
|
|
u8 erase_group_def;
|
|
|
|
|
u8 sec_feature_support;
|
2011-04-01 07:40:00 +08:00
|
|
|
u8 rel_sectors;
|
|
|
|
|
u8 rel_param;
|
2020-05-01 21:53:01 +08:00
|
|
|
bool enhanced_rpmb_supported;
|
2011-04-12 07:10:25 +08:00
|
|
|
u8 part_config;
|
2011-10-14 13:03:21 +08:00
|
|
|
u8 cache_ctrl;
|
2011-08-29 21:42:11 +08:00
|
|
|
u8 rst_n_function;
|
2013-02-06 16:01:43 +08:00
|
|
|
u8 max_packed_writes;
|
|
|
|
|
u8 max_packed_reads;
|
|
|
|
|
u8 packed_event_en;
|
2011-04-12 07:10:25 +08:00
|
|
|
unsigned int part_time; /* Units: ms */
|
2009-09-23 07:44:34 +08:00
|
|
|
unsigned int sa_timeout; /* Units: 100ns */
|
2011-09-23 13:15:29 +08:00
|
|
|
unsigned int generic_cmd6_time; /* Units: 10ms */
|
2011-10-13 14:34:16 +08:00
|
|
|
unsigned int power_off_longtime; /* Units: ms */
|
2012-10-06 00:45:39 +08:00
|
|
|
u8 power_off_notification; /* state */
|
2006-10-21 18:35:02 +08:00
|
|
|
unsigned int hs_max_dtr;
|
2014-04-23 16:08:44 +08:00
|
|
|
unsigned int hs200_max_dtr;
|
2012-04-25 15:17:37 +08:00
|
|
|
#define MMC_HIGH_26_MAX_DTR 26000000
|
|
|
|
|
#define MMC_HIGH_52_MAX_DTR 52000000
|
|
|
|
|
#define MMC_HIGH_DDR_MAX_DTR 52000000
|
|
|
|
|
#define MMC_HS200_MAX_DTR 200000000
|
2007-02-18 05:15:27 +08:00
|
|
|
unsigned int sectors;
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-12 05:17:46 +08:00
|
|
|
unsigned int hc_erase_size; /* In sectors */
|
|
|
|
|
unsigned int hc_erase_timeout; /* In milliseconds */
|
|
|
|
|
unsigned int sec_trim_mult; /* Secure trim multiplier */
|
|
|
|
|
unsigned int sec_erase_mult; /* Secure erase multiplier */
|
|
|
|
|
unsigned int trim_timeout; /* In milliseconds */
|
2014-09-15 23:47:09 +08:00
|
|
|
bool partition_setting_completed; /* enable bit */
|
2011-01-22 04:09:41 +08:00
|
|
|
unsigned long long enhanced_area_offset; /* Units: Byte */
|
|
|
|
|
unsigned int enhanced_area_size; /* Units: KB */
|
2011-10-14 13:03:21 +08:00
|
|
|
unsigned int cache_size; /* Units: KB */
|
2011-10-18 13:26:42 +08:00
|
|
|
bool hpi_en; /* HPI enablebit */
|
|
|
|
|
bool hpi; /* HPI support bit */
|
|
|
|
|
unsigned int hpi_cmd; /* cmd used as HPI */
|
2012-09-17 16:42:02 +08:00
|
|
|
bool bkops; /* background support bit */
|
2015-01-29 16:49:43 +08:00
|
|
|
bool man_bkops_en; /* manual bkops enable bit */
|
2017-02-08 00:00:01 +08:00
|
|
|
bool auto_bkops_en; /* auto bkops enable bit */
|
2011-12-21 15:39:17 +08:00
|
|
|
unsigned int data_sector_size; /* 512 bytes or 4KB */
|
|
|
|
|
unsigned int data_tag_unit_size; /* DATA TAG UNIT size */
|
2011-12-02 15:51:06 +08:00
|
|
|
unsigned int boot_ro_lock; /* ro lock support */
|
|
|
|
|
bool boot_ro_lockable;
|
2014-10-17 02:27:16 +08:00
|
|
|
bool ffu_capable; /* Firmware upgrade support */
|
2017-03-13 20:36:37 +08:00
|
|
|
bool cmdq_en; /* Command Queue enabled */
|
2016-11-29 18:09:16 +08:00
|
|
|
bool cmdq_support; /* Command Queue supported */
|
|
|
|
|
unsigned int cmdq_depth; /* Command Queue depth */
|
2014-10-17 02:27:16 +08:00
|
|
|
#define MMC_FIRMWARE_LEN 8
|
|
|
|
|
u8 fwrev[MMC_FIRMWARE_LEN]; /* FW version */
|
2013-01-08 14:07:39 +08:00
|
|
|
u8 raw_exception_status; /* 54 */
|
2011-07-08 00:04:55 +08:00
|
|
|
u8 raw_partition_support; /* 160 */
|
2012-11-18 07:08:24 +08:00
|
|
|
u8 raw_rpmb_size_mult; /* 168 */
|
2011-07-08 00:04:55 +08:00
|
|
|
u8 raw_erased_mem_count; /* 181 */
|
2016-05-26 09:56:22 +08:00
|
|
|
u8 strobe_support; /* 184 */
|
2011-07-08 00:04:55 +08:00
|
|
|
u8 raw_ext_csd_structure; /* 194 */
|
|
|
|
|
u8 raw_card_type; /* 196 */
|
2015-02-06 20:12:57 +08:00
|
|
|
u8 raw_driver_strength; /* 197 */
|
2011-10-18 13:26:42 +08:00
|
|
|
u8 out_of_int_time; /* 198 */
|
2013-04-23 22:27:07 +08:00
|
|
|
u8 raw_pwr_cl_52_195; /* 200 */
|
|
|
|
|
u8 raw_pwr_cl_26_195; /* 201 */
|
|
|
|
|
u8 raw_pwr_cl_52_360; /* 202 */
|
|
|
|
|
u8 raw_pwr_cl_26_360; /* 203 */
|
|
|
|
|
u8 raw_s_a_timeout; /* 217 */
|
2011-07-08 00:04:55 +08:00
|
|
|
u8 raw_hc_erase_gap_size; /* 221 */
|
|
|
|
|
u8 raw_erase_timeout_mult; /* 223 */
|
|
|
|
|
u8 raw_hc_erase_grp_size; /* 224 */
|
|
|
|
|
u8 raw_sec_trim_mult; /* 229 */
|
|
|
|
|
u8 raw_sec_erase_mult; /* 230 */
|
|
|
|
|
u8 raw_sec_feature_support;/* 231 */
|
|
|
|
|
u8 raw_trim_mult; /* 232 */
|
2013-04-23 22:27:07 +08:00
|
|
|
u8 raw_pwr_cl_200_195; /* 236 */
|
|
|
|
|
u8 raw_pwr_cl_200_360; /* 237 */
|
|
|
|
|
u8 raw_pwr_cl_ddr_52_195; /* 238 */
|
|
|
|
|
u8 raw_pwr_cl_ddr_52_360; /* 239 */
|
2014-04-23 16:14:58 +08:00
|
|
|
u8 raw_pwr_cl_ddr_200_360; /* 253 */
|
2012-09-17 16:42:02 +08:00
|
|
|
u8 raw_bkops_status; /* 246 */
|
2011-07-08 00:04:55 +08:00
|
|
|
u8 raw_sectors[4]; /* 212 - 4 bytes */
|
2016-12-22 11:37:34 +08:00
|
|
|
u8 pre_eol_info; /* 267 */
|
|
|
|
|
u8 device_life_time_est_typ_a; /* 268 */
|
|
|
|
|
u8 device_life_time_est_typ_b; /* 269 */
|
2011-10-18 08:34:04 +08:00
|
|
|
|
|
|
|
|
unsigned int feature_support;
|
|
|
|
|
#define MMC_DISCARD_FEATURE BIT(0) /* CMD38 feature */
|
2006-10-21 18:35:02 +08:00
|
|
|
};
|
|
|
|
|
|
2005-09-07 06:18:53 +08:00
|
|
|
struct sd_scr {
|
|
|
|
|
unsigned char sda_vsn;
|
2011-05-05 14:48:58 +08:00
|
|
|
unsigned char sda_spec3;
|
2019-02-06 19:28:06 +08:00
|
|
|
unsigned char sda_spec4;
|
|
|
|
|
unsigned char sda_specx;
|
2005-09-07 06:18:53 +08:00
|
|
|
unsigned char bus_widths;
|
|
|
|
|
#define SD_SCR_BUS_WIDTH_1 (1<<0)
|
|
|
|
|
#define SD_SCR_BUS_WIDTH_4 (1<<2)
|
2011-05-24 04:06:38 +08:00
|
|
|
unsigned char cmds;
|
|
|
|
|
#define SD_SCR_CMD20_SUPPORT (1<<0)
|
|
|
|
|
#define SD_SCR_CMD23_SUPPORT (1<<1)
|
2005-09-07 06:18:53 +08:00
|
|
|
};
|
|
|
|
|
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-12 05:17:46 +08:00
|
|
|
struct sd_ssr {
|
|
|
|
|
unsigned int au; /* In sectors */
|
|
|
|
|
unsigned int erase_timeout; /* In milliseconds */
|
|
|
|
|
unsigned int erase_offset; /* In milliseconds */
|
|
|
|
|
};
|
|
|
|
|
|
2006-11-09 06:03:10 +08:00
|
|
|
struct sd_switch_caps {
|
|
|
|
|
unsigned int hs_max_dtr;
|
2011-05-05 14:49:01 +08:00
|
|
|
unsigned int uhs_max_dtr;
|
2011-11-08 21:43:08 +08:00
|
|
|
#define HIGH_SPEED_MAX_DTR 50000000
|
2011-05-05 14:49:01 +08:00
|
|
|
#define UHS_SDR104_MAX_DTR 208000000
|
|
|
|
|
#define UHS_SDR50_MAX_DTR 100000000
|
|
|
|
|
#define UHS_DDR50_MAX_DTR 50000000
|
|
|
|
|
#define UHS_SDR25_MAX_DTR UHS_DDR50_MAX_DTR
|
|
|
|
|
#define UHS_SDR12_MAX_DTR 25000000
|
2018-05-24 11:38:25 +08:00
|
|
|
#define DEFAULT_SPEED_MAX_DTR UHS_SDR12_MAX_DTR
|
2011-05-05 14:48:58 +08:00
|
|
|
unsigned int sd3_bus_mode;
|
2011-05-05 14:49:01 +08:00
|
|
|
#define UHS_SDR12_BUS_SPEED 0
|
2011-11-08 21:43:08 +08:00
|
|
|
#define HIGH_SPEED_BUS_SPEED 1
|
2011-05-05 14:49:01 +08:00
|
|
|
#define UHS_SDR25_BUS_SPEED 1
|
|
|
|
|
#define UHS_SDR50_BUS_SPEED 2
|
|
|
|
|
#define UHS_SDR104_BUS_SPEED 3
|
|
|
|
|
#define UHS_DDR50_BUS_SPEED 4
|
|
|
|
|
|
2011-11-08 21:43:08 +08:00
|
|
|
#define SD_MODE_HIGH_SPEED (1 << HIGH_SPEED_BUS_SPEED)
|
2011-05-05 14:49:01 +08:00
|
|
|
#define SD_MODE_UHS_SDR12 (1 << UHS_SDR12_BUS_SPEED)
|
|
|
|
|
#define SD_MODE_UHS_SDR25 (1 << UHS_SDR25_BUS_SPEED)
|
|
|
|
|
#define SD_MODE_UHS_SDR50 (1 << UHS_SDR50_BUS_SPEED)
|
|
|
|
|
#define SD_MODE_UHS_SDR104 (1 << UHS_SDR104_BUS_SPEED)
|
|
|
|
|
#define SD_MODE_UHS_DDR50 (1 << UHS_DDR50_BUS_SPEED)
|
2011-05-05 14:48:58 +08:00
|
|
|
unsigned int sd3_drv_type;
|
2011-05-05 14:48:59 +08:00
|
|
|
#define SD_DRIVER_TYPE_B 0x01
|
|
|
|
|
#define SD_DRIVER_TYPE_A 0x02
|
|
|
|
|
#define SD_DRIVER_TYPE_C 0x04
|
|
|
|
|
#define SD_DRIVER_TYPE_D 0x08
|
2011-05-05 14:48:58 +08:00
|
|
|
unsigned int sd3_curr_limit;
|
2011-05-05 14:49:02 +08:00
|
|
|
#define SD_SET_CURRENT_LIMIT_200 0
|
|
|
|
|
#define SD_SET_CURRENT_LIMIT_400 1
|
|
|
|
|
#define SD_SET_CURRENT_LIMIT_600 2
|
|
|
|
|
#define SD_SET_CURRENT_LIMIT_800 3
|
2012-05-28 09:36:33 +08:00
|
|
|
#define SD_SET_CURRENT_NO_CHANGE (-1)
|
2011-05-05 14:49:02 +08:00
|
|
|
|
|
|
|
|
#define SD_MAX_CURRENT_200 (1 << SD_SET_CURRENT_LIMIT_200)
|
|
|
|
|
#define SD_MAX_CURRENT_400 (1 << SD_SET_CURRENT_LIMIT_400)
|
|
|
|
|
#define SD_MAX_CURRENT_600 (1 << SD_SET_CURRENT_LIMIT_600)
|
|
|
|
|
#define SD_MAX_CURRENT_800 (1 << SD_SET_CURRENT_LIMIT_800)
|
2006-11-09 06:03:10 +08:00
|
|
|
};
|
|
|
|
|
|
2007-06-12 02:25:43 +08:00
|
|
|
struct sdio_cccr {
|
|
|
|
|
unsigned int sdio_vsn;
|
|
|
|
|
unsigned int sd_vsn;
|
|
|
|
|
unsigned int multi_block:1,
|
|
|
|
|
low_speed:1,
|
|
|
|
|
wide_bus:1,
|
|
|
|
|
high_power:1,
|
2009-09-23 07:45:07 +08:00
|
|
|
high_speed:1,
|
|
|
|
|
disable_cd:1;
|
2007-06-12 02:25:43 +08:00
|
|
|
};
|
|
|
|
|
|
2007-07-30 21:15:30 +08:00
|
|
|
struct sdio_cis {
|
|
|
|
|
unsigned short vendor;
|
|
|
|
|
unsigned short device;
|
|
|
|
|
unsigned short blksize;
|
|
|
|
|
unsigned int max_dtr;
|
|
|
|
|
};
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
struct mmc_host;
|
2007-05-26 19:48:18 +08:00
|
|
|
struct sdio_func;
|
2007-07-30 21:15:30 +08:00
|
|
|
struct sdio_func_tuple;
|
2017-03-13 20:36:36 +08:00
|
|
|
struct mmc_queue_req;
|
2007-05-26 19:48:18 +08:00
|
|
|
|
|
|
|
|
#define SDIO_MAX_FUNCS 7
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2011-10-06 22:41:38 +08:00
|
|
|
/* The number of MMC physical partitions. These consist of:
|
2014-08-13 13:34:01 +08:00
|
|
|
* boot partitions (2), general purpose partitions (4) and
|
|
|
|
|
* RPMB partition (1) in MMC v4.4.
|
2011-10-06 22:41:38 +08:00
|
|
|
*/
|
|
|
|
|
#define MMC_NUM_BOOT_PARTITION 2
|
|
|
|
|
#define MMC_NUM_GP_PARTITION 4
|
2014-08-13 13:34:01 +08:00
|
|
|
#define MMC_NUM_PHY_PARTITION 7
|
2011-10-12 23:43:14 +08:00
|
|
|
#define MAX_MMC_PART_NAME_LEN 20
|
2011-10-06 22:41:38 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* MMC Physical partitions
|
|
|
|
|
*/
|
|
|
|
|
struct mmc_part {
|
2019-11-17 09:00:45 +08:00
|
|
|
u64 size; /* partition size (in bytes) */
|
2011-10-06 22:41:38 +08:00
|
|
|
unsigned int part_cfg; /* partition type */
|
2011-10-12 23:43:14 +08:00
|
|
|
char name[MAX_MMC_PART_NAME_LEN];
|
2011-10-06 22:41:38 +08:00
|
|
|
bool force_ro; /* to make boot parts RO by default */
|
2011-12-02 15:51:06 +08:00
|
|
|
unsigned int area_type;
|
|
|
|
|
#define MMC_BLK_DATA_AREA_MAIN (1<<0)
|
|
|
|
|
#define MMC_BLK_DATA_AREA_BOOT (1<<1)
|
|
|
|
|
#define MMC_BLK_DATA_AREA_GP (1<<2)
|
2012-11-18 07:08:24 +08:00
|
|
|
#define MMC_BLK_DATA_AREA_RPMB (1<<3)
|
2011-10-06 22:41:38 +08:00
|
|
|
};
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* MMC device
|
|
|
|
|
*/
|
|
|
|
|
struct mmc_card {
|
|
|
|
|
struct mmc_host *host; /* the host this device belongs to */
|
|
|
|
|
struct device dev; /* the device */
|
2013-09-13 17:31:33 +08:00
|
|
|
u32 ocr; /* the current OCR setting */
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int rca; /* relative card address of device */
|
2006-12-26 22:25:58 +08:00
|
|
|
unsigned int type; /* card type */
|
|
|
|
|
#define MMC_TYPE_MMC 0 /* MMC card */
|
|
|
|
|
#define MMC_TYPE_SD 1 /* SD card */
|
2007-05-22 02:23:20 +08:00
|
|
|
#define MMC_TYPE_SDIO 2 /* SDIO card */
|
2010-08-11 09:01:40 +08:00
|
|
|
#define MMC_TYPE_SD_COMBO 3 /* SD combo (IO+mem) card */
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int state; /* (our) card state */
|
2009-09-23 07:45:18 +08:00
|
|
|
unsigned int quirks; /* card quirks */
|
2018-04-10 15:00:31 +08:00
|
|
|
unsigned int quirk_max_rate; /* max rate set by quirks */
|
2009-09-23 07:45:18 +08:00
|
|
|
#define MMC_QUIRK_LENIENT_FN0 (1<<0) /* allow SDIO FN0 writes outside of the VS CCCR range */
|
2010-03-06 05:43:25 +08:00
|
|
|
#define MMC_QUIRK_BLKSZ_FOR_BYTE_MODE (1<<1) /* use func->cur_blksize */
|
|
|
|
|
/* for byte mode */
|
2010-08-11 09:01:50 +08:00
|
|
|
#define MMC_QUIRK_NONSTD_SDIO (1<<2) /* non-standard SDIO card attached */
|
|
|
|
|
/* (missing CIA registers) */
|
2011-04-05 22:50:14 +08:00
|
|
|
#define MMC_QUIRK_NONSTD_FUNC_IF (1<<4) /* SDIO card has nonstd function interfaces */
|
2011-04-05 23:02:25 +08:00
|
|
|
#define MMC_QUIRK_DISABLE_CD (1<<5) /* disconnect CD/DAT[3] resistor */
|
2011-04-13 04:06:53 +08:00
|
|
|
#define MMC_QUIRK_INAND_CMD38 (1<<6) /* iNAND devices have broken CMD38 */
|
2011-05-24 04:06:36 +08:00
|
|
|
#define MMC_QUIRK_BLK_NO_CMD23 (1<<7) /* Avoid CMD23 for regular multiblock */
|
2011-09-15 23:43:04 +08:00
|
|
|
#define MMC_QUIRK_BROKEN_BYTE_MODE_512 (1<<8) /* Avoid sending 512 bytes in */
|
2013-11-27 07:39:20 +08:00
|
|
|
/* byte mode */
|
2011-11-03 16:44:12 +08:00
|
|
|
#define MMC_QUIRK_LONG_READ_TIME (1<<9) /* Data read time > CSD says */
|
2012-08-29 14:05:36 +08:00
|
|
|
#define MMC_QUIRK_SEC_ERASE_TRIM_BROKEN (1<<10) /* Skip secure for erase/trim */
|
2013-11-27 07:39:20 +08:00
|
|
|
#define MMC_QUIRK_BROKEN_IRQ_POLLING (1<<11) /* Polling SDIO_CCCR_INTx could create a fake interrupt */
|
2015-08-12 13:08:32 +08:00
|
|
|
#define MMC_QUIRK_TRIM_BROKEN (1<<12) /* Skip trim */
|
2016-06-10 06:09:31 +08:00
|
|
|
#define MMC_QUIRK_BROKEN_HPI (1<<13) /* Disable broken HPI support */
|
2015-08-12 13:08:32 +08:00
|
|
|
|
2017-03-13 20:36:38 +08:00
|
|
|
bool reenable_cmdq; /* Re-enable Command Queue */
|
|
|
|
|
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-12 05:17:46 +08:00
|
|
|
unsigned int erase_size; /* erase size in sectors */
|
|
|
|
|
unsigned int erase_shift; /* if erase unit is power 2 */
|
|
|
|
|
unsigned int pref_erase; /* in sectors */
|
2015-06-23 17:43:52 +08:00
|
|
|
unsigned int eg_boundary; /* don't cross erase-group boundaries */
|
2019-02-06 19:28:05 +08:00
|
|
|
unsigned int erase_arg; /* erase / trim / discard */
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-12 05:17:46 +08:00
|
|
|
u8 erased_byte; /* value of erased bytes */
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
u32 raw_cid[4]; /* raw card CID */
|
|
|
|
|
u32 raw_csd[4]; /* raw card CSD */
|
2005-09-07 06:18:53 +08:00
|
|
|
u32 raw_scr[2]; /* raw card SCR */
|
2016-08-14 16:46:36 +08:00
|
|
|
u32 raw_ssr[16]; /* raw card SSR */
|
2005-04-17 06:20:36 +08:00
|
|
|
struct mmc_cid cid; /* card identification */
|
|
|
|
|
struct mmc_csd csd; /* card specific */
|
2006-10-21 18:35:02 +08:00
|
|
|
struct mmc_ext_csd ext_csd; /* mmc v4 extended card specific */
|
2005-09-07 06:18:53 +08:00
|
|
|
struct sd_scr scr; /* extra SD information */
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-12 05:17:46 +08:00
|
|
|
struct sd_ssr ssr; /* yet more SD information */
|
2006-11-09 06:03:10 +08:00
|
|
|
struct sd_switch_caps sw_caps; /* switch (CMD6) caps */
|
2007-05-26 19:48:18 +08:00
|
|
|
|
|
|
|
|
unsigned int sdio_funcs; /* number of SDIO functions */
|
mmc: core: Re-work HW reset for SDIO cards
It have turned out that it's not a good idea to unconditionally do a power
cycle and then to re-initialize the SDIO card, as currently done through
mmc_hw_reset() -> mmc_sdio_hw_reset(). This because there may be multiple
SDIO func drivers probed, who also shares the same SDIO card.
To address these scenarios, one may be tempted to use a notification
mechanism, as to allow the core to inform each of the probed func drivers,
about an ongoing HW reset. However, supporting such an operation from the
func driver point of view, may not be entirely trivial.
Therefore, let's use a more simplistic approach to solve the problem, by
instead forcing the card to be removed and re-detected, via scheduling a
rescan-work. In this way, we can rely on existing infrastructure, as the
func driver's ->remove() and ->probe() callbacks, becomes invoked to deal
with the cleanup and the re-initialization.
This solution may be considered as rather heavy, especially if a func
driver doesn't share its card with other func drivers. To address this,
let's keep the current immediate HW reset option as well, but run it only
when there is one func driver probed for the card.
Finally, to allow the caller of mmc_hw_reset(), to understand if the reset
is being asynchronously managed from a scheduled work, it returns 1
(propagated from mmc_sdio_hw_reset()). If the HW reset is executed
successfully and synchronously it returns 0, which maintains the existing
behaviour.
Reviewed-by: Douglas Anderson <dianders@chromium.org>
Tested-by: Douglas Anderson <dianders@chromium.org>
Cc: stable@vger.kernel.org # v5.4+
Signed-off-by: Ulf Hansson <ulf.hansson@linaro.org>
2019-10-17 21:25:36 +08:00
|
|
|
atomic_t sdio_funcs_probed; /* number of probed SDIO funcs */
|
2007-06-12 02:25:43 +08:00
|
|
|
struct sdio_cccr cccr; /* common card info */
|
2007-07-30 21:15:30 +08:00
|
|
|
struct sdio_cis cis; /* common tuple info */
|
2007-05-26 19:48:18 +08:00
|
|
|
struct sdio_func *sdio_func[SDIO_MAX_FUNCS]; /* SDIO functions (devices) */
|
2011-05-11 23:48:05 +08:00
|
|
|
struct sdio_func *sdio_single_irq; /* SDIO function when only one IRQ active */
|
2020-07-27 21:38:35 +08:00
|
|
|
u8 major_rev; /* major revision number */
|
|
|
|
|
u8 minor_rev; /* minor revision number */
|
2007-09-20 00:42:16 +08:00
|
|
|
unsigned num_info; /* number of info strings */
|
|
|
|
|
const char **info; /* info strings */
|
2007-07-30 21:15:30 +08:00
|
|
|
struct sdio_func_tuple *tuples; /* unknown common tuples */
|
2008-07-24 20:18:58 +08:00
|
|
|
|
2011-05-05 14:49:01 +08:00
|
|
|
unsigned int sd_bus_speed; /* Bus Speed Mode set for the card */
|
2014-04-23 16:07:58 +08:00
|
|
|
unsigned int mmc_avail_type; /* supported device type by both host and card */
|
2015-02-06 20:12:56 +08:00
|
|
|
unsigned int drive_strength; /* for UHS-I, HS200 or HS400 */
|
2011-05-05 14:49:01 +08:00
|
|
|
|
2008-07-24 20:18:58 +08:00
|
|
|
struct dentry *debugfs_root;
|
2011-10-06 22:41:38 +08:00
|
|
|
struct mmc_part part[MMC_NUM_PHY_PARTITION]; /* physical partitions */
|
|
|
|
|
unsigned int nr_parts;
|
2017-03-13 20:36:36 +08:00
|
|
|
|
2019-02-07 23:03:08 +08:00
|
|
|
struct workqueue_struct *complete_wq; /* Private workqueue */
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
2013-02-06 16:02:46 +08:00
|
|
|
static inline bool mmc_large_sector(struct mmc_card *card)
|
|
|
|
|
{
|
|
|
|
|
return card->ext_csd.data_sector_size == 4096;
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-25 02:41:55 +08:00
|
|
|
bool mmc_card_is_blockaddr(struct mmc_card *card);
|
|
|
|
|
|
2006-12-26 22:25:58 +08:00
|
|
|
#define mmc_card_mmc(c) ((c)->type == MMC_TYPE_MMC)
|
|
|
|
|
#define mmc_card_sd(c) ((c)->type == MMC_TYPE_SD)
|
2007-05-22 02:23:20 +08:00
|
|
|
#define mmc_card_sdio(c) ((c)->type == MMC_TYPE_SDIO)
|
2006-12-26 22:25:58 +08:00
|
|
|
|
2011-05-28 04:04:03 +08:00
|
|
|
#endif /* LINUX_MMC_CARD_H */
|