Data Structures
struct	tLCDIDDTiming

struct	tLCDRasterTiming

Macros
#define	PAL_FROM_RGB(ui32RGBColor)

#define	CYCLES_FROM_TIME_US(ui32ClockFreq, ui32Time_uS)

#define	CYCLES_FROM_TIME_NS(ui32ClockFreq, ui32Time_nS)

#define	RASTER_TIMING_SYNCS_OPPOSITE_PIXCLK 0x00000000

#define	RASTER_TIMING_SYNCS_ON_RISING_PIXCLK 0x02000000

#define	RASTER_TIMING_SYNCS_ON_FALLING_PIXCLK 0x03000000

#define	RASTER_TIMING_ACTIVE_HIGH_OE 0x00000000

#define	RASTER_TIMING_ACTIVE_LOW_OE 0x00800000

#define	RASTER_TIMING_ACTIVE_HIGH_PIXCLK 0x00000000

#define	RASTER_TIMING_ACTIVE_LOW_PIXCLK 0x00400000

#define	RASTER_TIMING_ACTIVE_HIGH_HSYNC 0x00000000

#define	RASTER_TIMING_ACTIVE_LOW_HSYNC 0x00200000

#define	RASTER_TIMING_ACTIVE_HIGH_VSYNC 0x00000000

#define	RASTER_TIMING_ACTIVE_LOW_VSYNC 0x00100000

#define	LCD_MODE_LIDD ((uint8_t)0x00)

#define	LCD_MODE_RASTER ((uint8_t)0x01)

#define	LCD_MODE_AUTO_UFLOW_RESTART ((uint8_t)0x02)

#define	LIDD_CONFIG_SYNC_MPU68 0x00000000

#define	LIDD_CONFIG_ASYNC_MPU68 0x00000001

#define	LIDD_CONFIG_SYNC_MPU80 0x00000002

#define	LIDD_CONFIG_ASYNC_MPU80 0x00000003

#define	LIDD_CONFIG_ASYNC_HITACHI 0x00000004

#define	LIDD_CONFIG_INVERT_ALE 0x00000008

#define	LIDD_CONFIG_INVERT_RS_EN 0x00000010

#define	LIDD_CONFIG_INVERT_WS_DIR 0x00000020

#define	LIDD_CONFIG_INVERT_CS0 0x00000040

#define	LIDD_CONFIG_INVERT_CS1 0x00000080

#define	RASTER_FMT_ACTIVE_24BPP_PACKED 0x02000080

#define	RASTER_FMT_ACTIVE_24BPP_UNPACKED 0x06000080

#define	RASTER_FMT_ACTIVE_PALETTIZED_12BIT 0x00000080

#define	RASTER_FMT_ACTIVE_PALETTIZED_16BIT 0x00800080

#define	RASTER_FMT_PASSIVE_MONO_4PIX 0x00000002

#define	RASTER_FMT_PASSIVE_MONO_8PIX 0x00000202

#define	RASTER_FMT_PASSIVE_PALETTIZED 0x00000000

#define	RASTER_FMT_PASSIVE_COLOR_12BIT 0x00000000

#define	RASTER_FMT_PASSIVE_COLOR_16BIT 0x01000000

#define	RASTER_ACTVID_DURING_BLANK 0x08000000

#define	RASTER_NIBBLE_MODE_ENABLED 0x00400000

#define	RASTER_LOAD_DATA_ONLY 0x00200000

#define	RASTER_LOAD_PALETTE_ONLY 0x00100000

#define	RASTER_READ_ORDER_REVERSED 0x00000100

#define	LCD_INT_DMA_DONE 0x00000001

#define	LCD_INT_RASTER_FRAME_DONE 0x00000002

#define	LCD_INT_SYNC_LOST 0x00000004

#define	LCD_INT_AC_BIAS_CNT 0x00000008

#define	LCD_INT_UNDERFLOW 0x00000020

#define	LCD_INT_PAL_LOAD 0x00000040

#define	LCD_INT_EOF0 0x00000100

#define	LCD_INT_EOF1 0x00000200

#define	LCD_DMA_FIFORDY_8_WORDS 0x00000000

#define	LCD_DMA_FIFORDY_16_WORDS 0x00000100

#define	LCD_DMA_FIFORDY_32_WORDS 0x00000200

#define	LCD_DMA_FIFORDY_64_WORDS 0x00000300

#define	LCD_DMA_FIFORDY_128_WORDS 0x00000400

#define	LCD_DMA_FIFORDY_256_WORDS 0x00000500

#define	LCD_DMA_FIFORDY_512_WORDS 0x00000600

#define	LCD_DMA_BURST_1 0x00000010

#define	LCD_DMA_BURST_2 0x00000010

#define	LCD_DMA_BURST_4 0x00000020

#define	LCD_DMA_BURST_8 0x00000030

#define	LCD_DMA_BURST_16 0x00000040

#define	LCD_DMA_BYTE_ORDER_0123 0x00000000

#define	LCD_DMA_BYTE_ORDER_1023 0x00000008

#define	LCD_DMA_BYTE_ORDER_3210 0x00000002

#define	LCD_DMA_BYTE_ORDER_2301 0x0000000A

#define	LCD_DMA_PING_PONG 0x00000001

#define	LCD_PALETTE_TYPE_1BPP 0x00000000

#define	LCD_PALETTE_TYPE_2BPP 0x00001000

#define	LCD_PALETTE_TYPE_4BPP 0x00002000

#define	LCD_PALETTE_TYPE_8BPP 0x00003000

#define	LCD_PALETTE_TYPE_DIRECT 0x00004000

#define	LCD_PALETTE_SRC_24BIT 0x80000000

#define	LCD_CLOCK_MAIN 0x00000008

#define	LCD_CLOCK_DMA 0x00000004

#define	LCD_CLOCK_LIDD 0x00000002

#define	LCD_CLOCK_CORE 0x00000001

#define	LCD_SUBPANEL_AT_TOP 0x20000000

#define	LCD_SUBPANEL_AT_BOTTOM 0x00000000

Functions
uint32_t	LCDModeSet (uint32_t ui32Base, uint8_t ui8Mode, uint32_t ui32PixClk, uint32_t ui32SysClk)

void	LCDClockReset (uint32_t ui32Base, uint32_t ui32Clocks)

void	LCDIDDConfigSet (uint32_t ui32Base, uint32_t ui32Config)

void	LCDIDDTimingSet (uint32_t ui32Base, uint32_t ui32CS, const tLCDIDDTiming *pTiming)

void	LCDIDDDMADisable (uint32_t ui32Base)

void	LCDIDDCommandWrite (uint32_t ui32Base, uint32_t ui32CS, uint16_t ui16Cmd)

void	LCDIDDDataWrite (uint32_t ui32Base, uint32_t ui32CS, uint16_t ui16Data)

void	LCDIDDIndexedWrite (uint32_t ui32Base, uint32_t ui32CS, uint16_t ui16Addr, uint16_t ui16Data)

uint16_t	LCDIDDStatusRead (uint32_t ui32Base, uint32_t ui32CS)

uint16_t	LCDIDDDataRead (uint32_t ui32Base, uint32_t ui32CS)

uint16_t	LCDIDDIndexedRead (uint32_t ui32Base, uint32_t ui32CS, uint16_t ui16Addr)

void	LCDIDDDMAWrite (uint32_t ui32Base, uint32_t ui32CS, const uint32_t *pui32Data, uint32_t ui32Count)

void	LCDRasterConfigSet (uint32_t ui32Base, uint32_t ui32Config, uint8_t ui8PalLoadDelay)

void	LCDRasterTimingSet (uint32_t ui32Base, const tLCDRasterTiming *pTiming)

void	LCDRasterACBiasIntCountSet (uint32_t ui32Base, uint8_t ui8Count)

void	LCDRasterEnable (uint32_t ui32Base)

bool	LCDRasterEnabled (uint32_t ui32Base)

void	LCDRasterDisable (uint32_t ui32Base)

void	LCDRasterSubPanelConfigSet (uint32_t ui32Base, uint32_t ui32Flags, uint32_t ui32BottomLines, uint32_t ui32DefaultPixel)

void	LCDRasterSubPanelEnable (uint32_t ui32Base)

void	LCDRasterSubPanelDisable (uint32_t ui32Base)

void	LCDDMAConfigSet (uint32_t ui32Base, uint32_t ui32Config)

void	LCDRasterPaletteSet (uint32_t ui32Base, uint32_t ui32Type, uint32_t pui32Addr, const uint32_t pui32SrcColors, uint32_t ui32Start, uint32_t ui32Count)

void	LCDRasterFrameBufferSet (uint32_t ui32Base, uint8_t ui8Buffer, uint32_t *pui32Addr, uint32_t ui32NumBytes)

void	LCDIntEnable (uint32_t ui32Base, uint32_t ui32IntFlags)

void	LCDIntDisable (uint32_t ui32Base, uint32_t ui32IntFlags)

uint32_t	LCDIntStatus (uint32_t ui32Base, bool bMasked)

void	LCDIntClear (uint32_t ui32Base, uint32_t ui32IntFlags)

void	LCDIntRegister (uint32_t ui32Base, void(*pfnHandler)(void))

void	LCDIntUnregister (uint32_t ui32Base)

Detailed Description

Macro Definition Documentation

#define CYCLES_FROM_TIME_NS	(	ui32ClockFreq,
		ui32Time_nS
	)

Value:

(((ui32Time_nS) == 0) ? 0 : \

((((((ui32ClockFreq) / 1000000) * ((ui32Time_nS) - 1)) / 1000)) + 1))

This macro can be used to convert from time in nanoseconds to periods of the supplied clock in Hertz as required when setting up the LIDD and raster timing structures. The calculation will round such that the number of cycles returned represents no longer a time than specified in the ui32Time_nS parameter. Values of ui32Time_nS less than or equal to 35791394 (35.79 milliseconds) are supported by the macro. Larger values will cause arithmetic overflow and yield incorrect values. It is further assumed that ui32ClockFreq is a non-zero multiple of 1000000 (1MHz).

Definition at line 100 of file lcd.h.

#define CYCLES_FROM_TIME_US	(	ui32ClockFreq,
		ui32Time_uS
	)

Value:

(((ui32Time_uS) == 0) ? 0 : \

(((ui32ClockFreq) / 1000000) * ((((ui32Time_uS) * 1000) - 1) / 1000)) + 1)

This macro can be used to convert from time in microseconds to periods of the supplied clock in Hertz as required when setting up the LIDD and raster timing structures. The calculation will round such that the number of cycles returned represents no longer a time than specified in the ui32Time_uS parameter. Values of ui32Time_uS less than or equal to 4294967uS (4.29 seconds) are supported by the macro. Larger values will cause arithmetic overflow and yield incorrect values. It is further assumed that ui32ClockFreq is a non-zero multiple of 1000000 (1MHz).

Definition at line 84 of file lcd.h.

#define LCD_CLOCK_CORE 0x00000001

Definition at line 408 of file lcd.h.

Referenced by LCDClockReset().

#define LCD_CLOCK_DMA 0x00000004

Definition at line 406 of file lcd.h.

Referenced by LCDClockReset().

#define LCD_CLOCK_LIDD 0x00000002

Definition at line 407 of file lcd.h.

Referenced by LCDClockReset().

#define LCD_CLOCK_MAIN 0x00000008

