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

Commit caeb1aae authored by Dmitry Torokhov's avatar Dmitry Torokhov
Browse files

Input: bu21013_ts - convert to using managed resources 



This allows trimming error unwinding and device removal handling.

Tested-by: default avatarLinus Walleij <linus.walleij@linaro.org>
Signed-off-by: default avatarDmitry Torokhov <dmitry.torokhov@gmail.com>
parent a5ee351d

drivers/input/touchscreen/bu21013_ts.c

+84 −98
Original line number Diff line number Diff line
@@ -137,7 +137,6 @@ 
/**

 * struct bu21013_ts - touch panel data structure

 * @client: pointer to the i2c client

 * @wait: variable to wait_queue_head_t structure

 * @touch_stopped: touch stop flag

 * @chip: pointer to the touch panel controller

 * @in_dev: pointer to the input device structure
@@ -149,7 +148,6 @@ 
 */

struct bu21013_ts {

	struct i2c_client *client;

	wait_queue_head_t wait;

	const struct bu21013_platform_device *chip;

	struct input_dev *in_dev;

	struct regulator *regulator;
@@ -242,11 +240,13 @@ static irqreturn_t bu21013_gpio_irq(int irq, void *device_data) 
			break;

		}



		if (unlikely(ts->touch_stopped))

			break;



		keep_polling = gpiod_get_value(ts->int_gpiod);

		if (keep_polling)

			wait_event_timeout(ts->wait, ts->touch_stopped,

					   msecs_to_jiffies(2));

	} while (keep_polling && !ts->touch_stopped);

			usleep_range(2000, 2500);

	} while (keep_polling);



	return IRQ_HANDLED;

}
@@ -388,20 +388,6 @@ static int bu21013_init_chip(struct bu21013_ts *ts) 
	return 0;

}



/**

 * bu21013_free_irq() - frees IRQ registered for touchscreen

 * @ts: device structure pointer

 *

 * This function signals interrupt thread to stop processing and

 * frees interrupt.

 */

static void bu21013_free_irq(struct bu21013_ts *ts)

{

	ts->touch_stopped = true;

	wake_up(&ts->wait);

	free_irq(ts->irq, ts);

}



#ifdef CONFIG_OF

static const struct bu21013_platform_device *

bu21013_parse_dt(struct device *dev)
@@ -439,6 +425,20 @@ bu21013_parse_dt(struct device *dev) 
}

#endif



static void bu21013_power_off(void *_ts)

{

	struct bu21013_ts *ts = _ts;



	regulator_disable(ts->regulator);

}



static void bu21013_disable_chip(void *_ts)

{

	struct bu21013_ts *ts = _ts;



	gpiod_set_value(ts->cs_gpiod, 0);

}



static int bu21013_probe(struct i2c_client *client,

			 const struct i2c_device_id *id)

