Arduino.ru

#if defined __AVR_ATmega328P__
    #include "pin_magic_UNO.h"
#endif
#if defined __AVR_ATmega2560__
    #include "pin_magic_MEGA.h"

#endif

И пишем

#include "pin_magic.h"

/**
 * \file
 *
 * \brief ILI9488 Display Controller Component Driver
 *
 * Copyright (c) 2012-2013 Atmel Corporation. All rights reserved.
 *
 * \asf_license_start
 *
 * \page License
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * 3. The name of Atmel may not be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * 4. This software may only be redistributed and used in connection with an
 *    Atmel microcontroller product.
 *
 * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
 * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * \asf_license_stop
 *
 */
#ifndef ILI9488_H_INCLUDED
#define ILI9488_H_INCLUDED

#include <ioport.h>
#include <compiler.h>

/* Controller and interface configuration file */
#include "conf_ili9488.h"

#if defined(CONF_ILI9488_USART_SPI)
#  include <usart_spi.h>
#elif defined(CONF_ILI9488_SPI)
#  include <spi_master.h>
#elif defined(CONF_ILI9488_EBI)
#  include <smc.h>
#  include <pmc.h>
#else
#  error "Interface not supported by the component driver"
#endif

#ifdef __cplusplus
extern "C" {
#endif

/**
 * \defgroup ili9488_group ILI9488 Display Controller Component Driver
 *
 * See \ref common_ili9488_qs
 *
 * This is the low level component driver for the ILI9488 display controller.
 * It provides basic functions for initializing, writing and reading the
 * controller. In addition to hardware control and use of the LCD controller
 * internal functions.
 *
 * \warning This component driver is not reentrant and can not be used in
 * interrupt service routines without extra care.
 *
 * Before writing data to the display call \ref ili9488_init() which will set up
 * the physical interface and the display. A configuration file conf_ili9488.h
 * is needed to define which interface to use, pin connections and communication
 * speed.
 *
 * An example conf_ili9488.h file for the XMEGA could look like:
 * \code
 * #define CONF_ILI9488_USART_SPI     &USARTC0
 * #define CONF_ILI9488_CLOCK_SPEED   8000000UL
 *
 * #define CONF_ILI9488_CS_PIN        IOPORT_CREATE_PIN(PORTC, 5)
 * #define CONF_ILI9488_DC_PIN        IOPORT_CREATE_PIN(PORTC, 4)
 * #define CONF_ILI9488_BACKLIGHT_PIN IOPORT_CREATE_PIN(PORTA, 5)
 * #define CONF_ILI9488_RESET_PIN     IOPORT_CREATE_PIN(PORTA, 7)
 * \endcode
 *
 * \section dependencies Dependencies
 * This component driver depends on the following modules:
 * - \ref gpio_group for IO port control.
 * - \ref sysclk_group for clock speed and functions.
 * - \ref usart_spi_group or \ref spi_group for communication with the
 * controller.
 * @{
 */

/** This macro generates a 16-bit native color for the display from a
 *  24-bit RGB value.
 */
#define ILI9488_COLOR(r, g, b)\
	Swap16((((uint16_t)b) >> 3) |\
	       ((((uint16_t)g) << 3) & 0x07E0) |\
	       ((((uint16_t)r) << 8) & 0xf800))

/** Type define for an integer type large enough to store a pixel color. */
typedef uint16_t ili9488_color_t;

/** Type define for an integer type large enough to store a pixel coordinate.
 */
typedef int16_t ili9488_coord_t;

/**
 * \name Display orientation flags
 * @{
 */

/** Bit mask for flipping X for ili9488_set_orientation() */
#define ILI9488_FLIP_X 1
/** Bit mask for flipping Y for ili9488_set_orientation() */
#define ILI9488_FLIP_Y 2
/** Bit mask for swapping X and Y for ili9488_set_orientation() */
#define ILI9488_SWITCH_XY 4

/** @} */

/** Height of display using default orientation */
#define ILI9488_DEFAULT_HEIGHT   320

/** Width of display using default orientation */
#define ILI9488_DEFAULT_WIDTH    480

/** Height of display using swapped X/Y orientation */
#define ILI9488_SWITCH_XY_HEIGHT 480

/** Width of display using swapped X/Y orientation */
#define ILI9488_SWITCH_XY_WIDTH  320

/**
 * \name Controller primitive graphical functions
 * @{
 */
ili9488_color_t ili9488_read_gram(void);

void ili9488_write_gram(ili9488_color_t color);

void ili9488_set_top_left_limit(ili9488_coord_t x, ili9488_coord_t y);

void ili9488_set_bottom_right_limit(ili9488_coord_t x, ili9488_coord_t y);

void ili9488_set_limits(ili9488_coord_t start_x, ili9488_coord_t start_y,
		ili9488_coord_t end_x, ili9488_coord_t end_y);

void ili9488_set_orientation(uint8_t flags);

void ili9488_copy_pixels_to_screen(const ili9488_color_t *pixels,
		uint32_t count);

#if XMEGA
void ili9488_copy_progmem_pixels_to_screen(
		ili9488_color_t PROGMEM_PTR_T pixels, uint32_t count);
#endif

void ili9488_copy_pixels_from_screen(ili9488_color_t *pixels, uint32_t count);

void ili9488_duplicate_pixel(const ili9488_color_t color, uint32_t count);

/** @} */

/**
 * \name Controller and display initialization and management
 * @{
 */

void ili9488_init(void);

/**
 * \brief Function to turn on the display back light
 *
 * Use this function to simply set the pin controlling the back light high to
 * turn on the back light.
 *
 * \note It is up to the user application if other means of controlling this pin
 * should be used, e.g. a PWM signal to be able to dim the display.
 */
static inline void ili9488_backlight_on(void)
{
	ioport_set_pin_level(CONF_ILI9488_BACKLIGHT_PIN, true);
}

/**
 * \brief Function to turn off the display back light
 *
 * Use this function to simply set the pin controlling the back light low to
 * turn off the back light.
 */
static inline void ili9488_backlight_off(void)
{
	ioport_set_pin_level(CONF_ILI9488_BACKLIGHT_PIN, false);
}

/** @} */

/** @} */

/**
 * \page common_ili9488_qs Quick Start Guide for the ILI9488 Display Controller Component Driver
 *
 * This is the quick start guide for the \ref ili9488_group, with step-by-step
 * instructions on how to configure and use the component driver for specific
 * use cases.
 *
 * The section described below can be compiled into e.g. the main application
 * loop or any other function that will need to interface non-volatile memory.
 *
 * \section common_ili9488_qs_basic Basic usage of the ILI9488 component driver
 * This section will present one use cases of the ILI9488 component driver. It
 * will first turn on the backlight and then fill the screen with a solid
 * color.
 *
 * \section common_ili9488_qs_basic_case Use case 1: Fill Screen Color
 *
 * The ILI9488 component driver contains a basic backlight control as well as
 * functions to draw pixels of various colors within a given pixel boundary.
 * This use case will turn on the backlight and fill the entire display with a
 * single color.
 *
 * \section common_ili9488_qs_basic_case_prereq Prerequisites
 * The conf_ili9488.h configuration file must be present in your application,
 * and should be set to use the correct SPI interface of your chosen
 * microcontroller.
 *
 * Your application should configure the display SPI, reset, command/data and
 * backlight pins as appropriate. If you are using the maXTouch Xplained Pro
 * kit this can be achieved by defining:
 * \code
 * #define CONF_BOARD_MAXTOUCH_XPLAINED_PRO
 * \endcode
 * in your conf_board.h header file.
 *
 * \section common_ili9488_qs_basic_case_setup Setup
 *
 * \subsection common_ili9488_qs_basic_case_setup_steps Code
 * \code
 * ili9488_init();
 * ili9488_backlight_on();
 * \endcode
 *
 * \subsection common_ili9488_qs_basic_case_setup_workflow Workflow
 * -# First, we must initialize the display so that it is correctly configured
 *    and ready to receive commands:
 *    \code
 *    ili9488_init();
 *    \endcode
 * -# Next, the display backlight is enabled, turning it on:
 *    \code
 *    ili9488_backlight_on();
 *    \endcode
 *
 * \section common_ili9488_qs_basic_case_example_code Example code
 *
 * \code
 * ili9488_set_top_left_limit(0, 0);
 * ili9488_set_bottom_right_limit(240, 320);
 *
 * ili9488_duplicate_pixel(ILI9488_COLOR(255, 0, 0), 240UL * 320UL);
 * \endcode
 *
 * \subsection common_ili9488_qs_basic_case_workflow Workflow
 *
 * -# First the screen drawing limits are set to start from the upper-left
 *    pixel coordinate, and end at the lower right screen boundary:
 *     - \code
 *       ili9488_set_top_left_limit(0, 0);
 *       ili9488_set_bottom_right_limit(240, 320);
 *       \endcode
 *    \note If both the top-left and bottom-right limits are to be set at the
 *          same time, it is faster to call \ref  ili9488_set_limits() instead.
 * -# Next, the display is filled with 240*320 (the screen's pixel dimensions)
 *    pixels of the same RGB color of (255, 0, 0), a bright red.
 *     - \code
 *       ili9488_duplicate_pixel(ILI9488_COLOR(255, 0, 0), 240UL * 320UL);
 *       \endcode
 *    \note You must encode the RGB color value to use in the display's native
 *          pixel color format using the \ref ILI9488_COLOR() macro.
 */

#ifdef __cplusplus
}
#endif

