Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 1 | /* |
Pierre Ossman | 70f1048 | 2007-07-11 20:04:50 +0200 | [diff] [blame] | 2 | * linux/drivers/mmc/core/sd.c |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 3 | * |
| 4 | * Copyright (C) 2003-2004 Russell King, All Rights Reserved. |
| 5 | * SD support Copyright (C) 2004 Ian Molton, All Rights Reserved. |
| 6 | * Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved. |
| 7 | * |
| 8 | * This program is free software; you can redistribute it and/or modify |
| 9 | * it under the terms of the GNU General Public License version 2 as |
| 10 | * published by the Free Software Foundation. |
| 11 | */ |
| 12 | |
| 13 | #include <linux/err.h> |
| 14 | |
| 15 | #include <linux/mmc/host.h> |
| 16 | #include <linux/mmc/card.h> |
| 17 | #include <linux/mmc/mmc.h> |
Pierre Ossman | 3373c0a | 2007-05-31 22:25:11 +0200 | [diff] [blame] | 18 | #include <linux/mmc/sd.h> |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 19 | |
| 20 | #include "core.h" |
| 21 | #include "sysfs.h" |
Pierre Ossman | 4101c16 | 2007-05-19 13:39:01 +0200 | [diff] [blame] | 22 | #include "bus.h" |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 23 | #include "mmc_ops.h" |
| 24 | #include "sd_ops.h" |
| 25 | |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 26 | static const unsigned int tran_exp[] = { |
| 27 | 10000, 100000, 1000000, 10000000, |
| 28 | 0, 0, 0, 0 |
| 29 | }; |
| 30 | |
| 31 | static const unsigned char tran_mant[] = { |
| 32 | 0, 10, 12, 13, 15, 20, 25, 30, |
| 33 | 35, 40, 45, 50, 55, 60, 70, 80, |
| 34 | }; |
| 35 | |
| 36 | static const unsigned int tacc_exp[] = { |
| 37 | 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, |
| 38 | }; |
| 39 | |
| 40 | static const unsigned int tacc_mant[] = { |
| 41 | 0, 10, 12, 13, 15, 20, 25, 30, |
| 42 | 35, 40, 45, 50, 55, 60, 70, 80, |
| 43 | }; |
| 44 | |
| 45 | #define UNSTUFF_BITS(resp,start,size) \ |
| 46 | ({ \ |
| 47 | const int __size = size; \ |
| 48 | const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \ |
| 49 | const int __off = 3 - ((start) / 32); \ |
| 50 | const int __shft = (start) & 31; \ |
| 51 | u32 __res; \ |
| 52 | \ |
| 53 | __res = resp[__off] >> __shft; \ |
| 54 | if (__size + __shft > 32) \ |
| 55 | __res |= resp[__off-1] << ((32 - __shft) % 32); \ |
| 56 | __res & __mask; \ |
| 57 | }) |
| 58 | |
| 59 | /* |
| 60 | * Given the decoded CSD structure, decode the raw CID to our CID structure. |
| 61 | */ |
| 62 | static void mmc_decode_cid(struct mmc_card *card) |
| 63 | { |
| 64 | u32 *resp = card->raw_cid; |
| 65 | |
| 66 | memset(&card->cid, 0, sizeof(struct mmc_cid)); |
| 67 | |
| 68 | /* |
| 69 | * SD doesn't currently have a version field so we will |
| 70 | * have to assume we can parse this. |
| 71 | */ |
| 72 | card->cid.manfid = UNSTUFF_BITS(resp, 120, 8); |
| 73 | card->cid.oemid = UNSTUFF_BITS(resp, 104, 16); |
| 74 | card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8); |
| 75 | card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8); |
| 76 | card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8); |
| 77 | card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8); |
| 78 | card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8); |
| 79 | card->cid.hwrev = UNSTUFF_BITS(resp, 60, 4); |
| 80 | card->cid.fwrev = UNSTUFF_BITS(resp, 56, 4); |
| 81 | card->cid.serial = UNSTUFF_BITS(resp, 24, 32); |
| 82 | card->cid.year = UNSTUFF_BITS(resp, 12, 8); |
| 83 | card->cid.month = UNSTUFF_BITS(resp, 8, 4); |
| 84 | |
| 85 | card->cid.year += 2000; /* SD cards year offset */ |
| 86 | } |
| 87 | |
| 88 | /* |
| 89 | * Given a 128-bit response, decode to our card CSD structure. |
| 90 | */ |
Pierre Ossman | bd76631 | 2007-05-01 16:11:57 +0200 | [diff] [blame] | 91 | static int mmc_decode_csd(struct mmc_card *card) |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 92 | { |
| 93 | struct mmc_csd *csd = &card->csd; |
| 94 | unsigned int e, m, csd_struct; |
| 95 | u32 *resp = card->raw_csd; |
| 96 | |
| 97 | csd_struct = UNSTUFF_BITS(resp, 126, 2); |
| 98 | |
| 99 | switch (csd_struct) { |
| 100 | case 0: |
| 101 | m = UNSTUFF_BITS(resp, 115, 4); |
| 102 | e = UNSTUFF_BITS(resp, 112, 3); |
| 103 | csd->tacc_ns = (tacc_exp[e] * tacc_mant[m] + 9) / 10; |
| 104 | csd->tacc_clks = UNSTUFF_BITS(resp, 104, 8) * 100; |
| 105 | |
| 106 | m = UNSTUFF_BITS(resp, 99, 4); |
| 107 | e = UNSTUFF_BITS(resp, 96, 3); |
| 108 | csd->max_dtr = tran_exp[e] * tran_mant[m]; |
| 109 | csd->cmdclass = UNSTUFF_BITS(resp, 84, 12); |
| 110 | |
| 111 | e = UNSTUFF_BITS(resp, 47, 3); |
| 112 | m = UNSTUFF_BITS(resp, 62, 12); |
| 113 | csd->capacity = (1 + m) << (e + 2); |
| 114 | |
| 115 | csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4); |
| 116 | csd->read_partial = UNSTUFF_BITS(resp, 79, 1); |
| 117 | csd->write_misalign = UNSTUFF_BITS(resp, 78, 1); |
| 118 | csd->read_misalign = UNSTUFF_BITS(resp, 77, 1); |
| 119 | csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3); |
| 120 | csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4); |
| 121 | csd->write_partial = UNSTUFF_BITS(resp, 21, 1); |
| 122 | break; |
| 123 | case 1: |
| 124 | /* |
| 125 | * This is a block-addressed SDHC card. Most |
| 126 | * interesting fields are unused and have fixed |
| 127 | * values. To avoid getting tripped by buggy cards, |
| 128 | * we assume those fixed values ourselves. |
| 129 | */ |
| 130 | mmc_card_set_blockaddr(card); |
| 131 | |
| 132 | csd->tacc_ns = 0; /* Unused */ |
| 133 | csd->tacc_clks = 0; /* Unused */ |
| 134 | |
| 135 | m = UNSTUFF_BITS(resp, 99, 4); |
| 136 | e = UNSTUFF_BITS(resp, 96, 3); |
| 137 | csd->max_dtr = tran_exp[e] * tran_mant[m]; |
| 138 | csd->cmdclass = UNSTUFF_BITS(resp, 84, 12); |
| 139 | |
| 140 | m = UNSTUFF_BITS(resp, 48, 22); |
| 141 | csd->capacity = (1 + m) << 10; |
| 142 | |
| 143 | csd->read_blkbits = 9; |
| 144 | csd->read_partial = 0; |
| 145 | csd->write_misalign = 0; |
| 146 | csd->read_misalign = 0; |
| 147 | csd->r2w_factor = 4; /* Unused */ |
| 148 | csd->write_blkbits = 9; |
| 149 | csd->write_partial = 0; |
| 150 | break; |
| 151 | default: |
Pierre Ossman | facba91 | 2007-07-24 21:53:43 +0200 | [diff] [blame] | 152 | printk(KERN_ERR "%s: unrecognised CSD structure version %d\n", |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 153 | mmc_hostname(card->host), csd_struct); |
Pierre Ossman | bd76631 | 2007-05-01 16:11:57 +0200 | [diff] [blame] | 154 | return -EINVAL; |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 155 | } |
Pierre Ossman | bd76631 | 2007-05-01 16:11:57 +0200 | [diff] [blame] | 156 | |
| 157 | return 0; |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 158 | } |
| 159 | |
| 160 | /* |
| 161 | * Given a 64-bit response, decode to our card SCR structure. |
| 162 | */ |
Pierre Ossman | bd76631 | 2007-05-01 16:11:57 +0200 | [diff] [blame] | 163 | static int mmc_decode_scr(struct mmc_card *card) |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 164 | { |
| 165 | struct sd_scr *scr = &card->scr; |
| 166 | unsigned int scr_struct; |
| 167 | u32 resp[4]; |
| 168 | |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 169 | resp[3] = card->raw_scr[1]; |
| 170 | resp[2] = card->raw_scr[0]; |
| 171 | |
| 172 | scr_struct = UNSTUFF_BITS(resp, 60, 4); |
| 173 | if (scr_struct != 0) { |
Pierre Ossman | facba91 | 2007-07-24 21:53:43 +0200 | [diff] [blame] | 174 | printk(KERN_ERR "%s: unrecognised SCR structure version %d\n", |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 175 | mmc_hostname(card->host), scr_struct); |
Pierre Ossman | bd76631 | 2007-05-01 16:11:57 +0200 | [diff] [blame] | 176 | return -EINVAL; |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 177 | } |
| 178 | |
| 179 | scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4); |
| 180 | scr->bus_widths = UNSTUFF_BITS(resp, 48, 4); |
Pierre Ossman | bd76631 | 2007-05-01 16:11:57 +0200 | [diff] [blame] | 181 | |
| 182 | return 0; |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 183 | } |
| 184 | |
| 185 | /* |
Pierre Ossman | 1addfcd | 2007-05-01 14:46:08 +0200 | [diff] [blame] | 186 | * Fetches and decodes switch information |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 187 | */ |
Pierre Ossman | 1addfcd | 2007-05-01 14:46:08 +0200 | [diff] [blame] | 188 | static int mmc_read_switch(struct mmc_card *card) |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 189 | { |
| 190 | int err; |
| 191 | u8 *status; |
| 192 | |
Pierre Ossman | 3373c0a | 2007-05-31 22:25:11 +0200 | [diff] [blame] | 193 | if (card->scr.sda_vsn < SCR_SPEC_VER_1) |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 194 | return 0; |
Pierre Ossman | 3373c0a | 2007-05-31 22:25:11 +0200 | [diff] [blame] | 195 | |
| 196 | if (!(card->csd.cmdclass & CCC_SWITCH)) { |
| 197 | printk(KERN_WARNING "%s: card lacks mandatory switch " |
| 198 | "function, performance might suffer.\n", |
| 199 | mmc_hostname(card->host)); |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 200 | return 0; |
Pierre Ossman | 3373c0a | 2007-05-31 22:25:11 +0200 | [diff] [blame] | 201 | } |
| 202 | |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 203 | err = -EIO; |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 204 | |
| 205 | status = kmalloc(64, GFP_KERNEL); |
| 206 | if (!status) { |
Pierre Ossman | facba91 | 2007-07-24 21:53:43 +0200 | [diff] [blame] | 207 | printk(KERN_ERR "%s: could not allocate a buffer for " |
| 208 | "switch capabilities.\n", mmc_hostname(card->host)); |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 209 | return -ENOMEM; |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 210 | } |
| 211 | |
| 212 | err = mmc_sd_switch(card, 0, 0, 1, status); |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 213 | if (err) { |
Pierre Ossman | adf66a0 | 2007-07-22 23:08:30 +0200 | [diff] [blame] | 214 | /* |
| 215 | * We all hosts that cannot perform the command |
| 216 | * to fail more gracefully |
| 217 | */ |
| 218 | if (err != -EINVAL) |
| 219 | goto out; |
| 220 | |
Pierre Ossman | 3373c0a | 2007-05-31 22:25:11 +0200 | [diff] [blame] | 221 | printk(KERN_WARNING "%s: problem reading switch " |
| 222 | "capabilities, performance might suffer.\n", |
| 223 | mmc_hostname(card->host)); |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 224 | err = 0; |
Pierre Ossman | adf66a0 | 2007-07-22 23:08:30 +0200 | [diff] [blame] | 225 | |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 226 | goto out; |
| 227 | } |
| 228 | |
| 229 | if (status[13] & 0x02) |
| 230 | card->sw_caps.hs_max_dtr = 50000000; |
| 231 | |
Pierre Ossman | 1addfcd | 2007-05-01 14:46:08 +0200 | [diff] [blame] | 232 | out: |
| 233 | kfree(status); |
| 234 | |
| 235 | return err; |
| 236 | } |
| 237 | |
| 238 | /* |
| 239 | * Test if the card supports high-speed mode and, if so, switch to it. |
| 240 | */ |
| 241 | static int mmc_switch_hs(struct mmc_card *card) |
| 242 | { |
| 243 | int err; |
| 244 | u8 *status; |
| 245 | |
Pierre Ossman | 3373c0a | 2007-05-31 22:25:11 +0200 | [diff] [blame] | 246 | if (card->scr.sda_vsn < SCR_SPEC_VER_1) |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 247 | return 0; |
Pierre Ossman | 3373c0a | 2007-05-31 22:25:11 +0200 | [diff] [blame] | 248 | |
| 249 | if (!(card->csd.cmdclass & CCC_SWITCH)) |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 250 | return 0; |
Pierre Ossman | 3373c0a | 2007-05-31 22:25:11 +0200 | [diff] [blame] | 251 | |
Pierre Ossman | 1addfcd | 2007-05-01 14:46:08 +0200 | [diff] [blame] | 252 | if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED)) |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 253 | return 0; |
Pierre Ossman | 1addfcd | 2007-05-01 14:46:08 +0200 | [diff] [blame] | 254 | |
| 255 | if (card->sw_caps.hs_max_dtr == 0) |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 256 | return 0; |
Pierre Ossman | 1addfcd | 2007-05-01 14:46:08 +0200 | [diff] [blame] | 257 | |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 258 | err = -EIO; |
Pierre Ossman | 1addfcd | 2007-05-01 14:46:08 +0200 | [diff] [blame] | 259 | |
| 260 | status = kmalloc(64, GFP_KERNEL); |
| 261 | if (!status) { |
Pierre Ossman | facba91 | 2007-07-24 21:53:43 +0200 | [diff] [blame] | 262 | printk(KERN_ERR "%s: could not allocate a buffer for " |
| 263 | "switch capabilities.\n", mmc_hostname(card->host)); |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 264 | return -ENOMEM; |
Pierre Ossman | 1addfcd | 2007-05-01 14:46:08 +0200 | [diff] [blame] | 265 | } |
| 266 | |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 267 | err = mmc_sd_switch(card, 1, 0, 1, status); |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 268 | if (err) |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 269 | goto out; |
| 270 | |
| 271 | if ((status[16] & 0xF) != 1) { |
| 272 | printk(KERN_WARNING "%s: Problem switching card " |
| 273 | "into high-speed mode!\n", |
| 274 | mmc_hostname(card->host)); |
| 275 | } else { |
| 276 | mmc_card_set_highspeed(card); |
| 277 | mmc_set_timing(card->host, MMC_TIMING_SD_HS); |
| 278 | } |
| 279 | |
| 280 | out: |
| 281 | kfree(status); |
| 282 | |
| 283 | return err; |
| 284 | } |
| 285 | |
| 286 | /* |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 287 | * Handle the detection and initialisation of a card. |
| 288 | * |
| 289 | * In the case of a resume, "curcard" will contain the card |
| 290 | * we're trying to reinitialise. |
| 291 | */ |
| 292 | static int mmc_sd_init_card(struct mmc_host *host, u32 ocr, |
| 293 | struct mmc_card *oldcard) |
| 294 | { |
| 295 | struct mmc_card *card; |
| 296 | int err; |
| 297 | u32 cid[4]; |
| 298 | unsigned int max_dtr; |
| 299 | |
| 300 | BUG_ON(!host); |
Pierre Ossman | d84075c8 | 2007-08-09 13:23:56 +0200 | [diff] [blame] | 301 | WARN_ON(!host->claimed); |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 302 | |
| 303 | /* |
| 304 | * Since we're changing the OCR value, we seem to |
| 305 | * need to tell some cards to go back to the idle |
| 306 | * state. We wait 1ms to give cards time to |
| 307 | * respond. |
| 308 | */ |
| 309 | mmc_go_idle(host); |
| 310 | |
| 311 | /* |
| 312 | * If SD_SEND_IF_COND indicates an SD 2.0 |
| 313 | * compliant card and we should set bit 30 |
| 314 | * of the ocr to indicate that we can handle |
| 315 | * block-addressed SDHC cards. |
| 316 | */ |
| 317 | err = mmc_send_if_cond(host, ocr); |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 318 | if (!err) |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 319 | ocr |= 1 << 30; |
| 320 | |
| 321 | err = mmc_send_app_op_cond(host, ocr, NULL); |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 322 | if (err) |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 323 | goto err; |
| 324 | |
| 325 | /* |
David Brownell | af51715 | 2007-08-08 09:11:32 -0700 | [diff] [blame] | 326 | * For SPI, enable CRC as appropriate. |
| 327 | */ |
| 328 | if (mmc_host_is_spi(host)) { |
| 329 | err = mmc_spi_set_crc(host, use_spi_crc); |
| 330 | if (err) |
| 331 | goto err; |
| 332 | } |
| 333 | |
| 334 | /* |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 335 | * Fetch CID from card. |
| 336 | */ |
David Brownell | af51715 | 2007-08-08 09:11:32 -0700 | [diff] [blame] | 337 | if (mmc_host_is_spi(host)) |
| 338 | err = mmc_send_cid(host, cid); |
| 339 | else |
| 340 | err = mmc_all_send_cid(host, cid); |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 341 | if (err) |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 342 | goto err; |
| 343 | |
| 344 | if (oldcard) { |
Pierre Ossman | adf66a0 | 2007-07-22 23:08:30 +0200 | [diff] [blame] | 345 | if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) { |
| 346 | err = -ENOENT; |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 347 | goto err; |
Pierre Ossman | adf66a0 | 2007-07-22 23:08:30 +0200 | [diff] [blame] | 348 | } |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 349 | |
| 350 | card = oldcard; |
| 351 | } else { |
| 352 | /* |
| 353 | * Allocate card structure. |
| 354 | */ |
| 355 | card = mmc_alloc_card(host); |
Pierre Ossman | adf66a0 | 2007-07-22 23:08:30 +0200 | [diff] [blame] | 356 | if (IS_ERR(card)) { |
| 357 | err = PTR_ERR(card); |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 358 | goto err; |
Pierre Ossman | adf66a0 | 2007-07-22 23:08:30 +0200 | [diff] [blame] | 359 | } |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 360 | |
| 361 | card->type = MMC_TYPE_SD; |
| 362 | memcpy(card->raw_cid, cid, sizeof(card->raw_cid)); |
| 363 | } |
| 364 | |
| 365 | /* |
David Brownell | af51715 | 2007-08-08 09:11:32 -0700 | [diff] [blame] | 366 | * For native busses: get card RCA and quit open drain mode. |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 367 | */ |
David Brownell | af51715 | 2007-08-08 09:11:32 -0700 | [diff] [blame] | 368 | if (!mmc_host_is_spi(host)) { |
| 369 | err = mmc_send_relative_addr(host, &card->rca); |
| 370 | if (err) |
| 371 | goto free_card; |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 372 | |
David Brownell | af51715 | 2007-08-08 09:11:32 -0700 | [diff] [blame] | 373 | mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL); |
| 374 | } |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 375 | |
| 376 | if (!oldcard) { |
| 377 | /* |
| 378 | * Fetch CSD from card. |
| 379 | */ |
| 380 | err = mmc_send_csd(card, card->raw_csd); |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 381 | if (err) |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 382 | goto free_card; |
| 383 | |
Pierre Ossman | bd76631 | 2007-05-01 16:11:57 +0200 | [diff] [blame] | 384 | err = mmc_decode_csd(card); |
Pierre Ossman | adf66a0 | 2007-07-22 23:08:30 +0200 | [diff] [blame] | 385 | if (err) |
Pierre Ossman | bd76631 | 2007-05-01 16:11:57 +0200 | [diff] [blame] | 386 | goto free_card; |
| 387 | |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 388 | mmc_decode_cid(card); |
| 389 | } |
| 390 | |
| 391 | /* |
| 392 | * Select card, as all following commands rely on that. |
| 393 | */ |
David Brownell | af51715 | 2007-08-08 09:11:32 -0700 | [diff] [blame] | 394 | if (!mmc_host_is_spi(host)) { |
| 395 | err = mmc_select_card(card); |
| 396 | if (err) |
| 397 | goto free_card; |
| 398 | } |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 399 | |
| 400 | if (!oldcard) { |
| 401 | /* |
| 402 | * Fetch SCR from card. |
| 403 | */ |
| 404 | err = mmc_app_send_scr(card, card->raw_scr); |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 405 | if (err) |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 406 | goto free_card; |
| 407 | |
Pierre Ossman | bd76631 | 2007-05-01 16:11:57 +0200 | [diff] [blame] | 408 | err = mmc_decode_scr(card); |
| 409 | if (err < 0) |
| 410 | goto free_card; |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 411 | |
| 412 | /* |
| 413 | * Fetch switch information from card. |
| 414 | */ |
| 415 | err = mmc_read_switch(card); |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 416 | if (err) |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 417 | goto free_card; |
| 418 | } |
| 419 | |
| 420 | /* |
| 421 | * Attempt to change to high-speed (if supported) |
| 422 | */ |
| 423 | err = mmc_switch_hs(card); |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 424 | if (err) |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 425 | goto free_card; |
| 426 | |
| 427 | /* |
| 428 | * Compute bus speed. |
| 429 | */ |
| 430 | max_dtr = (unsigned int)-1; |
| 431 | |
| 432 | if (mmc_card_highspeed(card)) { |
| 433 | if (max_dtr > card->sw_caps.hs_max_dtr) |
| 434 | max_dtr = card->sw_caps.hs_max_dtr; |
| 435 | } else if (max_dtr > card->csd.max_dtr) { |
| 436 | max_dtr = card->csd.max_dtr; |
| 437 | } |
| 438 | |
| 439 | mmc_set_clock(host, max_dtr); |
| 440 | |
| 441 | /* |
| 442 | * Switch to wider bus (if supported). |
| 443 | */ |
Pierre Ossman | 7165129 | 2007-06-06 20:23:25 +0200 | [diff] [blame] | 444 | if ((host->caps & MMC_CAP_4_BIT_DATA) && |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 445 | (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) { |
| 446 | err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4); |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 447 | if (err) |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 448 | goto free_card; |
| 449 | |
| 450 | mmc_set_bus_width(host, MMC_BUS_WIDTH_4); |
| 451 | } |
| 452 | |
Pierre Ossman | c3bff2e | 2007-06-13 19:06:03 +0200 | [diff] [blame] | 453 | /* |
| 454 | * Check if read-only switch is active. |
| 455 | */ |
| 456 | if (!oldcard) { |
| 457 | if (!host->ops->get_ro) { |
| 458 | printk(KERN_WARNING "%s: host does not " |
| 459 | "support reading read-only " |
| 460 | "switch. assuming write-enable.\n", |
| 461 | mmc_hostname(host)); |
| 462 | } else { |
| 463 | if (host->ops->get_ro(host)) |
| 464 | mmc_card_set_readonly(card); |
| 465 | } |
| 466 | } |
| 467 | |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 468 | if (!oldcard) |
| 469 | host->card = card; |
| 470 | |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 471 | return 0; |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 472 | |
| 473 | free_card: |
| 474 | if (!oldcard) |
| 475 | mmc_remove_card(card); |
| 476 | err: |
| 477 | |
Pierre Ossman | adf66a0 | 2007-07-22 23:08:30 +0200 | [diff] [blame] | 478 | return err; |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 479 | } |
| 480 | |
| 481 | /* |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 482 | * Host is being removed. Free up the current card. |
| 483 | */ |
| 484 | static void mmc_sd_remove(struct mmc_host *host) |
| 485 | { |
| 486 | BUG_ON(!host); |
| 487 | BUG_ON(!host->card); |
| 488 | |
| 489 | mmc_remove_card(host->card); |
| 490 | host->card = NULL; |
| 491 | } |
| 492 | |
| 493 | /* |
| 494 | * Card detection callback from host. |
| 495 | */ |
| 496 | static void mmc_sd_detect(struct mmc_host *host) |
| 497 | { |
| 498 | int err; |
| 499 | |
| 500 | BUG_ON(!host); |
| 501 | BUG_ON(!host->card); |
| 502 | |
| 503 | mmc_claim_host(host); |
| 504 | |
| 505 | /* |
| 506 | * Just check if our card has been removed. |
| 507 | */ |
| 508 | err = mmc_send_status(host->card, NULL); |
| 509 | |
| 510 | mmc_release_host(host); |
| 511 | |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 512 | if (err) { |
Pierre Ossman | 4101c16 | 2007-05-19 13:39:01 +0200 | [diff] [blame] | 513 | mmc_sd_remove(host); |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 514 | |
| 515 | mmc_claim_host(host); |
| 516 | mmc_detach_bus(host); |
| 517 | mmc_release_host(host); |
| 518 | } |
| 519 | } |
| 520 | |
Pierre Ossman | 4101c16 | 2007-05-19 13:39:01 +0200 | [diff] [blame] | 521 | MMC_ATTR_FN(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1], |
| 522 | card->raw_cid[2], card->raw_cid[3]); |
| 523 | MMC_ATTR_FN(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1], |
| 524 | card->raw_csd[2], card->raw_csd[3]); |
| 525 | MMC_ATTR_FN(scr, "%08x%08x\n", card->raw_scr[0], card->raw_scr[1]); |
| 526 | MMC_ATTR_FN(date, "%02d/%04d\n", card->cid.month, card->cid.year); |
| 527 | MMC_ATTR_FN(fwrev, "0x%x\n", card->cid.fwrev); |
| 528 | MMC_ATTR_FN(hwrev, "0x%x\n", card->cid.hwrev); |
| 529 | MMC_ATTR_FN(manfid, "0x%06x\n", card->cid.manfid); |
| 530 | MMC_ATTR_FN(name, "%s\n", card->cid.prod_name); |
| 531 | MMC_ATTR_FN(oemid, "0x%04x\n", card->cid.oemid); |
| 532 | MMC_ATTR_FN(serial, "0x%08x\n", card->cid.serial); |
| 533 | |
| 534 | static struct device_attribute mmc_sd_dev_attrs[] = { |
| 535 | MMC_ATTR_RO(cid), |
| 536 | MMC_ATTR_RO(csd), |
| 537 | MMC_ATTR_RO(scr), |
| 538 | MMC_ATTR_RO(date), |
| 539 | MMC_ATTR_RO(fwrev), |
| 540 | MMC_ATTR_RO(hwrev), |
| 541 | MMC_ATTR_RO(manfid), |
| 542 | MMC_ATTR_RO(name), |
| 543 | MMC_ATTR_RO(oemid), |
| 544 | MMC_ATTR_RO(serial), |
| 545 | __ATTR_NULL, |
| 546 | }; |
| 547 | |
| 548 | /* |
| 549 | * Adds sysfs entries as relevant. |
| 550 | */ |
| 551 | static int mmc_sd_sysfs_add(struct mmc_host *host, struct mmc_card *card) |
| 552 | { |
| 553 | int ret; |
| 554 | |
| 555 | ret = mmc_add_attrs(card, mmc_sd_dev_attrs); |
| 556 | if (ret < 0) |
| 557 | return ret; |
| 558 | |
| 559 | return 0; |
| 560 | } |
| 561 | |
| 562 | /* |
| 563 | * Removes the sysfs entries added by mmc_sysfs_add(). |
| 564 | */ |
| 565 | static void mmc_sd_sysfs_remove(struct mmc_host *host, struct mmc_card *card) |
| 566 | { |
| 567 | mmc_remove_attrs(card, mmc_sd_dev_attrs); |
| 568 | } |
| 569 | |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 570 | #ifdef CONFIG_MMC_UNSAFE_RESUME |
| 571 | |
| 572 | /* |
| 573 | * Suspend callback from host. |
| 574 | */ |
| 575 | static void mmc_sd_suspend(struct mmc_host *host) |
| 576 | { |
| 577 | BUG_ON(!host); |
| 578 | BUG_ON(!host->card); |
| 579 | |
| 580 | mmc_claim_host(host); |
David Brownell | af51715 | 2007-08-08 09:11:32 -0700 | [diff] [blame] | 581 | if (!mmc_host_is_spi(host)) |
| 582 | mmc_deselect_cards(host); |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 583 | host->card->state &= ~MMC_STATE_HIGHSPEED; |
| 584 | mmc_release_host(host); |
| 585 | } |
| 586 | |
| 587 | /* |
| 588 | * Resume callback from host. |
| 589 | * |
| 590 | * This function tries to determine if the same card is still present |
| 591 | * and, if so, restore all state to it. |
| 592 | */ |
| 593 | static void mmc_sd_resume(struct mmc_host *host) |
| 594 | { |
| 595 | int err; |
| 596 | |
| 597 | BUG_ON(!host); |
| 598 | BUG_ON(!host->card); |
| 599 | |
| 600 | mmc_claim_host(host); |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 601 | err = mmc_sd_init_card(host, host->ocr, host->card); |
Pierre Ossman | 2986d0b | 2007-07-22 17:52:06 +0200 | [diff] [blame] | 602 | mmc_release_host(host); |
| 603 | |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 604 | if (err) { |
Pierre Ossman | 4101c16 | 2007-05-19 13:39:01 +0200 | [diff] [blame] | 605 | mmc_sd_remove(host); |
Pierre Ossman | 2986d0b | 2007-07-22 17:52:06 +0200 | [diff] [blame] | 606 | |
| 607 | mmc_claim_host(host); |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 608 | mmc_detach_bus(host); |
Pierre Ossman | 2986d0b | 2007-07-22 17:52:06 +0200 | [diff] [blame] | 609 | mmc_release_host(host); |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 610 | } |
| 611 | |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 612 | } |
| 613 | |
| 614 | #else |
| 615 | |
| 616 | #define mmc_sd_suspend NULL |
| 617 | #define mmc_sd_resume NULL |
| 618 | |
| 619 | #endif |
| 620 | |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 621 | static const struct mmc_bus_ops mmc_sd_ops = { |
| 622 | .remove = mmc_sd_remove, |
| 623 | .detect = mmc_sd_detect, |
Pierre Ossman | 4101c16 | 2007-05-19 13:39:01 +0200 | [diff] [blame] | 624 | .sysfs_add = mmc_sd_sysfs_add, |
| 625 | .sysfs_remove = mmc_sd_sysfs_remove, |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 626 | .suspend = mmc_sd_suspend, |
| 627 | .resume = mmc_sd_resume, |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 628 | }; |
| 629 | |
| 630 | /* |
| 631 | * Starting point for SD card init. |
| 632 | */ |
| 633 | int mmc_attach_sd(struct mmc_host *host, u32 ocr) |
| 634 | { |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 635 | int err; |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 636 | |
| 637 | BUG_ON(!host); |
Pierre Ossman | d84075c8 | 2007-08-09 13:23:56 +0200 | [diff] [blame] | 638 | WARN_ON(!host->claimed); |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 639 | |
| 640 | mmc_attach_bus(host, &mmc_sd_ops); |
| 641 | |
Philip Langdale | 55556da | 2007-03-16 19:39:00 -0700 | [diff] [blame] | 642 | /* |
David Brownell | af51715 | 2007-08-08 09:11:32 -0700 | [diff] [blame] | 643 | * We need to get OCR a different way for SPI. |
| 644 | */ |
| 645 | if (mmc_host_is_spi(host)) { |
| 646 | mmc_go_idle(host); |
| 647 | |
| 648 | err = mmc_spi_read_ocr(host, 0, &ocr); |
| 649 | if (err) |
| 650 | goto err; |
| 651 | } |
| 652 | |
| 653 | /* |
Philip Langdale | 55556da | 2007-03-16 19:39:00 -0700 | [diff] [blame] | 654 | * Sanity check the voltages that the card claims to |
| 655 | * support. |
| 656 | */ |
| 657 | if (ocr & 0x7F) { |
| 658 | printk(KERN_WARNING "%s: card claims to support voltages " |
| 659 | "below the defined range. These will be ignored.\n", |
| 660 | mmc_hostname(host)); |
| 661 | ocr &= ~0x7F; |
| 662 | } |
| 663 | |
| 664 | if (ocr & MMC_VDD_165_195) { |
| 665 | printk(KERN_WARNING "%s: SD card claims to support the " |
| 666 | "incompletely defined 'low voltage range'. This " |
| 667 | "will be ignored.\n", mmc_hostname(host)); |
| 668 | ocr &= ~MMC_VDD_165_195; |
| 669 | } |
| 670 | |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 671 | host->ocr = mmc_select_voltage(host, ocr); |
| 672 | |
| 673 | /* |
| 674 | * Can we support the voltage(s) of the card(s)? |
| 675 | */ |
Pierre Ossman | 109b5be | 2007-07-23 00:12:10 +0200 | [diff] [blame] | 676 | if (!host->ocr) { |
| 677 | err = -EINVAL; |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 678 | goto err; |
Pierre Ossman | 109b5be | 2007-07-23 00:12:10 +0200 | [diff] [blame] | 679 | } |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 680 | |
| 681 | /* |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 682 | * Detect and init the card. |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 683 | */ |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 684 | err = mmc_sd_init_card(host, host->ocr, NULL); |
Pierre Ossman | 17b0429 | 2007-07-22 22:18:46 +0200 | [diff] [blame] | 685 | if (err) |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 686 | goto err; |
| 687 | |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 688 | mmc_release_host(host); |
| 689 | |
Pierre Ossman | 4101c16 | 2007-05-19 13:39:01 +0200 | [diff] [blame] | 690 | err = mmc_add_card(host->card); |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 691 | if (err) |
Pierre Ossman | 2986d0b | 2007-07-22 17:52:06 +0200 | [diff] [blame] | 692 | goto remove_card; |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 693 | |
| 694 | return 0; |
| 695 | |
Pierre Ossman | 2986d0b | 2007-07-22 17:52:06 +0200 | [diff] [blame] | 696 | remove_card: |
Pierre Ossman | 6abaa0c | 2007-05-01 16:00:02 +0200 | [diff] [blame] | 697 | mmc_remove_card(host->card); |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 698 | host->card = NULL; |
Pierre Ossman | 2986d0b | 2007-07-22 17:52:06 +0200 | [diff] [blame] | 699 | mmc_claim_host(host); |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 700 | err: |
| 701 | mmc_detach_bus(host); |
| 702 | mmc_release_host(host); |
| 703 | |
Pierre Ossman | 109b5be | 2007-07-23 00:12:10 +0200 | [diff] [blame] | 704 | printk(KERN_ERR "%s: error %d whilst initialising SD card\n", |
| 705 | mmc_hostname(host), err); |
| 706 | |
Pierre Ossman | adf66a0 | 2007-07-22 23:08:30 +0200 | [diff] [blame] | 707 | return err; |
Pierre Ossman | 7ea239d | 2006-12-31 00:11:32 +0100 | [diff] [blame] | 708 | } |
| 709 | |