devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Zynq-Linux移植学习笔记之31-用户自定义I2C驱动

作者：小蓝xlanll | 2024-06-13 13:47:10

赞

踩

Zynq-Linux移植学习笔记之31-用户自定义I2C驱动

1、背景介绍

板子上通过ZYNQ的I2C-0控制器连接了三片DBF芯片和一片Ti的226测功耗芯片，示意图如下：

如上图所示，三块DBF芯片的I2C地址分别为2,4,8,Ti 226芯片的I2C地址为0x40.现在需要ZYNQ通过I2C总线读写这四块芯片的寄存器数值。

 

2、I2C时序说明

之前调试过cps1848 RapidIO交换芯片，想来既然都是i2c从设备，知道了slave的地址操作过程应该差不多，不过真正调试的时候才发现虽然这些设备都遵循I2C协议，但在i2c的读写时序上还是存在不同，下面将cps1848与dbf的i2c读写时序进行对比，Ti 226的类似。

以上是从1848 datasheet中摘录出的i2c读写时序图，之前调试时采用的是7位地址，即后面两个图。

从图中可以得知，读操作时i2c master先发slave地址(加start共8bit)，再发要读写的空间地址(即寄存器offset，共24bit)，这两个部分组成第一个message.后一个message包括slave地址(8bit)和接收数据的缓冲区(32bit)。完成整个操作后表示读结束。对应代码如下：

Msgbuf即对应offset，共24bit，msg即为上面提到的message，调用i2c_transfer()发送两个msg正好匹配1848的读时序图。

再来看写操作，先是一个slave地址(8bit),再24bit偏移量，然后是待写入的32bit共同组成一个message.代码如下：

从代码中可以看到，这里把要写入的数据和长度都放入msgbuf中，前面加上24bit offset，最后组装为一个msg发送出去。

搞清楚了i2c读写时序，针对不同芯片只需要根据datasheet时序关系进行代码修改即可，dbf芯片读写时序如下

DBF芯片也支持7地址和10地址操作，显然这里选择7地址改动最小。和1848相比，这里的读操作是先8bit地址，然后8bit要读的数据长度，再8bit offset。通常要读的数据为32bit，所以NUM这里设为固定值0x04，代码改动如下：

要调整的地方就是msgbuf大小变为16bit，内容调整，msg[0]的len也设为2.

写操作也类似调整，代码如下：

Ti 226芯片也根据datasheet修改即可，这里不加赘述。

 

3、内核配置

将DBF驱动代码和226驱动代码编译进内核即可，这里图省事直接obj-y，dbf驱动名称忘了改，沿用1848了。

