Subversion Repositories openrisc

#ifndef _AE_H_

#define _AE_H_

/*********************************************************************

        ae.h            headers for AM188ES   6-20-99   7-16-98

*********************************************************************/

/*  Data structure for Serial operation */

typedef struct  {

        unsigned char ready;          /* TRUE when ready */

        unsigned char baud;

        unsigned int mode;

        unsigned char iflag;     /* interrupt status     */

        unsigned char* in_buf;        /* Input buffer */

        unsigned int in_tail;        /* Input buffer TAIL ptr */

        unsigned int in_head;        /* Input buffer HEAD ptr */

        unsigned int in_size;        /* Input buffer size */

        unsigned int in_crcnt;       /* Input  count */

        unsigned char in_mt;          /* Input buffer FLAG */

        unsigned char in_full;        /* input buffer full */

        unsigned char* out_buf;       /* Output buffer */

        unsigned int out_tail;       /* Output buffer TAIL ptr */

        unsigned int out_head;       /* Output buffer HEAD ptr */

        unsigned int out_size;       /* Output buffer size */

        unsigned char out_full;       /* Output buffer FLAG */

        unsigned char out_mt;         /* Output buffer MT */

        unsigned char tmso;     // transmit macro service operation

        unsigned char rts;

        unsigned char dtr;

        unsigned char en485;

        unsigned char err;

        unsigned char node;

        unsigned char cr; /* scc CR register    */

        unsigned char slave;

        unsigned int in_segm;       /* input buffer segment */

        unsigned int in_offs;       /* input buffer offset */

        unsigned int out_segm;       /* output buffer segment */

        unsigned int out_offs;       /* output buffer offset */

        unsigned char byte_delay;       /* V25 macro service byte delay */

} COM;

typedef struct{

        unsigned char sec1;

        unsigned char sec10;

        unsigned char min1;

        unsigned char min10;

        unsigned char hour1;

        unsigned char hour10;

        unsigned char day1;

        unsigned char day10;

        unsigned char mon1;

        unsigned char mon10;

        unsigned char year1;

        unsigned char year10;

        unsigned char wk;

} TIM;

void ae_init(void);

void ae_reset(void);

void led(int i);      //P12 used for led

void delay_ms(int m);

void delay0(unsigned int t);

void    HLPRsetvect(

                                unsigned int    wVec,           /* Interrupt vector number */

                                void    far             *ih             /* Interrupt handler to install */

                        );

void clka_en(int i);

void clkb_en(int i);

void pwr_save_en(int i);

void hitwd(void);

//

//      reset ee to remain enabled for reads

//      where s = segment register value pointing to ee starting addr.

//              for example = 0x8000

//

void amd_ee_read_reset(unsigned int s);

//

//      sec=0x00-0x07 for AM29F010, 16K/sector

//              sec=0   0x00000-0x03fff

//              sec=1   0x04000-0x07fff

//              sec=2   0x08000-0x0bfff

//              sec=3   0x0c000-0x0ffff

//              sec=4   0x10000-0x13fff

//              sec=5   0x14000-0x17fff

//              sec=6   0x18000-0x1bfff

//              sec=7   0x1c000-0x1ffff

//

//      sec=0x10-0x17 for AM29F040

//              sec=10  0x00000-0x0ffff

//              sec=11  0x10000-0x1ffff

//              sec=12  0x20000-0x2ffff

//              sec=13  0x30000-0x3ffff

//              sec=14  0x40000-0x4ffff

//              sec=15  0x50000-0x5ffff

//              sec=16  0x60000-0x6ffff

//              sec=17  0x70000-0x7ffff

//      segm=segment register value pointing to ee address 0

// returns:             if pass, return(0);

//                              if fail, return(1);

//

int amd_ee_sec_erase(unsigned int segm, unsigned char sec );

//

//      write one byte dat to AM29F040, at address of s:o

//      Approximately 70 us for 0 wait, 80us for 1 wait.

//              where s=segment register, it is fixed to 0x8000

//                              o=offset register

// returns:             if pass, return(0);

//                              if fail, return(1);

//

// Be aware of that a data bit "0" can not be programmed back to a "1" !!!

// Attempting to do so will hang up the system !!!

// you can program the "1"s to "0"s.

// Only erase operation can convert "0"s to "1"s

//

//

int amd_ee_byte_pro_512(unsigned int s, unsigned int o, unsigned char dat);

//

//      write one byte dat to AM29F010, at address of s:o, 80us per byte approx.

//              where s=segment register, you may use s=0x8000-0xe000

//                              o=offset register

// returns:             if pass, return(0);

//                              if fail, return(1);

//

// Be aware of that a data bit "0" can not be programmed back to a "1" !!!

// Attempting to do so will hang up the system !!!

// you can program the "1"s to "0"s.

// Only erase operation can convert "0"s to "1"s

//

int amd_ee_byte_pro_128(unsigned int s, unsigned int o, unsigned char dat);

//

// unsigned char rtc_rds(char* time_string);

