linux下一个iic驱动（按键+点灯）-互斥

一、前提：

硬件部分：

1. rk3399开发板，其中的某一路iic，这个作为总线的主控制器

2. gd32单片机，其中的某一路iic，从设备。主要是按键上报和灯的亮灭控制。（按键大约30个，灯在键的下面，对应有30个左右。）

3. iic主要的功能是两个部分，是主动上报按键值，和接收点灯命令（收到后需要发送应答）。

4. 该路iic总线上还有一个触摸屏的设备。（不在介绍范围，这个说明一下单片机端不能改为主设备，cpu改为从设备的原因）。

5.cpu与单片机之间有一个中断io引脚，用于有按键（或者应答）数据时，提示cpu（rk3399）的作用，低电平有效。

软件部分：

1.linux4.4.194的内核，arm64平台，自编ic驱动程序。

2.单片机也是自己做的iic程序，使用硬件iic，协议自定义，与驱动一致即可。（本文不介绍单片机的程序）。

3.数据帧的格式（前期已经定好，不再修改）：cpu（rk3399，下同）发送指令由5个字节组成，设备（单片机，下同）回复指令由7个字节组成。

cpu主动发送部分：

 设备发送部分：

 

二、iic驱动基本思路和逻辑

1. 发送数据时，首先把数据组合好，调用i2c_master_send，完成发送。（比如点亮熄灭的命令）

i2c_master_send(s_jc_keyboard_info.i2c_client, (char *)&keyboard_send_msg, sizeof(KEYBOARD_I2C_SEND_MSG_S)) != sizeof(KEYBOARD_I2C_SEND_MSG_S)

2.接收数据，单片机发送数据时，是肯定有一个中断触发cpu，所以cpu处理是在中断处理函数中。

   收到中断后，考虑到iic的数据是串行通信，比较费时，所以采用工作队列的方式处理，收到中断，其实就是启动一次工作队列，这时使用了内核自己的队列。

    队列启动后，使用i2c_master_recv接收数据，然后根据协议解析数据，完成相关的操作。

static irqreturn_t s_jc_keyboard_i2c_isr(int irq, void *dev_id)
{if(irq != s_jc_keyboard_info.i2c_client->irq) {return IRQ_NONE;}if(!schedule_work(&jc_keyboard_work)) {pr_err("Error schedule_work!\n");}return IRQ_HANDLED;
}
i2c_master_recv(s_jc_keyboard_info.i2c_client, (char *)&keyboard_recv_msg, sizeof(KEYBOARD_I2C_RECV_MSG_S)) != sizeof(KEYBOARD_I2C_RECV_MSG_S)

三、一个互斥问题。

1. 有闪烁灯的控制，而且是多个灯的闪烁，频率

    这种情况，cpu主动发送数据和设备应答的数据（cpu主动读取数据）比较多，每一次设备应答都会中断，中断比较频繁。

2.同时多次按键，组合键

    这个情况下，中断比较多，cpu主要是读取数据。

3.确实有异常的表现，报出一些数据帧不能解析的错误，偶尔有按键不能正常上报按下和松开的状态。

4.客户在使用的时候，发现多个灯闪的时候，会出现比较大的卡顿现象（后来分析其实是命令丢失，就是第一个点亮或熄灭命令发了很久之后，才开始闪），同时按键也会出现失灵的现象（可能要多次按键才会作用）。

5. 不知道是不是频繁中断的影响，schedule_work偶尔也会报出错误提示，原因未知。

四、解决思路

1. 中断是个问题，cpu发送数据和接收数据的过程中是很有可能被中断打断的，这个打断会不会导致数据帧出现错误。尤其是有数据下发的点灯命令和频繁按键上报的情况。

2.点灯命令的应答和按键上报的中断同时（或者间隔很短的情况下）会如何？

3.加上互斥锁（iic_idel_Mutex），一个发送流程（包括发送和接收应答）走完，才能进行下一步操作。比如点灯，必须把数据发完，同时接收到应答（或者超时）才能发送下一帧数据。

4.第二把互斥锁（iic_Mutex，不知道是否多余），每一次发送和接收都加锁，接收发送函数结束后解锁。

5.加上自定义的一个工作队列，使用自己的工作队列处理中断事件。

五、加上锁后，基本解决这个问题。

详细请参考一下源代码（部分主要源码，h文件省略了）

