17ea239d9SPierre Ossman /* 270f10482SPierre Ossman * linux/drivers/mmc/core/sd.c 37ea239d9SPierre Ossman * 47ea239d9SPierre Ossman * Copyright (C) 2003-2004 Russell King, All Rights Reserved. 57ea239d9SPierre Ossman * SD support Copyright (C) 2004 Ian Molton, All Rights Reserved. 67ea239d9SPierre Ossman * Copyright (C) 2005-2007 Pierre Ossman, 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> 157ea239d9SPierre Ossman 167ea239d9SPierre Ossman #include <linux/mmc/host.h> 177ea239d9SPierre Ossman #include <linux/mmc/card.h> 187ea239d9SPierre Ossman #include <linux/mmc/mmc.h> 193373c0aeSPierre Ossman #include <linux/mmc/sd.h> 207ea239d9SPierre Ossman 217ea239d9SPierre Ossman #include "core.h" 224101c16aSPierre Ossman #include "bus.h" 237ea239d9SPierre Ossman #include "mmc_ops.h" 24ce101496SMark Brown #include "sd.h" 257ea239d9SPierre Ossman #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 */ 6371578a1eSMichal Miroslaw void mmc_decode_cid(struct mmc_card *card) 647ea239d9SPierre Ossman { 657ea239d9SPierre Ossman u32 *resp = card->raw_cid; 667ea239d9SPierre Ossman 677ea239d9SPierre Ossman memset(&card->cid, 0, sizeof(struct mmc_cid)); 687ea239d9SPierre Ossman 697ea239d9SPierre Ossman /* 707ea239d9SPierre Ossman * SD doesn't currently have a version field so we will 717ea239d9SPierre Ossman * have to assume we can parse this. 727ea239d9SPierre Ossman */ 737ea239d9SPierre Ossman card->cid.manfid = UNSTUFF_BITS(resp, 120, 8); 747ea239d9SPierre Ossman card->cid.oemid = UNSTUFF_BITS(resp, 104, 16); 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.hwrev = UNSTUFF_BITS(resp, 60, 4); 817ea239d9SPierre Ossman card->cid.fwrev = UNSTUFF_BITS(resp, 56, 4); 827ea239d9SPierre Ossman card->cid.serial = UNSTUFF_BITS(resp, 24, 32); 837ea239d9SPierre Ossman card->cid.year = UNSTUFF_BITS(resp, 12, 8); 847ea239d9SPierre Ossman card->cid.month = UNSTUFF_BITS(resp, 8, 4); 857ea239d9SPierre Ossman 867ea239d9SPierre Ossman card->cid.year += 2000; /* SD cards year offset */ 877ea239d9SPierre Ossman } 887ea239d9SPierre Ossman 897ea239d9SPierre Ossman /* 907ea239d9SPierre Ossman * Given a 128-bit response, decode to our card CSD structure. 917ea239d9SPierre Ossman */ 92bd766312SPierre Ossman static int mmc_decode_csd(struct mmc_card *card) 937ea239d9SPierre Ossman { 947ea239d9SPierre Ossman struct mmc_csd *csd = &card->csd; 957ea239d9SPierre Ossman unsigned int e, m, csd_struct; 967ea239d9SPierre Ossman u32 *resp = card->raw_csd; 977ea239d9SPierre Ossman 987ea239d9SPierre Ossman csd_struct = UNSTUFF_BITS(resp, 126, 2); 997ea239d9SPierre Ossman 1007ea239d9SPierre Ossman switch (csd_struct) { 1017ea239d9SPierre Ossman case 0: 1027ea239d9SPierre Ossman m = UNSTUFF_BITS(resp, 115, 4); 1037ea239d9SPierre Ossman e = UNSTUFF_BITS(resp, 112, 3); 1047ea239d9SPierre Ossman csd->tacc_ns = (tacc_exp[e] * tacc_mant[m] + 9) / 10; 1057ea239d9SPierre Ossman csd->tacc_clks = UNSTUFF_BITS(resp, 104, 8) * 100; 1067ea239d9SPierre Ossman 1077ea239d9SPierre Ossman m = UNSTUFF_BITS(resp, 99, 4); 1087ea239d9SPierre Ossman e = UNSTUFF_BITS(resp, 96, 3); 1097ea239d9SPierre Ossman csd->max_dtr = tran_exp[e] * tran_mant[m]; 1107ea239d9SPierre Ossman csd->cmdclass = UNSTUFF_BITS(resp, 84, 12); 1117ea239d9SPierre Ossman 1127ea239d9SPierre Ossman e = UNSTUFF_BITS(resp, 47, 3); 1137ea239d9SPierre Ossman m = UNSTUFF_BITS(resp, 62, 12); 1147ea239d9SPierre Ossman csd->capacity = (1 + m) << (e + 2); 1157ea239d9SPierre Ossman 1167ea239d9SPierre Ossman csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4); 1177ea239d9SPierre Ossman csd->read_partial = UNSTUFF_BITS(resp, 79, 1); 1187ea239d9SPierre Ossman csd->write_misalign = UNSTUFF_BITS(resp, 78, 1); 1197ea239d9SPierre Ossman csd->read_misalign = UNSTUFF_BITS(resp, 77, 1); 1207ea239d9SPierre Ossman csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3); 1217ea239d9SPierre Ossman csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4); 1227ea239d9SPierre Ossman csd->write_partial = UNSTUFF_BITS(resp, 21, 1); 123dfe86cbaSAdrian Hunter 124dfe86cbaSAdrian Hunter if (UNSTUFF_BITS(resp, 46, 1)) { 125dfe86cbaSAdrian Hunter csd->erase_size = 1; 126dfe86cbaSAdrian Hunter } else if (csd->write_blkbits >= 9) { 127dfe86cbaSAdrian Hunter csd->erase_size = UNSTUFF_BITS(resp, 39, 7) + 1; 128dfe86cbaSAdrian Hunter csd->erase_size <<= csd->write_blkbits - 9; 129dfe86cbaSAdrian Hunter } 1307ea239d9SPierre Ossman break; 1317ea239d9SPierre Ossman case 1: 1327ea239d9SPierre Ossman /* 1333a303511SArindam Nath * This is a block-addressed SDHC or SDXC card. Most 1347ea239d9SPierre Ossman * interesting fields are unused and have fixed 1357ea239d9SPierre Ossman * values. To avoid getting tripped by buggy cards, 1367ea239d9SPierre Ossman * we assume those fixed values ourselves. 1377ea239d9SPierre Ossman */ 1387ea239d9SPierre Ossman mmc_card_set_blockaddr(card); 1397ea239d9SPierre Ossman 1407ea239d9SPierre Ossman csd->tacc_ns = 0; /* Unused */ 1417ea239d9SPierre Ossman csd->tacc_clks = 0; /* Unused */ 1427ea239d9SPierre Ossman 1437ea239d9SPierre Ossman m = UNSTUFF_BITS(resp, 99, 4); 1447ea239d9SPierre Ossman e = UNSTUFF_BITS(resp, 96, 3); 1457ea239d9SPierre Ossman csd->max_dtr = tran_exp[e] * tran_mant[m]; 1467ea239d9SPierre Ossman csd->cmdclass = UNSTUFF_BITS(resp, 84, 12); 1473a303511SArindam Nath csd->c_size = UNSTUFF_BITS(resp, 48, 22); 1483a303511SArindam Nath 1493a303511SArindam Nath /* SDXC cards have a minimum C_SIZE of 0x00FFFF */ 1503a303511SArindam Nath if (csd->c_size >= 0xFFFF) 1513a303511SArindam Nath mmc_card_set_ext_capacity(card); 1527ea239d9SPierre Ossman 1537ea239d9SPierre Ossman m = UNSTUFF_BITS(resp, 48, 22); 1547ea239d9SPierre Ossman csd->capacity = (1 + m) << 10; 1557ea239d9SPierre Ossman 1567ea239d9SPierre Ossman csd->read_blkbits = 9; 1577ea239d9SPierre Ossman csd->read_partial = 0; 1587ea239d9SPierre Ossman csd->write_misalign = 0; 1597ea239d9SPierre Ossman csd->read_misalign = 0; 1607ea239d9SPierre Ossman csd->r2w_factor = 4; /* Unused */ 1617ea239d9SPierre Ossman csd->write_blkbits = 9; 1627ea239d9SPierre Ossman csd->write_partial = 0; 163dfe86cbaSAdrian Hunter csd->erase_size = 1; 1647ea239d9SPierre Ossman break; 1657ea239d9SPierre Ossman default: 166facba917SPierre Ossman printk(KERN_ERR "%s: unrecognised CSD structure version %d\n", 1677ea239d9SPierre Ossman mmc_hostname(card->host), csd_struct); 168bd766312SPierre Ossman return -EINVAL; 1697ea239d9SPierre Ossman } 170bd766312SPierre Ossman 171dfe86cbaSAdrian Hunter card->erase_size = csd->erase_size; 172dfe86cbaSAdrian Hunter 173bd766312SPierre Ossman return 0; 1747ea239d9SPierre Ossman } 1757ea239d9SPierre Ossman 1767ea239d9SPierre Ossman /* 1777ea239d9SPierre Ossman * Given a 64-bit response, decode to our card SCR structure. 1787ea239d9SPierre Ossman */ 179bd766312SPierre Ossman static int mmc_decode_scr(struct mmc_card *card) 1807ea239d9SPierre Ossman { 1817ea239d9SPierre Ossman struct sd_scr *scr = &card->scr; 1827ea239d9SPierre Ossman unsigned int scr_struct; 1837ea239d9SPierre Ossman u32 resp[4]; 1847ea239d9SPierre Ossman 1857ea239d9SPierre Ossman resp[3] = card->raw_scr[1]; 1867ea239d9SPierre Ossman resp[2] = card->raw_scr[0]; 1877ea239d9SPierre Ossman 1887ea239d9SPierre Ossman scr_struct = UNSTUFF_BITS(resp, 60, 4); 1897ea239d9SPierre Ossman if (scr_struct != 0) { 190facba917SPierre Ossman printk(KERN_ERR "%s: unrecognised SCR structure version %d\n", 1917ea239d9SPierre Ossman mmc_hostname(card->host), scr_struct); 192bd766312SPierre Ossman return -EINVAL; 1937ea239d9SPierre Ossman } 1947ea239d9SPierre Ossman 1957ea239d9SPierre Ossman scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4); 1967ea239d9SPierre Ossman scr->bus_widths = UNSTUFF_BITS(resp, 48, 4); 197013909c4SArindam Nath if (scr->sda_vsn == SCR_SPEC_VER_2) 198013909c4SArindam Nath /* Check if Physical Layer Spec v3.0 is supported */ 199013909c4SArindam Nath scr->sda_spec3 = UNSTUFF_BITS(resp, 47, 1); 200bd766312SPierre Ossman 201dfe86cbaSAdrian Hunter if (UNSTUFF_BITS(resp, 55, 1)) 202dfe86cbaSAdrian Hunter card->erased_byte = 0xFF; 203dfe86cbaSAdrian Hunter else 204dfe86cbaSAdrian Hunter card->erased_byte = 0x0; 205dfe86cbaSAdrian Hunter 206f0d89972SAndrei Warkentin if (scr->sda_spec3) 207f0d89972SAndrei Warkentin scr->cmds = UNSTUFF_BITS(resp, 32, 2); 208bd766312SPierre Ossman return 0; 2097ea239d9SPierre Ossman } 2107ea239d9SPierre Ossman 2117ea239d9SPierre Ossman /* 212dfe86cbaSAdrian Hunter * Fetch and process SD Status register. 213dfe86cbaSAdrian Hunter */ 214dfe86cbaSAdrian Hunter static int mmc_read_ssr(struct mmc_card *card) 215dfe86cbaSAdrian Hunter { 216dfe86cbaSAdrian Hunter unsigned int au, es, et, eo; 217dfe86cbaSAdrian Hunter int err, i; 218dfe86cbaSAdrian Hunter u32 *ssr; 219dfe86cbaSAdrian Hunter 220dfe86cbaSAdrian Hunter if (!(card->csd.cmdclass & CCC_APP_SPEC)) { 221dfe86cbaSAdrian Hunter printk(KERN_WARNING "%s: card lacks mandatory SD Status " 222dfe86cbaSAdrian Hunter "function.\n", mmc_hostname(card->host)); 223dfe86cbaSAdrian Hunter return 0; 224dfe86cbaSAdrian Hunter } 225dfe86cbaSAdrian Hunter 226dfe86cbaSAdrian Hunter ssr = kmalloc(64, GFP_KERNEL); 227dfe86cbaSAdrian Hunter if (!ssr) 228dfe86cbaSAdrian Hunter return -ENOMEM; 229dfe86cbaSAdrian Hunter 230dfe86cbaSAdrian Hunter err = mmc_app_sd_status(card, ssr); 231dfe86cbaSAdrian Hunter if (err) { 232dfe86cbaSAdrian Hunter printk(KERN_WARNING "%s: problem reading SD Status " 233dfe86cbaSAdrian Hunter "register.\n", mmc_hostname(card->host)); 234dfe86cbaSAdrian Hunter err = 0; 235dfe86cbaSAdrian Hunter goto out; 236dfe86cbaSAdrian Hunter } 237dfe86cbaSAdrian Hunter 238dfe86cbaSAdrian Hunter for (i = 0; i < 16; i++) 239dfe86cbaSAdrian Hunter ssr[i] = be32_to_cpu(ssr[i]); 240dfe86cbaSAdrian Hunter 241dfe86cbaSAdrian Hunter /* 242dfe86cbaSAdrian Hunter * UNSTUFF_BITS only works with four u32s so we have to offset the 243dfe86cbaSAdrian Hunter * bitfield positions accordingly. 244dfe86cbaSAdrian Hunter */ 245dfe86cbaSAdrian Hunter au = UNSTUFF_BITS(ssr, 428 - 384, 4); 246dfe86cbaSAdrian Hunter if (au > 0 || au <= 9) { 247dfe86cbaSAdrian Hunter card->ssr.au = 1 << (au + 4); 248dfe86cbaSAdrian Hunter es = UNSTUFF_BITS(ssr, 408 - 384, 16); 249dfe86cbaSAdrian Hunter et = UNSTUFF_BITS(ssr, 402 - 384, 6); 250dfe86cbaSAdrian Hunter eo = UNSTUFF_BITS(ssr, 400 - 384, 2); 251dfe86cbaSAdrian Hunter if (es && et) { 252dfe86cbaSAdrian Hunter card->ssr.erase_timeout = (et * 1000) / es; 253dfe86cbaSAdrian Hunter card->ssr.erase_offset = eo * 1000; 254dfe86cbaSAdrian Hunter } 255dfe86cbaSAdrian Hunter } else { 256dfe86cbaSAdrian Hunter printk(KERN_WARNING "%s: SD Status: Invalid Allocation Unit " 257dfe86cbaSAdrian Hunter "size.\n", mmc_hostname(card->host)); 258dfe86cbaSAdrian Hunter } 259dfe86cbaSAdrian Hunter out: 260dfe86cbaSAdrian Hunter kfree(ssr); 261dfe86cbaSAdrian Hunter return err; 262dfe86cbaSAdrian Hunter } 263dfe86cbaSAdrian Hunter 264dfe86cbaSAdrian Hunter /* 2651addfcdbSPierre Ossman * Fetches and decodes switch information 2667ea239d9SPierre Ossman */ 2671addfcdbSPierre Ossman static int mmc_read_switch(struct mmc_card *card) 2687ea239d9SPierre Ossman { 2697ea239d9SPierre Ossman int err; 2707ea239d9SPierre Ossman u8 *status; 2717ea239d9SPierre Ossman 2723373c0aeSPierre Ossman if (card->scr.sda_vsn < SCR_SPEC_VER_1) 27317b0429dSPierre Ossman return 0; 2743373c0aeSPierre Ossman 2753373c0aeSPierre Ossman if (!(card->csd.cmdclass & CCC_SWITCH)) { 2763373c0aeSPierre Ossman printk(KERN_WARNING "%s: card lacks mandatory switch " 2773373c0aeSPierre Ossman "function, performance might suffer.\n", 2783373c0aeSPierre Ossman mmc_hostname(card->host)); 27917b0429dSPierre Ossman return 0; 2803373c0aeSPierre Ossman } 2813373c0aeSPierre Ossman 28217b0429dSPierre Ossman err = -EIO; 2837ea239d9SPierre Ossman 2847ea239d9SPierre Ossman status = kmalloc(64, GFP_KERNEL); 2857ea239d9SPierre Ossman if (!status) { 286facba917SPierre Ossman printk(KERN_ERR "%s: could not allocate a buffer for " 287013909c4SArindam Nath "switch capabilities.\n", 288013909c4SArindam Nath mmc_hostname(card->host)); 28917b0429dSPierre Ossman return -ENOMEM; 2907ea239d9SPierre Ossman } 2917ea239d9SPierre Ossman 292013909c4SArindam Nath /* Find out the supported Bus Speed Modes. */ 2937ea239d9SPierre Ossman err = mmc_sd_switch(card, 0, 0, 1, status); 29417b0429dSPierre Ossman if (err) { 295013909c4SArindam Nath /* 296013909c4SArindam Nath * If the host or the card can't do the switch, 297013909c4SArindam Nath * fail more gracefully. 298013909c4SArindam Nath */ 299013909c4SArindam Nath if (err != -EINVAL && err != -ENOSYS && err != -EFAULT) 300adf66a0dSPierre Ossman goto out; 301adf66a0dSPierre Ossman 302013909c4SArindam Nath printk(KERN_WARNING "%s: problem reading Bus Speed modes.\n", 3033373c0aeSPierre Ossman mmc_hostname(card->host)); 30417b0429dSPierre Ossman err = 0; 305adf66a0dSPierre Ossman 3067ea239d9SPierre Ossman goto out; 3077ea239d9SPierre Ossman } 3087ea239d9SPierre Ossman 309013909c4SArindam Nath if (card->scr.sda_spec3) { 310013909c4SArindam Nath card->sw_caps.sd3_bus_mode = status[13]; 311013909c4SArindam Nath 312013909c4SArindam Nath /* Find out Driver Strengths supported by the card */ 313013909c4SArindam Nath err = mmc_sd_switch(card, 0, 2, 1, status); 314013909c4SArindam Nath if (err) { 315013909c4SArindam Nath /* 316013909c4SArindam Nath * If the host or the card can't do the switch, 317013909c4SArindam Nath * fail more gracefully. 318013909c4SArindam Nath */ 319013909c4SArindam Nath if (err != -EINVAL && err != -ENOSYS && err != -EFAULT) 320013909c4SArindam Nath goto out; 321013909c4SArindam Nath 322013909c4SArindam Nath printk(KERN_WARNING "%s: problem reading " 323013909c4SArindam Nath "Driver Strength.\n", 324013909c4SArindam Nath mmc_hostname(card->host)); 325013909c4SArindam Nath err = 0; 326013909c4SArindam Nath 327013909c4SArindam Nath goto out; 328013909c4SArindam Nath } 329013909c4SArindam Nath 330013909c4SArindam Nath card->sw_caps.sd3_drv_type = status[9]; 331013909c4SArindam Nath 332013909c4SArindam Nath /* Find out Current Limits supported by the card */ 333013909c4SArindam Nath err = mmc_sd_switch(card, 0, 3, 1, status); 334013909c4SArindam Nath if (err) { 335013909c4SArindam Nath /* 336013909c4SArindam Nath * If the host or the card can't do the switch, 337013909c4SArindam Nath * fail more gracefully. 338013909c4SArindam Nath */ 339013909c4SArindam Nath if (err != -EINVAL && err != -ENOSYS && err != -EFAULT) 340013909c4SArindam Nath goto out; 341013909c4SArindam Nath 342013909c4SArindam Nath printk(KERN_WARNING "%s: problem reading " 343013909c4SArindam Nath "Current Limit.\n", 344013909c4SArindam Nath mmc_hostname(card->host)); 345013909c4SArindam Nath err = 0; 346013909c4SArindam Nath 347013909c4SArindam Nath goto out; 348013909c4SArindam Nath } 349013909c4SArindam Nath 350013909c4SArindam Nath card->sw_caps.sd3_curr_limit = status[7]; 351013909c4SArindam Nath } else { 3527ea239d9SPierre Ossman if (status[13] & 0x02) 3537ea239d9SPierre Ossman card->sw_caps.hs_max_dtr = 50000000; 354013909c4SArindam Nath } 3557ea239d9SPierre Ossman 3561addfcdbSPierre Ossman out: 3571addfcdbSPierre Ossman kfree(status); 3581addfcdbSPierre Ossman 3591addfcdbSPierre Ossman return err; 3601addfcdbSPierre Ossman } 3611addfcdbSPierre Ossman 3621addfcdbSPierre Ossman /* 3631addfcdbSPierre Ossman * Test if the card supports high-speed mode and, if so, switch to it. 3641addfcdbSPierre Ossman */ 36571578a1eSMichal Miroslaw int mmc_sd_switch_hs(struct mmc_card *card) 3661addfcdbSPierre Ossman { 3671addfcdbSPierre Ossman int err; 3681addfcdbSPierre Ossman u8 *status; 3691addfcdbSPierre Ossman 3703373c0aeSPierre Ossman if (card->scr.sda_vsn < SCR_SPEC_VER_1) 37117b0429dSPierre Ossman return 0; 3723373c0aeSPierre Ossman 3733373c0aeSPierre Ossman if (!(card->csd.cmdclass & CCC_SWITCH)) 37417b0429dSPierre Ossman return 0; 3753373c0aeSPierre Ossman 3761addfcdbSPierre Ossman if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED)) 37717b0429dSPierre Ossman return 0; 3781addfcdbSPierre Ossman 3791addfcdbSPierre Ossman if (card->sw_caps.hs_max_dtr == 0) 38017b0429dSPierre Ossman return 0; 3811addfcdbSPierre Ossman 38217b0429dSPierre Ossman err = -EIO; 3831addfcdbSPierre Ossman 3841addfcdbSPierre Ossman status = kmalloc(64, GFP_KERNEL); 3851addfcdbSPierre Ossman if (!status) { 386facba917SPierre Ossman printk(KERN_ERR "%s: could not allocate a buffer for " 387facba917SPierre Ossman "switch capabilities.\n", mmc_hostname(card->host)); 38817b0429dSPierre Ossman return -ENOMEM; 3891addfcdbSPierre Ossman } 3901addfcdbSPierre Ossman 3917ea239d9SPierre Ossman err = mmc_sd_switch(card, 1, 0, 1, status); 39217b0429dSPierre Ossman if (err) 3937ea239d9SPierre Ossman goto out; 3947ea239d9SPierre Ossman 3957ea239d9SPierre Ossman if ((status[16] & 0xF) != 1) { 3967ea239d9SPierre Ossman printk(KERN_WARNING "%s: Problem switching card " 3977ea239d9SPierre Ossman "into high-speed mode!\n", 3987ea239d9SPierre Ossman mmc_hostname(card->host)); 39971578a1eSMichal Miroslaw err = 0; 4007ea239d9SPierre Ossman } else { 40171578a1eSMichal Miroslaw err = 1; 4027ea239d9SPierre Ossman } 4037ea239d9SPierre Ossman 4047ea239d9SPierre Ossman out: 4057ea239d9SPierre Ossman kfree(status); 4067ea239d9SPierre Ossman 4077ea239d9SPierre Ossman return err; 4087ea239d9SPierre Ossman } 4097ea239d9SPierre Ossman 410d6d50a15SArindam Nath static int sd_select_driver_type(struct mmc_card *card, u8 *status) 411d6d50a15SArindam Nath { 412*ca8e99b3SPhilip Rakity int host_drv_type = SD_DRIVER_TYPE_B; 413*ca8e99b3SPhilip Rakity int card_drv_type = SD_DRIVER_TYPE_B; 414*ca8e99b3SPhilip Rakity int drive_strength; 415d6d50a15SArindam Nath int err; 416d6d50a15SArindam Nath 417d6d50a15SArindam Nath /* 418d6d50a15SArindam Nath * If the host doesn't support any of the Driver Types A,C or D, 419*ca8e99b3SPhilip Rakity * or there is no board specific handler then default Driver 420*ca8e99b3SPhilip Rakity * Type B is used. 421d6d50a15SArindam Nath */ 422d6d50a15SArindam Nath if (!(card->host->caps & (MMC_CAP_DRIVER_TYPE_A | MMC_CAP_DRIVER_TYPE_C 423d6d50a15SArindam Nath | MMC_CAP_DRIVER_TYPE_D))) 424d6d50a15SArindam Nath return 0; 425d6d50a15SArindam Nath 426*ca8e99b3SPhilip Rakity if (!card->host->ops->select_drive_strength) 427*ca8e99b3SPhilip Rakity return 0; 428d6d50a15SArindam Nath 429*ca8e99b3SPhilip Rakity if (card->host->caps & MMC_CAP_DRIVER_TYPE_A) 430*ca8e99b3SPhilip Rakity host_drv_type |= SD_DRIVER_TYPE_A; 431*ca8e99b3SPhilip Rakity 432*ca8e99b3SPhilip Rakity if (card->host->caps & MMC_CAP_DRIVER_TYPE_C) 433*ca8e99b3SPhilip Rakity host_drv_type |= SD_DRIVER_TYPE_C; 434*ca8e99b3SPhilip Rakity 435*ca8e99b3SPhilip Rakity if (card->host->caps & MMC_CAP_DRIVER_TYPE_D) 436*ca8e99b3SPhilip Rakity host_drv_type |= SD_DRIVER_TYPE_D; 437*ca8e99b3SPhilip Rakity 438*ca8e99b3SPhilip Rakity if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_A) 439*ca8e99b3SPhilip Rakity card_drv_type |= SD_DRIVER_TYPE_A; 440*ca8e99b3SPhilip Rakity 441*ca8e99b3SPhilip Rakity if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_C) 442*ca8e99b3SPhilip Rakity card_drv_type |= SD_DRIVER_TYPE_C; 443*ca8e99b3SPhilip Rakity 444*ca8e99b3SPhilip Rakity if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_D) 445*ca8e99b3SPhilip Rakity card_drv_type |= SD_DRIVER_TYPE_D; 446*ca8e99b3SPhilip Rakity 447*ca8e99b3SPhilip Rakity /* 448*ca8e99b3SPhilip Rakity * The drive strength that the hardware can support 449*ca8e99b3SPhilip Rakity * depends on the board design. Pass the appropriate 450*ca8e99b3SPhilip Rakity * information and let the hardware specific code 451*ca8e99b3SPhilip Rakity * return what is possible given the options 452*ca8e99b3SPhilip Rakity */ 453*ca8e99b3SPhilip Rakity drive_strength = card->host->ops->select_drive_strength( 454*ca8e99b3SPhilip Rakity card->sw_caps.uhs_max_dtr, 455*ca8e99b3SPhilip Rakity host_drv_type, card_drv_type); 456*ca8e99b3SPhilip Rakity 457*ca8e99b3SPhilip Rakity err = mmc_sd_switch(card, 1, 2, drive_strength, status); 458d6d50a15SArindam Nath if (err) 459d6d50a15SArindam Nath return err; 460d6d50a15SArindam Nath 461*ca8e99b3SPhilip Rakity if ((status[15] & 0xF) != drive_strength) { 462*ca8e99b3SPhilip Rakity printk(KERN_WARNING "%s: Problem setting drive strength!\n", 463d6d50a15SArindam Nath mmc_hostname(card->host)); 464d6d50a15SArindam Nath return 0; 465d6d50a15SArindam Nath } 466d6d50a15SArindam Nath 467*ca8e99b3SPhilip Rakity mmc_set_driver_type(card->host, drive_strength); 468d6d50a15SArindam Nath 469d6d50a15SArindam Nath return 0; 470d6d50a15SArindam Nath } 471d6d50a15SArindam Nath 47249c468fcSArindam Nath static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status) 47349c468fcSArindam Nath { 47449c468fcSArindam Nath unsigned int bus_speed = 0, timing = 0; 47549c468fcSArindam Nath int err; 47649c468fcSArindam Nath 47749c468fcSArindam Nath /* 47849c468fcSArindam Nath * If the host doesn't support any of the UHS-I modes, fallback on 47949c468fcSArindam Nath * default speed. 48049c468fcSArindam Nath */ 48149c468fcSArindam Nath if (!(card->host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 | 48249c468fcSArindam Nath MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50))) 48349c468fcSArindam Nath return 0; 48449c468fcSArindam Nath 48549c468fcSArindam Nath if ((card->host->caps & MMC_CAP_UHS_SDR104) && 48649c468fcSArindam Nath (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) { 48749c468fcSArindam Nath bus_speed = UHS_SDR104_BUS_SPEED; 48849c468fcSArindam Nath timing = MMC_TIMING_UHS_SDR104; 48949c468fcSArindam Nath card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR; 49049c468fcSArindam Nath } else if ((card->host->caps & MMC_CAP_UHS_DDR50) && 49149c468fcSArindam Nath (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) { 49249c468fcSArindam Nath bus_speed = UHS_DDR50_BUS_SPEED; 49349c468fcSArindam Nath timing = MMC_TIMING_UHS_DDR50; 49449c468fcSArindam Nath card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR; 49549c468fcSArindam Nath } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 | 49649c468fcSArindam Nath MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode & 49749c468fcSArindam Nath SD_MODE_UHS_SDR50)) { 49849c468fcSArindam Nath bus_speed = UHS_SDR50_BUS_SPEED; 49949c468fcSArindam Nath timing = MMC_TIMING_UHS_SDR50; 50049c468fcSArindam Nath card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR; 50149c468fcSArindam Nath } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 | 50249c468fcSArindam Nath MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) && 50349c468fcSArindam Nath (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) { 50449c468fcSArindam Nath bus_speed = UHS_SDR25_BUS_SPEED; 50549c468fcSArindam Nath timing = MMC_TIMING_UHS_SDR25; 50649c468fcSArindam Nath card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR; 50749c468fcSArindam Nath } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 | 50849c468fcSArindam Nath MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 | 50949c468fcSArindam Nath MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode & 51049c468fcSArindam Nath SD_MODE_UHS_SDR12)) { 51149c468fcSArindam Nath bus_speed = UHS_SDR12_BUS_SPEED; 51249c468fcSArindam Nath timing = MMC_TIMING_UHS_SDR12; 51349c468fcSArindam Nath card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR; 51449c468fcSArindam Nath } 51549c468fcSArindam Nath 51649c468fcSArindam Nath card->sd_bus_speed = bus_speed; 51749c468fcSArindam Nath err = mmc_sd_switch(card, 1, 0, bus_speed, status); 51849c468fcSArindam Nath if (err) 51949c468fcSArindam Nath return err; 52049c468fcSArindam Nath 52149c468fcSArindam Nath if ((status[16] & 0xF) != bus_speed) 52249c468fcSArindam Nath printk(KERN_WARNING "%s: Problem setting bus speed mode!\n", 52349c468fcSArindam Nath mmc_hostname(card->host)); 52449c468fcSArindam Nath else { 52549c468fcSArindam Nath mmc_set_timing(card->host, timing); 52649c468fcSArindam Nath mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr); 52749c468fcSArindam Nath } 52849c468fcSArindam Nath 52949c468fcSArindam Nath return 0; 53049c468fcSArindam Nath } 53149c468fcSArindam Nath 5325371c927SArindam Nath static int sd_set_current_limit(struct mmc_card *card, u8 *status) 5335371c927SArindam Nath { 5345371c927SArindam Nath int current_limit = 0; 5355371c927SArindam Nath int err; 5365371c927SArindam Nath 5375371c927SArindam Nath /* 5385371c927SArindam Nath * Current limit switch is only defined for SDR50, SDR104, and DDR50 5395371c927SArindam Nath * bus speed modes. For other bus speed modes, we set the default 5405371c927SArindam Nath * current limit of 200mA. 5415371c927SArindam Nath */ 5425371c927SArindam Nath if ((card->sd_bus_speed == UHS_SDR50_BUS_SPEED) || 5435371c927SArindam Nath (card->sd_bus_speed == UHS_SDR104_BUS_SPEED) || 5445371c927SArindam Nath (card->sd_bus_speed == UHS_DDR50_BUS_SPEED)) { 5455371c927SArindam Nath if (card->host->caps & MMC_CAP_MAX_CURRENT_800) { 5465371c927SArindam Nath if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_800) 5475371c927SArindam Nath current_limit = SD_SET_CURRENT_LIMIT_800; 5485371c927SArindam Nath else if (card->sw_caps.sd3_curr_limit & 5495371c927SArindam Nath SD_MAX_CURRENT_600) 5505371c927SArindam Nath current_limit = SD_SET_CURRENT_LIMIT_600; 5515371c927SArindam Nath else if (card->sw_caps.sd3_curr_limit & 5525371c927SArindam Nath SD_MAX_CURRENT_400) 5535371c927SArindam Nath current_limit = SD_SET_CURRENT_LIMIT_400; 5545371c927SArindam Nath else if (card->sw_caps.sd3_curr_limit & 5555371c927SArindam Nath SD_MAX_CURRENT_200) 5565371c927SArindam Nath current_limit = SD_SET_CURRENT_LIMIT_200; 5575371c927SArindam Nath } else if (card->host->caps & MMC_CAP_MAX_CURRENT_600) { 5585371c927SArindam Nath if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_600) 5595371c927SArindam Nath current_limit = SD_SET_CURRENT_LIMIT_600; 5605371c927SArindam Nath else if (card->sw_caps.sd3_curr_limit & 5615371c927SArindam Nath SD_MAX_CURRENT_400) 5625371c927SArindam Nath current_limit = SD_SET_CURRENT_LIMIT_400; 5635371c927SArindam Nath else if (card->sw_caps.sd3_curr_limit & 5645371c927SArindam Nath SD_MAX_CURRENT_200) 5655371c927SArindam Nath current_limit = SD_SET_CURRENT_LIMIT_200; 5665371c927SArindam Nath } else if (card->host->caps & MMC_CAP_MAX_CURRENT_400) { 5675371c927SArindam Nath if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_400) 5685371c927SArindam Nath current_limit = SD_SET_CURRENT_LIMIT_400; 5695371c927SArindam Nath else if (card->sw_caps.sd3_curr_limit & 5705371c927SArindam Nath SD_MAX_CURRENT_200) 5715371c927SArindam Nath current_limit = SD_SET_CURRENT_LIMIT_200; 5725371c927SArindam Nath } else if (card->host->caps & MMC_CAP_MAX_CURRENT_200) { 5735371c927SArindam Nath if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_200) 5745371c927SArindam Nath current_limit = SD_SET_CURRENT_LIMIT_200; 5755371c927SArindam Nath } 5765371c927SArindam Nath } else 5775371c927SArindam Nath current_limit = SD_SET_CURRENT_LIMIT_200; 5785371c927SArindam Nath 5795371c927SArindam Nath err = mmc_sd_switch(card, 1, 3, current_limit, status); 5805371c927SArindam Nath if (err) 5815371c927SArindam Nath return err; 5825371c927SArindam Nath 5835371c927SArindam Nath if (((status[15] >> 4) & 0x0F) != current_limit) 5845371c927SArindam Nath printk(KERN_WARNING "%s: Problem setting current limit!\n", 5855371c927SArindam Nath mmc_hostname(card->host)); 5865371c927SArindam Nath 5875371c927SArindam Nath return 0; 5885371c927SArindam Nath } 5895371c927SArindam Nath 590d6d50a15SArindam Nath /* 591d6d50a15SArindam Nath * UHS-I specific initialization procedure 592d6d50a15SArindam Nath */ 593d6d50a15SArindam Nath static int mmc_sd_init_uhs_card(struct mmc_card *card) 594d6d50a15SArindam Nath { 595d6d50a15SArindam Nath int err; 596d6d50a15SArindam Nath u8 *status; 597d6d50a15SArindam Nath 598d6d50a15SArindam Nath if (!card->scr.sda_spec3) 599d6d50a15SArindam Nath return 0; 600d6d50a15SArindam Nath 601d6d50a15SArindam Nath if (!(card->csd.cmdclass & CCC_SWITCH)) 602d6d50a15SArindam Nath return 0; 603d6d50a15SArindam Nath 604d6d50a15SArindam Nath status = kmalloc(64, GFP_KERNEL); 605d6d50a15SArindam Nath if (!status) { 606d6d50a15SArindam Nath printk(KERN_ERR "%s: could not allocate a buffer for " 607d6d50a15SArindam Nath "switch capabilities.\n", mmc_hostname(card->host)); 608d6d50a15SArindam Nath return -ENOMEM; 609d6d50a15SArindam Nath } 610d6d50a15SArindam Nath 611d6d50a15SArindam Nath /* Set 4-bit bus width */ 612d6d50a15SArindam Nath if ((card->host->caps & MMC_CAP_4_BIT_DATA) && 613d6d50a15SArindam Nath (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) { 614d6d50a15SArindam Nath err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4); 615d6d50a15SArindam Nath if (err) 616d6d50a15SArindam Nath goto out; 617d6d50a15SArindam Nath 618d6d50a15SArindam Nath mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4); 619d6d50a15SArindam Nath } 620d6d50a15SArindam Nath 621d6d50a15SArindam Nath /* Set the driver strength for the card */ 622d6d50a15SArindam Nath err = sd_select_driver_type(card, status); 62349c468fcSArindam Nath if (err) 62449c468fcSArindam Nath goto out; 62549c468fcSArindam Nath 62649c468fcSArindam Nath /* Set bus speed mode of the card */ 62749c468fcSArindam Nath err = sd_set_bus_speed_mode(card, status); 6285371c927SArindam Nath if (err) 6295371c927SArindam Nath goto out; 6305371c927SArindam Nath 6315371c927SArindam Nath /* Set current limit for the card */ 6325371c927SArindam Nath err = sd_set_current_limit(card, status); 633b513ea25SArindam Nath if (err) 634b513ea25SArindam Nath goto out; 635b513ea25SArindam Nath 636b513ea25SArindam Nath /* SPI mode doesn't define CMD19 */ 637b513ea25SArindam Nath if (!mmc_host_is_spi(card->host) && card->host->ops->execute_tuning) 638b513ea25SArindam Nath err = card->host->ops->execute_tuning(card->host); 639d6d50a15SArindam Nath 640d6d50a15SArindam Nath out: 641d6d50a15SArindam Nath kfree(status); 642d6d50a15SArindam Nath 643d6d50a15SArindam Nath return err; 644d6d50a15SArindam Nath } 645d6d50a15SArindam Nath 64651ec92e2SPierre Ossman MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1], 64751ec92e2SPierre Ossman card->raw_cid[2], card->raw_cid[3]); 64851ec92e2SPierre Ossman MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1], 64951ec92e2SPierre Ossman card->raw_csd[2], card->raw_csd[3]); 65051ec92e2SPierre Ossman MMC_DEV_ATTR(scr, "%08x%08x\n", card->raw_scr[0], card->raw_scr[1]); 65151ec92e2SPierre Ossman MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year); 652dfe86cbaSAdrian Hunter MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9); 653dfe86cbaSAdrian Hunter MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9); 65451ec92e2SPierre Ossman MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev); 65551ec92e2SPierre Ossman MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev); 65651ec92e2SPierre Ossman MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid); 65751ec92e2SPierre Ossman MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name); 65851ec92e2SPierre Ossman MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid); 65951ec92e2SPierre Ossman MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial); 66051ec92e2SPierre Ossman 66151ec92e2SPierre Ossman 66251ec92e2SPierre Ossman static struct attribute *sd_std_attrs[] = { 66351ec92e2SPierre Ossman &dev_attr_cid.attr, 66451ec92e2SPierre Ossman &dev_attr_csd.attr, 66551ec92e2SPierre Ossman &dev_attr_scr.attr, 66651ec92e2SPierre Ossman &dev_attr_date.attr, 667dfe86cbaSAdrian Hunter &dev_attr_erase_size.attr, 668dfe86cbaSAdrian Hunter &dev_attr_preferred_erase_size.attr, 66951ec92e2SPierre Ossman &dev_attr_fwrev.attr, 67051ec92e2SPierre Ossman &dev_attr_hwrev.attr, 67151ec92e2SPierre Ossman &dev_attr_manfid.attr, 67251ec92e2SPierre Ossman &dev_attr_name.attr, 67351ec92e2SPierre Ossman &dev_attr_oemid.attr, 67451ec92e2SPierre Ossman &dev_attr_serial.attr, 67551ec92e2SPierre Ossman NULL, 67651ec92e2SPierre Ossman }; 67751ec92e2SPierre Ossman 67851ec92e2SPierre Ossman static struct attribute_group sd_std_attr_group = { 67951ec92e2SPierre Ossman .attrs = sd_std_attrs, 68051ec92e2SPierre Ossman }; 68151ec92e2SPierre Ossman 682a4dbd674SDavid Brownell static const struct attribute_group *sd_attr_groups[] = { 68351ec92e2SPierre Ossman &sd_std_attr_group, 68451ec92e2SPierre Ossman NULL, 68551ec92e2SPierre Ossman }; 68651ec92e2SPierre Ossman 68771578a1eSMichal Miroslaw struct device_type sd_type = { 68851ec92e2SPierre Ossman .groups = sd_attr_groups, 68951ec92e2SPierre Ossman }; 69051ec92e2SPierre Ossman 6917ea239d9SPierre Ossman /* 69271578a1eSMichal Miroslaw * Fetch CID from card. 6936abaa0c9SPierre Ossman */ 694d6d50a15SArindam Nath int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr) 6956abaa0c9SPierre Ossman { 6966abaa0c9SPierre Ossman int err; 6976abaa0c9SPierre Ossman 6986abaa0c9SPierre Ossman /* 6996abaa0c9SPierre Ossman * Since we're changing the OCR value, we seem to 7006abaa0c9SPierre Ossman * need to tell some cards to go back to the idle 7016abaa0c9SPierre Ossman * state. We wait 1ms to give cards time to 7026abaa0c9SPierre Ossman * respond. 7036abaa0c9SPierre Ossman */ 7046abaa0c9SPierre Ossman mmc_go_idle(host); 7056abaa0c9SPierre Ossman 7066abaa0c9SPierre Ossman /* 7076abaa0c9SPierre Ossman * If SD_SEND_IF_COND indicates an SD 2.0 7086abaa0c9SPierre Ossman * compliant card and we should set bit 30 7096abaa0c9SPierre Ossman * of the ocr to indicate that we can handle 7106abaa0c9SPierre Ossman * block-addressed SDHC cards. 7116abaa0c9SPierre Ossman */ 7126abaa0c9SPierre Ossman err = mmc_send_if_cond(host, ocr); 71317b0429dSPierre Ossman if (!err) 714f2119df6SArindam Nath ocr |= SD_OCR_CCS; 7156abaa0c9SPierre Ossman 716f2119df6SArindam Nath /* 717f2119df6SArindam Nath * If the host supports one of UHS-I modes, request the card 718f2119df6SArindam Nath * to switch to 1.8V signaling level. 719f2119df6SArindam Nath */ 720f2119df6SArindam Nath if (host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 | 721f2119df6SArindam Nath MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50)) 722f2119df6SArindam Nath ocr |= SD_OCR_S18R; 723f2119df6SArindam Nath 724f2119df6SArindam Nath /* If the host can supply more than 150mA, XPC should be set to 1. */ 725f2119df6SArindam Nath if (host->caps & (MMC_CAP_SET_XPC_330 | MMC_CAP_SET_XPC_300 | 726f2119df6SArindam Nath MMC_CAP_SET_XPC_180)) 727f2119df6SArindam Nath ocr |= SD_OCR_XPC; 728f2119df6SArindam Nath 729f2119df6SArindam Nath try_again: 730d6d50a15SArindam Nath err = mmc_send_app_op_cond(host, ocr, rocr); 73117b0429dSPierre Ossman if (err) 73271578a1eSMichal Miroslaw return err; 7336abaa0c9SPierre Ossman 734f2119df6SArindam Nath /* 735f2119df6SArindam Nath * In case CCS and S18A in the response is set, start Signal Voltage 736f2119df6SArindam Nath * Switch procedure. SPI mode doesn't support CMD11. 737f2119df6SArindam Nath */ 738d6d50a15SArindam Nath if (!mmc_host_is_spi(host) && rocr && 739d6d50a15SArindam Nath ((*rocr & 0x41000000) == 0x41000000)) { 740261bbd46SPhilip Rakity err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180, true); 741f2119df6SArindam Nath if (err) { 742f2119df6SArindam Nath ocr &= ~SD_OCR_S18R; 743f2119df6SArindam Nath goto try_again; 744f2119df6SArindam Nath } 745f2119df6SArindam Nath } 746f2119df6SArindam Nath 747af517150SDavid Brownell if (mmc_host_is_spi(host)) 748af517150SDavid Brownell err = mmc_send_cid(host, cid); 749af517150SDavid Brownell else 7506abaa0c9SPierre Ossman err = mmc_all_send_cid(host, cid); 7516abaa0c9SPierre Ossman 75271578a1eSMichal Miroslaw return err; 753adf66a0dSPierre Ossman } 7546abaa0c9SPierre Ossman 75571578a1eSMichal Miroslaw int mmc_sd_get_csd(struct mmc_host *host, struct mmc_card *card) 75671578a1eSMichal Miroslaw { 75771578a1eSMichal Miroslaw int err; 7586abaa0c9SPierre Ossman 7596abaa0c9SPierre Ossman /* 7606abaa0c9SPierre Ossman * Fetch CSD from card. 7616abaa0c9SPierre Ossman */ 7626abaa0c9SPierre Ossman err = mmc_send_csd(card, card->raw_csd); 76317b0429dSPierre Ossman if (err) 76471578a1eSMichal Miroslaw return err; 7656abaa0c9SPierre Ossman 766bd766312SPierre Ossman err = mmc_decode_csd(card); 767adf66a0dSPierre Ossman if (err) 76871578a1eSMichal Miroslaw return err; 769bd766312SPierre Ossman 77071578a1eSMichal Miroslaw return 0; 7716abaa0c9SPierre Ossman } 7726abaa0c9SPierre Ossman 77371578a1eSMichal Miroslaw int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card, 77471578a1eSMichal Miroslaw bool reinit) 77571578a1eSMichal Miroslaw { 77671578a1eSMichal Miroslaw int err; 7776abaa0c9SPierre Ossman 77871578a1eSMichal Miroslaw if (!reinit) { 7796abaa0c9SPierre Ossman /* 7806abaa0c9SPierre Ossman * Fetch SCR from card. 7816abaa0c9SPierre Ossman */ 7826abaa0c9SPierre Ossman err = mmc_app_send_scr(card, card->raw_scr); 78317b0429dSPierre Ossman if (err) 78471578a1eSMichal Miroslaw return err; 7856abaa0c9SPierre Ossman 786bd766312SPierre Ossman err = mmc_decode_scr(card); 78771578a1eSMichal Miroslaw if (err) 78871578a1eSMichal Miroslaw return err; 7896abaa0c9SPierre Ossman 7906abaa0c9SPierre Ossman /* 791dfe86cbaSAdrian Hunter * Fetch and process SD Status register. 792dfe86cbaSAdrian Hunter */ 793dfe86cbaSAdrian Hunter err = mmc_read_ssr(card); 794dfe86cbaSAdrian Hunter if (err) 795dfe86cbaSAdrian Hunter return err; 796dfe86cbaSAdrian Hunter 797dfe86cbaSAdrian Hunter /* Erase init depends on CSD and SSR */ 798dfe86cbaSAdrian Hunter mmc_init_erase(card); 799dfe86cbaSAdrian Hunter 800dfe86cbaSAdrian Hunter /* 8016abaa0c9SPierre Ossman * Fetch switch information from card. 8026abaa0c9SPierre Ossman */ 8036abaa0c9SPierre Ossman err = mmc_read_switch(card); 80417b0429dSPierre Ossman if (err) 80571578a1eSMichal Miroslaw return err; 8066abaa0c9SPierre Ossman } 8076abaa0c9SPierre Ossman 8086abaa0c9SPierre Ossman /* 8099d9f25c0SWolfgang Muees * For SPI, enable CRC as appropriate. 8109d9f25c0SWolfgang Muees * This CRC enable is located AFTER the reading of the 8119d9f25c0SWolfgang Muees * card registers because some SDHC cards are not able 8129d9f25c0SWolfgang Muees * to provide valid CRCs for non-512-byte blocks. 8139d9f25c0SWolfgang Muees */ 8149d9f25c0SWolfgang Muees if (mmc_host_is_spi(host)) { 8159d9f25c0SWolfgang Muees err = mmc_spi_set_crc(host, use_spi_crc); 8169d9f25c0SWolfgang Muees if (err) 81771578a1eSMichal Miroslaw return err; 8189d9f25c0SWolfgang Muees } 8199d9f25c0SWolfgang Muees 8209d9f25c0SWolfgang Muees /* 82171578a1eSMichal Miroslaw * Check if read-only switch is active. 8226abaa0c9SPierre Ossman */ 82371578a1eSMichal Miroslaw if (!reinit) { 82471578a1eSMichal Miroslaw int ro = -1; 8256abaa0c9SPierre Ossman 82671578a1eSMichal Miroslaw if (host->ops->get_ro) 82771578a1eSMichal Miroslaw ro = host->ops->get_ro(host); 82871578a1eSMichal Miroslaw 82971578a1eSMichal Miroslaw if (ro < 0) { 83071578a1eSMichal Miroslaw printk(KERN_WARNING "%s: host does not " 83171578a1eSMichal Miroslaw "support reading read-only " 83271578a1eSMichal Miroslaw "switch. assuming write-enable.\n", 83371578a1eSMichal Miroslaw mmc_hostname(host)); 83471578a1eSMichal Miroslaw } else if (ro > 0) { 83571578a1eSMichal Miroslaw mmc_card_set_readonly(card); 83671578a1eSMichal Miroslaw } 83771578a1eSMichal Miroslaw } 83871578a1eSMichal Miroslaw 83971578a1eSMichal Miroslaw return 0; 84071578a1eSMichal Miroslaw } 84171578a1eSMichal Miroslaw 84271578a1eSMichal Miroslaw unsigned mmc_sd_get_max_clock(struct mmc_card *card) 84371578a1eSMichal Miroslaw { 84471578a1eSMichal Miroslaw unsigned max_dtr = (unsigned int)-1; 8456abaa0c9SPierre Ossman 8466abaa0c9SPierre Ossman if (mmc_card_highspeed(card)) { 8476abaa0c9SPierre Ossman if (max_dtr > card->sw_caps.hs_max_dtr) 8486abaa0c9SPierre Ossman max_dtr = card->sw_caps.hs_max_dtr; 8496abaa0c9SPierre Ossman } else if (max_dtr > card->csd.max_dtr) { 8506abaa0c9SPierre Ossman max_dtr = card->csd.max_dtr; 8516abaa0c9SPierre Ossman } 8526abaa0c9SPierre Ossman 85371578a1eSMichal Miroslaw return max_dtr; 85471578a1eSMichal Miroslaw } 85571578a1eSMichal Miroslaw 85671578a1eSMichal Miroslaw void mmc_sd_go_highspeed(struct mmc_card *card) 85771578a1eSMichal Miroslaw { 85871578a1eSMichal Miroslaw mmc_card_set_highspeed(card); 85971578a1eSMichal Miroslaw mmc_set_timing(card->host, MMC_TIMING_SD_HS); 86071578a1eSMichal Miroslaw } 86171578a1eSMichal Miroslaw 86271578a1eSMichal Miroslaw /* 86371578a1eSMichal Miroslaw * Handle the detection and initialisation of a card. 86471578a1eSMichal Miroslaw * 86571578a1eSMichal Miroslaw * In the case of a resume, "oldcard" will contain the card 86671578a1eSMichal Miroslaw * we're trying to reinitialise. 86771578a1eSMichal Miroslaw */ 86871578a1eSMichal Miroslaw static int mmc_sd_init_card(struct mmc_host *host, u32 ocr, 86971578a1eSMichal Miroslaw struct mmc_card *oldcard) 87071578a1eSMichal Miroslaw { 87171578a1eSMichal Miroslaw struct mmc_card *card; 87271578a1eSMichal Miroslaw int err; 87371578a1eSMichal Miroslaw u32 cid[4]; 874d6d50a15SArindam Nath u32 rocr = 0; 87571578a1eSMichal Miroslaw 87671578a1eSMichal Miroslaw BUG_ON(!host); 87771578a1eSMichal Miroslaw WARN_ON(!host->claimed); 87871578a1eSMichal Miroslaw 879d6d50a15SArindam Nath err = mmc_sd_get_cid(host, ocr, cid, &rocr); 88071578a1eSMichal Miroslaw if (err) 88171578a1eSMichal Miroslaw return err; 88271578a1eSMichal Miroslaw 88371578a1eSMichal Miroslaw if (oldcard) { 88471578a1eSMichal Miroslaw if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) 88571578a1eSMichal Miroslaw return -ENOENT; 88671578a1eSMichal Miroslaw 88771578a1eSMichal Miroslaw card = oldcard; 88871578a1eSMichal Miroslaw } else { 88971578a1eSMichal Miroslaw /* 89071578a1eSMichal Miroslaw * Allocate card structure. 89171578a1eSMichal Miroslaw */ 89271578a1eSMichal Miroslaw card = mmc_alloc_card(host, &sd_type); 89371578a1eSMichal Miroslaw if (IS_ERR(card)) 89471578a1eSMichal Miroslaw return PTR_ERR(card); 89571578a1eSMichal Miroslaw 89671578a1eSMichal Miroslaw card->type = MMC_TYPE_SD; 89771578a1eSMichal Miroslaw memcpy(card->raw_cid, cid, sizeof(card->raw_cid)); 89871578a1eSMichal Miroslaw } 89971578a1eSMichal Miroslaw 90071578a1eSMichal Miroslaw /* 90171578a1eSMichal Miroslaw * For native busses: get card RCA and quit open drain mode. 90271578a1eSMichal Miroslaw */ 90371578a1eSMichal Miroslaw if (!mmc_host_is_spi(host)) { 90471578a1eSMichal Miroslaw err = mmc_send_relative_addr(host, &card->rca); 90571578a1eSMichal Miroslaw if (err) 90671578a1eSMichal Miroslaw return err; 90771578a1eSMichal Miroslaw 90871578a1eSMichal Miroslaw mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL); 90971578a1eSMichal Miroslaw } 91071578a1eSMichal Miroslaw 91171578a1eSMichal Miroslaw if (!oldcard) { 91271578a1eSMichal Miroslaw err = mmc_sd_get_csd(host, card); 91371578a1eSMichal Miroslaw if (err) 91471578a1eSMichal Miroslaw return err; 91571578a1eSMichal Miroslaw 91671578a1eSMichal Miroslaw mmc_decode_cid(card); 91771578a1eSMichal Miroslaw } 91871578a1eSMichal Miroslaw 91971578a1eSMichal Miroslaw /* 92071578a1eSMichal Miroslaw * Select card, as all following commands rely on that. 92171578a1eSMichal Miroslaw */ 92271578a1eSMichal Miroslaw if (!mmc_host_is_spi(host)) { 92371578a1eSMichal Miroslaw err = mmc_select_card(card); 92471578a1eSMichal Miroslaw if (err) 92571578a1eSMichal Miroslaw return err; 92671578a1eSMichal Miroslaw } 92771578a1eSMichal Miroslaw 92871578a1eSMichal Miroslaw err = mmc_sd_setup_card(host, card, oldcard != NULL); 92971578a1eSMichal Miroslaw if (err) 93071578a1eSMichal Miroslaw goto free_card; 93171578a1eSMichal Miroslaw 932d6d50a15SArindam Nath /* Initialization sequence for UHS-I cards */ 933d6d50a15SArindam Nath if (rocr & SD_ROCR_S18A) { 934d6d50a15SArindam Nath err = mmc_sd_init_uhs_card(card); 935d6d50a15SArindam Nath if (err) 936d6d50a15SArindam Nath goto free_card; 9373a303511SArindam Nath 9383a303511SArindam Nath /* Card is an ultra-high-speed card */ 9393a303511SArindam Nath mmc_sd_card_set_uhs(card); 9404d55c5a1SArindam Nath 9414d55c5a1SArindam Nath /* 9424d55c5a1SArindam Nath * Since initialization is now complete, enable preset 9434d55c5a1SArindam Nath * value registers for UHS-I cards. 9444d55c5a1SArindam Nath */ 9454d55c5a1SArindam Nath if (host->ops->enable_preset_value) 9464d55c5a1SArindam Nath host->ops->enable_preset_value(host, true); 947d6d50a15SArindam Nath } else { 94871578a1eSMichal Miroslaw /* 94971578a1eSMichal Miroslaw * Attempt to change to high-speed (if supported) 95071578a1eSMichal Miroslaw */ 95171578a1eSMichal Miroslaw err = mmc_sd_switch_hs(card); 95271578a1eSMichal Miroslaw if (err > 0) 95371578a1eSMichal Miroslaw mmc_sd_go_highspeed(card); 95471578a1eSMichal Miroslaw else if (err) 95571578a1eSMichal Miroslaw goto free_card; 95671578a1eSMichal Miroslaw 95771578a1eSMichal Miroslaw /* 95871578a1eSMichal Miroslaw * Set bus speed. 95971578a1eSMichal Miroslaw */ 96071578a1eSMichal Miroslaw mmc_set_clock(host, mmc_sd_get_max_clock(card)); 9616abaa0c9SPierre Ossman 9626abaa0c9SPierre Ossman /* 9636abaa0c9SPierre Ossman * Switch to wider bus (if supported). 9646abaa0c9SPierre Ossman */ 96571651297SPierre Ossman if ((host->caps & MMC_CAP_4_BIT_DATA) && 9666abaa0c9SPierre Ossman (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) { 9676abaa0c9SPierre Ossman err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4); 96817b0429dSPierre Ossman if (err) 9696abaa0c9SPierre Ossman goto free_card; 9706abaa0c9SPierre Ossman 9716abaa0c9SPierre Ossman mmc_set_bus_width(host, MMC_BUS_WIDTH_4); 9726abaa0c9SPierre Ossman } 973d6d50a15SArindam Nath } 9746abaa0c9SPierre Ossman 9756abaa0c9SPierre Ossman host->card = card; 97617b0429dSPierre Ossman return 0; 9776abaa0c9SPierre Ossman 9786abaa0c9SPierre Ossman free_card: 9796abaa0c9SPierre Ossman if (!oldcard) 9806abaa0c9SPierre Ossman mmc_remove_card(card); 9816abaa0c9SPierre Ossman 982adf66a0dSPierre Ossman return err; 9836abaa0c9SPierre Ossman } 9846abaa0c9SPierre Ossman 9856abaa0c9SPierre Ossman /* 9867ea239d9SPierre Ossman * Host is being removed. Free up the current card. 9877ea239d9SPierre Ossman */ 9887ea239d9SPierre Ossman static void mmc_sd_remove(struct mmc_host *host) 9897ea239d9SPierre Ossman { 9907ea239d9SPierre Ossman BUG_ON(!host); 9917ea239d9SPierre Ossman BUG_ON(!host->card); 9927ea239d9SPierre Ossman 9937ea239d9SPierre Ossman mmc_remove_card(host->card); 9947ea239d9SPierre Ossman host->card = NULL; 9957ea239d9SPierre Ossman } 9967ea239d9SPierre Ossman 9977ea239d9SPierre Ossman /* 9987ea239d9SPierre Ossman * Card detection callback from host. 9997ea239d9SPierre Ossman */ 10007ea239d9SPierre Ossman static void mmc_sd_detect(struct mmc_host *host) 10017ea239d9SPierre Ossman { 10027ea239d9SPierre Ossman int err; 10037ea239d9SPierre Ossman 10047ea239d9SPierre Ossman BUG_ON(!host); 10057ea239d9SPierre Ossman BUG_ON(!host->card); 10067ea239d9SPierre Ossman 10077ea239d9SPierre Ossman mmc_claim_host(host); 10087ea239d9SPierre Ossman 10097ea239d9SPierre Ossman /* 10107ea239d9SPierre Ossman * Just check if our card has been removed. 10117ea239d9SPierre Ossman */ 10127ea239d9SPierre Ossman err = mmc_send_status(host->card, NULL); 10137ea239d9SPierre Ossman 10147ea239d9SPierre Ossman mmc_release_host(host); 10157ea239d9SPierre Ossman 101617b0429dSPierre Ossman if (err) { 10174101c16aSPierre Ossman mmc_sd_remove(host); 10187ea239d9SPierre Ossman 10197ea239d9SPierre Ossman mmc_claim_host(host); 10207ea239d9SPierre Ossman mmc_detach_bus(host); 10217ea239d9SPierre Ossman mmc_release_host(host); 10227ea239d9SPierre Ossman } 10237ea239d9SPierre Ossman } 10247ea239d9SPierre Ossman 10256abaa0c9SPierre Ossman /* 10266abaa0c9SPierre Ossman * Suspend callback from host. 10276abaa0c9SPierre Ossman */ 102895cdfb72SNicolas Pitre static int mmc_sd_suspend(struct mmc_host *host) 10296abaa0c9SPierre Ossman { 10306abaa0c9SPierre Ossman BUG_ON(!host); 10316abaa0c9SPierre Ossman BUG_ON(!host->card); 10326abaa0c9SPierre Ossman 10336abaa0c9SPierre Ossman mmc_claim_host(host); 1034af517150SDavid Brownell if (!mmc_host_is_spi(host)) 10356abaa0c9SPierre Ossman mmc_deselect_cards(host); 10366abaa0c9SPierre Ossman host->card->state &= ~MMC_STATE_HIGHSPEED; 10376abaa0c9SPierre Ossman mmc_release_host(host); 103895cdfb72SNicolas Pitre 103995cdfb72SNicolas Pitre return 0; 10406abaa0c9SPierre Ossman } 10416abaa0c9SPierre Ossman 10426abaa0c9SPierre Ossman /* 10436abaa0c9SPierre Ossman * Resume callback from host. 10446abaa0c9SPierre Ossman * 10456abaa0c9SPierre Ossman * This function tries to determine if the same card is still present 10466abaa0c9SPierre Ossman * and, if so, restore all state to it. 10476abaa0c9SPierre Ossman */ 104895cdfb72SNicolas Pitre static int mmc_sd_resume(struct mmc_host *host) 10496abaa0c9SPierre Ossman { 10506abaa0c9SPierre Ossman int err; 10516abaa0c9SPierre Ossman 10526abaa0c9SPierre Ossman BUG_ON(!host); 10536abaa0c9SPierre Ossman BUG_ON(!host->card); 10546abaa0c9SPierre Ossman 10556abaa0c9SPierre Ossman mmc_claim_host(host); 10566abaa0c9SPierre Ossman err = mmc_sd_init_card(host, host->ocr, host->card); 10572986d0bfSPierre Ossman mmc_release_host(host); 10582986d0bfSPierre Ossman 105995cdfb72SNicolas Pitre return err; 10606abaa0c9SPierre Ossman } 10616abaa0c9SPierre Ossman 106212ae637fSOhad Ben-Cohen static int mmc_sd_power_restore(struct mmc_host *host) 1063eae1aeeeSAdrian Hunter { 106412ae637fSOhad Ben-Cohen int ret; 106512ae637fSOhad Ben-Cohen 1066eae1aeeeSAdrian Hunter host->card->state &= ~MMC_STATE_HIGHSPEED; 1067eae1aeeeSAdrian Hunter mmc_claim_host(host); 106812ae637fSOhad Ben-Cohen ret = mmc_sd_init_card(host, host->ocr, host->card); 1069eae1aeeeSAdrian Hunter mmc_release_host(host); 107012ae637fSOhad Ben-Cohen 107112ae637fSOhad Ben-Cohen return ret; 1072eae1aeeeSAdrian Hunter } 1073eae1aeeeSAdrian Hunter 10749feae246SAdrian Hunter static const struct mmc_bus_ops mmc_sd_ops = { 10759feae246SAdrian Hunter .remove = mmc_sd_remove, 10769feae246SAdrian Hunter .detect = mmc_sd_detect, 10779feae246SAdrian Hunter .suspend = NULL, 10789feae246SAdrian Hunter .resume = NULL, 1079eae1aeeeSAdrian Hunter .power_restore = mmc_sd_power_restore, 10809feae246SAdrian Hunter }; 10819feae246SAdrian Hunter 10829feae246SAdrian Hunter static const struct mmc_bus_ops mmc_sd_ops_unsafe = { 10839feae246SAdrian Hunter .remove = mmc_sd_remove, 10849feae246SAdrian Hunter .detect = mmc_sd_detect, 10859feae246SAdrian Hunter .suspend = mmc_sd_suspend, 10869feae246SAdrian Hunter .resume = mmc_sd_resume, 1087eae1aeeeSAdrian Hunter .power_restore = mmc_sd_power_restore, 10889feae246SAdrian Hunter }; 10899feae246SAdrian Hunter 10909feae246SAdrian Hunter static void mmc_sd_attach_bus_ops(struct mmc_host *host) 10919feae246SAdrian Hunter { 10929feae246SAdrian Hunter const struct mmc_bus_ops *bus_ops; 10939feae246SAdrian Hunter 109471d7d3d1SMatt Fleming if (!mmc_card_is_removable(host)) 10959feae246SAdrian Hunter bus_ops = &mmc_sd_ops_unsafe; 10969feae246SAdrian Hunter else 10979feae246SAdrian Hunter bus_ops = &mmc_sd_ops; 10989feae246SAdrian Hunter mmc_attach_bus(host, bus_ops); 10999feae246SAdrian Hunter } 11009feae246SAdrian Hunter 11017ea239d9SPierre Ossman /* 11027ea239d9SPierre Ossman * Starting point for SD card init. 11037ea239d9SPierre Ossman */ 1104807e8e40SAndy Ross int mmc_attach_sd(struct mmc_host *host) 11057ea239d9SPierre Ossman { 11067ea239d9SPierre Ossman int err; 1107807e8e40SAndy Ross u32 ocr; 11087ea239d9SPierre Ossman 11097ea239d9SPierre Ossman BUG_ON(!host); 1110d84075c8SPierre Ossman WARN_ON(!host->claimed); 11117ea239d9SPierre Ossman 1112f2119df6SArindam Nath /* Make sure we are at 3.3V signalling voltage */ 1113261bbd46SPhilip Rakity err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, false); 1114f2119df6SArindam Nath if (err) 1115f2119df6SArindam Nath return err; 1116f2119df6SArindam Nath 11174d55c5a1SArindam Nath /* Disable preset value enable if already set since last time */ 11184d55c5a1SArindam Nath if (host->ops->enable_preset_value) 11194d55c5a1SArindam Nath host->ops->enable_preset_value(host, false); 11204d55c5a1SArindam Nath 1121807e8e40SAndy Ross err = mmc_send_app_op_cond(host, 0, &ocr); 1122807e8e40SAndy Ross if (err) 1123807e8e40SAndy Ross return err; 1124807e8e40SAndy Ross 11259feae246SAdrian Hunter mmc_sd_attach_bus_ops(host); 11268f230f45STakashi Iwai if (host->ocr_avail_sd) 11278f230f45STakashi Iwai host->ocr_avail = host->ocr_avail_sd; 11287ea239d9SPierre Ossman 112955556da0SPhilip Langdale /* 1130af517150SDavid Brownell * We need to get OCR a different way for SPI. 1131af517150SDavid Brownell */ 1132af517150SDavid Brownell if (mmc_host_is_spi(host)) { 1133af517150SDavid Brownell mmc_go_idle(host); 1134af517150SDavid Brownell 1135af517150SDavid Brownell err = mmc_spi_read_ocr(host, 0, &ocr); 1136af517150SDavid Brownell if (err) 1137af517150SDavid Brownell goto err; 1138af517150SDavid Brownell } 1139af517150SDavid Brownell 1140af517150SDavid Brownell /* 114155556da0SPhilip Langdale * Sanity check the voltages that the card claims to 114255556da0SPhilip Langdale * support. 114355556da0SPhilip Langdale */ 114455556da0SPhilip Langdale if (ocr & 0x7F) { 114555556da0SPhilip Langdale printk(KERN_WARNING "%s: card claims to support voltages " 114655556da0SPhilip Langdale "below the defined range. These will be ignored.\n", 114755556da0SPhilip Langdale mmc_hostname(host)); 114855556da0SPhilip Langdale ocr &= ~0x7F; 114955556da0SPhilip Langdale } 115055556da0SPhilip Langdale 11518f230f45STakashi Iwai if ((ocr & MMC_VDD_165_195) && 11528f230f45STakashi Iwai !(host->ocr_avail_sd & MMC_VDD_165_195)) { 115355556da0SPhilip Langdale printk(KERN_WARNING "%s: SD card claims to support the " 115455556da0SPhilip Langdale "incompletely defined 'low voltage range'. This " 115555556da0SPhilip Langdale "will be ignored.\n", mmc_hostname(host)); 115655556da0SPhilip Langdale ocr &= ~MMC_VDD_165_195; 115755556da0SPhilip Langdale } 115855556da0SPhilip Langdale 11597ea239d9SPierre Ossman host->ocr = mmc_select_voltage(host, ocr); 11607ea239d9SPierre Ossman 11617ea239d9SPierre Ossman /* 11627ea239d9SPierre Ossman * Can we support the voltage(s) of the card(s)? 11637ea239d9SPierre Ossman */ 1164109b5bedSPierre Ossman if (!host->ocr) { 1165109b5bedSPierre Ossman err = -EINVAL; 11667ea239d9SPierre Ossman goto err; 1167109b5bedSPierre Ossman } 11687ea239d9SPierre Ossman 11697ea239d9SPierre Ossman /* 11706abaa0c9SPierre Ossman * Detect and init the card. 11717ea239d9SPierre Ossman */ 11726abaa0c9SPierre Ossman err = mmc_sd_init_card(host, host->ocr, NULL); 117317b0429dSPierre Ossman if (err) 11747ea239d9SPierre Ossman goto err; 11757ea239d9SPierre Ossman 11767ea239d9SPierre Ossman mmc_release_host(host); 11774101c16aSPierre Ossman err = mmc_add_card(host->card); 1178807e8e40SAndy Ross mmc_claim_host(host); 11797ea239d9SPierre Ossman if (err) 11802986d0bfSPierre Ossman goto remove_card; 11817ea239d9SPierre Ossman 11827ea239d9SPierre Ossman return 0; 11837ea239d9SPierre Ossman 11842986d0bfSPierre Ossman remove_card: 1185807e8e40SAndy Ross mmc_release_host(host); 11866abaa0c9SPierre Ossman mmc_remove_card(host->card); 11877ea239d9SPierre Ossman host->card = NULL; 11882986d0bfSPierre Ossman mmc_claim_host(host); 11897ea239d9SPierre Ossman err: 11907ea239d9SPierre Ossman mmc_detach_bus(host); 11917ea239d9SPierre Ossman 1192109b5bedSPierre Ossman printk(KERN_ERR "%s: error %d whilst initialising SD card\n", 1193109b5bedSPierre Ossman mmc_hostname(host), err); 1194109b5bedSPierre Ossman 1195adf66a0dSPierre Ossman return err; 11967ea239d9SPierre Ossman } 11977ea239d9SPierre Ossman 1198