a0f704b72a78ac996c102431be177986ea2ad474
[muen/linux.git] / sound / core / pcm.c
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         list_for_each_entry(pcm, &snd_pcm_devices, list) {
43                 if (pcm->card == card && pcm->device == device)
44                         return pcm;
45         }
46         return NULL;
47 }
48
49 static int snd_pcm_next(struct snd_card *card, int device)
50 {
51         struct snd_pcm *pcm;
52
53         list_for_each_entry(pcm, &snd_pcm_devices, list) {
54                 if (pcm->card == card && pcm->device > device)
55                         return pcm->device;
56                 else if (pcm->card->number > card->number)
57                         return -1;
58         }
59         return -1;
60 }
61
62 static int snd_pcm_add(struct snd_pcm *newpcm)
63 {
64         struct snd_pcm *pcm;
65
66         if (newpcm->internal)
67                 return 0;
68
69         list_for_each_entry(pcm, &snd_pcm_devices, list) {
70                 if (pcm->card == newpcm->card && pcm->device == newpcm->device)
71                         return -EBUSY;
72                 if (pcm->card->number > newpcm->card->number ||
73                                 (pcm->card == newpcm->card &&
74                                 pcm->device > newpcm->device)) {
75                         list_add(&newpcm->list, pcm->list.prev);
76                         return 0;
77                 }
78         }
79         list_add_tail(&newpcm->list, &snd_pcm_devices);
80         return 0;
81 }
82
83 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         switch (cmd) {
88         case SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE:
89                 {
90                         int device;
91
92                         if (get_user(device, (int __user *)arg))
93                                 return -EFAULT;
94                         mutex_lock(&register_mutex);
95                         device = snd_pcm_next(card, device);
96                         mutex_unlock(&register_mutex);
97                         if (put_user(device, (int __user *)arg))
98                                 return -EFAULT;
99                         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                         info = (struct snd_pcm_info __user *)arg;
112                         if (get_user(device, &info->device))
113                                 return -EFAULT;
114                         if (get_user(stream, &info->stream))
115                                 return -EFAULT;
116                         if (stream < 0 || stream > 1)
117                                 return -EINVAL;
118                         stream = array_index_nospec(stream, 2);
119                         if (get_user(subdevice, &info->subdevice))
120                                 return -EFAULT;
121                         mutex_lock(&register_mutex);
122                         pcm = snd_pcm_get(card, device);
123                         if (pcm == NULL) {
124                                 err = -ENXIO;
125                                 goto _error;
126                         }
127                         pstr = &pcm->streams[stream];
128                         if (pstr->substream_count == 0) {
129                                 err = -ENOENT;
130                                 goto _error;
131                         }
132                         if (subdevice >= pstr->substream_count) {
133                                 err = -ENXIO;
134                                 goto _error;
135                         }
136                         for (substream = pstr->substream; substream;
137                              substream = substream->next)
138                                 if (substream->number == (int)subdevice)
139                                         break;
140                         if (substream == NULL) {
141                                 err = -ENXIO;
142                                 goto _error;
143                         }
144                         mutex_lock(&pcm->open_mutex);
145                         err = snd_pcm_info_user(substream, info);
146                         mutex_unlock(&pcm->open_mutex);
147                 _error:
148                         mutex_unlock(&register_mutex);
149                         return err;
150                 }
151         case SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE:
152                 {
153                         int val;
154                         
155                         if (get_user(val, (int __user *)arg))
156                                 return -EFAULT;
157                         control->preferred_subdevice[SND_CTL_SUBDEV_PCM] = val;
158                         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 const char *snd_pcm_format_name(snd_pcm_format_t format)
221 {
222         if ((__force unsigned int)format >= ARRAY_SIZE(snd_pcm_format_names))
223                 return "Unknown";
224         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         return snd_pcm_stream_names[stream];
276 }
277
278 static const char *snd_pcm_access_name(snd_pcm_access_t access)
279 {
280         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         return snd_pcm_subformat_names[(__force int)subformat];
286 }
287
288 static const char *snd_pcm_tstamp_mode_name(int mode)
289 {
290         return snd_pcm_tstamp_mode_names[mode];
291 }
292
293 static const char *snd_pcm_state_name(snd_pcm_state_t state)
294 {
295         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 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         if (! substream)
337                 return;
338
339         info = kmalloc(sizeof(*info), GFP_KERNEL);
340         if (!info)
341                 return;
342
343         err = snd_pcm_info(substream, info);
344         if (err < 0) {
345                 snd_iprintf(buffer, "error %d\n", err);
346                 kfree(info);
347                 return;
348         }
349         snd_iprintf(buffer, "card: %d\n", info->card);
350         snd_iprintf(buffer, "device: %d\n", info->device);
351         snd_iprintf(buffer, "subdevice: %d\n", info->subdevice);
352         snd_iprintf(buffer, "stream: %s\n", snd_pcm_stream_name(info->stream));
353         snd_iprintf(buffer, "id: %s\n", info->id);
354         snd_iprintf(buffer, "name: %s\n", info->name);
355         snd_iprintf(buffer, "subname: %s\n", info->subname);
356         snd_iprintf(buffer, "class: %d\n", info->dev_class);
357         snd_iprintf(buffer, "subclass: %d\n", info->dev_subclass);
358         snd_iprintf(buffer, "subdevices_count: %d\n", info->subdevices_count);
359         snd_iprintf(buffer, "subdevices_avail: %d\n", info->subdevices_avail);
360         kfree(info);
361 }
362
363 static void snd_pcm_stream_proc_info_read(struct snd_info_entry *entry,
364                                           struct snd_info_buffer *buffer)
365 {
366         snd_pcm_proc_info_read(((struct snd_pcm_str *)entry->private_data)->substream,
367                                buffer);
368 }
369
370 static void snd_pcm_substream_proc_info_read(struct snd_info_entry *entry,
371                                              struct snd_info_buffer *buffer)
372 {
373         snd_pcm_proc_info_read(entry->private_data, buffer);
374 }
375
376 static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry,
377                                                   struct snd_info_buffer *buffer)
378 {
379         struct snd_pcm_substream *substream = entry->private_data;
380         struct snd_pcm_runtime *runtime;
381
382         mutex_lock(&substream->pcm->open_mutex);
383         runtime = substream->runtime;
384         if (!runtime) {
385                 snd_iprintf(buffer, "closed\n");
386                 goto unlock;
387         }
388         if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
389                 snd_iprintf(buffer, "no setup\n");
390                 goto unlock;
391         }
392         snd_iprintf(buffer, "access: %s\n", snd_pcm_access_name(runtime->access));
393         snd_iprintf(buffer, "format: %s\n", snd_pcm_format_name(runtime->format));
394         snd_iprintf(buffer, "subformat: %s\n", snd_pcm_subformat_name(runtime->subformat));
395         snd_iprintf(buffer, "channels: %u\n", runtime->channels);       
396         snd_iprintf(buffer, "rate: %u (%u/%u)\n", runtime->rate, runtime->rate_num, runtime->rate_den); 
397         snd_iprintf(buffer, "period_size: %lu\n", runtime->period_size);        
398         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         mutex_unlock(&substream->pcm->open_mutex);
411 }
412
413 static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry,
414                                                   struct snd_info_buffer *buffer)
415 {
416         struct snd_pcm_substream *substream = entry->private_data;
417         struct snd_pcm_runtime *runtime;
418
419         mutex_lock(&substream->pcm->open_mutex);
420         runtime = substream->runtime;
421         if (!runtime) {
422                 snd_iprintf(buffer, "closed\n");
423                 goto unlock;
424         }
425         if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
426                 snd_iprintf(buffer, "no setup\n");
427                 goto unlock;
428         }
429         snd_iprintf(buffer, "tstamp_mode: %s\n", snd_pcm_tstamp_mode_name(runtime->tstamp_mode));
430         snd_iprintf(buffer, "period_step: %u\n", runtime->period_step);
431         snd_iprintf(buffer, "avail_min: %lu\n", runtime->control->avail_min);
432         snd_iprintf(buffer, "start_threshold: %lu\n", runtime->start_threshold);
433         snd_iprintf(buffer, "stop_threshold: %lu\n", runtime->stop_threshold);
434         snd_iprintf(buffer, "silence_threshold: %lu\n", runtime->silence_threshold);
435         snd_iprintf(buffer, "silence_size: %lu\n", runtime->silence_size);
436         snd_iprintf(buffer, "boundary: %lu\n", runtime->boundary);
437  unlock:
438         mutex_unlock(&substream->pcm->open_mutex);
439 }
440
441 static void snd_pcm_substream_proc_status_read(struct snd_info_entry *entry,
442                                                struct snd_info_buffer *buffer)
443 {
444         struct snd_pcm_substream *substream = entry->private_data;
445         struct snd_pcm_runtime *runtime;
446         struct snd_pcm_status64 status;
447         int err;
448
449         mutex_lock(&substream->pcm->open_mutex);
450         runtime = substream->runtime;
451         if (!runtime) {
452                 snd_iprintf(buffer, "closed\n");
453                 goto unlock;
454         }
455         memset(&status, 0, sizeof(status));
456         err = snd_pcm_status64(substream, &status);
457         if (err < 0) {
458                 snd_iprintf(buffer, "error %d\n", err);
459                 goto unlock;
460         }
461         snd_iprintf(buffer, "state: %s\n", snd_pcm_state_name(status.state));
462         snd_iprintf(buffer, "owner_pid   : %d\n", pid_vnr(substream->pid));
463         snd_iprintf(buffer, "trigger_time: %lld.%09lld\n",
464                 status.trigger_tstamp_sec, status.trigger_tstamp_nsec);
465         snd_iprintf(buffer, "tstamp      : %lld.%09lld\n",
466                 status.tstamp_sec, status.tstamp_nsec);
467         snd_iprintf(buffer, "delay       : %ld\n", status.delay);
468         snd_iprintf(buffer, "avail       : %ld\n", status.avail);
469         snd_iprintf(buffer, "avail_max   : %ld\n", status.avail_max);
470         snd_iprintf(buffer, "-----\n");
471         snd_iprintf(buffer, "hw_ptr      : %ld\n", runtime->status->hw_ptr);
472         snd_iprintf(buffer, "appl_ptr    : %ld\n", runtime->control->appl_ptr);
473  unlock:
474         mutex_unlock(&substream->pcm->open_mutex);
475 }
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 static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr)
504 {
505         struct snd_pcm *pcm = pstr->pcm;
506         struct snd_info_entry *entry;
507         char name[16];
508
509         sprintf(name, "pcm%i%c", pcm->device, 
510                 pstr->stream == SNDRV_PCM_STREAM_PLAYBACK ? 'p' : 'c');
511         entry = snd_info_create_card_entry(pcm->card, name,
512                                            pcm->card->proc_root);
513         if (!entry)
514                 return -ENOMEM;
515         entry->mode = S_IFDIR | 0555;
516         pstr->proc_root = entry;
517         entry = snd_info_create_card_entry(pcm->card, "info", pstr->proc_root);
518         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         snd_info_free_entry(pstr->proc_root);
535         pstr->proc_root = NULL;
536         return 0;
537 }
538
539 static struct snd_info_entry *
540 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         entry = snd_info_create_card_entry(substream->pcm->card, name,
548                                            substream->proc_root);
549         if (entry)
550                 snd_info_set_text_ops(entry, substream, read);
551         return entry;
552 }
553
554 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         card = substream->pcm->card;
561
562         sprintf(name, "sub%i", substream->number);
563         entry = snd_info_create_card_entry(card, name,
564                                            substream->pstr->proc_root);
565         if (!entry)
566                 return -ENOMEM;
567         entry->mode = S_IFDIR | 0555;
568         substream->proc_root = entry;
569
570         create_substream_info_entry(substream, "info",
571                                     snd_pcm_substream_proc_info_read);
572         create_substream_info_entry(substream, "hw_params",
573                                     snd_pcm_substream_proc_hw_params_read);
574         create_substream_info_entry(substream, "sw_params",
575                                     snd_pcm_substream_proc_sw_params_read);
576         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         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 int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
637 {
638         int idx, err;
639         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         pstr->stream = stream;
646         pstr->pcm = pcm;
647         pstr->substream_count = substream_count;
648         if (!substream_count)
649                 return 0;
650
651         snd_device_initialize(&pstr->dev, pcm->card);
652         pstr->dev.groups = pcm_dev_attr_groups;
653         pstr->dev.type = &pcm_dev_type;
654         dev_set_name(&pstr->dev, "pcmC%iD%i%c", pcm->card->number, pcm->device,
655                      stream == SNDRV_PCM_STREAM_PLAYBACK ? 'p' : 'c');
656
657         if (!pcm->internal) {
658                 err = snd_pcm_stream_proc_init(pstr);
659                 if (err < 0) {
660                         pcm_err(pcm, "Error in snd_pcm_stream_proc_init\n");
661                         return err;
662                 }
663         }
664         prev = NULL;
665         for (idx = 0, prev = NULL; idx < substream_count; idx++) {
666                 substream = kzalloc(sizeof(*substream), GFP_KERNEL);
667                 if (!substream)
668                         return -ENOMEM;
669                 substream->pcm = pcm;
670                 substream->pstr = pstr;
671                 substream->number = idx;
672                 substream->stream = stream;
673                 sprintf(substream->name, "subdevice #%i", idx);
674                 substream->buffer_bytes_max = UINT_MAX;
675                 if (prev == NULL)
676                         pstr->substream = substream;
677                 else
678                         prev->next = substream;
679
680                 if (!pcm->internal) {
681                         err = snd_pcm_substream_proc_init(substream);
682                         if (err < 0) {
683                                 pcm_err(pcm,
684                                         "Error in snd_pcm_stream_proc_init\n");
685                                 if (prev == NULL)
686                                         pstr->substream = NULL;
687                                 else
688                                         prev->next = NULL;
689                                 kfree(substream);
690                                 return err;
691                         }
692                 }
693                 substream->group = &substream->self_group;
694                 snd_pcm_group_init(&substream->self_group);
695                 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 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 const 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 const struct snd_device_ops internal_ops = {
715                 .dev_free = snd_pcm_dev_free,
716         };
717
718         if (snd_BUG_ON(!card))
719                 return -ENXIO;
720         if (rpcm)
721                 *rpcm = NULL;
722         pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
723         if (!pcm)
724                 return -ENOMEM;
725         pcm->card = card;
726         pcm->device = device;
727         pcm->internal = internal;
728         mutex_init(&pcm->open_mutex);
729         init_waitqueue_head(&pcm->open_wait);
730         INIT_LIST_HEAD(&pcm->list);
731         if (id)
732                 strlcpy(pcm->id, id, sizeof(pcm->id));
733
734         err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_PLAYBACK,
735                                  playback_count);
736         if (err < 0)
737                 goto free_pcm;
738
739         err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_CAPTURE, capture_count);
740         if (err < 0)
741                 goto free_pcm;
742
743         err = snd_device_new(card, SNDRV_DEV_PCM, pcm,
744                              internal ? &internal_ops : &ops);
745         if (err < 0)
746                 goto free_pcm;
747
748         if (rpcm)
749                 *rpcm = pcm;
750         return 0;
751
752 free_pcm:
753         snd_pcm_free(pcm);
754         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 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         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 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         return _snd_pcm_new(card, id, device, playback_count, capture_count,
806                         true, rpcm);
807 }
808 EXPORT_SYMBOL(snd_pcm_new_internal);
809
810 static void free_chmap(struct snd_pcm_str *pstr)
811 {
812         if (pstr->chmap_kctl) {
813                 snd_ctl_remove(pstr->pcm->card, pstr->chmap_kctl);
814                 pstr->chmap_kctl = NULL;
815         }
816 }
817
818 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         substream = pstr->substream;
829         while (substream) {
830                 substream_next = substream->next;
831                 snd_pcm_timer_done(substream);
832                 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         free_chmap(pstr);
843         if (pstr->substream_count)
844                 put_device(&pstr->dev);
845 }
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 static int snd_pcm_free(struct snd_pcm *pcm)
859 {
860         if (!pcm)
861                 return 0;
862         if (!pcm->internal)
863                 pcm_call_notify(pcm, n_unregister);
864         if (pcm->private_free)
865                 pcm->private_free(pcm);
866         snd_pcm_lib_preallocate_free_for_all(pcm);
867         snd_pcm_free_stream(&pcm->streams[SNDRV_PCM_STREAM_PLAYBACK]);
868         snd_pcm_free_stream(&pcm->streams[SNDRV_PCM_STREAM_CAPTURE]);
869         kfree(pcm);
870         return 0;
871 }
872
873 static int snd_pcm_dev_free(struct snd_device *device)
874 {
875         struct snd_pcm *pcm = device->device_data;
876         return snd_pcm_free(pcm);
877 }
878
879 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         if (snd_BUG_ON(!pcm || !rsubstream))
891                 return -ENXIO;
892         if (snd_BUG_ON(stream != SNDRV_PCM_STREAM_PLAYBACK &&
893                        stream != SNDRV_PCM_STREAM_CAPTURE))
894                 return -EINVAL;
895         *rsubstream = NULL;
896         pstr = &pcm->streams[stream];
897         if (pstr->substream == NULL || pstr->substream_count == 0)
898                 return -ENODEV;
899
900         card = pcm->card;
901         prefer_subdevice = snd_ctl_get_preferred_subdevice(card, SND_CTL_SUBDEV_PCM);
902
903         if (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX) {
904                 int opposite = !stream;
905
906                 for (substream = pcm->streams[opposite].substream; substream;
907                      substream = substream->next) {
908                         if (SUBSTREAM_BUSY(substream))
909                                 return -EAGAIN;
910                 }
911         }
912
913         if (file->f_flags & O_APPEND) {
914                 if (prefer_subdevice < 0) {
915                         if (pstr->substream_count > 1)
916                                 return -EINVAL; /* must be unique */
917                         substream = pstr->substream;
918                 } else {
919                         for (substream = pstr->substream; substream;
920                              substream = substream->next)
921                                 if (substream->number == prefer_subdevice)
922                                         break;
923                 }
924                 if (! substream)
925                         return -ENODEV;
926                 if (! SUBSTREAM_BUSY(substream))
927                         return -EBADFD;
928                 substream->ref_count++;
929                 *rsubstream = substream;
930                 return 0;
931         }
932
933         for (substream = pstr->substream; substream; substream = substream->next) {
934                 if (!SUBSTREAM_BUSY(substream) &&
935                     (prefer_subdevice == -1 ||
936                      substream->number == prefer_subdevice))
937                         break;
938         }
939         if (substream == NULL)
940                 return -EAGAIN;
941
942         runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
943         if (runtime == NULL)
944                 return -ENOMEM;
945
946         size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status));
947         runtime->status = alloc_pages_exact(size, GFP_KERNEL);
948         if (runtime->status == NULL) {
949                 kfree(runtime);
950                 return -ENOMEM;
951         }
952         memset(runtime->status, 0, size);
953
954         size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control));
955         runtime->control = alloc_pages_exact(size, GFP_KERNEL);
956         if (runtime->control == NULL) {
957                 free_pages_exact(runtime->status,
958                                PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)));
959                 kfree(runtime);
960                 return -ENOMEM;
961         }
962         memset(runtime->control, 0, size);
963
964         init_waitqueue_head(&runtime->sleep);
965         init_waitqueue_head(&runtime->tsleep);
966
967         runtime->status->state = SNDRV_PCM_STATE_OPEN;
968
969         substream->runtime = runtime;
970         substream->private_data = pcm->private_data;
971         substream->ref_count = 1;
972         substream->f_flags = file->f_flags;
973         substream->pid = get_pid(task_pid(current));
974         pstr->substream_opened++;
975         *rsubstream = substream;
976         return 0;
977 }
978
979 void snd_pcm_detach_substream(struct snd_pcm_substream *substream)
980 {
981         struct snd_pcm_runtime *runtime;
982
983         if (PCM_RUNTIME_CHECK(substream))
984                 return;
985         runtime = substream->runtime;
986         if (runtime->private_free != NULL)
987                 runtime->private_free(runtime);
988         free_pages_exact(runtime->status,
989                        PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)));
990         free_pages_exact(runtime->control,
991                        PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)));
992         kfree(runtime->hw_constraints.rules);
993         /* Avoid concurrent access to runtime via PCM timer interface */
994         if (substream->timer)
995                 spin_lock_irq(&substream->timer->lock);
996         substream->runtime = NULL;
997         if (substream->timer)
998                 spin_unlock_irq(&substream->timer->lock);
999         kfree(runtime);
1000         put_pid(substream->pid);
1001         substream->pid = NULL;
1002         substream->pstr->substream_opened--;
1003 }
1004
1005 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         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         if (pcm->dev_class > SNDRV_PCM_CLASS_LAST)
1019                 str = "none";
1020         else
1021                 str = strs[pcm->dev_class];
1022         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 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         if (snd_BUG_ON(!device || !device->device_data))
1047                 return -ENXIO;
1048         pcm = device->device_data;
1049
1050         mutex_lock(&register_mutex);
1051         err = snd_pcm_add(pcm);
1052         if (err)
1053                 goto unlock;
1054         for (cidx = 0; cidx < 2; cidx++) {
1055                 int devtype = -1;
1056                 if (pcm->streams[cidx].substream == NULL)
1057                         continue;
1058                 switch (cidx) {
1059                 case SNDRV_PCM_STREAM_PLAYBACK:
1060                         devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK;
1061                         break;
1062                 case SNDRV_PCM_STREAM_CAPTURE:
1063                         devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE;
1064                         break;
1065                 }
1066                 /* register pcm */
1067                 err = snd_register_device(devtype, pcm->card, pcm->device,
1068                                           &snd_pcm_f_ops[cidx], pcm,
1069                                           &pcm->streams[cidx].dev);
1070                 if (err < 0) {
1071                         list_del_init(&pcm->list);
1072                         goto unlock;
1073                 }
1074
1075                 for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
1076                         snd_pcm_timer_init(substream);
1077         }
1078
1079         pcm_call_notify(pcm, n_register);
1080
1081  unlock:
1082         mutex_unlock(&register_mutex);
1083         return err;
1084 }
1085
1086 static int snd_pcm_dev_disconnect(struct snd_device *device)
1087 {
1088         struct snd_pcm *pcm = device->device_data;
1089         struct snd_pcm_substream *substream;
1090         int cidx;
1091
1092         mutex_lock(&register_mutex);
1093         mutex_lock(&pcm->open_mutex);
1094         wake_up(&pcm->open_wait);
1095         list_del_init(&pcm->list);
1096         for (cidx = 0; cidx < 2; cidx++) {
1097                 for (substream = pcm->streams[cidx].substream; substream; substream = substream->next) {
1098                         snd_pcm_stream_lock_irq(substream);
1099                         if (substream->runtime) {
1100                                 if (snd_pcm_running(substream))
1101                                         snd_pcm_stop(substream,
1102                                                      SNDRV_PCM_STATE_DISCONNECTED);
1103                                 /* to be sure, set the state unconditionally */
1104                                 substream->runtime->status->state = SNDRV_PCM_STATE_DISCONNECTED;
1105                                 wake_up(&substream->runtime->sleep);
1106                                 wake_up(&substream->runtime->tsleep);
1107                         }
1108                         snd_pcm_stream_unlock_irq(substream);
1109                 }
1110         }
1111
1112         pcm_call_notify(pcm, n_disconnect);
1113         for (cidx = 0; cidx < 2; cidx++) {
1114                 snd_unregister_device(&pcm->streams[cidx].dev);
1115                 free_chmap(&pcm->streams[cidx]);
1116         }
1117         mutex_unlock(&pcm->open_mutex);
1118         mutex_unlock(&register_mutex);
1119         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 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         mutex_lock(&register_mutex);
1168         list_for_each_entry(pcm, &snd_pcm_devices, list) {
1169                 snd_iprintf(buffer, "%02i-%02i: %s : %s",
1170                             pcm->card->number, pcm->device, pcm->id, pcm->name);
1171                 if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream)
1172                         snd_iprintf(buffer, " : playback %i",
1173                                     pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream_count);
1174                 if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream)
1175                         snd_iprintf(buffer, " : capture %i",
1176                                     pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count);
1177                 snd_iprintf(buffer, "\n");
1178         }
1179         mutex_unlock(&register_mutex);
1180 }
1181
1182 static struct snd_info_entry *snd_pcm_proc_entry;
1183
1184 static void snd_pcm_proc_init(void)
1185 {
1186         struct snd_info_entry *entry;
1187
1188         entry = snd_info_create_module_entry(THIS_MODULE, "pcm", NULL);
1189         if (entry) {
1190                 snd_info_set_text_ops(entry, NULL, snd_pcm_proc_read);
1191                 if (snd_info_register(entry) < 0) {
1192                         snd_info_free_entry(entry);
1193                         entry = NULL;
1194                 }
1195         }
1196         snd_pcm_proc_entry = entry;
1197 }
1198
1199 static void snd_pcm_proc_done(void)
1200 {
1201         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 static int __init alsa_pcm_init(void)
1215 {
1216         snd_ctl_register_ioctl(snd_pcm_control_ioctl);
1217         snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl);
1218         snd_pcm_proc_init();
1219         return 0;
1220 }
1221
1222 static void __exit alsa_pcm_exit(void)
1223 {
1224         snd_ctl_unregister_ioctl(snd_pcm_control_ioctl);
1225         snd_ctl_unregister_ioctl_compat(snd_pcm_control_ioctl);
1226         snd_pcm_proc_done();
1227 }
1228
1229 module_init(alsa_pcm_init)
1230 module_exit(alsa_pcm_exit)