lcd4linux.git - lcd4linux

diff options

Diffstat (limited to 'config.sub')

0 files changed, 0 insertions, 0 deletions

/* $Id$ * $URL$ * * driver for USB2LCD display interface * see http://www.harbaum.org/till/lcd2usb for schematics * * Copyright 2005 Till Harbaum <till@harbaum.org> * Copyright 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. * */ /* * * exported fuctions: * * struct DRIVER drv_LCD2USB * */ #include "config.h" #include <stdlib.h> #include <stdio.h> #include <string.h> #include <errno.h> #include <unistd.h> #include <termios.h> #include <fcntl.h> #include <ctype.h> #include <sys/ioctl.h> #include <sys/time.h> #include <usb.h> #include "debug.h" #include "cfg.h" #include "timer.h" #include "qprintf.h" #include "plugin.h" #include "widget.h" #include "widget_text.h" #include "widget_icon.h" #include "widget_bar.h" #include "widget_keypad.h" #include "drv.h" #include "drv_generic_text.h" #include "drv_generic_keypad.h" /* vid/pid donated by FTDI */ #define LCD_USB_VENDOR 0x0403 #define LCD_USB_DEVICE 0xC630 /* number of buttons on display */ #define L2U_BUTTONS (2) #define LCD_ECHO (0<<5) #define LCD_CMD (1<<5) #define LCD_DATA (2<<5) #define LCD_SET (3<<5) #define LCD_GET (4<<5) /* target is a bit map for CMD/DATA */ #define LCD_CTRL_0 (1<<3) #define LCD_CTRL_1 (1<<4) #define LCD_BOTH (LCD_CTRL_0 | LCD_CTRL_1) /* target is value to set */ #define LCD_SET_CONTRAST (LCD_SET | (0<<3)) #define LCD_SET_BRIGHTNESS (LCD_SET | (1<<3)) #define LCD_SET_RESERVED0 (LCD_SET | (2<<3)) #define LCD_SET_RESERVED1 (LCD_SET | (3<<3)) /* target is value to get */ #define LCD_GET_FWVER (LCD_GET | (0<<3)) #define LCD_GET_BUTTONS (LCD_GET | (1<<3)) #define LCD_GET_CTRL (LCD_GET | (2<<3)) #define LCD_GET_RESERVED1 (LCD_GET | (3<<3)) static char Name[] = "LCD2USB"; static char *device_id = NULL, *bus_id = NULL; static usb_dev_handle *lcd; static int controllers = 0; extern int got_signal; /****************************************/ /*** hardware dependant functions ***/ /****************************************/ static int drv_L2U_open(char *bus_id, char *device_id) { struct usb_bus *busses, *bus; struct usb_device *dev; lcd = NULL; info("%s: scanning USB for LCD2USB interface ...", Name); if (bus_id != NULL) info("%s: scanning for bus id: %s", Name, bus_id); if (device_id != NULL) info("%s: scanning for device id: %s", Name, device_id); usb_set_debug(0); usb_init(); usb_find_busses(); usb_find_devices(); busses = usb_get_busses(); for (bus = busses; bus; bus = bus->next) { /* search this bus if no bus id was given or if this is the given bus id */ if (!bus_id || (bus_id && !strcasecmp(bus->dirname, bus_id))) { for (dev = bus->devices; dev; dev = dev->next) { /* search this device if no device id was given or if this is the given device id */ if (!device_id || (device_id && !strcasecmp(dev->filename, device_id))) { if ((dev->descriptor.idVendor == LCD_USB_VENDOR) && (dev->descriptor.idProduct == LCD_USB_DEVICE)) { info("%s: found LCD2USB interface on bus %s device %s", Name, bus->dirname, dev->filename); lcd = usb_open(dev); if (usb_claim_interface(lcd, 0) < 0) { error("%s: usb_claim_interface() failed!", Name); return -1; } return 0; } } } } } return -1; } static int drv_L2U_close(void) { usb_release_interface(lcd, 0); usb_close(lcd); return 0; } static int drv_L2U_send(int request, int value, int index) { if (usb_control_msg(lcd, USB_TYPE_VENDOR, request, value, index, NULL, 0, 1000) < 0) { error("%s: USB request failed! Trying to reconnect device.", Name); usb_release_interface(lcd, 0); usb_close(lcd); /* try to close and reopen connection */ if (drv_L2U_open(bus_id, device_id) < 0) { error("%s: could not re-detect LCD2USB USB LCD", Name); got_signal = -1; return -1; } /* and try to re-send command */ if (usb_control_msg(lcd, USB_TYPE_VENDOR, request, value, index, NULL, 0, 1000) < 0) { error("%s: retried USB request failed, aborting!", Name); got_signal = -1; return -1; } info("%s: Device successfully reconnected.", Name); } return 0; } /* send a number of 16 bit words to the lcd2usb interface */ /* and verify that they are correctly returned by the echo */ /* command. This may be used to check the reliability of */ /* the usb interfacing */ #define ECHO_NUM 100 int drv_L2U_echo(void) { int i, nBytes, errors = 0; unsigned short val, ret; for (i = 0; i < ECHO_NUM; i++) { val = rand() & 0xffff; nBytes = usb_control_msg(lcd, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, LCD_ECHO, val, 0, (char *) &ret, sizeof(ret), 1000); if (nBytes < 0) { error("%s: USB request failed!", Name); return -1; } if (val != ret) errors++; } if (errors) { error("%s: ERROR, %d out of %d echo transfers failed!", Name, errors, ECHO_NUM); return -1; } else info("%s: echo test successful", Name); return 0; } /* get a value from the lcd2usb interface */ static int drv_L2U_get(unsigned char cmd) { unsigned char buffer[2]; int nBytes; /* send control request and accept return value */ nBytes = usb_control_msg(lcd, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, cmd, 0, 0, (char *) buffer, sizeof(buffer), 1000); if (nBytes < 0) { error("%s: USB request failed!", Name); return -1; } return buffer[0] + 256 * buffer[1]; } /* get lcd2usb interface firmware version */ static void drv_L2U_get_version(void) { int ver = drv_L2U_get(LCD_GET_FWVER); if (ver != -1) info("%s: firmware version %d.%02d", Name, ver & 0xff, ver >> 8); else error("%s: unable to read firmware version", Name); } /* get the bit mask of installed LCD controllers (0 = no */ /* lcd found, 1 = single controller display, 3 = dual */ /* controller display */ static void drv_L2U_get_controllers(void) { controllers = drv_L2U_get(LCD_GET_CTRL); if (controllers != -1) { if (controllers) info("%s: installed controllers: %s%s", Name, (controllers & 1) ? "CTRL0" : "", (controllers & 2) ? " CTRL1" : ""); else error("%s: no controllers found", Name); } else { error("%s: unable to read installed controllers", Name); controllers = 0; /* don't access any controllers */ } /* convert into controller map matching our protocol */ controllers = ((controllers & 1) ? LCD_CTRL_0 : 0) | ((controllers & 2) ? LCD_CTRL_1 : 0); } /* get state of the two optional buttons */ static unsigned long drv_L2U_get_buttons(void) { int buttons = drv_L2U_get(LCD_GET_BUTTONS); if (buttons == -1) { error("%s: unable to read button state", Name); buttons = 0; } return buttons; } /* to increase performance, a little buffer is being used to */ /* collect command bytes of the same type before transmitting them */ #define BUFFER_MAX_CMD 4 /* current protocol supports up to 4 bytes */ int buffer_current_type = -1; /* nothing in buffer yet */ int buffer_current_fill = 0; /* -"- */ unsigned char buffer[BUFFER_MAX_CMD]; /* command format: * 7 6 5 4 3 2 1 0 * C C C T T R L L * * TT = target bit map * R = reserved for future use, set to 0 * LL = number of bytes in transfer - 1 */ /* flush command queue due to buffer overflow / content */ /* change or due to explicit request */ static void drv_L2U_flush(void) { int request, value, index; /* anything to flush? ignore request if not */ if (buffer_current_type == -1) return; /* build request byte */ request = buffer_current_type | (buffer_current_fill - 1); /* fill value and index with buffer contents. endianess should IMHO not */ /* be a problem, since usb_control_msg() will handle this. */ value = buffer[0] | (buffer[1] << 8); index = buffer[2] | (buffer[3] << 8); if (controllers) { /* send current buffer contents */ drv_L2U_send(request, value, index); } /* buffer is now free again */ buffer_current_type = -1; buffer_current_fill = 0; } /* enqueue a command into the buffer */ static void drv_L2U_enqueue(int command_type, int value) { if ((buffer_current_type >= 0) && (buffer_current_type != command_type)) drv_L2U_flush(); /* add new item to buffer */ buffer_current_type = command_type; buffer[buffer_current_fill++] = value; /* flush buffer if it's full */ if (buffer_current_fill == BUFFER_MAX_CMD) drv_L2U_flush(); } static void drv_L2U_command(const unsigned char ctrl, const unsigned char cmd) { drv_L2U_enqueue(LCD_CMD | (ctrl & controllers), cmd); } static void drv_L2U_clear(void) { drv_L2U_command(LCD_BOTH, 0x01); /* clear display */ drv_L2U_command(LCD_BOTH, 0x03); /* return home */ } static void drv_L2U_write(int row, const int col, const char *data, int len) { int pos, ctrl = LCD_CTRL_0; /* displays with more two rows and 20 columns have a logical width */ /* of 40 chars and use more than one controller */ if ((DROWS > 2) && (DCOLS > 20) && (row > 1)) { /* use second controller */ row -= 2; ctrl = LCD_CTRL_1; } /* 16x4 Displays use a slightly different layout */ if (DCOLS == 16 && DROWS == 4) { pos = (row % 2) * 64 + (row / 2) * 16 + col; } else { pos = (row % 2) * 64 + (row / 2) * 20 + col; } drv_L2U_command(ctrl, 0x80 | pos); while (len--) { drv_L2U_enqueue(LCD_DATA | (ctrl & controllers), *data++); } drv_L2U_flush(); } static void drv_L2U_defchar(const int ascii, const unsigned char *matrix) { int i; drv_L2U_command(LCD_BOTH, 0x40 | 8 * ascii); for (i = 0; i < 8; i++) { drv_L2U_enqueue(LCD_DATA | (LCD_BOTH & controllers), *matrix++ & 0x1f); } drv_L2U_flush(); } static int drv_L2U_contrast(int contrast) { if (contrast < 0) contrast = 0; if (contrast > 255) contrast = 255; drv_L2U_send(LCD_SET_CONTRAST, contrast, 0); return contrast; } static int drv_L2U_brightness(int brightness) { if (brightness < 0) brightness = 0; if (brightness > 255) brightness = 255; drv_L2U_send(LCD_SET_BRIGHTNESS, brightness, 0); return brightness; } static void drv_L2U_timer(void __attribute__ ((unused)) * notused) { static unsigned long last_but = 0; unsigned long new_but = drv_L2U_get_buttons(); int i; /* check if button state changed */ if (new_but ^ last_but) { /* send single keypad events for all changed buttons */ for (i = 0; i < L2U_BUTTONS; i++) if ((new_but & (1 << i)) ^ (last_but & (1 << i))) drv_generic_keypad_press(((new_but & (1 << i)) ? 0x80 : 0) | i); } last_but = new_but; } static int drv_L2U_keypad(const int num) { int val = 0; /* check for key press event */ if (num & 0x80) val = WIDGET_KEY_PRESSED; else val = WIDGET_KEY_RELEASED; if ((num & 0x7f) == 0) val += WIDGET_KEY_UP; if ((num & 0x7f) == 1) val += WIDGET_KEY_DOWN; return val; } static int drv_L2U_start(const char *section, const int quiet) { int contrast, brightness; int rows = -1, cols = -1; char *s; s = cfg_get(section, "Size", NULL); if (s == NULL || *s == '\0') { error("%s: no '%s.Size' entry from %s", Name, section, cfg_source()); return -1; } if (sscanf(s, "%dx%d", &cols, &rows) != 2 || rows < 1 || cols < 1) { error("%s: bad %s.Size '%s' from %s", Name, section, s, cfg_source()); free(s); return -1; } DROWS = rows; DCOLS = cols; /* bus id and device id are strings and not just intergers, since */ /* the windows port of libusb treats them as strings. And this way */ /* we keep windows compatibility ... just in case ... */ bus_id = cfg_get(section, "Bus", NULL); device_id = cfg_get(section, "Device", NULL); if (drv_L2U_open(bus_id, device_id) < 0) { error("%s: could not find a LCD2USB USB LCD", Name); return -1; } /* test interface reliability */ drv_L2U_echo(); /* get some infos from the interface */ drv_L2U_get_version(); drv_L2U_get_controllers(); if (!controllers) return -1; /* regularly request key state */ /* Fixme: make 100msec configurable */ timer_add(drv_L2U_timer, NULL, 100, 0); if (cfg_number(section, "Contrast", 0, 0, 255, &contrast) > 0) { drv_L2U_contrast(contrast); } if (cfg_number(section, "Brightness", 0, 0, 255, &brightness) > 0) { drv_L2U_brightness(brightness); } drv_L2U_clear(); /* clear display */ if (!quiet) { char buffer[40]; qprintf(buffer, sizeof(buffer), "%s %dx%d", Name, DCOLS, DROWS); if (drv_generic_text_greet(buffer, "www.harbaum.org/till")) { sleep(3); drv_L2U_clear(); } } return 0; } /****************************************/ /*** plugins ***/ /****************************************/ static void plugin_contrast(RESULT * result, RESULT * arg1) { double contrast; contrast = drv_L2U_contrast(R2N(arg1)); SetResult(&result, R_NUMBER, &contrast); } static void plugin_brightness(RESULT * result, RESULT * arg1) { double brightness; brightness = drv_L2U_brightness(R2N(arg1)); SetResult(&result, R_NUMBER, &brightness); } /****************************************/ /*** widget callbacks ***/ /****************************************/ /* using drv_generic_text_draw(W) */ /* using drv_generic_text_icon_draw(W) */ /* using drv_generic_text_bar_draw(W) */ /****************************************/ /*** exported functions ***/ /****************************************/ /* list models */ int drv_L2U_list(void) { printf("USB2LCD display interface"); return 0; } /* initialize driver & display */ int drv_L2U_init(const char *section, const int quiet) { WIDGET_CLASS wc; int asc255bug; int ret; info("%s: %s", Name, "$Rev$"); /* display preferences */ XRES = 5; /* pixel width of one char */ YRES = 8; /* pixel height of one char */ CHARS = 8; /* number of user-defineable characters */ CHAR0 = 0; /* ASCII of first user-defineable char */ GOTO_COST = 2; /* number of bytes a goto command requires */ /* real worker functions */ drv_generic_text_real_write = drv_L2U_write; drv_generic_text_real_defchar = drv_L2U_defchar; drv_generic_keypad_real_press = drv_L2U_keypad; /* start display */ if ((ret = drv_L2U_start(section, quiet)) != 0) return ret; /* initialize generic text driver */ if ((ret = drv_generic_text_init(section, Name)) != 0) return ret; /* initialize generic icon driver */ if ((ret = drv_generic_text_icon_init()) != 0) return ret; /* initialize generic bar driver */ if ((ret = drv_generic_text_bar_init(0)) != 0) return ret; /* add fixed chars to the bar driver */ /* most displays have a full block on ascii 255, but some have kind of */ /* an 'inverted P'. If you specify 'asc255bug 1 in the config, this */ /* char will not be used, but rendered by the bar driver */ cfg_number(section, "asc255bug", 0, 0, 1, &asc255bug); drv_generic_text_bar_add_segment(0, 0, 255, 32); /* ASCII 32 = blank */ if (!asc255bug) drv_generic_text_bar_add_segment(255, 255, 255, 255); /* ASCII 255 = block */ /* initialize generic key pad driver */ if ((ret = drv_generic_keypad_init(section, Name)) != 0) return ret; /* register text widget */ wc = Widget_Text; wc.draw = drv_generic_text_draw; widget_register(&wc); /* register icon widget */ wc = Widget_Icon; wc.draw = drv_generic_text_icon_draw; widget_register(&wc); /* register bar widget */ wc = Widget_Bar; wc.draw = drv_generic_text_bar_draw; widget_register(&wc); /* register plugins */ AddFunction("LCD::contrast", 1, plugin_contrast); AddFunction("LCD::brightness", 1, plugin_brightness); return 0; } /* close driver & display */ int drv_L2U_quit(const int quiet) { info("%s: shutting down.", Name); drv_generic_text_quit(); drv_generic_keypad_quit(); /* clear display */ drv_L2U_clear(); /* say goodbye... */ if (!quiet) { drv_generic_text_greet("That's all, folks!", NULL); } debug("closing USB connection"); drv_L2U_close(); return (0); } DRIVER drv_LCD2USB = { .name = Name, .list = drv_L2U_list, .init = drv_L2U_init, .quit = drv_L2U_quit, };


context:
space:
mode: