target/linux/mvebu/patches-5.10/910-drivers-leds-wt61p803-puzzle-improvements.patch

   1 --- a/drivers/leds/leds-iei-wt61p803-puzzle.c
   2 +++ b/drivers/leds/leds-iei-wt61p803-puzzle.c
   3 @@ -9,10 +9,13 @@
   4  #include <linux/mfd/iei-wt61p803-puzzle.h>
   5  #include <linux/mod_devicetable.h>
   6  #include <linux/module.h>
   7 +#include <linux/of.h>
   8  #include <linux/platform_device.h>
   9  #include <linux/property.h>
  10  #include <linux/slab.h>
  11
  12 +#define IEI_LEDS_MAX           4
  13 +
  14  enum iei_wt61p803_puzzle_led_state {
  15         IEI_LED_OFF = 0x30,
  16         IEI_LED_ON = 0x31,
  17 @@ -34,6 +37,9 @@ struct iei_wt61p803_puzzle_led {
  18         unsigned char response_buffer[IEI_WT61P803_PUZZLE_BUF_SIZE];
  19         struct mutex lock; /* mutex to protect led_power_state */
  20         int led_power_state;
  21 +       int id;
  22 +       bool blinking;
  23 +       bool active_low;
  24  };
  25
  26  static inline struct iei_wt61p803_puzzle_led *cdev_to_iei_wt61p803_puzzle_led
  27 @@ -51,10 +57,20 @@ static int iei_wt61p803_puzzle_led_brigh
  28         size_t reply_size;
  29         int ret;
  30
  31 +       mutex_lock(&priv->lock);
  32 +       if (priv->blinking) {
  33 +               if (brightness == LED_OFF)
  34 +                       priv->blinking = false;
  35 +               else
  36 +                       return 0;
  37 +       }
  38 +       mutex_unlock(&priv->lock);
  39 +
  40         led_power_cmd[0] = IEI_WT61P803_PUZZLE_CMD_HEADER_START;
  41         led_power_cmd[1] = IEI_WT61P803_PUZZLE_CMD_LED;
  42 -       led_power_cmd[2] = IEI_WT61P803_PUZZLE_CMD_LED_POWER;
  43 -       led_power_cmd[3] = brightness == LED_OFF ? IEI_LED_OFF : IEI_LED_ON;
  44 +       led_power_cmd[2] = IEI_WT61P803_PUZZLE_CMD_LED_SET(priv->id);
  45 +       led_power_cmd[3] = ((brightness == LED_OFF) ^ priv->active_low) ?
  46 +                               IEI_LED_OFF : IEI_LED_ON;
  47
  48         ret = iei_wt61p803_puzzle_write_command(priv->mcu, led_power_cmd,
  49                                                 sizeof(led_power_cmd),
  50 @@ -90,39 +106,164 @@ static enum led_brightness iei_wt61p803_
  51         return led_state;
  52  }
  53
  54 +static int iei_wt61p803_puzzle_led_set_blink(struct led_classdev *cdev,
  55 +                                            unsigned long *delay_on,
  56 +                                            unsigned long *delay_off)
  57 +{
  58 +       struct iei_wt61p803_puzzle_led *priv = cdev_to_iei_wt61p803_puzzle_led(cdev);
  59 +       unsigned char led_blink_cmd[5] = {};
  60 +       unsigned char resp_buf[IEI_WT61P803_PUZZLE_BUF_SIZE];
  61 +       size_t reply_size;
  62 +       int ret = 0;
  63 +
  64 +       /* set defaults */
  65 +       if (!*delay_on && !*delay_off) {
  66 +               *delay_on = 500;
  67 +               *delay_off = 500;
  68 +       }
  69 +
  70 +       /* minimum delay for soft-driven blinking is 50ms to keep load low */
  71 +       if (*delay_on < 50)
  72 +               *delay_on = 50;
  73 +
  74 +       if (*delay_off < 50)
  75 +               *delay_off = 50;
  76 +
  77 +       if (*delay_on != *delay_off)
  78 +               return -EINVAL;
  79 +
  80 +       /* aggressively offload blinking to hardware, if possible */
  81 +       if (*delay_on < 100) {
  82 +               return -EINVAL;
  83 +       } else if (*delay_on < 200) {
  84 +               *delay_on = 100;
  85 +               *delay_off = 100;
  86 +       } else if (*delay_on <= 500) {
  87 +               *delay_on = 500;
  88 +               *delay_off = 500;
  89 +       } else {
  90 +               return -EINVAL;
  91 +       }
  92 +
  93 +       led_blink_cmd[0] = IEI_WT61P803_PUZZLE_CMD_HEADER_START;
  94 +       led_blink_cmd[1] = IEI_WT61P803_PUZZLE_CMD_LED;
  95 +       led_blink_cmd[2] = IEI_WT61P803_PUZZLE_CMD_LED_SET(priv->id);
  96 +       led_blink_cmd[3] = (*delay_on == 100)?IEI_LED_BLINK_5HZ:IEI_LED_BLINK_1HZ;
  97 +
  98 +       ret = iei_wt61p803_puzzle_write_command(priv->mcu, led_blink_cmd,
  99 +                                               sizeof(led_blink_cmd),
 100 +                                               resp_buf,
 101 +                                               &reply_size);
 102 +
 103 +       if (ret)
 104 +               return ret;
 105 +
 106 +       if (reply_size != 3)
 107 +               return -EIO;
 108 +
 109 +       if (!(resp_buf[0] == IEI_WT61P803_PUZZLE_CMD_HEADER_START &&
 110 +             resp_buf[1] == IEI_WT61P803_PUZZLE_CMD_RESPONSE_OK &&
 111 +             resp_buf[2] == IEI_WT61P803_PUZZLE_CHECKSUM_RESPONSE_OK))
 112 +               return -EIO;
 113 +
 114 +       mutex_lock(&priv->lock);
 115 +       priv->blinking = true;
 116 +       mutex_unlock(&priv->lock);
 117 +
 118 +       return ret;
 119 +}
 120 +
 121 +static int iei_wt61p803_puzzle_led_set_dt_default(struct led_classdev *cdev,
 122 +                                    struct device_node *np)
 123 +{
 124 +       const char *state;
 125 +       int ret = 0;
 126 +
 127 +       state = of_get_property(np, "default-state", NULL);
 128 +       if (state) {
 129 +               if (!strcmp(state, "on")) {
 130 +                       ret =
 131 +                       iei_wt61p803_puzzle_led_brightness_set_blocking(
 132 +                               cdev, cdev->max_brightness);
 133 +               } else  {
 134 +                       ret = iei_wt61p803_puzzle_led_brightness_set_blocking(
 135 +                               cdev, LED_OFF);
 136 +               }
 137 +       }
 138 +
 139 +       return ret;
 140 +}
 141 +
 142  static int iei_wt61p803_puzzle_led_probe(struct platform_device *pdev)
 143  {
 144         struct device *dev = &pdev->dev;
 145 +       struct device_node *np = dev_of_node(dev);
 146 +       struct device_node *child;
 147         struct iei_wt61p803_puzzle *mcu = dev_get_drvdata(dev->parent);
 148         struct iei_wt61p803_puzzle_led *priv;
 149 -       struct led_init_data init_data = {};
 150 -       struct fwnode_handle *child;
 151         int ret;
 152 +       u32 reg;
 153
 154 -       if (device_get_child_node_count(dev) != 1)
 155 +       if (device_get_child_node_count(dev) > IEI_LEDS_MAX)
 156                 return -EINVAL;
 157
 158 -       priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 159 -       if (!priv)
 160 -               return -ENOMEM;
 161 -
 162 -       priv->mcu = mcu;
 163 -       priv->led_power_state = 1;
 164 -       mutex_init(&priv->lock);
 165 -       dev_set_drvdata(dev, priv);
 166 -
 167 -       child = device_get_next_child_node(dev, NULL);
 168 -       init_data.fwnode = child;
 169 -
 170 -       priv->cdev.brightness_set_blocking = iei_wt61p803_puzzle_led_brightness_set_blocking;
 171 -       priv->cdev.brightness_get = iei_wt61p803_puzzle_led_brightness_get;
 172 -       priv->cdev.max_brightness = 1;
 173 +       for_each_available_child_of_node(np, child) {
 174 +               struct led_init_data init_data = {};
 175
 176 -       ret = devm_led_classdev_register_ext(dev, &priv->cdev, &init_data);
 177 -       if (ret)
 178 -               dev_err(dev, "Could not register LED\n");
 179 +               ret = of_property_read_u32(child, "reg", &reg);
 180 +               if (ret) {
 181 +                       dev_err(dev, "Failed to read led 'reg' property\n");
 182 +                       goto put_child_node;
 183 +               }
 184 +
 185 +               if (reg > IEI_LEDS_MAX) {
 186 +                       dev_err(dev, "Invalid led reg %u\n", reg);
 187 +                       ret = -EINVAL;
 188 +                       goto put_child_node;
 189 +               }
 190 +
 191 +               priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 192 +               if (!priv) {
 193 +                       ret = -ENOMEM;
 194 +                       goto put_child_node;
 195 +               }
 196 +
 197 +               mutex_init(&priv->lock);
 198 +
 199 +               dev_set_drvdata(dev, priv);
 200 +
 201 +               if (of_property_read_bool(child, "active-low"))
 202 +                       priv->active_low = true;
 203 +
 204 +               priv->mcu = mcu;
 205 +               priv->id = reg;
 206 +               priv->led_power_state = 1;
 207 +               priv->blinking = false;
 208 +               init_data.fwnode = of_fwnode_handle(child);
 209 +
 210 +               priv->cdev.brightness_set_blocking = iei_wt61p803_puzzle_led_brightness_set_blocking;
 211 +               priv->cdev.brightness_get = iei_wt61p803_puzzle_led_brightness_get;
 212 +               priv->cdev.blink_set = iei_wt61p803_puzzle_led_set_blink;
 213 +
 214 +               priv->cdev.max_brightness = 1;
 215 +
 216 +               ret = iei_wt61p803_puzzle_led_set_dt_default(&priv->cdev, child);
 217 +               if (ret) {
 218 +                       dev_err(dev, "Could apply default from DT\n");
 219 +                       goto put_child_node;
 220 +               }
 221 +
 222 +               ret = devm_led_classdev_register_ext(dev, &priv->cdev, &init_data);
 223 +               if (ret) {
 224 +                       dev_err(dev, "Could not register LED\n");
 225 +                       goto put_child_node;
 226 +               }
 227 +       }
 228 +
 229 +       return ret;
 230
 231 -       fwnode_handle_put(child);
 232 +put_child_node:
 233 +       of_node_put(child);
 234         return ret;
 235  }
 236
 237 --- a/include/linux/mfd/iei-wt61p803-puzzle.h
 238 +++ b/include/linux/mfd/iei-wt61p803-puzzle.h
 239 @@ -36,7 +36,7 @@
 240  #define IEI_WT61P803_PUZZLE_CMD_FUNCTION_OTHER_POWER_LOSS 0x41 /* A */
 241
 242  #define IEI_WT61P803_PUZZLE_CMD_LED                    0x52 /* R */
 243 -#define IEI_WT61P803_PUZZLE_CMD_LED_POWER              0x31 /* 1 */
 244 +#define IEI_WT61P803_PUZZLE_CMD_LED_SET(n)             (0x30 | (n))
 245
 246  #define IEI_WT61P803_PUZZLE_CMD_TEMP                   0x54 /* T */
 247  #define IEI_WT61P803_PUZZLE_CMD_TEMP_ALL               0x41 /* A */