/* $Id$
* $URL$
*
* plugin for APM (battery status)
*
* Copyright (C) 2003 Michael Reinelt <michael@reinelt.co.at>
* Copyright (C) 2004 The LCD4Linux Team <lcd4linux-devel@users.sourceforge.net>
*
* based on the old 'battery.c' which is
* Copyright (C) 2001 Leopold T�tsch <lt@toetsch.at>
*
* 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 functions:
*
* int plugin_init_apm (void)
* adds apm() function
*
*/
#include "config.h"
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <asm/types.h>
#include "debug.h"
#include "plugin.h"
#include "hash.h"
static int fd = -2;
static HASH APM;
/* from /usr/src/linux/arch/i386/kernel/apm.c:
*
* Arguments, with symbols from linux/apm_bios.h. Information is
* from the Get Power Status (0x0a) call unless otherwise noted.
*
* 0) Linux driver version (this will change if format changes)
* 1) APM BIOS Version. Usually 1.0, 1.1 or 1.2.
* 2) APM flags from APM Installation Check (0x00):
* bit 0: APM_16_BIT_SUPPORT
* bit 1: APM_32_BIT_SUPPORT
* bit 2: APM_IDLE_SLOWS_CLOCK
* bit 3: APM_BIOS_DISABLED
* bit 4: APM_BIOS_DISENGAGED
* 3) AC line status
* 0x00: Off-line
* 0x01: On-line
* 0x02: On backup power (BIOS >= 1.1 only)
* 0xff: Unknown
* 4) Battery status
* 0x00: High
* 0x01: Low
* 0x02: Critical
* 0x03: Charging
* 0x04: Selected battery not present (BIOS >= 1.2 only)
* 0xff: Unknown
* 5) Battery flag
* bit 0: High
* bit 1: Low
* bit 2: Critical
* bit 3: Charging
* bit 7: No system battery
* 0xff: Unknown
* 6) Remaining battery life (percentage of charge):
* 0-100: valid
* -1: Unknown
* 7) Remaining battery life (time units):
* Number of remaining minutes or seconds
* -1: Unknown
* 8) min = minutes; sec = seconds
*
* p+= sprintf(p, "%s %d.%d 0x%02x 0x%02x 0x%02x 0x%02x %d%% %d %s\n",
* driver_version,
* (apm_info.bios.version >> 8) & 0xff,
* apm_info.bios.version & 0xff,
* apm_info.bios.flags,
* ac_line_status,
* battery_status,
* battery_flag,
* percentage,
* time_units,
* units);
*/
static int parse_proc_apm(void)
{
char *key[] = { "driver_version",
"bios_version",
"bios_flags",
"line_status",
"battery_status",
"battery_flag",
"battery_percent",
"battery_remaining",
"time_units"
};
char buffer[128], *beg, *end;
int age, i;
/* reread every 10 msec only */
age = hash_age(&APM, NULL);
if (age > 0 && age <= 10)
return 0;
if (fd == -2) {
fd = open("/proc/apm", O_RDONLY | O_NDELAY);
if (fd == -1) {
error("open(/proc/apm) failed: %s", strerror(errno));
return -1;
}pre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long *//* $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("generic");
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,
};
