drivers/leds/leds-mc13783.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * LEDs driver for Freescale MC13783/MC13892/MC34708
0004  *
0005  * Copyright (C) 2010 Philippe Rétornaz
0006  *
0007  * Based on leds-da903x:
0008  * Copyright (C) 2008 Compulab, Ltd.
0009  *      Mike Rapoport <mike@compulab.co.il>
0010  *
0011  * Copyright (C) 2006-2008 Marvell International Ltd.
0012  *      Eric Miao <eric.miao@marvell.com>
0013  */
0014
0015 #include <linux/module.h>
0016 #include <linux/kernel.h>
0017 #include <linux/platform_device.h>
0018 #include <linux/leds.h>
0019 #include <linux/of.h>
0020 #include <linux/mfd/mc13xxx.h>
0021
0022 struct mc13xxx_led_devtype {
0023     int led_min;
0024     int led_max;
0025     int num_regs;
0026     u32 ledctrl_base;
0027 };
0028
0029 struct mc13xxx_led {
0030     struct led_classdev cdev;
0031     int         id;
0032     struct mc13xxx_leds *leds;
0033 };
0034
0035 struct mc13xxx_leds {
0036     struct mc13xxx          *master;
0037     struct mc13xxx_led_devtype  *devtype;
0038     int             num_leds;
0039     struct mc13xxx_led      *led;
0040 };
0041
0042 static unsigned int mc13xxx_max_brightness(int id)
0043 {
0044     if (id >= MC13783_LED_MD && id <= MC13783_LED_KP)
0045         return 0x0f;
0046     else if (id >= MC13783_LED_R1 && id <= MC13783_LED_B3)
0047         return 0x1f;
0048
0049     return 0x3f;
0050 }
0051
0052 static int mc13xxx_led_set(struct led_classdev *led_cdev,
0053                 enum led_brightness value)
0054 {
0055     struct mc13xxx_led *led =
0056         container_of(led_cdev, struct mc13xxx_led, cdev);
0057     struct mc13xxx_leds *leds = led->leds;
0058     unsigned int reg, bank, off, shift;
0059
0060     switch (led->id) {
0061     case MC13783_LED_MD:
0062     case MC13783_LED_AD:
0063     case MC13783_LED_KP:
0064         reg = 2;
0065         shift = 9 + (led->id - MC13783_LED_MD) * 4;
0066         break;
0067     case MC13783_LED_R1:
0068     case MC13783_LED_G1:
0069     case MC13783_LED_B1:
0070     case MC13783_LED_R2:
0071     case MC13783_LED_G2:
0072     case MC13783_LED_B2:
0073     case MC13783_LED_R3:
0074     case MC13783_LED_G3:
0075     case MC13783_LED_B3:
0076         off = led->id - MC13783_LED_R1;
0077         bank = off / 3;
0078         reg = 3 + bank;
0079         shift = (off - bank * 3) * 5 + 6;
0080         break;
0081     case MC13892_LED_MD:
0082     case MC13892_LED_AD:
0083     case MC13892_LED_KP:
0084         off = led->id - MC13892_LED_MD;
0085         reg = off / 2;
0086         shift = 3 + (off - reg * 2) * 12;
0087         break;
0088     case MC13892_LED_R:
0089     case MC13892_LED_G:
0090     case MC13892_LED_B:
0091         off = led->id - MC13892_LED_R;
0092         bank = off / 2;
0093         reg = 2 + bank;
0094         shift = (off - bank * 2) * 12 + 3;
0095         break;
0096     case MC34708_LED_R:
0097     case MC34708_LED_G:
0098         reg = 0;
0099         shift = 3 + (led->id - MC34708_LED_R) * 12;
0100         break;
0101     default:
0102         BUG();
0103     }
0104
0105     return mc13xxx_reg_rmw(leds->master, leds->devtype->ledctrl_base + reg,
0106             mc13xxx_max_brightness(led->id) << shift,
0107             value << shift);
0108 }
0109
0110 #ifdef CONFIG_OF
0111 static struct mc13xxx_leds_platform_data __init *mc13xxx_led_probe_dt(
0112     struct platform_device *pdev)
0113 {
0114     struct mc13xxx_leds *leds = platform_get_drvdata(pdev);
0115     struct mc13xxx_leds_platform_data *pdata;
0116     struct device_node *parent, *child;
0117     struct device *dev = &pdev->dev;
0118     int i = 0, ret = -ENODATA;
0119
0120     pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
0121     if (!pdata)
0122         return ERR_PTR(-ENOMEM);
0123
0124     parent = of_get_child_by_name(dev_of_node(dev->parent), "leds");
0125     if (!parent)
0126         goto out_node_put;
0127
0128     ret = of_property_read_u32_array(parent, "led-control",
0129                      pdata->led_control,
0130                      leds->devtype->num_regs);
0131     if (ret)
0132         goto out_node_put;
0133
0134     pdata->num_leds = of_get_available_child_count(parent);
0135
0136     pdata->led = devm_kcalloc(dev, pdata->num_leds, sizeof(*pdata->led),
0137                   GFP_KERNEL);
0138     if (!pdata->led) {
0139         ret = -ENOMEM;
0140         goto out_node_put;
0141     }
0142
0143     for_each_available_child_of_node(parent, child) {
0144         const char *str;
0145         u32 tmp;
0146
0147         if (of_property_read_u32(child, "reg", &tmp))
0148             continue;
0149         pdata->led[i].id = leds->devtype->led_min + tmp;
0150
0151         if (!of_property_read_string(child, "label", &str))
0152             pdata->led[i].name = str;
0153         if (!of_property_read_string(child, "linux,default-trigger",
0154                          &str))
0155             pdata->led[i].default_trigger = str;
0156
0157         i++;
0158     }
0159
0160     pdata->num_leds = i;
0161     ret = i > 0 ? 0 : -ENODATA;
0162
0163 out_node_put:
0164     of_node_put(parent);
0165
0166     return ret ? ERR_PTR(ret) : pdata;
0167 }
0168 #else
0169 static inline struct mc13xxx_leds_platform_data __init *mc13xxx_led_probe_dt(
0170     struct platform_device *pdev)
0171 {
0172     return ERR_PTR(-ENOSYS);
0173 }
0174 #endif
0175
0176 static int __init mc13xxx_led_probe(struct platform_device *pdev)
0177 {
0178     struct device *dev = &pdev->dev;
0179     struct mc13xxx_leds_platform_data *pdata = dev_get_platdata(dev);
0180     struct mc13xxx *mcdev = dev_get_drvdata(dev->parent);
0181     struct mc13xxx_led_devtype *devtype =
0182         (struct mc13xxx_led_devtype *)pdev->id_entry->driver_data;
0183     struct mc13xxx_leds *leds;
0184     int i, id, ret = -ENODATA;
0185     u32 init_led = 0;
0186
0187     leds = devm_kzalloc(dev, sizeof(*leds), GFP_KERNEL);
0188     if (!leds)
0189         return -ENOMEM;
0190
0191     leds->devtype = devtype;
0192     leds->master = mcdev;
0193     platform_set_drvdata(pdev, leds);
0194
0195     if (dev_of_node(dev->parent)) {
0196         pdata = mc13xxx_led_probe_dt(pdev);
0197         if (IS_ERR(pdata))
0198             return PTR_ERR(pdata);
0199     } else if (!pdata)
0200         return -ENODATA;
0201
0202     leds->num_leds = pdata->num_leds;
0203
0204     if ((leds->num_leds < 1) ||
0205         (leds->num_leds > (devtype->led_max - devtype->led_min + 1))) {
0206         dev_err(dev, "Invalid LED count %d\n", leds->num_leds);
0207         return -EINVAL;
0208     }
0209
0210     leds->led = devm_kcalloc(dev, leds->num_leds, sizeof(*leds->led),
0211                  GFP_KERNEL);
0212     if (!leds->led)
0213         return -ENOMEM;
0214
0215     for (i = 0; i < devtype->num_regs; i++) {
0216         ret = mc13xxx_reg_write(mcdev, leds->devtype->ledctrl_base + i,
0217                     pdata->led_control[i]);
0218         if (ret)
0219             return ret;
0220     }
0221
0222     for (i = 0; i < leds->num_leds; i++) {
0223         const char *name, *trig;
0224
0225         ret = -EINVAL;
0226
0227         id = pdata->led[i].id;
0228         name = pdata->led[i].name;
0229         trig = pdata->led[i].default_trigger;
0230
0231         if ((id > devtype->led_max) || (id < devtype->led_min)) {
0232             dev_err(dev, "Invalid ID %i\n", id);
0233             break;
0234         }
0235
0236         if (init_led & (1 << id)) {
0237             dev_warn(dev, "LED %i already initialized\n", id);
0238             break;
0239         }
0240
0241         init_led |= 1 << id;
0242         leds->led[i].id = id;
0243         leds->led[i].leds = leds;
0244         leds->led[i].cdev.name = name;
0245         leds->led[i].cdev.default_trigger = trig;
0246         leds->led[i].cdev.flags = LED_CORE_SUSPENDRESUME;
0247         leds->led[i].cdev.brightness_set_blocking = mc13xxx_led_set;
0248         leds->led[i].cdev.max_brightness = mc13xxx_max_brightness(id);
0249
0250         ret = led_classdev_register(dev->parent, &leds->led[i].cdev);
0251         if (ret) {
0252             dev_err(dev, "Failed to register LED %i\n", id);
0253             break;
0254         }
0255     }
0256
0257     if (ret)
0258         while (--i >= 0)
0259             led_classdev_unregister(&leds->led[i].cdev);
0260
0261     return ret;
0262 }
0263
0264 static int mc13xxx_led_remove(struct platform_device *pdev)
0265 {
0266     struct mc13xxx_leds *leds = platform_get_drvdata(pdev);
0267     int i;
0268
0269     for (i = 0; i < leds->num_leds; i++)
0270         led_classdev_unregister(&leds->led[i].cdev);
0271
0272     return 0;
0273 }
0274
0275 static const struct mc13xxx_led_devtype mc13783_led_devtype = {
0276     .led_min    = MC13783_LED_MD,
0277     .led_max    = MC13783_LED_B3,
0278     .num_regs   = 6,
0279     .ledctrl_base   = 51,
0280 };
0281
0282 static const struct mc13xxx_led_devtype mc13892_led_devtype = {
0283     .led_min    = MC13892_LED_MD,
0284     .led_max    = MC13892_LED_B,
0285     .num_regs   = 4,
0286     .ledctrl_base   = 51,
0287 };
0288
0289 static const struct mc13xxx_led_devtype mc34708_led_devtype = {
0290     .led_min    = MC34708_LED_R,
0291     .led_max    = MC34708_LED_G,
0292     .num_regs   = 1,
0293     .ledctrl_base   = 54,
0294 };
0295
0296 static const struct platform_device_id mc13xxx_led_id_table[] = {
0297     { "mc13783-led", (kernel_ulong_t)&mc13783_led_devtype, },
0298     { "mc13892-led", (kernel_ulong_t)&mc13892_led_devtype, },
0299     { "mc34708-led", (kernel_ulong_t)&mc34708_led_devtype, },
0300     { }
0301 };
0302 MODULE_DEVICE_TABLE(platform, mc13xxx_led_id_table);
0303
0304 static struct platform_driver mc13xxx_led_driver = {
0305     .driver = {
0306         .name   = "mc13xxx-led",
0307     },
0308     .remove     = mc13xxx_led_remove,
0309     .id_table   = mc13xxx_led_id_table,
0310 };
0311 module_platform_driver_probe(mc13xxx_led_driver, mc13xxx_led_probe);
0312
0313 MODULE_DESCRIPTION("LEDs driver for Freescale MC13XXX PMIC");
0314 MODULE_AUTHOR("Philippe Retornaz <philippe.retornaz@epfl.ch>");
0315 MODULE_LICENSE("GPL");