Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input (d638d499) · Commits · 戴 / test

drivers/input/input.c

+4 −25

Original line number	Diff line number	Diff line
		@@ -471,37 +471,16 @@ static unsigned int input_proc_devices_poll(struct file file, poll_table wait)
		return 0;
		}

		static struct list_head list_get_nth_element(struct list_head list, loff_t *pos)
		{
		struct list_head *node;
		loff_t i = 0;

		list_for_each(node, list)
		if (i++ == *pos)
		return node;

		return NULL;
		}

		static struct list_head list_get_next_element(struct list_head list, struct list_head element, loff_t pos)
		{
		if (element->next == list)
		return NULL;

		++(*pos);
		return element->next;
		}

		static void input_devices_seq_start(struct seq_file seq, loff_t *pos)
		{
		/* acquire lock here ... Yes, we do need locking, I knowi, I know... */

		return list_get_nth_element(&input_dev_list, pos);
		return seq_list_start(&input_dev_list, *pos);
		}

		static void input_devices_seq_next(struct seq_file seq, void v, loff_t pos)
		{
		return list_get_next_element(&input_dev_list, v, pos);
		return seq_list_next(v, &input_dev_list, pos);
		}

		static void input_devices_seq_stop(struct seq_file seq, void v)
		@@ -592,13 +571,13 @@ static void input_handlers_seq_start(struct seq_file seq, loff_t *pos)
		{
		/* acquire lock here ... Yes, we do need locking, I knowi, I know... */
		seq->private = (void )(unsigned long)pos;
		return list_get_nth_element(&input_handler_list, pos);
		return seq_list_start(&input_handler_list, *pos);
		}

		static void input_handlers_seq_next(struct seq_file seq, void v, loff_t pos)
		{
		seq->private = (void )(unsigned long)(pos + 1);
		return list_get_next_element(&input_handler_list, v, pos);
		return seq_list_next(v, &input_handler_list, pos);
		}

		static void input_handlers_seq_stop(struct seq_file seq, void v)

drivers/input/joystick/Kconfig

+7 −0

Original line number	Diff line number	Diff line
		@@ -275,4 +275,11 @@ config JOYSTICK_XPAD_FF
		---help---
		Say Y here if you want to take advantage of xbox 360 rumble features.

		config JOYSTICK_XPAD_LEDS
		bool "LED Support for Xbox360 controller 'BigX' LED"
		depends on LEDS_CLASS && JOYSTICK_XPAD
		---help---
		This option enables support for the LED which surrounds the Big X on
		XBox 360 controller.

		endif

drivers/input/joystick/xpad.c

+148 −42

