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

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

uCOS

开发平台：

C/C++

LCD15XX.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        : LCD15XX.C
  16. Purpose     : Driver for LCDs using Seiko Epson SED15XX controllers     
  17.               The current version supports up to 4 LCD controllers in   
  18.               (almost) any hardware configuration. The following
  19.                derivatives are currently supported:
  20.                Epson SED1560
  21.                Epson SED1565  132*65  BW
  22.                Epson SED1566  132*49  BW   (untested due to lack of hardware)
  23.                Epson SED1567  132*33  BW   (untested due to lack of hardware)
  24.                Epson SED1568  132*55  BW   (untested due to lack of hardware)
  25.                Epson SED1569  132*53  BW   (untested due to lack of hardware)
  26.                Epson SED1575  132*200 BW
  27.                Samsung KS0108B
  28.                Hitachi HD61202
  29.                
  30.                Other Epson LCD controllers are very similar and could
  31.                be covered by this driver as well, but are not
  32.                currently supported.
  33. ----------------------------------------------------------------------
  34. Version-Date---Author-Explanation
  35. ----------------------------------------------------------------------
  36. 2.02e   020716 JE     a) Support for KS0108B & HD61202 added
  37. 2.02d   020715 JE     a) Reworked to work with 2 LCD-controllers
  38. 2.02c   020204 JE     a) Hardwareinterface routines renamed:
  39.                          ...DATA -> ...A1, ...CMD -> ...A0
  40. 2.02b   010706 JE     a) BUGFIXES: DrawBitLine1BPP_NoSwap
  41. 2.02a   010402 RS     a) LCD_GetDevCaps removed from driver
  42.                          (now LCD.c)
  43. 2.02    010329 JE     a) Completely revised, tested without mirror & swap
  44. 2.00    001107 RS     a) New driver interface V2.00 used
  45. 1.32.01 000321 RS     a) BUGFIX: LCD__ClearVRam: aCAdr set to LCD_SEGS_MAX-1
  46.                       b) BUGFIX: Flush: DataR_Cache = DataW_Cache inserted
  47.                JE     c) BUGFIX: ASSIGN_PIXEL_FAST now takes account 
  48.                          of LCD_DRAWMODE_XOR
  49.                       d) BUGFIX: DrawBitLine1BPP_NoSwap XORMODE now works
  50.                       e) BUGFIX: DrawBitLine1BPP_NoSwap clipping now works
  51.                       f) BUGFIX: FindByte: -LCD_FIRSTSEG0 removed
  52.                       g) BUGFIX: LCD_RefreshSection: -LCD_FIRSTSEG0 removed
  53.                       h) LCD_DrawBit now checks number of colors
  54. 1.32.00 990930 RS     a) LCD_Init now returns an int
  55.                       b) bit changed -> Bit in order to vaoid problems
  56.                          with IAR compilers
  57. 1.31.06 990926 RS     a) Code is generated now only if LCD_CONTROLLER
  58.                          is in the range of 1500 - 1599, allowing to
  59.  compile all LCD drivers with a project, making
  60.  the selection in the config file.
  61.   b) Config defaults added
  62. 1.31.05 990922 RS/BB  a) Number of Segments for 1575 changed from 168
  63.                          to 200. 200 is correct because the controller
  64.  has RAM for 200 segments, even thou just 168
  65.  segment lines
  66.   b) Transparency support for bitmaps in
  67.      DrawBitLine1BPP_Swap added
  68. 1.31.04 990810 RS     a) LCD__ClearVRam: Cut and paste error elimiated
  69.                          (Relevant only in 4 controller system)
  70.   b) Transparency problem in DrawBitLine1BPP_Swap
  71.      eliminated
  72.   c) CALCXY: LCD_FIRSTSEG had been subtracted,
  73.      but had already been subtracted before. Could
  74.  lead to a an offset in the memory area used as
  75.  video RAM if LCD_FIRSTSEG<x>  != 0.
  76.  Fixed.
  77.   d) FlushCache-routine simplified for easier
  78.      maintanance using a macro
  79.       e) Bugfix in FlushCache-routine --- untested
  80.      due to lack of hardware !
  81. 1.31.03 990720 RS     a) Compile problem in single-controller system
  82.                          (CurController) fixed
  83.                       b) GotoYPlus1(void) Prototype: Parameterlist:
  84.      () replaced by (void) to avoid comiler warning
  85. 1.31.02 990713 RS     a) All (global/static) variables are initialized in
  86.                          LCD_Init. This turned out to be necessary as not
  87.  all systems comply with ANSI-"C" and automatically
  88.  initialize these variables with 0.
  89. 1.31.01 990712 RS     a) Cache locking bug for systems with seg/Com lookup
  90.                          tables fixed. Cache writeout accelerated.
  91. 1.31.00 990712 RS     a) FindByte made leaner and converted to a macro
  92.                          for 2 controller systems, resulting in improved
  93.  performance
  94.   b) Internal DrawLine /DrawBitmap routines
  95.      improved for higher performance and better
  96.  readability
  97.   c) Inline versions of SetPixel/ClrPixel created, as
  98.      well as fast versions of ASSIGN_PIXEL
  99.  (again: for better performance !)
  100. 1.30.03 990709 RS     a) Structural changes leading to clearer
  101.                          structure and higher performance
  102.                    b) FindByte Optimization for 2-Controller system
  103.                c) Bugfix: One of the previous optimizations
  104.                  could lead to a duplicated byte in video memory
  105.                when LCD_DrawByte was called fo very
  106.              narrow bitmaps. Fixed.
  107. 1.30.02 990708 RS     a) ReadData optimized if all bytes are
  108.                          in Cache (macro, no switch statement)
  109. 1.30.01 990707 RS     a) Add. Optimization in FindByte
  110. 1.30.00 990707 RS     a) Various optimizations impemented, esp.
  111.                          if translation (lookup) table for COMs is
  112.                                           activated
  113. 1.21.02 990617 RS     a) Macro bug (created in 1.21.01) cleaned up
  114.                       b) Page 8 of all controllers cleared during
  115.                          init in order to make sure that the COMS
  116.                          signal can be used and the data for it is
  117.                          cleared to 0
  118.                       c) Problem with segment table fixed ...
  119.                          If used, the segments were moved by LCD_FIRSTSEG<X>
  120. 1.21.01 990615 RS     a) Some more macros generated in order to
  121.                          keep the driver easy to maintain
  122.                       b) Com-offset is now subtracted from Cache<X>
  123.                          index (in order to avoid potential bounds
  124.                          problem): e.g.:
  125.                          Cache0[Page][Col] --> Cache0[Page][Col-LCD_FIRSTSEG0]
  126. 1.21.00 990615 RS     a) When using segment/com lookup tables,
  127.                          the macro-values
  128.                          LCD_NUM_COMS0, LCD_NUM_COMS0
  129.                          LCD_NUM_COMS1, LCD_NUM_COMS1 (controller 1)
  130.                          Have to be defined.
  131.                          Add. configuration checking added.
  132. 1.20.02 990614 RS     a) LCD_Init did not clear VMem for 3. and 4.
  133.                          controller. Fixed.
  134.                          configuration switches eliminated
  135. 1.20.01 990614 RS     a) Problem with certain combination of
  136.                          configuration switches eliminated
  137. 1.20.00 990614 RS     a) Optional segment and com translation tables
  138.                          supported. This turned out to be necessary
  139.                          as with some LCDs the COM/SEG lines are
  140.                          completely mixed up. The translation tables
  141.                          have to be defined in a seperate file
  142.                          (sample supplied in LCDTable.c) in
  143.                          order to make sure that the code in this
  144.                          driver does not have to be changed.
  145. 1.10.00 990505 RS     a) Optional support for Cache locking added.
  146.                          It now requires the add. configuration switch
  147.                          LCD_SUPPORT_CACHECONTROL
  148. 1.04.00 990420 AW/RS  a) Support for 1560 added.
  149. 1.03.03 990322 RS     a) Bitmaps have not been properly cut off at the
  150.                          end of the clipping region. Fixed
  151.                       b) Clipping for horizontal/vert. lines
  152.                          implemented
  153. 1.03.02 990319 RS     a) When writing bitmaps in XOR-Mode, the LCD   
  154.                          cache was not automatically flushed.
  155.                          Fixed.
  156. 1.03.01 990319 RS     a) (Kuennemann) If multiple LCD-controllers had
  157.                          been used in a horizontal array (different
  158.                          SEG lines with SEG<X> > 0) the page
  159.                          calculation did not take the SEG<X> value
  160.                          into account. Fixed.
  161.                       b) (Kuennemann)
  162.                          LCD_Init(): VRAM of controller2/3 was not
  163.                          cleared in a 3 or 4 controller system.
  164.                          Fixed.
  165.                       c) LCD_SetInverse / LCD_ClrInverse:
  166.                          These routines did not write the command to
  167.                          all LCD-controllers, but only to the first
  168.                          one. Fixed.
  169. 1.03.00 990317 RS     a) XOR Mode implemented for all configurations
  170.                       b) DrawVLine accelerated
  171. 1.02.03 990218 RS     a) (Kuennemann) If multiple LCD-controllers had
  172.                          been used in a vertical array (different
  173.                          COM lines with COM<X> > 0) the page
  174.                          calculation did not take the COM<X> value
  175.                          into account. Fixed.
  176.                       b) Driver should now also work with 4
  177.                          controllers. However, this configuration is
  178.                          still untested. The #error is taken out.
  179. 1.02.02 990217 RS     a) LCD_GetVisPage, LCD_GetSelPage added
  180. 1.02.01 990216 RS     a) LCD_GetPixel implemented
  181.                       b) Support for GetDeviceCaps added
  182.                       c) Support for Drawmode can now be disabled via
  183.                          config switch
  184. 1.02.00 990212 RS     a) Include file string.h put back in in order to
  185.                       be able to completly reset the LCD, including
  186.                       clearing the cache
  187.                       b) LCD_Refresh implemented
  188.                       c) Support for physical bitmaps added
  189.                       d) Support for LCD_REVERSE added
  190.                       e) Support for Write-thru cache added
  191. 1.01.01 990203 RS     a) Include file string.h no longer needed,
  192.                       taken out
  193. 1.01.00 990203 RS     a) Cache no longer filled with 0 using memset
  194.                        (We trust the compiler to do the job for us.)
  195. 1.00.02 990202 RS     Support for up to 4 controllers implemented
  196. 1.00.01 990128 RS     Changes in header-configuration  as discussed
  197.                       with BB
  198. 1.00    990118 RS     First release for up to 2 LCD controllers *
  199. ----------------------------------------------------------------------
  200. Known problems or limitations with current version
  201. ----------------------------------------------------------------------
  202. Due to the change to interface version 2.0,
  203. The draw bitline routines has been temp. disabled
  204. The routines:
  205. LCD_L0_SetPixelIndex
  206. LCD_L0_XorPixel
  207. LCD_L0_GetPixelIndex
  208. need to be proberly implemented
  209. ----------------------------------------------------------------------
  210. Possible optimizations
  211. ----------------------------------------------------------------------
  212. ---------------------------END-OF-HEADER------------------------------
  213. */
  215. #include <string.h>             /* for memset */
  216. #include <stddef.h>           /* needed for definition of NULL */
  217. #include "LCD_Private.h"      /* private modul definitions & config */
  218. #include "GUI_Private.h"
  219. #include "GUIDebug.h"
  220. #include "LCD_0.h"            /* Defines for first display */
  222. #if   (   (LCD_CONTROLLER/100 ==    15) 
  223.        || (LCD_CONTROLLER     ==  0713) 
  224.        || (LCD_CONTROLLER     ==   108) 
  225.        || (LCD_CONTROLLER     == 61202) 
  226.       ) 
  227.       && (LCD_CONTROLLER/100 != 0x15E05 ) 
  228.       && (!defined(WIN32) | defined(LCD_SIMCONTROLLER))
  230. /*
  231.         *********************************************************
  232.         *                                                       *
  233.         *           Compiler specific settings                  *
  234.         *                                                       *
  235.         *********************************************************
  237. */
  239. #ifdef WIN32   /* Avoid warnings in MS-compiler */
  240.   #pragma warning(disable : 4244)  // warning C4244: '=' : conversion from 'long ' to 'unsigned char ', possible loss of data
  241.   #pragma warning(disable : 4761)  // warning C4761: integral size mismatch in argument; conversion supplied
  242.   #pragma warning(disable : 4305)  // warning C4305: '=' : truncation from 'const int ' to ...
  243. #endif
  246. #ifndef LCD_DISPLAY_INDEX
  247.   #define LCD_DISPLAY_INDEX 0
  248. #endif
  251. /*********************************************************************
  252. *
  253. *      Map hardware macros
  254. *
  255. **********************************************************************
  256. */
  258. /* mapping for multi-display configuration */
  259. #if (LCD_NUM_DISPLAYS > 1)
  260.   #if   (LCD_DISPLAY_INDEX == 0)     /* First display in a multi-display configuration */
  261.     #define LCD_WRITE_A0   LCD_WRITE_A0_0
  262.     #define LCD_WRITE_A1   LCD_WRITE_A1_0
  263.     #define LCD_WRITE_A0C1 LCD_WRITE_A0C1_0
  264.     #define LCD_WRITE_A1C1 LCD_WRITE_A1C1_0
  265.     #define LCD_WRITE_A0C2 LCD_WRITE_A0C2_0
  266.     #define LCD_WRITE_A1C2 LCD_WRITE_A1C2_0
  267.     #define LCD_WRITE_A0C3 LCD_WRITE_A0C3_0
  268.     #define LCD_WRITE_A1C3 LCD_WRITE_A1C3_0
  269.     #define LCD_READ_A0    LCD_READ_A0_0
  270.     #define LCD_READ_A0    LCD_READ_A0_0
  271.     #define LCD_READ_A0C1  LCD_READ_A0C1_0
  272.     #define LCD_READ_A0C1  LCD_READ_A0C1_0
  273.     #define LCD_READ_A0C2  LCD_READ_A0C2_0
  274.     #define LCD_READ_A0C2  LCD_READ_A0C2_0
  275.     #define LCD_READ_A0C3  LCD_READ_A0C3_0
  276.     #define LCD_READ_A0C3  LCD_READ_A0C3_0
  277.   #elif (LCD_DISPLAY_INDEX == 1)  /* Second display in a multi-display configuration */
  278.     #define LCD_WRITE_A0   LCD_WRITE_A0_1
  279.     #define LCD_WRITE_A1   LCD_WRITE_A1_1
  280.     #define LCD_WRITE_A0C1 LCD_WRITE_A0C1_1
  281.     #define LCD_WRITE_A1C1 LCD_WRITE_A1C1_1
  282.     #define LCD_WRITE_A0C2 LCD_WRITE_A0C2_1
  283.     #define LCD_WRITE_A1C2 LCD_WRITE_A1C2_1
  284.     #define LCD_WRITE_A0C3 LCD_WRITE_A0C3_1
  285.     #define LCD_WRITE_A1C3 LCD_WRITE_A1C3_1
  286.     #define LCD_READ_A0    LCD_READ_A0_1
  287.     #define LCD_READ_A0    LCD_READ_A0_1
  288.     #define LCD_READ_A0C1  LCD_READ_A0C1_1
  289.     #define LCD_READ_A0C1  LCD_READ_A0C1_1
  290.     #define LCD_READ_A0C2  LCD_READ_A0C2_1
  291.     #define LCD_READ_A0C2  LCD_READ_A0C2_1
  292.     #define LCD_READ_A0C3  LCD_READ_A0C3_1
  293.     #define LCD_READ_A0C3  LCD_READ_A0C3_1
  294.   #else
  295.     #error This many displays not yet supported !
  296.   #endif
  297. #endif
  299. /* Command definitions in dependence of selected LCD-controller */
  300. #if   (LCD_CONTROLLER/100 == 15) || (LCD_CONTROLLER     ==  0713)
  301.   #define SET_PAGE0(Page) LCD_WriteSingleCommand0(0xb0 + Page)
  302.   #define SET_CADR0(Col)  LCD_WriteDoubleCommand0(0x10 + (Col >> 4), 0x00 + (Col & 0xf))
  303.   #define CMD_LCD_ON      0xaf
  304.   #define CMD_LCD_OFF     0xae
  305.   #define WAIT0()
  306.   #define WAIT1()
  307.   #define WAIT2()
  308.   #define WAIT3()
  309. #elif (LCD_CONTROLLER ==  108) || (LCD_CONTROLLER == 61202)
  310.   static int _Status;
  311.   #define SET_PAGE0(Page) LCD_WriteSingleCommand0(0xb8 + Page);
  312.   #define SET_CADR0(Col)  LCD_WriteSingleCommand0(0x40 + Col);
  313.   #if (LCD_NUM_CONTROLLERS > 1)
  314.     #define SET_PAGE1(Page) LCD_WriteSingleCommand1(0xb8 + Page);
  315.     #define SET_CADR1(Col)  LCD_WriteSingleCommand1(0x40 + Col);
  316.   #endif
  317.   #define CMD_LCD_ON      0x3f
  318.   #define CMD_LCD_OFF     0x3e
  319.   #define WAIT0()         do { LCD_READ_A0(_Status); }   while (_Status & 0x80);
  320.   #define WAIT1()         do { LCD_READ_A0C1(_Status); } while (_Status & 0x80);
  321.   #define WAIT2()         do { LCD_READ_A0C2(_Status); } while (_Status & 0x80);
  322.   #define WAIT3()         do { LCD_READ_A0C3(_Status); } while (_Status & 0x80);
  323. #else
  324.   #error LCD-controller not supported!
  325. #endif
  327. #ifdef WIN32     /* SEGGER internal simulation */
  328.   void SIM_WriteA1C0(U8 Data);
  329.   void SIM_WriteA0C0(U8 cmd);
  330.   U8   SIM_ReadA0C0(void);
  331.   U8   SIM_ReadA1C0(void);
  332.   #define WRITE_DATA0(Data) SIM_WriteA1C0(Data) 
  333.   #define WRITE_CMD0(cmd)   SIM_WriteA0C0(cmd)
  334.   #define READ_DATA0(Data)  Data = SIM_ReadA1C0()
  335.   #define READ_CMD0(cmd)    cmd  = SIM_ReadA0C0()
  336.   #define INIT_CONTROLLER()
  337.   #if LCD_NUM_CONTROLLERS > 1
  338.     void SIM_WriteA1C1(U8 Data);
  339.     void SIM_WriteA0C1(U8 cmd);
  340.     U8   SIM_ReadA0C1(void);
  341.     U8   SIM_ReadA1C1(void);
  342.     #define WRITE_DATA1(Data) SIM_WriteA1C1(Data) 
  343.     #define WRITE_CMD1(cmd)   SIM_WriteA0C1(cmd)
  344.     #define READ_DATA1(Data)  Data = SIM_ReadA1C1()
  345.     #define READ_CMD1(cmd)    cmd  = SIM_ReadA0C1()
  346.   #endif
  347.   #if LCD_NUM_CONTROLLERS > 2
  348.     void SIM_WriteA1C2(U8 Data);
  349.     void SIM_WriteA0C2(U8 cmd);
  350.     U8   SIM_ReadA0C2(void);
  351.     U8   SIM_ReadA1C2(void);
  352.     #define WRITE_DATA2(Data) SIM_WriteA1C2(Data) 
  353.     #define WRITE_CMD2(cmd)   SIM_WriteA0C2(cmd)
  354.     #define READ_DATA2(Data)  Data = SIM_ReadA1C2()
  355.     #define READ_CMD2(cmd)    cmd  = SIM_ReadA0C2()
  356.   #endif
  357.   #if LCD_NUM_CONTROLLERS > 3
  358.     void SIM_WriteA1C3(U8 Data);
  359.     void SIM_WriteA0C3(U8 cmd);
  360.     U8   SIM_ReadA0C3(void);
  361.     U8   SIM_ReadA1C3(void);
  362.     #define WRITE_DATA3(Data) SIM_WriteA1C3(Data) 
  363.     #define WRITE_CMD3(cmd)   SIM_WriteA0C3(cmd)
  364.     #define READ_DATA3(Data)  Data = SIM_ReadA1C3()
  365.     #define READ_CMD3(cmd)    cmd  = SIM_ReadA0C3()
  366.   #endif
  367. #else
  368.   #define WRITE_CMD0(cmd)   WAIT0(); LCD_WRITE_A0(cmd)
  369.   #define WRITE_DATA0(Data) WAIT0(); LCD_WRITE_A1(Data)
  370.   #define READ_DATA0(Data)  WAIT0(); LCD_READ_A1(Data)
  371.   #define READ_CMD0(cmd)    WAIT0(); LCD_READ_A0(cmd)
  372.   #define INIT_CONTROLLER  LCD_INIT_CONTROLLER
  373.   #if LCD_NUM_CONTROLLERS > 1
  374.     #define WRITE_CMD1(cmd)   WAIT1(); LCD_WRITE_A0C1(cmd)
  375.     #define WRITE_DATA1(Data) WAIT1(); LCD_WRITE_A1C1(Data)
  376.     #define READ_DATA1(Data)  WAIT1(); LCD_READ_A1C1(Data)
  377.     #define READ_CMD1(cmd)    WAIT1(); LCD_READ_A0C1(cmd)
  378.   #endif
  379.   #if LCD_NUM_CONTROLLERS > 2
  380.     #define WRITE_CMD2(cmd)   WAIT(2); LCD_WRITE_A0C2(cmd)
  381.     #define WRITE_DATA2(Data) WAIT(2); LCD_WRITE_A1C2(Data)
  382.     #define READ_DATA2(Data)  WAIT(2); LCD_READ_A1C2(Data)
  383.     #define READ_CMD2(cmd)    WAIT(2); LCD_READ_A0C2(cmd)
  384.   #endif
  385.   #if LCD_NUM_CONTROLLERS > 3
  386.     #define WRITE_CMD3(cmd)   WAIT(3); LCD_WRITE_A0C3(cmd)
  387.     #define WRITE_DATA3(Data) WAIT(3); LCD_WRITE_A1C3(Data)
  388.     #define READ_DATA3(Data)  WAIT(3); LCD_READ_A1C3(Data)
  389.     #define READ_CMD3(cmd)    WAIT(3); LCD_READ_A0C3(cmd)
  390.   #endif
  391. #endif
  393. /*
  394.   ********************************************************************
  395.   *
  396.   *                  ID translation table
  397.   *
  398.   ********************************************************************
  400. This table contains 0, 1, 2, ... and serves as translation table for DDBs
  402. */
  404. #define INTS(Base)  Base+0,Base+1,Base+2,Base+3,Base+4,Base+5,   
  405.                     Base+6,Base+7,Base+8,Base+9,Base+10,Base+11, 
  406.                     Base+12,Base+13,Base+14,Base+15
  408. static const LCD_PIXELINDEX aID[] = {
  409.   INTS(0),
  410.   #if LCD_MAX_LOG_COLORS > 0x10
  411.     INTS(0x10),
  412.   #endif
  413.   #if LCD_MAX_LOG_COLORS > 0x20
  414.     INTS(0x20),
  415.     INTS(0x30),
  416.   #endif
  417.   #if LCD_MAX_LOG_COLORS > 0x40
  418.     INTS(0x40),
  419.     INTS(0x50),
  420.     INTS(0x60),
  421.     INTS(0x70),
  422.   #endif
  423.   #if LCD_MAX_LOG_COLORS > 0x80
  424.     INTS(0x80),
  425.     INTS(0x90),
  426.     INTS(0xa0),
  427.     INTS(0xb0),
  428.     INTS(0xc0),
  429.     INTS(0xd0),
  430.     INTS(0xe0),
  431.     INTS(0xf0)
  432.   #endif
  433. };
  435. /*
  436.   ********************************************************************
  437.   *                                                                  *
  438.   *                Defaults for config switches                      *
  439.   *                                                                  *
  440.   ********************************************************************
  441. */
  443. #ifndef LCD_CACHE
  444.   #define  LCD_CACHE (1)
  445. #endif
  447. #ifndef LCD_SUPPORT_REFRESH
  448.   #define  LCD_SUPPORT_REFRESH LCD_CACHE
  449. #endif
  451. #ifndef LCD_REVERSEMODE_SUPPORT
  452.   #define LCD_REVERSEMODE_SUPPORT (0)
  453. #endif
  455. #ifndef LCD_SUPPORT_VERIFY
  456.   #define LCD_SUPPORT_VERIFY (0)
  457. #endif
  459. /* Drivers supports anti-aliasing if active. */
  460. #ifndef LCD_SUPPORT_ANTIALIASING
  461.   #define LCD_SUPPORT_ANTIALIASING (0)
  462. #endif
  464. /* Switch for support of cache control (locking) */
  465. #ifndef  LCD_SUPPORT_CACHECONTROL
  466.   #define  LCD_SUPPORT_CACHECONTROL     (1)
  467. #endif
  469. /* Switch support for the LCD_CopyRect function of the driver */
  470. #ifndef  LCD_SUPPORT_COPYRECT
  471.   #define  LCD_SUPPORT_COPYRECT         (1)
  472. #endif
  474. /* If disabled, selected drawmode is ignored.
  475.    ==> XOR, REVERSE drawing not supported */
  476. #ifndef LCD_SUPPORT_DRAWMODE
  477.   #define LCD_SUPPORT_DRAWMODE          (1)
  478. #endif
  480. /* Switch support for the LCD_On, LCD_Off functions of the driver */
  481. #ifndef  LCD_SUPPORT_ONOFF
  482.   #define  LCD_SUPPORT_ONOFF            (1)
  483. #endif
  485. /* Switch for support of multiple pages.
  486.  Only available with certain LCD-controllers */
  487. #ifndef LCD_SUPPORT_PAGING
  488.   #define LCD_SUPPORT_PAGING            (0)
  489. #endif
  491. /* Switch for support of run-time inversion of display. */
  492. #ifndef LCD_SUPPORT_REVERSEMODE
  493.   #define LCD_SUPPORT_REVERSEMODE       (0)
  494. #endif
  496. /* Switch support for the LCD_SetOrg function of the driver */
  497. #ifndef LCD_SUPPORT_SETORG
  498.   #define LCD_SUPPORT_SETORG            (0)
  499. #endif
  501. /* Switch for support of refreshing video RAM. */
  502. #ifndef LCD_SUPPORT_REFRESH
  503.   #define LCD_SUPPORT_REFRESH           (0)
  504. #endif
  506. #ifndef LCD_SCHEDULE_CNT
  507.   #define LCD_SCHEDULE_CNT 0
  508. #endif
  510. #ifndef LCD_NUM_CONTROLLERS
  511.   #define LCD_NUM_CONTROLLERS (1)
  512. #endif
  514. #ifndef LCD_LOCK
  515.   #define LCD_LOCK()
  516. #endif
  518. #ifndef LCD_UNLOCK
  519.   #define LCD_UNLOCK()
  520. #endif
  522. #ifndef LCD_READABLE
  523.   #define LCD_READABLE (0)
  524. #endif
  525.   
  526. #ifndef LCD_CACHE_WRITETHRU  
  527.   #define LCD_CACHE_WRITETHRU (0)
  528. #endif
  530. #ifndef LCD_SUPPORT_RT_INVERSION  
  531.   #define LCD_SUPPORT_RT_INVERSION  (0)
  532. #endif
  534. #ifndef LCD_SUPPORT_CHECKINIT
  535.   #define LCD_SUPPORT_CHECKINIT (0)
  536. #endif
  538. /*
  539.   ********************************************************************
  540.   *                                                                  *
  541.   *                Explicit externals                                *
  542.   *                                                                  *
  543.   ********************************************************************
  544. */
  546. /* For compatibility with older configs, define defaults */
  547. #ifndef LCD_SUPPORT_COMTRANS
  548.   #define LCD_SUPPORT_COMTRANS 0
  549. #endif
  550. #ifndef LCD_SUPPORT_SEGTRANS
  551.   #define LCD_SUPPORT_SEGTRANS 0
  552. #endif
  554. #if LCD_SUPPORT_COMTRANS
  555.   extern U8 LCD__aLine2Com0[LCD_LASTCOM0-LCD_FIRSTCOM0+1];
  556.   #if (LCD_NUM_CONTROLLERS >1)
  557.     extern U8 LCD__aLine2Com1[LCD_LASTCOM1-LCD_FIRSTCOM1+1];
  558.   #endif
  559.   #if (LCD_NUM_CONTROLLERS >2)
  560.     extern U8 LCD__aLine2Com2[LCD_LASTCOM2-LCD_FIRSTCOM2+1];
  561.   #endif
  562.   #if (LCD_NUM_CONTROLLERS >3)
  563.     extern U8 LCD__aLine2Com3[LCD_LASTCOM3-LCD_FIRSTCOM3+1];
  564.   #endif
  565. #endif
  567. #if LCD_SUPPORT_SEGTRANS
  568.   extern U8 LCD__aRow2Seg0[LCD_LASTSEG0-LCD_FIRSTSEG0+1];
  569.   #if (LCD_NUM_CONTROLLERS >1)
  570.     extern U8 LCD__aRow2Seg1[LCD_LASTSEG1-LCD_FIRSTSEG1+1];
  571.   #endif
  572.   #if (LCD_NUM_CONTROLLERS >2)
  573.     extern U8 LCD__aRow2Seg2[LCD_LASTSEG2-LCD_FIRSTSEG2+1];
  574.   #endif
  575.   #if (LCD_NUM_CONTROLLERS >3)
  576.     extern U8 LCD__aRow2Seg3[LCD_LASTSEG3-LCD_FIRSTSEG3+1];
  577.   #endif
  578. #endif
  580. /*
  581.   ********************************************************************
  582.   *                                                                  *
  583.   *                Internal types                                    *
  584.   *                                                                  *
  585.   ********************************************************************
  586. */
  588. /*
  589.   ********************************************************************
  590.   *                                                                  *
  591.   *                SCHEDULING                                        *
  592.   *                                                                  *
  593.   ********************************************************************
  594. */
  596. #if LCD_SCHEDULE_CNT
  597.   static int ScheduleCntRem=LCD_SCHEDULE_CNT;
  598.   #define CHECK_SCHEDULE(PixelCnt)                              
  599.           if ((ScheduleCntRem-=(PixelCnt)) <=0) {               
  600.             ScheduleCntRem=LCD_SCHEDULE_CNT;                    
  601.             LCD_SCHEDULE();                                     
  602.           }
  603. #else
  604.   #define CHECK_SCHEDULE(PixelCnt)
  605. #endif
  607. /*
  608.   ********************************************************************
  609.   *                                                                  *
  610.   *                 Macro calculations                               *
  611.   *                                                                  *
  612.   ********************************************************************
  613. */
  615. /* To make life easier, assign physical x/y size */
  616. #if !LCD_SWAP_XY
  617.   #define LCD_XSIZE_P LCD_XSIZE
  618.   #define LCD_YSIZE_P LCD_YSIZE
  619. #else
  620.   #define LCD_XSIZE_P LCD_YSIZE
  621.   #define LCD_YSIZE_P LCD_XSIZE
  622. #endif
  625. /* Define number of available segments of controller */
  627. #if (LCD_CONTROLLER == 1560)
  628.   #define LCD_COMS_MAX 64
  629.   #define LCD_SEGS_MAX  102
  630. #elif (LCD_CONTROLLER == 1565)
  631.   #define LCD_COMS_MAX 65
  632.   #define LCD_SEGS_MAX  132
  633. #elif (LCD_CONTROLLER == 1566)
  634.   #define LCD_COMS_MAX 49
  635.   #define LCD_SEGS_MAX  132
  636. #elif (LCD_CONTROLLER == 1567)
  637.   #define LCD_COMS_MAX 33
  638.   #define LCD_SEGS_MAX  132
  639. #elif (LCD_CONTROLLER == 1568)
  640.   #define LCD_COMS_MAX 55
  641.   #define LCD_SEGS_MAX  132
  642. #elif (LCD_CONTROLLER == 1569)
  643.   #define LCD_COMS_MAX 53
  644.   #define LCD_SEGS_MAX  132
  645. #elif (LCD_CONTROLLER == 1575)
  646.   #define LCD_COMS_MAX 65
  647.   #define LCD_SEGS_MAX  200
  648. #elif (LCD_CONTROLLER == 0713)
  649.   #define LCD_COMS_MAX 65
  650.   #define LCD_SEGS_MAX  132
  651. #elif (LCD_CONTROLLER == 108)
  652.   #define LCD_COMS_MAX 64
  653.   #define LCD_SEGS_MAX 64
  654. #elif (LCD_CONTROLLER == 61202)
  655.   #define LCD_COMS_MAX 64
  656.   #define LCD_SEGS_MAX 64
  657. #else
  658.   #error Please define a controller to use !
  659. #endif
  661. /* Define number of used coms/segments per controller */
  662. #if !LCD_SUPPORT_SEGTRANS
  663.   #define LCD_NUM_SEGS0 (LCD_LASTSEG0-LCD_FIRSTSEG0+1)
  664. #else
  665.   #ifndef LCD_NUM_SEGS0
  666.     #error Please define LCD_NUM_SEGS0 in your configuratiuon file LCDConf.h
  667.   #endif
  668. #endif
  670. #if !LCD_SUPPORT_COMTRANS
  671.   #define LCD_NUM_COMS0 (LCD_LASTCOM0-LCD_FIRSTCOM0+1)
  672. #else
  673.   #ifndef LCD_NUM_COMS0
  674.     #error Please define LCD_NUM_COMS0 in your configuratiuon file LCDConf.h
  675.   #endif
  676. #endif
  678. #if (LCD_NUM_CONTROLLERS >1)
  679.   #if !LCD_SUPPORT_SEGTRANS
  680.     #define LCD_NUM_SEGS1 (LCD_LASTSEG1-LCD_FIRSTSEG1+1)
  681.   #else
  682.     #ifndef LCD_NUM_SEGS1
  683.       #error Please define LCD_NUM_SEGS1 in your configuratiuon file LCDConf.h
  684.     #endif
  685.   #endif
  686.   #if !LCD_SUPPORT_COMTRANS
  687.     #define LCD_NUM_COMS1 (LCD_LASTCOM1-LCD_FIRSTCOM1+1)
  688.   #else
  689.     #ifndef LCD_NUM_COMS1
  690.       #error Please define LCD_NUM_COMS1 in your configuratiuon file LCDConf.h
  691.     #endif
  692.   #endif
  693. #endif
  695. #if (LCD_NUM_CONTROLLERS >2)
  696.   #define LCD_NUM_SEGS2 (LCD_LASTSEG2-LCD_FIRSTSEG2+1)
  697.   #define LCD_NUM_COMS2 (LCD_LASTCOM2-LCD_FIRSTCOM2+1)
  698. #endif
  699. #if (LCD_NUM_CONTROLLERS >3)
  700.   #define LCD_NUM_SEGS3 (LCD_LASTSEG3-LCD_FIRSTSEG3+1)
  701.   #define LCD_NUM_COMS3 (LCD_LASTCOM3-LCD_FIRSTCOM3+1)
  702. #endif
  704. /* Define total number of used coms/segments */
  705. #if (LCD_NUM_CONTROLLERS ==1)
  706.   #define LCD_NUM_SEGS LCD_NUM_SEGS0
  707.   #define LCD_NUM_COMS LCD_NUM_COMS0
  708. #elif (LCD_NUM_CONTROLLERS ==2)
  709.   #define LCD_NUM_SEGS (LCD_NUM_SEGS0+LCD_NUM_SEGS1)
  710.   #define LCD_NUM_COMS (LCD_NUM_COMS0+LCD_NUM_COMS1)
  711. #elif (LCD_NUM_CONTROLLERS ==3)
  712.   #define LCD_NUM_SEGS (LCD_NUM_SEGS0+LCD_NUM_SEGS1+LCD_NUM_SEGS2)
  713.   #define LCD_NUM_COMS (LCD_NUM_COMS0+LCD_NUM_COMS1+LCD_NUM_COMS2)
  714. #elif (LCD_NUM_CONTROLLERS ==4)
  715.   #define LCD_NUM_SEGS (LCD_NUM_SEGS0+LCD_NUM_SEGS1+LCD_NUM_SEGS2+LCD_NUM_SEGS3)
  716.   #define LCD_NUM_COMS (LCD_NUM_COMS0+LCD_NUM_COMS1+LCD_NUM_COMS2+LCD_NUM_COMS3)
  717. #endif
  719. /* Calc. the first column to actually write to. This is not as
  720.    easy as it seems, because if we mirror X, the controller
  721.    uses different columns in video memory to store the data.
  722.    If you use lookup tables for segment lines, the offsets are 0
  723.    because the right values are in the table
  724. */
  725. #if LCD_SUPPORT_SEGTRANS==0
  726.   #if !LCD_MIRROR_X
  727.     #define LCD_SEGOFF0 LCD_FIRSTSEG0
  728.     #define LCD_SEGOFF1 (LCD_XORG1 - LCD_FIRSTSEG1)
  729.     #define LCD_SEGOFF2 (LCD_XORG2 - LCD_FIRSTSEG2)
  730.     #define LCD_SEGOFF3 (LCD_XORG3 - LCD_FIRSTSEG3)
  731.   #else
  732.     #define LCD_SEGOFF0 (LCD_SEGS_MAX-LCD_LASTSEG0-1)
  733.     #define LCD_SEGOFF1 (LCD_SEGS_MAX-LCD_LASTSEG1-1)
  734.     #define LCD_SEGOFF2 (LCD_SEGS_MAX-LCD_LASTSEG2-1)
  735.     #define LCD_SEGOFF3 (LCD_SEGS_MAX-LCD_LASTSEG3-1)
  736.   #endif
  737. #else
  738.     #define LCD_SEGOFF0 0
  739.     #define LCD_SEGOFF1 0
  740.     #define LCD_SEGOFF2 0
  741.     #define LCD_SEGOFF3 0
  742. #endif
  745. #if !LCD_REVERSE
  746.   #define  LCD_CMDNORMAL  0xa6
  747.   #define  LCD_CMDREVERSE 0xa7
  748. #else
  749.   #define  LCD_CMDNORMAL  0xa7
  750.   #define  LCD_CMDREVERSE 0xa6
  751. #endif
  754. /*
  755.   ********************************************************************
  756.   *                                                                  *
  757.   *            Configuration switch checking                         *
  758.   *                                                                  *
  759.   ********************************************************************
  761. Please be aware that not all configuration errors can be captured !
  763. */
  765. #if (LCD_SUPPORT_REFRESH && !LCD_CACHE)
  766.   #error Cache has to be enabled in order to support refresh !
  767. #endif
  769. #if (LCD_BITSPERPIXEL != 1)
  770.   #error This controller can handle only b/w displays
  771. #endif
  773. /* Check number of controllers */
  774. #if ((LCD_NUM_CONTROLLERS >4) || (LCD_NUM_CONTROLLERS <0))
  775.   #error "More than 4 controllers not supported !"
  776. #endif
  778. /* Check if number of segments / coms equals resolution */
  779. #if (LCD_NUM_SEGS < LCD_XSIZE_P)
  780.   #error Please check segment setup of controller 0 and X/YSIZE !!!
  781. #endif
  782. #if (LCD_NUM_COMS < LCD_YSIZE_P)
  783.   #error Please check com setup of controller 0 and X/YSIZE !!!
  784. #endif
  786. /*
  787.   ********************************************************************
  788.   *                                                                  *
  789.   *       Standard variables for driver                              *
  790.   *                                                                  *
  791.   ********************************************************************
  792. */
  794. #define BKCOLOR LCD_BKCOLORINDEX
  795. #define   COLOR LCD_COLORINDEX
  797. static LCD_RECT ClipRect;
  798. #if LCD_SUPPORT_VERIFY
  799.   static int ErrCnt;
  800.   static int ErrStat;
  801. #endif
  803. /*
  804.         *****************************************
  805.         *                                       *
  806.         *   Memory areas for caching (optional) *
  807.         *                                       *
  808.         *****************************************
  810. The cache stores only the bytes actually used in every controller.
  811. This is also the reason why different arrays are used for every
  812. controller.
  813. */
  815. #if LCD_CACHE
  816.   /* Handle controller #0 */
  817.   #define NUM_COMS0   (LCD_LASTCOM0-LCD_FIRSTCOM0+1)
  818.   #define NUM_PAGES0  ((NUM_COMS0+7)/8)
  819.   #define NUM_COLS0    (LCD_LASTSEG0-LCD_FIRSTSEG0+1)
  820.   static U8 Cache0[NUM_PAGES0][NUM_COLS0];
  821. /* Check configuration a bit to capture the worst mistakes ...  */
  822.   #if (NUM_COLS0<LCD_NUM_SEGS0)
  823.     #error Configuration error ! Please check LCD_LASTSEG0, LCD_FIRSTSEG0
  824.   #endif
  825.   #if (NUM_COMS0<LCD_NUM_COMS0)
  826.     #error Configuration error ! Please check LCD_LASTCOM0, LCD_FIRSTCOM0
  827.   #endif
  828.   /* Handle controller #1 */
  829.   #if (LCD_NUM_CONTROLLERS >1)
  830.     #define NUM_COMS1   (LCD_LASTCOM1-LCD_FIRSTCOM1+1)
  831.     #define NUM_PAGES1  ((NUM_COMS1+7)/8)
  832.     #define NUM_COLS1    (LCD_LASTSEG1-LCD_FIRSTSEG1+1)
  833.     static U8 Cache1[NUM_PAGES1][NUM_COLS1];
  834. /* Check configuration a bit to capture the worst mistakes ...  */
  835.     #if (NUM_COLS1<LCD_NUM_SEGS1)
  836.       #error Configuration error ! Please check LCD_LASTSEG1, LCD_FIRSTSEG1
  837.     #endif
  838.     #if (NUM_COMS1<LCD_NUM_COMS1)
  839.       #error Configuration error ! Please check LCD_LASTCOM1, LCD_FIRSTCOM1
  840.     #endif
  841.   #endif
  842.   /* Handle controller #2 */
  843.   #if (LCD_NUM_CONTROLLERS >2)
  844.     #define NUM_PAGES2  ((LCD_LASTCOM2-LCD_FIRSTCOM2+1+7)/8)
  845.     #define NUM_COLS2    (LCD_LASTSEG2-LCD_FIRSTSEG2+1)
  846.     static U8 Cache2[NUM_PAGES2][NUM_COLS2];
  847.   #endif
  848.   /* Handle controller #3 */
  849.   #if (LCD_NUM_CONTROLLERS >3)
  850.     #define NUM_PAGES3  ((LCD_LASTCOM3-LCD_FIRSTCOM3+1+7)/8)
  851.     #define NUM_COLS3    (LCD_LASTSEG3-LCD_FIRSTSEG3+1)
  852.     static U8 Cache3[NUM_PAGES3][NUM_COLS3];
  853.   #endif
  854. #endif
  856. /*
  857.   ********************************************************************
  858.   *                                                                  *
  859.   *                Write Cache variables                             *
  860.   *                                                                  *
  861.   ********************************************************************
  862. */
  864. #if  LCD_SUPPORT_CACHECONTROL
  865.   static char CacheStat   =0;     /* 0: No changes */
  866.   static char CacheLocked =0;     /* 0: Not locked */
  867.   static U8   aaCacheDirtyTag0[NUM_PAGES0][(NUM_COLS0+7)/8];
  868.   #if (LCD_NUM_CONTROLLERS >1)
  869.     static U8   aaCacheDirtyTag1[NUM_PAGES1][(NUM_COLS1+7)/8];
  870.   #endif
  871.   #if (LCD_NUM_CONTROLLERS >2)
  872.     static U8   aaCacheDirtyTag2[NUM_PAGES2][(NUM_COLS2+7)/8];
  873.   #endif
  874.   #if (LCD_NUM_CONTROLLERS >3)
  875.     static U8   aaCacheDirtyTag3[NUM_PAGES3][(NUM_COLS3+7)/8];
  876.   #endif
  877. #endif
  879. /*
  880.   ********************************************************************
  881.   *                                                                  *
  882.   *                  Hardware access, low level                      *
  883.   *                                                                  *
  884.   *           Write Command/Data, Reset                              *
  885.   *           Read  Command/data if possible (LCD readable)          *
  886.   *                                                                  *
  887.   ********************************************************************
  889.   The following routines are used for all access to the
  890.   LCD-controller(s).
  891. */
  893. /* This macro can be used to check how much time is used up
  894.    for management and how much for hardware access */
  895. #ifdef LCD_TESTSPEED
  896.   #undef  WRITE_DATA0
  897.   #undef  WRITE_CMD0
  898.   #undef  WRITE_DATA1
  899.   #undef  WRITE_CMD1
  900.   #define WRITE_DATA0(p0)
  901.   #define WRITE_CMD0(p0)
  902.   #define WRITE_DATA1(p0)
  903.   #define WRITE_CMD1(p0)
  904. #endif
  907.         /****************************************
  908.         *                                       *
  909.         *        Write Data                     *
  910.         *                                       *
  911.         ****************************************/
  913. static void LCD_WriteData0(char Data) {
  914.   LCD_LOCK();
  915.   WRITE_DATA0(Data);
  916.   LCD_UNLOCK();
  917. }
  919. #if (LCD_NUM_CONTROLLERS >1)
  920. static void LCD_WriteData1(char Data) {
  921.   LCD_LOCK();
  922.   WRITE_DATA1(Data);
  923.   LCD_UNLOCK();
  924. }
  925. #endif
  927. #if (LCD_NUM_CONTROLLERS >2)
  928. static void LCD_WriteData2(char Data) {
  929.   LCD_LOCK();
  930.   LCD_WRITEDATA2(Data);
  931.   LCD_UNLOCK();
  932. }
  933. #endif
  935. #if (LCD_NUM_CONTROLLERS >3)
  936. static void LCD_WriteData3(char Data) {
  937.   LCD_LOCK();
  938.   LCD_WRITEDATA3(Data);
  939.   LCD_UNLOCK();
  940. }
  941. #endif
  943.         /****************************************
  944.         *                                       *
  945.         *        Write single command           *
  946.         *                                       *
  947.         ****************************************/
  949. static void LCD_WriteSingleCommand0(char cmd) {
  950.   LCD_LOCK();
  951.   WRITE_CMD0(cmd);
  952.   LCD_UNLOCK();
  953. }
  955. #if (LCD_NUM_CONTROLLERS >1)
  956. static void LCD_WriteSingleCommand1(char cmd) {
  957.   LCD_LOCK();
  958.   WRITE_CMD1(cmd);
  959.   LCD_UNLOCK();
  960. }
  961. #endif
  962. #if (LCD_NUM_CONTROLLERS >2)
  963. static void LCD_WriteSingleCommand2(char cmd) {
  964.   LCD_LOCK();
  965.   LCD_WRITECMD2(cmd);
  966.   LCD_UNLOCK();
  967. }
  968. #endif
  969. #if (LCD_NUM_CONTROLLERS >3)
  970. static void LCD_WriteSingleCommand3(char cmd) {
  971.   LCD_LOCK();
  972.   LCD_WRITECMD3(cmd);
  973.   LCD_UNLOCK();
  974. }
  975. #endif
  977.         /****************************************
  978.         *                                       *
  979.         *        Write double command           *
  980.         *                                       *
  981.         ****************************************/
  983. static void LCD_WriteDoubleCommand0(char P1, char P2) {
  984.   LCD_LOCK();
  985.   WRITE_CMD0(P1);
  986.   WRITE_CMD0(P2);
  987.   LCD_UNLOCK();
  988. }
  989. #if (LCD_NUM_CONTROLLERS >1)
  990. static void LCD_WriteDoubleCommand1(char P1, char P2) {
  991.   LCD_LOCK();
  992.   WRITE_CMD1(P1);
  993.   WRITE_CMD1(P2);
  994.   LCD_UNLOCK();
  995. }
  996. #endif
  997. #if (LCD_NUM_CONTROLLERS >2)
  998. static void LCD_WriteDoubleCommand2(char P1, char P2) {
  999.   LCD_LOCK();
  1000.   LCD_WRITECMD2(P1);
  1001.   LCD_WRITECMD2(P2);
  1002.   LCD_UNLOCK();
  1003. }
  1004. #endif
  1005. #if (LCD_NUM_CONTROLLERS >3)
  1006. static void LCD_WriteDoubleCommand3(char P1, char P2) {
  1007.   LCD_LOCK();
  1008.   LCD_WRITECMD3(P1);
  1009.   LCD_WRITECMD3(P2);
  1010.   LCD_UNLOCK();
  1011. }
  1012. #endif
  1014.         /****************************************
  1015.         *                                       *
  1016.         *          Read data                    *
  1017.         *                                       *
  1018.         ****************************************/
  1020. #if LCD_READABLE
  1021. static U8 LCD_ReadData0(void) {
  1022.   U8 r;
  1023.   LCD_LOCK();
  1024.   READ_DATA0(r);
  1025.   LCD_UNLOCK();
  1026.   return r;
  1027. }
  1028. #if (LCD_NUM_CONTROLLERS >1)
  1029. static U8 LCD_ReadData1(void) {
  1030.   U8 r;
  1031.   LCD_LOCK();
  1032.   READ_DATA1(r);
  1033.   LCD_UNLOCK();
  1034.   return r;
  1035. }
  1036. #endif
  1037. #if (LCD_NUM_CONTROLLERS >2)
  1038. static U8 LCD_ReadData2(void) {
  1039.   U8 r;
  1040.   LCD_LOCK();
  1041.   READ_DATA2(r);
  1042.   LCD_UNLOCK();
  1043.   return r;
  1044. }
  1045. #endif
  1046. #if (LCD_NUM_CONTROLLERS >3)
  1047. static U8 LCD_ReadData3(void) {
  1048.   U8 r;
  1049.   LCD_LOCK();
  1050.   READ_DATA3(r);
  1051.   LCD_UNLOCK();
  1052.   return r;
  1053. }
  1054. #endif
  1055. #endif
  1057.         /****************************************
  1058.         *                                       *
  1059.         *          Read command (status)        *
  1060.         *                                       *
  1061.         ****************************************/
  1063. #if LCD_READABLE
  1064. static U8 LCD_ReadCmd0(void) {
  1065.   U8 r;
  1066.   LCD_LOCK();
  1067.   READ_CMD0(r);
  1068.   LCD_UNLOCK();
  1069.   return r;
  1070. }
  1071. #if (LCD_NUM_CONTROLLERS >1)
  1072. static U8 LCD_ReadCmd1(void) {
  1073.   U8 r;
  1074.   LCD_LOCK();
  1075.   READ_CMD1(r);
  1076.   LCD_UNLOCK();
  1077.   return r;
  1078. }
  1079. #endif
  1080. #if (LCD_NUM_CONTROLLERS >2)
  1081. static U8 LCD_ReadCmd2(void) {
  1082.   U8 r;
  1083.   LCD_LOCK();
  1084.   READ_CMD2(r);
  1085.   LCD_UNLOCK();
  1086.   return r;
  1087. }
  1088. #endif
  1089. #if (LCD_NUM_CONTROLLERS >3)
  1090. static U8 LCD_ReadCmd3(void) {
  1091.   U8 r;
  1092.   LCD_LOCK();
  1093.   READ_CMD3(r);
  1094.   LCD_UNLOCK();
  1095.   return r;
  1096. }
  1097. #endif
  1098. #endif
  1100. /*
  1101.         ****************************************
  1102.         *                                      *
  1103.         *     Write to  all controllers        *
  1104.         *                                      *
  1105.         ****************************************
  1107. Some commands should be written to all controllers at the same time.
  1108. (Commands used in the init-sequence, or display on/off).
  1109. With a multi-controller LCD it can come in handy to have a routine to
  1110. write to all of them at once.
  1111. */
  1113. #if (LCD_NUM_CONTROLLERS ==1)
  1114.   #define LCD_WriteSingleCommandAll LCD_WriteSingleCommand0
  1115. #else
  1116.   void LCD_WriteSingleCommandAll(char cmd) {
  1117.     LCD_WriteSingleCommand0(cmd);
  1118.     LCD_WriteSingleCommand1(cmd);
  1119.     #if (LCD_NUM_CONTROLLERS >2)
  1120.       LCD_WriteSingleCommand2(cmd);
  1121.     #endif
  1122.     #if (LCD_NUM_CONTROLLERS >3)
  1123.       LCD_WriteSingleCommand3(cmd);
  1124.     #endif
  1125.   }
  1126. #endif
  1128. /*
  1129.   ********************************************************************
  1130.   *                                                                  *
  1131.   *                  Hardware access, register level                 *
  1132.   *                                                                  *
  1133.   *           Write Page / Column                                    *
  1134.   *                                                                  *
  1135.   ********************************************************************
  1137.  The following routines are used for all access to the
  1138.  LCD-controller(s).
  1140. */
  1141. #if (LCD_NUM_CONTROLLERS > 1)
  1142.   static U8 CurController;    /* Currently selected controller. All
  1143.                                  hardware operations are executed on
  1144.                                  this particular controller. It is
  1145.                                  more efficient to have a global
  1146.                                  variable than to pass this value as
  1147.                                  parameter many times. And in a low 
  1148.                                  level driver as this one, the
  1149.                                  priority of efficiency is top of
  1150.                                  the list.  */
  1151. #endif
  1152. static U8* pCacheByte;
  1153. static U8 aPage[LCD_NUM_CONTROLLERS];   /* Current page of
  1154.                                            LCD controller(s) */
  1155. static U8 aCAdr[LCD_NUM_CONTROLLERS];   /* Current column adr
  1156.                                            of LCD controller(s) */
  1157. static U8 Page, Col;            /* Page / column of cache byte */
  1158. static U8 DataW_Dirty;          /* Set (1) bits are dirty */
  1159. static U8 DataW_Cache;          /* Data to be written
  1160.                                   (not all bits may be valid !) */
  1161. static U8 DataR_Valid;
  1162. static U8 DataR_Cache;
  1164. /* The coordinates of the cache byte. We save current X,Y as well
  1165.    as Y0/Y1 (min/max) in Y-direction. Note that on this level we
  1166.    always talk about physical coordinates ! */
  1167. static int DataCacheX=-1;   /* x-adr. of currently cached byte.
  1168.                                If it is <0 it is sure invalid ! */
  1169. static int DataCacheY;
  1170. static int DataCacheY0;
  1171. static int DataCacheY1;
  1173. #if LCD_SUPPORT_COMTRANS
  1174.   static int DataCacheYBit0;
  1175. #else
  1176.   #define DataCacheYBit0 DataCacheY0
  1177. #endif
  1179. /*
  1180.         *****************************************
  1181.         *                                       *
  1182.         *         Set Page routines             *
  1183.         *                                       *
  1184.         *****************************************
  1186. These routines set the page-register of their respective
  1187. LCD-controller. Note that page is not what you might imagine,
  1188. but is a section of the controllers internal video RAM.
  1189. For details, please refer to the datasheet.
  1191. */
  1193. static void SetPage0(void) {
  1194.   SET_PAGE0(Page);
  1195.   aPage[0] = Page;
  1196. }
  1198. #if (LCD_NUM_CONTROLLERS > 1)
  1199. static void SetPage1(void) {
  1200.   SET_PAGE1(Page);
  1201.   aPage[1] = Page;
  1202. }
  1203. #endif
  1205. #if (LCD_NUM_CONTROLLERS > 2)
  1206. static void SetPage2(void) {
  1207.   SET_PAGE2(Page);
  1208.   aPage[2] = Page;
  1209. }
  1210. #endif
  1212. #if (LCD_NUM_CONTROLLERS > 3)
  1213. static void SetPage3(void) {
  1214.   SET_PAGE3(Page);
  1215.   aPage[3] = Page;
  1216. }
  1217. #endif
  1219. /*
  1220.         *****************************************
  1221.         *                                       *
  1222.         *         Set column routines           *
  1223.         *                                       *
  1224.         *****************************************
  1225. */
  1227. static void SetCAdr0(void) {
  1228.   #if LCD_SEGOFF0
  1229.     U8 ColP = Col+LCD_SEGOFF0;
  1230.   #else
  1231.     #define ColP Col
  1232.   #endif
  1233.   SET_CADR0(ColP);
  1234.   aCAdr[0] = Col;
  1235.   #if !LCD_SEGOFF0
  1236.     #undef ColP
  1237.   #endif
  1238. }
  1240. #if (LCD_NUM_CONTROLLERS > 1)
  1241. static void SetCAdr1(void) {
  1242.   #if LCD_SEGOFF1
  1243.     U8 ColP = Col+LCD_SEGOFF1;
  1244.   #else
  1245.     #define ColP Col
  1246.   #endif
  1247.   SET_CADR1(ColP);
  1248.   aCAdr[1] = Col;
  1249.   #if !LCD_SEGOFF1
  1250.     #undef ColP
  1251.   #endif
  1252. }
  1253. #endif
  1255. #if (LCD_NUM_CONTROLLERS > 2)
  1256. static void SetCAdr2(void) {
  1257.   #if LCD_SEGOFF2
  1258.     U8 ColP = Col+LCD_SEGOFF2;
  1259.   #else
  1260.     #define ColP Col
  1261.   #endif
  1262.   SET_CADR2(ColP);
  1263.   aCAdr[2] = Col;
  1264.   #if !LCD_SEGOFF2
  1265.     #undef ColP
  1266.   #endif
  1267. }
  1268. #endif
  1270. #if (LCD_NUM_CONTROLLERS > 3)
  1271. static void SetCAdr3(void) {
  1272.   #if LCD_SEGOFF3
  1273.     U8 ColP = Col+LCD_SEGOFF3;
  1274.   #else
  1275.     #define ColP Col
  1276.   #endif
  1277.   SET_CADR3(ColP);
  1278.   aCAdr[3] = Col;
  1279.   #if !LCD_SEGOFF3
  1280.     #undef ColP
  1281.   #endif
  1282. }
  1283. #endif
  1285. /*
  1286.         *****************************************
  1287.         *                                       *
  1288.         *        Read video memory routines     *
  1289.         *                                       *
  1290.         *****************************************
  1291. */
  1293. #if !LCD_CACHE
  1294.   static U8 ReadVMem0() {
  1295.     if (Page !=aPage[0])
  1296.       SetPage0();
  1297.     if (Col != aCAdr[0])
  1298.       SetCAdr0();
  1299.     aCAdr[0]+=2;
  1300.     LCD_ReadData0(Data);        /* Dummy read */
  1301.     return LCD_ReadData0(Data);
  1302.   }
  1303. #else
  1304.   #define ReadVMem0() (*pCacheByte)
  1305. #endif
  1306. #if (LCD_NUM_CONTROLLERS > 1)
  1307.   #if !LCD_CACHE
  1308.     U8 ReadVMem1() {
  1309.       if (Page !=aPage[1])
  1310.         SetPage1();
  1311.       if (Col != aCAdr[1])
  1312.         SetCAdr1();
  1313.       aCAdr[1]+=2;
  1314.       LCD_ReadData1(Data);      /* Dummy read */
  1315.       return LCD_ReadData1(Data);
  1316.     }
  1317.   #else
  1318.     #define ReadVMem1() (*pCacheByte)
  1319.   #endif
  1320. #endif /* LCD_NUM_CONTROLLERS >1 */
  1321. #if (LCD_NUM_CONTROLLERS > 2)
  1322.   #if !LCD_CACHE
  1323.     U8 ReadVMem2() {
  1324.       if (Page !=aPage[2])
  1325.         SetPage2();
  1326.       if (Col != aCAdr[2])
  1327.         SetCAdr2();
  1328.       aCAdr[2]+=2;
  1329.       LCD_ReadData2(Data);      /* Dummy read */
  1330.       return LCD_ReadData2(Data);
  1331.     }
  1332.   #else
  1333.     #define ReadVMem2() (*pCacheByte)
  1334.   #endif
  1335. #endif
  1336. #if (LCD_NUM_CONTROLLERS > 3)
  1337.   #if !LCD_CACHE
  1338.     U8 ReadVMem3() {
  1339.       if (Page !=aPage[3])
  1340.         SetPage3();
  1341.       if (Col != aCAdr[3])
  1342.         SetCAdr3();
  1343.       aCAdr[3]+=2;
  1344.       LCD_ReadData3(Data);      /* Dummy read */
  1345.       return LCD_ReadData3(Data);
  1346.     }
  1347.   #else
  1348.     #define ReadVMem3() (*pCacheByte)
  1349.   #endif
  1350. #endif
  1352. /*
  1353.         *****************************************
  1354.         *                                       *
  1355.         *       Write video memory routines     *
  1356.         *                                       *
  1357.         *****************************************
  1358. */
  1360. #if  LCD_SUPPORT_CACHECONTROL
  1361.   #define CHECK_CACHE_LOCK(Con)                          
  1362.   if (CacheLocked) {                                     
  1363.     U8 ColOff = Col -LCD_FIRSTSEG##Con;                  
  1364.     U8 Bit = ColOff&7;                                   
  1365.     aaCacheDirtyTag##Con[Page][ColOff>>3] |= (1<<Bit);   
  1366.     CacheStat = 1;         /* Mark cache as dirty */     
  1367.     return;                                              
  1368.   }
  1369. #else
  1370.   #define CHECK_CACHE_LOCK(LCDCON)
  1371. #endif
  1372. #define WRITE_VMEM(Con)             
  1373.   CHECK_CACHE_LOCK(Con);            
  1374.   if (Page !=aPage[Con])            
  1375.     SetPage##Con();                 
  1376.   if (Col != aCAdr[Con])            
  1377.     SetCAdr##Con();                 
  1378.   LCD_LOCK();                       
  1379.   WRITE_DATA##Con(DataW_Cache);          
  1380.   LCD_UNLOCK();                     
  1381.   aCAdr[Con]++;
  1383. #if !LCD_CACHE_WRITETHRU
  1384.   #define RETURN_IF_WRITE_NOT_NEEDED(Con) 
  1385.     if ( *pCacheByte == DataW_Cache) 
  1386.       return;
  1387. #else
  1388.   #define RETURN_IF_WRITE_NOT_NEEDED(Con)
  1389. #endif
  1391. #if LCD_CACHE
  1392.   #define CHECK_VMEM_CACHE(Con) 
  1393.     RETURN_IF_WRITE_NOT_NEEDED(Con);                                
  1394.     *pCacheByte = DataW_Cache;
  1395. #else
  1396.   #define CHECK_VMEM_CACHE(Con)
  1397. #endif
  1399. static void WriteVMem0(void) {
  1400.   CHECK_VMEM_CACHE(0);
  1401.   WRITE_VMEM(0);
  1402. }
  1404. #if (LCD_NUM_CONTROLLERS > 1)
  1405. static void WriteVMem1(void) {
  1406.   CHECK_VMEM_CACHE(1);
  1407.   WRITE_VMEM(1);
  1408. }
  1409. #endif
  1411. #if (LCD_NUM_CONTROLLERS > 2)
  1412. static void WriteVMem2(void) {
  1413.   CHECK_VMEM_CACHE(2);
  1414.   WRITE_VMEM(2);
  1415. }
  1416. #endif
  1418. #if (LCD_NUM_CONTROLLERS > 3)
  1419. static void WriteVMem3(void) {
  1420.   CHECK_VMEM_CACHE(3);
  1421.   WRITE_VMEM(3);
  1422. }
  1423. #endif
  1425. /*
  1426.   ********************************************************************
  1427.   *                                                                  *
  1428.   *                Write Cache control                               *
  1429.   *                                                                  *
  1430.   ********************************************************************
  1432. In order to speed up access to the LCD and to avoid flickering, it
  1433. can be necessary to lock the write cache. This means that all drawing
  1434. commands do not affect the hardware it the cache is locked until
  1435. the flush (or unlock) command is given.
  1437. Note: The code could be shortened a bit by defining an add. macro
  1438.       for the code for every controller. This has not been done
  1439.       because it would make debugging even harder.
  1440.       (It is already hard enough)
  1441. */
  1443. #define CHECK_CACHE_BYTE_DIRTY(Controller,Bit)   
  1444.   if (Dirty&(1<<Bit)) {                          
  1445.     if (page !=aPage[Controller]) {              
  1446.       Page = page;                               
  1447.       SetPage##Controller();                     
  1448.     }                                            
  1449.     if (col+Bit != aCAdr[Controller]) {        
  1450.       Col = col+Bit;                             
  1451.       SetCAdr##Controller();                     
  1452.     }                                            
  1453.     LCD_WriteData##Controller(Cache##Controller[page][col+Bit]); 
  1454.     aCAdr[Controller]++;                         
  1455.   }
  1456.     
  1457. #define FLUSH_CACHE_X(Con)                                      
  1458.   for (page=0; page<NUM_PAGES##Con; page++) {
  1459.     for (col8=0; col8<(NUM_COLS##Con+7)/8; col8++) {
  1460.       U8 Dirty;
  1461.       if ((Dirty=aaCacheDirtyTag##Con[page][col8]) !=0) {
  1462.         int col   = col8<<3;
  1463.         aaCacheDirtyTag##Con[page][col8] =0;
  1464.         CHECK_CACHE_BYTE_DIRTY(Con,0);
  1465.         CHECK_CACHE_BYTE_DIRTY(Con,1);
  1466.         CHECK_CACHE_BYTE_DIRTY(Con,2);
  1467.         CHECK_CACHE_BYTE_DIRTY(Con,3);
  1468.         CHECK_CACHE_BYTE_DIRTY(Con,4);
  1469.         CHECK_CACHE_BYTE_DIRTY(Con,5);
  1470.         CHECK_CACHE_BYTE_DIRTY(Con,6);
  1471.         CHECK_CACHE_BYTE_DIRTY(Con,7);                          
  1472.       }                                                         
  1473.     }
  1474.   }
  1476. #if  LCD_SUPPORT_CACHECONTROL
  1477. static void FlushCache(void) {
  1478.   int page;
  1479.   int col8;     /* Column index, 1 inc skips 8 bytes */
  1480.   FLUSH_CACHE_X(0);
  1481.   #if (LCD_NUM_CONTROLLERS >1)
  1482.     FLUSH_CACHE_X(1);
  1483.   #endif
  1484.   #if (LCD_NUM_CONTROLLERS >2)
  1485.     FLUSH_CACHE_X(2);
  1486.   #endif
  1487.   #if (LCD_NUM_CONTROLLERS >3)
  1488.     FLUSH_CACHE_X(3);
  1489.   #endif
  1490. /* Important !!!
  1491.   We have to make sure that the byte-level cache is not level
  1492.   inconsistent because we have modified the Page/Col values. This
  1493.   is done by invalidating the x-position. */
  1494.   DataCacheX=-1;
  1495. }
  1497. U8 LCD_L0_ControlCache(U8 cmd) {
  1498.   switch (cmd) {
  1499.   case LCD_CC_LOCK:   /* Set Cache to lock state.*/
  1500.     CacheLocked =1;
  1501.     break;
  1502.   case LCD_CC_UNLOCK: /* Set Cache to unlock state ... must flush !*/
  1503.     CacheLocked =0;
  1504.   case LCD_CC_FLUSH:  /* Flush cache */
  1505.     if (CacheStat) {
  1506.       CacheStat =0;
  1507.       FlushCache();
  1508.     }
  1509.   }
  1510.   return CacheStat;
  1511. }
  1512. #endif
  1514. /*
  1515.   ********************************************************************
  1516.   *                                                                  *
  1517.   *                                                                  *
  1518.   *         Internal video memory management                         *
  1519.   *                                                                  *
  1520.   *                                                                  *
  1521.   ********************************************************************
  1523. This contains the internal video management of this driver, which is
  1524. the core of it. It has been designed with the following goals:
  1526. + Support for all types of orientaions of display
  1527. + Support for multiple controllers
  1528. + Support for both parallel and serial interface
  1529. + Small RAM footprint
  1530. + Fast execution on all CPUs in all configurations
  1531. + Small code
  1533. It has taken a considerable amount of time to develop, optimize and
  1534. test the concept of this driver. It should pretty much cover most LCDs
  1535. using 15XX controllers; if you feel your configuration is not covered
  1536. by this driver, please get
  1537. in contact with us, preferably via email (support@segger.com).
  1539. */
  1541. #define FLUSH() if (DataW_Dirty) Flush()
  1543. /* For XOR operations, the byte needs to be loaded in order to
  1544.    perform the operation. We also have to make sure that bits which
  1545.    have been previously modified are not forgotten.
  1546.    This essentially means loading only the unmodified bits (for which
  1547.    the bit in DATAW_Dirty is ==0) and leave the other ones unchanged.
  1548. */
  1550. #define LOADDATA()                               
  1551.   if (!DataR_Valid) {                            
  1552.     ReadData();                                  
  1553.     DataW_Cache &= DataW_Dirty;                  
  1554.     DataW_Cache |= DataR_Cache&(~DataW_Dirty);   
  1555.   }
  1557. #if LCD_CACHE
  1558.   #define ReadData() DataR_Cache = *pCacheByte; DataR_Valid= 0xff;
  1559. #else
  1560. static void ReadData(void) {
  1561.   DataR_Valid= 0xff;                    /* All bits are valid. */
  1562.   #if (LCD_NUM_CONTROLLERS == 1)
  1563.     DataR_Cache= ReadVMem0();
  1564.   #else
  1565.     switch (CurController) {
  1566.     case 0:
  1567.       DataR_Cache= ReadVMem0(); break;
  1568.     case 1:
  1569.       DataR_Cache= ReadVMem1(); break;
  1570.     #if (LCD_NUM_CONTROLLERS >2)
  1571.     case 2:
  1572.       DataR_Cache= ReadVMem2(); break;
  1573.     #endif
  1574.     #if (LCD_NUM_CONTROLLERS >3)
  1575.     case 3:
  1576.       DataR_Cache= ReadVMem3(); break;
  1577.     #endif
  1578.     }
  1579.   #endif    /* LCD_NUM_CONTROLLERS == 1 */
  1580. }
  1581. #endif
  1583. #if (LCD_NUM_CONTROLLERS > 1)
  1584. typedef void (tWriteVMem)(void);
  1585. tWriteVMem* aWriteVMemX[] = {
  1586.   WriteVMem0,WriteVMem1
  1587. #if (LCD_NUM_CONTROLLERS >2)
  1588.   ,WriteVMem2
  1589. #endif
  1590. #if (LCD_NUM_CONTROLLERS >3)
  1591.   ,WriteVMem3
  1592. #endif
  1593. }; 
  1594. #endif 
  1596. static void Flush(void) {
  1597.   /* Nothing to write ? Then we are done !*/
  1598.   if (DataW_Dirty==0)
  1599.     return;
  1600.   /* All bits are dirty ? Then write`em all, dont read !!*/
  1601.   if (DataW_Dirty!=0xff) {
  1602.     /* Only some are dirty ... We have to read the byte ! */
  1603.     if (!DataR_Valid) {
  1604.       ReadData();         /* Get current byte in our cache */
  1605.     }
  1606.     DataW_Cache &= DataW_Dirty;
  1607.     DataW_Cache |= DataR_Cache & (~DataW_Dirty);
  1608.   }
  1609.   DataR_Cache = DataW_Cache;
  1610. #if (LCD_NUM_CONTROLLERS == 1)
  1611.   WriteVMem0();
  1612. #else
  1613.   aWriteVMemX[CurController]();
  1614. #endif
  1615.   DataW_Dirty = 0;              /* No more bits to write */
  1616. }
  1618. /*
  1619.         *****************************************
  1620.         *                                       *
  1621.         *         Find Byte                     *
  1622.         *                                       *
  1623.         *****************************************
  1625. Due to the setup options reg. the area of the display which is covered
  1626. by one LCD-controller and the fact that different display controllers
  1627. can controll arbitrary areas of the display as defined in the
  1628. config-file, It can be a tricky job to find out which display
  1629. controller is concerned, where in the video memory of that particular
  1630. controller the byte is located and how many bits are left (i.e. what
  1631. the minimal and maximal physical y-position is).
  1632. Note that this job is a lot easier in a single controller system,
  1633. where the entire routine could be placed in a macro.
  1634. */
  1635. #if (LCD_SUPPORT_SEGTRANS==0)
  1636.   #define CALCCOL(Con) Col  = DataCacheX-LCD_XORG##Con
  1637. #else
  1638.   #define CALCCOL(Con) Col  = LCD__aRow2Seg##Con[DataCacheX-LCD_XORG##Con]
  1639. #endif
  1641. #if (LCD_SUPPORT_COMTRANS==0)
  1642.   #define CALCY(Con) 
  1643.     DataCacheY0 = DataCacheY &(~7);    
  1644.     DataCacheY1 = DataCacheY0+  7;     
  1645.     Page = (DataCacheY0-LCD_YORG##Con)>>3
  1646. #else
  1647.     #define CALCY(Con) 
  1648.     DataCacheY1 = DataCacheY0 = DataCacheY; 
  1649.     {                                       
  1650.       int Com = LCD__aLine2Com##Con[DataCacheY-LCD_YORG##Con]; 
  1651.       Page = Com>>3;                                   
  1652.       DataCacheYBit0 = DataCacheY-(Com&7);             
  1653.     }
  1654. #endif
  1656. #define IF_INLEFT(Con)   if (DataCacheX >= LCD_XORG##Con)
  1657. #define IF_INRIGHT(Con)  if (DataCacheX <= LCD_XORG##Con+LCD_NUM_SEGS##Con-1)
  1658. #define IF_INTOP(Con)    if (DataCacheY >= LCD_YORG##Con)
  1659. #define IF_INBOTTOM(Con) if (DataCacheY <= LCD_YORG##Con+LCD_NUM_COMS##Con-1)
  1661. #define IF_INAREA(Con)                                    
  1662.    IF_INRIGHT(Con)                                        
  1663.    IF_INLEFT(Con)                                         
  1664.    IF_INTOP(Con)                                          
  1665.    IF_INBOTTOM(Con)
  1668. #define CALCXY(Con) 
  1669.   CALCCOL(Con);      
  1670.   CALCY(Con);      
  1671.   pCacheByte = &Cache##Con[Page][Col];  
  1672.   CurController = Con;
  1674. /* This is an optimization for a single controller system */
  1675.   #if (LCD_NUM_CONTROLLERS == 1)
  1676. #define FindByte() 
  1677. CALCCOL(0); CALCY(0); pCacheByte = &Cache0[Page][Col];
  1678. /* CALCCOL(0); CALCY(0); pCacheByte = &Cache0[Page][Col-LCD_FIRSTSEG0];*/
  1679.   #endif
  1681. /* This is an optimization for a 2 controller system */
  1682. #if (LCD_NUM_CONTROLLERS == 2)
  1683.   #if (LCD_XORG0==LCD_XORG1)
  1684.     #undef IF_INAREA
  1685.     #if (LCD_YORG0 == LCD_YORG)
  1686.       #define IF_INAREA(Con) IF_INBOTTOM(Con)
  1687.     #else
  1688.       #define IF_INAREA(Con) IF_INTOP(Con)
  1689.     #endif
  1690. #define FindByte() IF_INAREA(0) { CALCXY(0); } else { CALCXY(1); }
  1691.   #endif
  1692. #endif
  1694. /* The actual routine ... */
  1695. #ifndef FindByte
  1696. static void FindByte(void) {
  1697.   #if (LCD_NUM_CONTROLLERS > 1)
  1698.   /* Check if controller 0 is concerned */
  1699.     IF_INAREA(0)
  1700.     {
  1701.       CALCXY(0);
  1702.       return;
  1703.     }
  1704.   /* Check if controller 1 is concerned, but only
  1705.      in a system with more than 2 controllers */
  1706.   #if (LCD_NUM_CONTROLLERS > 2)
  1707.     IF_INAREA(1)
  1708.   #endif
  1709.     {
  1710.       CALCXY(1);
  1711.       return;
  1712.     }
  1713.   /* Check if controller 2 is concerned */
  1714.     #if (LCD_NUM_CONTROLLERS > 3)
  1715.       #if (LCD_NUM_CONTROLLERS > 3)
  1716.       IF_INAREA(2)
  1717.       #endif
  1718.     {
  1719.       CALCXY(2);
  1720.       return;
  1721.     }
  1722.     #endif
  1723.   /* Check if controller 3 is concerned */
  1724.     #if (LCD_NUM_CONTROLLERS >3)
  1725.       #if (LCD_NUM_CONTROLLERS >4)
  1726.       IF_INAREA(3)
  1727.       #endif
  1728.     {
  1729.       CALCXY(3);
  1730.       return;
  1731.     }
  1732.     #endif
  1733.     /* This should never happen ! */
  1734.   #endif
  1735. }
  1736. #endif
  1738. /*
  1739.         *****************************************
  1740.         *                                       *
  1741.         *         Set new Position              *
  1742.         *                                       *
  1743.         *****************************************
  1744. */
  1746. static void Goto(void) {
  1747.   U8* pCacheByteTemp[2];
  1748.   U8  PageTemp[2];
  1749.   U8  ColTemp[2];
  1750.   #if (LCD_NUM_CONTROLLERS > 1)
  1751.     U8  CurControllerTemp[2];
  1752.   #endif
  1753.   DataR_Valid=0;       /* No info about what's in the data byte */
  1754.   if (DataW_Dirty == 0) {
  1755.     FindByte();
  1756.     return;
  1757.   }
  1758.   /* Save the current values because FindByte will overwrite them */
  1759.   pCacheByteTemp[0]        = pCacheByte;
  1760.   PageTemp[0]              = Page;
  1761.   ColTemp[0]               = Col;
  1762.   #if (LCD_NUM_CONTROLLERS > 1)
  1763.     CurControllerTemp[0]     = CurController;
  1764.   #endif
  1765.   FindByte();
  1766.   if (pCacheByteTemp[0] != pCacheByte) {
  1767.     /* Save the new values */
  1768.     pCacheByteTemp[1]        = pCacheByte;
  1769.     PageTemp[1]              = Page;
  1770.     ColTemp[1]               = Col;
  1771.     #if (LCD_NUM_CONTROLLERS > 1)
  1772.       CurControllerTemp[1] = CurController;
  1773.     #endif
  1774.     /* Restore the old values for writing */
  1775.     pCacheByte        = pCacheByteTemp[0];
  1776.     Page              = PageTemp[0];
  1777.     Col               = ColTemp[0];
  1778.     #if (LCD_NUM_CONTROLLERS > 1)
  1779.       CurController = CurControllerTemp[0];
  1780.     #endif
  1781.     Flush();
  1782.     /* Restore the new (current) values */
  1783.     pCacheByte        = pCacheByteTemp[1];
  1784.     Page              = PageTemp[1];
  1785.     Col               = ColTemp[1];
  1786.     DataR_Valid=0;       /* We have no more info about what's in the data byte */
  1787.     #if (LCD_NUM_CONTROLLERS > 1)
  1788.       CurController = CurControllerTemp[1];
  1789.     #endif
  1790.   }
  1791. }
  1793. /*
  1794.         *****************************************
  1795.         *                                       *
  1796.         *         Set X and Y- Position         *
  1797.         *                                       *
  1798.         *****************************************
  1800.    Check if we already have the right byte in the buffer.
  1801.    This works only if COM-Lines are straight, otherwise it is just
  1802.    a waste of CPU-time.
  1803. */
  1805. #if (LCD_SUPPORT_COMTRANS)
  1806.   #define GotoXY(x,y)                     
  1807.     DataCacheY = y;                                                      
  1808.     DataCacheX = x;                         
  1809.     Goto()
  1810. #else
  1811. static void GotoXY(int x, int y) {
  1812.   DataCacheY = y;                                                          
  1813.   if ((x == DataCacheX) &&                  
  1814.       (y >= DataCacheY0) &&     (y <= DataCacheY1))
  1815.   {
  1816.     return;                                 
  1817.   }                                         
  1818.   DataCacheX = x;                         
  1819.   Goto();
  1820. }
  1821. #endif
  1823. /*
  1824.         *****************************************
  1825.         *                                       *
  1826.         *         Set Y- Position               *
  1827.         *                                       *
  1828.         *****************************************
  1829. */
  1831. #if (!LCD_SUPPORT_COMTRANS)     /* Only used if COMs are straight ! */
  1832. static void GotoY(int y) {
  1833. /* Check if we already have the right byte in the buffer.
  1834.    This works only if COM-Lines are straight, otherwise it is just
  1835.    a waste of CPU-time.
  1836.  */
  1837.   DataCacheY = y;    
  1838.   if ((y >= DataCacheY0) && (y <= DataCacheY1))
  1839.     return;
  1840.   Goto();
  1841. }
  1842. #endif
  1845. #if (LCD_SUPPORT_COMTRANS)
  1846. #define GotoYPlus1()           
  1847.   DataCacheY++;                
  1848.         Goto()
  1849. #else
  1850. static void GotoYPlus1(void) {
  1851.   DataCacheY++;
  1852.   if ((DataCacheY >= DataCacheY0) && (DataCacheY <= DataCacheY1))
  1853.     return;
  1854.         Goto();
  1855. }
  1856. #endif
  1858. /*
  1859.   ********************************************************************
  1860.   *                                                                  *
  1861.   *                Drawing routines, internal                        *
  1862.   *                                                                  *
  1863.   ********************************************************************
  1864. */
  1866. static const U8 Bit2Mask[] = { 1,2,4,8,16,32,64,128 };
  1868. /*
  1869.         *****************************************
  1870.         *                                       *
  1871.         *           Xor pixel                   *
  1872.         *                                       *
  1873.         *****************************************
  1874. */
  1876. /*
  1877. static void XORPIXEL() {
  1878.   U8 HWMask;
  1879.   LOADDATA();
  1880.   HWMask = Bit2Mask[DataCacheY-DataCacheYBit0];
  1881.   DataW_Dirty |= HWMask;
  1882.   DataW_Cache ^= HWMask;
  1883. }
  1884. */
  1885. #define XORPIXEL() {                             
  1886.   U8 HWMask;
  1887.   LOADDATA(); /* For XOR operations, the byte needs to be loaded */ 
  1888.   HWMask = Bit2Mask[DataCacheY-DataCacheYBit0];
  1889.   DataW_Dirty |= HWMask;
  1890.   DataW_Cache ^= HWMask;
  1891. }
  1893. static void XorPixel(void) {
  1894.   XORPIXEL();
  1895. }
  1897. /*
  1898.         *****************************************
  1899.         *                                       *
  1900.         *     Set pixel, internal drawing       *
  1901.         *                                       *
  1902.         *****************************************
  1903. */
  1904. /*
  1905. static void SETPIXEL() {
  1906.   U8 HWMask;
  1907.   HWMask = Bit2Mask[DataCacheY-DataCacheYBit0];
  1908.   DataW_Dirty |= HWMask;
  1909.   DataW_Cache |= HWMask;
  1910. }
  1911. */
  1912. #define SETPIXEL() {                             
  1913.   U8 HWMask;  
  1914.   HWMask = Bit2Mask[DataCacheY-DataCacheYBit0];  
  1915.   DataW_Dirty |= HWMask;  
  1916.   DataW_Cache |= HWMask;  
  1917. }
  1919. static void SetPixel(void) {
  1920.   SETPIXEL();
  1921. }
  1923. /*
  1924.         *********************************************************
  1925.         *                                                       *
  1926.         *       LCD_L0_XorPixel                                 *
  1927.         *                                                       *
  1928.         *********************************************************
  1930. Purpose:  This routine is called by emWin. It writes 1 pixel into the
  1931.           display.
  1933. */
  1935. void LCD_L0_XorPixel(int x, int y) {
  1936.   GotoXY(x,y);
  1937.   LOADDATA();
  1938.   XORPIXEL();
  1939. }
  1941. /*
  1942.         *****************************************
  1943.         *                                       *
  1944.         *       Clear pixel                     *
  1945.         *                                       *
  1946.         *****************************************
  1947. */
  1949. /*
  1950. static void CLRPIXEL() {
  1951.   U8 HWMask;
  1952.   HWMask = Bit2Mask[DataCacheY-DataCacheYBit0];
  1953.   DataW_Dirty |=  HWMask;
  1954.   DataW_Cache &= ~HWMask;
  1955. }
  1956. */
  1957. #define CLRPIXEL() {                             
  1958.   U8 HWMask;      
  1959.   HWMask = Bit2Mask[DataCacheY-DataCacheYBit0]; 
  1960.   DataW_Dirty |=  HWMask;     
  1961.   DataW_Cache &= ~HWMask;     
  1962. }
  1964. static void ClrPixel(void) {
  1965.   CLRPIXEL();
  1966. }
  1968. /*
  1969.         *********************************************************
  1970.         *                                                       *
  1971.         *       LCD_L0_SetPixelIndex                            *
  1972.         *                                                       *
  1973.         *********************************************************
  1975. Purpose:  This routine is called by emWin. It writes 1 pixel into the
  1976.           display.
  1978. */
  1979. void LCD_L0_SetPixelIndex(int x, int y, int ColorIndex) {
  1980.   GotoXY(x,y);
  1981.   LOADDATA();
  1982.   if (ColorIndex) {
  1983.     SETPIXEL();
  1984.   } else {
  1985.     CLRPIXEL();
  1986.   }
  1987.   FLUSH();
  1988. }
  1990. unsigned int LCD_L0_GetPixelIndex(int x, int y) {
  1991.   unsigned int Result;
  1992.   GotoXY(x,y);
  1993.   LOADDATA();
  1994.   Result = DataR_Cache & (1<<(DataCacheY&7));
  1995.   if (Result)
  1996.     return 1;
  1997.   else
  1998.     return 0;
  1999. }
  2001. /*
  2002.         *****************************************
  2003.         *                                       *
  2004.         *       Assign pixel                    *
  2005.         *                                       *
  2006.         *****************************************
  2007. */
  2009. #define ASSIGN_PIXEL(c)          { if(c) { SetPixel(); } else ClrPixel();}
  2010. /*
  2011. static void ASSIGN_PIXEL_FAST(U8 c)
  2012. {
  2013.   if(c) {
  2014.     if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  2015.       XORPIXEL();
  2016.     } else {
  2017.       SETPIXEL();
  2018.     }
  2019.   } else {
  2020.     CLRPIXEL();
  2021.   }
  2022. }
  2023. */
  2024. #define ASSIGN_PIXEL_FAST(c) 
  2025. { 
  2026.   if(c) { 
  2027.     if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) { 
  2028.       XORPIXEL(); 
  2029.     } else { 
  2030.       SETPIXEL(); 
  2031.     } 
  2032.   } else { 
  2033.     CLRPIXEL(); 
  2034.   } 
  2035. }
  2037. #define ASSIGN_PIXEL_REV(c)      { if(c) { ClrPixel(); } else SetPixel();}
  2038. #define ASSIGN_PIXEL_REV_FAST(c) { if(c) { CLRPIXEL(); } else SETPIXEL();}
  2040. /*
  2041.   ********************************************************************
  2042.   *                                                                  *
  2043.   *           Line drawing routines, internal                        *
  2044.   *                                                                  *
  2045.   ********************************************************************
  2047. There are 2 line drawing routines for horizontal and vertical
  2048. line drawing. Due to the organization of the controllers video ram,
  2049. one of them (the vertical line draw routine) is a lot faster,
  2050. since it cam write up to 8 pixels at a time. This routine is therefor
  2051. used internally for filling of rectangles.
  2052. */
  2054. #if (!LCD_SUPPORT_COMTRANS)
  2055.   static const U8 aMaskStart[8] = { 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80 };
  2056.   static const U8 aMaskEnd  [8] = { 0xff, 0x7f, 0x3f, 0x1f, 0xf,  0x7,  0x3,  0x1 };
  2057. #endif
  2059. static void DrawVLinePhys  (int x, int y0,  int y1) {
  2060. #if (!LCD_SUPPORT_COMTRANS)
  2061.   int yByte = y0 &(~7);
  2062.   U8  Mask = aMaskStart[y0-yByte];
  2063.   if (yByte+7 > y1) {   /* do we have to cut off the end ? */
  2064.     Mask &= aMaskEnd[yByte+7-y1];
  2065.   }
  2066.   CHECK_SCHEDULE(y1-y0+1);
  2067.   GotoXY(x,y0);
  2068.   if ((GUI_Context.DrawMode & LCD_DRAWMODE_XOR) ==0) {
  2069.     if(COLOR) {   /* Set Line */
  2070.       /* Draw first byte */
  2071.       DataW_Dirty |= Mask;
  2072.       DataW_Cache |= Mask;
  2073.       /* Draw middle bytes */
  2074.       yByte+=8;
  2075.       for (; yByte+7 <= y1; yByte+=8) {
  2076.         GotoY(yByte);
  2077.         DataW_Dirty = 0xff;
  2078.         DataW_Cache = 0xff;
  2079.       }
  2080.       /* Draw last (incomplete) byte */
  2081.       if (yByte <= y1) {
  2082.         GotoY(yByte);
  2083.         Mask = aMaskEnd[yByte-y1+7];
  2084.         DataW_Dirty |= Mask;
  2085.         DataW_Cache |= Mask;   
  2086.       }
  2087.     } else {      /* Clear Line */
  2088.       /* Draw first byte */
  2089.       DataW_Dirty |=  Mask;
  2090.       DataW_Cache &= ~Mask;
  2091.       /* Draw middle bytes */
  2092.       yByte+=8;
  2093.       for (; yByte+7 <= y1; yByte+=8) {
  2094.         GotoY(yByte);
  2095.         DataW_Dirty = 0xff;
  2096.         DataW_Cache = 0;
  2097.       }
  2098.       /* Draw last (incomplete) byte */
  2099.       if (yByte <= y1) {
  2100.         GotoY(yByte);
  2101.         Mask = aMaskEnd[yByte-y1+7];
  2102.         DataW_Dirty |=  Mask;
  2103.         DataW_Cache &= ~Mask;   
  2104.       }
  2105.     }
  2106.   } else { /* Xor Line */
  2107.     LOADDATA();
  2108.     /* Draw first byte */
  2109.     DataW_Dirty |= Mask;
  2110.     DataW_Cache ^= Mask;
  2111.     /* Draw middle bytes */
  2112.     yByte+=8;
  2113.     for (; yByte+7 <= y1; yByte+=8) {
  2114.       GotoY(yByte);
  2115.       LOADDATA();           /* for xor, data needs to be in cache */
  2116.       DataW_Dirty  = 0xff;
  2117.       DataW_Cache ^= 0xff;
  2118.     }
  2119.     /* Draw last (incomplete) byte */
  2120.     if (yByte <= y1) {
  2121.       GotoY(yByte);
  2122.       LOADDATA();           /* for xor, data needs to be in cache */
  2123.       Mask = aMaskEnd[yByte-y1+7];
  2124.       DataW_Dirty |= Mask;
  2125.       DataW_Cache ^= Mask;   
  2126.     }
  2127.   }
  2128. #else
  2129.   int NumPixels = y1-y0+1;
  2130.   if (NumPixels<=0)
  2131.     return;
  2132.   CHECK_SCHEDULE(NumPixels);
  2133.   GotoXY(x,y0);
  2134.   if ((GUI_Context.DrawMode & LCD_DRAWMODE_XOR) ==0) {
  2135.     if(COLOR) {   /* Set Line */
  2136.       for (; --NumPixels; ) {
  2137.         SETPIXEL();
  2138.         GotoYPlus1();
  2139.       }
  2140.       SetPixel();
  2141.     } else {      /* Clear Line */
  2142.       for (; --NumPixels; ) {
  2143.         CLRPIXEL();
  2144.         GotoYPlus1();
  2145.       }
  2146.       ClrPixel();
  2147.     }
  2148.   } else { /* Xor Line */
  2149.       for (; --NumPixels; ) {
  2150.       XorPixel();
  2151.       GotoYPlus1();
  2152.     }
  2153.     XorPixel();
  2154.   }
  2155. #endif
  2156. }
  2158. /*
  2159.         *****************************************
  2160.         *                                       *
  2161.         *       Draw horizontal line            *
  2162.         *                                       *
  2163.         *****************************************
  2165. Due to the organisation of the RAM of the LCD-controller, this is the
  2166. slow routine. It is not used by the driver unless there is no
  2167. other choice; for this reason it is not very important to try to
  2168. squeeze the last CPU-bus cycle out of it.
  2169. */
  2171. static void DrawHLinePhys  (int x0, int y,  int x1) {
  2172.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  2173.     for ( ;x0 <= x1; x0++) {
  2174.       GotoXY(x0,y);
  2175.       XorPixel();
  2176.     }
  2177.   } else {
  2178.     if(COLOR) {
  2179.       for ( ;x0 <= x1; x0++) {
  2180.         GotoXY(x0,y);
  2181.         SetPixel();
  2182.       }
  2183.     } else {
  2184.       for ( ;x0 <= x1; x0++) {
  2185.         GotoXY(x0,y);
  2186.         ClrPixel();
  2187.       }
  2188.     }
  2189.   }
  2190. }
  2192. /*
  2193.   ********************************************************************
  2194.   *                                                                  *
  2195.   *                Drawing routines, public                          *
  2196.   *                                                                  *
  2197.   ********************************************************************
  2198. */
  2200. /*
  2201.         *****************************************
  2202.         *                                       *
  2203.         *       LCD_DrawPixel                   *
  2204.         *                                       *
  2205.         *****************************************
  2207. Purpose:  This routine is called by the upper layers of emWin.
  2208.           It writes 1 pixel into the display.
  2210. */
  2212. void LCD_L0_DrawPixel(int x, int y) {
  2213.   #if !LCD_SWAP_XY
  2214.     #define xP x
  2215.     #define yP y
  2216.   #else
  2217.     #define xP y
  2218.     #define yP x
  2219.   #endif
  2220.   GotoXY(xP,yP);
  2221.   ASSIGN_PIXEL_FAST(COLOR);
  2222.   FLUSH();
  2223. }
  2225. /*
  2226.         ****************************************
  2227.         *                                      *
  2228.         *     LCD_DrawHLine                    *
  2229.         *                                      *
  2230.         ****************************************
  2231. */
  2233. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  2234.   #if !LCD_SWAP_XY
  2235.     DrawHLinePhys(x0, y, x1);
  2236.   #else
  2237.     DrawVLinePhys(y,x0, x1);
  2238.   #endif
  2239.   FLUSH();
  2240. }
  2242. /*
  2243.         ****************************************
  2244.         *                                      *
  2245.         *     LCD_DrawVLine                    *
  2246.         *                                      *
  2247.         ****************************************
  2248. */
  2249. void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  2250.   #if !LCD_SWAP_XY
  2251.     DrawVLinePhys(x,y0,y1);
  2252.   #else
  2253.     DrawHLinePhys(y0,x,y1);
  2254.   #endif
  2255.   FLUSH();
  2256. }
  2258. /*
  2259.         *****************************************
  2260.         *                                       *
  2261.         *          LCD_DrawRect                 *
  2262.         *                                       *
  2263.         *****************************************
  2265. */
  2267. void LCD_L0_FillRect(int x0, int y0, int x1, int y1) {
  2268. /* Now map logical to physical coordinates.
  2269.   Phys. and log. coordinates are identical unless x and y are swapped,
  2270.   in which case we simply assign x to y and vice versa.
  2271. */
  2272.   #if !LCD_SWAP_XY
  2273.      #define x0P x0
  2274.      #define y0P y0
  2275.      #define x1P x1
  2276.      #define y1P y1
  2277.   #else
  2278.      #define x0P y0
  2279.      #define y0P x0
  2280.      #define x1P y1
  2281.      #define y1P x1
  2282.   #endif
  2283.   for (; x0P <= x1P; x0P++) {
  2284.     DrawVLinePhys (x0P, y0P, y1P);
  2285.   }
  2286.   FLUSH();
  2287. }
  2289. /*
  2290.   ***************************************************************
  2291.   *                                                             *
  2292.   *            Internal bitmap routines                         *
  2293.   *                                                             *
  2294.   ***************************************************************
  2296. */
  2298. /*
  2299.     *********************************************
  2300.     *                                           *
  2301.     *      Draw Bitmap 1 BPP optimized          *
  2302.     *                                           *
  2303.     *********************************************
  2305. There are 2 versions of this routine, depending on if the display
  2306. is turned (X<-->Y swapped) or not.
  2307. */
  2309. #if !LCD_SWAP_XY
  2310. static void  DrawBitLine1BPP_NoSwap(
  2311.              int x, int y
  2312.              ,U8 const*pData
  2313.              ,int size
  2314.              ,const LCD_PIXELINDEX*pTrans
  2315.               ,int BytesPerLine
  2316.               ,U8 Mask)
  2317. {
  2318. /*
  2319. // Check if there is something left to draw
  2320. */
  2321.   GotoXY(x,y);
  2322.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR | LCD_DRAWMODE_REV)) {
  2323.   case LCD_DRAWMODE_NORMAL:
  2324.   case LCD_DRAWMODE_REV:
  2325.     for (; size>0; size--, pData+=BytesPerLine) {
  2326.       if(*pData & Mask) {
  2327.         if (*(pTrans+1)) { SETPIXEL(); }
  2328.         else             { CLRPIXEL(); }
  2329.       } else {
  2330.         if (*(pTrans  )) { SETPIXEL(); }
  2331.         else             { CLRPIXEL(); }
  2332.       }
  2333.       GotoYPlus1();
  2334.     }
  2335.     break;
  2336.   case LCD_DRAWMODE_XOR:
  2337.     for (; size>=1; size--, pData+=BytesPerLine) {
  2338.       if (*pData & Mask) { XORPIXEL(); }
  2339.       GotoYPlus1();
  2340.     }
  2341.     break;
  2342.   case LCD_DRAWMODE_TRANS:
  2343.     if (*(pTrans+1)) {  /* foreground positiv */
  2344.       for (; size>0; size--, pData+=BytesPerLine) {
  2345.         if(*pData & Mask) { SETPIXEL(); }
  2346.         GotoYPlus1();
  2347.       }
  2348.     } else {
  2349.       for (; size>0; size--, pData+=BytesPerLine) {
  2350.         if(*pData & Mask) { CLRPIXEL(); }
  2351.         GotoYPlus1();
  2352.       }
  2353.     }
  2354.     break;
  2355.   }
  2356. }
  2357. #else
  2358. static void  DrawBitLine1BPP_Swap(
  2359.              int x, int y
  2360.              ,U8 const*pData
  2361.              ,int size
  2362.              ,const U8*pTrans
  2363.              ,int BitNo)
  2364. {
  2365.   U8 Mask = 0x80>>(BitNo&7);
  2366.   pData += (BitNo>>3);
  2367. /*
  2368. // Check if there is something left to draw
  2369. */
  2370.   if (size <=0)
  2371.     return;
  2372.   GotoXY(x,y);
  2373.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
  2374.   case 0:
  2375.     if (*(pTrans+1)) {  /* foreground positiv */
  2376.       for (; size>1; size--) {
  2377.         ASSIGN_PIXEL_FAST(*pData & Mask);
  2378.         GotoYPlus1();
  2379.         if ((Mask >>=1)==0) {
  2380.           Mask =0x80;
  2381.           pData++;
  2382.         }
  2383.       }
  2384.       ASSIGN_PIXEL(*pData & Mask);
  2385.     } else {
  2386.       for (; size>1; size--) {
  2387.         ASSIGN_PIXEL_REV_FAST(*pData & Mask);
  2388.         GotoYPlus1();
  2389.         if ((Mask >>=1)==0) {
  2390.            Mask =0x80;
  2391.           pData++;
  2392.         }
  2393.       }
  2394.       ASSIGN_PIXEL_REV(*pData & Mask);
  2395.     }
  2396.     break;
  2397.   case LCD_DRAWMODE_TRANS:
  2398.     if (*(pTrans+1)) {  /* foreground positiv */
  2399.       for (; size>1; size--) {
  2400.         if(*pData & Mask) { SETPIXEL(); }
  2401.         GotoYPlus1();
  2402.         if ((Mask >>=1)==0) {
  2403.           Mask =0x80;
  2404.           pData++;
  2405.         }
  2406.       }
  2407.       ASSIGN_PIXEL(*pData & Mask);
  2408.     } else {
  2409.       for (; size>1; size--) {
  2410.         if(*pData & Mask) { CLRPIXEL(); }
  2411.         GotoYPlus1();
  2412.         if ((Mask >>=1)==0) {
  2413.            Mask =0x80;
  2414.           pData++;
  2415.         }
  2416.       }
  2417.       ASSIGN_PIXEL_REV(*pData & Mask);
  2418.     }
  2419.     break;
  2420.   case LCD_DRAWMODE_XOR:
  2421.     /* todo bugfix */
  2422.     for (; size>1; size--,y++) {
  2423.       if (*pData & Mask)
  2424.         XorPixel();
  2425.       GotoYPlus1();
  2426.       if ((Mask >>=1)==0) {
  2427.         Mask =0x80;
  2428.         pData++;
  2429.       }
  2430.     }
  2431.     if (*pData & Mask)
  2432.       XorPixel();
  2433.     break;
  2434.   }
  2435. }
  2436. #endif
  2438. /*
  2439.     *********************************************
  2440.     *                                           *
  2441.     *      Draw Bitmap 2 BPP                    *
  2442.     *                                           *
  2443.     *********************************************
  2444. */
  2446. #if (LCD_MAX_LOG_COLORS > 2)
  2448. static void  DrawBitLine2BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  2449.   LCD_PIXELINDEX pixel;
  2450. /*
  2451.         Jump to right entry point
  2452. */
  2453.   pixel = *p;
  2454.   if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) switch (Diff&3) {
  2455.   case 0:
  2456.     goto WriteTBit0;
  2457.   case 1:
  2458.     goto WriteTBit1;
  2459.   case 2:
  2460.     goto WriteTBit2;
  2461.   default:
  2462.     goto WriteTBit3;
  2463.   } else switch (Diff&3) {
  2464.   case 0:
  2465.     goto WriteBit0;
  2466.   case 1:
  2467.     goto WriteBit1;
  2468.   case 2:
  2469.     goto WriteBit2;
  2470.   default:
  2471.     goto WriteBit3;
  2472.   }
  2473. /*
  2474.         Write without transparency
  2475. */
  2476. WriteBit0:
  2477.   LCD_L0_SetPixelIndex(x+0, y, *(pTrans+(pixel>>6)));
  2478.   if (!--xsize)
  2479.     return;
  2480. WriteBit1:
  2481.   LCD_L0_SetPixelIndex(x+1, y, *(pTrans+(3&(pixel>>4))));
  2482.   if (!--xsize)
  2483.     return;
  2484. WriteBit2:
  2485.   LCD_L0_SetPixelIndex(x+2, y, *(pTrans+(3&(pixel>>2))));
  2486.   if (!--xsize)
  2487.     return;
  2488. WriteBit3:
  2489.   LCD_L0_SetPixelIndex(x+3, y, *(pTrans+(3&(pixel))));
  2490.   if (!--xsize)
  2491.     return;
  2492.   pixel = *(++p);
  2493.   x+=4;
  2494.   goto WriteBit0;
  2495. /*
  2496.         Write with transparency
  2497. */
  2498. WriteTBit0:
  2499.   if (pixel&(3<<6))
  2500.     LCD_L0_SetPixelIndex(x+0, y, *(pTrans+(pixel>>6)));
  2501.   if (!--xsize)
  2502.     return;
  2503. WriteTBit1:
  2504.   if (pixel&(3<<4))
  2505.     LCD_L0_SetPixelIndex(x+1, y, *(pTrans+(3&(pixel>>4))));
  2506.   if (!--xsize)
  2507.     return;
  2508. WriteTBit2:
  2509.   if (pixel&(3<<2))
  2510.     LCD_L0_SetPixelIndex(x+2, y, *(pTrans+(3&(pixel>>2))));
  2511.   if (!--xsize)
  2512.     return;
  2513. WriteTBit3:
  2514.   if (pixel&(3<<0))
  2515.     LCD_L0_SetPixelIndex(x+3, y, *(pTrans+(3&(pixel))));
  2516.   if (!--xsize)
  2517.     return;
  2518.   pixel = *(++p);
  2519.   x+=4;
  2520.   goto WriteTBit0;
  2521. }
  2523. #endif
  2525. /*
  2526.     *********************************************
  2527.     *                                           *
  2528.     *      Draw Bitmap 4 BPP                    *
  2529.     *                                           *
  2530.     *********************************************
  2531. */
  2533. #if (LCD_MAX_LOG_COLORS > 4)
  2535. static void  DrawBitLine4BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  2536.   LCD_PIXELINDEX pixel;
  2537. /*
  2538.         Jump to right entry point
  2539. */
  2540.   pixel = *p;
  2541.   if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) {
  2542.     if ((Diff&1) ==0)
  2543.       goto WriteTBit0;
  2544.     goto WriteTBit1;
  2545.   } else {
  2546.     if ((Diff&1) ==0)
  2547.       goto WriteBit0;
  2548.     goto WriteBit1;
  2549.   }
  2550. /*
  2551.         Write without transparency
  2552. */
  2553. WriteBit0:
  2554.   LCD_L0_SetPixelIndex(x+0, y, *(pTrans+(pixel>>4)));
  2555.   if (!--xsize)
  2556.     return;
  2557. WriteBit1:
  2558.   LCD_L0_SetPixelIndex(x+1, y, *(pTrans+(pixel&0xf)));
  2559.   if (!--xsize)
  2560.     return;
  2561.   x+=2;
  2562.   pixel = *(++p);
  2563.   goto WriteBit0;
  2564. /*
  2565.         Write with transparency
  2566. */
  2567. WriteTBit0:
  2568.   if (pixel>>4)
  2569.     LCD_L0_SetPixelIndex(x+0, y, *(pTrans+(pixel>>4)));
  2570.   if (!--xsize)
  2571.     return;
  2572. WriteTBit1:
  2573.   if (pixel&0xf)
  2574.     LCD_L0_SetPixelIndex(x+1, y, *(pTrans+(pixel&0xf)));
  2575.   if (!--xsize)
  2576.     return;
  2577.   x+=2;
  2578.   pixel = *(++p);
  2579.   goto WriteTBit0;
  2580. }
  2582. #endif
  2584. /*
  2585.     *********************************************
  2586.     *                                           *
  2587.     *      Draw Bitmap 8 BPP  (256 colors)      *
  2588.     *                                           *
  2589.     *********************************************
  2590. */
  2592. #if (LCD_MAX_LOG_COLORS > 16)
  2594. static void  DrawBitLine8BPP(int x, int y, U8 const*p, int xsize, const LCD_PIXELINDEX*pTrans) {
  2595.   LCD_PIXELINDEX pixel;
  2596.   if ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS)==0) {
  2597.     while (xsize > 0) {
  2598.       pixel = *p;
  2599.       LCD_L0_SetPixelIndex(x+0, y, *(pTrans+pixel));
  2600.       xsize--;
  2601.       x++;
  2602.       p++;
  2603.     }
  2604.   } else {   /* Handle transparent bitmap */
  2605.     while (xsize > 0) {
  2606.       pixel = *p;
  2607.       if (pixel)
  2608.         LCD_L0_SetPixelIndex(x+0, y, *(pTrans+pixel));
  2609.       xsize--;
  2610.       x++;
  2611.       p++;
  2612.     }
  2613.   }
  2614. }
  2616. #endif
  2618. /*
  2619.     ******************************************************************
  2620.     *                                                                *
  2621.     *             Universal draw Bitmap routine                      *
  2622.     *                                                                *
  2623.     ******************************************************************
  2624. */
  2626. void LCD_L0_DrawBitmap   (int x0, int y0,
  2627.                        int xsize, int ysize,
  2628.                        int BitsPerPixel, 
  2629.                        int BytesPerLine,
  2630.                        const U8* pData, int Diff,
  2631.                        const LCD_PIXELINDEX* pTrans)
  2632. {
  2633.   int i;
  2634.   /* Use aID for bitmaps without palette */
  2635.   if (!pTrans) {
  2636.     pTrans = aID;
  2637.   }
  2638.   /*
  2639.      Use DrawBitLineXBPP
  2640.   */
  2641.   #if !LCD_SWAP_XY
  2642.     switch (BitsPerPixel) {
  2643.     case 1:
  2644.       xsize+=Diff&7;
  2645.       for (i=Diff; i<xsize; i++) {
  2646.         DrawBitLine1BPP_NoSwap(x0+i, y0,
  2647.                                pData+(i>>3),
  2648.                                ysize,
  2649.                                pTrans,
  2650.                                BytesPerLine,
  2651.                                0x80>>(i&7));
  2652.       }
  2653.       break;
  2654.       #if (LCD_MAX_LOG_COLORS > 2)
  2655.         case 2:
  2656.           for (i=0; i<ysize; i++) {
  2657.             DrawBitLine2BPP(x0, i+y0, pData, Diff, xsize, pTrans);
  2658.             pData += BytesPerLine;
  2659.           }
  2660.           break;
  2661.       #endif
  2662.       #if (LCD_MAX_LOG_COLORS > 4)
  2663.         case 4:
  2664.           for (i=0; i<ysize; i++) {
  2665.             DrawBitLine4BPP(x0, i+y0, pData, Diff, xsize, pTrans);
  2666.             pData += BytesPerLine;
  2667.           }
  2668.           break;
  2669.       #endif
  2670.       #if (LCD_MAX_LOG_COLORS > 16)
  2671.         case 8:
  2672.           for (i=0; i<ysize; i++) {
  2673.             DrawBitLine8BPP(x0, i+y0, pData, xsize, pTrans);
  2674.             pData += BytesPerLine;
  2675.           }
  2676.           break;
  2677.       #endif
  2678.     }
  2679.   #else
  2680.     switch (BitsPerPixel) {
  2681.     case 1:
  2682.       for (i=0; i<ysize; i++) {
  2683.         DrawBitLine1BPP_NoSwap(x0+i, y0,
  2684.                                pData+(i>>3),
  2685.                                ysize,
  2686.                                pTrans,
  2687.                                BytesPerLine,
  2688.                                0x80>>(i&7));
  2689.         pData += BytesPerLine;
  2690.       }
  2691.       break;
  2692.     }
  2693.   #endif
  2694.   FLUSH();
  2695. }
  2697. /*
  2698.         *********************************************************
  2699.         *                                                       *
  2700.         *       LCD_L0_SetOrg                                   *
  2701.         *                                                       *
  2702.         *********************************************************
  2704. Purpose: 
  2705.   Sets the original position of the virtual display.
  2706.   Has no function at this point with this driver,
  2707.   because the 15XX uses built-in memory as video memory.
  2708.   This memory is just big enough to store the info needed
  2709.   for the max. display resolution supported.
  2710. */
  2712. #if LCD_SUPPORT_SETORG
  2714. int OrgX, OrgY;
  2715. void LCD_L0_SetOrg(int x, int y) {
  2716.   OrgX = x;
  2717.   OrgY = y;
  2718. }
  2719. #endif
  2721. /*
  2722.         *********************************************************
  2723.         *                                                       *
  2724.         *       Support for dynamic inversion of LCD            *
  2725.         *                                                       *
  2726.         *********************************************************
  2728. */
  2730. #if LCD_SUPPORT_RT_INVERSION
  2731. void LCD_SetInverse   (void) {
  2732.   LCD_WriteSingleCommandAll(LCD_CMDREVERSE);  
  2733. }
  2735. /* This function is always available, it can not be eliminated
  2736.    by means of a configuration switch ! */
  2737. void LCD_ClrInverse   (void) {
  2738.   LCD_WriteSingleCommandAll(LCD_CMDNORMAL);  
  2739. }
  2740. #endif
  2742. /*
  2743.   ********************************************************************
  2744.   *                                                                  *
  2745.   *                       Refresh the Display                        *
  2746.   *                                                                  *
  2747.   ********************************************************************
  2748. */
  2750. /*
  2751.         *************************************************
  2752.         *                                               *
  2753.         *           Refresh display partially           *
  2754.         *                                               *
  2755.         *************************************************
  2756. */
  2758. #if LCD_SUPPORT_REFRESH
  2760. static U8 RefreshPage;
  2762. static void LCD_RefreshSection(void) {
  2763.   U8 OldPage = Page;
  2764.   U8 OldCol  = Col;
  2765.   U8* pData;
  2766.   Page = RefreshPage++;
  2767.   SetPage0();
  2768.   Col=0;
  2769.   SetCAdr0();
  2770.   pData = &Cache0[Page][Col];
  2771.   for (; Col<=LCD_NUM_SEGS0; Col++) {
  2772.     LCD_WriteData0(*pData++);
  2773.   }
  2774.   Page = OldPage;
  2775.   Col  = OldCol;
  2776.   if (RefreshPage >= NUM_PAGES0) {
  2777.     RefreshPage=0;
  2778.   }
  2779. }
  2781. /*
  2782.         *************************************************
  2783.         *                                               *
  2784.         *           Refresh entire display              *
  2785.         *                                               *
  2786.         *************************************************
  2787. */
  2789. void LCD_L0_Refresh(void) {
  2790.   int i;
  2791.   for (i=0; i<NUM_PAGES0; i++) {
  2792.     LCD_RefreshSection();
  2793.   }
  2794. }
  2795. #endif
  2797. /*
  2798.         *********************************************************
  2799.         *                                                       *
  2800.         *           Support for verification                    *
  2801.         *                                                       *
  2802.         *********************************************************
  2803. */
  2805. #if LCD_SUPPORT_VERIFY
  2806. static int ErrCnt;
  2807. static int ErrStat;
  2809. int  LCD_GetErrStat(void) {
  2810.   return ErrStat;
  2811. }
  2813. void LCD_ClrErrStat(void) {
  2814.   ErrStat = ErrCnt=0;
  2815. }
  2817. int  LCD_GetErrCnt (void) {
  2818.   return ErrCnt;
  2819. }
  2820. #endif  
  2822. /*
  2823.         *********************************************************
  2824.         *                                                       *
  2825.         *       LCD_On                                          *
  2826.         *       LCD_Off                                         *
  2827.         *                                                       *
  2828.         *********************************************************
  2829. */
  2831. #if LCD_SUPPORT_CHECKINIT
  2832.   static char IsOn;           /* Only needed for init check ! */
  2833. #endif
  2835. void LCD_On           (void) {
  2836.   LCD_WriteSingleCommandAll(CMD_LCD_ON);  
  2837.   #if LCD_SUPPORT_CHECKINIT
  2838.     IsOn =1;
  2839.   #endif
  2840. }
  2842. void LCD_Off          (void) {
  2843.   LCD_WriteSingleCommandAll(CMD_LCD_OFF);  
  2844.   #if LCD_SUPPORT_CHECKINIT
  2845.     IsOn =0;
  2846.   #endif
  2847. }
  2849. /*
  2850.         *********************************************************
  2851.         *                                                       *
  2852.         *       Support for different pages                     *
  2853.         *                                                       *
  2854.         *********************************************************
  2855. */
  2857. #if LCD_SUPPORT_PAGING
  2858. static U8 VisPage;
  2859. static U8 SelPage;
  2860. static int    XAdd;
  2862. int LCD_SelPage  (int Page) {
  2863.   int r = SelPage;
  2864.   SelPage = Page;
  2865.   XAdd = Page * LCD_XSIZE;
  2866.   return r;
  2867. }
  2869. int LCD_ShowPage (int Page) {
  2870.   int r = SelPage;
  2871.   SelPage = Page;
  2872. /* Update hardware */
  2873.   return r;
  2874. }
  2876. /* returns selected page */
  2877. int LCD_GetSelPage (void) {
  2878.   return SelPage;
  2879. }
  2880. /* returns visible page */
  2881. int LCD_GetVisPage (void) {
  2882.   return VisPage;
  2883. }
  2885. #endif
  2888. /*
  2889. *********************************************************
  2890. *
  2891. *       LCD_L0_ReInit : Re-Init the display
  2892. *
  2893. *********************************************************
  2895. ReInit contains all of the code that can be re-executed at any point without
  2896. changing or even disturbing what can be seen on the LCD.
  2897. Note that it is also used as a subroutine by LCD_Init().
  2899. */
  2901. #if LCD_MIRROR_X
  2902.   #define LCD_CMDSETADC 0xa1     /* ADC select: reverse  segment
  2903.                                     driver output (mirroring X) */
  2904. #else
  2905.   #define LCD_CMDSETADC 0xa0     /* ADC select: normal segment driver output */
  2906. #endif
  2908. #if LCD_MIRROR_Y
  2909.   #if LCD_CONTROLLER == 1560
  2910.     #error MIRROR_Y not supported for 1560 ! (Use LCD_INIT_CONTROLLER instead)
  2911.   #endif
  2912.   #define LCD_CMDCOMMODE  0xc8   /* Common mode : reverse output (mirroring Y) */
  2913. #else
  2914.   #define LCD_CMDCOMMODE  0xc0   /* Common mode : normal */
  2915. #endif
  2917. void  LCD_L0_ReInit(void) {
  2918.   int i;
  2919.   for (i=0; i<LCD_NUM_CONTROLLERS; i++) {
  2920.     aPage[i] = aCAdr[i] = 255;
  2921.   }
  2922.   INIT_CONTROLLER();                     /* macro defined in config */
  2923.   #if (LCD_CONTROLLER/100 == 15)
  2924.     LCD_WriteSingleCommandAll(LCD_CMDSETADC);      /* ADC select   */
  2925.     #if LCD_CONTROLLER != 1560                     /* This command is not available for the 1560 ! */
  2926.       LCD_WriteSingleCommandAll(LCD_CMDCOMMODE);   /* Set common mode */
  2927.     #endif
  2928.     LCD_WriteSingleCommandAll(LCD_FIRSTCOM0+0x40); /* Set start adress */
  2929.     LCD_WriteSingleCommandAll(0xA4);               /* Data Display Mode (not all on)  */
  2930.     LCD_WriteSingleCommandAll(LCD_CMDNORMAL);      /* Normal (Not reversed) mode  */
  2931.   #endif
  2932. }
  2934. static void LCD__ClearVRam(void) {
  2935.   for (Page=0; Page <=8; Page++) {
  2936.     SetPage0();
  2937.     #if (LCD_NUM_CONTROLLERS >1)
  2938.       SetPage1();
  2939.     #endif
  2940.     #if (LCD_NUM_CONTROLLERS >2)
  2941.       SetPage2();
  2942.     #endif
  2943.     #if (LCD_NUM_CONTROLLERS >3)
  2944.       SetPage3();
  2945.     #endif
  2946.     Col=0;
  2947.     SetCAdr0();
  2948.     #if (LCD_NUM_CONTROLLERS >1)
  2949.       SetCAdr1();
  2950.     #endif
  2951.     #if (LCD_NUM_CONTROLLERS >2)
  2952.       SetCAdr2();
  2953.     #endif
  2954.     #if (LCD_NUM_CONTROLLERS >3)
  2955.       SetCAdr3();
  2956.     #endif
  2957.     for (; Col<=LCD_SEGS_MAX; Col++) {
  2958.       LCD_WriteData0(0);
  2959.       #if (LCD_NUM_CONTROLLERS >1)
  2960.         LCD_WriteData1(0);
  2961.       #endif
  2962.       #if (LCD_NUM_CONTROLLERS >2)
  2963.         LCD_WriteData2(0);
  2964.       #endif
  2965.       #if (LCD_NUM_CONTROLLERS >3)
  2966.         LCD_WriteData3(0);
  2967.       #endif
  2968.     }
  2969.     memset (&aCAdr, LCD_SEGS_MAX-1, sizeof(aCAdr));    /* Invalidate register caches */
  2970.   }
  2971. }
  2973. /********************************************************
  2974. *
  2975. *       LCD_L0_SetOrg
  2976. *
  2977. *********************************************************
  2978. */
  2979. void LCD_L0_SetOrg(int x, int y) {
  2980.   LCD_USE_PARA(x);
  2981.   LCD_USE_PARA(y);
  2982. }
  2985. /*
  2986.         *********************************************************
  2987.         *                                                       *
  2988.         *       LCD_Init : Init the display                     *
  2989.         *                                                       *
  2990.         *********************************************************
  2991. */
  2993. #define ZEROINIT(var) memset(&var,0,sizeof(var))
  2995. int  LCD_L0_Init(void) {
  2996. /* Initialize static variables */
  2997. /* Clear Cache (If a cache has been configured) */
  2998.   #if LCD_CACHE
  2999.     ZEROINIT(Cache0);
  3000.     #if (LCD_NUM_CONTROLLERS >1)
  3001.       ZEROINIT(Cache1);
  3002.     #endif
  3003.     #if (LCD_NUM_CONTROLLERS >2)
  3004.       ZEROINIT(Cache2);
  3005.     #endif
  3006.     #if (LCD_NUM_CONTROLLERS >3)
  3007.       ZEROINIT(Cache3);
  3008.     #endif
  3009.   #endif
  3010.   #if  LCD_SUPPORT_CACHECONTROL
  3011.     CacheStat   =0;     /* 0: No changes */
  3012.     CacheLocked =0;     /* 0: Not locked */
  3013.     ZEROINIT(aaCacheDirtyTag0);
  3014.     #if (LCD_NUM_CONTROLLERS >1)
  3015.       ZEROINIT(aaCacheDirtyTag1);
  3016.     #endif
  3017.     #if (LCD_NUM_CONTROLLERS >2)
  3018.       ZEROINIT(aaCacheDirtyTag2);
  3019.     #endif
  3020.     #if (LCD_NUM_CONTROLLERS >3)
  3021.       ZEROINIT(aaCacheDirtyTag3);
  3022.     #endif
  3023.   #endif
  3024.   memset (&aPage, 255, sizeof(aPage));    /* Invalidate register caches */
  3025.   memset (&aCAdr, 255, sizeof(aCAdr));    /* Invalidate register caches */
  3026.   DataCacheX=-1;         /* Invalidate byte level cache */
  3027.   #if LCD_SUPPORT_VERIFY
  3028.     ErrCnt =0;
  3029.     ErrStat=0;
  3030.   #endif
  3031.   LCD_Off();
  3032.   LCD_L0_ReInit();
  3033. #if 0 /* For LCD-Test */
  3034.   LCD__ClearVRam();
  3035.   for (Page=0; Page <=8; Page++) {
  3036.     int Bit;
  3037.     SetPage0();
  3038.         for (Bit=0; Bit<=7; Bit++) {
  3039.       int Data = ((2<<Bit)-1);
  3040.           for (Col=0, SetCAdr0(); Col<=LCD_SEGS_MAX; Col++) {
  3041.         LCD_WriteData0(Data);
  3042.           }
  3043.         }
  3044.   }
  3045.   for (Page=0; Page <=8; Page++) {
  3046.     int Bit;
  3047.     SetPage1();
  3048.         for (Bit=0; Bit<=7; Bit++) {
  3049.       int Data = ((2<<Bit)-1);
  3050.           for (Col=0, SetCAdr1(); Col<=LCD_SEGS_MAX; Col++) {
  3051.         LCD_WriteData1(Data);
  3052.           }
  3053.         }
  3054.   }
  3055. #endif
  3056.   LCD__ClearVRam();
  3057.   LCD_On();
  3058.   return 0;
  3059. }
  3061. /*
  3062.         *********************************************************
  3063.         *                                                       *
  3064.         *                   LCD_L0_SetLUTEntry                     *
  3065.         *                                                       *
  3066.         *********************************************************
  3068.   This function is required, but has no functionality
  3069.   with 15XX controllers
  3070. */
  3072. void LCD_L0_SetLUTEntry(U8 Pos, LCD_COLOR color) {
  3073.   LCD_USE_PARA(Pos);
  3074.   LCD_USE_PARA(color);
  3075. }
  3077. /*
  3078.         *********************************************************
  3079.         *                                                       *
  3080.         *       LCD_L0_CheckInit                                   *
  3081.         *                                                       *
  3082.         *  Check if display controller(s) is/are still          *
  3083.         *  properly initialized                                 *
  3084.         *                                                       *
  3085.         *********************************************************
  3087. Return value:   0 => No error, init is O.K.
  3088. */
  3090. /* Create the mask to compare statuss with.
  3091.    The mask depends on the configuration.
  3092.    For details, refer to the manual page 8-49.
  3093. */
  3095. #if LCD_SUPPORT_CHECKINIT
  3096. int LCD_L0_CheckInit(void) {
  3097.   #if !LCD_READABLE
  3098.     return 0;           /* If LCD is not readable, there is
  3099.                            no way to check the configuration ! */
  3100.   #else
  3101.     /* Unfortunately, we can not read back the controller .
  3102.        The only thing that we can do is a status check.  */
  3103.     U8 Stat = LCD_ReadCmd0();
  3104.     /* Status of all controllers should be identical */
  3105.     #if (LCD_NUM_CONTROLLERS >1)
  3106.       if (Stat != LCD_ReadCmd1())
  3107.         return 1;
  3108.     #endif
  3109.     #if (LCD_NUM_CONTROLLERS >2)
  3110.       if (Stat != LCD_ReadCmd2())
  3111.         return 1;
  3112.     #endif
  3113.     #if (LCD_NUM_CONTROLLERS >3)
  3114.       if (Stat != LCD_ReadCmd3())
  3115.         return 1;
  3116.     #endif
  3117.     if (IsOn)
  3118.       Stat ^= (1<<5);   /* xor the on/off bit,
  3119.                           result should be 0 if O.K. */
  3120.     #if !LCD_MIRROR_X
  3121.       Stat ^= (1<<6);   /* xor the adc bit,
  3122.                           result should be 0 if O.K. */
  3123.     #endif
  3124.     return Stat;        /* will be 0 if all bits are O.K. */
  3125.   #endif
  3126. }
  3127. #endif
  3130. #else
  3132. void LCD15XX(void) { } /* avoid empty object files */
  3134. #endif /* (LCD_CONTROLLER/100 == 15) */
  3136. /* **************** END OF FILE ********************* */