Input: hgpk - support GlideSensor and PenTablet modes (ca94ec43) · Commits · 戴 / test

drivers/input/mouse/hgpk.c

+424 −43

Original line number	Diff line number	Diff line
		@@ -69,6 +69,32 @@ module_param(post_interrupt_delay, int, 0644);
		MODULE_PARM_DESC(post_interrupt_delay,
		"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"
		* 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.
		* x-neg/y-neg are the x and y delta negative 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;
		}

		static void hgpk_process_packet(struct psmouse *psmouse)
		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_advanced_packet(struct psmouse *psmouse)
		{
		struct input_dev *dev = psmouse->dev;
		struct hgpk_data *priv = psmouse->private;
		struct input_dev *idev = psmouse->dev;
		unsigned char *packet = psmouse->packet;
		int x, y, left, right;
		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);
		}

		left = packet[0] & 1;
		right = (packet[0] >> 1) & 1;
		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;

		x = packet[1] - ((packet[0] << 4) & 0x100);
		y = ((packet[0] << 3) & 0x100) - packet[2];
		/*
		* 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;
		unsigned char *packet = psmouse->packet;
		int left = packet[0] & 1;
		int right = (packet[0] >> 1) & 1;
		int x = packet[1] - ((packet[0] << 4) & 0x100);
		int y = ((packet[0] << 3) & 0x100) - packet[2];

		hgpk_jumpy_hack(psmouse, 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;

		if (hgpk_validate_byte(psmouse->packet)) {
		hgpk_dbg(psmouse, "%s: (%d) %02x %02x %02x\n",
		__func__, psmouse->pktcnt, psmouse->packet[0],
		psmouse->packet[1], psmouse->packet[2]);
		if (!hgpk_is_byte_valid(psmouse, psmouse->packet))
		return PSMOUSE_BAD_DATA;
		}

		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;
		}

		@@ -210,21 +351,133 @@ static psmouse_ret_t hgpk_process_byte(struct psmouse *psmouse)
		return PSMOUSE_GOOD_DATA;
		}

		static int hgpk_force_recalibrate(struct psmouse *psmouse)
		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;
		}

		/* C-series touchpads added the recalibrate command */
		if (psmouse->model < HGPK_MODEL_C)
		return 0;
		}

		/* we don't want to race with the irq handler, nor with resyncs */
		psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
		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;

		/* start by resetting the device */
		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) \|\|
		@@ -235,8 +488,39 @@ static int hgpk_force_recalibrate(struct psmouse *psmouse)

		/* 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)
		{
		struct ps2dev *ps2dev = &psmouse->ps2dev;
		struct hgpk_data *priv = psmouse->private;
		int err;

		/* C-series touchpads added the recalibrate command */
		if (psmouse->model < HGPK_MODEL_C)
		return 0;

		/* we don't want to race with the irq handler, nor with resyncs */
		psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);

		/* start by resetting the device */
		err = hgpk_reset_device(psmouse, true);
		if (err)
		return err;

		/* XXX: If a finger is down during this delay, recalibration will
		/*
		* XXX: If a finger is down during this delay, recalibration will
		* detect capacitance incorrectly. This is a hardware bug, and
		* we don't have a good way to deal with it. The 2s window stuff
		* (below) is our best option for now.
		@@ -247,7 +531,8 @@ static int hgpk_force_recalibrate(struct psmouse *psmouse)

		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.
		* If someone's finger was on the touchpad, it's probably
		* miscalibrated. So, we should schedule another recalibration
		@@ -266,6 +551,7 @@ static int hgpk_toggle_power(struct psmouse *psmouse, int enable)
		{
		struct ps2dev *ps2dev = &psmouse->ps2dev;
		int timeo;
		int err;

		/* Added on D-series touchpads */
		if (psmouse->model < HGPK_MODEL_D)
		@@ -288,7 +574,11 @@ static int hgpk_toggle_power(struct psmouse *psmouse, int enable)
		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 */
		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)
		{
		/* 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,
		* 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 (psmouse->ps2dev.serio->dev.power.power_state.event !=
		PM_EVENT_ON)
		return 0;

		psmouse_reset(psmouse);

		return 0;
		return hgpk_reset_device(psmouse, false);
		}

		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,
		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,
		void data, char buf)
		{
		@@ -401,6 +750,8 @@ static void hgpk_disconnect(struct psmouse *psmouse)

		device_remove_file(&psmouse->ps2dev.serio->dev,
		&psmouse_attr_powered.dattr);
		device_remove_file(&psmouse->ps2dev.serio->dev,
		&psmouse_attr_hgpk_mode.dattr);

		if (psmouse->model >= HGPK_MODEL_C)
		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)
		{
		struct hgpk_data *priv = psmouse->private;
		int err;

		/* register handlers */
		@@ -431,13 +783,14 @@ static int hgpk_register(struct psmouse *psmouse)
		psmouse->poll = hgpk_poll;
		psmouse->disconnect = hgpk_disconnect;
		psmouse->reconnect = hgpk_reconnect;
		psmouse->pktsize = 3;

		/* Disable the idle resync. */
		psmouse->resync_time = 0;
		/* Reset after a lot of bad bytes. */
		psmouse->resetafter = 1024;

		hgpk_setup_input_device(psmouse->dev, NULL, priv->mode);

		err = device_create_file(&psmouse->ps2dev.serio->dev,
		&psmouse_attr_powered.dattr);
		if (err) {
		@@ -445,6 +798,13 @@ static int hgpk_register(struct psmouse *psmouse)
		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 */
		if (psmouse->model >= HGPK_MODEL_C) {
		err = device_create_file(&psmouse->ps2dev.serio->dev,
		@@ -452,30 +812,40 @@ static int hgpk_register(struct psmouse *psmouse)
		if (err) {
		hgpk_err(psmouse,
		"Failed creating 'recalibrate' sysfs node\n");
		device_remove_file(&psmouse->ps2dev.serio->dev,
		&psmouse_attr_powered.dattr);
		return err;
		goto err_remove_mode;
		}
		}

		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)
		{
		struct hgpk_data *priv;
		int err = -ENOMEM;
		int err;

		priv = kzalloc(sizeof(struct hgpk_data), GFP_KERNEL);
		if (!priv)
		if (!priv) {
		err = -ENOMEM;
		goto alloc_fail;
		}

		psmouse->private = priv;

		priv->psmouse = psmouse;
		priv->powered = true;
		priv->mode = hgpk_default_mode;
		INIT_DELAYED_WORK(&priv->recalib_wq, hgpk_recalib_work);

		err = psmouse_reset(psmouse);
		err = hgpk_reset_device(psmouse, false);
		if (err)
		goto init_fail;

		@@ -531,3 +901,14 @@ int hgpk_detect(struct psmouse *psmouse, bool set_properties)

		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));
		}
		}

