I2C自编设备驱动设计

最新推荐文章于 2021-05-09 10:38:09 发布
最新推荐文章于 2021-05-09 10:38:09 发布
阅读量115 收藏
点赞数
原文链接：http://www.cnblogs.com/ch122633/p/7363293.html
版权
一、自编设备驱动模型

at24.c:
  1. static int __init at24_init(void)
  2. {
  3.     io_limit = rounddown_pow_of_two(io_limit);
  4.     return i2c_add_driver(&at24_driver);                                   //注册i2c驱动设备
  5. }
at24_driver:
  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. };
at24_probe:
  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;

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

  29.         chip.setup = NULL;
  30.         chip.context = NULL;
  31.     }

  33.     if (!is_power_of_2(chip.byte_len))
  34.         dev_warn(&client->dev,
  35.             "byte_len looks suspicious (no power of 2)!\n");
  36.     if (!is_power_of_2(chip.page_size))
  37.         dev_warn(&client->dev,
  38.             "page_size looks suspicious (no power of 2)!\n");

  40.     /* Use I2C operations unless we're stuck with SMBus extensions. */
  41.     if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
  42.         if (chip.flags & AT24_FLAG_ADDR16) {
  43.             err = -EPFNOSUPPORT;
  44.             goto err_out;
  45.         }
  46.         if (!i2c_check_functionality(client->adapter,
  47.                 I2C_FUNC_SMBUS_READ_I2C_BLOCK)) {
  48.             err = -EPFNOSUPPORT;
  49.             goto err_out;
  50.         }
  51.         use_smbus = true;
  52.     }

  54.     if (chip.flags & AT24_FLAG_TAKE8ADDR)
  55.         num_addresses = 8;
  56.     else
  57.         num_addresses =    DIV_ROUND_UP(chip.byte_len,
  58.             (chip.flags & AT24_FLAG_ADDR16) ? 65536 : 256);

  60.     at24 = kzalloc(sizeof(struct at24_data) +
  61.         num_addresses * sizeof(struct i2c_client *), GFP_KERNEL);
  62.     if (!at24) {
  63.         err = -ENOMEM;
  64.         goto err_out;
  65.     }

  67.     mutex_init(&at24->lock);
  68.     at24->use_smbus = use_smbus;
  69.     at24->chip = chip;
  70.     at24->num_addresses = num_addresses;

  72.     /*
  73.      * Export the EEPROM bytes through sysfs, since that's convenient.
  74.      * By default, only root should see the data (maybe passwords etc)
  75.      */
  76.     at24->bin.attr.name = "eeprom";
  77.     at24->bin.attr.mode = chip.flags & AT24_FLAG_IRUGO ? S_IRUGO : S_IRUSR;
  78.     at24->bin.read = at24_bin_read;
  79.     at24->bin.size = chip.byte_len;

  81.     at24->macc.read = at24_macc_read;

  83.     writable = !(chip.flags & AT24_FLAG_READONLY);
  84.     if (writable) {
  85.         if (!use_smbus || i2c_check_functionality(client->adapter,
  86.                 I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) {

  88.             unsigned write_max = chip.page_size;

  90.             at24->macc.write = at24_macc_write;

  92.             at24->bin.write = at24_bin_write;                          //这里注册了at24_bin_write，用户的write函数的调用接口
  93.             at24->bin.attr.mode |= S_IWUSR;

  95.             if (write_max > io_limit)
  96.                 write_max = io_limit;
  97.             if (use_smbus && write_max > I2C_SMBUS_BLOCK_MAX)
  98.                 write_max = I2C_SMBUS_BLOCK_MAX;
  99.             at24->write_max = write_max;

  101.             /* buffer (data + address at the beginning) */
  102.             at24->writebuf = kmalloc(write_max + 2, GFP_KERNEL);
  103.             if (!at24->writebuf) {
  104.                 err = -ENOMEM;
  105.                 goto err_struct;
  106.             }
  107.         } else {
  108.             dev_warn(&client->dev,
  109.                 "cannot write due to controller restrictions.");
  110.         }
  111.     }

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

  115.     /* use dummy devices for multiple-address chips */
  116.     for (i = 1; i < num_addresses; i++) {
  117.         at24->client[i] = i2c_new_dummy(client->adapter,
  118.                     client->addr + i);
  119.         if (!at24->client[i]) {
  120.             dev_err(&client->dev, "address 0x%02x unavailable\n",
  121.                     client->addr + i);
  122.             err = -EADDRINUSE;
  123.             goto err_clients;
  124.         }
  125.     }

  127.     err = sysfs_create_bin_file(&client->dev.kobj, &at24->bin);          //创建一个文件应用程序实际上是在/sys目录下的文件，而这个文件就是它函数创建的。
  128.     if (err)
  129.         goto err_clients;

  131.     i2c_set_clientdata(client, at24);

  133.     dev_info(&client->dev, "%zu byte %s EEPROM %s\n",
  134.         at24->bin.size, client->name,
  135.         writable ? "(writable)" : "(read-only)");
  136.     dev_dbg(&client->dev,
  137.         "page_size %d, num_addresses %d, write_max %d%s\n",
  138.         chip.page_size, num_addresses,
  139.         at24->write_max,
  140.         use_smbus ? ", use_smbus" : "");

  142.     /* export data to kernel code */
  143.     if (chip.setup)
  144.         chip.setup(&at24->macc, chip.context);

  146.     return 0;

  148. err_clients:
  149.     for (i = 1; i < num_addresses; i++)
  150.         if (at24->client[i])
  151.             i2c_unregister_device(at24->client[i]);

  153.     kfree(at24->writebuf);
  154. err_struct:
  155.     kfree(at24);
  156. err_out:
  157.     dev_dbg(&client->dev, "probe error %d\n", err);
  158.     return err;
  159. }