代码分别如下

  1. /*
  2.  * CPS1848 bus driver
  3.  *
  4.  * Copyright (C) 2014 CGT Corp.
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; version 2 of the License.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18.  *
  19.  */
  20.  
  21. #define DEBUG
  22.  
  23. #include <linux/kernel.h>
  24. #include <linux/module.h>
  25. #include <linux/slab.h>
  26. #include <linux/i2c.h>
  27. #include <linux/mutex.h>
  28. #include <linux/delay.h>
  29.  
  30. #include <linux/serial_core.h>
  31.  
  32. /* Each client has this additional data */
  33. #define USER_EEPROM_SIZE	0xFFFF48
  34. #define USER_XFER_MAX_COUNT	0x8
  35.  
  36. /* Addresses to scan */
  37. static const unsigned short cps1848_i2c[] = { 0x3, I2C_CLIENT_END };
  38.  
  39. static unsigned read_timeout = 25;
  40. module_param(read_timeout, uint, 0);
  41. MODULE_PARM_DESC(read_timeout, "Time (in ms) to try reads (default 25)");
  42.  
  43. static unsigned write_timeout = 25;
  44. module_param(write_timeout, uint, 0);
  45. MODULE_PARM_DESC(write_timeout, "Time (in ms) to try writes (default 25)");
  46.  
  47. struct cps1848_data {
  48. 	struct mutex	lock;
  49. 	u8	*data;
  50. };
  51.  
  52. static ssize_t cps1848_eeprom_read( struct i2c_client *client,
  53. 	char *buf, unsigned offset, size_t count)
  54. {
  55. 	struct i2c_msg msg[2];
  56. 	u8 msgbuf[4];
  57. 	unsigned long timeout, transfer_time;
  58. 	int status;
  59.  
  60. 	memset(msg, 0, sizeof(msg));
  61.  
  62. 	//msgbuf[0] = (u8)((offset >> 18) & 0x3f);
  63. 	//msgbuf[1] = (u8)((offset >> 10) & 0xff);
  64. 	//msgbuf[2] = (u8)((offset >>  2) & 0xff);
  65.  
  66. 	msgbuf[0] = 0x04;
  67. 	msgbuf[1] = 0x00;
  68.  
  69. 	msg[0].addr = client->addr;
  70. 	msg[0].buf = msgbuf;
  71. 	msg[0].len = 2;
  72.  
  73. 	msg[1].addr = client->addr;
  74. 	msg[1].flags = I2C_M_RD;
  75. 	msg[1].buf = buf;
  76. 	msg[1].len = count;
  77.  
  78. 	/*
  79. 	 * Reads fail if the previous write didn't complete yet. We may
  80. 	 * loop a few times until this one succeeds, waiting at least
  81. 	 * long enough for one entire page write to work.
  82. 	 */
  83. 	timeout = jiffies + msecs_to_jiffies(read_timeout);
  84. 	do {
  85. 		transfer_time = jiffies;
  86.  
  87. 		status = i2c_transfer(client->adapter, msg, 2);
  88.  
  89. 		if (status == 2)
  90. 			status = count;
  91.  
  92. 		dev_dbg(&client->dev, "read %ld@0x%lx --> %d (%ld)\n",
  93. 				count, (unsigned long)offset, status, jiffies);
  94.  
  95. 		if (status == count)
  96. 			return count;
  97.  
  98. 		/* REVISIT: at HZ=100, this is sloooow */
  99. 		msleep(1);
  100. 	} while (time_before(transfer_time, timeout));
  101.  
  102. 	return -ETIMEDOUT;
  103.  
  104.  }
  105.  
  106.  
  107. static ssize_t cps1848_read(struct file *filp, struct kobject *kobj,
  108. 			    struct bin_attribute *bin_attr,
  109. 			    char *buf, loff_t offset, size_t count)
  110. {
  111. 	struct i2c_client *client = kobj_to_i2c_client(kobj);
  112. 	struct cps1848_data *data = i2c_get_clientdata(client);
  113.  
  114. 	ssize_t retval = 0;
  115.  
  116. 	if (offset > USER_EEPROM_SIZE)
  117. 		return 0;
  118.  
  119. 	if (offset + count > USER_EEPROM_SIZE)
  120. 		count = USER_EEPROM_SIZE - offset;
  121.  
  122. 	mutex_lock(&data->lock);
  123.  
  124. 	dev_dbg(&client->dev, "cps1848 start read %ld@0x%lx ..\n", count, (unsigned long)offset);
  125.  
  126. 	while (count > 0) {
  127. 		ssize_t	status = count>USER_XFER_MAX_COUNT?USER_XFER_MAX_COUNT:count;
  128. 		status = cps1848_eeprom_read(client, buf, offset, status);
  129. 		if (status <= 0) {
  130. 			if (retval == 0)
  131. 				retval = status;
  132. 			break;
  133. 		}
  134. 		buf += status;
  135. 		offset += status;
  136. 		count -= status;
  137. 		retval += status;
  138. 	}
  139.  
  140. 	dev_dbg(&client->dev, "cps1848 end read %ld@0x%lx  !\n", retval, (unsigned long)offset);
  141.  
  142. 	mutex_unlock(&data->lock);
  143.  
  144. 	return retval;
  145.  
  146.  }
  147.  
  148. static ssize_t cps1848_eeprom_write(
  149. 	struct i2c_client *client,
  150. 	struct cps1848_data *data,
  151. 	char *buf, unsigned offset, size_t count)
  152. {
  153. 	struct i2c_msg msg[1];
  154. 	u8 *msgbuf;
  155. 	unsigned long timeout, transfer_time;
  156. 	int status;
  157.  
  158. 	memset(msg, 0, sizeof(msg));
  159.  
  160. 	msgbuf = data->data;
  161.  
  162. //	msgbuf[0] = (u8)((offset >> 18) & 0x3f);
  163. //	msgbuf[1] = (u8)((offset >> 10) & 0xff);
  164. //	msgbuf[2] = (u8)((offset >>  2) & 0xff);
  165.  
  166. 	msgbuf[0] = 0x04;
  167. 	msgbuf[1] = 0x00;
  168.  
  169. 	memcpy(msgbuf+2, buf, count);
  170.  
  171. 	msg[0].addr = client->addr;
  172. 	msg[0].buf = msgbuf;
  173. 	msg[0].len = 2 + count;
  174.  
  175. 	/*
  176. 	 * Reads fail if the previous write didn't complete yet. We may
  177. 	 * loop a few times until this one succeeds, waiting at least
  178. 	 * long enough for one entire page write to work.
  179. 	 */
  180. 	timeout = jiffies + msecs_to_jiffies(write_timeout);
  181. 	do {
  182. 		transfer_time = jiffies;
  183.  
  184. 		status = i2c_transfer(client->adapter, msg, 1);
  185.  
  186. 		if (status == 1)
  187. 			status = count;
  188.  
  189. 		dev_dbg(&client->dev, "write %ld@0x%lx --> %d (%ld)\n",
  190. 				count, (unsigned long)offset, status, jiffies);
  191.  
  192. 		if (status == count)
  193. 			return count;
  194.  
  195. 		/* REVISIT: at HZ=100, this is sloooow */
  196. 		msleep(1);
  197. 	} while (time_before(transfer_time, timeout));
  198.  
  199. 	return -ETIMEDOUT;
  200.  }
  201.  
  202. static ssize_t cps1848_write(struct file *filp, struct kobject *kobj,
  203. 			    struct bin_attribute *bin_attr,
  204. 			    char *buf, loff_t offset, size_t count)
  205. {
  206. 	struct i2c_client *client = kobj_to_i2c_client(kobj);
  207. 	struct cps1848_data *data = i2c_get_clientdata(client);
  208.  
  209. 	ssize_t retval = 0;
  210.  
  211. 	if (offset > USER_EEPROM_SIZE)
  212. 		return 0;
  213.  
  214. 	if (offset + count > USER_EEPROM_SIZE)
  215. 		count = USER_EEPROM_SIZE - offset;
  216.  
  217. 	mutex_lock(&data->lock);
  218.  
  219. 	dev_dbg(&client->dev, "cps1848 start write %ld@0x%lx ..\n", count, (unsigned long)offset);
  220.  
  221. 	while (count > 0) {
  222. 		ssize_t	status = count>USER_XFER_MAX_COUNT?USER_XFER_MAX_COUNT:count;
  223. 		status = cps1848_eeprom_write(client, data, buf, offset, status);
  224. 		if (status <= 0) {
  225. 			if (retval == 0)
  226. 				retval = status;
  227. 			break;
  228. 		}
  229. 		buf += status;
  230. 		offset += status;
  231. 		count -= status;
  232. 		retval += status;
  233. 	}
  234.  
  235. 	dev_dbg(&client->dev, "cps1848 end write %ld@0x%lx  !\n", retval, (unsigned long)offset);
  236.  
  237. 	mutex_unlock(&data->lock);
  238.  
  239. 	return retval;
  240.  
  241.  }
  242.  
  243. static struct bin_attribute user_eeprom_attr = {
  244. 	.attr = {
  245. 		.name = "eeprom",
  246. 		.mode = (S_IRUSR | S_IWUSR),
  247. 	},
  248. 	.size = USER_EEPROM_SIZE,
  249. 	.read = cps1848_read,
  250. 	.write = cps1848_write,
  251. };
  252.  
  253. /* Return 0 if detection is successful, -ENODEV otherwise */
  254. static int cps1848_detect(struct i2c_client *client, struct i2c_board_info *info)
  255. {
  256. 	struct i2c_adapter *adapter = client->adapter;
  257.  
  258. 	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
  259. 		dev_dbg(&client->dev, "cps1848 detect error for BYTE access !\n");
  260. 		return -ENODEV;
  261. 	}
  262.  
  263. 	strlcpy(info->type, "eeprom", I2C_NAME_SIZE);
  264.  
  265. 	return 0;
  266.  }
  267.  
  268. static int cps1848_probe(struct i2c_client *client,
  269. 			 const struct i2c_device_id *id)
  270. {
  271. 	struct i2c_adapter *adapter = client->adapter;
  272. 	struct cps1848_data *data;
  273. 	int err ;
  274.  
  275. 	dev_notice(&client->dev, "CPS1848 driver\n" );
  276.  
  277. 	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
  278. 		dev_err(&client->dev, "CPS1848 driver:  BYTE DATA not supported! \n" );
  279. 		return -ENODEV;
  280. 	}
  281.  
  282. 	if (!(data = kzalloc(sizeof(struct cps1848_data), GFP_KERNEL))) {
  283. 		dev_err(&client->dev, "CPS1848 driver:  Memory alloc error ! \n" );
  284. 		return -ENOMEM;
  285. 	}
  286.  
  287. 	/* alloc buffer */
  288. 	data->data = devm_kzalloc(&client->dev, USER_XFER_MAX_COUNT + 8, GFP_KERNEL);
  289. 	if (!data->data) {
  290. 		dev_err(&client->dev, "CPS1848 driver:  Memory alloc error ! \n" );
  291. 		err = -ENOMEM;
  292. 		goto exit_kfree;
  293. 	}
  294.  
  295. 	/* Init real i2c_client */
  296. 	i2c_set_clientdata(client, data);
  297. 	mutex_init(&data->lock);
  298.  
  299. 	err = sysfs_create_bin_file(&client->dev.kobj, &user_eeprom_attr);
  300. 	if (err) {
  301. 		dev_err(&client->dev, "CPS1848 driver:  sysfs create error ! \n" );
  302. 		goto exit_kfree;
  303. 	}
  304.  
  305. 	return 0;
  306.  
  307. exit_kfree:
  308. 	if(data->data)
  309. 		kfree(data->data);
  310. 	kfree(data);
  311. 	return err;
  312.  }
  313.  
  314. static int cps1848_remove(struct i2c_client *client)
  315. {
  316. 	struct cps1848_data *data = i2c_get_clientdata(client);
  317.  
  318. 	sysfs_remove_bin_file(&client->dev.kobj, &user_eeprom_attr);
  319. 	if(data->data)
  320. 		kfree(data->data);
  321. 	kfree(data);
  322.  
  323. 	return 0;
  324.  }
  325.  
  326. static const struct i2c_device_id cps1848_id[] = {
  327. 	{ "cps1848", 0 },
  328. 	{ }
  329. };
  330. MODULE_DEVICE_TABLE(i2c, cps1848_id);
  331.  
  332. static struct i2c_driver cps1848_driver = {
  333. 	.driver = {
  334. 		.name	= "cps1848",
  335. 	},
  336. 	.probe		= cps1848_probe,
  337. 	.remove		= cps1848_remove,
  338. 	.id_table	= cps1848_id,
  339.  
  340. 	.class		= I2C_CLASS_SPD,
  341. 	.detect		= cps1848_detect,
  342. 	.address_list	= cps1848_i2c,
  343. };
  344.  
  345. module_i2c_driver(cps1848_driver);
  346.  
  347. MODULE_AUTHOR("RobinLee");
  348. MODULE_DESCRIPTION("CPS1848 driver");
  349. MODULE_LICENSE("GPL");
  1. /*
  2.  * cps226 bus driver
  3.  *
  4.  * Copyright (C) 2014 CGT Corp.
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; version 2 of the License.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18.  *
  19.  */
  20.  
  21. #define DEBUG
  22.  
  23. #include <linux/kernel.h>
  24. #include <linux/module.h>
  25. #include <linux/slab.h>
  26. #include <linux/i2c.h>
  27. #include <linux/mutex.h>
  28. #include <linux/delay.h>
  29.  
  30. #include <linux/serial_core.h>
  31.  
  32. /* Each client has this additional data */
  33. #define USER_EEPROM_SIZE	0xFFFF48
  34. #define USER_XFER_MAX_COUNT	0x8
  35.  
  36. /* Addresses to scan */
  37. static const unsigned short cps226_i2c[] = { 0x3, I2C_CLIENT_END };
  38.  
  39. static unsigned read_timeout = 25;
  40. module_param(read_timeout, uint, 0);
  41. MODULE_PARM_DESC(read_timeout, "Time (in ms) to try reads (default 25)");
  42.  
  43. static unsigned write_timeout = 25;
  44. module_param(write_timeout, uint, 0);
  45. MODULE_PARM_DESC(write_timeout, "Time (in ms) to try writes (default 25)");
  46.  
  47. struct cps226_data {
  48. 	struct mutex	lock;
  49. 	u8	*data;
  50. };
  51.  
  52. static ssize_t cps226_eeprom_read( struct i2c_client *client,
  53. 	char *buf, unsigned offset, size_t count)
  54. {
  55. 	struct i2c_msg msg[2];
  56. 	u8 msgbuf[4];
  57. 	unsigned long timeout, transfer_time;
  58. 	int status;
  59.  
  60. 	memset(msg, 0, sizeof(msg));
  61.  
  62. 	msgbuf[0] = (u8)(offset & 0xff);
  63.  
  64.  
  65. 	msg[0].addr = client->addr;
  66. 	msg[0].buf = msgbuf;
  67. 	msg[0].len = 1;
  68.  
  69. 	msg[1].addr = client->addr;
  70. 	msg[1].flags = I2C_M_RD;
  71. 	msg[1].buf = buf;
  72. 	msg[1].len = count;
  73.  
  74. 	/*
  75. 	 * Reads fail if the previous write didn't complete yet. We may
  76. 	 * loop a few times until this one succeeds, waiting at least
  77. 	 * long enough for one entire page write to work.
  78. 	 */
  79. 	timeout = jiffies + msecs_to_jiffies(read_timeout);
  80. 	do {
  81. 		transfer_time = jiffies;
  82.  
  83. 		status = i2c_transfer(client->adapter, msg, 2);
  84.  
  85. 		if (status == 2)
  86. 			status = count;
  87.  
  88. 		dev_dbg(&client->dev, "read %ld@0x%lx --> %d (%ld)\n",
  89. 				count, (unsigned long)offset, status, jiffies);
  90.  
  91. 		if (status == count)
  92. 			return count;
  93.  
  94. 		/* REVISIT: at HZ=100, this is sloooow */
  95. 		msleep(1);
  96. 	} while (time_before(transfer_time, timeout));
  97.  
  98. 	return -ETIMEDOUT;
  99.  
  100.  }
  101.  
  102.  
  103. static ssize_t cps226_read(struct file *filp, struct kobject *kobj,
  104. 			    struct bin_attribute *bin_attr,
  105. 			    char *buf, loff_t offset, size_t count)
  106. {
  107. 	struct i2c_client *client = kobj_to_i2c_client(kobj);
  108. 	struct cps226_data *data = i2c_get_clientdata(client);
  109.  
  110. 	ssize_t retval = 0;
  111.  
  112. 	if (offset > USER_EEPROM_SIZE)
  113. 		return 0;
  114.  
  115. 	if (offset + count > USER_EEPROM_SIZE)
  116. 		count = USER_EEPROM_SIZE - offset;
  117.  
  118. 	mutex_lock(&data->lock);
  119.  
  120. 	dev_dbg(&client->dev, "cps226 start read %ld@0x%lx ..\n", count, (unsigned long)offset);
  121.  
  122. 	while (count > 0) {
  123. 		ssize_t	status = count>USER_XFER_MAX_COUNT?USER_XFER_MAX_COUNT:count;
  124. 		status = cps226_eeprom_read(client, buf, offset, status);
  125. 		if (status <= 0) {
  126. 			if (retval == 0)
  127. 				retval = status;
  128. 			break;
  129. 		}
  130. 		buf += status;
  131. 		offset += status;
  132. 		count -= status;
  133. 		retval += status;
  134. 	}
  135.  
  136. 	dev_dbg(&client->dev, "cps226 end read %ld@0x%lx  !\n", retval, (unsigned long)offset);
  137.  
  138. 	mutex_unlock(&data->lock);
  139.  
  140. 	return retval;
  141.  
  142.  }
  143.  
  144. static ssize_t cps226_eeprom_write(
  145. 	struct i2c_client *client,
  146. 	struct cps226_data *data,
  147. 	char *buf, unsigned offset, size_t count)
  148. {
  149. 	struct i2c_msg msg[1];
  150. 	u8 *msgbuf;
  151. 	unsigned long timeout, transfer_time;
  152. 	int status;
  153.  
  154. 	memset(msg, 0, sizeof(msg));
  155.  
  156. 	msgbuf = data->data;
  157.  
  158. //	msgbuf[0] = (u8)((offset >> 18) & 0x3f);
  159. //	msgbuf[1] = (u8)((offset >> 10) & 0xff);
  160. //	msgbuf[2] = (u8)((offset >>  2) & 0xff);
  161.  
  162. 	msgbuf[0] = (u8)(offset & 0xff);
  163.  
  164. 	memcpy(msgbuf+1, buf, count);
  165.  
  166. 	msg[0].addr = client->addr;
  167. 	msg[0].buf = msgbuf;
  168. 	msg[0].len = 1 + count;
  169.  
  170. 	/*
  171. 	 * Reads fail if the previous write didn't complete yet. We may
  172. 	 * loop a few times until this one succeeds, waiting at least
  173. 	 * long enough for one entire page write to work.
  174. 	 */
  175. 	timeout = jiffies + msecs_to_jiffies(write_timeout);
  176. 	do {
  177. 		transfer_time = jiffies;
  178.  
  179. 		status = i2c_transfer(client->adapter, msg, 1);
  180.  
  181. 		if (status == 1)
  182. 			status = count;
  183.  
  184. 		dev_dbg(&client->dev, "write %ld@0x%lx --> %d (%ld)\n",
  185. 				count, (unsigned long)offset, status, jiffies);
  186.  
  187. 		if (status == count)
  188. 			return count;
  189.  
  190. 		/* REVISIT: at HZ=100, this is sloooow */
  191. 		msleep(1);
  192. 	} while (time_before(transfer_time, timeout));
  193.  
  194. 	return -ETIMEDOUT;
  195.  }
  196.  
  197. static ssize_t cps226_write(struct file *filp, struct kobject *kobj,
  198. 			    struct bin_attribute *bin_attr,
  199. 			    char *buf, loff_t offset, size_t count)
  200. {
  201. 	struct i2c_client *client = kobj_to_i2c_client(kobj);
  202. 	struct cps226_data *data = i2c_get_clientdata(client);
  203.  
  204. 	ssize_t retval = 0;
  205.  
  206. 	if (offset > USER_EEPROM_SIZE)
  207. 		return 0;
  208.  
  209. 	if (offset + count > USER_EEPROM_SIZE)
  210. 		count = USER_EEPROM_SIZE - offset;
  211.  
  212. 	mutex_lock(&data->lock);
  213.  
  214. 	dev_dbg(&client->dev, "cps226 start write %ld@0x%lx ..\n", count, (unsigned long)offset);
  215.  
  216. 	while (count > 0) {
  217. 		ssize_t	status = count>USER_XFER_MAX_COUNT?USER_XFER_MAX_COUNT:count;
  218. 		status = cps226_eeprom_write(client, data, buf, offset, status);
  219. 		if (status <= 0) {
  220. 			if (retval == 0)
  221. 				retval = status;
  222. 			break;
  223. 		}
  224. 		buf += status;
  225. 		offset += status;
  226. 		count -= status;
  227. 		retval += status;
  228. 	}
  229.  
  230. 	dev_dbg(&client->dev, "cps226 end write %ld@0x%lx  !\n", retval, (unsigned long)offset);
  231.  
  232. 	mutex_unlock(&data->lock);
  233.  
  234. 	return retval;
  235.  
  236.  }
  237.  
  238. static struct bin_attribute user_eeprom_attr = {
  239. 	.attr = {
  240. 		.name = "eeprom",
  241. 		.mode = (S_IRUSR | S_IWUSR),
  242. 	},
  243. 	.size = USER_EEPROM_SIZE,
  244. 	.read = cps226_read,
  245. 	.write = cps226_write,
  246. };
  247.  
  248. /* Return 0 if detection is successful, -ENODEV otherwise */
  249. static int cps226_detect(struct i2c_client *client, struct i2c_board_info *info)
  250. {
  251. 	struct i2c_adapter *adapter = client->adapter;
  252.  
  253. 	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
  254. 		dev_dbg(&client->dev, "cps226 detect error for BYTE access !\n");
  255. 		return -ENODEV;
  256. 	}
  257.  
  258. 	strlcpy(info->type, "eeprom", I2C_NAME_SIZE);
  259.  
  260. 	return 0;
  261.  }
  262.  
  263. static int cps226_probe(struct i2c_client *client,
  264. 			 const struct i2c_device_id *id)
  265. {
  266. 	struct i2c_adapter *adapter = client->adapter;
  267. 	struct cps226_data *data;
  268. 	int err ;
  269.  
  270. 	dev_notice(&client->dev, "cps226 driver\n" );
  271.  
  272. 	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
  273. 		dev_err(&client->dev, "cps226 driver:  BYTE DATA not supported! \n" );
  274. 		return -ENODEV;
  275. 	}
  276.  
  277. 	if (!(data = kzalloc(sizeof(struct cps226_data), GFP_KERNEL))) {
  278. 		dev_err(&client->dev, "cps226 driver:  Memory alloc error ! \n" );
  279. 		return -ENOMEM;
  280. 	}
  281.  
  282. 	/* alloc buffer */
  283. 	data->data = devm_kzalloc(&client->dev, USER_XFER_MAX_COUNT + 8, GFP_KERNEL);
  284. 	if (!data->data) {
  285. 		dev_err(&client->dev, "cps226 driver:  Memory alloc error ! \n" );
  286. 		err = -ENOMEM;
  287. 		goto exit_kfree;
  288. 	}
  289.  
  290. 	/* Init real i2c_client */
  291. 	i2c_set_clientdata(client, data);
  292. 	mutex_init(&data->lock);
  293.  
  294. 	err = sysfs_create_bin_file(&client->dev.kobj, &user_eeprom_attr);
  295. 	if (err) {
  296. 		dev_err(&client->dev, "cps226 driver:  sysfs create error ! \n" );
  297. 		goto exit_kfree;
  298. 	}
  299.  
  300. 	return 0;
  301.  
  302. exit_kfree:
  303. 	if(data->data)
  304. 		kfree(data->data);
  305. 	kfree(data);
  306. 	return err;
  307.  }
  308.  
  309. static int cps226_remove(struct i2c_client *client)
  310. {
  311. 	struct cps226_data *data = i2c_get_clientdata(client);
  312.  
  313. 	sysfs_remove_bin_file(&client->dev.kobj, &user_eeprom_attr);
  314. 	if(data->data)
  315. 		kfree(data->data);
  316. 	kfree(data);
  317.  
  318. 	return 0;
  319.  }
  320.  
  321. static const struct i2c_device_id cps226_id[] = {
  322. 	{ "cps226", 0 },
  323. 	{ }
  324. };
  325. MODULE_DEVICE_TABLE(i2c, cps226_id);
  326.  
  327. static struct i2c_driver cps226_driver = {
  328. 	.driver = {
  329. 		.name	= "cps226",
  330. 	},
  331. 	.probe		= cps226_probe,
  332. 	.remove		= cps226_remove,
  333. 	.id_table	= cps226_id,
  334.  
  335. 	.class		= I2C_CLASS_SPD,
  336. 	.detect		= cps226_detect,
  337. 	.address_list	= cps226_i2c,
  338. };
  339.  
  340. module_i2c_driver(cps226_driver);
  341.  
  342. MODULE_AUTHOR("RobinLee");
  343. MODULE_DESCRIPTION("cps226 driver");
  344. MODULE_LICENSE("GPL");