#endif /* ILI9488_H_INCLUDED */ 

и

/**
 * \file
 *
 * \brief ILI9488 display controller component driver
 *
 * Copyright (c) 2012-2013 Atmel Corporation. All rights reserved.
 *
 * \asf_license_start
 *
 * \page License
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * 3. The name of Atmel may not be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * 4. This software may only be redistributed and used in connection with an
 *    Atmel microcontroller product.
 *
 * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
 * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * \asf_license_stop
 *
 */
#include "conf_ili9488.h"
#include "ili9488.h"
#include "ili9488_regs.h"
#include <sysclk.h>
#include <ioport.h>
#include <delay.h>

#if (SAM3S || SAM3N || SAM4S)
#  include <pdc.h>
#elif UC3
#  include <pdca.h>
#endif

#if (SAM3S || SAM3N || SAM4S) && defined(CONF_ILI9488_SPI)
#  define ILI9488_DMA_ENABLED
#  define ILI9488_DMA_CHUNK_SIZE   16
#elif UC3 && defined(CONF_ILI9488_PDCA_CHANNEL)
#  define ILI9488_DMA_ENABLED
#  define ILI9488_DMA_CHUNK_SIZE   16
#endif

#ifndef CONF_ILI9488_EBI
/**
 * \internal
 * \brief Helper function to select the CS of the controller on the bus
 */
