Return to adpcm.cpp CVS log

Up to [Isaki's NoNo m68k/m88k emulator] / nono / vm

Annotation of nono/vm/adpcm.cpp, revision 1.1.1.1

1.1       root        1: //
                      2: // nono
                      3: // Copyright (C) 2022 nono project
                      4: // Licensed under nono-license.txt
                      5: //
                      6: 
                      7: //
                      8: // ADPCM (MSM6258V)
                      9: //
                     10: 
                     11: #include "adpcm.h"
                     12: #include "dmac.h"
                     13: #include "mpu.h"
                     14: #include "pio.h"
                     15: #include "scheduler.h"
                     16: 
                     17: // グローバル参照用
                     18: ADPCMDevice *gADPCM;
                     19: 
                     20: // コンストラクタ
                     21: ADPCMDevice::ADPCMDevice()
                     22:        : inherited("ADPCM")
                     23: {
                     24:        devaddr = baseaddr;
                     25:        devlen  = 0x2000;
                     26: 
                     27:        event.func = ToEventCallback(&ADPCMDevice::EventCallback);
                     28:        event.Regist("ADPCM");
                     29: }
                     30: 
                     31: // デストラクタ
                     32: ADPCMDevice::~ADPCMDevice()
                     33: {
                     34:        gADPCM = NULL;
                     35: }
                     36: 
                     37: // リセット
                     38: void
                     39: ADPCMDevice::ResetHard(bool poweron)
                     40: {
                     41:        playing = false;
                     42:        dack = false;
                     43: 
                     44:        // ?
                     45:        clk = 8000'000;
                     46:        div = 512;
                     47: }
                     48: 
                     49: uint64
                     50: ADPCMDevice::Read(uint32 offset)
                     51: {
                     52:        uint8 data;
                     53: 
                     54:        gMPU->AddCycle(18);     // InsideOut p.135
                     55: 
                     56:        switch (offset) {
                     57:         case 0:        // STAT
                     58:                data = 0x40;
                     59:                if (playing) {
                     60:                        data |= STAT_PLAY;
                     61:                }
                     62:                putlog(1, "STAT -> $%02x", data);
                     63:                break;
                     64:         case 1:        // DATA
                     65:                putlog(0, "Read $%06x (NOT IMPLEMENTED)", gMPU->GetPaddr());
                     66:                data = 0xff;
                     67:                break;
                     68:         default:
                     69:                __unreachable();
                     70:        }
                     71: 
                     72:        return data;
                     73: }
                     74: 
                     75: uint64
                     76: ADPCMDevice::Write(uint32 offset, uint32 data)
                     77: {
                     78:        gMPU->AddCycle(22);     // InsideOut p.135
                     79: 
                     80:        switch (offset) {
                     81:         case 0:        // CMD
                     82:                putlog(1, "CMD  <- $%02x", data);
                     83:                if ((data & REC_START)) {
                     84:                        putlog(0, "Start recording (NOT IMPLEMENTED)");
                     85:                }
                     86:                if ((data & PLAY_START)) {
                     87:                        putlog(0, "Start playing (NOT IMPLEMENTED)");
                     88:                        StartPlay();
                     89:                }
                     90:                if ((data & STOP)) {
                     91:                        putlog(0, "Stop (NOT IMPLEMENTED)");
                     92:                        playing = false;
                     93:                }
                     94:                break;
                     95:         case 1:        // DATA
                     96:                // 未実装だけど再生中の書き込みは来るのは分かっているので抑えておく
                     97:                if ((playing && loglevel >= 2) || playing == false) {
                     98:                        putlogn("DATA <- $%02x (NOT IMPLEMENTED)", data);
                     99:                }
                    100:                break;
                    101:         default:
                    102:                __unreachable();
                    103:        }
                    104: 
                    105:        return 0;
                    106: }
                    107: 
                    108: uint64
                    109: ADPCMDevice::Peek(uint32 offset)
                    110: {
                    111:        // XXX 未実装
                    112:        return 0xff;
                    113: }
                    114: 
                    115: // 再生開始
                    116: void
                    117: ADPCMDevice::StartPlay()
                    118: {
                    119:        // PPI で設定されているサンプリングレートをここで読み出す。
                    120:        // XXX パンは未対応
                    121:        switch (gPPI->GetADPCMRate()) {
                    122:         case 0:
                    123:                div = 1024;
                    124:                break;
                    125:         case 1:
                    126:         case 3:                // %11 は %01 と同じになる (Inside p295)
                    127:                div = 768;
                    128:                break;
                    129:         case 2:
                    130:                div = 512;
                    131:                break;
                    132:         default:
                    133:                __unreachable();
                    134:        }
                    135: 
                    136:        playing = true;
                    137:        gDMAC->AssertREQ(3);
                    138: 
                    139:        event.time = div / clk;
                    140:        gScheduler->StartEvent(event);
                    141: }
                    142: 
                    143: // イベント
                    144: void
                    145: ADPCMDevice::EventCallback(Event& ev)
                    146: {
                    147:        // XXX 適当
                    148:        if (playing) {
                    149:                gDMAC->AssertREQ(3);
                    150:        }
                    151: }
                    152: 
                    153: // DACK 信号をアサートする (DMAC から呼ばれる)
                    154: void
                    155: ADPCMDevice::AssertDACK(bool tc_)
                    156: {
                    157:        dack = true;
                    158:        // DRQ を下げる
                    159:        gDMAC->NegateREQ(0);
                    160: }
                    161: 
                    162: // DACK 信号をネゲートする (DMAC から呼ばれる)
                    163: void
                    164: ADPCMDevice::NegateDACK()
                    165: {
                    166:        dack = false;
                    167: }
                    168: 
                    169: // クロック切り替え。OPM から呼ばれる。
                    170: // CT1 = %0 で 8MHz、%1 で 4MHz。
                    171: void
                    172: ADPCMDevice::SetClock(bool ct1)
                    173: {
                    174:        if (ct1) {
                    175:                clk = 4000'000;
                    176:        } else {
                    177:                clk = 8000'000;
                    178:        }
                    179: }

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