/* $Id: hash.c,v 1.26 2005/05/08 04:32:44 reinelt Exp $ * * hashes (associative arrays) * * 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. * * * $Log: hash.c,v $ * Revision 1.26 2005/05/08 04:32:44 reinelt * CodingStyle added and applied * * Revision 1.25 2005/01/18 06:30:23 reinelt * added (C) to all copyright statements * * Revision 1.24 2004/06/26 12:04:59 reinelt * * uh-oh... the last CVS log message messed up things a lot... * * Revision 1.23 2004/06/26 09:27:21 reinelt * * added '-W' to CFLAGS * changed all C++ comments to C ones * cleaned up a lot of signed/unsigned mistakes * * Revision 1.22 2004/06/20 10:09:56 reinelt * * 'const'ified the whole source * * Revision 1.21 2004/06/17 06:23:43 reinelt * * hash handling rewritten to solve performance issues * * Revision 1.20 2004/06/13 01:12:52 reinelt * * debug widgets changed (thanks to Andy Baxter) * * Revision 1.19 2004/06/01 06:45:30 reinelt * * some Fixme's processed * documented some code * * Revision 1.18 2004/05/31 16:39:06 reinelt * * added NULL display driver (for debugging/profiling purposes) * added backlight/contrast initialisation for matrixOrbital * added Backlight initialisation for Cwlinux * * Revision 1.17 2004/03/11 06:39:59 reinelt * big patch from Martin: * - reuse filehandles * - memory leaks fixed * - earlier busy-flag checking with HD44780 * - reuse memory for strings in RESULT and hash * - netdev_fast to wavid time-consuming regex * * Revision 1.16 2004/03/03 08:40:07 hejl * Fixed memory leak in hash_get_regex * * Revision 1.15 2004/03/03 04:44:16 reinelt * changes (cosmetics?) to the big patch from Martin * hash patch un-applied * * Revision 1.14 2004/03/03 03:47:04 reinelt * big patch from Martin Hejl: * - use qprintf() where appropriate * - save CPU cycles on gettimeofday() * - add quit() functions to free allocated memory * - fixed lots of memory leaks * * Revision 1.13 2004/02/27 06:07:55 reinelt * hash improvements from Martin * * Revision 1.12 2004/01/30 20:57:56 reinelt * HD44780 patch from Martin Hejl * dmalloc integrated * * Revision 1.11 2004/01/29 04:40:02 reinelt * every .c file includes "config.h" now * * Revision 1.10 2004/01/27 04:48:57 reinelt * bug with hash_age() fixed (thanks to Markus Keil for pointing this out) * * Revision 1.9 2004/01/22 07:57:45 reinelt * several bugs fixed where segfaulting on layout>display * Crystalfontz driver optimized, 632 display already works * * Revision 1.8 2004/01/21 14:29:03 reinelt * new helper 'hash_get_regex' which delivers the sum over regex matched items * new function 'disk()' which uses this regex matching * * Revision 1.7 2004/01/21 10:48:17 reinelt * hash_age function added * * Revision 1.6 2004/01/20 05:36:59 reinelt * moved text-display-specific stuff to drv_generic_text * moved all the bar stuff from drv_generic_bar to generic_text * * Revision 1.5 2004/01/18 09:01:45 reinelt * /proc/stat parsing finished * * Revision 1.4 2004/01/18 06:54:08 reinelt * bug in expr.c fixed (thanks to Xavier) * some progress with /proc/stat parsing * * Revision 1.3 2004/01/16 07:26:25 reinelt * moved various /proc parsing to own functions * made some progress with /proc/stat parsing * * Revision 1.2 2004/01/16 05:04:53 reinelt * started plugin proc_stat which should parse /proc/stat * which again is a paint in the a** * thinking over implementation methods of delta functions * (CPU load, ...) * * Revision 1.1 2004/01/13 10:03:01 reinelt * new util 'hash' for associative arrays * new plugin 'cpuinfo' * */ /* * exported functions: * * void hash_create (HASH *Hash); * initializes hash * * int hash_age (HASH *Hash, char *key, char **value); * return time of last hash_put * * void hash_put (HASH *Hash, char *key, char *val); * set an entry in the hash * * void hash_put_delta (HASH *Hash, char *key, char *val); * set a delta entry in the hash * * char *hash_get (HASH *Hash, char *key); * fetch an entry from the hash * * double hash_get_delta (HASH *Hash, char *key, int delay); * fetch a delta antry from the hash * * double hash_get_regex (HASH *Hash, char *key, int delay); * fetch one or more entries from the hash * * void hash_destroy (HASH *Hash); * releases hash * */ #include "config.h" #include #include #include #include #include "debug.h" #include "hash.h" #ifdef WITH_DMALLOC #include #endif /* number of slots for delta processing */ #define DELTA_SLOTS 64 /* string buffer chunk size */ #define CHUNK_SIZE 16 /* initialize a new hash table */ void hash_create(HASH * Hash) { Hash->sorted = 0; Hash->timestamp.tv_sec = 0; Hash->timestamp.tv_usec = 0; Hash->nItems = 0; Hash->Items = NULL; Hash->nColumns = 0; Hash->Columns = NULL; Hash->delimiter = strdup(" \t\n"); } /* bsearch compare function for hash items */ static int hash_lookup_item(const void *a, const void *b) { char *key = (char *) a; HASH_ITEM *item = (HASH_ITEM *) b; return strcasecmp(key, item->key); } /* qsort compare function for hash items */ static int hash_sort_item(const void *a, const void *b) { HASH_ITEM *ha = (HASH_ITEM *) a; HASH_ITEM *hb = (HASH_ITEM *) b; return strcasecmp(ha->key, hb->key); } /* bsearch compare function for hash headers */ static int hash_lookup_column(const void *a, const void *b) { char *key = (char *) a; HASH_COLUMN *column = (HASH_COLUMN *) b; return strcasecmp(key, column->key); } /* qsort compare function for hash headers */ static int hash_sort_column(const void *a, const void *b) { HASH_COLUMN *ha = (HASH_COLUMN *) a; HASH_COLUMN *hb = (HASH_COLUMN *) b; return strcasecmp(ha->key, hb->key); } /* split a value into columns and */ /* return the nth column in a string */ /* WARNING: does return a pointer to a static string!! */ static char *split(const char *val, const int column, const char *delimiter) { static char buffer[256]; int num; size_t len; const char *beg, *end; if (column < 0) return (char *) val; if (val == NULL) return NULL; num = 0; len = 0; beg = val; end = beg; while (beg && *beg) { while (strchr(delimiter, *beg)) beg++; end = strpbrk(beg, delimiter); if (num++ == column) break; beg = end ? end + 1 : NULL; } if (beg != NULL) { len = end ? (size_t) (end - beg) : strlen(beg); if (len >= sizeof(buffer)) len = sizeof(buffer) - 1; strncpy(buffer, beg, len); } buffer[len] = '\0'; return buffer; } /* search an entry in the hash table: */ /* If the table is flagged "sorted", the entry is looked */ /* up using the bsearch function. If the table is */ /* unsorted, it will be searched in a linear way */ static HASH_ITEM *hash_lookup(HASH * Hash, const char *key, const int do_sort) { HASH_ITEM *Item = NULL; /* maybe sort the array */ if (do_sort && !Hash->sorted) { qsort(Hash->Items, Hash->nItems, sizeof(HASH_ITEM), hash_sort_item); Hash->sorted = 1; } /* no key was passed */ if (key == NULL) return NULL; /* lookup using bsearch */ if (Hash->sorted) { Item = bsearch(key, Hash->Items, Hash->nItems, sizeof(HASH_ITEM), hash_lookup_item); } /* linear search */ if (Item == NULL) { int i; for (i = 0; i < Hash->nItems; i++) { if (strcmp(key, Hash->Items[i].key) == 0) { Item = &(Hash->Items[i]); break; } } } return Item; } /* return the age in milliseconds of an entry from the hash table */ /* or from the hash table itself if key is NULL */ /* returns -1 if entry does not exist */ int hash_age(HASH * Hash, const char *key) { HASH_ITEM *Item; struct timeval now, *timestamp; if (key == NULL) { timestamp = &(Hash->timestamp); } else { Item = hash_lookup(Hash, key, 1); if (Item == NULL) return -1; timestamp = &(Item->Slot[Item->index].timestamp); } gettimeofday(&now, NULL); return (now.tv_sec - timestamp->tv_sec) * 1000 + (now.tv_usec - timestamp->tv_usec) / 1000; } /* add an entry to the column header table */ void hash_set_column(HASH * Hash, const int number, const char *column) { if (Hash == NULL) return; Hash->nColumns++; Hash->Columns = realloc(Hash->Columns, Hash->nColumns * sizeof(HASH_COLUMN)); Hash->Columns[Hash->nColumns - 1].key = strdup(column); Hash->Columns[Hash->nColumns - 1].val = number; qsort(Hash->Columns, Hash->nColumns, sizeof(HASH_COLUMN), hash_sort_column); } /* fetch a column number by column header */ static int hash_get_column(HASH * Hash, const char *key) { HASH_COLUMN *Column; if (key == NULL || *key == '\0') return -1; Column = bsearch(key, Hash->Columns, Hash->nColumns, sizeof(HASH_COLUMN), hash_lookup_column); if (Column == NULL) return -1; return Column->val; } /* set column delimiters */ void hash_set_delimiter(HASH * Hash, const char *delimiter) { if (Hash->delimiter != NULL) free(Hash->delimiter); Hash->delimiter = strdup(delimiter); } /* get a string from the hash table */ char *hash_get(HASH * Hash, const char *key, const char *column) { HASH_ITEM *Item; int c; Item = hash_lookup(Hash, key, 1); if (Item == NULL) return NULL; c = hash_get_column(Hash, column); return split(Item->Slot[Item->index].value, c, Hash->delimiter); } /* get a delta value from the delta table */ double hash_get_delta(HASH * Hash, const char *key, const char *column, const int delay) { HASH_ITEM *Item; HASH_SLOT *Slot1, *Slot2; int i, c; double v1, v2; double dv, dt; struct timeval now, end; /* lookup item */ Item = hash_lookup(Hash, key, 1); if (Item == NULL) return 0.0; /* this is the "current" Slot */ Slot1 = &(Item->Slot[Item->index]); /* fetch column number */ c = hash_get_column(Hash, column); /* if delay is zero, return absolute value */ if (delay == 0) return atof(split(Slot1->value, c, Hash->delimiter)); /* prepare timing values */ now = Slot1->timestamp; end.tv_sec = now.tv_sec; end.tv_usec = now.tv_usec - 1000 * delay; while (end.tv_usec < 0) { end.tv_sec--; end.tv_usec += 1000000; } /* search delta slot */ Slot2 = &(Item->Slot[Item->index]); for (i = 1; i < Item->nSlot; i++) { Slot2 = &(Item->Slot[(Item->index + i) % Item->nSlot]); if (Slot2->timestamp.tv_sec == 0) break; if (timercmp(&(Slot2->timestamp), &end, <)) break; } /* empty slot => try the one before */ if (Slot2->timestamp.tv_sec == 0) { i--; Slot2 = &(Item->Slot[(Item->index + i) % Item->nSlot]); } /* not enough slots available... */ if (i == 0) return 0.0; /* delta value, delta time */ v1 = atof(split(Slot1->value, c, Hash->delimiter)); v2 = atof(split(Slot2->value, c, Hash->delimiter)); dv = v1 - v2; dt = (Slot1->timestamp.tv_sec - Slot2->timestamp.tv_sec) + (Slot1->timestamp.tv_usec - Slot2->timestamp.tv_usec) / 1000000.0; if (dt > 0.0 && dv >= 0.0) return dv / dt; return 0.0; } /* get a delta value from the delta table */ /* key may contain regular expressions, and the sum */ /* of all matching entries is returned. */ double hash_get_regex(HASH * Hash, const char *key, const char *column, const int delay) { double sum; regex_t preg; int i, err; err = regcomp(&preg, key, REG_ICASE | REG_NOSUB); if (err != 0) { char buffer[32]; regerror(err, &preg, buffer, sizeof(buffer)); error("error in regular expression: %s", buffer); regfree(&preg); return 0.0; } /* force the table to be sorted by requesting anything */ hash_lookup(Hash, NULL, 1); sum = 0.0; for (i = 0; i < Hash->nItems; i++) { if (regexec(&preg, Hash->Items[i].key, 0, NULL, 0) == 0) { sum += hash_get_delta(Hash, Hash->Items[i].key, column, delay); } } regfree(&preg); return sum; } /* insert a key/val pair into the hash table */ /* If the entry does already exist, it will be overwritten, */ /* and the table stays sorted (if it has been before). */ /* Otherwise, the entry is appended at the end, and */ /* the table will be flagged 'unsorted' afterwards */ static HASH_ITEM *hash_set(HASH * Hash, const char *key, const char *value, const int delta) { HASH_ITEM *Item; HASH_SLOT *Slot; int size; Item = hash_lookup(Hash, key, 0); if (Item == NULL) { /* add entry */ Hash->sorted = 0; Hash->nItems++; Hash->Items = realloc(Hash->Items, Hash->nItems * sizeof(HASH_ITEM)); Item = &(Hash->Items[Hash->nItems - 1]); Item->key = strdup(key); Item->index = 0; Item->nSlot = delta; Item->Slot = malloc(Item->nSlot * sizeof(HASH_SLOT)); memset(Item->Slot, 0, Item->nSlot * sizeof(HASH_SLOT)); } else { /* maybe enlarge delta table */ if (Item->nSlot < delta) { Item->nSlot = delta; Item->Slot = realloc(Item->Slot, Item->nSlot * sizeof(HASH_SLOT)); } } if (Item->nSlot > 1) { /* move the pointer to the next free slot, wrap around if necessary */ if (--Item->index < 0) Item->index = Item->nSlot - 1; } /* create entry */ Slot = &(Item->Slot[Item->index]); size = strlen(value) + 1; /* maybe enlarge value buffer */ if (size > Slot->size) { /* buffer is either empty or too small */ /* allocate memory in multiples of CHUNK_SIZE */ Slot->size = CHUNK_SIZE * (size / CHUNK_SIZE + 1); Slot->value = realloc(Slot->value, Slot->size); } /* set value */ strcpy(Slot->value, value); /* set timestamps */ gettimeofday(&(Hash->timestamp), NULL); Slot->timestamp = Hash->timestamp; return Item; } /* insert a string into the hash table */ /* without delta processing */ void hash_put(HASH * Hash, const char *key, const char *value) { hash_set(Hash, key, value, 1); } /* insert a string into the hash table */ /* with delta processing */ void hash_put_delta(HASH * Hash, const char *key, const char *value) { hash_set(Hash, key, value, DELTA_SLOTS); } void hash_destroy(HASH * Hash) { int i; if (Hash->Items) { /* free all headers */ for (i = 0; i < Hash->nColumns; i++) { if (Hash->Columns[i].key) free(Hash->Columns[i].key); } /* free header table */ free(Hash->Columns); /* free all items */ for (i = 0; i < Hash->nItems; i++) { if (Hash->Items[i].key) free(Hash->Items[i].key); if (Hash->Items[i].Slot) free(Hash->Items[i].Slot); } /* free items table */ free(Hash->Items); } Hash->sorted = 0; Hash->nItems = 0; Hash->Items = NULL; } 385'>385 386 387 388 389 
/* $Id$
 * $URL$
 * 
 * Driver for a Noritake GU128x32-311 graphical display.
 * 
 * Copyright (C) 2005 Julien Aube <ob@obconseil.net>
 * Copyright (C) 2005 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.
 *
 */

