lcdlin.c

ucgui的3.98版本的源代码

    aColorSep[i] = color &0xff;
    color >>= 8;
  }
  /* Convert 8 bit color seperation into index */
  for (i = 0; i < 3; i++) {
    aColorSep[i] = (U16)(aColorSep[i] + 8) / 17;
  }
  /* Write into palette register */
  LCD_ENABLE_REG_ACCESS();
  /* 4 bit palette */
  #if (LCD_BUSWIDTH == 16)
    WRITE_REG((0x14 >> 1), Pos * 0x101);   /* Select position */
    for (i = 0; i < 3; i++) {
      WRITE_REG((0x16 >> 1), ((U16)aColorSep[i] * 17) << 8);  /* 1375 expects high nibble, 1374 low nibble (so this works on both) */
    }
  #else
    WRITE_REG((0x15), Pos);   /* Select position */
    for (i = 0; i < 3; i++) {
      WRITE_REG((0x17), aColorSep[i] << 4);
    }
  #endif
  LCD_ENABLE_MEM_ACCESS();
}
#define LCD_SET_LUT_ENTRY(Pos, Color) _SetLUTEntry_1375(Pos, Color)

#elif (LCD_CONTROLLER == 1376)

/*********************************************************************
*
*       _SetLUTEntry_1376
*/
static void _SetLUTEntry_1376(U8 Pos, LCD_COLOR color) {
  int i;
  U16 aColorSep[3];
  for (i = 0; i < 3; i++) {
    aColorSep[i] = color &0xff;
    color >>= 8;
  }
  /* Convert 8 bit color seperation into index */
  for (i = 0; i < 3; i++) {
    aColorSep[i] = (aColorSep[i]) / 4;
  }
  /* Write into palette register */
  LCD_ENABLE_REG_ACCESS();
  /* Write Green and Blue into regs 8/9 */
  WRITE_REG((0x8 >> 1), (aColorSep[1] << (8 + 2))| (aColorSep[2] << 2));
  /* Write Red into regs 0xa, index into 0xb */
  WRITE_REG(0xa >> 1, (Pos << 8)  | (aColorSep[0] << 2));   /* Select position */
  LCD_ENABLE_MEM_ACCESS();
}
#define LCD_SET_LUT_ENTRY(Pos, Color) _SetLUTEntry_1376(Pos, Color)

#elif (LCD_CONTROLLER == 1356) || (LCD_CONTROLLER == 13506) || \
      (LCD_CONTROLLER == 1386) || (LCD_CONTROLLER == 13806)

/*********************************************************************
*
*       _SetLUTEntry_1386_1356
*/
static void _SetLUTEntry_1386_1356(U8 Pos, LCD_COLOR color) {
  int i;
  U16 aColorSep[3];
  for (i = 0; i < 3; i++) {
    aColorSep[i] = color &0xff;
    color >>= 8;
  }
  /* Convert 8 bit color seperation into index */
  for (i = 0; i < 3; i++) {
    aColorSep[i] = (U16)(aColorSep[i] + 8) / 17;
  }
  /* Write into palette register */
  LCD_ENABLE_REG_ACCESS();
  #if (LCD_BUSWIDTH == 16)
    WRITE_REG(0x01e2 / 2, Pos);   /* Select position */
    for (i = 0; i < 3; i++) {
      WRITE_REG(0x01e4 / 2, aColorSep[i] << 4);
    }
  #else
    #error Not yet defined
  #endif
  LCD_ENABLE_MEM_ACCESS();
}
#define LCD_SET_LUT_ENTRY(Pos, Color) _SetLUTEntry_1386_1356(Pos, Color)

#elif (LCD_CONTROLLER == 1304)

/*********************************************************************
*
*       _WriteReg16L
*/
static void _WriteReg16L(U32 Reg, U16 Value) {
  #if (LCD_CNF4 == 0)
    WRITE_REG( Reg      >> 1, Value);
  #else
    WRITE_REG((Reg + 2) >> 1, Value);
  #endif
}

/*********************************************************************
*
*       _WriteReg16H
*/
static void _WriteReg16H(U32 Reg, U16 Value) {
  #if (LCD_CNF4 == 0)
    WRITE_REG((Reg + 2) >> 1, Value);
  #else
    WRITE_REG( Reg      >> 1, Value);
  #endif
}

