Chinaunix首页 | 论坛 | 博客

Johnson的嵌入式技术博客jason2012.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

gfvvz

  • 博客访问： 451585
  • 博文数量： 40
  • 博客积分： 1410
  • 博客等级： 军士长
  • 技术积分： 1396
  • 用 户 组： 普通用户
  • 注册时间： 2011-03-22 19:26
个人简介

嵌入式系统工程师，从事视频、图像、网络、虚拟化等方面的底层软件开发与优化。

文章分类

全部博文（40）

文章存档

2014年（4）

2013年（10）

2012年（14）

2011年（12）

我的朋友
最近访客
推荐博文
相关博文
（三）I2C总线控制器驱动分析及其在BSP上的添加

分类： LINUX

2012-03-30 10:04:53

一、基于s3c6410的I2C总线控制器驱动程序分析及其在BSP中的添加
1. 适配器驱动分析
1.1 平台总线驱动结构体及其注册与注销

点击(此处)折叠或打开

  1. //1. s3c2410 I2C总线的平台驱动结构体
  2. static struct platform_driver s3c24xx_i2c_driver = {
  3.     .probe        = s3c24xx_i2c_probe,
  4.     .remove        = s3c24xx_i2c_remove,
  5.     .id_table    = s3c24xx_driver_ids,
  6.     .driver        = {
  7.         .owner    = THIS_MODULE,
  8.         .name    = "s3c-i2c",
  9.         .pm    = S3C24XX_DEV_PM_OPS,
  10.         .of_match_table = s3c24xx_i2c_match,
  11.     },
  12. };
  13. //2. 注册I2C平台总线驱动
  14. static int __init i2c_adap_s3c_init(void)
  15. {
  16.     return platform_driver_register(&s3c24xx_i2c_driver);
  17. }
  18. subsys_initcall(i2c_adap_s3c_init); //子系统初始化，在系统初始化时在do_initcall中调用
  19. //3. 注销I2C平台总线驱动
  20. static void __exit i2c_adap_s3c_exit(void)
  21. {
  22.     platform_driver_unregister(&s3c24xx_i2c_driver);
  23. }
  24. module_exit(i2c_adap_s3c_exit);
1.2 s3c24xx_i2c_probe函数分析
s3c24xx_i2c_probe函数总的来说是：给s3c24xx_i2c结构体及其私有数据分配内存，并且设置该结构体内的需要设置的成员。

