}
+static inline v3_reg_t get_gpr_mask(struct guest_info * info) {
+ switch (info->cpu_mode) {
+ case REAL:
+ return 0xffff;
+ break;
+ case PROTECTED:
+ case PROTECTED_PG:
+ return 0xffffffff;
+ default:
+ V3_ASSERT(0);
+ return 0;
+ }
+}
+
static inline addr_t get_addr_linear(struct guest_info * info, addr_t addr, struct v3_segment * seg) {
switch (info->cpu_mode) {
return addr + seg->base;
break;
default:
+ V3_ASSERT(0);
return 0;
}
}
uint_t channel_cycles = 0;
uint_t output_changed = 0;
- PrintDebug("8254 PIT: %d crystal tics\n", oscillations);
+ // PrintDebug("8254 PIT: %d crystal tics\n", oscillations);
if (ch->run_state == PENDING) {
oscillations--;
ch->counter = ch->reload_value;
+
+ if (ch->op_mode == SQR_WAVE) {
+ ch->counter -= ch->counter % 2;
+ }
+
ch->run_state = RUNNING;
} else if (ch->run_state != RUNNING) {
return output_changed;
}
-
+ /*
PrintDebug("8254 PIT: Channel Run State = %d, counter=", ch->run_state);
PrintTraceLL(ch->counter);
PrintDebug("\n");
-
+ */
+ if (ch->op_mode == SQR_WAVE) {
+ oscillations *= 2;
+ }
if (ch->counter > oscillations) {
ch->counter -= oscillations;
return output_changed;
} else {
+ ushort_t reload_val = ch->reload_value;
oscillations -= ch->counter;
ch->counter = 0;
channel_cycles = 1;
- channel_cycles += oscillations / ch->reload_value;
- oscillations = oscillations % ch->reload_value;
+ if (ch->op_mode == SQR_WAVE) {
+ reload_val -= reload_val % 2;
+ }
+
+ channel_cycles += oscillations / reload_val;
+ oscillations = oscillations % reload_val;
- ch->counter = ch->reload_value - oscillations;
+ ch->counter = reload_val - oscillations;
}
- PrintDebug("8254 PIT: Channel Cycles: %d\n", channel_cycles);
+ // PrintDebug("8254 PIT: Channel Cycles: %d\n", channel_cycles);
}
break;
case SQR_WAVE:
+ ch->output_pin = (ch->output_pin + 1) % 2;
+
+ if (ch->output_pin == 1) {
+ output_changed = 1;
+ }
+
break;
case SW_STROBE:
+ return -1;
break;
case HW_STROBE:
+ return -1;
break;
default:
break;
case WAITING_LOBYTE:
ch->reload_value &= 0xff00;
ch->reload_value |= val;
-
+
if (ch->access_mode == LOBYTE_HIBYTE) {
ch->access_state = WAITING_HIBYTE;
} else if ((ch->op_mode != RATE_GEN) || (ch->run_state != RUNNING)) {
ch->run_state = PENDING;
}
-
+
PrintDebug("8254 PIT: updated channel counter: %d\n", ch->reload_value);
PrintDebug("8254 PIT: Channel Run State=%d\n", ch->run_state);
break;
default:
return -1;
- }
-
+ }
+
switch (ch->op_mode) {
case IRQ_ON_TERM_CNT:
case RATE_GEN:
ch->output_pin = 1;
break;
-
-
+ case SQR_WAVE:
+ ch->output_pin = 1;
+ break;
default:
return -1;
break;
uint_t i;
GENERIC_DEBUG_PRINT("generic: writing 0x");
- for (i=0;i<length;i++) {
- GENERIC_DEBUG_PRINT("%x",((uchar_t*)src)[i]);
+
+ for (i = 0; i < length; i++) {
+ GENERIC_DEBUG_PRINT("%x", ((uchar_t*)src)[i]);
}
- GENERIC_DEBUG_PRINT(" to port 0x%x ... ",port);
- for (i=0;i<length;i++) {
- Out_Byte(port,((uchar_t*)src)[i]);
+
+ GENERIC_DEBUG_PRINT(" to port 0x%x ... ", port);
+
+ for (i = 0; i < length; i++) {
+ Out_Byte(port, ((uchar_t*)src)[i]);
}
+
GENERIC_DEBUG_PRINT(" done\n");
return length;
{
uint_t i;
- GENERIC_DEBUG_PRINT("generic: reading 0x%x bytes from port 0x%x ...",length,port);
- for (i=0;i<length;i++) {
- ((uchar_t*)src)[i] =In_Byte(port);
+ GENERIC_DEBUG_PRINT("generic: reading 0x%x bytes from port 0x%x ...", length, port);
+
+ for (i = 0; i < length; i++) {
+ ((uchar_t*)src)[i] = In_Byte(port);
}
+
GENERIC_DEBUG_PRINT(" done ... read 0x");
- for (i=0;i<length;i++) {
- GENERIC_DEBUG_PRINT("%x",((uchar_t*)src)[i]);
+
+ for (i = 0; i < length; i++) {
+ GENERIC_DEBUG_PRINT("%x", ((uchar_t*)src)[i]);
}
+
GENERIC_DEBUG_PRINT("\n");
return length;
int generic_interrupt(uint_t irq,
struct vm_device * dev)
{
- PrintDebug("generic: interrupt 0x%x - injecting into VM\n",irq);
+ PrintDebug("generic: interrupt 0x%x - injecting into VM\n", irq);
- dev->vm->vm_ops.raise_irq(dev->vm,irq);
+ dev->vm->vm_ops.raise_irq(dev->vm, irq);
return 0;
int generic_init_device(struct vm_device * dev)
{
- struct generic_internal *state = (struct generic_internal *) dev->private_data;
- uint_t i,j;
+ struct generic_internal *state = (struct generic_internal *)(dev->private_data);
+ uint_t i, j;
GENERIC_DEBUG_PRINT("generic: init_device\n");
generic_reset_device(dev);
- for (i=0;i<state->num_port_ranges;i++) {
- GENERIC_DEBUG_PRINT("generic: hooking ports 0x%x to 0x%x\n",state->port_ranges[i][0],state->port_ranges[i][1]);
+ for (i = 0; i < state->num_port_ranges; i++) {
+ GENERIC_DEBUG_PRINT("generic: hooking ports 0x%x to 0x%x\n", state->port_ranges[i][0], state->port_ranges[i][1]);
+
#if PORT_HOOKS
- for (j=state->port_ranges[i][0]; j<=state->port_ranges[i][1];j++) {
+ for (j = state->port_ranges[i][0]; j <= state->port_ranges[i][1]; j++) {
if (dev_hook_io(dev, j, &generic_read_port, &generic_write_port)) {
- GENERIC_DEBUG_PRINT("generic: can't hook port 0x%x (already hooked?)\n",j);
+ GENERIC_DEBUG_PRINT("generic: can't hook port 0x%x (already hooked?)\n", j);
}
}
#else
}
- for (i=0;i<state->num_address_ranges;i++) {
+ for (i = 0; i < state->num_address_ranges; i++) {
GENERIC_DEBUG_PRINT("generic: hooking addresses 0x%x to 0x%x\n",state->address_ranges[i][0],state->address_ranges[i][1]);
+
#if MEM_HOOKS
- if (dev_hook_mem(dev, state->address_ranges[i][0],state->address_ranges[i][1])) {
+ if (dev_hook_mem(dev, state->address_ranges[i][0], state->address_ranges[i][1])) {
GENERIC_DEBUG_PRINT("generic: Can't hook addresses 0x%x to 0x%x (already hooked?)\n",
- state->address_ranges[i][0],state->address_ranges[i][1]);
+ state->address_ranges[i][0], state->address_ranges[i][1]);
}
#else
GENERIC_DEBUG_PRINT("generic: hooking addresses not supported\n");
}
- for (i=0;i<state->num_irq_ranges;i++) {
+ for (i = 0; i < state->num_irq_ranges; i++) {
GENERIC_DEBUG_PRINT("generic: hooking irqs 0x%x to 0x%x\n",state->irq_ranges[i][0],state->irq_ranges[i][1]);
+
#if IRQ_HOOKS
- for (j=state->irq_ranges[i][0]; j<=state->irq_ranges[i][1];j++) {
- if (dev_hook_irq(dev, j, &generic_interrupt)) {
- GENERIC_DEBUG_PRINT("generic: can't hook irq 0x%x (already hooked?)\n",j);
+ for (j = state->irq_ranges[i][0]; j <= state->irq_ranges[i][1]; j++) {
+ if (dev_hook_irq(dev, j, &generic_interrupt)) {
+ GENERIC_DEBUG_PRINT("generic: can't hook irq 0x%x (already hooked?)\n", j);
}
}
#else
GENERIC_DEBUG_PRINT("generic: hooking irqs not supported\n");
#endif
+
}
return 0;
int generic_deinit_device(struct vm_device *dev)
{
- struct generic_internal *state = (struct generic_internal *) dev->private_data;
- uint_t i,j;
+ struct generic_internal *state = (struct generic_internal *)(dev->private_data);
+ uint_t i, j;
GENERIC_DEBUG_PRINT("generic: deinit_device\n");
- for (i=0;i<state->num_irq_ranges;i++) {
- GENERIC_DEBUG_PRINT("generic: unhooking irqs 0x%x to 0x%x\n",state->irq_ranges[i][0],state->irq_ranges[i][1]);
+ for (i = 0; i < state->num_irq_ranges; i++) {
+ GENERIC_DEBUG_PRINT("generic: unhooking irqs 0x%x to 0x%x\n", state->irq_ranges[i][0], state->irq_ranges[i][1]);
+
#if IRQ_HOOKS
- for (j=state->irq_ranges[i][0]; j<=state->irq_ranges[i][1];j++) {
+ for (j = state->irq_ranges[i][0]; j <= state->irq_ranges[i][1]; j++) {
if (dev_unhook_irq(dev, j)) {
GENERIC_DEBUG_PRINT("generic: can't unhook irq 0x%x (already unhooked?)\n",j);
}
}
- for (i=0;i<state->num_address_ranges;i++) {
+ for (i = 0; i < state->num_address_ranges; i++) {
GENERIC_DEBUG_PRINT("generic: unhooking addresses 0x%x to 0x%x\n",state->address_ranges[i][0],state->address_ranges[i][1]);
+
#if MEM_HOOKS
- if (dev_unhook_mem(dev, state->address_ranges[i][0],state->address_ranges[i][1])) {
+ if (dev_unhook_mem(dev, state->address_ranges[i][0], state->address_ranges[i][1])) {
GENERIC_DEBUG_PRINT("generic: Can't unhook addresses 0x%x to 0x%x (already unhooked?)\n",
- state->address_ranges[i][0],state->address_ranges[i][1]);
+ state->address_ranges[i][0], state->address_ranges[i][1]);
}
#else
GENERIC_DEBUG_PRINT("generic: unhooking addresses not supported\n");
#endif
+
}
- for (i=0;i<state->num_port_ranges;i++) {
+ for (i = 0; i < state->num_port_ranges; i++) {
GENERIC_DEBUG_PRINT("generic: unhooking ports 0x%x to 0x%x\n",state->port_ranges[i][0],state->port_ranges[i][1]);
+
#if PORT_HOOKS
- for (j=state->port_ranges[i][0]; j<=state->port_ranges[i][1];j++) {
+ for (j = state->port_ranges[i][0]; j <= state->port_ranges[i][1]; j++) {
if (dev_unhook_io(dev, j)) {
- GENERIC_DEBUG_PRINT("generic: can't unhook port 0x%x (already unhooked?)\n",j);
+ GENERIC_DEBUG_PRINT("generic: can't unhook port 0x%x (already unhooked?)\n", j);
}
}
#else
struct generic_internal * generic_state = (struct generic_internal *)V3_Malloc(sizeof(struct generic_internal));
- generic_state->num_port_ranges=num_port_ranges;
- if (num_port_ranges>0) {
- generic_state->port_ranges = V3_Malloc(sizeof(generic_address_range_type)*num_port_ranges);
- memcpy(generic_state->port_ranges,port_ranges,sizeof(generic_port_range_type)*num_port_ranges);
+ generic_state->num_port_ranges = num_port_ranges;
+
+ if (num_port_ranges > 0) {
+ generic_state->port_ranges = V3_Malloc(sizeof(generic_address_range_type) * num_port_ranges);
+ memcpy(generic_state->port_ranges, port_ranges, sizeof(generic_port_range_type) * num_port_ranges);
} else {
- generic_state->port_ranges=NULL;
+ generic_state->port_ranges = NULL;
}
- generic_state->num_address_ranges=num_address_ranges;
- if (num_address_ranges>0) {
- generic_state->address_ranges = V3_Malloc(sizeof(generic_address_range_type)*num_address_ranges);
- memcpy(generic_state->address_ranges,address_ranges,sizeof(generic_address_range_type)*num_address_ranges);
+
+ generic_state->num_address_ranges = num_address_ranges;
+
+ if (num_address_ranges > 0) {
+ generic_state->address_ranges = V3_Malloc(sizeof(generic_address_range_type) * num_address_ranges);
+ memcpy(generic_state->address_ranges, address_ranges, sizeof(generic_address_range_type) * num_address_ranges);
} else {
- generic_state->address_ranges=NULL;
+ generic_state->address_ranges = NULL;
}
- generic_state->num_irq_ranges=num_irq_ranges;
- if (num_irq_ranges>0) {
- generic_state->irq_ranges = V3_Malloc(sizeof(generic_address_range_type)*num_irq_ranges);
- memcpy(generic_state->irq_ranges,irq_ranges,sizeof(generic_irq_range_type)*num_port_ranges);
+
+
+ generic_state->num_irq_ranges = num_irq_ranges;
+
+ if (num_irq_ranges > 0) {
+ generic_state->irq_ranges = V3_Malloc(sizeof(generic_address_range_type) * num_irq_ranges);
+ memcpy(generic_state->irq_ranges, irq_ranges, sizeof(generic_irq_range_type) * num_port_ranges);
} else {
- generic_state->irq_ranges=NULL;
+ generic_state->irq_ranges = NULL;
}
#endif
-extern struct vmm_os_hooks *os_hooks;
-
-extern void SerialPrint(const char *format, ...);
-
-
-
#define KEYBOARD_60H 0x60 // keyboard microcontroller
#define KEYBOARD_64H 0x64 // onboard microcontroller
#define KEYBOARD_DELAY_80H 0x80 // written for timing
-#define KEYBOARD_IRQ 0x1
+#define KEYBOARD_IRQ 0x1
// extract bits for status byte
#define CMD_RESERVED 0x80 // should be zero
// The currently targetted keyboard
-static struct vm_device *thekeyboard=NULL;
+static struct vm_device *thekeyboard = NULL;
struct keyboard_internal {
//
static int PushToOutputQueue(struct vm_device *dev, uchar_t value, uchar_t overwrite)
{
- struct keyboard_internal *state = (struct keyboard_internal *)dev->private_data;
+ struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
- if (state->output_queue_len==0 || overwrite) {
- state->output_queue=value;
- state->output_queue_len=1;
+ if ((state->output_queue_len == 0) || overwrite) {
+
+ state->output_queue = value;
+ state->output_queue_len = 1;
state->status_byte |= STATUS_OUTPUT_BUFFER_FULL;
+
return 0;
} else {
KEYBOARD_DEBUG_PRINT("keyboard: PushToOutputQueue Failed - Queue Full\n");
// pull item from outputqueue
// returns 0 if successful
//
-static int PullFromOutputQueue(struct vm_device *dev,uchar_t *value)
+static int PullFromOutputQueue(struct vm_device *dev, uchar_t *value)
{
- struct keyboard_internal *state = (struct keyboard_internal *)dev->private_data;
- if (state->output_queue_len==1) {
- *value=state->output_queue;
- state->output_queue_len=0;
+ struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
+
+ if (state->output_queue_len == 1) {
+
+ *value = state->output_queue;
+ state->output_queue_len = 0;
state->status_byte &= ~STATUS_OUTPUT_BUFFER_FULL;
+
return 0;
} else {
KEYBOARD_DEBUG_PRINT("keyboard: PullFromOutputQueue Failed - Queue Empty\n");
//
static int PushToInputQueue(struct vm_device *dev, uchar_t value, uchar_t overwrite)
{
- struct keyboard_internal *state = (struct keyboard_internal *)dev->private_data;
- if (state->input_queue_len==0 || overwrite) {
- state->input_queue=value;
- state->input_queue_len=1;
+ struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
+
+ if ((state->input_queue_len == 0) || overwrite) {
+
+ state->input_queue = value;
+ state->input_queue_len = 1;
state->status_byte |= STATUS_INPUT_BUFFER_FULL;
+
return 0;
} else {
KEYBOARD_DEBUG_PRINT("keyboard: PushToOutputQueue Failed - Queue Full\n");
//
static int PullFromInputQueue(struct vm_device *dev, uchar_t *value)
{
- struct keyboard_internal *state = (struct keyboard_internal *)dev->private_data;
- if (state->input_queue_len==1) {
- *value=state->input_queue;
- state->input_queue_len=0;
- state->status_byte &=~STATUS_INPUT_BUFFER_FULL;
+ struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
+
+ if (state->input_queue_len == 1) {
+
+ *value = state->input_queue;
+ state->input_queue_len = 0;
+ state->status_byte &= ~STATUS_INPUT_BUFFER_FULL;
+
return 0;
} else {
KEYBOARD_DEBUG_PRINT("keyboard: PullFromInputQueue Failed - Queue Empty\n");
+
return -1;
}
}
return thekeyboard;
}
-int keyboard_interrupt(uint_t irq,struct vm_device * dev);
+int keyboard_interrupt(uint_t irq, struct vm_device * dev);
void deliver_key_to_vmm(uchar_t status, uchar_t scancode)
{
- struct vm_device *dev = demultiplex_injected_key(status,scancode);
+ struct vm_device *dev = demultiplex_injected_key(status, scancode);
+ struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
- struct keyboard_internal *state = (struct keyboard_internal *)dev->private_data;
-
- KEYBOARD_DEBUG_PRINT("keyboard: injected status 0x%x, and scancode 0x%x\n", status,scancode);
+ KEYBOARD_DEBUG_PRINT("keyboard: injected status 0x%x, and scancode 0x%x\n", status, scancode);
- if ( (state->status_byte & STATUS_ENABLED) // onboard is enabled
- && (!(state->cmd_byte & CMD_DISABLE))) { // keyboard is enabled
+ if ( (state->status_byte & STATUS_ENABLED) // onboard is enabled
+ && (!(state->cmd_byte & CMD_DISABLE)) ) { // keyboard is enabled
- PushToOutputQueue(dev,scancode,1);
+ PushToOutputQueue(dev, scancode, 1);
if (state->cmd_byte & CMD_INTR) {
- keyboard_interrupt(KEYBOARD_IRQ,dev);
+ keyboard_interrupt(KEYBOARD_IRQ, dev);
}
}
int keyboard_reset_device(struct vm_device * dev)
{
- struct keyboard_internal *data = (struct keyboard_internal *) dev->private_data;
+ struct keyboard_internal *data = (struct keyboard_internal *)(dev->private_data);
- memset(data,0,sizeof(struct keyboard_internal));
+ memset(data, 0, sizeof(struct keyboard_internal));
data->cmd_byte =
CMD_INTR // interrupts on
uint_t length,
struct vm_device * dev)
{
- if (length==1) {
+
+ if (length == 1) {
KEYBOARD_DEBUG_PRINT("keyboard: write of 0x%x to 80h\n", *((uchar_t*)src));
+
return 1;
} else {
KEYBOARD_DEBUG_PRINT("keyboard: write of >1 byte to 80h\n", *((uchar_t*)src));
+
return length;
}
}
uint_t length,
struct vm_device * dev)
{
- if (length==1) {
+
+ if (length == 1) {
*((uchar_t*)dest) = In_Byte(port);
+
KEYBOARD_DEBUG_PRINT("keyboard: read of 0x%x from 80h\n", *((uchar_t*)dest));
+
return 1;
} else {
KEYBOARD_DEBUG_PRINT("keyboard: read of >1 byte from 80h\n");
+
return length;
}
}
uint_t length,
struct vm_device * dev)
{
- struct keyboard_internal *state = (struct keyboard_internal *) dev->private_data;
+ struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
uchar_t cmd;
// Should always be single byte write
- if (length!=1) {
- KEYBOARD_DEBUG_PRINT("keyboard: write of >1 bytes (%d) to 64h\n",length);
+ if (length != 1) {
+ KEYBOARD_DEBUG_PRINT("keyboard: write of >1 bytes (%d) to 64h\n", length);
return -1;
}
- cmd = *((uchar_t*)src);
+ cmd = *((uchar_t*)src);
- if (state->state!=NORMAL) {
- KEYBOARD_DEBUG_PRINT("keyboard: warning - receiving command on 64h but state!=NORMAL\n");
+ if (state->state != NORMAL) {
+ KEYBOARD_DEBUG_PRINT("keyboard: warning - receiving command on 64h but state != NORMAL\n");
}
- KEYBOARD_DEBUG_PRINT("keyboard: command 0x%x on 64h\n",cmd);
+ KEYBOARD_DEBUG_PRINT("keyboard: command 0x%x on 64h\n", cmd);
switch (cmd) {
case 0x20: // READ COMMAND BYTE (returned in 60h)
- PushToOutputQueue(dev,state->cmd_byte,1);
- state->state=NORMAL; // the next read on 0x60 will get the right data
+ PushToOutputQueue(dev, state->cmd_byte, 1);
+ state->state = NORMAL; // the next read on 0x60 will get the right data
break;
case 0x60: // WRITE COMMAND BYTE (read from 60h)
- state->state=WRITING_CMD_BYTE; // we need to make sure we send the next 0x60 byte appropriately
+ state->state = WRITING_CMD_BYTE; // we need to make sure we send the next 0x60 byte appropriately
break;
// case 0x90-9f - write to output port (?)
case 0xa1: // Get version number
- PushToOutputQueue(dev,0,1);
- state->state=NORMAL;
+ PushToOutputQueue(dev, 0, 1);
+ state->state = NORMAL;
break;
case 0xa4: // is password installed? send result to 0x60
// we don't support passwords
- PushToOutputQueue(dev,0xf1,1);
- state->state=NORMAL;
+ PushToOutputQueue(dev, 0xf1, 1);
+ state->state = NORMAL;
break;
case 0xa5: // new password will arrive on 0x60
- state->state=TRANSMIT_PASSWD;
+ state->state = TRANSMIT_PASSWD;
break;
case 0xa6: // check passwd;
// since we do not support passwords, we will simply ignore this
// the implication is that any password check immediately succeeds
// with a blank password
- state->state=NORMAL;
+ state->state = NORMAL;
break;
case 0xa7: // disable mouse
state->cmd_byte |= CMD_MOUSE_DISABLE;
- state->state=NORMAL;
+ state->state = NORMAL;
break;
case 0xa8: // enable mouse
state->cmd_byte &= ~CMD_MOUSE_DISABLE;
- state->state=NORMAL;
+ state->state = NORMAL;
break;
case 0xa9: // mouse interface test (always succeeds)
- PushToOutputQueue(dev,0,1);
- state->state=NORMAL;
+ PushToOutputQueue(dev, 0, 1);
+ state->state = NORMAL;
break;
case 0xaa: // controller self test (always succeeds)
- PushToOutputQueue(dev,0x55,1);
- state->state=NORMAL;
+ PushToOutputQueue(dev, 0x55, 1);
+ state->state = NORMAL;
break;
case 0xab: // keyboard interface test (always succeeds)
- PushToOutputQueue(dev,0,1);
- state->state=NORMAL;
+ PushToOutputQueue(dev, 0, 1);
+ state->state = NORMAL;
break;
case 0xad: // disable keyboard
state->cmd_byte |= CMD_DISABLE;
- state->state=NORMAL;
+ state->state = NORMAL;
break;
case 0xae: // enable keyboard
state->cmd_byte &= ~CMD_DISABLE;
- state->state=NORMAL;
+ state->state = NORMAL;
break;
case 0xaf: // get version
- PushToOutputQueue(dev,0x00,1);
- state->state=NORMAL;
+ PushToOutputQueue(dev, 0x00, 1);
+ state->state = NORMAL;
break;
// case c0 read input port ?
default:
KEYBOARD_DEBUG_PRINT("keyboard: ignoring command (unimplemented)\n");
- state->state=NORMAL;
+ state->state = NORMAL;
break;
}
uint_t length,
struct vm_device * dev)
{
- struct keyboard_internal *state = (struct keyboard_internal *) dev->private_data;
+ struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
+
+ if (length == 1) {
- if (length==1) {
KEYBOARD_DEBUG_PRINT("keyboard: read status (64h): ");
- *((uchar_t*)dest)=state->status_byte;
- KEYBOARD_DEBUG_PRINT("0x%x\n",*((uchar_t*)dest));
+
+ *((uchar_t*)dest) = state->status_byte;
+
+ KEYBOARD_DEBUG_PRINT("0x%x\n", *((uchar_t*)dest));
+
return 1;
} else {
KEYBOARD_DEBUG_PRINT("keyboard: >1 byte read for status (64h)\n");
uint_t length,
struct vm_device * dev)
{
- struct keyboard_internal *state = (struct keyboard_internal *) dev->private_data;
+ struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
- if (length!=1) {
+ if (length != 1) {
KEYBOARD_DEBUG_PRINT("keyboard: write of 60h with >1 byte\n");
return -1;
}
- uchar_t data=*((uchar_t*)src);
+ uchar_t data = *((uchar_t*)src);
switch (state->state) {
case WRITING_CMD_BYTE:
- state->cmd_byte=data;
- state->state=NORMAL;
+ state->cmd_byte = data;
+ state->state = NORMAL;
break;
case TRANSMIT_PASSWD:
if (data) {
//ignore passwd
} else {
// end of password
- state->state=NORMAL;
+ state->state = NORMAL;
}
break;
case NORMAL:
- // command is being sent to keyboard controller
- switch (data) {
- case 0xff: // reset
- PushToOutputQueue(dev,0xfa,1); // ack
- state->state=RESET;
- break;
- case 0xf5: // disable scanning
- case 0xf4: // enable scanning
- // ack
- PushToOutputQueue(dev,0xfa,1);
- // should do something here... PAD
- state->state=NORMAL;
- break;
- case 0xfe: // resend
- case 0xfd: // set key type make
- case 0xfc: // set key typ make/break
- case 0xfb: // set key type typematic
- case 0xfa: // set all typematic make/break/typematic
- case 0xf9: // set all make
- case 0xf8: // set all make/break
- case 0xf7: // set all typemaktic
- case 0xf6: // set defaults
- case 0xf3: // set typematic delay/rate
- default:
- KEYBOARD_DEBUG_PRINT("keyboard: unhandled command 0x%x on output buffer (60h)\n",data);
+ {
+ // command is being sent to keyboard controller
+ switch (data) {
+ case 0xff: // reset
+ PushToOutputQueue(dev, 0xfa, 1); // ack
+ state->state = RESET;
+ break;
+ case 0xf5: // disable scanning
+ case 0xf4: // enable scanning
+ // ack
+ PushToOutputQueue(dev, 0xfa, 1);
+ // should do something here... PAD
+ state->state = NORMAL;
+ break;
+ case 0xfe: // resend
+ case 0xfd: // set key type make
+ case 0xfc: // set key typ make/break
+ case 0xfb: // set key type typematic
+ case 0xfa: // set all typematic make/break/typematic
+ case 0xf9: // set all make
+ case 0xf8: // set all make/break
+ case 0xf7: // set all typemaktic
+ case 0xf6: // set defaults
+ case 0xf3: // set typematic delay/rate
+ default:
+ KEYBOARD_DEBUG_PRINT("keyboard: unhandled command 0x%x on output buffer (60h)\n", data);
+ break;
+ }
break;
}
- break;
default:
- KEYBOARD_DEBUG_PRINT("keyboard: unknown state %x on command 0x%x on output buffer (60h)\n",state->state, data);
+ KEYBOARD_DEBUG_PRINT("keyboard: unknown state %x on command 0x%x on output buffer (60h)\n", state->state, data);
}
return 1;
uint_t length,
struct vm_device * dev)
{
- struct keyboard_internal *state = (struct keyboard_internal *) dev->private_data;
+ struct keyboard_internal *state = (struct keyboard_internal *)(dev->private_data);
- if (length==1) {
+ if (length == 1) {
uchar_t data;
+
KEYBOARD_DEBUG_PRINT("keyboard: read from input (60h): ");
- PullFromOutputQueue(dev,&data);
- if (state->state==RESET) {
+
+ PullFromOutputQueue(dev, &data);
+
+ if (state->state == RESET) {
// We just delivered the ack for the reset
// now we will ready ourselves to deliver the BAT code (success)
- PushToOutputQueue(dev,0xaa,1);
- state->state=NORMAL;
+ PushToOutputQueue(dev, 0xaa, 1);
+ state->state = NORMAL;
}
- KEYBOARD_DEBUG_PRINT("0x%x\n",data);
- *((uchar_t*)dest)=data;
+ KEYBOARD_DEBUG_PRINT("0x%x\n", data);
+
+ *((uchar_t*)dest) = data;
+
return 1;
} else {
KEYBOARD_DEBUG_PRINT("keyboard: unknown size read from input (60h)\n");
}
-int keyboard_interrupt(uint_t irq,
- struct vm_device * dev)
+int keyboard_interrupt(uint_t irq, struct vm_device * dev)
{
KEYBOARD_DEBUG_PRINT("keyboard: interrupt\n");
- dev->vm->vm_ops.raise_irq(dev->vm,irq);
+ dev->vm->vm_ops.raise_irq(dev->vm, irq);
return 0;
struct vm_device *create_keyboard() {
- if (thekeyboard!=NULL) {
+ if (thekeyboard != NULL) {
KEYBOARD_DEBUG_PRINT("keyboard: creating >1 keyboard device. This will probably fail!\n");
}
struct vm_device *device = create_device("KEYBOARD", &dev_ops, keyboard_state);
- thekeyboard=device;
+ thekeyboard = device;
return device;
}
/*
* Keyboard driver
* Copyright (c) 2001,2004 David H. Hovemeyer <daveho@cs.umd.edu>
- * $Revision: 1.5 $
+ * $Revision: 1.6 $
*
* This is free software. You are permitted to use,
* redistribute, and modify it as specified in the file "COPYING".
#include <geekos/keyboard.h>
-static enum {TARGET_GEEKOS,TARGET_VMM} target=TARGET_VMM;
+
+
+
+static enum {TARGET_GEEKOS,TARGET_VMM} target = TARGET_VMM;
+
extern void deliver_key_to_vmm(uchar_t status, uchar_t scancode);
//Print("Keyboard\n");
+
status = In_Byte(KB_CMD);
raw_status=status;
; Low level interrupt/thread handling code for GeekOS.
; Copyright (c) 2001,2003,2004 David H. Hovemeyer <daveho@cs.umd.edu>
; Copyright (c) 2003, Jeffrey K. Hollingsworth <hollings@cs.umd.edu>
-; $Revision: 1.6 $
+; $Revision: 1.7 $
; This is free software. You are permitted to use,
; redistribute, and modify it as specified in the file "COPYING".
; Function to activate a new user context (if needed).
IMPORT Switch_To_User_Context
+; Debug functions
IMPORT SerialPrintHex
IMPORT SerialPutChar
mov esi, [esp+REG_SKIP] ; get interrupt number
mov ebx, [eax+esi*4] ; get address of handler function
+ push esi
+ call SerialPrintHex
+ pop esi
+
+ push eax
+ mov eax, 0xa
+ push eax
+ call SerialPutChar
+ pop eax
+ pop eax
+
; Call the handler.
; The argument passed is a pointer to an Interrupt_State struct,
; which describes the stack layout for all interrupts.
; Restore registers
Restore_Registers
+
+ pusha
+
+ mov eax, 0xaa
+ push eax
+ call SerialPrintHex
+ pop eax
+
+ mov eax, 0xa
+ push eax
+ call SerialPutChar
+ pop eax
+
+ popa
+
; Return from the interrupt.
iret
* GeekOS timer interrupt support
* Copyright (c) 2001,2003 David H. Hovemeyer <daveho@cs.umd.edu>
* Copyright (c) 2003, Jeffrey K. Hollingsworth <hollings@cs.umd.edu>
- * $Revision: 1.5 $
+ * $Revision: 1.6 $
*
* This is free software. You are permitted to use,
* redistribute, and modify it as specified in the file "COPYING".
Begin_IRQ(state);
- SerialPrintLevel(1,"Host Timer Interrupt Handler Running\n");
+ SerialPrint("Host Timer Interrupt Handler running\n");
/* Update global and per-thread number of ticks */
++g_numTicks;
//generic_port_range_type range = {0,1024} ; // hook first 1024 ports if not already hooked
- //struct vm_device * generic = create_generic(&range,1,NULL,0,NULL,0);
+ //struct vm_device * generic = create_generic(&range, 1, NULL, 0, NULL, 0);
attach_device(&(vm_info), nvram);
//hook_irq(&vm_info, 1);
// give floppy controller to vm
- hook_irq(&vm_info, 6);
+ //hook_irq(&vm_info, 6);
// primary ide
- hook_irq(&vm_info, 14);
+ //hook_irq(&vm_info, 14);
// secondary ide
- hook_irq(&vm_info, 15);
+ //hook_irq(&vm_info, 15);
vm_info.rip = 0xfff0;
SerialPrint("Hooking IRQ: %d (vm=0x%x)\n", irq, info);
irq_map[irq] = info;
volatile void *foo = pic_intr_handler;
- foo=0;
+
+ /* This is disabled for the time being */
+ foo = 0;
+
+
Disable_IRQ(irq);
Install_IRQ(irq, pic_intr_handler);
Enable_IRQ(irq);
CLGI();
+ PrintDebug("SVM Entry...\n");
+
rdtscll(info->time_state.cached_host_tsc);
guest_ctrl->TSC_OFFSET = info->time_state.guest_tsc - info->time_state.cached_host_tsc;
safe_svm_launch((vmcb_t*)(info->vmm_data), &(info->vm_regs));
rdtscll(tmp_tsc);
+ PrintDebug("SVM Returned\n");
- //PrintDebug("SVM Returned\n");
v3_update_time(info, tmp_tsc - info->time_state.cached_host_tsc);
// Disable printing io exits due to bochs debug messages
- if (!((exit_code == VMEXIT_IOIO) && ((ushort_t)(guest_ctrl->exit_info1 >> 16) == 0x402))) {
+ //if (!((exit_code == VMEXIT_IOIO) && ((ushort_t)(guest_ctrl->exit_info1 >> 16) == 0x402))) {
- PrintDebug("SVM Returned: Exit Code: %x \t\t(tsc=%ul)\n",exit_code, (uint_t)info->time_state.guest_tsc);
- }
+ PrintDebug("SVM Returned: Exit Code: %x \t\t(tsc=%ul)\n",exit_code, (uint_t)info->time_state.guest_tsc);
+ // }
// PrintDebugVMCB((vmcb_t*)(info->vmm_data));
guest_ctrl->guest_ctrl.V_IGN_TPR = 1;
guest_ctrl->guest_ctrl.V_INTR_PRIO = 0xf;
+ PrintDebug("Injecting Interrupt %d (EIP=%x)\n", guest_ctrl->guest_ctrl.V_INTR_VECTOR, info->rip);
+
injecting_intr(info, irq, EXTERNAL_IRQ);
break;
guest_ctrl->EVENTINJ.vector = excp;
+ PrintDebug("Injecting Interrupt %d (EIP=%x)\n", guest_ctrl->EVENTINJ.vector, info->rip);
injecting_intr(info, excp, EXCEPTION);
break;
}
return -1;
}
- PrintDebug("Injecting Interrupt %d (EIP=%x)\n", guest_ctrl->EVENTINJ.vector, info->rip);
}
return -1;
}
- //PrintDebug("IN on port %d (0x%x)\n", io_info->port, io_info->port);
+ PrintDebug("IN on port %d (0x%x)\n", io_info->port, io_info->port);
if (io_info->sz8) {
read_size = 1;
return -1;
}
- //PrintDebug("INS on port %d (0x%x)\n", io_info->port, io_info->port);
+ PrintDebug("INS on port %d (0x%x)\n", io_info->port, io_info->port);
- if (io_info->sz8) {
+ if (io_info->sz8) {
read_size = 1;
} else if (io_info->sz16) {
read_size = 2;
} else if (io_info->sz32) {
read_size = 4;
+ } else {
+ PrintDebug("io_info Invalid Size\n");
+ return -1;
}
-
+
if (io_info->addr16) {
mask = 0xffff;
} else if (io_info->addr32) {
} else if (io_info->addr64) {
mask = 0xffffffffffffffffLL;
} else {
- // should never happen
- return -1;
+ // This value should be set depending on the host register size...
+ mask = get_gpr_mask(info);
}
if (io_info->rep) {
- rep_num = info->vm_regs.rcx & mask;
+ // rep_num = info->vm_regs.rcx & mask;
+ rep_num = info->vm_regs.rcx;
}
+ PrintDebug("INS size=%d for %d steps\n", read_size, rep_num);
while (rep_num > 0) {
addr_t host_addr;
if (guest_va_to_host_va(info, dst_addr, &host_addr) == -1) {
// either page fault or gpf...
+ PrintDebug("Could not convert Guest VA to host VA\n");
+ return -1;
}
if (hook->read(io_info->port, (char*)host_addr, read_size, hook->priv_data) != read_size) {
return -1;
}
- //PrintDebug("OUT on port %d (0x%x)\n", io_info->port, io_info->port);
+ PrintDebug("OUT on port %d (0x%x)\n", io_info->port, io_info->port);
if (io_info->sz8) {
write_size = 1;
return -1;
}
- //PrintDebug("OUTS on port %d (0x%x)\n", io_info->port, io_info->port);
+ PrintDebug("OUTS on port %d (0x%x)\n", io_info->port, io_info->port);
if (io_info->sz8) {
write_size = 1;
mask = 0xffffffffffffffffLL;
} else {
// should never happen
+ PrintDebug("Invalid Address length\n");
return -1;
}
if (guest_pa_to_host_va(info, first_operand + (info->segments.ds.base << 4), &host_addr) == -1) {
// gpf the guest
+ PrintDebug("Could not convert guest physical address to host virtual address\n");
return -1;
}
first_operand = host_addr;
} else {
- // error... don't know what to do
- return -1;
+ // Register operand
+ // Should be ok??
}
cr0_val = *(char*)cr0 & 0x0f;
