lm8333添加键盘背光代码

#include <linux/module.h>
#include <linux/irq.h>
#include <linux/i2c.h>
#include <linux/sched.h>
#include <linux/kthread.h>
#include <linux/interrupt.h>
#include <linux/input/matrix_keypad.h>
#include <linux/input/lm8333.h>
#include <linux/delay.h> 
#include <linux/input.h>

#define LM8333_FIFO_READ		0x20
#define LM8333_DEBOUNCE			0x22
#define LM8333_READ_INT			0xD0
#define LM8333_ACTIVE			0xE4
#define LM8333_READ_ERROR		0xF0

#define LM8333_KEYPAD_IRQ		(1 << 0)
#define LM8333_ERROR_IRQ		(1 << 3)

#define LM8333_ERROR_KEYOVR		0x04
#define LM8333_ERROR_FIFOOVR		0x40

#define LM8333_FIFO_TRANSFER_SIZE	16

#define LM8333_ROW_SHIFT	4
#define LM8333_NUM_ROWS		8

static struct task_struct *thread = NULL;
static int key_flag = 0;
static struct delayed_work keyboard_work;
static DECLARE_WAIT_QUEUE_HEAD(waiter);

static struct lm8333 *lm8333_data = NULL;

struct lm8333 {
	struct i2c_client *client;
	struct input_dev *input;
	unsigned int keycodes[15];
};

/* The accessors try twice because the first access may be needed for wakeup */

int lm8333_read8(struct lm8333 *lm8333, u8 cmd)
{
	int repeated = 0, ret;

	do {
		ret = i2c_smbus_read_byte_data(lm8333->client, cmd);
	} while (ret < 0 && !repeated++);
	return ret;
}
EXPORT_SYMBOL_GPL(lm8333_read8);/*导出lm8333_read8（）给有GPL认证的模块使用*/

int lm8333_write8(struct lm8333 *lm8333, u8 cmd, u8 val)
{
	int repeated = 0, ret;

	do {
		ret = i2c_smbus_write_byte_data(lm8333->client, cmd, val);
	} while (ret < 0 && !repeated++);

	return ret;
}
EXPORT_SYMBOL_GPL(lm8333_write8);

int lm8333_read_block(struct lm8333 *lm8333, u8 cmd, u8 len, u8 *buf)
{
	int repeated = 0, ret;

	do {
		ret = i2c_smbus_read_i2c_block_data(lm8333->client, cmd, len, buf);
	} while (ret < 0 && !repeated++);

	return ret;
}
EXPORT_SYMBOL_GPL(lm8333_read_block);

/*******************************************************************************
*   Function     : keyboard_backlight_delaywork_func
*   Input         : no
*   Output       : no
*   Return       : no
*   Description : lm8333 backlight timeout turn off the backlight
*   Author       :  yuqianjiang
*
*******************************************************************************/
static void keyboard_backlight_delaywork_func(struct work_struct *work)
{ 
	keyboard_backlight_off(lm8333_data);//<span style="font-family: Arial, Helvetica, sans-serif;">KEYBOARD_BCAKLIGHT_DELAY 的延时时间到后还没有按键事件发生，执行关闭动作</span>
	keyboard_thread_timeout = 0;  //并将键盘超时标志设置为0，接受下一次按键到来
	K_DBG("keyboard_backlight_delaywork_func.\n");
}

/*******************************************************************************
*   Function     : keyboard_backlight_delaywork_init
*   Input         : no
*   Output       : no
*   Return       : no
*   Description : lm8333 backlight delay work initialize function
*   Author       :  yuqianjiang
*
*******************************************************************************/
static void keyboard_backlight_delaywork_init(void)\
{ 
	INIT_DELAYED_WORK(&keyboard_backlight_work, keyboard_backlight_delaywork_func); //为键盘背光控制创建延时队列
       schedule_delayed_work(&keyboard_backlight_work, KEYBOARD_BCAKLIGHT_DELAY);
}

/*******************************************************************************
*   Function     : lm8333_early_suspend
*   Input         : h
*   Output       : no
*   Return       : no
*   Description : lm8333 resume suspend
*   Author       :  yuqianjiang
*
*******************************************************************************/
static void lm8333_early_suspend(struct early_suspend *h)
{
	keyboard_backlight_off(lm8333_data);
	cancel_delayed_work_sync(&keyboard_backlight_work);
	cancel_delayed_work_sync(&keyboard_work);
}