点击(此处)折叠或打开

  1. /* s3c24xx_i2c_probe
  2.  *
  3.  * called by the bus driver when a suitable device is found
  4. */

  6. static int s3c24xx_i2c_probe(struct platform_device *pdev)
  7. {
  8.     struct s3c24xx_i2c *i2c;
  9.     struct s3c2410_platform_i2c *pdata = NULL;
  10.     struct resource *res;
  11.     int ret;
  12.     //1. 判断是否已创建设备节点
  13.     if (!pdev->dev.of_node) {
  14.         pdata = pdev->dev.platform_data; //如果没有，把平台数据赋值给内部指针
  15.         if (!pdata) {
  16.             dev_err(&pdev->dev, "no platform data\n");
  17.             return -EINVAL;
  18.         }
  19.     }
  20.     //2. 分配s3c24xx_i2c结构体内存
  21.     i2c = kzalloc(sizeof(struct s3c24xx_i2c), GFP_KERNEL);
  22.     if (!i2c) {
  23.         dev_err(&pdev->dev, "no memory for state\n");
  24.         return -ENOMEM;
  25.     }
  26.     //3. 分配s3c24xx_i2c结构体私有数据的内存
  27.     i2c->pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
  28.     if (!i2c->pdata) {
  29.         ret = -ENOMEM;
  30.         goto err_noclk;
  31.     }
  32.     //4. 如果私有数据指针不为NULL，复制设备数据
  33.     if (pdata)
  34.         memcpy(i2c->pdata, pdata, sizeof(*pdata));
  35.     else
  36.         s3c24xx_i2c_parse_dt(pdev->dev.of_node, i2c);
  37.     //5. 设置i2c->adap
  38.     strlcpy(i2c->adap.name, "s3c2410-i2c", sizeof(i2c->adap.name));
  39.     i2c->adap.owner = THIS_MODULE;
  40.     i2c->adap.algo = &s3c24xx_i2c_algorithm;
  41.     i2c->adap.retries = 2;
  42.     i2c->adap.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
  43.     i2c->tx_setup = 50;
  44.     //6. 初始化I2C的自旋锁和等待队列
  45.     spin_lock_init(&i2c->lock);
  46.     init_waitqueue_head(&i2c->wait);
  47.     //7. 获取并使能I2C时钟
  48.     /* find the clock and enable it */

  50.     i2c->dev = &pdev->dev;
  51.     i2c->clk = clk_get(&pdev->dev, "i2c");
  52.     if (IS_ERR(i2c->clk)) {
  53.         dev_err(&pdev->dev, "cannot get clock\n");
  54.         ret = -ENOENT;
  55.         goto err_noclk;
  56.     }

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

  60.     clk_enable(i2c->clk);
  61.     //8. 寄存器映射
  62.     /* map the registers */

  64.     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  65.     if (res == NULL) {
  66.         dev_err(&pdev->dev, "cannot find IO resource\n");
  67.         ret = -ENOENT;
  68.         goto err_clk;
  69.     }

  71.     i2c->ioarea = request_mem_region(res->start, resource_size(res),
  72.                      pdev->name);

  74.     if (i2c->ioarea == NULL) {
  75.         dev_err(&pdev->dev, "cannot request IO\n");
  76.         ret = -ENXIO;
  77.         goto err_clk;
  78.     }

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

  82.     if (i2c->regs == NULL) {
  83.         dev_err(&pdev->dev, "cannot map IO\n");
  84.         ret = -ENXIO;
  85.         goto err_ioarea;
  86.     }

  88.     dev_dbg(&pdev->dev, "registers %p (%p, %p)\n",
  89.         i2c->regs, i2c->ioarea, res);
  90.     //9. 为i2c核心设置部分信息
  91.     /* setup info block for the i2c core */

  93.     i2c->adap.algo_data = i2c;
  94.     i2c->adap.dev.parent = &pdev->dev;
  95.     //10. 初始化i2c控制器
  96.     /* initialise the i2c controller */

  98.     ret = s3c24xx_i2c_init(i2c);
  99.     if (ret != 0)
  100.         goto err_iomap;
  101.     //11. 获取并注册I2C IRQ
  102.     /* find the IRQ for this unit (note, this relies on the init call to
  103.      * ensure no current IRQs pending
  104.      */

  106.     i2c->irq = ret = platform_get_irq(pdev, 0);
  107.     if (ret <= 0) {
  108.         dev_err(&pdev->dev, "cannot find IRQ\n");
  109.         goto err_iomap;
  110.     }

  112.     ret = request_irq(i2c->irq, s3c24xx_i2c_irq, 0,
  113.              dev_name(&pdev->dev), i2c);

  115.     if (ret != 0) {
  116.         dev_err(&pdev->dev, "cannot claim IRQ %d\n", i2c->irq);
  117.         goto err_iomap;
  118.     }
  119.     //12. 以CPU的频率注册I2C结构体
  120.     ret = s3c24xx_i2c_register_cpufreq(i2c);
  121.     if (ret < 0) {
  122.         dev_err(&pdev->dev, "failed to register cpufreq notifier\n");
  123.         goto err_irq;
  124.     }

  126.     /* Note, previous versions of the driver used i2c_add_adapter()
  127.      * to add the bus at any number. We now pass the bus number via
  128.      * the platform data, so if unset it will now default to always
  129.      * being bus 0.
  130.      */
  131.     
  132.     i2c->adap.nr = i2c->pdata->bus_num; //当处理器包含多个I2C控制器时，用bus_num区分
  133.     i2c->adap.dev.of_node = pdev->dev.of_node;
  134.     //13. 添加适配器
  135.     ret = i2c_add_numbered_adapter(&i2c->adap);
  136.     if (ret < 0) {
  137.         dev_err(&pdev->dev, "failed to add bus to i2c core\n");
  138.         goto err_cpufreq;
  139.     }

  141.     of_i2c_register_devices(&i2c->adap);
  142.     platform_set_drvdata(pdev, i2c);

  144.     dev_info(&pdev->dev, "%s: S3C I2C adapter\n", dev_name(&i2c->adap.dev));
  145.     clk_disable(i2c->clk);
  146.     return 0;

  148.  err_cpufreq:
  149.     s3c24xx_i2c_deregister_cpufreq(i2c);
  150.  
  151.  err_irq:
  152.     free_irq(i2c->irq, i2c);

  154.  err_iomap:
  155.     iounmap(i2c->regs);

  157.  err_ioarea:
  158.     release_resource(i2c->ioarea);
  159.     kfree(i2c->ioarea);

  161.  err_clk:
  162.     clk_disable(i2c->clk);
  163.     clk_put(i2c->clk);

  165.  err_noclk:
  166.     kfree(i2c);
  167.     return ret;
  168. }

  170. /* s3c24xx_i2c_remove
  171.  *
  172.  * called when device is removed from the bus
  173. */

  175. static int s3c24xx_i2c_remove(struct platform_device *pdev)
  176. {
  177.     struct s3c24xx_i2c *i2c = platform_get_drvdata(pdev);

  179.     s3c24xx_i2c_deregister_cpufreq(i2c);

  181.     i2c_del_adapter(&i2c->adap);
  182.     free_irq(i2c->irq, i2c);

  184.     clk_disable(i2c->clk);
  185.     clk_put(i2c->clk);

  187.     iounmap(i2c->regs);

  189.     release_resource(i2c->ioarea);
  190.     s3c24xx_i2c_dt_gpio_free(i2c);
  191.     kfree(i2c->ioarea);
  192.     kfree(i2c);

  194.     return 0;
  195. }
1.3 s3c24xx_i2c_init函数分析

点击(此处)折叠或打开

  1. /* s3c24xx_i2c_init
  2.  *
  3.  * initialise the controller, set the IO lines and frequency
  4. */

  6. static int s3c24xx_i2c_init(struct s3c24xx_i2c *i2c)
  7. {
  8.     unsigned long iicon = S3C2410_IICCON_IRQEN | S3C2410_IICCON_ACKEN;
  9.     struct s3c2410_platform_i2c *pdata;
  10.     unsigned int freq;

  12.     /* get the plafrom data */

  14.     pdata = i2c->pdata;

  16.     /* inititalise the gpio */

  18.     if (pdata->cfg_gpio)
  19.         pdata->cfg_gpio(to_platform_device(i2c->dev));
  20.     else
  21.         if (s3c24xx_i2c_parse_dt_gpio(i2c))
  22.             return -EINVAL;

  24.     /* write slave address */

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

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

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

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

  34.     if (s3c24xx_i2c_clockrate(i2c, &freq) != 0) {
  35.         writel(0, i2c->regs + S3C2410_IICCON);
  36.         dev_err(i2c->dev, "cannot meet bus frequency required\n");
  37.         return -EINVAL;
  38.     }

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

  42.     dev_info(i2c->dev, "bus frequency set to %d KHz\n", freq);
  43.     dev_dbg(i2c->dev, "S3C2410_IICCON=0x%02lx\n", iicon);

  45.     return 0;
  46. }
2.适配器设备驱动

