* [PATCH v12 1/5] media: Media Device Allocator API
2019-03-27 2:24 [PATCH v12 0/5] Media Device Allocator API Shuah Khan
@ 2019-03-27 2:24 ` Shuah Khan
2019-03-27 10:37 ` Hans Verkuil
2019-03-27 2:24 ` [PATCH v12 2/5] media: change au0828 to use " Shuah Khan
` (3 subsequent siblings)
4 siblings, 1 reply; 10+ messages in thread
From: Shuah Khan @ 2019-03-27 2:24 UTC (permalink / raw)
To: mchehab, perex, tiwai, hverkuil
Cc: Shuah Khan, linux-media, linux-kernel, alsa-devel
Media Device Allocator API to allows multiple drivers share a media device.
This API solves a very common use-case for media devices where one physical
device (an USB stick) provides both audio and video. When such media device
exposes a standard USB Audio class, a proprietary Video class, two or more
independent drivers will share a single physical USB bridge. In such cases,
it is necessary to coordinate access to the shared resource.
Using this API, drivers can allocate a media device with the shared struct
device as the key. Once the media device is allocated by a driver, other
drivers can get a reference to it. The media device is released when all
the references are released.
Signed-off-by: Shuah Khan <shuah@kernel.org>
---
Documentation/media/kapi/mc-core.rst | 41 ++++++++
drivers/media/Makefile | 6 ++
drivers/media/media-dev-allocator.c | 142 +++++++++++++++++++++++++++
include/media/media-dev-allocator.h | 54 ++++++++++
4 files changed, 243 insertions(+)
create mode 100644 drivers/media/media-dev-allocator.c
create mode 100644 include/media/media-dev-allocator.h
diff --git a/Documentation/media/kapi/mc-core.rst b/Documentation/media/kapi/mc-core.rst
index f930725e0d6b..05bba0b61748 100644
--- a/Documentation/media/kapi/mc-core.rst
+++ b/Documentation/media/kapi/mc-core.rst
@@ -259,6 +259,45 @@ Subsystems should facilitate link validation by providing subsystem specific
helper functions to provide easy access for commonly needed information, and
in the end provide a way to use driver-specific callbacks.
+Media Controller Device Allocator API
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+When the media device belongs to more than one driver, the shared media
+device is allocated with the shared struct device as the key for look ups.
+
+The shared media device should stay in registered state until the last
+driver unregisters it. In addition, the media device should be released when
+all the references are released. Each driver gets a reference to the media
+device during probe, when it allocates the media device. If media device is
+already allocated, the allocate API bumps up the refcount and returns the
+existing media device. The driver puts the reference back in its disconnect
+routine when it calls :c:func:`media_device_delete()`.
+
+The media device is unregistered and cleaned up from the kref put handler to
+ensure that the media device stays in registered state until the last driver
+unregisters the media device.
+
+**Driver Usage**
+
+Drivers should use the appropriate media-core routines to manage the shared
+media device life-time handling the two states:
+1. allocate -> register -> delete
+2. get reference to already registered device -> delete
+
+call :c:func:`media_device_delete()` routine to make sure the shared media
+device delete is handled correctly.
+
+**driver probe:**
+Call :c:func:`media_device_usb_allocate()` to allocate or get a reference
+Call :c:func:`media_device_register()`, if media devnode isn't registered
+
+**driver disconnect:**
+Call :c:func:`media_device_delete()` to free the media_device. Freeing is
+handled by the kref put handler.
+
+API Definitions
+^^^^^^^^^^^^^^^
+
.. kernel-doc:: include/media/media-device.h
.. kernel-doc:: include/media/media-devnode.h
@@ -266,3 +305,5 @@ in the end provide a way to use driver-specific callbacks.
.. kernel-doc:: include/media/media-entity.h
.. kernel-doc:: include/media/media-request.h
+
+.. kernel-doc:: include/media/media-dev-allocator.h
diff --git a/drivers/media/Makefile b/drivers/media/Makefile
index 985d35ec6b29..20b488067ec2 100644
--- a/drivers/media/Makefile
+++ b/drivers/media/Makefile
@@ -6,6 +6,12 @@
media-objs := media-device.o media-devnode.o media-entity.o \
media-request.o
+ifeq ($(CONFIG_USB),y)
+ ifeq ($(CONFIG_MODULES),y)
+ media-objs += media-dev-allocator.o
+ endif
+endif
+
#
# I2C drivers should come before other drivers, otherwise they'll fail
# when compiled as builtin drivers
diff --git a/drivers/media/media-dev-allocator.c b/drivers/media/media-dev-allocator.c
new file mode 100644
index 000000000000..a37515254009
--- /dev/null
+++ b/drivers/media/media-dev-allocator.c
@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * media-dev-allocator.c - Media Controller Device Allocator API
+ *
+ * Copyright (c) 2018 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>
+
+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: mdev=%p\n", __func__, &mdi->mdev);
+
+ 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 *modp)
+{
+ 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 (modp != mdi->owner && !try_module_get(mdi->owner))
+ dev_err(dev, "%s: try_module_get() error\n", __func__);
+ dev_dbg(dev, "%s: get mdev=%p module_name %s\n",
+ __func__, &mdi->mdev, module_name);
+ return &mdi->mdev;
+ }
+
+ mdi = kzalloc(sizeof(*mdi), GFP_KERNEL);
+ if (!mdi)
+ return NULL;
+
+ mdi->owner = modp;
+ kref_init(&mdi->refcount);
+ list_add_tail(&mdi->list, &media_device_list);
+
+ dev_dbg(dev, "%s: alloc mdev=%p module_name %s\n", __func__,
+ &mdi->mdev, module_name);
+ return &mdi->mdev;
+}
+
+struct media_device *media_device_usb_allocate(struct usb_device *udev,
+ const char *module_name)
+{
+ struct media_device *mdev;
+ struct module *modptr;
+
+ mutex_lock(&module_mutex);
+ modptr = find_module(module_name);
+ mutex_unlock(&module_mutex);
+
+ mutex_lock(&media_device_lock);
+ mdev = __media_device_get(&udev->dev, module_name, modptr);
+ 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 media_device_instance *mdi = to_media_device_instance(mdev);
+ struct module *modptr;
+
+ dev_dbg(mdi->mdev.dev, "%s: mdev=%p module_name %s\n",
+ __func__, &mdi->mdev, module_name);
+
+ mutex_lock(&module_mutex);
+ modptr = find_module(module_name);
+ mutex_unlock(&module_mutex);
+
+ mutex_lock(&media_device_lock);
+ /* put module reference if media_device owner is not THIS_MODULE */
+ if (mdi->owner != modptr) {
+ module_put(mdi->owner);
+ dev_dbg(mdi->mdev.dev,
+ "%s decremented owner module reference\n", __func__);
+ }
+ mutex_unlock(&media_device_lock);
+ kref_put(&mdi->refcount, media_device_instance_release);
+}
+EXPORT_SYMBOL_GPL(media_device_delete);
diff --git a/include/media/media-dev-allocator.h b/include/media/media-dev-allocator.h
new file mode 100644
index 000000000000..69aee9a4b4c1
--- /dev/null
+++ b/include/media/media-dev-allocator.h
@@ -0,0 +1,54 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * media-dev-allocator.h - Media Controller Device Allocator API
+ *
+ * Copyright (c) 2018 Shuah Khan <shuah@kernel.org>
+ *
+ * Credits: Suggested by Laurent Pinchart <laurent.pinchart@ideasonboard.com>
+ */
+
+/*
+ * This file adds a global ref-counted 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.
+ */
+
+#ifndef _MEDIA_DEV_ALLOCTOR_H
+#define _MEDIA_DEV_ALLOCTOR_H
+
+struct usb_device;
+
+#if defined(CONFIG_MEDIA_CONTROLLER) && defined(CONFIG_USB) && \
+ defined(CONFIG_MODULES)
+/**
+ * media_device_usb_allocate() - Allocate and return struct &media device
+ *
+ * @udev: struct &usb_device pointer
+ * @module_name: should be filled with %KBUILD_MODNAME
+ *
+ * This interface should be called to allocate a Media Device when multiple
+ * drivers share usb_device and the media device. This interface allocates
+ * &media_device structure and calls media_device_usb_init() to initialize
+ * it.
+ *
+ */
+struct media_device *media_device_usb_allocate(struct usb_device *udev,
+ char *module_name);
+/**
+ * media_device_delete() - Release media device. Calls kref_put().
+ *
+ * @mdev: struct &media_device pointer
+ * @module_name: should be filled with %KBUILD_MODNAME
+ *
+ * This interface should be called to put Media Device Instance kref.
+ */
+void media_device_delete(struct media_device *mdev, char *module_name);
+#else
+static inline struct media_device *media_device_usb_allocate(
+ struct usb_device *udev, char *module_name)
+ { return NULL; }
+static inline void media_device_delete(
+ struct media_device *mdev, char *module_name) { }
+#endif /* CONFIG_MEDIA_CONTROLLER && CONFIG_USB && CONFIG_MODULES */
+#endif
--
2.17.1
^ permalink raw reply related [flat|nested] 10+ messages in thread* Re: [PATCH v12 1/5] media: Media Device Allocator API
2019-03-27 2:24 ` [PATCH v12 1/5] media: " Shuah Khan
@ 2019-03-27 10:37 ` Hans Verkuil
2019-03-27 13:45 ` shuah
0 siblings, 1 reply; 10+ messages in thread
From: Hans Verkuil @ 2019-03-27 10:37 UTC (permalink / raw)
To: Shuah Khan, mchehab, perex, tiwai; +Cc: linux-media, linux-kernel, alsa-devel
Hi Shuah,
Some comments at the end. I suspect you still have to do more work :-(
On 3/27/19 3:24 AM, Shuah Khan wrote:
> Media Device Allocator API to allows multiple drivers share a media device.
> This API solves a very common use-case for media devices where one physical
> device (an USB stick) provides both audio and video. When such media device
> exposes a standard USB Audio class, a proprietary Video class, two or more
> independent drivers will share a single physical USB bridge. In such cases,
> it is necessary to coordinate access to the shared resource.
>
> Using this API, drivers can allocate a media device with the shared struct
> device as the key. Once the media device is allocated by a driver, other
> drivers can get a reference to it. The media device is released when all
> the references are released.
>
> Signed-off-by: Shuah Khan <shuah@kernel.org>
> ---
> Documentation/media/kapi/mc-core.rst | 41 ++++++++
> drivers/media/Makefile | 6 ++
> drivers/media/media-dev-allocator.c | 142 +++++++++++++++++++++++++++
> include/media/media-dev-allocator.h | 54 ++++++++++
> 4 files changed, 243 insertions(+)
> create mode 100644 drivers/media/media-dev-allocator.c
> create mode 100644 include/media/media-dev-allocator.h
>
> diff --git a/Documentation/media/kapi/mc-core.rst b/Documentation/media/kapi/mc-core.rst
> index f930725e0d6b..05bba0b61748 100644
> --- a/Documentation/media/kapi/mc-core.rst
> +++ b/Documentation/media/kapi/mc-core.rst
> @@ -259,6 +259,45 @@ Subsystems should facilitate link validation by providing subsystem specific
> helper functions to provide easy access for commonly needed information, and
> in the end provide a way to use driver-specific callbacks.
>
> +Media Controller Device Allocator API
> +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> +
> +When the media device belongs to more than one driver, the shared media
> +device is allocated with the shared struct device as the key for look ups.
> +
> +The shared media device should stay in registered state until the last
> +driver unregisters it. In addition, the media device should be released when
> +all the references are released. Each driver gets a reference to the media
> +device during probe, when it allocates the media device. If media device is
> +already allocated, the allocate API bumps up the refcount and returns the
> +existing media device. The driver puts the reference back in its disconnect
> +routine when it calls :c:func:`media_device_delete()`.
> +
> +The media device is unregistered and cleaned up from the kref put handler to
> +ensure that the media device stays in registered state until the last driver
> +unregisters the media device.
> +
> +**Driver Usage**
> +
> +Drivers should use the appropriate media-core routines to manage the shared
> +media device life-time handling the two states:
> +1. allocate -> register -> delete
> +2. get reference to already registered device -> delete
> +
> +call :c:func:`media_device_delete()` routine to make sure the shared media
> +device delete is handled correctly.
> +
> +**driver probe:**
> +Call :c:func:`media_device_usb_allocate()` to allocate or get a reference
> +Call :c:func:`media_device_register()`, if media devnode isn't registered
> +
> +**driver disconnect:**
> +Call :c:func:`media_device_delete()` to free the media_device. Freeing is
> +handled by the kref put handler.
> +
> +API Definitions
> +^^^^^^^^^^^^^^^
> +
> .. kernel-doc:: include/media/media-device.h
>
> .. kernel-doc:: include/media/media-devnode.h
> @@ -266,3 +305,5 @@ in the end provide a way to use driver-specific callbacks.
> .. kernel-doc:: include/media/media-entity.h
>
> .. kernel-doc:: include/media/media-request.h
> +
> +.. kernel-doc:: include/media/media-dev-allocator.h
> diff --git a/drivers/media/Makefile b/drivers/media/Makefile
> index 985d35ec6b29..20b488067ec2 100644
> --- a/drivers/media/Makefile
> +++ b/drivers/media/Makefile
> @@ -6,6 +6,12 @@
> media-objs := media-device.o media-devnode.o media-entity.o \
> media-request.o
>
> +ifeq ($(CONFIG_USB),y)
> + ifeq ($(CONFIG_MODULES),y)
> + media-objs += media-dev-allocator.o
> + endif
> +endif
> +
> #
> # I2C drivers should come before other drivers, otherwise they'll fail
> # when compiled as builtin drivers
> diff --git a/drivers/media/media-dev-allocator.c b/drivers/media/media-dev-allocator.c
> new file mode 100644
> index 000000000000..a37515254009
> --- /dev/null
> +++ b/drivers/media/media-dev-allocator.c
> @@ -0,0 +1,142 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * media-dev-allocator.c - Media Controller Device Allocator API
> + *
> + * Copyright (c) 2018 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>
> +
> +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: mdev=%p\n", __func__, &mdi->mdev);
> +
> + 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 *modp)
> +{
> + 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 (modp != mdi->owner && !try_module_get(mdi->owner))
> + dev_err(dev, "%s: try_module_get() error\n", __func__);
> + dev_dbg(dev, "%s: get mdev=%p module_name %s\n",
> + __func__, &mdi->mdev, module_name);
> + return &mdi->mdev;
> + }
> +
> + mdi = kzalloc(sizeof(*mdi), GFP_KERNEL);
> + if (!mdi)
> + return NULL;
> +
> + mdi->owner = modp;
> + kref_init(&mdi->refcount);
> + list_add_tail(&mdi->list, &media_device_list);
> +
> + dev_dbg(dev, "%s: alloc mdev=%p module_name %s\n", __func__,
> + &mdi->mdev, module_name);
> + return &mdi->mdev;
> +}
> +
> +struct media_device *media_device_usb_allocate(struct usb_device *udev,
> + const char *module_name)
> +{
> + struct media_device *mdev;
> + struct module *modptr;
> +
> + mutex_lock(&module_mutex);
> + modptr = find_module(module_name);
> + mutex_unlock(&module_mutex);
> +
> + mutex_lock(&media_device_lock);
> + mdev = __media_device_get(&udev->dev, module_name, modptr);
> + 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 media_device_instance *mdi = to_media_device_instance(mdev);
> + struct module *modptr;
> +
> + dev_dbg(mdi->mdev.dev, "%s: mdev=%p module_name %s\n",
> + __func__, &mdi->mdev, module_name);
> +
> + mutex_lock(&module_mutex);
> + modptr = find_module(module_name);
> + mutex_unlock(&module_mutex);
> +
> + mutex_lock(&media_device_lock);
> + /* put module reference if media_device owner is not THIS_MODULE */
> + if (mdi->owner != modptr) {
> + module_put(mdi->owner);
> + dev_dbg(mdi->mdev.dev,
> + "%s decremented owner module reference\n", __func__);
> + }
> + mutex_unlock(&media_device_lock);
> + kref_put(&mdi->refcount, media_device_instance_release);
> +}
> +EXPORT_SYMBOL_GPL(media_device_delete);
> diff --git a/include/media/media-dev-allocator.h b/include/media/media-dev-allocator.h
> new file mode 100644
> index 000000000000..69aee9a4b4c1
> --- /dev/null
> +++ b/include/media/media-dev-allocator.h
> @@ -0,0 +1,54 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +/*
> + * media-dev-allocator.h - Media Controller Device Allocator API
> + *
> + * Copyright (c) 2018 Shuah Khan <shuah@kernel.org>
> + *
> + * Credits: Suggested by Laurent Pinchart <laurent.pinchart@ideasonboard.com>
> + */
> +
> +/*
> + * This file adds a global ref-counted 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.
> + */
> +
> +#ifndef _MEDIA_DEV_ALLOCTOR_H
> +#define _MEDIA_DEV_ALLOCTOR_H
> +
> +struct usb_device;
> +
> +#if defined(CONFIG_MEDIA_CONTROLLER) && defined(CONFIG_USB) && \
> + defined(CONFIG_MODULES)
> +/**
> + * media_device_usb_allocate() - Allocate and return struct &media device
> + *
> + * @udev: struct &usb_device pointer
> + * @module_name: should be filled with %KBUILD_MODNAME
> + *
> + * This interface should be called to allocate a Media Device when multiple
> + * drivers share usb_device and the media device. This interface allocates
> + * &media_device structure and calls media_device_usb_init() to initialize
> + * it.
> + *
> + */
> +struct media_device *media_device_usb_allocate(struct usb_device *udev,
> + char *module_name);
> +/**
> + * media_device_delete() - Release media device. Calls kref_put().
> + *
> + * @mdev: struct &media_device pointer
> + * @module_name: should be filled with %KBUILD_MODNAME
> + *
> + * This interface should be called to put Media Device Instance kref.
> + */
> +void media_device_delete(struct media_device *mdev, char *module_name);
> +#else
> +static inline struct media_device *media_device_usb_allocate(
> + struct usb_device *udev, char *module_name)
> + { return NULL; }
> +static inline void media_device_delete(
> + struct media_device *mdev, char *module_name) { }
> +#endif /* CONFIG_MEDIA_CONTROLLER && CONFIG_USB && CONFIG_MODULES */
I am still getting sparse warnings:
drivers/media/media-dev-allocator.c /home/hans/work/build/media-git/drivers/media/media-dev-allocator.c:94:21: warning: symbol 'media_device_usb_allocate' was not declared. Should it be static?
drivers/media/media-dev-allocator.c /home/hans/work/build/media-git/drivers/media/media-dev-allocator.c:120:6: warning: symbol 'media_device_delete' was not declared. Should it be static?
drivers/media/media-dev-allocator.c:94:22: warning: no previous prototype for 'media_device_usb_allocate' [-Wmissing-prototypes]
drivers/media/media-dev-allocator.c:120:6: warning: no previous prototype for 'media_device_delete' [-Wmissing-prototypes]
This makes sense since if the #if above evaluates to 0, then the
static inlines are used. But in media-dev-allocator.c these functions
are still present without a corresponding prototype.
You likely need a similar #if in media-dev-allocator.c.
Have you tested this if CONFIG_MODULES is not set? Does au0828 still work
w.r.t. sharing the shared resource? Has the driver been tested when MEDIA_CONTROLLER
is not set? Should au0828 select MEDIA_CONTROLLER explicitly perhaps?
My main concern is that it looks like au0828's probe() will now fail if MODULES is
not set.
Regards,
Hans
> +#endif
>
^ permalink raw reply [flat|nested] 10+ messages in thread* Re: [PATCH v12 1/5] media: Media Device Allocator API
2019-03-27 10:37 ` Hans Verkuil
@ 2019-03-27 13:45 ` shuah
2019-03-27 13:55 ` Hans Verkuil
0 siblings, 1 reply; 10+ messages in thread
From: shuah @ 2019-03-27 13:45 UTC (permalink / raw)
To: Hans Verkuil, mchehab, perex, tiwai
Cc: linux-media, linux-kernel, alsa-devel, shuah
Hi Hans,
On 3/27/19 4:37 AM, Hans Verkuil wrote:
> Hi Shuah,
>
> Some comments at the end. I suspect you still have to do more work :-(
I am okay with doing more work. I am expecting it since, I am not happy
with the config options that are in play. More on this below.
>
> On 3/27/19 3:24 AM, Shuah Khan wrote:
>> Media Device Allocator API to allows multiple drivers share a media device.
>> This API solves a very common use-case for media devices where one physical
>> device (an USB stick) provides both audio and video. When such media device
>> exposes a standard USB Audio class, a proprietary Video class, two or more
>> independent drivers will share a single physical USB bridge. In such cases,
>> it is necessary to coordinate access to the shared resource.
>>
>> Using this API, drivers can allocate a media device with the shared struct
>> device as the key. Once the media device is allocated by a driver, other
>> drivers can get a reference to it. The media device is released when all
>> the references are released.
>>
>> Signed-off-by: Shuah Khan <shuah@kernel.org>
>> ---
>> Documentation/media/kapi/mc-core.rst | 41 ++++++++
>> drivers/media/Makefile | 6 ++
>> drivers/media/media-dev-allocator.c | 142 +++++++++++++++++++++++++++
>> include/media/media-dev-allocator.h | 54 ++++++++++
>> 4 files changed, 243 insertions(+)
>> create mode 100644 drivers/media/media-dev-allocator.c
>> create mode 100644 include/media/media-dev-allocator.h
>>
>> diff --git a/Documentation/media/kapi/mc-core.rst b/Documentation/media/kapi/mc-core.rst
>> index f930725e0d6b..05bba0b61748 100644
>> --- a/Documentation/media/kapi/mc-core.rst
>> +++ b/Documentation/media/kapi/mc-core.rst
>> @@ -259,6 +259,45 @@ Subsystems should facilitate link validation by providing subsystem specific
>> helper functions to provide easy access for commonly needed information, and
>> in the end provide a way to use driver-specific callbacks.
>>
>> +Media Controller Device Allocator API
>> +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>> +
>> +When the media device belongs to more than one driver, the shared media
>> +device is allocated with the shared struct device as the key for look ups.
>> +
>> +The shared media device should stay in registered state until the last
>> +driver unregisters it. In addition, the media device should be released when
>> +all the references are released. Each driver gets a reference to the media
>> +device during probe, when it allocates the media device. If media device is
>> +already allocated, the allocate API bumps up the refcount and returns the
>> +existing media device. The driver puts the reference back in its disconnect
>> +routine when it calls :c:func:`media_device_delete()`.
>> +
>> +The media device is unregistered and cleaned up from the kref put handler to
>> +ensure that the media device stays in registered state until the last driver
>> +unregisters the media device.
>> +
>> +**Driver Usage**
>> +
>> +Drivers should use the appropriate media-core routines to manage the shared
>> +media device life-time handling the two states:
>> +1. allocate -> register -> delete
>> +2. get reference to already registered device -> delete
>> +
>> +call :c:func:`media_device_delete()` routine to make sure the shared media
>> +device delete is handled correctly.
>> +
>> +**driver probe:**
>> +Call :c:func:`media_device_usb_allocate()` to allocate or get a reference
>> +Call :c:func:`media_device_register()`, if media devnode isn't registered
>> +
>> +**driver disconnect:**
>> +Call :c:func:`media_device_delete()` to free the media_device. Freeing is
>> +handled by the kref put handler.
>> +
>> +API Definitions
>> +^^^^^^^^^^^^^^^
>> +
>> .. kernel-doc:: include/media/media-device.h
>>
>> .. kernel-doc:: include/media/media-devnode.h
>> @@ -266,3 +305,5 @@ in the end provide a way to use driver-specific callbacks.
>> .. kernel-doc:: include/media/media-entity.h
>>
>> .. kernel-doc:: include/media/media-request.h
>> +
>> +.. kernel-doc:: include/media/media-dev-allocator.h
>> diff --git a/drivers/media/Makefile b/drivers/media/Makefile
>> index 985d35ec6b29..20b488067ec2 100644
>> --- a/drivers/media/Makefile
>> +++ b/drivers/media/Makefile
>> @@ -6,6 +6,12 @@
>> media-objs := media-device.o media-devnode.o media-entity.o \
>> media-request.o
>>
>> +ifeq ($(CONFIG_USB),y)
>> + ifeq ($(CONFIG_MODULES),y)
>> + media-objs += media-dev-allocator.o
>> + endif
>> +endif
>> +
>> #
>> # I2C drivers should come before other drivers, otherwise they'll fail
>> # when compiled as builtin drivers
>> diff --git a/drivers/media/media-dev-allocator.c b/drivers/media/media-dev-allocator.c
>> new file mode 100644
>> index 000000000000..a37515254009
>> --- /dev/null
>> +++ b/drivers/media/media-dev-allocator.c
>> @@ -0,0 +1,142 @@
>> +// SPDX-License-Identifier: GPL-2.0
>> +/*
>> + * media-dev-allocator.c - Media Controller Device Allocator API
>> + *
>> + * Copyright (c) 2018 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>
>> +
>> +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: mdev=%p\n", __func__, &mdi->mdev);
>> +
>> + 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 *modp)
>> +{
>> + 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 (modp != mdi->owner && !try_module_get(mdi->owner))
>> + dev_err(dev, "%s: try_module_get() error\n", __func__);
>> + dev_dbg(dev, "%s: get mdev=%p module_name %s\n",
>> + __func__, &mdi->mdev, module_name);
>> + return &mdi->mdev;
>> + }
>> +
>> + mdi = kzalloc(sizeof(*mdi), GFP_KERNEL);
>> + if (!mdi)
>> + return NULL;
>> +
>> + mdi->owner = modp;
>> + kref_init(&mdi->refcount);
>> + list_add_tail(&mdi->list, &media_device_list);
>> +
>> + dev_dbg(dev, "%s: alloc mdev=%p module_name %s\n", __func__,
>> + &mdi->mdev, module_name);
>> + return &mdi->mdev;
>> +}
>> +
>> +struct media_device *media_device_usb_allocate(struct usb_device *udev,
>> + const char *module_name)
>> +{
>> + struct media_device *mdev;
>> + struct module *modptr;
>> +
>> + mutex_lock(&module_mutex);
>> + modptr = find_module(module_name);
>> + mutex_unlock(&module_mutex);
>> +
>> + mutex_lock(&media_device_lock);
>> + mdev = __media_device_get(&udev->dev, module_name, modptr);
>> + 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 media_device_instance *mdi = to_media_device_instance(mdev);
>> + struct module *modptr;
>> +
>> + dev_dbg(mdi->mdev.dev, "%s: mdev=%p module_name %s\n",
>> + __func__, &mdi->mdev, module_name);
>> +
>> + mutex_lock(&module_mutex);
>> + modptr = find_module(module_name);
>> + mutex_unlock(&module_mutex);
>> +
>> + mutex_lock(&media_device_lock);
>> + /* put module reference if media_device owner is not THIS_MODULE */
>> + if (mdi->owner != modptr) {
>> + module_put(mdi->owner);
>> + dev_dbg(mdi->mdev.dev,
>> + "%s decremented owner module reference\n", __func__);
>> + }
>> + mutex_unlock(&media_device_lock);
>> + kref_put(&mdi->refcount, media_device_instance_release);
>> +}
>> +EXPORT_SYMBOL_GPL(media_device_delete);
>> diff --git a/include/media/media-dev-allocator.h b/include/media/media-dev-allocator.h
>> new file mode 100644
>> index 000000000000..69aee9a4b4c1
>> --- /dev/null
>> +++ b/include/media/media-dev-allocator.h
>> @@ -0,0 +1,54 @@
>> +/* SPDX-License-Identifier: GPL-2.0+ */
>> +/*
>> + * media-dev-allocator.h - Media Controller Device Allocator API
>> + *
>> + * Copyright (c) 2018 Shuah Khan <shuah@kernel.org>
>> + *
>> + * Credits: Suggested by Laurent Pinchart <laurent.pinchart@ideasonboard.com>
>> + */
>> +
>> +/*
>> + * This file adds a global ref-counted 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.
>> + */
>> +
>> +#ifndef _MEDIA_DEV_ALLOCTOR_H
>> +#define _MEDIA_DEV_ALLOCTOR_H
>> +
>> +struct usb_device;
>> +
>> +#if defined(CONFIG_MEDIA_CONTROLLER) && defined(CONFIG_USB) && \
>> + defined(CONFIG_MODULES)
>> +/**
>> + * media_device_usb_allocate() - Allocate and return struct &media device
>> + *
>> + * @udev: struct &usb_device pointer
>> + * @module_name: should be filled with %KBUILD_MODNAME
>> + *
>> + * This interface should be called to allocate a Media Device when multiple
>> + * drivers share usb_device and the media device. This interface allocates
>> + * &media_device structure and calls media_device_usb_init() to initialize
>> + * it.
>> + *
>> + */
>> +struct media_device *media_device_usb_allocate(struct usb_device *udev,
>> + char *module_name);
>> +/**
>> + * media_device_delete() - Release media device. Calls kref_put().
>> + *
>> + * @mdev: struct &media_device pointer
>> + * @module_name: should be filled with %KBUILD_MODNAME
>> + *
>> + * This interface should be called to put Media Device Instance kref.
>> + */
>> +void media_device_delete(struct media_device *mdev, char *module_name);
>> +#else
>> +static inline struct media_device *media_device_usb_allocate(
>> + struct usb_device *udev, char *module_name)
>> + { return NULL; }
>> +static inline void media_device_delete(
>> + struct media_device *mdev, char *module_name) { }
>> +#endif /* CONFIG_MEDIA_CONTROLLER && CONFIG_USB && CONFIG_MODULES */
>
> I am still getting sparse warnings:
>
> drivers/media/media-dev-allocator.c /home/hans/work/build/media-git/drivers/media/media-dev-allocator.c:94:21: warning: symbol 'media_device_usb_allocate' was not declared. Should it be static?
> drivers/media/media-dev-allocator.c /home/hans/work/build/media-git/drivers/media/media-dev-allocator.c:120:6: warning: symbol 'media_device_delete' was not declared. Should it be static?
> drivers/media/media-dev-allocator.c:94:22: warning: no previous prototype for 'media_device_usb_allocate' [-Wmissing-prototypes]
> drivers/media/media-dev-allocator.c:120:6: warning: no previous prototype for 'media_device_delete' [-Wmissing-prototypes]
I didn't see the warns - maybe I have to upgrade to the latest gcc.
>
> This makes sense since if the #if above evaluates to 0, then the
> static inlines are used. But in media-dev-allocator.c these functions
> are still present without a corresponding prototype.
>
> You likely need a similar #if in media-dev-allocator.c.
>
> Have you tested this if CONFIG_MODULES is not set? Does au0828 still work
> w.r.t. sharing the shared resource? Has the driver been tested when MEDIA_CONTROLLER
> is not set? Should au0828 select MEDIA_CONTROLLER explicitly perhaps?
Unfortunately without MEDIA_CONTROLLER and CONFIG_MODULES, no sharing
happening. The only way to ensure sharing in all cases, is selecting
MEDIA_CONTROLLER and MODULES in au0828 and that will make sure
snd-usb-audio enables SND_USB_AUDIO_USE_MEDIA_CONTROLLER and all of
the sharing logic works.
>
> My main concern is that it looks like au0828's probe() will now fail if MODULES is
> not set.
>
Agreed. At the moment, we have too many config options in play even
before this work. Maybe it is time au0828 selected MEDIA_CONTROLLER
and CONFIG_MODULES - this will make sure all of this works.
I was hoping to start the config option discussion, so we can decide on
a set of options to select from these drivers.
thanks,
-- Shuah
^ permalink raw reply [flat|nested] 10+ messages in thread* Re: [PATCH v12 1/5] media: Media Device Allocator API
2019-03-27 13:45 ` shuah
@ 2019-03-27 13:55 ` Hans Verkuil
2019-03-27 14:18 ` shuah
0 siblings, 1 reply; 10+ messages in thread
From: Hans Verkuil @ 2019-03-27 13:55 UTC (permalink / raw)
To: shuah, mchehab, perex, tiwai; +Cc: linux-media, linux-kernel, alsa-devel
On 3/27/19 2:45 PM, shuah wrote:
> Hi Hans,
>
> On 3/27/19 4:37 AM, Hans Verkuil wrote:
>> Hi Shuah,
>>
>> Some comments at the end. I suspect you still have to do more work :-(
>
> I am okay with doing more work. I am expecting it since, I am not happy
> with the config options that are in play. More on this below.
>
>>
>> On 3/27/19 3:24 AM, Shuah Khan wrote:
>>> Media Device Allocator API to allows multiple drivers share a media device.
>>> This API solves a very common use-case for media devices where one physical
>>> device (an USB stick) provides both audio and video. When such media device
>>> exposes a standard USB Audio class, a proprietary Video class, two or more
>>> independent drivers will share a single physical USB bridge. In such cases,
>>> it is necessary to coordinate access to the shared resource.
>>>
>>> Using this API, drivers can allocate a media device with the shared struct
>>> device as the key. Once the media device is allocated by a driver, other
>>> drivers can get a reference to it. The media device is released when all
>>> the references are released.
>>>
>>> Signed-off-by: Shuah Khan <shuah@kernel.org>
>>> ---
>>> Documentation/media/kapi/mc-core.rst | 41 ++++++++
>>> drivers/media/Makefile | 6 ++
>>> drivers/media/media-dev-allocator.c | 142 +++++++++++++++++++++++++++
>>> include/media/media-dev-allocator.h | 54 ++++++++++
>>> 4 files changed, 243 insertions(+)
>>> create mode 100644 drivers/media/media-dev-allocator.c
>>> create mode 100644 include/media/media-dev-allocator.h
>>>
>>> diff --git a/Documentation/media/kapi/mc-core.rst b/Documentation/media/kapi/mc-core.rst
>>> index f930725e0d6b..05bba0b61748 100644
>>> --- a/Documentation/media/kapi/mc-core.rst
>>> +++ b/Documentation/media/kapi/mc-core.rst
>>> @@ -259,6 +259,45 @@ Subsystems should facilitate link validation by providing subsystem specific
>>> helper functions to provide easy access for commonly needed information, and
>>> in the end provide a way to use driver-specific callbacks.
>>>
>>> +Media Controller Device Allocator API
>>> +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>>> +
>>> +When the media device belongs to more than one driver, the shared media
>>> +device is allocated with the shared struct device as the key for look ups.
>>> +
>>> +The shared media device should stay in registered state until the last
>>> +driver unregisters it. In addition, the media device should be released when
>>> +all the references are released. Each driver gets a reference to the media
>>> +device during probe, when it allocates the media device. If media device is
>>> +already allocated, the allocate API bumps up the refcount and returns the
>>> +existing media device. The driver puts the reference back in its disconnect
>>> +routine when it calls :c:func:`media_device_delete()`.
>>> +
>>> +The media device is unregistered and cleaned up from the kref put handler to
>>> +ensure that the media device stays in registered state until the last driver
>>> +unregisters the media device.
>>> +
>>> +**Driver Usage**
>>> +
>>> +Drivers should use the appropriate media-core routines to manage the shared
>>> +media device life-time handling the two states:
>>> +1. allocate -> register -> delete
>>> +2. get reference to already registered device -> delete
>>> +
>>> +call :c:func:`media_device_delete()` routine to make sure the shared media
>>> +device delete is handled correctly.
>>> +
>>> +**driver probe:**
>>> +Call :c:func:`media_device_usb_allocate()` to allocate or get a reference
>>> +Call :c:func:`media_device_register()`, if media devnode isn't registered
>>> +
>>> +**driver disconnect:**
>>> +Call :c:func:`media_device_delete()` to free the media_device. Freeing is
>>> +handled by the kref put handler.
>>> +
>>> +API Definitions
>>> +^^^^^^^^^^^^^^^
>>> +
>>> .. kernel-doc:: include/media/media-device.h
>>>
>>> .. kernel-doc:: include/media/media-devnode.h
>>> @@ -266,3 +305,5 @@ in the end provide a way to use driver-specific callbacks.
>>> .. kernel-doc:: include/media/media-entity.h
>>>
>>> .. kernel-doc:: include/media/media-request.h
>>> +
>>> +.. kernel-doc:: include/media/media-dev-allocator.h
>>> diff --git a/drivers/media/Makefile b/drivers/media/Makefile
>>> index 985d35ec6b29..20b488067ec2 100644
>>> --- a/drivers/media/Makefile
>>> +++ b/drivers/media/Makefile
>>> @@ -6,6 +6,12 @@
>>> media-objs := media-device.o media-devnode.o media-entity.o \
>>> media-request.o
>>>
>>> +ifeq ($(CONFIG_USB),y)
>>> + ifeq ($(CONFIG_MODULES),y)
>>> + media-objs += media-dev-allocator.o
>>> + endif
>>> +endif
>>> +
>>> #
>>> # I2C drivers should come before other drivers, otherwise they'll fail
>>> # when compiled as builtin drivers
>>> diff --git a/drivers/media/media-dev-allocator.c b/drivers/media/media-dev-allocator.c
>>> new file mode 100644
>>> index 000000000000..a37515254009
>>> --- /dev/null
>>> +++ b/drivers/media/media-dev-allocator.c
>>> @@ -0,0 +1,142 @@
>>> +// SPDX-License-Identifier: GPL-2.0
>>> +/*
>>> + * media-dev-allocator.c - Media Controller Device Allocator API
>>> + *
>>> + * Copyright (c) 2018 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>
>>> +
>>> +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: mdev=%p\n", __func__, &mdi->mdev);
>>> +
>>> + 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 *modp)
>>> +{
>>> + 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 (modp != mdi->owner && !try_module_get(mdi->owner))
>>> + dev_err(dev, "%s: try_module_get() error\n", __func__);
>>> + dev_dbg(dev, "%s: get mdev=%p module_name %s\n",
>>> + __func__, &mdi->mdev, module_name);
>>> + return &mdi->mdev;
>>> + }
>>> +
>>> + mdi = kzalloc(sizeof(*mdi), GFP_KERNEL);
>>> + if (!mdi)
>>> + return NULL;
>>> +
>>> + mdi->owner = modp;
>>> + kref_init(&mdi->refcount);
>>> + list_add_tail(&mdi->list, &media_device_list);
>>> +
>>> + dev_dbg(dev, "%s: alloc mdev=%p module_name %s\n", __func__,
>>> + &mdi->mdev, module_name);
>>> + return &mdi->mdev;
>>> +}
>>> +
>>> +struct media_device *media_device_usb_allocate(struct usb_device *udev,
>>> + const char *module_name)
>>> +{
>>> + struct media_device *mdev;
>>> + struct module *modptr;
>>> +
>>> + mutex_lock(&module_mutex);
>>> + modptr = find_module(module_name);
>>> + mutex_unlock(&module_mutex);
>>> +
>>> + mutex_lock(&media_device_lock);
>>> + mdev = __media_device_get(&udev->dev, module_name, modptr);
>>> + 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 media_device_instance *mdi = to_media_device_instance(mdev);
>>> + struct module *modptr;
>>> +
>>> + dev_dbg(mdi->mdev.dev, "%s: mdev=%p module_name %s\n",
>>> + __func__, &mdi->mdev, module_name);
>>> +
>>> + mutex_lock(&module_mutex);
>>> + modptr = find_module(module_name);
>>> + mutex_unlock(&module_mutex);
>>> +
>>> + mutex_lock(&media_device_lock);
>>> + /* put module reference if media_device owner is not THIS_MODULE */
>>> + if (mdi->owner != modptr) {
>>> + module_put(mdi->owner);
>>> + dev_dbg(mdi->mdev.dev,
>>> + "%s decremented owner module reference\n", __func__);
>>> + }
>>> + mutex_unlock(&media_device_lock);
>>> + kref_put(&mdi->refcount, media_device_instance_release);
>>> +}
>>> +EXPORT_SYMBOL_GPL(media_device_delete);
>>> diff --git a/include/media/media-dev-allocator.h b/include/media/media-dev-allocator.h
>>> new file mode 100644
>>> index 000000000000..69aee9a4b4c1
>>> --- /dev/null
>>> +++ b/include/media/media-dev-allocator.h
>>> @@ -0,0 +1,54 @@
>>> +/* SPDX-License-Identifier: GPL-2.0+ */
>>> +/*
>>> + * media-dev-allocator.h - Media Controller Device Allocator API
>>> + *
>>> + * Copyright (c) 2018 Shuah Khan <shuah@kernel.org>
>>> + *
>>> + * Credits: Suggested by Laurent Pinchart <laurent.pinchart@ideasonboard.com>
>>> + */
>>> +
>>> +/*
>>> + * This file adds a global ref-counted 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.
>>> + */
>>> +
>>> +#ifndef _MEDIA_DEV_ALLOCTOR_H
>>> +#define _MEDIA_DEV_ALLOCTOR_H
>>> +
>>> +struct usb_device;
>>> +
>>> +#if defined(CONFIG_MEDIA_CONTROLLER) && defined(CONFIG_USB) && \
>>> + defined(CONFIG_MODULES)
>>> +/**
>>> + * media_device_usb_allocate() - Allocate and return struct &media device
>>> + *
>>> + * @udev: struct &usb_device pointer
>>> + * @module_name: should be filled with %KBUILD_MODNAME
>>> + *
>>> + * This interface should be called to allocate a Media Device when multiple
>>> + * drivers share usb_device and the media device. This interface allocates
>>> + * &media_device structure and calls media_device_usb_init() to initialize
>>> + * it.
>>> + *
>>> + */
>>> +struct media_device *media_device_usb_allocate(struct usb_device *udev,
>>> + char *module_name);
>>> +/**
>>> + * media_device_delete() - Release media device. Calls kref_put().
>>> + *
>>> + * @mdev: struct &media_device pointer
>>> + * @module_name: should be filled with %KBUILD_MODNAME
>>> + *
>>> + * This interface should be called to put Media Device Instance kref.
>>> + */
>>> +void media_device_delete(struct media_device *mdev, char *module_name);
>>> +#else
>>> +static inline struct media_device *media_device_usb_allocate(
>>> + struct usb_device *udev, char *module_name)
>>> + { return NULL; }
>>> +static inline void media_device_delete(
>>> + struct media_device *mdev, char *module_name) { }
>>> +#endif /* CONFIG_MEDIA_CONTROLLER && CONFIG_USB && CONFIG_MODULES */
>>
>> I am still getting sparse warnings:
>>
>> drivers/media/media-dev-allocator.c /home/hans/work/build/media-git/drivers/media/media-dev-allocator.c:94:21: warning: symbol 'media_device_usb_allocate' was not declared. Should it be static?
>> drivers/media/media-dev-allocator.c /home/hans/work/build/media-git/drivers/media/media-dev-allocator.c:120:6: warning: symbol 'media_device_delete' was not declared. Should it be static?
>> drivers/media/media-dev-allocator.c:94:22: warning: no previous prototype for 'media_device_usb_allocate' [-Wmissing-prototypes]
>> drivers/media/media-dev-allocator.c:120:6: warning: no previous prototype for 'media_device_delete' [-Wmissing-prototypes]
>
> I didn't see the warns - maybe I have to upgrade to the latest gcc.
Ah, media-dev-allocator.c doesn't include media-dev-allocator.h.
I suspect that that's the reason for the sparse warning.
>
>>
>> This makes sense since if the #if above evaluates to 0, then the
>> static inlines are used. But in media-dev-allocator.c these functions
>> are still present without a corresponding prototype.
>>
>> You likely need a similar #if in media-dev-allocator.c.
>>
>> Have you tested this if CONFIG_MODULES is not set? Does au0828 still work
>> w.r.t. sharing the shared resource? Has the driver been tested when MEDIA_CONTROLLER
>> is not set? Should au0828 select MEDIA_CONTROLLER explicitly perhaps?
>
> Unfortunately without MEDIA_CONTROLLER and CONFIG_MODULES, no sharing
> happening. The only way to ensure sharing in all cases, is selecting
> MEDIA_CONTROLLER and MODULES in au0828 and that will make sure
> snd-usb-audio enables SND_USB_AUDIO_USE_MEDIA_CONTROLLER and all of
> the sharing logic works.
You can select MEDIA_CONTROLLER for au0828, but never MODULES. Selecting
MEDIA_CONTROLLER makes sense, I have no objection to that.
What do you mean with 'no sharing happening'? You have to deal with
modules to make sure they are not unloaded, but other than that this
feature shouldn't depend on MODULES. Or am I missing something?
>
>>
>> My main concern is that it looks like au0828's probe() will now fail if MODULES is
>> not set.
>>
>
> Agreed. At the moment, we have too many config options in play even
> before this work. Maybe it is time au0828 selected MEDIA_CONTROLLER
> and CONFIG_MODULES - this will make sure all of this works.
>
> I was hoping to start the config option discussion, so we can decide on
> a set of options to select from these drivers.
Regards,
Hans
>
> thanks,
> -- Shuah
>
^ permalink raw reply [flat|nested] 10+ messages in thread* Re: [PATCH v12 1/5] media: Media Device Allocator API
2019-03-27 13:55 ` Hans Verkuil
@ 2019-03-27 14:18 ` shuah
0 siblings, 0 replies; 10+ messages in thread
From: shuah @ 2019-03-27 14:18 UTC (permalink / raw)
To: Hans Verkuil, mchehab, perex, tiwai
Cc: linux-media, linux-kernel, alsa-devel, shuah
On 3/27/19 7:55 AM, Hans Verkuil wrote:
> On 3/27/19 2:45 PM, shuah wrote:
>> Hi Hans,
>>
>> On 3/27/19 4:37 AM, Hans Verkuil wrote:
>>> Hi Shuah,
>>>
>>> Some comments at the end. I suspect you still have to do more work :-(
>>
>> I am okay with doing more work. I am expecting it since, I am not happy
>> with the config options that are in play. More on this below.
>>
>>>
>>> On 3/27/19 3:24 AM, Shuah Khan wrote:
>>>> Media Device Allocator API to allows multiple drivers share a media device.
>>>> This API solves a very common use-case for media devices where one physical
>>>> device (an USB stick) provides both audio and video. When such media device
>>>> exposes a standard USB Audio class, a proprietary Video class, two or more
>>>> independent drivers will share a single physical USB bridge. In such cases,
>>>> it is necessary to coordinate access to the shared resource.
>>>>
>>>> Using this API, drivers can allocate a media device with the shared struct
>>>> device as the key. Once the media device is allocated by a driver, other
>>>> drivers can get a reference to it. The media device is released when all
>>>> the references are released.
>>>>
>>>> Signed-off-by: Shuah Khan <shuah@kernel.org>
>>>> ---
>>>> Documentation/media/kapi/mc-core.rst | 41 ++++++++
>>>> drivers/media/Makefile | 6 ++
>>>> drivers/media/media-dev-allocator.c | 142 +++++++++++++++++++++++++++
>>>> include/media/media-dev-allocator.h | 54 ++++++++++
>>>> 4 files changed, 243 insertions(+)
>>>> create mode 100644 drivers/media/media-dev-allocator.c
>>>> create mode 100644 include/media/media-dev-allocator.h
>>>>
>>>> diff --git a/Documentation/media/kapi/mc-core.rst b/Documentation/media/kapi/mc-core.rst
>>>> index f930725e0d6b..05bba0b61748 100644
>>>> --- a/Documentation/media/kapi/mc-core.rst
>>>> +++ b/Documentation/media/kapi/mc-core.rst
>>>> @@ -259,6 +259,45 @@ Subsystems should facilitate link validation by providing subsystem specific
>>>> helper functions to provide easy access for commonly needed information, and
>>>> in the end provide a way to use driver-specific callbacks.
>>>>
>>>> +Media Controller Device Allocator API
>>>> +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>>>> +
>>>> +When the media device belongs to more than one driver, the shared media
>>>> +device is allocated with the shared struct device as the key for look ups.
>>>> +
>>>> +The shared media device should stay in registered state until the last
>>>> +driver unregisters it. In addition, the media device should be released when
>>>> +all the references are released. Each driver gets a reference to the media
>>>> +device during probe, when it allocates the media device. If media device is
>>>> +already allocated, the allocate API bumps up the refcount and returns the
>>>> +existing media device. The driver puts the reference back in its disconnect
>>>> +routine when it calls :c:func:`media_device_delete()`.
>>>> +
>>>> +The media device is unregistered and cleaned up from the kref put handler to
>>>> +ensure that the media device stays in registered state until the last driver
>>>> +unregisters the media device.
>>>> +
>>>> +**Driver Usage**
>>>> +
>>>> +Drivers should use the appropriate media-core routines to manage the shared
>>>> +media device life-time handling the two states:
>>>> +1. allocate -> register -> delete
>>>> +2. get reference to already registered device -> delete
>>>> +
>>>> +call :c:func:`media_device_delete()` routine to make sure the shared media
>>>> +device delete is handled correctly.
>>>> +
>>>> +**driver probe:**
>>>> +Call :c:func:`media_device_usb_allocate()` to allocate or get a reference
>>>> +Call :c:func:`media_device_register()`, if media devnode isn't registered
>>>> +
>>>> +**driver disconnect:**
>>>> +Call :c:func:`media_device_delete()` to free the media_device. Freeing is
>>>> +handled by the kref put handler.
>>>> +
>>>> +API Definitions
>>>> +^^^^^^^^^^^^^^^
>>>> +
>>>> .. kernel-doc:: include/media/media-device.h
>>>>
>>>> .. kernel-doc:: include/media/media-devnode.h
>>>> @@ -266,3 +305,5 @@ in the end provide a way to use driver-specific callbacks.
>>>> .. kernel-doc:: include/media/media-entity.h
>>>>
>>>> .. kernel-doc:: include/media/media-request.h
>>>> +
>>>> +.. kernel-doc:: include/media/media-dev-allocator.h
>>>> diff --git a/drivers/media/Makefile b/drivers/media/Makefile
>>>> index 985d35ec6b29..20b488067ec2 100644
>>>> --- a/drivers/media/Makefile
>>>> +++ b/drivers/media/Makefile
>>>> @@ -6,6 +6,12 @@
>>>> media-objs := media-device.o media-devnode.o media-entity.o \
>>>> media-request.o
>>>>
>>>> +ifeq ($(CONFIG_USB),y)
>>>> + ifeq ($(CONFIG_MODULES),y)
>>>> + media-objs += media-dev-allocator.o
>>>> + endif
>>>> +endif
>>>> +
>>>> #
>>>> # I2C drivers should come before other drivers, otherwise they'll fail
>>>> # when compiled as builtin drivers
>>>> diff --git a/drivers/media/media-dev-allocator.c b/drivers/media/media-dev-allocator.c
>>>> new file mode 100644
>>>> index 000000000000..a37515254009
>>>> --- /dev/null
>>>> +++ b/drivers/media/media-dev-allocator.c
>>>> @@ -0,0 +1,142 @@
>>>> +// SPDX-License-Identifier: GPL-2.0
>>>> +/*
>>>> + * media-dev-allocator.c - Media Controller Device Allocator API
>>>> + *
>>>> + * Copyright (c) 2018 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>
>>>> +
>>>> +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: mdev=%p\n", __func__, &mdi->mdev);
>>>> +
>>>> + 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 *modp)
>>>> +{
>>>> + 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 (modp != mdi->owner && !try_module_get(mdi->owner))
>>>> + dev_err(dev, "%s: try_module_get() error\n", __func__);
>>>> + dev_dbg(dev, "%s: get mdev=%p module_name %s\n",
>>>> + __func__, &mdi->mdev, module_name);
>>>> + return &mdi->mdev;
>>>> + }
>>>> +
>>>> + mdi = kzalloc(sizeof(*mdi), GFP_KERNEL);
>>>> + if (!mdi)
>>>> + return NULL;
>>>> +
>>>> + mdi->owner = modp;
>>>> + kref_init(&mdi->refcount);
>>>> + list_add_tail(&mdi->list, &media_device_list);
>>>> +
>>>> + dev_dbg(dev, "%s: alloc mdev=%p module_name %s\n", __func__,
>>>> + &mdi->mdev, module_name);
>>>> + return &mdi->mdev;
>>>> +}
>>>> +
>>>> +struct media_device *media_device_usb_allocate(struct usb_device *udev,
>>>> + const char *module_name)
>>>> +{
>>>> + struct media_device *mdev;
>>>> + struct module *modptr;
>>>> +
>>>> + mutex_lock(&module_mutex);
>>>> + modptr = find_module(module_name);
>>>> + mutex_unlock(&module_mutex);
>>>> +
>>>> + mutex_lock(&media_device_lock);
>>>> + mdev = __media_device_get(&udev->dev, module_name, modptr);
>>>> + 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 media_device_instance *mdi = to_media_device_instance(mdev);
>>>> + struct module *modptr;
>>>> +
>>>> + dev_dbg(mdi->mdev.dev, "%s: mdev=%p module_name %s\n",
>>>> + __func__, &mdi->mdev, module_name);
>>>> +
>>>> + mutex_lock(&module_mutex);
>>>> + modptr = find_module(module_name);
>>>> + mutex_unlock(&module_mutex);
>>>> +
>>>> + mutex_lock(&media_device_lock);
>>>> + /* put module reference if media_device owner is not THIS_MODULE */
>>>> + if (mdi->owner != modptr) {
>>>> + module_put(mdi->owner);
>>>> + dev_dbg(mdi->mdev.dev,
>>>> + "%s decremented owner module reference\n", __func__);
>>>> + }
>>>> + mutex_unlock(&media_device_lock);
>>>> + kref_put(&mdi->refcount, media_device_instance_release);
>>>> +}
>>>> +EXPORT_SYMBOL_GPL(media_device_delete);
>>>> diff --git a/include/media/media-dev-allocator.h b/include/media/media-dev-allocator.h
>>>> new file mode 100644
>>>> index 000000000000..69aee9a4b4c1
>>>> --- /dev/null
>>>> +++ b/include/media/media-dev-allocator.h
>>>> @@ -0,0 +1,54 @@
>>>> +/* SPDX-License-Identifier: GPL-2.0+ */
>>>> +/*
>>>> + * media-dev-allocator.h - Media Controller Device Allocator API
>>>> + *
>>>> + * Copyright (c) 2018 Shuah Khan <shuah@kernel.org>
>>>> + *
>>>> + * Credits: Suggested by Laurent Pinchart <laurent.pinchart@ideasonboard.com>
>>>> + */
>>>> +
>>>> +/*
>>>> + * This file adds a global ref-counted 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.
>>>> + */
>>>> +
>>>> +#ifndef _MEDIA_DEV_ALLOCTOR_H
>>>> +#define _MEDIA_DEV_ALLOCTOR_H
>>>> +
>>>> +struct usb_device;
>>>> +
>>>> +#if defined(CONFIG_MEDIA_CONTROLLER) && defined(CONFIG_USB) && \
>>>> + defined(CONFIG_MODULES)
>>>> +/**
>>>> + * media_device_usb_allocate() - Allocate and return struct &media device
>>>> + *
>>>> + * @udev: struct &usb_device pointer
>>>> + * @module_name: should be filled with %KBUILD_MODNAME
>>>> + *
>>>> + * This interface should be called to allocate a Media Device when multiple
>>>> + * drivers share usb_device and the media device. This interface allocates
>>>> + * &media_device structure and calls media_device_usb_init() to initialize
>>>> + * it.
>>>> + *
>>>> + */
>>>> +struct media_device *media_device_usb_allocate(struct usb_device *udev,
>>>> + char *module_name);
>>>> +/**
>>>> + * media_device_delete() - Release media device. Calls kref_put().
>>>> + *
>>>> + * @mdev: struct &media_device pointer
>>>> + * @module_name: should be filled with %KBUILD_MODNAME
>>>> + *
>>>> + * This interface should be called to put Media Device Instance kref.
>>>> + */
>>>> +void media_device_delete(struct media_device *mdev, char *module_name);
>>>> +#else
>>>> +static inline struct media_device *media_device_usb_allocate(
>>>> + struct usb_device *udev, char *module_name)
>>>> + { return NULL; }
>>>> +static inline void media_device_delete(
>>>> + struct media_device *mdev, char *module_name) { }
>>>> +#endif /* CONFIG_MEDIA_CONTROLLER && CONFIG_USB && CONFIG_MODULES */
>>>
>>> I am still getting sparse warnings:
>>>
>>> drivers/media/media-dev-allocator.c /home/hans/work/build/media-git/drivers/media/media-dev-allocator.c:94:21: warning: symbol 'media_device_usb_allocate' was not declared. Should it be static?
>>> drivers/media/media-dev-allocator.c /home/hans/work/build/media-git/drivers/media/media-dev-allocator.c:120:6: warning: symbol 'media_device_delete' was not declared. Should it be static?
>>> drivers/media/media-dev-allocator.c:94:22: warning: no previous prototype for 'media_device_usb_allocate' [-Wmissing-prototypes]
>>> drivers/media/media-dev-allocator.c:120:6: warning: no previous prototype for 'media_device_delete' [-Wmissing-prototypes]
>>
>> I didn't see the warns - maybe I have to upgrade to the latest gcc.
>
> Ah, media-dev-allocator.c doesn't include media-dev-allocator.h.
>
> I suspect that that's the reason for the sparse warning.
>
>>
>>>
>>> This makes sense since if the #if above evaluates to 0, then the
>>> static inlines are used. But in media-dev-allocator.c these functions
>>> are still present without a corresponding prototype.
>>>
>>> You likely need a similar #if in media-dev-allocator.c.
>>>
>>> Have you tested this if CONFIG_MODULES is not set? Does au0828 still work
>>> w.r.t. sharing the shared resource? Has the driver been tested when MEDIA_CONTROLLER
>>> is not set? Should au0828 select MEDIA_CONTROLLER explicitly perhaps?
>>
>> Unfortunately without MEDIA_CONTROLLER and CONFIG_MODULES, no sharing
>> happening. The only way to ensure sharing in all cases, is selecting
>> MEDIA_CONTROLLER and MODULES in au0828 and that will make sure
>> snd-usb-audio enables SND_USB_AUDIO_USE_MEDIA_CONTROLLER and all of
>> the sharing logic works.
>
> You can select MEDIA_CONTROLLER for au0828, but never MODULES. Selecting
> MEDIA_CONTROLLER makes sense, I have no objection to that.
>
> What do you mean with 'no sharing happening'? You have to deal with
> modules to make sure they are not unloaded, but other than that this
> feature shouldn't depend on MODULES. Or am I missing something?
>
>>
You are right. It shouldn't depend on MODULES. The code that deals with
modules so they don't get unloaded has dependency on MODULES, not all
of it. I see the problem now.
I will update au0828 to select MEDIA_CONTROLLER and update the module
logic and send v13. Maybe that is the lucky version :)
thanks,
-- Shuah
^ permalink raw reply [flat|nested] 10+ messages in thread
* [PATCH v12 2/5] media: change au0828 to use Media Device Allocator API
2019-03-27 2:24 [PATCH v12 0/5] Media Device Allocator API Shuah Khan
2019-03-27 2:24 ` [PATCH v12 1/5] media: " Shuah Khan
@ 2019-03-27 2:24 ` Shuah Khan
2019-03-27 2:24 ` [PATCH v12 3/5] media: media.h: Enable ALSA MEDIA_INTF_T* interface types Shuah Khan
` (2 subsequent siblings)
4 siblings, 0 replies; 10+ messages in thread
From: Shuah Khan @ 2019-03-27 2:24 UTC (permalink / raw)
To: mchehab, perex, tiwai, hverkuil
Cc: Shuah Khan, linux-media, linux-kernel, alsa-devel
Media Device Allocator API to allows multiple drivers share a media device.
This API solves a very common use-case for media devices where one physical
device (an USB stick) provides both audio and video. When such media device
exposes a standard USB Audio class, a proprietary Video class, two or more
independent drivers will share a single physical USB bridge. In such cases,
it is necessary to coordinate access to the shared resource.
Using this API, drivers can allocate a media device with the shared struct
device as the key. Once the media device is allocated by a driver, other
drivers can get a reference to it. The media device is released when all
the references are released.
Change au0828 to use Media Device Allocator API to allocate media device
with the parent usb struct device as the key, so it can be shared with the
snd_usb_audio driver.
Signed-off-by: Shuah Khan <shuah@kernel.org>
---
drivers/media/usb/au0828/au0828-core.c | 12 ++++--------
drivers/media/usb/au0828/au0828.h | 1 +
2 files changed, 5 insertions(+), 8 deletions(-)
diff --git a/drivers/media/usb/au0828/au0828-core.c b/drivers/media/usb/au0828/au0828-core.c
index 3f8c92a70116..8167e50b7bc4 100644
--- a/drivers/media/usb/au0828/au0828-core.c
+++ b/drivers/media/usb/au0828/au0828-core.c
@@ -155,9 +155,7 @@ static void au0828_unregister_media_device(struct au0828_dev *dev)
dev->media_dev->disable_source = NULL;
mutex_unlock(&mdev->graph_mutex);
- media_device_unregister(dev->media_dev);
- media_device_cleanup(dev->media_dev);
- kfree(dev->media_dev);
+ media_device_delete(dev->media_dev, KBUILD_MODNAME);
dev->media_dev = NULL;
#endif
}
@@ -210,14 +208,10 @@ static int au0828_media_device_init(struct au0828_dev *dev,
#ifdef CONFIG_MEDIA_CONTROLLER
struct media_device *mdev;
- mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
+ mdev = media_device_usb_allocate(udev, KBUILD_MODNAME);
if (!mdev)
return -ENOMEM;
- /* check if media device is already initialized */
- if (!mdev->dev)
- media_device_usb_init(mdev, udev, udev->product);
-
dev->media_dev = mdev;
#endif
return 0;
@@ -480,6 +474,8 @@ static int au0828_media_device_register(struct au0828_dev *dev,
/* register media device */
ret = media_device_register(dev->media_dev);
if (ret) {
+ media_device_delete(dev->media_dev, KBUILD_MODNAME);
+ dev->media_dev = NULL;
dev_err(&udev->dev,
"Media Device Register Error: %d\n", ret);
return ret;
diff --git a/drivers/media/usb/au0828/au0828.h b/drivers/media/usb/au0828/au0828.h
index 425c35d16057..57b00de8d3f2 100644
--- a/drivers/media/usb/au0828/au0828.h
+++ b/drivers/media/usb/au0828/au0828.h
@@ -31,6 +31,7 @@
#include <media/v4l2-ctrls.h>
#include <media/v4l2-fh.h>
#include <media/media-device.h>
+#include <media/media-dev-allocator.h>
/* DVB */
#include <media/demux.h>
--
2.17.1
^ permalink raw reply related [flat|nested] 10+ messages in thread* [PATCH v12 3/5] media: media.h: Enable ALSA MEDIA_INTF_T* interface types
2019-03-27 2:24 [PATCH v12 0/5] Media Device Allocator API Shuah Khan
2019-03-27 2:24 ` [PATCH v12 1/5] media: " Shuah Khan
2019-03-27 2:24 ` [PATCH v12 2/5] media: change au0828 to use " Shuah Khan
@ 2019-03-27 2:24 ` Shuah Khan
2019-03-27 2:24 ` [PATCH v12 4/5] sound/usb: Use Media Controller API to share media resources Shuah Khan
2019-03-27 2:24 ` [PATCH v12 5/5] au0828: fix enable and disable source audio and video inconsistencies Shuah Khan
4 siblings, 0 replies; 10+ messages in thread
From: Shuah Khan @ 2019-03-27 2:24 UTC (permalink / raw)
To: mchehab, perex, tiwai, hverkuil
Cc: Shuah Khan, linux-media, linux-kernel, alsa-devel
Move PCM_CAPTURE, PCM_PLAYBACK, and CONTROL ALSA MEDIA_INTF_T* interface
types back into __KERNEL__ scope to get ready for adding ALSA support for
these to the media controller.
Signed-off-by: Shuah Khan <shuah@kernel.org>
---
include/uapi/linux/media.h | 25 +++++++++++++++----------
1 file changed, 15 insertions(+), 10 deletions(-)
diff --git a/include/uapi/linux/media.h b/include/uapi/linux/media.h
index e5d0c5c611b5..9aedb187bc48 100644
--- a/include/uapi/linux/media.h
+++ b/include/uapi/linux/media.h
@@ -262,6 +262,11 @@ struct media_links_enum {
#define MEDIA_INTF_T_V4L_SWRADIO (MEDIA_INTF_T_V4L_BASE + 4)
#define MEDIA_INTF_T_V4L_TOUCH (MEDIA_INTF_T_V4L_BASE + 5)
+#define MEDIA_INTF_T_ALSA_BASE 0x00000300
+#define MEDIA_INTF_T_ALSA_PCM_CAPTURE (MEDIA_INTF_T_ALSA_BASE)
+#define MEDIA_INTF_T_ALSA_PCM_PLAYBACK (MEDIA_INTF_T_ALSA_BASE + 1)
+#define MEDIA_INTF_T_ALSA_CONTROL (MEDIA_INTF_T_ALSA_BASE + 2)
+
#if defined(__KERNEL__)
/*
@@ -413,19 +418,19 @@ struct media_v2_topology {
#define MEDIA_ENT_F_DTV_DECODER MEDIA_ENT_F_DV_DECODER
/*
- * There is still no ALSA support in the media controller. These
+ * There is still no full ALSA support in the media controller. These
* defines should not have been added and we leave them here only
* in case some application tries to use these defines.
+ *
+ * The ALSA defines that are in use have been moved into __KERNEL__
+ * scope. As support gets added to these interface types, they should
+ * be moved into __KERNEL__ scope with the code that uses them.
*/
-#define MEDIA_INTF_T_ALSA_BASE 0x00000300
-#define MEDIA_INTF_T_ALSA_PCM_CAPTURE (MEDIA_INTF_T_ALSA_BASE)
-#define MEDIA_INTF_T_ALSA_PCM_PLAYBACK (MEDIA_INTF_T_ALSA_BASE + 1)
-#define MEDIA_INTF_T_ALSA_CONTROL (MEDIA_INTF_T_ALSA_BASE + 2)
-#define MEDIA_INTF_T_ALSA_COMPRESS (MEDIA_INTF_T_ALSA_BASE + 3)
-#define MEDIA_INTF_T_ALSA_RAWMIDI (MEDIA_INTF_T_ALSA_BASE + 4)
-#define MEDIA_INTF_T_ALSA_HWDEP (MEDIA_INTF_T_ALSA_BASE + 5)
-#define MEDIA_INTF_T_ALSA_SEQUENCER (MEDIA_INTF_T_ALSA_BASE + 6)
-#define MEDIA_INTF_T_ALSA_TIMER (MEDIA_INTF_T_ALSA_BASE + 7)
+#define MEDIA_INTF_T_ALSA_COMPRESS (MEDIA_INTF_T_ALSA_BASE + 3)
+#define MEDIA_INTF_T_ALSA_RAWMIDI (MEDIA_INTF_T_ALSA_BASE + 4)
+#define MEDIA_INTF_T_ALSA_HWDEP (MEDIA_INTF_T_ALSA_BASE + 5)
+#define MEDIA_INTF_T_ALSA_SEQUENCER (MEDIA_INTF_T_ALSA_BASE + 6)
+#define MEDIA_INTF_T_ALSA_TIMER (MEDIA_INTF_T_ALSA_BASE + 7)
/* Obsolete symbol for media_version, no longer used in the kernel */
#define MEDIA_API_VERSION ((0 << 16) | (1 << 8) | 0)
--
2.17.1
^ permalink raw reply related [flat|nested] 10+ messages in thread* [PATCH v12 4/5] sound/usb: Use Media Controller API to share media resources
2019-03-27 2:24 [PATCH v12 0/5] Media Device Allocator API Shuah Khan
` (2 preceding siblings ...)
2019-03-27 2:24 ` [PATCH v12 3/5] media: media.h: Enable ALSA MEDIA_INTF_T* interface types Shuah Khan
@ 2019-03-27 2:24 ` Shuah Khan
2019-03-27 2:24 ` [PATCH v12 5/5] au0828: fix enable and disable source audio and video inconsistencies Shuah Khan
4 siblings, 0 replies; 10+ messages in thread
From: Shuah Khan @ 2019-03-27 2:24 UTC (permalink / raw)
To: mchehab, perex, tiwai, dan.carpenter, hverkuil
Cc: Shuah Khan, linux-media, linux-kernel, alsa-devel
Media Device Allocator API to allows multiple drivers share a media device.
This API solves a very common use-case for media devices where one physical
device (an USB stick) provides both audio and video. When such media device
exposes a standard USB Audio class, a proprietary Video class, two or more
independent drivers will share a single physical USB bridge. In such cases,
it is necessary to coordinate access to the shared resource.
Using this API, drivers can allocate a media device with the shared struct
device as the key. Once the media device is allocated by a driver, other
drivers can get a reference to it. The media device is released when all
the references are released.
Change the ALSA driver to use the Media Controller API to share media
resources with DVB, and V4L2 drivers on a AU0828 media device.
The Media Controller specific initialization is done after sound card is
registered. ALSA creates Media interface and entity function graph nodes
for Control, Mixer, PCM Playback, and PCM Capture devices.
snd_usb_hw_params() will call Media Controller enable source handler
interface to request the media resource. If resource request is granted,
it will release it from snd_usb_hw_free(). If resource is busy, -EBUSY is
returned.
Media specific cleanup is done in usb_audio_disconnect().
Reviewed-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Shuah Khan <shuah@kernel.org>
---
sound/usb/Kconfig | 4 +
sound/usb/Makefile | 2 +
sound/usb/card.c | 14 ++
sound/usb/card.h | 3 +
sound/usb/media.c | 327 +++++++++++++++++++++++++++++++++++++++
sound/usb/media.h | 74 +++++++++
sound/usb/mixer.h | 3 +
sound/usb/pcm.c | 29 +++-
sound/usb/quirks-table.h | 1 +
sound/usb/stream.c | 2 +
sound/usb/usbaudio.h | 6 +
11 files changed, 461 insertions(+), 4 deletions(-)
create mode 100644 sound/usb/media.c
create mode 100644 sound/usb/media.h
diff --git a/sound/usb/Kconfig b/sound/usb/Kconfig
index f61b5662bb89..6319b544ba3a 100644
--- a/sound/usb/Kconfig
+++ b/sound/usb/Kconfig
@@ -15,6 +15,7 @@ config SND_USB_AUDIO
select SND_RAWMIDI
select SND_PCM
select BITREVERSE
+ select SND_USB_AUDIO_USE_MEDIA_CONTROLLER if MEDIA_CONTROLLER && (MEDIA_SUPPORT=y || MEDIA_SUPPORT=SND_USB_AUDIO)
help
Say Y here to include support for USB audio and USB MIDI
devices.
@@ -22,6 +23,9 @@ config SND_USB_AUDIO
To compile this driver as a module, choose M here: the module
will be called snd-usb-audio.
+config SND_USB_AUDIO_USE_MEDIA_CONTROLLER
+ bool
+
config SND_USB_UA101
tristate "Edirol UA-101/UA-1000 driver"
select SND_PCM
diff --git a/sound/usb/Makefile b/sound/usb/Makefile
index d330f74c90e6..e1ce257ab705 100644
--- a/sound/usb/Makefile
+++ b/sound/usb/Makefile
@@ -18,6 +18,8 @@ snd-usb-audio-objs := card.o \
quirks.o \
stream.o
+snd-usb-audio-$(CONFIG_SND_USB_AUDIO_USE_MEDIA_CONTROLLER) += media.o
+
snd-usbmidi-lib-objs := midi.o
# Toplevel Module Dependency
diff --git a/sound/usb/card.c b/sound/usb/card.c
index 719e10034553..04465d581204 100644
--- a/sound/usb/card.c
+++ b/sound/usb/card.c
@@ -68,6 +68,7 @@
#include "format.h"
#include "power.h"
#include "stream.h"
+#include "media.h"
MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
MODULE_DESCRIPTION("USB Audio");
@@ -673,6 +674,11 @@ static int usb_audio_probe(struct usb_interface *intf,
if (err < 0)
goto __error;
+ if (quirk && quirk->shares_media_device) {
+ /* don't want to fail when snd_media_device_create() fails */
+ snd_media_device_create(chip, intf);
+ }
+
usb_chip[chip->index] = chip;
chip->num_interfaces++;
usb_set_intfdata(intf, chip);
@@ -732,6 +738,14 @@ static void usb_audio_disconnect(struct usb_interface *intf)
list_for_each(p, &chip->midi_list) {
snd_usbmidi_disconnect(p);
}
+ /*
+ * Nice to check quirk && quirk->shares_media_device and
+ * then call the snd_media_device_delete(). Don't have
+ * access to the quirk here. snd_media_device_delete()
+ * accesses mixer_list
+ */
+ snd_media_device_delete(chip);
+
/* release mixer resources */
list_for_each_entry(mixer, &chip->mixer_list, list) {
snd_usb_mixer_disconnect(mixer);
diff --git a/sound/usb/card.h b/sound/usb/card.h
index 79fa2a19fb7b..2991b9986f66 100644
--- a/sound/usb/card.h
+++ b/sound/usb/card.h
@@ -109,6 +109,8 @@ struct snd_usb_endpoint {
struct list_head list;
};
+struct media_ctl;
+
struct snd_usb_substream {
struct snd_usb_stream *stream;
struct usb_device *dev;
@@ -161,6 +163,7 @@ struct snd_usb_substream {
} dsd_dop;
bool trigger_tstamp_pending_update; /* trigger timestamp being updated from initial estimate */
+ struct media_ctl *media_ctl;
};
struct snd_usb_stream {
diff --git a/sound/usb/media.c b/sound/usb/media.c
new file mode 100644
index 000000000000..776c83a670dc
--- /dev/null
+++ b/sound/usb/media.c
@@ -0,0 +1,327 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * media.c - Media Controller specific ALSA driver code
+ *
+ * Copyright (c) 2018 Shuah Khan <shuah@kernel.org>
+ *
+ */
+
+/*
+ * This file adds Media Controller support to the ALSA driver
+ * to use the Media Controller API to share the tuner with DVB
+ * and V4L2 drivers that control the media device.
+ *
+ * The media device is created based on the existing quirks framework.
+ * Using this approach, the media controller API usage can be added for
+ * a specific device.
+ */
+
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/mutex.h>
+#include <linux/slab.h>
+#include <linux/usb.h>
+
+#include <sound/pcm.h>
+#include <sound/core.h>
+
+#include "usbaudio.h"
+#include "card.h"
+#include "mixer.h"
+#include "media.h"
+
+int snd_media_stream_init(struct snd_usb_substream *subs, struct snd_pcm *pcm,
+ int stream)
+{
+ struct media_device *mdev;
+ struct media_ctl *mctl;
+ struct device *pcm_dev = &pcm->streams[stream].dev;
+ u32 intf_type;
+ int ret = 0;
+ u16 mixer_pad;
+ struct media_entity *entity;
+
+ mdev = subs->stream->chip->media_dev;
+ if (!mdev)
+ return 0;
+
+ if (subs->media_ctl)
+ return 0;
+
+ /* allocate media_ctl */
+ mctl = kzalloc(sizeof(*mctl), GFP_KERNEL);
+ if (!mctl)
+ return -ENOMEM;
+
+ mctl->media_dev = mdev;
+ if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
+ intf_type = MEDIA_INTF_T_ALSA_PCM_PLAYBACK;
+ mctl->media_entity.function = MEDIA_ENT_F_AUDIO_PLAYBACK;
+ mctl->media_pad.flags = MEDIA_PAD_FL_SOURCE;
+ mixer_pad = 1;
+ } else {
+ intf_type = MEDIA_INTF_T_ALSA_PCM_CAPTURE;
+ mctl->media_entity.function = MEDIA_ENT_F_AUDIO_CAPTURE;
+ mctl->media_pad.flags = MEDIA_PAD_FL_SINK;
+ mixer_pad = 2;
+ }
+ mctl->media_entity.name = pcm->name;
+ media_entity_pads_init(&mctl->media_entity, 1, &mctl->media_pad);
+ ret = media_device_register_entity(mctl->media_dev,
+ &mctl->media_entity);
+ if (ret)
+ goto free_mctl;
+
+ mctl->intf_devnode = media_devnode_create(mdev, intf_type, 0,
+ MAJOR(pcm_dev->devt),
+ MINOR(pcm_dev->devt));
+ if (!mctl->intf_devnode) {
+ ret = -ENOMEM;
+ goto unregister_entity;
+ }
+ mctl->intf_link = media_create_intf_link(&mctl->media_entity,
+ &mctl->intf_devnode->intf,
+ MEDIA_LNK_FL_ENABLED);
+ if (!mctl->intf_link) {
+ ret = -ENOMEM;
+ goto devnode_remove;
+ }
+
+ /* create link between mixer and audio */
+ media_device_for_each_entity(entity, mdev) {
+ switch (entity->function) {
+ case MEDIA_ENT_F_AUDIO_MIXER:
+ ret = media_create_pad_link(entity, mixer_pad,
+ &mctl->media_entity, 0,
+ MEDIA_LNK_FL_ENABLED);
+ if (ret)
+ goto remove_intf_link;
+ break;
+ }
+ }
+
+ subs->media_ctl = mctl;
+ return 0;
+
+remove_intf_link:
+ media_remove_intf_link(mctl->intf_link);
+devnode_remove:
+ media_devnode_remove(mctl->intf_devnode);
+unregister_entity:
+ media_device_unregister_entity(&mctl->media_entity);
+free_mctl:
+ kfree(mctl);
+ return ret;
+}
+
+void snd_media_stream_delete(struct snd_usb_substream *subs)
+{
+ struct media_ctl *mctl = subs->media_ctl;
+
+ if (mctl) {
+ struct media_device *mdev;
+
+ mdev = mctl->media_dev;
+ if (mdev && media_devnode_is_registered(mdev->devnode)) {
+ media_devnode_remove(mctl->intf_devnode);
+ media_device_unregister_entity(&mctl->media_entity);
+ media_entity_cleanup(&mctl->media_entity);
+ }
+ kfree(mctl);
+ subs->media_ctl = NULL;
+ }
+}
+
+int snd_media_start_pipeline(struct snd_usb_substream *subs)
+{
+ struct media_ctl *mctl = subs->media_ctl;
+ int ret = 0;
+
+ if (!mctl)
+ return 0;
+
+ mutex_lock(&mctl->media_dev->graph_mutex);
+ if (mctl->media_dev->enable_source)
+ ret = mctl->media_dev->enable_source(&mctl->media_entity,
+ &mctl->media_pipe);
+ mutex_unlock(&mctl->media_dev->graph_mutex);
+ return ret;
+}
+
+void snd_media_stop_pipeline(struct snd_usb_substream *subs)
+{
+ struct media_ctl *mctl = subs->media_ctl;
+
+ if (!mctl)
+ return;
+
+ mutex_lock(&mctl->media_dev->graph_mutex);
+ if (mctl->media_dev->disable_source)
+ mctl->media_dev->disable_source(&mctl->media_entity);
+ mutex_unlock(&mctl->media_dev->graph_mutex);
+}
+
+static int snd_media_mixer_init(struct snd_usb_audio *chip)
+{
+ struct device *ctl_dev = &chip->card->ctl_dev;
+ struct media_intf_devnode *ctl_intf;
+ struct usb_mixer_interface *mixer;
+ struct media_device *mdev = chip->media_dev;
+ struct media_mixer_ctl *mctl;
+ u32 intf_type = MEDIA_INTF_T_ALSA_CONTROL;
+ int ret;
+
+ if (!mdev)
+ return -ENODEV;
+
+ ctl_intf = chip->ctl_intf_media_devnode;
+ if (!ctl_intf) {
+ ctl_intf = media_devnode_create(mdev, intf_type, 0,
+ MAJOR(ctl_dev->devt),
+ MINOR(ctl_dev->devt));
+ if (!ctl_intf)
+ return -ENOMEM;
+ chip->ctl_intf_media_devnode = ctl_intf;
+ }
+
+ list_for_each_entry(mixer, &chip->mixer_list, list) {
+
+ if (mixer->media_mixer_ctl)
+ continue;
+
+ /* allocate media_mixer_ctl */
+ mctl = kzalloc(sizeof(*mctl), GFP_KERNEL);
+ if (!mctl)
+ return -ENOMEM;
+
+ mctl->media_dev = mdev;
+ mctl->media_entity.function = MEDIA_ENT_F_AUDIO_MIXER;
+ mctl->media_entity.name = chip->card->mixername;
+ mctl->media_pad[0].flags = MEDIA_PAD_FL_SINK;
+ mctl->media_pad[1].flags = MEDIA_PAD_FL_SOURCE;
+ mctl->media_pad[2].flags = MEDIA_PAD_FL_SOURCE;
+ media_entity_pads_init(&mctl->media_entity, MEDIA_MIXER_PAD_MAX,
+ mctl->media_pad);
+ ret = media_device_register_entity(mctl->media_dev,
+ &mctl->media_entity);
+ if (ret) {
+ kfree(mctl);
+ return ret;
+ }
+
+ mctl->intf_link = media_create_intf_link(&mctl->media_entity,
+ &ctl_intf->intf,
+ MEDIA_LNK_FL_ENABLED);
+ if (!mctl->intf_link) {
+ media_device_unregister_entity(&mctl->media_entity);
+ media_entity_cleanup(&mctl->media_entity);
+ kfree(mctl);
+ return -ENOMEM;
+ }
+ mctl->intf_devnode = ctl_intf;
+ mixer->media_mixer_ctl = mctl;
+ }
+ return 0;
+}
+
+static void snd_media_mixer_delete(struct snd_usb_audio *chip)
+{
+ struct usb_mixer_interface *mixer;
+ struct media_device *mdev = chip->media_dev;
+
+ if (!mdev)
+ return;
+
+ list_for_each_entry(mixer, &chip->mixer_list, list) {
+ struct media_mixer_ctl *mctl;
+
+ mctl = mixer->media_mixer_ctl;
+ if (!mixer->media_mixer_ctl)
+ continue;
+
+ if (media_devnode_is_registered(mdev->devnode)) {
+ media_device_unregister_entity(&mctl->media_entity);
+ media_entity_cleanup(&mctl->media_entity);
+ }
+ kfree(mctl);
+ mixer->media_mixer_ctl = NULL;
+ }
+ if (media_devnode_is_registered(mdev->devnode))
+ media_devnode_remove(chip->ctl_intf_media_devnode);
+ chip->ctl_intf_media_devnode = NULL;
+}
+
+int snd_media_device_create(struct snd_usb_audio *chip,
+ struct usb_interface *iface)
+{
+ struct media_device *mdev;
+ struct usb_device *usbdev = interface_to_usbdev(iface);
+ int ret = 0;
+
+ /* usb-audio driver is probed for each usb interface, and
+ * there are multiple interfaces per device. Avoid calling
+ * media_device_usb_allocate() each time usb_audio_probe()
+ * is called. Do it only once.
+ */
+ if (chip->media_dev) {
+ mdev = chip->media_dev;
+ goto snd_mixer_init;
+ }
+
+ mdev = media_device_usb_allocate(usbdev, KBUILD_MODNAME);
+ if (IS_ERR(mdev))
+ return -ENOMEM;
+
+ /* save media device - avoid lookups */
+ chip->media_dev = mdev;
+
+snd_mixer_init:
+ /* Create media entities for mixer and control dev */
+ ret = snd_media_mixer_init(chip);
+ /* media_device might be registered, print error and continue */
+ if (ret)
+ dev_err(&usbdev->dev,
+ "Couldn't create media mixer entities. Error: %d\n",
+ ret);
+
+ if (!media_devnode_is_registered(mdev->devnode)) {
+ /* dont'register if snd_media_mixer_init() failed */
+ if (ret)
+ goto create_fail;
+
+ /* register media_device */
+ ret = media_device_register(mdev);
+create_fail:
+ if (ret) {
+ snd_media_mixer_delete(chip);
+ media_device_delete(mdev, KBUILD_MODNAME);
+ /* clear saved media_dev */
+ chip->media_dev = NULL;
+ dev_err(&usbdev->dev,
+ "Couldn't register media device. Error: %d\n",
+ ret);
+ return ret;
+ }
+ }
+
+ return ret;
+}
+
+void snd_media_device_delete(struct snd_usb_audio *chip)
+{
+ struct media_device *mdev = chip->media_dev;
+ struct snd_usb_stream *stream;
+
+ /* release resources */
+ list_for_each_entry(stream, &chip->pcm_list, list) {
+ snd_media_stream_delete(&stream->substream[0]);
+ snd_media_stream_delete(&stream->substream[1]);
+ }
+
+ snd_media_mixer_delete(chip);
+
+ if (mdev) {
+ media_device_delete(mdev, KBUILD_MODNAME);
+ chip->media_dev = NULL;
+ }
+}
diff --git a/sound/usb/media.h b/sound/usb/media.h
new file mode 100644
index 000000000000..0e8a4785f858
--- /dev/null
+++ b/sound/usb/media.h
@@ -0,0 +1,74 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * media.h - Media Controller specific ALSA driver code
+ *
+ * Copyright (c) 2018 Shuah Khan <shuah@kernel.org>
+ *
+ */
+
+/*
+ * This file adds Media Controller support to the ALSA driver
+ * to use the Media Controller API to share the tuner with DVB
+ * and V4L2 drivers that control the media device.
+ *
+ * The media device is created based on the existing quirks framework.
+ * Using this approach, the media controller API usage can be added for
+ * a specific device.
+ */
+#ifndef __MEDIA_H
+
+#ifdef CONFIG_SND_USB_AUDIO_USE_MEDIA_CONTROLLER
+
+#include <linux/media.h>
+#include <media/media-device.h>
+#include <media/media-entity.h>
+#include <media/media-dev-allocator.h>
+#include <sound/asound.h>
+
+struct media_ctl {
+ struct media_device *media_dev;
+ struct media_entity media_entity;
+ struct media_intf_devnode *intf_devnode;
+ struct media_link *intf_link;
+ struct media_pad media_pad;
+ struct media_pipeline media_pipe;
+};
+
+/*
+ * One source pad each for SNDRV_PCM_STREAM_CAPTURE and
+ * SNDRV_PCM_STREAM_PLAYBACK. One for sink pad to link
+ * to AUDIO Source
+ */
+#define MEDIA_MIXER_PAD_MAX (SNDRV_PCM_STREAM_LAST + 2)
+
+struct media_mixer_ctl {
+ struct media_device *media_dev;
+ struct media_entity media_entity;
+ struct media_intf_devnode *intf_devnode;
+ struct media_link *intf_link;
+ struct media_pad media_pad[MEDIA_MIXER_PAD_MAX];
+ struct media_pipeline media_pipe;
+};
+
+int snd_media_device_create(struct snd_usb_audio *chip,
+ struct usb_interface *iface);
+void snd_media_device_delete(struct snd_usb_audio *chip);
+int snd_media_stream_init(struct snd_usb_substream *subs, struct snd_pcm *pcm,
+ int stream);
+void snd_media_stream_delete(struct snd_usb_substream *subs);
+int snd_media_start_pipeline(struct snd_usb_substream *subs);
+void snd_media_stop_pipeline(struct snd_usb_substream *subs);
+#else
+static inline int snd_media_device_create(struct snd_usb_audio *chip,
+ struct usb_interface *iface)
+ { return 0; }
+static inline void snd_media_device_delete(struct snd_usb_audio *chip) { }
+static inline int snd_media_stream_init(struct snd_usb_substream *subs,
+ struct snd_pcm *pcm, int stream)
+ { return 0; }
+static inline void snd_media_stream_delete(struct snd_usb_substream *subs) { }
+static inline int snd_media_start_pipeline(struct snd_usb_substream *subs)
+ { return 0; }
+static inline void snd_media_stop_pipeline(struct snd_usb_substream *subs) { }
+#endif
+#endif /* __MEDIA_H */
diff --git a/sound/usb/mixer.h b/sound/usb/mixer.h
index 3d12af8bf191..394cd9107507 100644
--- a/sound/usb/mixer.h
+++ b/sound/usb/mixer.h
@@ -4,6 +4,8 @@
#include <sound/info.h>
+struct media_mixer_ctl;
+
struct usb_mixer_interface {
struct snd_usb_audio *chip;
struct usb_host_interface *hostif;
@@ -23,6 +25,7 @@ struct usb_mixer_interface {
struct urb *rc_urb;
struct usb_ctrlrequest *rc_setup_packet;
u8 rc_buffer[6];
+ struct media_mixer_ctl *media_mixer_ctl;
bool disconnected;
};
diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c
index 056af0a57b22..5d8494b2a026 100644
--- a/sound/usb/pcm.c
+++ b/sound/usb/pcm.c
@@ -35,6 +35,7 @@
#include "pcm.h"
#include "clock.h"
#include "power.h"
+#include "media.h"
#define SUBSTREAM_FLAG_DATA_EP_STARTED 0
#define SUBSTREAM_FLAG_SYNC_EP_STARTED 1
@@ -787,6 +788,10 @@ static int snd_usb_hw_params(struct snd_pcm_substream *substream,
struct audioformat *fmt;
int ret;
+ ret = snd_media_start_pipeline(subs);
+ if (ret)
+ return ret;
+
if (snd_usb_use_vmalloc)
ret = snd_pcm_lib_alloc_vmalloc_buffer(substream,
params_buffer_bytes(hw_params));
@@ -794,7 +799,7 @@ static int snd_usb_hw_params(struct snd_pcm_substream *substream,
ret = snd_pcm_lib_malloc_pages(substream,
params_buffer_bytes(hw_params));
if (ret < 0)
- return ret;
+ goto stop_pipeline;
subs->pcm_format = params_format(hw_params);
subs->period_bytes = params_period_bytes(hw_params);
@@ -808,12 +813,13 @@ static int snd_usb_hw_params(struct snd_pcm_substream *substream,
dev_dbg(&subs->dev->dev,
"cannot set format: format = %#x, rate = %d, channels = %d\n",
subs->pcm_format, subs->cur_rate, subs->channels);
- return -EINVAL;
+ ret = -EINVAL;
+ goto stop_pipeline;
}
ret = snd_usb_lock_shutdown(subs->stream->chip);
if (ret < 0)
- return ret;
+ goto stop_pipeline;
ret = snd_usb_pcm_change_state(subs, UAC3_PD_STATE_D0);
if (ret < 0)
@@ -829,6 +835,12 @@ static int snd_usb_hw_params(struct snd_pcm_substream *substream,
unlock:
snd_usb_unlock_shutdown(subs->stream->chip);
+ if (ret < 0)
+ goto stop_pipeline;
+ return ret;
+
+ stop_pipeline:
+ snd_media_stop_pipeline(subs);
return ret;
}
@@ -841,6 +853,7 @@ static int snd_usb_hw_free(struct snd_pcm_substream *substream)
{
struct snd_usb_substream *subs = substream->runtime->private_data;
+ snd_media_stop_pipeline(subs);
subs->cur_audiofmt = NULL;
subs->cur_rate = 0;
subs->period_bytes = 0;
@@ -1313,6 +1326,7 @@ static int snd_usb_pcm_open(struct snd_pcm_substream *substream)
struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
struct snd_pcm_runtime *runtime = substream->runtime;
struct snd_usb_substream *subs = &as->substream[direction];
+ int ret;
subs->interface = -1;
subs->altset_idx = 0;
@@ -1326,7 +1340,13 @@ static int snd_usb_pcm_open(struct snd_pcm_substream *substream)
subs->dsd_dop.channel = 0;
subs->dsd_dop.marker = 1;
- return setup_hw_info(runtime, subs);
+ ret = setup_hw_info(runtime, subs);
+ if (ret == 0) {
+ ret = snd_media_stream_init(subs, as->pcm, direction);
+ if (ret)
+ snd_usb_autosuspend(subs->stream->chip);
+ }
+ return ret;
}
static int snd_usb_pcm_close(struct snd_pcm_substream *substream)
@@ -1337,6 +1357,7 @@ static int snd_usb_pcm_close(struct snd_pcm_substream *substream)
int ret;
stop_endpoints(subs, true);
+ snd_media_stop_pipeline(subs);
if (!as->chip->keep_iface &&
subs->interface >= 0 &&
diff --git a/sound/usb/quirks-table.h b/sound/usb/quirks-table.h
index 86e80916a029..8cbca137ee6f 100644
--- a/sound/usb/quirks-table.h
+++ b/sound/usb/quirks-table.h
@@ -2887,6 +2887,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
.product_name = pname, \
.ifnum = QUIRK_ANY_INTERFACE, \
.type = QUIRK_AUDIO_ALIGN_TRANSFER, \
+ .shares_media_device = 1, \
} \
}
diff --git a/sound/usb/stream.c b/sound/usb/stream.c
index d9e3de495c16..9f1623e37fb3 100644
--- a/sound/usb/stream.c
+++ b/sound/usb/stream.c
@@ -38,6 +38,7 @@
#include "clock.h"
#include "stream.h"
#include "power.h"
+#include "media.h"
/*
* free a substream
@@ -55,6 +56,7 @@ static void free_substream(struct snd_usb_substream *subs)
}
kfree(subs->rate_list.list);
kfree(subs->str_pd);
+ snd_media_stream_delete(subs);
}
diff --git a/sound/usb/usbaudio.h b/sound/usb/usbaudio.h
index b9faeca645fd..0968a45c8925 100644
--- a/sound/usb/usbaudio.h
+++ b/sound/usb/usbaudio.h
@@ -30,6 +30,9 @@
*
*/
+struct media_device;
+struct media_intf_devnode;
+
struct snd_usb_audio {
int index;
struct usb_device *dev;
@@ -66,6 +69,8 @@ struct snd_usb_audio {
*/
struct usb_host_interface *ctrl_intf; /* the audio control interface */
+ struct media_device *media_dev;
+ struct media_intf_devnode *ctl_intf_media_devnode;
};
#define usb_audio_err(chip, fmt, args...) \
@@ -117,6 +122,7 @@ struct snd_usb_audio_quirk {
const char *profile_name; /* override the card->longname */
int16_t ifnum;
uint16_t type;
+ bool shares_media_device;
const void *data;
};
--
2.17.1
^ permalink raw reply related [flat|nested] 10+ messages in thread* [PATCH v12 5/5] au0828: fix enable and disable source audio and video inconsistencies
2019-03-27 2:24 [PATCH v12 0/5] Media Device Allocator API Shuah Khan
` (3 preceding siblings ...)
2019-03-27 2:24 ` [PATCH v12 4/5] sound/usb: Use Media Controller API to share media resources Shuah Khan
@ 2019-03-27 2:24 ` Shuah Khan
4 siblings, 0 replies; 10+ messages in thread
From: Shuah Khan @ 2019-03-27 2:24 UTC (permalink / raw)
To: mchehab, perex, tiwai, hverkuil
Cc: Shuah Khan, linux-media, linux-kernel, alsa-devel
Enable and disable source interfaces aren't consistent in enforcing
how video and audio share the tuner resource.
Fix these issues to enforce the following rules and allow
sharing between audio and video applications.
- When DVB is streaming, audio/video/vbi/s-video/composite
should find the resource busy. DVB holds the tuner in
exclusive mode.
- When video is streaming, audio can share the tuner and vice versa.
- v4l2 allows multiple applications to open video device.
- Video applications call enable source multiple times during their
run-time. Resource should stay locked until the last application
releases it.
- A shared resource should stay in shared state and locked when it is
in use by audio and video. More than one video application is allowed
to use the tuner as long as video streaming protocol allows such usage.
Resource is released when the last video/audio application releases it.
- S-Video and Composite hold the resource in exclusive mode.
- VBI allows more than vbi applications sharing and will not share
with another type. When resource is locked by VBI and in use by
multiple VBI applications, it should stay locked until the last
application disables it.
Signed-off-by: Shuah Khan <shuah@kernel.org>
---
drivers/media/usb/au0828/au0828-core.c | 182 +++++++++++++++++++------
drivers/media/usb/au0828/au0828.h | 5 +-
2 files changed, 148 insertions(+), 39 deletions(-)
diff --git a/drivers/media/usb/au0828/au0828-core.c b/drivers/media/usb/au0828/au0828-core.c
index 8167e50b7bc4..7652ddb5042a 100644
--- a/drivers/media/usb/au0828/au0828-core.c
+++ b/drivers/media/usb/au0828/au0828-core.c
@@ -272,6 +272,27 @@ static void au0828_media_graph_notify(struct media_entity *new,
}
}
+static bool au0828_is_link_sharable(struct media_entity *owner,
+ struct media_entity *entity)
+{
+ bool sharable = false;
+
+ /* Tuner link can be shared by audio and video */
+ switch (owner->function) {
+ case MEDIA_ENT_F_IO_V4L:
+ case MEDIA_ENT_F_AUDIO_CAPTURE:
+ if (entity->function == MEDIA_ENT_F_IO_V4L ||
+ entity->function == MEDIA_ENT_F_AUDIO_CAPTURE)
+ sharable = true;
+ break;
+ case MEDIA_ENT_F_DTV_DEMOD:
+ case MEDIA_ENT_F_IO_VBI:
+ default:
+ break;
+ }
+ return sharable;
+}
+
/* Callers should hold graph_mutex */
static int au0828_enable_source(struct media_entity *entity,
struct media_pipeline *pipe)
@@ -314,18 +335,20 @@ static int au0828_enable_source(struct media_entity *entity,
/*
* Default input is tuner and default input_type
* is AU0828_VMUX_TELEVISION.
- * FIXME:
+ *
* There is a problem when s_input is called to
* change the default input. s_input will try to
* enable_source before attempting to change the
* input on the device, and will end up enabling
* default source which is tuner.
*
- * Additional logic is necessary in au0828
- * to detect that the input has changed and
- * enable the right source.
+ * Additional logic is necessary in au0828 to detect
+ * that the input has changed and enable the right
+ * source. au0828 handles this case in its s_input.
+ * It will disable the old source and enable the new
+ * source.
+ *
*/
-
if (dev->input_type == AU0828_VMUX_TELEVISION)
find_source = dev->tuner;
else if (dev->input_type == AU0828_VMUX_SVIDEO ||
@@ -338,27 +361,33 @@ static int au0828_enable_source(struct media_entity *entity,
}
}
- /* Is an active link between sink and source */
+ /* Is there an active link between sink and source */
if (dev->active_link) {
- /*
- * If DVB is using the tuner and calling entity is
- * audio/video, the following check will be false,
- * since sink is different. Result is Busy.
- */
- if (dev->active_link->sink->entity == sink &&
- dev->active_link->source->entity == find_source) {
- /*
- * Either ALSA or Video own tuner. sink is
- * the same for both. Prevent Video stepping
- * on ALSA when ALSA owns the source.
+ if (dev->active_link_owner == entity) {
+ /* This check is necessary to handle multiple
+ * enable_source calls from v4l_ioctls during
+ * the course of video/vbi application run-time.
*/
- if (dev->active_link_owner != entity &&
- dev->active_link_owner->function ==
- MEDIA_ENT_F_AUDIO_CAPTURE) {
- pr_debug("ALSA has the tuner\n");
- ret = -EBUSY;
- goto end;
- }
+ pr_debug("%s already owns the tuner\n", entity->name);
+ ret = 0;
+ goto end;
+ } else if (au0828_is_link_sharable(dev->active_link_owner,
+ entity)) {
+ /* Either ALSA or Video own tuner. Sink is the same
+ * for both. Allow sharing the active link between
+ * their common source (tuner) and sink (decoder).
+ * Starting pipeline between sharing entity and sink
+ * will fail with pipe mismatch, while owner has an
+ * active pipeline. Switch pipeline ownership from
+ * user to owner when owner disables the source.
+ */
+ dev->active_link_shared = true;
+ /* save the user info to use from disable */
+ dev->active_link_user = entity;
+ dev->active_link_user_pipe = pipe;
+ pr_debug("%s owns the tuner %s can share!\n",
+ dev->active_link_owner->name,
+ entity->name);
ret = 0;
goto end;
} else {
@@ -385,7 +414,7 @@ static int au0828_enable_source(struct media_entity *entity,
source = found_link->source->entity;
ret = __media_entity_setup_link(found_link, MEDIA_LNK_FL_ENABLED);
if (ret) {
- pr_err("Activate tuner link %s->%s. Error %d\n",
+ pr_err("Activate link from %s->%s. Error %d\n",
source->name, sink->name, ret);
goto end;
}
@@ -395,25 +424,26 @@ static int au0828_enable_source(struct media_entity *entity,
pr_err("Start Pipeline: %s->%s Error %d\n",
source->name, entity->name, ret);
ret = __media_entity_setup_link(found_link, 0);
- pr_err("Deactivate link Error %d\n", ret);
+ if (ret)
+ pr_err("Deactivate link Error %d\n", ret);
goto end;
}
- /*
- * save active link and active link owner to avoid audio
- * deactivating video owned link from disable_source and
- * vice versa
+
+ /* save link state to allow audio and video share the link
+ * and not disable the link while the other is using it.
+ * active_link_owner is used to deactivate the link.
*/
dev->active_link = found_link;
dev->active_link_owner = entity;
dev->active_source = source;
dev->active_sink = sink;
- pr_debug("Enabled Source: %s->%s->%s Ret %d\n",
+ pr_info("Enabled Source: %s->%s->%s Ret %d\n",
dev->active_source->name, dev->active_sink->name,
dev->active_link_owner->name, ret);
end:
- pr_debug("au0828_enable_source() end %s %d %d\n",
- entity->name, entity->function, ret);
+ pr_debug("%s end: ent:%s fnc:%d ret %d\n",
+ __func__, entity->name, entity->function, ret);
return ret;
}
@@ -432,21 +462,95 @@ static void au0828_disable_source(struct media_entity *entity)
if (!dev->active_link)
return;
- /* link is active - stop pipeline from source (tuner) */
+ /* link is active - stop pipeline from source
+ * (tuner/s-video/Composite) to the entity
+ * When DVB/s-video/Composite owns tuner, it won't be in
+ * shared state.
+ */
if (dev->active_link->sink->entity == dev->active_sink &&
dev->active_link->source->entity == dev->active_source) {
/*
- * prevent video from deactivating link when audio
- * has active pipeline
+ * Prevent video from deactivating link when audio
+ * has active pipeline and vice versa. In addition
+ * handle the case when more than one video/vbi
+ * application is sharing the link.
*/
+ bool owner_is_audio = false;
+
+ if (dev->active_link_owner->function ==
+ MEDIA_ENT_F_AUDIO_CAPTURE)
+ owner_is_audio = true;
+
+ if (dev->active_link_shared) {
+ pr_debug("Shared link owner %s user %s %d\n",
+ dev->active_link_owner->name,
+ entity->name, dev->users);
+
+ /* Handle video device users > 1
+ * When audio owns the shared link with
+ * more than one video users, avoid
+ * disabling the source and/or switching
+ * the owner until the last disable_source
+ * call from video _close(). Use dev->users to
+ * determine when to switch/disable.
+ */
+ if (dev->active_link_owner != entity) {
+ /* video device has users > 1 */
+ if (owner_is_audio && dev->users > 1)
+ return;
+
+ dev->active_link_user = NULL;
+ dev->active_link_user_pipe = NULL;
+ dev->active_link_shared = false;
+ return;
+ }
+
+ /* video owns the link and has users > 1 */
+ if (!owner_is_audio && dev->users > 1)
+ return;
+
+ /* stop pipeline */
+ __media_pipeline_stop(dev->active_link_owner);
+ pr_debug("Pipeline stop for %s\n",
+ dev->active_link_owner->name);
+
+ ret = __media_pipeline_start(
+ dev->active_link_user,
+ dev->active_link_user_pipe);
+ if (ret) {
+ pr_err("Start Pipeline: %s->%s %d\n",
+ dev->active_source->name,
+ dev->active_link_user->name,
+ ret);
+ goto deactivate_link;
+ }
+ /* link user is now the owner */
+ dev->active_link_owner = dev->active_link_user;
+ dev->active_link_user = NULL;
+ dev->active_link_user_pipe = NULL;
+ dev->active_link_shared = false;
+
+ pr_debug("Pipeline started for %s\n",
+ dev->active_link_owner->name);
+ return;
+ } else if (!owner_is_audio && dev->users > 1)
+ /* video/vbi owns the link and has users > 1 */
+ return;
+
if (dev->active_link_owner != entity)
return;
- __media_pipeline_stop(entity);
+
+ /* stop pipeline */
+ __media_pipeline_stop(dev->active_link_owner);
+ pr_debug("Pipeline stop for %s\n",
+ dev->active_link_owner->name);
+
+deactivate_link:
ret = __media_entity_setup_link(dev->active_link, 0);
if (ret)
pr_err("Deactivate link Error %d\n", ret);
- pr_debug("Disabled Source: %s->%s->%s Ret %d\n",
+ pr_info("Disabled Source: %s->%s->%s Ret %d\n",
dev->active_source->name, dev->active_sink->name,
dev->active_link_owner->name, ret);
@@ -454,6 +558,8 @@ static void au0828_disable_source(struct media_entity *entity)
dev->active_link_owner = NULL;
dev->active_source = NULL;
dev->active_sink = NULL;
+ dev->active_link_shared = false;
+ dev->active_link_user = NULL;
}
}
#endif
diff --git a/drivers/media/usb/au0828/au0828.h b/drivers/media/usb/au0828/au0828.h
index 57b00de8d3f2..b47ecc9affd8 100644
--- a/drivers/media/usb/au0828/au0828.h
+++ b/drivers/media/usb/au0828/au0828.h
@@ -284,9 +284,12 @@ struct au0828_dev {
struct media_entity_notify entity_notify;
struct media_entity *tuner;
struct media_link *active_link;
- struct media_entity *active_link_owner;
struct media_entity *active_source;
struct media_entity *active_sink;
+ struct media_entity *active_link_owner;
+ struct media_entity *active_link_user;
+ struct media_pipeline *active_link_user_pipe;
+ bool active_link_shared;
#endif
};
--
2.17.1
^ permalink raw reply related [flat|nested] 10+ messages in thread