/** jc_keyboard.c**  Created on: Dec 25, 2021*      Author: dazhi*/#include <linux/module.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/fs.h>
#include <linux/i2c.h>
#include <linux/of_gpio.h>
#include <linux/input.h>
#include <linux/miscdevice.h>
#include <linux/workqueue.h>
#include <linux/semaphore.h>
#include <asm/uaccess.h>
#include <linux/moduleparam.h>#include "jc_keyboard.h"
#include "jc_keyboard_cmd.h"
#include "jc_keyuser.h"#define JC_KEYBOARD_DRIVER_NAME		"jc_keyboard"
#define JC_KEYBOARD_IRQ_GPIO_NAME	"jc_keyboard_irq_gpio"
#define JC_KEYBOARD_IRQ_NAME		"jc_keyboard_irq"
#define JC_KEYBOARD_MISCDEV_MINOR	(20)
#define JC_KEYBOARD_I2C_TIMEOUT		(4000)	//4000 --> 1s  2022-09-06 dazhi修改，客户处调试暂时已通过。#define NO_POLL_MODE   //不主动查询，需要单片机给出中断才行。
#define USE_SELF_WORK_QUEUE //static int jc_keyboard_inited = -1;  //是否加载成功，2023-01-09#ifdef USE_SELF_WORK_QUEUE
//分配工作队列的指针
static struct workqueue_struct *jc_keyboard_wq;
#endifstatic int debug_print = 0;   //默认不打印调试语句static struct mutex iic_Mutex;      //互斥锁
static struct mutex iic_idel_Mutex;      //iic空闲互斥锁
static volatile unsigned long wait_respon_bits = 0; //需要等待什么应答，每一个位对应一种需求module_param(debug_print,int, 0644);   //加载时传递参数typedef struct {int irq_gpio;struct input_dev *input_dev;struct i2c_client *i2c_client;struct semaphore ioctl_sem;
} JC_KEYBOARD_INFO;static char s_i2c_reply_ret = 0;
static struct miscdevice s_jc_keyboard_miscdevice;
static struct work_struct jc_keyboard_work;
static JC_KEYBOARD_INFO s_jc_keyboard_info;//按键转换值的数组，定义在jc_keyuser.h
static const unsigned char s_user_key_value[] = {0,USER_KEY_VALUE_FUNCTION_1,   //0x1USER_KEY_VALUE_FUNCTION_2,   //0x2USER_KEY_VALUE_FUNCTION_3,   //0x3USER_KEY_VALUE_FUNCTION_4,   //0x4USER_KEY_VALUE_FUNCTION_5,   //0x5USER_KEY_VALUE_FUNCTION_6,   //0x6USER_KEY_VALUE_FUNCTION_7,   //0x7USER_KEY_VALUE_FUNCTION_8,   //0x8USER_KEY_VALUE_FUNCTION_9,   //0x9USER_KEY_VALUE_FUNCTION_10,   //0xaUSER_KEY_VALUE_FUNCTION_11,   //0xbUSER_KEY_VALUE_FUNCTION_12,   //0xcUSER_KEY_VALUE_0,    //索引号13  -- 数字0USER_KEY_VALUE_1,    //索引号14  -- 数字1USER_KEY_VALUE_2,    //索引号15  -- 数字2USER_KEY_VALUE_3,    //索引号16  -- 数字3USER_KEY_VALUE_4,    //索引号17  -- 数字4USER_KEY_VALUE_5,    //索引号18  -- 数字5USER_KEY_VALUE_6,    //索引号19  -- 数字6USER_KEY_VALUE_7,    //索引号20  -- 数字7USER_KEY_VALUE_8,    //索引号21  -- 数字8USER_KEY_VALUE_9,    //索引号22  -- 数字9USER_KEY_VALUE_ASTERISK,    //索引号23  -- USER_KEY_VALUE_POUND,    //索引号24  -- USER_KEY_VALUE_TELL,    //索引号25USER_KEY_VALUE_VOLUME_INCREASE,    //索引号26USER_KEY_VALUE_VOLUME_DECREASE,    //索引号27USER_KEY_VALUE_SWITCH,USER_KEY_VALUE_INSIDE,USER_KEY_VALUE_OUTSIDE,USER_KEY_VALUE_UP,    //索引号31USER_KEY_VALUE_DOWN,    //索引号32USER_KEY_VALUE_PTT,    //索引号33USER_KEY_VALUE_LEFT,    //索引号34USER_KEY_VALUE_RIGHT,    //索引号35USER_KEY_VALUE_OK,    //索引号36USER_KEY_VALUE_KEEP,    //索引号37USER_KEY_VALUE_SET,    //索引号38USER_KEY_VALUE_TEST    //索引号39---> 0x27
};//左侧（中括号中的数）是客户自动自定义的键值 比如KC_L1 --> 1
//右侧是s_user_key_value中对应值得索引号，比如数字0，在数组中排13，就是0xd，
static const unsigned char s_user_map_led_value[] = {[1] = 0x01	, //图示1左1	     //KC_L1   1[3] = 0x02	, //图示2左2	     //KC_L2   3[5] = 0x03	, //图示3左3	     //KC_L3   5[7] = 0x04	, //图示4左4	     //KC_L4   7[9] = 0x05	, //图示5左5	     //KC_L5   9[44] = 0x06	, //图示6左6	     //KC_L6   44[2] = 0x07	, //图示7右1	     //KC_R1   2[4] = 0x08	, //图示8右2	     //KC_R2   4[6] = 0x09	, //图示9右3	     //KC_R3   6[8] = 0x0A	, //图示10右4     //KC_R4	8  [10] = 0x0B	, //图示11右5     //KC_R5	10[45] = 0x0C	, //图示12右6	//KC_R6    45[27] = 0x0D	, //0		//KC_NUM0   27[18] = 0x0E	, //1		//KC_NUM1   18[19] = 0x0F	, //2		//KC_NUM2   19	[20] = 0x10	, //3		//KC_NUM3   20	[21] = 0x11	, //4		//KC_NUM4   21	[22] = 0x12	, //5		//KC_NUM5   22	[23] = 0x13	, //6		//KC_NUM6   23	[24] = 0x14	, //7		//KC_NUM7   24	[25] = 0x15	, //8		//KC_NUM8   25	[26] = 0x16	, //9		//KC_NUM9   26	[28] = 0x17	, //*		//KC_DOT   28	[29] = 0x18	, //#		//KC_CLEAR   29	[13] = 0x19	, //电话（拨号）			//KC_TEL   13[35] = 0x1A	, //音量+		//KC_VOLUME_UP	   35[36] = 0x1B	, //音量-		//KC_VOLUME_DOWN	36	[14] = 0x27	, //TEST		//KC_TESKKEY   14   //原0x1c改0x27[11] = 0x1D	, //内通			//KC_INC      11[12] = 0x1E	, //外通			//KC_EXC      12 [30] = 0x1F	, //上			//KC_UP       30[31] = 0x20	, //下			//KC_DOWN     31[17] = 0x21	, //PTT		//KC_PTT        17	[32] = 0x22	, //左			//KC_LEFT   32[33] = 0x23	, //右			//KC_FIGHT  33[34] = 0x24	, //OK			//KC_OK     34[15] = 0x25	, //保持			//KC_HOLD   15[43] = 0x26	, //设置/摘挂机		//KC_RECOV  16改成43 原来[16] = 0x26	,[42] = 0x27	, //测试/复位		//KC_xxx	[37] = 0x28	, //指示灯-红		//LED_RED  37	[38] = 0x29	, //指示灯-绿		//LED_GREEN 38	[39] = 0x2A	, //指示灯-蓝		//KC_BLUE   39	[40] = 0x2B	 //全部键灯			//ALL_KEY_LED  40
};static const struct of_device_id s_jc_keyboard_match_table[] = {{ .compatible = "jc,keyboard", },{},
};static const struct i2c_device_id s_jc_keyboard_i2c_id[] = {{ JC_KEYBOARD_DRIVER_NAME, 0},{}
};static void s_jc_keyboard_work_func_t(struct work_struct *work) {KEYBOARD_I2C_RECV_MSG_S keyboard_recv_msg;unsigned char i = 0;unsigned char cmd_verify_tmp = 0;
//	pr_err("2023debug s_jc_keyboard_work_func_t\n");memset(&keyboard_recv_msg, 0, sizeof(KEYBOARD_I2C_RECV_MSG_S));mutex_lock(&iic_Mutex);  //加锁if(i2c_master_recv(s_jc_keyboard_info.i2c_client, (char *)&keyboard_recv_msg, sizeof(KEYBOARD_I2C_RECV_MSG_S)) != sizeof(KEYBOARD_I2C_RECV_MSG_S)) {pr_err("Error i2c_master_recv, addr = %#x\n", s_jc_keyboard_info.i2c_client->addr);mutex_unlock(&iic_Mutex);  //开锁return;}mutex_unlock(&iic_Mutex);  //开锁if(debug_print)pr_err("i2c_master_recv: h0 = %#x, h1 = %#x type = %#x, key0=%#x, key1=%#x，key2=%#x,verify=%#x\n",keyboard_recv_msg.cmd_header0,keyboard_recv_msg.cmd_header1,keyboard_recv_msg.cmd_type,keyboard_recv_msg.cmd_key0,keyboard_recv_msg.cmd_key1,keyboard_recv_msg.cmd_key2,keyboard_recv_msg.cmd_verify);cmd_verify_tmp = FRAME_VERIFY(keyboard_recv_msg.cmd_header0,keyboard_recv_msg.cmd_header1,keyboard_recv_msg.cmd_type,keyboard_recv_msg.cmd_key0,keyboard_recv_msg.cmd_key1,keyboard_recv_msg.cmd_key2);if(keyboard_recv_msg.cmd_header0 != FRAME_HEADER_0 || keyboard_recv_msg.cmd_header1 != FRAME_HEADER_1) {pr_err("Error recv cmd header: %#x %#x\n", keyboard_recv_msg.cmd_header0, keyboard_recv_msg.cmd_header1);return;}if(keyboard_recv_msg.cmd_verify != cmd_verify_tmp) {if(debug_print)pr_err("Error verify %#x\n", keyboard_recv_msg.cmd_verify);return;}if((keyboard_recv_msg.cmd_type & 0xfc) == FRAME_CMD_TYPE_KEY_LED_FLASH)  //闪烁的指令{s_i2c_reply_ret = keyboard_recv_msg.cmd_key2;clear_bit(KEY_LED_FLASH_RESPONSE_BIT, &wait_respon_bits);   //置高某一位up(&s_jc_keyboard_info.ioctl_sem);return ;		}//	pr_err("2023debug s_jc_keyboard_work_func_t cmd_type = %d,cmd_key2 = %d\n",keyboard_recv_msg.cmd_type,keyboard_recv_msg.cmd_key2);switch(keyboard_recv_msg.cmd_type) {case FRAME_CMD_TYPE_GET_KEY_VALUE_REPLY_PRESS:case FRAME_CMD_TYPE_GET_KEY_VALUE_REPLY_RELEASE:if(s_jc_keyboard_info.input_dev) {//	unsigned char key;unsigned char key_val[3] = {keyboard_recv_msg.cmd_key0,keyboard_recv_msg.cmd_key1,keyboard_recv_msg.cmd_key2};if(debug_print)pr_info("key1 = %d key2 = %d key3 = %d\n",key_val[0],key_val[1],key_val[2]);for(i=0;(i<3);i++)//for(i=0;(i<3) && key_val[i];i++){//key = keyboard_recv_msg.cmd_key0? keyboard_recv_msg.cmd_key0:keyboard_recv_msg.cmd_key2;if(key_val[i] < KEY_VALUE_FUNCTION_1 || key_val[i] > KEY_VALUE_TEST) {continue;// pr_err("Error key %#x out of range!\n", key_val[i]);// break;}input_report_key(s_jc_keyboard_info.input_dev, s_user_key_value[key_val[i]], (keyboard_recv_msg.cmd_type == FRAME_CMD_TYPE_GET_KEY_VALUE_REPLY_PRESS)? 1:0);}input_sync(s_jc_keyboard_info.input_dev);}break;case FRAME_CMD_TYPE_GET_BRIGHTNESS:s_i2c_reply_ret = keyboard_recv_msg.cmd_key2;clear_bit(BRIGHTNESS_RESPONSE_BIT, &wait_respon_bits);   //清零某一位up(&s_jc_keyboard_info.ioctl_sem);break;case FRAME_CMD_TYPE_GET_PANEL_MODEL:s_i2c_reply_ret = keyboard_recv_msg.cmd_key2;clear_bit(PANEL_MODEL_RESPONSE_BIT, &wait_respon_bits);   //清零某一位up(&s_jc_keyboard_info.ioctl_sem);break;case FRAME_CMD_TYPE_GET_PANEL_VER:s_i2c_reply_ret = keyboard_recv_msg.cmd_key2;clear_bit(PANEL_MODEL_RESPONSE_BIT, &wait_respon_bits);   //清零某一位up(&s_jc_keyboard_info.ioctl_sem);break;case FRAME_CMD_TYPE_SET_BRIGHTNESS:s_i2c_reply_ret = keyboard_recv_msg.cmd_key2;clear_bit(PANEL_MODEL_RESPONSE_BIT, &wait_respon_bits);   //清零某一位up(&s_jc_keyboard_info.ioctl_sem);break;case FRAME_CMD_TYPE_RESET:s_i2c_reply_ret = keyboard_recv_msg.cmd_key2;clear_bit(RESET_RESPONSE_BIT, &wait_respon_bits);   //清零某一位up(&s_jc_keyboard_info.ioctl_sem);break;case FRAME_CMD_TYPE_KEY_LED_ON:s_i2c_reply_ret = keyboard_recv_msg.cmd_key2;clear_bit(KEY_LED_ON_RESPONSE_BIT, &wait_respon_bits);   //清零某一位up(&s_jc_keyboard_info.ioctl_sem);break;case FRAME_CMD_TYPE_KEY_LED_OFF:s_i2c_reply_ret = keyboard_recv_msg.cmd_key2;clear_bit(KEY_LED_OFF_RESPONSE_BIT, &wait_respon_bits);   //清零某一位up(&s_jc_keyboard_info.ioctl_sem);break;default:pr_err("Error non-supported cmd %#x\n", keyboard_recv_msg.cmd_type);break;}
}#ifndef NO_POLL_MODE
//读取消息超时的处理
static int s_jc_keyboard_inttimeout_func_t(void) {KEYBOARD_I2C_RECV_MSG_S keyboard_recv_msg;unsigned char cmd_verify_tmp = 0;// if(jc_keyboard_inited != 1)  //驱动没有加载成功！！// 	return -1;
//	pr_err("2023debug s_jc_keyboard_inttimeout_func_t\n");memset(&keyboard_recv_msg, 0, sizeof(KEYBOARD_I2C_RECV_MSG_S));mutex_lock(&iic_Mutex);  //加锁if(i2c_master_recv(s_jc_keyboard_info.i2c_client, (char *)&keyboard_recv_msg, sizeof(KEYBOARD_I2C_RECV_MSG_S)) != sizeof(KEYBOARD_I2C_RECV_MSG_S)) {pr_err("Error i2c_master_recv, addr = %#x\n", s_jc_keyboard_info.i2c_client->addr);mutex_unlock(&iic_Mutex);  //开锁return -1;}mutex_unlock(&iic_Mutex);  //开锁cmd_verify_tmp = FRAME_VERIFY(keyboard_recv_msg.cmd_header0,keyboard_recv_msg.cmd_header1,keyboard_recv_msg.cmd_type,keyboard_recv_msg.cmd_key0,keyboard_recv_msg.cmd_key1,keyboard_recv_msg.cmd_key2);if(keyboard_recv_msg.cmd_header0 != FRAME_HEADER_0 || keyboard_recv_msg.cmd_header1 != FRAME_HEADER_1) {pr_err("Error recv cmd header: %#x %#x\n", keyboard_recv_msg.cmd_header0, keyboard_recv_msg.cmd_header1);return -1;}if(keyboard_recv_msg.cmd_verify != cmd_verify_tmp) {pr_err("Error verify %#x\n", keyboard_recv_msg.cmd_verify);return -1;}switch(keyboard_recv_msg.cmd_type) {case FRAME_CMD_TYPE_GET_KEY_VALUE_REPLY_PRESS:case FRAME_CMD_TYPE_GET_KEY_VALUE_REPLY_RELEASE:if(s_jc_keyboard_info.input_dev) {unsigned char key = keyboard_recv_msg.cmd_key0? keyboard_recv_msg.cmd_key0:keyboard_recv_msg.cmd_key2;if(key < KEY_VALUE_FUNCTION_1 || key > KEY_VALUE_TEST) {pr_err("Error key %#x out of range!\n", key);break;}input_report_key(s_jc_keyboard_info.input_dev, s_user_key_value[key], (keyboard_recv_msg.cmd_type == FRAME_CMD_TYPE_GET_KEY_VALUE_REPLY_PRESS)? 1:0);input_sync(s_jc_keyboard_info.input_dev);}break;case FRAME_CMD_TYPE_GET_BRIGHTNESS:case FRAME_CMD_TYPE_GET_PANEL_MODEL:case FRAME_CMD_TYPE_GET_PANEL_VER:case FRAME_CMD_TYPE_SET_BRIGHTNESS:case FRAME_CMD_TYPE_RESET:case FRAME_CMD_TYPE_KEY_LED_ON:case FRAME_CMD_TYPE_KEY_LED_OFF:s_i2c_reply_ret = keyboard_recv_msg.cmd_key2;//	up(&s_jc_keyboard_info.ioctl_sem);break;default:pr_err("Error non-supported cmd %#x\n", keyboard_recv_msg.cmd_type);return -1;}return 0;
}
#endifstatic irqreturn_t s_jc_keyboard_i2c_isr(int irq, void *dev_id)
{if(irq != s_jc_keyboard_info.i2c_client->irq) {return IRQ_NONE;}if(debug_print)pr_err("enter jc_keyboard_i2c_isr\n");#ifdef USE_SELF_WORK_QUEUE//将自己的工作和自己的工作队列进行管理，然后再登记if(!queue_work(jc_keyboard_wq, &jc_keyboard_work)) {pr_err("Error queue_work 2023!\n");}
#elseif(!schedule_work(&jc_keyboard_work)) {pr_err("Error schedule_work!\n");}
#endif	return IRQ_HANDLED;
}static int s_jc_keyboard_irq_init(void) {if(s_jc_keyboard_info.irq_gpio <= 0) {pr_err("Error irq_gpio is %d\n", s_jc_keyboard_info.irq_gpio);return -1;}if(s_jc_keyboard_info.i2c_client->irq <= 0) {pr_err("Error irq is %d\n", s_jc_keyboard_info.i2c_client->irq);return -1;}if(gpio_request(s_jc_keyboard_info.irq_gpio, JC_KEYBOARD_IRQ_GPIO_NAME)) {pr_err("Error gpio_request %s\n", JC_KEYBOARD_IRQ_GPIO_NAME);return -1;}if(gpio_direction_input(s_jc_keyboard_info.irq_gpio)) {pr_err("Error gpio_direction_input %d\n", s_jc_keyboard_info.irq_gpio);gpio_free(s_jc_keyboard_info.irq_gpio);return -1;}INIT_WORK(&jc_keyboard_work, s_jc_keyboard_work_func_t);#ifdef USE_SELF_WORK_QUEUE//创建自己的工作队列和自己的内核线程jc_keyboard_wq = create_workqueue("myjc_keyboard_wq");
#endifif(request_irq(s_jc_keyboard_info.i2c_client->irq, s_jc_keyboard_i2c_isr, IRQF_TRIGGER_FALLING, JC_KEYBOARD_IRQ_NAME, NULL)) {pr_err("Error request_irq!\n");gpio_free(s_jc_keyboard_info.irq_gpio);return -1;}return 0;
}static int s_jc_keyboard_irq_exit(void) {if(s_jc_keyboard_info.i2c_client->irq > 0) {free_irq(s_jc_keyboard_info.i2c_client->irq, NULL);}if(s_jc_keyboard_info.irq_gpio > 0) {gpio_free(s_jc_keyboard_info.irq_gpio);}#ifdef USE_SELF_WORK_QUEUE//销毁自己的工作队列和内核线程destroy_workqueue(jc_keyboard_wq);
#endifreturn 0;
}static int s_jc_keyboard_input_init(void) {int i = 0;if(s_jc_keyboard_info.input_dev) {pr_err("Error input_dev is not null!\n");return -1;}if(!(s_jc_keyboard_info.input_dev = input_allocate_device())) {pr_err("Error input_allocate_device!\n");return -1;}s_jc_keyboard_info.input_dev->name = JC_KEYBOARD_DRIVER_NAME;for(i = KEY_VALUE_FUNCTION_1; i <= KEY_VALUE_TEST; i ++) {input_set_capability(s_jc_keyboard_info.input_dev, EV_KEY, s_user_key_value[i]);}if(input_register_device(s_jc_keyboard_info.input_dev)) {pr_err("Error input_register_device!\n");input_free_device(s_jc_keyboard_info.input_dev);s_jc_keyboard_info.input_dev = NULL;return -1;}return 0;
}static int s_jc_keyboard_input_exit(void) {if(!s_jc_keyboard_info.input_dev) {pr_err("Error input_dev is null!\n");return -1;}input_unregister_device(s_jc_keyboard_info.input_dev);input_free_device(s_jc_keyboard_info.input_dev);s_jc_keyboard_info.input_dev = NULL;return 0;
}static long s_jc_keyboard_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long argv) {KEYBOARD_I2C_SEND_MSG_S keyboard_send_msg;if(debug_print)pr_err("enter jc_keyboard_unlocked_ioctl\n");// if(jc_keyboard_inited != 1)  //驱动没有加载成功！！// 	return -1;if(_IOC_TYPE(cmd) != KEYBOARD_IOC_MAGIC) {pr_err("Error cmd %d\n", cmd);return -1;}memset(&keyboard_send_msg, 0, sizeof(KEYBOARD_I2C_SEND_MSG_S));keyboard_send_msg.cmd_header0 = FRAME_HEADER_0;keyboard_send_msg.cmd_header1 = FRAME_HEADER_1;switch(cmd) {case KEYBOARD_IOC_GET_BRIGHTNESS:keyboard_send_msg.cmd_type = FRAME_CMD_TYPE_GET_BRIGHTNESS;set_bit(BRIGHTNESS_RESPONSE_BIT, &wait_respon_bits);   //置高某一位break;case KEYBOARD_IOC_SET_BRIGHTNESS:if(!argv || copy_from_user(&keyboard_send_msg.cmd, (void *)argv, 1)) {pr_err("Error copy_from_user!\n");return -2;}if(keyboard_send_msg.cmd < FRAME_CMD_TYPE_SET_BRIGHTNESS_MIN || keyboard_send_msg.cmd > FRAME_CMD_TYPE_SET_BRIGHTNESS_MAX) {pr_err("Error brightness out of range!\n");return -3;}keyboard_send_msg.cmd_type = FRAME_CMD_TYPE_SET_BRIGHTNESS;set_bit(SET_BRIGHTNESS_RESPONSE_BIT, &wait_respon_bits);   //置高某一位break;case KEYBOARD_IOC_GET_PANEL_MODEL:keyboard_send_msg.cmd_type = FRAME_CMD_TYPE_GET_PANEL_MODEL;set_bit(PANEL_MODEL_RESPONSE_BIT, &wait_respon_bits);   //置高某一位break;case KEYBOARD_IOC_GET_PANEL_VER:keyboard_send_msg.cmd_type = FRAME_CMD_TYPE_GET_PANEL_VER;set_bit(PANEL_VER_RESPONSE_BIT, &wait_respon_bits);   //置高某一位break;case KEYBOARD_IOC_RESET:keyboard_send_msg.cmd_type = FRAME_CMD_TYPE_RESET;set_bit(RESET_RESPONSE_BIT, &wait_respon_bits);   //置高某一位break;case KEYBOARD_IOC_KEY_LED_FLASH:   //2023-04-28{unsigned char user_val = 0;unsigned char flashtype = 0;if(!argv || copy_from_user(&user_val, (void *)argv, 1)) {pr_err("Error KEYBOARD_IOC_KEY_LED_FLASH copy_from_user!\n");return -4;}keyboard_send_msg.cmd = s_user_map_led_value[user_val & 0x3f];//(user_val & 0x3f);	//闪烁哪个灯flashtype = ((user_val >> 6) & 0x3);   //闪烁类型keyboard_send_msg.cmd_type = FRAME_CMD_TYPE_KEY_LED_FLASH | flashtype;  //发过去的命令是0x80，81，82，83}set_bit(KEY_LED_FLASH_RESPONSE_BIT, &wait_respon_bits);   //置高某一位break;case KEYBOARD_IOC_KEY_LED_ON:case KEYBOARD_IOC_KEY_LED_OFF: {//	int i = KEY_VALUE_FUNCTION_1;unsigned char user_key_code = 0;if(!argv || copy_from_user(&user_key_code, (void *)argv, 1)) {pr_err("Error copy_from_user!\n");return -5;}// for(; i < KEY_VALUE_TEST; i ++) {// 	if(s_user_key_value[i] == user_key_code) {// 		keyboard_send_msg.cmd = i;// 		break;// 	}// }if(user_key_code < sizeof(s_user_map_led_value)/sizeof(s_user_map_led_value[0]))keyboard_send_msg.cmd = s_user_map_led_value[user_key_code];elsekeyboard_send_msg.cmd = 0;  //20220905//2023-01-05  不能识别的按键if(keyboard_send_msg.cmd == 0){pr_err("Error keyboard_send_msg.cmd == 0! user_key_code = %d\n",user_key_code);return -6;}// if(i >= KEY_VALUE_TEST) {// 	if(user_key_code >= KEY_RED_LED && user_key_code <= ALL_KEY_VALUE) {  /*lsr modify 20220512 (KEY_BLUE_LED)*/// 		keyboard_send_msg.cmd = user_key_code;// 	}// 	else {// 		pr_err("Error key code %#x out of range!\n", keyboard_send_msg.cmd);// 		return -1;// 	}// }if(cmd == KEYBOARD_IOC_KEY_LED_ON) {keyboard_send_msg.cmd_type = FRAME_CMD_TYPE_KEY_LED_ON;set_bit(KEY_LED_ON_RESPONSE_BIT, &wait_respon_bits);   //置高某一位}else {keyboard_send_msg.cmd_type = FRAME_CMD_TYPE_KEY_LED_OFF;set_bit(KEY_LED_OFF_RESPONSE_BIT, &wait_respon_bits);   //置高某一位}break;}default:pr_err("Error non-supported cmd %d\n", cmd);return -7;}keyboard_send_msg.cmd_verify = FRAME_VERIFY(keyboard_send_msg.cmd_header0,keyboard_send_msg.cmd_header1,keyboard_send_msg.cmd_type,keyboard_send_msg.cmd,0,0);
#if 1if(debug_print)pr_err("i2c_master_send: h0 = %#x, h1 = %#x type = %#x, %#x, %#x\n",keyboard_send_msg.cmd_header0,keyboard_send_msg.cmd_header1,keyboard_send_msg.cmd_type,keyboard_send_msg.cmd,keyboard_send_msg.cmd_verify);
#endifmutex_lock(&iic_idel_Mutex);   //不让发mutex_lock(&iic_Mutex);  //加锁if(i2c_master_send(s_jc_keyboard_info.i2c_client, (char *)&keyboard_send_msg, sizeof(KEYBOARD_I2C_SEND_MSG_S)) != sizeof(KEYBOARD_I2C_SEND_MSG_S)) {pr_err("Error i2c_master_send!\n");mutex_unlock(&iic_Mutex);  //开锁mutex_unlock(&iic_idel_Mutex);  //开锁return -8;}mutex_unlock(&iic_Mutex);//开锁if(down_timeout(&s_jc_keyboard_info.ioctl_sem, JC_KEYBOARD_I2C_TIMEOUT/4)) {//没有中断的情况会超时
#ifndef NO_POLL_MODEif(s_jc_keyboard_inttimeout_func_t())	
#endif{pr_err("Error down_timeout!\n");mutex_unlock(&iic_idel_Mutex);  //开锁return -9;}}mutex_unlock(&iic_idel_Mutex);  //开锁switch(cmd) {case KEYBOARD_IOC_GET_BRIGHTNESS:if(test_bit(SET_BRIGHTNESS_RESPONSE_BIT, &wait_respon_bits)){pr_err("Error KEYBOARD_IOC_GET_BRIGHTNESS down_timeout! ----test_bit\n");clear_bit(SET_BRIGHTNESS_RESPONSE_BIT, &wait_respon_bits);return -20;}if(!argv || copy_to_user((void *)argv, &s_i2c_reply_ret, 1)) {pr_err("Error copy_to_user!\n");return -10;}break;case KEYBOARD_IOC_GET_PANEL_MODEL:if(test_bit(PANEL_MODEL_RESPONSE_BIT, &wait_respon_bits)){pr_err("Error KEYBOARD_IOC_GET_PANEL_MODEL down_timeout! ----test_bit\n");clear_bit(PANEL_MODEL_RESPONSE_BIT, &wait_respon_bits);return -21;}if(!argv || copy_to_user((void *)argv, &s_i2c_reply_ret, 1)) {pr_err("Error copy_to_user!\n");return -10;}break;case KEYBOARD_IOC_GET_PANEL_VER:if(test_bit(PANEL_VER_RESPONSE_BIT, &wait_respon_bits)){pr_err("Error KEYBOARD_IOC_GET_PANEL_VER down_timeout! ----test_bit\n");clear_bit(PANEL_VER_RESPONSE_BIT, &wait_respon_bits);return -22;}if(!argv || copy_to_user((void *)argv, &s_i2c_reply_ret, 1)) {pr_err("Error copy_to_user!\n");return -10;}break;case KEYBOARD_IOC_SET_BRIGHTNESS:if(test_bit(SET_BRIGHTNESS_RESPONSE_BIT, &wait_respon_bits)){pr_err("Error KEYBOARD_IOC_SET_BRIGHTNESS down_timeout! ----test_bit\n");clear_bit(SET_BRIGHTNESS_RESPONSE_BIT, &wait_respon_bits);return -23;}if(s_i2c_reply_ret == FRAME_CMD_REPLY_FAILED) {pr_err("Error execute failed!\n");return -11;}break;case KEYBOARD_IOC_RESET:if(test_bit(RESET_RESPONSE_BIT, &wait_respon_bits)){pr_err("Error KEYBOARD_IOC_RESET down_timeout! ----test_bit\n");clear_bit(RESET_RESPONSE_BIT, &wait_respon_bits);return -24;}if(s_i2c_reply_ret == FRAME_CMD_REPLY_FAILED) {pr_err("Error execute failed!\n");return -11;}break;	case KEYBOARD_IOC_KEY_LED_ON:if(test_bit(KEY_LED_ON_RESPONSE_BIT, &wait_respon_bits)){pr_err("Error KEYBOARD_IOC_KEY_LED_ON down_timeout! ----test_bit\n");clear_bit(KEY_LED_ON_RESPONSE_BIT, &wait_respon_bits);return -25;}if(s_i2c_reply_ret == FRAME_CMD_REPLY_FAILED) {pr_err("Error execute failed!\n");return -11;}break;case KEYBOARD_IOC_KEY_LED_OFF:   //灯的控制部分，不再等待应答，2022-09-05		if(test_bit(KEY_LED_OFF_RESPONSE_BIT, &wait_respon_bits)){pr_err("Error KEYBOARD_IOC_KEY_LED_OFF down_timeout! ----test_bit\n");clear_bit(KEY_LED_OFF_RESPONSE_BIT, &wait_respon_bits);return -26;}//return 0;if(s_i2c_reply_ret == FRAME_CMD_REPLY_FAILED) {pr_err("Error execute failed!\n");return -11;}break;default:if((cmd & 0xfc) == KEYBOARD_IOC_KEY_LED_FLASH)  //闪烁的指令{if(test_bit(KEY_LED_FLASH_RESPONSE_BIT, &wait_respon_bits)){pr_err("Error KEYBOARD_IOC_KEY_LED_FLASH down_timeout! ----test_bit\n");clear_bit(KEY_LED_FLASH_RESPONSE_BIT, &wait_respon_bits);return -27;}return 0;		}break;}return 0;
}static struct file_operations s_jc_keyboard_fops = {.unlocked_ioctl = s_jc_keyboard_unlocked_ioctl,
};static int s_jc_keyboard_misc_init(void) {memset(&s_jc_keyboard_miscdevice, 0, sizeof(struct miscdevice));s_jc_keyboard_miscdevice.minor = JC_KEYBOARD_MISCDEV_MINOR;s_jc_keyboard_miscdevice.name = JC_KEYBOARD_DRIVER_NAME;s_jc_keyboard_miscdevice.fops = &s_jc_keyboard_fops;if(misc_register(&s_jc_keyboard_miscdevice)) {pr_err("Error misc_register!\n");return -1;}sema_init(&s_jc_keyboard_info.ioctl_sem, 0);return 0;
}static int s_jc_keyboard_misc_exit(void) {misc_deregister(&s_jc_keyboard_miscdevice);return 0;
}static int jc_kayboard_command_for_read(struct i2c_client *client)
{int ret = -1;uint8_t tmpbuf[10] = {0};struct i2c_msg msg[1];msg[0].addr = client->addr;msg[0].flags = I2C_M_RD;/*Read*/msg[0].len = 7;msg[0].buf = tmpbuf;ret = i2c_transfer(client->adapter, msg, 1);return ret;
}//static void s_jc_keyboard_exit(void);static int s_jc_keyboard_probe(struct i2c_client *i2c_client, const struct i2c_device_id *i2c_device_id) {int ret;
//	jc_keyboard_inited = -1;if(debug_print)pr_err("addr = %#x\n", i2c_client->addr);ret = jc_kayboard_command_for_read(i2c_client);  //尝试着读一次if(ret < 0)  //读不了直接返回{pr_err("error : jc_keyboard_command_for_read,no probe\n");
//		s_jc_keyboard_exit();return ret;}memset(&s_jc_keyboard_info, 0, sizeof(JC_KEYBOARD_INFO));if((s_jc_keyboard_info.irq_gpio = of_get_named_gpio(i2c_client->dev.of_node, "irq-gpio", 0)) < 0) {pr_err("Error of_get_named_gpio %s\n", "irq-gpio");return -1;}if((i2c_client->irq = gpio_to_irq(s_jc_keyboard_info.irq_gpio)) < 0) {pr_err("Error gpio_to_irq %d\n", s_jc_keyboard_info.irq_gpio);return -1;}s_jc_keyboard_info.i2c_client = i2c_client;if(s_jc_keyboard_input_init()) {pr_err("Error s_jc_keyboard_input_init!\n");return -1;}if(s_jc_keyboard_misc_init()) {pr_err("Error s_jc_keyboard_misc_init!\n");s_jc_keyboard_input_exit();return -1;}if(s_jc_keyboard_irq_init()) {pr_err("Error s_jc_keyboard_irq_init!\n");s_jc_keyboard_misc_exit();s_jc_keyboard_input_exit();return -1;}mutex_init(&iic_Mutex);  //初始化互斥锁mutex_init(&iic_idel_Mutex);
//	jc_keyboard_inited = 1;  //加载成功！！return 0;
}static int s_jc_keyboard_remove(struct i2c_client *i2c_client) {// if(jc_keyboard_inited != 1)  //驱动没有加载成功！！// 	return -1;if(s_jc_keyboard_irq_exit()) {pr_err("Error s_jc_keyboard_irq_exit!\n");}if(s_jc_keyboard_misc_exit()) {pr_err("Error s_jc_keyboard_misc_exit!\n");}if(s_jc_keyboard_input_exit()) {pr_err("Error s_jc_keyboard_input_exit!\n");}return 0;
}static struct i2c_driver s_i2c_driver_jc_keyboard = {.probe = s_jc_keyboard_probe,.remove = s_jc_keyboard_remove,.driver = {.name = JC_KEYBOARD_DRIVER_NAME,.owner = THIS_MODULE,.of_match_table = s_jc_keyboard_match_table,},.id_table = s_jc_keyboard_i2c_id,
};// static int s_jc_keyboard_init(void) {
// 	if(i2c_add_driver(&s_i2c_driver_jc_keyboard)) {
// 		pr_err("Error s_jc_keyboard_init i2c_add_driver!\n");
// 		return -1;
// 	}
// 	return 0;
// }// static void s_jc_keyboard_exit(void) {
// 	return;
// //	i2c_del_driver(&s_i2c_driver_jc_keyboard);
// }module_i2c_driver(s_i2c_driver_jc_keyboard);     //2023-03-30  增加 // module_init(s_jc_keyboard_init);
// module_exit(s_jc_keyboard_exit);
// date 需要修改内核的makefile ，注释 886 KBUILD_CFLAGS   += $(call cc-option,-Werror=date-time)
MODULE_DESCRIPTION("Buildtime :"__DATE__" "__TIME__);
MODULE_AUTHOR("dazhi@jc,keyboard,2023-05");
MODULE_LICENSE("GPL");
MODULE_VERSION("1.1.0");    //2023-05-10 版本1.1.0