Definition at line 405 of file lcd.h.

Referenced by LCDClockReset(), and LCDRasterEnable().

#define LCD_DMA_BURST_1 0x00000010

Definition at line 377 of file lcd.h.

#define LCD_DMA_BURST_16 0x00000040

Definition at line 381 of file lcd.h.

#define LCD_DMA_BURST_2 0x00000010

Definition at line 378 of file lcd.h.

#define LCD_DMA_BURST_4 0x00000020

Definition at line 379 of file lcd.h.

#define LCD_DMA_BURST_8 0x00000030

Definition at line 380 of file lcd.h.

#define LCD_DMA_BYTE_ORDER_0123 0x00000000

Definition at line 382 of file lcd.h.

#define LCD_DMA_BYTE_ORDER_1023 0x00000008

Definition at line 383 of file lcd.h.

#define LCD_DMA_BYTE_ORDER_2301 0x0000000A

Definition at line 385 of file lcd.h.

#define LCD_DMA_BYTE_ORDER_3210 0x00000002

Definition at line 384 of file lcd.h.

#define LCD_DMA_FIFORDY_128_WORDS 0x00000400

Definition at line 371 of file lcd.h.

#define LCD_DMA_FIFORDY_16_WORDS 0x00000100

Definition at line 365 of file lcd.h.

#define LCD_DMA_FIFORDY_256_WORDS 0x00000500

Definition at line 373 of file lcd.h.

#define LCD_DMA_FIFORDY_32_WORDS 0x00000200

Definition at line 367 of file lcd.h.

#define LCD_DMA_FIFORDY_512_WORDS 0x00000600

Definition at line 375 of file lcd.h.

#define LCD_DMA_FIFORDY_64_WORDS 0x00000300

Definition at line 369 of file lcd.h.

#define LCD_DMA_FIFORDY_8_WORDS 0x00000000

Definition at line 364 of file lcd.h.

#define LCD_DMA_PING_PONG 0x00000001

Definition at line 386 of file lcd.h.

#define LCD_INT_AC_BIAS_CNT 0x00000008

Definition at line 353 of file lcd.h.

Referenced by LCDIntClear(), LCDIntDisable(), and LCDIntEnable().

#define LCD_INT_DMA_DONE 0x00000001

Definition at line 349 of file lcd.h.

Referenced by LCDIntClear(), LCDIntDisable(), and LCDIntEnable().

#define LCD_INT_EOF0 0x00000100

Definition at line 356 of file lcd.h.

Referenced by LCDIntClear(), LCDIntDisable(), and LCDIntEnable().

#define LCD_INT_EOF1 0x00000200

Definition at line 357 of file lcd.h.

Referenced by LCDIntClear(), LCDIntDisable(), and LCDIntEnable().

#define LCD_INT_PAL_LOAD 0x00000040

Definition at line 355 of file lcd.h.

Referenced by LCDIntClear(), LCDIntDisable(), and LCDIntEnable().

#define LCD_INT_RASTER_FRAME_DONE 0x00000002

Definition at line 350 of file lcd.h.

Referenced by LCDIntClear(), LCDIntDisable(), and LCDIntEnable().

#define LCD_INT_SYNC_LOST 0x00000004

Definition at line 352 of file lcd.h.

Referenced by LCDIntClear(), LCDIntDisable(), and LCDIntEnable().

#define LCD_INT_UNDERFLOW 0x00000020

Definition at line 354 of file lcd.h.

Referenced by LCDIntClear(), LCDIntDisable(), and LCDIntEnable().

#define LCD_MODE_AUTO_UFLOW_RESTART ((uint8_t)0x02)

Definition at line 282 of file lcd.h.

Referenced by LCDModeSet().

#define LCD_MODE_LIDD ((uint8_t)0x00)

Definition at line 280 of file lcd.h.

Referenced by LCDModeSet().

#define LCD_MODE_RASTER ((uint8_t)0x01)

Definition at line 281 of file lcd.h.

Referenced by LCDModeSet().

#define LCD_PALETTE_SRC_24BIT 0x80000000

Definition at line 398 of file lcd.h.

Referenced by LCDRasterPaletteSet().

#define LCD_PALETTE_TYPE_1BPP 0x00000000

Definition at line 393 of file lcd.h.

Referenced by LCDRasterPaletteSet().

#define LCD_PALETTE_TYPE_2BPP 0x00001000

Definition at line 394 of file lcd.h.

Referenced by LCDRasterPaletteSet().

#define LCD_PALETTE_TYPE_4BPP 0x00002000

Definition at line 395 of file lcd.h.

Referenced by LCDRasterPaletteSet().

#define LCD_PALETTE_TYPE_8BPP 0x00003000

Definition at line 396 of file lcd.h.

Referenced by LCDRasterPaletteSet().

#define LCD_PALETTE_TYPE_DIRECT 0x00004000

Definition at line 397 of file lcd.h.

Referenced by LCDRasterPaletteSet().

#define LCD_SUBPANEL_AT_BOTTOM 0x00000000

Definition at line 416 of file lcd.h.

Referenced by LCDRasterSubPanelConfigSet().

#define LCD_SUBPANEL_AT_TOP 0x20000000

Definition at line 415 of file lcd.h.

Referenced by LCDRasterSubPanelConfigSet().

#define LIDD_CONFIG_ASYNC_HITACHI 0x00000004

Definition at line 294 of file lcd.h.

Referenced by LCDIDDConfigSet().

#define LIDD_CONFIG_ASYNC_MPU68 0x00000001

Definition at line 291 of file lcd.h.

Referenced by LCDIDDConfigSet().

#define LIDD_CONFIG_ASYNC_MPU80 0x00000003

Definition at line 293 of file lcd.h.

Referenced by LCDIDDConfigSet().

#define LIDD_CONFIG_INVERT_ALE 0x00000008

Definition at line 296 of file lcd.h.

Referenced by LCDIDDConfigSet().

#define LIDD_CONFIG_INVERT_CS0 0x00000040

Definition at line 301 of file lcd.h.

Referenced by LCDIDDConfigSet().

#define LIDD_CONFIG_INVERT_CS1 0x00000080

Definition at line 302 of file lcd.h.

Referenced by LCDIDDConfigSet().

#define LIDD_CONFIG_INVERT_RS_EN 0x00000010

Definition at line 297 of file lcd.h.

Referenced by LCDIDDConfigSet().

#define LIDD_CONFIG_INVERT_WS_DIR 0x00000020

Definition at line 299 of file lcd.h.

Referenced by LCDIDDConfigSet().

#define LIDD_CONFIG_SYNC_MPU68 0x00000000

Definition at line 290 of file lcd.h.

Referenced by LCDIDDConfigSet().

#define LIDD_CONFIG_SYNC_MPU80 0x00000002

Definition at line 292 of file lcd.h.

Referenced by LCDIDDConfigSet().

#define PAL_FROM_RGB ( ui32RGBColor )

Value:

(((ui32RGBColor & 0xF0) >> 4) |            \
                                    ((ui32RGBColor & 0xF000) >> 8) |          \
                                    ((ui32RGBColor & 0xF00000) >> 12))

This macro can be used to convert a 24-bit RGB color value as used by the TivaWare Graphics Library into a 12-bit LCD controller color palette entry.

Definition at line 68 of file lcd.h.

Referenced by LCDRasterPaletteSet().

#define RASTER_ACTVID_DURING_BLANK 0x08000000

Definition at line 332 of file lcd.h.

Referenced by LCDRasterConfigSet().

#define RASTER_FMT_ACTIVE_24BPP_PACKED 0x02000080

Definition at line 314 of file lcd.h.

Referenced by LCDRasterConfigSet().

#define RASTER_FMT_ACTIVE_24BPP_UNPACKED 0x06000080

Definition at line 316 of file lcd.h.

Referenced by LCDRasterConfigSet().

#define RASTER_FMT_ACTIVE_PALETTIZED_12BIT 0x00000080

Definition at line 318 of file lcd.h.

Referenced by LCDRasterConfigSet().

#define RASTER_FMT_ACTIVE_PALETTIZED_16BIT 0x00800080

Definition at line 320 of file lcd.h.

Referenced by LCDRasterConfigSet().

#define RASTER_FMT_PASSIVE_COLOR_12BIT 0x00000000

Definition at line 328 of file lcd.h.

Referenced by LCDRasterConfigSet().

#define RASTER_FMT_PASSIVE_COLOR_16BIT 0x01000000

Definition at line 330 of file lcd.h.

Referenced by LCDRasterConfigSet().

#define RASTER_FMT_PASSIVE_MONO_4PIX 0x00000002

Definition at line 322 of file lcd.h.

Referenced by LCDRasterConfigSet().

#define RASTER_FMT_PASSIVE_MONO_8PIX 0x00000202

Definition at line 324 of file lcd.h.

Referenced by LCDRasterConfigSet().

#define RASTER_FMT_PASSIVE_PALETTIZED 0x00000000

Definition at line 326 of file lcd.h.

Referenced by LCDRasterConfigSet().

#define RASTER_LOAD_DATA_ONLY 0x00200000

Definition at line 336 of file lcd.h.

Referenced by LCDRasterConfigSet().

#define RASTER_LOAD_PALETTE_ONLY 0x00100000

Definition at line 337 of file lcd.h.

Referenced by LCDRasterConfigSet().

#define RASTER_NIBBLE_MODE_ENABLED 0x00400000

Definition at line 334 of file lcd.h.

Referenced by LCDRasterConfigSet().

#define RASTER_READ_ORDER_REVERSED 0x00000100

Definition at line 339 of file lcd.h.

Referenced by LCDRasterConfigSet().

#define RASTER_TIMING_ACTIVE_HIGH_HSYNC 0x00000000

Definition at line 186 of file lcd.h.

#define RASTER_TIMING_ACTIVE_HIGH_OE 0x00000000

Definition at line 178 of file lcd.h.

#define RASTER_TIMING_ACTIVE_HIGH_PIXCLK 0x00000000

Definition at line 182 of file lcd.h.

#define RASTER_TIMING_ACTIVE_HIGH_VSYNC 0x00000000

Definition at line 190 of file lcd.h.

#define RASTER_TIMING_ACTIVE_LOW_HSYNC 0x00200000

Definition at line 188 of file lcd.h.

Referenced by LCDRasterTimingSet().

#define RASTER_TIMING_ACTIVE_LOW_OE 0x00800000

Definition at line 180 of file lcd.h.

Referenced by LCDRasterTimingSet().

#define RASTER_TIMING_ACTIVE_LOW_PIXCLK 0x00400000

Definition at line 184 of file lcd.h.

Referenced by LCDRasterTimingSet().

#define RASTER_TIMING_ACTIVE_LOW_VSYNC 0x00100000

Definition at line 192 of file lcd.h.

Referenced by LCDRasterTimingSet().

#define RASTER_TIMING_SYNCS_ON_FALLING_PIXCLK 0x03000000

Definition at line 176 of file lcd.h.

Referenced by LCDRasterTimingSet().

#define RASTER_TIMING_SYNCS_ON_RISING_PIXCLK 0x02000000

Definition at line 174 of file lcd.h.

Referenced by LCDRasterTimingSet().

#define RASTER_TIMING_SYNCS_OPPOSITE_PIXCLK 0x00000000

Definition at line 172 of file lcd.h.

Referenced by LCDRasterTimingSet().

