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