4、devicetree配置

devicetree中需要配置四个从设备的地址，如下，dbf名称懒得改了：

  1. /dts-v1/;
  2.  
  3. / {
  4. 	#address-cells = <0x1>;
  5. 	#size-cells = <0x1>;
  6. 	compatible = "xlnx,zynq-7000";
  7.  
  8. 	cpus {
  9. 		#address-cells = <0x1>;
  10. 		#size-cells = <0x0>;
  11.  
  12. 		cpu@0 {
  13. 			compatible = "arm,cortex-a9";
  14. 			device_type = "cpu";
  15. 			reg = <0x0>;
  16. 			clocks = <0x1 0x3>;
  17. 			clock-latency = <0x3e8>;
  18. 			cpu0-supply = <0x2>;
  19. 			operating-points = <0xa4cb8 0xf4240 0x5265c 0xf4240>;
  20. 		};
  21.  
  22. 		cpu@1 {
  23. 			compatible = "arm,cortex-a9";
  24. 			device_type = "cpu";
  25. 			reg = <0x1>;
  26. 			clocks = <0x1 0x3>;
  27. 		};
  28. 	};
  29.  
  30. 	fpga-full {
  31. 		compatible = "fpga-region";
  32. 		fpga-mgr = <0x3>;
  33. 		#address-cells = <0x1>;
  34. 		#size-cells = <0x1>;
  35. 		ranges;
  36. 	};
  37.  
  38. 	pmu@f8891000 {
  39. 		compatible = "arm,cortex-a9-pmu";
  40. 		interrupts = <0x0 0x5 0x4 0x0 0x6 0x4>;
  41. 		interrupt-parent = <0x4>;
  42. 		reg = <0xf8891000 0x1000 0xf8893000 0x1000>;
  43. 	};
  44.  
  45. 	fixedregulator {
  46. 		compatible = "regulator-fixed";
  47. 		regulator-name = "VCCPINT";
  48. 		regulator-min-microvolt = <0xf4240>;
  49. 		regulator-max-microvolt = <0xf4240>;
  50. 		regulator-boot-on;
  51. 		regulator-always-on;
  52. 		linux,phandle = <0x2>;
  53. 		phandle = <0x2>;
  54. 	};
  55.  
  56. 	amba {
  57. 		u-boot,dm-pre-reloc;
  58. 		compatible = "simple-bus";
  59. 		#address-cells = <0x1>;
  60. 		#size-cells = <0x1>;
  61. 		interrupt-parent = <0x4>;
  62. 		ranges;
  63.  
  64. 		adc@f8007100 {
  65. 			compatible = "xlnx,zynq-xadc-1.00.a";
  66. 			reg = <0xf8007100 0x20>;
  67. 			interrupts = <0x0 0x7 0x4>;
  68. 			interrupt-parent = <0x4>;
  69. 			clocks = <0x1 0xc>;
  70.  
  71. 			xlnx,channels {
  72. 			    #address-cells = <1>;
  73. 			    #size-cells = <0>;
  74. 			    channel@0 {
  75. 				reg = <0>;
  76. 			    };
  77. 			    channel@1 {
  78. 				reg = <1>;
  79. 			    };
  80. 			    channel@2 {
  81. 				reg = <2>;
  82. 			    };
  83.  			    channel@3 {
  84. 				reg = <3>;
  85. 			    };
  86. 			    channel@4{
  87. 				reg = <4>;
  88. 			    };
  89. 			    channel@5{
  90. 				reg = <5>;
  91. 			    };
  92. 			    channel@6{
  93. 				reg = <6>;
  94. 			    };
  95. 			   channel@7{
  96. 				reg = <7>;
  97. 			    };
  98. 			    channel@8 {
  99. 				reg = <8>;
  100. 			    };
  101. 			    channel@9 {
  102. 				reg = <9>;
  103. 			    };
  104. 			    channel@a {
  105. 				reg = <0xa>;
  106. 			    };
  107. 		    	    channel@b {
  108. 				reg = <0xb>;
  109. 			    };
  110. 			    channel@c {
  111. 				reg = <0xc>;
  112. 			    };
  113. 			    channel@d {
  114. 				reg = <0xd>;
  115. 			    };
  116. 			    channel@e {
  117. 				reg = <0xe>;
  118. 			    };
  119.   			    channel@f {
  120. 				reg = <0xf>;
  121. 			    };
  122.   			    channel@10 {
  123. 				reg = <0x10>;
  124. 			    };
  125.         		};
  126. 		};
  127.  
  128.  
  129. 		gpio@e000a000 {
  130. 			compatible = "xlnx,zynq-gpio-1.0";
  131. 			#gpio-cells = <0x2>;
  132. 			clocks = <0x1 0x2a>;
  133. 			gpio-controller;
  134. 			interrupt-controller;
  135. 			#interrupt-cells = <0x2>;
  136. 			interrupt-parent = <0x4>;
  137. 			interrupts = <0x0 0x14 0x4>;
  138. 			reg = <0xe000a000 0x1000>;
  139. 		};
  140.  
  141. 		i2c@e0004000 {
  142. 			compatible = "cdns,i2c-r1p10";
  143. 			status = "okay";
  144. 			clocks = <0x1 0x26>;
  145. 			interrupt-parent = <0x4>;
  146. 			interrupts = <0x0 0x19 0x4>;
  147. 			reg = <0xe0004000 0x1000>;
  148. 			#address-cells = <0x1>;
  149. 			#size-cells = <0x0>;
  150. 			clock-frequency = <0x61a80>;
  151.  
  152. 			cps1848@2 {
  153. 				compatible = "cps1848";
  154. 				reg = <0x2>;
  155. 			};
  156.  
  157. 			cps1848@4 {
  158. 				compatible = "cps1848";
  159. 				reg = <0x4>;
  160. 			};
  161.  
  162. 			cps1848@8 {
  163. 				compatible = "cps1848";
  164. 				reg = <0x8>;
  165. 			};
  166.  
  167. 			cps226@40 {
  168. 				compatible = "cps226";
  169. 				reg = <0x40>;
  170. 			};
  171. 		};
  172.  
  173. 		i2c@e0005000 {
  174. 			compatible = "cdns,i2c-r1p10";
  175. 			status = "okay";
  176. 			clocks = <0x1 0x27>;
  177. 			interrupt-parent = <0x4>;
  178. 			interrupts = <0x0 0x30 0x4>;
  179. 			reg = <0xe0005000 0x1000>;
  180. 			#address-cells = <0x1>;
  181. 			#size-cells = <0x0>;
  182. 			clock-frequency = <0x61a80>;
  183. 		};
  184.  
  185. 		interrupt-controller@f8f01000 {
  186. 			compatible = "arm,cortex-a9-gic";
  187. 			#interrupt-cells = <0x3>;
  188. 			interrupt-controller;
  189. 			reg = <0xf8f01000 0x1000 0xf8f00100 0x100>;
  190. 			num_cpus = <0x2>;
  191. 			num_interrupts = <0x60>;
  192. 			linux,phandle = <0x4>;
  193. 			phandle = <0x4>;
  194. 		};
  195.  
  196. 		cache-controller@f8f02000 {
  197. 			compatible = "arm,pl310-cache";
  198. 			reg = <0xf8f02000 0x1000>;
  199. 			interrupts = <0x0 0x2 0x4>;
  200. 			arm,data-latency = <0x3 0x2 0x2>;
  201. 			arm,tag-latency = <0x2 0x2 0x2>;
  202. 			cache-unified;
  203. 			cache-level = <0x2>;
  204. 		};
  205.  
  206. 		memory-controller@f8006000 {
  207. 			compatible = "xlnx,zynq-ddrc-a05";
  208. 			reg = <0xf8006000 0x1000>;
  209. 		};
  210.  
  211. 		ocmc@f800c000 {
  212. 			compatible = "xlnx,zynq-ocmc-1.0";
  213. 			interrupt-parent = <0x4>;
  214. 			interrupts = <0x0 0x3 0x4>;
  215. 			reg = <0xf800c000 0x1000>;
  216. 		};
  217.  
  218. 		serial@e0000000 {
  219. 			compatible = "xlnx,xuartps", "cdns,uart-r1p8";
  220. 			status = "okay";
  221. 			clocks = <0x1 0x17 0x1 0x28>;
  222. 			clock-names = "uart_clk", "pclk";
  223. 			reg = <0xe0000000 0x1000>;
  224. 			interrupts = <0x0 0x1b 0x4>;
  225. 			device_type = "serial";
  226. 			port-number = <0x0>;
  227. 		};
  228.  
  229. 		spi@e0006000 {
  230. 			compatible = "xlnx,zynq-spi-r1p6";
  231. 			reg = <0xe0006000 0x1000>;
  232. 			status = "okay";
  233. 			interrupt-parent = <0x4>;
  234. 			interrupts = <0x0 0x1a 0x4>;
  235. 			clocks = <0x1 0x19 0x1 0x22>;
  236. 			clock-names = "ref_clk", "pclk";
  237. 			#address-cells = <0x1>;
  238. 			#size-cells = <0x0>;
  239. 			is-decoded-cs = <0x0>;
  240. 			num-cs = <0x3>;
  241. 		};
  242.  
  243. 		spi@e0007000 {
  244. 			compatible = "xlnx,zynq-spi-r1p6";
  245. 			reg = <0xe0007000 0x1000>;
  246. 			status = "okay";
  247. 			interrupt-parent = <0x4>;
  248. 			interrupts = <0x0 0x31 0x4>;
  249. 			clocks = <0x1 0x1a 0x1 0x23>;
  250. 			clock-names = "ref_clk", "pclk";
  251. 			#address-cells = <0x1>;
  252. 			#size-cells = <0x0>;
  253. 			is-decoded-cs = <0x0>;
  254. 			num-cs = <0x3>;
  255.  
  256. 			flash@0 {
  257. 				compatible = "micron,n25q128a11","jedec,spi-nor";
  258. 				reg = <0x1>;
  259. 				spi-max-frequency = <0x9EF21B0>;
  260. 				spi-tx-bus-width = <0x1>;
  261. 				spi-rx-bus-width = <0x1>;
  262. 				#address-cells = <0x1>;
  263. 				#size-cells = <0x1>;
  264.  
  265. 				partition@dbf {
  266. 					label = "spi-flash";
  267. 					reg = <0x0 0x1000000>;
  268. 				};
  269. 			};
  270. 		};
  271.  
  272. 		spi@e000d000 {
  273. 			clock-names = "ref_clk", "pclk";
  274. 			clocks = <0x1 0xa 0x1 0x2b>;
  275. 			compatible = "xlnx,zynq-qspi-1.0";
  276. 			status = "okay";
  277. 			interrupt-parent = <0x4>;
  278. 			interrupts = <0x0 0x13 0x4>;
  279. 			reg = <0xe000d000 0x1000>;
  280. 			#address-cells = <0x1>;
  281. 			#size-cells = <0x0>;
  282. 			is-dual = <0x1>;
  283. 			num-cs = <0x1>;
  284. 		};
  285.  
  286. 		ethernet@e000b000 {
  287. 			compatible = "xlnx,ps7-ethernet-1.00.a";
  288. 			reg = <0xe000b000 0x1000>;
  289. 			status = "okay";
  290. 			interrupt-parent = <0x3>;
  291. 			interrupts = <0x0 0x16 0x4>;
  292. 			clocks = <0x1 0xd 0x1 0x1e>;
  293. 			clock-names = "ref_clk", "aper_clk";
  294. 			#address-cells = <0x1>;
  295. 			#size-cells = <0x0>;
  296. 			enet-reset = <0x4 0x2f 0x0>;
  297. 			local-mac-address = [00 0a 35 00 00 00];
  298. 			phy-mode = "rgmii";
  299. 			phy-handle = <0x5>;
  300. 			xlnx,eth-mode = <0x1>;
  301. 			xlnx,has-mdio = <0x1>;
  302. 			xlnx,ptp-enet-clock = <0x69f6bcb>;
  303.  
  304. 			mdio {
  305. 				#address-cells = <0x1>;
  306. 				#size-cells = <0x0>;
  307.  
  308. 				phy@0 {
  309. 					compatible = "marvell,88e1111";
  310. 					device_type = "ethernet-phy";
  311. 					reg = <0x4>;
  312. 					linux,phandle = <0x7>;
  313. 					phandle = <0x7>;
  314. 				};
  315. 			};
  316. 		};
  317.  
  318. 		slcr@f8000000 {
  319. 			#address-cells = <0x1>;
  320. 			#size-cells = <0x1>;
  321. 			compatible = "xlnx,zynq-slcr", "syscon", "simple-mfd";
  322. 			reg = <0xf8000000 0x1000>;
  323. 			ranges;
  324. 			linux,phandle = <0x5>;
  325. 			phandle = <0x5>;
  326.  
  327. 			clkc@100 {
  328. 				#clock-cells = <0x1>;
  329. 				compatible = "xlnx,ps7-clkc";
  330. 				fclk-enable = <0x1>;
  331. 				clock-output-names = "armpll", "ddrpll", "iopll", "cpu_6or4x", "cpu_3or2x", "cpu_2x", "cpu_1x", "ddr2x", "ddr3x", "dci", "lqspi", "smc", "pcap", "gem0", "gem1", "fclk0", "fclk1", "fclk2", "fclk3", "can0", "can1", "sdio0", "sdio1", "uart0", "uart1", "spi0", "spi1", "dma", "usb0_aper", "usb1_aper", "gem0_aper", "gem1_aper", "sdio0_aper", "sdio1_aper", "spi0_aper", "spi1_aper", "can0_aper", "can1_aper", "i2c0_aper", "i2c1_aper", "uart0_aper", "uart1_aper", "gpio_aper", "lqspi_aper", "smc_aper", "swdt", "dbg_trc", "dbg_apb";
  332. 				reg = <0x100 0x100>;
  333. 				ps-clk-frequency = <0x2faf080>;
  334. 				linux,phandle = <0x1>;
  335. 				phandle = <0x1>;
  336. 			};
  337.  
  338. 			rstc@200 {
  339. 				compatible = "xlnx,zynq-reset";
  340. 				reg = <0x200 0x48>;
  341. 				#reset-cells = <0x1>;
  342. 				syscon = <0x5>;
  343. 			};
  344.  
  345. 			pinctrl@700 {
  346. 				compatible = "xlnx,pinctrl-zynq";
  347. 				reg = <0x700 0x200>;
  348. 				syscon = <0x5>;
  349. 			};
  350. 		};
  351.  
  352. 		dmac@f8003000 {
  353. 			compatible = "arm,pl330", "arm,primecell";
  354. 			reg = <0xf8003000 0x1000>;
  355. 			interrupt-parent = <0x4>;
  356. 			interrupt-names = "abort", "dma0", "dma1", "dma2", "dma3", "dma4", "dma5", "dma6", "dma7";
  357. 			interrupts = <0x0 0xd 0x4 0x0 0xe 0x4 0x0 0xf 0x4 0x0 0x10 0x4 0x0 0x11 0x4 0x0 0x28 0x4 0x0 0x29 0x4 0x0 0x2a 0x4 0x0 0x2b 0x4>;
  358. 			#dma-cells = <0x1>;
  359. 			#dma-channels = <0x8>;
  360. 			#dma-requests = <0x4>;
  361. 			clocks = <0x1 0x1b>;
  362. 			clock-names = "apb_pclk";
  363. 		};
  364.  
  365. 		devcfg@f8007000 {
  366. 			compatible = "xlnx,zynq-devcfg-1.0";
  367. 			interrupt-parent = <0x4>;
  368. 			interrupts = <0x0 0x8 0x4>;
  369. 			reg = <0xf8007000 0x100>;
  370. 			clocks = <0x1 0xc 0x1 0xf 0x1 0x10 0x1 0x11 0x1 0x12>;
  371. 			clock-names = "ref_clk", "fclk0", "fclk1", "fclk2", "fclk3";
  372. 			syscon = <0x5>;
  373. 			linux,phandle = <0x3>;
  374. 			phandle = <0x3>;
  375. 		};
  376.  
  377. 		efuse@f800d000 {
  378. 			compatible = "xlnx,zynq-efuse";
  379. 			reg = <0xf800d000 0x20>;
  380. 		};
  381.  
  382. 		timer@f8f00200 {
  383. 			compatible = "arm,cortex-a9-global-timer";
  384. 			reg = <0xf8f00200 0x20>;
  385. 			interrupts = <0x1 0xb 0x301>;
  386. 			interrupt-parent = <0x4>;
  387. 			clocks = <0x1 0x4>;
  388. 		};
  389.  
  390. 		timer@f8001000 {
  391. 			interrupt-parent = <0x4>;
  392. 			interrupts = <0x0 0xa 0x4 0x0 0xb 0x4 0x0 0xc 0x4>;
  393. 			compatible = "cdns,ttc";
  394. 			clocks = <0x1 0x6>;
  395. 			reg = <0xf8001000 0x1000>;
  396. 		};
  397.  
  398. 		timer@f8002000 {
  399. 			interrupt-parent = <0x4>;
  400. 			interrupts = <0x0 0x25 0x4 0x0 0x26 0x4 0x0 0x27 0x4>;
  401. 			compatible = "cdns,ttc";
  402. 			clocks = <0x1 0x6>;
  403. 			reg = <0xf8002000 0x1000>;
  404. 		};
  405.  
  406. 		timer@f8f00600 {
  407. 			interrupt-parent = <0x4>;
  408. 			interrupts = <0x1 0xd 0x301>;
  409. 			compatible = "arm,cortex-a9-twd-timer";
  410. 			reg = <0xf8f00600 0x20>;
  411. 			clocks = <0x1 0x4>;
  412. 		};
  413.  
  414. 		watchdog@f8005000 {
  415. 			clocks = <0x1 0x2d>;
  416. 			compatible = "cdns,wdt-r1p2";
  417. 			interrupt-parent = <0x4>;
  418. 			interrupts = <0x0 0x9 0x1>;
  419. 			reg = <0xf8005000 0x1000>;
  420. 			timeout-sec = <0xa>;
  421. 		};
  422. 	};
  423.  
  424. 	chosen {
  425. 		bootargs = "earlycon";
  426. 		stdout-path = "serial0:115200n8";
  427. 	};
  428.  
  429. 	aliases {
  430. 		ethernet0 = "/amba/ethernet@e000b000";
  431. 		serial0 = "/amba/serial@e0000000";
  432. 		spi0 = "/amba/spi@e000d000";
  433. 		spi1 = "/amba/spi@e0006000";
  434. 		spi2 = "/amba/spi@e0007000";
  435. 	};
  436.  
  437. 	memory {
  438. 		device_type = "memory";
  439. 		reg = <0x0 0x40000000>;
  440. 	};
  441. };

 

