EFR32 Mighty Gecko 1 Software Documentation  efr32mg1-doc-5.1.2
displayls013b7dh03.c
Go to the documentation of this file.
1 /**************************************************************************/
18 #include <stdint.h>
19 #include <stdbool.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 
24 #include "em_gpio.h"
25 
26 /* DISPLAY driver inclustions */
27 #include "displayconfigall.h"
28 #include "displaypal.h"
29 #include "displaybackend.h"
30 #include "displayls013b7dh03.h"
31 
34 /*******************************************************************************
35  ******************************** DEFINES ************************************
36  ******************************************************************************/
37 
38 /* LS013B7DH03 SPI commands */
39 #define LS013B7DH03_CMD_UPDATE (0x01)
40 #define LS013B7DH03_CMD_ALL_CLEAR (0x04)
41 
42 /* Frequency of LCD polarity inversion. */
43 #ifndef LS013B7DH03_POLARITY_INVERSION_FREQUENCY
44 #define LS013B7DH03_POLARITY_INVERSION_FREQUENCY (128)
45 #endif
46 
47 #ifdef USE_CONTROL_BYTES
48 #define LS013B7DH03_CONTROL_BYTES (2)
49 #else
50 #define LS013B7DH03_CONTROL_BYTES (0)
51 #endif
52 
53 #ifdef PIXEL_MATRIX_ALLOC_SUPPORT
54 
55  #ifdef USE_STATIC_PIXEL_MATRIX_POOL
56  /* Static pool has been chosen for pixelmatix allocation.
57  Disable the use of malloc for allocation of pixel matrices. */
58  #undef USE_MALLOC
59  #endif
60 
61  #ifdef USE_MALLOC
62  /* malloc has been chosen for pixelmatix allocation.
63  Disable the use of static pool for allocation of pixel matrices. */
64  #undef USE_STATIC_PIXEL_MATRIX_POOL
65  #endif
66 
67 #endif /* PIXEL_MATRIX_ALLOC_SUPPORT */
68 
69 
70 /*******************************************************************************
71  ********************************* TYPEDEFS **********************************
72  ******************************************************************************/
73 
74 #ifdef PIXEL_MATRIX_ALLOC_SUPPORT
75 #ifndef PIXEL_MATRIX_ALIGNMENT
76 typedef uint8_t PixelMatrixAlign_t;
77 #else
78  #if (1 == PIXEL_MATRIX_ALIGNMENT)
79  typedef uint8_t PixelMatrixAlign_t;
80  #elif (2 == PIXEL_MATRIX_ALIGNMENT)
81  typedef uint16_t PixelMatrixAlign_t;
82  #elif (4 == PIXEL_MATRIX_ALIGNMENT)
83  typedef uint32_t PixelMatrixAlign_t;
84  #else
85  #error Unsupported PIXEL_MATRIX_ALIGNMENT.
86  #endif
87 #endif
88 #endif
89 
90 
91 /*******************************************************************************
92  ******************************** STATICS ************************************
93  ******************************************************************************/
94 
95 /* Static variables: */
96 static uint8_t lcdPolarity = 0;
97 
98 #ifdef PIXEL_MATRIX_ALLOC_SUPPORT
99 #ifdef USE_STATIC_PIXEL_MATRIX_POOL
100 #define PIXEL_MATRIX_POOL_ELEMENTS \
101  (PIXEL_MATRIX_POOL_SIZE/sizeof(PixelMatrixAlign_t) + \
102  ((PIXEL_MATRIX_POOL_SIZE%sizeof(PixelMatrixAlign_t))? 1 : 0))
103 static PixelMatrixAlign_t pixelMatrixPoolBase[PIXEL_MATRIX_POOL_ELEMENTS];
104 static PixelMatrixAlign_t* pixelMatrixPool = pixelMatrixPoolBase;
105 #endif
106 #endif
107 
108 
109 /*******************************************************************************
110  ************************ STATIC FUNCTION PROTOTYPES ***********************
111  ******************************************************************************/
112 
113 static EMSTATUS DisplayEnable(DISPLAY_Device_t* device,
114  bool enable);
115 static EMSTATUS DisplayClear(void);
116 #ifndef POLARITY_INVERSION_EXTCOMIN_PAL_AUTO_TOGGLE
117 static EMSTATUS DisplayPolarityInverse (void);
118 #endif
119 
120 #ifdef PIXEL_MATRIX_ALLOC_SUPPORT
121 static EMSTATUS PixelMatrixAllocate( DISPLAY_Device_t* device,
122  unsigned int width,
123 #ifdef EMWIN_WORKAROUND
124  unsigned int userStride,
125 #endif
126  unsigned int height,
127  DISPLAY_PixelMatrix_t *pixelMatrix);
128 static EMSTATUS PixelMatrixFree( DISPLAY_Device_t* device,
129  DISPLAY_PixelMatrix_t pixelMatrix);
130 #endif
131 static EMSTATUS PixelMatrixDraw( DISPLAY_Device_t* device,
132  DISPLAY_PixelMatrix_t pixelMatrix,
133  unsigned int startColumn,
134  unsigned int width,
135 #ifdef EMWIN_WORKAROUND
136  unsigned int userStride,
137 #endif
138  unsigned int startRow,
139  unsigned int height );
140 static EMSTATUS PixelMatrixClear( DISPLAY_Device_t* device,
141  DISPLAY_PixelMatrix_t pixelMatrix,
142  unsigned int width,
143  unsigned int height);
144 static EMSTATUS DriverRefresh (DISPLAY_Device_t* device);
145 
146 
147 /*******************************************************************************
148  ************************** GLOBAL FUNCTIONS **************************
149  ******************************************************************************/
150 
151 /**************************************************************************/
156 EMSTATUS DISPLAY_Ls013b7dh03Init(void)
157 {
158  DISPLAY_Device_t display;
159  EMSTATUS status;
160 
161  /* Initialize the Platform Abstraction Layer (PAL) interface. */
162  PAL_TimerInit();
163  PAL_SpiInit();
164  PAL_GpioInit();
165 
166  /* Setup GPIOs */
167  PAL_GpioPinModeSet(LCD_PORT_SCLK, LCD_PIN_SCLK, palGpioModePushPull,0);
168  PAL_GpioPinModeSet(LCD_PORT_SI, LCD_PIN_SI, palGpioModePushPull,0);
169  PAL_GpioPinModeSet(LCD_PORT_SCS, LCD_PIN_SCS, palGpioModePushPull,0);
170 #if defined( LCD_PORT_DISP_SEL )
171  PAL_GpioPinModeSet(LCD_PORT_DISP_SEL,LCD_PIN_DISP_SEL,palGpioModePushPull,0);
172 #endif
173 
174 #if defined( LCD_PORT_DISP_PWR )
175  PAL_GpioPinModeSet(LCD_PORT_DISP_PWR,LCD_PIN_DISP_PWR,palGpioModePushPull,0);
176 #endif
177 
178 #if defined( LCD_PORT_EXTMODE )
179  PAL_GpioPinModeSet(LCD_PORT_EXTMODE, LCD_PIN_EXTMODE, palGpioModePushPull,0);
180 #endif
181 #if defined (LCD_PORT_EXTCOMIN)
182  PAL_GpioPinModeSet(LCD_PORT_EXTCOMIN,LCD_PIN_EXTCOMIN,palGpioModePushPull,0);
183 #endif
184 #ifdef PAL_TIMER_REPEAT_FUNCTION
185  /* If the platform specifies to use a timer repeat function we should
186  register the DisplayPolarityInverse to be called every second in
187  order to toggle the EXTCOMIN pin at 1Hz.
188  */
189  status =
190  PAL_TimerRepeat((void(*)(void*)) DisplayPolarityInverse, 0,
191  LS013B7DH03_POLARITY_INVERSION_FREQUENCY);
192 #elif defined POLARITY_INVERSION_EXTCOMIN_MANUAL
193  /* Manually do the toggling of the EXTCOMIN pin in the application. */
194  status = PAL_EMSTATUS_OK;
195 #elif defined POLARITY_INVERSION_EXTCOMIN_PAL_AUTO_TOGGLE
196  /* Setup system (via PAL) to toggle the EXTCOMIN pin every second. */
197  status = PAL_GpioPinAutoToggle(LCD_PORT_EXTCOMIN, LCD_PIN_EXTCOMIN,
198  LS013B7DH03_POLARITY_INVERSION_FREQUENCY);
199 #else
200  /* System does not support toggling the EXTCOMIN pin. Return error. */
202 #endif
203  if (PAL_EMSTATUS_OK != status)
204  {
205  return status;
206  }
207 
208  /* Setup and register the LS013B7DH03 as a DISPLAY device now. */
209  display.name = SHARP_MEMLCD_DEVICE_NAME;
212  display.geometry.width = LS013B7DH03_WIDTH;
213  display.geometry.height = LS013B7DH03_HEIGHT;
214  /* stride = pixels + ctrl bytes */
215  display.geometry.stride =
216  display.geometry.width + LS013B7DH03_CONTROL_BYTES*8;
217 
218  display.pDisplayPowerOn = DisplayEnable;
219 #ifdef PIXEL_MATRIX_ALLOC_SUPPORT
220  display.pPixelMatrixAllocate = PixelMatrixAllocate;
221  display.pPixelMatrixFree = PixelMatrixFree;
222 #else
223  display.pPixelMatrixAllocate = NULL;
224  display.pPixelMatrixFree = NULL;
225 #endif
226  display.pPixelMatrixDraw = PixelMatrixDraw;
227  display.pPixelMatrixClear = PixelMatrixClear;
228  display.pDriverRefresh = DriverRefresh;
229 
230  status = DISPLAY_DeviceRegister (&display);
231 
232  if (DISPLAY_EMSTATUS_OK == status)
233  {
234  /* Turn on display. */
235  DisplayEnable(&display, true);
236 
237  /* Clear display */
238  DisplayClear();
239  }
240 
241  return status;
242 }
243 
244 
245 /*******************************************************************************
246  ***************************** STATIC FUNCTIONS ****************************
247  ******************************************************************************/
248 
249 /**************************************************************************/
256 static EMSTATUS DriverRefresh(DISPLAY_Device_t* device)
257 {
258  EMSTATUS status = DISPLAY_EMSTATUS_OK;
259 
260  (void) device; /* Suppress compiler warning: unused parameter. */
261 
262  /* Reinitialize the timer and SPI configuration. */
263  PAL_TimerInit();
264  PAL_SpiInit();
265 
266  return status;
267 }
268 
269 
270 /**************************************************************************/
283 static EMSTATUS DisplayEnable(DISPLAY_Device_t* device,
284  bool enable)
285 {
286  (void) device; /* Suppress compiler warning: unused parameter. */
287 
288  if (enable)
289  {
290 #if defined( LCD_PORT_DISP_SEL )
291  /* Set EFM_DISP_SELECT pin. */
292  PAL_GpioPinOutSet(LCD_PORT_DISP_SEL, LCD_PIN_DISP_SEL);
293 #endif
294 
295 #if defined( LCD_PORT_DISP_PWR )
296  /* Drive voltage on EFM_DISP_PWR_EN pin. */
297  PAL_GpioPinOutSet(LCD_PORT_DISP_PWR, LCD_PIN_DISP_PWR);
298 #endif
299  }
300  else
301  {
302 #if defined( LCD_PORT_DISP_PWR )
303  /* Stop driving voltage on EFM_DISP_PWR_EN pin. */
304  PAL_GpioPinOutClear(LCD_PORT_DISP_PWR, LCD_PIN_DISP_PWR);
305 #endif
306 
307 #if defined( LCD_PORT_DISP_SEL )
308  /* Clear EFM_DISP_SELECT pin. */
309  PAL_GpioPinOutClear(LCD_PORT_DISP_SEL, LCD_PIN_DISP_SEL);
310 #endif
311  }
312 
313  return DISPLAY_EMSTATUS_OK;
314 }
315 
316 
317 /**************************************************************************/
324 static EMSTATUS DisplayClear ( void )
325 {
326  uint16_t cmd;
327 
328  /* Set SCS */
329  PAL_GpioPinOutSet( LCD_PORT_SCS, LCD_PIN_SCS );
330 
331  /* SCS setup time: min 6us */
332  PAL_TimerMicroSecondsDelay(6);
333 
334  /* Send command */
335  cmd = LS013B7DH03_CMD_ALL_CLEAR | lcdPolarity;
336  PAL_SpiTransmit ((uint8_t*) &cmd, 2 );
337 
338  /* SCS hold time: min 2us */
339  PAL_TimerMicroSecondsDelay(2);
340 
341  /* Clear SCS */
342  PAL_GpioPinOutClear( LCD_PORT_SCS, LCD_PIN_SCS );
343 
344  return DISPLAY_EMSTATUS_OK;
345 }
346 
347 
348 #ifdef PAL_TIMER_REPEAT_FUNCTION
349 
350 /**************************************************************************/
358 static EMSTATUS DisplayPolarityInverse (void)
359 {
360 #ifdef POLARITY_INVERSION_EXTCOMIN
361 
362 #if defined(LCD_PORT_EXTCOMIN)
363  /* Toggle extcomin gpio */
364  PAL_GpioPinOutToggle( LCD_PORT_EXTCOMIN, LCD_PIN_EXTCOMIN );
365 #endif
366 #else /* POLARITY_INVERSION_EXTCOMIN */
367 
368  /* Send a packet with inverted com */
369  PAL_GpioPinOutSet( LCD_PORT_SCS, LCD_PIN_SCS );
370 
371  /* SCS setup time: min 6us */
372  PAL_TimerMicroSecondsDelay(6);
373 
374  /* Send polarity command including dummy bits */
375  PAL_SpiTransmit ((uint8_t*) &lcdPolarity, 2 );
376 
377  /* SCS hold time: min 2us */
378  PAL_TimerMicroSecondsDelay(2);
379 
380  PAL_GpioPinOutClear( LCD_PORT_SCS, LCD_PIN_SCS );
381 
382  /* Invert com polarity */
383  if (lcdPolarity == 0x00)
384  {
385  lcdPolarity = 0x02;
386  }
387  else
388  {
389  lcdPolarity = 0x00;
390  }
391 
392 #endif /* POLARITY_INVERSION_EXTCOMIN */
393 
394  return DISPLAY_EMSTATUS_OK;
395 }
396 
397 #endif /* POLARITY_INVERSION_EXTCOMIN_PAL_AUTO_TOGGLE */
398 
399 
400 #ifdef PIXEL_MATRIX_ALLOC_SUPPORT
401 /**************************************************************************/
419 static EMSTATUS PixelMatrixAllocate( DISPLAY_Device_t* device,
420  unsigned int width,
421 #ifdef EMWIN_WORKAROUND
422  unsigned int userStride,
423 #endif
424  unsigned int height,
425  DISPLAY_PixelMatrix_t *pixelMatrix)
426 {
427 #ifdef EMWIN_WORKAROUND
428  unsigned int allocSize = (userStride/8 + LS013B7DH03_CONTROL_BYTES) * height;
429 #else
430  unsigned int allocSize = (width/8 + LS013B7DH03_CONTROL_BYTES) * height;
431 #endif
432 
433  (void) device; /* Suppress compiler warning: unused parameter. */
434 
435  if (width != LS013B7DH03_WIDTH)
437 #ifdef EMWIN_WORKAROUND
438  if (userStride < width)
440 #endif
441 
442 #ifdef USE_MALLOC
443 
444  /* Allocate the pixel matrix buffer including 2 control bytes per line. */
445  *pixelMatrix = (DISPLAY_PixelMatrix_t) malloc (allocSize);
446 
447  if (NULL == *pixelMatrix)
449  else
450  return DISPLAY_EMSTATUS_OK;
451 
452 #endif /* USE_MALLOC */
453 
454 #ifdef USE_STATIC_PIXEL_MATRIX_POOL
455 
456  if (((uint8_t*)pixelMatrixPool) + allocSize >
457  ((uint8_t*)pixelMatrixPoolBase) + PIXEL_MATRIX_POOL_SIZE)
458  {
459  *pixelMatrix = NULL;
461  }
462  else
463  {
464  *pixelMatrix = pixelMatrixPool;
465  pixelMatrixPool += allocSize / sizeof(PixelMatrixAlign_t) +
466  ((allocSize % sizeof(PixelMatrixAlign_t))? 1 : 0);
467  return DISPLAY_EMSTATUS_OK;
468  }
469 
470 #endif /* USE_STATIC_PIXEL_MATRIX_POOL */
471 
472 }
473 #endif /* PIXEL_MATRIX_ALLOC_SUPPORT */
474 
475 
476 #ifdef PIXEL_MATRIX_ALLOC_SUPPORT
477 /**************************************************************************/
487 static EMSTATUS PixelMatrixFree( DISPLAY_Device_t* device,
488  DISPLAY_PixelMatrix_t pixelMatrix)
489 {
490  (void) device; /* Suppress compiler warning: unused parameter. */
491 
492 #ifdef USE_MALLOC
493  free(pixelMatrix);
494  return DISPLAY_EMSTATUS_OK;
495 #endif /* USE_MALLOC */
496 
497 #ifdef USE_STATIC_PIXEL_MATRIX_POOL
498  /* The non-malloc PixelMatrixAllocate function only allocates buffers
499  consequtively from a pool. It is not possible to free the buffers.
500  I.e. this allocator can only be used for one-shot allocations of
501  buffers that will should never be freed and re-alloced.
502  */
503  (void) pixelMatrix; /* Supress compiles warning: unused parameter. */
505 #endif
506 }
507 #endif /* PIXEL_MATRIX_ALLOC_SUPPORT */
508 
509 
510 /**************************************************************************/
527 static EMSTATUS PixelMatrixClear( DISPLAY_Device_t* device,
528  DISPLAY_PixelMatrix_t pixelMatrix,
529  unsigned int width,
530  unsigned int height)
531 {
532  uint8_t* pByte = (uint8_t*) pixelMatrix;
533  unsigned int i;
534 
535  (void) device; /* Suppress compiler warning: unused parameter. */
536  (void) width; /* Suppress compiler warning: unused parameter. */
537 
538  for (i=0; i<height; i++)
539  {
540  /* Clear line */
541  memset(pByte, 0, LS013B7DH03_WIDTH/8);
542  pByte += LS013B7DH03_WIDTH/8;
543 
544 #ifdef USE_CONTROL_BYTES
545  /* Set dummy byte. */
546  *pByte++ = 0xff;
547  /* Set address of next line */
548  *pByte++ = i+1;
549 #endif
550  }
551 
552  return DISPLAY_EMSTATUS_OK;
553 }
554 
555 
556 #ifdef USE_CONTROL_BYTES
557 /**************************************************************************/
568 static EMSTATUS pixelMatrixSetup( DISPLAY_PixelMatrix_t pixelMatrix,
569  unsigned int startRow,
570  unsigned int height
571 #ifdef EMWIN_WORKAROUND
572  ,
573  unsigned int userStride
574 #endif
575  )
576 {
577  int i = 0;
578  uint8_t* pByte = (uint8_t*) pixelMatrix;
579 #ifdef EMWIN_WORKAROUND
580  int strideGap =
581  (userStride-LS013B7DH03_WIDTH-(LS013B7DH03_CONTROL_BYTES*8)) /
582  8 / sizeof(uint8_t);
583  if ((userStride-LS013B7DH03_WIDTH) % sizeof(uint16_t))
585 #endif
586 
587  while (i<height)
588  {
589  pByte += LS013B7DH03_WIDTH/8;
590  /* Set dummy byte. */
591  *pByte++ = 0xff;
592 
593  if (i == height-1)
594  {
595  /* Set dummy data at end of last line. */
596  *pByte++ = 0xff;
597  break;
598  }
599  else
600  /* Set address of next line */
601  *pByte++ = startRow + (++i);
602 
603 #ifdef EMWIN_WORKAROUND
604  pByte += strideGap;
605 #endif
606  }
607 
608  return DISPLAY_EMSTATUS_OK;
609 }
610 
611 #endif /* USE_CONTROL_BYTES */
612 
613 
614 /**************************************************************************/
631 static EMSTATUS PixelMatrixDraw( DISPLAY_Device_t* device,
632  DISPLAY_PixelMatrix_t pixelMatrix,
633  unsigned int startColumn,
634  unsigned int width,
635 #ifdef EMWIN_WORKAROUND
636  unsigned int userStride,
637 #endif
638  unsigned int startRow,
639  unsigned int height )
640 {
641  unsigned int i;
642  uint16_t* p = (uint16_t *)pixelMatrix;
643  uint16_t cmd;
644 #ifdef EMWIN_WORKAROUND
645  int strideGap =
646  (userStride-width-(LS013B7DH03_CONTROL_BYTES*8)) / 8 / sizeof(uint16_t);
647  if ((userStride-width) % sizeof(uint16_t))
649 #else
650  (void) width; /* Suppress compiler warning: unused parameter. */
651 #endif
652  (void) startColumn; /* Suppress compiler warning: unused parameter. */
653  (void) device; /* Suppress compiler warning: unused parameter. */
654 
655  /* Need to adjust start row by one because LS013B7DH03 starts counting lines
656  from 1, while the DISPLAY interface starts from 0. */
657  startRow++;
658 
659 #ifdef USE_CONTROL_BYTES
660  /* Setup line addressing in control words. */
661  pixelMatrixSetup(pixelMatrix, startRow, height
662 #ifdef EMWIN_WORKAROUND
663  , userStride
664 #endif
665  );
666 #endif
667 
668  /* Assert SCS */
669  PAL_GpioPinOutSet( LCD_PORT_SCS, LCD_PIN_SCS );
670 
671  /* SCS setup time: min 6us */
672  PAL_TimerMicroSecondsDelay(6);
673 
674  /* Send update command and first line address */
675  cmd = LS013B7DH03_CMD_UPDATE | (startRow << 8);
676  PAL_SpiTransmit((uint8_t*) &cmd, 2 );
677 
678  /* Get start address to draw from */
679  for ( i=0; i<height; i++ ) {
680 
681  /* Send pixels for this line */
682  PAL_SpiTransmit((uint8_t*) p,
683  LS013B7DH03_WIDTH/8 + LS013B7DH03_CONTROL_BYTES);
684  p+=(LS013B7DH03_WIDTH/8 + LS013B7DH03_CONTROL_BYTES) / sizeof(uint16_t);
685 
686 #ifndef USE_CONTROL_BYTES
687  if (i==height-1)
688  {
689  cmd = 0xffff;
690  }
691  else
692  {
693  cmd = 0xff | ((startRow+i+1) << 8);
694  }
695  PAL_SpiTransmit((uint8_t*) &cmd, 2 );
696 #endif
697 
698 #ifdef EMWIN_WORKAROUND
699  p += strideGap;
700 #endif
701 
702  }
703 
704  /* SCS hold time: min 2us */
705  PAL_TimerMicroSecondsDelay(2);
706 
707  /* De-assert SCS */
708  PAL_GpioPinOutClear( LCD_PORT_SCS, LCD_PIN_SCS );
709 
710  return DISPLAY_EMSTATUS_OK;
711 }
712 
DISPLAY_ColourMode_t colourMode
Definition: display.h:110
EMSTATUS(* pPixelMatrixClear)(struct DISPLAY_Device_t *device, DISPLAY_PixelMatrix_t pixelMatrix, unsigned int width, unsigned int height)
Definition: display.h:145
#define DISPLAY_EMSTATUS_INVALID_PARAMETER
Definition: display.h:48
#define DISPLAY_EMSTATUS_NOT_ENOUGH_MEMORY
Definition: display.h:46
EMSTATUS DISPLAY_DeviceRegister(DISPLAY_Device_t *device)
Register a display device.
Definition: display.c:172
Display device backend interface.
EMSTATUS(* pDriverRefresh)(struct DISPLAY_Device_t *device)
Definition: display.h:153
EMSTATUS(* pPixelMatrixDraw)(struct DISPLAY_Device_t *device, DISPLAY_PixelMatrix_t pixelMatrix, unsigned int startColumn, unsigned int width, unsigned int startRow, unsigned int height)
Definition: display.h:134
EMSTATUS(* pDisplayPowerOn)(struct DISPLAY_Device_t *device, bool on)
Definition: display.h:114
EMSTATUS(* pPixelMatrixFree)(struct DISPLAY_Device_t *device, DISPLAY_PixelMatrix_t pixelMatrix)
Definition: display.h:129
Platform Abstraction Layer (PAL) interface for DISPLAY driver.
General Purpose IO (GPIO) peripheral API.
unsigned int width
Definition: display.h:91
unsigned int stride
Definition: display.h:92
unsigned int height
Definition: display.h:94
#define PAL_EMSTATUS_OK
Definition: displaypal.h:34
#define DISPLAY_EMSTATUS_OK
Definition: display.h:45
Main configuration file for the DISPLAY driver software stack.
#define DISPLAY_EMSTATUS_OUT_OF_RANGE
Definition: display.h:47
DISPLAY_Geometry_t geometry
Definition: display.h:109
Configuration for the display driver for the Sharp Memory LCD LS013B7DH03.
#define DISPLAY_EMSTATUS_NOT_SUPPORTED
Definition: display.h:49
EMSTATUS(* pPixelMatrixAllocate)(struct DISPLAY_Device_t *device, unsigned int width, unsigned int height, DISPLAY_PixelMatrix_t *pixelMatrix)
Definition: display.h:119
void * DISPLAY_PixelMatrix_t
Definition: display.h:81
DISPLAY_AddressMode_t addressMode
Definition: display.h:111