x4412&ibox项目实战55－Linux音频驱动之I2C驱动实验

armeasy

音频驱动关于I2C的源码路径：

1. kernel/sound/soc/codecs/wm8960.c
   
2. kernel/arch/arm/mach-exynos/mach-x4412.c
   
3. kernel/sound/soc/soc-core.c
   
4. kernel/sound/soc/soc-cache.c

复制代码

       在mach-x4412.c中，通过I2C_BOARD_INFO宏指定了音频芯片wm8960的名称和i2c地址，同时，在i2c_devs0数组中，还指定了音频驱动的平台数据：

1. static struct wm8960_data wm8960_pdata = {
   
2.          .capless      = 0,
   
3.          .dres           = WM8960_DRES_400R,
   
4. };
   
5. 
   
6. static struct i2c_board_info i2c_devs0[] __initdata = {
   
7.          {
   
8.                    I2C_BOARD_INFO("kxud9", 0x18),
   
9.                    .platform_data     = &kxud9_data,
   
10.          }, {
    
11.                    I2C_BOARD_INFO("wm8960", 0x1a),
    
12.                    .platform_data = &wm8960_pdata,
    
13.          }
    
14. };

复制代码

       在smdk4x12_machine_init函数中，通过i2c_register_board_info函数注册相应的i2c设备：

1. i2c_register_board_info(0, i2c_devs0, ARRAY_SIZE(i2c_devs0));

复制代码

       这时，一个名为wm8960，设备地址为0x1a的设备已经被添加到i2c总线上。

       在wm8960.c的wm8960_modinit中，通过i2c_add_driver函数添加了一个名为wm8960-codec的i2c设备驱动：

1. static const struct i2c_device_id wm8960_i2c_id[] = {
   
2.          { "wm8960", 0 },
   
3.          { }
   
4. };
   
5. MODULE_DEVICE_TABLE(i2c, wm8960_i2c_id);
   
6. 
   
7. static struct i2c_driver wm8960_i2c_driver = {
   
8.          .driver = {
   
9.                    .name = "wm8960-codec",
   
10.                    .owner = THIS_MODULE,
    
11.          },
    
12.          .probe =    wm8960_i2c_probe,
    
13.          .remove =   __devexit_p(wm8960_i2c_remove),
    
14.          .id_table = wm8960_i2c_id,
    
15. };

复制代码

       在wm8960_i2c_id中，可以找到和I2C_BOARD_INFO宏注册的相同的i2c设备驱动名称wm8960，探测函数wm8960_i2c_probe被触发。

1. static __devinit int wm8960_i2c_probe(struct i2c_client *i2c,
   
2.                                            const struct i2c_device_id *id)
   
3. {
   
4.          struct wm8960_priv *wm8960;
   
5.          int ret;
   
6. 
   
7.          //在这里可以打印i2c->addr和i2c->type，表明从设备i2c_client已经传递进来
   
8.          wm8960 = kzalloc(sizeof(struct wm8960_priv), GFP_KERNEL);
   
9.          if (wm8960 == NULL)
   
10.                    return -ENOMEM;
    
11. 
    
12.          i2c_set_clientdata(i2c, wm8960);//保存i2c相关数据
    
13.          wm8960->control_type = SND_SOC_I2C;
    
14.          wm8960->control_data = i2c;
    
15. 
    
16.          ret = snd_soc_register_codec(&i2c->dev,
    
17.                             &soc_codec_dev_wm8960, &wm8960_dai, 1);
    
18.          if (ret < 0)
    
19.                    kfree(wm8960);
    
20.          return ret;
    
21. }

复制代码

       在探测函数中，通过名为i2c的形参结构体传入i2c设备的地址和名称，可以在函数入口添加如下打印语句：

1. printk("%s:i2c->addr = 0x%x,i2c->name = %s\n",__FUNCTION__,i2c->addr,i2c->name);

复制代码

       编译内核，更新映像后，可以看到如下打印信息：

1. wm8960_i2c_probe:i2c->addr = 0x1a,i2c->name = wm8960

复制代码

       后续整个i2c的读写，都离不开这个结构体。在wm8960.c中，通过snd_soc_read函数读取寄存器值，通过snd_soc_write函数写寄存器值。snd_soc_read函数原型在soc-core.c中：

1. unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg)
   
2. {
   
3.          unsigned int ret;
   
4. 
   
5.          ret = codec->read(codec, reg);
   
6.          dev_dbg(codec->dev, "read %x => %x\n", reg, ret);
   
7.          trace_snd_soc_reg_read(codec, reg, ret);
   
8. 
   
9.          return ret;
   
10. }
    
11. EXPORT_SYMBOL_GPL(snd_soc_read);

复制代码

       它通过codec->read函数，即形参结构体codec中的成员read实现I2C的读。在wm8960.c的probe函数wm8960_probe中，snd_soc_codec_set_cache_io函数实现了对结构体codec的成员赋值，snd_soc_codec_set_cache_io的函数原型在soc-cache.c中：

1. int snd_soc_codec_set_cache_io(struct snd_soc_codec *codec,
   
2.                                    int addr_bits, int data_bits,
   
3.                                    enum snd_soc_control_type control)
   
4. {
   
5.          int i;
   
6. 
   
7.          for (i = 0; i < ARRAY_SIZE(io_types); i++)
   
8.                    if (io_types[i].addr_bits == addr_bits &&
   
9.                        io_types[i].data_bits == data_bits)
   
10.                             break;
    
11.          if (i == ARRAY_SIZE(io_types)) {
    
12.                    printk(KERN_ERR
    
13.                           "No I/O functions for %d bit address %d bit data\n",
    
14.                           addr_bits, data_bits);
    
15.                    return -EINVAL;
    
16.          }
    
17. 
    
18.          codec->write = io_types[i].write;
    
19.          codec->read = io_types[i].read;
    
20.          codec->bulk_write_raw = snd_soc_hw_bulk_write_raw;
    
21. 
    
22.          switch (control) {
    
23.          case SND_SOC_I2C:
    
24. #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
    
25.                    codec->hw_write = (hw_write_t)i2c_master_send;//填充snd_soc_codec结构体，指定i2c写函数
    
26. #endif
    
27.                    if (io_types[i].i2c_read)
    
28.                             codec->hw_read = io_types[i].i2c_read;
    
29. 
    
30.                    codec->control_data = container_of(codec->dev,
    
31.                                                            struct i2c_client,
    
32.                                                            dev);
    
33.                    break;
    
34. 
    
35.          case SND_SOC_SPI:
    
36. #ifdef CONFIG_SPI_MASTER
    
37.                    codec->hw_write = do_spi_write;
    
38. #endif
    
39. 
    
40.                    codec->control_data = container_of(codec->dev,
    
41.                                                            struct spi_device,
    
42.                                                            dev);
    
43.                    break;
    
44.          }
    
45. 
    
46.          return 0;
    
47. }
    
48. EXPORT_SYMBOL_GPL(snd_soc_codec_set_cache_io);

复制代码

       io_types数组定义如下：

1. static struct {
   
2.          int addr_bits;
   
3.          int data_bits;
   
4.          int (*write)(struct snd_soc_codec *codec, unsigned int, unsigned int);
   
5.          unsigned int (*read)(struct snd_soc_codec *, unsigned int);
   
6.          unsigned int (*i2c_read)(struct snd_soc_codec *, unsigned int);
   
7. } io_types[] = {
   
8.          {
   
9.                    .addr_bits = 4, .data_bits = 12,
   
10.                    .write = snd_soc_4_12_write, .read = snd_soc_4_12_read,
    
11.          },
    
12.          {
    
13.                    .addr_bits = 7, .data_bits = 9,
    
14.                    .write = snd_soc_7_9_write, .read = snd_soc_7_9_read,
    
15.          },
    
16.          {
    
17.                    .addr_bits = 8, .data_bits = 8,
    
18.                    .write = snd_soc_8_8_write, .read = snd_soc_8_8_read,
    
19.                    .i2c_read = snd_soc_8_8_read_i2c,
    
20.          },
    
21.          {
    
22.                    .addr_bits = 8, .data_bits = 16,
    
23.                    .write = snd_soc_8_16_write, .read = snd_soc_8_16_read,
    
24.                    .i2c_read = snd_soc_8_16_read_i2c,
    
25.          },
    
26.          {
    
27.                    .addr_bits = 16, .data_bits = 8,
    
28.                    .write = snd_soc_16_8_write, .read = snd_soc_16_8_read,
    
29.                    .i2c_read = snd_soc_16_8_read_i2c,
    
30.          },
    
31.          {
    
32.                    .addr_bits = 16, .data_bits = 16,
    
33.                    .write = snd_soc_16_16_write, .read = snd_soc_16_16_read,
    
34.                    .i2c_read = snd_soc_16_16_read_i2c,
    
35.          },
    
36. };

