基于S3C2440的嵌入式Linux驱动——AT24C02(EEPROM I2C接口)驱动解读

最新推荐文章于 2024-07-12 20:00:00 发布
最新推荐文章于 2024-07-12 20:00:00 发布
阅读量307 收藏
点赞数
分类专栏： # kernel-driver-i2c

转载地址：http://blog.csdn.net/yj4231/article/details/18182775

本文将介绍Linux中AT24C02驱动。AT24C02是一种EEPROM，使用I2C接口来访问。

在开发板中，使用I2C控制器0和AT24C02连接，这里就不给出原理图了，如需要，可以搜索TQ2440开发板的原理图。

目标平台：TQ2440

CPU：s3c2440

内核版本：2.6.32

本文所有的代码均位于内核源码：linux/drivers/misc/eeprom/at24.c中。

1. 模块注册和注销

[cpp] view plain copy
  1. static int __init at24_init(void)  
  2. {  
  3.     /* 将io_limit向下圆整到最近的2的幂*/  
  4.     io_limit = rounddown_pow_of_two(io_limit);  
  5.     return i2c_add_driver(&at24_driver); /* i2c 驱动注册*/  
  6. }  
  7. module_init(at24_init);  
  8.   
  9. static void __exit at24_exit(void)  
  10. {  
  11.     i2c_del_driver(&at24_driver);  
  12. }  
  13. module_exit(at24_exit);  
  14.   
  15. MODULE_DESCRIPTION("Driver for most I2C EEPROMs");  
  16. MODULE_AUTHOR("David Brownell and Wolfram Sang");  
  17. MODULE_LICENSE("GPL");  


注册函数很简单。io_limit为写入时允许一次写入的最大字节，该参数为驱动模块参数，可由用户设置，默认值为128字节。

首先对io_limit向下圆整到最近的2的幂，接着直接调用了i2c_add_driver来注册一个i2c驱动。

注销函数更简单。注销之前注册的i2c驱动。


2. 设备驱动绑定

熟悉I2C驱动架构的可能会知道I2C驱动的match函数，该函数将使用id表(struct i2c_device_id)和i2c设备（struct i2c_client）进行匹配，判断是否有name字段相同，如果相同则匹配完成，即可完成设备和驱动的绑定，接着便会调用驱动提供的probe方法。我们来看下驱动提供的id表。

[cpp] view plain copy
  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. };  
驱动提供的id为at24_ids，如下：


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

结构体成员的第一个参数即为name，表示设备的名字。第二个参数，在该驱动中，为一个幻术（magic），通过AT24_DEVICE_MAGIC宏计算。

宏第一个参数为eeprom的大小，第二参数为一些标志位。我们看下这个宏：

[cpp] view plain copy
  1. #define AT24_SIZE_BYTELEN 5  
  2. #define AT24_SIZE_FLAGS 8  
  3.   
  4. /* create non-zero magic value for given eeprom parameters */  
  5. #define AT24_DEVICE_MAGIC(_len, _flags)         \  
  6.     ((1 << AT24_SIZE_FLAGS | (_flags))        \  
  7.         << AT24_SIZE_BYTELEN | ilog2(_len))  

在这个表中，针对这里讲解的24c02，其大小为256字节，标志位为空。


3.probe函数

    当i2c总线完成设备驱动绑定后，就会调用probe方法了。具体看下这个函数。

