lcdlin.c

ucgui的3.98版本的源代码

    int NumWords = ((Diff & 7) + xsize + 15) >> 4;
    WRITE_REG(0x102 / 2, Data);                                           /* set start bit and operation */
    WRITE_REG(0x104 / 2, 0);                                              /* set source start address */
    BITBLT_SET_DESTINATION(x, y);                                         /* set destination start address */
    WRITE_REG(0x110 / 2, (xsize - 1));                                    /* set width */
    WRITE_REG(0x112 / 2, (ysize - 1));                                    /* set height */
    WRITE_REG(0x114 / 2, (*(pTrans + 0)));                                /* set background color */
    WRITE_REG(0x118 / 2, (*(pTrans + 1)));                                /* set foreground color  */
    BITBLT_SET_ACTIVE();                                                  /* engage bitblt engine */
    do {
      READ_REG(0x100 / 2, tmp);
    } while ((tmp & 0x80) == 0);
    for (;ysize; ysize--, p += BytesPerLine) {
      U8 const *pLine= p;
      int i;
      for (i = NumWords; i; i--, pLine += 2) {
        do {
          READ_REG(0x100 / 2, tmp);
        } while ((tmp & 0x40) == 0x40);
        WRITE_REG(0x100000 / 2, ((*pLine) | ((*(pLine + 1)) << 8)));      /* write data into FIFO */
      }
    }
    _WaitForBltEnd();                                                     /* wait for pending blit to end */
  } LCD_ENABLE_MEM_ACCESS();
}

#endif

/*********************************************************************
*
*       Static code: BitBlt access for S1D13A03 - S1D13A05
*
**********************************************************************
*/
#if LCD_USE_BITBLT              \
    && (LCD_BUSWIDTH==16)       \
    && (!defined (LCD_LUT_COM)) \
    && (!defined (LCD_LUT_SEG)) \
    && (LCD_CONTROLLER == 1304)

#if LCD_BITSPERPIXEL == 8
  #define BITBLT_SET_DESTINATION(x,y)     _WriteReg32(0x8010, (U32)y * BYTESPERLINE + x)
  #define BITBLT_SET_ACTIVE()             _WriteReg16H(0x8000, 0x0000); /* 8bpp mode */ \
                                          _WriteReg16L(0x8000, 0x0001)  /* BitBLT enable */
#elif LCD_BITSPERPIXEL == 16
  #define BITBLT_SET_DESTINATION(x,y)     _WriteReg32(0x8010, (U32)y * BYTESPERLINE + (x << 1))
  #define BITBLT_SET_ACTIVE()             _WriteReg16H(0x8000, 0x0004); /* 16bpp mode */ \
                                          _WriteReg16L(0x8000, 0x0001)  /* BitBLT enable */
#endif

/*********************************************************************
*
*       _WaitForBltEnd
*/
static void _WaitForBltEnd(void) {
  volatile U32 tmp;
  do {
    tmp = _ReadReg16L(0x8004);
  } while (tmp & 1);
}

/*********************************************************************
*
*       _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 */
        _WriteReg16L(0x8018, (_x1 - x0));                                 /* set width */
        _WriteReg16L(0x801C, (_y1 - _y0));                                /* set height */
        _WriteReg16L(0x8024, (COLOR));                                    /* set foreground color  */
        if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
          _WriteReg16L(0x8008, 0x0006);                                   /* pattern fill */
          _WriteReg16H(0x8008, 0x0005);                                   /* ~D */
        } else {
          _WriteReg16L(0x8008, 0x000C);                                   /* solid fill */
          _WriteReg16H(0x8008, 0x0000);                                   /* 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 Operation = (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) ? 0x0009 : 0x0008;
    int NumWords = ((Diff & 7) + xsize + 15) >> 4;
    _WriteReg16L(0x8008, Operation);                                      /* set operation */
    _WriteReg16H(0x8008, StartBit);                                       /* set start bit */
    _WriteReg32 (0x800C, 0);                                              /* set source start address */
    BITBLT_SET_DESTINATION(x, y);                                         /* set destination start address */
    _WriteReg16L(0x8018, (xsize - 1));                                    /* set width */
    _WriteReg16L(0x801C, (ysize - 1));                                    /* set height */
    _WriteReg16L(0x8020, (*(pTrans + 0)));                                /* set background color */
    _WriteReg16L(0x8024, (*(pTrans + 1)));                                /* set foreground color  */
    BITBLT_SET_ACTIVE();                                                  /* engage bitblt engine */
    do {
      tmp = _ReadReg16L(0x8004);
    } while ((tmp & 1) == 0);
    for (;ysize; ysize--, p += BytesPerLine) {
      U8 const *pLine= p;
      int i;
      for (i = NumWords; i; i--, pLine += 2) {
        do {
          tmp = _ReadReg16L(0x8004);
        } while ((tmp & 0x4) == 0x4);
        _WriteReg16L(0x10000, ((*pLine) | ((*(pLine + 1)) << 8)));        /* write data into FIFO */
      }
    }
    _WaitForBltEnd();                                                     /* wait for pending blit to end */
  } LCD_ENABLE_MEM_ACCESS();
}

#endif

/*
        *********************************************************
        *                                                       *
        *       Internal set pixel routines                     *
        *                                                       *
        *********************************************************
*/

