← Back to branch summary

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

« back to all changes in this revision

Viewing changes to debian/patches/ubuntu/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/ubuntu/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
-- 
 
534
1.8.5.2
 
535