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