这里做了一个简单的分析，解决iic通信时的一个互斥问题，但是可能不是很完善，请各位多多包含指教。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/29808.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Appium+python自动化（十二）- Android UIAutomator终极定位凶器（超详解）

Appium+python自动化（十二）- Android UIAutomator终极定位凶器（超详解）

简介 乍眼一看&#xff0c;小伙伴们觉得这部分其实在异性兄弟那里就做过介绍和分享了&#xff0c;其实不然&#xff0c;上次介绍和分享的大哥是uiautomatorviewer&#xff0c;是一款定位工具。今天介绍的是一个java库&#xff0c;提供执行自动化测试的各种API。 Android团队在4…
阅读更多...
供应链管理系统有哪些？

供应链管理系统有哪些？

1万字干货分享&#xff0c;国内外 20款 供应链管理软件都给你讲的明明白白。如果你还不知道怎么选择&#xff0c;一定要翻到第三大段&#xff0c;这里我将会通过8年的软件产品选型经验告诉你&#xff0c;怎么样才能快速选到适合自己的软件工具。 &#xff08;为防后续找不到&a…
阅读更多...
2023护网面试题200道（附答案）

2023护网面试题200道（附答案）

最近日入1000的护网行动已经开始摇人了&#xff0c; 不少大学生在后台私信我如何参加护网、面试问些什么、有没有护网内推 作为一个负责任的博主&#xff0c;收到大家反馈的我&#xff0c;连夜发动钞能力&#xff0c;收集整理了一套护网蓝初面试文档 1. 什么是DDoS攻击&#x…
阅读更多...
解决appium-doctor报 bundletool.jar cannot be found

