sound/usb/media.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * media.c - Media Controller specific ALSA driver code
   4  *
   5  * Copyright (c) 2019 Shuah Khan <shuah@kernel.org>
   6  *
   7  */
   8
   9 /*
  10  * This file adds Media Controller support to the ALSA driver
  11  * to use the Media Controller API to share the tuner with DVB
  12  * and V4L2 drivers that control the media device.
  13  *
  14  * The media device is created based on the existing quirks framework.
  15  * Using this approach, the media controller API usage can be added for
  16  * a specific device.
  17  */
  18
  19 #include <linux/init.h>
  20 #include <linux/list.h>
  21 #include <linux/mutex.h>
  22 #include <linux/slab.h>
  23 #include <linux/usb.h>
  24
  25 #include <sound/pcm.h>
  26 #include <sound/core.h>
  27
  28 #include "usbaudio.h"
  29 #include "card.h"
  30 #include "mixer.h"
  31 #include "media.h"
  32
  33 int snd_media_stream_init(struct snd_usb_substream *subs, struct snd_pcm *pcm,
  34                           int stream)
  35 {
  36         struct media_device *mdev;
  37         struct media_ctl *mctl;
  38         struct device *pcm_dev = &pcm->streams[stream].dev;
  39         u32 intf_type;
  40         int ret = 0;
  41         u16 mixer_pad;
  42         struct media_entity *entity;
  43
  44         mdev = subs->stream->chip->media_dev;
  45         if (!mdev)
  46                 return 0;
  47
  48         if (subs->media_ctl)
  49                 return 0;
  50
  51         /* allocate media_ctl */
  52         mctl = kzalloc(sizeof(*mctl), GFP_KERNEL);
  53         if (!mctl)
  54                 return -ENOMEM;
  55
  56         mctl->media_dev = mdev;
  57         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
  58                 intf_type = MEDIA_INTF_T_ALSA_PCM_PLAYBACK;
  59                 mctl->media_entity.function = MEDIA_ENT_F_AUDIO_PLAYBACK;
  60                 mctl->media_pad.flags = MEDIA_PAD_FL_SOURCE;
  61                 mixer_pad = 1;
  62         } else {
  63                 intf_type = MEDIA_INTF_T_ALSA_PCM_CAPTURE;
  64                 mctl->media_entity.function = MEDIA_ENT_F_AUDIO_CAPTURE;
  65                 mctl->media_pad.flags = MEDIA_PAD_FL_SINK;
  66                 mixer_pad = 2;
  67         }
  68         mctl->media_entity.name = pcm->name;
  69         media_entity_pads_init(&mctl->media_entity, 1, &mctl->media_pad);
  70         ret =  media_device_register_entity(mctl->media_dev,
  71                                             &mctl->media_entity);
  72         if (ret)
  73                 goto free_mctl;
  74
  75         mctl->intf_devnode = media_devnode_create(mdev, intf_type, 0,
  76                                                   MAJOR(pcm_dev->devt),
  77                                                   MINOR(pcm_dev->devt));
  78         if (!mctl->intf_devnode) {
  79                 ret = -ENOMEM;
  80                 goto unregister_entity;
  81         }
  82         mctl->intf_link = media_create_intf_link(&mctl->media_entity,
  83                                                  &mctl->intf_devnode->intf,
  84                                                  MEDIA_LNK_FL_ENABLED);
  85         if (!mctl->intf_link) {
  86                 ret = -ENOMEM;
  87                 goto devnode_remove;
  88         }
  89
  90         /* create link between mixer and audio */
  91         media_device_for_each_entity(entity, mdev) {
  92                 switch (entity->function) {
  93                 case MEDIA_ENT_F_AUDIO_MIXER:
  94                         ret = media_create_pad_link(entity, mixer_pad,
  95                                                     &mctl->media_entity, 0,
  96                                                     MEDIA_LNK_FL_ENABLED);
  97                         if (ret)
  98                                 goto remove_intf_link;
  99                         break;
 100                 }
 101         }
 102
 103         subs->media_ctl = mctl;
 104         return 0;
 105
 106 remove_intf_link:
 107         media_remove_intf_link(mctl->intf_link);
 108 devnode_remove:
 109         media_devnode_remove(mctl->intf_devnode);
 110 unregister_entity:
 111         media_device_unregister_entity(&mctl->media_entity);
 112 free_mctl:
 113         kfree(mctl);
 114         return ret;
 115 }
 116
 117 void snd_media_stream_delete(struct snd_usb_substream *subs)
 118 {
 119         struct media_ctl *mctl = subs->media_ctl;
 120
 121         if (mctl) {
 122                 struct media_device *mdev;
 123
 124                 mdev = mctl->media_dev;
 125                 if (mdev && media_devnode_is_registered(mdev->devnode)) {
 126                         media_devnode_remove(mctl->intf_devnode);
 127                         media_device_unregister_entity(&mctl->media_entity);
 128                         media_entity_cleanup(&mctl->media_entity);
 129                 }
 130                 kfree(mctl);
 131                 subs->media_ctl = NULL;
 132         }
 133 }
 134
 135 int snd_media_start_pipeline(struct snd_usb_substream *subs)
 136 {
 137         struct media_ctl *mctl = subs->media_ctl;
 138         int ret = 0;
 139
 140         if (!mctl)
 141                 return 0;
 142
 143         mutex_lock(&mctl->media_dev->graph_mutex);
 144         if (mctl->media_dev->enable_source)
 145                 ret = mctl->media_dev->enable_source(&mctl->media_entity,
 146                                                      &mctl->media_pipe);
 147         mutex_unlock(&mctl->media_dev->graph_mutex);
 148         return ret;
 149 }
 150
 151 void snd_media_stop_pipeline(struct snd_usb_substream *subs)
 152 {
 153         struct media_ctl *mctl = subs->media_ctl;
 154
 155         if (!mctl)
 156                 return;
 157
 158         mutex_lock(&mctl->media_dev->graph_mutex);
 159         if (mctl->media_dev->disable_source)
 160                 mctl->media_dev->disable_source(&mctl->media_entity);
 161         mutex_unlock(&mctl->media_dev->graph_mutex);
 162 }
 163
 164 static int snd_media_mixer_init(struct snd_usb_audio *chip)
 165 {
 166         struct device *ctl_dev = &chip->card->ctl_dev;
 167         struct media_intf_devnode *ctl_intf;
 168         struct usb_mixer_interface *mixer;
 169         struct media_device *mdev = chip->media_dev;
 170         struct media_mixer_ctl *mctl;
 171         u32 intf_type = MEDIA_INTF_T_ALSA_CONTROL;
 172         int ret;
 173
 174         if (!mdev)
 175                 return -ENODEV;
 176
 177         ctl_intf = chip->ctl_intf_media_devnode;
 178         if (!ctl_intf) {
 179                 ctl_intf = media_devnode_create(mdev, intf_type, 0,
 180                                                 MAJOR(ctl_dev->devt),
 181                                                 MINOR(ctl_dev->devt));
 182                 if (!ctl_intf)
 183                         return -ENOMEM;
 184                 chip->ctl_intf_media_devnode = ctl_intf;
 185         }
 186
 187         list_for_each_entry(mixer, &chip->mixer_list, list) {
 188
 189                 if (mixer->media_mixer_ctl)
 190                         continue;
 191
 192                 /* allocate media_mixer_ctl */
 193                 mctl = kzalloc(sizeof(*mctl), GFP_KERNEL);
 194                 if (!mctl)
 195                         return -ENOMEM;
 196
 197                 mctl->media_dev = mdev;
 198                 mctl->media_entity.function = MEDIA_ENT_F_AUDIO_MIXER;
 199                 mctl->media_entity.name = chip->card->mixername;
 200                 mctl->media_pad[0].flags = MEDIA_PAD_FL_SINK;
 201                 mctl->media_pad[1].flags = MEDIA_PAD_FL_SOURCE;
 202                 mctl->media_pad[2].flags = MEDIA_PAD_FL_SOURCE;
 203                 media_entity_pads_init(&mctl->media_entity, MEDIA_MIXER_PAD_MAX,
 204                                   mctl->media_pad);
 205                 ret =  media_device_register_entity(mctl->media_dev,
 206                                                     &mctl->media_entity);
 207                 if (ret) {
 208                         kfree(mctl);
 209                         return ret;
 210                 }
 211
 212                 mctl->intf_link = media_create_intf_link(&mctl->media_entity,
 213                                                          &ctl_intf->intf,
 214                                                          MEDIA_LNK_FL_ENABLED);
 215                 if (!mctl->intf_link) {
 216                         media_device_unregister_entity(&mctl->media_entity);
 217                         media_entity_cleanup(&mctl->media_entity);
 218                         kfree(mctl);
 219                         return -ENOMEM;
 220                 }
 221                 mctl->intf_devnode = ctl_intf;
 222                 mixer->media_mixer_ctl = mctl;
 223         }
 224         return 0;
 225 }
 226
 227 static void snd_media_mixer_delete(struct snd_usb_audio *chip)
 228 {
 229         struct usb_mixer_interface *mixer;
 230         struct media_device *mdev = chip->media_dev;
 231
 232         if (!mdev)
 233                 return;
 234
 235         list_for_each_entry(mixer, &chip->mixer_list, list) {
 236                 struct media_mixer_ctl *mctl;
 237
 238                 mctl = mixer->media_mixer_ctl;
 239                 if (!mixer->media_mixer_ctl)
 240                         continue;
 241
 242                 if (media_devnode_is_registered(mdev->devnode)) {
 243                         media_device_unregister_entity(&mctl->media_entity);
 244                         media_entity_cleanup(&mctl->media_entity);
 245                 }
 246                 kfree(mctl);
 247                 mixer->media_mixer_ctl = NULL;
 248         }
 249         if (media_devnode_is_registered(mdev->devnode))
 250                 media_devnode_remove(chip->ctl_intf_media_devnode);
 251         chip->ctl_intf_media_devnode = NULL;
 252 }
 253
 254 int snd_media_device_create(struct snd_usb_audio *chip,
 255                         struct usb_interface *iface)
 256 {
 257         struct media_device *mdev;
 258         struct usb_device *usbdev = interface_to_usbdev(iface);
 259         int ret = 0;
 260
 261         /* usb-audio driver is probed for each usb interface, and
 262          * there are multiple interfaces per device. Avoid calling
 263          * media_device_usb_allocate() each time usb_audio_probe()
 264          * is called. Do it only once.
 265          */
 266         if (chip->media_dev) {
 267                 mdev = chip->media_dev;
 268                 goto snd_mixer_init;
 269         }
 270
 271         mdev = media_device_usb_allocate(usbdev, KBUILD_MODNAME, THIS_MODULE);
 272         if (IS_ERR(mdev))
 273                 return -ENOMEM;
 274
 275         /* save media device - avoid lookups */
 276         chip->media_dev = mdev;
 277
 278 snd_mixer_init:
 279         /* Create media entities for mixer and control dev */
 280         ret = snd_media_mixer_init(chip);
 281         /* media_device might be registered, print error and continue */
 282         if (ret)
 283                 dev_err(&usbdev->dev,
 284                         "Couldn't create media mixer entities. Error: %d\n",
 285                         ret);
 286
 287         if (!media_devnode_is_registered(mdev->devnode)) {
 288                 /* don't register if snd_media_mixer_init() failed */
 289                 if (ret)
 290                         goto create_fail;
 291
 292                 /* register media_device */
 293                 ret = media_device_register(mdev);
 294 create_fail:
 295                 if (ret) {
 296                         snd_media_mixer_delete(chip);
 297                         media_device_delete(mdev, KBUILD_MODNAME, THIS_MODULE);
 298                         /* clear saved media_dev */
 299                         chip->media_dev = NULL;
 300                         dev_err(&usbdev->dev,
 301                                 "Couldn't register media device. Error: %d\n",
 302                                 ret);
 303                         return ret;
 304                 }
 305         }
 306
 307         return ret;
 308 }
 309
 310 void snd_media_device_delete(struct snd_usb_audio *chip)
 311 {
 312         struct media_device *mdev = chip->media_dev;
 313         struct snd_usb_stream *stream;
 314
 315         /* release resources */
 316         list_for_each_entry(stream, &chip->pcm_list, list) {
 317                 snd_media_stream_delete(&stream->substream[0]);
 318                 snd_media_stream_delete(&stream->substream[1]);
 319         }
 320
 321         snd_media_mixer_delete(chip);
 322
 323         if (mdev) {
 324                 media_device_delete(mdev, KBUILD_MODNAME, THIS_MODULE);
 325                 chip->media_dev = NULL;
 326         }
 327 }