?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Break up vl.h.
[qemu/mini2440.git] / hw / sd.c
blob08e8805e54cf82f626d66840092f020cb604c260
1 /*
2 * SD Memory Card emulation as defined in the "SD Memory Card Physical
3 * layer specification, Version 1.10."
4 *
5 * Copyright (c) 2006 Andrzej Zaborowski <balrog@zabor.org>
6 * Copyright (c) 2007 CodeSourcery
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in
16 * the documentation and/or other materials provided with the
17 * distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS''
20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
21 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
22 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
27 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include "hw.h"
33 #include "block.h"
34 #include "sd.h"
35
36 //#define DEBUG_SD 1
37
38 #ifdef DEBUG_SD
39 #define DPRINTF(fmt, args...) \
40 do { printf("SD: " fmt , ##args); } while (0)
41 #else
42 #define DPRINTF(fmt, args...) do {} while(0)
43 #endif
44
45 typedef enum {
46 sd_r0 = 0, /* no response */
47 sd_r1, /* normal response command */
48 sd_r2_i, /* CID register */
49 sd_r2_s, /* CSD register */
50 sd_r3, /* OCR register */
51 sd_r6 = 6, /* Published RCA response */
52 sd_r1b = -1,
53 } sd_rsp_type_t;
54
55 struct SDState {
56 enum {
57 sd_inactive,
58 sd_card_identification_mode,
59 sd_data_transfer_mode,
60 } mode;
61 enum {
62 sd_inactive_state = -1,
63 sd_idle_state = 0,
64 sd_ready_state,
65 sd_identification_state,
66 sd_standby_state,
67 sd_transfer_state,
68 sd_sendingdata_state,
69 sd_receivingdata_state,
70 sd_programming_state,
71 sd_disconnect_state,
72 } state;
73 uint32_t ocr;
74 uint8_t scr[8];
75 uint8_t cid[16];
76 uint8_t csd[16];
77 uint16_t rca;
78 uint32_t card_status;
79 uint8_t sd_status[64];
80 int wp_switch;
81 int *wp_groups;
82 uint32_t size;
83 int blk_len;
84 uint32_t erase_start;
85 uint32_t erase_end;
86 uint8_t pwd[16];
87 int pwd_len;
88 int function_group[6];
89
90 int current_cmd;
91 int blk_written;
92 uint32_t data_start;
93 uint32_t data_offset;
94 uint8_t data[512];
95 qemu_irq readonly_cb;
96 qemu_irq inserted_cb;
97 BlockDriverState *bdrv;
98 };
99
100 static void sd_set_status(SDState *sd)
101 {
102 switch (sd->state) {
103 case sd_inactive_state:
104 sd->mode = sd_inactive;
105 break;
106
107 case sd_idle_state:
108 case sd_ready_state:
109 case sd_identification_state:
110 sd->mode = sd_card_identification_mode;
111 break;
112
113 case sd_standby_state:
114 case sd_transfer_state:
115 case sd_sendingdata_state:
116 case sd_receivingdata_state:
117 case sd_programming_state:
118 case sd_disconnect_state:
119 sd->mode = sd_data_transfer_mode;
120 break;
121 }
122
123 sd->card_status &= ~CURRENT_STATE;
124 sd->card_status |= sd->state << 9;
125 }
126
127 const sd_cmd_type_t sd_cmd_type[64] = {
128 sd_bc, sd_none, sd_bcr, sd_bcr, sd_none, sd_none, sd_none, sd_ac,
129 sd_none, sd_ac, sd_ac, sd_adtc, sd_ac, sd_ac, sd_none, sd_ac,
130 sd_ac, sd_adtc, sd_adtc, sd_none, sd_none, sd_none, sd_none, sd_none,
131 sd_adtc, sd_adtc, sd_adtc, sd_adtc, sd_ac, sd_ac, sd_adtc, sd_none,
132 sd_ac, sd_ac, sd_none, sd_none, sd_none, sd_none, sd_ac, sd_none,
133 sd_none, sd_none, sd_bc, sd_none, sd_none, sd_none, sd_none, sd_none,
134 sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_ac,
135 sd_adtc, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none,
136 };
137
138 const sd_cmd_type_t sd_acmd_type[64] = {
139 sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_ac, sd_none,
140 sd_none, sd_none, sd_none, sd_none, sd_none, sd_adtc, sd_none, sd_none,
141 sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_adtc, sd_ac,
142 sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none,
143 sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none,
144 sd_none, sd_bcr, sd_ac, sd_none, sd_none, sd_none, sd_none, sd_none,
145 sd_none, sd_none, sd_none, sd_adtc, sd_none, sd_none, sd_none, sd_none,
146 sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none,
147 };
148
149 static const int sd_cmd_class[64] = {
150 0, 0, 0, 0, 0, 9, 10, 0, 0, 0, 0, 1, 0, 0, 0, 0,
151 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 6, 6, 6, 6,
152 5, 5, 10, 10, 10, 10, 5, 9, 9, 9, 7, 7, 7, 7, 7, 7,
153 7, 7, 10, 7, 9, 9, 9, 8, 8, 10, 8, 8, 8, 8, 8, 8,
154 };
155
156 static uint8_t sd_crc7(void *message, size_t width)
157 {
158 int i, bit;
159 uint8_t shift_reg = 0x00;
160 uint8_t *msg = (uint8_t *) message;
161
162 for (i = 0; i < width; i ++, msg ++)
163 for (bit = 7; bit >= 0; bit --) {
164 shift_reg <<= 1;
165 if ((shift_reg >> 7) ^ ((*msg >> bit) & 1))
166 shift_reg ^= 0x89;
167 }
168
169 return shift_reg;
170 }
171
172 static uint16_t sd_crc16(void *message, size_t width)
173 {
174 int i, bit;
175 uint16_t shift_reg = 0x0000;
176 uint16_t *msg = (uint16_t *) message;
177 width <<= 1;
178
179 for (i = 0; i < width; i ++, msg ++)
180 for (bit = 15; bit >= 0; bit --) {
181 shift_reg <<= 1;
182 if ((shift_reg >> 15) ^ ((*msg >> bit) & 1))
183 shift_reg ^= 0x1011;
184 }
185
186 return shift_reg;
187 }
188
189 static void sd_set_ocr(SDState *sd)
190 {
191 sd->ocr = 0x80fffff0;
192 }
193
194 static void sd_set_scr(SDState *sd)
195 {
196 sd->scr[0] = 0x00; /* SCR Structure */
197 sd->scr[1] = 0x2f; /* SD Security Support */
198 sd->scr[2] = 0x00;
199 sd->scr[3] = 0x00;
200 sd->scr[4] = 0x00;
201 sd->scr[5] = 0x00;
202 sd->scr[6] = 0x00;
203 sd->scr[7] = 0x00;
204 }
205
206 #define MID 0xaa
207 #define OID "XY"
208 #define PNM "QEMU!"
209 #define PRV 0x01
210 #define MDT_YR 2006
211 #define MDT_MON 2
212
213 static void sd_set_cid(SDState *sd)
214 {
215 sd->cid[0] = MID; /* Fake card manufacturer ID (MID) */
216 sd->cid[1] = OID[0]; /* OEM/Application ID (OID) */
217 sd->cid[2] = OID[1];
218 sd->cid[3] = PNM[0]; /* Fake product name (PNM) */
219 sd->cid[4] = PNM[1];
220 sd->cid[5] = PNM[2];
221 sd->cid[6] = PNM[3];
222 sd->cid[7] = PNM[4];
223 sd->cid[8] = PRV; /* Fake product revision (PRV) */
224 sd->cid[9] = 0xde; /* Fake serial number (PSN) */
225 sd->cid[10] = 0xad;
226 sd->cid[11] = 0xbe;
227 sd->cid[12] = 0xef;
228 sd->cid[13] = 0x00 | /* Manufacture date (MDT) */
229 ((MDT_YR - 2000) / 10);
230 sd->cid[14] = ((MDT_YR % 10) << 4) | MDT_MON;
231 sd->cid[15] = (sd_crc7(sd->cid, 15) << 1) | 1;
232 }
233
234 #define HWBLOCK_SHIFT 9 /* 512 bytes */
235 #define SECTOR_SHIFT 5 /* 16 kilobytes */
236 #define WPGROUP_SHIFT 7 /* 2 megs */
237 #define CMULT_SHIFT 9 /* 512 times HWBLOCK_SIZE */
238 #define BLOCK_SIZE (1 << (HWBLOCK_SHIFT))
239 #define SECTOR_SIZE (1 << (HWBLOCK_SHIFT + SECTOR_SHIFT))
240 #define WPGROUP_SIZE (1 << (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT))
241
242 static const uint8_t sd_csd_rw_mask[16] = {
243 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
244 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfe,
245 };
246
247 static void sd_set_csd(SDState *sd, uint32_t size)
248 {
249 uint32_t csize = (size >> (CMULT_SHIFT + HWBLOCK_SHIFT)) - 1;
250 uint32_t sectsize = (1 << (SECTOR_SHIFT + 1)) - 1;
251 uint32_t wpsize = (1 << (WPGROUP_SHIFT + 1)) - 1;
252
253 sd->csd[0] = 0x00; /* CSD structure */
254 sd->csd[1] = 0x26; /* Data read access-time-1 */
255 sd->csd[2] = 0x00; /* Data read access-time-2 */
256 sd->csd[3] = 0x5a; /* Max. data transfer rate */
257 sd->csd[4] = 0x5f; /* Card Command Classes */
258 sd->csd[5] = 0x50 | /* Max. read data block length */
259 HWBLOCK_SHIFT;
260 sd->csd[6] = 0xe0 | /* Partial block for read allowed */
261 ((csize >> 10) & 0x03);
262 sd->csd[7] = 0x00 | /* Device size */
263 ((csize >> 2) & 0xff);
264 sd->csd[8] = 0x3f | /* Max. read current */
265 ((csize << 6) & 0xc0);
266 sd->csd[9] = 0xfc | /* Max. write current */
267 ((CMULT_SHIFT - 2) >> 1);
268 sd->csd[10] = 0x40 | /* Erase sector size */
269 (((CMULT_SHIFT - 2) << 7) & 0x80) | (sectsize >> 1);
270 sd->csd[11] = 0x00 | /* Write protect group size */
271 ((sectsize << 7) & 0x80) | wpsize;
272 sd->csd[12] = 0x90 | /* Write speed factor */
273 (HWBLOCK_SHIFT >> 2);
274 sd->csd[13] = 0x20 | /* Max. write data block length */
275 ((HWBLOCK_SHIFT << 6) & 0xc0);
276 sd->csd[14] = 0x00; /* File format group */
277 sd->csd[15] = (sd_crc7(sd->csd, 15) << 1) | 1;
278 }
279
280 static void sd_set_rca(SDState *sd)
281 {
282 sd->rca += 0x4567;
283 }
284
285 #define CARD_STATUS_A 0x02004100
286 #define CARD_STATUS_B 0x00c01e00
287 #define CARD_STATUS_C 0xfd39a028
288
289 static void sd_set_cardstatus(SDState *sd)
290 {
291 sd->card_status = 0x00000100;
292 }
293
294 static void sd_set_sdstatus(SDState *sd)
295 {
296 memset(sd->sd_status, 0, 64);
297 }
298
299 static int sd_req_crc_validate(struct sd_request_s *req)
300 {
301 uint8_t buffer[5];
302 buffer[0] = 0x40 | req->cmd;
303 buffer[1] = (req->arg >> 24) & 0xff;
304 buffer[2] = (req->arg >> 16) & 0xff;
305 buffer[3] = (req->arg >> 8) & 0xff;
306 buffer[4] = (req->arg >> 0) & 0xff;
307 return 0;
308 return sd_crc7(buffer, 5) != req->crc; /* TODO */
309 }
310
311 void sd_response_r1_make(SDState *sd,
312 uint8_t *response, uint32_t last_status)
313 {
314 uint32_t mask = CARD_STATUS_B ^ ILLEGAL_COMMAND;
315 uint32_t status;
316
317 status = (sd->card_status & ~mask) | (last_status & mask);
318 sd->card_status &= ~CARD_STATUS_C | APP_CMD;
319
320 response[0] = (status >> 24) & 0xff;
321 response[1] = (status >> 16) & 0xff;
322 response[2] = (status >> 8) & 0xff;
323 response[3] = (status >> 0) & 0xff;
324 }
325
326 void sd_response_r3_make(SDState *sd, uint8_t *response)
327 {
328 response[0] = (sd->ocr >> 24) & 0xff;
329 response[1] = (sd->ocr >> 16) & 0xff;
330 response[2] = (sd->ocr >> 8) & 0xff;
331 response[3] = (sd->ocr >> 0) & 0xff;
332 }
333
334 void sd_response_r6_make(SDState *sd, uint8_t *response)
335 {
336 uint16_t arg;
337 uint16_t status;
338
339 arg = sd->rca;
340 status = ((sd->card_status >> 8) & 0xc000) |
341 ((sd->card_status >> 6) & 0x2000) |
342 (sd->card_status & 0x1fff);
343
344 response[0] = (arg >> 8) & 0xff;
345 response[1] = arg & 0xff;
346 response[2] = (status >> 8) & 0xff;
347 response[3] = status & 0xff;
348 }
349
350 static void sd_reset(SDState *sd, BlockDriverState *bdrv)
351 {
352 uint32_t size;
353 uint64_t sect;
354
355 bdrv_get_geometry(bdrv, &sect);
356 sect <<= 9;
357
358 if (sect > 0x40000000)
359 size = 0x40000000; /* 1 gig */
360 else
361 size = sect + 1;
362
363 sect = (size >> (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT)) + 1;
364
365 sd->state = sd_idle_state;
366 sd->rca = 0x0000;
367 sd_set_ocr(sd);
368 sd_set_scr(sd);
369 sd_set_cid(sd);
370 sd_set_csd(sd, size);
371 sd_set_cardstatus(sd);
372 sd_set_sdstatus(sd);
373
374 sd->bdrv = bdrv;
375
376 if (sd->wp_groups)
377 qemu_free(sd->wp_groups);
378 sd->wp_switch = bdrv_is_read_only(bdrv);
379 sd->wp_groups = (int *) qemu_mallocz(sizeof(int) * sect);
380 memset(sd->wp_groups, 0, sizeof(int) * sect);
381 memset(sd->function_group, 0, sizeof(int) * 6);
382 sd->erase_start = 0;
383 sd->erase_end = 0;
384 sd->size = size;
385 sd->blk_len = 0x200;
386 sd->pwd_len = 0;
387 }
388
389 static void sd_cardchange(void *opaque)
390 {
391 SDState *sd = opaque;
392 qemu_set_irq(sd->inserted_cb, bdrv_is_inserted(sd->bdrv));
393 if (bdrv_is_inserted(sd->bdrv)) {
394 sd_reset(sd, sd->bdrv);
395 qemu_set_irq(sd->readonly_cb, sd->wp_switch);
396 }
397 }
398
399 SDState *sd_init(BlockDriverState *bs)
400 {
401 SDState *sd;
402
403 sd = (SDState *) qemu_mallocz(sizeof(SDState));
404 sd_reset(sd, bs);
405 bdrv_set_change_cb(sd->bdrv, sd_cardchange, sd);
406 return sd;
407 }
408
409 void sd_set_cb(SDState *sd, qemu_irq readonly, qemu_irq insert)
410 {
411 sd->readonly_cb = readonly;
412 sd->inserted_cb = insert;
413 qemu_set_irq(readonly, bdrv_is_read_only(sd->bdrv));
414 qemu_set_irq(insert, bdrv_is_inserted(sd->bdrv));
415 }
416
417 static void sd_erase(SDState *sd)
418 {
419 int i, start, end;
420 if (!sd->erase_start || !sd->erase_end) {
421 sd->card_status |= ERASE_SEQ_ERROR;
422 return;
423 }
424
425 start = sd->erase_start >>
426 (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT);
427 end = sd->erase_end >>
428 (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT);
429 sd->erase_start = 0;
430 sd->erase_end = 0;
431 sd->csd[14] |= 0x40;
432
433 for (i = start; i <= end; i ++)
434 if (sd->wp_groups[i])
435 sd->card_status |= WP_ERASE_SKIP;
436 }
437
438 static uint32_t sd_wpbits(SDState *sd, uint32_t addr)
439 {
440 uint32_t i, wpnum;
441 uint32_t ret = 0;
442
443 wpnum = addr >> (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT);
444
445 for (i = 0; i < 32; i ++, wpnum ++, addr += WPGROUP_SIZE)
446 if (addr < sd->size && sd->wp_groups[wpnum])
447 ret |= (1 << i);
448
449 return ret;
450 }
451
452 static void sd_function_switch(SDState *sd, uint32_t arg)
453 {
454 int i, mode, new_func, crc;
455 mode = !!(arg & 0x80000000);
456
457 sd->data[0] = 0x00; /* Maximum current consumption */
458 sd->data[1] = 0x01;
459 sd->data[2] = 0x80; /* Supported group 6 functions */
460 sd->data[3] = 0x01;
461 sd->data[4] = 0x80; /* Supported group 5 functions */
462 sd->data[5] = 0x01;
463 sd->data[6] = 0x80; /* Supported group 4 functions */
464 sd->data[7] = 0x01;
465 sd->data[8] = 0x80; /* Supported group 3 functions */
466 sd->data[9] = 0x01;
467 sd->data[10] = 0x80; /* Supported group 2 functions */
468 sd->data[11] = 0x43;
469 sd->data[12] = 0x80; /* Supported group 1 functions */
470 sd->data[13] = 0x03;
471 for (i = 0; i < 6; i ++) {
472 new_func = (arg >> (i * 4)) & 0x0f;
473 if (mode && new_func != 0x0f)
474 sd->function_group[i] = new_func;
475 sd->data[14 + (i >> 1)] = new_func << ((i * 4) & 4);
476 }
477 memset(&sd->data[17], 0, 47);
478 crc = sd_crc16(sd->data, 64);
479 sd->data[65] = crc >> 8;
480 sd->data[66] = crc & 0xff;
481 }
482
483 static inline int sd_wp_addr(SDState *sd, uint32_t addr)
484 {
485 return sd->wp_groups[addr >>
486 (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT)];
487 }
488
489 static void sd_lock_command(SDState *sd)
490 {
491 int erase, lock, clr_pwd, set_pwd, pwd_len;
492 erase = !!(sd->data[0] & 0x08);
493 lock = sd->data[0] & 0x04;
494 clr_pwd = sd->data[0] & 0x02;
495 set_pwd = sd->data[0] & 0x01;
496
497 if (sd->blk_len > 1)
498 pwd_len = sd->data[1];
499 else
500 pwd_len = 0;
501
502 if (erase) {
503 if (!(sd->card_status & CARD_IS_LOCKED) || sd->blk_len > 1 ||
504 set_pwd || clr_pwd || lock || sd->wp_switch ||
505 (sd->csd[14] & 0x20)) {
506 sd->card_status |= LOCK_UNLOCK_FAILED;
507 return;
508 }
509 memset(sd->wp_groups, 0, sizeof(int) * (sd->size >>
510 (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT)));
511 sd->csd[14] &= ~0x10;
512 sd->card_status &= ~CARD_IS_LOCKED;
513 sd->pwd_len = 0;
514 /* Erasing the entire card here! */
515 printf("SD: Card force-erased by CMD42\n");
516 return;
517 }
518
519 if (sd->blk_len < 2 + pwd_len ||
520 pwd_len <= sd->pwd_len ||
521 pwd_len > sd->pwd_len + 16) {
522 sd->card_status |= LOCK_UNLOCK_FAILED;
523 return;
524 }
525
526 if (sd->pwd_len && memcmp(sd->pwd, sd->data + 2, sd->pwd_len)) {
527 sd->card_status |= LOCK_UNLOCK_FAILED;
528 return;
529 }
530
531 pwd_len -= sd->pwd_len;
532 if ((pwd_len && !set_pwd) ||
533 (clr_pwd && (set_pwd || lock)) ||
534 (lock && !sd->pwd_len && !set_pwd) ||
535 (!set_pwd && !clr_pwd &&
536 (((sd->card_status & CARD_IS_LOCKED) && lock) ||
537 (!(sd->card_status & CARD_IS_LOCKED) && !lock)))) {
538 sd->card_status |= LOCK_UNLOCK_FAILED;
539 return;
540 }
541
542 if (set_pwd) {
543 memcpy(sd->pwd, sd->data + 2 + sd->pwd_len, pwd_len);
544 sd->pwd_len = pwd_len;
545 }
546
547 if (clr_pwd) {
548 sd->pwd_len = 0;
549 }
550
551 if (lock)
552 sd->card_status |= CARD_IS_LOCKED;
553 else
554 sd->card_status &= ~CARD_IS_LOCKED;
555 }
556
557 static sd_rsp_type_t sd_normal_command(SDState *sd,
558 struct sd_request_s req)
559 {
560 uint32_t rca = 0x0000;
561
562 if (sd_cmd_type[req.cmd] == sd_ac || sd_cmd_type[req.cmd] == sd_adtc)
563 rca = req.arg >> 16;
564
565 DPRINTF("CMD%d 0x%08x state %d\n", req.cmd, req.arg, sd->state);
566 switch (req.cmd) {
567 /* Basic commands (Class 0 and Class 1) */
568 case 0: /* CMD0: GO_IDLE_STATE */
569 switch (sd->state) {
570 case sd_inactive_state:
571 return sd_r0;
572
573 default:
574 sd->state = sd_idle_state;
575 sd_reset(sd, sd->bdrv);
576 return sd_r0;
577 }
578 break;
579
580 case 2: /* CMD2: ALL_SEND_CID */
581 switch (sd->state) {
582 case sd_ready_state:
583 sd->state = sd_identification_state;
584 return sd_r2_i;
585
586 default:
587 break;
588 }
589 break;
590
591 case 3: /* CMD3: SEND_RELATIVE_ADDR */
592 switch (sd->state) {
593 case sd_identification_state:
594 case sd_standby_state:
595 sd->state = sd_standby_state;
596 sd_set_rca(sd);
597 return sd_r6;
598
599 default:
600 break;
601 }
602 break;
603
604 case 4: /* CMD4: SEND_DSR */
605 switch (sd->state) {
606 case sd_standby_state:
607 break;
608
609 default:
610 break;
611 }
612 break;
613
614 case 6: /* CMD6: SWITCH_FUNCTION */
615 switch (sd->mode) {
616 case sd_data_transfer_mode:
617 sd_function_switch(sd, req.arg);
618 sd->state = sd_sendingdata_state;
619 sd->data_start = 0;
620 sd->data_offset = 0;
621 return sd_r1;
622
623 default:
624 break;
625 }
626 break;
627
628 case 7: /* CMD7: SELECT/DESELECT_CARD */
629 switch (sd->state) {
630 case sd_standby_state:
631 if (sd->rca != rca)
632 return sd_r0;
633
634 sd->state = sd_transfer_state;
635 return sd_r1b;
636
637 case sd_transfer_state:
638 case sd_sendingdata_state:
639 if (sd->rca == rca)
640 break;
641
642 sd->state = sd_standby_state;
643 return sd_r1b;
644
645 case sd_disconnect_state:
646 if (sd->rca != rca)
647 return sd_r0;
648
649 sd->state = sd_programming_state;
650 return sd_r1b;
651
652 case sd_programming_state:
653 if (sd->rca == rca)
654 break;
655
656 sd->state = sd_disconnect_state;
657 return sd_r1b;
658
659 default:
660 break;
661 }
662 break;
663
664 case 9: /* CMD9: SEND_CSD */
665 switch (sd->state) {
666 case sd_standby_state:
667 if (sd->rca != rca)
668 return sd_r0;
669
670 return sd_r2_s;
671
672 default:
673 break;
674 }
675 break;
676
677 case 10: /* CMD10: SEND_CID */
678 switch (sd->state) {
679 case sd_standby_state:
680 if (sd->rca != rca)
681 return sd_r0;
682
683 return sd_r2_i;
684
685 default:
686 break;
687 }
688 break;
689
690 case 11: /* CMD11: READ_DAT_UNTIL_STOP */
691 switch (sd->state) {
692 case sd_transfer_state:
693 sd->state = sd_sendingdata_state;
694 sd->data_start = req.arg;
695 sd->data_offset = 0;
696
697 if (sd->data_start + sd->blk_len > sd->size)
698 sd->card_status |= ADDRESS_ERROR;
699 return sd_r0;
700
701 default:
702 break;
703 }
704 break;
705
706 case 12: /* CMD12: STOP_TRANSMISSION */
707 switch (sd->state) {
708 case sd_sendingdata_state:
709 sd->state = sd_transfer_state;
710 return sd_r1b;
711
712 case sd_receivingdata_state:
713 sd->state = sd_programming_state;
714 /* Bzzzzzzztt .... Operation complete. */
715 sd->state = sd_transfer_state;
716 return sd_r1b;
717
718 default:
719 break;
720 }
721 break;
722
723 case 13: /* CMD13: SEND_STATUS */
724 switch (sd->mode) {
725 case sd_data_transfer_mode:
726 if (sd->rca != rca)
727 return sd_r0;
728
729 return sd_r1;
730
731 default:
732 break;
733 }
734 break;
735
736 case 15: /* CMD15: GO_INACTIVE_STATE */
737 switch (sd->mode) {
738 case sd_data_transfer_mode:
739 if (sd->rca != rca)
740 return sd_r0;
741
742 sd->state = sd_inactive_state;
743 return sd_r0;
744
745 default:
746 break;
747 }
748 break;
749
750 /* Block read commands (Classs 2) */
751 case 16: /* CMD16: SET_BLOCKLEN */
752 switch (sd->state) {
753 case sd_transfer_state:
754 if (req.arg > (1 << HWBLOCK_SHIFT))
755 sd->card_status |= BLOCK_LEN_ERROR;
756 else
757 sd->blk_len = req.arg;
758
759 return sd_r1;
760
761 default:
762 break;
763 }
764 break;
765
766 case 17: /* CMD17: READ_SINGLE_BLOCK */
767 switch (sd->state) {
768 case sd_transfer_state:
769 sd->state = sd_sendingdata_state;
770 sd->data_start = req.arg;
771 sd->data_offset = 0;
772
773 if (sd->data_start + sd->blk_len > sd->size)
774 sd->card_status |= ADDRESS_ERROR;
775 return sd_r1;
776
777 default:
778 break;
779 }
780 break;
781
782 case 18: /* CMD18: READ_MULTIPLE_BLOCK */
783 switch (sd->state) {
784 case sd_transfer_state:
785 sd->state = sd_sendingdata_state;
786 sd->data_start = req.arg;
787 sd->data_offset = 0;
788
789 if (sd->data_start + sd->blk_len > sd->size)
790 sd->card_status |= ADDRESS_ERROR;
791 return sd_r1;
792
793 default:
794 break;
795 }
796 break;
797
798 /* Block write commands (Class 4) */
799 case 24: /* CMD24: WRITE_SINGLE_BLOCK */
800 switch (sd->state) {
801 case sd_transfer_state:
802 sd->state = sd_receivingdata_state;
803 sd->data_start = req.arg;
804 sd->data_offset = 0;
805 sd->blk_written = 0;
806
807 if (sd->data_start + sd->blk_len > sd->size)
808 sd->card_status |= ADDRESS_ERROR;
809 if (sd_wp_addr(sd, sd->data_start))
810 sd->card_status |= WP_VIOLATION;
811 if (sd->csd[14] & 0x30)
812 sd->card_status |= WP_VIOLATION;
813 return sd_r1;
814
815 default:
816 break;
817 }
818 break;
819
820 case 25: /* CMD25: WRITE_MULTIPLE_BLOCK */
821 switch (sd->state) {
822 case sd_transfer_state:
823 sd->state = sd_receivingdata_state;
824 sd->data_start = req.arg;
825 sd->data_offset = 0;
826 sd->blk_written = 0;
827
828 if (sd->data_start + sd->blk_len > sd->size)
829 sd->card_status |= ADDRESS_ERROR;
830 if (sd_wp_addr(sd, sd->data_start))
831 sd->card_status |= WP_VIOLATION;
832 if (sd->csd[14] & 0x30)
833 sd->card_status |= WP_VIOLATION;
834 return sd_r1;
835
836 default:
837 break;
838 }
839 break;
840
841 case 26: /* CMD26: PROGRAM_CID */
842 switch (sd->state) {
843 case sd_transfer_state:
844 sd->state = sd_receivingdata_state;
845 sd->data_start = 0;
846 sd->data_offset = 0;
847 return sd_r1;
848
849 default:
850 break;
851 }
852 break;
853
854 case 27: /* CMD27: PROGRAM_CSD */
855 switch (sd->state) {
856 case sd_transfer_state:
857 sd->state = sd_receivingdata_state;
858 sd->data_start = 0;
859 sd->data_offset = 0;
860 return sd_r1;
861
862 default:
863 break;
864 }
865 break;
866
867 /* Write protection (Class 6) */
868 case 28: /* CMD28: SET_WRITE_PROT */
869 switch (sd->state) {
870 case sd_transfer_state:
871 if (req.arg >= sd->size) {
872 sd->card_status = ADDRESS_ERROR;
873 return sd_r1b;
874 }
875
876 sd->state = sd_programming_state;
877 sd->wp_groups[req.arg >> (HWBLOCK_SHIFT +
878 SECTOR_SHIFT + WPGROUP_SHIFT)] = 1;
879 /* Bzzzzzzztt .... Operation complete. */
880 sd->state = sd_transfer_state;
881 return sd_r1b;
882
883 default:
884 break;
885 }
886 break;
887
888 case 29: /* CMD29: CLR_WRITE_PROT */
889 switch (sd->state) {
890 case sd_transfer_state:
891 if (req.arg >= sd->size) {
892 sd->card_status = ADDRESS_ERROR;
893 return sd_r1b;
894 }
895
896 sd->state = sd_programming_state;
897 sd->wp_groups[req.arg >> (HWBLOCK_SHIFT +
898 SECTOR_SHIFT + WPGROUP_SHIFT)] = 0;
899 /* Bzzzzzzztt .... Operation complete. */
900 sd->state = sd_transfer_state;
901 return sd_r1b;
902
903 default:
904 break;
905 }
906 break;
907
908 case 30: /* CMD30: SEND_WRITE_PROT */
909 switch (sd->state) {
910 case sd_transfer_state:
911 sd->state = sd_sendingdata_state;
912 *(uint32_t *) sd->data = sd_wpbits(sd, req.arg);
913 sd->data_start = req.arg;
914 sd->data_offset = 0;
915 return sd_r1b;
916
917 default:
918 break;
919 }
920 break;
921
922 /* Erase commands (Class 5) */
923 case 32: /* CMD32: ERASE_WR_BLK_START */
924 switch (sd->state) {
925 case sd_transfer_state:
926 sd->erase_start = req.arg;
927 return sd_r1;
928
929 default:
930 break;
931 }
932 break;
933
934 case 33: /* CMD33: ERASE_WR_BLK_END */
935 switch (sd->state) {
936 case sd_transfer_state:
937 sd->erase_end = req.arg;
938 return sd_r1;
939
940 default:
941 break;
942 }
943 break;
944
945 case 38: /* CMD38: ERASE */
946 switch (sd->state) {
947 case sd_transfer_state:
948 if (sd->csd[14] & 0x30) {
949 sd->card_status |= WP_VIOLATION;
950 return sd_r1b;
951 }
952
953 sd->state = sd_programming_state;
954 sd_erase(sd);
955 /* Bzzzzzzztt .... Operation complete. */
956 sd->state = sd_transfer_state;
957 return sd_r1b;
958
959 default:
960 break;
961 }
962 break;
963
964 /* Lock card commands (Class 7) */
965 case 42: /* CMD42: LOCK_UNLOCK */
966 switch (sd->state) {
967 case sd_transfer_state:
968 sd->state = sd_receivingdata_state;
969 sd->data_start = 0;
970 sd->data_offset = 0;
971 return sd_r1;
972
973 default:
974 break;
975 }
976 break;
977
978 /* Application specific commands (Class 8) */
979 case 55: /* CMD55: APP_CMD */
980 if (sd->rca != rca)
981 return sd_r0;
982
983 sd->card_status |= APP_CMD;
984 return sd_r1;
985
986 case 56: /* CMD56: GEN_CMD */
987 printf("SD: GEN_CMD 0x%08x\n", req.arg);
988
989 switch (sd->state) {
990 case sd_transfer_state:
991 sd->data_offset = 0;
992 if (req.arg & 1)
993 sd->state = sd_sendingdata_state;
994 else
995 sd->state = sd_receivingdata_state;
996 return sd_r1;
997
998 default:
999 break;
1000 }
1001 break;
1002
1003 default:
1004 sd->card_status |= ILLEGAL_COMMAND;
1005
1006 printf("SD: Unknown CMD%i\n", req.cmd);
1007 return sd_r0;
1008 }
1009
1010 sd->card_status |= ILLEGAL_COMMAND;
1011 printf("SD: CMD%i in a wrong state\n", req.cmd);
1012 return sd_r0;
1013 }
1014
1015 static sd_rsp_type_t sd_app_command(SDState *sd,
1016 struct sd_request_s req) {
1017 uint32_t rca;
1018
1019 if (sd_cmd_type[req.cmd] == sd_ac || sd_cmd_type[req.cmd] == sd_adtc)
1020 rca = req.arg >> 16;
1021
1022 DPRINTF("ACMD%d 0x%08x\n", req.cmd, req.arg);
1023 switch (req.cmd) {
1024 case 6: /* ACMD6: SET_BUS_WIDTH */
1025 switch (sd->state) {
1026 case sd_transfer_state:
1027 sd->sd_status[0] &= 0x3f;
1028 sd->sd_status[0] |= (req.arg & 0x03) << 6;
1029 return sd_r1;
1030
1031 default:
1032 break;
1033 }
1034 break;
1035
1036 case 13: /* ACMD13: SD_STATUS */
1037 switch (sd->state) {
1038 case sd_transfer_state:
1039 sd->data_start = 0;
1040 sd->data_offset = 0;
1041 return sd_r1;
1042
1043 default:
1044 break;
1045 }
1046 break;
1047
1048 case 22: /* ACMD22: SEND_NUM_WR_BLOCKS */
1049 switch (sd->state) {
1050 case sd_transfer_state:
1051 *(uint32_t *) sd->data = sd->blk_written;
1052
1053 sd->data_start = 0;
1054 sd->data_offset = 0;
1055 return sd_r1;
1056
1057 default:
1058 break;
1059 }
1060 break;
1061
1062 case 23: /* ACMD23: SET_WR_BLK_ERASE_COUNT */
1063 switch (sd->state) {
1064 case sd_transfer_state:
1065 return sd_r1;
1066
1067 default:
1068 break;
1069 }
1070 break;
1071
1072 case 41: /* ACMD41: SD_APP_OP_COND */
1073 switch (sd->state) {
1074 case sd_idle_state:
1075 /* We accept any voltage. 10000 V is nothing. */
1076 if (req.arg)
1077 sd->state = sd_ready_state;
1078
1079 return sd_r3;
1080
1081 default:
1082 break;
1083 }
1084 break;
1085
1086 case 42: /* ACMD42: SET_CLR_CARD_DETECT */
1087 switch (sd->state) {
1088 case sd_transfer_state:
1089 /* Bringing in the 50KOhm pull-up resistor... Done. */
1090 return sd_r1;
1091
1092 default:
1093 break;
1094 }
1095 break;
1096
1097 case 51: /* ACMD51: SEND_SCR */
1098 switch (sd->state) {
1099 case sd_transfer_state:
1100 sd->state = sd_sendingdata_state;
1101 sd->data_start = 0;
1102 sd->data_offset = 0;
1103 return sd_r1;
1104
1105 default:
1106 break;
1107 }
1108 break;
1109
1110 default:
1111 /* Fall back to standard commands. */
1112 sd->card_status &= ~APP_CMD;
1113 return sd_normal_command(sd, req);
1114 }
1115
1116 printf("SD: ACMD%i in a wrong state\n", req.cmd);
1117 return sd_r0;
1118 }
1119
1120 int sd_do_command(SDState *sd, struct sd_request_s *req,
1121 uint8_t *response) {
1122 uint32_t last_status = sd->card_status;
1123 sd_rsp_type_t rtype;
1124 int rsplen;
1125
1126 if (!bdrv_is_inserted(sd->bdrv)) {
1127 return 0;
1128 }
1129
1130 if (sd_req_crc_validate(req)) {
1131 sd->card_status &= ~COM_CRC_ERROR;
1132 return 0;
1133 }
1134
1135 sd->card_status &= ~CARD_STATUS_B;
1136 sd_set_status(sd);
1137
1138 if (last_status & CARD_IS_LOCKED)
1139 if (((last_status & APP_CMD) &&
1140 req->cmd == 41) ||
1141 (!(last_status & APP_CMD) &&
1142 (sd_cmd_class[req->cmd] == 0 ||
1143 sd_cmd_class[req->cmd] == 7 ||
1144 req->cmd == 16 || req->cmd == 55))) {
1145 sd->card_status |= ILLEGAL_COMMAND;
1146 printf("SD: Card is locked\n");
1147 return 0;
1148 }
1149
1150 if (last_status & APP_CMD) {
1151 rtype = sd_app_command(sd, *req);
1152 sd->card_status &= ~APP_CMD;
1153 } else
1154 rtype = sd_normal_command(sd, *req);
1155
1156 sd->current_cmd = req->cmd;
1157
1158 switch (rtype) {
1159 case sd_r1:
1160 case sd_r1b:
1161 sd_response_r1_make(sd, response, last_status);
1162 rsplen = 4;
1163 break;
1164
1165 case sd_r2_i:
1166 memcpy(response, sd->cid, sizeof(sd->cid));
1167 response[7] |= 1;
1168 rsplen = 16;
1169 break;
1170
1171 case sd_r2_s:
1172 memcpy(response, sd->csd, sizeof(sd->csd));
1173 response[7] |= 1;
1174 rsplen = 16;
1175 break;
1176
1177 case sd_r3:
1178 sd_response_r3_make(sd, response);
1179 rsplen = 4;
1180 break;
1181
1182 case sd_r6:
1183 sd_response_r6_make(sd, response);
1184 rsplen = 4;
1185 break;
1186
1187 case sd_r0:
1188 default:
1189 rsplen = 0;
1190 break;
1191 }
1192
1193 if (sd->card_status & ILLEGAL_COMMAND)
1194 rsplen = 0;
1195
1196 #ifdef DEBUG_SD
1197 if (rsplen) {
1198 int i;
1199 DPRINTF("Response:");
1200 for (i = 0; i < rsplen; i++)
1201 printf(" %02x", response[i]);
1202 printf(" state %d\n", sd->state);
1203 } else {
1204 DPRINTF("No response %d\n", sd->state);
1205 }
1206 #endif
1207
1208 return rsplen;
1209 }
1210
1211 /* No real need for 64 bit addresses here */
1212 static void sd_blk_read(BlockDriverState *bdrv,
1213 void *data, uint32_t addr, uint32_t len)
1214 {
1215 uint8_t buf[512];
1216 uint32_t end = addr + len;
1217
1218 if (!bdrv || bdrv_read(bdrv, addr >> 9, buf, 1) == -1) {
1219 printf("sd_blk_read: read error on host side\n");
1220 return;
1221 }
1222
1223 if (end > (addr & ~511) + 512) {
1224 memcpy(data, buf + (addr & 511), 512 - (addr & 511));
1225
1226 if (bdrv_read(bdrv, end >> 9, buf, 1) == -1) {
1227 printf("sd_blk_read: read error on host side\n");
1228 return;
1229 }
1230 memcpy(data + 512 - (addr & 511), buf, end & 511);
1231 } else
1232 memcpy(data, buf + (addr & 511), len);
1233 }
1234
1235 static void sd_blk_write(BlockDriverState *bdrv,
1236 void *data, uint32_t addr, uint32_t len)
1237 {
1238 uint8_t buf[512];
1239 uint32_t end = addr + len;
1240
1241 if ((addr & 511) || len < 512)
1242 if (!bdrv || bdrv_read(bdrv, addr >> 9, buf, 1) == -1) {
1243 printf("sd_blk_write: read error on host side\n");
1244 return;
1245 }
1246
1247 if (end > (addr & ~511) + 512) {
1248 memcpy(buf + (addr & 511), data, 512 - (addr & 511));
1249 if (bdrv_write(bdrv, addr >> 9, buf, 1) == -1) {
1250 printf("sd_blk_write: write error on host side\n");
1251 return;
1252 }
1253
1254 if (bdrv_read(bdrv, end >> 9, buf, 1) == -1) {
1255 printf("sd_blk_write: read error on host side\n");
1256 return;
1257 }
1258 memcpy(buf, data + 512 - (addr & 511), end & 511);
1259 if (bdrv_write(bdrv, end >> 9, buf, 1) == -1)
1260 printf("sd_blk_write: write error on host side\n");
1261 } else {
1262 memcpy(buf + (addr & 511), data, len);
1263 if (!bdrv || bdrv_write(bdrv, addr >> 9, buf, 1) == -1)
1264 printf("sd_blk_write: write error on host side\n");
1265 }
1266 }
1267
1268 #define BLK_READ_BLOCK(a, len) sd_blk_read(sd->bdrv, sd->data, a, len)
1269 #define BLK_WRITE_BLOCK(a, len) sd_blk_write(sd->bdrv, sd->data, a, len)
1270 #define APP_READ_BLOCK(a, len) memset(sd->data, 0xec, len)
1271 #define APP_WRITE_BLOCK(a, len)
1272
1273 void sd_write_data(SDState *sd, uint8_t value)
1274 {
1275 int i;
1276
1277 if (!sd->bdrv || !bdrv_is_inserted(sd->bdrv))
1278 return;
1279
1280 if (sd->state != sd_receivingdata_state) {
1281 printf("sd_write_data: not in Receiving-Data state\n");
1282 return;
1283 }
1284
1285 if (sd->card_status & (ADDRESS_ERROR | WP_VIOLATION))
1286 return;
1287
1288 switch (sd->current_cmd) {
1289 case 24: /* CMD24: WRITE_SINGLE_BLOCK */
1290 sd->data[sd->data_offset ++] = value;
1291 if (sd->data_offset >= sd->blk_len) {
1292 /* TODO: Check CRC before committing */
1293 sd->state = sd_programming_state;
1294 BLK_WRITE_BLOCK(sd->data_start, sd->data_offset);
1295 sd->blk_written ++;
1296 sd->csd[14] |= 0x40;
1297 /* Bzzzzzzztt .... Operation complete. */
1298 sd->state = sd_transfer_state;
1299 }
1300 break;
1301
1302 case 25: /* CMD25: WRITE_MULTIPLE_BLOCK */
1303 sd->data[sd->data_offset ++] = value;
1304 if (sd->data_offset >= sd->blk_len) {
1305 /* TODO: Check CRC before committing */
1306 sd->state = sd_programming_state;
1307 BLK_WRITE_BLOCK(sd->data_start, sd->data_offset);
1308 sd->blk_written ++;
1309 sd->data_start += sd->blk_len;
1310 sd->data_offset = 0;
1311 if (sd->data_start + sd->blk_len > sd->size) {
1312 sd->card_status |= ADDRESS_ERROR;
1313 break;
1314 }
1315 if (sd_wp_addr(sd, sd->data_start)) {
1316 sd->card_status |= WP_VIOLATION;
1317 break;
1318 }
1319 sd->csd[14] |= 0x40;
1320
1321 /* Bzzzzzzztt .... Operation complete. */
1322 sd->state = sd_receivingdata_state;
1323 }
1324 break;
1325
1326 case 26: /* CMD26: PROGRAM_CID */
1327 sd->data[sd->data_offset ++] = value;
1328 if (sd->data_offset >= sizeof(sd->cid)) {
1329 /* TODO: Check CRC before committing */
1330 sd->state = sd_programming_state;
1331 for (i = 0; i < sizeof(sd->cid); i ++)
1332 if ((sd->cid[i] | 0x00) != sd->data[i])
1333 sd->card_status |= CID_CSD_OVERWRITE;
1334
1335 if (!(sd->card_status & CID_CSD_OVERWRITE))
1336 for (i = 0; i < sizeof(sd->cid); i ++) {
1337 sd->cid[i] |= 0x00;
1338 sd->cid[i] &= sd->data[i];
1339 }
1340 /* Bzzzzzzztt .... Operation complete. */
1341 sd->state = sd_transfer_state;
1342 }
1343 break;
1344
1345 case 27: /* CMD27: PROGRAM_CSD */
1346 sd->data[sd->data_offset ++] = value;
1347 if (sd->data_offset >= sizeof(sd->csd)) {
1348 /* TODO: Check CRC before committing */
1349 sd->state = sd_programming_state;
1350 for (i = 0; i < sizeof(sd->csd); i ++)
1351 if ((sd->csd[i] | sd_csd_rw_mask[i]) !=
1352 (sd->data[i] | sd_csd_rw_mask[i]))
1353 sd->card_status |= CID_CSD_OVERWRITE;
1354
1355 /* Copy flag (OTP) & Permanent write protect */
1356 if (sd->csd[14] & ~sd->data[14] & 0x60)
1357 sd->card_status |= CID_CSD_OVERWRITE;
1358
1359 if (!(sd->card_status & CID_CSD_OVERWRITE))
1360 for (i = 0; i < sizeof(sd->csd); i ++) {
1361 sd->csd[i] |= sd_csd_rw_mask[i];
1362 sd->csd[i] &= sd->data[i];
1363 }
1364 /* Bzzzzzzztt .... Operation complete. */
1365 sd->state = sd_transfer_state;
1366 }
1367 break;
1368
1369 case 42: /* CMD42: LOCK_UNLOCK */
1370 sd->data[sd->data_offset ++] = value;
1371 if (sd->data_offset >= sd->blk_len) {
1372 /* TODO: Check CRC before committing */
1373 sd->state = sd_programming_state;
1374 sd_lock_command(sd);
1375 /* Bzzzzzzztt .... Operation complete. */
1376 sd->state = sd_transfer_state;
1377 }
1378 break;
1379
1380 case 56: /* CMD56: GEN_CMD */
1381 sd->data[sd->data_offset ++] = value;
1382 if (sd->data_offset >= sd->blk_len) {
1383 APP_WRITE_BLOCK(sd->data_start, sd->data_offset);
1384 sd->state = sd_transfer_state;
1385 }
1386 break;
1387
1388 default:
1389 printf("sd_write_data: unknown command\n");
1390 break;
1391 }
1392 }
1393
1394 uint8_t sd_read_data(SDState *sd)
1395 {
1396 /* TODO: Append CRCs */
1397 uint8_t ret;
1398
1399 if (!sd->bdrv || !bdrv_is_inserted(sd->bdrv))
1400 return 0x00;
1401
1402 if (sd->state != sd_sendingdata_state) {
1403 printf("sd_read_data: not in Sending-Data state\n");
1404 return 0x00;
1405 }
1406
1407 if (sd->card_status & (ADDRESS_ERROR | WP_VIOLATION))
1408 return 0x00;
1409
1410 switch (sd->current_cmd) {
1411 case 6: /* CMD6: SWITCH_FUNCTION */
1412 ret = sd->data[sd->data_offset ++];
1413
1414 if (sd->data_offset >= 64)
1415 sd->state = sd_transfer_state;
1416 break;
1417
1418 case 11: /* CMD11: READ_DAT_UNTIL_STOP */
1419 if (sd->data_offset == 0)
1420 BLK_READ_BLOCK(sd->data_start, sd->blk_len);
1421 ret = sd->data[sd->data_offset ++];
1422
1423 if (sd->data_offset >= sd->blk_len) {
1424 sd->data_start += sd->blk_len;
1425 sd->data_offset = 0;
1426 if (sd->data_start + sd->blk_len > sd->size) {
1427 sd->card_status |= ADDRESS_ERROR;
1428 break;
1429 }
1430 }
1431 break;
1432
1433 case 13: /* ACMD13: SD_STATUS */
1434 ret = sd->sd_status[sd->data_offset ++];
1435
1436 if (sd->data_offset >= sizeof(sd->sd_status))
1437 sd->state = sd_transfer_state;
1438 break;
1439
1440 case 17: /* CMD17: READ_SINGLE_BLOCK */
1441 if (sd->data_offset == 0)
1442 BLK_READ_BLOCK(sd->data_start, sd->blk_len);
1443 ret = sd->data[sd->data_offset ++];
1444
1445 if (sd->data_offset >= sd->blk_len)
1446 sd->state = sd_transfer_state;
1447 break;
1448
1449 case 18: /* CMD18: READ_MULTIPLE_BLOCK */
1450 if (sd->data_offset == 0)
1451 BLK_READ_BLOCK(sd->data_start, sd->blk_len);
1452 ret = sd->data[sd->data_offset ++];
1453
1454 if (sd->data_offset >= sd->blk_len) {
1455 sd->data_start += sd->blk_len;
1456 sd->data_offset = 0;
1457 if (sd->data_start + sd->blk_len > sd->size) {
1458 sd->card_status |= ADDRESS_ERROR;
1459 break;
1460 }
1461 }
1462 break;
1463
1464 case 22: /* ACMD22: SEND_NUM_WR_BLOCKS */
1465 ret = sd->data[sd->data_offset ++];
1466
1467 if (sd->data_offset >= 4)
1468 sd->state = sd_transfer_state;
1469 break;
1470
1471 case 30: /* CMD30: SEND_WRITE_PROT */
1472 ret = sd->data[sd->data_offset ++];
1473
1474 if (sd->data_offset >= 4)
1475 sd->state = sd_transfer_state;
1476 break;
1477
1478 case 51: /* ACMD51: SEND_SCR */
1479 ret = sd->scr[sd->data_offset ++];
1480
1481 if (sd->data_offset >= sizeof(sd->scr))
1482 sd->state = sd_transfer_state;
1483 break;
1484
1485 case 56: /* CMD56: GEN_CMD */
1486 if (sd->data_offset == 0)
1487 APP_READ_BLOCK(sd->data_start, sd->blk_len);
1488 ret = sd->data[sd->data_offset ++];
1489
1490 if (sd->data_offset >= sd->blk_len)
1491 sd->state = sd_transfer_state;
1492 break;
1493
1494 default:
1495 printf("sd_read_data: unknown command\n");
1496 return 0x00;
1497 }
1498
1499 return ret;
1500 }
1501
1502 int sd_data_ready(SDState *sd)
1503 {
1504 return sd->state == sd_sendingdata_state;
1505 }
Samsung s3c2440 and arm920t support for the mini2440 dev board