#include "sysbus.h"
#include "trace.h"
#include "console.h"
-#include "usb.h"
+#include "hid.h"
#include "qemu-error.h"
enum {
struct MilkymistSoftUsbState {
SysBusDevice busdev;
- USBBus usbbus;
- USBPort usbport[2];
- USBDevice *usbdev;
+ HIDState hid_kbd;
+ HIDState hid_mouse;
+ MemoryRegion regs_region;
+ MemoryRegion pmem;
+ MemoryRegion dmem;
qemu_irq irq;
/* device properties */
uint32_t regs[R_MAX];
/* mouse state */
- int mouse_dx;
- int mouse_dy;
- int mouse_dz;
- uint8_t mouse_buttons_state;
+ uint8_t mouse_hid_buffer[4];
/* keyboard state */
- uint8_t kbd_usb_buffer[8];
+ uint8_t kbd_hid_buffer[8];
};
typedef struct MilkymistSoftUsbState MilkymistSoftUsbState;
-static uint32_t softusb_read(void *opaque, target_phys_addr_t addr)
+static uint64_t softusb_read(void *opaque, hwaddr addr,
+ unsigned size)
{
MilkymistSoftUsbState *s = opaque;
uint32_t r = 0;
}
static void
-softusb_write(void *opaque, target_phys_addr_t addr, uint32_t value)
+softusb_write(void *opaque, hwaddr addr, uint64_t value,
+ unsigned size)
{
MilkymistSoftUsbState *s = opaque;
}
}
-static CPUReadMemoryFunc * const softusb_read_fn[] = {
- NULL,
- NULL,
- &softusb_read,
-};
-
-static CPUWriteMemoryFunc * const softusb_write_fn[] = {
- NULL,
- NULL,
- &softusb_write,
+static const MemoryRegionOps softusb_mmio_ops = {
+ .read = softusb_read,
+ .write = softusb_write,
+ .endianness = DEVICE_NATIVE_ENDIAN,
+ .valid = {
+ .min_access_size = 4,
+ .max_access_size = 4,
+ },
};
static inline void softusb_read_dmem(MilkymistSoftUsbState *s,
{
if (offset + len >= s->dmem_size) {
error_report("milkymist_softusb: read dmem out of bounds "
- "at offset 0x%x, len %d\n", offset, len);
+ "at offset 0x%x, len %d", offset, len);
return;
}
{
if (offset + len >= s->dmem_size) {
error_report("milkymist_softusb: write dmem out of bounds "
- "at offset 0x%x, len %d\n", offset, len);
+ "at offset 0x%x, len %d", offset, len);
return;
}
{
if (offset + len >= s->pmem_size) {
error_report("milkymist_softusb: read pmem out of bounds "
- "at offset 0x%x, len %d\n", offset, len);
+ "at offset 0x%x, len %d", offset, len);
return;
}
{
if (offset + len >= s->pmem_size) {
error_report("milkymist_softusb: write pmem out of bounds "
- "at offset 0x%x, len %d\n", offset, len);
+ "at offset 0x%x, len %d", offset, len);
return;
}
static void softusb_mouse_changed(MilkymistSoftUsbState *s)
{
uint8_t m;
- uint8_t buf[4];
-
- buf[0] = s->mouse_buttons_state;
- buf[1] = s->mouse_dx;
- buf[2] = s->mouse_dy;
- buf[3] = s->mouse_dz;
softusb_read_dmem(s, COMLOC_MEVT_PRODUCE, &m, 1);
trace_milkymist_softusb_mevt(m);
- softusb_write_dmem(s, COMLOC_MEVT_BASE + 4 * m, buf, 4);
+ softusb_write_dmem(s, COMLOC_MEVT_BASE + 4 * m, s->mouse_hid_buffer, 4);
m = (m + 1) & 0xf;
softusb_write_dmem(s, COMLOC_MEVT_PRODUCE, &m, 1);
softusb_read_dmem(s, COMLOC_KEVT_PRODUCE, &m, 1);
trace_milkymist_softusb_kevt(m);
- softusb_write_dmem(s, COMLOC_KEVT_BASE + 8 * m, s->kbd_usb_buffer, 8);
+ softusb_write_dmem(s, COMLOC_KEVT_BASE + 8 * m, s->kbd_hid_buffer, 8);
m = (m + 1) & 0x7;
softusb_write_dmem(s, COMLOC_KEVT_PRODUCE, &m, 1);
qemu_irq_pulse(s->irq);
}
-static void softusb_mouse_event(void *opaque,
- int dx, int dy, int dz, int buttons_state)
+static void softusb_kbd_hid_datain(HIDState *hs)
{
- MilkymistSoftUsbState *s = opaque;
+ MilkymistSoftUsbState *s = container_of(hs, MilkymistSoftUsbState, hid_kbd);
+ int len;
/* if device is in reset, do nothing */
if (s->regs[R_CTRL] & CTRL_RESET) {
return;
}
- trace_milkymist_softusb_mouse_event(dx, dy, dz, buttons_state);
+ len = hid_keyboard_poll(hs, s->kbd_hid_buffer, sizeof(s->kbd_hid_buffer));
- s->mouse_dx = dx;
- s->mouse_dy = dy;
- s->mouse_dz = dz;
- s->mouse_buttons_state = buttons_state;
-
- softusb_mouse_changed(s);
+ if (len == 8) {
+ softusb_kbd_changed(s);
+ }
}
-static void softusb_usbdev_datain(void *opaque)
+static void softusb_mouse_hid_datain(HIDState *hs)
{
- MilkymistSoftUsbState *s = opaque;
-
- USBPacket p;
+ MilkymistSoftUsbState *s =
+ container_of(hs, MilkymistSoftUsbState, hid_mouse);
+ int len;
- p.pid = USB_TOKEN_IN;
- p.devep = 1;
- p.data = s->kbd_usb_buffer;
- p.len = sizeof(s->kbd_usb_buffer);
- s->usbdev->info->handle_data(s->usbdev, &p);
+ /* if device is in reset, do nothing */
+ if (s->regs[R_CTRL] & CTRL_RESET) {
+ return;
+ }
- softusb_kbd_changed(s);
-}
+ len = hid_pointer_poll(hs, s->mouse_hid_buffer,
+ sizeof(s->mouse_hid_buffer));
-static void softusb_attach(USBPort *port)
-{
+ if (len == 4) {
+ softusb_mouse_changed(s);
+ }
}
-static USBPortOps softusb_ops = {
- .attach = softusb_attach,
-};
-
static void milkymist_softusb_reset(DeviceState *d)
{
MilkymistSoftUsbState *s =
for (i = 0; i < R_MAX; i++) {
s->regs[i] = 0;
}
- s->mouse_dx = 0;
- s->mouse_dy = 0;
- s->mouse_dz = 0;
- s->mouse_buttons_state = 0;
- memset(s->kbd_usb_buffer, 0, sizeof(s->kbd_usb_buffer));
+ memset(s->kbd_hid_buffer, 0, sizeof(s->kbd_hid_buffer));
+ memset(s->mouse_hid_buffer, 0, sizeof(s->mouse_hid_buffer));
+
+ hid_reset(&s->hid_kbd);
+ hid_reset(&s->hid_mouse);
/* defaults */
s->regs[R_CTRL] = CTRL_RESET;
static int milkymist_softusb_init(SysBusDevice *dev)
{
MilkymistSoftUsbState *s = FROM_SYSBUS(typeof(*s), dev);
- int softusb_regs;
- ram_addr_t pmem_ram;
- ram_addr_t dmem_ram;
sysbus_init_irq(dev, &s->irq);
- softusb_regs = cpu_register_io_memory(softusb_read_fn, softusb_write_fn, s,
- DEVICE_NATIVE_ENDIAN);
- sysbus_init_mmio(dev, R_MAX * 4, softusb_regs);
+ memory_region_init_io(&s->regs_region, &softusb_mmio_ops, s,
+ "milkymist-softusb", R_MAX * 4);
+ sysbus_init_mmio(dev, &s->regs_region);
/* register pmem and dmem */
- pmem_ram = qemu_ram_alloc(NULL, "milkymist_softusb.pmem", s->pmem_size);
- cpu_register_physical_memory(s->pmem_base, s->pmem_size,
- pmem_ram | IO_MEM_RAM);
- dmem_ram = qemu_ram_alloc(NULL, "milkymist_softusb.dmem", s->dmem_size);
- cpu_register_physical_memory(s->dmem_base, s->dmem_size,
- dmem_ram | IO_MEM_RAM);
-
- qemu_add_mouse_event_handler(softusb_mouse_event, s, 0, "Milkymist Mouse");
-
- /* create our usb bus */
- usb_bus_new(&s->usbbus, NULL);
-
- /* our two ports */
- usb_register_port(&s->usbbus, &s->usbport[0], NULL, 0, &softusb_ops,
- USB_SPEED_MASK_LOW);
- usb_register_port(&s->usbbus, &s->usbport[1], NULL, 1, &softusb_ops,
- USB_SPEED_MASK_LOW);
-
- /* and finally create an usb keyboard */
- s->usbdev = usb_create_simple(&s->usbbus, "usb-kbd");
- usb_hid_datain_cb(s->usbdev, s, softusb_usbdev_datain);
- s->usbdev->info->handle_reset(s->usbdev);
+ memory_region_init_ram(&s->pmem, "milkymist-softusb.pmem",
+ s->pmem_size);
+ vmstate_register_ram_global(&s->pmem);
+ sysbus_add_memory(dev, s->pmem_base, &s->pmem);
+ memory_region_init_ram(&s->dmem, "milkymist-softusb.dmem",
+ s->dmem_size);
+ vmstate_register_ram_global(&s->dmem);
+ sysbus_add_memory(dev, s->dmem_base, &s->dmem);
+
+ hid_init(&s->hid_kbd, HID_KEYBOARD, softusb_kbd_hid_datain);
+ hid_init(&s->hid_mouse, HID_MOUSE, softusb_mouse_hid_datain);
return 0;
}
.minimum_version_id_old = 1,
.fields = (VMStateField[]) {
VMSTATE_UINT32_ARRAY(regs, MilkymistSoftUsbState, R_MAX),
- VMSTATE_INT32(mouse_dx, MilkymistSoftUsbState),
- VMSTATE_INT32(mouse_dy, MilkymistSoftUsbState),
- VMSTATE_INT32(mouse_dz, MilkymistSoftUsbState),
- VMSTATE_UINT8(mouse_buttons_state, MilkymistSoftUsbState),
- VMSTATE_BUFFER(kbd_usb_buffer, MilkymistSoftUsbState),
+ VMSTATE_HID_KEYBOARD_DEVICE(hid_kbd, MilkymistSoftUsbState),
+ VMSTATE_HID_POINTER_DEVICE(hid_mouse, MilkymistSoftUsbState),
+ VMSTATE_BUFFER(kbd_hid_buffer, MilkymistSoftUsbState),
+ VMSTATE_BUFFER(mouse_hid_buffer, MilkymistSoftUsbState),
VMSTATE_END_OF_LIST()
}
};
-static SysBusDeviceInfo milkymist_softusb_info = {
- .init = milkymist_softusb_init,
- .qdev.name = "milkymist-softusb",
- .qdev.size = sizeof(MilkymistSoftUsbState),
- .qdev.vmsd = &vmstate_milkymist_softusb,
- .qdev.reset = milkymist_softusb_reset,
- .qdev.props = (Property[]) {
- DEFINE_PROP_UINT32(
- "pmem_base", MilkymistSoftUsbState, pmem_base, 0xa0000000
- ),
- DEFINE_PROP_UINT32(
- "pmem_size", MilkymistSoftUsbState, pmem_size, 0x00001000
- ),
- DEFINE_PROP_UINT32(
- "dmem_base", MilkymistSoftUsbState, dmem_base, 0xa0020000
- ),
- DEFINE_PROP_UINT32(
- "dmem_size", MilkymistSoftUsbState, dmem_size, 0x00002000
- ),
- DEFINE_PROP_END_OF_LIST(),
- }
+static Property milkymist_softusb_properties[] = {
+ DEFINE_PROP_UINT32("pmem_base", MilkymistSoftUsbState, pmem_base, 0xa0000000),
+ DEFINE_PROP_UINT32("pmem_size", MilkymistSoftUsbState, pmem_size, 0x00001000),
+ DEFINE_PROP_UINT32("dmem_base", MilkymistSoftUsbState, dmem_base, 0xa0020000),
+ DEFINE_PROP_UINT32("dmem_size", MilkymistSoftUsbState, dmem_size, 0x00002000),
+ DEFINE_PROP_END_OF_LIST(),
+};
+
+static void milkymist_softusb_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
+
+ k->init = milkymist_softusb_init;
+ dc->reset = milkymist_softusb_reset;
+ dc->vmsd = &vmstate_milkymist_softusb;
+ dc->props = milkymist_softusb_properties;
+}
+
+static TypeInfo milkymist_softusb_info = {
+ .name = "milkymist-softusb",
+ .parent = TYPE_SYS_BUS_DEVICE,
+ .instance_size = sizeof(MilkymistSoftUsbState),
+ .class_init = milkymist_softusb_class_init,
};
-static void milkymist_softusb_register(void)
+static void milkymist_softusb_register_types(void)
{
- sysbus_register_withprop(&milkymist_softusb_info);
+ type_register_static(&milkymist_softusb_info);
}
-device_init(milkymist_softusb_register)
+type_init(milkymist_softusb_register_types)
projects / mirror_qemu.git / blobdiff