drivers/input/remotectl/rockchip_pwm_remotectl.c

   1 #include <linux/clk.h>
   2 #include <linux/io.h>
   3 #include <linux/module.h>
   4 #include <linux/of.h>
   5 #include <linux/platform_device.h>
   6 #include <linux/module.h>
   7 #include <linux/init.h>
   8 #include <linux/interrupt.h>
   9 #include <linux/platform_device.h>
  10 #include <linux/input.h>
  11 #include <linux/workqueue.h>
  12 #include <linux/wakelock.h>
  13 #include <linux/slab.h>
  14 #include "rockchip_pwm_remotectl.h"
  15 #include <linux/leds.h>
  16
  17 /*sys/module/rk_pwm_remotectl/parameters,
  18 modify code_print to change the value*/
  19
  20 static int rk_remote_print_code;
  21 module_param_named(code_print, rk_remote_print_code, int, 0644);
  22 #define DBG_CODE(args...) \
  23         do { \
  24                 if (rk_remote_print_code) { \
  25                         pr_info(args); \
  26                 } \
  27         } while (0)
  28
  29 static int rk_remote_pwm_dbg_level;
  30 module_param_named(dbg_level, rk_remote_pwm_dbg_level, int, 0644);
  31 #define DBG(args...) \
  32         do { \
  33                 if (rk_remote_pwm_dbg_level) { \
  34                         pr_info(args); \
  35                 } \
  36         } while (0)
  37
  38 #define BLINK_DELAY 50
  39 DEFINE_LED_TRIGGER(ledtrig_ir_click);
  40 static unsigned long ir_blink_delay = BLINK_DELAY;
  41
  42 void ledtrig_ir_activity(void)
  43 {
  44     led_trigger_blink_oneshot(ledtrig_ir_click, &ir_blink_delay, &ir_blink_delay,1);
  45 }
  46 struct rkxx_remote_key_table {
  47         int scancode;
  48         int keycode;
  49 };
  50
  51 struct rkxx_remotectl_button {
  52         int usercode;
  53         int nbuttons;
  54         struct rkxx_remote_key_table key_table[MAX_NUM_KEYS];
  55 };
  56
  57 struct rkxx_remotectl_drvdata {
  58         void __iomem *base;
  59         int state;
  60         int nbuttons;
  61         int result;
  62         int scandata;
  63         int count;
  64         int keynum;
  65         int maxkeybdnum;
  66         int keycode;
  67         int press;
  68         int pre_press;
  69         int irq;
  70         int remote_pwm_id;
  71         int handle_cpu_id;
  72         int wakeup;
  73         int clk_rate;
  74         unsigned long period;
  75         unsigned long temp_period;
  76         int pwm_freq_nstime;
  77         struct input_dev *input;
  78         struct timer_list timer;
  79         struct tasklet_struct remote_tasklet;
  80         struct wake_lock remotectl_wake_lock;
  81 };
  82
  83 static struct rkxx_remotectl_button *remotectl_button;
  84
  85 static int remotectl_keybd_num_lookup(struct rkxx_remotectl_drvdata *ddata)
  86 {
  87         int i;
  88         int num;
  89
  90         num = ddata->maxkeybdnum;
  91         for (i = 0; i < num; i++) {
  92                 if (remotectl_button[i].usercode == (ddata->scandata&0xFFFF)) {
  93                         ddata->keynum = i;
  94                         return 1;
  95                 }
  96         }
  97         return 0;
  98 }
  99
 100
 101 static int remotectl_keycode_lookup(struct rkxx_remotectl_drvdata *ddata)
 102 {
 103         int i;
 104         unsigned char keydata = (unsigned char)((ddata->scandata >> 8) & 0xff);
 105
 106         for (i = 0; i < remotectl_button[ddata->keynum].nbuttons; i++) {
 107                 if (remotectl_button[ddata->keynum].key_table[i].scancode ==
 108                     keydata) {
 109                         ddata->keycode =
 110                         remotectl_button[ddata->keynum].key_table[i].keycode;
 111                         return 1;
 112                 }
 113         }
 114         return 0;
 115 }
 116
 117 static int rk_remotectl_get_irkeybd_count(struct platform_device *pdev)
 118 {
 119         struct device_node *node = pdev->dev.of_node;
 120         struct device_node *child_node;
 121         int boardnum;
 122         int temp_usercode;
 123
 124         boardnum = 0;
 125         for_each_child_of_node(node, child_node) {
 126                 if(of_property_read_u32(child_node, "rockchip,usercode",
 127                         &temp_usercode)) {
 128                         DBG("get keybd num error.\n");
 129                 } else {
 130                         boardnum++;
 131                 }
 132         }
 133         DBG("get keybd num = 0x%x.\n", boardnum);
 134         return boardnum;
 135 }
 136
 137
 138 static int rk_remotectl_parse_ir_keys(struct platform_device *pdev)
 139 {
 140         struct rkxx_remotectl_drvdata *ddata = platform_get_drvdata(pdev);
 141         struct device_node *node = pdev->dev.of_node;
 142         struct device_node *child_node;
 143         int loop;
 144         int ret;
 145         int len;
 146         int boardnum;
 147
 148         boardnum = 0;
 149         for_each_child_of_node(node, child_node) {
 150                 if(of_property_read_u32(child_node, "rockchip,usercode",
 151                          &remotectl_button[boardnum].usercode)) {
 152                         dev_err(&pdev->dev, "Missing usercode property in the DTS.\n");
 153                         ret = -1;
 154                         return ret;
 155                 }
 156                 DBG("remotectl_button[0].usercode=0x%x\n",
 157                                 remotectl_button[boardnum].usercode);
 158                 of_get_property(child_node, "rockchip,key_table", &len);
 159                 len /= sizeof(u32);
 160                 DBG("len=0x%x\n",len);
 161                 remotectl_button[boardnum].nbuttons = len/2;
 162                 if(of_property_read_u32_array(child_node, "rockchip,key_table",
 163                          (u32 *)remotectl_button[boardnum].key_table, len)) {
 164                         dev_err(&pdev->dev, "Missing key_table property in the DTS.\n");
 165                         ret = -1;
 166                         return ret;
 167                 }
 168                 for (loop=0; loop<(len/2); loop++) {
 169                         DBG("board[%d].scanCode[%d]=0x%x\n", boardnum, loop,
 170                                         remotectl_button[boardnum].key_table[loop].scancode);
 171                         DBG("board[%d].keyCode[%d]=%d\n", boardnum, loop,
 172                                         remotectl_button[boardnum].key_table[loop].keycode);
 173                 }
 174                 boardnum++;
 175                 if (boardnum > ddata->maxkeybdnum)
 176                         break;
 177         }
 178         DBG("keybdNum=0x%x\n",boardnum);
 179         return 0;
 180 }
 181
 182
 183
 184 static void rk_pwm_remotectl_do_something(unsigned long  data)
 185 {
 186         struct rkxx_remotectl_drvdata *ddata;
 187
 188         ddata = (struct rkxx_remotectl_drvdata *)data;
 189         switch (ddata->state) {
 190         case RMC_IDLE: {
 191                 ;
 192                 break;
 193         }
 194         case RMC_PRELOAD: {
 195                 mod_timer(&ddata->timer, jiffies + msecs_to_jiffies(140));
 196                 if ((RK_PWM_TIME_PRE_MIN < ddata->period) &&
 197                     (ddata->period < RK_PWM_TIME_PRE_MAX)) {
 198                         ddata->scandata = 0;
 199                         ddata->count = 0;
 200                         ddata->state = RMC_USERCODE;
 201                 } else {
 202                         ddata->state = RMC_PRELOAD;
 203                 }
 204                 break;
 205         }
 206         case RMC_USERCODE: {
 207                 if ((RK_PWM_TIME_BIT1_MIN < ddata->period) &&
 208                     (ddata->period < RK_PWM_TIME_BIT1_MAX))
 209                         ddata->scandata |= (0x01 << ddata->count);
 210                 ddata->count++;
 211                 if (ddata->count == 0x10) {
 212                         DBG_CODE("USERCODE=0x%x\n", ddata->scandata);
 213                         if (remotectl_keybd_num_lookup(ddata)) {
 214                                 ddata->state = RMC_GETDATA;
 215                                 ddata->scandata = 0;
 216                                 ddata->count = 0;
 217                         } else {
 218                                 if (rk_remote_print_code){
 219                                         ddata->state = RMC_GETDATA;
 220                                         ddata->scandata = 0;
 221                                         ddata->count = 0;
 222                                 } else
 223                                         ddata->state = RMC_PRELOAD;
 224                         }
 225                 }
 226         }
 227         break;
 228         case RMC_GETDATA: {
 229                 if(ddata->keycode != KEY_POWER)
 230                 {
 231                         ledtrig_ir_activity();
 232                         led_trigger_blink_oneshot(ledtrig_ir_click, &ir_blink_delay, &ir_blink_delay,1);
 233                 }
 234
 235                 if ((RK_PWM_TIME_BIT1_MIN < ddata->period) &&
 236                     (ddata->period < RK_PWM_TIME_BIT1_MAX))
 237                         ddata->scandata |= (0x01<<ddata->count);
 238                 ddata->count++;
 239                 if (ddata->count < 0x10)
 240                         return;
 241                 DBG_CODE("RMC_GETDATA=%x\n", (ddata->scandata>>8));
 242                 if ((ddata->scandata&0x0ff) ==
 243                     ((~ddata->scandata >> 8) & 0x0ff)) {
 244                         if (remotectl_keycode_lookup(ddata)) {
 245                                 ddata->press = 1;
 246                                 if(ddata->keycode == KEY_POWER){
 247                     led_trigger_event(ledtrig_ir_click,LED_OFF);
 248                 }
 249                                 input_event(ddata->input, EV_KEY,
 250                                             ddata->keycode, 1);
 251                                 input_sync(ddata->input);
 252                                 ddata->state = RMC_SEQUENCE;
 253                         } else {
 254                                 ddata->state = RMC_PRELOAD;
 255                         }
 256                 } else {
 257                         ddata->state = RMC_PRELOAD;
 258                 }
 259         }
 260         break;
 261         case RMC_SEQUENCE:{
 262                 DBG("S=%ld\n", ddata->period);
 263                 if ((RK_PWM_TIME_RPT_MIN < ddata->period) &&
 264                     (ddata->period < RK_PWM_TIME_RPT_MAX)) {
 265                         DBG("S1\n");
 266                         mod_timer(&ddata->timer, jiffies
 267                                   + msecs_to_jiffies(130));
 268                 } else if ((RK_PWM_TIME_SEQ1_MIN < ddata->period) &&
 269                            (ddata->period < RK_PWM_TIME_SEQ1_MAX)) {
 270                         DBG("S2\n");
 271                         mod_timer(&ddata->timer, jiffies
 272                                   + msecs_to_jiffies(130));
 273                 } else if ((RK_PWM_TIME_SEQ2_MIN < ddata->period) &&
 274                           (ddata->period < RK_PWM_TIME_SEQ2_MAX)) {
 275                         DBG("S3\n");
 276                         mod_timer(&ddata->timer, jiffies
 277                                   + msecs_to_jiffies(130));
 278                 } else {
 279                         DBG("S4\n");
 280                         input_event(ddata->input, EV_KEY,
 281                                     ddata->keycode, 0);
 282                         input_sync(ddata->input);
 283                         ddata->state = RMC_PRELOAD;
 284                         ddata->press = 0;
 285                 }
 286         }
 287         break;
 288         default:
 289         break;
 290         }
 291 }
 292
 293 static void rk_pwm_remotectl_timer(unsigned long _data)
 294 {
 295         struct rkxx_remotectl_drvdata *ddata;
 296
 297         ddata =  (struct rkxx_remotectl_drvdata *)_data;
 298         if (ddata->press != ddata->pre_press) {
 299                 ddata->pre_press = 0;
 300                 ddata->press = 0;
 301                 input_event(ddata->input, EV_KEY, ddata->keycode, 0);
 302                 input_sync(ddata->input);
 303         }
 304         ddata->state = RMC_PRELOAD;
 305 }
 306
 307
 308 static irqreturn_t rockchip_pwm_irq(int irq, void *dev_id)
 309 {
 310         struct rkxx_remotectl_drvdata *ddata = dev_id;
 311         int val;
 312         int temp_hpr;
 313         int temp_lpr;
 314         int temp_period;
 315         unsigned int id = ddata->remote_pwm_id;
 316
 317         if (id > 3)
 318                 return IRQ_NONE;
 319         val = readl_relaxed(ddata->base + PWM_REG_INTSTS(id));
 320         if ((val & PWM_CH_INT(id)) == 0)
 321                 return IRQ_NONE;
 322         if ((val & PWM_CH_POL(id)) == 0) {
 323                 temp_hpr = readl_relaxed(ddata->base + PWM_REG_HPR);
 324                 DBG("hpr=%d\n", temp_hpr);
 325                 temp_lpr = readl_relaxed(ddata->base + PWM_REG_LPR);
 326                 DBG("lpr=%d\n", temp_lpr);
 327                 temp_period = ddata->pwm_freq_nstime * temp_lpr / 1000;
 328                 if (temp_period > RK_PWM_TIME_BIT0_MIN) {
 329                         ddata->period = ddata->temp_period
 330                             + ddata->pwm_freq_nstime * temp_hpr / 1000;
 331                         tasklet_hi_schedule(&ddata->remote_tasklet);
 332                         ddata->temp_period = 0;
 333                         DBG("period+ =%ld\n", ddata->period);
 334                 } else {
 335                         ddata->temp_period += ddata->pwm_freq_nstime
 336                             * (temp_hpr + temp_lpr) / 1000;
 337                 }
 338         }
 339         writel_relaxed(PWM_CH_INT(id), ddata->base + PWM_REG_INTSTS(id));
 340         if (ddata->state == RMC_PRELOAD)
 341                 wake_lock_timeout(&ddata->remotectl_wake_lock, HZ);
 342         return IRQ_HANDLED;
 343 }
 344
 345
 346
 347 static int rk_pwm_remotectl_hw_init(struct rkxx_remotectl_drvdata *ddata)
 348 {
 349         int val;
 350
 351         val = readl_relaxed(ddata->base + PWM_REG_CTRL);
 352         val = (val & 0xFFFFFFFE) | PWM_DISABLE;
 353         writel_relaxed(val, ddata->base + PWM_REG_CTRL);
 354         val = readl_relaxed(ddata->base + PWM_REG_CTRL);
 355         val = (val & 0xFFFFFFF9) | PWM_MODE_CAPTURE;
 356         writel_relaxed(val, ddata->base + PWM_REG_CTRL);
 357         val = readl_relaxed(ddata->base + PWM_REG_CTRL);
 358         val = (val & 0xFF008DFF) | 0x0006000;
 359         writel_relaxed(val, ddata->base + PWM_REG_CTRL);
 360         switch (ddata->remote_pwm_id) {
 361         case 0: {
 362                 val = readl_relaxed(ddata->base + PWM0_REG_INT_EN);
 363                 val = (val & 0xFFFFFFFE) | PWM_CH0_INT_ENABLE;
 364                 writel_relaxed(val, ddata->base + PWM0_REG_INT_EN);
 365         }
 366         break;
 367         case 1: {
 368                 val = readl_relaxed(ddata->base + PWM1_REG_INT_EN);
 369                 val = (val & 0xFFFFFFFD) | PWM_CH1_INT_ENABLE;
 370                 writel_relaxed(val, ddata->base + PWM1_REG_INT_EN);
 371         }
 372         break;
 373         case 2: {
 374                 val = readl_relaxed(ddata->base + PWM2_REG_INT_EN);
 375                 val = (val & 0xFFFFFFFB) | PWM_CH2_INT_ENABLE;
 376                 writel_relaxed(val, ddata->base + PWM2_REG_INT_EN);
 377         }
 378         break;
 379         case 3: {
 380                 val = readl_relaxed(ddata->base + PWM3_REG_INT_EN);
 381                 val = (val & 0xFFFFFFF7) | PWM_CH3_INT_ENABLE;
 382                 writel_relaxed(val, ddata->base + PWM3_REG_INT_EN);
 383         }
 384         break;
 385         default:
 386         break;
 387         }
 388         val = readl_relaxed(ddata->base + PWM_REG_CTRL);
 389         val = (val & 0xFFFFFFFE) | PWM_ENABLE;
 390         writel_relaxed(val, ddata->base + PWM_REG_CTRL);
 391         return 0;
 392 }
 393
 394
 395 static int rk_pwm_probe(struct platform_device *pdev)
 396 {
 397         struct rkxx_remotectl_drvdata *ddata;
 398         struct device_node *np = pdev->dev.of_node;
 399         struct resource *r;
 400         struct input_dev *input;
 401         struct clk *clk;
 402         struct cpumask cpumask;
 403         int num;
 404         int irq;
 405         int ret;
 406         int i, j;
 407         int cpu_id;
 408         int pwm_id;
 409         int pwm_freq;
 410
 411         pr_err(".. rk pwm remotectl v1.1 init\n");
 412         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 413         if (!r) {
 414                 dev_err(&pdev->dev, "no memory resources defined\n");
 415                 return -ENODEV;
 416         }
 417         ddata = devm_kzalloc(&pdev->dev, sizeof(struct rkxx_remotectl_drvdata),
 418                              GFP_KERNEL);
 419         if (!ddata) {
 420                 dev_err(&pdev->dev, "failed to allocate memory\n");
 421                 return -ENOMEM;
 422         }
 423         ddata->state = RMC_PRELOAD;
 424         ddata->temp_period = 0;
 425         ddata->base = devm_ioremap_resource(&pdev->dev, r);
 426         if (IS_ERR(ddata->base))
 427                 return PTR_ERR(ddata->base);
 428         clk = devm_clk_get(&pdev->dev, NULL);
 429         if (IS_ERR(clk))
 430                 return PTR_ERR(clk);
 431         platform_set_drvdata(pdev, ddata);
 432         num = rk_remotectl_get_irkeybd_count(pdev);
 433         if (num == 0) {
 434                 pr_err("remotectl: no ir keyboard add in dts!!\n");
 435                 return -1;
 436         }
 437         ddata->maxkeybdnum = num;
 438         remotectl_button = kmalloc(
 439                                         num*sizeof(struct rkxx_remotectl_button),
 440                                         GFP_KERNEL);
 441         if (!remotectl_button) {
 442                 pr_err("failed to malloc remote button memory\n");
 443                 return -ENOMEM;
 444         }
 445         input = input_allocate_device();
 446         input->name = pdev->name;
 447         input->phys = "gpio-keys/remotectl";
 448         input->dev.parent = &pdev->dev;
 449         input->id.bustype = BUS_HOST;
 450         input->id.vendor = 0x0001;
 451         input->id.product = 0x0001;
 452         input->id.version = 0x0100;
 453         ddata->input = input;
 454         ddata->input = input;
 455         wake_lock_init(&ddata->remotectl_wake_lock,
 456                        WAKE_LOCK_SUSPEND, "rk29_pwm_remote");
 457         ret = clk_prepare_enable(clk);
 458         if (ret)
 459                 return ret;
 460         irq = platform_get_irq(pdev, 0);
 461         if (ret < 0) {
 462                 dev_err(&pdev->dev, "cannot find IRQ\n");
 463                 return ret;
 464         }
 465         ddata->irq = irq;
 466         ddata->wakeup = 1;
 467         of_property_read_u32(np, "remote_pwm_id", &pwm_id);
 468         ddata->remote_pwm_id = pwm_id;
 469         DBG("remotectl: remote pwm id=0x%x\n", pwm_id);
 470         of_property_read_u32(np, "handle_cpu_id", &cpu_id);
 471         ddata->handle_cpu_id = cpu_id;
 472         DBG("remotectl: handle cpu id=0x%x\n", cpu_id);
 473         rk_remotectl_parse_ir_keys(pdev);
 474         tasklet_init(&ddata->remote_tasklet, rk_pwm_remotectl_do_something,
 475                      (unsigned long)ddata);
 476         for (j = 0; j < num; j++) {
 477                 DBG("remotectl probe j = 0x%x\n", j);
 478                 for (i = 0; i < remotectl_button[j].nbuttons; i++) {
 479                         unsigned int type = EV_KEY;
 480
 481                         input_set_capability(input, type, remotectl_button[j].
 482                                              key_table[i].keycode);
 483                 }
 484         }
 485         ret = input_register_device(input);
 486         if (ret)
 487                 pr_err("remotectl: register input device err, ret: %d\n", ret);
 488         input_set_capability(input, EV_KEY, KEY_WAKEUP);
 489         device_init_wakeup(&pdev->dev, 1);
 490         enable_irq_wake(irq);
 491         setup_timer(&ddata->timer, rk_pwm_remotectl_timer,
 492                     (unsigned long)ddata);
 493         //mod_timer(&ddata->timer, jiffies + msecs_to_jiffies(1000));
 494         cpumask_clear(&cpumask);
 495         cpumask_set_cpu(cpu_id, &cpumask);
 496         irq_set_affinity(irq, &cpumask);
 497         ret = devm_request_irq(&pdev->dev, irq, rockchip_pwm_irq,
 498                                IRQF_NO_SUSPEND, "rk_pwm_irq", ddata);
 499         if (ret) {
 500                 dev_err(&pdev->dev, "cannot claim IRQ %d\n", irq);
 501                 return ret;
 502         }
 503         rk_pwm_remotectl_hw_init(ddata);
 504         pwm_freq = clk_get_rate(clk) / 64;
 505         ddata->pwm_freq_nstime = 1000000000 / pwm_freq;
 506         led_trigger_register_simple("ir-power-click", &ledtrig_ir_click);
 507
 508         return ret;
 509 }
 510
 511 static int rk_pwm_remove(struct platform_device *pdev)
 512 {
 513         led_trigger_unregister_simple(ledtrig_ir_click);
 514         return 0;
 515 }
 516
 517 #ifdef CONFIG_PM
 518 static int remotectl_suspend(struct device *dev)
 519 {
 520         int cpu = 0;
 521         struct cpumask cpumask;
 522         struct platform_device *pdev = to_platform_device(dev);
 523         struct rkxx_remotectl_drvdata *ddata = platform_get_drvdata(pdev);
 524
 525         cpumask_clear(&cpumask);
 526         cpumask_set_cpu(cpu, &cpumask);
 527         irq_set_affinity(ddata->irq, &cpumask);
 528         return 0;
 529 }
 530
 531
 532 static int remotectl_resume(struct device *dev)
 533 {
 534         struct cpumask cpumask;
 535         struct platform_device *pdev = to_platform_device(dev);
 536         struct rkxx_remotectl_drvdata *ddata = platform_get_drvdata(pdev);
 537
 538         cpumask_clear(&cpumask);
 539         cpumask_set_cpu(ddata->handle_cpu_id, &cpumask);
 540         irq_set_affinity(ddata->irq, &cpumask);
 541         return 0;
 542 }
 543
 544 static const struct dev_pm_ops remotectl_pm_ops = {
 545         .suspend_late = remotectl_suspend,
 546         .resume_early = remotectl_resume,
 547 };
 548 #endif
 549
 550 static const struct of_device_id rk_pwm_of_match[] = {
 551         { .compatible =  "rockchip,remotectl-pwm"},
 552         { }
 553 };
 554
 555 MODULE_DEVICE_TABLE(of, rk_pwm_of_match);
 556
 557 static struct platform_driver rk_pwm_driver = {
 558         .driver = {
 559                 .name = "remotectl-pwm",
 560                 .of_match_table = rk_pwm_of_match,
 561 #ifdef CONFIG_PM
 562                 .pm = &remotectl_pm_ops,
 563 #endif
 564         },
 565         .probe = rk_pwm_probe,
 566         .remove = rk_pwm_remove,
 567 };
 568
 569 module_platform_driver(rk_pwm_driver);
 570
 571 MODULE_LICENSE("GPL");