复制代码

       在引用snd_soc_codec_set_cache_io函数时，传入的形参已经指定addr_bits为7，data_bits为9，故读函数对应snd_soc_7_9_read，写函数对应snd_soc_7_9_write。

       snd_soc_7_9_read函数对应函数原型如下：

1. static unsigned int snd_soc_7_9_read(struct snd_soc_codec *codec,
   
2.                                           unsigned int reg)
   
3. {
   
4.          return do_hw_read (codec, reg);
   
5. }

复制代码

       do_hw_read函数原型如下：

1. static unsigned int do_hw_read(struct snd_soc_codec *codec, unsigned int reg)
   
2. {
   
3.          int ret;
   
4.          unsigned int val;
   
5. 
   
6.          if (reg >= codec->driver->reg_cache_size ||
   
7.              snd_soc_codec_volatile_register(codec, reg) ||
   
8.              codec->cache_bypass) {
   
9.                    if (codec->cache_only)
   
10.                             return -1;
    
11. 
    
12.                    BUG_ON(!codec->hw_read);
    
13.                    return codec->hw_read(codec, reg);
    
14.          }
    
15. 
    
16.          ret = snd_soc_cache_read(codec, reg, &val);
    
17.          if (ret < 0)
    
18.                    return -1;
    
19.          return val;
    
20. }

复制代码

       从这里很容易分析出，do_hw_read函数最终会调用snd_soc_cache_read函数。它的函数原型如下：

1. int snd_soc_cache_read(struct snd_soc_codec *codec,
   
2.                           unsigned int reg, unsigned int *value)
   
3. {
   
4.          int ret;
   
5. 
   
6.          mutex_lock(&codec->cache_rw_mutex);
   
7. 
   
8.          if (value && codec->cache_ops && codec->cache_ops->read) {
   
9.                    ret = codec->cache_ops->read(codec, reg, value);
   
10.                    mutex_unlock(&codec->cache_rw_mutex);
    
11.                    return ret;
    
12.          }
    
13. 
    
14.          mutex_unlock(&codec->cache_rw_mutex);
    
15.          return -ENOSYS;
    
16. }
    
17. EXPORT_SYMBOL_GPL(snd_soc_cache_read);

复制代码

       可见，真正的i2c读函数会调用codec->cache_ops->read()函数。在soc-core.c的probe函数soc_probe中，调用了snd_soc_register_card函数，用于注册声卡，该函数会继续调用snd_soc_instantiate_cards函数初始化声卡，最终初始化声卡的函数为snd_soc_instantiate_card，它引用了snd_soc_init_codec_cache函数初始化解码芯片，snd_soc_cache_init函数被调用，它的函数原型在soc-cache.c中：

1. 
   
2. int snd_soc_cache_init(struct snd_soc_codec *codec)
   
3. {
   
4.          int i;
   
5. 
   
6.          for (i = 0; i < ARRAY_SIZE(cache_types); ++i)
   
7.                    if (cache_types[i].id == codec->compress_type)
   
8.                             break;
   
9. 
   
10.          /* Fall back to flat compression */
    
11.          if (i == ARRAY_SIZE(cache_types)) {
    
12.                    dev_warn(codec->dev, "Could not match compress type: %d\n",
    
13.                              codec->compress_type);
    
14.                    i = 0;
    
15.          }
    
16. 
    
17.          mutex_init(&codec->cache_rw_mutex);
    
18.          codec->cache_ops = &cache_types[i];//赋值cache_ops
    
19. 
    
20.          if (codec->cache_ops->init) {
    
21.                    if (codec->cache_ops->name)
    
22.                             dev_dbg(codec->dev, "Initializing %s cache for %s codec\n",
    
23.                                      codec->cache_ops->name, codec->name);
    
24.                    return codec->cache_ops->init(codec);
    
25.          }
    
26.          return -ENOSYS;
    
27. }

