drivers/leds/leds-pca9532.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * pca9532.c - 16-bit Led dimmer
0004  *
0005  * Copyright (C) 2011 Jan Weitzel
0006  * Copyright (C) 2008 Riku Voipio
0007  *
0008  * Datasheet: http://www.nxp.com/documents/data_sheet/PCA9532.pdf
0009  */
0010
0011 #include <linux/module.h>
0012 #include <linux/i2c.h>
0013 #include <linux/slab.h>
0014 #include <linux/leds.h>
0015 #include <linux/input.h>
0016 #include <linux/mutex.h>
0017 #include <linux/workqueue.h>
0018 #include <linux/leds-pca9532.h>
0019 #include <linux/gpio/driver.h>
0020 #include <linux/of.h>
0021 #include <linux/of_device.h>
0022
0023 /* m =  num_leds*/
0024 #define PCA9532_REG_INPUT(i)    ((i) >> 3)
0025 #define PCA9532_REG_OFFSET(m)   ((m) >> 4)
0026 #define PCA9532_REG_PSC(m, i)   (PCA9532_REG_OFFSET(m) + 0x1 + (i) * 2)
0027 #define PCA9532_REG_PWM(m, i)   (PCA9532_REG_OFFSET(m) + 0x2 + (i) * 2)
0028 #define LED_REG(m, led)     (PCA9532_REG_OFFSET(m) + 0x5 + (led >> 2))
0029 #define LED_NUM(led)        (led & 0x3)
0030 #define LED_SHIFT(led)      (LED_NUM(led) * 2)
0031 #define LED_MASK(led)       (0x3 << LED_SHIFT(led))
0032
0033 #define ldev_to_led(c)       container_of(c, struct pca9532_led, ldev)
0034
0035 struct pca9532_chip_info {
0036     u8  num_leds;
0037 };
0038
0039 struct pca9532_data {
0040     struct i2c_client *client;
0041     struct pca9532_led leds[16];
0042     struct mutex update_lock;
0043     struct input_dev *idev;
0044     struct work_struct work;
0045 #ifdef CONFIG_LEDS_PCA9532_GPIO
0046     struct gpio_chip gpio;
0047 #endif
0048     const struct pca9532_chip_info *chip_info;
0049     u8 pwm[2];
0050     u8 psc[2];
0051 };
0052
0053 static int pca9532_probe(struct i2c_client *client,
0054     const struct i2c_device_id *id);
0055 static int pca9532_remove(struct i2c_client *client);
0056
0057 enum {
0058     pca9530,
0059     pca9531,
0060     pca9532,
0061     pca9533,
0062 };
0063
0064 static const struct i2c_device_id pca9532_id[] = {
0065     { "pca9530", pca9530 },
0066     { "pca9531", pca9531 },
0067     { "pca9532", pca9532 },
0068     { "pca9533", pca9533 },
0069     { }
0070 };
0071
0072 MODULE_DEVICE_TABLE(i2c, pca9532_id);
0073
0074 static const struct pca9532_chip_info pca9532_chip_info_tbl[] = {
0075     [pca9530] = {
0076         .num_leds = 2,
0077     },
0078     [pca9531] = {
0079         .num_leds = 8,
0080     },
0081     [pca9532] = {
0082         .num_leds = 16,
0083     },
0084     [pca9533] = {
0085         .num_leds = 4,
0086     },
0087 };
0088
0089 #ifdef CONFIG_OF
0090 static const struct of_device_id of_pca9532_leds_match[] = {
0091     { .compatible = "nxp,pca9530", .data = (void *)pca9530 },
0092     { .compatible = "nxp,pca9531", .data = (void *)pca9531 },
0093     { .compatible = "nxp,pca9532", .data = (void *)pca9532 },
0094     { .compatible = "nxp,pca9533", .data = (void *)pca9533 },
0095     {},
0096 };
0097
0098 MODULE_DEVICE_TABLE(of, of_pca9532_leds_match);
0099 #endif
0100
0101 static struct i2c_driver pca9532_driver = {
0102     .driver = {
0103         .name = "leds-pca953x",
0104         .of_match_table = of_match_ptr(of_pca9532_leds_match),
0105     },
0106     .probe = pca9532_probe,
0107     .remove = pca9532_remove,
0108     .id_table = pca9532_id,
0109 };
0110
0111 /* We have two pwm/blinkers, but 16 possible leds to drive. Additionally,
0112  * the clever Thecus people are using one pwm to drive the beeper. So,
0113  * as a compromise we average one pwm to the values requested by all
0114  * leds that are not ON/OFF.
0115  * */
0116 static int pca9532_calcpwm(struct i2c_client *client, int pwm, int blink,
0117     enum led_brightness value)
0118 {
0119     int a = 0, b = 0, i = 0;
0120     struct pca9532_data *data = i2c_get_clientdata(client);
0121     for (i = 0; i < data->chip_info->num_leds; i++) {
0122         if (data->leds[i].type == PCA9532_TYPE_LED &&
0123             data->leds[i].state == PCA9532_PWM0+pwm) {
0124                 a++;
0125                 b += data->leds[i].ldev.brightness;
0126         }
0127     }
0128     if (a == 0) {
0129         dev_err(&client->dev,
0130         "fear of division by zero %d/%d, wanted %d\n",
0131             b, a, value);
0132         return -EINVAL;
0133     }
0134     b = b/a;
0135     if (b > 0xFF)
0136         return -EINVAL;
0137     data->pwm[pwm] = b;
0138     data->psc[pwm] = blink;
0139     return 0;
0140 }
0141
0142 static int pca9532_setpwm(struct i2c_client *client, int pwm)
0143 {
0144     struct pca9532_data *data = i2c_get_clientdata(client);
0145     u8 maxleds = data->chip_info->num_leds;
0146
0147     mutex_lock(&data->update_lock);
0148     i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(maxleds, pwm),
0149         data->pwm[pwm]);
0150     i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(maxleds, pwm),
0151         data->psc[pwm]);
0152     mutex_unlock(&data->update_lock);
0153     return 0;
0154 }
0155
0156 /* Set LED routing */
0157 static void pca9532_setled(struct pca9532_led *led)
0158 {
0159     struct i2c_client *client = led->client;
0160     struct pca9532_data *data = i2c_get_clientdata(client);
0161     u8 maxleds = data->chip_info->num_leds;
0162     char reg;
0163
0164     mutex_lock(&data->update_lock);
0165     reg = i2c_smbus_read_byte_data(client, LED_REG(maxleds, led->id));
0166     /* zero led bits */
0167     reg = reg & ~LED_MASK(led->id);
0168     /* set the new value */
0169     reg = reg | (led->state << LED_SHIFT(led->id));
0170     i2c_smbus_write_byte_data(client, LED_REG(maxleds, led->id), reg);
0171     mutex_unlock(&data->update_lock);
0172 }
0173
0174 static int pca9532_set_brightness(struct led_classdev *led_cdev,
0175     enum led_brightness value)
0176 {
0177     int err = 0;
0178     struct pca9532_led *led = ldev_to_led(led_cdev);
0179
0180     if (value == LED_OFF)
0181         led->state = PCA9532_OFF;
0182     else if (value == LED_FULL)
0183         led->state = PCA9532_ON;
0184     else {
0185         led->state = PCA9532_PWM0; /* Thecus: hardcode one pwm */
0186         err = pca9532_calcpwm(led->client, 0, 0, value);
0187         if (err)
0188             return err;
0189     }
0190     if (led->state == PCA9532_PWM0)
0191         pca9532_setpwm(led->client, 0);
0192     pca9532_setled(led);
0193     return err;
0194 }
0195
0196 static int pca9532_set_blink(struct led_classdev *led_cdev,
0197     unsigned long *delay_on, unsigned long *delay_off)
0198 {
0199     struct pca9532_led *led = ldev_to_led(led_cdev);
0200     struct i2c_client *client = led->client;
0201     int psc;
0202     int err = 0;
0203
0204     if (*delay_on == 0 && *delay_off == 0) {
0205         /* led subsystem ask us for a blink rate */
0206         *delay_on = 1000;
0207         *delay_off = 1000;
0208     }
0209     if (*delay_on != *delay_off || *delay_on > 1690 || *delay_on < 6)
0210         return -EINVAL;
0211
0212     /* Thecus specific: only use PSC/PWM 0 */
0213     psc = (*delay_on * 152-1)/1000;
0214     err = pca9532_calcpwm(client, 0, psc, led_cdev->brightness);
0215     if (err)
0216         return err;
0217     if (led->state == PCA9532_PWM0)
0218         pca9532_setpwm(led->client, 0);
0219     pca9532_setled(led);
0220
0221     return 0;
0222 }
0223
0224 static int pca9532_event(struct input_dev *dev, unsigned int type,
0225     unsigned int code, int value)
0226 {
0227     struct pca9532_data *data = input_get_drvdata(dev);
0228
0229     if (!(type == EV_SND && (code == SND_BELL || code == SND_TONE)))
0230         return -1;
0231
0232     /* XXX: allow different kind of beeps with psc/pwm modifications */
0233     if (value > 1 && value < 32767)
0234         data->pwm[1] = 127;
0235     else
0236         data->pwm[1] = 0;
0237
0238     schedule_work(&data->work);
0239
0240     return 0;
0241 }
0242
0243 static void pca9532_input_work(struct work_struct *work)
0244 {
0245     struct pca9532_data *data =
0246         container_of(work, struct pca9532_data, work);
0247     u8 maxleds = data->chip_info->num_leds;
0248
0249     mutex_lock(&data->update_lock);
0250     i2c_smbus_write_byte_data(data->client, PCA9532_REG_PWM(maxleds, 1),
0251         data->pwm[1]);
0252     mutex_unlock(&data->update_lock);
0253 }
0254
0255 static enum pca9532_state pca9532_getled(struct pca9532_led *led)
0256 {
0257     struct i2c_client *client = led->client;
0258     struct pca9532_data *data = i2c_get_clientdata(client);
0259     u8 maxleds = data->chip_info->num_leds;
0260     char reg;
0261     enum pca9532_state ret;
0262
0263     mutex_lock(&data->update_lock);
0264     reg = i2c_smbus_read_byte_data(client, LED_REG(maxleds, led->id));
0265     ret = (reg & LED_MASK(led->id)) >> LED_SHIFT(led->id);
0266     mutex_unlock(&data->update_lock);
0267     return ret;
0268 }
0269
0270 #ifdef CONFIG_LEDS_PCA9532_GPIO
0271 static int pca9532_gpio_request_pin(struct gpio_chip *gc, unsigned offset)
0272 {
0273     struct pca9532_data *data = gpiochip_get_data(gc);
0274     struct pca9532_led *led = &data->leds[offset];
0275
0276     if (led->type == PCA9532_TYPE_GPIO)
0277         return 0;
0278
0279     return -EBUSY;
0280 }
0281
0282 static void pca9532_gpio_set_value(struct gpio_chip *gc, unsigned offset, int val)
0283 {
0284     struct pca9532_data *data = gpiochip_get_data(gc);
0285     struct pca9532_led *led = &data->leds[offset];
0286
0287     if (val)
0288         led->state = PCA9532_ON;
0289     else
0290         led->state = PCA9532_OFF;
0291
0292     pca9532_setled(led);
0293 }
0294
0295 static int pca9532_gpio_get_value(struct gpio_chip *gc, unsigned offset)
0296 {
0297     struct pca9532_data *data = gpiochip_get_data(gc);
0298     unsigned char reg;
0299
0300     reg = i2c_smbus_read_byte_data(data->client, PCA9532_REG_INPUT(offset));
0301
0302     return !!(reg & (1 << (offset % 8)));
0303 }
0304
0305 static int pca9532_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
0306 {
0307     /* To use as input ensure pin is not driven */
0308     pca9532_gpio_set_value(gc, offset, 0);
0309
0310     return 0;
0311 }
0312
0313 static int pca9532_gpio_direction_output(struct gpio_chip *gc, unsigned offset, int val)
0314 {
0315     pca9532_gpio_set_value(gc, offset, val);
0316
0317     return 0;
0318 }
0319 #endif /* CONFIG_LEDS_PCA9532_GPIO */
0320
0321 static void pca9532_destroy_devices(struct pca9532_data *data, int n_devs)
0322 {
0323     int i = n_devs;
0324
0325     while (--i >= 0) {
0326         switch (data->leds[i].type) {
0327         case PCA9532_TYPE_NONE:
0328         case PCA9532_TYPE_GPIO:
0329             break;
0330         case PCA9532_TYPE_LED:
0331             led_classdev_unregister(&data->leds[i].ldev);
0332             break;
0333         case PCA9532_TYPE_N2100_BEEP:
0334             if (data->idev != NULL) {
0335                 cancel_work_sync(&data->work);
0336                 data->idev = NULL;
0337             }
0338             break;
0339         }
0340     }
0341
0342 #ifdef CONFIG_LEDS_PCA9532_GPIO
0343     if (data->gpio.parent)
0344         gpiochip_remove(&data->gpio);
0345 #endif
0346 }
0347
0348 static int pca9532_configure(struct i2c_client *client,
0349     struct pca9532_data *data, struct pca9532_platform_data *pdata)
0350 {
0351     int i, err = 0;
0352     int gpios = 0;
0353     u8 maxleds = data->chip_info->num_leds;
0354
0355     for (i = 0; i < 2; i++) {
0356         data->pwm[i] = pdata->pwm[i];
0357         data->psc[i] = pdata->psc[i];
0358         i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(maxleds, i),
0359             data->pwm[i]);
0360         i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(maxleds, i),
0361             data->psc[i]);
0362     }
0363
0364     for (i = 0; i < data->chip_info->num_leds; i++) {
0365         struct pca9532_led *led = &data->leds[i];
0366         struct pca9532_led *pled = &pdata->leds[i];
0367         led->client = client;
0368         led->id = i;
0369         led->type = pled->type;
0370         switch (led->type) {
0371         case PCA9532_TYPE_NONE:
0372             break;
0373         case PCA9532_TYPE_GPIO:
0374             gpios++;
0375             break;
0376         case PCA9532_TYPE_LED:
0377             if (pled->state == PCA9532_KEEP)
0378                 led->state = pca9532_getled(led);
0379             else
0380                 led->state = pled->state;
0381             led->name = pled->name;
0382             led->ldev.name = led->name;
0383             led->ldev.default_trigger = pled->default_trigger;
0384             led->ldev.brightness = LED_OFF;
0385             led->ldev.brightness_set_blocking =
0386                         pca9532_set_brightness;
0387             led->ldev.blink_set = pca9532_set_blink;
0388             err = led_classdev_register(&client->dev, &led->ldev);
0389             if (err < 0) {
0390                 dev_err(&client->dev,
0391                     "couldn't register LED %s\n",
0392                     led->name);
0393                 goto exit;
0394             }
0395             pca9532_setled(led);
0396             break;
0397         case PCA9532_TYPE_N2100_BEEP:
0398             BUG_ON(data->idev);
0399             led->state = PCA9532_PWM1;
0400             pca9532_setled(led);
0401             data->idev = devm_input_allocate_device(&client->dev);
0402             if (data->idev == NULL) {
0403                 err = -ENOMEM;
0404                 goto exit;
0405             }
0406             data->idev->name = pled->name;
0407             data->idev->phys = "i2c/pca9532";
0408             data->idev->id.bustype = BUS_HOST;
0409             data->idev->id.vendor = 0x001f;
0410             data->idev->id.product = 0x0001;
0411             data->idev->id.version = 0x0100;
0412             data->idev->evbit[0] = BIT_MASK(EV_SND);
0413             data->idev->sndbit[0] = BIT_MASK(SND_BELL) |
0414                         BIT_MASK(SND_TONE);
0415             data->idev->event = pca9532_event;
0416             input_set_drvdata(data->idev, data);
0417             INIT_WORK(&data->work, pca9532_input_work);
0418             err = input_register_device(data->idev);
0419             if (err) {
0420                 cancel_work_sync(&data->work);
0421                 data->idev = NULL;
0422                 goto exit;
0423             }
0424             break;
0425         }
0426     }
0427
0428 #ifdef CONFIG_LEDS_PCA9532_GPIO
0429     if (gpios) {
0430         data->gpio.label = "gpio-pca9532";
0431         data->gpio.direction_input = pca9532_gpio_direction_input;
0432         data->gpio.direction_output = pca9532_gpio_direction_output;
0433         data->gpio.set = pca9532_gpio_set_value;
0434         data->gpio.get = pca9532_gpio_get_value;
0435         data->gpio.request = pca9532_gpio_request_pin;
0436         data->gpio.can_sleep = 1;
0437         data->gpio.base = pdata->gpio_base;
0438         data->gpio.ngpio = data->chip_info->num_leds;
0439         data->gpio.parent = &client->dev;
0440         data->gpio.owner = THIS_MODULE;
0441
0442         err = gpiochip_add_data(&data->gpio, data);
0443         if (err) {
0444             /* Use data->gpio.dev as a flag for freeing gpiochip */
0445             data->gpio.parent = NULL;
0446             dev_warn(&client->dev, "could not add gpiochip\n");
0447         } else {
0448             dev_info(&client->dev, "gpios %i...%i\n",
0449                 data->gpio.base, data->gpio.base +
0450                 data->gpio.ngpio - 1);
0451         }
0452     }
0453 #endif
0454
0455     return 0;
0456
0457 exit:
0458     pca9532_destroy_devices(data, i);
0459     return err;
0460 }
0461
0462 static struct pca9532_platform_data *
0463 pca9532_of_populate_pdata(struct device *dev, struct device_node *np)
0464 {
0465     struct pca9532_platform_data *pdata;
0466     struct device_node *child;
0467     int devid, maxleds;
0468     int i = 0;
0469     const char *state;
0470
0471     devid = (int)(uintptr_t)of_device_get_match_data(dev);
0472     maxleds = pca9532_chip_info_tbl[devid].num_leds;
0473
0474     pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
0475     if (!pdata)
0476         return ERR_PTR(-ENOMEM);
0477
0478     pdata->gpio_base = -1;
0479
0480     of_property_read_u8_array(np, "nxp,pwm", &pdata->pwm[0],
0481                   ARRAY_SIZE(pdata->pwm));
0482     of_property_read_u8_array(np, "nxp,psc", &pdata->psc[0],
0483                   ARRAY_SIZE(pdata->psc));
0484
0485     for_each_available_child_of_node(np, child) {
0486         if (of_property_read_string(child, "label",
0487                         &pdata->leds[i].name))
0488             pdata->leds[i].name = child->name;
0489         of_property_read_u32(child, "type", &pdata->leds[i].type);
0490         of_property_read_string(child, "linux,default-trigger",
0491                     &pdata->leds[i].default_trigger);
0492         if (!of_property_read_string(child, "default-state", &state)) {
0493             if (!strcmp(state, "on"))
0494                 pdata->leds[i].state = PCA9532_ON;
0495             else if (!strcmp(state, "keep"))
0496                 pdata->leds[i].state = PCA9532_KEEP;
0497         }
0498         if (++i >= maxleds) {
0499             of_node_put(child);
0500             break;
0501         }
0502     }
0503
0504     return pdata;
0505 }
0506
0507 static int pca9532_probe(struct i2c_client *client,
0508     const struct i2c_device_id *id)
0509 {
0510     int devid;
0511     struct pca9532_data *data = i2c_get_clientdata(client);
0512     struct pca9532_platform_data *pca9532_pdata =
0513             dev_get_platdata(&client->dev);
0514     struct device_node *np = dev_of_node(&client->dev);
0515
0516     if (!pca9532_pdata) {
0517         if (np) {
0518             pca9532_pdata =
0519                 pca9532_of_populate_pdata(&client->dev, np);
0520             if (IS_ERR(pca9532_pdata))
0521                 return PTR_ERR(pca9532_pdata);
0522         } else {
0523             dev_err(&client->dev, "no platform data\n");
0524             return -EINVAL;
0525         }
0526         devid = (int)(uintptr_t)of_device_get_match_data(&client->dev);
0527     } else {
0528         devid = id->driver_data;
0529     }
0530
0531     if (!i2c_check_functionality(client->adapter,
0532         I2C_FUNC_SMBUS_BYTE_DATA))
0533         return -EIO;
0534
0535     data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
0536     if (!data)
0537         return -ENOMEM;
0538
0539     data->chip_info = &pca9532_chip_info_tbl[devid];
0540
0541     dev_info(&client->dev, "setting platform data\n");
0542     i2c_set_clientdata(client, data);
0543     data->client = client;
0544     mutex_init(&data->update_lock);
0545
0546     return pca9532_configure(client, data, pca9532_pdata);
0547 }
0548
0549 static int pca9532_remove(struct i2c_client *client)
0550 {
0551     struct pca9532_data *data = i2c_get_clientdata(client);
0552
0553     pca9532_destroy_devices(data, data->chip_info->num_leds);
0554
0555     return 0;
0556 }
0557
0558 module_i2c_driver(pca9532_driver);
0559
0560 MODULE_AUTHOR("Riku Voipio");
0561 MODULE_LICENSE("GPL");
0562 MODULE_DESCRIPTION("PCA 9532 LED dimmer");