Original line number	Diff line number	Diff line
		@@ -191,13 +191,18 @@ struct usb_xpad {
		unsigned char idata; / input data */
		dma_addr_t idata_dma;

		#ifdef CONFIG_JOYSTICK_XPAD_FF
		#if defined(CONFIG_JOYSTICK_XPAD_FF) \|\| defined(CONFIG_JOYSTICK_XPAD_LEDS)
		struct urb irq_out; / urb for interrupt out report */
		unsigned char odata; / output data */
		dma_addr_t odata_dma;
		struct mutex odata_mutex;
		#endif

		#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
		struct xpad_led *led;
		#endif

		char phys[65]; /* physical device path */
		char phys[64]; /* physical device path */

		int dpad_mapping; /* map d-pad to buttons or to axes */
		int xtype; /* type of xbox device */
		@@ -349,7 +354,7 @@ exit:
		__FUNCTION__, retval);
		}

		#ifdef CONFIG_JOYSTICK_XPAD_FF
		#if defined(CONFIG_JOYSTICK_XPAD_FF) \|\| defined(CONFIG_JOYSTICK_XPAD_LEDS)
		static void xpad_irq_out(struct urb *urb)
		{
		int retval;
		@@ -376,29 +381,7 @@ exit:
		__FUNCTION__, retval);
		}

		static int xpad_play_effect(struct input_dev dev, void data,
		struct ff_effect *effect)
		{
		struct usb_xpad *xpad = input_get_drvdata(dev);

		if (effect->type == FF_RUMBLE) {
		__u16 strong = effect->u.rumble.strong_magnitude;
		__u16 weak = effect->u.rumble.weak_magnitude;
		xpad->odata[0] = 0x00;
		xpad->odata[1] = 0x08;
		xpad->odata[2] = 0x00;
		xpad->odata[3] = strong / 256;
		xpad->odata[4] = weak / 256;
		xpad->odata[5] = 0x00;
		xpad->odata[6] = 0x00;
		xpad->odata[7] = 0x00;
		usb_submit_urb(xpad->irq_out, GFP_KERNEL);
		}

		return 0;
		}

		static int xpad_init_ff(struct usb_interface intf, struct usb_xpad xpad)
		static int xpad_init_output(struct usb_interface intf, struct usb_xpad xpad)
		{
		struct usb_endpoint_descriptor *ep_irq_out;
		int error = -ENOMEM;
		@@ -411,6 +394,8 @@ static int xpad_init_ff(struct usb_interface intf, struct usb_xpad xpad)
		if (!xpad->odata)
		goto fail1;

		mutex_init(&xpad->odata_mutex);

		xpad->irq_out = usb_alloc_urb(0, GFP_KERNEL);
		if (!xpad->irq_out)
		goto fail2;
		@@ -423,25 +408,19 @@ static int xpad_init_ff(struct usb_interface intf, struct usb_xpad xpad)
		xpad->irq_out->transfer_dma = xpad->odata_dma;
		xpad->irq_out->transfer_flags \|= URB_NO_TRANSFER_DMA_MAP;

		input_set_capability(xpad->dev, EV_FF, FF_RUMBLE);

		error = input_ff_create_memless(xpad->dev, NULL, xpad_play_effect);
		if (error)
		goto fail2;

		return 0;

		fail2: usb_buffer_free(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma);
		fail1: return error;
		}

		static void xpad_stop_ff(struct usb_xpad *xpad)
		static void xpad_stop_output(struct usb_xpad *xpad)
		{
		if (xpad->xtype == XTYPE_XBOX360)
		usb_kill_urb(xpad->irq_out);
		}

		static void xpad_deinit_ff(struct usb_xpad *xpad)
		static void xpad_deinit_output(struct usb_xpad *xpad)
		{
		if (xpad->xtype == XTYPE_XBOX360) {
		usb_free_urb(xpad->irq_out);
		@@ -449,13 +428,130 @@ static void xpad_deinit_ff(struct usb_xpad *xpad)
		xpad->odata, xpad->odata_dma);
		}
		}
		#else
		static int xpad_init_output(struct usb_interface intf, struct usb_xpad xpad) { return 0; }
		static void xpad_deinit_output(struct usb_xpad *xpad) {}
		static void xpad_stop_output(struct usb_xpad *xpad) {}
		#endif

		#ifdef CONFIG_JOYSTICK_XPAD_FF
		static int xpad_play_effect(struct input_dev dev, void data,
		struct ff_effect *effect)
		{
		struct usb_xpad *xpad = input_get_drvdata(dev);

		if (effect->type == FF_RUMBLE) {
		__u16 strong = effect->u.rumble.strong_magnitude;
		__u16 weak = effect->u.rumble.weak_magnitude;
		xpad->odata[0] = 0x00;
		xpad->odata[1] = 0x08;
		xpad->odata[2] = 0x00;
		xpad->odata[3] = strong / 256;
		xpad->odata[4] = weak / 256;
		xpad->odata[5] = 0x00;
		xpad->odata[6] = 0x00;
		xpad->odata[7] = 0x00;
		usb_submit_urb(xpad->irq_out, GFP_KERNEL);
		}

		return 0;
		}

		static int xpad_init_ff(struct usb_xpad *xpad)
		{
		input_set_capability(xpad->dev, EV_FF, FF_RUMBLE);

		return input_ff_create_memless(xpad->dev, NULL, xpad_play_effect);
		}

		#else
		static int xpad_init_ff(struct usb_xpad *xpad) { return 0; }
		#endif

		#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
		#include <linux/leds.h>

		struct xpad_led {
		char name[16];
		struct led_classdev led_cdev;
		struct usb_xpad *xpad;
		};

		static void xpad_send_led_command(struct usb_xpad *xpad, int command)
		{
		if (command >= 0 && command < 14) {
		mutex_lock(&xpad->odata_mutex);
		xpad->odata[0] = 0x01;
		xpad->odata[1] = 0x03;
		xpad->odata[2] = command;
		usb_submit_urb(xpad->irq_out, GFP_KERNEL);
		mutex_unlock(&xpad->odata_mutex);
		}
		}

		static void xpad_led_set(struct led_classdev *led_cdev,
		enum led_brightness value)
		{
		struct xpad_led *xpad_led = container_of(led_cdev,
		struct xpad_led, led_cdev);

		xpad_send_led_command(xpad_led->xpad, value);
		}

		static int xpad_led_probe(struct usb_xpad *xpad)
		{
		static atomic_t led_seq = ATOMIC_INIT(0);
		long led_no;
		struct xpad_led *led;
		struct led_classdev *led_cdev;
		int error;

		if (xpad->xtype != XTYPE_XBOX360)
		return 0;

		xpad->led = led = kzalloc(sizeof(struct xpad_led), GFP_KERNEL);
		if (!led)
		return -ENOMEM;

		led_no = (long)atomic_inc_return(&led_seq) - 1;

		snprintf(led->name, sizeof(led->name), "xpad%ld", led_no);
		led->xpad = xpad;

		led_cdev = &led->led_cdev;
		led_cdev->name = led->name;
		led_cdev->brightness_set = xpad_led_set;

		error = led_classdev_register(&xpad->udev->dev, led_cdev);
		if (error) {
		kfree(led);
		xpad->led = NULL;
		return error;
		}

		/*
		* Light up the segment corresponding to controller number
		*/
		xpad_send_led_command(xpad, (led_no % 4) + 2);

		return 0;
		}

		static void xpad_led_disconnect(struct usb_xpad *xpad)
		{
		struct xpad_led *xpad_led = xpad->led;

		if (xpad_led) {
		led_classdev_unregister(&xpad_led->led_cdev);
		kfree(xpad_led->name);
		}
		}
		#else
		static int xpad_init_ff(struct usb_interface intf, struct usb_xpad xpad) { return 0; }
		static void xpad_stop_ff(struct usb_xpad *xpad) { }
		static void xpad_deinit_ff(struct usb_xpad *xpad) { }
		static int xpad_led_probe(struct usb_xpad *xpad) { return 0; }
		static void xpad_led_disconnect(struct usb_xpad *xpad) { }
		#endif


		static int xpad_open(struct input_dev *dev)
		{
		struct usb_xpad *xpad = input_get_drvdata(dev);
		@@ -472,7 +568,7 @@ static void xpad_close(struct input_dev *dev)
		struct usb_xpad *xpad = input_get_drvdata(dev);

		usb_kill_urb(xpad->irq_in);
		xpad_stop_ff(xpad);
		xpad_stop_output(xpad);
		}

		static void xpad_set_up_abs(struct input_dev *input_dev, signed short abs)
		@@ -564,10 +660,18 @@ static int xpad_probe(struct usb_interface intf, const struct usb_device_id id
		for (i = 0; xpad_abs_pad[i] >= 0; i++)
		xpad_set_up_abs(input_dev, xpad_abs_pad[i]);

		error = xpad_init_ff(intf, xpad);
		error = xpad_init_output(intf, xpad);
		if (error)
		goto fail2;

		error = xpad_init_ff(xpad);
		if (error)
		goto fail3;

		error = xpad_led_probe(xpad);
		if (error)
		goto fail3;

		ep_irq_in = &intf->cur_altsetting->endpoint[0].desc;
		usb_fill_int_urb(xpad->irq_in, udev,
		usb_rcvintpipe(udev, ep_irq_in->bEndpointAddress),
		@@ -578,12 +682,13 @@ static int xpad_probe(struct usb_interface intf, const struct usb_device_id id

		error = input_register_device(xpad->dev);
		if (error)
		goto fail3;
		goto fail4;

		usb_set_intfdata(intf, xpad);
		return 0;

		fail3: usb_free_urb(xpad->irq_in);
		fail4: usb_free_urb(xpad->irq_in);
		fail3: xpad_deinit_output(xpad);
		fail2: usb_buffer_free(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma);
		fail1: input_free_device(input_dev);
		kfree(xpad);
		@@ -597,8 +702,9 @@ static void xpad_disconnect(struct usb_interface *intf)

		usb_set_intfdata(intf, NULL);
		if (xpad) {
		xpad_led_disconnect(xpad);
		input_unregister_device(xpad->dev);
		xpad_deinit_ff(xpad);
		xpad_deinit_output(xpad);
		usb_free_urb(xpad->irq_in);
		usb_buffer_free(xpad->udev, XPAD_PKT_LEN,
		xpad->idata, xpad->idata_dma);

drivers/input/mouse/appletouch.c

+74 −37

Original line number	Diff line number	Diff line
		@@ -155,6 +155,8 @@ struct atp {
		int xy_acc[ATP_XSENSORS + ATP_YSENSORS];
		int overflowwarn; /* overflow warning printed? */
		int datalen; /* size of an USB urb transfer */
		int idlecount; /* number of empty packets */
		struct work_struct work;
		};

		#define dbg_dump(msg, tab) \
		@@ -208,6 +210,55 @@ static inline int atp_is_geyser_3(struct atp *dev)
		(productId == GEYSER4_JIS_PRODUCT_ID);
		}

		/*
		* By default Geyser 3 device sends standard USB HID mouse
		* packets (Report ID 2). This code changes device mode, so it
		* sends raw sensor reports (Report ID 5).
		*/
		static int atp_geyser3_init(struct usb_device *udev)
		{
		char data[8];
		int size;

		size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
		ATP_GEYSER3_MODE_READ_REQUEST_ID,
		USB_DIR_IN \| USB_TYPE_CLASS \| USB_RECIP_INTERFACE,
		ATP_GEYSER3_MODE_REQUEST_VALUE,
		ATP_GEYSER3_MODE_REQUEST_INDEX, &data, 8, 5000);

		if (size != 8) {
		err("Could not do mode read request from device"
		" (Geyser 3 mode)");
		return -EIO;
		}

		/* Apply the mode switch */
		data[0] = ATP_GEYSER3_MODE_VENDOR_VALUE;

		size = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
		ATP_GEYSER3_MODE_WRITE_REQUEST_ID,
		USB_DIR_OUT \| USB_TYPE_CLASS \| USB_RECIP_INTERFACE,
		ATP_GEYSER3_MODE_REQUEST_VALUE,
		ATP_GEYSER3_MODE_REQUEST_INDEX, &data, 8, 5000);

		if (size != 8) {
		err("Could not do mode write request to device"
		" (Geyser 3 mode)");
		return -EIO;
		}
		return 0;
		}

		/* Reinitialise the device if it's a geyser 3 */
		static void atp_reinit(struct work_struct *work)
		{
		struct atp *dev = container_of(work, struct atp, work);
		struct usb_device *udev = dev->udev;

		dev->idlecount = 0;
		atp_geyser3_init(udev);
		}

		static int atp_calculate_abs(int *xy_sensors, int nb_sensors, int fact,
		int z, int fingers)
		{
		@@ -439,8 +490,8 @@ static void atp_complete(struct urb* urb)
		}
		dev->x_old = x;
		dev->y_old = y;
		}
		else if (!x && !y) {

		} else if (!x && !y) {

		dev->x_old = dev->y_old = -1;
		input_report_key(dev->input, BTN_TOUCH, 0);
		@@ -449,11 +500,21 @@ static void atp_complete(struct urb* urb)

		/* reset the accumulator on release */
		memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
		}

		input_report_key(dev->input, BTN_LEFT,
		!!dev->data[dev->datalen - 1]);
		/* Geyser 3 will continue to send packets continually after
		the first touch unless reinitialised. Do so if it's been
		idle for a while in order to avoid waking the kernel up
		several hundred times a second */
		if (atp_is_geyser_3(dev)) {
		dev->idlecount++;
		if (dev->idlecount == 10) {
		dev->valid = 0;
		schedule_work(&dev->work);
		}
		}
		}

		input_report_key(dev->input, BTN_LEFT, dev->data[dev->datalen - 1] & 1);
		input_sync(dev->input);

		exit:
		@@ -480,6 +541,7 @@ static void atp_close(struct input_dev *input)
		struct atp *dev = input_get_drvdata(input);

		usb_kill_urb(dev->urb);
		cancel_work_sync(&dev->work);
		dev->open = 0;
		}

		@@ -528,40 +590,10 @@ static int atp_probe(struct usb_interface iface, const struct usb_device_id id
		dev->datalen = 81;

		if (atp_is_geyser_3(dev)) {
		/*
		* By default Geyser 3 device sends standard USB HID mouse
		* packets (Report ID 2). This code changes device mode, so it
		* sends raw sensor reports (Report ID 5).
		*/
		char data[8];
		int size;

		size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
		ATP_GEYSER3_MODE_READ_REQUEST_ID,
		USB_DIR_IN \| USB_TYPE_CLASS \| USB_RECIP_INTERFACE,
		ATP_GEYSER3_MODE_REQUEST_VALUE,
		ATP_GEYSER3_MODE_REQUEST_INDEX, &data, 8, 5000);

		if (size != 8) {
		err("Could not do mode read request from device"
		" (Geyser 3 mode)");
		/* switch to raw sensor mode */
		if (atp_geyser3_init(udev))
		goto err_free_devs;
		}

		/* Apply the mode switch */
		data[0] = ATP_GEYSER3_MODE_VENDOR_VALUE;

		size = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
		ATP_GEYSER3_MODE_WRITE_REQUEST_ID,
		USB_DIR_OUT \| USB_TYPE_CLASS \| USB_RECIP_INTERFACE,
		ATP_GEYSER3_MODE_REQUEST_VALUE,
		ATP_GEYSER3_MODE_REQUEST_INDEX, &data, 8, 5000);

		if (size != 8) {
		err("Could not do mode write request to device"
		" (Geyser 3 mode)");
		goto err_free_devs;
		}
		printk("appletouch Geyser 3 inited.\n");
		}

		@@ -636,6 +668,8 @@ static int atp_probe(struct usb_interface iface, const struct usb_device_id id
		/* save our data pointer in this interface device */
		usb_set_intfdata(iface, dev);

		INIT_WORK(&dev->work, atp_reinit);

		return 0;

		err_free_buffer:
		@@ -669,14 +703,17 @@ static void atp_disconnect(struct usb_interface *iface)
		static int atp_suspend(struct usb_interface *iface, pm_message_t message)
		{
		struct atp *dev = usb_get_intfdata(iface);

		usb_kill_urb(dev->urb);
		dev->valid = 0;

		return 0;
		}

		static int atp_resume(struct usb_interface *iface)
		{
		struct atp *dev = usb_get_intfdata(iface);

		if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
		return -EIO;

drivers/input/mouse/lifebook.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -109,7 +109,7 @@ static psmouse_ret_t lifebook_process_byte(struct psmouse *psmouse)
		{
		struct lifebook_data *priv = psmouse->private;
		struct input_dev *dev1 = psmouse->dev;
		struct input_dev *dev2 = priv->dev2;
		struct input_dev *dev2 = priv ? priv->dev2 : NULL;
		unsigned char *packet = psmouse->packet;
		int relative_packet = packet[0] & 0x08;

Admin message