8M sensor mt9e013 驱动

1.  最上层的数据结构 v4l2_i2c_data，V4L2设备mt9e013的i2c数据表示：

   1. static struct v4l2_i2c_driver_data v4l2_i2c_data = {
   2.     .name = MT9E013_NAME,
   3.     .probe = mt9e013_probe,
   4.     .remove = mt9e013_remove,
   5.     .id_table = mt9e013_id,
   6. };

v4l2_i2c_driver_data 原型定义：

   1. struct v4l2_i2c_driver_data {
   2.     const char * const name;
   3.     int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
   4.     int (*probe)(struct i2c_client *client, const struct i2c_device_id *id);
   5.     int (*remove)(struct i2c_client *client);
   6.     int (*suspend)(struct i2c_client *client, pm_message_t state);
   7.     int (*resume)(struct i2c_client *client);
   8.     const struct i2c_device_id *id_table;
   9. };

2. mt9e013_probe()

   1. static int mt9e013_probe(struct i2c_client *client,
   2.              const struct i2c_device_id *id)
   3. {
   4.     struct mt9e013_device *dev;                 //mt9e013_device 是最上层的模型，里面包含了很多数据结构，后面介绍
   5.     int ret;
   6.     _dev_info(&client->dev, "mt9e013 probe\n");
   7.

   8.     /* allocate sensor device & init sub device */
   9.     dev = kzalloc(sizeof(*dev), GFP_KERNEL);    //分配dev内存，并置0
  10.     if (!dev) {
  11.         v4l2_err(client, "%s: out of memory\n", __func__);
  12.         return -ENOMEM;
  13.     }
  14.

  15.     dev->fmt_idx = 0;
  16.     v4l2_i2c_subdev_init(&(dev->sd), client, &mt9e013_ops);  //i2c v4l2子设备初始化 添加mt9e013_ops。
  17.

  18.     dev->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;    //this subdev needs a device node.
  19.     dev->pad.flags = MEDIA_PAD_FLAG_OUTPUT;
  20.     dev->sd.entity.ops = &mt9e013_entity_ops;       //entity operation
  21.     dev->format.code = V4L2_MBUS_FMT_SGRBG10_1X10;
  22.

  23.     /* REVISIT: Do we need media controller? */
  24.     ret = media_entity_init(&dev->sd.entity, 1, &dev->pad, 0);  //media entity init
  25.     if (ret) {
  26.         mt9e013_remove(client);
  27.         return ret;
  28.     }
  29.

  30.     return 0;
  31. }

3. mt9e013_device 相关数据结构:

a. struct v4l2_subdev

1. /* Each instance of a subdev driver should create this struct, either
   
2.    stand-alone or embedded in a larger struct.
   
3.  */
   
4. struct v4l2_subdev {
   
5. #if defined(CONFIG_MEDIA_CONTROLLER)
   
6.     struct media_entity entity;
   
7. #endif
   
8.     struct list_head list;
   
9.     struct module*owner;
   
10.     u32 flags;
    
11.     struct v4l2_device *v4l2_dev;
    
12.     const struct v4l2_subdev_ops*ops;
    
13.     /* The control handler of this subdev. May be NULL. */
    
14.     struct v4l2_ctrl_handler *ctrl_handler;
    
15.     /* name must be unique */
    
16.     char name[V4L2_SUBDEV_NAME_SIZE];
    
17.     /* can be used to group similar subdevs, value is driver-specific */
    
18.     u32 grp_id;
    
19.     /* pointer to private data */
    
20.     void *dev_priv;
    
21.     void *host_priv;
    
22.     /* subdev device node */
    
23.     struct video_device devnode;
    
24.     unsigned int initialized;
    
25.     /* number of events to be allocated on open */
    
26.     unsigned int nevents;
    
27. };

b. struct media_pad

1. struct media_pad{
   
2.     struct media_entity *entity;    /* Entity this pad belongs to */
   
3.     u16 index;            /* Pad index in the entity pads array */
   
4.     unsigned long flags;        /* Pad flags (MEDIA_PAD_FLAG_*) */
   
5. };

struct media_entity

1. struct media_entity{
   
2.     struct list_head list;
   
3.     struct media_device *parent;    /* Media device this entity belongs to*/
   
4.     u32 id;                /* Entity ID, unique in the parent media
   
5.                      * device context */
   
6.     const char*name;        /* Entity name */
   
7.     u32 type;            /* Entity type (MEDIA_ENTITY_TYPE_*) */
   
8.     u32 revision;            /* Entity revision, driver specific */
   
9.     unsigned long flags;        /* Entity flags (MEDIA_ENTITY_FLAG_*) */
   
10.     u32 group_id;            /* Entity group ID */
    
11. 
    
12.     u16 num_pads;            /* Number of input and output pads */
    
13.     u16 num_links;            /* Number of existing links, both
    
14.                      * enabled and disabled */
    
15.     u16 num_backlinks;        /* Number of backlinks */
    
16.     u16 max_links;            /* Maximum number of links */
    
17. 
    
18.     struct media_pad *pads;        /* Pads array (num_pads elements) */
    
19.     struct media_link *links;    /* Links array (max_links elements)*/
    
20. 
    
21.     const struct media_entity_operations *ops;    /* Entity operations */ //这个比较重要
    
22. 
    
23.     int stream_count;        /* Stream count for the entity. */
    
24.     int use_count;            /* Use count for the entity. */
    
25. 
    
26.     struct media_pipeline *pipe;    /* Pipeline this entity belongs to. */
    
27. 
    
28.     union {
    
29.         /* Node specifications */
    
30.         struct {
    
31.             u32 major;
    
32.             u32 minor;
    
33.         } v4l;
    
34.         struct {
    
35.             u32 major;
    
36.             u32 minor;
    
37.         } fb;
    
38.         struct {
    
39.             u32 card;
    
40.             u32 device;
    
41.             u32 subdevice;
    
42.         } alsa;
    
43.         int dvb;
    
44. 
    
45.         /* Sub-device specifications */
    
46.         /* Nothing needed yet */
    
47.     };
    
48. };