Function Documentation

void LCDClockReset	(	uint32_t	ui32Base,
		uint32_t	ui32Clocks
	)

Resets one or more of the LCD controller clock domains.

Parameters

ui32Base	specifies the LCD controller module base address.
ui32Clocks	defines the subset of clock domains to be reset.

This function allows sub-modules of the LCD controller to be reset under software control. The ui32Clocks parameter is the logical OR of the following clocks:

LCD_CLOCK_MAIN causes the entire LCD controller module to be reset.
LCD_CLOCK_DMA causes the DMA controller submodule to be reset.
LCD_CLOCK_LIDD causes the LIDD submodule to be reset.
LCD_CLOCK_CORE causes the core module, including the raster logic to be reset.

In all cases, LCD controller register values are preserved across these resets.

Returns: None.

Definition at line 181 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_CLOCK_CORE, LCD_CLOCK_DMA, LCD_CLOCK_LIDD, LCD_CLOCK_MAIN, and SysCtlDelay().

Referenced by LCDRasterEnable().

 {
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT(!(ui32Clocks & ~(LCD_CLOCK_MAIN | LCD_CLOCK_LIDD | LCD_CLOCK_DMA |
                             LCD_CLOCK_CORE)));
 
     //
     // Reset the required LCD controller sub-module(s).
     //
     HWREG(LCD0_BASE + 0x70) = ui32Clocks;
 
     //
     // Wait a while.
     //
     SysCtlDelay(10);
 
     //
     // Remove software reset.
     //
     HWREG(LCD0_BASE + 0x70) = 0x00000000;
 
     //
     // Wait a while.
     //
     SysCtlDelay(10);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void LCDDMAConfigSet	(	uint32_t	ui32Base,
		uint32_t	ui32Config
	)

Configures the LCD controller's internal DMA engine.

Parameters

ui32Base	is the base address of the controller.
ui32Config	provides flags defining the desired DMA parameters.

This function is used to configure the DMA engine within the LCD controller. This engine is responsible for performing bulk data transfers to the display when in LIDD mode or for transferring palette and pixel data from SRAM to the display panel when in raster mode.

The ui32Config parameter is a logical OR of various flags. It must contain one value from each of the following groups.

The first group of flags set the number of words that have to be in the FIFO before it signals that it is ready:

LCD_DMA_FIFORDY_8_WORDS
LCD_DMA_FIFORDY_16_WORDS
LCD_DMA_FIFORDY_32_WORDS
LCD_DMA_FIFORDY_64_WORDS
LCD_DMA_FIFORDY_128_WORDS
LCD_DMA_FIFORDY_256_WORDS
LCD_DMA_FIFORDY_512_WORDS

The second group of flags set the number of 32-bit words in each DMA burst transfer:

LCD_DMA_BURST_1
LCD_DMA_BURST_2
LCD_DMA_BURST_4
LCD_DMA_BURST_8
LCD_DMA_BURST_16

The final group of flags set internal byte lane controls and allow byte swapping within the DMA engine. The label represents the output byte order for an input 32-bit word ordered ``0123''.

LCD_DMA_BYTE_ORDER_0123
LCD_DMA_BYTE_ORDER_1023
LCD_DMA_BYTE_ORDER_3210
LCD_DMA_BYTE_ORDER_2301

Additionally, LCD_DMA_PING_PONG may be specified. This flag configures the controller to operate in double-buffered mode. When data is scanned out from the first frame buffer, the DMA engine immediately moves to the second frame buffer and scans from there before moving back to the first. If this flag is clear, the DMA engine uses a single frame buffer, restarting the scan from the beginning of the buffer each time it completes a frame.

Note: DMA burst size LCD_DMA_BURST_16 should be set when using frame buffers in external, EPI-connected memory. Using a smaller burst size in this case is likely to result in occasional FIFO underflows and associated display glitches.

Returns: None.

Definition at line 1293 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_DMACTL_BIGDEND, LCD_DMACTL_BURSTSZ_M, LCD_DMACTL_BYTESWAP, LCD_DMACTL_FIFORDY_M, LCD_DMACTL_FMODE, and LCD_O_DMACTL.

 {
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT(!(ui32Config & ~(LCD_DMACTL_FIFORDY_M | LCD_DMACTL_BURSTSZ_M |
                             LCD_DMACTL_BYTESWAP | LCD_DMACTL_BIGDEND |
                             LCD_DMACTL_FMODE)));
 
     //
     // Write the DMA control register.
     //
     HWREG(ui32Base + LCD_O_DMACTL) = ui32Config;
 }

void LCDIDDCommandWrite	(	uint32_t	ui32Base,
		uint32_t	ui32CS,
		uint16_t	ui16Cmd
	)

Writes a command to the display when the LCD controller is in LIDD mode.

Parameters

ui32Base	specifies the LCD controller module base address.
ui32CS	specifies the chip select to use. Valid values are 0 and 1.
ui16Cmd	is the 16-bit command word to write.

This function writes a 16-bit command word to the display when the LCD controller is in LIDD mode. A command write occurs with the ALE signal active.

This function must not be called if the LIDD interface is currently configured to expect DMA transactions. If DMA was previously used to write to the panel, LCDIDDDMADisable() must be called before this function can be used.

Note: CS1 is not available when operating in Sync MPU68 or Sync MPU80 modes.

Returns: None.

Definition at line 401 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_O_LIDDCS0ADDR, and LCD_O_LIDDCS1ADDR.

 {
     uint32_t ui32Reg;
 
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT((ui32CS == 0) || (ui32CS == 1));
 
     //
     // Determine the register to write based on the CS value supplied.
     //
     ui32Reg = ui32CS ? LCD_O_LIDDCS1ADDR : LCD_O_LIDDCS0ADDR;
 
     //
     // Write the command/address to the register.
     //
     HWREG(ui32Base + ui32Reg) = ui16Cmd;
 }

void LCDIDDConfigSet	(	uint32_t	ui32Base,
		uint32_t	ui32Config
	)

Sets the LCD controller communication parameters when in LIDD mode.

Parameters

ui32Base	specifies the LCD controller module base address.
ui32Config	defines the display interface configuration.

This function is used when the LCD controller is configured in LIDD mode and specifies the configuration of the interface between the controller and the display panel. The ui32Config parameter is comprised of one of the following modes:

LIDD_CONFIG_SYNC_MPU68 selects Sync MPU68 mode. LCDCP = EN, LCDLP = DIR, LCDFP = ALE, LCDAC = CS0, LCDMCLK = MCLK.
LIDD_CONFIG_ASYNC_MPU68 selects Async MPU68 mode. LCDCP = EN, LCDLP = DIR, LCDFP = ALE, LCDAC = CS0, LCDMCLK = CS1.
LIDD_CONFIG_SYNC_MPU80 selects Sync MPU80 mode. LCDCP = RS, LCDLP = WS, LCDFP = ALE, LCDAC = CS0, LCDMCLK = MCLK.
LIDD_CONFIG_ASYNC_MPU80 selects Async MPU80 mode. LCDCP = RS, LCDLP = WS, LCDFP = ALE, LCDAC = CS0, LCDMCLK = CS1.
LIDD_CONFIG_ASYNC_HITACHI selects Hitachi (async) mode. LCDCP = N/C, LCDLP = DIR, LCDFP = ALE, LCDAC = E0, LCDMCLK = E1.

Additional flags may be ORed into ui32Config to control the polarities of various control signals:

LIDD_CONFIG_INVERT_ALE - Address Latch Enable (ALE) polarity control. By default, ALE is active low. If this flag is set, it becomes active high.
LIDD_CONFIG_INVERT_RS_EN - Read Strobe/Enable polarity control. By default, RS is active low and Enable is active high. If this flag is set, RS becomes active high and Enable active low.
LIDD_CONFIG_INVERT_WS_DIR - Write Strobe/Direction polarity control. By default, WS is active low and Direction write low/read high. If this flag is set, WS becomes active high and Direction becomes write high/read low.
LIDD_CONFIG_INVERT_CS0 - Chip Select 0/Enable 0 polarity control. By default, CS0 and E0 are active high. If this flag is set, they become active low.
LIDD_CONFIG_INVERT_CS1 - Chip Select 1/Enable 1 polarity control. By default, CS1 and E1 are active high. If this flag is set, they become active low.

Returns: None.

Definition at line 258 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_O_LIDDCTL, LIDD_CONFIG_ASYNC_HITACHI, LIDD_CONFIG_ASYNC_MPU68, LIDD_CONFIG_ASYNC_MPU80, LIDD_CONFIG_INVERT_ALE, LIDD_CONFIG_INVERT_CS0, LIDD_CONFIG_INVERT_CS1, LIDD_CONFIG_INVERT_RS_EN, LIDD_CONFIG_INVERT_WS_DIR, LIDD_CONFIG_SYNC_MPU68, and LIDD_CONFIG_SYNC_MPU80.

 {
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT(!(ui32Config & ~(LIDD_CONFIG_SYNC_MPU68 | LIDD_CONFIG_ASYNC_MPU68 |
                             LIDD_CONFIG_SYNC_MPU80 | LIDD_CONFIG_ASYNC_MPU80 |
                             LIDD_CONFIG_ASYNC_HITACHI |
                             LIDD_CONFIG_INVERT_ALE |
                             LIDD_CONFIG_INVERT_RS_EN |
                             LIDD_CONFIG_INVERT_WS_DIR |
                             LIDD_CONFIG_INVERT_CS0 | LIDD_CONFIG_INVERT_CS1)));
 
     //
     // Write the LIDD Control Register.
     //
     HWREG(ui32Base + LCD_O_LIDDCTL) = ui32Config;
 }

uint16_t LCDIDDDataRead	(	uint32_t	ui32Base,
		uint32_t	ui32CS
	)

Reads a data word from the display when the LCD controller is in LIDD mode.

Parameters

ui32Base	specifies the LCD controller module base address.
ui32CS	specifies the chip select to use. Valid values are 0 and 1.

This function reads the 16-bit data word from the display when the LCD controller is in LIDD mode. A data read occurs with the ALE signal inactive.

This function must not be called if the LIDD interface is currently configured to expect DMA transactions. If DMA was previously used to write to the panel, LCDIDDDMADisable() must be called before this function can be used.

Note: CS1 is not available when operating in Sync MPU68 or Sync MPU80 modes.

Returns: Returns the status word read from the display panel.

Definition at line 603 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_O_LIDDCS0DATA, and LCD_O_LIDDCS1DATA.

 {
     uint32_t ui32Reg;
 
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT((ui32CS == 0) || (ui32CS == 1));
 
     //
     // Determine the register to read based on the CS value supplied.
     //
     ui32Reg = ui32CS ? LCD_O_LIDDCS1DATA : LCD_O_LIDDCS0DATA;
 
     //
     // Read the relevant data register.
     //
     return((uint16_t)HWREG(ui32Base + ui32Reg));
 }

void LCDIDDDataWrite	(	uint32_t	ui32Base,
		uint32_t	ui32CS,
		uint16_t	ui16Data
	)

Writes a data value to the display when the LCD controller is in LIDD mode.

Parameters

ui32Base	specifies the LCD controller module base address.
ui32CS	specifies the chip select to use. Valid values are 0 and 1.
ui16Data	is the 16-bit data word to write.

This function writes a 16-bit data word to the display when the LCD controller is in LIDD mode. A data write occurs with the ALE signal inactive.

This function must not be called if the LIDD interface is currently configured to expect DMA transactions. If DMA was previously used to write to the panel, LCDIDDDMADisable() must be called before this function can be used.

Note: CS1 is not available when operating in Sync MPU68 or Sync MPU80 modes.

Returns: None.

Definition at line 446 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_O_LIDDCS0DATA, and LCD_O_LIDDCS1DATA.

 {
     uint32_t ui32Reg;
 
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT((ui32CS == 0) || (ui32CS == 1));
 
     //
     // Determine the register to write based on the CS value supplied.
     //
     ui32Reg = ui32CS ? LCD_O_LIDDCS1DATA : LCD_O_LIDDCS0DATA;
 
     //
     // Write the data value to the register.
     //
     HWREG(ui32Base + ui32Reg) = ui16Data;
 }

void LCDIDDDMADisable ( uint32_t ui32Base )

Disables internal DMA operation when the LCD controller is in LIDD mode.

Parameters

ui32Base specifies the LCD controller module base address.

When the LCD controller is operating in LCD Interface Display Driver mode, this function must be called after completion of a DMA transaction and before calling LCDIDDCommandWrite(), LCDIDDDataWrite(), LCDIDDStatusRead(), LCDIDDIndexedWrite(), LCDIDDIndexedRead() or LCDIDDDataRead() to disable DMA mode and allow CPU-initiated transactions to the display.

Note: LIDD DMA mode is enabled automatically when LCDIDDDMAWrite() is called.

Returns: None.

Definition at line 364 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_LIDDCTL_DMAEN, and LCD_O_LIDDCTL.

 {
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
 
     //
     // Disable DMA.
     //
     HWREG(ui32Base + LCD_O_LIDDCTL) &= ~LCD_LIDDCTL_DMAEN;
 }

void LCDIDDDMAWrite	(	uint32_t	ui32Base,
		uint32_t	ui32CS,
		const uint32_t *	pui32Data,
		uint32_t	ui32Count
	)

Writes a block of data to the display using DMA when the LCD controller is in LIDD mode.

Parameters

ui32Base	specifies the LCD controller module base address.
ui32CS	specifies the chip select to use. Valid values are 0 and 1.
pui32Data	is the address of the first 16-bit word to write. This address must be aligned on a 32-bit word boundary.
ui32Count	is the number of 16-bit words to write. This value must be a multiple of 2.

This function writes a block of 16-bit data words to the display using DMA. It is only valid when the LCD controller is in LIDD mode. Completion of the DMA transfer is signaled by the LCD_INT_DMA_DONE interrupt.

This function enables DMA mode prior to starting the transfer. The caller is responsible for ensuring that any earlier DMA transfer has completed before initiating another transfer.

During the time that DMA is enabled, none of the other LCD LIDD data transfer functions may be called. When the DMA transfer is complete and the application wishes to use the CPU to communicate with the display, LCDIDDDMADisable() must be called to disable DMA access prior to calling LCDIDDCommandWrite(), LCDIDDDataWrite(), LCDIDDStatusRead(), LCDIDDIndexedWrite(), LCDIDDIndexedRead() or LCDIDDDataRead().

Note: CS1 is not available when operating in Sync MPU68 or Sync MPU80 modes.

Returns: None.

Definition at line 721 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_LIDDCTL_DMACS, LCD_LIDDCTL_DMAEN, LCD_O_DMABAFB0, LCD_O_DMACAFB0, and LCD_O_LIDDCTL.

 {
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT((ui32CS == 0) || (ui32CS == 1));
     ASSERT(!((uint32_t)pui32Data & 3));
     ASSERT(!(ui32Count & 1));
 
     //
     // Make sure DMA is disabled so that enabling it triggers this new
     // transfer.
     //
     HWREG(ui32Base + LCD_O_LIDDCTL) &= ~LCD_LIDDCTL_DMAEN;
 
     //
     // Set up the transfer.  Note that the ceiling register must contain the
     // address of the last word which contains data we want transfered and NOT
     // the first location after the data we want written.
     //
     HWREG(ui32Base + LCD_O_DMABAFB0) = (uint32_t)pui32Data;
     HWREG(ui32Base + LCD_O_DMACAFB0) = ((uint32_t)pui32Data +
                                         (ui32Count * 2) - 4);
 
     //
     // Tell the controller which CS to use for the DMA transaction.
     //
     if(!ui32CS)
     {
         //
         // Use CS0.
         //
         HWREG(ui32Base + LCD_O_LIDDCTL) &= ~LCD_LIDDCTL_DMACS;
     }
     else
     {
         //
         // Use CS1.
         //
         HWREG(ui32Base + LCD_O_LIDDCTL) |= LCD_LIDDCTL_DMACS;
     }
 
     //
     // Enable the DMA engine and start the transaction.
     //
     HWREG(ui32Base + LCD_O_LIDDCTL) |= LCD_LIDDCTL_DMAEN;
 }

uint16_t LCDIDDIndexedRead	(	uint32_t	ui32Base,
		uint32_t	ui32CS,
		uint16_t	ui16Addr
	)

Reads a given display register when the LCD controller is in LIDD mode.

Parameters

ui32Base	specifies the LCD controller module base address.
ui32CS	specifies the chip select to use. Valid values are 0 and 1.
ui16Addr	is the address of the display register to read.

This function reads a 16-bit word from a register in the display when the LCD controller is in LIDD mode and configured to use either the Motorola (LIDD_CONFIG_SYNC_MPU68 or LIDD_CONFIG_ASYNC_MPU68) or Intel (LIDD_CONFIG_SYNC_MPU80 or LIDD_CONFIG_ASYNC_MPU80) modes that employ an external address latch.

When configured in Hitachi mode (LIDD_CONFIG_ASYNC_HITACHI), this function should not be used. In this case, the functions LCDIDDStatusRead() and LCDIDDDataRead() may be used to read status and data bytes from the panel.

This function must not be called if the LIDD interface is currently configured to expect DMA transactions. If DMA was previously used to write to the panel, LCDIDDDMADisable() must be called before this function can be used.

Note: CS1 is not available when operating in Sync MPU68 or Sync MPU80 modes.

Returns: None.

Definition at line 655 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_O_LIDDCS0ADDR, LCD_O_LIDDCS0DATA, LCD_O_LIDDCS1ADDR, and LCD_O_LIDDCS1DATA.

 {
     uint32_t ui32Addr;
 
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT((ui32CS == 0) || (ui32CS == 1));
 
     //
     // Determine the address register to write.
     //
     ui32Addr = ui32CS ? LCD_O_LIDDCS1ADDR : LCD_O_LIDDCS0ADDR;
 
     //
     // Write the address.
     //
     HWREG(ui32Base + ui32Addr) = ui16Addr;
 
     //
     // Determine the data register to read.
     //
     ui32Addr = ui32CS ? LCD_O_LIDDCS1DATA : LCD_O_LIDDCS0DATA;
 
     //
     // Return the data read.
     //
     return((uint16_t)HWREG(ui32Base + ui32Addr));
 }

void LCDIDDIndexedWrite	(	uint32_t	ui32Base,
		uint32_t	ui32CS,
		uint16_t	ui16Addr,
		uint16_t	ui16Data
	)

Writes data to a given display register when the LCD controller is in LIDD mode.

Parameters

ui32Base	specifies the LCD controller module base address.
ui32CS	specifies the chip select to use. Valid values are 0 and 1.
ui16Addr	is the address of the display register to write.
ui16Data	is the data to write.

This function writes a 16-bit data word to a register in the display when the LCD controller is in LIDD mode and configured to use either the Motorola (LIDD_CONFIG_SYNC_MPU68 or LIDD_CONFIG_ASYNC_MPU68) or Intel (LIDD_CONFIG_SYNC_MPU80 or LIDD_CONFIG_ASYNC_MPU80) modes that employ an external address latch.

When configured in Hitachi mode (LIDD_CONFIG_ASYNC_HITACHI), this function should not be used. In this case the functions LCDIDDCommandWrite() and LCDIDDDataWrite() may be used to transfer command and data bytes to the panel.

This function must not be called if the LIDD interface is currently configured to expect DMA transactions. If DMA was previously used to write to the panel, LCDIDDDMADisable() must be called before this function can be used.

Note: CS1 is not available when operating in Sync MPU68 or Sync MPU80 modes.

Returns: None.

Definition at line 500 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_O_LIDDCS0ADDR, LCD_O_LIDDCS0DATA, LCD_O_LIDDCS1ADDR, and LCD_O_LIDDCS1DATA.

 {
     uint32_t ui32Addr;
 
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT((ui32CS == 0) || (ui32CS == 1));
 
     //
     // Determine the address register to write.
     //
     ui32Addr = ui32CS ? LCD_O_LIDDCS1ADDR : LCD_O_LIDDCS0ADDR;
 
     //
     // Write the address.
     //
     HWREG(ui32Base + ui32Addr) = ui16Addr;
 
     //
     // Determine the data register to write.
     //
     ui32Addr = ui32CS ? LCD_O_LIDDCS1DATA : LCD_O_LIDDCS0DATA;
 
     //
     // Write the data.
     //
     HWREG(ui32Base + ui32Addr) = ui16Data;
 }

uint16_t LCDIDDStatusRead	(	uint32_t	ui32Base,
		uint32_t	ui32CS
	)

Reads a status word from the display when the LCD controller is in LIDD mode.

Parameters

ui32Base	specifies the LCD controller module base address.
ui32CS	specifies the chip select to use. Valid values are 0 and 1.

This function reads the 16-bit status word from the display when the LCD controller is in LIDD mode. A status read occurs with the ALE signal active. If the interface is configured in Hitachi mode (LIDD_CONFIG_ASYNC_HITACHI), this operation corresponds to a command mode read.

This function must not be called if the LIDD interface is currently configured to expect DMA transactions. If DMA was previously used to write to the panel, LCDIDDDMADisable() must be called before this function can be used.

Note: CS1 is not available when operating in Sync MPU68 or Sync MPU80 modes.

Returns: Returns the status word read from the display panel.

Definition at line 558 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_O_LIDDCS0ADDR, and LCD_O_LIDDCS1ADDR.

 {
     uint32_t ui32Reg;
 
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT((ui32CS == 0) || (ui32CS == 1));
 
     //
     // Determine the register to read based on the CS value supplied.
     //
     ui32Reg = ui32CS ? LCD_O_LIDDCS1ADDR : LCD_O_LIDDCS0ADDR;
 
     //
     // Read the relevant status register.
     //
     return((uint16_t)HWREG(ui32Base + ui32Reg));
 }

void LCDIDDTimingSet	(	uint32_t	ui32Base,
		uint32_t	ui32CS,
		const tLCDIDDTiming *	pTiming
	)

Sets the LCD controller interface timing when in LIDD mode.

Parameters

ui32Base	specifies the LCD controller module base address.
ui32CS	specifies the chip select whose timings are to be set.
pTiming	points to a structure containing the desired timing parameters.

This function is used in LIDD mode to set the setup, strobe and hold times for the various interface control signals. Independent timings are stored for each of the two supported chip selects offered by the LCD controller.

For a definition of the timing parameters required, see the definition of tLCDIDDTiming.

Note: CS1 is not available when operating in Sync MPU68 or Sync MPU80 modes.

Returns: None

Definition at line 301 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_LIDDCS0CFG_GAP_S, LCD_LIDDCS0CFG_RDDUR_S, LCD_LIDDCS0CFG_RDHOLD_S, LCD_LIDDCS0CFG_RDSU_S, LCD_LIDDCS0CFG_WRDUR_S, LCD_LIDDCS0CFG_WRHOLD_S, LCD_LIDDCS0CFG_WRSU_S, LCD_O_LIDDCS0CFG, LCD_O_LIDDCS1CFG, tLCDIDDTiming::ui8DelayCycles, tLCDIDDTiming::ui8RSDuration, tLCDIDDTiming::ui8RSHold, tLCDIDDTiming::ui8RSSetup, tLCDIDDTiming::ui8WSDuration, tLCDIDDTiming::ui8WSHold, and tLCDIDDTiming::ui8WSSetup.

 {
     uint32_t ui32Val;
 
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT((ui32CS == 0) || (ui32CS == 1));
     ASSERT(pTiming);
     ASSERT(pTiming->ui8WSSetup < 32);
     ASSERT(pTiming->ui8WSDuration && (pTiming->ui8WSDuration < 64));
     ASSERT(pTiming->ui8WSHold && (pTiming->ui8WSHold < 16));
     ASSERT(pTiming->ui8RSSetup < 32);
     ASSERT(pTiming->ui8RSDuration && (pTiming->ui8RSDuration < 64));
     ASSERT(pTiming->ui8RSHold && (pTiming->ui8RSHold < 16));
     ASSERT(pTiming->ui8DelayCycles && (pTiming->ui8DelayCycles < 5));
 
     //
     // Convert the timings provided into a value ready for the register.
     //
     ui32Val =
         (((uint32_t)(pTiming->ui8WSSetup) << LCD_LIDDCS0CFG_WRSU_S) |
          ((uint32_t)(pTiming->ui8WSDuration) << LCD_LIDDCS0CFG_WRDUR_S) |
          ((uint32_t)(pTiming->ui8WSHold) << LCD_LIDDCS0CFG_WRHOLD_S) |
          ((uint32_t)(pTiming->ui8RSSetup) << LCD_LIDDCS0CFG_RDSU_S) |
          ((uint32_t)(pTiming->ui8RSDuration) << LCD_LIDDCS0CFG_RDDUR_S) |
          ((uint32_t)(pTiming->ui8RSHold) << LCD_LIDDCS0CFG_RDHOLD_S) |
          ((uint32_t)(pTiming->ui8DelayCycles - 1) << LCD_LIDDCS0CFG_GAP_S));
 
     //
     // Write the appropriate LCD LIDD CS configuration register.
     //
     if(!ui32CS)
     {
         HWREG(ui32Base + LCD_O_LIDDCS0CFG) = ui32Val;
     }
     else
     {
         HWREG(ui32Base + LCD_O_LIDDCS1CFG) = ui32Val;
     }
 }

void LCDIntClear	(	uint32_t	ui32Base,
		uint32_t	ui32IntFlags
	)

Clears LCD controller interrupt sources.

Parameters

ui32Base	is the base address of the controller.
ui32IntFlags	is a bit mask of the interrupt sources to be cleared.

The specified LCD controller interrupt sources are cleared so that they no longer assert. This function must be called in the interrupt handler to keep the interrupt from being triggered again immediately upon exit.

The ui32IntFlags parameter is the logical OR of any of the following:

LCD_INT_DMA_DONE - indicates that a LIDD DMA transfer is complete.
LCD_INT_RASTER_FRAME_DONE - indicates that a raster-mode frame is complete.
LCD_INT_SYNC_LOST - indicates that frame synchronization was lost.
LCD_INT_AC_BIAS_CNT - indicates that that AC bias transition counter has decremented to zero and is is valid for passive matrix panels only. The counter, set by a call to LCDRasterACBiasIntCountSet(), is reloaded but remains disabled until this interrupt is cleared.
LCD_INT_UNDERFLOW - indicates that a data underflow occurred. The internal FIFO was empty when the output logic attempted to read data to send to the display.
LCD_INT_PAL_LOAD - indicates that the color palette has been loaded.
LCD_INT_EOF0 - indicates that the raw End-of-Frame 0 has been signaled.
LCD_INT_EOF2 - indicates that the raw End-of-Frame 1 has been signaled.

Note: Because there is a write buffer in the Cortex-M processor, it may take several clock cycles before the interrupt source is actually cleared. Therefore, it is recommended that the interrupt source be cleared early in the interrupt handler (as opposed to the very last action) to avoid returning from the interrupt handler before the interrupt source is actually cleared. Failure to do so may result in the interrupt handler being immediately reentered (because the interrupt controller still sees the interrupt source asserted).

Returns: None.

Definition at line 1709 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_INT_AC_BIAS_CNT, LCD_INT_DMA_DONE, LCD_INT_EOF0, LCD_INT_EOF1, LCD_INT_PAL_LOAD, LCD_INT_RASTER_FRAME_DONE, LCD_INT_SYNC_LOST, LCD_INT_UNDERFLOW, and LCD_O_MISCLR.

 {
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT(!(ui32IntFlags & ~(LCD_INT_DMA_DONE | LCD_INT_SYNC_LOST |
                               LCD_INT_AC_BIAS_CNT | LCD_INT_UNDERFLOW |
                               LCD_INT_PAL_LOAD | LCD_INT_EOF0 | LCD_INT_EOF1 |
                               LCD_INT_RASTER_FRAME_DONE)));
 
     //
     // Clear the requested interrupts.
     //
     HWREG(ui32Base + LCD_O_MISCLR) = ui32IntFlags;
 }

void LCDIntDisable	(	uint32_t	ui32Base,
		uint32_t	ui32IntFlags
	)

Disables individual LCD controller interrupt sources.

Parameters

ui32Base	is the base address of the controller.
ui32IntFlags	is the bit mask of the interrupt sources to be disabled.

This function disables the indicated LCD controller interrupt sources. Only the sources that are enabled can be reflected to the processor interrupt; disabled sources have no effect on the processor.

The ui32IntFlags parameter is the logical OR of any of the following:

LCD_INT_DMA_DONE - indicates that a LIDD DMA transfer is complete.
LCD_INT_RASTER_FRAME_DONE - indicates that a raster-mode frame is complete.
LCD_INT_SYNC_LOST - indicates that frame synchronization was lost.
LCD_INT_AC_BIAS_CNT - indicates that that AC bias transition counter has decremented to zero and is is valid for passive matrix panels only. The counter, set by a call to LCDRasterACBiasIntCountSet(), is reloaded but remains disabled until this interrupt is cleared.
LCD_INT_UNDERFLOW - indicates that a data underflow occurred. The internal FIFO was empty when the output logic attempted to read data to send to the display.
LCD_INT_PAL_LOAD - indicates that the color palette has been loaded.
LCD_INT_EOF0 - indicates that the raw End-of-Frame 0 has been signaled.
LCD_INT_EOF2 - indicates that the raw End-of-Frame 1 has been signaled.

Returns: None.

Definition at line 1594 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_INT_AC_BIAS_CNT, LCD_INT_DMA_DONE, LCD_INT_EOF0, LCD_INT_EOF1, LCD_INT_PAL_LOAD, LCD_INT_RASTER_FRAME_DONE, LCD_INT_SYNC_LOST, LCD_INT_UNDERFLOW, and LCD_O_IENC.

 {
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT(!(ui32IntFlags & ~(LCD_INT_DMA_DONE | LCD_INT_SYNC_LOST |
                               LCD_INT_AC_BIAS_CNT | LCD_INT_UNDERFLOW |
                               LCD_INT_PAL_LOAD | LCD_INT_EOF0 | LCD_INT_EOF1 |
                               LCD_INT_RASTER_FRAME_DONE)));
 
     //
     // Disable the interrupt sources by clearing the appropriate bits in the
     // mask register.
     //
     HWREG(ui32Base + LCD_O_IENC) = ui32IntFlags;
 }

void LCDIntEnable	(	uint32_t	ui32Base,
		uint32_t	ui32IntFlags
	)

Enables individual LCD controller interrupt sources.

Parameters

ui32Base	is the base address of the controller.
ui32IntFlags	is the bit mask of the interrupt sources to be enabled.

This function enables the indicated LCD controller interrupt sources. Only the sources that are enabled can be reflected to the processor interrupt; disabled sources have no effect on the processor.

The ui32IntFlags parameter is the logical OR of any of the following:

LCD_INT_DMA_DONE - indicates that a LIDD DMA transfer is complete.
LCD_INT_RASTER_FRAME_DONE - indicates that a raster-mode frame is complete.
LCD_INT_SYNC_LOST - indicates that frame synchronization was lost.
LCD_INT_AC_BIAS_CNT - indicates that that AC bias transition counter has decremented to zero and is is valid for passive matrix panels only. The counter, set by a call to LCDRasterACBiasIntCountSet(), is reloaded but remains disabled until this interrupt is cleared.
LCD_INT_UNDERFLOW - indicates that a data underflow occurred. The internal FIFO was empty when the output logic attempted to read data to send to the display.
LCD_INT_PAL_LOAD - indicates that the color palette has been loaded.
LCD_INT_EOF0 - indicates that the raw End-of-Frame 0 has been signaled.
LCD_INT_EOF2 - indicates that the raw End-of-Frame 1 has been signaled.

Returns: None.

Definition at line 1544 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_INT_AC_BIAS_CNT, LCD_INT_DMA_DONE, LCD_INT_EOF0, LCD_INT_EOF1, LCD_INT_PAL_LOAD, LCD_INT_RASTER_FRAME_DONE, LCD_INT_SYNC_LOST, LCD_INT_UNDERFLOW, and LCD_O_IM.

 {
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT(!(ui32IntFlags & ~(LCD_INT_DMA_DONE | LCD_INT_SYNC_LOST |
                               LCD_INT_AC_BIAS_CNT | LCD_INT_UNDERFLOW |
                               LCD_INT_PAL_LOAD | LCD_INT_EOF0 | LCD_INT_EOF1 |
                               LCD_INT_RASTER_FRAME_DONE)));
 
     //
     // Enable the interrupt sources by setting the appropriate bits in the
     // mask register.
     //
     HWREG(ui32Base + LCD_O_IM) = ui32IntFlags;
 }

void LCDIntRegister	(	uint32_t	ui32Base,
		void(*)(void)	pfnHandler
	)

Registers an interrupt handler for the LCD controller module.

Parameters

ui32Base	specifies the LCD controller module base address.
pfnHandler	is a pointer to the function to be called when the LCD controller interrupt occurs.

This function registers the handler to be called when the LCD controller module interrupt occurs.

Note: This function need not be called if the appropriate interrupt vector is statically linked into the vector table in the application startup code.

See also: IntRegister() for important information about registering interrupt handlers.

Returns: None.

Definition at line 1744 of file lcd.c.

References ASSERT, INT_LCD0_TM4C129, IntEnable(), IntRegister(), and LCD0_BASE.

 {
     //
     // Check the arguments.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT(pfnHandler);
 
     //
     // Register the interrupt handler.
     //
     IntRegister(INT_LCD0_TM4C129, pfnHandler);
 
     //
     // Enable the interrupt in the interrupt controller.
     //
     IntEnable(INT_LCD0_TM4C129);
 }

Here is the call graph for this function:

uint32_t LCDIntStatus	(	uint32_t	ui32Base,
		bool	bMasked
	)

Gets the current LCD controller interrupt status.

Parameters

ui32Base	is the base address of the controller.
bMasked	is false if the raw interrupt status is required and true if the masked interrupt status is required.

This function returns the interrupt status for the LCD controller. Either the raw interrupt status or the status of interrupts that are allowed to reflect to the processor can be returned.

Returns: Returns the current interrupt status as the logical OR of any of the following:

LCD_INT_DMA_DONE - indicates that a LIDD DMA transfer is complete.
LCD_INT_RASTER_FRAME_DONE - indicates that a raster-mode frame is complete.
LCD_INT_SYNC_LOST - indicates that frame synchronization was lost.
LCD_INT_AC_BIAS_CNT - indicates that that AC bias transition counter has decremented to zero and is is valid for passive matrix panels only. The counter, set by a call to LCDRasterACBiasIntCountSet(), is reloaded but remains disabled until this interrupt is cleared.
LCD_INT_UNDERFLOW - indicates that a data underflow occurred. The internal FIFO was empty when the output logic attempted to read data to send to the display.
LCD_INT_PAL_LOAD - indicates that the color palette has been loaded.
LCD_INT_EOF0 - indicates that the raw End-of-Frame 0 has been signaled.
LCD_INT_EOF2 - indicates that the raw End-of-Frame 1 has been signaled.

Definition at line 1643 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_O_MISCLR, and LCD_O_RISSET.

 {
     ASSERT(ui32Base == LCD0_BASE);
 
     //
     // Were we asked for the masked or raw interrupt status?
     //
     if(bMasked)
     {
         //
         // Return the masked interrupt status.
         //
         return(HWREG(ui32Base + LCD_O_MISCLR));
     }
     else
     {
         //
         // Return the raw interrupts status.
         //
         return(HWREG(ui32Base + LCD_O_RISSET));
     }
 }

void LCDIntUnregister ( uint32_t ui32Base )

Unregisters the interrupt handler for the LCD controller module.

Parameters

ui32Base specifies the LCD controller module base address.

This function unregisters the interrupt handler and disables the global LCD controller interrupt in the interrupt controller.

Note: This function need not be called if the appropriate interrupt vector is statically linked into the vector table in the application startup code.

See also: IntRegister() for important information about registering interrupt handlers.

Returns: None.

Definition at line 1782 of file lcd.c.

References ASSERT, INT_LCD0_TM4C129, IntDisable(), IntUnregister(), and LCD0_BASE.

 {
     //
     // Check the arguments.
     //
     ASSERT(ui32Base == LCD0_BASE);
 
     //
     // Disable the interrupt in the interrupt controller.
     //
     IntDisable(INT_LCD0_TM4C129);
 
     //
     // Unregister the interrupt handler.
     //
     IntUnregister(INT_LCD0_TM4C129);
 }

Here is the call graph for this function:

uint32_t LCDModeSet	(	uint32_t	ui32Base,
		uint8_t	ui8Mode,
		uint32_t	ui32PixClk,
		uint32_t	ui32SysClk
	)

Configures the basic operating mode and clock rate for the LCD controller.

Parameters

ui32Base	specifies the LCD controller module base address.
ui8Mode	specifies the basic operating mode to be used.
ui32PixClk	specifies the desired LCD controller pixel or master clock rate in Hz.
ui32SysClk	specifies the current system clock rate in Hz.

This function sets the basic operating mode of the LCD controller and also its master clock. The ui8Mode parameter may be set to either LCD_MODE_LIDD or LCD_MODE_RASTER. LCD_MODE_LIDD is used to select LCD Interface Display Driver mode for character panels connected via an asynchronous interface (CS, WE, OE, ALE, data) and LCD_MODE_RASTER is used to communicate with panels via a synchronous video interface using data and sync signals. Additionally, LCD_MODE_AUTO_UFLOW_RESTART may be ORed with either of these modes to indicate that the hardware should restart automatically if a data underflow occurs.

The ui32PixClk parameter specifies the desired master clock for the the LCD controller. In LIDD mode, this value controls the MCLK used in communication with the display and valid values are between ui32SysClk and ui32SysClk/255. In raster mode, ui32PixClk specifies the pixel clock rate for the raster interface and valid values are between ui32SysClk/2 and ui32SysClk/255. The actual clock rate set may differ slightly from the desired rate due to the fact that only integer dividers are supported. The rate set will, however, be no higher than the requested value.

The ui32SysClk parameter provides the current system clock rate and is used to allow the LCD controller clock rate divisor to be correctly set to give the desired ui32PixClk rate.

Returns: Returns the actual LCD controller pixel clock or MCLK rate set.

Definition at line 110 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_CLKEN_CORE, LCD_CLKEN_DMA, LCD_CLKEN_LIDD, LCD_CTL_CLKDIV_S, LCD_MODE_AUTO_UFLOW_RESTART, LCD_MODE_LIDD, LCD_MODE_RASTER, LCD_O_CLKEN, and LCD_O_CTL.

 {
     uint32_t ui32Div;
 
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT((ui8Mode & ~(LCD_MODE_RASTER | LCD_MODE_LIDD |
                         LCD_MODE_AUTO_UFLOW_RESTART)) == 0);
 
     //
     // Enable clocks to the LCD controller submodules.
     //
     HWREG(ui32Base + LCD_O_CLKEN) = (LCD_CLKEN_DMA | LCD_CLKEN_CORE |
                                      LCD_CLKEN_LIDD);
 
     //
     // Determine the clock divider to use to get as close as possible to the
     // desired pixel clock.  Note that we set the division up so that we
     // round the divisor up and ensure that the clock used is never faster
     // than the requested rate.
     //
     ui32Div = (ui32SysClk + (ui32PixClk - 1)) / ui32PixClk;
 
     //
     // Check that the calculated value is valid.
     //
     ASSERT(ui32Div);
     ASSERT(ui32Div < 256);
     ASSERT(!((ui8Mode & LCD_MODE_RASTER) && (ui32Div < 2)));
 
     //
     // Write the LCDCTL register to set the mode.
     //
     HWREG(ui32Base + LCD_O_CTL) = (uint32_t)ui8Mode |
                                   (ui32Div << LCD_CTL_CLKDIV_S);
 
     //
     // Return the selected clock rate.  Finding ui32Div set to 0 should not
     // happen unless someone passed pathological arguments and builds without
     // the ASSERTS, but we guard against it just in case.
     //
     return(ui32Div ? (ui32SysClk / ui32Div) : ui32SysClk);
 }

void LCDRasterACBiasIntCountSet	(	uint32_t	ui32Base,
		uint8_t	ui8Count
	)

Sets the number of AC bias pin transitions per interrupt.

Parameters

ui32Base	is the base address of the controller.
ui8Count	is the number of AC bias pin transitions to count before the AC bias count interrupt is asserted. Valid values are from 0 to 15.

This function is used to set the number of AC bias transitions between each AC bias count interrupt (LCD_INT_AC_BIAS_CNT). If ui8Count is 0, no AC bias count interrupt is generated.

Returns: None.

Definition at line 974 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_O_RASTRTIM2, LCD_RASTRTIM2_ACBI_M, and LCD_RASTRTIM2_ACBI_S.

 {
     uint32_t ui32Val;
 
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT(ui8Count < 16);
 
     //
     // Get the existing raster timing 2 register value and mask in the new
     // AC Bias interrupt count.
     //
     ui32Val = HWREG(ui32Base + LCD_O_RASTRTIM2);
     ui32Val &= ~LCD_RASTRTIM2_ACBI_M;
     ui32Val |= ((ui8Count << LCD_RASTRTIM2_ACBI_S) & LCD_RASTRTIM2_ACBI_M);
 
     //
     // Write the new value back to the register.
     //
     HWREG(ui32Base + LCD_O_RASTRTIM2) = ui32Val;
 }

void LCDRasterConfigSet	(	uint32_t	ui32Base,
		uint32_t	ui32Config,
		uint8_t	ui8PalLoadDelay
	)

Sets the LCD controller interface timing when in raster mode.

Parameters

ui32Base	specifies the LCD controller module base address.
ui32Config	specifies properties of the raster interface and the attached display panel.
ui8PalLoadDelay	specifies the number of system clocks to wait between each 16 halfword (16-bit) burst when loading the palette from SRAM into the internal palette RAM of the controller.

This function configures the basic operating mode of the raster interface and specifies the type of panel that the controller is to drive.

The ui32Config parameter must be defined as one of the following to select the required target panel type and output pixel format:

RASTER_FMT_ACTIVE_24BPP_PACKED selects an active matrix display and uses a packed 24-bit per pixel packet frame buffer where 4 pixels are described within 3 consecutive 32-bit words.
RASTER_FMT_ACTIVE_24BPP_UNPACKED selects an active matrix display and uses an unpacked 24-bit per pixel packet frame buffer where each 32-bit word contains a single pixel and 8 bits of padding.
RASTER_FMT_ACTIVE_16BPP selects an active matrix display and uses a 16-bit per pixel frame buffer with 2 pixels in each 32-bit word.
RASTER_FMT_ACTIVE_PALETTIZED_12BIT selects an active matrix display and uses a 1, 2, 4 or 8bpp frame buffer with palette lookup. Output color data is described in 12-bit format using bits 11:0 of the data bus. The frame buffer pixel format is defined by the value passed in the ui32Type parameter to LCDRasterPaletteSet().
RASTER_FMT_ACTIVE_PALETTIZED_16BIT selects an active matrix display and uses a 1, 2, 4 or 8bpp frame buffer with palette lookup. Output color data is described in 16-bit 5:6:5 format. The frame buffer pixel format is defined by the value passed in the ui32Type parameter to LCDRasterPaletteSet().
RASTER_FMT_PASSIVE_MONO_4PIX selects a monochrome, passive matrix display that outputs 4 pixels on each pixel clock.
RASTER_FMT_PASSIVE_MONO_8PIX selects a monochrome, passive matrix display that outputs 8 pixels on each pixel clock.
RASTER_FMT_PASSIVE_COLOR_12BIT selects a passive matrix display and uses a 12bpp frame buffer. The palette is bypassed and 12-bit pixel data is sent to the grayscaler for the display.
RASTER_FMT_PASSIVE_COLOR_16BIT selects a passive matrix display and uses a 16bpp frame buffer with pixels in 5:6:5 format. Only the 4 most significant bits of each color component are sent to the grayscaler for the display.

Additionally, the following flags may be ORed into ui32Config:

RASTER_ACTVID_DURING_BLANK sets Actvid to toggle during vertical blanking.
RASTER_NIBBLE_MODE_ENABLED enables nibble mode. This parameter works with RASTER_READ_ORDER_REVERSED to determine how 1, 2 and 4bpp pixels are extracted from words read from the frame buffer. If specified, words read from the frame buffer are byte swapped prior to individual pixels being parsed from them.
RASTER_LOAD_DATA_ONLY tells the controller to read only pixel data from the frame buffer and to use the last palette read. No palette load is performed.
RASTER_LOAD_PALETTE_ONLY tells the controller to read only the palette data from the frame buffer.
RASTER_READ_ORDER_REVERSED when using 1, 2, 4 and 8bpp frame buffers, this option reverses the order in which frame buffer words are parsed. When this option is specified, the leftmost pixel in a word is taken from the most significant bits. When absent, the leftmost pixel is parsed from the least significant bits.

If the LCD controller's raster engine is enabled when this function is called, it is disabled as a result of the call.

Returns: None.

Definition at line 846 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_O_RASTRCTL, LCD_RASTRCTL_REQDLY_S, RASTER_ACTVID_DURING_BLANK, RASTER_FMT_ACTIVE_24BPP_PACKED, RASTER_FMT_ACTIVE_24BPP_UNPACKED, RASTER_FMT_ACTIVE_PALETTIZED_12BIT, RASTER_FMT_ACTIVE_PALETTIZED_16BIT, RASTER_FMT_PASSIVE_COLOR_12BIT, RASTER_FMT_PASSIVE_COLOR_16BIT, RASTER_FMT_PASSIVE_MONO_4PIX, RASTER_FMT_PASSIVE_MONO_8PIX, RASTER_FMT_PASSIVE_PALETTIZED, RASTER_LOAD_DATA_ONLY, RASTER_LOAD_PALETTE_ONLY, RASTER_NIBBLE_MODE_ENABLED, and RASTER_READ_ORDER_REVERSED.

 {
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT(!(ui32Config & ~(RASTER_FMT_ACTIVE_24BPP_PACKED |
                             RASTER_FMT_ACTIVE_24BPP_UNPACKED |
                             RASTER_FMT_ACTIVE_PALETTIZED_12BIT |
                             RASTER_FMT_ACTIVE_PALETTIZED_16BIT |
                             RASTER_FMT_PASSIVE_MONO_4PIX |
                             RASTER_FMT_PASSIVE_MONO_8PIX |
                             RASTER_FMT_PASSIVE_PALETTIZED |
                             RASTER_FMT_PASSIVE_COLOR_12BIT |
                             RASTER_FMT_PASSIVE_COLOR_16BIT |
                             RASTER_ACTVID_DURING_BLANK |
                             RASTER_NIBBLE_MODE_ENABLED |
                             RASTER_LOAD_DATA_ONLY |
                             RASTER_LOAD_PALETTE_ONLY |
                             RASTER_READ_ORDER_REVERSED)));
 
     //
     // Write the raster control register.
     //
     HWREG(ui32Base + LCD_O_RASTRCTL) = (ui32Config |
                                         ((uint32_t)ui8PalLoadDelay <<
                                          LCD_RASTRCTL_REQDLY_S));
 }

void LCDRasterDisable ( uint32_t ui32Base )

Disables the raster output.

Parameters

ui32Base is the base address of the controller.

This function disables the LCD controller raster output and stops driving the attached display.

Note: Once disabled, the raster engine continues to scan data until the end of the current frame. If the display is to be re-enabled, wait until after the final LCD_INT_RASTER_FRAME_DONE has been received, indicating that the raster engine has stopped.

Returns: None.

Definition at line 1079 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_O_RASTRCTL, and LCD_RASTRCTL_LCDEN.

 {
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
 
     //
     // Disable the raster engine.
     //
     HWREG(ui32Base + LCD_O_RASTRCTL) &= ~LCD_RASTRCTL_LCDEN;
 }

void LCDRasterEnable ( uint32_t ui32Base )

Enables the raster output.

Parameters

ui32Base is the base address of the controller.

This function enables the LCD controller raster output and starts displaying the content of the current frame buffer on the attached panel. Prior to enabling the raster output, LCDModeSet(), LCDRasterConfigSet(), LCDDMAConfigSet(), LCDRasterTimingSet(), LCDRasterPaletteSet() and LCDRasterFrameBufferSet() must have been called.

Returns: None.

Definition at line 1014 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_CLOCK_MAIN, LCD_O_RASTRCTL, LCD_RASTRCTL_LCDEN, and LCDClockReset().

 {
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
 
     //
     // Reset the module prior to starting the raster.  This is required to
     // ensure correct operation of the raster engine.
     //
     LCDClockReset(ui32Base, LCD_CLOCK_MAIN);
 
     //
     // Enable the raster engine.
     //
     HWREG(ui32Base + LCD_O_RASTRCTL) |= LCD_RASTRCTL_LCDEN;
 }

Here is the call graph for this function:

bool LCDRasterEnabled ( uint32_t ui32Base )

Determines whether or not the raster output is currently enabled.

Parameters

ui32Base is the base address of the controller.

This function may be used to query whether or not the raster output is currently enabled.

Returns: Returns true if the raster is enabled or false if it is disabled.

Definition at line 1047 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_O_RASTRCTL, and LCD_RASTRCTL_LCDEN.

 {
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
 
     //
     // Return the current raster engine status.
     //
     return((HWREG(ui32Base + LCD_O_RASTRCTL) & LCD_RASTRCTL_LCDEN) ?
            true : false);
 }

void LCDRasterFrameBufferSet	(	uint32_t	ui32Base,
		uint8_t	ui8Buffer,
		uint32_t *	pui32Addr,
		uint32_t	ui32NumBytes
	)

Sets the LCD controller frame buffer start address and size in raster mode.

Parameters

ui32Base	is the base address of the controller.
ui8Buffer	specifies which frame buffer to configure. Valid values are 0 and 1.
pui32Addr	points to the first byte of the frame buffer. This pointer must be aligned on a 32-bit (word) boundary.
ui32NumBytes	specifies the size of the frame buffer in bytes. This value must be a multiple of 4.

This function is used to configure the position and size of one of the two supported frame buffers while in raster mode. The second frame buffer (configured when ui8Buffer is set to 1) is only used if the controller is set to operate in ping-pong mode (by specifying the LCD_DMA_PING_PONG configuration flag on a call to LCDDMAConfigSet()).

The format of the frame buffer depends on the image type in use and the current raster configuration settings. If RASTER_LOAD_DATA_ONLY was specified in a previous call to LCDRasterConfigSet(), the frame buffer contains only packed pixel data in the required bit depth and format. In other cases, the frame buffer comprises a palette of either 8 or 128 32-bit words followed by the packed pixel data. The palette size is 8 words (16 16-bit entries) for all pixel formats other than 8bpp which uses a palette of 128 words (256 16-bit entries). Note that the 8 word palette is still present even for 12, 16 and 24-bit formats, which do not use the lookup table.

The frame buffer size, specified using the ui32NumBytes parameter, must be the palette size (if any) plus the size of the image bitmap required for the currently configured display resolution.

ui32NumBytes = (Palette Size) + ((Width * Height) * BPP) / 8)

