Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * linux/include/linux/mmc/card.h |
| 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 | * |
| 8 | * Card driver specific definitions. |
| 9 | */ |
| 10 | #ifndef LINUX_MMC_CARD_H |
| 11 | #define LINUX_MMC_CARD_H |
| 12 | |
Pierre Ossman | aaac1b4 | 2007-02-28 15:33:10 +0100 | [diff] [blame] | 13 | #include <linux/mmc/core.h> |
Andrei Warkentin | 32780cd | 2011-04-11 17:02:15 -0500 | [diff] [blame] | 14 | #include <linux/mod_devicetable.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | |
| 16 | struct mmc_cid { |
| 17 | unsigned int manfid; |
| 18 | char prod_name[8]; |
| 19 | unsigned int serial; |
| 20 | unsigned short oemid; |
| 21 | unsigned short year; |
| 22 | unsigned char hwrev; |
| 23 | unsigned char fwrev; |
| 24 | unsigned char month; |
| 25 | }; |
| 26 | |
| 27 | struct mmc_csd { |
Kyungmin Park | 6da24b7 | 2010-08-10 18:01:36 -0700 | [diff] [blame] | 28 | unsigned char structure; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | unsigned char mmca_vsn; |
| 30 | unsigned short cmdclass; |
| 31 | unsigned short tacc_clks; |
| 32 | unsigned int tacc_ns; |
Arindam Nath | 3a30351 | 2011-05-05 12:19:03 +0530 | [diff] [blame] | 33 | unsigned int c_size; |
Russell King | 37be4e7 | 2006-05-02 17:24:59 +0100 | [diff] [blame] | 34 | unsigned int r2w_factor; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 35 | unsigned int max_dtr; |
Adrian Hunter | dfe86cb | 2010-08-11 14:17:46 -0700 | [diff] [blame] | 36 | unsigned int erase_size; /* In sectors */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | unsigned int read_blkbits; |
Russell King | a6f6c96 | 2006-01-03 22:38:44 +0000 | [diff] [blame] | 38 | unsigned int write_blkbits; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | unsigned int capacity; |
Russell King | a6f6c96 | 2006-01-03 22:38:44 +0000 | [diff] [blame] | 40 | unsigned int read_partial:1, |
| 41 | read_misalign:1, |
Russell King | ce11a16 | 2006-01-04 12:40:39 +0000 | [diff] [blame] | 42 | write_partial:1, |
Russell King | a6f6c96 | 2006-01-03 22:38:44 +0000 | [diff] [blame] | 43 | write_misalign:1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | }; |
| 45 | |
Philip Langdale | bce40a3 | 2006-10-21 12:35:02 +0200 | [diff] [blame] | 46 | struct mmc_ext_csd { |
Jarkko Lavinen | b1ebe38 | 2009-09-22 16:44:34 -0700 | [diff] [blame] | 47 | u8 rev; |
Adrian Hunter | dfe86cb | 2010-08-11 14:17:46 -0700 | [diff] [blame] | 48 | u8 erase_group_def; |
| 49 | u8 sec_feature_support; |
Andrei Warkentin | f4c5522 | 2011-03-31 18:40:00 -0500 | [diff] [blame] | 50 | u8 rel_sectors; |
| 51 | u8 rel_param; |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 52 | u8 part_config; |
Seungwon Jeon | 881d1c2 | 2011-10-14 14:03:21 +0900 | [diff] [blame] | 53 | u8 cache_ctrl; |
Adrian Hunter | b249951 | 2011-08-29 16:42:11 +0300 | [diff] [blame] | 54 | u8 rst_n_function; |
Andrei Warkentin | 371a689 | 2011-04-11 18:10:25 -0500 | [diff] [blame] | 55 | unsigned int part_time; /* Units: ms */ |
Jarkko Lavinen | b1ebe38 | 2009-09-22 16:44:34 -0700 | [diff] [blame] | 56 | unsigned int sa_timeout; /* Units: 100ns */ |
Seungwon Jeon | b23cf0b | 2011-09-23 14:15:29 +0900 | [diff] [blame] | 57 | unsigned int generic_cmd6_time; /* Units: 10ms */ |
Girish K S | bec8726 | 2011-10-13 12:04:16 +0530 | [diff] [blame] | 58 | unsigned int power_off_longtime; /* Units: ms */ |
Philip Langdale | bce40a3 | 2006-10-21 12:35:02 +0200 | [diff] [blame] | 59 | unsigned int hs_max_dtr; |
Pierre Ossman | 85a18ad | 2007-02-17 22:15:27 +0100 | [diff] [blame] | 60 | unsigned int sectors; |
Hanumath Prasad | dfc13e8 | 2010-09-30 17:37:23 -0400 | [diff] [blame] | 61 | unsigned int card_type; |
Adrian Hunter | dfe86cb | 2010-08-11 14:17:46 -0700 | [diff] [blame] | 62 | unsigned int hc_erase_size; /* In sectors */ |
| 63 | unsigned int hc_erase_timeout; /* In milliseconds */ |
| 64 | unsigned int sec_trim_mult; /* Secure trim multiplier */ |
| 65 | unsigned int sec_erase_mult; /* Secure erase multiplier */ |
| 66 | unsigned int trim_timeout; /* In milliseconds */ |
Chuanxiao Dong | 709de99 | 2011-01-22 04:09:41 +0800 | [diff] [blame] | 67 | bool enhanced_area_en; /* enable bit */ |
| 68 | unsigned long long enhanced_area_offset; /* Units: Byte */ |
| 69 | unsigned int enhanced_area_size; /* Units: KB */ |
Seungwon Jeon | 881d1c2 | 2011-10-14 14:03:21 +0900 | [diff] [blame] | 70 | unsigned int cache_size; /* Units: KB */ |
Jaehoon Chung | eb0d8f1 | 2011-10-18 01:26:42 -0400 | [diff] [blame] | 71 | bool hpi_en; /* HPI enablebit */ |
| 72 | bool hpi; /* HPI support bit */ |
| 73 | unsigned int hpi_cmd; /* cmd used as HPI */ |
Johan Rudholm | add710e | 2011-12-02 08:51:06 +0100 | [diff] [blame] | 74 | unsigned int boot_ro_lock; /* ro lock support */ |
| 75 | bool boot_ro_lockable; |
Philip Rakity | f39b2dd | 2011-07-07 09:04:55 -0700 | [diff] [blame] | 76 | u8 raw_partition_support; /* 160 */ |
| 77 | u8 raw_erased_mem_count; /* 181 */ |
| 78 | u8 raw_ext_csd_structure; /* 194 */ |
| 79 | u8 raw_card_type; /* 196 */ |
Jaehoon Chung | eb0d8f1 | 2011-10-18 01:26:42 -0400 | [diff] [blame] | 80 | u8 out_of_int_time; /* 198 */ |
Philip Rakity | f39b2dd | 2011-07-07 09:04:55 -0700 | [diff] [blame] | 81 | u8 raw_s_a_timeout; /* 217 */ |
| 82 | u8 raw_hc_erase_gap_size; /* 221 */ |
| 83 | u8 raw_erase_timeout_mult; /* 223 */ |
| 84 | u8 raw_hc_erase_grp_size; /* 224 */ |
| 85 | u8 raw_sec_trim_mult; /* 229 */ |
| 86 | u8 raw_sec_erase_mult; /* 230 */ |
| 87 | u8 raw_sec_feature_support;/* 231 */ |
| 88 | u8 raw_trim_mult; /* 232 */ |
| 89 | u8 raw_sectors[4]; /* 212 - 4 bytes */ |
Kyungmin Park | b3bf915 | 2011-10-18 09:34:04 +0900 | [diff] [blame] | 90 | |
| 91 | unsigned int feature_support; |
| 92 | #define MMC_DISCARD_FEATURE BIT(0) /* CMD38 feature */ |
Philip Langdale | bce40a3 | 2006-10-21 12:35:02 +0200 | [diff] [blame] | 93 | }; |
| 94 | |
Pierre Ossman | b57c43a | 2005-09-06 15:18:53 -0700 | [diff] [blame] | 95 | struct sd_scr { |
| 96 | unsigned char sda_vsn; |
Arindam Nath | 013909c | 2011-05-05 12:18:58 +0530 | [diff] [blame] | 97 | unsigned char sda_spec3; |
Pierre Ossman | b57c43a | 2005-09-06 15:18:53 -0700 | [diff] [blame] | 98 | unsigned char bus_widths; |
| 99 | #define SD_SCR_BUS_WIDTH_1 (1<<0) |
| 100 | #define SD_SCR_BUS_WIDTH_4 (1<<2) |
Andrei Warkentin | f0d8997 | 2011-05-23 15:06:38 -0500 | [diff] [blame] | 101 | unsigned char cmds; |
| 102 | #define SD_SCR_CMD20_SUPPORT (1<<0) |
| 103 | #define SD_SCR_CMD23_SUPPORT (1<<1) |
Pierre Ossman | b57c43a | 2005-09-06 15:18:53 -0700 | [diff] [blame] | 104 | }; |
| 105 | |
Adrian Hunter | dfe86cb | 2010-08-11 14:17:46 -0700 | [diff] [blame] | 106 | struct sd_ssr { |
| 107 | unsigned int au; /* In sectors */ |
| 108 | unsigned int erase_timeout; /* In milliseconds */ |
| 109 | unsigned int erase_offset; /* In milliseconds */ |
| 110 | }; |
| 111 | |
Pierre Ossman | 7ccd266 | 2006-11-08 23:03:10 +0100 | [diff] [blame] | 112 | struct sd_switch_caps { |
| 113 | unsigned int hs_max_dtr; |
Arindam Nath | 49c468f | 2011-05-05 12:19:01 +0530 | [diff] [blame] | 114 | unsigned int uhs_max_dtr; |
Qiang Liu | fffe5d5 | 2011-11-08 08:43:08 -0500 | [diff] [blame] | 115 | #define HIGH_SPEED_MAX_DTR 50000000 |
Arindam Nath | 49c468f | 2011-05-05 12:19:01 +0530 | [diff] [blame] | 116 | #define UHS_SDR104_MAX_DTR 208000000 |
| 117 | #define UHS_SDR50_MAX_DTR 100000000 |
| 118 | #define UHS_DDR50_MAX_DTR 50000000 |
| 119 | #define UHS_SDR25_MAX_DTR UHS_DDR50_MAX_DTR |
| 120 | #define UHS_SDR12_MAX_DTR 25000000 |
Arindam Nath | 013909c | 2011-05-05 12:18:58 +0530 | [diff] [blame] | 121 | unsigned int sd3_bus_mode; |
Arindam Nath | 49c468f | 2011-05-05 12:19:01 +0530 | [diff] [blame] | 122 | #define UHS_SDR12_BUS_SPEED 0 |
Qiang Liu | fffe5d5 | 2011-11-08 08:43:08 -0500 | [diff] [blame] | 123 | #define HIGH_SPEED_BUS_SPEED 1 |
Arindam Nath | 49c468f | 2011-05-05 12:19:01 +0530 | [diff] [blame] | 124 | #define UHS_SDR25_BUS_SPEED 1 |
| 125 | #define UHS_SDR50_BUS_SPEED 2 |
| 126 | #define UHS_SDR104_BUS_SPEED 3 |
| 127 | #define UHS_DDR50_BUS_SPEED 4 |
| 128 | |
Qiang Liu | fffe5d5 | 2011-11-08 08:43:08 -0500 | [diff] [blame] | 129 | #define SD_MODE_HIGH_SPEED (1 << HIGH_SPEED_BUS_SPEED) |
Arindam Nath | 49c468f | 2011-05-05 12:19:01 +0530 | [diff] [blame] | 130 | #define SD_MODE_UHS_SDR12 (1 << UHS_SDR12_BUS_SPEED) |
| 131 | #define SD_MODE_UHS_SDR25 (1 << UHS_SDR25_BUS_SPEED) |
| 132 | #define SD_MODE_UHS_SDR50 (1 << UHS_SDR50_BUS_SPEED) |
| 133 | #define SD_MODE_UHS_SDR104 (1 << UHS_SDR104_BUS_SPEED) |
| 134 | #define SD_MODE_UHS_DDR50 (1 << UHS_DDR50_BUS_SPEED) |
Arindam Nath | 013909c | 2011-05-05 12:18:58 +0530 | [diff] [blame] | 135 | unsigned int sd3_drv_type; |
Arindam Nath | d6d50a1 | 2011-05-05 12:18:59 +0530 | [diff] [blame] | 136 | #define SD_DRIVER_TYPE_B 0x01 |
| 137 | #define SD_DRIVER_TYPE_A 0x02 |
| 138 | #define SD_DRIVER_TYPE_C 0x04 |
| 139 | #define SD_DRIVER_TYPE_D 0x08 |
Arindam Nath | 013909c | 2011-05-05 12:18:58 +0530 | [diff] [blame] | 140 | unsigned int sd3_curr_limit; |
Arindam Nath | 5371c92 | 2011-05-05 12:19:02 +0530 | [diff] [blame] | 141 | #define SD_SET_CURRENT_LIMIT_200 0 |
| 142 | #define SD_SET_CURRENT_LIMIT_400 1 |
| 143 | #define SD_SET_CURRENT_LIMIT_600 2 |
| 144 | #define SD_SET_CURRENT_LIMIT_800 3 |
| 145 | |
| 146 | #define SD_MAX_CURRENT_200 (1 << SD_SET_CURRENT_LIMIT_200) |
| 147 | #define SD_MAX_CURRENT_400 (1 << SD_SET_CURRENT_LIMIT_400) |
| 148 | #define SD_MAX_CURRENT_600 (1 << SD_SET_CURRENT_LIMIT_600) |
| 149 | #define SD_MAX_CURRENT_800 (1 << SD_SET_CURRENT_LIMIT_800) |
Pierre Ossman | 7ccd266 | 2006-11-08 23:03:10 +0100 | [diff] [blame] | 150 | }; |
| 151 | |
Pierre Ossman | 35c66c1 | 2007-06-11 20:25:43 +0200 | [diff] [blame] | 152 | struct sdio_cccr { |
| 153 | unsigned int sdio_vsn; |
| 154 | unsigned int sd_vsn; |
| 155 | unsigned int multi_block:1, |
| 156 | low_speed:1, |
| 157 | wide_bus:1, |
| 158 | high_power:1, |
Ohad Ben-Cohen | 006ebd5 | 2009-09-22 16:45:07 -0700 | [diff] [blame] | 159 | high_speed:1, |
| 160 | disable_cd:1; |
Pierre Ossman | 35c66c1 | 2007-06-11 20:25:43 +0200 | [diff] [blame] | 161 | }; |
| 162 | |
Pierre Ossman | 1a632f8 | 2007-07-30 15:15:30 +0200 | [diff] [blame] | 163 | struct sdio_cis { |
| 164 | unsigned short vendor; |
| 165 | unsigned short device; |
| 166 | unsigned short blksize; |
| 167 | unsigned int max_dtr; |
| 168 | }; |
| 169 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 170 | struct mmc_host; |
Pierre Ossman | e29a7d7 | 2007-05-26 13:48:18 +0200 | [diff] [blame] | 171 | struct sdio_func; |
Pierre Ossman | 1a632f8 | 2007-07-30 15:15:30 +0200 | [diff] [blame] | 172 | struct sdio_func_tuple; |
Pierre Ossman | e29a7d7 | 2007-05-26 13:48:18 +0200 | [diff] [blame] | 173 | |
| 174 | #define SDIO_MAX_FUNCS 7 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 175 | |
Namjae Jeon | e0c368d | 2011-10-06 23:41:38 +0900 | [diff] [blame] | 176 | /* The number of MMC physical partitions. These consist of: |
| 177 | * boot partitions (2), general purpose partitions (4) in MMC v4.4. |
| 178 | */ |
| 179 | #define MMC_NUM_BOOT_PARTITION 2 |
| 180 | #define MMC_NUM_GP_PARTITION 4 |
| 181 | #define MMC_NUM_PHY_PARTITION 6 |
Namjae Jeon | a6029e1 | 2011-10-13 00:43:14 +0900 | [diff] [blame] | 182 | #define MAX_MMC_PART_NAME_LEN 20 |
Namjae Jeon | e0c368d | 2011-10-06 23:41:38 +0900 | [diff] [blame] | 183 | |
| 184 | /* |
| 185 | * MMC Physical partitions |
| 186 | */ |
| 187 | struct mmc_part { |
| 188 | unsigned int size; /* partition size (in bytes) */ |
| 189 | unsigned int part_cfg; /* partition type */ |
Namjae Jeon | a6029e1 | 2011-10-13 00:43:14 +0900 | [diff] [blame] | 190 | char name[MAX_MMC_PART_NAME_LEN]; |
Namjae Jeon | e0c368d | 2011-10-06 23:41:38 +0900 | [diff] [blame] | 191 | bool force_ro; /* to make boot parts RO by default */ |
Johan Rudholm | add710e | 2011-12-02 08:51:06 +0100 | [diff] [blame] | 192 | unsigned int area_type; |
| 193 | #define MMC_BLK_DATA_AREA_MAIN (1<<0) |
| 194 | #define MMC_BLK_DATA_AREA_BOOT (1<<1) |
| 195 | #define MMC_BLK_DATA_AREA_GP (1<<2) |
Namjae Jeon | e0c368d | 2011-10-06 23:41:38 +0900 | [diff] [blame] | 196 | }; |
| 197 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 198 | /* |
| 199 | * MMC device |
| 200 | */ |
| 201 | struct mmc_card { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 202 | struct mmc_host *host; /* the host this device belongs to */ |
| 203 | struct device dev; /* the device */ |
| 204 | unsigned int rca; /* relative card address of device */ |
Pierre Ossman | 9c2c0af | 2006-12-26 15:25:58 +0100 | [diff] [blame] | 205 | unsigned int type; /* card type */ |
| 206 | #define MMC_TYPE_MMC 0 /* MMC card */ |
| 207 | #define MMC_TYPE_SD 1 /* SD card */ |
Pierre Ossman | 5c4e6f1 | 2007-05-21 20:23:20 +0200 | [diff] [blame] | 208 | #define MMC_TYPE_SDIO 2 /* SDIO card */ |
Michal Miroslaw | 7310ece | 2010-08-10 18:01:40 -0700 | [diff] [blame] | 209 | #define MMC_TYPE_SD_COMBO 3 /* SD combo (IO+mem) card */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 210 | unsigned int state; /* (our) card state */ |
| 211 | #define MMC_STATE_PRESENT (1<<0) /* present in sysfs */ |
Pierre Ossman | bd76631 | 2007-05-01 16:11:57 +0200 | [diff] [blame] | 212 | #define MMC_STATE_READONLY (1<<1) /* card is read-only */ |
| 213 | #define MMC_STATE_HIGHSPEED (1<<2) /* card is in high speed mode */ |
| 214 | #define MMC_STATE_BLOCKADDR (1<<3) /* card uses block-addressing */ |
Hanumath Prasad | dfc13e8 | 2010-09-30 17:37:23 -0400 | [diff] [blame] | 215 | #define MMC_STATE_HIGHSPEED_DDR (1<<4) /* card is in high speed mode */ |
Arindam Nath | 3a30351 | 2011-05-05 12:19:03 +0530 | [diff] [blame] | 216 | #define MMC_STATE_ULTRAHIGHSPEED (1<<5) /* card is in ultra high speed mode */ |
| 217 | #define MMC_CARD_SDXC (1<<6) /* card is SDXC */ |
Adrian Hunter | d304950 | 2011-11-28 16:22:00 +0200 | [diff] [blame] | 218 | #define MMC_CARD_REMOVED (1<<7) /* card has been removed */ |
Girish K S | a4924c7 | 2012-01-11 14:04:52 -0500 | [diff] [blame] | 219 | #define MMC_STATE_HIGHSPEED_200 (1<<8) /* card is in HS200 mode */ |
Girish K S | 3e73c36 | 2012-01-31 15:44:03 +0530 | [diff] [blame^] | 220 | #define MMC_STATE_SLEEP (1<<9) /* card is in sleep state */ |
Ohad Ben-Cohen | 7c979ec | 2009-09-22 16:45:18 -0700 | [diff] [blame] | 221 | unsigned int quirks; /* card quirks */ |
| 222 | #define MMC_QUIRK_LENIENT_FN0 (1<<0) /* allow SDIO FN0 writes outside of the VS CCCR range */ |
Bing Zhao | 3fb7fb4 | 2010-03-05 13:43:25 -0800 | [diff] [blame] | 223 | #define MMC_QUIRK_BLKSZ_FOR_BYTE_MODE (1<<1) /* use func->cur_blksize */ |
| 224 | /* for byte mode */ |
Grazvydas Ignotas | 6f51be3 | 2010-08-10 18:01:50 -0700 | [diff] [blame] | 225 | #define MMC_QUIRK_NONSTD_SDIO (1<<2) /* non-standard SDIO card attached */ |
| 226 | /* (missing CIA registers) */ |
Pierre Tardy | db99350 | 2011-02-06 19:03:47 +0100 | [diff] [blame] | 227 | #define MMC_QUIRK_BROKEN_CLK_GATING (1<<3) /* clock gating the sdio bus will make card fail */ |
Ohad Ben-Cohen | eab4068 | 2011-04-05 17:50:14 +0300 | [diff] [blame] | 228 | #define MMC_QUIRK_NONSTD_FUNC_IF (1<<4) /* SDIO card has nonstd function interfaces */ |
Ohad Ben-Cohen | 2059a02 | 2011-04-05 18:02:25 +0300 | [diff] [blame] | 229 | #define MMC_QUIRK_DISABLE_CD (1<<5) /* disconnect CD/DAT[3] resistor */ |
Andrei Warkentin | 6a7a6b4 | 2011-04-12 15:06:53 -0500 | [diff] [blame] | 230 | #define MMC_QUIRK_INAND_CMD38 (1<<6) /* iNAND devices have broken CMD38 */ |
Andrei Warkentin | d0c97cf | 2011-05-23 15:06:36 -0500 | [diff] [blame] | 231 | #define MMC_QUIRK_BLK_NO_CMD23 (1<<7) /* Avoid CMD23 for regular multiblock */ |
Stefan Nilsson XK | 9a0da64 | 2011-09-15 17:43:04 +0200 | [diff] [blame] | 232 | #define MMC_QUIRK_BROKEN_BYTE_MODE_512 (1<<8) /* Avoid sending 512 bytes in */ |
Stefan Nilsson XK | 6de5fc9 | 2011-11-03 09:44:12 +0100 | [diff] [blame] | 233 | #define MMC_QUIRK_LONG_READ_TIME (1<<9) /* Data read time > CSD says */ |
Stefan Nilsson XK | 9a0da64 | 2011-09-15 17:43:04 +0200 | [diff] [blame] | 234 | /* byte mode */ |
Girish K S | bec8726 | 2011-10-13 12:04:16 +0530 | [diff] [blame] | 235 | unsigned int poweroff_notify_state; /* eMMC4.5 notify feature */ |
| 236 | #define MMC_NO_POWER_NOTIFICATION 0 |
| 237 | #define MMC_POWERED_ON 1 |
| 238 | #define MMC_POWEROFF_SHORT 2 |
| 239 | #define MMC_POWEROFF_LONG 3 |
Pierre Ossman | e29a7d7 | 2007-05-26 13:48:18 +0200 | [diff] [blame] | 240 | |
Adrian Hunter | dfe86cb | 2010-08-11 14:17:46 -0700 | [diff] [blame] | 241 | unsigned int erase_size; /* erase size in sectors */ |
| 242 | unsigned int erase_shift; /* if erase unit is power 2 */ |
| 243 | unsigned int pref_erase; /* in sectors */ |
| 244 | u8 erased_byte; /* value of erased bytes */ |
| 245 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 246 | u32 raw_cid[4]; /* raw card CID */ |
| 247 | u32 raw_csd[4]; /* raw card CSD */ |
Pierre Ossman | b57c43a | 2005-09-06 15:18:53 -0700 | [diff] [blame] | 248 | u32 raw_scr[2]; /* raw card SCR */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | struct mmc_cid cid; /* card identification */ |
| 250 | struct mmc_csd csd; /* card specific */ |
Philip Langdale | bce40a3 | 2006-10-21 12:35:02 +0200 | [diff] [blame] | 251 | struct mmc_ext_csd ext_csd; /* mmc v4 extended card specific */ |
Pierre Ossman | b57c43a | 2005-09-06 15:18:53 -0700 | [diff] [blame] | 252 | struct sd_scr scr; /* extra SD information */ |
Adrian Hunter | dfe86cb | 2010-08-11 14:17:46 -0700 | [diff] [blame] | 253 | struct sd_ssr ssr; /* yet more SD information */ |
Pierre Ossman | 7ccd266 | 2006-11-08 23:03:10 +0100 | [diff] [blame] | 254 | struct sd_switch_caps sw_caps; /* switch (CMD6) caps */ |
Pierre Ossman | e29a7d7 | 2007-05-26 13:48:18 +0200 | [diff] [blame] | 255 | |
| 256 | unsigned int sdio_funcs; /* number of SDIO functions */ |
Pierre Ossman | 35c66c1 | 2007-06-11 20:25:43 +0200 | [diff] [blame] | 257 | struct sdio_cccr cccr; /* common card info */ |
Pierre Ossman | 1a632f8 | 2007-07-30 15:15:30 +0200 | [diff] [blame] | 258 | struct sdio_cis cis; /* common tuple info */ |
Pierre Ossman | e29a7d7 | 2007-05-26 13:48:18 +0200 | [diff] [blame] | 259 | struct sdio_func *sdio_func[SDIO_MAX_FUNCS]; /* SDIO functions (devices) */ |
Stefan Nilsson XK | 06e8935 | 2011-05-11 17:48:05 +0200 | [diff] [blame] | 260 | struct sdio_func *sdio_single_irq; /* SDIO function when only one IRQ active */ |
Pierre Ossman | 759bdc7 | 2007-09-19 18:42:16 +0200 | [diff] [blame] | 261 | unsigned num_info; /* number of info strings */ |
| 262 | const char **info; /* info strings */ |
Pierre Ossman | 1a632f8 | 2007-07-30 15:15:30 +0200 | [diff] [blame] | 263 | struct sdio_func_tuple *tuples; /* unknown common tuples */ |
Haavard Skinnemoen | f4b7f92 | 2008-07-24 14:18:58 +0200 | [diff] [blame] | 264 | |
Arindam Nath | 49c468f | 2011-05-05 12:19:01 +0530 | [diff] [blame] | 265 | unsigned int sd_bus_speed; /* Bus Speed Mode set for the card */ |
| 266 | |
Haavard Skinnemoen | f4b7f92 | 2008-07-24 14:18:58 +0200 | [diff] [blame] | 267 | struct dentry *debugfs_root; |
Namjae Jeon | e0c368d | 2011-10-06 23:41:38 +0900 | [diff] [blame] | 268 | struct mmc_part part[MMC_NUM_PHY_PARTITION]; /* physical partitions */ |
| 269 | unsigned int nr_parts; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 270 | }; |
| 271 | |
Andrei Warkentin | 32780cd | 2011-04-11 17:02:15 -0500 | [diff] [blame] | 272 | /* |
Namjae Jeon | e0c368d | 2011-10-06 23:41:38 +0900 | [diff] [blame] | 273 | * This function fill contents in mmc_part. |
| 274 | */ |
| 275 | static inline void mmc_part_add(struct mmc_card *card, unsigned int size, |
Johan Rudholm | add710e | 2011-12-02 08:51:06 +0100 | [diff] [blame] | 276 | unsigned int part_cfg, char *name, int idx, bool ro, |
| 277 | int area_type) |
Namjae Jeon | e0c368d | 2011-10-06 23:41:38 +0900 | [diff] [blame] | 278 | { |
| 279 | card->part[card->nr_parts].size = size; |
| 280 | card->part[card->nr_parts].part_cfg = part_cfg; |
| 281 | sprintf(card->part[card->nr_parts].name, name, idx); |
| 282 | card->part[card->nr_parts].force_ro = ro; |
Johan Rudholm | add710e | 2011-12-02 08:51:06 +0100 | [diff] [blame] | 283 | card->part[card->nr_parts].area_type = area_type; |
Namjae Jeon | e0c368d | 2011-10-06 23:41:38 +0900 | [diff] [blame] | 284 | card->nr_parts++; |
| 285 | } |
| 286 | |
| 287 | /* |
Andrei Warkentin | 32780cd | 2011-04-11 17:02:15 -0500 | [diff] [blame] | 288 | * The world is not perfect and supplies us with broken mmc/sdio devices. |
| 289 | * For at least some of these bugs we need a work-around. |
| 290 | */ |
| 291 | |
| 292 | struct mmc_fixup { |
| 293 | /* CID-specific fields. */ |
| 294 | const char *name; |
| 295 | |
| 296 | /* Valid revision range */ |
| 297 | u64 rev_start, rev_end; |
| 298 | |
| 299 | unsigned int manfid; |
| 300 | unsigned short oemid; |
| 301 | |
| 302 | /* SDIO-specfic fields. You can use SDIO_ANY_ID here of course */ |
| 303 | u16 cis_vendor, cis_device; |
| 304 | |
| 305 | void (*vendor_fixup)(struct mmc_card *card, int data); |
| 306 | int data; |
| 307 | }; |
| 308 | |
Randy Dunlap | 853c6ca | 2011-04-12 12:59:09 -0400 | [diff] [blame] | 309 | #define CID_MANFID_ANY (-1u) |
Andrei Warkentin | 32780cd | 2011-04-11 17:02:15 -0500 | [diff] [blame] | 310 | #define CID_OEMID_ANY ((unsigned short) -1) |
| 311 | #define CID_NAME_ANY (NULL) |
| 312 | |
| 313 | #define END_FIXUP { 0 } |
| 314 | |
| 315 | #define _FIXUP_EXT(_name, _manfid, _oemid, _rev_start, _rev_end, \ |
| 316 | _cis_vendor, _cis_device, \ |
| 317 | _fixup, _data) \ |
| 318 | { \ |
| 319 | .name = (_name), \ |
| 320 | .manfid = (_manfid), \ |
| 321 | .oemid = (_oemid), \ |
| 322 | .rev_start = (_rev_start), \ |
| 323 | .rev_end = (_rev_end), \ |
| 324 | .cis_vendor = (_cis_vendor), \ |
| 325 | .cis_device = (_cis_device), \ |
| 326 | .vendor_fixup = (_fixup), \ |
| 327 | .data = (_data), \ |
| 328 | } |
| 329 | |
| 330 | #define MMC_FIXUP_REV(_name, _manfid, _oemid, _rev_start, _rev_end, \ |
| 331 | _fixup, _data) \ |
| 332 | _FIXUP_EXT(_name, _manfid, \ |
| 333 | _oemid, _rev_start, _rev_end, \ |
| 334 | SDIO_ANY_ID, SDIO_ANY_ID, \ |
| 335 | _fixup, _data) \ |
| 336 | |
| 337 | #define MMC_FIXUP(_name, _manfid, _oemid, _fixup, _data) \ |
| 338 | MMC_FIXUP_REV(_name, _manfid, _oemid, 0, -1ull, _fixup, _data) |
| 339 | |
| 340 | #define SDIO_FIXUP(_vendor, _device, _fixup, _data) \ |
| 341 | _FIXUP_EXT(CID_NAME_ANY, CID_MANFID_ANY, \ |
| 342 | CID_OEMID_ANY, 0, -1ull, \ |
| 343 | _vendor, _device, \ |
| 344 | _fixup, _data) \ |
| 345 | |
| 346 | #define cid_rev(hwrev, fwrev, year, month) \ |
| 347 | (((u64) hwrev) << 40 | \ |
| 348 | ((u64) fwrev) << 32 | \ |
| 349 | ((u64) year) << 16 | \ |
| 350 | ((u64) month)) |
| 351 | |
| 352 | #define cid_rev_card(card) \ |
| 353 | cid_rev(card->cid.hwrev, \ |
| 354 | card->cid.fwrev, \ |
| 355 | card->cid.year, \ |
| 356 | card->cid.month) |
| 357 | |
| 358 | /* |
Andrei Warkentin | c59de92 | 2011-05-23 15:06:35 -0500 | [diff] [blame] | 359 | * Unconditionally quirk add/remove. |
Andrei Warkentin | 32780cd | 2011-04-11 17:02:15 -0500 | [diff] [blame] | 360 | */ |
Andrei Warkentin | c59de92 | 2011-05-23 15:06:35 -0500 | [diff] [blame] | 361 | |
Andrei Warkentin | 32780cd | 2011-04-11 17:02:15 -0500 | [diff] [blame] | 362 | static inline void __maybe_unused add_quirk(struct mmc_card *card, int data) |
| 363 | { |
| 364 | card->quirks |= data; |
| 365 | } |
| 366 | |
Andrei Warkentin | 32780cd | 2011-04-11 17:02:15 -0500 | [diff] [blame] | 367 | static inline void __maybe_unused remove_quirk(struct mmc_card *card, int data) |
| 368 | { |
| 369 | card->quirks &= ~data; |
| 370 | } |
Pierre Tardy | 57f0adc | 2011-02-06 19:03:46 +0100 | [diff] [blame] | 371 | |
Pierre Ossman | 9c2c0af | 2006-12-26 15:25:58 +0100 | [diff] [blame] | 372 | #define mmc_card_mmc(c) ((c)->type == MMC_TYPE_MMC) |
| 373 | #define mmc_card_sd(c) ((c)->type == MMC_TYPE_SD) |
Pierre Ossman | 5c4e6f1 | 2007-05-21 20:23:20 +0200 | [diff] [blame] | 374 | #define mmc_card_sdio(c) ((c)->type == MMC_TYPE_SDIO) |
Pierre Ossman | 9c2c0af | 2006-12-26 15:25:58 +0100 | [diff] [blame] | 375 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 376 | #define mmc_card_present(c) ((c)->state & MMC_STATE_PRESENT) |
Pierre Ossman | a00fc09 | 2005-09-06 15:18:52 -0700 | [diff] [blame] | 377 | #define mmc_card_readonly(c) ((c)->state & MMC_STATE_READONLY) |
Philip Langdale | bce40a3 | 2006-10-21 12:35:02 +0200 | [diff] [blame] | 378 | #define mmc_card_highspeed(c) ((c)->state & MMC_STATE_HIGHSPEED) |
Girish K S | a4924c7 | 2012-01-11 14:04:52 -0500 | [diff] [blame] | 379 | #define mmc_card_hs200(c) ((c)->state & MMC_STATE_HIGHSPEED_200) |
Philip Langdale | fba68bd | 2007-01-04 06:57:32 -0800 | [diff] [blame] | 380 | #define mmc_card_blockaddr(c) ((c)->state & MMC_STATE_BLOCKADDR) |
Hanumath Prasad | dfc13e8 | 2010-09-30 17:37:23 -0400 | [diff] [blame] | 381 | #define mmc_card_ddr_mode(c) ((c)->state & MMC_STATE_HIGHSPEED_DDR) |
Philip Rakity | a303c53 | 2011-11-14 19:14:38 -0800 | [diff] [blame] | 382 | #define mmc_card_uhs(c) ((c)->state & MMC_STATE_ULTRAHIGHSPEED) |
| 383 | #define mmc_sd_card_uhs(c) ((c)->state & MMC_STATE_ULTRAHIGHSPEED) |
Arindam Nath | 3a30351 | 2011-05-05 12:19:03 +0530 | [diff] [blame] | 384 | #define mmc_card_ext_capacity(c) ((c)->state & MMC_CARD_SDXC) |
Adrian Hunter | d304950 | 2011-11-28 16:22:00 +0200 | [diff] [blame] | 385 | #define mmc_card_removed(c) ((c) && ((c)->state & MMC_CARD_REMOVED)) |
Girish K S | 3e73c36 | 2012-01-31 15:44:03 +0530 | [diff] [blame^] | 386 | #define mmc_card_is_sleep(c) ((c)->state & MMC_STATE_SLEEP) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 387 | |
| 388 | #define mmc_card_set_present(c) ((c)->state |= MMC_STATE_PRESENT) |
Pierre Ossman | a00fc09 | 2005-09-06 15:18:52 -0700 | [diff] [blame] | 389 | #define mmc_card_set_readonly(c) ((c)->state |= MMC_STATE_READONLY) |
Philip Langdale | bce40a3 | 2006-10-21 12:35:02 +0200 | [diff] [blame] | 390 | #define mmc_card_set_highspeed(c) ((c)->state |= MMC_STATE_HIGHSPEED) |
Girish K S | a4924c7 | 2012-01-11 14:04:52 -0500 | [diff] [blame] | 391 | #define mmc_card_set_hs200(c) ((c)->state |= MMC_STATE_HIGHSPEED_200) |
Philip Langdale | fba68bd | 2007-01-04 06:57:32 -0800 | [diff] [blame] | 392 | #define mmc_card_set_blockaddr(c) ((c)->state |= MMC_STATE_BLOCKADDR) |
Hanumath Prasad | dfc13e8 | 2010-09-30 17:37:23 -0400 | [diff] [blame] | 393 | #define mmc_card_set_ddr_mode(c) ((c)->state |= MMC_STATE_HIGHSPEED_DDR) |
Philip Rakity | a303c53 | 2011-11-14 19:14:38 -0800 | [diff] [blame] | 394 | #define mmc_card_set_uhs(c) ((c)->state |= MMC_STATE_ULTRAHIGHSPEED) |
Arindam Nath | 3a30351 | 2011-05-05 12:19:03 +0530 | [diff] [blame] | 395 | #define mmc_sd_card_set_uhs(c) ((c)->state |= MMC_STATE_ULTRAHIGHSPEED) |
| 396 | #define mmc_card_set_ext_capacity(c) ((c)->state |= MMC_CARD_SDXC) |
Adrian Hunter | d304950 | 2011-11-28 16:22:00 +0200 | [diff] [blame] | 397 | #define mmc_card_set_removed(c) ((c)->state |= MMC_CARD_REMOVED) |
Girish K S | 3e73c36 | 2012-01-31 15:44:03 +0530 | [diff] [blame^] | 398 | #define mmc_card_set_sleep(c) ((c)->state |= MMC_STATE_SLEEP) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 399 | |
Girish K S | 3e73c36 | 2012-01-31 15:44:03 +0530 | [diff] [blame^] | 400 | #define mmc_card_clr_sleep(c) ((c)->state &= ~MMC_STATE_SLEEP) |
Andrei Warkentin | c59de92 | 2011-05-23 15:06:35 -0500 | [diff] [blame] | 401 | /* |
| 402 | * Quirk add/remove for MMC products. |
| 403 | */ |
| 404 | |
| 405 | static inline void __maybe_unused add_quirk_mmc(struct mmc_card *card, int data) |
| 406 | { |
| 407 | if (mmc_card_mmc(card)) |
| 408 | card->quirks |= data; |
| 409 | } |
| 410 | |
| 411 | static inline void __maybe_unused remove_quirk_mmc(struct mmc_card *card, |
| 412 | int data) |
| 413 | { |
| 414 | if (mmc_card_mmc(card)) |
| 415 | card->quirks &= ~data; |
| 416 | } |
| 417 | |
| 418 | /* |
| 419 | * Quirk add/remove for SD products. |
| 420 | */ |
| 421 | |
| 422 | static inline void __maybe_unused add_quirk_sd(struct mmc_card *card, int data) |
| 423 | { |
| 424 | if (mmc_card_sd(card)) |
| 425 | card->quirks |= data; |
| 426 | } |
| 427 | |
| 428 | static inline void __maybe_unused remove_quirk_sd(struct mmc_card *card, |
| 429 | int data) |
| 430 | { |
| 431 | if (mmc_card_sd(card)) |
| 432 | card->quirks &= ~data; |
| 433 | } |
| 434 | |
Ohad Ben-Cohen | 7c979ec | 2009-09-22 16:45:18 -0700 | [diff] [blame] | 435 | static inline int mmc_card_lenient_fn0(const struct mmc_card *c) |
| 436 | { |
| 437 | return c->quirks & MMC_QUIRK_LENIENT_FN0; |
| 438 | } |
| 439 | |
Bing Zhao | 3fb7fb4 | 2010-03-05 13:43:25 -0800 | [diff] [blame] | 440 | static inline int mmc_blksz_for_byte_mode(const struct mmc_card *c) |
| 441 | { |
| 442 | return c->quirks & MMC_QUIRK_BLKSZ_FOR_BYTE_MODE; |
| 443 | } |
| 444 | |
Ohad Ben-Cohen | 2059a02 | 2011-04-05 18:02:25 +0300 | [diff] [blame] | 445 | static inline int mmc_card_disable_cd(const struct mmc_card *c) |
| 446 | { |
| 447 | return c->quirks & MMC_QUIRK_DISABLE_CD; |
| 448 | } |
| 449 | |
Ohad Ben-Cohen | eab4068 | 2011-04-05 17:50:14 +0300 | [diff] [blame] | 450 | static inline int mmc_card_nonstd_func_interface(const struct mmc_card *c) |
| 451 | { |
| 452 | return c->quirks & MMC_QUIRK_NONSTD_FUNC_IF; |
| 453 | } |
| 454 | |
Stefan Nilsson XK | 9a0da64 | 2011-09-15 17:43:04 +0200 | [diff] [blame] | 455 | static inline int mmc_card_broken_byte_mode_512(const struct mmc_card *c) |
| 456 | { |
| 457 | return c->quirks & MMC_QUIRK_BROKEN_BYTE_MODE_512; |
| 458 | } |
| 459 | |
Stefan Nilsson XK | 6de5fc9 | 2011-11-03 09:44:12 +0100 | [diff] [blame] | 460 | static inline int mmc_card_long_read_time(const struct mmc_card *c) |
| 461 | { |
| 462 | return c->quirks & MMC_QUIRK_LONG_READ_TIME; |
| 463 | } |
| 464 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 465 | #define mmc_card_name(c) ((c)->cid.prod_name) |
Kay Sievers | d1b2686 | 2008-11-08 21:37:46 +0100 | [diff] [blame] | 466 | #define mmc_card_id(c) (dev_name(&(c)->dev)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 467 | |
Andy Shevchenko | 265cdc9 | 2010-09-17 20:32:25 -0400 | [diff] [blame] | 468 | #define mmc_dev_to_card(d) container_of(d, struct mmc_card, dev) |
Andy Shevchenko | 453722b | 2010-08-20 10:46:46 +0300 | [diff] [blame] | 469 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 470 | #define mmc_list_to_card(l) container_of(l, struct mmc_card, node) |
| 471 | #define mmc_get_drvdata(c) dev_get_drvdata(&(c)->dev) |
| 472 | #define mmc_set_drvdata(c,d) dev_set_drvdata(&(c)->dev, d) |
| 473 | |
| 474 | /* |
| 475 | * MMC device driver (e.g., Flash card, I/O card...) |
| 476 | */ |
| 477 | struct mmc_driver { |
| 478 | struct device_driver drv; |
| 479 | int (*probe)(struct mmc_card *); |
| 480 | void (*remove)(struct mmc_card *); |
| 481 | int (*suspend)(struct mmc_card *, pm_message_t); |
| 482 | int (*resume)(struct mmc_card *); |
| 483 | }; |
| 484 | |
| 485 | extern int mmc_register_driver(struct mmc_driver *); |
| 486 | extern void mmc_unregister_driver(struct mmc_driver *); |
| 487 | |
Andrei Warkentin | 32780cd | 2011-04-11 17:02:15 -0500 | [diff] [blame] | 488 | extern void mmc_fixup_device(struct mmc_card *card, |
| 489 | const struct mmc_fixup *table); |
| 490 | |
Robert P. J. Day | 100e918 | 2011-05-27 16:04:03 -0400 | [diff] [blame] | 491 | #endif /* LINUX_MMC_CARD_H */ |