__always_inline static void ili9488_select_chip(void)
{
	ioport_set_pin_level(CONF_ILI9488_CS_PIN, false);
}

/**
 * \internal
 * \brief Helper function to de-select the CS of the controller on the bus
 */
__always_inline static void ili9488_deselect_chip(void)
{
	ioport_set_pin_level(CONF_ILI9488_CS_PIN, true);
}

/**
 * \internal
 * \brief Helper function to select command byte transmission mode
 */
__always_inline static void ili9488_select_command_mode(void)
{
	ioport_set_pin_level(CONF_ILI9488_DC_PIN, false);
}

/**
 * \internal
 * \brief Helper function to select data byte transmission mode
 */
__always_inline static void ili9488_select_data_mode(void)
{
	ioport_set_pin_level(CONF_ILI9488_DC_PIN, true);
}

/**
 * \internal
 * \brief Helper function to wait for the last send operation to complete
 */
__always_inline static void ili9488_wait_for_send_done(void)
{
#if defined(CONF_ILI9488_USART_SPI)
#  if XMEGA
	while (!usart_tx_is_complete(CONF_ILI9488_USART_SPI)) {
		/* Do nothing */
	}
	usart_clear_tx_complete(CONF_ILI9488_USART_SPI);
#  else
	/* Wait for TX to complete */
	while (!usart_spi_is_tx_empty(CONF_ILI9488_USART_SPI)) {
		/* Do nothing */
	}
#  endif
#elif defined(CONF_ILI9488_SPI)
	/* Wait for TX to complete */
	while (!spi_is_tx_empty(CONF_ILI9488_SPI)) {
		/* Do nothing */
	}
#endif
}

/**
 * \internal
 * \brief Helper function to send a byte over an arbitrary interface
 *
 * This function is used to hide what interface is used by the component
 * driver, e.g.  the component driver does not need to know if USART in SPI
 * mode is used or the native SPI module.
 *
 * \param data The byte to be transfered
 */
__always_inline static void ili9488_send_byte(uint8_t data)
{
#if defined(CONF_ILI9488_USART_SPI)
#  if XMEGA
	while (!usart_data_register_is_empty(CONF_ILI9488_USART_SPI)) {
		/* Do nothing */
	}

	irqflags_t flags = cpu_irq_save();
	usart_clear_tx_complete(CONF_ILI9488_USART_SPI);
	usart_put(CONF_ILI9488_USART_SPI, data);
	cpu_irq_restore(flags);
#  else
	usart_spi_write_single(CONF_ILI9488_USART_SPI, data);
#  endif
#elif defined(CONF_ILI9488_SPI)
	/* Wait for any previously running send data */
	ili9488_wait_for_send_done();

	spi_write_single(CONF_ILI9488_SPI, data);
#endif
}

/**
 * \internal
 * \brief Helper function to read a byte from an arbitrary interface
 *
 * This function is used to hide what interface is used by the component
 * driver, e.g.  the component driver does not need to know if USART in SPI
 * mode is used or the native SPI module.
 *
 * \retval uint8_t Byte of data read from the display controller
 */
__always_inline static uint8_t ili9488_read_byte(void)
{
	uint8_t data;

#if defined(CONF_ILI9488_USART_SPI)
#  if XMEGA
	/* Workaround for clearing the RXCIF for XMEGA */
	usart_rx_enable(CONF_ILI9488_USART_SPI);

	usart_put(CONF_ILI9488_USART_SPI, 0xFF);
	while (!usart_rx_is_complete(CONF_ILI9488_USART_SPI)) {
		/* Do nothing */
	}
	data = usart_get(CONF_ILI9488_USART_SPI);

	/* Workaround for clearing the RXCIF for XMEGA */
	usart_rx_disable(CONF_ILI9488_USART_SPI);
#  else
	usart_spi_read_single(CONF_ILI9488_USART_SPI, &data);
#  endif
#elif defined(CONF_ILI9488_SPI)
	spi_write_single(CONF_ILI9488_SPI, 0xFF);

	ili9488_wait_for_send_done();

	/* Wait for RX to complete */
	while (!spi_is_rx_full(CONF_ILI9488_SPI)) {
		/* Do nothing */
	}

	spi_read_single(CONF_ILI9488_SPI, &data);
#endif

	return data;
}