点击(此处)折叠或打开

  1. static struct resource s3c_i2c0_resource[] = {
  2.     [0] = DEFINE_RES_MEM(S3C_PA_IIC, SZ_4K),
  3.     [1] = DEFINE_RES_IRQ(IRQ_IIC),
  4. };

  6. struct platform_device s3c_device_i2c0 = {
  7.     .name        = "s3c2410-i2c",
  8. #ifdef CONFIG_S3C_DEV_I2C1
  9.     .id        = 0,
  10. #else
  11.     .id        = -1,
  12. #endif
  13.     .num_resources    = ARRAY_SIZE(s3c_i2c0_resource),
  14.     .resource    = s3c_i2c0_resource,
  15. };

  17. struct s3c2410_platform_i2c default_i2c_data __initdata = {
  18.     .flags        = 0,
  19.     .slave_addr    = 0x10,
  20.     .frequency    = 100*1000,
  21.     .sda_delay    = 100,
  22. };

  24. void __init s3c_i2c0_set_platdata(struct s3c2410_platform_i2c *pd)
  25. {
  26.     struct s3c2410_platform_i2c *npd;

  28.     if (!pd)
  29.         pd = &default_i2c_data;

  31.     npd = s3c_set_platdata(pd, sizeof(struct s3c2410_platform_i2c),
  32.              &s3c_device_i2c0);

  34.     if (!npd->cfg_gpio)
  35.         npd->cfg_gpio = s3c_i2c0_cfg_gpio;
  36. }
3.BSP中添加I2C适配器

点击(此处)折叠或打开

  1. /* linux/arch/arm/mach-s3c64xx/mach-jason6410.c
  2.  *
  3.  * Copyright 2012 Jason Lu <gfvvz@yahoo.com.cn>
  4.  *     http://jason2012.blog.chinaunix.net
  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 version 2 as
  8.  * published by the Free Software Foundation.
  9.  *
  10. */

  12. #include <linux/init.h>
  13. #include <linux/interrupt.h>
  14. #include <linux/fb.h>
  15. #include <linux/gpio.h>
  16. #include <linux/kernel.h>
  17. #include <linux/list.h>
  18. #include <linux/dm9000.h>
  19. #include <linux/mtd/mtd.h>
  20. #include <linux/mtd/partitions.h>
  21. #include <linux/serial_core.h>
  22. #include <linux/types.h>

  24. #include <asm/mach-types.h>
  25. #include <asm/mach/arch.h>
  26. #include <asm/mach/map.h>

  28. #include <mach/map.h>
  29. #include <mach/regs-gpio.h>
  30. #include <mach/regs-modem.h>
  31. #include <mach/regs-srom.h>

  33. #include <plat/s3c6410.h>
  34. #include <plat/adc.h>
  35. #include <plat/cpu.h>
  36. #include <plat/devs.h>
  37. #include <plat/fb.h>
  38. #include <plat/nand.h>
  39. #include <plat/regs-serial.h>
  40. #include <plat/ts.h>
  41. #include <plat/regs-fb-v4.h>
  42. #include

  44. #include <video/platform_lcd.h>

  46. #define UCON S3C2410_UCON_DEFAULT
  47. #define ULCON (S3C2410_LCON_CS8 | S3C2410_LCON_PNONE | S3C2410_LCON_STOPB)
  48. #define UFCON (S3C2410_UFCON_RXTRIG8 | S3C2410_UFCON_FIFOMODE)

  50. static struct s3c2410_uartcfg jason6410_uartcfgs[] __initdata = {
  51.     [0] = {
  52.         .hwport    = 0,
  53.         .flags    = 0,
  54.         .ucon    = UCON,
  55.         .ulcon    = ULCON,
  56.         .ufcon    = UFCON,
  57.     },
  58.     [1] = {
  59.         .hwport    = 1,
  60.         .flags    = 0,
  61.         .ucon    = UCON,
  62.         .ulcon    = ULCON,
  63.         .ufcon    = UFCON,
  64.     },
  65.     [2] = {
  66.         .hwport    = 2,
  67.         .flags    = 0,
  68.         .ucon    = UCON,
  69.         .ulcon    = ULCON,
  70.         .ufcon    = UFCON,
  71.     },
  72.     [3] = {
  73.         .hwport    = 3,
  74.         .flags    = 0,
  75.         .ucon    = UCON,
  76.         .ulcon    = ULCON,
  77.         .ufcon    = UFCON,
  78.     },
  79. };

  81. /* Nand flash */
  82. static struct mtd_partition jason6410_nand_part[] = {
  83.     {
  84.         .name        = "u-boot-2011.06",
  85.         .offset        = 0,
  86.         .size        = (4 * 128 *SZ_1K),
  87.         .mask_flags    = MTD_CAP_NANDFLASH,
  88.     },
  89.     {
  90.         .name        = "Linux Kernel 3.2.8",
  91.         .offset        = MTDPART_OFS_APPEND,
  92.         .size        = (5*SZ_1M) ,
  93.         .mask_flags    = MTD_CAP_NANDFLASH,
  94.     },
  95.     {
  96.         .name        = "UBI File System",
  97.         .offset        = MTDPART_OFS_APPEND,
  98.         .size        = MTDPART_SIZ_FULL,
  99.     }
  100. };

  102. static struct s3c2410_nand_set jason6410_nand_sets[] = {
  103.     [0] = {
  104.         .name        = "nand",
  105.         .nr_chips    = 1,
  106.         .nr_partitions    = ARRAY_SIZE(jason6410_nand_part),
  107.         .partitions    = jason6410_nand_part,
  108.     },
  109. };

  111. static struct s3c2410_platform_nand jason6410_nand_info = {
  112.     .tacls        = 25,
  113.     .twrph0        = 55,
  114.     .twrph1        = 40,
  115.     .nr_sets    = ARRAY_SIZE(jason6410_nand_sets),
  116.     .sets        = jason6410_nand_sets,
  117. };

  119. static struct platform_device *jason6410_devices[] __initdata = {
  120.     &s3c_device_nand,
  121.     &s3c_device_i2c0,
  122. };

  124. static void __init jason6410_map_io(void)
  125. {
  126.     s3c64xx_init_io(NULL, 0);
  127.     s3c24xx_init_clocks(12000000);
  128.     s3c24xx_init_uarts(jason6410_uartcfgs, ARRAY_SIZE(jason6410_uartcfgs));
  129. }

  131. static void __init jason6410_machine_init(void)
  132. {
  133.     s3c_device_nand.name = "s3c6410-nand";
  134.     s3c_nand_set_platdata(&jason6410_nand_info);

  136.     s3c_i2c0_set_platdata(NULL);

  138.     platform_add_devices(jason6410_devices, ARRAY_SIZE(jason6410_devices));
  139. }

  141. MACHINE_START(JASON6410, "JASON6410")
  142.     /* Maintainer: Darius Augulis <augulis.darius@gmail.com> */
  143.     .atag_offset    = 0x100,
  144.     .init_irq    = s3c6410_init_irq,
  145.     .map_io        = jason6410_map_io,
  146.     .init_machine    = jason6410_machine_init,
  147.     .timer        = &s3c24xx_timer,
  148. MACHINE_END

