palacios/src/devices/keyboard.c

   1 #include <devices/keyboard.h>
   2 #include <geekos/io.h>
   3 #include <palacios/vmm.h>
   4 #include <palacios/vmm_types.h>
   5
   6 extern struct vmm_os_hooks *os_hooks;
   7
   8 extern void SerialPrint(const char *format, ...);
   9
  10
  11
  12 #define KEYBOARD_DATA_REG          0x60
  13 #define KEYBOARD_CONTROL_REG       0x64
  14
  15 #define KEYBOARD_IRQ    0x1
  16
  17
  18
  19 struct keyboard_internal {
  20   int x;
  21   // figure this out later - it should be the internal state of the keyboard buffer and
  22   // the emulated status, etc.
  23   // which should be fed from the underlying OS and drained via this interface
  24 };
  25
  26
  27
  28
  29 int keyboard_reset_device(struct vm_device * dev)
  30 {
  31   //  struct keyboard_internal *data = (struct keyboard_internal *) dev->private_data;
  32
  33   SerialPrint("keyboard: reset device\n");
  34
  35
  36   return 0;
  37
  38 }
  39
  40
  41
  42
  43
  44 int keyboard_start_device(struct vm_device *dev)
  45 {
  46   SerialPrint("keyboard: start device\n");
  47   return 0;
  48 }
  49
  50
  51 int keyboard_stop_device(struct vm_device *dev)
  52 {
  53   SerialPrint("keyboard: stop device\n");
  54   return 0;
  55 }
  56
  57
  58
  59
  60 int keyboard_write_control_port(ushort_t port,
  61                                 void * src,
  62                                 uint_t length,
  63                                 struct vm_device * dev)
  64 {
  65   //struct keyboard_internal *data = (struct keyboard_internal *) dev->private_data;
  66
  67   if (length==1) {
  68     uchar_t data = *((uchar_t*)src);
  69     PrintDebug("keyboard: write of 0x%x to control port\n",data);
  70     Out_Byte(KEYBOARD_CONTROL_REG,data);
  71     return 1;
  72   } else {
  73     PrintDebug("keyboard: unknown size write to control port!\n");
  74     return -1;
  75   }
  76 }
  77
  78 int keyboard_read_control_port(ushort_t port,
  79                                void * dest,
  80                                uint_t length,
  81                                struct vm_device * dev)
  82 {
  83   //struct keyboard_internal *data = (struct keyboard_internal *) dev->private_data;
  84
  85   if (length==1) {
  86     uchar_t data;
  87     PrintDebug("keyboard: read from control port: ");
  88     data=In_Byte(KEYBOARD_CONTROL_REG);
  89     PrintDebug("0x%x\n",data);
  90     memcpy(dest,&data,1);
  91     return 1;
  92   } else {
  93     PrintDebug("keyboard: unknown size read from control port!\n");
  94     return -1;
  95   }
  96 }
  97
  98 int keyboard_write_data_port(ushort_t port,
  99                              void * src,
 100                              uint_t length,
 101                              struct vm_device * dev)
 102 {
 103   //struct keyboard_internal *data = (struct keyboard_internal *) dev->private_data;
 104
 105   if (length==1) {
 106     uchar_t data = *((uchar_t*)src);
 107     PrintDebug("keyboard: write of 0x%x to data port\n",data);
 108     Out_Byte(KEYBOARD_DATA_REG,data);
 109     return 1;
 110   } else {
 111     PrintDebug("keyboard: unknown size write to data port!\n");
 112     return -1;
 113   }
 114 }
 115
 116 int keyboard_read_data_port(ushort_t port,
 117                             void * dest,
 118                             uint_t length,
 119                             struct vm_device * dev)
 120 {
 121   //struct keyboard_internal *data = (struct keyboard_internal *) dev->private_data;
 122
 123   if (length==1) {
 124     uchar_t data;
 125     PrintDebug("keyboard: read from data port: ");
 126     data=In_Byte(KEYBOARD_DATA_REG);
 127     PrintDebug("0x%x\n",data);
 128     memcpy(dest,&data,1);
 129     return 1;
 130   } else {
 131     PrintDebug("keyboard: unknown size read from data port!\n");
 132     return -1;
 133   }
 134 }
 135
 136
 137 int keyboard_interrupt(uint_t irq,
 138                        struct vm_device * dev)
 139 {
 140   PrintDebug("keyboard: interrupt\n");
 141   return 0;
 142   // Inject ?
 143 }
 144
 145
 146 int keyboard_init_device(struct vm_device * dev)
 147 {
 148
 149   //  struct keyboard_internal *data = (struct keyboard_internal *) dev->private_data;
 150
 151   SerialPrint("keyboard: init_device\n");
 152
 153   // Would read state here
 154
 155   keyboard_reset_device(dev);
 156
 157   // hook ports
 158   dev_hook_io(dev, KEYBOARD_DATA_REG, &keyboard_read_data_port, &keyboard_write_data_port);
 159   dev_hook_io(dev, KEYBOARD_CONTROL_REG, &keyboard_read_control_port, &keyboard_write_control_port);
 160
 161   // hook irq
 162   // currently assume this is done in vm.c?
 163   //dev_hook_irq(dev,KEYBOARD_IRQ,&keyboard_interrupt);
 164
 165
 166   return 0;
 167 }
 168
 169 int keyboard_deinit_device(struct vm_device *dev)
 170 {
 171
 172
 173   //dev_unhook_irq(dev,KEYBOARD_IRQ);
 174   dev_unhook_io(dev, KEYBOARD_DATA_REG);
 175   dev_unhook_io(dev, KEYBOARD_CONTROL_REG);
 176
 177   keyboard_reset_device(dev);
 178   return 0;
 179 }
 180
 181
 182
 183
 184
 185 static struct vm_device_ops dev_ops = {
 186   .init = keyboard_init_device,
 187   .deinit = keyboard_deinit_device,
 188   .reset = keyboard_reset_device,
 189   .start = keyboard_start_device,
 190   .stop = keyboard_stop_device,
 191 };
 192
 193
 194
 195
 196 struct vm_device *create_keyboard() {
 197   struct keyboard_internal * keyboard_state = os_hooks->malloc(sizeof(struct keyboard_internal));
 198
 199   struct vm_device *device = create_device("KEYBOARD", &dev_ops, keyboard_state);
 200
 201   return device;
 202 }