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