404 lines
12 KiB
C
404 lines
12 KiB
C
/* This is some sort of LCD display found on various cabinets. It is driven
|
|
directly by amdaemon, and it has something to do with displaying the status
|
|
of electronic payments.
|
|
|
|
Part number in schematics is "VFD GP1232A02A FUTABA".
|
|
|
|
Credits:
|
|
|
|
Haruka
|
|
*/
|
|
|
|
#include <windows.h>
|
|
|
|
#include <assert.h>
|
|
#include <stdint.h>
|
|
|
|
#include "board/config.h"
|
|
#include "board/vfd.h"
|
|
#include "board/vfd-cmd.h"
|
|
|
|
#include "hook/iohook.h"
|
|
|
|
#include "hooklib/uart.h"
|
|
|
|
#include "util/dprintf.h"
|
|
#include "util/dump.h"
|
|
|
|
#define SUPER_VERBOSE 0
|
|
|
|
static HRESULT vfd_handle_irp(struct irp *irp);
|
|
|
|
static struct uart vfd_uart;
|
|
static uint8_t vfd_written[4096];
|
|
static uint8_t vfd_readable[4096];
|
|
|
|
static int encoding = VFD_ENC_SHIFT_JIS;
|
|
|
|
HRESULT vfd_handle_get_version(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
|
|
HRESULT vfd_handle_reset(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
|
|
HRESULT vfd_handle_clear_screen(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
|
|
HRESULT vfd_handle_set_brightness(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
|
|
HRESULT vfd_handle_set_screen_on(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
|
|
HRESULT vfd_handle_set_h_scroll(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
|
|
HRESULT vfd_handle_draw_image(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
|
|
HRESULT vfd_handle_set_cursor(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
|
|
HRESULT vfd_handle_set_encoding(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
|
|
HRESULT vfd_handle_set_text_wnd(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
|
|
HRESULT vfd_handle_set_text_speed(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
|
|
HRESULT vfd_handle_write_text(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
|
|
HRESULT vfd_handle_enable_scroll(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
|
|
HRESULT vfd_handle_disable_scroll(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
|
|
HRESULT vfd_handle_rotate(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
|
|
HRESULT vfd_handle_create_char(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
|
|
HRESULT vfd_handle_create_char2(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart);
|
|
|
|
static bool utf_enabled;
|
|
|
|
HRESULT vfd_hook_init(struct vfd_config *cfg, int default_port)
|
|
{
|
|
if (!cfg->enable){
|
|
return S_FALSE;
|
|
}
|
|
|
|
utf_enabled = cfg->utf_conversion;
|
|
|
|
int port = cfg->port;
|
|
if (port == 0){
|
|
port = default_port;
|
|
}
|
|
|
|
dprintf("VFD: enabling (port=%d)\n", port);
|
|
uart_init(&vfd_uart, port);
|
|
vfd_uart.written.bytes = vfd_written;
|
|
vfd_uart.written.nbytes = sizeof(vfd_written);
|
|
vfd_uart.readable.bytes = vfd_readable;
|
|
vfd_uart.readable.nbytes = sizeof(vfd_readable);
|
|
|
|
return iohook_push_handler(vfd_handle_irp);
|
|
}
|
|
|
|
|
|
const char* get_encoding_name(int b){
|
|
switch (b){
|
|
case 0: return "gb2312";
|
|
case 1: return "big5";
|
|
case 2: return "shift-jis";
|
|
case 3: return "ks_c_5601-1987";
|
|
default: return "unknown";
|
|
}
|
|
}
|
|
|
|
void print_vfd_text(const char* str, int len){
|
|
|
|
if (utf_enabled){
|
|
|
|
wchar_t encoded[1024];
|
|
memset(encoded, 0, 1024 * sizeof(wchar_t));
|
|
|
|
int codepage = 0;
|
|
if (encoding == VFD_ENC_GB2312){
|
|
codepage = 936;
|
|
} else if (encoding == VFD_ENC_BIG5){
|
|
codepage = 950;
|
|
} else if (encoding == VFD_ENC_SHIFT_JIS){
|
|
codepage = 932;
|
|
} else if (encoding == VFD_ENC_KSC5601) {
|
|
codepage = 949;
|
|
}
|
|
|
|
if (!MultiByteToWideChar(codepage, MB_USEGLYPHCHARS, str, len, encoded, 1024)){
|
|
dprintf("VFD: Text conversion failed: %ld", GetLastError());
|
|
return;
|
|
}
|
|
|
|
dprintf("VFD: Text: %ls\n", encoded);
|
|
} else {
|
|
|
|
dprintf("VFD: Text: %s\n", str);
|
|
|
|
}
|
|
}
|
|
|
|
static HRESULT vfd_handle_irp(struct irp *irp)
|
|
{
|
|
HRESULT hr;
|
|
|
|
assert(irp != NULL);
|
|
|
|
if (!uart_match_irp(&vfd_uart, irp)) {
|
|
return iohook_invoke_next(irp);
|
|
}
|
|
|
|
if (irp->op == IRP_OP_OPEN){
|
|
dprintf("VFD: Open\n");
|
|
} else if (irp->op == IRP_OP_CLOSE){
|
|
dprintf("VFD: Close\n");
|
|
}
|
|
|
|
hr = uart_handle_irp(&vfd_uart, irp);
|
|
|
|
if (FAILED(hr) || irp->op != IRP_OP_WRITE) {
|
|
return hr;
|
|
}
|
|
|
|
#if SUPER_VERBOSE
|
|
dprintf("VFD TX:\n");
|
|
dump_iobuf(&vfd_uart.written);
|
|
#endif
|
|
|
|
struct const_iobuf reader;
|
|
iobuf_flip(&reader, &vfd_uart.written);
|
|
|
|
struct iobuf* writer = &vfd_uart.readable;
|
|
for (; reader.pos < reader.nbytes ; ){
|
|
|
|
if (vfd_frame_sync(&reader)) {
|
|
|
|
reader.pos++; // get the sync byte out of the way
|
|
|
|
uint8_t cmd;
|
|
iobuf_read_8(&reader, &cmd);
|
|
|
|
if (cmd == VFD_CMD_GET_VERSION) {
|
|
hr = vfd_handle_get_version(&reader, writer, &vfd_uart);
|
|
} else if (cmd == VFD_CMD_RESET) {
|
|
hr = vfd_handle_reset(&reader, writer, &vfd_uart);
|
|
} else if (cmd == VFD_CMD_CLEAR_SCREEN) {
|
|
hr = vfd_handle_clear_screen(&reader, writer, &vfd_uart);
|
|
} else if (cmd == VFD_CMD_SET_BRIGHTNESS) {
|
|
hr = vfd_handle_set_brightness(&reader, writer, &vfd_uart);
|
|
} else if (cmd == VFD_CMD_SET_SCREEN_ON) {
|
|
hr = vfd_handle_set_screen_on(&reader, writer, &vfd_uart);
|
|
} else if (cmd == VFD_CMD_SET_H_SCROLL) {
|
|
hr = vfd_handle_set_h_scroll(&reader, writer, &vfd_uart);
|
|
} else if (cmd == VFD_CMD_DRAW_IMAGE) {
|
|
hr = vfd_handle_draw_image(&reader, writer, &vfd_uart);
|
|
} else if (cmd == VFD_CMD_SET_CURSOR) {
|
|
hr = vfd_handle_set_cursor(&reader, writer, &vfd_uart);
|
|
} else if (cmd == VFD_CMD_SET_ENCODING) {
|
|
hr = vfd_handle_set_encoding(&reader, writer, &vfd_uart);
|
|
} else if (cmd == VFD_CMD_SET_TEXT_WND) {
|
|
hr = vfd_handle_set_text_wnd(&reader, writer, &vfd_uart);
|
|
} else if (cmd == VFD_CMD_SET_TEXT_SPEED) {
|
|
hr = vfd_handle_set_text_speed(&reader, writer, &vfd_uart);
|
|
} else if (cmd == VFD_CMD_WRITE_TEXT) {
|
|
hr = vfd_handle_write_text(&reader, writer, &vfd_uart);
|
|
} else if (cmd == VFD_CMD_ENABLE_SCROLL) {
|
|
hr = vfd_handle_enable_scroll(&reader, writer, &vfd_uart);
|
|
} else if (cmd == VFD_CMD_DISABLE_SCROLL) {
|
|
hr = vfd_handle_disable_scroll(&reader, writer, &vfd_uart);
|
|
} else if (cmd == VFD_CMD_ROTATE) {
|
|
hr = vfd_handle_rotate(&reader, writer, &vfd_uart);
|
|
} else if (cmd == VFD_CMD_CREATE_CHAR) {
|
|
hr = vfd_handle_create_char(&reader, writer, &vfd_uart);
|
|
} else if (cmd == VFD_CMD_CREATE_CHAR2) {
|
|
hr = vfd_handle_create_char2(&reader, writer, &vfd_uart);
|
|
} else {
|
|
dprintf("VFD: Unknown command 0x%x\n", cmd);
|
|
dump_const_iobuf(&reader);
|
|
hr = S_FALSE;
|
|
}
|
|
} else {
|
|
|
|
// if no sync byte is sent, we are just getting plain text...
|
|
|
|
if (reader.pos < reader.nbytes){
|
|
int len = 0;
|
|
|
|
// read chars until we hit a new sync byte or the data ends
|
|
while (reader.pos + len + 1 < reader.nbytes && reader.bytes[reader.pos + len] != VFD_SYNC_BYTE && reader.bytes[reader.pos + len] != VFD_SYNC_BYTE2){
|
|
len++;
|
|
}
|
|
|
|
char* str = malloc(len);
|
|
memset(str, 0, len);
|
|
iobuf_read(&reader, str, len);
|
|
print_vfd_text(str, len);
|
|
free(str);
|
|
|
|
reader.pos += len;
|
|
}
|
|
|
|
}
|
|
|
|
if (!SUCCEEDED(hr)){
|
|
return hr;
|
|
}
|
|
|
|
}
|
|
|
|
vfd_uart.written.pos = 0;
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT vfd_handle_get_version(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
|
|
dprintf("VFD: Get Version\n");
|
|
|
|
struct vfd_resp_board_info resp;
|
|
|
|
memset(&resp, 0, sizeof(resp));
|
|
resp.unk1 = 2;
|
|
strcpy(resp.version, "01.20");
|
|
resp.unk2 = 1;
|
|
|
|
return vfd_frame_encode(writer, &resp, sizeof(resp));
|
|
}
|
|
HRESULT vfd_handle_reset(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
|
|
dprintf("VFD: Reset\n");
|
|
|
|
encoding = VFD_ENC_SHIFT_JIS;
|
|
|
|
return S_FALSE;
|
|
}
|
|
HRESULT vfd_handle_clear_screen(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
|
|
dprintf("VFD: Clear Screen\n");
|
|
|
|
return S_FALSE;
|
|
}
|
|
HRESULT vfd_handle_set_brightness(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
|
|
uint8_t b;
|
|
iobuf_read_8(reader, &b);
|
|
|
|
if (b > 4){
|
|
dprintf("VFD: Brightness, invalid argument\n");
|
|
return E_FAIL;
|
|
}
|
|
|
|
dprintf("VFD: Brightness, %d\n", b);
|
|
|
|
return S_FALSE;
|
|
}
|
|
HRESULT vfd_handle_set_screen_on(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
|
|
uint8_t b;
|
|
iobuf_read_8(reader, &b);
|
|
|
|
if (b > 1){
|
|
dprintf("VFD: Screen Power, invalid argument\n");
|
|
return E_FAIL;
|
|
}
|
|
|
|
dprintf("VFD: Screen Power, %d\n", b);
|
|
return S_FALSE;
|
|
}
|
|
HRESULT vfd_handle_set_h_scroll(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
|
|
uint8_t x;
|
|
iobuf_read_8(reader, &x);
|
|
|
|
dprintf("VFD: Horizontal Scroll, X=%d\n", x);
|
|
return S_FALSE;
|
|
}
|
|
HRESULT vfd_handle_draw_image(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
|
|
int w, h;
|
|
uint16_t x0, x1;
|
|
uint8_t y0, y1;
|
|
uint8_t image[2048];
|
|
|
|
iobuf_read_be16(reader, &x0);
|
|
iobuf_read_8(reader, &y0);
|
|
iobuf_read_be16(reader, &x1);
|
|
iobuf_read_8(reader, &y1);
|
|
w = x1 - x0;
|
|
h = y1 - y0;
|
|
iobuf_read(reader, image, w*h);
|
|
|
|
dprintf("VFD: Draw image, %dx%d\n", w, h);
|
|
return S_FALSE;
|
|
}
|
|
|
|
HRESULT vfd_handle_set_cursor(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
|
|
uint16_t x;
|
|
uint8_t y;
|
|
|
|
iobuf_read_be16(reader, &x);
|
|
iobuf_read_8(reader, &y);
|
|
|
|
dprintf("VFD: Set Cursor, x=%d,y=%d\n", x, y);
|
|
|
|
return S_FALSE;
|
|
}
|
|
|
|
HRESULT vfd_handle_set_encoding(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
|
|
uint8_t b;
|
|
iobuf_read_8(reader, &b);
|
|
|
|
dprintf("VFD: Set Encoding, %d (%s)\n", b, get_encoding_name(b));
|
|
|
|
if (b < 0 || b > VFD_ENC_MAX){
|
|
dprintf("Invalid encoding specified\n");
|
|
return E_FAIL;
|
|
}
|
|
|
|
encoding = b;
|
|
|
|
return S_FALSE;
|
|
}
|
|
HRESULT vfd_handle_set_text_wnd(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
|
|
uint16_t x0, x1;
|
|
uint8_t y0, y1;
|
|
|
|
iobuf_read_be16(reader, &x0);
|
|
iobuf_read_8(reader, &y0);
|
|
iobuf_read_be16(reader, &x1);
|
|
iobuf_read_8(reader, &y1);
|
|
|
|
dprintf("VFD: Set Text Window, p0:%d,%d, p1:%d,%d\n", x0, y0, x1, y1);
|
|
return S_FALSE;
|
|
}
|
|
HRESULT vfd_handle_set_text_speed(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
|
|
uint8_t b;
|
|
iobuf_read_8(reader, &b);
|
|
|
|
dprintf("VFD: Set Text Speed, %d\n", b);
|
|
return S_FALSE;
|
|
}
|
|
HRESULT vfd_handle_write_text(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
|
|
uint8_t len;
|
|
iobuf_read_8(reader, &len);
|
|
|
|
char* str = malloc(len);
|
|
iobuf_read(reader, str, len);
|
|
|
|
print_vfd_text(str, len);
|
|
free(str);
|
|
|
|
return S_FALSE;
|
|
}
|
|
HRESULT vfd_handle_enable_scroll(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
|
|
dprintf("VFD: Enable Scrolling\n");
|
|
return S_FALSE;
|
|
}
|
|
HRESULT vfd_handle_disable_scroll(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
|
|
dprintf("VFD: Disable Scrolling\n");
|
|
return S_FALSE;
|
|
}
|
|
HRESULT vfd_handle_rotate(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
|
|
uint8_t b;
|
|
iobuf_read_8(reader, &b);
|
|
|
|
dprintf("VFD: Rotate, %d\n", b);
|
|
return S_FALSE;
|
|
}
|
|
HRESULT vfd_handle_create_char(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
|
|
uint8_t b;
|
|
iobuf_read_8(reader, &b);
|
|
char buf[32];
|
|
|
|
iobuf_read(reader, buf, 32);
|
|
|
|
dprintf("VFD: Create character, %d\n", b);
|
|
return S_FALSE;
|
|
}
|
|
HRESULT vfd_handle_create_char2(struct const_iobuf* reader, struct iobuf* writer, struct uart* vfd_uart){
|
|
uint8_t b, b2;
|
|
iobuf_read_8(reader, &b);
|
|
iobuf_read_8(reader, &b2);
|
|
char buf[16];
|
|
|
|
iobuf_read(reader, buf, 16);
|
|
|
|
dprintf("VFD: Create character, %d, %d\n", b, b2);
|
|
return S_FALSE;
|
|
}
|