/*
 * *** Noritake Itron GU128x32-311 ***
 * A 128x32 VFD (Vacuum Fluorescent Display).
 * It is driver by a Hitachi microcontroller, with a specific 
 * firmware. 
 * The datasheet can be easily found on the internet by searching for the 
 * the name of the display, it's a PDF file that describe the timing, and 
 * the protocol to communicate with the Hitachi microcontroller.
 * 
 * The display support 2 modes (that can be mutiplexed), one text mode
 * thanks to an integrated character generator, and provide 4 lines of 
 * 21 caracters.
 * There is also a graphical mode that can be used to switch on or off
 * each one if the 128x32 pixels. (monochrome).
 * 
 * The protocol include the possibility to clear the display memory quickly,
 * change the luminosity, swich the display on or off (without affecting the 
 * content of the memory) and finally change the "page" or the caracter 
 * generator. Two pages are available in the ROM, all the characters are 
 * listed in the documentation.
 *
 * This driver support only the character mode at the moment.
 * A future release will support the graphical mode as an option.
 * 
 * This driver is released under the GPL.
 */

/* 
 *
 * exported fuctions:
 *
 * struct DRIVER drv_Noritake
 *
 */

#include "config.h"

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

#include "debug.h"
#include "cfg.h"
#include "qprintf.h"
#include "plugin.h"
#include "widget.h"
#include "widget_text.h"
#include "widget_icon.h"
#include "widget_bar.h"
#include "drv.h"
#include "udelay.h"
#include "drv_generic_text.h"
#include "drv_generic_parport.h"


