1 /*drivers/cir/bu92747guw_cir.c - driver for bu92747guw
3 * Copyright (C) 2010 ROCKCHIP, Inc.
5 * This software is licensed under the terms of the GNU General Public
6 * License version 2, as published by the Free Software Foundation, and
7 * may be copied, distributed, and modified under those terms.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 #include <linux/interrupt.h>
15 #include <linux/slab.h>
16 #include <linux/irq.h>
17 #include <linux/gpio.h>
18 #include <asm/uaccess.h>
19 #include <linux/workqueue.h>
20 #include <linux/module.h>
21 #include <linux/i2c.h>
22 #include <linux/platform_device.h>
23 #include <linux/types.h>
24 #include <linux/bcd.h>
25 #include <linux/spinlock.h>
27 #include <linux/delay.h>
28 #include <linux/wakelock.h>
29 #include <linux/miscdevice.h>
30 #include <linux/freezer.h>
31 #include <mach/gpio.h>
32 #include <mach/iomux.h>
33 #include <mach/rk29_smc.h>
35 #include "bu92747guw_cir.h"
38 #define BU92747_DBG(x...) printk(x)
40 #define BU92747_DBG(x...)
43 #define CIR_IIC_SPEED 100 * 1000
45 #define XIN_INPUT_FREQ 48*1000 //KHz
47 struct bu92747_data_info {
48 struct bu92747guw_platform_data *platdata;
49 struct i2c_client *client;
54 struct delayed_work dwork;
60 static struct miscdevice bu92747guw_device;
64 //mutex lock between remote and irda
65 static DEFINE_MUTEX(bu92747_mutex);
66 void bu92747_lock(void)
68 mutex_lock(&bu92747_mutex);
70 void bu92747_unlock(void)
72 mutex_unlock(&bu92747_mutex);
79 static int bu92747_cir_i2c_read_regs(struct i2c_client *client, u8 reg, u8 *buf, int len)
82 ret = i2c_master_reg8_recv(client, reg, buf, len, CIR_IIC_SPEED);
86 static int bu92747_cir_i2c_set_regs(struct i2c_client *client, u8 reg, u8 *buf, int len)
89 ret = i2c_master_reg8_send(client, reg, buf, len, CIR_IIC_SPEED);
94 static int bu92747_stop(struct i2c_client *client)
97 struct bu92747_data_info *bu92747 = (struct bu92747_data_info *)i2c_get_clientdata(client);
98 //BU92747_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);
99 printk("line %d: enter %s\n", __LINE__, __FUNCTION__);
100 // disable_irq(bu92747->irq);
101 //diable clk, repeat=1
102 bu92747_cir_i2c_read_regs(client, REG_SETTING0, reg_value, 2);
103 reg_value[0] = reg_value[0]&0xfe;
104 reg_value[1] = reg_value[1]&0xf1;
105 bu92747_cir_i2c_set_regs(client, REG_SETTING0, reg_value, 2);
108 BU92747_DBG("line %d: exit %s\n", __LINE__, __FUNCTION__);
112 static void bu92747_dwork_handler(struct work_struct *work)
114 struct bu92747_data_info *bu92747 =
115 (struct bu92747_data_info *)container_of(work, struct bu92747_data_info, dwork.work);
118 printk("------- sss enter %s\n", __func__);
120 if ( !start_flag && (repeat_flag <= -1)){
121 bu92747_stop(bu92747->client);
122 BU92747_DBG("----------exit %s\n", __func__);
128 bu92747_cir_i2c_read_regs(bu92747->client, REG_SETTING1, reg_value, 1);
129 reg_value[0] &= 0xf0;
130 bu92747_cir_i2c_set_regs(bu92747->client, REG_SETTING1, reg_value, 1);
131 //printk("----------exit %s reg_value = %d\n", __func__, reg_value[1]);
136 bu92747_cir_i2c_set_regs(bu92747->client, REG_SEND, reg_value, 1);
137 // bu92747_cir_i2c_read_regs(bu92747->client, REG_FRMLEN1, reg_value, 2);
139 // printk("frame_interval = 0x%x\n", reg_value[1], reg_value[2]);
142 BU92747_DBG("----------exit %s\n", __func__);
146 static irqreturn_t bu92747_cir_irq(int irq, void *dev_id)
149 struct i2c_client *client = container_of(bu92747guw_device.parent, struct i2c_client, dev);
150 struct bu92747_data_info *bu92747 = (struct bu92747_data_info *)i2c_get_clientdata(client);
152 printk("----------enter %s repeat_flag = %d\n", __func__, repeat_flag);
155 if (((--repeat_flag%16) == 0) || (repeat_flag < 0)){
156 schedule_delayed_work(&bu92747->dwork, msecs_to_jiffies(0));
165 static int bu92747_send_data(struct i2c_client *client, struct rk29_cir_struct_info *cir)
168 unsigned int hlo, hhi;
171 struct bu92747_data_info *bu92747 = (struct bu92747_data_info *)i2c_get_clientdata(client);
172 struct bu92747guw_platform_data *pdata = bu92747->platdata;
173 int sys_clock = bu92747->sys_clock;
176 BU92747_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);
177 //if (bu92747->state == BU92747_BUSY) {
178 // printk("line %d, func: %s, dev is busy now\n", __LINE__, __func__);
182 //bu92747->state = BU92747_BUSY;
184 repeat_flag = cir->repeat%16;
186 bu92747_cir_i2c_read_regs(client, REG_SETTING0, reg_value, 2);
188 inv0 = cir->inv & 0x01;
189 inv1 = (cir->inv>>1) & 0x01;
190 reg_value[0] = reg_value[0] | (inv0<<1) | (inv1<<2);
191 reg_value[1] = (reg_value[1]&0xf0) | (repeat_flag&0x0f);
192 bu92747_cir_i2c_set_regs(client, REG_SETTING0, reg_value, 2);
193 BU92747_DBG("inv0 = %d, inv1 = %d, repeat=%d\n", inv0, inv1, repeat_flag);
195 //head maybe different while repeat
196 if ((bu92747->head_burst_time!=cir->head_burst_time)
197 || (bu92747->head_space_time!=cir->head_space_time)) {
198 hlo = (cir->head_space_time*sys_clock)/1000;
199 hhi = (cir->head_burst_time*sys_clock)/1000;
200 reg_value[0] = hlo>>8;
201 reg_value[1] = hlo&0xff;
202 reg_value[2] = hhi>>8;
203 reg_value[3] = hhi&0xff;
204 bu92747_cir_i2c_set_regs(client, REG_HLO1, reg_value, 4);
205 BU92747_DBG("hlo = 0x%x, hhi = 0x%x\n", hlo, hhi);
208 //switch to remote control
212 reg_value[0] = cir->frame_bit_len;
213 bu92747_cir_i2c_set_regs(client, REG_BITLEN, reg_value, 1);
214 BU92747_DBG("frame_bit_len = 0x%x\n", cir->frame_bit_len);
217 nByte = (cir->frame_bit_len+7)/8;
218 for (i=0; i<nByte; i++) {
219 reg_value[i] = ((cir->frame)>>(8*i))&0xff;
220 BU92747_DBG("reg_value[%d] = %d\n", i, reg_value[i]);
222 bu92747_cir_i2c_set_regs(client, REG_OUT0, reg_value, nByte);
223 BU92747_DBG("nByte = %d\n", nByte);
225 //clear irq, start send
228 //bu92747_cir_i2c_set_regs(client, REG_IRQC, reg_value, 2);
231 // while (gpio_get_value(pdata->intr_pin)) {
232 // BU92747_DBG("line %d: data register is not null\n", __LINE__);
235 //switch to irda control
236 //smc0_write(3, smc0_read(3) & 0xfbff);
239 //enable_irq(bu92747->irq);
241 BU92747_DBG("line %d: exit %s\n", __LINE__, __FUNCTION__);
246 static int bu92747_set_format(struct i2c_client *client, struct rk29_cir_struct_info *cir)
249 unsigned int clo, chi, clo_org, chi_org;
250 unsigned int hlo, hhi;
251 unsigned int d0lo, d0hi, d1lo, d1hi;
254 unsigned int carry_freq = cir->carry;
256 struct bu92747_data_info *bu92747 = (struct bu92747_data_info *)i2c_get_clientdata(client);
257 int sys_clock = bu92747->sys_clock;
259 BU92747_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);
265 inv0 = cir->inv & 0x01;
266 inv1 = (cir->inv>>1) & 0x01;
267 bu92747_cir_i2c_read_regs(client, REG_SETTING0, reg_value, 1);
268 reg_value[0] = reg_value[0] | (inv0<<1) | (inv1<<2);
269 bu92747_cir_i2c_set_regs(client, REG_SETTING0, reg_value, 1);
270 BU92747_DBG("inv0 = %d, inv1 = %d\n", inv0, inv1);
271 bu92747->inv = cir->inv;
274 chi_org = cir->duty_cycle / 10;
275 clo_org = (cir->duty_cycle % 10) - chi_org;
276 clo = (XIN_INPUT_FREQ*clo_org)/(3*carry_freq*(clo_org+chi_org));
277 chi = (XIN_INPUT_FREQ*chi_org)/(3*carry_freq*(clo_org+chi_org));
278 reg_value[0] = clo>>8;
279 reg_value[1] = clo&0xff;
280 reg_value[2] = chi>>8;
281 reg_value[3] = chi&0xff;
282 BU92747_DBG("clo = 0x%x, chi = 0x%x\n", clo, chi);
285 hlo = (cir->head_space_time*sys_clock)/1000;
286 hhi = (cir->head_burst_time*sys_clock)/1000;
287 reg_value[4] = hlo>>8;
288 reg_value[5] = hlo&0xff;
289 reg_value[6] = hhi>>8;
290 reg_value[7] = hhi&0xff;
291 BU92747_DBG("hlo = 0x%x, hhi = 0x%x\n", hlo, hhi);
292 bu92747->head_space_time = cir->head_space_time;
293 bu92747->head_burst_time = cir->head_burst_time;
296 d0lo = (cir->logic_low_space_time*sys_clock)/1000;
297 d0hi = (cir->logic_low_burst_time*sys_clock)/1000;
298 reg_value[8] = d0lo>>8;
299 reg_value[9] = d0lo&0xff;
300 reg_value[10] = d0hi>>8;
301 reg_value[11] = d0hi&0xff;
302 BU92747_DBG("d0lo = 0x%x, d0hi = 0x%x\n", d0lo, d0hi);
305 d1lo = (cir->logic_high_space_time*sys_clock)/1000;
306 d1hi = (cir->logic_high_burst_time*sys_clock)/1000;
307 reg_value[12] = d1lo>>8;
308 reg_value[13] = d1lo&0xff;
309 reg_value[14] = d1hi>>8;
310 reg_value[15] = d1hi&0xff;
311 BU92747_DBG("d1lo = 0x%x, d1hi = 0x%x\n", d1lo, d1hi);
314 end = (cir->stop_bit_interval*sys_clock)/1000;
315 reg_value[16] = end>>8;
316 reg_value[17] = end&0xff;
317 bu92747_cir_i2c_set_regs(client, REG_CLO1, reg_value, 18);
319 BU92747_DBG("end = 0x%x\n", end);
322 frame_interval = (cir->frame_interval*sys_clock)/1000;
323 reg_value[0] = frame_interval>>8;
324 reg_value[1] = frame_interval&0xff;
325 bu92747_cir_i2c_set_regs(client, REG_FRMLEN1, reg_value, 2);
327 BU92747_DBG("frame_interval = 0x%x\n", frame_interval);
329 BU92747_DBG("line %d: exit %s\n", __LINE__, __FUNCTION__);
336 static int bu92747_start(struct i2c_client *client)
339 struct bu92747_data_info *bu92747 = (struct bu92747_data_info *)i2c_get_clientdata(client);
340 printk("line %d: enter %s\n", __LINE__, __FUNCTION__);
344 //enable_irq(bu92747->irq);
346 bu92747_cir_i2c_read_regs(client, REG_SETTING0, reg_value, 1);
347 reg_value[0] = reg_value[0]|0x01;
348 bu92747_cir_i2c_set_regs(client, REG_SETTING0, reg_value, 1);
350 //clear irq, start send
353 bu92747_cir_i2c_set_regs(client, REG_IRQC, reg_value, 2);
356 printk("line %d: exit %s\n", __LINE__, __FUNCTION__);
361 static void bu92747_printk_cir(struct rk29_cir_struct_info *cir)
363 BU92747_DBG("\ncir struct:\n");
364 BU92747_DBG("carry_high = %d\n", cir->carry_high);
365 BU92747_DBG("carry_low = %d\n", cir->carry_low);
366 BU92747_DBG("repeat = %d\n", cir->repeat);
367 BU92747_DBG("inv = %d\n", cir->inv);
368 BU92747_DBG("frame_bit_len = %d\n", cir->frame_bit_len);
369 BU92747_DBG("stop_bit_interval = %d\n", cir->stop_bit_interval);
370 BU92747_DBG("frame = %lld\n", cir->frame);
371 BU92747_DBG("frame_interval = %d\n", cir->frame_interval);
372 BU92747_DBG("head_burst_time = %d\n", cir->head_burst_time);
373 BU92747_DBG("head_space_time = %d\n", cir->head_space_time);
374 BU92747_DBG("logic_high_burst_time = %d\n", cir->logic_high_burst_time);
375 BU92747_DBG("logic_high_space_time = %d\n", cir->logic_high_space_time);
376 BU92747_DBG("logic_low_burst_time = %d\n", cir->logic_low_burst_time);
377 BU92747_DBG("logic_low_space_time = %d\n", cir->logic_low_space_time);
382 static int bu92747_set_duration(struct i2c_client *client, struct rk29_cir_struct_info *cir)
387 struct bu92747_data_info *bu92747 = (struct bu92747_data_info *)i2c_get_clientdata(client);
388 int sys_clock = bu92747->sys_clock;
390 BU92747_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);
395 BU92747_DBG("sys_clock = %d, frame_interval = 0x%x\n", sys_clock,cir->frame_interval);
397 frame_interval = (cir->frame_interval*sys_clock)/1000;
399 reg_value[0] = frame_interval>>8;
400 reg_value[1] = frame_interval&0xff;
401 bu92747_cir_i2c_set_regs(client, REG_FRMLEN1, reg_value, 2);
403 BU92747_DBG("frame_interval = 0x%x\n", frame_interval);
405 BU92747_DBG("line %d: exit %s\n", __LINE__, __FUNCTION__);
411 static int bu92747_set_data(struct i2c_client *client, struct rk29_cir_struct_info *cir)
419 BU92747_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);
422 reg_value[0] = cir->frame_bit_len;
423 bu92747_cir_i2c_set_regs(client, REG_BITLEN, reg_value, 1);
424 BU92747_DBG("frame_bit_len = 0x%x\n", cir->frame_bit_len);
427 nByte = (cir->frame_bit_len+7)/8;
428 for (i=0; i<nByte; i++) {
429 reg_value[i] = ((cir->frame)>>(8*i))&0xff;
430 BU92747_DBG("reg_value[%d] = %d\n", i, reg_value[i]);
432 bu92747_cir_i2c_set_regs(client, REG_OUT0, reg_value, nByte);
433 BU92747_DBG("nByte = %d\n", nByte);
436 BU92747_DBG("line %d: exit %s\n", __LINE__, __FUNCTION__);
441 static int bu92747_set_pulse(struct i2c_client *client, struct rk29_cir_struct_info *cir)
446 unsigned int d0lo, d0hi, d1lo, d1hi;
449 u8 reg_value[8] = {0};
450 struct bu92747_data_info *bu92747 = (struct bu92747_data_info *)i2c_get_clientdata(client);
451 int sys_clock = bu92747->sys_clock;
453 BU92747_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);
459 inv0 = cir->inv & 0x01;
460 inv1 = (cir->inv>>1) & 0x01;
461 bu92747_cir_i2c_read_regs(client, REG_SETTING0, reg_value, 1);
462 reg_value[0] = reg_value[0] | (inv0<<1) | (inv1<<2);
463 bu92747_cir_i2c_set_regs(client, REG_SETTING0, reg_value, 1);
464 BU92747_DBG("inv0 = %d, inv1 = %d\n", inv0, inv1);
465 bu92747->inv = cir->inv;
469 d0lo = (cir->logic_low_space_time*sys_clock)/1000;
470 d0hi = (cir->logic_low_burst_time*sys_clock)/1000;
471 reg_value[0] = d0lo>>8;
472 reg_value[1] = d0lo&0xff;
473 reg_value[2] = d0hi>>8;
474 reg_value[3] = d0hi&0xff;
475 BU92747_DBG("d0lo = 0x%x, d0hi = 0x%x\n", d0lo, d0hi);
478 d1lo = (cir->logic_high_space_time*sys_clock)/1000;
479 d1hi = (cir->logic_high_burst_time*sys_clock)/1000;
480 reg_value[4] = d1lo>>8;
481 reg_value[5] = d1lo&0xff;
482 reg_value[6] = d1hi>>8;
483 reg_value[7] = d1hi&0xff;
484 BU92747_DBG("d1lo = 0x%x, d1hi = 0x%x\n", d1lo, d1hi);
485 bu92747_cir_i2c_set_regs(client, REG_D0LO1, reg_value, 8);
487 BU92747_DBG("line %d: exit %s\n", __LINE__, __FUNCTION__);
495 static int bu92747_set_parameter(struct i2c_client *client, struct rk29_cir_struct_info *cir)
497 unsigned int hlo, hhi;
501 struct bu92747_data_info *bu92747 = (struct bu92747_data_info *)i2c_get_clientdata(client);
502 int sys_clock = bu92747->sys_clock;
504 BU92747_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);
510 hlo = (cir->head_space_time*sys_clock)/1000;
511 hhi = (cir->head_burst_time*sys_clock)/1000;
512 reg_value[0] = hlo>>8;
513 reg_value[1] = hlo&0xff;
514 reg_value[2] = hhi>>8;
515 reg_value[3] = hhi&0xff;
516 BU92747_DBG("hlo = 0x%x, hhi = 0x%x\n", hlo, hhi);
517 bu92747->head_space_time = cir->head_space_time;
518 bu92747->head_burst_time = cir->head_burst_time;
519 bu92747_cir_i2c_set_regs(client, REG_HLO1, reg_value, 4);
522 end = (cir->stop_bit_interval*sys_clock)/1000;
523 reg_value[0] = end>>8;
524 reg_value[1] = end&0xff;
525 bu92747_cir_i2c_set_regs(client, REG_ENDLEN1, reg_value, 2);
527 BU92747_DBG("end = 0x%x\n", end);
529 BU92747_DBG("line %d: exit %s\n", __LINE__, __FUNCTION__);
536 static int bu92747_set_repeat(struct i2c_client *client, struct rk29_cir_struct_info *cir)
542 BU92747_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);
544 repeat_flag = cir->repeat;
545 printk("repeat 11111 =%d\n", repeat_flag);
547 if (repeat_flag > 16){
550 repeat = repeat_flag;
553 repeat = repeat % 16;
555 bu92747_cir_i2c_read_regs(client, REG_SETTING1, reg_value, 1);
557 reg_value[0] = (reg_value[0]&0xf0) | (repeat&0x0f);
558 bu92747_cir_i2c_set_regs(client, REG_SETTING1, reg_value, 1);
559 printk("repeat 2222 =%d reg_value = %d\n", repeat, reg_value[0]);
561 BU92747_DBG("line %d: exit %s\n", __LINE__, __FUNCTION__);
566 static int bu92747_set_carrier(struct i2c_client *client, struct rk29_cir_struct_info *cir)
569 u16 clo = 0, chi = 0;
570 unsigned int hlo = cir->carry_low , hhi = cir->carry_high;
572 BU92747_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);
579 clo = XIN_INPUT_FREQ / 3000 * hlo;
580 chi = XIN_INPUT_FREQ / 3000 * hhi;
581 reg_value[0] = clo>>8;
582 reg_value[1] = clo&0xff;
583 reg_value[2] = chi>>8;
584 reg_value[3] = chi&0xff;
585 BU92747_DBG("clo = 0x%x, chi = 0x%x\n", clo, chi);
586 bu92747_cir_i2c_set_regs(client, REG_CLO1, reg_value, 4);
588 BU92747_DBG("line %d: exit %s\n", __LINE__, __FUNCTION__);
595 static int bu92747_cir_init_device(struct i2c_client *client, struct bu92747_data_info *bu92747)
599 BU92747_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);
601 //transmission buff null intertupt, base clock div, irq enable, clock power up
602 //reg_value[0] = /*REG0_OPM | */REG0_DIVS | REG0_PWR | REG0_IRQE;
603 reg_value[0] = /*REG0_OPM | */REG0_DIVS | REG0_IRQE;
604 reg_value[1] = REG1_FRME | REG1_RPT; //enable frame interval, repeat = 1
605 reg_value[2] = 80; //base clock = 100KHz
606 BU92747_DBG("line %d: reg0=0x%x, reg1=0x%x, reg2=0x%x\n", __LINE__, reg_value[0], reg_value[1], reg_value[2]);
607 bu92747_cir_i2c_set_regs(client, REG_SETTING0, reg_value, 3);
608 bu92747_cir_i2c_read_regs(client, REG_SETTING0, reg_value, 3);
609 BU92747_DBG("line %d: reg0=0x%x, reg1=0x%x, reg2=0x%x\n", __LINE__, reg_value[0], reg_value[1], reg_value[2]);
611 bu92747->base_clock = 100; //KHz
612 bu92747->sys_clock = bu92747->base_clock;
614 BU92747_DBG("line %d: exit %s\n", __LINE__, __FUNCTION__);
619 static int bu92747_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
621 void __user *argp = (void __user *)arg;
622 char msg[CIR_FRAME_SIZE];
624 struct i2c_client *client = container_of(bu92747guw_device.parent, struct i2c_client, dev);
626 BU92747_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);
631 case BU92747_IOCTL_START:
632 ret = bu92747_start(client);
637 case BU92747_IOCTL_STOP:
638 ret = bu92747_stop(client);
643 case BU92747_IOCTL_PULSE:
644 if (copy_from_user(&msg, argp, sizeof(msg)))
647 //bu92747_printk_cir((struct rk29_cir_struct_info *)msg);
648 ret = bu92747_set_pulse(client, (struct rk29_cir_struct_info *)msg);
653 case BU92747_IOCTL_DATA:
654 if (copy_from_user(&msg, argp, sizeof(msg)))
656 ret = bu92747_set_data(client, (struct rk29_cir_struct_info *)msg);
661 case BU92747_IOCTL_CARRIER:
662 if (copy_from_user(&msg, argp, sizeof(msg)))
664 ret = bu92747_set_carrier(client, (struct rk29_cir_struct_info *)msg);
668 case BU92747_IOCTL_REPEAT:
669 if (copy_from_user(&msg, argp, sizeof(msg)))
671 ret = bu92747_set_repeat(client, (struct rk29_cir_struct_info *)msg);
676 case BU92747_IOCTL_DURATION:
677 if (copy_from_user(&msg, argp, sizeof(msg)))
679 ret = bu92747_set_duration(client, (struct rk29_cir_struct_info *)msg);
683 case BU92747_IOCTL_PARAMETER:
684 if (copy_from_user(&msg, argp, sizeof(msg)))
687 ret = bu92747_set_parameter(client, (struct rk29_cir_struct_info *)msg);
695 BU92747_DBG("line %d: exit %s\n", __LINE__, __FUNCTION__);
700 static int bu92747_open(struct inode *inode, struct file *file)
702 struct i2c_client *client = container_of(bu92747guw_device.parent, struct i2c_client, dev);
703 struct bu92747_data_info *bu92747 = (struct bu92747_data_info *)i2c_get_clientdata(client);
704 struct bu92747guw_platform_data *pdata = bu92747->platdata;
706 BU92747_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);
708 printk("bu92747_open\n");
709 // if (BU92747_OPEN == bu92747->state)
711 // bu92747->state = BU92747_OPEN;
714 if (pdata && pdata->cir_pwr_ctl) {
715 pdata->cir_pwr_ctl(1);
718 //switch to remote control, mcr, ec_en=1,rc_mode=1
719 smc0_write(REG_MCR_ADDR, smc0_read(REG_MCR_ADDR)|(3<<10));
720 //set irda pwdownpin = 0
721 smc0_write(REG_TRCR_ADDR, smc0_read(REG_TRCR_ADDR)&0xffbf);
722 BU92747_DBG("irda power down pin = %d\n", gpio_get_value(RK29_PIN5_PA7));
725 bu92747_cir_init_device(client, bu92747);
727 BU92747_DBG("line %d: exit %s\n", __LINE__, __FUNCTION__);
732 static int bu92747_release(struct inode *inode, struct file *file)
734 struct i2c_client *client = container_of(bu92747guw_device.parent, struct i2c_client, dev);
735 struct bu92747_data_info *bu92747 = (struct bu92747_data_info *)i2c_get_clientdata(client);
736 struct bu92747guw_platform_data *pdata = bu92747->platdata;
738 BU92747_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);
741 if (pdata && pdata->cir_pwr_ctl) {
742 pdata->cir_pwr_ctl(0);
745 // bu92747->state = BU92747_CLOSE;
747 BU92747_DBG("line %d: exit %s\n", __LINE__, __FUNCTION__);
752 static struct file_operations bu92747_fops = {
753 .owner = THIS_MODULE,
754 .open = bu92747_open,
755 .release = bu92747_release,
756 .ioctl = bu92747_ioctl,
759 static struct miscdevice bu92747guw_device = {
760 .minor = MISC_DYNAMIC_MINOR,
762 .fops = &bu92747_fops,
765 static int __devinit bu92747_cir_probe(struct i2c_client *client, const struct i2c_device_id *id)
767 struct bu92747_data_info *bu92747;
768 struct bu92747guw_platform_data *pdata;
771 BU92747_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);
773 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
776 bu92747 = kzalloc(sizeof(struct bu92747_data_info), GFP_KERNEL);
778 printk("line %d: bu92747 alloc data failed.\n", __LINE__);
783 pdata = client->dev.platform_data;
784 if (pdata && pdata->iomux_init) {
788 bu92747->platdata = pdata;
789 bu92747->client = client;
790 i2c_set_clientdata(client, bu92747);
791 bu92747->state = BU92747_CLOSE;
794 bu92747guw_device.parent = &client->dev;
795 err = misc_register(&bu92747guw_device);
797 printk("line %d: bu92747 misc_register failed.\n", __LINE__);
802 if (pdata && gpio_is_valid(pdata->intr_pin)) {
803 printk("-------request irq\n");
804 err = gpio_request(pdata->intr_pin, "rk29 cir irq");
806 printk("line %d: bu92747 request gpio failed.\n", __LINE__);
809 gpio_direction_input(pdata->intr_pin);
810 gpio_request(RK29_PIN5_PA7, NULL);
812 printk("line %d: bu92747 request gpio failed.\n", __LINE__);
814 gpio_direction_input(RK29_PIN5_PA7);
815 bu92747->irq = gpio_to_irq(pdata->intr_pin);
816 err = request_irq(bu92747->irq, bu92747_cir_irq, IRQF_TRIGGER_FALLING, client->dev.driver->name, bu92747);
818 BU92747_DBG("line %d: bu92747 request gpio failed.\n", __LINE__);
821 //disable_irq(bu92747->irq);
824 //INIT_DELAYED_WORK(&bu92747->dwork, bu92747_dwork_handler);
825 INIT_DELAYED_WORK(&bu92747->dwork, bu92747_dwork_handler);
829 //bu92747_start(client);
831 //bu92747_send_data_test(client);
832 //BU92747_DBG("line %d: test %s\n", __LINE__, __FUNCTION__);
837 BU92747_DBG("line %d: exit %s\n", __LINE__, __FUNCTION__);
841 gpio_free(pdata->intr_pin);
843 misc_deregister(&bu92747guw_device);
845 if (pdata && pdata->iomux_deinit)
846 pdata->iomux_deinit();
852 static int __devexit bu92747_cir_remove(struct i2c_client *client)
855 struct bu92747_data_info *bu92747 = i2c_get_clientdata(client);
856 struct bu92747guw_platform_data *pdata = bu92747->platdata;
858 printk(" cir_remove \n");
860 free_irq(bu92747->irq, bu92747);
861 gpio_free(pdata->intr_pin);
862 misc_deregister(&bu92747guw_device);
863 if (pdata && pdata->iomux_deinit)
864 pdata->iomux_deinit();
869 static const struct i2c_device_id bu92747_cir_id[] = {
870 { "bu92747_cir", 0 },
873 MODULE_DEVICE_TABLE(i2c, bu92747_cir_id);
875 static struct i2c_driver bu92747_cir_driver = {
877 .name = "bu92747_cir",
878 .owner = THIS_MODULE,
880 .probe = bu92747_cir_probe,
881 .remove = __devexit_p(bu92747_cir_remove),
882 .id_table = bu92747_cir_id,
885 static int __init bu92747_cir_init(void)
887 return i2c_add_driver(&bu92747_cir_driver);
890 static void __exit bu92747_cir_exit(void)
892 i2c_del_driver(&bu92747_cir_driver);
895 MODULE_AUTHOR("zyw zyw@rock-chips.com");
896 MODULE_DESCRIPTION("bu92747 cir driver");
897 MODULE_LICENSE("GPL");
899 module_init(bu92747_cir_init);
900 module_exit(bu92747_cir_exit);