sound/usb/media.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /*
  * media.c - Media Controller specific ALSA driver code
  *
  * Copyright (c) 2019 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, THIS_MODULE);
 	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)) {
 		/* don't 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, THIS_MODULE);
 			/* 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, THIS_MODULE);
 		chip->media_dev = NULL;
 	}
 }
	// SPDX-License-Identifier: GPL-2.0
	/*
	* media.c - Media Controller specific ALSA driver code
	*
	* Copyright (c) 2019 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, THIS_MODULE);
	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)) {
	/* don't 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, THIS_MODULE);
	/* 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, THIS_MODULE);
	chip->media_dev = NULL;
	}
	}