static char Name[] = "Noritake";

typedef struct {
    int type;
    char *name;
    int rows;
    int cols;
    int xres;
    int yrex;
    int goto_cost;
    int protocol;
} MODEL;

static int Model, Protocol;
static MODEL Models[] = {
    {0x01, "GU311", 4, 21, 6, 8, 5, 1},
    {0x02, "GU311_Graphic", 4, 21, 6, 8, 6, 1},
    {0xff, "Unknown", -1, -1, -1, -1, -1, -1}
};

static unsigned char SIGNAL_CS;	/* Chip select, OUTPUT, negative logic, pport AUTOFEED */
static unsigned char SIGNAL_WR;	/* Write        OUTPUT, negative logic, pport STOBE */
static unsigned char SIGNAL_RESET;	/* Reset,       OUTPUT, negative logic, pport INIT */
static unsigned char SIGNAL_BLANK;	/* Blank,       OUTPUT , negative logic, pport SELECT-IN */

#if 0
static unsigned char SIGNAL_BUSY;	/* Busy,        INPUT , positive logic, pport BUSY, not used */
static unsigned char SIGNAL_FRP;	/* Frame Pulse, INPUT , positive logic, pport ACK, not used */
#endif

void (*drv_Noritake_clear) (void);

/* Data port is positive logic */


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