c. struct v4l2_mbus_framfmt

1. /**
   
2.  * struct v4l2_mbus_framefmt - frame format on the media bus
   
3.  * @width:    frame width
   
4.  * @height:    frame height
   
5.  * @code:    data format code (from enum v4l2_mbus_pixelcode)
   
6.  * @field:    used interlacing type (from enum v4l2_field)
   
7.  * @colorspace:    colorspace of the data (from enum v4l2_colorspace)
   
8.  */
   
9. struct v4l2_mbus_framefmt {
   
10.     __u32            width;
    
11.     __u32            height;
    
12.     __u32            code;
    
13.     __u32            field;
    
14.     __u32            colorspace;
    
15. };

d. struct camera_sensor_platform_data

1. struct camera_sensor_platform_data{
   
2.     int (*gpio_ctrl)(struct v4l2_subdev*subdev, int flag);
   
3.     int (*flisclk_ctrl)(struct v4l2_subdev*subdev, int flag);
   
4.     int (*power_ctrl)(struct v4l2_subdev*subdev, int flag);
   
5.     int (*csi_cfg)(struct v4l2_subdev*subdev, int flag);
   
6. };

4. v4l2_i2c_subdev_init(),这里执行了2个动作，一个是设置V4L2子设备数据，一个是设置I2C client数据

1. /* I2C Helper functions */
   
2. 
   
3. 
   
4. void v4l2_i2c_subdev_init(struct v4l2_subdev*sd, struct i2c_client *client,
   
5.         const struct v4l2_subdev_ops *ops)
   
6. {
   
7.     v4l2_subdev_init(sd, ops);
   
8.     sd->flags|= V4L2_SUBDEV_FL_IS_I2C;
   
9.     /* the owner is the same as the i2c_client's driver owner */
   
10.     sd->owner= client->driver->driver.owner;
    
11.     /* i2c_client and v4l2_subdev point to one another */
    
12.     v4l2_set_subdevdata(sd, client);     //设置V4L2 子设备数据
    
13.     i2c_set_clientdata(client, sd);      //设置I2C client 数据
    
14.     /* initialize name */
    
15.     snprintf(sd->name,sizeof(sd->name),"%s %d-%04x",
    
16.         client->driver->driver.name, i2c_adapter_id(client->adapter),
    
17.         client->addr);
    
18. }
    
19. EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init);

5. mt9e013_ops

1. static const struct v4l2_subdev_ops mt9e013_ops= {   //v4l2_subdev operation， 表示vl42 子设备所具有的能力。
   
2.     .core =&mt9e013_core_ops,
   
3.     .video =&mt9e013_video_ops,
   
4.     .pad =&mt9e013_pad_ops,
   
5. };

a. mt9e013_core_ops ： V4L2 IOCTL 传下来的具体执行函数

1. static const struct v4l2_subdev_core_ops mt9e013_core_ops= {
   
2.     .g_chip_ident = mt9e013_g_chip_ident,  //获得Id
   
3.     .s_config = mt9e013_s_config,          //配置
   
4.     .queryctrl = mt9e013_queryctrl,        //query control能力
   
5.     .g_ctrl = mt9e013_g_ctrl,             //get control
   
6.     .s_ctrl = mt9e013_s_ctrl,             //set control
   
7.     .s_power = mt9e013_s_power,           //set power
   
8.     .ioctl = mt9e013_ioctl,               //ioctl
   
9.     .init = mt9e013_init,
   
10. };

b. mt9e013_video_ops ： v4l2 接口传下来的视频相关的操作

1. static const struct v4l2_subdev_video_ops mt9e013_video_ops= {
   
2.     .s_stream = mt9e013_s_stream,                      //set stream
   
3.     .enum_framesizes = mt9e013_enum_framesizes,         //enum framesizes
   
4.     .enum_frameintervals = mt9e013_enum_frameintervals,   
   
5.     .enum_mbus_fmt = mt9e013_enum_mbus_fmt,
   
6.     .try_mbus_fmt = mt9e013_try_mbus_fmt,        // try format
   
7.     .g_mbus_fmt = mt9e013_g_mbus_fmt,            // get format
   
8.     .s_mbus_fmt = mt9e013_s_mbus_fmt,            //set format
   
9. };

