lcd13xx.c

用于S3C44B0的ucGUI,支持中文。

    #if ((LCD_BITSPERPIXEL == 16) || (LCD_BITSPERPIXEL == 8 )) && (LCD_MIRROR_Y == 0) && (LCD_SWAP_XY  == 0)
      #define LCD_USE_BITBLT            (1)
    #else
      #define LCD_USE_BITBLT            (0)
    #endif
  #else
    #if (LCD_MIRROR_Y)
      #error BITBLT engine does not support LCD_MIRROR_Y = 1!
    #endif
    #if (LCD_SWAP_XY)
      #error BITBLT engine does not support LCD_SWAP_XY = 1!
    #endif
  #endif
#else
  #define LCD_USE_BITBLT                (0)
#endif

#ifndef LCD_ENABLE_REG_ACCESS
  #define LCD_ENABLE_REG_ACCESS()
#endif

#ifndef LCD_ENABLE_MEM_ACCESS
  #define LCD_ENABLE_MEM_ACCESS()
#endif

#ifndef STATIC
  #define STATIC static
#endif


/*
        *********************************************************
        *                                                       *
        *           Defines for configuration simulation        *
        *                                                       *
        *********************************************************

*/
#if defined(WIN32) && !defined(USE_PC_HARDWARE)
  void SIM_WriteMem8(unsigned int Off, int Data);
  void SIM_WriteReg8(unsigned int Off, int Data);
  int  SIM_ReadMem8(unsigned int Off);
  int  SIM_ReadReg8(unsigned int Off);
  void SIM_WriteMem16(unsigned int Off, int Data);
  void SIM_WriteReg16(unsigned int Off, int Data);
  int  SIM_ReadMem16(unsigned int Off);
  int  SIM_ReadReg16(unsigned int Off);

  #undef  LCD_READ_MEM
  #undef  LCD_READ_REG
  #undef  LCD_WRITE_MEM
  #undef  LCD_WRITE_REG

  #if LCD_BUSWIDTH==8
    #define LCD_READ_MEM(Off)       SIM_ReadMem8(Off)
    #define LCD_WRITE_MEM(Off,Data) SIM_WriteMem8(Off, Data)
    #define LCD_READ_REG(Off)       SIM_ReadReg8(Off)
    #define LCD_WRITE_REG(Off,Data) SIM_WriteReg8(Off, Data)
  #elif LCD_BUSWIDTH==16
    #define LCD_READ_MEM(Off)       SIM_ReadMem16(Off)
    #define LCD_WRITE_MEM(Off,Data) SIM_WriteMem16(Off, Data)
    #define LCD_READ_REG(Off)       SIM_ReadReg16(Off)
    #define LCD_WRITE_REG(Off,Data) SIM_WriteReg16(Off, Data)
  #endif
#elif defined(WIN32) && defined(USE_PC_HARDWARE)
  void PC_WriteMem8(unsigned int Off, int Data);
  void PC_WriteReg8(unsigned int Off, int Data);
  int  PC_ReadMem8(unsigned int Off);
  int  PC_ReadReg8(unsigned int Off);
  void PC_WriteMem16(unsigned int Off, int Data);
  void PC_WriteReg16(unsigned int Off, int Data);
  int  PC_ReadMem16(unsigned int Off);
  int  PC_ReadReg16(unsigned int Off);

  #undef  LCD_READ_MEM
  #undef  LCD_READ_REG
  #undef  LCD_WRITE_MEM
  #undef  LCD_WRITE_REG
  #if LCD_BUSWIDTH==8
    #define LCD_READ_MEM(Off)       PC_ReadMem8(Off)
    #define LCD_WRITE_MEM(Off,Data) PC_WriteMem8(Off, Data)
    #define LCD_READ_REG(Off)       PC_ReadReg8(Off)
    #define LCD_WRITE_REG(Off,Data) PC_WriteReg8(Off, Data)
  #else
    #define LCD_READ_MEM(Off)       PC_ReadMem16(Off)
    #define LCD_WRITE_MEM(Off,Data) PC_WriteMem16(Off, Data)
    #define LCD_READ_REG(Off)       PC_ReadReg16(Off)
    #define LCD_WRITE_REG(Off,Data) PC_WriteReg16(Off, Data)
  #endif
#endif

/********************************************************
*
*           Remap Hardware macros
*
*********************************************************
*/

#if LCD_NUM_DISPLAYS ==1 /* Use single display macros */
#else
  #if LCD_DISPLAY_INDEX == 0     /* First display in a multi-display configuration */
    #define LCD_READ_MEM(Off)       LCD_READ_MEM_0(Off)
    #define LCD_WRITE_MEM(Off,Data) LCD_WRITE_MEM_0(Off,Data)
    #define LCD_READ_REG(Off)       LCD_READ_REG_0(Off)
    #define LCD_WRITE_REG(Off,Data) LCD_WRITE_REG_0(Off,Data)
    #define LCD_INIT_CONTROLLER     LCD_INIT_CONTROLLER_0
  #else
    #define LCD_READ_MEM(Off)       LCD_READ_MEM_1(Off)
    #define LCD_WRITE_MEM(Off,Data) LCD_WRITE_MEM_1(Off,Data)
    #define LCD_READ_REG(Off)       LCD_READ_REG_1(Off)
    #define LCD_WRITE_REG(Off,Data) LCD_WRITE_REG_1(Off,Data)
    #define LCD_INIT_CONTROLLER     LCD_INIT_CONTROLLER_1
  #endif
#endif

/*
        *********************************************************
        *                                                       *
        *          Internal types                               *
        *                                                       *
        *********************************************************
*/

/*
        *********************************************************
        *                                                       *
        *          SCHEDULING                                   *
        *                                                       *
        *********************************************************
*/

#if (LCD_SCHEDULE_CNT !=0)
  static int ScheduleCntRem=LCD_SCHEDULE_CNT;
  #define CHECK_SCHEDULE(PixelCnt)                              \
          if ((ScheduleCntRem-=(PixelCnt)) <=0) {               \
            ScheduleCntRem=LCD_SCHEDULE_CNT;                    \
            LCD_SCHEDULE();                                     \
          }
#else
  #define CHECK_SCHEDULE(PixelCnt)
#endif




/*
        *********************************************************
        *                                                       *
        *           Macro calculations                          *
        *                                                       *
        *********************************************************
*/

/* To make life easier, assign physical x/y size */

#if !LCD_SWAP_XY
  #define LCD_XSIZE_P LCD_XSIZE
  #define LCD_YSIZE_P LCD_YSIZE
  #define LCD_VXSIZE_P LCD_VXSIZE
  #define LCD_VYSIZE_P LCD_VYSIZE
#else
  #define LCD_XSIZE_P LCD_YSIZE
  #define LCD_YSIZE_P LCD_XSIZE
  #define LCD_VXSIZE_P LCD_VYSIZE
  #define LCD_VYSIZE_P LCD_VXSIZE
#endif

#if   LCD_BITSPERPIXEL == 1
  #define BYTESPERLINE (LCD_VXSIZE_P/8)
  #define WORDSPERLINE (LCD_VXSIZE_P/16)
#elif   LCD_BITSPERPIXEL == 2
  #define BYTESPERLINE (LCD_VXSIZE_P/4)
  #define WORDSPERLINE (LCD_VXSIZE_P/8)
#elif   LCD_BITSPERPIXEL == 4
  #define BYTESPERLINE (LCD_VXSIZE_P/2)
  #define WORDSPERLINE (LCD_VXSIZE_P/4)
#elif LCD_BITSPERPIXEL == 8
  #define BYTESPERLINE (LCD_VXSIZE_P)
  #define WORDSPERLINE (LCD_VXSIZE_P/2)
#elif  (LCD_BITSPERPIXEL == 15)
  #define BYTESPERLINE (LCD_VXSIZE_P*2)
  #define WORDSPERLINE (LCD_VXSIZE_P)
#elif  (LCD_BITSPERPIXEL == 16)
  #define BYTESPERLINE (LCD_VXSIZE_P*2)
  #define WORDSPERLINE (LCD_VXSIZE_P)
#else
  #error This colordepth is not supported !!!
