#include <linux/wakelock.h>
#include <linux/slab.h>
#include "rockchip_pwm_remotectl.h"
-
-
+#include <linux/leds.h>
+#include <linux/fb.h>
/*sys/module/rk_pwm_remotectl/parameters,
modify code_print to change the value*/
static int rk_remote_print_code;
+static bool remote_suspend = false;
module_param_named(code_print, rk_remote_print_code, int, 0644);
#define DBG_CODE(args...) \
do { \
} \
} while (0)
+#define BLINK_DELAY 50
+DEFINE_LED_TRIGGER(ledtrig_ir_click);
+static unsigned long ir_blink_delay = BLINK_DELAY;
+
+bool get_state_remotectl(void)
+{
+ return remote_suspend;
+}
+void ledtrig_ir_activity(void)
+{
+ led_trigger_blink_oneshot(ledtrig_ir_click, &ir_blink_delay, &ir_blink_delay,1);
+}
struct rkxx_remote_key_table {
int scancode;
int keycode;
int keycode;
int press;
int pre_press;
- int period;
int irq;
int remote_pwm_id;
int handle_cpu_id;
int wakeup;
+ int clk_rate;
+ unsigned long period;
+ unsigned long temp_period;
+ int pwm_freq_nstime;
struct input_dev *input;
struct timer_list timer;
struct tasklet_struct remote_tasklet;
struct wake_lock remotectl_wake_lock;
};
-static struct rkxx_remotectl_button *remotectl_button;
-
+static struct rkxx_remotectl_button *remotectl_button;
static int remotectl_keybd_num_lookup(struct rkxx_remotectl_drvdata *ddata)
{
return 0;
}
+static int rk_remotectl_get_irkeybd_count(struct platform_device *pdev)
+{
+ struct device_node *node = pdev->dev.of_node;
+ struct device_node *child_node;
+ int boardnum;
+ int temp_usercode;
+
+ boardnum = 0;
+ for_each_child_of_node(node, child_node) {
+ if(of_property_read_u32(child_node, "rockchip,usercode",
+ &temp_usercode)) {
+ DBG("get keybd num error.\n");
+ } else {
+ boardnum++;
+ }
+ }
+ DBG("get keybd num = 0x%x.\n", boardnum);
+ return boardnum;
+}
+
static int rk_remotectl_parse_ir_keys(struct platform_device *pdev)
{
struct rkxx_remotectl_drvdata *ddata = platform_get_drvdata(pdev);
struct device_node *node = pdev->dev.of_node;
struct device_node *child_node;
- u32 loop;
- u32 ret;
- u32 len;
- u32 boardnum;
-
+ int loop;
+ int ret;
+ int len;
+ int boardnum;
+
boardnum = 0;
for_each_child_of_node(node, child_node) {
if(of_property_read_u32(child_node, "rockchip,usercode",
len /= sizeof(u32);
DBG("len=0x%x\n",len);
remotectl_button[boardnum].nbuttons = len/2;
- if(of_property_read_u32_array(child_node, "rockchip,key_table",
+ if(of_property_read_u32_array(child_node, "rockchip,key_table",
(u32 *)remotectl_button[boardnum].key_table, len)) {
dev_err(&pdev->dev, "Missing key_table property in the DTS.\n");
ret = -1;
return ret;
}
for (loop=0; loop<(len/2); loop++) {
- DBG("board[%d].scanCode[%d]=0x%x\n", boardnum, loop,
+ DBG("board[%d].scanCode[%d]=0x%x\n", boardnum, loop,
remotectl_button[boardnum].key_table[loop].scancode);
- DBG("board[%d].keyCode[%d]=%d\n", boardnum, loop,
+ DBG("board[%d].keyCode[%d]=%d\n", boardnum, loop,
remotectl_button[boardnum].key_table[loop].keycode);
}
boardnum++;
break;
}
case RMC_PRELOAD: {
- mod_timer(&ddata->timer, jiffies + msecs_to_jiffies(130));
+ mod_timer(&ddata->timer, jiffies + msecs_to_jiffies(140));
if ((RK_PWM_TIME_PRE_MIN < ddata->period) &&
(ddata->period < RK_PWM_TIME_PRE_MAX)) {
ddata->scandata = 0;
ddata->scandata = 0;
ddata->count = 0;
} else {
- ddata->state = RMC_PRELOAD;
+ if (rk_remote_print_code){
+ ddata->state = RMC_GETDATA;
+ ddata->scandata = 0;
+ ddata->count = 0;
+ } else
+ ddata->state = RMC_PRELOAD;
}
}
}
break;
case RMC_GETDATA: {
+ if(!get_state_remotectl() && (ddata->keycode != KEY_POWER))
+ {
+ ledtrig_ir_activity();
+ }
+ if(ddata->keycode != KEY_POWER)
+ led_trigger_blink_oneshot(ledtrig_ir_click, &ir_blink_delay, &ir_blink_delay,1);
+
if ((RK_PWM_TIME_BIT1_MIN < ddata->period) &&
(ddata->period < RK_PWM_TIME_BIT1_MAX))
ddata->scandata |= (0x01<<ddata->count);
((~ddata->scandata >> 8) & 0x0ff)) {
if (remotectl_keycode_lookup(ddata)) {
ddata->press = 1;
+ if(ddata->keycode== KEY_POWER && !get_state_remotectl()){
+ led_trigger_event(ledtrig_ir_click,LED_OFF);
+ }
input_event(ddata->input, EV_KEY,
ddata->keycode, 1);
input_sync(ddata->input);
}
break;
case RMC_SEQUENCE:{
- DBG("S=%d\n", ddata->period);
+ DBG("S=%ld\n", ddata->period);
if ((RK_PWM_TIME_RPT_MIN < ddata->period) &&
(ddata->period < RK_PWM_TIME_RPT_MAX)) {
DBG("S1\n");
static irqreturn_t rockchip_pwm_irq(int irq, void *dev_id)
{
- struct rkxx_remotectl_drvdata *ddata;
+ struct rkxx_remotectl_drvdata *ddata = dev_id;
int val;
-
- ddata = (struct rkxx_remotectl_drvdata *)dev_id;
- switch (ddata->remote_pwm_id) {
- case 0: {
- val = readl_relaxed(ddata->base + PWM0_REG_INTSTS);
- if (val & PWM_CH0_INT) {
- if ((val & PWM_CH0_POL) == 0) {
- val = readl_relaxed(ddata->base + PWM_REG_HPR);
- ddata->period = val;
- tasklet_hi_schedule(&ddata->remote_tasklet);
- DBG("hpr=0x%x\n", val);
- } else {
- val = readl_relaxed(ddata->base + PWM_REG_LPR);
- DBG("lpr=0x%x\n", val);
- }
- writel_relaxed(PWM_CH0_INT, ddata->base + PWM0_REG_INTSTS);
- if (ddata->state == RMC_PRELOAD)
- wake_lock_timeout(&ddata->remotectl_wake_lock, HZ);
- return IRQ_HANDLED;
- }
- }
- break;
- case 1: {
- val = readl_relaxed(ddata->base + PWM1_REG_INTSTS);
- if (val & PWM_CH1_INT) {
- if ((val & PWM_CH1_POL) == 0) {
- val = readl_relaxed(ddata->base + PWM_REG_HPR);
- ddata->period = val;
- tasklet_hi_schedule(&ddata->remote_tasklet);
- DBG("hpr=0x%x\n", val);
- } else {
- val = readl_relaxed(ddata->base + PWM_REG_LPR);
- DBG("lpr=0x%x\n", val);
- }
- writel_relaxed(PWM_CH1_INT, ddata->base + PWM1_REG_INTSTS);
- if (ddata->state == RMC_PRELOAD)
- wake_lock_timeout(&ddata->remotectl_wake_lock, HZ);
- return IRQ_HANDLED;
- }
- }
- break;
- case 2: {
- val = readl_relaxed(ddata->base + PWM2_REG_INTSTS);
- if (val & PWM_CH2_INT) {
- if ((val & PWM_CH2_POL) == 0) {
- val = readl_relaxed(ddata->base + PWM_REG_HPR);
- ddata->period = val;
- tasklet_hi_schedule(&ddata->remote_tasklet);
- DBG("hpr=0x%x\n", val);
- } else {
- val = readl_relaxed(ddata->base + PWM_REG_LPR);
- DBG("lpr=0x%x\n", val);
- }
- writel_relaxed(PWM_CH2_INT, ddata->base + PWM2_REG_INTSTS);
- if (ddata->state == RMC_PRELOAD)
- wake_lock_timeout(&ddata->remotectl_wake_lock, HZ);
- return IRQ_HANDLED;
- }
- }
- break;
- case 3: {
- val = readl_relaxed(ddata->base + PWM3_REG_INTSTS);
- if (val & PWM_CH3_INT) {
- if ((val & PWM_CH3_POL) == 0) {
- val = readl_relaxed(ddata->base + PWM_REG_HPR);
- ddata->period = val;
- tasklet_hi_schedule(&ddata->remote_tasklet);
- DBG("hpr=0x%x\n", val);
- } else {
- val = readl_relaxed(ddata->base + PWM_REG_LPR);
- DBG("lpr=0x%x\n", val);
- }
- writel_relaxed(PWM_CH3_INT, ddata->base + PWM3_REG_INTSTS);
- if (ddata->state == RMC_PRELOAD)
- wake_lock_timeout(&ddata->remotectl_wake_lock, HZ);
- return IRQ_HANDLED;
+ int temp_hpr;
+ int temp_lpr;
+ int temp_period;
+ unsigned int id = ddata->remote_pwm_id;
+
+ if (id > 3)
+ return IRQ_NONE;
+ val = readl_relaxed(ddata->base + PWM_REG_INTSTS(id));
+ if ((val & PWM_CH_INT(id)) == 0)
+ return IRQ_NONE;
+ if ((val & PWM_CH_POL(id)) == 0) {
+ temp_hpr = readl_relaxed(ddata->base + PWM_REG_HPR);
+ DBG("hpr=%d\n", temp_hpr);
+ temp_lpr = readl_relaxed(ddata->base + PWM_REG_LPR);
+ DBG("lpr=%d\n", temp_lpr);
+ temp_period = ddata->pwm_freq_nstime * temp_lpr / 1000;
+ if (temp_period > RK_PWM_TIME_BIT0_MIN) {
+ ddata->period = ddata->temp_period
+ + ddata->pwm_freq_nstime * temp_hpr / 1000;
+ tasklet_hi_schedule(&ddata->remote_tasklet);
+ ddata->temp_period = 0;
+ DBG("period+ =%ld\n", ddata->period);
+ } else {
+ ddata->temp_period += ddata->pwm_freq_nstime
+ * (temp_hpr + temp_lpr) / 1000;
}
}
- break;
- default:
- break;
- }
- return IRQ_NONE;
+ writel_relaxed(PWM_CH_INT(id), ddata->base + PWM_REG_INTSTS(id));
+#if ! defined(CONFIG_RK_IR_NO_DEEP_SLEEP)
+ if (ddata->state == RMC_PRELOAD)
+ wake_lock_timeout(&ddata->remotectl_wake_lock, HZ);
+#endif
+ return IRQ_HANDLED;
}
+
+
static int rk_pwm_remotectl_hw_init(struct rkxx_remotectl_drvdata *ddata)
{
int val;
val = (val & 0xFFFFFFF9) | PWM_MODE_CAPTURE;
writel_relaxed(val, ddata->base + PWM_REG_CTRL);
val = readl_relaxed(ddata->base + PWM_REG_CTRL);
- val = (val & 0xFF008DFF) | 0x00646200;
+ val = (val & 0xFF008DFF) | 0x0006000;
writel_relaxed(val, ddata->base + PWM_REG_CTRL);
switch (ddata->remote_pwm_id) {
case 0: {
writel_relaxed(val, ddata->base + PWM3_REG_INT_EN);
}
break;
- default:
+ default:
break;
- }
+ }
val = readl_relaxed(ddata->base + PWM_REG_CTRL);
val = (val & 0xFFFFFFFE) | PWM_ENABLE;
writel_relaxed(val, ddata->base + PWM_REG_CTRL);
return 0;
}
-
+static int remotectl_fb_event_notify(struct notifier_block *self, unsigned long action, void *data)
+{
+ struct fb_event *event = data;
+
+ if (action == FB_EARLY_EVENT_BLANK) {
+ switch (*((int *)event->data)) {
+ case FB_BLANK_UNBLANK:
+ break;
+ default:
+ led_trigger_event(ledtrig_ir_click,LED_OFF);
+ remote_suspend = true;
+ break;
+ }
+ }
+ else if (action == FB_EVENT_BLANK) {
+ switch (*((int *)event->data)) {
+ case FB_BLANK_UNBLANK:
+ remote_suspend = false;
+ led_trigger_event(ledtrig_ir_click,LED_FULL);
+ break;
+ default:
+ break;
+ }
+ }
+ return NOTIFY_OK;
+}
+static struct notifier_block remotectl_fb_notifier = {
+ .notifier_call = remotectl_fb_event_notify,
+};
static int rk_pwm_probe(struct platform_device *pdev)
{
struct rkxx_remotectl_drvdata *ddata;
struct device_node *np = pdev->dev.of_node;
- struct device_node *child_node;
struct resource *r;
struct input_dev *input;
struct clk *clk;
int i, j;
int cpu_id;
int pwm_id;
-
+ int pwm_freq;
+
pr_err(".. rk pwm remotectl v1.1 init\n");
r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!r) {
return -ENOMEM;
}
ddata->state = RMC_PRELOAD;
+ ddata->temp_period = 0;
ddata->base = devm_ioremap_resource(&pdev->dev, r);
if (IS_ERR(ddata->base))
return PTR_ERR(ddata->base);
- clk = devm_clk_get(&pdev->dev, "pclk_pwm");
+ clk = devm_clk_get(&pdev->dev, NULL);
if (IS_ERR(clk))
return PTR_ERR(clk);
platform_set_drvdata(pdev, ddata);
- num = 0;
- for_each_child_of_node(np, child_node){
- if(of_device_is_compatible(child_node, "rockchip,ir_key"))
- num++;
- }
+ num = rk_remotectl_get_irkeybd_count(pdev);
if (num == 0) {
pr_err("remotectl: no ir keyboard add in dts!!\n");
return -1;
input->id.version = 0x0100;
ddata->input = input;
ddata->input = input;
+ fb_register_client(&remotectl_fb_notifier);
wake_lock_init(&ddata->remotectl_wake_lock,
WAKE_LOCK_SUSPEND, "rk29_pwm_remote");
+#if defined(CONFIG_RK_IR_NO_DEEP_SLEEP)
+ wake_lock(&ddata->remotectl_wake_lock);
+#endif
ret = clk_prepare_enable(clk);
if (ret)
return ret;
pr_err("remotectl: register input device err, ret: %d\n", ret);
input_set_capability(input, EV_KEY, KEY_WAKEUP);
device_init_wakeup(&pdev->dev, 1);
+ enable_irq_wake(irq);
+ setup_timer(&ddata->timer, rk_pwm_remotectl_timer,
+ (unsigned long)ddata);
+ //mod_timer(&ddata->timer, jiffies + msecs_to_jiffies(1000));
+ cpumask_clear(&cpumask);
+ cpumask_set_cpu(cpu_id, &cpumask);
+ irq_set_affinity(irq, &cpumask);
ret = devm_request_irq(&pdev->dev, irq, rockchip_pwm_irq,
- 0, "rk_pwm_irq", ddata);
+ IRQF_NO_SUSPEND, "rk_pwm_irq", ddata);
if (ret) {
dev_err(&pdev->dev, "cannot claim IRQ %d\n", irq);
return ret;
}
- enable_irq_wake(irq);
- setup_timer(&ddata->timer, rk_pwm_remotectl_timer,
- (unsigned long)ddata);
- mod_timer(&ddata->timer, jiffies + msecs_to_jiffies(1000));
- cpumask_clear(&cpumask);
- cpumask_set_cpu(cpu_id, &cpumask);
- irq_set_affinity(irq, &cpumask);
rk_pwm_remotectl_hw_init(ddata);
+ pwm_freq = clk_get_rate(clk) / 64;
+ ddata->pwm_freq_nstime = 1000000000 / pwm_freq;
+ led_trigger_register_simple("ir-power-click", &ledtrig_ir_click);
+
return ret;
}
static int rk_pwm_remove(struct platform_device *pdev)
{
+#if defined(CONFIG_RK_IR_NO_DEEP_SLEEP)
+ struct rkxx_remotectl_drvdata *ddata = platform_get_drvdata(pdev);
+#endif
+ led_trigger_unregister_simple(ledtrig_ir_click);
+#if defined(CONFIG_RK_IR_NO_DEEP_SLEEP)
+ wake_unlock(&ddata->remotectl_wake_lock);
+#endif
return 0;
}
struct cpumask cpumask;
struct platform_device *pdev = to_platform_device(dev);
struct rkxx_remotectl_drvdata *ddata = platform_get_drvdata(pdev);
-
+
cpumask_clear(&cpumask);
cpumask_set_cpu(cpu, &cpumask);
irq_set_affinity(ddata->irq, &cpumask);
struct cpumask cpumask;
struct platform_device *pdev = to_platform_device(dev);
struct rkxx_remotectl_drvdata *ddata = platform_get_drvdata(pdev);
-
+
+ led_trigger_event(ledtrig_ir_click,LED_FULL);
cpumask_clear(&cpumask);
- cpumask_set_cpu(ddata->handle_cpu_id, &cpumask);
- irq_set_affinity(ddata->irq, &cpumask);
+ cpumask_set_cpu(ddata->handle_cpu_id, &cpumask);
+ irq_set_affinity(ddata->irq, &cpumask);
return 0;
}
static const struct dev_pm_ops remotectl_pm_ops = {
- .suspend = remotectl_suspend,
- .resume = remotectl_resume,
+ .suspend_late = remotectl_suspend,
+ .resume_early = remotectl_resume,
};
#endif
.name = "remotectl-pwm",
.of_match_table = rk_pwm_of_match,
#ifdef CONFIG_PM
- .pm = &remotectl_pm_ops,
-#endif
+ .pm = &remotectl_pm_ops,
+#endif
},
.probe = rk_pwm_probe,
.remove = rk_pwm_remove,
projects / firefly-linux-kernel-4.4.55.git / blobdiff