[cpp] view plain copy
  1. static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id)  
  2. {  
  3.     struct at24_platform_data chip;  
  4.     bool writable;  
  5.     bool use_smbus = false;  
  6.     struct at24_data *at24;  
  7.     int err;  
  8.     unsigned i, num_addresses;  
  9.     kernel_ulong_t magic;  
  10.   
  11.     /* 获取板级设备信息*/  
  12.     if (client->dev.platform_data) {  
  13.         chip = *(struct at24_platform_data *)client->dev.platform_data;  
  14.     } else {  
  15.         /* 没有板级设备信息，也没有driver_data，直接出错*/  
  16.         if (!id->driver_data) {  
  17.             err = -ENODEV;  
  18.             goto err_out;  
  19.         }  
  20.         magic = id->driver_data;  
  21.         chip.byte_len = BIT(magic & AT24_BITMASK(AT24_SIZE_BYTELEN));  
  22.         magic >>= AT24_SIZE_BYTELEN;  
  23.         chip.flags = magic & AT24_BITMASK(AT24_SIZE_FLAGS);  
  24.         /* 
  25.          * This is slow, but we can't know all eeproms, so we better 
  26.          * play safe. Specifying custom eeprom-types via platform_data 
  27.          * is recommended anyhow. 
  28.          */  
  29.         chip.page_size = 1;  
  30.   
  31.         chip.setup = NULL;  
  32.         chip.context = NULL;  
  33.     }  
  34.   
  35.     /* 检查参数， 
  36.         byte_len和page_size必须为2的幂，不是则打印警告*/  
  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 (!is_power_of_2(chip.page_size))  
  41.         dev_warn(&client->dev,  
  42.             "page_size looks suspicious (no power of 2)!\n");  
  43.   
  44.     /* Use I2C operations unless we're stuck with SMBus extensions. */  
  45.     /* 检查是否支持I2C协议， 
  46.         如果不支持，则检查是否使用SMBUS协议*/  
  47.     if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {  
  48.         /* 不支持I2C协议，但是使用16位地址，出错*/  
  49.         if (chip.flags & AT24_FLAG_ADDR16) {  
  50.             err = -EPFNOSUPPORT;  
  51.             goto err_out;  
  52.         }  
  53.         /*  不支持I2C协议，使用8位地址， 
  54.            但是不支持I2C_FUNC_SMBUS_READ_I2C_BLOCK，出错*/  
  55.         if (!i2c_check_functionality(client->adapter,  
  56.                 I2C_FUNC_SMBUS_READ_I2C_BLOCK)) {  
  57.             err = -EPFNOSUPPORT;  
  58.             goto err_out;  
  59.         }  
  60.         use_smbus = true; /*使用 SMBUS协议*/  
  61.     }  
  62.   
  63.     /*是否使用8个地址，根据id表， 
  64.         目前只有AT24C00使用8个地址，其他都为1个*/  
  65.     if (chip.flags & AT24_FLAG_TAKE8ADDR)  
  66.         num_addresses = 8;  
  67.     else  
  68.         /* 24C02需要1个地址，24C04为2个，以此类推*/  
  69.         num_addresses = DIV_ROUND_UP(chip.byte_len,  
  70.             (chip.flags & AT24_FLAG_ADDR16) ? 65536 : 256);  
  71.   
  72.     /* 分配struct at24_data，同时根据地址个数分配struct i2c_client*/  
  73.     at24 = kzalloc(sizeof(struct at24_data) +  
  74.         num_addresses * sizeof(struct i2c_client *), GFP_KERNEL);  
  75.     if (!at24) {  
  76.         err = -ENOMEM;  
  77.         goto err_out;  
  78.     }  
  79.   
  80.     /* 初始化struct at24_data*/  
  81.     mutex_init(&at24->lock);  
  82.     at24->use_smbus = use_smbus;  
  83.     at24->chip = chip;  
  84.     at24->num_addresses = num_addresses;  
  85.   
  86.     /* 
  87.      * Export the EEPROM bytes through sysfs, since that's convenient. 
  88.      * By default, only root should see the data (maybe passwords etc) 
  89.      */  
  90.      /* 设置bin_attribute字段，二进制文件名为eeprom， 
  91.          通过它即可读写设备 */  
  92.     at24->bin.attr.name = "eeprom";  
  93.     at24->bin.attr.mode = chip.flags & AT24_FLAG_IRUGO ? S_IRUGO : S_IRUSR;  
  94.     at24->bin.read = at24_bin_read;  
  95.     at24->bin.size = chip.byte_len;  
  96.   
  97.     at24->macc.read = at24_macc_read;  /***  先忽略***/  
  98.   
  99.     /* 判断设备是否可写*/  
  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)) {  
  104.   
  105.             unsigned write_max = chip.page_size;  
  106.   
  107.             at24->macc.write = at24_macc_write;  /***  先忽略***/  
  108.   
  109.             at24->bin.write = at24_bin_write;    /* 写函数*/  
  110.             at24->bin.attr.mode |= S_IWUSR;    /* 文件拥有者可写*/  
  111.   
  112.             if (write_max > io_limit)  /* 一次最多写io_limit个字节*/  
  113.                 write_max = io_limit;  
  114.             /* 如果使用smbus，对write_max检查*/  
  115.             if (use_smbus && write_max > I2C_SMBUS_BLOCK_MAX)  
  116.                 write_max = I2C_SMBUS_BLOCK_MAX;  
  117.             at24->write_max = write_max;    
  118.   
  119.             /* buffer (data + address at the beginning) */  
  120.             /* 分配写缓冲区，多余两个字节用于保存寄存器地址*/  
  121.             at24->writebuf = kmalloc(write_max + 2, GFP_KERNEL);  
  122.             if (!at24->writebuf) {  
  123.                 err = -ENOMEM;  
  124.                 goto err_struct;  
  125.             }  
  126.         } else {  
  127.             dev_warn(&client->dev,  
  128.                 "cannot write due to controller restrictions.");  
  129.         }  
  130.     }  
  131.   
  132.     at24->client[0] = client;  /* 保存i2c设备client*/  
  133.   
  134.     /* use dummy devices for multiple-address chips */  
  135.     /* 为其余设备地址注册一个dummy设备*/  
  136.     for (i = 1; i < num_addresses; i++) {  
  137.         at24->client[i] = i2c_new_dummy(client->adapter,  
  138.                     client->addr + i);     /* 设备地址每次加1 */  
  139.         if (!at24->client[i]) {  
  140.             dev_err(&client->dev, "address 0x%02x unavailable\n",  
  141.                     client->addr + i);  
  142.             err = -EADDRINUSE;  
  143.             goto err_clients;  
  144.         }  
  145.     }  
  146.   
  147.     /* 创建二进制属性*/  
  148.     err = sysfs_create_bin_file(&client->dev.kobj, &at24->bin);  
  149.     if (err)  
  150.         goto err_clients;  
  151.   
  152.     i2c_set_clientdata(client, at24);  /* 保存驱动数据*/  
  153.   
  154.     /* 打印设备信息*/  
  155.     dev_info(&client->dev, "%zu byte %s EEPROM %s\n",  
  156.         at24->bin.size, client->name,  
  157.         writable ? "(writable)" : "(read-only)");  
  158.     dev_dbg(&client->dev,  
  159.         "page_size %d, num_addresses %d, write_max %d%s\n",  
  160.         chip.page_size, num_addresses,  
  161.         at24->write_max,  
  162.         use_smbus ? ", use_smbus" : "");  
  163.   
  164.     /* export data to kernel code */  
  165.     if (chip.setup)  
  166.         chip.setup(&at24->macc, chip.context);  
  167.   
  168.     return 0;  
  169.   
  170. err_clients:  
  171.     for (i = 1; i < num_addresses; i++)  
  172.         if (at24->client[i])  
  173.             i2c_unregister_device(at24->client[i]);  
  174.   
  175.     kfree(at24->writebuf);  
  176. err_struct:  
  177.     kfree(at24);  
  178. }  