二、AT24 EEPROM I2C设备驱动程序分析及其在BSP中的添加
1. AT24设备驱动分析
1.1 平台总线驱动结构体及其注册与注销

点击(此处)折叠或打开

  1. static struct i2c_driver at24_driver = { //该结构体较新内核才有的，具体变化详见附录
  2.     .driver = {
  3.         .name = "at24",
  4.         .owner = THIS_MODULE,
  5.     },
  6.     .probe = at24_probe,
  7.     .remove = __devexit_p(at24_remove),
  8.     .id_table = at24_ids,
  9. };

  11. static int __init at24_init(void)
  12. {
  13.     if (!io_limit) {
  14.         pr_err("at24: io_limit must not be 0!\n");
  15.         return -EINVAL;
  16.     }

  18.     io_limit = rounddown_pow_of_two(io_limit);
  19.     return i2c_add_driver(&at24_driver);
  20. }
  21. module_init(at24_init);

  23. static void __exit at24_exit(void)
  24. {
  25.     i2c_del_driver(&at24_driver);
  26. }
  27. module_exit(at24_exit);
1.2 i2c_device_id结构体

点击(此处)折叠或打开

  1. /* create non-zero magic value for given eeprom parameters */
  2. #define AT24_DEVICE_MAGIC(_len, _flags)         \
  3.     ((1 << AT24_SIZE_FLAGS | (_flags))         \
  4.      << AT24_SIZE_BYTELEN | ilog2(_len))

  6. static const struct i2c_device_id at24_ids[] = {
  7.     /* needs 8 addresses as A0-A2 are ignored */
  8.     { "24c00", AT24_DEVICE_MAGIC(128 / 8, AT24_FLAG_TAKE8ADDR) },
  9.     /* old variants can't be handled with this generic */
  10.     { "24c01", AT24_DEVICE_MAGIC(1024 / 8, 0) },
  11.     { "24c02", AT24_DEVICE_MAGIC(2048 / 8, 0) },
  12.     /* spd is a 24c02 in memory DIMMs */
  13.     { "spd", AT24_DEVICE_MAGIC(2048 / 8,
  14.         AT24_FLAG_READONLY | AT24_FLAG_IRUGO) },
  15.     { "24c04", AT24_DEVICE_MAGIC(4096 / 8, 0) },
  16.     /* 24rf08 quirk is handled at i2c-core */
  17.     { "24c08", AT24_DEVICE_MAGIC(8192 / 8, 0) },
  18.     { "24c16", AT24_DEVICE_MAGIC(16384 / 8, 0) },
  19.     { "24c32", AT24_DEVICE_MAGIC(32768 / 8, AT24_FLAG_ADDR16) },
  20.     { "24c64", AT24_DEVICE_MAGIC(65536 / 8, AT24_FLAG_ADDR16) },
  21.     { "24c128", AT24_DEVICE_MAGIC(131072 / 8, AT24_FLAG_ADDR16) },
  22.     { "24c256", AT24_DEVICE_MAGIC(262144 / 8, AT24_FLAG_ADDR16) },
  23.     { "24c512", AT24_DEVICE_MAGIC(524288 / 8, AT24_FLAG_ADDR16) },
  24.     { "24c1024", AT24_DEVICE_MAGIC(1048576 / 8, AT24_FLAG_ADDR16) },
  25.     { "at24", 0 },
  26.     { /* END OF LIST */ }
  27. };
  28. MODULE_DEVICE_TABLE(i2c, at24_ids);
1.3 at24_probe函数分析

