3 #include <linux/module.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"
18 /*sys/module/rk_pwm_remotectl/parameters,
19 modify code_print to change the value*/
21 static int rk_remote_print_code;
22 module_param_named(code_print, rk_remote_print_code, int, 0644);
23 #define DBG_CODE(args...) \
25 if (rk_remote_print_code) { \
30 static int rk_remote_pwm_dbg_level;
31 module_param_named(dbg_level, rk_remote_pwm_dbg_level, int, 0644);
32 #define DBG(args...) \
34 if (rk_remote_pwm_dbg_level) { \
40 struct rkxx_remote_key_table {
45 struct rkxx_remotectl_button {
48 struct rkxx_remote_key_table key_table[MAX_NUM_KEYS];
51 struct rkxx_remotectl_drvdata {
68 struct input_dev *input;
69 struct timer_list timer;
70 struct tasklet_struct remote_tasklet;
71 struct wake_lock remotectl_wake_lock;
74 static struct rkxx_remotectl_button *remotectl_button;
77 static int remotectl_keybd_num_lookup(struct rkxx_remotectl_drvdata *ddata)
82 num = ddata->maxkeybdnum;
83 for (i = 0; i < num; i++) {
84 if (remotectl_button[i].usercode == (ddata->scandata&0xFFFF)) {
93 static int remotectl_keycode_lookup(struct rkxx_remotectl_drvdata *ddata)
96 unsigned char keydata = (unsigned char)((ddata->scandata >> 8) & 0xff);
98 for (i = 0; i < remotectl_button[ddata->keynum].nbuttons; i++) {
99 if (remotectl_button[ddata->keynum].key_table[i].scancode ==
102 remotectl_button[ddata->keynum].key_table[i].keycode;
109 static int rk_remotectl_get_irkeybd_count(struct platform_device *pdev)
111 struct device_node *node = pdev->dev.of_node;
112 struct device_node *child_node;
117 for_each_child_of_node(node, child_node) {
118 if(of_property_read_u32(child_node, "rockchip,usercode",
120 DBG("get keybd num error.\n");
125 DBG("get keybd num = 0x%x.\n", boardnum);
130 static int rk_remotectl_parse_ir_keys(struct platform_device *pdev)
132 struct rkxx_remotectl_drvdata *ddata = platform_get_drvdata(pdev);
133 struct device_node *node = pdev->dev.of_node;
134 struct device_node *child_node;
141 for_each_child_of_node(node, child_node) {
142 if(of_property_read_u32(child_node, "rockchip,usercode",
143 &remotectl_button[boardnum].usercode)) {
144 dev_err(&pdev->dev, "Missing usercode property in the DTS.\n");
148 DBG("remotectl_button[0].usercode=0x%x\n",
149 remotectl_button[boardnum].usercode);
150 of_get_property(child_node, "rockchip,key_table", &len);
152 DBG("len=0x%x\n",len);
153 remotectl_button[boardnum].nbuttons = len/2;
154 if(of_property_read_u32_array(child_node, "rockchip,key_table",
155 (u32 *)remotectl_button[boardnum].key_table, len)) {
156 dev_err(&pdev->dev, "Missing key_table property in the DTS.\n");
160 for (loop=0; loop<(len/2); loop++) {
161 DBG("board[%d].scanCode[%d]=0x%x\n", boardnum, loop,
162 remotectl_button[boardnum].key_table[loop].scancode);
163 DBG("board[%d].keyCode[%d]=%d\n", boardnum, loop,
164 remotectl_button[boardnum].key_table[loop].keycode);
167 if (boardnum > ddata->maxkeybdnum)
170 DBG("keybdNum=0x%x\n",boardnum);
176 static void rk_pwm_remotectl_do_something(unsigned long data)
178 struct rkxx_remotectl_drvdata *ddata;
180 ddata = (struct rkxx_remotectl_drvdata *)data;
181 switch (ddata->state) {
187 mod_timer(&ddata->timer, jiffies + msecs_to_jiffies(140));
188 if ((RK_PWM_TIME_PRE_MIN < ddata->period) &&
189 (ddata->period < RK_PWM_TIME_PRE_MAX)) {
192 ddata->state = RMC_USERCODE;
194 ddata->state = RMC_PRELOAD;
199 if ((RK_PWM_TIME_BIT1_MIN < ddata->period) &&
200 (ddata->period < RK_PWM_TIME_BIT1_MAX))
201 ddata->scandata |= (0x01 << ddata->count);
203 if (ddata->count == 0x10) {
204 DBG_CODE("USERCODE=0x%x\n", ddata->scandata);
205 if (remotectl_keybd_num_lookup(ddata)) {
206 ddata->state = RMC_GETDATA;
210 ddata->state = RMC_PRELOAD;
216 if ((RK_PWM_TIME_BIT1_MIN < ddata->period) &&
217 (ddata->period < RK_PWM_TIME_BIT1_MAX))
218 ddata->scandata |= (0x01<<ddata->count);
220 if (ddata->count < 0x10)
222 DBG_CODE("RMC_GETDATA=%x\n", (ddata->scandata>>8));
223 if ((ddata->scandata&0x0ff) ==
224 ((~ddata->scandata >> 8) & 0x0ff)) {
225 if (remotectl_keycode_lookup(ddata)) {
227 input_event(ddata->input, EV_KEY,
229 input_sync(ddata->input);
230 ddata->state = RMC_SEQUENCE;
232 ddata->state = RMC_PRELOAD;
235 ddata->state = RMC_PRELOAD;
240 DBG("S=%d\n", ddata->period);
241 if ((RK_PWM_TIME_RPT_MIN < ddata->period) &&
242 (ddata->period < RK_PWM_TIME_RPT_MAX)) {
244 mod_timer(&ddata->timer, jiffies
245 + msecs_to_jiffies(130));
246 } else if ((RK_PWM_TIME_SEQ1_MIN < ddata->period) &&
247 (ddata->period < RK_PWM_TIME_SEQ1_MAX)) {
249 mod_timer(&ddata->timer, jiffies
250 + msecs_to_jiffies(130));
251 } else if ((RK_PWM_TIME_SEQ2_MIN < ddata->period) &&
252 (ddata->period < RK_PWM_TIME_SEQ2_MAX)) {
254 mod_timer(&ddata->timer, jiffies
255 + msecs_to_jiffies(130));
258 input_event(ddata->input, EV_KEY,
260 input_sync(ddata->input);
261 ddata->state = RMC_PRELOAD;
271 static void rk_pwm_remotectl_timer(unsigned long _data)
273 struct rkxx_remotectl_drvdata *ddata;
275 ddata = (struct rkxx_remotectl_drvdata *)_data;
276 if (ddata->press != ddata->pre_press) {
277 ddata->pre_press = 0;
279 input_event(ddata->input, EV_KEY, ddata->keycode, 0);
280 input_sync(ddata->input);
282 ddata->state = RMC_PRELOAD;
286 static irqreturn_t rockchip_pwm_irq(int irq, void *dev_id)
288 struct rkxx_remotectl_drvdata *ddata;
291 ddata = (struct rkxx_remotectl_drvdata *)dev_id;
292 switch (ddata->remote_pwm_id) {
294 val = readl_relaxed(ddata->base + PWM0_REG_INTSTS);
295 if (val & PWM_CH0_INT) {
296 if ((val & PWM_CH0_POL) == 0) {
297 val = readl_relaxed(ddata->base + PWM_REG_HPR);
299 tasklet_hi_schedule(&ddata->remote_tasklet);
300 DBG("hpr=0x%x\n", val);
302 val = readl_relaxed(ddata->base + PWM_REG_LPR);
303 DBG("lpr=0x%x\n", val);
305 writel_relaxed(PWM_CH0_INT, ddata->base + PWM0_REG_INTSTS);
306 if (ddata->state == RMC_PRELOAD)
307 wake_lock_timeout(&ddata->remotectl_wake_lock, HZ);
313 val = readl_relaxed(ddata->base + PWM1_REG_INTSTS);
314 if (val & PWM_CH1_INT) {
315 if ((val & PWM_CH1_POL) == 0) {
316 val = readl_relaxed(ddata->base + PWM_REG_HPR);
318 tasklet_hi_schedule(&ddata->remote_tasklet);
319 DBG("hpr=0x%x\n", val);
321 val = readl_relaxed(ddata->base + PWM_REG_LPR);
322 DBG("lpr=0x%x\n", val);
324 writel_relaxed(PWM_CH1_INT, ddata->base + PWM1_REG_INTSTS);
325 if (ddata->state == RMC_PRELOAD)
326 wake_lock_timeout(&ddata->remotectl_wake_lock, HZ);
332 val = readl_relaxed(ddata->base + PWM2_REG_INTSTS);
333 if (val & PWM_CH2_INT) {
334 if ((val & PWM_CH2_POL) == 0) {
335 val = readl_relaxed(ddata->base + PWM_REG_HPR);
337 tasklet_hi_schedule(&ddata->remote_tasklet);
338 DBG("hpr=0x%x\n", val);
340 val = readl_relaxed(ddata->base + PWM_REG_LPR);
341 DBG("lpr=0x%x\n", val);
343 writel_relaxed(PWM_CH2_INT, ddata->base + PWM2_REG_INTSTS);
344 if (ddata->state == RMC_PRELOAD)
345 wake_lock_timeout(&ddata->remotectl_wake_lock, HZ);
351 val = readl_relaxed(ddata->base + PWM3_REG_INTSTS);
352 if (val & PWM_CH3_INT) {
353 if ((val & PWM_CH3_POL) == 0) {
354 val = readl_relaxed(ddata->base + PWM_REG_HPR);
356 tasklet_hi_schedule(&ddata->remote_tasklet);
357 DBG("hpr=0x%x\n", val);
359 val = readl_relaxed(ddata->base + PWM_REG_LPR);
360 DBG("lpr=0x%x\n", val);
362 writel_relaxed(PWM_CH3_INT, ddata->base + PWM3_REG_INTSTS);
363 if (ddata->state == RMC_PRELOAD)
364 wake_lock_timeout(&ddata->remotectl_wake_lock, HZ);
375 static int rk_pwm_remotectl_hw_init(struct rkxx_remotectl_drvdata *ddata)
379 val = readl_relaxed(ddata->base + PWM_REG_CTRL);
380 val = (val & 0xFFFFFFFE) | PWM_DISABLE;
381 writel_relaxed(val, ddata->base + PWM_REG_CTRL);
382 val = readl_relaxed(ddata->base + PWM_REG_CTRL);
383 val = (val & 0xFFFFFFF9) | PWM_MODE_CAPTURE;
384 writel_relaxed(val, ddata->base + PWM_REG_CTRL);
385 val = readl_relaxed(ddata->base + PWM_REG_CTRL);
386 val = (val & 0xFF008DFF) | 0x00646200;
387 writel_relaxed(val, ddata->base + PWM_REG_CTRL);
388 switch (ddata->remote_pwm_id) {
390 val = readl_relaxed(ddata->base + PWM0_REG_INT_EN);
391 val = (val & 0xFFFFFFFE) | PWM_CH0_INT_ENABLE;
392 writel_relaxed(val, ddata->base + PWM0_REG_INT_EN);
396 val = readl_relaxed(ddata->base + PWM1_REG_INT_EN);
397 val = (val & 0xFFFFFFFD) | PWM_CH1_INT_ENABLE;
398 writel_relaxed(val, ddata->base + PWM1_REG_INT_EN);
402 val = readl_relaxed(ddata->base + PWM2_REG_INT_EN);
403 val = (val & 0xFFFFFFFB) | PWM_CH2_INT_ENABLE;
404 writel_relaxed(val, ddata->base + PWM2_REG_INT_EN);
408 val = readl_relaxed(ddata->base + PWM3_REG_INT_EN);
409 val = (val & 0xFFFFFFF7) | PWM_CH3_INT_ENABLE;
410 writel_relaxed(val, ddata->base + PWM3_REG_INT_EN);
416 val = readl_relaxed(ddata->base + PWM_REG_CTRL);
417 val = (val & 0xFFFFFFFE) | PWM_ENABLE;
418 writel_relaxed(val, ddata->base + PWM_REG_CTRL);
424 static int rk_pwm_probe(struct platform_device *pdev)
426 struct rkxx_remotectl_drvdata *ddata;
427 struct device_node *np = pdev->dev.of_node;
429 struct input_dev *input;
431 struct cpumask cpumask;
439 pr_err(".. rk pwm remotectl v1.1 init\n");
440 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
442 dev_err(&pdev->dev, "no memory resources defined\n");
445 ddata = devm_kzalloc(&pdev->dev, sizeof(struct rkxx_remotectl_drvdata),
448 dev_err(&pdev->dev, "failed to allocate memory\n");
451 ddata->state = RMC_PRELOAD;
452 ddata->base = devm_ioremap_resource(&pdev->dev, r);
453 if (IS_ERR(ddata->base))
454 return PTR_ERR(ddata->base);
455 clk = devm_clk_get(&pdev->dev, "pclk_pwm");
458 platform_set_drvdata(pdev, ddata);
459 num = rk_remotectl_get_irkeybd_count(pdev);
461 pr_err("remotectl: no ir keyboard add in dts!!\n");
464 ddata->maxkeybdnum = num;
465 remotectl_button = kmalloc(
466 num*sizeof(struct rkxx_remotectl_button),
468 if (!remotectl_button) {
469 pr_err("failed to malloc remote button memory\n");
472 input = input_allocate_device();
473 input->name = pdev->name;
474 input->phys = "gpio-keys/remotectl";
475 input->dev.parent = &pdev->dev;
476 input->id.bustype = BUS_HOST;
477 input->id.vendor = 0x0001;
478 input->id.product = 0x0001;
479 input->id.version = 0x0100;
480 ddata->input = input;
481 ddata->input = input;
482 wake_lock_init(&ddata->remotectl_wake_lock,
483 WAKE_LOCK_SUSPEND, "rk29_pwm_remote");
484 ret = clk_prepare_enable(clk);
487 irq = platform_get_irq(pdev, 0);
489 dev_err(&pdev->dev, "cannot find IRQ\n");
494 of_property_read_u32(np, "remote_pwm_id", &pwm_id);
495 ddata->remote_pwm_id = pwm_id;
496 DBG("remotectl: remote pwm id=0x%x\n", pwm_id);
497 of_property_read_u32(np, "handle_cpu_id", &cpu_id);
498 ddata->handle_cpu_id = cpu_id;
499 DBG("remotectl: handle cpu id=0x%x\n", cpu_id);
500 rk_remotectl_parse_ir_keys(pdev);
501 tasklet_init(&ddata->remote_tasklet, rk_pwm_remotectl_do_something,
502 (unsigned long)ddata);
503 for (j = 0; j < num; j++) {
504 DBG("remotectl probe j = 0x%x\n", j);
505 for (i = 0; i < remotectl_button[j].nbuttons; i++) {
506 unsigned int type = EV_KEY;
508 input_set_capability(input, type, remotectl_button[j].
509 key_table[i].keycode);
512 ret = input_register_device(input);
514 pr_err("remotectl: register input device err, ret: %d\n", ret);
515 input_set_capability(input, EV_KEY, KEY_WAKEUP);
516 device_init_wakeup(&pdev->dev, 1);
517 enable_irq_wake(irq);
518 setup_timer(&ddata->timer, rk_pwm_remotectl_timer,
519 (unsigned long)ddata);
520 //mod_timer(&ddata->timer, jiffies + msecs_to_jiffies(1000));
521 cpumask_clear(&cpumask);
522 cpumask_set_cpu(cpu_id, &cpumask);
523 irq_set_affinity(irq, &cpumask);
524 ret = devm_request_irq(&pdev->dev, irq, rockchip_pwm_irq,
525 0, "rk_pwm_irq", ddata);
527 dev_err(&pdev->dev, "cannot claim IRQ %d\n", irq);
530 rk_pwm_remotectl_hw_init(ddata);
534 static int rk_pwm_remove(struct platform_device *pdev)
540 static int remotectl_suspend(struct device *dev)
543 struct cpumask cpumask;
544 struct platform_device *pdev = to_platform_device(dev);
545 struct rkxx_remotectl_drvdata *ddata = platform_get_drvdata(pdev);
547 cpumask_clear(&cpumask);
548 cpumask_set_cpu(cpu, &cpumask);
549 irq_set_affinity(ddata->irq, &cpumask);
554 static int remotectl_resume(struct device *dev)
556 struct cpumask cpumask;
557 struct platform_device *pdev = to_platform_device(dev);
558 struct rkxx_remotectl_drvdata *ddata = platform_get_drvdata(pdev);
560 cpumask_clear(&cpumask);
561 cpumask_set_cpu(ddata->handle_cpu_id, &cpumask);
562 irq_set_affinity(ddata->irq, &cpumask);
566 static const struct dev_pm_ops remotectl_pm_ops = {
567 .suspend = remotectl_suspend,
568 .resume = remotectl_resume,
572 static const struct of_device_id rk_pwm_of_match[] = {
573 { .compatible = "rockchip,remotectl-pwm"},
577 MODULE_DEVICE_TABLE(of, rk_pwm_of_match);
579 static struct platform_driver rk_pwm_driver = {
581 .name = "remotectl-pwm",
582 .of_match_table = rk_pwm_of_match,
584 .pm = &remotectl_pm_ops,
587 .probe = rk_pwm_probe,
588 .remove = rk_pwm_remove,
591 module_platform_driver(rk_pwm_driver);
593 MODULE_LICENSE("GPL");