Return to psg.c CVS log

Up to [HATARI the Atari ST Emulator] / hatari / src

Annotation of hatari/src/psg.c, revision 1.1.1.2

1.1       root        1: /*
                      2:   Hatari
                      3: 
                      4:   Programmable Sound Generator (YM-2149) - PSG
                      5: */
                      6: 
                      7: #include "main.h"
                      8: #include "memAlloc.h"
                      9: #include "memorySnapShot.h"
                     10: #include "sound.h"
                     11: 
                     12: unsigned char PSGRegisterSelect = 0;                  /* 0xff8800 (read/write) */
                     13: unsigned char PSGRegisters[16] = { 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0 };  /* Register in PSG, see PSG_REG_xxxx */
                     14: 
                     15: 
                     16: /*-----------------------------------------------------------------------*/
                     17: /*
                     18:   Reset variables used in PSG
                     19: */
                     20: void PSG_Reset(void)
                     21: {
                     22:   PSGRegisterSelect = 0;
                     23:   Memory_Clear(PSGRegisters,sizeof(unsigned char)*16);
                     24: }
                     25: 
1.1.1.2 ! root       26: 
        !            27: /*-----------------------------------------------------------------------*/
1.1       root       28: /*
                     29:   Save/Restore snapshot of local variables('MemorySnapShot_Store' handles type)
                     30: */
                     31: void PSG_MemorySnapShot_Capture(BOOL bSave)
                     32: {
1.1.1.2 ! root       33:   /* Save/Restore details */
1.1       root       34:   MemorySnapShot_Store(&PSGRegisterSelect,sizeof(PSGRegisterSelect));
                     35:   MemorySnapShot_Store(PSGRegisters,sizeof(PSGRegisters));
                     36: }
                     37: 
1.1.1.2 ! root       38: 
        !            39: /*-----------------------------------------------------------------------*/
1.1       root       40: /*
                     41:   Write byte to 0xff88000, this is used as a selector for when we read/write to address 0xff8802
                     42: */
                     43: void PSG_WriteSelectRegister(unsigned short v)
                     44: {
                     45:  PSGRegisterSelect = v & 0x0f;              /* Store register to select (value in bits 0-3) */
                     46: }
                     47: 
1.1.1.2 ! root       48: 
        !            49: /*-----------------------------------------------------------------------*/
1.1       root       50: /*
                     51:   Read byte from 0xff8800, returns to PSG data
                     52: */
                     53: unsigned short PSG_ReadSelectRegister(void)
                     54: {
1.1.1.2 ! root       55:  /* Read data last selected by register */
1.1       root       56:  return PSGRegisters[PSGRegisterSelect];    /* Return value from PSGRegisters[] */
                     57: }
                     58: 
1.1.1.2 ! root       59: 
        !            60: /*-----------------------------------------------------------------------*/
1.1       root       61: /*
                     62:   Write byte to 0xff8802, stores according to PSG select register(write 0xff8800)
                     63: */
                     64: void PSG_WriteDataRegister(unsigned short bl)
                     65: {
                     66:  Sound_Update();                            /* Create samples up until this point with current values */
                     67:  PSGRegisters[PSGRegisterSelect]=bl;        /* Write value to PSGRegisters[] */
                     68:  if( PSGRegisterSelect==13 )                /* Whenever 'write' to register 13, cause envelope to reset */
                     69:   {
                     70:    bEnvelopeFreqFlag = TRUE;
                     71:    bWriteEnvelopeFreq = TRUE;
                     72:   }
                     73:  /* Check registers 8,9 and 10 which are 'amplitude' for each channel and store if wrote to(to check for sample playback) */
                     74:  if( PSGRegisterSelect==8 )
                     75:    bWriteChannelAAmp=TRUE;
                     76:  else if( PSGRegisterSelect==9 )
                     77:    bWriteChannelBAmp=TRUE;
                     78:  else if( PSGRegisterSelect==10 )
                     79:    bWriteChannelCAmp=TRUE;
                     80: }
                     81: 
1.1.1.2 ! root       82: 
        !            83: /*-----------------------------------------------------------------------*/
1.1       root       84: /*
                     85:   Read byte from 0xff8802, returns 0xff
                     86: */
                     87: unsigned short PSG_ReadDataRegister(void)
                     88: {
                     89:  return 0xff;
                     90: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.