static void _SetPixel(int x, int y, LCD_PIXELINDEX c) {
  tOff Off = XY2OFF(x,y);
#if LCD_BUSWIDTH == 16
  #if LCD_BITSPERPIXEL == 1
    U8 BitNo = (~x)&15;
    U16 Data;
    READ_MEM(Off, Data);
    if (c)
      Data |= c<<BitNo;
    else
      Data &= ~(1<<BitNo);
    WRITE_MEM(Off, Data);
  #elif LCD_BITSPERPIXEL == 2
    U16 Data;
    U8 Shift = 14 - ((x & 7) << 1);
    READ_MEM(Off, Data);
    Data = (Data & ~(3 << Shift)) | (c << Shift);
    WRITE_MEM(Off, Data);
  #elif LCD_BITSPERPIXEL == 4
    U8 Shift = ((~x)&3)<<2;         /* 12,8,4 or 0 */
    U16 Data;
    READ_MEM(Off, Data);
    Data &= ~(15<<Shift);
		Data |= c<<Shift;
    WRITE_MEM(Off, Data);
  #elif LCD_BITSPERPIXEL == 8
    U16 Data;
    READ_MEM(Off, Data);
    switch (x&1) {
    case 1:
      Data = (Data & ~(0xff   )) | (c   );
      break;
    case 0:
      Data = (Data & ~(0xff<<8)) | (c<<8);
      break;
    }
    WRITE_MEM(Off, Data);
  #elif (LCD_BITSPERPIXEL == 15) | (LCD_BITSPERPIXEL == 16)
    WRITE_MEM(Off, c);
  #else
    #error unsupported LCD_BITSPERPIXEL
  #endif
#elif LCD_BUSWIDTH == 8
  #if LCD_BITSPERPIXEL == 1
    U8 Data;
    U8 BitNo;
    READ_MEM(Off, Data);
    BitNo = 7-(x&7);
    if (c)
      Data |= c<<BitNo;
    else
      Data &= ~(1<<BitNo);
    WRITE_MEM(Off, Data);
  #elif LCD_BITSPERPIXEL == 2
    U8 Data;
    READ_MEM(Off, Data);
    switch (x&3) {
    case 3:
      Data = (Data & ~(3<<0)) | (c<<0);
      break;
    case 2:
      Data = (Data & ~(3<<2)) | (c<<2);
      break;
    case 1:
      Data = (Data & ~(3<<4)) | (c<<4);
      break;
    case 0:
      Data = (Data & ~(3<<6)) | (c<<6);
      break;
    }
    WRITE_MEM(Off, Data);
  #elif LCD_BITSPERPIXEL == 4
    U8 Data;
    READ_MEM(Off, Data);
    switch (x&1) {
    case 1:
      Data = (Data & ~(15<<0)) | (c<<0);
      break;
    case 0:
      Data = (Data & ~(15<<4)) | (c<<4);
      break;
    }
    WRITE_MEM(Off, Data);
  #elif LCD_BITSPERPIXEL == 8
    WRITE_MEM(Off, c);
  #else
    #error TBD
  #endif
#else
  #error unsupported LCD_BUSWIDTH
#endif
}

static unsigned int _GetPixelIndex(int x, int y) {
  LCD_PIXELINDEX col;
  tOff Off = XY2OFF(x,y);
#if LCD_BUSWIDTH == 16
  U16 Data;
  READ_MEM(Off,Data);
  #if LCD_BITSPERPIXEL == 1
    col = (Data >> (15-(x&15))) &1;
  #elif LCD_BITSPERPIXEL == 2
    col = (Data >> (14-((x&7)<<1))) &3;
  #elif LCD_BITSPERPIXEL == 4
    col = (Data >> (12-((x&3)<<2))) &15;
  #elif LCD_BITSPERPIXEL == 8
    col = ((x&1) ==0) ? Data>>8 : Data&255;
  #elif LCD_BITSPERPIXEL == 15
    col = Data;
  #elif LCD_BITSPERPIXEL == 16
    col = Data;
  #endif
#else
  U8 Data;
  READ_MEM(Off,Data);
  #if LCD_BITSPERPIXEL == 1
    col = (Data >> (7-(x&7))) &1;
  #elif LCD_BITSPERPIXEL == 2
    col = (Data >> (6-((x&3)<<1))) &3;
  #elif LCD_BITSPERPIXEL == 4
    col = (x&1) ? Data&15 : Data>>4;
  #elif LCD_BITSPERPIXEL == 8
    col = Data;
  #endif
#endif
  return col;
}

static void XorPixel   (int x, int y) {
  LCD_PIXELINDEX Index = _GetPixelIndex(x,y);
  _SetPixel(x,y,LCD_NUM_COLORS-1-Index);
}



/*
        *********************************************************
        *                                                       *
        *       LCD_L0_XorPixel                                 *
        *                                                       *
        *********************************************************

Purpose:  Inverts 1 pixel of the display.

*/

void LCD_L0_XorPixel(int x, int y) {
  XORPIXEL(x, y);
}

/*
        *********************************************************
        *                                                       *
        *       LCD_L0_SetPixelIndex                            *
        *                                                       *
        *********************************************************

Purpose:  Writes 1 pixel into the display.

*/
void LCD_L0_SetPixelIndex(int x, int y, int ColorIndex) {
  SETPIXEL(x, y, ColorIndex);
}


/*
        *********************************************************
        *                                                       *
        *          LCD_L0_DrawHLine optimized                      *
        *                                                       *
        *          16 bit bus, Using BITBLT                     *
        *                                                       *
        *********************************************************
*/

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

void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  #if LCD_MIRROR_X
    #define X0