drivers/media/mc/mc-dev-allocator.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * media-dev-allocator.c - Media Controller Device Allocator API
   4  *
   5  * Copyright (c) 2019 Shuah Khan <shuah@kernel.org>
   6  *
   7  * Credits: Suggested by Laurent Pinchart <laurent.pinchart@ideasonboard.com>
   8  */
   9
  10 /*
  11  * This file adds a global refcounted Media Controller Device Instance API.
  12  * A system wide global media device list is managed and each media device
  13  * includes a kref count. The last put on the media device releases the media
  14  * device instance.
  15  *
  16  */
  17
  18 #include <linux/kref.h>
  19 #include <linux/module.h>
  20 #include <linux/slab.h>
  21 #include <linux/usb.h>
  22
  23 #include <media/media-device.h>
  24 #include <media/media-dev-allocator.h>
  25
  26 static LIST_HEAD(media_device_list);
  27 static DEFINE_MUTEX(media_device_lock);
  28
  29 struct media_device_instance {
  30         struct media_device mdev;
  31         struct module *owner;
  32         struct list_head list;
  33         struct kref refcount;
  34 };
  35
  36 static inline struct media_device_instance *
  37 to_media_device_instance(struct media_device *mdev)
  38 {
  39         return container_of(mdev, struct media_device_instance, mdev);
  40 }
  41
  42 static void media_device_instance_release(struct kref *kref)
  43 {
  44         struct media_device_instance *mdi =
  45                 container_of(kref, struct media_device_instance, refcount);
  46
  47         dev_dbg(mdi->mdev.dev, "%s: releasing Media Device\n", __func__);
  48
  49         mutex_lock(&media_device_lock);
  50
  51         media_device_unregister(&mdi->mdev);
  52         media_device_cleanup(&mdi->mdev);
  53
  54         list_del(&mdi->list);
  55         mutex_unlock(&media_device_lock);
  56
  57         kfree(mdi);
  58 }
  59
  60 /* Callers should hold media_device_lock when calling this function */
  61 static struct media_device *__media_device_get(struct device *dev,
  62                                                 const char *module_name,
  63                                                 struct module *owner)
  64 {
  65         struct media_device_instance *mdi;
  66
  67         list_for_each_entry(mdi, &media_device_list, list) {
  68                 if (mdi->mdev.dev != dev)
  69                         continue;
  70
  71                 kref_get(&mdi->refcount);
  72
  73                 /* get module reference for the media_device owner */
  74                 if (owner != mdi->owner && !try_module_get(mdi->owner))
  75                         dev_err(dev,
  76                                 "%s: module %s get owner reference error\n",
  77                                         __func__, module_name);
  78                 else
  79                         dev_dbg(dev, "%s: module %s got owner reference\n",
  80                                         __func__, module_name);
  81                 return &mdi->mdev;
  82         }
  83
  84         mdi = kzalloc(sizeof(*mdi), GFP_KERNEL);
  85         if (!mdi)
  86                 return NULL;
  87
  88         mdi->owner = owner;
  89         kref_init(&mdi->refcount);
  90         list_add_tail(&mdi->list, &media_device_list);
  91
  92         dev_dbg(dev, "%s: Allocated media device for owner %s\n",
  93                         __func__, module_name);
  94         return &mdi->mdev;
  95 }
  96
  97 struct media_device *media_device_usb_allocate(struct usb_device *udev,
  98                                                const char *module_name,
  99                                                struct module *owner)
 100 {
 101         struct media_device *mdev;
 102
 103         mutex_lock(&media_device_lock);
 104         mdev = __media_device_get(&udev->dev, module_name, owner);
 105         if (!mdev) {
 106                 mutex_unlock(&media_device_lock);
 107                 return ERR_PTR(-ENOMEM);
 108         }
 109
 110         /* check if media device is already initialized */
 111         if (!mdev->dev)
 112                 __media_device_usb_init(mdev, udev, udev->product,
 113                                         module_name);
 114         mutex_unlock(&media_device_lock);
 115         return mdev;
 116 }
 117 EXPORT_SYMBOL_GPL(media_device_usb_allocate);
 118
 119 void media_device_delete(struct media_device *mdev, const char *module_name,
 120                          struct module *owner)
 121 {
 122         struct media_device_instance *mdi = to_media_device_instance(mdev);
 123
 124         mutex_lock(&media_device_lock);
 125         /* put module reference for the media_device owner */
 126         if (mdi->owner != owner) {
 127                 module_put(mdi->owner);
 128                 dev_dbg(mdi->mdev.dev,
 129                         "%s: module %s put owner module reference\n",
 130                         __func__, module_name);
 131         }
 132         mutex_unlock(&media_device_lock);
 133         kref_put(&mdi->refcount, media_device_instance_release);
 134 }
 135 EXPORT_SYMBOL_GPL(media_device_delete);