#endif

#ifndef LCD_USE_32BIT_OFF
  #if ((WORDSPERLINE * LCD_YSIZE) > 0xFFFF)
    #define LCD_USE_32BIT_OFF 1
  #else
    #define LCD_USE_32BIT_OFF 0
  #endif
#endif

#if LCD_USE_32BIT_OFF
  typedef unsigned long tOff;
#else
  typedef unsigned int  tOff;
#endif

/*
        *********************************************************
        *                                                       *
        *              Macros, standard                         *
        *                                                       *
        *********************************************************

These macros can be found in any LCD-driver as they serve purposes
that can be found in any class of LCD-driver (Like clipping).

*/

#define BKCOLOR LCD_BKCOLORINDEX
#define   COLOR LCD_COLORINDEX

/*
        *********************************************************
        *                                                       *
        *      Configuration switch checking                    *
        *                                                       *
        *********************************************************

Please be aware that not all configuration errors can be captured !

*/

/* Check number of controllers */
#if ((LCD_NUM_CONTROLLERS >1) || (LCD_NUM_CONTROLLERS <0))
  #error "More than 1 controller not supported by this driver"
#endif

#if ((LCD_CONTROLLER==1356)||(LCD_CONTROLLER==13806)) && (LCD_BUSWIDTH !=16)
  #error This controller does not work with 8-bit bus
#endif

#if (((LCD_CONTROLLER==1356)||(LCD_CONTROLLER==13806)) && LCD_USE_BITBLT && ((LCD_BITSPERPIXEL != 8) && (LCD_BITSPERPIXEL != 16)))
  #error BitBlt-Access only available for 8bpp and 16bpp mode
#endif

#if (LCD_CONTROLLER==1374)
  #if (LCD_BITSPERPIXEL == 8)
    #if (LCD_FIXEDPALETTE != 233)
      #error This controller supports only 233 palette in 8 bpp mode !
    #endif
  #endif
#endif





/*
        *********************************************************
        *                                                       *
        *       Macros for internal use                         *
        *                                                       *
        *********************************************************
*/

#if !defined (LCD_LUT_COM)
  #define LINE2COM(y) y
#else
  #define LINE2COM(y) LCD__aLine2Com0[y]
#endif

#if LCD_BUSWIDTH == 16
  #if   (LCD_BITSPERPIXEL == 16)
    #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)WORDSPERLINE+(x))
  #elif (LCD_BITSPERPIXEL == 15)
    #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)WORDSPERLINE+(x))
  #elif (LCD_BITSPERPIXEL ==  8)
    #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)WORDSPERLINE+(x>>1))
  #elif (LCD_BITSPERPIXEL ==  4)
    #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)WORDSPERLINE+(x>>2))
  #elif (LCD_BITSPERPIXEL ==  2)
    #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)WORDSPERLINE+((x)>>3))
  #elif (LCD_BITSPERPIXEL ==  1)
    #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)WORDSPERLINE+((x)>>4))
  #endif
#else
  #if   (LCD_BITSPERPIXEL == 16)
    #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)BYTESPERLINE+((x)<<1))
  #elif (LCD_BITSPERPIXEL == 15)
    #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)BYTESPERLINE+((x)<<1))
  #elif (LCD_BITSPERPIXEL ==  8)
    #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)BYTESPERLINE+(x))
  #elif (LCD_BITSPERPIXEL ==  4)
    #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)BYTESPERLINE+((x)>>1))
  #elif (LCD_BITSPERPIXEL ==  2)
    #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)BYTESPERLINE+((x)>>2))
  #elif (LCD_BITSPERPIXEL ==  1)
    #define XY2OFF(x,y)    (tOff)((tOff)LINE2COM(y)*(tOff)BYTESPERLINE+((x)>>3))
  #endif
#endif

#if ((LCD_SWAP_BYTE_ORDER) && (LCD_BITSPERPIXEL <=8)) | ((LCD_SWAP_BYTE_ORDER==0) && (LCD_BITSPERPIXEL  > 8))
  #define READ_MEM(Off, Data)  Data = LCD_READ_MEM(Off); Data = ((Data & 0xff) << 8) + (Data >> 8)
  #define WRITE_MEM(Off, Data) LCD_WRITE_MEM(Off, (U16)(((Data & 0xff) << 8) + ((Data & 0xff00) >> 8)))
