LCOV - code coverage report
Current view: top level - lkbce/drivers/mmc/core - mmc.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 43 389 11.1 %
Date: 2017-01-25 Functions: 3 22 13.6 %

          Line data    Source code
       1             : /*
       2             :  *  linux/drivers/mmc/core/mmc.c
       3             :  *
       4             :  *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
       5             :  *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
       6             :  *  MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
       7             :  *
       8             :  * This program is free software; you can redistribute it and/or modify
       9             :  * it under the terms of the GNU General Public License version 2 as
      10             :  * published by the Free Software Foundation.
      11             :  */
      12             : 
      13             : #include <linux/err.h>
      14             : 
      15             : #include <linux/mmc/host.h>
      16             : #include <linux/mmc/card.h>
      17             : #include <linux/mmc/mmc.h>
      18             : 
      19             : #include "core.h"
      20             : #include "bus.h"
      21             : #include "mmc_ops.h"
      22             : 
      23           1 : static const unsigned int tran_exp[] = {
      24             :         10000,          100000,         1000000,        10000000,
      25             :         0,              0,              0,              0
      26             : };
      27             : 
      28           1 : static const unsigned char tran_mant[] = {
      29             :         0,      10,     12,     13,     15,     20,     25,     30,
      30             :         35,     40,     45,     50,     55,     60,     70,     80,
      31             : };
      32             : 
      33           1 : static const unsigned int tacc_exp[] = {
      34             :         1,      10,     100,    1000,   10000,  100000, 1000000, 10000000,
      35             : };
      36             : 
      37           1 : static const unsigned int tacc_mant[] = {
      38             :         0,      10,     12,     13,     15,     20,     25,     30,
      39             :         35,     40,     45,     50,     55,     60,     70,     80,
      40             : };
      41             : 
      42             : #define UNSTUFF_BITS(resp,start,size)                                   \
      43             :         ({                                                              \
      44             :                 const int __size = size;                                \
      45             :                 const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1;        \
      46             :                 const int __off = 3 - ((start) / 32);                   \
      47             :                 const int __shft = (start) & 31;                    \
      48             :                 u32 __res;                                              \
      49             :                                                                         \
      50             :                 __res = resp[__off] >> __shft;                            \
      51             :                 if (__size + __shft > 32)                            \
      52             :                         __res |= resp[__off-1] << ((32 - __shft) % 32);   \
      53             :                 __res & __mask;                                             \
      54             :         })
      55             : 
      56             : /*
      57             :  * Given the decoded CSD structure, decode the raw CID to our CID structure.
      58             :  */
      59             : static int mmc_decode_cid(struct mmc_card *card)
      60             : {
      61           0 :         u32 *resp = card->raw_cid;
      62           0 : 
      63           0 :         /*
      64           0 :          * The selection of the format here is based upon published
      65           0 :          * specs from sandisk and from what people have reported.
      66           0 :          */
      67           0 :         switch (card->csd.mmca_vsn) {
      68           0 :         case 0: /* MMC v1.0 - v1.2 */
      69           0 :         case 1: /* MMC v1.4 */
      70           0 :                 card->cid.manfid     = UNSTUFF_BITS(resp, 104, 24);
      71           0 :                 card->cid.prod_name[0]       = UNSTUFF_BITS(resp, 96, 8);
      72           0 :                 card->cid.prod_name[1]       = UNSTUFF_BITS(resp, 88, 8);
      73           0 :                 card->cid.prod_name[2]       = UNSTUFF_BITS(resp, 80, 8);
      74           0 :                 card->cid.prod_name[3]       = UNSTUFF_BITS(resp, 72, 8);
      75           0 :                 card->cid.prod_name[4]       = UNSTUFF_BITS(resp, 64, 8);
      76           0 :                 card->cid.prod_name[5]       = UNSTUFF_BITS(resp, 56, 8);
      77           0 :                 card->cid.prod_name[6]       = UNSTUFF_BITS(resp, 48, 8);
      78           0 :                 card->cid.hwrev              = UNSTUFF_BITS(resp, 44, 4);
      79           0 :                 card->cid.fwrev              = UNSTUFF_BITS(resp, 40, 4);
      80           0 :                 card->cid.serial     = UNSTUFF_BITS(resp, 16, 24);
      81           0 :                 card->cid.month              = UNSTUFF_BITS(resp, 12, 4);
      82           0 :                 card->cid.year               = UNSTUFF_BITS(resp, 8, 4) + 1997;
      83           0 :                 break;
      84           0 : 
      85           0 :         case 2: /* MMC v2.0 - v2.2 */
      86           0 :         case 3: /* MMC v3.1 - v3.3 */
      87           0 :         case 4: /* MMC v4 */
      88           0 :                 card->cid.manfid     = UNSTUFF_BITS(resp, 120, 8);
      89           0 :                 card->cid.oemid              = UNSTUFF_BITS(resp, 104, 16);
      90           0 :                 card->cid.prod_name[0]       = UNSTUFF_BITS(resp, 96, 8);
      91           0 :                 card->cid.prod_name[1]       = UNSTUFF_BITS(resp, 88, 8);
      92           0 :                 card->cid.prod_name[2]       = UNSTUFF_BITS(resp, 80, 8);
      93           0 :                 card->cid.prod_name[3]       = UNSTUFF_BITS(resp, 72, 8);
      94           0 :                 card->cid.prod_name[4]       = UNSTUFF_BITS(resp, 64, 8);
      95           0 :                 card->cid.prod_name[5]       = UNSTUFF_BITS(resp, 56, 8);
      96           0 :                 card->cid.serial     = UNSTUFF_BITS(resp, 16, 32);
      97           0 :                 card->cid.month              = UNSTUFF_BITS(resp, 12, 4);
      98           0 :                 card->cid.year               = UNSTUFF_BITS(resp, 8, 4) + 1997;
      99           0 :                 break;
     100           0 : 
     101           0 :         default:
     102           0 :                 printk(KERN_ERR "%s: card has unknown MMCA version %d\n",
     103           0 :                         mmc_hostname(card->host), card->csd.mmca_vsn);
     104           0 :                 return -EINVAL;
     105           0 :         }
     106           0 : 
     107           0 :         return 0;
     108           0 : }
     109           0 : 
     110           0 : /*
     111           0 :  * Given a 128-bit response, decode to our card CSD structure.
     112           0 :  */
     113           0 : static int mmc_decode_csd(struct mmc_card *card)
     114           0 : {
     115           0 :         struct mmc_csd *csd = &card->csd;
     116           0 :         unsigned int e, m, csd_struct;
     117           0 :         u32 *resp = card->raw_csd;
     118           0 : 
     119           0 :         /*
     120           0 :          * We only understand CSD structure v1.1 and v1.2.
     121           0 :          * v1.2 has extra information in bits 15, 11 and 10.
     122           0 :          */
     123           0 :         csd_struct = UNSTUFF_BITS(resp, 126, 2);
     124           0 :         if (csd_struct != 1 && csd_struct != 2) {
     125           0 :                 printk(KERN_ERR "%s: unrecognised CSD structure version %d\n",
     126           0 :                         mmc_hostname(card->host), csd_struct);
     127           0 :                 return -EINVAL;
     128           0 :         }
     129           0 : 
     130           0 :         csd->mmca_vsn         = UNSTUFF_BITS(resp, 122, 4);
     131           0 :         m = UNSTUFF_BITS(resp, 115, 4);
     132           0 :         e = UNSTUFF_BITS(resp, 112, 3);
     133           0 :         csd->tacc_ns  = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
     134           0 :         csd->tacc_clks        = UNSTUFF_BITS(resp, 104, 8) * 100;
     135           0 : 
     136           0 :         m = UNSTUFF_BITS(resp, 99, 4);
     137           0 :         e = UNSTUFF_BITS(resp, 96, 3);
     138           0 :         csd->max_dtr   = tran_exp[e] * tran_mant[m];
     139           0 :         csd->cmdclass          = UNSTUFF_BITS(resp, 84, 12);
     140           0 : 
     141           0 :         e = UNSTUFF_BITS(resp, 47, 3);
     142           0 :         m = UNSTUFF_BITS(resp, 62, 12);
     143           0 :         csd->capacity          = (1 + m) << (e + 2);
     144           0 : 
     145           0 :         csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
     146           0 :         csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
     147           0 :         csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
     148           0 :         csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
     149           0 :         csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
     150           0 :         csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
     151           0 :         csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
     152           0 : 
     153           0 :         return 0;
     154           0 : }
     155           0 : 
     156           0 : /*
     157           0 :  * Read and decode extended CSD.
     158           0 :  */
     159           0 : static int mmc_read_ext_csd(struct mmc_card *card)
     160           0 : {
     161           0 :         int err;
     162           0 :         u8 *ext_csd;
     163           0 : 
     164           0 :         BUG_ON(!card);
     165           0 : 
     166           0 :         if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
     167           0 :                 return 0;
     168           0 : 
     169           0 :         /*
     170           0 :          * As the ext_csd is so large and mostly unused, we don't store the
     171           0 :          * raw block in mmc_card.
     172           0 :          */
     173           0 :         ext_csd = kmalloc(512, GFP_KERNEL);
     174           0 :         if (!ext_csd) {
     175           0 :                 printk(KERN_ERR "%s: could not allocate a buffer to "
     176           0 :                         "receive the ext_csd.\n", mmc_hostname(card->host));
     177           0 :                 return -ENOMEM;
     178           0 :         }
     179           0 : 
     180           0 :         err = mmc_send_ext_csd(card, ext_csd);
     181           0 :         if (err) {
     182           0 :                 /* If the host or the card can't do the switch,
     183           0 :                  * fail more gracefully. */
     184           0 :                 if ((err != -EINVAL)
     185           0 :                  && (err != -ENOSYS)
     186           0 :                  && (err != -EFAULT))
     187           0 :                         goto out;
     188           0 : 
     189           0 :                 /*
     190           0 :                  * High capacity cards should have this "magic" size
     191           0 :                  * stored in their CSD.
     192           0 :                  */
     193           0 :                 if (card->csd.capacity == (4096 * 512)) {
     194           0 :                         printk(KERN_ERR "%s: unable to read EXT_CSD "
     195           0 :                                 "on a possible high capacity card. "
     196           0 :                                 "Card will be ignored.\n",
     197           0 :                                 mmc_hostname(card->host));
     198           0 :                 } else {
     199           0 :                         printk(KERN_WARNING "%s: unable to read "
     200           0 :                                 "EXT_CSD, performance might "
     201           0 :                                 "suffer.\n",
     202           0 :                                 mmc_hostname(card->host));
     203           0 :                         err = 0;
     204           0 :                 }
     205           0 : 
     206           0 :                 goto out;
     207             :         }
     208             : 
     209           0 :         card->ext_csd.rev = ext_csd[EXT_CSD_REV];
     210           0 :         if (card->ext_csd.rev > 5) {
     211           0 :                 printk(KERN_ERR "%s: unrecognised EXT_CSD structure "
     212             :                         "version %d\n", mmc_hostname(card->host),
     213             :                         card->ext_csd.rev);
     214           0 :                 err = -EINVAL;
     215           0 :                 goto out;
     216             :         }
     217             : 
     218           0 :         if (card->ext_csd.rev >= 2) {
     219           0 :                 card->ext_csd.sectors =
     220             :                         ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
     221             :                         ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
     222             :                         ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
     223             :                         ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
     224           0 :                 if (card->ext_csd.sectors)
     225           0 :                         mmc_card_set_blockaddr(card);
     226             :         }
     227             : 
     228             :         switch (ext_csd[EXT_CSD_CARD_TYPE]) {
     229           0 :         case EXT_CSD_CARD_TYPE_52 | EXT_CSD_CARD_TYPE_26:
     230           0 :                 card->ext_csd.hs_max_dtr = 52000000;
     231           0 :                 break;
     232           0 :         case EXT_CSD_CARD_TYPE_26:
     233           0 :                 card->ext_csd.hs_max_dtr = 26000000;
     234           0 :                 break;
     235           0 :         default:
     236           0 :                 /* MMC v4 spec says this cannot happen */
     237           0 :                 printk(KERN_WARNING "%s: card is mmc v4 but doesn't "
     238             :                         "support any high-speed modes.\n",
     239             :                         mmc_hostname(card->host));
     240           0 :                 goto out;
     241             :         }
     242             : 
     243           0 :         if (card->ext_csd.rev >= 3) {
     244           0 :                 u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
     245             : 
     246             :                 /* Sleep / awake timeout in 100ns units */
     247           0 :                 if (sa_shift > 0 && sa_shift <= 0x17)
     248           0 :                         card->ext_csd.sa_timeout =
     249             :                                         1 << ext_csd[EXT_CSD_S_A_TIMEOUT];
     250             :         }
     251             : 
     252             : out:
     253           0 :         kfree(ext_csd);
     254             : 
     255           0 :         return err;
     256             : }
     257             : 
     258           0 : MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
     259           1 :         card->raw_cid[2], card->raw_cid[3]);
     260           0 : MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
     261           1 :         card->raw_csd[2], card->raw_csd[3]);
     262           1 : MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
     263           1 : MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
     264           1 : MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
     265           1 : MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
     266           1 : MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
     267           1 : MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
     268           1 : MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
     269           0 : 
     270           1 : static struct attribute *mmc_std_attrs[] = {
     271           0 :         &dev_attr_cid.attr,
     272           0 :         &dev_attr_csd.attr,
     273           0 :         &dev_attr_date.attr,
     274             :         &dev_attr_fwrev.attr,
     275             :         &dev_attr_hwrev.attr,
     276             :         &dev_attr_manfid.attr,
     277             :         &dev_attr_name.attr,
     278             :         &dev_attr_oemid.attr,
     279             :         &dev_attr_serial.attr,
     280             :         NULL,
     281             : };
     282             : 
     283           1 : static struct attribute_group mmc_std_attr_group = {
     284             :         .attrs = mmc_std_attrs,
     285             : };
     286             : 
     287           1 : static const struct attribute_group *mmc_attr_groups[] = {
     288             :         &mmc_std_attr_group,
     289             :         NULL,
     290             : };
     291             : 
     292           1 : static struct device_type mmc_type = {
     293             :         .groups = mmc_attr_groups,
     294             : };
     295             : 
     296             : /*
     297             :  * Handle the detection and initialisation of a card.
     298             :  *
     299             :  * In the case of a resume, "oldcard" will contain the card
     300             :  * we're trying to reinitialise.
     301             :  */
     302             : static int mmc_init_card(struct mmc_host *host, u32 ocr,
     303             :         struct mmc_card *oldcard)
     304           0 : {
     305           0 :         struct mmc_card *card;
     306           0 :         int err;
     307           0 :         u32 cid[4];
     308           0 :         unsigned int max_dtr;
     309           0 : 
     310           0 :         BUG_ON(!host);
     311           0 :         WARN_ON(!host->claimed);
     312           0 : 
     313           0 :         /*
     314           0 :          * Since we're changing the OCR value, we seem to
     315           0 :          * need to tell some cards to go back to the idle
     316           0 :          * state.  We wait 1ms to give cards time to
     317           0 :          * respond.
     318             :          */
     319           0 :         mmc_go_idle(host);
     320             : 
     321             :         /* The extra bit indicates that we support high capacity */
     322           0 :         err = mmc_send_op_cond(host, ocr | (1 << 30), NULL);
     323           0 :         if (err)
     324           0 :                 goto err;
     325             : 
     326             :         /*
     327             :          * For SPI, enable CRC as appropriate.
     328             :          */
     329           0 :         if (mmc_host_is_spi(host)) {
     330           0 :                 err = mmc_spi_set_crc(host, use_spi_crc);
     331           0 :                 if (err)
     332           0 :                         goto err;
     333             :         }
     334             : 
     335             :         /*
     336             :          * Fetch CID from card.
     337             :          */
     338           0 :         if (mmc_host_is_spi(host))
     339           0 :                 err = mmc_send_cid(host, cid);
     340             :         else
     341           0 :                 err = mmc_all_send_cid(host, cid);
     342           0 :         if (err)
     343           0 :                 goto err;
     344             : 
     345           0 :         if (oldcard) {
     346           0 :                 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
     347           0 :                         err = -ENOENT;
     348           0 :                         goto err;
     349             :                 }
     350             : 
     351           0 :                 card = oldcard;
     352             :         } else {
     353             :                 /*
     354             :                  * Allocate card structure.
     355             :                  */
     356           0 :                 card = mmc_alloc_card(host, &mmc_type);
     357           0 :                 if (IS_ERR(card)) {
     358           0 :                         err = PTR_ERR(card);
     359           0 :                         goto err;
     360             :                 }
     361             : 
     362           0 :                 card->type = MMC_TYPE_MMC;
     363           0 :                 card->rca = 1;
     364           0 :                 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
     365             :         }
     366             : 
     367             :         /*
     368             :          * For native busses:  set card RCA and quit open drain mode.
     369             :          */
     370           0 :         if (!mmc_host_is_spi(host)) {
     371           0 :                 err = mmc_set_relative_addr(card);
     372           0 :                 if (err)
     373           0 :                         goto free_card;
     374             : 
     375           0 :                 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
     376             :         }
     377             : 
     378           0 :         if (!oldcard) {
     379             :                 /*
     380             :                  * Fetch CSD from card.
     381             :                  */
     382           0 :                 err = mmc_send_csd(card, card->raw_csd);
     383           0 :                 if (err)
     384           0 :                         goto free_card;
     385             : 
     386           0 :                 err = mmc_decode_csd(card);
     387           0 :                 if (err)
     388           0 :                         goto free_card;
     389           0 :                 err = mmc_decode_cid(card);
     390           0 :                 if (err)
     391           0 :                         goto free_card;
     392             :         }
     393             : 
     394             :         /*
     395             :          * Select card, as all following commands rely on that.
     396             :          */
     397           0 :         if (!mmc_host_is_spi(host)) {
     398           0 :                 err = mmc_select_card(card);
     399           0 :                 if (err)
     400           0 :                         goto free_card;
     401             :         }
     402             : 
     403           0 :         if (!oldcard) {
     404             :                 /*
     405             :                  * Fetch and process extended CSD.
     406             :                  */
     407           0 :                 err = mmc_read_ext_csd(card);
     408           0 :                 if (err)
     409           0 :                         goto free_card;
     410             :         }
     411             : 
     412             :         /*
     413             :          * Activate high speed (if supported)
     414             :          */
     415           0 :         if ((card->ext_csd.hs_max_dtr != 0) &&
     416             :                 (host->caps & MMC_CAP_MMC_HIGHSPEED)) {
     417           0 :                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
     418             :                         EXT_CSD_HS_TIMING, 1);
     419           0 :                 if (err && err != -EBADMSG)
     420           0 :                         goto free_card;
     421             : 
     422           0 :                 if (err) {
     423           0 :                         printk(KERN_WARNING "%s: switch to highspeed failed\n",
     424             :                                mmc_hostname(card->host));
     425           0 :                         err = 0;
     426             :                 } else {
     427           0 :                         mmc_card_set_highspeed(card);
     428           0 :                         mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
     429             :                 }
     430             :         }
     431             : 
     432             :         /*
     433             :          * Compute bus speed.
     434             :          */
     435           0 :         max_dtr = (unsigned int)-1;
     436             : 
     437           0 :         if (mmc_card_highspeed(card)) {
     438           0 :                 if (max_dtr > card->ext_csd.hs_max_dtr)
     439           0 :                         max_dtr = card->ext_csd.hs_max_dtr;
     440           0 :         } else if (max_dtr > card->csd.max_dtr) {
     441           0 :                 max_dtr = card->csd.max_dtr;
     442             :         }
     443             : 
     444           0 :         mmc_set_clock(host, max_dtr);
     445             : 
     446             :         /*
     447             :          * Activate wide bus (if supported).
     448             :          */
     449           0 :         if ((card->csd.mmca_vsn >= CSD_SPEC_VER_4) &&
     450             :             (host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA))) {
     451             :                 unsigned ext_csd_bit, bus_width;
     452             : 
     453           0 :                 if (host->caps & MMC_CAP_8_BIT_DATA) {
     454           0 :                         ext_csd_bit = EXT_CSD_BUS_WIDTH_8;
     455           0 :                         bus_width = MMC_BUS_WIDTH_8;
     456             :                 } else {
     457           0 :                         ext_csd_bit = EXT_CSD_BUS_WIDTH_4;
     458           0 :                         bus_width = MMC_BUS_WIDTH_4;
     459             :                 }
     460             : 
     461           0 :                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
     462             :                                  EXT_CSD_BUS_WIDTH, ext_csd_bit);
     463             : 
     464           0 :                 if (err && err != -EBADMSG)
     465           0 :                         goto free_card;
     466             : 
     467           0 :                 if (err) {
     468           0 :                         printk(KERN_WARNING "%s: switch to bus width %d "
     469             :                                "failed\n", mmc_hostname(card->host),
     470             :                                1 << bus_width);
     471           0 :                         err = 0;
     472             :                 } else {
     473           0 :                         mmc_set_bus_width(card->host, bus_width);
     474             :                 }
     475             :         }
     476             : 
     477           0 :         if (!oldcard)
     478           0 :                 host->card = card;
     479             : 
     480           0 :         return 0;
     481           0 : 
     482             : free_card:
     483           0 :         if (!oldcard)
     484           0 :                 mmc_remove_card(card);
     485             : err:
     486             : 
     487           0 :         return err;
     488             : }
     489           0 : 
     490             : /*
     491             :  * Host is being removed. Free up the current card.
     492             :  */
     493             : static void mmc_remove(struct mmc_host *host)
     494             : {
     495           0 :         BUG_ON(!host);
     496           0 :         BUG_ON(!host->card);
     497             : 
     498           0 :         mmc_remove_card(host->card);
     499           0 :         host->card = NULL;
     500           0 : }
     501             : 
     502             : /*
     503             :  * Card detection callback from host.
     504             :  */
     505             : static void mmc_detect(struct mmc_host *host)
     506             : {
     507           0 :         int err;
     508           0 : 
     509           0 :         BUG_ON(!host);
     510           0 :         BUG_ON(!host->card);
     511             : 
     512           0 :         mmc_claim_host(host);
     513             : 
     514             :         /*
     515             :          * Just check if our card has been removed.
     516             :          */
     517           0 :         err = mmc_send_status(host->card, NULL);
     518             : 
     519           0 :         mmc_release_host(host);
     520             : 
     521           0 :         if (err) {
     522           0 :                 mmc_remove(host);
     523             : 
     524           0 :                 mmc_claim_host(host);
     525           0 :                 mmc_detach_bus(host);
     526           0 :                 mmc_release_host(host);
     527             :         }
     528           0 : }
     529             : 
     530             : /*
     531             :  * Suspend callback from host.
     532             :  */
     533             : static int mmc_suspend(struct mmc_host *host)
     534             : {
     535           7 :         BUG_ON(!host);
     536           8 :         BUG_ON(!host->card);
     537             : 
     538           2 :         mmc_claim_host(host);
     539           2 :         if (!mmc_host_is_spi(host))
     540           2 :                 mmc_deselect_cards(host);
     541           2 :         host->card->state &= ~MMC_STATE_HIGHSPEED;
     542           4 :         mmc_release_host(host);
     543             : 
     544           1 :         return 0;
     545             : }
     546             : 
     547             : /*
     548             :  * Resume callback from host.
     549             :  *
     550             :  * This function tries to determine if the same card is still present
     551             :  * and, if so, restore all state to it.
     552             :  */
     553             : static int mmc_resume(struct mmc_host *host)
     554             : {
     555           0 :         int err;
     556           0 : 
     557           0 :         BUG_ON(!host);
     558           0 :         BUG_ON(!host->card);
     559             : 
     560           0 :         mmc_claim_host(host);
     561           0 :         err = mmc_init_card(host, host->ocr, host->card);
     562           0 :         mmc_release_host(host);
     563             : 
     564           0 :         return err;
     565             : }
     566             : 
     567             : static void mmc_power_restore(struct mmc_host *host)
     568             : {
     569           0 :         host->card->state &= ~MMC_STATE_HIGHSPEED;
     570           0 :         mmc_claim_host(host);
     571           0 :         mmc_init_card(host, host->ocr, host->card);
     572           0 :         mmc_release_host(host);
     573           0 : }
     574             : 
     575             : static int mmc_sleep(struct mmc_host *host)
     576             : {
     577           4 :         struct mmc_card *card = host->card;
     578           4 :         int err = -ENOSYS;
     579           2 : 
     580           8 :         if (card && card->ext_csd.rev >= 3) {
     581           8 :                 err = mmc_card_sleepawake(host, 1);
     582           4 :                 if (err < 0)
     583           6 :                         pr_debug("%s: Error %d while putting card into sleep",
     584             :                                  mmc_hostname(host), err);
     585             :         }
     586             : 
     587           6 :         return err;
     588             : }
     589             : 
     590             : static int mmc_awake(struct mmc_host *host)
     591             : {
     592           4 :         struct mmc_card *card = host->card;
     593           4 :         int err = -ENOSYS;
     594           2 : 
     595           8 :         if (card && card->ext_csd.rev >= 3) {
     596           8 :                 err = mmc_card_sleepawake(host, 0);
     597           4 :                 if (err < 0)
     598           6 :                         pr_debug("%s: Error %d while awaking sleeping card",
     599             :                                  mmc_hostname(host), err);
     600             :         }
     601             : 
     602           6 :         return err;
     603             : }
     604             : 
     605           1 : static const struct mmc_bus_ops mmc_ops = {
     606             :         .awake = mmc_awake,
     607             :         .sleep = mmc_sleep,
     608             :         .remove = mmc_remove,
     609             :         .detect = mmc_detect,
     610             :         .suspend = NULL,
     611             :         .resume = NULL,
     612             :         .power_restore = mmc_power_restore,
     613             : };
     614             : 
     615           1 : static const struct mmc_bus_ops mmc_ops_unsafe = {
     616             :         .awake = mmc_awake,
     617             :         .sleep = mmc_sleep,
     618             :         .remove = mmc_remove,
     619             :         .detect = mmc_detect,
     620             :         .suspend = mmc_suspend,
     621             :         .resume = mmc_resume,
     622             :         .power_restore = mmc_power_restore,
     623             : };
     624             : 
     625             : static void mmc_attach_bus_ops(struct mmc_host *host)
     626             : {
     627           0 :         const struct mmc_bus_ops *bus_ops;
     628             : 
     629           0 :         if (host->caps & MMC_CAP_NONREMOVABLE || !mmc_assume_removable)
     630           0 :                 bus_ops = &mmc_ops_unsafe;
     631             :         else
     632           0 :                 bus_ops = &mmc_ops;
     633           0 :         mmc_attach_bus(host, bus_ops);
     634           0 : }
     635             : 
     636             : /*
     637             :  * Starting point for MMC card init.
     638             :  */
     639             : int mmc_attach_mmc(struct mmc_host *host, u32 ocr)
     640             : {
     641           0 :         int err;
     642           0 : 
     643           0 :         BUG_ON(!host);
     644           0 :         WARN_ON(!host->claimed);
     645           0 : 
     646           0 :         mmc_attach_bus_ops(host);
     647             : 
     648             :         /*
     649             :          * We need to get OCR a different way for SPI.
     650             :          */
     651           0 :         if (mmc_host_is_spi(host)) {
     652           0 :                 err = mmc_spi_read_ocr(host, 1, &ocr);
     653           0 :                 if (err)
     654           0 :                         goto err;
     655             :         }
     656             : 
     657             :         /*
     658             :          * Sanity check the voltages that the card claims to
     659             :          * support.
     660             :          */
     661           0 :         if (ocr & 0x7F) {
     662           0 :                 printk(KERN_WARNING "%s: card claims to support voltages "
     663             :                        "below the defined range. These will be ignored.\n",
     664             :                        mmc_hostname(host));
     665           0 :                 ocr &= ~0x7F;
     666             :         }
     667             : 
     668           0 :         host->ocr = mmc_select_voltage(host, ocr);
     669             : 
     670             :         /*
     671             :          * Can we support the voltage of the card?
     672             :          */
     673           0 :         if (!host->ocr) {
     674           0 :                 err = -EINVAL;
     675           0 :                 goto err;
     676             :         }
     677             : 
     678             :         /*
     679             :          * Detect and init the card.
     680             :          */
     681           0 :         err = mmc_init_card(host, host->ocr, NULL);
     682           0 :         if (err)
     683           0 :                 goto err;
     684             : 
     685           0 :         mmc_release_host(host);
     686             : 
     687           0 :         err = mmc_add_card(host->card);
     688           0 :         if (err)
     689           0 :                 goto remove_card;
     690             : 
     691           0 :         return 0;
     692           0 : 
     693             : remove_card:
     694           0 :         mmc_remove_card(host->card);
     695           0 :         host->card = NULL;
     696           0 :         mmc_claim_host(host);
     697             : err:
     698           0 :         mmc_detach_bus(host);
     699           0 :         mmc_release_host(host);
     700             : 
     701           0 :         printk(KERN_ERR "%s: error %d whilst initialising MMC card\n",
     702             :                 mmc_hostname(host), err);
     703             : 
     704           0 :         return err;
     705             : }

Generated by: LCOV version 1.10