projects/linux·blob master · refs

739 lines · 18.8 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * ti_fpc202.c - FPC202 Dual Port Controller driver
4 *
5 * Copyright (C) 2024 Bootlin
6 *
7 */
8
9#include <linux/cleanup.h>
10#include <linux/device/devres.h>
11#include <linux/err.h>
12#include <linux/i2c.h>
13#include <linux/i2c-atr.h>
14#include <linux/gpio/consumer.h>
15#include <linux/gpio/driver.h>
16#include <linux/gpio/machine.h>
17#include <linux/leds.h>
18#include <linux/module.h>
19#include <linux/math.h>
20#include <linux/types.h>
21
22#define FPC202_NUM_PORTS 2
23#define FPC202_ALIASES_PER_PORT 2
24
25/*
26 * GPIO: port mapping
27 *
28 * 0: P0_S0_IN_A
29 * 1: P0_S1_IN_A
30 * 2: P1_S0_IN_A
31 * 3: P1_S1_IN_A
32 * 4: P0_S0_IN_B
33 * ...
34 * 8: P0_S0_IN_C
35 * ...
36 * 12: P0_S0_OUT_A
37 * ...
38 * 16: P0_S0_OUT_B
39 * ...
40 * 19: P1_S1_OUT_B
41 *
42 * Ports with optional LED control:
43 *
44 * 20: P0_S0_OUT_C (P0_S0_LED1)
45 * ...
46 * 23: P1_S1_OUT_C (P1_S1_LED1)
47 * 24: P0_S0_OUT_D (P0_S0_LED2
48 * ...
49 * 27: P1_S1_OUT_D (P1_S1_LED2)
50 *
51 */
52
53#define FPC202_GPIO_COUNT 28
54#define FPC202_GPIO_P0_S0_IN_B 4
55#define FPC202_GPIO_P0_S0_OUT_A 12
56#define FPC202_GPIO_P0_S0_OUT_C 20
57#define FPC202_GPIO_P0_S0_OUT_D 24
58
59#define FPC202_REG_IN_A_INT 0x6
60#define FPC202_REG_IN_C_IN_B 0x7
61#define FPC202_REG_OUT_A_OUT_B 0x8
62#define FPC202_REG_OUT_C_OUT_D 0x9
63
64#define FPC202_REG_OUT_A_OUT_B_VAL 0xa
65
66#define FPC202_LED_COUNT 8
67
68/* There are four LED GPIO mode registers which manage two GPIOs each. */
69#define FPC202_REG_LED_MODE(offset) (0x1a + 0x20 * ((offset) % 4))
70
71/* LED1 GPIOs (*_OUT_C) are configured in bits 1:0, LED2 GPIOs (*_OUT_D) in bits 3:2. */
72#define FPC202_LED_MODE_SHIFT(offset) ((offset) < FPC202_GPIO_P0_S0_OUT_D ? 0 : 2)
73#define FPC202_LED_MODE_MASK(offset) (GENMASK(1, 0) << FPC202_LED_MODE_SHIFT(offset))
74
75/* There is one PWM control register for each GPIO LED */
76#define FPC202_REG_LED_PWM(offset) \
77 (((offset) < FPC202_GPIO_P0_S0_OUT_D ? 0x14 : 0x15) + 0x20 * ((offset) % 4))
78
79/* There are two blink delay registers (on/off time) for each GPIO LED */
80#define FPC202_REG_LED_BLINK_ON(offset) \
81 (((offset) < FPC202_GPIO_P0_S0_OUT_D ? 0x16 : 0x18) + 0x20 * ((offset) % 4))
82#define FPC202_REG_LED_BLINK_OFF(offset) (FPC202_REG_LED_BLINK_ON(offset) + 1)
83
84/* The actual hardware precision is 2.5ms but since the LED API doesn't handle sub-millisecond
85 * timesteps this is rounded up to 5ms
86 */
87#define FPC202_LED_BLINK_PRECISION 5UL
88
89#define FPC202_LED_MAX_BRIGHTNESS 255
90
91#define FPC202_REG_MOD_DEV(port, dev) (0xb4 + ((port) * 4) + (dev))
92#define FPC202_REG_AUX_DEV(port, dev) (0xb6 + ((port) * 4) + (dev))
93
94/*
95 * The FPC202 doesn't support turning off address translation on a single port.
96 * So just set an invalid I2C address as the translation target when no client
97 * address is attached.
98 */
99#define FPC202_REG_DEV_INVALID 0
100
101/* Even aliases are assigned to device 0 and odd aliases to device 1 */
102#define fpc202_dev_num_from_alias(alias) ((alias) % 2)
103
104enum fpc202_led_mode {
105 FPC202_LED_MODE_OFF = 0,
106 FPC202_LED_MODE_ON = 1,
107 FPC202_LED_MODE_PWM = 2,
108 FPC202_LED_MODE_BLINK = 3,
109};
110
111struct fpc202_led {
112 int offset;
113 struct led_classdev led_cdev;
114 struct fpc202_priv *priv;
115 struct gpio_desc *gpio;
116 enum fpc202_led_mode mode;
117};
118
119struct fpc202_priv {
120 struct i2c_client *client;
121 struct i2c_atr *atr;
122 struct gpio_desc *en_gpio;
123 struct gpio_chip gpio;
124 struct fpc202_led leds[FPC202_LED_COUNT];
125
126 /* Lock REG_MOD/AUX_DEV and addr_caches during attach/detach */
127 struct mutex reg_dev_lock;
128
129 /* Lock LED mode select register during accesses */
130 struct mutex led_mode_lock;
131
132 /* Cached device addresses for both ports and their devices */
133 u8 addr_caches[2][2];
134
135 /* Keep track of which ports were probed */
136 DECLARE_BITMAP(probed_ports, FPC202_NUM_PORTS);
137};
138
139static void fpc202_fill_alias_table(struct i2c_client *client, u16 *aliases, int port_id)
140{
141 u16 first_alias;
142 int i;
143
144 /*
145 * There is a predefined list of aliases for each FPC202 I2C
146 * self-address. This allows daisy-chained FPC202 units to
147 * automatically take on different sets of aliases.
148 * Each port of an FPC202 unit is assigned two aliases from this list.
149 */
150 first_alias = 0x10 + 4 * port_id + 8 * ((u16)client->addr - 2);
151
152 for (i = 0; i < FPC202_ALIASES_PER_PORT; i++)
153 aliases[i] = first_alias + i;
154}
155
156static int fpc202_gpio_get_dir(int offset)
157{
158 return offset < FPC202_GPIO_P0_S0_OUT_A ? GPIO_LINE_DIRECTION_IN : GPIO_LINE_DIRECTION_OUT;
159}
160
161static int fpc202_gpio_has_led_caps(int offset)
162{
163 return offset >= FPC202_GPIO_P0_S0_OUT_C;
164}
165
166static int fpc202_read(struct fpc202_priv *priv, u8 reg)
167{
168 int val;
169
170 val = i2c_smbus_read_byte_data(priv->client, reg);
171 return val;
172}
173
174static int fpc202_write(struct fpc202_priv *priv, u8 reg, u8 value)
175{
176 return i2c_smbus_write_byte_data(priv->client, reg, value);
177}
178
179static void fpc202_set_enable(struct fpc202_priv *priv, int enable)
180{
181 if (!priv->en_gpio)
182 return;
183
184 gpiod_set_value(priv->en_gpio, enable);
185}
186
187static int fpc202_led_mode_write(struct fpc202_priv *priv,
188 int offset,
189 enum fpc202_led_mode mode)
190{
191 u8 val, reg = FPC202_REG_LED_MODE(offset);
192 int ret;
193
194 guard(mutex)(&priv->led_mode_lock);
195
196 ret = fpc202_read(priv, reg);
197 if (ret < 0) {
198 dev_err(&priv->client->dev, "failed to read LED mode %d! err %d\n",
199 offset, ret);
200 return ret;
201 }
202
203 val = (u8)ret & ~FPC202_LED_MODE_MASK(offset);
204 val |= mode << FPC202_LED_MODE_SHIFT(offset);
205
206 return fpc202_write(priv, reg, val);
207}
208
209static int fpc202_led_mode_set(struct fpc202_led *led, enum fpc202_led_mode mode)
210{
211 struct fpc202_priv *priv = led->priv;
212
213 led->mode = mode;
214
215 return fpc202_led_mode_write(priv, led->offset, mode);
216}
217
218static int fpc202_gpio_set(struct gpio_chip *chip, unsigned int offset,
219 int value)
220{
221 struct fpc202_priv *priv = gpiochip_get_data(chip);
222 int ret;
223 u8 val;
224
225 if (fpc202_gpio_has_led_caps(offset)) {
226 ret = fpc202_led_mode_write(priv, offset,
227 value ? FPC202_LED_MODE_ON : FPC202_LED_MODE_OFF);
228 if (ret < 0)
229 dev_err(&priv->client->dev, "Failed to set GPIO %d LED mode! err %d\n",
230 offset, ret);
231
232 return ret;
233 }
234
235 ret = fpc202_read(priv, FPC202_REG_OUT_A_OUT_B_VAL);
236 if (ret < 0) {
237 dev_err(&priv->client->dev, "Failed to set GPIO %d value! err %d\n", offset, ret);
238 return ret;
239 }
240
241 val = (u8)ret;
242
243 if (value)
244 val |= BIT(offset - FPC202_GPIO_P0_S0_OUT_A);
245 else
246 val &= ~BIT(offset - FPC202_GPIO_P0_S0_OUT_A);
247
248 return fpc202_write(priv, FPC202_REG_OUT_A_OUT_B_VAL, val);
249}
250
251static int fpc202_gpio_get(struct gpio_chip *chip, unsigned int offset)
252{
253 struct fpc202_priv *priv = gpiochip_get_data(chip);
254 u8 reg, bit;
255 int ret;
256
257 if (offset < FPC202_GPIO_P0_S0_IN_B) {
258 reg = FPC202_REG_IN_A_INT;
259 bit = BIT(4 + offset);
260 } else if (offset < FPC202_GPIO_P0_S0_OUT_A) {
261 reg = FPC202_REG_IN_C_IN_B;
262 bit = BIT(offset - FPC202_GPIO_P0_S0_IN_B);
263 } else if (!fpc202_gpio_has_led_caps(offset)) {
264 reg = FPC202_REG_OUT_A_OUT_B_VAL;
265 bit = BIT(offset - FPC202_GPIO_P0_S0_OUT_A);
266 } else {
267 return -EOPNOTSUPP;
268 }
269
270 ret = fpc202_read(priv, reg);
271 if (ret < 0)
272 return ret;
273
274 return !!(((u8)ret) & bit);
275}
276
277static int fpc202_gpio_direction_input(struct gpio_chip *chip, unsigned int offset)
278{
279 if (fpc202_gpio_get_dir(offset) == GPIO_LINE_DIRECTION_OUT)
280 return -EINVAL;
281
282 return 0;
283}
284
285static int fpc202_gpio_direction_output(struct gpio_chip *chip, unsigned int offset,
286 int value)
287{
288 struct fpc202_priv *priv = gpiochip_get_data(chip);
289 u8 reg, val, bit;
290 int ret;
291
292 if (fpc202_gpio_get_dir(offset) == GPIO_LINE_DIRECTION_IN)
293 return -EINVAL;
294
295 fpc202_gpio_set(chip, offset, value);
296
297 if (fpc202_gpio_has_led_caps(offset)) {
298 reg = FPC202_REG_OUT_C_OUT_D;
299 bit = BIT(offset - FPC202_GPIO_P0_S0_OUT_C);
300 } else {
301 reg = FPC202_REG_OUT_A_OUT_B;
302 bit = BIT(offset - FPC202_GPIO_P0_S0_OUT_A);
303 }
304
305 ret = fpc202_read(priv, reg);
306 if (ret < 0)
307 return ret;
308
309 val = (u8)ret | bit;
310
311 return fpc202_write(priv, reg, val);
312}
313
314/*
315 * Set the translation table entry associated with a port and device number.
316 *
317 * Each downstream port of the FPC202 has two fixed aliases corresponding to
318 * device numbers 0 and 1. If one of these aliases is found in an incoming I2C
319 * transfer, it will be translated to the address given by the corresponding
320 * translation table entry.
321 */
322static int fpc202_write_dev_addr(struct fpc202_priv *priv, u32 port_id, int dev_num, u16 addr)
323{
324 int ret, reg_mod, reg_aux;
325 u8 val;
326
327 guard(mutex)(&priv->reg_dev_lock);
328
329 reg_mod = FPC202_REG_MOD_DEV(port_id, dev_num);
330 reg_aux = FPC202_REG_AUX_DEV(port_id, dev_num);
331 val = addr & 0x7f;
332
333 ret = fpc202_write(priv, reg_mod, val);
334 if (ret)
335 return ret;
336
337 /*
338 * The FPC202 datasheet is unclear about the role of the AUX registers.
339 * Empirically, writing to them as well seems to be necessary for
340 * address translation to function properly.
341 */
342 ret = fpc202_write(priv, reg_aux, val);
343
344 priv->addr_caches[port_id][dev_num] = val;
345
346 return ret;
347}
348
349static int fpc202_attach_addr(struct i2c_atr *atr, u32 chan_id,
350 u16 addr, u16 alias)
351{
352 struct fpc202_priv *priv = i2c_atr_get_driver_data(atr);
353
354 dev_dbg(&priv->client->dev, "attaching address 0x%02x to alias 0x%02x\n", addr, alias);
355
356 return fpc202_write_dev_addr(priv, chan_id, fpc202_dev_num_from_alias(alias), addr);
357}
358
359static void fpc202_detach_addr(struct i2c_atr *atr, u32 chan_id,
360 u16 addr)
361{
362 struct fpc202_priv *priv = i2c_atr_get_driver_data(atr);
363 int dev_num, val;
364
365 for (dev_num = 0; dev_num < 2; dev_num++) {
366 mutex_lock(&priv->reg_dev_lock);
367
368 val = priv->addr_caches[chan_id][dev_num];
369
370 mutex_unlock(&priv->reg_dev_lock);
371
372 if (val == (addr & 0x7f)) {
373 fpc202_write_dev_addr(priv, chan_id, dev_num, FPC202_REG_DEV_INVALID);
374 return;
375 }
376 }
377}
378
379static const struct i2c_atr_ops fpc202_atr_ops = {
380 .attach_addr = fpc202_attach_addr,
381 .detach_addr = fpc202_detach_addr,
382};
383
384static struct fpc202_led *fpc202_cdev_to_led(struct led_classdev *cdev)
385{
386 return container_of(cdev, struct fpc202_led, led_cdev);
387}
388
389static struct fpc202_led *fpc202_led_get(struct fpc202_priv *priv, int offset)
390{
391 return &priv->leds[offset - FPC202_GPIO_P0_S0_OUT_C];
392}
393
394static int fpc202_led_blink_set(struct led_classdev *cdev,
395 unsigned long *delay_on,
396 unsigned long *delay_off)
397{
398 struct fpc202_led *led = fpc202_cdev_to_led(cdev);
399 struct fpc202_priv *priv = led->priv;
400 unsigned long val;
401 int ret;
402
403 if (*delay_on == 0 && *delay_off == 0) {
404 *delay_on = 250;
405 *delay_off = 250;
406 } else {
407 if (*delay_on % FPC202_LED_BLINK_PRECISION)
408 *delay_on = roundup(*delay_on, FPC202_LED_BLINK_PRECISION);
409
410 if (*delay_off % FPC202_LED_BLINK_PRECISION)
411 *delay_off = roundup(*delay_off, FPC202_LED_BLINK_PRECISION);
412 }
413
414 /* Multiply the duration by two, since the actual precision is 2.5ms not 5ms*/
415 val = 2 * (*delay_on / FPC202_LED_BLINK_PRECISION);
416 if (val > 255) {
417 val = 255;
418 *delay_on = (val / 2) * FPC202_LED_BLINK_PRECISION;
419 }
420
421 ret = fpc202_write(priv, FPC202_REG_LED_BLINK_ON(led->offset), val);
422 if (ret) {
423 dev_err(&priv->client->dev,
424 "Failed to set blink on duration for LED %d, err %d\n",
425 led->offset, ret);
426 return ret;
427 }
428
429 val = 2 * (*delay_off / FPC202_LED_BLINK_PRECISION);
430 if (val > 255) {
431 val = 255;
432 *delay_off = (val / 2) * FPC202_LED_BLINK_PRECISION;
433 }
434
435 ret = fpc202_write(priv, FPC202_REG_LED_BLINK_OFF(led->offset), val);
436 if (ret) {
437 dev_err(&priv->client->dev,
438 "Failed to set blink off duration for LED %d, err %d\n",
439 led->offset, ret);
440 return ret;
441 }
442
443 return fpc202_led_mode_set(led, FPC202_LED_MODE_BLINK);
444}
445
446static enum led_brightness fpc202_led_brightness_get(struct led_classdev *cdev)
447{
448 struct fpc202_led *led = fpc202_cdev_to_led(cdev);
449
450 if (led->mode == FPC202_LED_MODE_OFF)
451 return LED_OFF;
452
453 return LED_ON;
454}
455
456static int fpc202_led_brightness_set(struct led_classdev *cdev,
457 enum led_brightness brightness)
458{
459 struct fpc202_led *led = fpc202_cdev_to_led(cdev);
460 struct fpc202_priv *priv = led->priv;
461 int ret;
462
463 if (!brightness)
464 return fpc202_led_mode_set(led, FPC202_LED_MODE_OFF);
465
466 if (led->mode != FPC202_LED_MODE_BLINK) {
467 if (brightness == FPC202_LED_MAX_BRIGHTNESS)
468 return fpc202_led_mode_set(led, FPC202_LED_MODE_ON);
469
470 ret = fpc202_led_mode_set(led, FPC202_LED_MODE_PWM);
471 if (ret) {
472 dev_err(&priv->client->dev, "Failed to set LED %d mode, err %d\n",
473 led->offset, ret);
474 return ret;
475 }
476 }
477
478 return fpc202_write(priv, FPC202_REG_LED_PWM(led->offset), brightness);
479}
480
481static int fpc202_register_led(struct fpc202_priv *priv, int offset,
482 struct device_node *led_handle)
483{
484 struct fpc202_led *led = fpc202_led_get(priv, offset);
485 struct device *dev = &priv->client->dev;
486 struct led_init_data init_data = { };
487 int ret = 0;
488
489 led->priv = priv;
490 led->offset = offset;
491 led->led_cdev.max_brightness = FPC202_LED_MAX_BRIGHTNESS;
492 led->led_cdev.brightness_set_blocking = fpc202_led_brightness_set;
493 led->led_cdev.brightness_get = fpc202_led_brightness_get;
494 led->led_cdev.blink_set = fpc202_led_blink_set;
495
496 init_data.fwnode = of_fwnode_handle(led_handle);
497 init_data.default_label = NULL;
498 init_data.devicename = NULL;
499 init_data.devname_mandatory = false;
500
501 ret = fpc202_led_mode_set(led, FPC202_LED_MODE_OFF);
502 if (ret) {
503 dev_err(dev, "Failed to set LED %d mode, err %d\n", offset, ret);
504 return ret;
505 }
506
507 ret = devm_led_classdev_register_ext(dev, &led->led_cdev, &init_data);
508 if (ret) {
509 dev_err(dev, "Failed to register LED %d cdev, err %d\n", offset, ret);
510 return ret;
511 }
512
513 /* Claim corresponding GPIO line so that it cannot be interfered with */
514 led->gpio = gpiochip_request_own_desc(&priv->gpio, offset, led->led_cdev.name,
515 GPIO_ACTIVE_HIGH, GPIOD_ASIS);
516 if (IS_ERR(led->gpio)) {
517 ret = PTR_ERR(led->gpio);
518 dev_err(dev, "Failed to register LED %d cdev, err %d\n", offset, ret);
519 }
520
521 return ret;
522}
523
524static int fpc202_register_leds(struct fpc202_priv *priv)
525{
526 struct device *dev = &priv->client->dev;
527 int offset, ret = 0;
528
529 if (!devres_open_group(dev, fpc202_register_leds, GFP_KERNEL))
530 return -ENOMEM;
531
532 for_each_child_of_node_scoped(dev->of_node, led_handle) {
533 ret = of_property_read_u32(led_handle, "reg", &offset);
534 if (ret) {
535 dev_err(dev, "Failed to read 'reg' property of child node, err %d\n", ret);
536 return ret;
537 }
538
539 if (offset < FPC202_GPIO_P0_S0_OUT_C || offset > FPC202_GPIO_COUNT)
540 continue;
541
542 ret = fpc202_register_led(priv, offset, led_handle);
543 if (ret) {
544 dev_err(dev, "Failed to register LED %d, err %d\n", offset,
545 ret);
546 goto free_own_gpios;
547 }
548 }
549
550 devres_close_group(dev, fpc202_register_leds);
551
552 return 0;
553
554free_own_gpios:
555 for (offset = 0; offset < FPC202_LED_COUNT; offset++)
556 if (priv->leds[offset].gpio)
557 gpiochip_free_own_desc(priv->leds[offset].gpio);
558 return ret;
559}
560
561static int fpc202_probe_port(struct fpc202_priv *priv, struct device_node *i2c_handle, int port_id)
562{
563 u16 aliases[FPC202_ALIASES_PER_PORT] = { };
564 struct device *dev = &priv->client->dev;
565 struct i2c_atr_adap_desc desc = { };
566 int ret = 0;
567
568 desc.chan_id = port_id;
569 desc.parent = dev;
570 desc.bus_handle = of_fwnode_handle(i2c_handle);
571 desc.num_aliases = FPC202_ALIASES_PER_PORT;
572
573 fpc202_fill_alias_table(priv->client, aliases, port_id);
574 desc.aliases = aliases;
575
576 ret = i2c_atr_add_adapter(priv->atr, &desc);
577 if (ret)
578 return ret;
579
580 set_bit(port_id, priv->probed_ports);
581
582 ret = fpc202_write_dev_addr(priv, port_id, 0, FPC202_REG_DEV_INVALID);
583 if (ret)
584 return ret;
585
586 return fpc202_write_dev_addr(priv, port_id, 1, FPC202_REG_DEV_INVALID);
587}
588
589static void fpc202_remove_port(struct fpc202_priv *priv, int port_id)
590{
591 i2c_atr_del_adapter(priv->atr, port_id);
592 clear_bit(port_id, priv->probed_ports);
593}
594
595static int fpc202_probe(struct i2c_client *client)
596{
597 struct device *dev = &client->dev;
598 struct fpc202_priv *priv;
599 int ret, port_id, led_id;
600
601 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
602 if (!priv)
603 return -ENOMEM;
604
605 mutex_init(&priv->reg_dev_lock);
606 mutex_init(&priv->led_mode_lock);
607
608 priv->client = client;
609 i2c_set_clientdata(client, priv);
610
611 priv->en_gpio = devm_gpiod_get_optional(dev, "enable", GPIOD_OUT_HIGH);
612 if (IS_ERR(priv->en_gpio)) {
613 ret = PTR_ERR(priv->en_gpio);
614 dev_err(dev, "failed to fetch enable GPIO! err %d\n", ret);
615 goto destroy_mutex;
616 }
617
618 priv->gpio.label = "gpio-fpc202";
619 priv->gpio.base = -1;
620 priv->gpio.direction_input = fpc202_gpio_direction_input;
621 priv->gpio.direction_output = fpc202_gpio_direction_output;
622 priv->gpio.set = fpc202_gpio_set;
623 priv->gpio.get = fpc202_gpio_get;
624 priv->gpio.ngpio = FPC202_GPIO_COUNT;
625 priv->gpio.parent = dev;
626 priv->gpio.owner = THIS_MODULE;
627
628 ret = gpiochip_add_data(&priv->gpio, priv);
629 if (ret) {
630 priv->gpio.parent = NULL;
631 dev_err(dev, "failed to add gpiochip err %d\n", ret);
632 goto disable_gpio;
633 }
634
635 priv->atr = i2c_atr_new(client->adapter, dev, &fpc202_atr_ops, 2, 0);
636 if (IS_ERR(priv->atr)) {
637 ret = PTR_ERR(priv->atr);
638 dev_err(dev, "failed to create i2c atr err %d\n", ret);
639 goto disable_gpio;
640 }
641
642 i2c_atr_set_driver_data(priv->atr, priv);
643
644 ret = fpc202_register_leds(priv);
645 if (ret) {
646 dev_err(dev, "Failed to register LEDs, err %d\n", ret);
647 goto delete_atr;
648 }
649
650 bitmap_zero(priv->probed_ports, FPC202_NUM_PORTS);
651
652 for_each_child_of_node_scoped(dev->of_node, i2c_handle) {
653 ret = of_property_read_u32(i2c_handle, "reg", &port_id);
654 if (ret) {
655 if (ret == -EINVAL)
656 continue;
657
658 dev_err(dev, "failed to read 'reg' property of child node, err %d\n", ret);
659 goto unregister_chans;
660 }
661
662 if (port_id >= FPC202_NUM_PORTS)
663 continue;
664
665 ret = fpc202_probe_port(priv, i2c_handle, port_id);
666 if (ret) {
667 dev_err(dev, "Failed to probe port %d, err %d\n", port_id, ret);
668 goto unregister_chans;
669 }
670 }
671
672 goto out;
673
674unregister_chans:
675 for_each_set_bit(port_id, priv->probed_ports, FPC202_NUM_PORTS)
676 fpc202_remove_port(priv, port_id);
677
678 for (led_id = 0; led_id < FPC202_LED_COUNT; led_id++)
679 if (priv->leds[led_id].gpio)
680 gpiochip_free_own_desc(priv->leds[led_id].gpio);
681
682 devres_release_group(&client->dev, fpc202_register_leds);
683delete_atr:
684 i2c_atr_delete(priv->atr);
685disable_gpio:
686 fpc202_set_enable(priv, 0);
687 gpiochip_remove(&priv->gpio);
688destroy_mutex:
689 mutex_destroy(&priv->led_mode_lock);
690 mutex_destroy(&priv->reg_dev_lock);
691out:
692 return ret;
693}
694
695static void fpc202_remove(struct i2c_client *client)
696{
697 struct fpc202_priv *priv = i2c_get_clientdata(client);
698 int port_id, led_id;
699
700 for_each_set_bit(port_id, priv->probed_ports, FPC202_NUM_PORTS)
701 fpc202_remove_port(priv, port_id);
702
703 for (led_id = 0; led_id < FPC202_LED_COUNT; led_id++)
704 if (priv->leds[led_id].gpio)
705 gpiochip_free_own_desc(priv->leds[led_id].gpio);
706
707 /* Release led devices early so that blink handlers don't trigger. */
708 devres_release_group(&client->dev, fpc202_register_leds);
709
710 mutex_destroy(&priv->led_mode_lock);
711 mutex_destroy(&priv->reg_dev_lock);
712
713 i2c_atr_delete(priv->atr);
714
715 fpc202_set_enable(priv, 0);
716 gpiochip_remove(&priv->gpio);
717}
718
719static const struct of_device_id fpc202_of_match[] = {
720 { .compatible = "ti,fpc202" },
721 { }
722};
723MODULE_DEVICE_TABLE(of, fpc202_of_match);
724
725static struct i2c_driver fpc202_driver = {
726 .driver = {
727 .name = "fpc202",
728 .of_match_table = fpc202_of_match,
729 },
730 .probe = fpc202_probe,
731 .remove = fpc202_remove,
732};
733
734module_i2c_driver(fpc202_driver);
735
736MODULE_AUTHOR("Romain Gantois <[email protected]>");
737MODULE_DESCRIPTION("TI FPC202 Dual Port Controller driver");
738MODULE_LICENSE("GPL");
739MODULE_IMPORT_NS("I2C_ATR");