/************************************************************************************ * nuttx/configs/compal_e99/src/ssd1783.c * * Copyright (C) 2009, 2011 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * Laurent Latil * Denis 'GNUtoo' Carikli * Alan Carvalho de Assis * * This driver for SSD1783 used part of SSD1783 driver developed by * Christian Vogel for Osmocom-BB and relicensed * to BSD with permission from author. * * 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. Neither the name NuttX nor the names of its contributors may be * used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT OWNER OR CONTRIBUTORS 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. * ************************************************************************************/ #include #include #include #include #include #include #include #include #include #include #include "up_arch.h" #include "ssd1783.h" /* Color depth and format */ #define LCD_BPP 16 #define LCD_COLORFMT FB_FMT_RGB16_555 /* Display Resolution */ # define LCD_XRES 98 # define LCD_YRES 67 /* Debug ******************************************************************************/ #ifdef CONFIG_DEBUG_LCD # define lcddbg(format, arg...) vdbg(format, ##arg) #else # define lcddbg(x...) #endif /** This should be put elsewhere */ #ifdef __CC_ARM /* ARM Compiler */ #define lcd_inline static __inline #elif defined (__ICCARM__) /* for IAR Compiler */ #define lcd_inline inline #elif defined (__GNUC__) /* GNU GCC Compiler */ #define lcd_inline static __inline #else #define lcd_inline static #endif static void lcd_clear(void); static void fb_ssd1783_send_cmdlist(const struct ssd1783_cmdlist *p); /* LCD Data Transfer Methods */ int lcd_putrun(fb_coord_t row, fb_coord_t col, FAR const uint8_t *buffer, size_t npixels); int lcd_getrun(fb_coord_t row, fb_coord_t col, FAR uint8_t *buffer, size_t npixels); /* LCD Configuration */ static int lcd_getvideoinfo(FAR struct lcd_dev_s *dev, FAR struct fb_videoinfo_s *vinfo); static int lcd_getplaneinfo(FAR struct lcd_dev_s *dev, unsigned int planeno, FAR struct lcd_planeinfo_s *pinfo); /* LCD RGB Mapping */ #ifdef CONFIG_FB_CMAP # error "RGB color mapping not supported by this driver" #endif /* Cursor Controls */ #ifdef CONFIG_FB_HWCURSOR # error "Cursor control not supported by this driver" #endif /* LCD Specific Controls */ static int lcd_getpower(struct lcd_dev_s *dev); static int lcd_setpower(struct lcd_dev_s *dev, int power); static int lcd_getcontrast(struct lcd_dev_s *dev); static int lcd_setcontrast(struct lcd_dev_s *dev, unsigned int contrast); /* Initialization (LCD ctrl / backlight) */ static inline void lcd_initialize(void); /************************************************************************************** * Private Data **************************************************************************************/ /* This is working memory allocated by the LCD driver for each LCD device * and for each color plane. This memory will hold one raster line of data. * The size of the allocated run buffer must therefore be at least * (bpp * xres / 8). Actual alignment of the buffer must conform to the * bitwidth of the underlying pixel type. * * If there are multiple planes, they may share the same working buffer * because different planes will not be operate on concurrently. However, * if there are multiple LCD devices, they must each have unique run buffers. */ static uint16_t g_runbuffer[LCD_XRES]; /* This structure describes the overall LCD video controller */ static const struct fb_videoinfo_s g_videoinfo = { .fmt = LCD_COLORFMT, /* Color format: RGB16-565: RRRR RGGG GGGB BBBB */ .xres = LCD_XRES, /* Horizontal resolution in pixel columns */ .yres = LCD_YRES, /* Vertical resolutiSend a command list to the LCD panelon in pixel rows */ .nplanes = 1, /* Number of color planes supported */ }; /* This is the standard, NuttX Plane information object */ static const struct lcd_planeinfo_s g_planeinfo = { .putrun = lcd_putrun, /* Put a run into LCD memory */ // .getrun = lcd_getrun, /* Get a run from LCD memory */ .buffer = (uint8_t*) g_runbuffer, /* Run scratch buffer */ .bpp = LCD_BPP, /* Bits-per-pixel */ }; /* This is the standard, NuttX LCD driver object */ static struct ssd1783_dev_s g_lcddev = { .dev = { /* LCD Configuration */ .getvideoinfo = lcd_getvideoinfo, .getplaneinfo = lcd_getplaneinfo, /* LCD RGB Mapping -- Not supported */ /* Cursor Controls -- Not supported */ /* LCD Specific Controls */ .getpower = lcd_getpower, .setpower = lcd_setpower, // .getcontrast = lcd_getcontrast, // .setcontrast = lcd_setcontrast, }, .power=0 }; /* we trust gcc to move this expensive bitshifting out of the loops in the drawing funtcions */ static uint8_t rgb_to_pixel(uint16_t color) { uint8_t ret; ret = (FB_COLOR_TO_R(color) & 0xe0); /* 765 = RRR */ ret |= (FB_COLOR_TO_G(color) & 0xe0) >> 3; /* 432 = GGG */ ret |= (FB_COLOR_TO_B(color) & 0xc0) >> 6; /* 10 = BB */ return ret; } /* somehow the palette is messed up, RRR seems to have the bits reversed! R0 R1 R2 G G G B B ---> R2 R1 R0 G G G B B */ uint8_t fix_rrr(uint8_t v){ return (v & 0x5f) | (v & 0x80) >> 2 | (v & 0x20) << 2; } lcd_inline void write_data(uint16_t datain) { uint16_t dataout = 0x0100 | fix_rrr(rgb_to_pixel(datain)); uwire_xfer(SSD1783_DEV_ID,SSD1783_UWIRE_BITLEN,&dataout, NULL); } static void fb_ssd1783_send_cmdlist(const struct ssd1783_cmdlist *p) { int i=0; while(p->is_cmd != END) { uint16_t sendcmd = p->data; if(p->is_cmd == DATA) sendcmd |= 0x0100; /* 9th bit is cmd/data flag */ uwire_xfer(SSD1783_DEV_ID, SSD1783_UWIRE_BITLEN, &sendcmd, NULL); p++; i++; } } static void lcd_write_prepare(unsigned int x1, unsigned int x2, unsigned int y1, unsigned int y2) {; DEBUGASSERT( (x1 < x2 )&& (y1 < y2)); struct ssd1783_cmdlist prepare_disp_write_cmds[] = { { CMD, 0x15 }, /* set column address */ { DATA, x1 }, { DATA, x2 }, { CMD, 0x75 }, /* set page address (Y) */ { DATA, y1 }, { DATA, y2 }, { CMD, 0x5c }, /* enter write display ram mode */ { END, 0x00 } }; dbg("x1:%d, x2:%d, y1:%d, y2:%d\n",x1, x2,y1, y2); fb_ssd1783_send_cmdlist(prepare_disp_write_cmds); } /************************************************************************************** * Name: lcd_putrun * * Description: * This method can be used to write a partial raster line to the LCD: * * row - Starting row to write to (range: 0 <= row < yres) * col - Starting column to write to (range: 0 <= col <= xres-npixels) * buffer - The buffer containing the run to be written to the LCD * npixels - The number of pixels to write to the LCD * (range: 0 < npixels <= xres-col) * **************************************************************************************/ int lcd_putrun(fb_coord_t row, fb_coord_t col, FAR const uint8_t *buffer, size_t npixels) { int i; FAR const uint16_t *src = (FAR const uint16_t*) buffer; /* Buffer must be provided and aligned to a 16-bit address boundary */ DEBUGASSERT(buffer && ((uintptr_t)buffer & 1) == 0); /* Write the run to GRAM. */ lcd_write_prepare(col,col+npixels, row,row+1); for (i = 0; i < npixels; i++) { write_data(*src++); } fb_ssd1783_send_cmdlist(nop); return OK; } /************************************************************************************** * Name: lcd_getrun * * Description: * This method can be used to read a partial raster line from the LCD: * * row - Starting row to read from (range: 0 <= row < yres) * col - Starting column to read read (range: 0 <= col <= xres-npixels) * buffer - The buffer in which to return the run read from the LCD * npixels - The number of pixels to read from the LCD * (range: 0 < npixels <= xres-col) * **************************************************************************************/ int lcd_getrun(fb_coord_t row, fb_coord_t col, FAR uint8_t *buffer, size_t npixels) { gvdbg("Not implemented\n"); return -ENOSYS; } /************************************************************************************** * Name: lcd_getvideoinfo * * Description: * Get information about the LCD video controller configuration. * **************************************************************************************/ static int lcd_getvideoinfo(FAR struct lcd_dev_s *dev, FAR struct fb_videoinfo_s *vinfo) { DEBUGASSERT(dev && vinfo);gvdbg("fmt: %d xres: %d yres: %d nplanes: %d\n", g_videoinfo.fmt, g_videoinfo.xres, g_videoinfo.yres, g_videoinfo.nplanes); memcpy(vinfo, &g_videoinfo, sizeof(struct fb_videoinfo_s)); return OK; } /************************************************************************************** * Name: lcd_getplaneinfo * * Description: * Get information about the configuration of each LCD color plane. * **************************************************************************************/ static int lcd_getplaneinfo(FAR struct lcd_dev_s *dev, unsigned int planeno, FAR struct lcd_planeinfo_s *pinfo) { DEBUGASSERT(dev && pinfo && planeno == 0);gvdbg("planeno: %d bpp: %d\n", planeno, g_planeinfo.bpp); memcpy(pinfo, &g_planeinfo, sizeof(struct lcd_planeinfo_s)); return OK; } /************************************************************************************** * Name: lcd_getpower * * Description: * Get the LCD panel power status (0: full off - CONFIG_LCD_MAXPOWER: full on). On * backlit LCDs, this setting may correspond to the backlight setting. * **************************************************************************************/ static int lcd_getpower(struct lcd_dev_s *dev) { gvdbg("power: %d\n", 0); return g_lcddev.power; } /************************************************************************************** * Name: lcd_setpower * * Description: * Enable/disable LCD panel power (0: full off - CONFIG_LCD_MAXPOWER: full on). * Used here to set pwm duty on timer used for backlight. * **************************************************************************************/ static int lcd_setpower(struct lcd_dev_s *dev, int power) { uint16_t reg; if (g_lcddev.power == power) { return OK; } gvdbg("power: %d\n", power); DEBUGASSERT(power <= CONFIG_LCD_MAXPOWER); /* Set new power level */ reg = getreg16(ASIC_CONF_REG); if (power) { reg = getreg16(ASIC_CONF_REG); /* LCD Set I/O(3) / SA0 to I/O(3) mode */ reg &= ~( (1 << 12) | (1 << 10) | (1 << 7) | (1 << 1)) ; /* don't set function pins to I2C Mode, C155 uses UWire */ /* TWL3025: Set SPI+RIF RX clock to rising edge */ reg |= (1 << 13) | (1 << 14); putreg16(reg, ASIC_CONF_REG); /* LCD Set I/O(3) to output mode and enable C155 backlight (IO1) */ /* FIXME: Put the display backlight control to backlight.c */ reg = getreg16(IO_CNTL_REG); reg &= ~( (1 << 3) | (1 << 1)); putreg16(reg, IO_CNTL_REG); /* LCD Set I/O(3) output low */ reg = getreg16(ARMIO_LATCH_OUT); reg &= ~(1 << 3); reg |= (1 << 1); putreg16(reg, ARMIO_LATCH_OUT); } else { gvdbg("powering LCD off...\n"); /* Switch pin from PWL to LT */ reg &= ~ASCONF_PWL_ENA; putreg8(reg, ASIC_CONF_REG); /* Disable pwl */ putreg8(0x00, PWL_REG(PWL_CTRL)); } return OK; } /************************************************************************************** * Name: lcd_getcontrast * * Description: * Get the current contrast setting (0-CONFIG_LCD_MAXCONTRAST). * **************************************************************************************/ static int lcd_getcontrast(struct lcd_dev_s *dev) { gvdbg("Not implemented\n"); return -ENOSYS; } /************************************************************************************** * Name: lcd_setcontrast * * Description: * Set LCD panel contrast (0-CONFIG_LCD_MAXCONTRAST). * **************************************************************************************/ static int lcd_setcontrast(struct lcd_dev_s *dev, unsigned int contrast) { gvdbg("Not implemented\n"); return -ENOSYS; } /************************************************************************************** * Name: lcd_lcdinitialize * * Description: * Set LCD panel contrast (0-CONFIG_LCD_MAXCONTRAST). * **************************************************************************************/ static inline void lcd_initialize(void) { gvdbg("%s: initializing LCD.\n",__FUNCTION__); calypso_reset_set(RESET_EXT, 0); usleep(5000); uwire_init(); usleep(5000); fb_ssd1783_send_cmdlist(ssd1783_initdata); } /************************************************************************************** * Public Functions **************************************************************************************/ /************************************************************************************** * Name: up_lcdinitialize * * Description: * Initialize the LCD video hardware. The initial state of the LCD is fully * initialized, display memory cleared, and the LCD ready to use, but with the power * setting at 0 (full off). * **************************************************************************************/ int up_lcdinitialize(void) { gvdbg("Initializing\n"); lcd_initialize(); /* Clear the display */ lcd_clear(); return OK; } /************************************************************************************** * Name: up_lcdgetdev * * Description: * Return a a reference to the LCD object for the specified LCD. This allows support * for multiple LCD devices. * **************************************************************************************/ FAR struct lcd_dev_s *up_lcdgetdev(int lcddev) { DEBUGASSERT(lcddev == 0); return &g_lcddev.dev; } /************************************************************************************** * Name: up_lcduninitialize * * Description: * Un-initialize the LCD support * **************************************************************************************/ void up_lcduninitialize(void) { lcd_setpower(&g_lcddev.dev, 0); } /************************************************************************************** * Name: lcd_clear * * Description: * Fill the LCD ctrl memory with given color * **************************************************************************************/ void lcd_clear() { struct ssd1783_cmdlist prepare_disp_write_cmds[] = { { CMD, 0x8E }, { DATA, 0x00 }, { DATA, 0x00 }, { DATA, LCD_XRES }, { DATA, LCD_YRES }, { END, 0x00 } }; struct ssd1783_cmdlist nop[] = { { CMD, 0x25 }, // NOP command { END, 0x00 } }; fb_ssd1783_send_cmdlist(prepare_disp_write_cmds); fb_ssd1783_send_cmdlist(nop); }