/**
 * \internal
 * \brief Sends a command to the controller, and prepares for parameter transfer
 *
 * Helper function to use for sending a command to the controller.
 *
 * \note After the command is sent, the display remains selected.
 *
 * \param command The command to send
 */
static void ili9488_send_command(uint8_t command)
{
	ili9488_select_command_mode();
	ili9488_select_chip();
	ili9488_send_byte(command);
	ili9488_wait_for_send_done();
	ili9488_select_data_mode();
}

#else
volatile uint8_t *cmd_addr = (uint8_t *) (CONF_ILI9488_EBI_CMD_ADDRESS);
volatile uint8_t *data_addr = (uint8_t *) (CONF_ILI9488_EBI_DATA_ADDRESS);

#define ili9488_select_chip()
#define ili9488_deselect_chip()
#define ili9488_select_command_mode()
#define ili9488_select_data_mode()
#define ili9488_wait_for_send_done()

__always_inline static void ili9488_send_byte(uint8_t data) {
	*data_addr = data;
}
__always_inline static uint8_t ili9488_read_byte(void) {
	return *data_addr;
}
static void ili9488_send_command(uint8_t command) {
	*cmd_addr = command;
}
#endif

static ili9488_coord_t limit_start_x, limit_start_y;
static ili9488_coord_t limit_end_x, limit_end_y;

/**
 * \internal
 * \brief Helper function to send the drawing limits (boundaries) to the display
 *
 * This function is used to send the currently set upper-left and lower-right
 * drawing limits to the display, as set through the various limit functions.
 *
 * \param send_end_limits  True to also send the lower-right drawing limits
 */
static void ili9488_send_draw_limits(const bool send_end_limits)
{
	ili9488_send_command(ILI9488_CMD_COLUMN_ADDRESS_SET);
	ili9488_send_byte(limit_start_x >> 8);
	ili9488_send_byte(limit_start_x & 0xFF);
	if (send_end_limits) {
		ili9488_send_byte(limit_end_x >> 8);
		ili9488_send_byte(limit_end_x & 0xFF);
	}
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();

	ili9488_send_command(ILI9488_CMD_PAGE_ADDRESS_SET);
	ili9488_send_byte(limit_start_y >> 8);
	ili9488_send_byte(limit_start_y & 0xFF);
	if (send_end_limits) {
		ili9488_send_byte(limit_end_y >> 8);
		ili9488_send_byte(limit_end_y & 0xFF);
	}
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();
}

/**
 * \brief Set the display top left drawing limit
 *
 * Use this function to set the top left limit of the drawing limit box.
 *
 * \param x The x coordinate of the top left corner
 * \param y The y coordinate of the top left corner
 */
void ili9488_set_top_left_limit(ili9488_coord_t x, ili9488_coord_t y)
{
	limit_start_x = x;
	limit_start_y = y;

	ili9488_send_draw_limits(false);
}

/**
 * \brief Set the display bottom right drawing limit
 *
 * Use this function to set the bottom right corner of the drawing limit box.
 *
 * \param x The x coordinate of the bottom right corner
 * \param y The y coordinate of the bottom right corner
 */
void ili9488_set_bottom_right_limit(ili9488_coord_t x, ili9488_coord_t y)
{
	limit_end_x = x;
	limit_end_y = y;

	ili9488_send_draw_limits(true);
}

/**
 * \brief Set the full display drawing limits
 *
 * Use this function to set the full drawing limit box.
 *
 * \param start_x The x coordinate of the top left corner
 * \param start_y The y coordinate of the top left corner
 * \param end_x The x coordinate of the bottom right corner
 * \param end_y The y coordinate of the bottom right corner
 */
void ili9488_set_limits(ili9488_coord_t start_x, ili9488_coord_t start_y,
		ili9488_coord_t end_x, ili9488_coord_t end_y)
{
	limit_start_x = start_x;
	limit_start_y = start_y;
	limit_end_x = end_x;
	limit_end_y = end_y;

	ili9488_send_draw_limits(true);
}

/**
 * \brief Read a single color from the graphical memory
 *
 * Use this function to read a color from the graphical memory of the
 * controller.
 *
 * Limits have to be set prior to calling this function, e.g.:
 * \code
 * ili9488_set_top_left_limit(0, 0);
 * ili9488_set_bottom_right_limit(320, 240);
 * ...
 * \endcode
 *
 * \retval ili9488_color_t The read color pixel
 */
ili9488_color_t ili9488_read_gram(void)
{
	uint8_t red, green, blue;

	ili9488_send_command(ILI9488_CMD_MEMORY_READ);

	/* No interesting data in the first byte, hence read and discard */
	red = ili9488_read_byte();

	red = ili9488_read_byte();
	green = ili9488_read_byte();
	blue = ili9488_read_byte();

	ili9488_deselect_chip();

	return ILI9488_COLOR(red, green, blue);
}

