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