/*******************************************************************************
*   Function     : lm8333_late_resume
*   Input         : h
*   Output       : no
*   Return       : no
*   Description : lm8333 resume function
*   Author       :  yuqianjiang
*
*******************************************************************************/
static void lm8333_late_resume(struct early_suspend *h)
{ 
	keyboard_backlight_on(lm8333_data);
 	 schedule_delayed_work(&keyboard_backlight_work, KEYBOARD_BCAKLIGHT_DELAY);
	 schedule_delayed_work(&keyboard_work, KEYBOARD_RESET_DELAY);
}

/*******************************************************************************
*   Function     : lm8333_keys_report
*   Input         : no
*   Output       : no
*   Return       : no
*   Description : read lm8333 FIFO and report keys events to input system
*   Author       :  yuqianjiang
*
*******************************************************************************/
static void lm8333_keys_report(struct lm8333 *lm8333)
{
	u8 keys[LM8333_FIFO_TRANSFER_SIZE];//LM8333_FIFO_TRANSFER_SIZE=16
	u8 code, pressed;
	int i, ret;

	ret = lm8333_read_block(lm8333, LM8333_FIFO_READ, LM8333_FIFO_TRANSFER_SIZE,keys);
	if (ret != LM8333_FIFO_TRANSFER_SIZE) {
		dev_err(&lm8333->client->dev, "Error %d while reading FIFO\n", ret);
		return;
	}
	for (i = 0; keys[i] && i < LM8333_FIFO_TRANSFER_SIZE ; i++) {
		pressed = !!(keys[i] & 0x80);
		code = keys[i] & 0x7f;
		K_DBG("success to received key[%d] : code = %d\n", i, code);
		//input_event(lm8333->input, EV_MSC, MSC_SCAN, code);
        
        switch(code)
        {
            case 0x21:
                input_report_key(lm8333->input, 2, pressed);break; //1
            case 0x11:
                input_report_key(lm8333->input, 3, pressed);break; //2
            case 0x01:
                input_report_key(lm8333->input, 4, pressed);break; //3
            case 0x22:
                input_report_key(lm8333->input, 5, pressed);break; //4
            case 0x12:
                input_report_key(lm8333->input, 6, pressed);break; //5
            case 0x02:
                input_report_key(lm8333->input, 7, pressed);break; //6
            case 0x26:
                input_report_key(lm8333->input, 8, pressed);break; //7
            case 0x16:
                input_report_key(lm8333->input, 9, pressed);break; //8
            case 0x06:
                input_report_key(lm8333->input, 10, pressed);break; //9
            case 0x15:
                input_report_key(lm8333->input, 11, pressed);break; //0
            case 0x25:
                input_report_key(lm8333->input, 52, pressed);break; //.
            case 0x05:
                input_report_key(lm8333->input, 42, pressed);break; //shift
            case 0x23:
                input_report_key(lm8333->input, 116, pressed);break; //enter
            case 0x14:
                input_report_key(lm8333->input, 105, pressed);break; //left
            case 0x04:
                input_report_key(lm8333->input, 14, pressed);break; //del default: 
            break; 
        }  
		
	}
	input_sync(lm8333->input);
}

/*******************************************************************************
*   Function     : keys_event_handler
*   Input         : no
*   Output       : no
*   Return       : no
*   Description : read keys interrupter and clear interrupter 
*                      Judgment error events and to deal with errors
*   Author       :  yuqianjiang
*
*******************************************************************************/
static void keys_event_handler(void)
{
    volatile u8 status;
    volatile u8 err;
    status = lm8333_read8(lm8333_data, LM8333_READ_INT);
    if (!status)
        return ;

	if (status & LM8333_ERROR_IRQ) 
	{
		err = lm8333_read8(lm8333_data, LM8333_READ_ERROR);

		if (err & (LM8333_ERROR_KEYOVR | LM8333_ERROR_FIFOOVR))
		{
			u8 dummy[LM8333_FIFO_TRANSFER_SIZE];

			lm8333_read_block(lm8333_data, LM8333_FIFO_READ,
					LM8333_FIFO_TRANSFER_SIZE, dummy);
		}
		dev_err(&lm8333_data->client->dev, "Got error %02x\n", err);
		return;
	}
	if (status & LM8333_KEYPAD_IRQ)
	{
		lm8333_keys_report(lm8333_data);
	}

}


