← Back to branch summary

~ubuntu-branches/ubuntu/trusty/qemu/trusty

« back to all changes in this revision

Viewing changes to debian/patches/linaro/0004-hw-sd.c-Add-MMC-emulation-support.patch

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2014-02-04 12:13:08 UTC
  • mfrom: (10.1.45 sid)
  • Revision ID: package-import@ubuntu.com-20140204121308-1xq92lrfs75agw2g
Tags: 1.7.0+dfsg-3ubuntu1~ppa1
* Merge 1.7.0+dfsg-3 from debian.  Remaining changes:
  - debian/patches/ubuntu:
    * expose-vmx_qemu64cpu.patch
    * linaro (omap3) and arm64 patches
    * ubuntu/target-ppc-add-stubs-for-kvm-breakpoints: fix FTBFS
      on ppc
    * ubuntu/CVE-2013-4377.patch: fix denial of service via virtio
  - debian/qemu-system-x86.modprobe: set kvm_intel nested=1 options
  - debian/control:
    * add arm64 to Architectures
    * add qemu-common and qemu-system-aarch64 packages
  - debian/qemu-system-common.install: add debian/tmp/usr/lib
  - debian/qemu-system-common.preinst: add kvm group
  - debian/qemu-system-common.postinst: remove acl placed by udev,
    and add udevadm trigger.
  - qemu-system-x86.links: add eepro100.rom, remove pxe-virtio,
    pxe-e1000 and pxe-rtl8139.
  - add qemu-system-x86.qemu-kvm.upstart and .default
  - qemu-user-static.postinst-in: remove arm64 binfmt
  - debian/rules:
    * allow parallel build
    * add aarch64 to system_targets and sys_systems
    * add qemu-kvm-spice links
    * install qemu-system-x86.modprobe
  - add debian/qemu-system-common.links for OVMF.fd link
* Remove kvm-img, kvm-nbd, kvm-ifup and kvm-ifdown symlinks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/patches/linaro/0004-hw-sd.c-Add-MMC-emulation-support.patch
1
 
From 5ab88d616886f4903bcd32857cc7fb5528286686 Mon Sep 17 00:00:00 2001
2
 
From: =?UTF-8?q?Juha=20Riihim=C3=A4ki?= <juha.riihimaki@nokia.com>
3
 
Date: Mon, 18 Feb 2013 16:58:23 +0000
4
 
Subject: [PATCH 04/70] hw/sd.c: Add MMC emulation support
5
 
 
6
 
This patch is basically just adding actual implementation
7
 
of the mmc flag. It also has a few minor cleanups like
8
 
printf->fprintf (but should be DPRINTF)
9
 
---
10
 
 hw/sd/sd.c      | 275 +++++++++++++++++++++++++++++++++++++++++++++++---------
11
 
 include/hw/sd.h |   1 +
12
 
 2 files changed, 233 insertions(+), 43 deletions(-)
13
 
 
14
 
diff --git a/hw/sd/sd.c b/hw/sd/sd.c
15
 
index ce7f57f..3ec2c0d 100644
16
 
--- a/hw/sd/sd.c
17
 
+++ b/hw/sd/sd.c
18
 
@@ -4,6 +4,7 @@
19
 
  *
20
 
  * Copyright (c) 2006 Andrzej Zaborowski  <balrog@zabor.org>
21
 
  * Copyright (c) 2007 CodeSourcery
22
 
+ * Copyright (c) 2009 Nokia Corporation
23
 
  *
24
 
  * Redistribution and use in source and binary forms, with or without
25
 
  * modification, are permitted provided that the following conditions
26
 
@@ -83,6 +84,7 @@ struct SDState {
27
 
     uint8_t scr[8];
28
 
     uint8_t cid[16];
29
 
     uint8_t csd[16];
30
 
+    uint8_t ext_csd[512];
31
 
     uint16_t rca;
32
 
     uint32_t card_status;
33
 
     uint8_t sd_status[64];
34
 
@@ -98,7 +100,7 @@ struct SDState {
35
 
     uint32_t pwd_len;
36
 
     uint8_t function_group[6];
37
 
 
38
 
-    bool spi;
39
 
+    bool spi, mmc;
40
 
     uint8_t current_cmd;
41
 
     /* True if we will handle the next command as an ACMD. Note that this does
42
 
      * *not* track the APP_CMD status bit!
43
 
@@ -114,6 +116,7 @@ struct SDState {
44
 
     uint8_t *buf;
45
 
 
46
 
     bool enable;
47
 
+    int buswidth, highspeed;
48
 
 };
49
 
 
50
 
 static void sd_set_mode(SDState *sd)
51
 
@@ -141,9 +144,9 @@ static void sd_set_mode(SDState *sd)
52
 
 }
53
 
 
54
 
 static const sd_cmd_type_t sd_cmd_type[64] = {
55
 
-    sd_bc,   sd_none, sd_bcr,  sd_bcr,  sd_none, sd_none, sd_none, sd_ac,
56
 
+    sd_bc,   sd_none, sd_bcr,  sd_bcr,  sd_none, sd_ac,   sd_none, sd_ac,
57
 
     sd_bcr,  sd_ac,   sd_ac,   sd_adtc, sd_ac,   sd_ac,   sd_none, sd_ac,
58
 
-    sd_ac,   sd_adtc, sd_adtc, sd_none, sd_none, sd_none, sd_none, sd_none,
59
 
+    sd_ac,   sd_adtc, sd_adtc, sd_none, sd_adtc, sd_none, sd_none, sd_adtc,
60
 
     sd_adtc, sd_adtc, sd_adtc, sd_adtc, sd_ac,   sd_ac,   sd_adtc, sd_none,
61
 
     sd_ac,   sd_ac,   sd_none, sd_none, sd_none, sd_none, sd_ac,   sd_none,
62
 
     sd_none, sd_none, sd_bc,   sd_none, sd_none, sd_none, sd_none, sd_none,
63
 
@@ -210,8 +213,8 @@ static void sd_set_ocr(SDState *sd)
64
 
 
65
 
 static void sd_set_scr(SDState *sd)
66
 
 {
67
 
-    sd->scr[0] = 0x00;         /* SCR Structure */
68
 
-    sd->scr[1] = 0x2f;         /* SD Security Support */
69
 
+    sd->scr[0] = 0x00; /* SCR v1.0, SD spec v1.0/1.01 */
70
 
+    sd->scr[1] = 0x25; /* erase=0, SD security v1.01, 1bit/4bit bus width */
71
 
     sd->scr[2] = 0x00;
72
 
     sd->scr[3] = 0x00;
73
 
     sd->scr[4] = 0x00;
74
 
@@ -222,7 +225,7 @@ static void sd_set_scr(SDState *sd)
75
 
 
76
 
 #define MID    0xaa
77
 
 #define OID    "XY"
78
 
-#define PNM    "QEMU!"
79
 
+#define PNM    "QEMU!!"
80
 
 #define PRV    0x01
81
 
 #define MDT_YR 2006
82
 
 #define MDT_MON        2
83
 
@@ -237,14 +240,23 @@ static void sd_set_cid(SDState *sd)
84
 
     sd->cid[5] = PNM[2];
85
 
     sd->cid[6] = PNM[3];
86
 
     sd->cid[7] = PNM[4];
87
 
-    sd->cid[8] = PRV;          /* Fake product revision (PRV) */
88
 
+    if (sd->mmc) {
89
 
+        sd->cid[8] = PNM[5];
90
 
+    } else {
91
 
+        sd->cid[8] = PRV;              /* Fake product revision (PRV) */
92
 
+    }
93
 
     sd->cid[9] = 0xde;         /* Fake serial number (PSN) */
94
 
     sd->cid[10] = 0xad;
95
 
     sd->cid[11] = 0xbe;
96
 
     sd->cid[12] = 0xef;
97
 
-    sd->cid[13] = 0x00 |       /* Manufacture date (MDT) */
98
 
-        ((MDT_YR - 2000) / 10);
99
 
-    sd->cid[14] = ((MDT_YR % 10) << 4) | MDT_MON;
100
 
+    if (sd->mmc) {
101
 
+        sd->cid[13] = 0x55;
102
 
+        sd->cid[14] = ((MDT_MON) << 4) | (MDT_YR - 1997);
103
 
+    } else {
104
 
+        sd->cid[13] = 0x00 |   /* Manufacture date (MDT) */
105
 
+            ((MDT_YR - 2000) / 10);
106
 
+        sd->cid[14] = ((MDT_YR % 10) << 4) | MDT_MON;
107
 
+    }
108
 
     sd->cid[15] = (sd_crc7(sd->cid, 15) << 1) | 1;
109
 
 }
110
 
 
111
 
@@ -266,7 +278,12 @@ static void sd_set_csd(SDState *sd, uint64_t size)
112
 
     uint32_t wpsize = (1 << (WPGROUP_SHIFT + 1)) - 1;
113
 
 
114
 
     if (size <= 0x40000000) {  /* Standard Capacity SD */
115
 
-        sd->csd[0] = 0x00;     /* CSD structure */
116
 
+        if (sd->mmc) {
117
 
+            sd->csd[0] = 0x80 | /* CSD structure: v1.2 */
118
 
+                         0x0c;  /* MMC v3.x */
119
 
+        } else {
120
 
+            sd->csd[0] = 0x00;  /* CSD structure: v0 */
121
 
+        }
122
 
         sd->csd[1] = 0x26;     /* Data read access-time-1 */
123
 
         sd->csd[2] = 0x00;     /* Data read access-time-2 */
124
 
         sd->csd[3] = 0x5a;     /* Max. data transfer rate */
125
 
@@ -292,25 +309,52 @@ static void sd_set_csd(SDState *sd, uint64_t size)
126
 
         sd->csd[14] = 0x00;    /* File format group */
127
 
         sd->csd[15] = (sd_crc7(sd->csd, 15) << 1) | 1;
128
 
     } else {                   /* SDHC */
129
 
-        size /= 512 * 1024;
130
 
-        size -= 1;
131
 
-        sd->csd[0] = 0x40;
132
 
+        if (sd->mmc) {
133
 
+            sd->csd[0] = 0x90; /* CSD structure v1.2, MMC v4.0/4.1 */
134
 
+        } else {
135
 
+            sd->csd[0] = 0x40; /* CSD structure v1 */
136
 
+        }
137
 
         sd->csd[1] = 0x0e;
138
 
         sd->csd[2] = 0x00;
139
 
         sd->csd[3] = 0x32;
140
 
         sd->csd[4] = 0x5b;
141
 
         sd->csd[5] = 0x59;
142
 
-        sd->csd[6] = 0x00;
143
 
-        sd->csd[7] = (size >> 16) & 0xff;
144
 
-        sd->csd[8] = (size >> 8) & 0xff;
145
 
-        sd->csd[9] = (size & 0xff);
146
 
-        sd->csd[10] = 0x7f;
147
 
+        if (sd->mmc) {
148
 
+            sd->csd[6] = 0x03;
149
 
+            sd->csd[7] = 0xff;
150
 
+            sd->csd[8] = 0xff;
151
 
+            sd->csd[9] = 0xff;
152
 
+            sd->csd[10] = 0xff;
153
 
+        } else {
154
 
+            size /= 512 * 1024;
155
 
+            size -= 1;
156
 
+            sd->csd[6] = 0x00;
157
 
+            sd->csd[7] = (size >> 16) & 0xff;
158
 
+            sd->csd[8] = (size >> 8) & 0xff;
159
 
+            sd->csd[9] = (size & 0xff);
160
 
+            sd->csd[10] = 0x7f;
161
 
+        }
162
 
         sd->csd[11] = 0x80;
163
 
         sd->csd[12] = 0x0a;
164
 
         sd->csd[13] = 0x40;
165
 
         sd->csd[14] = 0x00;
166
 
         sd->csd[15] = 0x00;
167
 
         sd->ocr |= 1 << 30;     /* High Capacity SD Memory Card */
168
 
+        if (sd->mmc) {
169
 
+            size /= 512;
170
 
+            sd->buswidth = 1; /* 4bit mode */
171
 
+            sd->highspeed = 0;
172
 
+            memset(sd->ext_csd, 0, 512);
173
 
+            sd->ext_csd[183] = sd->buswidth;
174
 
+            sd->ext_csd[185] = sd->highspeed;
175
 
+            sd->ext_csd[192] = 0x03; /* EXT_CSD v3 */
176
 
+            sd->ext_csd[196] = 0x03; /* supports 26MHz and 52MHz */
177
 
+            sd->ext_csd[212] = (size & 0xff);
178
 
+            sd->ext_csd[213] = (size >> 8) & 0xff;
179
 
+            sd->ext_csd[214] = (size >> 16) & 0xff;
180
 
+            sd->ext_csd[215] = (size >> 24) & 0xff;
181
 
+            sd->ext_csd[217] = 0x00; /* sleep/awake timeout */
182
 
+        }
183
 
     }
184
 
 }