/**
 * \brief Write the graphical memory with a single color pixel
 *
 * Use this function to write a single color pixel to the controller memory.
 *
 * Limits have to be set prior to calling this function, e.g.:
 * \code
 * ili9488_set_top_left_limit(0, 0);
 * ili9488_set_bottom_right_limit(320, 240);
 * ...
 * \endcode
 *
 * \param color The color pixel to write to the screen
 */
void ili9488_write_gram(ili9488_color_t color)
{
	/* Only 16-bit color supported */
	Assert(sizeof(color) == 2);

	ili9488_send_command(ILI9488_CMD_MEMORY_WRITE);
	ili9488_send_byte(color);
	ili9488_send_byte(color >> 8);
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();
}

/**
 * \brief Copy pixels from SRAM to the screen
 *
 * Used to copy a large quantitative of data to the screen in one go.
 *
 * Limits have to be set prior to calling this function, e.g.:
 * \code
 * ili9488_set_top_left_limit(0, 0);
 * ili9488_set_bottom_right_limit(320, 240);
 * ...
 * \endcode
 *
 * \param pixels Pointer to the pixel data
 * \param count Number of pixels to copy to the screen
 */
void ili9488_copy_pixels_to_screen(const ili9488_color_t *pixels, uint32_t count)
{
	const ili9488_color_t *pixel = pixels;

	/* Sanity check to make sure that the pixel count is not zero */
	Assert(count > 0);

	ili9488_send_command(ILI9488_CMD_MEMORY_WRITE);

#if defined(ILI9488_DMA_ENABLED)
	ili9488_color_t chunk_buf[ILI9488_DMA_CHUNK_SIZE];
	uint32_t chunk_len;

#  if SAM
	Pdc *SPI_DMA = spi_get_pdc_base(CONF_ILI9488_SPI);
	pdc_packet_t spi_pdc_data;

	pdc_enable_transfer(SPI_DMA, PERIPH_PTCR_TXTEN);
	spi_pdc_data.ul_addr = (uint32_t)chunk_buf;
#  elif UC3
	pdca_set_transfer_size(CONF_ILI9488_PDCA_CHANNEL,
			PDCA_TRANSFER_SIZE_BYTE);
	pdca_set_peripheral_select(CONF_ILI9488_PDCA_CHANNEL,
			CONF_ILI9488_PDCA_PID);
#  endif

	while (count)
	{
		/* We need to copy out the data to send in chunks into RAM, as the PDC
		 * does not allow FLASH->Peripheral transfers */
		chunk_len = min(ILI9488_DMA_CHUNK_SIZE, count);

		/* Wait for pending transfer to complete */
		ili9488_wait_for_send_done();

		for (uint32_t i = 0; i < chunk_len; i++) {
			chunk_buf[i] = le16_to_cpu(pixel[i]);
		}

#  if SAM
		spi_pdc_data.ul_size = (uint32_t)sizeof(ili9488_color_t) * chunk_len;
		pdc_tx_init(SPI_DMA, NULL, &spi_pdc_data);
#  elif UC3
		pdca_reload_channel(CONF_ILI9488_PDCA_CHANNEL, chunk_buf,
				(uint32_t)sizeof(ili9488_color_t) * chunk_len);
		pdca_enable(CONF_ILI9488_PDCA_CHANNEL);
#  endif

		pixel += chunk_len;
		count -= chunk_len;
	}

	ili9488_wait_for_send_done();
	ili9488_deselect_chip();

#  if SAM
	pdc_disable_transfer(SPI_DMA, PERIPH_PTCR_TXTEN);
#  elif UC3
	pdca_disable(CONF_ILI9488_PDCA_CHANNEL);
#  endif
#else
	while (count--) {
		ili9488_send_byte(*pixel);
		ili9488_send_byte(*pixel >> 8);

		pixel++;
	}

	ili9488_wait_for_send_done();
	ili9488_deselect_chip();
#endif
}

#if XMEGA
/**
 * \brief Copy pixels from progmem to the screen
 *
 * This function can be used to copy data from program memory (flash) to the
 * display.
 *
 * Limits have to be set prior to calling this function, e.g.:
 * \code
 * ili9488_set_top_left_limit(0, 0);
 * ili9488_set_bottom_right_limit(320, 240);
 * ...
 * \endcode
 *
 * \param pixels Pointer to the progmem data
 * \param count Number of pixels to write
 */
void ili9488_copy_progmem_pixels_to_screen(
		ili9488_color_t PROGMEM_PTR_T pixels, uint32_t count)
{
	ili9488_color_t color;

	/* Sanity check to make sure that the pixel count is not zero */
	Assert(count > 0);

	ili9488_send_command(ILI9488_CMD_MEMORY_WRITE);

	while (count--) {
		color = PROGMEM_READ_WORD(pixels);

		ili9488_send_byte(color);
		ili9488_send_byte(color >> 8);

		pixels++;
	}

	ili9488_wait_for_send_done();
	ili9488_deselect_chip();
}
#endif

