iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Input: hgpk - support GlideSensor and PenTablet modes

Browse Source 
Add a "hgpk_mode" sysfs attribute that allows selection between 3 options:
Mouse (the existing option), GlideSensor and PenTablet.

GlideSensor is an enhanced protocol for the regular touchpad mode that
additionally reports pressure and uses absolute coordinates. We suspect
that it may be more reliable than mouse mode in some environments.

PenTablet mode puts the touchpad into resistive mode, you must then use
a stylus as an input. We suspect this is the most reliable way to drive
the touchpad.

The GlideSensor and PenTablet devices expose themselves with the
intention of being combined with the synaptics X11 input driver.

Based on earlier work by Paul Fox.

Signed-off-by: Daniel Drake <dsd@laptop.org>
Signed-off-by: Dmitry Torokhov <dtor@mail.ru>
This commit is contained in:
Daniel Drake 2010-11-11 22:19:57 -08:00 committed by Dmitry Torokhov
parent 10ee2ded62
commit ca94ec4354
3 changed files with 442 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

469
drivers/input/mouse/hgpk.c
View File

@ -69,6 +69,32 @@ module_param(post_interrupt_delay, int, 0644);
MODULE_PARM_DESC(post_interrupt_delay, MODULE_PARM_DESC(post_interrupt_delay,
"delay (ms) before recal after recal interrupt detected"); "delay (ms) before recal after recal interrupt detected");
static char hgpk_mode_name[16];
module_param_string(hgpk_mode, hgpk_mode_name, sizeof(hgpk_mode_name), 0644);
MODULE_PARM_DESC(hgpk_mode,
"default hgpk mode: mouse, glidesensor or pentablet");
static int hgpk_default_mode = HGPK_MODE_MOUSE;
static const char * const hgpk_mode_names[] = {
[HGPK_MODE_MOUSE] = "Mouse",
[HGPK_MODE_GLIDESENSOR] = "GlideSensor",
[HGPK_MODE_PENTABLET] = "PenTablet",
};
static int hgpk_mode_from_name(const char *buf, int len)
{
int i;
for (i = 0; i < ARRAY_SIZE(hgpk_mode_names); i++) {
const char *name = hgpk_mode_names[i];
if (strlen(name) == len && !strncasecmp(name, buf, len))
return i;
}
return HGPK_MODE_INVALID;
}
/* /*
* When the touchpad gets ultra-sensitive, one can keep their finger 1/2" * When the touchpad gets ultra-sensitive, one can keep their finger 1/2"
* above the pad and still have it send packets. This causes a jump cursor * above the pad and still have it send packets. This causes a jump cursor
@ -143,23 +169,139 @@ static void hgpk_spewing_hack(struct psmouse *psmouse,
* swr/swl are the left/right buttons. * swr/swl are the left/right buttons.
* x-neg/y-neg are the x and y delta negative bits * x-neg/y-neg are the x and y delta negative bits
* x-over/y-over are the x and y overflow bits * x-over/y-over are the x and y overflow bits
*
* ---
*
* HGPK Advanced Mode - single-mode format
*
* byte 0(PT): 1 1 0 0 1 1 1 1
* byte 0(GS): 1 1 1 1 1 1 1 1
* byte 1: 0 x6 x5 x4 x3 x2 x1 x0
* byte 2(PT): 0 0 x9 x8 x7 ? pt-dsw 0
* byte 2(GS): 0 x10 x9 x8 x7 ? gs-dsw pt-dsw
* byte 3: 0 y9 y8 y7 1 0 swr swl
* byte 4: 0 y6 y5 y4 y3 y2 y1 y0
* byte 5: 0 z6 z5 z4 z3 z2 z1 z0
*
* ?'s are not defined in the protocol spec, may vary between models.
*
* swr/swl are the left/right buttons.
*
* pt-dsw/gs-dsw indicate that the pt/gs sensor is detecting a
* pen/finger
*/ */
static int hgpk_validate_byte(unsigned char *packet) static bool hgpk_is_byte_valid(struct psmouse *psmouse, unsigned char *packet)
{ {
return (packet[0] & 0x0C) != 0x08; struct hgpk_data *priv = psmouse->private;
int pktcnt = psmouse->pktcnt;
bool valid;
switch (priv->mode) {
case HGPK_MODE_MOUSE:
valid = (packet[0] & 0x0C) == 0x08;
break;
case HGPK_MODE_GLIDESENSOR:
valid = pktcnt == 1 ?
packet[0] == HGPK_GS : !(packet[pktcnt - 1] & 0x80);
break;
case HGPK_MODE_PENTABLET:
valid = pktcnt == 1 ?
packet[0] == HGPK_PT : !(packet[pktcnt - 1] & 0x80);
break;
default:
valid = false;
break;
}
if (!valid)
hgpk_dbg(psmouse,
"bad data, mode %d (%d) %02x %02x %02x %02x %02x %02x\n",
priv->mode, pktcnt,
psmouse->packet[0], psmouse->packet[1],
psmouse->packet[2], psmouse->packet[3],
psmouse->packet[4], psmouse->packet[5]);
return valid;
} }
static void hgpk_process_packet(struct psmouse *psmouse) static void hgpk_process_advanced_packet(struct psmouse *psmouse)
{
struct hgpk_data *priv = psmouse->private;
struct input_dev *idev = psmouse->dev;
unsigned char *packet = psmouse->packet;
int down = !!(packet[2] & 2);
int left = !!(packet[3] & 1);
int right = !!(packet[3] & 2);
int x = packet[1] | ((packet[2] & 0x78) << 4);
int y = packet[4] | ((packet[3] & 0x70) << 3);
if (priv->mode == HGPK_MODE_GLIDESENSOR) {
int pt_down = !!(packet[2] & 1);
int finger_down = !!(packet[2] & 2);
int z = packet[5];
input_report_abs(idev, ABS_PRESSURE, z);
if (tpdebug)
hgpk_dbg(psmouse, "pd=%d fd=%d z=%d",
pt_down, finger_down, z);
} else {
/*
* PenTablet mode does not report pressure, so we don't
* report it here
*/
if (tpdebug)
hgpk_dbg(psmouse, "pd=%d ", down);
}
if (tpdebug)
hgpk_dbg(psmouse, "l=%d r=%d x=%d y=%d\n", left, right, x, y);
input_report_key(idev, BTN_TOUCH, down);
input_report_key(idev, BTN_LEFT, left);
input_report_key(idev, BTN_RIGHT, right);
/*
* If this packet says that the finger was removed, reset our position
* tracking so that we don't erroneously detect a jump on next press.
*/
if (!down)
priv->abs_x = priv->abs_y = -1;
/*
* Report position if finger/pen is down, but weed out duplicate
* packets (we get quite a few in this mode, and they mess up our
* jump detection.
*/
if (down && (x != priv->abs_x || y != priv->abs_y)) {
/* Don't apply hacks in PT mode, it seems reliable */
if (priv->mode != HGPK_MODE_PENTABLET && priv->abs_x != -1) {
hgpk_jumpy_hack(psmouse,
priv->abs_x - x, priv->abs_y - y);
hgpk_spewing_hack(psmouse, left, right,
priv->abs_x - x, priv->abs_y - y);
}
input_report_abs(idev, ABS_X, x);
input_report_abs(idev, ABS_Y, y);
priv->abs_x = x;
priv->abs_y = y;
}
input_sync(idev);
}
static void hgpk_process_simple_packet(struct psmouse *psmouse)
{ {
struct input_dev *dev = psmouse->dev; struct input_dev *dev = psmouse->dev;
unsigned char *packet = psmouse->packet; unsigned char *packet = psmouse->packet;
int x, y, left, right; int left = packet[0] & 1;
int right = (packet[0] >> 1) & 1;
left = packet[0] & 1; int x = packet[1] - ((packet[0] << 4) & 0x100);
right = (packet[0] >> 1) & 1; int y = ((packet[0] << 3) & 0x100) - packet[2];
x = packet[1] - ((packet[0] << 4) & 0x100);
y = ((packet[0] << 3) & 0x100) - packet[2];
hgpk_jumpy_hack(psmouse, x, y); hgpk_jumpy_hack(psmouse, x, y);
hgpk_spewing_hack(psmouse, left, right, x, y); hgpk_spewing_hack(psmouse, left, right, x, y);
@ -180,15 +322,14 @@ static psmouse_ret_t hgpk_process_byte(struct psmouse *psmouse)
{ {
struct hgpk_data *priv = psmouse->private; struct hgpk_data *priv = psmouse->private;
if (hgpk_validate_byte(psmouse->packet)) { if (!hgpk_is_byte_valid(psmouse, psmouse->packet))
hgpk_dbg(psmouse, "%s: (%d) %02x %02x %02x\n",
__func__, psmouse->pktcnt, psmouse->packet[0],
psmouse->packet[1], psmouse->packet[2]);
return PSMOUSE_BAD_DATA; return PSMOUSE_BAD_DATA;
}
if (psmouse->pktcnt >= psmouse->pktsize) { if (psmouse->pktcnt >= psmouse->pktsize) {
hgpk_process_packet(psmouse); if (priv->mode == HGPK_MODE_MOUSE)
hgpk_process_simple_packet(psmouse);
else
hgpk_process_advanced_packet(psmouse);
return PSMOUSE_FULL_PACKET; return PSMOUSE_FULL_PACKET;
} }
@ -210,10 +351,161 @@ static psmouse_ret_t hgpk_process_byte(struct psmouse *psmouse)
return PSMOUSE_GOOD_DATA; return PSMOUSE_GOOD_DATA;
} }
static int hgpk_select_mode(struct psmouse *psmouse)
{
struct ps2dev *ps2dev = &psmouse->ps2dev;
struct hgpk_data *priv = psmouse->private;
int i;
int cmd;
/*
* 4 disables to enable advanced mode
* then 3 0xf2 bytes as the preamble for GS/PT selection
*/
const int advanced_init[] = {
PSMOUSE_CMD_DISABLE, PSMOUSE_CMD_DISABLE,
PSMOUSE_CMD_DISABLE, PSMOUSE_CMD_DISABLE,
0xf2, 0xf2, 0xf2,
};
switch (priv->mode) {
case HGPK_MODE_MOUSE:
psmouse->pktsize = 3;
break;
case HGPK_MODE_GLIDESENSOR:
case HGPK_MODE_PENTABLET:
psmouse->pktsize = 6;
/* Switch to 'Advanced mode.', four disables in a row. */
for (i = 0; i < ARRAY_SIZE(advanced_init); i++)
if (ps2_command(ps2dev, NULL, advanced_init[i]))
return -EIO;
/* select between GlideSensor (mouse) or PenTablet */
cmd = priv->mode == HGPK_MODE_GLIDESENSOR ?
PSMOUSE_CMD_SETSCALE11 : PSMOUSE_CMD_SETSCALE21;
if (ps2_command(ps2dev, NULL, cmd))
return -EIO;
break;
default:
return -EINVAL;
}
return 0;
}
static void hgpk_setup_input_device(struct input_dev *input,
struct input_dev *old_input,
enum hgpk_mode mode)
{
if (old_input) {
input->name = old_input->name;
input->phys = old_input->phys;
input->id = old_input->id;
input->dev.parent = old_input->dev.parent;
}
memset(input->evbit, 0, sizeof(input->evbit));
memset(input->relbit, 0, sizeof(input->relbit));
memset(input->keybit, 0, sizeof(input->keybit));
/* All modes report left and right buttons */
__set_bit(EV_KEY, input->evbit);
__set_bit(BTN_LEFT, input->keybit);
__set_bit(BTN_RIGHT, input->keybit);
switch (mode) {
case HGPK_MODE_MOUSE:
__set_bit(EV_REL, input->evbit);
__set_bit(REL_X, input->relbit);
__set_bit(REL_Y, input->relbit);
break;
case HGPK_MODE_GLIDESENSOR:
__set_bit(BTN_TOUCH, input->keybit);
__set_bit(BTN_TOOL_FINGER, input->keybit);
__set_bit(EV_ABS, input->evbit);
/* GlideSensor has pressure sensor, PenTablet does not */
input_set_abs_params(input, ABS_PRESSURE, 0, 15, 0, 0);
/* From device specs */
input_set_abs_params(input, ABS_X, 0, 399, 0, 0);
input_set_abs_params(input, ABS_Y, 0, 290, 0, 0);
/* Calculated by hand based on usable size (52mm x 38mm) */
input_abs_set_res(input, ABS_X, 8);
input_abs_set_res(input, ABS_Y, 8);
break;
case HGPK_MODE_PENTABLET:
__set_bit(BTN_TOUCH, input->keybit);
__set_bit(BTN_TOOL_FINGER, input->keybit);
__set_bit(EV_ABS, input->evbit);
/* From device specs */
input_set_abs_params(input, ABS_X, 0, 999, 0, 0);
input_set_abs_params(input, ABS_Y, 5, 239, 0, 0);
/* Calculated by hand based on usable size (156mm x 38mm) */
input_abs_set_res(input, ABS_X, 6);
input_abs_set_res(input, ABS_Y, 8);
break;
default:
BUG();
}
}
static void hgpk_reset_hack_state(struct psmouse *psmouse)
{
struct hgpk_data *priv = psmouse->private;
priv->abs_x = priv->abs_y = -1;
}
static int hgpk_reset_device(struct psmouse *psmouse, bool recalibrate)
{
int err;
psmouse_reset(psmouse);
if (recalibrate) {
struct ps2dev *ps2dev = &psmouse->ps2dev;
/* send the recalibrate request */
if (ps2_command(ps2dev, NULL, 0xf5) ||
ps2_command(ps2dev, NULL, 0xf5) ||
ps2_command(ps2dev, NULL, 0xe6) ||
ps2_command(ps2dev, NULL, 0xf5)) {
return -1;
}
/* according to ALPS, 150mS is required for recalibration */
msleep(150);
}
err = hgpk_select_mode(psmouse);
if (err) {
hgpk_err(psmouse, "failed to select mode\n");
return err;
}
hgpk_reset_hack_state(psmouse);
return 0;
}
static int hgpk_force_recalibrate(struct psmouse *psmouse) static int hgpk_force_recalibrate(struct psmouse *psmouse)
{ {
struct ps2dev *ps2dev = &psmouse->ps2dev; struct ps2dev *ps2dev = &psmouse->ps2dev;
struct hgpk_data *priv = psmouse->private; struct hgpk_data *priv = psmouse->private;
int err;
/* C-series touchpads added the recalibrate command */ /* C-series touchpads added the recalibrate command */
if (psmouse->model < HGPK_MODEL_C) if (psmouse->model < HGPK_MODEL_C)
@ -223,20 +515,12 @@ static int hgpk_force_recalibrate(struct psmouse *psmouse)
psmouse_set_state(psmouse, PSMOUSE_INITIALIZING); psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
/* start by resetting the device */ /* start by resetting the device */
psmouse_reset(psmouse); err = hgpk_reset_device(psmouse, true);
if (err)
return err;
/* send the recalibrate request */ /*
if (ps2_command(ps2dev, NULL, 0xf5) || * XXX: If a finger is down during this delay, recalibration will
ps2_command(ps2dev, NULL, 0xf5) ||
ps2_command(ps2dev, NULL, 0xe6) ||
ps2_command(ps2dev, NULL, 0xf5)) {
return -1;
}
/* according to ALPS, 150mS is required for recalibration */
msleep(150);
/* XXX: If a finger is down during this delay, recalibration will
* detect capacitance incorrectly. This is a hardware bug, and * detect capacitance incorrectly. This is a hardware bug, and
* we don't have a good way to deal with it. The 2s window stuff * we don't have a good way to deal with it. The 2s window stuff
* (below) is our best option for now. * (below) is our best option for now.
@ -247,12 +531,13 @@ static int hgpk_force_recalibrate(struct psmouse *psmouse)
psmouse_set_state(psmouse, PSMOUSE_ACTIVATED); psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
/* After we recalibrate, we shouldn't get any packets for 2s. If /*
* After we recalibrate, we shouldn't get any packets for 2s. If
* we do, it's likely that someone's finger was on the touchpad. * we do, it's likely that someone's finger was on the touchpad.
* If someone's finger *was* on the touchpad, it's probably * If someone's finger *was* on the touchpad, it's probably
* miscalibrated. So, we should schedule another recalibration * miscalibrated. So, we should schedule another recalibration
*/ */
priv->recalib_window = jiffies + msecs_to_jiffies(recal_guard_time); priv->recalib_window = jiffies + msecs_to_jiffies(recal_guard_time);
return 0; return 0;
} }
@ -266,6 +551,7 @@ static int hgpk_toggle_power(struct psmouse *psmouse, int enable)
{ {
struct ps2dev *ps2dev = &psmouse->ps2dev; struct ps2dev *ps2dev = &psmouse->ps2dev;
int timeo; int timeo;
int err;
/* Added on D-series touchpads */ /* Added on D-series touchpads */
if (psmouse->model < HGPK_MODEL_D) if (psmouse->model < HGPK_MODEL_D)
@ -288,7 +574,11 @@ static int hgpk_toggle_power(struct psmouse *psmouse, int enable)
msleep(50); msleep(50);
} }
psmouse_reset(psmouse); err = hgpk_reset_device(psmouse, false);
if (err) {
hgpk_err(psmouse, "Failed to reset device!\n");
return err;
}
/* should be all set, enable the touchpad */ /* should be all set, enable the touchpad */
ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE); ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE);
@ -319,17 +609,17 @@ static int hgpk_poll(struct psmouse *psmouse)
static int hgpk_reconnect(struct psmouse *psmouse) static int hgpk_reconnect(struct psmouse *psmouse)
{ {
/* During suspend/resume the ps2 rails remain powered. We don't want /*
* During suspend/resume the ps2 rails remain powered. We don't want
* to do a reset because it's flush data out of buffers; however, * to do a reset because it's flush data out of buffers; however,
* earlier prototypes (B1) had some brokenness that required a reset. */ * earlier prototypes (B1) had some brokenness that required a reset.
*/
if (olpc_board_at_least(olpc_board(0xb2))) if (olpc_board_at_least(olpc_board(0xb2)))
if (psmouse->ps2dev.serio->dev.power.power_state.event != if (psmouse->ps2dev.serio->dev.power.power_state.event !=
PM_EVENT_ON) PM_EVENT_ON)
return 0; return 0;
psmouse_reset(psmouse); return hgpk_reset_device(psmouse, false);
return 0;
} }
static ssize_t hgpk_show_powered(struct psmouse *psmouse, void *data, char *buf) static ssize_t hgpk_show_powered(struct psmouse *psmouse, void *data, char *buf)
@ -366,6 +656,65 @@ static ssize_t hgpk_set_powered(struct psmouse *psmouse, void *data,
__PSMOUSE_DEFINE_ATTR(powered, S_IWUSR | S_IRUGO, NULL, __PSMOUSE_DEFINE_ATTR(powered, S_IWUSR | S_IRUGO, NULL,
hgpk_show_powered, hgpk_set_powered, false); hgpk_show_powered, hgpk_set_powered, false);
static ssize_t attr_show_mode(struct psmouse *psmouse, void *data, char *buf)
{
struct hgpk_data *priv = psmouse->private;
return sprintf(buf, "%s\n", hgpk_mode_names[priv->mode]);
}
static ssize_t attr_set_mode(struct psmouse *psmouse, void *data,
const char *buf, size_t len)
{
struct hgpk_data *priv = psmouse->private;
enum hgpk_mode old_mode = priv->mode;
enum hgpk_mode new_mode = hgpk_mode_from_name(buf, len);
struct input_dev *old_dev = psmouse->dev;
struct input_dev *new_dev;
int err;
if (new_mode == HGPK_MODE_INVALID)
return -EINVAL;
if (old_mode == new_mode)
return len;
new_dev = input_allocate_device();
if (!new_dev)
return -ENOMEM;
psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
/* Switch device into the new mode */
priv->mode = new_mode;
err = hgpk_reset_device(psmouse, false);
if (err)
goto err_try_restore;
hgpk_setup_input_device(new_dev, old_dev, new_mode);
psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
err = input_register_device(new_dev);
if (err)
goto err_try_restore;
psmouse->dev = new_dev;
input_unregister_device(old_dev);
return len;
err_try_restore:
input_free_device(new_dev);
priv->mode = old_mode;
hgpk_reset_device(psmouse, false);
return err;
}
PSMOUSE_DEFINE_ATTR(hgpk_mode, S_IWUSR | S_IRUGO, NULL,
attr_show_mode, attr_set_mode);
static ssize_t hgpk_trigger_recal_show(struct psmouse *psmouse, static ssize_t hgpk_trigger_recal_show(struct psmouse *psmouse,
void *data, char *buf) void *data, char *buf)
{ {
@ -401,6 +750,8 @@ static void hgpk_disconnect(struct psmouse *psmouse)
device_remove_file(&psmouse->ps2dev.serio->dev, device_remove_file(&psmouse->ps2dev.serio->dev,
&psmouse_attr_powered.dattr); &psmouse_attr_powered.dattr);
device_remove_file(&psmouse->ps2dev.serio->dev,
&psmouse_attr_hgpk_mode.dattr);
if (psmouse->model >= HGPK_MODEL_C) if (psmouse->model >= HGPK_MODEL_C)
device_remove_file(&psmouse->ps2dev.serio->dev, device_remove_file(&psmouse->ps2dev.serio->dev,
@ -424,6 +775,7 @@ static void hgpk_recalib_work(struct work_struct *work)
static int hgpk_register(struct psmouse *psmouse) static int hgpk_register(struct psmouse *psmouse)
{ {
struct hgpk_data *priv = psmouse->private;
int err; int err;
/* register handlers */ /* register handlers */
@ -431,13 +783,14 @@ static int hgpk_register(struct psmouse *psmouse)
psmouse->poll = hgpk_poll; psmouse->poll = hgpk_poll;
psmouse->disconnect = hgpk_disconnect; psmouse->disconnect = hgpk_disconnect;
psmouse->reconnect = hgpk_reconnect; psmouse->reconnect = hgpk_reconnect;
psmouse->pktsize = 3;
/* Disable the idle resync. */ /* Disable the idle resync. */
psmouse->resync_time = 0; psmouse->resync_time = 0;
/* Reset after a lot of bad bytes. */ /* Reset after a lot of bad bytes. */
psmouse->resetafter = 1024; psmouse->resetafter = 1024;
hgpk_setup_input_device(psmouse->dev, NULL, priv->mode);
err = device_create_file(&psmouse->ps2dev.serio->dev, err = device_create_file(&psmouse->ps2dev.serio->dev,
&psmouse_attr_powered.dattr); &psmouse_attr_powered.dattr);
if (err) { if (err) {
@ -445,6 +798,13 @@ static int hgpk_register(struct psmouse *psmouse)
return err; return err;
} }
err = device_create_file(&psmouse->ps2dev.serio->dev,
&psmouse_attr_hgpk_mode.dattr);
if (err) {
hgpk_err(psmouse, "Failed creating 'hgpk_mode' sysfs node\n");
goto err_remove_powered;
}
/* C-series touchpads added the recalibrate command */ /* C-series touchpads added the recalibrate command */
if (psmouse->model >= HGPK_MODEL_C) { if (psmouse->model >= HGPK_MODEL_C) {
err = device_create_file(&psmouse->ps2dev.serio->dev, err = device_create_file(&psmouse->ps2dev.serio->dev,
@ -452,30 +812,40 @@ static int hgpk_register(struct psmouse *psmouse)
if (err) { if (err) {
hgpk_err(psmouse, hgpk_err(psmouse,
"Failed creating 'recalibrate' sysfs node\n"); "Failed creating 'recalibrate' sysfs node\n");
device_remove_file(&psmouse->ps2dev.serio->dev, goto err_remove_mode;
&psmouse_attr_powered.dattr);
return err;
} }
} }
return 0; return 0;
err_remove_mode:
device_remove_file(&psmouse->ps2dev.serio->dev,
&psmouse_attr_hgpk_mode.dattr);
err_remove_powered:
device_remove_file(&psmouse->ps2dev.serio->dev,
&psmouse_attr_powered.dattr);
return err;
} }
int hgpk_init(struct psmouse *psmouse) int hgpk_init(struct psmouse *psmouse)
{ {
struct hgpk_data *priv; struct hgpk_data *priv;
int err = -ENOMEM; int err;
priv = kzalloc(sizeof(struct hgpk_data), GFP_KERNEL); priv = kzalloc(sizeof(struct hgpk_data), GFP_KERNEL);
if (!priv) if (!priv) {
err = -ENOMEM;
goto alloc_fail; goto alloc_fail;
}
psmouse->private = priv; psmouse->private = priv;
priv->psmouse = psmouse; priv->psmouse = psmouse;
priv->powered = true; priv->powered = true;
priv->mode = hgpk_default_mode;
INIT_DELAYED_WORK(&priv->recalib_wq, hgpk_recalib_work); INIT_DELAYED_WORK(&priv->recalib_wq, hgpk_recalib_work);
err = psmouse_reset(psmouse); err = hgpk_reset_device(psmouse, false);
if (err) if (err)
goto init_fail; goto init_fail;
@ -531,3 +901,14 @@ int hgpk_detect(struct psmouse *psmouse, bool set_properties)
return 0; return 0;
} }
void hgpk_module_init(void)
{
hgpk_default_mode = hgpk_mode_from_name(hgpk_mode_name,
strlen(hgpk_mode_name));
if (hgpk_default_mode == HGPK_MODE_INVALID) {
hgpk_default_mode = HGPK_MODE_MOUSE;
strlcpy(hgpk_mode_name, hgpk_mode_names[HGPK_MODE_MOUSE],
sizeof(hgpk_mode_name));
}
}

16
drivers/input/mouse/hgpk.h
View File

@ -5,6 +5,9 @@
#ifndef _HGPK_H #ifndef _HGPK_H
#define _HGPK_H #define _HGPK_H
#define HGPK_GS 0xff /* The GlideSensor */
#define HGPK_PT 0xcf /* The PenTablet */
enum hgpk_model_t { enum hgpk_model_t {
HGPK_MODEL_PREA = 0x0a, /* pre-B1s */ HGPK_MODEL_PREA = 0x0a, /* pre-B1s */
HGPK_MODEL_A = 0x14, /* found on B1s, PT disabled in hardware */ HGPK_MODEL_A = 0x14, /* found on B1s, PT disabled in hardware */
@ -13,12 +16,21 @@ enum hgpk_model_t {
HGPK_MODEL_D = 0x50, /* C1, mass production */ HGPK_MODEL_D = 0x50, /* C1, mass production */
}; };
enum hgpk_mode {
HGPK_MODE_MOUSE,
HGPK_MODE_GLIDESENSOR,
HGPK_MODE_PENTABLET,
HGPK_MODE_INVALID
};
struct hgpk_data { struct hgpk_data {
struct psmouse *psmouse; struct psmouse *psmouse;
enum hgpk_mode mode;
bool powered; bool powered;
int count, x_tally, y_tally; /* hardware workaround stuff */ int count, x_tally, y_tally; /* hardware workaround stuff */
unsigned long recalib_window; unsigned long recalib_window;
struct delayed_work recalib_wq; struct delayed_work recalib_wq;
int abs_x, abs_y;
}; };
#define hgpk_dbg(psmouse, format, arg...) \ #define hgpk_dbg(psmouse, format, arg...) \
@ -33,9 +45,13 @@ struct hgpk_data {
dev_notice(&(psmouse)->ps2dev.serio->dev, format, ## arg) dev_notice(&(psmouse)->ps2dev.serio->dev, format, ## arg)
#ifdef CONFIG_MOUSE_PS2_OLPC #ifdef CONFIG_MOUSE_PS2_OLPC
void hgpk_module_init(void);
int hgpk_detect(struct psmouse *psmouse, bool set_properties); int hgpk_detect(struct psmouse *psmouse, bool set_properties);
int hgpk_init(struct psmouse *psmouse); int hgpk_init(struct psmouse *psmouse);
#else #else
static inline void hgpk_module_init(void)
{
}
static inline int hgpk_detect(struct psmouse *psmouse, bool set_properties) static inline int hgpk_detect(struct psmouse *psmouse, bool set_properties)
{ {
return -ENODEV; return -ENODEV;

1
drivers/input/mouse/psmouse-base.c
View File

@ -1711,6 +1711,7 @@ static int __init psmouse_init(void)
lifebook_module_init(); lifebook_module_init();
synaptics_module_init(); synaptics_module_init();
hgpk_module_init();
kpsmoused_wq = create_singlethread_workqueue("kpsmoused"); kpsmoused_wq = create_singlethread_workqueue("kpsmoused");
if (!kpsmoused_wq) { if (!kpsmoused_wq) {