185
 
 
186
 
@@ -454,7 +498,7 @@ static const BlockDevOps sd_block_ops = {
187
 
 
188
 
 static const VMStateDescription sd_vmstate = {
189
 
     .name = "sd-card",
190
 
-    .version_id = 1,
191
 
+    .version_id = 2,
192
 
     .minimum_version_id = 1,
193
 
     .fields = (VMStateField[]) {
194
 
         VMSTATE_UINT32(mode, SDState),
195
 
@@ -480,6 +524,7 @@ static const VMStateDescription sd_vmstate = {
196
 
         VMSTATE_UINT8_ARRAY(data, SDState, 512),
197
 
         VMSTATE_BUFFER_POINTER_UNSAFE(buf, SDState, 1, 512),
198
 
         VMSTATE_BOOL(enable, SDState),
199
 
+        VMSTATE_UINT8_ARRAY_V(ext_csd, SDState, 512, 2),
200
 
         VMSTATE_END_OF_LIST()
201
 
     }
202
 
 };
203
 
@@ -500,6 +545,7 @@ SDState *sd_init(BlockDriverState *bs, bool is_spi, bool is_mmc)
204
 
     sd = (SDState *) g_malloc0(sizeof(SDState));
205
 
     sd->buf = qemu_blockalign(bs, 512);
206
 
     sd->spi = is_spi;
207
 
+    sd->mmc = is_mmc;
208
 
     sd->enable = true;
209
 
     sd->bdrv = bs;
210
 
     sd_reset(sd);
211
 
@@ -596,6 +642,46 @@ static void sd_function_switch(SDState *sd, uint32_t arg)
212
 
     sd->data[66] = crc & 0xff;
213
 
 }
214
 
 
215
 
+static void mmc_function_switch(SDState *sd, uint32_t arg)
216
 
+{
217
 
+    enum {
218
 
+        cmd_set = 0,
219
 
+        set_bits,
220
 
+        clear_bits,
221
 
+        write_byte,
222
 
+
223
 
+        unknown
224
 
+    } mode = (arg >> 24);
225
 
+    if (mode >= unknown) {
226
 
+        fprintf(stderr, "%s: unknown mode 0x%02x\n", __FUNCTION__, mode);
227
 
+    } else {
228
 
+        if (mode == cmd_set) {
229
 
+            fprintf(stderr, "%s: command set change not implemented!\n",
230
 
+                    __FUNCTION__);
231
 
+        } else {
232
 
+            uint8_t index = (arg >> 16) & 0xff;
233
 
+            /* ignore writes to read-only fields */
234
 
+            if (index != 192 && index != 196 &&
235
 
+                (index < 212 || index > 215)) {
236
 
+                uint8_t value = (arg >> 8) & 0xff;
237
 
+                switch (mode) {
238
 
+                    case set_bits:
239
 
+                        sd->ext_csd[index] |= value;
240
 
+                        break;
241
 
+                    case clear_bits:
242
 
+                        sd->ext_csd[index] &= ~value;
243
 
+                        break;
244
 
+                    case write_byte:
245
 
+                        sd->ext_csd[index] = value;
246
 
+                        break;
247
 
+                    default:
248
 
+                        break;
249
 
+                }
250
 
+            }
251
 
+        }
252
 
+    }
253
 
+}
254
 
+
255
 
 static inline bool sd_wp_addr(SDState *sd, uint64_t addr)
256
 
 {
257
 
     return test_bit(sd_addr_to_wpnum(addr), sd->wp_groups);
258
 
@@ -696,9 +782,15 @@ static sd_rsp_type_t sd_normal_command(SDState *sd,
259
 
         break;
260
 
 
261
 
     case 1:    /* CMD1:   SEND_OP_CMD */
262
 
+        if (sd->mmc) {
263
 
+            if (sd->state == sd_idle_state) {
264
 
+                sd->state = sd_ready_state;
265
 
+                return sd_r3;
266
 
+            }
267
 
+            break;
268
 
+         }
269
 
         if (!sd->spi)
270
 
             goto bad_cmd;
271
 
-
272
 
         sd->state = sd_transfer_state;
273
 
         return sd_r1;
274
 
 
275
 
@@ -720,8 +812,12 @@ static sd_rsp_type_t sd_normal_command(SDState *sd,
276
 
             goto bad_cmd;
277
 
         switch (sd->state) {
278
 
         case sd_identification_state:
279
 
-        case sd_standby_state:
280
 
             sd->state = sd_standby_state;
281
 
+        case sd_standby_state:
282
 
+            if (sd->mmc) {
283
 
+                sd->rca = req.arg >> 16;
284
 
+                return sd_r1;
285
 
+            }
286
 
             sd_set_rca(sd);
287
 
             return sd_r6;
288
 
 
289
 
@@ -735,14 +831,26 @@ static sd_rsp_type_t sd_normal_command(SDState *sd,
290
 
             goto bad_cmd;
291
 
         switch (sd->state) {
292
 
         case sd_standby_state:
293
 
-            break;
294
 
+            return sd_r0;
295
 
 
296
 
         default:
297
 
             break;
298
 
         }
299
 
         break;
300
 
 
301
 
-    case 5: /* CMD5: reserved for SDIO cards */
302
 
+    case 5: /* CMD5: reserved for SDIO cards / SLEEP_AWAKE (MMC) */
303
 
+        if (sd->mmc) {
304
 
+            if (sd->rca != rca) {
305
 
+                return sd_r0;
306
 
+            }
307
 
+            if (req.arg & (1 << 15)) {
308
 
+                sd->state = sd_transfer_state;
309
 
+            } else {
310
 
+                sd->state = sd_standby_state;
311
 
+            }
312
 
+            return sd_r1b;
313
 
+        }
314
 
+        sd->card_status |= ILLEGAL_COMMAND;
315
 
         return sd_illegal;
316
 
 
317
 
     case 6:    /* CMD6:   SWITCH_FUNCTION */
318
 
@@ -750,11 +858,16 @@ static sd_rsp_type_t sd_normal_command(SDState *sd,
319
 
             goto bad_cmd;
320
 
         switch (sd->mode) {
321
 
         case sd_data_transfer_mode:
322
 
-            sd_function_switch(sd, req.arg);
323
 
-            sd->state = sd_sendingdata_state;
324
 
-            sd->data_start = 0;
325
 
-            sd->data_offset = 0;
326
 
-            return sd_r1;
327
 
+            if (sd->mmc) {
328
 
+                mmc_function_switch(sd, req.arg);
329
 
+                return sd_r1b;
330
 
+            } else {
331
 
+                sd_function_switch(sd, req.arg);
332
 
+                sd->state = sd_sendingdata_state;
333
 
+                sd->data_start = 0;
334
 
+                sd->data_offset = 0;
335
 
+                return sd_r1;
336
 
+            }
337
 
 
338
 
         default:
339
 
             break;
340
 
@@ -799,22 +912,30 @@ static sd_rsp_type_t sd_normal_command(SDState *sd,
341
 
         }
342
 
         break;
343
 
 
344
 
-    case 8:    /* CMD8:   SEND_IF_COND */
345
 
-        /* Physical Layer Specification Version 2.00 command */
346
 
-        switch (sd->state) {
347
 
-        case sd_idle_state:
348
 
-            sd->vhs = 0;
349
 
+    case 8:    /* CMD8:   SEND_IF_COND / SEND_EXT_CSD (MMC) */
350
 
+        if (sd->mmc) {
351
 
+            sd->state = sd_sendingdata_state;
352
 
+            memcpy(sd->data, sd->ext_csd, 512);
353
 
+            sd->data_start = addr;
354
 
+            sd->data_offset = 0;
355
 
+            return sd_r1;
356
 
+        } else {
357
 
+            /* Physical Layer Specification Version 2.00 command */
358
 
+            switch (sd->state) {
359
 
+            case sd_idle_state:
360
 
+                sd->vhs = 0;
361
 
 
362
 
-            /* No response if not exactly one VHS bit is set.  */
363
 
-            if (!(req.arg >> 8) || (req.arg >> ffs(req.arg & ~0xff)))
364
 
-                return sd->spi ? sd_r7 : sd_r0;
365
 
+                /* No response if not exactly one VHS bit is set.  */
366
 
+                if (!(req.arg >> 8) || (req.arg >> ffs(req.arg & ~0xff)))
367
 
+                    return sd->spi ? sd_r7 : sd_r0;
368
 
 
369
 
-            /* Accept.  */
370
 
-            sd->vhs = req.arg;
371
 
-            return sd_r7;
372
 
+                /* Accept.  */
373
 
+                sd->vhs = req.arg;
374
 
+                return sd_r7;
375
 
 
376
 
-        default:
377
 
-            break;
378
 
+            default:
379
 
+                break;
380
 
+            }
381
 
         }
382
 
         break;
383
 
 
384
 
@@ -974,7 +1095,32 @@ static sd_rsp_type_t sd_normal_command(SDState *sd,
385
 
         }
386
 
         break;
387
 
 
388
 
+    /* Block write commands (Class 3) */
389
 
+    case 20: /* CMD20: WRITE_DAT_UNTIL_STOP */
390
 
+        if (sd->mmc) {
391
 
+            if (sd->state == sd_transfer_state) {
392
 
+                sd->state = sd_sendingdata_state;
393
 
+                sd->data_start = req.arg;
394
 
+                sd->data_offset = 0;
395
 
+
396
 
+                if (sd->data_start + sd->blk_len > sd->size) {
397
 
+                    sd->card_status |= ADDRESS_ERROR;
398
 
+                }
399
 
+                return sd_r0;
400
 
+            }
401
 
+            break;
402
 
+        }
403
 
+        goto bad_cmd;
404
 
+
405
 
     /* Block write commands (Class 4) */
406
 
+    case 23: /* CMD23: SET_BLOCK_COUNT */
407
 
+        if (sd->mmc) {
408
 
+            sd->card_status |= ILLEGAL_COMMAND;
409
 
+            fprintf(stderr, "%s: CMD23 not implemented\n", __FUNCTION__);
410
 
+            return sd_r0;
411
 
+        }
412
 
+        goto bad_cmd;
413
 
+
414
 
     case 24:   /* CMD24:  WRITE_SINGLE_BLOCK */
415
 
         if (sd->spi)
416
 
             goto unimplemented_cmd;
417
 
@@ -1112,6 +1258,11 @@ static sd_rsp_type_t sd_normal_command(SDState *sd,
418
 
 
419
 
     /* Erase commands (Class 5) */
420
 
     case 32:   /* CMD32:  ERASE_WR_BLK_START */
421
 
+    case 35: /* CMD35: ERASE_GROUP_START */
422
 
+        if ((req.cmd == 35 && !sd->mmc) ||
423
 
+            (req.cmd == 32 && sd->mmc)) {
424
 
+            goto bad_cmd;
425
 
+        }
426
 
         switch (sd->state) {
427
 
         case sd_transfer_state:
428
 
             sd->erase_start = req.arg;
429
 
@@ -1123,6 +1274,11 @@ static sd_rsp_type_t sd_normal_command(SDState *sd,
430
 
         break;
431
 
 
432
 
     case 33:   /* CMD33:  ERASE_WR_BLK_END */
433
 
+    case 36: /* CMD36: ERASE_GROUP_END */
434
 
+        if ((req.cmd == 36 && !sd->mmc) ||
435
 
+            (req.cmd == 33 && sd->mmc)) {
436
 
+            goto bad_cmd;
437
 
+        }
438
 
         switch (sd->state) {
439
 
         case sd_transfer_state:
440
 
             sd->erase_end = req.arg;
441
 
@@ -1152,6 +1308,17 @@ static sd_rsp_type_t sd_normal_command(SDState *sd,
442
 
         }
443
 
         break;
444
 
 
445
 
+    /* Class 9 */
446
 
+    case 39: /* CMD39: FAST_IO */
447
 
+    case 40: /* CMD40: GO_IRQ_STATE */
448
 
+        if (sd->mmc) {
449
 
+            sd->card_status |= ILLEGAL_COMMAND;
450
 
+            fprintf(stderr, "%s: CMD%d not implemented\n",
451
 
+                    __FUNCTION__, req.cmd);
452
 
+            return sd_r0;
453
 
+        }
454
 
+        goto bad_cmd;
455
 
+
456
 
     /* Lock card commands (Class 7) */
457
 
     case 42:   /* CMD42:  LOCK_UNLOCK */
458
 
         if (sd->spi)
459
 
@@ -1550,6 +1717,11 @@ void sd_write_data(SDState *sd, uint8_t value)
460
 
         }
461
 
         break;
462
 
 
463
 
+    case 20: /* CMD20: WRITE_DAT_UNTIL_STOP */
464
 
+        if (!sd->mmc) {
465
 
+            goto unknown_command;
466
 
+        }
467
 
+        /* fall through */
468
 
     case 25:   /* CMD25:  WRITE_MULTIPLE_BLOCK */
469
 
         if (sd->data_offset == 0) {
470
 
             /* Start of the block - let's check the address is valid */
471
 
@@ -1640,6 +1812,7 @@ void sd_write_data(SDState *sd, uint8_t value)
472
 
         break;
473
 
 
474
 
     default:
475
 
+    unknown_command:
476
 
         fprintf(stderr, "sd_write_data: unknown command\n");
477
 
         break;
478
 
     }
479
 
@@ -1655,7 +1828,7 @@ uint8_t sd_read_data(SDState *sd)
480
 
         return 0x00;
481
 
 
482
 
     if (sd->state != sd_sendingdata_state) {
483
 
-        fprintf(stderr, "sd_read_data: not in Sending-Data state\n");
484
 
+        fprintf(stderr, "sd_read_data: not in Sending-Data state (state=%d)\n", sd->state);
485
 
         return 0x00;
486
 
     }
487
 
 
488
 
@@ -1672,6 +1845,16 @@ uint8_t sd_read_data(SDState *sd)
489
 
             sd->state = sd_transfer_state;
490
 
         break;
491
 
 
492
 
+    case 8: /* CMD8: SEND_EXT_CSD (MMC only) */
493
 
+        if (sd->mmc) {
494
 
+            ret = sd->data[sd->data_offset++];
495
 
+            if (sd->data_offset >= 512) {
496
 
+                sd->state = sd_transfer_state;
497
 
+            }
498
 
+        } else {
499
 
+            goto unknown_command;
500
 
+        }
501
 
+        break;
502
 
     case 9:    /* CMD9:   SEND_CSD */
503
 
     case 10:   /* CMD10:  SEND_CID */
504
 
         ret = sd->data[sd->data_offset ++];
505
 
@@ -1757,6 +1940,7 @@ uint8_t sd_read_data(SDState *sd)
506
 
         break;
507
 
 
508
 
     default:
509
 
+    unknown_command:
510
 
         fprintf(stderr, "sd_read_data: unknown command\n");
511
 
         return 0x00;
512
 
     }
513
 
@@ -1773,3 +1957,8 @@ void sd_enable(SDState *sd, bool enable)
514
 
 {
515
 
     sd->enable = enable;
516
 
 }
517
 
+
518
 
+bool sd_is_mmc(SDState *sd)
519
 
+{
520
 
+    return sd->mmc;
521
 
+}
522
 
diff --git a/include/hw/sd.h b/include/hw/sd.h
523
 
index 562eaa2..13ef5d3 100644
524
 
--- a/include/hw/sd.h
525
 
+++ b/include/hw/sd.h
526
 
@@ -77,5 +77,6 @@ uint8_t sd_read_data(SDState *sd);
527
 
 void sd_set_cb(SDState *sd, qemu_irq readonly, qemu_irq insert);
528
 
 bool sd_data_ready(SDState *sd);
529
 
 void sd_enable(SDState *sd, bool enable);
530
 
+bool sd_is_mmc(SDState *sd);
531
 
 
532
 
 #endif /* __hw_sd_h */
533
 
1.8.5.2
534