驱动首先获取板级设备信息（client->dev.platform_data），我们假设驱动移植时，添加了该板级设备信息。

判断是使用I2C协议还是SMBus协议。在这里，I2C adpater使用I2C协议。

然后，判断设备需要多少个i2c设备地址。

这里补充下：根据at24c02的datasheet，设备地址的第1位到第3位，将根据不同的设备来进行设置。

例如，如果是at24c04，则设备地址的第1位将用来表示寄存器地址，因为内存大小为512字节，而寄存器地址只有8位（256字节），

需要额外的一位用来表示512字节，因此使用了设备地址当中的一位来实现此目的。具体的请看datasheet。

这里使用at24c02，num_addresses将为1。

接着分配struct at24_data和struct i2c_client指针数组空间。

然后对struct at24_data进行了初始化工作。

接着，对二进制属性进行了配置。名字为eeprom，同时配置了其读方法（at24_bin_read），如果设备可写，还将配置其写方法（at24_bin_write）。

接下来很重要的一步，如果设备使用多个地址，则需要为所有地址（除了第一个地址）分配一个dummy device，这样这些地址就不会被其他的I2C设备占用了。

最后，向sys文件系统注册了二进制属性文件，通过该二进制文件，用户即可访问该设备。

注意：驱动使用了struct memory_accessor的东东，对这个东东不是太了解，所以先忽略，这个东西不影响驱动整体的架构。


4.设备访问方法

   从第3结的分析可知，驱动并没有注册任何字符设备或者杂项设备，只是向sys文件系统注册了一个二进制属性文件。因此要访问设备，必须通过该文件的读写函数来。

读写函数在probe函数中指定为at24_bin_write和at24_bin_read，我们来分别看下。

4.1 写函数（at24_bin_write）

