#define LCD_READCMD0    LCD_READ_A1
#define LCD_READDATA0   LCD_READ_A0
#define LCD_WRITECMD0   LCD_WRITE_A1
#define LCD_WRITEDATA0  LCD_WRITE_A0

#ifndef LCD_WAIT
  #define LCD_WAIT() while ((LCD_READ_A1()&3)!=3) /* Do not use LCD_READCMD0 to fix NC30-problem (JE) */
#endif

#define LCD_WRITECMD(cmd)      { LCD_WAIT(); LCD_WRITECMD0(cmd);  }
#define LCD_WRITEDATA(Data)    { LCD_WAIT(); LCD_WRITEDATA0(Data);}

/* Access Macros */
#define LCD_READDATA()        \
  LCD_WRITECMD(0xC5);         \
  return LCD_DATA0;

#define LCD_SETADR(Adr)       \
  LCD_WRITEDATA((U8)Adr);     \
  LCD_WRITEDATA((U8)(Adr>>8));\
  LCD_WRITECMD(0x24);         \
  LCD_Adr=Adr;

#define LCD_WRITE1(Byte)      \
  LCD_WRITEDATA(Byte);        \
  LCD_WRITECMD(0xC0);         \
  LCD_Adr++;


/* LCD_L0_ReInit */
#define LCD_RAMSIZE (0x2000)
#define LCD_GSTART  (0x0)
#define LCD_XSIZEB  ((LCD_XSIZE_PHYS+7)>>3)
#define LCD_TSTART  (LCD_RAMSIZE-(LCD_XSIZEB)-(LCD_YSIZE_PHYS>>3))

void LCD_L0_ReInit(void) {
  LCD_WRITECMD(0x81);           /* SetModeXor */

  LCD_WRITEDATA((U8)LCD_TSTART);/* SetTextAdr */
  LCD_WRITEDATA((U8)(LCD_TSTART>>8));
  LCD_WRITECMD(0x40);

  LCD_WRITEDATA(1);             /* SetTextArea */
  LCD_WRITEDATA(1>>8);
  LCD_WRITECMD(0x41);

  LCD_WRITECMD(0x9C);           /* SetTextGraph */

  LCD_WRITEDATA(LCD_GSTART);    /* SetGraphAdr */
  LCD_WRITEDATA(LCD_GSTART>>8);
  LCD_WRITECMD(0x42);

  LCD_WRITEDATA(LCD_XSIZEB);    /* SetGraphArea */
  LCD_WRITEDATA(LCD_XSIZEB>>8);
  LCD_WRITECMD(0x43);
}


/* LCD_FirstInit */
void LCD_FirstInit(void) {
  int i;
  LCD_INIT_CONTROLLER();
  LCD_SETADR(0);
  for (i=0; i<100; i++) {
    LCD_WRITE1(0xff);
  }
  LCD_SETADR(0);
  for (i=0;i<LCD_RAMSIZE;i++) {
    LCD_WRITE1(0x0);
  }
}

#endif /* T6963 */


/*
        *********************************************************
        *                                                       *
        *       Write 1 byte and manage cache                   *
        *                                                       *
        *********************************************************
*/

static void LCD_Write(int Adr, U8 Byte) {
  if (Cache[Adr]!=Byte) {
    Cache[Adr]=Byte;
    if (LCD_Adr!=Adr) {
      LCD_SETADR(Adr);
    }
    LCD_WRITE1(Byte);
  }
}

#define LCD_WRITE(Adr,Byte) LCD_Write(Adr,Byte);


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

static void _SetPixel(int x, int y, LCD_PIXELINDEX c) {
  U8 Mask=1<<(7-(x&7));
  int Adr=XY2OFF(x,y);
  U8 CacheByte=Cache[Adr];
  if (c)
    CacheByte|= Mask;
  else
    CacheByte&=~Mask;
  LCD_WRITE(Adr,CacheByte)
}

static PIXELCOLOR _GetPixel(int x, int y) {
  int Adr=XY2OFF(x,y);
  U8 Mask=1<<(7-(x&7));
  return (Cache[Adr]&Mask) ? 1 : 0;
}

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

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

Purpose:  This routine is called by emWin. It writes 1 pixel into the
          display.

*/

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


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

Purpose:  This routine is called by emWin. It writes 1 pixel into the
          display.

*/

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


/*
        *********************************************************
        *                                                       *
        *          LCD_L0_DrawHLine optimized                   *
        *                                                       *
        *********************************************************
*/

#if (LCD_OPTIMIZE)               \
      && (!LCD_SWAP_XY)          \
      && (!LCD_MIRROR_X)         \
      && (!LCD_MIRROR_Y)         \
      && (!LCD_SUPPORT_COMTRANS) \
      && (!LCD_SUPPORT_SEGTRANS)

