V4L2源代码之旅一：struct v4l2_device

struct v4l2_device {
    /* dev->driver_data points to this struct.
       Note: dev might be NULL if there is no parent device
       as is the case with e.g. ISA devices. */
    struct device *dev;
#if defined(CONFIG_MEDIA_CONTROLLER)
    struct media_device *mdev;
#endif
    /* used to keep track of the registered subdevs */
    struct list_head subdevs;    // 跟踪注册的所有subdev
    /* lock this struct; can be used by the driver as well if this
       struct is embedded into a larger struct. */
    spinlock_t lock;
    /* unique device name, by default the driver name + bus ID */
    char name[V4L2_DEVICE_NAME_SIZE];
    /* notify callback called by some sub-devices. */
    void (*notify)(struct v4l2_subdev *sd,
            unsigned int notification, void *arg);
    /* The control handler. May be NULL. */
    struct v4l2_ctrl_handler *ctrl_handler;
    /* Device‘s priority state */
    struct v4l2_prio_state prio;
    /* BKL replacement mutex. Temporary solution only. */
    struct mutex ioctl_lock;
    /* Keep track of the references to this struct. */
    struct kref ref;
    /* Release function that is called when the ref count goes to 0. */
    void (*release)(struct v4l2_device *v4l2_dev);
};

/* kernel/drivers/media/video/v4l2-device.c */
int v4l2_device_register(struct device *dev, struct v4l2_device *v4l2_dev)
{
    if (v4l2_dev == NULL)
        return -EINVAL;

    INIT_LIST_HEAD(&v4l2_dev->subdevs);  // 初始化一个将要挂在v4l2_device上的子设备列表
    spin_lock_init(&v4l2_dev->lock);     // 初始化一个spin lock
    mutex_init(&v4l2_dev->ioctl_lock);   // 初始化一个mutex，看来会在ioctrl上使用的mutex
    v4l2_prio_init(&v4l2_dev->prio);     // 优先级
    kref_init(&v4l2_dev->ref);           // 将v4l2_dev的父设备指定为struct device *dev
    v4l2_dev->dev = dev;                 // 父设备
    if (dev == NULL) {                   // 如果dev为空，v4l2->dev->name必须设置
        /* If dev == NULL, then name must be filled in by the caller */
        WARN_ON(!v4l2_dev->name[0]);
        return 0;
    }

    /* Set name to driver name + device name if it is empty. */
    if (!v4l2_dev->name[0])
        snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "%s %s",  // 如果v4l2_dev->name为空，那么由dev_name(dev)来设置 driver name + device name
            dev->driver->name, dev_name(dev));
    if (!dev_get_drvdata(dev))
        dev_set_drvdata(dev, v4l2_dev);   // 将dev和v4l2_dev关联：dev->p->driver_data = v4l2_dev
    return 0;
}
EXPORT_SYMBOL_GPL(v4l2_device_register);

int dev_set_drvdata(struct device *dev, void *data)
{
    int error;

    if (!dev->p) {
        error = device_private_init(dev);
        if (error)
            return error;
    }
    dev->p->driver_data = data;
    return 0;
}
EXPORT_SYMBOL(dev_set_drvdata);

/* kernel/drivers/media/video/v4l2-device.c */
void v4l2_device_disconnect(struct v4l2_device *v4l2_dev)
{
    if (v4l2_dev->dev == NULL)
        return;

    if (dev_get_drvdata(v4l2_dev->dev) == v4l2_dev)  // 如果v4l2->dev->p->driver_data 指向v4l2_dev
        dev_set_drvdata(v4l2_dev->dev, NULL);        // 设置v4l2->dev->p->driver_data为NULL
    v4l2_dev->dev = NULL;                            // 设置v4l2->dev为NULL
}
EXPORT_SYMBOL_GPL(v4l2_device_disconnect);
/*
 * 如果是一个热插拔设备（如USB设备），当断开连接的时候父设备变为无效。v4l2_device->dev将设置为空，并且标记父设备消失。这就通过v4l2_device_disconnect实现。
 * 从代码可以看出，这个方法并不注销subdev，所以需要注销subdev需要调用v4l2_device_unregister函数。如果你的设备不支持热插拔无需调用v4l2_device_disconnect.
*/

