drv_D4D.c

/* $Id$
 * $URL$
 *
 * LCD4Linux driver for 4D Systems Display Graphics Modules
 *
 * Copyright (C) 2008, 2011 Sven Killig <sven@killig.de>
 * Modified from sample code by:
 * Copyright (C) 2005 Michael Reinelt <michael@reinelt.co.at>
 * Copyright (C) 2005, 2006, 2007 The LCD4Linux Team <lcd4linux-devel@users.sourceforge.net>
 *
 * 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_D4D
 *
 */

#include "config.h"

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#include <termios.h>
#include <fcntl.h>
#include <math.h>

#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_graphic.h"
#include "drv_generic_serial.h"

#include <sys/ioctl.h>
#include <linux/serial.h>

static char Name[] = "D4D";
char NAME_[20];
int FONT = 1, MODE = 0, EXTRA = 0, SECTOR = 0, SECTOR_SIZE, POWERCYCLE = 0;
/* int CONTRAST_; */

#define address_mmsb(variable) ((variable >> 24) & 0xFF)
#define address_mlsb(variable) ((variable >> 16) & 0xFF)
#define address_lmsb(variable) ((variable >>  8) & 0xFF)
#define address_llsb(variable)  (variable        & 0xFF)

#define address_hi(variable)   ((variable >> 16) & 0xFF)
#define address_mid(variable)  ((variable >>  8) & 0xFF)
#define address_lo(variable)    (variable        & 0xFF)

#define msb(variable)          ((variable >>  8) & 0xFF)
#define lsb(variable)           (variable        & 0xFF)

RGBA FG_COL_ = {.R = 0x00,.G = 0x00,.B = 0x00,.A = 0xff };
RGBA BG_COL_ = {.R = 0xff,.G = 0xff,.B = 0xff,.A = 0xff };

short int FG_COLOR, BG_COLOR;

int RGB_24to16(int red, int grn, int blu)
{
    return (((red >> 3) << 11) | ((grn >> 2) << 5) | (blu >> 3));
}

int RGB_24to8(int red, int grn, int blu)
{
    return (((red >> 5) << 5) | ((grn >> 5) << 2) | (blu >> 6));
}

/****************************************/
/***  hardware dependant functions    ***/
/****************************************/


static void drv_D4D_receive_ACK()
{
    char ret[1];
    while (drv_generic_serial_read(ret, sizeof(ret)) != 1)
	usleep(1);		/* loop should be unneccessary */
    if (ret[0] == 0x15) {
	error("NAK!");
    } else if (ret[0] != 6) {
	error("no ACK!");
    }
}


static void drv_D4D_send_nowait(const char *data, const unsigned int len)
{
    if (len > 1 && data[0] >= 32 && data[0] < 127)
	debug("drv_D4D_send_nowait('%c'", data[0]);
    drv_generic_serial_write(data, len);
}

static void drv_D4D_send(const char *data, const unsigned int len)
{
    drv_D4D_send_nowait(data, len);
    drv_D4D_receive_ACK();
}

static void drv_D4D_send_extra_nowait(const char *data, const unsigned int len, unsigned char pos1, unsigned char pos2,
				      unsigned char pos3, unsigned char pos4)
{
    /* possibly leave out bytes at posn for GOLDELOX protocol format */
    if (EXTRA) {
	drv_D4D_send_nowait(data, len);
    } else {
	unsigned int i, j = 0, lenNew = len;
	char send[len];
	for (i = 0; i < len; i++) {
	    if (i != pos1 && i != pos2 && i != pos3 && i != pos4) {
		send[j++] = data[i];
	    } else {
		lenNew--;
	    }
	}
	drv_D4D_send_nowait(send, lenNew);
    }
}

static void drv_D4D_send_extra(const char *data, const unsigned int len, unsigned char pos1, unsigned char pos2,
			       unsigned char pos3, unsigned char pos4)
{
    drv_D4D_send_extra_nowait(data, len, pos1, pos2, pos3, pos4);
    drv_D4D_receive_ACK();
}


