2 * QEMU model of the Milkymist SD Card Controller.
4 * Copyright (c) 2010 Michael Walle <michael@walle.cc>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
20 * Specification available at:
21 * http://milkymist.walle.cc/socdoc/memcard.pdf
24 #include "qemu/osdep.h"
26 #include "qemu/module.h"
27 #include "hw/sysbus.h"
28 #include "migration/vmstate.h"
29 #include "sysemu/sysemu.h"
31 #include "qapi/error.h"
32 #include "sysemu/block-backend.h"
33 #include "sysemu/blockdev.h"
34 #include "hw/qdev-properties.h"
38 ENABLE_CMD_TX
= (1<<0),
39 ENABLE_CMD_RX
= (1<<1),
40 ENABLE_DAT_TX
= (1<<2),
41 ENABLE_DAT_RX
= (1<<3),
45 PENDING_CMD_TX
= (1<<0),
46 PENDING_CMD_RX
= (1<<1),
47 PENDING_DAT_TX
= (1<<2),
48 PENDING_DAT_RX
= (1<<3),
52 START_CMD_TX
= (1<<0),
53 START_DAT_RX
= (1<<1),
66 #define TYPE_MILKYMIST_MEMCARD "milkymist-memcard"
67 #define MILKYMIST_MEMCARD(obj) \
68 OBJECT_CHECK(MilkymistMemcardState, (obj), TYPE_MILKYMIST_MEMCARD)
70 struct MilkymistMemcardState
{
71 SysBusDevice parent_obj
;
73 MemoryRegion regs_region
;
76 int command_write_ptr
;
77 int response_read_ptr
;
85 typedef struct MilkymistMemcardState MilkymistMemcardState
;
87 static void update_pending_bits(MilkymistMemcardState
*s
)
89 /* transmits are instantaneous, thus tx pending bits are never set */
90 s
->regs
[R_PENDING
] = 0;
91 /* if rx is enabled the corresponding pending bits are always set */
92 if (s
->regs
[R_ENABLE
] & ENABLE_CMD_RX
) {
93 s
->regs
[R_PENDING
] |= PENDING_CMD_RX
;
95 if (s
->regs
[R_ENABLE
] & ENABLE_DAT_RX
) {
96 s
->regs
[R_PENDING
] |= PENDING_DAT_RX
;
100 static void memcard_sd_command(MilkymistMemcardState
*s
)
104 req
.cmd
= s
->command
[0] & 0x3f;
105 req
.arg
= ldl_be_p(s
->command
+ 1);
106 req
.crc
= s
->command
[5];
108 s
->response
[0] = req
.cmd
;
109 s
->response_len
= sdbus_do_command(&s
->sdbus
, &req
, s
->response
+ 1);
110 s
->response_read_ptr
= 0;
112 if (s
->response_len
== 16) {
114 s
->response
[0] = 0x3f;
115 s
->response_len
+= 1;
116 } else if (s
->response_len
== 4) {
117 /* no crc calculation, insert dummy byte */
119 s
->response_len
+= 2;
123 /* next write is a dummy byte to clock the initialization of the sd
125 s
->ignore_next_cmd
= 1;
129 static uint64_t memcard_read(void *opaque
, hwaddr addr
,
132 MilkymistMemcardState
*s
= opaque
;
141 r
= s
->response
[s
->response_read_ptr
++];
142 if (s
->response_read_ptr
> s
->response_len
) {
143 qemu_log_mask(LOG_GUEST_ERROR
, "milkymist_memcard: "
144 "read more cmd bytes than available: clipping\n");
145 s
->response_read_ptr
= 0;
154 r
|= sdbus_read_data(&s
->sdbus
) << 24;
155 r
|= sdbus_read_data(&s
->sdbus
) << 16;
156 r
|= sdbus_read_data(&s
->sdbus
) << 8;
157 r
|= sdbus_read_data(&s
->sdbus
);
168 qemu_log_mask(LOG_UNIMP
, "milkymist_memcard: "
169 "read access to unknown register 0x%" HWADDR_PRIx
"\n",
174 trace_milkymist_memcard_memory_read(addr
<< 2, r
);
179 static void memcard_write(void *opaque
, hwaddr addr
, uint64_t value
,
182 MilkymistMemcardState
*s
= opaque
;
184 trace_milkymist_memcard_memory_write(addr
, value
);
189 /* clear rx pending bits */
190 s
->regs
[R_PENDING
] &= ~(value
& (PENDING_CMD_RX
| PENDING_DAT_RX
));
191 update_pending_bits(s
);
197 if (s
->ignore_next_cmd
) {
198 s
->ignore_next_cmd
= 0;
201 s
->command
[s
->command_write_ptr
] = value
& 0xff;
202 s
->command_write_ptr
= (s
->command_write_ptr
+ 1) % 6;
203 if (s
->command_write_ptr
== 0) {
204 memcard_sd_command(s
);
211 sdbus_write_data(&s
->sdbus
, (value
>> 24) & 0xff);
212 sdbus_write_data(&s
->sdbus
, (value
>> 16) & 0xff);
213 sdbus_write_data(&s
->sdbus
, (value
>> 8) & 0xff);
214 sdbus_write_data(&s
->sdbus
, value
& 0xff);
217 s
->regs
[addr
] = value
;
218 update_pending_bits(s
);
222 s
->regs
[addr
] = value
;
226 qemu_log_mask(LOG_UNIMP
, "milkymist_memcard: "
227 "write access to unknown register 0x%" HWADDR_PRIx
" "
228 "(value 0x%" PRIx64
")\n", addr
<< 2, value
);
233 static const MemoryRegionOps memcard_mmio_ops
= {
234 .read
= memcard_read
,
235 .write
= memcard_write
,
237 .min_access_size
= 4,
238 .max_access_size
= 4,
240 .endianness
= DEVICE_NATIVE_ENDIAN
,
243 static void milkymist_memcard_reset(DeviceState
*d
)
245 MilkymistMemcardState
*s
= MILKYMIST_MEMCARD(d
);
248 s
->command_write_ptr
= 0;
249 s
->response_read_ptr
= 0;
252 for (i
= 0; i
< R_MAX
; i
++) {
257 static void milkymist_memcard_init(Object
*obj
)
259 MilkymistMemcardState
*s
= MILKYMIST_MEMCARD(obj
);
260 SysBusDevice
*dev
= SYS_BUS_DEVICE(obj
);
262 memory_region_init_io(&s
->regs_region
, OBJECT(s
), &memcard_mmio_ops
, s
,
263 "milkymist-memcard", R_MAX
* 4);
264 sysbus_init_mmio(dev
, &s
->regs_region
);
267 static void milkymist_memcard_realize(DeviceState
*dev
, Error
**errp
)
269 MilkymistMemcardState
*s
= MILKYMIST_MEMCARD(dev
);
270 DeviceState
*carddev
;
275 qbus_create_inplace(&s
->sdbus
, sizeof(s
->sdbus
), TYPE_SD_BUS
,
278 /* Create and plug in the sd card */
279 /* FIXME use a qdev drive property instead of drive_get_next() */
280 dinfo
= drive_get_next(IF_SD
);
281 blk
= dinfo
? blk_by_legacy_dinfo(dinfo
) : NULL
;
282 carddev
= qdev_create(BUS(&s
->sdbus
), TYPE_SD_CARD
);
283 qdev_prop_set_drive(carddev
, "drive", blk
, &err
);
284 object_property_set_bool(OBJECT(carddev
), true, "realized", &err
);
286 error_setg(errp
, "failed to init SD card: %s", error_get_pretty(err
));
289 s
->enabled
= blk
&& blk_is_inserted(blk
);
292 static const VMStateDescription vmstate_milkymist_memcard
= {
293 .name
= "milkymist-memcard",
295 .minimum_version_id
= 1,
296 .fields
= (VMStateField
[]) {
297 VMSTATE_INT32(command_write_ptr
, MilkymistMemcardState
),
298 VMSTATE_INT32(response_read_ptr
, MilkymistMemcardState
),
299 VMSTATE_INT32(response_len
, MilkymistMemcardState
),
300 VMSTATE_INT32(ignore_next_cmd
, MilkymistMemcardState
),
301 VMSTATE_INT32(enabled
, MilkymistMemcardState
),
302 VMSTATE_UINT8_ARRAY(command
, MilkymistMemcardState
, 6),
303 VMSTATE_UINT8_ARRAY(response
, MilkymistMemcardState
, 17),
304 VMSTATE_UINT32_ARRAY(regs
, MilkymistMemcardState
, R_MAX
),
305 VMSTATE_END_OF_LIST()
309 static void milkymist_memcard_class_init(ObjectClass
*klass
, void *data
)
311 DeviceClass
*dc
= DEVICE_CLASS(klass
);
313 dc
->realize
= milkymist_memcard_realize
;
314 dc
->reset
= milkymist_memcard_reset
;
315 dc
->vmsd
= &vmstate_milkymist_memcard
;
316 /* Reason: init() method uses drive_get_next() */
317 dc
->user_creatable
= false;
320 static const TypeInfo milkymist_memcard_info
= {
321 .name
= TYPE_MILKYMIST_MEMCARD
,
322 .parent
= TYPE_SYS_BUS_DEVICE
,
323 .instance_size
= sizeof(MilkymistMemcardState
),
324 .instance_init
= milkymist_memcard_init
,
325 .class_init
= milkymist_memcard_class_init
,
328 static void milkymist_memcard_register_types(void)
330 type_register_static(&milkymist_memcard_info
);
333 type_init(milkymist_memcard_register_types
)