// put a time string into time_string, based on the reading of RTC.

//      At least 15 bytes of buffer must be available for the time_string

//      returns 0, if RTC OK, or returns 1, if problem

//

unsigned char rtc_rds(char* time_string);

int rtc_rd(TIM *r);

void rtc_init(unsigned char*);

unsigned char r_rd(void);

int r_out(unsigned char v);

void t2_init(unsigned int tm,unsigned int ta,void interrupt far(*t2_isr)());

void t1_init(unsigned int tm,unsigned int ta,unsigned int tb,void interrupt far(*t1_isr)());

void t0_init(unsigned int tm,unsigned int ta,unsigned int tb,void interrupt far(*t0_isr)());

unsigned int t2_rd(void);

unsigned int t1_rd(void);

unsigned int t0_rd(void);

//      Analog to Digital conversion using TLC2543 on the A-Engine-88/86

//      Input:

//              unsigned char c = input channel

//              c = 0,  input ch = AD0

//              c = 1,  input ch = AD1

//              c = 2,  input ch = AD2

//              c = 3,  input ch = AD3

//              c = 4,  input ch = AD4

//              c = 5,  input ch = AD5

//              c = 6,  input ch = AD6

//              c = 7,  input ch = AD7

//              c = 8,  input ch = AD8

//              c = 9,  input ch = AD9

//              c = a,  input ch = AD10

//      In order to operate ADC, P11 must be input.

//      P11 is shared by RTC, EE. It must be high while power on/reset

//      For AE88, using PPI for ADC, I20,I21,I22 must be output

//      For AE86, using PAL for ADC, T0=CLK, T1=DIN, T2=ADCS

//              Enter the ae_ad12(unsigned char c);  EE is stopped first.

//              Enter the ae86_ad12(unsigned char c);  EE is stopped first.

//

//      Output: 12 bit AD data of the previous channel !

//              Unipolar:

//              (Vref+ - Vref-)=0x7ff

//              Vref- = 0x000

//              Vref+ = 0xfff

//

//

int ae_ad12(unsigned char c);

//      outportb(0x120,1);  // T0=0, CLK

//      outportb(0x128,1);  // T1=0, DIN

//      outportb(0x130,1);  // T2=0, ADCS

int ae86_ad12(unsigned char c);

void nmi_init(void interrupt far (* nmi_isr)());

void int0_init(unsigned char i, void interrupt far (*int0_isr)());

void int1_init(unsigned char i, void interrupt far (*int1_isr)());

void int2_init(unsigned char i, void interrupt far (*int2_isr)());

void int3_init(unsigned char i, void interrupt far (*int3_isr)());

void int4_init(unsigned char i, void interrupt far (*int4_isr)());

void int5_init(unsigned char i, void interrupt far (*int5_isr)());

void int6_init(unsigned char i, void interrupt far (*int6_isr)());

//

// void pio_init(char bit, char mode)

//      where bit=0-31

//                      mode=0, Normal operation

//                      mode=1, Input with pullup/down

//                      mode=2, Output

//                      mode=3, input without pull

//

void pio_init(char bit, char mode);

//

//      void pio_wr(char bit, char dat)

//      where bit=0-31

//              dat=0/1

//

void pio_wr(char bit, char dat);

//

// unsigned int pio_rd(char port)

//      return P15-P0, if port=0

//      return P31-P16, if port=1

//

unsigned int pio_rd(char port);

// setup I/O wait states for I/O instructions

//      where wait = 0-7

//      wait=0,                 wait states = 0, I/O enable for 100 ns

//      wait=1,                 wait states = 1, I/O enable for 100+25 ns

//      wait=2,                 wait states = 2, I/O enable for 100+50 ns

//      wait=3,                 wait states = 3, I/O enable for 100+75 ns

//      wait=4,                 wait states = 5, I/O enable for 100+125 ns

//      wait=5,                 wait states = 7, I/O enable for 100+175 ns

//      wait=6,                 wait states = 9, I/O enable for 100+225 ns

//      wait=7,                 wait states = 15, I/O enable for 100+375 ns

void io_wait(char wait);

unsigned int crc16(unsigned char *wptr, unsigned int count);

/******************************************************

        void ae_da(int dat1, int dat2)

        output dat to U11 DAC of AE88

        Requires P12=CLK, P26=DI, P29=LD/CS as output pins !

        where dat1 for channel A, dat2 for channel B;   dat1/2 = 0-4095

*******************************************************/

void ae_da(int dat1, int dat2);

/******************************************************

        void ae86_da(int dat1, int dat2)

        output dat to U15 DAC of AE86

        Requires T0=CLK=0x120, T1=DI=0x128, T3=LD/CS=0x138

        where dat1 for channel A, dat2 for channel B;   dat1/2 = 0-4095

        Output 0-2.5V at VA=J4.16, VB=J4.18

*******************************************************/

void ae86_da(int dat1, int dat2);

void interrupt reset_io_trap();

#endif