创建字符设备给文件系统接口并建立I2C与MCU直之间通信驱动

最新推荐文章于 2024-04-11 17:48:58 发布
最新推荐文章于 2024-04-11 17:48:58 发布
阅读量343 收藏
点赞数
分类专栏： I2C  字符设备
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jinron10/article/details/108929231
版权

1、创建字符设备
如果不是I2C的驱动设备，要创建一个字符设备，方法如下：
定义全局变量：
//字符设备
#define SOCTOMCU_DEVICE_NAME “soctomcu”
tatic int soctomcu_major = 0;
static struct class *soctomcu_class;
struct device *soctomcu_device;
#define FRAME_LEN_MAX 132
typedef struct{
unsigned char buf[FRAME_LEN_MAX];
int len;
}soctomcu_frame;
//I2C设备
struct i2c_client *i2c_connect_client;
struct SOCTOR78I2C_data{
struct i2c_client *SOCTOR78I2C_client;
struct delayed_work work;
};
static struct SOCTOR78I2C_data *SOCTOR78I2C_i2c;

定义文件系统接口：
static const struct file_operations soctomcu_fops = {
.owner = THIS_MODULE,
.open = soctomcu_open,
.release = soctomcu_close,
.read = socto_lvdsmcu_read,
.write = socto_lvdsmcu_write,
};
在init初始化函数中:
static int __init soctor78_init(void)
{
/*创建I2C设备定义/
struct i2c_board_info info;
struct i2c_adapter *adapter;
struct i2c_client *client;
int ret=0;
…
//获取主设备号
soctomcu_major = register_chrdev(0, SOCTOMCU_DEVICE_NAME, &soctomcu_fops);
if(soctomcu_major < 0){
unregister_chrdev(soctomcu_major, SOCTOMCU_DEVICE_NAME);
pr_info(“soctomcu register_chrdev fail!\n”);
ret =soctomcu_major;
}
//获取设备类
soctomcu_class = class_create(THIS_MODULE, SOCTOMCU_DEVICE_NAME);
if (IS_ERR(soctomcu_class)) {
class_destroy(soctomcu_class);
printk(KERN_ERR “Error creating class.\n”);
ret = -1;
}
//创建字符设备
soctomcu_device = device_create(soctomcu_class, NULL, MKDEV(soctomcu_major, 0), NULL, SOCTOMCU_DEVICE_NAME);
if (IS_ERR(soctomcu_device)) {
device_destroy(soctomcu_class, MKDEV(soctomcu_major, 0));
printk(KERN_ERR “Error creating class device.\n”);
ret = -1;
}
memset(&info, 0, sizeof(struct i2c_board_info));
info.addr = SOCTOR78I2C_ADDR;
strlcpy(info.type, “SocToR78_I2c”, I2C_NAME_SIZE);

 adapter = i2c_get_adapter(0);  //创建I2C适配器，后面的i2c_transfer()函数需要用到这个适配器
 if (!adapter)
    {
       	printk(KERN_ERR "Can't get i2c adapter 0\n");
       	//kfree(pdata);
       	ret = -ENODEV;
		goto exit;
    }
client = i2c_new_device(adapter, &info); //取到client，后面传给probe()函数，在probe()函数中保存给后面的i2C通信函数使用
//printk("i2c_new_device::client=0x%x\n",*client);
i2c_put_adapter(adapter);
if (!client)
  {
    printk(KERN_ERR "Can't add i2c device at 0x%x\n", (unsigned int)info.addr); 
    //kfree(pdata);
    ret = -ENOMEM;
   	goto exit;
}

printk(“soctor78 driver installing…\n”);
return i2c_add_driver(&soctor78_driver);
}

static int __devinit soctor78_probe(struct i2c_client *client,
					   const struct i2c_device_id *id)

{
   int ret=0;
   struct SOCTOR78I2C_data *ts_pdata;
   client->addr=SOCTOR78I2C_ADDR;
   i2c_connect_client = client;
   if(!i2c_check_functionality(client->adapter,
   	   I2C_FUNC_SMBUS_BYTE|I2C_FUNC_SMBUS_BYTE_DATA)){
   	    printk("[mcui2c]:i2c_check_functionality failed \n");
   	   return -1;
   }
   ts_pdata = kzalloc(sizeof(struct SOCTOR78I2C_data), GFP_KERNEL);
   if (!ts_pdata)
   	 return -ENOMEM;
   ts_pdata->SOCTOR78I2C_client=client;
   i2c_set_clientdata(client,ts_pdata);

   SOCTOR78I2C_i2c = ts_pdata;
   SOCTOR78I2C_i2c->SOCTOR78I2C_client =client;
   SOCTOR78I2C_i2c->SOCTOR78I2C_client->adapter=client->adapter;
   return 0;
   }

后面使用probe()函数中保存的client取到adapter用于I2C接口通信
I2C写：
在这里插入图片描述

static int LvdsMcuWrite(int wLen,unsigned char *wData)
{
	struct SOCTOR78I2C_data *pata=i2c_get_clientdata(i2c_connect_client);//从保存的client中取到client数据，后面用于I2C数据传输pata->SOCTOR78I2C_client->adapter
	struct i2c_msg msgs[1];
   	unsigned char WriteData[10];
	unsigned int msg0_len=0;
	unsigned char i=0;
	unsigned char j=0;
	unsigned int ret=0;
	WriteData[i++]=0xFF;
	WriteData[i++]=0x55;
	for(j=0; j<(wLen);j++){
		WriteData[i++]=*(wData+j);
	}
	WriteData[i++]=SOCWriteIIC_GetSum((wLen),&WriteData[3]);
	msg0_len = wLen+3;
	for(i=0;i< msg0_len;i++)  
		printk("WriteData[%d]=0x%x\n",i,WriteData[i]);
       msgs[0].flags = !I2C_M_RD;
       msgs[0].addr  = pata->SOCTOR78I2C_client->addr;
       msgs[0].len   = msg0_len;
       msgs[0].buf   = &WriteData[0];

	write_read_cmd =WriteData[4];
	printk("I2cToRt87::i2c Read write :: write_read_cmd=0x%x\n",write_read_cmd);
       ret = i2c_transfer(pata->SOCTOR78I2C_client->adapter, msgs,1);
   	if(ret < 0){
   		printk("I2cToRt87::i2c Read write  error ret=%d\n",ret);
   	}
      printk("I2cToRt87::i2c Read write OK ret=%d\n",ret);
      return ret;
}

I2C读：

static int LvdsMcuRead(int rLen,unsigned char *rData)
{
	struct SOCTOR78I2C_data *pata=i2c_get_clientdata(i2c_connect_client);
	struct i2c_msg msgs[1];
	unsigned char ReadTPAckData[20];
	unsigned char i=0;
	unsigned int ret=0;
	printk("LvdsMcuRead()::rLen=%d,i2c_connect_client->addr=0x%x\n",rLen,i2c_connect_client->addr);
       msgs[0].flags = I2C_M_RD;
       msgs[0].addr  = pata->SOCTOR78I2C_client->addr;
       msgs[0].len   = rLen;
       msgs[0].buf   = &ReadTPAckData[0];
      
       ret = i2c_transfer(pata->SOCTOR78I2C_client->adapter, msgs,1);
   	if(ret < 0){
   		printk("I2cToRt87::i2c Read write  error ret=%d\n",ret);
   	}
      for(i=0;i<rLen;i++){
      		//printk("I2cToRt87::ReadTPAckData[%d]=0x%x\n",i,ReadTPAckData[i]);
		*(rData+i)=ReadTPAckData[i];
      	}
     return ret;
}

例如复位TP的通信指令：
在这里插入图片描述

const unsigned char TOUCHPANEL_RESET[]={0x03,0x10,0x13};
int Lvdsmcu_Resettp(void)
{
	unsigned char wTempdata[10];
	unsigned char ret=0;
	wTempdata[0]=TOUCHPANEL_RESET[0];
	wTempdata[1]=TOUCHPANEL_RESET[1];
	wTempdata[2]=TOUCHPANEL_RESET[2];
	ret=LvdsMcuWrite(wTempdata[0], &wTempdata[0]);
	if(ret<0){
		printk("LvdsMcuWrite()::touchpannel reset error ret=%d\n",ret);
		return ret;
	}
	printk("LvdsMcuWrite()::touchpannel reset ok ret=%d\n",ret);
	return ret;
}

最后整个驱动代码：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/irq.h>
#include <linux/platform_device.h>
#include <linux/input-polldev.h>
#include <linux/input.h>
#include <linux/wait.h>
#include <linux/workqueue.h>
#include <linux/proc_fs.h>
#include <linux/clk.h>
#include <linux/io.h>
#include <linux/gpio.h>
#include <linux/proc_fs.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <asm/mach-types.h>
#include <linux/clk.h>
#include <linux/device.h>
#include <linux/types.h>
#include <linux/workqueue.h>
#include <linux/spinlock.h>
#include <linux/regulator/consumer.h>
#include <linux/fsl_devices.h>
#include <linux/input.h>
#include <linux/workqueue.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/mutex.h>
#include <linux/uaccess.h>
/*Winfred Young add for tftloader*/
#include <linux/cdev.h>
#include <linux/io.h>
#include <linux/kthread.h>   
#include <linux/sched.h> 
#include <linux/workqueue.h>
#include <linux/poll.h>

#include <linux/gpio.h>

/**************soc to mcu communication protocol ****************/
#define SOCTOR78I2C_NAME          "SocToR78_I2c"
#define SOCTOR78I2C_NAME_SIZE   20
#define SOCTOR78I2C_ADDR      0x3c //0x78
//add soc to R87 connect test
const unsigned char GET_COMMUNICATIONDET[]={0x03,0x10,0x88};
const unsigned char TOUCHPANEL_RESET[]={0x03,0x10,0x13};

struct i2c_client *i2c_connect_client;
struct SOCTOR78I2C_data{
   struct i2c_client *SOCTOR78I2C_client;
   struct delayed_work work;
};
static struct  SOCTOR78I2C_data *SOCTOR78I2C_i2c;
/********************************************************
*Soc to mcu IO ctrl interface
************************************************************/
#define SOCTOMCU_DEVICE_NAME "soctomcu"

//static DECLARE_WAIT_QUEUE_HEAD(inq);
//int is_read_frame = 0;
static unsigned char write_read_cmd =0x00;
static int soctomcu_major = 0;
static struct class *soctomcu_class;
struct device *soctomcu_device;
static int soctomcuopen=0;

#define FRAME_LEN_MAX  132
typedef struct{
	unsigned char buf[FRAME_LEN_MAX];
	int len;
}soctomcu_frame;
static spinlock_t mcu_lock;
/**************************************END ***************************/
unsigned char SOCWriteIIC_GetSum(unsigned char cLen,unsigned char *cData)
{
	unsigned char i;
	unsigned char checkSum=0;
	for(i=0; i<(cLen-1); i++){
		checkSum += *(cData+i);
	}
	return(checkSum);
}
/**********************************************************************
wLen: Packet Length:Byte count from CID to CSUM
wData: Byte count from CID to Para-N
1 frame data length=package head + 1byte wlwn+wLen = 2+1+wLen
***********************************************************************/
//static int LvdsMcuWrite(unsigned char wLen,unsigned char *wData)
static int LvdsMcuWrite(int wLen,unsigned char *wData)
{
	struct SOCTOR78I2C_data *pata=i2c_get_clientdata(i2c_connect_client);;
	struct i2c_msg msgs[1];
   	unsigned char WriteData[10];
	unsigned int msg0_len=0;
	unsigned char i=0;
	unsigned char j=0;
	unsigned int ret=0;
	WriteData[i++]=0xFF;
	WriteData[i++]=0x55;
	for(j=0; j<(wLen);j++){
		WriteData[i++]=*(wData+j);
	}
	WriteData[i++]=SOCWriteIIC_GetSum((wLen),&WriteData[3]);
	msg0_len = wLen+3;
	for(i=0;i< msg0_len;i++)  
		printk("WriteData[%d]=0x%x\n",i,WriteData[i]);
       msgs[0].flags = !I2C_M_RD;
       msgs[0].addr  = pata->SOCTOR78I2C_client->addr;
       msgs[0].len   = msg0_len;
       msgs[0].buf   = &WriteData[0];

	write_read_cmd =WriteData[4];
	printk("I2cToRt87::i2c Read write :: write_read_cmd=0x%x\n",write_read_cmd);
       ret = i2c_transfer(pata->SOCTOR78I2C_client->adapter, msgs,1);
   	if(ret < 0){
   		printk("I2cToRt87::i2c Read write  error ret=%d\n",ret);
   	}
      printk("I2cToRt87::i2c Read write OK ret=%d\n",ret);
      return ret;
}
/*************************************************************
rLen: 1 frame data length
rData: read 1 frame data length
1 frame data length=package head + 1byte wlwn+wLen = 2+1+wLen
****************************************************************/
//static int LvdsMcuRead(unsigned char rLen,unsigned char *rData)
static int LvdsMcuRead(int rLen,unsigned char *rData)
{
	struct SOCTOR78I2C_data *pata=i2c_get_clientdata(i2c_connect_client);
	struct i2c_msg msgs[1];
	unsigned char ReadTPAckData[20];
	unsigned char i=0;
	unsigned int ret=0;
	printk("LvdsMcuRead()::rLen=%d,i2c_connect_client->addr=0x%x\n",rLen,i2c_connect_client->addr);
       msgs[0].flags = I2C_M_RD;
       msgs[0].addr  = pata->SOCTOR78I2C_client->addr;
       msgs[0].len   = rLen;
       msgs[0].buf   = &ReadTPAckData[0];
      
       ret = i2c_transfer(pata->SOCTOR78I2C_client->adapter, msgs,1);
   	if(ret < 0){
   		printk("I2cToRt87::i2c Read write  error ret=%d\n",ret);
   	}
      for(i=0;i<rLen;i++){
      		//printk("I2cToRt87::ReadTPAckData[%d]=0x%x\n",i,ReadTPAckData[i]);
		*(rData+i)=ReadTPAckData[i];
      	}
     return ret;
}

int Lvdsmcu_Resettp(void)
{
	unsigned char wTempdata[10];
	unsigned char ret=0;
	wTempdata[0]=TOUCHPANEL_RESET[0];
	wTempdata[1]=TOUCHPANEL_RESET[1];
	wTempdata[2]=TOUCHPANEL_RESET[2];
	ret=LvdsMcuWrite(wTempdata[0], &wTempdata[0]);
	if(ret<0){
		printk("LvdsMcuWrite()::touchpannel reset error ret=%d\n",ret);
		return ret;
	}
	printk("LvdsMcuWrite()::touchpannel reset ok ret=%d\n",ret);
	return ret;
}
EXPORT_SYMBOL(Lvdsmcu_Resettp);
int SocConnect_Rt87Mcu(void)
{
    unsigned char i=0,ret=0;
    unsigned char ReadR17Data[10];
    unsigned char WriteData[10];
    WriteData[0]=GET_COMMUNICATIONDET[0];
    WriteData[1]=GET_COMMUNICATIONDET[1];
    WriteData[2]=GET_COMMUNICATIONDET[2];
     ret=LvdsMcuWrite(WriteData[0], &WriteData[0]);
	if(ret<0){
		printk("LvdsMcuWrite()::touchpannel reset error ret=%d\n",ret);
		return ret;
	}
	printk("LvdsMcuWrite()::touchpannel reset ok ret=%d\n",ret);
	msleep(30);
	ret=LvdsMcuRead(9,&ReadR17Data[0]); //read 9 byte
	if(ret<0){
		printk("LvdsMcuRead()::touchpannel reset ACK error ret=%d\n",ret);
		return ret;
	}
	for(i=0;i<9;i++)
      		printk("I2cToRt87::*(rData+%d)=0x%x\n",i,ReadR17Data[i]);
	return ret;

}
EXPORT_SYMBOL(SocConnect_Rt87Mcu);
static int __devinit soctor78_probe(struct i2c_client *client,
					   const struct i2c_device_id *id)

{
   int ret=0;
   struct SOCTOR78I2C_data *ts_pdata;
   //struct i2c_adapter *adapter;
   //struct i2c_msg msgs[1];
   //unsigned char ReadR17Data[10];
   //unsigned char WriteData[10];
   //unsigned char PwmData[2];
   client->addr=SOCTOR78I2C_ADDR;
   //printk("soctor78_probe::client=0x%x\n",*client);
   i2c_connect_client = client;
   if(!i2c_check_functionality(client->adapter,
   	   I2C_FUNC_SMBUS_BYTE|I2C_FUNC_SMBUS_BYTE_DATA)){
   	    printk("[mcui2c]:i2c_check_functionality failed \n");
   	   return -1;
   }
   printk("[soctor78]:%s\n",__FUNCTION__);

   ts_pdata = kzalloc(sizeof(struct SOCTOR78I2C_data), GFP_KERNEL);
   if (!ts_pdata)
   	 return -ENOMEM;
   
   ts_pdata->SOCTOR78I2C_client=client;
   i2c_set_clientdata(client,ts_pdata);

   SOCTOR78I2C_i2c = ts_pdata;
   SOCTOR78I2C_i2c->SOCTOR78I2C_client =client;
   SOCTOR78I2C_i2c->SOCTOR78I2C_client->adapter=client->adapter;
/*********************************************************/
   /
  //add soc to R87 mcu connect tes dect
  /* ret= SocConnect_Rt87Mcu();
	if(ret < 0){
		printk("SocConnect_Rt87Mcu failed!\n");
		return -1;
	}
    msleep(20);
    */
   return 0;
}

static int soctor78_remove(struct i2c_client *client)
{
  int ret=0;
  struct mcui2c *pdata=i2c_get_clientdata(client);

  i2c_set_clientdata(client,NULL);
  kfree(pdata);
  return ret;
}


//I2C devie id
static const struct i2c_device_id soctor78_id[]={
   	{SOCTOR78I2C_NAME,0},
	{	}
};

MODULE_DEVICE_TABLE(i2c,soctor78_id);


static struct i2c_driver soctor78_driver={
    .driver={
       .name  = SOCTOR78I2C_NAME,
       .owner = THIS_MODULE,
	 },
    .probe	  = soctor78_probe,
    .remove	  = __devexit_p(soctor78_remove),
    .id_table = soctor78_id,
};
/****************Analysis of communication protocol************************/

/*************************soc to mcu file system interface *******************/
static void soctomcu_lock_init(void)
{
	/* init lock */
	spin_lock_init(&mcu_lock);
}

static void soctomcu_lock(void)
{
	spin_lock(&mcu_lock);
}

static void soctomcu_unlock(void)
{
	spin_unlock(&mcu_lock);
}
static int soctomcu_open(struct inode* inode, struct file* filep)
{
	printk("<semisky><soctomcu open>soctomcu_open++\n");
	if (soctomcuopen) {
		printk(KERN_DEBUG "device_open() - Returning EBUSY. \
			Device already open... \n");
		return -EBUSY;
	}
	soctomcu_lock();
	soctomcuopen++;
	soctomcu_unlock();
	try_module_get(THIS_MODULE);
	return 0;
}
static int soctomcu_close(struct inode *inode, struct file *filep)
{
	printk("<semisky><soctomcu close>soctomcu_close++\n");
	soctomcu_lock();
	soctomcuopen--;	
	soctomcu_unlock();
       module_put(THIS_MODULE);
  	return 0;
}
static void printFrame(soctomcu_frame * frame)
{
	int index;
	return ;
	for(index = 0; index < frame->len; index++)
	{
		pr_info("<semisky> soctomcu_package[%d]=0x%02x\n",index,frame->buf[index]);
	}
}

/***************************************************************/
static ssize_t socto_lvdsmcu_read(struct file *filp, char __user *buf, size_t count,loff_t *f_pos)
{
	soctomcu_frame mcu_read_pkg;
	int i;
	
	printk("<semisky><mcu read>soctomcu_read++\n");
	
	memset(&mcu_read_pkg, 0, sizeof(soctomcu_frame));
	mcu_read_pkg.len=count;
	soctomcu_lock();
	LvdsMcuRead(mcu_read_pkg.len,&mcu_read_pkg.buf[0]);
	soctomcu_unlock();
	
	printFrame(&mcu_read_pkg);
	
	if(copy_to_user((unsigned char *)buf, &mcu_read_pkg.buf[0], count)){
		printk("<semisky><mcu_udpate>SOCTOMCU_READ_PACKAGE, copy fail\n");
		return -1;
	}
	printk("<semisky><mcu_udpate>SOCTOMCU_READ_PACKAGE ok\n");
	return 0;
}
/***************************************************************/
static ssize_t socto_lvdsmcu_write(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    soctomcu_frame  soctomcu_write_pkg;
    unsigned char  soctomcu_cmd ;
    int i=0;
	
    printk("<semisky><soctomcu write>soctomcu_write++\n");
    memset(&soctomcu_write_pkg, 0, sizeof(soctomcu_frame));
    if (copy_from_user(&soctomcu_write_pkg.buf[0], (unsigned char*)buf, count)) {
		printk("<semisky><SOCTOMCU_WRITE>write farme buff error\n");	
    }
   soctomcu_write_pkg.len=count;
   for(i=0;i<soctomcu_write_pkg.len;i++)
   	printk("<soctomcu write>soctomcu_write_pkg.buf[%d]=0x%x\n",i,soctomcu_write_pkg.buf[i]);
   soctomcu_cmd = soctomcu_write_pkg.buf[2];
   printk("%s, soctomcu_cmd = 0x%x,soctomcu_write_pkg.len=%d\n",__FUNCTION__,soctomcu_cmd,soctomcu_write_pkg.len);
   soctomcu_lock();
   LvdsMcuWrite(soctomcu_write_pkg.len, &soctomcu_write_pkg.buf[0]);
   soctomcu_unlock();
    return 0;
}
/***************************************************************/
static const struct file_operations soctomcu_fops = {
	.owner		 = THIS_MODULE,	
	.open		 = soctomcu_open,
	.release	 = 	soctomcu_close,
	.read      = 	socto_lvdsmcu_read,
	.write     =    socto_lvdsmcu_write,
};
/********************************END*************************/
static int __init soctor78_init(void)
{
	//struct goodix_ts_platform_data *pdata;
	//struct SOCTOR78I2C_data *pdata;
	struct i2c_board_info info;
	struct i2c_adapter *adapter;
    	struct i2c_client *client;
	int ret=0;
	printk("%s\n",__FUNCTION__);
	/********************************creat char device node*******************/
	/* init access lock */
	soctomcu_lock_init();
	soctomcuopen = 0;
	//printk("<semisky><soctomcu >soctomcu_init++\n");	

	soctomcu_major = register_chrdev(0, SOCTOMCU_DEVICE_NAME, &soctomcu_fops);
	if(soctomcu_major < 0){
		unregister_chrdev(soctomcu_major, SOCTOMCU_DEVICE_NAME);
		pr_info("<semisky><soctomcu>soctomcu register_chrdev fail!\n");
		ret =soctomcu_major;
	}
	//pr_info("<semisky><soctomcu>register_chrdev success!\n");
	
	soctomcu_class = class_create(THIS_MODULE, SOCTOMCU_DEVICE_NAME);
	if (IS_ERR(soctomcu_class)) {
		class_destroy(soctomcu_class);
		printk(KERN_ERR "<semisky><soctomcu>Error creating class.\n");
		ret = -1;
	}
	soctomcu_device = device_create(soctomcu_class, NULL, MKDEV(soctomcu_major, 0), NULL, SOCTOMCU_DEVICE_NAME);
	if (IS_ERR(soctomcu_device)) {
		device_destroy(soctomcu_class, MKDEV(soctomcu_major, 0));
		printk(KERN_ERR "<semisky><soctomcu>Error creating class device.\n");
		ret = -1;
	}
    memset(&info, 0, sizeof(struct i2c_board_info));
	info.addr = SOCTOR78I2C_ADDR;
	strlcpy(info.type,  "SocToR78_I2c", I2C_NAME_SIZE);
	
        adapter = i2c_get_adapter(0);
	if (!adapter)
	    {
	       	printk(KERN_ERR "Can't get i2c adapter 0\n");
	       	//kfree(pdata);
	       	ret = -ENODEV;
			goto exit;
	    }
	client = i2c_new_device(adapter, &info);
	//printk("i2c_new_device::client=0x%x\n",*client);
   	i2c_put_adapter(adapter);
	if (!client)
      {
        printk(KERN_ERR "Can't add i2c device at 0x%x\n", (unsigned int)info.addr); 
        //kfree(pdata);
        ret = -ENOMEM;
       	goto exit;
    }
  printk("soctor78 driver installing..\n");
  return  i2c_add_driver(&soctor78_driver);
  exit:
	return ret;
 }

static void __exit soctor78_exit(void)
{
       printk("%s\n",__FUNCTION__);
	i2c_del_driver(&soctor78_driver);
	i2c_unregister_device(i2c_connect_client);
	/*************************************************/
	/*unregister_chrdev_region(MKDEV(SOCTOMCU_MAJOR,SOCTOMCU_MINOR),10);
        
       cdev_del(soctomcudev);
       device_destroy(soctomcu_class, soctomcu_dev);
       class_destroy(soctomcu_class);
       */
       device_destroy(soctomcu_class, MKDEV(soctomcu_major, 0));
	
	class_destroy(soctomcu_class);

	unregister_chrdev(soctomcu_major, SOCTOMCU_DEVICE_NAME);
	/**************************************************/
 }

 module_init(soctor78_init);
 module_exit(soctor78_exit);
 MODULE_AUTHOR("czwyle");
 MODULE_DESCRIPTION("Driver for soctor78 I2C devices");
 MODULE_LICENSE("GPL");
jinron10
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
I2C接口
小柚子的博客
06-12 1785
I2C总线是一种简单的方法来连接多个芯片，特别是fpga / cpld。 I2C总线的特点但它是如何工作的一个I2C总线至少需要一个I2C主总线和一个I2C从总线。I2C主服务器是一个事务启动器(主服务器可以向从服务器写或从服务器读)。 I2C从站是一个事务接收端(从站可以向主站写入或从主站读取)。I2C波形这是它在公共汽车上的样子。 这是对地址为0x51的EEPROM的写操作，包含2个数据字节0x50和0x0F。 一个I2C事务以一个“开始”条件开始，后面是我们想要与之通信的设备地址，一个比特表示我们
【干货】深度解析I2C原理，建议收藏！
dpwkj的博客
05-02 1024
I2C全拼Inter Integrated Circuit，简称IIC或I2C，是由Philips公司开发的两线时串行总线，用于SOC与外设的连接通讯，它只需要两根线就能实现I2C的通讯，采用主从模式，主的一方可以读写数据，而从的一方只能等待被读写。从的一方没有主动权。
I2c流程
linuxdriverdeveloper的专栏
02-20 1046
1.I2C协议      2条双向串行线，一条数据线SDA，一条时钟线SCL。    SDA传输数据是大端传输，每次传输8bit，即一字节。    支持多主控(multimastering)，任何时间点只能有一个主控。    总线上每个设备都有自己的一个addr，共7个bit，广播地址全0.    系统中可能有多个同种芯片，为此addr分为固定部分和可编程部份，细节视芯片而定，看da
I2C接口简介和时序
re_call的博客
09-11 1757
简介 I2C，Inter－Integrated Circuit，是两根线，SDA（数据）和SCL（时钟），也是一种同步传输协议。主机在发送开始信号之后，先发送7个比特的地址位和1个比特的读写位，每个从机有自己的I2C地址，当发现该条指令是发给自己的时候，拉低SDA线（即回复ACK信号），然后主机发送或接收数据，完成传输。传输完成之后，主机发送停止位，完成该次传输。 时序 (1) master发起始信号后，总线上所有的slave开始等待主机紧接下来的地址广播。总线上每个设备的地址都是唯一的，..
GD32F103 硬件I2C驱动SSD1306-OLED显示屏,PCF8563-RTC实时时钟,SHT30温湿度传器
最新发布
06-02
GD32F103是一款基于ARM Cortex-M3内核的高性能通用MCU，它提供了丰富的外设接口，包括I2C，使得与各种外围设备的通信变得简单。 **GD32F103硬件I2C接口** GD32F103系列微控制器的I2C接口支持标准和快速模式，最高...
i2c-eeprom.rar_eeprom i2c
09-21
标题 "i2c-eeprom.rar_eeprom i2c" 涉及到的主题是I2C总线协议与EEPROM的交互，这是嵌入式系统中常见的一种存储数据的方法。I2C（Inter-Integrated Circuit）是一种由Philips（现为NXP半导体）开发的多设备通信总线...
I2C.rar_I2C介绍_I2C总线_I2C总线协议_i2c_i2c protocol
09-22
I2C（Inter-Integrated Circuit）是由Philips公司（现为NXP半导体）在1982年推出的一种串行通信协议，它是一种高效、简单、低成本的两线制通信接口，广泛应用于微控制器（MCU）与外部设备之间的通信，如传感器、显示...
STM32F103C8T6使用Hal库IO模拟I2C驱动0.96寸OLED屏显示
07-14
这款MCU拥有丰富的外设接口，包括GPIO、定时器、ADC、UART、SPI和I2C等，适用于各种嵌入式应用，如物联网设备、工业控制和消费电子产品。 在本项目中，开发者使用了HAL库来操作STM32F103C8T6的GPIO引脚，模拟I2C...
21ic下载_STM32F103C8T6例程_i2c_
09-30
这款MCU基于ARM Cortex-M3内核，具有丰富的外设接口，包括I2C（Inter-Integrated Circuit）通信接口。在标题和描述中提到的"STM32F103C8T6例程_i2c_"，显然涉及到的是利用STM32F103C8T6进行I2C通信的示例代码或教程...
Harmony鸿蒙南向驱动开发-I2C接口使用
m0_64420071的博客
04-11 1316
I2C（Inter Integrated Circuit）总线是由Philips公司开发的一种简单、双向二线制同步串行总线
STC89C52RC单片机额外篇 | 08 - 认识I2C协议以及E2PROM存储器（AT24Cxx）
Systemcall名屋
07-13 1940
## 一、I2C协议 I2C 也叫 IIC（Inter－Integrated Circuit）总线，是一种由PHILIPS公司在80年代开发的两线式串行总线，用于连接微控制器及其外围设备。它是**半双工通信方式**。 我们首先阅读以下这个例子，这会方便后面大家进一步理解I2C协议： > 如图所示，老师（MCU）将球（数据）传给众多学生中的一个（众多外设设备中的一个）。 > ![](https://img-blog.csdnimg.cn/20210517150259595.png?x-oss-proce
I2C设备的创建
qwaszx523的博客
06-28 1622
在引入设备树前后，I2C设备创建的方式是不同的，但有一点都是相同的，都是在I2C总线控制器驱动执行probe函数时进行创建。 下面就先看一下I2C总线控制器驱动执行probe函数，省略无关部分，代码如下： static int i2c_bus_probe(struct platform_device *dev) { //引入设备树之前 ret = i2c_add_numbered_adapte
Linux里SPI与I2C创建设备的流程
但是博客很漂亮
01-17 2965
Soc里怎么知道设备的存在？ 我高中的时候就曾想过，Windows怎么知道我电脑上有什么硬件呢？后来刚接触驱动这一块时，被Soc上设备的创建困惑了好一阵子。当然现在看起来已经清晰不少了。Linux下的SPI与I2C算是轻量级框架了，是去熟悉Linux驱动模型一个不错的切入点。当初在学校尽去关心操作系统的实现而无视驱动开发这一块，后来找工作时才发现，满大街招的都是搞驱动的。于是转回去熟悉Linux的
linux i2c adapter 增加设备_LINUX I2C-dev字符设备及通信接口分析（I2C部分分析之五）...
weixin_39553352的博客
11-28 308
前面几章基本上完成了i2c 设备、驱动、总线等几个模块的分析，本章我们主要说下i2c通信接口以及i2c 字符设备(准确的说是注册到i2c总线上的adapter设备对应的字符设备)。本篇内容主要包括：i2c通信接口i2c 字符设备相关内容i2c通信接口在之前的分析中，我们也知道cpu需要通过i2c adapter的方法与i2c client进行通信。而i2c模块也为此抽象出了cpu与i2c clie...
linux驱动之--fops的关联
jingema1的专栏
06-20 1276
1.各种驱动形式不过是表象，本质还是把fops注册到inode中。 2.一直没有找到确实的“证据”不过还是有点线索的：device_create->device_create_vargs->                                  dev_set_drvdata(dev, drvdata)把fops设置到了dev->p->driver_data中       
linux i2c设备 创建文件节点
06-11
在 Linux 中，可以通过 i2c-tools 工具包中的 i2cdetect 命令扫描 i2c 总线上的设备地址，以确定设备的地址。然后，可以使用 i2c-dev 模块创建...现在，就可以访问 i2c 设备节点 `/dev/myi2c`，与 i2c 设备进行通信了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值