/*******************************************************************************
*   Function     : keys_event_handler_kthread
*   Input         : unused
*   Output       : no
*   Return       : no
*   Description : keys event handler thread main function
*   Author       :  yuqianjiang
*
*******************************************************************************/
static int keys_event_handler_kthread(void *unused)
{
    struct sched_param param = { .sched_priority = 1};
    sched_setscheduler(current, SCHED_RR, ¶m); 

    do
    {
        set_current_state(TASK_INTERRUPTIBLE); 
        wait_event_interruptible(waiter, key_flag != 0); //等待按键时间
        key_flag = 0;
        set_current_state(TASK_RUNNING);

	if (keyboard_thread_timeout == 0) { //键盘背光是否关闭
		keyboard_backlight_on(lm8333_data); //键盘背光是关闭状态，则开启背光灯
		schedule_delayed_work(&keyboard_backlight_work, KEYBOARD_BCAKLIGHT_DELAY); //启动背光点亮延时队列
		keyboard_thread_timeout = 1; //同时将背光延时，开启标志设置为1
    	}
	
        keys_event_handler();

    } while (!kthread_should_stop());

    return 0;
}


/*******************************************************************************
*   Function     : keyboard_delay_func
*   Input         : work
*   Output       : no
*   Return       : no
*   Description : Clear interrupt flag, prevent the FIFO overflow
*   Author       :  yuqianjiang
*
*******************************************************************************/
static void keyboard_delay_func(struct work_struct *work)
{
	u8 ret;
     ret = lm8333_read8(lm8333_data, LM8333_READ_INT);
     K_DBG("keyboard_delay_func ret= %x .\n", ret);
}

static irqreturn_t lm8333_irq_thread(int irq, void *data)
{
    key_flag = 1;
    schedule_delayed_work(&keyboard_work, KEYBOARD_RESET_DELAY);
    wake_up_interruptible(&waiter);

    return IRQ_HANDLED;
}

/*******************************************************************************
*   Function     : set_key_input_bit
*   Input         : input
*   Output       : no
*   Return       : no
*   Description : set input system keybit
*   Author       :  yuqianjiang
*
*******************************************************************************/
static void set_key_input_bit(struct input_dev *input)
{
	set_bit(1, input->keybit);
	set_bit(2, input->keybit);
	set_bit(3, input->keybit);
	set_bit(4, input->keybit);
	set_bit(5, input->keybit);
	set_bit(6, input->keybit);
	set_bit(7, input->keybit);
	set_bit(8, input->keybit);
	set_bit(9, input->keybit);
	set_bit(10, input->keybit);
	set_bit(11, input->keybit);//0
	set_bit(14, input->keybit);
	set_bit(105, input->keybit);
	set_bit(106, input->keybit);
	set_bit(116, input->keybit);
	set_bit(56, input->keybit);
	set_bit(42, input->keybit);
	set_bit(52, input->keybit);
	
	
	set_bit(16, input->keybit);
	set_bit(17, input->keybit);
	set_bit(18, input->keybit);
	set_bit(19, input->keybit);
	set_bit(20, input->keybit);
	set_bit(21, input->keybit);
	set_bit(22, input->keybit);
	set_bit(23, input->keybit);
	set_bit(24, input->keybit);
	set_bit(25, input->keybit);
	set_bit(26, input->keybit);
	set_bit(27, input->keybit);
	set_bit(30, input->keybit);
	set_bit(31, input->keybit);
	set_bit(32, input->keybit);
	
	set_bit(33, input->keybit);
	set_bit(36, input->keybit);
	set_bit(35, input->keybit);
	
	set_bit(37, input->keybit);
	set_bit(38, input->keybit);
	set_bit(44, input->keybit);
	set_bit(45, input->keybit);
	set_bit(46, input->keybit);
	set_bit(47, input->keybit);
	set_bit(48, input->keybit);
	set_bit(28, input->keybit);
	input->evbit[0] = BIT_MASK(EV_KEY);
}