5、应用示例

应用可以参考1848那样提供读写寄存器接口函数，这里要注意数据高低位转换问题，是否需要使用htonl函数，不同的芯片要求不一样。

DBF芯片代码如下：

  1. /*
  2.  * cps1848.h
  3.  *
  4.  *  Created on: 2018年9月8日
  5.  *      Author: Administrator
  6.  */
  7.  
  8. #ifndef SRC_CPS1848_H_
  9. #define SRC_CPS1848_H_
  10.  
  11. int Init_1848();
  12. unsigned int get_1848_reg(int num,unsigned int offset);
  13. void set_1848_reg(int num,unsigned int offset, unsigned int data);
  14.  
  15.  
  16. #endif /* SRC_CPS1848_H_ */
  1. /*
  2.  * Copyright (c) 2016 CGT Co., Ltd.
  3.  *
  4.  * Authors: Robin Lee <lixiangbin@china-dsp.com>
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program;
  18.  *
  19.  */
  20.  
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <stdarg.h>
  24. #include <string.h>
  25. #include <memory.h>
  26.  
  27. #include <sys/types.h>
  28. #include <sys/stat.h>
  29. #include <sys/ioctl.h>
  30. #include <sys/poll.h>
  31. #include <sys/time.h>
  32. #include <sys/socket.h>
  33.  
  34. #include <fcntl.h>
  35. #include <errno.h>
  36. #include <pthread.h>
  37. #include <math.h>
  38. #include <unistd.h>
  39. #include <signal.h>
  40.  
  41. #include <termios.h>
  42. #include <netinet/in.h>
  43.  
  44. #include "cps1848.h"
  45.  
  46. /*---------------------------------------------------------------------------------------------------------------------------------------------------
  47.  * global vars
  48.  */
  49. #define FP_DEV_1 "/sys/class/i2c-dev/i2c-0/device/0-0002/eeprom"
  50. #define FP_DEV_2 "/sys/class/i2c-dev/i2c-0/device/0-0004/eeprom"
  51. #define FP_DEV_3 "/sys/class/i2c-dev/i2c-0/device/0-0008/eeprom"
  52.  
  53. static int global_fd_1 = -1;
  54. static int global_fd_2 = -1;
  55. static int global_fd_3 = -1;
  56.  
  57. //operations of cps1848
  58. int fd_initial(int num)
  59. {
  60.  
  61. 	int fd = -1;
  62.  
  63. 	/*
  64. 		Open modem device for reading and writing and not as controlling tty
  65. 		because we don't want to get killed if linenoise sends CTRL-C.
  66. 	*/
  67. 	if(num==0)
  68. 	{
  69. 		printf("Open '%s' .. ", FP_DEV_1);
  70. 		fd = open(FP_DEV_1, O_RDWR );
  71. 	}
  72. 	else if(num==1)
  73. 	{
  74. 		printf("Open '%s' .. ", FP_DEV_2);
  75. 		fd = open(FP_DEV_2, O_RDWR );
  76. 	}
  77. 	else if(num==2)
  78. 	{
  79. 		printf("Open '%s' .. ", FP_DEV_3);
  80. 		fd = open(FP_DEV_3, O_RDWR );
  81. 	}
  82. 	else
  83. 	{
  84. 		printf("Open error.\n");
  85. 		return -1;
  86. 	}
  87.  
  88. 	if (fd <0) {
  89. 		printf("failed (err = %d)\n", fd);
  90. 		return -1;
  91. 	}
  92.  
  93. 	printf("Done\n");
  94.  
  95. 	return fd;
  96. }
  97.  
  98. int fd_exit(int fd,int num)
  99. {
  100. 	if(num==1)
  101. 	{
  102. 		printf("Close '%s' .. ", FP_DEV_1);
  103. 	}
  104. 	else if(num==2)
  105. 	{
  106. 		printf("Close '%s' .. ", FP_DEV_2);
  107. 	}
  108. 	else
  109. 	{
  110. 		printf("Close '%s' .. ", FP_DEV_3);
  111. 	}
  112. 	close(fd);
  113.  
  114. 	printf("Done\n");
  115.  
  116. 	return 0;
  117. }
  118.  
  119. /*---------------------------------------------------------------------------------------------------------------------------------------------------
  120.  * get_1848_reg, set_1848_reg
  121.  */
  122. unsigned int get_1848_reg(int num,unsigned int offset)
  123. {
  124. 	unsigned int value = 0xffff;
  125. 	unsigned int ans=0;
  126. 	int fd=-1;
  127. 	if(num==0)
  128. 	{
  129. 		fd=global_fd_1;
  130. 	}
  131. 	else if(num==1)
  132. 	{
  133. 		fd=global_fd_2;
  134. 	}
  135. 	else if( num==2 )
  136. 	{
  137. 		fd=global_fd_3;
  138. 	}
  139. 	else
  140. 	{
  141. 		printf("get_dbf_reg::Invalid param !\n");
  142. 		return 0;
  143. 	}
  144.  
  145. 	if (fd<0) {
  146. 		printf("Invalid device handle !\n");
  147. 		return value;
  148. 	}
  149.  
  150. 	if( lseek(fd, offset, SEEK_SET) == (off_t) -1 ) {
  151. 		printf("failed for seek to offset 0x%x !\n", offset);
  152. 		return value;
  153. 	}
  154.  
  155. 	if ( read(fd, &value, sizeof(value)) != sizeof(value)) {
  156. 		printf("failed for read from offset 0x%x !\n", offset);
  157. 		return value;
  158. 	}
  159. 	//ans=htonl(value);
  160. 	return value;
  161. }
  162.  
  163. void set_1848_reg(int num,unsigned int offset, unsigned int data)
  164. {
  165. 	unsigned int value = data;
  166. 	int fd=-1;
  167. 	if(num==0)
  168. 	{
  169. 		fd=global_fd_1;
  170. 	}
  171. 	else if(num==1)
  172. 	{
  173. 		fd=global_fd_2;
  174. 	}
  175. 	else if( num==2 )
  176. 	{
  177. 		fd=global_fd_3;
  178. 	}
  179. 	else
  180. 	{
  181. 		printf("set_dbf_reg::Invalid param !\n");
  182. 		return;
  183. 	}
  184. 	if (fd<0) {
  185. 		printf("Invalid device handle !\n");
  186. 		return ;
  187. 	}
  188.  
  189. 	if( lseek(fd, offset, SEEK_SET) == (off_t) -1 ) {
  190. 		printf("failed for seek to offset 0x%x !\n", offset);
  191. 		return ;
  192. 	}
  193.  
  194. 	if ( write(fd, &value, sizeof(value)) != sizeof(value)) {
  195. //		printf("failed for write from offset 0x%x !\n", offset);
  196. 		return ;
  197. 	}
  198. 	return ;
  199. }
  200.  
  201. unsigned int regtoul(const char *str)
  202. {
  203. 	int cbase = 10;
  204. 	if(str[0]=='0'&&(str[1]=='x'||str[1]=='X')) {
  205. 		cbase = 16;
  206. 	}
  207. 	return strtoul(str, NULL, cbase);
  208. }
  209.  
  210. int Init_1848()
  211. {
  212. 		global_fd_1 = fd_initial(0);
  213. 		global_fd_2 = fd_initial(1);
  214. 		global_fd_3 = fd_initial(2);
  215. 		if (global_fd_1<0) {
  216. 			printf("\n Invalid First dbf device ! \n");
  217. 			return -1;
  218. 		}
  219. 		if (global_fd_2<0) {
  220. 			printf("\n Invalid Second dbf device ! \n");
  221. 			return -1;
  222. 		}
  223. 		if (global_fd_3<0) {
  224. 			printf("\n Invalid Third dbf device ! \n");
  225. 			return -1;
  226. 		}
  227. 		return 0;
  228. }
  229.  
  230.

