mirror of
https://github.com/torvalds/linux.git
synced 2026-03-08 08:44:46 +01:00
bf4afc53b7
This was done entirely with mindless brute force, using
git grep -l '\<k[vmz]*alloc_objs*(.*, GFP_KERNEL)' |
xargs sed -i 's/\(alloc_objs*(.*\), GFP_KERNEL)/\1)/'
to convert the new alloc_obj() users that had a simple GFP_KERNEL
argument to just drop that argument.
Note that due to the extreme simplicity of the scripting, any slightly
more complex cases spread over multiple lines would not be triggered:
they definitely exist, but this covers the vast bulk of the cases, and
the resulting diff is also then easier to check automatically.
For the same reason the 'flex' versions will be done as a separate
conversion.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
135 lines
3.5 KiB
C
135 lines
3.5 KiB
C
// 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_obj(*mdi);
|
|
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);
|