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