If RASTER_LOAD_DATA_ONLY is not specified, frame buffers passed to this function must be initialized using a call to LCDRasterPaletteSet() prior to enabling the raster output. If this is not done, the pixel format identifier and color table required by the hardware is not present and the results are unpredictable.

Returns: None.

Definition at line 1476 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_O_DMABAFB0, LCD_O_DMABAFB1, LCD_O_DMACAFB0, and LCD_O_DMACAFB1.

 {
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT(!((uint32_t)pui32Addr & 3));
     ASSERT(!(ui32NumBytes & 3));
     ASSERT(ui8Buffer < 2);
 
     //
     // Are we setting the values for frame buffer 0?
     //
     if(!ui8Buffer)
     {
         //
         // Yes - set the registers for frame buffer 0.
         //
         HWREG(ui32Base + LCD_O_DMABAFB0) = (uint32_t)pui32Addr;
         HWREG(ui32Base + LCD_O_DMACAFB0) = (uint32_t)pui32Addr +
                                            ui32NumBytes - 4;
     }
     else
     {
         //
         // No - set the registers for frame buffer 1.
         //
         HWREG(ui32Base + LCD_O_DMABAFB1) = (uint32_t)pui32Addr;
         HWREG(ui32Base + LCD_O_DMACAFB1) = (uint32_t)pui32Addr +
                                            ui32NumBytes - 4;
     }
 }