static int drv_D4D_open(const char *section)
{
    info("drv_D4D_open()");
    int fd, picaso = 0;
    struct termios portset;
    static speed_t Speed = 0;
    fd = drv_generic_serial_open(section, Name, 0);
    if (fd < 0)
	return -1;
    int flags;
    flags = fcntl(fd, F_GETFL);
    flags &= ~FNDELAY;
    fcntl(fd, F_SETFL, flags);

    cfg_number(section, "PICASO", 0, 1200, 4000000, &picaso);
    if (picaso) {
	info("switching to 9600 baud");
	if (tcgetattr(fd, &portset) == -1) {
	    error("%s: tcgetattr failed: %s", Name, strerror(errno));
	    return -1;
	}
	cfsetispeed(&portset, B9600);
	cfsetospeed(&portset, B9600);
	if (tcsetattr(fd, TCSANOW, &portset) == -1) {
	    error("%s: tcsetattr failed: %s", Name, strerror(errno));
	    return -1;
	}
    }

    char cmd[] = { 'U' };
    drv_D4D_send(cmd, sizeof(cmd));
    debug("2");

    if (picaso) {
	char baud[] = { 'Q', 0 };
	switch (picaso) {
	case 1200:
	    Speed = B1200;
	    baud[1] = 0x03;
	    break;
	case 2400:
	    Speed = B2400;
	    baud[1] = 0x04;
	    break;
	case 4800:
	    Speed = B4800;
	    baud[1] = 0x05;
	    break;
	case 9600:
	    Speed = B9600;
	    baud[1] = 0x06;
	    break;
	case 19200:
	    Speed = B19200;
	    baud[1] = 0x08;
	    break;
	case 38400:
	    Speed = B38400;
	    baud[1] = 0x0A;
	    break;
	case 57600:
	    Speed = B57600;
	    baud[1] = 0x0B;
	    break;
	case 115200:
	    Speed = B115200;
	    baud[1] = 0x0D;
	    break;
	default:
	    if (picaso >= 128000 && picaso < 256000) {	/* FTDI: 129032 */
		Speed = B38400;
		baud[1] = 0x0E;
		break;
	    } else if (picaso >= 256000) {	/* FTDI: 282353 */
		Speed = B38400;
		baud[1] = 0x0F;
		break;
	    }
	    error("%s: unsupported speed '%d' from %s", Name, picaso, cfg_source());
	    return -1;
	}
	drv_D4D_send_nowait(baud, sizeof(baud));
	sleep(1);
	debug("3");
	cfsetispeed(&portset, Speed);
	cfsetospeed(&portset, Speed);
	if (picaso >= 128000) {
	    struct serial_struct sstruct;
	    if (ioctl(fd, TIOCGSERIAL, &sstruct) < 0) {
		error("Error: could not get comm ioctl\n");
		return -1;
	    }
	    sstruct.custom_divisor = sstruct.baud_base / picaso;
	    info("baud_base=%d; custom_divisor=%d -> effective baud:%d", sstruct.baud_base, sstruct.custom_divisor,
		 sstruct.baud_base / sstruct.custom_divisor);
	    sstruct.flags |= ASYNC_SPD_CUST;
	    if (ioctl(fd, TIOCSSERIAL, &sstruct) < 0) {
		error("Error: could not set custom comm baud divisor\n");
		return -1;
	    }
	}
	debug("4");
	info("switching to %d baud", picaso);
	if (tcsetattr(fd, /*TCSANOW*/ TCSAFLUSH /*TCSADRAIN*/, &portset) == -1) {
	    error("%s: tcsetattr failed: %s", Name, strerror(errno));
	    return -1;
	}
	debug("5");

    }

    return 0;
}


static int drv_D4D_close(void)
{
    drv_generic_serial_close();
    return 0;
}


static void drv_D4D_clear(void)
{
    char cmd[] = { 'E' };
    drv_D4D_send(cmd, sizeof(cmd));
}