/* Low-level parport driving functions */

/* This function was used to pool the BUSY line on the parallel port, which 
can be linked to the BUSY line on the display. But since it works 
with a timed wait, this function is not necessary, and is kept just in case.*/
#if 0
static void drv_GU311_wait_busy(void)
{
    char c;

    c = drv_generic_parport_status();
    while ((c & SIGNAL_BUSY) == 0) {
	ndelay(200);		/* Wait 100ns before next consultation of BUSY line 
				   if the first one was not successful */
	c = drv_generic_parport_status();
    }
}
#endif


static void drv_GU311_send_char(char c)
{
#if 0
    /* Disabled because all the cables does not have the busy line linked. */
    drv_GU311_wait_busy();	/* ensuite the display is ready to take the command */
#endif
    drv_generic_parport_data(c);
    ndelay(30);			/* delay to ensure data line stabilisation on long cables */
    drv_generic_parport_control(SIGNAL_WR, 0);	/* write line to enable */
    ndelay(150);		/* data hold time */
    drv_generic_parport_control(SIGNAL_WR, 0xff);	/* write line to disable */
    ndelay(75);			/* From spec : minimum time before next command */
}

static void drv_GU311_send_string(char *str, int size)
{
    int i;
    for (i = 0; i < size; i++)
	drv_GU311_send_char(str[i]);

}

