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

linux I2C二_msgs[1].buf = &data;

作者：寸_铁 | 2024-06-23 19:00:58

赞

踩

msgs[1].buf = &data;

一、linux I2C体系结构


上图中分为用户空间部分、内核空间、硬件。

应用程序是要求实现的应用功能，通过调用系统调用(i2c-dev.c虚拟的I2C设备驱动)，内核进行交互。

硬件包括实际的I2C总线和挂接在I2C总线上的设备

内核是描述设备与总线是如何通信的。

举个例子：

假设上层要给设备某地址写值，调用如下

应用层序调用系统函数write>（client）i2cdev_write->（i2c-core.c）i2c_master_send->（适配器）(adap->algo->master_xfer)->（硬件）使I2C产生特定的信号与设备交互


内核的实现：

内核分三大块 1、core   2、适配器管理+总线驱动   3、设备管理+驱动

1、core是核心模块，将适配端与外设相隔离。提供一组不依赖具体硬件的接口函数，实现各种适配器、总线驱动、设备驱动等相同的部分。一种外设可以在不同适配器上使用，一个适配器可以接不同的外设。

具体表现：

1、int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)//接收发送函数

2、int i2c_add_numbered_adapter(struct i2c_adapter *adap)//注册适配器

3、int i2c_del_adapter(struct i2c_adapter *adap)//删除适配器

。。。


2、适配器可以简单理解为cpu上的I2C接口，总线驱动是其工作软件的实现。

3、外设驱动即描述该设备怎么工作。


理解几个结构体：

  1. struct i2c_adapter {
  2. 	struct module *owner;
  3. 	unsigned int id;
  4. 	unsigned int class;		  /* classes to allow probing for */
  5. 	const struct i2c_algorithm *algo; /* the algorithm to access the bus */
  6. 	void *algo_data;	//指向某变量或开辟的结构体
  7.  
  8. 	/* data fields that are valid for all devices	*/
  9. 	struct rt_mutex bus_lock;
  10.  
  11. 	int timeout;			/* in jiffies */
  12. 	int retries;			//重做次数
  13. 	struct device dev;		/* the adapter device */
  14.  
  15. 	int nr;				//编号
  16. 	char name[48];		//名称
  17. 	struct completion dev_released;
  18.  
  19. 	struct mutex userspace_clients_lock;
  20. 	struct list_head userspace_clients;
  21. };
  22.  
  23. struct i2c_algorithm {//通信方法，产生特定的信号
  24. 	/* master_xfer should return the number of messages successfully
  25. 	   processed, or a negative value on error */
  26. 	int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,
  27. 			   int num);//发送接收函数
  28. 。。。
  29. 	/* To determine what the adapter supports */
  30. 	u32 (*functionality) (struct i2c_adapter *);
  31. 。。。
  32. }
  33.  
  34. struct i2c_driver{
  35. unsigned int class;
  36.  
  37. 	/* Notifies the driver that a new bus has appeared or is about to be
  38. 	 * removed. You should avoid using this if you can, it will probably
  39. 	 * be removed in a near future.
  40. 	 */
  41. 	int (*attach_adapter)(struct i2c_adapter *);//attach to a i2c adapter
  42. 	int (*detach_adapter)(struct i2c_adapter *);//deattach an adapter which attached
  43.  
  44. 	/* Standard driver model interfaces */
  45. 	int (*probe)(struct i2c_client *, const struct i2c_device_id *);
  46. 	int (*remove)(struct i2c_client *);
  47.  
  48. 	/* driver model interfaces that don't relate to enumeration  */
  49. 	void (*shutdown)(struct i2c_client *);
  50. 	int (*suspend)(struct i2c_client *, pm_message_t mesg);
  51. 	int (*resume)(struct i2c_client *);
  52.  
  53. 	/* Alert callback, for example for the SMBus alert protocol.
  54. 	 * The format and meaning of the data value depends on the protocol.
  55. 	 * For the SMBus alert protocol, there is a single bit of data passed
  56. 	 * as the alert response's low bit ("event flag").
  57. 	 */
  58. 	void (*alert)(struct i2c_client *, unsigned int data);
  59.  
  60. 	/* a ioctl like command that can be used to perform specific functions
  61. 	 * with the device.
  62. 	 */
  63. 	int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
  64.  
  65. 	struct device_driver driver;
  66. 	const struct i2c_device_id *id_table;
  67.  
  68. 	/* Device detection callback for automatic device creation */
  69. 	int (*detect)(struct i2c_client *, struct i2c_board_info *);
  70. 	const unsigned short *address_list;
  71. 	struct list_head clients;
  72. };
  73.  
  74. struct i2c_client {//外设描述
  75. 	unsigned short flags;		/* div., see below		*/
  76. 	unsigned short addr;		/* chip address - NOTE: 7bit	*/
  77. 					/* addresses are stored in the	*/
  78. 					/* _LOWER_ 7 bits		*/
  79. 	char name[I2C_NAME_SIZE];
  80. 	struct i2c_adapter *adapter;	/* the adapter we sit on	*/
  81. 	struct i2c_driver *driver;	/* and our access routines	*/
  82. 	struct device dev;		/* the device structure		*/
  83. 	int irq;			/* irq issued by device		*/
  84. 	struct list_head detected;
  85. };
  86.  
  87. /*另外再了解一个重要结构体，*/
  88. struct i2c_msg { //通信的基本载体
  89. 	__u16 addr;	/* slave address-器件地址*/
  90. 	__u16 flags;
  91. #define I2C_M_TEN		0x0010	/* this is a ten bit chip address */
  92. #define I2C_M_RD		0x0001	/* read data, from slave to master */
  93. #define I2C_M_NOSTART		0x4000	/* if I2C_FUNC_PROTOCOL_MANGLING */
  94. #define I2C_M_REV_DIR_ADDR	0x2000	/* if I2C_FUNC_PROTOCOL_MANGLING */
  95. #define I2C_M_IGNORE_NAK	0x1000	/* if I2C_FUNC_PROTOCOL_MANGLING */
  96. #define I2C_M_NO_RD_ACK		0x0800	/* if I2C_FUNC_PROTOCOL_MANGLING */
  97. #define I2C_M_RECV_LEN		0x0400	/* length will be first received byte */
  98. 	__u16 len;		/* msg length--描述buf长度*/
  99. 	__u8 *buf;		/* pointer to msg data--指向数据缓存*/
  100. };
  101.

  
 

 

 

 

 

  1. 现在说明如何构造i2c_msg，现以write为例说明。
  2.  
  3.  
  4.     msgs[0].addr = address;
  5.     msgs[0].flags = 0;    /* write */
  6.     msgs[0].buf = (unsigned char *)data;//包含的数据是上图２段,本例中buf包含两个值：register address+data
  7.     msgs[0].len = len;          //本例中len=2
  8.     msgs[0].scl_rate = I2C_RATE;
  9.  
  10. 因此，
  11. １、系统开始时先将７位的地址左移１位，并判断msg为WRITE，所以第８位位０．
  12. ２、将地址传输出去，进入中断。在中断函数里判断传输是否正确(比如是否收到ＡＣＫ信号等)
  13. ３、再依次将ｂｕｆ中的值发送，并用len判断是否传输完毕
  14.  
  15. 现在说明如何构造i2c_msg，现以ｒｅａｄ为例说明。
  16.  
  17. 分两个msg传输：
  18. 　　msg０对应上图第一段，是写msg。
  19. 　　msg1对应上图第二段，是读msg。
  20.  
  21. msgs[0].addr = address;//启动传输时发送
  22.     msgs[0].flags = 0;    /* write */
  23.     msgs[0].buf = reg;//reg表示片内地址
  24.     msgs[0].len = 1;//发送长度
  25.     msgs[0].scl_rate = SENSOR_I2C_RATE;
  26.     
  27.     msgs[1].addr = address;//重新启动后再发送(见上图段２，见下面分析)。
  28.     msgs[1].flags = I2C_M_RD;//上图段２，第一字节第８位。
  29.     msgs[1].buf = data;//接收缓存
  30.     msgs[1].len = len;//接受长度
  31.     msgs[1].scl_rate = SENSOR_I2C_RATE
 

 

 

 


 
 


 
 

