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
Loading
Loading
Loading
Loading
+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,