/**
 * \brief Set a given number of pixels to the same color
 *
 * Use this function to write a certain number of pixels to the same color
 * within a set limit.
 *
 * Limits have to be set prior to calling this function, e.g.:
 * \code
 * ili9488_set_top_left_limit(0, 0);
 * ili9488_set_bottom_right_limit(320, 240);
 * ...
 * \endcode
 *
 * \param color The color to write to the display
 * \param count The number of pixels to write with this color
 */
void ili9488_duplicate_pixel(const ili9488_color_t color, uint32_t count)
{
	/* Sanity check to make sure that the pixel count is not zero */
	Assert(count > 0);

	ili9488_send_command(ILI9488_CMD_MEMORY_WRITE);

#if defined(ILI9488_DMA_ENABLED)
	ili9488_color_t chunk_buf[ILI9488_DMA_CHUNK_SIZE];
	uint32_t chunk_len;

#  if SAM
	Pdc *SPI_DMA = spi_get_pdc_base(CONF_ILI9488_SPI);
	pdc_packet_t spi_pdc_data;

	pdc_enable_transfer(SPI_DMA, PERIPH_PTCR_TXTEN);
	spi_pdc_data.ul_addr = (uint32_t)chunk_buf;
#  elif UC3
	pdca_set_transfer_size(CONF_ILI9488_PDCA_CHANNEL,
			PDCA_TRANSFER_SIZE_BYTE);
	pdca_set_peripheral_select(CONF_ILI9488_PDCA_CHANNEL,
			CONF_ILI9488_PDCA_PID);
#  endif

	for (uint32_t i = 0; i < ILI9488_DMA_CHUNK_SIZE; i++) {
		chunk_buf[i] = le16_to_cpu(color);
	}

	while (count)
	{
		chunk_len = min(ILI9488_DMA_CHUNK_SIZE, count);

		ili9488_wait_for_send_done();

#  if SAM
		spi_pdc_data.ul_size = (uint32_t)sizeof(ili9488_color_t) * chunk_len;
		pdc_tx_init(SPI_DMA, NULL, &spi_pdc_data);
#  elif UC3
		pdca_reload_channel(CONF_ILI9488_PDCA_CHANNEL, chunk_buf,
				(uint32_t)sizeof(ili9488_color_t) * chunk_len);
		pdca_enable(CONF_ILI9488_PDCA_CHANNEL);
#  endif

		count -= chunk_len;
	}

	ili9488_wait_for_send_done();
	ili9488_deselect_chip();

#  if SAM
	pdc_disable_transfer(SPI_DMA, PERIPH_PTCR_TXTEN);
#  elif UC3
	pdca_disable(CONF_ILI9488_PDCA_CHANNEL);
#  endif
#else
	while (count--) {
		ili9488_send_byte(color);
		ili9488_send_byte(color >> 8);
	}

	ili9488_wait_for_send_done();
	ili9488_deselect_chip();
#endif
}

/**
 * \brief Copy pixels from the screen to a pixel buffer
 *
 * Use this function to copy pixels from the display to an internal SRAM buffer.
 *
 * Limits have to be set prior to calling this function, e.g.:
 * \code
 * ili9488_set_top_left_limit(0, 0);
 * ili9488_set_bottom_right_limit(320, 240);
 * ...
 * \endcode
 *
 * \param pixels Pointer to the pixel buffer to read to
 * \param count Number of pixels to read
 */
void ili9488_copy_pixels_from_screen(ili9488_color_t *pixels, uint32_t count)
{
	uint8_t red, green, blue;

	/* Sanity check to make sure that the pixel count is not zero */
	Assert(count > 0);

	ili9488_send_command(ILI9488_CMD_MEMORY_READ);

	/* No interesting data in the first byte, hence read and discard */
	red = ili9488_read_byte();

	while (count--) {
		red = ili9488_read_byte();
		green = ili9488_read_byte();
		blue = ili9488_read_byte();

		*pixels = ILI9488_COLOR(red, green, blue);
		pixels++;
	}

	ili9488_deselect_chip();
}

/**
 * \internal
 * \brief Initialize the hardware interface to the controller
 *
 * This will initialize the module used for communication with the controller.
 * Currently supported interfaces by this component driver are the SPI
 * interface through either the SPI module in master mode or the USART in
 * Master SPI mode.  Configuration must be done in the associated
 * conf_ili9488.h file.
 */