点击(此处)折叠或打开

  1. //该函数的参数及实现是较新内核才有的，具体变化详见附录
  2. static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id)
  3. {
  4.     struct at24_platform_data chip;
  5.     bool writable;
  6.     int use_smbus = 0;
  7.     struct at24_data *at24;
  8.     int err;
  9.     unsigned i, num_addresses;
  10.     kernel_ulong_t magic;

  12.     if (client->dev.platform_data) {
  13.         chip = *(struct at24_platform_data *)client->dev.platform_data;
  14.     } else {
  15.         if (!id->driver_data) {
  16.             err = -ENODEV;
  17.             goto err_out;
  18.         }
  19.         magic = id->driver_data;
  20.         chip.byte_len = BIT(magic & AT24_BITMASK(AT24_SIZE_BYTELEN));
  21.         magic >>= AT24_SIZE_BYTELEN;
  22.         chip.flags = magic & AT24_BITMASK(AT24_SIZE_FLAGS);
  23.         /*
  24.          * This is slow, but we can't know all eeproms, so we better
  25.          * play safe. Specifying custom eeprom-types via platform_data
  26.          * is recommended anyhow.
  27.          */
  28.         chip.page_size = 1;

  30.         /* update chipdata if OF is present */
  31.         at24_get_ofdata(client, &chip);

  33.         chip.setup = NULL;
  34.         chip.context = NULL;
  35.     }

  37.     if (!is_power_of_2(chip.byte_len))
  38.         dev_warn(&client->dev,
  39.             "byte_len looks suspicious (no power of 2)!\n");
  40.     if (!chip.page_size) {
  41.         dev_err(&client->dev, "page_size must not be 0!\n");
  42.         err = -EINVAL;
  43.         goto err_out;
  44.     }
  45.     if (!is_power_of_2(chip.page_size))
  46.         dev_warn(&client->dev,
  47.             "page_size looks suspicious (no power of 2)!\n");

  49.     /* Use I2C operations unless we're stuck with SMBus extensions. */
  50.     if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
  51.         if (chip.flags & AT24_FLAG_ADDR16) {
  52.             err = -EPFNOSUPPORT;
  53.             goto err_out;
  54.         }
  55.         if (i2c_check_functionality(client->adapter,
  56.                 I2C_FUNC_SMBUS_READ_I2C_BLOCK)) {
  57.             use_smbus = I2C_SMBUS_I2C_BLOCK_DATA;
  58.         } else if (i2c_check_functionality(client->adapter,
  59.                 I2C_FUNC_SMBUS_READ_WORD_DATA)) {
  60.             use_smbus = I2C_SMBUS_WORD_DATA;
  61.         } else if (i2c_check_functionality(client->adapter,
  62.                 I2C_FUNC_SMBUS_READ_BYTE_DATA)) {
  63.             use_smbus = I2C_SMBUS_BYTE_DATA;
  64.         } else {
  65.             err = -EPFNOSUPPORT;
  66.             goto err_out;
  67.         }
  68.     }

  70.     if (chip.flags & AT24_FLAG_TAKE8ADDR)
  71.         num_addresses = 8;
  72.     else
  73.         num_addresses =    DIV_ROUND_UP(chip.byte_len,
  74.             (chip.flags & AT24_FLAG_ADDR16) ? 65536 : 256);

  76.     at24 = kzalloc(sizeof(struct at24_data) +
  77.         num_addresses * sizeof(struct i2c_client *), GFP_KERNEL);
  78.     if (!at24) {
  79.         err = -ENOMEM;
  80.         goto err_out;
  81.     }

  83.     mutex_init(&at24->lock);
  84.     at24->use_smbus = use_smbus;
  85.     at24->chip = chip;
  86.     at24->num_addresses = num_addresses;

  88.     /*
  89.      * Export the EEPROM bytes through sysfs, since that's convenient.
  90.      * By default, only root should see the data (maybe passwords etc)
  91.      */
  92.     sysfs_bin_attr_init(&at24->bin);
  93.     at24->bin.attr.name = "eeprom";
  94.     at24->bin.attr.mode = chip.flags & AT24_FLAG_IRUGO ? S_IRUGO : S_IRUSR;
  95.     at24->bin.read = at24_bin_read;
  96.     at24->bin.size = chip.byte_len;

  98.     at24->macc.read = at24_macc_read;

  100.     writable = !(chip.flags & AT24_FLAG_READONLY);
  101.     if (writable) {
  102.         if (!use_smbus || i2c_check_functionality(client->adapter,
  103.                 I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) {

  105.             unsigned write_max = chip.page_size;

  107.             at24->macc.write = at24_macc_write;

  109.             at24->bin.write = at24_bin_write;
  110.             at24->bin.attr.mode |= S_IWUSR;

  112.             if (write_max > io_limit)
  113.                 write_max = io_limit;
  114.             if (use_smbus && write_max > I2C_SMBUS_BLOCK_MAX)
  115.                 write_max = I2C_SMBUS_BLOCK_MAX;
  116.             at24->write_max = write_max;

  118.             /* buffer (data + address at the beginning) */
  119.             at24->writebuf = kmalloc(write_max + 2, GFP_KERNEL);
  120.             if (!at24->writebuf) {
  121.                 err = -ENOMEM;
  122.                 goto err_struct;
  123.             }
  124.         } else {
  125.             dev_warn(&client->dev,
  126.                 "cannot write due to controller restrictions.");
  127.         }
  128.     }

  130.     at24->client[0] = client;

  132.     /* use dummy devices for multiple-address chips */
  133.     for (i = 1; i < num_addresses; i++) {
  134.         at24->client[i] = i2c_new_dummy(client->adapter,
  135.                     client->addr + i);
  136.         if (!at24->client[i]) {
  137.             dev_err(&client->dev, "address 0x%02x unavailable\n",
  138.                     client->addr + i);
  139.             err = -EADDRINUSE;
  140.             goto err_clients;
  141.         }
  142.     }

  144.     err = sysfs_create_bin_file(&client->dev.kobj, &at24->bin);
  145.     if (err)
  146.         goto err_clients;

  148.     i2c_set_clientdata(client, at24);

  150.     dev_info(&client->dev, "%zu byte %s EEPROM, %s, %u bytes/write\n",
  151.         at24->bin.size, client->name,
  152.         writable ? "writable" : "read-only", at24->write_max);
  153.     if (use_smbus == I2C_SMBUS_WORD_DATA ||
  154.      use_smbus == I2C_SMBUS_BYTE_DATA) {
  155.         dev_notice(&client->dev, "Falling back to %s reads, "
  156.              "performance will suffer\n", use_smbus ==
  157.              I2C_SMBUS_WORD_DATA ? "word" : "byte");
  158.     }

  160.     /* export data to kernel code */
  161.     if (chip.setup)
  162.         chip.setup(&at24->macc, chip.context);

  164.     return 0;

  166. err_clients:
  167.     for (i = 1; i < num_addresses; i++)
  168.         if (at24->client[i])
  169.             i2c_unregister_device(at24->client[i]);

  171.     kfree(at24->writebuf);
  172. err_struct:
  173.     kfree(at24);
  174. err_out:
  175.     dev_dbg(&client->dev, "probe error %d\n", err);
  176.     return err;
  177. }

  179. static int __devexit at24_remove(struct i2c_client *client)
  180. {
  181.     struct at24_data *at24;
  182.     int i;

  184.     at24 = i2c_get_clientdata(client);
  185.     sysfs_remove_bin_file(&client->dev.kobj, &at24->bin);

  187.     for (i = 1; i < at24->num_addresses; i++)
  188.         i2c_unregister_device(at24->client[i]);

  190.     kfree(at24->writebuf);
  191.     kfree(at24);
  192.     return 0;
  193. }
2. BSP中添加at24c08 I2C 信息

点击(此处)折叠或打开

  1. /* linux/arch/arm/mach-s3c64xx/mach-jason6410.c
  2.  *
  3.  * Copyright 2012 Jason Lu <gfvvz@yahoo.com.cn>
  4.  *     http://jason2012.blog.chinaunix.net
  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 version 2 as
  8.  * published by the Free Software Foundation.
  9.  *
  10. */

  12. #include <linux/init.h>
  13. #include <linux/interrupt.h>
  14. #include <linux/fb.h>
  15. #include <linux/gpio.h>
  16. #include <linux/kernel.h>
  17. #include <linux/list.h>
  18. #include <linux/dm9000.h>
  19. #include <linux/mtd/mtd.h>
  20. #include <linux/mtd/partitions.h>
  21. #include <linux/serial_core.h>
  22. #include <linux/types.h>

  24. #include <asm/mach-types.h>
  25. #include <asm/mach/arch.h>
  26. #include <asm/mach/map.h>

  28. #include <mach/map.h>
  29. #include <mach/regs-gpio.h>
  30. #include <mach/regs-modem.h>
  31. #include <mach/regs-srom.h>

  33. #include <plat/s3c6410.h>
  34. #include <plat/adc.h>
  35. #include <plat/cpu.h>
  36. #include <plat/devs.h>
  37. #include <plat/fb.h>
  38. #include <plat/nand.h>
  39. #include <plat/regs-serial.h>
  40. #include <plat/ts.h>
  41. #include <plat/regs-fb-v4.h>
  42. #include <plat/iic.h>

  44. #include <video/platform_lcd.h>

  46. #define UCON S3C2410_UCON_DEFAULT
  47. #define ULCON (S3C2410_LCON_CS8 | S3C2410_LCON_PNONE | S3C2410_LCON_STOPB)
  48. #define UFCON (S3C2410_UFCON_RXTRIG8 | S3C2410_UFCON_FIFOMODE)

  50. static struct s3c2410_uartcfg jason6410_uartcfgs[] __initdata = {
  51.     [0] = {
  52.         .hwport    = 0,
  53.         .flags    = 0,
  54.         .ucon    = UCON,
  55.         .ulcon    = ULCON,
  56.         .ufcon    = UFCON,
  57.     },
  58.     [1] = {
  59.         .hwport    = 1,
  60.         .flags    = 0,
  61.         .ucon    = UCON,
  62.         .ulcon    = ULCON,
  63.         .ufcon    = UFCON,
  64.     },
  65.     [2] = {
  66.         .hwport    = 2,
  67.         .flags    = 0,
  68.         .ucon    = UCON,
  69.         .ulcon    = ULCON,
  70.         .ufcon    = UFCON,
  71.     },
  72.     [3] = {
  73.         .hwport    = 3,
  74.         .flags    = 0,
  75.         .ucon    = UCON,
  76.         .ulcon    = ULCON,
  77.         .ufcon    = UFCON,
  78.     },
  79. };

  81. /* Nand flash */
  82. static struct mtd_partition jason6410_nand_part[] = {
  83.     {
  84.         .name        = "u-boot-2011.06",
  85.         .offset        = 0,
  86.         .size        = (4 * 128 *SZ_1K),
  87.         .mask_flags    = MTD_CAP_NANDFLASH,
  88.     },
  89.     {
  90.         .name        = "Linux Kernel 3.2.8",
  91.         .offset        = MTDPART_OFS_APPEND,
  92.         .size        = (5*SZ_1M) ,
  93.         .mask_flags    = MTD_CAP_NANDFLASH,
  94.     },
  95.     {
  96.         .name        = "UBI File System",
  97.         .offset        = MTDPART_OFS_APPEND,
  98.         .size        = MTDPART_SIZ_FULL,
  99.     }
  100. };

  102. static struct s3c2410_nand_set jason6410_nand_sets[] = {
  103.     [0] = {
  104.         .name        = "nand",
  105.         .nr_chips    = 1,
  106.         .nr_partitions    = ARRAY_SIZE(jason6410_nand_part),
  107.         .partitions    = jason6410_nand_part,
  108.     },
  109. };

  111. static struct s3c2410_platform_nand jason6410_nand_info = {
  112.     .tacls        = 25,
  113.     .twrph0        = 55,
  114.     .twrph1        = 40,
  115.     .nr_sets    = ARRAY_SIZE(jason6410_nand_sets),
  116.     .sets        = jason6410_nand_sets,
  117. };

  119. static struct platform_device *jason6410_devices[] __initdata = {
  120.     &s3c_device_nand,
  121.     &s3c_device_i2c0,
  122. };

  124. static struct i2c_board_info i2c_devs0[] __initdata = { //i2c: add @2012.4.1
  125.     { I2C_BOARD_INFO("24c08", 0x50), },
  126. };

  128. static struct i2c_board_info i2c_devs1[] __initdata = { //i2c: add @2012.4.1
  129.     /* Add your i2c device here */
  130. };

  132. static void __init jason6410_map_io(void)
  133. {
  134.     s3c64xx_init_io(NULL, 0);
  135.     s3c24xx_init_clocks(12000000);
  136.     s3c24xx_init_uarts(jason6410_uartcfgs, ARRAY_SIZE(jason6410_uartcfgs));
  137. }

  139. static void __init jason6410_machine_init(void)
  140. {
  141.     s3c_device_nand.name = "s3c6410-nand";
  142.     s3c_nand_set_platdata(&jason6410_nand_info);

  144.     s3c_i2c0_set_platdata(NULL);
  145.     
  146.     /*
  147.      * 在添加如下加粗代码后，内核报错，如下图，必须用：
  148.      * make KALLSYMS_EXTRA_PASS=1 uImage -j4
  149.      * 添加红色部分才能顺利通过编译，具体原因尚未清楚
  150.      */
  151.     if (ARRAY_SIZE(i2c_devs0)) { //i2c: add @2012.4.1
  152.         i2c_register_board_info(0, i2c_devs0, ARRAY_SIZE(i2c_devs0));
  153.     }
  154.     if (ARRAY_SIZE(i2c_devs1)) { //i2c: add @2012.4.1
  155.         i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1));
  156.     }

  158.     platform_add_devices(jason6410_devices, ARRAY_SIZE(jason6410_devices));
  159. }

  161. MACHINE_START(JASON6410, "JASON6410")
  162.     /* Maintainer: Darius Augulis <augulis.darius@gmail.com> */
  163.     .atag_offset    = 0x100,
  164.     .init_irq    = s3c6410_init_irq,
  165.     .map_io        = jason6410_map_io,
  166.     .init_machine    = jason6410_machine_init,
  167.     .timer        = &s3c24xx_timer,
  168. MACHINE_END