drivers/input/mouse/hgpk.h

+16 −0

Original line number	Diff line number	Diff line
		@@ -5,6 +5,9 @@
		#ifndef _HGPK_H
		#define _HGPK_H

		#define HGPK_GS 0xff /* The GlideSensor */
		#define HGPK_PT 0xcf /* The PenTablet */

		enum hgpk_model_t {
		HGPK_MODEL_PREA = 0x0a, /* pre-B1s */
		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 */
		};

		enum hgpk_mode {
		HGPK_MODE_MOUSE,
		HGPK_MODE_GLIDESENSOR,
		HGPK_MODE_PENTABLET,
		HGPK_MODE_INVALID
		};

		struct hgpk_data {
		struct psmouse *psmouse;
		enum hgpk_mode mode;
		bool powered;
		int count, x_tally, y_tally; /* hardware workaround stuff */
		unsigned long recalib_window;
		struct delayed_work recalib_wq;
		int abs_x, abs_y;
		};

		#define hgpk_dbg(psmouse, format, arg...) \
		@@ -33,9 +45,13 @@ struct hgpk_data {
		dev_notice(&(psmouse)->ps2dev.serio->dev, format, ## arg)

		#ifdef CONFIG_MOUSE_PS2_OLPC
		void hgpk_module_init(void);
		int hgpk_detect(struct psmouse *psmouse, bool set_properties);
		int hgpk_init(struct psmouse *psmouse);
		#else
		static inline void hgpk_module_init(void)
		{
		}
		static inline int hgpk_detect(struct psmouse *psmouse, bool set_properties)
		{
		return -ENODEV;

drivers/input/mouse/psmouse-base.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -1711,6 +1711,7 @@ static int __init psmouse_init(void)

		lifebook_module_init();
		synaptics_module_init();
		hgpk_module_init();

		kpsmoused_wq = create_singlethread_workqueue("kpsmoused");
		if (!kpsmoused_wq) {

Admin message