Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
regulator: rpi-panel-attiny: use new GPIO line value
Merge series from Bartosz Golaszewski <brgl@bgdev.pl>:
struct gpio_chip now has callbacks for setting line values that return
an integer, allowing to indicate failures. We're in the process of
converting all GPIO drivers to using the new API. This series converts
the only GPIO controller under drivers/regulator/ and - while at it -
refactors the code a bit.
+28
-53
+28
-53
drivers/regulator/rpi-panel-attiny-regulator.c
+28
-53
drivers/regulator/rpi-panel-attiny-regulator.c
···
6
6
*/
7
7
8
8
#include <linux/backlight.h>
9
+
#include <linux/cleanup.h>
9
10
#include <linux/err.h>
10
11
#include <linux/gpio/driver.h>
11
12
#include <linux/i2c.h>
12
13
#include <linux/init.h>
13
14
#include <linux/interrupt.h>
14
15
#include <linux/module.h>
16
+
#include <linux/mutex.h>
15
17
#include <linux/regmap.h>
16
18
#include <linux/regulator/driver.h>
17
19
#include <linux/regulator/machine.h>
···
95
93
{
96
94
struct attiny_lcd *state = rdev_get_drvdata(rdev);
97
95
98
-
mutex_lock(&state->lock);
96
+
guard(mutex)(&state->lock);
99
97
100
98
/* Ensure bridge, and tp stay in reset */
101
99
attiny_set_port_state(state, REG_PORTC, 0);
···
116
114
117
115
msleep(80);
118
116
119
-
mutex_unlock(&state->lock);
120
-
121
117
return 0;
122
118
}
123
119
···
123
123
{
124
124
struct attiny_lcd *state = rdev_get_drvdata(rdev);
125
125
126
-
mutex_lock(&state->lock);
126
+
guard(mutex)(&state->lock);
127
127
128
128
regmap_write(rdev->regmap, REG_PWM, 0);
129
129
usleep_range(5000, 10000);
···
135
135
attiny_set_port_state(state, REG_PORTC, 0);
136
136
msleep(30);
137
137
138
-
mutex_unlock(&state->lock);
139
-
140
138
return 0;
141
139
}
142
140
···
142
144
{
143
145
struct attiny_lcd *state = rdev_get_drvdata(rdev);
144
146
unsigned int data;
145
-
int ret, i;
147
+
int ret = 0, i;
146
148
147
-
mutex_lock(&state->lock);
148
-
149
-
for (i = 0; i < 10; i++) {
150
-
ret = regmap_read(rdev->regmap, REG_PORTC, &data);
151
-
if (!ret)
152
-
break;
153
-
usleep_range(10000, 12000);
149
+
scoped_guard(mutex, &state->lock) {
150
+
for (i = 0; i < 10; i++) {
151
+
ret = regmap_read(rdev->regmap, REG_PORTC, &data);
152
+
if (!ret)
153
+
break;
154
+
usleep_range(10000, 12000);
155
+
}
154
156
}
155
-
156
-
mutex_unlock(&state->lock);
157
157
158
158
if (ret < 0)
159
159
return ret;
···
185
189
int brightness = backlight_get_brightness(bl);
186
190
int ret, i;
187
191
188
-
mutex_lock(&state->lock);
192
+
guard(mutex)(&state->lock);
189
193
190
194
for (i = 0; i < 10; i++) {
191
195
ret = regmap_write(regmap, REG_PWM, brightness);
192
196
if (!ret)
193
197
break;
194
198
}
195
-
196
-
mutex_unlock(&state->lock);
197
199
198
200
return ret;
199
201
}
···
205
211
return GPIO_LINE_DIRECTION_OUT;
206
212
}
207
213
208
-
static void attiny_gpio_set(struct gpio_chip *gc, unsigned int off, int val)
214
+
static int attiny_gpio_set(struct gpio_chip *gc, unsigned int off, int val)
209
215
{
210
216
struct attiny_lcd *state = gpiochip_get_data(gc);
211
217
u8 last_val;
212
218
213
-
if (off >= NUM_GPIO)
214
-
return;
215
-
216
-
mutex_lock(&state->lock);
219
+
guard(mutex)(&state->lock);
217
220
218
221
last_val = attiny_get_port_state(state, mappings[off].reg);
219
222
if (val)
···
233
242
msleep(100);
234
243
}
235
244
236
-
mutex_unlock(&state->lock);
245
+
return 0;
237
246
}
238
247
239
248
static int attiny_i2c_read(struct i2c_client *client, u8 reg, unsigned int *buf)
···
287
296
if (!state)
288
297
return -ENOMEM;
289
298
290
-
mutex_init(&state->lock);
299
+
ret = devm_mutex_init(&i2c->dev, &state->lock);
300
+
if (ret)
301
+
return ret;
302
+
291
303
i2c_set_clientdata(i2c, state);
292
304
293
305
regmap = devm_regmap_init_i2c(i2c, &attiny_regmap_config);
···
298
304
ret = PTR_ERR(regmap);
299
305
dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
300
306
ret);
301
-
goto error;
307
+
return ret;
302
308
}
303
309
304
310
ret = attiny_i2c_read(i2c, REG_ID, &data);
305
311
if (ret < 0) {
306
312
dev_err(&i2c->dev, "Failed to read REG_ID reg: %d\n", ret);
307
-
goto error;
313
+
return ret;
308
314
}
309
315
310
316
switch (data) {
···
313
319
break;
314
320
default:
315
321
dev_err(&i2c->dev, "Unknown Atmel firmware revision: 0x%02x\n", data);
316
-
ret = -ENODEV;
317
-
goto error;
322
+
return -ENODEV;
318
323
}
319
324
320
325
regmap_write(regmap, REG_POWERON, 0);
···
329
336
rdev = devm_regulator_register(&i2c->dev, &attiny_regulator, &config);
330
337
if (IS_ERR(rdev)) {
331
338
dev_err(&i2c->dev, "Failed to register ATTINY regulator\n");
332
-
ret = PTR_ERR(rdev);
333
-
goto error;
339
+
return PTR_ERR(rdev);
334
340
}
335
341
336
342
props.type = BACKLIGHT_RAW;
···
340
348
bl = devm_backlight_device_register(&i2c->dev, dev_name(&i2c->dev),
341
349
&i2c->dev, state, &attiny_bl,
342
350
&props);
343
-
if (IS_ERR(bl)) {
344
-
ret = PTR_ERR(bl);
345
-
goto error;
346
-
}
351
+
if (IS_ERR(bl))
352
+
return PTR_ERR(bl);
347
353
348
354
bl->props.brightness = 0xff;
349
355
···
351
361
state->gc.base = -1;
352
362
state->gc.ngpio = NUM_GPIO;
353
363
354
-
state->gc.set = attiny_gpio_set;
364
+
state->gc.set_rv = attiny_gpio_set;
355
365
state->gc.get_direction = attiny_gpio_get_direction;
356
366
state->gc.can_sleep = true;
357
367
358
368
ret = devm_gpiochip_add_data(&i2c->dev, &state->gc, state);
359
-
if (ret) {
369
+
if (ret)
360
370
dev_err(&i2c->dev, "Failed to create gpiochip: %d\n", ret);
361
-
goto error;
362
-
}
363
-
364
-
return 0;
365
-
366
-
error:
367
-
mutex_destroy(&state->lock);
368
371
369
372
return ret;
370
-
}
371
-
372
-
static void attiny_i2c_remove(struct i2c_client *client)
373
-
{
374
-
struct attiny_lcd *state = i2c_get_clientdata(client);
375
-
376
-
mutex_destroy(&state->lock);
377
373
}
378
374
379
375
static const struct of_device_id attiny_dt_ids[] = {
···
375
399
.of_match_table = attiny_dt_ids,
376
400
},
377
401
.probe = attiny_i2c_probe,
378
-
.remove = attiny_i2c_remove,
379
402
};
380
403
381
404
module_i2c_driver(attiny_regulator_driver);