1 /* 2 * Digital Audio (PCM) abstract layer 3 * Copyright (c) by Jaroslav Kysela <perex@perex.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 <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 <perex@perex.cz>, Abramo Bagnara <abramo@alsa-project.org>"); 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(®ister_mutex); 101 device = snd_pcm_next(card, device); 102 mutex_unlock(®ister_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(®ister_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(®ister_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 629 /** 630 * snd_pcm_new_stream - create a new PCM stream 631 * @pcm: the pcm instance 632 * @stream: the stream direction, SNDRV_PCM_STREAM_XXX 633 * @substream_count: the number of substreams 634 * 635 * Creates a new stream for the pcm. 636 * The corresponding stream on the pcm must have been empty before 637 * calling this, i.e. zero must be given to the argument of 638 * snd_pcm_new(). 639 * 640 * Returns zero if successful, or a negative error code on failure. 641 */ 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 748 /** 749 * snd_pcm_new - create a new PCM instance 750 * @card: the card instance 751 * @id: the id string 752 * @device: the device index (zero based) 753 * @playback_count: the number of substreams for playback 754 * @capture_count: the number of substreams for capture 755 * @rpcm: the pointer to store the new pcm instance 756 * 757 * Creates a new PCM instance. 758 * 759 * The pcm operators have to be set afterwards to the new instance 760 * via snd_pcm_set_ops(). 761 * 762 * Returns zero if successful, or a negative error code on failure. 763 */ 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 772 /** 773 * snd_pcm_new_internal - create a new internal PCM instance 774 * @card: the card instance 775 * @id: the id string 776 * @device: the device index (zero based - shared with normal PCMs) 777 * @playback_count: the number of substreams for playback 778 * @capture_count: the number of substreams for capture 779 * @rpcm: the pointer to store the new pcm instance 780 * 781 * Creates a new internal PCM instance with no userspace device or procfs 782 * entries. This is used by ASoC Back End PCMs in order to create a PCM that 783 * will only be used internally by kernel drivers. i.e. it cannot be opened 784 * by userspace. It provides existing ASoC components drivers with a substream 785 * and access to any private data. 786 * 787 * The pcm operators have to be set afterwards to the new instance 788 * via snd_pcm_set_ops(). 789 * 790 * Returns zero if successful, or a negative error code on failure. 791 */ 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 kfree(runtime->hwptr_log); 985 #endif 986 kfree(runtime); 987 substream->runtime = NULL; 988 put_pid(substream->pid); 989 substream->pid = NULL; 990 substream->pstr->substream_opened--; 991 } 992 993 static ssize_t show_pcm_class(struct device *dev, 994 struct device_attribute *attr, char *buf) 995 { 996 struct snd_pcm *pcm; 997 const char *str; 998 static const char *strs[SNDRV_PCM_CLASS_LAST + 1] = { 999 [SNDRV_PCM_CLASS_GENERIC] = "generic", 1000 [SNDRV_PCM_CLASS_MULTI] = "multi", 1001 [SNDRV_PCM_CLASS_MODEM] = "modem", 1002 [SNDRV_PCM_CLASS_DIGITIZER] = "digitizer", 1003 }; 1004 1005 if (! (pcm = dev_get_drvdata(dev)) || 1006 pcm->dev_class > SNDRV_PCM_CLASS_LAST) 1007 str = "none"; 1008 else 1009 str = strs[pcm->dev_class]; 1010 return snprintf(buf, PAGE_SIZE, "%s\n", str); 1011 } 1012 1013 static struct device_attribute pcm_attrs = 1014 __ATTR(pcm_class, S_IRUGO, show_pcm_class, NULL); 1015 1016 static int snd_pcm_dev_register(struct snd_device *device) 1017 { 1018 int cidx, err; 1019 struct snd_pcm_substream *substream; 1020 struct snd_pcm_notify *notify; 1021 char str[16]; 1022 struct snd_pcm *pcm; 1023 struct device *dev; 1024 1025 if (snd_BUG_ON(!device || !device->device_data)) 1026 return -ENXIO; 1027 pcm = device->device_data; 1028 mutex_lock(®ister_mutex); 1029 err = snd_pcm_add(pcm); 1030 if (err) { 1031 mutex_unlock(®ister_mutex); 1032 return err; 1033 } 1034 for (cidx = 0; cidx < 2; cidx++) { 1035 int devtype = -1; 1036 if (pcm->streams[cidx].substream == NULL || pcm->internal) 1037 continue; 1038 switch (cidx) { 1039 case SNDRV_PCM_STREAM_PLAYBACK: 1040 sprintf(str, "pcmC%iD%ip", pcm->card->number, pcm->device); 1041 devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK; 1042 break; 1043 case SNDRV_PCM_STREAM_CAPTURE: 1044 sprintf(str, "pcmC%iD%ic", pcm->card->number, pcm->device); 1045 devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE; 1046 break; 1047 } 1048 /* device pointer to use, pcm->dev takes precedence if 1049 * it is assigned, otherwise fall back to card's device 1050 * if possible */ 1051 dev = pcm->dev; 1052 if (!dev) 1053 dev = snd_card_get_device_link(pcm->card); 1054 /* register pcm */ 1055 err = snd_register_device_for_dev(devtype, pcm->card, 1056 pcm->device, 1057 &snd_pcm_f_ops[cidx], 1058 pcm, str, dev); 1059 if (err < 0) { 1060 list_del(&pcm->list); 1061 mutex_unlock(®ister_mutex); 1062 return err; 1063 } 1064 snd_add_device_sysfs_file(devtype, pcm->card, pcm->device, 1065 &pcm_attrs); 1066 for (substream = pcm->streams[cidx].substream; substream; substream = substream->next) 1067 snd_pcm_timer_init(substream); 1068 } 1069 1070 list_for_each_entry(notify, &snd_pcm_notify_list, list) 1071 notify->n_register(pcm); 1072 1073 mutex_unlock(®ister_mutex); 1074 return 0; 1075 } 1076 1077 static int snd_pcm_dev_disconnect(struct snd_device *device) 1078 { 1079 struct snd_pcm *pcm = device->device_data; 1080 struct snd_pcm_notify *notify; 1081 struct snd_pcm_substream *substream; 1082 int cidx, devtype; 1083 1084 mutex_lock(®ister_mutex); 1085 if (list_empty(&pcm->list)) 1086 goto unlock; 1087 1088 mutex_lock(&pcm->open_mutex); 1089 wake_up(&pcm->open_wait); 1090 list_del_init(&pcm->list); 1091 for (cidx = 0; cidx < 2; cidx++) 1092 for (substream = pcm->streams[cidx].substream; substream; substream = substream->next) { 1093 snd_pcm_stream_lock_irq(substream); 1094 if (substream->runtime) { 1095 substream->runtime->status->state = SNDRV_PCM_STATE_DISCONNECTED; 1096 wake_up(&substream->runtime->sleep); 1097 wake_up(&substream->runtime->tsleep); 1098 } 1099 snd_pcm_stream_unlock_irq(substream); 1100 } 1101 list_for_each_entry(notify, &snd_pcm_notify_list, list) { 1102 notify->n_disconnect(pcm); 1103 } 1104 for (cidx = 0; cidx < 2; cidx++) { 1105 devtype = -1; 1106 switch (cidx) { 1107 case SNDRV_PCM_STREAM_PLAYBACK: 1108 devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK; 1109 break; 1110 case SNDRV_PCM_STREAM_CAPTURE: 1111 devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE; 1112 break; 1113 } 1114 snd_unregister_device(devtype, pcm->card, pcm->device); 1115 if (pcm->streams[cidx].chmap_kctl) { 1116 snd_ctl_remove(pcm->card, pcm->streams[cidx].chmap_kctl); 1117 pcm->streams[cidx].chmap_kctl = NULL; 1118 } 1119 } 1120 mutex_unlock(&pcm->open_mutex); 1121 unlock: 1122 mutex_unlock(®ister_mutex); 1123 return 0; 1124 } 1125 1126 int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree) 1127 { 1128 struct snd_pcm *pcm; 1129 1130 if (snd_BUG_ON(!notify || 1131 !notify->n_register || 1132 !notify->n_unregister || 1133 !notify->n_disconnect)) 1134 return -EINVAL; 1135 mutex_lock(®ister_mutex); 1136 if (nfree) { 1137 list_del(¬ify->list); 1138 list_for_each_entry(pcm, &snd_pcm_devices, list) 1139 notify->n_unregister(pcm); 1140 } else { 1141 list_add_tail(¬ify->list, &snd_pcm_notify_list); 1142 list_for_each_entry(pcm, &snd_pcm_devices, list) 1143 notify->n_register(pcm); 1144 } 1145 mutex_unlock(®ister_mutex); 1146 return 0; 1147 } 1148 1149 EXPORT_SYMBOL(snd_pcm_notify); 1150 1151 #ifdef CONFIG_PROC_FS 1152 /* 1153 * Info interface 1154 */ 1155 1156 static void snd_pcm_proc_read(struct snd_info_entry *entry, 1157 struct snd_info_buffer *buffer) 1158 { 1159 struct snd_pcm *pcm; 1160 1161 mutex_lock(®ister_mutex); 1162 list_for_each_entry(pcm, &snd_pcm_devices, list) { 1163 snd_iprintf(buffer, "%02i-%02i: %s : %s", 1164 pcm->card->number, pcm->device, pcm->id, pcm->name); 1165 if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) 1166 snd_iprintf(buffer, " : playback %i", 1167 pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream_count); 1168 if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) 1169 snd_iprintf(buffer, " : capture %i", 1170 pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count); 1171 snd_iprintf(buffer, "\n"); 1172 } 1173 mutex_unlock(®ister_mutex); 1174 } 1175 1176 static struct snd_info_entry *snd_pcm_proc_entry; 1177 1178 static void snd_pcm_proc_init(void) 1179 { 1180 struct snd_info_entry *entry; 1181 1182 if ((entry = snd_info_create_module_entry(THIS_MODULE, "pcm", NULL)) != NULL) { 1183 snd_info_set_text_ops(entry, NULL, snd_pcm_proc_read); 1184 if (snd_info_register(entry) < 0) { 1185 snd_info_free_entry(entry); 1186 entry = NULL; 1187 } 1188 } 1189 snd_pcm_proc_entry = entry; 1190 } 1191 1192 static void snd_pcm_proc_done(void) 1193 { 1194 snd_info_free_entry(snd_pcm_proc_entry); 1195 } 1196 1197 #else /* !CONFIG_PROC_FS */ 1198 #define snd_pcm_proc_init() 1199 #define snd_pcm_proc_done() 1200 #endif /* CONFIG_PROC_FS */ 1201 1202 1203 /* 1204 * ENTRY functions 1205 */ 1206 1207 static int __init alsa_pcm_init(void) 1208 { 1209 snd_ctl_register_ioctl(snd_pcm_control_ioctl); 1210 snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl); 1211 snd_pcm_proc_init(); 1212 return 0; 1213 } 1214 1215 static void __exit alsa_pcm_exit(void) 1216 { 1217 snd_ctl_unregister_ioctl(snd_pcm_control_ioctl); 1218 snd_ctl_unregister_ioctl_compat(snd_pcm_control_ioctl); 1219 snd_pcm_proc_done(); 1220 } 1221 1222 module_init(alsa_pcm_init) 1223 module_exit(alsa_pcm_exit) 1224