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 --- 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,18 +68,46 @@ 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  }
 104
 105 -
 106  static int rt_timer_request(struct rt_timer *rt)
 107  {
 108 -       int err = request_irq(rt->irq, rt_timer_irq, IRQF_DISABLED,
 109 -                                               dev_name(rt->dev), rt);
 110 +       int err = devm_request_irq(rt->dev, rt->irq, rt_timer_irq,
 111 +                                       IRQF_DISABLED, dev_name(rt->dev), rt);
 112         if (err) {
 113                 dev_err(rt->dev, "failed to request irq\n");
 114         } else {
 115 @@ -81,8 +129,6 @@ static int rt_timer_config(struct rt_tim
 116         else
 117                 rt->timer_div = divisor;
 118
 119 -       rt_timer_w32(rt, TIMER_REG_TMR0LOAD, rt->timer_freq / rt->timer_div);
 120 -
 121         return 0;
 122  }
 123
 124 @@ -108,11 +154,128 @@ static void rt_timer_disable(struct rt_t
 125         rt_timer_w32(rt, TIMER_REG_TMR0CTL, t);
 126  }
 127
 128 +static ssize_t led_fade_show(struct device *dev,
 129 +                               struct device_attribute *attr, char *buf)
 130 +{
 131 +       struct led_classdev *led_cdev = dev_get_drvdata(dev);
 132 +       struct rt_timer *rt = container_of(led_cdev->trigger, struct rt_timer, led_trigger);
 133 +
 134 +       return sprintf(buf, "speed: %d, min: %d, max: %d\n", rt->fade_speed, rt->fade_min, rt->fade_max);
 135 +}
 136 +
 137 +static ssize_t led_fade_store(struct device *dev,
 138 +               struct device_attribute *attr, const char *buf, size_t size)
 139 +{
 140 +       struct led_classdev *led_cdev = dev_get_drvdata(dev);
 141 +       struct rt_timer *rt = container_of(led_cdev->trigger, struct rt_timer, led_trigger);
 142 +       unsigned int speed = 0, min = 0, max = 0;
 143 +       ssize_t ret = -EINVAL;
 144 +
 145 +       ret = sscanf(buf, "%u %u %u", &speed, &min, &max);
 146 +
 147 +       if (ret == 3) {
 148 +               rt->fade_speed = speed;
 149 +               rt->fade_min = min;
 150 +               rt->fade_max = max;
 151 +               rt->fade = 1;
 152 +       } else {
 153 +               rt->fade = 0;
 154 +       }
 155 +
 156 +       return size;
 157 +}
 158 +
 159 +static DEVICE_ATTR(fade, 0644, led_fade_show, led_fade_store);
 160 +
 161 +static ssize_t led_duty_cycle_show(struct device *dev,
 162 +                               struct device_attribute *attr, char *buf)
 163 +{
 164 +       struct led_classdev *led_cdev = dev_get_drvdata(dev);
 165 +       struct rt_timer *rt = container_of(led_cdev->trigger, struct rt_timer, led_trigger);
 166 +
 167 +       return sprintf(buf, "%u\n", rt->duty_cycle);
 168 +}
 169 +
 170 +static ssize_t led_duty_cycle_store(struct device *dev,
 171 +               struct device_attribute *attr, const char *buf, size_t size)
 172 +{
 173 +       struct led_classdev *led_cdev = dev_get_drvdata(dev);
 174 +       struct rt_timer *rt = container_of(led_cdev->trigger, struct rt_timer, led_trigger);
 175 +       unsigned long state;
 176 +       ssize_t ret = -EINVAL;
 177 +
 178 +       ret = kstrtoul(buf, 10, &state);
 179 +       if (ret)
 180 +               return ret;
 181 +
 182 +       if (state <= 100)
 183 +               rt->duty_cycle = state;
 184 +       else
 185 +               rt->duty_cycle = 100;
 186 +
 187 +       rt->fade = 0;
 188 +
 189 +       return size;
 190 +}
 191 +
 192 +static DEVICE_ATTR(duty_cycle, 0644, led_duty_cycle_show, led_duty_cycle_store);
 193 +
 194 +static void rt_timer_trig_activate(struct led_classdev *led_cdev)
 195 +{
 196 +       struct rt_timer *rt = container_of(led_cdev->trigger, struct rt_timer, led_trigger);
 197 +       struct rt_timer_gpio *gpio_data;
 198 +       int rc;
 199 +
 200 +       led_cdev->trigger_data = NULL;
 201 +       gpio_data = kzalloc(sizeof(*gpio_data), GFP_KERNEL);
 202 +       if (!gpio_data)
 203 +               return;
 204 +
 205 +       rc = device_create_file(led_cdev->dev, &dev_attr_duty_cycle);
 206 +       if (rc)
 207 +               goto err_gpio;
 208 +       rc = device_create_file(led_cdev->dev, &dev_attr_fade);
 209 +       if (rc)
 210 +               goto err_out_duty_cycle;
 211 +
 212 +       led_cdev->activated = true;
 213 +       led_cdev->trigger_data = gpio_data;
 214 +       gpio_data->led = led_cdev;
 215 +       list_add(&gpio_data->list, &rt->gpios);
 216 +       led_cdev->trigger_data = gpio_data;
 217 +       rt_timer_enable(rt);
 218 +       return;
 219 +
 220 +err_out_duty_cycle:
 221 +       device_remove_file(led_cdev->dev, &dev_attr_duty_cycle);
 222 +
 223 +err_gpio:
 224 +       kfree(gpio_data);
 225 +}
 226 +
 227 +static void rt_timer_trig_deactivate(struct led_classdev *led_cdev)
 228 +{
 229 +       struct rt_timer *rt = container_of(led_cdev->trigger, struct rt_timer, led_trigger);
 230 +       struct rt_timer_gpio *gpio_data = (struct rt_timer_gpio*) led_cdev->trigger_data;
 231 +
 232 +       if (led_cdev->activated) {
 233 +               device_remove_file(led_cdev->dev, &dev_attr_duty_cycle);
 234 +               device_remove_file(led_cdev->dev, &dev_attr_fade);
 235 +               led_cdev->activated = false;
 236 +       }
 237 +
 238 +       list_del(&gpio_data->list);
 239 +       rt_timer_disable(rt);
 240 +       led_set_brightness(led_cdev, LED_OFF);
 241 +}
 242 +
 243  static int rt_timer_probe(struct platform_device *pdev)
 244  {
 245         struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 246 +       const __be32 *divisor;
 247         struct rt_timer *rt;
 248         struct clk *clk;
 249 +       int ret;
 250
 251         rt = devm_kzalloc(&pdev->dev, sizeof(*rt), GFP_KERNEL);
 252         if (!rt) {
 253 @@ -140,12 +303,29 @@ static int rt_timer_probe(struct platfor
 254         if (!rt->timer_freq)
 255                 return -EINVAL;
 256
 257 +       rt->duty_cycle = 100;
 258         rt->dev = &pdev->dev;
 259         platform_set_drvdata(pdev, rt);
 260
 261 -       rt_timer_request(rt);
 262 -       rt_timer_config(rt, 2);
 263 -       rt_timer_enable(rt);
 264 +       ret = rt_timer_request(rt);
 265 +       if (ret)
 266 +               return ret;
 267 +
 268 +       divisor = of_get_property(pdev->dev.of_node, "ralink,divisor", NULL);
 269 +       if (divisor)
 270 +               rt_timer_config(rt, be32_to_cpu(*divisor));
 271 +       else
 272 +               rt_timer_config(rt, 200);
 273 +
 274 +       rt->led_trigger.name = "pwmtimer",
 275 +       rt->led_trigger.activate = rt_timer_trig_activate,
 276 +       rt->led_trigger.deactivate = rt_timer_trig_deactivate,
 277 +
 278 +       ret = led_trigger_register(&rt->led_trigger);
 279 +       if (ret)
 280 +               return ret;
 281 +
 282 +       INIT_LIST_HEAD(&rt->gpios);
 283
 284         dev_info(&pdev->dev, "maximum frequency is %luHz\n", rt->timer_freq);
 285
 286 @@ -156,6 +336,7 @@ static int rt_timer_remove(struct platfo
 287  {
 288         struct rt_timer *rt = platform_get_drvdata(pdev);
 289
 290 +       led_trigger_unregister(&rt->led_trigger);
 291         rt_timer_disable(rt);
 292         rt_timer_free(rt);
 293
 294 @@ -180,6 +361,6 @@ static struct platform_driver rt_timer_d
 295
 296  module_platform_driver(rt_timer_driver);
 297
 298 -MODULE_DESCRIPTION("Ralink RT2880 timer");
 299 +MODULE_DESCRIPTION("Ralink RT2880 timer / pseudo pwm");
 300  MODULE_AUTHOR("John Crispin <blogic@openwrt.org");
 301  MODULE_LICENSE("GPL");