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