矩阵键盘驱动编写 - 嵌入式大作
1. 主动中断回调（失败）
https://blog.csdn.net/weixin_49551849/article/details/113190428
//liyuan-zlg7290.c
现在的问题是 probe函数无法被调用，
当我们调用i2c_add_driver时会去设备
链中寻找与id_tables中相同名字的i2c_client设备，
其中i2c_client设备的初始化应该于板级加载时就初始化，因此需要
https://blog.csdn.net/tanxjian/article/details/7479444
现在问题出在request_irq时会出错，可使用dmesg处理
input_dev是基于上报事件的，所以无需专门创建一个设备给他
可查看 cat /proc/bus/input/devices
struct i2c_board_info __initdata xxx_ls_cm3212 =
{
I2C_BOARD_INFO(“cm3212”,0x90),
// I2C_BOARD_INFO是个简单的宏：.type="cm3212",.addr=0x90.
};
然后，在板级系统初始化的时候注册：
i2c_register_board_info(int busnum,struct i2c_board_info const *info, unsigned len)
其中busnum表示你对应系统的那个 i2c 控制（adapter），len表示你注册的info的个数。
i2c设备 -》 对应的驱动会寻找该设备，因此现在的问题时在板级系统起来前注册一个设备；
思路：一开始的zImage包含 zlg7290驱动，然后手动卸载该驱动 rmmod zlg7290， 然后手动insmod 自己的zlg7290的驱动；
该思路无法实现，因为加进内核里的驱动不能简单地从用户态移除；
发现无法找到 s5p_register_gpio_interrupt, 找了下，内核里面有该方法，
解决方案是将自己的驱动替换系统的相应内核驱动，可以正常运行；
由于之前对 make menuconfg的一些奇怪配置，因此现在重新解压linux-3.0.15压缩包，环境清0，但初次编译花了较久时间，因此可考虑先复制一份
nohup /root/runoob.sh > runoob.log 2>&1 &
//地址是一样的
#ifdef CONFIG_FS4412_ZLG7290
{
I2C_BOARD_INFO(“zlg7290”, (0x70 >> 1)),
.irq = EXYNOS4_GPK2(2),
},
#endif
#ifdef CONFIG_FS4412_SEGDIS
{
I2C_BOARD_INFO(“FS4412_segdis”, 0x70 >> 1),
},
#endif
arm-none-linux-gnueabi-gcc -static -o hello.cgi hello.c
nohup /root/runoob.sh > runoob.log 2>&1 &
| 1c | 14 | c | 1 |
| 1b | 13 | b | 2 |
| 1a | 12 | a | 3 |
| 19 | 11 | 9 | 4 |
#include
ifeq ($(KERNELRELEASE), )
KERNELDIR ?=/home/linux/liyuan/kernel/linux-3.0.15
PWD := $(shell pwd)
modules :
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
modules_install :
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install
clean :
rm -f *.o *.mod* *.order *.symvers
.PHONY : modules modules_install clean
else
# obj-m +=FS4412_LED_drv.o
# obj-m +=FS4412_segdis_drv_2.o
obj-m +=liyuan-zlg7290.o
endif
//测试上报的事件
#include 2. 定时查询(成功)
上述实现由于是直接修改内核中驱动中代码，与题意不符合，题目是要求可以通过insmod xxx实现的，因此书写了下面这个版本，通过定时查询按键缓冲中是否有值从而读取按键的值；
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/gpio.h>
#include <linux/platform_device.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/poll.h>
#include <linux/sched.h>
#include <plat/gpio-cfg.h>
static volatile int key_press =0;
#define ADDR_ZLG7290 0x70 /* ZLG7290 address 0x70*/
#define ZLG7290_NAME "zlg7290"
/* 为了方便起见，将需要操作的设备封装一个结构体 */
struct zlg7290
{
struct i2c_client *client;/* 由于该设备通过i2c总线通信，所以需要将它定义为一个i2c从设备 */
struct input_dev *key;/* 定义input device */
// struct cdev cdev;/* 定义字符设备结构体 */
struct device *class_dev;
struct delayed_work work;
//uint32_t irq;
}*zlg7290;
struct device *dev;
unsigned int key_value[65]={
0,
1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32,
33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48,
49, 50, 51, 52, 53, 54, 55, 56,
57, 58, 59, 60, 61, 62, 63, 64,
};/* 定义linux内核标准键值 */
static void zlg7290_irq_work(struct work_struct *work) {
struct zlg7290 *ctr_zlg7290 = container_of(work,struct zlg7290,work);
size_t retlen = 0;
char *kbuf;
static char bfbuf[10];
struct i2c_client *client = zlg7290->client;
int ret, i, key;
kbuf = kmalloc(9, GFP_KERNEL);
kbuf[0] = 1;
struct i2c_msg msgr[] = {
{client->addr, 0, 1, kbuf},
{client->addr, I2C_M_RD, 2, kbuf}
};
struct i2c_msg msgw[] = {
{client->addr, 0, 9, kbuf},
};
ret = i2c_transfer(client->adapter, msgr, 2);
if (ret < 0) { printk("error!->i2c_transfer ret=%d; addr = %x;\n", ret, client->addr); }
key = kbuf[0];
if(key==0){
goto out;
}
printk("key1 = %x;key2 = %x;, repeat:%x \n", key,kbuf[1]);
kbuf[0] = 0x10;
for (i = 1; i < 8; i++) {
kbuf[i + 1] = kbuf[i];
}
if (key == 0x1c) { kbuf[1] = 0x0c; }//1
if (key == 0x1b) { kbuf[1] = 0xb6; }//5
if (key == 0x1a) { kbuf[1] = 0xf6; }//9
if (key == 0x19) { kbuf[1] = 0x7a; }//d
if (key == 0x14) { kbuf[1] = 0xda; }//2
if (key == 0x13) { kbuf[1] = 0xbe; }//6
if (key == 0x12) { kbuf[1] = 0xef; }//A
if (key == 0x11) { kbuf[1] = 0x9f; }//E
if (key == 0xc) { kbuf[1] = 0xf2; }//3
if (key == 0xb) { kbuf[1] = 0xe0; }//7
if (key == 0xa) { kbuf[1] = 0x3e; }//b
if (key == 0x9) { kbuf[1] = 0x8e; }//f
if (key == 0x4) { kbuf[1] = 0x66; }//4
if (key == 0x3) { kbuf[1] = 0xfe; }//8
if (key == 0x2) { kbuf[1] = 0x9c; }//c
if (key == 0x1) { kbuf[1] = 0xfc; }//0
for (i = 1; i < 8; i++) {
kbuf[i + 1] = bfbuf[i];
bfbuf[i] = kbuf[i];
}
ret = i2c_transfer(client->adapter, msgw, 1);
if (ret < 0) { printk("ret= %d;, addr=%x; \n", ret, client->addr); }
kfree(kbuf);
printk("liyuan->input report key!\n");
input_report_key(zlg7290->key, key_value[key], 1);
input_report_key(zlg7290->key, key_value[key], 0);
input_sync(zlg7290->key);
out:
schedule_delayed_work(&zlg7290->work,HZ/5);
}
/*设备与驱动匹配成功后会调用该函数,I2c_client 代表一个挂在i2c总线上的i2c从设备包含该设备所需的数据,I2c_device*/
static int zlg7290_probe(struct i2c_client *client, const struct i2c_device_id *id){
struct input_dev *key_dev;
int ret = 0 , i = 0 , err = -EINVAL;
for(i=0;i<=65;i++)
key_value[i]=i;
if (!(zlg7290 = kzalloc(sizeof(struct zlg7290), GFP_KERNEL)))/* 为zlg7290设备分配地址空间 */
{
printk("zlg7290 kzalloc fail!");
return -ENOMEM;
}
zlg7290->key = input_allocate_device();/* 为input设备分配地址空间 */
if (zlg7290->key == NULL)
{
printk("input device allocate fail!");
kfree(zlg7290);
return -ENOMEM;
}
key_dev = zlg7290->key;/* 将zlg7290设备的相关属性配置到input设备中 */
key_dev->name = "zlg7290";
key_dev->id.bustype = BUS_HOST;
key_dev->id.vendor = 0x0001;
key_dev->id.product = 0x0001;
key_dev->id.version = 0x0001;
key_dev->evbit[0] = BIT_MASK(EV_KEY);
for(i=1;i<=64;i++)
key_dev->keybit[BIT_WORD(key_value[i])] |= BIT_MASK(key_value[i]);
ret = input_register_device(key_dev);/* 注册input设备 */
if (ret < 0)
{
printk("Failed to register input device\n");
goto err1;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) /* 检测i2c控制器是否支持我们的需求，如果返回1则支持，0则不支持 */
{
err = -ENODEV;
return err;
}
zlg7290->client = client;
i2c_set_clientdata(client, zlg7290);/* 将自定义的设备结构dev赋给设备驱动client的私有指针 */
INIT_DELAYED_WORK(&zlg7290->work, zlg7290_irq_work);
schedule_delayed_work(&zlg7290->work, HZ/5);
return 0;
err1:
input_free_device(key_dev);
kfree(zlg7290);
return ret;
}
/* 定义i2c设备信息 */
static const struct i2c_device_id zlg7290_id[] ={
{ZLG7290_NAME, 0 },
{ }
};
MODULE_DEVICE_TABLE(i2c, zlg7290_id);/* 将zlg7290结构输出到用户空间，这样模块加载系统在加载模块时,就知道了什么模块对应什么硬件设备*/
static int __devexit zlg7290_remove(struct i2c_client *client) {
// free_irq(client->irq, NULL);
cancel_delayed_work_sync(&zlg7290->work);
i2c_set_clientdata(client, NULL);
kfree(zlg7290);
return 0;
}
/* 定义i2c设备驱动结构体 */
static struct i2c_driver zlg7290_driver =
{
.probe = zlg7290_probe,
.remove = zlg7290_remove,
.id_table = zlg7290_id,
.driver = {
.name = ZLG7290_NAME,
.owner = THIS_MODULE,
},
};
static int __init zlg7290_init(void)
{
return i2c_add_driver(&zlg7290_driver);
}
static void __exit zlg7290_exit(void)
{
i2c_del_driver(&zlg7290_driver);
}
MODULE_AUTHOR("liyuan");
MODULE_DESCRIPTION("zlg7290 driver");
MODULE_LICENSE("GPL");
module_init(zlg7290_init);
module_exit(zlg7290_exit);