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