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"
30 #include "qapi/error.h"
31 #include "sysemu/block-backend.h"
32 #include "sysemu/blockdev.h"
33 #include "hw/qdev-properties.h"
37 ENABLE_CMD_TX
= (1<<0),
38 ENABLE_CMD_RX
= (1<<1),
39 ENABLE_DAT_TX
= (1<<2),
40 ENABLE_DAT_RX
= (1<<3),
44 PENDING_CMD_TX
= (1<<0),
45 PENDING_CMD_RX
= (1<<1),
46 PENDING_DAT_TX
= (1<<2),
47 PENDING_DAT_RX
= (1<<3),
51 START_CMD_TX
= (1<<0),
52 START_DAT_RX
= (1<<1),
65 #define TYPE_MILKYMIST_MEMCARD "milkymist-memcard"
66 #define MILKYMIST_MEMCARD(obj) \
67 OBJECT_CHECK(MilkymistMemcardState, (obj), TYPE_MILKYMIST_MEMCARD)
69 #define TYPE_MILKYMIST_SDBUS "milkymist-sdbus"
71 struct MilkymistMemcardState
{
72 SysBusDevice parent_obj
;
74 MemoryRegion regs_region
;
77 int command_write_ptr
;
78 int response_read_ptr
;
86 typedef struct MilkymistMemcardState MilkymistMemcardState
;
88 static void update_pending_bits(MilkymistMemcardState
*s
)
90 /* transmits are instantaneous, thus tx pending bits are never set */
91 s
->regs
[R_PENDING
] = 0;
92 /* if rx is enabled the corresponding pending bits are always set */
93 if (s
->regs
[R_ENABLE
] & ENABLE_CMD_RX
) {
94 s
->regs
[R_PENDING
] |= PENDING_CMD_RX
;
96 if (s
->regs
[R_ENABLE
] & ENABLE_DAT_RX
) {
97 s
->regs
[R_PENDING
] |= PENDING_DAT_RX
;
101 static void memcard_sd_command(MilkymistMemcardState
*s
)
105 req
.cmd
= s
->command
[0] & 0x3f;
106 req
.arg
= ldl_be_p(s
->command
+ 1);
107 req
.crc
= s
->command
[5];
109 s
->response
[0] = req
.cmd
;
110 s
->response_len
= sdbus_do_command(&s
->sdbus
, &req
, s
->response
+ 1);
111 s
->response_read_ptr
= 0;
113 if (s
->response_len
== 16) {
115 s
->response
[0] = 0x3f;
116 s
->response_len
+= 1;
117 } else if (s
->response_len
== 4) {
118 /* no crc calculation, insert dummy byte */
120 s
->response_len
+= 2;
124 /* next write is a dummy byte to clock the initialization of the sd
126 s
->ignore_next_cmd
= 1;
130 static uint64_t memcard_read(void *opaque
, hwaddr addr
,
133 MilkymistMemcardState
*s
= opaque
;
142 r
= s
->response
[s
->response_read_ptr
++];
143 if (s
->response_read_ptr
> s
->response_len
) {
144 qemu_log_mask(LOG_GUEST_ERROR
, "milkymist_memcard: "
145 "read more cmd bytes than available: clipping\n");
146 s
->response_read_ptr
= 0;
155 r
|= sdbus_read_data(&s
->sdbus
) << 24;
156 r
|= sdbus_read_data(&s
->sdbus
) << 16;
157 r
|= sdbus_read_data(&s
->sdbus
) << 8;
158 r
|= sdbus_read_data(&s
->sdbus
);
169 qemu_log_mask(LOG_UNIMP
, "milkymist_memcard: "
170 "read access to unknown register 0x%" HWADDR_PRIx
"\n",
175 trace_milkymist_memcard_memory_read(addr
<< 2, r
);
180 static void memcard_write(void *opaque
, hwaddr addr
, uint64_t value
,
183 MilkymistMemcardState
*s
= opaque
;
185 trace_milkymist_memcard_memory_write(addr
, value
);
190 /* clear rx pending bits */
191 s
->regs
[R_PENDING
] &= ~(value
& (PENDING_CMD_RX
| PENDING_DAT_RX
));
192 update_pending_bits(s
);
198 if (s
->ignore_next_cmd
) {
199 s
->ignore_next_cmd
= 0;
202 s
->command
[s
->command_write_ptr
] = value
& 0xff;
203 s
->command_write_ptr
= (s
->command_write_ptr
+ 1) % 6;
204 if (s
->command_write_ptr
== 0) {
205 memcard_sd_command(s
);
212 sdbus_write_data(&s
->sdbus
, (value
>> 24) & 0xff);
213 sdbus_write_data(&s
->sdbus
, (value
>> 16) & 0xff);
214 sdbus_write_data(&s
->sdbus
, (value
>> 8) & 0xff);
215 sdbus_write_data(&s
->sdbus
, value
& 0xff);
218 s
->regs
[addr
] = value
;
219 update_pending_bits(s
);
223 s
->regs
[addr
] = value
;
227 qemu_log_mask(LOG_UNIMP
, "milkymist_memcard: "
228 "write access to unknown register 0x%" HWADDR_PRIx
" "
229 "(value 0x%" PRIx64
")\n", addr
<< 2, value
);
234 static const MemoryRegionOps memcard_mmio_ops
= {
235 .read
= memcard_read
,
236 .write
= memcard_write
,
238 .min_access_size
= 4,
239 .max_access_size
= 4,
241 .endianness
= DEVICE_NATIVE_ENDIAN
,
244 static void milkymist_memcard_reset(DeviceState
*d
)
246 MilkymistMemcardState
*s
= MILKYMIST_MEMCARD(d
);
249 s
->command_write_ptr
= 0;
250 s
->response_read_ptr
= 0;
253 for (i
= 0; i
< R_MAX
; i
++) {
258 static void milkymist_memcard_set_readonly(DeviceState
*dev
, bool level
)
260 qemu_log_mask(LOG_UNIMP
,
261 "milkymist_memcard: read-only mode not supported\n");
264 static void milkymist_memcard_set_inserted(DeviceState
*dev
, bool level
)
266 MilkymistMemcardState
*s
= MILKYMIST_MEMCARD(dev
);
268 s
->enabled
= !!level
;
271 static void milkymist_memcard_init(Object
*obj
)
273 MilkymistMemcardState
*s
= MILKYMIST_MEMCARD(obj
);
274 SysBusDevice
*dev
= SYS_BUS_DEVICE(obj
);
276 memory_region_init_io(&s
->regs_region
, OBJECT(s
), &memcard_mmio_ops
, s
,
277 "milkymist-memcard", R_MAX
* 4);
278 sysbus_init_mmio(dev
, &s
->regs_region
);
280 qbus_create_inplace(&s
->sdbus
, sizeof(s
->sdbus
), TYPE_SD_BUS
,
281 DEVICE(obj
), "sd-bus");
284 static const VMStateDescription vmstate_milkymist_memcard
= {
285 .name
= "milkymist-memcard",
287 .minimum_version_id
= 1,
288 .fields
= (VMStateField
[]) {
289 VMSTATE_INT32(command_write_ptr
, MilkymistMemcardState
),
290 VMSTATE_INT32(response_read_ptr
, MilkymistMemcardState
),
291 VMSTATE_INT32(response_len
, MilkymistMemcardState
),
292 VMSTATE_INT32(ignore_next_cmd
, MilkymistMemcardState
),
293 VMSTATE_INT32(enabled
, MilkymistMemcardState
),
294 VMSTATE_UINT8_ARRAY(command
, MilkymistMemcardState
, 6),
295 VMSTATE_UINT8_ARRAY(response
, MilkymistMemcardState
, 17),
296 VMSTATE_UINT32_ARRAY(regs
, MilkymistMemcardState
, R_MAX
),
297 VMSTATE_END_OF_LIST()
301 static void milkymist_memcard_class_init(ObjectClass
*klass
, void *data
)
303 DeviceClass
*dc
= DEVICE_CLASS(klass
);
305 dc
->reset
= milkymist_memcard_reset
;
306 dc
->vmsd
= &vmstate_milkymist_memcard
;
307 /* Reason: output IRQs should be wired up */
308 dc
->user_creatable
= false;
311 static const TypeInfo milkymist_memcard_info
= {
312 .name
= TYPE_MILKYMIST_MEMCARD
,
313 .parent
= TYPE_SYS_BUS_DEVICE
,
314 .instance_size
= sizeof(MilkymistMemcardState
),
315 .instance_init
= milkymist_memcard_init
,
316 .class_init
= milkymist_memcard_class_init
,
319 static void milkymist_sdbus_class_init(ObjectClass
*klass
, void *data
)
321 SDBusClass
*sbc
= SD_BUS_CLASS(klass
);
323 sbc
->set_inserted
= milkymist_memcard_set_inserted
;
324 sbc
->set_readonly
= milkymist_memcard_set_readonly
;
327 static const TypeInfo milkymist_sdbus_info
= {
328 .name
= TYPE_MILKYMIST_SDBUS
,
329 .parent
= TYPE_SD_BUS
,
330 .instance_size
= sizeof(SDBus
),
331 .class_init
= milkymist_sdbus_class_init
,
334 static void milkymist_memcard_register_types(void)
336 type_register_static(&milkymist_memcard_info
);
337 type_register_static(&milkymist_sdbus_info
);
340 type_init(milkymist_memcard_register_types
)