I2C调试小结

Jul 13, 2011

 driver  C  C++  driver  linux  i2c

文章首发：http://user.qzone.qq.com/276546441/blog/1303712793


1、硬件部分

I2C物理组成上，只有两根线，一根时钟线，一根数据线，线的具体位置原理图都为标注的，找ISCL和ISDA管脚即可。I2C的时钟线不像一般总线的时钟，时刻都存在，只有当总线上有数据发送时，才会产生时钟信号；数据线在没有数据传送时，一直为高电平，故如果发送数据时发现返回总线忙的错误，原因一般为数据线上电平被拉低了。

调试I2C信号时，示波器需要设置为触发式，如果需要查看发送数据是否正确，最好用两个探头同时测时钟与数据信号，这样可以方便看出捕获的数据值。


2、软件部分

硬件了解清楚，便需要注意软件部分了。软件部分分为驱动程序与应用程序。接下来我们分别描述。


2.1 驱动程序

由于操作系统的存在，应用软件和硬件打交道需要通过驱动来进行。笔者使用的设备都基于Linux系统，故本文描述内容基于Linux系统。

驱动部分需要了解两个方面内容：I2C设备体系结构和I2C协议含义。

驱动一般分为总线驱动与设备驱动。由于Linux内核是开源的，所有有人都可以定制内核来适应自己的硬件系统来使用。所以一般情况下，我们要写的设备的总线驱动最新内核中都会包含的，有兴趣的可以通过阅读内核代码来了解其工作原理。

设备驱动只需按总线驱动的要求构造数据结构，实现操作函数注册设备即可。代码结构可以参考已有的驱动代码（附录中提供了一种简单协议的I2C驱动代码，有兴趣可以参考一下），复用已有框架代码，实现自己的设备对应的协议便可以。

I2C直观来说只是通信通道，芯片需要设置寄存器数据时，可以自定义通信协议，应用程序按照协议规定组织好数据发给I2C总线即可。协议制定时，不同芯片的协议有可能不同，常见的协议是 | I2C地址 | 寄存器地址 | 节数据 |，这些协议在芯片手册中都会有明确说明。比如某款镜头的协议如下图：

图表 1： I2C写时序


        图表 1为该镜头的写操作协议（时序），由图可知，该镜头在I2C体系中的地址是0xBA（说白了也就是协议头），设备地址为了区分读写操作，一个字节中的前七位为设备地址，当最后一位是0时为写操作，值是1时为读操作，紧跟着的一个字节是寄存器地址0x09，然后是写入寄存器的两字节值0000 0010 1000 0100，所以在写这镜头寄存器时给I2C总线发送的数据为0xBA 0x09 0x02 0x84，发送完后，镜头解析完命令便把地址为0x09寄存器的值设置为0x0284。

图表 2：I2C读时序

图表 2为该镜头的读操作协议（时序），进行读操作之前需要先写入要读的寄存器地址，这便是0xBA 0x09的作用，然后直接读操作，0xBB便是对0xBA地址的I2C设备进行读操作，读出两字节内容，便是0x09对应的寄存器值。

而另一款镜头的协议则有些复杂。见下图。

图表 3：写时序

这个协议的制定格式为| 设备地址 | 44字节数据 |。44字节数据的协议有明确的说明文档，只要按照文档说明组织内容即可达到自己想要的操作。


2.2 应用程序