[cpp] view plain copy
  1. static ssize_t at24_bin_write(struct kobject *kobj, struct bin_attribute *attr,  
  2.         char *buf, loff_t off, size_t count)  
  3. {  
  4.     struct at24_data *at24;  
  5.   
  6.         /* 通过kobj获取device，再获取driver_data */  
  7.     at24 = dev_get_drvdata(container_of(kobj, struct device, kobj));  
  8.     return at24_write(at24, buf, off, count);  
  9. }  
该函数首先通过kobj获取了struct device的指针，再获取了at24。

接着直接调用了at24_write。如下:

[cpp] view plain copy
  1. tatic ssize_t at24_write(struct at24_data *at24, const char *buf, loff_t off,  
  2.               size_t count)  
  3. {  
  4.     ssize_t retval = 0;  
  5.   
  6.     if (unlikely(!count))  
  7.         return count;  
  8.   
  9.     /* 
  10.      * Write data to chip, protecting against concurrent updates 
  11.      * from this host, but not from other I2C masters. 
  12.      */  
  13.       /* 访问设备前，加锁*/  
  14.     mutex_lock(&at24->lock);  
  15.   
  16.     while (count) {  
  17.         ssize_t status;  
  18.   
  19.         status = at24_eeprom_write(at24, buf, off, count);  
  20.         if (status <= 0) {  
  21.             if (retval == 0)  
  22.                 retval = status;  
  23.             break;  
  24.         }  
  25.         buf += status;  
  26.         off += status;  
  27.         count -= status;  
  28.         retval += status;  
  29.     }  
  30.   
  31.     mutex_unlock(&at24->lock);  
  32.   
  33.     return retval;  
  34. }  

该函数不复杂。在访问设备前，首先加锁互斥体，以防止竞态。然后根据count来调用at24_eeprom_write函数将数据写入设备。

写入成功后，更新偏移量等信息，如果还需要写入，则再次调用at24_eeprom_write函数。

看下at24_eeprom_write函数：

[cpp] view plain copy
  1. /* 
  2.  * Note that if the hardware write-protect pin is pulled high, the whole 
  3.  * chip is normally write protected. But there are plenty of product 
  4.  * variants here, including OTP fuses and partial chip protect. 
  5.  * 
  6.  * We only use page mode writes; the alternative is sloooow. This routine 
  7.  * writes at most one page. 
  8.  */  
  9. static ssize_t at24_eeprom_write(struct at24_data *at24, const char *buf,  
  10.         unsigned offset, size_t count)  
  11. {  
  12.     struct i2c_client *client;  
  13.     struct i2c_msg msg;  
  14.     ssize_t status;  
  15.     unsigned long timeout, write_time;  
  16.     unsigned next_page;  
  17.   
  18.     /* Get corresponding I2C address and adjust offset */  
  19.     client = at24_translate_offset(at24, &offset);  
  20.   
  21.     /* write_max is at most a page */  
  22.     /* 检查写入的字节数*/  
  23.     if (count > at24->write_max)  
  24.         count = at24->write_max;  
  25.   
  26.     /* Never roll over backwards, to the start of this page */  
  27.     /* 写入不会超过下一页的边界*/  
  28.     next_page = roundup(offset + 1, at24->chip.page_size);  
  29.     /* 根据页大小调整count*/  
  30.     if (offset + count > next_page)  
  31.         count = next_page - offset;  
  32.   
  33.     /* If we'll use I2C calls for I/O, set up the message */  
  34.     /* 使用I2C协议，需要填充msg*/  
  35.     if (!at24->use_smbus) {  
  36.         int i = 0;  
  37.   
  38.         msg.addr = client->addr;  /*设备地址*/  
  39.         msg.flags = 0;  
  40.   
  41.         /* msg.buf is u8 and casts will mask the values */  
  42.         /* 使用writebuf作为发送缓冲区 */  
  43.         msg.buf = at24->writebuf;  
  44.           
  45.         /* 根据是8位还是16位地址，msg.buf的前一(两)个字节 
  46.              为设备内部的寄存器地址*/  
  47.         if (at24->chip.flags & AT24_FLAG_ADDR16)  
  48.             msg.buf[i++] = offset >> 8;  /* 16位地址，先写高位地址*/  
  49.   
  50.         msg.buf[i++] = offset;  
  51.         /* 复制需要发送的数据 */  
  52.         memcpy(&msg.buf[i], buf, count);  
  53.         msg.len = i + count;   /* 发送长度为数据长度加上地址长度*/  
  54.     }  
  55.   
  56.     /* 
  57.      * Writes fail if the previous one didn't complete yet. We may 
  58.      * loop a few times until this one succeeds, waiting at least 
  59.      * long enough for one entire page write to work. 
  60.      */  
  61.     timeout = jiffies + msecs_to_jiffies(write_timeout);  
  62.     do {  
  63.         write_time = jiffies;  
  64.         if (at24->use_smbus) {  
  65.             /* 使用SMBus协议发送*/  
  66.             status = i2c_smbus_write_i2c_block_data(client,  
  67.                     offset, count, buf);  
  68.             if (status == 0)  
  69.                 status = count;  
  70.         } else {  
  71.             /* 使用I2C协议发送*/  
  72.             status = i2c_transfer(client->adapter, &msg, 1);  
  73.             if (status == 1)  
  74.                 status = count;  
  75.         }  
  76.         dev_dbg(&client->dev, "write %zu@%d --> %zd (%ld)\n",  
  77.                 count, offset, status, jiffies);  
  78.   
  79.         if (status == count)  
  80.             return count;  /* 已全部写入，返回*/  
  81.   
  82.         /* REVISIT: at HZ=100, this is sloooow */  
  83.         msleep(1);  
  84.     } while (time_before(write_time, timeout));  /* 使用timeout */  
  85.   
  86.     return -ETIMEDOUT;  /* 超时，返回错误*/  
  87. }  

