17ea239d9SPierre Ossman /* 270f10482SPierre Ossman * linux/drivers/mmc/core/mmc.c 37ea239d9SPierre Ossman * 47ea239d9SPierre Ossman * Copyright (C) 2003-2004 Russell King, All Rights Reserved. 57ea239d9SPierre Ossman * Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved. 67ea239d9SPierre Ossman * MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved. 77ea239d9SPierre Ossman * 87ea239d9SPierre Ossman * This program is free software; you can redistribute it and/or modify 97ea239d9SPierre Ossman * it under the terms of the GNU General Public License version 2 as 107ea239d9SPierre Ossman * published by the Free Software Foundation. 117ea239d9SPierre Ossman */ 127ea239d9SPierre Ossman 137ea239d9SPierre Ossman #include <linux/err.h> 145a0e3ad6STejun Heo #include <linux/slab.h> 150205a904SPaul Gortmaker #include <linux/stat.h> 160cb403a2SUlf Hansson #include <linux/pm_runtime.h> 177ea239d9SPierre Ossman 187ea239d9SPierre Ossman #include <linux/mmc/host.h> 197ea239d9SPierre Ossman #include <linux/mmc/card.h> 207ea239d9SPierre Ossman #include <linux/mmc/mmc.h> 217ea239d9SPierre Ossman 227ea239d9SPierre Ossman #include "core.h" 234101c16aSPierre Ossman #include "bus.h" 247ea239d9SPierre Ossman #include "mmc_ops.h" 254c4cb171SPhilip Rakity #include "sd_ops.h" 267ea239d9SPierre Ossman 277ea239d9SPierre Ossman static const unsigned int tran_exp[] = { 287ea239d9SPierre Ossman 10000, 100000, 1000000, 10000000, 297ea239d9SPierre Ossman 0, 0, 0, 0 307ea239d9SPierre Ossman }; 317ea239d9SPierre Ossman 327ea239d9SPierre Ossman static const unsigned char tran_mant[] = { 337ea239d9SPierre Ossman 0, 10, 12, 13, 15, 20, 25, 30, 347ea239d9SPierre Ossman 35, 40, 45, 50, 55, 60, 70, 80, 357ea239d9SPierre Ossman }; 367ea239d9SPierre Ossman 377ea239d9SPierre Ossman static const unsigned int tacc_exp[] = { 387ea239d9SPierre Ossman 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 397ea239d9SPierre Ossman }; 407ea239d9SPierre Ossman 417ea239d9SPierre Ossman static const unsigned int tacc_mant[] = { 427ea239d9SPierre Ossman 0, 10, 12, 13, 15, 20, 25, 30, 437ea239d9SPierre Ossman 35, 40, 45, 50, 55, 60, 70, 80, 447ea239d9SPierre Ossman }; 457ea239d9SPierre Ossman 467ea239d9SPierre Ossman #define UNSTUFF_BITS(resp,start,size) \ 477ea239d9SPierre Ossman ({ \ 487ea239d9SPierre Ossman const int __size = size; \ 497ea239d9SPierre Ossman const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \ 507ea239d9SPierre Ossman const int __off = 3 - ((start) / 32); \ 517ea239d9SPierre Ossman const int __shft = (start) & 31; \ 527ea239d9SPierre Ossman u32 __res; \ 537ea239d9SPierre Ossman \ 547ea239d9SPierre Ossman __res = resp[__off] >> __shft; \ 557ea239d9SPierre Ossman if (__size + __shft > 32) \ 567ea239d9SPierre Ossman __res |= resp[__off-1] << ((32 - __shft) % 32); \ 577ea239d9SPierre Ossman __res & __mask; \ 587ea239d9SPierre Ossman }) 597ea239d9SPierre Ossman 607ea239d9SPierre Ossman /* 617ea239d9SPierre Ossman * Given the decoded CSD structure, decode the raw CID to our CID structure. 627ea239d9SPierre Ossman */ 63bd766312SPierre Ossman static int mmc_decode_cid(struct mmc_card *card) 647ea239d9SPierre Ossman { 657ea239d9SPierre Ossman u32 *resp = card->raw_cid; 667ea239d9SPierre Ossman 677ea239d9SPierre Ossman /* 687ea239d9SPierre Ossman * The selection of the format here is based upon published 697ea239d9SPierre Ossman * specs from sandisk and from what people have reported. 707ea239d9SPierre Ossman */ 717ea239d9SPierre Ossman switch (card->csd.mmca_vsn) { 727ea239d9SPierre Ossman case 0: /* MMC v1.0 - v1.2 */ 737ea239d9SPierre Ossman case 1: /* MMC v1.4 */ 747ea239d9SPierre Ossman card->cid.manfid = UNSTUFF_BITS(resp, 104, 24); 757ea239d9SPierre Ossman card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8); 767ea239d9SPierre Ossman card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8); 777ea239d9SPierre Ossman card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8); 787ea239d9SPierre Ossman card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8); 797ea239d9SPierre Ossman card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8); 807ea239d9SPierre Ossman card->cid.prod_name[5] = UNSTUFF_BITS(resp, 56, 8); 817ea239d9SPierre Ossman card->cid.prod_name[6] = UNSTUFF_BITS(resp, 48, 8); 827ea239d9SPierre Ossman card->cid.hwrev = UNSTUFF_BITS(resp, 44, 4); 837ea239d9SPierre Ossman card->cid.fwrev = UNSTUFF_BITS(resp, 40, 4); 847ea239d9SPierre Ossman card->cid.serial = UNSTUFF_BITS(resp, 16, 24); 857ea239d9SPierre Ossman card->cid.month = UNSTUFF_BITS(resp, 12, 4); 867ea239d9SPierre Ossman card->cid.year = UNSTUFF_BITS(resp, 8, 4) + 1997; 877ea239d9SPierre Ossman break; 887ea239d9SPierre Ossman 897ea239d9SPierre Ossman case 2: /* MMC v2.0 - v2.2 */ 907ea239d9SPierre Ossman case 3: /* MMC v3.1 - v3.3 */ 917ea239d9SPierre Ossman case 4: /* MMC v4 */ 927ea239d9SPierre Ossman card->cid.manfid = UNSTUFF_BITS(resp, 120, 8); 937ea239d9SPierre Ossman card->cid.oemid = UNSTUFF_BITS(resp, 104, 16); 947ea239d9SPierre Ossman card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8); 957ea239d9SPierre Ossman card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8); 967ea239d9SPierre Ossman card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8); 977ea239d9SPierre Ossman card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8); 987ea239d9SPierre Ossman card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8); 997ea239d9SPierre Ossman card->cid.prod_name[5] = UNSTUFF_BITS(resp, 56, 8); 10051e7e8b6SBernie Thompson card->cid.prv = UNSTUFF_BITS(resp, 48, 8); 1017ea239d9SPierre Ossman card->cid.serial = UNSTUFF_BITS(resp, 16, 32); 1027ea239d9SPierre Ossman card->cid.month = UNSTUFF_BITS(resp, 12, 4); 1037ea239d9SPierre Ossman card->cid.year = UNSTUFF_BITS(resp, 8, 4) + 1997; 1047ea239d9SPierre Ossman break; 1057ea239d9SPierre Ossman 1067ea239d9SPierre Ossman default: 107a3c76eb9SGirish K S pr_err("%s: card has unknown MMCA version %d\n", 1087ea239d9SPierre Ossman mmc_hostname(card->host), card->csd.mmca_vsn); 109bd766312SPierre Ossman return -EINVAL; 1107ea239d9SPierre Ossman } 111bd766312SPierre Ossman 112bd766312SPierre Ossman return 0; 1137ea239d9SPierre Ossman } 1147ea239d9SPierre Ossman 115dfe86cbaSAdrian Hunter static void mmc_set_erase_size(struct mmc_card *card) 116dfe86cbaSAdrian Hunter { 117dfe86cbaSAdrian Hunter if (card->ext_csd.erase_group_def & 1) 118dfe86cbaSAdrian Hunter card->erase_size = card->ext_csd.hc_erase_size; 119dfe86cbaSAdrian Hunter else 120dfe86cbaSAdrian Hunter card->erase_size = card->csd.erase_size; 121dfe86cbaSAdrian Hunter 122dfe86cbaSAdrian Hunter mmc_init_erase(card); 123dfe86cbaSAdrian Hunter } 124dfe86cbaSAdrian Hunter 1257ea239d9SPierre Ossman /* 1267ea239d9SPierre Ossman * Given a 128-bit response, decode to our card CSD structure. 1277ea239d9SPierre Ossman */ 128bd766312SPierre Ossman static int mmc_decode_csd(struct mmc_card *card) 1297ea239d9SPierre Ossman { 1307ea239d9SPierre Ossman struct mmc_csd *csd = &card->csd; 131dfe86cbaSAdrian Hunter unsigned int e, m, a, b; 1327ea239d9SPierre Ossman u32 *resp = card->raw_csd; 1337ea239d9SPierre Ossman 1347ea239d9SPierre Ossman /* 1357ea239d9SPierre Ossman * We only understand CSD structure v1.1 and v1.2. 1367ea239d9SPierre Ossman * v1.2 has extra information in bits 15, 11 and 10. 1376da24b78SKyungmin Park * We also support eMMC v4.4 & v4.41. 1387ea239d9SPierre Ossman */ 1396da24b78SKyungmin Park csd->structure = UNSTUFF_BITS(resp, 126, 2); 1406da24b78SKyungmin Park if (csd->structure == 0) { 141a3c76eb9SGirish K S pr_err("%s: unrecognised CSD structure version %d\n", 1426da24b78SKyungmin Park mmc_hostname(card->host), csd->structure); 143bd766312SPierre Ossman return -EINVAL; 1447ea239d9SPierre Ossman } 1457ea239d9SPierre Ossman 1467ea239d9SPierre Ossman csd->mmca_vsn = UNSTUFF_BITS(resp, 122, 4); 1477ea239d9SPierre Ossman m = UNSTUFF_BITS(resp, 115, 4); 1487ea239d9SPierre Ossman e = UNSTUFF_BITS(resp, 112, 3); 1497ea239d9SPierre Ossman csd->tacc_ns = (tacc_exp[e] * tacc_mant[m] + 9) / 10; 1507ea239d9SPierre Ossman csd->tacc_clks = UNSTUFF_BITS(resp, 104, 8) * 100; 1517ea239d9SPierre Ossman 1527ea239d9SPierre Ossman m = UNSTUFF_BITS(resp, 99, 4); 1537ea239d9SPierre Ossman e = UNSTUFF_BITS(resp, 96, 3); 1547ea239d9SPierre Ossman csd->max_dtr = tran_exp[e] * tran_mant[m]; 1557ea239d9SPierre Ossman csd->cmdclass = UNSTUFF_BITS(resp, 84, 12); 1567ea239d9SPierre Ossman 1577ea239d9SPierre Ossman e = UNSTUFF_BITS(resp, 47, 3); 1587ea239d9SPierre Ossman m = UNSTUFF_BITS(resp, 62, 12); 1597ea239d9SPierre Ossman csd->capacity = (1 + m) << (e + 2); 1607ea239d9SPierre Ossman 1617ea239d9SPierre Ossman csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4); 1627ea239d9SPierre Ossman csd->read_partial = UNSTUFF_BITS(resp, 79, 1); 1637ea239d9SPierre Ossman csd->write_misalign = UNSTUFF_BITS(resp, 78, 1); 1647ea239d9SPierre Ossman csd->read_misalign = UNSTUFF_BITS(resp, 77, 1); 1653d705d14SSascha Hauer csd->dsr_imp = UNSTUFF_BITS(resp, 76, 1); 1667ea239d9SPierre Ossman csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3); 1677ea239d9SPierre Ossman csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4); 1687ea239d9SPierre Ossman csd->write_partial = UNSTUFF_BITS(resp, 21, 1); 169bd766312SPierre Ossman 170dfe86cbaSAdrian Hunter if (csd->write_blkbits >= 9) { 171dfe86cbaSAdrian Hunter a = UNSTUFF_BITS(resp, 42, 5); 172dfe86cbaSAdrian Hunter b = UNSTUFF_BITS(resp, 37, 5); 173dfe86cbaSAdrian Hunter csd->erase_size = (a + 1) * (b + 1); 174dfe86cbaSAdrian Hunter csd->erase_size <<= csd->write_blkbits - 9; 175dfe86cbaSAdrian Hunter } 176dfe86cbaSAdrian Hunter 177bd766312SPierre Ossman return 0; 1787ea239d9SPierre Ossman } 1797ea239d9SPierre Ossman 1807ea239d9SPierre Ossman /* 18108ee80ccSPhilip Rakity * Read extended CSD. 1827ea239d9SPierre Ossman */ 18308ee80ccSPhilip Rakity static int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd) 1847ea239d9SPierre Ossman { 1857ea239d9SPierre Ossman int err; 1867ea239d9SPierre Ossman u8 *ext_csd; 1877ea239d9SPierre Ossman 1887ea239d9SPierre Ossman BUG_ON(!card); 18908ee80ccSPhilip Rakity BUG_ON(!new_ext_csd); 19008ee80ccSPhilip Rakity 19108ee80ccSPhilip Rakity *new_ext_csd = NULL; 1927ea239d9SPierre Ossman 1937ea239d9SPierre Ossman if (card->csd.mmca_vsn < CSD_SPEC_VER_4) 19417b0429dSPierre Ossman return 0; 1957ea239d9SPierre Ossman 1967ea239d9SPierre Ossman /* 1977ea239d9SPierre Ossman * As the ext_csd is so large and mostly unused, we don't store the 1987ea239d9SPierre Ossman * raw block in mmc_card. 1997ea239d9SPierre Ossman */ 2007ea239d9SPierre Ossman ext_csd = kmalloc(512, GFP_KERNEL); 2017ea239d9SPierre Ossman if (!ext_csd) { 202a3c76eb9SGirish K S pr_err("%s: could not allocate a buffer to " 203adf66a0dSPierre Ossman "receive the ext_csd.\n", mmc_hostname(card->host)); 20417b0429dSPierre Ossman return -ENOMEM; 2057ea239d9SPierre Ossman } 2067ea239d9SPierre Ossman 2077ea239d9SPierre Ossman err = mmc_send_ext_csd(card, ext_csd); 20817b0429dSPierre Ossman if (err) { 20908ee80ccSPhilip Rakity kfree(ext_csd); 21008ee80ccSPhilip Rakity *new_ext_csd = NULL; 21108ee80ccSPhilip Rakity 212d08ebeddSWolfgang Muees /* If the host or the card can't do the switch, 213d08ebeddSWolfgang Muees * fail more gracefully. */ 214d08ebeddSWolfgang Muees if ((err != -EINVAL) 215d08ebeddSWolfgang Muees && (err != -ENOSYS) 216d08ebeddSWolfgang Muees && (err != -EFAULT)) 21708ee80ccSPhilip Rakity return err; 218adf66a0dSPierre Ossman 219adf66a0dSPierre Ossman /* 2207ea239d9SPierre Ossman * High capacity cards should have this "magic" size 2217ea239d9SPierre Ossman * stored in their CSD. 2227ea239d9SPierre Ossman */ 2237ea239d9SPierre Ossman if (card->csd.capacity == (4096 * 512)) { 224a3c76eb9SGirish K S pr_err("%s: unable to read EXT_CSD " 2257ea239d9SPierre Ossman "on a possible high capacity card. " 2267ea239d9SPierre Ossman "Card will be ignored.\n", 2277ea239d9SPierre Ossman mmc_hostname(card->host)); 2287ea239d9SPierre Ossman } else { 229a3c76eb9SGirish K S pr_warning("%s: unable to read " 2307ea239d9SPierre Ossman "EXT_CSD, performance might " 2317ea239d9SPierre Ossman "suffer.\n", 2327ea239d9SPierre Ossman mmc_hostname(card->host)); 23317b0429dSPierre Ossman err = 0; 2347ea239d9SPierre Ossman } 23508ee80ccSPhilip Rakity } else 23608ee80ccSPhilip Rakity *new_ext_csd = ext_csd; 237adf66a0dSPierre Ossman 23808ee80ccSPhilip Rakity return err; 2397ea239d9SPierre Ossman } 2407ea239d9SPierre Ossman 24196cf5f02SSeungwon Jeon static void mmc_select_card_type(struct mmc_card *card) 24296cf5f02SSeungwon Jeon { 24396cf5f02SSeungwon Jeon struct mmc_host *host = card->host; 2440a5b6438SSeungwon Jeon u8 card_type = card->ext_csd.raw_card_type; 2455f1a4dd0SLee Jones u32 caps = host->caps, caps2 = host->caps2; 246577fb131SSeungwon Jeon unsigned int hs_max_dtr = 0, hs200_max_dtr = 0; 2472415c0efSSeungwon Jeon unsigned int avail_type = 0; 24896cf5f02SSeungwon Jeon 24996cf5f02SSeungwon Jeon if (caps & MMC_CAP_MMC_HIGHSPEED && 2502415c0efSSeungwon Jeon card_type & EXT_CSD_CARD_TYPE_HS_26) { 2512415c0efSSeungwon Jeon hs_max_dtr = MMC_HIGH_26_MAX_DTR; 2522415c0efSSeungwon Jeon avail_type |= EXT_CSD_CARD_TYPE_HS_26; 2532415c0efSSeungwon Jeon } 2542415c0efSSeungwon Jeon 2552415c0efSSeungwon Jeon if (caps & MMC_CAP_MMC_HIGHSPEED && 2562415c0efSSeungwon Jeon card_type & EXT_CSD_CARD_TYPE_HS_52) { 25796cf5f02SSeungwon Jeon hs_max_dtr = MMC_HIGH_52_MAX_DTR; 2582415c0efSSeungwon Jeon avail_type |= EXT_CSD_CARD_TYPE_HS_52; 2592415c0efSSeungwon Jeon } 26096cf5f02SSeungwon Jeon 2612415c0efSSeungwon Jeon if (caps & MMC_CAP_1_8V_DDR && 2622415c0efSSeungwon Jeon card_type & EXT_CSD_CARD_TYPE_DDR_1_8V) { 26396cf5f02SSeungwon Jeon hs_max_dtr = MMC_HIGH_DDR_MAX_DTR; 2642415c0efSSeungwon Jeon avail_type |= EXT_CSD_CARD_TYPE_DDR_1_8V; 2652415c0efSSeungwon Jeon } 26696cf5f02SSeungwon Jeon 2672415c0efSSeungwon Jeon if (caps & MMC_CAP_1_2V_DDR && 2682415c0efSSeungwon Jeon card_type & EXT_CSD_CARD_TYPE_DDR_1_2V) { 2692415c0efSSeungwon Jeon hs_max_dtr = MMC_HIGH_DDR_MAX_DTR; 2702415c0efSSeungwon Jeon avail_type |= EXT_CSD_CARD_TYPE_DDR_1_2V; 2712415c0efSSeungwon Jeon } 2722415c0efSSeungwon Jeon 2732415c0efSSeungwon Jeon if (caps2 & MMC_CAP2_HS200_1_8V_SDR && 2742415c0efSSeungwon Jeon card_type & EXT_CSD_CARD_TYPE_HS200_1_8V) { 275577fb131SSeungwon Jeon hs200_max_dtr = MMC_HS200_MAX_DTR; 2762415c0efSSeungwon Jeon avail_type |= EXT_CSD_CARD_TYPE_HS200_1_8V; 2772415c0efSSeungwon Jeon } 2782415c0efSSeungwon Jeon 2792415c0efSSeungwon Jeon if (caps2 & MMC_CAP2_HS200_1_2V_SDR && 2802415c0efSSeungwon Jeon card_type & EXT_CSD_CARD_TYPE_HS200_1_2V) { 281577fb131SSeungwon Jeon hs200_max_dtr = MMC_HS200_MAX_DTR; 2822415c0efSSeungwon Jeon avail_type |= EXT_CSD_CARD_TYPE_HS200_1_2V; 2832415c0efSSeungwon Jeon } 28496cf5f02SSeungwon Jeon 2850a5b6438SSeungwon Jeon if (caps2 & MMC_CAP2_HS400_1_8V && 2860a5b6438SSeungwon Jeon card_type & EXT_CSD_CARD_TYPE_HS400_1_8V) { 2870a5b6438SSeungwon Jeon hs200_max_dtr = MMC_HS200_MAX_DTR; 2880a5b6438SSeungwon Jeon avail_type |= EXT_CSD_CARD_TYPE_HS400_1_8V; 2890a5b6438SSeungwon Jeon } 2900a5b6438SSeungwon Jeon 2910a5b6438SSeungwon Jeon if (caps2 & MMC_CAP2_HS400_1_2V && 2920a5b6438SSeungwon Jeon card_type & EXT_CSD_CARD_TYPE_HS400_1_2V) { 2930a5b6438SSeungwon Jeon hs200_max_dtr = MMC_HS200_MAX_DTR; 2940a5b6438SSeungwon Jeon avail_type |= EXT_CSD_CARD_TYPE_HS400_1_2V; 2950a5b6438SSeungwon Jeon } 2960a5b6438SSeungwon Jeon 29796cf5f02SSeungwon Jeon card->ext_csd.hs_max_dtr = hs_max_dtr; 298577fb131SSeungwon Jeon card->ext_csd.hs200_max_dtr = hs200_max_dtr; 2992415c0efSSeungwon Jeon card->mmc_avail_type = avail_type; 30096cf5f02SSeungwon Jeon } 30196cf5f02SSeungwon Jeon 302b4493eeaSGrégory Soutadé static void mmc_manage_enhanced_area(struct mmc_card *card, u8 *ext_csd) 303b4493eeaSGrégory Soutadé { 304994324bbSGrégory Soutadé u8 hc_erase_grp_sz, hc_wp_grp_sz; 305994324bbSGrégory Soutadé 306994324bbSGrégory Soutadé /* 307994324bbSGrégory Soutadé * Disable these attributes by default 308994324bbSGrégory Soutadé */ 309994324bbSGrégory Soutadé card->ext_csd.enhanced_area_offset = -EINVAL; 310994324bbSGrégory Soutadé card->ext_csd.enhanced_area_size = -EINVAL; 311b4493eeaSGrégory Soutadé 312b4493eeaSGrégory Soutadé /* 313b4493eeaSGrégory Soutadé * Enhanced area feature support -- check whether the eMMC 314b4493eeaSGrégory Soutadé * card has the Enhanced area enabled. If so, export enhanced 315b4493eeaSGrégory Soutadé * area offset and size to user by adding sysfs interface. 316b4493eeaSGrégory Soutadé */ 317b4493eeaSGrégory Soutadé if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) && 318b4493eeaSGrégory Soutadé (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) { 319994324bbSGrégory Soutadé if (card->ext_csd.partition_setting_completed) { 320b4493eeaSGrégory Soutadé hc_erase_grp_sz = 321b4493eeaSGrégory Soutadé ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 322b4493eeaSGrégory Soutadé hc_wp_grp_sz = 323b4493eeaSGrégory Soutadé ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 324b4493eeaSGrégory Soutadé 325b4493eeaSGrégory Soutadé /* 326b4493eeaSGrégory Soutadé * calculate the enhanced data area offset, in bytes 327b4493eeaSGrégory Soutadé */ 328b4493eeaSGrégory Soutadé card->ext_csd.enhanced_area_offset = 329b4493eeaSGrégory Soutadé (ext_csd[139] << 24) + (ext_csd[138] << 16) + 330b4493eeaSGrégory Soutadé (ext_csd[137] << 8) + ext_csd[136]; 331b4493eeaSGrégory Soutadé if (mmc_card_blockaddr(card)) 332b4493eeaSGrégory Soutadé card->ext_csd.enhanced_area_offset <<= 9; 333b4493eeaSGrégory Soutadé /* 334b4493eeaSGrégory Soutadé * calculate the enhanced data area size, in kilobytes 335b4493eeaSGrégory Soutadé */ 336b4493eeaSGrégory Soutadé card->ext_csd.enhanced_area_size = 337b4493eeaSGrégory Soutadé (ext_csd[142] << 16) + (ext_csd[141] << 8) + 338b4493eeaSGrégory Soutadé ext_csd[140]; 339b4493eeaSGrégory Soutadé card->ext_csd.enhanced_area_size *= 340b4493eeaSGrégory Soutadé (size_t)(hc_erase_grp_sz * hc_wp_grp_sz); 341b4493eeaSGrégory Soutadé card->ext_csd.enhanced_area_size <<= 9; 342b4493eeaSGrégory Soutadé } else { 343994324bbSGrégory Soutadé pr_warn("%s: defines enhanced area without partition setting complete\n", 344994324bbSGrégory Soutadé mmc_hostname(card->host)); 345994324bbSGrégory Soutadé } 346b4493eeaSGrégory Soutadé } 347b4493eeaSGrégory Soutadé } 348b4493eeaSGrégory Soutadé 349b4493eeaSGrégory Soutadé static void mmc_manage_gp_partitions(struct mmc_card *card, u8 *ext_csd) 350b4493eeaSGrégory Soutadé { 351b4493eeaSGrégory Soutadé int idx; 352994324bbSGrégory Soutadé u8 hc_erase_grp_sz, hc_wp_grp_sz; 353994324bbSGrégory Soutadé unsigned int part_size; 354b4493eeaSGrégory Soutadé 355b4493eeaSGrégory Soutadé /* 356b4493eeaSGrégory Soutadé * General purpose partition feature support -- 357b4493eeaSGrégory Soutadé * If ext_csd has the size of general purpose partitions, 358b4493eeaSGrégory Soutadé * set size, part_cfg, partition name in mmc_part. 359b4493eeaSGrégory Soutadé */ 360b4493eeaSGrégory Soutadé if (ext_csd[EXT_CSD_PARTITION_SUPPORT] & 361b4493eeaSGrégory Soutadé EXT_CSD_PART_SUPPORT_PART_EN) { 362b4493eeaSGrégory Soutadé hc_erase_grp_sz = 363b4493eeaSGrégory Soutadé ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 364b4493eeaSGrégory Soutadé hc_wp_grp_sz = 365b4493eeaSGrégory Soutadé ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 366b4493eeaSGrégory Soutadé 367b4493eeaSGrégory Soutadé for (idx = 0; idx < MMC_NUM_GP_PARTITION; idx++) { 368b4493eeaSGrégory Soutadé if (!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3] && 369b4493eeaSGrégory Soutadé !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1] && 370b4493eeaSGrégory Soutadé !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2]) 371b4493eeaSGrégory Soutadé continue; 372994324bbSGrégory Soutadé if (card->ext_csd.partition_setting_completed == 0) { 373994324bbSGrégory Soutadé pr_warn("%s: has partition size defined without partition complete\n", 374994324bbSGrégory Soutadé mmc_hostname(card->host)); 375994324bbSGrégory Soutadé break; 376994324bbSGrégory Soutadé } 377b4493eeaSGrégory Soutadé part_size = 378b4493eeaSGrégory Soutadé (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2] 379b4493eeaSGrégory Soutadé << 16) + 380b4493eeaSGrégory Soutadé (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1] 381b4493eeaSGrégory Soutadé << 8) + 382b4493eeaSGrégory Soutadé ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3]; 383b4493eeaSGrégory Soutadé part_size *= (size_t)(hc_erase_grp_sz * 384b4493eeaSGrégory Soutadé hc_wp_grp_sz); 385b4493eeaSGrégory Soutadé mmc_part_add(card, part_size << 19, 386b4493eeaSGrégory Soutadé EXT_CSD_PART_CONFIG_ACC_GP0 + idx, 387b4493eeaSGrégory Soutadé "gp%d", idx, false, 388b4493eeaSGrégory Soutadé MMC_BLK_DATA_AREA_GP); 389b4493eeaSGrégory Soutadé } 390b4493eeaSGrégory Soutadé } 391b4493eeaSGrégory Soutadé } 392b4493eeaSGrégory Soutadé 39308ee80ccSPhilip Rakity /* 39408ee80ccSPhilip Rakity * Decode extended CSD. 39508ee80ccSPhilip Rakity */ 39608ee80ccSPhilip Rakity static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd) 39708ee80ccSPhilip Rakity { 398e0c368d5SNamjae Jeon int err = 0, idx; 399e0c368d5SNamjae Jeon unsigned int part_size; 40008ee80ccSPhilip Rakity 40108ee80ccSPhilip Rakity BUG_ON(!card); 40208ee80ccSPhilip Rakity 40308ee80ccSPhilip Rakity if (!ext_csd) 40408ee80ccSPhilip Rakity return 0; 40508ee80ccSPhilip Rakity 4066da24b78SKyungmin Park /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */ 407f39b2dd9SPhilip Rakity card->ext_csd.raw_ext_csd_structure = ext_csd[EXT_CSD_STRUCTURE]; 4086da24b78SKyungmin Park if (card->csd.structure == 3) { 409f39b2dd9SPhilip Rakity if (card->ext_csd.raw_ext_csd_structure > 2) { 410a3c76eb9SGirish K S pr_err("%s: unrecognised EXT_CSD structure " 4118fdd8521SPierre Ossman "version %d\n", mmc_hostname(card->host), 412f39b2dd9SPhilip Rakity card->ext_csd.raw_ext_csd_structure); 4136da24b78SKyungmin Park err = -EINVAL; 4146da24b78SKyungmin Park goto out; 4156da24b78SKyungmin Park } 4166da24b78SKyungmin Park } 4176da24b78SKyungmin Park 41803a59437SRomain Izard /* 41903a59437SRomain Izard * The EXT_CSD format is meant to be forward compatible. As long 42003a59437SRomain Izard * as CSD_STRUCTURE does not change, all values for EXT_CSD_REV 42103a59437SRomain Izard * are authorized, see JEDEC JESD84-B50 section B.8. 42203a59437SRomain Izard */ 4236da24b78SKyungmin Park card->ext_csd.rev = ext_csd[EXT_CSD_REV]; 424d7604d76SPierre Ossman 425f39b2dd9SPhilip Rakity card->ext_csd.raw_sectors[0] = ext_csd[EXT_CSD_SEC_CNT + 0]; 426f39b2dd9SPhilip Rakity card->ext_csd.raw_sectors[1] = ext_csd[EXT_CSD_SEC_CNT + 1]; 427f39b2dd9SPhilip Rakity card->ext_csd.raw_sectors[2] = ext_csd[EXT_CSD_SEC_CNT + 2]; 428f39b2dd9SPhilip Rakity card->ext_csd.raw_sectors[3] = ext_csd[EXT_CSD_SEC_CNT + 3]; 429b1ebe384SJarkko Lavinen if (card->ext_csd.rev >= 2) { 4307ea239d9SPierre Ossman card->ext_csd.sectors = 4317ea239d9SPierre Ossman ext_csd[EXT_CSD_SEC_CNT + 0] << 0 | 4327ea239d9SPierre Ossman ext_csd[EXT_CSD_SEC_CNT + 1] << 8 | 4337ea239d9SPierre Ossman ext_csd[EXT_CSD_SEC_CNT + 2] << 16 | 4347ea239d9SPierre Ossman ext_csd[EXT_CSD_SEC_CNT + 3] << 24; 435fc8a0985SHanumath Prasad 436fc8a0985SHanumath Prasad /* Cards with density > 2GiB are sector addressed */ 437fc8a0985SHanumath Prasad if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512) 4387ea239d9SPierre Ossman mmc_card_set_blockaddr(card); 439d7604d76SPierre Ossman } 44096cf5f02SSeungwon Jeon 441f39b2dd9SPhilip Rakity card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE]; 44296cf5f02SSeungwon Jeon mmc_select_card_type(card); 4437ea239d9SPierre Ossman 444f39b2dd9SPhilip Rakity card->ext_csd.raw_s_a_timeout = ext_csd[EXT_CSD_S_A_TIMEOUT]; 445f39b2dd9SPhilip Rakity card->ext_csd.raw_erase_timeout_mult = 446f39b2dd9SPhilip Rakity ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]; 447f39b2dd9SPhilip Rakity card->ext_csd.raw_hc_erase_grp_size = 448f39b2dd9SPhilip Rakity ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 449b1ebe384SJarkko Lavinen if (card->ext_csd.rev >= 3) { 450b1ebe384SJarkko Lavinen u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT]; 451371a689fSAndrei Warkentin card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG]; 452371a689fSAndrei Warkentin 453371a689fSAndrei Warkentin /* EXT_CSD value is in units of 10ms, but we store in ms */ 454371a689fSAndrei Warkentin card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME]; 455b1ebe384SJarkko Lavinen 456b1ebe384SJarkko Lavinen /* Sleep / awake timeout in 100ns units */ 457b1ebe384SJarkko Lavinen if (sa_shift > 0 && sa_shift <= 0x17) 458b1ebe384SJarkko Lavinen card->ext_csd.sa_timeout = 459b1ebe384SJarkko Lavinen 1 << ext_csd[EXT_CSD_S_A_TIMEOUT]; 460dfe86cbaSAdrian Hunter card->ext_csd.erase_group_def = 461dfe86cbaSAdrian Hunter ext_csd[EXT_CSD_ERASE_GROUP_DEF]; 462dfe86cbaSAdrian Hunter card->ext_csd.hc_erase_timeout = 300 * 463dfe86cbaSAdrian Hunter ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]; 464dfe86cbaSAdrian Hunter card->ext_csd.hc_erase_size = 465dfe86cbaSAdrian Hunter ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10; 466f4c5522bSAndrei Warkentin 467f4c5522bSAndrei Warkentin card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C]; 468371a689fSAndrei Warkentin 469371a689fSAndrei Warkentin /* 470371a689fSAndrei Warkentin * There are two boot regions of equal size, defined in 471371a689fSAndrei Warkentin * multiples of 128K. 472371a689fSAndrei Warkentin */ 473e0c368d5SNamjae Jeon if (ext_csd[EXT_CSD_BOOT_MULT] && mmc_boot_partition_access(card->host)) { 474e0c368d5SNamjae Jeon for (idx = 0; idx < MMC_NUM_BOOT_PARTITION; idx++) { 475e0c368d5SNamjae Jeon part_size = ext_csd[EXT_CSD_BOOT_MULT] << 17; 476e0c368d5SNamjae Jeon mmc_part_add(card, part_size, 477e0c368d5SNamjae Jeon EXT_CSD_PART_CONFIG_ACC_BOOT0 + idx, 478add710eaSJohan Rudholm "boot%d", idx, true, 479add710eaSJohan Rudholm MMC_BLK_DATA_AREA_BOOT); 480e0c368d5SNamjae Jeon } 481e0c368d5SNamjae Jeon } 482b1ebe384SJarkko Lavinen } 483b1ebe384SJarkko Lavinen 484f39b2dd9SPhilip Rakity card->ext_csd.raw_hc_erase_gap_size = 485dd13b4edSJurgen Heeks ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 486f39b2dd9SPhilip Rakity card->ext_csd.raw_sec_trim_mult = 487f39b2dd9SPhilip Rakity ext_csd[EXT_CSD_SEC_TRIM_MULT]; 488f39b2dd9SPhilip Rakity card->ext_csd.raw_sec_erase_mult = 489f39b2dd9SPhilip Rakity ext_csd[EXT_CSD_SEC_ERASE_MULT]; 490f39b2dd9SPhilip Rakity card->ext_csd.raw_sec_feature_support = 491f39b2dd9SPhilip Rakity ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]; 492f39b2dd9SPhilip Rakity card->ext_csd.raw_trim_mult = 493f39b2dd9SPhilip Rakity ext_csd[EXT_CSD_TRIM_MULT]; 494836dc2feSPhilip Rakity card->ext_csd.raw_partition_support = ext_csd[EXT_CSD_PARTITION_SUPPORT]; 495dfe86cbaSAdrian Hunter if (card->ext_csd.rev >= 4) { 49669803d4fSGrégory Soutadé if (ext_csd[EXT_CSD_PARTITION_SETTING_COMPLETED] & 49769803d4fSGrégory Soutadé EXT_CSD_PART_SETTING_COMPLETED) 49869803d4fSGrégory Soutadé card->ext_csd.partition_setting_completed = 1; 49969803d4fSGrégory Soutadé else 50069803d4fSGrégory Soutadé card->ext_csd.partition_setting_completed = 0; 50169803d4fSGrégory Soutadé 502b4493eeaSGrégory Soutadé mmc_manage_enhanced_area(card, ext_csd); 503709de99dSChuanxiao Dong 504b4493eeaSGrégory Soutadé mmc_manage_gp_partitions(card, ext_csd); 505e0c368d5SNamjae Jeon 506dfe86cbaSAdrian Hunter card->ext_csd.sec_trim_mult = 507dfe86cbaSAdrian Hunter ext_csd[EXT_CSD_SEC_TRIM_MULT]; 508dfe86cbaSAdrian Hunter card->ext_csd.sec_erase_mult = 509dfe86cbaSAdrian Hunter ext_csd[EXT_CSD_SEC_ERASE_MULT]; 510dfe86cbaSAdrian Hunter card->ext_csd.sec_feature_support = 511dfe86cbaSAdrian Hunter ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]; 512dfe86cbaSAdrian Hunter card->ext_csd.trim_timeout = 300 * 513dfe86cbaSAdrian Hunter ext_csd[EXT_CSD_TRIM_MULT]; 514add710eaSJohan Rudholm 515add710eaSJohan Rudholm /* 516add710eaSJohan Rudholm * Note that the call to mmc_part_add above defaults to read 517add710eaSJohan Rudholm * only. If this default assumption is changed, the call must 518add710eaSJohan Rudholm * take into account the value of boot_locked below. 519add710eaSJohan Rudholm */ 520add710eaSJohan Rudholm card->ext_csd.boot_ro_lock = ext_csd[EXT_CSD_BOOT_WP]; 521add710eaSJohan Rudholm card->ext_csd.boot_ro_lockable = true; 52260443712SFredrik Soderstedt 52360443712SFredrik Soderstedt /* Save power class values */ 52460443712SFredrik Soderstedt card->ext_csd.raw_pwr_cl_52_195 = 52560443712SFredrik Soderstedt ext_csd[EXT_CSD_PWR_CL_52_195]; 52660443712SFredrik Soderstedt card->ext_csd.raw_pwr_cl_26_195 = 52760443712SFredrik Soderstedt ext_csd[EXT_CSD_PWR_CL_26_195]; 52860443712SFredrik Soderstedt card->ext_csd.raw_pwr_cl_52_360 = 52960443712SFredrik Soderstedt ext_csd[EXT_CSD_PWR_CL_52_360]; 53060443712SFredrik Soderstedt card->ext_csd.raw_pwr_cl_26_360 = 53160443712SFredrik Soderstedt ext_csd[EXT_CSD_PWR_CL_26_360]; 53260443712SFredrik Soderstedt card->ext_csd.raw_pwr_cl_200_195 = 53360443712SFredrik Soderstedt ext_csd[EXT_CSD_PWR_CL_200_195]; 53460443712SFredrik Soderstedt card->ext_csd.raw_pwr_cl_200_360 = 53560443712SFredrik Soderstedt ext_csd[EXT_CSD_PWR_CL_200_360]; 53660443712SFredrik Soderstedt card->ext_csd.raw_pwr_cl_ddr_52_195 = 53760443712SFredrik Soderstedt ext_csd[EXT_CSD_PWR_CL_DDR_52_195]; 53860443712SFredrik Soderstedt card->ext_csd.raw_pwr_cl_ddr_52_360 = 53960443712SFredrik Soderstedt ext_csd[EXT_CSD_PWR_CL_DDR_52_360]; 5400a5b6438SSeungwon Jeon card->ext_csd.raw_pwr_cl_ddr_200_360 = 5410a5b6438SSeungwon Jeon ext_csd[EXT_CSD_PWR_CL_DDR_200_360]; 542dfe86cbaSAdrian Hunter } 543dfe86cbaSAdrian Hunter 544b2499518SAdrian Hunter if (card->ext_csd.rev >= 5) { 5457c4f10acSRomain Izard /* Adjust production date as per JEDEC JESD84-B451 */ 5467c4f10acSRomain Izard if (card->cid.year < 2010) 5477c4f10acSRomain Izard card->cid.year += 16; 5487c4f10acSRomain Izard 549950d56acSJaehoon Chung /* check whether the eMMC card supports BKOPS */ 550950d56acSJaehoon Chung if (ext_csd[EXT_CSD_BKOPS_SUPPORT] & 0x1) { 551950d56acSJaehoon Chung card->ext_csd.bkops = 1; 552950d56acSJaehoon Chung card->ext_csd.bkops_en = ext_csd[EXT_CSD_BKOPS_EN]; 553950d56acSJaehoon Chung card->ext_csd.raw_bkops_status = 554950d56acSJaehoon Chung ext_csd[EXT_CSD_BKOPS_STATUS]; 555950d56acSJaehoon Chung if (!card->ext_csd.bkops_en) 556950d56acSJaehoon Chung pr_info("%s: BKOPS_EN bit is not set\n", 557950d56acSJaehoon Chung mmc_hostname(card->host)); 558950d56acSJaehoon Chung } 559950d56acSJaehoon Chung 560eb0d8f13SJaehoon Chung /* check whether the eMMC card supports HPI */ 561eb0d8f13SJaehoon Chung if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1) { 562eb0d8f13SJaehoon Chung card->ext_csd.hpi = 1; 563eb0d8f13SJaehoon Chung if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x2) 564eb0d8f13SJaehoon Chung card->ext_csd.hpi_cmd = MMC_STOP_TRANSMISSION; 565eb0d8f13SJaehoon Chung else 566eb0d8f13SJaehoon Chung card->ext_csd.hpi_cmd = MMC_SEND_STATUS; 567eb0d8f13SJaehoon Chung /* 568eb0d8f13SJaehoon Chung * Indicate the maximum timeout to close 569eb0d8f13SJaehoon Chung * a command interrupted by HPI 570eb0d8f13SJaehoon Chung */ 571eb0d8f13SJaehoon Chung card->ext_csd.out_of_int_time = 572eb0d8f13SJaehoon Chung ext_csd[EXT_CSD_OUT_OF_INTERRUPT_TIME] * 10; 573eb0d8f13SJaehoon Chung } 574eb0d8f13SJaehoon Chung 575f4c5522bSAndrei Warkentin card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM]; 576b2499518SAdrian Hunter card->ext_csd.rst_n_function = ext_csd[EXT_CSD_RST_N_FUNCTION]; 577090d25feSLoic Pallardy 578090d25feSLoic Pallardy /* 579090d25feSLoic Pallardy * RPMB regions are defined in multiples of 128K. 580090d25feSLoic Pallardy */ 581090d25feSLoic Pallardy card->ext_csd.raw_rpmb_size_mult = ext_csd[EXT_CSD_RPMB_MULT]; 582d0123ccaSBalaji T K if (ext_csd[EXT_CSD_RPMB_MULT] && mmc_host_cmd23(card->host)) { 583090d25feSLoic Pallardy mmc_part_add(card, ext_csd[EXT_CSD_RPMB_MULT] << 17, 584090d25feSLoic Pallardy EXT_CSD_PART_CONFIG_ACC_RPMB, 585090d25feSLoic Pallardy "rpmb", 0, false, 586090d25feSLoic Pallardy MMC_BLK_DATA_AREA_RPMB); 587090d25feSLoic Pallardy } 588b2499518SAdrian Hunter } 589f4c5522bSAndrei Warkentin 5905238acbeSAndrei Warkentin card->ext_csd.raw_erased_mem_count = ext_csd[EXT_CSD_ERASED_MEM_CONT]; 591dfe86cbaSAdrian Hunter if (ext_csd[EXT_CSD_ERASED_MEM_CONT]) 592dfe86cbaSAdrian Hunter card->erased_byte = 0xFF; 593dfe86cbaSAdrian Hunter else 594dfe86cbaSAdrian Hunter card->erased_byte = 0x0; 595dfe86cbaSAdrian Hunter 596336c716aSSeungwon Jeon /* eMMC v4.5 or later */ 597bec8726aSGirish K S if (card->ext_csd.rev >= 6) { 598336c716aSSeungwon Jeon card->ext_csd.feature_support |= MMC_DISCARD_FEATURE; 599336c716aSSeungwon Jeon 600b23cf0bdSSeungwon Jeon card->ext_csd.generic_cmd6_time = 10 * 601b23cf0bdSSeungwon Jeon ext_csd[EXT_CSD_GENERIC_CMD6_TIME]; 602bec8726aSGirish K S card->ext_csd.power_off_longtime = 10 * 603bec8726aSGirish K S ext_csd[EXT_CSD_POWER_OFF_LONG_TIME]; 604b23cf0bdSSeungwon Jeon 605881d1c25SSeungwon Jeon card->ext_csd.cache_size = 606881d1c25SSeungwon Jeon ext_csd[EXT_CSD_CACHE_SIZE + 0] << 0 | 607881d1c25SSeungwon Jeon ext_csd[EXT_CSD_CACHE_SIZE + 1] << 8 | 608881d1c25SSeungwon Jeon ext_csd[EXT_CSD_CACHE_SIZE + 2] << 16 | 609881d1c25SSeungwon Jeon ext_csd[EXT_CSD_CACHE_SIZE + 3] << 24; 6104265900eSSaugata Das 6114265900eSSaugata Das if (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] == 1) 6124265900eSSaugata Das card->ext_csd.data_sector_size = 4096; 6134265900eSSaugata Das else 6144265900eSSaugata Das card->ext_csd.data_sector_size = 512; 6154265900eSSaugata Das 6164265900eSSaugata Das if ((ext_csd[EXT_CSD_DATA_TAG_SUPPORT] & 1) && 6174265900eSSaugata Das (ext_csd[EXT_CSD_TAG_UNIT_SIZE] <= 8)) { 6184265900eSSaugata Das card->ext_csd.data_tag_unit_size = 6194265900eSSaugata Das ((unsigned int) 1 << ext_csd[EXT_CSD_TAG_UNIT_SIZE]) * 6204265900eSSaugata Das (card->ext_csd.data_sector_size); 6214265900eSSaugata Das } else { 6224265900eSSaugata Das card->ext_csd.data_tag_unit_size = 0; 6234265900eSSaugata Das } 624abd9ac14SSeungwon Jeon 625abd9ac14SSeungwon Jeon card->ext_csd.max_packed_writes = 626abd9ac14SSeungwon Jeon ext_csd[EXT_CSD_MAX_PACKED_WRITES]; 627abd9ac14SSeungwon Jeon card->ext_csd.max_packed_reads = 628abd9ac14SSeungwon Jeon ext_csd[EXT_CSD_MAX_PACKED_READS]; 629a5075eb9SSaugata Das } else { 630a5075eb9SSaugata Das card->ext_csd.data_sector_size = 512; 631336c716aSSeungwon Jeon } 632881d1c25SSeungwon Jeon 6337ea239d9SPierre Ossman out: 63408ee80ccSPhilip Rakity return err; 63508ee80ccSPhilip Rakity } 6367ea239d9SPierre Ossman 63708ee80ccSPhilip Rakity static inline void mmc_free_ext_csd(u8 *ext_csd) 63808ee80ccSPhilip Rakity { 63908ee80ccSPhilip Rakity kfree(ext_csd); 64008ee80ccSPhilip Rakity } 64108ee80ccSPhilip Rakity 64208ee80ccSPhilip Rakity 643f39b2dd9SPhilip Rakity static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width) 64408ee80ccSPhilip Rakity { 64508ee80ccSPhilip Rakity u8 *bw_ext_csd; 64608ee80ccSPhilip Rakity int err; 64708ee80ccSPhilip Rakity 648f39b2dd9SPhilip Rakity if (bus_width == MMC_BUS_WIDTH_1) 649f39b2dd9SPhilip Rakity return 0; 65008ee80ccSPhilip Rakity 651f39b2dd9SPhilip Rakity err = mmc_get_ext_csd(card, &bw_ext_csd); 652f39b2dd9SPhilip Rakity 653f39b2dd9SPhilip Rakity if (err || bw_ext_csd == NULL) { 65408ee80ccSPhilip Rakity err = -EINVAL; 65508ee80ccSPhilip Rakity goto out; 65608ee80ccSPhilip Rakity } 65708ee80ccSPhilip Rakity 65808ee80ccSPhilip Rakity /* only compare read only fields */ 659dd13b4edSJurgen Heeks err = !((card->ext_csd.raw_partition_support == 66008ee80ccSPhilip Rakity bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) && 661f39b2dd9SPhilip Rakity (card->ext_csd.raw_erased_mem_count == 66208ee80ccSPhilip Rakity bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) && 663f39b2dd9SPhilip Rakity (card->ext_csd.rev == 66408ee80ccSPhilip Rakity bw_ext_csd[EXT_CSD_REV]) && 665f39b2dd9SPhilip Rakity (card->ext_csd.raw_ext_csd_structure == 66608ee80ccSPhilip Rakity bw_ext_csd[EXT_CSD_STRUCTURE]) && 667f39b2dd9SPhilip Rakity (card->ext_csd.raw_card_type == 66808ee80ccSPhilip Rakity bw_ext_csd[EXT_CSD_CARD_TYPE]) && 669f39b2dd9SPhilip Rakity (card->ext_csd.raw_s_a_timeout == 67008ee80ccSPhilip Rakity bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) && 671f39b2dd9SPhilip Rakity (card->ext_csd.raw_hc_erase_gap_size == 67208ee80ccSPhilip Rakity bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) && 673f39b2dd9SPhilip Rakity (card->ext_csd.raw_erase_timeout_mult == 67408ee80ccSPhilip Rakity bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) && 675f39b2dd9SPhilip Rakity (card->ext_csd.raw_hc_erase_grp_size == 67608ee80ccSPhilip Rakity bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) && 677f39b2dd9SPhilip Rakity (card->ext_csd.raw_sec_trim_mult == 67808ee80ccSPhilip Rakity bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) && 679f39b2dd9SPhilip Rakity (card->ext_csd.raw_sec_erase_mult == 68008ee80ccSPhilip Rakity bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) && 681f39b2dd9SPhilip Rakity (card->ext_csd.raw_sec_feature_support == 68208ee80ccSPhilip Rakity bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) && 683f39b2dd9SPhilip Rakity (card->ext_csd.raw_trim_mult == 68408ee80ccSPhilip Rakity bw_ext_csd[EXT_CSD_TRIM_MULT]) && 685f39b2dd9SPhilip Rakity (card->ext_csd.raw_sectors[0] == 686f39b2dd9SPhilip Rakity bw_ext_csd[EXT_CSD_SEC_CNT + 0]) && 687f39b2dd9SPhilip Rakity (card->ext_csd.raw_sectors[1] == 688f39b2dd9SPhilip Rakity bw_ext_csd[EXT_CSD_SEC_CNT + 1]) && 689f39b2dd9SPhilip Rakity (card->ext_csd.raw_sectors[2] == 690f39b2dd9SPhilip Rakity bw_ext_csd[EXT_CSD_SEC_CNT + 2]) && 691f39b2dd9SPhilip Rakity (card->ext_csd.raw_sectors[3] == 69260443712SFredrik Soderstedt bw_ext_csd[EXT_CSD_SEC_CNT + 3]) && 69360443712SFredrik Soderstedt (card->ext_csd.raw_pwr_cl_52_195 == 69460443712SFredrik Soderstedt bw_ext_csd[EXT_CSD_PWR_CL_52_195]) && 69560443712SFredrik Soderstedt (card->ext_csd.raw_pwr_cl_26_195 == 69660443712SFredrik Soderstedt bw_ext_csd[EXT_CSD_PWR_CL_26_195]) && 69760443712SFredrik Soderstedt (card->ext_csd.raw_pwr_cl_52_360 == 69860443712SFredrik Soderstedt bw_ext_csd[EXT_CSD_PWR_CL_52_360]) && 69960443712SFredrik Soderstedt (card->ext_csd.raw_pwr_cl_26_360 == 70060443712SFredrik Soderstedt bw_ext_csd[EXT_CSD_PWR_CL_26_360]) && 70160443712SFredrik Soderstedt (card->ext_csd.raw_pwr_cl_200_195 == 70260443712SFredrik Soderstedt bw_ext_csd[EXT_CSD_PWR_CL_200_195]) && 70360443712SFredrik Soderstedt (card->ext_csd.raw_pwr_cl_200_360 == 70460443712SFredrik Soderstedt bw_ext_csd[EXT_CSD_PWR_CL_200_360]) && 70560443712SFredrik Soderstedt (card->ext_csd.raw_pwr_cl_ddr_52_195 == 70660443712SFredrik Soderstedt bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_195]) && 70760443712SFredrik Soderstedt (card->ext_csd.raw_pwr_cl_ddr_52_360 == 7080a5b6438SSeungwon Jeon bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_360]) && 7090a5b6438SSeungwon Jeon (card->ext_csd.raw_pwr_cl_ddr_200_360 == 7100a5b6438SSeungwon Jeon bw_ext_csd[EXT_CSD_PWR_CL_DDR_200_360])); 7110a5b6438SSeungwon Jeon 71208ee80ccSPhilip Rakity if (err) 71308ee80ccSPhilip Rakity err = -EINVAL; 71408ee80ccSPhilip Rakity 71508ee80ccSPhilip Rakity out: 71608ee80ccSPhilip Rakity mmc_free_ext_csd(bw_ext_csd); 7177ea239d9SPierre Ossman return err; 7187ea239d9SPierre Ossman } 7197ea239d9SPierre Ossman 72051ec92e2SPierre Ossman MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1], 72151ec92e2SPierre Ossman card->raw_cid[2], card->raw_cid[3]); 72251ec92e2SPierre Ossman MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1], 72351ec92e2SPierre Ossman card->raw_csd[2], card->raw_csd[3]); 72451ec92e2SPierre Ossman MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year); 725dfe86cbaSAdrian Hunter MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9); 726dfe86cbaSAdrian Hunter MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9); 72751ec92e2SPierre Ossman MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev); 72851ec92e2SPierre Ossman MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev); 72951ec92e2SPierre Ossman MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid); 73051ec92e2SPierre Ossman MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name); 73151ec92e2SPierre Ossman MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid); 73251e7e8b6SBernie Thompson MMC_DEV_ATTR(prv, "0x%x\n", card->cid.prv); 73351ec92e2SPierre Ossman MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial); 734709de99dSChuanxiao Dong MMC_DEV_ATTR(enhanced_area_offset, "%llu\n", 735709de99dSChuanxiao Dong card->ext_csd.enhanced_area_offset); 736709de99dSChuanxiao Dong MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size); 737188cc042SLoic Pallardy MMC_DEV_ATTR(raw_rpmb_size_mult, "%#x\n", card->ext_csd.raw_rpmb_size_mult); 738188cc042SLoic Pallardy MMC_DEV_ATTR(rel_sectors, "%#x\n", card->ext_csd.rel_sectors); 73951ec92e2SPierre Ossman 74051ec92e2SPierre Ossman static struct attribute *mmc_std_attrs[] = { 74151ec92e2SPierre Ossman &dev_attr_cid.attr, 74251ec92e2SPierre Ossman &dev_attr_csd.attr, 74351ec92e2SPierre Ossman &dev_attr_date.attr, 744dfe86cbaSAdrian Hunter &dev_attr_erase_size.attr, 745dfe86cbaSAdrian Hunter &dev_attr_preferred_erase_size.attr, 74651ec92e2SPierre Ossman &dev_attr_fwrev.attr, 74751ec92e2SPierre Ossman &dev_attr_hwrev.attr, 74851ec92e2SPierre Ossman &dev_attr_manfid.attr, 74951ec92e2SPierre Ossman &dev_attr_name.attr, 75051ec92e2SPierre Ossman &dev_attr_oemid.attr, 75151e7e8b6SBernie Thompson &dev_attr_prv.attr, 75251ec92e2SPierre Ossman &dev_attr_serial.attr, 753709de99dSChuanxiao Dong &dev_attr_enhanced_area_offset.attr, 754709de99dSChuanxiao Dong &dev_attr_enhanced_area_size.attr, 755188cc042SLoic Pallardy &dev_attr_raw_rpmb_size_mult.attr, 756188cc042SLoic Pallardy &dev_attr_rel_sectors.attr, 75751ec92e2SPierre Ossman NULL, 75851ec92e2SPierre Ossman }; 759d1e58212SAxel Lin ATTRIBUTE_GROUPS(mmc_std); 76051ec92e2SPierre Ossman 76151ec92e2SPierre Ossman static struct device_type mmc_type = { 762d1e58212SAxel Lin .groups = mmc_std_groups, 76351ec92e2SPierre Ossman }; 76451ec92e2SPierre Ossman 7657ea239d9SPierre Ossman /* 766b87d8dbfSGirish K S * Select the PowerClass for the current bus width 767b87d8dbfSGirish K S * If power class is defined for 4/8 bit bus in the 768b87d8dbfSGirish K S * extended CSD register, select it by executing the 769b87d8dbfSGirish K S * mmc_switch command. 770b87d8dbfSGirish K S */ 7712385049dSSeungwon Jeon static int __mmc_select_powerclass(struct mmc_card *card, 77260443712SFredrik Soderstedt unsigned int bus_width) 773b87d8dbfSGirish K S { 7742385049dSSeungwon Jeon struct mmc_host *host = card->host; 7752385049dSSeungwon Jeon struct mmc_ext_csd *ext_csd = &card->ext_csd; 77660443712SFredrik Soderstedt unsigned int pwrclass_val = 0; 7772385049dSSeungwon Jeon int err = 0; 778b87d8dbfSGirish K S 779b87d8dbfSGirish K S /* Power class selection is supported for versions >= 4.0 */ 780b87d8dbfSGirish K S if (card->csd.mmca_vsn < CSD_SPEC_VER_4) 781b87d8dbfSGirish K S return 0; 782b87d8dbfSGirish K S 783b87d8dbfSGirish K S /* Power class values are defined only for 4/8 bit bus */ 784b87d8dbfSGirish K S if (bus_width == EXT_CSD_BUS_WIDTH_1) 785b87d8dbfSGirish K S return 0; 786b87d8dbfSGirish K S 787b87d8dbfSGirish K S switch (1 << host->ios.vdd) { 788b87d8dbfSGirish K S case MMC_VDD_165_195: 7892385049dSSeungwon Jeon if (host->ios.clock <= MMC_HIGH_26_MAX_DTR) 7902385049dSSeungwon Jeon pwrclass_val = ext_csd->raw_pwr_cl_26_195; 7912385049dSSeungwon Jeon else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR) 79260443712SFredrik Soderstedt pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ? 7932385049dSSeungwon Jeon ext_csd->raw_pwr_cl_52_195 : 7942385049dSSeungwon Jeon ext_csd->raw_pwr_cl_ddr_52_195; 7952385049dSSeungwon Jeon else if (host->ios.clock <= MMC_HS200_MAX_DTR) 7962385049dSSeungwon Jeon pwrclass_val = ext_csd->raw_pwr_cl_200_195; 797b87d8dbfSGirish K S break; 79893fc5a47SSubhash Jadavani case MMC_VDD_27_28: 79993fc5a47SSubhash Jadavani case MMC_VDD_28_29: 80093fc5a47SSubhash Jadavani case MMC_VDD_29_30: 80193fc5a47SSubhash Jadavani case MMC_VDD_30_31: 80293fc5a47SSubhash Jadavani case MMC_VDD_31_32: 803b87d8dbfSGirish K S case MMC_VDD_32_33: 804b87d8dbfSGirish K S case MMC_VDD_33_34: 805b87d8dbfSGirish K S case MMC_VDD_34_35: 806b87d8dbfSGirish K S case MMC_VDD_35_36: 8072385049dSSeungwon Jeon if (host->ios.clock <= MMC_HIGH_26_MAX_DTR) 8082385049dSSeungwon Jeon pwrclass_val = ext_csd->raw_pwr_cl_26_360; 8092385049dSSeungwon Jeon else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR) 81060443712SFredrik Soderstedt pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ? 8112385049dSSeungwon Jeon ext_csd->raw_pwr_cl_52_360 : 8122385049dSSeungwon Jeon ext_csd->raw_pwr_cl_ddr_52_360; 8132385049dSSeungwon Jeon else if (host->ios.clock <= MMC_HS200_MAX_DTR) 8140a5b6438SSeungwon Jeon pwrclass_val = (bus_width == EXT_CSD_DDR_BUS_WIDTH_8) ? 8150a5b6438SSeungwon Jeon ext_csd->raw_pwr_cl_ddr_200_360 : 8160a5b6438SSeungwon Jeon ext_csd->raw_pwr_cl_200_360; 817b87d8dbfSGirish K S break; 818b87d8dbfSGirish K S default: 819b87d8dbfSGirish K S pr_warning("%s: Voltage range not supported " 820b87d8dbfSGirish K S "for power class.\n", mmc_hostname(host)); 821b87d8dbfSGirish K S return -EINVAL; 822b87d8dbfSGirish K S } 823b87d8dbfSGirish K S 824b87d8dbfSGirish K S if (bus_width & (EXT_CSD_BUS_WIDTH_8 | EXT_CSD_DDR_BUS_WIDTH_8)) 825b87d8dbfSGirish K S pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_8BIT_MASK) >> 826b87d8dbfSGirish K S EXT_CSD_PWR_CL_8BIT_SHIFT; 827b87d8dbfSGirish K S else 828b87d8dbfSGirish K S pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_4BIT_MASK) >> 829b87d8dbfSGirish K S EXT_CSD_PWR_CL_4BIT_SHIFT; 830b87d8dbfSGirish K S 831b87d8dbfSGirish K S /* If the power class is different from the default value */ 832b87d8dbfSGirish K S if (pwrclass_val > 0) { 833b87d8dbfSGirish K S err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 834b87d8dbfSGirish K S EXT_CSD_POWER_CLASS, 835b87d8dbfSGirish K S pwrclass_val, 83671fe3eb0SSeungwon Jeon card->ext_csd.generic_cmd6_time); 837b87d8dbfSGirish K S } 838b87d8dbfSGirish K S 839b87d8dbfSGirish K S return err; 840b87d8dbfSGirish K S } 841b87d8dbfSGirish K S 8422385049dSSeungwon Jeon static int mmc_select_powerclass(struct mmc_card *card) 8432385049dSSeungwon Jeon { 8442385049dSSeungwon Jeon struct mmc_host *host = card->host; 8452385049dSSeungwon Jeon u32 bus_width, ext_csd_bits; 8462385049dSSeungwon Jeon int err, ddr; 8472385049dSSeungwon Jeon 8482385049dSSeungwon Jeon /* Power class selection is supported for versions >= 4.0 */ 8492385049dSSeungwon Jeon if (card->csd.mmca_vsn < CSD_SPEC_VER_4) 8502385049dSSeungwon Jeon return 0; 8512385049dSSeungwon Jeon 8522385049dSSeungwon Jeon bus_width = host->ios.bus_width; 8532385049dSSeungwon Jeon /* Power class values are defined only for 4/8 bit bus */ 8542385049dSSeungwon Jeon if (bus_width == MMC_BUS_WIDTH_1) 8552385049dSSeungwon Jeon return 0; 8562385049dSSeungwon Jeon 8572385049dSSeungwon Jeon ddr = card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52; 8582385049dSSeungwon Jeon if (ddr) 8592385049dSSeungwon Jeon ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ? 8602385049dSSeungwon Jeon EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4; 8612385049dSSeungwon Jeon else 8622385049dSSeungwon Jeon ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ? 8632385049dSSeungwon Jeon EXT_CSD_BUS_WIDTH_8 : EXT_CSD_BUS_WIDTH_4; 8642385049dSSeungwon Jeon 8652385049dSSeungwon Jeon err = __mmc_select_powerclass(card, ext_csd_bits); 8662385049dSSeungwon Jeon if (err) 8672385049dSSeungwon Jeon pr_warn("%s: power class selection to bus width %d ddr %d failed\n", 8682385049dSSeungwon Jeon mmc_hostname(host), 1 << bus_width, ddr); 8692385049dSSeungwon Jeon 8702385049dSSeungwon Jeon return err; 8712385049dSSeungwon Jeon } 8722385049dSSeungwon Jeon 873b87d8dbfSGirish K S /* 874577fb131SSeungwon Jeon * Set the bus speed for the selected speed mode. 875a4924c71SGirish K S */ 876577fb131SSeungwon Jeon static void mmc_set_bus_speed(struct mmc_card *card) 877a4924c71SGirish K S { 878577fb131SSeungwon Jeon unsigned int max_dtr = (unsigned int)-1; 879577fb131SSeungwon Jeon 8800a5b6438SSeungwon Jeon if ((mmc_card_hs200(card) || mmc_card_hs400(card)) && 8810a5b6438SSeungwon Jeon max_dtr > card->ext_csd.hs200_max_dtr) 882577fb131SSeungwon Jeon max_dtr = card->ext_csd.hs200_max_dtr; 883577fb131SSeungwon Jeon else if (mmc_card_hs(card) && max_dtr > card->ext_csd.hs_max_dtr) 884577fb131SSeungwon Jeon max_dtr = card->ext_csd.hs_max_dtr; 885577fb131SSeungwon Jeon else if (max_dtr > card->csd.max_dtr) 886577fb131SSeungwon Jeon max_dtr = card->csd.max_dtr; 887577fb131SSeungwon Jeon 888577fb131SSeungwon Jeon mmc_set_clock(card->host, max_dtr); 889577fb131SSeungwon Jeon } 890577fb131SSeungwon Jeon 891577fb131SSeungwon Jeon /* 892577fb131SSeungwon Jeon * Select the bus width amoung 4-bit and 8-bit(SDR). 893577fb131SSeungwon Jeon * If the bus width is changed successfully, return the selected width value. 894577fb131SSeungwon Jeon * Zero is returned instead of error value if the wide width is not supported. 895577fb131SSeungwon Jeon */ 896577fb131SSeungwon Jeon static int mmc_select_bus_width(struct mmc_card *card) 897577fb131SSeungwon Jeon { 898a4924c71SGirish K S static unsigned ext_csd_bits[] = { 899a4924c71SGirish K S EXT_CSD_BUS_WIDTH_8, 900577fb131SSeungwon Jeon EXT_CSD_BUS_WIDTH_4, 901a4924c71SGirish K S }; 902a4924c71SGirish K S static unsigned bus_widths[] = { 903a4924c71SGirish K S MMC_BUS_WIDTH_8, 904577fb131SSeungwon Jeon MMC_BUS_WIDTH_4, 905a4924c71SGirish K S }; 906577fb131SSeungwon Jeon struct mmc_host *host = card->host; 907577fb131SSeungwon Jeon unsigned idx, bus_width = 0; 908577fb131SSeungwon Jeon int err = 0; 909a4924c71SGirish K S 910577fb131SSeungwon Jeon if ((card->csd.mmca_vsn < CSD_SPEC_VER_4) && 911577fb131SSeungwon Jeon !(host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA))) 912577fb131SSeungwon Jeon return 0; 913a4924c71SGirish K S 914577fb131SSeungwon Jeon idx = (host->caps & MMC_CAP_8_BIT_DATA) ? 0 : 1; 915a4924c71SGirish K S 916a4924c71SGirish K S /* 917a4924c71SGirish K S * Unlike SD, MMC cards dont have a configuration register to notify 918a4924c71SGirish K S * supported bus width. So bus test command should be run to identify 919a4924c71SGirish K S * the supported bus width or compare the ext csd values of current 920a4924c71SGirish K S * bus width and ext csd values of 1 bit mode read earlier. 921a4924c71SGirish K S */ 922577fb131SSeungwon Jeon for (; idx < ARRAY_SIZE(bus_widths); idx++) { 923a4924c71SGirish K S /* 924a4924c71SGirish K S * Host is capable of 8bit transfer, then switch 925a4924c71SGirish K S * the device to work in 8bit transfer mode. If the 926a4924c71SGirish K S * mmc switch command returns error then switch to 927a4924c71SGirish K S * 4bit transfer mode. On success set the corresponding 928a4924c71SGirish K S * bus width on the host. 929a4924c71SGirish K S */ 930a4924c71SGirish K S err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 931a4924c71SGirish K S EXT_CSD_BUS_WIDTH, 932a4924c71SGirish K S ext_csd_bits[idx], 933a4924c71SGirish K S card->ext_csd.generic_cmd6_time); 934a4924c71SGirish K S if (err) 935a4924c71SGirish K S continue; 936a4924c71SGirish K S 937577fb131SSeungwon Jeon bus_width = bus_widths[idx]; 938577fb131SSeungwon Jeon mmc_set_bus_width(host, bus_width); 939a4924c71SGirish K S 940577fb131SSeungwon Jeon /* 941577fb131SSeungwon Jeon * If controller can't handle bus width test, 942577fb131SSeungwon Jeon * compare ext_csd previously read in 1 bit mode 943577fb131SSeungwon Jeon * against ext_csd at new bus width 944577fb131SSeungwon Jeon */ 945a4924c71SGirish K S if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST)) 946577fb131SSeungwon Jeon err = mmc_compare_ext_csds(card, bus_width); 947a4924c71SGirish K S else 948577fb131SSeungwon Jeon err = mmc_bus_test(card, bus_width); 949577fb131SSeungwon Jeon 950577fb131SSeungwon Jeon if (!err) { 951577fb131SSeungwon Jeon err = bus_width; 952a4924c71SGirish K S break; 953577fb131SSeungwon Jeon } else { 954577fb131SSeungwon Jeon pr_warn("%s: switch to bus width %d failed\n", 955577fb131SSeungwon Jeon mmc_hostname(host), ext_csd_bits[idx]); 956577fb131SSeungwon Jeon } 957a4924c71SGirish K S } 958a4924c71SGirish K S 959577fb131SSeungwon Jeon return err; 960577fb131SSeungwon Jeon } 961577fb131SSeungwon Jeon 962577fb131SSeungwon Jeon /* 963577fb131SSeungwon Jeon * Switch to the high-speed mode 964577fb131SSeungwon Jeon */ 965577fb131SSeungwon Jeon static int mmc_select_hs(struct mmc_card *card) 966577fb131SSeungwon Jeon { 967577fb131SSeungwon Jeon int err; 968577fb131SSeungwon Jeon 9694509f847SUlf Hansson err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 970577fb131SSeungwon Jeon EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS, 97157de31f6SUlf Hansson card->ext_csd.generic_cmd6_time, 97257de31f6SUlf Hansson true, true, true); 973577fb131SSeungwon Jeon if (!err) 974577fb131SSeungwon Jeon mmc_set_timing(card->host, MMC_TIMING_MMC_HS); 975577fb131SSeungwon Jeon 976577fb131SSeungwon Jeon return err; 977577fb131SSeungwon Jeon } 978577fb131SSeungwon Jeon 979577fb131SSeungwon Jeon /* 980577fb131SSeungwon Jeon * Activate wide bus and DDR if supported. 981577fb131SSeungwon Jeon */ 982577fb131SSeungwon Jeon static int mmc_select_hs_ddr(struct mmc_card *card) 983577fb131SSeungwon Jeon { 984577fb131SSeungwon Jeon struct mmc_host *host = card->host; 985577fb131SSeungwon Jeon u32 bus_width, ext_csd_bits; 986577fb131SSeungwon Jeon int err = 0; 987577fb131SSeungwon Jeon 988577fb131SSeungwon Jeon if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52)) 989577fb131SSeungwon Jeon return 0; 990577fb131SSeungwon Jeon 991577fb131SSeungwon Jeon bus_width = host->ios.bus_width; 992577fb131SSeungwon Jeon if (bus_width == MMC_BUS_WIDTH_1) 993577fb131SSeungwon Jeon return 0; 994577fb131SSeungwon Jeon 995577fb131SSeungwon Jeon ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ? 996577fb131SSeungwon Jeon EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4; 997577fb131SSeungwon Jeon 998577fb131SSeungwon Jeon err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 999577fb131SSeungwon Jeon EXT_CSD_BUS_WIDTH, 1000577fb131SSeungwon Jeon ext_csd_bits, 1001577fb131SSeungwon Jeon card->ext_csd.generic_cmd6_time); 1002577fb131SSeungwon Jeon if (err) { 1003577fb131SSeungwon Jeon pr_warn("%s: switch to bus width %d ddr failed\n", 1004577fb131SSeungwon Jeon mmc_hostname(host), 1 << bus_width); 1005577fb131SSeungwon Jeon return err; 1006577fb131SSeungwon Jeon } 1007577fb131SSeungwon Jeon 1008577fb131SSeungwon Jeon /* 1009577fb131SSeungwon Jeon * eMMC cards can support 3.3V to 1.2V i/o (vccq) 1010577fb131SSeungwon Jeon * signaling. 1011577fb131SSeungwon Jeon * 1012577fb131SSeungwon Jeon * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq. 1013577fb131SSeungwon Jeon * 1014577fb131SSeungwon Jeon * 1.8V vccq at 3.3V core voltage (vcc) is not required 1015577fb131SSeungwon Jeon * in the JEDEC spec for DDR. 1016577fb131SSeungwon Jeon * 1017312449efSChuanxiao.Dong * Even (e)MMC card can support 3.3v to 1.2v vccq, but not all 1018312449efSChuanxiao.Dong * host controller can support this, like some of the SDHCI 1019312449efSChuanxiao.Dong * controller which connect to an eMMC device. Some of these 1020312449efSChuanxiao.Dong * host controller still needs to use 1.8v vccq for supporting 1021312449efSChuanxiao.Dong * DDR mode. 1022312449efSChuanxiao.Dong * 1023312449efSChuanxiao.Dong * So the sequence will be: 1024312449efSChuanxiao.Dong * if (host and device can both support 1.2v IO) 1025312449efSChuanxiao.Dong * use 1.2v IO; 1026312449efSChuanxiao.Dong * else if (host and device can both support 1.8v IO) 1027312449efSChuanxiao.Dong * use 1.8v IO; 1028312449efSChuanxiao.Dong * so if host and device can only support 3.3v IO, this is the 1029312449efSChuanxiao.Dong * last choice. 1030577fb131SSeungwon Jeon * 1031577fb131SSeungwon Jeon * WARNING: eMMC rules are NOT the same as SD DDR 1032577fb131SSeungwon Jeon */ 1033312449efSChuanxiao.Dong err = -EINVAL; 1034312449efSChuanxiao.Dong if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_2V) 1035312449efSChuanxiao.Dong err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120); 1036577fb131SSeungwon Jeon 1037312449efSChuanxiao.Dong if (err && (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_8V)) 1038312449efSChuanxiao.Dong err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180); 1039312449efSChuanxiao.Dong 1040312449efSChuanxiao.Dong /* make sure vccq is 3.3v after switching disaster */ 1041312449efSChuanxiao.Dong if (err) 1042312449efSChuanxiao.Dong err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330); 1043312449efSChuanxiao.Dong 1044312449efSChuanxiao.Dong if (!err) 1045577fb131SSeungwon Jeon mmc_set_timing(host, MMC_TIMING_MMC_DDR52); 1046577fb131SSeungwon Jeon 1047577fb131SSeungwon Jeon return err; 1048577fb131SSeungwon Jeon } 1049577fb131SSeungwon Jeon 10500a5b6438SSeungwon Jeon static int mmc_select_hs400(struct mmc_card *card) 10510a5b6438SSeungwon Jeon { 10520a5b6438SSeungwon Jeon struct mmc_host *host = card->host; 10530a5b6438SSeungwon Jeon int err = 0; 10540a5b6438SSeungwon Jeon 10550a5b6438SSeungwon Jeon /* 10560a5b6438SSeungwon Jeon * HS400 mode requires 8-bit bus width 10570a5b6438SSeungwon Jeon */ 10580a5b6438SSeungwon Jeon if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 && 10590a5b6438SSeungwon Jeon host->ios.bus_width == MMC_BUS_WIDTH_8)) 10600a5b6438SSeungwon Jeon return 0; 10610a5b6438SSeungwon Jeon 10620a5b6438SSeungwon Jeon /* 10630a5b6438SSeungwon Jeon * Before switching to dual data rate operation for HS400, 10640a5b6438SSeungwon Jeon * it is required to convert from HS200 mode to HS mode. 10650a5b6438SSeungwon Jeon */ 10660a5b6438SSeungwon Jeon mmc_set_timing(card->host, MMC_TIMING_MMC_HS); 10670a5b6438SSeungwon Jeon mmc_set_bus_speed(card); 10680a5b6438SSeungwon Jeon 10690a5b6438SSeungwon Jeon err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 10700a5b6438SSeungwon Jeon EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS, 10710a5b6438SSeungwon Jeon card->ext_csd.generic_cmd6_time, 10720a5b6438SSeungwon Jeon true, true, true); 10730a5b6438SSeungwon Jeon if (err) { 10740a5b6438SSeungwon Jeon pr_warn("%s: switch to high-speed from hs200 failed, err:%d\n", 10750a5b6438SSeungwon Jeon mmc_hostname(host), err); 10760a5b6438SSeungwon Jeon return err; 10770a5b6438SSeungwon Jeon } 10780a5b6438SSeungwon Jeon 10790a5b6438SSeungwon Jeon err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 10800a5b6438SSeungwon Jeon EXT_CSD_BUS_WIDTH, 10810a5b6438SSeungwon Jeon EXT_CSD_DDR_BUS_WIDTH_8, 10820a5b6438SSeungwon Jeon card->ext_csd.generic_cmd6_time); 10830a5b6438SSeungwon Jeon if (err) { 10840a5b6438SSeungwon Jeon pr_warn("%s: switch to bus width for hs400 failed, err:%d\n", 10850a5b6438SSeungwon Jeon mmc_hostname(host), err); 10860a5b6438SSeungwon Jeon return err; 10870a5b6438SSeungwon Jeon } 10880a5b6438SSeungwon Jeon 10890a5b6438SSeungwon Jeon err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 10900a5b6438SSeungwon Jeon EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS400, 10910a5b6438SSeungwon Jeon card->ext_csd.generic_cmd6_time, 10920a5b6438SSeungwon Jeon true, true, true); 10930a5b6438SSeungwon Jeon if (err) { 10940a5b6438SSeungwon Jeon pr_warn("%s: switch to hs400 failed, err:%d\n", 10950a5b6438SSeungwon Jeon mmc_hostname(host), err); 10960a5b6438SSeungwon Jeon return err; 10970a5b6438SSeungwon Jeon } 10980a5b6438SSeungwon Jeon 10990a5b6438SSeungwon Jeon mmc_set_timing(host, MMC_TIMING_MMC_HS400); 11000a5b6438SSeungwon Jeon mmc_set_bus_speed(card); 11010a5b6438SSeungwon Jeon 11020a5b6438SSeungwon Jeon return 0; 11030a5b6438SSeungwon Jeon } 11040a5b6438SSeungwon Jeon 1105577fb131SSeungwon Jeon /* 1106577fb131SSeungwon Jeon * For device supporting HS200 mode, the following sequence 1107577fb131SSeungwon Jeon * should be done before executing the tuning process. 1108577fb131SSeungwon Jeon * 1. set the desired bus width(4-bit or 8-bit, 1-bit is not supported) 1109577fb131SSeungwon Jeon * 2. switch to HS200 mode 1110577fb131SSeungwon Jeon * 3. set the clock to > 52Mhz and <=200MHz 1111577fb131SSeungwon Jeon */ 1112577fb131SSeungwon Jeon static int mmc_select_hs200(struct mmc_card *card) 1113577fb131SSeungwon Jeon { 1114577fb131SSeungwon Jeon struct mmc_host *host = card->host; 1115577fb131SSeungwon Jeon int err = -EINVAL; 1116577fb131SSeungwon Jeon 1117577fb131SSeungwon Jeon if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_2V) 1118577fb131SSeungwon Jeon err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120); 1119577fb131SSeungwon Jeon 1120577fb131SSeungwon Jeon if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_8V) 1121577fb131SSeungwon Jeon err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180); 1122577fb131SSeungwon Jeon 1123577fb131SSeungwon Jeon /* If fails try again during next card power cycle */ 1124577fb131SSeungwon Jeon if (err) 1125577fb131SSeungwon Jeon goto err; 1126577fb131SSeungwon Jeon 1127577fb131SSeungwon Jeon /* 1128577fb131SSeungwon Jeon * Set the bus width(4 or 8) with host's support and 1129577fb131SSeungwon Jeon * switch to HS200 mode if bus width is set successfully. 1130577fb131SSeungwon Jeon */ 1131577fb131SSeungwon Jeon err = mmc_select_bus_width(card); 1132577fb131SSeungwon Jeon if (!IS_ERR_VALUE(err)) { 1133577fb131SSeungwon Jeon err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1134577fb131SSeungwon Jeon EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS200, 1135577fb131SSeungwon Jeon card->ext_csd.generic_cmd6_time, 1136577fb131SSeungwon Jeon true, true, true); 1137577fb131SSeungwon Jeon if (!err) 1138577fb131SSeungwon Jeon mmc_set_timing(host, MMC_TIMING_MMC_HS200); 1139577fb131SSeungwon Jeon } 1140a4924c71SGirish K S err: 1141a4924c71SGirish K S return err; 1142a4924c71SGirish K S } 1143a4924c71SGirish K S 1144a4924c71SGirish K S /* 1145577fb131SSeungwon Jeon * Activate High Speed or HS200 mode if supported. 1146577fb131SSeungwon Jeon */ 1147577fb131SSeungwon Jeon static int mmc_select_timing(struct mmc_card *card) 1148577fb131SSeungwon Jeon { 1149577fb131SSeungwon Jeon int err = 0; 1150577fb131SSeungwon Jeon 1151577fb131SSeungwon Jeon if ((card->csd.mmca_vsn < CSD_SPEC_VER_4 && 1152577fb131SSeungwon Jeon card->ext_csd.hs_max_dtr == 0)) 1153577fb131SSeungwon Jeon goto bus_speed; 1154577fb131SSeungwon Jeon 1155577fb131SSeungwon Jeon if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200) 1156577fb131SSeungwon Jeon err = mmc_select_hs200(card); 1157577fb131SSeungwon Jeon else if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS) 1158577fb131SSeungwon Jeon err = mmc_select_hs(card); 1159577fb131SSeungwon Jeon 1160577fb131SSeungwon Jeon if (err && err != -EBADMSG) 1161577fb131SSeungwon Jeon return err; 1162577fb131SSeungwon Jeon 1163577fb131SSeungwon Jeon if (err) { 1164577fb131SSeungwon Jeon pr_warn("%s: switch to %s failed\n", 1165577fb131SSeungwon Jeon mmc_card_hs(card) ? "high-speed" : 1166577fb131SSeungwon Jeon (mmc_card_hs200(card) ? "hs200" : ""), 1167577fb131SSeungwon Jeon mmc_hostname(card->host)); 1168577fb131SSeungwon Jeon err = 0; 1169577fb131SSeungwon Jeon } 1170577fb131SSeungwon Jeon 1171577fb131SSeungwon Jeon bus_speed: 1172577fb131SSeungwon Jeon /* 1173577fb131SSeungwon Jeon * Set the bus speed to the selected bus timing. 1174577fb131SSeungwon Jeon * If timing is not selected, backward compatible is the default. 1175577fb131SSeungwon Jeon */ 1176577fb131SSeungwon Jeon mmc_set_bus_speed(card); 1177577fb131SSeungwon Jeon return err; 1178577fb131SSeungwon Jeon } 1179577fb131SSeungwon Jeon 118048d11e06SStephen Boyd const u8 tuning_blk_pattern_4bit[MMC_TUNING_BLK_PATTERN_4BIT_SIZE] = { 118148d11e06SStephen Boyd 0xff, 0x0f, 0xff, 0x00, 0xff, 0xcc, 0xc3, 0xcc, 118248d11e06SStephen Boyd 0xc3, 0x3c, 0xcc, 0xff, 0xfe, 0xff, 0xfe, 0xef, 118348d11e06SStephen Boyd 0xff, 0xdf, 0xff, 0xdd, 0xff, 0xfb, 0xff, 0xfb, 118448d11e06SStephen Boyd 0xbf, 0xff, 0x7f, 0xff, 0x77, 0xf7, 0xbd, 0xef, 118548d11e06SStephen Boyd 0xff, 0xf0, 0xff, 0xf0, 0x0f, 0xfc, 0xcc, 0x3c, 118648d11e06SStephen Boyd 0xcc, 0x33, 0xcc, 0xcf, 0xff, 0xef, 0xff, 0xee, 118748d11e06SStephen Boyd 0xff, 0xfd, 0xff, 0xfd, 0xdf, 0xff, 0xbf, 0xff, 118848d11e06SStephen Boyd 0xbb, 0xff, 0xf7, 0xff, 0xf7, 0x7f, 0x7b, 0xde, 118948d11e06SStephen Boyd }; 119048d11e06SStephen Boyd EXPORT_SYMBOL(tuning_blk_pattern_4bit); 119148d11e06SStephen Boyd 119248d11e06SStephen Boyd const u8 tuning_blk_pattern_8bit[MMC_TUNING_BLK_PATTERN_8BIT_SIZE] = { 119348d11e06SStephen Boyd 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 119448d11e06SStephen Boyd 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc, 0xcc, 119548d11e06SStephen Boyd 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff, 0xff, 119648d11e06SStephen Boyd 0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee, 0xff, 119748d11e06SStephen Boyd 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd, 0xdd, 119848d11e06SStephen Boyd 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb, 119948d11e06SStephen Boyd 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff, 0xff, 120048d11e06SStephen Boyd 0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee, 0xff, 120148d11e06SStephen Boyd 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 120248d11e06SStephen Boyd 0x00, 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc, 120348d11e06SStephen Boyd 0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff, 120448d11e06SStephen Boyd 0xff, 0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee, 120548d11e06SStephen Boyd 0xff, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd, 120648d11e06SStephen Boyd 0xdd, 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff, 120748d11e06SStephen Boyd 0xbb, 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff, 120848d11e06SStephen Boyd 0xff, 0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee, 120948d11e06SStephen Boyd }; 121048d11e06SStephen Boyd EXPORT_SYMBOL(tuning_blk_pattern_8bit); 121148d11e06SStephen Boyd 1212577fb131SSeungwon Jeon /* 1213577fb131SSeungwon Jeon * Execute tuning sequence to seek the proper bus operating 12140a5b6438SSeungwon Jeon * conditions for HS200 and HS400, which sends CMD21 to the device. 1215577fb131SSeungwon Jeon */ 1216577fb131SSeungwon Jeon static int mmc_hs200_tuning(struct mmc_card *card) 1217577fb131SSeungwon Jeon { 1218577fb131SSeungwon Jeon struct mmc_host *host = card->host; 1219577fb131SSeungwon Jeon int err = 0; 1220577fb131SSeungwon Jeon 12210a5b6438SSeungwon Jeon /* 12220a5b6438SSeungwon Jeon * Timing should be adjusted to the HS400 target 12230a5b6438SSeungwon Jeon * operation frequency for tuning process 12240a5b6438SSeungwon Jeon */ 12250a5b6438SSeungwon Jeon if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 && 12260a5b6438SSeungwon Jeon host->ios.bus_width == MMC_BUS_WIDTH_8) 12270a5b6438SSeungwon Jeon if (host->ops->prepare_hs400_tuning) 12280a5b6438SSeungwon Jeon host->ops->prepare_hs400_tuning(host, &host->ios); 12290a5b6438SSeungwon Jeon 1230577fb131SSeungwon Jeon if (host->ops->execute_tuning) { 1231577fb131SSeungwon Jeon mmc_host_clk_hold(host); 1232577fb131SSeungwon Jeon err = host->ops->execute_tuning(host, 1233577fb131SSeungwon Jeon MMC_SEND_TUNING_BLOCK_HS200); 1234577fb131SSeungwon Jeon mmc_host_clk_release(host); 1235577fb131SSeungwon Jeon 1236577fb131SSeungwon Jeon if (err) 1237577fb131SSeungwon Jeon pr_warn("%s: tuning execution failed\n", 1238577fb131SSeungwon Jeon mmc_hostname(host)); 1239577fb131SSeungwon Jeon } 1240577fb131SSeungwon Jeon 1241577fb131SSeungwon Jeon return err; 1242577fb131SSeungwon Jeon } 1243577fb131SSeungwon Jeon 1244577fb131SSeungwon Jeon /* 12456abaa0c9SPierre Ossman * Handle the detection and initialisation of a card. 12466abaa0c9SPierre Ossman * 12478769392bSDeepak Saxena * In the case of a resume, "oldcard" will contain the card 12486abaa0c9SPierre Ossman * we're trying to reinitialise. 12497ea239d9SPierre Ossman */ 12508c75deaeSPierre Ossman static int mmc_init_card(struct mmc_host *host, u32 ocr, 12516abaa0c9SPierre Ossman struct mmc_card *oldcard) 12527ea239d9SPierre Ossman { 12537ea239d9SPierre Ossman struct mmc_card *card; 1254577fb131SSeungwon Jeon int err; 12557ea239d9SPierre Ossman u32 cid[4]; 1256b676f039SPhilip Rakity u32 rocr; 125708ee80ccSPhilip Rakity u8 *ext_csd = NULL; 12587ea239d9SPierre Ossman 12597ea239d9SPierre Ossman BUG_ON(!host); 1260d84075c8SPierre Ossman WARN_ON(!host->claimed); 12617ea239d9SPierre Ossman 126244669034SStefan Nilsson XK /* Set correct bus mode for MMC before attempting init */ 126344669034SStefan Nilsson XK if (!mmc_host_is_spi(host)) 126444669034SStefan Nilsson XK mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN); 126544669034SStefan Nilsson XK 12667ea239d9SPierre Ossman /* 12677ea239d9SPierre Ossman * Since we're changing the OCR value, we seem to 12687ea239d9SPierre Ossman * need to tell some cards to go back to the idle 12697ea239d9SPierre Ossman * state. We wait 1ms to give cards time to 12707ea239d9SPierre Ossman * respond. 1271c3805467SBalaji T K * mmc_go_idle is needed for eMMC that are asleep 12727ea239d9SPierre Ossman */ 12737ea239d9SPierre Ossman mmc_go_idle(host); 12747ea239d9SPierre Ossman 12757ea239d9SPierre Ossman /* The extra bit indicates that we support high capacity */ 1276b676f039SPhilip Rakity err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr); 127717b0429dSPierre Ossman if (err) 12786abaa0c9SPierre Ossman goto err; 12797ea239d9SPierre Ossman 12807ea239d9SPierre Ossman /* 1281af517150SDavid Brownell * For SPI, enable CRC as appropriate. 1282af517150SDavid Brownell */ 1283af517150SDavid Brownell if (mmc_host_is_spi(host)) { 1284af517150SDavid Brownell err = mmc_spi_set_crc(host, use_spi_crc); 1285af517150SDavid Brownell if (err) 1286af517150SDavid Brownell goto err; 1287af517150SDavid Brownell } 1288af517150SDavid Brownell 1289af517150SDavid Brownell /* 12907ea239d9SPierre Ossman * Fetch CID from card. 12917ea239d9SPierre Ossman */ 1292af517150SDavid Brownell if (mmc_host_is_spi(host)) 1293af517150SDavid Brownell err = mmc_send_cid(host, cid); 1294af517150SDavid Brownell else 12957ea239d9SPierre Ossman err = mmc_all_send_cid(host, cid); 129617b0429dSPierre Ossman if (err) 12977ea239d9SPierre Ossman goto err; 12987ea239d9SPierre Ossman 12996abaa0c9SPierre Ossman if (oldcard) { 1300adf66a0dSPierre Ossman if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) { 1301adf66a0dSPierre Ossman err = -ENOENT; 13026abaa0c9SPierre Ossman goto err; 1303adf66a0dSPierre Ossman } 13046abaa0c9SPierre Ossman 13056abaa0c9SPierre Ossman card = oldcard; 13066abaa0c9SPierre Ossman } else { 13077ea239d9SPierre Ossman /* 13087ea239d9SPierre Ossman * Allocate card structure. 13097ea239d9SPierre Ossman */ 131051ec92e2SPierre Ossman card = mmc_alloc_card(host, &mmc_type); 1311adf66a0dSPierre Ossman if (IS_ERR(card)) { 1312adf66a0dSPierre Ossman err = PTR_ERR(card); 13137ea239d9SPierre Ossman goto err; 1314adf66a0dSPierre Ossman } 13157ea239d9SPierre Ossman 131669041150SUlf Hansson card->ocr = ocr; 13177ea239d9SPierre Ossman card->type = MMC_TYPE_MMC; 13187ea239d9SPierre Ossman card->rca = 1; 13197ea239d9SPierre Ossman memcpy(card->raw_cid, cid, sizeof(card->raw_cid)); 13206abaa0c9SPierre Ossman } 13217ea239d9SPierre Ossman 13227ea239d9SPierre Ossman /* 1323af517150SDavid Brownell * For native busses: set card RCA and quit open drain mode. 13247ea239d9SPierre Ossman */ 1325af517150SDavid Brownell if (!mmc_host_is_spi(host)) { 13267ea239d9SPierre Ossman err = mmc_set_relative_addr(card); 132717b0429dSPierre Ossman if (err) 13287ea239d9SPierre Ossman goto free_card; 13297ea239d9SPierre Ossman 13307ea239d9SPierre Ossman mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL); 1331af517150SDavid Brownell } 13327ea239d9SPierre Ossman 13336abaa0c9SPierre Ossman if (!oldcard) { 13347ea239d9SPierre Ossman /* 13357ea239d9SPierre Ossman * Fetch CSD from card. 13367ea239d9SPierre Ossman */ 13377ea239d9SPierre Ossman err = mmc_send_csd(card, card->raw_csd); 133817b0429dSPierre Ossman if (err) 13397ea239d9SPierre Ossman goto free_card; 13407ea239d9SPierre Ossman 1341bd766312SPierre Ossman err = mmc_decode_csd(card); 1342adf66a0dSPierre Ossman if (err) 1343bd766312SPierre Ossman goto free_card; 1344bd766312SPierre Ossman err = mmc_decode_cid(card); 1345adf66a0dSPierre Ossman if (err) 1346bd766312SPierre Ossman goto free_card; 13476abaa0c9SPierre Ossman } 13487ea239d9SPierre Ossman 13497ea239d9SPierre Ossman /* 13503d705d14SSascha Hauer * handling only for cards supporting DSR and hosts requesting 13513d705d14SSascha Hauer * DSR configuration 13523d705d14SSascha Hauer */ 13533d705d14SSascha Hauer if (card->csd.dsr_imp && host->dsr_req) 13543d705d14SSascha Hauer mmc_set_dsr(host); 13553d705d14SSascha Hauer 13563d705d14SSascha Hauer /* 135789a73cf5SPierre Ossman * Select card, as all following commands rely on that. 13587ea239d9SPierre Ossman */ 1359af517150SDavid Brownell if (!mmc_host_is_spi(host)) { 13607ea239d9SPierre Ossman err = mmc_select_card(card); 136117b0429dSPierre Ossman if (err) 13627ea239d9SPierre Ossman goto free_card; 1363af517150SDavid Brownell } 13647ea239d9SPierre Ossman 13656abaa0c9SPierre Ossman if (!oldcard) { 136689a73cf5SPierre Ossman /* 1367af517150SDavid Brownell * Fetch and process extended CSD. 136889a73cf5SPierre Ossman */ 136908ee80ccSPhilip Rakity 137008ee80ccSPhilip Rakity err = mmc_get_ext_csd(card, &ext_csd); 137108ee80ccSPhilip Rakity if (err) 137208ee80ccSPhilip Rakity goto free_card; 137308ee80ccSPhilip Rakity err = mmc_read_ext_csd(card, ext_csd); 137417b0429dSPierre Ossman if (err) 13757ea239d9SPierre Ossman goto free_card; 1376b676f039SPhilip Rakity 1377b676f039SPhilip Rakity /* If doing byte addressing, check if required to do sector 1378b676f039SPhilip Rakity * addressing. Handle the case of <2GB cards needing sector 1379b676f039SPhilip Rakity * addressing. See section 8.1 JEDEC Standard JED84-A441; 1380b676f039SPhilip Rakity * ocr register has bit 30 set for sector addressing. 1381b676f039SPhilip Rakity */ 1382b676f039SPhilip Rakity if (!(mmc_card_blockaddr(card)) && (rocr & (1<<30))) 1383b676f039SPhilip Rakity mmc_card_set_blockaddr(card); 1384b676f039SPhilip Rakity 1385dfe86cbaSAdrian Hunter /* Erase size depends on CSD and Extended CSD */ 1386dfe86cbaSAdrian Hunter mmc_set_erase_size(card); 13876abaa0c9SPierre Ossman } 13887ea239d9SPierre Ossman 13897ea239d9SPierre Ossman /* 1390709de99dSChuanxiao Dong * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF 1391709de99dSChuanxiao Dong * bit. This bit will be lost every time after a reset or power off. 1392709de99dSChuanxiao Dong */ 139369803d4fSGrégory Soutadé if (card->ext_csd.partition_setting_completed || 139483bb24aaSAdrian Hunter (card->ext_csd.rev >= 3 && (host->caps2 & MMC_CAP2_HC_ERASE_SZ))) { 1395709de99dSChuanxiao Dong err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1396b23cf0bdSSeungwon Jeon EXT_CSD_ERASE_GROUP_DEF, 1, 1397b23cf0bdSSeungwon Jeon card->ext_csd.generic_cmd6_time); 1398709de99dSChuanxiao Dong 1399709de99dSChuanxiao Dong if (err && err != -EBADMSG) 1400709de99dSChuanxiao Dong goto free_card; 1401709de99dSChuanxiao Dong 1402709de99dSChuanxiao Dong if (err) { 1403709de99dSChuanxiao Dong err = 0; 1404709de99dSChuanxiao Dong /* 1405709de99dSChuanxiao Dong * Just disable enhanced area off & sz 1406709de99dSChuanxiao Dong * will try to enable ERASE_GROUP_DEF 1407709de99dSChuanxiao Dong * during next time reinit 1408709de99dSChuanxiao Dong */ 1409709de99dSChuanxiao Dong card->ext_csd.enhanced_area_offset = -EINVAL; 1410709de99dSChuanxiao Dong card->ext_csd.enhanced_area_size = -EINVAL; 1411709de99dSChuanxiao Dong } else { 1412709de99dSChuanxiao Dong card->ext_csd.erase_group_def = 1; 1413709de99dSChuanxiao Dong /* 1414709de99dSChuanxiao Dong * enable ERASE_GRP_DEF successfully. 1415709de99dSChuanxiao Dong * This will affect the erase size, so 1416709de99dSChuanxiao Dong * here need to reset erase size 1417709de99dSChuanxiao Dong */ 1418709de99dSChuanxiao Dong mmc_set_erase_size(card); 1419709de99dSChuanxiao Dong } 1420709de99dSChuanxiao Dong } 1421709de99dSChuanxiao Dong 1422709de99dSChuanxiao Dong /* 142341e2a489SPhilip Rakity * Ensure eMMC user default partition is enabled 142441e2a489SPhilip Rakity */ 1425371a689fSAndrei Warkentin if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) { 1426371a689fSAndrei Warkentin card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK; 1427371a689fSAndrei Warkentin err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG, 1428371a689fSAndrei Warkentin card->ext_csd.part_config, 1429371a689fSAndrei Warkentin card->ext_csd.part_time); 1430371a689fSAndrei Warkentin if (err && err != -EBADMSG) 1431371a689fSAndrei Warkentin goto free_card; 143241e2a489SPhilip Rakity } 143341e2a489SPhilip Rakity 143441e2a489SPhilip Rakity /* 143543235679SUlf Hansson * Enable power_off_notification byte in the ext_csd register 1436bec8726aSGirish K S */ 143743235679SUlf Hansson if (card->ext_csd.rev >= 6) { 1438bec8726aSGirish K S err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1439bec8726aSGirish K S EXT_CSD_POWER_OFF_NOTIFICATION, 1440bec8726aSGirish K S EXT_CSD_POWER_ON, 1441bec8726aSGirish K S card->ext_csd.generic_cmd6_time); 1442bec8726aSGirish K S if (err && err != -EBADMSG) 1443bec8726aSGirish K S goto free_card; 1444bec8726aSGirish K S 144596a85d54SGirish K S /* 144696a85d54SGirish K S * The err can be -EBADMSG or 0, 144796a85d54SGirish K S * so check for success and update the flag 144896a85d54SGirish K S */ 1449bec8726aSGirish K S if (!err) 1450e6c08586SUlf Hansson card->ext_csd.power_off_notification = EXT_CSD_POWER_ON; 145196a85d54SGirish K S } 1452bec8726aSGirish K S 1453bec8726aSGirish K S /* 1454577fb131SSeungwon Jeon * Select timing interface 145589a73cf5SPierre Ossman */ 1456577fb131SSeungwon Jeon err = mmc_select_timing(card); 1457577fb131SSeungwon Jeon if (err) 145889a73cf5SPierre Ossman goto free_card; 145989a73cf5SPierre Ossman 1460a4924c71SGirish K S if (mmc_card_hs200(card)) { 1461577fb131SSeungwon Jeon err = mmc_hs200_tuning(card); 14624c4cb171SPhilip Rakity if (err) 14634c4cb171SPhilip Rakity goto err; 14640a5b6438SSeungwon Jeon 14650a5b6438SSeungwon Jeon err = mmc_select_hs400(card); 14660a5b6438SSeungwon Jeon if (err) 14670a5b6438SSeungwon Jeon goto err; 1468577fb131SSeungwon Jeon } else if (mmc_card_hs(card)) { 1469577fb131SSeungwon Jeon /* Select the desired bus width optionally */ 1470577fb131SSeungwon Jeon err = mmc_select_bus_width(card); 1471577fb131SSeungwon Jeon if (!IS_ERR_VALUE(err)) { 1472577fb131SSeungwon Jeon err = mmc_select_hs_ddr(card); 1473577fb131SSeungwon Jeon if (err) 1474577fb131SSeungwon Jeon goto err; 147589a73cf5SPierre Ossman } 1476ef0b27d4SAdrian Hunter } 147789a73cf5SPierre Ossman 1478881d1c25SSeungwon Jeon /* 14792385049dSSeungwon Jeon * Choose the power class with selected bus interface 14802385049dSSeungwon Jeon */ 14812385049dSSeungwon Jeon mmc_select_powerclass(card); 14822385049dSSeungwon Jeon 14832385049dSSeungwon Jeon /* 148452d0974eSSubhash Jadavani * Enable HPI feature (if supported) 148552d0974eSSubhash Jadavani */ 148652d0974eSSubhash Jadavani if (card->ext_csd.hpi) { 148752d0974eSSubhash Jadavani err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 148852d0974eSSubhash Jadavani EXT_CSD_HPI_MGMT, 1, 148952d0974eSSubhash Jadavani card->ext_csd.generic_cmd6_time); 149052d0974eSSubhash Jadavani if (err && err != -EBADMSG) 149152d0974eSSubhash Jadavani goto free_card; 149252d0974eSSubhash Jadavani if (err) { 149352d0974eSSubhash Jadavani pr_warning("%s: Enabling HPI failed\n", 149452d0974eSSubhash Jadavani mmc_hostname(card->host)); 149552d0974eSSubhash Jadavani err = 0; 149652d0974eSSubhash Jadavani } else 149752d0974eSSubhash Jadavani card->ext_csd.hpi_en = 1; 149852d0974eSSubhash Jadavani } 149952d0974eSSubhash Jadavani 150052d0974eSSubhash Jadavani /* 1501881d1c25SSeungwon Jeon * If cache size is higher than 0, this indicates 1502881d1c25SSeungwon Jeon * the existence of cache and it can be turned on. 1503881d1c25SSeungwon Jeon */ 15047536d3f8SUlf Hansson if (card->ext_csd.cache_size > 0) { 1505881d1c25SSeungwon Jeon err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 15068bc0678bSSeungwon Jeon EXT_CSD_CACHE_CTRL, 1, 15078bc0678bSSeungwon Jeon card->ext_csd.generic_cmd6_time); 1508881d1c25SSeungwon Jeon if (err && err != -EBADMSG) 1509881d1c25SSeungwon Jeon goto free_card; 1510881d1c25SSeungwon Jeon 1511881d1c25SSeungwon Jeon /* 1512881d1c25SSeungwon Jeon * Only if no error, cache is turned on successfully. 1513881d1c25SSeungwon Jeon */ 15148bc0678bSSeungwon Jeon if (err) { 15158bc0678bSSeungwon Jeon pr_warning("%s: Cache is supported, " 15168bc0678bSSeungwon Jeon "but failed to turn on (%d)\n", 15178bc0678bSSeungwon Jeon mmc_hostname(card->host), err); 15188bc0678bSSeungwon Jeon card->ext_csd.cache_ctrl = 0; 15198bc0678bSSeungwon Jeon err = 0; 15208bc0678bSSeungwon Jeon } else { 15218bc0678bSSeungwon Jeon card->ext_csd.cache_ctrl = 1; 15228bc0678bSSeungwon Jeon } 1523881d1c25SSeungwon Jeon } 1524881d1c25SSeungwon Jeon 1525abd9ac14SSeungwon Jeon /* 1526abd9ac14SSeungwon Jeon * The mandatory minimum values are defined for packed command. 1527abd9ac14SSeungwon Jeon * read: 5, write: 3 1528abd9ac14SSeungwon Jeon */ 1529abd9ac14SSeungwon Jeon if (card->ext_csd.max_packed_writes >= 3 && 1530abd9ac14SSeungwon Jeon card->ext_csd.max_packed_reads >= 5 && 1531abd9ac14SSeungwon Jeon host->caps2 & MMC_CAP2_PACKED_CMD) { 1532abd9ac14SSeungwon Jeon err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1533abd9ac14SSeungwon Jeon EXT_CSD_EXP_EVENTS_CTRL, 1534abd9ac14SSeungwon Jeon EXT_CSD_PACKED_EVENT_EN, 1535abd9ac14SSeungwon Jeon card->ext_csd.generic_cmd6_time); 1536abd9ac14SSeungwon Jeon if (err && err != -EBADMSG) 1537abd9ac14SSeungwon Jeon goto free_card; 1538abd9ac14SSeungwon Jeon if (err) { 1539abd9ac14SSeungwon Jeon pr_warn("%s: Enabling packed event failed\n", 1540abd9ac14SSeungwon Jeon mmc_hostname(card->host)); 1541abd9ac14SSeungwon Jeon card->ext_csd.packed_event_en = 0; 1542abd9ac14SSeungwon Jeon err = 0; 1543abd9ac14SSeungwon Jeon } else { 1544abd9ac14SSeungwon Jeon card->ext_csd.packed_event_en = 1; 1545abd9ac14SSeungwon Jeon } 1546abd9ac14SSeungwon Jeon } 1547abd9ac14SSeungwon Jeon 15486abaa0c9SPierre Ossman if (!oldcard) 15497ea239d9SPierre Ossman host->card = card; 15507ea239d9SPierre Ossman 155108ee80ccSPhilip Rakity mmc_free_ext_csd(ext_csd); 155217b0429dSPierre Ossman return 0; 15536abaa0c9SPierre Ossman 15546abaa0c9SPierre Ossman free_card: 15556abaa0c9SPierre Ossman if (!oldcard) 15566abaa0c9SPierre Ossman mmc_remove_card(card); 15576abaa0c9SPierre Ossman err: 155808ee80ccSPhilip Rakity mmc_free_ext_csd(ext_csd); 15596abaa0c9SPierre Ossman 1560adf66a0dSPierre Ossman return err; 15616abaa0c9SPierre Ossman } 15626abaa0c9SPierre Ossman 156307a68216SUlf Hansson static int mmc_can_sleep(struct mmc_card *card) 156407a68216SUlf Hansson { 156507a68216SUlf Hansson return (card && card->ext_csd.rev >= 3); 156607a68216SUlf Hansson } 156707a68216SUlf Hansson 156807a68216SUlf Hansson static int mmc_sleep(struct mmc_host *host) 156907a68216SUlf Hansson { 157007a68216SUlf Hansson struct mmc_command cmd = {0}; 157107a68216SUlf Hansson struct mmc_card *card = host->card; 1572cb962e04SUlf Hansson unsigned int timeout_ms = DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000); 157307a68216SUlf Hansson int err; 157407a68216SUlf Hansson 157507a68216SUlf Hansson err = mmc_deselect_cards(host); 157607a68216SUlf Hansson if (err) 157707a68216SUlf Hansson return err; 157807a68216SUlf Hansson 157907a68216SUlf Hansson cmd.opcode = MMC_SLEEP_AWAKE; 158007a68216SUlf Hansson cmd.arg = card->rca << 16; 158107a68216SUlf Hansson cmd.arg |= 1 << 15; 158207a68216SUlf Hansson 1583cb962e04SUlf Hansson /* 1584cb962e04SUlf Hansson * If the max_busy_timeout of the host is specified, validate it against 1585cb962e04SUlf Hansson * the sleep cmd timeout. A failure means we need to prevent the host 1586cb962e04SUlf Hansson * from doing hw busy detection, which is done by converting to a R1 1587cb962e04SUlf Hansson * response instead of a R1B. 1588cb962e04SUlf Hansson */ 1589cb962e04SUlf Hansson if (host->max_busy_timeout && (timeout_ms > host->max_busy_timeout)) { 1590cb962e04SUlf Hansson cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 1591cb962e04SUlf Hansson } else { 159207a68216SUlf Hansson cmd.flags = MMC_RSP_R1B | MMC_CMD_AC; 1593cb962e04SUlf Hansson cmd.busy_timeout = timeout_ms; 1594cb962e04SUlf Hansson } 1595cb962e04SUlf Hansson 159607a68216SUlf Hansson err = mmc_wait_for_cmd(host, &cmd, 0); 159707a68216SUlf Hansson if (err) 159807a68216SUlf Hansson return err; 159907a68216SUlf Hansson 160007a68216SUlf Hansson /* 160107a68216SUlf Hansson * If the host does not wait while the card signals busy, then we will 160207a68216SUlf Hansson * will have to wait the sleep/awake timeout. Note, we cannot use the 160307a68216SUlf Hansson * SEND_STATUS command to poll the status because that command (and most 160407a68216SUlf Hansson * others) is invalid while the card sleeps. 160507a68216SUlf Hansson */ 1606cb962e04SUlf Hansson if (!cmd.busy_timeout || !(host->caps & MMC_CAP_WAIT_WHILE_BUSY)) 1607cb962e04SUlf Hansson mmc_delay(timeout_ms); 160807a68216SUlf Hansson 160907a68216SUlf Hansson return err; 161007a68216SUlf Hansson } 161107a68216SUlf Hansson 1612e6c08586SUlf Hansson static int mmc_can_poweroff_notify(const struct mmc_card *card) 1613e6c08586SUlf Hansson { 1614e6c08586SUlf Hansson return card && 1615e6c08586SUlf Hansson mmc_card_mmc(card) && 1616e6c08586SUlf Hansson (card->ext_csd.power_off_notification == EXT_CSD_POWER_ON); 1617e6c08586SUlf Hansson } 1618e6c08586SUlf Hansson 1619e6c08586SUlf Hansson static int mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type) 1620e6c08586SUlf Hansson { 1621e6c08586SUlf Hansson unsigned int timeout = card->ext_csd.generic_cmd6_time; 1622e6c08586SUlf Hansson int err; 1623e6c08586SUlf Hansson 1624e6c08586SUlf Hansson /* Use EXT_CSD_POWER_OFF_SHORT as default notification type. */ 1625e6c08586SUlf Hansson if (notify_type == EXT_CSD_POWER_OFF_LONG) 1626e6c08586SUlf Hansson timeout = card->ext_csd.power_off_longtime; 1627e6c08586SUlf Hansson 1628878e200bSUlf Hansson err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 1629e6c08586SUlf Hansson EXT_CSD_POWER_OFF_NOTIFICATION, 16304509f847SUlf Hansson notify_type, timeout, true, false, false); 1631e6c08586SUlf Hansson if (err) 1632e6c08586SUlf Hansson pr_err("%s: Power Off Notification timed out, %u\n", 1633e6c08586SUlf Hansson mmc_hostname(card->host), timeout); 1634e6c08586SUlf Hansson 1635e6c08586SUlf Hansson /* Disable the power off notification after the switch operation. */ 1636e6c08586SUlf Hansson card->ext_csd.power_off_notification = EXT_CSD_NO_POWER_NOTIFICATION; 1637e6c08586SUlf Hansson 1638e6c08586SUlf Hansson return err; 1639e6c08586SUlf Hansson } 1640e6c08586SUlf Hansson 16416abaa0c9SPierre Ossman /* 16426abaa0c9SPierre Ossman * Host is being removed. Free up the current card. 16436abaa0c9SPierre Ossman */ 16446abaa0c9SPierre Ossman static void mmc_remove(struct mmc_host *host) 16456abaa0c9SPierre Ossman { 16466abaa0c9SPierre Ossman BUG_ON(!host); 16476abaa0c9SPierre Ossman BUG_ON(!host->card); 16486abaa0c9SPierre Ossman 16496abaa0c9SPierre Ossman mmc_remove_card(host->card); 16506abaa0c9SPierre Ossman host->card = NULL; 16516abaa0c9SPierre Ossman } 16526abaa0c9SPierre Ossman 16536abaa0c9SPierre Ossman /* 1654d3049504SAdrian Hunter * Card detection - card is alive. 1655d3049504SAdrian Hunter */ 1656d3049504SAdrian Hunter static int mmc_alive(struct mmc_host *host) 1657d3049504SAdrian Hunter { 1658d3049504SAdrian Hunter return mmc_send_status(host->card, NULL); 1659d3049504SAdrian Hunter } 1660d3049504SAdrian Hunter 1661d3049504SAdrian Hunter /* 16626abaa0c9SPierre Ossman * Card detection callback from host. 16636abaa0c9SPierre Ossman */ 16646abaa0c9SPierre Ossman static void mmc_detect(struct mmc_host *host) 16656abaa0c9SPierre Ossman { 16666abaa0c9SPierre Ossman int err; 16676abaa0c9SPierre Ossman 16686abaa0c9SPierre Ossman BUG_ON(!host); 16696abaa0c9SPierre Ossman BUG_ON(!host->card); 16706abaa0c9SPierre Ossman 1671e94cfef6SUlf Hansson mmc_get_card(host->card); 16726abaa0c9SPierre Ossman 16736abaa0c9SPierre Ossman /* 16746abaa0c9SPierre Ossman * Just check if our card has been removed. 16756abaa0c9SPierre Ossman */ 1676d3049504SAdrian Hunter err = _mmc_detect_card_removed(host); 16776abaa0c9SPierre Ossman 1678e94cfef6SUlf Hansson mmc_put_card(host->card); 16797ea239d9SPierre Ossman 168017b0429dSPierre Ossman if (err) { 16814101c16aSPierre Ossman mmc_remove(host); 16826abaa0c9SPierre Ossman 16836abaa0c9SPierre Ossman mmc_claim_host(host); 16846abaa0c9SPierre Ossman mmc_detach_bus(host); 16857f7e4129SUlf Hansson mmc_power_off(host); 16866abaa0c9SPierre Ossman mmc_release_host(host); 16876abaa0c9SPierre Ossman } 16886abaa0c9SPierre Ossman } 16896abaa0c9SPierre Ossman 169003d071fcSUlf Hansson static int _mmc_suspend(struct mmc_host *host, bool is_suspend) 16916abaa0c9SPierre Ossman { 1692c3805467SBalaji T K int err = 0; 169303d071fcSUlf Hansson unsigned int notify_type = is_suspend ? EXT_CSD_POWER_OFF_SHORT : 169403d071fcSUlf Hansson EXT_CSD_POWER_OFF_LONG; 1695c3805467SBalaji T K 16966abaa0c9SPierre Ossman BUG_ON(!host); 16976abaa0c9SPierre Ossman BUG_ON(!host->card); 16986abaa0c9SPierre Ossman 16996abaa0c9SPierre Ossman mmc_claim_host(host); 1700881d926dSMaya Erez 17019ec775f7SUlf Hansson if (mmc_card_suspended(host->card)) 17029ec775f7SUlf Hansson goto out; 17039ec775f7SUlf Hansson 170439b9431bSUlf Hansson if (mmc_card_doing_bkops(host->card)) { 170539b9431bSUlf Hansson err = mmc_stop_bkops(host->card); 170639b9431bSUlf Hansson if (err) 170739b9431bSUlf Hansson goto out; 170839b9431bSUlf Hansson } 170939b9431bSUlf Hansson 171010e5d965SUlf Hansson err = mmc_flush_cache(host->card); 1711881d926dSMaya Erez if (err) 1712881d926dSMaya Erez goto out; 1713881d926dSMaya Erez 171443235679SUlf Hansson if (mmc_can_poweroff_notify(host->card) && 171553275c21SUlf Hansson ((host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) || !is_suspend)) 171603d071fcSUlf Hansson err = mmc_poweroff_notify(host->card, notify_type); 171707a68216SUlf Hansson else if (mmc_can_sleep(host->card)) 171807a68216SUlf Hansson err = mmc_sleep(host); 1719e6c08586SUlf Hansson else if (!mmc_host_is_spi(host)) 172085e727edSJaehoon Chung err = mmc_deselect_cards(host); 172195cdfb72SNicolas Pitre 17229ec775f7SUlf Hansson if (!err) { 172374590263SUlf Hansson mmc_power_off(host); 17249ec775f7SUlf Hansson mmc_card_set_suspended(host->card); 17259ec775f7SUlf Hansson } 1726881d926dSMaya Erez out: 1727881d926dSMaya Erez mmc_release_host(host); 1728c3805467SBalaji T K return err; 17296abaa0c9SPierre Ossman } 17306abaa0c9SPierre Ossman 17316abaa0c9SPierre Ossman /* 17320cb403a2SUlf Hansson * Suspend callback 173303d071fcSUlf Hansson */ 173403d071fcSUlf Hansson static int mmc_suspend(struct mmc_host *host) 173503d071fcSUlf Hansson { 17360cb403a2SUlf Hansson int err; 17370cb403a2SUlf Hansson 17380cb403a2SUlf Hansson err = _mmc_suspend(host, true); 17390cb403a2SUlf Hansson if (!err) { 17400cb403a2SUlf Hansson pm_runtime_disable(&host->card->dev); 17410cb403a2SUlf Hansson pm_runtime_set_suspended(&host->card->dev); 17420cb403a2SUlf Hansson } 17430cb403a2SUlf Hansson 17440cb403a2SUlf Hansson return err; 174503d071fcSUlf Hansson } 174603d071fcSUlf Hansson 174703d071fcSUlf Hansson /* 17486abaa0c9SPierre Ossman * This function tries to determine if the same card is still present 17496abaa0c9SPierre Ossman * and, if so, restore all state to it. 17506abaa0c9SPierre Ossman */ 17510cb403a2SUlf Hansson static int _mmc_resume(struct mmc_host *host) 17526abaa0c9SPierre Ossman { 17539ec775f7SUlf Hansson int err = 0; 17546abaa0c9SPierre Ossman 17556abaa0c9SPierre Ossman BUG_ON(!host); 17566abaa0c9SPierre Ossman BUG_ON(!host->card); 17576abaa0c9SPierre Ossman 17586abaa0c9SPierre Ossman mmc_claim_host(host); 17599ec775f7SUlf Hansson 17609ec775f7SUlf Hansson if (!mmc_card_suspended(host->card)) 17619ec775f7SUlf Hansson goto out; 17629ec775f7SUlf Hansson 176369041150SUlf Hansson mmc_power_up(host, host->card->ocr); 176469041150SUlf Hansson err = mmc_init_card(host, host->card->ocr, host->card); 17659ec775f7SUlf Hansson mmc_card_clr_suspended(host->card); 17662986d0bfSPierre Ossman 17679ec775f7SUlf Hansson out: 17689ec775f7SUlf Hansson mmc_release_host(host); 176995cdfb72SNicolas Pitre return err; 17706abaa0c9SPierre Ossman } 17716abaa0c9SPierre Ossman 17729ec775f7SUlf Hansson /* 17739ec775f7SUlf Hansson * Shutdown callback 17749ec775f7SUlf Hansson */ 17759ec775f7SUlf Hansson static int mmc_shutdown(struct mmc_host *host) 17769ec775f7SUlf Hansson { 17779ec775f7SUlf Hansson int err = 0; 17789ec775f7SUlf Hansson 17799ec775f7SUlf Hansson /* 17809ec775f7SUlf Hansson * In a specific case for poweroff notify, we need to resume the card 17819ec775f7SUlf Hansson * before we can shutdown it properly. 17829ec775f7SUlf Hansson */ 17839ec775f7SUlf Hansson if (mmc_can_poweroff_notify(host->card) && 17849ec775f7SUlf Hansson !(host->caps2 & MMC_CAP2_FULL_PWR_CYCLE)) 17850cb403a2SUlf Hansson err = _mmc_resume(host); 17869ec775f7SUlf Hansson 17879ec775f7SUlf Hansson if (!err) 17889ec775f7SUlf Hansson err = _mmc_suspend(host, false); 17899ec775f7SUlf Hansson 17909ec775f7SUlf Hansson return err; 17919ec775f7SUlf Hansson } 1792c4d770d7SUlf Hansson 1793c4d770d7SUlf Hansson /* 17940cb403a2SUlf Hansson * Callback for resume. 17950cb403a2SUlf Hansson */ 17960cb403a2SUlf Hansson static int mmc_resume(struct mmc_host *host) 17970cb403a2SUlf Hansson { 17984d223782SUlf Hansson int err = 0; 17990cb403a2SUlf Hansson 18004d223782SUlf Hansson if (!(host->caps & MMC_CAP_RUNTIME_RESUME)) { 18010cb403a2SUlf Hansson err = _mmc_resume(host); 18020cb403a2SUlf Hansson pm_runtime_set_active(&host->card->dev); 18030cb403a2SUlf Hansson pm_runtime_mark_last_busy(&host->card->dev); 18044d223782SUlf Hansson } 18050cb403a2SUlf Hansson pm_runtime_enable(&host->card->dev); 18060cb403a2SUlf Hansson 18070cb403a2SUlf Hansson return err; 18080cb403a2SUlf Hansson } 18090cb403a2SUlf Hansson 18100cb403a2SUlf Hansson /* 1811c4d770d7SUlf Hansson * Callback for runtime_suspend. 1812c4d770d7SUlf Hansson */ 1813c4d770d7SUlf Hansson static int mmc_runtime_suspend(struct mmc_host *host) 1814c4d770d7SUlf Hansson { 1815c4d770d7SUlf Hansson int err; 1816c4d770d7SUlf Hansson 1817c4d770d7SUlf Hansson if (!(host->caps & MMC_CAP_AGGRESSIVE_PM)) 1818c4d770d7SUlf Hansson return 0; 1819c4d770d7SUlf Hansson 18200cb403a2SUlf Hansson err = _mmc_suspend(host, true); 18210cc81a8cSUlf Hansson if (err) 1822c4d770d7SUlf Hansson pr_err("%s: error %d doing aggessive suspend\n", 1823c4d770d7SUlf Hansson mmc_hostname(host), err); 1824c4d770d7SUlf Hansson 1825c4d770d7SUlf Hansson return err; 1826c4d770d7SUlf Hansson } 1827c4d770d7SUlf Hansson 1828c4d770d7SUlf Hansson /* 1829c4d770d7SUlf Hansson * Callback for runtime_resume. 1830c4d770d7SUlf Hansson */ 1831c4d770d7SUlf Hansson static int mmc_runtime_resume(struct mmc_host *host) 1832c4d770d7SUlf Hansson { 1833c4d770d7SUlf Hansson int err; 1834c4d770d7SUlf Hansson 18354d223782SUlf Hansson if (!(host->caps & (MMC_CAP_AGGRESSIVE_PM | MMC_CAP_RUNTIME_RESUME))) 1836c4d770d7SUlf Hansson return 0; 1837c4d770d7SUlf Hansson 18380cb403a2SUlf Hansson err = _mmc_resume(host); 1839c4d770d7SUlf Hansson if (err) 1840c4d770d7SUlf Hansson pr_err("%s: error %d doing aggessive resume\n", 1841c4d770d7SUlf Hansson mmc_hostname(host), err); 1842c4d770d7SUlf Hansson 1843c4d770d7SUlf Hansson return 0; 1844c4d770d7SUlf Hansson } 1845c4d770d7SUlf Hansson 184612ae637fSOhad Ben-Cohen static int mmc_power_restore(struct mmc_host *host) 1847eae1aeeeSAdrian Hunter { 184812ae637fSOhad Ben-Cohen int ret; 184912ae637fSOhad Ben-Cohen 1850eae1aeeeSAdrian Hunter mmc_claim_host(host); 185169041150SUlf Hansson ret = mmc_init_card(host, host->card->ocr, host->card); 1852eae1aeeeSAdrian Hunter mmc_release_host(host); 185312ae637fSOhad Ben-Cohen 185412ae637fSOhad Ben-Cohen return ret; 1855eae1aeeeSAdrian Hunter } 1856eae1aeeeSAdrian Hunter 18579feae246SAdrian Hunter static const struct mmc_bus_ops mmc_ops = { 18589feae246SAdrian Hunter .remove = mmc_remove, 18599feae246SAdrian Hunter .detect = mmc_detect, 18609feae246SAdrian Hunter .suspend = mmc_suspend, 18619feae246SAdrian Hunter .resume = mmc_resume, 1862c4d770d7SUlf Hansson .runtime_suspend = mmc_runtime_suspend, 1863c4d770d7SUlf Hansson .runtime_resume = mmc_runtime_resume, 1864eae1aeeeSAdrian Hunter .power_restore = mmc_power_restore, 1865d3049504SAdrian Hunter .alive = mmc_alive, 1866486fdbbcSUlf Hansson .shutdown = mmc_shutdown, 18679feae246SAdrian Hunter }; 18689feae246SAdrian Hunter 18696abaa0c9SPierre Ossman /* 18706abaa0c9SPierre Ossman * Starting point for MMC card init. 18716abaa0c9SPierre Ossman */ 1872807e8e40SAndy Ross int mmc_attach_mmc(struct mmc_host *host) 18736abaa0c9SPierre Ossman { 18746abaa0c9SPierre Ossman int err; 187569041150SUlf Hansson u32 ocr, rocr; 18766abaa0c9SPierre Ossman 18776abaa0c9SPierre Ossman BUG_ON(!host); 1878d84075c8SPierre Ossman WARN_ON(!host->claimed); 18796abaa0c9SPierre Ossman 188044669034SStefan Nilsson XK /* Set correct bus mode for MMC before attempting attach */ 188144669034SStefan Nilsson XK if (!mmc_host_is_spi(host)) 188244669034SStefan Nilsson XK mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN); 188344669034SStefan Nilsson XK 1884807e8e40SAndy Ross err = mmc_send_op_cond(host, 0, &ocr); 1885807e8e40SAndy Ross if (err) 1886807e8e40SAndy Ross return err; 1887807e8e40SAndy Ross 18882501c917SUlf Hansson mmc_attach_bus(host, &mmc_ops); 18898f230f45STakashi Iwai if (host->ocr_avail_mmc) 18908f230f45STakashi Iwai host->ocr_avail = host->ocr_avail_mmc; 18916abaa0c9SPierre Ossman 18926abaa0c9SPierre Ossman /* 1893af517150SDavid Brownell * We need to get OCR a different way for SPI. 1894af517150SDavid Brownell */ 1895af517150SDavid Brownell if (mmc_host_is_spi(host)) { 1896af517150SDavid Brownell err = mmc_spi_read_ocr(host, 1, &ocr); 1897af517150SDavid Brownell if (err) 1898af517150SDavid Brownell goto err; 1899af517150SDavid Brownell } 1900af517150SDavid Brownell 190169041150SUlf Hansson rocr = mmc_select_voltage(host, ocr); 19026abaa0c9SPierre Ossman 19036abaa0c9SPierre Ossman /* 19046abaa0c9SPierre Ossman * Can we support the voltage of the card? 19056abaa0c9SPierre Ossman */ 190669041150SUlf Hansson if (!rocr) { 1907109b5bedSPierre Ossman err = -EINVAL; 19086abaa0c9SPierre Ossman goto err; 1909109b5bedSPierre Ossman } 19106abaa0c9SPierre Ossman 19116abaa0c9SPierre Ossman /* 19126abaa0c9SPierre Ossman * Detect and init the card. 19136abaa0c9SPierre Ossman */ 191469041150SUlf Hansson err = mmc_init_card(host, rocr, NULL); 191517b0429dSPierre Ossman if (err) 19166abaa0c9SPierre Ossman goto err; 19176abaa0c9SPierre Ossman 19186abaa0c9SPierre Ossman mmc_release_host(host); 19194101c16aSPierre Ossman err = mmc_add_card(host->card); 1920807e8e40SAndy Ross mmc_claim_host(host); 19217ea239d9SPierre Ossman if (err) 19222986d0bfSPierre Ossman goto remove_card; 19237ea239d9SPierre Ossman 19247ea239d9SPierre Ossman return 0; 19257ea239d9SPierre Ossman 19262986d0bfSPierre Ossman remove_card: 1927807e8e40SAndy Ross mmc_release_host(host); 19286abaa0c9SPierre Ossman mmc_remove_card(host->card); 19292986d0bfSPierre Ossman mmc_claim_host(host); 1930807e8e40SAndy Ross host->card = NULL; 19317ea239d9SPierre Ossman err: 19327ea239d9SPierre Ossman mmc_detach_bus(host); 19337ea239d9SPierre Ossman 1934a3c76eb9SGirish K S pr_err("%s: error %d whilst initialising MMC card\n", 1935109b5bedSPierre Ossman mmc_hostname(host), err); 1936109b5bedSPierre Ossman 1937adf66a0dSPierre Ossman return err; 19387ea239d9SPierre Ossman } 1939