static void ili9488_interface_init(void)
{
#if defined(CONF_ILI9488_USART_SPI) || defined(CONF_ILI9488_SPI)
	spi_flags_t spi_flags = SPI_MODE_0;
	board_spi_select_id_t spi_select_id = 0;
#elif defined(CONF_ILI9488_EBI)
#else
	#error Interface for ILI9488 has not been selected or interface not\
	supported, please configure component driver using the conf_ili9488.h\
	file!
#endif

#if defined(CONF_ILI9488_USART_SPI)
	struct usart_spi_device device = {
		.id = 0,
	};

	usart_spi_init(CONF_ILI9488_USART_SPI);
	usart_spi_setup_device(CONF_ILI9488_USART_SPI, &device, spi_flags,
			CONF_ILI9488_CLOCK_SPEED, spi_select_id);

#elif defined(CONF_ILI9488_SPI)
	struct spi_device device = {
		.id = 0,
	};

	spi_master_init(CONF_ILI9488_SPI);
	spi_master_setup_device(CONF_ILI9488_SPI, &device, spi_flags,
			CONF_ILI9488_CLOCK_SPEED, spi_select_id);
	spi_enable(CONF_ILI9488_SPI);

#  if UC3
	spi_set_chipselect(CONF_ILI9488_SPI, ~(1 << 0));

#    if defined(ILI9488_DMA_ENABLED)
	sysclk_enable_peripheral_clock(&AVR32_PDCA);
#    endif
#  endif

	/* Send one dummy byte for the spi_is_tx_ok() to work as expected */
	spi_write_single(CONF_ILI9488_SPI, 0);
#else	
	pmc_enable_periph_clk(ID_SMC);
	/* The timing is based on a 120 MHz clock and the configuration is the
	 * fastest speed that the display can do in parallel mode.
	 */
	smc_set_setup_timing(SMC, CONF_ILI9488_EBI_CS,
	SMC_SETUP_NWE_SETUP(1)
	| SMC_SETUP_NCS_WR_SETUP(0)
	| SMC_SETUP_NRD_SETUP(1)
	| SMC_SETUP_NCS_RD_SETUP(0));
	smc_set_pulse_timing(SMC, CONF_ILI9488_EBI_CS,
	SMC_PULSE_NWE_PULSE(2)
	| SMC_PULSE_NCS_WR_PULSE(4)
	| SMC_PULSE_NRD_PULSE(43)
	| SMC_PULSE_NCS_RD_PULSE(54));
	smc_set_cycle_timing(SMC, CONF_ILI9488_EBI_CS,
	SMC_CYCLE_NWE_CYCLE(5)
	| SMC_CYCLE_NRD_CYCLE(55));
	smc_set_mode(SMC, CONF_ILI9488_EBI_CS, SMC_MODE_READ_MODE | SMC_MODE_WRITE_MODE);
#endif
}

/**
 * \internal
 * \brief Initialize all the display registers
 *
 * This function will set up all the internal registers according the the
 * manufacturer's description.
 */
static void ili9488_controller_init_registers(void)
{
	
	// PGAMCTRL - Positive Gamma Control
	ili9488_send_command(ILI9488_CMD_POSITIVE_GAMMA_CTRL);
	ili9488_send_byte(0x00);
	ili9488_send_byte(0x07);
	ili9488_send_byte(0x0f);
	ili9488_send_byte(0x0D);
	ili9488_send_byte(0x1B);
	ili9488_send_byte(0x0A);
	ili9488_send_byte(0x3c);
	ili9488_send_byte(0x78);
	ili9488_send_byte(0x4A);
	ili9488_send_byte(0x07);
	ili9488_send_byte(0x0E);
	ili9488_send_byte(0x09);
	ili9488_send_byte(0x1B);
	ili9488_send_byte(0x1e);
	ili9488_send_byte(0x0f);
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();

	// NGAMCTRL - Negative Gamma Control
	ili9488_send_command(ILI9488_CMD_NEGATIVE_GAMMA_CTRL);
	ili9488_send_byte(0x00);
	ili9488_send_byte(0x22);
	ili9488_send_byte(0x24);
	ili9488_send_byte(0x06);
	ili9488_send_byte(0x12);
	ili9488_send_byte(0x07);
	ili9488_send_byte(0x36);
	ili9488_send_byte(0x47);
	ili9488_send_byte(0x47);
	ili9488_send_byte(0x06);
	ili9488_send_byte(0x0a);
	ili9488_send_byte(0x07);
	ili9488_send_byte(0x30);
	ili9488_send_byte(0x37);
	ili9488_send_byte(0x0f);
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();

	// Power Control 1
	ili9488_send_command(ILI9488_CMD_POWER_CONTROL_1);
	ili9488_send_byte(0x10);
	ili9488_send_byte(0x10);
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();

	// Power Control 2
	ili9488_send_command(ILI9488_CMD_POWER_CONTROL_2);
	ili9488_send_byte(0x41);
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();

	// VCOM Control
	ili9488_send_command(ILI9488_CMD_VCOM_CONTROL_1);
	ili9488_send_byte(0x00);
	ili9488_send_byte(0x22);
	ili9488_send_byte(0x80);
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();
   
	// Memory Access Control
	ili9488_send_command(ILI9488_CMD_MEMORY_ACCESS_CONTROL);
	ili9488_send_byte(0x68);
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();

	//Interface Mode Control
	// Set up used SPI lines and RGB interface
	ili9488_send_command(ILI9488_CMD_INTERFACE_MODE_CONTROL);
	ili9488_send_byte(0x00);
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();

	//Frame rate 70HZ
	ili9488_send_command(ILI9488_CMD_FRAME_RATE_CONTROL_NORMAL);
	ili9488_send_byte(0xB0);
	ili9488_send_byte(0x11);
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();

	// Display Inversion
	ili9488_send_command(ILI9488_CMD_DISPLAY_INVERSION_CONTROL);
	ili9488_send_byte(0x02);
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();

	// Entry Set Mode
	ili9488_send_command(ILI9488_CMD_ENTRY_MODE_SET);
	ili9488_send_byte(0xC6);
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();

#ifndef CONF_ILI9488_SPI

	// Interface Pixel Format
	ili9488_send_command(ILI9488_CMD_INTERFACE_PIXEL_FORMAT);
	ili9488_send_byte(0x55);// DPI: 16bpp  DBI: 16bpp
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();
	
	// Set Image Function
	// enable 24 bit data bus
	ili9488_send_command(ILI9488_CMD_SET_IMAGE_FUNCTION);
	ili9488_send_byte(0x01);
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();
#else
	// Interface Pixel Format
	ili9488_send_command(ILI9488_CMD_INTERFACE_PIXEL_FORMAT);
	ili9488_send_byte(0x51);// DPI: 16bpp  DBI: 16bpp
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();
	
	// Set Image Function
	ili9488_send_command(ILI9488_CMD_SET_IMAGE_FUNCTION);
	ili9488_send_byte(0x00);
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();
#endif

	// Adjustment Control 3
	// fixed settings and DSI packet setup
	ili9488_send_command(ILI9488_CMD_ADJUST_CONTROL_3);
	ili9488_send_byte(0xA9);
	ili9488_send_byte(0x51);
	ili9488_send_byte(0x2C);
	ili9488_send_byte(0x82);
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();

	// Set Interface Mode
	ili9488_send_command(ILI9488_CMD_DISPLAY_FUNCTION_CONTROL);
	ili9488_send_byte(0x00);// RGB or other interface
	ili9488_send_byte(0x22);
	ili9488_send_byte(0x3B);
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();

	ili9488_set_orientation(0);
	ili9488_set_limits(0, 0, ILI9488_DEFAULT_WIDTH,
			ILI9488_DEFAULT_HEIGHT);
}


