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