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

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

uCOS

开发平台：

C/C++

LCD6642X.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        : 
  16. Purpose     : 
  17. ----------------------------------------------------------------------
  18. Version-Date---Author-Explanation
  19. ----------------------------------------------------------------------
  20. 1.04f   020204 JE     a) Hardwareinterface routines renamed:
  21.                          ...REG01 -> ...A1, ...REG00 -> ...A0
  22. 1.04e   010706 JE     a) Bugfixes in DrawBitLine1BPP_Swap
  23. 1.04d   010627 JE     a) Bugfix in DrawBitLine1BPP_Swap
  24. 1.04c   010420 JE     a) Defaults for config switches added
  25. 1.04b   010418 JE     a) Accelerations of DrawVLine changed 
  26.                          for using with cache
  27.                       b) LCD_L0_DrawBitmap changed
  28. 1.04a   010417 RS     a) DrawVLine for "Philips mode" accelerated
  29. 1.04    010411 JE     a) 2bpp bitmaps accelerated
  30.                       b) 1bpp bitmaps accelerated
  31. 1.02    010406 JE     a) Use of cache completed
  32.                       b) DrawVLine optimized
  33. 1.00    010401 RS     a) Major work ...
  34. 0.02    010314 JE     a) REORG0 changed
  35.                       b) _GetPixel0 & _GetPixel0 changed
  36.                       c) Superfluous macro definitions SETPIXEL, ... deleted
  37.                       d) PHYS_... new to handle rotation
  38. 0.01    010313 JE     a) Initialisation changed
  39. 0.00    001019 RS     Start of development
  40. ---------------------------LIST OF CONFIG SWITCHES--------------------
  41. The following is a list of additional configuration switches for this
  42. driver. These switches might not be listed in the manual, because
  43. the manual mainly covers the general config switches which are
  44. supported by all drivers.
  45. ----------------------------------------------------------------------
  46. define ----------------------Explanation------------------------------
  47. LCD_OPTIMIZE                 Controls the use of optimized routines.
  48. LCD_CACHE                    If active cache is used
  49. ----------------------------------------------------------------------
  50. Known problems or limitations with current version
  51. ----------------------------------------------------------------------
  52. none
  53. ---------------------------END-OF-HEADER------------------------------
  54. */
  56. #include <string.h>             /* for memset */
  57. #include <stddef.h>           /* needed for definition of NULL */
  58. #include "LCD_Private.h"      /* private modul definitions & config */
  59. #include "GUI_Private.h"
  60. #include "GUIDebug.h"
  61. #include "LCD_0.h"            /* Defines for first display */
  63. #if   ((LCD_CONTROLLER == 66420) | (LCD_CONTROLLER == 66421)) 
  64.       && (!defined(WIN32) | defined(LCD_SIMCONTROLLER))
  68. /*
  69.   ********************************************************************
  70.   *
  71.   *                  ID translation table
  72.   *
  73.   ********************************************************************
  75. This table contains 0, 1, 2, ... and serves as translation table for DDBs
  77. */
  79. #define INTS(Base)  Base+0,Base+1,Base+2,Base+3,Base+4,Base+5,   
  80.                     Base+6,Base+7,Base+8,Base+9,Base+10,Base+11, 
  81.                     Base+12,Base+13,Base+14,Base+15
  83. static const LCD_PIXELINDEX aID[] = {
  84.   INTS(0),
  85.   #if LCD_MAX_LOG_COLORS > 0x10
  86.     INTS(0x10),
  87.   #endif
  88.   #if LCD_MAX_LOG_COLORS > 0x20
  89.     INTS(0x20),
  90.     INTS(0x30),
  91.   #endif
  92.   #if LCD_MAX_LOG_COLORS > 0x40
  93.     INTS(0x40),
  94.     INTS(0x50),
  95.     INTS(0x60),
  96.     INTS(0x70),
  97.   #endif
  98.   #if LCD_MAX_LOG_COLORS > 0x80
  99.     INTS(0x80),
  100.     INTS(0x90),
  101.     INTS(0xa0),
  102.     INTS(0xb0),
  103.     INTS(0xc0),
  104.     INTS(0xd0),
  105.     INTS(0xe0),
  106.     INTS(0xf0)
  107.   #endif
  108. };
  110. /*
  111.         *********************************************************
  112.         *                                                       *
  113.         *           Defaults for configuration                  *
  114.         *                                                       *
  115.         *********************************************************
  116. */
  118. #ifndef LCD_XORG0
  119.   #define LCD_XORG0     (0)     /* leftmost position covered by this controller */
  120. #endif
  122. #ifndef LCD_YORG0
  123.   #define LCD_YORG0     (0)     /* topmost position covered by this controller */
  124. #endif
  126. #ifndef LCD_STATIC
  127.   #define LCD_STATIC static
  128. #endif
  130. #ifndef LCD_CACHE
  131.   #define  LCD_CACHE (0)
  132. #endif
  134. #ifndef LCD_FIRSTSEG0
  135.   #define LCD_FIRSTSEG0   (0)     /* Contr.0: first segment line used */
  136. #endif
  138. #ifndef LCD_LASTSEG0
  139.   #define LCD_LASTSEG0    (LCD_XSIZE_PHYS-1)    /* Contr.0: last segment line used */
  140. #endif
  142. #ifndef LCD_FIRSTCOM0
  143.   #define LCD_FIRSTCOM0   (0)     /* Contr.0: first com line used */
  144. #endif
  146. #ifndef LCD_LASTCOM0
  147.   #define LCD_LASTCOM0    (LCD_YSIZE_PHYS-1)     /* Contr.0: last com line used */
  148. #endif
  150. #ifndef LCD_NUM_CONTROLLERS
  151.   #define LCD_NUM_CONTROLLERS           (1)
  152. #endif
  154. #ifndef LCD_SUPPORT_CHECKINIT
  155.   #define LCD_SUPPORT_CHECKINIT         (0)
  156. #endif
  158. #ifndef LCD_OPTIMIZE
  159.   #define LCD_OPTIMIZE                (1)
  160. #endif
  162. /*      *********************************************************
  163.         *                                                       *
  164.         *              Controller dependend values              *
  165.         *                                                       *
  166.         *********************************************************
  167. */
  169. #define MAX_REGS   18
  170. #if (LCD_CONTROLLER == 66420)
  171.   #define MAX_SEGS   160
  172.   #define MAX_COMS   80
  173. #elif (LCD_CONTROLLER == 66421)
  174.   #define MAX_SEGS   160
  175.   #define MAX_COMS   100
  176. #endif
  178. /*
  179.         *********************************************************
  180.         *                                                       *
  181.         *           Compiler specific settings                  *
  182.         *                                                       *
  183.         *********************************************************
  184. */
  186. #ifdef WIN32   /* Avoid warnings in MS-compiler */
  187.   #pragma warning(disable : 4761)  // warning C4761: integral size mismatch in argument; conversion supplied
  188. #endif
  190. /*
  191.         *********************************************************
  192.         *
  193.         *           Defines for simulation
  194.         *
  195.         *********************************************************
  196. */
  198. #ifdef WIN32
  199.   U8 SIM_Read00(void);
  200.   U8 SIM_Read01(void);
  201.   U8 SIM_Read10(void);
  202.   U8 SIM_Read11(void);
  203.   void SIM_Write00(U8 Data);
  204.   void SIM_Write01(U8 Data);
  205.   void SIM_Write10(U8 Data);
  206.   void SIM_Write11(U8 Data);
  207. /* Write data */
  208.   #undef  LCD_WRITE_A0
  209.   #define LCD_WRITE_A0(Data) SIM_Write00(Data)
  210.   #undef  LCD_WRITE_A1
  211.   #define LCD_WRITE_A1(Data) SIM_Write01(Data)
  212.   #if LCD_NUM_CONTROLLERS > 1
  213.     #undef  LCD_WRITE_A0C1
  214.     #define LCD_WRITE_A0C1(Data) SIM_Write10(Data)
  215.     #undef  LCD_WRITE_A1C1
  216.     #define LCD_WRITE_A1C1(Data) SIM_Write11(Data)
  217.   #endif  /* LCD_NUM_CONTROLLERS > 1 */
  218. /* Read data */
  219.   #undef  LCD_READ_A0
  220.   #define LCD_READ_A0(Data) Data = SIM_Read00()
  221.   #undef  LCD_READ_A1
  222.   #define LCD_READ_A1(Data) Data = SIM_Read01()
  223.   #if LCD_NUM_CONTROLLERS > 1
  224.     #undef  LCD_READ_A0C0
  225.     #define LCD_READ_A0C0(Data) Data = SIM_Read10()
  226.     #undef  LCD_READ_A1C0
  227.     #define LCD_READ_A1C0(Data) Data = SIM_Read11()
  228.   #endif  /* LCD_NUM_CONTROLLERS > 1 */
  229. #endif
  231. /*
  232.         *********************************************************
  233.         *
  234.         *          Remap ...A0, ...A1 -> ...CMD, ...DATA
  235.         *
  236.         *********************************************************
  237. */
  239. #define LCD_WRITE_REG00 LCD_WRITE_A0
  240. #define LCD_WRITE_REG01 LCD_WRITE_A1
  241. #define LCD_READ_REG00  LCD_READ_A0
  242. #define LCD_READ_REG01  LCD_READ_A1
  243. #if LCD_NUM_CONTROLLERS > 1
  244.   #define LCD_WRITE_REG10 LCD_WRITE_A0C1
  245.   #define LCD_WRITE_REG11 LCD_WRITE_A1C1
  246.   #define LCD_READ_REG10  LCD_READ_A0C1
  247.   #define LCD_READ_REG11  LCD_READ_A1C1
  248. #endif
  250. /*
  251.         *********************************************************
  252.         *                                                       *
  253.         *          Internal types                               *
  254.         *                                                       *
  255.         *********************************************************
  256. */
  258. #define PIXELCOLOR U8
  259. #define BKCOLOR LCD_BKCOLORINDEX
  260. #define   COLOR LCD_COLORINDEX
  262. /*
  263.         *********************************************************
  264.         *                                                       *
  265.         *          Support for Segment/COMLUTs                  *
  266.         *                                                       *
  267.         *********************************************************
  268. */
  270. /* For compatibility with older configs, define defaults */
  271. #ifndef LCD_SUPPORT_COMTRANS
  272.   #define LCD_SUPPORT_COMTRANS 0
  273. #endif
  274. #ifndef LCD_SUPPORT_SEGTRANS
  275.   #define LCD_SUPPORT_SEGTRANS 0
  276. #endif
  278. #if LCD_SUPPORT_COMTRANS
  279.   extern LCD_TYPE_COMTRANS LCD__aLine2Com0[LCD_LASTCOM0-LCD_FIRSTCOM0+1];
  280. #endif
  282. #if LCD_SUPPORT_SEGTRANS
  283.   extern LCD_TYPE_SEGTRANS LCD__aRow2Seg0[LCD_LASTSEG0-LCD_FIRSTSEG0+1];
  284. #endif
  286. /*
  287.         *********************************************************
  288.         *                                                       *
  289.         *           Macro calculations                          *
  290.         *                                                       *
  291.         *********************************************************
  292. */
  294. #define LCD_MSB_SHIFT       (8-LCD_LSB_SHIFT)
  296. /* Define number of used coms/segments per controller */
  297. #define LCD_NUM_SEGS0 (LCD_LASTSEG0-LCD_FIRSTSEG0+1)
  298. #define LCD_NUM_COMS0 (LCD_LASTCOM0-LCD_FIRSTCOM0+1)
  299. #if (LCD_NUM_CONTROLLERS >1)
  300.   #define LCD_NUM_SEGS1 (LCD_LASTSEG1-LCD_FIRSTSEG1+1)
  301.   #define LCD_NUM_COMS1 (LCD_LASTCOM1-LCD_FIRSTCOM1+1)
  302. #endif
  304. /* Define total number of used coms/segments */
  305. #if (LCD_NUM_CONTROLLERS ==1)
  306.   #define LCD_NUM_SEGS LCD_NUM_SEGS0
  307.   #define LCD_NUM_COMS LCD_NUM_COMS0
  308. #elif (LCD_NUM_CONTROLLERS ==2)
  309.   #define LCD_NUM_SEGS (LCD_NUM_SEGS0+LCD_NUM_SEGS1)
  310.   #define LCD_NUM_COMS (LCD_NUM_COMS0+LCD_NUM_COMS1)
  311. #endif
  313. #define LCD_MEMSIZE ((LCD_BITSPERPIXEL*LCD_VXSIZE/LCD_BUSWIDTH)*(LCD_VYSIZE+LCD_NUM_EMPTY_LINES))
  315. #define LCD_NUM_PAGES (LCD_NUM_COMS+7)/8
  317. /*
  318.         *********************************************************
  319.         *                                                       *
  320.         *      Configuration switch checking                    *
  321.         *                                                       *
  322.         *********************************************************
  324. Please be aware that not all configuration errors can be captured !
  326. */
  328. /* Check number of controllers */
  329. #if ((LCD_NUM_CONTROLLERS >1) || (LCD_NUM_CONTROLLERS <0))
  330.   #error "More than 1 controller not supported by this driver"
  331. #endif
  333. #if (!defined(LCD_INIT_R00)) | (!defined(LCD_INIT_R01))
  334.   #error You have to define init values in the configuration for Registers 0,1
  335.          /* Drivers needs to know as these values can not be read back ! */
  336. #endif
  339. /*********************************************************************
  340. *
  341. *           Static variables
  342. *
  343. **********************************************************************
  344. */
  346. static struct {
  347.   U8 ConReg0;
  348.   U8 ConReg1;
  349.   U8 x,y;
  350.   #if LCD_CACHE
  351.     U8 aaVMem[MAX_COMS][MAX_SEGS/4];  /* video memory */
  352.   #endif
  353. } aState[LCD_NUM_CONTROLLERS];
  355. /*
  356.         *********************************************************
  357.         *                                                       *
  358.         *              Macros, standard                         *
  359.         *                                                       *
  360.         *********************************************************
  362. These macros can be found in any LCD-driver as they serve purposes
  363. that can be found in any class of LCD-driver.
  364. */
  366. #if (!LCD_SWAP_XY) && (!LCD_MIRROR_X) && (!LCD_MIRROR_Y)
  367.   #define LOG2PHYS(x,y) x,y
  368. #elif (!LCD_SWAP_XY) && (!LCD_MIRROR_X) && (LCD_MIRROR_Y)
  369.   #define LOG2PHYS(x,y) x,LCD_YSIZE_PHYS-1-(y)
  370. #elif (!LCD_SWAP_XY) && (LCD_MIRROR_X) && (!LCD_MIRROR_Y)
  371.   #define LOG2PHYS(x,y) LCD_XSIZE_PHYS-1-(x),y
  372. #elif (!LCD_SWAP_XY) && (LCD_MIRROR_X) && (LCD_MIRROR_Y)
  373.   #define LOG2PHYS(x,y) LCD_XSIZE_PHYS-1-(x),LCD_YSIZE_PHYS-1-(y)
  374. #elif (LCD_SWAP_XY) && (!LCD_MIRROR_X) && (!LCD_MIRROR_Y)
  375.   #define LOG2PHYS(x,y) y,x
  376. #elif (LCD_SWAP_XY) && (LCD_MIRROR_X) && (!LCD_MIRROR_Y)
  377.   #define LOG2PHYS(x,y) y,LCD_XSIZE-1-(x)
  378. #elif (LCD_SWAP_XY) && (!LCD_MIRROR_X) && (LCD_MIRROR_Y)
  379.   #define LOG2PHYS(x,y) LCD_YSIZE-1-(y),x
  380. #elif (LCD_SWAP_XY) && (LCD_MIRROR_X) && (LCD_MIRROR_Y)
  381.   #define LOG2PHYS(x,y) LCD_YSIZE-1-(y),LCD_XSIZE-1-(x)
  382. #else
  383.   #error unsupported configuration
  384. #endif
  386. /*
  387.         *********************************************************
  388.         *                                                       *
  389.         *       Macros for internal use                         *
  390.         *                                                       *
  391.         *********************************************************
  392. */
  394. #if (LCD_SUPPORT_COMTRANS)
  395.   #if (LCD_MIRROR_Y)
  396.     #error LCD_MIRROR_Y not supported with COMTrans !
  397.   #endif
  398.   #if (LCD_MIRROR_X)
  399.     #error LCD_MIRROR_X not supported with COMTrans !
  400.   #endif
  401. #endif
  403. #define XORPIXEL_DATA(x, y,c)  XorPixel_Data(x,y,c)
  405. #if (!LCD_SUPPORT_COMTRANS && !LCD_SUPPORT_SEGTRANS)
  406.   #define SETPIXEL(x, y, c)  _SetPixel(x, y, c)
  407.   #define GETPIXEL(x, y)     _GetPixel(x,y)
  408.   #define XORPIXEL(x, y)     XorPixel(x,y)
  409.   #define XORPIXEL_DATA(x, y,c)  XorPixel_Data(x,y,c)
  410. #elif (LCD_SUPPORT_COMTRANS && !LCD_SUPPORT_SEGTRANS)
  411.   #if (!LCD_SWAP_XY)
  412.     #define SETPIXEL(x, y, c)  _SetPixel(x,LCD__aLine2Com0[y], c)
  413.     #define GETPIXEL(x, y)     _GetPixel(x,LCD__aLine2Com0[y])
  414.     #define XORPIXEL(x, y)      XorPixel(x,LCD__aLine2Com0[y])
  415.   #else
  416.     #define SETPIXEL(x, y, c)  _SetPixel(y,LCD__aLine2Com0[x], c)
  417.     #define GETPIXEL(x, y)     _GetPixel(y,LCD__aLine2Com0[x])
  418.     #define XORPIXEL(x, y)      XorPixel(y,LCD__aLine2Com0[x])
  419.   #endif
  420. #elif (!LCD_SUPPORT_COMTRANS && LCD_SUPPORT_SEGTRANS)
  421.   #if (!LCD_SWAP_XY)
  422.     #define SETPIXEL(x, y, c)  _SetPixel(LCD__aRow2Seg0[x],y, c)
  423.     #define GETPIXEL(x, y)     _GetPixel(LCD__aRow2Seg0[x],y)
  424.     #define XORPIXEL(x, y)      XorPixel(LCD__aRow2Seg0[x],y)
  425.   #else
  426.     #define SETPIXEL(x, y, c)  _SetPixel(LCD__aRow2Seg0[y],x, c)
  427.     #define GETPIXEL(x, y)     _GetPixel(LCD__aRow2Seg0[y],x)
  428.     #define XORPIXEL(x, y)      XorPixel(LCD__aRow2Seg0[y],x)
  429.   #endif
  430. #elif (LCD_SUPPORT_COMTRANS && LCD_SUPPORT_SEGTRANS)
  431.   #if (!LCD_SWAP_XY)
  432.     #define SETPIXEL(x, y, c)  _SetPixel(LCD__aRow2Seg0[x],LCD__aLine2Com0[y], c)
  433.     #define GETPIXEL(x, y)     _GetPixel(LCD__aRow2Seg0[x],LCD__aLine2Com0[y])
  434.     #define XORPIXEL(x, y)      XorPixel(LCD__aRow2Seg0[x],LCD__aLine2Com0[y])
  435.   #else
  436.     #define SETPIXEL(x, y, c)  _SetPixel(LCD__aRow2Seg0[y],LCD__aLine2Com0[x], c)
  437.     #define GETPIXEL(x, y)     _GetPixel(LCD__aRow2Seg0[y],LCD__aLine2Com0[x])
  438.     #define XORPIXEL(x, y)      XorPixel(LCD__aRow2Seg0[y],LCD__aLine2Com0[x])
  439.   #endif
  440. #else
  441.   #error This combination of switches not yet supported
  442. #endif
  444. /*
  445.         *********************************************************
  446.         *                                                       *
  447.         *       Next pixel routines                             *
  448.         *                                                       *
  449.         *********************************************************
  450. */
  453. /*
  454.         *********************************************************
  455.         *                                                       *
  456.         *                   LCD_SetPaletteEntry                 *
  457.         *                                                       *
  458.         *********************************************************
  460. */
  462. void LCD_L0_SetLUTEntry(U8 Pos, LCD_COLOR color) {
  463.   Pos=Pos;
  464.   color=color;
  465. }
  467. /*
  468. ********************************************************************
  469. *
  470. *           Hardware access routines
  471. *
  472. ********************************************************************
  473. */
  475. /* Write into controller 0 */
  476. void LCD_WriteReg0(int Reg, U8 Data) {
  477.   LCD_WRITE_REG00(Reg);
  478.   LCD_WRITE_REG01(Data);
  479. }
  481. #if LCD_NUM_CONTROLLERS > 1
  482. void LCD_WriteReg1(int Reg, U8 Data) {
  483.   LCD_WRITE_REG10(Reg);
  484.   LCD_WRITE_REG11(Data);
  485. }
  486. #endif
  488. /*
  489.   ********************************************************************
  490.   *                                                                  *
  491.   *                  Hardware access, register level                 *
  492.   *                                                                  *
  493.   *           Write Page / Column                                    *
  494.   *                                                                  *
  495.   ********************************************************************
  497.  The following routines are used for all access to the
  498.  LCD-controller(s).
  500. */
  502. #define SET_X_INCREMENT()                    
  503.   aState[0].ConReg1 = (LCD_INIT_R01) | ( 2); 
  504.   LCD_WriteReg0( 1, aState[0].ConReg1)
  506. #define SET_Y_INCREMENT()                    
  507.   aState[0].ConReg1 = (LCD_INIT_R01) & (~2); 
  508.   LCD_WriteReg0( 1, aState[0].ConReg1)
  510. #define SET_X0(xNew) 
  511.   if (aState[0].x != xNew) 
  512.   { LCD_WRITE_REG00(2); LCD_WRITE_REG01(xNew); aState[0].x = xNew; }
  514. #define SET_Y0(yNew) 
  515.   if (aState[0].y != yNew) 
  516.   { LCD_WRITE_REG00(3); LCD_WRITE_REG01(yNew); aState[0].y = yNew; }
  518. #define EXEC_INCREMENT()        
  519.   if (aState[0].ConReg1 & 1<<1) 
  520.     aState[0].x++;              
  521.   else                          
  522.     aState[0].y++
  524. #if LCD_CACHE
  525.   #define WRITE_VMEM0(Data) {     
  526.     aState[0].aaVMem[aState[0].y][aState[0].x] = Data; 
  527.     LCD_WRITE_REG00(4);           
  528.     LCD_WRITE_REG01(Data);        
  529.     EXEC_INCREMENT();             
  530.   }
  531. #else
  532.   #define WRITE_VMEM0(Data) {     
  533.     LCD_WRITE_REG00(4);           
  534.     LCD_WRITE_REG01(Data);        
  535.     EXEC_INCREMENT();             
  536.   }
  537. #endif
  539. #if LCD_CACHE
  540.   #define READ_VMEM0(Data)  {     
  541.     Data = aState[0].aaVMem[aState[0].y][aState[0].x]; 
  542.   }
  543. #else
  544.   #define READ_VMEM0(Data)  {     
  545.     LCD_WRITE_REG00(4);           
  546.     LCD_READ_REG01(Data);         
  547.     LCD_READ_REG01(Data);         
  548.   }
  549. #endif
  551. /*
  552.         *********************************************************
  553.         *                                                       *
  554.         *       Internal set pixel routines                     *
  555.         *                                                       *
  556.         *********************************************************
  557. */
  559. static U8 aAndMask[4] = {255-(3<<6), 255-(3<<4), 255-(3<<2), 255-(3<<0)};
  561. static void _SetPixel0_Phys(int x, int y, PIXELCOLOR c) {
  562.   U8 Data;
  563.   int xByte = x>>2;
  564.   int Pos = x&3;
  565.   #if LCD_CACHE ==0
  566.     SET_X0(xByte);
  567.     SET_Y0(y);
  568.     READ_VMEM0(Data);
  569.     Data &= aAndMask[Pos];
  570.     Data |= c<<(6-(Pos<<1));
  571.     WRITE_VMEM0(Data);
  572.   #else
  573.     U8* pData = &aState[0].aaVMem[y][xByte];
  574.     Data = *pData & aAndMask[Pos];
  575.     Data |= c<<(6-(Pos<<1));
  576.     if (Data != *pData) {
  577.       SET_X0(xByte);
  578.       SET_Y0(y);
  579.       WRITE_VMEM0(Data);
  580.     }
  581.   #endif
  582. }
  584. #define _SetPixel(x,y,c)     _SetPixel0_Phys(LOG2PHYS((x-LCD_XORG0),(y-LCD_YORG0)), c)
  586. static PIXELCOLOR _GetPixel0(int x, int y) {
  587.   int xByte = x>>2;
  588.   int Pos = 3-(x&3);
  589.   U8 Data;
  590.   SET_X0(xByte);
  591.   SET_Y0(y);
  592.   READ_VMEM0(Data);
  593.   return 3&(Data>>(Pos<<1));
  594. }
  596. static PIXELCOLOR _GetPixel(int x, int y) {
  597.   return _GetPixel0(LOG2PHYS((x-LCD_XORG0),(y-LCD_YORG0)));
  598. }
  600. static void XorPixel(int x, int y) {
  601.   PIXELCOLOR Index = _GetPixel(x,y);
  602.   _SetPixel(x,y, LCD_NUM_COLORS-1-Index);
  603. }
  605. static void XorPixel_Data(int x, int y, PIXELCOLOR c) {
  606.   PIXELCOLOR Index = _GetPixel(x,y);
  607.   _SetPixel(x,y,Index^c);
  608. }
  610. /*
  611. *********************************************************
  612. *
  613. *                  LCD_L0_GetPixelIndex
  614. *
  615. *********************************************************
  616. */
  618. unsigned LCD_L0_GetPixelIndex(int x, int y) {
  619.   return _GetPixel(x,y);
  620. }
  622. /*
  623.         *********************************************************
  624.         *                                                       *
  625.         *       LCD_L0_XorPixel                                 *
  626.         *                                                       *
  627.         *********************************************************
  629. Purpose:  This routine is called by emWin. It writes 1 pixel into the
  630.           display.
  632. */
  634. void LCD_L0_XorPixel(int x, int y) {
  635.   XORPIXEL(x, y);
  636. }
  638. /*
  639.         *********************************************************
  640.         *                                                       *
  641.         *       LCD_L0_SetPixelIndex                            *
  642.         *                                                       *
  643.         *********************************************************
  645. Purpose:  This routine is called by emWin. It writes 1 pixel into the
  646.           display.
  648. */
  649. void LCD_L0_SetPixelIndex(int x, int y, int ColorIndex) {
  650.   SETPIXEL(x, y, ColorIndex);
  651. }
  653. /*
  654.         *********************************************************
  655.         *                                                       *
  656.         *          LCD_L0_DrawHLine unoptimized                 *
  657.         *                                                       *
  658.         *********************************************************
  659. */
  661. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  662.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  663.     while (x0 <= x1) {
  664.       XORPIXEL(x0, y);
  665.       x0++;
  666.     }
  667.   } else {
  668.     while (x0 <= x1) {
  669.       SETPIXEL(x0, y, COLOR);
  670.       x0++;
  671.     }
  672.   }
  673. }
  675. /*
  676.         *********************************************************
  677.         *
  678.         *          LCD_L0_DrawVLine, optimized
  679.         *
  680.         *********************************************************
  681. */
  683. #if (LCD_OPTIMIZE)               
  684.     && (LCD_BITSPERPIXEL == 2)   
  685.     && (LCD_SWAP_XY ==1)         
  686.     && (LCD_MIRROR_X==1)         
  687.     && (LCD_MIRROR_Y==0)         
  688.     && (!defined (LCD_LUT_SEG))
  690. void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  691.   U8 ColorMask, OrMask, AndMask, Data;
  692.   int y = LCD_XSIZE - x - 1;
  693.   int x0 = y0;
  694.   int x1 = y1;
  695.   int x0Byte = x0 >> 2;
  696.   int x1Byte = (x1 + 1) >> 2;
  697.   int NumBytes = x1Byte - x0Byte;
  698.   SET_X_INCREMENT();
  699.   SET_Y0(y);
  700.   SET_X0(x0Byte);
  701.   ColorMask  = COLOR + (COLOR<<2) + (COLOR<<4) + (COLOR<<6);
  702.   if (x0 & 3) {
  703.     int Pos = (x0 & 3) << 1;
  704.     AndMask = 0xff << (8 - Pos);
  705.     OrMask = ColorMask >> Pos;
  706.     READ_VMEM0(Data);
  707.     if (x0Byte == (x1 >> 2)) {
  708.       if ((x1 & 3) != 3) {
  709.         int Pos = ((x1 + 1) & 3) << 1;
  710.         AndMask |= 0xff >> Pos;
  711.         OrMask &= ColorMask << (8 - Pos);
  712.       }
  713.       NumBytes = 0;
  714.     }
  715.     if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  716.       Data ^= (0xff & ~AndMask);
  717.     } else {
  718.       Data &= AndMask;
  719.       Data |= OrMask;
  720.     }
  721.     WRITE_VMEM0(Data);
  722.     if (!NumBytes) {
  723.       SET_Y_INCREMENT();
  724.       return;
  725.     }
  726.     --NumBytes;
  727.   }
  728.   if (NumBytes) {
  729.     if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  730.       do {
  731.         READ_VMEM0(Data);
  732.         Data ^= 0xff;
  733.         WRITE_VMEM0(Data);
  734.       } while(--NumBytes);
  735.     } else {
  736.       LCD_WRITE_REG00(4);
  737.       #if LCD_CACHE
  738.         memset(&aState[0].aaVMem[aState[0].y][aState[0].x], ColorMask, NumBytes);
  739.       #endif
  740.       aState[0].x += NumBytes;
  741.       do {
  742.         LCD_WRITE_REG01(ColorMask);
  743.       } while(--NumBytes);
  744.     }
  745.   }
  746.   if ((x1 + 1) & 3) {
  747.     int Pos = ((x1 + 1) & 3) << 1;
  748.     AndMask = 0xff >> Pos;
  749.     OrMask = ColorMask << (8 - Pos);
  750.     READ_VMEM0(Data);
  751.     if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  752.       Data ^= (0xff & ~AndMask);
  753.     } else {
  754.       Data &= AndMask;
  755.       Data |= OrMask;
  756.     }
  757.     WRITE_VMEM0(Data);
  758.   }
  759.   SET_Y_INCREMENT();
  760. }
  762. /*
  763.         *********************************************************
  764.         *
  765.         *          LCD_L0_DrawVLine no optimization
  766.         *
  767.         *********************************************************
  768. */
  770. #else
  772. void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  773.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  774.     while (y0 <= y1) {
  775.       XORPIXEL(x, y0);
  776.       y0++;
  777.     }
  778.   } else {
  779.     while (y0 <= y1) {
  780.       SETPIXEL(x, y0, COLOR);
  781.       y0++;
  782.     }
  783.   }
  784. }
  786. #endif
  788. /*********************************************************************
  789. *
  790. *          LCD_FillRect
  791. *
  792. **********************************************************************
  793. */
  796. #if LCD_SWAP_XY
  797. void LCD_L0_FillRect(int x, int y0, int x1, int y1) {
  798.   for (; x <= x1; x++) {
  799.     LCD_L0_DrawVLine(x,y0, y1);
  800.   }
  801. }
  802. #else
  803. void LCD_L0_FillRect(int x0, int y0, int x1, int y1) {
  804.   for (; y0 <= y1; y0++) {
  805.     LCD_L0_DrawHLine(x0,y0, x1);
  806.   }
  807. }
  808. #endif
  810. /*
  811.         *********************************************************
  812.         *
  813.         *  Draw Bitmap 1 BPP, optimized
  814.         *
  815.         *********************************************************
  816. */
  818. #if (LCD_OPTIMIZE)               
  819.     && (LCD_BITSPERPIXEL == 2)   
  820.     && (LCD_SWAP_XY ==1)         
  821.     && (LCD_MIRROR_X==1)         
  822.     && (LCD_MIRROR_Y==0)         
  823.     && (!defined (LCD_LUT_SEG))
  825. static void DrawBitLine1BPP_Swap(
  826.   int x,
  827.   int y,
  828.   U8 const * pData,
  829.   int ysize,
  830.   const U8 * pTrans,
  831.   int BytesPerLine,
  832.   U8 Pos)
  833. {
  834.   LCD_PIXELINDEX Index0 = *(pTrans+0);
  835.   LCD_PIXELINDEX Index1 = *(pTrans+1);
  836.   int i;
  837.   int y0 = LCD_XSIZE - x - 1;
  838.   int x0 = y;
  839.   int x0Byte = y >> 2;
  840.   U8 Buffer, DataMask, Index, Data, ShiftPos, BufferMask, Pixel;
  841.   U8 BufferValid = 0;
  842.   SET_Y0(y0);
  843.   SET_X0(x0Byte);
  844.   ShiftPos = Pos & 7;
  845.   BufferMask = 0xC0 >> ((x0  & 3) << 1);
  846.   DataMask =   0x80 >> ShiftPos;
  847.   for (i = 0; i < ysize; i++, pData += BytesPerLine) {
  848.     if (!BufferValid) {
  849.       READ_VMEM0(Buffer);
  850.       BufferValid = 1;
  851.     }
  852.     switch (GUI_Context.DrawMode) {
  853.     case LCD_DRAWMODE_NORMAL:
  854.     case LCD_DRAWMODE_REV:
  855.       Buffer &= ~BufferMask;
  856.       Index = *(pTrans + ((*pData & DataMask) >> (7 - ShiftPos)));
  857.       Data = Index << (6 - (((i + x0) & 3) << 1));
  858.       Buffer |= Data;
  859.       break;
  860.     case LCD_DRAWMODE_XOR:
  861.       Pixel = (*pData & DataMask) >> (7 - ShiftPos);
  862.       if (Pixel) {
  863.         Data = 3 << (6 - (((i + x0) & 3) << 1));
  864.         Buffer ^= Data;
  865.       }
  866.       break;
  867.     case LCD_DRAWMODE_TRANS:
  868.       Pixel = (*pData & DataMask) >> (7 - ShiftPos);
  869.       if (Pixel) {
  870.         Index = *(pTrans + Pixel);
  871.         Buffer &= ~BufferMask;
  872.         Data = Index << (6 - (((i + x0) & 3) << 1));
  873.         Buffer |= Data;
  874.       }
  875.       break;
  876.     }
  877.     if (BufferMask == 3) {
  878.       BufferMask = 0xC0;
  879.       BufferValid = 0;
  880.       WRITE_VMEM0(Buffer);
  881.     } else {
  882.       BufferMask >>= 2;
  883.     }
  884.   }
  885.   if (BufferValid) {
  886.     WRITE_VMEM0(Buffer);
  887.   }
  888. }
  890. #else
  892. /*
  893.         *********************************************************
  894.         *
  895.         *  Draw Bitmap 1 BPP no optimization
  896.         *
  897.         *********************************************************
  898. */
  900. static void  DrawBitLine1BPP(int x, int y, U8 const *p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  901.   PIXELCOLOR pixels;
  902.   PIXELCOLOR Index0 = *(pTrans+0);
  903.   PIXELCOLOR Index1 = *(pTrans+1);
  904. /*
  905. // Jump to right entry point
  906. */
  907.   pixels = *p;
  908.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)) {
  909.   case 0:
  910.     #if defined (SETNEXTPIXEL)
  911.       SetPosXY(x,y);
  912.     #endif
  913.     switch (Diff&7) {
  914.     case 0:
  915.       goto WriteBit0;
  916.     case 1:
  917.       goto WriteBit1;
  918.     case 2:
  919.       goto WriteBit2;
  920.     case 3:
  921.       goto WriteBit3;
  922.     case 4:
  923.       goto WriteBit4;
  924.     case 5:
  925.       goto WriteBit5;
  926.     case 6:
  927.       goto WriteBit6;
  928.     case 7:
  929.       goto WriteBit7;
  930.     }
  931.     break;
  932.   case LCD_DRAWMODE_TRANS:
  933.     switch (Diff&7) {
  934.     case 0:
  935.       goto WriteTBit0;
  936.     case 1:
  937.       goto WriteTBit1;
  938.     case 2:
  939.       goto WriteTBit2;
  940.     case 3:
  941.       goto WriteTBit3;
  942.     case 4:
  943.       goto WriteTBit4;
  944.     case 5:
  945.       goto WriteTBit5;
  946.     case 6:
  947.       goto WriteTBit6;
  948.     case 7:
  949.       goto WriteTBit7;
  950.     }
  951.     break;
  952.   case LCD_DRAWMODE_XOR:
  953.     switch (Diff&7) {
  954.     case 0:
  955.       goto WriteXBit0;
  956.     case 1:
  957.       goto WriteXBit1;
  958.     case 2:
  959.       goto WriteXBit2;
  960.     case 3:
  961.       goto WriteXBit3;
  962.     case 4:
  963.       goto WriteXBit4;
  964.     case 5:
  965.       goto WriteXBit5;
  966.     case 6:
  967.       goto WriteXBit6;
  968.     case 7:
  969.       goto WriteXBit7;
  970.     }
  971.   }
  972. /*
  973.         Write with transparency
  974. */
  975.   WriteTBit0:
  976.     if (pixels&(1<<7)) SETPIXEL(x+0, y, Index1);
  977.     if (!--xsize)
  978.       return;
  979.   WriteTBit1:
  980.     if (pixels&(1<<6)) SETPIXEL(x+1, y, Index1);
  981.     if (!--xsize)
  982.       return;
  983.   WriteTBit2:
  984.     if (pixels&(1<<5)) SETPIXEL(x+2, y, Index1);
  985.     if (!--xsize)
  986.       return;
  987.   WriteTBit3:
  988.     if (pixels&(1<<4)) SETPIXEL(x+3, y, Index1);
  989.     if (!--xsize)
  990.       return;
  991.   WriteTBit4:
  992.     if (pixels&(1<<3)) SETPIXEL(x+4, y, Index1);
  993.     if (!--xsize)
  994.       return;
  995.   WriteTBit5:
  996.     if (pixels&(1<<2)) SETPIXEL(x+5, y, Index1);
  997.     if (!--xsize)
  998.       return;
  999.   WriteTBit6:
  1000.     if (pixels&(1<<1)) SETPIXEL(x+6, y, Index1);
  1001.     if (!--xsize)
  1002.       return;
  1003.   WriteTBit7:
  1004.     if (pixels&(1<<0)) SETPIXEL(x+7, y, Index1);
  1005.     if (!--xsize)
  1006.       return;
  1007.     x+=8;
  1008.     pixels = *(++p);
  1009.     goto WriteTBit0;
  1010. /*
  1011.         Write without transparency
  1012. */
  1013. #if defined (SETNEXTPIXEL)   /* Optimization ! */
  1014.   WriteBit0:
  1015.     SetNextPixel(x+0, y, (pixels&(1<<7)) ? Index1 : Index0);
  1016.     if (!--xsize)
  1017.       return;
  1018.   WriteBit1:
  1019.     SetNextPixel(x+1, y, (pixels&(1<<6)) ? Index1 : Index0);
  1020.     if (!--xsize)
  1021.       return;
  1022.   WriteBit2:
  1023.     SetNextPixel(x+2, y, (pixels&(1<<5)) ? Index1 : Index0);
  1024.     if (!--xsize)
  1025.       return;
  1026.   WriteBit3:
  1027.     SetNextPixel(x+3, y, (pixels&(1<<4)) ? Index1 : Index0);
  1028.     if (!--xsize)
  1029.       return;
  1030.   WriteBit4:
  1031.     SetNextPixel(x+4, y, (pixels&(1<<3)) ? Index1 : Index0);
  1032.     if (!--xsize)
  1033.       return;
  1034.   WriteBit5:
  1035.     SetNextPixel(x+5, y, (pixels&(1<<2)) ? Index1 : Index0);
  1036.     if (!--xsize)
  1037.       return;
  1038.   WriteBit6:
  1039.     SetNextPixel(x+6, y, (pixels&(1<<1)) ? Index1 : Index0);
  1040.     if (!--xsize)
  1041.       return;
  1042.   WriteBit7:
  1043.     SetNextPixel(x+7, y, (pixels&(1<<0)) ? Index1 : Index0);
  1044.     if (!--xsize)
  1045.       return;
  1046.     x+=8;
  1047.     pixels = *(++p);
  1048.     goto WriteBit0;
  1049. #else
  1050.   WriteBit0:
  1051.     SETPIXEL(x+0, y, (pixels&(1<<7)) ? Index1 : Index0);
  1052.     if (!--xsize)
  1053.       return;
  1054.   WriteBit1:
  1055.     SETPIXEL(x+1, y, (pixels&(1<<6)) ? Index1 : Index0);
  1056.     if (!--xsize)
  1057.       return;
  1058.   WriteBit2:
  1059.     SETPIXEL(x+2, y, (pixels&(1<<5)) ? Index1 : Index0);
  1060.     if (!--xsize)
  1061.       return;
  1062.   WriteBit3:
  1063.     SETPIXEL(x+3, y, (pixels&(1<<4)) ? Index1 : Index0);
  1064.     if (!--xsize)
  1065.       return;
  1066.   WriteBit4:
  1067.     SETPIXEL(x+4, y, (pixels&(1<<3)) ? Index1 : Index0);
  1068.     if (!--xsize)
  1069.       return;
  1070.   WriteBit5:
  1071.     SETPIXEL(x+5, y, (pixels&(1<<2)) ? Index1 : Index0);
  1072.     if (!--xsize)
  1073.       return;
  1074.   WriteBit6:
  1075.     SETPIXEL(x+6, y, (pixels&(1<<1)) ? Index1 : Index0);
  1076.     if (!--xsize)
  1077.       return;
  1078.   WriteBit7:
  1079.     SETPIXEL(x+7, y, (pixels&(1<<0)) ? Index1 : Index0);
  1080.     if (!--xsize)
  1081.       return;
  1082.     x+=8;
  1083.     pixels = *(++p);
  1084.     goto WriteBit0;
  1085. #endif
  1086. /*
  1087.         Write XOR mode
  1088. */
  1089.   WriteXBit0:
  1090.     if (pixels&(1<<7))
  1091.       XORPIXEL(x+0, y);
  1092.     if (!--xsize)
  1093.       return;
  1094.   WriteXBit1:
  1095.     if (pixels&(1<<6))
  1096.       XORPIXEL(x+1, y);
  1097.     if (!--xsize)
  1098.       return;
  1099.   WriteXBit2:
  1100.     if (pixels&(1<<5))
  1101.       XORPIXEL(x+2, y);
  1102.     if (!--xsize)
  1103.       return;
  1104.   WriteXBit3:
  1105.     if (pixels&(1<<4))
  1106.       XORPIXEL(x+3, y);
  1107.     if (!--xsize)
  1108.       return;
  1109.   WriteXBit4:
  1110.     if (pixels&(1<<3))
  1111.       XORPIXEL(x+4, y);
  1112.     if (!--xsize)
  1113.       return;
  1114.   WriteXBit5:
  1115.     if (pixels&(1<<2))
  1116.       XORPIXEL(x+5, y);
  1117.     if (!--xsize)
  1118.       return;
  1119.   WriteXBit6:
  1120.     if (pixels&(1<<1))
  1121.       XORPIXEL(x+6, y);
  1122.     if (!--xsize)
  1123.       return;
  1124.   WriteXBit7:
  1125.     if (pixels&(1<<0))
  1126.       XORPIXEL(x+7, y);
  1127.     if (!--xsize)
  1128.       return;
  1129.     x+=8;
  1130.     pixels = *(++p);
  1131.     goto WriteXBit0;
  1132. }
  1134. #endif
  1136. /*
  1137.         *********************************************************
  1138.         *
  1139.         *  Draw Bitmap 2 BPP, optimized
  1140.         *
  1141.         *********************************************************
  1142. */
  1144. #if (LCD_MAX_LOG_COLORS > 2)
  1146. #if (LCD_OPTIMIZE)               
  1147.     && (LCD_BITSPERPIXEL == 2)   
  1148.     && (LCD_SWAP_XY ==1)         
  1149.     && (LCD_MIRROR_X==1)         
  1150.     && (LCD_MIRROR_Y==0)         
  1151.     && (!defined (LCD_LUT_SEG))
  1153. static void DrawBitLine2BPP_Swap(
  1154.   int x,
  1155.   int y,
  1156.   U8 const * pData,
  1157.   int ysize,
  1158.   const U8 * pTrans,
  1159.   int BytesPerLine,
  1160.   U8 Pos)
  1161. {
  1162.   int i;
  1163.   int y0 = LCD_XSIZE - x - 1;
  1164.   int x0 = y;
  1165.   int x0Byte = y >> 2;
  1166.   U8 Buffer, DataMask, Index, Data, ShiftPos, BufferMask;
  1167.   U8 BufferValid = 0;
  1168.   SET_Y0(y0);
  1169.   SET_X0(x0Byte);
  1170.   ShiftPos = (Pos & 3) << 1;
  1171.   BufferMask = 0xC0 >> ((x0  & 3) << 1);
  1172.   DataMask =   0xC0 >> ShiftPos;
  1173.   for (i = 0; i < ysize; i++, pData += BytesPerLine) {
  1174.     if (!BufferValid) {
  1175.       READ_VMEM0(Buffer);
  1176.       BufferValid = 1;
  1177.     }
  1178.     switch (GUI_Context.DrawMode) {
  1179.     case LCD_DRAWMODE_NORMAL:
  1180.     case LCD_DRAWMODE_REV:
  1181.       Buffer &= ~BufferMask;
  1182.       Index = *(pTrans + ((*pData & DataMask) >> (6 - ShiftPos)));
  1183.       Data = Index << (6 - (((i + x0) & 3) << 1));
  1184.       Buffer |= Data;
  1185.       break;
  1186.     case LCD_DRAWMODE_XOR:
  1187.       Index = *(pTrans + ((*pData & DataMask) >> (6 - ShiftPos))) * 3;
  1188.       Data = Index << (6 - (((i + x0) & 3) << 1));
  1189.       Buffer ^= Data;
  1190.       break;
  1191.     case LCD_DRAWMODE_TRANS:
  1192.       Index = *(pTrans + ((*pData & DataMask) >> (6 - ShiftPos)));
  1193.       if (Index) {
  1194.         Buffer &= ~BufferMask;
  1195.         Data = Index << (6 - (((i + x0) & 3) << 1));
  1196.         Buffer |= Data;
  1197.       }
  1198.       break;
  1199.     }
  1200.     if (BufferMask == 3) {
  1201.       BufferMask = 0xC0;
  1202.       BufferValid = 0;
  1203.       WRITE_VMEM0(Buffer);
  1204.     } else {
  1205.       BufferMask >>= 2;
  1206.     }
  1207.   }
  1208.   if (BufferValid) {
  1209.     WRITE_VMEM0(Buffer);
  1210.   }
  1211. }
  1213. /*
  1214.         *********************************************************
  1215.         *
  1216.         *  Draw Bitmap 2 BPP no optimization
  1217.         *
  1218.         *********************************************************
  1219. */
  1221. #else
  1223. static void  DrawBitLine2BPP(int x, int y, U8 const *p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  1224.   PIXELCOLOR pixels;
  1225. /*
  1226. // Jump to right entry point
  1227. */
  1228.   pixels = *p;
  1229.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)) {
  1230.   case 0:
  1231.     switch (Diff&3) {
  1232.     case 0:
  1233.       goto WriteBit0;
  1234.     case 1:
  1235.       goto WriteBit1;
  1236.     case 2:
  1237.       goto WriteBit2;
  1238.     default:
  1239.       goto WriteBit3;
  1240.     }
  1241.   case LCD_DRAWMODE_TRANS:
  1242.     switch (Diff&3) {
  1243.     case 0:
  1244.       goto WriteTBit0;
  1245.     case 1:
  1246.       goto WriteTBit1;
  1247.     case 2:
  1248.       goto WriteTBit2;
  1249.     default:
  1250.       goto WriteTBit3;
  1251.     }
  1252.   case LCD_DRAWMODE_XOR:
  1253.     switch (Diff&3) {
  1254.     case 0:
  1255.       goto WriteXBit0;
  1256.     case 1:
  1257.       goto WriteXBit1;
  1258.     case 2:
  1259.       goto WriteXBit2;
  1260.     default:
  1261.       goto WriteXBit3;
  1262.     }
  1263.   case LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR:
  1264.     switch (Diff&3) {
  1265.     case 0:
  1266.       goto WriteTXBit0;
  1267.     case 1:
  1268.       goto WriteTXBit1;
  1269.     case 2:
  1270.       goto WriteTXBit2;
  1271.     default:
  1272.       goto WriteTXBit3;
  1273.     }
  1274.   }
  1275. /*
  1276.         Write without transparency
  1277. */
  1278. WriteBit0:
  1279.   SETPIXEL(x+0, y, *(pTrans+(pixels>>6)));
  1280.   if (!--xsize)
  1281.     return;
  1282. WriteBit1:
  1283.   SETPIXEL(x+1, y, *(pTrans+(3&(pixels>>4))));
  1284.   if (!--xsize)
  1285.     return;
  1286. WriteBit2:
  1287.   SETPIXEL(x+2, y, *(pTrans+(3&(pixels>>2))));
  1288.   if (!--xsize)
  1289.     return;
  1290. WriteBit3:
  1291.   SETPIXEL(x+3, y, *(pTrans+(3&(pixels))));
  1292.   if (!--xsize)
  1293.     return;
  1294.   pixels = *(++p);
  1295.   x+=4;
  1296.   goto WriteBit0;
  1297. /*
  1298.         Write with transparency
  1299. */
  1300. WriteTBit0:
  1301.   if (pixels&(3<<6))
  1302.     SETPIXEL(x+0, y, *(pTrans+(pixels>>6)));
  1303.   if (!--xsize)
  1304.     return;
  1305. WriteTBit1:
  1306.   if (pixels&(3<<4))
  1307.     SETPIXEL(x+1, y, *(pTrans+(3&(pixels>>4))));
  1308.   if (!--xsize)
  1309.     return;
  1310. WriteTBit2:
  1311.   if (pixels&(3<<2))
  1312.     SETPIXEL(x+2, y, *(pTrans+(3&(pixels>>2))));
  1313.   if (!--xsize)
  1314.     return;
  1315. WriteTBit3:
  1316.   if (pixels&(3<<0))
  1317.     SETPIXEL(x+3, y, *(pTrans+(3&(pixels))));
  1318.   if (!--xsize)
  1319.     return;
  1320.   pixels = *(++p);
  1321.   x+=4;
  1322.   goto WriteTBit0;
  1323. /*
  1324.         Write without transparency, xor
  1325. */
  1326. WriteXBit0:
  1327.   XORPIXEL_DATA(x+0, y, *(pTrans+(pixels>>6)));
  1328.   if (!--xsize)
  1329.     return;
  1330. WriteXBit1:
  1331.   XORPIXEL_DATA(x+1, y, *(pTrans+(3&(pixels>>4))));
  1332.   if (!--xsize)
  1333.     return;
  1334. WriteXBit2:
  1335.   XORPIXEL_DATA(x+2, y, *(pTrans+(3&(pixels>>2))));
  1336.   if (!--xsize)
  1337.     return;
  1338. WriteXBit3:
  1339.   XORPIXEL_DATA(x+3, y, *(pTrans+(3&(pixels))));
  1340.   if (!--xsize)
  1341.     return;
  1342.   pixels = *(++p);
  1343.   x+=4;
  1344.   goto WriteXBit0;
  1345. /*
  1346.         Write with transparency, xor
  1347. */
  1348. WriteTXBit0:
  1349.   if (pixels&(3<<6))
  1350.     XORPIXEL_DATA(x+0, y, *(pTrans+(pixels>>6)));
  1351.   if (!--xsize)
  1352.     return;
  1353. WriteTXBit1:
  1354.   if (pixels&(3<<4))
  1355.     XORPIXEL_DATA(x+1, y, *(pTrans+(3&(pixels>>4))));
  1356.   if (!--xsize)
  1357.     return;
  1358. WriteTXBit2:
  1359.   if (pixels&(3<<2))
  1360.     XORPIXEL_DATA(x+2, y, *(pTrans+(3&(pixels>>2))));
  1361.   if (!--xsize)
  1362.     return;
  1363. WriteTXBit3:
  1364.   if (pixels&(3<<0))
  1365.     XORPIXEL_DATA(x+3, y, *(pTrans+(3&(pixels))));
  1366.   if (!--xsize)
  1367.     return;
  1368.   pixels = *(++p);
  1369.   x+=4;
  1370.   goto WriteTXBit0;
  1371. }
  1373. #endif
  1375. #endif
  1377. /*
  1378.         *********************************************************
  1379.         *                                                       *
  1380.         *  Draw Bitmap 4 BPP                                    *
  1381.         *                                                       *
  1382.         *********************************************************
  1383. */
  1385. #if (LCD_MAX_LOG_COLORS > 4)
  1387. static void  DrawBitLine4BPP(int x, int y, U8 const *p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  1388.   PIXELCOLOR pixels;
  1389. /*
  1390. // Jump to right entry point
  1391. */
  1392.   pixels = *p;
  1393.   if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) {
  1394.     if ((Diff&1) ==0)
  1395.       goto WriteTBit0;
  1396.     goto WriteTBit1;
  1397.   } else {
  1398.     if ((Diff&1) ==0)
  1399.       goto WriteBit0;
  1400.     goto WriteBit1;
  1401.   }
  1402. /*
  1403.         Write without transparency
  1404. */
  1405. WriteBit0:
  1406.   SETPIXEL(x+0, y, *(pTrans+(pixels>>4)));
  1407.   if (!--xsize)
  1408.     return;
  1409. WriteBit1:
  1410.   SETPIXEL(x+1, y, *(pTrans+(pixels&0xf)));
  1411.   if (!--xsize)
  1412.     return;
  1413.   x+=2;
  1414.   pixels = *(++p);
  1415.   goto WriteBit0;
  1416. /*
  1417.         Write with transparency
  1418. */
  1419. WriteTBit0:
  1420.   if (pixels>>4)
  1421.     SETPIXEL(x+0, y, *(pTrans+(pixels>>4)));
  1422.   if (!--xsize)
  1423.     return;
  1424. WriteTBit1:
  1425.   if (pixels&0xf)
  1426.     SETPIXEL(x+1, y, *(pTrans+(pixels&0xf)));
  1427.   if (!--xsize)
  1428.     return;
  1429.   x+=2;
  1430.   pixels = *(++p);
  1431.   goto WriteTBit0;
  1432. }
  1434. #endif
  1436. /*
  1437.         *********************************************************
  1438.         *                                                       *
  1439.         *  Draw Bitmap 8 BPP  (256 colors)                      *
  1440.         *                                                       *
  1441.         *      Default (no optimization)                        *
  1442.         *                                                       *
  1443.         *********************************************************
  1444. */
  1446. #if (LCD_MAX_LOG_COLORS > 16)
  1447. static void  DrawBitLine8BPP(int x, int y, U8 const *p, int xsize, const LCD_PIXELINDEX*pTrans) {
  1448.   LCD_PIXELINDEX pixel;
  1449.   if (pTrans) {
  1450.     if ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS)==0) {
  1451.       while (xsize > 0) {
  1452.         pixel = *p;
  1453.         SETPIXEL(x+0, y, *(pTrans+pixel));
  1454.         xsize--; x++; p++;
  1455.       }
  1456.     } else {   /* Handle transparent bitmap */
  1457.       while (xsize > 0) {
  1458.         pixel = *p;
  1459.         if (pixel)
  1460.           SETPIXEL(x+0, y, *(pTrans+pixel));
  1461.         xsize--; x++; p++;
  1462.       }
  1463.     }
  1464.   } else {
  1465.     if ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS)==0) {
  1466.       while (xsize > 0) {
  1467.         pixel = *p;
  1468.         SETPIXEL(x+0, y, pixel);
  1469.         xsize--; x++; p++;
  1470.       }
  1471.     } else {   /* Handle transparent bitmap */
  1472.       while (xsize > 0) {
  1473.         pixel = *p;
  1474.         if (pixel)
  1475.           SETPIXEL(x+0, y, pixel);
  1476.         xsize--; x++; p++;
  1477.       }
  1478.     }
  1479.   }
  1480. }
  1482. #endif
  1484. /*
  1485.         *********************************************************
  1486.         *                                                       *
  1487.         *         Universal draw Bitmap routine                 *
  1488.         *                                                       *
  1489.         *********************************************************
  1490. */
  1492. void LCD_L0_DrawBitmap(int x0, int y0,
  1493.                        int xsize, int ysize,
  1494.                        int BitsPerPixel,
  1495.                        int BytesPerLine,
  1496.                        const U8* pData, int Diff,
  1497.                        const LCD_PIXELINDEX* pTrans)
  1498. {
  1499.   int i;
  1500.   /* Use aID for bitmaps without palette */
  1501.   if (!pTrans) {
  1502.     pTrans = aID;
  1503.   }
  1504.   /*
  1505.      Use DrawBitLineXBPP
  1506.   */
  1507.   switch (BitsPerPixel) {
  1508.   case 1:
  1509.     #if (LCD_OPTIMIZE)               
  1510.         && (LCD_BITSPERPIXEL == 2)   
  1511.         && (LCD_SWAP_XY ==1)         
  1512.         && (LCD_MIRROR_X==1)         
  1513.         && (LCD_MIRROR_Y==0)         
  1514.         && (!defined (LCD_LUT_SEG))
  1515.       SET_X_INCREMENT();
  1516.       xsize += Diff & 7;
  1517.       for (i = Diff; i < xsize; i++) {
  1518.         DrawBitLine1BPP_Swap(
  1519.           x0+i, y0,
  1520.           pData + (i>>3),
  1521.           ysize,
  1522.           pTrans,
  1523.           BytesPerLine,
  1524.           i
  1525.         );
  1526.       }
  1527.       SET_Y_INCREMENT();
  1528.       break;
  1529.     #else
  1530.       for (i=0; i<ysize; i++) {
  1531.         DrawBitLine1BPP(x0, i+y0, pData, Diff, xsize, pTrans);
  1532.         pData += BytesPerLine;
  1533.       }
  1534.       break;
  1535.     #endif
  1536.     #if (LCD_MAX_LOG_COLORS > 2)
  1537.     case 2:
  1538.       #if (LCD_OPTIMIZE)               
  1539.           && (LCD_BITSPERPIXEL == 2)   
  1540.           && (LCD_SWAP_XY ==1)         
  1541.           && (LCD_MIRROR_X==1)         
  1542.           && (LCD_MIRROR_Y==0)         
  1543.           && (!defined (LCD_LUT_SEG))
  1544.         SET_X_INCREMENT();
  1545.         xsize += Diff & 3;
  1546.         for (i = Diff; i < xsize; i++) {
  1547.           DrawBitLine2BPP_Swap(
  1548.             x0+i, y0,
  1549.             pData + (i>>2),
  1550.             ysize,
  1551.             pTrans,
  1552.             BytesPerLine,
  1553.             i
  1554.           );
  1555.         }
  1556.         SET_Y_INCREMENT();
  1557.         break;
  1558.       #else
  1559.         for (i=0; i<ysize; i++) {
  1560.           DrawBitLine2BPP(x0, i+y0, pData, Diff, xsize, pTrans);
  1561.           pData += BytesPerLine;
  1562.         }
  1563.         break;
  1564.       #endif
  1565.     #endif
  1566.     #if (LCD_MAX_LOG_COLORS > 4)
  1567.       case 4:
  1568.         for (i=0; i<ysize; i++) {
  1569.           DrawBitLine4BPP(x0, i+y0, pData, Diff, xsize, pTrans);
  1570.           pData += BytesPerLine;
  1571.         }
  1572.         break;
  1573.     #endif
  1574.     #if (LCD_MAX_LOG_COLORS > 16)
  1575.       case 8:
  1576.         for (i=0; i<ysize; i++) {
  1577.           DrawBitLine8BPP(x0, i+y0, pData, xsize, pTrans);
  1578.           pData += BytesPerLine;
  1579.         }
  1580.         break;
  1581.     #endif
  1582.   }
  1583. }
  1585. /*
  1586.         *********************************************************
  1587.         *                                                       *
  1588.         *       LCD_L0_SetOrg                                   *
  1589.         *                                                       *
  1590.         *********************************************************
  1592. Purpose:        Sets the original position of the virtual display.
  1593.                 Has no function at this point with the PC-driver.
  1594. */
  1596. int OrgX, OrgY;
  1597. void LCD_L0_SetOrg(int x, int y) {
  1598.   OrgX = x;
  1599.   OrgY = y;
  1600. }
  1602. /*
  1603.         *********************************************************
  1604.         *                                                       *
  1605.         *       LCD_On                                          *
  1606.         *       LCD_Off                                         *
  1607.         *                                                       *
  1608.         *********************************************************
  1609. */
  1611. void LCD_Off          (void) {
  1612.   aState[0].ConReg0 = (LCD_INIT_R00) & ~(1<<6);
  1613.   LCD_WriteReg0( 0, aState[0].ConReg0);
  1614. }
  1616. void LCD_On           (void) {
  1617.   aState[0].ConReg0 = (LCD_INIT_R00) |  (1<<6);
  1618.   LCD_WriteReg0( 0, aState[0].ConReg0);
  1619. }
  1621. /*
  1622.         *********************************************************
  1623.         *                                                       *
  1624.         *       LCD_L0_ReInit : Re-Init the display                *
  1625.         *                                                       *
  1626.         *********************************************************
  1628. ReInit contains all of the code that can be re-executed at any point without
  1629. changing or even disturbing what can be seen on the LCD.
  1630. Note that it is also used as a subroutine by LCD_L0_Init().
  1632. */
  1634. void  LCD_L0_ReInit(void) {
  1635.   LCD_INIT_CONTROLLER();
  1636.   aState[0].ConReg0 = (LCD_INIT_R00) | 0x80;
  1637.   aState[0].ConReg1 = (LCD_INIT_R01) & (~2);
  1638. /* Write control register 0, 1 */
  1639.   LCD_WriteReg0( 0, aState[0].ConReg0); /* Control register 1 */ 
  1640.   LCD_WriteReg0( 1, aState[0].ConReg1); /* Control register 2 */ 
  1642. }
  1644. /*
  1645.         *********************************************************
  1646.         *                                                       *
  1647.         *       LCD_Init : Init the display                     *
  1648.         *                                                       *
  1649.         *********************************************************
  1650. */
  1652. int  LCD_L0_Init(void) {
  1653.   U8 Data;
  1654.   GUI_DEBUG_LOG("nLCD_L0_Init()");
  1655. /* Invalidate register cache */
  1656.   { int i;
  1657.     for (i=0; i<LCD_NUM_CONTROLLERS; i++) {
  1658.      aState[i].x = aState[i].y = 255;
  1659.     }
  1660.   }
  1661.   LCD_L0_ReInit();
  1662. /* Check memory */
  1663.   SET_X0(1);
  1664.   SET_Y0(2);
  1665.   WRITE_VMEM0(0x12);
  1666.   SET_X0(3);
  1667.   SET_Y0(4);
  1668.   WRITE_VMEM0(0x34);
  1669.   SET_X0(1);
  1670.   SET_Y0(2);
  1671.   READ_VMEM0(Data);
  1672.   if (Data != 0x12) {
  1673.     GUI_DEBUG_ERROROUT("nLCD6642X: video memory problem");
  1674.     return LCD_ERR_MEMORY;
  1675.   }
  1676.   SET_X0(3);
  1677.   SET_Y0(4);
  1678.   READ_VMEM0(Data);
  1679.   if (Data != 0x34) {
  1680.     GUI_DEBUG_ERROROUT("nLCD6642X: video memory problem");
  1681.     return LCD_ERR_MEMORY;
  1682.   }
  1683. /* Fill LCD memory with gray scale bar */
  1684.   #if 1
  1685.   {
  1686.     int x, y;
  1687.     int MaxX, MaxY;
  1688.     int IncX = (aState[0].ConReg1 & 1<<1) ? 1 : 0;
  1689.     if (IncX) {
  1690.       MaxX = MAX_COMS;
  1691.       MaxY = MAX_SEGS/4;
  1692.     } else {
  1693.       MaxY = MAX_COMS;
  1694.       MaxX = MAX_SEGS/4;
  1695.     }
  1696.     for (x=0; x < MaxX; x++) {
  1697.       if (IncX) {
  1698.         SET_X0(0);
  1699.         SET_Y0(x);
  1700.       } else {
  1701.         SET_X0(x);
  1702.         SET_Y0(0);
  1703.       }
  1704.       for (y=0; y<MaxY; y++) {
  1705.         WRITE_VMEM0(0x00);
  1706.       }
  1707.     }
  1708.   }
  1709.   #endif
  1710.   return 0;    /* Init successfull ! */
  1711. }
  1713. /*
  1714.         *********************************************************
  1715.         *                                                       *
  1716.         *       LCD_L0_CheckInit                                   *
  1717.         *                                                       *
  1718.         *  Check if display controller(s) is/are still          *
  1719.         *  properly initialized                                 *
  1720.         *                                                       *
  1721.         *********************************************************
  1723. Return value: 0 => No error, init is O.K.
  1725. */
  1727. #if LCD_SUPPORT_CHECKINIT
  1729. char LCD_L0_CheckInit(void) {
  1730.   return 0;
  1731. }
  1732. #endif
  1734. #else
  1736. void LCD6642X(void) { } /* avoid empty object files */
  1738. #endif  /* Right LCD_CONTROLLER */