home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 3 / TheARMClub_PDCD3.iso / programs / emulaton / at2600 / !v2600 / c / memory < prev    next >
Text File  |  1998-04-11  |  16KB  |  856 lines
  1. /*****************************************************************************
  2.  
  3.    This file is part of x2600, the Atari 2600 Emulator
  4.    ===================================================
  5.  
  6.    Copyright 1996 Alex Hornby. For contributions see the file CREDITS.
  7.  
  8.    This software is distributed under the terms of the GNU General Public
  9.    License. This is free software with ABSOLUTELY NO WARRANTY.
  10.  
  11.    See the file COPYING for Details.
  12.  
  13.    $Id: memory.c,v 2.22 1997/02/23 20:39:29 ahornby Exp $
  14. ******************************************************************************/
  15.  
  16. /*
  17.  * Holds the memory access routines to both memory and memory mapped
  18.  * i/o, hence memory.c
  19.  *
  20.  * Uses GNU C extensions.
  21.  */
  22.  
  23. #include <stdio.h>
  24. #include "string.h"
  25. #include "types.h"
  26. #include "address.h"
  27. #include "vmachine.h"
  28. #include "display.h"
  29. #include "raster.h"
  30. #include "collision.h"
  31. #include "col_mask.h"
  32. #include "options.h"
  33. #include "control.h"
  34. #include "sound.h"
  35. #include "hawklib.h"
  36.  
  37. extern CLOCK clkcount;
  38. extern CLOCK clk;
  39. extern int beamadj;
  40.  
  41. /* Undecoded Read, for executable code etc. */
  42. /* a: address to read */
  43. /* returns: byte at address a */
  44. BYTE
  45. undecRead (ADDRESS a)
  46. {
  47.   if (a & 0x1000)
  48.     return theRom[a & 0xfff];
  49.   else
  50.     return theRam[a & 0x7f];
  51. }
  52.  
  53.  
  54. inline void
  55. bank_switch_write (ADDRESS a, BYTE b)
  56. {
  57.   a&=0xfff;
  58.   switch (base_opts.bank)
  59.     {
  60.  
  61.     case 1:
  62.       /* Atari 8k F8 */
  63.       switch (a)
  64.     {
  65.     case 0xff8:
  66.       theRom = &theCart[0];
  67.       break;
  68.     case 0xff9:
  69.       theRom = &theCart[4096];
  70.       break;
  71.     }
  72.       break;
  73.  
  74.     case 2:
  75.       /* Atari 16k F6 */
  76.       switch (a)
  77.     {
  78.     case 0xff6:
  79.       theRom = &theCart[0];
  80.       break;
  81.     case 0xff7:
  82.       theRom = &theCart[4096];
  83.       break;
  84.     case 0xff8:
  85.       theRom = &theCart[8192];
  86.       break;
  87.     case 0xff9:
  88.       theRom = &theCart[12288];
  89.       break;
  90.     }
  91.       break;
  92.  
  93.     case 3:
  94.       /* Parker Brothers 8k E0 */
  95.       {
  96.     ADDRESS a1;
  97.     if (a > 0xfdf && a < 0xfe8)
  98.       {
  99.         a1=(a&0x07)<<10;
  100.         memcpy(&cartScratch[0],&theCart[a1],0x400);
  101.       }
  102.     else if (a > 0xfe7 && a < 0xff0)
  103.       {
  104.         a1=(a&0x07)<<10;
  105.         memcpy(&cartScratch[0x400],&theCart[a1],0x400);
  106.       }
  107.     else if (a > 0xfef && a < 0xff8)
  108.       {
  109.         a1=(a&0x07)<<10;
  110.         memcpy(&cartScratch[0x800],&theCart[a1],0x400);
  111.       }
  112.       }
  113.       break;
  114.  
  115.     case 4:
  116.       /* CBS Ram Plus FA */
  117.       if (a < 0x100)
  118.     cartRam[a & 0xff]=b;
  119.       else
  120.     {
  121.       switch (a)
  122.         {
  123.         case 0xff8:
  124.           theRom = &theCart[0];
  125.           break;
  126.         case 0xff9:
  127.           theRom = &theCart[4096];
  128.           break;
  129.         case 0xffa:
  130.           theRom = &theCart[8192];
  131.           break;
  132.         }
  133.     }
  134.       break;
  135.  
  136.     case 5:
  137.       /* Atari 16k + super chip ram F6SC */
  138.       if (a < 0x80)
  139.     cartRam[a & 0x7f] = b;
  140.       else
  141.     {
  142.       switch (a)
  143.         {
  144.         case 0xff6:
  145.           theRom = &theCart[0];
  146.           break;
  147.         case 0xff7:
  148.           theRom = &theCart[4096];
  149.           break;
  150.         case 0xff8:
  151.           theRom = &theCart[8192];
  152.           break;
  153.         case 0xff9:
  154.           theRom = &theCart[12288];
  155.           break;
  156.         }
  157.     }
  158.       break;
  159.     }
  160. }
  161.  
  162. inline BYTE
  163. bank_switch_read (ADDRESS a)
  164. {
  165.   BYTE res;
  166.  
  167.   a&=0xfff;
  168.   switch (base_opts.bank)
  169.     {
  170.     case 1:
  171.       /* Atari 8k F8 */
  172.       switch (a)
  173.     {
  174.     case 0xff8:
  175.       theRom = &theCart[0];
  176.       break;
  177.     case 0xff9:
  178.       theRom = &theCart[4096];
  179.       break;
  180.     }
  181.       res=theRom[a];
  182.       break;
  183.  
  184.     case 2:
  185.       /* Atari 16k F6 */
  186.       switch (a)
  187.     {
  188.     case 0xff6:
  189.       theRom = &theCart[0];
  190.       break;
  191.     case 0xff7:
  192.       theRom = &theCart[4096];
  193.       break;
  194.     case 0xff8:
  195.       theRom = &theCart[8192];
  196.       break;
  197.     case 0xff9:
  198.       theRom = &theCart[12288];
  199.       break;
  200.     }
  201.       res=theRom[a];
  202.       break;
  203.  
  204.     case 3:
  205.       /* Parker Brothers 8k E0 */
  206.       /* Parker Brothers 8k E0 */
  207.       {
  208.     ADDRESS a1;
  209.     if (a > 0xfdf && a < 0xfe8)
  210.       {
  211.         a1=(a&0x07)<<10;
  212.         memcpy(&cartScratch[0],&theCart[a1],0x400);
  213.       }
  214.     else if (a > 0xfe7 && a < 0xff0)
  215.       {
  216.         a1=(a&0x07)<<10;
  217.         memcpy(&cartScratch[0x400],&theCart[a1],0x400);
  218.       }
  219.     else if (a > 0xfef && a < 0xff8)
  220.       {
  221.         a1=(a&0x07)<<10;
  222.         memcpy(&cartScratch[0x800],&theCart[a1],0x400);
  223.       }
  224.       }
  225.       res=theRom[a];
  226.       break;
  227.  
  228.     case 4:
  229.       /* CBS Ram Plus FA */
  230.       if (a > 0xff && a < 0x200)
  231.       res=cartRam[a & 0xff];
  232.       else
  233.     {
  234.       switch (a)
  235.         {
  236.         case 0xff8:
  237.           theRom = &theCart[0];
  238.           break;
  239.         case 0xff9:
  240.           theRom = &theCart[4096];
  241.           break;
  242.         case 0xffa:
  243.           theRom = &theCart[8192];
  244.           break;
  245.         }
  246.       res=theRom[a];
  247.     }
  248.       break;
  249.  
  250.     case 5:
  251.       /* Atari 16k + super chip ram F6SC */
  252.       if (a > 0x7f && a < 0x100)
  253.     res=cartRam[a & 0x7f];
  254.       else
  255.     {
  256.       switch (a)
  257.         {
  258.         case 0xff6:
  259.           theRom = &theCart[0];
  260.           break;
  261.         case 0xff7:
  262.           theRom = &theCart[4096];
  263.           break;
  264.         case 0xff8:
  265.           theRom = &theCart[8192];
  266.           break;
  267.         case 0xff9:
  268.           theRom = &theCart[12288];
  269.           break;
  270.         }
  271.       res=theRom[a];
  272.     }
  273.       break;
  274.     default:
  275.       res=theRom[a];
  276.       break;
  277.     }
  278.   return res;
  279. }
  280.  
  281.  
  282. /* Decoded write to memory */
  283. /* a: address written to */
  284. /* b: byte value written */
  285. void
  286. decWrite (ADDRESS a, BYTE b)
  287. {
  288.   int i;
  289.  
  290.   /* A Write to the ROM area */
  291.   if (a & 0x1000)
  292.     {
  293.       bank_switch_write (a,b);
  294.     }
  295.   /* A Write to the RAM area in Page 0 and 1 */
  296.   else if ((a & 0x280) == 0x80)
  297.     {
  298.       theRam[a & 0x7f] = b;
  299.     }
  300.   /* TIA */
  301.   else if (!(a & 0x80))
  302.     {
  303.       switch (a & 0x7f)
  304.     {
  305.     case VSYNC:
  306.       if (b & 0x02)
  307.         {
  308.           /* Start vertical sync */
  309.           vbeam_state = VSYNCSTATE;
  310.         }
  311.       break;
  312.     case VBLANK:
  313.       do_vblank (b);
  314.       /* Ground paddle pots */
  315.       if (b & 0x80)
  316.         {
  317.           /* Grounded ports */
  318.           tiaRead[INPT0] = 0x00;
  319.           tiaRead[INPT1] = 0x00;
  320.         }
  321.       else
  322.         {
  323.           /* Processor now measures time for a logic 1 to appear
  324.              at each paddle port */
  325.           tiaRead[INPT0] = 0x80;
  326.           tiaRead[INPT1] = 0x80;
  327.           paddle[0].val = (int)clk;
  328.           paddle[1].val = (int)clk;
  329.         }
  330.       tiaWrite[VBLANK] = b;
  331.       break;
  332.     case WSYNC:
  333.       /* Skip to HSYNC pulse */
  334.       do_hsync ();
  335.       break;
  336.     case RSYNC:
  337.       /* used in chip testing */
  338.       //hl_error("ARGHH an undocumented RSYNC!");
  339.       break;
  340.     case NUSIZ0:
  341.       /*
  342.          printf("P0 nusize: ebeamx=%d, ebeamy=%d, nusize=%02x\n",
  343.          ebeamx, ebeamy, (int)b);
  344.        */
  345.       pl[0].nusize = b & 0x07;
  346.       ml[0].width = (b & 0x30) >> 4;
  347.       break;
  348.     case NUSIZ1:
  349.       /*
  350.          printf("P1 nusize: ebeamx=%d, ebeamy=%d, nusize=%02x\n",
  351.          ebeamx, ebeamy, (int)b);
  352.        */
  353.       pl[1].nusize = b & 0x07;
  354.       ml[1].width = (b & 0x30) >> 4;
  355.       break;
  356.     case COLUP0:
  357.       do_unified_change (0, tv_color (b));
  358.       break;
  359.     case COLUP1:
  360.       do_unified_change (1, tv_color (b));
  361.       break;
  362.     case COLUPF:
  363.       do_unified_change (2, tv_color (b));
  364.       break;
  365.     case COLUBK:
  366.       /*printf("BKcolour = %d, line=%d\n", (int)(b>>1), ebeamy); */
  367.       do_unified_change (3, tv_color (b));
  368.       break;
  369.     case CTRLPF:
  370.       tiaWrite[CTRLPF] = b & 0x37;    /* Bitmask 00110111 */
  371.       do_pfraster_change (0, 3, b & 0x01);    /* Reflection */
  372.  
  373.       /* Normal/Alternate priority */
  374.       do_unified_change(4, (b & 0x04));
  375.  
  376.       /* Scores/Not scores */
  377.       do_unified_change(5, (b & 0x02));
  378.  
  379.       break;
  380.     case REFP0:
  381.       pl[0].reflect = (b & 0x08) >> 3;
  382.       break;
  383.     case REFP1:
  384.       pl[1].reflect = (b & 0x08) >> 3;
  385.       break;
  386.     case PF0:
  387.       do_pfraster_change (0, 0, b & 0xf0);
  388.       break;
  389.     case PF1:
  390.       do_pfraster_change (0, 1, b);
  391.       break;
  392.     case PF2:
  393.       do_pfraster_change (0, 2, b);
  394.       break;
  395.     case RESP0:
  396.       /* Ghost in pacman!
  397.          if(beamadj == 0) {
  398.          printf("RESP0: ebeamx=%d, ebeamy=%d\n",
  399.          ebeamx, ebeamy);
  400.          show();
  401.          } */
  402.       pl[0].x = ebeamx + beamadj;
  403.       /* As per page 20 Stella Programmers Guide */
  404.       if (pl[0].x < 0)
  405.         pl[0].x = 0;
  406.       break;
  407.     case RESP1:
  408.       /*if(beamadj == 0) {
  409.          printf("RESP1: ebeamx=%d, ebeamy=%d\n",
  410.          ebeamx, ebeamy);
  411.          show();
  412.          } */
  413.       pl[1].x = ebeamx + beamadj;
  414.       /* As per page 20 Stella Programmers Guide */
  415.       if (pl[1].x < 0)
  416.         pl[1].x = 0;
  417.       break;
  418.     case RESM0:
  419.       ml[0].x = ebeamx + beamadj;
  420.       /* As per page 20 Stella Programmers Guide */
  421.       if (ml[0].x < 0)
  422.         ml[0].x = 0;
  423.       break;
  424.     case RESM1:
  425.       ml[1].x = ebeamx + beamadj;
  426.       /* As per page 20 Stella Programmers Guide */
  427.       if (ml[1].x < 0)
  428.         ml[1].x = 0;
  429.       break;
  430.     case RESBL:
  431.       ml[2].x = ebeamx + beamadj;
  432.       /* As per page 20 Stella Programmers Guide */
  433.       if (ml[2].x < 0)
  434.         ml[2].x = 0;
  435.       break;
  436.     case AUDC0:
  437.       sound_waveform (0, b & 0x0f);
  438.       break;
  439.     case AUDC1:
  440.       sound_waveform (1, b & 0x0f);
  441.       break;
  442.     case AUDF0:
  443.       sound_freq (0, b & 0x1f);
  444.       break;
  445.     case AUDF1:
  446.       sound_freq (1, b & 0x1f);
  447.       break;
  448.     case AUDV0:
  449.       sound_volume (0, b & 0x0f);
  450.       break;
  451.     case AUDV1:
  452.       sound_volume (1, b & 0x0f);
  453.       break;
  454.     case GRP0:
  455.       do_plraster_change (0, 0, b);
  456.       do_plraster_change (1, 1, b);
  457.       break;
  458.     case GRP1:
  459.       do_plraster_change (1, 0, b);
  460.       do_plraster_change (0, 1, b);
  461.       ml[2].vdel = ml[2].enabled;
  462.       break;
  463.     case ENAM0:
  464.       ml[0].enabled = b & 0x02;
  465.       if (tiaWrite[RESMP0])
  466.         ml[0].enabled = 0;
  467.       break;
  468.     case ENAM1:
  469.       ml[1].enabled = b & 0x02;
  470.       if (tiaWrite[RESMP1])
  471.         ml[1].enabled = 0;
  472.       break;
  473.     case ENABL:
  474.       ml[2].enabled = b & 0x02;
  475.       break;
  476.     case HMP0:
  477.       pl[0].hmm = (b >> 4);
  478.       break;
  479.     case HMP1:
  480.       pl[1].hmm = (b >> 4);
  481.       break;
  482.     case HMM0:
  483.       ml[0].hmm = (b >> 4);
  484.       break;
  485.     case HMM1:
  486.       ml[1].hmm = (b >> 4);
  487.       break;
  488.     case HMBL:
  489.       ml[2].hmm = (b >> 4);
  490.       break;
  491.     case VDELP0:
  492.       pl[0].vdel_flag = b & 0x01;
  493.       break;
  494.     case VDELP1:
  495.       pl[1].vdel_flag = b & 0x01;
  496.       break;
  497.     case VDELBL:
  498.       ml[2].vdel_flag = b & 0x01;
  499.       break;
  500.     case RESMP0:
  501.       tiaWrite[RESMP0] = b & 0x02;
  502.       if (b & 0x02)
  503.         {
  504.           ml[0].x = pl[0].x + 4;
  505.           ml[0].enabled = 0;
  506.         }
  507.       break;
  508.     case RESMP1:
  509.       tiaWrite[RESMP1] = b & 0x02;
  510.       if (b & 0x02)
  511.         {
  512.           ml[1].x = pl[1].x + 4;
  513.           ml[1].enabled = 0;
  514.         }
  515.       break;
  516.     case HMOVE:
  517.       /* Player 0 */
  518.       if (pl[0].hmm & 0x08)
  519.         pl[0].x += ((pl[0].hmm ^ 0x0f) + 1);
  520.       else
  521.         pl[0].x -= pl[0].hmm;
  522.       if (pl[0].x > 160)
  523.         pl[0].x = -68;
  524.       else if (pl[0].x < -68)
  525.         pl[0].x = 160;
  526.  
  527.       /* Player 2 */
  528.       if (pl[1].hmm & 0x08)
  529.         pl[1].x += ((pl[1].hmm ^ 0x0f) + 1);
  530.       else
  531.         pl[1].x -= pl[1].hmm;
  532.       if (pl[1].x > 160)
  533.         pl[1].x = -68;
  534.       else if (pl[1].x < -68)
  535.         pl[1].x = 160;
  536.  
  537.       /* Missiles */
  538.       for (i = 0; i < 3; i++)
  539.         {
  540.           if (ml[i].hmm & 0x08)
  541.         ml[i].x += ((ml[i].hmm ^ 0x0f) + 1);
  542.           else
  543.         ml[i].x -= ml[i].hmm;
  544.           if (ml[i].x > 160)
  545.         ml[i].x = -68;
  546.           else if (ml[i].x < -68)
  547.         ml[i].x = 160;
  548.         }
  549.       break;
  550.     case HMCLR:
  551.       pl[0].hmm = 0;
  552.       pl[1].hmm = 0;
  553.       for (i = 0; i < 3; i++)
  554.         ml[i].hmm = 0;
  555.       break;
  556.     case CXCLR:
  557.       col_state=0;
  558.       break;
  559.     }
  560.     }
  561.   else
  562.     {
  563.       switch (a & 0x2ff)
  564.     {
  565.       /* RIOT I/O ports */
  566.     case SWCHA:
  567.       riotWrite[SWCHA] = b;
  568.       break;
  569.     case SWACNT:
  570.       riotWrite[SWACNT] = b;
  571.       break;
  572.     case SWCHB:
  573.     case SWBCNT:
  574.       /* Do nothing */
  575.       break;
  576.  
  577.       /* Timer ports */
  578.     case TIM1T:
  579.       set_timer (0, b, (int)clkcount);
  580.       break;
  581.     case TIM8T:
  582.       set_timer (3, b, (int)clkcount);
  583.       break;
  584.     case TIM64T:
  585.       set_timer (6, b, (int)clkcount);
  586.       break;
  587.     case T1024T:
  588.       set_timer (10, b, (int)clkcount);
  589.       break;
  590.     default:
  591.       printf ("Unknown write %x\n", a);
  592.  
  593.       break;
  594.     }
  595.     }
  596. }
  597.  
  598.  
  599. /* Decoded read from memory */
  600. /* a: address to read */
  601. /* returns: byte value from address a */
  602. BYTE
  603. decRead (ADDRESS a)
  604. {
  605.   BYTE res = 65;
  606.  
  607.   if (a & 0x1000)
  608.     {
  609.       a = a & 0xfff;
  610.       if (base_opts.bank != 0)
  611.     res= bank_switch_read (a);
  612.       else
  613.     res = theRom[a];
  614.     }
  615.   else if ((a & 0x280) == 0x80)
  616.     {
  617.       res = theRam[a & 0x7f];
  618.     }
  619.   else if (!(a & 0x80))
  620.     {
  621.       switch (a & 0x0f)
  622.     {
  623.       /* TIA */
  624.     case CXM0P:
  625.       res = (col_state & CXM0P_MASK) << 6;
  626.       break;
  627.     case CXM1P:
  628.       res = (col_state & CXM1P_MASK) << 4;
  629.       break;
  630.     case CXP0FB:
  631.       res = (col_state & CXP0FB_MASK) << 2;
  632.       break;
  633.     case CXP1FB:
  634.       res = (col_state & CXP1FB_MASK);
  635.       break;
  636.     case CXM0FB:
  637.       res = (col_state & CXM0FB_MASK) >> 2;
  638.       break;
  639.     case CXM1FB:
  640.       res = (col_state & CXM1FB_MASK) >> 4;
  641.       break;
  642.     case CXBLPF:
  643.       res = (col_state & CXBLPF_MASK) >> 5;
  644.       break;
  645.     case CXPPMM:
  646.       res = (col_state & CXPPMM_MASK) >> 7;
  647.       break;
  648.     case INPT0:
  649.       if (base_opts.lcon == PADDLE)
  650.         {
  651.           tiaRead[INPT0] = do_paddle (0);
  652.         }
  653.       else if (base_opts.lcon == KEYPAD)
  654.         tiaRead[INPT0] = do_keypad (0, 0);
  655.       res = tiaRead[INPT0];
  656.       break;
  657.     case INPT1:
  658.       if (base_opts.lcon == PADDLE)
  659.         {
  660.           tiaRead[INPT1] = do_paddle (1);
  661.         }
  662.       if (base_opts.lcon == KEYPAD)
  663.         tiaRead[INPT1]=do_keypad (0, 1);
  664.       res = tiaRead[INPT1];
  665.       break;
  666.     case INPT2:
  667.       if (base_opts.rcon == KEYPAD)
  668.         tiaRead[INPT2] = do_keypad (1, 0);
  669.       res = tiaRead[INPT2];
  670.       break;
  671.     case INPT3:
  672.       if (base_opts.rcon == KEYPAD)
  673.          tiaRead[INPT3]=do_keypad ( 1, 1);
  674.       res = tiaRead[INPT3];
  675.       break;
  676.     case INPT4:
  677.       res = tiaRead[INPT4];
  678.       break;
  679.     case INPT5:
  680.       res = tiaRead[INPT5];
  681.       break;
  682.     case 0x0e:
  683.     case 0x0f:
  684.       res = 0x0f;
  685.       /* RAM, mapped to page 0 and 1 */
  686.     }
  687.     }
  688.   else
  689.     {
  690.       switch (a & 0x2ff)
  691.     {
  692.       /* Timer output */
  693.     case INTIM:
  694.     case 0x285:
  695.     case 0x286:
  696.     case TIM1T:
  697.     case TIM8T:
  698.     case TIM64T:
  699.     case T1024T:
  700.       res = do_timer ((int)clkcount);
  701.       /*printf("Timer is %d res is %d\n", res, timer_res); */
  702.       break;
  703.     case SWCHA:
  704.       switch (base_opts.lcon)
  705.         {
  706.         case PADDLE:
  707.           if (base_opts.lcon == PADDLE)
  708.         {
  709.           if (mouse_button ())
  710.             riotRead[SWCHA] &= 0x7f;
  711.           else
  712.             riotRead[SWCHA] |= 0x80;
  713.         }
  714.           else if (base_opts.rcon == PADDLE)
  715.         {
  716.           if (mouse_button ())
  717.             riotRead[SWCHA] &= 0xbf;
  718.           else
  719.             riotRead[SWCHA] |= 0x40;
  720.         }
  721.           break;
  722.         }
  723.       res = riotRead[SWCHA];
  724.       break;
  725.       /* Switch B is hardwired to input */
  726.     case SWCHB:
  727.     case SWCHB + 0x100:
  728.       res = riotRead[SWCHB];
  729.       break;
  730.     default:
  731.       printf ("Unknown read 0x%x\n", a & 0x2ff);
  732.  
  733.       res = 65;
  734.       break;
  735.     }
  736.     }
  737.   return res;
  738. }
  739.  
  740.  
  741. /* Debugging read from memory */
  742. /* a: address to read from */
  743. /* returns: value at address a, WITHOUT side effects */
  744. BYTE
  745. dbgRead (ADDRESS a)
  746. {
  747.   BYTE res;
  748.  
  749.   if (a & 0x1000)
  750.     {
  751.       a = a & 0xfff;
  752.       res = theRom[a];
  753.       if (base_opts.bank != 0)
  754.     bank_switch_read (a);
  755.     }
  756.   else if ((a & 0x280) == 0x80)
  757.     {
  758.       res = theRam[a & 0x7f];
  759.     }
  760.   else if (!(a & 0x80))
  761.     {
  762.       switch (a & 0x0f)
  763.     {
  764.       /* TIA */
  765.     case COLUP0:
  766.       res = colour_table[P0M0_COLOUR];
  767.       break;
  768.     case COLUP1:
  769.       res = colour_table[P1M1_COLOUR];
  770.       break;
  771.     case COLUPF:
  772.       res = colour_table[PFBL_COLOUR];
  773.       break;
  774.     case COLUBK:
  775.       res = colour_table[BK_COLOUR];
  776.       break;
  777.     case CTRLPF:
  778.       res = tiaWrite[CTRLPF];    /* Bitmask 00110111 */
  779.       break;
  780.     case REFP0:
  781.       res = tiaWrite[REFP0];
  782.       break;
  783.     case REFP1:
  784.       res = tiaWrite[REFP1];
  785.       break;
  786.     case PF0:
  787.       res = pf[0].pf0;
  788.       break;
  789.     case PF1:
  790.       res = pf[0].pf1;
  791.       break;
  792.     case PF2:
  793.       res = pf[0].pf2;
  794.       break;
  795.     default:
  796.       res = 0;
  797.       break;
  798.       /*  case CXM0P:
  799.          break;
  800.          case CXM1P:
  801.          break;
  802.          case CXP0FB:
  803.          break;
  804.          case CXP1FB:
  805.          break;
  806.          case CXM0FB:
  807.          break;
  808.          case CXM1FB:
  809.          break;
  810.          case CXBLPF:
  811.          break;
  812.          case CXPPMM:
  813.          break;
  814.          case INPT0:
  815.          break;
  816.          case INPT1:
  817.          break;
  818.          case INPT2:
  819.          break;
  820.          case INPT3:
  821.          break;
  822.          case INPT4:
  823.          break;
  824.          case INPT5:
  825.          break;
  826.        */
  827.     }
  828.     }
  829.   else
  830.     {
  831.       switch (a & 0x2ff)
  832.     {
  833.       /* Timer output */
  834.     case INTIM:
  835.     case 0x285:
  836.     case 0x29d:
  837.     case INTIM + 0x100:
  838.       res = riotRead[INTIM];
  839.       break;
  840.     case SWCHA:
  841.     case SWCHA + 0x100:
  842.       res = riotRead[SWCHA];
  843.       break;
  844.       /* Switch B is hardwired to input */
  845.     case SWCHB:
  846.     case SWCHB + 0x100:
  847.       res = riotRead[SWCHB];
  848.       break;
  849.     default:
  850.       res = 0;
  851.       break;
  852.     }
  853.     }
  854.   return res;
  855. }
  856.