742 lines
23 KiB
C
742 lines
23 KiB
C
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include <86box/86box.h>
|
|
#include <86box/device.h>
|
|
#include <86box/timer.h>
|
|
#include <86box/mouse.h>
|
|
#include <86box/serial.h>
|
|
#include <86box/plat.h>
|
|
#include <86box/fifo8.h>
|
|
|
|
#define FLAG_3BTN 0x20 /* enable 3-button mode */
|
|
|
|
enum wacom_modes {
|
|
WACOM_MODE_SUPPRESSED = 0,
|
|
WACOM_MODE_POINT = 1,
|
|
WACOM_MODE_STREAM = 2,
|
|
WACOM_MODE_SWITCH = 3,
|
|
};
|
|
|
|
enum wacom_handshake_modes {
|
|
WACOM_HANDSHAKE_NONE = 0,
|
|
WACOM_HANDSHAKE_CTS = 1,
|
|
WACOM_HANDSHAKE_DTS = 2,
|
|
WACOM_HANDSHAKE_BOTH = 3,
|
|
};
|
|
|
|
enum wacom_cmd_set {
|
|
WACOM_CMDSET_BITPAD = 0,
|
|
WACOM_CMDSET_MM1201 = 1,
|
|
WACOM_CMDSET_IIS = 2,
|
|
WACOM_CMDSET_IV = 3
|
|
};
|
|
|
|
enum wacom_tablet_type {
|
|
WACOM_TYPE_IISONLY = 0,
|
|
WACOM_TYPE_IV,
|
|
};
|
|
|
|
enum {
|
|
REPORT_PHASE_PREPARE,
|
|
REPORT_PHASE_TRANSMIT
|
|
};
|
|
|
|
typedef struct wacom_tablet_id {
|
|
char id[64];
|
|
int type;
|
|
} wacom_tablet_id;
|
|
|
|
static const wacom_tablet_id sd510_id = {
|
|
.id = "~#SD51C V3.2.1.01\r",
|
|
.type = WACOM_TYPE_IISONLY
|
|
};
|
|
|
|
static const wacom_tablet_id artpad_id = {
|
|
.id = "~#KT-0405-R00 V1.1-0\r",
|
|
.type = WACOM_TYPE_IV
|
|
};
|
|
|
|
static const uint32_t wacom_resolution_values[4] = {
|
|
500,
|
|
508,
|
|
1000,
|
|
1270
|
|
};
|
|
|
|
typedef struct mouse_wacom_t {
|
|
const char *name; /* name of this device */
|
|
int8_t type; /* type of this device */
|
|
int8_t port;
|
|
uint8_t flags; /* device flags */
|
|
uint8_t but;
|
|
uint8_t status;
|
|
uint8_t bits;
|
|
uint8_t data_rec[0x200];
|
|
int abs_x;
|
|
int abs_y;
|
|
int rel_x;
|
|
int rel_y;
|
|
int oldb;
|
|
int b;
|
|
|
|
Fifo8 data;
|
|
|
|
int data_rec_pos;
|
|
int mode;
|
|
int interval;
|
|
int increment;
|
|
int suppressed_increment;
|
|
int transmission_stopped;
|
|
int reset;
|
|
int transmit_id;
|
|
int transmit_id_pending;
|
|
int pressure_mode;
|
|
int suppressed;
|
|
int measurement;
|
|
int remote_req;
|
|
|
|
uint32_t x_res;
|
|
uint32_t y_res;
|
|
const wacom_tablet_id *tablet_type;
|
|
|
|
int last_abs_x; /* Suppressed/Increment Mode. */
|
|
int last_abs_y; /* Suppressed/Increment Mode. */
|
|
union {
|
|
uint32_t settings; /* Settings DWORD */
|
|
/* We don't target any architectures except x86/x64/ARM32/ARM64.
|
|
(The ABIs for those are explicit in little-endian bit ordering) */
|
|
struct settings_bits {
|
|
uint8_t remote_mode : 1;
|
|
uint8_t bitpad_two_cursor_data : 1;
|
|
uint8_t mm961_orientation : 1;
|
|
uint8_t mm_command_set : 1;
|
|
uint8_t tilt : 1;
|
|
uint8_t multi_device : 1;
|
|
uint8_t reading_height : 1;
|
|
uint8_t pressure_sensitivity : 1;
|
|
|
|
uint8_t pnp : 1; /* Unused. */
|
|
uint8_t dummy : 1;
|
|
uint8_t terminator : 2;
|
|
uint8_t out_of_range_data : 1;
|
|
uint8_t origin_location : 1;
|
|
uint8_t resolution : 2;
|
|
|
|
uint8_t transfer_rate : 2;
|
|
uint8_t coord_sys : 1;
|
|
uint8_t output_format : 1;
|
|
uint8_t transfer_mode : 2;
|
|
uint8_t handshake : 2;
|
|
|
|
uint8_t stop_bits_conf : 1;
|
|
uint8_t data_bits_conf : 1;
|
|
uint8_t parity : 2;
|
|
uint8_t baud_rate : 2;
|
|
uint8_t cmd_set : 2;
|
|
} settings_bits;
|
|
};
|
|
|
|
double transmit_period;
|
|
double old_tsc;
|
|
double reset_tsc;
|
|
pc_timer_t report_timer;
|
|
|
|
serial_t *serial;
|
|
} mouse_wacom_t;
|
|
|
|
/* TODO: What is this needed for? */
|
|
#if 0
|
|
static unsigned int
|
|
reverse(register unsigned int x)
|
|
{
|
|
x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
|
|
x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
|
|
x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
|
|
x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
|
|
return ((x >> 16) | (x << 16));
|
|
}
|
|
#endif
|
|
|
|
static double
|
|
wacom_transmit_period(mouse_wacom_t *dev, int bps, int rps)
|
|
{
|
|
double dbps = (double) bps;
|
|
double temp = 0.0;
|
|
int word_len = dev->bits;
|
|
|
|
if (rps == -1)
|
|
temp = (double) word_len;
|
|
else {
|
|
temp = (double) rps;
|
|
temp = (9600.0 - (temp * 33.0));
|
|
temp /= rps;
|
|
}
|
|
temp = (1000000.0 / dbps) * temp;
|
|
|
|
return temp;
|
|
}
|
|
|
|
static void
|
|
wacom_process_settings_dword(mouse_wacom_t *wacom, uint32_t dword)
|
|
{
|
|
wacom->settings = dword;
|
|
|
|
wacom->mode = wacom->settings_bits.transfer_mode;
|
|
|
|
wacom->bits = 1 + 7 + wacom->settings_bits.data_bits_conf;
|
|
wacom->bits += 1 + wacom->settings_bits.stop_bits_conf;
|
|
if (wacom->settings_bits.parity == 2 && !(wacom->bits % 2)) {
|
|
wacom->bits++;
|
|
} else if (wacom->settings_bits.parity == 3 && (wacom->bits % 2)) {
|
|
wacom->bits++;
|
|
}
|
|
|
|
switch(wacom->settings_bits.baud_rate) {
|
|
case 0:
|
|
wacom->transmit_period = wacom_transmit_period(wacom, 2400, -1);
|
|
break;
|
|
|
|
case 1:
|
|
wacom->transmit_period = wacom_transmit_period(wacom, 4800, -1);
|
|
break;
|
|
|
|
case 2:
|
|
wacom->transmit_period = wacom_transmit_period(wacom, 9600, -1);
|
|
break;
|
|
|
|
case 3:
|
|
wacom->transmit_period = wacom_transmit_period(wacom, 19200, -1);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
mouse_input_mode = !wacom->settings_bits.coord_sys;
|
|
wacom->x_res = wacom->y_res = wacom_resolution_values[wacom->settings_bits.resolution];
|
|
}
|
|
|
|
static void
|
|
wacom_reset(mouse_wacom_t *wacom)
|
|
{
|
|
wacom->transmit_period = wacom_transmit_period(wacom, 9600, -1);
|
|
wacom->mode = WACOM_MODE_POINT;
|
|
wacom->transmission_stopped = 0;
|
|
wacom->interval = 0;
|
|
wacom->transmit_id = 0;
|
|
wacom->settings_bits.output_format = 1; /* ASCII */
|
|
wacom->settings_bits.cmd_set = 1;
|
|
wacom->measurement = 1;
|
|
wacom->increment = wacom->suppressed_increment = 0;
|
|
wacom->reset_tsc = tsc;
|
|
wacom->settings_bits.remote_mode = wacom->remote_req = 0;
|
|
wacom->settings_bits.out_of_range_data = 0;
|
|
|
|
mouse_input_mode = 1;
|
|
wacom_process_settings_dword(wacom, 0xA21BC800);
|
|
}
|
|
|
|
static void
|
|
wacom_reset_artpad(mouse_wacom_t *wacom)
|
|
{
|
|
wacom->transmit_period = wacom_transmit_period(wacom, 9600, -1);
|
|
wacom->mode = WACOM_MODE_SUPPRESSED;
|
|
wacom->transmission_stopped = 0;
|
|
wacom->interval = 0;
|
|
wacom->transmit_id = 0;
|
|
wacom->settings_bits.output_format = 0; /* Binary */
|
|
wacom->measurement = 1;
|
|
wacom->increment = 0;
|
|
wacom->suppressed_increment = 1;
|
|
wacom->reset_tsc = tsc;
|
|
wacom->settings_bits.remote_mode = 0;
|
|
wacom->remote_req = 0;
|
|
wacom->settings_bits.out_of_range_data = 0;
|
|
|
|
wacom_process_settings_dword(wacom, 0xE203C000);
|
|
mouse_input_mode = 1;
|
|
}
|
|
|
|
static void
|
|
wacom_callback(UNUSED(struct serial_s *serial), void *priv)
|
|
{
|
|
mouse_wacom_t *wacom = (mouse_wacom_t *) priv;
|
|
|
|
switch(wacom->settings_bits.baud_rate) {
|
|
case 0:
|
|
wacom->transmit_period = wacom_transmit_period(wacom, 2400, -1);
|
|
break;
|
|
|
|
case 1:
|
|
wacom->transmit_period = wacom_transmit_period(wacom, 4800, -1);
|
|
break;
|
|
|
|
case 2:
|
|
wacom->transmit_period = wacom_transmit_period(wacom, 9600, -1);
|
|
break;
|
|
|
|
case 3:
|
|
wacom->transmit_period = wacom_transmit_period(wacom, 19200, -1);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
timer_stop(&wacom->report_timer);
|
|
timer_on_auto(&wacom->report_timer, wacom->transmit_period);
|
|
}
|
|
|
|
static void
|
|
wacom_write(UNUSED(struct serial_s *serial), void *priv, uint8_t data)
|
|
{
|
|
mouse_wacom_t *wacom = (mouse_wacom_t *) priv;
|
|
static int special_command = 0;
|
|
|
|
if (data == '~') {
|
|
special_command = 1;
|
|
return;
|
|
}
|
|
if (special_command) {
|
|
switch (data) {
|
|
case '#':
|
|
{
|
|
wacom->transmit_id = 1;
|
|
break;
|
|
}
|
|
case 'C':
|
|
case '*':
|
|
case 'R':
|
|
{
|
|
wacom->data_rec[wacom->data_rec_pos++] = '~';
|
|
wacom->data_rec[wacom->data_rec_pos++] = data;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
special_command = 0;
|
|
return;
|
|
}
|
|
|
|
if (data == '@') {
|
|
wacom->remote_req = 1;
|
|
wacom->settings_bits.remote_mode = 1;
|
|
return;
|
|
}
|
|
if (data == '#' && wacom->tablet_type->type == WACOM_TYPE_IV) {
|
|
wacom_reset_artpad(wacom);
|
|
return;
|
|
}
|
|
if (data == '$') {
|
|
wacom_reset(wacom);
|
|
return;
|
|
}
|
|
if (data == 0x13) {
|
|
wacom->transmission_stopped = 1;
|
|
return;
|
|
}
|
|
if (data == 0x11) {
|
|
wacom->transmission_stopped = 0;
|
|
wacom->settings_bits.remote_mode = wacom->remote_req = 0;
|
|
return;
|
|
}
|
|
wacom->data_rec[wacom->data_rec_pos++] = data;
|
|
if (data == '\r' || data == '\n') {
|
|
wacom->data_rec[wacom->data_rec_pos] = 0;
|
|
wacom->data_rec_pos = 0;
|
|
|
|
if (data == '\n')
|
|
pclog("Wacom: written %s", wacom->data_rec);
|
|
else
|
|
pclog("Wacom: written %s\n", wacom->data_rec);
|
|
if (!memcmp(wacom->data_rec, "AS", 2) && wacom->settings_bits.cmd_set == WACOM_CMDSET_IIS) {
|
|
wacom->settings_bits.output_format = !(wacom->data_rec[2] == '1');
|
|
} else if (!memcmp(wacom->data_rec, "SR", 2)) {
|
|
wacom->mode = WACOM_MODE_STREAM;
|
|
} else if (!memcmp(wacom->data_rec, "IN", 2)) {
|
|
sscanf((const char *) wacom->data_rec, "IN%d", &wacom->increment);
|
|
} else if (!memcmp(wacom->data_rec, "RE", 2)) {
|
|
if (wacom->tablet_type->type == WACOM_TYPE_IV) wacom_reset_artpad(wacom);
|
|
else wacom_reset(wacom);
|
|
} else if (!memcmp(wacom->data_rec, "IT", 2)) {
|
|
sscanf((const char *) wacom->data_rec, "IT%d", &wacom->interval);
|
|
} else if (!memcmp(wacom->data_rec, "DE", 2) && wacom->settings_bits.cmd_set == WACOM_CMDSET_IIS) {
|
|
sscanf((const char *) wacom->data_rec, "DE%d", &mouse_input_mode);
|
|
mouse_input_mode = !mouse_input_mode;
|
|
plat_mouse_capture(0);
|
|
} else if (!memcmp(wacom->data_rec, "SU", 2)) {
|
|
sscanf((const char *) wacom->data_rec, "SU%d", &wacom->suppressed_increment);
|
|
wacom->settings_bits.transfer_mode = wacom->mode = WACOM_MODE_SUPPRESSED;
|
|
} else if (!memcmp(wacom->data_rec, "PH", 2) && wacom->settings_bits.cmd_set == WACOM_CMDSET_IIS) {
|
|
sscanf((const char *) wacom->data_rec, "PH%d", &wacom->pressure_mode);
|
|
} else if (!memcmp(wacom->data_rec, "IC", 2)) {
|
|
sscanf((const char *) wacom->data_rec, "IC%d", &wacom->measurement);
|
|
} else if (!memcmp(wacom->data_rec, "SW", 2)) {
|
|
wacom->mode = WACOM_MODE_SWITCH;
|
|
} else if (!memcmp(wacom->data_rec, "AL", 2)) {
|
|
uint8_t out_of_range_data = wacom->settings_bits.out_of_range_data;
|
|
wacom->settings_bits.out_of_range_data = !!out_of_range_data;
|
|
} else if (!memcmp(wacom->data_rec, "RQ", 2)) {
|
|
int remote_mode = 0;
|
|
sscanf((const char *) wacom->data_rec, "RQ%d", &remote_mode);
|
|
wacom->settings_bits.remote_mode = !!remote_mode;
|
|
if (wacom->settings_bits.remote_mode)
|
|
wacom->remote_req = 1;
|
|
} else if (!memcmp(wacom->data_rec, "SP", 2)) {
|
|
wacom->transmission_stopped = 1;
|
|
} else if (!memcmp(wacom->data_rec, "ST", 2)) {
|
|
wacom->transmission_stopped = 0;
|
|
wacom->settings_bits.remote_mode = wacom->remote_req = 0;
|
|
} else if (!memcmp(wacom->data_rec, "NR", 2)) {
|
|
sscanf((const char *) wacom->data_rec, "NR%d", &wacom->x_res);
|
|
wacom->y_res = wacom->x_res;
|
|
} else if (wacom->tablet_type->type == WACOM_TYPE_IV && wacom->data_rec[0] == '~') {
|
|
if (!memcmp(wacom->data_rec, "~*", 2)) {
|
|
uint32_t settings_dword = wacom->settings;
|
|
if (strstr((const char *) wacom->data_rec, ",")) {
|
|
uint32_t x_res = wacom->x_res;
|
|
uint32_t y_res = wacom->y_res;
|
|
uint32_t increment = wacom->increment;
|
|
uint32_t interval = wacom->interval;
|
|
|
|
sscanf((const char *) wacom->data_rec, "~*%08X,%d,%d,%d,%d", &settings_dword, &increment, &interval, &x_res, &y_res);
|
|
|
|
wacom->interval = interval;
|
|
wacom->increment = increment;
|
|
wacom->x_res = x_res;
|
|
wacom->y_res = y_res;
|
|
} else {
|
|
sscanf((const char *) wacom->data_rec, "~*%X", &settings_dword);
|
|
}
|
|
wacom_process_settings_dword(wacom, settings_dword);
|
|
} else if (!memcmp(wacom->data_rec, "~C", 2)) {
|
|
fifo8_push_all(&wacom->data, (const uint8_t *) "~C5039,3779\r", sizeof("~C5039,3779\r") - 1);
|
|
} else if (!memcmp(wacom->data_rec, "~R", 2)) {
|
|
uint8_t data[256] = { 0 };
|
|
snprintf((char *)data, sizeof(data), (const char *) "~*%08X,%d,%d,%d,%d\r", wacom->settings, wacom->increment, wacom->interval, wacom->x_res, wacom->y_res);
|
|
fifo8_push_all(&wacom->data, data, strlen((const char *) data));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static int
|
|
wacom_poll(void *priv)
|
|
{
|
|
mouse_wacom_t *wacom = (mouse_wacom_t *) priv;
|
|
int delta_x;
|
|
int delta_y;
|
|
int b = mouse_get_buttons_ex();
|
|
double abs_x;
|
|
double abs_y;
|
|
|
|
mouse_subtract_coords(&delta_x, &delta_y, NULL, NULL, -32768, 32767, 0, 0);
|
|
mouse_get_abs_coords(&abs_x, &abs_y);
|
|
|
|
if (wacom->settings_bits.cmd_set == WACOM_CMDSET_IV) {
|
|
wacom->abs_x = abs_x * 5039. * (wacom->x_res / 1000.);
|
|
wacom->abs_y = abs_y * 3779. * (wacom->y_res / 1000.);
|
|
} else {
|
|
wacom->abs_x = abs_x * (wacom->measurement ? 4566. : 5800.);
|
|
wacom->abs_y = abs_y * (wacom->measurement ? 2972. : 3774.);
|
|
if (wacom->abs_x > (wacom->measurement ? 4566 : 5800))
|
|
wacom->abs_x = (wacom->measurement ? 4566 : 5800);
|
|
if (wacom->abs_y > (wacom->measurement ? 2972 : 3774))
|
|
wacom->abs_x = (wacom->measurement ? 2972 : 3774);
|
|
if (wacom->abs_x < 0)
|
|
wacom->abs_x = 0;
|
|
if (wacom->abs_y < 0)
|
|
wacom->abs_y = 0;
|
|
wacom->rel_x = delta_x;
|
|
wacom->rel_y = delta_y;
|
|
}
|
|
if (wacom->b != b)
|
|
wacom->oldb = wacom->b;
|
|
wacom->b = b;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
wacom_switch_off_to_on(int b, int oldb)
|
|
{
|
|
if (!(oldb & 0x1) && (b & 1))
|
|
return 1;
|
|
if (!(oldb & 0x2) && (b & 2))
|
|
return 1;
|
|
if (!(oldb & 0x4) && (b & 4))
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static uint8_t
|
|
wacom_get_switch(int b)
|
|
{
|
|
if (b & 0x4)
|
|
return 0x23;
|
|
if (b & 0x2)
|
|
return 0x22;
|
|
if (b & 0x1)
|
|
return 0x21;
|
|
|
|
return 0x00;
|
|
}
|
|
|
|
static void
|
|
wacom_transmit_prepare(mouse_wacom_t *wacom, int x, int y)
|
|
{
|
|
if (wacom->transmit_id) {
|
|
uint8_t data[128] = { 0 };
|
|
snprintf((char *) data, sizeof(data), "%s", wacom->tablet_type->id);
|
|
fifo8_push_all(&wacom->data, data, strlen((char *)data));
|
|
wacom->transmit_id = 0;
|
|
return;
|
|
}
|
|
wacom->last_abs_x = wacom->abs_x;
|
|
wacom->last_abs_y = wacom->abs_y;
|
|
wacom->remote_req = 0;
|
|
|
|
wacom->oldb = wacom->b;
|
|
if (wacom->settings_bits.output_format == 0) {
|
|
uint8_t data[7];
|
|
data[0] = 0xC0;
|
|
if (wacom->settings_bits.cmd_set == WACOM_CMDSET_IV) {
|
|
if (tablet_tool_type == 0)
|
|
data[6] = ((wacom->b & 0x1) ? (uint8_t) 31 : (uint8_t) -1);
|
|
else
|
|
data[6] = ((wacom->b & 0x1) ? (uint8_t) 63 : (uint8_t) -63);
|
|
}
|
|
else
|
|
data[6] = (wacom->pressure_mode || wacom->settings_bits.cmd_set == WACOM_CMDSET_IV) ? ((wacom->b & 0x1) ? (uint8_t) 31 : (uint8_t) -31) : wacom_get_switch(wacom->b);
|
|
|
|
data[5] = (y & 0x7F);
|
|
data[4] = ((y & 0x3F80) >> 7) & 0x7F;
|
|
data[3] = (((y & 0xC000) >> 14) & 3);
|
|
|
|
data[2] = (x & 0x7F);
|
|
data[1] = ((x & 0x3F80) >> 7) & 0x7F;
|
|
data[0] |= (((x & 0xC000) >> 14) & 3);
|
|
|
|
if (mouse_input_mode == 0 && wacom->settings_bits.cmd_set == WACOM_CMDSET_IIS) {
|
|
data[0] |= (!!(x < 0)) << 2;
|
|
data[3] |= (!!(y < 0)) << 2;
|
|
}
|
|
|
|
if (wacom->settings_bits.cmd_set == WACOM_CMDSET_IV) {
|
|
data[6] &= 0x7F;
|
|
data[3] &= 0x3;
|
|
if (wacom_get_switch(wacom->b) != 0x21) {
|
|
data[3] |= (wacom_get_switch(wacom->b) & 0xF) << 3;
|
|
data[0] |= 0x8;
|
|
}
|
|
}
|
|
|
|
if (wacom->pressure_mode && wacom->settings_bits.cmd_set == WACOM_CMDSET_IIS) {
|
|
data[0] |= 0x10;
|
|
data[6] &= 0x7F;
|
|
}
|
|
|
|
if (tablet_tool_type == 1) {
|
|
data[0] |= 0x20;
|
|
}
|
|
|
|
if (!mouse_tablet_in_proximity) {
|
|
data[0] &= ~0x40;
|
|
}
|
|
fifo8_push_all(&wacom->data, data, 7);
|
|
} else {
|
|
uint8_t data[128];
|
|
data[0] = 0;
|
|
snprintf((char *) data, sizeof(data), "*,%05d,%05d,%d\r\n",
|
|
wacom->abs_x, wacom->abs_y,
|
|
wacom->pressure_mode ? ((wacom->b & 0x1) ? (uint8_t) -31 : (uint8_t) 15) : ((wacom->b & 0x1) ? 21 : 00));
|
|
fifo8_push_all(&wacom->data, data, strlen((char *)data));
|
|
}
|
|
}
|
|
|
|
extern double cpuclock;
|
|
static void
|
|
wacom_report_timer(void *priv)
|
|
{
|
|
mouse_wacom_t *wacom = (mouse_wacom_t *) priv;
|
|
double milisecond_diff = ((double) (tsc - wacom->old_tsc)) / cpuclock * 1000.0;
|
|
int relative_mode = (mouse_input_mode == 0);
|
|
int x = (relative_mode ? wacom->rel_x : wacom->abs_x);
|
|
int y = (relative_mode ? wacom->rel_y : wacom->abs_y);
|
|
int x_diff = abs(relative_mode ? wacom->rel_x : (wacom->abs_x - wacom->last_abs_x));
|
|
int y_diff = abs(relative_mode ? wacom->rel_y : (wacom->abs_y - wacom->last_abs_y));
|
|
int increment = wacom->suppressed_increment ? wacom->suppressed_increment : wacom->increment;
|
|
|
|
timer_on_auto(&wacom->report_timer, wacom->transmit_period);
|
|
if ((((double) (tsc - wacom->reset_tsc)) / cpuclock * 1000.0) <= 10)
|
|
return;
|
|
if (wacom->transmit_id)
|
|
goto transmit_prepare;
|
|
if (fifo8_num_used(&wacom->data))
|
|
goto transmit;
|
|
else if (wacom->settings_bits.remote_mode && !wacom->remote_req)
|
|
return;
|
|
else {
|
|
if (wacom->settings_bits.remote_mode && wacom->remote_req) {
|
|
goto transmit_prepare;
|
|
}
|
|
if (wacom->transmission_stopped || (!mouse_tablet_in_proximity && !wacom->settings_bits.out_of_range_data))
|
|
return;
|
|
|
|
if (milisecond_diff >= (wacom->interval * 5)) {
|
|
wacom->old_tsc = tsc;
|
|
} else
|
|
return;
|
|
|
|
switch (wacom->mode) {
|
|
default:
|
|
case WACOM_MODE_STREAM:
|
|
break;
|
|
|
|
case WACOM_MODE_POINT:
|
|
{
|
|
if (wacom->suppressed_increment)
|
|
break;
|
|
if (!(wacom_switch_off_to_on(wacom->b, wacom->oldb)))
|
|
return;
|
|
break;
|
|
}
|
|
|
|
case WACOM_MODE_SWITCH:
|
|
{
|
|
if (!wacom->b)
|
|
return;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (increment && !mouse_tablet_in_proximity)
|
|
return;
|
|
|
|
if (increment && !(x_diff > increment || y_diff > increment)) {
|
|
if (wacom->suppressed_increment && (wacom->b == wacom->oldb))
|
|
return;
|
|
|
|
if (wacom->increment && !wacom_switch_off_to_on(wacom->b, wacom->oldb))
|
|
return;
|
|
}
|
|
}
|
|
|
|
transmit_prepare:
|
|
wacom_transmit_prepare(wacom, x, y);
|
|
|
|
transmit:
|
|
serial_write_fifo(wacom->serial, fifo8_pop(&wacom->data));
|
|
if (fifo8_num_used(&wacom->data) == 0) {
|
|
wacom->old_tsc = tsc;
|
|
}
|
|
return;
|
|
}
|
|
|
|
static void *
|
|
wacom_init(const device_t *info)
|
|
{
|
|
mouse_wacom_t *dev;
|
|
|
|
dev = (mouse_wacom_t *) calloc(1, sizeof(mouse_wacom_t));
|
|
dev->name = info->name;
|
|
dev->but = 3;
|
|
dev->bits = 10;
|
|
if (info->local == 0) {
|
|
dev->tablet_type = &sd510_id;
|
|
} else
|
|
dev->tablet_type = (wacom_tablet_id*)info->local;
|
|
|
|
fifo8_create(&dev->data, 512);
|
|
|
|
dev->port = device_get_config_int("port");
|
|
|
|
dev->serial = serial_attach(dev->port, wacom_callback, wacom_write, dev);
|
|
timer_add(&dev->report_timer, wacom_report_timer, dev, 0);
|
|
mouse_set_buttons(dev->but);
|
|
|
|
if (dev->tablet_type->type == WACOM_TYPE_IV) {
|
|
wacom_reset_artpad(dev);
|
|
wacom_process_settings_dword(dev, 0xE2018000);
|
|
}
|
|
else wacom_reset(dev);
|
|
|
|
return dev;
|
|
}
|
|
|
|
static void
|
|
wacom_speed_changed(void *priv)
|
|
{
|
|
mouse_wacom_t *dev = (mouse_wacom_t *) priv;
|
|
|
|
wacom_callback(dev->serial, dev);
|
|
}
|
|
|
|
static void
|
|
wacom_close(void *priv)
|
|
{
|
|
mouse_wacom_t *dev = (mouse_wacom_t *) priv;
|
|
|
|
fifo8_destroy(&dev->data);
|
|
|
|
/* Detach serial port from the mouse. */
|
|
if (dev && dev->serial && dev->serial->sd)
|
|
memset(dev->serial->sd, 0, sizeof(serial_device_t));
|
|
|
|
free(dev);
|
|
}
|
|
|
|
static const device_config_t wacom_config[] = {
|
|
// clang-format off
|
|
{
|
|
.name = "port",
|
|
.description = "Serial Port",
|
|
.type = CONFIG_SELECTION,
|
|
.default_string = "",
|
|
.default_int = 0,
|
|
.file_filter = "",
|
|
.spinner = { 0 },
|
|
.selection = {
|
|
{ .description = "COM1", .value = 0 },
|
|
{ .description = "COM2", .value = 1 },
|
|
{ .description = "COM3", .value = 2 },
|
|
{ .description = "COM4", .value = 3 },
|
|
{ .description = "" }
|
|
}
|
|
},
|
|
{ .name = "", .description = "", .type = CONFIG_END }
|
|
// clang-format on
|
|
};
|
|
|
|
const device_t mouse_wacom_device = {
|
|
.name = "Wacom SD-510C",
|
|
.internal_name = "wacom_serial",
|
|
.flags = DEVICE_COM,
|
|
.local = 0,
|
|
.init = wacom_init,
|
|
.close = wacom_close,
|
|
.reset = NULL,
|
|
{ .poll = wacom_poll },
|
|
.speed_changed = wacom_speed_changed,
|
|
.force_redraw = NULL,
|
|
.config = wacom_config
|
|
};
|
|
|
|
const device_t mouse_wacom_artpad_device = {
|
|
.name = "Wacom ArtPad",
|
|
.internal_name = "wacom_serial_artpad",
|
|
.flags = DEVICE_COM,
|
|
.local = (uintptr_t)&artpad_id,
|
|
.init = wacom_init,
|
|
.close = wacom_close,
|
|
.reset = NULL,
|
|
{ .poll = wacom_poll },
|
|
.speed_changed = wacom_speed_changed,
|
|
.force_redraw = NULL,
|
|
.config = wacom_config
|
|
};
|