/**
 * \internal
 * \brief Send display commands to exit standby mode
 *
 * This function is used to exit the display standby mode, which is the default
 * mode after a reset signal to the display.
 */
static void ili9488_exit_standby(void)
{
	ili9488_send_command(ILI9488_CMD_SLEEP_OUT);
	ili9488_deselect_chip();
	delay_ms(150);
	ili9488_send_command(ILI9488_CMD_DISPLAY_ON);
	ili9488_deselect_chip();
}

/**
 * \internal
 * \brief Reset the display using the digital control interface
 *
 * Controls the reset pin of the display controller to reset the display.
 */
static void ili9488_reset_display(void)
{
	ioport_set_pin_level(CONF_ILI9488_RESET_PIN, true);
	delay_ms(10);
	ioport_set_pin_level(CONF_ILI9488_RESET_PIN, false);
	delay_ms(10);
	ioport_set_pin_level(CONF_ILI9488_RESET_PIN, true);
	delay_ms(150);
}

/**
 * \brief Initialize the controller
 *
 * Used to initialize the ILI9488 display controller by setting up the hardware
 * interface, and setting up the controller according to the manufacturer's
 * description. It also set up the screen orientation to the default state
 * (portrait).
 */
void ili9488_init(void)
{
	/* Initialize the communication interface */
	ili9488_interface_init();

	/* Reset the display */
	ili9488_reset_display();

	/* Write all the controller registers with correct values */
	ili9488_controller_init_registers();
	
	/* Send commands to exit standby mode */
	ili9488_exit_standby();
}

/**
 * \brief Sets the orientation of the display data
 *
 * Configures the display for a given orientation, including mirroring and/or
 * screen rotation.
 *
 * \param flags Orientation flags to use, see \ref ILI9488_FLIP_X, \ref ILI9488_FLIP_Y
 *        and \ref ILI9488_SWITCH_XY.
 */
void ili9488_set_orientation(uint8_t flags)
{
	/* Flip X/Y and reverse X orientation and set BGR mode*/
	uint8_t madctl = 0x68;

	/* Pretend the display is in landscape mode by default to match other display drivers */
	//flags ^= ILI9488_SWITCH_XY | ILI9488_FLIP_X;

	if (flags & ILI9488_FLIP_X) {
		madctl &= ~(1 << 6);
	}

	if (flags & ILI9488_FLIP_Y) {
		madctl |= 1 << 7;
	}

	if (flags & ILI9488_SWITCH_XY) {
		madctl &= ~(1 << 5);
	}

	ili9488_send_command(ILI9488_CMD_MEMORY_ACCESS_CONTROL);
	ili9488_send_byte(madctl);
	ili9488_wait_for_send_done();
	ili9488_deselect_chip();
} 

Опять же, как этим воспользоваться - совсем не понимаю.

Понимающие, помогите пожалуйста.