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. }




















    无欲速，无见小利。欲速，则不达；见小利，则大事不成。
  • 相关阅读:
    地方坐标系
    地图常用坐标系
    地图投影【百度百科】
    地图投影
    坐标系、坐标参照系、坐标变换、投影变换
    Scale和Resolution的含义及转换算法
    OpenStreetMap/Google/百度/Bing瓦片地图服务(TMS)
    面向对象的一些方法
    对象构造函数的原型图
    bookstarp的初体验
  • 原文地址：https://www.cnblogs.com/ch122633/p/7363293.html
Copyright © 2011-2022 走看看