void LCDRasterPaletteSet	(	uint32_t	ui32Base,
		uint32_t	ui32Type,
		uint32_t *	pui32Addr,
		const uint32_t *	pui32SrcColors,
		uint32_t	ui32Start,
		uint32_t	ui32Count
	)

Initializes the color palette in a frame buffer.

Parameters

ui32Base	is the base address of the controller.
ui32Type	specifies the type of pixel data to be held in the frame buffer and also the format of the source color values passed.
pui32Addr	points to the start of the frame buffer into which the palette information is to be written.
pui32SrcColors	points to the first color value that is to be written into the frame buffer palette.
ui32Start	specifies the index of the first color in the palette to update.
ui32Count	specifies the number of source colors to be copied into the frame buffer palette.

This function is used to initialize the color palette stored at the beginning of a frame buffer. It writes the relevant pixel type into the first entry of the frame buffer and copies the requested number of colors from a source buffer into the palette starting at the required index, optionally converting them from 24-bit color format into the 12-bit format used by the LCD controller.

ui32Type must be set to one of the following values to indicate the type of frame buffer for which the palette is being initialized:

LCD_PALETTE_TYPE_1BPP indicates a 1 bit per pixel (monochrome) frame buffer. This format requires a 2 entry palette.
LCD_PALETTE_TYPE_2BPP indicates a 2 bit per pixel frame buffer. This format requires a 4 entry palette.
LCD_PALETTE_TYPE_4BPP indicates a 4 bit per pixel frame buffer. This format requires a 4 entry palette.
LCD_PALETTE_TYPE_8BPP indicates an 8 bit per pixel frame buffer. This format requires a 256 entry palette.
LCD_PALETTE_TYPE_DIRECT indicates a direct color (12, 16 or 24 bit per pixel). The color palette is not used in these modes, but the frame buffer type must still be initialized to ensure that the hardware uses the correct pixel type. When this value is used, the format of the pixels in the frame buffer is defined by the ui32Config parameter previously passed to LCDRasterConfigSet().