/*********************************************************************
*
*       _WriteReg32
*/
static void _WriteReg32(U32 Reg, U32 Value) {
  _WriteReg16L(Reg, (U16)Value);
  _WriteReg16H(Reg, (U16)(Value >> 16));
}

/*********************************************************************
*
*       _ReadReg16L
*/
static U16 _ReadReg16L(U32 Reg) {
  U16 Value;
  #if (LCD_CNF4 == 0)
    READ_REG( Reg      >> 1, Value);
  #else
    READ_REG((Reg + 2) >> 1, Value);
  #endif
  return Value;
}

/*********************************************************************
*
*       _SetLUTEntry_1304
*/
static void _SetLUTEntry_1304(U8 Pos, LCD_COLOR color) {
  int i;
  U16 RegL, RegH;
  U16 aColorSep[3];
  for (i = 0; i < 3; i++) {
    aColorSep[i] = color & 0xfc;
    color >>= 8;
  }
  /* Write into palette register */
  RegL = aColorSep[2] | (aColorSep[1] << 8);
  RegH = aColorSep[0] | (Pos << 8);
  LCD_ENABLE_REG_ACCESS();
  #if (LCD_CNF4 == 0)
    _WriteReg16L(0x18, RegL);
    _WriteReg16H(0x18, RegH); /* If pin CNF4 = 0 (little endian mode) the LUT is updated after writing bits 24-31 */
  #else
    _WriteReg16H(0x18, RegH);
    _WriteReg16L(0x18, RegL); /* If pin CNF4 = 1 (big endian mode) the LUT is updated after writing bits 2-7 */
  #endif
  LCD_ENABLE_MEM_ACCESS();
}
#define LCD_SET_LUT_ENTRY(Pos, Color) _SetLUTEntry_1304(Pos, Color)

#endif

#endif /* !defined(LCD_SET_LUT_ENTRY) */

/*
        *********************************************************
        *                                                       *
        *       Next pixel routines                             *
        *                                                       *
        *********************************************************
*/

#if      (LCD_OPTIMIZE)             \
      && (LCD_BUSWIDTH == 8)        \
      && (!LCD_MIRROR_X)             \
      && (!LCD_MIRROR_Y)            \
      && (LCD_SWAP_XY)              \
      && (!defined (LCD_LUT_COM))    \
      && (!defined (LCD_LUT_SEG))    \
      && (LCD_BITSPERPIXEL == 4)

static int CurPosY;    /* Physical x position !!! */
static tOff CurOff;

static void SetPosXY(int x, int y) {
  y = LCD_YSIZE-1-y;
  CurPosY = y;
  CurOff = XY2OFF(y,x);
}

static void SetNextPixel(LCD_PIXELINDEX c) {
  U8 Data;
  READ_MEM(CurOff, Data);
  if (CurPosY&1) {
    Data = (Data & ~(15<<0)) | (c<<0);
    CurOff++;
  } else {
    Data = (Data & ~(15<<4)) | (c<<4);
  }
  WRITE_MEM(CurOff, Data);
  CurPosY++;
}

#elif      (LCD_OPTIMIZE)           \
      && (LCD_BUSWIDTH == 8)        \
      && (!LCD_MIRROR_X)            \
      && (!LCD_MIRROR_Y)            \
      && (!LCD_SWAP_XY)              \
      && (!defined (LCD_LUT_COM))    \
      && (!defined (LCD_LUT_SEG))    \
      && (LCD_BITSPERPIXEL == 4)

static int CurPosX;    /* Physical x position !!! */
static tOff CurOff;
static U8  CurData;

static void SetPosXY(int x, int y) {
  CurPosX = x;
  CurOff = XY2OFF(x,y);
  CurData = LCD_READ_MEM(CurOff);
}

#define SETNEXTPIXEL(c) {                           \
  if (CurPosX&1) {																	\
    CurData = (CurData & ~(15<<0)) | (c<<0);				\
    WRITE_MEM(CurOff, CurData);			    						\
    CurOff++;																				\
    READ_MEM(CurOff, CurData);				    					\
  } else {																					\
    CurData = (CurData & ~(15<<4)) | (c<<4);				\
  }																									\
  CurPosX++;                                        \
}