#else
  #define READ_MEM(Off, Data)  Data = LCD_READ_MEM(Off)
  #define WRITE_MEM(Off, Data) LCD_WRITE_MEM(Off, Data)
#endif

#if (LCD_SWAP_BYTE_ORDER)
  #define READ_REG(Off, Data)  Data = LCD_READ_REG(Off)
  #define WRITE_REG(Off, Data) LCD_WRITE_REG(Off, Data)
#else
  #define READ_REG(Off, Data)  { Data = Swap(LCD_READ_REG(Off)); }
  #define WRITE_REG(Off, Data) { LCD_WRITE_REG(Off, Swap(Data)); }
  #define REQUIRE_SWAP
#endif

/* No use of LCD_WRITE_MEM, LCD_READ_MEM, LCD_WRITE_REG, LCD_READ_REG from this point */

#if defined (LCD_LUT_COM)
  #if (LCD_MIRROR_Y)
    #error LCD_MIRROR_Y not supported with COMTrans !
  #endif
  #if (LCD_MIRROR_X)
    #error LCD_MIRROR_X not supported with COMTrans !
  #endif
#endif

#if (!defined(LCD_LUT_SEG))
  #if   (!LCD_MIRROR_X && !LCD_MIRROR_Y && !LCD_SWAP_XY) 
    #define PHYS2LOG(x, y) x, y
  #elif (!LCD_MIRROR_X && !LCD_MIRROR_Y &&  LCD_SWAP_XY) 
    #define PHYS2LOG(x, y) y, x
  #elif (!LCD_MIRROR_X &&  LCD_MIRROR_Y && !LCD_SWAP_XY) 
    #define PHYS2LOG(x, y) x, LCD_YSIZE - 1 - (y)
  #elif (!LCD_MIRROR_X &&  LCD_MIRROR_Y &&  LCD_SWAP_XY) 
    #define PHYS2LOG(x, y) LCD_YSIZE - 1 - (y), x
  #elif ( LCD_MIRROR_X && !LCD_MIRROR_Y && !LCD_SWAP_XY) 
    #define PHYS2LOG(x, y) LCD_XSIZE - 1 - (x), y
  #elif ( LCD_MIRROR_X && !LCD_MIRROR_Y &&  LCD_SWAP_XY) 
    #define PHYS2LOG(x, y) LCD_YSIZE - 1 - (y), x
  #elif ( LCD_MIRROR_X &&  LCD_MIRROR_Y && !LCD_SWAP_XY) 
    #define PHYS2LOG(x, y) LCD_XSIZE - 1 - (x), LCD_YSIZE - 1 - (y)
  #elif ( LCD_MIRROR_X &&  LCD_MIRROR_Y &&  LCD_SWAP_XY) 
    #error This combination of mirroring/swapping not yet supported
  #endif
#else
  #define PHYS2LOG(x, y) LCD__aCol2Seg0[x], y
#endif

#define SETPIXEL(x, y, c)  _SetPixel    (PHYS2LOG(x, y), c)
#define GETPIXEL(x, y)     GetPixelIndex(PHYS2LOG(x, y))
#define XORPIXEL(x, y)     XorPixel     (PHYS2LOG(x, y))

/*
        *********************************************************
        *                                                       *
        *       Register access routines                        *
        *                                                       *
        *********************************************************
*/
#if defined(LCD_READ_REG)
#if (LCD_BUSWIDTH == 8)
  #define READ_REG_BYTE(Off) LCD_READ_REG(Off)
#else
  #define READ_REG_BYTE(Off) ReadRegByte(Off)
U8 ReadRegByte(int Off) {
  U16 Data = LCD_READ_REG((Off>>1));
  #if LCD_SWAP_BYTE_ORDER
    return (Off&1) ? Data>>8 : Data&255;
  #else
    return (Off&1) ? Data&255 : Data>>8;
  #endif
}
#endif