void v4l2_device_unregister(struct v4l2_device *v4l2_dev)
{
    struct v4l2_subdev *sd, *next;

    if (v4l2_dev == NULL)
        return;
    v4l2_device_disconnect(v4l2_dev);

    /* Unregister subdevs */
    list_for_each_entry_safe(sd, next, &v4l2_dev->subdevs, list) {  // 遍历v4l2_dev->subdevs这个链表，这个链表是组织所有的sub-dev
        v4l2_device_unregister_subdev(sd);
#if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
        if (sd->flags & V4L2_SUBDEV_FL_IS_I2C) {
            struct i2c_client *client = v4l2_get_subdevdata(sd);

            /* We need to unregister the i2c client explicitly.
               We cannot rely on i2c_del_adapter to always
               unregister clients for us, since if the i2c bus
               is a platform bus, then it is never deleted. */
            if (client)
                i2c_unregister_device(client);
            continue;
        }
#endif
#if defined(CONFIG_SPI)
        if (sd->flags & V4L2_SUBDEV_FL_IS_SPI) {
            struct spi_device *spi = v4l2_get_subdevdata(sd);

            if (spi)
                spi_unregister_device(spi);
            continue;
        }
#endif
    }
}
EXPORT_SYMBOL_GPL(v4l2_device_unregister);

void v4l2_device_unregister_subdev(struct v4l2_subdev *sd)
{
    struct v4l2_device *v4l2_dev;

    /* return if it isn‘t registered */
    if (sd == NULL || sd->v4l2_dev == NULL)
        return;

    v4l2_dev = sd->v4l2_dev;

    spin_lock(&v4l2_dev->lock);
    list_del(&sd->list);           // 将sd从v4l2_dev->subdev链表中删除
    spin_unlock(&v4l2_dev->lock);

    if (sd->internal_ops && sd->internal_ops->unregistered)
        sd->internal_ops->unregistered(sd);  // 回掉 sd->internal_ops->unregistered
    sd->v4l2_dev = NULL;

#if defined(CONFIG_MEDIA_CONTROLLER)
    if (v4l2_dev->mdev)
        media_device_unregister_entity(&sd->entity);
#endif
    video_unregister_device(&sd->devnode);   // 这个方法很关键，解除v4l2_subdev和video_device之间的关系
    module_put(sd->owner);
}
EXPORT_SYMBOL_GPL(v4l2_device_unregister_subdev);

/* kernel/drivers/media/video/v4l2-dev.c */
/**
 *    video_unregister_device - unregister a video4linux device
 *    @vdev: the device to unregister
 *
 *    This unregisters the passed device. Future open calls will
 *    be met with errors.
 */
void video_unregister_device(struct video_device *vdev)
{
    /* Check if vdev was ever registered at all */
    if (!vdev || !video_is_registered(vdev))
        return;

    mutex_lock(&videodev_lock);
    /* This must be in a critical section to prevent a race with v4l2_open.
     * Once this bit has been cleared video_get may never be called again.
     */
    clear_bit(V4L2_FL_REGISTERED, &vdev->flags);
    mutex_unlock(&videodev_lock);
    device_unregister(&vdev->dev);
}
EXPORT_SYMBOL(video_unregister_device);

/* 用如下代码迭代所有的注册设备 */
static int callback(struct device *dev, void *p)
{
    struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);

    /* test if this device was inited */
    if (v4l2_dev == NULL)
        return 0;
    ...
    return 0;
}

int iterate(void *p)
{
    struct device_driver *drv;
    int err;

    /* Find driver ‘ivtv‘ on the PCI bus.
       pci_bus_type is a global. For USB busses use usb_bus_type. */
    drv = driver_find("ivtv", &pci_bus_type);
    /* iterate over all ivtv device instances */
    err = driver_for_each_device(drv, NULL, p, callback);
    put_driver(drv);
    return err;
}

    static atomic_t drv_instance = ATOMIC_INIT(0);

    static int __devinit drv_probe(struct pci_dev *pdev,
                    const struct pci_device_id *pci_id)
    {
        ...
        state->instance = atomic_inc_return(&drv_instance) - 1;
    }

    #define atomic_inc_return(v) (atomic_add_return(1, v))       /*将v原子自加1*/

void v4l2_device_get(struct v4l2_device *v4l2_dev); // 增加引用计数

int v4l2_device_put(struct v4l2_device *v4l2_dev);  // 较小引用计数

/* kernel/include/media/v4l2-device.h */
static inline void v4l2_device_get(struct v4l2_device *v4l2_dev)
{
    kref_get(&v4l2_dev->ref);
}

/* kernel/drivers/media/video/v4l2-device.c */
int v4l2_device_put(struct v4l2_device *v4l2_dev)
{
    return kref_put(&v4l2_dev->ref, v4l2_device_release);  // 当引用计数为0时，调用v4l2_device_release函数
}
EXPORT_SYMBOL_GPL(v4l2_device_put);

static void v4l2_device_release(struct kref *ref)
{
    struct v4l2_device *v4l2_dev =
        container_of(ref, struct v4l2_device, ref);

    if (v4l2_dev->release)
        v4l2_dev->release(v4l2_dev);
}