void SetNextPixel(int c) {
  SETNEXTPIXEL(c);
}

#define END_SETNEXTPIXEL() if (CurPosX&1) WRITE_MEM(CurOff, CurData);

#else
  #define END_SETNEXTPIXEL()
#endif

/*********************************************************************
*
*       Static code: BitBlt access for SED1356/SED13806
*
**********************************************************************
*/

#if LCD_USE_BITBLT             \
    && (LCD_BUSWIDTH==16)      \
    && (!defined (LCD_LUT_COM))   \
    && (!defined (LCD_LUT_SEG))   \
    && ((LCD_CONTROLLER == 1356)||(LCD_CONTROLLER == 13806))

#if LCD_BITSPERPIXEL == 8
  #define BITBLT_SET_DESTINATION(x,y)     {                                                                            \
                                            U32 DestOff = (U32)y * BYTESPERLINE + x;                                   \
                                            WRITE_REG(0x108 / 2, DestOff);                                             \
                                            WRITE_REG(0x10a / 2, DestOff >> 16);                                       \
                                          }
  #define BITBLT_SET_ACTIVE()             WRITE_REG(0x100 / 2, 0x0000); WRITE_REG(0x100 / 2, 0x0080)
#elif LCD_BITSPERPIXEL == 16
  #define BITBLT_SET_DESTINATION(x,y)     {                                                                            \
                                            U32 DestOff = (U32)y * BYTESPERLINE + (x <<1);                                   \
                                            WRITE_REG(0x108 / 2, DestOff);                                             \
                                            WRITE_REG(0x10a / 2, DestOff >> 16);                                       \
                                          }
  #define BITBLT_SET_ACTIVE()             WRITE_REG(0x100 / 2, 0x0100); WRITE_REG(0x100 / 2, 0x0180)
#endif

/*********************************************************************
*
*       _WaitForBltEnd
*/
static void _WaitForBltEnd(void) {
  volatile U16 tmp;
  do {
    READ_REG(0x100 / 2, tmp);
  } while (tmp & 0x80);
  READ_REG(0x100000 / 2, tmp);                                            /* dummy read */
}

/*********************************************************************
*
*       _FillRectBB
*/
static void _FillRectBB(int x0, int y0, int x1, int y1) {
  LCD_ENABLE_REG_ACCESS(); {
    for (;x0 <= x1; x0 += 1024) {
      int _y0 = y0;
      int _x1 = x1;
      if (_x1 > (x0 + 1023)) {
        _x1 = x0 + 1023;
      }
      for (;_y0 <= y1; _y0 += 1024) {
        int _y1 = y1;
        if (_y1 > (_y0 + 1023)) {
          _y1 = _y0 + 1023;
        }
        BITBLT_SET_DESTINATION(x0, _y0);                                  /* set destination start address */
        WRITE_REG(0x110 / 2, (_x1 - x0));                                 /* set width */
        WRITE_REG(0x112 / 2, (_y1 - _y0));                                /* set height */
        WRITE_REG(0x118 / 2, (COLOR));                                    /* set foreground color  */
        if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
          WRITE_REG(0x102 / 2, 0x0605);                                   /* pattern fill, ~D   */
        } else {
          WRITE_REG(0x102 / 2, 0x0c00);                                   /* solid fill, no ROP */
        }
        BITBLT_SET_ACTIVE();                                              /* engage bitblt engine */
        _WaitForBltEnd();                                                 /* wait for pending blit to end */
      }
    }
  } LCD_ENABLE_MEM_ACCESS();
}

/*********************************************************************
*
*       _DrawBitmap1BPPBB
*/
static void _DrawBitmap1BPPBB(int x, int y, U8 const*p, int Diff, int xsize, int ysize, int BytesPerLine, const LCD_PIXELINDEX*pTrans) {
  volatile U16 tmp;
  x+= Diff;
  LCD_ENABLE_REG_ACCESS(); {
    U16 StartBit = 7 - (Diff & 7);
    U16 Data = StartBit | ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) ? 0x900 : 0x800);