c. mt9e013_pad_ops :  media 帧设置方面的操作

1. /* REVISIT: Do we need pad operations? */
   
2. static conststruct v4l2_subdev_pad_ops mt9e013_pad_ops = {
   
3.     .enum_mbus_code = mt9e013_enum_mbus_code,
   
4.     .enum_frame_size = mt9e013_enum_frame_size,      // frame size
   
5.     .get_fmt = mt9e013_get_pad_format,               // get format
   
6.     .set_fmt = mt9e013_set_pad_format,               // set format
   
7. };

6. mt9e013_entity_ops

1. static const struct media_entity_operations mt9e013_entity_ops= {
   
2.     .set_power = v4l2_subdev_set_power,   //设置v4l2子设备电源
   
3. };

media_entity_operations 原型定义：

1. struct media_entity_operations{
   
2.     int (*link_setup)(struct media_entity*entity,
   
3.              const struct media_pad *local,
   
4.              const struct media_pad *remote, u32 flags);
   
5.     int (*set_power)(struct media_entity*entity, int power);
   
6. };

7.  media_entity_init

1. /**
   
2.  * media_entity_init - Initialize a media entity
   
3.  *
   
4.  * @num_pads: Total number of input and output pads.
   
5.  * @extra_links: Initial estimate of the number of extra links.
   
6.  * @pads: Array of 'num_pads' pads.
   
7.  *
   
8.  * The total number of pads is an intrinsic property of entities known by the
   
9.  * entity driver, while the total number of links depends on hardware design
   
10.  * and is an extrinsic property unknown to the entity driver. However, in most
    
11.  * use cases the entity driver can guess the number of links which can safely
    
12.  * be assumed to be equal to or larger than the number of pads.
    
13.  *
    
14.  * For those reasons the links array can be preallocated based on the entity
    
15.  * driver guess and will be reallocated later if extra links need to be
    
16.  * created.
    
17.  *
    
18.  * This function allocates a links array with enough space to hold at least
    
19.  * 'num_pads' + 'extra_links' elements. The media_entity::max_links field will
    
20.  * be set to the number of allocated elements.
    
21.  *
    
22.  * The pads array is managed by the entity driver and passed to
    
23.  * media_entity_init() where its pointer will be stored in the entity structure.
    
24.  */
    
25. int
    
26. media_entity_init(struct media_entity*entity, u16 num_pads,
    
27.          struct media_pad *pads, u16 extra_links)
    
28. {
    
29.     struct media_link *links;
    
30.     unsigned int max_links = num_pads + extra_links;
    
31.     unsigned int i;
    
32. 
    
33.     links = kzalloc(max_links* sizeof(links[0]), GFP_KERNEL);
    
34.     if (links== NULL)
    
35.         return -ENOMEM;
    
36. 
    
37.     entity->group_id= 0;
    
38.     entity->max_links= max_links;
    
39.     entity->num_links= 0;
    
40.     entity->num_backlinks= 0;
    
41.     entity->num_pads= num_pads;
    
42.     entity->pads= pads;
    
43.     entity->links= links;
    
44. 
    
45.     for (i= 0; i < num_pads; i++){
    
46.         pads[i].entity= entity;
    
47.         pads[i].index= i;
    
48.     }
    
49. 
    
50.     return 0;
    
51. }
    
52. EXPORT_SYMBOL_GPL(media_entity_init);

struct media_link

1. struct media_link{
   
2.     struct media_pad *source;    /* Source pad */
   
3.     struct media_pad *sink;        /* Sink pad */
   
4.     struct media_link *reverse;    /* Link in the reverse direction */
   
5.     unsigned long flags;        /* Link flags (MEDIA_LINK_FLAG_*) */
   
6. };

8. mt9e013_remove

1. static int mt9e013_remove(struct i2c_client*client)
   
2. {
   
3.     struct v4l2_subdev *sd = i2c_get_clientdata(client);  //先根据i2c client, 来获得v4l2 子设备。
   
4.     struct mt9e013_device *dev = to_mt9e013_sensor(sd);   //通过container_of(v4l2_subdev),来获得包含它的 最上层mt9e013设备。
   
5. 
   
6.     dev->platform_data->csi_cfg(sd, 0);
   
7.     v4l2_device_unregister_subdev(sd); //注销v4l2子设备。
   
8.     kfree(dev);
   
9. 
   
10.     return 0;
    
11. }

struct mt9e013_device

   1. /* mt9e013 device structure */
   2. struct mt9e013_device {
   3.     struct v4l2_subdev sd;         //表示V4L2 子设备属性
   4.     struct media_pad pad;
   5.     struct v4l2_mbus_framefmt format;
   6.

   7.     struct camera_sensor_platform_data *platform_data;
   8.     int fmt_idx;
   9.     int    status;
  10.     u8 res;
  11.     u8 type;
  12.     u16    sensor_id;
  13.     u8    sensor_revision;
  14.

  15.     unsigned int intg_factor;
  16. };