解决appium-doctor报 bundletool.jar cannot be found

一、下载bundletool.jar 下载地址&#xff1a;https://github.com/google/bundletool/releases 二、重命名 重命名这个jar包为bundletool.jar&#xff0c;在android sdk目录下&#xff0c;新建bundle-tool目录&#xff0c;把bundletool.jar包放入其中。 三、配置环境 path后追加…
阅读更多...
docker基础1——架构组成、安装配置

docker基础1——架构组成、安装配置

文章目录 一、发展起源1.1 传统虚拟化与容器虚拟化1.2 docker底层核心技术1.2.1 命名空间1.2.2 控制组 1.3 docker工作方式1.4 docker容器编排1.5 docker优劣势1.6 docker架构组成 二、yum安装docker三、配置docker加速器 一、发展起源 背景了解&#xff1a; 容器是内核里的一项…
阅读更多...
消息重试框架 Spring-Retry 和 Guava-Retry

消息重试框架 Spring-Retry 和 Guava-Retry

一 重试框架之Spring-Retry 1.Spring-Retry的普通使用方式 2.Spring-Retry的注解使用方式 二 重试框架之Guava-Retry 总结 图片 一 重试框架之Spring-Retry Spring Retry 为 Spring 应用程序提供了声明性重试支持。它用于Spring批处理、Spring集成、Apache Hadoop(等等)。…
阅读更多...
BUFG/BUFGCE/BUFH/BUFHCE/BUFH/BUFGHCE/BUFMR/BUFMRCE/BUFR/IBUF/IBUFDS

