mangavalk/lcdproc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
5e5ee21e37937fbecc7ca0084718fc3fb1f808d8
lcdproc/server/drivers/lis.c
T
marschap 5e5ee21e37 update lis driver Daryl F
2007-05-26 19:43:13 +00:00

1443 lines
34 KiB
C
Raw Blame History

/*
* LIS driver for lcdproc
* For the L.I.S MCE vacuum fluorescent display from vlsys.co.kr
* 20x2 display using NEC UPD16314 driver and FTDI FT232RQ USB-to-serial
* converter.
*
* This driver uses the libftdi library to interface to the FTDI chip. Make
* sure kernel module ftdi_sio doesn't claim the device.
*
* Based on: ula200 driver Copyright (C) 2006, Bernhard Walle
*
* Copyright (c) 2007, Daryl Fonseca-Holt <wyatt@prairieturtle.ca>
*
* This file is released under the GNU General Public License. Refer to the
* COPYING file distributed with this package.
*
*
*
*
*/
/*
* Notes on this driver
*
* vlsys is unwilling to provide information about the protocol for this
* device. This driver was developed entirely by analyzing the USB data
* flowing between the host and the device on a WinXP machine. As such it
* probably isn't an optimal driver but it works.
*
* Using a dirty buffer/clean buffer approach was useless since I could
* not determine how to write to specific columns. The only thing selectable
* was which line would be written at column 1.
*/
/* CHANGES:
*
* 2007/05/22 Removed useless Device= config option.
* Added VendorID= and ProductID= config
* option parsting. Moved constants to
* lis.h where they belong. Added
* lis_cellheight() and lis_cellwidth().
* Completely commented out lis_test() to
* save memory.
*/
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <termios.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <syslog.h>
#include <usb.h>
#include <ftdi.h>
#include <sys/syscall.h>
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "lcd.h"
#include "lis.h"
#include "report.h"
#include "lcd_lib.h"
#include "timing.h"
// void lis_test(Driver *drvthis);
/* Vars for the server core */
MODULE_EXPORT char *api_version = API_VERSION;
MODULE_EXPORT int stay_in_foreground = 0;
MODULE_EXPORT int supports_multiple = 1;
MODULE_EXPORT char *symbol_prefix = "lis_";
/*
* Charactar mapping for UPD16314 device by Daryl Fonseca-Holt
* <wyatt@prairieturtle.ca> taken from Mark Haemmerling's HD44780 table.
* Character mapping for HD44780 devices by Mark Haemmerling <mail@markh.de>.
*
* Translates ISO 8859-1 to any HD44780 charset.
*
* Charmap selector (C) 2006 Pillon Matteo <matteo.pillon@email.it>
*
* This file is released under the GNU General Public License.
* Refer to the COPYING file distributed with this package.
*/
/*
* UPD16314 table
*
*/
const unsigned char UPD16314_charmap[] = {
/* #0 */
0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31,
/* #32 */
32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55,
56, 57, 58, 59, 60, 61, 62, 63,
/* #64 */
64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 78, 79,
80, 81, 82, 83, 84, 85, 86, 87,
88, 89, 90, 91, 47, 93, 94, 95,
/* #96 */
96, 97, 98, 99, 100, 101, 102, 103,
104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119,
120, 121, 122, 123, 124, 125, 126, 127,
/* #128 */
128, 129, 130, 131, 132, 133, 134, 135,
136, 137, 138, 139, 140, 141, 142, 143,
144, 145, 146, 147, 148, 149, 150, 151,
152, 153, 154, 155, 156, 157, 158, 159,
/* #160 */
160, 33, 236, 237, 164, 92, 124, 167,
168, 169, 170, 171, 172, 173, 174, 175,
176, 177, 178, 179, 180, 181, 182, 183,
184, 185, 186, 187, 188, 189, 190, 191,
/* #192 */
192, 193, 194, 195, 196, 197, 198, 199,
200, 201, 202, 203, 204, 205, 206, 207,
208, 209, 210, 211, 212, 213, 214, 215,
216, 217, 218, 219, 220, 221, 223, 224,
/* #224 */
224, 225, 226, 227, 228, 229, 230, 231,
232, 233, 234, 235, 237, 237, 238, 239,
240, 241, 242, 243, 244, 245, 246, 247,
248, 249, 250, 251, 252, 253, 254, 3
};
///////////////////////////////////////////////////////////////////////////////
// Write a command to the display.
//
// @param p the private data
// @param data the data bytes
// @param length the number of bytes in @p data which are valid
// @return 0 on success, negative value on error
//
static int
lis_ftdi_write_command(Driver *drvthis, unsigned char *data, int length)
{
PrivateData *p = (PrivateData *) drvthis->private_data;
int err;
err = ftdi_write_data(&p->ftdic, data, length);
if (err < 0) {
report(RPT_WARNING, "%s: ftdi_write_data failed with %d", drvthis->name, err);
return -1;
}
timing_uPause(16000);
return 0;
}
//////////////////////////////////////////////////////////////////////////////
// Displays a string at line n (n typically 1 or 2)
//
static int
lis_ftdi_line_to_display(Driver *drvthis, int line, unsigned char *string, int len)
{
PrivateData *p = (PrivateData *) drvthis->private_data;
unsigned char buffer[128];
int err;
int i;
if (len > p->width || line < 1 || line > p->height) {
return -EINVAL;
}
buffer[0] = 0xA0 + line;
buffer[1] = 0;
buffer[2] = 0xA7;
for (i=0; i < len; i++) {
buffer[i+3] = UPD16314_charmap[(unsigned char)string[i]];
}
buffer[i+3] = 0x00;
err = lis_ftdi_write_command(drvthis, buffer, len+4);
if (err < 0) {
report(RPT_WARNING, "%s: lis_ftdi_string: "
"lis_ftdi_write_command() failed", drvthis->name);
}
return err;
}
///////////////////////////////////////////////////////////////////////////////
// Flush the framebuffer to the display
//
MODULE_EXPORT void
lis_flush(Driver *drvthis)
{
PrivateData *p = (PrivateData *) drvthis->private_data;
int line;
for (line = 0; line < p->height; line++) {
if (p->line_flags[line]) {
lis_ftdi_line_to_display(drvthis, line+1, p->framebuf + (line * p->width), p->width);
p->line_flags[line] = 0; // clean
}
}
}
///////////////////////////////////////////////////////////////////////////////
// Loads custom characters in the display
//
static int
lis_load_custom_chars(Driver *drvthis)
{
PrivateData *p = (PrivateData *) drvthis->private_data;
int i, col, row, err;
unsigned char buffer[65];
char custom_chars[8][CELLHEIGHT*CELLHEIGHT] = {
{ 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,
0, 0, 0, 0, 0 },
{ 1, 0, 0, 0, 0, /* 1-5 characters used by hbar() */
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, 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 },
{ 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 },
{ 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 },
{ 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,
1, 1, 1, 1, 1 },
{ 0, 0, 0, 0, 0,
0, 0, 0, 0, 0,
1, 1, 1, 1, 1,
1, 0, 0, 0, 1,
1, 0, 0, 0, 1,
1, 0, 0, 0, 1,
1, 1, 1, 1, 1,
0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0,
0, 0, 0, 0, 0,
1, 1, 1, 1, 1,
1, 0, 1, 0, 1,
1, 1, 0, 1, 1,
1, 0, 1, 0, 1,
1, 1, 1, 1, 1,
0, 0, 0, 0, 0 }};
buffer[0] = 0xAD; // command to write CGRAM at 0
for (i = 0; i < 8; i++)
{
/* build the buffer */
for (row = 0; row < CELLHEIGHT; row++) {
unsigned char value = 0;
for (col = 0; col < CELLWIDTH; col++) {
value <<= 1;
value |= (custom_chars[i][(row * CELLWIDTH) + col] > 0) ? 1 : 0;
}
buffer[(i*8)+row+1] = value;
}
}
err = lis_ftdi_write_command(drvthis, buffer, 65);
if (err < 0) {
report(RPT_WARNING, "%s: lis_load_custom_chars(): "
"lis_ftdi_write_command() failed", drvthis->name);
}
else
p->cc_flag = 1;
return err;
}
//////////////////////////////////////////////////////////////////////////////
// Separate thread to keep a read up on the USB device at all times
int
lis_read_thread(void *arg)
{
Driver *drvthis;
PrivateData *p;
char unsigned buffer[64];
int size;
drvthis = (Driver *)arg;
p = (PrivateData *) drvthis->private_data;
while(! p->child_flag) {
for (size = ftdi_read_data(&p->ftdic, buffer, 64); size > 0; size = ftdi_read_data(&p->ftdic, buffer, 64))
;
if (size < 0) {
return size;
p->parent_flag = 0;
}
}
p->parent_flag = 0;
return 0;
}
///////////////////////////////////////////////////////////////////////////////
// Control the display brightness
//
MODULE_EXPORT int
lis_set_brightness(Driver *drvthis, int state, int promille)
{
unsigned char buffer[2];
int err;
PrivateData *p = (PrivateData *) drvthis->private_data;
if (promille < 0 || promille > 1000)
return -EINVAL;
buffer[0] = 0xA5;
if ( promille < 251 )
buffer[1] = 0x3; // 25%
else if ( promille < 501 )
buffer[1] = 0x2; // 50%
else if ( promille < 751 )
buffer[1] = 0x1; // 75%
else
buffer[1] = 0x0; // 100%
err = ftdi_write_data(&p->ftdic, buffer, 2);
if (err < 0) {
report(RPT_WARNING, "%s: lis_set_brightness(): ftdi_write_data failed with %d", drvthis->name, err);
return err;
}
else
p->brightness = promille;
return 0;
}
///////////////////////////////////////////////////////////////////////////////
// Get the brightness setting
MODULE_EXPORT int
lis_get_brightness(Driver *drvthis, int state)
{
PrivateData *p = (PrivateData *) drvthis->private_data;
return p->brightness;
}
///////////////////////////////////////////////////////////////////////////////
// Init the driver and display
//
MODULE_EXPORT int
lis_init(Driver *drvthis)
{
PrivateData *p;
int err;
const char *s;
unsigned char buffer[64], *thread_stack;
int count;
// Alocate and store private data
p = (PrivateData *) malloc( sizeof( PrivateData) );
if (p == NULL) {
return -1;
}
if (drvthis->store_private_ptr(drvthis, p)) {
return -1;
}
p->child_flag = 0;
p->parent_flag = 0;
p->cc_flag = 0;
// Get and parse size
s = drvthis->config_get_string( drvthis->name, "size", 0, "20x2");
if ((sscanf(s, "%dx%d", &(p->width), &(p->height)) != 2)
|| (p->width <= 0) || (p->width > LCD_MAX_WIDTH)
|| (p->height <= 0) || (p->height > LCD_MAX_HEIGHT)) {
report(RPT_ERR, "%s: cannot read Size %s", drvthis->name, s);
return -1;
}
// set up the dirty flags
if( ! (p->line_flags = (unsigned int *)malloc(sizeof(int) * p->height))) {
report(RPT_ERR, "%s: cannot allocate line flags memory", drvthis->name);
return -1;
}
for (count = 0; count < p->height; count++)
p->line_flags[count] = 1; // dirty!
/* Which display brightness */
count = drvthis->config_get_int(drvthis->name, "Brightness", 0, DEFAULT_BRIGHTNESS);
if ((count < 0) || (count > 1000)) {
report(RPT_WARNING, "%s: Brightness must be between 0 and 1000; using default %d",
drvthis->name, DEFAULT_BRIGHTNESS);
count = DEFAULT_BRIGHTNESS;
}
p->brightness = count;
p->VendorID = drvthis->config_get_int(drvthis->name, "VendorID", 0, DISPLAY_VENDOR_ID);
p->ProductID = drvthis->config_get_int(drvthis->name, "ProductID", 0, DISPLAY_PRODUCT_ID);
/* End of config file parsing */
// initialise delay timing
if (timing_init()) {
report(RPT_ERR, "%s: cannot initialise delay timing", drvthis->name);
return -1;
}
// Allocate framebuffer
p->framebuf = (unsigned char *) malloc(p->width * p->height);
if (p->framebuf == NULL) {
report(RPT_ERR, "%s: unable to allocate framebuffer", drvthis->name);
goto err_begin;
}
// open the FTDI library
ftdi_init(&p->ftdic);
// (&p->ftdic)->usb_write_timeout = 20;
// (&p->ftdic)->usb_read_timeout = 20;
// open the device
err = ftdi_usb_open(&p->ftdic, p->VendorID, p->ProductID);
if (err < 0) {
report(RPT_ERR, "%s: cannot open USB device %x:%x",
drvthis->name
p->VendorID,
p->ProductID);
goto err_framebuf;
}
// set communication parameters
err = ftdi_set_line_property(&p->ftdic, BITS_7, STOP_BIT_1, EVEN);
if (err < 0) {
report(RPT_ERR, "%s: cannot set line properties", drvthis->name);
goto err_ftdi;
}
// set DTR mask and high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_MASK | SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR mask", drvthis->name);
goto err_ftdi;
}
// set RTS mask and high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_MASK | SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS mask", drvthis->name);
goto err_ftdi;
}
// set the baudrate
err = ftdi_set_baudrate(&p->ftdic, 1200);
if (err < 0) {
report(RPT_ERR, "%s: cannot set baudrate", drvthis->name);
goto err_ftdi;
}
// set RTS high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS high", drvthis->name);
goto err_ftdi;
}
// set DTR high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR high", drvthis->name);
goto err_ftdi;
}
for (count = 0; count < 6; count++) {
// reset device
err = ftdi_usb_reset(&p->ftdic);
if (err < 0) {
report(RPT_ERR, "%s: cannot reset device", drvthis->name);
goto err_ftdi;
}
}
// set latency timer
err = ftdi_set_latency_timer(&p->ftdic, 16);
if (err < 0) {
report(RPT_ERR, "%s: cannot set latency timer", drvthis->name);
goto err_ftdi;
}
// clone a thread to keep a read up on the device
thread_stack = calloc(4096, 1);
if(! thread_stack) {
report(RPT_ERR, "%s: cannot create thread stack", drvthis->name);
goto err_framebuf;
}
err = clone(lis_read_thread, thread_stack+4092, CLONE_VM | CLONE_THREAD| CLONE_SIGHAND, drvthis);
if (err == -1) {
report(RPT_ERR, "%s: clone() - %s", drvthis->name, strerror(errno));
goto err_framebuf;
}
p->parent_flag = 1; // show we're now a happy parent, birth successful.
// set communication parameters
err = ftdi_set_line_property(&p->ftdic, BITS_7, STOP_BIT_1, EVEN);
if (err < 0) {
report(RPT_ERR, "%s: cannot set line properties", drvthis->name);
goto err_ftdi;
}
// set DTR mask and high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_MASK | SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR mask", drvthis->name);
goto err_ftdi;
}
// set RTS mask and high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_MASK | SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS mask", drvthis->name);
goto err_ftdi;
}
// disable flow control
err = ftdi_setflowctrl(&p->ftdic, SIO_DISABLE_FLOW_CTRL);
if (err < 0) {
report(RPT_ERR, "%s: cannot disable flow control", drvthis->name);
goto err_ftdi;
}
// set the baudrate
err = ftdi_set_baudrate(&p->ftdic, 1200);
if (err < 0) {
report(RPT_ERR, "%s: cannot set baudrate", drvthis->name);
goto err_ftdi;
}
// set RTS mask and high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_MASK | SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS mask", drvthis->name);
goto err_ftdi;
}
// set DTR mask and high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_MASK | SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR mask", drvthis->name);
goto err_ftdi;
}
// disable flow control
err = ftdi_setflowctrl(&p->ftdic, SIO_DISABLE_FLOW_CTRL);
if (err < 0) {
report(RPT_ERR, "%s: cannot disable flow control", drvthis->name);
goto err_ftdi;
}
// set DTR mask and high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_MASK | SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR mask", drvthis->name);
goto err_ftdi;
}
// set RTS high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS high", drvthis->name);
goto err_ftdi;
}
timing_uPause(192000);
// set the baudrate
err = ftdi_set_baudrate(&p->ftdic, 1200);
if (err < 0) {
report(RPT_ERR, "%s: cannot set baudrate", drvthis->name);
goto err_ftdi;
}
// set communication parameters
err = ftdi_set_line_property(&p->ftdic, BITS_7, STOP_BIT_1, NONE);
if (err < 0) {
report(RPT_ERR, "%s: cannot set line properties", drvthis->name);
goto err_ftdi;
}
// set DTR high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR high", drvthis->name);
goto err_ftdi;
}
// set RTS high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS high", drvthis->name);
goto err_ftdi;
}
timing_uPause(192000);
// set DTR mask and high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_MASK | SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR mask", drvthis->name);
goto err_ftdi;
}
timing_uPause(192000);
// set RTS mask and high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_MASK | SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS mask", drvthis->name);
goto err_ftdi;
}
timing_uPause(236000);
// set DTR high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR high", drvthis->name);
goto err_ftdi;
}
// set RTS high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS high", drvthis->name);
goto err_ftdi;
}
timing_uPause(192000);
// set DTR mask and high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_MASK | SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR mask", drvthis->name);
goto err_ftdi;
}
// set RTS mask and high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_MASK | SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS mask", drvthis->name);
goto err_ftdi;
}
timing_uPause(236000);
// set DTR mask and high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_MASK | SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR mask", drvthis->name);
goto err_ftdi;
}
// set RTS high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS high", drvthis->name);
goto err_ftdi;
}
timing_uPause(192000);
// set the baudrate
err = ftdi_set_baudrate(&p->ftdic, 1200);
if (err < 0) {
report(RPT_ERR, "%s: cannot set baudrate", drvthis->name);
goto err_ftdi;
}
// set communication parameters
err = ftdi_set_line_property(&p->ftdic, BITS_7, STOP_BIT_1, NONE);
if (err < 0) {
report(RPT_ERR, "%s: cannot set line properties", drvthis->name);
goto err_ftdi;
}
// set DTR high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR high", drvthis->name);
goto err_ftdi;
}
// set RTS high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS high", drvthis->name);
goto err_ftdi;
}
timing_uPause(192000);
// set DTR mask and high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_MASK | SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR mask", drvthis->name);
goto err_ftdi;
}
timing_uPause(192000);
// set RTS mask and high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_MASK | SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS mask", drvthis->name);
goto err_ftdi;
}
timing_uPause(236000);
// set DTR high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR high", drvthis->name);
goto err_ftdi;
}
// set RTS high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS high", drvthis->name);
goto err_ftdi;
}
timing_uPause(236000);
// set DTR mask and high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_MASK | SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR mask", drvthis->name);
goto err_ftdi;
}
// set RTS high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS high", drvthis->name);
goto err_ftdi;
}
// set the baudrate
err = ftdi_set_baudrate(&p->ftdic, 1200);
if (err < 0) {
report(RPT_ERR, "%s: cannot set baudrate", drvthis->name);
goto err_ftdi;
}
// set communication parameters
err = ftdi_set_line_property(&p->ftdic, BITS_7, STOP_BIT_1, NONE);
if (err < 0) {
report(RPT_ERR, "%s: cannot set line properties", drvthis->name);
goto err_ftdi;
}
// set DTR high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR high", drvthis->name);
goto err_ftdi;
}
// set RTS high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS high", drvthis->name);
goto err_ftdi;
}
timing_uPause(13*16000);
// set DTR mask and high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_MASK | SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR mask", drvthis->name);
goto err_ftdi;
}
timing_uPause(13*16000);
// set RTS mask and high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_MASK | SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS mask", drvthis->name);
goto err_ftdi;
}
timing_uPause(15*16000);
// set DTR high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR high", drvthis->name);
goto err_ftdi;
}
// set RTS high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS high", drvthis->name);
goto err_ftdi;
}
timing_uPause(13*16000);
// set DTR mask and high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_MASK | SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR mask", drvthis->name);
goto err_ftdi;
}
// set RTS mask and high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_MASK | SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS mask", drvthis->name);
goto err_ftdi;
}
timing_uPause(16*16000);
// set DTR mask and high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_MASK | SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR mask", drvthis->name);
goto err_ftdi;
}
// set RTS mask and high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_MASK | SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS mask", drvthis->name);
goto err_ftdi;
}
// disable flow control
err = ftdi_setflowctrl(&p->ftdic, SIO_DISABLE_FLOW_CTRL);
if (err < 0) {
report(RPT_ERR, "%s: cannot disable flow control", drvthis->name);
goto err_ftdi;
}
timing_uPause(16000);
// set DTR high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR high", drvthis->name);
goto err_ftdi;
}
// set RTS high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS high", drvthis->name);
goto err_ftdi;
}
for (count = 0; count < 6; count++) {
// reset device
err = ftdi_usb_reset(&p->ftdic);
if (err < 0) {
report(RPT_ERR, "%s: cannot reset device", drvthis->name);
goto err_ftdi;
}
}
// set latency timer
err = ftdi_set_latency_timer(&p->ftdic, 16);
if (err < 0) {
report(RPT_ERR, "%s: cannot set latency timer", drvthis->name);
goto err_ftdi;
}
timing_uPause(16000);
// set communication parameters
err = ftdi_set_line_property(&p->ftdic, BITS_7, STOP_BIT_1, NONE);
if (err < 0) {
report(RPT_ERR, "%s: cannot set line properties", drvthis->name);
goto err_ftdi;
}
// set DTR mask and high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_MASK | SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR mask", drvthis->name);
goto err_ftdi;
}
// set RTS mask and high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_MASK | SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS mask", drvthis->name);
goto err_ftdi;
}
// disable flow control
err = ftdi_setflowctrl(&p->ftdic, SIO_DISABLE_FLOW_CTRL);
if (err < 0) {
report(RPT_ERR, "%s: cannot disable flow control", drvthis->name);
goto err_ftdi;
}
// set the baudrate
err = ftdi_set_baudrate(&p->ftdic, 1200);
if (err < 0) {
report(RPT_ERR, "%s: cannot set baudrate", drvthis->name);
goto err_ftdi;
}
// set the baudrate
err = ftdi_set_baudrate(&p->ftdic, 38400);
if (err < 0) {
report(RPT_ERR, "%s: cannot set baudrate", drvthis->name);
goto err_ftdi;
}
// set RTS mask and high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_MASK | SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS mask", drvthis->name);
goto err_ftdi;
}
// set DTR mask and high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_MASK | SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR mask", drvthis->name);
goto err_ftdi;
}
// set communication parameters N,8,1
err = ftdi_set_line_property(&p->ftdic, BITS_8, STOP_BIT_1, NONE);
if (err < 0) {
report(RPT_ERR, "%s: cannot set line properties N,8,1", drvthis->name);
goto err_ftdi;
}
// disable flow control
err = ftdi_setflowctrl(&p->ftdic, SIO_DISABLE_FLOW_CTRL);
if (err < 0) {
report(RPT_ERR, "%s: cannot disable flow control", drvthis->name);
goto err_ftdi;
}
// set DTR high
err = ftdi_setrts(&p->ftdic, SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR high", drvthis->name);
goto err_ftdi;
}
#if 0
// uncomment this if using a patched version of ftdi
// set the event character to 0x00
err = ftdi_set_event_char(&p->ftdic, 0x100);
if (err < 0) {
report(RPT_ERR, "%s: cannot set event character ", drvthis->name);
goto err_ftdi;
}
timing_uPause(16000);
#endif
// don't know what this does exactly
buffer[0] = 0xA4;
buffer[1] = 0x7d;
err = ftdi_write_data(&p->ftdic, buffer, 2);
if (err < 0) {
report(RPT_WARNING, "%s: ftdi_write_data failed with %d", drvthis->name, err);
goto err_ftdi;
}
timing_uPause(3*16000);
buffer[0] = 0xAA;
buffer[1] = 0xAA;
for(count = 0; count < 10; count++) {
err = ftdi_write_data(&p->ftdic, buffer, 2);
if (err < 0) {
report(RPT_WARNING, "%s: ftdi_write_data failed with %d", drvthis->name, err);
goto err_ftdi;
}
timing_uPause(3*16000);
}
// set the event character to 0x00 (only works with patched libftdi)
// err = ftdi_set_event_char(&p->ftdic, 0x00);
// if (err < 0) {
// report(RPT_ERR, "%s: cannot set event character ", drvthis->name);
// goto err_ftdi;
// }
//
// timing_uPause(16000);
// set DTR high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR high", drvthis->name);
goto err_ftdi;
}
// set RTS high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS high", drvthis->name);
goto err_ftdi;
}
for (count = 0; count < 6; count++) {
// reset device
err = ftdi_usb_reset(&p->ftdic);
if (err < 0) {
report(RPT_ERR, "%s: cannot reset device", drvthis->name);
goto err_ftdi;
}
}
// set latency timer
err = ftdi_set_latency_timer(&p->ftdic, 16);
if (err < 0) {
report(RPT_ERR, "%s: cannot set latency timer", drvthis->name);
goto err_ftdi;
}
timing_uPause(16000);
// set communication parameters N,8,1
err = ftdi_set_line_property(&p->ftdic, BITS_8, STOP_BIT_1, NONE);
if (err < 0) {
report(RPT_ERR, "%s: cannot set line properties N,8,1", drvthis->name);
goto err_ftdi;
}
// set DTR mask and high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_MASK | SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR mask", drvthis->name);
goto err_ftdi;
}
// set RTS mask and high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_MASK | SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS mask", drvthis->name);
goto err_ftdi;
}
// disable flow control
err = ftdi_setflowctrl(&p->ftdic, SIO_DISABLE_FLOW_CTRL);
if (err < 0) {
report(RPT_ERR, "%s: cannot disable flow control", drvthis->name);
goto err_ftdi;
}
// set the baudrate
err = ftdi_set_baudrate(&p->ftdic, 38400);
if (err < 0) {
report(RPT_ERR, "%s: cannot set baudrate 38400", drvthis->name);
goto err_ftdi;
}
// set the baudrate
err = ftdi_set_baudrate(&p->ftdic, 38400);
if (err < 0) {
report(RPT_ERR, "%s: cannot set baudrate 38400", drvthis->name);
goto err_ftdi;
}
// set RTS mask and high
err = ftdi_setrts(&p->ftdic, SIO_SET_RTS_MASK | SIO_SET_RTS_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set RTS mask", drvthis->name);
goto err_ftdi;
}
// set DTR mask and high
err = ftdi_setdtr(&p->ftdic, SIO_SET_DTR_MASK | SIO_SET_DTR_HIGH);
if (err < 0) {
report(RPT_ERR, "%s: cannot set DTR mask", drvthis->name);
goto err_ftdi;
}
// set communication parameters N,8,1
err = ftdi_set_line_property(&p->ftdic, BITS_8, STOP_BIT_1, NONE);
if (err < 0) {
report(RPT_ERR, "%s: cannot set line properties N,8,1", drvthis->name);
goto err_ftdi;
}
// disable flow control
err = ftdi_setflowctrl(&p->ftdic, SIO_DISABLE_FLOW_CTRL);
if (err < 0) {
report(RPT_ERR, "%s: cannot disable flow control", drvthis->name);
goto err_ftdi;
}
// turn off the event character (only works with patched libftdi)
// err = ftdi_set_event_char(&p->ftdic, 0x00);
// if (err < 0) {
// report(RPT_ERR, "%s: cannot turn off event character ", drvthis->name);
// goto err_ftdi;
// }
//
// timing_uPause(2*16000);
// not sure about this
buffer[0] = 0xA0;
err = lis_ftdi_write_command(drvthis, buffer, 1);
if (err < 0) {
report(RPT_WARNING, "%s: lis_ftdi_clear: "
"lis_ftdi_write_command failed", drvthis->name);
}
timing_uPause(10*16000);
lis_load_custom_chars(drvthis);
report(RPT_DEBUG, "%s: init() done", drvthis->name);
// lis_test(drvthis); /*DEBUG*/
return 0;
err_ftdi:
ftdi_usb_close(&p->ftdic);
ftdi_deinit(&p->ftdic);
if(p->line_flags)
free(p->line_flags);
err_framebuf:
free(p->framebuf);
err_begin:
if (p->parent_flag) { // terminate the child
p->child_flag = 1;
while(p->parent_flag)
timing_uPause(5*16000);
}
return -1;
}
///////////////////////////////////////////////////////////////////////////////
// Clean-up
//
MODULE_EXPORT void
lis_close(Driver *drvthis)
{
PrivateData *p = (PrivateData *) drvthis->private_data;
if (p != NULL) {
if (p->parent_flag) { // terminate the child
p->child_flag = 1;
while(p->parent_flag)
timing_uPause(5*16000);
}
ftdi_usb_purge_buffers(&p->ftdic);
ftdi_usb_close(&p->ftdic);
ftdi_deinit(&p->ftdic);
if (p->framebuf != NULL)
free(p->framebuf);
free(p);
}
drvthis->store_private_ptr(drvthis, NULL);
}
///////////////////////////////////////////////////////////////////////////////
// Returns the display width
//
MODULE_EXPORT int
lis_width (Driver *drvthis)
{
PrivateData *p = (PrivateData *) drvthis->private_data;
return p->width;
}
///////////////////////////////////////////////////////////////////////////////
// Returns the display height
//
MODULE_EXPORT int
lis_height (Driver *drvthis)
{
PrivateData *p = (PrivateData *) drvthis->private_data;
return p->height;
}
///////////////////////////////////////////////////////////////////////////////
// Clear the framebuffer
//
MODULE_EXPORT void
lis_clear (Driver *drvthis)
{
PrivateData *p = (PrivateData *) drvthis->private_data;
int line;
for (line = 0; line < p->height; line++) {
memset(p->framebuf + (line * p->width), ' ', p->width);
p->line_flags[line] = 1;
}
p->ccmode = standard;
}
///////////////////////////////////////////////////////////////////////////////
// Place a character in the framebuffer
//
MODULE_EXPORT void
lis_chr (Driver *drvthis, int x, int y, char ch)
{
PrivateData *p = (PrivateData *) drvthis->private_data;
// ignore out-of-range
if (y > p->height || x > p->width)
return;
y--;
x--;
if ( p->framebuf[ (y * p->width) + x] != ch) {
p->framebuf[ (y * p->width) + x] = ch;
p->line_flags[y] = 1;
}
}
///////////////////////////////////////////////////////////////////////////////
// Place a string in the framebuffer
//
MODULE_EXPORT void
lis_string (Driver *drvthis, int x, int y, char *s)
{
PrivateData *p = (PrivateData *) drvthis->private_data;
int i;
x --; // Convert 1-based coords to 0-based
y --;
for (i = 0; s[i]; i++) {
// Check for buffer overflows...
if ((y * p->width) + x + i > (p->width * p->height))
break;
if ( p->framebuf[(y*p->width) + x + i] != s[i] ) {
p->framebuf[(y*p->width) + x + i] = s[i];
p->line_flags[((y*p->width) + x + i ) / p->width ] = 1; // dirty
}
}
}
///////////////////////////////////////////////////////////////////////////////
// Set default icon into a userdef char
//
MODULE_EXPORT int
lis_icon (Driver *drvthis, int x, int y, int icon)
{
char ch;
switch (icon) {
case ICON_BLOCK_FILLED:
ch = 0xFF;
break;
case ICON_HEART_FILLED:
ch = 0x9D;
break;
case ICON_HEART_OPEN:
ch = 0x9C;
break;
case ICON_ARROW_UP:
ch = 0x18;
break;
case ICON_ARROW_DOWN:
ch = 0x19;
break;
case ICON_ARROW_LEFT:
ch = 0x1B;
break;
case ICON_ARROW_RIGHT:
ch = 0x1A;
break;
case ICON_CHECKBOX_OFF:
ch = 0x6F;
break;
case ICON_CHECKBOX_ON:
ch = 0xC7;
break;
case ICON_CHECKBOX_GRAY:
ch = 7;
break;
case ICON_STOP:
ch = 0x16;
break;
case ICON_PAUSE:
ch = 0xA0;
break;
case ICON_PLAY:
ch = 0x10;
break;
case ICON_PLAYR:
ch = 0x11;
break;
case ICON_FF:
ch = 0xBB;
break;
case ICON_FR:
ch = 0xBC;
break;
case ICON_NEXT:
ch = 0x1D;
break;
case ICON_PREV:
ch = 0x1C;
break;
case ICON_REC:
ch = 0xAE;
break;
default:
return -1; /* Let the core do other icons */
lis_chr(drvthis, x, y, ch);
}
return 0;
}
///////////////////////////////////////////////////////////////////////////////
// Draw a horizontal bar
//
// options ignored
// truncates to fit display if needed
MODULE_EXPORT void
lis_hbar(Driver *drvthis, int x, int y, int len, int promille, int options)
{
PrivateData *p = (PrivateData *) drvthis->private_data;
char buf[p->width+1];
int per_pel;
char *bp;
if (! p->cc_flag)
lis_load_custom_chars(drvthis);
if (x + len > p->width)
len = p->width - x;
if (len < 1 || promille < 0 || promille > 1000 )
return;
// blank area for bar
memset(buf, ' ', len);
if( promille == 0)
return;
per_pel = 1000 / (len * CELLWIDTH);
bp = buf;
while(promille > per_pel) {
if( promille >= per_pel * CELLWIDTH) {
*bp = 0x05; // full width
promille -= CELLWIDTH*per_pel;
} else {
*bp = (promille / per_pel);
promille = 0;
}
bp++;
}
*bp = 0x00;
lis_string(drvthis, x, y, buf);
}
#if 0
void
lis_test(Driver *drvthis)
{
int x, y, i;
x = 0;
y = 1;
lis_clear(drvthis);
for (i = 0; i < 1001; i++) {
lis_hbar(drvthis, 1, 1, 20, i, 0);
lis_flush(drvthis);
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink