Linux I2C驱动源码分析(二)
 

下面开始分析linux/drivers/i2c/busses/i2c-s3c2410.c,在设备与驱动匹配成功后,会执行s3c24xx_i2c_probe()函数,其源码如下:

/* s3c24xx_i2c_probe called by the bus driver when a suitable device is found*/

static int s3c24xx_i2c_probe(struct platform_device *pdev)

{

       struct s3c24xx_i2c *i2c;

       struct s3c2410_platform_i2c *pdata;

       struct resource *res;

       int ret;

/*这里pdev->dev.platform_data 在s3c_i2c0_set_platdata()函数中设置,指向了系统初始化时的设置过的s3c2410_platform_i2c结构体*/

       pdata = pdev->dev.platform_data;

       if (!pdata) {

              dev_err(&pdev->dev, "no platform data\n");

              return -EINVAL;

       }

    /*申请一段sizeof(struct s3c24xx_i2c)的内存,并清0 */

       i2c = kzalloc(sizeof(struct s3c24xx_i2c), GFP_KERNEL);

       if (!i2c) {

              dev_err(&pdev->dev, "no memory for state\n");

              return -ENOMEM;

       }

 

       strlcpy(i2c->adap.name, "s3c2410-i2c", sizeof(i2c->adap.name));

       i2c->adap.owner   = THIS_MODULE;

       i2c->adap.algo    = &s3c24xx_i2c_algorithm;  /*设置I2C总线的通信函数 */

       i2c->adap.retries = 2;

       i2c->adap.class   = I2C_CLASS_HWMON | I2C_CLASS_SPD;

       i2c->tx_setup     = 50;

 

       spin_lock_init(&i2c->lock);

       init_waitqueue_head(&i2c->wait);  /*初始化等待队列头 */

 

       /* find the clock and enable it */

   /*获得I2C设备的时钟,并使能I2C控制器时钟,后面会具体分析*/

       i2c->dev = &pdev->dev;

       i2c->clk = clk_get(&pdev->dev, "i2c");

       if (IS_ERR(i2c->clk)) {

              dev_err(&pdev->dev, "cannot get clock\n");

              ret = -ENOENT;

              goto err_noclk;

       }

       dev_dbg(&pdev->dev, "clock source %p\n", i2c->clk);

       clk_enable(i2c->clk);

 

       /* map the registers */

    /*获取系统的物理地址,中断等资源信息,并进行物理地址到虚拟地址的映射 */

       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

       if (res == NULL) {

              dev_err(&pdev->dev, "cannot find IO resource\n");

              ret = -ENOENT;

              goto err_clk;

       }

 

       i2c->ioarea = request_mem_region(res->start, resource_size(res),

                                    pdev->name);

 

       if (i2c->ioarea == NULL) {

              dev_err(&pdev->dev, "cannot request IO\n");

              ret = -ENXIO;

              goto err_clk;

       }

 

       i2c->regs = ioremap(res->start, resource_size(res));

 

       if (i2c->regs == NULL) {

              dev_err(&pdev->dev, "cannot map IO\n");

              ret = -ENXIO;

              goto err_ioarea;

       }

 

       dev_dbg(&pdev->dev, "registers %p (%p, %p)\n",

              i2c->regs, i2c->ioarea, res);

 

       /* setup info block for the i2c core */

 

       i2c->adap.algo_data = i2c;

       i2c->adap.dev.parent = &pdev->dev;

 

       /* initialise the i2c controller */

  

       ret = s3c24xx_i2c_init(i2c);  /*控制器的初始化, 后面具体会分析 */

       if (ret != 0)

              goto err_iomap;

 

       /* find the IRQ for this unit (note, this relies on the init call to

        * ensure no current IRQs pending

        */

       i2c->irq = ret = platform_get_irq(pdev, 0);  

       if (ret <= 0) {

              dev_err(&pdev->dev, "cannot find IRQ\n");

              goto err_iomap;

       }

 

       ret = request_irq(i2c->irq, s3c24xx_i2c_irq, IRQF_DISABLED,

                       dev_name(&pdev->dev), i2c);   /*申请中断 */

 

       if (ret != 0) {

              dev_err(&pdev->dev, "cannot claim IRQ %d\n", i2c->irq);

              goto err_iomap;

       }

 

       ret = s3c24xx_i2c_register_cpufreq(i2c);

       if (ret < 0) {

              dev_err(&pdev->dev, "failed to register cpufreq notifier\n");

              goto err_irq;

       }

 

       /* Note, previous versions of the driver used i2c_add_adapter()

        * to add the bus at any number. We now pass the bus number via

        * the platform data, so if unset it will now default to always

        * being bus 0.

        */

/* 向对应的I2C总线(总线号)注册adapter */

       i2c->adap.nr = pdata->bus_num;

       ret = i2c_add_numbered_adapter(&i2c->adap);  

if (ret < 0) {

              dev_err(&pdev->dev, "failed to add bus to i2c core\n");

              goto err_cpufreq;

       }

       platform_set_drvdata(pdev, i2c);

       dev_info(&pdev->dev, "%s: S3C I2C adapter\n", dev_name(&i2c->adap.dev));

       return 0;

 err_cpufreq:

       s3c24xx_i2c_deregister_cpufreq(i2c);

 err_irq:

       free_irq(i2c->irq, i2c);

 err_iomap:

       iounmap(i2c->regs);

 err_ioarea:

       release_resource(i2c->ioarea);

       kfree(i2c->ioarea);

 err_clk:

       clk_disable(i2c->clk);

       clk_put(i2c->clk);

 err_noclk:

       kfree(i2c);

       return ret;

}

 