static void drv_D4D_write(const int row, const int col, const char *data, int len)
{
    char out[len];
    char user_char[len];
    int user_x[len];
    int user_y[len];
    int i, k = 0;

    if (!SECTOR) {		/* font in ROM */

	for (i = 0; i < len; i++) {
	    if (data[i] >= 31 && data[i] < CHAR0) {
		out[i] = data[i];
	    } else if (data[i] == 'µ') {	/* mu */
		if (FONT == 2)
		    out[i] = 31;	/* undocumented */
		else if (FONT == 0)
		    out[i] = 'u';
		else
		    out[i] = 127;	/* undocumented */
	    } else {
		out[i] = ' ';
		if (data[i] == '°')
		    user_char[k] = 0;	/* degree */
		else
		    user_char[k] = data[i] - CHAR0;
		user_x[k] = (col + i) * XRES;
		user_y[k] = row * YRES;
		k++;
	    }
	}

	char cmd[] = { 's', col, row, FONT, msb(FG_COLOR), lsb(FG_COLOR) };	/* normal chars */
	drv_D4D_send_nowait(cmd, sizeof(cmd));
	if (len > 256)
	    len = 256;
	drv_D4D_send_nowait(out, len);
	char cmdNull[1];
	cmdNull[0] = 0;
	drv_D4D_send(cmdNull, 1);

	/*                       1, 2, 3, 4, 5, 6
	   g, c,mx,lx,my,ly */
	char cmd_user[] = { 'D', 0, 0, 0, 0, 0, 0, msb(FG_COLOR), lsb(FG_COLOR) };	/* user defined symbols */
	for (i = 0; i < k; i++) {
	    cmd_user[2] = user_char[i];
	    cmd_user[3] = msb(user_x[i]);
	    cmd_user[4] = lsb(user_x[i]);
	    cmd_user[5] = msb(user_y[i]);
	    cmd_user[6] = lsb(user_y[i]);
	    drv_D4D_send_extra(cmd_user, sizeof(cmd_user), 1, 3, 5, -1);
	}
    } else {			/* font on SD card */
	int sec;
	/*                          2, 3, 4              , 5              , 6        , 7        , 8        , 9        , 10,11,12,13
	   mx,lx, my             , ly             , mw       , lw       , mh       , lh       , cm,hs,ms,ls */
	char cmd_sd[] =
	    { '@', 'I', 0, 0, msb(row * YRES), lsb(row * YRES), msb(XRES), lsb(XRES), msb(YRES), lsb(YRES), 16, 0, 0,
	    0
	};
	for (i = 0; i < len; i++) {
	    cmd_sd[2] = msb((col + i) * XRES);
	    cmd_sd[3] = lsb((col + i) * XRES);
	    sec = SECTOR + (unsigned char) data[i] * SECTOR_SIZE;
	    cmd_sd[11] = address_hi(sec);
	    cmd_sd[12] = address_mid(sec);
	    cmd_sd[13] = address_lo(sec);
	    drv_D4D_send_extra(cmd_sd, sizeof(cmd_sd), 2, 4, 6, 8);
	}
    }
}


static void drv_D4D_defchar(const int ascii, const unsigned char *matrix)
{
    info("drv_D4D_defchar");
    char cmd[11];
    int i;

    cmd[0] = 'A';
    cmd[1] = 0;
    cmd[2] = ascii - CHAR0;

    for (i = 0; i < 8; i++) {
	cmd[i + 3] = *matrix++;
    }
    drv_D4D_send_extra(cmd, sizeof(cmd), 1, -1, -1, -1);
}


