From 181cec4348da40331b3e8ab365732c025ec149b2 Mon Sep 17 00:00:00 2001 From: Reinhard Tartler Date: Wed, 27 Apr 2011 19:24:15 +0200 Subject: Import upstream version 0.11.0~svn1143 --- drv_M50530.c | 688 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 688 insertions(+) create mode 100644 drv_M50530.c (limited to 'drv_M50530.c') diff --git a/drv_M50530.c b/drv_M50530.c new file mode 100644 index 0000000..45518b2 --- /dev/null +++ b/drv_M50530.c @@ -0,0 +1,688 @@ +/* $Id: drv_M50530.c 975 2009-01-18 11:16:20Z michael $ + * $URL: https://ssl.bulix.org/svn/lcd4linux/trunk/drv_M50530.c $ + * + * new style driver for M50530-based displays + * + * Copyright (C) 2003 Michael Reinelt + * Copyright (C) 2004 The LCD4Linux Team + * + * This file is part of LCD4Linux. + * + * LCD4Linux is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * LCD4Linux is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +/* + * + * exported fuctions: + * + * struct DRIVER drv_M50530 + * + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "debug.h" +#include "cfg.h" +#include "qprintf.h" +#include "udelay.h" +#include "plugin.h" +#include "widget.h" +#include "widget_text.h" +#include "widget_icon.h" +#include "widget_bar.h" +#include "drv.h" +#include "drv_generic_text.h" +#include "drv_generic_gpio.h" +#include "drv_generic_parport.h" + +static char Name[] = "M50530"; + +static int Model; + +/* Timings */ +static int T_SU, T_W, T_D, T_H; +static int T_INIT, T_EXEC, T_CLEAR; +static int T_GPO_ST, T_GPO_PW; + +static unsigned char SIGNAL_RW; +static unsigned char SIGNAL_EX; +static unsigned char SIGNAL_IOC1; +static unsigned char SIGNAL_IOC2; +static unsigned char SIGNAL_GPO; + +static int FONT5X11; +static int DDRAM; +static int DUTY; + +/* maximum time to wait for the busy-flag (in usec) */ +#define MAX_BUSYFLAG_WAIT 10000 + +/* maximum busy flag errors before falling back to busy-waiting */ +#define MAX_BUSYFLAG_ERRORS 20 + +/* flag for busy-waiting vs. busy flag checking */ +static int UseBusy = 0; + +/* buffer holding the GPO state */ +static unsigned char GPO = 0; + + +typedef struct { + int type; + char *name; +} MODEL; + +static MODEL Models[] = { + {0x01, "M50530"}, + {0xff, "Unknown"} +}; + + +/****************************************/ +/*** hardware dependant functions ***/ +/****************************************/ + +static void drv_M5_busy(void) +{ + static unsigned int errors = 0; + + unsigned char data = 0xFF; + unsigned char busymask = 0x88; + unsigned int counter; + + /* set data-lines to input */ + drv_generic_parport_direction(1); + + /* clear I/OC1 and I/OC2, set R/W */ + drv_generic_parport_control(SIGNAL_IOC1 | SIGNAL_IOC2 | SIGNAL_RW, SIGNAL_RW); + + /* Control data setup time */ + ndelay(T_SU); + + counter = 0; + while (1) { + + /* rise enable */ + drv_generic_parport_control(SIGNAL_EX, SIGNAL_EX); + + /* data output delay time */ + ndelay(T_D); + + /* read the busy flag */ + data = drv_generic_parport_read(); + + /* lower enable */ + /* as T_D is larger than T_W, we don't need to delay again */ + drv_generic_parport_control(SIGNAL_EX, 0); + + if ((data & busymask) == 0) { + errors = 0; + break; + } + + /* make sure we don't wait forever + * - but only check after 5 iterations + * that way, we won't slow down normal mode + * (where we don't need the timeout anyway) + */ + counter++; + + if (counter >= 5) { + struct timeval now, end; + + if (counter == 5) { + /* determine the time when the timeout has expired */ + gettimeofday(&end, NULL); + end.tv_usec += MAX_BUSYFLAG_WAIT; + while (end.tv_usec > 1000000) { + end.tv_usec -= 1000000; + end.tv_sec++; + } + } + + /* get the current time */ + gettimeofday(&now, NULL); + if (now.tv_sec == end.tv_sec ? now.tv_usec >= end.tv_usec : now.tv_sec >= end.tv_sec) { + error("%s: timeout waiting for busy flag (0x%02x)", Name, data); + if (++errors >= MAX_BUSYFLAG_ERRORS) { + error("%s: too many busy flag failures, turning off busy flag checking.", Name); + UseBusy = 0; + } + break; + } + } + } + + /* clear R/W */ + drv_generic_parport_control(SIGNAL_RW, 0); + + /* honour data hold time */ + ndelay(T_H); + + /* set data-lines to output */ + drv_generic_parport_direction(0); + +} + + +static void drv_M5_command(const unsigned int cmd, const int delay) +{ + + if (UseBusy) + drv_M5_busy(); + + /* put data on DB1..DB8 */ + drv_generic_parport_data(cmd & 0xff); + + /* set I/OC1 */ + /* set I/OC2 */ + /* clear RW */ + drv_generic_parport_control(SIGNAL_IOC1 | SIGNAL_IOC2 | SIGNAL_RW, + (cmd & 0x100 ? SIGNAL_IOC1 : 0) | (cmd & 0x200 ? SIGNAL_IOC2 : 0)); + + /* Control data setup time */ + ndelay(T_SU); + + /* send command */ + drv_generic_parport_toggle(SIGNAL_EX, 1, T_W); + + if (UseBusy) { + /* honour data hold time */ + ndelay(T_H); + } else { + /* wait for command completion */ + udelay(delay); + } +} + + +static void drv_M5_clear(void) +{ + drv_M5_command(0x0001, T_CLEAR); /* clear display */ +} + + +static void drv_M5_write(const int row, const int col, const char *data, const int len) +{ + int l = len; + unsigned int cmd; + unsigned int pos; + + if (row < 4) { + pos = row * (DDRAM >> DUTY) + col; + } else { + pos = (row - 4) * (DDRAM >> DUTY) + (DDRAM >> DUTY) / 2 + col; + } + + drv_M5_command(0x300 | pos, T_EXEC); + + while (l--) { + cmd = *(unsigned char *) data++; + drv_M5_command(0x200 | cmd, T_EXEC); + } +} + + +static void drv_M5_defchar(const int ascii, const unsigned char *matrix) +{ + int i; + + drv_M5_command(0x300 + DDRAM + 8 * (ascii - CHAR0), T_EXEC); + + for (i = 0; i < YRES; i++) { + drv_M5_command(0x200 | (matrix[i] & 0x3f), T_EXEC); + } +} + + +static int drv_M5_GPO(const int num, const int val) +{ + int v; + + if (val > 0) { + /* set bit */ + v = 1; + GPO |= 1 << num; + } else { + /* clear bit */ + v = 0; + GPO &= ~(1 << num); + } + + /* put data on DB1..DB8 */ + drv_generic_parport_data(GPO); + + /* 74HCT573 set-up time */ + ndelay(T_GPO_ST); + + /* send data */ + /* 74HCT573 enable pulse width */ + drv_generic_parport_toggle(SIGNAL_GPO, 1, T_GPO_PW); + + return v; +} + + +static int drv_M5_start(const char *section, const int quiet) +{ + char *s; + int n; + int rows = -1, cols = -1; + unsigned int SF; + + s = cfg_get(section, "Model", "generic"); + if (s != NULL && *s != '\0') { + int i; + for (i = 0; Models[i].type != 0xff; i++) { + if (strcasecmp(Models[i].name, s) == 0) + break; + } + free(s); + if (Models[i].type == 0xff) { + error("%s: %s.Model '%s' is unknown from %s", Name, section, s, cfg_source()); + return -1; + } + Model = i; + info("%s: using model '%s'", Name, Models[Model].name); + } else { + error("%s: empty '%s.Model' entry from %s", Name, section, cfg_source()); + free(s); + return -1; + } + + s = cfg_get(section, "Size", NULL); + if (s == NULL || *s == '\0') { + error("%s: no '%s.Size' entry from %s", Name, section, cfg_source()); + free(s); + return -1; + } + if (sscanf(s, "%dx%d", &cols, &rows) != 2 || rows < 1 || cols < 1) { + error("%s: bad %s.Size '%s' from %s", Name, section, s, cfg_source()); + free(s); + return -1; + } + free(s); + DROWS = rows; + DCOLS = cols; + + s = cfg_get(section, "Font", "5x7"); + if (s == NULL && *s == '\0') { + error("%s: empty '%s.Font' entry from %s", Name, section, cfg_source()); + free(s); + return -1; + } + if (strcasecmp(s, "5x7") == 0) { + XRES = 5; + YRES = 7; + FONT5X11 = 0; + } else if (strcasecmp(s, "5x11") == 0) { + XRES = 5; + YRES = 11; + FONT5X11 = 1; + } else { + error("%s: bad '%s.Font' entry '%s' from %s", Name, section, s, cfg_source()); + error("%s: should be '5x7' or '5x11'", Name); + free(s); + return -1; + } + free(s); + + + if (DCOLS * DROWS > 256) { + error("%s: %s.Size '%dx%d' is too big, would require %d bytes", Name, section, DCOLS, DROWS, DCOLS * DROWS); + return -1; + } else if (DCOLS * DROWS > 224) { + DDRAM = 256; + CHARS = 0; + } else if (DCOLS * DROWS > 192) { + DDRAM = 224; + CHARS = FONT5X11 ? 2 : 4; + } else if (DCOLS * DROWS > 160) { + DDRAM = 192; + CHARS = FONT5X11 ? 4 : 8; + } else { + DDRAM = 160; + CHARS = FONT5X11 ? 6 : 12; + } + info("%s: using %d words DDRAM / %d words CGRAM (%d user chars)", Name, DDRAM, 256 - DDRAM, CHARS); + + if (cfg_number(section, "DUTY", 2, 0, 2, &DUTY) < 0) + return -1; + info("%s: using duty %d: 1/%d, %d lines x %d words", Name, DUTY, (XRES + 1) << DUTY, 1 << DUTY, DDRAM >> DUTY); + + + if (cfg_number(section, "GPOs", 0, 0, 8, &n) < 0) + return -1; + GPOS = n; + if (GPOS > 0) { + info("%s: controlling %d GPO's", Name, GPOS); + } + + if (drv_generic_parport_open(section, Name) != 0) { + error("%s: could not initialize parallel port!", Name); + return -1; + } + + if ((SIGNAL_RW = drv_generic_parport_wire_ctrl("RW", "GND")) == 0xff) + return -1; + if ((SIGNAL_EX = drv_generic_parport_wire_ctrl("EX", "STROBE")) == 0xff) + return -1; + if ((SIGNAL_IOC1 = drv_generic_parport_wire_ctrl("IOC1", "SLCTIN")) == 0xff) + return -1; + if ((SIGNAL_IOC2 = drv_generic_parport_wire_ctrl("IOC2", "AUTOFD")) == 0xff) + return -1; + if ((SIGNAL_GPO = drv_generic_parport_wire_ctrl("GPO", "GND")) == 0xff) + return -1; + + /* Timings */ + + /* low level communication timings [nanoseconds] + * we use the worst-case default values, but allow + * modification from the config file. + */ + + T_SU = timing(Name, section, "SU", 200, "ns"); /* control data setup time */ + T_W = timing(Name, section, "W", 500, "ns"); /* EX signal pulse width */ + T_D = timing(Name, section, "D", 300, "ns"); /* Data output delay time */ + T_H = timing(Name, section, "H", 100, "ns"); /* Data hold time */ + + /* GPO timing */ + if (SIGNAL_GPO != 0) { + T_GPO_ST = timing(Name, section, "GPO_ST", 20, "ns"); /* 74HCT573 set-up time */ + T_GPO_PW = timing(Name, section, "GPO_PW", 230, "ns"); /* 74HCT573 enable pulse width */ + } else { + T_GPO_ST = 0; + T_GPO_PW = 0; + } + + /* M50530 execution timings [microseconds] + * we use the worst-case default values, but allow + * modification from the config file. + */ + + T_EXEC = timing(Name, section, "EXEC", 20, "us"); /* normal execution time */ + T_CLEAR = timing(Name, section, "CLEAR", 1250, "us"); /* 'clear display' execution time */ + T_INIT = timing(Name, section, "INIT", 2000, "us"); /* mysterious initialization time */ + + + /* maybe use busy-flag from now on */ + cfg_number(section, "UseBusy", 0, 0, 1, &UseBusy); + + /* make sure we don't use the busy flag with RW wired to GND */ + if (UseBusy && !SIGNAL_RW) { + error("%s: busy-flag checking is impossible with RW wired to GND!", Name); + UseBusy = 0; + } + info("%s: %susing busy-flag checking", Name, UseBusy ? "" : "not "); + + /* clear all signals */ + drv_generic_parport_control(SIGNAL_RW | SIGNAL_EX | SIGNAL_IOC1 | SIGNAL_IOC2 | SIGNAL_GPO, 0); + + /* for some mysterious reason, this delay is necessary... */ + udelay(T_INIT); + + /* set direction: write */ + drv_generic_parport_direction(0); + + + /* set function (SF) mode: + * Bit 0 : RAM 0 + * Bit 1 : RAM 1 + * Bit 2 : DUTY 0 + * Bit 3 : DUTY 1 + * Bit 4 : FONT: 0 = 5x12, 1 = 5x8 + * Bit 5 : I/O: 0 = 4-bit, 1 = 8-bit + * Bit 6 : 1 + * Bit 7 : 1 + * + * RAM layout: + * 00: 256 words DDRAM, 0 words CGRAM + * 01: 224 words DDRAM, 32 words CGRAM + * 10: 192 words DDRAM, 64 words CGRAM + * 11: 160 words DDRAM, 96 words CGRAM + * + * Duty: + * 00: 1/8 (1/12 for 5x11), 1 line + * 00: 1/16 (1/24 for 5x11), 2 lines + * 00: 1/32 (1/48 for 5x11), 4 lines + * 11: undefined + */ + + /* 11100000 : SF, 8-bit mode */ + SF = 0xE0; + + /* RAM layout */ + switch (DDRAM) { + case 160: + SF |= 0x03; + break; + case 192: + SF |= 0x02; + break; + case 224: + SF |= 0x01; + break; + case 256: + SF |= 0x00; + break; + } + + /* Duty */ + SF |= (DUTY << 2); + + /* Font */ + SF |= (!FONT5X11) << 4; + + + debug("SET FUNCTION MODE 0x%02x", SF); + drv_M5_command(SF, T_EXEC); + + + /* set display (SD) mode: + * Bit 0 : 1 = turn on character blinking + * Bit 0 : 1 = turn on cursor blinking + * Bit 0 : 1 = turn on underline display + * Bit 0 : 1 = turn on cursor + * Bit 0 : 1 = turn on display + * Bit 0 : 1 + * Bit 0 : 0 + * Bit 0 : 0 + */ + + /* SD: 0x20 = 00100000 */ + /* SD: turn off display */ + drv_M5_command(0x0020, T_EXEC); + + + /* set entry (SE) mode: + * Bit 0 : 1 = inc/dec cursor address after Read + * Bit 1 : 1 = inc/dec cursor address after Write + * Bit 2 : 0 = inc, 1 = dec + * Bit 3 : 1 = inc/dec display start addr after Read + * Bit 4 : 1 = inc/dec display start addr after Write + * Bit 5 : 0 = inc, 1 = dec + * Bit 6 : 1 + * Bit 7 : 0 + * + */ + + /* SE: 0x50 = 01010000 */ + /* SE: increment display start after Write */ + drv_M5_command(0x0050, T_EXEC); + + + /* SD: 0x30 = 00110000 */ + /* SD: turn on display */ + drv_M5_command(0x0030, T_EXEC); + + + drv_M5_clear(); + + if (!quiet) { + char buffer[40]; + qprintf(buffer, sizeof(buffer), "%s %dx%d", Name, DCOLS, DROWS); + if (drv_generic_text_greet(buffer, NULL)) { + sleep(3); + drv_M5_clear(); + } + } + + return 0; +} + + +/****************************************/ +/*** plugins ***/ +/****************************************/ + +/* none at the moment */ + + +/****************************************/ +/*** widget callbacks ***/ +/****************************************/ + +/* using drv_generic_text_draw(W) */ +/* using drv_generic_text_icon_draw(W) */ +/* using drv_generic_text_bar_draw(W) */ +/* using drv_generic_gpio_draw(W) */ + + +/****************************************/ +/*** exported functions ***/ +/****************************************/ + + +/* list models */ +int drv_M5_list(void) +{ + int i; + + for (i = 0; Models[i].type != 0xff; i++) { + printf("%s ", Models[i].name); + } + return 0; +} + + +/* initialize driver & display */ +int drv_M5_init(const char *section, const int quiet) +{ + WIDGET_CLASS wc; + int ret; + + info("%s: %s", Name, "$Rev: 975 $"); + + /* display preferences */ + XRES = -1; /* pixel width of one char */ + YRES = -1; /* pixel height of one char */ + CHARS = 0; /* number of user-defineable characters */ + CHAR0 = 248; /* ASCII of first user-defineable char */ + GOTO_COST = 1; /* number of bytes a goto command requires */ + + /* real worker functions */ + drv_generic_text_real_write = drv_M5_write; + drv_generic_text_real_defchar = drv_M5_defchar; + drv_generic_gpio_real_set = drv_M5_GPO; + + + /* start display */ + if ((ret = drv_M5_start(section, quiet)) != 0) + return ret; + + /* initialize generic text driver */ + if ((ret = drv_generic_text_init(section, Name)) != 0) + return ret; + + /* initialize generic icon driver */ + if ((ret = drv_generic_text_icon_init()) != 0) + return ret; + + /* initialize generic bar driver */ + if ((ret = drv_generic_text_bar_init(0)) != 0) + return ret; + + /* add fixed chars to the bar driver */ + drv_generic_text_bar_add_segment(0, 0, 255, 32); /* ASCII 32 = blank */ + + /* initialize generic GPIO driver */ + if ((ret = drv_generic_gpio_init(section, Name)) != 0) + return ret; + + /* register text widget */ + wc = Widget_Text; + wc.draw = drv_generic_text_draw; + widget_register(&wc); + + /* register icon widget */ + wc = Widget_Icon; + wc.draw = drv_generic_text_icon_draw; + widget_register(&wc); + + /* register bar widget */ + wc = Widget_Bar; + wc.draw = drv_generic_text_bar_draw; + widget_register(&wc); + + /* register plugins */ + /* none at the moment */ + + return 0; +} + + +/* close driver & display */ +int drv_M5_quit(const int quiet) +{ + + info("%s: shutting down.", Name); + + drv_generic_text_quit(); + drv_generic_gpio_quit(); + + /* clear display */ + drv_M5_clear(); + + /* say goodbye... */ + if (!quiet) { + drv_generic_text_greet("goodbye!", NULL); + } + + /* clear all signals */ + drv_generic_parport_control(SIGNAL_RW | SIGNAL_EX | SIGNAL_IOC1 | SIGNAL_IOC2 | SIGNAL_GPO, 0); + + /* close port */ + drv_generic_parport_close(); + + return (0); +} + + +DRIVER drv_M50530 = { + .name = Name, + .list = drv_M5_list, + .init = drv_M5_init, + .quit = drv_M5_quit, +}; -- cgit v1.2.3