target/linux/ramips/patches-3.14/0019-MIPS-ralink-add-pseudo-pwm-led-trigger-based-on-time.patch

   1 From 9de00286e20a5f5edc419698373010f1cb6ff0ce Mon Sep 17 00:00:00 2001
   2 From: John Crispin <blogic@openwrt.org>
   3 Date: Sun, 27 Jul 2014 09:25:02 +0100
   4 Subject: [PATCH 19/57] MIPS: ralink: add pseudo pwm led trigger based on
   5  timer0
   6
   7 Signed-off-by: John Crispin <blogic@openwrt.org>
   8 ---
   9  arch/mips/ralink/timer.c |  213 ++++++++++++++++++++++++++++++++++++++++++----
  10  1 file changed, 197 insertions(+), 16 deletions(-)
  11
  12 diff --git a/arch/mips/ralink/timer.c b/arch/mips/ralink/timer.c
  13 index e38692a..a71a7cb 100644
  14 --- a/arch/mips/ralink/timer.c
  15 +++ b/arch/mips/ralink/timer.c
  16 @@ -12,6 +12,8 @@
  17  #include <linux/timer.h>
  18  #include <linux/of_gpio.h>
  19  #include <linux/clk.h>
  20 +#include <linux/leds.h>
  21 +#include <linux/slab.h>
  22
  23  #include <asm/mach-ralink/ralink_regs.h>
  24
  25 @@ -23,16 +25,34 @@
  26
  27  #define TMR0CTL_ENABLE                 BIT(7)
  28  #define TMR0CTL_MODE_PERIODIC          BIT(4)
  29 -#define TMR0CTL_PRESCALER              1
  30 +#define TMR0CTL_PRESCALER              2
  31  #define TMR0CTL_PRESCALE_VAL           (0xf - TMR0CTL_PRESCALER)
  32  #define TMR0CTL_PRESCALE_DIV           (65536 / BIT(TMR0CTL_PRESCALER))
  33
  34 +struct rt_timer_gpio {
  35 +       struct list_head        list;
  36 +       struct led_classdev     *led;
  37 +};
  38 +
  39  struct rt_timer {
  40 -       struct device   *dev;
  41 -       void __iomem    *membase;
  42 -       int             irq;
  43 -       unsigned long   timer_freq;
  44 -       unsigned long   timer_div;
  45 +       struct device           *dev;
  46 +       void __iomem            *membase;
  47 +       int                     irq;
  48 +
  49 +       unsigned long           timer_freq;
  50 +       unsigned long           timer_div;
  51 +
  52 +       struct list_head        gpios;
  53 +       struct led_trigger      led_trigger;
  54 +       unsigned int            duty_cycle;
  55 +       unsigned int            duty;
  56 +
  57 +       unsigned int            fade;
  58 +       unsigned int            fade_min;
  59 +       unsigned int            fade_max;
  60 +       unsigned int            fade_speed;
  61 +       unsigned int            fade_dir;
  62 +       unsigned int            fade_count;
  63  };
  64
  65  static inline void rt_timer_w32(struct rt_timer *rt, u8 reg, u32 val)
  66 @@ -48,18 +68,46 @@ static inline u32 rt_timer_r32(struct rt_timer *rt, u8 reg)
  67  static irqreturn_t rt_timer_irq(int irq, void *_rt)
  68  {
  69         struct rt_timer *rt =  (struct rt_timer *) _rt;
  70 +       struct rt_timer_gpio *gpio;
  71 +       unsigned int val;
  72
  73 -       rt_timer_w32(rt, TIMER_REG_TMR0LOAD, rt->timer_freq / rt->timer_div);
  74 +       if (rt->fade && (rt->fade_count++ > rt->fade_speed)) {
  75 +               rt->fade_count = 0;
  76 +               if (rt->duty_cycle <= rt->fade_min)
  77 +                       rt->fade_dir = 1;
  78 +               else if (rt->duty_cycle >= rt->fade_max)
  79 +                       rt->fade_dir = 0;
  80 +
  81 +               if (rt->fade_dir)
  82 +                       rt->duty_cycle += 1;
  83 +               else
  84 +                       rt->duty_cycle -= 1;
  85 +
  86 +       }
  87 +
  88 +       val = rt->timer_freq / rt->timer_div;
  89 +       if (rt->duty)
  90 +               val *= rt->duty_cycle;
  91 +       else
  92 +               val *= (100 - rt->duty_cycle);
  93 +       val /= 100;
  94 +
  95 +       if (!list_empty(&rt->gpios))
  96 +               list_for_each_entry(gpio, &rt->gpios, list)
  97 +                       led_set_brightness(gpio->led, !!rt->duty);
  98 +
  99 +       rt->duty = !rt->duty;
 100 +
 101 +       rt_timer_w32(rt, TIMER_REG_TMR0LOAD, val + 1);
 102         rt_timer_w32(rt, TIMER_REG_TMRSTAT, TMRSTAT_TMR0INT);
 103
 104         return IRQ_HANDLED;
 105  }
 106
 107 -
 108  static int rt_timer_request(struct rt_timer *rt)
 109  {
 110 -       int err = request_irq(rt->irq, rt_timer_irq, IRQF_DISABLED,
 111 -                                               dev_name(rt->dev), rt);
 112 +       int err = devm_request_irq(rt->dev, rt->irq, rt_timer_irq,
 113 +                                       IRQF_DISABLED, dev_name(rt->dev), rt);
 114         if (err) {
 115                 dev_err(rt->dev, "failed to request irq\n");
 116         } else {
 117 @@ -81,8 +129,6 @@ static int rt_timer_config(struct rt_timer *rt, unsigned long divisor)
 118         else
 119                 rt->timer_div = divisor;
 120
 121 -       rt_timer_w32(rt, TIMER_REG_TMR0LOAD, rt->timer_freq / rt->timer_div);
 122 -
 123         return 0;
 124  }
 125
 126 @@ -108,11 +154,128 @@ static void rt_timer_disable(struct rt_timer *rt)
 127         rt_timer_w32(rt, TIMER_REG_TMR0CTL, t);
 128  }
 129
 130 +static ssize_t led_fade_show(struct device *dev,
 131 +                               struct device_attribute *attr, char *buf)
 132 +{
 133 +       struct led_classdev *led_cdev = dev_get_drvdata(dev);
 134 +       struct rt_timer *rt = container_of(led_cdev->trigger, struct rt_timer, led_trigger);
 135 +
 136 +       return sprintf(buf, "speed: %d, min: %d, max: %d\n", rt->fade_speed, rt->fade_min, rt->fade_max);
 137 +}
 138 +
 139 +static ssize_t led_fade_store(struct device *dev,
 140 +               struct device_attribute *attr, const char *buf, size_t size)
 141 +{
 142 +       struct led_classdev *led_cdev = dev_get_drvdata(dev);
 143 +       struct rt_timer *rt = container_of(led_cdev->trigger, struct rt_timer, led_trigger);
 144 +       unsigned int speed = 0, min = 0, max = 0;
 145 +       ssize_t ret = -EINVAL;
 146 +
 147 +       ret = sscanf(buf, "%u %u %u", &speed, &min, &max);
 148 +
 149 +       if (ret == 3) {
 150 +               rt->fade_speed = speed;
 151 +               rt->fade_min = min;
 152 +               rt->fade_max = max;
 153 +               rt->fade = 1;
 154 +       } else {
 155 +               rt->fade = 0;
 156 +       }
 157 +
 158 +       return size;
 159 +}
 160 +
 161 +static DEVICE_ATTR(fade, 0644, led_fade_show, led_fade_store);
 162 +
 163 +static ssize_t led_duty_cycle_show(struct device *dev,
 164 +                               struct device_attribute *attr, char *buf)
 165 +{
 166 +       struct led_classdev *led_cdev = dev_get_drvdata(dev);
 167 +       struct rt_timer *rt = container_of(led_cdev->trigger, struct rt_timer, led_trigger);
 168 +
 169 +       return sprintf(buf, "%u\n", rt->duty_cycle);
 170 +}
 171 +
 172 +static ssize_t led_duty_cycle_store(struct device *dev,
 173 +               struct device_attribute *attr, const char *buf, size_t size)
 174 +{
 175 +       struct led_classdev *led_cdev = dev_get_drvdata(dev);
 176 +       struct rt_timer *rt = container_of(led_cdev->trigger, struct rt_timer, led_trigger);
 177 +       unsigned long state;
 178 +       ssize_t ret = -EINVAL;
 179 +
 180 +       ret = kstrtoul(buf, 10, &state);
 181 +       if (ret)
 182 +               return ret;
 183 +
 184 +       if (state <= 100)
 185 +               rt->duty_cycle = state;
 186 +       else
 187 +               rt->duty_cycle = 100;
 188 +
 189 +       rt->fade = 0;
 190 +
 191 +       return size;
 192 +}
 193 +
 194 +static DEVICE_ATTR(duty_cycle, 0644, led_duty_cycle_show, led_duty_cycle_store);
 195 +
 196 +static void rt_timer_trig_activate(struct led_classdev *led_cdev)
 197 +{
 198 +       struct rt_timer *rt = container_of(led_cdev->trigger, struct rt_timer, led_trigger);
 199 +       struct rt_timer_gpio *gpio_data;
 200 +       int rc;
 201 +
 202 +       led_cdev->trigger_data = NULL;
 203 +       gpio_data = kzalloc(sizeof(*gpio_data), GFP_KERNEL);
 204 +       if (!gpio_data)
 205 +               return;
 206 +
 207 +       rc = device_create_file(led_cdev->dev, &dev_attr_duty_cycle);
 208 +       if (rc)
 209 +               goto err_gpio;
 210 +       rc = device_create_file(led_cdev->dev, &dev_attr_fade);
 211 +       if (rc)
 212 +               goto err_out_duty_cycle;
 213 +
 214 +       led_cdev->activated = true;
 215 +       led_cdev->trigger_data = gpio_data;
 216 +       gpio_data->led = led_cdev;
 217 +       list_add(&gpio_data->list, &rt->gpios);
 218 +       led_cdev->trigger_data = gpio_data;
 219 +       rt_timer_enable(rt);
 220 +       return;
 221 +
 222 +err_out_duty_cycle:
 223 +       device_remove_file(led_cdev->dev, &dev_attr_duty_cycle);
 224 +
 225 +err_gpio:
 226 +       kfree(gpio_data);
 227 +}
 228 +
 229 +static void rt_timer_trig_deactivate(struct led_classdev *led_cdev)
 230 +{
 231 +       struct rt_timer *rt = container_of(led_cdev->trigger, struct rt_timer, led_trigger);
 232 +       struct rt_timer_gpio *gpio_data = (struct rt_timer_gpio*) led_cdev->trigger_data;
 233 +
 234 +       if (led_cdev->activated) {
 235 +               device_remove_file(led_cdev->dev, &dev_attr_duty_cycle);
 236 +               device_remove_file(led_cdev->dev, &dev_attr_fade);
 237 +               led_cdev->activated = false;
 238 +       }
 239 +
 240 +       list_del(&gpio_data->list);
 241 +       rt_timer_disable(rt);
 242 +       led_set_brightness(led_cdev, LED_OFF);
 243 +}
 244 +
 245  static int rt_timer_probe(struct platform_device *pdev)
 246  {
 247         struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 248 +       const __be32 *divisor;
 249         struct rt_timer *rt;
 250         struct clk *clk;
 251 +       int ret;
 252
 253         rt = devm_kzalloc(&pdev->dev, sizeof(*rt), GFP_KERNEL);
 254         if (!rt) {
 255 @@ -140,12 +303,29 @@ static int rt_timer_probe(struct platform_device *pdev)
 256         if (!rt->timer_freq)
 257                 return -EINVAL;
 258
 259 +       rt->duty_cycle = 100;
 260         rt->dev = &pdev->dev;
 261         platform_set_drvdata(pdev, rt);
 262
 263 -       rt_timer_request(rt);
 264 -       rt_timer_config(rt, 2);
 265 -       rt_timer_enable(rt);
 266 +       ret = rt_timer_request(rt);
 267 +       if (ret)
 268 +               return ret;
 269 +
 270 +       divisor = of_get_property(pdev->dev.of_node, "ralink,divisor", NULL);
 271 +       if (divisor)
 272 +               rt_timer_config(rt, be32_to_cpu(*divisor));
 273 +       else
 274 +               rt_timer_config(rt, 200);
 275 +
 276 +       rt->led_trigger.name = "pwmtimer",
 277 +       rt->led_trigger.activate = rt_timer_trig_activate,
 278 +       rt->led_trigger.deactivate = rt_timer_trig_deactivate,
 279 +
 280 +       ret = led_trigger_register(&rt->led_trigger);
 281 +       if (ret)
 282 +               return ret;
 283 +
 284 +       INIT_LIST_HEAD(&rt->gpios);
 285
 286         dev_info(&pdev->dev, "maximum frequency is %luHz\n", rt->timer_freq);
 287
 288 @@ -156,6 +336,7 @@ static int rt_timer_remove(struct platform_device *pdev)
 289  {
 290         struct rt_timer *rt = platform_get_drvdata(pdev);
 291
 292 +       led_trigger_unregister(&rt->led_trigger);
 293         rt_timer_disable(rt);
 294         rt_timer_free(rt);
 295
 296 @@ -180,6 +361,6 @@ static struct platform_driver rt_timer_driver = {
 297
 298  module_platform_driver(rt_timer_driver);
 299
 300 -MODULE_DESCRIPTION("Ralink RT2880 timer");
 301 +MODULE_DESCRIPTION("Ralink RT2880 timer / pseudo pwm");
 302  MODULE_AUTHOR("John Crispin <blogic@openwrt.org");
 303  MODULE_LICENSE("GPL");
 304 --
 305 1.7.10.4
 306