]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/mmc/core/mmc.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branches 'for-4.11/upstream-fixes', 'for-4.12/accutouch', 'for-4.12/cp2112...
[mirror_ubuntu-artful-kernel.git] / drivers / mmc / core / mmc.c
1 /*
2 * linux/drivers/mmc/core/mmc.c
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>
14 #include <linux/of.h>
15 #include <linux/slab.h>
16 #include <linux/stat.h>
17 #include <linux/pm_runtime.h>
18
19 #include <linux/mmc/host.h>
20 #include <linux/mmc/card.h>
21 #include <linux/mmc/mmc.h>
22
23 #include "core.h"
24 #include "card.h"
25 #include "host.h"
26 #include "bus.h"
27 #include "mmc_ops.h"
28 #include "quirks.h"
29 #include "sd_ops.h"
30
31 #define DEFAULT_CMD6_TIMEOUT_MS 500
32
33 static const unsigned int tran_exp[] = {
34 10000, 100000, 1000000, 10000000,
35 0, 0, 0, 0
36 };
37
38 static 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
43 static const unsigned int tacc_exp[] = {
44 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000,
45 };
46
47 static 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 */
69 static int mmc_decode_cid(struct mmc_card *card)
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);
106 card->cid.prv = UNSTUFF_BITS(resp, 48, 8);
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:
113 pr_err("%s: card has unknown MMCA version %d\n",
114 mmc_hostname(card->host), card->csd.mmca_vsn);
115 return -EINVAL;
116 }
117
118 return 0;
119 }
120
121 static 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
131 /*
132 * Given a 128-bit response, decode to our card CSD structure.
133 */
134 static int mmc_decode_csd(struct mmc_card *card)
135 {
136 struct mmc_csd *csd = &card->csd;
137 unsigned int e, m, a, b;
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.
143 * We also support eMMC v4.4 & v4.41.
144 */
145 csd->structure = UNSTUFF_BITS(resp, 126, 2);
146 if (csd->structure == 0) {
147 pr_err("%s: unrecognised CSD structure version %d\n",
148 mmc_hostname(card->host), csd->structure);
149 return -EINVAL;
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);
171 csd->dsr_imp = UNSTUFF_BITS(resp, 76, 1);
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);
175
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
183 return 0;
184 }
185
186 static void mmc_select_card_type(struct mmc_card *card)
187 {
188 struct mmc_host *host = card->host;
189 u8 card_type = card->ext_csd.raw_card_type;
190 u32 caps = host->caps, caps2 = host->caps2;
191 unsigned int hs_max_dtr = 0, hs200_max_dtr = 0;
192 unsigned int avail_type = 0;
193
194 if (caps & MMC_CAP_MMC_HIGHSPEED &&
195 card_type & EXT_CSD_CARD_TYPE_HS_26) {
196 hs_max_dtr = MMC_HIGH_26_MAX_DTR;
197 avail_type |= EXT_CSD_CARD_TYPE_HS_26;
198 }
199
200 if (caps & MMC_CAP_MMC_HIGHSPEED &&
201 card_type & EXT_CSD_CARD_TYPE_HS_52) {
202 hs_max_dtr = MMC_HIGH_52_MAX_DTR;
203 avail_type |= EXT_CSD_CARD_TYPE_HS_52;
204 }
205
206 if (caps & (MMC_CAP_1_8V_DDR | MMC_CAP_3_3V_DDR) &&
207 card_type & EXT_CSD_CARD_TYPE_DDR_1_8V) {
208 hs_max_dtr = MMC_HIGH_DDR_MAX_DTR;
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 }
217
218 if (caps2 & MMC_CAP2_HS200_1_8V_SDR &&
219 card_type & EXT_CSD_CARD_TYPE_HS200_1_8V) {
220 hs200_max_dtr = MMC_HS200_MAX_DTR;
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) {
226 hs200_max_dtr = MMC_HS200_MAX_DTR;
227 avail_type |= EXT_CSD_CARD_TYPE_HS200_1_2V;
228 }
229
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
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
247 card->ext_csd.hs_max_dtr = hs_max_dtr;
248 card->ext_csd.hs200_max_dtr = hs200_max_dtr;
249 card->mmc_avail_type = avail_type;
250 }
251
252 static void mmc_manage_enhanced_area(struct mmc_card *card, u8 *ext_csd)
253 {
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;
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)) {
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];
274
275 /*
276 * calculate the enhanced data area offset, in bytes
277 */
278 card->ext_csd.enhanced_area_offset =
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]));
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 }
298 }
299 }
300
301 static 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
313 static void mmc_manage_gp_partitions(struct mmc_card *card, u8 *ext_csd)
314 {
315 int idx;
316 u8 hc_erase_grp_sz, hc_wp_grp_sz;
317 unsigned int part_size;
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) {
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];
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;
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 }
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
357 /* Minimum partition switch timeout in milliseconds */
358 #define MMC_MIN_PART_SWITCH_TIME 300
359
360 /*
361 * Decode extended CSD.
362 */
363 static int mmc_decode_ext_csd(struct mmc_card *card, u8 *ext_csd)
364 {
365 int err = 0, idx;
366 unsigned int part_size;
367 struct device_node *np;
368 bool broken_hpi = false;
369
370 /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */
371 card->ext_csd.raw_ext_csd_structure = ext_csd[EXT_CSD_STRUCTURE];
372 if (card->csd.structure == 3) {
373 if (card->ext_csd.raw_ext_csd_structure > 2) {
374 pr_err("%s: unrecognised EXT_CSD structure "
375 "version %d\n", mmc_hostname(card->host),
376 card->ext_csd.raw_ext_csd_structure);
377 err = -EINVAL;
378 goto out;
379 }
380 }
381
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
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 */
392 card->ext_csd.rev = ext_csd[EXT_CSD_REV];
393
394 /* fixup device after ext_csd revision field is updated */
395 mmc_fixup_device(card, mmc_ext_csd_fixups);
396
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];
401 if (card->ext_csd.rev >= 2) {
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;
407
408 /* Cards with density > 2GiB are sector addressed */
409 if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512)
410 mmc_card_set_blockaddr(card);
411 }
412
413 card->ext_csd.strobe_support = ext_csd[EXT_CSD_STROBE_SUPPORT];
414 card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE];
415 mmc_select_card_type(card);
416
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];
422 if (card->ext_csd.rev >= 3) {
423 u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
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];
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;
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];
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;
443
444 card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C];
445
446 /*
447 * There are two boot regions of equal size, defined in
448 * multiples of 128K.
449 */
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,
455 "boot%d", idx, true,
456 MMC_BLK_DATA_AREA_BOOT);
457 }
458 }
459 }
460
461 card->ext_csd.raw_hc_erase_gap_size =
462 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
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];
471 card->ext_csd.raw_partition_support = ext_csd[EXT_CSD_PARTITION_SUPPORT];
472 card->ext_csd.raw_driver_strength = ext_csd[EXT_CSD_DRIVER_STRENGTH];
473 if (card->ext_csd.rev >= 4) {
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
480 mmc_manage_enhanced_area(card, ext_csd);
481
482 mmc_manage_gp_partitions(card, ext_csd);
483
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];
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;
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];
518 card->ext_csd.raw_pwr_cl_ddr_200_360 =
519 ext_csd[EXT_CSD_PWR_CL_DDR_200_360];
520 }
521
522 if (card->ext_csd.rev >= 5) {
523 /* Adjust production date as per JEDEC JESD84-B451 */
524 if (card->cid.year < 2010)
525 card->cid.year += 16;
526
527 /* check whether the eMMC card supports BKOPS */
528 if (!mmc_card_broken_hpi(card) &&
529 ext_csd[EXT_CSD_BKOPS_SUPPORT] & 0x1) {
530 card->ext_csd.bkops = 1;
531 card->ext_csd.man_bkops_en =
532 (ext_csd[EXT_CSD_BKOPS_EN] &
533 EXT_CSD_MANUAL_BKOPS_MASK);
534 card->ext_csd.raw_bkops_status =
535 ext_csd[EXT_CSD_BKOPS_STATUS];
536 if (card->ext_csd.man_bkops_en)
537 pr_debug("%s: MAN_BKOPS_EN bit is set\n",
538 mmc_hostname(card->host));
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));
545 }
546
547 /* check whether the eMMC card supports HPI */
548 if (!mmc_card_broken_hpi(card) &&
549 !broken_hpi && (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1)) {
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
563 card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM];
564 card->ext_csd.rst_n_function = ext_csd[EXT_CSD_RST_N_FUNCTION];
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];
570 if (ext_csd[EXT_CSD_RPMB_MULT] && mmc_host_cmd23(card->host)) {
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 }
576 }
577
578 card->ext_csd.raw_erased_mem_count = ext_csd[EXT_CSD_ERASED_MEM_CONT];
579 if (ext_csd[EXT_CSD_ERASED_MEM_CONT])
580 card->erased_byte = 0xFF;
581 else
582 card->erased_byte = 0x0;
583
584 /* eMMC v4.5 or later */
585 card->ext_csd.generic_cmd6_time = DEFAULT_CMD6_TIMEOUT_MS;
586 if (card->ext_csd.rev >= 6) {
587 card->ext_csd.feature_support |= MMC_DISCARD_FEATURE;
588
589 card->ext_csd.generic_cmd6_time = 10 *
590 ext_csd[EXT_CSD_GENERIC_CMD6_TIME];
591 card->ext_csd.power_off_longtime = 10 *
592 ext_csd[EXT_CSD_POWER_OFF_LONG_TIME];
593
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;
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 }
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];
618 } else {
619 card->ext_csd.data_sector_size = 512;
620 }
621
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);
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];
635 }
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 }
654 out:
655 return err;
656 }
657
658 static int mmc_read_ext_csd(struct mmc_card *card)
659 {
660 u8 *ext_csd;
661 int err;
662
663 if (!mmc_can_ext_csd(card))
664 return 0;
665
666 err = mmc_get_ext_csd(card, &ext_csd);
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
688 return err;
689 }
690
691 err = mmc_decode_ext_csd(card, ext_csd);
692 kfree(ext_csd);
693 return err;
694 }
695
696 static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)
697 {
698 u8 *bw_ext_csd;
699 int err;
700
701 if (bus_width == MMC_BUS_WIDTH_1)
702 return 0;
703
704 err = mmc_get_ext_csd(card, &bw_ext_csd);
705 if (err)
706 return err;
707
708 /* only compare read only fields */
709 err = !((card->ext_csd.raw_partition_support ==
710 bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&
711 (card->ext_csd.raw_erased_mem_count ==
712 bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&
713 (card->ext_csd.rev ==
714 bw_ext_csd[EXT_CSD_REV]) &&
715 (card->ext_csd.raw_ext_csd_structure ==
716 bw_ext_csd[EXT_CSD_STRUCTURE]) &&
717 (card->ext_csd.raw_card_type ==
718 bw_ext_csd[EXT_CSD_CARD_TYPE]) &&
719 (card->ext_csd.raw_s_a_timeout ==
720 bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&
721 (card->ext_csd.raw_hc_erase_gap_size ==
722 bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&
723 (card->ext_csd.raw_erase_timeout_mult ==
724 bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&
725 (card->ext_csd.raw_hc_erase_grp_size ==
726 bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
727 (card->ext_csd.raw_sec_trim_mult ==
728 bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&
729 (card->ext_csd.raw_sec_erase_mult ==
730 bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&
731 (card->ext_csd.raw_sec_feature_support ==
732 bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&
733 (card->ext_csd.raw_trim_mult ==
734 bw_ext_csd[EXT_CSD_TRIM_MULT]) &&
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] ==
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 ==
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
762 if (err)
763 err = -EINVAL;
764
765 kfree(bw_ext_csd);
766 return err;
767 }
768
769 MMC_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]);
771 MMC_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]);
773 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
774 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
775 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
776 MMC_DEV_ATTR(ffu_capable, "%d\n", card->ext_csd.ffu_capable);
777 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
778 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
779 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
780 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
781 MMC_DEV_ATTR(prv, "0x%x\n", card->cid.prv);
782 MMC_DEV_ATTR(pre_eol_info, "%02x\n", card->ext_csd.pre_eol_info);
783 MMC_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);
786 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
787 MMC_DEV_ATTR(enhanced_area_offset, "%llu\n",
788 card->ext_csd.enhanced_area_offset);
789 MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);
790 MMC_DEV_ATTR(raw_rpmb_size_mult, "%#x\n", card->ext_csd.raw_rpmb_size_mult);
791 MMC_DEV_ATTR(rel_sectors, "%#x\n", card->ext_csd.rel_sectors);
792 MMC_DEV_ATTR(ocr, "%08x\n", card->ocr);
793
794 static ssize_t mmc_fwrev_show(struct device *dev,
795 struct device_attribute *attr,
796 char *buf)
797 {
798 struct mmc_card *card = mmc_dev_to_card(dev);
799
800 if (card->ext_csd.rev < 7) {
801 return sprintf(buf, "0x%x\n", card->cid.fwrev);
802 } else {
803 return sprintf(buf, "0x%*phN\n", MMC_FIRMWARE_LEN,
804 card->ext_csd.fwrev);
805 }
806 }
807
808 static DEVICE_ATTR(fwrev, S_IRUGO, mmc_fwrev_show, NULL);
809
810 static ssize_t mmc_dsr_show(struct device *dev,
811 struct device_attribute *attr,
812 char *buf)
813 {
814 struct mmc_card *card = mmc_dev_to_card(dev);
815 struct mmc_host *host = card->host;
816
817 if (card->csd.dsr_imp && host->dsr_req)
818 return sprintf(buf, "0x%x\n", host->dsr);
819 else
820 /* return default DSR value */
821 return sprintf(buf, "0x%x\n", 0x404);
822 }
823
824 static DEVICE_ATTR(dsr, S_IRUGO, mmc_dsr_show, NULL);
825
826 static struct attribute *mmc_std_attrs[] = {
827 &dev_attr_cid.attr,
828 &dev_attr_csd.attr,
829 &dev_attr_date.attr,
830 &dev_attr_erase_size.attr,
831 &dev_attr_preferred_erase_size.attr,
832 &dev_attr_fwrev.attr,
833 &dev_attr_ffu_capable.attr,
834 &dev_attr_hwrev.attr,
835 &dev_attr_manfid.attr,
836 &dev_attr_name.attr,
837 &dev_attr_oemid.attr,
838 &dev_attr_prv.attr,
839 &dev_attr_pre_eol_info.attr,
840 &dev_attr_life_time.attr,
841 &dev_attr_serial.attr,
842 &dev_attr_enhanced_area_offset.attr,
843 &dev_attr_enhanced_area_size.attr,
844 &dev_attr_raw_rpmb_size_mult.attr,
845 &dev_attr_rel_sectors.attr,
846 &dev_attr_ocr.attr,
847 &dev_attr_dsr.attr,
848 NULL,
849 };
850 ATTRIBUTE_GROUPS(mmc_std);
851
852 static struct device_type mmc_type = {
853 .groups = mmc_std_groups,
854 };
855
856 /*
857 * Select the PowerClass for the current bus width
858 * If power class is defined for 4/8 bit bus in the
859 * extended CSD register, select it by executing the
860 * mmc_switch command.
861 */
862 static int __mmc_select_powerclass(struct mmc_card *card,
863 unsigned int bus_width)
864 {
865 struct mmc_host *host = card->host;
866 struct mmc_ext_csd *ext_csd = &card->ext_csd;
867 unsigned int pwrclass_val = 0;
868 int err = 0;
869
870 switch (1 << host->ios.vdd) {
871 case MMC_VDD_165_195:
872 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
873 pwrclass_val = ext_csd->raw_pwr_cl_26_195;
874 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
875 pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
876 ext_csd->raw_pwr_cl_52_195 :
877 ext_csd->raw_pwr_cl_ddr_52_195;
878 else if (host->ios.clock <= MMC_HS200_MAX_DTR)
879 pwrclass_val = ext_csd->raw_pwr_cl_200_195;
880 break;
881 case MMC_VDD_27_28:
882 case MMC_VDD_28_29:
883 case MMC_VDD_29_30:
884 case MMC_VDD_30_31:
885 case MMC_VDD_31_32:
886 case MMC_VDD_32_33:
887 case MMC_VDD_33_34:
888 case MMC_VDD_34_35:
889 case MMC_VDD_35_36:
890 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
891 pwrclass_val = ext_csd->raw_pwr_cl_26_360;
892 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
893 pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
894 ext_csd->raw_pwr_cl_52_360 :
895 ext_csd->raw_pwr_cl_ddr_52_360;
896 else if (host->ios.clock <= MMC_HS200_MAX_DTR)
897 pwrclass_val = (bus_width == EXT_CSD_DDR_BUS_WIDTH_8) ?
898 ext_csd->raw_pwr_cl_ddr_200_360 :
899 ext_csd->raw_pwr_cl_200_360;
900 break;
901 default:
902 pr_warn("%s: Voltage range not supported for power class\n",
903 mmc_hostname(host));
904 return -EINVAL;
905 }
906
907 if (bus_width & (EXT_CSD_BUS_WIDTH_8 | EXT_CSD_DDR_BUS_WIDTH_8))
908 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_8BIT_MASK) >>
909 EXT_CSD_PWR_CL_8BIT_SHIFT;
910 else
911 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_4BIT_MASK) >>
912 EXT_CSD_PWR_CL_4BIT_SHIFT;
913
914 /* If the power class is different from the default value */
915 if (pwrclass_val > 0) {
916 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
917 EXT_CSD_POWER_CLASS,
918 pwrclass_val,
919 card->ext_csd.generic_cmd6_time);
920 }
921
922 return err;
923 }
924
925 static int mmc_select_powerclass(struct mmc_card *card)
926 {
927 struct mmc_host *host = card->host;
928 u32 bus_width, ext_csd_bits;
929 int err, ddr;
930
931 /* Power class selection is supported for versions >= 4.0 */
932 if (!mmc_can_ext_csd(card))
933 return 0;
934
935 bus_width = host->ios.bus_width;
936 /* Power class values are defined only for 4/8 bit bus */
937 if (bus_width == MMC_BUS_WIDTH_1)
938 return 0;
939
940 ddr = card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52;
941 if (ddr)
942 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
943 EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
944 else
945 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
946 EXT_CSD_BUS_WIDTH_8 : EXT_CSD_BUS_WIDTH_4;
947
948 err = __mmc_select_powerclass(card, ext_csd_bits);
949 if (err)
950 pr_warn("%s: power class selection to bus width %d ddr %d failed\n",
951 mmc_hostname(host), 1 << bus_width, ddr);
952
953 return err;
954 }
955
956 /*
957 * Set the bus speed for the selected speed mode.
958 */
959 static void mmc_set_bus_speed(struct mmc_card *card)
960 {
961 unsigned int max_dtr = (unsigned int)-1;
962
963 if ((mmc_card_hs200(card) || mmc_card_hs400(card)) &&
964 max_dtr > card->ext_csd.hs200_max_dtr)
965 max_dtr = card->ext_csd.hs200_max_dtr;
966 else if (mmc_card_hs(card) && max_dtr > card->ext_csd.hs_max_dtr)
967 max_dtr = card->ext_csd.hs_max_dtr;
968 else if (max_dtr > card->csd.max_dtr)
969 max_dtr = card->csd.max_dtr;
970
971 mmc_set_clock(card->host, max_dtr);
972 }
973
974 /*
975 * Select the bus width amoung 4-bit and 8-bit(SDR).
976 * If the bus width is changed successfully, return the selected width value.
977 * Zero is returned instead of error value if the wide width is not supported.
978 */
979 static int mmc_select_bus_width(struct mmc_card *card)
980 {
981 static unsigned ext_csd_bits[] = {
982 EXT_CSD_BUS_WIDTH_8,
983 EXT_CSD_BUS_WIDTH_4,
984 };
985 static unsigned bus_widths[] = {
986 MMC_BUS_WIDTH_8,
987 MMC_BUS_WIDTH_4,
988 };
989 struct mmc_host *host = card->host;
990 unsigned idx, bus_width = 0;
991 int err = 0;
992
993 if (!mmc_can_ext_csd(card) ||
994 !(host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA)))
995 return 0;
996
997 idx = (host->caps & MMC_CAP_8_BIT_DATA) ? 0 : 1;
998
999 /*
1000 * Unlike SD, MMC cards dont have a configuration register to notify
1001 * supported bus width. So bus test command should be run to identify
1002 * the supported bus width or compare the ext csd values of current
1003 * bus width and ext csd values of 1 bit mode read earlier.
1004 */
1005 for (; idx < ARRAY_SIZE(bus_widths); idx++) {
1006 /*
1007 * Host is capable of 8bit transfer, then switch
1008 * the device to work in 8bit transfer mode. If the
1009 * mmc switch command returns error then switch to
1010 * 4bit transfer mode. On success set the corresponding
1011 * bus width on the host.
1012 */
1013 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1014 EXT_CSD_BUS_WIDTH,
1015 ext_csd_bits[idx],
1016 card->ext_csd.generic_cmd6_time);
1017 if (err)
1018 continue;
1019
1020 bus_width = bus_widths[idx];
1021 mmc_set_bus_width(host, bus_width);
1022
1023 /*
1024 * If controller can't handle bus width test,
1025 * compare ext_csd previously read in 1 bit mode
1026 * against ext_csd at new bus width
1027 */
1028 if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
1029 err = mmc_compare_ext_csds(card, bus_width);
1030 else
1031 err = mmc_bus_test(card, bus_width);
1032
1033 if (!err) {
1034 err = bus_width;
1035 break;
1036 } else {
1037 pr_warn("%s: switch to bus width %d failed\n",
1038 mmc_hostname(host), 1 << bus_width);
1039 }
1040 }
1041
1042 return err;
1043 }
1044
1045 /*
1046 * Switch to the high-speed mode
1047 */
1048 static int mmc_select_hs(struct mmc_card *card)
1049 {
1050 int err;
1051
1052 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1053 EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
1054 card->ext_csd.generic_cmd6_time, MMC_TIMING_MMC_HS,
1055 true, true, true);
1056 if (err)
1057 pr_warn("%s: switch to high-speed failed, err:%d\n",
1058 mmc_hostname(card->host), err);
1059
1060 return err;
1061 }
1062
1063 /*
1064 * Activate wide bus and DDR if supported.
1065 */
1066 static int mmc_select_hs_ddr(struct mmc_card *card)
1067 {
1068 struct mmc_host *host = card->host;
1069 u32 bus_width, ext_csd_bits;
1070 int err = 0;
1071
1072 if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52))
1073 return 0;
1074
1075 bus_width = host->ios.bus_width;
1076 if (bus_width == MMC_BUS_WIDTH_1)
1077 return 0;
1078
1079 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
1080 EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
1081
1082 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1083 EXT_CSD_BUS_WIDTH,
1084 ext_csd_bits,
1085 card->ext_csd.generic_cmd6_time,
1086 MMC_TIMING_MMC_DDR52,
1087 true, true, true);
1088 if (err) {
1089 pr_err("%s: switch to bus width %d ddr failed\n",
1090 mmc_hostname(host), 1 << bus_width);
1091 return err;
1092 }
1093
1094 /*
1095 * eMMC cards can support 3.3V to 1.2V i/o (vccq)
1096 * signaling.
1097 *
1098 * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq.
1099 *
1100 * 1.8V vccq at 3.3V core voltage (vcc) is not required
1101 * in the JEDEC spec for DDR.
1102 *
1103 * Even (e)MMC card can support 3.3v to 1.2v vccq, but not all
1104 * host controller can support this, like some of the SDHCI
1105 * controller which connect to an eMMC device. Some of these
1106 * host controller still needs to use 1.8v vccq for supporting
1107 * DDR mode.
1108 *
1109 * So the sequence will be:
1110 * if (host and device can both support 1.2v IO)
1111 * use 1.2v IO;
1112 * else if (host and device can both support 1.8v IO)
1113 * use 1.8v IO;
1114 * so if host and device can only support 3.3v IO, this is the
1115 * last choice.
1116 *
1117 * WARNING: eMMC rules are NOT the same as SD DDR
1118 */
1119 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_2V) {
1120 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
1121 if (!err)
1122 return 0;
1123 }
1124
1125 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_8V &&
1126 host->caps & MMC_CAP_1_8V_DDR)
1127 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
1128
1129 /* make sure vccq is 3.3v after switching disaster */
1130 if (err)
1131 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330);
1132
1133 return err;
1134 }
1135
1136 static int mmc_select_hs400(struct mmc_card *card)
1137 {
1138 struct mmc_host *host = card->host;
1139 unsigned int max_dtr;
1140 int err = 0;
1141 u8 val;
1142
1143 /*
1144 * HS400 mode requires 8-bit bus width
1145 */
1146 if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
1147 host->ios.bus_width == MMC_BUS_WIDTH_8))
1148 return 0;
1149
1150 /* Switch card to HS mode */
1151 val = EXT_CSD_TIMING_HS;
1152 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1153 EXT_CSD_HS_TIMING, val,
1154 card->ext_csd.generic_cmd6_time, 0,
1155 true, false, true);
1156 if (err) {
1157 pr_err("%s: switch to high-speed from hs200 failed, err:%d\n",
1158 mmc_hostname(host), err);
1159 return err;
1160 }
1161
1162 /* Set host controller to HS timing */
1163 mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
1164
1165 /* Reduce frequency to HS frequency */
1166 max_dtr = card->ext_csd.hs_max_dtr;
1167 mmc_set_clock(host, max_dtr);
1168
1169 err = mmc_switch_status(card);
1170 if (err)
1171 goto out_err;
1172
1173 /* Switch card to DDR */
1174 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1175 EXT_CSD_BUS_WIDTH,
1176 EXT_CSD_DDR_BUS_WIDTH_8,
1177 card->ext_csd.generic_cmd6_time);
1178 if (err) {
1179 pr_err("%s: switch to bus width for hs400 failed, err:%d\n",
1180 mmc_hostname(host), err);
1181 return err;
1182 }
1183
1184 /* Switch card to HS400 */
1185 val = EXT_CSD_TIMING_HS400 |
1186 card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
1187 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1188 EXT_CSD_HS_TIMING, val,
1189 card->ext_csd.generic_cmd6_time, 0,
1190 true, false, true);
1191 if (err) {
1192 pr_err("%s: switch to hs400 failed, err:%d\n",
1193 mmc_hostname(host), err);
1194 return err;
1195 }
1196
1197 /* Set host controller to HS400 timing and frequency */
1198 mmc_set_timing(host, MMC_TIMING_MMC_HS400);
1199 mmc_set_bus_speed(card);
1200
1201 err = mmc_switch_status(card);
1202 if (err)
1203 goto out_err;
1204
1205 return 0;
1206
1207 out_err:
1208 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
1209 __func__, err);
1210 return err;
1211 }
1212
1213 int mmc_hs200_to_hs400(struct mmc_card *card)
1214 {
1215 return mmc_select_hs400(card);
1216 }
1217
1218 int mmc_hs400_to_hs200(struct mmc_card *card)
1219 {
1220 struct mmc_host *host = card->host;
1221 unsigned int max_dtr;
1222 int err;
1223 u8 val;
1224
1225 /* Reduce frequency to HS */
1226 max_dtr = card->ext_csd.hs_max_dtr;
1227 mmc_set_clock(host, max_dtr);
1228
1229 /* Switch HS400 to HS DDR */
1230 val = EXT_CSD_TIMING_HS;
1231 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING,
1232 val, card->ext_csd.generic_cmd6_time, 0,
1233 true, false, true);
1234 if (err)
1235 goto out_err;
1236
1237 mmc_set_timing(host, MMC_TIMING_MMC_DDR52);
1238
1239 err = mmc_switch_status(card);
1240 if (err)
1241 goto out_err;
1242
1243 /* Switch HS DDR to HS */
1244 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BUS_WIDTH,
1245 EXT_CSD_BUS_WIDTH_8, card->ext_csd.generic_cmd6_time,
1246 0, true, false, true);
1247 if (err)
1248 goto out_err;
1249
1250 mmc_set_timing(host, MMC_TIMING_MMC_HS);
1251
1252 err = mmc_switch_status(card);
1253 if (err)
1254 goto out_err;
1255
1256 /* Switch HS to HS200 */
1257 val = EXT_CSD_TIMING_HS200 |
1258 card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
1259 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING,
1260 val, card->ext_csd.generic_cmd6_time, 0,
1261 true, false, true);
1262 if (err)
1263 goto out_err;
1264
1265 mmc_set_timing(host, MMC_TIMING_MMC_HS200);
1266
1267 /*
1268 * For HS200, CRC errors are not a reliable way to know the switch
1269 * failed. If there really is a problem, we would expect tuning will
1270 * fail and the result ends up the same.
1271 */
1272 err = __mmc_switch_status(card, false);
1273 if (err)
1274 goto out_err;
1275
1276 mmc_set_bus_speed(card);
1277
1278 return 0;
1279
1280 out_err:
1281 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
1282 __func__, err);
1283 return err;
1284 }
1285
1286 static int mmc_select_hs400es(struct mmc_card *card)
1287 {
1288 struct mmc_host *host = card->host;
1289 int err = 0;
1290 u8 val;
1291
1292 if (!(host->caps & MMC_CAP_8_BIT_DATA)) {
1293 err = -ENOTSUPP;
1294 goto out_err;
1295 }
1296
1297 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400_1_2V)
1298 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
1299
1300 if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400_1_8V)
1301 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
1302
1303 /* If fails try again during next card power cycle */
1304 if (err)
1305 goto out_err;
1306
1307 err = mmc_select_bus_width(card);
1308 if (err < 0)
1309 goto out_err;
1310
1311 /* Switch card to HS mode */
1312 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1313 EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
1314 card->ext_csd.generic_cmd6_time, 0,
1315 true, false, true);
1316 if (err) {
1317 pr_err("%s: switch to hs for hs400es failed, err:%d\n",
1318 mmc_hostname(host), err);
1319 goto out_err;
1320 }
1321
1322 mmc_set_timing(host, MMC_TIMING_MMC_HS);
1323 err = mmc_switch_status(card);
1324 if (err)
1325 goto out_err;
1326
1327 mmc_set_clock(host, card->ext_csd.hs_max_dtr);
1328
1329 /* Switch card to DDR with strobe bit */
1330 val = EXT_CSD_DDR_BUS_WIDTH_8 | EXT_CSD_BUS_WIDTH_STROBE;
1331 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1332 EXT_CSD_BUS_WIDTH,
1333 val,
1334 card->ext_csd.generic_cmd6_time);
1335 if (err) {
1336 pr_err("%s: switch to bus width for hs400es failed, err:%d\n",
1337 mmc_hostname(host), err);
1338 goto out_err;
1339 }
1340
1341 /* Switch card to HS400 */
1342 val = EXT_CSD_TIMING_HS400 |
1343 card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
1344 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1345 EXT_CSD_HS_TIMING, val,
1346 card->ext_csd.generic_cmd6_time, 0,
1347 true, false, true);
1348 if (err) {
1349 pr_err("%s: switch to hs400es failed, err:%d\n",
1350 mmc_hostname(host), err);
1351 goto out_err;
1352 }
1353
1354 /* Set host controller to HS400 timing and frequency */
1355 mmc_set_timing(host, MMC_TIMING_MMC_HS400);
1356
1357 /* Controller enable enhanced strobe function */
1358 host->ios.enhanced_strobe = true;
1359 if (host->ops->hs400_enhanced_strobe)
1360 host->ops->hs400_enhanced_strobe(host, &host->ios);
1361
1362 err = mmc_switch_status(card);
1363 if (err)
1364 goto out_err;
1365
1366 return 0;
1367
1368 out_err:
1369 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
1370 __func__, err);
1371 return err;
1372 }
1373
1374 static void mmc_select_driver_type(struct mmc_card *card)
1375 {
1376 int card_drv_type, drive_strength, drv_type;
1377
1378 card_drv_type = card->ext_csd.raw_driver_strength |
1379 mmc_driver_type_mask(0);
1380
1381 drive_strength = mmc_select_drive_strength(card,
1382 card->ext_csd.hs200_max_dtr,
1383 card_drv_type, &drv_type);
1384
1385 card->drive_strength = drive_strength;
1386
1387 if (drv_type)
1388 mmc_set_driver_type(card->host, drv_type);
1389 }
1390
1391 /*
1392 * For device supporting HS200 mode, the following sequence
1393 * should be done before executing the tuning process.
1394 * 1. set the desired bus width(4-bit or 8-bit, 1-bit is not supported)
1395 * 2. switch to HS200 mode
1396 * 3. set the clock to > 52Mhz and <=200MHz
1397 */
1398 static int mmc_select_hs200(struct mmc_card *card)
1399 {
1400 struct mmc_host *host = card->host;
1401 unsigned int old_timing, old_signal_voltage;
1402 int err = -EINVAL;
1403 u8 val;
1404
1405 old_signal_voltage = host->ios.signal_voltage;
1406 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_2V)
1407 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
1408
1409 if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_8V)
1410 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
1411
1412 /* If fails try again during next card power cycle */
1413 if (err)
1414 return err;
1415
1416 mmc_select_driver_type(card);
1417
1418 /*
1419 * Set the bus width(4 or 8) with host's support and
1420 * switch to HS200 mode if bus width is set successfully.
1421 */
1422 err = mmc_select_bus_width(card);
1423 if (err > 0) {
1424 val = EXT_CSD_TIMING_HS200 |
1425 card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
1426 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1427 EXT_CSD_HS_TIMING, val,
1428 card->ext_csd.generic_cmd6_time, 0,
1429 true, false, true);
1430 if (err)
1431 goto err;
1432 old_timing = host->ios.timing;
1433 mmc_set_timing(host, MMC_TIMING_MMC_HS200);
1434
1435 /*
1436 * For HS200, CRC errors are not a reliable way to know the
1437 * switch failed. If there really is a problem, we would expect
1438 * tuning will fail and the result ends up the same.
1439 */
1440 err = __mmc_switch_status(card, false);
1441
1442 /*
1443 * mmc_select_timing() assumes timing has not changed if
1444 * it is a switch error.
1445 */
1446 if (err == -EBADMSG)
1447 mmc_set_timing(host, old_timing);
1448 }
1449 err:
1450 if (err) {
1451 /* fall back to the old signal voltage, if fails report error */
1452 if (mmc_set_signal_voltage(host, old_signal_voltage))
1453 err = -EIO;
1454
1455 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
1456 __func__, err);
1457 }
1458 return err;
1459 }
1460
1461 /*
1462 * Activate High Speed, HS200 or HS400ES mode if supported.
1463 */
1464 static int mmc_select_timing(struct mmc_card *card)
1465 {
1466 int err = 0;
1467
1468 if (!mmc_can_ext_csd(card))
1469 goto bus_speed;
1470
1471 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400ES)
1472 err = mmc_select_hs400es(card);
1473 else if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200)
1474 err = mmc_select_hs200(card);
1475 else if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS)
1476 err = mmc_select_hs(card);
1477
1478 if (err && err != -EBADMSG)
1479 return err;
1480
1481 bus_speed:
1482 /*
1483 * Set the bus speed to the selected bus timing.
1484 * If timing is not selected, backward compatible is the default.
1485 */
1486 mmc_set_bus_speed(card);
1487 return 0;
1488 }
1489
1490 /*
1491 * Execute tuning sequence to seek the proper bus operating
1492 * conditions for HS200 and HS400, which sends CMD21 to the device.
1493 */
1494 static int mmc_hs200_tuning(struct mmc_card *card)
1495 {
1496 struct mmc_host *host = card->host;
1497
1498 /*
1499 * Timing should be adjusted to the HS400 target
1500 * operation frequency for tuning process
1501 */
1502 if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
1503 host->ios.bus_width == MMC_BUS_WIDTH_8)
1504 if (host->ops->prepare_hs400_tuning)
1505 host->ops->prepare_hs400_tuning(host, &host->ios);
1506
1507 return mmc_execute_tuning(card);
1508 }
1509
1510 /*
1511 * Handle the detection and initialisation of a card.
1512 *
1513 * In the case of a resume, "oldcard" will contain the card
1514 * we're trying to reinitialise.
1515 */
1516 static int mmc_init_card(struct mmc_host *host, u32 ocr,
1517 struct mmc_card *oldcard)
1518 {
1519 struct mmc_card *card;
1520 int err;
1521 u32 cid[4];
1522 u32 rocr;
1523
1524 WARN_ON(!host->claimed);
1525
1526 /* Set correct bus mode for MMC before attempting init */
1527 if (!mmc_host_is_spi(host))
1528 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
1529
1530 /*
1531 * Since we're changing the OCR value, we seem to
1532 * need to tell some cards to go back to the idle
1533 * state. We wait 1ms to give cards time to
1534 * respond.
1535 * mmc_go_idle is needed for eMMC that are asleep
1536 */
1537 mmc_go_idle(host);
1538
1539 /* The extra bit indicates that we support high capacity */
1540 err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
1541 if (err)
1542 goto err;
1543
1544 /*
1545 * For SPI, enable CRC as appropriate.
1546 */
1547 if (mmc_host_is_spi(host)) {
1548 err = mmc_spi_set_crc(host, use_spi_crc);
1549 if (err)
1550 goto err;
1551 }
1552
1553 /*
1554 * Fetch CID from card.
1555 */
1556 if (mmc_host_is_spi(host))
1557 err = mmc_send_cid(host, cid);
1558 else
1559 err = mmc_all_send_cid(host, cid);
1560 if (err)
1561 goto err;
1562
1563 if (oldcard) {
1564 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
1565 err = -ENOENT;
1566 goto err;
1567 }
1568
1569 card = oldcard;
1570 } else {
1571 /*
1572 * Allocate card structure.
1573 */
1574 card = mmc_alloc_card(host, &mmc_type);
1575 if (IS_ERR(card)) {
1576 err = PTR_ERR(card);
1577 goto err;
1578 }
1579
1580 card->ocr = ocr;
1581 card->type = MMC_TYPE_MMC;
1582 card->rca = 1;
1583 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
1584 }
1585
1586 /*
1587 * Call the optional HC's init_card function to handle quirks.
1588 */
1589 if (host->ops->init_card)
1590 host->ops->init_card(host, card);
1591
1592 /*
1593 * For native busses: set card RCA and quit open drain mode.
1594 */
1595 if (!mmc_host_is_spi(host)) {
1596 err = mmc_set_relative_addr(card);
1597 if (err)
1598 goto free_card;
1599
1600 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
1601 }
1602
1603 if (!oldcard) {
1604 /*
1605 * Fetch CSD from card.
1606 */
1607 err = mmc_send_csd(card, card->raw_csd);
1608 if (err)
1609 goto free_card;
1610
1611 err = mmc_decode_csd(card);
1612 if (err)
1613 goto free_card;
1614 err = mmc_decode_cid(card);
1615 if (err)
1616 goto free_card;
1617 }
1618
1619 /*
1620 * handling only for cards supporting DSR and hosts requesting
1621 * DSR configuration
1622 */
1623 if (card->csd.dsr_imp && host->dsr_req)
1624 mmc_set_dsr(host);
1625
1626 /*
1627 * Select card, as all following commands rely on that.
1628 */
1629 if (!mmc_host_is_spi(host)) {
1630 err = mmc_select_card(card);
1631 if (err)
1632 goto free_card;
1633 }
1634
1635 if (!oldcard) {
1636 /* Read extended CSD. */
1637 err = mmc_read_ext_csd(card);
1638 if (err)
1639 goto free_card;
1640
1641 /*
1642 * If doing byte addressing, check if required to do sector
1643 * addressing. Handle the case of <2GB cards needing sector
1644 * addressing. See section 8.1 JEDEC Standard JED84-A441;
1645 * ocr register has bit 30 set for sector addressing.
1646 */
1647 if (rocr & BIT(30))
1648 mmc_card_set_blockaddr(card);
1649
1650 /* Erase size depends on CSD and Extended CSD */
1651 mmc_set_erase_size(card);
1652 }
1653
1654 /*
1655 * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF
1656 * bit. This bit will be lost every time after a reset or power off.
1657 */
1658 if (card->ext_csd.partition_setting_completed ||
1659 (card->ext_csd.rev >= 3 && (host->caps2 & MMC_CAP2_HC_ERASE_SZ))) {
1660 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1661 EXT_CSD_ERASE_GROUP_DEF, 1,
1662 card->ext_csd.generic_cmd6_time);
1663
1664 if (err && err != -EBADMSG)
1665 goto free_card;
1666
1667 if (err) {
1668 err = 0;
1669 /*
1670 * Just disable enhanced area off & sz
1671 * will try to enable ERASE_GROUP_DEF
1672 * during next time reinit
1673 */
1674 card->ext_csd.enhanced_area_offset = -EINVAL;
1675 card->ext_csd.enhanced_area_size = -EINVAL;
1676 } else {
1677 card->ext_csd.erase_group_def = 1;
1678 /*
1679 * enable ERASE_GRP_DEF successfully.
1680 * This will affect the erase size, so
1681 * here need to reset erase size
1682 */
1683 mmc_set_erase_size(card);
1684 }
1685 }
1686
1687 /*
1688 * Ensure eMMC user default partition is enabled
1689 */
1690 if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
1691 card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
1692 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
1693 card->ext_csd.part_config,
1694 card->ext_csd.part_time);
1695 if (err && err != -EBADMSG)
1696 goto free_card;
1697 }
1698
1699 /*
1700 * Enable power_off_notification byte in the ext_csd register
1701 */
1702 if (card->ext_csd.rev >= 6) {
1703 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1704 EXT_CSD_POWER_OFF_NOTIFICATION,
1705 EXT_CSD_POWER_ON,
1706 card->ext_csd.generic_cmd6_time);
1707 if (err && err != -EBADMSG)
1708 goto free_card;
1709
1710 /*
1711 * The err can be -EBADMSG or 0,
1712 * so check for success and update the flag
1713 */
1714 if (!err)
1715 card->ext_csd.power_off_notification = EXT_CSD_POWER_ON;
1716 }
1717
1718 /*
1719 * Select timing interface
1720 */
1721 err = mmc_select_timing(card);
1722 if (err)
1723 goto free_card;
1724
1725 if (mmc_card_hs200(card)) {
1726 err = mmc_hs200_tuning(card);
1727 if (err)
1728 goto free_card;
1729
1730 err = mmc_select_hs400(card);
1731 if (err)
1732 goto free_card;
1733 } else {
1734 /* Select the desired bus width optionally */
1735 err = mmc_select_bus_width(card);
1736 if (err > 0 && mmc_card_hs(card)) {
1737 err = mmc_select_hs_ddr(card);
1738 if (err)
1739 goto free_card;
1740 }
1741 }
1742
1743 /*
1744 * Choose the power class with selected bus interface
1745 */
1746 mmc_select_powerclass(card);
1747
1748 /*
1749 * Enable HPI feature (if supported)
1750 */
1751 if (card->ext_csd.hpi) {
1752 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1753 EXT_CSD_HPI_MGMT, 1,
1754 card->ext_csd.generic_cmd6_time);
1755 if (err && err != -EBADMSG)
1756 goto free_card;
1757 if (err) {
1758 pr_warn("%s: Enabling HPI failed\n",
1759 mmc_hostname(card->host));
1760 err = 0;
1761 } else
1762 card->ext_csd.hpi_en = 1;
1763 }
1764
1765 /*
1766 * If cache size is higher than 0, this indicates
1767 * the existence of cache and it can be turned on.
1768 */
1769 if (!mmc_card_broken_hpi(card) &&
1770 card->ext_csd.cache_size > 0) {
1771 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1772 EXT_CSD_CACHE_CTRL, 1,
1773 card->ext_csd.generic_cmd6_time);
1774 if (err && err != -EBADMSG)
1775 goto free_card;
1776
1777 /*
1778 * Only if no error, cache is turned on successfully.
1779 */
1780 if (err) {
1781 pr_warn("%s: Cache is supported, but failed to turn on (%d)\n",
1782 mmc_hostname(card->host), err);
1783 card->ext_csd.cache_ctrl = 0;
1784 err = 0;
1785 } else {
1786 card->ext_csd.cache_ctrl = 1;
1787 }
1788 }
1789
1790 /*
1791 * The mandatory minimum values are defined for packed command.
1792 * read: 5, write: 3
1793 */
1794 if (card->ext_csd.max_packed_writes >= 3 &&
1795 card->ext_csd.max_packed_reads >= 5 &&
1796 host->caps2 & MMC_CAP2_PACKED_CMD) {
1797 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1798 EXT_CSD_EXP_EVENTS_CTRL,
1799 EXT_CSD_PACKED_EVENT_EN,
1800 card->ext_csd.generic_cmd6_time);
1801 if (err && err != -EBADMSG)
1802 goto free_card;
1803 if (err) {
1804 pr_warn("%s: Enabling packed event failed\n",
1805 mmc_hostname(card->host));
1806 card->ext_csd.packed_event_en = 0;
1807 err = 0;
1808 } else {
1809 card->ext_csd.packed_event_en = 1;
1810 }
1811 }
1812
1813 if (!oldcard)
1814 host->card = card;
1815
1816 return 0;
1817
1818 free_card:
1819 if (!oldcard)
1820 mmc_remove_card(card);
1821 err:
1822 return err;
1823 }
1824
1825 static int mmc_can_sleep(struct mmc_card *card)
1826 {
1827 return (card && card->ext_csd.rev >= 3);
1828 }
1829
1830 static int mmc_sleep(struct mmc_host *host)
1831 {
1832 struct mmc_command cmd = {};
1833 struct mmc_card *card = host->card;
1834 unsigned int timeout_ms = DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000);
1835 int err;
1836
1837 /* Re-tuning can't be done once the card is deselected */
1838 mmc_retune_hold(host);
1839
1840 err = mmc_deselect_cards(host);
1841 if (err)
1842 goto out_release;
1843
1844 cmd.opcode = MMC_SLEEP_AWAKE;
1845 cmd.arg = card->rca << 16;
1846 cmd.arg |= 1 << 15;
1847
1848 /*
1849 * If the max_busy_timeout of the host is specified, validate it against
1850 * the sleep cmd timeout. A failure means we need to prevent the host
1851 * from doing hw busy detection, which is done by converting to a R1
1852 * response instead of a R1B.
1853 */
1854 if (host->max_busy_timeout && (timeout_ms > host->max_busy_timeout)) {
1855 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
1856 } else {
1857 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
1858 cmd.busy_timeout = timeout_ms;
1859 }
1860
1861 err = mmc_wait_for_cmd(host, &cmd, 0);
1862 if (err)
1863 goto out_release;
1864
1865 /*
1866 * If the host does not wait while the card signals busy, then we will
1867 * will have to wait the sleep/awake timeout. Note, we cannot use the
1868 * SEND_STATUS command to poll the status because that command (and most
1869 * others) is invalid while the card sleeps.
1870 */
1871 if (!cmd.busy_timeout || !(host->caps & MMC_CAP_WAIT_WHILE_BUSY))
1872 mmc_delay(timeout_ms);
1873
1874 out_release:
1875 mmc_retune_release(host);
1876 return err;
1877 }
1878
1879 static int mmc_can_poweroff_notify(const struct mmc_card *card)
1880 {
1881 return card &&
1882 mmc_card_mmc(card) &&
1883 (card->ext_csd.power_off_notification == EXT_CSD_POWER_ON);
1884 }
1885
1886 static int mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type)
1887 {
1888 unsigned int timeout = card->ext_csd.generic_cmd6_time;
1889 int err;
1890
1891 /* Use EXT_CSD_POWER_OFF_SHORT as default notification type. */
1892 if (notify_type == EXT_CSD_POWER_OFF_LONG)
1893 timeout = card->ext_csd.power_off_longtime;
1894
1895 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1896 EXT_CSD_POWER_OFF_NOTIFICATION,
1897 notify_type, timeout, 0, true, false, false);
1898 if (err)
1899 pr_err("%s: Power Off Notification timed out, %u\n",
1900 mmc_hostname(card->host), timeout);
1901
1902 /* Disable the power off notification after the switch operation. */
1903 card->ext_csd.power_off_notification = EXT_CSD_NO_POWER_NOTIFICATION;
1904
1905 return err;
1906 }
1907
1908 /*
1909 * Host is being removed. Free up the current card.
1910 */
1911 static void mmc_remove(struct mmc_host *host)
1912 {
1913 mmc_remove_card(host->card);
1914 host->card = NULL;
1915 }
1916
1917 /*
1918 * Card detection - card is alive.
1919 */
1920 static int mmc_alive(struct mmc_host *host)
1921 {
1922 return mmc_send_status(host->card, NULL);
1923 }
1924
1925 /*
1926 * Card detection callback from host.
1927 */
1928 static void mmc_detect(struct mmc_host *host)
1929 {
1930 int err;
1931
1932 mmc_get_card(host->card);
1933
1934 /*
1935 * Just check if our card has been removed.
1936 */
1937 err = _mmc_detect_card_removed(host);
1938
1939 mmc_put_card(host->card);
1940
1941 if (err) {
1942 mmc_remove(host);
1943
1944 mmc_claim_host(host);
1945 mmc_detach_bus(host);
1946 mmc_power_off(host);
1947 mmc_release_host(host);
1948 }
1949 }
1950
1951 static int _mmc_suspend(struct mmc_host *host, bool is_suspend)
1952 {
1953 int err = 0;
1954 unsigned int notify_type = is_suspend ? EXT_CSD_POWER_OFF_SHORT :
1955 EXT_CSD_POWER_OFF_LONG;
1956
1957 mmc_claim_host(host);
1958
1959 if (mmc_card_suspended(host->card))
1960 goto out;
1961
1962 if (mmc_card_doing_bkops(host->card)) {
1963 err = mmc_stop_bkops(host->card);
1964 if (err)
1965 goto out;
1966 }
1967
1968 err = mmc_flush_cache(host->card);
1969 if (err)
1970 goto out;
1971
1972 if (mmc_can_poweroff_notify(host->card) &&
1973 ((host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) || !is_suspend))
1974 err = mmc_poweroff_notify(host->card, notify_type);
1975 else if (mmc_can_sleep(host->card))
1976 err = mmc_sleep(host);
1977 else if (!mmc_host_is_spi(host))
1978 err = mmc_deselect_cards(host);
1979
1980 if (!err) {
1981 mmc_power_off(host);
1982 mmc_card_set_suspended(host->card);
1983 }
1984 out:
1985 mmc_release_host(host);
1986 return err;
1987 }
1988
1989 /*
1990 * Suspend callback
1991 */
1992 static int mmc_suspend(struct mmc_host *host)
1993 {
1994 int err;
1995
1996 err = _mmc_suspend(host, true);
1997 if (!err) {
1998 pm_runtime_disable(&host->card->dev);
1999 pm_runtime_set_suspended(&host->card->dev);
2000 }
2001
2002 return err;
2003 }
2004
2005 /*
2006 * This function tries to determine if the same card is still present
2007 * and, if so, restore all state to it.
2008 */
2009 static int _mmc_resume(struct mmc_host *host)
2010 {
2011 int err = 0;
2012
2013 mmc_claim_host(host);
2014
2015 if (!mmc_card_suspended(host->card))
2016 goto out;
2017
2018 mmc_power_up(host, host->card->ocr);
2019 err = mmc_init_card(host, host->card->ocr, host->card);
2020 mmc_card_clr_suspended(host->card);
2021
2022 out:
2023 mmc_release_host(host);
2024 return err;
2025 }
2026
2027 /*
2028 * Shutdown callback
2029 */
2030 static int mmc_shutdown(struct mmc_host *host)
2031 {
2032 int err = 0;
2033
2034 /*
2035 * In a specific case for poweroff notify, we need to resume the card
2036 * before we can shutdown it properly.
2037 */
2038 if (mmc_can_poweroff_notify(host->card) &&
2039 !(host->caps2 & MMC_CAP2_FULL_PWR_CYCLE))
2040 err = _mmc_resume(host);
2041
2042 if (!err)
2043 err = _mmc_suspend(host, false);
2044
2045 return err;
2046 }
2047
2048 /*
2049 * Callback for resume.
2050 */
2051 static int mmc_resume(struct mmc_host *host)
2052 {
2053 pm_runtime_enable(&host->card->dev);
2054 return 0;
2055 }
2056
2057 /*
2058 * Callback for runtime_suspend.
2059 */
2060 static int mmc_runtime_suspend(struct mmc_host *host)
2061 {
2062 int err;
2063
2064 if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
2065 return 0;
2066
2067 err = _mmc_suspend(host, true);
2068 if (err)
2069 pr_err("%s: error %d doing aggressive suspend\n",
2070 mmc_hostname(host), err);
2071
2072 return err;
2073 }
2074
2075 /*
2076 * Callback for runtime_resume.
2077 */
2078 static int mmc_runtime_resume(struct mmc_host *host)
2079 {
2080 int err;
2081
2082 err = _mmc_resume(host);
2083 if (err && err != -ENOMEDIUM)
2084 pr_err("%s: error %d doing runtime resume\n",
2085 mmc_hostname(host), err);
2086
2087 return 0;
2088 }
2089
2090 int mmc_can_reset(struct mmc_card *card)
2091 {
2092 u8 rst_n_function;
2093
2094 rst_n_function = card->ext_csd.rst_n_function;
2095 if ((rst_n_function & EXT_CSD_RST_N_EN_MASK) != EXT_CSD_RST_N_ENABLED)
2096 return 0;
2097 return 1;
2098 }
2099 EXPORT_SYMBOL(mmc_can_reset);
2100
2101 static int mmc_reset(struct mmc_host *host)
2102 {
2103 struct mmc_card *card = host->card;
2104
2105 /*
2106 * In the case of recovery, we can't expect flushing the cache to work
2107 * always, but we have a go and ignore errors.
2108 */
2109 mmc_flush_cache(host->card);
2110
2111 if ((host->caps & MMC_CAP_HW_RESET) && host->ops->hw_reset &&
2112 mmc_can_reset(card)) {
2113 /* If the card accept RST_n signal, send it. */
2114 mmc_set_clock(host, host->f_init);
2115 host->ops->hw_reset(host);
2116 /* Set initial state and call mmc_set_ios */
2117 mmc_set_initial_state(host);
2118 } else {
2119 /* Do a brute force power cycle */
2120 mmc_power_cycle(host, card->ocr);
2121 }
2122 return mmc_init_card(host, card->ocr, card);
2123 }
2124
2125 static const struct mmc_bus_ops mmc_ops = {
2126 .remove = mmc_remove,
2127 .detect = mmc_detect,
2128 .suspend = mmc_suspend,
2129 .resume = mmc_resume,
2130 .runtime_suspend = mmc_runtime_suspend,
2131 .runtime_resume = mmc_runtime_resume,
2132 .alive = mmc_alive,
2133 .shutdown = mmc_shutdown,
2134 .reset = mmc_reset,
2135 };
2136
2137 /*
2138 * Starting point for MMC card init.
2139 */
2140 int mmc_attach_mmc(struct mmc_host *host)
2141 {
2142 int err;
2143 u32 ocr, rocr;
2144
2145 WARN_ON(!host->claimed);
2146
2147 /* Set correct bus mode for MMC before attempting attach */
2148 if (!mmc_host_is_spi(host))
2149 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
2150
2151 err = mmc_send_op_cond(host, 0, &ocr);
2152 if (err)
2153 return err;
2154
2155 mmc_attach_bus(host, &mmc_ops);
2156 if (host->ocr_avail_mmc)
2157 host->ocr_avail = host->ocr_avail_mmc;
2158
2159 /*
2160 * We need to get OCR a different way for SPI.
2161 */
2162 if (mmc_host_is_spi(host)) {
2163 err = mmc_spi_read_ocr(host, 1, &ocr);
2164 if (err)
2165 goto err;
2166 }
2167
2168 rocr = mmc_select_voltage(host, ocr);
2169
2170 /*
2171 * Can we support the voltage of the card?
2172 */
2173 if (!rocr) {
2174 err = -EINVAL;
2175 goto err;
2176 }
2177
2178 /*
2179 * Detect and init the card.
2180 */
2181 err = mmc_init_card(host, rocr, NULL);
2182 if (err)
2183 goto err;
2184
2185 mmc_release_host(host);
2186 err = mmc_add_card(host->card);
2187 if (err)
2188 goto remove_card;
2189
2190 mmc_claim_host(host);
2191 return 0;
2192
2193 remove_card:
2194 mmc_remove_card(host->card);
2195 mmc_claim_host(host);
2196 host->card = NULL;
2197 err:
2198 mmc_detach_bus(host);
2199
2200 pr_err("%s: error %d whilst initialising MMC card\n",
2201 mmc_hostname(host), err);
2202
2203 return err;
2204 }
Ubuntu Artful kernel mirror