zoukankan      html  css  js  c++  java

  • I2C自编设备驱动设计

    一、自编设备驱动模型

    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)! ");
    36.     if (!is_power_of_2(chip.page_size))
    37.         dev_warn(&client->dev,
    38.             "page_size looks suspicious (no power of 2)! ");

    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 ",
    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 ",
    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 ",
    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 ", 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) ",
    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 ", 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 ");
    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 ",
    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 ",
    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(" ");
    29.         printf("%3d ",read_data[i]);
    30.     }
    31.     printf(" ");
    32.     close(fd);
    33. }




















    无欲速，无见小利。欲速，则不达；见小利，则大事不成。
  • 相关阅读:
    HDU 1800 Flying to the Mars 字典树，STL中的map ，哈希树
    字典树 HDU 1075 What Are You Talking About
    字典树 HDU 1251 统计难题
    最小生成树prim算法 POJ2031
    POJ 1287 Networking 最小生成树
    次小生成树 POJ 2728
    最短路N题Tram SPFA
    poj2236 并查集
    POJ 1611并查集
    Number Sequence
  • 原文地址：https://www.cnblogs.com/ch122633/p/7363293.html
Copyright © 2011-2022 走看看