BUFG/BUFGCE/BUFH/BUFHCE/BUFH/BUFGHCE/BUFMR/BUFMRCE/BUFR/IBUF/IBUFDS

本文对BUFG/BUFGCE/BUFH/BUFHCE简单介绍&#xff0c;便于后续查看。 原语的使用&#xff1a;在vivado中找到所要用的原语&#xff0c;直接将其实例化到设计中即可。 文章目录 BUFGBUFGCEBUFHBUFHCEBUFMRBUFRBUFMRCEIBUFIBUFDS 下图为 7 系列 FPGA 时钟架构图&#xff1a; BU…
阅读更多...
系列七、VMware中的CentOS服务不息屏

系列七、VMware中的CentOS服务不息屏

一、场景 VMware中安装好CentOS7等虚拟机后&#xff0c;过一段时间会自动息屏&#xff0c;这个时候如果想执行操作&#xff0c;需要重新输入 用户名/密码&#xff0c;体验感不好。 二、解决方法 应用程序》系统工具》设置》Privacy》锁屏》自动锁屏&#xff08;关闭&#xff0…
阅读更多...
UnxUtils工具包，Windows下使用Linux命令

UnxUtils工具包，Windows下使用Linux命令

1. 前言 最近写批处理多了&#xff0c;发现Windows下的bat批处理命令&#xff0c;相比Linux的命令&#xff0c;无论是功能还是多样性&#xff0c;真的差太多了。但有时候又不得不使用bat批处理&#xff0c;好在今天发现了一个不错的工具包&#xff1a;UnxUtils&#xff0c;这个…
阅读更多...
分区类型ID一键变身！快速改变分区类型ID的简单方法