该函数首先调用了at24_translate_offset函数，来获取地址对应的client：
[cpp] view plain copy
  1. /* 
  2.  * This routine supports chips which consume multiple I2C addresses. It 
  3.  * computes the addressing information to be used for a given r/w request. 
  4.  * Assumes that sanity checks for offset happened at sysfs-layer. 
  5.  */  
  6. static struct i2c_client *at24_translate_offset(struct at24_data *at24,  
  7.         unsigned *offset)  
  8. {  
  9.     unsigned i;  
  10.   
  11.     /* 有多个I2C设备地址，根据offset获取该地址对应的client*/  
  12.     if (at24->chip.flags & AT24_FLAG_ADDR16) {  
  13.         i = *offset >> 16;  
  14.         *offset &= 0xffff;  
  15.     } else {  
  16.         i = *offset >> 8;  
  17.         *offset &= 0xff;  
  18.     }  
  19.   
  20.     return at24->client[i];  
  21. }  

然后，对写入的字节数（count）进行了调整。

随后，如果使用I2C协议，则要组建msg用于发送。

最后，根据使用I2C还是SMBus协议，调用相应的发送函数来发送数据。

注意的是，这里使用了超时，超时时间write_timeout为驱动模块参数，可由用户设置，默认为25ms。如果发送超时了，while循环将终止。

至此，at24c02的写入过程就结束了。

4.2 读函数（at24_bin_read）

  写函数和读函数非常相似，只是在使用I2C协议时，组建的msg有所不同。同样读函数也使用了超时。

  因此，这里仅仅给出代码：
