Linux Kernel
3.7.1
Main Page
Related Pages
Modules
Namespaces
Data Structures
Files
File List
Globals
All
Data Structures
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Macros
Groups
Pages
drivers
mmc
core
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;
37
cmd.
flags
=
MMC_RSP_SPI_R1
|
MMC_RSP_R1
|
MMC_CMD_AC
;
38
}
else
{
39
cmd.
arg
= 0;
40
cmd.
flags
=
MMC_RSP_SPI_R1
|
MMC_RSP_R1
|
MMC_CMD_BCR
;
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
}
53
EXPORT_SYMBOL_GPL
(
mmc_app_cmd
);
54
68
int
mmc_wait_for_app_cmd
(
struct
mmc_host
*
host
,
struct
mmc_card
*
card
,
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
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 = {0};
125
126
BUG_ON
(!card);
127
BUG_ON
(!card->
host
);
128
129
cmd.
opcode
=
SD_APP_SET_BUS_WIDTH
;
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;
162
cmd.
flags
=
MMC_RSP_SPI_R1
|
MMC_RSP_R3
|
MMC_CMD_BCR
;
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
193
int
mmc_send_if_cond
(
struct
mmc_host
*
host
,
u32
ocr)
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;
207
cmd.
flags
=
MMC_RSP_SPI_R7
|
MMC_RSP_R7
|
MMC_CMD_BCR
;
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
232
cmd.
opcode
=
SD_SEND_RELATIVE_ADDR
;
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
245
int
mmc_app_send_scr
(
struct
mmc_card
*
card
,
u32
*
scr
)
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;
276
cmd.
flags
=
MMC_RSP_SPI_R1
|
MMC_RSP_R1
|
MMC_CMD_ADTC
;
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);
327
cmd.
flags
=
MMC_RSP_SPI_R1
|
MMC_RSP_R1
|
MMC_CMD_ADTC
;
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;
372
cmd.
flags
=
MMC_RSP_SPI_R2
|
MMC_RSP_R1
|
MMC_CMD_ADTC
;
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
}
Generated on Thu Jan 10 2013 13:55:33 for Linux Kernel by
1.8.2