复制代码

       可以看到，加粗部分已经给codec->cache_ops赋值了，再回到前面，真正执行i2c读的函数会调用codec->cache_ops->read()函数，也就是cache_types中的读函数。该数组的程序清单如下：

1. static const struct snd_soc_cache_ops cache_types[] = {
   
2.          /* Flat *must* be the first entry for fallback */
   
3.          {
   
4.                    .id = SND_SOC_FLAT_COMPRESSION,
   
5.                    .name = "flat",
   
6.                    .init = snd_soc_flat_cache_init,
   
7.                    .exit = snd_soc_flat_cache_exit,
   
8.                    .read = snd_soc_flat_cache_read,
   
9.                    .write = snd_soc_flat_cache_write,
   
10.                    .sync = snd_soc_flat_cache_sync
    
11.          },
    
12. #ifdef CONFIG_SND_SOC_CACHE_LZO
    
13.          {
    
14.                    .id = SND_SOC_LZO_COMPRESSION,
    
15.                    .name = "LZO",
    
16.                    .init = snd_soc_lzo_cache_init,
    
17.                    .exit = snd_soc_lzo_cache_exit,
    
18.                    .read = snd_soc_lzo_cache_read,
    
19.                    .write = snd_soc_lzo_cache_write,
    
20.                    .sync = snd_soc_lzo_cache_sync
    
21.          },
    
22. #endif
    
23.          {
    
24.                    .id = SND_SOC_RBTREE_COMPRESSION,
    
25.                    .name = "rbtree",
    
26.                    .init = snd_soc_rbtree_cache_init,
    
27.                    .exit = snd_soc_rbtree_cache_exit,
    
28.                    .read = snd_soc_rbtree_cache_read,
    
29.                    .write = snd_soc_rbtree_cache_write,
    
30.                    .sync = snd_soc_rbtree_cache_sync
    
31.          }
    
32. };

复制代码

       结合程序上下文，可以分析出codec->compress_type为SND_SOC_FLAT_COMPRESSION，即对应的读函数为snd_soc_flat_cache_read。其函数原型如下：

1. static int snd_soc_flat_cache_read(struct snd_soc_codec *codec,
   
2.                                         unsigned int reg, unsigned int *value)
   
3. {
   
4.          *value = snd_soc_get_cache_val(codec->reg_cache, reg,
   
5.                                             codec->driver->reg_word_size);
   
6.          return 0;
   
7. }

复制代码

       snd_soc_get_cache_val的函数原型如下：

1. static unsigned int snd_soc_get_cache_val(const void *base, unsigned int idx,
   
2.                    unsigned int word_size)
   
3. {
   
4.          if (!base)
   
5.                    return -1;
   
6. 
   
7.          switch (word_size) {
   
8.          case 1: {
   
9.                    const u8 *cache = base;
   
10.                    return cache[idx];
    
11.          }
    
12.          case 2: {
    
13.                    const u16 *cache = base;
    
14.                    return cache[idx];
    
15.          }
    
16.          default:
    
17.                    BUG();
    
18.          }
    
19.          /* unreachable */
    
20.          return -1;
    
21. }

复制代码

       再来分析snd_soc_get_cache_val函数的几个重要的形参。snd_soc_flat_cache_init函数用于将codec->reg_def_copy赋给codec->reg_cache：

1. static int snd_soc_flat_cache_init(struct snd_soc_codec *codec)
   
2. {
   
3.          const struct snd_soc_codec_driver *codec_drv;
   
4. 
   
5.          codec_drv = codec->driver;
   
6. 
   
7.          if (codec->reg_def_copy)
   
8.                    codec->reg_cache = kmemdup(codec->reg_def_copy,
   
9.                                                   codec->reg_size, GFP_KERNEL);
   
10.          else
    
11.                    codec->reg_cache = kzalloc(codec->reg_size, GFP_KERNEL);
    
12.          if (!codec->reg_cache)
    
13.                    return -ENOMEM;
    
14. 
    
15.          return 0;
    
16. }