at24_bin_write:
  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;

  6.     at24 = dev_get_drvdata(container_of(kobj, struct device, kobj));
  7.     return at24_write(at24, buf, off, count);                        //调用at24_write
  8. }
at24_write:
  1. static ssize_t at24_write(struct at24_data *at24, const char *buf, loff_t off,
  2.              size_t count)
  3. {
  4.     ssize_t retval = 0;

  6.     if (unlikely(!count))
  7.         return count;

  9.     mutex_lock(&at24->lock);

  11.     while (count) {
  12.         ssize_t    status;

  14.         status = at24_eeprom_write(at24, buf, off, count);                    //调用at24_eeprom_write
  15.         if (status <= 0) {
  16.             if (retval == 0)
  17.                 retval = status;
  18.             break;
  19.         }
  20.         buf += status;
  21.         off += status;
  22.         count -= status;
  23.         retval += status;
  24.     }

  26.     mutex_unlock(&at24->lock);

  28.     return retval;
  29. }
at24_eeprom_write:
  1. static ssize_t at24_eeprom_write(struct at24_data *at24, const char *buf,
  2.         unsigned offset, size_t count)
  3. {
  4.     struct i2c_client *client;
  5.     struct i2c_msg msg;
  6.     ssize_t status;
  7.     unsigned long timeout, write_time;
  8.     unsigned next_page;

  10.     /* Get corresponding I2C address and adjust offset */
  11.     client = at24_translate_offset(at24, &offset);

  13.     /* write_max is at most a page */
  14.     if (count > at24->write_max)
  15.         count = at24->write_max;

  17.     /* Never roll over backwards, to the start of this page */
  18.     next_page = roundup(offset + 1, at24->chip.page_size);
  19.     if (offset + count > next_page)
  20.         count = next_page - offset;

  22.     /* If we'll use I2C calls for I/O, set up the message */                     //I2C的消息
  23.     if (!at24->use_smbus) {
  24.         int i = 0;

  26.         msg.addr = client->addr;
  27.         msg.flags = 0;

  29.         /* msg.buf is u8 and casts will mask the values */
  30.         msg.buf = at24->writebuf;
  31.         if (at24->chip.flags & AT24_FLAG_ADDR16)
  32.             msg.buf[i++] = offset >> 8;

  34.         msg.buf[i++] = offset;                                          //提供偏移地址
  35.         memcpy(&msg.buf[i], buf, count);                                //拷贝用户发送数据
  36.         msg.len = i + count;                                            //设置长度
  37.     }

  39.     /*
  40.      * Writes fail if the previous one didn't complete yet. We may
  41.      * loop a few times until this one succeeds, waiting at least
  42.      * long enough for one entire page write to work.
  43.      */
  44.     timeout = jiffies + msecs_to_jiffies(write_timeout);
  45.     do {
  46.         write_time = jiffies;
  47.         if (at24->use_smbus) {
  48.             status = i2c_smbus_write_i2c_block_data(client,
  49.                     offset, count, buf);
  50.             if (status == 0)
  51.                 status = count;
  52.         } else {
  53.             status = i2c_transfer(client->adapter, &msg, 1);                     //交给I2C控制器完成
  54.             if (status == 1)
  55.                 status = count;
  56.         }
  57.         dev_dbg(&client->dev, "write %zu@%d --> %zd (%ld)\n",
  58.                 count, offset, status, jiffies);

  60.         if (status == count)
  61.             return count;

  63.         /* REVISIT: at HZ=100, this is sloooow */
  64.         msleep(1);
  65.     } while (time_before(write_time, timeout));

  67.     return -ETIMEDOUT;
  68. }
