1 /* 2 * Digital Audio (PCM) abstract layer 3 * Copyright (c) by Jaroslav Kysela <perex@suse.cz> 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 <sound/driver.h> 23 #include <linux/init.h> 24 #include <linux/slab.h> 25 #include <linux/time.h> 26 #include <sound/core.h> 27 #include <sound/minors.h> 28 #include <sound/pcm.h> 29 #include <sound/control.h> 30 #include <sound/info.h> 31 32 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>, Abramo Bagnara <abramo@alsa-project.org>"); 33 MODULE_DESCRIPTION("Midlevel PCM code for ALSA."); 34 MODULE_LICENSE("GPL"); 35 36 static LIST_HEAD(snd_pcm_devices); 37 static LIST_HEAD(snd_pcm_notify_list); 38 static DECLARE_MUTEX(register_mutex); 39 40 static int snd_pcm_free(struct snd_pcm *pcm); 41 static int snd_pcm_dev_free(struct snd_device *device); 42 static int snd_pcm_dev_register(struct snd_device *device); 43 static int snd_pcm_dev_disconnect(struct snd_device *device); 44 static int snd_pcm_dev_unregister(struct snd_device *device); 45 46 static struct snd_pcm *snd_pcm_search(struct snd_card *card, int device) 47 { 48 struct list_head *p; 49 struct snd_pcm *pcm; 50 51 list_for_each(p, &snd_pcm_devices) { 52 pcm = list_entry(p, struct snd_pcm, list); 53 if (pcm->card == card && pcm->device == device) 54 return pcm; 55 } 56 return NULL; 57 } 58 59 static int snd_pcm_control_ioctl(struct snd_card *card, 60 struct snd_ctl_file *control, 61 unsigned int cmd, unsigned long arg) 62 { 63 switch (cmd) { 64 case SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE: 65 { 66 int device; 67 68 if (get_user(device, (int __user *)arg)) 69 return -EFAULT; 70 down(®ister_mutex); 71 device = device < 0 ? 0 : device + 1; 72 while (device < SNDRV_PCM_DEVICES) { 73 if (snd_pcm_search(card, device)) 74 break; 75 device++; 76 } 77 if (device == SNDRV_PCM_DEVICES) 78 device = -1; 79 up(®ister_mutex); 80 if (put_user(device, (int __user *)arg)) 81 return -EFAULT; 82 return 0; 83 } 84 case SNDRV_CTL_IOCTL_PCM_INFO: 85 { 86 struct snd_pcm_info __user *info; 87 unsigned int device, subdevice; 88 int stream; 89 struct snd_pcm *pcm; 90 struct snd_pcm_str *pstr; 91 struct snd_pcm_substream *substream; 92 int err; 93 94 info = (struct snd_pcm_info __user *)arg; 95 if (get_user(device, &info->device)) 96 return -EFAULT; 97 if (get_user(stream, &info->stream)) 98 return -EFAULT; 99 if (stream < 0 || stream > 1) 100 return -EINVAL; 101 if (get_user(subdevice, &info->subdevice)) 102 return -EFAULT; 103 down(®ister_mutex); 104 pcm = snd_pcm_search(card, device); 105 if (pcm == NULL) { 106 err = -ENXIO; 107 goto _error; 108 } 109 pstr = &pcm->streams[stream]; 110 if (pstr->substream_count == 0) { 111 err = -ENOENT; 112 goto _error; 113 } 114 if (subdevice >= pstr->substream_count) { 115 err = -ENXIO; 116 goto _error; 117 } 118 for (substream = pstr->substream; substream; 119 substream = substream->next) 120 if (substream->number == (int)subdevice) 121 break; 122 if (substream == NULL) { 123 err = -ENXIO; 124 goto _error; 125 } 126 err = snd_pcm_info_user(substream, info); 127 _error: 128 up(®ister_mutex); 129 return err; 130 } 131 case SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE: 132 { 133 int val; 134 135 if (get_user(val, (int __user *)arg)) 136 return -EFAULT; 137 control->prefer_pcm_subdevice = val; 138 return 0; 139 } 140 } 141 return -ENOIOCTLCMD; 142 } 143 #define STATE(v) [SNDRV_PCM_STATE_##v] = #v 144 #define STREAM(v) [SNDRV_PCM_STREAM_##v] = #v 145 #define READY(v) [SNDRV_PCM_READY_##v] = #v 146 #define XRUN(v) [SNDRV_PCM_XRUN_##v] = #v 147 #define SILENCE(v) [SNDRV_PCM_SILENCE_##v] = #v 148 #define TSTAMP(v) [SNDRV_PCM_TSTAMP_##v] = #v 149 #define ACCESS(v) [SNDRV_PCM_ACCESS_##v] = #v 150 #define START(v) [SNDRV_PCM_START_##v] = #v 151 #define FORMAT(v) [SNDRV_PCM_FORMAT_##v] = #v 152 #define SUBFORMAT(v) [SNDRV_PCM_SUBFORMAT_##v] = #v 153 154 static char *snd_pcm_format_names[] = { 155 FORMAT(S8), 156 FORMAT(U8), 157 FORMAT(S16_LE), 158 FORMAT(S16_BE), 159 FORMAT(U16_LE), 160 FORMAT(U16_BE), 161 FORMAT(S24_LE), 162 FORMAT(S24_BE), 163 FORMAT(U24_LE), 164 FORMAT(U24_BE), 165 FORMAT(S32_LE), 166 FORMAT(S32_BE), 167 FORMAT(U32_LE), 168 FORMAT(U32_BE), 169 FORMAT(FLOAT_LE), 170 FORMAT(FLOAT_BE), 171 FORMAT(FLOAT64_LE), 172 FORMAT(FLOAT64_BE), 173 FORMAT(IEC958_SUBFRAME_LE), 174 FORMAT(IEC958_SUBFRAME_BE), 175 FORMAT(MU_LAW), 176 FORMAT(A_LAW), 177 FORMAT(IMA_ADPCM), 178 FORMAT(MPEG), 179 FORMAT(GSM), 180 FORMAT(SPECIAL), 181 FORMAT(S24_3LE), 182 FORMAT(S24_3BE), 183 FORMAT(U24_3LE), 184 FORMAT(U24_3BE), 185 FORMAT(S20_3LE), 186 FORMAT(S20_3BE), 187 FORMAT(U20_3LE), 188 FORMAT(U20_3BE), 189 FORMAT(S18_3LE), 190 FORMAT(S18_3BE), 191 FORMAT(U18_3LE), 192 FORMAT(U18_3BE), 193 }; 194 195 const char *snd_pcm_format_name(snd_pcm_format_t format) 196 { 197 return snd_pcm_format_names[format]; 198 } 199 200 #ifdef CONFIG_PROC_FS 201 static char *snd_pcm_stream_names[] = { 202 STREAM(PLAYBACK), 203 STREAM(CAPTURE), 204 }; 205 206 static char *snd_pcm_state_names[] = { 207 STATE(OPEN), 208 STATE(SETUP), 209 STATE(PREPARED), 210 STATE(RUNNING), 211 STATE(XRUN), 212 STATE(DRAINING), 213 STATE(PAUSED), 214 STATE(SUSPENDED), 215 }; 216 217 static char *snd_pcm_access_names[] = { 218 ACCESS(MMAP_INTERLEAVED), 219 ACCESS(MMAP_NONINTERLEAVED), 220 ACCESS(MMAP_COMPLEX), 221 ACCESS(RW_INTERLEAVED), 222 ACCESS(RW_NONINTERLEAVED), 223 }; 224 225 static char *snd_pcm_subformat_names[] = { 226 SUBFORMAT(STD), 227 }; 228 229 static char *snd_pcm_tstamp_mode_names[] = { 230 TSTAMP(NONE), 231 TSTAMP(MMAP), 232 }; 233 234 static const char *snd_pcm_stream_name(int stream) 235 { 236 snd_assert(stream <= SNDRV_PCM_STREAM_LAST, return NULL); 237 return snd_pcm_stream_names[stream]; 238 } 239 240 static const char *snd_pcm_access_name(snd_pcm_access_t access) 241 { 242 return snd_pcm_access_names[access]; 243 } 244 245 static const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat) 246 { 247 return snd_pcm_subformat_names[subformat]; 248 } 249 250 static const char *snd_pcm_tstamp_mode_name(int mode) 251 { 252 snd_assert(mode <= SNDRV_PCM_TSTAMP_LAST, return NULL); 253 return snd_pcm_tstamp_mode_names[mode]; 254 } 255 256 static const char *snd_pcm_state_name(snd_pcm_state_t state) 257 { 258 return snd_pcm_state_names[state]; 259 } 260 261 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) 262 #include <linux/soundcard.h> 263 static const char *snd_pcm_oss_format_name(int format) 264 { 265 switch (format) { 266 case AFMT_MU_LAW: 267 return "MU_LAW"; 268 case AFMT_A_LAW: 269 return "A_LAW"; 270 case AFMT_IMA_ADPCM: 271 return "IMA_ADPCM"; 272 case AFMT_U8: 273 return "U8"; 274 case AFMT_S16_LE: 275 return "S16_LE"; 276 case AFMT_S16_BE: 277 return "S16_BE"; 278 case AFMT_S8: 279 return "S8"; 280 case AFMT_U16_LE: 281 return "U16_LE"; 282 case AFMT_U16_BE: 283 return "U16_BE"; 284 case AFMT_MPEG: 285 return "MPEG"; 286 default: 287 return "unknown"; 288 } 289 } 290 #endif 291 292 static void snd_pcm_proc_info_read(struct snd_pcm_substream *substream, 293 struct snd_info_buffer *buffer) 294 { 295 struct snd_pcm_info *info; 296 int err; 297 298 if (! substream) 299 return; 300 301 info = kmalloc(sizeof(*info), GFP_KERNEL); 302 if (! info) { 303 printk(KERN_DEBUG "snd_pcm_proc_info_read: cannot malloc\n"); 304 return; 305 } 306 307 err = snd_pcm_info(substream, info); 308 if (err < 0) { 309 snd_iprintf(buffer, "error %d\n", err); 310 kfree(info); 311 return; 312 } 313 snd_iprintf(buffer, "card: %d\n", info->card); 314 snd_iprintf(buffer, "device: %d\n", info->device); 315 snd_iprintf(buffer, "subdevice: %d\n", info->subdevice); 316 snd_iprintf(buffer, "stream: %s\n", snd_pcm_stream_name(info->stream)); 317 snd_iprintf(buffer, "id: %s\n", info->id); 318 snd_iprintf(buffer, "name: %s\n", info->name); 319 snd_iprintf(buffer, "subname: %s\n", info->subname); 320 snd_iprintf(buffer, "class: %d\n", info->dev_class); 321 snd_iprintf(buffer, "subclass: %d\n", info->dev_subclass); 322 snd_iprintf(buffer, "subdevices_count: %d\n", info->subdevices_count); 323 snd_iprintf(buffer, "subdevices_avail: %d\n", info->subdevices_avail); 324 kfree(info); 325 } 326 327 static void snd_pcm_stream_proc_info_read(struct snd_info_entry *entry, 328 struct snd_info_buffer *buffer) 329 { 330 snd_pcm_proc_info_read(((struct snd_pcm_str *)entry->private_data)->substream, 331 buffer); 332 } 333 334 static void snd_pcm_substream_proc_info_read(struct snd_info_entry *entry, 335 struct snd_info_buffer *buffer) 336 { 337 snd_pcm_proc_info_read((struct snd_pcm_substream *)entry->private_data, 338 buffer); 339 } 340 341 static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry, 342 struct snd_info_buffer *buffer) 343 { 344 struct snd_pcm_substream *substream = entry->private_data; 345 struct snd_pcm_runtime *runtime = substream->runtime; 346 if (!runtime) { 347 snd_iprintf(buffer, "closed\n"); 348 return; 349 } 350 snd_pcm_stream_lock_irq(substream); 351 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) { 352 snd_iprintf(buffer, "no setup\n"); 353 snd_pcm_stream_unlock_irq(substream); 354 return; 355 } 356 snd_iprintf(buffer, "access: %s\n", snd_pcm_access_name(runtime->access)); 357 snd_iprintf(buffer, "format: %s\n", snd_pcm_format_name(runtime->format)); 358 snd_iprintf(buffer, "subformat: %s\n", snd_pcm_subformat_name(runtime->subformat)); 359 snd_iprintf(buffer, "channels: %u\n", runtime->channels); 360 snd_iprintf(buffer, "rate: %u (%u/%u)\n", runtime->rate, runtime->rate_num, runtime->rate_den); 361 snd_iprintf(buffer, "period_size: %lu\n", runtime->period_size); 362 snd_iprintf(buffer, "buffer_size: %lu\n", runtime->buffer_size); 363 snd_iprintf(buffer, "tick_time: %u\n", runtime->tick_time); 364 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) 365 if (substream->oss.oss) { 366 snd_iprintf(buffer, "OSS format: %s\n", snd_pcm_oss_format_name(runtime->oss.format)); 367 snd_iprintf(buffer, "OSS channels: %u\n", runtime->oss.channels); 368 snd_iprintf(buffer, "OSS rate: %u\n", runtime->oss.rate); 369 snd_iprintf(buffer, "OSS period bytes: %lu\n", (unsigned long)runtime->oss.period_bytes); 370 snd_iprintf(buffer, "OSS periods: %u\n", runtime->oss.periods); 371 snd_iprintf(buffer, "OSS period frames: %lu\n", (unsigned long)runtime->oss.period_frames); 372 } 373 #endif 374 snd_pcm_stream_unlock_irq(substream); 375 } 376 377 static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry, 378 struct snd_info_buffer *buffer) 379 { 380 struct snd_pcm_substream *substream = entry->private_data; 381 struct snd_pcm_runtime *runtime = substream->runtime; 382 if (!runtime) { 383 snd_iprintf(buffer, "closed\n"); 384 return; 385 } 386 snd_pcm_stream_lock_irq(substream); 387 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) { 388 snd_iprintf(buffer, "no setup\n"); 389 snd_pcm_stream_unlock_irq(substream); 390 return; 391 } 392 snd_iprintf(buffer, "tstamp_mode: %s\n", snd_pcm_tstamp_mode_name(runtime->tstamp_mode)); 393 snd_iprintf(buffer, "period_step: %u\n", runtime->period_step); 394 snd_iprintf(buffer, "sleep_min: %u\n", runtime->sleep_min); 395 snd_iprintf(buffer, "avail_min: %lu\n", runtime->control->avail_min); 396 snd_iprintf(buffer, "xfer_align: %lu\n", runtime->xfer_align); 397 snd_iprintf(buffer, "start_threshold: %lu\n", runtime->start_threshold); 398 snd_iprintf(buffer, "stop_threshold: %lu\n", runtime->stop_threshold); 399 snd_iprintf(buffer, "silence_threshold: %lu\n", runtime->silence_threshold); 400 snd_iprintf(buffer, "silence_size: %lu\n", runtime->silence_size); 401 snd_iprintf(buffer, "boundary: %lu\n", runtime->boundary); 402 snd_pcm_stream_unlock_irq(substream); 403 } 404 405 static void snd_pcm_substream_proc_status_read(struct snd_info_entry *entry, 406 struct snd_info_buffer *buffer) 407 { 408 struct snd_pcm_substream *substream = entry->private_data; 409 struct snd_pcm_runtime *runtime = substream->runtime; 410 struct snd_pcm_status status; 411 int err; 412 if (!runtime) { 413 snd_iprintf(buffer, "closed\n"); 414 return; 415 } 416 memset(&status, 0, sizeof(status)); 417 err = snd_pcm_status(substream, &status); 418 if (err < 0) { 419 snd_iprintf(buffer, "error %d\n", err); 420 return; 421 } 422 snd_iprintf(buffer, "state: %s\n", snd_pcm_state_name(status.state)); 423 snd_iprintf(buffer, "trigger_time: %ld.%09ld\n", 424 status.trigger_tstamp.tv_sec, status.trigger_tstamp.tv_nsec); 425 snd_iprintf(buffer, "tstamp : %ld.%09ld\n", 426 status.tstamp.tv_sec, status.tstamp.tv_nsec); 427 snd_iprintf(buffer, "delay : %ld\n", status.delay); 428 snd_iprintf(buffer, "avail : %ld\n", status.avail); 429 snd_iprintf(buffer, "avail_max : %ld\n", status.avail_max); 430 snd_iprintf(buffer, "-----\n"); 431 snd_iprintf(buffer, "hw_ptr : %ld\n", runtime->status->hw_ptr); 432 snd_iprintf(buffer, "appl_ptr : %ld\n", runtime->control->appl_ptr); 433 } 434 435 #ifdef CONFIG_SND_DEBUG 436 static void snd_pcm_xrun_debug_read(struct snd_info_entry *entry, 437 struct snd_info_buffer *buffer) 438 { 439 struct snd_pcm_str *pstr = entry->private_data; 440 snd_iprintf(buffer, "%d\n", pstr->xrun_debug); 441 } 442 443 static void snd_pcm_xrun_debug_write(struct snd_info_entry *entry, 444 struct snd_info_buffer *buffer) 445 { 446 struct snd_pcm_str *pstr = entry->private_data; 447 char line[64]; 448 if (!snd_info_get_line(buffer, line, sizeof(line))) 449 pstr->xrun_debug = simple_strtoul(line, NULL, 10); 450 } 451 #endif 452 453 static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr) 454 { 455 struct snd_pcm *pcm = pstr->pcm; 456 struct snd_info_entry *entry; 457 char name[16]; 458 459 sprintf(name, "pcm%i%c", pcm->device, 460 pstr->stream == SNDRV_PCM_STREAM_PLAYBACK ? 'p' : 'c'); 461 if ((entry = snd_info_create_card_entry(pcm->card, name, pcm->card->proc_root)) == NULL) 462 return -ENOMEM; 463 entry->mode = S_IFDIR | S_IRUGO | S_IXUGO; 464 if (snd_info_register(entry) < 0) { 465 snd_info_free_entry(entry); 466 return -ENOMEM; 467 } 468 pstr->proc_root = entry; 469 470 if ((entry = snd_info_create_card_entry(pcm->card, "info", pstr->proc_root)) != NULL) { 471 snd_info_set_text_ops(entry, pstr, 256, snd_pcm_stream_proc_info_read); 472 if (snd_info_register(entry) < 0) { 473 snd_info_free_entry(entry); 474 entry = NULL; 475 } 476 } 477 pstr->proc_info_entry = entry; 478 479 #ifdef CONFIG_SND_DEBUG 480 if ((entry = snd_info_create_card_entry(pcm->card, "xrun_debug", 481 pstr->proc_root)) != NULL) { 482 entry->c.text.read_size = 64; 483 entry->c.text.read = snd_pcm_xrun_debug_read; 484 entry->c.text.write_size = 64; 485 entry->c.text.write = snd_pcm_xrun_debug_write; 486 entry->mode |= S_IWUSR; 487 entry->private_data = pstr; 488 if (snd_info_register(entry) < 0) { 489 snd_info_free_entry(entry); 490 entry = NULL; 491 } 492 } 493 pstr->proc_xrun_debug_entry = entry; 494 #endif 495 return 0; 496 } 497 498 static int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr) 499 { 500 #ifdef CONFIG_SND_DEBUG 501 if (pstr->proc_xrun_debug_entry) { 502 snd_info_unregister(pstr->proc_xrun_debug_entry); 503 pstr->proc_xrun_debug_entry = NULL; 504 } 505 #endif 506 if (pstr->proc_info_entry) { 507 snd_info_unregister(pstr->proc_info_entry); 508 pstr->proc_info_entry = NULL; 509 } 510 if (pstr->proc_root) { 511 snd_info_unregister(pstr->proc_root); 512 pstr->proc_root = NULL; 513 } 514 return 0; 515 } 516 517 static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream) 518 { 519 struct snd_info_entry *entry; 520 struct snd_card *card; 521 char name[16]; 522 523 card = substream->pcm->card; 524 525 sprintf(name, "sub%i", substream->number); 526 if ((entry = snd_info_create_card_entry(card, name, substream->pstr->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 substream->proc_root = entry; 534 535 if ((entry = snd_info_create_card_entry(card, "info", substream->proc_root)) != NULL) { 536 snd_info_set_text_ops(entry, substream, 256, snd_pcm_substream_proc_info_read); 537 if (snd_info_register(entry) < 0) { 538 snd_info_free_entry(entry); 539 entry = NULL; 540 } 541 } 542 substream->proc_info_entry = entry; 543 544 if ((entry = snd_info_create_card_entry(card, "hw_params", substream->proc_root)) != NULL) { 545 snd_info_set_text_ops(entry, substream, 256, snd_pcm_substream_proc_hw_params_read); 546 if (snd_info_register(entry) < 0) { 547 snd_info_free_entry(entry); 548 entry = NULL; 549 } 550 } 551 substream->proc_hw_params_entry = entry; 552 553 if ((entry = snd_info_create_card_entry(card, "sw_params", substream->proc_root)) != NULL) { 554 snd_info_set_text_ops(entry, substream, 256, snd_pcm_substream_proc_sw_params_read); 555 if (snd_info_register(entry) < 0) { 556 snd_info_free_entry(entry); 557 entry = NULL; 558 } 559 } 560 substream->proc_sw_params_entry = entry; 561 562 if ((entry = snd_info_create_card_entry(card, "status", substream->proc_root)) != NULL) { 563 snd_info_set_text_ops(entry, substream, 256, snd_pcm_substream_proc_status_read); 564 if (snd_info_register(entry) < 0) { 565 snd_info_free_entry(entry); 566 entry = NULL; 567 } 568 } 569 substream->proc_status_entry = entry; 570 571 return 0; 572 } 573 574 static int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream) 575 { 576 if (substream->proc_info_entry) { 577 snd_info_unregister(substream->proc_info_entry); 578 substream->proc_info_entry = NULL; 579 } 580 if (substream->proc_hw_params_entry) { 581 snd_info_unregister(substream->proc_hw_params_entry); 582 substream->proc_hw_params_entry = NULL; 583 } 584 if (substream->proc_sw_params_entry) { 585 snd_info_unregister(substream->proc_sw_params_entry); 586 substream->proc_sw_params_entry = NULL; 587 } 588 if (substream->proc_status_entry) { 589 snd_info_unregister(substream->proc_status_entry); 590 substream->proc_status_entry = NULL; 591 } 592 if (substream->proc_root) { 593 snd_info_unregister(substream->proc_root); 594 substream->proc_root = NULL; 595 } 596 return 0; 597 } 598 #else /* !CONFIG_PROC_FS */ 599 static inline int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr) { return 0; } 600 static inline int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr) { return 0; } 601 static inline int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream) { return 0; } 602 static inline int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream) { return 0; } 603 #endif /* CONFIG_PROC_FS */ 604 605 /** 606 * snd_pcm_new_stream - create a new PCM stream 607 * @pcm: the pcm instance 608 * @stream: the stream direction, SNDRV_PCM_STREAM_XXX 609 * @substream_count: the number of substreams 610 * 611 * Creates a new stream for the pcm. 612 * The corresponding stream on the pcm must have been empty before 613 * calling this, i.e. zero must be given to the argument of 614 * snd_pcm_new(). 615 * 616 * Returns zero if successful, or a negative error code on failure. 617 */ 618 int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count) 619 { 620 int idx, err; 621 struct snd_pcm_str *pstr = &pcm->streams[stream]; 622 struct snd_pcm_substream *substream, *prev; 623 624 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) 625 init_MUTEX(&pstr->oss.setup_mutex); 626 #endif 627 pstr->stream = stream; 628 pstr->pcm = pcm; 629 pstr->substream_count = substream_count; 630 if (substream_count > 0) { 631 err = snd_pcm_stream_proc_init(pstr); 632 if (err < 0) { 633 snd_printk(KERN_ERR "Error in snd_pcm_stream_proc_init\n"); 634 return err; 635 } 636 } 637 prev = NULL; 638 for (idx = 0, prev = NULL; idx < substream_count; idx++) { 639 substream = kzalloc(sizeof(*substream), GFP_KERNEL); 640 if (substream == NULL) { 641 snd_printk(KERN_ERR "Cannot allocate PCM substream\n"); 642 return -ENOMEM; 643 } 644 substream->pcm = pcm; 645 substream->pstr = pstr; 646 substream->number = idx; 647 substream->stream = stream; 648 sprintf(substream->name, "subdevice #%i", idx); 649 substream->buffer_bytes_max = UINT_MAX; 650 if (prev == NULL) 651 pstr->substream = substream; 652 else 653 prev->next = substream; 654 err = snd_pcm_substream_proc_init(substream); 655 if (err < 0) { 656 snd_printk(KERN_ERR "Error in snd_pcm_stream_proc_init\n"); 657 kfree(substream); 658 return err; 659 } 660 substream->group = &substream->self_group; 661 spin_lock_init(&substream->self_group.lock); 662 INIT_LIST_HEAD(&substream->self_group.substreams); 663 list_add_tail(&substream->link_list, &substream->self_group.substreams); 664 spin_lock_init(&substream->timer_lock); 665 prev = substream; 666 } 667 return 0; 668 } 669 670 /** 671 * snd_pcm_new - create a new PCM instance 672 * @card: the card instance 673 * @id: the id string 674 * @device: the device index (zero based) 675 * @playback_count: the number of substreams for playback 676 * @capture_count: the number of substreams for capture 677 * @rpcm: the pointer to store the new pcm instance 678 * 679 * Creates a new PCM instance. 680 * 681 * The pcm operators have to be set afterwards to the new instance 682 * via snd_pcm_set_ops(). 683 * 684 * Returns zero if successful, or a negative error code on failure. 685 */ 686 int snd_pcm_new(struct snd_card *card, char *id, int device, 687 int playback_count, int capture_count, 688 struct snd_pcm ** rpcm) 689 { 690 struct snd_pcm *pcm; 691 int err; 692 static struct snd_device_ops ops = { 693 .dev_free = snd_pcm_dev_free, 694 .dev_register = snd_pcm_dev_register, 695 .dev_disconnect = snd_pcm_dev_disconnect, 696 .dev_unregister = snd_pcm_dev_unregister 697 }; 698 699 snd_assert(rpcm != NULL, return -EINVAL); 700 *rpcm = NULL; 701 snd_assert(card != NULL, return -ENXIO); 702 pcm = kzalloc(sizeof(*pcm), GFP_KERNEL); 703 if (pcm == NULL) { 704 snd_printk(KERN_ERR "Cannot allocate PCM\n"); 705 return -ENOMEM; 706 } 707 pcm->card = card; 708 pcm->device = device; 709 if (id) 710 strlcpy(pcm->id, id, sizeof(pcm->id)); 711 if ((err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_PLAYBACK, playback_count)) < 0) { 712 snd_pcm_free(pcm); 713 return err; 714 } 715 if ((err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_CAPTURE, capture_count)) < 0) { 716 snd_pcm_free(pcm); 717 return err; 718 } 719 init_MUTEX(&pcm->open_mutex); 720 init_waitqueue_head(&pcm->open_wait); 721 if ((err = snd_device_new(card, SNDRV_DEV_PCM, pcm, &ops)) < 0) { 722 snd_pcm_free(pcm); 723 return err; 724 } 725 *rpcm = pcm; 726 return 0; 727 } 728 729 static void snd_pcm_free_stream(struct snd_pcm_str * pstr) 730 { 731 struct snd_pcm_substream *substream, *substream_next; 732 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) 733 struct snd_pcm_oss_setup *setup, *setupn; 734 #endif 735 substream = pstr->substream; 736 while (substream) { 737 substream_next = substream->next; 738 snd_pcm_substream_proc_done(substream); 739 kfree(substream); 740 substream = substream_next; 741 } 742 snd_pcm_stream_proc_done(pstr); 743 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) 744 for (setup = pstr->oss.setup_list; setup; setup = setupn) { 745 setupn = setup->next; 746 kfree(setup->task_name); 747 kfree(setup); 748 } 749 #endif 750 } 751 752 static int snd_pcm_free(struct snd_pcm *pcm) 753 { 754 snd_assert(pcm != NULL, return -ENXIO); 755 if (pcm->private_free) 756 pcm->private_free(pcm); 757 snd_pcm_lib_preallocate_free_for_all(pcm); 758 snd_pcm_free_stream(&pcm->streams[SNDRV_PCM_STREAM_PLAYBACK]); 759 snd_pcm_free_stream(&pcm->streams[SNDRV_PCM_STREAM_CAPTURE]); 760 kfree(pcm); 761 return 0; 762 } 763 764 static int snd_pcm_dev_free(struct snd_device *device) 765 { 766 struct snd_pcm *pcm = device->device_data; 767 return snd_pcm_free(pcm); 768 } 769 770 static void snd_pcm_tick_timer_func(unsigned long data) 771 { 772 struct snd_pcm_substream *substream = (struct snd_pcm_substream *) data; 773 snd_pcm_tick_elapsed(substream); 774 } 775 776 int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, 777 struct snd_pcm_substream **rsubstream) 778 { 779 struct snd_pcm_str * pstr; 780 struct snd_pcm_substream *substream; 781 struct snd_pcm_runtime *runtime; 782 struct snd_ctl_file *kctl; 783 struct snd_card *card; 784 struct list_head *list; 785 int prefer_subdevice = -1; 786 size_t size; 787 788 snd_assert(rsubstream != NULL, return -EINVAL); 789 *rsubstream = NULL; 790 snd_assert(pcm != NULL, return -ENXIO); 791 pstr = &pcm->streams[stream]; 792 if (pstr->substream == NULL) 793 return -ENODEV; 794 795 card = pcm->card; 796 down_read(&card->controls_rwsem); 797 list_for_each(list, &card->ctl_files) { 798 kctl = snd_ctl_file(list); 799 if (kctl->pid == current->pid) { 800 prefer_subdevice = kctl->prefer_pcm_subdevice; 801 break; 802 } 803 } 804 up_read(&card->controls_rwsem); 805 806 if (pstr->substream_count == 0) 807 return -ENODEV; 808 switch (stream) { 809 case SNDRV_PCM_STREAM_PLAYBACK: 810 if (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX) { 811 for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream; substream; substream = substream->next) { 812 if (SUBSTREAM_BUSY(substream)) 813 return -EAGAIN; 814 } 815 } 816 break; 817 case SNDRV_PCM_STREAM_CAPTURE: 818 if (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX) { 819 for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next) { 820 if (SUBSTREAM_BUSY(substream)) 821 return -EAGAIN; 822 } 823 } 824 break; 825 default: 826 return -EINVAL; 827 } 828 829 if (prefer_subdevice >= 0) { 830 for (substream = pstr->substream; substream; substream = substream->next) 831 if (!SUBSTREAM_BUSY(substream) && substream->number == prefer_subdevice) 832 goto __ok; 833 } 834 for (substream = pstr->substream; substream; substream = substream->next) 835 if (!SUBSTREAM_BUSY(substream)) 836 break; 837 __ok: 838 if (substream == NULL) 839 return -EAGAIN; 840 841 runtime = kzalloc(sizeof(*runtime), GFP_KERNEL); 842 if (runtime == NULL) 843 return -ENOMEM; 844 845 size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)); 846 runtime->status = snd_malloc_pages(size, GFP_KERNEL); 847 if (runtime->status == NULL) { 848 kfree(runtime); 849 return -ENOMEM; 850 } 851 memset((void*)runtime->status, 0, size); 852 853 size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)); 854 runtime->control = snd_malloc_pages(size, GFP_KERNEL); 855 if (runtime->control == NULL) { 856 snd_free_pages((void*)runtime->status, 857 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status))); 858 kfree(runtime); 859 return -ENOMEM; 860 } 861 memset((void*)runtime->control, 0, size); 862 863 init_waitqueue_head(&runtime->sleep); 864 atomic_set(&runtime->mmap_count, 0); 865 init_timer(&runtime->tick_timer); 866 runtime->tick_timer.function = snd_pcm_tick_timer_func; 867 runtime->tick_timer.data = (unsigned long) substream; 868 869 runtime->status->state = SNDRV_PCM_STATE_OPEN; 870 871 substream->runtime = runtime; 872 substream->private_data = pcm->private_data; 873 pstr->substream_opened++; 874 *rsubstream = substream; 875 return 0; 876 } 877 878 void snd_pcm_release_substream(struct snd_pcm_substream *substream) 879 { 880 struct snd_pcm_runtime *runtime; 881 substream->file = NULL; 882 runtime = substream->runtime; 883 snd_assert(runtime != NULL, return); 884 if (runtime->private_free != NULL) 885 runtime->private_free(runtime); 886 snd_free_pages((void*)runtime->status, 887 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status))); 888 snd_free_pages((void*)runtime->control, 889 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control))); 890 kfree(runtime->hw_constraints.rules); 891 kfree(runtime); 892 substream->runtime = NULL; 893 substream->pstr->substream_opened--; 894 } 895 896 static int snd_pcm_dev_register(struct snd_device *device) 897 { 898 int cidx, err; 899 struct snd_pcm_substream *substream; 900 struct list_head *list; 901 char str[16]; 902 struct snd_pcm *pcm = device->device_data; 903 904 snd_assert(pcm != NULL && device != NULL, return -ENXIO); 905 down(®ister_mutex); 906 if (snd_pcm_search(pcm->card, pcm->device)) { 907 up(®ister_mutex); 908 return -EBUSY; 909 } 910 list_add_tail(&pcm->list, &snd_pcm_devices); 911 for (cidx = 0; cidx < 2; cidx++) { 912 int devtype = -1; 913 if (pcm->streams[cidx].substream == NULL) 914 continue; 915 switch (cidx) { 916 case SNDRV_PCM_STREAM_PLAYBACK: 917 sprintf(str, "pcmC%iD%ip", pcm->card->number, pcm->device); 918 devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK; 919 break; 920 case SNDRV_PCM_STREAM_CAPTURE: 921 sprintf(str, "pcmC%iD%ic", pcm->card->number, pcm->device); 922 devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE; 923 break; 924 } 925 if ((err = snd_register_device(devtype, pcm->card, 926 pcm->device, 927 &snd_pcm_f_ops[cidx], 928 pcm, str)) < 0) 929 { 930 list_del(&pcm->list); 931 up(®ister_mutex); 932 return err; 933 } 934 for (substream = pcm->streams[cidx].substream; substream; substream = substream->next) 935 snd_pcm_timer_init(substream); 936 } 937 list_for_each(list, &snd_pcm_notify_list) { 938 struct snd_pcm_notify *notify; 939 notify = list_entry(list, struct snd_pcm_notify, list); 940 notify->n_register(pcm); 941 } 942 up(®ister_mutex); 943 return 0; 944 } 945 946 static int snd_pcm_dev_disconnect(struct snd_device *device) 947 { 948 struct snd_pcm *pcm = device->device_data; 949 struct list_head *list; 950 struct snd_pcm_substream *substream; 951 int cidx; 952 953 down(®ister_mutex); 954 list_del_init(&pcm->list); 955 for (cidx = 0; cidx < 2; cidx++) 956 for (substream = pcm->streams[cidx].substream; substream; substream = substream->next) 957 if (substream->runtime) 958 substream->runtime->status->state = SNDRV_PCM_STATE_DISCONNECTED; 959 list_for_each(list, &snd_pcm_notify_list) { 960 struct snd_pcm_notify *notify; 961 notify = list_entry(list, struct snd_pcm_notify, list); 962 notify->n_disconnect(pcm); 963 } 964 up(®ister_mutex); 965 return 0; 966 } 967 968 static int snd_pcm_dev_unregister(struct snd_device *device) 969 { 970 int cidx, devtype; 971 struct snd_pcm_substream *substream; 972 struct list_head *list; 973 struct snd_pcm *pcm = device->device_data; 974 975 snd_assert(pcm != NULL, return -ENXIO); 976 down(®ister_mutex); 977 list_del(&pcm->list); 978 for (cidx = 0; cidx < 2; cidx++) { 979 devtype = -1; 980 switch (cidx) { 981 case SNDRV_PCM_STREAM_PLAYBACK: 982 devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK; 983 break; 984 case SNDRV_PCM_STREAM_CAPTURE: 985 devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE; 986 break; 987 } 988 snd_unregister_device(devtype, pcm->card, pcm->device); 989 for (substream = pcm->streams[cidx].substream; substream; substream = substream->next) 990 snd_pcm_timer_done(substream); 991 } 992 list_for_each(list, &snd_pcm_notify_list) { 993 struct snd_pcm_notify *notify; 994 notify = list_entry(list, struct snd_pcm_notify, list); 995 notify->n_unregister(pcm); 996 } 997 up(®ister_mutex); 998 return snd_pcm_free(pcm); 999 } 1000 1001 int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree) 1002 { 1003 struct list_head *p; 1004 1005 snd_assert(notify != NULL && notify->n_register != NULL && notify->n_unregister != NULL, return -EINVAL); 1006 down(®ister_mutex); 1007 if (nfree) { 1008 list_del(¬ify->list); 1009 list_for_each(p, &snd_pcm_devices) 1010 notify->n_unregister(list_entry(p, 1011 struct snd_pcm, list)); 1012 } else { 1013 list_add_tail(¬ify->list, &snd_pcm_notify_list); 1014 list_for_each(p, &snd_pcm_devices) 1015 notify->n_register(list_entry(p, struct snd_pcm, list)); 1016 } 1017 up(®ister_mutex); 1018 return 0; 1019 } 1020 1021 #ifdef CONFIG_PROC_FS 1022 /* 1023 * Info interface 1024 */ 1025 1026 static void snd_pcm_proc_read(struct snd_info_entry *entry, 1027 struct snd_info_buffer *buffer) 1028 { 1029 struct list_head *p; 1030 struct snd_pcm *pcm; 1031 1032 down(®ister_mutex); 1033 list_for_each(p, &snd_pcm_devices) { 1034 pcm = list_entry(p, struct snd_pcm, list); 1035 snd_iprintf(buffer, "%02i-%02i: %s : %s", 1036 pcm->card->number, pcm->device, pcm->id, pcm->name); 1037 if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) 1038 snd_iprintf(buffer, " : playback %i", 1039 pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream_count); 1040 if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) 1041 snd_iprintf(buffer, " : capture %i", 1042 pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count); 1043 snd_iprintf(buffer, "\n"); 1044 } 1045 up(®ister_mutex); 1046 } 1047 1048 static struct snd_info_entry *snd_pcm_proc_entry = NULL; 1049 1050 static void snd_pcm_proc_init(void) 1051 { 1052 struct snd_info_entry *entry; 1053 1054 if ((entry = snd_info_create_module_entry(THIS_MODULE, "pcm", NULL)) != NULL) { 1055 snd_info_set_text_ops(entry, NULL, SNDRV_CARDS * SNDRV_PCM_DEVICES * 128, 1056 snd_pcm_proc_read); 1057 if (snd_info_register(entry) < 0) { 1058 snd_info_free_entry(entry); 1059 entry = NULL; 1060 } 1061 } 1062 snd_pcm_proc_entry = entry; 1063 } 1064 1065 static void snd_pcm_proc_done(void) 1066 { 1067 if (snd_pcm_proc_entry) 1068 snd_info_unregister(snd_pcm_proc_entry); 1069 } 1070 1071 #else /* !CONFIG_PROC_FS */ 1072 #define snd_pcm_proc_init() 1073 #define snd_pcm_proc_done() 1074 #endif /* CONFIG_PROC_FS */ 1075 1076 1077 /* 1078 * ENTRY functions 1079 */ 1080 1081 static int __init alsa_pcm_init(void) 1082 { 1083 snd_ctl_register_ioctl(snd_pcm_control_ioctl); 1084 snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl); 1085 snd_pcm_proc_init(); 1086 return 0; 1087 } 1088 1089 static void __exit alsa_pcm_exit(void) 1090 { 1091 snd_ctl_unregister_ioctl(snd_pcm_control_ioctl); 1092 snd_ctl_unregister_ioctl_compat(snd_pcm_control_ioctl); 1093 snd_pcm_proc_done(); 1094 } 1095 1096 module_init(alsa_pcm_init) 1097 module_exit(alsa_pcm_exit) 1098 1099 EXPORT_SYMBOL(snd_pcm_new); 1100 EXPORT_SYMBOL(snd_pcm_new_stream); 1101 EXPORT_SYMBOL(snd_pcm_notify); 1102 EXPORT_SYMBOL(snd_pcm_open_substream); 1103 EXPORT_SYMBOL(snd_pcm_release_substream); 1104 EXPORT_SYMBOL(snd_pcm_format_name); 1105 /* pcm_native.c */ 1106 EXPORT_SYMBOL(snd_pcm_link_rwlock); 1107 #ifdef CONFIG_PM 1108 EXPORT_SYMBOL(snd_pcm_suspend); 1109 EXPORT_SYMBOL(snd_pcm_suspend_all); 1110 #endif 1111 EXPORT_SYMBOL(snd_pcm_kernel_playback_ioctl); 1112 EXPORT_SYMBOL(snd_pcm_kernel_capture_ioctl); 1113 EXPORT_SYMBOL(snd_pcm_kernel_ioctl); 1114 EXPORT_SYMBOL(snd_pcm_mmap_data); 1115 #if SNDRV_PCM_INFO_MMAP_IOMEM 1116 EXPORT_SYMBOL(snd_pcm_lib_mmap_iomem); 1117 #endif 1118 /* pcm_misc.c */ 1119 EXPORT_SYMBOL(snd_pcm_format_signed); 1120 EXPORT_SYMBOL(snd_pcm_format_unsigned); 1121 EXPORT_SYMBOL(snd_pcm_format_linear); 1122 EXPORT_SYMBOL(snd_pcm_format_little_endian); 1123 EXPORT_SYMBOL(snd_pcm_format_big_endian); 1124 EXPORT_SYMBOL(snd_pcm_format_width); 1125 EXPORT_SYMBOL(snd_pcm_format_physical_width); 1126 EXPORT_SYMBOL(snd_pcm_format_size); 1127 EXPORT_SYMBOL(snd_pcm_format_silence_64); 1128 EXPORT_SYMBOL(snd_pcm_format_set_silence); 1129 EXPORT_SYMBOL(snd_pcm_build_linear_format); 1130 EXPORT_SYMBOL(snd_pcm_limit_hw_rates); 1131