系统在初始化时会将系统硬件中的时钟注册进系统,用双向循环连接起来,在linux/arch/arm/plat-s3c24xx/s3c244x.c中,s3c244x_init_clocks ()函数完成这个操作这个操作。

 

void __init s3c244x_init_clocks(int xtal)

{

       /* initialise the clocks here, to allow other things like the

        * console to use them, and to add new ones after the initialisation

        */

 

       s3c24xx_register_baseclocks(xtal);

       s3c244x_setup_clocks();

       s3c2410_baseclk_add();

}

其中s3c2410_baseclk_add()的源码如下:

/* s3c2410_baseclk_add()

 * Add all the clocks used by the s3c2410 or compatible CPUs

 * such as the S3C2440 and S3C2442.

 * We cannot use a system device as we are needed before any

 * of the init-calls that initialise the devices are actually

 * done.*/

int __init s3c2410_baseclk_add(void)

{

       unsigned long clkslow = __raw_readl(S3C2410_CLKSLOW);

       unsigned long clkcon  = __raw_readl(S3C2410_CLKCON);

       struct clk *clkp;

       struct clk *xtal;

       int ret;

       int ptr;

       clk_upll.enable = s3c2410_upll_enable;

       if (s3c24xx_register_clock(&clk_usb_bus) < 0)

              printk(KERN_ERR "failed to register usb bus clock\n");

       /* register clocks from clock array */

       clkp = init_clocks;

       for (ptr = 0; ptr < ARRAY_SIZE(init_clocks); ptr++, clkp++) {

              /* ensure that we note the clock state */

              clkp->usage = clkcon & clkp->ctrlbit ? 1 : 0;

              ret = s3c24xx_register_clock(clkp);

              if (ret < 0) {

                     printk(KERN_ERR "Failed to register clock %s (%d)\n",

                            clkp->name, ret);

              }

       }

       /* We must be careful disabling the clocks we are not intending to

        * be using at boot time, as subsystems such as the LCD which do

        * their own DMA requests to the bus can cause the system to lockup

        * if they where in the middle of requesting bus access.

        *

        * Disabling the LCD clock if the LCD is active is very dangerous,

        * and therefore the bootloader should be careful to not enable

        * the LCD clock if it is not needed.

       */

       /* install (and disable) the clocks we do not need immediately */

       clkp = init_clocks_disable;

       for (ptr = 0; ptr < ARRAY_SIZE(init_clocks_disable); ptr++, clkp++) {

              ret = s3c24xx_register_clock(clkp);

              if (ret < 0) {

                     printk(KERN_ERR "Failed to register clock %s (%d)\n",

                            clkp->name, ret);

              }

              s3c2410_clkcon_enable(clkp, 0);

       }

       /* show the clock-slow value */

       xtal = clk_get(NULL, "xtal");

       printk("CLOCK: Slow mode (%ld.%ld MHz), %s, MPLL %s, UPLL %s\n",

              print_mhz(clk_get_rate(xtal) /

                      ( 2 * S3C2410_CLKSLOW_GET_SLOWVAL(clkslow))),

              (clkslow & S3C2410_CLKSLOW_SLOW) ? "slow" : "fast",

              (clkslow & S3C2410_CLKSLOW_MPLL_OFF) ? "off" : "on",

              (clkslow & S3C2410_CLKSLOW_UCLK_OFF) ? "off" : "on");

 

       s3c_pwmclk_init();

       return 0;

}

