1 /* SPDX-License-Identifier: GPL-2.0 */
2
3 #include <linux/clk.h>
4 #include <linux/io.h>
5 #include <linux/irq.h>
6 #include <linux/irqdesc.h>
7 #include <linux/irqdomain.h>
8 #include <linux/module.h>
9 #include <linux/of.h>
10 #include <linux/platform_device.h>
11 #include <linux/module.h>
12 #include <linux/init.h>
13 #include <linux/interrupt.h>
14 #include <linux/platform_device.h>
15 #include <linux/input.h>
16 #include <linux/workqueue.h>
17 #include <linux/wakelock.h>
18 #include <linux/slab.h>
19 #include <linux/rockchip/rockchip_sip.h>
20 #include "rockchip_pwm_remotectl.h"
21
22
23
24 /*
25 * sys/module/rk_pwm_remotectl/parameters,
26 * modify code_print to change the value
27 */
28
29 static int rk_remote_print_code;
30 module_param_named(code_print, rk_remote_print_code, int, 0644);
31 #define DBG_CODE(args...) \
32 do { \
33 if (rk_remote_print_code) { \
34 pr_info(args); \
35 } \
36 } while (0)
37
38 static int rk_remote_pwm_dbg_level;
39 module_param_named(dbg_level, rk_remote_pwm_dbg_level, int, 0644);
40 #define DBG(args...) \
41 do { \
42 if (rk_remote_pwm_dbg_level) { \
43 pr_info(args); \
44 } \
45 } while (0)
46
47
48 struct rkxx_remote_key_table {
49 int scancode;
50 int keycode;
51 };
52
53 struct rkxx_remotectl_button {
54 int usercode;
55 int nbuttons;
56 struct rkxx_remote_key_table key_table[MAX_NUM_KEYS];
57 };
58
59 struct rkxx_remotectl_drvdata {
60 void __iomem *base;
61 int state;
62 int nbuttons;
63 int scandata;
64 int count;
65 int keynum;
66 int maxkeybdnum;
67 int keycode;
68 int press;
69 int pre_press;
70 int irq;
71 int remote_pwm_id;
72 int handle_cpu_id;
73 int wakeup;
74 int support_psci;
75 int pwm_pwrkey_capture;
76 unsigned long period;
77 unsigned long temp_period;
78 int pwm_freq_nstime;
79 int pwrkey_wakeup;
80 struct input_dev *input;
81 struct timer_list timer;
82 struct tasklet_struct remote_tasklet;
83 struct wake_lock remotectl_wake_lock;
84 };
85
86 static struct rkxx_remotectl_button *remotectl_button;
87
remotectl_keybd_num_lookup(struct rkxx_remotectl_drvdata * ddata)88 static int remotectl_keybd_num_lookup(struct rkxx_remotectl_drvdata *ddata)
89 {
90 int i;
91 int num;
92
93 num = ddata->maxkeybdnum;
94 for (i = 0; i < num; i++) {
95 if (remotectl_button[i].usercode == (ddata->scandata&0xFFFF)) {
96 ddata->keynum = i;
97 return 1;
98 }
99 }
100 return 0;
101 }
102
103
remotectl_keycode_lookup(struct rkxx_remotectl_drvdata * ddata)104 static int remotectl_keycode_lookup(struct rkxx_remotectl_drvdata *ddata)
105 {
106 int i;
107 unsigned char keydata = (unsigned char)((ddata->scandata >> 8) & 0xff);
108
109 for (i = 0; i < remotectl_button[ddata->keynum].nbuttons; i++) {
110 if (remotectl_button[ddata->keynum].key_table[i].scancode ==
111 keydata) {
112 ddata->keycode =
113 remotectl_button[ddata->keynum].key_table[i].keycode;
114 return 1;
115 }
116 }
117 return 0;
118 }
119
rk_remotectl_get_irkeybd_count(struct platform_device * pdev)120 static int rk_remotectl_get_irkeybd_count(struct platform_device *pdev)
121 {
122 struct device_node *node = pdev->dev.of_node;
123 struct device_node *child_node;
124 int boardnum;
125 int temp_usercode;
126
127 boardnum = 0;
128 for_each_child_of_node(node, child_node) {
129 if (of_property_read_u32(child_node, "rockchip,usercode",
130 &temp_usercode)) {
131 DBG("get keybd num error.\n");
132 } else {
133 boardnum++;
134 }
135 }
136 DBG("get keybd num = 0x%x.\n", boardnum);
137 return boardnum;
138 }
139
140
rk_remotectl_parse_ir_keys(struct platform_device * pdev)141 static int rk_remotectl_parse_ir_keys(struct platform_device *pdev)
142 {
143 struct rkxx_remotectl_drvdata *ddata = platform_get_drvdata(pdev);
144 struct device_node *node = pdev->dev.of_node;
145 struct device_node *child_node;
146 int loop;
147 int ret;
148 int len;
149 int boardnum;
150
151 boardnum = 0;
152 for_each_child_of_node(node, child_node) {
153 if (of_property_read_u32(child_node, "rockchip,usercode",
154 &remotectl_button[boardnum].usercode)) {
155 dev_err(&pdev->dev, "Missing usercode in the DTS.\n");
156 ret = -1;
157 return ret;
158 }
159 DBG("remotectl_button[0].usercode=0x%x\n",
160 remotectl_button[boardnum].usercode);
161 of_get_property(child_node, "rockchip,key_table", &len);
162 len /= sizeof(u32);
163 DBG("len=0x%x\n", len);
164 remotectl_button[boardnum].nbuttons = len/2;
165 if (of_property_read_u32_array(child_node, "rockchip,key_table",
166 (u32 *)remotectl_button[boardnum].key_table, len)) {
167 dev_err(&pdev->dev, "Missing key_table in the DTS.\n");
168 ret = -1;
169 return ret;
170 }
171 for (loop = 0; loop < (len/2); loop++) {
172 DBG("board[%d].scanCode[%d]=0x%x\n", boardnum, loop,
173 remotectl_button[boardnum].key_table[loop].scancode);
174 DBG("board[%d].keyCode[%d]=%d\n", boardnum, loop,
175 remotectl_button[boardnum].key_table[loop].keycode);
176 }
177 boardnum++;
178 if (boardnum > ddata->maxkeybdnum)
179 break;
180 }
181 DBG("keybdNum=0x%x\n", boardnum);
182 return 0;
183 }
184
185
186
rk_pwm_remotectl_do_something(unsigned long data)187 static void rk_pwm_remotectl_do_something(unsigned long data)
188 {
189 struct rkxx_remotectl_drvdata *ddata;
190
191 ddata = (struct rkxx_remotectl_drvdata *)data;
192 switch (ddata->state) {
193 case RMC_IDLE: {
194 ;
195 break;
196 }
197 case RMC_PRELOAD: {
198 mod_timer(&ddata->timer, jiffies + msecs_to_jiffies(140));
199 if ((ddata->period > RK_PWM_TIME_PRE_MIN) &&
200 (ddata->period < RK_PWM_TIME_PRE_MAX)) {
201 ddata->scandata = 0;
202 ddata->count = 0;
203 ddata->state = RMC_USERCODE;
204 } else {
205 ddata->state = RMC_PRELOAD;
206 }
207 break;
208 }
209 case RMC_USERCODE: {
210 if ((ddata->period > RK_PWM_TIME_BIT1_MIN) &&
211 (ddata->period < RK_PWM_TIME_BIT1_MAX))
212 ddata->scandata |= (0x01 << ddata->count);
213 ddata->count++;
214 if (ddata->count == 0x10) {
215 DBG_CODE("USERCODE=0x%x\n", ddata->scandata);
216 if (remotectl_keybd_num_lookup(ddata)) {
217 ddata->state = RMC_GETDATA;
218 ddata->scandata = 0;
219 ddata->count = 0;
220 } else {
221 if (rk_remote_print_code) {
222 ddata->state = RMC_GETDATA;
223 ddata->scandata = 0;
224 ddata->count = 0;
225 } else
226 ddata->state = RMC_PRELOAD;
227 }
228 }
229 }
230 break;
231 case RMC_GETDATA: {
232 if ((ddata->period > RK_PWM_TIME_BIT1_MIN) &&
233 (ddata->period < RK_PWM_TIME_BIT1_MAX))
234 ddata->scandata |= (0x01<<ddata->count);
235 ddata->count++;
236 if (ddata->count < 0x10)
237 return;
238 DBG_CODE("RMC_GETDATA=%x\n", (ddata->scandata>>8));
239 if ((ddata->scandata&0x0ff) ==
240 ((~ddata->scandata >> 8) & 0x0ff)) {
241 if (remotectl_keycode_lookup(ddata)) {
242 ddata->press = 1;
243 input_event(ddata->input, EV_KEY,
244 ddata->keycode, 1);
245 input_sync(ddata->input);
246 ddata->state = RMC_SEQUENCE;
247 } else {
248 ddata->state = RMC_PRELOAD;
249 }
250 } else {
251 ddata->state = RMC_PRELOAD;
252 }
253 }
254 break;
255 case RMC_SEQUENCE:{
256 DBG("S=%ld\n", ddata->period);
257 if ((ddata->period > RK_PWM_TIME_RPT_MIN) &&
258 (ddata->period < RK_PWM_TIME_RPT_MAX)) {
259 DBG("S1\n");
260 mod_timer(&ddata->timer, jiffies
261 + msecs_to_jiffies(130));
262 } else if ((ddata->period > RK_PWM_TIME_SEQ1_MIN) &&
263 (ddata->period < RK_PWM_TIME_SEQ1_MAX)) {
264 DBG("S2\n");
265 mod_timer(&ddata->timer, jiffies
266 + msecs_to_jiffies(130));
267 } else if ((ddata->period > RK_PWM_TIME_SEQ2_MIN) &&
268 (ddata->period < RK_PWM_TIME_SEQ2_MAX)) {
269 DBG("S3\n");
270 mod_timer(&ddata->timer, jiffies
271 + msecs_to_jiffies(130));
272 } else {
273 DBG("S4\n");
274 input_event(ddata->input, EV_KEY,
275 ddata->keycode, 0);
276 input_sync(ddata->input);
277 ddata->state = RMC_PRELOAD;
278 ddata->press = 0;
279 }
280 }
281 break;
282 default:
283 break;
284 }
285 }
286
rk_pwm_remotectl_timer(struct timer_list * t)287 static void rk_pwm_remotectl_timer(struct timer_list *t)
288 {
289 struct rkxx_remotectl_drvdata *ddata = from_timer(ddata, t, timer);
290
291 if (ddata->press != ddata->pre_press) {
292 ddata->pre_press = 0;
293 ddata->press = 0;
294 input_event(ddata->input, EV_KEY, ddata->keycode, 0);
295 input_sync(ddata->input);
296 }
297 ddata->state = RMC_PRELOAD;
298 }
299
rockchip_pwm_pwrirq(int irq,void * dev_id)300 static irqreturn_t rockchip_pwm_pwrirq(int irq, void *dev_id)
301 {
302 struct rkxx_remotectl_drvdata *ddata = dev_id;
303 int val;
304 unsigned int id = ddata->remote_pwm_id;
305
306 if (id > 3)
307 return IRQ_NONE;
308
309 val = readl_relaxed(ddata->base + PWM_REG_INTSTS(id));
310
311 if (val & PWM_PWR_KEY_INT) {
312 DBG("pwr=0x%x\n", readl_relaxed(ddata->base + PWM_PWRCAPTURE_VALUE(id)));
313 writel_relaxed(PWM_PWR_KEY_INT, ddata->base + PWM_REG_INTSTS(id));
314 ddata->pwrkey_wakeup = 1;
315 return IRQ_HANDLED;
316 }
317
318 return IRQ_NONE;
319 }
320
rockchip_pwm_irq(int irq,void * dev_id)321 static irqreturn_t rockchip_pwm_irq(int irq, void *dev_id)
322 {
323 struct rkxx_remotectl_drvdata *ddata = dev_id;
324 int val;
325 int temp_hpr;
326 int temp_lpr;
327 int temp_period;
328 unsigned int id = ddata->remote_pwm_id;
329
330 if (id > 3)
331 return IRQ_NONE;
332 val = readl_relaxed(ddata->base + PWM_REG_INTSTS(id));
333
334 if ((val & PWM_CH_INT(id)) == 0)
335 return IRQ_NONE;
336 if ((val & PWM_CH_POL(id)) == 0) {
337 temp_hpr = readl_relaxed(ddata->base + PWM_REG_HPR);
338 DBG("hpr=%d\n", temp_hpr);
339 temp_lpr = readl_relaxed(ddata->base + PWM_REG_LPR);
340 DBG("lpr=%d\n", temp_lpr);
341 temp_period = ddata->pwm_freq_nstime * temp_lpr / 1000;
342 if (temp_period > RK_PWM_TIME_BIT0_MIN) {
343 ddata->period = ddata->temp_period
344 + ddata->pwm_freq_nstime * temp_hpr / 1000;
345 tasklet_hi_schedule(&ddata->remote_tasklet);
346 ddata->temp_period = 0;
347 DBG("period+ =%ld\n", ddata->period);
348 } else {
349 ddata->temp_period += ddata->pwm_freq_nstime
350 * (temp_hpr + temp_lpr) / 1000;
351 }
352 }
353 writel_relaxed(PWM_CH_INT(id), ddata->base + PWM_REG_INTSTS(id));
354 if (ddata->state == RMC_PRELOAD)
355 wake_lock_timeout(&ddata->remotectl_wake_lock, HZ);
356 return IRQ_HANDLED;
357 }
358
rk_pwm_pwrkey_wakeup_init(struct platform_device * pdev)359 static int rk_pwm_pwrkey_wakeup_init(struct platform_device *pdev)
360 {
361 struct rkxx_remotectl_drvdata *ddata = platform_get_drvdata(pdev);
362 int val, min_temp, max_temp;
363 unsigned int pwm_id = ddata->remote_pwm_id;
364 int version;
365 int i, j;
366 int num = 0;
367 int ret = -1;
368 int pwr_irq;
369
370 ddata->pwm_pwrkey_capture = 0;
371 version = readl_relaxed(ddata->base + RK_PWM_VERSION_ID(pwm_id));
372 dev_info(&pdev->dev, "pwm version is 0x%x\n", version & 0xffff0000);
373 if (((version >> 24) & 0xFF) < 2) {
374 dev_info(&pdev->dev, "pwm version is less v2.0\n");
375 goto end;
376 }
377 pwr_irq = platform_get_irq(pdev, 1);
378 if (pwr_irq < 0) {
379 dev_err(&pdev->dev, "cannot find PWR IRQ\n");
380 goto end;
381 }
382 ret = devm_request_irq(&pdev->dev, pwr_irq, rockchip_pwm_pwrirq,
383 IRQF_NO_SUSPEND, "rk_pwm_pwr_irq", ddata);
384 if (ret) {
385 dev_err(&pdev->dev, "cannot claim PWR_IRQ!!!\n");
386 goto end;
387 }
388 val = readl_relaxed(ddata->base + PWM_REG_CTRL);
389 val = (val & 0xFFFFFFFE) | PWM_DISABLE;
390 writel_relaxed(val, ddata->base + PWM_REG_CTRL);
391
392 //preloader low min:8000us, max:10000us
393 min_temp = RK_PWM_TIME_PRE_MIN_LOW * 1000 / ddata->pwm_freq_nstime;
394 max_temp = RK_PWM_TIME_PRE_MAX_LOW * 1000 / ddata->pwm_freq_nstime;
395 val = (max_temp & 0xffff) << 16 | (min_temp & 0xffff);
396 writel_relaxed(val, ddata->base + PWM_REG_PWRMATCH_LPRE(pwm_id));
397
398 //preloader higt min:4000us, max:5000us
399 min_temp = RK_PWM_TIME_PRE_MIN * 1000 / ddata->pwm_freq_nstime;
400 max_temp = RK_PWM_TIME_PRE_MAX * 1000 / ddata->pwm_freq_nstime;
401 val = (max_temp & 0xffff) << 16 | (min_temp & 0xffff);
402 writel_relaxed(val, ddata->base + PWM_REG_PWRMATCH_HPRE(pwm_id));
403
404 //logic 0/1 low min:480us, max 700us
405 min_temp = RK_PWM_TIME_BIT_MIN_LOW * 1000 / ddata->pwm_freq_nstime;
406 max_temp = RK_PWM_TIME_BIT_MAX_LOW * 1000 / ddata->pwm_freq_nstime;
407 val = (max_temp & 0xffff) << 16 | (min_temp & 0xffff);
408 writel_relaxed(val, ddata->base + PWM_REG_PWRMATCH_LD(pwm_id));
409
410 //logic 0 higt min:480us, max 700us
411 min_temp = RK_PWM_TIME_BIT0_MIN * 1000 / ddata->pwm_freq_nstime;
412 max_temp = RK_PWM_TIME_BIT0_MAX * 1000 / ddata->pwm_freq_nstime;
413 val = (max_temp & 0xffff) << 16 | (min_temp & 0xffff);
414 writel_relaxed(val, ddata->base + PWM_REG_PWRMATCH_HD_ZERO(pwm_id));
415
416 //logic 1 higt min:1300us, max 2000us
417 min_temp = RK_PWM_TIME_BIT1_MIN * 1000 / ddata->pwm_freq_nstime;
418 max_temp = RK_PWM_TIME_BIT1_MAX * 1000 / ddata->pwm_freq_nstime;
419 val = (max_temp & 0xffff) << 16 | (min_temp & 0xffff);
420 writel_relaxed(val, ddata->base + PWM_REG_PWRMATCH_HD_ONE(pwm_id));
421
422 for (j = 0; j < ddata->maxkeybdnum; j++) {
423 for (i = 0; i < remotectl_button[j].nbuttons; i++) {
424 int scancode, usercode, pwrkey;
425
426 if (remotectl_button[j].key_table[i].keycode != KEY_POWER)
427 continue;
428 usercode = remotectl_button[j].usercode & 0xffff;
429 scancode = remotectl_button[j].key_table[i].scancode & 0xff;
430 DBG("usercode=%x, key=%x\n", usercode, scancode);
431 pwrkey = usercode;
432 pwrkey |= (scancode << 24) | ((~scancode & 0xff) << 16);
433 DBG("pwrkey = %x\n", pwrkey);
434 writel_relaxed(pwrkey, ddata->base
435 + PWM_PWRMATCH_VALUE(pwm_id) + num * 4);
436 num++;
437 if (num >= PWM_PWR_KEY_CAPURURE_MAX)
438 break;
439 }
440 }
441
442 val = readl_relaxed(ddata->base + PWM_REG_INT_EN(pwm_id));
443 val = (val & 0xFFFFFF7F) | PWM_PWR_INT_ENABLE;
444 writel_relaxed(val, ddata->base + PWM_REG_INT_EN(pwm_id));
445
446 val = CH3_PWRKEY_ENABLE;
447 writel_relaxed(val, ddata->base + PWM_REG_PWRMATCH_CTRL(pwm_id));
448
449 val = readl_relaxed(ddata->base + PWM_REG_CTRL);
450 val = (val & 0xFFFFFFFE) | PWM_ENABLE;
451 writel_relaxed(val, ddata->base + PWM_REG_CTRL);
452 ddata->pwm_pwrkey_capture = 1;
453 end:
454 return ret;
455 }
456
rk_pwm_int_ctrl(void __iomem * pwm_base,uint pwm_id,int ctrl)457 static void rk_pwm_int_ctrl(void __iomem *pwm_base, uint pwm_id, int ctrl)
458 {
459 int val;
460
461 if (pwm_id > 3)
462 return;
463 val = readl_relaxed(pwm_base + PWM_REG_INT_EN(pwm_id));
464 if (ctrl) {
465 val |= PWM_CH_INT_ENABLE(pwm_id);
466 DBG("pwm int enabled, value is 0x%x\n", val);
467 writel_relaxed(val, pwm_base + PWM_REG_INT_EN(pwm_id));
468 } else {
469 val &= ~PWM_CH_INT_ENABLE(pwm_id);
470 DBG("pwm int disabled, value is 0x%x\n", val);
471 }
472 writel_relaxed(val, pwm_base + PWM_REG_INT_EN(pwm_id));
473 }
474
rk_pwm_remotectl_hw_init(void __iomem * pwm_base,uint pwm_id)475 static int rk_pwm_remotectl_hw_init(void __iomem *pwm_base, uint pwm_id)
476 {
477 int val;
478
479 if (pwm_id > 3)
480 return -1;
481 //1. disabled pwm
482 val = readl_relaxed(pwm_base + PWM_REG_CTRL);
483 val = (val & 0xFFFFFFFE) | PWM_DISABLE;
484 writel_relaxed(val, pwm_base + PWM_REG_CTRL);
485 //2. capture mode
486 val = readl_relaxed(pwm_base + PWM_REG_CTRL);
487 val = (val & 0xFFFFFFF9) | PWM_MODE_CAPTURE;
488 writel_relaxed(val, pwm_base + PWM_REG_CTRL);
489 //set clk div, clk div to 64
490 val = readl_relaxed(pwm_base + PWM_REG_CTRL);
491 val = (val & 0xFF0001FF) | PWM_DIV64;
492 writel_relaxed(val, pwm_base + PWM_REG_CTRL);
493 //4. enabled pwm int
494 rk_pwm_int_ctrl(pwm_base, pwm_id, PWM_INT_ENABLE);
495 //5. enabled pwm
496 val = readl_relaxed(pwm_base + PWM_REG_CTRL);
497 val = (val & 0xFFFFFFFE) | PWM_ENABLE;
498 writel_relaxed(val, pwm_base + PWM_REG_CTRL);
499 return 0;
500 }
501
rk_pwm_sip_wakeup_init(struct platform_device * pdev)502 static int rk_pwm_sip_wakeup_init(struct platform_device *pdev)
503 {
504 struct rkxx_remotectl_drvdata *ddata = platform_get_drvdata(pdev);
505 struct device_node *np = pdev->dev.of_node;
506 struct irq_desc *desc;
507 int support_psci = 0;
508 int irq;
509 int hwirq;
510 int i, j;
511 int num;
512 int pwm_id;
513 int ret = -1;
514
515 if (of_property_read_u32(np, "remote_support_psci", &support_psci)) {
516 dev_info(&pdev->dev, "PWM Missing psci property in the DT.\n");
517 goto end;
518 }
519 DBG("support_psci=0x%x\n", support_psci);
520 if (!support_psci)
521 goto end;
522 irq = ddata->irq;
523 desc = irq_to_desc(irq);
524 if (!desc || !desc->irq_data.domain)
525 goto end;
526 hwirq = desc->irq_data.hwirq;
527 ret = sip_smc_remotectl_config(REMOTECTL_SET_IRQ, hwirq);
528 if (ret) {
529 dev_err(&pdev->dev, "set irq err, set support_psci to 0 !!\n");
530 /*
531 * if atf doesn't support, return probe success to abandon atf
532 * function and still use kernel pwm parse function
533 */
534 goto end;
535 }
536 pwm_id = ddata->remote_pwm_id;
537 num = ddata->maxkeybdnum;
538 sip_smc_remotectl_config(REMOTECTL_SET_PWM_CH, pwm_id);
539 for (j = 0; j < num; j++) {
540 for (i = 0; i < remotectl_button[j].nbuttons; i++) {
541 int scancode, pwrkey;
542
543 if (remotectl_button[j].key_table[i].keycode
544 != KEY_POWER)
545 continue;
546 scancode = remotectl_button[j].key_table[i].scancode;
547 DBG("usercode=%x, key=%x\n",
548 remotectl_button[j].usercode, scancode);
549 pwrkey = (remotectl_button[j].usercode & 0xffff) << 16;
550 pwrkey |= (scancode & 0xff) << 8;
551 DBG("deliver: key=%x\n", pwrkey);
552 sip_smc_remotectl_config(REMOTECTL_SET_PWRKEY,
553 pwrkey);
554 }
555 }
556 sip_smc_remotectl_config(REMOTECTL_ENABLE, 1);
557 ddata->support_psci = support_psci;
558 DBG("rk pwm sip init end!\n");
559 return 0;
560 end:
561 dev_info(&pdev->dev, "pwm sip wakeup config error!!\n");
562 ddata->support_psci = 0;
563 return ret;
564 }
565
rk_pwm_wakeup(struct input_dev * input)566 static inline void rk_pwm_wakeup(struct input_dev *input)
567 {
568 input_event(input, EV_KEY, KEY_POWER, 1);
569 input_event(input, EV_KEY, KEY_POWER, 0);
570 input_sync(input);
571 }
572
rk_pwm_probe(struct platform_device * pdev)573 static int rk_pwm_probe(struct platform_device *pdev)
574 {
575 struct rkxx_remotectl_drvdata *ddata;
576 struct device_node *np = pdev->dev.of_node;
577 struct resource *r;
578 struct input_dev *input;
579 struct clk *clk;
580 struct clk *p_clk;
581 struct cpumask cpumask;
582 int num;
583 int irq;
584 int ret;
585 int i, j;
586 int cpu_id;
587 int pwm_id;
588 int pwm_freq;
589 int count;
590
591 pr_err(".. rk pwm remotectl v2.0 init\n");
592 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
593 if (!r) {
594 dev_err(&pdev->dev, "no memory resources defined\n");
595 return -ENODEV;
596 }
597 ddata = devm_kzalloc(&pdev->dev, sizeof(struct rkxx_remotectl_drvdata),
598 GFP_KERNEL);
599 if (!ddata) {
600 dev_err(&pdev->dev, "failed to allocate memory\n");
601 return -ENOMEM;
602 }
603 ddata->state = RMC_PRELOAD;
604 ddata->temp_period = 0;
605 ddata->base = devm_ioremap_resource(&pdev->dev, r);
606 if (IS_ERR(ddata->base))
607 return PTR_ERR(ddata->base);
608 count = of_property_count_strings(np, "clock-names");
609 if (count == 2) {
610 clk = devm_clk_get(&pdev->dev, "pwm");
611 p_clk = devm_clk_get(&pdev->dev, "pclk");
612 } else {
613 clk = devm_clk_get(&pdev->dev, NULL);
614 p_clk = clk;
615 }
616 if (IS_ERR(clk)) {
617 ret = PTR_ERR(clk);
618 if (ret != -EPROBE_DEFER)
619 dev_err(&pdev->dev, "Can't get bus clk: %d\n", ret);
620 return ret;
621 }
622 if (IS_ERR(p_clk)) {
623 ret = PTR_ERR(p_clk);
624 if (ret != -EPROBE_DEFER)
625 dev_err(&pdev->dev, "Can't get periph clk: %d\n", ret);
626 return ret;
627 }
628 ret = clk_prepare_enable(clk);
629 if (ret) {
630 dev_err(&pdev->dev, "Can't enable bus clk: %d\n", ret);
631 return ret;
632 }
633 ret = clk_prepare_enable(p_clk);
634 if (ret) {
635 dev_err(&pdev->dev, "Can't enable bus periph clk: %d\n", ret);
636 goto error_clk;
637 }
638 platform_set_drvdata(pdev, ddata);
639 num = rk_remotectl_get_irkeybd_count(pdev);
640 if (num == 0) {
641 pr_err("remotectl: no ir keyboard add in dts!!\n");
642 ret = -EINVAL;
643 goto error_pclk;
644 }
645 ddata->maxkeybdnum = num;
646 remotectl_button = devm_kzalloc(&pdev->dev,
647 num * sizeof(struct rkxx_remotectl_button),
648 GFP_KERNEL);
649 if (!remotectl_button) {
650 pr_err("failed to malloc remote button memory\n");
651 ret = -ENOMEM;
652 goto error_pclk;
653 }
654 input = devm_input_allocate_device(&pdev->dev);
655 if (!input) {
656 pr_err("failed to allocate input device\n");
657 ret = -ENOMEM;
658 goto error_pclk;
659 }
660 input->name = pdev->name;
661 input->phys = "gpio-keys/remotectl";
662 input->dev.parent = &pdev->dev;
663 input->id.bustype = BUS_HOST;
664 input->id.vendor = 0x524b;
665 input->id.product = 0x0006;
666 input->id.version = 0x0100;
667 ddata->input = input;
668 irq = platform_get_irq(pdev, 0);
669 if (irq < 0) {
670 dev_err(&pdev->dev, "cannot find IRQ\n");
671 goto error_pclk;
672 }
673 ddata->irq = irq;
674 ddata->wakeup = 1;
675 of_property_read_u32(np, "remote_pwm_id", &pwm_id);
676 pwm_id %= 4;
677 ddata->remote_pwm_id = pwm_id;
678 if (pwm_id > 3) {
679 dev_err(&pdev->dev, "pwm id error\n");
680 goto error_pclk;
681 }
682 DBG("remotectl: remote pwm id=0x%x\n", pwm_id);
683 of_property_read_u32(np, "handle_cpu_id", &cpu_id);
684 ddata->handle_cpu_id = cpu_id;
685 DBG("remotectl: handle cpu id=0x%x\n", cpu_id);
686 rk_remotectl_parse_ir_keys(pdev);
687 tasklet_init(&ddata->remote_tasklet, rk_pwm_remotectl_do_something,
688 (unsigned long)ddata);
689 for (j = 0; j < num; j++) {
690 DBG("remotectl probe j = 0x%x\n", j);
691 for (i = 0; i < remotectl_button[j].nbuttons; i++) {
692 int keycode;
693
694 keycode = remotectl_button[j].key_table[i].keycode;
695 input_set_capability(input, EV_KEY, keycode);
696 }
697 }
698 ret = input_register_device(input);
699 if (ret)
700 dev_err(&pdev->dev, "register input device err, ret=%d\n", ret);
701 input_set_capability(input, EV_KEY, KEY_WAKEUP);
702 device_init_wakeup(&pdev->dev, 1);
703 enable_irq_wake(irq);
704 timer_setup(&ddata->timer, rk_pwm_remotectl_timer, 0);
705 wake_lock_init(&ddata->remotectl_wake_lock,
706 WAKE_LOCK_SUSPEND, "rockchip_pwm_remote");
707 cpumask_clear(&cpumask);
708 cpumask_set_cpu(cpu_id, &cpumask);
709 irq_set_affinity_hint(irq, &cpumask);
710 ret = devm_request_irq(&pdev->dev, irq, rockchip_pwm_irq,
711 IRQF_NO_SUSPEND, "rk_pwm_irq", ddata);
712 if (ret) {
713 dev_err(&pdev->dev, "cannot claim IRQ %d\n", irq);
714 goto error_irq;
715 }
716
717 pwm_freq = clk_get_rate(clk) / 64;
718 ddata->pwm_freq_nstime = 1000000000 / pwm_freq;
719 rk_pwm_remotectl_hw_init(ddata->base, pwm_id);
720
721 ret = rk_pwm_pwrkey_wakeup_init(pdev);
722 if (!ret) {
723 dev_info(&pdev->dev, "Controller support pwrkey capture\n");
724 goto end;
725 }
726
727 ret = rk_pwm_sip_wakeup_init(pdev);
728 if (ret)
729 dev_info(&pdev->dev, "Donot support ATF Wakeup\n");
730 else
731 dev_info(&pdev->dev, "Support ATF Wakeup\n");
732
733 DBG("rk pwm remotectl init end!\n");
734 end:
735 return 0;
736 error_irq:
737 wake_lock_destroy(&ddata->remotectl_wake_lock);
738 error_pclk:
739 clk_unprepare(p_clk);
740 error_clk:
741 clk_unprepare(clk);
742 return ret;
743 }
744
rk_pwm_remove(struct platform_device * pdev)745 static int rk_pwm_remove(struct platform_device *pdev)
746 {
747 return 0;
748 }
749
750 #ifdef CONFIG_PM
remotectl_suspend(struct device * dev)751 static int remotectl_suspend(struct device *dev)
752 {
753 int cpu = 0;
754 int pwm_id;
755 struct cpumask cpumask;
756 struct platform_device *pdev = to_platform_device(dev);
757 struct rkxx_remotectl_drvdata *ddata = platform_get_drvdata(pdev);
758
759 if (ddata->pwm_pwrkey_capture) {
760 pwm_id = ddata->remote_pwm_id;
761 ddata->pwrkey_wakeup = 0;
762 rk_pwm_int_ctrl(ddata->base, pwm_id, PWM_INT_DISABLE);
763 }
764 cpumask_clear(&cpumask);
765 cpumask_set_cpu(cpu, &cpumask);
766 irq_set_affinity_hint(ddata->irq, &cpumask);
767 return 0;
768 }
769
770
remotectl_resume(struct device * dev)771 static int remotectl_resume(struct device *dev)
772 {
773 struct cpumask cpumask;
774 int pwm_id;
775 struct platform_device *pdev = to_platform_device(dev);
776 struct rkxx_remotectl_drvdata *ddata = platform_get_drvdata(pdev);
777 int state;
778
779 cpumask_clear(&cpumask);
780 cpumask_set_cpu(ddata->handle_cpu_id, &cpumask);
781 irq_set_affinity_hint(ddata->irq, &cpumask);
782 if (ddata->support_psci) {
783 /*
784 * loop wakeup state
785 */
786 state = sip_smc_remotectl_config(
787 REMOTECTL_GET_WAKEUP_STATE, 0);
788 if (state == REMOTECTL_PWRKEY_WAKEUP)
789 rk_pwm_wakeup(ddata->input);
790 } else if (ddata->pwm_pwrkey_capture) {
791 pwm_id = ddata->remote_pwm_id;
792 rk_pwm_int_ctrl(ddata->base, pwm_id, PWM_INT_ENABLE);
793 if (ddata->pwrkey_wakeup == 0)
794 return 0;
795 ddata->pwrkey_wakeup = 0;
796 rk_pwm_wakeup(ddata->input);
797 }
798
799 return 0;
800 }
801
802 static const struct dev_pm_ops remotectl_pm_ops = {
803 .suspend_late = remotectl_suspend,
804 .resume_early = remotectl_resume,
805 };
806 #endif
807
808 static const struct of_device_id rk_pwm_of_match[] = {
809 { .compatible = "rockchip,remotectl-pwm"},
810 { }
811 };
812
813 MODULE_DEVICE_TABLE(of, rk_pwm_of_match);
814
815 static struct platform_driver rk_pwm_driver = {
816 .driver = {
817 .name = "remotectl-pwm",
818 .of_match_table = rk_pwm_of_match,
819 #ifdef CONFIG_PM
820 .pm = &remotectl_pm_ops,
821 #endif
822 },
823 .remove = rk_pwm_remove,
824 };
825
826 module_platform_driver_probe(rk_pwm_driver, rk_pwm_probe);
827
828 MODULE_LICENSE("GPL");
829