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         // Bit 2 must be 0
  49         #define DPS    0x01
  50 SFR(B, 0xF0); // B register
  51         SBIT(B7, 0xF0, 7);
  52         SBIT(B6, 0xF0, 6);
  53         SBIT(B5, 0xF0, 5);
  54         SBIT(B4, 0xF0, 4);
  55         SBIT(B3, 0xF0, 3);
  56         SBIT(B2, 0xF0, 2);
  57         SBIT(B1, 0xF0, 1);
  58         SBIT(B0, 0xF0, 0);
  59 SFR(CCAP0H, 0xFA); // Module 0 Capture High
  60 SFR(CCAP1H, 0xFB); // Module 1 Capture High
  61 SFR(CCAP2H, 0xFC); // Module 2 Capture High
  62 SFR(CCAP3H, 0xFD); // Module 3 Capture High
  63 SFR(CCAP4H, 0xFE); // Module 4 Capture High
  64 SFR(CCAP0L, 0xEA); // Module 0 Capture Low
  65 SFR(CCAP1L, 0xEB); // Module 1 Capture Low
  66 SFR(CCAP2L, 0xEC); // Module 2 Capture Low
  67 SFR(CCAP3L, 0xED); // Module 3 Capture Low
  68 SFR(CCAP4L, 0xEE); // Module 4 Capture Low
  69 SFR(CCAPM0, 0xC2); // Module 0 Mode
  70 SFR(CCAPM1, 0xC3); // Module 1 Mode
  71 SFR(CCAPM2, 0xC4); // Module 2 Mode
  72 SFR(CCAPM3, 0xC5); // Module 3 Mode
  73 SFR(CCAPM4, 0xC6); // Module 4 Mode
  74         #define ECOM   0x40
  75         #define CAPP   0x20
  76         #define CAPN   0x10
  77         #define MAT    0x08
  78         #define TOG    0x04
  79         #define PWM    0x02
  80         #define ECCF   0x01
  81 SFR(CCON,   0xC0); // PCA Counter Control
  82         SBIT(CF,   0xC0, 7);
  83         SBIT(CR,   0xC0, 6);
  84         SBIT(CCF4, 0xC0, 4);
  85         SBIT(CCF3, 0xC0, 3);
  86         SBIT(CCF2, 0xC0, 2);
  87         SBIT(CCF1, 0xC0, 1);
  88         SBIT(CCF0, 0xC0, 0);
  89 SFR(CH,   0xF9); // PCA Counter High
  90 SFR(CL,   0xE9); // PCA Counter Low
  91 SFR(CMOD, 0xC1); // PCA Counter Mode
  92         #define CIDL 0x80
  93         #define WDTE 0x40
  94         #define CPS1 0x04
  95         #define CPS0 0x02
  96         #define ECF  0x01
  97 SFR(DPH,  0x83); // Data Pointer High
  98 SFR(DPL,  0x82); // Data Pointer Low
  99 SFR(IEN0, 0xA8); // Interrupt Enable 0
 100         SBIT(EA,  0xA8, 7);
 101         SBIT(EC,  0xA8, 6);
 102         SBIT(ES1, 0xA8, 5);
 103         SBIT(ES0, 0xA8, 4);
 104         SBIT(ET1, 0xA8, 3);
 105         SBIT(EX1, 0xA8, 2);
 106         SBIT(ET0, 0xA8, 1);
 107         SBIT(EX0, 0xA8, 0);
 108 SFR(IEN1, 0xE8); // Interrupt Enable 1
 109         SBIT(ET2, 0xE8, 0);
 110 SFR(IP, 0xB8); // Interrupt Priority
 111         SBIT(PT2, 0xB8, 7);
 112         SBIT(PPC, 0xB8, 6);
 113         SBIT(PS1, 0xB8, 5);
 114         SBIT(PS0, 0xB8, 4);
 115         SBIT(PT1, 0xB8, 3);
 116         SBIT(PX1, 0xB8, 2);
 117         SBIT(PT0, 0xB8, 1);
 118         SBIT(PX0, 0xB8, 0);
 119 SFR(IPH, 0xB7); // Interrupt Priority High
 120         #define PT2H  0x80
 121         #define PPCH  0x40
 122         #define PS1H  0x20
 123         #define PS0H  0x10
 124         #define PT1H  0x08
 125         #define PX1H  0x04
 126         #define PT0H  0x02
 127         #define PX0H  0x01
 128 SFR(P0, 0x80); // Port 0
 129         SBIT(AD7,  0x80, 7);
 130         SBIT(P0_7, 0x80, 7);
 131         SBIT(AD6,  0x80, 6);
 132         SBIT(P0_6, 0x80, 6);
 133         SBIT(AD5,  0x80, 5);
 134         SBIT(P0_5, 0x80, 5);
 135         SBIT(AD4,  0x80, 4);
 136         SBIT(P0_4, 0x80, 4);
 137         SBIT(AD3,  0x80, 3);
 138         SBIT(P0_3, 0x80, 3);
 139         SBIT(AD2,  0x80, 2);
 140         SBIT(P0_2, 0x80, 2);
 141         SBIT(AD1,  0x80, 1);
 142         SBIT(P0_1, 0x80, 1);
 143         SBIT(AD0,  0x80, 0);
 144         SBIT(P0_0, 0x80, 0);
 145 SFR(P1, 0x90); // Port 1
 146         SBIT(T1_CEX4, 0x90, 7);
 147         SBIT(P1_7,    0x90, 7);
 148         SBIT(T0_CEX3, 0x90, 6);
 149         SBIT(P1_6,    0x90, 6);
 150         SBIT(CEX2,    0x90, 5);
 151         SBIT(P1_5,    0x90, 5);
 152         SBIT(CEX1,    0x90, 4);
 153         SBIT(P1_4,    0x90, 4);
 154         SBIT(CEX0,    0x90, 3);
 155         SBIT(P1_3,    0x90, 3);
 156         SBIT(ECI,     0x90, 2);
 157         SBIT(P1_2,    0x90, 2);
 158         SBIT(T2EX,    0x90, 1);
 159         SBIT(P1_1,    0x90, 1);
 160         SBIT(T2,      0x90, 0);
 161         SBIT(P1_0,    0x90, 0);
 162 SFR(P2, 0xA0); // Port 2
 163         SBIT(AD15, 0xA0, 7);
 164         SBIT(P2_7, 0xA0, 7);
 165         SBIT(AD14, 0xA0, 6);
 166         SBIT(P2_6, 0xA0, 6);
 167         SBIT(AD13, 0xA0, 5);
 168         SBIT(P2_5, 0xA0, 5);
 169         SBIT(AD12, 0xA0, 4);
 170         SBIT(P2_4, 0xA0, 4);
 171         SBIT(AD11, 0xA0, 3);
 172         SBIT(P2_3, 0xA0, 3);
 173         SBIT(AD10, 0xA0, 2);
 174         SBIT(P2_2, 0xA0, 2);
 175         SBIT(AD9,  0xA0, 1);
 176         SBIT(P2_1, 0xA0, 1);
 177         SBIT(AD8,  0xA0, 0);
 178         SBIT(P2_0, 0xA0, 0);
 179 SFR(P3, 0xB0); // Port 3
 180         SBIT(RD,   0xB0, 7);
 181         SBIT(P3_7, 0xB0, 7);
 182         SBIT(WR,   0xB0, 6);
 183         SBIT(P3_6, 0xB0, 6);
 184         SBIT(T1,   0xB0, 5);
 185         SBIT(P3_5, 0xB0, 5);
 186         SBIT(T0,   0xB0, 4);
 187         SBIT(P3_4, 0xB0, 4);
 188         SBIT(INT1, 0xB0, 3);
 189         SBIT(P3_3, 0xB0, 3);
 190         SBIT(INT0, 0xB0, 2);
 191         SBIT(P3_2, 0xB0, 2);
 192         SBIT(TXD,  0xB0, 1);
 193         SBIT(P3_1, 0xB0, 1);
 194         SBIT(RXD,  0xB0, 0);
 195         SBIT(P3_0, 0xB0, 0);
 196 SFR(PCON, 0x87); // Power Control
 197         #define SMOD1 0x80
 198         #define SMOD0 0x40
 199         #define POF   0x10
 200         #define GF1   0x80
 201         #define GF0   0x40
 202         #define PD    0x20
 203         #define IDL   0x10
 204 SFR(PSW, 0xD0); // Program Status Word
 205         SBIT(CY,  0xD0, 7);
 206         SBIT(AC,  0xD0, 6);
 207         SBIT(F0,  0xD0, 5);
 208         SBIT(RS1, 0xD0, 4);
 209         SBIT(RS0, 0xD0, 3);
 210         SBIT(OV,  0xD0, 2);
 211         SBIT(F1,  0xD0, 1);
 212         SBIT(P,   0xD0, 0);
 213 SFR(RCAP2H, 0xCB); // Timer 2 Capture High
 214 SFR(RCAP2L, 0xCA); // Timer 2 Capture Low
 215 SFR(SADDR,  0xA9); // I2C Slave Address
 216 SFR(SADEN,  0xB9); // I2C Slave Address Mask
 217 SFR(S0BUF,  0x99); // Serial Data Buffer
 218 SFR(S0CON,  0x98); // Serial Control
 219         SBIT(SM0_FE, 0x98, 7);
 220         SBIT(SM1,    0x98, 6);
 221         SBIT(SM2,    0x98, 5);
 222         SBIT(REN,    0x98, 4);
 223         SBIT(TB8,    0x98, 3);
 224         SBIT(RB8,    0x98, 2);
 225         SBIT(TI,     0x98, 1);
 226         SBIT(RI,     0x98, 0);
 227 SFR(SP,    0x81); // Stack Pointer
 228 SFR(S1DAT, 0xDA); // I2C Serial 1 Data
 229 SFR(S1IST, 0xDC); // I2C Serial 1 Internal Status
 230 SFR(S1ADR, 0xDB); // I2C Serial 1 Address
 231         #define GC  0x01
 232 SFR(S1STA, 0xD9); // I2C Serial 1 Status
 233         #define SC4 0x80
 234         #define SC3 0x40
 235         #define SC2 0x20
 236         #define SC1 0x10
 237         #define SC0 0x08
 238 SFR(S1CON, 0xD8); // I2C Serial 1 Control
 239         SBIT(CR2,  0xD8, 7);
 240         SBIT(ENS1, 0xD8, 6);
 241         SBIT(STA,  0xD8, 5);
 242         SBIT(STO,  0xD8, 4);
 243         SBIT(SI,   0xD8, 3);
 244         SBIT(AA,   0xD8, 2);
 245         SBIT(CR1,  0xD8, 1);
 246         SBIT(CR0,  0xD8, 0);
 247 SFR(TCON, 0x88); // Timer Control
 248         SBIT(TF1, 0x88, 7);
 249         SBIT(TR1, 0x88, 6);
 250         SBIT(TF0, 0x88, 5);
 251         SBIT(TR0, 0x88, 4);
 252         SBIT(IE1, 0x88, 3);
 253         SBIT(IT1, 0x88, 2);
 254         SBIT(IE0, 0x88, 1);
 255         SBIT(IT0, 0x88, 0);
 256 SFR(T2CON, 0xC8); // Timer 2 Control
 257         SBIT(TF2,    0xC8, 7);
 258         SBIT(EXF2,   0xC8, 6);
 259         SBIT(RCLK,   0xC8, 5);
 260         SBIT(TCLK,   0xC8, 4);
 261         SBIT(EXEN2,  0xC8, 3);
 262         SBIT(TR2,    0xC8, 2);
 263         SBIT(C_T2,   0xC8, 1);
 264         SBIT(CP_RL2, 0xC8, 0);
 265 SFR(T2MOD,  0xC9); // Timer 2 Mode Control
 266         #define T2OE 0x02
 267         #define DCEN 0x01
 268 SFR(TH0 ,   0x8C); // Timer High 0
 269 SFR(TH1,    0x8D); // Timer High 1
 270 SFR(TH2,    0xCD); // Timer High 2
 271 SFR(TL0,    0x8A); // Timer Low 0
 272 SFR(TL1,    0x8B); // Timer Low 1
 273 SFR(TL2,    0xCC); // Timer Low 2
 274 SFR(TMOD,   0x89); // Timer Mode
 275         #define GATE_1 0x80
 276         #define C_T_1  0x40
 277         #define M1_1   0x20
 278         #define M0_1   0x10
 279         #define GATE_0 0x08
 280         #define C_T_0  0x04
 281         #define M1_0   0x02
 282         #define M0_0   0x01
 283 SFR(WDTRST, 0xA6); // Watchdog Timer Reset
 284
 285 #endif