void mouse_init(void) /*Note that we are doing NO device initialization.
We are assuming that this was done suitably when the system
was booted and the standard mouse driver was installed. THis is very poor
programming practice! CW */
{
/* _go32_dpmi_lock_data(mousequeue,200); I'm not using these in this simple
demo so they are commented out. CW
_go32_dpmi_lock_data(&mousequeue,sizeof(mousequeue));*/
_go32_dpmi_lock_code(NewInt74,(unsigned long)(LOCKint74-NewInt74));
// This ensures that the handler is not placed into paged memory.
_go32_dpmi_get_protected_mode_interrupt_vector(0x74,&old_handler);
/* Reads the selector and offset of the old handler into a structure, so
that it can be restored later. */
/*Obtains the far pointer for the mouse ISR */
new_mousehandler.pm_selector=_go32_my_cs(); /* Note that _go32_my_cs()
returns the selector for the program's code.*/
new_mousehandler.pm_offset=(unsigned long)NewInt74;
_go32_dpmi_allocate_iret_wrapper(&new_mousehandler);
/* The wrapper saves the machine state using a series of PUSH instructions. */
_go32_dpmi_set_protected_mode_interrupt_vector(0x74,&new_mousehandler);
/* Places the ISR far pointer into a protected mode interrupt table. */
}
void ShutdownPort ( void )
{
if(!port_initted)
return;
usermsg("shutting down serial port");
OUTPUT(uart + INTERRUPT_ENABLE_REGISTER, 0);
OUTPUT(uart + MODEM_CONTROL_REGISTER, 0);
OUTPUT(0x20 + 1, INPUT(0x20 + 1) | (1<<irq));
// restore old irq
asm("cli");
_go32_dpmi_set_protected_mode_interrupt_vector
(irqintnum, &oldirqvect);
_go32_dpmi_free_iret_wrapper(&newirqvect);
asm("sti");
//
// init com port settings to defaults
//
regs.x.ax = 0xf3; //f3= 9600 n 8 1
regs.x.dx = comport - 1;
int86 (0x14, ®s, ®s);
port_initted = false;
}
static void ComPort_Disable(ComPort *p)
{
if (!p->enabled)
{
Con_Printf("Already disabled\n");
return;
}
// disable interrupts at the uart
outportb (p->uart + INTERRUPT_ENABLE_REGISTER, 0);
// disable our interrupt at the PIC
outportb (0x21, inportb (0x21) | (1<<p->irq));
// disable interrupts at the processor
disable();
// restore the old interrupt handler
_go32_dpmi_set_protected_mode_interrupt_vector(p->irq + 8, &p->protectedModeSaveInfo);
_go32_dpmi_free_iret_wrapper(&p->protectedModeInfo);
// enable interrupts at the processor
enable();
p->enabled = false;
}
/* Remove the timer handler */
void timer_restore(void)
{
/* Restore previous timer setting */
timer_adjust(0);
/* Remove the interrupt handler */
_go32_dpmi_set_protected_mode_interrupt_vector(TIMER_INT, &old_handler);
}
void key_init(void)
{
lo=hi=0;
new_key_handler.pm_offset = (int) key_handler;
new_key_handler.pm_selector = _go32_my_cs();
_go32_dpmi_get_protected_mode_interrupt_vector(0x9, &old_key_handler);
_go32_dpmi_allocate_iret_wrapper(&new_key_handler);
_go32_dpmi_set_protected_mode_interrupt_vector(0x9, &new_key_handler);
}
void keyboard_int_remove() {
// revert to old keyboard ISR
_go32_dpmi_set_protected_mode_interrupt_vector(9, &OldHandler);
// free the iret wrapper
_go32_dpmi_free_iret_wrapper(&NewHandler);
printf("old keyboard ISR installed\n");
}
/* Restore the standard keyboard interrupt. */
void kbd_uninstall(void)
{
int r;
r = _go32_dpmi_set_protected_mode_interrupt_vector(9, &std_kbd_handler_seginfo);
if (r) {
log_error(LOG_DEFAULT, "Couldn't restore the standard kbd interrupt vector!");
}
}
void reinstall_c_irq_handler(int irq, _go32_dpmi_seginfo *old_irq) {
_go32_dpmi_seginfo new_irq;
_go32_dpmi_get_protected_mode_interrupt_vector(IRQ_VECTOR(irq), &new_irq);
// importante: reposição do handler original
_go32_dpmi_set_protected_mode_interrupt_vector(IRQ_VECTOR(irq), old_irq);
// liberta funcao assembly
_go32_dpmi_free_iret_wrapper(&new_irq);
}
/**
* key_init
* This function initiates the interrupt for the keyboard. This was given
* as part of the VBETEST.C example.
**/
void key_init(void){
//Finds location of old handler
_go32_dpmi_lock_code(NewInt9, (unsigned long)(LOCKint9 - NewInt9));
_go32_dpmi_get_protected_mode_interrupt_vector(9, &old_handler);
//Set new handler
new_handler.pm_offset = (unsigned long)NewInt9;
new_handler.pm_selector = _go32_my_cs();
//Set in protected mode
_go32_dpmi_allocate_iret_wrapper(&new_handler);
_go32_dpmi_set_protected_mode_interrupt_vector(9, &new_handler);
}
int set_isr(int irq, void (*isr)(void),
_go32_dpmi_seginfo *prev_isr)
{
int vector = irq_vector(irq);
if(_go32_dpmi_get_protected_mode_interrupt_vector(vector, prev_isr)) return -1;
_go32_dpmi_seginfo new_isr;
new_isr.pm_selector = _go32_my_cs( );
new_isr.pm_offset=(unsigned long) isr;
if(_go32_dpmi_set_protected_mode_interrupt_vector(vector, &new_isr)) return -1;
return 0;
}
void timer_deinit(void)
{
/* Reset timer frequency to 18.2Hz */
timer_setrate(0);
/* Reset handler to old one */
_go32_dpmi_set_protected_mode_interrupt_vector(TIMER_INT, &oldhandler);
/* Free the IRET wrapper */
_go32_dpmi_free_iret_wrapper(&myhandler);
}
void key_delete(void)
{
if (keyboard_handler_replaced) {
int kflags;
_go32_dpmi_set_protected_mode_interrupt_vector(0x9, &old_key_handler);
/*set the original keyboard LED settings*/
kflags=_farpeekb(_dos_ds,0x417);
outportb(0x60,0xed);
asm("nop; nop");
outportb(0x60,((kflags>>4)&0x7));
}
}
/* Try to restore interrupt handler */
static int restore(int vector, _go32_dpmi_seginfo *seginfo, _go32_dpmi_seginfo *orig_seginfo) {
_go32_dpmi_seginfo cur_seginfo;
_go32_dpmi_get_protected_mode_interrupt_vector(vector, &cur_seginfo);
if (cur_seginfo.pm_selector != seginfo->pm_selector ||
cur_seginfo.pm_offset != seginfo->pm_offset)
return 1;
_go32_dpmi_set_protected_mode_interrupt_vector(vector, orig_seginfo);
return 0;
}
int install_asm_irq_handler(int irq, void (*irq_func)(void), _go32_dpmi_seginfo *old_irq) {
// endereço do handler original
_go32_dpmi_get_protected_mode_interrupt_vector(IRQ_VECTOR(irq), old_irq);
// instalação do handler na IDT
_go32_dpmi_seginfo new_irq;
new_irq.pm_selector = _go32_my_cs( ); // selector do código
new_irq.pm_offset = (unsigned long) irq_func; // endereço do novo handler
_go32_dpmi_set_protected_mode_interrupt_vector(IRQ_VECTOR(irq), &new_irq);
return 0;
}
static void uninstall_isr(struct port *p)
{
/* Disable interrupts. */
outportb(p->baseaddr + MCR, 0);
outportb(p->baseaddr + IER, 0);
outportb(p->pic_imr, inportb(p->pic_imr) | (~p->interrupt_enable_mask));
/* Restore old vector. */
disable();
_go32_dpmi_set_protected_mode_interrupt_vector(p->vector_num, &p->old_vector);
_go32_dpmi_free_iret_wrapper(&p->new_vector);
enable();
}
void key_init(void)
{
int i;
for (i=0;i<256;i++) keypush[i]=0; /*none key is pressed*/
extended_key_follows=FALSE;
update_leds();
raw_key_r=0;raw_key=0;
new_key_handler.pm_offset = (int) key_handler;
new_key_handler.pm_selector = _go32_my_cs();
_go32_dpmi_get_protected_mode_interrupt_vector(0x9, &old_key_handler);
_go32_dpmi_allocate_iret_wrapper(&new_key_handler);
_go32_dpmi_set_protected_mode_interrupt_vector(0x9, &new_key_handler);
keyboard_handler_replaced = TRUE;
}
void display_dos_end()
{
__dpmi_regs r;
/* Restore video mode */
r.x.ax = 0x1202;
r.h.bl = 0x30;
__dpmi_int(0x10, &r);
r.x.ax = 0x0003;
__dpmi_int(0x10, &r);
/* Restore cursor */
_setcursortype(_NORMALCURSOR);
/* Restore keyboard handler */
_go32_dpmi_set_protected_mode_interrupt_vector(KBD_INT, &old_kb_handler);
}
int install_c_irq_handler(int irq, void (*irq_func)(void), _go32_dpmi_seginfo *old_irq) {
// endereço do handler original
_go32_dpmi_get_protected_mode_interrupt_vector(IRQ_VECTOR(irq), old_irq);
// instalação do handler na IDT
_go32_dpmi_seginfo new_irq;
new_irq.pm_selector = _go32_my_cs( ); // selector do código
new_irq.pm_offset = (unsigned long) irq_func; // endereço do novo handler
// prepara funcao assembly para chamar funcao C
_go32_dpmi_allocate_iret_wrapper(&new_irq);
_go32_dpmi_set_protected_mode_interrupt_vector(IRQ_VECTOR(irq), &new_irq);
return 0;
}
int timer_init(TimerHandler handler)
{
/* Save old handler */
_go32_dpmi_get_protected_mode_interrupt_vector(TIMER_INT, &oldhandler);
/* Setup our handler */
real_handler = handler;
myhandler.pm_selector = _go32_my_cs();
myhandler.pm_offset = (unsigned long)timer_handler;
/* Allocate an IRET wrapper */
if(_go32_dpmi_allocate_iret_wrapper(&myhandler))
return 0;
/* Set our handler to be the new interrupt handler */
return _go32_dpmi_set_protected_mode_interrupt_vector(TIMER_INT, &myhandler);
}
int set_isr_c_wrapper(int irq, void (*isr)(void), _go32_dpmi_seginfo *prev_isr) {
int vector = irq_vector(irq);
if(_go32_dpmi_get_protected_mode_interrupt_vector(vector, prev_isr))
return -1;
_go32_dpmi_seginfo new_isr;
new_isr.pm_selector = _go32_my_cs();
new_isr.pm_offset=(unsigned long) isr;
/* prepara função assembly para chamar função C */
_go32_dpmi_allocate_iret_wrapper(&new_isr);
if(_go32_dpmi_set_protected_mode_interrupt_vector(vector, &new_isr))
return -1;
return 0;
}
static void install_isr(int portnum, struct port *p, int irq)
{
int x, baseaddr = p->baseaddr;
p->irq = irq;
/* Clear pending interrupts. */
do {
inportb(baseaddr + RBR);
inportb(baseaddr + LSR);
inportb(baseaddr + MSR);
x = inportb(baseaddr + IIR);
} while (!(x & 0x01));
/* Calculate vector from IRQ. */
if (p->irq <= 7) {
p->interrupt_enable_mask = ~(1 << p->irq); /* IMR is inverted */
p->vector_num = 8 + p->irq;
p->pic_imr = 0x21;
}
else {
p->interrupt_enable_mask = ~(1 << (p->irq - 8));
p->vector_num = 0x70 + (p->irq - 8);
p->pic_imr = 0xa1;
}
/* Install ISR into vector. */
p->new_vector.pm_selector = _go32_my_cs();
p->new_vector.pm_offset = (int)isr_wrapper_table[portnum];
_go32_dpmi_allocate_iret_wrapper(&p->new_vector);
disable();
_go32_dpmi_get_protected_mode_interrupt_vector(p->vector_num, &p->old_vector);
_go32_dpmi_set_protected_mode_interrupt_vector(p->vector_num, &p->new_vector);
/* Enable interrupts. */
outportb(baseaddr + MCR, 0x0f);
outportb(baseaddr + IER, 0x0f);
outportb(p->pic_imr, inportb(p->pic_imr) & p->interrupt_enable_mask);
enable();
}
void keyboard_int_install() {
// retrieve the current (old) keyboard handler
_go32_dpmi_get_protected_mode_interrupt_vector(9, &OldHandler);
// lock code and data from being paged
_go32_dpmi_lock_code(myKeyInt, (long)myKeyInt_Size);
_go32_dpmi_lock_data(&keyVal, (long)sizeof(keyVal));
// establish new seginfo struct
NewHandler.pm_offset = (long)myKeyInt;
NewHandler.pm_selector = _go32_my_cs();
// allocate the IRET wrapper
_go32_dpmi_allocate_iret_wrapper(&NewHandler);
// install the new keyboard ISR
_go32_dpmi_set_protected_mode_interrupt_vector(9, &NewHandler);
printf("new keyboard ISR installed\n");
}
PVI MIrq_SetHandler(UBYTE irqno, PVI handler)
{
#ifdef __DJGPP__
_go32_dpmi_seginfo seginfo;
#endif
PVI oldvect;
int vecno = (irqno > 7) ? irqno + 0x68 : irqno + 0x8;
#ifdef __DJGPP__
_go32_dpmi_get_protected_mode_interrupt_vector(vecno, &seginfo);
oldvect = seginfo.pm_offset;
seginfo.pm_offset = handler;
seginfo.pm_selector = _go32_my_cs();
_go32_dpmi_allocate_iret_wrapper(&seginfo);
_go32_dpmi_set_protected_mode_interrupt_vector(vecno, &seginfo);
#else
oldvect = _dos_getvect(vecno);
_dos_setvect(vecno, handler);
#endif
return oldvect;
}
/* Install our custom keyboard interrupt. */
void kbd_install(void)
{
int r;
static _go32_dpmi_seginfo my_kbd_handler_seginfo;
my_kbd_handler_seginfo.pm_offset = (int)my_kbd_interrupt_handler;
my_kbd_handler_seginfo.pm_selector = _go32_my_cs();
r = _go32_dpmi_allocate_iret_wrapper(&my_kbd_handler_seginfo);
if (r) {
log_error(LOG_DEFAULT, "Cannot allocate IRET wrapper for the keyboard interrupt.");
exit(-1);
}
r = _go32_dpmi_set_protected_mode_interrupt_vector(9, &my_kbd_handler_seginfo);
if (r) {
log_error(LOG_DEFAULT, "Cannot install the keyboard interrupt handler.");
exit(-1);
}
/* Initialize the keyboard matrix. */
keyboard_clear_keymatrix();
/* Reset modifier status. */
memset(&modifiers, 0, sizeof(modifiers));
}
void reinstall_asm_irq_handler(int irq, _go32_dpmi_seginfo *old_irq) {
// importante: reposição do handler original
_go32_dpmi_set_protected_mode_interrupt_vector(IRQ_VECTOR(irq), old_irq);
}
/**
* key_delete
* This function returns keyboard control to the operating system. This was
* given as part of the VBETEST.C example.
**/
void key_delete(void){
_go32_dpmi_set_protected_mode_interrupt_vector(9, &old_handler);
_go32_dpmi_free_iret_wrapper(&new_handler);
}
void key_done(void)
{
_go32_dpmi_set_protected_mode_interrupt_vector(0x9, &old_key_handler);
}
void restore_isr_c_wrapper(int irq, _go32_dpmi_seginfo *isr) {
int vector = irq_vector(irq);
_go32_dpmi_set_protected_mode_interrupt_vector(vector, isr);
}
static void ComPort_Enable(ComPort *p)
{
void (*isr)(void);
int n;
byte b;
if (p->enabled)
{
Con_Printf("Already enabled\n");
return;
}
// disable all UART interrupts
outportb (p->uart + INTERRUPT_ENABLE_REGISTER, 0);
// clear out any buffered uncoming data
while((inportb (p->uart + LINE_STATUS_REGISTER)) & LSR_DATA_READY)
inportb (p->uart + RECEIVE_BUFFER_REGISTER);
// get the current line and modem status
p->modemStatus = (inportb (p->uart + MODEM_STATUS_REGISTER) & MODEM_STATUS_MASK) | p->modemStatusIgnore;
p->lineStatus = inportb (p->uart + LINE_STATUS_REGISTER);
// clear any UART interrupts
do
{
n = inportb (p->uart + INTERRUPT_ID_REGISTER) & 7;
if (n == IIR_RX_DATA_READY_INTERRUPT)
inportb (p->uart + RECEIVE_BUFFER_REGISTER);
} while (!(n & 1));
if (p->uartType == UART_AUTO)
{
outportb (p->uart + FIFO_CONTROL_REGISTER, FCR_FIFO_ENABLE);
b = inportb (p->uart + INTERRUPT_ID_REGISTER);
if ((b & IIR_FIFO_ENABLED) == IIR_FIFO_ENABLED)
p->uartType = UART_16550;
else
p->uartType = UART_8250;
}
// save the old interrupt handler
_go32_dpmi_get_protected_mode_interrupt_vector(p->irq + 8, &p->protectedModeSaveInfo);
if (p->uartType == UART_8250)
{
outportb (p->uart + FIFO_CONTROL_REGISTER, 0);
if (p == handleToPort[0])
isr = COM1_ISR_8250;
else
isr = COM2_ISR_8250;
}
else
{
outportb (p->uart + FIFO_CONTROL_REGISTER, FCR_FIFO_ENABLE | FCR_RCVR_FIFO_RESET | FCR_XMIT_FIFO_RESET | FCR_TRIGGER_08);
if (p == handleToPort[0])
isr = COM1_ISR_16550;
else
isr = COM2_ISR_16550;
}
p->protectedModeInfo.pm_offset = (int)isr;
n = _go32_dpmi_allocate_iret_wrapper(&p->protectedModeInfo);
if (n)
{
Con_Printf("serial: protected mode callback allocation failed\n");
return;
}
// disable interrupts at the processor
disable();
// install our interrupt handlers now
_go32_dpmi_set_protected_mode_interrupt_vector(p->irq + 8, &p->protectedModeInfo);
// enable our interrupt at the PIC
outportb (0x21, inportb (0x21) & ~(1<<p->irq));
// enable interrupts at the processor
enable();
// enable interrupts at the PIC
outportb (0x20, 0xc2);
// set baud rate & line control
outportb (p->uart + LINE_CONTROL_REGISTER, LCR_DLAB | p->lineControl);
outportb (p->uart, p->baudBits);
outportb (p->uart + 1, 0);
outportb (p->uart + LINE_CONTROL_REGISTER, p->lineControl);
// set modem control register & enable uart interrupt generation
outportb(p->uart + MODEM_CONTROL_REGISTER, MCR_OUT2 | MCR_RTS | MCR_DTR);
// enable the individual interrupts at the uart
outportb (p->uart + INTERRUPT_ENABLE_REGISTER, IER_RX_DATA_READY | IER_TX_HOLDING_REGISTER_EMPTY | IER_LINE_STATUS | IER_MODEM_STATUS);
p->enabled = true;
}
/**
* mouse_delete
* This function returns us to the old handler's address we saved before.
**/
void mouse_delete(void)
{
_go32_dpmi_set_protected_mode_interrupt_vector(0x74,&old_handler);
_go32_dpmi_free_iret_wrapper(&new_mousehandler);
}