按部分讲解
 

1、适配器
 

dev-i2c0.c
 

  1. struct platform_device s3c_device_i2c0 = {
  2. 	.name		  = "s3c2410-i2c",
  3. #ifdef CONFIG_S3C_DEV_I2C1
  4. 	.id		  = 0,
  5. #else
  6. 	.id		  = -1,
  7. #endif
  8. 	.num_resources	  = ARRAY_SIZE(s3c_i2c_resource),
  9. 	.resource	  = s3c_i2c_resource,
  10. };
  11.  
  12. static struct s3c2410_platform_i2c default_i2c_data0 __initdata = {
  13. 	.flags		= 0,
  14. 	.slave_addr	= 0x10,
  15. 	.frequency	= 100*1000,
  16. 	.sda_delay	= 100,
  17. };
  18.  
  19. void __init s3c_i2c0_set_platdata(struct s3c2410_platform_i2c *pd)
  20. {
  21. 	struct s3c2410_platform_i2c *npd;
  22.  
  23. 	if (!pd)
  24. 		pd = &default_i2c_data0;
  25.  
  26. 	npd = kmemdup(pd, sizeof(struct s3c2410_platform_i2c), GFP_KERNEL);
  27. 	if (!npd)
  28. 		printk(KERN_ERR "%s: no memory for platform data\n", __func__);
  29. 	else if (!npd->cfg_gpio)
  30. 		npd->cfg_gpio = s3c_i2c0_cfg_gpio;//set GPIO as I2C func
  31.  
  32. 	s3c_device_i2c0.dev.platform_data = npd;}//作私有变量
 


 
 

mach-mini2440.c　//描述板子上的硬件设备信息
 

 

  1. static struct i2c_board_info mini2440_i2c_devs[] __initdata = {
  2. 	{
  3. 		I2C_BOARD_INFO("24c08", 0x50), //type=24c08--device name
  4. 		.platform_data = &at24c08,	   //addr=0x50--device addr
  5. 	},
  6. };
  7. i2c_register_board_info(0, mini2440_i2c_devs,
  8. 				ARRAY_SIZE(mini2440_i2c_devs));//添加i2c外设	
  9. 。。。
  10. platform_add_devices（&s3c_device_i2c0）;
  11. 。。。
 

 

 

 

 

 

