hw/input/milkymist-softusb.c

   1 /*
   2  *  QEMU model of the Milkymist SoftUSB block.
   3  *
   4  *  Copyright (c) 2010 Michael Walle <michael@walle.cc>
   5  *
   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.
  10  *
  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.
  15  *
  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/>.
  18  *
  19  *
  20  * Specification available at:
  21  *   not available yet
  22  */
  23
  24 #include "qemu/osdep.h"
  25 #include "hw/hw.h"
  26 #include "hw/sysbus.h"
  27 #include "trace.h"
  28 #include "ui/console.h"
  29 #include "hw/input/hid.h"
  30 #include "qemu/error-report.h"
  31
  32 enum {
  33     R_CTRL = 0,
  34     R_MAX
  35 };
  36
  37 enum {
  38     CTRL_RESET = (1<<0),
  39 };
  40
  41 #define COMLOC_DEBUG_PRODUCE 0x1000
  42 #define COMLOC_DEBUG_BASE    0x1001
  43 #define COMLOC_MEVT_PRODUCE  0x1101
  44 #define COMLOC_MEVT_BASE     0x1102
  45 #define COMLOC_KEVT_PRODUCE  0x1142
  46 #define COMLOC_KEVT_BASE     0x1143
  47
  48 #define TYPE_MILKYMIST_SOFTUSB "milkymist-softusb"
  49 #define MILKYMIST_SOFTUSB(obj) \
  50     OBJECT_CHECK(MilkymistSoftUsbState, (obj), TYPE_MILKYMIST_SOFTUSB)
  51
  52 struct MilkymistSoftUsbState {
  53     SysBusDevice parent_obj;
  54
  55     HIDState hid_kbd;
  56     HIDState hid_mouse;
  57
  58     MemoryRegion regs_region;
  59     MemoryRegion pmem;
  60     MemoryRegion dmem;
  61     qemu_irq irq;
  62
  63     void *pmem_ptr;
  64     void *dmem_ptr;
  65
  66     /* device properties */
  67     uint32_t pmem_size;
  68     uint32_t dmem_size;
  69
  70     /* device registers */
  71     uint32_t regs[R_MAX];
  72
  73     /* mouse state */
  74     uint8_t mouse_hid_buffer[4];
  75
  76     /* keyboard state */
  77     uint8_t kbd_hid_buffer[8];
  78 };
  79 typedef struct MilkymistSoftUsbState MilkymistSoftUsbState;
  80
  81 static uint64_t softusb_read(void *opaque, hwaddr addr,
  82                              unsigned size)
  83 {
  84     MilkymistSoftUsbState *s = opaque;
  85     uint32_t r = 0;
  86
  87     addr >>= 2;
  88     switch (addr) {
  89     case R_CTRL:
  90         r = s->regs[addr];
  91         break;
  92
  93     default:
  94         error_report("milkymist_softusb: read access to unknown register 0x"
  95                 TARGET_FMT_plx, addr << 2);
  96         break;
  97     }
  98
  99     trace_milkymist_softusb_memory_read(addr << 2, r);
 100
 101     return r;
 102 }
 103
 104 static void
 105 softusb_write(void *opaque, hwaddr addr, uint64_t value,
 106               unsigned size)
 107 {
 108     MilkymistSoftUsbState *s = opaque;
 109
 110     trace_milkymist_softusb_memory_write(addr, value);
 111
 112     addr >>= 2;
 113     switch (addr) {
 114     case R_CTRL:
 115         s->regs[addr] = value;
 116         break;
 117
 118     default:
 119         error_report("milkymist_softusb: write access to unknown register 0x"
 120                 TARGET_FMT_plx, addr << 2);
 121         break;
 122     }
 123 }
 124
 125 static const MemoryRegionOps softusb_mmio_ops = {
 126     .read = softusb_read,
 127     .write = softusb_write,
 128     .endianness = DEVICE_NATIVE_ENDIAN,
 129     .valid = {
 130         .min_access_size = 4,
 131         .max_access_size = 4,
 132     },
 133 };
 134
 135 static inline void softusb_read_dmem(MilkymistSoftUsbState *s,
 136         uint32_t offset, uint8_t *buf, uint32_t len)
 137 {
 138     if (offset + len >= s->dmem_size) {
 139         error_report("milkymist_softusb: read dmem out of bounds "
 140                 "at offset 0x%x, len %d", offset, len);
 141         memset(buf, 0, len);
 142         return;
 143     }
 144
 145     memcpy(buf, s->dmem_ptr + offset, len);
 146 }
 147
 148 static inline void softusb_write_dmem(MilkymistSoftUsbState *s,
 149         uint32_t offset, uint8_t *buf, uint32_t len)
 150 {
 151     if (offset + len >= s->dmem_size) {
 152         error_report("milkymist_softusb: write dmem out of bounds "
 153                 "at offset 0x%x, len %d", offset, len);
 154         return;
 155     }
 156
 157     memcpy(s->dmem_ptr + offset, buf, len);
 158 }
 159
 160 static void softusb_mouse_changed(MilkymistSoftUsbState *s)
 161 {
 162     uint8_t m;
 163
 164     softusb_read_dmem(s, COMLOC_MEVT_PRODUCE, &m, 1);
 165     trace_milkymist_softusb_mevt(m);
 166     softusb_write_dmem(s, COMLOC_MEVT_BASE + 4 * m, s->mouse_hid_buffer, 4);
 167     m = (m + 1) & 0xf;
 168     softusb_write_dmem(s, COMLOC_MEVT_PRODUCE, &m, 1);
 169
 170     trace_milkymist_softusb_pulse_irq();
 171     qemu_irq_pulse(s->irq);
 172 }
 173
 174 static void softusb_kbd_changed(MilkymistSoftUsbState *s)
 175 {
 176     uint8_t m;
 177
 178     softusb_read_dmem(s, COMLOC_KEVT_PRODUCE, &m, 1);
 179     trace_milkymist_softusb_kevt(m);
 180     softusb_write_dmem(s, COMLOC_KEVT_BASE + 8 * m, s->kbd_hid_buffer, 8);
 181     m = (m + 1) & 0x7;
 182     softusb_write_dmem(s, COMLOC_KEVT_PRODUCE, &m, 1);
 183
 184     trace_milkymist_softusb_pulse_irq();
 185     qemu_irq_pulse(s->irq);
 186 }
 187
 188 static void softusb_kbd_hid_datain(HIDState *hs)
 189 {
 190     MilkymistSoftUsbState *s = container_of(hs, MilkymistSoftUsbState, hid_kbd);
 191     int len;
 192
 193     /* if device is in reset, do nothing */
 194     if (s->regs[R_CTRL] & CTRL_RESET) {
 195         return;
 196     }
 197
 198     while (hid_has_events(hs)) {
 199         len = hid_keyboard_poll(hs, s->kbd_hid_buffer,
 200                 sizeof(s->kbd_hid_buffer));
 201
 202         if (len == 8) {
 203             softusb_kbd_changed(s);
 204         }
 205     }
 206 }
 207
 208 static void softusb_mouse_hid_datain(HIDState *hs)
 209 {
 210     MilkymistSoftUsbState *s =
 211             container_of(hs, MilkymistSoftUsbState, hid_mouse);
 212     int len;
 213
 214     /* if device is in reset, do nothing */
 215     if (s->regs[R_CTRL] & CTRL_RESET) {
 216         return;
 217     }
 218
 219     while (hid_has_events(hs)) {
 220         len = hid_pointer_poll(hs, s->mouse_hid_buffer,
 221                 sizeof(s->mouse_hid_buffer));
 222
 223         if (len == 4) {
 224             softusb_mouse_changed(s);
 225         }
 226     }
 227 }
 228
 229 static void milkymist_softusb_reset(DeviceState *d)
 230 {
 231     MilkymistSoftUsbState *s = MILKYMIST_SOFTUSB(d);
 232     int i;
 233
 234     for (i = 0; i < R_MAX; i++) {
 235         s->regs[i] = 0;
 236     }
 237     memset(s->kbd_hid_buffer, 0, sizeof(s->kbd_hid_buffer));
 238     memset(s->mouse_hid_buffer, 0, sizeof(s->mouse_hid_buffer));
 239
 240     hid_reset(&s->hid_kbd);
 241     hid_reset(&s->hid_mouse);
 242
 243     /* defaults */
 244     s->regs[R_CTRL] = CTRL_RESET;
 245 }
 246
 247 static int milkymist_softusb_init(SysBusDevice *dev)
 248 {
 249     MilkymistSoftUsbState *s = MILKYMIST_SOFTUSB(dev);
 250
 251     sysbus_init_irq(dev, &s->irq);
 252
 253     memory_region_init_io(&s->regs_region, OBJECT(s), &softusb_mmio_ops, s,
 254                           "milkymist-softusb", R_MAX * 4);
 255     sysbus_init_mmio(dev, &s->regs_region);
 256
 257     /* register pmem and dmem */
 258     memory_region_init_ram(&s->pmem, OBJECT(s), "milkymist-softusb.pmem",
 259                            s->pmem_size, &error_fatal);
 260     vmstate_register_ram_global(&s->pmem);
 261     s->pmem_ptr = memory_region_get_ram_ptr(&s->pmem);
 262     sysbus_init_mmio(dev, &s->pmem);
 263     memory_region_init_ram(&s->dmem, OBJECT(s), "milkymist-softusb.dmem",
 264                            s->dmem_size, &error_fatal);
 265     vmstate_register_ram_global(&s->dmem);
 266     s->dmem_ptr = memory_region_get_ram_ptr(&s->dmem);
 267     sysbus_init_mmio(dev, &s->dmem);
 268
 269     hid_init(&s->hid_kbd, HID_KEYBOARD, softusb_kbd_hid_datain);
 270     hid_init(&s->hid_mouse, HID_MOUSE, softusb_mouse_hid_datain);
 271
 272     return 0;
 273 }
 274
 275 static const VMStateDescription vmstate_milkymist_softusb = {
 276     .name = "milkymist-softusb",
 277     .version_id = 1,
 278     .minimum_version_id = 1,
 279     .fields = (VMStateField[]) {
 280         VMSTATE_UINT32_ARRAY(regs, MilkymistSoftUsbState, R_MAX),
 281         VMSTATE_HID_KEYBOARD_DEVICE(hid_kbd, MilkymistSoftUsbState),
 282         VMSTATE_HID_POINTER_DEVICE(hid_mouse, MilkymistSoftUsbState),
 283         VMSTATE_BUFFER(kbd_hid_buffer, MilkymistSoftUsbState),
 284         VMSTATE_BUFFER(mouse_hid_buffer, MilkymistSoftUsbState),
 285         VMSTATE_END_OF_LIST()
 286     }
 287 };
 288
 289 static Property milkymist_softusb_properties[] = {
 290     DEFINE_PROP_UINT32("pmem_size", MilkymistSoftUsbState, pmem_size, 0x00001000),
 291     DEFINE_PROP_UINT32("dmem_size", MilkymistSoftUsbState, dmem_size, 0x00002000),
 292     DEFINE_PROP_END_OF_LIST(),
 293 };
 294
 295 static void milkymist_softusb_class_init(ObjectClass *klass, void *data)
 296 {
 297     DeviceClass *dc = DEVICE_CLASS(klass);
 298     SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
 299
 300     k->init = milkymist_softusb_init;
 301     dc->reset = milkymist_softusb_reset;
 302     dc->vmsd = &vmstate_milkymist_softusb;
 303     dc->props = milkymist_softusb_properties;
 304 }
 305
 306 static const TypeInfo milkymist_softusb_info = {
 307     .name          = TYPE_MILKYMIST_SOFTUSB,
 308     .parent        = TYPE_SYS_BUS_DEVICE,
 309     .instance_size = sizeof(MilkymistSoftUsbState),
 310     .class_init    = milkymist_softusb_class_init,
 311 };
 312
 313 static void milkymist_softusb_register_types(void)
 314 {
 315     type_register_static(&milkymist_softusb_info);
 316 }
 317
 318 type_init(milkymist_softusb_register_types)