i2c_transfer:
  1. int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
  2. {
  3.     int ret;

  5.     if (adap->algo->master_xfer) {
  6. #ifdef DEBUG
  7.         for (ret = 0; ret < num; ret++) {
  8.             dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
  9.                 "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
  10.                 ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
  11.                 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
  12.         }
  13. #endif

  15.         if (in_atomic() || irqs_disabled()) {
  16.             ret = mutex_trylock(&adap->bus_lock);
  17.             if (!ret)
  18.                 /* I2C activity is ongoing. */
  19.                 return -EAGAIN;
  20.         } else {
  21.             mutex_lock_nested(&adap->bus_lock, adap->level);
  22.         }

  24.         ret = adap->algo->master_xfer(adap,msgs,num);                   //调用控制器中的算法
  25.         mutex_unlock(&adap->bus_lock);

  27.         return ret;
  28.     } else {
  29.         dev_dbg(&adap->dev, "I2C level transfers not supported\n");
  30.         return -EOPNOTSUPP;
  31.     }
  32. }
然后看一下i2c_bin_read:
  1. static ssize_t at24_bin_read(struct kobject *kobj, struct bin_attribute *attr,
  2.         char *buf, loff_t off, size_t count)
  3. {
  4.     struct at24_data *at24;

  6.     at24 = dev_get_drvdata(container_of(kobj, struct device, kobj));
  7.     return at24_read(at24, buf, off, count);                               //调用at24_read
  8. }
at24_read:
  1. static ssize_t at24_read(struct at24_data *at24,
  2.         char *buf, loff_t off, size_t count)
  3. {
  4.     ssize_t retval = 0;

  6.     if (unlikely(!count))
  7.         return count;

  9.     mutex_lock(&at24->lock);

  11.     while (count) {
  12.         ssize_t    status;

  14.         status = at24_eeprom_read(at24, buf, off, count);                  //继续调用at24_eeprom_read
  15.         if (status <= 0) {
  16.             if (retval == 0)
  17.                 retval = status;
  18.             break;
  19.         }
  20.         buf += status;
  21.         off += status;
  22.         count -= status;
  23.         retval += status;
  24.     }

  26.     mutex_unlock(&at24->lock);

  28.     return retval;
  29. }
