Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6] / drivers / mmc / core / sd_ops.c
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/types.h>
13 #include <asm/scatterlist.h>
14 #include <linux/scatterlist.h>
15
16 #include <linux/mmc/host.h>
17 #include <linux/mmc/card.h>
18 #include <linux/mmc/mmc.h>
19 #include <linux/mmc/sd.h>
20
21 #include "core.h"
22 #include "sd_ops.h"
23
24 static int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)
25 {
26         int err;
27         struct mmc_command cmd;
28
29         BUG_ON(!host);
30         BUG_ON(card && (card->host != host));
31
32         cmd.opcode = MMC_APP_CMD;
33
34         if (card) {
35                 cmd.arg = card->rca << 16;
36                 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
37         } else {
38                 cmd.arg = 0;
39                 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_BCR;
40         }
41
42         err = mmc_wait_for_cmd(host, &cmd, 0);
43         if (err)
44                 return err;
45
46         /* Check that card supported application commands */
47         if (!mmc_host_is_spi(host) && !(cmd.resp[0] & R1_APP_CMD))
48                 return -EOPNOTSUPP;
49
50         return 0;
51 }
52
53 /**
54  *      mmc_wait_for_app_cmd - start an application command and wait for
55                                completion
56  *      @host: MMC host to start command
57  *      @card: Card to send MMC_APP_CMD to
58  *      @cmd: MMC command to start
59  *      @retries: maximum number of retries
60  *
61  *      Sends a MMC_APP_CMD, checks the card response, sends the command
62  *      in the parameter and waits for it to complete. Return any error
63  *      that occurred while the command was executing.  Do not attempt to
64  *      parse the response.
65  */
66 int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card,
67         struct mmc_command *cmd, int retries)
68 {
69         struct mmc_request mrq;
70
71         int i, err;
72
73         BUG_ON(!cmd);
74         BUG_ON(retries < 0);
75
76         err = -EIO;
77
78         /*
79          * We have to resend MMC_APP_CMD for each attempt so
80          * we cannot use the retries field in mmc_command.
81          */
82         for (i = 0;i <= retries;i++) {
83                 memset(&mrq, 0, sizeof(struct mmc_request));
84
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
119 EXPORT_SYMBOL(mmc_wait_for_app_cmd);
120
121 int mmc_app_set_bus_width(struct mmc_card *card, int width)
122 {
123         int err;
124         struct mmc_command cmd;
125
126         BUG_ON(!card);
127         BUG_ON(!card->host);
128
129         memset(&cmd, 0, sizeof(struct mmc_command));
130
131         cmd.opcode = SD_APP_SET_BUS_WIDTH;
132         cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
133
134         switch (width) {
135         case MMC_BUS_WIDTH_1:
136                 cmd.arg = SD_BUS_WIDTH_1;
137                 break;
138         case MMC_BUS_WIDTH_4:
139                 cmd.arg = SD_BUS_WIDTH_4;
140                 break;
141         default:
142                 return -EINVAL;
143         }
144
145         err = mmc_wait_for_app_cmd(card->host, card, &cmd, MMC_CMD_RETRIES);
146         if (err)
147                 return err;
148
149         return 0;
150 }
151
152 int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
153 {
154         struct mmc_command cmd;
155         int i, err = 0;
156
157         BUG_ON(!host);
158
159         memset(&cmd, 0, sizeof(struct mmc_command));
160
161         cmd.opcode = SD_APP_OP_COND;
162         if (mmc_host_is_spi(host))
163                 cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */
164         else
165                 cmd.arg = ocr;
166         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;
167
168         for (i = 100; i; i--) {
169                 err = mmc_wait_for_app_cmd(host, NULL, &cmd, MMC_CMD_RETRIES);
170                 if (err)
171                         break;
172
173                 /* if we're just probing, do a single pass */
174                 if (ocr == 0)
175                         break;
176
177                 /* otherwise wait until reset completes */
178                 if (mmc_host_is_spi(host)) {
179                         if (!(cmd.resp[0] & R1_SPI_IDLE))
180                                 break;
181                 } else {
182                         if (cmd.resp[0] & MMC_CARD_BUSY)
183                                 break;
184                 }
185
186                 err = -ETIMEDOUT;
187
188                 mmc_delay(10);
189         }
190
191         if (rocr && !mmc_host_is_spi(host))
192                 *rocr = cmd.resp[0];
193
194         return err;
195 }
196
197 int mmc_send_if_cond(struct mmc_host *host, u32 ocr)
198 {
199         struct mmc_command cmd;
200         int err;
201         static const u8 test_pattern = 0xAA;
202         u8 result_pattern;
203
204         /*
205          * To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND
206          * before SD_APP_OP_COND. This command will harmlessly fail for
207          * SD 1.0 cards.
208          */
209         cmd.opcode = SD_SEND_IF_COND;
210         cmd.arg = ((ocr & 0xFF8000) != 0) << 8 | test_pattern;
211         cmd.flags = MMC_RSP_SPI_R7 | MMC_RSP_R7 | MMC_CMD_BCR;
212
213         err = mmc_wait_for_cmd(host, &cmd, 0);
214         if (err)
215                 return err;
216
217         if (mmc_host_is_spi(host))
218                 result_pattern = cmd.resp[1] & 0xFF;
219         else
220                 result_pattern = cmd.resp[0] & 0xFF;
221
222         if (result_pattern != test_pattern)
223                 return -EIO;
224
225         return 0;
226 }
227
228 int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)
229 {
230         int err;
231         struct mmc_command cmd;
232
233         BUG_ON(!host);
234         BUG_ON(!rca);
235
236         memset(&cmd, 0, sizeof(struct mmc_command));
237
238         cmd.opcode = SD_SEND_RELATIVE_ADDR;
239         cmd.arg = 0;
240         cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;
241
242         err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
243         if (err)
244                 return err;
245
246         *rca = cmd.resp[0] >> 16;
247
248         return 0;
249 }
250
251 int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
252 {
253         int err;
254         struct mmc_request mrq;
255         struct mmc_command cmd;
256         struct mmc_data data;
257         struct scatterlist sg;
258
259         BUG_ON(!card);
260         BUG_ON(!card->host);
261         BUG_ON(!scr);
262
263         /* NOTE: caller guarantees scr is heap-allocated */
264
265         err = mmc_app_cmd(card->host, card);
266         if (err)
267                 return err;
268
269         memset(&mrq, 0, sizeof(struct mmc_request));
270         memset(&cmd, 0, sizeof(struct mmc_command));
271         memset(&data, 0, sizeof(struct mmc_data));
272
273         mrq.cmd = &cmd;
274         mrq.data = &data;
275
276         cmd.opcode = SD_APP_SEND_SCR;
277         cmd.arg = 0;
278         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
279
280         data.blksz = 8;
281         data.blocks = 1;
282         data.flags = MMC_DATA_READ;
283         data.sg = &sg;
284         data.sg_len = 1;
285
286         sg_init_one(&sg, scr, 8);
287
288         mmc_set_data_timeout(&data, card);
289
290         mmc_wait_for_req(card->host, &mrq);
291
292         if (cmd.error)
293                 return cmd.error;
294         if (data.error)
295                 return data.error;
296
297         scr[0] = ntohl(scr[0]);
298         scr[1] = ntohl(scr[1]);
299
300         return 0;
301 }
302
303 int mmc_sd_switch(struct mmc_card *card, int mode, int group,
304         u8 value, u8 *resp)
305 {
306         struct mmc_request mrq;
307         struct mmc_command cmd;
308         struct mmc_data data;
309         struct scatterlist sg;
310
311         BUG_ON(!card);
312         BUG_ON(!card->host);
313
314         /* NOTE: caller guarantees resp is heap-allocated */
315
316         mode = !!mode;
317         value &= 0xF;
318
319         memset(&mrq, 0, sizeof(struct mmc_request));
320         memset(&cmd, 0, sizeof(struct mmc_command));
321         memset(&data, 0, sizeof(struct mmc_data));
322
323         mrq.cmd = &cmd;
324         mrq.data = &data;
325
326         cmd.opcode = SD_SWITCH;
327         cmd.arg = mode << 31 | 0x00FFFFFF;
328         cmd.arg &= ~(0xF << (group * 4));
329         cmd.arg |= value << (group * 4);
330         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
331
332         data.blksz = 64;
333         data.blocks = 1;
334         data.flags = MMC_DATA_READ;
335         data.sg = &sg;
336         data.sg_len = 1;
337
338         sg_init_one(&sg, resp, 64);
339
340         mmc_set_data_timeout(&data, card);
341
342         mmc_wait_for_req(card->host, &mrq);
343
344         if (cmd.error)
345                 return cmd.error;
346         if (data.error)
347                 return data.error;
348
349         return 0;
350 }
351