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 104 enum 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 111 struct 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 119 struct 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 139 static 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 156 static 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 161 static int fpc202_gpio_has_led_caps(int offset) 162 { 163 return offset >= FPC202_GPIO_P0_S0_OUT_C; 164 } 165 166 static 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 174 static 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 179 static 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 187 static 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 209 static 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 218 static 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 251 static 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 277 static 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 285 static 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 */ 322 static 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 349 static 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 359 static 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 379 static const struct i2c_atr_ops fpc202_atr_ops = { 380 .attach_addr = fpc202_attach_addr, 381 .detach_addr = fpc202_detach_addr, 382 }; 383 384 static struct fpc202_led *fpc202_cdev_to_led(struct led_classdev *cdev) 385 { 386 return container_of(cdev, struct fpc202_led, led_cdev); 387 } 388 389 static 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 394 static 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 446 static 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 456 static 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 481 static 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 524 static 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 554 free_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 561 static 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 589 static 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 595 static 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 674 unregister_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); 683 delete_atr: 684 i2c_atr_delete(priv->atr); 685 disable_gpio: 686 fpc202_set_enable(priv, 0); 687 gpiochip_remove(&priv->gpio); 688 destroy_mutex: 689 mutex_destroy(&priv->led_mode_lock); 690 mutex_destroy(&priv->reg_dev_lock); 691 out: 692 return ret; 693 } 694 695 static 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 719 static const struct of_device_id fpc202_of_match[] = { 720 { .compatible = "ti,fpc202" }, 721 {} 722 }; 723 MODULE_DEVICE_TABLE(of, fpc202_of_match); 724 725 static 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 734 module_i2c_driver(fpc202_driver); 735 736 MODULE_AUTHOR("Romain Gantois <romain.gantois@bootlin.com>"); 737 MODULE_DESCRIPTION("TI FPC202 Dual Port Controller driver"); 738 MODULE_LICENSE("GPL"); 739 MODULE_IMPORT_NS("I2C_ATR"); 740