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