palacios/src/devices/generic.c

   1 /* (c) 2008, Peter Dinda <pdinda@northwestern.edu> */
   2 /* (c) 2008, The V3VEE Project <http://www.v3vee.org> */
   3
   4
   5 #include <devices/generic.h>
   6 #include <palacios/vmm.h>
   7 #include <palacios/vmm_types.h>
   8 #include <geekos/io.h>
   9
  10
  11
  12 #ifndef DEBUG_GENERIC
  13 #undef PrintDebug
  14 #define PrintDebug(fmt, args...)
  15 #endif
  16
  17
  18 #define PORT_HOOKS 1
  19 #define MEM_HOOKS  0   // not yet implmented in device model
  20 #define IRQ_HOOKS  0   // not yet implemented in device model
  21
  22 struct generic_internal {
  23   generic_port_range_type    *port_ranges;
  24   uint_t                     num_port_ranges;
  25   generic_address_range_type *address_ranges;
  26   uint_t                     num_address_ranges;
  27   generic_irq_range_type     *irq_ranges;
  28   uint_t                     num_irq_ranges;
  29 };
  30
  31
  32
  33 int generic_reset_device(struct vm_device * dev)
  34 {
  35   PrintDebug("generic: reset device\n");
  36
  37   return 0;
  38
  39 }
  40
  41
  42
  43
  44
  45 int generic_start_device(struct vm_device *dev)
  46 {
  47   PrintDebug("generic: start device\n");
  48   return 0;
  49 }
  50
  51
  52 int generic_stop_device(struct vm_device *dev)
  53 {
  54   PrintDebug("generic: stop device\n");
  55   return 0;
  56 }
  57
  58
  59
  60
  61 int generic_write_port_passthrough(ushort_t port,
  62                                    void * src,
  63                                    uint_t length,
  64                                    struct vm_device * dev)
  65 {
  66   uint_t i;
  67
  68   PrintDebug("generic: writing 0x");
  69
  70   for (i = 0; i < length; i++) {
  71     PrintDebug("%x", ((uchar_t*)src)[i]);
  72   }
  73
  74   PrintDebug(" to port 0x%x ... ", port);
  75
  76
  77   switch (length) {
  78   case 1:
  79     Out_Byte(port,((uchar_t*)src)[0]);
  80     break;
  81   case 2:
  82     Out_Word(port,((ushort_t*)src)[0]);
  83     break;
  84   case 4:
  85     Out_DWord(port,((uint_t*)src)[0]);
  86     break;
  87   default:
  88     for (i = 0; i < length; i++) {
  89       Out_Byte(port, ((uchar_t*)src)[i]);
  90     }
  91   } //switch length
  92
  93
  94   PrintDebug(" done\n");
  95
  96   return length;
  97 }
  98
  99 int generic_read_port_passthrough(ushort_t port,
 100                                   void * src,
 101                                   uint_t length,
 102                                   struct vm_device * dev)
 103 {
 104   uint_t i;
 105
 106   PrintDebug("generic: reading 0x%x bytes from port 0x%x ...", length, port);
 107
 108
 109     switch (length) {
 110     case 1:
 111       ((uchar_t*)src)[0] = In_Byte(port);
 112       break;
 113     case 2:
 114       ((ushort_t*)src)[0] = In_Word(port);
 115       break;
 116     case 4:
 117       ((uint_t*)src)[0] = In_DWord(port);
 118       break;
 119     default:
 120       for (i = 0; i < length; i++) {
 121         ((uchar_t*)src)[i] = In_Byte(port);
 122       }
 123     }//switch length
 124
 125   PrintDebug(" done ... read 0x");
 126
 127   for (i = 0; i < length; i++) {
 128     PrintDebug("%x", ((uchar_t*)src)[i]);
 129   }
 130
 131   PrintDebug("\n");
 132
 133   return length;
 134 }
 135
 136 int generic_write_port_ignore(ushort_t port,
 137                               void * src,
 138                               uint_t length,
 139                               struct vm_device * dev)
 140 {
 141   uint_t i;
 142
 143   PrintDebug("generic: writing 0x");
 144
 145   for (i = 0; i < length; i++) {
 146     PrintDebug("%x", ((uchar_t*)src)[i]);
 147   }
 148
 149   PrintDebug(" to port 0x%x ... ", port);
 150
 151   PrintDebug(" ignored\n");
 152
 153   return length;
 154 }
 155
 156 int generic_read_port_ignore(ushort_t port,
 157                              void * src,
 158                              uint_t length,
 159                              struct vm_device * dev)
 160 {
 161
 162   PrintDebug("generic: reading 0x%x bytes from port 0x%x ...", length, port);
 163
 164   memset((char*)src,0,length);
 165   PrintDebug(" ignored (return zeroed buffer)\n");
 166
 167   return length;
 168 }
 169
 170
 171
 172 int generic_interrupt(uint_t irq,
 173                       struct vm_device * dev)
 174 {
 175   PrintDebug("generic: interrupt 0x%x - injecting into VM\n", irq);
 176
 177   dev->vm->vm_ops.raise_irq(dev->vm, irq);
 178
 179   return 0;
 180
 181 }
 182
 183
 184 int generic_init_device(struct vm_device * dev)
 185 {
 186   struct generic_internal *state = (struct generic_internal *)(dev->private_data);
 187   uint_t i, j;
 188
 189   PrintDebug("generic: init_device\n");
 190
 191   // Would read state here
 192
 193   generic_reset_device(dev);
 194
 195   for (i = 0; i < state->num_port_ranges; i++) {
 196     PrintDebug("generic: hooking ports 0x%x to 0x%x as %x\n", state->port_ranges[i][0], state->port_ranges[i][1], state->port_ranges[i][2]==GENERIC_PRINT_AND_PASSTHROUGH ? "print-and-passthrough" : "print-and-ignore");
 197
 198 #if PORT_HOOKS
 199     for (j = state->port_ranges[i][0]; j <= state->port_ranges[i][1]; j++) {
 200       if (state->port_ranges[i][2]==GENERIC_PRINT_AND_PASSTHROUGH) {
 201         if (dev_hook_io(dev, j, &generic_read_port_passthrough, &generic_write_port_passthrough)) {
 202           PrintDebug("generic: can't hook port 0x%x (already hooked?)\n", j);
 203         }
 204       } else if (state->port_ranges[i][2]==GENERIC_PRINT_AND_IGNORE) {
 205         if (dev_hook_io(dev, j, &generic_read_port_ignore, &generic_write_port_ignore)) {
 206           PrintDebug("generic: can't hook port 0x%x (already hooked?)\n", j);
 207         }
 208       }
 209     }
 210 #else
 211     PrintDebug("generic: hooking ports not supported\n");
 212 #endif
 213
 214   }
 215
 216   for (i = 0; i < state->num_address_ranges; i++) {
 217     PrintDebug("generic: hooking addresses 0x%x to 0x%x\n",state->address_ranges[i][0],state->address_ranges[i][1]);
 218
 219 #if MEM_HOOKS
 220     if (dev_hook_mem(dev, state->address_ranges[i][0], state->address_ranges[i][1])) {
 221       PrintDebug("generic: Can't hook addresses 0x%x to 0x%x (already hooked?)\n",
 222                   state->address_ranges[i][0], state->address_ranges[i][1]);
 223     }
 224 #else
 225     PrintDebug("generic: hooking addresses not supported\n");
 226 #endif
 227
 228   }
 229
 230   for (i = 0; i < state->num_irq_ranges; i++) {
 231     PrintDebug("generic: hooking irqs 0x%x to 0x%x\n",state->irq_ranges[i][0],state->irq_ranges[i][1]);
 232
 233 #if IRQ_HOOKS
 234     for (j = state->irq_ranges[i][0]; j <= state->irq_ranges[i][1]; j++) {
 235       if (dev_hook_irq(dev, j, &generic_interrupt)) {
 236         PrintDebug("generic: can't hook irq  0x%x (already hooked?)\n", j);
 237       }
 238     }
 239 #else
 240     PrintDebug("generic: hooking irqs not supported\n");
 241 #endif
 242
 243   }
 244
 245   return 0;
 246 }
 247
 248 int generic_deinit_device(struct vm_device *dev)
 249 {
 250   struct generic_internal *state = (struct generic_internal *)(dev->private_data);
 251   uint_t i, j;
 252
 253   PrintDebug("generic: deinit_device\n");
 254
 255
 256   for (i = 0; i < state->num_irq_ranges; i++) {
 257     PrintDebug("generic: unhooking irqs 0x%x to 0x%x\n", state->irq_ranges[i][0], state->irq_ranges[i][1]);
 258
 259 #if IRQ_HOOKS
 260     for (j = state->irq_ranges[i][0]; j <= state->irq_ranges[i][1]; j++) {
 261       if (dev_unhook_irq(dev, j)) {
 262         PrintDebug("generic: can't unhook irq 0x%x (already unhooked?)\n",j);
 263       }
 264     }
 265 #else
 266     PrintDebug("generic: unhooking irqs not supported\n");
 267 #endif
 268
 269   }
 270
 271   for (i = 0; i < state->num_address_ranges; i++) {
 272     PrintDebug("generic: unhooking addresses 0x%x to 0x%x\n",state->address_ranges[i][0],state->address_ranges[i][1]);
 273
 274 #if MEM_HOOKS
 275     if (dev_unhook_mem(dev, state->address_ranges[i][0], state->address_ranges[i][1])) {
 276       PrintDebug("generic: Can't unhook addresses 0x%x to 0x%x (already unhooked?)\n",
 277                   state->address_ranges[i][0], state->address_ranges[i][1]);
 278     }
 279 #else
 280     PrintDebug("generic: unhooking addresses not supported\n");
 281 #endif
 282
 283   }
 284
 285   for (i = 0; i < state->num_port_ranges; i++) {
 286     PrintDebug("generic: unhooking ports 0x%x to 0x%x\n",state->port_ranges[i][0],state->port_ranges[i][1]);
 287
 288 #if PORT_HOOKS
 289     for (j = state->port_ranges[i][0]; j <= state->port_ranges[i][1]; j++) {
 290       if (dev_unhook_io(dev, j)) {
 291         PrintDebug("generic: can't unhook port 0x%x (already unhooked?)\n", j);
 292       }
 293     }
 294 #else
 295     PrintDebug("generic: unhooking ports not supported\n");
 296 #endif
 297
 298   }
 299
 300   generic_reset_device(dev);
 301   return 0;
 302 }
 303
 304
 305
 306
 307
 308 static struct vm_device_ops dev_ops = {
 309   .init = generic_init_device,
 310   .deinit = generic_deinit_device,
 311   .reset = generic_reset_device,
 312   .start = generic_start_device,
 313   .stop = generic_stop_device,
 314 };
 315
 316
 317
 318
 319 struct vm_device *create_generic(generic_port_range_type    port_ranges[],
 320                                  generic_address_range_type address_ranges[],
 321                                  generic_irq_range_type     irq_ranges[])
 322 {
 323   struct generic_internal * generic_state = (struct generic_internal *)V3_Malloc(sizeof(struct generic_internal));
 324   int i;
 325   uint_t num_port_ranges, num_address_ranges, num_irq_ranges;
 326
 327   num_port_ranges=0;
 328   if (port_ranges!=NULL) {
 329     i=0;
 330     while (port_ranges[i]!=NULL &&
 331            !(port_ranges[i][0]==0 && port_ranges[i][1]==0 && port_ranges[i][2]==0))
 332       { num_port_ranges++; i++; }
 333   }
 334
 335
 336   num_address_ranges=0;
 337   if (address_ranges!=NULL) {
 338     i=0;
 339     while (address_ranges[i]!=NULL  &&
 340            !(address_ranges[i][0]==0 && address_ranges[i][1]==0 && address_ranges[i][2]==0))
 341       { num_address_ranges++; i++; }
 342   }
 343
 344   num_irq_ranges=0;
 345   if (irq_ranges!=NULL) {
 346     i=0;
 347     while (irq_ranges[i]!=NULL &&
 348            !(irq_ranges[i][0]==0 && irq_ranges[i][1]==0 && irq_ranges[i][2]==0) )
 349       { num_irq_ranges++; i++; }
 350   }
 351
 352
 353   generic_state->num_port_ranges = num_port_ranges;
 354
 355   if (num_port_ranges > 0) {
 356     generic_state->port_ranges = V3_Malloc(sizeof(generic_address_range_type) * num_port_ranges);
 357     memcpy(generic_state->port_ranges, port_ranges, sizeof(generic_port_range_type) * num_port_ranges);
 358   } else {
 359     generic_state->port_ranges = NULL;
 360   }
 361
 362
 363   generic_state->num_address_ranges = num_address_ranges;
 364
 365   if (num_address_ranges > 0) {
 366     generic_state->address_ranges = V3_Malloc(sizeof(generic_address_range_type) * num_address_ranges);
 367     memcpy(generic_state->address_ranges, address_ranges, sizeof(generic_address_range_type) * num_address_ranges);
 368   } else {
 369     generic_state->address_ranges = NULL;
 370   }
 371
 372
 373   generic_state->num_irq_ranges = num_irq_ranges;
 374
 375   if (num_irq_ranges > 0) {
 376     generic_state->irq_ranges = V3_Malloc(sizeof(generic_address_range_type) * num_irq_ranges);
 377     memcpy(generic_state->irq_ranges, irq_ranges, sizeof(generic_irq_range_type) * num_port_ranges);
 378   } else {
 379     generic_state->irq_ranges = NULL;
 380   }
 381
 382   struct vm_device *device = create_device("GENERIC", &dev_ops, generic_state);
 383
 384   return device;
 385 }