/* Command-string elaboration functions */
static void drv_GU311_make_text_string(const int row, const int col, const char *data, int len)
{
    static char cmd[96] = { 0x01, 'C', 0, 0, 'S', 0 };
    unsigned char start_addr;

    /* Cols are 0x00..0x15, on 4 lines. */
    start_addr = (0x16 * row) + col;
    if (start_addr > 0x57)
	return;
    if (len > 0x57)
	return;

    cmd[2] = start_addr;
    cmd[3] = len;

    memcpy(cmd + 5, data, len);

    drv_GU311_send_string(cmd, len + 5);

}

/* API functions */

static void drv_GU311_clear(void)
{
    static char clear_cmd[] = { 0x01, 'O', 'P' };
    drv_GU311_send_string(clear_cmd, sizeof(clear_cmd));
    ndelay(500);		/* Delay for execution - this command is the longuest */
}


static void drv_GU311_write(const int row, const int col, const char *data, int len)
{
    drv_GU311_make_text_string(row, col, data, len);
}


static void drv_GU311_reset(void)
{
    drv_generic_parport_control(SIGNAL_RESET, 0);	/* initiate reset */
    ndelay(1000);		/* reset hold time 1ms */
    drv_generic_parport_control(SIGNAL_RESET, 0xff);
    ndelay(200000);		/* reset ready time 200ms */

}


