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