应用程序主要通过驱动的IOCONTRL接口操作I2C，按手册提供的协议说明发送命令即可，可以参考附录中应用程序部分代码。

    3 附录

  1. 	3.1 简单I2C协议驱动代码
  2. 	
  3. 	#include <dev_i2c.h>
  4. 	#include <linux/config.h>
  5. 	#include <linux/module.h>
  6. 	#include <linux/init.h>
  7. 	#include <linux/fs.h>           /* everything... */
  8. 	#include <linux/cdev.h>
  9. 	#include <linux/mm.h>
  10. 	#include <linux/i2c.h>
  11. 	#include <linux/kernel.h>       /* printk() */
  12. 	#include <linux/slab.h>         /* kmalloc() */
  13. 	#include <asm/uaccess.h>        /* copy_*_user */
  14. 	
  15. 	
  16. 	static unsigned short gI2C_curAddr;
  17. 	
  18. 	typedef struct {
  19. 	
  20. 	  int devAddr;
  21. 	
  22. 	  struct i2c_client client;   //!< Data structure containing general access routines.
  23. 	  struct i2c_driver driver;   //!< Data structure containing information specific to each client.
  24. 	  
  25. 	  char name[20];
  26. 	  int nameSize;
  27. 	  int users;
  28. 	  
  29. 	} I2C_Obj;
  30. 	
  31. 	typedef struct {
  32. 	
  33. 	  struct cdev cdev;             /* Char device structure    */
  34. 	  int     major;
  35. 	  struct semaphore semLock;
  36. 	    
  37. 	  I2C_Obj *pObj[I2C_DEV_MAX_ADDR];
  38. 	
  39. 	  uint8_t reg[I2C_TRANSFER_BUF_SIZE_MAX];
  40. 	  uint8_t buffer[I2C_TRANSFER_BUF_SIZE_MAX*4];
  41. 	  
  42. 	} I2C_Dev;
  43. 	
  44. 	I2C_Dev gI2C_dev;
  45. 	
  46. 	int I2C_detectClient(struct i2c_adapter *adapter, int address)
  47. 	{
  48. 	    I2C_Obj *pObj;
  49. 	    struct i2c_client *client;
  50. 	    int err = 0;
  51. 	    
  52. 	    #ifdef I2C_DEBUG
  53. 	    printk(KERN_INFO "I2C: I2C_detectClient() at address %x ...\n", address);
  54. 	    #endif
  55. 	        
  56. 	    if(address > I2C_DEV_MAX_ADDR) {
  57. 	      printk( KERN_ERR "I2C: ERROR: Invalid device address %x\n", address);        
  58. 	      return -1;
  59. 	    }
  60. 	      
  61. 	    pObj = gI2C_dev.pObj[address];
  62. 	    if(pObj==NULL) {
  63. 	      printk( KERN_ERR "I2C: ERROR: Object not found for address %x\n", address);    
  64. 	      return -1;
  65. 	    }
  66. 	
  67. 	    client = &pObj->client;
  68. 	
  69. 	    if(client->adapter)
  70. 	      return -EBUSY;  /* our client is already attached */
  71. 	
  72. 	    memset(client, 0x00, sizeof(struct i2c_client));
  73. 	    client->addr = pObj->devAddr;
  74. 	    client->adapter = adapter;
  75. 	    client->driver = &pObj->driver;
  76. 	
  77. 	    #ifdef I2C_DEBUG
  78. 	    printk(KERN_INFO "I2C: i2c_attach_client() ...\n");
  79. 	    #endif
  80. 	
  81. 	    if((err = i2c_attach_client(client)))
  82. 	    {
  83. 	        printk( KERN_ERR "I2C: ERROR: Couldn't attach %s (address=%x)\n", pObj->name, pObj->devAddr);
  84. 	        client->adapter = NULL;
  85. 	        return err;
  86. 	    }
  87. 	    
  88. 	    #ifdef I2C_DEBUG
  89. 	    printk( KERN_INFO "I2C: %s client registered at address %x !\n", pObj->name, pObj->devAddr );
  90. 	    #endif
  91. 	
  92. 	    return 0;
  93. 	}
  94. 	
  95. 	int I2C_detachClient(struct i2c_client *client)
  96. 	{
  97. 	    int err;
  98. 	
  99. 	    if(!client->adapter)
  100. 	        return -ENODEV; /* our client isn't attached */
  101. 	
  102. 	    if((err = i2c_detach_client(client))) {
  103. 	        printk( KERN_ERR "Client deregistration failed (address=%x), client not detached.\n", client->addr);
  104. 	        return err;
  105. 	    }
  106. 	
  107. 	    client->adapter = NULL;
  108. 	
  109. 	    return 0;
  110. 	}
  111. 	
  112. 	int I2C_attachAdapter(struct i2c_adapter *adapter)
  113. 	{
  114. 	    #ifdef I2C_DEBUG
  115. 	    printk(KERN_INFO "I2C: I2C_attachAdapter() ...\n");
  116. 	    #endif
  117. 	    
  118. 	    return I2C_detectClient(adapter, gI2C_curAddr);
  119. 	}
  120. 	
  121. 	void *I2C_create(int devAddr) {
  122. 	
  123. 	    int ret;
  124. 	    struct i2c_driver *driver;
  125. 	    struct i2c_client *client = client;
  126. 	    
  127. 	    I2C_Obj *pObj;
  128. 	
  129. 	    #ifdef I2C_DEBUG
  130. 	    printk(KERN_INFO "I2C: Driver registration in progress for address %x...\n", devAddr);
  131. 	    #endif
  132. 	    
  133. 	    devAddr >>= 1;
  134. 	    
  135. 	    if(devAddr>I2C_DEV_MAX_ADDR)
  136. 	      return NULL;
  137. 	   
  138. 	    if(gI2C_dev.pObj[devAddr]!=NULL) {
  139. 	      // already allocated, increment user count, and return the allocated handle
  140. 	      
  141. 	      gI2C_dev.pObj[devAddr]->users++;
  142. 	      
  143. 	      return gI2C_dev.pObj[devAddr];
  144. 	    }
  145. 	    
  146. 	    pObj = (void*)kmalloc( sizeof(I2C_Obj), GFP_KERNEL);
  147. 	
  148. 	    gI2C_dev.pObj[devAddr] = pObj;
  149. 	
  150. 	    memset(pObj, 0, sizeof(I2C_Obj));
  151. 	  
  152. 	    pObj->client.adapter = NULL;
  153. 	    pObj->users++;
  154. 	    
  155. 	    pObj->devAddr = devAddr;
  156. 	    
  157. 	    gI2C_curAddr = pObj->devAddr;
  158. 	    
  159. 	    driver = &pObj->driver;
  160. 	
  161. 	    pObj->nameSize=0;
  162. 	    pObj->name[pObj->nameSize++] = 'I';
  163. 	    pObj->name[pObj->nameSize++] = '2';
  164. 	    pObj->name[pObj->nameSize++] = 'C';
  165. 	    pObj->name[pObj->nameSize++] = '_';   
  166. 	    pObj->name[pObj->nameSize++] = 'A' + ((pObj->devAddr >> 0) & 0xF);
  167. 	    pObj->name[pObj->nameSize++] = 'B' + ((pObj->devAddr >> 4) & 0xF);
  168. 	    pObj->name[pObj->nameSize++] = 0;
  169. 	
  170. 	    driver->driver.name = pObj->name;
  171. 	    driver->id = I2C_DRIVERID_MISC;
  172. 	    driver->attach_adapter = I2C_attachAdapter;
  173. 	    driver->detach_client = I2C_detachClient;
  174. 	
  175. 	    #ifdef I2C_DEBUG
  176. 	    printk(KERN_INFO "I2C: i2c_add_driver() ...\n");
  177. 	    #endif
  178. 	
  179. 	    if((ret = i2c_add_driver(driver)))
  180. 	    {
  181. 	        printk( KERN_ERR "I2C: ERROR: Driver registration failed (address=%x), module not inserted.\n", pObj->devAddr);
  182. 	    }
  183. 	    
  184. 	    #ifdef I2C_DEBUG
  185. 	    printk(KERN_INFO "I2C: Driver registration successful (address=%x)\n", pObj->devAddr);
  186. 	    #endif
  187. 	    
  188. 	    if(ret<0) {
  189. 	
  190. 	      gI2C_dev.pObj[pObj->devAddr] = NULL;
  191. 	    
  192. 	      kfree(pObj);    
  193. 	
  194. 	      return NULL;
  195. 	    }
  196. 	    
  197. 	    return pObj;
  198. 	}
  199. 	
  200. 	int I2C_delete(I2C_Obj *pObj)
  201. 	{
  202. 	  if(pObj==NULL)
  203. 	    return -1;
  204. 	  
  205. 	  pObj->users--;
  206. 	  
  207. 	  if(pObj->users<=0) {
  208. 	    if(pObj->client.adapter!=NULL) {
  209. 	      if(i2c_del_driver(&pObj->driver))
  210. 	      printk(KERN_ERR "I2C: ERROR: Driver remove failed (address=%x), module not removed.\n", pObj->devAddr);
  211. 	
  212. 	      pObj->client.adapter = NULL;
  213. 	
  214. 	      gI2C_dev.pObj[pObj->devAddr] = NULL;
  215. 	    
  216. 	      kfree(pObj);    
  217. 	    }
  218. 	  }
  219. 	
  220. 	  return 0;
  221. 	}
  222. 	
  223. 	int I2C_read(I2C_Obj *pObj, uint8_t *reg, uint8_t *buffer, uint8_t count, uint8_t dataSize)
  224. 	{
  225. 	  uint8_t i;
  226. 	  int err;
  227. 	  struct i2c_client *client;
  228. 		struct i2c_msg msg[1];
  229. 		unsigned char data[1];
  230. 	
  231. 	  if(pObj==NULL)
  232. 	    return -ENODEV;
  233. 	
  234. 	  client = &pObj->client;
  235. 	  if(!client->adapter)
  236. 	    return -ENODEV;  
  237. 	
  238. 	  if(dataSize<=0||dataSize>4)
  239. 	    return -1;
  240. 	    
  241. 	  for(i=0; i<count; i++) {
  242. 			msg->addr  = client->addr;
  243. 			msg->flags = 0;
  244. 			msg->len   = 1;
  245. 			msg->buf   = data;
  246. 			data[0]    = reg[i];
  247. 			err = i2c_transfer(client->adapter, msg, 1);
  248. 			if(err<0) {
  249. 			  printk( KERN_ERR " i2c_transfer(0x%x, %x)\n", msg->addr, msg->buf[0]);
  250. 			}
  251. 	
  252. 			if (err >= 0) 
  253. 			{
  254. 				msg->flags = I2C_M_RD;
  255. 	      msg->len   = dataSize;
  256. 				err = i2c_transfer(client->adapter, msg, 1);
  257. 				if (err >= 0) 
  258. 				{
  259. 				  if(dataSize==1) {
  260. 	  				buffer[i] = data[0];
  261. 	  		  } else 
  262. 	  		  if(dataSize==2) {
  263. 	  		    buffer[2*i]   = data[1];
  264. 	  		    buffer[2*i+1] = data[0];  		    
  265. 	  		  }
  266. 				}
  267. 			}
  268. 	    if (err<0)
  269. 	      return -ENODEV;
  270. 	  }
  271. 	  
  272. 	  return 0;
  273. 	}
  274. 	
  275. 	int I2C_write(I2C_Obj *pObj, uint8_t *reg, uint8_t *buffer, uint8_t count, uint8_t dataSize)
  276. 	{
  277. 	  uint8_t i;
  278. 	  int err;
  279. 	  struct i2c_client *client;
  280. 		struct i2c_msg msg[1];
  281. 		unsigned char data[8];
  282. 	
  283. 	  if(pObj==NULL)
  284. 	    return -ENODEV;
  285. 	
  286. 	  client = &pObj->client;
  287. 	  if(!client->adapter)
  288. 	    return -ENODEV;  
  289. 	  
  290. 	  if(dataSize<=0||dataSize>4)
  291. 	    return -1;
  292. 	    
  293. 	  for(i=0; i<count; i++) {
  294. 	  
  295. 	    msg->addr = client->addr;
  296. 			msg->flags= 0;
  297. 			msg->buf  = data;
  298. 			
  299. 			data[0] = reg[i];
  300. 			
  301. 			if(dataSize==1) {
  302. 	  		data[1]  = buffer[i];
  303. 	  		msg->len = 2;  		
  304. 	    }	else	
  305. 			if(dataSize==2) {
  306. 	  		data[1] = buffer[2*i+1];
  307. 	  		data[2] = buffer[2*i];
  308. 	  		msg->len = 3;
  309. 			} 
  310. 			err = i2c_transfer(client->adapter, msg, 1);
  311. 	    if( err < 0 )
  312. 	      return err;
  313. 	  }
  314. 	  
  315. 	  return 0;
  316. 	}
  317. 	
  318. 	int I2C_devOpen(struct inode *inode, struct file *filp)
  319. 	{
  320. 	  int minor, major;
  321. 	
  322. 	  minor = iminor(inode);
  323. 	  major = imajor(inode);
  324. 	
  325. 	#ifdef I2C_DEBUG
  326. 	  printk(KERN_INFO "I2C: I2C_devOpen()   , %4d, %2d \n", major, minor);
  327. 	#endif
  328. 	
  329. 	  filp->private_data = NULL;
  330. 	
  331. 	  return 0;                /* success */
  332. 	}
  333. 	
  334. 	int I2C_devRelease(struct inode *inode, struct file *filp)
  335. 	{
  336. 	  I2C_Obj *pObj;
  337. 	
  338. 	  pObj = (I2C_Obj *)filp->private_data;
  339. 	  
  340. 	  if(pObj==NULL)
  341. 	    return 0;
  342. 	
  343. 	#ifdef I2C_DEBUG
  344. 	  printk(KERN_INFO "I2C: I2C_devRelease(), %x, %d \n", pObj->devAddr, pObj->users);
  345. 	#endif
  346. 	
  347. 	  I2C_delete(pObj);
  348. 	
  349. 	  return 0;
  350. 	}
  351. 	
  352. 	int I2C_devIoctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
  353. 	{
  354. 	  I2C_Obj *pObj;
  355. 	  int status=0;
  356. 	  I2C_TransferPrm transferPrm;
  357. 	  
  358. 	  pObj = (I2C_Obj *)filp->private_data;
  359. 	
  360. 	#ifdef I2C_DEBUG
  361. 	  printk(KERN_INFO "I2C: I2C_devIoctl() \n");
  362. 	#endif
  363. 	
  364. 	  if(!I2C_IOCTL_CMD_IS_VALID(cmd))
  365. 	    return -1;
  366. 	
  367. 	  cmd = I2C_IOCTL_CMD_GET(cmd);
  368. 	
  369. 	  down_interruptible(&gI2C_dev.semLock);      
  370. 	  
  371. 	  switch(cmd)
  372. 	  {
  373. 	    case I2C_CMD_SET_DEV_ADDR:
  374. 	      filp->private_data = I2C_create(arg);
  375. 	      if(filp->private_data==NULL)
  376. 	        status = -1;
  377. 	      break;
  378. 	      
  379. 	    case I2C_CMD_WRITE:
  380. 	      
  381. 	      status = copy_from_user(&transferPrm, (void *)arg, sizeof(transferPrm));
  382. 	      if(status==0) {
  383. 	        status = copy_from_user(gI2C_dev.reg, transferPrm.reg, transferPrm.count);  
  384. 	        status |= copy_from_user(gI2C_dev.buffer, transferPrm.value, transferPrm.count*transferPrm.dataSize);  
  385. 	        if(status==0) {
  386. 	          status = I2C_write(pObj, gI2C_dev.reg, gI2C_dev.buffer, transferPrm.count, transferPrm.dataSize);
  387. 	        }
  388. 	      }
  389. 	            
  390. 	      break;
  391. 	    case I2C_CMD_READ:  
  392. 	    
  393. 	      status = copy_from_user(&transferPrm, (void *)arg, sizeof(transferPrm));
  394. 	      if(status==0) {
  395. 	        status = copy_from_user(gI2C_dev.reg, transferPrm.reg, transferPrm.count);        
  396. 	        if(status==0) {
  397. 	          status = I2C_read(pObj, gI2C_dev.reg, gI2C_dev.buffer, transferPrm.count, transferPrm.dataSize);
  398. 	          if(status==0) {
  399. 	            status = copy_to_user(transferPrm.value, gI2C_dev.buffer, transferPrm.count*transferPrm.dataSize);
  400. 	          }
  401. 	        }
  402. 	      }
  403. 	      
  404. 	      break;
  405. 	    default:
  406. 	      status = -1;
  407. 	      break;    
  408. 	  }
  409. 	
  410. 	  up(&gI2C_dev.semLock);      
  411. 	
  412. 	  return status;
  413. 	}
  414. 	
  415. 	
  416. 	struct file_operations gI2C_devFileOps = {
  417. 	  .owner = THIS_MODULE,
  418. 	  .open = I2C_devOpen,
  419. 	  .release = I2C_devRelease,
  420. 	  .ioctl = I2C_devIoctl,
  421. 	};
  422. 	
  423. 	int I2C_devInit(void)
  424. 	{
  425. 	  int     result, i;
  426. 	  dev_t   dev = 0;
  427. 	
  428. 	#ifdef I2C_DEBUG
  429. 	  printk(KERN_INFO "I2C: I2C_devInit() \n");
  430. 	#endif
  431. 	
  432. 	  result = alloc_chrdev_region(&dev, 0, 1, I2C_DRV_NAME);
  433. 	
  434. 	  if (result < 0) {
  435. 	    printk(KERN_WARNING "I2C: can't get device major num \n");
  436. 	    return result;
  437. 	  }
  438. 	  
  439. 	  for(i=0; i<I2C_DEV_MAX_ADDR; i++)
  440. 	  {
  441. 	    gI2C_dev.pObj[i]=NULL;
  442. 	  }
  443. 	
  444. 	  gI2C_dev.major = MAJOR(dev);
  445. 	  
  446. 	  sema_init(&gI2C_dev.semLock, 1);
  447. 	
  448. 	  cdev_init(&gI2C_dev.cdev, &gI2C_devFileOps);
  449. 	
  450. 	  gI2C_dev.cdev.owner = THIS_MODULE;
  451. 	  gI2C_dev.cdev.ops = &gI2C_devFileOps;
  452. 	
  453. 	  result = cdev_add(&gI2C_dev.cdev, dev, 1);
  454. 	
  455. 	  if (result)
  456. 	    printk(KERN_WARNING "I2C: Error [%d] while adding device [%s] \n", result, I2C_DRV_NAME);
  457. 	
  458. 	  printk(KERN_INFO "I2C: Module install successful, device major num = %d \n", gI2C_dev.major);
  459. 	
  460. 	  return result;
  461. 	}
  462. 	
  463. 	void I2C_devExit(void)
  464. 	{
  465. 	  dev_t   devno = MKDEV(gI2C_dev.major, 0);
  466. 	
  467. 	#ifdef I2C_DEBUG
  468. 	  printk(KERN_INFO "I2C: I2C_devExit() \n");
  469. 	#endif
  470. 	
  471. 	  cdev_del(&gI2C_dev.cdev);
  472. 	
  473. 	  unregister_chrdev_region(devno, 1);
  474. 	}
  475. 	
  476. 	3.2 应用程序
  477. 	
  478. 	
  479. 	#include <drv_i2c.h>
  480. 	#include <dev_i2c.h>
  481. 	#include <sys/ioctl.h>
  482. 	#include <fcntl.h>
  483. 	#include <unistd.h>
  484. 	
  485. 	int DRV_i2cOpen(DRV_I2cHndl *hndl, Uint8 devAddr)
  486. 	{
  487. 	  char deviceName[20];
  488. 	  Uint32 cmd;
  489. 	  int status;
  490. 	
  491. 	  sprintf(deviceName, "/dev/%s", I2C_DRV_NAME);
  492. 	
  493. 	  hndl->fd = open(deviceName, O_RDWR);
  494. 	  if(hndl->fd<0)
  495. 	    return OSA_EFAIL;
  496. 	  
  497. 	  cmd = I2C_IOCTL_CMD_MAKE(I2C_CMD_SET_DEV_ADDR);
  498. 	  status = ioctl(hndl->fd, cmd, devAddr);
  499. 	  
  500. 	  if(status<0)
  501. 	    close(hndl->fd);
  502. 	    
  503. 	  return status;
  504. 	}
  505. 	
  506. 	int DRV_i2cRead8(DRV_I2cHndl *hndl, Uint8 *reg, Uint8 *value, Uint8 count)
  507. 	{
  508. 	  I2C_TransferPrm prm;
  509. 	  Uint32 cmd;
  510. 	  int status;
  511. 	  
  512. 	  prm.dataSize = 1;
  513. 	  prm.reg = reg;
  514. 	  prm.count = count;
  515. 	  prm.value = value;
  516. 	  
  517. 	  cmd = I2C_IOCTL_CMD_MAKE(I2C_CMD_READ);
  518. 	  status = ioctl(hndl->fd, cmd, &prm);
  519. 	
  520. 	  return status;  
  521. 	}
  522. 	
  523. 	int DRV_i2cWrite8(DRV_I2cHndl *hndl, Uint8 *reg, Uint8 *value, Uint8 count)
  524. 	{
  525. 	  I2C_TransferPrm prm;
  526. 	  Uint32 cmd;
  527. 	  int status;
  528. 	   
  529. 	  prm.dataSize = 1;   
  530. 	  prm.reg = reg;
  531. 	  prm.count = count;
  532. 	  prm.value = value;
  533. 	  
  534. 	  cmd = I2C_IOCTL_CMD_MAKE(I2C_CMD_WRITE);
  535. 	  status = ioctl(hndl->fd, cmd, &prm);
  536. 	  
  537. 	  return status;  
  538. 	}
  539. 	
  540. 	int DRV_i2cRead16(DRV_I2cHndl *hndl, Uint8 *reg, Uint16 *value, Uint8 count)
  541. 	{
  542. 	  I2C_TransferPrm prm;
  543. 	  Uint32 cmd;
  544. 	  int status;
  545. 	  
  546. 	  prm.dataSize = 2;
  547. 	  prm.reg = reg;
  548. 	  prm.count = count;
  549. 	  prm.value = value;
  550. 	  
  551. 	  cmd = I2C_IOCTL_CMD_MAKE(I2C_CMD_READ);
  552. 	  status = ioctl(hndl->fd, cmd, &prm);
  553. 	
  554. 	  return status;  
  555. 	}
  556. 	
  557. 	int DRV_i2cWrite16(DRV_I2cHndl *hndl, Uint8 *reg, Uint16 *value, Uint8 count)
  558. 	{
  559. 	  I2C_TransferPrm prm;
  560. 	  Uint32 cmd;
  561. 	  int status;
  562. 	   
  563. 	  prm.dataSize = 2;   
  564. 	  prm.reg = reg;
  565. 	  prm.count = count;
  566. 	  prm.value = value;
  567. 	  
  568. 	  cmd = I2C_IOCTL_CMD_MAKE(I2C_CMD_WRITE);
  569. 	  status = ioctl(hndl->fd, cmd, &prm);
  570. 	  
  571. 	  return status;  
  572. 	}
  573. 	
  574. 	int DRV_i2cClose(DRV_I2cHndl *hndl)
  575. 	{
  576. 	  return close(hndl->fd);
  577. 	}
  578. 	
  579. 	int DRV_i2cTestShowUsage(char *str)
  580. 	{
  581. 	  OSA_printf(" \n");
  582. 	  OSA_printf(" I2C Test Utility, \r\n");
  583. 	  OSA_printf(" Usage: %s -r|-w <devAddrInHex> <regAddrInHex> <regValueInHex or numRegsToReadInDec> <regSizeInBytes>\r\n", str);
  584. 	  OSA_printf(" \n");
  585. 	  return 0;
  586. 	}
  587. 	
  588. 	int DRV_i2cTestMain(int argc, char **argv)
  589. 	{
  590. 	  DRV_I2cHndl i2cHndl;
  591. 	  Uint8 devAddr, numRegs;
  592. 	  Bool doRead;
  593. 	  Uint8 dataSize=1;
  594. 	  int status, i;
  595. 	  
  596. 	  static Uint8 regAddr[256], regValue8[256];
  597. 	  static Uint16 regValue16[256];      
  598. 	  
  599. 	  if(argc<3) {
  600. 	    DRV_i2cTestShowUsage(argv[0]);
  601. 	    return -1;
  602. 	  }
  603. 	  
  604. 	  if(strcmp(argv[1], "-r")==0)
  605. 	    doRead=TRUE;
  606. 	  else  
  607. 	  if(strcmp(argv[1], "-w")==0)
  608. 	    doRead=FALSE;
  609. 	  else {
  610. 	    DRV_i2cTestShowUsage(argv[0]);
  611. 	    return -1;  
  612. 	  }
  613. 	  
  614. 	  devAddr = 0;
  615. 	  numRegs = 4;
  616. 	  regValue8[0] = 0;
  617. 	  regValue16[0] = 0;
  618. 	  regAddr[0] = 0;  
  619. 	
  620. 	  if(argc>2)
  621. 	    devAddr = xstrtoi(argv[2]);
  622. 	    
  623. 	  if(argc>3)
  624. 	    regAddr[0] = xstrtoi(argv[3]);
  625. 	
  626. 	  if(argc>5) 
  627. 	    dataSize = atoi(argv[5]);
  628. 	  
  629. 	  if(dataSize>2 || dataSize<=0)
  630. 	    dataSize=1;
  631. 	
  632. 	  if(argc>4) {
  633. 	    if(doRead)
  634. 	      numRegs = atoi(argv[4]);
  635. 	    else {
  636. 	      if(dataSize==1)
  637. 	        regValue8[0] = xstrtoi(argv[4]);
  638. 	      else
  639. 	      if(dataSize==2)      
  640. 	        regValue16[0] = xstrtoi(argv[4]);      
  641. 	    }
  642. 	  }
  643. 	    
  644. 	  if(devAddr==0) {
  645. 	    OSA_printf(" I2C: Invalid device address\n");
  646. 	    DRV_i2cTestShowUsage(argv[0]);
  647. 	    return -1;  
  648. 	  }
  649. 	  
  650. 	//  OSA_printf(" I2C: Opening I2C at device address %x ...\n", devAddr);
  651. 	  
  652. 	  status = DRV_i2cOpen(&i2cHndl, devAddr);
  653. 	  
  654. 	  if(status != OSA_SOK) {
  655. 	    OSA_ERROR("DRV_i2cOpen(%d)", devAddr);
  656. 	    return status;
  657. 	  }
  658. 	    
  659. 	  if(status==OSA_SOK)
  660. 	  {
  661. 	    #if 1
  662. 	    if(doRead) {
  663. 	      for(i=1; i<numRegs; i++)
  664. 	        regAddr[i] = regAddr[0]+i;
  665. 	      
  666. 	      if(dataSize==1)
  667. 	        status = DRV_i2cRead8(&i2cHndl, regAddr, regValue8, numRegs);
  668. 	      else
  669. 	      if(dataSize==2)      
  670. 	        status = DRV_i2cRead16(&i2cHndl, regAddr, regValue16, numRegs);
  671. 	
  672. 	      OSA_printf(" \n");      
  673. 	      if(status==OSA_SOK) {
  674. 	        for(i=0; i<numRegs; i++) {
  675. 	          if(dataSize==1) {
  676. 	            OSA_printf(" I2C: 0x%02x = 0x%02x \n", regAddr[i], regValue8[i] );          
  677. 	          } else
  678. 	          if(dataSize==2)
  679. 	            OSA_printf(" I2C: 0x%02x = 0x%04x \n", regAddr[i], regValue16[i] );          
  680. 	          
  681. 	        }
  682. 	      } else {
  683. 	        OSA_printf(" I2C: Read ERROR !!!\n");          
  684. 	      }
  685. 	      OSA_printf(" \n");              
  686. 	      
  687. 	    } else {
  688. 	      OSA_printf(" \n");              
  689. 	          
  690. 	      if(dataSize==1) {   
  691. 	
  692. 	        status = DRV_i2cWrite8(&i2cHndl, regAddr, regValue8, 1);
  693. 	        if(status==OSA_SOK) {
  694. 	          status = DRV_i2cRead8(&i2cHndl, regAddr, regValue8, 1);
  695. 	        }        
  696. 	      }
  697. 	      else
  698. 	      if(dataSize==2) {   
  699. 	        status = DRV_i2cWrite16(&i2cHndl, regAddr, regValue16, 1);
  700. 	        if(status==OSA_SOK) {
  701. 	          status = DRV_i2cRead16(&i2cHndl, regAddr, regValue16, 1);        
  702. 	        }
  703. 	      }
  704. 	      
  705. 	      if(status==OSA_SOK) {
  706. 	        if(dataSize==1) {
  707. 	          OSA_printf(" I2C: 0x%02x = 0x%02x \n", regAddr[0], regValue8[0] );          
  708. 	        } else
  709. 	        if(dataSize==2)
  710. 	          OSA_printf(" I2C: 0x%02x = 0x%04x \n", regAddr[0], regValue16[0] );                  
  711. 	      } else {
  712. 	        OSA_printf(" I2C: Write ERROR !!!\n");          
  713. 	      }
  714. 	      OSA_printf(" \n");                    
  715. 	      
  716. 	    }
  717. 	    #endif
  718. 	    
  719. 	    DRV_i2cClose(&i2cHndl);
  720. 	  }


 Toc
 Tags
 Related