[cpp] view plain copy
  1. /* 
  2.  * This routine supports chips which consume multiple I2C addresses. It 
  3.  * computes the addressing information to be used for a given r/w request. 
  4.  * Assumes that sanity checks for offset happened at sysfs-layer. 
  5.  */  
  6. static struct i2c_client *at24_translate_offset(struct at24_data *at24,  
  7.         unsigned *offset)  
  8. {  
  9.     unsigned i;  
  10.   
  11.     /* 有多个I2C设备地址，根据offset获取该地址对应的client*/  
  12.     if (at24->chip.flags & AT24_FLAG_ADDR16) {  
  13.         i = *offset >> 16;  
  14.         *offset &= 0xffff;  
  15.     } else {  
  16.         i = *offset >> 8;  
  17.         *offset &= 0xff;  
  18.     }  
  19.   
  20.     return at24->client[i];  
  21. }  
  22.   
  23. static ssize_t at24_eeprom_read(struct at24_data *at24, char *buf,  
  24.         unsigned offset, size_t count)  
  25. {  
  26.     struct i2c_msg msg[2];  
  27.     u8 msgbuf[2];  
  28.     struct i2c_client *client;  
  29.     unsigned long timeout, read_time;  
  30.     int status, i;  
  31.   
  32.     memset(msg, 0, sizeof(msg));  
  33.   
  34.     /* 
  35.      * REVISIT some multi-address chips don't rollover page reads to 
  36.      * the next slave address, so we may need to truncate the count. 
  37.      * Those chips might need another quirk flag. 
  38.      * 
  39.      * If the real hardware used four adjacent 24c02 chips and that 
  40.      * were misconfigured as one 24c08, that would be a similar effect: 
  41.      * one "eeprom" file not four, but larger reads would fail when 
  42.      * they crossed certain pages. 
  43.      */  
  44.   
  45.     /* 
  46.      * Slave address and byte offset derive from the offset. Always 
  47.      * set the byte address; on a multi-master board, another master 
  48.      * may have changed the chip's "current" address pointer. 
  49.      */  
  50.     client = at24_translate_offset(at24, &offset);  
  51.   
  52.     if (count > io_limit)  
  53.         count = io_limit;  
  54.   
  55.     if (at24->use_smbus) {  
  56.         /* Smaller eeproms can work given some SMBus extension calls */  
  57.         if (count > I2C_SMBUS_BLOCK_MAX)  
  58.             count = I2C_SMBUS_BLOCK_MAX;  
  59.     } else {  
  60.         /* 使用I2C协议，需要填充msg*/  
  61.         /* 
  62.          * When we have a better choice than SMBus calls, use a 
  63.          * combined I2C message. Write address; then read up to 
  64.          * io_limit data bytes. Note that read page rollover helps us 
  65.          * here (unlike writes). msgbuf is u8 and will cast to our 
  66.          * needs. 
  67.          */  
  68.         i = 0;  
  69.         if (at24->chip.flags & AT24_FLAG_ADDR16)  
  70.             msgbuf[i++] = offset >> 8;  
  71.         msgbuf[i++] = offset;  
  72.   
  73.         msg[0].addr = client->addr;  
  74.         msg[0].buf = msgbuf;  
  75.         msg[0].len = i;  
  76.   
  77.         msg[1].addr = client->addr;  
  78.         msg[1].flags = I2C_M_RD;  /* 读模式*/  
  79.         msg[1].buf = buf;  
  80.         msg[1].len = count;  
  81.     }  
  82.   
  83.     /* 
  84.      * Reads fail if the previous write didn't complete yet. We may 
  85.      * loop a few times until this one succeeds, waiting at least 
  86.      * long enough for one entire page write to work. 
  87.      */  
  88.     timeout = jiffies + msecs_to_jiffies(write_timeout);  
  89.     do {  
  90.         read_time = jiffies;  
  91.         if (at24->use_smbus) {  
  92.             status = i2c_smbus_read_i2c_block_data(client, offset,  
  93.                     count, buf);  
  94.         } else {  
  95.             status = i2c_transfer(client->adapter, msg, 2);  
  96.             if (status == 2)  
  97.                 status = count;  
  98.         }  
  99.         dev_dbg(&client->dev, "read %zu@%d --> %d (%ld)\n",  
  100.                 count, offset, status, jiffies);  
  101.   
  102.         if (status == count)  
  103.             return count;  
  104.   
  105.         /* REVISIT: at HZ=100, this is sloooow */  
  106.         msleep(1);  
  107.     } while (time_before(read_time, timeout));  /* 使用timeout */  
  108.   
  109.     return -ETIMEDOUT;  
  110. }  
  111.   
  112. static ssize_t at24_read(struct at24_data *at24,  
  113.         char *buf, loff_t off, size_t count)  
  114. {  
  115.     ssize_t retval = 0;  
  116.   
  117.     if (unlikely(!count))  
  118.         return count;  
  119.   
  120.     /* 
  121.      * Read data from chip, protecting against concurrent updates 
  122.      * from this host, but not from other I2C masters. 
  123.      */  
  124.      /* 访问设备前，加锁*/  
  125.     mutex_lock(&at24->lock);   
  126.   
  127.     while (count) {  
  128.         ssize_t status;  
  129.   
  130.         status = at24_eeprom_read(at24, buf, off, count);  
  131.         if (status <= 0) {  
  132.             if (retval == 0)  
  133.                 retval = status;  
  134.             break;  
  135.         }  
  136.         buf += status;  
  137.         off += status;  
  138.         count -= status;  
  139.         retval += status;  
  140.     }  
  141.   
  142.     mutex_unlock(&at24->lock);  
  143.   
  144.     return retval;  
  145. }  
  146.   
  147. static ssize_t at24_bin_read(struct kobject *kobj, struct bin_attribute *attr,  
  148.         char *buf, loff_t off, size_t count)  
  149. {  
  150.     struct at24_data *at24;  
  151.   
  152.     /* 通过kobj获取device，再获取driver_data */  
  153.     at24 = dev_get_drvdata(container_of(kobj, struct device, kobj));  
  154.     return at24_read(at24, buf, off, count);  
  155. }  

