drivers/mmc/core/mmc_ops.c

   1 /*
   2  *  linux/drivers/mmc/core/mmc_ops.h
   3  *
   4  *  Copyright 2006-2007 Pierre Ossman
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or (at
   9  * your option) any later version.
  10  */
  11
  12 #include <linux/types.h>
  13 #if 1   // add by VIctor Yu. 12-02-2008
  14 #include <linux/pagemap.h>
  15 #endif
  16 #include <asm/scatterlist.h>
  17 #include <linux/scatterlist.h>
  18
  19 #include <linux/mmc/host.h>
  20 #include <linux/mmc/card.h>
  21 #include <linux/mmc/mmc.h>
  22
  23 #include "core.h"
  24 #include "mmc_ops.h"
  25
  26 static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card)
  27 {
  28         int err;
  29         struct mmc_command cmd;
  30
  31         BUG_ON(!host);
  32
  33         memset(&cmd, 0, sizeof(struct mmc_command));
  34
  35         cmd.opcode = MMC_SELECT_CARD;
  36
  37         if (card) {
  38                 cmd.arg = card->rca << 16;
  39                 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
  40         } else {
  41                 cmd.arg = 0;
  42                 cmd.flags = MMC_RSP_NONE | MMC_CMD_AC;
  43         }
  44
  45         err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
  46         if (err != MMC_ERR_NONE)
  47                 return err;
  48
  49         return MMC_ERR_NONE;
  50 }
  51
  52 int mmc_select_card(struct mmc_card *card)
  53 {
  54         BUG_ON(!card);
  55
  56         return _mmc_select_card(card->host, card);
  57 }
  58
  59 int mmc_deselect_cards(struct mmc_host *host)
  60 {
  61         return _mmc_select_card(host, NULL);
  62 }
  63
  64 int mmc_go_idle(struct mmc_host *host)
  65 {
  66         int err;
  67         struct mmc_command cmd;
  68
  69         mmc_set_chip_select(host, MMC_CS_HIGH);
  70
  71         mmc_delay(1);
  72
  73         memset(&cmd, 0, sizeof(struct mmc_command));
  74
  75         cmd.opcode = MMC_GO_IDLE_STATE;
  76         cmd.arg = 0;
  77         cmd.flags = MMC_RSP_NONE | MMC_CMD_BC;
  78
  79         err = mmc_wait_for_cmd(host, &cmd, 0);
  80
  81         mmc_delay(1);
  82
  83         mmc_set_chip_select(host, MMC_CS_DONTCARE);
  84
  85         mmc_delay(1);
  86
  87         return err;
  88 }
  89
  90 int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
  91 {
  92         struct mmc_command cmd;
  93         int i, err = 0;
  94
  95         BUG_ON(!host);
  96
  97         memset(&cmd, 0, sizeof(struct mmc_command));
  98
  99         cmd.opcode = MMC_SEND_OP_COND;
 100         cmd.arg = ocr;
 101         cmd.flags = MMC_RSP_R3 | MMC_CMD_BCR;
 102
 103         for (i = 100; i; i--) {
 104                 err = mmc_wait_for_cmd(host, &cmd, 0);
 105                 if (err != MMC_ERR_NONE)
 106                         break;
 107
 108                 if (cmd.resp[0] & MMC_CARD_BUSY || ocr == 0)
 109                         break;
 110
 111                 err = MMC_ERR_TIMEOUT;
 112
 113                 mmc_delay(10);
 114         }
 115
 116         if (rocr)
 117                 *rocr = cmd.resp[0];
 118
 119         return err;
 120 }
 121
 122 int mmc_all_send_cid(struct mmc_host *host, u32 *cid)
 123 {
 124         int err;
 125         struct mmc_command cmd;
 126
 127         BUG_ON(!host);
 128         BUG_ON(!cid);
 129
 130         memset(&cmd, 0, sizeof(struct mmc_command));
 131
 132         cmd.opcode = MMC_ALL_SEND_CID;
 133         cmd.arg = 0;
 134         cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
 135
 136         err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
 137         if (err != MMC_ERR_NONE)
 138                 return err;
 139
 140         memcpy(cid, cmd.resp, sizeof(u32) * 4);
 141
 142         return MMC_ERR_NONE;
 143 }
 144
 145 int mmc_set_relative_addr(struct mmc_card *card)
 146 {
 147         int err;
 148         struct mmc_command cmd;
 149
 150         BUG_ON(!card);
 151         BUG_ON(!card->host);
 152
 153         memset(&cmd, 0, sizeof(struct mmc_command));
 154
 155         cmd.opcode = MMC_SET_RELATIVE_ADDR;
 156         cmd.arg = card->rca << 16;
 157         cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 158
 159         err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
 160         if (err != MMC_ERR_NONE)
 161                 return err;
 162
 163         return MMC_ERR_NONE;
 164 }
 165
 166 int mmc_send_csd(struct mmc_card *card, u32 *csd)
 167 {
 168         int err;
 169         struct mmc_command cmd;
 170
 171         BUG_ON(!card);
 172         BUG_ON(!card->host);
 173         BUG_ON(!csd);
 174
 175         memset(&cmd, 0, sizeof(struct mmc_command));
 176
 177         cmd.opcode = MMC_SEND_CSD;
 178         cmd.arg = card->rca << 16;
 179         cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;
 180
 181         err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
 182         if (err != MMC_ERR_NONE)
 183                 return err;
 184
 185         memcpy(csd, cmd.resp, sizeof(u32) * 4);
 186
 187         return MMC_ERR_NONE;
 188 }
 189
 190 int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd)
 191 {
 192         struct mmc_request mrq;
 193         struct mmc_command cmd;
 194         struct mmc_data data;
 195         struct scatterlist sg;
 196
 197         BUG_ON(!card);
 198         BUG_ON(!card->host);
 199         BUG_ON(!ext_csd);
 200
 201         memset(&mrq, 0, sizeof(struct mmc_request));
 202         memset(&cmd, 0, sizeof(struct mmc_command));
 203         memset(&data, 0, sizeof(struct mmc_data));
 204
 205         mrq.cmd = &cmd;
 206         mrq.data = &data;
 207
 208         cmd.opcode = MMC_SEND_EXT_CSD;
 209         cmd.arg = 0;
 210         cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
 211
 212         data.blksz = 512;
 213         data.blocks = 1;
 214         data.flags = MMC_DATA_READ;
 215         data.sg = &sg;
 216         data.sg_len = 1;
 217
 218         sg_init_one(&sg, ext_csd, 512);
 219
 220         mmc_set_data_timeout(&data, card, 0);
 221
 222         mmc_wait_for_req(card->host, &mrq);
 223
 224         if (cmd.error != MMC_ERR_NONE)
 225                 return cmd.error;
 226         if (data.error != MMC_ERR_NONE)
 227                 return data.error;
 228
 229         return MMC_ERR_NONE;
 230 }
 231
 232 int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value)
 233 {
 234         int err;
 235         struct mmc_command cmd;
 236
 237         BUG_ON(!card);
 238         BUG_ON(!card->host);
 239
 240         memset(&cmd, 0, sizeof(struct mmc_command));
 241
 242         cmd.opcode = MMC_SWITCH;
 243         cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
 244                   (index << 16) |
 245                   (value << 8) |
 246                   set;
 247         cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
 248
 249         err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
 250         if (err != MMC_ERR_NONE)
 251                 return err;
 252
 253         return MMC_ERR_NONE;
 254 }
 255
 256 int mmc_send_status(struct mmc_card *card, u32 *status)
 257 {
 258         int err;
 259         struct mmc_command cmd;
 260
 261         BUG_ON(!card);
 262         BUG_ON(!card->host);
 263
 264         memset(&cmd, 0, sizeof(struct mmc_command));
 265
 266         cmd.opcode = MMC_SEND_STATUS;
 267         cmd.arg = card->rca << 16;
 268         cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 269
 270         err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
 271         if (err != MMC_ERR_NONE)
 272                 return err;
 273
 274         if (status)
 275                 *status = cmd.resp[0];
 276
 277         return MMC_ERR_NONE;
 278 }
 279