f33dc4df3f
- Add mmap into file_operations and remove it from ioctl definitions. - Add mm_map structure definitions to support future unmapping - Modify all drivers to initialize the operations struct accordingly Signed-off-by: Jukka Laitinen <jukkax@ssrc.tii.ae>
1591 lines
46 KiB
C
1591 lines
46 KiB
C
/****************************************************************************
|
|
* drivers/lcd/ft80x.c
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership. The
|
|
* ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance with the
|
|
* License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*
|
|
****************************************************************************/
|
|
|
|
/* References:
|
|
* - Document No.: FT_000792, "FT800 Embedded Video Engine", Datasheet
|
|
* Version 1.1, Clearance No.: FTDI# 334, Future Technology Devices
|
|
* International Ltd.
|
|
* - Document No.: FT_000986, "FT801 Embedded Video Engine Datasheet",
|
|
* Version 1.0, Clearance No.: FTDI#376, Future Technology Devices
|
|
* International Ltd.
|
|
* - Application Note AN_240AN_240, "FT800 From the Ground Up", Version
|
|
* 1.1, Issue Date: 2014-06-09, Future Technology Devices International
|
|
* Ltd.
|
|
* - "FT800 Series Programmer Guide Guide", Version 2.1, Issue Date:
|
|
* 2016-09-19, Future Technology Devices International Ltd.
|
|
*/
|
|
|
|
/****************************************************************************
|
|
* Included Files
|
|
****************************************************************************/
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
#include <sys/types.h>
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <debug.h>
|
|
|
|
#include <nuttx/arch.h>
|
|
#include <nuttx/semaphore.h>
|
|
#include <nuttx/kmalloc.h>
|
|
#include <nuttx/clock.h>
|
|
#include <nuttx/wqueue.h>
|
|
#include <nuttx/fs/fs.h>
|
|
#include <nuttx/i2c/i2c_master.h>
|
|
#include <nuttx/spi/spi.h>
|
|
#include <nuttx/lcd/lcd.h>
|
|
#include <nuttx/lcd/ft80x.h>
|
|
|
|
#include <arch/irq.h>
|
|
|
|
#include "ft80x.h"
|
|
|
|
#ifdef CONFIG_LCD_FT80X
|
|
|
|
/****************************************************************************
|
|
* Pre-processor Definitions
|
|
****************************************************************************/
|
|
|
|
#define CHIPID 0x7c
|
|
#define ROMID_MASK 0x0000ffff
|
|
#define VERSION_MASK 0xffff0000
|
|
#if defined(CONFIG_LCD_FT800)
|
|
# define DEVNAME "/dev/ft800"
|
|
# define ROM_CHIPID 0x00010008 /* Byte [0:1] Chip ID "0800" BCD
|
|
* Byte [2:3] Version "0100" BCD */
|
|
#elif defined(CONFIG_LCD_FT801)
|
|
# define DEVNAME "/dev/ft801"
|
|
# define ROM_CHIPID 0x00010108 /* Byte [0:1] Chip ID "0801" BCD
|
|
* Byte [2:3] Version "0100" BCD */
|
|
#else
|
|
# error No FT80x device configured
|
|
#endif
|
|
|
|
#define ROMID (ROM_CHIPID & ROMID_MASK)
|
|
#define VERSION (ROM_CHIPID & VERSION_MASK)
|
|
|
|
#define MIN_FADE_DELAY 10 /* Milliseconds */
|
|
#define MAX_FADE_DELAY 16700 /* Milliseconds */
|
|
#define FADE_STEP_MSEC 10 /* Milliseconds */
|
|
|
|
/****************************************************************************
|
|
* Private Function Prototypes
|
|
****************************************************************************/
|
|
|
|
static int ft80x_fade(FAR struct ft80x_dev_s *priv,
|
|
FAR const struct ft80x_fade_s *fade);
|
|
|
|
static void ft80x_notify(FAR struct ft80x_dev_s *priv,
|
|
enum ft80x_notify_e id, int value);
|
|
static void ft80x_interrupt_work(FAR void *arg);
|
|
static int ft80x_interrupt(int irq, FAR void *context, FAR void *arg);
|
|
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
|
|
static void ft80x_destroy(FAR struct ft80x_dev_s *priv);
|
|
#endif
|
|
|
|
/* Character driver methods */
|
|
|
|
static int ft80x_open(FAR struct file *filep);
|
|
static int ft80x_close(FAR struct file *filep);
|
|
|
|
static ssize_t ft80x_read(FAR struct file *filep, FAR char *buffer,
|
|
size_t buflen);
|
|
static ssize_t ft80x_write(FAR struct file *filep, FAR const char *buffer,
|
|
size_t buflen);
|
|
static int ft80x_ioctl(FAR struct file *filep, int cmd, unsigned long arg);
|
|
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
|
|
static int ft80x_unlink(FAR struct inode *inode);
|
|
#endif
|
|
|
|
/* Initialization */
|
|
|
|
static int ft80x_initialize(FAR struct ft80x_dev_s *priv);
|
|
|
|
/****************************************************************************
|
|
* Private Data
|
|
****************************************************************************/
|
|
|
|
static const struct file_operations g_ft80x_fops =
|
|
{
|
|
ft80x_open, /* open */
|
|
ft80x_close, /* close */
|
|
ft80x_read, /* read */
|
|
ft80x_write, /* write */
|
|
NULL, /* seek */
|
|
ft80x_ioctl, /* ioctl */
|
|
NULL, /* truncate */
|
|
NULL, /* mmap */
|
|
NULL /* poll */
|
|
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
|
|
, ft80x_unlink /* unlink */
|
|
#endif
|
|
};
|
|
|
|
/****************************************************************************
|
|
* Private Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: ft80x_fade
|
|
*
|
|
* Description:
|
|
* Change the backlight intensity with a controllable fade.
|
|
*
|
|
****************************************************************************/
|
|
|
|
static int ft80x_fade(FAR struct ft80x_dev_s *priv,
|
|
FAR const struct ft80x_fade_s *fade)
|
|
{
|
|
clock_t start;
|
|
clock_t elapsed;
|
|
int32_t delay;
|
|
int32_t duty;
|
|
int16_t endduty;
|
|
int16_t delta;
|
|
|
|
/* 0% corresponds to the value 0, but 100% corresponds to the value 128 */
|
|
|
|
endduty = (uint16_t)((uint16_t)fade->duty << 7) / 100;
|
|
|
|
/* Get the change in duty from the current to the terminal duty. */
|
|
|
|
duty = (int32_t)(ft80x_read_byte(priv, FT80X_REG_PWM_DUTY) & 0x7f);
|
|
delta = endduty - (int16_t)duty;
|
|
|
|
/* The "smoothness" of the steps will depend on the resolution of the
|
|
* system timer. The minimum delay is <= 2 * system_clock_period.
|
|
*
|
|
* We will try for a FADE_STEP_MSEC delay, but we will try to adapt to
|
|
* whatever we get is we are working close the system time resolution.
|
|
* For human factors reasons, any delay less than 100 MS or so should
|
|
* appear more or less smooth.
|
|
*
|
|
* The delay calculation should never overflow:
|
|
*
|
|
* Max delay: 16,700 msec (MAX_FADE_DELAY)
|
|
* Min clock period: 1 usec
|
|
* Max delay: 16,700,000 ticks
|
|
* INT32_MAX 2,147,483,647
|
|
*/
|
|
|
|
delay = MSEC2TICK((int32_t)fade->delay);
|
|
if (delay <= 0)
|
|
{
|
|
delay = 1;
|
|
}
|
|
|
|
start = clock_systime_ticks();
|
|
|
|
do
|
|
{
|
|
/* Wait for FADE_STEP_MSEC msec (or whatever we get) */
|
|
|
|
nxsig_usleep(FADE_STEP_MSEC * 1000);
|
|
|
|
/* Get the elapsed time */
|
|
|
|
elapsed = clock_systime_ticks() - start;
|
|
if (elapsed > INT32_MAX || (int32_t)elapsed >= delay)
|
|
{
|
|
duty = endduty;
|
|
}
|
|
else
|
|
{
|
|
/* Interpolate to get the next PWM duty in the fade. This
|
|
* calculation should never overflow:
|
|
*
|
|
* Max delta: 128
|
|
* Max elapsed: 16,700,000 ticks
|
|
* Max numerator: 2,137,600,000
|
|
* Min denominator: 1
|
|
* Max duty: 2,137,600,000
|
|
* INT32_MAX 2,147,483,647
|
|
*/
|
|
|
|
duty += ((int32_t)delta * (int32_t)elapsed) / delay;
|
|
if (duty > 128)
|
|
{
|
|
duty = 128;
|
|
}
|
|
else if (duty < 0)
|
|
{
|
|
duty = 0;
|
|
}
|
|
}
|
|
|
|
/* The set the new backlight PWM duty */
|
|
|
|
ft80x_write_byte(priv, FT80X_REG_PWM_DUTY, (uint8_t)duty);
|
|
}
|
|
while (duty != endduty);
|
|
|
|
return OK;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: ft80x_notify
|
|
*
|
|
* Description:
|
|
* Notify any registered client of the FT80x event
|
|
*
|
|
****************************************************************************/
|
|
|
|
static void ft80x_notify(FAR struct ft80x_dev_s *priv,
|
|
enum ft80x_notify_e id, int value)
|
|
{
|
|
FAR struct ft80x_eventinfo_s *info = &priv->notify[id];
|
|
|
|
/* Are notifications enabled for this event? */
|
|
|
|
if (info->enable)
|
|
{
|
|
DEBUGASSERT(info->pid > 0);
|
|
|
|
/* Yes.. Signal the client */
|
|
|
|
info->event.sigev_value.sival_int = value;
|
|
nxsig_notification(info->pid, &info->event, SI_QUEUE, &info->work);
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: ft80x_interrupt_work
|
|
*
|
|
* Description:
|
|
* Back end handling for FT80x interrupts
|
|
*
|
|
****************************************************************************/
|
|
|
|
static void ft80x_interrupt_work(FAR void *arg)
|
|
{
|
|
FAR struct ft80x_dev_s *priv = (FAR struct ft80x_dev_s *)arg;
|
|
uint32_t intflags;
|
|
uint32_t regval;
|
|
|
|
DEBUGASSERT(priv != NULL);
|
|
|
|
/* Get exclusive access to the device structures */
|
|
|
|
nxmutex_lock(&priv->lock);
|
|
|
|
/* Get the set of pending interrupts. Note that simply reading this
|
|
* register is sufficient to clear all pending interrupts.
|
|
*/
|
|
|
|
intflags = ft80x_read_word(priv, FT80X_REG_INT_FLAGS);
|
|
|
|
/* And process each pending interrupt.
|
|
*
|
|
* REVISIT: No interrupt sources are ever enabled in the current
|
|
* implementation.
|
|
*/
|
|
|
|
if ((intflags & FT80X_INT_SWAP) != 0)
|
|
{
|
|
/* Display swap occurred */
|
|
|
|
lcdinfo("Display swap occurred\n");
|
|
ft80x_notify(priv, FT80X_NOTIFY_SWAP, 0);
|
|
}
|
|
|
|
if ((intflags & FT80X_INT_TOUCH) != 0)
|
|
{
|
|
/* Touch-screen touch detected */
|
|
|
|
lcdinfo("Touch-screen touch detected\n");
|
|
ft80x_notify(priv, FT80X_NOTIFY_TOUCH, 0);
|
|
}
|
|
|
|
if ((intflags & FT80X_INT_TAG) != 0)
|
|
{
|
|
/* Touch-screen tag value change */
|
|
|
|
lcdinfo("Touch-screen tag value change\n");
|
|
#ifdef CONFIG_LCD_FT800
|
|
regval = ft80x_read_word(priv, FT80X_REG_TOUCH_TAG);
|
|
#else
|
|
regval = ft80x_read_word(priv, FT80X_REG_CTOUCH_TAG);
|
|
#endif
|
|
ft80x_notify(priv, FT80X_NOTIFY_TAG, (int)(regval & TOUCH_TAG_MASK));
|
|
}
|
|
|
|
if ((intflags & FT80X_INT_SOUND) != 0)
|
|
{
|
|
/* Sound effect ended */
|
|
|
|
lcdinfo(" Sound effect ended\n");
|
|
ft80x_notify(priv, FT80X_NOTIFY_SOUND, 0);
|
|
}
|
|
|
|
if ((intflags & FT80X_INT_PLAYBACK) != 0)
|
|
{
|
|
/* Audio playback ended */
|
|
|
|
lcdinfo("Audio playback ended\n");
|
|
ft80x_notify(priv, FT80X_NOTIFY_PLAYBACK, 0);
|
|
}
|
|
|
|
if ((intflags & FT80X_INT_CMDEMPTY) != 0)
|
|
{
|
|
/* Command FIFO empty */
|
|
|
|
lcdinfo("Command FIFO empty\n");
|
|
ft80x_notify(priv, FT80X_NOTIFY_CMDEMPTY, 0);
|
|
}
|
|
|
|
if ((intflags & FT80X_INT_CMDFLAG) != 0)
|
|
{
|
|
/* Command FIFO flag */
|
|
|
|
lcdinfo("Command FIFO flag\n");
|
|
ft80x_notify(priv, FT80X_NOTIFY_CMDFLAG, 0);
|
|
}
|
|
|
|
if ((intflags & FT80X_INT_CONVCOMPLETE) != 0)
|
|
{
|
|
/* Touch-screen conversions completed */
|
|
|
|
lcdinfo(" Touch-screen conversions completed\n");
|
|
ft80x_notify(priv, FT80X_NOTIFY_CONVCOMPLETE, 0);
|
|
}
|
|
|
|
/* Re-enable interrupts */
|
|
|
|
DEBUGASSERT(priv->lower != NULL && priv->lower->enable != NULL);
|
|
priv->lower->enable(priv->lower, true);
|
|
nxmutex_unlock(&priv->lock);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: ft80x_interrupt
|
|
*
|
|
* Description:
|
|
* FT80x interrupt handler
|
|
*
|
|
****************************************************************************/
|
|
|
|
static int ft80x_interrupt(int irq, FAR void *context, FAR void *arg)
|
|
{
|
|
FAR struct ft80x_dev_s *priv = (FAR struct ft80x_dev_s *)arg;
|
|
|
|
DEBUGASSERT(priv != NULL);
|
|
|
|
/* Perform the interrupt work on the high priority work queue. */
|
|
|
|
work_queue(HPWORK, &priv->intwork, ft80x_interrupt_work, priv, 0);
|
|
|
|
/* Disable further interrupts for the GPIO interrupt source.
|
|
* REVISIT: This assumes that GPIO interrupts will pend until re-enabled.
|
|
* In certain implementations, that assumption is not true and could cause
|
|
* a loss of interrupts.
|
|
*/
|
|
|
|
DEBUGASSERT(priv->lower != NULL && priv->lower->enable != NULL);
|
|
priv->lower->enable(priv->lower, false);
|
|
return OK;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: ft80x_destroy
|
|
*
|
|
* Description:
|
|
* The driver has been unlinked... clean up as best we can.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
|
|
static void ft80x_destroy(FAR struct ft80x_dev_s *priv)
|
|
{
|
|
/* If the lower half driver provided a destroy method, then call that
|
|
* method now in order order to clean up resources used by the lower-half
|
|
* driver.
|
|
*/
|
|
|
|
DEBUGASSERT(priv != NULL && priv->lower != NULL);
|
|
if (priv->lower->destroy != NULL)
|
|
{
|
|
priv->lower->destroy(priv->lower);
|
|
}
|
|
|
|
/* Then free our container */
|
|
|
|
nxmutex_destroy(&priv->lock);
|
|
kmm_free(priv);
|
|
}
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Name: ft80x_open
|
|
*
|
|
* Description:
|
|
* This function is called whenever the PWM device is opened.
|
|
*
|
|
****************************************************************************/
|
|
|
|
static int ft80x_open(FAR struct file *filep)
|
|
{
|
|
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
|
|
FAR struct inode *inode;
|
|
FAR struct ft80x_dev_s *priv;
|
|
uint8_t tmp;
|
|
int ret;
|
|
|
|
DEBUGASSERT(filep != NULL);
|
|
inode = filep->f_inode;
|
|
DEBUGASSERT(inode != NULL && inode->i_private != NULL);
|
|
priv = inode->i_private;
|
|
|
|
lcdinfo("crefs: %d\n", priv->crefs);
|
|
|
|
/* Get exclusive access to the device structures */
|
|
|
|
ret = nxmutex_lock(&priv->lock);
|
|
if (ret < 0)
|
|
{
|
|
goto errout;
|
|
}
|
|
|
|
/* Increment the count of references to the device */
|
|
|
|
tmp = priv->crefs + 1;
|
|
if (tmp == 0)
|
|
{
|
|
/* More than 255 opens; uint8_t overflows to zero */
|
|
|
|
ret = -EMFILE;
|
|
goto errout_with_lock;
|
|
}
|
|
|
|
/* Save the new open count */
|
|
|
|
priv->crefs = tmp;
|
|
ret = OK;
|
|
|
|
errout_with_lock:
|
|
nxmutex_unlock(&priv->lock);
|
|
|
|
errout:
|
|
return ret;
|
|
#else
|
|
return OK;
|
|
#endif
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: ft80x_close
|
|
*
|
|
* Description:
|
|
* This function is called when the PWM device is closed.
|
|
*
|
|
****************************************************************************/
|
|
|
|
static int ft80x_close(FAR struct file *filep)
|
|
{
|
|
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
|
|
FAR struct inode *inode;
|
|
FAR struct ft80x_dev_s *priv;
|
|
int ret;
|
|
|
|
DEBUGASSERT(filep != NULL);
|
|
inode = filep->f_inode;
|
|
DEBUGASSERT(inode != NULL && inode->i_private != NULL);
|
|
priv = inode->i_private;
|
|
|
|
lcdinfo("crefs: %d\n", priv->crefs);
|
|
|
|
/* Get exclusive access to the device structures */
|
|
|
|
ret = nxmutex_lock(&priv->lock);
|
|
if (ret < 0)
|
|
{
|
|
goto errout;
|
|
}
|
|
|
|
/* Will the count decrement to zero? */
|
|
|
|
if (priv->crefs <= 1)
|
|
{
|
|
/* Yes.. if the driver has been unlinked, then we need to destroy the
|
|
* driver instance.
|
|
*/
|
|
|
|
priv->crefs = 0;
|
|
if (priv->unlinked)
|
|
{
|
|
nxmutex_unlock(&priv->lock);
|
|
ft80x_destroy(priv);
|
|
return OK;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* NO.. decrement the number of references to the driver. */
|
|
|
|
priv->crefs--;
|
|
}
|
|
|
|
ret = OK;
|
|
nxmutex_unlock(&priv->lock);
|
|
|
|
errout:
|
|
return ret;
|
|
#else
|
|
return OK;
|
|
#endif
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: ft80x_read
|
|
****************************************************************************/
|
|
|
|
static ssize_t ft80x_read(FAR struct file *filep, FAR char *buffer,
|
|
size_t len)
|
|
{
|
|
/* Reading from the FT80X is an undefined operation and not support */
|
|
|
|
lcdinfo("buffer: %p len %lu\n", buffer, (unsigned long)len);
|
|
return 0; /* Return EOF */
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: ft80x_write
|
|
****************************************************************************/
|
|
|
|
static ssize_t ft80x_write(FAR struct file *filep, FAR const char *buffer,
|
|
size_t len)
|
|
{
|
|
FAR struct inode *inode;
|
|
FAR struct ft80x_dev_s *priv;
|
|
int ret;
|
|
|
|
lcdinfo("buffer: %p len %lu\n", buffer, (unsigned long)len);
|
|
DEBUGASSERT(buffer != NULL && ((uintptr_t)buffer & 3) == 0 &&
|
|
len > 0 && (len & 3) == 0 && len <= FT80X_RAM_DL_SIZE);
|
|
|
|
DEBUGASSERT(filep != NULL);
|
|
inode = filep->f_inode;
|
|
DEBUGASSERT(inode != NULL && inode->i_private != NULL);
|
|
priv = inode->i_private;
|
|
|
|
if (buffer == NULL || ((uintptr_t)buffer & 3) != 0 ||
|
|
len == 0 || (len & 3) != 0 || (len + filep->f_pos) > FT80X_RAM_DL_SIZE)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* Get exclusive access to the device structures */
|
|
|
|
ret = nxmutex_lock(&priv->lock);
|
|
if (ret < 0)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
/* Note that there is no check if the driver was opened read-only. That
|
|
* would be a silly thing to do.
|
|
*/
|
|
|
|
/* The write method is functionally equivalent to the FT80X_IOC_CREATEDL
|
|
* IOCTL command: It simply copies the display list in the user buffer to
|
|
* the FT80x display list memory.
|
|
*/
|
|
|
|
ft80x_write_memory(priv, FT80X_RAM_DL + filep->f_pos, buffer, len);
|
|
filep->f_pos += len;
|
|
|
|
nxmutex_unlock(&priv->lock);
|
|
return len;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: ft80x_ioctl
|
|
*
|
|
* Description:
|
|
* The standard ioctl method. This is where ALL of the PWM work is done.
|
|
*
|
|
****************************************************************************/
|
|
|
|
static int ft80x_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
|
|
{
|
|
FAR struct inode *inode;
|
|
FAR struct ft80x_dev_s *priv;
|
|
int ret;
|
|
|
|
DEBUGASSERT(filep != NULL);
|
|
inode = filep->f_inode;
|
|
DEBUGASSERT(inode != NULL && inode->i_private != NULL);
|
|
priv = inode->i_private;
|
|
|
|
lcdinfo("cmd: %d arg: %lu\n", cmd, arg);
|
|
|
|
/* Get exclusive access to the device structures */
|
|
|
|
ret = nxmutex_lock(&priv->lock);
|
|
if (ret < 0)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
/* Handle built-in ioctl commands */
|
|
|
|
switch (cmd)
|
|
{
|
|
/* FT80X_IOC_CREATEDL:
|
|
* Description: Write a display list to the FT80x display list
|
|
* memory
|
|
* Description: Write a display list to the FT80x display list
|
|
* memory starting at offset zero. This may or may
|
|
* not be the entire display list. Display lists may
|
|
* be created incrementally, starting with
|
|
* FT80X_IOC_CREATEDL and finishing the display list
|
|
* using FT80XIO_APPENDDL
|
|
* Argument: A reference to a display list structure instance.
|
|
* See struct ft80x_displaylist_s.
|
|
* Returns: None
|
|
*/
|
|
|
|
case FT80X_IOC_CREATEDL:
|
|
|
|
/* Set the file position to zero and fall through to "append" the new
|
|
* display list data at offset 0.
|
|
*/
|
|
|
|
filep->f_pos = 0;
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
/* FT80X_IOC_APPENDDL:
|
|
* Description: Write additional display list entries to the FT80x
|
|
* display list memory at the current display list
|
|
* offset. This IOCTL command permits display lists
|
|
* to be completed incrementally, starting with
|
|
* FT80X_IOC_CREATEDL and finishing the display list
|
|
* using FT80XIO_APPENDDL.
|
|
* Argument: A reference to a display list structure instance.
|
|
* See struct ft80x_displaylist_s.
|
|
* Returns: None
|
|
*/
|
|
|
|
case FT80X_IOC_APPENDDL:
|
|
{
|
|
FAR struct ft80x_displaylist_s *dl =
|
|
(FAR struct ft80x_displaylist_s *)((uintptr_t)arg);
|
|
|
|
if (dl == NULL || ((uintptr_t)&dl->cmd & 3) != 0 ||
|
|
(dl->dlsize & 3) != 0 ||
|
|
dl->dlsize + filep->f_pos > FT80X_RAM_DL_SIZE)
|
|
{
|
|
ret = -EINVAL;
|
|
}
|
|
else
|
|
{
|
|
/* Check if there is a display list. It might be useful for
|
|
* the application to issue FT80X_IOC_CREATEDL with no data in
|
|
* order to initialize the display list, then form all of the
|
|
* list entries with FT80X_IOC_APPENDDL.
|
|
*/
|
|
|
|
if (dl->dlsize > 0)
|
|
{
|
|
/* This IOCTL command simply copies the display list
|
|
* provided into the FT80x display list memory.
|
|
*/
|
|
|
|
ft80x_write_memory(priv, FT80X_RAM_DL + filep->f_pos,
|
|
&dl->cmd, dl->dlsize);
|
|
filep->f_pos += dl->dlsize;
|
|
}
|
|
|
|
ret = OK;
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* FT80X_IOC_GETRAMDL:
|
|
* Description: Read a 32-bit value from the display list.
|
|
* Argument: A reference to an instance of struct ft80x_relmem_s.
|
|
* Returns: The 32-bit value read from the display list.
|
|
*/
|
|
|
|
case FT80X_IOC_GETRAMDL:
|
|
{
|
|
FAR struct ft80x_relmem_s *ramdl =
|
|
(FAR struct ft80x_relmem_s *)((uintptr_t)arg);
|
|
|
|
if (ramdl == NULL || ((uintptr_t)ramdl->offset & 3) != 0 ||
|
|
ramdl->offset >= FT80X_RAM_DL_SIZE)
|
|
{
|
|
ret = -EINVAL;
|
|
}
|
|
else
|
|
{
|
|
ft80x_read_memory(priv, FT80X_RAM_DL + ramdl->offset,
|
|
ramdl->value, ramdl->nbytes);
|
|
ret = OK;
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* FT80X_IOC_PUTRAMG
|
|
* Description: Write byte data to FT80x graphics memory (RAM_G)
|
|
* Argument: A reference to an instance of struct ft80x_relmem_s.
|
|
* Returns: None.
|
|
*/
|
|
|
|
case FT80X_IOC_PUTRAMG:
|
|
{
|
|
FAR struct ft80x_relmem_s *ramg =
|
|
(FAR struct ft80x_relmem_s *)((uintptr_t)arg);
|
|
|
|
if (ramg == NULL ||
|
|
(ramg->offset + ramg->nbytes) >= FT80X_RAM_G_SIZE)
|
|
{
|
|
ret = -EINVAL;
|
|
}
|
|
else
|
|
{
|
|
ft80x_write_memory(priv, FT80X_RAM_G + ramg->offset,
|
|
ramg->value, ramg->nbytes);
|
|
ret = OK;
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* FT80X_IOC_PUTRAMCMD
|
|
* Description: Write 32-bit aligned data to FT80x FIFO (RAM_CMD)
|
|
* Argument: A reference to an instance of struct ft80x_relmem_s.
|
|
* Returns: None.
|
|
*/
|
|
|
|
case FT80X_IOC_PUTRAMCMD:
|
|
{
|
|
FAR struct ft80x_relmem_s *ramcmd =
|
|
(FAR struct ft80x_relmem_s *)((uintptr_t)arg);
|
|
|
|
if (ramcmd == NULL || ((uintptr_t)ramcmd->offset & 3) != 0)
|
|
{
|
|
ret = -EINVAL;
|
|
}
|
|
else
|
|
{
|
|
ft80x_write_memory(priv, FT80X_RAM_CMD + ramcmd->offset,
|
|
ramcmd->value, ramcmd->nbytes);
|
|
ret = OK;
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* FT80X_IOC_GETREG8:
|
|
* Description: Read an 8-bit register value from the FT80x.
|
|
* Argument: A reference to an instance of struct
|
|
* ft80x_register_s.
|
|
* Returns: The 8-bit value read from the register.
|
|
*/
|
|
|
|
case FT80X_IOC_GETREG8:
|
|
{
|
|
FAR struct ft80x_register_s *reg =
|
|
(FAR struct ft80x_register_s *)((uintptr_t)arg);
|
|
|
|
if (reg == NULL || ((uintptr_t)reg->addr & 3) != 0)
|
|
{
|
|
ret = -EINVAL;
|
|
}
|
|
else
|
|
{
|
|
reg->value.u8 = ft80x_read_byte(priv, reg->addr);
|
|
ret = OK;
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* FT80X_IOC_GETREG16:
|
|
* Description: Read a 16-bit register value from the FT80x.
|
|
* Argument: A reference to an instance of struct
|
|
* ft80x_register_s.
|
|
* Returns: The 16-bit value read from the register.
|
|
*/
|
|
|
|
case FT80X_IOC_GETREG16:
|
|
{
|
|
FAR struct ft80x_register_s *reg =
|
|
(FAR struct ft80x_register_s *)((uintptr_t)arg);
|
|
|
|
if (reg == NULL || ((uintptr_t)reg->addr & 3) != 0)
|
|
{
|
|
ret = -EINVAL;
|
|
}
|
|
else
|
|
{
|
|
reg->value.u16 = ft80x_read_hword(priv, reg->addr);
|
|
ret = OK;
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* FT80X_IOC_GETREG32:
|
|
* Description: Read a 32-bit register value from the FT80x.
|
|
* Argument: A reference to an instance of struct
|
|
* ft80x_register_s.
|
|
* Returns: The 32-bit value read from the register.
|
|
*/
|
|
|
|
case FT80X_IOC_GETREG32:
|
|
{
|
|
FAR struct ft80x_register_s *reg =
|
|
(FAR struct ft80x_register_s *)((uintptr_t)arg);
|
|
|
|
if (reg == NULL || ((uintptr_t)reg->addr & 3) != 0)
|
|
{
|
|
ret = -EINVAL;
|
|
}
|
|
else
|
|
{
|
|
reg->value.u32 = ft80x_read_word(priv, reg->addr);
|
|
ret = OK;
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* FT80X_IOC_GETREGS:
|
|
* Description: Read multiple 32-bit register values from the FT80x.
|
|
* Argument: A reference to an instance of struct
|
|
* ft80x_registers_s.
|
|
* Returns: The 32-bit values read from the consecutive
|
|
* registers .
|
|
*/
|
|
|
|
case FT80X_IOC_GETREGS:
|
|
{
|
|
FAR struct ft80x_registers_s *regs =
|
|
(FAR struct ft80x_registers_s *)((uintptr_t)arg);
|
|
|
|
if (regs == NULL || ((uintptr_t)regs->addr & 3) != 0)
|
|
{
|
|
ret = -EINVAL;
|
|
}
|
|
else
|
|
{
|
|
ft80x_read_memory(priv, regs->addr, regs->value,
|
|
(size_t)regs->nregs << 2);
|
|
ret = OK;
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* FT80X_IOC_PUTREG8:
|
|
* Description: Write an 8-bit register value to the FT80x.
|
|
* Argument: A reference to an instance of struct
|
|
* ft80x_register_s.
|
|
* Returns: None.
|
|
*/
|
|
|
|
case FT80X_IOC_PUTREG8:
|
|
{
|
|
FAR struct ft80x_register_s *reg =
|
|
(FAR struct ft80x_register_s *)((uintptr_t)arg);
|
|
|
|
if (reg == NULL || ((uintptr_t)reg->addr & 3) != 0)
|
|
{
|
|
ret = -EINVAL;
|
|
}
|
|
else
|
|
{
|
|
ft80x_write_byte(priv, reg->addr, reg->value.u8);
|
|
ret = OK;
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* FT80X_IOC_PUTREG16:
|
|
* Description: Write a 16-bit register value to the FT80x.
|
|
* Argument: A reference to an instance of struct
|
|
* ft80x_register_s.
|
|
* Returns: None.
|
|
*/
|
|
|
|
case FT80X_IOC_PUTREG16:
|
|
{
|
|
FAR struct ft80x_register_s *reg =
|
|
(FAR struct ft80x_register_s *)((uintptr_t)arg);
|
|
|
|
if (reg == NULL || ((uintptr_t)reg->addr & 3) != 0)
|
|
{
|
|
ret = -EINVAL;
|
|
}
|
|
else
|
|
{
|
|
ft80x_write_hword(priv, reg->addr, reg->value.u16);
|
|
ret = OK;
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* FT80X_IOC_PUTREG32:
|
|
* Description: Write a 32-bit register value to the FT80x.
|
|
* Argument: A reference to an instance of struct
|
|
* ft80x_register_s.
|
|
* Returns: None.
|
|
*/
|
|
|
|
case FT80X_IOC_PUTREG32:
|
|
{
|
|
FAR struct ft80x_register_s *reg =
|
|
(FAR struct ft80x_register_s *)((uintptr_t)arg);
|
|
|
|
if (reg == NULL || ((uintptr_t)reg->addr & 3) != 0)
|
|
{
|
|
ret = -EINVAL;
|
|
}
|
|
else
|
|
{
|
|
ft80x_write_word(priv, reg->addr, reg->value.u32);
|
|
ret = OK;
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* FT80X_IOC_PUTREGS:
|
|
* Description: Write multiple 32-bit register values to the FT80x.
|
|
* Argument: A reference to an instance of struct
|
|
* ft80x_registers_s.
|
|
* Returns: None.
|
|
*/
|
|
|
|
case FT80X_IOC_PUTREGS:
|
|
{
|
|
FAR struct ft80x_registers_s *regs =
|
|
(FAR struct ft80x_registers_s *)((uintptr_t)arg);
|
|
|
|
if (regs == NULL || ((uintptr_t)regs->addr & 3) != 0)
|
|
{
|
|
ret = -EINVAL;
|
|
}
|
|
else
|
|
{
|
|
ft80x_write_memory(priv, regs->addr, regs->value,
|
|
(size_t)regs->nregs << 2);
|
|
ret = OK;
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* FT80X_IOC_EVENTNOTIFY:
|
|
* Description: Setup to receive a signal when an event occurs.
|
|
* Argument: A reference to an instance of struct ft80x_notify_s.
|
|
* Returns: None
|
|
*/
|
|
|
|
case FT80X_IOC_EVENTNOTIFY:
|
|
{
|
|
FAR struct ft80x_notify_s *notify =
|
|
(FAR struct ft80x_notify_s *)((uintptr_t)arg);
|
|
|
|
if (notify == NULL || notify->pid < 0 ||
|
|
(unsigned int)notify->id >= FT80X_INT_NEVENTS)
|
|
{
|
|
ret = -EINVAL;
|
|
}
|
|
else
|
|
{
|
|
FAR struct ft80x_eventinfo_s *info = &priv->notify[notify->id];
|
|
uint32_t regval;
|
|
|
|
/* Are we enabling or disabling */
|
|
|
|
if (notify->enable)
|
|
{
|
|
/* Make sure that arguments are valid for the enable */
|
|
|
|
if (notify->pid == 0)
|
|
{
|
|
ret = -EINVAL;
|
|
}
|
|
else
|
|
{
|
|
/* Setup the new notification information */
|
|
|
|
info->event = notify->event;
|
|
info->pid = notify->pid;
|
|
info->enable = true;
|
|
|
|
/* Enable interrupts associated with the event */
|
|
|
|
regval = ft80x_read_word(priv, FT80X_REG_INT_MASK);
|
|
regval |= (1 << notify->id);
|
|
ft80x_write_word(priv, FT80X_REG_INT_MASK, regval);
|
|
ret = OK;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Disable the notification */
|
|
|
|
info->pid = 0;
|
|
info->enable = false;
|
|
|
|
/* Disable interrupts associated with the event */
|
|
|
|
regval = ft80x_read_word(priv, FT80X_REG_INT_MASK);
|
|
regval &= ~(1 << notify->id);
|
|
ft80x_write_word(priv, FT80X_REG_INT_MASK, regval);
|
|
|
|
/* Cancel any pending notification */
|
|
|
|
nxsig_cancel_notification(&info->work);
|
|
ret = OK;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* FT80X_IOC_FADE:
|
|
* Description: Change the backlight intensity with a controllable
|
|
* fade.
|
|
* Argument: A reference to an instance of struct ft80x_fade_s.
|
|
* Returns: None.
|
|
*/
|
|
|
|
case FT80X_IOC_FADE:
|
|
{
|
|
FAR const struct ft80x_fade_s *fade =
|
|
(FAR const struct ft80x_fade_s *)((uintptr_t)arg);
|
|
|
|
if (fade == NULL || fade->duty > 100 ||
|
|
fade->delay < MIN_FADE_DELAY || fade->delay > MAX_FADE_DELAY)
|
|
{
|
|
ret = -EINVAL;
|
|
}
|
|
else
|
|
{
|
|
ret = ft80x_fade(priv, fade);
|
|
}
|
|
}
|
|
break;
|
|
|
|
/* FT80X_IOC_AUDIO:
|
|
* Description: Enable/disable an external audio amplifier.
|
|
* Argument: 0=disable; 1=enable.
|
|
* Returns: None.
|
|
*/
|
|
|
|
case FT80X_IOC_AUDIO:
|
|
{
|
|
#if defined(CONFIG_LCD_FT80X_AUDIO_MCUSHUTDOWN)
|
|
/* Amplifier is controlled by an MCU GPIO pin */
|
|
|
|
DEBUGASSERT(priv->lower->attach != NULL &&
|
|
priv->lower->audio != NULL);
|
|
DEBUGASSERT(arg == 0 || arg == 1);
|
|
|
|
priv->lower->audio(priv->lower, (arg != 0));
|
|
ret = OK;
|
|
|
|
#elif defined(CONFIG_LCD_FT80X_AUDIO_GPIOSHUTDOWN)
|
|
/* Amplifier is controlled by an FT80x GPIO pin */
|
|
|
|
uint8_t regval8;
|
|
|
|
DEBUGASSERT(arg == 0 || arg == 1);
|
|
|
|
regval8 = ft80x_read_byte(priv, FT80X_REG_GPIO);
|
|
|
|
/* Active low logic assumed */
|
|
|
|
if (arg == 0)
|
|
{
|
|
regval8 |= (1 << CONFIG_LCD_FT80X_AUDIO_GPIO);
|
|
}
|
|
else
|
|
{
|
|
regval8 &= ~(1 << CONFIG_LCD_FT80X_AUDIO_GPIO);
|
|
}
|
|
|
|
ft80x_write_byte(priv, FT80X_REG_GPIO, regval8);
|
|
ret = OK;
|
|
|
|
#else
|
|
/* Amplifier is not controllable. */
|
|
|
|
DEBUGASSERT(arg == 0 || arg == 1);
|
|
return OK;
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
/* Unrecognized IOCTL command */
|
|
|
|
default:
|
|
lcderr("ERROR: Unrecognized cmd: %d arg: %ld\n", cmd, arg);
|
|
ret = -ENOTTY;
|
|
break;
|
|
}
|
|
|
|
nxmutex_unlock(&priv->lock);
|
|
return ret;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: ft80x_unlink
|
|
****************************************************************************/
|
|
|
|
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
|
|
static int ft80x_unlink(FAR struct inode *inode)
|
|
{
|
|
FAR struct ft80x_dev_s *priv;
|
|
|
|
/* Get the reference to our internal state structure from the inode
|
|
* structure.
|
|
*/
|
|
|
|
DEBUGASSERT(inode && inode->i_private);
|
|
priv = inode->i_private;
|
|
|
|
/* Indicate that the driver has been unlinked */
|
|
|
|
priv->unlinked = true;
|
|
|
|
/* If there are no further open references to the driver, then commit
|
|
* Hara-Kiri now.
|
|
*/
|
|
|
|
if (priv->crefs == 0)
|
|
{
|
|
ft80x_destroy(priv);
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Name: ft80x_initialize
|
|
*
|
|
* Description:
|
|
* Initialize the FT80x
|
|
*
|
|
****************************************************************************/
|
|
|
|
static int ft80x_initialize(FAR struct ft80x_dev_s *priv)
|
|
{
|
|
uint32_t timeout;
|
|
uint32_t regval32;
|
|
uint8_t regval8;
|
|
|
|
/* To configure the display, load the timing control registers with values
|
|
* for the particular display. These registers control horizontal timing:
|
|
*
|
|
* - FT80X_REG_PCLK
|
|
* - FT80X_REG_PCLK_POL
|
|
* - FT80X_REG_HCYCLE
|
|
* - FT80X_REG_HOFFSET
|
|
* - FT80X_REG_HSIZE
|
|
* - FT80X_REG_HSYNC0
|
|
* - FT80X_REG_HSYNC1
|
|
*
|
|
* These registers control vertical timing:
|
|
*
|
|
* - FT80X_REG_VCYCLE
|
|
* - FT80X_REG_VOFFSET
|
|
* - FT80X_REG_VSIZE
|
|
* - FT80X_REG_VSYNC0
|
|
* - FT80X_REG_VSYNC1
|
|
*
|
|
* And the FT80X_REG_CSPREAD register changes color clock timing to reduce
|
|
* system noise.
|
|
*
|
|
* GPIO bit 7 is used for the display enable pin of the LCD module. By
|
|
* setting the direction of the GPIO bit to out direction, the display can
|
|
* be enabled by writing value of 1 into GPIO bit 7 or the display can be
|
|
* disabled by writing a value of 0 into GPIO bit 7. By default GPIO bit 7
|
|
* direction is output and the value is 0.
|
|
*/
|
|
|
|
/* Initialization Sequence from Power Down using PD_N pin:
|
|
*
|
|
* 1. Drive the PD_N pin high
|
|
* 2. Wait for at least 20ms
|
|
* 3. Execute "Initialization Sequence during the Boot up" from steps 1
|
|
* to 9
|
|
*
|
|
* Initialization Sequence from Sleep Mode:
|
|
*
|
|
* 1. Send Host command "ACTIVE" to enable clock to FT800
|
|
* 2. Wait for at least 20ms
|
|
* 3. Execute "Initialization Sequence during Boot Up" from steps 5 to 8
|
|
*
|
|
* Initialization sequence from standby mode:
|
|
*
|
|
* Execute all the steps mentioned in "Initialization Sequence from Sleep
|
|
* Mode" except waiting for at least 20ms in step 2.
|
|
*/
|
|
|
|
DEBUGASSERT(priv->lower != NULL && priv->lower->pwrdown != NULL);
|
|
priv->lower->pwrdown(priv->lower, false);
|
|
up_mdelay(20);
|
|
|
|
/* Initialization Sequence during the boot up:
|
|
*
|
|
* 1. Use MCU SPI clock not more than 11MHz
|
|
* 2. Send Host command CLKEXT to FT800 to enable PLL input from oscillator
|
|
* or external clock. Should default to 48MHz PLL output.
|
|
* 3. Send Host command ACTIVE to enable clock and wake up the FT80x.
|
|
* 4. Configure video timing registers, except FT80X_REG_PCLK
|
|
* 5. Write first display list
|
|
* 6. Write FT80X_REG_DLSWAP, FT800 swaps display list immediately
|
|
* 7. Enable back light control for display
|
|
* 8. Write FT80X_REG_PCLK, video output begins with the first display list
|
|
* 9. Use MCU SPI clock not more than 30MHz
|
|
*/
|
|
|
|
/* 1. Select the initial SPI frequency */
|
|
|
|
DEBUGASSERT(priv->lower->init_frequency <= 11000000);
|
|
priv->frequency = priv->lower->init_frequency;
|
|
|
|
/* 2. Send Host command CLKEXT to FT800 to enable PLL input from oscillator
|
|
* or external clock.
|
|
*/
|
|
|
|
ft80x_host_command(priv, FT80X_CMD_CLKEXT);
|
|
up_mdelay(10);
|
|
|
|
#if 0 /* Un-necessary? */
|
|
/* Switch PLL output to 48MHz (should be the default) */
|
|
|
|
ft80x_host_command(priv, FT80X_CMD_CLK48M);
|
|
up_mdelay(10);
|
|
#endif
|
|
|
|
/* 3. Send Host command ACTIVE to enable clock and wake up the FT80x. */
|
|
|
|
ft80x_host_command(priv, FT80X_CMD_ACTIVE);
|
|
up_mdelay(10);
|
|
|
|
#if 0 /* Un-necessary? */
|
|
/* Do a core reset for safer */
|
|
|
|
ft80x_host_command(priv, FT80X_CMD_CORERST);
|
|
#endif
|
|
|
|
/* Verify the chip ID. Read repeatedly until FT80x is ready. */
|
|
|
|
timeout = 0;
|
|
for (; ; )
|
|
{
|
|
/* Read the Chip ID */
|
|
|
|
regval8 = ft80x_read_byte(priv, FT80X_REG_ID);
|
|
if (regval8 == CHIPID)
|
|
{
|
|
/* Chip ID verify so FT80x is ready */
|
|
|
|
break;
|
|
}
|
|
|
|
/* Initial Chip ID read may fail because the chip is not yet ready. */
|
|
|
|
if (++timeout > 100000)
|
|
{
|
|
lcderr("ERROR: Bad chip ID: %02x\n", regval8);
|
|
return -ENODEV;
|
|
}
|
|
}
|
|
|
|
regval32 = ft80x_read_word(priv, FT80X_ROM_CHIPID);
|
|
if ((regval32 & ROMID_MASK) != ROMID)
|
|
{
|
|
lcderr("ERROR: Bad ROM chip ID: %08lx\n", (unsigned long)regval32);
|
|
return -ENODEV;
|
|
}
|
|
|
|
/* 4. Configure video timing registers, except FT80X_REG_PCLK
|
|
*
|
|
* Once the FT800 is awake and the internal clock set and Device ID
|
|
* checked, the next task is to configure the LCD display parameters for
|
|
* the chosen display with the values determined in Section 2.3.3 above.
|
|
*
|
|
* a. Set FT80X_REG_PCLK to zero - This disables the pixel clock output
|
|
* while the LCD and other system parameters are configured
|
|
* b. Set the following registers with values for the chosen display.
|
|
* Typical WQVGA and QVGA values are shown:
|
|
*
|
|
* Register Description WQVGA QVGA
|
|
* 480x272 320x240
|
|
* FT80X_REG_PCLK_POL Pixel Clock Polarity 1 0
|
|
* FT80X_REG_HSIZE Image width in pixels 480 320
|
|
* FT80X_REG_HCYCLE Total number of clocks per line 548 408
|
|
* FT80X_REG_HOFFSET Horizontal image start 43 70
|
|
* (pixels from left)
|
|
* FT80X_REG_HSYNC0 Start of HSYNC pulse 0 0
|
|
* (falling edge)
|
|
* FT80X_REG_HSYNC1 End of HSYNC pulse 41 10
|
|
* (rising edge)
|
|
* FT80X_REG_VSIZE Image height in pixels 272 240
|
|
* FT80X_REG_VCYCLE Total number of lines per screen 292 263
|
|
* FT80X_REG_VOFFSET Vertical image start 12 13
|
|
* (lines from top)
|
|
* FT80X_REG_VSYNC0 Start of VSYNC pulse 0 0
|
|
* (falling edge)
|
|
* FT80X_REG_VSYNC1 End of VSYNC pulse 10 2
|
|
* (rising edge)
|
|
*
|
|
* c. Enable or disable FT80X_REG_CSPREAD with a value of 01h or 00h,
|
|
* respectively. Enabling FT80X_REG_CSPREAD will offset the R, G and B
|
|
* output bits so all they do not all change at the same time.
|
|
*/
|
|
|
|
ft80x_write_byte(priv, FT80X_REG_PCLK, 0);
|
|
|
|
#if defined(CONFIG_LCD_FT80X_WQVGA)
|
|
ft80x_write_hword(priv, FT80X_REG_HCYCLE, 548);
|
|
ft80x_write_hword(priv, FT80X_REG_HOFFSET, 43);
|
|
ft80x_write_hword(priv, FT80X_REG_HSYNC0, 0);
|
|
ft80x_write_hword(priv, FT80X_REG_HSYNC1, 41);
|
|
ft80x_write_hword(priv, FT80X_REG_VCYCLE, 292);
|
|
ft80x_write_hword(priv, FT80X_REG_VOFFSET, 12);
|
|
ft80x_write_hword(priv, FT80X_REG_VSYNC0, 0);
|
|
ft80x_write_hword(priv, FT80X_REG_VSYNC1, 10);
|
|
ft80x_write_byte(priv, FT80X_REG_SWIZZLE, 0);
|
|
ft80x_write_byte(priv, FT80X_REG_PCLK_POL, 1);
|
|
ft80x_write_byte(priv, FT80X_REG_CSPREAD, 1);
|
|
ft80x_write_hword(priv, FT80X_REG_HSIZE, 480);
|
|
ft80x_write_hword(priv, FT80X_REG_VSIZE, 272);
|
|
|
|
#elif defined(CONFIG_LCD_FT80X_QVGA)
|
|
ft80x_write_hword(priv, FT80X_REG_HCYCLE, 408);
|
|
ft80x_write_hword(priv, FT80X_REG_HOFFSET, 70);
|
|
ft80x_write_hword(priv, FT80X_REG_HSYNC0, 0);
|
|
ft80x_write_hword(priv, FT80X_REG_HSYNC1, 10);
|
|
ft80x_write_hword(priv, FT80X_REG_VCYCLE, 263);
|
|
ft80x_write_hword(priv, FT80X_REG_VOFFSET, 13);
|
|
ft80x_write_hword(priv, FT80X_REG_VSYNC0, 0);
|
|
ft80x_write_hword(priv, FT80X_REG_VSYNC1, 2);
|
|
ft80x_write_byte(priv, FT80X_REG_SWIZZLE, 2);
|
|
ft80x_write_byte(priv, FT80X_REG_PCLK_POL, 0);
|
|
ft80x_write_byte(priv, FT80X_REG_CSPREAD, 1);
|
|
ft80x_write_hword(priv, FT80X_REG_HSIZE, 320);
|
|
ft80x_write_hword(priv, FT80X_REG_VSIZE, 240);
|
|
|
|
#else
|
|
# error Unknown display size
|
|
#endif
|
|
|
|
/* 5. Write first display list */
|
|
|
|
ft80x_write_word(priv, FT80X_RAM_DL + 0, FT80X_CLEAR_COLOR_RGB(0, 0, 0));
|
|
ft80x_write_word(priv, FT80X_RAM_DL + 4, FT80X_CLEAR(1, 1, 1));
|
|
ft80x_write_word(priv, FT80X_RAM_DL + 8, FT80X_DISPLAY());
|
|
|
|
/* 6. Write FT80X_REG_DLSWAP, FT800 swaps display list immediately */
|
|
|
|
ft80x_write_byte(priv, FT80X_REG_DLSWAP, DLSWAP_FRAME);
|
|
|
|
/* GPIO bit 7 is used for the display enable pin of the LCD module. By
|
|
* setting the direction of the GPIO bit to out direction, the display can
|
|
* be enabled by writing value of 1 into GPIO bit 7 or the display can be
|
|
* disabled by writing a value of 0 into GPIO bit 7. By default GPIO bit 7
|
|
* direction is output and the value is 0.
|
|
*
|
|
* If an external audio amplified is controlled by an FT80x GPIO, then
|
|
* configure that GPIO as well. Active low logic is assumed so that the
|
|
* amplifier is initially in the shutdown state.
|
|
*/
|
|
|
|
regval8 = ft80x_read_byte(priv, FT80X_REG_GPIO_DIR);
|
|
regval8 |= (1 << 7);
|
|
#ifdef CONFIG_LCD_FT80X_AUDIO_GPIOSHUTDOWN
|
|
regval8 |= (1 << CONFIG_LCD_FT80X_AUDIO_GPIO);
|
|
#endif
|
|
ft80x_write_byte(priv, FT80X_REG_GPIO_DIR, regval8);
|
|
|
|
regval8 = ft80x_read_byte(priv, FT80X_REG_GPIO);
|
|
regval8 |= (1 << 7);
|
|
#ifdef CONFIG_LCD_FT80X_AUDIO_GPIOSHUTDOWN
|
|
regval8 |= (1 << CONFIG_LCD_FT80X_AUDIO_GPIO);
|
|
#endif
|
|
ft80x_write_byte(priv, FT80X_REG_GPIO, regval8);
|
|
|
|
/* 7. Enable back light control for display */
|
|
#warning Missing logic
|
|
|
|
/* 8. Write FT80X_REG_PCLK, video output with the first display list */
|
|
|
|
#if defined(CONFIG_LCD_FT80X_WQVGA)
|
|
ft80x_write_byte(priv, FT80X_REG_PCLK, 5);
|
|
#elif defined(CONFIG_LCD_FT80X_QVGA)
|
|
ft80x_write_byte(priv, FT80X_REG_PCLK, 8);
|
|
#else
|
|
# error Unknown display size
|
|
#endif
|
|
|
|
/* 9. Use MCU SPI clock not more than 30MHz */
|
|
|
|
DEBUGASSERT(priv->lower->op_frequency <= 30000000);
|
|
priv->frequency = priv->lower->op_frequency;
|
|
|
|
/* Configure touch mode. Using default touch mode of FRAME_SYNC (~60Hz) */
|
|
|
|
ft80x_write_byte(priv, FT80X_REG_TOUCH_MODE, TOUCH_MODE_FRAMESYNC);
|
|
|
|
#if defined(CONFIG_LCD_FT800)
|
|
/* Configure the touch threshold. The value 1200 may need to be tweaked
|
|
* for your application.
|
|
*/
|
|
|
|
ft80x_write_hword(priv, FT80X_REG_TOUCH_RZTHRESH, 1200);
|
|
|
|
#elif defined(CONFIG_LCD_FT801)
|
|
#ifdef CONFIG_LCD_FT801_MULTITOUCH
|
|
/* Selected extended mode */
|
|
|
|
ft80x_write_byte(priv, FT80X_REG_CTOUCH_EXTENDED, 0);
|
|
#else
|
|
/* Selected compatibility mode */
|
|
|
|
ft80x_write_byte(priv, FT80X_REG_CTOUCH_EXTENDED, 1);
|
|
#endif
|
|
|
|
#else
|
|
# error No FT80x device configured
|
|
#endif
|
|
|
|
return OK;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: ft80x_register
|
|
*
|
|
* Description:
|
|
* Configure the ADS7843E to use the provided SPI device instance. This
|
|
* will register the driver as /dev/ft800 or /dev/ft801, depending upon
|
|
* the configuration.
|
|
*
|
|
* Input Parameters:
|
|
* spi - An SPI driver instance
|
|
* i2c - An I2C master driver instance
|
|
* lower - Persistent board configuration data / lower half interface
|
|
*
|
|
* Returned Value:
|
|
* Zero is returned on success. Otherwise, a negated errno value is
|
|
* returned to indicate the nature of the failure.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#if defined(CONFIG_LCD_FT80X_SPI)
|
|
int ft80x_register(FAR struct spi_dev_s *spi,
|
|
FAR const struct ft80x_config_s *lower)
|
|
#elif defined(CONFIG_LCD_FT80X_I2C)
|
|
int ft80x_register(FAR struct i2c_master_s *i2c,
|
|
FAR const struct ft80x_config_s *lower)
|
|
#endif
|
|
{
|
|
FAR struct ft80x_dev_s *priv;
|
|
int ret;
|
|
|
|
#if defined(CONFIG_LCD_FT80X_SPI)
|
|
DEBUGASSERT(spi != NULL && lower != NULL);
|
|
#elif defined(CONFIG_LCD_FT80X_I2C)
|
|
DEBUGASSERT(i2c != NULL && lower != NULL);
|
|
#endif
|
|
|
|
/* Allocate the driver state structure */
|
|
|
|
priv = (FAR struct ft80x_dev_s *)kmm_zalloc(sizeof(struct ft80x_dev_s));
|
|
if (priv == NULL)
|
|
{
|
|
lcderr("ERROR: Failed to allocate state structure\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/* Save the lower level interface and configuration information */
|
|
|
|
priv->lower = lower;
|
|
|
|
#ifdef CONFIG_LCD_FT80X_SPI
|
|
/* Remember the SPI configuration */
|
|
|
|
priv->spi = spi;
|
|
#else
|
|
/* Remember the I2C configuration */
|
|
|
|
priv->i2c = i2c;
|
|
#endif
|
|
|
|
/* Initialize the mutual exclusion mutex */
|
|
|
|
nxmutex_init(&priv->lock);
|
|
|
|
/* Initialize the FT80x */
|
|
|
|
ret = ft80x_initialize(priv);
|
|
if (ret < 0)
|
|
{
|
|
goto errout_with_lock;
|
|
}
|
|
|
|
/* Attach our interrupt handler */
|
|
|
|
DEBUGASSERT(lower->attach != NULL && lower->enable != NULL);
|
|
ret = lower->attach(lower, ft80x_interrupt, priv);
|
|
if (ret < 0)
|
|
{
|
|
goto errout_with_lock;
|
|
}
|
|
|
|
/* Disable all interrupt sources, but enable interrupts both in the lower
|
|
* half driver and in the FT80x.
|
|
*/
|
|
|
|
ft80x_write_word(priv, FT80X_REG_INT_MASK, 0);
|
|
ft80x_write_word(priv, FT80X_REG_INT_EN, FT80X_INT_ENABLE);
|
|
lower->enable(lower, true);
|
|
|
|
/* Register the FT80x character driver */
|
|
|
|
ret = register_driver(DEVNAME, &g_ft80x_fops, 0666, priv);
|
|
if (ret < 0)
|
|
{
|
|
goto errout_with_interrupts;
|
|
}
|
|
|
|
return OK;
|
|
|
|
errout_with_interrupts:
|
|
lower->enable(lower, false);
|
|
ft80x_write_word(priv, FT80X_REG_INT_EN, FT80X_INT_DISABLE);
|
|
lower->attach(lower, NULL, NULL);
|
|
|
|
errout_with_lock:
|
|
nxmutex_destroy(&priv->lock);
|
|
kmm_free(priv);
|
|
return ret;
|
|
}
|
|
|
|
#endif /* CONFIG_LCD_FT80X */
|