tiny6410 添加LM8333驱动

Lm8333 为IIC键盘设备

1 在板级文件中添加lm8333注册信息

/linux/arch/arm/mach-mini64xx/mach-6410.c中添加

static struct i2c_board_info i2c_devs0[] __initdata = {

 { I2C_BOARD_INFO("lm8333", 0x50),   //lm8333为设备名，0x50为设备的地址
  .platform_data = &lm8333_pdata, 
    },

 

i2c_register_board_info(0, i2c_devs0, ARRAY_SIZE(i2c_devs0));
  /* 0表示该I2C设备挂在I2C-0上 ，注册I2C adapt时相应的id = 0,这个0 与 （lm8333.c中的）id_table中的0对应 */

 

#include <linux/module.h>
#include <linux/irq.h>
#include <linux/i2c.h>
#include <linux/interrupt.h>
#include <linux/input/matrix_keypad.h>
#include <linux/input/lm8333.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

struct lm8333 {
	struct i2c_client *client;
	struct input_dev *input;
	unsigned short keycodes[LM8333_NUM_ROWS << LM8333_ROW_SHIFT];
};

/* 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);

static void lm8333_key_handler(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;

		input_event(lm8333->input, EV_MSC, MSC_SCAN, code);
		input_report_key(lm8333->input, lm8333->keycodes[code], pressed);
	}

	input_sync(lm8333->input);
}

static irqreturn_t lm8333_irq_thread(int irq, void *data)
{
	struct lm8333 *lm8333 = data;
	u8 status = lm8333_read8(lm8333, LM8333_READ_INT);
	if (!status)
		return IRQ_NONE;

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

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

			lm8333_read_block(lm8333, LM8333_FIFO_READ,
					LM8333_FIFO_TRANSFER_SIZE, dummy);
		}
		dev_err(&lm8333->client->dev, "Got error %02x\n", err);
	}

	if (status & LM8333_KEYPAD_IRQ)
		lm8333_key_handler(lm8333);

	return IRQ_HANDLED;
}

static int __devinit lm8333_probe(struct i2c_client *client,
			  const struct i2c_device_id *id){
	printk("\n\npreparing to register lm8333\n\n");
	//struct lm8333_platform_data *pdata = client->dev.platform_data; 
	struct lm8333_platform_data *pdata = client->dev.platform_data; /*add by zl*/
	printk("\n\n%d\n\n",pdata->debounce_time);
	printk("\n\nv1\n\n");
	struct lm8333 *lm8333;
	struct input_dev *input;
	
	int err, active_time;

	if (!pdata)
		{
			printk("\n\n1\n\n");
			return -EINVAL;
		}
	printk("\n\nv2\n\n");
	active_time = pdata->active_time ?: 500;
	if (active_time / 3 <= pdata->debounce_time / 3) 
	{
		dev_err(&client->dev, "Active time not big enough!\n");
		printk("\n\n2\n\n");
		return -EINVAL;
	}
	printk("\n\nv3\n\n");
	lm8333 = devm_kzalloc(&client->dev, sizeof(*lm8333), GFP_KERNEL);
	printk("\n\nv4\n\n");
	input = input_allocate_device();
	printk("\n\nv5\n\n");
	if (!lm8333 || !input)
		{
			printk("\n\n3\n\n");
			return -ENOMEM;
		}
	printk("\n\nv6\n\n");
	input->name = client->name;
	input->dev.parent = &client->dev;
	input->id.bustype = BUS_I2C;
	printk("\n\nv7\n\n");
	lm8333->client = client;
	lm8333->input = input;
	printk("\n\nv8\n\n");
	i2c_set_clientdata(client, lm8333);
	printk("\nv9\n");
	input->keycode = lm8333->keycodes;
	input->keycodesize = sizeof(lm8333->keycodes[0]);
	input->keycodemax = ARRAY_SIZE(lm8333->keycodes);
	input->evbit[0] = BIT_MASK(EV_KEY);
	input_set_capability(input, EV_MSC, MSC_SCAN);
	printk("\nv10\n");
	matrix_keypad_build_keymap(pdata->matrix_data, LM8333_ROW_SHIFT,
			input->keycode, input->keybit);
	printk("\nv11\n");
	if (pdata->debounce_time) {
		printk("\nv12\n");
		err = lm8333_write8(lm8333, LM8333_DEBOUNCE, pdata->debounce_time / 3);
		printk("\nv13\n");
		if (err)
			{
			printk("\n\n4\n\n");
			dev_warn(&client->dev, "Unable to set debounce time\n");
			}
		printk("\nv14\n");
	}
	printk("\nv15\n");
	if (pdata->active_time) 
	{
		printk("\nv16\n");
		err = lm8333_write8(lm8333, LM8333_ACTIVE, pdata->active_time / 3);
		printk("\nv17\n");
		if (err)
			{
			printk("\n\n5\n\n");
			dev_warn(&client->dev, "Unable to set active time\n");
			}
	}
	printk("\n\n6\n\n");
	/*err = devm_request_threaded_irq(&client->dev, client->irq, NULL,lm8333_irq_thread,
			IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "lm8333", lm8333);*/
			err = devm_request_threaded_irq(&client->dev, 101, NULL,lm8333_irq_thread,
			IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "lm8333", lm8333);
	if (err)
		{
			printk("\n\n5\n\n");
			goto free_input;
		}
    printk("\n\n&&&&&&&&&&&&&&&&&\nrequire IRQ successful\n \n\n");
	err = input_register_device(input);
	if (err)
		{
		printk("\n\n7\n\n");
		goto free_input;
		}
	printk("\n\nregister lm8333 successful \n\n");
	return 0;

 free_input:
	input_free_device(input);
	printk("\n\nregister lm8333 failed !\n\n");
	return err;
}

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

	input_unregister_device(lm8333->input);
	input_free_device(lm8333->input);
	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,
};
//module_i2c_driver(lm8333_driver);

static int __init lm8333_init(void)
{
	printk("\n\n???????????????????????????\n???????????????????????????\n???????????????\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");

注：红色的比较重要