Optionally, the LCD_PALETTE_SRC_24BIT flag may be ORed into ui32Type to indicate that the supplied colors in the pui32SrcColors array are in the 24-bit format as used by the TivaWare Graphics Library with one color stored in each 32-bit word. In this case, the colors read from the source array are converted to the 12-bit format used by the LCD controller before being written into the frame buffer palette.

If LCD_PALETTE_SRC_24BIT is not present, it is assumed that the pui32SrcColors array contains 12-bit colors in the format required by the LCD controller with 2 colors stored in each 32-bit word. In this case, the values are copied directly into the frame buffer palette without any reformatting.

Returns: None.

Definition at line 1367 of file lcd.c.

References ASSERT, LCD0_BASE, LCD_PALETTE_SRC_24BIT, LCD_PALETTE_TYPE_1BPP, LCD_PALETTE_TYPE_2BPP, LCD_PALETTE_TYPE_4BPP, LCD_PALETTE_TYPE_8BPP, LCD_PALETTE_TYPE_DIRECT, and PAL_FROM_RGB.

 {
     uint16_t *pui16Pal;
     uint16_t *pui16Src;
     uint32_t ui32Loop;
 
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT(ui32Start < 256);
     ASSERT((ui32Start + ui32Count) <= 256);
     ASSERT(pui32Addr);
     ASSERT((pui32SrcColors) || (ui32Count == 0));
     ASSERT(!(ui32Type & ~(LCD_PALETTE_SRC_24BIT | LCD_PALETTE_TYPE_DIRECT |
                           LCD_PALETTE_TYPE_8BPP | LCD_PALETTE_TYPE_4BPP |
                           LCD_PALETTE_TYPE_2BPP | LCD_PALETTE_TYPE_1BPP)));
 
     //
     // Get a pointer to the start of the palette.
     //
     pui16Pal = (uint16_t *)pui32Addr;
 
     //
     // Are we converting the palette color format?
     //
     if(ui32Type & LCD_PALETTE_SRC_24BIT)
     {
         //
         // Yes - loop through each of the supplied 24-bit colors converting
         // and storing each.
         //
         ui32Loop = 0;
         while(ui32Count)
         {
             pui16Pal[ui32Start + ui32Loop] =
                 PAL_FROM_RGB(pui32SrcColors[ui32Loop]);
             ui32Loop++;
             ui32Count--;
         }
     }
     else
     {
         //
         // No - loop through the supplied 12-bit colors storing each.
         //
 
         pui16Src = (uint16_t *)pui32SrcColors;
         while(ui32Count)
         {
             pui16Pal[ui32Start] = pui16Src[ui32Start];
             ui32Start++;
             ui32Count--;
         }
     }
 
     //
     // Write the pixel type into the first palette entry.
     //
     pui16Pal[0] &= ~(LCD_PALETTE_TYPE_8BPP | LCD_PALETTE_TYPE_DIRECT);
     pui16Pal[0] |= (ui32Type & ~LCD_PALETTE_SRC_24BIT);
 }

