git.gag.com Git - fw/sdcc/blob - device/include/mcs51/p89c66x.h

   1 /*--------------------------------------------------------------------------
   2 P89c66x.H
   3
   4 This header allows to use the microcontroler Philips P89c66x
   5 with the compiler SDCC.
   6
   7 Copyright (c) 2007 Gudjon I. Gudjonsson <gudjon AT gudjon.org>
   8
   9  This library is free software; you can redistribute it and/or
  10  modify it under the terms of the GNU Lesser General Public
  11  License as published by the Free Software Foundation; either
  12  version 2.1 of the License, or (at your option) any later version.
  13
  14  This library is distributed in the hope that it will be useful,
  15  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the GNU
  17  Lesser General Public License for more details.
  18
  19  You should have received a copy of the GNU Lesser General Public
  20  License along with this library; if not, write to the Free Software
  21  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA02111-1307 USA
  22
  23  The registered are ordered in the same way as in the NXP data sheet
  24  P89C660_662_664_3.PDF, see http://www.nxp.com
  25
  26 --------------------------------------------------------------------------*/
  27
  28 #ifndef __P89c66x_H__
  29 #define __P89c66x_H__
  30 #include <compiler.h>
  31
  32 /*BYTE Registers*/
  33 SFR(ACC, 0xE0); // Accumulator
  34         SBIT(ACC_7, 0xE0, 7);
  35         SBIT(ACC_6, 0xE0, 6);
  36         SBIT(ACC_5, 0xE0, 5);
  37         SBIT(ACC_4, 0xE0, 4);
  38         SBIT(ACC_3, 0xE0, 3);
  39         SBIT(ACC_2, 0xE0, 2);
  40         SBIT(ACC_1, 0xE0, 1);
  41         SBIT(ACC_0, 0xE0, 0);
  42 SFR(AUXR, 0x8E); // Auxiliary
  43         #define EXTRAM 0x02
  44         #define AO     0x01
  45 SFR(AUXR1, 0xA2); // Auxiliary 1
  46         #define ENBOOT 0x20
  47         #define GF2    0x08
  48         #define DPS    0x01
  49 SFR(B, 0xF0); // B register
  50         SBIT(B7, 0xF0, 7);
  51         SBIT(B6, 0xF0, 6);
  52         SBIT(B5, 0xF0, 5);
  53         SBIT(B4, 0xF0, 4);
  54         SBIT(B3, 0xF0, 3);
  55         SBIT(B2, 0xF0, 2);
  56         SBIT(B1, 0xF0, 1);
  57         SBIT(B0, 0xF0, 0);
  58 SFR(CCAP0H, 0xFA); // Module 0 Capture High
  59 SFR(CCAP1H, 0xFB); // Module 1 Capture High
  60 SFR(CCAP2H, 0xFC); // Module 2 Capture High
  61 SFR(CCAP3H, 0xFD); // Module 3 Capture High
  62 SFR(CCAP4H, 0xFE); // Module 4 Capture High
  63 SFR(CCAP0L, 0xEA); // Module 0 Capture Low
  64 SFR(CCAP1L, 0xEB); // Module 1 Capture Low
  65 SFR(CCAP2L, 0xEC); // Module 2 Capture Low
  66 SFR(CCAP3L, 0xED); // Module 3 Capture Low
  67 SFR(CCAP4L, 0xEE); // Module 4 Capture Low
  68 SFR(CCAPM0, 0xC2); // Module 0 Mode
  69 SFR(CCAPM1, 0xC3); // Module 1 Mode
  70 SFR(CCAPM2, 0xC4); // Module 2 Mode
  71 SFR(CCAPM3, 0xC5); // Module 3 Mode
  72 SFR(CCAPM4, 0xC6); // Module 4 Mode
  73         #define ECOM   0x40
  74         #define CAPP   0x20
  75         #define CAPN   0x10
  76         #define MAT    0x08
  77         #define TOG    0x04
  78         #define PWM    0x02
  79         #define ECCF   0x01
  80 SFR(CCON,   0xC0); // PCA Counter Control
  81         SBIT(CF,   0xC0, 7);
  82         SBIT(CR,   0xC0, 6);
  83         SBIT(CCF4, 0xC0, 4);
  84         SBIT(CCF3, 0xC0, 3);
  85         SBIT(CCF2, 0xC0, 2);
  86         SBIT(CCF1, 0xC0, 1);
  87         SBIT(CCF0, 0xC0, 0);
  88 SFR(CH,   0xF9); // PCA Counter High
  89 SFR(CL,   0xE9); // PCA Counter Low
  90 SFR(CMOD, 0xC1); // PCA Counter Mode
  91         #define CIDL 0x80
  92         #define WDTE 0x40
  93         #define CPS1 0x04
  94         #define CPS0 0x02
  95         #define ECF  0x01
  96 SFR(DPH,  0x83); // Data Pointer High
  97 SFR(DPL,  0x82); // Data Pointer Low
  98 SFR(IEN0, 0xA8); // Interrupt Enable 0
  99         SBIT(EA,  0xA8, 7);
 100         SBIT(EC,  0xA8, 6);
 101         SBIT(ES1, 0xA8, 5);
 102         SBIT(ES0, 0xA8, 4);
 103         SBIT(ET1, 0xA8, 3);
 104         SBIT(EX1, 0xA8, 2);
 105         SBIT(ET0, 0xA8, 1);
 106         SBIT(EX0, 0xA8, 0);
 107 SFR(IEN1, 0xE8); // Interrupt Enable 1
 108         SBIT(ET2, 0xE8, 0);
 109 SFR(IP, 0xB8); // Interrupt Priority
 110         SBIT(PT2, 0xB8, 7);
 111         SBIT(PPC, 0xB8, 6);
 112         SBIT(PS1, 0xB8, 5);
 113         SBIT(PS0, 0xB8, 4);
 114         SBIT(PT1, 0xB8, 3);
 115         SBIT(PX1, 0xB8, 2);
 116         SBIT(PT0, 0xB8, 1);
 117         SBIT(PX0, 0xB8, 0);
 118 SFR(IPH, 0xB7); // Interrupt Priority High
 119         #define PT2H  0x80
 120         #define PPCH  0x40
 121         #define PS1H  0x20
 122         #define PS0H  0x10
 123         #define PT1H  0x80
 124         #define PX1H  0x40
 125         #define PT0H  0x20
 126         #define PX0H  0x10
 127 SFR(P0, 0x80); // Port 0
 128         SBIT(AD7,  0x80, 7);
 129         SBIT(P0_7, 0x80, 7);
 130         SBIT(AD6,  0x80, 6);
 131         SBIT(P0_6, 0x80, 6);
 132         SBIT(AD5,  0x80, 5);
 133         SBIT(P0_5, 0x80, 5);
 134         SBIT(AD4,  0x80, 4);
 135         SBIT(P0_4, 0x80, 4);
 136         SBIT(AD3,  0x80, 3);
 137         SBIT(P0_3, 0x80, 3);
 138         SBIT(AD2,  0x80, 2);
 139         SBIT(P0_2, 0x80, 2);
 140         SBIT(AD1,  0x80, 1);
 141         SBIT(P0_1, 0x80, 1);
 142         SBIT(AD0,  0x80, 0);
 143         SBIT(P0_0, 0x80, 0);
 144 SFR(P1, 0x90); // Port 1
 145         SBIT(T1_CEX4, 0x90, 7);
 146         SBIT(P1_7,    0x90, 7);
 147         SBIT(T0_CEX3, 0x90, 6);
 148         SBIT(P1_6,    0x90, 6);
 149         SBIT(CEX2,    0x90, 5);
 150         SBIT(P1_5,    0x90, 5);
 151         SBIT(CEX1,    0x90, 4);
 152         SBIT(P1_4,    0x90, 4);
 153         SBIT(CEX0,    0x90, 3);
 154         SBIT(P1_3,    0x90, 3);
 155         SBIT(ECI,     0x90, 2);
 156         SBIT(P1_2,    0x90, 2);
 157         SBIT(T2EX,    0x90, 1);
 158         SBIT(P1_1,    0x90, 1);
 159         SBIT(T2,      0x90, 0);
 160         SBIT(P1_0,    0x90, 0);
 161 SFR(P2, 0xA0); // Port 2
 162         SBIT(AD15, 0xA0, 7);
 163         SBIT(P2_7, 0xA0, 7);
 164         SBIT(AD14, 0xA0, 6);
 165         SBIT(P2_6, 0xA0, 6);
 166         SBIT(AD13, 0xA0, 5);
 167         SBIT(P2_5, 0xA0, 5);
 168         SBIT(AD12, 0xA0, 4);
 169         SBIT(P2_4, 0xA0, 4);
 170         SBIT(AD11, 0xA0, 3);
 171         SBIT(P2_3, 0xA0, 3);
 172         SBIT(AD10, 0xA0, 2);
 173         SBIT(P2_2, 0xA0, 2);
 174         SBIT(AD9,  0xA0, 1);
 175         SBIT(P2_1, 0xA0, 1);
 176         SBIT(AD8,  0xA0, 0);
 177         SBIT(P2_0, 0xA0, 0);
 178 SFR(P3, 0xB0); // Port 3
 179         SBIT(RD,   0xB0, 7);
 180         SBIT(P3_7, 0xB0, 7);
 181         SBIT(WR,   0xB0, 6);
 182         SBIT(P3_6, 0xB0, 6);
 183         SBIT(T1,   0xB0, 5);
 184         SBIT(P3_5, 0xB0, 5);
 185         SBIT(T0,   0xB0, 4);
 186         SBIT(P3_4, 0xB0, 4);
 187         SBIT(INT1, 0xB0, 3);
 188         SBIT(P3_3, 0xB0, 3);
 189         SBIT(INT0, 0xB0, 2);
 190         SBIT(P3_2, 0xB0, 2);
 191         SBIT(TXD,  0xB0, 1);
 192         SBIT(P3_1, 0xB0, 1);
 193         SBIT(RXD,  0xB0, 0);
 194         SBIT(P3_0, 0xB0, 0);
 195 SFR(PCON, 0x87); // Power Control
 196         #define SMOD1 0x80
 197         #define SMOD0 0x40
 198         #define POF   0x10
 199         #define GF1   0x80
 200         #define GF0   0x40
 201         #define PD    0x20
 202         #define IDL   0x10
 203 SFR(PSW, 0xD0); // Program Status Word
 204         SBIT(CY,  0xD0, 7);
 205         SBIT(AC,  0xD0, 6);
 206         SBIT(F0,  0xD0, 5);
 207         SBIT(RS1, 0xD0, 4);
 208         SBIT(RS0, 0xD0, 3);
 209         SBIT(OV,  0xD0, 2);
 210         SBIT(F1,  0xD0, 1);
 211         SBIT(P,   0xD0, 0);
 212 SFR(RCAP2H, 0xCB); // Timer 2 Capture High
 213 SFR(RCAP2L, 0xCA); // Timer 2 Capture Low
 214 SFR(SADDR,  0xA9); // I2C Slave Address
 215 SFR(SADEN,  0xB9); // I2C Slave Address Mask
 216 SFR(S0BUF,  0x99); // Serial Data Buffer
 217 SFR(S0CON,  0x98); // Serial Control
 218         SBIT(SM0_FE, 0x98, 7);
 219         SBIT(SM1,    0x98, 6);
 220         SBIT(SM2,    0x98, 5);
 221         SBIT(REN,    0x98, 4);
 222         SBIT(TB8,    0x98, 3);
 223         SBIT(RB8,    0x98, 2);
 224         SBIT(TI,     0x98, 1);
 225         SBIT(RI,     0x98, 0);
 226 SFR(SP,    0x81); // Stack Pointer
 227 SFR(S1DAT, 0xDA); // I2C Serial 1 Data
 228 SFR(S1IST, 0xDC); // I2C Serial 1 Internal Status
 229 SFR(S1ADR, 0xDB); // I2C Serial 1 Address
 230 SFR(S1STA, 0xD9); // I2C Serial 1 Status
 231         #define SC4 0x80
 232         #define SC3 0x40
 233         #define SC2 0x20
 234         #define SC1 0x10
 235         #define SC0 0x08
 236 SFR(S1CON, 0xD8); // I2C Serial 1 Control
 237         SBIT(CR2,  0xD8, 7);
 238         SBIT(ENS1, 0xD8, 6);
 239         SBIT(STA,  0xD8, 5);
 240         SBIT(STO,  0xD8, 4);
 241         SBIT(SI,   0xD8, 3);
 242         SBIT(AA,   0xD8, 2);
 243         SBIT(CR01, 0xD8, 2);
 244         SBIT(CR0,  0xD8, 0);
 245 SFR(TCON, 0x88); // Timer Control
 246         SBIT(TF1, 0x88, 7);
 247         SBIT(TR1, 0x88, 6);
 248         SBIT(TF0, 0x88, 5);
 249         SBIT(TR0, 0x88, 4);
 250         SBIT(IE1, 0x88, 3);
 251         SBIT(IT1, 0x88, 2);
 252         SBIT(IE0, 0x88, 1);
 253         SBIT(IT0, 0x88, 0);
 254 SFR(T2CON, 0xC8); // Timer 2 Control
 255         SBIT(TF2,    0xC8, 7);
 256         SBIT(EXF2,   0xC8, 6);
 257         SBIT(RCLK,   0xC8, 5);
 258         SBIT(TCLK,   0xC8, 4);
 259         SBIT(EXEN2,  0xC8, 3);
 260         SBIT(TR2,    0xC8, 2);
 261         SBIT(C_T2,   0xC8, 1);
 262         SBIT(CP_RL2, 0xC8, 0);
 263 SFR(T2MOD,  0xC9); // Timer 2 Mode Control
 264         #define T2OE 0x02
 265         #define DCEN 0x01
 266 SFR(TH0 ,   0x8C); // Timer High 0
 267 SFR(TH1,    0x8D); // Timer High 1
 268 SFR(TH2,    0xCD); // Timer High 2
 269 SFR(TL0,    0x8A); // Timer Low 0
 270 SFR(TL1,    0x8B); // Timer Low 1
 271 SFR(TL2,    0xCC); // Timer Low 2
 272 SFR(TMOD ,  0x89); // Timer Mode
 273         #define GATE_1 0x80
 274         #define C_T_1  0x40
 275         #define M1_1   0x20
 276         #define M0_1   0x10
 277         #define GATE_0 0x08
 278         #define C_T_0  0x04
 279         #define M1_0   0x02
 280         #define M0_0   0x01
 281 SFR(WDTRST, 0xA6); // Watchdog Timer Reset
 282
 283 #endif