static void drv_D4D_blit(const int row, const int col, const int height, const int width)
{
    debug("drv_D4D_blit(%i, %i, %i, %i)", row, col, height, width);
    int r, c;
    RGBA rgb;
    short int color;
    char colorArray[width * height * MODE / 8];

    /* optimization: single colour rectangle? */
    /* commented out because obviously seldom used and expensive */
    /*RGBA pixel0_0, pixel;
       pixel0_0 = drv_generic_graphic_rgb(row, col);
       char unicolor = 1;
       for (r = row; (r < row + height) && unicolor; r++) {
       for (c = col; (c < col + width) && unicolor; c++) {
       pixel = drv_generic_graphic_rgb(r, c);
       if (pixel0_0.R != pixel.R || pixel0_0.G != pixel.G || pixel0_0.B != pixel.B || pixel0_0.A != pixel.A)
       unicolor = 0;
       }
       }

       if (unicolor) {
       color = RGB_24to16(pixel0_0.R, pixel0_0.G, pixel0_0.B);
       unsigned char col2 = col + width - 1;
       unsigned char row2 = row + height - 1;
       char cmdRect[] =
       { 'r', msb(col), lsb(col), msb(row), lsb(row), msb(col2), lsb(col2), msb(row2), lsb(row2), msb(color),
       lsb(color)
       };
       debug("Rectangle(%i, %i, %i, %i, %i", col, row, col2, row2, color);
       drv_D4D_send_extra(cmdRect, sizeof(cmdRect), 1, 3, 5, 7);
       } else { */
    char cmd[] =
	{ 'I', msb(col), lsb(col), msb(row), lsb(row), msb(width), lsb(width), msb(height), lsb(height), MODE };
    int p = 0;
    drv_D4D_send_extra_nowait(cmd, sizeof(cmd), 1, 3, 5, 7);
    for (r = row; r < row + height; r++) {
	for (c = col; c < col + width; c++) {
	    rgb = drv_generic_graphic_rgb(r, c);
	    if (MODE == 8) {
		colorArray[p++] = RGB_24to8(rgb.R, rgb.G, rgb.B);
	    } else {
		color = RGB_24to16(rgb.R, rgb.G, rgb.B);
		colorArray[p++] = msb(color);
		colorArray[p++] = lsb(color);
	    }
	}
    }
    drv_D4D_send_nowait(colorArray, width * height * MODE / 8);	/* doesn't werk if sent together (error: "partial write(/dev/tts/1): len=2 ret=1") */
    drv_D4D_receive_ACK();
    /*} */
}


static int drv_D4D_contrast(int contrast)
{
    if (contrast < 0)
	contrast = 0;
    if (contrast > 15)
	contrast = 15;

    char cmd[] = { 'Y', 2, contrast };
    drv_D4D_send(cmd, sizeof(cmd));

    /* CONTRAST_=contrast; */
    return contrast;
}


