lcdc.c

   1
   2
   3 #include <stdlib.h>
   4
   5 #include "defs.h"
   6 #include "hw.h"
   7 #include "cpu.h"
   8 #include "regs.h"
   9 #include "lcd.h"
  10
  11 #define C (cpu.lcdc)
  12
  13
  14 /*
  15  * stat_trigger updates the STAT interrupt line to reflect whether any
  16  * of the conditions set to be tested (by bits 3-6 of R_STAT) are met.
  17  * This function should be called whenever any of the following occur:
  18  * 1) LY or LYC changes.
  19  * 2) A state transition affects the low 2 bits of R_STAT (see below).
  20  * 3) The program writes to the upper bits of R_STAT.
  21  * stat_trigger also updates bit 2 of R_STAT to reflect whether LY=LYC.
  22  */
  23
  24 void stat_trigger()
  25 {
  26         static const int condbits[4] = { 0x08, 0x10, 0x20, 0x00 };
  27         int flag = 0;
  28
  29         if (R_LY == R_LYC)
  30         {
  31                 R_STAT |= 0x04;
  32                 if (R_STAT & 0x40) flag = IF_STAT;
  33         }
  34         else R_STAT &= ~0x04;
  35
  36         if (R_STAT & condbits[R_STAT&3]) flag = IF_STAT;
  37
  38         if (!(R_LCDC & 0x80)) flag = 0;
  39
  40         hw_interrupt(flag, IF_STAT);
  41 }
  42
  43 void stat_write(byte b)
  44 {
  45         R_STAT = (R_STAT & 0x07) | (b & 0x78);
  46         if (!hw.cgb && !(R_STAT & 2)) /* DMG STAT write bug => interrupt */
  47                 hw_interrupt(IF_STAT, IF_STAT);
  48         stat_trigger();
  49 }
  50
  51
  52 /*
  53  * stat_change is called when a transition results in a change to the
  54  * LCD STAT condition (the low 2 bits of R_STAT).  It raises or lowers
  55  * the VBLANK interrupt line appropriately and calls stat_trigger to
  56  * update the STAT interrupt line.
  57  */
  58
  59 static void stat_change(int stat)
  60 {
  61         stat &= 3;
  62         R_STAT = (R_STAT & 0x7C) | stat;
  63
  64         if (stat != 1) hw_interrupt(0, IF_VBLANK);
  65         /* hw_interrupt((stat == 1) ? IF_VBLANK : 0, IF_VBLANK); */
  66         stat_trigger();
  67 }
  68
  69
  70 void lcdc_change(byte b)
  71 {
  72         byte old = R_LCDC;
  73         R_LCDC = b;
  74         if ((R_LCDC ^ old) & 0x80) /* lcd on/off change */
  75         {
  76                 R_LY = 0;
  77                 stat_change(2);
  78                 C = 40;
  79                 lcd_begin();
  80         }
  81 }
  82
  83
  84 void lcdc_trans()
  85 {
  86         if (!(R_LCDC & 0x80))
  87         {
  88                 while (C <= 0)
  89                 {
  90                         switch ((byte)(R_STAT & 3))
  91                         {
  92                         case 0:
  93                         case 1:
  94                                 stat_change(2);
  95                                 C += 40;
  96                                 break;
  97                         case 2:
  98                                 stat_change(3);
  99                                 C += 86;
 100                                 break;
 101                         case 3:
 102                                 stat_change(0);
 103                                 if (hw.hdma & 0x80)
 104                                         hw_hdma();
 105                                 else
 106                                         C += 102;
 107                                 break;
 108                         }
 109                         return;
 110                 }
 111         }
 112         while (C <= 0)
 113         {
 114                 switch ((byte)(R_STAT & 3))
 115                 {
 116                 case 1:
 117                         if (!(hw.ilines & IF_VBLANK))
 118                         {
 119                                 C += 218;
 120                                 hw_interrupt(IF_VBLANK, IF_VBLANK);
 121                                 break;
 122                         }
 123                         if (R_LY == 0)
 124                         {
 125                                 lcd_begin();
 126                                 stat_change(2);
 127                                 C += 40;
 128                                 break;
 129                         }
 130                         else if (R_LY < 152)
 131                                 C += 228;
 132                         else if (R_LY == 152)
 133                                 C += 28;
 134                         else
 135                         {
 136                                 R_LY = -1;
 137                                 C += 200;
 138                         }
 139                         R_LY++;
 140                         stat_trigger();
 141                         break;
 142                 case 2:
 143                         lcd_refreshline();
 144                         stat_change(3);
 145                         C += 86;
 146                         break;
 147                 case 3:
 148                         stat_change(0);
 149                         if (hw.hdma & 0x80)
 150                                 hw_hdma();
 151                         /* FIXME -- how much of the hblank does hdma use?? */
 152                         /* else */
 153                         C += 102;
 154                         break;
 155                 case 0:
 156                         if (++R_LY >= 144)
 157                         {
 158                                 if (cpu.halt)
 159                                 {
 160                                         hw_interrupt(IF_VBLANK, IF_VBLANK);
 161                                         C += 228;
 162                                 }
 163                                 else C += 10;
 164                                 stat_change(1);
 165                                 break;
 166                         }
 167                         stat_change(2);
 168                         C += 40;
 169                         break;
 170                 }
 171         }
 172 }
 173
 174
 175
 176
 177
 178
 179