开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
LCDSLin.c
资源名称：mini2440_uCos2_ucgui.rar　[点击查看]
上传用户：zbk8730
上传日期：2017-08-10
资源大小：12168k
文件大小：44k
源码类别：

uCOS

开发平台：

C/C++

LCDSLin.c：源码内容
  1. /*
  2. *********************************************************************************************************
  3. *                                                uC/GUI
  4. *                        Universal graphic software for embedded applications
  5. *
  6. *                       (c) Copyright 2002, Micrium Inc., Weston, FL
  7. *                       (c) Copyright 2002, SEGGER Microcontroller Systeme GmbH
  8. *
  9. *              礐/GUI is protected by international copyright laws. Knowledge of the
  10. *              source code may not be used to write a similar product. This file may
  11. *              only be used in accordance with a license and should not be redistributed
  12. *              in any way. We appreciate your understanding and fairness.
  13. *
  14. ----------------------------------------------------------------------
  15. File        : LCDSLin.C
  16. Purpose     : Driver for LCDs using simple bus interface
  18. Currently supported controllers:
  20.               Toshiba T6963
  21.               Epson SED1330
  22.               Epson SED1335
  24. ----------------------------------------------------------------------
  25. Version-Date---Author-Explanation
  26. ----------------------------------------------------------------------
  27. 2.00g   020319 JE     a) Macro changed to fix NC30-error
  28. 2.00f   020204 JE     a) Hardwareinterface routines renamed:
  29.                          ...DATA -> ...A0, ...CMD -> ...A1
  30. 2.00e   011112 JE     a) LCD_INIT_CONTROLLER added to be able to
  31.                          execute LCD_X_Init during init
  32. 2.00d   010926 JE     a) Support for LCD_SWAP_XY added
  33. 2.00c   010706 JE     a) Bugfix in DrawBitLine1BPP
  34. 2.00b   010402 RS     a) LCD_GetDevCaps removed from driver
  35.                          (now LCD.c)
  36. 2.00a   008026 RS     a) Simulation interface changed
  37. 2.00    000525 JE     a) Interface changed
  38. 1.02c   000509 JE     a) Simple bus interface changed for SED133x
  39.                       b) Small changes in DrawBitLine1BPP
  40.                       c) Cache initialisation to SED133x added
  41. 1.02b   000508 JE     a) Simple bus interface changed for T6963
  42. 1.02a   000426 JE     a) Transparent mode in DrawBitLine1BPP changed
  43.                       b) Dummy LCD_L0_SetLUTEntry inserted
  44. 1.02    000426 RS     a) Changes for new LCD-driver interface V1.30
  45. 1.00a   000410 JE     a) LCD_GetDevCap changed
  46.                       b) LCD_GetpCapFunc deleted
  47.                       c) LCD_DrawBitMap changed
  48.                       d) Definition for aColorIndex changed
  49. 1.00    000407 JE     First release
  50. ---------------------------LIST OF CONFIG SWITCHES--------------------
  51. The following is a list of additional configuration switches for this
  52. driver. These switches might not be listed in the manual, because
  53. the manual mainly covers the general config switches which are
  54. supported by all drivers.
  55. ----------------------------------------------------------------------
  56. define ----------------------Explanation------------------------------
  57. LCD_OPTIMIZE                 Controls the use of optimized routines.
  58. ----------------------------------------------------------------------
  59. Known problems or limitations with current version
  60. ----------------------------------------------------------------------
  61. none
  62. ---------------------------END-OF-HEADER------------------------------
  63. */
  65. #include <string.h>             /* for memset */
  66. #include <stddef.h>           /* needed for definition of NULL */
  67. #include "LCD_Private.h"      /* private modul definitions & config */
  68. #include "GUI_Private.h"
  69. #include "GUIDebug.h"
  70. #include "LCD_0.h"            /* Defines for first display */
  72. #if (LCD_CONTROLLER == 6963) || (LCD_CONTROLLER == 1330) || (LCD_CONTROLLER == 1335) 
  73.       && (!defined(WIN32) | defined(LCD_SIMCONTROLLER))
  77. /*
  78.   ********************************************************************
  79.   *                                                                  *
  80.   *                Conversion table
  81.   *                                                                  *
  82.   ********************************************************************
  83. */
  85. static const LCD_PIXELINDEX LCD_ConversionTable[2] = {0, 1};
  87. /*
  88.         *********************************************************
  89.         *                                                       *
  90.         *           Defaults for configuration                  *
  91.         *                                                       *
  92.         *********************************************************
  94. */
  96. #ifndef LCD_OPTIMIZE
  97.   #define LCD_OPTIMIZE                  (1)
  98. #endif
  100. #ifndef LCD_CHECKBUSY
  101.   #define LCD_CHECKBUSY                 (1)
  102. #endif
  104. #ifndef LCD_INIT
  105.   #define LCD_INIT()
  106. #endif
  108. #ifndef LCD_WATCHDOG_TRIGGERCNT
  109.   #define LCD_WATCHDOG_TRIGGERCNT       (0)
  110. #endif
  112. #ifndef LCD_KICK_WATCHDOG
  113.   #define LCD_KICK_WATCHDOG()
  114. #endif
  116. #ifndef LCD_CACHE
  117.   #define  LCD_CACHE                    (1)
  118. #endif
  120. #ifndef LCD_SUPPORT_REFRESH
  121.   #define  LCD_SUPPORT_REFRESH LCD_CACHE
  122. #endif
  124. #ifndef LCD_REVERSEMODE_SUPPORT
  125.   #define LCD_REVERSEMODE_SUPPORT       (0)
  126. #endif
  128. #ifndef LCD_SUPPORT_VERIFY
  129.   #define LCD_SUPPORT_VERIFY            (0)
  130. #endif
  132. /* Switch for support of multiple pages.
  133.  Only available with certain LCD-controllers */
  134. #ifndef LCD_SUPPORT_PAGING
  135.   #define LCD_SUPPORT_PAGING            (0)
  136. #endif
  138. #ifndef LCD_SCHEDULE_CNT
  139.   #define LCD_SCHEDULE_CNT              (0)
  140. #endif
  142. #ifndef LCD_NUM_CONTROLLERS
  143.   #define LCD_NUM_CONTROLLERS           (1)
  144. #endif
  146. #ifndef LCD_SUPPORT_CHECKINIT
  147.   #define LCD_SUPPORT_CHECKINIT         (0)
  148. #endif
  150. /* Switch support for the LCD_CopyRect function of the driver */
  151. #ifndef  LCD_SUPPORT_COPYRECT
  152.   #define  LCD_SUPPORT_COPYRECT         (1)
  153. #endif
  155. #ifndef LCD_INIT_CONTROLLER
  156.   #define LCD_INIT_CONTROLLER()
  157. #endif
  160. /*
  161.         *********************************************************
  162.         *                                                       *
  163.         *          Internal types                               *
  164.         *                                                       *
  165.         *********************************************************
  166. */
  168. #if LCD_BITSPERPIXEL == 1
  169.   #define PIXELCOLOR U8
  170. #else
  171.   #error LCD_BITSPERPIXEL != 1 not supported
  172. #endif
  175. /*
  176.         *********************************************************
  177.         *                                                       *
  178.         *      Configuration switch checking                    *
  179.         *                                                       *
  180.         *********************************************************
  182. Please be aware that not all configuration errors can be captured !
  184. */
  186. /* Check number of controllers */
  187. #if (LCD_NUM_CONTROLLERS != 1)
  188.   #error "Only 1 controller supported by this driver"
  189. #endif
  191. /*
  192.         *********************************************************
  193.         *
  194.         *           Defines for simulation
  195.         *
  196.         *********************************************************
  197. */
  199. #ifdef WIN32
  200.   #undef LCD_WRITE_A0
  201.   #undef LCD_WRITE_A1
  202.   #undef LCD_READ_A0
  203.   #undef LCD_READ_A1
  204.   void SIM_WriteA1C0(U8 Data);
  205.   void SIM_WriteA0C0(U8 cmd);
  206.   U8   SIM_ReadA1C0(void);
  207.   U8   SIM_ReadA0C0(void);
  208.   #define LCD_WRITE_A1(Data) SIM_WriteA1C0(Data) 
  209.   #define LCD_WRITE_A0(cmd)  SIM_WriteA0C0(cmd)
  210.   #define LCD_READ_A1()      SIM_ReadA1C0()
  211.   #define LCD_READ_A0()      SIM_ReadA0C0()
  212. #endif
  214. /*
  215.         *********************************************************
  216.         *                                                       *
  217.         * Standard variables for driver                         *
  218.         *                                                       *
  219.         *********************************************************
  220. */
  222. static U8 Cache[((LCD_XSIZE_PHYS+7)>>3)*LCD_YSIZE_PHYS];
  224. #if LCD_WATCHDOG_TRIGGERCNT
  225.   int WatchdogTriggerCnt;
  226. #endif
  228. #if LCD_SUPPORT_VERIFY
  229.   static int ErrCnt;
  230.   static int ErrStat;
  231. #endif
  235. /*
  236.         *********************************************************
  237.         *                                                       *
  238.         *          Support for Segment/COMLUTs                  *
  239.         *                                                       *
  240.         *********************************************************
  241. */
  243. /* For compatibility with older configs, define defaults */
  244. #ifndef LCD_SUPPORT_COMTRANS
  245.   #define LCD_SUPPORT_COMTRANS 0
  246. #endif
  247. #ifndef LCD_SUPPORT_SEGTRANS
  248.   #define LCD_SUPPORT_SEGTRANS 0
  249. #endif
  251. #if LCD_SUPPORT_COMTRANS
  252.   extern LCD_TYPE_COMTRANS LCD__aLine2Com0[LCD_LASTCOM0-LCD_FIRSTCOM0+1];
  253. #endif
  255. #if LCD_SUPPORT_SEGTRANS
  256.   extern LCD_TYPE_SEGTRANS LCD__aRow2Seg0[LCD_LASTSEG0-LCD_FIRSTSEG0+1];
  257. #endif
  259. /*
  260.         *********************************************************
  261.         *                                                       *
  262.         *       Macros for internal use                         *
  263.         *                                                       *
  264.         *********************************************************
  265. */
  267. #if (LCD_SUPPORT_COMTRANS)
  268.   #if (LCD_MIRROR_Y)
  269.     #error LCD_MIRROR_Y not supported with COMTrans !
  270.   #endif
  271.   #if (LCD_MIRROR_X)
  272.     #error LCD_MIRROR_X not supported with COMTrans !
  273.   #endif
  274. #endif
  276. #if (!LCD_SUPPORT_COMTRANS && !LCD_SUPPORT_SEGTRANS)
  277.   #if   (!LCD_MIRROR_X && !LCD_MIRROR_Y && !LCD_SWAP_XY) 
  278.     #define SETPIXEL(x, y, c)  _SetPixel(x, y, c)
  279.     #define GETPIXEL(x, y)     _GetPixel(x,y)
  280.     #define XORPIXEL(x, y)     XorPixel(x,y)
  281.   #elif (!LCD_MIRROR_X && !LCD_MIRROR_Y &&  LCD_SWAP_XY) 
  282.     #define SETPIXEL(x, y, c)  _SetPixel(y, x, c)
  283.     #define GETPIXEL(x, y)     _GetPixel(y, x)
  284.     #define XORPIXEL(x, y)      XorPixel(y, x)
  285.   #elif (!LCD_MIRROR_X &&  LCD_MIRROR_Y && !LCD_SWAP_XY) 
  286.     #define SETPIXEL(x, y, c)  _SetPixel(x, LCD_YSIZE-1-(y), c)
  287.     #define GETPIXEL(x, y)     _GetPixel(x, LCD_YSIZE-1-(y))
  288.     #define XORPIXEL(x, y)     XorPixel (x, LCD_YSIZE-1-(y))
  289.   #elif (!LCD_MIRROR_X &&  LCD_MIRROR_Y &&  LCD_SWAP_XY) 
  290.     #define SETPIXEL(x, y, c)  _SetPixel(LCD_YSIZE-1-(y), x, c)
  291.     #define GETPIXEL(x, y)     _GetPixel(LCD_YSIZE-1-(y), x)
  292.     #define XORPIXEL(x, y)      XorPixel(LCD_YSIZE-1-(y), x)
  293.   #elif ( LCD_MIRROR_X && !LCD_MIRROR_Y && !LCD_SWAP_XY) 
  294.     #define SETPIXEL(x, y, c)  _SetPixel(LCD_XSIZE-1-(x), y, c)
  295.     #define GETPIXEL(x, y)     _GetPixel(LCD_XSIZE-1-(x), y)
  296.     #define XORPIXEL(x, y)     XorPixel (LCD_XSIZE-1-(x), y)
  297.   #elif ( LCD_MIRROR_X && !LCD_MIRROR_Y &&  LCD_SWAP_XY) 
  298.     #define SETPIXEL(x, y, c)  _SetPixel(LCD_YSIZE-1-(y), x, c)
  299.     #define GETPIXEL(x, y)     _GetPixel(LCD_YSIZE-1-(y), x)
  300.     #define XORPIXEL(x, y)      XorPixel(LCD_YSIZE-1-(y), x)
  301.   #elif ( LCD_MIRROR_X &&  LCD_MIRROR_Y && !LCD_SWAP_XY) 
  302.     #define SETPIXEL(x, y, c)  _SetPixel(LCD_XSIZE-1-(x), LCD_YSIZE-1-(y), c)
  303.     #define GETPIXEL(x, y)     _GetPixel(LCD_XSIZE-1-(x), LCD_YSIZE-1-(y))
  304.     #define XORPIXEL(x, y)     XorPixel (LCD_XSIZE-1-(x), LCD_YSIZE-1-(y))
  305.   #elif ( LCD_MIRROR_X &&  LCD_MIRROR_Y &&  LCD_SWAP_XY) 
  306.     #error This combination of mirroring/swapping not yet supported
  307.   #endif
  308. #elif (LCD_SUPPORT_COMTRANS && !LCD_SUPPORT_SEGTRANS)
  309.   #if (!LCD_SWAP_XY)
  310.     #define SETPIXEL(x, y, c)  _SetPixel(x,LCD__aLine2Com0[y], c)
  311.     #define GETPIXEL(x, y)     _GetPixel(x,LCD__aLine2Com0[y])
  312.     #define XORPIXEL(x, y)      XorPixel(x,LCD__aLine2Com0[y])
  313.   #else
  314.     #define SETPIXEL(x, y, c)  _SetPixel(y,LCD__aLine2Com0[x], c)
  315.     #define GETPIXEL(x, y)     _GetPixel(y,LCD__aLine2Com0[x])
  316.     #define XORPIXEL(x, y)      XorPixel(y,LCD__aLine2Com0[x])
  317.   #endif
  318. #elif (!LCD_SUPPORT_COMTRANS && LCD_SUPPORT_SEGTRANS)
  319.   #if (!LCD_SWAP_XY)
  320.     #define SETPIXEL(x, y, c)  _SetPixel(LCD__aRow2Seg0[x],y, c)
  321.     #define GETPIXEL(x, y)     _GetPixel(LCD__aRow2Seg0[x],y)
  322.     #define XORPIXEL(x, y)      XorPixel(LCD__aRow2Seg0[x],y)
  323.   #else
  324.     #define SETPIXEL(x, y, c)  _SetPixel(LCD__aRow2Seg0[y],x, c)
  325.     #define GETPIXEL(x, y)     _GetPixel(LCD__aRow2Seg0[y],x)
  326.     #define XORPIXEL(x, y)      XorPixel(LCD__aRow2Seg0[y],x)
  327.   #endif
  328. #elif (LCD_SUPPORT_COMTRANS && LCD_SUPPORT_SEGTRANS)
  329.   #if (!LCD_SWAP_XY)
  330.     #define SETPIXEL(x, y, c)  _SetPixel(LCD__aRow2Seg0[x],LCD__aLine2Com0[y], c)
  331.     #define GETPIXEL(x, y)     _GetPixel(LCD__aRow2Seg0[x],LCD__aLine2Com0[y])
  332.     #define XORPIXEL(x, y)      XorPixel(LCD__aRow2Seg0[x],LCD__aLine2Com0[y])
  333.   #else
  334.     #define SETPIXEL(x, y, c)  _SetPixel(LCD__aRow2Seg0[y],LCD__aLine2Com0[x], c)
  335.     #define GETPIXEL(x, y)     _GetPixel(LCD__aRow2Seg0[y],LCD__aLine2Com0[x])
  336.     #define XORPIXEL(x, y)      XorPixel(LCD__aRow2Seg0[y],LCD__aLine2Com0[x])
  337.   #endif
  338. #else
  339.   #error This combination of switches not yet supported
  340. #endif
  342. #define XY2OFF(x,y) ((x>>3)+y*((LCD_XSIZE_PHYS+7)>>3))
  343. #define BKCOLOR LCD_BKCOLORINDEX
  344. #define   COLOR LCD_COLORINDEX
  349. /*
  350.         *********************************************************
  351.         *                                                       *
  352.         *       ID translation table                            *
  353.         *                                                       *
  354.         *********************************************************
  356. This table contains 0, 1, 2, ... and serves as translation table for DDBs
  358. */
  360. static const U8 TransId[] = { 0,1 };
  363. /*
  364.         *********************************************************
  365.         *                                                       *
  366.         *       LCD Access                                      *
  367.         *                                                       *
  368.         *********************************************************
  369. */
  371. int LCD_Adr;
  373. #if (!LCD_CHECKBUSY)
  374.   #define LCD_WAIT()
  375. #endif
  377. static U8 result; /* Possibly needed for access macro */
  380. /*
  381.         *********************************************************
  382.         *                                                       *
  383.         *       LCD Access Controller SED133x                   *
  384.         *                                                       *
  385.         *********************************************************
  386. */
  388. #if (LCD_CONTROLLER == 1330) 
  389.   ||(LCD_CONTROLLER == 1335)
  391. /* Remap ...A0, ...A1 -> ...CMD, ...DATA */
  393. #define LCD_READCMD0    LCD_READ_A0
  394. #define LCD_READDATA0   LCD_READ_A1
  395. #define LCD_WRITECMD0   LCD_WRITE_A1
  396. #define LCD_WRITEDATA0  LCD_WRITE_A0
  398. #ifndef LCD_EXTENDED_WAIT
  399.   #define LCD_EXTENDED_WAIT 1
  400. #endif
  402. #ifndef LCD_WAIT
  403.   #define LCD_WAIT()                
  404.     while (!(LCD_READCMD0()&0x40)); 
  405.     while (  LCD_READCMD0()&0x40) ;
  406. #endif
  407. #if LCD_EXTENDED_WAIT
  408.   #define LCD_WRITECMD(cmd)      { LCD_WAIT(); LCD_WRITECMD0(cmd);  }
  409.   #define LCD_WRITEDATA(Data)    { LCD_WAIT(); LCD_WRITEDATA0(Data);}
  410. #else
  411.   #define LCD_WRITECMD(cmd)      { LCD_WRITECMD0(cmd);  }
  412.   #define LCD_WRITEDATA(Data)    { LCD_WRITEDATA0(Data);}
  413. #endif
  415. #define GSTART (0x0)
  416. #if (LCD_YSIZE_PHYS >128)
  417.   #define TSTART 30000
  418. #else
  419.   #define TSTART 7000
  420. #endif
  422. static void LCD_SetSystem(void) {
  423.   LCD_WRITECMD (0x40);
  424.   LCD_WRITEDATA(0x30);                 /* P1                                    */
  425.   LCD_WRITEDATA(0x87);                 /* P2 : FX : hor. char size-1            */
  426.   LCD_WRITEDATA(0x7);                  /* P3 : FY : ver. char size-1 (not imp.) */
  427.   LCD_WRITEDATA(((LCD_XSIZE_PHYS+7)>>3)-1); /* P4 : Characters per row               */
  428.   LCD_WRITEDATA(0x4a);                 /* P5 : Timing charcters per row         */
  429.   LCD_WRITEDATA(LCD_YSIZE_PHYS-1);          /* P6 : Number of lines per screen       */
  430.   LCD_WRITEDATA((LCD_XSIZE_PHYS+7)>>3);     /* P7 : Address pitch low                */
  431.   LCD_WRITEDATA(0x00);                 /* P8 : Address pitch high               */
  432. }
  434. static void LCD_SetScroll(int Adr) {
  435.   LCD_WRITECMD(0x44);
  436.   LCD_WRITEDATA(TSTART&255);               /* address of screen 1 (text)            */
  437.   LCD_WRITEDATA(TSTART>>8);
  438.   LCD_WRITEDATA((LCD_YSIZE_PHYS)-1);
  439.   LCD_WRITEDATA(Adr);                  /* address of screen 2 (graphic)         */
  440.   LCD_WRITEDATA(Adr>>8);
  441.   LCD_WRITEDATA((LCD_YSIZE_PHYS)-1);
  442. }
  444. static void LCD_SetAdr(int Off) {
  445.   LCD_Adr=Off;
  446.   #if (!LCD_EXTENDED_WAIT)
  447.     LCD_WAIT();
  448.   #endif
  449.   LCD_WRITECMD (0x46);
  450.   LCD_WRITEDATA(Off&255);
  451.   LCD_WRITEDATA(Off>>8);
  452. }
  454. #define LCD_SETADR(Off) LCD_SetAdr(Off)
  456. static void LCD_Write1(char Byte) {
  457.   #if (!LCD_EXTENDED_WAIT)
  458.     LCD_WAIT();
  459.   #endif
  460.   LCD_WRITECMD (0x42);
  461.   LCD_WRITEDATA(Byte);
  462.   LCD_Adr++;
  463. }
  465. #define LCD_WRITE1(Byte) LCD_Write1(Byte)
  467. /* LCD_L0_ReInit */
  468. void LCD_L0_ReInit(void) {
  469.   int i;
  470.   LCD_INIT_CONTROLLER();
  471.   LCD_SetSystem();
  472.   LCD_SetScroll(GSTART) ;
  473.   LCD_WRITECMD (0x4c);                 /* Set cursor move direction             */
  474.   LCD_WRITECMD (0x5a);                 /* HDOT SCR : Set horiz. scroll position */
  475.   LCD_WRITEDATA(0);
  476.   LCD_WRITECMD (0x5b);                 /* OVLAY                                 */
  477.   LCD_WRITEDATA(1);
  478.   /* Clear display memory */
  479.   LCD_SETADR(0);
  480.   LCD_WRITECMD (0x42);
  481.   #if (LCD_YSIZE_PHYS >128)
  482.     for (i=0; i<32000; i++)
  483.   #else
  484.     for (i=0; i<8000; i++)
  485.   #endif
  486.       LCD_WRITEDATA(0);
  487.   #if (LCD_REVERSE)
  488.     LCD_SETADR(GSTART);
  489.     LCD_WRITECMD (0x42);
  490.     for (i=GSTART; i<GSTART+((LCD_XSIZE_PHYS+7)>>3)*LCD_YSIZE_PHYS; i++)
  491.       LCD_WRITEDATA(0xff);
  492.   #endif
  493.   if(COLOR)
  494.     memset(Cache,0xff,sizeof(Cache));
  495.   else
  496.     memset(Cache,0x0,sizeof(Cache));
  497.   LCD_WRITECMD (0x59);                 /* Display on                            */
  498.   LCD_WRITEDATA(0x14);                 /* All screens on, curosr off            */
  499. }
  501. /* LCD_FirstInit */
  502. static void LCD_FirstInit(void) {
  503.   LCD_L0_ReInit();
  504. }
  506. #endif /* SED133x */
  509. /*
  510.         *********************************************************
  511.         *                                                       *
  512.         *       LCD Access Controller T6963                     *
  513.         *                                                       *
  514.         *********************************************************
  515. */
  517. #if (LCD_CONTROLLER == 6963)
  519. /* Remap ...A0, ...A1 -> ...CMD, ...DATA */
  521. #define LCD_READCMD0    LCD_READ_A1
  522. #define LCD_READDATA0   LCD_READ_A0
  523. #define LCD_WRITECMD0   LCD_WRITE_A1
  524. #define LCD_WRITEDATA0  LCD_WRITE_A0
  526. #ifndef LCD_WAIT
  527.   #define LCD_WAIT() while ((LCD_READ_A1()&3)!=3) /* Do not use LCD_READCMD0 to fix NC30-problem (JE) */
  528. #endif
  530. #define LCD_WRITECMD(cmd)      { LCD_WAIT(); LCD_WRITECMD0(cmd);  }
  531. #define LCD_WRITEDATA(Data)    { LCD_WAIT(); LCD_WRITEDATA0(Data);}
  533. /* Access Macros */
  534. #define LCD_READDATA()        
  535.   LCD_WRITECMD(0xC5);         
  536.   return LCD_DATA0;
  538. #define LCD_SETADR(Adr)       
  539.   LCD_WRITEDATA((U8)Adr);     
  540.   LCD_WRITEDATA((U8)(Adr>>8));
  541.   LCD_WRITECMD(0x24);         
  542.   LCD_Adr=Adr;
  544. #define LCD_WRITE1(Byte)      
  545.   LCD_WRITEDATA(Byte);        
  546.   LCD_WRITECMD(0xC0);         
  547.   LCD_Adr++;
  550. /* LCD_L0_ReInit */
  551. #define LCD_RAMSIZE (0x2000)
  552. #define LCD_GSTART  (0x0)
  553. #define LCD_XSIZEB  ((LCD_XSIZE_PHYS+7)>>3)
  554. #define LCD_TSTART  (LCD_RAMSIZE-(LCD_XSIZEB)-(LCD_YSIZE_PHYS>>3))
  556. void LCD_L0_ReInit(void) {
  557.   LCD_WRITECMD(0x81);           /* SetModeXor */
  559.   LCD_WRITEDATA((U8)LCD_TSTART);/* SetTextAdr */
  560.   LCD_WRITEDATA((U8)(LCD_TSTART>>8));
  561.   LCD_WRITECMD(0x40);
  563.   LCD_WRITEDATA(1);             /* SetTextArea */
  564.   LCD_WRITEDATA(1>>8);
  565.   LCD_WRITECMD(0x41);
  567.   LCD_WRITECMD(0x9C);           /* SetTextGraph */
  569.   LCD_WRITEDATA(LCD_GSTART);    /* SetGraphAdr */
  570.   LCD_WRITEDATA(LCD_GSTART>>8);
  571.   LCD_WRITECMD(0x42);
  573.   LCD_WRITEDATA(LCD_XSIZEB);    /* SetGraphArea */
  574.   LCD_WRITEDATA(LCD_XSIZEB>>8);
  575.   LCD_WRITECMD(0x43);
  576. }
  579. /* LCD_FirstInit */
  580. void LCD_FirstInit(void) {
  581.   int i;
  582.   LCD_INIT_CONTROLLER();
  583.   LCD_SETADR(0);
  584.   for (i=0; i<100; i++) {
  585.     LCD_WRITE1(0xff);
  586.   }
  587.   LCD_SETADR(0);
  588.   for (i=0;i<LCD_RAMSIZE;i++) {
  589.     LCD_WRITE1(0x0);
  590.   }
  591. }
  593. #endif /* T6963 */
  596. /*
  597.         *********************************************************
  598.         *                                                       *
  599.         *       Write 1 byte and manage cache                   *
  600.         *                                                       *
  601.         *********************************************************
  602. */
  604. static void LCD_Write(int Adr, U8 Byte) {
  605.   if (Cache[Adr]!=Byte) {
  606.     Cache[Adr]=Byte;
  607.     if (LCD_Adr!=Adr) {
  608.       LCD_SETADR(Adr);
  609.     }
  610.     LCD_WRITE1(Byte);
  611.   }
  612. }
  614. #define LCD_WRITE(Adr,Byte) LCD_Write(Adr,Byte);
  617. /*
  618.         *********************************************************
  619.         *                                                       *
  620.         *       Internal set pixel routines                     *
  621.         *                                                       *
  622.         *********************************************************
  623. */
  625. static void _SetPixel(int x, int y, LCD_PIXELINDEX c) {
  626.   U8 Mask=1<<(7-(x&7));
  627.   int Adr=XY2OFF(x,y);
  628.   U8 CacheByte=Cache[Adr];
  629.   if (c)
  630.     CacheByte|= Mask;
  631.   else
  632.     CacheByte&=~Mask;
  633.   LCD_WRITE(Adr,CacheByte)
  634. }
  636. static PIXELCOLOR _GetPixel(int x, int y) {
  637.   int Adr=XY2OFF(x,y);
  638.   U8 Mask=1<<(7-(x&7));
  639.   return (Cache[Adr]&Mask) ? 1 : 0;
  640. }
  642. static void XorPixel   (int x, int y) {
  643.   LCD_PIXELINDEX Index = _GetPixel(x,y);
  644.   _SetPixel(x,y, LCD_NUM_COLORS-1-Index);
  645. }
  647. /*
  648.         *********************************************************
  649.         *                                                       *
  650.         *       LCD_L0_SetPixelIndex                            *
  651.         *                                                       *
  652.         *********************************************************
  654. Purpose:  This routine is called by emWin. It writes 1 pixel into the
  655.           display.
  657. */
  659. void LCD_L0_SetPixelIndex(int x, int y, int ColorIndex) {
  660.   SETPIXEL(x, y, ColorIndex);
  661. }
  664. /*
  665.         *********************************************************
  666.         *                                                       *
  667.         *       LCD_L0_XorPixel                                 *
  668.         *                                                       *
  669.         *********************************************************
  671. Purpose:  This routine is called by emWin. It writes 1 pixel into the
  672.           display.
  674. */
  676. void LCD_L0_XorPixel(int x, int y) {
  677.   XORPIXEL(x, y);
  678. }
  681. /*
  682.         *********************************************************
  683.         *                                                       *
  684.         *          LCD_L0_DrawHLine optimized                   *
  685.         *                                                       *
  686.         *********************************************************
  687. */
  689. #if (LCD_OPTIMIZE)               
  690.       && (!LCD_SWAP_XY)          
  691.       && (!LCD_MIRROR_X)         
  692.       && (!LCD_MIRROR_Y)         
  693.       && (!LCD_SUPPORT_COMTRANS) 
  694.       && (!LCD_SUPPORT_SEGTRANS)
  696. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  697.   register int Off = XY2OFF(x0,y);
  698.   int iByte = x0>>3;
  699.   int Byte1 = x1>>3;
  700.   U8 Mask =    0xff   >> (x0&7);
  701.   U8 EndMask = 0xff80 >> (x1&7);
  702.   U8 Data;
  703.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  704.     for (; iByte<Byte1; iByte++) {
  705.       Data = Cache[Off];
  706.       Data ^= Mask; 
  707.       LCD_WRITE(Off++,Data);
  708.       Mask = 0xff;
  709.     }
  710.     Mask &= EndMask;
  711.     Data = Cache[Off];
  712.     Data ^= Mask; 
  713.     LCD_WRITE(Off++,Data);
  714.   } else {                                  /* Clear pixels in line */
  715.     int NumBytes = Byte1-iByte;
  716.     if (COLOR==0) {
  717.       if (NumBytes) {
  718.         Data = Cache[Off] & (~Mask);
  719.         LCD_WRITE(Off++,Data);
  720.         NumBytes--;
  721.       /* Fill bytes in 2 loops for speed reasons ... */
  722.         for (; NumBytes>=4; NumBytes-=4) {
  723.           LCD_WRITE(Off++,0);
  724.           LCD_WRITE(Off++,0);
  725.           LCD_WRITE(Off++,0);
  726.           LCD_WRITE(Off++,0);
  727.         }
  728.         for (; NumBytes; NumBytes--) {
  729.           LCD_WRITE(Off++,0);
  730.         }
  731.         Mask = 0xff;
  732.       }
  733.       Mask &= EndMask;
  734.       Data = Cache[Off];
  735.       Data &= ~Mask; 
  736.       LCD_WRITE(Off++,Data);
  737.     } else {                                  /* Set pixels in line */
  738.       if (NumBytes) {
  739.         Data = Cache[Off] | Mask; 
  740.         LCD_WRITE(Off++,Data);
  741.         NumBytes--;
  742.       /* Fill bytes in 2 loops for speed reasons ... */
  743.         for (; NumBytes>=4; NumBytes-=4) {
  744.           LCD_WRITE(Off++,0xff);
  745.           LCD_WRITE(Off++,0xff);
  746.           LCD_WRITE(Off++,0xff);
  747.           LCD_WRITE(Off++,0xff);
  748.         }
  749.         for (; NumBytes; NumBytes--) {
  750.           LCD_WRITE(Off++,0xff);
  751.         }
  752.         Mask = 0xff;
  753.       }
  754.       Mask &= EndMask;
  755.       Data = Cache[Off] | Mask; 
  756.       LCD_WRITE(Off++,Data);
  757.     }
  758.   }
  759. }
  761. #else
  763. /*
  764.         *********************************************************
  765.         *                                                       *
  766.         *          LCD_L0_DrawHLine unoptimized                 *
  767.         *                                                       *
  768.         *********************************************************
  769. */
  771. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  772.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  773.     while (x0 <= x1) {
  774.       XORPIXEL(x0, y);
  775.       x0++;
  776.     }
  777.   } else {
  778.     while (x0 <= x1) {
  779.       SETPIXEL(x0, y, COLOR);
  780.       x0++;
  781.     }
  782.   }
  783. }
  785. #endif
  788. /*
  789.         *********************************************************
  790.         *                                                       *
  791.         *          LCD_L0_DrawVLine                             *
  792.         *                                                       *
  793.         *********************************************************
  794. */
  796. void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  797.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  798.     while (y0 <= y1) {
  799.       XORPIXEL(x, y0);
  800.       y0++;
  801.     }
  802.   } else {
  803.     while (y0 <= y1) {
  804.       SETPIXEL(x, y0, COLOR);
  805.       y0++;
  806.     }
  807.   }
  808. }
  811. /*
  812.         *********************************************************
  813.         *                                                       *
  814.         *          LCD_FillRect, unoptimized                    *
  815.         *                                                       *
  816.         *********************************************************
  817. */
  819. void LCD_L0_FillRect(int x0, int y0, int x1, int y1) {
  820.   for (; y0 <= y1; y0++) {
  821.     LCD_L0_DrawHLine(x0,y0, x1);
  822.   }
  823. }
  826. /*
  827.         *********************************************************
  828.         *                                                       *
  829.         *    Support for dynamic inversion of entire LCD        *
  830.         *                                                       *
  831.         *********************************************************
  833. */
  835. #if LCD_REVERSEMODE_SUPPORT
  837. void LCD_SetNormalDispMode    (void) {
  838. }
  839. void LCD_SetReverseDispMode   (void) {
  840. }
  842. #endif
  845. /*
  846.         *********************************************************
  847.         *                                                       *
  848.         *          Draw Bitmap 1 BPP, optimized                 *
  849.         *                                                       *
  850.         *********************************************************
  851. */
  853. #if (LCD_OPTIMIZE)               
  854.       && (!LCD_SWAP_XY)          
  855.       && (!LCD_MIRROR_X)         
  856.       && (!LCD_MIRROR_Y)         
  857.       && (!LCD_SUPPORT_COMTRANS) 
  858.       && (!LCD_SUPPORT_SEGTRANS)
  860. static void  DrawBitLine1BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  861.   LCD_PIXELINDEX Index0 = *(pTrans+0);
  862.   LCD_PIXELINDEX Index1 = *(pTrans+1);
  863.   x+=Diff;
  864.   if ((Index0==Index1) & (!(GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)))) {
  865.     LCD_PIXELINDEX ColorIndexOld= COLOR;
  866.     COLOR = Index0;
  867.     LCD_L0_DrawHLine(x,y,x+xsize-1);
  868.     COLOR = ColorIndexOld;
  869.     return;
  870.   }
  871.   {
  872.     int Adr=XY2OFF(x,y);
  873.     int x1 = x+xsize-1;
  874.     U8 Mask    = 0xff   >> (x &7);
  875.     U8 EndMask = 0xff80 >> (x1&7);
  876.     U8 CacheByte;
  877.     U16 PixelData;
  878.     int NumBytes = (x1>>3) - (x>>3);
  879.     if (NumBytes) {
  880.       CacheByte=Cache[Adr];
  881.       PixelData   = (*(p+1) | ((*p)<<8));
  882.       PixelData >>= (8+(x&7)-(Diff&7));
  883.       switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)) {
  884.       case 0:
  885.         if (!COLOR)
  886.           PixelData ^= 255;
  887.         CacheByte = (CacheByte&~Mask)|(PixelData&Mask);
  888.         break;
  889.       case LCD_DRAWMODE_TRANS:
  890.         if (COLOR)
  891.           CacheByte |= (PixelData&Mask);
  892.         else
  893.           CacheByte &= ~(PixelData&Mask);
  894.         break;
  895.       case LCD_DRAWMODE_XOR:
  896.         CacheByte ^= (PixelData&Mask);
  897.         break;
  898.       }
  899.       LCD_WRITE(Adr++,CacheByte);
  900.       { 
  901.         int DiffOld = Diff;
  902.         Diff+= 8-(x&7); 
  903.         if ((DiffOld&~7) != (Diff&~7))
  904.           p++;
  905.       }
  906.       x=0;
  907.       NumBytes--;
  908.       for (; NumBytes; NumBytes--) {
  909.         PixelData   = (*(p+1) | ((*p)<<8));
  910.         PixelData >>= (8-(Diff&7));
  911.         p++;
  912.         switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)) {
  913.         case 0:
  914.           if (!COLOR)
  915.             PixelData ^= 255;
  916.           CacheByte=PixelData&255;
  917.           break;
  918.         case LCD_DRAWMODE_TRANS:
  919.           CacheByte=Cache[Adr];
  920.           if (COLOR)
  921.             CacheByte |= PixelData;
  922.           else
  923.             CacheByte &= ~PixelData;
  924.           break;
  925.         case LCD_DRAWMODE_XOR:
  926.           CacheByte=Cache[Adr] ^ PixelData;
  927.           break;
  928.         }
  929.         LCD_WRITE(Adr++,CacheByte);
  930.       }
  931.       Mask = 0xff;
  932.     }
  933.     PixelData   = (*(p+1) | ((*p)<<8));
  934.     PixelData >>= (8+(x&7)-(Diff&7));
  935.     Mask &= EndMask;
  936.     CacheByte = Cache[Adr];
  937.     switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)) {
  938.     case 0:
  939.       if (!COLOR)
  940.         PixelData ^= 255;
  941.       CacheByte = (CacheByte&~Mask)|(PixelData&Mask);
  942.       break;
  943.     case LCD_DRAWMODE_TRANS:
  944.       if (COLOR)
  945.         CacheByte |= (PixelData&Mask);
  946.       else
  947.         CacheByte &= ~(PixelData&Mask);
  948.       break;
  949.     case LCD_DRAWMODE_XOR:
  950.       CacheByte ^= (PixelData&Mask);
  951.       break;
  952.     }
  953.     LCD_WRITE(Adr++,CacheByte);
  954.   }
  955. }
  957. #else
  960. /*
  961.         *********************************************************
  962.         *                                                       *
  963.         *          Draw Bitmap 1 BPP, no optimization           *
  964.         *                                                       *
  965.         *********************************************************
  966. */
  968. static void  DrawBitLine1BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  969.   PIXELCOLOR pixels;
  970.   PIXELCOLOR Index0 = *(pTrans+0);
  971.   PIXELCOLOR Index1 = *(pTrans+1);
  972. /*
  973.         Jump to right entry point
  974. */
  975.   pixels = *p;
  976.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)) {
  977.   case 0:
  978.     switch (Diff&7) {
  979.     case 0:   
  980.       goto WriteBit0;
  981.     case 1:   
  982.       goto WriteBit1;
  983.     case 2:
  984.       goto WriteBit2;
  985.     case 3:
  986.       goto WriteBit3;
  987.     case 4:
  988.       goto WriteBit4;
  989.     case 5:   
  990.       goto WriteBit5;
  991.     case 6:   
  992.       goto WriteBit6;
  993.     case 7:   
  994.       goto WriteBit7;
  995.     }
  996.     break;
  997.   case LCD_DRAWMODE_TRANS:
  998.     switch (Diff&7) {
  999.     case 0:
  1000.       goto WriteTBit0;
  1001.     case 1:
  1002.       goto WriteTBit1;
  1003.     case 2:
  1004.       goto WriteTBit2;
  1005.     case 3:
  1006.       goto WriteTBit3;
  1007.     case 4:
  1008.       goto WriteTBit4;
  1009.     case 5:   
  1010.       goto WriteTBit5;
  1011.     case 6:   
  1012.       goto WriteTBit6;
  1013.     case 7:   
  1014.       goto WriteTBit7;
  1015.     }
  1016.     break;
  1017.   case LCD_DRAWMODE_XOR:
  1018.     switch (Diff&7) {
  1019.     case 0:   
  1020.       goto WriteXBit0;
  1021.     case 1:   
  1022.       goto WriteXBit1;
  1023.     case 2:
  1024.       goto WriteXBit2;
  1025.     case 3:
  1026.       goto WriteXBit3;
  1027.     case 4:
  1028.       goto WriteXBit4;
  1029.     case 5:   
  1030.       goto WriteXBit5;
  1031.     case 6:   
  1032.       goto WriteXBit6;
  1033.     case 7:   
  1034.       goto WriteXBit7;
  1035.     }
  1036.   }
  1037. /*
  1038.         Write with transparency
  1039. */
  1040.   WriteTBit0:
  1041.     if (pixels&(1<<7)) SETPIXEL(x+0, y, Index1);
  1042.     if (!--xsize)
  1043.       return;
  1044.   WriteTBit1:
  1045.     if (pixels&(1<<6)) SETPIXEL(x+1, y, Index1);
  1046.     if (!--xsize)
  1047.       return;
  1048.   WriteTBit2:
  1049.     if (pixels&(1<<5)) SETPIXEL(x+2, y, Index1);
  1050.     if (!--xsize)
  1051.       return;
  1052.   WriteTBit3:
  1053.     if (pixels&(1<<4)) SETPIXEL(x+3, y, Index1);
  1054.     if (!--xsize)
  1055.       return;
  1056.   WriteTBit4:
  1057.     if (pixels&(1<<3)) SETPIXEL(x+4, y, Index1);
  1058.     if (!--xsize)
  1059.       return;
  1060.   WriteTBit5:
  1061.     if (pixels&(1<<2)) SETPIXEL(x+5, y, Index1);
  1062.     if (!--xsize)
  1063.       return;
  1064.   WriteTBit6:
  1065.     if (pixels&(1<<1)) SETPIXEL(x+6, y, Index1);
  1066.     if (!--xsize)
  1067.       return;
  1068.   WriteTBit7:
  1069.     if (pixels&(1<<0)) SETPIXEL(x+7, y, Index1);
  1070.     if (!--xsize)
  1071.       return;
  1072.     x+=8;
  1073.     pixels = *(++p);
  1074.     goto WriteTBit0;
  1076. /*
  1077.         Write without transparency
  1078. */
  1079.   WriteBit0:
  1080.     SETPIXEL(x+0, y, (pixels&(1<<7)) ? Index1 : Index0);
  1081.     if (!--xsize)
  1082.       return;
  1083.   WriteBit1:
  1084.     SETPIXEL(x+1, y, (pixels&(1<<6)) ? Index1 : Index0);
  1085.     if (!--xsize)
  1086.       return;
  1087.   WriteBit2:
  1088.     SETPIXEL(x+2, y, (pixels&(1<<5)) ? Index1 : Index0);
  1089.     if (!--xsize)
  1090.       return;
  1091.   WriteBit3:
  1092.     SETPIXEL(x+3, y, (pixels&(1<<4)) ? Index1 : Index0);
  1093.     if (!--xsize)
  1094.       return;
  1095.   WriteBit4:
  1096.     SETPIXEL(x+4, y, (pixels&(1<<3)) ? Index1 : Index0);
  1097.     if (!--xsize)
  1098.       return;
  1099.   WriteBit5:
  1100.     SETPIXEL(x+5, y, (pixels&(1<<2)) ? Index1 : Index0);
  1101.     if (!--xsize)
  1102.       return;
  1103.   WriteBit6:
  1104.     SETPIXEL(x+6, y, (pixels&(1<<1)) ? Index1 : Index0);
  1105.     if (!--xsize)
  1106.       return;
  1107.   WriteBit7:
  1108.     SETPIXEL(x+7, y, (pixels&(1<<0)) ? Index1 : Index0);
  1109.     if (!--xsize)
  1110.       return;
  1111.     x+=8;
  1112.     pixels = *(++p);
  1113.     goto WriteBit0;
  1114. /*
  1115.         Write XOR mode
  1116. */
  1117.   WriteXBit0:
  1118.     if (pixels&(1<<7))
  1119.       XORPIXEL(x+0, y);
  1120.     if (!--xsize)
  1121.       return;
  1122.   WriteXBit1:
  1123.     if (pixels&(1<<6))
  1124.       XORPIXEL(x+1, y);
  1125.     if (!--xsize)
  1126.       return;
  1127.   WriteXBit2:
  1128.     if (pixels&(1<<5))
  1129.       XORPIXEL(x+2, y);
  1130.     if (!--xsize)
  1131.       return;
  1132.   WriteXBit3:
  1133.     if (pixels&(1<<4))
  1134.       XORPIXEL(x+3, y);
  1135.     if (!--xsize)
  1136.       return;
  1137.   WriteXBit4:
  1138.     if (pixels&(1<<3))
  1139.       XORPIXEL(x+4, y);
  1140.     if (!--xsize)
  1141.       return;
  1142.   WriteXBit5:
  1143.     if (pixels&(1<<2))
  1144.       XORPIXEL(x+5, y);
  1145.     if (!--xsize)
  1146.       return;
  1147.   WriteXBit6:
  1148.     if (pixels&(1<<1))
  1149.       XORPIXEL(x+6, y);
  1150.     if (!--xsize)
  1151.       return;
  1152.   WriteXBit7:
  1153.     if (pixels&(1<<0))
  1154.       XORPIXEL(x+7, y);
  1155.     if (!--xsize)
  1156.       return;
  1157.     x+=8;
  1158.     pixels = *(++p);
  1159.     goto WriteXBit0;
  1160. }
  1162. #endif
  1165. /*
  1166.         *********************************************************
  1167.         *                                                       *
  1168.         *  Draw Bitmap 2 BPP                                    *
  1169.         *                                                       *
  1170.         *********************************************************
  1171. */
  1173. #if (LCD_MAX_LOG_COLORS > 2)
  1175. static void  DrawBitLine2BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  1176.   PIXELCOLOR pixels;
  1177. /*
  1178.         Jump to right entry point
  1179. */
  1180.   pixels = *p;
  1181.   if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) switch (Diff&3) {
  1182.   case 0:
  1183.     goto WriteTBit0;
  1184.   case 1:
  1185.     goto WriteTBit1;
  1186.   case 2:
  1187.     goto WriteTBit2;
  1188.   default:
  1189.     goto WriteTBit3;
  1190.   } else switch (Diff&3) {
  1191.   case 0:
  1192.     goto WriteBit0;
  1193.   case 1:
  1194.     goto WriteBit1;
  1195.   case 2:
  1196.     goto WriteBit2;
  1197.   default:
  1198.     goto WriteBit3;
  1199.   }
  1200. /*
  1201.         Write without transparency
  1202. */
  1203. WriteBit0:
  1204.   SETPIXEL(x+0, y, *(pTrans+(pixels>>6)));
  1205.   if (!--xsize)
  1206.     return;
  1207. WriteBit1:
  1208.   SETPIXEL(x+1, y, *(pTrans+(3&(pixels>>4))));
  1209.   if (!--xsize)
  1210.     return;
  1211. WriteBit2:
  1212.   SETPIXEL(x+2, y, *(pTrans+(3&(pixels>>2))));
  1213.   if (!--xsize)
  1214.     return;
  1215. WriteBit3:
  1216.   SETPIXEL(x+3, y, *(pTrans+(3&(pixels))));
  1217.   if (!--xsize)
  1218.     return;
  1219.   pixels = *(++p);
  1220.   x+=4;
  1221.   goto WriteBit0;
  1222. /*
  1223.         Write with transparency
  1224. */
  1225. WriteTBit0:
  1226.   if (pixels&(3<<6))
  1227.     SETPIXEL(x+0, y, *(pTrans+(pixels>>6)));
  1228.   if (!--xsize)
  1229.     return;
  1230. WriteTBit1:
  1231.   if (pixels&(3<<4))
  1232.     SETPIXEL(x+1, y, *(pTrans+(3&(pixels>>4))));
  1233.   if (!--xsize)
  1234.     return;
  1235. WriteTBit2:
  1236.   if (pixels&(3<<2))
  1237.     SETPIXEL(x+2, y, *(pTrans+(3&(pixels>>2))));
  1238.   if (!--xsize)
  1239.     return;
  1240. WriteTBit3:
  1241.   if (pixels&(3<<0))
  1242.     SETPIXEL(x+3, y, *(pTrans+(3&(pixels))));
  1243.   if (!--xsize)
  1244.     return;
  1245.   pixels = *(++p);
  1246.   x+=4;
  1247.   goto WriteTBit0;
  1248. }
  1250. #endif
  1253. /*
  1254.         *********************************************************
  1255.         *                                                       *
  1256.         *  Draw Bitmap 4 BPP                                    *
  1257.         *                                                       *
  1258.         *********************************************************
  1259. */
  1261. #if (LCD_MAX_LOG_COLORS > 4)
  1263. static void  DrawBitLine4BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  1264.   PIXELCOLOR pixels;
  1265. /*
  1266.         Jump to right entry point
  1267. */
  1268.   pixels = *p;
  1269.   if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) {
  1270.     if ((Diff&1) ==0)
  1271.       goto WriteTBit0;
  1272.     goto WriteTBit1;
  1273.   } else {
  1274.     if ((Diff&1) ==0)
  1275.       goto WriteBit0;
  1276.     goto WriteBit1;
  1277.   }
  1278. /*
  1279.         Write without transparency
  1280. */
  1281. WriteBit0:
  1282.   SETPIXEL(x+0, y, *(pTrans+(pixels>>4)));
  1283.   if (!--xsize)
  1284.     return;
  1285. WriteBit1:
  1286.   SETPIXEL(x+1, y, *(pTrans+(pixels&0xf)));
  1287.   if (!--xsize)
  1288.     return;
  1289.   x+=2;
  1290.   pixels = *(++p);
  1291.   goto WriteBit0;
  1292. /*
  1293.         Write with transparency
  1294. */
  1295. WriteTBit0:
  1296.   if (pixels>>4)
  1297.     SETPIXEL(x+0, y, *(pTrans+(pixels>>4)));
  1298.   if (!--xsize)
  1299.     return;
  1300. WriteTBit1:
  1301.   if (pixels&0xf)
  1302.     SETPIXEL(x+1, y, *(pTrans+(pixels&0xf)));
  1303.   if (!--xsize)
  1304.     return;
  1305.   x+=2;
  1306.   pixels = *(++p);
  1307.   goto WriteTBit0;
  1308. }
  1310. #endif
  1312. /*
  1313.         *********************************************************
  1314.         *                                                       *
  1315.         *  Draw Bitmap 8 BPP  (256 colors)                      *
  1316.         *                                                       *
  1317.         *      Default (no optimization)                        *
  1318.         *                                                       *
  1319.         *********************************************************
  1320. */
  1322. #if (LCD_MAX_LOG_COLORS > 16)
  1323. static void  DrawBitLine8BPP(int x, int y, U8 const*p, int xsize, const LCD_PIXELINDEX*pTrans) {
  1324.   LCD_PIXELINDEX pixel;
  1325. /*  
  1326.         Do x-Clipping
  1327. */
  1328.   if ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS)==0) {
  1329.     while (xsize > 0) {
  1330.       pixel = *p;
  1331.       SETPIXEL(x+0, y, *(pTrans+pixel));
  1332.       xsize--;
  1333.       x++;
  1334.       p++;
  1335.     }
  1336.   } else {   /* Handle transparent bitmap */
  1337.     while (xsize > 0) {
  1338.       pixel = *p;
  1339.       if (pixel)
  1340.         SETPIXEL(x+0, y, *(pTrans+pixel));
  1341.       xsize--;
  1342.       x++;
  1343.       p++;
  1344.     }
  1345.   }
  1346. }
  1348. #endif
  1351. /*
  1352.         *********************************************************
  1353.         *                                                       *
  1354.         *         Universal draw Bitmap routine                 *
  1355.         *                                                       *
  1356.         *********************************************************
  1357. */
  1358. void LCD_L0_DrawBitmap   (int x0, int y0,
  1359.                        int xsize, int ysize,
  1360.                        int BitsPerPixel, 
  1361.                        int BytesPerLine,
  1362.                        const U8* pData, int Diff,
  1363.                        const LCD_PIXELINDEX* pTrans)
  1364. {
  1365.   int i;
  1366.   if (!pTrans)
  1367.     pTrans = LCD_ConversionTable;
  1368.   /*
  1369.      Use DrawBitLineXBPP
  1370.   */
  1371.   for (i=0; i<ysize; i++) {
  1372.     switch (BitsPerPixel) {
  1373.     case 1:
  1374.       DrawBitLine1BPP(x0, i+y0, pData, Diff, xsize, pTrans);
  1375.       break;
  1376.     #if (LCD_MAX_LOG_COLORS > 2)
  1377.       case 2:
  1378.         DrawBitLine2BPP(x0, i+y0, pData, Diff, xsize, pTrans);
  1379.         break;
  1380.     #endif
  1381.     #if (LCD_MAX_LOG_COLORS > 4)
  1382.       case 4:
  1383.         DrawBitLine4BPP(x0, i+y0, pData, Diff, xsize, pTrans);
  1384.         break;
  1385.     #endif
  1386.     #if (LCD_MAX_LOG_COLORS > 16)
  1387.       case 8:
  1388.         DrawBitLine8BPP(x0, i+y0, pData, xsize, pTrans);
  1389.         break;
  1390.     #endif
  1391.     }
  1392.     pData += BytesPerLine;
  1393.   }
  1394. }
  1397. /********************************************************
  1398. *
  1399. *       LCD_L0_SetOrg
  1400. *
  1401. *********************************************************
  1403. Purpose:        Sets the original position of the virtual display.
  1404.                 Has no function at this point with the PC-driver.
  1405. */
  1407. int OrgX, OrgY;
  1408. void LCD_L0_SetOrg(int x, int y) {
  1409.   OrgX = x;
  1410.   OrgY = y;
  1411. }
  1414. /*
  1415.         *********************************************************
  1416.         *                                                       *
  1417.         *           Support for verification                    *
  1418.         *                                                       *
  1419.         *********************************************************
  1421. The following routines are implemented, but have no functionility
  1422. at this point. The reason is that these functions are supposed
  1423. to supervise the hardware, which for obvious reasons can not be
  1424. done in a simulation.
  1426. */
  1428. #if LCD_SUPPORT_VERIFY
  1430. int  LCD_GetErrStat(void) {
  1431.   return 0;
  1432. }
  1433. void LCD_ClrErrStat(void) {
  1434. }
  1435. int  LCD_GetErrCnt (void) {
  1436.   return 0;
  1437. }
  1439. #endif  
  1442. /*
  1443.         *********************************************************
  1444.         *                                                       *
  1445.         *               Copy rectangle                          *
  1446.         *                                                       *
  1447.         *********************************************************
  1449. This function is used for scrolling. If scrolling is not required
  1450. (as is sometimes the case) this routine can be eliminated via
  1451. configuration switch.
  1453. */
  1455. #if  LCD_SUPPORT_COPYRECT
  1457. static void Copy_Line (int y,int x0,int x1,int dx,int dy) {
  1458.   if (dy >=0) {
  1459.     int x;
  1460.     for (x=x0; x<=x1; x++) {
  1461.       _SetPixel(x+dx, y+dy, _GetPixel(x,y));
  1462.     }
  1463.   } else {
  1464.     int x;
  1465.     for (x=x1; x>=x0; x--) {
  1466.       _SetPixel(x+dx, y+dy, _GetPixel(x,y));
  1467.     }
  1468.   }
  1469. }
  1471. void LCD_CopyRect     (int x0, int y0, int x1, int y1, int dx, int dy) {
  1472.   if (dy >=0) {
  1473.     int y;
  1474.     for (y=y0; y<=y1; y++) {
  1475.       Copy_Line (y,x0,x1,dx,dy);
  1476.     }
  1477.   } else {
  1478.     int y;
  1479.     for (y=y1; y>=y0; y--) {
  1480.       Copy_Line (y,x0,x1,dx,dy);
  1481.     }
  1482.   }
  1483. }
  1484. #endif
  1487. /*
  1488.         *********************************************************
  1489.         *                                                       *
  1490.         *                   LCD_SetPaletteEntry                 *
  1491.         *                                                       *
  1492.         *********************************************************
  1494. */
  1496. void LCD_L0_SetLUTEntry(U8 Pos, LCD_COLOR color) {
  1497.   Pos=Pos;
  1498.   color=color;
  1499. }
  1502. /*
  1503.         *********************************************************
  1504.         *                                                       *
  1505.         *       LCD_On                                          *
  1506.         *       LCD_Off                                         *
  1507.         *                                                       *
  1508.         *********************************************************
  1509. */
  1511. void LCD_Off          (void) {
  1512. #ifdef LCD_OFF
  1513.   LCD_OFF();
  1514. #endif
  1515. }
  1517. void LCD_On           (void) {
  1518. #ifdef LCD_ON
  1519.   LCD_ON();
  1520. #endif
  1521. }
  1523. unsigned int LCD_L0_GetPixelIndex(int x, int y) {
  1524.   return GETPIXEL(x,y);
  1525. }
  1528. /*
  1529.         *********************************************************
  1530.         *                                                       *
  1531.         *       LCD_Init : Init the display                     *
  1532.         *                                                       *
  1533.         *********************************************************
  1534. */
  1536. int  LCD_L0_Init(void) {
  1537.   /* Controller independent */
  1538.   #if LCD_WATCHDOG_TRIGGERCNT
  1539.     WatchdogTriggerCnt =0;
  1540.   #endif
  1541.   /* Controller initialisation */
  1542.   LCD_FirstInit();
  1543.   LCD_L0_ReInit();
  1544.   LCD_Adr=0xffff;
  1545.   /* Init successfull */
  1546.   return 0;
  1547. }
  1549. #else
  1551. void LCDSLin(void) { } /* avoid empty object files */
  1553. #endif