static int drv_GU311_start(const char *section)
{
    char cmd[3] = { 0x01, 'O' };

    /* Parallel port opening and association */
    if (drv_generic_parport_open(section, Name) < 0)
	return -1;
    if ((SIGNAL_CS = drv_generic_parport_wire_ctrl("CS", "AUTOFD")) == 0xff)
	return -1;
    if ((SIGNAL_WR = drv_generic_parport_wire_ctrl("WR", "STROBE")) == 0xff)
	return -1;
    if ((SIGNAL_RESET = drv_generic_parport_wire_ctrl("RESET", "INIT")) == 0xff)
	return -1;
    if ((SIGNAL_BLANK = drv_generic_parport_wire_ctrl("BLANK", "SLCTIN")) == 0xff)
	return -1;
    /* SIGNAL_BUSY=PARPORT_STATUS_BUSY; *//* Not currently needed */
    /* SIGNAL_FRP=PARPORT_STATUS_ACK;   *//* Not currently needed */

    /* Signals configuration */
    drv_generic_parport_direction(0);	/* parallel port in output mode */
    drv_generic_parport_control(SIGNAL_CS | SIGNAL_WR | SIGNAL_RESET | SIGNAL_BLANK, 0xff);
    /* All lines to "deactivate", -> 1 level on the wire */
    drv_generic_parport_control(SIGNAL_CS, 0);	/* CS to 0 all the time, write done by WR */
    drv_GU311_reset();

    /* Ready for commands from now on. */

    /* Display configuration */
    cmd[2] = '0';
    drv_GU311_send_string(cmd, sizeof(cmd));	/* Select char. page 0 */
    cmd[2] = 'Q';
    drv_GU311_send_string(cmd, sizeof(cmd));	/* Select 'Quick Mode' */
    cmd[2] = 'a';
    drv_GU311_send_string(cmd, sizeof(cmd));	/* Brightness at 100% */
    cmd[2] = 'T';
    drv_GU311_send_string(cmd, sizeof(cmd));	/* Ensure display ON */

    drv_Noritake_clear();
    return 0;
}



static int drv_Noritake_start(const char *section)
{
    char *model = 0;
    int i;
    model = cfg_get(section, "Model", NULL);
    if (model != NULL && *model != '\0') {
	for (i = 0; Models[i].type != 0xff; i++) {
	    if (strcasecmp(Models[i].name, model) == 0)
		break;
	}
	if (Models[i].type == 0xff) {
	    error("%s: %s.Model '%s' is unknown from %s", Name, section, model, cfg_source());
	    return -1;
	}
	Model = i;
	info("%s: using model '%s'", Name, Models[Model].name);
    } else {
	error("%s: no '%s.Model' entry from %s", Name, section, cfg_source());
	return -1;
    }

    DROWS = Models[Model].rows;
    DCOLS = Models[Model].cols;
    XRES = Models[Model].xres;
    YRES = Models[Model].xres;
    GOTO_COST = Models[Model].goto_cost;
    Protocol = Models[Model].protocol;
    /* display preferences */
    CHARS = 0;			/* number of user-defineable characters */
    CHAR0 = 0;			/* ASCII of first user-defineable char */



    /* real worker functions */
    drv_Noritake_clear = drv_GU311_clear;
    if (Models[Model].type == 0x01) {
	drv_generic_text_real_write = drv_GU311_write;
    } else {
	error("%s: Unsupported display. Currently supported are : GU311.", Name);
	return -1;
    }
    return drv_GU311_start(section);
}


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

/* none */


/****************************************/
/***        widget callbacks          ***/
/****************************************/


/* using drv_generic_text_draw(W) */


/****************************************/
/***        exported functions        ***/
/****************************************/


/* list models */
int drv_Noritake_list(void)
{
    printf("GU311 GU311_Graphic");
    return 0;
}


/* initialize driver & display */
int drv_Noritake_init(const char *section, const int quiet)
{
    WIDGET_CLASS wc;
    int ret;

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

    /* start display */
    if ((ret = drv_Noritake_start(section)) != 0)
	return ret;

    /* initialize generic text driver */
    if ((ret = drv_generic_text_init(section, Name)) != 0)
	return ret;

    /* register text widget */
    wc = Widget_Text;
    wc.draw = drv_generic_text_draw;
    widget_register(&wc);

    /* register plugins */
    /* none */

    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_Noritake_clear();
	}
    }

    return 0;
}


/* close driver & display */
int drv_Noritake_quit(const int quiet)
{

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

    /* clear display */
    drv_Noritake_clear();

    /* say goodbye... */
    if (!quiet) {
	drv_generic_text_greet("goodbye!", NULL);
    }

    drv_generic_parport_close();
    drv_generic_text_quit();
    return (0);
}


DRIVER drv_Noritake = {
    .name = Name,
    .list = drv_Noritake_list,
    .init = drv_Noritake_init,
    .quit = drv_Noritake_quit,
};
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-02 02:51:37 +0000