static int drv_D4D_start(const char *section)
{
    info("drv_D4D_start()");
    int contrast;
    int xres_cfg = -1, yres_cfg = -1;
    char *s;
    char *color;

    if (drv_D4D_open(section) < 0) {
	return -1;
    }

    char getVersion[] = { 'V', 0 /*1 */  };
    drv_D4D_send_nowait(getVersion, sizeof(getVersion));
    char answer[5];
    debug("reading answer[0]");
    drv_generic_serial_read(answer + 0, 1);	/* ,5: PICASO 0/1, Speed 9600: error: "partial read(/dev/ttyUSB0): len=5 ret=1" */
    debug("reading answer[1]");
    drv_generic_serial_read(answer + 1, 1);
    debug("reading answer[2]");
    drv_generic_serial_read(answer + 2, 1);
    debug("reading answer[3]");
    drv_generic_serial_read(answer + 3, 1);
    debug("reading answer[4]");
    drv_generic_serial_read(answer + 4, 1);
    char *ids[] = { "uOLED", "uLCD", "uVGA" };
    char *id;
    if (answer[0] <= 2)
	id = ids[(int) answer[0]];
    else
	id = "Unknown";
    qprintf(NAME_, sizeof(NAME_), "%s H%u S%u", id, (int) answer[1], (int) answer[2]);
    int res[2];
    int i;
    for (i = 0; i < 2; i++) {
	switch ((unsigned char) answer[3 + i]) {
	case 0x22:
	    res[i] = 220;
	    break;
	case 0x28:
	    res[i] = 128;
	    break;
	case 0x32:
	    res[i] = 320;
	    EXTRA = 1;
	    break;
	case 0x60:
	    res[i] = 160;
	    break;
	case 0x64:
	    res[i] = 64;
	    break;
	case 0x76:
	    res[i] = 176;
	    break;
	case 0x96:
	    res[i] = 96;
	    break;
	case 0x24:		/* undocumented? */
	    res[i] = 240;
	    break;
	default:
	    error("Can't detect display dimensions! answer: {%d, %d, %d, %d, %d}", answer[0], answer[1], answer[2],
		  answer[3], answer[4]);
	    return -1;
	}
    }
    DCOLS = res[0];
    DROWS = res[1];


    cfg_number(section, "Mode", 0, 0, 16, &MODE);

    if (MODE == 0) {
	s = cfg_get(section, "Font", NULL);
	if (s == NULL || *s == '\0') {
	    error("%s: no '%s.Font' entry from %s", Name, section, cfg_source());
	    return -1;
	}
	if (sscanf(s, "%dx%d", &xres_cfg, &yres_cfg) < 1 || xres_cfg < 0) {
	    error("%s: bad %s.Font '%s' from %s", Name, section, s, cfg_source());
	    free(s);
	    return -1;
	}

	if (yres_cfg == -1) {	/* font on SD card */
	    SECTOR = xres_cfg * 512;
	    char setAddress[] =
		{ '@', 'A', address_mmsb(SECTOR), address_mlsb(SECTOR), address_lmsb(SECTOR), address_llsb(SECTOR) };
	    drv_D4D_send(setAddress, sizeof(setAddress));
	    char answer1[1];
	    char readByte[] = { '@', 'r' };
	    drv_D4D_send_nowait(readByte, sizeof(readByte));
	    drv_generic_serial_read(answer1, sizeof(answer1));
	    XRES = answer1[0];
	    drv_D4D_send_nowait(readByte, sizeof(readByte));
	    drv_generic_serial_read(answer1, sizeof(answer1));
	    YRES = answer1[0];
	    SECTOR = xres_cfg + 1;
	    SECTOR_SIZE = ceil((double) XRES * (double) YRES * 2.0 / 512.0);
	} else {
	    XRES = xres_cfg;
	    YRES = yres_cfg;
	}


	color = cfg_get(section, "foreground", "ffffff");
	if (color2RGBA(color, &FG_COL_) < 0) {
	    error("%s: ignoring illegal color '%s'", Name, color);
	}
	if (color)
	    free(color);
	FG_COLOR = RGB_24to16(FG_COL_.R, FG_COL_.G, FG_COL_.B);

	color = cfg_get(section, "background", "000000");
	if (color2RGBA(color, &BG_COL_) < 0) {
	    error("%s: ignoring illegal color '%s'", Name, color);
	}
	if (color)
	    free(color);
	BG_COLOR = RGB_24to16(BG_COL_.R, BG_COL_.G, BG_COL_.B);

	DCOLS = DCOLS / XRES;
	DROWS = DROWS / YRES;
	switch (yres_cfg) {	/* font in ROM */
	case 8:
	    switch (xres_cfg) {
	    case 6:
		FONT = 0;
		break;
	    case 8:
		FONT = 1;
		break;
	    default:
		error("%s: unknown width in %s.Font '%s' from %s", Name, section, s, cfg_source());
		return -1;
	    };
	    break;
	case 12:
	    FONT = 2;
	    break;
	case 16:
	    FONT = 3;
	    break;
	case -1:
	    break;
	default:
	    error("%s: unknown height in %s.Font '%s' from %s", Name, section, s, cfg_source());
	    return -1;
	}
    }

    info("XRES=%i, YRES=%i;  DCOLS=%i, DROWS=%d;  FONT=%d, SECTOR=%i, SECTOR_SIZE=%i\n", XRES, YRES, DCOLS, DROWS,
	 FONT, SECTOR, SECTOR_SIZE);



    cfg_number(section, "PowerCycle", 0, 0, 1, &POWERCYCLE);
    if (POWERCYCLE) {
	char powerOn[] = { 'Y', 3, 1 };
	drv_D4D_send(powerOn, sizeof(powerOn));

	/*char background[] = {'B', msb(BG_COLOR), lsb(BG_COLOR)};
	   drv_D4D_send(background, sizeof(background)); */
    }

    char opaque[] = { 'O', 1 };
    drv_D4D_send(opaque, sizeof(opaque));

    char penSize[] = { 'p', 0 };
    drv_D4D_send(penSize, sizeof(penSize));


    if (!MODE) {
	unsigned char buffer[] = { 0x18, 0x24, 0x24, 0x18, 0, 0, 0, 0 };	/* degree */
	drv_D4D_defchar(CHAR0, buffer);
	CHARS--;
	CHAR0++;
    }

    if (cfg_number(section, "Contrast", 0, 0, 255, &contrast) > 0) {
	drv_D4D_contrast(contrast);
    }

    drv_D4D_clear();

    return 0;
}