void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  register int Off = XY2OFF(x0,y);
  int iByte = x0>>3;
  int Byte1 = x1>>3;
  U8 Mask =    0xff   >> (x0&7);
  U8 EndMask = 0xff80 >> (x1&7);
  U8 Data;
  if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
    for (; iByte<Byte1; iByte++) {
      Data = Cache[Off];
      Data ^= Mask; 
      LCD_WRITE(Off++,Data);
      Mask = 0xff;
    }
    Mask &= EndMask;
    Data = Cache[Off];
    Data ^= Mask; 
    LCD_WRITE(Off++,Data);
  } else {                                  /* Clear pixels in line */
    int NumBytes = Byte1-iByte;
    if (COLOR==0) {
      if (NumBytes) {
        Data = Cache[Off] & (~Mask);
        LCD_WRITE(Off++,Data);
        NumBytes--;
      /* Fill bytes in 2 loops for speed reasons ... */
        for (; NumBytes>=4; NumBytes-=4) {
          LCD_WRITE(Off++,0);
          LCD_WRITE(Off++,0);
          LCD_WRITE(Off++,0);
          LCD_WRITE(Off++,0);
        }
        for (; NumBytes; NumBytes--) {
          LCD_WRITE(Off++,0);
        }
        Mask = 0xff;
      }
      Mask &= EndMask;
      Data = Cache[Off];
      Data &= ~Mask; 
      LCD_WRITE(Off++,Data);
    } else {                                  /* Set pixels in line */
      if (NumBytes) {
        Data = Cache[Off] | Mask; 
        LCD_WRITE(Off++,Data);
        NumBytes--;
      /* Fill bytes in 2 loops for speed reasons ... */
        for (; NumBytes>=4; NumBytes-=4) {
          LCD_WRITE(Off++,0xff);
          LCD_WRITE(Off++,0xff);
          LCD_WRITE(Off++,0xff);
          LCD_WRITE(Off++,0xff);
        }
        for (; NumBytes; NumBytes--) {
          LCD_WRITE(Off++,0xff);
        }
        Mask = 0xff;
      }
      Mask &= EndMask;
      Data = Cache[Off] | Mask; 
      LCD_WRITE(Off++,Data);
    }
  }
}

#else

/*
        *********************************************************
        *                                                       *
        *          LCD_L0_DrawHLine unoptimized                 *
        *                                                       *
        *********************************************************
*/

void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
    while (x0 <= x1) {
      XORPIXEL(x0, y);
      x0++;
    }
  } else {
    while (x0 <= x1) {
      SETPIXEL(x0, y, COLOR);
      x0++;
    }
  }
}

#endif


/*
        *********************************************************
        *                                                       *
        *          LCD_L0_DrawVLine                             *
        *                                                       *
        *********************************************************
*/

void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
    while (y0 <= y1) {
      XORPIXEL(x, y0);
      y0++;
    }
  } else {
    while (y0 <= y1) {
      SETPIXEL(x, y0, COLOR);
      y0++;
    }
  }
}


/*
        *********************************************************
        *                                                       *
        *          LCD_FillRect, unoptimized                    *
        *                                                       *
        *********************************************************
*/

void LCD_L0_FillRect(int x0, int y0, int x1, int y1) {
  for (; y0 <= y1; y0++) {
    LCD_L0_DrawHLine(x0,y0, x1);
  }
}


/*
        *********************************************************
        *                                                       *
        *    Support for dynamic inversion of entire LCD        *
        *                                                       *
        *********************************************************

*/

#if LCD_REVERSEMODE_SUPPORT

void LCD_SetNormalDispMode    (void) {
}
void LCD_SetReverseDispMode   (void) {
}

#endif


/*
        *********************************************************
        *                                                       *
        *          Draw Bitmap 1 BPP, optimized                 *
        *                                                       *
        *********************************************************
*/

#if (LCD_OPTIMIZE)               \
      && (!LCD_SWAP_XY)          \
      && (!LCD_MIRROR_X)         \
      && (!LCD_MIRROR_Y)         \
      && (!LCD_SUPPORT_COMTRANS) \
      && (!LCD_SUPPORT_SEGTRANS)