复制代码

       同时，在snd_soc_register_codec函数中，如下程序用于将codec_drv->reg_cache_default给codec->reg_def_copy赋值：

1. 
   
2. if (codec_drv->reg_cache_default) {
   
3.                             codec->reg_def_copy = kmemdup(codec_drv->reg_cache_default,
   
4.                                                               reg_size, GFP_KERNEL);
   
5.                             if (!codec->reg_def_copy) {
   
6.                                      ret = -ENOMEM;
   
7.                                      goto fail;
   
8.                             }
   
9.                    }

复制代码

       结合wm8960_i2c_probe中的如下语句：

1. ret = snd_soc_register_codec(&i2c->dev,
   
2.                             &soc_codec_dev_wm8960, &wm8960_dai, 1);

复制代码

       可以分析出，codec_drv->reg_cache_default已被赋值为wm8960_reg，而wm8960_reg就是wm8960.c最前面的寄存器表：

1. static const u16 wm8960_reg[WM8960_CACHEREGNUM] = {
   
2.          0x0097, 0x0097, 0x0000, 0x0000,
   
3.          0x0000, 0x0008, 0x0000, 0x000a,
   
4.          0x01c0, 0x0000, 0x00ff, 0x00ff,
   
5.          0x0000, 0x0000, 0x0000, 0x0000,
   
6.          0x0000, 0x007b, 0x0100, 0x0032,
   
7.          0x0000, 0x00c3, 0x00c3, 0x01c0,
   
8.          0x0000, 0x0000, 0x0000, 0x0000,
   
9.          0x0000, 0x0000, 0x0000, 0x0000,
   
10.          0x0100, 0x0100, 0x0050, 0x0050,
    
11.          0x0050, 0x0050, 0x0000, 0x0000,
    
12.          0x0000, 0x0000, 0x0040, 0x0000,
    
13.          0x0000, 0x0050, 0x0050, 0x0000,
    
14.          0x0002, 0x0037, 0x004d, 0x0080,
    
15.          0x0008, 0x0031, 0x0026, 0x00e9,
    
16. };

复制代码

       snd_soc_register_codec函数的第二个形参reg对应着该数组的第reg个数，第三个形参value返回该数组的第reg个数的值。当我们需要读取WM8960的寄存器值时，只需要调用snd_soc_read函数，传入形参codec和寄存器在该表中存在的位号即可。

       可见，WM8960的I2C读，并不是直接通过I2C协议从硬件上读取寄存器的值，而是驱动中预先将寄存器的初始值填入一个名为wm8960_reg的寄存器表，当读寄存器值时，直接从该表格里面读取数值，即对应了相应寄存器的值。下面我们再来分析I2C的写。

       驱动通过snd_soc_write函数实现I2C的写，该函数原型在soc-core.c中：

1. unsigned int snd_soc_write(struct snd_soc_codec *codec,
   
2.                                unsigned int reg, unsigned int val)
   
3. {
   
4.          dev_dbg(codec->dev, "write %x = %x\n", reg, val);
   
5.          trace_snd_soc_reg_write(codec, reg, val);
   
6.          return codec->write(codec, reg, val);
   
7. }
   
8. EXPORT_SYMBOL_GPL(snd_soc_write);

复制代码

       它通过调用codec->write函数实现。同样，在snd_soc_codec_set_cache_io函数中，将io_types.write赋给了codec->write，同时有如下语句：

1. codec->hw_write = (hw_write_t)i2c_master_send;

复制代码

       找到io_types.write函数，我们可以很轻松的分析出，codec->write函数对应snd_soc_7_9_write，其函数原型如下：

1. static int snd_soc_7_9_write(struct snd_soc_codec *codec, unsigned int reg,
   
2.                                  unsigned int value)
   
3. {
   
4.          u8 data[2];
   
5. 
   
6.          data[0] = (reg << 1) | ((value >> 8) & 0x0001);
   
7.          data[1] = value & 0x00ff;
   
8. 
   
9.          return do_hw_write(codec, reg, value, data, 2);
   
10. }

