crtc.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005-2013 by Fred Klaus <development@fkweb.de>          *
 *                                                                         *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef CPC_CRTC_H
#define CPC_CRTC_H

#include "types.h"
#include "ppi.h"

namespace cpcx
{
    class Crtc final
    {

    public:
        enum Register : tUBYTE
        {                                 
            HorizontalTotal         =  0, 
            HorizontalDisplayed     =  1, 
            HorizontalSyncPosition  =  2, 
            SyncWidth               =  3, 
            VerticalTotal           =  4, 
            VerticalTotalAdjust     =  5, 
            VerticalDisplayed       =  6, 
            VerticalSyncPosition    =  7, 
            InterlaceAndSkew        =  8, 
            MaximumRasterAddress    =  9, 
            CursorStartRaster       = 10, 
            CursorEndRaster         = 11, 
            StartAddressHigh        = 12, 
            StartAddressLow         = 13, 
            CursorHigh              = 14, 
            CursorLow               = 15, 
            LightPenHigh            = 16, 
            LightPenLow             = 17  
        };

        enum Flags : tUWORD
        {
            VS     = 1,   
            HS     = 2,   
            HDT    = 4,   
            VDT    = 8,   
            HT     = 16,  
            VT     = 32,  
            MR     = 64,  
            VTadj  = 128, 
            VSf    = 256  
        };

        Crtc() : mPpi(0), mSelected(0) {init();}
        ~Crtc() ROLAND_DEFAULT

        void init(Ppi* ppi = nullptr);

        tUBYTE selected() const {return mSelected;}

        tUBYTE read()                    const {return mRegister[mSelected];}
        tUBYTE read (tUBYTE num)         const {return (num < 18) ? mRegister[num] : 0;}
        void  select(tUBYTE reg)               {if (reg < 18) mSelected = reg;}
        void  write (tUBYTE reg, tUBYTE value) {mRegister[reg] = value;}
        void  write (tUBYTE value);

        uint  flags()           {return mFlags;}
        tUBYTE hsw()            {return mHsw;}
        tBYTE  hswVdu()         {return mHswVdu;}
        tUBYTE hswActive()      {return mHswActive;}
        tUBYTE hswCount()       {return mHswCount;}
        tUBYTE vsw()            {return mVsw;}
        tUBYTE vswCount()       {return mVswCount;}
        tUBYTE lastHDisp()      {return mLastHDisp;}
        tUBYTE skew()           {return mSkew;}
        tUBYTE vtAdjust()       {return mVtAdjust;}
        tUBYTE vtAdjustCount()  {return mVtAdjustCount;}
        tUBYTE maxRaster()      {return mMaxRaster;}
        tUBYTE rasterCount()    {return mRasterCount;}
        tUBYTE lineCount()      {return mLineCount;}
        tUBYTE charCount()      {return mCharCount;}
        uint requestedAddr()   {return mRequestedAddr;}
        uint addr()            {return mAddr;}



        void setFlags         (uint flags)  {mFlags = flags;}
        void addFlags         (uint flags)  {mFlags |= flags;}
        void removeFlags      (uint flags)  {mFlags &= ~flags;}
        //void setHsw(tUBYTE val) {write(read(SyncWidth) | (val & 0x0f));}
        //void setVsw(tUBYTE val) {write(read(SyncWidth) | (val >> 4));}
        void setHswVdu        (tUBYTE value) {mHswVdu        = value;}
        void setHswActive     (tUBYTE value) {mHswActive     = value;}
        void setHswCount      (tUBYTE value) {mHswCount      = value;}
        void setAddr          (uint value)  {mAddr          = value;}
        void setVtAdjust      (tUBYTE value) {mVtAdjust      = value;}
        void setVtAdjustCount (tUBYTE value) {mVtAdjustCount = value;}
        void setVswCount      (tUBYTE value) {mVswCount      = value;}
        void setLastHDisp     (tUBYTE value) {mLastHDisp     = value;}
        void setCharCount     (tUBYTE value) {mCharCount     = value;}
        void setLineCount     (tUBYTE value) {mLineCount     = value;}
        void setRasterCount   (tUBYTE value) {mRasterCount   = value;}
        void setSkew          (tUBYTE value) {mSkew          = value;}

        void incVswCount()  {mVswCount++;}
        //void decVswCount()  {--mVswCount;}
        //void incLineCount() {mLineCount++;}

    private:
        Ppi*  mPpi;

        tUBYTE mRegister[18];
        tUBYTE mSelected;

        uint  mFlags;
        tUBYTE mHsw;
        tBYTE  mHswVdu; // formerly known as Vdu::mHsw
        tUBYTE mHswCount;
        tUBYTE mHswActive;
        tUBYTE mVsw;
        tUBYTE mVswCount;
        tUBYTE mLastHDisp;
        tUBYTE mSkew;
        tUBYTE mVtAdjust;
        tUBYTE mVtAdjustCount;
        tUBYTE mMaxRaster;
        tUBYTE mRasterCount;
        tUBYTE mLineCount;
        tUBYTE mCharCount;
        uint  mRequestedAddr;
        uint  mAddr;

    };

} // cpc

#endif // CPC_CRTC_H