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