at24_eeprom_read:
  1. static ssize_t at24_eeprom_read(struct at24_data *at24, char *buf,
  2.         unsigned offset, size_t count)
  3. {
  4.     struct i2c_msg msg[2];
  5.     u8 msgbuf[2];
  6.     struct i2c_client *client;
  7.     int status, i;

  9.     memset(msg, 0, sizeof(msg));

  11.     client = at24_translate_offset(at24, &offset);

  13.     if (count > io_limit)
  14.         count = io_limit;

  16.     /* Smaller eeproms can work given some SMBus extension calls */
  17.     if (at24->use_smbus) {
  18.         if (count > I2C_SMBUS_BLOCK_MAX)
  19.             count = I2C_SMBUS_BLOCK_MAX;
  20.         status = i2c_smbus_read_i2c_block_data(client, offset,
  21.                 count, buf);
  22.         dev_dbg(&client->dev, "smbus read %zu@%d --> %d\n",
  23.                 count, offset, status);
  24.         return (status < 0) ? -EIO : status;
  25.     }

  27.     i = 0;
  28.     if (at24->chip.flags & AT24_FLAG_ADDR16)
  29.         msgbuf[i++] = offset >> 8;
  30.     msgbuf[i++] = offset;                                                //设置偏移

  32.     msg[0].addr = client->addr;                                          //第一条消息，提供从设备地址
  33.     msg[0].buf = msgbuf;
  34.     msg[0].len = i;

  36.     msg[1].addr = client->addr;                                          //第二条消息
  37.     msg[1].flags = I2C_M_RD;                                             //flags是读
  38.     msg[1].buf = buf;                                                    //提供数据量
  39.     msg[1].len = count;

  41.     status = i2c_transfer(client->adapter, msg, 2);
  42.     dev_dbg(&client->dev, "i2c read %zu@%d --> %d\n",
  43.             count, offset, status);

  45.     if (status == 2)
  46.         return count;
  47.     else if (status >= 0)
  48.         return -EIO;
  49.     else
  50.         return status;
  51. }

二、对驱动程序的修改和移植
I2C设备的注册：
  1. static void __init tq2440_machine_init(void)
  2. {
  3.     s3c24xx_fb_set_platdata(&tq2440_fb_info);
  4.     s3c_i2c0_set_platdata(NULL);

  6.     platform_add_devices(tq2440_devices, ARRAY_SIZE(tq2440_devices));
  7.     EmbedSky_machine_init();
  8.     s3c2410_gpio_setpin(S3C2410_GPG12, 0);
  9.     s3c2410_gpio_cfgpin(S3C2410_GPG12, S3C2410_GPIO_OUTPUT);
  10.     s3c24xx_udc_set_platdata(&EmbedSky_udc_cfg);
  11. }
增加设备：
  1. static struct at24_platform_data at24c02 = {
  2.     .byte_len = 2048 / 8,
  3.     .page_size = 8,
  4.     .flags = 0,
  5. };

  7. static struct i2c_board_info __initdata tq2440_i2c_devices[] = {
  8.     {
  9.         I2C_BOARD_INFO("24c02", 0x50),
  10.         .platform_data = &at24c02,
  11.     },
  12. };
然后在tq2440_machine_init中添加：
  1. i2c_register_board_info(0, tq2440_i2c_devices, ARRAY_SIZE(tq2440_i2c_devices));
然后添加头文件：
  1. #include <linux/i2c.h>
  2. #include <linux/i2c/at24.h>
然后会在开发板/sys/bus/i2c/devices/有一个0-0050的目录，有一个eeprom文件。

编写i2c-app.c文件：
  1. #include <stdio.h>
  2. #include <sys/types.h>
  3. #include <sys/stat.h>
  4. #include <fcntl.h>
  5. #include <unistd.h>

  7. int main()
  8. {
  9.     char write_data[256],read_data[256];
  10.     int fd;
  11.     int i = 0;
  12.     //打开at24c02对应的sys文件
  13.     fd = open("/sys/bus/i2c/devices/0-0050/eeprom", O_RDWR);

  15.     //写入数据
  16.     for(i=0;i<256;i++)
  17.         write_data[i] = i;

  19.     lseek(fd, 0, SEEK_SET);
  20.     write(fd, write_data, 256);
  21.     //读出数据
  22.     lseek(fd, 0, SEEK_SET);
  23.     read(fd, read_data, 256);

  25.     //打印对比
  26.     for(i=0;i<256;i++)
  27.     {
  28.         if(i%16 == 0) printf("\r\n");
  29.         printf("%3d ",read_data[i]);
  30.     }
  31.     printf("\n");
  32.     close(fd);
  33. }




















转载于:https://www.cnblogs.com/ch122633/p/7363293.html

