Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d9202af2 authored by Timo Teräs's avatar Timo Teräs Committed by Dmitry Torokhov
Browse files

Input: rotary_encoder - convert to devm-* api 



Use managed resource API for simplifying error paths.

Signed-off-by: default avatarTimo Teräs <timo.teras@iki.fi>
Signed-off-by: default avatarDmitry Torokhov <dmitry.torokhov@gmail.com>
parent afd2ff9b

drivers/input/misc/rotary_encoder.c

+25 −61
Original line number Original line Diff line number Diff line
@@ -211,7 +211,7 @@ static struct rotary_encoder_platform_data *rotary_encoder_parse_dt(struct devic 
	if (!of_id || !np)

	if (!of_id || !np)

		return NULL;

		return NULL;





	pdata = kzalloc(sizeof(struct rotary_encoder_platform_data),

	pdata = devm_kzalloc(dev, sizeof(struct rotary_encoder_platform_data),

			     GFP_KERNEL);

			     GFP_KERNEL);

	if (!pdata)

	if (!pdata)

		return ERR_PTR(-ENOMEM);

		return ERR_PTR(-ENOMEM);
@@ -277,12 +277,13 @@ static int rotary_encoder_probe(struct platform_device *pdev) 
		}

		}

	}

	}





	encoder = kzalloc(sizeof(struct rotary_encoder), GFP_KERNEL);

	encoder = devm_kzalloc(dev, sizeof(struct rotary_encoder), GFP_KERNEL);

	input = input_allocate_device();

	if (!encoder)

	if (!encoder || !input) {

		return -ENOMEM;

		err = -ENOMEM;



		goto exit_free_mem;

	input = devm_input_allocate_device(dev);

	}

	if (!input)

		return -ENOMEM;





	encoder->input = input;

	encoder->input = input;

	encoder->pdata = pdata;

	encoder->pdata = pdata;
@@ -301,16 +302,18 @@ static int rotary_encoder_probe(struct platform_device *pdev) 
	}

	}





	/* request the GPIOs */

	/* request the GPIOs */

	err = gpio_request_one(pdata->gpio_a, GPIOF_IN, dev_name(dev));

	err = devm_gpio_request_one(dev, pdata->gpio_a, GPIOF_IN,

				    dev_name(dev));

	if (err) {

	if (err) {

		dev_err(dev, "unable to request GPIO %d\n", pdata->gpio_a);

		dev_err(dev, "unable to request GPIO %d\n", pdata->gpio_a);

		goto exit_free_mem;

		return err;

	}

	}





	err = gpio_request_one(pdata->gpio_b, GPIOF_IN, dev_name(dev));

	err = devm_gpio_request_one(dev, pdata->gpio_b, GPIOF_IN,

				    dev_name(dev));

	if (err) {

	if (err) {

		dev_err(dev, "unable to request GPIO %d\n", pdata->gpio_b);

		dev_err(dev, "unable to request GPIO %d\n", pdata->gpio_b);

		goto exit_free_gpio_a;

		return err;

	}

	}





	encoder->irq_a = gpio_to_irq(pdata->gpio_a);

	encoder->irq_a = gpio_to_irq(pdata->gpio_a);
@@ -331,30 +334,29 @@ static int rotary_encoder_probe(struct platform_device *pdev) 
	default:

	default:

		dev_err(dev, "'%d' is not a valid steps-per-period value\n",

		dev_err(dev, "'%d' is not a valid steps-per-period value\n",

			pdata->steps_per_period);

			pdata->steps_per_period);

		err = -EINVAL;

		return -EINVAL;

		goto exit_free_gpio_b;

	}

	}





	err = request_irq(encoder->irq_a, handler,

	err = devm_request_irq(dev, encoder->irq_a, handler,

			       IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,

			       IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,

			       DRV_NAME, encoder);

			       DRV_NAME, encoder);

	if (err) {

	if (err) {

		dev_err(dev, "unable to request IRQ %d\n", encoder->irq_a);

		dev_err(dev, "unable to request IRQ %d\n", encoder->irq_a);

		goto exit_free_gpio_b;

		return err;

	}

	}





	err = request_irq(encoder->irq_b, handler,

	err = devm_request_irq(dev, encoder->irq_b, handler,

			       IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,

			       IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,

			       DRV_NAME, encoder);

			       DRV_NAME, encoder);

	if (err) {

	if (err) {

		dev_err(dev, "unable to request IRQ %d\n", encoder->irq_b);

		dev_err(dev, "unable to request IRQ %d\n", encoder->irq_b);

		goto exit_free_irq_a;

		return err;

	}

	}





	err = input_register_device(input);

	err = input_register_device(input);

	if (err) {

	if (err) {

		dev_err(dev, "failed to register input device\n");

		dev_err(dev, "failed to register input device\n");

		goto exit_free_irq_b;

		return err;

	}

	}





	device_init_wakeup(&pdev->dev, pdata->wakeup_source);

	device_init_wakeup(&pdev->dev, pdata->wakeup_source);
@@ -362,43 +364,6 @@ static int rotary_encoder_probe(struct platform_device *pdev) 
	platform_set_drvdata(pdev, encoder);

	platform_set_drvdata(pdev, encoder);





	return 0;

	return 0;



exit_free_irq_b:

	free_irq(encoder->irq_b, encoder);

exit_free_irq_a:

	free_irq(encoder->irq_a, encoder);

exit_free_gpio_b:

	gpio_free(pdata->gpio_b);

exit_free_gpio_a:

	gpio_free(pdata->gpio_a);

exit_free_mem:

	input_free_device(input);

	kfree(encoder);

	if (!dev_get_platdata(&pdev->dev))

		kfree(pdata);



	return err;

}



static int rotary_encoder_remove(struct platform_device *pdev)

{

	struct rotary_encoder *encoder = platform_get_drvdata(pdev);

	const struct rotary_encoder_platform_data *pdata = encoder->pdata;



	device_init_wakeup(&pdev->dev, false);



	free_irq(encoder->irq_a, encoder);

	free_irq(encoder->irq_b, encoder);

	gpio_free(pdata->gpio_a);

	gpio_free(pdata->gpio_b);



	input_unregister_device(encoder->input);

	kfree(encoder);



	if (!dev_get_platdata(&pdev->dev))

		kfree(pdata);



	return 0;

}

}





#ifdef CONFIG_PM_SLEEP

#ifdef CONFIG_PM_SLEEP
@@ -432,7 +397,6 @@ static SIMPLE_DEV_PM_OPS(rotary_encoder_pm_ops, 




static struct platform_driver rotary_encoder_driver = {

static struct platform_driver rotary_encoder_driver = {

	.probe		= rotary_encoder_probe,

	.probe		= rotary_encoder_probe,

	.remove		= rotary_encoder_remove,

	.driver		= {

	.driver		= {

		.name	= DRV_NAME,

		.name	= DRV_NAME,

		.pm	= &rotary_encoder_pm_ops,

		.pm	= &rotary_encoder_pm_ops,