sergiotarxz/nuttx
sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
nuttx/boards/arm/sam34/sam4l-xplained/src/sam_slcd.c
Gustavo Henrique Nihei e6b204f438 nuttx: Use MIN/MAX definitions from "sys/param.h" 
Signed-off-by: Gustavo Henrique Nihei <gustavo.nihei@espressif.com>
2023-02-01 23:47:44 +08:00

1283 lines
36 KiB
C
Raw Blame History

/****************************************************************************
* boards/arm/sam34/sam4l-xplained/src/sam_slcd.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.
*
****************************************************************************/
/* TODO: Add support for additional pixels: B0-B2, G0-G7, and E0-E7,
* probably via ioctl calls.
*/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/param.h>
#include <sys/types.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <poll.h>
#include <assert.h>
#include <errno.h>
#include <debug.h>
#include <nuttx/ascii.h>
#include <nuttx/streams.h>
#include <nuttx/fs/fs.h>
#include <nuttx/lcd/slcd_ioctl.h>
#include <nuttx/lcd/slcd_codec.h>
#include <nuttx/semaphore.h>
#include "arm_internal.h"
#include "sam_gpio.h"
#include "sam4l_periphclks.h"
#include "hardware/sam4l_lcdca.h"
#include "sam4l-xplained.h"
#if defined(CONFIG_SAM34_LCDCA) && defined(CONFIG_SAM4L_XPLAINED_SLCD1MODULE)
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* Configuration ************************************************************/
#ifndef CONFIG_LIBC_SLCDCODEC
# error This SLCD driver requires CONFIG_LIBC_SLCDCODEC
#endif
#if !defined(CONFIG_SAM34_OSC32K) && !defined(CONFIG_SAM34_RC32K)
# error This SLCD driver requires that either CONFIG_SAM34_OSC32K or
# error CONFIG_SAM34_RC32K be selected in the board configuration
#endif
/* LCD **********************************************************************/
/* LCD characteristics. The logic in this driver is not portable; it is
* tailored for the SAM4l Xplained Pro's LED1 module. However, in an effort
* to add some reusability to this module, some of the tunable settings are
* included here as BOARD_ definitions (although they do not appear in the
* board.h header file.
*/
#define SLCD_NROWS 1
#define SLCD_NCHARS 5
#define SLCD_NBARS 4
#define SLCD_MAXCONTRAST 63
#define BOARD_SLCD_NCOM 4
#define BOARD_SLCD_NSEG 24
#define SLCD_NPINS (BOARD_SLCD_NCOM+BOARD_SLCD_NSEG+1)
/* An ASCII character may need to be decorated with a preceding decimal
* point
*/
#define SLCD_DP 0x01
/* LCD controller bias configuration. */
#undef BOARD_XBIAS
#define BOARD_LPWAVE 1
/* LCD controller initial contrast setting. */
#define BOARD_INITIAL_CONTRAST (SLCD_MAXCONTRAST / 2)
/* LCD controller timing configuration */
#define BOARD_TIM_PRES 0 /* Clock prescaler {0|LCDCA_TIM_PRESC} */
#define BOARD_TIM_CLOCKDIV 8 /* Clock divider {1..8} */
#define BOARD_TIM_FC0 2 /* Frame 0 configuration {0..31} */
#define BOARD_TIM_FC1 2 /* Frame 1 configuration {0..31} */
#define BOARD_TIM_FC2 1 /* Frame 2 configuration {0..31} */
/* LCD controller configuration */
#if BOARD_SLCD_NCOM < 2
# define LCD_DUTY LCDCA_CFG_DUTY_STATIC /* Static COM0 */
#elif BOARD_SLCD_NCOM < 3
# define LCD_DUTY LCDCA_CFG_DUTY_1TO2 /* 1/2 COM[0:1] */
#elif BOARD_SLCD_NCOM < 4
# define LCD_DUTY LCDCA_CFG_DUTY_1TO3 /* 1/3 COM[0:2] */
#elif BOARD_SLCD_NCOM < 5
# define LCD_DUTY LCDCA_CFG_DUTY_1TO4 /* 1/4 COM[0:3] */
#else
# error Value of BOARD_SLCD_NCOM not supported
#endif
/* LCD Mapping
*
* a
* ---------
* |\ |h /|
* f| g | i |b
* | \ | / |
* --j-- --k-+
* | /| \ |
* e| l | n |c
* _ | / |m \| _
* B | | --------- | | B
* - d -
*
* ----- ---- ---- ---- ----- ----------------------------------------------
* COM0 COM1 COM2 COM3 Comments
* ----- ---- ---- ---- ----- ----------------------------------------------
* SEG0 G1 G2 G4 G3 Atmel logo, 4 stage battery-, Dot-point-,
* SEG1 G0 G6 G7 G5 usband play indicator
* SEG2 E7 E5 E3 E1 4 stage wireless-, AM-, PM- Volt- and milli
* SEG3 E6 E4 E2 E0 voltindicator
* SEG4 A0-h A0-i A0-k A0-n 1st 14-segment character
* SEG5 B3 A0-f A0-e A0-d
* SEG6 A0-a A0-b A0-c B4
* SEG7 A0-g A0-j A0-l A0-m
* SEG8 A1-h A1-i A1-k A1-n 2nd 14-segment character
* SEG9 B2 A1-f A1-e A1-d
* SEG10 A1-a A1-b A1-c B5
* SEG11 A1-g A1-j A1-l A1-m
* SEG12 A2-h A2-i A2-k A2-n 3rd 14-segment character
* SEG13 B1 A2-f A2-e A2-d
* SEG14 A2-a A2-b A2-c B6
* SEG15 A2-g A2-j A2-l A2-m
* SEG16 A3-h A3-i A3-k A3-n 4th 14-segment character
* SEG17 B0 A3-f A3-e A3-d
* SEG18 A3-a A3-b A3-c B7
* SEG19 A3-g A3-j A3-l A3-m
* SEG20 A4-h A4-i A4-k A4-n 5th 14-segment character. Celsius and
* SEG21 B8 A4-f A4-e A4-d Fahrenheit indicator
* SEG22 A4-a A4-b A4-c B9
* SEG23 A4-g A4-j A4-l A4-m
*/
#define SLCD_A0_STARTSEG 4
#define SLCD_A0_ENDSEG 7
#define SLCD_A1_STARTSEG 8
#define SLCD_A1_ENDSEG 11
#define SLCD_A2_STARTSEG 12
#define SLCD_A2_ENDSEG 15
#define SLCD_A3_STARTSEG 16
#define SLCD_A3_ENDSEG 19
#define SLCD_A4_STARTSEG 20
#define SLCD_A4_ENDSEG 23
#define SLCD_NB 10 /* Number of 'B' segments B0-B9 */
#define SLCD_NG 8 /* Number of 'G' segments G0-G7 */
#define SLCD_NE 8 /* Number of 'E' segments G0-G7 */
/* Named pixels */
#define SLCD_MINUS (&g_binfo[0])
#define SLCD_H (&g_binfo[1])
#define SLCD_M (&g_binfo[2])
#define SLCD_DP0 (&g_binfo[3])
#define SLCD_DP1 (&g_binfo[4])
#define SLCD_DP2 (&g_binfo[5])
#define SLCD_DP3 (&g_binfo[6])
#define SLCD_DP4 (&g_binfo[7])
#define SLCD_CENTIGRADE (&g_binfo[8])
#define SLCD_FAHRENHEIT (&g_binfo[9])
#define SLCD_ATMEL (&g_ginfo[0])
#define SLCD_BAR0 (&g_ginfo[1])
#define SLCD_BAR1 (&g_ginfo[2])
#define SLCD_BAR2 (&g_ginfo[3])
#define SLCD_BAR3 (&g_ginfo[4])
#define SLCD_COLON (&g_ginfo[5])
#define SLCD_USB (&g_ginfo[6])
#define SLCD_PAY (&g_ginfo[7])
#define SLCD_RNG0 (&g_einfo[0])
#define SLCD_RNG1 (&g_einfo[1])
#define SLCD_RNG2 (&g_einfo[2])
#define SLCD_RNG3 (&g_einfo[3])
#define SLCD_MV (&g_einfo[4])
#define SLCD_V (&g_einfo[5])
#define SLCD_PM (&g_einfo[6])
#define SLCD_AM (&g_einfo[7])
/****************************************************************************
* Private Type Definition
****************************************************************************/
/* Global SLCD state */
struct sam_slcdstate_s
{
bool initialized; /* True: Completed initialization sequence */
uint8_t curpos; /* The current cursor position */
uint8_t buffer[SLCD_NCHARS]; /* SLCD ASCII content */
uint8_t options[SLCD_NCHARS]; /* Ornamentations */
};
/* Describes one pixel */
struct slcd_pixel_s
{
uint8_t segment;
uint8_t com;
};
/****************************************************************************
* Private Function Protototypes
****************************************************************************/
/* Debug */
#ifdef CONFIG_DEBUG_LCD_INFO
static void slcd_dumpstate(const char *msg);
static void slcd_dumpslcd(const char *msg);
#else
# define slcd_dumpstate(msg)
# define slcd_dumpslcd(msg)
#endif
/* Internal utilities */
#if 0 /* Not used */
static void slcd_clear(void);
#endif
static void slcd_setpixel(const struct slcd_pixel_s *info);
static void slcd_clrpixel(const struct slcd_pixel_s *info);
static inline void slcd_setdp(uint8_t curpos);
static inline void slcd_clrdp(uint8_t curpos);
static uint8_t slcd_getcontrast(void);
static int slcd_setcontrast(unsigned int contrast);
static void slcd_writech(uint8_t ch, uint8_t curpos, uint8_t options);
static void slcd_action(enum slcdcode_e code, uint8_t count);
/* Character driver methods */
static ssize_t slcd_read(struct file *, char *, size_t);
static ssize_t slcd_write(struct file *, const char *, size_t);
static int slcd_ioctl(struct file *filep, int cmd, unsigned long arg);
static int slcd_poll(struct file *filep, struct pollfd *fds,
bool setup);
/****************************************************************************
* Private Data
****************************************************************************/
/* This is the driver state structure
* (there is no retained state information)
*/
static const struct file_operations g_slcdops =
{
NULL, /* open */
NULL, /* close */
slcd_read, /* read */
slcd_write, /* write */
NULL, /* seek */
slcd_ioctl, /* ioctl */
NULL, /* mmap */
NULL, /* truncate */
slcd_poll /* poll */
};
/* LCD state data */
static struct sam_slcdstate_s g_slcdstate;
/* LCD pin configurations */
static gpio_pinset_t g_slcdgpio[SLCD_NPINS] =
{
GPIO_LCDCA_COM0, GPIO_LCDCA_COM1, GPIO_LCDCA_COM2, GPIO_LCDCA_COM3,
GPIO_LCDCA_SEG0, GPIO_LCDCA_SEG1, GPIO_LCDCA_SEG2, GPIO_LCDCA_SEG3,
GPIO_LCDCA_SEG4, GPIO_LCDCA_SEG5, GPIO_LCDCA_SEG6, GPIO_LCDCA_SEG7,
GPIO_LCDCA_SEG8, GPIO_LCDCA_SEG9, GPIO_LCDCA_SEG10, GPIO_LCDCA_SEG11,
GPIO_LCDCA_SEG12, GPIO_LCDCA_SEG13, GPIO_LCDCA_SEG14, GPIO_LCDCA_SEG15,
GPIO_LCDCA_SEG16, GPIO_LCDCA_SEG17, GPIO_LCDCA_SEG18, GPIO_LCDCA_SEG19,
GPIO_LCDCA_SEG20, GPIO_LCDCA_SEG21, GPIO_LCDCA_SEG22, GPIO_LCDCA_SEG23,
GPIO_LCD1_BL
};
/* First segment of each character */
static const uint8_t g_startseg[SLCD_NCHARS] =
{
SLCD_A0_STARTSEG, SLCD_A1_STARTSEG, SLCD_A2_STARTSEG, SLCD_A3_STARTSEG,
SLCD_A4_STARTSEG
};
/* Pixel position for each 'B' segment */
static const struct slcd_pixel_s g_binfo[SLCD_NB] =
{
{17, 0},
{13, 0},
{9, 0},
{5, 0},
{6, 3},
{10, 3},
{14, 3},
{18, 3},
{21, 0},
{22, 3}
};
/* Pixel position for each 'G' segment */
static const struct slcd_pixel_s g_ginfo[SLCD_NG] =
{
{1, 0},
{0, 0},
{0, 1},
{0, 3},
{0, 2},
{1, 3},
{1, 1},
{1, 2}
};
/* Pixel position for each 'E' segment */
static const struct slcd_pixel_s g_einfo[SLCD_NE] =
{
{3, 3},
{2, 3},
{3, 2},
{2, 2},
{3, 1},
{2, 1},
{3, 0},
{2, 0}
};
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: slcd_dumpstate
****************************************************************************/
#ifdef CONFIG_DEBUG_LCD_INFO
static void slcd_dumpstate(const char *msg)
{
lcdinfo("%s:\n", msg);
lcdinfo(" curpos: %d\n",
g_slcdstate.curpos);
lcdinfo(" Display: [%c%c%c%c%c]\n",
g_slcdstate.buffer[0],
g_slcdstate.buffer[1],
g_slcdstate.buffer[2],
g_slcdstate.buffer[3],
g_slcdstate.buffer[4]);
lcdinfo(" Options: [%d%d%d%d%d]\n",
g_slcdstate.options[0],
g_slcdstate.options[1],
g_slcdstate.options[2],
g_slcdstate.options[3],
g_slcdstate.options[4]);
}
#endif
/****************************************************************************
* Name: slcd_dumpslcd
****************************************************************************/
#ifdef CONFIG_DEBUG_LCD_INFO
static void slcd_dumpslcd(const char *msg)
{
lcdinfo("%s:\n", msg);
lcdinfo(" CFG: %08x TIM: %08x SR: %08x\n",
getreg32(SAM_LCDCA_CFG), getreg32(SAM_LCDCA_TIM),
getreg32(SAM_LCDCA_SR));
lcdinfo(" DR0: %02x %08x DR1: %02x %08x\n",
getreg32(SAM_LCDCA_DRH0), getreg32(SAM_LCDCA_DRL0),
getreg32(SAM_LCDCA_DRH1), getreg32(SAM_LCDCA_DRL1));
lcdinfo(" DR2: %02x %08x DR3: %02x %08x\n",
getreg32(SAM_LCDCA_DRH2), getreg32(SAM_LCDCA_DRL2),
getreg32(SAM_LCDCA_DRH3), getreg32(SAM_LCDCA_DRL3));
lcdinfo(" BCFG: %08x CSRCFG: %08x CMCFG: %08x ACMCFG: %08x\n",
getreg32(SAM_LCDCA_BCFG), getreg32(SAM_LCDCA_CSRCFG),
getreg32(SAM_LCDCA_CMCFG), getreg32(SAM_LCDCA_ACMCFG));
lcdinfo(" ABMCFG: %08x IMR: %08x VER: %08x\n",
getreg32(SAM_LCDCA_ABMCFG), getreg32(SAM_LCDCA_IMR),
getreg32(SAM_LCDCA_VERSION));
}
#endif
/****************************************************************************
* Name: slcd_clear
****************************************************************************/
#if 0 /* Not used */
static void slcd_clear(void)
{
linfo("Clearing\n");
/* Clear display memory */
putreg32(LCDCA_CR_CDM, SAM_LCDCA_CR);
}
#endif
/****************************************************************************
* Name: slcd_setpixel
****************************************************************************/
static void slcd_setpixel(const struct slcd_pixel_s *info)
{
uintptr_t regaddr;
uint32_t regval;
regaddr = SAM_LCDCA_DRL(info->com);
regval = getreg32(regaddr);
regval |= (1 << info->segment);
putreg32(regval, regaddr);
}
/****************************************************************************
* Name: slcd_clrpixel
****************************************************************************/
static void slcd_clrpixel(const struct slcd_pixel_s *info)
{
uintptr_t regaddr;
uint32_t regval;
regaddr = SAM_LCDCA_DRL(info->com);
regval = getreg32(regaddr);
regval &= ~(1 << info->segment);
putreg32(regval, regaddr);
}
/****************************************************************************
* Name: slcd_setdp
****************************************************************************/
static inline void slcd_setdp(uint8_t curpos)
{
/* Set the decimal point before the current cursor position
*
* B3 B4 B5 B6 B7
* .O .O .O .O .O
*/
slcd_setpixel(&g_binfo[curpos + 3]);
}
/****************************************************************************
* Name: slcd_clrdp
****************************************************************************/
static inline void slcd_clrdp(uint8_t curpos)
{
/* Set the decimal point before the current cursor position
*
* B3 B4 B5 B6 B7
* .O .O .O .O .O
*/
slcd_clrpixel(&g_binfo[curpos + 3]);
}
/****************************************************************************
* Name: slcd_getcontrast
****************************************************************************/
static uint8_t slcd_getcontrast(void)
{
uint32_t regval;
uint32_t ucontrast;
int32_t scontrast;
/* Get the current contrast value */
regval = getreg32(SAM_LCDCA_CFG);
ucontrast = (regval & LCDCA_CFG_FCST_MASK) >> LCDCA_CFG_FCST_SHIFT;
/* Sign extend and translate the 6 bit signed value
*
* Unsigned Signed Extended Translated
* Value Hex Dec
* ---------- --------- ----- -----------
* 0000 001f 0000 001f 31 63
* 0000 0000 0000 0000 0 32
* 0000 0020 ffff ffe0 -32 0
*/
scontrast = (int32_t)(ucontrast << (32 - 6));
scontrast >>= (32 - 6);
return scontrast + 32;
}
/****************************************************************************
* Name: slcd_setcontrast
****************************************************************************/
static int slcd_setcontrast(unsigned int contrast)
{
uint32_t regval;
int scontrast;
int ret = OK;
/* Make sure that the contrast setting is within range */
if (contrast > SLCD_MAXCONTRAST)
{
contrast = SLCD_MAXCONTRAST;
ret = -ERANGE;
}
/* Translate to get a signed value:
*
* Input Translated Value Masked Value
* Dec Hex
* ------ --- ------------ -----------
* 63 -> 31 0000 0001f 0000 0001f
* 32 -> 0 0000 00000 0000 00000
* 0 -> -32 ffff fffe0 0000 00020
*/
scontrast = (int)contrast - 32;
/* Set the new contrast value */
regval = getreg32(SAM_LCDCA_CFG);
regval &= ~LCDCA_CFG_FCST_MASK;
regval |= LCDCA_CFG_FCST(scontrast);
putreg32(regval, SAM_LCDCA_CFG);
lcdinfo("contrast: %d CFG: %08x\n", contrast, getreg32(SAM_LCDCA_CFG));
return ret;
}
/****************************************************************************
* Name: slcd_writech
****************************************************************************/
static void slcd_writech(uint8_t ch, uint8_t curpos, uint8_t options)
{
uint8_t segment;
/* "LCDCA handles up to four ASCII characters tables, configured in
* Character Mapping Configuration register (CMCFG). Instead of handling
* each segments in display memory for a selected digit, user writes ASCII
* code in Character Mapping Control Register (CMCR) to display the
* corresponding character.
*
* "User can then drive several digits with few operations:
*
* "1. Select the Type of Digit (CMCFG.TDG),
* "2. Write the Start Segment value (CMCFG.STSEG) of the first digit,
* "3. Select Digit Reverse Mode (CMCFG.DREV) if required. If DREV is one,
* segment index is decremented,
* "4. Then write ASCII code in CMCR register."
*/
segment = g_startseg[curpos];
putreg32(LCDCA_CMCFG_TDG_14S4C | LCDCA_CMCFG_STSEG(segment),
SAM_LCDCA_CMCFG);
putreg32(ch, SAM_LCDCA_CMDR);
/* Check if we need to decorate the character with a preceding dot. */
if ((options & SLCD_DP) != 0)
{
slcd_setdp(curpos);
}
else
{
slcd_clrdp(curpos);
}
/* Save these values in the state structure */
g_slcdstate.buffer[curpos] = ch;
g_slcdstate.options[curpos] = options;
slcd_dumpstate("AFTER WRITE");
}
/****************************************************************************
* Name: slcd_action
****************************************************************************/
static void slcd_action(enum slcdcode_e code, uint8_t count)
{
lcdinfo("Action: %d count: %d\n", code, count);
slcd_dumpstate("BEFORE ACTION");
switch (code)
{
/* Erasure */
case SLCDCODE_BACKDEL: /* Backspace (backward delete) N characters */
{
int tmp;
/* If we are at the home position or if the count is zero,
* then ignore the action
*/
if (g_slcdstate.curpos < 1 || count < 1)
{
break;
}
/* Otherwise, BACKDEL is like moving the cursor back N characters
* then doing a forward deletion.
* Decrement the cursor position and fall through.
*/
tmp = (int)g_slcdstate.curpos - count;
if (tmp < 0)
{
tmp = 0;
count = g_slcdstate.curpos;
}
/* Save the updated cursor positions */
g_slcdstate.curpos = tmp;
}
case SLCDCODE_FWDDEL: /* DELete (forward delete) N characters moving text */
if (count > 0)
{
int nchars;
int nmove;
int i;
/* How many characters are to the right of the cursor position
* (including the one at the cursor position)? Then get the
* number of characters to move.
*/
nchars = SLCD_NCHARS - g_slcdstate.curpos;
nmove = MIN(nchars, count) - 1;
/* Move all characters after the current cursor position left by
* 'nmove' characters
*/
for (i = g_slcdstate.curpos + nmove; i < SLCD_NCHARS - 1; i++)
{
slcd_writech(g_slcdstate.buffer[i - nmove], i,
g_slcdstate.options[i - nmove]);
}
/* Erase the last 'nmove' characters on the display */
for (i = SLCD_NCHARS - nmove; i < SLCD_NCHARS; i++)
{
slcd_writech(' ', i, 0);
}
}
break;
case SLCDCODE_ERASE: /* Erase N characters from the cursor position */
if (count > 0)
{
int last;
int i;
/* Get the last position to clear and make sure that the last
* position is on the SLCD.
*/
last = g_slcdstate.curpos + count - 1;
if (last >= SLCD_NCHARS)
{
last = SLCD_NCHARS - 1;
}
/* Erase N characters after the current cursor position left
* by one
*/
for (i = g_slcdstate.curpos; i < last; i++)
{
slcd_writech(' ', i, 0);
}
}
break;
case SLCDCODE_CLEAR: /* Home the cursor and erase the entire display */
{
/* This is like HOME followed by ERASEEOL.
* Home the cursor and fall through.
*/
g_slcdstate.curpos = 0;
}
case SLCDCODE_ERASEEOL: /* Erase from the cursor position to the end of line */
{
int i;
/* Erase characters after the current cursor position to the end of
* the line
*/
for (i = g_slcdstate.curpos; i < SLCD_NCHARS; i++)
{
slcd_writech(' ', i, 0);
}
}
break;
/* Cursor movement */
case SLCDCODE_HOME: /* Cursor home */
{
g_slcdstate.curpos = 0;
}
break;
case SLCDCODE_END: /* Cursor end */
{
g_slcdstate.curpos = SLCD_NCHARS - 1;
}
break;
case SLCDCODE_LEFT: /* Cursor left by N characters */
{
int tmp = (int)g_slcdstate.curpos - count;
/* Don't permit movement past the beginning of the SLCD */
if (tmp < 0)
{
tmp = 0;
}
/* Save the new cursor position */
g_slcdstate.curpos = (uint8_t)tmp;
}
break;
case SLCDCODE_RIGHT: /* Cursor right by N characters */
{
int tmp = (int)g_slcdstate.curpos + count;
/* Don't permit movement past the end of the SLCD */
if (tmp >= SLCD_NCHARS)
{
tmp = SLCD_NCHARS - 1;
}
/* Save the new cursor position */
g_slcdstate.curpos = (uint8_t)tmp;
}
break;
case SLCDCODE_UP: /* Cursor up by N lines */
case SLCDCODE_DOWN: /* Cursor down by N lines */
case SLCDCODE_PAGEUP: /* Cursor up by N pages */
case SLCDCODE_PAGEDOWN: /* Cursor down by N pages */
break; /* Not supportable on this SLCD */
/* Blinking */
case SLCDCODE_BLINKSTART: /* Start blinking with current cursor position */
case SLCDCODE_BLINKEND: /* End blinking after the current cursor position */
case SLCDCODE_BLINKOFF: /* Turn blinking off */
break; /* Not implemented */
/* These are actually unreportable errors */
default:
case SLCDCODE_NORMAL: /* Not a special keycode */
break;
}
slcd_dumpstate("AFTER ACTION");
}
/****************************************************************************
* Name: slcd_read
****************************************************************************/
static ssize_t slcd_read(struct file *filep,
char *buffer, size_t len)
{
int ret = 0;
int i;
/* Try to read the entire display. Notice that the seek offset
* (filep->f_pos) is ignored. It probably should be taken into account
* and also updated after each read and write.
*/
for (i = 0; i < SLCD_NCHARS && ret < len; i++)
{
/* Check if the character is decorated with a preceding period */
if (ret < len && g_slcdstate.options[i] != 0)
{
if ((g_slcdstate.options[i] & SLCD_DP) != 0)
{
*buffer++ = '.';
ret++;
}
}
/* Return the character */
*buffer++ = g_slcdstate.buffer[i];
ret++;
}
slcd_dumpstate("READ");
return ret;
}
/****************************************************************************
* Name: slcd_write
****************************************************************************/
static ssize_t slcd_write(struct file *filep,
const char *buffer, size_t len)
{
struct lib_meminstream_s instream;
struct slcdstate_s state;
enum slcdret_e result;
uint8_t ch;
uint8_t count;
uint8_t options;
/* Initialize the stream for use with the SLCD CODEC */
lib_meminstream(&instream, buffer, len);
/* Initialize the SLCD decode state buffer */
memset(&state, 0, sizeof(struct slcdstate_s));
/* Decode and process every byte in the input buffer */
options = 0;
while ((result = slcd_decode(&instream.public,
&state, &ch, &count)) != SLCDRET_EOF)
{
lcdinfo("slcd_decode returned result=%d char=%d count=%d\n",
result, ch, count);
if (result == SLCDRET_CHAR) /* A normal character was returned */
{
/* Check for ASCII control characters */
if (ch < ASCII_SPACE)
{
/* All are ignored except for backspace and carriage return */
if (ch == ASCII_BS)
{
/* Perform the backward deletion */
slcd_action(SLCDCODE_BACKDEL, 1);
}
else if (ch == ASCII_CR)
{
/* Perform the carriage return */
slcd_action(SLCDCODE_HOME, 0);
}
/* Ignore dots before control characters (all of them?) */
options = 0;
}
/* Handle characters decoreated with a preceding period */
else if (ch == '.')
{
/* The next character will need a dot in front of it */
options |= SLCD_DP;
}
/* Handle ASCII_DEL */
else if (ch == ASCII_DEL)
{
/* Perform the forward deletion */
slcd_action(SLCDCODE_FWDDEL, 1);
options = 0;
}
/* The rest of the 7-bit ASCII characters are fair game */
else if (ch < 128)
{
lcdinfo("ch: %c[%02x] options: %02x\n", ch, ch, options);
/* Write the character at the current cursor position */
slcd_writech(ch, g_slcdstate.curpos, options);
options = 0;
/* And advance the cursor position */
if (g_slcdstate.curpos < (SLCD_NCHARS - 1))
{
g_slcdstate.curpos++;
}
slcd_dumpstate("AFTER APPEND");
}
}
else /* (result == SLCDRET_SPEC) */ /* A special SLCD action was returned */
{
/* Then Perform the action */
slcd_action((enum slcdcode_e)ch, count);
}
}
/* Ignore any dots with no following characters */
/* Assume that the entire input buffer was processed */
return (ssize_t)len;
}
/****************************************************************************
* Name: slcd_poll
****************************************************************************/
static int slcd_ioctl(struct file *filep, int cmd, unsigned long arg)
{
switch (cmd)
{
/* SLCDIOC_GETATTRIBUTES: Get the attributes of the SLCD
*
* argument: Pointer to struct slcd_attributes_s in which values will
* be returned
*/
case SLCDIOC_GETATTRIBUTES:
{
struct slcd_attributes_s *attr =
(struct slcd_attributes_s *)((uintptr_t)arg);
lcdinfo("SLCDIOC_GETATTRIBUTES:\n");
if (!attr)
{
return -EINVAL;
}
attr->nrows = SLCD_NROWS;
attr->ncolumns = SLCD_NCHARS;
attr->nbars = SLCD_NBARS;
attr->maxcontrast = SLCD_MAXCONTRAST;
attr->maxbrightness = 0;
}
break;
/* SLCDIOC_CURPOS: Get the SLCD cursor positioni (rows x characters)
*
* argument: Pointer to struct slcd_curpos_s in which values will be
* returned
*/
case SLCDIOC_CURPOS:
{
struct slcd_curpos_s *curpos =
(struct slcd_curpos_s *)((uintptr_t)arg);
lcdinfo("SLCDIOC_CURPOS: row=0 column=%d\n", g_slcdstate.curpos);
if (!curpos)
{
return -EINVAL;
}
curpos->row = 0;
curpos->column = g_slcdstate.curpos;
}
break;
/* SLCDIOC_SETBAR: Set bars on a bar display
*
* argument: 32-bit bitset, with each bit corresponding to one bar.
*/
case SLCDIOC_SETBAR:
{
lcdinfo("SLCDIOC_SETBAR: arg=0x%02lx\n", arg);
if ((arg & 1) != 0)
{
slcd_setpixel(SLCD_RNG0);
}
else
{
slcd_clrpixel(SLCD_RNG0);
}
if ((arg & 2) != 0)
{
slcd_setpixel(SLCD_RNG1);
}
else
{
slcd_clrpixel(SLCD_RNG1);
}
if ((arg & 4) != 0)
{
slcd_setpixel(SLCD_RNG2);
}
else
{
slcd_clrpixel(SLCD_RNG2);
}
if ((arg & 8) != 0)
{
slcd_clrpixel(SLCD_RNG3);
}
else
{
slcd_setpixel(SLCD_RNG3);
}
}
break;
/* SLCDIOC_GETCONTRAST: Get the current contrast setting
*
* argument: Pointer type int that will receive the current contrast
* setting
*/
case SLCDIOC_GETCONTRAST:
{
int *contrast = (int *)((uintptr_t)arg);
if (!contrast)
{
return -EINVAL;
}
*contrast = (int)slcd_getcontrast();
lcdinfo("SLCDIOC_GETCONTRAST: contrast=%d\n", *contrast);
}
break;
/* SLCDIOC_SETCONTRAST: Set the contrast to a new value
*
* argument: The new contrast value
*/
case SLCDIOC_SETCONTRAST:
{
lcdinfo("SLCDIOC_SETCONTRAST: arg=%ld\n", arg);
if (arg > SLCD_MAXCONTRAST)
{
return -ERANGE;
}
return slcd_setcontrast((unsigned int)arg);
}
break;
case SLCDIOC_GETBRIGHTNESS: /* Get the current brightness setting */
case SLCDIOC_SETBRIGHTNESS: /* Set the brightness to a new value */
default:
return -ENOTTY;
}
return OK;
}
/****************************************************************************
* Name: slcd_poll
****************************************************************************/
static int slcd_poll(struct file *filep, struct pollfd *fds,
bool setup)
{
if (setup)
{
/* Data is always available to be read / Data can always be written */
poll_notify(&fds, 1, POLLIN | POLLOUT);
}
return OK;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: sam_slcd_initialize
*
* Description:
* Initialize the SAM4L Xplained Pro LCD hardware and register the
* character driver as /dev/slcd0.
*
****************************************************************************/
int sam_slcd_initialize(void)
{
uint32_t regval;
int ret = OK;
int i;
/* Only initialize the driver once. */
if (!g_slcdstate.initialized)
{
lcdinfo("Initializing\n");
/* Configure LCD GPIO pins */
for (i = 0; i < SLCD_NPINS; i++)
{
sam_configgpio(g_slcdgpio[i]);
}
/* Enable APB clock for LCDCA */
sam_lcdca_enableclk();
/* Here we require that either CONFIG_SAM34_OSC32K or
* CONFIG_SAM34_RC32K is defined in the configuration.
* In that case, the source clock was initialized during boot up
* and we can be assured that it is read for use now.
*/
/* Disable the LCD controller and frame counters */
putreg32(LCDCA_CR_DIS | LCDCA_CR_FC0DIS | LCDCA_CR_FC1DIS |
LCDCA_CR_FC2DIS, SAM_LCDCA_CR);
/* Configure LCD controller timing */
regval = BOARD_TIM_PRES | LCDCA_TIM_CLKDIV(BOARD_TIM_CLOCKDIV) |
LCDCA_TIM_FC0(BOARD_TIM_FC0) | LCDCA_TIM_FC1(BOARD_TIM_FC1) |
LCDCA_TIM_FC2(BOARD_TIM_FC2);
putreg32(regval, SAM_LCDCA_TIM);
/* Setup the LCD controller configuration.
*
* External bias generation (XBIAS): Controlled by board setting
* Waveform mode: Controlled by board setting
* Blank LCD: No
* Lock: No
* Duty: Controlled by board setting
* Fine Contrast (FCST): 0
* Number of segments (NSU): Controlled by board setting
*/
regval =
#ifdef BOARD_XBIAS
LCDCA_CFG_XBIAS |
#endif
#ifndef BOARD_LPWAVE
LCDCA_CFG_WMOD |
#endif
LCD_DUTY |
LCDCA_CFG_FCST(0) |
LCDCA_CFG_NSU(BOARD_SLCD_NSEG);
putreg32(regval, SAM_LCDCA_CFG);
/* Provide an initial contrast setting */
slcd_setcontrast(BOARD_INITIAL_CONTRAST);
/* Turn off blanking of display segments */
regval = getreg32(SAM_LCDCA_CFG);
regval &= ~LCDCA_CFG_BLANK;
putreg32(regval, SAM_LCDCA_CFG);
/* Enable the display controller */
putreg32(LCDCA_CR_EN, SAM_LCDCA_CR);
/* Clear all display memory */
putreg32(LCDCA_CR_CDM, SAM_LCDCA_CR);
/* Wait for the LCD to be fully enabled */
while ((getreg32(SAM_LCDCA_SR) & LCDCA_SR_EN) == 0);
/* Enable frame counters */
putreg32(LCDCA_CR_FC0EN, SAM_LCDCA_CR);
while ((getreg32(SAM_LCDCA_SR) & LCDCA_SR_FC0S) == 0);
putreg32(LCDCA_CR_FC1EN, SAM_LCDCA_CR);
while ((getreg32(SAM_LCDCA_SR) & LCDCA_SR_FC1S) == 0);
putreg32(LCDCA_CR_FC2EN, SAM_LCDCA_CR);
while ((getreg32(SAM_LCDCA_SR) & LCDCA_SR_FC2S) == 0);
/* Make sure that blinking and circular shifting is off */
putreg32(LCDCA_CR_BSTOP | LCDCA_CR_CSTOP, SAM_LCDCA_CR);
/* Disable any automated display */
regval = getreg32(SAM_LCDCA_ACMCFG);
regval &= ~LCDCA_ACMCFG_EN;
putreg32(regval, SAM_LCDCA_ACMCFG);
/* Initialize display memory */
putreg32(0, SAM_LCDCA_DRL0);
putreg32(0, SAM_LCDCA_DRH0);
putreg32(0, SAM_LCDCA_DRL1);
putreg32(0, SAM_LCDCA_DRH1);
putreg32(0, SAM_LCDCA_DRL2);
putreg32(0, SAM_LCDCA_DRH2);
putreg32(0, SAM_LCDCA_DRL3);
putreg32(0, SAM_LCDCA_DRH3);
/* Turn on the Atmel pixel */
slcd_setpixel(SLCD_ATMEL);
/* Register the LCD device driver */
ret = register_driver("/dev/slcd0", &g_slcdops, 0644, &g_slcdstate);
g_slcdstate.initialized = true;
/* Turn on the backlight */
sam_gpiowrite(GPIO_LCD1_BL, true);
slcd_dumpstate("AFTER INITIALIZATION");
slcd_dumpslcd("AFTER INITIALIZATION");
}
return ret;
}
#endif /* CONFIG_SAM34_LCDCA && CONFIG_SAM4L_XPLAINED_SLCD1MODULE */
Reference in New Issue View Git Blame Copy Permalink