target/linux/bcm63xx/patches-5.4/030-v5.9-leds-bcm6328-support-second-hw-blinking-interval.patch

   1 From e190f57df3c7e7713687905c14e72fbcbd81c5e4 Mon Sep 17 00:00:00 2001
   2 From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= <noltari@gmail.com>
   3 Date: Thu, 4 Jun 2020 15:59:05 +0200
   4 Subject: [PATCH] leds-bcm6328: support second hw blinking interval
   5 MIME-Version: 1.0
   6 Content-Type: text/plain; charset=UTF-8
   7 Content-Transfer-Encoding: 8bit
   8
   9 Right now the driver uses only 3 LED modes:
  10 0: On
  11 1: HW Blinking (Interval 1)
  12 3: Off
  13
  14 However, the controller supports a second HW blinking interval, which results
  15 in 4 possible LED modes:
  16 0: On
  17 1: HW Blinking (Interval 1)
  18 2: HW Blinking (Interval 2)
  19 3: Off
  20
  21 Signed-off-by: Álvaro Fernández Rojas <noltari@gmail.com>
  22 Signed-off-by: Pavel Machek <pavel@ucw.cz>
  23 ---
  24  drivers/leds/leds-bcm6328.c | 97 ++++++++++++++++++++++++++++---------
  25  1 file changed, 75 insertions(+), 22 deletions(-)
  26
  27 --- a/drivers/leds/leds-bcm6328.c
  28 +++ b/drivers/leds/leds-bcm6328.c
  29 @@ -24,12 +24,17 @@
  30
  31  #define BCM6328_LED_MAX_COUNT          24
  32  #define BCM6328_LED_DEF_DELAY          500
  33 -#define BCM6328_LED_INTERVAL_MS                20
  34
  35 -#define BCM6328_LED_INTV_MASK          0x3f
  36 -#define BCM6328_LED_FAST_INTV_SHIFT    6
  37 -#define BCM6328_LED_FAST_INTV_MASK     (BCM6328_LED_INTV_MASK << \
  38 -                                        BCM6328_LED_FAST_INTV_SHIFT)
  39 +#define BCM6328_LED_BLINK_DELAYS       2
  40 +#define BCM6328_LED_BLINK_MS           20
  41 +
  42 +#define BCM6328_LED_BLINK_MASK         0x3f
  43 +#define BCM6328_LED_BLINK1_SHIFT       0
  44 +#define BCM6328_LED_BLINK1_MASK                (BCM6328_LED_BLINK_MASK << \
  45 +                                        BCM6328_LED_BLINK1_SHIFT)
  46 +#define BCM6328_LED_BLINK2_SHIFT       6
  47 +#define BCM6328_LED_BLINK2_MASK                (BCM6328_LED_BLINK_MASK << \
  48 +                                        BCM6328_LED_BLINK2_SHIFT)
  49  #define BCM6328_SERIAL_LED_EN          BIT(12)
  50  #define BCM6328_SERIAL_LED_MUX         BIT(13)
  51  #define BCM6328_SERIAL_LED_CLK_NPOL    BIT(14)
  52 @@ -45,8 +50,8 @@
  53
  54  #define BCM6328_LED_MODE_MASK          3
  55  #define BCM6328_LED_MODE_ON            0
  56 -#define BCM6328_LED_MODE_FAST          1
  57 -#define BCM6328_LED_MODE_BLINK         2
  58 +#define BCM6328_LED_MODE_BLINK1                1
  59 +#define BCM6328_LED_MODE_BLINK2                2
  60  #define BCM6328_LED_MODE_OFF           3
  61  #define BCM6328_LED_SHIFT(X)           ((X) << 1)
  62
  63 @@ -127,12 +132,18 @@ static void bcm6328_led_set(struct led_c
  64         unsigned long flags;
  65
  66         spin_lock_irqsave(led->lock, flags);
  67 -       *(led->blink_leds) &= ~BIT(led->pin);
  68 +
  69 +       /* Remove LED from cached HW blinking intervals */
  70 +       led->blink_leds[0] &= ~BIT(led->pin);
  71 +       led->blink_leds[1] &= ~BIT(led->pin);
  72 +
  73 +       /* Set LED on/off */
  74         if ((led->active_low && value == LED_OFF) ||
  75             (!led->active_low && value != LED_OFF))
  76                 bcm6328_led_mode(led, BCM6328_LED_MODE_ON);
  77         else
  78                 bcm6328_led_mode(led, BCM6328_LED_MODE_OFF);
  79 +
  80         spin_unlock_irqrestore(led->lock, flags);
  81  }
  82
  83 @@ -140,8 +151,8 @@ static unsigned long bcm6328_blink_delay
  84  {
  85         unsigned long bcm6328_delay;
  86
  87 -       bcm6328_delay = delay + BCM6328_LED_INTERVAL_MS / 2;
  88 -       bcm6328_delay = bcm6328_delay / BCM6328_LED_INTERVAL_MS;
  89 +       bcm6328_delay = delay + BCM6328_LED_BLINK_MS / 2;
  90 +       bcm6328_delay = bcm6328_delay / BCM6328_LED_BLINK_MS;
  91         if (bcm6328_delay == 0)
  92                 bcm6328_delay = 1;
  93
  94 @@ -168,28 +179,68 @@ static int bcm6328_blink_set(struct led_
  95                 return -EINVAL;
  96         }
  97
  98 -       if (delay > BCM6328_LED_INTV_MASK) {
  99 +       if (delay > BCM6328_LED_BLINK_MASK) {
 100                 dev_dbg(led_cdev->dev,
 101                         "fallback to soft blinking (delay > %ums)\n",
 102 -                       BCM6328_LED_INTV_MASK * BCM6328_LED_INTERVAL_MS);
 103 +                       BCM6328_LED_BLINK_MASK * BCM6328_LED_BLINK_MS);
 104                 return -EINVAL;
 105         }
 106
 107         spin_lock_irqsave(led->lock, flags);
 108 -       if (*(led->blink_leds) == 0 ||
 109 -           *(led->blink_leds) == BIT(led->pin) ||
 110 -           *(led->blink_delay) == delay) {
 111 +       /*
 112 +        * Check if any of the two configurable HW blinking intervals is
 113 +        * available:
 114 +        *   1. No LEDs assigned to the HW blinking interval.
 115 +        *   2. Only this LED is assigned to the HW blinking interval.
 116 +        *   3. LEDs with the same delay assigned.
 117 +        */
 118 +       if (led->blink_leds[0] == 0 ||
 119 +           led->blink_leds[0] == BIT(led->pin) ||
 120 +           led->blink_delay[0] == delay) {
 121                 unsigned long val;
 122
 123 -               *(led->blink_leds) |= BIT(led->pin);
 124 -               *(led->blink_delay) = delay;
 125 +               /* Add LED to the first HW blinking interval cache */
 126 +               led->blink_leds[0] |= BIT(led->pin);
 127 +
 128 +               /* Remove LED from the second HW blinking interval cache */
 129 +               led->blink_leds[1] &= ~BIT(led->pin);
 130
 131 +               /* Cache first HW blinking interval delay */
 132 +               led->blink_delay[0] = delay;
 133 +
 134 +               /* Update the delay for the first HW blinking interval */
 135                 val = bcm6328_led_read(led->mem + BCM6328_REG_INIT);
 136 -               val &= ~BCM6328_LED_FAST_INTV_MASK;
 137 -               val |= (delay << BCM6328_LED_FAST_INTV_SHIFT);
 138 +               val &= ~BCM6328_LED_BLINK1_MASK;
 139 +               val |= (delay << BCM6328_LED_BLINK1_SHIFT);
 140                 bcm6328_led_write(led->mem + BCM6328_REG_INIT, val);
 141
 142 -               bcm6328_led_mode(led, BCM6328_LED_MODE_BLINK);
 143 +               /* Set the LED to first HW blinking interval */
 144 +               bcm6328_led_mode(led, BCM6328_LED_MODE_BLINK1);
 145 +
 146 +               rc = 0;
 147 +       } else if (led->blink_leds[1] == 0 ||
 148 +                  led->blink_leds[1] == BIT(led->pin) ||
 149 +                  led->blink_delay[1] == delay) {
 150 +               unsigned long val;
 151 +
 152 +               /* Remove LED from the first HW blinking interval */
 153 +               led->blink_leds[0] &= ~BIT(led->pin);
 154 +
 155 +               /* Add LED to the second HW blinking interval */
 156 +               led->blink_leds[1] |= BIT(led->pin);
 157 +
 158 +               /* Cache second HW blinking interval delay */
 159 +               led->blink_delay[1] = delay;
 160 +
 161 +               /* Update the delay for the second HW blinking interval */
 162 +               val = bcm6328_led_read(led->mem + BCM6328_REG_INIT);
 163 +               val &= ~BCM6328_LED_BLINK2_MASK;
 164 +               val |= (delay << BCM6328_LED_BLINK2_SHIFT);
 165 +               bcm6328_led_write(led->mem + BCM6328_REG_INIT, val);
 166 +
 167 +               /* Set the LED to second HW blinking interval */
 168 +               bcm6328_led_mode(led, BCM6328_LED_MODE_BLINK2);
 169 +
 170                 rc = 0;
 171         } else {
 172                 dev_dbg(led_cdev->dev,
 173 @@ -363,11 +414,13 @@ static int bcm6328_leds_probe(struct pla
 174         if (!lock)
 175                 return -ENOMEM;
 176
 177 -       blink_leds = devm_kzalloc(dev, sizeof(*blink_leds), GFP_KERNEL);
 178 +       blink_leds = devm_kcalloc(dev, BCM6328_LED_BLINK_DELAYS,
 179 +                                 sizeof(*blink_leds), GFP_KERNEL);
 180         if (!blink_leds)
 181                 return -ENOMEM;
 182
 183 -       blink_delay = devm_kzalloc(dev, sizeof(*blink_delay), GFP_KERNEL);
 184 +       blink_delay = devm_kcalloc(dev, BCM6328_LED_BLINK_DELAYS,
 185 +                                  sizeof(*blink_delay), GFP_KERNEL);
 186         if (!blink_delay)
 187                 return -ENOMEM;
 188