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