int drv_D4D_text_draw(WIDGET * W)
{
    short int FG_COLOR_old = FG_COLOR, BG_COLOR_old = BG_COLOR;
    int ret;
    RGBA fg, bg;
    fg = W->fg_valid ? W->fg_color : FG_COL_;
    bg = W->bg_valid ? W->bg_color : BG_COL_;
    FG_COLOR = RGB_24to16(fg.R, fg.G, fg.B);
    BG_COLOR = RGB_24to16(bg.R, bg.G, bg.B);
    ret = drv_generic_text_draw(W);
    FG_COLOR = FG_COLOR_old;
    BG_COLOR = BG_COLOR_old;
    return ret;
}


int lastVal[40 * 40 * 2];	/* Fixme: MAX_WIDGETS*2 */
int drv_D4D_bar_draw(WIDGET * W)
{
    /* optimizations:
       - draw filled rectangles instead of user defined bar characters
       - cache last values */

    WIDGET_BAR *Bar = W->data;
    int row, col, len, res, max, val1, val2;
    DIRECTION dir;
#if 0
    STYLE style;		/* Fixme: missing style support */
#endif

    row = W->row;
    col = W->col;
    dir = Bar->direction;
#if 0
    style = Bar->style;		/* Fixme: missing style support */
#endif
    len = Bar->length;

    res = dir & (DIR_EAST | DIR_WEST) ? XRES : YRES;
    max = len * res;
    val1 = Bar->val1 * (double) (max);
    val2 = Bar->val2 * (double) (max);

    if (val1 < 1)
	val1 = 1;
    else if (val1 > max)
	val1 = max;

    if (val2 < 1)
	val2 = 1;
    else if (val2 > max)
	val2 = max;

    short int FG_COLOR_old = FG_COLOR, BG_COLOR_old = BG_COLOR;
    RGBA fg, bg;
    fg = W->fg_valid ? W->fg_color : FG_COL_;
    bg = W->bg_valid ? W->bg_color : BG_COL_;
    FG_COLOR = RGB_24to16(fg.R, fg.G, fg.B);
    BG_COLOR = RGB_24to16(bg.R, bg.G, bg.B);

    char cmd[11];
    cmd[0] = 'r';
    int val[2];
    val[0] = val1;
    val[1] = val2;
    int i, vals, x1, x2;
    int lastValIndex0 = row * DCOLS + col;
    int cells = DROWS * DCOLS;
    if (val1 == val2 && lastVal[lastValIndex0] == lastVal[lastValIndex0 + cells])
	vals = 1;
    else
	vals = 2;
    for (i = 0; i < vals; i++) {
	int lastValIndex = lastValIndex0 + cells * (i /*+1 */ );
	int y1 = row * YRES + (YRES / 2) * i;
	cmd[3] = msb(y1);
	cmd[4] = lsb(y1);
	int y2 = y1 + YRES / vals - 1;
	cmd[7] = msb(y2);
	cmd[8] = lsb(y2);
	if (val[i] > lastVal[lastValIndex]) {
	    x1 = col * XRES + lastVal[lastValIndex];
	    cmd[1] = msb(x1);
	    cmd[2] = lsb(x1);
	    x2 = x1 + val[i] - lastVal[lastValIndex] - 1;
	    cmd[5] = msb(x2);
	    cmd[6] = lsb(x2);
	    cmd[9] = msb(FG_COLOR);
	    cmd[10] = lsb(FG_COLOR);
	    drv_D4D_send_extra(cmd, sizeof(cmd), 1, 3, 5, 7);
	} else if (val[i] < lastVal[lastValIndex]) {
	    x1 = col * XRES + val[i] - 1 + 1;
	    cmd[1] = msb(x1);
	    cmd[2] = lsb(x1);
	    x2 = x1 + lastVal[lastValIndex] - val[i];
	    cmd[5] = msb(x2);
	    cmd[6] = lsb(x2);
	    cmd[9] = msb(BG_COLOR);
	    cmd[10] = lsb(BG_COLOR);
	    drv_D4D_send_extra(cmd, sizeof(cmd), 1, 3, 5, 7);
	} else {
	    /* do nothing */
	}
	lastVal[lastValIndex] = val[i];
    }

    FG_COLOR = FG_COLOR_old;
    BG_COLOR = BG_COLOR_old;
    return 0;
}