weixin_30412167
关注
Linux I2C驱动框架（超详细）
JT同学的博客
06-07 4万+
Linux I2C驱动框架 一、总览全局 在讨论I2C驱动框架前，先讨论几个重要的概念 1、I2C总线 struct bus_type i2c_bus_type = { .name = "i2c", .match = i2c_device_match, .probe = i2c_device_probe, .remove = i2c_device_remove, .shutdow...
Linux驱动开发实战宝典：设备模型、模块编程、I2C/SPI/USB外设精讲
最新发布
嵌入式极客小张
07-01 1247
I2C 是一种同步、半双工的通信协议，只有两根线：SDA(数据线) 和 SCL(时钟线)。每个连接到总线的器件都有唯一的 I2C 地址。SPI 是一种同步、全双工的通信协议，使用四根线：MOSI(主输出从输入)、MISO(主输入从输出)、SCLK(时钟线) 和 CS(片选线)。USB 是一种通用串行总线，用于连接计算机和外设。它使用四根线：VBUS(电源线)、GND(地线)、D+(数据线) 和 D-(数据线)。
I2C总线及EEPROM的Linux驱动程序的设计
张亮校的专栏
06-05 880
之所以转载此博客,是因为这个对linux架构解释的比较清楚.   1 引言 　　I2C （Inter-Integrated Circuit1总线是一种由Philips公司开发的2线式串行总线，用于连接微控制器及其外围设备。它是同步通信的一种特殊形式，具有接口线少、控制方式简单、器件封装形式小、通信速率较高等优点。在主从通信中，可有多个I2C总线器件同时接到I2C总线上，通过地址来识别通信对象
gpio_direction_output 和 gpio_set_value之间的使用关系
热门推荐
BlackSmith
11-08 1万+
在linux驱动中常常会碰到gpio_set_value（port_num,0/1）或gpio_direction_output （port_num,0/1) 这两者有什么关系呢gpio_set_value（port_num,0/1） 一般只是在这个GPIO口的寄存器上写上某个值，至于这个端口是否设置为输出，它就管不了！而gpio_direction_output （port_num,0/1)
求最接近的最大2的指数次幂roundup_pow_of_two分析与实现
mergerly的专栏
09-02 1万+
思想很简单，就是找出当前数的二级制中最大位为1位的
AT24 I2C EEPROM解析及测试
weixin_33918357的博客
11-27 1036
 关键词：AT24、I2C、nvmem、EEPROM。 1. AT24C介绍 AT24C是一款采用I2C通信的EEPROM，相关驱动涉及到I2C和nvmem。 I2C是读写数据的通道，nvmem将AT24C注册为nvmem设备。   2.源码分析   2.1 DTS at24是挂在i2c总线下的设备，硬件接到哪个i2c，DTS中也需要对应修改。 其中需要注意的是，status不能是disabled...
