563 lines
12 KiB
C
563 lines
12 KiB
C
/* wirz-sli.c -- Source file for LCDproc Wirz SLI driver
|
|
Copyright (C) 1999 Horizon Technologies-http://horizon.pair.com/
|
|
Written by Bryan Rittmeyer <bryanr@pair.com> - Released under GPL
|
|
|
|
LCD info: http://www.wirz.com/sli/ */
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <termios.h>
|
|
#include <fcntl.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include "lcd.h"
|
|
#include "wirz-sli.h"
|
|
#include "drv_base.h"
|
|
|
|
#include "../../shared/debug.h"
|
|
#include "../../shared/str.h"
|
|
|
|
static int custom=0;
|
|
typedef enum {
|
|
hbar = 1,
|
|
vbar = 2,
|
|
bign = 4,
|
|
beat = 8 } custom_type;
|
|
|
|
static int fd;
|
|
static char lastframe[32];
|
|
|
|
lcd_logical_driver *sli;
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
// Opens com port and sets baud correctly...
|
|
//
|
|
int sli_init(lcd_logical_driver *driver, char *args)
|
|
{
|
|
char *argv[64];
|
|
int argc;
|
|
struct termios portset;
|
|
int i;
|
|
int tmp;
|
|
char out[2];
|
|
|
|
char device[256] = "/dev/lcd";
|
|
int speed=B19200;
|
|
|
|
sli = driver;
|
|
|
|
//debug("sli_init: Args(all): %s\n", args);
|
|
|
|
argc = get_args(argv, args, 64);
|
|
|
|
/*
|
|
for(i=0; i<argc; i++)
|
|
{
|
|
printf("Arg(%i): %s\n", i, argv[i]);
|
|
}
|
|
*/
|
|
|
|
for(i=0; i<argc; i++)
|
|
{
|
|
//printf("Arg(%i): %s\n", i, argv[i]);
|
|
if(0 == strcmp(argv[i], "-d") ||
|
|
0 == strcmp(argv[i], "--device"))
|
|
{
|
|
if(i + 1 > argc) {
|
|
fprintf(stderr, "sli_init: %s requires an argument\n",
|
|
argv[i]);
|
|
return -1;
|
|
}
|
|
strcpy(device, argv[++i]);
|
|
}
|
|
else if(0 == strcmp(argv[i], "-s") ||
|
|
0 == strcmp(argv[i], "--speed"))
|
|
{
|
|
if(i + 1 > argc) {
|
|
fprintf(stderr, "sli_init: %s requires an argument\n",
|
|
argv[i]);
|
|
return -1;
|
|
}
|
|
tmp = atoi(argv[++i]);
|
|
if(tmp==1200) speed=B1200;
|
|
else if(tmp==2400) speed=B2400;
|
|
else if(tmp==9600) speed=B9600;
|
|
else if(tmp==19200) speed=B19200;
|
|
else if(tmp==38400) speed=B38400;
|
|
else if(tmp==57600) speed=B57600;
|
|
else if(tmp==115200) speed=B115200;
|
|
else {
|
|
fprintf(stderr, "sli_init: %s argument must be 1200, 2400, 9600, 19200, 38400, 57600, or 115200. Using default value (19200).\n",
|
|
argv[i]);
|
|
}
|
|
}
|
|
else if(0 == strcmp(argv[i], "-h") ||
|
|
0 == strcmp(argv[i], "--help"))
|
|
{
|
|
printf("LCDproc Wirz SLI LCD driver\n"
|
|
"\t-d\t--device\tSelect the output device to use [/dev/lcd]\n"
|
|
"\t-s\t--speed\t\tSet the communication speed [19200]\n"
|
|
"\t-h\t--help\t\tShow this help information\n");
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
printf("Invalid parameter: %s\n", argv[i]);
|
|
}
|
|
|
|
}
|
|
|
|
// Set up io port correctly, and open it...
|
|
fd = open(device, O_RDWR | O_NOCTTY | O_NDELAY);
|
|
if (fd == -1)
|
|
{
|
|
fprintf(stderr, "sli_init: failed (%s)\n", strerror(errno));
|
|
return -1;
|
|
}
|
|
//else fprintf(stderr, "sli_init: opened device %s\n", device);
|
|
tcgetattr(fd, &portset);
|
|
// This is necessary in Linux, but does not exist in irix.
|
|
#ifndef IRIX
|
|
cfmakeraw(&portset);
|
|
#endif
|
|
cfsetospeed(&portset, speed);
|
|
tcsetattr(fd, TCSANOW, &portset);
|
|
|
|
/* Initialize SLI using autobaud detection, and then turn off cursor
|
|
and clear screen */
|
|
usleep(150000); /* 150ms delay to allow SLI to power on */
|
|
out[0]=13; /* CR for SLI autobaud */
|
|
write(fd, out, 1);
|
|
usleep(3000); /* 3ms delay.. wait for it to autobaud */
|
|
out[0]=0x0FE;
|
|
out[1]=0x00C; /* No cursor */
|
|
write(fd, out, 2);
|
|
out[0]=0x0FE;
|
|
out[1]=0x001; /* Clear LCD, not sure if this belongs here */
|
|
write(fd, out, 2);
|
|
|
|
|
|
if(!driver->framebuf)
|
|
{
|
|
fprintf(stderr, "sli_init: No frame buffer.\n");
|
|
driver->close();
|
|
return -1;
|
|
}
|
|
|
|
// Set LCD parameters (I use a 16x2 LCD) -- small but still useful
|
|
// Its also much cheaper than the higher quality Matrix Orbital modules
|
|
// Currently, $30 for interface kit and 16x2 non-backlit LCD...
|
|
driver->wid = 15;
|
|
driver->hgt = 2;
|
|
|
|
|
|
// Set the functions the driver supports...
|
|
|
|
driver->clear = (void *)-1;
|
|
driver->string = (void *)-1;
|
|
driver->chr = (void *)-1;
|
|
driver->vbar = sli_vbar;
|
|
driver->init_vbar = sli_init_vbar;
|
|
driver->hbar = sli_hbar;
|
|
driver->init_hbar = sli_init_hbar;
|
|
driver->num = (void *)-1;
|
|
driver->init_num = (void *)-1;
|
|
|
|
driver->init = sli_init;
|
|
driver->close = sli_close;
|
|
driver->flush = sli_flush;
|
|
driver->flush_box = sli_flush_box;
|
|
driver->contrast = (void *)-1;
|
|
driver->backlight = (void *)-1;
|
|
driver->set_char = sli_set_char;
|
|
driver->icon = sli_icon;
|
|
driver->draw_frame = sli_draw_frame;
|
|
|
|
driver->getkey = (void *)-1;
|
|
|
|
return fd;
|
|
}
|
|
|
|
|
|
/* Clean-up */
|
|
void sli_close()
|
|
{
|
|
close(fd);
|
|
|
|
if(sli->framebuf) free(sli->framebuf);
|
|
|
|
sli->framebuf = NULL;
|
|
}
|
|
|
|
|
|
void sli_flush()
|
|
{
|
|
sli_draw_frame(lcd.framebuf);
|
|
}
|
|
|
|
|
|
/* no bounds checking is done in MtxOrb.c (which I shamelessly ripped)
|
|
this is bad imho, so I added it.. may remove later
|
|
speed is not a huge issue though, this isnt a
|
|
device driver or anything ;) */
|
|
void sli_flush_box(int lft, int top, int rgt, int bot)
|
|
{
|
|
int y;
|
|
char out[2]; /* Why does the matrix driver allocate so much here? */
|
|
|
|
/* simple bounds checking */
|
|
if((top>lcd.hgt)|(bot>lcd.hgt))
|
|
return;
|
|
|
|
if((lft>lcd.wid)|(rgt>lcd.wid))
|
|
return;
|
|
|
|
// printf("Flush (%i,%i)-(%i,%i)\n", lft, top, rgt, bot);
|
|
|
|
/* I like having hex, everywhere and all the time */
|
|
for(y=top; y<=bot; y++)
|
|
{
|
|
if(y==1)
|
|
sprintf(out, "%c%c", 0x0FE, 0x080+lft);
|
|
if(y==2)
|
|
sprintf(out, "%c%c", 0x0FE, 0x0C0+lft);
|
|
write(fd, out, 0x002);
|
|
write(fd, lcd.framebuf+(y*lcd.wid)+lft, rgt-lft+1);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
// 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).
|
|
//
|
|
void sli_chr(int x, int y, char c)
|
|
{
|
|
y--;
|
|
x--;
|
|
|
|
lcd.framebuf[(y*lcd.wid) + x] = c;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
// Sets up for vertical bars. Call before lcd.vbar()
|
|
//
|
|
|
|
/* Because of the way we do this (custom characters in CGRAM)
|
|
we can't have both horizontal and vertical bars at once...
|
|
this also appears to be a limitation of the Matrix Orbital
|
|
modules so I will assume that all client coders know about it
|
|
|
|
I think it would be cool to use triangular stuff for the non-full
|
|
characters, so that you can do both bar types at once.. maybe I
|
|
will release a new version of the SLI driver that attempts this */
|
|
|
|
void sli_init_vbar()
|
|
{
|
|
char a[] = {
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
1,1,1,1,1,
|
|
};
|
|
char b[] = {
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
};
|
|
char c[] = {
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
};
|
|
char d[] = {
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
};
|
|
char e[] = {
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
};
|
|
char f[] = {
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
};
|
|
char g[] = {
|
|
0,0,0,0,0,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
1,1,1,1,1,
|
|
};
|
|
|
|
if(custom!=vbar) {
|
|
sli_set_char(1,a);
|
|
sli_set_char(2,b);
|
|
sli_set_char(3,c);
|
|
sli_set_char(4,d);
|
|
sli_set_char(5,e);
|
|
sli_set_char(6,f);
|
|
sli_set_char(7,g);
|
|
custom=vbar;
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
// Inits horizontal bars...
|
|
//
|
|
void sli_init_hbar()
|
|
{
|
|
|
|
char a[] = {
|
|
1,0,0,0,0,
|
|
1,0,0,0,0,
|
|
1,0,0,0,0,
|
|
1,0,0,0,0,
|
|
1,0,0,0,0,
|
|
1,0,0,0,0,
|
|
1,0,0,0,0,
|
|
1,0,0,0,0,
|
|
};
|
|
char b[] = {
|
|
1,1,0,0,0,
|
|
1,1,0,0,0,
|
|
1,1,0,0,0,
|
|
1,1,0,0,0,
|
|
1,1,0,0,0,
|
|
1,1,0,0,0,
|
|
1,1,0,0,0,
|
|
1,1,0,0,0,
|
|
};
|
|
char c[] = {
|
|
1,1,1,0,0,
|
|
1,1,1,0,0,
|
|
1,1,1,0,0,
|
|
1,1,1,0,0,
|
|
1,1,1,0,0,
|
|
1,1,1,0,0,
|
|
1,1,1,0,0,
|
|
1,1,1,0,0,
|
|
};
|
|
char d[] = {
|
|
1,1,1,1,0,
|
|
1,1,1,1,0,
|
|
1,1,1,1,0,
|
|
1,1,1,1,0,
|
|
1,1,1,1,0,
|
|
1,1,1,1,0,
|
|
1,1,1,1,0,
|
|
1,1,1,1,0,
|
|
};
|
|
|
|
if(custom!=hbar) {
|
|
sli_set_char(1,a);
|
|
sli_set_char(2,b);
|
|
sli_set_char(3,c);
|
|
sli_set_char(4,d);
|
|
custom=hbar;
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
// Draws a vertical bar...
|
|
//
|
|
|
|
/* It would be cool if you could start a vertical bar at any y
|
|
like the horizontal bar routine can start at any x... but
|
|
since we only have 2 lines anyway this is rather pointless
|
|
for me to add */
|
|
|
|
void sli_vbar(int x, int len)
|
|
{
|
|
char map[9] = {32, 1, 2, 3, 4, 5, 6, 7, 255 };
|
|
|
|
|
|
int y;
|
|
for(y=lcd.hgt; y > 0 && len>0; y--)
|
|
{
|
|
if(len >= lcd.cellhgt) sli_chr(x, y, 255);
|
|
else sli_chr(x, y, map[len]);
|
|
|
|
len -= lcd.cellhgt;
|
|
}
|
|
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
// Draws a horizontal bar to the right.
|
|
//
|
|
void sli_hbar(int x, int y, int len)
|
|
{
|
|
char map[6] = { 32, 1, 2, 3, 4, 255 };
|
|
|
|
for(; x<=lcd.wid && len>0; x++)
|
|
{
|
|
if(len >= lcd.cellwid) sli_chr(x,y,255);
|
|
else sli_chr(x, y, map[len]);
|
|
|
|
len -= lcd.cellwid;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
// Sets a custom character from 0-7...
|
|
//
|
|
// For input, values > 0 mean "on" and values <= 0 are "off".
|
|
//
|
|
// The input is just an array of characters...
|
|
//
|
|
void sli_set_char(int n, char *dat)
|
|
{
|
|
char out[2];
|
|
int row, col;
|
|
int letter;
|
|
|
|
/* SLI also has 8 user definable characters */
|
|
if(n < 0 || n > 7) return;
|
|
if(!dat) return;
|
|
|
|
/* Move cursor to CGRAM */
|
|
out[0]=0x0FE;
|
|
out[1]=0x040+8*n;
|
|
write(fd, out, 2);
|
|
|
|
for(row=0; row<lcd.cellhgt; row++)
|
|
{
|
|
letter = 0;
|
|
for(col=0; col<lcd.cellwid; col++)
|
|
{
|
|
letter <<= 1;
|
|
letter |= (dat[(row*lcd.cellwid) + col] > 0);
|
|
}
|
|
letter|=0x020; /* SLI can't accept CR, LF, etc in this character! */
|
|
write(fd, &letter, 1);
|
|
}
|
|
|
|
/* Move cursor back to DDRAM */
|
|
out[0]=0x0FE;
|
|
out[1]=0x080;
|
|
write(fd, out, 2);
|
|
}
|
|
|
|
|
|
void sli_icon(int which, char dest)
|
|
{
|
|
char icons[3][5*8] = {
|
|
{
|
|
1,1,1,1,1, // Empty Heart
|
|
1,0,1,0,1,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
1,0,0,0,1,
|
|
1,1,0,1,1,
|
|
1,1,1,1,1,
|
|
},
|
|
|
|
{
|
|
1,1,1,1,1, // Filled Heart
|
|
1,0,1,0,1,
|
|
0,1,0,1,0,
|
|
0,1,1,1,0,
|
|
0,1,1,1,0,
|
|
1,0,1,0,1,
|
|
1,1,0,1,1,
|
|
1,1,1,1,1,
|
|
},
|
|
|
|
{
|
|
0,0,0,0,0, // Ellipsis
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
0,0,0,0,0,
|
|
1,0,1,0,1,
|
|
},
|
|
|
|
};
|
|
|
|
if(custom==bign) custom=beat;
|
|
sli_set_char(dest, &icons[which][0]);
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// Blasts a single frame onscreen, to the lcd...
|
|
//
|
|
// Input is a character array, sized lcd.wid*lcd.hgt
|
|
//
|
|
void sli_draw_frame(char *dat)
|
|
{
|
|
char out[2]; /* Again, why does the Matrix driver allocate so much here? */
|
|
int y;
|
|
|
|
if(!dat) return;
|
|
|
|
/*
|
|
out[0]=0x0FE;
|
|
out[1]=0x001;
|
|
write(fd, out, 2);
|
|
*/
|
|
|
|
/* Don't update if we have no new data
|
|
this keeps me from getting a migraine
|
|
(just like those copyleft penguin mints... mmmmmm) */
|
|
|
|
// if (!strncmp(dat,lastframe,32)) /* Nothing has changed */
|
|
// return;
|
|
|
|
/* Do the actual refresh */
|
|
out[0]=0x0FE;
|
|
out[1]=0x080;
|
|
write(fd, out, 2);
|
|
write(fd, &dat[0], 16);
|
|
usleep(10);
|
|
write(fd, &dat[16],15);
|
|
|
|
// strncpy(lastframe,dat,32); // Update lastframe...
|
|
|
|
}
|