Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
sd.c
Go to the documentation of this file.
1 /*
2  * linux/drivers/mmc/core/sd.c
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 #include <linux/slab.h>
15 #include <linux/stat.h>
16 
17 #include <linux/mmc/host.h>
18 #include <linux/mmc/card.h>
19 #include <linux/mmc/mmc.h>
20 #include <linux/mmc/sd.h>
21 
22 #include "core.h"
23 #include "bus.h"
24 #include "mmc_ops.h"
25 #include "sd.h"
26 #include "sd_ops.h"
27 
28 static const unsigned int tran_exp[] = {
29  10000, 100000, 1000000, 10000000,
30  0, 0, 0, 0
31 };
32 
33 static const unsigned char tran_mant[] = {
34  0, 10, 12, 13, 15, 20, 25, 30,
35  35, 40, 45, 50, 55, 60, 70, 80,
36 };
37 
38 static const unsigned int tacc_exp[] = {
39  1, 10, 100, 1000, 10000, 100000, 1000000, 10000000,
40 };
41 
42 static const unsigned int tacc_mant[] = {
43  0, 10, 12, 13, 15, 20, 25, 30,
44  35, 40, 45, 50, 55, 60, 70, 80,
45 };
46 
47 #define UNSTUFF_BITS(resp,start,size) \
48  ({ \
49  const int __size = size; \
50  const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \
51  const int __off = 3 - ((start) / 32); \
52  const int __shft = (start) & 31; \
53  u32 __res; \
54  \
55  __res = resp[__off] >> __shft; \
56  if (__size + __shft > 32) \
57  __res |= resp[__off-1] << ((32 - __shft) % 32); \
58  __res & __mask; \
59  })
60 
61 /*
62  * Given the decoded CSD structure, decode the raw CID to our CID structure.
63  */
65 {
66  u32 *resp = card->raw_cid;
67 
68  memset(&card->cid, 0, sizeof(struct mmc_cid));
69 
70  /*
71  * SD doesn't currently have a version field so we will
72  * have to assume we can parse this.
73  */
74  card->cid.manfid = UNSTUFF_BITS(resp, 120, 8);
75  card->cid.oemid = UNSTUFF_BITS(resp, 104, 16);
76  card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8);
77  card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8);
78  card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8);
79  card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8);
80  card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8);
81  card->cid.hwrev = UNSTUFF_BITS(resp, 60, 4);
82  card->cid.fwrev = UNSTUFF_BITS(resp, 56, 4);
83  card->cid.serial = UNSTUFF_BITS(resp, 24, 32);
84  card->cid.year = UNSTUFF_BITS(resp, 12, 8);
85  card->cid.month = UNSTUFF_BITS(resp, 8, 4);
86 
87  card->cid.year += 2000; /* SD cards year offset */
88 }
89 
90 /*
91  * Given a 128-bit response, decode to our card CSD structure.
92  */
93 static int mmc_decode_csd(struct mmc_card *card)
94 {
95  struct mmc_csd *csd = &card->csd;
96  unsigned int e, m, csd_struct;
97  u32 *resp = card->raw_csd;
98 
99  csd_struct = UNSTUFF_BITS(resp, 126, 2);
100 
101  switch (csd_struct) {
102  case 0:
103  m = UNSTUFF_BITS(resp, 115, 4);
104  e = UNSTUFF_BITS(resp, 112, 3);
105  csd->tacc_ns = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
106  csd->tacc_clks = UNSTUFF_BITS(resp, 104, 8) * 100;
107 
108  m = UNSTUFF_BITS(resp, 99, 4);
109  e = UNSTUFF_BITS(resp, 96, 3);
110  csd->max_dtr = tran_exp[e] * tran_mant[m];
111  csd->cmdclass = UNSTUFF_BITS(resp, 84, 12);
112 
113  e = UNSTUFF_BITS(resp, 47, 3);
114  m = UNSTUFF_BITS(resp, 62, 12);
115  csd->capacity = (1 + m) << (e + 2);
116 
117  csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
118  csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
119  csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
120  csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
121  csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
122  csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
123  csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
124 
125  if (UNSTUFF_BITS(resp, 46, 1)) {
126  csd->erase_size = 1;
127  } else if (csd->write_blkbits >= 9) {
128  csd->erase_size = UNSTUFF_BITS(resp, 39, 7) + 1;
129  csd->erase_size <<= csd->write_blkbits - 9;
130  }
131  break;
132  case 1:
133  /*
134  * This is a block-addressed SDHC or SDXC card. Most
135  * interesting fields are unused and have fixed
136  * values. To avoid getting tripped by buggy cards,
137  * we assume those fixed values ourselves.
138  */
140 
141  csd->tacc_ns = 0; /* Unused */
142  csd->tacc_clks = 0; /* Unused */
143 
144  m = UNSTUFF_BITS(resp, 99, 4);
145  e = UNSTUFF_BITS(resp, 96, 3);
146  csd->max_dtr = tran_exp[e] * tran_mant[m];
147  csd->cmdclass = UNSTUFF_BITS(resp, 84, 12);
148  csd->c_size = UNSTUFF_BITS(resp, 48, 22);
149 
150  /* SDXC cards have a minimum C_SIZE of 0x00FFFF */
151  if (csd->c_size >= 0xFFFF)
153 
154  m = UNSTUFF_BITS(resp, 48, 22);
155  csd->capacity = (1 + m) << 10;
156 
157  csd->read_blkbits = 9;
158  csd->read_partial = 0;
159  csd->write_misalign = 0;
160  csd->read_misalign = 0;
161  csd->r2w_factor = 4; /* Unused */
162  csd->write_blkbits = 9;
163  csd->write_partial = 0;
164  csd->erase_size = 1;
165  break;
166  default:
167  pr_err("%s: unrecognised CSD structure version %d\n",
168  mmc_hostname(card->host), csd_struct);
169  return -EINVAL;
170  }
171 
172  card->erase_size = csd->erase_size;
173 
174  return 0;
175 }
176 
177 /*
178  * Given a 64-bit response, decode to our card SCR structure.
179  */
180 static int mmc_decode_scr(struct mmc_card *card)
181 {
182  struct sd_scr *scr = &card->scr;
183  unsigned int scr_struct;
184  u32 resp[4];
185 
186  resp[3] = card->raw_scr[1];
187  resp[2] = card->raw_scr[0];
188 
189  scr_struct = UNSTUFF_BITS(resp, 60, 4);
190  if (scr_struct != 0) {
191  pr_err("%s: unrecognised SCR structure version %d\n",
192  mmc_hostname(card->host), scr_struct);
193  return -EINVAL;
194  }
195 
196  scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4);
197  scr->bus_widths = UNSTUFF_BITS(resp, 48, 4);
198  if (scr->sda_vsn == SCR_SPEC_VER_2)
199  /* Check if Physical Layer Spec v3.0 is supported */
200  scr->sda_spec3 = UNSTUFF_BITS(resp, 47, 1);
201 
202  if (UNSTUFF_BITS(resp, 55, 1))
203  card->erased_byte = 0xFF;
204  else
205  card->erased_byte = 0x0;
206 
207  if (scr->sda_spec3)
208  scr->cmds = UNSTUFF_BITS(resp, 32, 2);
209  return 0;
210 }
211 
212 /*
213  * Fetch and process SD Status register.
214  */
215 static int mmc_read_ssr(struct mmc_card *card)
216 {
217  unsigned int au, es, et, eo;
218  int err, i;
219  u32 *ssr;
220 
221  if (!(card->csd.cmdclass & CCC_APP_SPEC)) {
222  pr_warning("%s: card lacks mandatory SD Status "
223  "function.\n", mmc_hostname(card->host));
224  return 0;
225  }
226 
227  ssr = kmalloc(64, GFP_KERNEL);
228  if (!ssr)
229  return -ENOMEM;
230 
231  err = mmc_app_sd_status(card, ssr);
232  if (err) {
233  pr_warning("%s: problem reading SD Status "
234  "register.\n", mmc_hostname(card->host));
235  err = 0;
236  goto out;
237  }
238 
239  for (i = 0; i < 16; i++)
240  ssr[i] = be32_to_cpu(ssr[i]);
241 
242  /*
243  * UNSTUFF_BITS only works with four u32s so we have to offset the
244  * bitfield positions accordingly.
245  */
246  au = UNSTUFF_BITS(ssr, 428 - 384, 4);
247  if (au > 0 && au <= 9) {
248  card->ssr.au = 1 << (au + 4);
249  es = UNSTUFF_BITS(ssr, 408 - 384, 16);
250  et = UNSTUFF_BITS(ssr, 402 - 384, 6);
251  eo = UNSTUFF_BITS(ssr, 400 - 384, 2);
252  if (es && et) {
253  card->ssr.erase_timeout = (et * 1000) / es;
254  card->ssr.erase_offset = eo * 1000;
255  }
256  } else {
257  pr_warning("%s: SD Status: Invalid Allocation Unit "
258  "size.\n", mmc_hostname(card->host));
259  }
260 out:
261  kfree(ssr);
262  return err;
263 }
264 
265 /*
266  * Fetches and decodes switch information
267  */
268 static int mmc_read_switch(struct mmc_card *card)
269 {
270  int err;
271  u8 *status;
272 
273  if (card->scr.sda_vsn < SCR_SPEC_VER_1)
274  return 0;
275 
276  if (!(card->csd.cmdclass & CCC_SWITCH)) {
277  pr_warning("%s: card lacks mandatory switch "
278  "function, performance might suffer.\n",
279  mmc_hostname(card->host));
280  return 0;
281  }
282 
283  err = -EIO;
284 
285  status = kmalloc(64, GFP_KERNEL);
286  if (!status) {
287  pr_err("%s: could not allocate a buffer for "
288  "switch capabilities.\n",
289  mmc_hostname(card->host));
290  return -ENOMEM;
291  }
292 
293  /*
294  * Find out the card's support bits with a mode 0 operation.
295  * The argument does not matter, as the support bits do not
296  * change with the arguments.
297  */
298  err = mmc_sd_switch(card, 0, 0, 0, status);
299  if (err) {
300  /*
301  * If the host or the card can't do the switch,
302  * fail more gracefully.
303  */
304  if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
305  goto out;
306 
307  pr_warning("%s: problem reading Bus Speed modes.\n",
308  mmc_hostname(card->host));
309  err = 0;
310 
311  goto out;
312  }
313 
314  if (status[13] & SD_MODE_HIGH_SPEED)
315  card->sw_caps.hs_max_dtr = HIGH_SPEED_MAX_DTR;
316 
317  if (card->scr.sda_spec3) {
318  card->sw_caps.sd3_bus_mode = status[13];
319  /* Driver Strengths supported by the card */
320  card->sw_caps.sd3_drv_type = status[9];
321  }
322 
323 out:
324  kfree(status);
325 
326  return err;
327 }
328 
329 /*
330  * Test if the card supports high-speed mode and, if so, switch to it.
331  */
332 int mmc_sd_switch_hs(struct mmc_card *card)
333 {
334  int err;
335  u8 *status;
336 
337  if (card->scr.sda_vsn < SCR_SPEC_VER_1)
338  return 0;
339 
340  if (!(card->csd.cmdclass & CCC_SWITCH))
341  return 0;
342 
343  if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
344  return 0;
345 
346  if (card->sw_caps.hs_max_dtr == 0)
347  return 0;
348 
349  err = -EIO;
350 
351  status = kmalloc(64, GFP_KERNEL);
352  if (!status) {
353  pr_err("%s: could not allocate a buffer for "
354  "switch capabilities.\n", mmc_hostname(card->host));
355  return -ENOMEM;
356  }
357 
358  err = mmc_sd_switch(card, 1, 0, 1, status);
359  if (err)
360  goto out;
361 
362  if ((status[16] & 0xF) != 1) {
363  pr_warning("%s: Problem switching card "
364  "into high-speed mode!\n",
365  mmc_hostname(card->host));
366  err = 0;
367  } else {
368  err = 1;
369  }
370 
371 out:
372  kfree(status);
373 
374  return err;
375 }
376 
377 static int sd_select_driver_type(struct mmc_card *card, u8 *status)
378 {
379  int host_drv_type = SD_DRIVER_TYPE_B;
380  int card_drv_type = SD_DRIVER_TYPE_B;
381  int drive_strength;
382  int err;
383 
384  /*
385  * If the host doesn't support any of the Driver Types A,C or D,
386  * or there is no board specific handler then default Driver
387  * Type B is used.
388  */
389  if (!(card->host->caps & (MMC_CAP_DRIVER_TYPE_A | MMC_CAP_DRIVER_TYPE_C
391  return 0;
392 
393  if (!card->host->ops->select_drive_strength)
394  return 0;
395 
396  if (card->host->caps & MMC_CAP_DRIVER_TYPE_A)
397  host_drv_type |= SD_DRIVER_TYPE_A;
398 
399  if (card->host->caps & MMC_CAP_DRIVER_TYPE_C)
400  host_drv_type |= SD_DRIVER_TYPE_C;
401 
402  if (card->host->caps & MMC_CAP_DRIVER_TYPE_D)
403  host_drv_type |= SD_DRIVER_TYPE_D;
404 
405  if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_A)
406  card_drv_type |= SD_DRIVER_TYPE_A;
407 
408  if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_C)
409  card_drv_type |= SD_DRIVER_TYPE_C;
410 
411  if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_D)
412  card_drv_type |= SD_DRIVER_TYPE_D;
413 
414  /*
415  * The drive strength that the hardware can support
416  * depends on the board design. Pass the appropriate
417  * information and let the hardware specific code
418  * return what is possible given the options
419  */
420  mmc_host_clk_hold(card->host);
421  drive_strength = card->host->ops->select_drive_strength(
422  card->sw_caps.uhs_max_dtr,
423  host_drv_type, card_drv_type);
424  mmc_host_clk_release(card->host);
425 
426  err = mmc_sd_switch(card, 1, 2, drive_strength, status);
427  if (err)
428  return err;
429 
430  if ((status[15] & 0xF) != drive_strength) {
431  pr_warning("%s: Problem setting drive strength!\n",
432  mmc_hostname(card->host));
433  return 0;
434  }
435 
436  mmc_set_driver_type(card->host, drive_strength);
437 
438  return 0;
439 }
440 
441 static void sd_update_bus_speed_mode(struct mmc_card *card)
442 {
443  /*
444  * If the host doesn't support any of the UHS-I modes, fallback on
445  * default speed.
446  */
447  if (!(card->host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
449  card->sd_bus_speed = 0;
450  return;
451  }
452 
453  if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
454  (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
456  } else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
457  (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
459  } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
460  MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
463  } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
465  (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
467  } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
469  MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
472  }
473 }
474 
475 static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
476 {
477  int err;
478  unsigned int timing = 0;
479 
480  switch (card->sd_bus_speed) {
482  timing = MMC_TIMING_UHS_SDR104;
483  card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
484  break;
485  case UHS_DDR50_BUS_SPEED:
486  timing = MMC_TIMING_UHS_DDR50;
487  card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
488  break;
489  case UHS_SDR50_BUS_SPEED:
490  timing = MMC_TIMING_UHS_SDR50;
491  card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
492  break;
493  case UHS_SDR25_BUS_SPEED:
494  timing = MMC_TIMING_UHS_SDR25;
495  card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
496  break;
497  case UHS_SDR12_BUS_SPEED:
498  timing = MMC_TIMING_UHS_SDR12;
499  card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
500  break;
501  default:
502  return 0;
503  }
504 
505  err = mmc_sd_switch(card, 1, 0, card->sd_bus_speed, status);
506  if (err)
507  return err;
508 
509  if ((status[16] & 0xF) != card->sd_bus_speed)
510  pr_warning("%s: Problem setting bus speed mode!\n",
511  mmc_hostname(card->host));
512  else {
513  mmc_set_timing(card->host, timing);
514  mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
515  }
516 
517  return 0;
518 }
519 
520 /* Get host's max current setting at its current voltage */
521 static u32 sd_get_host_max_current(struct mmc_host *host)
522 {
523  u32 voltage, max_current;
524 
525  voltage = 1 << host->ios.vdd;
526  switch (voltage) {
527  case MMC_VDD_165_195:
528  max_current = host->max_current_180;
529  break;
530  case MMC_VDD_29_30:
531  case MMC_VDD_30_31:
532  max_current = host->max_current_300;
533  break;
534  case MMC_VDD_32_33:
535  case MMC_VDD_33_34:
536  max_current = host->max_current_330;
537  break;
538  default:
539  max_current = 0;
540  }
541 
542  return max_current;
543 }
544 
545 static int sd_set_current_limit(struct mmc_card *card, u8 *status)
546 {
547  int current_limit = SD_SET_CURRENT_NO_CHANGE;
548  int err;
549  u32 max_current;
550 
551  /*
552  * Current limit switch is only defined for SDR50, SDR104, and DDR50
553  * bus speed modes. For other bus speed modes, we do not change the
554  * current limit.
555  */
556  if ((card->sd_bus_speed != UHS_SDR50_BUS_SPEED) &&
557  (card->sd_bus_speed != UHS_SDR104_BUS_SPEED) &&
559  return 0;
560 
561  /*
562  * Host has different current capabilities when operating at
563  * different voltages, so find out its max current first.
564  */
565  max_current = sd_get_host_max_current(card->host);
566 
567  /*
568  * We only check host's capability here, if we set a limit that is
569  * higher than the card's maximum current, the card will be using its
570  * maximum current, e.g. if the card's maximum current is 300ma, and
571  * when we set current limit to 200ma, the card will draw 200ma, and
572  * when we set current limit to 400/600/800ma, the card will draw its
573  * maximum 300ma from the host.
574  */
575  if (max_current >= 800)
576  current_limit = SD_SET_CURRENT_LIMIT_800;
577  else if (max_current >= 600)
578  current_limit = SD_SET_CURRENT_LIMIT_600;
579  else if (max_current >= 400)
580  current_limit = SD_SET_CURRENT_LIMIT_400;
581  else if (max_current >= 200)
582  current_limit = SD_SET_CURRENT_LIMIT_200;
583 
584  if (current_limit != SD_SET_CURRENT_NO_CHANGE) {
585  err = mmc_sd_switch(card, 1, 3, current_limit, status);
586  if (err)
587  return err;
588 
589  if (((status[15] >> 4) & 0x0F) != current_limit)
590  pr_warning("%s: Problem setting current limit!\n",
591  mmc_hostname(card->host));
592 
593  }
594 
595  return 0;
596 }
597 
598 /*
599  * UHS-I specific initialization procedure
600  */
601 static int mmc_sd_init_uhs_card(struct mmc_card *card)
602 {
603  int err;
604  u8 *status;
605 
606  if (!card->scr.sda_spec3)
607  return 0;
608 
609  if (!(card->csd.cmdclass & CCC_SWITCH))
610  return 0;
611 
612  status = kmalloc(64, GFP_KERNEL);
613  if (!status) {
614  pr_err("%s: could not allocate a buffer for "
615  "switch capabilities.\n", mmc_hostname(card->host));
616  return -ENOMEM;
617  }
618 
619  /* Set 4-bit bus width */
620  if ((card->host->caps & MMC_CAP_4_BIT_DATA) &&
621  (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
623  if (err)
624  goto out;
625 
627  }
628 
629  /*
630  * Select the bus speed mode depending on host
631  * and card capability.
632  */
633  sd_update_bus_speed_mode(card);
634 
635  /* Set the driver strength for the card */
636  err = sd_select_driver_type(card, status);
637  if (err)
638  goto out;
639 
640  /* Set current limit for the card */
641  err = sd_set_current_limit(card, status);
642  if (err)
643  goto out;
644 
645  /* Set bus speed mode of the card */
646  err = sd_set_bus_speed_mode(card, status);
647  if (err)
648  goto out;
649 
650  /* SPI mode doesn't define CMD19 */
651  if (!mmc_host_is_spi(card->host) && card->host->ops->execute_tuning) {
652  mmc_host_clk_hold(card->host);
653  err = card->host->ops->execute_tuning(card->host,
655  mmc_host_clk_release(card->host);
656  }
657 
658 out:
659  kfree(status);
660 
661  return err;
662 }
663 
664 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
665  card->raw_cid[2], card->raw_cid[3]);
666 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
667  card->raw_csd[2], card->raw_csd[3]);
668 MMC_DEV_ATTR(scr, "%08x%08x\n", card->raw_scr[0], card->raw_scr[1]);
669 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
670 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
671 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
672 MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
673 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
674 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
675 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
676 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
677 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
678 
679 
680 static struct attribute *sd_std_attrs[] = {
681  &dev_attr_cid.attr,
682  &dev_attr_csd.attr,
683  &dev_attr_scr.attr,
684  &dev_attr_date.attr,
685  &dev_attr_erase_size.attr,
686  &dev_attr_preferred_erase_size.attr,
687  &dev_attr_fwrev.attr,
688  &dev_attr_hwrev.attr,
689  &dev_attr_manfid.attr,
690  &dev_attr_name.attr,
691  &dev_attr_oemid.attr,
692  &dev_attr_serial.attr,
693  NULL,
694 };
695 
696 static struct attribute_group sd_std_attr_group = {
697  .attrs = sd_std_attrs,
698 };
699 
700 static const struct attribute_group *sd_attr_groups[] = {
701  &sd_std_attr_group,
702  NULL,
703 };
704 
706  .groups = sd_attr_groups,
707 };
708 
709 /*
710  * Fetch CID from card.
711  */
712 int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr)
713 {
714  int err;
715  u32 max_current;
716 
717  /*
718  * Since we're changing the OCR value, we seem to
719  * need to tell some cards to go back to the idle
720  * state. We wait 1ms to give cards time to
721  * respond.
722  */
723  mmc_go_idle(host);
724 
725  /*
726  * If SD_SEND_IF_COND indicates an SD 2.0
727  * compliant card and we should set bit 30
728  * of the ocr to indicate that we can handle
729  * block-addressed SDHC cards.
730  */
731  err = mmc_send_if_cond(host, ocr);
732  if (!err)
733  ocr |= SD_OCR_CCS;
734 
735  /*
736  * If the host supports one of UHS-I modes, request the card
737  * to switch to 1.8V signaling level.
738  */
739  if (host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
741  ocr |= SD_OCR_S18R;
742 
743  /*
744  * If the host can supply more than 150mA at current voltage,
745  * XPC should be set to 1.
746  */
747  max_current = sd_get_host_max_current(host);
748  if (max_current > 150)
749  ocr |= SD_OCR_XPC;
750 
751 try_again:
752  err = mmc_send_app_op_cond(host, ocr, rocr);
753  if (err)
754  return err;
755 
756  /*
757  * In case CCS and S18A in the response is set, start Signal Voltage
758  * Switch procedure. SPI mode doesn't support CMD11.
759  */
760  if (!mmc_host_is_spi(host) && rocr &&
761  ((*rocr & 0x41000000) == 0x41000000)) {
763  if (err) {
764  ocr &= ~SD_OCR_S18R;
765  goto try_again;
766  }
767  }
768 
769  if (mmc_host_is_spi(host))
770  err = mmc_send_cid(host, cid);
771  else
772  err = mmc_all_send_cid(host, cid);
773 
774  return err;
775 }
776 
777 int mmc_sd_get_csd(struct mmc_host *host, struct mmc_card *card)
778 {
779  int err;
780 
781  /*
782  * Fetch CSD from card.
783  */
784  err = mmc_send_csd(card, card->raw_csd);
785  if (err)
786  return err;
787 
788  err = mmc_decode_csd(card);
789  if (err)
790  return err;
791 
792  return 0;
793 }
794 
795 int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,
796  bool reinit)
797 {
798  int err;
799 
800  if (!reinit) {
801  /*
802  * Fetch SCR from card.
803  */
804  err = mmc_app_send_scr(card, card->raw_scr);
805  if (err)
806  return err;
807 
808  err = mmc_decode_scr(card);
809  if (err)
810  return err;
811 
812  /*
813  * Fetch and process SD Status register.
814  */
815  err = mmc_read_ssr(card);
816  if (err)
817  return err;
818 
819  /* Erase init depends on CSD and SSR */
820  mmc_init_erase(card);
821 
822  /*
823  * Fetch switch information from card.
824  */
825  err = mmc_read_switch(card);
826  if (err)
827  return err;
828  }
829 
830  /*
831  * For SPI, enable CRC as appropriate.
832  * This CRC enable is located AFTER the reading of the
833  * card registers because some SDHC cards are not able
834  * to provide valid CRCs for non-512-byte blocks.
835  */
836  if (mmc_host_is_spi(host)) {
837  err = mmc_spi_set_crc(host, use_spi_crc);
838  if (err)
839  return err;
840  }
841 
842  /*
843  * Check if read-only switch is active.
844  */
845  if (!reinit) {
846  int ro = -1;
847 
848  if (host->ops->get_ro) {
849  mmc_host_clk_hold(card->host);
850  ro = host->ops->get_ro(host);
851  mmc_host_clk_release(card->host);
852  }
853 
854  if (ro < 0) {
855  pr_warning("%s: host does not "
856  "support reading read-only "
857  "switch. assuming write-enable.\n",
858  mmc_hostname(host));
859  } else if (ro > 0) {
860  mmc_card_set_readonly(card);
861  }
862  }
863 
864  return 0;
865 }
866 
867 unsigned mmc_sd_get_max_clock(struct mmc_card *card)
868 {
869  unsigned max_dtr = (unsigned int)-1;
870 
871  if (mmc_card_highspeed(card)) {
872  if (max_dtr > card->sw_caps.hs_max_dtr)
873  max_dtr = card->sw_caps.hs_max_dtr;
874  } else if (max_dtr > card->csd.max_dtr) {
875  max_dtr = card->csd.max_dtr;
876  }
877 
878  return max_dtr;
879 }
880 
881 void mmc_sd_go_highspeed(struct mmc_card *card)
882 {
885 }
886 
887 /*
888  * Handle the detection and initialisation of a card.
889  *
890  * In the case of a resume, "oldcard" will contain the card
891  * we're trying to reinitialise.
892  */
893 static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
894  struct mmc_card *oldcard)
895 {
896  struct mmc_card *card;
897  int err;
898  u32 cid[4];
899  u32 rocr = 0;
900 
901  BUG_ON(!host);
902  WARN_ON(!host->claimed);
903 
904  err = mmc_sd_get_cid(host, ocr, cid, &rocr);
905  if (err)
906  return err;
907 
908  if (oldcard) {
909  if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0)
910  return -ENOENT;
911 
912  card = oldcard;
913  } else {
914  /*
915  * Allocate card structure.
916  */
917  card = mmc_alloc_card(host, &sd_type);
918  if (IS_ERR(card))
919  return PTR_ERR(card);
920 
921  card->type = MMC_TYPE_SD;
922  memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
923  }
924 
925  /*
926  * For native busses: get card RCA and quit open drain mode.
927  */
928  if (!mmc_host_is_spi(host)) {
929  err = mmc_send_relative_addr(host, &card->rca);
930  if (err)
931  return err;
932  }
933 
934  if (!oldcard) {
935  err = mmc_sd_get_csd(host, card);
936  if (err)
937  return err;
938 
939  mmc_decode_cid(card);
940  }
941 
942  /*
943  * Select card, as all following commands rely on that.
944  */
945  if (!mmc_host_is_spi(host)) {
946  err = mmc_select_card(card);
947  if (err)
948  return err;
949  }
950 
951  err = mmc_sd_setup_card(host, card, oldcard != NULL);
952  if (err)
953  goto free_card;
954 
955  /* Initialization sequence for UHS-I cards */
956  if (rocr & SD_ROCR_S18A) {
957  err = mmc_sd_init_uhs_card(card);
958  if (err)
959  goto free_card;
960 
961  /* Card is an ultra-high-speed card */
962  mmc_card_set_uhs(card);
963 
964  /*
965  * Since initialization is now complete, enable preset
966  * value registers for UHS-I cards.
967  */
968  if (host->ops->enable_preset_value) {
969  mmc_host_clk_hold(card->host);
970  host->ops->enable_preset_value(host, true);
971  mmc_host_clk_release(card->host);
972  }
973  } else {
974  /*
975  * Attempt to change to high-speed (if supported)
976  */
977  err = mmc_sd_switch_hs(card);
978  if (err > 0)
979  mmc_sd_go_highspeed(card);
980  else if (err)
981  goto free_card;
982 
983  /*
984  * Set bus speed.
985  */
986  mmc_set_clock(host, mmc_sd_get_max_clock(card));
987 
988  /*
989  * Switch to wider bus (if supported).
990  */
991  if ((host->caps & MMC_CAP_4_BIT_DATA) &&
992  (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
994  if (err)
995  goto free_card;
996 
998  }
999  }
1000 
1001  host->card = card;
1002  return 0;
1003 
1004 free_card:
1005  if (!oldcard)
1006  mmc_remove_card(card);
1007 
1008  return err;
1009 }
1010 
1011 /*
1012  * Host is being removed. Free up the current card.
1013  */
1014 static void mmc_sd_remove(struct mmc_host *host)
1015 {
1016  BUG_ON(!host);
1017  BUG_ON(!host->card);
1018 
1019  mmc_remove_card(host->card);
1020  host->card = NULL;
1021 }
1022 
1023 /*
1024  * Card detection - card is alive.
1025  */
1026 static int mmc_sd_alive(struct mmc_host *host)
1027 {
1028  return mmc_send_status(host->card, NULL);
1029 }
1030 
1031 /*
1032  * Card detection callback from host.
1033  */
1034 static void mmc_sd_detect(struct mmc_host *host)
1035 {
1036  int err;
1037 
1038  BUG_ON(!host);
1039  BUG_ON(!host->card);
1040 
1041  mmc_claim_host(host);
1042 
1043  /*
1044  * Just check if our card has been removed.
1045  */
1046  err = _mmc_detect_card_removed(host);
1047 
1048  mmc_release_host(host);
1049 
1050  if (err) {
1051  mmc_sd_remove(host);
1052 
1053  mmc_claim_host(host);
1054  mmc_detach_bus(host);
1055  mmc_power_off(host);
1056  mmc_release_host(host);
1057  }
1058 }
1059 
1060 /*
1061  * Suspend callback from host.
1062  */
1063 static int mmc_sd_suspend(struct mmc_host *host)
1064 {
1065  int err = 0;
1066 
1067  BUG_ON(!host);
1068  BUG_ON(!host->card);
1069 
1070  mmc_claim_host(host);
1071  if (!mmc_host_is_spi(host))
1072  err = mmc_deselect_cards(host);
1073  host->card->state &= ~MMC_STATE_HIGHSPEED;
1074  mmc_release_host(host);
1075 
1076  return err;
1077 }
1078 
1079 /*
1080  * Resume callback from host.
1081  *
1082  * This function tries to determine if the same card is still present
1083  * and, if so, restore all state to it.
1084  */
1085 static int mmc_sd_resume(struct mmc_host *host)
1086 {
1087  int err;
1088 
1089  BUG_ON(!host);
1090  BUG_ON(!host->card);
1091 
1092  mmc_claim_host(host);
1093  err = mmc_sd_init_card(host, host->ocr, host->card);
1094  mmc_release_host(host);
1095 
1096  return err;
1097 }
1098 
1099 static int mmc_sd_power_restore(struct mmc_host *host)
1100 {
1101  int ret;
1102 
1103  host->card->state &= ~MMC_STATE_HIGHSPEED;
1104  mmc_claim_host(host);
1105  ret = mmc_sd_init_card(host, host->ocr, host->card);
1106  mmc_release_host(host);
1107 
1108  return ret;
1109 }
1110 
1111 static const struct mmc_bus_ops mmc_sd_ops = {
1112  .remove = mmc_sd_remove,
1113  .detect = mmc_sd_detect,
1114  .suspend = NULL,
1115  .resume = NULL,
1116  .power_restore = mmc_sd_power_restore,
1117  .alive = mmc_sd_alive,
1118 };
1119 
1120 static const struct mmc_bus_ops mmc_sd_ops_unsafe = {
1121  .remove = mmc_sd_remove,
1122  .detect = mmc_sd_detect,
1123  .suspend = mmc_sd_suspend,
1124  .resume = mmc_sd_resume,
1125  .power_restore = mmc_sd_power_restore,
1126  .alive = mmc_sd_alive,
1127 };
1128 
1129 static void mmc_sd_attach_bus_ops(struct mmc_host *host)
1130 {
1131  const struct mmc_bus_ops *bus_ops;
1132 
1133  if (!mmc_card_is_removable(host))
1134  bus_ops = &mmc_sd_ops_unsafe;
1135  else
1136  bus_ops = &mmc_sd_ops;
1137  mmc_attach_bus(host, bus_ops);
1138 }
1139 
1140 /*
1141  * Starting point for SD card init.
1142  */
1143 int mmc_attach_sd(struct mmc_host *host)
1144 {
1145  int err;
1146  u32 ocr;
1147 
1148  BUG_ON(!host);
1149  WARN_ON(!host->claimed);
1150 
1151  /* Disable preset value enable if already set since last time */
1152  if (host->ops->enable_preset_value) {
1153  mmc_host_clk_hold(host);
1154  host->ops->enable_preset_value(host, false);
1155  mmc_host_clk_release(host);
1156  }
1157 
1158  err = mmc_send_app_op_cond(host, 0, &ocr);
1159  if (err)
1160  return err;
1161 
1162  mmc_sd_attach_bus_ops(host);
1163  if (host->ocr_avail_sd)
1164  host->ocr_avail = host->ocr_avail_sd;
1165 
1166  /*
1167  * We need to get OCR a different way for SPI.
1168  */
1169  if (mmc_host_is_spi(host)) {
1170  mmc_go_idle(host);
1171 
1172  err = mmc_spi_read_ocr(host, 0, &ocr);
1173  if (err)
1174  goto err;
1175  }
1176 
1177  /*
1178  * Sanity check the voltages that the card claims to
1179  * support.
1180  */
1181  if (ocr & 0x7F) {
1182  pr_warning("%s: card claims to support voltages "
1183  "below the defined range. These will be ignored.\n",
1184  mmc_hostname(host));
1185  ocr &= ~0x7F;
1186  }
1187 
1188  if ((ocr & MMC_VDD_165_195) &&
1189  !(host->ocr_avail_sd & MMC_VDD_165_195)) {
1190  pr_warning("%s: SD card claims to support the "
1191  "incompletely defined 'low voltage range'. This "
1192  "will be ignored.\n", mmc_hostname(host));
1193  ocr &= ~MMC_VDD_165_195;
1194  }
1195 
1196  host->ocr = mmc_select_voltage(host, ocr);
1197 
1198  /*
1199  * Can we support the voltage(s) of the card(s)?
1200  */
1201  if (!host->ocr) {
1202  err = -EINVAL;
1203  goto err;
1204  }
1205 
1206  /*
1207  * Detect and init the card.
1208  */
1209  err = mmc_sd_init_card(host, host->ocr, NULL);
1210  if (err)
1211  goto err;
1212 
1213  mmc_release_host(host);
1214  err = mmc_add_card(host->card);
1215  mmc_claim_host(host);
1216  if (err)
1217  goto remove_card;
1218 
1219  return 0;
1220 
1221 remove_card:
1222  mmc_release_host(host);
1223  mmc_remove_card(host->card);
1224  host->card = NULL;
1225  mmc_claim_host(host);
1226 err:
1227  mmc_detach_bus(host);
1228 
1229  pr_err("%s: error %d whilst initialising SD card\n",
1230  mmc_hostname(host), err);
1231 
1232  return err;
1233 }
1234