根据注释中给的提示,时钟被分成了两部分,init_clocks和init_clocks_disable,其中init_clocks中的时钟是系统启动时会开启的,而init_clocks_disable中的时钟则在系统启动时会关闭。其中函数s3c24xx_register_clock()就是实现讲系统中的时钟插入到双向循环链表中。比如我们这里I2C的时钟的是定义在init_clocks_disable数组中,定义如下:

{

              .name             = "i2c",

              .id           = -1,

              .parent           = &clk_p,

              .enable           = s3c2410_clkcon_enable,

              .ctrlbit     = S3C2410_CLKCON_IIC,

}

结构中保存了I2C控制器中时钟时能位的位置偏移,时钟名字已经时钟时能的函数等信息。

s3c24xx_i2c_probe函数中有一段程序就是用来获取时钟信息,并使能I2C时钟,即:

       /* find the clock and enable it */

       i2c->dev = &pdev->dev;

       i2c->clk = clk_get(&pdev->dev, "i2c");

       if (IS_ERR(i2c->clk)) {

              dev_err(&pdev->dev, "cannot get clock\n");

              ret = -ENOENT;

              goto err_noclk;

       }

       dev_dbg(&pdev->dev, "clock source %p\n", i2c->clk);

       clk_enable(i2c->clk);

 

clk_get(&pdev->dev, "i2c")函数用于获取时钟信息,函数内部会将传入的“i2c”字符串和系统中各时钟的名字进行比较,看是否匹配,看上面的分析可知,I2C控制器时钟注册时的时钟名也是“i2c”,这个过程实际上和device,driver的匹配过程是类似的。clk_get源码如下:

struct clk *clk_get(struct device *dev, const char *id)

{

       struct clk *p;

       struct clk *clk = ERR_PTR(-ENOENT);

       int idno;

       if (dev == NULL || dev->bus != &platform_bus_type)

              idno = -1;

       else

              idno = to_platform_device(dev)->id;

 

       spin_lock(&clocks_lock);