{
@@ -460,133 +460,119 @@ static int bu21013_probe(struct i2c_client *client, 
			return PTR_ERR(pdata);

	}



	ts = kzalloc(sizeof(*ts), GFP_KERNEL);

	in_dev = input_allocate_device();

	if (!ts || !in_dev) {

	ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL);

	if (!ts)

		return -ENOMEM;



	ts->chip = pdata;

	ts->client = client;



	in_dev = devm_input_allocate_device(&client->dev);

	if (!in_dev) {

		dev_err(&client->dev, "device memory alloc failed\n");

		error = -ENOMEM;

		goto err_free_mem;

		return -ENOMEM;

	}

	ts->in_dev = in_dev;



	/* Named "INT" on the chip, DT binding is "touch" */

	ts->int_gpiod = gpiod_get(&client->dev, "touch", GPIOD_IN);

	error = PTR_ERR_OR_ZERO(ts->int_gpiod);

	if (error) {

		if (error != -EPROBE_DEFER)

			dev_err(&client->dev, "failed to get INT GPIO\n");

		goto err_free_mem;

	}

	gpiod_set_consumer_name(ts->int_gpiod, "BU21013 INT");

	/* register the device to input subsystem */

	in_dev->name = DRIVER_TP;

	in_dev->id.bustype = BUS_I2C;



	ts->in_dev = in_dev;

	ts->chip = pdata;

	ts->client = client;

	ts->irq = gpiod_to_irq(ts->int_gpiod);

	__set_bit(EV_SYN, in_dev->evbit);

	__set_bit(EV_KEY, in_dev->evbit);

	__set_bit(EV_ABS, in_dev->evbit);



	input_set_abs_params(in_dev, ABS_MT_POSITION_X,

			     0, pdata->touch_x_max, 0, 0);

	input_set_abs_params(in_dev, ABS_MT_POSITION_Y,

			     0, pdata->touch_y_max, 0, 0);

	input_set_drvdata(in_dev, ts);



	ts->regulator = regulator_get(&client->dev, "avdd");

	ts->regulator = devm_regulator_get(&client->dev, "avdd");

	if (IS_ERR(ts->regulator)) {

		dev_err(&client->dev, "regulator_get failed\n");

		error = PTR_ERR(ts->regulator);

		goto err_put_int_gpio;

		return PTR_ERR(ts->regulator);

	}



	error = regulator_enable(ts->regulator);

	if (error < 0) {

	if (error) {

		dev_err(&client->dev, "regulator enable failed\n");

		goto err_put_regulator;

		return error;

	}



	ts->touch_stopped = false;

	init_waitqueue_head(&ts->wait);

	error = devm_add_action_or_reset(&client->dev, bu21013_power_off, ts);

	if (error) {

		dev_err(&client->dev, "failed to install power off handler\n");

		return error;

	}



	/* Named "CS" on the chip, DT binding is "reset" */

	ts->cs_gpiod = gpiod_get(&client->dev, "reset", GPIOD_OUT_HIGH);

	ts->cs_gpiod = devm_gpiod_get(&client->dev, "reset", GPIOD_OUT_HIGH);

	error = PTR_ERR_OR_ZERO(ts->cs_gpiod);

	if (error) {

		if (error != -EPROBE_DEFER)

			dev_err(&client->dev, "failed to get CS GPIO\n");

		goto err_disable_regulator;

		return error;

	}

	gpiod_set_consumer_name(ts->cs_gpiod, "BU21013 CS");



	error = devm_add_action_or_reset(&client->dev,

					 bu21013_disable_chip, ts);

	if (error) {

		dev_err(&client->dev,

			"failed to install chip disable handler\n");

		return error;

	}



	/* Named "INT" on the chip, DT binding is "touch" */

	ts->int_gpiod = devm_gpiod_get(&client->dev, "touch", GPIOD_IN);

	error = PTR_ERR_OR_ZERO(ts->int_gpiod);

	if (error) {

		if (error != -EPROBE_DEFER)

			dev_err(&client->dev, "failed to get INT GPIO\n");

		return error;

	}

	gpiod_set_consumer_name(ts->int_gpiod, "BU21013 INT");



	/* configure the touch panel controller */

	error = bu21013_init_chip(ts);

	if (error) {

		dev_err(&client->dev, "error in bu21013 config\n");

		goto err_cs_disable;

		return error;

	}



	/* register the device to input subsystem */

	in_dev->name = DRIVER_TP;

	in_dev->id.bustype = BUS_I2C;

	in_dev->dev.parent = &client->dev;



	__set_bit(EV_SYN, in_dev->evbit);

	__set_bit(EV_KEY, in_dev->evbit);

	__set_bit(EV_ABS, in_dev->evbit);



	input_set_abs_params(in_dev, ABS_MT_POSITION_X,

			     0, pdata->touch_x_max, 0, 0);

	input_set_abs_params(in_dev, ABS_MT_POSITION_Y,

			     0, pdata->touch_y_max, 0, 0);

	input_set_drvdata(in_dev, ts);



	error = request_threaded_irq(ts->irq, NULL, bu21013_gpio_irq,

				     IRQF_TRIGGER_FALLING | IRQF_SHARED |

	ts->irq = gpiod_to_irq(ts->int_gpiod);

	error = devm_request_threaded_irq(&client->dev, ts->irq,

					  NULL, bu21013_gpio_irq,

					  IRQF_TRIGGER_FALLING |

						IRQF_SHARED |

						IRQF_ONESHOT,

					  DRIVER_TP, ts);

	if (error) {

		dev_err(&client->dev, "request irq %d failed\n",

			ts->irq);

		goto err_cs_disable;

		return error;

	}



	error = input_register_device(in_dev);

	if (error) {

		dev_err(&client->dev, "failed to register input device\n");

		goto err_free_irq;

		return error;

	}



	device_init_wakeup(&client->dev, pdata->wakeup);

	i2c_set_clientdata(client, ts);



	return 0;



err_free_irq:

	bu21013_free_irq(ts);

err_cs_disable:

	gpiod_set_value(ts->cs_gpiod, 0);

	gpiod_put(ts->cs_gpiod);

err_disable_regulator:

	regulator_disable(ts->regulator);

err_put_regulator:

	regulator_put(ts->regulator);

err_put_int_gpio:

	gpiod_put(ts->int_gpiod);

err_free_mem:

	input_free_device(in_dev);

	kfree(ts);



	return error;

}



static int bu21013_remove(struct i2c_client *client)

{

	struct bu21013_ts *ts = i2c_get_clientdata(client);



	bu21013_free_irq(ts);



	gpiod_set_value(ts->cs_gpiod, 0);

	gpiod_put(ts->cs_gpiod);



	input_unregister_device(ts->in_dev);



	regulator_disable(ts->regulator);

	regulator_put(ts->regulator);



	gpiod_put(ts->int_gpiod);



	kfree(ts);

	/* Make sure IRQ will exit quickly even if there is contact */

	ts->touch_stopped = true;

	/* The resources will be freed by devm */



	return 0;

}