复制代码

       do_hw_write函数原型如下：

1. static int do_hw_write(struct snd_soc_codec *codec, unsigned int reg,
   
2.                           unsigned int value, const void *data, int len)
   
3. {
   
4.          int ret;
   
5. 
   
6.          if (!snd_soc_codec_volatile_register(codec, reg) &&
   
7.              reg < codec->driver->reg_cache_size &&
   
8.              !codec->cache_bypass) {
   
9.                    ret = snd_soc_cache_write(codec, reg, value);//将要写的值填入cache表
   
10.                    if (ret < 0)
    
11.                             return -1;
    
12.          }
    
13. 
    
14.          if (codec->cache_only) {
    
15.                    codec->cache_sync = 1;
    
16.                    return 0;
    
17.          }
    
18. 
    
19.          ret = codec->hw_write(codec->control_data, data, len);
    
20.          if (ret == len)
    
21.                    return 0;
    
22.          if (ret < 0)
    
23.                    return ret;
    
24.          else
    
25.                    return -EIO;
    
26. }

复制代码

       程序首先调用snd_soc_cache_write函数，将要写入的值填入寄存器的cache表，确保下次调用读函数时其寄存器的正确性，再调用codec->hw_write函数，写入寄存器。前面已经提到，codec->hw_write对应i2c_master_send，它就是标准的i2c写函数了，是真实的硬件I2C写操作。

       我们再来分析snd_soc_cache_write函数是如何填入寄存器的cache表的。它的函数原型如下：

1. int snd_soc_cache_write(struct snd_soc_codec *codec,
   
2.                             unsigned int reg, unsigned int value)
   
3. {
   
4.          int ret;
   
5. 
   
6.          mutex_lock(&codec->cache_rw_mutex);
   
7. 
   
8.          if (codec->cache_ops && codec->cache_ops->write) {
   
9.                    ret = codec->cache_ops->write(codec, reg, value);
   
10.                    mutex_unlock(&codec->cache_rw_mutex);
    
11.                    return ret;
    
12.          }
    
13. 
    
14.          mutex_unlock(&codec->cache_rw_mutex);
    
15.          return -ENOSYS;
    
16. }
    
17. EXPORT_SYMBOL_GPL(snd_soc_cache_write);

复制代码

       程序中写函数的关键在codec->cache_ops->write函数，在snd_soc_cache_init函数中，有如下语句：

1. codec->cache_ops = &cache_types[i];

复制代码

       即codec->cache_ops->write对应cache_types->write，即snd_soc_flat_cache_write函数。其函数原型如下：

1. static int snd_soc_flat_cache_write(struct snd_soc_codec *codec,
   
2.                                          unsigned int reg, unsigned int value)
   
3. {
   
4.          snd_soc_set_cache_val(codec->reg_cache, reg, value,
   
5.                                   codec->driver->reg_word_size);
   
6.          return 0;
   
7. }

复制代码

snd_soc_set_cache_val函数原型如下：

1. 
   
2. static bool snd_soc_set_cache_val(void *base, unsigned int idx,
   
3.                                        unsigned int val, unsigned int word_size)
   
4. {
   
5.          switch (word_size) {
   
6.          case 1: {
   
7.                    u8 *cache = base;
   
8.                    if (cache[idx] == val)
   
9.                             return true;
   
10.                    cache[idx] = val;
    
11.                    break;
    
12.          }
    
13.          case 2: {
    
14.                    u16 *cache = base;
    
15.                    if (cache[idx] == val)
    
16.                             return true;
    
17.                    cache[idx] = val;
    
18.                    break;
    
19.          }
    
20.          default:
    
21.                    BUG();
    
22.          }
    
23.          return false;
    
24. }

复制代码

       可见，snd_soc_set_cache_val函数的本质就是将val值填充到cache[idx]对应的地址，即wm8960.c中最前面定义的数组wm8960_reg中。

       整个音频驱动的I2C工作机制到此分析完毕，驱动架构写得过于复杂，其目的在于兼容各种各样的芯片，方便音频驱动的移植。

mzucore

非常感谢您的分享~~~~~~~~