/****************************************/
/***            plugins               ***/
/****************************************/

static void plugin_contrast(RESULT * result, RESULT * arg1)
{
    double contrast;

    contrast = drv_D4D_contrast(R2N(arg1));
    SetResult(&result, R_NUMBER, &contrast);
}


/****************************************/
/***        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        ***/
/****************************************/


int drv_D4D_list(void)
{
    printf("4D Systems Display Graphics Modules");
    return 0;
}


int drv_D4D_init(const char *section, const int quiet)
{
    info("drv_D4D_init()");
    WIDGET_CLASS wc;
    int ret;

    info("%s: %s", Name, "$Rev$");

    if ((ret = drv_D4D_start(section)) != 0)
	return ret;

    if (EXTRA)
	CHARS = 64;
    else
	CHARS = 32;
    CHAR0 = 128;
    GOTO_COST = 7;

    if (MODE) {
	drv_generic_graphic_real_blit = drv_D4D_blit;
    } else {
	drv_generic_text_real_write = drv_D4D_write;
	drv_generic_text_real_defchar = drv_D4D_defchar;
    }




    if (!quiet) {
	char buffer[40];
	qprintf(buffer, sizeof(buffer), "%s %dx%d", NAME_, DCOLS, DROWS);
	if (MODE) {
	    if (drv_generic_graphic_greet(buffer, "www.4dsystems.com.au")) {
		sleep(3);
		drv_generic_graphic_clear();
	    }
	} else {
	    if (drv_generic_text_greet(buffer, "www.4dsystems.com.au")) {
		sleep(3);
		drv_D4D_clear();
	    }
	}
    }


    if (MODE) {
	if ((ret = drv_generic_graphic_init(section, Name)) != 0)
	    return ret;
    } else {

	if ((ret = drv_generic_text_init(section, Name)) != 0)
	    return ret;

	if ((ret = drv_generic_text_icon_init()) != 0)
	    return ret;

	if ((ret = drv_generic_text_bar_init(0)) != 0)
	    return ret;

	drv_generic_text_bar_add_segment(0, 0, 255, 32);


	wc = Widget_Text;
	wc.draw = drv_D4D_text_draw;
	widget_register(&wc);

	wc = Widget_Icon;
	wc.draw = drv_generic_text_icon_draw;
	widget_register(&wc);

	wc = Widget_Bar;
	wc.draw = drv_D4D_bar_draw;
	widget_register(&wc);

    }

    AddFunction("LCD::contrast", 1, plugin_contrast);

    return 0;
}


int drv_D4D_quit(const int quiet)
{
    info("drv_D4D_quit()");

    info("%s: shutting down.", Name);

    if (MODE == 0)
	drv_generic_text_quit();


    if (POWERCYCLE) {
	drv_D4D_clear();
    }

    if (!quiet) {
	if (MODE)
	    drv_generic_graphic_greet("goodbye!", NULL);
	else
	    drv_generic_text_greet("goodbye!", NULL);
    }

    /* fade */
    /*int i;
       for(i=CONTRAST_;i>=0;i--) {
       drv_D4D_contrast(i);
       usleep(1000);
       } */

    if (MODE)
	drv_generic_graphic_quit();

    if (POWERCYCLE) {
	char powerDown[] = { 'Y', 3, 0 };
	drv_D4D_send(powerDown, sizeof(powerDown));
    }

    if (EXTRA) {
	info("switching to 9600 baud");
	char baud[] = { 'Q', 0x06 };
	drv_D4D_send_nowait(baud, sizeof(baud));
    }

    info("closing connection");
    drv_D4D_close();

    return (0);
}



DRIVER drv_D4D = {
    .name = Name,
    .list = drv_D4D_list,
    .init = drv_D4D_init,
    .quit = drv_D4D_quit,
};