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

   1 /*--------------------------------------------------------------------------
   2 p89v66x.h
   3
   4 This header allows to use the microcontroler NXP (formerly Philips) p89v66x
   5 where x stands for 0,2,4.
   6
   7 Copyright (c) 2008 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  http://www.standardics.nxp.com/products/80c51/datasheet/p89v660.p89v662.p89v664.pdf
  25
  26 --------------------------------------------------------------------------*/
  27 #ifndef __P89V66X_H__
  28 #define __P89V66X_H__
  29 #include <compiler.h>
  30
  31 /*BYTE Registers*/
  32 SFR(ACC, 0xE0); // Accumulator
  33         SBIT(ACC_7, 0xE0, 7);
  34         SBIT(ACC_6, 0xE0, 6);
  35         SBIT(ACC_5, 0xE0, 5);
  36         SBIT(ACC_4, 0xE0, 4);
  37         SBIT(ACC_3, 0xE0, 3);
  38         SBIT(ACC_2, 0xE0, 2);
  39         SBIT(ACC_1, 0xE0, 1);
  40         SBIT(ACC_0, 0xE0, 0);
  41 SFR(AUXR, 0x8E); // Auxiliary
  42         #define  EXTRAM   0x02
  43         #define  AO       0x01
  44 SFR(AUXR1, 0xA2); // Auxiliary 1
  45         #define  GF2      0x08
  46         // Bit 2 must be zero
  47         #define  DPS      0x01
  48 SFR(B, 0xF0); // B register
  49         SBIT(B7, 0xF0, 7);
  50         SBIT(B6, 0xF0, 6);
  51         SBIT(B5, 0xF0, 5);
  52         SBIT(B4, 0xF0, 4);
  53         SBIT(B3, 0xF0, 3);
  54         SBIT(B2, 0xF0, 2);
  55         SBIT(B1, 0xF0, 1);
  56         SBIT(B0, 0xF0, 0);
  57 SFR(CCAP0H, 0xFA); // Module 0 Capture High
  58 SFR(CCAP1H, 0xFB); // Module 1 Capture High
  59 SFR(CCAP2H, 0xFC); // Module 2 Capture High
  60 SFR(CCAP3H, 0xFD); // Module 3 Capture High
  61 SFR(CCAP4H, 0xFE); // Module 4 Capture High
  62 SFR(CCAP0L, 0xEA); // Module 0 Capture Low
  63 SFR(CCAP1L, 0xEB); // Module 1 Capture Low
  64 SFR(CCAP2L, 0xEC); // Module 2 Capture Low
  65 SFR(CCAP3L, 0xED); // Module 3 Capture Low
  66 SFR(CCAP4L, 0xEE); // Module 4 Capture Low
  67 SFR(CCAPM0, 0xC2); // Module 0 Mode
  68         #define ECOM_0   0x40
  69         #define CAPP_0   0x20
  70         #define CAPN_0   0x10
  71         #define  MAT_0   0x08
  72         #define  TOG_0   0x04
  73         #define  PWM_0   0x02
  74         #define ECCF_0   0x01
  75 SFR(CCAPM1, 0xC3); // Module 1 Mode
  76         #define ECOM_1   0x40
  77         #define CAPP_1   0x20
  78         #define CAPN_1   0x10
  79         #define  MAT_1   0x08
  80         #define  TOG_1   0x04
  81         #define  PWM_1   0x02
  82         #define ECCF_1   0x01
  83 SFR(CCAPM2, 0xC4); // Module 2 Mode
  84         #define ECOM_2   0x40
  85         #define CAPP_2   0x20
  86         #define CAPN_2   0x10
  87         #define  MAT_2   0x08
  88         #define  TOG_2   0x04
  89         #define  PWM_2   0x02
  90         #define ECCF_2   0x01
  91 SFR(CCAPM3, 0xC5); // Module 3 Mode
  92         #define ECOM_3   0x40
  93         #define CAPP_3   0x20
  94         #define CAPN_3   0x10
  95         #define  MAT_3   0x08
  96         #define  TOG_3   0x04
  97         #define  PWM_3   0x02
  98         #define ECCF_3   0x01
  99 SFR(CCAPM4, 0xC6); // Module 4 Mode
 100         #define ECOM_4   0x40
 101         #define CAPP_4   0x20
 102         #define CAPN_4   0x10
 103         #define  MAT_4   0x08
 104         #define  TOG_4   0x04
 105         #define  PWM_4   0x02
 106         #define ECCF_4   0x01
 107         #define ECOM     0x40
 108         #define CAPP     0x20
 109         #define CAPN     0x10
 110         #define MAT      0x08
 111         #define TOG      0x04
 112         #define PWM      0x02
 113         #define ECCF     0x01
 114 SFR(CCON,   0xC0); // PCA Counter Control
 115         SBIT(CF,   0xD8, 7);
 116         SBIT(CR,   0xD8, 6);
 117         SBIT(CCF4, 0xD8, 4);
 118         SBIT(CCF3, 0xD8, 3);
 119         SBIT(CCF2, 0xD8, 2);
 120         SBIT(CCF1, 0xD8, 1);
 121         SBIT(CCF0, 0xD8, 0);
 122 SFR(CH,   0xF9); // PCA Counter High
 123 SFR(CL,   0xE9); // PCA Counter Low
 124 SFR(CMOD, 0xC1); // PCA Counter Mode
 125         #define CIDL    0x80
 126         #define WDTE    0x40
 127         #define CPS1    0x04
 128         #define CPS0    0x02
 129         #define  ECF    0x01
 130 SFR(DPH,  0x83); // Data Pointer High
 131 SFR(DPL,  0x82); // Data Pointer Low
 132 SFR(IEN0, 0xA8); // Interrupt Enable 0
 133         SBIT(EA,  0xA8, 7);
 134         SBIT(EC,  0xA8, 6);
 135         SBIT(ES1, 0xA8, 5);
 136         SBIT(ES0, 0xA8, 4);
 137         SBIT(ET1, 0xA8, 3);
 138         SBIT(EX1, 0xA8, 2);
 139         SBIT(ET0, 0xA8, 1);
 140         SBIT(EX0, 0xA8, 0);
 141 SFR(IEN1, 0xE8); // Interrupt Enable 1
 142         SBIT(ES3, 0xE8, 2);
 143         SBIT(ES2, 0xE8, 1);
 144         SBIT(ET2, 0xE8, 0);
 145 SFR(IP0, 0xB8); // Interrupt Priority 0
 146         SBIT(PT2, 0xB8, 7);
 147         SBIT(PPC, 0xB8, 6);
 148         SBIT(PS1, 0xB8, 5);
 149         SBIT(PS0, 0xB8, 4);
 150         SBIT(PT1, 0xB8, 3);
 151         SBIT(PX1, 0xB8, 2);
 152         SBIT(PT0, 0xB8, 1);
 153         SBIT(PX0, 0xB8, 0);
 154 SFR(IP0H, 0xB7); // Interrupt Priority 0 High
 155         #define PT2H  0x80
 156         #define PPCH  0x40
 157         #define PS1H  0x20
 158         #define PS0H  0x10
 159         #define PT1H  0x08
 160         #define PX1H  0x04
 161         #define PT0H  0x02
 162         #define PX0H  0x01
 163 SFR(IP1, 0x91); // Interrupt Priority 1
 164         #define PS3  0x02
 165         #define PS2  0x01
 166 SFR(IP1H, 0x92); // Interrupt Priority 1 High
 167         #define PS3H  0x02
 168         #define PS2H  0x01
 169 SFR(P0, 0x80); // Port 0
 170         SBIT(AD7,  0x80, 7);
 171         SBIT(P0_7, 0x80, 7);
 172         SBIT(AD6,  0x80, 6);
 173         SBIT(P0_6, 0x80, 6);
 174         SBIT(AD5,  0x80, 5);
 175         SBIT(P0_5, 0x80, 5);
 176         SBIT(AD4,  0x80, 4);
 177         SBIT(P0_4, 0x80, 4);
 178         SBIT(AD3,  0x80, 3);
 179         SBIT(P0_3, 0x80, 3);
 180         SBIT(AD2,  0x80, 2);
 181         SBIT(P0_2, 0x80, 2);
 182         SBIT(AD1,  0x80, 1);
 183         SBIT(P0_1, 0x80, 1);
 184         SBIT(AD0,  0x80, 0);
 185         SBIT(P0_0, 0x80, 0);
 186 SFR(P1, 0x90); // Port 1
 187         SBIT(T1_CEX4, 0x90, 7);
 188         SBIT(P1_7,    0x90, 7);
 189         SBIT(T0_CEX3, 0x90, 6);
 190         SBIT(P1_6,    0x90, 6);
 191         SBIT(CEX2,    0x90, 5);
 192         SBIT(P1_5,    0x90, 5);
 193         SBIT(CEX1,    0x90, 4);
 194         SBIT(P1_4,    0x90, 4);
 195         SBIT(CEX0,    0x90, 3);
 196         SBIT(P1_3,    0x90, 3);
 197         SBIT(ECI,     0x90, 2);
 198         SBIT(P1_2,    0x90, 2);
 199         SBIT(T2EX,    0x90, 1);
 200         SBIT(P1_1,    0x90, 1);
 201         SBIT(T2,      0x90, 0);
 202         SBIT(P1_0,    0x90, 0);
 203 SFR(P2, 0xA0); // Port 2
 204         SBIT(AD15, 0xA0, 7);
 205         SBIT(P2_7, 0xA0, 7);
 206         SBIT(AD14, 0xA0, 6);
 207         SBIT(P2_6, 0xA0, 6);
 208         SBIT(AD13, 0xA0, 5);
 209         SBIT(P2_5, 0xA0, 5);
 210         SBIT(AD12, 0xA0, 4);
 211         SBIT(P2_4, 0xA0, 4);
 212         SBIT(AD11, 0xA0, 3);
 213         SBIT(P2_3, 0xA0, 3);
 214         SBIT(AD10, 0xA0, 2);
 215         SBIT(P2_2, 0xA0, 2);
 216         SBIT(AD9,  0xA0, 1);
 217         SBIT(P2_1, 0xA0, 1);
 218         SBIT(AD8,  0xA0, 0);
 219         SBIT(P2_0, 0xA0, 0);
 220 SFR(P3, 0xB0); // Port 3
 221         SBIT(RD,   0xB0, 7);
 222         SBIT(P3_7, 0xB0, 7);
 223         SBIT(WR,   0xB0, 6);
 224         SBIT(P3_6, 0xB0, 6);
 225         SBIT(T1,   0xB0, 5);
 226         SBIT(P3_5, 0xB0, 5);
 227         SBIT(T0,   0xB0, 4);
 228         SBIT(P3_4, 0xB0, 4);
 229         SBIT(INT1, 0xB0, 3);
 230         SBIT(P3_3, 0xB0, 3);
 231         SBIT(INT0, 0xB0, 2);
 232         SBIT(P3_2, 0xB0, 2);
 233         SBIT(TXD,  0xB0, 1);
 234         SBIT(P3_1, 0xB0, 1);
 235         SBIT(RXD,  0xB0, 0);
 236         SBIT(P3_0, 0xB0, 0);
 237 SFR(P4, 0xA1); // Port 3
 238         #define SS    0x08
 239         #define P4_3  0x08
 240         #define MOSI  0x04
 241         #define P4_2  0x04
 242         #define MISO  0x02
 243         #define SDA_1 0x02
 244         #define P4_1  0x02
 245         #define SCK   0x01
 246         #define SCL_1 0x01
 247         #define P4_0  0x01
 248 SFR(PCON, 0x87); // Power Control
 249         #define SMOD1  0x80
 250         #define SMOD0  0x40
 251         #define POF    0x10
 252         #define GF1    0x08
 253         #define GF0    0x04
 254         #define PD     0x02
 255         #define IDL    0x01
 256 SFR(PSW, 0xD0); // Program Status Word
 257         SBIT(CY,  0xD0, 7);
 258         SBIT(AC,  0xD0, 6);
 259         SBIT(F0,  0xD0, 5);
 260         SBIT(RS1, 0xD0, 4);
 261         SBIT(RS0, 0xD0, 3);
 262         SBIT(OV,  0xD0, 2);
 263         SBIT(F1,  0xD0, 1);
 264         SBIT(P,   0xD0, 0);
 265 SFR(RCAP2H, 0xCB); // Timer 2 Capture High
 266 SFR(RCAP2L, 0xCA); // Timer 2 Capture Low
 267 SFR(S0CON,  0x98); // Serial Control
 268         SBIT(SM0_FE,0x98, 7);
 269         SBIT(SM1,   0x98, 6);
 270         SBIT(SM2,   0x98, 5);
 271         SBIT(REN,   0x98, 4);
 272         SBIT(TB8,   0x98, 3);
 273         SBIT(RB8,   0x98, 2);
 274         SBIT(TI,    0x98, 1);
 275         SBIT(RI,    0x98, 0);
 276 SFR(S0BUF, 0x99); // Serial Data Buffer
 277 SFR(SADDR, 0xA9); // I2C Slave Address
 278 SFR(SADEN, 0xB9); // I2C Slave Address Mask
 279 SFR(SPCR,  0xD5); // SPI Control Register
 280         #define SPIE  0x80
 281         #define SPEN  0x40
 282         #define DORD  0x20
 283         #define MSTR  0x10
 284         #define CPOL  0x08
 285         #define CPHA  0x04
 286         #define SPR1  0x02
 287         #define SPR0  0x01
 288 /*      SBIT(SPIE,   0x80, 7);   // SPCR is not bit addressable, not yet at least, according to the manual.
 289         SBIT(SPEN,   0x80, 6);
 290         SBIT(DORD,   0x80, 5);
 291         SBIT(MSTR,   0x80, 4);
 292         SBIT(CPOL,   0x80, 3);
 293         SBIT(CPHA,   0x80, 2);
 294         SBIT(SPR1,   0x80, 1);
 295         SBIT(SPR0,   0x80, 0);*/
 296 SFR(SPSR,  0xAA); // SPI Configuration Register
 297         #define SPIF  0x80
 298         #define WCOL  0x40
 299 SFR(SPDAT, 0x86); // SPI Data
 300 SFR(SP,    0x81); // Stack Pointer
 301 SFR(S1DAT, 0xDA); // I2C Serial 1 Data
 302 SFR(S1ADR, 0xDB); // I2C Serial 1 Address
 303         #define S1ADR_6  0x80
 304         #define S1ADR_5  0x40
 305         #define S1ADR_4  0x20
 306         #define S1ADR_3  0x10
 307         #define S1ADR_2  0x08
 308         #define S1ADR_1  0x04
 309         #define S1ADR_0  0x02
 310         #define S1GC     0x01
 311 SFR(S1STA, 0xD9); // I2C Serial 1 Status
 312         #define SC4  0x80
 313         #define SC3  0x40
 314         #define SC2  0x20
 315         #define SC1  0x10
 316         #define SC0  0x08    // Only write 0 to the lowest three bits
 317 SFR(S1CON, 0xD8); // I2C Serial 1 Control
 318         SBIT(CR2,  0xD8, 7);
 319         SBIT(ENS1, 0xD8, 6);
 320         SBIT(STA,  0xD8, 5);
 321         SBIT(STO,  0xD8, 4);
 322         SBIT(SI,   0xD8, 3);
 323         SBIT(AA,   0xD8, 2);
 324         SBIT(CR1,  0xD8, 1);
 325         SBIT(CR0,  0xD8, 0);
 326 SFR(S2DAT, 0xE2); // I2C Serial 1 Data
 327 SFR(S2ADR, 0xE3); // I2C Serial 1 Address
 328         #define S2ADR_6  0x80
 329         #define S2ADR_5  0x40
 330         #define S2ADR_4  0x20
 331         #define S2ADR_3  0x10
 332         #define S2ADR_2  0x08
 333         #define S2ADR_1  0x04
 334         #define S2ADR_0  0x02
 335         #define S2GC     0x01
 336 SFR(S2STA, 0xE1); // I2C Serial 1 Status
 337         #define SC24  0x80
 338         #define SC23  0x40
 339         #define SC22  0x20
 340         #define SC21  0x10
 341         #define SC20  0x08  // Only write 0 to the lowest three bits
 342 SFR(S2CON, 0xF8); // I2C Serial 1 Control
 343         SBIT(CR22,  0xF8, 7);
 344         SBIT(ENS21, 0xF8, 6);
 345         SBIT(STA2,  0xF8, 5);
 346         SBIT(STO2,  0xF8, 4);
 347         SBIT(SI2,   0xF8, 3);
 348         SBIT(AA2,   0xF8, 2);
 349         SBIT(CR21,  0xF8, 1);
 350         SBIT(CR20,  0xF8, 0);
 351 SFR(TCON, 0x88); // Timer Control
 352         SBIT(TF1, 0x88, 7);
 353         SBIT(TR1, 0x88, 6);
 354         SBIT(TF0, 0x88, 5);
 355         SBIT(TR0, 0x88, 4);
 356         SBIT(IE1, 0x88, 3);
 357         SBIT(IT1, 0x88, 2);
 358         SBIT(IE0, 0x88, 1);
 359         SBIT(IT0, 0x88, 0);
 360 SFR(T2CON, 0xC8); // Timer 2 Control
 361         SBIT(TF2,    0xC8, 7);
 362         SBIT(EXF2,   0xC8, 6);
 363         SBIT(RCLK,   0xC8, 5);
 364         SBIT(TCLK,   0xC8, 4);
 365         SBIT(EXEN2,  0xC8, 3);
 366         SBIT(TR2,    0xC8, 2);
 367         SBIT(C_T2,   0xC8, 1);
 368         SBIT(CP_RL2, 0xC8, 0);
 369 SFR(T2MOD,  0xC9); // Timer 2 Mode Control
 370         #define ENT2  0x20
 371         #define T2OE  0x02
 372         #define DCEN  0x01
 373 SFR(TH0,  0x8C); // Timer High 0
 374 SFR(TH1,  0x8D); // Timer High 1
 375 SFR(TH2,  0xCD); // Timer High 2
 376 SFR(TL0,  0x8A); // Timer Low 0
 377 SFR(TL1,  0x8B); // Timer Low 1
 378 SFR(TL2,  0xCC); // Timer Low 2
 379 SFR(TMOD, 0x89); // Timer Mode
 380         #define GATE_1  0x80
 381         #define  C_T_1  0x40
 382         #define   M1_1  0x20
 383         #define   M0_1  0x10
 384         #define GATE_0  0x08
 385         #define  C_T_0  0x04
 386         #define   M1_0  0x02
 387         #define   M0_0  0x01
 388 SFR(WDTRST, 0xA6); // Watchdog Timer Reset
 389
 390 #endif  //__P89V66X_H__