Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
sd_ops.c
Go to the documentation of this file.
1 /*
2  * linux/drivers/mmc/core/sd_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/slab.h>
13 #include <linux/types.h>
14 #include <linux/export.h>
15 #include <linux/scatterlist.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 "sd_ops.h"
24 
25 int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)
26 {
27  int err;
28  struct mmc_command cmd = {0};
29 
30  BUG_ON(!host);
31  BUG_ON(card && (card->host != host));
32 
33  cmd.opcode = MMC_APP_CMD;
34 
35  if (card) {
36  cmd.arg = card->rca << 16;
38  } else {
39  cmd.arg = 0;
41  }
42 
43  err = mmc_wait_for_cmd(host, &cmd, 0);
44  if (err)
45  return err;
46 
47  /* Check that card supported application commands */
48  if (!mmc_host_is_spi(host) && !(cmd.resp[0] & R1_APP_CMD))
49  return -EOPNOTSUPP;
50 
51  return 0;
52 }
54 
69  struct mmc_command *cmd, int retries)
70 {
71  struct mmc_request mrq = {NULL};
72 
73  int i, err;
74 
75  BUG_ON(!cmd);
76  BUG_ON(retries < 0);
77 
78  err = -EIO;
79 
80  /*
81  * We have to resend MMC_APP_CMD for each attempt so
82  * we cannot use the retries field in mmc_command.
83  */
84  for (i = 0;i <= retries;i++) {
85  err = mmc_app_cmd(host, card);
86  if (err) {
87  /* no point in retrying; no APP commands allowed */
88  if (mmc_host_is_spi(host)) {
89  if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
90  break;
91  }
92  continue;
93  }
94 
95  memset(&mrq, 0, sizeof(struct mmc_request));
96 
97  memset(cmd->resp, 0, sizeof(cmd->resp));
98  cmd->retries = 0;
99 
100  mrq.cmd = cmd;
101  cmd->data = NULL;
102 
103  mmc_wait_for_req(host, &mrq);
104 
105  err = cmd->error;
106  if (!cmd->error)
107  break;
108 
109  /* no point in retrying illegal APP commands */
110  if (mmc_host_is_spi(host)) {
111  if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
112  break;
113  }
114  }
115 
116  return err;
117 }
118 
120 
122 {
123  int err;
124  struct mmc_command cmd = {0};
125 
126  BUG_ON(!card);
127  BUG_ON(!card->host);
128 
130  cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
131 
132  switch (width) {
133  case MMC_BUS_WIDTH_1:
134  cmd.arg = SD_BUS_WIDTH_1;
135  break;
136  case MMC_BUS_WIDTH_4:
137  cmd.arg = SD_BUS_WIDTH_4;
138  break;
139  default:
140  return -EINVAL;
141  }
142 
143  err = mmc_wait_for_app_cmd(card->host, card, &cmd, MMC_CMD_RETRIES);
144  if (err)
145  return err;
146 
147  return 0;
148 }
149 
150 int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
151 {
152  struct mmc_command cmd = {0};
153  int i, err = 0;
154 
155  BUG_ON(!host);
156 
157  cmd.opcode = SD_APP_OP_COND;
158  if (mmc_host_is_spi(host))
159  cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */
160  else
161  cmd.arg = ocr;
163 
164  for (i = 100; i; i--) {
165  err = mmc_wait_for_app_cmd(host, NULL, &cmd, MMC_CMD_RETRIES);
166  if (err)
167  break;
168 
169  /* if we're just probing, do a single pass */
170  if (ocr == 0)
171  break;
172 
173  /* otherwise wait until reset completes */
174  if (mmc_host_is_spi(host)) {
175  if (!(cmd.resp[0] & R1_SPI_IDLE))
176  break;
177  } else {
178  if (cmd.resp[0] & MMC_CARD_BUSY)
179  break;
180  }
181 
182  err = -ETIMEDOUT;
183 
184  mmc_delay(10);
185  }
186 
187  if (rocr && !mmc_host_is_spi(host))
188  *rocr = cmd.resp[0];
189 
190  return err;
191 }
192 
194 {
195  struct mmc_command cmd = {0};
196  int err;
197  static const u8 test_pattern = 0xAA;
198  u8 result_pattern;
199 
200  /*
201  * To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND
202  * before SD_APP_OP_COND. This command will harmlessly fail for
203  * SD 1.0 cards.
204  */
205  cmd.opcode = SD_SEND_IF_COND;
206  cmd.arg = ((ocr & 0xFF8000) != 0) << 8 | test_pattern;
208 
209  err = mmc_wait_for_cmd(host, &cmd, 0);
210  if (err)
211  return err;
212 
213  if (mmc_host_is_spi(host))
214  result_pattern = cmd.resp[1] & 0xFF;
215  else
216  result_pattern = cmd.resp[0] & 0xFF;
217 
218  if (result_pattern != test_pattern)
219  return -EIO;
220 
221  return 0;
222 }
223 
224 int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)
225 {
226  int err;
227  struct mmc_command cmd = {0};
228 
229  BUG_ON(!host);
230  BUG_ON(!rca);
231 
233  cmd.arg = 0;
234  cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;
235 
236  err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
237  if (err)
238  return err;
239 
240  *rca = cmd.resp[0] >> 16;
241 
242  return 0;
243 }
244 
246 {
247  int err;
248  struct mmc_request mrq = {NULL};
249  struct mmc_command cmd = {0};
250  struct mmc_data data = {0};
251  struct scatterlist sg;
252  void *data_buf;
253 
254  BUG_ON(!card);
255  BUG_ON(!card->host);
256  BUG_ON(!scr);
257 
258  /* NOTE: caller guarantees scr is heap-allocated */
259 
260  err = mmc_app_cmd(card->host, card);
261  if (err)
262  return err;
263 
264  /* dma onto stack is unsafe/nonportable, but callers to this
265  * routine normally provide temporary on-stack buffers ...
266  */
267  data_buf = kmalloc(sizeof(card->raw_scr), GFP_KERNEL);
268  if (data_buf == NULL)
269  return -ENOMEM;
270 
271  mrq.cmd = &cmd;
272  mrq.data = &data;
273 
274  cmd.opcode = SD_APP_SEND_SCR;
275  cmd.arg = 0;
277 
278  data.blksz = 8;
279  data.blocks = 1;
280  data.flags = MMC_DATA_READ;
281  data.sg = &sg;
282  data.sg_len = 1;
283 
284  sg_init_one(&sg, data_buf, 8);
285 
286  mmc_set_data_timeout(&data, card);
287 
288  mmc_wait_for_req(card->host, &mrq);
289 
290  memcpy(scr, data_buf, sizeof(card->raw_scr));
291  kfree(data_buf);
292 
293  if (cmd.error)
294  return cmd.error;
295  if (data.error)
296  return data.error;
297 
298  scr[0] = be32_to_cpu(scr[0]);
299  scr[1] = be32_to_cpu(scr[1]);
300 
301  return 0;
302 }
303 
304 int mmc_sd_switch(struct mmc_card *card, int mode, int group,
305  u8 value, u8 *resp)
306 {
307  struct mmc_request mrq = {NULL};
308  struct mmc_command cmd = {0};
309  struct mmc_data data = {0};
310  struct scatterlist sg;
311 
312  BUG_ON(!card);
313  BUG_ON(!card->host);
314 
315  /* NOTE: caller guarantees resp is heap-allocated */
316 
317  mode = !!mode;
318  value &= 0xF;
319 
320  mrq.cmd = &cmd;
321  mrq.data = &data;
322 
323  cmd.opcode = SD_SWITCH;
324  cmd.arg = mode << 31 | 0x00FFFFFF;
325  cmd.arg &= ~(0xF << (group * 4));
326  cmd.arg |= value << (group * 4);
328 
329  data.blksz = 64;
330  data.blocks = 1;
331  data.flags = MMC_DATA_READ;
332  data.sg = &sg;
333  data.sg_len = 1;
334 
335  sg_init_one(&sg, resp, 64);
336 
337  mmc_set_data_timeout(&data, card);
338 
339  mmc_wait_for_req(card->host, &mrq);
340 
341  if (cmd.error)
342  return cmd.error;
343  if (data.error)
344  return data.error;
345 
346  return 0;
347 }
348 
349 int mmc_app_sd_status(struct mmc_card *card, void *ssr)
350 {
351  int err;
352  struct mmc_request mrq = {NULL};
353  struct mmc_command cmd = {0};
354  struct mmc_data data = {0};
355  struct scatterlist sg;
356 
357  BUG_ON(!card);
358  BUG_ON(!card->host);
359  BUG_ON(!ssr);
360 
361  /* NOTE: caller guarantees ssr is heap-allocated */
362 
363  err = mmc_app_cmd(card->host, card);
364  if (err)
365  return err;
366 
367  mrq.cmd = &cmd;
368  mrq.data = &data;
369 
370  cmd.opcode = SD_APP_SD_STATUS;
371  cmd.arg = 0;
373 
374  data.blksz = 64;
375  data.blocks = 1;
376  data.flags = MMC_DATA_READ;
377  data.sg = &sg;
378  data.sg_len = 1;
379 
380  sg_init_one(&sg, ssr, 64);
381 
382  mmc_set_data_timeout(&data, card);
383 
384  mmc_wait_for_req(card->host, &mrq);
385 
386  if (cmd.error)
387  return cmd.error;
388  if (data.error)
389  return data.error;
390 
391  return 0;
392 }