i2c-s3c2410.c
 

 

 

  1. /* device driver for platform bus bits */
  2.  
  3. static struct platform_device_id s3c24xx_driver_ids[] = {
  4. 	{
  5. 		.name		= "s3c2410-i2c",
  6. 		.driver_data	= TYPE_S3C2410,
  7. 	}, {
  8. 		.name		= "s3c2440-i2c",
  9. 		.driver_data	= TYPE_S3C2440,
  10. 	}, { },
  11. };
  12.  
  13. static struct platform_driver s3c24xx_i2c_driver = {
  14. 	.probe		= s3c24xx_i2c_probe,
  15. 	.remove		= s3c24xx_i2c_remove,
  16. 	.id_table	= s3c24xx_driver_ids,
  17. 	.driver		= {
  18. 		.owner	= THIS_MODULE,
  19. 		.name	= "s3c-i2c",
  20. 		.pm	= S3C24XX_DEV_PM_OPS,
  21. 	},
  22. };
 
 


 
 


 
 


 
 


 
 


 
 


 
 


 
 

 

  1. <pre name="code" class="cpp">/*platform_bus_type的match函数*/
  2. static int platform_match(struct device *dev, struct device_driver *drv)
  3. {
  4. 	struct platform_device *pdev = to_platform_device(dev);
  5. 	struct platform_driver *pdrv = to_platform_driver(drv);
  6.  
  7. 	/* match against the id table first */
  8. 	if (pdrv->id_table)
  9. 		return platform_match_id(pdrv->id_table, pdev) != NULL;
  10.  
  11. 	/* fall-back to driver name match */
  12. 	return (strcmp(pdev->name, drv->name) == 0);
  13. }
  14.  
  15. static const struct platform_device_id *platform_match_id(
  16. 			struct platform_device_id *id,
  17. 			struct platform_device *pdev)
  18. {
  19. 	while (id->name[0]) {
  20.                 /*比较pdev设备名和驱动支持列表*/
  21. 		if (strcmp(pdev->name, id->name) == 0) {
  22. 			pdev->id_entry = id;
  23. 			return id;
  24. 		}
  25. 		id++;
  26. 	}
  27. 	return NULL;
  28. }
  29. 由上面可以看出，设备名要在驱动支持列表里头才可以配对
  30.  
  31. /* s3c24xx_i2c_probe
  32.  *
  33.  * called by the bus driver when a suitable device is found
  34. */
  35.  
  36. static int s3c24xx_i2c_probe(struct platform_device *pdev)
  37. {
  38.     struct s3c24xx_i2c *i2c;
  39.     struct s3c2410_platform_i2c *pdata;
  40.     struct resource *res;
  41.     int ret;
  42. 　　/*取得私有变量--有时是获得指针，有时是获得变量，这里是获得已经初始化好的变量*/
  43.     pdata = pdev->dev.platform_data;
  44.     if (!pdata) {
  45.         dev_err(&pdev->dev, "no platform data\n");
  46.         return -EINVAL;
  47.     }
  48.  
  49.     i2c = kzalloc(sizeof(struct s3c24xx_i2c), GFP_KERNEL);
  50.     if (!i2c) {
  51.         dev_err(&pdev->dev, "no memory for state\n");
  52.         return -ENOMEM;
  53.     }
  54. 　　/*初始化adapter*/　
  55.     strlcpy(i2c->adap.name, "s3c2410-i2c", sizeof(i2c->adap.name));
  56.     i2c->adap.owner   = THIS_MODULE;
  57.     i2c->adap.algo    = &s3c24xx_i2c_algorithm;//通信方法，当有数据要传输时都会调用该函数
  58.     i2c->adap.retries = 2;
  59.     i2c->adap.class   = I2C_CLASS_HWMON | I2C_CLASS_SPD;
  60.     i2c->tx_setup     = 50;
  61.  
  62.     spin_lock_init(&i2c->lock);
  63.     init_waitqueue_head(&i2c->wait);
  64.  
  65.     /* find the clock and enable it */
  66.  
  67.     i2c->dev = &pdev->dev;
  68.     i2c->clk = clk_get(&pdev->dev, "i2c");
  69.     if (IS_ERR(i2c->clk)) {
  70.         dev_err(&pdev->dev, "cannot get clock\n");
  71.         ret = -ENOENT;
  72.         goto err_noclk;
  73.     }
  74.  
  75.     dev_dbg(&pdev->dev, "clock source %p\n", i2c->clk);
  76.  
  77.     clk_enable(i2c->clk);
  78.  
  79.     /* map the registers */
  80.  
  81.     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  82.     if (res == NULL) {
  83.         dev_err(&pdev->dev, "cannot find IO resource\n");
  84.         ret = -ENOENT;
  85.         goto err_clk;
  86.     }
  87.  
  88.     i2c->ioarea = request_mem_region(res->start, resource_size(res),
  89.                      pdev->name);
  90.  
  91.     if (i2c->ioarea == NULL) {
  92.         dev_err(&pdev->dev, "cannot request IO\n");
  93.         ret = -ENXIO;
  94.         goto err_clk;
  95.     }
  96.  
  97.     i2c->regs = ioremap(res->start, resource_size(res));
  98.  
  99.     if (i2c->regs == NULL) {
  100.         dev_err(&pdev->dev, "cannot map IO\n");
  101.         ret = -ENXIO;
  102.         goto err_ioarea;
  103.     }
  104.  
  105.     dev_dbg(&pdev->dev, "registers %p (%p, %p)\n",
  106.         i2c->regs, i2c->ioarea, res);
  107.  
  108.     /* setup info block for the i2c core */
  109.  
  110.     i2c->adap.algo_data = i2c;
  111.     i2c->adap.dev.parent = &pdev->dev;
  112.  
  113.     /* initialise the i2c controller */
  114.  
  115.     ret = s3c24xx_i2c_init(i2c);//初始化i2c频率
  116.     if (ret != 0)
  117.         goto err_iomap;
  118.  
  119.     /* find the IRQ for this unit (note, this relies on the init call to
  120.      * ensure no current IRQs pending
  121.      */
  122.  
  123.     i2c->irq = ret = platform_get_irq(pdev, 0);
  124.     if (ret <= 0) {
  125.         dev_err(&pdev->dev, "cannot find IRQ\n");
  126.         goto err_iomap;
  127.     }
  128.     /*注册中断，每当发送或者接受一个完整的字节时就会进入中断*/
  129.     ret = request_irq(i2c->irq, s3c24xx_i2c_irq, IRQF_DISABLED,
  130.               dev_name(&pdev->dev), i2c);
  131.  
  132.     if (ret != 0) {
  133.         dev_err(&pdev->dev, "cannot claim IRQ %d\n", i2c->irq);
  134.         goto err_iomap;
  135.     }
  136.  
  137.  
  138.     /* Note, previous versions of the driver used i2c_add_adapter()
  139.      * to add the bus at any number. We now pass the bus number via
  140.      * the platform data, so if unset it will now default to always
  141.      * being bus 0.
  142.      */
  143.  
  144.     i2c->adap.nr = pdata->bus_num;
  145. 　　/*向系统添加i2c适配器*/　
  146.     ret = i2c_add_numbered_adapter(&i2c->adap);
  147.     if (ret < 0) {
  148.         dev_err(&pdev->dev, "failed to add bus to i2c core\n");
  149.         goto err_cpufreq;
  150.     }
  151.  
  152.     platform_set_drvdata(pdev, i2c);
  153.  
  154.     dev_info(&pdev->dev, "%s: S3C I2C adapter\n", dev_name(&i2c->adap.dev));
  155.     return 0;
  156.  
  157.  err_cpufreq:
  158.     s3c24xx_i2c_deregister_cpufreq(i2c);
  159.  
  160.  err_irq:
  161.     free_irq(i2c->irq, i2c);
  162.  
  163.  err_iomap:
  164.     iounmap(i2c->regs);
  165.  
  166.  err_ioarea:
  167.     release_resource(i2c->ioarea);
  168.     kfree(i2c->ioarea);
  169.  
  170.  err_clk:
  171.     clk_disable(i2c->clk);
  172.     clk_put(i2c->clk);
  173.  
  174.  err_noclk:
  175.     kfree(i2c);
  176.     return ret;
  177. }
  178.  
  179. /* i2c bus registration info */
  180.  
  181. static const struct i2c_algorithm s3c24xx_i2c_algorithm = {
  182.     .master_xfer        = s3c24xx_i2c_xfer,//通信方法
  183.     .functionality        = s3c24xx_i2c_func,
  184. };
  185.  
  186. /* s3c24xx_i2c_xfer
  187.  *
  188.  * first port of call from the i2c bus code when an message needs
  189.  * transferring across the i2c bus.
  190. */
  191.  
  192. static int s3c24xx_i2c_xfer(struct i2c_adapter *adap,
  193.             struct i2c_msg *msgs, int num)
  194. {
  195.     struct s3c24xx_i2c *i2c = (struct s3c24xx_i2c *)adap->algo_data;
  196.     int retry;
  197.     int ret;
  198.  
  199.     for (retry = 0; retry < adap->retries; retry++) {
  200.  
  201.         ret = s3c24xx_i2c_doxfer(i2c, msgs, num);//继续往下调用
  202.  
  203.         if (ret != -EAGAIN)
  204.             return ret;
  205.  
  206.         dev_dbg(i2c->dev, "Retrying transmission (%d)\n", retry);
  207.  
  208.         udelay(100);
  209.     }
  210.  
  211.     return -EREMOTEIO;
  212. }
  213.  
  214. /* s3c24xx_i2c_doxfer
  215.  *
  216.  * this starts an i2c transfer
  217. */
  218.  
  219. static int s3c24xx_i2c_doxfer(struct s3c24xx_i2c *i2c,
  220.                   struct i2c_msg *msgs, int num)
  221. {
  222.     unsigned long timeout;
  223.     unsigned long iicstat;
  224.     int ret;
  225.  
  226.     if (i2c->suspended)
  227.         return -EIO;
  228.  
  229.     ret = s3c24xx_i2c_set_master(i2c);
  230.     if (ret != 0) {
  231.         dev_err(i2c->dev, "cannot get bus (error %d)\n", ret);
  232.         ret = -EAGAIN;
  233.         goto out;
  234.     }
  235.  
  236.     spin_lock_irq(&i2c->lock);
  237. 　　//获取待传输的msg　
  238.     i2c->msg     = msgs;//
  239.     i2c->msg_num = num;
  240.     i2c->msg_ptr = 0;
  241.     i2c->msg_idx = 0;
  242.     i2c->state   = STATE_START;
  243.  
  244.     s3c24xx_i2c_enable_irq(i2c);
  245.     s3c24xx_i2c_message_start(i2c, msgs);//启动发送，发送address。当address传输完后，进入中断，在中断里判断是否传输错误
  246.     spin_unlock_irq(&i2c->lock);
  247.  
  248.     timeout = wait_event_timeout(i2c->wait, i2c->msg_num == 0, HZ * 1);//等待超时或者传输完成。
  249.  
  250.     ret = i2c->msg_idx;
  251.  
  252.     /* having these next two as dev_err() makes life very
  253.      * noisy when doing an i2cdetect */
  254.  
  255.     if (timeout == 0) {
  256.         dev_dbg(i2c->dev, "timeout\n");
  257.         iicstat = readl(i2c->regs + S3C2410_IICSTAT);
  258.  
  259.         /* stop the transfer */
  260.         iicstat &= ~(S3C2410_IICSTAT_START | S3C2410_IICSTAT_TXRXEN);
  261.         writel(iicstat, i2c->regs + S3C2410_IICSTAT);
  262.  
  263.         i2c->state = STATE_STOP;
  264.  
  265.         s3c24xx_i2c_master_complete(i2c, ret);
  266.         s3c24xx_i2c_disable_irq(i2c);
  267.  
  268.         goto out;
  269.     }
  270.     else if (ret != num)
  271.         dev_dbg(i2c->dev, "incomplete xfer (%d)\n", ret);
  272.  
  273.     /* ensure the stop has been through the bus */
  274.  
  275.     udelay(50);
  276.  
  277.  out:
  278.     return ret;
  279. }
  280.  
  281. /* s3c24xx_i2c_message_start
  282.  *
  283.  * put the start of a message onto the bus
  284. */
  285.  
  286. static void s3c24xx_i2c_message_start(struct s3c24xx_i2c *i2c,
  287.                       struct i2c_msg *msg)
  288. {
  289.     unsigned int addr = (msg->addr & 0x7f) << 1;//获取address并左移一位，第８位表示读写
  290.     unsigned long stat;
  291.     unsigned long iiccon;
  292.  
  293.     stat = 0;
  294.     stat |=  S3C2410_IICSTAT_TXRXEN;
  295.  
  296.     if (msg->flags & I2C_M_RD) {
  297.         stat |= S3C2410_IICSTAT_MASTER_RX;
  298.         addr |= 1;//赋值第８位
  299.     } else
  300.         stat |= S3C2410_IICSTAT_MASTER_TX;
  301.  
  302.     if (msg->flags & I2C_M_REV_DIR_ADDR)
  303.         addr ^= 1;
  304.  
  305.     /* todo - check for wether ack wanted or not */
  306.     s3c24xx_i2c_enable_ack(i2c);
  307.  
  308.     iiccon = readl(i2c->regs + S3C2410_IICCON);
  309.     writel(stat, i2c->regs + S3C2410_IICSTAT);//启动传输
  310.  
  311.     dev_dbg(i2c->dev, "START: %08lx to IICSTAT, %02x to DS\n", stat, addr);
  312.     writeb(addr, i2c->regs + S3C2410_IICDS);//将地址写到IICDS，通过ＳＤＡ发送
  313.  
  314.     /* delay here to ensure the data byte has gotten onto the bus
  315.      * before the transaction is started */
  316.  
  317.     ndelay(i2c->tx_setup);
  318.  
  319.     //dev_dbg(i2c->dev, "iiccon, %08lx\n", iiccon);
  320.     //writel(iiccon, i2c->regs + S3C2410_IICCON);
  321.  
  322.     stat |= S3C2410_IICSTAT_START;
  323.     writel(stat, i2c->regs + S3C2410_IICSTAT);
  324. }
  325. /*发送完一字节进中断*/
  326. static irqreturn_t s3c24xx_i2c_irq(int irqno, void *dev_id)
  327. {
  328.     struct s3c24xx_i2c *i2c = dev_id;
  329.     unsigned long status;
  330.     unsigned long tmp;
  331.  
  332.     status = readl(i2c->regs + S3C2410_IICSTAT);//以下是判断是否传输有错误
  333.  
  334.     if (status & S3C2410_IICSTAT_ARBITR) {
  335.         /* deal with arbitration loss */
  336.         dev_err(i2c->dev, "deal with arbitration loss\n");
  337.     }
  338.  
  339.     if (i2c->state == STATE_IDLE) {
  340.         dev_dbg(i2c->dev, "IRQ: error i2c->state == IDLE\n");
  341.  
  342.         tmp = readl(i2c->regs + S3C2410_IICCON);
  343.         tmp &= ~S3C2410_IICCON_IRQPEND;
  344.         writel(tmp, i2c->regs +  S3C2410_IICCON);
  345.         goto out;
  346.     }
  347.  
  348.     /* pretty much this leaves us with the fact that we've
  349.      * transmitted or received whatever byte we last sent */
  350.  
  351.     i2c_s3c_irq_nextbyte(i2c, status);//传送下一个字节
  352.  
  353.  out:
  354.     return IRQ_HANDLED;
  355. }
  356.  
  357. static int i2c_s3c_irq_nextbyte(struct s3c24xx_i2c *i2c, unsigned long iicstat)
  358. {
  359.     unsigned long tmp;
  360.     unsigned char byte;
  361.     int ret = 0;
  362.  
  363.     switch (i2c->state) {
  364.  
  365.     case STATE_IDLE:
  366.         dev_err(i2c->dev, "%s: called in STATE_IDLE\n", __func__);
  367.         goto out;
  368.         break;
  369.  
  370.     case STATE_STOP:
  371.         dev_err(i2c->dev, "%s: called in STATE_STOP\n", __func__);
  372.         s3c24xx_i2c_disable_irq(i2c);
  373.         goto out_ack;
  374.  
  375.     case STATE_START://标志为ＳＴＡＲＴ有两种情况:1、刚开始，２、ＲＥＡＤ的重启时候
  376.         /* last thing we did was send a start condition on the
  377.          * bus, or started a new i2c message
  378.          */
  379.  
  380.         if (iicstat & S3C2410_IICSTAT_LASTBIT &&
  381.             !(i2c->msg->flags & I2C_M_IGNORE_NAK)) {
  382.             /* ack was not received... */
  383.  
  384.             dev_dbg(i2c->dev, "ack was not received\n");
  385.             s3c24xx_i2c_stop(i2c, -ENXIO);
  386.             goto out_ack;
  387.         }
  388.  
  389.         if (i2c->msg->flags & I2C_M_RD)
  390.             i2c->state = STATE_READ;//ＲＥＡＤ的重启时候        
  391.         else
  392.             i2c->state = STATE_WRITE;//刚开始传输
  393.  
  394.         /* terminate the transfer if there is nothing to do
  395.          * as this is used by the i2c probe to find devices. */
  396.  
  397.         if (is_lastmsg(i2c) && i2c->msg->len == 0) {
  398.             s3c24xx_i2c_stop(i2c, 0);
  399.             goto out_ack;
  400.         }
  401.  
  402.         if (i2c->state == STATE_READ)//如果是ＲＥＡＤ，先要未读准备一下。如只读一个字节，如果是则要设置读完后主机不发送ＡＣＫ等
  403.             goto prepare_read;
  404.  
  405.         /* fall through to the write state, as we will need to
  406.          * send a byte as well */
  407.  
  408.     case STATE_WRITE:
  409.         /* we are writing data to the device... check for the
  410.          * end of the message, and if so, work out what to do
  411.          */
  412.  
  413.         if (!(i2c->msg->flags & I2C_M_IGNORE_NAK)) {
  414.             if (iicstat & S3C2410_IICSTAT_LASTBIT) {
  415.                 dev_dbg(i2c->dev, "WRITE: No Ack\n");
  416.  
  417.                 s3c24xx_i2c_stop(i2c, -ECONNREFUSED);
  418.                 goto out_ack;
  419.             }
  420.         }
  421.  
  422.  retry_write:
  423.  
  424.         if (!is_msgend(i2c)) {//msg是否传完数据
  425.             byte = i2c->msg->buf[i2c->msg_ptr++];//指针自加１
  426.             writeb(byte, i2c->regs + S3C2410_IICDS);//未传完数据，则要将数据写到ＣＤＳ，通过ＳＤＡ发送
  427.  
  428.             /* delay after writing the byte to allow the
  429.              * data setup time on the bus, as writing the
  430.              * data to the register causes the first bit
  431.              * to appear on SDA, and SCL will change as
  432.              * soon as the interrupt is acknowledged */
  433.  
  434.             ndelay(i2c->tx_setup);
  435.  
  436.         } else if (!is_lastmsg(i2c)) {//如果msg数据传完，且后面还有msg,则要跳到下一个msg
  437.             /* we need to go to the next i2c message */
  438.  
  439.             dev_dbg(i2c->dev, "WRITE: Next Message\n");
  440.  
  441.             i2c->msg_ptr = 0;
  442.             i2c->msg_idx++;
  443.             i2c->msg++;//跳到下一个msg
  444.  
  445.             /* check to see if we need to do another message */
  446.             if (i2c->msg->flags & I2C_M_NOSTART) {
  447.  
  448.                 if (i2c->msg->flags & I2C_M_RD) {
  449.                     /* cannot do this, the controller
  450.                      * forces us to send a new START
  451.                      * when we change direction */
  452.  
  453.                     s3c24xx_i2c_stop(i2c, -EINVAL);
  454.                 }
  455.  
  456.                 goto retry_write;
  457.             } else {
  458.                 /* send the new start */
  459.                 s3c24xx_i2c_message_start(i2c, i2c->msg);//这里是在case WRITE里，该msg数据传完(片内地址传完)，且后面还有msg待传输，说明是主机要向从机读数据。因此重启Ｉ２Ｃ
  460.                 i2c->state = STATE_START;//设置Ｉ２Ｃ状态
  461.             }
  462.  
  463.         } else {
  464.             /* send stop */
  465.  
  466.             s3c24xx_i2c_stop(i2c, 0);
  467.         }
  468.         break;
  469.  
  470.     case STATE_READ:
  471.         /* we have a byte of data in the data register, do
  472.          * something with it, and then work out wether we are
  473.          * going to do any more read/write
  474.          */
  475.  
  476.         byte = readb(i2c->regs + S3C2410_IICDS);//(接受一个字节会进中断，且将值放在ＣＤＳ里)，获取数据
  477.         i2c->msg->buf[i2c->msg_ptr++] = byte;//ptr指向下一个字节
  478.  
  479.  prepare_read:
  480.         if (is_msglast(i2c)) {//仅剩最后一个字节未读取
  481.             /* last byte of buffer */
  482.  
  483.             if (is_lastmsg(i2c))
  484.                 s3c24xx_i2c_disable_ack(i2c);//到时不发送ＡＣＫ
  485.  
  486.         } 
  487. 　　　　　else if (is_msgend(i2c)) //数据接受完毕
  488. 　　　　　{
  489.             /* ok, we've read the entire buffer, see if there
  490.              * is anything else we need to do */
  491.  
  492.             if (is_lastmsg(i2c)) {//最后一个msg ?
  493.                 /* last message, send stop and complete */
  494.                 dev_dbg(i2c->dev, "READ: Send Stop\n");
  495.  
  496.                 s3c24xx_i2c_stop(i2c, 0);//说明已经全部接受完毕，主机给从机发送停止信号
  497.             } else {
  498.                 /* go to the next transfer */
  499.                 dev_dbg(i2c->dev, "READ: Next Transfer\n");
  500.  
  501.                 i2c->msg_ptr = 0;
  502.                 i2c->msg_idx++;
  503.                 i2c->msg++;
  504.             }
  505.         }
  506.  
  507.         break;
  508.     }
  509.  
  510.     /* acknowlegde the IRQ and get back on with the work */
  511. //清中断，重新传输
  512.  out_ack:
  513.     tmp = readl(i2c->regs + S3C2410_IICCON);
  514.     tmp &= ~S3C2410_IICCON_IRQPEND;
  515.     writel(tmp, i2c->regs + S3C2410_IICCON);
  516.  out:
  517.     return ret;
  518. }
  519.  
 

 

 

 

 

 2、core 

 

