git.oblomov.eu Git - wine/blob - msdos/ioports.c

   1 /*
   2  * Emulation of processor ioports.
   3  *
   4  * Copyright 1995 Morten Welinder
   5  * Copyright 1998 Andreas Mohr, Ove Kaaven
   6  */
   7
   8 /* Known problems:
   9    - only a few ports are emulated.
  10    - real-time clock in "cmos" is bogus.  A nifty alarm() setup could
  11      fix that, I guess.
  12 */
  13
  14 #include <ctype.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <time.h>
  18 #include <unistd.h>
  19 #include "windef.h"
  20 #include "vga.h"
  21 #include "dosexe.h"
  22 #include "options.h"
  23 #include "miscemu.h"
  24 #include "debug.h"
  25 #include "miscemu.h"
  26
  27 DEFAULT_DEBUG_CHANNEL(int)
  28
  29 static WORD tmr_8253_countmax[3] = {0xffff, 0x12, 1}; /* [2] needs to be 1 ! */
  30 /* if byte_toggle is TRUE, then hi byte has already been written */
  31 static BOOL16 tmr_8253_byte_toggle[3] = {FALSE, FALSE, FALSE};
  32 static WORD tmr_8253_latch[3] = {0, 0, 0};
  33
  34 /* 4th contents are dummy */
  35 static BOOL16 tmr_8253_latched[4] = {FALSE, FALSE, FALSE, FALSE};
  36 static BYTE tmr_8253_ctrlbyte_ch[4] = {0x06, 0x44, 0x86, 0};
  37
  38 static int dummy_ctr = 0;
  39
  40 static BYTE parport_8255[4] = {0x4f, 0x20, 0xff, 0xff};
  41
  42 static BYTE cmosaddress;
  43
  44 static BYTE cmosimage[64] =
  45 {
  46   0x27, 0x34, 0x31, 0x47, 0x16, 0x15, 0x00, 0x01,
  47   0x04, 0x94, 0x26, 0x02, 0x50, 0x80, 0x00, 0x00,
  48   0x40, 0xb1, 0x00, 0x9c, 0x01, 0x80, 0x02, 0x00,
  49   0x1c, 0x00, 0x00, 0xad, 0x02, 0x10, 0x00, 0x00,
  50   0x08, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x00,
  51   0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x03, 0x19,
  52   0x00, 0x1c, 0x19, 0x81, 0x00, 0x0e, 0x00, 0x80,
  53   0x1b, 0x7b, 0x21, 0x00, 0x00, 0x00, 0x05, 0x5f
  54 };
  55
  56 #if defined(linux) && defined(__i386__)
  57 # define DIRECT_IO_ACCESS
  58 #else
  59 # undef DIRECT_IO_ACCESS
  60 #endif  /* linux && __i386__ */
  61
  62 #ifdef DIRECT_IO_ACCESS
  63
  64 extern int iopl(int level);
  65
  66 static char do_direct_port_access = 0;
  67 static char port_permissions[0x10000];
  68
  69 #define IO_READ  1
  70 #define IO_WRITE 2
  71
  72 #endif  /* DIRECT_IO_ACCESS */
  73
  74 static void IO_FixCMOSCheckSum(void)
  75 {
  76         WORD sum = 0;
  77         int i;
  78
  79         for (i=0x10; i < 0x2d; i++)
  80                 sum += cmosimage[i];
  81         cmosimage[0x2e] = sum >> 8; /* yes, this IS hi byte !! */
  82         cmosimage[0x2f] = sum & 0xff;
  83         TRACE(int, "calculated hi %02x, lo %02x\n", cmosimage[0x2e], cmosimage[0x2f]);
  84 }
  85
  86 static void set_timer_maxval(unsigned timer, unsigned maxval)
  87 {
  88     switch (timer) {
  89         case 0: /* System timer counter divisor */
  90             DOSVM_SetTimer(maxval);
  91             break;
  92         case 1: /* RAM refresh */
  93             FIXME(int, "RAM refresh counter handling not implemented !");
  94             break;
  95         case 2: /* cassette & speaker */
  96             /* speaker on ? */
  97             if (((BYTE)parport_8255[1] & 3) == 3)
  98             {
  99                 TRACE(int, "Beep (freq: %d) !\n", 1193180 / maxval );
 100                 Beep(1193180 / maxval, 20);
 101             }
 102             break;
 103     }
 104 }
 105
 106 /**********************************************************************
 107  *          IO_port_init
 108  */
 109
 110 /* set_IO_permissions(int val1, int val)
 111  * Helper function for IO_port_init
 112  */
 113 #ifdef DIRECT_IO_ACCESS
 114 static void set_IO_permissions(int val1, int val, char rw)
 115 {
 116         int j;
 117         if (val1 != -1) {
 118                 if (val == -1) val = 0x3ff;
 119                 for (j = val1; j <= val; j++)
 120                         port_permissions[j] |= rw;
 121
 122                 do_direct_port_access = 1;
 123
 124                 val1 = -1;
 125         } else if (val != -1) {
 126                 do_direct_port_access = 1;
 127
 128                 port_permissions[val] |= rw;
 129         }
 130
 131 }
 132
 133 /* do_IO_port_init_read_or_write(char* temp, char rw)
 134  * Helper function for IO_port_init
 135  */
 136
 137 static void do_IO_port_init_read_or_write(char* temp, char rw)
 138 {
 139         int val, val1, i, len;
 140         if (!strcasecmp(temp, "all")) {
 141                 MSG("Warning!!! Granting FULL IO port access to"
 142                         " windoze programs!\nWarning!!! "
 143                         "*** THIS IS NOT AT ALL "
 144                         "RECOMMENDED!!! ***\n");
 145                 for (i=0; i < sizeof(port_permissions); i++)
 146                         port_permissions[i] |= rw;
 147
 148         } else if (!(!strcmp(temp, "*") || *temp == '\0')) {
 149                 len = strlen(temp);
 150                 val = -1;
 151                 val1 = -1;
 152                 for (i = 0; i < len; i++) {
 153                         switch (temp[i]) {
 154                         case '0':
 155                                 if (temp[i+1] == 'x' || temp[i+1] == 'X') {
 156                                         sscanf(temp+i, "%x", &val);
 157                                         i += 2;
 158                                 } else {
 159                                         sscanf(temp+i, "%d", &val);
 160                                 }
 161                                 while (isxdigit(temp[i]))
 162                                         i++;
 163                                 i--;
 164                                 break;
 165                         case ',':
 166                         case ' ':
 167                         case '\t':
 168                                 set_IO_permissions(val1, val, rw);
 169                                 val1 = -1; val = -1;
 170                                 break;
 171                         case '-':
 172                                 val1 = val;
 173                                 if (val1 == -1) val1 = 0;
 174                                 break;
 175                         default:
 176                                 if (temp[i] >= '0' && temp[i] <= '9') {
 177                                         sscanf(temp+i, "%d", &val);
 178                                         while (isdigit(temp[i]))
 179                                                 i++;
 180                                 }
 181                         }
 182                 }
 183                 set_IO_permissions(val1, val, rw);
 184         }
 185 }
 186
 187 static inline BYTE inb( WORD port )
 188 {
 189     BYTE b;
 190     __asm__ __volatile__( "inb %w1,%0" : "=a" (b) : "d" (port) );
 191     return b;
 192 }
 193
 194 static inline WORD inw( WORD port )
 195 {
 196     WORD w;
 197     __asm__ __volatile__( "inw %w1,%0" : "=a" (w) : "d" (port) );
 198     return w;
 199 }
 200
 201 static inline DWORD inl( WORD port )
 202 {
 203     DWORD dw;
 204     __asm__ __volatile__( "inl %w1,%0" : "=a" (dw) : "d" (port) );
 205     return dw;
 206 }
 207
 208 static inline void outb( BYTE value, WORD port )
 209 {
 210     __asm__ __volatile__( "outb %b0,%w1" : : "a" (value), "d" (port) );
 211 }
 212
 213 static inline void outw( WORD value, WORD port )
 214 {
 215     __asm__ __volatile__( "outw %w0,%w1" : : "a" (value), "d" (port) );
 216 }
 217
 218 static inline void outl( DWORD value, WORD port )
 219 {
 220     __asm__ __volatile__( "outl %0,%w1" : : "a" (value), "d" (port) );
 221 }
 222
 223 #endif  /* DIRECT_IO_ACCESS */
 224
 225 void IO_port_init()
 226 {
 227 #ifdef DIRECT_IO_ACCESS
 228         char temp[1024];
 229
 230         /* Can we do that? */
 231         if (!iopl(3)) {
 232                 iopl(0);
 233
 234                 PROFILE_GetWineIniString( "ports", "read", "*",
 235                                          temp, sizeof(temp) );
 236                 do_IO_port_init_read_or_write(temp, IO_READ);
 237                 PROFILE_GetWineIniString( "ports", "write", "*",
 238                                          temp, sizeof(temp) );
 239                 do_IO_port_init_read_or_write(temp, IO_WRITE);
 240         }
 241 #endif  /* DIRECT_IO_ACCESS */
 242     IO_FixCMOSCheckSum();
 243 }
 244
 245
 246 /**********************************************************************
 247  *          IO_inport
 248  *
 249  * Note: The size argument has to be handled correctly _externally_
 250  * (as we always return a DWORD)
 251  */
 252 DWORD IO_inport( int port, int size )
 253 {
 254     DWORD res = 0;
 255
 256     TRACE(int, "%d-byte value from port 0x%02x\n", size, port );
 257
 258 #ifdef DIRECT_IO_ACCESS
 259     if ((do_direct_port_access)
 260         /* Make sure we have access to the port */
 261         && (port_permissions[port] & IO_READ))
 262     {
 263         iopl(3);
 264         switch(size)
 265         {
 266         case 1: res = inb( port ); break;
 267         case 2: res = inw( port ); break;
 268         case 4: res = inl( port ); break;
 269         default:
 270             ERR(int, "invalid data size %d\n", size);
 271         }
 272         iopl(0);
 273         return res;
 274     }
 275 #endif
 276
 277     switch (port)
 278     {
 279     case 0x3ba:
 280     case 0x3da:
 281         res = (DWORD)VGA_ioport_in( port );
 282         break;
 283     case 0x40:
 284     case 0x41:
 285     case 0x42:
 286     {
 287         BYTE chan = port & 3;
 288         WORD tempval = 0;
 289
 290         if (tmr_8253_latched[chan] == TRUE)
 291         {
 292             tempval = tmr_8253_latch[chan];
 293             tmr_8253_latched[chan] = FALSE;
 294         }
 295         else
 296         {
 297             dummy_ctr -= 1+(int) (10.0*rand()/(RAND_MAX+1.0));
 298         if (chan == 0) /* System timer counter divisor */
 299                 /* FIXME: DOSVM_GetTimer() returns quite rigid values */
 300                                 tempval = dummy_ctr+(WORD)DOSVM_GetTimer();
 301         else
 302         {   /* FIXME: intelligent hardware timer emulation needed */
 303             tempval = dummy_ctr;
 304         }
 305         }
 306         switch (tmr_8253_ctrlbyte_ch[chan] & 0x30)
 307         {
 308         case 0x00:
 309             break; /* correct ? */
 310         case 0x10: /* read lo byte */
 311             res = (BYTE)tempval;
 312             break;
 313         case 0x30: /* read lo byte, then hi byte */
 314             tmr_8253_byte_toggle[chan] ^= TRUE; /* toggle */
 315             if (tmr_8253_byte_toggle[chan] == TRUE)
 316             {
 317                 res = (BYTE)tempval;
 318                 break;
 319             }
 320             /* else [fall through if read hi byte !] */
 321         case 0x20: /* read hi byte */
 322             res = (BYTE)tempval>>8;
 323             break;
 324         }
 325         break;
 326     }
 327     case 0x60:
 328         res = INT_Int09ReadScan();
 329 #if 0 /* what's this port got to do with parport ? */
 330         res = (DWORD)parport_8255[0];
 331 #endif
 332         break;
 333     case 0x61:
 334         res = (DWORD)parport_8255[1];
 335         break;
 336     case 0x62:
 337         res = (DWORD)parport_8255[2];
 338         break;
 339     case 0x70:
 340         res = (DWORD)cmosaddress;
 341         break;
 342     case 0x71:
 343         res = (DWORD)cmosimage[cmosaddress & 0x3f];
 344         break;
 345     case 0x200:
 346     case 0x201:
 347         res = 0xffffffff; /* no joystick */
 348         break;
 349     default:
 350         WARN( int, "Direct I/O read attempted from port %x\n", port);
 351         res = 0xffffffff;
 352         break;
 353     }
 354     TRACE(int, "  returning ( 0x%lx )\n", res );
 355     return res;
 356 }
 357
 358
 359 /**********************************************************************
 360  *          IO_outport
 361  */
 362 void IO_outport( int port, int size, DWORD value )
 363 {
 364     TRACE(int, "IO: 0x%lx (%d-byte value) to port 0x%02x\n",
 365                  value, size, port );
 366
 367 #ifdef DIRECT_IO_ACCESS
 368     if ((do_direct_port_access)
 369         /* Make sure we have access to the port */
 370         && (port_permissions[port] & IO_WRITE))
 371     {
 372         iopl(3);
 373         switch(size)
 374         {
 375         case 1: outb( LOBYTE(value), port ); break;
 376         case 2: outw( LOWORD(value), port ); break;
 377         case 4: outl( value, port ); break;
 378         default:
 379             WARN(int, "Invalid data size %d\n", size);
 380         }
 381         iopl(0);
 382         return;
 383     }
 384 #endif
 385
 386     switch (port)
 387     {
 388     case 0x3c8:
 389     case 0x3c9:
 390         VGA_ioport_out( port, (BYTE)value );
 391         break;
 392     case 0x20:
 393         DOSVM_PIC_ioport_out( port, (BYTE)value );
 394         break;
 395     case 0x40:
 396     case 0x41:
 397     case 0x42:
 398     {
 399         BYTE chan = port & 3;
 400         WORD oldval = 0;
 401
 402         if ( ((tmr_8253_ctrlbyte_ch[chan] & 0x30) != 0x30) ||
 403 /* we need to get the oldval before any lo/hi byte change has been made */
 404              (tmr_8253_byte_toggle[chan] == FALSE) )
 405             oldval = tmr_8253_countmax[chan];
 406         switch (tmr_8253_ctrlbyte_ch[chan] & 0x30)
 407         {
 408         case 0x00:
 409             break; /* correct ? */
 410         case 0x10: /* write lo byte */
 411             tmr_8253_countmax[chan] =
 412                 (tmr_8253_countmax[chan] & 0xff00) | (BYTE)value;
 413             break;
 414         case 0x30: /* write lo byte, then hi byte */
 415             tmr_8253_byte_toggle[chan] ^= TRUE; /* toggle */
 416             if (tmr_8253_byte_toggle[chan] == TRUE)
 417             {
 418                 tmr_8253_countmax[chan] =
 419                     (tmr_8253_countmax[chan] & 0xff00) | (BYTE)value;
 420                 break;
 421             }
 422             /* else [fall through if write hi byte !] */
 423         case 0x20: /* write hi byte */
 424             tmr_8253_countmax[chan] =
 425                 (tmr_8253_countmax[chan] & 0xff)|((BYTE)value << 8);
 426             break;
 427         }
 428         if (
 429             /* programming finished ? */
 430             ( ((tmr_8253_ctrlbyte_ch[chan] & 0x30) != 0x30) ||
 431               (tmr_8253_byte_toggle[chan] == FALSE) )
 432             /* update to new value ? */
 433             && (tmr_8253_countmax[chan] != oldval)
 434             )
 435             set_timer_maxval(chan, tmr_8253_countmax[chan]);
 436     }
 437     break;
 438     case 0x43:
 439         {
 440           BYTE chan = ((BYTE)value & 0xc0) >> 6;
 441
 442         /* ctrl byte for specific timer channel */
 443           tmr_8253_ctrlbyte_ch[chan] = (BYTE)value;
 444           if (chan == 3) {
 445             FIXME(int,"8254 timer readback not implemented yet\n");
 446             }
 447           else
 448           if (((BYTE)value&0x30)==0) { /* latch timer */
 449             tmr_8253_latched[chan] = TRUE;
 450             dummy_ctr -= 1+(int) (10.0*rand()/(RAND_MAX+1.0));
 451             if (chan == 0) /* System timer divisor */
 452               tmr_8253_latch[0] = dummy_ctr+(WORD)DOSVM_GetTimer();
 453             else
 454             {   /* FIXME: intelligent hardware timer emulation needed */
 455               tmr_8253_latch[chan] = dummy_ctr;
 456             }
 457           }
 458         if ((value & 0x30) == 0x30) /* write lo byte, then hi byte */
 459             tmr_8253_byte_toggle[((BYTE)value & 0xc0) >> 6] = FALSE; /* init */
 460         }
 461         break;
 462     case 0x61:
 463         parport_8255[1] = (BYTE)value;
 464         if ((((BYTE)parport_8255[1] & 3) == 3) && (tmr_8253_countmax[2] != 1))
 465         {
 466             TRACE(int, "Beep (freq: %d) !\n", 1193180 / tmr_8253_countmax[2]);
 467             Beep(1193180 / tmr_8253_countmax[2], 20);
 468         }
 469         break;
 470     case 0x70:
 471         cmosaddress = (BYTE)value & 0x7f;
 472         break;
 473     case 0x71:
 474         cmosimage[cmosaddress & 0x3f] = (BYTE)value;
 475         break;
 476     default:
 477         WARN(int, "Direct I/O write attempted to port %x\n", port );
 478         break;
 479     }
 480 }