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

Documentation/devicetree/bindings/input/gpio-keys-polled.txt

0 → 100644

+38 −0

Original line number	Original line	Diff line number	Diff line
			Device-Tree bindings for input/gpio_keys_polled.c keyboard driver

			Required properties:
			- compatible = "gpio-keys-polled";
			- poll-interval: Poll interval time in milliseconds

			Optional properties:
			- autorepeat: Boolean, Enable auto repeat feature of Linux input
			subsystem.

			Each button (key) is represented as a sub-node of "gpio-keys-polled":
			Subnode properties:

			- gpios: OF device-tree gpio specification.
			- label: Descriptive name of the key.
			- linux,code: Keycode to emit.

			Optional subnode-properties:
			- linux,input-type: Specify event type this button/key generates.
			If not specified defaults to <1> == EV_KEY.
			- debounce-interval: Debouncing interval time in milliseconds.
			If not specified defaults to 5.
			- gpio-key,wakeup: Boolean, button can wake-up the system.

			Example nodes:

			gpio_keys_polled {
			compatible = "gpio-keys-polled";
			#address-cells = <1>;
			#size-cells = <0>;
			poll-interval = <100>;
			autorepeat;
			button@21 {
			label = "GPIO Key UP";
			linux,code = <103>;
			gpios = <&gpio1 0 1>;
			};
			...

Documentation/devicetree/bindings/input/rotary-encoder.txt

0 → 100644

+36 −0

Original line number	Original line	Diff line number	Diff line
			Rotary encoder DT bindings

			Required properties:
			- gpios: a spec for two GPIOs to be used

			Optional properties:
			- linux,axis: the input subsystem axis to map to this rotary encoder.
			Defaults to 0 (ABS_X / REL_X)
			- rotary-encoder,steps: Number of steps in a full turnaround of the
			encoder. Only relevant for absolute axis. Defaults to 24 which is a
			typical value for such devices.
			- rotary-encoder,relative-axis: register a relative axis rather than an
			absolute one. Relative axis will only generate +1/-1 events on the input
			device, hence no steps need to be passed.
			- rotary-encoder,rollover: Automatic rollove when the rotary value becomes
			greater than the specified steps or smaller than 0. For absolute axis only.
			- rotary-encoder,half-period: Makes the driver work on half-period mode.

			See Documentation/input/rotary-encoder.txt for more information.

			Example:

			rotary@0 {
			compatible = "rotary-encoder";
			gpios = <&gpio 19 1>, <&gpio 20 0>; /* GPIO19 is inverted */
			linux,axis = <0>; /* REL_X */
			rotary-encoder,relative-axis;
			};

			rotary@1 {
			compatible = "rotary-encoder";
			gpios = <&gpio 21 0>, <&gpio 22 0>;
			linux,axis = <1>; /* ABS_Y */
			rotary-encoder,steps = <24>;
			rotary-encoder,rollover;
			};

drivers/input/ff-memless.c

+8 −6

Original line number	Original line	Diff line number	Diff line
	@@ -74,8 +74,10 @@ static const struct ff_envelope get_envelope(const struct ff_effect effect)
	switch (effect->type) {		switch (effect->type) {
	case FF_PERIODIC:		case FF_PERIODIC:
	return &effect->u.periodic.envelope;		return &effect->u.periodic.envelope;

	case FF_CONSTANT:		case FF_CONSTANT:
	return &effect->u.constant.envelope;		return &effect->u.constant.envelope;

	default:		default:
	return &empty_envelope;		return &empty_envelope;
	}		}

drivers/input/input.c

+26 −17

Original line number	Original line	Diff line number	Diff line
	@@ -918,18 +918,10 @@ int input_set_keycode(struct input_dev *dev,
	}		}
	EXPORT_SYMBOL(input_set_keycode);		EXPORT_SYMBOL(input_set_keycode);

	#define MATCH_BIT(bit, max) \
	for (i = 0; i < BITS_TO_LONGS(max); i++) \
	if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
	break; \
	if (i != BITS_TO_LONGS(max)) \
	continue;

	static const struct input_device_id input_match_device(struct input_handler handler,		static const struct input_device_id input_match_device(struct input_handler handler,
	struct input_dev *dev)		struct input_dev *dev)
	{		{
	const struct input_device_id *id;		const struct input_device_id *id;
	int i;

	for (id = handler->id_table; id->flags \|\| id->driver_info; id++) {		for (id = handler->id_table; id->flags \|\| id->driver_info; id++) {

	@@ -949,15 +941,32 @@ static const struct input_device_id input_match_device(struct input_handler ha
	if (id->version != dev->id.version)		if (id->version != dev->id.version)
	continue;		continue;

	MATCH_BIT(evbit, EV_MAX);		if (!bitmap_subset(id->evbit, dev->evbit, EV_MAX))
	MATCH_BIT(keybit, KEY_MAX);		continue;
	MATCH_BIT(relbit, REL_MAX);
	MATCH_BIT(absbit, ABS_MAX);		if (!bitmap_subset(id->keybit, dev->keybit, KEY_MAX))
	MATCH_BIT(mscbit, MSC_MAX);		continue;
	MATCH_BIT(ledbit, LED_MAX);
	MATCH_BIT(sndbit, SND_MAX);		if (!bitmap_subset(id->relbit, dev->relbit, REL_MAX))
	MATCH_BIT(ffbit, FF_MAX);		continue;
	MATCH_BIT(swbit, SW_MAX);
			if (!bitmap_subset(id->absbit, dev->absbit, ABS_MAX))
			continue;

			if (!bitmap_subset(id->mscbit, dev->mscbit, MSC_MAX))
			continue;

			if (!bitmap_subset(id->ledbit, dev->ledbit, LED_MAX))
			continue;

			if (!bitmap_subset(id->sndbit, dev->sndbit, SND_MAX))
			continue;

			if (!bitmap_subset(id->ffbit, dev->ffbit, FF_MAX))
			continue;

			if (!bitmap_subset(id->swbit, dev->swbit, SW_MAX))
			continue;

	if (!handler->match \|\| handler->match(handler, dev))		if (!handler->match \|\| handler->match(handler, dev))
	return id;		return id;

drivers/input/keyboard/gpio_keys.c

+88 −81

Original line number	Original line	Diff line number	Diff line
	@@ -43,11 +43,9 @@ struct gpio_button_data {
	};		};

	struct gpio_keys_drvdata {		struct gpio_keys_drvdata {
			const struct gpio_keys_platform_data *pdata;
	struct input_dev *input;		struct input_dev *input;
	struct mutex disable_lock;		struct mutex disable_lock;
	unsigned int n_buttons;
	int (enable)(struct device dev);
	void (disable)(struct device dev);
	struct gpio_button_data data[0];		struct gpio_button_data data[0];
	};		};

	@@ -171,7 +169,7 @@ static ssize_t gpio_keys_attr_show_helper(struct gpio_keys_drvdata *ddata,
	if (!bits)		if (!bits)
	return -ENOMEM;		return -ENOMEM;

	for (i = 0; i < ddata->n_buttons; i++) {		for (i = 0; i < ddata->pdata->nbuttons; i++) {
	struct gpio_button_data *bdata = &ddata->data[i];		struct gpio_button_data *bdata = &ddata->data[i];

	if (bdata->button->type != type)		if (bdata->button->type != type)
	@@ -219,7 +217,7 @@ static ssize_t gpio_keys_attr_store_helper(struct gpio_keys_drvdata *ddata,
	goto out;		goto out;

	/* First validate */		/* First validate */
	for (i = 0; i < ddata->n_buttons; i++) {		for (i = 0; i < ddata->pdata->nbuttons; i++) {
	struct gpio_button_data *bdata = &ddata->data[i];		struct gpio_button_data *bdata = &ddata->data[i];

	if (bdata->button->type != type)		if (bdata->button->type != type)
	@@ -234,7 +232,7 @@ static ssize_t gpio_keys_attr_store_helper(struct gpio_keys_drvdata *ddata,

	mutex_lock(&ddata->disable_lock);		mutex_lock(&ddata->disable_lock);

	for (i = 0; i < ddata->n_buttons; i++) {		for (i = 0; i < ddata->pdata->nbuttons; i++) {
	struct gpio_button_data *bdata = &ddata->data[i];		struct gpio_button_data *bdata = &ddata->data[i];

	if (bdata->button->type != type)		if (bdata->button->type != type)
	@@ -346,6 +344,9 @@ static void gpio_keys_gpio_work_func(struct work_struct *work)
	container_of(work, struct gpio_button_data, work);		container_of(work, struct gpio_button_data, work);

	gpio_keys_gpio_report_event(bdata);		gpio_keys_gpio_report_event(bdata);

			if (bdata->button->wakeup)
			pm_relax(bdata->input->dev.parent);
	}		}

	static void gpio_keys_gpio_timer(unsigned long _data)		static void gpio_keys_gpio_timer(unsigned long _data)
	@@ -361,6 +362,8 @@ static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id)

	BUG_ON(irq != bdata->irq);		BUG_ON(irq != bdata->irq);

			if (bdata->button->wakeup)
			pm_stay_awake(bdata->input->dev.parent);
	if (bdata->timer_debounce)		if (bdata->timer_debounce)
	mod_timer(&bdata->timer,		mod_timer(&bdata->timer,
	jiffies + msecs_to_jiffies(bdata->timer_debounce));		jiffies + msecs_to_jiffies(bdata->timer_debounce));
	@@ -397,6 +400,9 @@ static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id)
	spin_lock_irqsave(&bdata->lock, flags);		spin_lock_irqsave(&bdata->lock, flags);

	if (!bdata->key_pressed) {		if (!bdata->key_pressed) {
			if (bdata->button->wakeup)
			pm_wakeup_event(bdata->input->dev.parent, 0);

	input_event(input, EV_KEY, button->code, 1);		input_event(input, EV_KEY, button->code, 1);
	input_sync(input);		input_sync(input);

	@@ -523,56 +529,64 @@ fail:
	static int gpio_keys_open(struct input_dev *input)		static int gpio_keys_open(struct input_dev *input)
	{		{
	struct gpio_keys_drvdata *ddata = input_get_drvdata(input);		struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
			const struct gpio_keys_platform_data *pdata = ddata->pdata;

	return ddata->enable ? ddata->enable(input->dev.parent) : 0;		return pdata->enable ? pdata->enable(input->dev.parent) : 0;
	}		}

	static void gpio_keys_close(struct input_dev *input)		static void gpio_keys_close(struct input_dev *input)
	{		{
	struct gpio_keys_drvdata *ddata = input_get_drvdata(input);		struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
			const struct gpio_keys_platform_data *pdata = ddata->pdata;

	if (ddata->disable)		if (pdata->disable)
	ddata->disable(input->dev.parent);		pdata->disable(input->dev.parent);
	}		}

	/*		/*
	* Handlers for alternative sources of platform_data		* Handlers for alternative sources of platform_data
	*/		*/

	#ifdef CONFIG_OF		#ifdef CONFIG_OF
	/*		/*
	* Translate OpenFirmware node properties into platform_data		* Translate OpenFirmware node properties into platform_data
	*/		*/
	static int gpio_keys_get_devtree_pdata(struct device *dev,		static struct gpio_keys_platform_data * __devinit
	struct gpio_keys_platform_data *pdata)		gpio_keys_get_devtree_pdata(struct device *dev)
	{		{
	struct device_node node, pp;		struct device_node node, pp;
			struct gpio_keys_platform_data *pdata;
			struct gpio_keys_button *button;
			int error;
			int nbuttons;
	int i;		int i;
	struct gpio_keys_button *buttons;
	u32 reg;

	node = dev->of_node;		node = dev->of_node;
	if (node == NULL)		if (!node) {
	return -ENODEV;		error = -ENODEV;
			goto err_out;
	memset(pdata, 0, sizeof *pdata);		}

	pdata->rep = !!of_get_property(node, "autorepeat", NULL);		nbuttons = of_get_child_count(node);
			if (nbuttons == 0) {
			error = -ENODEV;
			goto err_out;
			}

	/* First count the subnodes */		pdata = kzalloc(sizeof(pdata) + nbuttons (sizeof *button),
	pp = NULL;		GFP_KERNEL);
	while ((pp = of_get_next_child(node, pp)))		if (!pdata) {
	pdata->nbuttons++;		error = -ENOMEM;
			goto err_out;
			}

	if (pdata->nbuttons == 0)		pdata->buttons = (struct gpio_keys_button *)(pdata + 1);
	return -ENODEV;		pdata->nbuttons = nbuttons;

	buttons = kzalloc(pdata->nbuttons * (sizeof *buttons), GFP_KERNEL);		pdata->rep = !!of_get_property(node, "autorepeat", NULL);
	if (!buttons)
	return -ENOMEM;

	pp = NULL;
	i = 0;		i = 0;
	while ((pp = of_get_next_child(node, pp))) {		for_each_child_of_node(node, pp) {
	enum of_gpio_flags flags;		enum of_gpio_flags flags;

	if (!of_find_property(pp, "gpios", NULL)) {		if (!of_find_property(pp, "gpios", NULL)) {
	@@ -580,39 +594,42 @@ static int gpio_keys_get_devtree_pdata(struct device *dev,
	dev_warn(dev, "Found button without gpios\n");		dev_warn(dev, "Found button without gpios\n");
	continue;		continue;
	}		}
	buttons[i].gpio = of_get_gpio_flags(pp, 0, &flags);
	buttons[i].active_low = flags & OF_GPIO_ACTIVE_LOW;

	if (of_property_read_u32(pp, "linux,code", &reg)) {		button = &pdata->buttons[i++];
	dev_err(dev, "Button without keycode: 0x%x\n", buttons[i].gpio);
	goto out_fail;
	}
	buttons[i].code = reg;

	buttons[i].desc = of_get_property(pp, "label", NULL);		button->gpio = of_get_gpio_flags(pp, 0, &flags);
			button->active_low = flags & OF_GPIO_ACTIVE_LOW;

	if (of_property_read_u32(pp, "linux,input-type", &reg) == 0)		if (of_property_read_u32(pp, "linux,code", &button->code)) {
	buttons[i].type = reg;		dev_err(dev, "Button without keycode: 0x%x\n",
	else		button->gpio);
	buttons[i].type = EV_KEY;		error = -EINVAL;
			goto err_free_pdata;
			}

	buttons[i].wakeup = !!of_get_property(pp, "gpio-key,wakeup", NULL);		button->desc = of_get_property(pp, "label", NULL);

	if (of_property_read_u32(pp, "debounce-interval", &reg) == 0)		if (of_property_read_u32(pp, "linux,input-type", &button->type))
	buttons[i].debounce_interval = reg;		button->type = EV_KEY;
	else
	buttons[i].debounce_interval = 5;		button->wakeup = !!of_get_property(pp, "gpio-key,wakeup", NULL);

	i++;		if (of_property_read_u32(pp, "debounce-interval",
			&button->debounce_interval))
			button->debounce_interval = 5;
	}		}

	pdata->buttons = buttons;		if (pdata->nbuttons == 0) {
			error = -EINVAL;
			goto err_free_pdata;
			}

	return 0;		return pdata;

	out_fail:		err_free_pdata:
	kfree(buttons);		kfree(pdata);
	return -ENODEV;		err_out:
			return ERR_PTR(error);
	}		}

	static struct of_device_id gpio_keys_of_match[] = {		static struct of_device_id gpio_keys_of_match[] = {
	@@ -623,14 +640,12 @@ MODULE_DEVICE_TABLE(of, gpio_keys_of_match);

	#else		#else

	static int gpio_keys_get_devtree_pdata(struct device *dev,		static inline struct gpio_keys_platform_data *
	struct gpio_keys_platform_data *altp)		gpio_keys_get_devtree_pdata(struct device *dev)
	{		{
	return -ENODEV;		return ERR_PTR(-ENODEV);
	}		}

	#define gpio_keys_of_match NULL

	#endif		#endif

	static void gpio_remove_key(struct gpio_button_data *bdata)		static void gpio_remove_key(struct gpio_button_data *bdata)
	@@ -645,19 +660,17 @@ static void gpio_remove_key(struct gpio_button_data *bdata)

	static int __devinit gpio_keys_probe(struct platform_device *pdev)		static int __devinit gpio_keys_probe(struct platform_device *pdev)
	{		{
	const struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
	struct gpio_keys_drvdata *ddata;
	struct device *dev = &pdev->dev;		struct device *dev = &pdev->dev;
	struct gpio_keys_platform_data alt_pdata;		const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
			struct gpio_keys_drvdata *ddata;
	struct input_dev *input;		struct input_dev *input;
	int i, error;		int i, error;
	int wakeup = 0;		int wakeup = 0;

	if (!pdata) {		if (!pdata) {
	error = gpio_keys_get_devtree_pdata(dev, &alt_pdata);		pdata = gpio_keys_get_devtree_pdata(dev);
	if (error)		if (IS_ERR(pdata))
	return error;		return PTR_ERR(pdata);
	pdata = &alt_pdata;
	}		}

	ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +		ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
	@@ -670,10 +683,8 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
	goto fail1;		goto fail1;
	}		}

			ddata->pdata = pdata;
	ddata->input = input;		ddata->input = input;
	ddata->n_buttons = pdata->nbuttons;
	ddata->enable = pdata->enable;
	ddata->disable = pdata->disable;
	mutex_init(&ddata->disable_lock);		mutex_init(&ddata->disable_lock);

	platform_set_drvdata(pdev, ddata);		platform_set_drvdata(pdev, ddata);
	@@ -742,9 +753,9 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
	fail1:		fail1:
	input_free_device(input);		input_free_device(input);
	kfree(ddata);		kfree(ddata);
	/* If we have no platform_data, we allocated buttons dynamically. */		/* If we have no platform data, we allocated pdata dynamically. */
	if (!pdev->dev.platform_data)		if (!dev_get_platdata(&pdev->dev))
	kfree(pdata->buttons);		kfree(pdata);

	return error;		return error;
	}		}
	@@ -759,18 +770,14 @@ static int __devexit gpio_keys_remove(struct platform_device *pdev)

	device_init_wakeup(&pdev->dev, 0);		device_init_wakeup(&pdev->dev, 0);

	for (i = 0; i < ddata->n_buttons; i++)		for (i = 0; i < ddata->pdata->nbuttons; i++)
	gpio_remove_key(&ddata->data[i]);		gpio_remove_key(&ddata->data[i]);

	input_unregister_device(input);		input_unregister_device(input);

	/*		/* If we have no platform data, we allocated pdata dynamically. */
	* If we had no platform_data, we allocated buttons dynamically, and		if (!dev_get_platdata(&pdev->dev))
	* must free them here. ddata->data[0].button is the pointer to the		kfree(ddata->pdata);
	* beginning of the allocated array.
	*/
	if (!pdev->dev.platform_data)
	kfree(ddata->data[0].button);

	kfree(ddata);		kfree(ddata);

	@@ -784,7 +791,7 @@ static int gpio_keys_suspend(struct device *dev)
	int i;		int i;

	if (device_may_wakeup(dev)) {		if (device_may_wakeup(dev)) {
	for (i = 0; i < ddata->n_buttons; i++) {		for (i = 0; i < ddata->pdata->nbuttons; i++) {
	struct gpio_button_data *bdata = &ddata->data[i];		struct gpio_button_data *bdata = &ddata->data[i];
	if (bdata->button->wakeup)		if (bdata->button->wakeup)
	enable_irq_wake(bdata->irq);		enable_irq_wake(bdata->irq);
	@@ -799,7 +806,7 @@ static int gpio_keys_resume(struct device *dev)
	struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);		struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
	int i;		int i;

	for (i = 0; i < ddata->n_buttons; i++) {		for (i = 0; i < ddata->pdata->nbuttons; i++) {
	struct gpio_button_data *bdata = &ddata->data[i];		struct gpio_button_data *bdata = &ddata->data[i];
	if (bdata->button->wakeup && device_may_wakeup(dev))		if (bdata->button->wakeup && device_may_wakeup(dev))
	disable_irq_wake(bdata->irq);		disable_irq_wake(bdata->irq);
	@@ -822,7 +829,7 @@ static struct platform_driver gpio_keys_device_driver = {
	.name = "gpio-keys",		.name = "gpio-keys",
	.owner = THIS_MODULE,		.owner = THIS_MODULE,
	.pm = &gpio_keys_pm_ops,		.pm = &gpio_keys_pm_ops,
	.of_match_table = gpio_keys_of_match,		.of_match_table = of_match_ptr(gpio_keys_of_match),
	}		}
	};		};

Admin message