[media] Revert "[media] sound/usb: Use Media Controller API to share media resources" (c89178f5) · Commits · 戴 / test

sound/usb/Kconfig

+0 −4

Original line number	Diff line number	Diff line
		@@ -15,7 +15,6 @@ 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.
		@@ -23,9 +22,6 @@ 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

sound/usb/Makefile

+0 −2

Original line number	Diff line number	Diff line
		@@ -15,8 +15,6 @@ 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

sound/usb/card.c

+0 −14

Original line number	Diff line number	Diff line
		@@ -66,7 +66,6 @@
		#include "format.h"
		#include "power.h"
		#include "stream.h"
		#include "media.h"

		MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
		MODULE_DESCRIPTION("USB Audio");
		@@ -612,11 +611,6 @@ static int usb_audio_probe(struct usb_interface *intf,
		if (err < 0)
		goto __error;

		if (quirk->media_device) {
		/* don't want to fail when media_snd_device_create() fails */
		media_snd_device_create(chip, intf);
		}

		usb_chip[chip->index] = chip;
		chip->num_interfaces++;
		usb_set_intfdata(intf, chip);
		@@ -673,14 +667,6 @@ 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->media_device
		* need some special handlings. Doesn't look like
		* we have access to quirk here
		* Acceses mixer_list
		*/
		media_snd_device_delete(chip);

		/* release mixer resources */
		list_for_each_entry(mixer, &chip->mixer_list, list) {
		snd_usb_mixer_disconnect(mixer);

sound/usb/card.h

+0 −3

Original line number	Diff line number	Diff line
		@@ -105,8 +105,6 @@ struct snd_usb_endpoint {
		struct list_head list;
		};

		struct media_ctl;

		struct snd_usb_substream {
		struct snd_usb_stream *stream;
		struct usb_device *dev;
		@@ -158,7 +156,6 @@ 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 {

sound/usb/media.c

deleted100644 → 0

+0 −318

Original line number	Diff line number	Diff line
		/*
		* media.c - Media Controller specific ALSA driver code
		*
		* Copyright (c) 2016 Shuah Khan <shuahkh@osg.samsung.com>
		* Copyright (c) 2016 Samsung Electronics Co., Ltd.
		*
		* This file is released under the GPLv2.
		*/

		/*
		* This file adds Media Controller support to ALSA driver
		* to use the Media Controller API to share tuner with DVB
		* and V4L2 drivers that control media device. Media device
		* is created based on 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"

		static int media_snd_enable_source(struct media_ctl *mctl)
		{
		if (mctl && mctl->media_dev->enable_source)
		return mctl->media_dev->enable_source(&mctl->media_entity,
		&mctl->media_pipe);
		return 0;
		}

		static void media_snd_disable_source(struct media_ctl *mctl)
		{
		if (mctl && mctl->media_dev->disable_source)
		mctl->media_dev->disable_source(&mctl->media_entity);
		}

		int media_snd_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 -ENODEV;

		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 media_snd_stream_delete(struct snd_usb_substream *subs)
		{
		struct media_ctl *mctl = subs->media_ctl;

		if (mctl && mctl->media_dev) {
		struct media_device *mdev;

		mdev = subs->stream->chip->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 media_snd_start_pipeline(struct snd_usb_substream *subs)
		{
		struct media_ctl *mctl = subs->media_ctl;

		if (mctl)
		return media_snd_enable_source(mctl);
		return 0;
		}

		void media_snd_stop_pipeline(struct snd_usb_substream *subs)
		{
		struct media_ctl *mctl = subs->media_ctl;

		if (mctl)
		media_snd_disable_source(mctl);
		}

		int media_snd_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 media_snd_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 media_snd_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;

		mdev = media_device_get_devres(&usbdev->dev);
		if (!mdev)
		return -ENOMEM;
		if (!mdev->dev) {
		/* register media device */
		mdev->dev = &usbdev->dev;
		if (usbdev->product)
		strlcpy(mdev->model, usbdev->product,
		sizeof(mdev->model));
		if (usbdev->serial)
		strlcpy(mdev->serial, usbdev->serial,
		sizeof(mdev->serial));
		strcpy(mdev->bus_info, usbdev->devpath);
		mdev->hw_revision = le16_to_cpu(usbdev->descriptor.bcdDevice);
		media_device_init(mdev);
		}
		if (!media_devnode_is_registered(&mdev->devnode)) {
		ret = media_device_register(mdev);
		if (ret) {
		dev_err(&usbdev->dev,
		"Couldn't register media device. Error: %d\n",
		ret);
		return ret;
		}
		}

		/* save media device - avoid lookups */
		chip->media_dev = mdev;

		/* Create media entities for mixer and control dev */
		ret = media_snd_mixer_init(chip);
		if (ret) {
		dev_err(&usbdev->dev,
		"Couldn't create media mixer entities. Error: %d\n",
		ret);

		/* clear saved media_dev */
		chip->media_dev = NULL;

		return ret;
		}
		return 0;
		}

		void media_snd_device_delete(struct snd_usb_audio *chip)
		{
		struct media_device *mdev = chip->media_dev;

		media_snd_mixer_delete(chip);

		if (mdev) {
		if (media_devnode_is_registered(&mdev->devnode))
		media_device_unregister(mdev);
		chip->media_dev = NULL;
		}
		}

Admin message