void LCDRasterSubPanelConfigSet	(	uint32_t	ui32Base,
		uint32_t	ui32Flags,
		uint32_t	ui32BottomLines,
		uint32_t	ui32DefaultPixel
	)

Sets the position and size of the subpanel on the raster display.

Parameters

ui32Base	is the base address of the controller.
ui32Flags	may be either LCD_SUBPANEL_AT_TOP to show frame buffer image data in the top portion of the display and default color in the bottom portion, or LCD_SUBPANEL_AT_BOTTOM to show image data at the bottom of the display and default color at the top.
ui32BottomLines	defines the number of lines comprising the bottom portion of the display. If LCD_SUBPANEL_AT_TOP is set in ui32Flags, these lines contain the default pixel color when the subpanel is enabled, otherwise they contain image data.
ui32DefaultPixel	is the 24-bit RGB color to show in the portion of the display not configured to show image data.

The LCD controller provides a feature that allows a portion of the display to be filled with a default color rather than image data from the frame buffer. This feature reduces SRAM bandwidth requirements because no data is fetched for lines containing the default color. This feature is only available when the LCD controller is in raster mode and configured to drive an active matrix display.

The subpanel area containing image data from the frame buffer may be positioned either at the top or bottom of the display as controlled by the value of ui32Flags. The height of the bottom portion of the display is defined by ui32BottomLines.

