LCOV - code coverage report
Current view: top level - sound/core - pcm.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 117 412 28.4 %
Date: 2020-09-30 20:25:40 Functions: 10 30 33.3 %
Branches: 46 235 19.6 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  *  Digital Audio (PCM) abstract layer
       4                 :            :  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
       5                 :            :  */
       6                 :            : 
       7                 :            : #include <linux/init.h>
       8                 :            : #include <linux/slab.h>
       9                 :            : #include <linux/module.h>
      10                 :            : #include <linux/time.h>
      11                 :            : #include <linux/mutex.h>
      12                 :            : #include <linux/device.h>
      13                 :            : #include <linux/nospec.h>
      14                 :            : #include <sound/core.h>
      15                 :            : #include <sound/minors.h>
      16                 :            : #include <sound/pcm.h>
      17                 :            : #include <sound/timer.h>
      18                 :            : #include <sound/control.h>
      19                 :            : #include <sound/info.h>
      20                 :            : 
      21                 :            : #include "pcm_local.h"
      22                 :            : 
      23                 :            : MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Abramo Bagnara <abramo@alsa-project.org>");
      24                 :            : MODULE_DESCRIPTION("Midlevel PCM code for ALSA.");
      25                 :            : MODULE_LICENSE("GPL");
      26                 :            : 
      27                 :            : static LIST_HEAD(snd_pcm_devices);
      28                 :            : static DEFINE_MUTEX(register_mutex);
      29                 :            : #if IS_ENABLED(CONFIG_SND_PCM_OSS)
      30                 :            : static LIST_HEAD(snd_pcm_notify_list);
      31                 :            : #endif
      32                 :            : 
      33                 :            : static int snd_pcm_free(struct snd_pcm *pcm);
      34                 :            : static int snd_pcm_dev_free(struct snd_device *device);
      35                 :            : static int snd_pcm_dev_register(struct snd_device *device);
      36                 :            : static int snd_pcm_dev_disconnect(struct snd_device *device);
      37                 :            : 
      38                 :            : static struct snd_pcm *snd_pcm_get(struct snd_card *card, int device)
      39                 :            : {
      40                 :            :         struct snd_pcm *pcm;
      41                 :            : 
      42         [ #  # ]:          0 :         list_for_each_entry(pcm, &snd_pcm_devices, list) {
      43   [ #  #  #  # ]:          0 :                 if (pcm->card == card && pcm->device == device)
      44                 :          0 :                         return pcm;
      45                 :            :         }
      46                 :            :         return NULL;
      47                 :            : }
      48                 :            : 
      49                 :          0 : static int snd_pcm_next(struct snd_card *card, int device)
      50                 :            : {
      51                 :            :         struct snd_pcm *pcm;
      52                 :            : 
      53         [ #  # ]:          0 :         list_for_each_entry(pcm, &snd_pcm_devices, list) {
      54   [ #  #  #  # ]:          0 :                 if (pcm->card == card && pcm->device > device)
      55                 :          0 :                         return pcm->device;
      56         [ #  # ]:          0 :                 else if (pcm->card->number > card->number)
      57                 :            :                         return -1;
      58                 :            :         }
      59                 :            :         return -1;
      60                 :            : }
      61                 :            : 
      62                 :        414 : static int snd_pcm_add(struct snd_pcm *newpcm)
      63                 :            : {
      64                 :            :         struct snd_pcm *pcm;
      65                 :            : 
      66         [ +  - ]:        414 :         if (newpcm->internal)
      67                 :            :                 return 0;
      68                 :            : 
      69         [ +  + ]:        621 :         list_for_each_entry(pcm, &snd_pcm_devices, list) {
      70   [ -  +  #  # ]:        207 :                 if (pcm->card == newpcm->card && pcm->device == newpcm->device)
      71                 :            :                         return -EBUSY;
      72   [ +  -  -  + ]:        207 :                 if (pcm->card->number > newpcm->card->number ||
      73         [ #  # ]:          0 :                                 (pcm->card == newpcm->card &&
      74                 :          0 :                                 pcm->device > newpcm->device)) {
      75                 :          0 :                         list_add(&newpcm->list, pcm->list.prev);
      76                 :          0 :                         return 0;
      77                 :            :                 }
      78                 :            :         }
      79                 :        414 :         list_add_tail(&newpcm->list, &snd_pcm_devices);
      80                 :        414 :         return 0;
      81                 :            : }
      82                 :            : 
      83                 :          0 : static int snd_pcm_control_ioctl(struct snd_card *card,
      84                 :            :                                  struct snd_ctl_file *control,
      85                 :            :                                  unsigned int cmd, unsigned long arg)
      86                 :            : {
      87   [ #  #  #  # ]:          0 :         switch (cmd) {
      88                 :            :         case SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE:
      89                 :            :                 {
      90                 :            :                         int device;
      91                 :            : 
      92         [ #  # ]:          0 :                         if (get_user(device, (int __user *)arg))
      93                 :            :                                 return -EFAULT;
      94                 :          0 :                         mutex_lock(&register_mutex);
      95                 :          0 :                         device = snd_pcm_next(card, device);
      96                 :          0 :                         mutex_unlock(&register_mutex);
      97         [ #  # ]:          0 :                         if (put_user(device, (int __user *)arg))
      98                 :            :                                 return -EFAULT;
      99                 :          0 :                         return 0;
     100                 :            :                 }
     101                 :            :         case SNDRV_CTL_IOCTL_PCM_INFO:
     102                 :            :                 {
     103                 :            :                         struct snd_pcm_info __user *info;
     104                 :            :                         unsigned int device, subdevice;
     105                 :            :                         int stream;
     106                 :            :                         struct snd_pcm *pcm;
     107                 :            :                         struct snd_pcm_str *pstr;
     108                 :            :                         struct snd_pcm_substream *substream;
     109                 :            :                         int err;
     110                 :            : 
     111                 :          0 :                         info = (struct snd_pcm_info __user *)arg;
     112         [ #  # ]:          0 :                         if (get_user(device, &info->device))
     113                 :            :                                 return -EFAULT;
     114         [ #  # ]:          0 :                         if (get_user(stream, &info->stream))
     115                 :            :                                 return -EFAULT;
     116         [ #  # ]:          0 :                         if (stream < 0 || stream > 1)
     117                 :            :                                 return -EINVAL;
     118                 :          0 :                         stream = array_index_nospec(stream, 2);
     119         [ #  # ]:          0 :                         if (get_user(subdevice, &info->subdevice))
     120                 :            :                                 return -EFAULT;
     121                 :          0 :                         mutex_lock(&register_mutex);
     122                 :          0 :                         pcm = snd_pcm_get(card, device);
     123         [ #  # ]:          0 :                         if (pcm == NULL) {
     124                 :            :                                 err = -ENXIO;
     125                 :            :                                 goto _error;
     126                 :            :                         }
     127                 :            :                         pstr = &pcm->streams[stream];
     128         [ #  # ]:          0 :                         if (pstr->substream_count == 0) {
     129                 :            :                                 err = -ENOENT;
     130                 :            :                                 goto _error;
     131                 :            :                         }
     132         [ #  # ]:          0 :                         if (subdevice >= pstr->substream_count) {
     133                 :            :                                 err = -ENXIO;
     134                 :            :                                 goto _error;
     135                 :            :                         }
     136         [ #  # ]:          0 :                         for (substream = pstr->substream; substream;
     137                 :          0 :                              substream = substream->next)
     138         [ #  # ]:          0 :                                 if (substream->number == (int)subdevice)
     139                 :            :                                         break;
     140         [ #  # ]:          0 :                         if (substream == NULL) {
     141                 :            :                                 err = -ENXIO;
     142                 :            :                                 goto _error;
     143                 :            :                         }
     144                 :          0 :                         mutex_lock(&pcm->open_mutex);
     145                 :          0 :                         err = snd_pcm_info_user(substream, info);
     146                 :          0 :                         mutex_unlock(&pcm->open_mutex);
     147                 :            :                 _error:
     148                 :          0 :                         mutex_unlock(&register_mutex);
     149                 :          0 :                         return err;
     150                 :            :                 }
     151                 :            :         case SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE:
     152                 :            :                 {
     153                 :            :                         int val;
     154                 :            :                         
     155         [ #  # ]:          0 :                         if (get_user(val, (int __user *)arg))
     156                 :            :                                 return -EFAULT;
     157                 :          0 :                         control->preferred_subdevice[SND_CTL_SUBDEV_PCM] = val;
     158                 :          0 :                         return 0;
     159                 :            :                 }
     160                 :            :         }
     161                 :            :         return -ENOIOCTLCMD;
     162                 :            : }
     163                 :            : 
     164                 :            : #define FORMAT(v) [SNDRV_PCM_FORMAT_##v] = #v
     165                 :            : 
     166                 :            : static char *snd_pcm_format_names[] = {
     167                 :            :         FORMAT(S8),
     168                 :            :         FORMAT(U8),
     169                 :            :         FORMAT(S16_LE),
     170                 :            :         FORMAT(S16_BE),
     171                 :            :         FORMAT(U16_LE),
     172                 :            :         FORMAT(U16_BE),
     173                 :            :         FORMAT(S24_LE),
     174                 :            :         FORMAT(S24_BE),
     175                 :            :         FORMAT(U24_LE),
     176                 :            :         FORMAT(U24_BE),
     177                 :            :         FORMAT(S32_LE),
     178                 :            :         FORMAT(S32_BE),
     179                 :            :         FORMAT(U32_LE),
     180                 :            :         FORMAT(U32_BE),
     181                 :            :         FORMAT(FLOAT_LE),
     182                 :            :         FORMAT(FLOAT_BE),
     183                 :            :         FORMAT(FLOAT64_LE),
     184                 :            :         FORMAT(FLOAT64_BE),
     185                 :            :         FORMAT(IEC958_SUBFRAME_LE),
     186                 :            :         FORMAT(IEC958_SUBFRAME_BE),
     187                 :            :         FORMAT(MU_LAW),
     188                 :            :         FORMAT(A_LAW),
     189                 :            :         FORMAT(IMA_ADPCM),
     190                 :            :         FORMAT(MPEG),
     191                 :            :         FORMAT(GSM),
     192                 :            :         FORMAT(SPECIAL),
     193                 :            :         FORMAT(S24_3LE),
     194                 :            :         FORMAT(S24_3BE),
     195                 :            :         FORMAT(U24_3LE),
     196                 :            :         FORMAT(U24_3BE),
     197                 :            :         FORMAT(S20_3LE),
     198                 :            :         FORMAT(S20_3BE),
     199                 :            :         FORMAT(U20_3LE),
     200                 :            :         FORMAT(U20_3BE),
     201                 :            :         FORMAT(S18_3LE),
     202                 :            :         FORMAT(S18_3BE),
     203                 :            :         FORMAT(U18_3LE),
     204                 :            :         FORMAT(U18_3BE),
     205                 :            :         FORMAT(G723_24),
     206                 :            :         FORMAT(G723_24_1B),
     207                 :            :         FORMAT(G723_40),
     208                 :            :         FORMAT(G723_40_1B),
     209                 :            :         FORMAT(DSD_U8),
     210                 :            :         FORMAT(DSD_U16_LE),
     211                 :            :         FORMAT(DSD_U32_LE),
     212                 :            :         FORMAT(DSD_U16_BE),
     213                 :            :         FORMAT(DSD_U32_BE),
     214                 :            : };
     215                 :            : 
     216                 :            : /**
     217                 :            :  * snd_pcm_format_name - Return a name string for the given PCM format
     218                 :            :  * @format: PCM format
     219                 :            :  */
     220                 :          0 : const char *snd_pcm_format_name(snd_pcm_format_t format)
     221                 :            : {
     222   [ #  #  #  # ]:          0 :         if ((__force unsigned int)format >= ARRAY_SIZE(snd_pcm_format_names))
     223                 :            :                 return "Unknown";
     224                 :          0 :         return snd_pcm_format_names[(__force unsigned int)format];
     225                 :            : }
     226                 :            : EXPORT_SYMBOL_GPL(snd_pcm_format_name);
     227                 :            : 
     228                 :            : #ifdef CONFIG_SND_VERBOSE_PROCFS
     229                 :            : 
     230                 :            : #define STATE(v) [SNDRV_PCM_STATE_##v] = #v
     231                 :            : #define STREAM(v) [SNDRV_PCM_STREAM_##v] = #v
     232                 :            : #define READY(v) [SNDRV_PCM_READY_##v] = #v
     233                 :            : #define XRUN(v) [SNDRV_PCM_XRUN_##v] = #v
     234                 :            : #define SILENCE(v) [SNDRV_PCM_SILENCE_##v] = #v
     235                 :            : #define TSTAMP(v) [SNDRV_PCM_TSTAMP_##v] = #v
     236                 :            : #define ACCESS(v) [SNDRV_PCM_ACCESS_##v] = #v
     237                 :            : #define START(v) [SNDRV_PCM_START_##v] = #v
     238                 :            : #define SUBFORMAT(v) [SNDRV_PCM_SUBFORMAT_##v] = #v 
     239                 :            : 
     240                 :            : static char *snd_pcm_stream_names[] = {
     241                 :            :         STREAM(PLAYBACK),
     242                 :            :         STREAM(CAPTURE),
     243                 :            : };
     244                 :            : 
     245                 :            : static char *snd_pcm_state_names[] = {
     246                 :            :         STATE(OPEN),
     247                 :            :         STATE(SETUP),
     248                 :            :         STATE(PREPARED),
     249                 :            :         STATE(RUNNING),
     250                 :            :         STATE(XRUN),
     251                 :            :         STATE(DRAINING),
     252                 :            :         STATE(PAUSED),
     253                 :            :         STATE(SUSPENDED),
     254                 :            : };
     255                 :            : 
     256                 :            : static char *snd_pcm_access_names[] = {
     257                 :            :         ACCESS(MMAP_INTERLEAVED), 
     258                 :            :         ACCESS(MMAP_NONINTERLEAVED),
     259                 :            :         ACCESS(MMAP_COMPLEX),
     260                 :            :         ACCESS(RW_INTERLEAVED),
     261                 :            :         ACCESS(RW_NONINTERLEAVED),
     262                 :            : };
     263                 :            : 
     264                 :            : static char *snd_pcm_subformat_names[] = {
     265                 :            :         SUBFORMAT(STD), 
     266                 :            : };
     267                 :            : 
     268                 :            : static char *snd_pcm_tstamp_mode_names[] = {
     269                 :            :         TSTAMP(NONE),
     270                 :            :         TSTAMP(ENABLE),
     271                 :            : };
     272                 :            : 
     273                 :            : static const char *snd_pcm_stream_name(int stream)
     274                 :            : {
     275                 :          0 :         return snd_pcm_stream_names[stream];
     276                 :            : }
     277                 :            : 
     278                 :            : static const char *snd_pcm_access_name(snd_pcm_access_t access)
     279                 :            : {
     280                 :          0 :         return snd_pcm_access_names[(__force int)access];
     281                 :            : }
     282                 :            : 
     283                 :            : static const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat)
     284                 :            : {
     285                 :          0 :         return snd_pcm_subformat_names[(__force int)subformat];
     286                 :            : }
     287                 :            : 
     288                 :            : static const char *snd_pcm_tstamp_mode_name(int mode)
     289                 :            : {
     290                 :          0 :         return snd_pcm_tstamp_mode_names[mode];
     291                 :            : }
     292                 :            : 
     293                 :            : static const char *snd_pcm_state_name(snd_pcm_state_t state)
     294                 :            : {
     295                 :          0 :         return snd_pcm_state_names[(__force int)state];
     296                 :            : }
     297                 :            : 
     298                 :            : #if IS_ENABLED(CONFIG_SND_PCM_OSS)
     299                 :            : #include <linux/soundcard.h>
     300                 :            : 
     301                 :            : static const char *snd_pcm_oss_format_name(int format)
     302                 :            : {
     303                 :            :         switch (format) {
     304                 :            :         case AFMT_MU_LAW:
     305                 :            :                 return "MU_LAW";
     306                 :            :         case AFMT_A_LAW:
     307                 :            :                 return "A_LAW";
     308                 :            :         case AFMT_IMA_ADPCM:
     309                 :            :                 return "IMA_ADPCM";
     310                 :            :         case AFMT_U8:
     311                 :            :                 return "U8";
     312                 :            :         case AFMT_S16_LE:
     313                 :            :                 return "S16_LE";
     314                 :            :         case AFMT_S16_BE:
     315                 :            :                 return "S16_BE";
     316                 :            :         case AFMT_S8:
     317                 :            :                 return "S8";
     318                 :            :         case AFMT_U16_LE:
     319                 :            :                 return "U16_LE";
     320                 :            :         case AFMT_U16_BE:
     321                 :            :                 return "U16_BE";
     322                 :            :         case AFMT_MPEG:
     323                 :            :                 return "MPEG";
     324                 :            :         default:
     325                 :            :                 return "unknown";
     326                 :            :         }
     327                 :            : }
     328                 :            : #endif
     329                 :            : 
     330                 :          0 : static void snd_pcm_proc_info_read(struct snd_pcm_substream *substream,
     331                 :            :                                    struct snd_info_buffer *buffer)
     332                 :            : {
     333                 :            :         struct snd_pcm_info *info;
     334                 :            :         int err;
     335                 :            : 
     336         [ #  # ]:          0 :         if (! substream)
     337                 :            :                 return;
     338                 :            : 
     339                 :            :         info = kmalloc(sizeof(*info), GFP_KERNEL);
     340         [ #  # ]:          0 :         if (!info)
     341                 :            :                 return;
     342                 :            : 
     343                 :          0 :         err = snd_pcm_info(substream, info);
     344         [ #  # ]:          0 :         if (err < 0) {
     345                 :          0 :                 snd_iprintf(buffer, "error %d\n", err);
     346                 :          0 :                 kfree(info);
     347                 :          0 :                 return;
     348                 :            :         }
     349                 :          0 :         snd_iprintf(buffer, "card: %d\n", info->card);
     350                 :          0 :         snd_iprintf(buffer, "device: %d\n", info->device);
     351                 :          0 :         snd_iprintf(buffer, "subdevice: %d\n", info->subdevice);
     352                 :          0 :         snd_iprintf(buffer, "stream: %s\n", snd_pcm_stream_name(info->stream));
     353                 :          0 :         snd_iprintf(buffer, "id: %s\n", info->id);
     354                 :          0 :         snd_iprintf(buffer, "name: %s\n", info->name);
     355                 :          0 :         snd_iprintf(buffer, "subname: %s\n", info->subname);
     356                 :          0 :         snd_iprintf(buffer, "class: %d\n", info->dev_class);
     357                 :          0 :         snd_iprintf(buffer, "subclass: %d\n", info->dev_subclass);
     358                 :          0 :         snd_iprintf(buffer, "subdevices_count: %d\n", info->subdevices_count);
     359                 :          0 :         snd_iprintf(buffer, "subdevices_avail: %d\n", info->subdevices_avail);
     360                 :          0 :         kfree(info);
     361                 :            : }
     362                 :            : 
     363                 :          0 : static void snd_pcm_stream_proc_info_read(struct snd_info_entry *entry,
     364                 :            :                                           struct snd_info_buffer *buffer)
     365                 :            : {
     366                 :          0 :         snd_pcm_proc_info_read(((struct snd_pcm_str *)entry->private_data)->substream,
     367                 :            :                                buffer);
     368                 :          0 : }
     369                 :            : 
     370                 :          0 : static void snd_pcm_substream_proc_info_read(struct snd_info_entry *entry,
     371                 :            :                                              struct snd_info_buffer *buffer)
     372                 :            : {
     373                 :          0 :         snd_pcm_proc_info_read(entry->private_data, buffer);
     374                 :          0 : }
     375                 :            : 
     376                 :          0 : static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry,
     377                 :            :                                                   struct snd_info_buffer *buffer)
     378                 :            : {
     379                 :          0 :         struct snd_pcm_substream *substream = entry->private_data;
     380                 :            :         struct snd_pcm_runtime *runtime;
     381                 :            : 
     382                 :          0 :         mutex_lock(&substream->pcm->open_mutex);
     383                 :          0 :         runtime = substream->runtime;
     384         [ #  # ]:          0 :         if (!runtime) {
     385                 :          0 :                 snd_iprintf(buffer, "closed\n");
     386                 :          0 :                 goto unlock;
     387                 :            :         }
     388         [ #  # ]:          0 :         if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
     389                 :          0 :                 snd_iprintf(buffer, "no setup\n");
     390                 :          0 :                 goto unlock;
     391                 :            :         }
     392                 :          0 :         snd_iprintf(buffer, "access: %s\n", snd_pcm_access_name(runtime->access));
     393                 :          0 :         snd_iprintf(buffer, "format: %s\n", snd_pcm_format_name(runtime->format));
     394                 :          0 :         snd_iprintf(buffer, "subformat: %s\n", snd_pcm_subformat_name(runtime->subformat));
     395                 :          0 :         snd_iprintf(buffer, "channels: %u\n", runtime->channels);  
     396                 :          0 :         snd_iprintf(buffer, "rate: %u (%u/%u)\n", runtime->rate, runtime->rate_num, runtime->rate_den);      
     397                 :          0 :         snd_iprintf(buffer, "period_size: %lu\n", runtime->period_size);   
     398                 :          0 :         snd_iprintf(buffer, "buffer_size: %lu\n", runtime->buffer_size);   
     399                 :            : #if IS_ENABLED(CONFIG_SND_PCM_OSS)
     400                 :            :         if (substream->oss.oss) {
     401                 :            :                 snd_iprintf(buffer, "OSS format: %s\n", snd_pcm_oss_format_name(runtime->oss.format));
     402                 :            :                 snd_iprintf(buffer, "OSS channels: %u\n", runtime->oss.channels);  
     403                 :            :                 snd_iprintf(buffer, "OSS rate: %u\n", runtime->oss.rate);
     404                 :            :                 snd_iprintf(buffer, "OSS period bytes: %lu\n", (unsigned long)runtime->oss.period_bytes);
     405                 :            :                 snd_iprintf(buffer, "OSS periods: %u\n", runtime->oss.periods);
     406                 :            :                 snd_iprintf(buffer, "OSS period frames: %lu\n", (unsigned long)runtime->oss.period_frames);
     407                 :            :         }
     408                 :            : #endif
     409                 :            :  unlock:
     410                 :          0 :         mutex_unlock(&substream->pcm->open_mutex);
     411                 :          0 : }
     412                 :            : 
     413                 :          0 : static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry,
     414                 :            :                                                   struct snd_info_buffer *buffer)
     415                 :            : {
     416                 :          0 :         struct snd_pcm_substream *substream = entry->private_data;
     417                 :            :         struct snd_pcm_runtime *runtime;
     418                 :            : 
     419                 :          0 :         mutex_lock(&substream->pcm->open_mutex);
     420                 :          0 :         runtime = substream->runtime;
     421         [ #  # ]:          0 :         if (!runtime) {
     422                 :          0 :                 snd_iprintf(buffer, "closed\n");
     423                 :          0 :                 goto unlock;
     424                 :            :         }
     425         [ #  # ]:          0 :         if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
     426                 :          0 :                 snd_iprintf(buffer, "no setup\n");
     427                 :          0 :                 goto unlock;
     428                 :            :         }
     429                 :          0 :         snd_iprintf(buffer, "tstamp_mode: %s\n", snd_pcm_tstamp_mode_name(runtime->tstamp_mode));
     430                 :          0 :         snd_iprintf(buffer, "period_step: %u\n", runtime->period_step);
     431                 :          0 :         snd_iprintf(buffer, "avail_min: %lu\n", runtime->control->avail_min);
     432                 :          0 :         snd_iprintf(buffer, "start_threshold: %lu\n", runtime->start_threshold);
     433                 :          0 :         snd_iprintf(buffer, "stop_threshold: %lu\n", runtime->stop_threshold);
     434                 :          0 :         snd_iprintf(buffer, "silence_threshold: %lu\n", runtime->silence_threshold);
     435                 :          0 :         snd_iprintf(buffer, "silence_size: %lu\n", runtime->silence_size);
     436                 :          0 :         snd_iprintf(buffer, "boundary: %lu\n", runtime->boundary);
     437                 :            :  unlock:
     438                 :          0 :         mutex_unlock(&substream->pcm->open_mutex);
     439                 :          0 : }
     440                 :            : 
     441                 :          0 : static void snd_pcm_substream_proc_status_read(struct snd_info_entry *entry,
     442                 :            :                                                struct snd_info_buffer *buffer)
     443                 :            : {
     444                 :          0 :         struct snd_pcm_substream *substream = entry->private_data;
     445                 :            :         struct snd_pcm_runtime *runtime;
     446                 :            :         struct snd_pcm_status status;
     447                 :            :         int err;
     448                 :            : 
     449                 :          0 :         mutex_lock(&substream->pcm->open_mutex);
     450                 :          0 :         runtime = substream->runtime;
     451         [ #  # ]:          0 :         if (!runtime) {
     452                 :          0 :                 snd_iprintf(buffer, "closed\n");
     453                 :          0 :                 goto unlock;
     454                 :            :         }
     455                 :          0 :         memset(&status, 0, sizeof(status));
     456                 :          0 :         err = snd_pcm_status(substream, &status);
     457         [ #  # ]:          0 :         if (err < 0) {
     458                 :          0 :                 snd_iprintf(buffer, "error %d\n", err);
     459                 :          0 :                 goto unlock;
     460                 :            :         }
     461                 :          0 :         snd_iprintf(buffer, "state: %s\n", snd_pcm_state_name(status.state));
     462                 :          0 :         snd_iprintf(buffer, "owner_pid   : %d\n", pid_vnr(substream->pid));
     463                 :          0 :         snd_iprintf(buffer, "trigger_time: %ld.%09ld\n",
     464                 :            :                 status.trigger_tstamp.tv_sec, status.trigger_tstamp.tv_nsec);
     465                 :          0 :         snd_iprintf(buffer, "tstamp      : %ld.%09ld\n",
     466                 :            :                 status.tstamp.tv_sec, status.tstamp.tv_nsec);
     467                 :          0 :         snd_iprintf(buffer, "delay       : %ld\n", status.delay);
     468                 :          0 :         snd_iprintf(buffer, "avail       : %ld\n", status.avail);
     469                 :          0 :         snd_iprintf(buffer, "avail_max   : %ld\n", status.avail_max);
     470                 :          0 :         snd_iprintf(buffer, "-----\n");
     471                 :          0 :         snd_iprintf(buffer, "hw_ptr      : %ld\n", runtime->status->hw_ptr);
     472                 :          0 :         snd_iprintf(buffer, "appl_ptr    : %ld\n", runtime->control->appl_ptr);
     473                 :            :  unlock:
     474                 :          0 :         mutex_unlock(&substream->pcm->open_mutex);
     475                 :          0 : }
     476                 :            : 
     477                 :            : #ifdef CONFIG_SND_PCM_XRUN_DEBUG
     478                 :            : static void snd_pcm_xrun_injection_write(struct snd_info_entry *entry,
     479                 :            :                                          struct snd_info_buffer *buffer)
     480                 :            : {
     481                 :            :         struct snd_pcm_substream *substream = entry->private_data;
     482                 :            : 
     483                 :            :         snd_pcm_stop_xrun(substream);
     484                 :            : }
     485                 :            : 
     486                 :            : static void snd_pcm_xrun_debug_read(struct snd_info_entry *entry,
     487                 :            :                                     struct snd_info_buffer *buffer)
     488                 :            : {
     489                 :            :         struct snd_pcm_str *pstr = entry->private_data;
     490                 :            :         snd_iprintf(buffer, "%d\n", pstr->xrun_debug);
     491                 :            : }
     492                 :            : 
     493                 :            : static void snd_pcm_xrun_debug_write(struct snd_info_entry *entry,
     494                 :            :                                      struct snd_info_buffer *buffer)
     495                 :            : {
     496                 :            :         struct snd_pcm_str *pstr = entry->private_data;
     497                 :            :         char line[64];
     498                 :            :         if (!snd_info_get_line(buffer, line, sizeof(line)))
     499                 :            :                 pstr->xrun_debug = simple_strtoul(line, NULL, 10);
     500                 :            : }
     501                 :            : #endif
     502                 :            : 
     503                 :        414 : static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr)
     504                 :            : {
     505                 :        414 :         struct snd_pcm *pcm = pstr->pcm;
     506                 :            :         struct snd_info_entry *entry;
     507                 :            :         char name[16];
     508                 :            : 
     509         [ -  + ]:        828 :         sprintf(name, "pcm%i%c", pcm->device, 
     510                 :        414 :                 pstr->stream == SNDRV_PCM_STREAM_PLAYBACK ? 'p' : 'c');
     511                 :        414 :         entry = snd_info_create_card_entry(pcm->card, name,
     512                 :        414 :                                            pcm->card->proc_root);
     513         [ +  - ]:        414 :         if (!entry)
     514                 :            :                 return -ENOMEM;
     515                 :        414 :         entry->mode = S_IFDIR | 0555;
     516                 :        414 :         pstr->proc_root = entry;
     517                 :        414 :         entry = snd_info_create_card_entry(pcm->card, "info", pstr->proc_root);
     518         [ +  - ]:        414 :         if (entry)
     519                 :            :                 snd_info_set_text_ops(entry, pstr, snd_pcm_stream_proc_info_read);
     520                 :            : #ifdef CONFIG_SND_PCM_XRUN_DEBUG
     521                 :            :         entry = snd_info_create_card_entry(pcm->card, "xrun_debug",
     522                 :            :                                            pstr->proc_root);
     523                 :            :         if (entry) {
     524                 :            :                 snd_info_set_text_ops(entry, pstr, snd_pcm_xrun_debug_read);
     525                 :            :                 entry->c.text.write = snd_pcm_xrun_debug_write;
     526                 :            :                 entry->mode |= 0200;
     527                 :            :         }
     528                 :            : #endif
     529                 :            :         return 0;
     530                 :            : }
     531                 :            : 
     532                 :            : static int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr)
     533                 :            : {
     534                 :          0 :         snd_info_free_entry(pstr->proc_root);
     535                 :          0 :         pstr->proc_root = NULL;
     536                 :            :         return 0;
     537                 :            : }
     538                 :            : 
     539                 :            : static struct snd_info_entry *
     540                 :       6624 : create_substream_info_entry(struct snd_pcm_substream *substream,
     541                 :            :                             const char *name,
     542                 :            :                             void (*read)(struct snd_info_entry *,
     543                 :            :                                          struct snd_info_buffer *))
     544                 :            : {
     545                 :            :         struct snd_info_entry *entry;
     546                 :            : 
     547                 :       6624 :         entry = snd_info_create_card_entry(substream->pcm->card, name,
     548                 :            :                                            substream->proc_root);
     549         [ +  - ]:       6624 :         if (entry)
     550                 :            :                 snd_info_set_text_ops(entry, substream, read);
     551                 :       6624 :         return entry;
     552                 :            : }
     553                 :            : 
     554                 :       1656 : static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream)
     555                 :            : {
     556                 :            :         struct snd_info_entry *entry;
     557                 :            :         struct snd_card *card;
     558                 :            :         char name[16];
     559                 :            : 
     560                 :       1656 :         card = substream->pcm->card;
     561                 :            : 
     562                 :       1656 :         sprintf(name, "sub%i", substream->number);
     563                 :       1656 :         entry = snd_info_create_card_entry(card, name,
     564                 :       1656 :                                            substream->pstr->proc_root);
     565         [ +  - ]:       1656 :         if (!entry)
     566                 :            :                 return -ENOMEM;
     567                 :       1656 :         entry->mode = S_IFDIR | 0555;
     568                 :       1656 :         substream->proc_root = entry;
     569                 :            : 
     570                 :       1656 :         create_substream_info_entry(substream, "info",
     571                 :            :                                     snd_pcm_substream_proc_info_read);
     572                 :       1656 :         create_substream_info_entry(substream, "hw_params",
     573                 :            :                                     snd_pcm_substream_proc_hw_params_read);
     574                 :       1656 :         create_substream_info_entry(substream, "sw_params",
     575                 :            :                                     snd_pcm_substream_proc_sw_params_read);
     576                 :       1656 :         create_substream_info_entry(substream, "status",
     577                 :            :                                     snd_pcm_substream_proc_status_read);
     578                 :            : 
     579                 :            : #ifdef CONFIG_SND_PCM_XRUN_DEBUG
     580                 :            :         entry = create_substream_info_entry(substream, "xrun_injection", NULL);
     581                 :            :         if (entry) {
     582                 :            :                 entry->c.text.write = snd_pcm_xrun_injection_write;
     583                 :            :                 entry->mode = S_IFREG | 0200;
     584                 :            :         }
     585                 :            : #endif /* CONFIG_SND_PCM_XRUN_DEBUG */
     586                 :            : 
     587                 :       1656 :         return 0;
     588                 :            : }
     589                 :            : 
     590                 :            : #else /* !CONFIG_SND_VERBOSE_PROCFS */
     591                 :            : static inline int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr) { return 0; }
     592                 :            : static inline int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr) { return 0; }
     593                 :            : static inline int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream) { return 0; }
     594                 :            : #endif /* CONFIG_SND_VERBOSE_PROCFS */
     595                 :            : 
     596                 :            : static const struct attribute_group *pcm_dev_attr_groups[];
     597                 :            : 
     598                 :            : /*
     599                 :            :  * PM callbacks: we need to deal only with suspend here, as the resume is
     600                 :            :  * triggered either from user-space or the driver's resume callback
     601                 :            :  */
     602                 :            : #ifdef CONFIG_PM_SLEEP
     603                 :            : static int do_pcm_suspend(struct device *dev)
     604                 :            : {
     605                 :            :         struct snd_pcm_str *pstr = container_of(dev, struct snd_pcm_str, dev);
     606                 :            : 
     607                 :            :         if (!pstr->pcm->no_device_suspend)
     608                 :            :                 snd_pcm_suspend_all(pstr->pcm);
     609                 :            :         return 0;
     610                 :            : }
     611                 :            : #endif
     612                 :            : 
     613                 :            : static const struct dev_pm_ops pcm_dev_pm_ops = {
     614                 :            :         SET_SYSTEM_SLEEP_PM_OPS(do_pcm_suspend, NULL)
     615                 :            : };
     616                 :            : 
     617                 :            : /* device type for PCM -- basically only for passing PM callbacks */
     618                 :            : static const struct device_type pcm_dev_type = {
     619                 :            :         .name = "pcm",
     620                 :            :         .pm = &pcm_dev_pm_ops,
     621                 :            : };
     622                 :            : 
     623                 :            : /**
     624                 :            :  * snd_pcm_new_stream - create a new PCM stream
     625                 :            :  * @pcm: the pcm instance
     626                 :            :  * @stream: the stream direction, SNDRV_PCM_STREAM_XXX
     627                 :            :  * @substream_count: the number of substreams
     628                 :            :  *
     629                 :            :  * Creates a new stream for the pcm.
     630                 :            :  * The corresponding stream on the pcm must have been empty before
     631                 :            :  * calling this, i.e. zero must be given to the argument of
     632                 :            :  * snd_pcm_new().
     633                 :            :  *
     634                 :            :  * Return: Zero if successful, or a negative error code on failure.
     635                 :            :  */
     636                 :        828 : int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
     637                 :            : {
     638                 :            :         int idx, err;
     639                 :        828 :         struct snd_pcm_str *pstr = &pcm->streams[stream];
     640                 :            :         struct snd_pcm_substream *substream, *prev;
     641                 :            : 
     642                 :            : #if IS_ENABLED(CONFIG_SND_PCM_OSS)
     643                 :            :         mutex_init(&pstr->oss.setup_mutex);
     644                 :            : #endif
     645                 :        828 :         pstr->stream = stream;
     646                 :        828 :         pstr->pcm = pcm;
     647                 :        828 :         pstr->substream_count = substream_count;
     648         [ +  + ]:        828 :         if (!substream_count)
     649                 :            :                 return 0;
     650                 :            : 
     651                 :        414 :         snd_device_initialize(&pstr->dev, pcm->card);
     652                 :        414 :         pstr->dev.groups = pcm_dev_attr_groups;
     653                 :        414 :         pstr->dev.type = &pcm_dev_type;
     654         [ -  + ]:        414 :         dev_set_name(&pstr->dev, "pcmC%iD%i%c", pcm->card->number, pcm->device,
     655                 :            :                      stream == SNDRV_PCM_STREAM_PLAYBACK ? 'p' : 'c');
     656                 :            : 
     657         [ +  - ]:        414 :         if (!pcm->internal) {
     658                 :        414 :                 err = snd_pcm_stream_proc_init(pstr);
     659         [ +  - ]:        414 :                 if (err < 0) {
     660                 :          0 :                         pcm_err(pcm, "Error in snd_pcm_stream_proc_init\n");
     661                 :          0 :                         return err;
     662                 :            :                 }
     663                 :            :         }
     664                 :            :         prev = NULL;
     665         [ +  + ]:       1656 :         for (idx = 0, prev = NULL; idx < substream_count; idx++) {
     666                 :       1656 :                 substream = kzalloc(sizeof(*substream), GFP_KERNEL);
     667         [ +  - ]:       1656 :                 if (!substream)
     668                 :            :                         return -ENOMEM;
     669                 :       1656 :                 substream->pcm = pcm;
     670                 :       1656 :                 substream->pstr = pstr;
     671                 :       1656 :                 substream->number = idx;
     672                 :       1656 :                 substream->stream = stream;
     673                 :       1656 :                 sprintf(substream->name, "subdevice #%i", idx);
     674                 :       1656 :                 substream->buffer_bytes_max = UINT_MAX;
     675         [ +  + ]:       1656 :                 if (prev == NULL)
     676                 :        414 :                         pstr->substream = substream;
     677                 :            :                 else
     678                 :       1242 :                         prev->next = substream;
     679                 :            : 
     680         [ +  - ]:       1656 :                 if (!pcm->internal) {
     681                 :       1656 :                         err = snd_pcm_substream_proc_init(substream);
     682         [ -  + ]:       1656 :                         if (err < 0) {
     683                 :          0 :                                 pcm_err(pcm,
     684                 :            :                                         "Error in snd_pcm_stream_proc_init\n");
     685         [ #  # ]:          0 :                                 if (prev == NULL)
     686                 :          0 :                                         pstr->substream = NULL;
     687                 :            :                                 else
     688                 :          0 :                                         prev->next = NULL;
     689                 :          0 :                                 kfree(substream);
     690                 :          0 :                                 return err;
     691                 :            :                         }
     692                 :            :                 }
     693                 :       1656 :                 substream->group = &substream->self_group;
     694                 :       1656 :                 snd_pcm_group_init(&substream->self_group);
     695                 :       1656 :                 list_add_tail(&substream->link_list, &substream->self_group.substreams);
     696                 :            :                 atomic_set(&substream->mmap_count, 0);
     697                 :            :                 prev = substream;
     698                 :            :         }
     699                 :            :         return 0;
     700                 :            : }                               
     701                 :            : EXPORT_SYMBOL(snd_pcm_new_stream);
     702                 :            : 
     703                 :        414 : static int _snd_pcm_new(struct snd_card *card, const char *id, int device,
     704                 :            :                 int playback_count, int capture_count, bool internal,
     705                 :            :                 struct snd_pcm **rpcm)
     706                 :            : {
     707                 :            :         struct snd_pcm *pcm;
     708                 :            :         int err;
     709                 :            :         static struct snd_device_ops ops = {
     710                 :            :                 .dev_free = snd_pcm_dev_free,
     711                 :            :                 .dev_register = snd_pcm_dev_register,
     712                 :            :                 .dev_disconnect = snd_pcm_dev_disconnect,
     713                 :            :         };
     714                 :            :         static struct snd_device_ops internal_ops = {
     715                 :            :                 .dev_free = snd_pcm_dev_free,
     716                 :            :         };
     717                 :            : 
     718         [ +  - ]:        414 :         if (snd_BUG_ON(!card))
     719                 :            :                 return -ENXIO;
     720         [ +  - ]:        414 :         if (rpcm)
     721                 :        414 :                 *rpcm = NULL;
     722                 :        414 :         pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
     723         [ +  - ]:        414 :         if (!pcm)
     724                 :            :                 return -ENOMEM;
     725                 :        414 :         pcm->card = card;
     726                 :        414 :         pcm->device = device;
     727                 :        414 :         pcm->internal = internal;
     728                 :        414 :         mutex_init(&pcm->open_mutex);
     729                 :        414 :         init_waitqueue_head(&pcm->open_wait);
     730                 :        414 :         INIT_LIST_HEAD(&pcm->list);
     731         [ +  - ]:        414 :         if (id)
     732                 :        414 :                 strlcpy(pcm->id, id, sizeof(pcm->id));
     733                 :            : 
     734                 :        414 :         err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_PLAYBACK,
     735                 :            :                                  playback_count);
     736         [ +  - ]:        414 :         if (err < 0)
     737                 :            :                 goto free_pcm;
     738                 :            : 
     739                 :        414 :         err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_CAPTURE, capture_count);
     740         [ +  - ]:        414 :         if (err < 0)
     741                 :            :                 goto free_pcm;
     742                 :            : 
     743         [ +  - ]:        414 :         err = snd_device_new(card, SNDRV_DEV_PCM, pcm,
     744                 :            :                              internal ? &internal_ops : &ops);
     745         [ +  - ]:        414 :         if (err < 0)
     746                 :            :                 goto free_pcm;
     747                 :            : 
     748         [ +  - ]:        414 :         if (rpcm)
     749                 :        414 :                 *rpcm = pcm;
     750                 :            :         return 0;
     751                 :            : 
     752                 :            : free_pcm:
     753                 :          0 :         snd_pcm_free(pcm);
     754                 :          0 :         return err;
     755                 :            : }
     756                 :            : 
     757                 :            : /**
     758                 :            :  * snd_pcm_new - create a new PCM instance
     759                 :            :  * @card: the card instance
     760                 :            :  * @id: the id string
     761                 :            :  * @device: the device index (zero based)
     762                 :            :  * @playback_count: the number of substreams for playback
     763                 :            :  * @capture_count: the number of substreams for capture
     764                 :            :  * @rpcm: the pointer to store the new pcm instance
     765                 :            :  *
     766                 :            :  * Creates a new PCM instance.
     767                 :            :  *
     768                 :            :  * The pcm operators have to be set afterwards to the new instance
     769                 :            :  * via snd_pcm_set_ops().
     770                 :            :  *
     771                 :            :  * Return: Zero if successful, or a negative error code on failure.
     772                 :            :  */
     773                 :        414 : int snd_pcm_new(struct snd_card *card, const char *id, int device,
     774                 :            :                 int playback_count, int capture_count, struct snd_pcm **rpcm)
     775                 :            : {
     776                 :        414 :         return _snd_pcm_new(card, id, device, playback_count, capture_count,
     777                 :            :                         false, rpcm);
     778                 :            : }
     779                 :            : EXPORT_SYMBOL(snd_pcm_new);
     780                 :            : 
     781                 :            : /**
     782                 :            :  * snd_pcm_new_internal - create a new internal PCM instance
     783                 :            :  * @card: the card instance
     784                 :            :  * @id: the id string
     785                 :            :  * @device: the device index (zero based - shared with normal PCMs)
     786                 :            :  * @playback_count: the number of substreams for playback
     787                 :            :  * @capture_count: the number of substreams for capture
     788                 :            :  * @rpcm: the pointer to store the new pcm instance
     789                 :            :  *
     790                 :            :  * Creates a new internal PCM instance with no userspace device or procfs
     791                 :            :  * entries. This is used by ASoC Back End PCMs in order to create a PCM that
     792                 :            :  * will only be used internally by kernel drivers. i.e. it cannot be opened
     793                 :            :  * by userspace. It provides existing ASoC components drivers with a substream
     794                 :            :  * and access to any private data.
     795                 :            :  *
     796                 :            :  * The pcm operators have to be set afterwards to the new instance
     797                 :            :  * via snd_pcm_set_ops().
     798                 :            :  *
     799                 :            :  * Return: Zero if successful, or a negative error code on failure.
     800                 :            :  */
     801                 :          0 : int snd_pcm_new_internal(struct snd_card *card, const char *id, int device,
     802                 :            :         int playback_count, int capture_count,
     803                 :            :         struct snd_pcm **rpcm)
     804                 :            : {
     805                 :          0 :         return _snd_pcm_new(card, id, device, playback_count, capture_count,
     806                 :            :                         true, rpcm);
     807                 :            : }
     808                 :            : EXPORT_SYMBOL(snd_pcm_new_internal);
     809                 :            : 
     810                 :          0 : static void free_chmap(struct snd_pcm_str *pstr)
     811                 :            : {
     812         [ #  # ]:          0 :         if (pstr->chmap_kctl) {
     813                 :          0 :                 snd_ctl_remove(pstr->pcm->card, pstr->chmap_kctl);
     814                 :          0 :                 pstr->chmap_kctl = NULL;
     815                 :            :         }
     816                 :          0 : }
     817                 :            : 
     818                 :          0 : static void snd_pcm_free_stream(struct snd_pcm_str * pstr)
     819                 :            : {
     820                 :            :         struct snd_pcm_substream *substream, *substream_next;
     821                 :            : #if IS_ENABLED(CONFIG_SND_PCM_OSS)
     822                 :            :         struct snd_pcm_oss_setup *setup, *setupn;
     823                 :            : #endif
     824                 :            : 
     825                 :            :         /* free all proc files under the stream */
     826                 :            :         snd_pcm_stream_proc_done(pstr);
     827                 :            : 
     828                 :          0 :         substream = pstr->substream;
     829         [ #  # ]:          0 :         while (substream) {
     830                 :          0 :                 substream_next = substream->next;
     831                 :          0 :                 snd_pcm_timer_done(substream);
     832                 :          0 :                 kfree(substream);
     833                 :            :                 substream = substream_next;
     834                 :            :         }
     835                 :            : #if IS_ENABLED(CONFIG_SND_PCM_OSS)
     836                 :            :         for (setup = pstr->oss.setup_list; setup; setup = setupn) {
     837                 :            :                 setupn = setup->next;
     838                 :            :                 kfree(setup->task_name);
     839                 :            :                 kfree(setup);
     840                 :            :         }
     841                 :            : #endif
     842                 :          0 :         free_chmap(pstr);
     843         [ #  # ]:          0 :         if (pstr->substream_count)
     844                 :          0 :                 put_device(&pstr->dev);
     845                 :          0 : }
     846                 :            : 
     847                 :            : #if IS_ENABLED(CONFIG_SND_PCM_OSS)
     848                 :            : #define pcm_call_notify(pcm, call)                                      \
     849                 :            :         do {                                                            \
     850                 :            :                 struct snd_pcm_notify *_notify;                         \
     851                 :            :                 list_for_each_entry(_notify, &snd_pcm_notify_list, list) \
     852                 :            :                         _notify->call(pcm);                          \
     853                 :            :         } while (0)
     854                 :            : #else
     855                 :            : #define pcm_call_notify(pcm, call) do {} while (0)
     856                 :            : #endif
     857                 :            : 
     858                 :          0 : static int snd_pcm_free(struct snd_pcm *pcm)
     859                 :            : {
     860         [ #  # ]:          0 :         if (!pcm)
     861                 :            :                 return 0;
     862                 :            :         if (!pcm->internal)
     863                 :            :                 pcm_call_notify(pcm, n_unregister);
     864         [ #  # ]:          0 :         if (pcm->private_free)
     865                 :          0 :                 pcm->private_free(pcm);
     866                 :          0 :         snd_pcm_lib_preallocate_free_for_all(pcm);
     867                 :          0 :         snd_pcm_free_stream(&pcm->streams[SNDRV_PCM_STREAM_PLAYBACK]);
     868                 :          0 :         snd_pcm_free_stream(&pcm->streams[SNDRV_PCM_STREAM_CAPTURE]);
     869                 :          0 :         kfree(pcm);
     870                 :          0 :         return 0;
     871                 :            : }
     872                 :            : 
     873                 :          0 : static int snd_pcm_dev_free(struct snd_device *device)
     874                 :            : {
     875                 :          0 :         struct snd_pcm *pcm = device->device_data;
     876                 :          0 :         return snd_pcm_free(pcm);
     877                 :            : }
     878                 :            : 
     879                 :          0 : int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
     880                 :            :                              struct file *file,
     881                 :            :                              struct snd_pcm_substream **rsubstream)
     882                 :            : {
     883                 :            :         struct snd_pcm_str * pstr;
     884                 :            :         struct snd_pcm_substream *substream;
     885                 :            :         struct snd_pcm_runtime *runtime;
     886                 :            :         struct snd_card *card;
     887                 :            :         int prefer_subdevice;
     888                 :            :         size_t size;
     889                 :            : 
     890         [ #  # ]:          0 :         if (snd_BUG_ON(!pcm || !rsubstream))
     891                 :            :                 return -ENXIO;
     892         [ #  # ]:          0 :         if (snd_BUG_ON(stream != SNDRV_PCM_STREAM_PLAYBACK &&
     893                 :            :                        stream != SNDRV_PCM_STREAM_CAPTURE))
     894                 :            :                 return -EINVAL;
     895                 :          0 :         *rsubstream = NULL;
     896                 :            :         pstr = &pcm->streams[stream];
     897   [ #  #  #  # ]:          0 :         if (pstr->substream == NULL || pstr->substream_count == 0)
     898                 :            :                 return -ENODEV;
     899                 :            : 
     900                 :          0 :         card = pcm->card;
     901                 :          0 :         prefer_subdevice = snd_ctl_get_preferred_subdevice(card, SND_CTL_SUBDEV_PCM);
     902                 :            : 
     903         [ #  # ]:          0 :         if (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX) {
     904                 :          0 :                 int opposite = !stream;
     905                 :            : 
     906         [ #  # ]:          0 :                 for (substream = pcm->streams[opposite].substream; substream;
     907                 :          0 :                      substream = substream->next) {
     908         [ #  # ]:          0 :                         if (SUBSTREAM_BUSY(substream))
     909                 :            :                                 return -EAGAIN;
     910                 :            :                 }
     911                 :            :         }
     912                 :            : 
     913         [ #  # ]:          0 :         if (file->f_flags & O_APPEND) {
     914         [ #  # ]:          0 :                 if (prefer_subdevice < 0) {
     915         [ #  # ]:          0 :                         if (pstr->substream_count > 1)
     916                 :            :                                 return -EINVAL; /* must be unique */
     917                 :          0 :                         substream = pstr->substream;
     918                 :            :                 } else {
     919         [ #  # ]:          0 :                         for (substream = pstr->substream; substream;
     920                 :          0 :                              substream = substream->next)
     921         [ #  # ]:          0 :                                 if (substream->number == prefer_subdevice)
     922                 :            :                                         break;
     923                 :            :                 }
     924         [ #  # ]:          0 :                 if (! substream)
     925                 :            :                         return -ENODEV;
     926         [ #  # ]:          0 :                 if (! SUBSTREAM_BUSY(substream))
     927                 :            :                         return -EBADFD;
     928                 :          0 :                 substream->ref_count++;
     929                 :          0 :                 *rsubstream = substream;
     930                 :          0 :                 return 0;
     931                 :            :         }
     932                 :            : 
     933         [ #  # ]:          0 :         for (substream = pstr->substream; substream; substream = substream->next) {
     934   [ #  #  #  # ]:          0 :                 if (!SUBSTREAM_BUSY(substream) &&
     935         [ #  # ]:          0 :                     (prefer_subdevice == -1 ||
     936                 :          0 :                      substream->number == prefer_subdevice))
     937                 :            :                         break;
     938                 :            :         }
     939         [ #  # ]:          0 :         if (substream == NULL)
     940                 :            :                 return -EAGAIN;
     941                 :            : 
     942                 :          0 :         runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
     943         [ #  # ]:          0 :         if (runtime == NULL)
     944                 :            :                 return -ENOMEM;
     945                 :            : 
     946                 :            :         size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status));
     947                 :          0 :         runtime->status = alloc_pages_exact(size, GFP_KERNEL);
     948         [ #  # ]:          0 :         if (runtime->status == NULL) {
     949                 :          0 :                 kfree(runtime);
     950                 :          0 :                 return -ENOMEM;
     951                 :            :         }
     952                 :          0 :         memset(runtime->status, 0, size);
     953                 :            : 
     954                 :            :         size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control));
     955                 :          0 :         runtime->control = alloc_pages_exact(size, GFP_KERNEL);
     956         [ #  # ]:          0 :         if (runtime->control == NULL) {
     957                 :          0 :                 free_pages_exact(runtime->status,
     958                 :            :                                PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)));
     959                 :          0 :                 kfree(runtime);
     960                 :          0 :                 return -ENOMEM;
     961                 :            :         }
     962                 :          0 :         memset(runtime->control, 0, size);
     963                 :            : 
     964                 :          0 :         init_waitqueue_head(&runtime->sleep);
     965                 :          0 :         init_waitqueue_head(&runtime->tsleep);
     966                 :            : 
     967                 :          0 :         runtime->status->state = SNDRV_PCM_STATE_OPEN;
     968                 :            : 
     969                 :          0 :         substream->runtime = runtime;
     970                 :          0 :         substream->private_data = pcm->private_data;
     971                 :          0 :         substream->ref_count = 1;
     972                 :          0 :         substream->f_flags = file->f_flags;
     973                 :          0 :         substream->pid = get_pid(task_pid(current));
     974                 :          0 :         pstr->substream_opened++;
     975                 :          0 :         *rsubstream = substream;
     976                 :          0 :         return 0;
     977                 :            : }
     978                 :            : 
     979                 :          0 : void snd_pcm_detach_substream(struct snd_pcm_substream *substream)
     980                 :            : {
     981                 :            :         struct snd_pcm_runtime *runtime;
     982                 :            : 
     983   [ #  #  #  #  :          0 :         if (PCM_RUNTIME_CHECK(substream))
                   #  # ]
     984                 :          0 :                 return;
     985                 :          0 :         runtime = substream->runtime;
     986         [ #  # ]:          0 :         if (runtime->private_free != NULL)
     987                 :          0 :                 runtime->private_free(runtime);
     988                 :          0 :         free_pages_exact(runtime->status,
     989                 :            :                        PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)));
     990                 :          0 :         free_pages_exact(runtime->control,
     991                 :            :                        PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)));
     992                 :          0 :         kfree(runtime->hw_constraints.rules);
     993                 :            :         /* Avoid concurrent access to runtime via PCM timer interface */
     994         [ #  # ]:          0 :         if (substream->timer)
     995                 :            :                 spin_lock_irq(&substream->timer->lock);
     996                 :          0 :         substream->runtime = NULL;
     997         [ #  # ]:          0 :         if (substream->timer)
     998                 :            :                 spin_unlock_irq(&substream->timer->lock);
     999                 :          0 :         kfree(runtime);
    1000                 :          0 :         put_pid(substream->pid);
    1001                 :          0 :         substream->pid = NULL;
    1002                 :          0 :         substream->pstr->substream_opened--;
    1003                 :            : }
    1004                 :            : 
    1005                 :          0 : static ssize_t show_pcm_class(struct device *dev,
    1006                 :            :                               struct device_attribute *attr, char *buf)
    1007                 :            : {
    1008                 :            :         struct snd_pcm_str *pstr = container_of(dev, struct snd_pcm_str, dev);
    1009                 :          0 :         struct snd_pcm *pcm = pstr->pcm;
    1010                 :            :         const char *str;
    1011                 :            :         static const char *strs[SNDRV_PCM_CLASS_LAST + 1] = {
    1012                 :            :                 [SNDRV_PCM_CLASS_GENERIC] = "generic",
    1013                 :            :                 [SNDRV_PCM_CLASS_MULTI] = "multi",
    1014                 :            :                 [SNDRV_PCM_CLASS_MODEM] = "modem",
    1015                 :            :                 [SNDRV_PCM_CLASS_DIGITIZER] = "digitizer",
    1016                 :            :         };
    1017                 :            : 
    1018         [ #  # ]:          0 :         if (pcm->dev_class > SNDRV_PCM_CLASS_LAST)
    1019                 :            :                 str = "none";
    1020                 :            :         else
    1021                 :          0 :                 str = strs[pcm->dev_class];
    1022                 :          0 :         return snprintf(buf, PAGE_SIZE, "%s\n", str);
    1023                 :            : }
    1024                 :            : 
    1025                 :            : static DEVICE_ATTR(pcm_class, 0444, show_pcm_class, NULL);
    1026                 :            : static struct attribute *pcm_dev_attrs[] = {
    1027                 :            :         &dev_attr_pcm_class.attr,
    1028                 :            :         NULL
    1029                 :            : };
    1030                 :            : 
    1031                 :            : static const struct attribute_group pcm_dev_attr_group = {
    1032                 :            :         .attrs  = pcm_dev_attrs,
    1033                 :            : };
    1034                 :            : 
    1035                 :            : static const struct attribute_group *pcm_dev_attr_groups[] = {
    1036                 :            :         &pcm_dev_attr_group,
    1037                 :            :         NULL
    1038                 :            : };
    1039                 :            : 
    1040                 :        414 : static int snd_pcm_dev_register(struct snd_device *device)
    1041                 :            : {
    1042                 :            :         int cidx, err;
    1043                 :            :         struct snd_pcm_substream *substream;
    1044                 :            :         struct snd_pcm *pcm;
    1045                 :            : 
    1046   [ +  -  +  -  :        414 :         if (snd_BUG_ON(!device || !device->device_data))
                   +  - ]
    1047                 :            :                 return -ENXIO;
    1048                 :        414 :         pcm = device->device_data;
    1049                 :            : 
    1050                 :        414 :         mutex_lock(&register_mutex);
    1051                 :        414 :         err = snd_pcm_add(pcm);
    1052         [ +  - ]:        414 :         if (err)
    1053                 :            :                 goto unlock;
    1054         [ +  + ]:        828 :         for (cidx = 0; cidx < 2; cidx++) {
    1055                 :            :                 int devtype = -1;
    1056         [ +  + ]:        828 :                 if (pcm->streams[cidx].substream == NULL)
    1057                 :        414 :                         continue;
    1058      [ +  -  - ]:        414 :                 switch (cidx) {
    1059                 :            :                 case SNDRV_PCM_STREAM_PLAYBACK:
    1060                 :            :                         devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK;
    1061                 :        414 :                         break;
    1062                 :            :                 case SNDRV_PCM_STREAM_CAPTURE:
    1063                 :            :                         devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE;
    1064                 :          0 :                         break;
    1065                 :            :                 }
    1066                 :            :                 /* register pcm */
    1067                 :        414 :                 err = snd_register_device(devtype, pcm->card, pcm->device,
    1068                 :            :                                           &snd_pcm_f_ops[cidx], pcm,
    1069                 :            :                                           &pcm->streams[cidx].dev);
    1070         [ -  + ]:        414 :                 if (err < 0) {
    1071                 :          0 :                         list_del_init(&pcm->list);
    1072                 :            :                         goto unlock;
    1073                 :            :                 }
    1074                 :            : 
    1075         [ +  + ]:       2070 :                 for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
    1076                 :       1656 :                         snd_pcm_timer_init(substream);
    1077                 :            :         }
    1078                 :            : 
    1079                 :            :         pcm_call_notify(pcm, n_register);
    1080                 :            : 
    1081                 :            :  unlock:
    1082                 :        414 :         mutex_unlock(&register_mutex);
    1083                 :        414 :         return err;
    1084                 :            : }
    1085                 :            : 
    1086                 :          0 : static int snd_pcm_dev_disconnect(struct snd_device *device)
    1087                 :            : {
    1088                 :          0 :         struct snd_pcm *pcm = device->device_data;
    1089                 :            :         struct snd_pcm_substream *substream;
    1090                 :            :         int cidx;
    1091                 :            : 
    1092                 :          0 :         mutex_lock(&register_mutex);
    1093                 :          0 :         mutex_lock(&pcm->open_mutex);
    1094                 :          0 :         wake_up(&pcm->open_wait);
    1095                 :          0 :         list_del_init(&pcm->list);
    1096         [ #  # ]:          0 :         for (cidx = 0; cidx < 2; cidx++) {
    1097         [ #  # ]:          0 :                 for (substream = pcm->streams[cidx].substream; substream; substream = substream->next) {
    1098                 :          0 :                         snd_pcm_stream_lock_irq(substream);
    1099         [ #  # ]:          0 :                         if (substream->runtime) {
    1100         [ #  # ]:          0 :                                 if (snd_pcm_running(substream))
    1101                 :          0 :                                         snd_pcm_stop(substream,
    1102                 :            :                                                      SNDRV_PCM_STATE_DISCONNECTED);
    1103                 :            :                                 /* to be sure, set the state unconditionally */
    1104                 :          0 :                                 substream->runtime->status->state = SNDRV_PCM_STATE_DISCONNECTED;
    1105                 :          0 :                                 wake_up(&substream->runtime->sleep);
    1106                 :          0 :                                 wake_up(&substream->runtime->tsleep);
    1107                 :            :                         }
    1108                 :          0 :                         snd_pcm_stream_unlock_irq(substream);
    1109                 :            :                 }
    1110                 :            :         }
    1111                 :            : 
    1112                 :            :         pcm_call_notify(pcm, n_disconnect);
    1113         [ #  # ]:          0 :         for (cidx = 0; cidx < 2; cidx++) {
    1114                 :          0 :                 snd_unregister_device(&pcm->streams[cidx].dev);
    1115                 :          0 :                 free_chmap(&pcm->streams[cidx]);
    1116                 :            :         }
    1117                 :          0 :         mutex_unlock(&pcm->open_mutex);
    1118                 :          0 :         mutex_unlock(&register_mutex);
    1119                 :          0 :         return 0;
    1120                 :            : }
    1121                 :            : 
    1122                 :            : #if IS_ENABLED(CONFIG_SND_PCM_OSS)
    1123                 :            : /**
    1124                 :            :  * snd_pcm_notify - Add/remove the notify list
    1125                 :            :  * @notify: PCM notify list
    1126                 :            :  * @nfree: 0 = register, 1 = unregister
    1127                 :            :  *
    1128                 :            :  * This adds the given notifier to the global list so that the callback is
    1129                 :            :  * called for each registered PCM devices.  This exists only for PCM OSS
    1130                 :            :  * emulation, so far.
    1131                 :            :  */
    1132                 :            : int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree)
    1133                 :            : {
    1134                 :            :         struct snd_pcm *pcm;
    1135                 :            : 
    1136                 :            :         if (snd_BUG_ON(!notify ||
    1137                 :            :                        !notify->n_register ||
    1138                 :            :                        !notify->n_unregister ||
    1139                 :            :                        !notify->n_disconnect))
    1140                 :            :                 return -EINVAL;
    1141                 :            :         mutex_lock(&register_mutex);
    1142                 :            :         if (nfree) {
    1143                 :            :                 list_del(&notify->list);
    1144                 :            :                 list_for_each_entry(pcm, &snd_pcm_devices, list)
    1145                 :            :                         notify->n_unregister(pcm);
    1146                 :            :         } else {
    1147                 :            :                 list_add_tail(&notify->list, &snd_pcm_notify_list);
    1148                 :            :                 list_for_each_entry(pcm, &snd_pcm_devices, list)
    1149                 :            :                         notify->n_register(pcm);
    1150                 :            :         }
    1151                 :            :         mutex_unlock(&register_mutex);
    1152                 :            :         return 0;
    1153                 :            : }
    1154                 :            : EXPORT_SYMBOL(snd_pcm_notify);
    1155                 :            : #endif /* CONFIG_SND_PCM_OSS */
    1156                 :            : 
    1157                 :            : #ifdef CONFIG_SND_PROC_FS
    1158                 :            : /*
    1159                 :            :  *  Info interface
    1160                 :            :  */
    1161                 :            : 
    1162                 :          0 : static void snd_pcm_proc_read(struct snd_info_entry *entry,
    1163                 :            :                               struct snd_info_buffer *buffer)
    1164                 :            : {
    1165                 :            :         struct snd_pcm *pcm;
    1166                 :            : 
    1167                 :          0 :         mutex_lock(&register_mutex);
    1168         [ #  # ]:          0 :         list_for_each_entry(pcm, &snd_pcm_devices, list) {
    1169                 :          0 :                 snd_iprintf(buffer, "%02i-%02i: %s : %s",
    1170                 :            :                             pcm->card->number, pcm->device, pcm->id, pcm->name);
    1171         [ #  # ]:          0 :                 if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream)
    1172                 :          0 :                         snd_iprintf(buffer, " : playback %i",
    1173                 :            :                                     pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream_count);
    1174         [ #  # ]:          0 :                 if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream)
    1175                 :          0 :                         snd_iprintf(buffer, " : capture %i",
    1176                 :            :                                     pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count);
    1177                 :          0 :                 snd_iprintf(buffer, "\n");
    1178                 :            :         }
    1179                 :          0 :         mutex_unlock(&register_mutex);
    1180                 :          0 : }
    1181                 :            : 
    1182                 :            : static struct snd_info_entry *snd_pcm_proc_entry;
    1183                 :            : 
    1184                 :        207 : static void snd_pcm_proc_init(void)
    1185                 :            : {
    1186                 :            :         struct snd_info_entry *entry;
    1187                 :            : 
    1188                 :        207 :         entry = snd_info_create_module_entry(THIS_MODULE, "pcm", NULL);
    1189         [ +  - ]:        207 :         if (entry) {
    1190                 :            :                 snd_info_set_text_ops(entry, NULL, snd_pcm_proc_read);
    1191         [ -  + ]:        207 :                 if (snd_info_register(entry) < 0) {
    1192                 :          0 :                         snd_info_free_entry(entry);
    1193                 :            :                         entry = NULL;
    1194                 :            :                 }
    1195                 :            :         }
    1196                 :        207 :         snd_pcm_proc_entry = entry;
    1197                 :        207 : }
    1198                 :            : 
    1199                 :            : static void snd_pcm_proc_done(void)
    1200                 :            : {
    1201                 :          0 :         snd_info_free_entry(snd_pcm_proc_entry);
    1202                 :            : }
    1203                 :            : 
    1204                 :            : #else /* !CONFIG_SND_PROC_FS */
    1205                 :            : #define snd_pcm_proc_init()
    1206                 :            : #define snd_pcm_proc_done()
    1207                 :            : #endif /* CONFIG_SND_PROC_FS */
    1208                 :            : 
    1209                 :            : 
    1210                 :            : /*
    1211                 :            :  *  ENTRY functions
    1212                 :            :  */
    1213                 :            : 
    1214                 :        207 : static int __init alsa_pcm_init(void)
    1215                 :            : {
    1216                 :        207 :         snd_ctl_register_ioctl(snd_pcm_control_ioctl);
    1217                 :            :         snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl);
    1218                 :        207 :         snd_pcm_proc_init();
    1219                 :        207 :         return 0;
    1220                 :            : }
    1221                 :            : 
    1222                 :          0 : static void __exit alsa_pcm_exit(void)
    1223                 :            : {
    1224                 :          0 :         snd_ctl_unregister_ioctl(snd_pcm_control_ioctl);
    1225                 :            :         snd_ctl_unregister_ioctl_compat(snd_pcm_control_ioctl);
    1226                 :            :         snd_pcm_proc_done();
    1227                 :          0 : }
    1228                 :            : 
    1229                 :            : module_init(alsa_pcm_init)
    1230                 :            : module_exit(alsa_pcm_exit)

Generated by: LCOV version 1.14