数据结构之内核队列kfifo
u011298001的博客
01-10 3367
kfifo概述 据wiki介绍，环形缓冲区（ring buffer），也称作圆形队列（circular queue），圆形缓冲区（circular buffer），循环缓冲区（cyclic buffer），是一种用于表示一个固定尺寸、头尾相连的缓冲区的数据结构，适合缓存数据流。 圆形缓冲区的一个有用特性是：当一个数据元素被用掉后，其余数据元素不需要移动其存储位置。相反，一个非圆形缓冲区（例如一...
linux驱动i2c设备树中断,linux-kernel – 将设备树中断标志映射到devm_request_irq
weixin_34656273的博客
05-05 1205
此外,我将展示如何在一些常见情况下从设备树获取IRQ号和IRQ标志：>在I2C驱动程序中>在平台驱动程序中>手动在I2C驱动程序中简而言之如果您正在编写I2C驱动程序,则无需手动从DT读取IRQ参数.您可以依靠I2C内核为您填充IRQ参数：>在您的probe()函数中,client-> irq将包含IRQ编号> devm_request_irq()将自动使用DT...
linux软件层修改i2c速率,Linux I2C驱动分析(三)----i2c_dev驱动和应用层分析
weixin_31131927的博客
05-09 2779
一、i2c-dev驱动分析1.1、设备驱动注册分析这个驱动，还是从module_init()和module_exit()开始，程序如下：点击(此处)折叠或打开staticint__init i2c_dev_init(void){intres;printk(KERN_INFO"i2c /dev entries driver\n");res=register_chrdev(I2C_MAJOR, "i2...
操作系统第二次实验-------向linux内核添加自定义的系统调用函数
qq_38091564的博客
06-01 1623
添加自定义的系统调用函数实验目的实验环境实验内容添加自定义的系统调用编译linux内核编写实验代码实验结论 实验目的   本次实验主要是完成一个简单四则运算的系统调用，同时在用户态实现一个相同功能的代码，比较系统调用与普通用户态的时间开销。 实验环境   系统版本 Ubuntu 18.0.4   当前linux内核版本 linux4.15.0-101   需要重新编译的linux版本 4.10.1 实验内容   本次实验主要涉及以下三个方面的内容：   第一、添加自定义的系统调用，这一块主要涉及：添加系统调
Linux设备驱动程序架构分析之一个I2C驱动实例
Linux/Android开发记录
12-12 1万+
作者：刘昊昱  博客：http://blog.csdn.net/liuhaoyutz 内核版本：3.10.1   编写一个I2C设备驱动程序的工作可分为两部分，一是定义和注册I2C设备，即i2c_client；二是定义和注册I2C设备驱动，即i2c_driver。下面我们就以mini2440的I2C设备at24c08 EEPROM为例，介绍如何完成这两个工作。   一、定义和注册I2C
linux的I2C驱动——ID匹配
Smile_Smilling的博客
08-06 3246
以下基于3.0内核版本的源码进行讲解，驱动代码路径为driver/misc/eeprom/at24.c。I2C核心代码路径为driver/I2C 模块入口module_init(at24_init);module_init()是一个宏定义，位于include/linux/init.h。 如果将驱动编译入内核，定义如下：#define device_initcall(fn) __define
关于Linux下I2C驱动的Probe方式没有自动生成i2c_client且没有自动调用i2c_driver的.probe指向的函数的问题解决
lihui126的专栏
05-14 5736
背景项目内容是使用i2c接口的气压传感器SHT21，连接至mini2440上实时采集气压存储至板子上的sqlite数据库并显示一个Qt的界面。同学负责SHT21的驱动编写，博主负责上层应用的开发。开发工具均使用mini2440官方提供的工具，交叉编译器使用gcc4.4.3 with EABI，开发板内核是linux-2.6.32.2版本，主机环境是Ubuntu12.04。
基于S3C2440的嵌入式Linux驱动——AT24C02(EEPROM I2C接口)驱动解读
嵌入式Linux
01-12 1万+
本文将介绍Linux中AT24C02驱动。AT24C02是一种EEPROM，使用I2C接口来访问。 在开发板中，使用I2C控制器0和AT24C02连接，这里就不给出原理图了，如需要，可以搜索TQ2440开发板的原理图。 目标平台：TQ2440 CPU：s3c2440 内核版本：2.6.32 本文所有的代码均位于内核源码：linux/drivers/misc/eeprom/at24.
学习笔记 --- LINUX I2C总线驱动框架分析
忧郁天蝎
04-11 802
I2C也是一种总线，协议就不多说了，这里主要分析框架，怎么使用内核kuangjia
Linux驱动子系统之I2C(5)
liaoye's blog
11-21 6550
5 客户驱动 5.1 概述 I2C客户驱动是对I2C从设备的实现，一个具体的I2C客户驱动包括两个部分：一部分是i2c_driver，用于将设备挂接于i2c总线；另一部分是设备本身的驱动。 I2C客户驱动程序主要由i2c_driver和i2c_client来描述。   5.2 实例源码分析 好了，我们来深入了解客户驱动代码的实现，drivers/misc/eeprom/at24.c文件
I2C总线 驱动程序设计 --- EEPROM 驱动设计
ZhY_Rening的博客
08-04 1032
I2C总线 驱动程序设计 --- EEPROM 驱动设计
Kernel I2C子系统
weixin_33755649的博客
12-09 628
2019独角兽企业重金招聘Python工程师标准>>> ...
i2c-gpio的使用
07-09
现在，您可以使用标准的I2C工具（如i2c-tools）或编写自己的应用程序来与通过i2c-gpio驱动程序模拟的I2C设备进行通信。 请注意，i2c-gpio是一种软件模拟的解决方案，在某些情况下可能会受到性能或兼容性方面的限制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值