三、内核配置
Device Drivers  --->
<*> I2C support --->
I2C Hardware Bus support --->
<*> S3C2410 I2C Driver //默认配置里是已选的

Device Drivers  --->
[*] Misc devices  --->  
EEPROM support --->
<*> I2C EEPROMs from most vendors //输入"Y"，选择编译进内核

最后，在启动信息里，多出如下红色方框里几行。上面一个红色方框里的是s3c6410适配器的device和driver匹配成功后，在调用probe函数时，probe函数及probe函数里s3c24xx_i2c_init函数的的打印信息。
下面一个方框里的打印信息是BSP中i2c_board_info结构体中的I2C_BOARD_INFO成员里的.name成员24c08与at24.c里的at24_ids结构体里的某一成员名匹配成功后，调用probe函数，该函数打印出如此信息。

四、简单测试

附录：upgrading-clients: Upgrading I2C Drivers to the new 2.6 Driver Model

点击(此处)折叠或打开

  1. Upgrading I2C Drivers to the new 2.6 Driver Model
  2. =================================================

  4. Ben Dooks <ben-linux@fluff.org>

  6. Introduction
  7. ------------

  9. This guide outlines how to alter existing Linux 2.6 client drivers from
  10. the old to the new new binding methods.


  13. Example old-style driver
  14. ------------------------


  17. struct example_state {
  18.     struct i2c_client    client;
  19.     ....
  20. };

  22. static struct i2c_driver example_driver;

  24. static unsigned short ignore[] = { I2C_CLIENT_END };
  25. static unsigned short normal_addr[] = { OUR_ADDR, I2C_CLIENT_END };

  27. I2C_CLIENT_INSMOD;

  29. static int example_attach(struct i2c_adapter *adap, int addr, int kind)
  30. {
  31.     struct example_state *state;
  32.     struct device *dev = &adap->dev; /* to use for dev_ reports */
  33.     int ret;

  35.     state = kzalloc(sizeof(struct example_state), GFP_KERNEL);
  36.     if (state == NULL) {
  37.         dev_err(dev, "failed to create our state\n");
  38.         return -ENOMEM;
  39.     }

  41.     example->client.addr = addr;
  42.     example->client.flags = 0;
  43.     example->client.adapter = adap;

  45.     i2c_set_clientdata(&state->i2c_client, state);
  46.     strlcpy(client->i2c_client.name, "example", I2C_NAME_SIZE);

  48.     ret = i2c_attach_client(&state->i2c_client);
  49.     if (ret < 0) {
  50.         dev_err(dev, "failed to attach client\n");
  51.         kfree(state);
  52.         return ret;
  53.     }

  55.     dev = &state->i2c_client.dev;

  57.     /* rest of the initialisation goes here. */

  59.     dev_info(dev, "example client created\n");

  61.     return 0;
  62. }

  64. static int example_detach(struct i2c_client *client)
  65. {
  66.     struct example_state *state = i2c_get_clientdata(client);

  68.     i2c_detach_client(client);
  69.     kfree(state);
  70.     return 0;
  71. }

  73. static int example_attach_adapter(struct i2c_adapter *adap)
  74. {
  75.     return i2c_probe(adap, &addr_data, example_attach);
  76. }

  78. static struct i2c_driver example_driver = {
  79.      .driver        = {
  80.         .owner        = THIS_MODULE,
  81.         .name        = "example",
  82.     },
  83.     .attach_adapter = example_attach_adapter,
  84.     .detach_client    = example_detach,
  85.     .suspend    = example_suspend,
  86.     .resume        = example_resume,
  87. };


  90. Updating the client
  91. -------------------

  93. The new style binding model will check against a list of supported
  94. devices and their associated address supplied by the code registering
  95. the busses. This means that the driver .attach_adapter and
  96. .detach_client methods can be removed, along with the addr_data,
  97. as follows:

  99. - static struct i2c_driver example_driver;

  101. - static unsigned short ignore[] = { I2C_CLIENT_END };
  102. - static unsigned short normal_addr[] = { OUR_ADDR, I2C_CLIENT_END };

  104. - I2C_CLIENT_INSMOD;

  106. - static int example_attach_adapter(struct i2c_adapter *adap)
  107. - {
  108. -     return i2c_probe(adap, &addr_data, example_attach);
  109. - }

  111.  static struct i2c_driver example_driver = {
  112. -    .attach_adapter = example_attach_adapter,
  113. -    .detach_client    = example_detach,
  114.  }

  116. Add the probe and remove methods to the i2c_driver, as so:

  118.  static struct i2c_driver example_driver = {
  119. +    .probe        = example_probe,
  120. +    .remove        = example_remove,
  121.  }

  123. Change the example_attach method to accept the new parameters
  124. which include the i2c_client that it will be working with:

  126. - static int example_attach(struct i2c_adapter *adap, int addr, int kind)
  127. + static int example_probe(struct i2c_client *client,
  128. +             const struct i2c_device_id *id)

  130. Change the name of example_attach to example_probe to align it with the
  131. i2c_driver entry names. The rest of the probe routine will now need to be
  132. changed as the i2c_client has already been setup for use.

  134. The necessary client fields have already been setup before
  135. the probe function is called, so the following client setup
  136. can be removed:

  138. -    example->client.addr = addr;
  139. -    example->client.flags = 0;
  140. -    example->client.adapter = adap;
  141. -
  142. -    strlcpy(client->i2c_client.name, "example", I2C_NAME_SIZE);

  144. The i2c_set_clientdata is now:

  146. -    i2c_set_clientdata(&state->client, state);
  147. +    i2c_set_clientdata(client, state);

  149. The call to i2c_attach_client is no longer needed, if the probe
  150. routine exits successfully, then the driver will be automatically
  151. attached by the core. Change the probe routine as so:

  153. -    ret = i2c_attach_client(&state->i2c_client);
  154. -    if (ret < 0) {
  155. -        dev_err(dev, "failed to attach client\n");
  156. -        kfree(state);
  157. -        return ret;
  158. -    }


  161. Remove the storage of 'struct i2c_client' from the 'struct example_state'
  162. as we are provided with the i2c_client in our example_probe. Instead we
  163. store a pointer to it for when it is needed.

  165. struct example_state {
  166. -    struct i2c_client    client;
  167. +    struct i2c_client    *client;

  169. the new i2c client as so:

  171. -    struct device *dev = &adap->dev; /* to use for dev_ reports */
  172. +     struct device *dev = &i2c_client->dev; /* to use for dev_ reports */

  174. And remove the change after our client is attached, as the driver no
  175. longer needs to register a new client structure with the core:

  177. -    dev = &state->i2c_client.dev;

  179. In the probe routine, ensure that the new state has the client stored
  180. in it:

  182. static int example_probe(struct i2c_client *i2c_client,
  183.              const struct i2c_device_id *id)
  184. {
  185.     struct example_state *state;
  186.      struct device *dev = &i2c_client->dev;
  187.     int ret;

  189.     state = kzalloc(sizeof(struct example_state), GFP_KERNEL);
  190.     if (state == NULL) {
  191.         dev_err(dev, "failed to create our state\n");
  192.         return -ENOMEM;
  193.     }

  195. +    state->client = i2c_client;

  197. Update the detach method, by changing the name to _remove and
  198. to delete the i2c_detach_client call. It is possible that you
  199. can also remove the ret variable as it is not not needed for
  200. any of the core functions.

  202. - static int example_detach(struct i2c_client *client)
  203. + static int example_remove(struct i2c_client *client)
  204. {
  205.     struct example_state *state = i2c_get_clientdata(client);

  207. -    i2c_detach_client(client);

  209. And finally ensure that we have the correct ID table for the i2c-core
  210. and other utilities:

  212. + struct i2c_device_id example_idtable[] = {
  213. + { "example", 0 },
  214. + { }
  215. +};
  216. +
  217. +MODULE_DEVICE_TABLE(i2c, example_idtable);

  219. static struct i2c_driver example_driver = {
  220.      .driver        = {
  221.         .owner        = THIS_MODULE,
  222.         .name        = "example",
  223.     },
  224. +    .id_table    = example_ids,


  227. Our driver should now look like this:

  229. struct example_state {
  230.     struct i2c_client    *client;
  231.     ....
  232. };

  234. static int example_probe(struct i2c_client *client,
  235.               const struct i2c_device_id *id)
  236. {
  237.     struct example_state *state;
  238.     struct device *dev = &client->dev;

  240.     state = kzalloc(sizeof(struct example_state), GFP_KERNEL);
  241.     if (state == NULL) {
  242.         dev_err(dev, "failed to create our state\n");
  243.         return -ENOMEM;
  244.     }

  246.     state->client = client;
  247.     i2c_set_clientdata(client, state);

  249.     /* rest of the initialisation goes here. */

  251.     dev_info(dev, "example client created\n");

  253.     return 0;
  254. }

  256. static int example_remove(struct i2c_client *client)
  257. {
  258.     struct example_state *state = i2c_get_clientdata(client);

  260.     kfree(state);
  261.     return 0;
  262. }

  264. static struct i2c_device_id example_idtable[] = {
  265.     { "example", 0 },
  266.     { }
  267. };

  269. MODULE_DEVICE_TABLE(i2c, example_idtable);

  271. static struct i2c_driver example_driver = {
  272.      .driver        = {
  273.         .owner        = THIS_MODULE,
  274.         .name        = "example",
  275.     },
  276.     .id_table    = example_idtable,
  277.     .probe        = example_probe,
  278.     .remove        = example_remove,
  279.     .suspend    = example_suspend,
  280.     .resume        = example_resume,
  281. };






阅读(6864) | 评论(0) | 转发(5) |
2

上一篇：（二）BSP编写（串口、MTD、UBIFS）

下一篇：Linux内核源码分析--内核启动命令行的传递过程（Linux-3.0 ARMv7）

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6