5. 总结

    本文主要对at24c02的驱动架构进行了分析。该驱动基于i2c总线架构，提供了id表来帮助设备驱动的绑定，该驱动支持AT24CXX等多个系列，不仅仅是at24c02。

其次，该驱动并没有注册任何字符设备或者杂项设备，而是通过sys文件系统的二进制属性文件来对设备进行访问。此外，驱动同时支持I2C协议和SMBus协议来访问设备。


有关驱动的移植可以参考：

S3C2440驱动移植——AT24C02（EEPROM）移植

kunkliu
关注
专栏目录
Linux驱动开发-编写(EEPROM)AT24C02驱动
03-09 1169
AT24C02是IIC接口的EEPROM存储芯片，这颗芯片非常经典，百度搜索可以找到非常多的资料，大多都是51、STM32单片机的示例代码，大多采用模拟时序、裸机系统运行。当前文章介绍在Linux系统里如何编写AT24C02的驱动，并且在应用层完成驱动读写测试，将AT24C02的存储空间映射成文件，在应用层，用户可以直接将AT24C02当做一个普通文件的形式进行读写，偏移文件指针；在Linux内核里有一套标准的IIC子系统框架专门读写IIC接口设备，采用平台设备模型框架，编写驱动非常方便。
ESP32-C3入门教程 基础篇⑦——I2C通信读写EEPROM AT24CXX
小康师兄
09-23 2611
文章目录一、IIC简介二、硬件接线三、运行效果四、初始化五、数据读取六、数据写入 一、IIC简介 IIC(Inter－Integrated Circuit)总线是一种由 PHILIPS 公司开发的两线式串行总线，用于连接微控制器及其外围设备。 它是由数据线 SDA 和时钟 SCL 构成的串行总线，可发送和接收数据。 在 CPU 与被控 IC 之间、IC 与 IC 之间进行双向传送，高速 IIC 总线一般可达 400kbps 以上。 I2C 总线在传送数据过程中共有三种类型信号， 它们分别是：开始信号、
TQ2440 linux i2c驱动——at24c02（eeprom）
izobs‘s linux-space
07-21 3221
TQ2440 linux i2c驱动——at24c02（eeprom） 最近因为实习的原因要搞一个摄像头的驱动，多数cmos摄像头是用SCCB协议来配置寄存器，类似于i2c，于是从零o开始。因为TQ2440板上有at24c02 eeprom，正好拿他来开刀。下面把这几天的心得写下来与大家分享。 一.开发环境: （1）开发板:TQ2440开发板 （2）pc系统:ubuntu 13.04-
S3C2440 Linux驱动移植——AT24C02（EEPROM）驱动
热门推荐
嵌入式Linux
01-11 1万+
开发板：TQ2440 内核：Linux 2.6.32 PC OS：Ubuntu 11.04 1.配置内核 打开I2C功能： 打开杂项设备，该选项打开后，EEPROM也就打开了。     2. 修改代码 修改文件: linux/arch/arm/mach-s3c2440/mach-smdk2440.c 增加如下代码片段： #include stat
IIC协议详解--Linux下I2C读取AT24C02例程
weixin_37553721的博客
04-10 1919
I2C 是很常见的一种总线协议， I2C是NXP公司设计的，I2C 使用两条线在主控制器和从机之间进行数据通信。一条是 SCL(串行时钟线)，另外一条是 SDA(串行数据线)，因为I2C这两条数据线是开漏输出的，所以需要接上拉电阻，总线空闲的时候 SCL 和 SDA 处于高电平。I2C 总线标准模式下速度可以达到 100Kb/S，快速模式下可以达到 400Kb/S。感兴趣的可以读《I2C总线规范和用户手册》
i2c.rar_2440_2440 I2C_i2c_i2c 驱动_lpc2214
09-22
标题中的“i2c.rar_2440_2440 I2C_i2c_i2c 驱动_lpc2214”暗示了这是一个关于S3C2440微处理器的I2C（Inter-Integrated Circuit）接口的驱动程序，主要针对I2C通信协议进行开发和测试。I2C是一种多主机、两线制的串行...
S3C2440A + IIC + AT24C02 + IAR
10-24
标题 "S3C2440A + IIC + AT24C02 + IAR" 描述了一个基于S3C2440A微处理器的电子设计项目，该设计中利用了IIC（Inter-Integrated Circuit）通信协议来与AT24C02电可擦可编程只读存储器（EEPROM）进行交互。...
s3c2440 IIC AT24C08 No Interrupt
06-05
在本文中，我们将深入探讨与"S3C2440 IIC AT24C08 No Interrupt"相关的知识点，这是关于在S3C2440微处理器上实现IIC通信，针对AT24C08 EEPROM进行裸机编程的一个案例，且不使用中断模式。S3C2440是一款广泛应用的ARM...
嵌入式中linux系统对eeprom芯片at24c02的操作实例（包括驱动层和应用层代码）
仗劍走天涯
09-15 1586
应用层代码示例 /* app.c at24c08读写测试应用程序 */ #include <stdio.h> #include <string.h> #include <stdlib.h> #include <fcntl.h> #include <unistd.h> #include <sys/types.h> ...
AT24C02驱动
08-20
AT24C02存储芯片的驱动程序，以及AT24C02存储芯片的资料内容。
AT24C02驱动程序（I2C串行总线的组成及工作原理）
09-26
基于IIC总线的AT24C02驱动程序详解
linux下eeprom调试(AT24c02)
weixin_37854301的博客
10-19 1360
仓库 https://github.com/starfive-tech/linux.git branch starlight 使能配置 make menuconfig ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- Device Drivers > Misc devices > EEPROM support > "I2C EEPROMs / RAMs / ROMs from most vendors" 增加dts节点 diff --git a
S3C2440 IIC读写AT24C02A
lianghongge的专栏
10-07 1506
S3C2440读写AT24C02A只需要采用主机发送模式和主机接收模式即可，手册上提供有这两个模式的流程图，可以参考。AT24C02A有几点需要注意的：1.写程序时还要看下AT24C02A操作时序图，AT24C02A连续读多个字节时最后一个字节不用产生应答信号。2.读的时候要先用写的方式写入硬件地址写方式和数据地址，此时不用发送STOP信号，接着继续写入硬件地址读方式，然后开始读数据。3.其写的方式只有单字节写或者页写两种，页写时每次只能写一页不能超过，AT24C02A的一页大小是8字节。以下是程序：#in
IIC驱动AT24C02(EEPROM)读写操作
m0_52864526的博客
09-22 2562
总容量是256（2K/8)个字节。接口：IIC1、EEPROM由8位表示为存储地址2、设备号+读写位其中最低位是读写位，0表示读，1表示写高7位表示设备地址（IIC通讯使用）下面图中的设备地址只是占用了4位，A0-A2默认为0。因此设备地址为1010（二进制）3、内存地址根据EEPROM的型号不同，其中设备地址占的位数有所不同，有的存储的地址单元超过8位。例如AT24C04有512个地址，需要9位表示。24C08有1024个地址，需要10位表示。为解决这个问题，
嵌入式Linux开发: 编写EEPROM驱动_采用杂项字符设备框架
最新发布
走向CTO的路上...
07-12 573
总之,EEPROM驱动程序的开发是一个不断演进的过程,需要根据实际需求和硬件条件进行持续优化和扩展,以满足不同场景下的应用需求。目前示例代码仅支持I2C接口的EEPROM,未来可以扩展支持SPI、并行接口等其他类型的EEPROM。如果多个进程同时访问EEPROM,需要实现适当的并发控制机制,确保数据的一致性。根据EEPROM的硬件接口,实现设备寻址算法,确定要读写的EEPROM芯片。实现更加全面的错误检测和处理机制,如EEPROM损坏、写保护等情况的处理。
Clion开发STM32之at24c02驱动的封装(I2C硬件驱动)
scl8295的博客
05-07 230
【代码】Clion开发STM32之at24c02驱动的封装(I2C硬件驱动)
Linux系统驱动之编写APP直接访问EEPROM
韦东山嵌入式专栏
08-25 587
编写APP直接访问EEPROM 参考资料： Linux驱动程序: drivers/i2c/i2c-dev.c I2C-Tools-4.2: https://mirrors.edge.kernel.org/pub/software/utils/i2c-tools/ AT24cxx.pdf 本节源码：GIT仓库中 doc_and_source_for_drivers\IMX6ULL\source\04_I2C\01_at24c02_test doc_and_source_for_drivers\STM32
NiosII嵌入式系统中基于AT24C02的I2C接口设计与验证
嵌入式系统/ARM技术中的基于NiosII的I2C总线接口实现是一篇专注于在Nios II嵌入式系统中应用AT24C02A芯片的文章。Nios II系统在面临掉电风险时，需要确保重要数据的安全存储，因此作者提出了结合Nios II处理器和AT...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值