Ti 226芯片读写接口如下

  1. /*
  2.  * cps1848.h
  3.  *
  4.  *  Created on: 2018年9月8日
  5.  *      Author: Administrator
  6.  */
  7.  
  8. #ifndef SRC_CPS226_H_
  9. #define SRC_CPS226_H_
  10.  
  11. int Init_226();
  12. unsigned int get_226_reg(unsigned int offset);
  13. void set_226_reg(unsigned int offset, unsigned int data);
  14.  
  15.  
  16. #endif /* SRC_CPS1848_H_ */
  1. /*
  2.  * Copyright (c) 2016 CGT Co., Ltd.
  3.  *
  4.  * Authors: Robin Lee <lixiangbin@china-dsp.com>
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program;
  18.  *
  19.  */
  20.  
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <stdarg.h>
  24. #include <string.h>
  25. #include <memory.h>
  26.  
  27. #include <sys/types.h>
  28. #include <sys/stat.h>
  29. #include <sys/ioctl.h>
  30. #include <sys/poll.h>
  31. #include <sys/time.h>
  32. #include <sys/socket.h>
  33.  
  34. #include <fcntl.h>
  35. #include <errno.h>
  36. #include <pthread.h>
  37. #include <math.h>
  38. #include <unistd.h>
  39. #include <signal.h>
  40.  
  41. #include <termios.h>
  42. #include <netinet/in.h>
  43.  
  44. #include "cps226.h"
  45.  
  46. /*---------------------------------------------------------------------------------------------------------------------------------------------------
  47.  * global vars
  48.  */
  49. #define FP_DEV "/sys/class/i2c-dev/i2c-0/device/0-0040/eeprom"
  50.  
  51.  
  52. static int global_fd = -1;
  53.  
  54. //operations of cps1848
  55. int fd_initial_226()
  56. {
  57. 	int fd = -1;
  58. 	/*
  59. 		Open modem device for reading and writing and not as controlling tty
  60. 		because we don't want to get killed if linenoise sends CTRL-C.
  61. 	*/
  62. 	printf("Open '%s' .. ", FP_DEV);
  63. 	fd = open(FP_DEV, O_RDWR );
  64.  
  65. 	if (fd <0) {
  66. 		printf("failed (err = %d)\n", fd);
  67. 		return -1;
  68. 	}
  69.  
  70. 	printf("Done\n");
  71.  
  72. 	return fd;
  73. }
  74.  
  75. int fd_exit_226(int fd)
  76. {
  77. 	close(fd);
  78. 	printf("Done\n");
  79.  
  80. 	return 0;
  81. }
  82.  
  83. /*---------------------------------------------------------------------------------------------------------------------------------------------------
  84.  * get_1848_reg, set_1848_reg
  85.  */
  86. unsigned int get_226_reg(unsigned int offset)
  87. {
  88. 	unsigned int value = 0xffff;
  89. 	unsigned int ans=0;
  90. 	int fd=-1;
  91. 	fd=global_fd;
  92.  
  93. 	if (fd<0) {
  94. 		printf("Invalid device handle !\n");
  95. 		return value;
  96. 	}
  97.  
  98. 	if( lseek(fd, offset, SEEK_SET) == (off_t) -1 ) {
  99. 		printf("failed for seek to offset 0x%x !\n", offset);
  100. 		return value;
  101. 	}
  102.  
  103. 	if ( read(fd, &value, sizeof(value)) != sizeof(value)) {
  104. 		printf("failed for read from offset 0x%x !\n", offset);
  105. 		return value;
  106. 	}
  107. 	ans=htonl(value);
  108. 	return ans>>16;
  109. }
  110.  
  111. void set_226_reg(unsigned int offset, unsigned int data)
  112. {
  113. 	unsigned int value = data;
  114. 	int fd=-1;
  115. 	fd=global_fd;
  116. 	if (fd<0) {
  117. 		printf("Invalid device handle !\n");
  118. 		return ;
  119. 	}
  120.  
  121. 	if( lseek(fd, offset, SEEK_SET) == (off_t) -1 ) {
  122. 		printf("failed for seek to offset 0x%x !\n", offset);
  123. 		return ;
  124. 	}
  125.  
  126. 	if ( write(fd, &value, sizeof(value)) != sizeof(value)) {
  127. //		printf("failed for write from offset 0x%x !\n", offset);
  128. 		return ;
  129. 	}
  130. 	return ;
  131. }
  132.  
  133. unsigned int regtoul_226(const char *str)
  134. {
  135. 	int cbase = 10;
  136. 	if(str[0]=='0'&&(str[1]=='x'||str[1]=='X')) {
  137. 		cbase = 16;
  138. 	}
  139. 	return strtoul(str, NULL, cbase);
  140. }
  141.  
  142. int Init_226()
  143. {
  144. 	global_fd = fd_initial_226();
  145. 	if (global_fd<0)
  146. 	{
  147. 		printf("\n Invalid 226 device ! \n");
  148. 		return -1;
  149. 	}
  150. 	return 0;
  151. }
  152.  
  153.

 

