projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
net: smc91x: constify dev_pm_ops structures.
[linux-2.6-block.git] / drivers / mmc / core / mmc.c
CommitLineData
7ea239d9 1/*
70f10482 2 * linux/drivers/mmc/core/mmc.c
7ea239d9
PO		 3 *
4 * Copyright (C) 2003-2004 Russell King, All Rights Reserved.
5 * Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
6 * MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12
13#include <linux/err.h>
81f8a7be 14#include <linux/of.h>
5a0e3ad6 15#include <linux/slab.h>
0205a904 16#include <linux/stat.h>
0cb403a2 17#include <linux/pm_runtime.h>
7ea239d9
PO		 18
19#include <linux/mmc/host.h>
20#include <linux/mmc/card.h>
21#include <linux/mmc/mmc.h>
22
23#include "core.h"
4facdde1 24#include "card.h"
436f8daa 25#include "host.h"
4101c16a 26#include "bus.h"
7ea239d9 27#include "mmc_ops.h"
28fc64af 28#include "quirks.h"
4c4cb171 29#include "sd_ops.h"
7ea239d9 30
fe1b5700
UH		 31#define DEFAULT_CMD6_TIMEOUT_MS 500
32
7ea239d9
PO		 33static const unsigned int tran_exp[] = {
34 10000, 100000, 1000000, 10000000,
35 0, 0, 0, 0
36};
37
38static const unsigned char tran_mant[] = {
39 0, 10, 12, 13, 15, 20, 25, 30,
40 35, 40, 45, 50, 55, 60, 70, 80,
41};
42
43static const unsigned int tacc_exp[] = {
44 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000,
45};
46
47static const unsigned int tacc_mant[] = {
48 0, 10, 12, 13, 15, 20, 25, 30,
49 35, 40, 45, 50, 55, 60, 70, 80,
50};
51
52#define UNSTUFF_BITS(resp,start,size) \
53 ({ \
54 const int __size = size; \
55 const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \
56 const int __off = 3 - ((start) / 32); \
57 const int __shft = (start) & 31; \
58 u32 __res; \
59 \
60 __res = resp[__off] >> __shft; \
61 if (__size + __shft > 32) \
62 __res |= resp[__off-1] << ((32 - __shft) % 32); \
63 __res & __mask; \
64 })
65
66/*
67 * Given the decoded CSD structure, decode the raw CID to our CID structure.
68 */
bd766312 69static int mmc_decode_cid(struct mmc_card *card)
7ea239d9
PO		 70{
71 u32 *resp = card->raw_cid;
72
73 /*
74 * The selection of the format here is based upon published
75 * specs from sandisk and from what people have reported.
76 */
77 switch (card->csd.mmca_vsn) {
78 case 0: /* MMC v1.0 - v1.2 */
79 case 1: /* MMC v1.4 */
80 card->cid.manfid = UNSTUFF_BITS(resp, 104, 24);
81 card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8);
82 card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8);
83 card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8);
84 card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8);
85 card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8);
86 card->cid.prod_name[5] = UNSTUFF_BITS(resp, 56, 8);
87 card->cid.prod_name[6] = UNSTUFF_BITS(resp, 48, 8);
88 card->cid.hwrev = UNSTUFF_BITS(resp, 44, 4);
89 card->cid.fwrev = UNSTUFF_BITS(resp, 40, 4);
90 card->cid.serial = UNSTUFF_BITS(resp, 16, 24);
91 card->cid.month = UNSTUFF_BITS(resp, 12, 4);
92 card->cid.year = UNSTUFF_BITS(resp, 8, 4) + 1997;
93 break;
94
95 case 2: /* MMC v2.0 - v2.2 */
96 case 3: /* MMC v3.1 - v3.3 */
97 case 4: /* MMC v4 */
98 card->cid.manfid = UNSTUFF_BITS(resp, 120, 8);
99 card->cid.oemid = UNSTUFF_BITS(resp, 104, 16);
100 card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8);
101 card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8);
102 card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8);
103 card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8);
104 card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8);
105 card->cid.prod_name[5] = UNSTUFF_BITS(resp, 56, 8);
51e7e8b6 106 card->cid.prv = UNSTUFF_BITS(resp, 48, 8);
7ea239d9
PO		 107 card->cid.serial = UNSTUFF_BITS(resp, 16, 32);
108 card->cid.month = UNSTUFF_BITS(resp, 12, 4);
109 card->cid.year = UNSTUFF_BITS(resp, 8, 4) + 1997;
110 break;
111
112 default:
a3c76eb9 113 pr_err("%s: card has unknown MMCA version %d\n",
7ea239d9 114 mmc_hostname(card->host), card->csd.mmca_vsn);
bd766312 115 return -EINVAL;
7ea239d9 116 }
bd766312
PO		 117
118 return 0;
7ea239d9
PO		 119}
120
dfe86cba
AH		 121static void mmc_set_erase_size(struct mmc_card *card)
122{
123 if (card->ext_csd.erase_group_def & 1)
124 card->erase_size = card->ext_csd.hc_erase_size;
125 else
126 card->erase_size = card->csd.erase_size;
127
128 mmc_init_erase(card);
129}
130
7ea239d9
PO		 131/*
132 * Given a 128-bit response, decode to our card CSD structure.
133 */
bd766312 134static int mmc_decode_csd(struct mmc_card *card)
7ea239d9
PO		 135{
136 struct mmc_csd *csd = &card->csd;
dfe86cba 137 unsigned int e, m, a, b;
7ea239d9
PO		 138 u32 *resp = card->raw_csd;
139
140 /*
141 * We only understand CSD structure v1.1 and v1.2.
142 * v1.2 has extra information in bits 15, 11 and 10.
6da24b78 143 * We also support eMMC v4.4 & v4.41.
7ea239d9 144 */
6da24b78
KP		 145 csd->structure = UNSTUFF_BITS(resp, 126, 2);
146 if (csd->structure == 0) {
a3c76eb9 147 pr_err("%s: unrecognised CSD structure version %d\n",
6da24b78 148 mmc_hostname(card->host), csd->structure);
bd766312 149 return -EINVAL;
7ea239d9
PO		 150 }
151
152 csd->mmca_vsn = UNSTUFF_BITS(resp, 122, 4);
153 m = UNSTUFF_BITS(resp, 115, 4);
154 e = UNSTUFF_BITS(resp, 112, 3);
155 csd->tacc_ns = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
156 csd->tacc_clks = UNSTUFF_BITS(resp, 104, 8) * 100;
157
158 m = UNSTUFF_BITS(resp, 99, 4);
159 e = UNSTUFF_BITS(resp, 96, 3);
160 csd->max_dtr = tran_exp[e] * tran_mant[m];
161 csd->cmdclass = UNSTUFF_BITS(resp, 84, 12);
162
163 e = UNSTUFF_BITS(resp, 47, 3);
164 m = UNSTUFF_BITS(resp, 62, 12);
165 csd->capacity = (1 + m) << (e + 2);
166
167 csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
168 csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
169 csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
170 csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
3d705d14 171 csd->dsr_imp = UNSTUFF_BITS(resp, 76, 1);
7ea239d9
PO		 172 csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
173 csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
174 csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
bd766312 175
dfe86cba
AH		 176 if (csd->write_blkbits >= 9) {
177 a = UNSTUFF_BITS(resp, 42, 5);
178 b = UNSTUFF_BITS(resp, 37, 5);
179 csd->erase_size = (a + 1) * (b + 1);
180 csd->erase_size <<= csd->write_blkbits - 9;
181 }
182
bd766312 183 return 0;
7ea239d9
PO		 184}
185
96cf5f02
SJ		 186static void mmc_select_card_type(struct mmc_card *card)
187{
188 struct mmc_host *host = card->host;
0a5b6438 189 u8 card_type = card->ext_csd.raw_card_type;
5f1a4dd0 190 u32 caps = host->caps, caps2 = host->caps2;
577fb131 191 unsigned int hs_max_dtr = 0, hs200_max_dtr = 0;
2415c0ef 192 unsigned int avail_type = 0;
96cf5f02 193
2415c0ef
SJ		 194 if (caps & MMC_CAP_MMC_HIGHSPEED &&
195 card_type & EXT_CSD_CARD_TYPE_HS_26) {
96cf5f02 196 hs_max_dtr = MMC_HIGH_26_MAX_DTR;
2415c0ef
SJ		 197 avail_type |= EXT_CSD_CARD_TYPE_HS_26;
198 }
96cf5f02
SJ		 199
200 if (caps & MMC_CAP_MMC_HIGHSPEED &&
2415c0ef 201 card_type & EXT_CSD_CARD_TYPE_HS_52) {
96cf5f02 202 hs_max_dtr = MMC_HIGH_52_MAX_DTR;
2415c0ef
SJ		 203 avail_type |= EXT_CSD_CARD_TYPE_HS_52;
204 }
96cf5f02 205
20f921bb 206 if (caps & (MMC_CAP_1_8V_DDR | MMC_CAP_3_3V_DDR) &&
2415c0ef 207 card_type & EXT_CSD_CARD_TYPE_DDR_1_8V) {
96cf5f02 208 hs_max_dtr = MMC_HIGH_DDR_MAX_DTR;
2415c0ef
SJ		 209 avail_type |= EXT_CSD_CARD_TYPE_DDR_1_8V;
210 }
211
212 if (caps & MMC_CAP_1_2V_DDR &&
213 card_type & EXT_CSD_CARD_TYPE_DDR_1_2V) {
214 hs_max_dtr = MMC_HIGH_DDR_MAX_DTR;
215 avail_type |= EXT_CSD_CARD_TYPE_DDR_1_2V;
216 }
96cf5f02 217
2415c0ef
SJ		 218 if (caps2 & MMC_CAP2_HS200_1_8V_SDR &&
219 card_type & EXT_CSD_CARD_TYPE_HS200_1_8V) {
577fb131 220 hs200_max_dtr = MMC_HS200_MAX_DTR;
2415c0ef
SJ		 221 avail_type |= EXT_CSD_CARD_TYPE_HS200_1_8V;
222 }
223
224 if (caps2 & MMC_CAP2_HS200_1_2V_SDR &&
225 card_type & EXT_CSD_CARD_TYPE_HS200_1_2V) {
577fb131 226 hs200_max_dtr = MMC_HS200_MAX_DTR;
2415c0ef
SJ		 227 avail_type |= EXT_CSD_CARD_TYPE_HS200_1_2V;
228 }
96cf5f02 229
0a5b6438
SJ		 230 if (caps2 & MMC_CAP2_HS400_1_8V &&
231 card_type & EXT_CSD_CARD_TYPE_HS400_1_8V) {
232 hs200_max_dtr = MMC_HS200_MAX_DTR;
233 avail_type |= EXT_CSD_CARD_TYPE_HS400_1_8V;
234 }
235
236 if (caps2 & MMC_CAP2_HS400_1_2V &&
237 card_type & EXT_CSD_CARD_TYPE_HS400_1_2V) {
238 hs200_max_dtr = MMC_HS200_MAX_DTR;
239 avail_type |= EXT_CSD_CARD_TYPE_HS400_1_2V;
240 }
241
81ac2af6
SL		 242 if ((caps2 & MMC_CAP2_HS400_ES) &&
243 card->ext_csd.strobe_support &&
244 (avail_type & EXT_CSD_CARD_TYPE_HS400))
245 avail_type |= EXT_CSD_CARD_TYPE_HS400ES;
246
96cf5f02 247 card->ext_csd.hs_max_dtr = hs_max_dtr;
577fb131 248 card->ext_csd.hs200_max_dtr = hs200_max_dtr;
2415c0ef 249 card->mmc_avail_type = avail_type;
96cf5f02
SJ		 250}
251
b4493eea
GS		 252static void mmc_manage_enhanced_area(struct mmc_card *card, u8 *ext_csd)
253{
994324bb
GS		 254 u8 hc_erase_grp_sz, hc_wp_grp_sz;
255
256 /*
257 * Disable these attributes by default
258 */
259 card->ext_csd.enhanced_area_offset = -EINVAL;
260 card->ext_csd.enhanced_area_size = -EINVAL;
b4493eea
GS		 261
262 /*
263 * Enhanced area feature support -- check whether the eMMC
264 * card has the Enhanced area enabled. If so, export enhanced
265 * area offset and size to user by adding sysfs interface.
266 */
267 if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) &&
268 (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) {
994324bb
GS		 269 if (card->ext_csd.partition_setting_completed) {
270 hc_erase_grp_sz =
271 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
272 hc_wp_grp_sz =
273 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
b4493eea 274
994324bb
GS		 275 /*
276 * calculate the enhanced data area offset, in bytes
277 */
278 card->ext_csd.enhanced_area_offset =
ded8a5f9
KM		 279 (((unsigned long long)ext_csd[139]) << 24) +
280 (((unsigned long long)ext_csd[138]) << 16) +
281 (((unsigned long long)ext_csd[137]) << 8) +
282 (((unsigned long long)ext_csd[136]));
994324bb
GS		 283 if (mmc_card_blockaddr(card))
284 card->ext_csd.enhanced_area_offset <<= 9;
285 /*
286 * calculate the enhanced data area size, in kilobytes
287 */
288 card->ext_csd.enhanced_area_size =
289 (ext_csd[142] << 16) + (ext_csd[141] << 8) +
290 ext_csd[140];
291 card->ext_csd.enhanced_area_size *=
292 (size_t)(hc_erase_grp_sz * hc_wp_grp_sz);
293 card->ext_csd.enhanced_area_size <<= 9;
294 } else {
295 pr_warn("%s: defines enhanced area without partition setting complete\n",
296 mmc_hostname(card->host));
297 }
b4493eea
GS		 298 }
299}
300
4facdde1
UH		 301static void mmc_part_add(struct mmc_card *card, unsigned int size,
302 unsigned int part_cfg, char *name, int idx, bool ro,
303 int area_type)
304{
305 card->part[card->nr_parts].size = size;
306 card->part[card->nr_parts].part_cfg = part_cfg;
307 sprintf(card->part[card->nr_parts].name, name, idx);
308 card->part[card->nr_parts].force_ro = ro;
309 card->part[card->nr_parts].area_type = area_type;
310 card->nr_parts++;
311}
312
b4493eea
GS		 313static void mmc_manage_gp_partitions(struct mmc_card *card, u8 *ext_csd)
314{
b4493eea 315 int idx;
994324bb
GS		 316 u8 hc_erase_grp_sz, hc_wp_grp_sz;
317 unsigned int part_size;
b4493eea
GS		 318
319 /*
320 * General purpose partition feature support --
321 * If ext_csd has the size of general purpose partitions,
322 * set size, part_cfg, partition name in mmc_part.
323 */
324 if (ext_csd[EXT_CSD_PARTITION_SUPPORT] &
325 EXT_CSD_PART_SUPPORT_PART_EN) {
994324bb
GS		 326 hc_erase_grp_sz =
327 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
328 hc_wp_grp_sz =
329 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
b4493eea
GS		 330
331 for (idx = 0; idx < MMC_NUM_GP_PARTITION; idx++) {
332 if (!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3] &&
333 !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1] &&
334 !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2])
335 continue;
994324bb
GS		 336 if (card->ext_csd.partition_setting_completed == 0) {
337 pr_warn("%s: has partition size defined without partition complete\n",
338 mmc_hostname(card->host));
339 break;
340 }
b4493eea
GS		 341 part_size =
342 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2]
343 << 16) +
344 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1]
345 << 8) +
346 ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3];
347 part_size *= (size_t)(hc_erase_grp_sz *
348 hc_wp_grp_sz);
349 mmc_part_add(card, part_size << 19,
350 EXT_CSD_PART_CONFIG_ACC_GP0 + idx,
351 "gp%d", idx, false,
352 MMC_BLK_DATA_AREA_GP);
353 }
354 }
355}
356
1c447116
AH		 357/* Minimum partition switch timeout in milliseconds */
358#define MMC_MIN_PART_SWITCH_TIME 300
359
08ee80cc
PR		 360/*
361 * Decode extended CSD.
362 */
076ec38a 363static int mmc_decode_ext_csd(struct mmc_card *card, u8 *ext_csd)
08ee80cc 364{
e0c368d5
NJ		 365 int err = 0, idx;
366 unsigned int part_size;
81f8a7be
HG		 367 struct device_node *np;
368 bool broken_hpi = false;
08ee80cc 369
6da24b78 370 /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */
f39b2dd9 371 card->ext_csd.raw_ext_csd_structure = ext_csd[EXT_CSD_STRUCTURE];
6da24b78 372 if (card->csd.structure == 3) {
f39b2dd9 373 if (card->ext_csd.raw_ext_csd_structure > 2) {
a3c76eb9 374 pr_err("%s: unrecognised EXT_CSD structure "
6da24b78 375 "version %d\n", mmc_hostname(card->host),
f39b2dd9 376 card->ext_csd.raw_ext_csd_structure);
6da24b78
KP		 377 err = -EINVAL;
378 goto out;
379 }
380 }
381
81f8a7be
HG		 382 np = mmc_of_find_child_device(card->host, 0);
383 if (np && of_device_is_compatible(np, "mmc-card"))
384 broken_hpi = of_property_read_bool(np, "broken-hpi");
385 of_node_put(np);
386
03a59437
RI		 387 /*
388 * The EXT_CSD format is meant to be forward compatible. As long
389 * as CSD_STRUCTURE does not change, all values for EXT_CSD_REV
390 * are authorized, see JEDEC JESD84-B50 section B.8.
391 */
b1ebe384 392 card->ext_csd.rev = ext_csd[EXT_CSD_REV];
d7604d76 393
5320226a
P		 394 /* fixup device after ext_csd revision field is updated */
395 mmc_fixup_device(card, mmc_ext_csd_fixups);
396
f39b2dd9
PR		 397 card->ext_csd.raw_sectors[0] = ext_csd[EXT_CSD_SEC_CNT + 0];
398 card->ext_csd.raw_sectors[1] = ext_csd[EXT_CSD_SEC_CNT + 1];
399 card->ext_csd.raw_sectors[2] = ext_csd[EXT_CSD_SEC_CNT + 2];
400 card->ext_csd.raw_sectors[3] = ext_csd[EXT_CSD_SEC_CNT + 3];
b1ebe384 401 if (card->ext_csd.rev >= 2) {
d7604d76
PO		 402 card->ext_csd.sectors =
403 ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
404 ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
405 ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
406 ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
fc8a0985
HP		 407
408 /* Cards with density > 2GiB are sector addressed */
409 if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512)
d7604d76
PO		 410 mmc_card_set_blockaddr(card);
411 }
96cf5f02 412
81ac2af6 413 card->ext_csd.strobe_support = ext_csd[EXT_CSD_STROBE_SUPPORT];
f39b2dd9 414 card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE];
96cf5f02 415 mmc_select_card_type(card);
7ea239d9 416
f39b2dd9
PR		 417 card->ext_csd.raw_s_a_timeout = ext_csd[EXT_CSD_S_A_TIMEOUT];
418 card->ext_csd.raw_erase_timeout_mult =
419 ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
420 card->ext_csd.raw_hc_erase_grp_size =
421 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
b1ebe384
JL		 422 if (card->ext_csd.rev >= 3) {
423 u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
371a689f
AW		 424 card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG];
425
426 /* EXT_CSD value is in units of 10ms, but we store in ms */
427 card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME];
1c447116
AH		 428 /* Some eMMC set the value too low so set a minimum */
429 if (card->ext_csd.part_time &&
430 card->ext_csd.part_time < MMC_MIN_PART_SWITCH_TIME)
431 card->ext_csd.part_time = MMC_MIN_PART_SWITCH_TIME;
b1ebe384
JL		 432
433 /* Sleep / awake timeout in 100ns units */
434 if (sa_shift > 0 && sa_shift <= 0x17)
435 card->ext_csd.sa_timeout =
436 1 << ext_csd[EXT_CSD_S_A_TIMEOUT];
dfe86cba
AH		 437 card->ext_csd.erase_group_def =
438 ext_csd[EXT_CSD_ERASE_GROUP_DEF];
439 card->ext_csd.hc_erase_timeout = 300 *
440 ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
441 card->ext_csd.hc_erase_size =
442 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10;
f4c5522b
AW		 443
444 card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C];
371a689f
AW		 445
446 /*
447 * There are two boot regions of equal size, defined in
448 * multiples of 128K.
449 */
e0c368d5
NJ		 450 if (ext_csd[EXT_CSD_BOOT_MULT] && mmc_boot_partition_access(card->host)) {
451 for (idx = 0; idx < MMC_NUM_BOOT_PARTITION; idx++) {
452 part_size = ext_csd[EXT_CSD_BOOT_MULT] << 17;
453 mmc_part_add(card, part_size,
454 EXT_CSD_PART_CONFIG_ACC_BOOT0 + idx,
add710ea
JR		 455 "boot%d", idx, true,
456 MMC_BLK_DATA_AREA_BOOT);
e0c368d5
NJ		 457 }
458 }
dfe86cba
AH		 459 }
460
f39b2dd9 461 card->ext_csd.raw_hc_erase_gap_size =
dd13b4ed 462 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
f39b2dd9
PR		 463 card->ext_csd.raw_sec_trim_mult =
464 ext_csd[EXT_CSD_SEC_TRIM_MULT];
465 card->ext_csd.raw_sec_erase_mult =
466 ext_csd[EXT_CSD_SEC_ERASE_MULT];
467 card->ext_csd.raw_sec_feature_support =
468 ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
469 card->ext_csd.raw_trim_mult =
470 ext_csd[EXT_CSD_TRIM_MULT];
836dc2fe 471 card->ext_csd.raw_partition_support = ext_csd[EXT_CSD_PARTITION_SUPPORT];
b097e07f 472 card->ext_csd.raw_driver_strength = ext_csd[EXT_CSD_DRIVER_STRENGTH];
dfe86cba 473 if (card->ext_csd.rev >= 4) {
69803d4f
GS		 474 if (ext_csd[EXT_CSD_PARTITION_SETTING_COMPLETED] &
475 EXT_CSD_PART_SETTING_COMPLETED)
476 card->ext_csd.partition_setting_completed = 1;
477 else
478 card->ext_csd.partition_setting_completed = 0;
479
b4493eea 480 mmc_manage_enhanced_area(card, ext_csd);
709de99d 481
b4493eea 482 mmc_manage_gp_partitions(card, ext_csd);
e0c368d5 483
dfe86cba
AH		 484 card->ext_csd.sec_trim_mult =
485 ext_csd[EXT_CSD_SEC_TRIM_MULT];
486 card->ext_csd.sec_erase_mult =
487 ext_csd[EXT_CSD_SEC_ERASE_MULT];
488 card->ext_csd.sec_feature_support =
489 ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
490 card->ext_csd.trim_timeout = 300 *
491 ext_csd[EXT_CSD_TRIM_MULT];
add710ea
JR		 492
493 /*
494 * Note that the call to mmc_part_add above defaults to read
495 * only. If this default assumption is changed, the call must
496 * take into account the value of boot_locked below.
497 */
498 card->ext_csd.boot_ro_lock = ext_csd[EXT_CSD_BOOT_WP];
499 card->ext_csd.boot_ro_lockable = true;
60443712
FS		 500
501 /* Save power class values */
502 card->ext_csd.raw_pwr_cl_52_195 =
503 ext_csd[EXT_CSD_PWR_CL_52_195];
504 card->ext_csd.raw_pwr_cl_26_195 =
505 ext_csd[EXT_CSD_PWR_CL_26_195];
506 card->ext_csd.raw_pwr_cl_52_360 =
507 ext_csd[EXT_CSD_PWR_CL_52_360];
508 card->ext_csd.raw_pwr_cl_26_360 =
509 ext_csd[EXT_CSD_PWR_CL_26_360];
510 card->ext_csd.raw_pwr_cl_200_195 =
511 ext_csd[EXT_CSD_PWR_CL_200_195];
512 card->ext_csd.raw_pwr_cl_200_360 =
513 ext_csd[EXT_CSD_PWR_CL_200_360];
514 card->ext_csd.raw_pwr_cl_ddr_52_195 =
515 ext_csd[EXT_CSD_PWR_CL_DDR_52_195];
516 card->ext_csd.raw_pwr_cl_ddr_52_360 =
517 ext_csd[EXT_CSD_PWR_CL_DDR_52_360];
0a5b6438
SJ		 518 card->ext_csd.raw_pwr_cl_ddr_200_360 =
519 ext_csd[EXT_CSD_PWR_CL_DDR_200_360];
b1ebe384
JL		 520 }
521
b2499518 522 if (card->ext_csd.rev >= 5) {
7c4f10ac
RI		 523 /* Adjust production date as per JEDEC JESD84-B451 */
524 if (card->cid.year < 2010)
525 card->cid.year += 16;
526
950d56ac 527 /* check whether the eMMC card supports BKOPS */
5320226a
P		 528 if (!mmc_card_broken_hpi(card) &&
529 ext_csd[EXT_CSD_BKOPS_SUPPORT] & 0x1) {
950d56ac 530 card->ext_csd.bkops = 1;
0501be64
AS		 531 card->ext_csd.man_bkops_en =
532 (ext_csd[EXT_CSD_BKOPS_EN] &
533 EXT_CSD_MANUAL_BKOPS_MASK);
950d56ac
JC		 534 card->ext_csd.raw_bkops_status =
535 ext_csd[EXT_CSD_BKOPS_STATUS];
6962c2fb
UY		 536 if (card->ext_csd.man_bkops_en)
537 pr_debug("%s: MAN_BKOPS_EN bit is set\n",
950d56ac 538 mmc_hostname(card->host));
efff8e78
UY		 539 card->ext_csd.auto_bkops_en =
540 (ext_csd[EXT_CSD_BKOPS_EN] &
541 EXT_CSD_AUTO_BKOPS_MASK);
542 if (card->ext_csd.auto_bkops_en)
543 pr_debug("%s: AUTO_BKOPS_EN bit is set\n",
544 mmc_hostname(card->host));
950d56ac
JC		 545 }
546
eb0d8f13 547 /* check whether the eMMC card supports HPI */
5320226a
P		 548 if (!mmc_card_broken_hpi(card) &&
549 !broken_hpi && (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1)) {
eb0d8f13
JC		 550 card->ext_csd.hpi = 1;
551 if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x2)
552 card->ext_csd.hpi_cmd = MMC_STOP_TRANSMISSION;
553 else
554 card->ext_csd.hpi_cmd = MMC_SEND_STATUS;
555 /*
556 * Indicate the maximum timeout to close
557 * a command interrupted by HPI
558 */
559 card->ext_csd.out_of_int_time =
560 ext_csd[EXT_CSD_OUT_OF_INTERRUPT_TIME] * 10;
561 }
562
f4c5522b 563 card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM];
b2499518 564 card->ext_csd.rst_n_function = ext_csd[EXT_CSD_RST_N_FUNCTION];
090d25fe
LP		 565
566 /*
567 * RPMB regions are defined in multiples of 128K.
568 */
569 card->ext_csd.raw_rpmb_size_mult = ext_csd[EXT_CSD_RPMB_MULT];
d0123cca 570 if (ext_csd[EXT_CSD_RPMB_MULT] && mmc_host_cmd23(card->host)) {
090d25fe
LP		 571 mmc_part_add(card, ext_csd[EXT_CSD_RPMB_MULT] << 17,
572 EXT_CSD_PART_CONFIG_ACC_RPMB,
573 "rpmb", 0, false,
574 MMC_BLK_DATA_AREA_RPMB);
575 }
b2499518 576 }
f4c5522b 577
5238acbe 578 card->ext_csd.raw_erased_mem_count = ext_csd[EXT_CSD_ERASED_MEM_CONT];
dfe86cba
AH		 579 if (ext_csd[EXT_CSD_ERASED_MEM_CONT])
580 card->erased_byte = 0xFF;
581 else
582 card->erased_byte = 0x0;
583
336c716a 584 /* eMMC v4.5 or later */
fe1b5700 585 card->ext_csd.generic_cmd6_time = DEFAULT_CMD6_TIMEOUT_MS;
bec8726a 586 if (card->ext_csd.rev >= 6) {
336c716a
SJ		 587 card->ext_csd.feature_support |= MMC_DISCARD_FEATURE;
588
b23cf0bd
SJ		 589 card->ext_csd.generic_cmd6_time = 10 *
590 ext_csd[EXT_CSD_GENERIC_CMD6_TIME];
bec8726a
G		 591 card->ext_csd.power_off_longtime = 10 *
592 ext_csd[EXT_CSD_POWER_OFF_LONG_TIME];
b23cf0bd 593
336c716a
SJ		 594 card->ext_csd.cache_size =
595 ext_csd[EXT_CSD_CACHE_SIZE + 0] << 0 |
596 ext_csd[EXT_CSD_CACHE_SIZE + 1] << 8 |
597 ext_csd[EXT_CSD_CACHE_SIZE + 2] << 16 |
598 ext_csd[EXT_CSD_CACHE_SIZE + 3] << 24;
4265900e
SD		 599
600 if (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] == 1)
601 card->ext_csd.data_sector_size = 4096;
602 else
603 card->ext_csd.data_sector_size = 512;
604
605 if ((ext_csd[EXT_CSD_DATA_TAG_SUPPORT] & 1) &&
606 (ext_csd[EXT_CSD_TAG_UNIT_SIZE] <= 8)) {
607 card->ext_csd.data_tag_unit_size =
608 ((unsigned int) 1 << ext_csd[EXT_CSD_TAG_UNIT_SIZE]) *
609 (card->ext_csd.data_sector_size);
610 } else {
611 card->ext_csd.data_tag_unit_size = 0;
612 }
abd9ac14
SJ		 613
614 card->ext_csd.max_packed_writes =
615 ext_csd[EXT_CSD_MAX_PACKED_WRITES];
616 card->ext_csd.max_packed_reads =
617 ext_csd[EXT_CSD_MAX_PACKED_READS];
a5075eb9
SD		 618 } else {
619 card->ext_csd.data_sector_size = 512;
336c716a 620 }
881d1c25 621
0f762426
GG		 622 /* eMMC v5 or later */
623 if (card->ext_csd.rev >= 7) {
624 memcpy(card->ext_csd.fwrev, &ext_csd[EXT_CSD_FIRMWARE_VERSION],
625 MMC_FIRMWARE_LEN);
626 card->ext_csd.ffu_capable =
627 (ext_csd[EXT_CSD_SUPPORTED_MODE] & 0x1) &&
628 !(ext_csd[EXT_CSD_FW_CONFIG] & 0x1);
46bc5c40
JL		 629
630 card->ext_csd.pre_eol_info = ext_csd[EXT_CSD_PRE_EOL_INFO];
631 card->ext_csd.device_life_time_est_typ_a =
632 ext_csd[EXT_CSD_DEVICE_LIFE_TIME_EST_TYP_A];
633 card->ext_csd.device_life_time_est_typ_b =
634 ext_csd[EXT_CSD_DEVICE_LIFE_TIME_EST_TYP_B];
0f762426 635 }
925ff3a7
AH		 636
637 /* eMMC v5.1 or later */
638 if (card->ext_csd.rev >= 8) {
639 card->ext_csd.cmdq_support = ext_csd[EXT_CSD_CMDQ_SUPPORT] &
640 EXT_CSD_CMDQ_SUPPORTED;
641 card->ext_csd.cmdq_depth = (ext_csd[EXT_CSD_CMDQ_DEPTH] &
642 EXT_CSD_CMDQ_DEPTH_MASK) + 1;
643 /* Exclude inefficiently small queue depths */
644 if (card->ext_csd.cmdq_depth <= 2) {
645 card->ext_csd.cmdq_support = false;
646 card->ext_csd.cmdq_depth = 0;
647 }
648 if (card->ext_csd.cmdq_support) {
649 pr_debug("%s: Command Queue supported depth %u\n",
650 mmc_hostname(card->host),
651 card->ext_csd.cmdq_depth);
652 }
653 }
7ea239d9 654out:
08ee80cc
PR		 655 return err;
656}
657
076ec38a
UH		 658static int mmc_read_ext_csd(struct mmc_card *card)
659{
c197787c 660 u8 *ext_csd;
076ec38a
UH		 661 int err;
662
c197787c
UH		 663 if (!mmc_can_ext_csd(card))
664 return 0;
665
076ec38a 666 err = mmc_get_ext_csd(card, &ext_csd);
c197787c
UH		 667 if (err) {
668 /* If the host or the card can't do the switch,
669 * fail more gracefully. */
670 if ((err != -EINVAL)
671 && (err != -ENOSYS)
672 && (err != -EFAULT))
673 return err;
674
675 /*
676 * High capacity cards should have this "magic" size
677 * stored in their CSD.
678 */
679 if (card->csd.capacity == (4096 * 512)) {
680 pr_err("%s: unable to read EXT_CSD on a possible high capacity card. Card will be ignored.\n",
681 mmc_hostname(card->host));
682 } else {
683 pr_warn("%s: unable to read EXT_CSD, performance might suffer\n",
684 mmc_hostname(card->host));
685 err = 0;
686 }
687
076ec38a 688 return err;
c197787c 689 }
076ec38a
UH		 690
691 err = mmc_decode_ext_csd(card, ext_csd);
692 kfree(ext_csd);
693 return err;
694}
695
f39b2dd9 696static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)
08ee80cc
PR		 697{
698 u8 *bw_ext_csd;
699 int err;
700
f39b2dd9
PR		 701 if (bus_width == MMC_BUS_WIDTH_1)
702 return 0;
703
08ee80cc 704 err = mmc_get_ext_csd(card, &bw_ext_csd);
c197787c
UH		 705 if (err)
706 return err;
08ee80cc 707
08ee80cc 708 /* only compare read only fields */
dd13b4ed 709 err = !((card->ext_csd.raw_partition_support ==
08ee80cc 710 bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&
f39b2dd9 711 (card->ext_csd.raw_erased_mem_count ==
08ee80cc 712 bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&
f39b2dd9 713 (card->ext_csd.rev ==
08ee80cc 714 bw_ext_csd[EXT_CSD_REV]) &&
f39b2dd9 715 (card->ext_csd.raw_ext_csd_structure ==
08ee80cc 716 bw_ext_csd[EXT_CSD_STRUCTURE]) &&
f39b2dd9 717 (card->ext_csd.raw_card_type ==
08ee80cc 718 bw_ext_csd[EXT_CSD_CARD_TYPE]) &&
f39b2dd9 719 (card->ext_csd.raw_s_a_timeout ==
08ee80cc 720 bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&
f39b2dd9 721 (card->ext_csd.raw_hc_erase_gap_size ==
08ee80cc 722 bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&
f39b2dd9 723 (card->ext_csd.raw_erase_timeout_mult ==
08ee80cc 724 bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&
f39b2dd9 725 (card->ext_csd.raw_hc_erase_grp_size ==
08ee80cc 726 bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
f39b2dd9 727 (card->ext_csd.raw_sec_trim_mult ==
08ee80cc 728 bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&
f39b2dd9 729 (card->ext_csd.raw_sec_erase_mult ==
08ee80cc 730 bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&
f39b2dd9 731 (card->ext_csd.raw_sec_feature_support ==
08ee80cc 732 bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&
f39b2dd9 733 (card->ext_csd.raw_trim_mult ==
08ee80cc 734 bw_ext_csd[EXT_CSD_TRIM_MULT]) &&
f39b2dd9
PR		 735 (card->ext_csd.raw_sectors[0] ==
736 bw_ext_csd[EXT_CSD_SEC_CNT + 0]) &&
737 (card->ext_csd.raw_sectors[1] ==
738 bw_ext_csd[EXT_CSD_SEC_CNT + 1]) &&
739 (card->ext_csd.raw_sectors[2] ==
740 bw_ext_csd[EXT_CSD_SEC_CNT + 2]) &&
741 (card->ext_csd.raw_sectors[3] ==
60443712
FS		 742 bw_ext_csd[EXT_CSD_SEC_CNT + 3]) &&
743 (card->ext_csd.raw_pwr_cl_52_195 ==
744 bw_ext_csd[EXT_CSD_PWR_CL_52_195]) &&
745 (card->ext_csd.raw_pwr_cl_26_195 ==
746 bw_ext_csd[EXT_CSD_PWR_CL_26_195]) &&
747 (card->ext_csd.raw_pwr_cl_52_360 ==
748 bw_ext_csd[EXT_CSD_PWR_CL_52_360]) &&
749 (card->ext_csd.raw_pwr_cl_26_360 ==
750 bw_ext_csd[EXT_CSD_PWR_CL_26_360]) &&
751 (card->ext_csd.raw_pwr_cl_200_195 ==
752 bw_ext_csd[EXT_CSD_PWR_CL_200_195]) &&
753 (card->ext_csd.raw_pwr_cl_200_360 ==
754 bw_ext_csd[EXT_CSD_PWR_CL_200_360]) &&
755 (card->ext_csd.raw_pwr_cl_ddr_52_195 ==
756 bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_195]) &&
757 (card->ext_csd.raw_pwr_cl_ddr_52_360 ==
0a5b6438
SJ		 758 bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_360]) &&
759 (card->ext_csd.raw_pwr_cl_ddr_200_360 ==
760 bw_ext_csd[EXT_CSD_PWR_CL_DDR_200_360]));
761
08ee80cc
PR		 762 if (err)
763 err = -EINVAL;
764
00b41b58 765 kfree(bw_ext_csd);
7ea239d9
PO		 766 return err;
767}
768
51ec92e2
PO		 769MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
770 card->raw_cid[2], card->raw_cid[3]);
771MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
772 card->raw_csd[2], card->raw_csd[3]);
773MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
dfe86cba
AH		 774MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
775MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
0f762426 776MMC_DEV_ATTR(ffu_capable, "%d\n", card->ext_csd.ffu_capable);
51ec92e2
PO		 777MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
778MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
779MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
780MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
51e7e8b6 781MMC_DEV_ATTR(prv, "0x%x\n", card->cid.prv);
46bc5c40
JL		 782MMC_DEV_ATTR(pre_eol_info, "%02x\n", card->ext_csd.pre_eol_info);
783MMC_DEV_ATTR(life_time, "0x%02x 0x%02x\n",
784 card->ext_csd.device_life_time_est_typ_a,
785 card->ext_csd.device_life_time_est_typ_b);
51ec92e2 786MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
709de99d
CD		 787MMC_DEV_ATTR(enhanced_area_offset, "%llu\n",
788 card->ext_csd.enhanced_area_offset);
789MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);
188cc042
LP		 790MMC_DEV_ATTR(raw_rpmb_size_mult, "%#x\n", card->ext_csd.raw_rpmb_size_mult);
791MMC_DEV_ATTR(rel_sectors, "%#x\n", card->ext_csd.rel_sectors);
5fb06af7 792MMC_DEV_ATTR(ocr, "%08x\n", card->ocr);
b658af71 793MMC_DEV_ATTR(cmdq_en, "%d\n", card->ext_csd.cmdq_en);
51ec92e2 794
0f762426
GG		 795static ssize_t mmc_fwrev_show(struct device *dev,
796 struct device_attribute *attr,
797 char *buf)
798{
799 struct mmc_card *card = mmc_dev_to_card(dev);
800
801 if (card->ext_csd.rev < 7) {
802 return sprintf(buf, "0x%x\n", card->cid.fwrev);
803 } else {
804 return sprintf(buf, "0x%*phN\n", MMC_FIRMWARE_LEN,
805 card->ext_csd.fwrev);
806 }
807}
808
809static DEVICE_ATTR(fwrev, S_IRUGO, mmc_fwrev_show, NULL);
810
6825a606
BP		 811static ssize_t mmc_dsr_show(struct device *dev,
812 struct device_attribute *attr,
813 char *buf)
814{
815 struct mmc_card *card = mmc_dev_to_card(dev);
816 struct mmc_host *host = card->host;
817
818 if (card->csd.dsr_imp && host->dsr_req)
819 return sprintf(buf, "0x%x\n", host->dsr);
820 else
821 /* return default DSR value */
822 return sprintf(buf, "0x%x\n", 0x404);
823}
824
825static DEVICE_ATTR(dsr, S_IRUGO, mmc_dsr_show, NULL);
826
51ec92e2
PO		 827static struct attribute *mmc_std_attrs[] = {
828 &dev_attr_cid.attr,
829 &dev_attr_csd.attr,
830 &dev_attr_date.attr,
dfe86cba
AH		 831 &dev_attr_erase_size.attr,
832 &dev_attr_preferred_erase_size.attr,
51ec92e2 833 &dev_attr_fwrev.attr,
0f762426 834 &dev_attr_ffu_capable.attr,
51ec92e2
PO		 835 &dev_attr_hwrev.attr,
836 &dev_attr_manfid.attr,
837 &dev_attr_name.attr,
838 &dev_attr_oemid.attr,
51e7e8b6 839 &dev_attr_prv.attr,
46bc5c40
JL		 840 &dev_attr_pre_eol_info.attr,
841 &dev_attr_life_time.attr,
51ec92e2 842 &dev_attr_serial.attr,
709de99d
CD		 843 &dev_attr_enhanced_area_offset.attr,
844 &dev_attr_enhanced_area_size.attr,
188cc042
LP		 845 &dev_attr_raw_rpmb_size_mult.attr,
846 &dev_attr_rel_sectors.attr,
5fb06af7 847 &dev_attr_ocr.attr,
6825a606 848 &dev_attr_dsr.attr,
b658af71 849 &dev_attr_cmdq_en.attr,
51ec92e2
PO		 850 NULL,
851};
d1e58212 852ATTRIBUTE_GROUPS(mmc_std);
51ec92e2
PO		 853
854static struct device_type mmc_type = {
d1e58212 855 .groups = mmc_std_groups,
51ec92e2
PO		 856};
857
b87d8dbf
G		 858/*
859 * Select the PowerClass for the current bus width
860 * If power class is defined for 4/8 bit bus in the
861 * extended CSD register, select it by executing the
862 * mmc_switch command.
863 */
2385049d
SJ		 864static int __mmc_select_powerclass(struct mmc_card *card,
865 unsigned int bus_width)
b87d8dbf 866{
2385049d
SJ		 867 struct mmc_host *host = card->host;
868 struct mmc_ext_csd *ext_csd = &card->ext_csd;
60443712 869 unsigned int pwrclass_val = 0;
2385049d 870 int err = 0;
b87d8dbf 871
b87d8dbf
G		 872 switch (1 << host->ios.vdd) {
873 case MMC_VDD_165_195:
2385049d
SJ		 874 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
875 pwrclass_val = ext_csd->raw_pwr_cl_26_195;
876 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
60443712 877 pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
2385049d
SJ		 878 ext_csd->raw_pwr_cl_52_195 :
879 ext_csd->raw_pwr_cl_ddr_52_195;
880 else if (host->ios.clock <= MMC_HS200_MAX_DTR)
881 pwrclass_val = ext_csd->raw_pwr_cl_200_195;
b87d8dbf 882 break;
93fc5a47
SJ		 883 case MMC_VDD_27_28:
884 case MMC_VDD_28_29:
885 case MMC_VDD_29_30:
886 case MMC_VDD_30_31:
887 case MMC_VDD_31_32:
b87d8dbf
G		 888 case MMC_VDD_32_33:
889 case MMC_VDD_33_34:
890 case MMC_VDD_34_35:
891 case MMC_VDD_35_36:
2385049d
SJ		 892 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
893 pwrclass_val = ext_csd->raw_pwr_cl_26_360;
894 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
60443712 895 pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
2385049d
SJ		 896 ext_csd->raw_pwr_cl_52_360 :
897 ext_csd->raw_pwr_cl_ddr_52_360;
898 else if (host->ios.clock <= MMC_HS200_MAX_DTR)
0a5b6438
SJ		 899 pwrclass_val = (bus_width == EXT_CSD_DDR_BUS_WIDTH_8) ?
900 ext_csd->raw_pwr_cl_ddr_200_360 :
901 ext_csd->raw_pwr_cl_200_360;
b87d8dbf
G		 902 break;
903 default:
6606110d
JP		 904 pr_warn("%s: Voltage range not supported for power class\n",
905 mmc_hostname(host));
b87d8dbf
G		 906 return -EINVAL;
907 }
908
b87d8dbf
G		 909 if (bus_width & (EXT_CSD_BUS_WIDTH_8 | EXT_CSD_DDR_BUS_WIDTH_8))
910 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_8BIT_MASK) >>
911 EXT_CSD_PWR_CL_8BIT_SHIFT;
912 else
913 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_4BIT_MASK) >>
914 EXT_CSD_PWR_CL_4BIT_SHIFT;
915
916 /* If the power class is different from the default value */
917 if (pwrclass_val > 0) {
918 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
919 EXT_CSD_POWER_CLASS,
920 pwrclass_val,
71fe3eb0 921 card->ext_csd.generic_cmd6_time);
b87d8dbf
G		 922 }
923
924 return err;
925}
926
2385049d
SJ		 927static int mmc_select_powerclass(struct mmc_card *card)
928{
929 struct mmc_host *host = card->host;
930 u32 bus_width, ext_csd_bits;
931 int err, ddr;
932
933 /* Power class selection is supported for versions >= 4.0 */
148bcab2 934 if (!mmc_can_ext_csd(card))
2385049d
SJ		 935 return 0;
936
937 bus_width = host->ios.bus_width;
938 /* Power class values are defined only for 4/8 bit bus */
939 if (bus_width == MMC_BUS_WIDTH_1)
940 return 0;
941
942 ddr = card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52;
943 if (ddr)
944 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
945 EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
946 else
947 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
948 EXT_CSD_BUS_WIDTH_8 : EXT_CSD_BUS_WIDTH_4;
949
950 err = __mmc_select_powerclass(card, ext_csd_bits);
951 if (err)
952 pr_warn("%s: power class selection to bus width %d ddr %d failed\n",
953 mmc_hostname(host), 1 << bus_width, ddr);
954
955 return err;
956}
957
a4924c71 958/*
577fb131 959 * Set the bus speed for the selected speed mode.
a4924c71 960 */
577fb131
SJ		 961static void mmc_set_bus_speed(struct mmc_card *card)
962{
963 unsigned int max_dtr = (unsigned int)-1;
964
0a5b6438
SJ		 965 if ((mmc_card_hs200(card) || mmc_card_hs400(card)) &&
966 max_dtr > card->ext_csd.hs200_max_dtr)
577fb131
SJ		 967 max_dtr = card->ext_csd.hs200_max_dtr;
968 else if (mmc_card_hs(card) && max_dtr > card->ext_csd.hs_max_dtr)
969 max_dtr = card->ext_csd.hs_max_dtr;
970 else if (max_dtr > card->csd.max_dtr)
971 max_dtr = card->csd.max_dtr;
972
973 mmc_set_clock(card->host, max_dtr);
974}
975
976/*
977 * Select the bus width amoung 4-bit and 8-bit(SDR).
978 * If the bus width is changed successfully, return the selected width value.
979 * Zero is returned instead of error value if the wide width is not supported.
980 */
981static int mmc_select_bus_width(struct mmc_card *card)
a4924c71 982{
a4924c71 983 static unsigned ext_csd_bits[] = {
a4924c71 984 EXT_CSD_BUS_WIDTH_8,
577fb131 985 EXT_CSD_BUS_WIDTH_4,
a4924c71
G		 986 };
987 static unsigned bus_widths[] = {
a4924c71 988 MMC_BUS_WIDTH_8,
577fb131 989 MMC_BUS_WIDTH_4,
a4924c71 990 };
577fb131
SJ		 991 struct mmc_host *host = card->host;
992 unsigned idx, bus_width = 0;
993 int err = 0;
a4924c71 994
1c2d26e3 995 if (!mmc_can_ext_csd(card) ||
577fb131
SJ		 996 !(host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA)))
997 return 0;
a4924c71 998
577fb131 999 idx = (host->caps & MMC_CAP_8_BIT_DATA) ? 0 : 1;
a4924c71
G		 1000
1001 /*
1002 * Unlike SD, MMC cards dont have a configuration register to notify
1003 * supported bus width. So bus test command should be run to identify
1004 * the supported bus width or compare the ext csd values of current
1005 * bus width and ext csd values of 1 bit mode read earlier.
1006 */
577fb131 1007 for (; idx < ARRAY_SIZE(bus_widths); idx++) {
a4924c71
G		 1008 /*
1009 * Host is capable of 8bit transfer, then switch
1010 * the device to work in 8bit transfer mode. If the
1011 * mmc switch command returns error then switch to
1012 * 4bit transfer mode. On success set the corresponding
1013 * bus width on the host.
1014 */
1015 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1016 EXT_CSD_BUS_WIDTH,
1017 ext_csd_bits[idx],
1018 card->ext_csd.generic_cmd6_time);
1019 if (err)
1020 continue;
1021
577fb131
SJ		 1022 bus_width = bus_widths[idx];
1023 mmc_set_bus_width(host, bus_width);
a4924c71 1024
577fb131
SJ		 1025 /*
1026 * If controller can't handle bus width test,
1027 * compare ext_csd previously read in 1 bit mode
1028 * against ext_csd at new bus width
1029 */
a4924c71 1030 if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
577fb131 1031 err = mmc_compare_ext_csds(card, bus_width);
a4924c71 1032 else
577fb131
SJ		 1033 err = mmc_bus_test(card, bus_width);
1034
1035 if (!err) {
1036 err = bus_width;
a4924c71 1037 break;
577fb131
SJ		 1038 } else {
1039 pr_warn("%s: switch to bus width %d failed\n",
ed9feec7 1040 mmc_hostname(host), 1 << bus_width);
577fb131 1041 }
a4924c71
G		 1042 }
1043
577fb131
SJ		 1044 return err;
1045}
1046
1047/*
1048 * Switch to the high-speed mode
1049 */
1050static int mmc_select_hs(struct mmc_card *card)
1051{
1052 int err;
1053
1054 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1055 EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
53e60650
UH		 1056 card->ext_csd.generic_cmd6_time, MMC_TIMING_MMC_HS,
1057 true, true, true);
67d35960
JL		 1058 if (err)
1059 pr_warn("%s: switch to high-speed failed, err:%d\n",
1060 mmc_hostname(card->host), err);
1061
577fb131
SJ		 1062 return err;
1063}
1064
1065/*
1066 * Activate wide bus and DDR if supported.
1067 */
1068static int mmc_select_hs_ddr(struct mmc_card *card)
1069{
1070 struct mmc_host *host = card->host;
1071 u32 bus_width, ext_csd_bits;
1072 int err = 0;
1073
1074 if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52))
1075 return 0;
1076
1077 bus_width = host->ios.bus_width;
1078 if (bus_width == MMC_BUS_WIDTH_1)
1079 return 0;
1080
1081 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
1082 EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
1083
e173f891
UH		 1084 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1085 EXT_CSD_BUS_WIDTH,
1086 ext_csd_bits,
1087 card->ext_csd.generic_cmd6_time,
1088 MMC_TIMING_MMC_DDR52,
1089 true, true, true);
577fb131 1090 if (err) {
4b75bffc 1091 pr_err("%s: switch to bus width %d ddr failed\n",
577fb131
SJ		 1092 mmc_hostname(host), 1 << bus_width);
1093 return err;
1094 }
1095
1096 /*
1097 * eMMC cards can support 3.3V to 1.2V i/o (vccq)
1098 * signaling.
1099 *
1100 * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq.
1101 *
1102 * 1.8V vccq at 3.3V core voltage (vcc) is not required
1103 * in the JEDEC spec for DDR.
1104 *
312449ef
CD		 1105 * Even (e)MMC card can support 3.3v to 1.2v vccq, but not all
1106 * host controller can support this, like some of the SDHCI
1107 * controller which connect to an eMMC device. Some of these
1108 * host controller still needs to use 1.8v vccq for supporting
1109 * DDR mode.
1110 *
1111 * So the sequence will be:
1112 * if (host and device can both support 1.2v IO)
1113 * use 1.2v IO;
1114 * else if (host and device can both support 1.8v IO)
1115 * use 1.8v IO;
1116 * so if host and device can only support 3.3v IO, this is the
1117 * last choice.
577fb131
SJ		 1118 *
1119 * WARNING: eMMC rules are NOT the same as SD DDR
1120 */
20f921bb 1121 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_2V) {
4e74b6b3 1122 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
20f921bb
UH		 1123 if (!err)
1124 return 0;
1125 }
577fb131 1126
20f921bb
UH		 1127 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_8V &&
1128 host->caps & MMC_CAP_1_8V_DDR)
4e74b6b3 1129 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
312449ef
CD		 1130
1131 /* make sure vccq is 3.3v after switching disaster */
1132 if (err)
4e74b6b3 1133 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330);
312449ef 1134
577fb131
SJ		 1135 return err;
1136}
1137
0a5b6438
SJ		 1138static int mmc_select_hs400(struct mmc_card *card)
1139{
1140 struct mmc_host *host = card->host;
51b12f77 1141 unsigned int max_dtr;
0a5b6438 1142 int err = 0;
cc4f414c 1143 u8 val;
0a5b6438
SJ		 1144
1145 /*
1146 * HS400 mode requires 8-bit bus width
1147 */
1148 if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
1149 host->ios.bus_width == MMC_BUS_WIDTH_8))
1150 return 0;
1151
51b12f77 1152 /* Switch card to HS mode */
adb24d42 1153 val = EXT_CSD_TIMING_HS;
0a5b6438 1154 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
cc4f414c 1155 EXT_CSD_HS_TIMING, val,
aa33ce3c 1156 card->ext_csd.generic_cmd6_time, 0,
08573eaf 1157 true, false, true);
0a5b6438 1158 if (err) {
4b75bffc 1159 pr_err("%s: switch to high-speed from hs200 failed, err:%d\n",
0a5b6438
SJ		 1160 mmc_hostname(host), err);
1161 return err;
1162 }
1163
51b12f77
AH		 1164 /* Set host controller to HS timing */
1165 mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
1166
649c6059
ZX		 1167 /* Reduce frequency to HS frequency */
1168 max_dtr = card->ext_csd.hs_max_dtr;
1169 mmc_set_clock(host, max_dtr);
1170
08573eaf
CJ		 1171 err = mmc_switch_status(card);
1172 if (err)
1173 goto out_err;
d2302933
AH		 1174
1175 /* Switch card to DDR */
0a5b6438
SJ		 1176 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1177 EXT_CSD_BUS_WIDTH,
1178 EXT_CSD_DDR_BUS_WIDTH_8,
1179 card->ext_csd.generic_cmd6_time);
1180 if (err) {
4b75bffc 1181 pr_err("%s: switch to bus width for hs400 failed, err:%d\n",
0a5b6438
SJ		 1182 mmc_hostname(host), err);
1183 return err;
1184 }
1185
d2302933 1186 /* Switch card to HS400 */
cc4f414c
AH		 1187 val = EXT_CSD_TIMING_HS400 |
1188 card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
0a5b6438 1189 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
cc4f414c 1190 EXT_CSD_HS_TIMING, val,
aa33ce3c 1191 card->ext_csd.generic_cmd6_time, 0,
08573eaf 1192 true, false, true);
0a5b6438 1193 if (err) {
4b75bffc 1194 pr_err("%s: switch to hs400 failed, err:%d\n",
0a5b6438
SJ		 1195 mmc_hostname(host), err);
1196 return err;
1197 }
1198
d2302933 1199 /* Set host controller to HS400 timing and frequency */
0a5b6438
SJ		 1200 mmc_set_timing(host, MMC_TIMING_MMC_HS400);
1201 mmc_set_bus_speed(card);
1202
08573eaf
CJ		 1203 err = mmc_switch_status(card);
1204 if (err)
1205 goto out_err;
d2302933 1206
0a5b6438 1207 return 0;
d2302933
AH		 1208
1209out_err:
1210 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
1211 __func__, err);
1212 return err;
0a5b6438
SJ		 1213}
1214
6376f69d
AH		 1215int mmc_hs200_to_hs400(struct mmc_card *card)
1216{
1217 return mmc_select_hs400(card);
1218}
1219
6376f69d
AH		 1220int mmc_hs400_to_hs200(struct mmc_card *card)
1221{
1222 struct mmc_host *host = card->host;
6376f69d
AH		 1223 unsigned int max_dtr;
1224 int err;
cc4f414c 1225 u8 val;
6376f69d 1226
6376f69d
AH		 1227 /* Reduce frequency to HS */
1228 max_dtr = card->ext_csd.hs_max_dtr;
1229 mmc_set_clock(host, max_dtr);
1230
1231 /* Switch HS400 to HS DDR */
adb24d42 1232 val = EXT_CSD_TIMING_HS;
6376f69d 1233 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING,
aa33ce3c 1234 val, card->ext_csd.generic_cmd6_time, 0,
08573eaf 1235 true, false, true);
6376f69d
AH		 1236 if (err)
1237 goto out_err;
1238
1239 mmc_set_timing(host, MMC_TIMING_MMC_DDR52);
1240
08573eaf
CJ		 1241 err = mmc_switch_status(card);
1242 if (err)
1243 goto out_err;
6376f69d
AH		 1244
1245 /* Switch HS DDR to HS */
1246 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BUS_WIDTH,
1247 EXT_CSD_BUS_WIDTH_8, card->ext_csd.generic_cmd6_time,
aa33ce3c 1248 0, true, false, true);
6376f69d
AH		 1249 if (err)
1250 goto out_err;
1251
1252 mmc_set_timing(host, MMC_TIMING_MMC_HS);
1253
08573eaf
CJ		 1254 err = mmc_switch_status(card);
1255 if (err)
1256 goto out_err;
6376f69d
AH		 1257
1258 /* Switch HS to HS200 */
cc4f414c
AH		 1259 val = EXT_CSD_TIMING_HS200 |
1260 card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
6376f69d 1261 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING,
aa33ce3c 1262 val, card->ext_csd.generic_cmd6_time, 0,
08573eaf 1263 true, false, true);
6376f69d
AH		 1264 if (err)
1265 goto out_err;
1266
1267 mmc_set_timing(host, MMC_TIMING_MMC_HS200);
1268
ef3d2322
AH		 1269 /*
1270 * For HS200, CRC errors are not a reliable way to know the switch
1271 * failed. If there really is a problem, we would expect tuning will
1272 * fail and the result ends up the same.
1273 */
1274 err = __mmc_switch_status(card, false);
08573eaf
CJ		 1275 if (err)
1276 goto out_err;
6376f69d
AH		 1277
1278 mmc_set_bus_speed(card);
1279
1280 return 0;
1281
1282out_err:
1283 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
1284 __func__, err);
1285 return err;
1286}
1287
81ac2af6
SL		 1288static int mmc_select_hs400es(struct mmc_card *card)
1289{
1290 struct mmc_host *host = card->host;
1291 int err = 0;
1292 u8 val;
1293
1294 if (!(host->caps & MMC_CAP_8_BIT_DATA)) {
1295 err = -ENOTSUPP;
1296 goto out_err;
1297 }
1298
1720d354 1299 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400_1_2V)
4e74b6b3 1300 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
1720d354
SL		 1301
1302 if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400_1_8V)
4e74b6b3 1303 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
1720d354
SL		 1304
1305 /* If fails try again during next card power cycle */
1306 if (err)
1307 goto out_err;
1308
81ac2af6
SL		 1309 err = mmc_select_bus_width(card);
1310 if (err < 0)
1311 goto out_err;
1312
1313 /* Switch card to HS mode */
53e60650
UH		 1314 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1315 EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
1316 card->ext_csd.generic_cmd6_time, 0,
1317 true, false, true);
1318 if (err) {
1319 pr_err("%s: switch to hs for hs400es failed, err:%d\n",
1320 mmc_hostname(host), err);
81ac2af6 1321 goto out_err;
53e60650 1322 }
81ac2af6 1323
53e60650 1324 mmc_set_timing(host, MMC_TIMING_MMC_HS);
81ac2af6
SL		 1325 err = mmc_switch_status(card);
1326 if (err)
1327 goto out_err;
1328
53e60650
UH		 1329 mmc_set_clock(host, card->ext_csd.hs_max_dtr);
1330
81ac2af6
SL		 1331 /* Switch card to DDR with strobe bit */
1332 val = EXT_CSD_DDR_BUS_WIDTH_8 | EXT_CSD_BUS_WIDTH_STROBE;
1333 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1334 EXT_CSD_BUS_WIDTH,
1335 val,
1336 card->ext_csd.generic_cmd6_time);
1337 if (err) {
1338 pr_err("%s: switch to bus width for hs400es failed, err:%d\n",
1339 mmc_hostname(host), err);
1340 goto out_err;
1341 }
1342
1343 /* Switch card to HS400 */
1344 val = EXT_CSD_TIMING_HS400 |
1345 card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
1346 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1347 EXT_CSD_HS_TIMING, val,
aa33ce3c 1348 card->ext_csd.generic_cmd6_time, 0,
81ac2af6
SL		 1349 true, false, true);
1350 if (err) {
1351 pr_err("%s: switch to hs400es failed, err:%d\n",
1352 mmc_hostname(host), err);
1353 goto out_err;
1354 }
1355
1356 /* Set host controller to HS400 timing and frequency */
1357 mmc_set_timing(host, MMC_TIMING_MMC_HS400);
1358
1359 /* Controller enable enhanced strobe function */
1360 host->ios.enhanced_strobe = true;
1361 if (host->ops->hs400_enhanced_strobe)
1362 host->ops->hs400_enhanced_strobe(host, &host->ios);
1363
1364 err = mmc_switch_status(card);
1365 if (err)
1366 goto out_err;
1367
1368 return 0;
1369
1370out_err:
1371 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
1372 __func__, err);
1373 return err;
1374}
1375
cc4f414c
AH		 1376static void mmc_select_driver_type(struct mmc_card *card)
1377{
1378 int card_drv_type, drive_strength, drv_type;
1379
1380 card_drv_type = card->ext_csd.raw_driver_strength |
1381 mmc_driver_type_mask(0);
1382
1383 drive_strength = mmc_select_drive_strength(card,
1384 card->ext_csd.hs200_max_dtr,
1385 card_drv_type, &drv_type);
1386
1387 card->drive_strength = drive_strength;
1388
1389 if (drv_type)
1390 mmc_set_driver_type(card->host, drv_type);
1391}
1392
577fb131
SJ		 1393/*
1394 * For device supporting HS200 mode, the following sequence
1395 * should be done before executing the tuning process.
1396 * 1. set the desired bus width(4-bit or 8-bit, 1-bit is not supported)
1397 * 2. switch to HS200 mode
1398 * 3. set the clock to > 52Mhz and <=200MHz
1399 */
1400static int mmc_select_hs200(struct mmc_card *card)
1401{
1402 struct mmc_host *host = card->host;
e51534c8 1403 unsigned int old_timing, old_signal_voltage;
577fb131 1404 int err = -EINVAL;
cc4f414c 1405 u8 val;
577fb131 1406
e51534c8 1407 old_signal_voltage = host->ios.signal_voltage;
577fb131 1408 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_2V)
4e74b6b3 1409 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
577fb131
SJ		 1410
1411 if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_8V)
4e74b6b3 1412 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
577fb131
SJ		 1413
1414 /* If fails try again during next card power cycle */
1415 if (err)
e51534c8 1416 return err;
577fb131 1417
cc4f414c
AH		 1418 mmc_select_driver_type(card);
1419
577fb131
SJ		 1420 /*
1421 * Set the bus width(4 or 8) with host's support and
1422 * switch to HS200 mode if bus width is set successfully.
1423 */
1424 err = mmc_select_bus_width(card);
8b7be8f2 1425 if (err > 0) {
cc4f414c
AH		 1426 val = EXT_CSD_TIMING_HS200 |
1427 card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
4509f847 1428 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
cc4f414c 1429 EXT_CSD_HS_TIMING, val,
aa33ce3c 1430 card->ext_csd.generic_cmd6_time, 0,
08573eaf 1431 true, false, true);
1815e61b
AH		 1432 if (err)
1433 goto err;
1434 old_timing = host->ios.timing;
1435 mmc_set_timing(host, MMC_TIMING_MMC_HS200);
08573eaf 1436
ef3d2322
AH		 1437 /*
1438 * For HS200, CRC errors are not a reliable way to know the
1439 * switch failed. If there really is a problem, we would expect
1440 * tuning will fail and the result ends up the same.
1441 */
1442 err = __mmc_switch_status(card, false);
1443
08573eaf
CJ		 1444 /*
1445 * mmc_select_timing() assumes timing has not changed if
1446 * it is a switch error.
1447 */
1448 if (err == -EBADMSG)
1449 mmc_set_timing(host, old_timing);
577fb131 1450 }
a4924c71 1451err:
e51534c8
DA		 1452 if (err) {
1453 /* fall back to the old signal voltage, if fails report error */
4e74b6b3 1454 if (mmc_set_signal_voltage(host, old_signal_voltage))
e51534c8
DA		 1455 err = -EIO;
1456
1815e61b
AH		 1457 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
1458 __func__, err);
e51534c8 1459 }
a4924c71
G		 1460 return err;
1461}
1462
577fb131 1463/*
81ac2af6 1464 * Activate High Speed, HS200 or HS400ES mode if supported.
577fb131
SJ		 1465 */
1466static int mmc_select_timing(struct mmc_card *card)
1467{
1468 int err = 0;
1469
148bcab2 1470 if (!mmc_can_ext_csd(card))
577fb131
SJ		 1471 goto bus_speed;
1472
81ac2af6
SL		 1473 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400ES)
1474 err = mmc_select_hs400es(card);
1475 else if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200)
577fb131
SJ		 1476 err = mmc_select_hs200(card);
1477 else if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS)
1478 err = mmc_select_hs(card);
1479
1480 if (err && err != -EBADMSG)
1481 return err;
1482
577fb131
SJ		 1483bus_speed:
1484 /*
1485 * Set the bus speed to the selected bus timing.
1486 * If timing is not selected, backward compatible is the default.
1487 */
1488 mmc_set_bus_speed(card);
0400ed0a 1489 return 0;
577fb131
SJ		 1490}
1491
1492/*
1493 * Execute tuning sequence to seek the proper bus operating
0a5b6438 1494 * conditions for HS200 and HS400, which sends CMD21 to the device.
577fb131
SJ		 1495 */
1496static int mmc_hs200_tuning(struct mmc_card *card)
1497{
1498 struct mmc_host *host = card->host;
577fb131 1499
0a5b6438
SJ		 1500 /*
1501 * Timing should be adjusted to the HS400 target
1502 * operation frequency for tuning process
1503 */
1504 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
1505 host->ios.bus_width == MMC_BUS_WIDTH_8)
1506 if (host->ops->prepare_hs400_tuning)
1507 host->ops->prepare_hs400_tuning(host, &host->ios);
1508
63e415c6 1509 return mmc_execute_tuning(card);
577fb131
SJ		 1510}
1511
7ea239d9 1512/*
6abaa0c9
PO		 1513 * Handle the detection and initialisation of a card.
1514 *
8769392b 1515 * In the case of a resume, "oldcard" will contain the card
6abaa0c9 1516 * we're trying to reinitialise.
7ea239d9 1517 */
8c75deae 1518static int mmc_init_card(struct mmc_host *host, u32 ocr,
6abaa0c9 1519 struct mmc_card *oldcard)
7ea239d9
PO		 1520{
1521 struct mmc_card *card;
577fb131 1522 int err;
7ea239d9 1523 u32 cid[4];
b676f039 1524 u32 rocr;
7ea239d9 1525
d84075c8 1526 WARN_ON(!host->claimed);
7ea239d9 1527
44669034
SNX		 1528 /* Set correct bus mode for MMC before attempting init */
1529 if (!mmc_host_is_spi(host))
1530 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
1531
7ea239d9
PO		 1532 /*
1533 * Since we're changing the OCR value, we seem to
1534 * need to tell some cards to go back to the idle
1535 * state. We wait 1ms to give cards time to
1536 * respond.
c3805467 1537 * mmc_go_idle is needed for eMMC that are asleep
7ea239d9
PO		 1538 */
1539 mmc_go_idle(host);
1540
1541 /* The extra bit indicates that we support high capacity */
b676f039 1542 err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
17b0429d 1543 if (err)
6abaa0c9 1544 goto err;
7ea239d9 1545
af517150
DB		 1546 /*
1547 * For SPI, enable CRC as appropriate.
1548 */
1549 if (mmc_host_is_spi(host)) {
1550 err = mmc_spi_set_crc(host, use_spi_crc);
1551 if (err)
1552 goto err;
1553 }
1554
7ea239d9
PO		 1555 /*
1556 * Fetch CID from card.
1557 */
af517150
DB		 1558 if (mmc_host_is_spi(host))
1559 err = mmc_send_cid(host, cid);
1560 else
1561 err = mmc_all_send_cid(host, cid);
17b0429d 1562 if (err)
7ea239d9
PO		 1563 goto err;
1564
6abaa0c9 1565 if (oldcard) {
adf66a0d
PO		 1566 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
1567 err = -ENOENT;
6abaa0c9 1568 goto err;
adf66a0d 1569 }
6abaa0c9
PO		 1570
1571 card = oldcard;
1572 } else {
1573 /*
1574 * Allocate card structure.
1575 */
51ec92e2 1576 card = mmc_alloc_card(host, &mmc_type);
adf66a0d
PO		 1577 if (IS_ERR(card)) {
1578 err = PTR_ERR(card);
6abaa0c9 1579 goto err;
adf66a0d 1580 }
7ea239d9 1581
69041150 1582 card->ocr = ocr;
6abaa0c9
PO		 1583 card->type = MMC_TYPE_MMC;
1584 card->rca = 1;
1585 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
1586 }
7ea239d9 1587
eac86321
DA		 1588 /*
1589 * Call the optional HC's init_card function to handle quirks.
1590 */
1591 if (host->ops->init_card)
1592 host->ops->init_card(host, card);
1593
7ea239d9 1594 /*
af517150 1595 * For native busses: set card RCA and quit open drain mode.
7ea239d9 1596 */
af517150
DB		 1597 if (!mmc_host_is_spi(host)) {
1598 err = mmc_set_relative_addr(card);
1599 if (err)
1600 goto free_card;
7ea239d9 1601
af517150
DB		 1602 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
1603 }
7ea239d9 1604
6abaa0c9
PO		 1605 if (!oldcard) {
1606 /*
1607 * Fetch CSD from card.
1608 */
1609 err = mmc_send_csd(card, card->raw_csd);
17b0429d 1610 if (err)
6abaa0c9 1611 goto free_card;
7ea239d9 1612
bd766312 1613 err = mmc_decode_csd(card);
adf66a0d 1614 if (err)
bd766312
PO		 1615 goto free_card;
1616 err = mmc_decode_cid(card);
adf66a0d 1617 if (err)
bd766312 1618 goto free_card;
6abaa0c9 1619 }
7ea239d9 1620
3d705d14
SH		 1621 /*
1622 * handling only for cards supporting DSR and hosts requesting
1623 * DSR configuration
1624 */
1625 if (card->csd.dsr_imp && host->dsr_req)
1626 mmc_set_dsr(host);
1627
7ea239d9 1628 /*
89a73cf5 1629 * Select card, as all following commands rely on that.
7ea239d9 1630 */
af517150
DB		 1631 if (!mmc_host_is_spi(host)) {
1632 err = mmc_select_card(card);
1633 if (err)
1634 goto free_card;
1635 }
7ea239d9 1636
6abaa0c9 1637 if (!oldcard) {
076ec38a
UH		 1638 /* Read extended CSD. */
1639 err = mmc_read_ext_csd(card);
17b0429d 1640 if (err)
6abaa0c9 1641 goto free_card;
b676f039 1642
87e88659
MY		 1643 /*
1644 * If doing byte addressing, check if required to do sector
b676f039
PR		 1645 * addressing. Handle the case of <2GB cards needing sector
1646 * addressing. See section 8.1 JEDEC Standard JED84-A441;
1647 * ocr register has bit 30 set for sector addressing.
1648 */
87e88659 1649 if (rocr & BIT(30))
b676f039
PR		 1650 mmc_card_set_blockaddr(card);
1651
dfe86cba
AH		 1652 /* Erase size depends on CSD and Extended CSD */
1653 mmc_set_erase_size(card);
6abaa0c9 1654 }
7ea239d9 1655
709de99d
CD		 1656 /*
1657 * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF
25985edc 1658 * bit. This bit will be lost every time after a reset or power off.
709de99d 1659 */
69803d4f 1660 if (card->ext_csd.partition_setting_completed ||
83bb24aa 1661 (card->ext_csd.rev >= 3 && (host->caps2 & MMC_CAP2_HC_ERASE_SZ))) {
709de99d 1662 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
b23cf0bd
SJ		 1663 EXT_CSD_ERASE_GROUP_DEF, 1,
1664 card->ext_csd.generic_cmd6_time);
709de99d
CD		 1665
1666 if (err && err != -EBADMSG)
1667 goto free_card;
1668
1669 if (err) {
1670 err = 0;
1671 /*
1672 * Just disable enhanced area off & sz
1673 * will try to enable ERASE_GROUP_DEF
1674 * during next time reinit
1675 */
1676 card->ext_csd.enhanced_area_offset = -EINVAL;
1677 card->ext_csd.enhanced_area_size = -EINVAL;
1678 } else {
1679 card->ext_csd.erase_group_def = 1;
1680 /*
1681 * enable ERASE_GRP_DEF successfully.
1682 * This will affect the erase size, so
1683 * here need to reset erase size
1684 */
1685 mmc_set_erase_size(card);
1686 }
1687 }
1688
41e2a489
PR		 1689 /*
1690 * Ensure eMMC user default partition is enabled
1691 */
371a689f
AW		 1692 if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
1693 card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
1694 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
1695 card->ext_csd.part_config,
1696 card->ext_csd.part_time);
1697 if (err && err != -EBADMSG)
1698 goto free_card;
41e2a489
PR		 1699 }
1700
bec8726a 1701 /*
43235679 1702 * Enable power_off_notification byte in the ext_csd register
bec8726a 1703 */
43235679 1704 if (card->ext_csd.rev >= 6) {
bec8726a
G		 1705 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1706 EXT_CSD_POWER_OFF_NOTIFICATION,
1707 EXT_CSD_POWER_ON,
1708 card->ext_csd.generic_cmd6_time);
1709 if (err && err != -EBADMSG)
1710 goto free_card;
bec8726a 1711
96a85d54
G		 1712 /*
1713 * The err can be -EBADMSG or 0,
1714 * so check for success and update the flag
1715 */
1716 if (!err)
e6c08586 1717 card->ext_csd.power_off_notification = EXT_CSD_POWER_ON;
96a85d54 1718 }
bec8726a 1719
89a73cf5 1720 /*
577fb131 1721 * Select timing interface
dfc13e84 1722 */
577fb131
SJ		 1723 err = mmc_select_timing(card);
1724 if (err)
1725 goto free_card;
dfc13e84 1726
a4924c71 1727 if (mmc_card_hs200(card)) {
577fb131
SJ		 1728 err = mmc_hs200_tuning(card);
1729 if (err)
4b75bffc 1730 goto free_card;
0a5b6438
SJ		 1731
1732 err = mmc_select_hs400(card);
1733 if (err)
4b75bffc 1734 goto free_card;
773dc118 1735 } else if (!mmc_card_hs400es(card)) {
577fb131
SJ		 1736 /* Select the desired bus width optionally */
1737 err = mmc_select_bus_width(card);
3d4ef329 1738 if (err > 0 && mmc_card_hs(card)) {
577fb131
SJ		 1739 err = mmc_select_hs_ddr(card);
1740 if (err)
4b75bffc 1741 goto free_card;
ef0b27d4 1742 }
89a73cf5
PO		 1743 }
1744
2385049d
SJ		 1745 /*
1746 * Choose the power class with selected bus interface
1747 */
1748 mmc_select_powerclass(card);
1749
52d0974e
SJ		 1750 /*
1751 * Enable HPI feature (if supported)
1752 */
1753 if (card->ext_csd.hpi) {
1754 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1755 EXT_CSD_HPI_MGMT, 1,
1756 card->ext_csd.generic_cmd6_time);
1757 if (err && err != -EBADMSG)
1758 goto free_card;
1759 if (err) {
6606110d
JP		 1760 pr_warn("%s: Enabling HPI failed\n",
1761 mmc_hostname(card->host));
52d0974e
SJ		 1762 err = 0;
1763 } else
1764 card->ext_csd.hpi_en = 1;
1765 }
1766
881d1c25
SJ		 1767 /*
1768 * If cache size is higher than 0, this indicates
1769 * the existence of cache and it can be turned on.
1770 */
5320226a
P		 1771 if (!mmc_card_broken_hpi(card) &&
1772 card->ext_csd.cache_size > 0) {
881d1c25 1773 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
8bc0678b
SJ		 1774 EXT_CSD_CACHE_CTRL, 1,
1775 card->ext_csd.generic_cmd6_time);
881d1c25
SJ		 1776 if (err && err != -EBADMSG)
1777 goto free_card;
1778
1779 /*
1780 * Only if no error, cache is turned on successfully.
1781 */
8bc0678b 1782 if (err) {
6606110d
JP		 1783 pr_warn("%s: Cache is supported, but failed to turn on (%d)\n",
1784 mmc_hostname(card->host), err);
8bc0678b
SJ		 1785 card->ext_csd.cache_ctrl = 0;
1786 err = 0;
1787 } else {
1788 card->ext_csd.cache_ctrl = 1;
1789 }
881d1c25
SJ		 1790 }
1791
9d4579a8
AH		 1792 /*
1793 * In some cases (e.g. RPMB or mmc_test), the Command Queue must be
1794 * disabled for a time, so a flag is needed to indicate to re-enable the
1795 * Command Queue.
1796 */
1797 card->reenable_cmdq = card->ext_csd.cmdq_en;
1798
abd9ac14
SJ		 1799 /*
1800 * The mandatory minimum values are defined for packed command.
1801 * read: 5, write: 3
1802 */
1803 if (card->ext_csd.max_packed_writes >= 3 &&
1804 card->ext_csd.max_packed_reads >= 5 &&
1805 host->caps2 & MMC_CAP2_PACKED_CMD) {
1806 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1807 EXT_CSD_EXP_EVENTS_CTRL,
1808 EXT_CSD_PACKED_EVENT_EN,
1809 card->ext_csd.generic_cmd6_time);
1810 if (err && err != -EBADMSG)
1811 goto free_card;
1812 if (err) {
1813 pr_warn("%s: Enabling packed event failed\n",
1814 mmc_hostname(card->host));
1815 card->ext_csd.packed_event_en = 0;
1816 err = 0;
1817 } else {
1818 card->ext_csd.packed_event_en = 1;
1819 }
1820 }
1821
6abaa0c9
PO		 1822 if (!oldcard)
1823 host->card = card;
1824
17b0429d 1825 return 0;
6abaa0c9
PO		 1826
1827free_card:
1828 if (!oldcard)
1829 mmc_remove_card(card);
1830err:
adf66a0d 1831 return err;
6abaa0c9
PO		 1832}
1833
07a68216
UH		 1834static int mmc_can_sleep(struct mmc_card *card)
1835{
1836 return (card && card->ext_csd.rev >= 3);
1837}
1838
1839static int mmc_sleep(struct mmc_host *host)
1840{
c7836d15 1841 struct mmc_command cmd = {};
07a68216 1842 struct mmc_card *card = host->card;
cb962e04 1843 unsigned int timeout_ms = DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000);
07a68216
UH		 1844 int err;
1845
436f8daa
AH		 1846 /* Re-tuning can't be done once the card is deselected */
1847 mmc_retune_hold(host);
1848
07a68216
UH		 1849 err = mmc_deselect_cards(host);
1850 if (err)
436f8daa 1851 goto out_release;
07a68216
UH		 1852
1853 cmd.opcode = MMC_SLEEP_AWAKE;
1854 cmd.arg = card->rca << 16;
1855 cmd.arg |= 1 << 15;
1856
cb962e04
UH		 1857 /*
1858 * If the max_busy_timeout of the host is specified, validate it against
1859 * the sleep cmd timeout. A failure means we need to prevent the host
1860 * from doing hw busy detection, which is done by converting to a R1
1861 * response instead of a R1B.
1862 */
1863 if (host->max_busy_timeout && (timeout_ms > host->max_busy_timeout)) {
1864 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
1865 } else {
1866 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
1867 cmd.busy_timeout = timeout_ms;
1868 }
1869
07a68216
UH		 1870 err = mmc_wait_for_cmd(host, &cmd, 0);
1871 if (err)
436f8daa 1872 goto out_release;
07a68216
UH		 1873
1874 /*
1875 * If the host does not wait while the card signals busy, then we will
1876 * will have to wait the sleep/awake timeout. Note, we cannot use the
1877 * SEND_STATUS command to poll the status because that command (and most
1878 * others) is invalid while the card sleeps.
1879 */
cb962e04
UH		 1880 if (!cmd.busy_timeout || !(host->caps & MMC_CAP_WAIT_WHILE_BUSY))
1881 mmc_delay(timeout_ms);
07a68216 1882
436f8daa
AH		 1883out_release:
1884 mmc_retune_release(host);
07a68216
UH		 1885 return err;
1886}
1887
e6c08586
UH		 1888static int mmc_can_poweroff_notify(const struct mmc_card *card)
1889{
1890 return card &&
1891 mmc_card_mmc(card) &&
1892 (card->ext_csd.power_off_notification == EXT_CSD_POWER_ON);
1893}
1894
1895static int mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type)
1896{
1897 unsigned int timeout = card->ext_csd.generic_cmd6_time;
1898 int err;
1899
1900 /* Use EXT_CSD_POWER_OFF_SHORT as default notification type. */
1901 if (notify_type == EXT_CSD_POWER_OFF_LONG)
1902 timeout = card->ext_csd.power_off_longtime;
1903
878e200b
UH		 1904 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1905 EXT_CSD_POWER_OFF_NOTIFICATION,
aa33ce3c 1906 notify_type, timeout, 0, true, false, false);
e6c08586
UH		 1907 if (err)
1908 pr_err("%s: Power Off Notification timed out, %u\n",
1909 mmc_hostname(card->host), timeout);
1910
1911 /* Disable the power off notification after the switch operation. */
1912 card->ext_csd.power_off_notification = EXT_CSD_NO_POWER_NOTIFICATION;
1913
1914 return err;
1915}
1916
6abaa0c9
PO		 1917/*
1918 * Host is being removed. Free up the current card.
1919 */
1920static void mmc_remove(struct mmc_host *host)
1921{
6abaa0c9
PO		 1922 mmc_remove_card(host->card);
1923 host->card = NULL;
1924}
1925
d3049504
AH		 1926/*
1927 * Card detection - card is alive.
1928 */
1929static int mmc_alive(struct mmc_host *host)
1930{
1931 return mmc_send_status(host->card, NULL);
1932}
1933
6abaa0c9
PO		 1934/*
1935 * Card detection callback from host.
1936 */
1937static void mmc_detect(struct mmc_host *host)
1938{
1939 int err;
1940
e94cfef6 1941 mmc_get_card(host->card);
6abaa0c9
PO		 1942
1943 /*
1944 * Just check if our card has been removed.
1945 */
d3049504 1946 err = _mmc_detect_card_removed(host);
6abaa0c9 1947
e94cfef6 1948 mmc_put_card(host->card);
6abaa0c9 1949
17b0429d 1950 if (err) {
4101c16a 1951 mmc_remove(host);
6abaa0c9
PO		 1952
1953 mmc_claim_host(host);
1954 mmc_detach_bus(host);
7f7e4129 1955 mmc_power_off(host);
6abaa0c9
PO		 1956 mmc_release_host(host);
1957 }
1958}
1959
03d071fc 1960static int _mmc_suspend(struct mmc_host *host, bool is_suspend)
6abaa0c9 1961{
c3805467 1962 int err = 0;
03d071fc
UH		 1963 unsigned int notify_type = is_suspend ? EXT_CSD_POWER_OFF_SHORT :
1964 EXT_CSD_POWER_OFF_LONG;
c3805467 1965
6abaa0c9 1966 mmc_claim_host(host);
881d926d 1967
9ec775f7
UH		 1968 if (mmc_card_suspended(host->card))
1969 goto out;
1970
39b9431b
UH		 1971 if (mmc_card_doing_bkops(host->card)) {
1972 err = mmc_stop_bkops(host->card);
1973 if (err)
1974 goto out;
1975 }
1976
10e5d965 1977 err = mmc_flush_cache(host->card);
881d926d
ME		 1978 if (err)
1979 goto out;
1980
43235679 1981 if (mmc_can_poweroff_notify(host->card) &&
53275c21 1982 ((host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) || !is_suspend))
03d071fc 1983 err = mmc_poweroff_notify(host->card, notify_type);
07a68216
UH		 1984 else if (mmc_can_sleep(host->card))
1985 err = mmc_sleep(host);
e6c08586 1986 else if (!mmc_host_is_spi(host))
85e727ed 1987 err = mmc_deselect_cards(host);
95cdfb72 1988
9ec775f7 1989 if (!err) {
74590263 1990 mmc_power_off(host);
9ec775f7
UH		 1991 mmc_card_set_suspended(host->card);
1992 }
881d926d
ME		 1993out:
1994 mmc_release_host(host);
c3805467 1995 return err;
6abaa0c9 1996}
7ea239d9 1997
03d071fc 1998/*
0cb403a2 1999 * Suspend callback
03d071fc
UH		 2000 */
2001static int mmc_suspend(struct mmc_host *host)
2002{
0cb403a2
UH		 2003 int err;
2004
2005 err = _mmc_suspend(host, true);
2006 if (!err) {
2007 pm_runtime_disable(&host->card->dev);
2008 pm_runtime_set_suspended(&host->card->dev);
2009 }
2010
2011 return err;
03d071fc
UH		 2012}
2013
6abaa0c9 2014/*
6abaa0c9
PO		 2015 * This function tries to determine if the same card is still present
2016 * and, if so, restore all state to it.
2017 */
0cb403a2 2018static int _mmc_resume(struct mmc_host *host)
6abaa0c9 2019{
9ec775f7 2020 int err = 0;
6abaa0c9 2021
6abaa0c9 2022 mmc_claim_host(host);
9ec775f7
UH		 2023
2024 if (!mmc_card_suspended(host->card))
2025 goto out;
2026
69041150 2027 mmc_power_up(host, host->card->ocr);
69041150 2028 err = mmc_init_card(host, host->card->ocr, host->card);
9ec775f7 2029 mmc_card_clr_suspended(host->card);
2986d0bf 2030
9ec775f7
UH		 2031out:
2032 mmc_release_host(host);
95cdfb72 2033 return err;
6abaa0c9
PO		 2034}
2035
9ec775f7
UH		 2036/*
2037 * Shutdown callback
2038 */
2039static int mmc_shutdown(struct mmc_host *host)
2040{
2041 int err = 0;
2042
2043 /*
2044 * In a specific case for poweroff notify, we need to resume the card
2045 * before we can shutdown it properly.
2046 */
2047 if (mmc_can_poweroff_notify(host->card) &&
2048 !(host->caps2 & MMC_CAP2_FULL_PWR_CYCLE))
0cb403a2 2049 err = _mmc_resume(host);
9ec775f7
UH		 2050
2051 if (!err)
2052 err = _mmc_suspend(host, false);
2053
2054 return err;
2055}
c4d770d7 2056
0cb403a2
UH		 2057/*
2058 * Callback for resume.
2059 */
2060static int mmc_resume(struct mmc_host *host)
2061{
0cb403a2 2062 pm_runtime_enable(&host->card->dev);
c29536e8 2063 return 0;
0cb403a2
UH		 2064}
2065
c4d770d7
UH		 2066/*
2067 * Callback for runtime_suspend.
2068 */
2069static int mmc_runtime_suspend(struct mmc_host *host)
2070{
2071 int err;
2072
2073 if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
2074 return 0;
2075
0cb403a2 2076 err = _mmc_suspend(host, true);
0cc81a8c 2077 if (err)
f42cf8d6 2078 pr_err("%s: error %d doing aggressive suspend\n",
c4d770d7 2079 mmc_hostname(host), err);
c4d770d7 2080
c4d770d7
UH		 2081 return err;
2082}
2083
2084/*
2085 * Callback for runtime_resume.
2086 */
2087static int mmc_runtime_resume(struct mmc_host *host)
2088{
2089 int err;
2090
0cb403a2 2091 err = _mmc_resume(host);
520322d9 2092 if (err && err != -ENOMEDIUM)
c29536e8 2093 pr_err("%s: error %d doing runtime resume\n",
c4d770d7
UH		 2094 mmc_hostname(host), err);
2095
c4d770d7
UH		 2096 return 0;
2097}
2098
f855a371
JR		 2099int mmc_can_reset(struct mmc_card *card)
2100{
2101 u8 rst_n_function;
2102
2103 rst_n_function = card->ext_csd.rst_n_function;
2104 if ((rst_n_function & EXT_CSD_RST_N_EN_MASK) != EXT_CSD_RST_N_ENABLED)
2105 return 0;
2106 return 1;
2107}
2108EXPORT_SYMBOL(mmc_can_reset);
2109
2110static int mmc_reset(struct mmc_host *host)
2111{
2112 struct mmc_card *card = host->card;
f855a371 2113
437db4c6
AH		 2114 /*
2115 * In the case of recovery, we can't expect flushing the cache to work
2116 * always, but we have a go and ignore errors.
2117 */
2118 mmc_flush_cache(host->card);
2119
4e6c7178
GG		 2120 if ((host->caps & MMC_CAP_HW_RESET) && host->ops->hw_reset &&
2121 mmc_can_reset(card)) {
2122 /* If the card accept RST_n signal, send it. */
2123 mmc_set_clock(host, host->f_init);
2124 host->ops->hw_reset(host);
2125 /* Set initial state and call mmc_set_ios */
2126 mmc_set_initial_state(host);
2127 } else {
2128 /* Do a brute force power cycle */
2129 mmc_power_cycle(host, card->ocr);
2130 }
364549dd 2131 return mmc_init_card(host, card->ocr, card);
f855a371
JR		 2132}
2133
6abaa0c9
PO		 2134static const struct mmc_bus_ops mmc_ops = {
2135 .remove = mmc_remove,
2136 .detect = mmc_detect,
2137 .suspend = mmc_suspend,
2138 .resume = mmc_resume,
c4d770d7
UH		 2139 .runtime_suspend = mmc_runtime_suspend,
2140 .runtime_resume = mmc_runtime_resume,
d3049504 2141 .alive = mmc_alive,
486fdbbc 2142 .shutdown = mmc_shutdown,
f855a371 2143 .reset = mmc_reset,
6abaa0c9
PO		 2144};
2145
2146/*
2147 * Starting point for MMC card init.
2148 */
807e8e40 2149int mmc_attach_mmc(struct mmc_host *host)
6abaa0c9
PO		 2150{
2151 int err;
69041150 2152 u32 ocr, rocr;
6abaa0c9 2153
d84075c8 2154 WARN_ON(!host->claimed);
6abaa0c9 2155
44669034
SNX		 2156 /* Set correct bus mode for MMC before attempting attach */
2157 if (!mmc_host_is_spi(host))
2158 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
2159
807e8e40
AR		 2160 err = mmc_send_op_cond(host, 0, &ocr);
2161 if (err)
2162 return err;
2163
2501c917 2164 mmc_attach_bus(host, &mmc_ops);
8f230f45
TI		 2165 if (host->ocr_avail_mmc)
2166 host->ocr_avail = host->ocr_avail_mmc;
6abaa0c9 2167
af517150
DB		 2168 /*
2169 * We need to get OCR a different way for SPI.
2170 */
2171 if (mmc_host_is_spi(host)) {
2172 err = mmc_spi_read_ocr(host, 1, &ocr);
2173 if (err)
2174 goto err;
2175 }
2176
69041150 2177 rocr = mmc_select_voltage(host, ocr);
6abaa0c9
PO		 2178
2179 /*
2180 * Can we support the voltage of the card?
2181 */
69041150 2182 if (!rocr) {
109b5bed 2183 err = -EINVAL;
6abaa0c9 2184 goto err;
109b5bed 2185 }
6abaa0c9
PO		 2186
2187 /*
2188 * Detect and init the card.
2189 */
69041150 2190 err = mmc_init_card(host, rocr, NULL);
17b0429d 2191 if (err)
6abaa0c9
PO		 2192 goto err;
2193
2194 mmc_release_host(host);
4101c16a 2195 err = mmc_add_card(host->card);
7ea239d9 2196 if (err)
2986d0bf 2197 goto remove_card;
7ea239d9 2198
2860d060 2199 mmc_claim_host(host);
7ea239d9
PO		 2200 return 0;
2201
2986d0bf 2202remove_card:
6abaa0c9 2203 mmc_remove_card(host->card);
2986d0bf 2204 mmc_claim_host(host);
807e8e40 2205 host->card = NULL;
7ea239d9
PO		 2206err:
2207 mmc_detach_bus(host);
7ea239d9 2208
a3c76eb9 2209 pr_err("%s: error %d whilst initialising MMC card\n",
109b5bed
PO		 2210 mmc_hostname(host), err);
2211
adf66a0d 2212 return err;
7ea239d9 2213}
Linux 6.x block layer and io_uring tree(s)