mangavalk/lcdproc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Major change was to convert from multiple drivers to a single driver.

Browse Source 
Other minor things: comments, more robust MtxOrb driver, and more use
of syslog.
This commit is contained in:
ddouthitt
2001-09-24 22:33:59 +00:00
parent f23292a554
commit 875ee72589
6 changed files with 361 additions and 622 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/drivers/MtxOrb.c
+109 -69
View File
@@ -52,6 +52,7 @@
static int custom = 0; static int custom = 0;
static enum {MTXORB_LCD, MTXORB_LKD, MTXORB_VFD, MTXORB_VKD} MtxOrb_type; static enum {MTXORB_LCD, MTXORB_LKD, MTXORB_VFD, MTXORB_VKD} MtxOrb_type;
extern int debug_level;
// TODO: Remove this custom_type if not in use anymore. // TODO: Remove this custom_type if not in use anymore.
typedef enum { typedef enum {
@@ -98,8 +99,9 @@ static int use[9] = { 1, 0, 0, 0, 0, 0, 0, 0, 0 };
static void MtxOrb_linewrap (int on); static void MtxOrb_linewrap (int on);
static void MtxOrb_autoscroll (int on); static void MtxOrb_autoscroll (int on);
static void MtxOrb_cursorblink (int on); static void MtxOrb_cursorblink (int on);
static void MtxOrb_string (int x, int y, char *string);
int static int
MtxOrb_set_type (char * str) { MtxOrb_set_type (char * str) {
char c; char c;
c = str[0]; c = str[0];
@@ -126,7 +128,7 @@ MtxOrb_set_type (char * str) {
return (-1); return (-1);
} }
int static int
MtxOrb_get_speed (char *arg) { MtxOrb_get_speed (char *arg) {
int speed; int speed;
@@ -150,7 +152,7 @@ MtxOrb_get_speed (char *arg) {
return speed; return speed;
} }
void static void
MtxOrb_usage (void) { MtxOrb_usage (void) {
printf ("LCDproc Matrix-Orbital LCD driver\n" printf ("LCDproc Matrix-Orbital LCD driver\n"
"\t-d\t--device\tSelect the output device to use [/dev/lcd]\n" "\t-d\t--device\tSelect the output device to use [/dev/lcd]\n"
@@ -162,7 +164,7 @@ MtxOrb_usage (void) {
"\t-t\t--type\t\tdisplay type: lcd, lkd, vfd, vkd\n"); "\t-t\t--type\t\tdisplay type: lcd, lkd, vfd, vkd\n");
} }
int static int
MtxOrb_set_contrast (char * str) { MtxOrb_set_contrast (char * str) {
int contrast; int contrast;
@@ -174,7 +176,7 @@ MtxOrb_set_contrast (char * str) {
return contrast; return contrast;
} }
// TODO: Get rid of this variable? // TODO: Get rid of this variable? Probably not...
lcd_logical_driver *MtxOrb; // set by MtxOrb_init(); doesn't seem to be used anywhere lcd_logical_driver *MtxOrb; // set by MtxOrb_init(); doesn't seem to be used anywhere
// TODO: Get the frame buffers working right // TODO: Get the frame buffers working right
@@ -323,7 +325,7 @@ MtxOrb_init (lcd_logical_driver * driver, char *args)
MtxOrb_contrast (contrast); MtxOrb_contrast (contrast);
if (!driver->framebuf) { if (!driver->framebuf) {
fprintf (stderr, "MtxOrb_init: No frame buffer.\n"); syslog(LOG_ERR, "no frame buffer! exiting driver init...");
driver->close (); driver->close ();
return -1; return -1;
} }
@@ -332,13 +334,13 @@ MtxOrb_init (lcd_logical_driver * driver, char *args)
* Configure the display functions * Configure the display functions
*/ */
driver->clear = MtxOrb_clear; // was GENERIC driver->clear = MtxOrb_clear;
driver->string = GENERIC; driver->string = MtxOrb_string;
driver->chr = MtxOrb_chr; // was GENERIC driver->chr = MtxOrb_chr;
driver->vbar = MtxOrb_vbar; driver->vbar = MtxOrb_vbar;
driver->init_vbar = MtxOrb_init_vbar; // was GENERIC driver->init_vbar = MtxOrb_init_vbar;
driver->hbar = MtxOrb_hbar; driver->hbar = MtxOrb_hbar;
driver->init_hbar = MtxOrb_init_hbar; // was GENERIC driver->init_hbar = MtxOrb_init_hbar;
driver->num = MtxOrb_num; driver->num = MtxOrb_num;
driver->init_num = MtxOrb_init_num; driver->init_num = MtxOrb_init_num;
@@ -369,18 +371,20 @@ MtxOrb_init (lcd_logical_driver * driver, char *args)
// This reliance on drv_base_clear seems suspicious... especially as // This reliance on drv_base_clear seems suspicious... especially as
// using a (void *) -1 in the driver structure does the same thing... // using a (void *) -1 in the driver structure does the same thing...
// //
void static void
MtxOrb_clear () MtxOrb_clear ()
{ {
drv_base_clear (); // do we need this? if (MtxOrb->framebuf != NULL)
write(fd, "\x0FEX", 2); // instant clear... memset (MtxOrb->framebuf, ' ', (MtxOrb->wid * MtxOrb->hgt));
write(fd, "\x0FE" "X", 2); // instant clear...
clear = 1; clear = 1;
} }
///////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////
// Clean-up // Clean-up
// //
void static void
MtxOrb_close () MtxOrb_close ()
{ {
close (fd); close (fd);
@@ -391,24 +395,48 @@ MtxOrb_close ()
MtxOrb->framebuf = NULL; MtxOrb->framebuf = NULL;
} }
void static void
MtxOrb_flush () MtxOrb_string (int x, int y, char *string)
{ {
MtxOrb_draw_frame (lcd.framebuf); int offset, siz;
x--; y--; // Convert 1-based coords to 0-based...
// Check range of Y
if (y > MtxOrb->hgt) {
syslog(LOG_WARNING, "lcd height overflow!");
return;
}
// Check range of X
if (x > MtxOrb->wid) {
syslog(LOG_WARNING, "lcd width overflow!");
return;
}
offset = (y * MtxOrb->wid) + x;
siz = (MtxOrb->wid * MtxOrb->hgt) - offset - 1;
siz = siz > strlen(string) ? strlen(string) : siz;
memcpy(MtxOrb->framebuf + offset, string, siz);
} }
void static void
MtxOrb_flush ()
{
MtxOrb_draw_frame (MtxOrb->framebuf);
}
static void
MtxOrb_flush_box (int lft, int top, int rgt, int bot) MtxOrb_flush_box (int lft, int top, int rgt, int bot)
{ {
int y; int y;
char out[LCD_MAX_WIDTH]; char out[LCD_MAX_WIDTH];
// printf("Flush (%i,%i)-(%i,%i)\n", lft, top, rgt, bot);
for (y = top; y <= bot; y++) { for (y = top; y <= bot; y++) {
sprintf (out, "\x0FEG%c%c", lft, y); sprintf (out, "\x0FEG%c%c", lft, y);
write (fd, out, 4); write (fd, out, 4);
write (fd, lcd.framebuf + (y * lcd.wid) + lft, rgt - lft + 1); write (fd, MtxOrb->framebuf + (y * MtxOrb->wid) + lft, rgt - lft + 1);
} }
@@ -418,29 +446,41 @@ MtxOrb_flush_box (int lft, int top, int rgt, int bot)
// Prints a character on the lcd display, at position (x,y). The // Prints a character on the lcd display, at position (x,y). The
// upper-left is (1,1), and the lower right should be (20,4). // upper-left is (1,1), and the lower right should be (20,4).
// //
void static void
MtxOrb_chr (int x, int y, char c) MtxOrb_chr (int x, int y, char c)
{ {
char out[10]; char out[10], buf[64];
int offset;
// Characters may or may NOT be alphabetic; it appears
// that characters 0..4 (or similar) are graphic fonts
// validate x and y // validate x and y
if (y > lcd.hgt) if (x > MtxOrb->wid)
y = lcd.hgt; x = MtxOrb->wid;
if (x > lcd.wid)
x = lcd.wid;
if (y < 1)
y = 1;
if (x < 1) if (x < 1)
x = 1; x = 1;
if (y > MtxOrb->hgt)
y = MtxOrb->hgt;
if (y < 1)
y = 1;
// write immediately to screen... this code was taken // write immediately to screen... this code was taken
// from the LK202-25; should work for others, yes? // from the LK202-25; should work for others, yes?
sprintf(out, "\x0FEG%c%c%c", x, y, c); // sprintf(out, "\x0FEG%c%c%c", x, y, c);
write (fd, out, 4); // write (fd, out, 4);
// write to frame buffer // write to frame buffer
y--; x--; y--; x--; // translate to 0-index
lcd.framebuf[(y * lcd.wid) + x] = c; offset = (y * MtxOrb->wid) + x;
MtxOrb->framebuf[offset] = c;
if (debug_level > 2) {
snprintf(buf, sizeof(buf), "writing character %02X to position (%d,%d)",
c, x, y);
syslog(LOG_DEBUG, buf);
}
} }
///////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////
@@ -448,7 +488,7 @@ MtxOrb_chr (int x, int y, char c)
// note: works only for LCD displays // note: works only for LCD displays
// Is it better to use the brightness for VFD/VKD displays ? // Is it better to use the brightness for VFD/VKD displays ?
// //
int static int
MtxOrb_contrast (int contrast) MtxOrb_contrast (int contrast)
{ {
char out[4]; char out[4];
@@ -479,7 +519,7 @@ MtxOrb_contrast (int contrast)
#define BACKLIGHT_OFF 0 #define BACKLIGHT_OFF 0
#define BACKLIGHT_ON 1 #define BACKLIGHT_ON 1
void static void
MtxOrb_backlight (int on) MtxOrb_backlight (int on)
{ {
switch (on) { switch (on) {
@@ -502,7 +542,7 @@ MtxOrb_backlight (int on)
// displays with keypad have 6 outputs but the one without kepad // displays with keypad have 6 outputs but the one without kepad
// have only one output // have only one output
// NOTE: length of command are different // NOTE: length of command are different
void static void
MtxOrb_output (int on) MtxOrb_output (int on)
{ {
char out[5]; char out[5];
@@ -561,7 +601,7 @@ MtxOrb_cursorblink (int on)
///////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////
// Sets up for vertical bars. Call before lcd.vbar() // Sets up for vertical bars. Call before lcd.vbar()
// //
void static void
MtxOrb_init_vbar () MtxOrb_init_vbar ()
{ {
// Isn't this function supposed to go away? // Isn't this function supposed to go away?
@@ -572,7 +612,7 @@ MtxOrb_init_vbar ()
///////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////
// Inits horizontal bars... // Inits horizontal bars...
// //
void static void
MtxOrb_init_hbar () MtxOrb_init_hbar ()
{ {
// Isn't this function supposed to go away? // Isn't this function supposed to go away?
@@ -582,7 +622,7 @@ MtxOrb_init_hbar ()
///////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////
// Returns string with general information about the display // Returns string with general information about the display
// //
char * static char *
MtxOrb_getinfo (void) MtxOrb_getinfo (void)
{ {
char in = 0; char in = 0;
@@ -707,7 +747,7 @@ MtxOrb_getinfo (void)
// Draws a vertical bar... // Draws a vertical bar...
// This is the new version ussing dynamic icon alocation // This is the new version ussing dynamic icon alocation
// //
void static void
MtxOrb_vbar (int x, int len) MtxOrb_vbar (int x, int len)
{ {
unsigned char mapu[9] = { barw, baru1, baru2, baru3, baru4, baru5, baru6, baru7, barb }; unsigned char mapu[9] = { barw, baru1, baru2, baru3, baru4, baru5, baru6, baru7, barb };
@@ -720,23 +760,23 @@ MtxOrb_vbar (int x, int len)
// REMOVE THE PREVIOUS LINE FOR TESTING ONLY... // REMOVE THE PREVIOUS LINE FOR TESTING ONLY...
if (len > 0) { if (len > 0) {
for (y = lcd.hgt; y > 0 && len > 0; y--) { for (y = MtxOrb->hgt; y > 0 && len > 0; y--) {
if (len >= lcd.cellhgt) if (len >= MtxOrb->cellhgt)
MtxOrb_chr (x, y, 255); MtxOrb_chr (x, y, 255);
else else
MtxOrb_chr (x, y, MtxOrb_ask_bar (mapu[len])); MtxOrb_chr (x, y, MtxOrb_ask_bar (mapu[len]));
len -= lcd.cellhgt; len -= MtxOrb->cellhgt;
} }
} else { } else {
len = -len; len = -len;
for (y = 2; y <= lcd.hgt && len > 0; y++) { for (y = 2; y <= MtxOrb->hgt && len > 0; y++) {
if (len >= lcd.cellhgt) if (len >= MtxOrb->cellhgt)
MtxOrb_chr (x, y, 255); MtxOrb_chr (x, y, 255);
else else
MtxOrb_chr (x, y, MtxOrb_ask_bar (mapd[len])); MtxOrb_chr (x, y, MtxOrb_ask_bar (mapd[len]));
len -= lcd.cellhgt; len -= MtxOrb->cellhgt;
} }
} }
@@ -747,31 +787,31 @@ MtxOrb_vbar (int x, int len)
// Draws a horizontal bar to the right. // Draws a horizontal bar to the right.
// This is the new version ussing dynamic icon alocation // This is the new version ussing dynamic icon alocation
// //
void static void
MtxOrb_hbar (int x, int y, int len) MtxOrb_hbar (int x, int y, int len)
{ {
unsigned char mapr[6] = { barw, barr1, barr2, barr3, barr4, barb }; unsigned char mapr[6] = { barw, barr1, barr2, barr3, barr4, barb };
unsigned char mapl[6] = { barw, barl1, barl2, barl3, barl4, barb }; unsigned char mapl[6] = { barw, barl1, barl2, barl3, barl4, barb };
if (len > 0) { if (len > 0) {
for (; x <= lcd.wid && len > 0; x++) { for (; x <= MtxOrb->wid && len > 0; x++) {
if (len >= lcd.cellwid) if (len >= MtxOrb->cellwid)
MtxOrb_chr (x, y, 255); MtxOrb_chr (x, y, 255);
else else
MtxOrb_chr (x, y, MtxOrb_ask_bar (mapr[len])); MtxOrb_chr (x, y, MtxOrb_ask_bar (mapr[len]));
len -= lcd.cellwid; len -= MtxOrb->cellwid;
} }
} else { } else {
len = -len; len = -len;
for (; x > 0 && len > 0; x--) { for (; x > 0 && len > 0; x--) {
if (len >= lcd.cellwid) if (len >= MtxOrb->cellwid)
MtxOrb_chr (x, y, 255); MtxOrb_chr (x, y, 255);
else else
MtxOrb_chr (x, y, MtxOrb_ask_bar (mapl[len])); MtxOrb_chr (x, y, MtxOrb_ask_bar (mapl[len]));
len -= lcd.cellwid; len -= MtxOrb->cellwid;
} }
} }
@@ -783,7 +823,7 @@ MtxOrb_hbar (int x, int y, int len)
///////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////
// Sets up for big numbers. // Sets up for big numbers.
// //
void static void
MtxOrb_init_num () MtxOrb_init_num ()
{ {
if (custom != bign) { if (custom != bign) {
@@ -797,7 +837,7 @@ MtxOrb_init_num ()
///////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////
// Writes a big number. // Writes a big number.
// //
void static void
MtxOrb_num (int x, int num) MtxOrb_num (int x, int num)
{ {
char out[5]; char out[5];
@@ -814,7 +854,7 @@ MtxOrb_num (int x, int num)
// //
// The input is just an array of characters... // The input is just an array of characters...
// //
void static void
MtxOrb_set_char (int n, char *dat) MtxOrb_set_char (int n, char *dat)
{ {
char out[4]; char out[4];
@@ -829,17 +869,17 @@ MtxOrb_set_char (int n, char *dat)
sprintf (out, "\x0FEN%c", n); sprintf (out, "\x0FEN%c", n);
write (fd, out, 3); write (fd, out, 3);
for (row = 0; row < lcd.cellhgt; row++) { for (row = 0; row < MtxOrb->cellhgt; row++) {
letter = 0; letter = 0;
for (col = 0; col < lcd.cellwid; col++) { for (col = 0; col < MtxOrb->cellwid; col++) {
letter <<= 1; letter <<= 1;
letter |= (dat[(row * lcd.cellwid) + col] > 0); letter |= (dat[(row * MtxOrb->cellwid) + col] > 0);
} }
write (fd, &letter, 1); write (fd, &letter, 1);
} }
} }
void static void
MtxOrb_icon (int which, char dest) MtxOrb_icon (int which, char dest)
{ {
char icons[3][5 * 8] = { char icons[3][5 * 8] = {
@@ -888,7 +928,7 @@ MtxOrb_icon (int which, char dest)
// //
// Input is a character array, sized lcd.wid*lcd.hgt // Input is a character array, sized lcd.wid*lcd.hgt
// //
void static void
MtxOrb_draw_frame (char *dat) MtxOrb_draw_frame (char *dat)
{ {
char out[LCD_MAX_WIDTH * LCD_MAX_HEIGHT]; char out[LCD_MAX_WIDTH * LCD_MAX_HEIGHT];
@@ -901,10 +941,10 @@ MtxOrb_draw_frame (char *dat)
write(fd, out, 4); write(fd, out, 4);
write(fd, dat, lcd.wid*lcd.hgt); write(fd, dat, lcd.wid*lcd.hgt);
*/ */
for (i = 0; i < lcd.hgt; i++) { for (i = 0; i < MtxOrb->hgt; i++) {
sprintf (out, "\x0FEG\x001%c", i + 1); sprintf (out, "\x0FEG\x001%c", i + 1);
write (fd, out, 4); write (fd, out, 4);
write (fd, dat + (lcd.wid * i), lcd.wid); write (fd, dat + (MtxOrb->wid * i), MtxOrb->wid);
} }
} }
@@ -912,7 +952,7 @@ MtxOrb_draw_frame (char *dat)
// returns one character from the keypad... // returns one character from the keypad...
// (A-Z) on success, 0 on failure... // (A-Z) on success, 0 on failure...
// //
char static char
MtxOrb_getkey () MtxOrb_getkey ()
{ {
char in = 0; char in = 0;
@@ -930,7 +970,7 @@ MtxOrb_getkey ()
// I really hope it is working and bug-less because it is not // I really hope it is working and bug-less because it is not
// completely tested, just a quick hack. // completely tested, just a quick hack.
// //
int static int
MtxOrb_ask_bar (int type) MtxOrb_ask_bar (int type)
{ {
int i; int i;
@@ -1072,18 +1112,18 @@ MtxOrb_ask_bar (int type)
///////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////
// Does the heartbeat... // Does the heartbeat...
// //
char static char
MtxOrb_heartbeat (int timer) MtxOrb_heartbeat (int timer)
{ {
MtxOrb_icon (!((timer + 4) & 5), 0); MtxOrb_icon (!((timer + 4) & 5), 0);
MtxOrb_chr (lcd.wid, 1, 0); MtxOrb_chr (MtxOrb->wid, 1, 0);
return (char) 0; return (char) 0;
} }
///////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////
// Sets up a well known character for use. // Sets up a well known character for use.
// //
void static void
MtxOrb_set_known_char (int car, int type) MtxOrb_set_known_char (int car, int type)
{ {
char all_bar[25][5 * 8] = { char all_bar[25][5 * 8] = {
@@ -1324,7 +1364,7 @@ MtxOrb_set_known_char (int car, int type)
// PS: There might be reference to this code left, so keep it for some time. // PS: There might be reference to this code left, so keep it for some time.
// //
// MtxOrb_init_hbar and MtxOrb_init_vbar use it; it's prototyped in MtxOrb.h ... // MtxOrb_init_hbar and MtxOrb_init_vbar use it; it's prototyped in MtxOrb.h ...
void static void
MtxOrb_init_all (int type) MtxOrb_init_all (int type)
{ {
} }
server/drivers/MtxOrb.h
+22 -22
View File
@@ -4,29 +4,29 @@
extern lcd_logical_driver *MtxOrb; extern lcd_logical_driver *MtxOrb;
int MtxOrb_init (lcd_logical_driver * driver, char *device); int MtxOrb_init (lcd_logical_driver * driver, char *device);
void MtxOrb_clear (); static void MtxOrb_clear ();
void MtxOrb_close (); static void MtxOrb_close ();
void MtxOrb_flush (); static void MtxOrb_flush ();
void MtxOrb_flush_box (int lft, int top, int rgt, int bot); static void MtxOrb_flush_box (int lft, int top, int rgt, int bot);
void MtxOrb_chr (int x, int y, char c); static void MtxOrb_chr (int x, int y, char c);
int MtxOrb_contrast (int contrast); static int MtxOrb_contrast (int contrast);
void MtxOrb_backlight (int on); static void MtxOrb_backlight (int on);
void MtxOrb_output (int on); static void MtxOrb_output (int on);
void MtxOrb_init_vbar (); static void MtxOrb_init_vbar ();
void MtxOrb_init_hbar (); static void MtxOrb_init_hbar ();
void MtxOrb_vbar (int x, int len); static void MtxOrb_vbar (int x, int len);
void MtxOrb_hbar (int x, int y, int len); static void MtxOrb_hbar (int x, int y, int len);
void MtxOrb_init_num (); static void MtxOrb_init_num ();
void MtxOrb_num (int x, int num); static void MtxOrb_num (int x, int num);
void MtxOrb_set_char (int n, char *dat); static void MtxOrb_set_char (int n, char *dat);
void MtxOrb_icon (int which, char dest); static void MtxOrb_icon (int which, char dest);
void MtxOrb_draw_frame (char *dat); static void MtxOrb_draw_frame (char *dat);
char MtxOrb_getkey (); static char MtxOrb_getkey ();
char * MtxOrb_getinfo (); static char * MtxOrb_getinfo ();
int MtxOrb_ask_bar (int type); static int MtxOrb_ask_bar (int type);
void MtxOrb_set_known_char (int car, int type); static void MtxOrb_set_known_char (int car, int type);
// Isn't this function supposed to go away? // Isn't this function supposed to go away?
void MtxOrb_init_all (int type); static void MtxOrb_init_all (int type);
#endif #endif
server/drivers/lcd.c
+219 -506
View File
@@ -13,6 +13,7 @@
#include <fcntl.h> #include <fcntl.h>
#include <string.h> #include <string.h>
#include <sys/errno.h> #include <sys/errno.h>
#include <syslog.h>
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
#include "config.h" #include "config.h"
@@ -23,7 +24,27 @@
#include "lcd.h" #include "lcd.h"
#include "drv_base.h" static int lcd_drv_init (lcd_logical_driver * driver, char *args);
static void lcd_drv_close ();
static void lcd_drv_clear ();
static void lcd_drv_flush ();
static void lcd_drv_string (int x, int y, char *string);
static void lcd_drv_chr (int x, int y, char c);
static int lcd_drv_contrast (int contrast);
static void lcd_drv_backlight (int on);
static void lcd_drv_output (int on);
static void lcd_drv_init_vbar ();
static void lcd_drv_init_hbar ();
static void lcd_drv_init_num ();
static void lcd_drv_num (int x, int num);
static void lcd_drv_set_char (int n, char *dat);
static void lcd_drv_vbar (int x, int len);
static void lcd_drv_hbar (int x, int y, int len);
static void lcd_drv_icon (int which, char dest);
static void lcd_drv_flush_box (int lft, int top, int rgt, int bot);
static void lcd_drv_draw_frame ();
static char lcd_drv_getkey ();
static char *lcd_drv_getinfo ();
#ifdef MTXORB_DRV #ifdef MTXORB_DRV
#include "MtxOrb.h" #include "MtxOrb.h"
@@ -105,7 +126,7 @@ lcd_logical_driver lcd;
// names, as well as older ones... // names, as well as older ones...
// //
lcd_physical_driver drivers[] = { lcd_physical_driver drivers[] = {
{"base", drv_base_init,},
#ifdef MTXORB_DRV #ifdef MTXORB_DRV
{"MtxOrb", MtxOrb_init,}, {"MtxOrb", MtxOrb_init,},
#endif #endif
@@ -162,46 +183,73 @@ LL *list;
// "base" array. To initialize a specific driver, use the // "base" array. To initialize a specific driver, use the
// lcd_add_driver() function. // lcd_add_driver() function.
// //
// This was eliminated; everything
// done here is to be replaced by the use of lcd_add_driver()...
int int
lcd_init (char *args) lcd_init (char *args)
{ {
// int i; return 0;
int err; }
list = LL_new (); // This sets up all of the "wrapper" driver functions
if (!list) { // which call all of the drivers in turn.
printf ("Error allocating driver list.\n"); //
return -1; static int
lcd_drv_init (struct lcd_logical_driver *driver, char *args)
{
driver->wid = LCD_STD_WIDTH;
driver->hgt = LCD_STD_HEIGHT;
driver->cellwid = LCD_STD_CELL_WIDTH;
driver->cellhgt = LCD_STD_CELL_HEIGHT;
driver->framebuf = NULL;
// Set up these wrapper functions...
driver->clear = lcd_drv_clear;
driver->string = lcd_drv_string;
driver->chr = lcd_drv_chr;
driver->vbar = lcd_drv_vbar;
driver->hbar = lcd_drv_hbar;
driver->init_num = lcd_drv_init_num;
driver->num = lcd_drv_num;
driver->init = lcd_drv_init;
driver->close = lcd_drv_close;
driver->flush = lcd_drv_flush;
driver->flush_box = lcd_drv_flush_box;
driver->contrast = lcd_drv_contrast;
driver->backlight = lcd_drv_backlight;
driver->output = lcd_drv_output;
driver->set_char = lcd_drv_set_char;
driver->icon = lcd_drv_icon;
driver->init_vbar = lcd_drv_init_vbar;
driver->init_hbar = lcd_drv_init_hbar;
driver->draw_frame = lcd_drv_draw_frame;
driver->getkey = lcd_drv_getkey;
driver->getinfo = lcd_drv_getinfo;
return 1; // 1 is arbitrary. (must be 1 or more)
}
/*
* This function can be replaced later with something
* that utilizes the results of dynamic library loading
*
*/
static
void *
lcd_find_init (char *driver) {
int i;
for (i = 0; drivers[i].name; i++) {
if (strcmp(driver, drivers[i].name) == 0) {
return (*drivers[i].init);
}
} }
return NULL;
// This sets up functions which call all drivers in
// round-robin fashion
lcd_drv_init (NULL, NULL);
// "base" driver is a special driver which is always
// loaded...
err = lcd_add_driver ("base", args);
lcd.wid = 20;
lcd.hgt = 4;
return err;
/*
drv_base_init(args);
for(i=0; drivers[i].name; i++)
{
if(!strcmp(driver, drivers[i].name))
{
return drivers[i].init(args);
}
}
printf("Invalid driver: %s\n", driver);
return -1;
*/
} }
// TODO: lcd_remove_driver() // TODO: lcd_remove_driver()
@@ -209,56 +257,47 @@ lcd_init (char *args)
// This initializes the specified driver and sends parameters to // This initializes the specified driver and sends parameters to
// it. This is the function which calls, for example, // it. This is the function which calls, for example,
// MtxOrb_init. The specifics come from the drivers[] array. // MtxOrb_init. The specifics come from the drivers[] array.
//
int int
lcd_add_driver (char *driver, char *args) lcd_add_driver (char *driver, char *args)
{ {
int i; int i;
char buf[64];
int (*init_driver) ();
lcd_logical_driver *add; lcd_logical_driver *add;
for (i = 0; drivers[i].name; i++) { if ((init_driver = (void *) lcd_find_init(driver)) != NULL) {
//printf("Checking driver: %s\n", drivers[i].name); // This creates an instance of the lcd structure specific to the
// driver... it is passed to the driver's init routine...
if (0 == strcmp (driver, drivers[i].name)) { //if ((add = malloc (sizeof (*add))) == NULL) {
// snprintf (buf, sizeof(buf), "couldn't allocate space for driver \"%s\"", driver);
// syslog (LOG_ERR, buf);
// return -1;
//}
//printf("Found driver: %s (%s)\n", drivers[i].name, driver); add = &lcd;
memset (add, 0, sizeof (add));
// This creates an instance of the lcd structure specific to the // Default settings for the driver...
// driver... it is passed to the driver's init routine... lcd_drv_init(add, NULL);
add = malloc (sizeof (lcd_logical_driver));
if (!add) {
printf ("Couldn't allocate driver \"%s\".\n", driver);
return -1;
}
//printf("Allocated driver\n");
memset (add, 0, sizeof (lcd_logical_driver));
add->wid = lcd.wid; // Allocate space for a framebuffer...
add->hgt = lcd.hgt; if ((add->framebuf = malloc (add->wid * add->hgt)) == NULL) {
add->cellwid = lcd.cellwid; snprintf (buf, sizeof(buf), "couldn't allocate framebuffer for driver \"%s\"", driver);
add->cellhgt = lcd.cellhgt; syslog (LOG_ERR, buf);
// free (add);
// printf("LCD driver info:\n\twid: %i\thgt: %i\n", return -1;
// add->wid, add->hgt);
add->framebuf = malloc (add->wid * add->hgt);
if (!add->framebuf) {
printf ("Couldn't allocate framebuffer for driver \"%s\".\n", driver);
free (add);
return -1;
}
//printf("Allocated frame buffer\n");
LL_Push (list, (void *) add);
// This is where the driver itself is actually called;
return drivers[i].init (add, args);
} }
} memset (add->framebuf, ' ', (add->wid * add->hgt));
return init_driver (add, args);
} else {
snprintf(buf, sizeof(buf), "invalid driver: %s", driver);
syslog(LOG_ERR, buf);
}
return -1; return -1;
} }
@@ -268,87 +307,11 @@ lcd_shutdown ()
{ {
lcd_logical_driver *driver; lcd_logical_driver *driver;
LL_Rewind (list); lcd.close ();
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
//printf("driver...\n");
lcd.framebuf = driver->framebuf;
if ((int) driver->close > 0) {
driver->close ();
} else if ((int) driver->close == -1) {
drv_base->close ();
}
LL_Shift (list);
// FIXME: This crashes!
//if(driver) free(driver);
//printf("...freed\n");
}
} while (LL_Length (list) > 0);
return 0; return 0;
} }
// This sets up all of the "wrapper" driver functions
// which call all of the drivers in turn.
//
int
lcd_drv_init (struct lcd_logical_driver *driver, char *args)
{
// printf("lcd_drv_init()\n");
lcd.wid = LCD_MAX_WID;
lcd.hgt = LCD_MAX_HGT;
lcd.framebuf = NULL;
/*
if(!lcd.framebuf)
lcd.framebuf = malloc(lcd.wid * lcd.hgt);
if(!lcd.framebuf)
{
lcd_drv_close();
return -1;
}
memset(lcd.framebuf, ' ', lcd.wid*lcd.hgt);
*/
// Debugging...
// if(lcd.framebuf) printf("Frame buffer: %i\n", (int)lcd.framebuf);
lcd.cellwid = 5;
lcd.cellhgt = 8;
// Set up these wrapper functions...
lcd.clear = lcd_drv_clear;
lcd.string = lcd_drv_string;
lcd.chr = lcd_drv_chr;
lcd.vbar = lcd_drv_vbar;
lcd.hbar = lcd_drv_hbar;
lcd.init_num = lcd_drv_init_num;
lcd.num = lcd_drv_num;
lcd.init = lcd_drv_init;
lcd.close = lcd_drv_close;
lcd.flush = lcd_drv_flush;
lcd.flush_box = lcd_drv_flush_box;
lcd.contrast = lcd_drv_contrast;
lcd.backlight = lcd_drv_backlight;
lcd.output = lcd_drv_output;
lcd.set_char = lcd_drv_set_char;
lcd.icon = lcd_drv_icon;
lcd.init_vbar = lcd_drv_init_vbar;
lcd.init_hbar = lcd_drv_init_hbar;
lcd.draw_frame = lcd_drv_draw_frame;
lcd.getkey = lcd_drv_getkey;
lcd.getinfo = lcd_drv_getinfo;
return 1; // 1 is arbitrary. (must be 1 or more)
}
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// All functions below here call their respective driver functions... // All functions below here call their respective driver functions...
// //
@@ -364,438 +327,188 @@ lcd_drv_init (struct lcd_logical_driver *driver, char *args)
// driver->func() == -1 means it should call the generic driver. // driver->func() == -1 means it should call the generic driver.
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
void /*
* The functions below are wrapper functions for the actual driver
* functions.
*
*/
/*
* TODO: Convert these functions to either null functions (output)
* or to use a new interface for a linked list (input).
*
*/
// lcd_drv_close ()
// lcd_drv_clear ()
// lcd_drv_flush ()
// lcd_drv_string (int x, int y, char string[])
// lcd_drv_chr (int x, int y, char c)
// lcd_drv_contrast (int contrast)
// lcd_drv_backlight (int on)
// lcd_drv_output (int on)
// lcd_drv_init_vbar ()
// lcd_drv_init_hbar ()
// lcd_drv_init_num ()
// lcd_drv_num (int x, int num)
// lcd_drv_set_char (int n, char *dat)
// lcd_drv_vbar (int x, int len)
// lcd_drv_hbar (int x, int y, int len)
// lcd_drv_icon (int which, char dest)
// lcd_drv_flush_box (int lft, int top, int rgt, int bot)
// lcd_drv_draw_frame (char *dat)
// lcd_drv_getkey ()
// lcd_drv_getinfo ()
static void
lcd_drv_close () lcd_drv_close ()
{ {
lcd_logical_driver *driver; ;
// printf("lcd_drv_close()\n");
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->close > 0) {
printf ("Calling close()\n");
driver->close ();
} else if ((int) driver->close == -1) {
drv_base->close ();
}
}
} while (LL_Next (list) == 0);
} }
void static void
lcd_drv_clear () lcd_drv_clear ()
{ {
lcd_logical_driver *driver; ;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->clear > 0)
driver->clear ();
else if ((int) driver->clear == -1) {
drv_base->clear ();
}
}
} while (LL_Next (list) == 0);
} }
void static void
lcd_drv_flush () lcd_drv_flush ()
{ {
lcd_logical_driver *driver; ;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->flush > 0)
driver->flush ();
else if ((int) driver->flush == -1) {
drv_base->flush ();
}
}
} while (LL_Next (list) == 0);
} }
void static void
lcd_drv_string (int x, int y, char string[]) lcd_drv_string (int x, int y, char *string)
{ {
lcd_logical_driver *driver; ;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->string > 0)
driver->string (x, y, string);
else if ((int) driver->string == -1) {
drv_base->string (x, y, string);
}
}
} while (LL_Next (list) == 0);
} }
void static void
lcd_drv_chr (int x, int y, char c) lcd_drv_chr (int x, int y, char c)
{ {
lcd_logical_driver *driver; ;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->chr > 0)
driver->chr (x, y, c);
else if ((int) driver->chr == -1) {
drv_base->chr (x, y, c);
}
}
} while (LL_Next (list) == 0);
} }
int static int
lcd_drv_contrast (int contrast) lcd_drv_contrast (int contrast)
{ {
int res = 0; return -1;
lcd_logical_driver *driver;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->contrast > 0) {
res = driver->contrast (contrast);
if (res >= 0)
return res;
}
/*
else if((int)driver->contrast == -1)
{
res=drv_base->contrast(contrast);
}
*/
}
} while (LL_Next (list) == 0);
return res;
} }
void static void
lcd_drv_backlight (int on) lcd_drv_backlight (int on)
{ {
lcd_logical_driver *driver; ;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->backlight > 0)
driver->backlight (on);
else if ((int) driver->backlight == -1) {
drv_base->backlight (on);
}
}
} while (LL_Next (list) == 0);
} }
void static void
lcd_drv_output (int on) lcd_drv_output (int on)
{ {
lcd_logical_driver *driver; ;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->output > 0)
driver->output (on);
else if ((int) driver->output == -1) {
drv_base->output (on);
}
}
} while (LL_Next (list) == 0);
} }
void static void
lcd_drv_init_vbar () lcd_drv_init_vbar ()
{ {
lcd_logical_driver *driver; ;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->init_vbar > 0)
driver->init_vbar ();
else if ((int) driver->init_vbar == -1) {
drv_base->init_vbar ();
}
}
} while (LL_Next (list) == 0);
} }
void static void
lcd_drv_init_hbar () lcd_drv_init_hbar ()
{ {
lcd_logical_driver *driver; ;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->init_hbar > 0)
driver->init_hbar ();
else if ((int) driver->init_hbar == -1) {
drv_base->init_hbar ();
}
}
} while (LL_Next (list) == 0);
} }
void static void
lcd_drv_init_num () lcd_drv_init_num ()
{ {
lcd_logical_driver *driver; ;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->init_num > 0)
driver->init_num ();
else if ((int) driver->init_num == -1) {
drv_base->init_num ();
}
}
} while (LL_Next (list) == 0);
} }
void static void
lcd_drv_num (int x, int num) lcd_drv_num (int x, int num)
{ {
lcd_logical_driver *driver; ;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->num > 0)
driver->num (x, num);
else if ((int) driver->num == -1) {
drv_base->num (x, num);
}
}
} while (LL_Next (list) == 0);
} }
void static void
lcd_drv_set_char (int n, char *dat) lcd_drv_set_char (int n, char *dat)
{ {
lcd_logical_driver *driver; ;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->set_char > 0)
driver->set_char (n, dat);
else if ((int) driver->set_char == -1) {
drv_base->set_char (n, dat);
}
}
} while (LL_Next (list) == 0);
} }
void static void
lcd_drv_vbar (int x, int len) lcd_drv_vbar (int x, int len)
{ {
lcd_logical_driver *driver; ;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->vbar > 0)
driver->vbar (x, len);
else if ((int) driver->vbar == -1) {
drv_base->vbar (x, len);
}
}
} while (LL_Next (list) == 0);
} }
void static void
lcd_drv_hbar (int x, int y, int len) lcd_drv_hbar (int x, int y, int len)
{ {
lcd_logical_driver *driver; ;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->hbar > 0)
driver->hbar (x, y, len);
else if ((int) driver->hbar == -1) {
drv_base->hbar (x, y, len);
}
}
} while (LL_Next (list) == 0);
} }
void static void
lcd_drv_icon (int which, char dest) lcd_drv_icon (int which, char dest)
{ {
lcd_logical_driver *driver; ;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->icon > 0)
driver->icon (which, dest);
else if ((int) driver->icon == -1) {
drv_base->icon (which, dest);
}
}
} while (LL_Next (list) == 0);
} }
void static void
lcd_drv_flush_box (int lft, int top, int rgt, int bot) lcd_drv_flush_box (int lft, int top, int rgt, int bot)
{ {
lcd_logical_driver *driver; ;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->flush_box > 0)
driver->flush_box (lft, top, rgt, bot);
else if ((int) driver->flush_box == -1) {
drv_base->flush_box (lft, top, rgt, bot);
}
}
} while (LL_Next (list) == 0);
} }
// TODO: Check whether lcd.draw_frame() should really take a framebuffer // TODO: Check whether lcd.draw_frame() should really take a framebuffer
// TODO: as an argument, or if it should always use lcd.framebuf // TODO: as an argument, or if it should always use lcd.framebuf
void static void
lcd_drv_draw_frame (char *dat) lcd_drv_draw_frame (char *dat)
{ {
lcd_logical_driver *driver; ;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->draw_frame > 0)
driver->draw_frame (dat);
else if ((int) driver->draw_frame == -1) {
drv_base->draw_frame (dat);
}
}
} while (LL_Next (list) == 0);
} }
char static char *
lcd_drv_getinfo ()
{
return NULL;
}
// Input functions: may come from multiple sources...
static char
lcd_drv_getkey () lcd_drv_getkey ()
{ {
lcd_logical_driver *driver;
char key;
LL_Rewind (list);
do {
driver = (lcd_logical_driver *) LL_Get (list);
if (driver) {
lcd.framebuf = driver->framebuf;
if ((int) driver->getkey > 0) {
key = driver->getkey ();
if (key)
return key;
} else if ((int) driver->getkey == -1) {
key = drv_base->getkey ();
if (key)
return key;
}
}
} while (LL_Next (list) == 0);
return 0; return 0;
} }
#define MAX_INFO_BUF 1024 // char
// lcd_drv_getkey ()
// {
// lcd_logical_driver *driver;
//
// char key;
//
// LL_Rewind (list);
// do {
// driver = (lcd_logical_driver *) LL_Get (list);
// if (driver) {
// lcd.framebuf = driver->framebuf;
//
// if ((int) driver->getkey > 0) {
// key = driver->getkey ();
// if (key)
// return key;
// } else if ((int) driver->getkey == -1) {
// key = drv_base->getkey ();
// if (key)
// return key;
// }
// }
// } while (LL_Next (list) == 0);
//
// return 0;
// }
char *
lcd_drv_getinfo ()
{
static char info[MAX_INFO_BUF];
char *p;
lcd_logical_driver *driver;
memset(info, '\0', sizeof(info));
ResetList(list);
do {
driver = GetDriverData(list);
if (DriverPresent(driver)) {
if (FunctionPresent(driver->getinfo)) {
p = (char *) driver->getinfo ();
if (strlen(p) + strlen(info) < (MAX_INFO_BUF - 2)) {
strcat(info, p);
}
strcat(info, "\n");
}
}
} while (MoreDrivers(list));
return info;
}
server/drivers/lcd.h
+6 -24
View File
@@ -2,11 +2,15 @@
#define LCD_H #define LCD_H
// Maximum supported sizes // Maximum supported sizes
#define LCD_MAX_WID 256
#define LCD_MAX_WIDTH 256 #define LCD_MAX_WIDTH 256
#define LCD_MAX_HGT 256
#define LCD_MAX_HEIGHT 256 #define LCD_MAX_HEIGHT 256
// Standard supported sizes
#define LCD_STD_WIDTH 20
#define LCD_STD_HEIGHT 4
#define LCD_STD_CELL_WIDTH 5
#define LCD_STD_CELL_HEIGHT 8
int lcd_init (char *args); int lcd_init (char *args);
int lcd_add_driver (char *driver, char *args); int lcd_add_driver (char *driver, char *args);
int lcd_shutdown (); int lcd_shutdown ();
@@ -66,26 +70,4 @@ typedef struct lcd_physical_driver {
extern lcd_logical_driver lcd; extern lcd_logical_driver lcd;
int lcd_drv_init (lcd_logical_driver * driver, char *args);
void lcd_drv_close ();
void lcd_drv_clear ();
void lcd_drv_flush ();
void lcd_drv_string (int x, int y, char string[]);
void lcd_drv_chr (int x, int y, char c);
int lcd_drv_contrast (int contrast);
void lcd_drv_backlight (int on);
void lcd_drv_output (int on);
void lcd_drv_init_vbar ();
void lcd_drv_init_hbar ();
void lcd_drv_init_num ();
void lcd_drv_num (int x, int num);
void lcd_drv_set_char (int n, char *dat);
void lcd_drv_vbar (int x, int len);
void lcd_drv_hbar (int x, int y, int len);
void lcd_drv_icon (int which, char dest);
void lcd_drv_flush_box (int lft, int top, int rgt, int bot);
void lcd_drv_draw_frame ();
char lcd_drv_getkey ();
char *lcd_drv_getinfo ();
#endif #endif
server/main.c
+1
View File
@@ -39,6 +39,7 @@
#define MAX_TIMER 0x10000 #define MAX_TIMER 0x10000
#define DEFAULT_USER "nobody" #define DEFAULT_USER "nobody"
int debug_level = 3;
char *version = VERSION; char *version = VERSION;
char *protocol_version = PROTOCOL_VERSION; char *protocol_version = PROTOCOL_VERSION;
char *build_date = __DATE__; char *build_date = __DATE__;
server/screenlist.c
+4 -1
View File
@@ -1,5 +1,6 @@
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <syslog.h>
#include "shared/LL.h" #include "shared/LL.h"
#include "shared/sockets.h" #include "shared/sockets.h"
@@ -29,7 +30,7 @@ screenlist_init ()
screenlist = LL_new (); screenlist = LL_new ();
if (!screenlist) { if (!screenlist) {
fprintf (stderr, "screenlist_init: Error allocating list\n"); syslog(LOG_ERR, "screenlist_init: error allocating list");
return -1; return -1;
} }
@@ -116,6 +117,7 @@ screenlist_current ()
sock_send_string (c->sock, str); sock_send_string (c->sock, str);
} else // The server has the display, so do nothing } else // The server has the display, so do nothing
{ {
;
} }
//debug("screenlist_current: ... sent ignore\n"); //debug("screenlist_current: ... sent ignore\n");
} }
@@ -129,6 +131,7 @@ screenlist_current ()
sock_send_string (c->sock, str); sock_send_string (c->sock, str);
} else // The server has the display, so do nothing } else // The server has the display, so do nothing
{ {
;
} }
} }
} }