target/linux/mediatek/files/drivers/leds/leds-smartrg-system.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2
   3 #include <linux/delay.h>
   4 #include <linux/i2c.h>
   5 #include <linux/init.h>
   6 #include <linux/leds.h>
   7 #include <linux/module.h>
   8 #include <linux/mutex.h>
   9 #include <linux/of.h>
  10
  11 /**
  12  * Driver for SmartRG RGBW LED microcontroller.
  13  * RGBW LED is connected to a Holtek HT45F0062 that is on the I2C bus.
  14  *
  15  */
  16
  17 struct srg_led_ctrl;
  18 struct srg_led {
  19         u8 index;
  20         struct led_classdev led;
  21         struct srg_led_ctrl *ctrl;
  22 };
  23
  24 struct srg_led_ctrl {
  25         struct mutex lock;
  26         struct i2c_client *client;
  27         struct srg_led channel[4];
  28         u8 control[5];
  29 };
  30
  31 static int
  32 srg_led_i2c_write(struct srg_led_ctrl *sysled_ctrl, u8 reg, u8 value)
  33 {
  34         return i2c_smbus_write_byte_data(sysled_ctrl->client, reg, value);
  35 }
  36
  37 /*
  38  * MC LED Command: 0 = OFF, 1 = ON, 2 = Flash, 3 = Pulse, 4 = Blink
  39  * */
  40 static int
  41 srg_led_control_sync(struct srg_led_ctrl *sysled_ctrl)
  42 {
  43         int i, ret;
  44
  45         for (i = 1; i < 5; i++) {
  46                 ret = srg_led_i2c_write(sysled_ctrl, i, sysled_ctrl->control[i]);
  47                 if (ret)
  48                         break;
  49         }
  50         return ret;
  51 }
  52
  53 /*
  54  * This function overrides the led driver timer trigger to offload
  55  * flashing to the micro-controller.  The negative effect of this
  56  * is the inability to configure the delay_on and delay_off periods.
  57  *
  58  * */
  59 static int
  60 srg_led_set_pulse(struct led_classdev *led_cdev,
  61                   unsigned long *delay_on,
  62                   unsigned long *delay_off)
  63 {
  64         struct srg_led *sysled = container_of(led_cdev, struct srg_led, led);
  65         struct srg_led_ctrl *sysled_ctrl = sysled->ctrl;
  66         bool blinking = false, pulsing = false;
  67         u8 cbyte;
  68         int ret;
  69
  70         if (delay_on && delay_off && (*delay_on > 100) && (*delay_on <= 500)) {
  71                 pulsing = true;
  72                 *delay_on = 500;
  73                 *delay_off = 500;
  74         } else if (delay_on && delay_off && (*delay_on >= 50) && (*delay_on <= 100)) {
  75                 blinking = true;
  76                 *delay_on = 50;
  77                 *delay_off = 50;
  78         }
  79
  80         cbyte = pulsing ? 3 : blinking ? 2 : 0;
  81         mutex_lock(&sysled_ctrl->lock);
  82         ret = srg_led_i2c_write(sysled_ctrl, sysled->index + 4,
  83                                 (blinking || pulsing) ? 255 : 0);
  84         if (!ret) {
  85                 sysled_ctrl->control[sysled->index] = cbyte;
  86                 ret = srg_led_control_sync(sysled_ctrl);
  87         }
  88         mutex_unlock(&sysled_ctrl->lock);
  89
  90         return !cbyte;
  91 }
  92
  93 static int
  94 srg_led_set_brightness(struct led_classdev *led_cdev,
  95                         enum led_brightness value)
  96 {
  97         struct srg_led *sysled = container_of(led_cdev, struct srg_led, led);
  98         struct srg_led_ctrl *sysled_ctrl = sysled->ctrl;
  99         int ret;
 100
 101         mutex_lock(&sysled_ctrl->lock);
 102         ret = srg_led_i2c_write(sysled_ctrl, sysled->index + 4, value);
 103         if (!ret) {
 104                 sysled_ctrl->control[sysled->index] = !!value;
 105                 ret = srg_led_control_sync(sysled_ctrl);
 106         }
 107         mutex_unlock(&sysled_ctrl->lock);
 108         return ret;
 109 }
 110
 111 static int
 112 srg_led_init_led(struct srg_led_ctrl *sysled_ctrl, struct device_node *np)
 113 {
 114         struct led_init_data init_data = {};
 115         struct led_classdev *led_cdev;
 116         struct srg_led *sysled;
 117         int index, ret;
 118
 119         if (!np)
 120                 return -ENOENT;
 121
 122         ret = of_property_read_u32(np, "reg", &index);
 123         if (ret) {
 124                 dev_err(&sysled_ctrl->client->dev,
 125                         "srg_led_init_led: no reg defined in np!\n");
 126                 return ret;
 127         }
 128
 129         if (index < 1 || index > 4)
 130                 return -EINVAL;
 131
 132         sysled = &sysled_ctrl->channel[index - 1];
 133         led_cdev = &sysled->led;
 134
 135         sysled->index = index;
 136         sysled->ctrl = sysled_ctrl;
 137
 138         init_data.fwnode = of_fwnode_handle(np);
 139
 140         led_cdev->name = of_get_property(np, "label", NULL) ? : np->name;
 141         led_cdev->brightness = LED_OFF;
 142         led_cdev->max_brightness = LED_FULL;
 143         led_cdev->brightness_set_blocking = srg_led_set_brightness;
 144         led_cdev->blink_set = srg_led_set_pulse;
 145
 146         srg_led_i2c_write(sysled_ctrl, index + 4, 0);
 147
 148         ret = devm_led_classdev_register_ext(&sysled_ctrl->client->dev,
 149                                                 led_cdev, &init_data);
 150         if (ret) {
 151                 dev_err(&sysled_ctrl->client->dev,
 152                         "srg_led_init_led: led register %s error ret %d!n",
 153                         led_cdev->name, ret);
 154                 return ret;
 155         }
 156
 157         return 0;
 158 }
 159
 160 static int
 161
 162 srg_led_probe(struct i2c_client *client)
 163 {
 164         struct device_node *np = client->dev.of_node, *child;
 165         struct srg_led_ctrl *sysled_ctrl;
 166
 167         sysled_ctrl = devm_kzalloc(&client->dev, sizeof(*sysled_ctrl), GFP_KERNEL);
 168         if (!sysled_ctrl)
 169                 return -ENOMEM;
 170
 171         sysled_ctrl->client = client;
 172
 173         mutex_init(&sysled_ctrl->lock);
 174
 175         i2c_set_clientdata(client, sysled_ctrl);
 176
 177         for_each_child_of_node(np, child) {
 178                 if (srg_led_init_led(sysled_ctrl, child))
 179                         continue;
 180
 181                 msleep(5);
 182         }
 183
 184         return srg_led_control_sync(sysled_ctrl);;
 185 }
 186
 187 static void srg_led_disable(struct i2c_client *client)
 188 {
 189         struct srg_led_ctrl *sysled_ctrl = i2c_get_clientdata(client);
 190         int i;
 191
 192         for (i = 1; i < 10; i++)
 193                 srg_led_i2c_write(sysled_ctrl, i, 0);
 194 }
 195
 196 static void
 197 srg_led_remove(struct i2c_client *client)
 198 {
 199         struct srg_led_ctrl *sysled_ctrl = i2c_get_clientdata(client);
 200
 201         srg_led_disable(client);
 202         mutex_destroy(&sysled_ctrl->lock);
 203 }
 204
 205 static const struct i2c_device_id srg_led_id[] = {
 206         { "srg-sysled", 0 },
 207         { }
 208 };
 209 MODULE_DEVICE_TABLE(i2c, srg_led_id);
 210
 211 static const struct of_device_id of_srg_led_match[] = {
 212         { .compatible = "srg,sysled", },
 213         {},
 214 };
 215 MODULE_DEVICE_TABLE(of, of_srg_led_match);
 216
 217 static struct i2c_driver srg_sysled_driver = {
 218         .driver = {
 219                 .name   = "srg-sysled",
 220                 .of_match_table = of_srg_led_match,
 221         },
 222         .probe          = srg_led_probe,
 223         .remove         = srg_led_remove,
 224         .id_table       = srg_led_id,
 225 };
 226 module_i2c_driver(srg_sysled_driver);
 227
 228 MODULE_DESCRIPTION("SmartRG system LED driver");
 229 MODULE_AUTHOR("Shen Loh <shen.loh@adtran.com>");
 230 MODULE_AUTHOR("Daniel Golle <daniel@makrotopia.org>");
 231 MODULE_LICENSE("GPL v2");