//除了添加adapter外还初始化并注册了挂接在这个adapter上的设备
 

 

  1. int i2c_add_numbered_adapter(struct i2c_adapter *adap)
  2. {//we have already set the adap->nr
  3. 	int	id;
  4. 	int	status;
  5.  
  6. 	if (adap->nr & ~MAX_ID_MASK)
  7. 		return -EINVAL;
  8.  
  9. retry:
  10. 	if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
  11. 		return -ENOMEM;
  12.  
  13. 	mutex_lock(&core_lock);
  14. 	/* "above" here means "above or equal to", sigh;
  15. 	 * we need the "equal to" result to force the result
  16. 	 */
  17. 	status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);//建立id与adap的关系
  18.  
  19. 	if (status == 0 && id != adap->nr) {
  20. 		status = -EBUSY;
  21. 		idr_remove(&i2c_adapter_idr, id);
  22. 	}
  23. 	mutex_unlock(&core_lock);
  24. 	if (status == -EAGAIN)
  25. 		goto retry;
  26.  
  27. 	if (status == 0)
  28. 		<span style="color:#ff0000;">status = i2c_register_adapter(adap);</span>
  29. 	return status;
  30. }
  31.  
  32. static int i2c_register_adapter(struct i2c_adapter *adap)
  33. {
  34. 	int res = 0;
  35.  
  36. 	/* Can't register until after driver model init */
  37. 	if (unlikely(WARN_ON(!i2c_bus_type.p))) {
  38. 		res = -EAGAIN;
  39. 		goto out_list;
  40. 	}
  41.  
  42. 	rt_mutex_init(&adap->bus_lock);
  43. 	mutex_init(&adap->userspace_clients_lock);
  44. 	INIT_LIST_HEAD(&adap->userspace_clients);
  45.  
  46. 	/* Set default timeout to 1 second if not already set */
  47. 	if (adap->timeout == 0)
  48. 		adap->timeout = HZ;
  49. 												 //adap->dev.name=i2c0
  50. 	dev_set_name(&adap->dev, "i2c-%d", adap->nr);//i2c-0
  51. 	adap->dev.bus = &i2c_bus_type;
  52. 	adap->dev.type = &i2c_adapter_type;
  53. 	res = device_register(&adap->dev);//register adapter dev
  54. 	if (res)
  55. 		goto out_list;
  56.  
  57. 	dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
  58.  
  59. #ifdef CONFIG_I2C_COMPAT
  60. 	res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
  61. 				       adap->dev.parent);
  62. 	if (res)
  63. 		dev_warn(&adap->dev,
  64. 			 "Failed to create compatibility class link\n");
  65. #endif
  66.  
  67. 	/* create pre-declared device nodes */
  68. 	if (adap->nr < __i2c_first_dynamic_bus_num)  //will call this
  69. 		<span style="color:#ff0000;"><strong>i2c_scan_static_board_info(adap);</strong></span>
  70.  
  71. 	/* Notify drivers */
  72. 	mutex_lock(&core_lock);	//will not do this part
  73. 	bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
  74. 	mutex_unlock(&core_lock);
  75.  
  76. 	return 0;
  77.  
  78. out_list:
  79. 	mutex_lock(&core_lock);
  80. 	idr_remove(&i2c_adapter_idr, adap->nr);
  81. 	mutex_unlock(&core_lock);
  82. 	return res;
  83. }
  84.  
  85. static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
  86. {
  87. 	struct i2c_devinfo	*devinfo;
  88.  
  89. 	down_read(&__i2c_board_lock);
  90. 	list_for_each_entry(devinfo, &__i2c_board_list, list) {
  91. 		if (devinfo->busnum == adapter->nr
  92. 			&& !i2c_new_device(adapter,
  93. 						&devinfo->board_info)) //initilize the device
  94. 			dev_err(&adapter->dev,
  95. 				"Can't create device at 0x%02x\n",
  96. 				devinfo->board_info.addr);
  97. 	}
  98. 	up_read(&__i2c_board_lock);
  99. }
  100.  
  101. struct i2c_client *
  102. i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
  103. {
  104. 	struct i2c_client	*client;
  105. 	int			status;
  106.  
  107. 	client = kzalloc(sizeof *client, GFP_KERNEL);
  108. 	if (!client)
  109. 		return NULL;
  110.  
  111. 	client->adapter = adap;
  112.  
  113. 	client->dev.platform_data = info->platform_data;
  114.  
  115. 	if (info->archdata)
  116. 		client->dev.archdata = *info->archdata;
  117.  
  118. 	client->flags = info->flags;
  119. 	client->addr = info->addr;
  120. 	client->irq = info->irq;
  121.  
  122. 	strlcpy(client->name, info->type, sizeof(client->name));//set client name
  123.  
  124. 	/* Check for address validity */
  125. 	status = i2c_check_client_addr_validity(client);
  126. 	if (status) {
  127. 		dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
  128. 			client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
  129. 		goto out_err_silent;
  130. 	}
  131.  
  132. 	/* Check for address business */
  133. 	status = i2c_check_addr_busy(adap, client->addr);//check the addr occupied?
  134. 	if (status)
  135. 		goto out_err;
  136.  
  137. 	client->dev.parent = &client->adapter->dev;//add on adapter
  138. 	client->dev.bus = &i2c_bus_type;
  139. 	client->dev.type = &i2c_client_type;
  140. #ifdef CONFIG_OF
  141. 	client->dev.of_node = info->of_node;
  142. #endif
  143.  
  144. 	dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
  145. 		     client->addr);//set clinet->dev.name=0-0x45
  146. 	status = device_register(&client->dev);//add the device first
  147. 	if (status)
  148. 		goto out_err;
  149.  
  150. 	dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
  151. 		client->name, dev_name(&client->dev));
  152.  
  153. 	return client;
  154.  
  155. out_err:
  156. 	dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
  157. 		"(%d)\n", client->name, client->addr, status);
  158. out_err_silent:
  159. 	kfree(client);
  160. 	return NULL;
  161. }
  162. int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
  163. {
  164. 	unsigned long orig_jiffies;
  165. 	int ret, try;
  166. 	if (adap->algo->master_xfer) {
  167. #ifdef DEBUG
  168. 		for (ret = 0; ret < num; ret++) {
  169. 			dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
  170. 				"len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
  171. 				? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
  172. 				(msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
  173. 		}
  174. #endif
  175.  
  176. 		if (in_atomic() || irqs_disabled()) {
  177. 			ret = i2c_trylock_adapter(adap);
  178. 			if (!ret)
  179. 				/* I2C activity is ongoing. */
  180. 				return -EAGAIN;
  181. 		} else {
  182. 			i2c_lock_adapter(adap);
  183. 		}/* Retry automatically on arbitration loss */
  184. orig_jiffies = jiffies;
  185. for (ret = 0, try = 0; try <= adap->retries; try++) {
  186. ret = adap->algo->master_xfer(adap, msgs, num);//transfer msg--见上面
  187. if (ret != -EAGAIN)
  188. break;
  189. if (time_after(jiffies, orig_jiffies + adap->timeout))
  190. break;
  191. }
  192. i2c_unlock_adapter(adap);
  193. return ret;
  194. } else {
  195. dev_dbg(&adap->dev, "I2C level transfers not supported\n");
  196. return -EOPNOTSUPP;
  197. }
  198. }
 

 

 
 
 
  
 
   
 
   
 
   
 
   
 
   
 
   

 
 
 
   
　　　
 
 
  
 
 
 


                

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

  
闽ICP备14008679号