static void  DrawBitLine1BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  LCD_PIXELINDEX Index0 = *(pTrans+0);
  LCD_PIXELINDEX Index1 = *(pTrans+1);
  x+=Diff;
  if ((Index0==Index1) & (!(GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)))) {
    LCD_PIXELINDEX ColorIndexOld= COLOR;
    COLOR = Index0;
    LCD_L0_DrawHLine(x,y,x+xsize-1);
    COLOR = ColorIndexOld;
    return;
  }
  {
    int Adr=XY2OFF(x,y);
    int x1 = x+xsize-1;
    U8 Mask    = 0xff   >> (x &7);
    U8 EndMask = 0xff80 >> (x1&7);
    U8 CacheByte;
    U16 PixelData;
    int NumBytes = (x1>>3) - (x>>3);
    if (NumBytes) {
      CacheByte=Cache[Adr];
      PixelData   = (*(p+1) | ((*p)<<8));
      PixelData >>= (8+(x&7)-(Diff&7));
      switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)) {
      case 0:
        if (!COLOR)
          PixelData ^= 255;
        CacheByte = (CacheByte&~Mask)|(PixelData&Mask);
        break;
      case LCD_DRAWMODE_TRANS:
        if (COLOR)
          CacheByte |= (PixelData&Mask);
        else
          CacheByte &= ~(PixelData&Mask);
        break;
      case LCD_DRAWMODE_XOR:
        CacheByte ^= (PixelData&Mask);
        break;
      }
      LCD_WRITE(Adr++,CacheByte);
      { 
        int DiffOld = Diff;
        Diff+= 8-(x&7); 
        if ((DiffOld&~7) != (Diff&~7))
          p++;
      }
      x=0;
      NumBytes--;
      for (; NumBytes; NumBytes--) {
        PixelData   = (*(p+1) | ((*p)<<8));
        PixelData >>= (8-(Diff&7));
        p++;
        switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)) {
        case 0:
          if (!COLOR)
            PixelData ^= 255;
          CacheByte=PixelData&255;
          break;
        case LCD_DRAWMODE_TRANS:
          CacheByte=Cache[Adr];
          if (COLOR)
            CacheByte |= PixelData;
          else
            CacheByte &= ~PixelData;
          break;
        case LCD_DRAWMODE_XOR:
          CacheByte=Cache[Adr] ^ PixelData;
          break;
        }
        LCD_WRITE(Adr++,CacheByte);
      }
      Mask = 0xff;
    }
    PixelData   = (*(p+1) | ((*p)<<8));
    PixelData >>= (8+(x&7)-(Diff&7));
    Mask &= EndMask;
    CacheByte = Cache[Adr];
    switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)) {
    case 0:
      if (!COLOR)
        PixelData ^= 255;
      CacheByte = (CacheByte&~Mask)|(PixelData&Mask);
      break;
    case LCD_DRAWMODE_TRANS:
      if (COLOR)
        CacheByte |= (PixelData&Mask);
      else
        CacheByte &= ~(PixelData&Mask);
      break;
    case LCD_DRAWMODE_XOR:
      CacheByte ^= (PixelData&Mask);
      break;
    }
    LCD_WRITE(Adr++,CacheByte);
  }
}

#else


/*
        *********************************************************
        *                                                       *
        *          Draw Bitmap 1 BPP, no optimization           *
        *                                                       *
        *********************************************************
*/

static void  DrawBitLine1BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  PIXELCOLOR pixels;
  PIXELCOLOR Index0 = *(pTrans+0);
  PIXELCOLOR Index1 = *(pTrans+1);
/*
        Jump to right entry point
*/
  pixels = *p;
  switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)) {
  case 0:
    switch (Diff&7) {
    case 0:   
      goto WriteBit0;
    case 1:   
      goto WriteBit1;
    case 2:
      goto WriteBit2;
    case 3:
      goto WriteBit3;
    case 4:
      goto WriteBit4;
    case 5:   
      goto WriteBit5;
    case 6:   
      goto WriteBit6;
    case 7:   
      goto WriteBit7;
    }
    break;
  case LCD_DRAWMODE_TRANS:
    switch (Diff&7) {
    case 0:
      goto WriteTBit0;
    case 1:
      goto WriteTBit1;
    case 2:
      goto WriteTBit2;
    case 3:
      goto WriteTBit3;
    case 4:
      goto WriteTBit4;
    case 5:   
      goto WriteTBit5;
    case 6:   
      goto WriteTBit6;
    case 7:   
      goto WriteTBit7;
    }
    break;
  case LCD_DRAWMODE_XOR:
    switch (Diff&7) {
    case 0:   
      goto WriteXBit0;
    case 1:   
      goto WriteXBit1;
    case 2:
      goto WriteXBit2;
    case 3:
      goto WriteXBit3;
    case 4:
      goto WriteXBit4;
    case 5:   
      goto WriteXBit5;
    case 6:   
      goto WriteXBit6;
    case 7:   
      goto WriteXBit7;
    }
  }
/*
        Write with transparency