分区类型ID一键变身！快速改变分区类型ID的简单方法

分区类型ID是什么&#xff1f; 想要改变分区类型ID&#xff0c;先得明白分区类型ID是什么。大多数电脑用户可能只熟悉分区和分区类型&#xff0c;实际上有5种分区类型&#xff1a;主分区、可扩展固件接口&#xff08;EFI&#xff09;、扩展分区、逻辑分区和Microsoft保留分…
阅读更多...
向量检索增强chatglm生成

向量检索增强chatglm生成

背景&#xff1a; 基于chatglm构建agnet&#xff1a;chatglm实现Agent控制 - 知乎 前面一篇文章已经介绍了如何去搭建LLM Agent控制系统&#xff0c;也简单介绍了如何去构建Toolset和构建Action。但是在上篇文章中Toolset其实是基于搜索api构建的&#xff0c;从这篇文章开始后…
阅读更多...
文心一言 VS 讯飞星火 VS chatgpt （63）-- 算法导论6.5 2题

文心一言 VS 讯飞星火 VS chatgpt （63）-- 算法导论6.5 2题

文心一言 VS 讯飞星火 VS chatgpt &#xff08;63&#xff09;-- 算法导论6.5 2题 二、试说明 MAX-HEAP-INSERT(A&#xff0c;10)在堆A(15&#xff0c;13&#xff0c;9&#xff0c;5&#xff0c;12&#xff0c;8&#xff0c;7&#xff0c;4&#xff0c;0&#xff0c;6&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023