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