When a subpanel is configured, the application must also reconfigure the frame buffer to ensure that it contains the correct number of lines for the subpanel size in use. This configuration can be achieved by calling LCDRasterFrameBufferSet() with the ui32NumBytes parameter set appropriately to describe the required number of active video lines in the subpanel area.

The subpanel display mode is not enabled using this function. To enable the subpanel once it has been configured, call LCDRasterSubPanelEnable().

Returns: None.

Definition at line 1134 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_O_RASTRSUBP1, LCD_O_RASTRSUBP2, LCD_RASTRSUBP1_DPDLSB_S, LCD_RASTRSUBP1_LPPT_M, LCD_RASTRSUBP1_LPPT_S, LCD_RASTRSUBP1_SPEN, LCD_RASTRSUBP2_DPDMSB_M, LCD_SUBPANEL_AT_BOTTOM, and LCD_SUBPANEL_AT_TOP.

 {
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT((ui32Flags == LCD_SUBPANEL_AT_TOP) ||
            (ui32Flags == LCD_SUBPANEL_AT_BOTTOM));
     ASSERT(ui32BottomLines && (ui32BottomLines <= 2048));
 
     //
     // Adjust the line count into the 0-2047 range.
     //
     ui32BottomLines--;
 
     //
     // Set the first subpanel configuration register, taking care to leave the
     // subpanel enabled if it already was.
     //
     HWREG(ui32Base + LCD_O_RASTRSUBP1) = (HWREG(ui32Base + LCD_O_RASTRSUBP1) &
                                           LCD_RASTRSUBP1_SPEN) | ui32Flags |
                                          ((ui32DefaultPixel & 0xFFFF) <<
                                           LCD_RASTRSUBP1_DPDLSB_S) |
                                          ((ui32BottomLines <<
                                            LCD_RASTRSUBP1_LPPT_S) &
                                           LCD_RASTRSUBP1_LPPT_M);
 
     //
     // Set the second subpanel configuration register.
     //
     HWREG(ui32Base + LCD_O_RASTRSUBP2) =
         ((ui32DefaultPixel >> 16) & LCD_RASTRSUBP2_DPDMSB_M) |
         (((ui32BottomLines >> LCD_RASTRSUBP1_LPPT_S) & 1) << 8);
 }

void LCDRasterSubPanelDisable ( uint32_t ui32Base )

Disables subpanel display mode.

Parameters

ui32Base is the base address of the controller.

This function disables subpanel display mode and reverts to showing the entire frame buffer image on the display. After the subpanel is disabled, the frame buffer size must be reconfigured to match the full dimensions of the display area by calling LCDRasterFrameBufferSet() with an appropriate value for the ui32NumBytes parameter.

Returns: None.

Definition at line 1219 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_O_RASTRSUBP1, and LCD_RASTRSUBP1_SPEN.

 {
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
 
     //
     // Disable the subpanel.
     //
     HWREG(ui32Base + LCD_O_RASTRSUBP1) &= ~LCD_RASTRSUBP1_SPEN;
 }

void LCDRasterSubPanelEnable ( uint32_t ui32Base )

Enables subpanel display mode.

Parameters

ui32Base is the base address of the controller.

This function enables subpanel display mode and displays a default color rather than image data in the number of lines and at the position specified by a previous call to LCDRasterSubPanelConfigSet(). Prior to calling LCDRasterSubPanelEnable(), the frame buffer should have been reconfigured to match the desired subpanel size using a call to LCDRasterFrameBufferSet().

Subpanel display is only possible when the LCD controller is in raster mode and is configured to drive an active matrix display.

Returns: None.

Definition at line 1190 of file lcd.c.

References ASSERT, HWREG, LCD0_BASE, LCD_O_RASTRSUBP1, and LCD_RASTRSUBP1_SPEN.

 {
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
 
     //
     // Enable the subpanel.
     //
     HWREG(ui32Base + LCD_O_RASTRSUBP1) |= LCD_RASTRSUBP1_SPEN;
 }

void LCDRasterTimingSet	(	uint32_t	ui32Base,
		const tLCDRasterTiming *	pTiming
	)

Sets the LCD controller interface timing when in raster mode.

Parameters

ui32Base	specifies the LCD controller module base address.
pTiming	points to a structure containing the desired timing parameters.

This function is used in raster mode to set the panel size and sync timing parameters.

For a definition of the timing parameters required, see the definition of tLCDRasterTiming.

Returns: None

Definition at line 894 of file lcd.c.

 {
     uint32_t ui32T0, ui32T1, ui32T2;
 
     //
     // Sanity check parameters.
     //
     ASSERT(ui32Base == LCD0_BASE);
     ASSERT(pTiming);
     ASSERT(!(pTiming->ui32Flags & ~(RASTER_TIMING_SYNCS_OPPOSITE_PIXCLK |
                                     RASTER_TIMING_SYNCS_ON_FALLING_PIXCLK |
                                     RASTER_TIMING_SYNCS_ON_RISING_PIXCLK |
                                     RASTER_TIMING_ACTIVE_LOW_OE |
                                     RASTER_TIMING_ACTIVE_LOW_PIXCLK |
                                     RASTER_TIMING_ACTIVE_LOW_HSYNC |
                                     RASTER_TIMING_ACTIVE_LOW_VSYNC)));
     ASSERT(pTiming->ui16PanelWidth && (pTiming->ui16PanelWidth <= 2048) &&
            ((pTiming->ui16PanelWidth % 16) == 0));
     ASSERT(pTiming->ui16PanelHeight && (pTiming->ui16PanelHeight <= 2048));
     ASSERT(pTiming->ui16HFrontPorch && (pTiming->ui16HFrontPorch <= 1024));
     ASSERT(pTiming->ui16HBackPorch && (pTiming->ui16HBackPorch <= 1024));
     ASSERT(pTiming->ui16HSyncWidth && (pTiming->ui16HSyncWidth <= 1024));
     ASSERT(pTiming->ui8VSyncWidth && (pTiming->ui8VSyncWidth <= 64));
 
     //
     // Construct the values we need for the three raster timing registers.
     //
     ui32T0 = ((uint32_t)((pTiming->ui16HBackPorch - 1) & 0xFF) <<
               LCD_RASTRTIM0_HBP_S) |
              ((uint32_t)((pTiming->ui16HFrontPorch - 1) & 0xFF) <<
               LCD_RASTRTIM0_HFP_S) |
              ((uint32_t)((pTiming->ui16HSyncWidth - 1) & 0x3F) <<
               LCD_RASTRTIM0_HSW_S) |
              (((uint32_t)((pTiming->ui16PanelWidth - 1) & 0x3F0) >> 4) <<
               LCD_RASTRTIM0_PPL_S) |
              (((uint32_t)((pTiming->ui16PanelWidth - 1) & 0x400) >> 10) <<
               LCD_RASTRTIM0_MSBPPL_S);
     ui32T1 = ((uint32_t)pTiming->ui8VBackPorch << LCD_RASTRTIM1_VBP_S) |
              ((uint32_t)pTiming->ui8VFrontPorch << LCD_RASTRTIM1_VFP_S) |
              ((uint32_t)((pTiming->ui8VSyncWidth - 1) & 0x3F) <<
               LCD_RASTRTIM1_VSW_S) |
              ((uint32_t)(pTiming->ui16PanelHeight - 1) & 0x3FF) <<
              LCD_RASTRTIM1_LPP_S;
     ui32T2 = pTiming->ui32Flags |
              ((((pTiming->ui16HSyncWidth - 1) & 0x3C0) >> 6) <<
               LCD_RASTRTIM2_HSW_S) |
              ((((pTiming->ui16PanelHeight - 1) & 0x400) >> 10) <<
               LCD_RASTRTIM2_MSBLPP_S) |
              ((((pTiming->ui16HBackPorch - 1) & 0x300) >> 8) <<
               LCD_RASTRTIM2_MSBHBP_S) |
              ((((pTiming->ui16HFrontPorch - 1) & 0x300) >> 8) <<
               LCD_RASTRTIM2_MSBHFP_S) |
              (pTiming->ui8ACBiasLineCount << LCD_RASTRTIM2_ACBF_S);
 
     //
     // Write the timing registers, taking care to preserve any existing value
     // in the AC Bias interrupt field of RASTRTIM2.
     //
     HWREG(ui32Base + LCD_O_RASTRTIM0) = ui32T0;
     HWREG(ui32Base + LCD_O_RASTRTIM1) = ui32T1;
     HWREG(ui32Base + LCD_O_RASTRTIM2) = (HWREG(ui32Base + LCD_O_RASTRTIM2) &
                                          LCD_RASTRTIM2_ACBI_M) | ui32T2;
 }

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

Function Documentation