6、测试说明

Linux启动过程中能看到驱动正确加载，显然设备都找到了。

启动应用后能读出DBF芯片原来的ID，并根据槽位号配置新的ID

代码如下：

  1. /*
  2.  * config_dbf.c
  3.  *
  4.  *  Created on: 2018年8月17日
  5.  *      Author: Administrator
  6.  */
  7.  
  8.  
  9. #include "config_dbf.h"
  10. #include "gpio.h"
  11. #include "cps1848.h"
  12.  
  13. extern unsigned int ga_chass;
  14.  
  15. int config_dbf_id()
  16. {
  17. 	unsigned int _data;
  18. 	u32 chip_id;
  19.  
  20. 	printf("Change dbf id start\n");
  21.  
  22. 	printf("------------Set DBFA ID Register------------\n");
  23. 	_data=get_1848_reg(0,0);
  24. 	printf("orignial DBFA ID  = 0x%x\n",_data);
  25.  
  26.     chip_id = (ga_chass<<4) | 0x1;
  27.     set_1848_reg(0,0,chip_id);
  28.  
  29.     _data=get_1848_reg(0,0);
  30. 	printf("config DBFA ID  = 0x%x\n",_data);
  31.  
  32.  
  33. 	printf("------------Set DBFB ID Register------------\n");
  34. 	_data=get_1848_reg(1,0);
  35. 	printf("orignial DBFB ID  = 0x%x\n",_data);
  36.  
  37. 	chip_id = (ga_chass<<4) | 0x2;
  38. 	set_1848_reg(1,0,chip_id);
  39.  
  40. 	_data=get_1848_reg(1,0);
  41. 	printf("config DBFB ID  = 0x%x\n",_data);
  42.  
  43.  
  44. 	printf("------------Set DBFC ID Register------------\n");
  45. 	_data=get_1848_reg(2,0);
  46. 	printf("orignial DBFC ID  = 0x%x\n",_data);
  47.  
  48. 	chip_id = (ga_chass<<4) | 0x3;
  49. 	set_1848_reg(2,0,chip_id);
  50.  
  51. 	_data=get_1848_reg(2,0);
  52. 	printf("config DBFC ID  = 0x%x\n",_data);
  53.  
  54. 	return 0;
  55. }
  56.  
  57. int read_dbf_id()
  58. {
  59. 	unsigned int _data;
  60. 	_data=get_1848_reg(0,0);
  61. 	printf("DBFA ID  = 0x%x\n",_data);//true data is 1002
  62.  
  63. 	_data=get_1848_reg(1,0);
  64. 	printf("DBFB ID   = 0x%x\n",_data);//true data is 1003
  65.  
  66. 	_data=get_1848_reg(2,0);
  67. 	printf("DBFC ID   = 0x%x\n",_data);//true data is 1004
  68. 	return 0;
  69. }
  70.  
  71. int change_dbf_uart(int id)
  72. {
  73. 	if(id==0)
  74. 	{
  75. 		SetGpioReg(GPIO_UAET_SELECT_BASE_ADDR,0x0,0);
  76. 	}
  77. 	else if(id==1)
  78. 	{
  79. 		SetGpioReg(GPIO_UAET_SELECT_BASE_ADDR,0x0,1);
  80. 	}
  81. 	else
  82. 	{
  83. 		SetGpioReg(GPIO_UAET_SELECT_BASE_ADDR,0x0,2);
  84. 	}
  85. 	return 0;
  86. }
  87.  
  88. #if 0
  89. int bit_226()
  90. {
  91. 	unsigned int val32;
  92. 	unsigned short val16;
  93. 	unsigned int _data;
  94. 	float TempData;
  95. 	int Status;
  96.  
  97. 	int ret=0;
  98.  
  99. 	ret=IICRead_Reg(IIC_SLAVE_ADDR_226,0x05,&_data);
  100. 	if(ret<0)
  101. 	{
  102. 		goto error;
  103. 	}
  104. 	ret=IICWrite_Reg(IIC_SLAVE_ADDR_226,0x05,0x1400);
  105. 	if(ret<0)
  106. 	{
  107. 		goto error;
  108. 	}
  109. 	ret=IICRead_Reg(IIC_SLAVE_ADDR_226,0x05,&_data);
  110. 	if(ret<0)
  111. 	{
  112. 		goto error;
  113. 	}
  114. 	ret=IICWrite_Reg(IIC_SLAVE_ADDR_226,0x02,0x1400);
  115. 	if(ret<0)
  116. 	{
  117. 		goto error;
  118. 	}
  119. 	ret=IICRead_Reg(IIC_SLAVE_ADDR_226,0x05,&_data);
  120. 	if(ret<0)
  121. 	{
  122. 		goto error;
  123. 	}
  124. 	val32=_data;
  125. 	val16=(val32)&0xFFFF;
  126.  
  127. 	ret=IICRead_Reg(IIC_SLAVE_ADDR_226,0x02,&_data);
  128. 	if(ret<0)
  129. 	{
  130. 		goto error;
  131. 	}
  132. 	val32=_data;
  133. 	val16=(val32)&0xFFFF;
  134. 	TempData = val16*1.0/1000.0;
  135. 	printf("bus voltage is %f V.\n", TempData);
  136.  
  137. 	ret=IICRead_Reg(IIC_SLAVE_ADDR_226,0x04,&_data);
  138. 	if(ret<0)
  139. 	{
  140. 		goto error;
  141. 	}
  142.  
  143. 	val32=_data;
  144. 	val16=(val32)&0xFFFF;
  145. 	TempData = val16*1.0/1000.0;
  146. 	printf("bus current is %f A.\n", TempData);
  147.  
  148. 	if(TempData>=15.0)
  149. 	{
  150. 		printf("-----safe_rst because of Current----\n");
  151. 		SetGpioReg(GPIO_DBF_RESET_ADDR,0x0,1);
  152. 		SetGpioReg(GPIO_DBF_RESET_ADDR,0x0,0);
  153. 	}
  154.  
  155. 	ret=IICRead_Reg(IIC_SLAVE_ADDR_226,0x03,&_data);
  156. 	if(ret<0)
  157. 	{
  158. 		goto error;
  159. 	}
  160.  
  161. 	val32=_data;
  162. 	val16=(val32)&0xFFFF;
  163. 	TempData = val16*25.0/1000.0;
  164. 	printf("power is %f W.\n", TempData);
  165.  
  166. 	return 0;
  167.  
  168. error:
  169. 	return -1;
  170. }
  171. #endif

