v86_lrmi.c

   1 #include <string.h>
   2 #include <lrmi.h>
   3 #include "v86.h"
   4
   5 /* Memory access functions */
   6 u8 v_rdb(u32 addr) {
   7         return *(u8*)(addr);
   8 }
   9
  10 u16 v_rdw(u32 addr) {
  11         return *(u16*)(addr);
  12 }
  13
  14 u32 v_rdl(u32 addr) {
  15         return *(u32*)(addr);
  16 }
  17
  18 void v_wrb(u32 addr, u8 val) {
  19         *(u8*)(addr) = val;
  20 }
  21
  22 void v_wrw(u32 addr, u16 val) {
  23         *(u16*)(addr) = val;
  24 }
  25
  26 void v_wrl(u32 addr, u32 val) {
  27         *(u32*)(addr) = val;
  28 }
  29
  30 void *vptr(u32 addr) {
  31         return (u8*)addr;
  32 }
  33
  34 void rconv_v86_to_LRMI(struct v86_regs *rs, struct LRMI_regs *rd)
  35 {
  36         memset(rd, 0, sizeof(*rd));
  37
  38         rd->eax = rs->eax;
  39         rd->ebx = rs->ebx;
  40         rd->ecx = rs->ecx;
  41         rd->edx = rs->edx;
  42         rd->edi = rs->edi;
  43         rd->esi = rs->esi;
  44         rd->ebp = rs->ebp;
  45         rd->sp  = rs->esp;
  46         rd->flags = rs->eflags;
  47         rd->ip  = rs->eip;
  48         rd->cs  = rs->cs;
  49         rd->ds  = rs->ds;
  50         rd->es  = rs->es;
  51         rd->fs  = rs->fs;
  52         rd->gs  = rs->gs;
  53 }
  54
  55 void rconv_LRMI_to_v86(struct LRMI_regs *rs, struct v86_regs *rd)
  56 {
  57         rd->eax = rs->eax;
  58         rd->ebx = rs->ebx;
  59         rd->ecx = rs->ecx;
  60         rd->edx = rs->edx;
  61         rd->edi = rs->edi;
  62         rd->esi = rs->esi;
  63         rd->ebp = rs->ebp;
  64         rd->esp = rs->sp;
  65         rd->eflags = rs->flags;
  66         rd->eip = rs->ip;
  67         rd->cs  = rs->cs;
  68         rd->ds  = rs->ds;
  69         rd->es  = rs->es;
  70         rd->fs  = rs->fs;
  71         rd->gs  = rs->gs;
  72 }
  73
  74 int v86_init() {
  75         int err = LRMI_init();
  76
  77         ioperm(0, 1024, 1);
  78         iopl(3);
  79
  80         return (err == 1) ? 0 : 1;
  81 }
  82
  83 void v86_cleanup()
  84 {
  85         /* dummy function */
  86 }
  87
  88 /*
  89  * Perform a simulated interrupt call.
  90  */
  91 int v86_int(int num, struct v86_regs *regs)
  92 {
  93         struct LRMI_regs r;
  94         int err;
  95
  96         rconv_v86_to_LRMI(regs, &r);
  97         err = LRMI_int(num, &r);
  98         rconv_LRMI_to_v86(&r, regs);
  99
 100         return (err == 1) ? 0 : 1;
 101 }
 102
 103 inline void v86_mem_free(u32 m) {
 104         LRMI_free_real((void*)m);
 105 }
 106
 107 inline u32 v86_mem_alloc(int size) {
 108         return (u32)LRMI_alloc_real(size);
 109 }