static int __devinit lm8333_probe(struct i2c_client *client,
			  const struct i2c_device_id *id){
			 
	struct lm8333_platform_data *pdata = client->dev.platform_data; 
	
	struct lm8333 *lm8333;
	struct input_dev *input;
	int err, active_time;

	K_DBG("debounce_time: %d\n\n",pdata->debounce_time);
	if (!pdata)
    {
        return -EINVAL;
    }

	active_time = pdata->active_time ?: 500;
	if (active_time / 3 <= pdata->debounce_time / 3) 
	{
		dev_err(&client->dev, "Active time not big enough!\n");
		return -EINVAL;
	}
	lm8333 = devm_kzalloc(&client->dev, sizeof(*lm8333), GFP_KERNEL);
	input = input_allocate_device();
	if (!lm8333 || !input)
    {
        err = -ENOMEM;
        goto devm_kfree;
    }

	input->name = client->name;
	input->dev.parent = &client->dev;
	input->id.bustype = BUS_I2C;
	lm8333->client = client;
	lm8333->input = input;

	lm8333_data = lm8333;
	K_DBG("keyboard_backlight_hrtimer_func %p\n", lm8333_data);

	i2c_set_clientdata(client, lm8333);

	set_key_input_bit(input);
	//input_set_capability(input, EV_MSC, MSC_SCAN);
    
	if (pdata->debounce_time)
    {
		err = 0;

		err = lm8333_write8(lm8333, LM8333_DEBOUNCE, pdata->debounce_time / 3);	
        if (err)
        {
            dev_warn(&client->dev, "Unable to set debounce time\n");
        }
		
	}
	
	if (pdata->active_time) 
	{
		err = lm8333_write8(lm8333, LM8333_ACTIVE, pdata->active_time / 3);		
		if (err)
        {
            dev_warn(&client->dev, "Unable to set active time\n");
        }	
	}

	err = devm_request_threaded_irq(&client->dev, 101, NULL,lm8333_irq_thread,
			IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "lm8333", lm8333);
	if (err)
    {
        goto free_input;
    }
    K_DBG("require IRQ successful \n\n");

    INIT_DELAYED_WORK(&keyboard_work, keyboard_delay_func);
    schedule_delayed_work(&keyboard_work, 100);

	//configure GEN_IO_1 to output
	keyboard_backlight_init(lm8333); //初始化键盘芯片IO
	keyboard_backlight_delaywork_init(); //初始化键盘背光延时队列
 
    thread = kthread_run(keys_event_handler_kthread, 0, "lm8333"); //创建线程来轮询按键情况，根据不通情况去执行开关键盘背光
    if (IS_ERR(thread))
    {
        err = PTR_ERR(thread);
        K_DBG("lm8333 failed to create kernel thread: %d\n", err);
        goto free_irq;
    }

	
	err = input_register_device(input);
	if (err)
    {
        goto free_irq;
    }

	lm8333_early.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
	lm8333_early.suspend = lm8333_early_suspend;
	lm8333_early.resume = lm8333_late_resume;
	register_early_suspend(&lm8333_early);

	K_DBG("\n\nregister lm8333 successful \n\n");

	return 0;

devm_kfree:
    devm_kfree(&client->dev, lm8333);
 free_input:
	input_free_device(input);
	printk("\n\nregister lm8333 failed !\n\n");
free_irq:
    devm_free_irq(&client->dev, 101, lm8333);
	return err;
}

static int __devexit lm8333_remove(struct i2c_client *client)
{
	struct lm8333 *lm8333 = i2c_get_clientdata(client);

    devm_free_irq(&client->dev, 101, lm8333);
	input_unregister_device(lm8333->input);
	input_free_device(lm8333->input);
    devm_kfree(&client->dev, lm8333);

	return 0;
}

static const struct i2c_device_id lm8333_id[] = {
	{ "lm8333", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, lm8333_id);

static struct i2c_driver lm8333_driver = {

	.driver = {
		.name		= "lm8333",
		.owner		= THIS_MODULE,
	},
	.probe		= lm8333_probe,
	.remove		= __devexit_p(lm8333_remove),
	.id_table	= lm8333_id,
};

static int __init lm8333_init(void)
{
	printk("\ninit lm8333\n\n");
	return i2c_add_driver(&lm8333_driver);
}

module_init(lm8333_init);

static void __exit lm8333_exit(void)
{
	i2c_del_driver(&lm8333_driver);
}
module_exit(lm8333_exit);

MODULE_AUTHOR("Wolfram Sang <w.s...@pengutronix.de>");
MODULE_DESCRIPTION("LM8333 keyboard driver");
MODULE_LICENSE("GPL v2");