Ti 226芯片也能读出功耗了

读功耗代码如下：

  1. #include <stdio.h>
  2.  
  3. #include "bit.h"
  4. #include "config_dbf.h"
  5. #include "gpio.h"
  6. #include "cps226.h"
  7.  
  8. extern unsigned int g_temp[10];
  9. extern unsigned int g_vcc[9];
  10. extern unsigned int g_vcc_aux[16];
  11.  
  12.  
  13. void Show_226_bit()
  14. {
  15. 	unsigned int _data,val32;
  16. 	unsigned short val16;
  17. 	float temp;
  18.  
  19. 	_data=get_226_reg(0x05);
  20. 	set_226_reg(0x05,0x14);
  21. 	_data=get_226_reg(0x05);
  22.  
  23. 	set_226_reg(0x02,0x14);
  24. 	val32=get_226_reg(0x05);
  25. 	val16=val32&0xffff;
  26.  
  27.  
  28. 	val32 = get_226_reg(0x02);
  29. 	val16 = (val32)&0xFFFF;
  30. 	temp = val16*1.25/1000.0;
  31. 	printf("bus voltage is %.3f V. \n",temp);
  32.  
  33. 	val32 = get_226_reg(0x04);
  34. 	val16 = (val32)&0xFFFF;
  35.  
  36. 	temp = val16*1.0/1000.0;
  37. 	printf("Current is %.3f A. \n", temp);
  38.  
  39. 	if(temp>=15)
  40. 	{
  41. 		printf("Warning!!! DBF Current Amp Alarm! Reset DBF NOW!!!\n");
  42. 		SetGpioReg(GPIO_DBF_RESET_ADDR,0,0x1);
  43. 		SetGpioReg(GPIO_DBF_RESET_ADDR,0,0x0);
  44. 	}
  45.  
  46. 	val32 = get_226_reg(0x03);
  47. 	val16 = (val32)&0xFFFF ;
  48. 	temp = val16*25.0/1000.0;
  49. 	printf("Power is %.3f W. \r\n", temp);
  50. }

至此I2C驱动调试结束。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/713104
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号