Return to mfp_ser.c CVS log

Up to [HATARI the Atari ST Emulator] / hatari / tests / serial

Annotation of hatari/tests/serial/mfp_ser.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Hatari serial port test
                      3:  *
                      4:  * Partly based on the file serport.c and mfp.h from EmuTOS:
                      5:  * Copyright (C) 2013-2018 The EmuTOS development team
                      6:  *
                      7:  * This file is distributed under the GPL, version 2 or at your
                      8:  * option any later version.  See doc/license.txt for details.
                      9:  */
                     10: 
                     11: #include <tos.h>
                     12: 
                     13: typedef unsigned char UBYTE;
                     14: 
                     15: /*==== MFP memory mapping =================================================*/
                     16: typedef struct
                     17: {
                     18:        UBYTE   dum1;
                     19:        volatile UBYTE  gpip;   /* general purpose .. register */
                     20:        UBYTE   dum2;
                     21:        volatile UBYTE  aer;    /* active edge register              */
                     22:        UBYTE   dum3;
                     23:        volatile UBYTE  ddr;    /* data direction register           */
                     24:        UBYTE   dum4;
                     25:        volatile UBYTE  iera;   /* interrupt enable register A       */
                     26:        UBYTE   dum5;
                     27:        volatile UBYTE  ierb;   /* interrupt enable register B       */
                     28:        UBYTE   dum6;
                     29:        volatile UBYTE  ipra;   /* interrupt pending register A      */
                     30:        UBYTE   dum7;
                     31:        volatile UBYTE  iprb;   /* interrupt pending register B      */
                     32:        UBYTE   dum8;
                     33:        volatile UBYTE  isra;   /* interrupt in-service register A   */
                     34:        UBYTE   dum9;
                     35:        volatile UBYTE  isrb;   /* interrupt in-service register B   */
                     36:        UBYTE   dum10;
                     37:        volatile UBYTE  imra;   /* interrupt mask register A         */
                     38:        UBYTE   dum11;
                     39:        volatile UBYTE  imrb;   /* interrupt mask register B         */
                     40:        UBYTE   dum12;
                     41:        volatile UBYTE  vr;     /* vector register                   */
                     42:        UBYTE   dum13;
                     43:        volatile UBYTE  tacr;   /* timer A control register          */
                     44:        UBYTE   dum14;
                     45:        volatile UBYTE  tbcr;   /* timer B control register          */
                     46:        UBYTE   dum15;
                     47:        volatile UBYTE  tcdcr;  /* timer C + D control register      */
                     48:        UBYTE   dum16;
                     49:        volatile UBYTE  tadr;   /* timer A data register             */
                     50:        UBYTE   dum17;
                     51:        volatile UBYTE  tbdr;   /* timer B data register             */
                     52:        UBYTE   dum18;
                     53:        volatile UBYTE  tcdr;   /* timer C data register             */
                     54:        UBYTE   dum19;
                     55:        volatile UBYTE  tddr;   /* timer D data register             */
                     56:        UBYTE   dum20;
                     57:        volatile UBYTE  scr;    /* syncronous character register     */
                     58:        UBYTE   dum21;
                     59:        volatile UBYTE  ucr;    /* USART control register            */
                     60:        UBYTE   dum22;
                     61:        volatile UBYTE  rsr;    /* receiver status register          */
                     62:        UBYTE   dum23;
                     63:        volatile UBYTE  tsr;    /* transmitter status register       */
                     64:        UBYTE   dum24;
                     65:        volatile UBYTE  udr;    /* USART data register               */
                     66: } MFP;
                     67: 
                     68: #define MFP_BASE  ((MFP *)(0xfffffa00L))
                     69: 
                     70: /*
                     71:  * MFP serial port i/o routines
                     72:  */
                     73: static long costat(void)
                     74: {
                     75:        if (MFP_BASE->tsr & 0x80)
                     76:                return -1;
                     77:        else
                     78:                return 0;
                     79: }
                     80: 
                     81: static void conout(char b)
                     82: {
                     83:        /* Wait for transmit buffer to become empty */
                     84:        while(!costat())
                     85:                ;
                     86: 
                     87:        /* Output to RS232 interface */
                     88:        MFP_BASE->udr = (char)b;
                     89: }
                     90: 
                     91: int main(int argc, char *argv[])
                     92: {
                     93:        char text[] = "The quick brown fox\njumps over the lazy dog\n";
                     94:        int i;
                     95:        void *sp = (void*)Super(0);
                     96: 
                     97:        MFP_BASE->scr = 0x00;
                     98:        MFP_BASE->ucr = 0x88;
                     99:        MFP_BASE->rsr = 0x01;
                    100:        MFP_BASE->tsr = 0x01;
                    101: 
                    102:        for (i = 0; text[i] != 0; i++)
                    103:                conout(text[i]);
                    104: 
                    105:        Super(sp);
                    106: 
                    107:        return 0;
                    108: }

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