       list_for_each_entry(p, &clocks, list) {

              if (p->id == idno &&

                  strcmp(id, p->name) == 0 &&

                  try_module_get(p->owner)) {

                     clk = p;

                     break;

              }

       }

 

s3c24xx_i2c_probe函数还调用了s3c24xx_i2c_init(i2c)函数进行了S3C2440上I2C控制器硬件上的初始化,源码如下:

/* s3c24xx_i2c_init initialise the controller, set the IO lines and frequency*/

 

static int s3c24xx_i2c_init(struct s3c24xx_i2c *i2c)

{

       unsigned long iicon = S3C2410_IICCON_IRQEN | S3C2410_IICCON_ACKEN;

       struct s3c2410_platform_i2c *pdata;

       unsigned int freq;

       /* get the plafrom data */

       pdata = i2c->dev->platform_data;

       /* inititalise the gpio */

       if (pdata->cfg_gpio)

              pdata->cfg_gpio(to_platform_device(i2c->dev));  /*I2C控制器IO的初始化

      

/* write slave address */

/*  写入从设备的地址  */

       writeb(pdata->slave_addr, i2c->regs + S3C2410_IICADD);

       dev_info(i2c->dev, "slave address 0x%02x\n", pdata->slave_addr);

       /* 使能接收发送中断和I2C总线应答信号  */

       writel(iicon, i2c->regs + S3C2410_IICCON);

 

       /* we need to work out the divisors for the clock... */

    /*这里freq用来获取实际的I2C时钟频率,具体指为97KHZ,后面会分析  */

       if (s3c24xx_i2c_clockrate(i2c, &freq) != 0) {

              writel(0, i2c->regs + S3C2410_IICCON);

              dev_err(i2c->dev, "cannot meet bus frequency required\n");

              return -EINVAL;

       }

       /* todo - check that the i2c lines aren't being dragged anywhere */

       dev_info(i2c->dev, "bus frequency set to %d KHz\n", freq);

       dev_dbg(i2c->dev, "S3C2410_IICCON=0x%02lx\n", iicon);

       return 0;

}

 

 

/* s3c24xx_i2c_clockrate

 *

 * work out a divisor for the user requested frequency setting,

 * either by the requested frequency, or scanning the acceptable

 * range of frequencies until something is found

*/

 

static int s3c24xx_i2c_clockrate(struct s3c24xx_i2c *i2c, unsigned int *got)

{

       struct s3c2410_platform_i2c *pdata = i2c->dev->platform_data;

/*从系统平台时钟队列中获取pclk的时钟频率,大小为50MHZ */

       unsigned long clkin = clk_get_rate(i2c->clk);

       unsigned int divs, div1;

       unsigned long target_frequency;

       u32 iiccon;

       int freq;

       i2c->clkrate = clkin;

       clkin /= 1000;        /* clkin now in KHz */

       dev_dbg(i2c->dev, "pdata desired frequency %lu\n", pdata->frequency);

       target_frequency = pdata->frequency ? pdata->frequency : 100000;

       target_frequency /= 1000; /* Target frequency now in KHz */

    /* 目标频率在前面default_i2c_data0中frequency为100KHZ,根据PCLK和目标频率计算分频系数,计算后实际频率为97KHZ,即freq 为97K*/

       freq = s3c24xx_i2c_calcdivisor(clkin, target_frequency, &div1, &divs);

       if (freq > target_frequency) {

              dev_err(i2c->dev,

                     "Unable to achieve desired frequency %luKHz."   \

                     " Lowest achievable %dKHz\n", target_frequency, freq);

              return -EINVAL;

       }

       *got = freq;  /*通过传入的指针返回实际频率 */

 

/* 根据时钟选择和分频系数配置对应硬件寄存器 */

       iiccon = readl(i2c->regs + S3C2410_IICCON);

       iiccon &= ~(S3C2410_IICCON_SCALEMASK | S3C2410_IICCON_TXDIV_512);

       iiccon |= (divs-1);

 

       if (div1 == 512)

              iiccon |= S3C2410_IICCON_TXDIV_512;

 

       writel(iiccon, i2c->regs + S3C2410_IICCON); 

    /*  判断是否为S3C2440  */

       if (s3c24xx_i2c_is2440(i2c)) {

              unsigned long sda_delay;

 

              if (pdata->sda_delay) {

                     sda_delay = (freq / 1000) * pdata->sda_delay;

                     sda_delay /= 1000000;

                     sda_delay = DIV_ROUND_UP(sda_delay, 5);

                     if (sda_delay > 3)

                            sda_delay = 3;

                     sda_delay |= S3C2410_IICLC_FILTER_ON;

              } else

                     sda_delay = 0;

 

              dev_dbg(i2c->dev, "IICLC=%08lx\n", sda_delay);

              writel(sda_delay, i2c->regs + S3C2440_IICLC);

       }

 

       return 0;

}

 

       到这里,I2C控制器的硬件初始化操作基本上分析完了,接下来该分析Linux内核I2C总线的通信机制了~~

阅读更多
个人分类: linux驱动
想对作者说点什么? 我来说一句

2.6 内核I2C驱动框架

-

学院

1970年01月01日 08:00

没有更多推荐了,返回首页

不良信息举报

Linux I2C驱动源码分析(二)

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