1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Abstract layer for MIDI v1.0 stream 4 * Copyright (c) by Jaroslav Kysela <perex@perex.cz> 5 */ 6 7 #include <sound/core.h> 8 #include <linux/major.h> 9 #include <linux/init.h> 10 #include <linux/sched/signal.h> 11 #include <linux/slab.h> 12 #include <linux/time.h> 13 #include <linux/wait.h> 14 #include <linux/mutex.h> 15 #include <linux/module.h> 16 #include <linux/delay.h> 17 #include <linux/mm.h> 18 #include <linux/nospec.h> 19 #include <sound/rawmidi.h> 20 #include <sound/info.h> 21 #include <sound/control.h> 22 #include <sound/minors.h> 23 #include <sound/initval.h> 24 25 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>"); 26 MODULE_DESCRIPTION("Midlevel RawMidi code for ALSA."); 27 MODULE_LICENSE("GPL"); 28 29 #ifdef CONFIG_SND_OSSEMUL 30 static int midi_map[SNDRV_CARDS]; 31 static int amidi_map[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = 1}; 32 module_param_array(midi_map, int, NULL, 0444); 33 MODULE_PARM_DESC(midi_map, "Raw MIDI device number assigned to 1st OSS device."); 34 module_param_array(amidi_map, int, NULL, 0444); 35 MODULE_PARM_DESC(amidi_map, "Raw MIDI device number assigned to 2nd OSS device."); 36 #endif /* CONFIG_SND_OSSEMUL */ 37 38 static int snd_rawmidi_free(struct snd_rawmidi *rmidi); 39 static int snd_rawmidi_dev_free(struct snd_device *device); 40 static int snd_rawmidi_dev_register(struct snd_device *device); 41 static int snd_rawmidi_dev_disconnect(struct snd_device *device); 42 43 static LIST_HEAD(snd_rawmidi_devices); 44 static DEFINE_MUTEX(register_mutex); 45 46 #define rmidi_err(rmidi, fmt, args...) \ 47 dev_err(&(rmidi)->dev, fmt, ##args) 48 #define rmidi_warn(rmidi, fmt, args...) \ 49 dev_warn(&(rmidi)->dev, fmt, ##args) 50 #define rmidi_dbg(rmidi, fmt, args...) \ 51 dev_dbg(&(rmidi)->dev, fmt, ##args) 52 53 struct snd_rawmidi_status32 { 54 s32 stream; 55 s32 tstamp_sec; /* Timestamp */ 56 s32 tstamp_nsec; 57 u32 avail; /* available bytes */ 58 u32 xruns; /* count of overruns since last status (in bytes) */ 59 unsigned char reserved[16]; /* reserved for future use */ 60 }; 61 62 #define SNDRV_RAWMIDI_IOCTL_STATUS32 _IOWR('W', 0x20, struct snd_rawmidi_status32) 63 64 struct snd_rawmidi_status64 { 65 int stream; 66 u8 rsvd[4]; /* alignment */ 67 s64 tstamp_sec; /* Timestamp */ 68 s64 tstamp_nsec; 69 size_t avail; /* available bytes */ 70 size_t xruns; /* count of overruns since last status (in bytes) */ 71 unsigned char reserved[16]; /* reserved for future use */ 72 }; 73 74 #define SNDRV_RAWMIDI_IOCTL_STATUS64 _IOWR('W', 0x20, struct snd_rawmidi_status64) 75 76 static struct snd_rawmidi *snd_rawmidi_search(struct snd_card *card, int device) 77 { 78 struct snd_rawmidi *rawmidi; 79 80 list_for_each_entry(rawmidi, &snd_rawmidi_devices, list) 81 if (rawmidi->card == card && rawmidi->device == device) 82 return rawmidi; 83 return NULL; 84 } 85 86 static inline unsigned short snd_rawmidi_file_flags(struct file *file) 87 { 88 switch (file->f_mode & (FMODE_READ | FMODE_WRITE)) { 89 case FMODE_WRITE: 90 return SNDRV_RAWMIDI_LFLG_OUTPUT; 91 case FMODE_READ: 92 return SNDRV_RAWMIDI_LFLG_INPUT; 93 default: 94 return SNDRV_RAWMIDI_LFLG_OPEN; 95 } 96 } 97 98 static inline bool __snd_rawmidi_ready(struct snd_rawmidi_runtime *runtime) 99 { 100 return runtime->avail >= runtime->avail_min; 101 } 102 103 static bool snd_rawmidi_ready(struct snd_rawmidi_substream *substream) 104 { 105 struct snd_rawmidi_runtime *runtime = substream->runtime; 106 unsigned long flags; 107 bool ready; 108 109 spin_lock_irqsave(&runtime->lock, flags); 110 ready = __snd_rawmidi_ready(runtime); 111 spin_unlock_irqrestore(&runtime->lock, flags); 112 return ready; 113 } 114 115 static inline int snd_rawmidi_ready_append(struct snd_rawmidi_substream *substream, 116 size_t count) 117 { 118 struct snd_rawmidi_runtime *runtime = substream->runtime; 119 120 return runtime->avail >= runtime->avail_min && 121 (!substream->append || runtime->avail >= count); 122 } 123 124 static void snd_rawmidi_input_event_work(struct work_struct *work) 125 { 126 struct snd_rawmidi_runtime *runtime = 127 container_of(work, struct snd_rawmidi_runtime, event_work); 128 129 if (runtime->event) 130 runtime->event(runtime->substream); 131 } 132 133 /* buffer refcount management: call with runtime->lock held */ 134 static inline void snd_rawmidi_buffer_ref(struct snd_rawmidi_runtime *runtime) 135 { 136 runtime->buffer_ref++; 137 } 138 139 static inline void snd_rawmidi_buffer_unref(struct snd_rawmidi_runtime *runtime) 140 { 141 runtime->buffer_ref--; 142 } 143 144 static int snd_rawmidi_runtime_create(struct snd_rawmidi_substream *substream) 145 { 146 struct snd_rawmidi_runtime *runtime; 147 148 runtime = kzalloc(sizeof(*runtime), GFP_KERNEL); 149 if (!runtime) 150 return -ENOMEM; 151 runtime->substream = substream; 152 spin_lock_init(&runtime->lock); 153 init_waitqueue_head(&runtime->sleep); 154 INIT_WORK(&runtime->event_work, snd_rawmidi_input_event_work); 155 runtime->event = NULL; 156 runtime->buffer_size = PAGE_SIZE; 157 runtime->avail_min = 1; 158 if (substream->stream == SNDRV_RAWMIDI_STREAM_INPUT) 159 runtime->avail = 0; 160 else 161 runtime->avail = runtime->buffer_size; 162 runtime->buffer = kvzalloc(runtime->buffer_size, GFP_KERNEL); 163 if (!runtime->buffer) { 164 kfree(runtime); 165 return -ENOMEM; 166 } 167 runtime->appl_ptr = runtime->hw_ptr = 0; 168 substream->runtime = runtime; 169 return 0; 170 } 171 172 static int snd_rawmidi_runtime_free(struct snd_rawmidi_substream *substream) 173 { 174 struct snd_rawmidi_runtime *runtime = substream->runtime; 175 176 kvfree(runtime->buffer); 177 kfree(runtime); 178 substream->runtime = NULL; 179 return 0; 180 } 181 182 static inline void snd_rawmidi_output_trigger(struct snd_rawmidi_substream *substream, int up) 183 { 184 if (!substream->opened) 185 return; 186 substream->ops->trigger(substream, up); 187 } 188 189 static void snd_rawmidi_input_trigger(struct snd_rawmidi_substream *substream, int up) 190 { 191 if (!substream->opened) 192 return; 193 substream->ops->trigger(substream, up); 194 if (!up) 195 cancel_work_sync(&substream->runtime->event_work); 196 } 197 198 static void __reset_runtime_ptrs(struct snd_rawmidi_runtime *runtime, 199 bool is_input) 200 { 201 runtime->drain = 0; 202 runtime->appl_ptr = runtime->hw_ptr = 0; 203 runtime->avail = is_input ? 0 : runtime->buffer_size; 204 } 205 206 static void reset_runtime_ptrs(struct snd_rawmidi_runtime *runtime, 207 bool is_input) 208 { 209 unsigned long flags; 210 211 spin_lock_irqsave(&runtime->lock, flags); 212 __reset_runtime_ptrs(runtime, is_input); 213 spin_unlock_irqrestore(&runtime->lock, flags); 214 } 215 216 int snd_rawmidi_drop_output(struct snd_rawmidi_substream *substream) 217 { 218 snd_rawmidi_output_trigger(substream, 0); 219 reset_runtime_ptrs(substream->runtime, false); 220 return 0; 221 } 222 EXPORT_SYMBOL(snd_rawmidi_drop_output); 223 224 int snd_rawmidi_drain_output(struct snd_rawmidi_substream *substream) 225 { 226 int err; 227 long timeout; 228 struct snd_rawmidi_runtime *runtime = substream->runtime; 229 230 err = 0; 231 runtime->drain = 1; 232 timeout = wait_event_interruptible_timeout(runtime->sleep, 233 (runtime->avail >= runtime->buffer_size), 234 10*HZ); 235 if (signal_pending(current)) 236 err = -ERESTARTSYS; 237 if (runtime->avail < runtime->buffer_size && !timeout) { 238 rmidi_warn(substream->rmidi, 239 "rawmidi drain error (avail = %li, buffer_size = %li)\n", 240 (long)runtime->avail, (long)runtime->buffer_size); 241 err = -EIO; 242 } 243 runtime->drain = 0; 244 if (err != -ERESTARTSYS) { 245 /* we need wait a while to make sure that Tx FIFOs are empty */ 246 if (substream->ops->drain) 247 substream->ops->drain(substream); 248 else 249 msleep(50); 250 snd_rawmidi_drop_output(substream); 251 } 252 return err; 253 } 254 EXPORT_SYMBOL(snd_rawmidi_drain_output); 255 256 int snd_rawmidi_drain_input(struct snd_rawmidi_substream *substream) 257 { 258 snd_rawmidi_input_trigger(substream, 0); 259 reset_runtime_ptrs(substream->runtime, true); 260 return 0; 261 } 262 EXPORT_SYMBOL(snd_rawmidi_drain_input); 263 264 /* look for an available substream for the given stream direction; 265 * if a specific subdevice is given, try to assign it 266 */ 267 static int assign_substream(struct snd_rawmidi *rmidi, int subdevice, 268 int stream, int mode, 269 struct snd_rawmidi_substream **sub_ret) 270 { 271 struct snd_rawmidi_substream *substream; 272 struct snd_rawmidi_str *s = &rmidi->streams[stream]; 273 static const unsigned int info_flags[2] = { 274 [SNDRV_RAWMIDI_STREAM_OUTPUT] = SNDRV_RAWMIDI_INFO_OUTPUT, 275 [SNDRV_RAWMIDI_STREAM_INPUT] = SNDRV_RAWMIDI_INFO_INPUT, 276 }; 277 278 if (!(rmidi->info_flags & info_flags[stream])) 279 return -ENXIO; 280 if (subdevice >= 0 && subdevice >= s->substream_count) 281 return -ENODEV; 282 283 list_for_each_entry(substream, &s->substreams, list) { 284 if (substream->opened) { 285 if (stream == SNDRV_RAWMIDI_STREAM_INPUT || 286 !(mode & SNDRV_RAWMIDI_LFLG_APPEND) || 287 !substream->append) 288 continue; 289 } 290 if (subdevice < 0 || subdevice == substream->number) { 291 *sub_ret = substream; 292 return 0; 293 } 294 } 295 return -EAGAIN; 296 } 297 298 /* open and do ref-counting for the given substream */ 299 static int open_substream(struct snd_rawmidi *rmidi, 300 struct snd_rawmidi_substream *substream, 301 int mode) 302 { 303 int err; 304 305 if (substream->use_count == 0) { 306 err = snd_rawmidi_runtime_create(substream); 307 if (err < 0) 308 return err; 309 err = substream->ops->open(substream); 310 if (err < 0) { 311 snd_rawmidi_runtime_free(substream); 312 return err; 313 } 314 substream->opened = 1; 315 substream->active_sensing = 0; 316 if (mode & SNDRV_RAWMIDI_LFLG_APPEND) 317 substream->append = 1; 318 substream->pid = get_pid(task_pid(current)); 319 rmidi->streams[substream->stream].substream_opened++; 320 } 321 substream->use_count++; 322 return 0; 323 } 324 325 static void close_substream(struct snd_rawmidi *rmidi, 326 struct snd_rawmidi_substream *substream, 327 int cleanup); 328 329 static int rawmidi_open_priv(struct snd_rawmidi *rmidi, int subdevice, int mode, 330 struct snd_rawmidi_file *rfile) 331 { 332 struct snd_rawmidi_substream *sinput = NULL, *soutput = NULL; 333 int err; 334 335 rfile->input = rfile->output = NULL; 336 if (mode & SNDRV_RAWMIDI_LFLG_INPUT) { 337 err = assign_substream(rmidi, subdevice, 338 SNDRV_RAWMIDI_STREAM_INPUT, 339 mode, &sinput); 340 if (err < 0) 341 return err; 342 } 343 if (mode & SNDRV_RAWMIDI_LFLG_OUTPUT) { 344 err = assign_substream(rmidi, subdevice, 345 SNDRV_RAWMIDI_STREAM_OUTPUT, 346 mode, &soutput); 347 if (err < 0) 348 return err; 349 } 350 351 if (sinput) { 352 err = open_substream(rmidi, sinput, mode); 353 if (err < 0) 354 return err; 355 } 356 if (soutput) { 357 err = open_substream(rmidi, soutput, mode); 358 if (err < 0) { 359 if (sinput) 360 close_substream(rmidi, sinput, 0); 361 return err; 362 } 363 } 364 365 rfile->rmidi = rmidi; 366 rfile->input = sinput; 367 rfile->output = soutput; 368 return 0; 369 } 370 371 /* called from sound/core/seq/seq_midi.c */ 372 int snd_rawmidi_kernel_open(struct snd_card *card, int device, int subdevice, 373 int mode, struct snd_rawmidi_file *rfile) 374 { 375 struct snd_rawmidi *rmidi; 376 int err = 0; 377 378 if (snd_BUG_ON(!rfile)) 379 return -EINVAL; 380 381 mutex_lock(®ister_mutex); 382 rmidi = snd_rawmidi_search(card, device); 383 if (!rmidi) 384 err = -ENODEV; 385 else if (!try_module_get(rmidi->card->module)) 386 err = -ENXIO; 387 mutex_unlock(®ister_mutex); 388 if (err < 0) 389 return err; 390 391 mutex_lock(&rmidi->open_mutex); 392 err = rawmidi_open_priv(rmidi, subdevice, mode, rfile); 393 mutex_unlock(&rmidi->open_mutex); 394 if (err < 0) 395 module_put(rmidi->card->module); 396 return err; 397 } 398 EXPORT_SYMBOL(snd_rawmidi_kernel_open); 399 400 static int snd_rawmidi_open(struct inode *inode, struct file *file) 401 { 402 int maj = imajor(inode); 403 struct snd_card *card; 404 int subdevice; 405 unsigned short fflags; 406 int err; 407 struct snd_rawmidi *rmidi; 408 struct snd_rawmidi_file *rawmidi_file = NULL; 409 wait_queue_entry_t wait; 410 411 if ((file->f_flags & O_APPEND) && !(file->f_flags & O_NONBLOCK)) 412 return -EINVAL; /* invalid combination */ 413 414 err = stream_open(inode, file); 415 if (err < 0) 416 return err; 417 418 if (maj == snd_major) { 419 rmidi = snd_lookup_minor_data(iminor(inode), 420 SNDRV_DEVICE_TYPE_RAWMIDI); 421 #ifdef CONFIG_SND_OSSEMUL 422 } else if (maj == SOUND_MAJOR) { 423 rmidi = snd_lookup_oss_minor_data(iminor(inode), 424 SNDRV_OSS_DEVICE_TYPE_MIDI); 425 #endif 426 } else 427 return -ENXIO; 428 429 if (rmidi == NULL) 430 return -ENODEV; 431 432 if (!try_module_get(rmidi->card->module)) { 433 snd_card_unref(rmidi->card); 434 return -ENXIO; 435 } 436 437 mutex_lock(&rmidi->open_mutex); 438 card = rmidi->card; 439 err = snd_card_file_add(card, file); 440 if (err < 0) 441 goto __error_card; 442 fflags = snd_rawmidi_file_flags(file); 443 if ((file->f_flags & O_APPEND) || maj == SOUND_MAJOR) /* OSS emul? */ 444 fflags |= SNDRV_RAWMIDI_LFLG_APPEND; 445 rawmidi_file = kmalloc(sizeof(*rawmidi_file), GFP_KERNEL); 446 if (rawmidi_file == NULL) { 447 err = -ENOMEM; 448 goto __error; 449 } 450 rawmidi_file->user_pversion = 0; 451 init_waitqueue_entry(&wait, current); 452 add_wait_queue(&rmidi->open_wait, &wait); 453 while (1) { 454 subdevice = snd_ctl_get_preferred_subdevice(card, SND_CTL_SUBDEV_RAWMIDI); 455 err = rawmidi_open_priv(rmidi, subdevice, fflags, rawmidi_file); 456 if (err >= 0) 457 break; 458 if (err == -EAGAIN) { 459 if (file->f_flags & O_NONBLOCK) { 460 err = -EBUSY; 461 break; 462 } 463 } else 464 break; 465 set_current_state(TASK_INTERRUPTIBLE); 466 mutex_unlock(&rmidi->open_mutex); 467 schedule(); 468 mutex_lock(&rmidi->open_mutex); 469 if (rmidi->card->shutdown) { 470 err = -ENODEV; 471 break; 472 } 473 if (signal_pending(current)) { 474 err = -ERESTARTSYS; 475 break; 476 } 477 } 478 remove_wait_queue(&rmidi->open_wait, &wait); 479 if (err < 0) { 480 kfree(rawmidi_file); 481 goto __error; 482 } 483 #ifdef CONFIG_SND_OSSEMUL 484 if (rawmidi_file->input && rawmidi_file->input->runtime) 485 rawmidi_file->input->runtime->oss = (maj == SOUND_MAJOR); 486 if (rawmidi_file->output && rawmidi_file->output->runtime) 487 rawmidi_file->output->runtime->oss = (maj == SOUND_MAJOR); 488 #endif 489 file->private_data = rawmidi_file; 490 mutex_unlock(&rmidi->open_mutex); 491 snd_card_unref(rmidi->card); 492 return 0; 493 494 __error: 495 snd_card_file_remove(card, file); 496 __error_card: 497 mutex_unlock(&rmidi->open_mutex); 498 module_put(rmidi->card->module); 499 snd_card_unref(rmidi->card); 500 return err; 501 } 502 503 static void close_substream(struct snd_rawmidi *rmidi, 504 struct snd_rawmidi_substream *substream, 505 int cleanup) 506 { 507 if (--substream->use_count) 508 return; 509 510 if (cleanup) { 511 if (substream->stream == SNDRV_RAWMIDI_STREAM_INPUT) 512 snd_rawmidi_input_trigger(substream, 0); 513 else { 514 if (substream->active_sensing) { 515 unsigned char buf = 0xfe; 516 /* sending single active sensing message 517 * to shut the device up 518 */ 519 snd_rawmidi_kernel_write(substream, &buf, 1); 520 } 521 if (snd_rawmidi_drain_output(substream) == -ERESTARTSYS) 522 snd_rawmidi_output_trigger(substream, 0); 523 } 524 } 525 substream->ops->close(substream); 526 if (substream->runtime->private_free) 527 substream->runtime->private_free(substream); 528 snd_rawmidi_runtime_free(substream); 529 substream->opened = 0; 530 substream->append = 0; 531 put_pid(substream->pid); 532 substream->pid = NULL; 533 rmidi->streams[substream->stream].substream_opened--; 534 } 535 536 static void rawmidi_release_priv(struct snd_rawmidi_file *rfile) 537 { 538 struct snd_rawmidi *rmidi; 539 540 rmidi = rfile->rmidi; 541 mutex_lock(&rmidi->open_mutex); 542 if (rfile->input) { 543 close_substream(rmidi, rfile->input, 1); 544 rfile->input = NULL; 545 } 546 if (rfile->output) { 547 close_substream(rmidi, rfile->output, 1); 548 rfile->output = NULL; 549 } 550 rfile->rmidi = NULL; 551 mutex_unlock(&rmidi->open_mutex); 552 wake_up(&rmidi->open_wait); 553 } 554 555 /* called from sound/core/seq/seq_midi.c */ 556 int snd_rawmidi_kernel_release(struct snd_rawmidi_file *rfile) 557 { 558 struct snd_rawmidi *rmidi; 559 560 if (snd_BUG_ON(!rfile)) 561 return -ENXIO; 562 563 rmidi = rfile->rmidi; 564 rawmidi_release_priv(rfile); 565 module_put(rmidi->card->module); 566 return 0; 567 } 568 EXPORT_SYMBOL(snd_rawmidi_kernel_release); 569 570 static int snd_rawmidi_release(struct inode *inode, struct file *file) 571 { 572 struct snd_rawmidi_file *rfile; 573 struct snd_rawmidi *rmidi; 574 struct module *module; 575 576 rfile = file->private_data; 577 rmidi = rfile->rmidi; 578 rawmidi_release_priv(rfile); 579 kfree(rfile); 580 module = rmidi->card->module; 581 snd_card_file_remove(rmidi->card, file); 582 module_put(module); 583 return 0; 584 } 585 586 static int snd_rawmidi_info(struct snd_rawmidi_substream *substream, 587 struct snd_rawmidi_info *info) 588 { 589 struct snd_rawmidi *rmidi; 590 591 if (substream == NULL) 592 return -ENODEV; 593 rmidi = substream->rmidi; 594 memset(info, 0, sizeof(*info)); 595 info->card = rmidi->card->number; 596 info->device = rmidi->device; 597 info->subdevice = substream->number; 598 info->stream = substream->stream; 599 info->flags = rmidi->info_flags; 600 strcpy(info->id, rmidi->id); 601 strcpy(info->name, rmidi->name); 602 strcpy(info->subname, substream->name); 603 info->subdevices_count = substream->pstr->substream_count; 604 info->subdevices_avail = (substream->pstr->substream_count - 605 substream->pstr->substream_opened); 606 return 0; 607 } 608 609 static int snd_rawmidi_info_user(struct snd_rawmidi_substream *substream, 610 struct snd_rawmidi_info __user *_info) 611 { 612 struct snd_rawmidi_info info; 613 int err; 614 615 err = snd_rawmidi_info(substream, &info); 616 if (err < 0) 617 return err; 618 if (copy_to_user(_info, &info, sizeof(struct snd_rawmidi_info))) 619 return -EFAULT; 620 return 0; 621 } 622 623 static int __snd_rawmidi_info_select(struct snd_card *card, 624 struct snd_rawmidi_info *info) 625 { 626 struct snd_rawmidi *rmidi; 627 struct snd_rawmidi_str *pstr; 628 struct snd_rawmidi_substream *substream; 629 630 rmidi = snd_rawmidi_search(card, info->device); 631 if (!rmidi) 632 return -ENXIO; 633 if (info->stream < 0 || info->stream > 1) 634 return -EINVAL; 635 info->stream = array_index_nospec(info->stream, 2); 636 pstr = &rmidi->streams[info->stream]; 637 if (pstr->substream_count == 0) 638 return -ENOENT; 639 if (info->subdevice >= pstr->substream_count) 640 return -ENXIO; 641 list_for_each_entry(substream, &pstr->substreams, list) { 642 if ((unsigned int)substream->number == info->subdevice) 643 return snd_rawmidi_info(substream, info); 644 } 645 return -ENXIO; 646 } 647 648 int snd_rawmidi_info_select(struct snd_card *card, struct snd_rawmidi_info *info) 649 { 650 int ret; 651 652 mutex_lock(®ister_mutex); 653 ret = __snd_rawmidi_info_select(card, info); 654 mutex_unlock(®ister_mutex); 655 return ret; 656 } 657 EXPORT_SYMBOL(snd_rawmidi_info_select); 658 659 static int snd_rawmidi_info_select_user(struct snd_card *card, 660 struct snd_rawmidi_info __user *_info) 661 { 662 int err; 663 struct snd_rawmidi_info info; 664 665 if (get_user(info.device, &_info->device)) 666 return -EFAULT; 667 if (get_user(info.stream, &_info->stream)) 668 return -EFAULT; 669 if (get_user(info.subdevice, &_info->subdevice)) 670 return -EFAULT; 671 err = snd_rawmidi_info_select(card, &info); 672 if (err < 0) 673 return err; 674 if (copy_to_user(_info, &info, sizeof(struct snd_rawmidi_info))) 675 return -EFAULT; 676 return 0; 677 } 678 679 static int resize_runtime_buffer(struct snd_rawmidi_runtime *runtime, 680 struct snd_rawmidi_params *params, 681 bool is_input) 682 { 683 char *newbuf, *oldbuf; 684 unsigned int framing = params->mode & SNDRV_RAWMIDI_MODE_FRAMING_MASK; 685 686 if (params->buffer_size < 32 || params->buffer_size > 1024L * 1024L) 687 return -EINVAL; 688 if (framing == SNDRV_RAWMIDI_MODE_FRAMING_TSTAMP && (params->buffer_size & 0x1f) != 0) 689 return -EINVAL; 690 if (params->avail_min < 1 || params->avail_min > params->buffer_size) 691 return -EINVAL; 692 if (params->buffer_size != runtime->buffer_size) { 693 newbuf = kvzalloc(params->buffer_size, GFP_KERNEL); 694 if (!newbuf) 695 return -ENOMEM; 696 spin_lock_irq(&runtime->lock); 697 if (runtime->buffer_ref) { 698 spin_unlock_irq(&runtime->lock); 699 kvfree(newbuf); 700 return -EBUSY; 701 } 702 oldbuf = runtime->buffer; 703 runtime->buffer = newbuf; 704 runtime->buffer_size = params->buffer_size; 705 __reset_runtime_ptrs(runtime, is_input); 706 spin_unlock_irq(&runtime->lock); 707 kvfree(oldbuf); 708 } 709 runtime->avail_min = params->avail_min; 710 return 0; 711 } 712 713 int snd_rawmidi_output_params(struct snd_rawmidi_substream *substream, 714 struct snd_rawmidi_params *params) 715 { 716 if (substream->append && substream->use_count > 1) 717 return -EBUSY; 718 snd_rawmidi_drain_output(substream); 719 substream->active_sensing = !params->no_active_sensing; 720 return resize_runtime_buffer(substream->runtime, params, false); 721 } 722 EXPORT_SYMBOL(snd_rawmidi_output_params); 723 724 int snd_rawmidi_input_params(struct snd_rawmidi_substream *substream, 725 struct snd_rawmidi_params *params) 726 { 727 unsigned int framing = params->mode & SNDRV_RAWMIDI_MODE_FRAMING_MASK; 728 unsigned int clock_type = params->mode & SNDRV_RAWMIDI_MODE_CLOCK_MASK; 729 int err; 730 731 if (framing == SNDRV_RAWMIDI_MODE_FRAMING_NONE && clock_type != SNDRV_RAWMIDI_MODE_CLOCK_NONE) 732 return -EINVAL; 733 else if (clock_type > SNDRV_RAWMIDI_MODE_CLOCK_MONOTONIC_RAW) 734 return -EINVAL; 735 if (framing > SNDRV_RAWMIDI_MODE_FRAMING_TSTAMP) 736 return -EINVAL; 737 snd_rawmidi_drain_input(substream); 738 err = resize_runtime_buffer(substream->runtime, params, true); 739 if (err < 0) 740 return err; 741 742 substream->framing = framing; 743 substream->clock_type = clock_type; 744 return 0; 745 } 746 EXPORT_SYMBOL(snd_rawmidi_input_params); 747 748 static int snd_rawmidi_output_status(struct snd_rawmidi_substream *substream, 749 struct snd_rawmidi_status64 *status) 750 { 751 struct snd_rawmidi_runtime *runtime = substream->runtime; 752 753 memset(status, 0, sizeof(*status)); 754 status->stream = SNDRV_RAWMIDI_STREAM_OUTPUT; 755 spin_lock_irq(&runtime->lock); 756 status->avail = runtime->avail; 757 spin_unlock_irq(&runtime->lock); 758 return 0; 759 } 760 761 static int snd_rawmidi_input_status(struct snd_rawmidi_substream *substream, 762 struct snd_rawmidi_status64 *status) 763 { 764 struct snd_rawmidi_runtime *runtime = substream->runtime; 765 766 memset(status, 0, sizeof(*status)); 767 status->stream = SNDRV_RAWMIDI_STREAM_INPUT; 768 spin_lock_irq(&runtime->lock); 769 status->avail = runtime->avail; 770 status->xruns = runtime->xruns; 771 runtime->xruns = 0; 772 spin_unlock_irq(&runtime->lock); 773 return 0; 774 } 775 776 static int snd_rawmidi_ioctl_status32(struct snd_rawmidi_file *rfile, 777 struct snd_rawmidi_status32 __user *argp) 778 { 779 int err = 0; 780 struct snd_rawmidi_status32 __user *status = argp; 781 struct snd_rawmidi_status32 status32; 782 struct snd_rawmidi_status64 status64; 783 784 if (copy_from_user(&status32, argp, 785 sizeof(struct snd_rawmidi_status32))) 786 return -EFAULT; 787 788 switch (status32.stream) { 789 case SNDRV_RAWMIDI_STREAM_OUTPUT: 790 if (rfile->output == NULL) 791 return -EINVAL; 792 err = snd_rawmidi_output_status(rfile->output, &status64); 793 break; 794 case SNDRV_RAWMIDI_STREAM_INPUT: 795 if (rfile->input == NULL) 796 return -EINVAL; 797 err = snd_rawmidi_input_status(rfile->input, &status64); 798 break; 799 default: 800 return -EINVAL; 801 } 802 if (err < 0) 803 return err; 804 805 status32 = (struct snd_rawmidi_status32) { 806 .stream = status64.stream, 807 .tstamp_sec = status64.tstamp_sec, 808 .tstamp_nsec = status64.tstamp_nsec, 809 .avail = status64.avail, 810 .xruns = status64.xruns, 811 }; 812 813 if (copy_to_user(status, &status32, sizeof(*status))) 814 return -EFAULT; 815 816 return 0; 817 } 818 819 static int snd_rawmidi_ioctl_status64(struct snd_rawmidi_file *rfile, 820 struct snd_rawmidi_status64 __user *argp) 821 { 822 int err = 0; 823 struct snd_rawmidi_status64 status; 824 825 if (copy_from_user(&status, argp, sizeof(struct snd_rawmidi_status64))) 826 return -EFAULT; 827 828 switch (status.stream) { 829 case SNDRV_RAWMIDI_STREAM_OUTPUT: 830 if (rfile->output == NULL) 831 return -EINVAL; 832 err = snd_rawmidi_output_status(rfile->output, &status); 833 break; 834 case SNDRV_RAWMIDI_STREAM_INPUT: 835 if (rfile->input == NULL) 836 return -EINVAL; 837 err = snd_rawmidi_input_status(rfile->input, &status); 838 break; 839 default: 840 return -EINVAL; 841 } 842 if (err < 0) 843 return err; 844 if (copy_to_user(argp, &status, 845 sizeof(struct snd_rawmidi_status64))) 846 return -EFAULT; 847 return 0; 848 } 849 850 static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 851 { 852 struct snd_rawmidi_file *rfile; 853 void __user *argp = (void __user *)arg; 854 855 rfile = file->private_data; 856 if (((cmd >> 8) & 0xff) != 'W') 857 return -ENOTTY; 858 switch (cmd) { 859 case SNDRV_RAWMIDI_IOCTL_PVERSION: 860 return put_user(SNDRV_RAWMIDI_VERSION, (int __user *)argp) ? -EFAULT : 0; 861 case SNDRV_RAWMIDI_IOCTL_INFO: 862 { 863 int stream; 864 struct snd_rawmidi_info __user *info = argp; 865 866 if (get_user(stream, &info->stream)) 867 return -EFAULT; 868 switch (stream) { 869 case SNDRV_RAWMIDI_STREAM_INPUT: 870 return snd_rawmidi_info_user(rfile->input, info); 871 case SNDRV_RAWMIDI_STREAM_OUTPUT: 872 return snd_rawmidi_info_user(rfile->output, info); 873 default: 874 return -EINVAL; 875 } 876 } 877 case SNDRV_RAWMIDI_IOCTL_USER_PVERSION: 878 if (get_user(rfile->user_pversion, (unsigned int __user *)arg)) 879 return -EFAULT; 880 return 0; 881 882 case SNDRV_RAWMIDI_IOCTL_PARAMS: 883 { 884 struct snd_rawmidi_params params; 885 886 if (copy_from_user(¶ms, argp, sizeof(struct snd_rawmidi_params))) 887 return -EFAULT; 888 if (rfile->user_pversion < SNDRV_PROTOCOL_VERSION(2, 0, 2)) { 889 params.mode = 0; 890 memset(params.reserved, 0, sizeof(params.reserved)); 891 } 892 switch (params.stream) { 893 case SNDRV_RAWMIDI_STREAM_OUTPUT: 894 if (rfile->output == NULL) 895 return -EINVAL; 896 return snd_rawmidi_output_params(rfile->output, ¶ms); 897 case SNDRV_RAWMIDI_STREAM_INPUT: 898 if (rfile->input == NULL) 899 return -EINVAL; 900 return snd_rawmidi_input_params(rfile->input, ¶ms); 901 default: 902 return -EINVAL; 903 } 904 } 905 case SNDRV_RAWMIDI_IOCTL_STATUS32: 906 return snd_rawmidi_ioctl_status32(rfile, argp); 907 case SNDRV_RAWMIDI_IOCTL_STATUS64: 908 return snd_rawmidi_ioctl_status64(rfile, argp); 909 case SNDRV_RAWMIDI_IOCTL_DROP: 910 { 911 int val; 912 913 if (get_user(val, (int __user *) argp)) 914 return -EFAULT; 915 switch (val) { 916 case SNDRV_RAWMIDI_STREAM_OUTPUT: 917 if (rfile->output == NULL) 918 return -EINVAL; 919 return snd_rawmidi_drop_output(rfile->output); 920 default: 921 return -EINVAL; 922 } 923 } 924 case SNDRV_RAWMIDI_IOCTL_DRAIN: 925 { 926 int val; 927 928 if (get_user(val, (int __user *) argp)) 929 return -EFAULT; 930 switch (val) { 931 case SNDRV_RAWMIDI_STREAM_OUTPUT: 932 if (rfile->output == NULL) 933 return -EINVAL; 934 return snd_rawmidi_drain_output(rfile->output); 935 case SNDRV_RAWMIDI_STREAM_INPUT: 936 if (rfile->input == NULL) 937 return -EINVAL; 938 return snd_rawmidi_drain_input(rfile->input); 939 default: 940 return -EINVAL; 941 } 942 } 943 default: 944 rmidi_dbg(rfile->rmidi, 945 "rawmidi: unknown command = 0x%x\n", cmd); 946 } 947 return -ENOTTY; 948 } 949 950 static int snd_rawmidi_control_ioctl(struct snd_card *card, 951 struct snd_ctl_file *control, 952 unsigned int cmd, 953 unsigned long arg) 954 { 955 void __user *argp = (void __user *)arg; 956 957 switch (cmd) { 958 case SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE: 959 { 960 int device; 961 962 if (get_user(device, (int __user *)argp)) 963 return -EFAULT; 964 if (device >= SNDRV_RAWMIDI_DEVICES) /* next device is -1 */ 965 device = SNDRV_RAWMIDI_DEVICES - 1; 966 mutex_lock(®ister_mutex); 967 device = device < 0 ? 0 : device + 1; 968 while (device < SNDRV_RAWMIDI_DEVICES) { 969 if (snd_rawmidi_search(card, device)) 970 break; 971 device++; 972 } 973 if (device == SNDRV_RAWMIDI_DEVICES) 974 device = -1; 975 mutex_unlock(®ister_mutex); 976 if (put_user(device, (int __user *)argp)) 977 return -EFAULT; 978 return 0; 979 } 980 case SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE: 981 { 982 int val; 983 984 if (get_user(val, (int __user *)argp)) 985 return -EFAULT; 986 control->preferred_subdevice[SND_CTL_SUBDEV_RAWMIDI] = val; 987 return 0; 988 } 989 case SNDRV_CTL_IOCTL_RAWMIDI_INFO: 990 return snd_rawmidi_info_select_user(card, argp); 991 } 992 return -ENOIOCTLCMD; 993 } 994 995 static int receive_with_tstamp_framing(struct snd_rawmidi_substream *substream, 996 const unsigned char *buffer, int src_count, const struct timespec64 *tstamp) 997 { 998 struct snd_rawmidi_runtime *runtime = substream->runtime; 999 struct snd_rawmidi_framing_tstamp *dest_ptr; 1000 struct snd_rawmidi_framing_tstamp frame = { .tv_sec = tstamp->tv_sec, .tv_nsec = tstamp->tv_nsec }; 1001 int dest_frames = 0; 1002 int orig_count = src_count; 1003 int frame_size = sizeof(struct snd_rawmidi_framing_tstamp); 1004 1005 BUILD_BUG_ON(frame_size != 0x20); 1006 if (snd_BUG_ON((runtime->hw_ptr & 0x1f) != 0)) 1007 return -EINVAL; 1008 1009 while (src_count > 0) { 1010 if ((int)(runtime->buffer_size - runtime->avail) < frame_size) { 1011 runtime->xruns += src_count; 1012 break; 1013 } 1014 if (src_count >= SNDRV_RAWMIDI_FRAMING_DATA_LENGTH) 1015 frame.length = SNDRV_RAWMIDI_FRAMING_DATA_LENGTH; 1016 else { 1017 frame.length = src_count; 1018 memset(frame.data, 0, SNDRV_RAWMIDI_FRAMING_DATA_LENGTH); 1019 } 1020 memcpy(frame.data, buffer, frame.length); 1021 buffer += frame.length; 1022 src_count -= frame.length; 1023 dest_ptr = (struct snd_rawmidi_framing_tstamp *) (runtime->buffer + runtime->hw_ptr); 1024 *dest_ptr = frame; 1025 runtime->avail += frame_size; 1026 runtime->hw_ptr += frame_size; 1027 runtime->hw_ptr %= runtime->buffer_size; 1028 dest_frames++; 1029 } 1030 return orig_count - src_count; 1031 } 1032 1033 static struct timespec64 get_framing_tstamp(struct snd_rawmidi_substream *substream) 1034 { 1035 struct timespec64 ts64 = {0, 0}; 1036 1037 switch (substream->clock_type) { 1038 case SNDRV_RAWMIDI_MODE_CLOCK_MONOTONIC_RAW: 1039 ktime_get_raw_ts64(&ts64); 1040 break; 1041 case SNDRV_RAWMIDI_MODE_CLOCK_MONOTONIC: 1042 ktime_get_ts64(&ts64); 1043 break; 1044 case SNDRV_RAWMIDI_MODE_CLOCK_REALTIME: 1045 ktime_get_real_ts64(&ts64); 1046 break; 1047 } 1048 return ts64; 1049 } 1050 1051 /** 1052 * snd_rawmidi_receive - receive the input data from the device 1053 * @substream: the rawmidi substream 1054 * @buffer: the buffer pointer 1055 * @count: the data size to read 1056 * 1057 * Reads the data from the internal buffer. 1058 * 1059 * Return: The size of read data, or a negative error code on failure. 1060 */ 1061 int snd_rawmidi_receive(struct snd_rawmidi_substream *substream, 1062 const unsigned char *buffer, int count) 1063 { 1064 unsigned long flags; 1065 struct timespec64 ts64 = get_framing_tstamp(substream); 1066 int result = 0, count1; 1067 struct snd_rawmidi_runtime *runtime = substream->runtime; 1068 1069 if (!substream->opened) 1070 return -EBADFD; 1071 if (runtime->buffer == NULL) { 1072 rmidi_dbg(substream->rmidi, 1073 "snd_rawmidi_receive: input is not active!!!\n"); 1074 return -EINVAL; 1075 } 1076 1077 spin_lock_irqsave(&runtime->lock, flags); 1078 if (substream->framing == SNDRV_RAWMIDI_MODE_FRAMING_TSTAMP) { 1079 result = receive_with_tstamp_framing(substream, buffer, count, &ts64); 1080 } else if (count == 1) { /* special case, faster code */ 1081 substream->bytes++; 1082 if (runtime->avail < runtime->buffer_size) { 1083 runtime->buffer[runtime->hw_ptr++] = buffer[0]; 1084 runtime->hw_ptr %= runtime->buffer_size; 1085 runtime->avail++; 1086 result++; 1087 } else { 1088 runtime->xruns++; 1089 } 1090 } else { 1091 substream->bytes += count; 1092 count1 = runtime->buffer_size - runtime->hw_ptr; 1093 if (count1 > count) 1094 count1 = count; 1095 if (count1 > (int)(runtime->buffer_size - runtime->avail)) 1096 count1 = runtime->buffer_size - runtime->avail; 1097 memcpy(runtime->buffer + runtime->hw_ptr, buffer, count1); 1098 runtime->hw_ptr += count1; 1099 runtime->hw_ptr %= runtime->buffer_size; 1100 runtime->avail += count1; 1101 count -= count1; 1102 result += count1; 1103 if (count > 0) { 1104 buffer += count1; 1105 count1 = count; 1106 if (count1 > (int)(runtime->buffer_size - runtime->avail)) { 1107 count1 = runtime->buffer_size - runtime->avail; 1108 runtime->xruns += count - count1; 1109 } 1110 if (count1 > 0) { 1111 memcpy(runtime->buffer, buffer, count1); 1112 runtime->hw_ptr = count1; 1113 runtime->avail += count1; 1114 result += count1; 1115 } 1116 } 1117 } 1118 if (result > 0) { 1119 if (runtime->event) 1120 schedule_work(&runtime->event_work); 1121 else if (__snd_rawmidi_ready(runtime)) 1122 wake_up(&runtime->sleep); 1123 } 1124 spin_unlock_irqrestore(&runtime->lock, flags); 1125 return result; 1126 } 1127 EXPORT_SYMBOL(snd_rawmidi_receive); 1128 1129 static long snd_rawmidi_kernel_read1(struct snd_rawmidi_substream *substream, 1130 unsigned char __user *userbuf, 1131 unsigned char *kernelbuf, long count) 1132 { 1133 unsigned long flags; 1134 long result = 0, count1; 1135 struct snd_rawmidi_runtime *runtime = substream->runtime; 1136 unsigned long appl_ptr; 1137 int err = 0; 1138 1139 spin_lock_irqsave(&runtime->lock, flags); 1140 snd_rawmidi_buffer_ref(runtime); 1141 while (count > 0 && runtime->avail) { 1142 count1 = runtime->buffer_size - runtime->appl_ptr; 1143 if (count1 > count) 1144 count1 = count; 1145 if (count1 > (int)runtime->avail) 1146 count1 = runtime->avail; 1147 1148 /* update runtime->appl_ptr before unlocking for userbuf */ 1149 appl_ptr = runtime->appl_ptr; 1150 runtime->appl_ptr += count1; 1151 runtime->appl_ptr %= runtime->buffer_size; 1152 runtime->avail -= count1; 1153 1154 if (kernelbuf) 1155 memcpy(kernelbuf + result, runtime->buffer + appl_ptr, count1); 1156 if (userbuf) { 1157 spin_unlock_irqrestore(&runtime->lock, flags); 1158 if (copy_to_user(userbuf + result, 1159 runtime->buffer + appl_ptr, count1)) 1160 err = -EFAULT; 1161 spin_lock_irqsave(&runtime->lock, flags); 1162 if (err) 1163 goto out; 1164 } 1165 result += count1; 1166 count -= count1; 1167 } 1168 out: 1169 snd_rawmidi_buffer_unref(runtime); 1170 spin_unlock_irqrestore(&runtime->lock, flags); 1171 return result > 0 ? result : err; 1172 } 1173 1174 long snd_rawmidi_kernel_read(struct snd_rawmidi_substream *substream, 1175 unsigned char *buf, long count) 1176 { 1177 snd_rawmidi_input_trigger(substream, 1); 1178 return snd_rawmidi_kernel_read1(substream, NULL/*userbuf*/, buf, count); 1179 } 1180 EXPORT_SYMBOL(snd_rawmidi_kernel_read); 1181 1182 static ssize_t snd_rawmidi_read(struct file *file, char __user *buf, size_t count, 1183 loff_t *offset) 1184 { 1185 long result; 1186 int count1; 1187 struct snd_rawmidi_file *rfile; 1188 struct snd_rawmidi_substream *substream; 1189 struct snd_rawmidi_runtime *runtime; 1190 1191 rfile = file->private_data; 1192 substream = rfile->input; 1193 if (substream == NULL) 1194 return -EIO; 1195 runtime = substream->runtime; 1196 snd_rawmidi_input_trigger(substream, 1); 1197 result = 0; 1198 while (count > 0) { 1199 spin_lock_irq(&runtime->lock); 1200 while (!__snd_rawmidi_ready(runtime)) { 1201 wait_queue_entry_t wait; 1202 1203 if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) { 1204 spin_unlock_irq(&runtime->lock); 1205 return result > 0 ? result : -EAGAIN; 1206 } 1207 init_waitqueue_entry(&wait, current); 1208 add_wait_queue(&runtime->sleep, &wait); 1209 set_current_state(TASK_INTERRUPTIBLE); 1210 spin_unlock_irq(&runtime->lock); 1211 schedule(); 1212 remove_wait_queue(&runtime->sleep, &wait); 1213 if (rfile->rmidi->card->shutdown) 1214 return -ENODEV; 1215 if (signal_pending(current)) 1216 return result > 0 ? result : -ERESTARTSYS; 1217 spin_lock_irq(&runtime->lock); 1218 if (!runtime->avail) { 1219 spin_unlock_irq(&runtime->lock); 1220 return result > 0 ? result : -EIO; 1221 } 1222 } 1223 spin_unlock_irq(&runtime->lock); 1224 count1 = snd_rawmidi_kernel_read1(substream, 1225 (unsigned char __user *)buf, 1226 NULL/*kernelbuf*/, 1227 count); 1228 if (count1 < 0) 1229 return result > 0 ? result : count1; 1230 result += count1; 1231 buf += count1; 1232 count -= count1; 1233 } 1234 return result; 1235 } 1236 1237 /** 1238 * snd_rawmidi_transmit_empty - check whether the output buffer is empty 1239 * @substream: the rawmidi substream 1240 * 1241 * Return: 1 if the internal output buffer is empty, 0 if not. 1242 */ 1243 int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream *substream) 1244 { 1245 struct snd_rawmidi_runtime *runtime = substream->runtime; 1246 int result; 1247 unsigned long flags; 1248 1249 if (runtime->buffer == NULL) { 1250 rmidi_dbg(substream->rmidi, 1251 "snd_rawmidi_transmit_empty: output is not active!!!\n"); 1252 return 1; 1253 } 1254 spin_lock_irqsave(&runtime->lock, flags); 1255 result = runtime->avail >= runtime->buffer_size; 1256 spin_unlock_irqrestore(&runtime->lock, flags); 1257 return result; 1258 } 1259 EXPORT_SYMBOL(snd_rawmidi_transmit_empty); 1260 1261 /** 1262 * __snd_rawmidi_transmit_peek - copy data from the internal buffer 1263 * @substream: the rawmidi substream 1264 * @buffer: the buffer pointer 1265 * @count: data size to transfer 1266 * 1267 * This is a variant of snd_rawmidi_transmit_peek() without spinlock. 1268 */ 1269 int __snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream, 1270 unsigned char *buffer, int count) 1271 { 1272 int result, count1; 1273 struct snd_rawmidi_runtime *runtime = substream->runtime; 1274 1275 if (runtime->buffer == NULL) { 1276 rmidi_dbg(substream->rmidi, 1277 "snd_rawmidi_transmit_peek: output is not active!!!\n"); 1278 return -EINVAL; 1279 } 1280 result = 0; 1281 if (runtime->avail >= runtime->buffer_size) { 1282 /* warning: lowlevel layer MUST trigger down the hardware */ 1283 goto __skip; 1284 } 1285 if (count == 1) { /* special case, faster code */ 1286 *buffer = runtime->buffer[runtime->hw_ptr]; 1287 result++; 1288 } else { 1289 count1 = runtime->buffer_size - runtime->hw_ptr; 1290 if (count1 > count) 1291 count1 = count; 1292 if (count1 > (int)(runtime->buffer_size - runtime->avail)) 1293 count1 = runtime->buffer_size - runtime->avail; 1294 memcpy(buffer, runtime->buffer + runtime->hw_ptr, count1); 1295 count -= count1; 1296 result += count1; 1297 if (count > 0) { 1298 if (count > (int)(runtime->buffer_size - runtime->avail - count1)) 1299 count = runtime->buffer_size - runtime->avail - count1; 1300 memcpy(buffer + count1, runtime->buffer, count); 1301 result += count; 1302 } 1303 } 1304 __skip: 1305 return result; 1306 } 1307 EXPORT_SYMBOL(__snd_rawmidi_transmit_peek); 1308 1309 /** 1310 * snd_rawmidi_transmit_peek - copy data from the internal buffer 1311 * @substream: the rawmidi substream 1312 * @buffer: the buffer pointer 1313 * @count: data size to transfer 1314 * 1315 * Copies data from the internal output buffer to the given buffer. 1316 * 1317 * Call this in the interrupt handler when the midi output is ready, 1318 * and call snd_rawmidi_transmit_ack() after the transmission is 1319 * finished. 1320 * 1321 * Return: The size of copied data, or a negative error code on failure. 1322 */ 1323 int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream, 1324 unsigned char *buffer, int count) 1325 { 1326 struct snd_rawmidi_runtime *runtime = substream->runtime; 1327 int result; 1328 unsigned long flags; 1329 1330 spin_lock_irqsave(&runtime->lock, flags); 1331 result = __snd_rawmidi_transmit_peek(substream, buffer, count); 1332 spin_unlock_irqrestore(&runtime->lock, flags); 1333 return result; 1334 } 1335 EXPORT_SYMBOL(snd_rawmidi_transmit_peek); 1336 1337 /** 1338 * __snd_rawmidi_transmit_ack - acknowledge the transmission 1339 * @substream: the rawmidi substream 1340 * @count: the transferred count 1341 * 1342 * This is a variant of __snd_rawmidi_transmit_ack() without spinlock. 1343 */ 1344 int __snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count) 1345 { 1346 struct snd_rawmidi_runtime *runtime = substream->runtime; 1347 1348 if (runtime->buffer == NULL) { 1349 rmidi_dbg(substream->rmidi, 1350 "snd_rawmidi_transmit_ack: output is not active!!!\n"); 1351 return -EINVAL; 1352 } 1353 snd_BUG_ON(runtime->avail + count > runtime->buffer_size); 1354 runtime->hw_ptr += count; 1355 runtime->hw_ptr %= runtime->buffer_size; 1356 runtime->avail += count; 1357 substream->bytes += count; 1358 if (count > 0) { 1359 if (runtime->drain || __snd_rawmidi_ready(runtime)) 1360 wake_up(&runtime->sleep); 1361 } 1362 return count; 1363 } 1364 EXPORT_SYMBOL(__snd_rawmidi_transmit_ack); 1365 1366 /** 1367 * snd_rawmidi_transmit_ack - acknowledge the transmission 1368 * @substream: the rawmidi substream 1369 * @count: the transferred count 1370 * 1371 * Advances the hardware pointer for the internal output buffer with 1372 * the given size and updates the condition. 1373 * Call after the transmission is finished. 1374 * 1375 * Return: The advanced size if successful, or a negative error code on failure. 1376 */ 1377 int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count) 1378 { 1379 struct snd_rawmidi_runtime *runtime = substream->runtime; 1380 int result; 1381 unsigned long flags; 1382 1383 spin_lock_irqsave(&runtime->lock, flags); 1384 result = __snd_rawmidi_transmit_ack(substream, count); 1385 spin_unlock_irqrestore(&runtime->lock, flags); 1386 return result; 1387 } 1388 EXPORT_SYMBOL(snd_rawmidi_transmit_ack); 1389 1390 /** 1391 * snd_rawmidi_transmit - copy from the buffer to the device 1392 * @substream: the rawmidi substream 1393 * @buffer: the buffer pointer 1394 * @count: the data size to transfer 1395 * 1396 * Copies data from the buffer to the device and advances the pointer. 1397 * 1398 * Return: The copied size if successful, or a negative error code on failure. 1399 */ 1400 int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream, 1401 unsigned char *buffer, int count) 1402 { 1403 struct snd_rawmidi_runtime *runtime = substream->runtime; 1404 int result; 1405 unsigned long flags; 1406 1407 spin_lock_irqsave(&runtime->lock, flags); 1408 if (!substream->opened) 1409 result = -EBADFD; 1410 else { 1411 count = __snd_rawmidi_transmit_peek(substream, buffer, count); 1412 if (count <= 0) 1413 result = count; 1414 else 1415 result = __snd_rawmidi_transmit_ack(substream, count); 1416 } 1417 spin_unlock_irqrestore(&runtime->lock, flags); 1418 return result; 1419 } 1420 EXPORT_SYMBOL(snd_rawmidi_transmit); 1421 1422 /** 1423 * snd_rawmidi_proceed - Discard the all pending bytes and proceed 1424 * @substream: rawmidi substream 1425 * 1426 * Return: the number of discarded bytes 1427 */ 1428 int snd_rawmidi_proceed(struct snd_rawmidi_substream *substream) 1429 { 1430 struct snd_rawmidi_runtime *runtime = substream->runtime; 1431 unsigned long flags; 1432 int count = 0; 1433 1434 spin_lock_irqsave(&runtime->lock, flags); 1435 if (runtime->avail < runtime->buffer_size) { 1436 count = runtime->buffer_size - runtime->avail; 1437 __snd_rawmidi_transmit_ack(substream, count); 1438 } 1439 spin_unlock_irqrestore(&runtime->lock, flags); 1440 return count; 1441 } 1442 EXPORT_SYMBOL(snd_rawmidi_proceed); 1443 1444 static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream, 1445 const unsigned char __user *userbuf, 1446 const unsigned char *kernelbuf, 1447 long count) 1448 { 1449 unsigned long flags; 1450 long count1, result; 1451 struct snd_rawmidi_runtime *runtime = substream->runtime; 1452 unsigned long appl_ptr; 1453 1454 if (!kernelbuf && !userbuf) 1455 return -EINVAL; 1456 if (snd_BUG_ON(!runtime->buffer)) 1457 return -EINVAL; 1458 1459 result = 0; 1460 spin_lock_irqsave(&runtime->lock, flags); 1461 if (substream->append) { 1462 if ((long)runtime->avail < count) { 1463 spin_unlock_irqrestore(&runtime->lock, flags); 1464 return -EAGAIN; 1465 } 1466 } 1467 snd_rawmidi_buffer_ref(runtime); 1468 while (count > 0 && runtime->avail > 0) { 1469 count1 = runtime->buffer_size - runtime->appl_ptr; 1470 if (count1 > count) 1471 count1 = count; 1472 if (count1 > (long)runtime->avail) 1473 count1 = runtime->avail; 1474 1475 /* update runtime->appl_ptr before unlocking for userbuf */ 1476 appl_ptr = runtime->appl_ptr; 1477 runtime->appl_ptr += count1; 1478 runtime->appl_ptr %= runtime->buffer_size; 1479 runtime->avail -= count1; 1480 1481 if (kernelbuf) 1482 memcpy(runtime->buffer + appl_ptr, 1483 kernelbuf + result, count1); 1484 else if (userbuf) { 1485 spin_unlock_irqrestore(&runtime->lock, flags); 1486 if (copy_from_user(runtime->buffer + appl_ptr, 1487 userbuf + result, count1)) { 1488 spin_lock_irqsave(&runtime->lock, flags); 1489 result = result > 0 ? result : -EFAULT; 1490 goto __end; 1491 } 1492 spin_lock_irqsave(&runtime->lock, flags); 1493 } 1494 result += count1; 1495 count -= count1; 1496 } 1497 __end: 1498 count1 = runtime->avail < runtime->buffer_size; 1499 snd_rawmidi_buffer_unref(runtime); 1500 spin_unlock_irqrestore(&runtime->lock, flags); 1501 if (count1) 1502 snd_rawmidi_output_trigger(substream, 1); 1503 return result; 1504 } 1505 1506 long snd_rawmidi_kernel_write(struct snd_rawmidi_substream *substream, 1507 const unsigned char *buf, long count) 1508 { 1509 return snd_rawmidi_kernel_write1(substream, NULL, buf, count); 1510 } 1511 EXPORT_SYMBOL(snd_rawmidi_kernel_write); 1512 1513 static ssize_t snd_rawmidi_write(struct file *file, const char __user *buf, 1514 size_t count, loff_t *offset) 1515 { 1516 long result, timeout; 1517 int count1; 1518 struct snd_rawmidi_file *rfile; 1519 struct snd_rawmidi_runtime *runtime; 1520 struct snd_rawmidi_substream *substream; 1521 1522 rfile = file->private_data; 1523 substream = rfile->output; 1524 runtime = substream->runtime; 1525 /* we cannot put an atomic message to our buffer */ 1526 if (substream->append && count > runtime->buffer_size) 1527 return -EIO; 1528 result = 0; 1529 while (count > 0) { 1530 spin_lock_irq(&runtime->lock); 1531 while (!snd_rawmidi_ready_append(substream, count)) { 1532 wait_queue_entry_t wait; 1533 1534 if (file->f_flags & O_NONBLOCK) { 1535 spin_unlock_irq(&runtime->lock); 1536 return result > 0 ? result : -EAGAIN; 1537 } 1538 init_waitqueue_entry(&wait, current); 1539 add_wait_queue(&runtime->sleep, &wait); 1540 set_current_state(TASK_INTERRUPTIBLE); 1541 spin_unlock_irq(&runtime->lock); 1542 timeout = schedule_timeout(30 * HZ); 1543 remove_wait_queue(&runtime->sleep, &wait); 1544 if (rfile->rmidi->card->shutdown) 1545 return -ENODEV; 1546 if (signal_pending(current)) 1547 return result > 0 ? result : -ERESTARTSYS; 1548 spin_lock_irq(&runtime->lock); 1549 if (!runtime->avail && !timeout) { 1550 spin_unlock_irq(&runtime->lock); 1551 return result > 0 ? result : -EIO; 1552 } 1553 } 1554 spin_unlock_irq(&runtime->lock); 1555 count1 = snd_rawmidi_kernel_write1(substream, buf, NULL, count); 1556 if (count1 < 0) 1557 return result > 0 ? result : count1; 1558 result += count1; 1559 buf += count1; 1560 if ((size_t)count1 < count && (file->f_flags & O_NONBLOCK)) 1561 break; 1562 count -= count1; 1563 } 1564 if (file->f_flags & O_DSYNC) { 1565 spin_lock_irq(&runtime->lock); 1566 while (runtime->avail != runtime->buffer_size) { 1567 wait_queue_entry_t wait; 1568 unsigned int last_avail = runtime->avail; 1569 1570 init_waitqueue_entry(&wait, current); 1571 add_wait_queue(&runtime->sleep, &wait); 1572 set_current_state(TASK_INTERRUPTIBLE); 1573 spin_unlock_irq(&runtime->lock); 1574 timeout = schedule_timeout(30 * HZ); 1575 remove_wait_queue(&runtime->sleep, &wait); 1576 if (signal_pending(current)) 1577 return result > 0 ? result : -ERESTARTSYS; 1578 if (runtime->avail == last_avail && !timeout) 1579 return result > 0 ? result : -EIO; 1580 spin_lock_irq(&runtime->lock); 1581 } 1582 spin_unlock_irq(&runtime->lock); 1583 } 1584 return result; 1585 } 1586 1587 static __poll_t snd_rawmidi_poll(struct file *file, poll_table *wait) 1588 { 1589 struct snd_rawmidi_file *rfile; 1590 struct snd_rawmidi_runtime *runtime; 1591 __poll_t mask; 1592 1593 rfile = file->private_data; 1594 if (rfile->input != NULL) { 1595 runtime = rfile->input->runtime; 1596 snd_rawmidi_input_trigger(rfile->input, 1); 1597 poll_wait(file, &runtime->sleep, wait); 1598 } 1599 if (rfile->output != NULL) { 1600 runtime = rfile->output->runtime; 1601 poll_wait(file, &runtime->sleep, wait); 1602 } 1603 mask = 0; 1604 if (rfile->input != NULL) { 1605 if (snd_rawmidi_ready(rfile->input)) 1606 mask |= EPOLLIN | EPOLLRDNORM; 1607 } 1608 if (rfile->output != NULL) { 1609 if (snd_rawmidi_ready(rfile->output)) 1610 mask |= EPOLLOUT | EPOLLWRNORM; 1611 } 1612 return mask; 1613 } 1614 1615 /* 1616 */ 1617 #ifdef CONFIG_COMPAT 1618 #include "rawmidi_compat.c" 1619 #else 1620 #define snd_rawmidi_ioctl_compat NULL 1621 #endif 1622 1623 /* 1624 */ 1625 1626 static void snd_rawmidi_proc_info_read(struct snd_info_entry *entry, 1627 struct snd_info_buffer *buffer) 1628 { 1629 struct snd_rawmidi *rmidi; 1630 struct snd_rawmidi_substream *substream; 1631 struct snd_rawmidi_runtime *runtime; 1632 unsigned long buffer_size, avail, xruns; 1633 unsigned int clock_type; 1634 static const char *clock_names[4] = { "none", "realtime", "monotonic", "monotonic raw" }; 1635 1636 rmidi = entry->private_data; 1637 snd_iprintf(buffer, "%s\n\n", rmidi->name); 1638 mutex_lock(&rmidi->open_mutex); 1639 if (rmidi->info_flags & SNDRV_RAWMIDI_INFO_OUTPUT) { 1640 list_for_each_entry(substream, 1641 &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams, 1642 list) { 1643 snd_iprintf(buffer, 1644 "Output %d\n" 1645 " Tx bytes : %lu\n", 1646 substream->number, 1647 (unsigned long) substream->bytes); 1648 if (substream->opened) { 1649 snd_iprintf(buffer, 1650 " Owner PID : %d\n", 1651 pid_vnr(substream->pid)); 1652 runtime = substream->runtime; 1653 spin_lock_irq(&runtime->lock); 1654 buffer_size = runtime->buffer_size; 1655 avail = runtime->avail; 1656 spin_unlock_irq(&runtime->lock); 1657 snd_iprintf(buffer, 1658 " Mode : %s\n" 1659 " Buffer size : %lu\n" 1660 " Avail : %lu\n", 1661 runtime->oss ? "OSS compatible" : "native", 1662 buffer_size, avail); 1663 } 1664 } 1665 } 1666 if (rmidi->info_flags & SNDRV_RAWMIDI_INFO_INPUT) { 1667 list_for_each_entry(substream, 1668 &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams, 1669 list) { 1670 snd_iprintf(buffer, 1671 "Input %d\n" 1672 " Rx bytes : %lu\n", 1673 substream->number, 1674 (unsigned long) substream->bytes); 1675 if (substream->opened) { 1676 snd_iprintf(buffer, 1677 " Owner PID : %d\n", 1678 pid_vnr(substream->pid)); 1679 runtime = substream->runtime; 1680 spin_lock_irq(&runtime->lock); 1681 buffer_size = runtime->buffer_size; 1682 avail = runtime->avail; 1683 xruns = runtime->xruns; 1684 spin_unlock_irq(&runtime->lock); 1685 snd_iprintf(buffer, 1686 " Buffer size : %lu\n" 1687 " Avail : %lu\n" 1688 " Overruns : %lu\n", 1689 buffer_size, avail, xruns); 1690 if (substream->framing == SNDRV_RAWMIDI_MODE_FRAMING_TSTAMP) { 1691 clock_type = substream->clock_type >> SNDRV_RAWMIDI_MODE_CLOCK_SHIFT; 1692 if (!snd_BUG_ON(clock_type >= ARRAY_SIZE(clock_names))) 1693 snd_iprintf(buffer, 1694 " Framing : tstamp\n" 1695 " Clock type : %s\n", 1696 clock_names[clock_type]); 1697 } 1698 } 1699 } 1700 } 1701 mutex_unlock(&rmidi->open_mutex); 1702 } 1703 1704 /* 1705 * Register functions 1706 */ 1707 1708 static const struct file_operations snd_rawmidi_f_ops = { 1709 .owner = THIS_MODULE, 1710 .read = snd_rawmidi_read, 1711 .write = snd_rawmidi_write, 1712 .open = snd_rawmidi_open, 1713 .release = snd_rawmidi_release, 1714 .llseek = no_llseek, 1715 .poll = snd_rawmidi_poll, 1716 .unlocked_ioctl = snd_rawmidi_ioctl, 1717 .compat_ioctl = snd_rawmidi_ioctl_compat, 1718 }; 1719 1720 static int snd_rawmidi_alloc_substreams(struct snd_rawmidi *rmidi, 1721 struct snd_rawmidi_str *stream, 1722 int direction, 1723 int count) 1724 { 1725 struct snd_rawmidi_substream *substream; 1726 int idx; 1727 1728 for (idx = 0; idx < count; idx++) { 1729 substream = kzalloc(sizeof(*substream), GFP_KERNEL); 1730 if (!substream) 1731 return -ENOMEM; 1732 substream->stream = direction; 1733 substream->number = idx; 1734 substream->rmidi = rmidi; 1735 substream->pstr = stream; 1736 list_add_tail(&substream->list, &stream->substreams); 1737 stream->substream_count++; 1738 } 1739 return 0; 1740 } 1741 1742 static void release_rawmidi_device(struct device *dev) 1743 { 1744 kfree(container_of(dev, struct snd_rawmidi, dev)); 1745 } 1746 1747 /** 1748 * snd_rawmidi_new - create a rawmidi instance 1749 * @card: the card instance 1750 * @id: the id string 1751 * @device: the device index 1752 * @output_count: the number of output streams 1753 * @input_count: the number of input streams 1754 * @rrawmidi: the pointer to store the new rawmidi instance 1755 * 1756 * Creates a new rawmidi instance. 1757 * Use snd_rawmidi_set_ops() to set the operators to the new instance. 1758 * 1759 * Return: Zero if successful, or a negative error code on failure. 1760 */ 1761 int snd_rawmidi_new(struct snd_card *card, char *id, int device, 1762 int output_count, int input_count, 1763 struct snd_rawmidi **rrawmidi) 1764 { 1765 struct snd_rawmidi *rmidi; 1766 int err; 1767 static const struct snd_device_ops ops = { 1768 .dev_free = snd_rawmidi_dev_free, 1769 .dev_register = snd_rawmidi_dev_register, 1770 .dev_disconnect = snd_rawmidi_dev_disconnect, 1771 }; 1772 1773 if (snd_BUG_ON(!card)) 1774 return -ENXIO; 1775 if (rrawmidi) 1776 *rrawmidi = NULL; 1777 rmidi = kzalloc(sizeof(*rmidi), GFP_KERNEL); 1778 if (!rmidi) 1779 return -ENOMEM; 1780 rmidi->card = card; 1781 rmidi->device = device; 1782 mutex_init(&rmidi->open_mutex); 1783 init_waitqueue_head(&rmidi->open_wait); 1784 INIT_LIST_HEAD(&rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams); 1785 INIT_LIST_HEAD(&rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams); 1786 1787 if (id != NULL) 1788 strscpy(rmidi->id, id, sizeof(rmidi->id)); 1789 1790 snd_device_initialize(&rmidi->dev, card); 1791 rmidi->dev.release = release_rawmidi_device; 1792 dev_set_name(&rmidi->dev, "midiC%iD%i", card->number, device); 1793 1794 err = snd_rawmidi_alloc_substreams(rmidi, 1795 &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT], 1796 SNDRV_RAWMIDI_STREAM_INPUT, 1797 input_count); 1798 if (err < 0) 1799 goto error; 1800 err = snd_rawmidi_alloc_substreams(rmidi, 1801 &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT], 1802 SNDRV_RAWMIDI_STREAM_OUTPUT, 1803 output_count); 1804 if (err < 0) 1805 goto error; 1806 err = snd_device_new(card, SNDRV_DEV_RAWMIDI, rmidi, &ops); 1807 if (err < 0) 1808 goto error; 1809 1810 if (rrawmidi) 1811 *rrawmidi = rmidi; 1812 return 0; 1813 1814 error: 1815 snd_rawmidi_free(rmidi); 1816 return err; 1817 } 1818 EXPORT_SYMBOL(snd_rawmidi_new); 1819 1820 static void snd_rawmidi_free_substreams(struct snd_rawmidi_str *stream) 1821 { 1822 struct snd_rawmidi_substream *substream; 1823 1824 while (!list_empty(&stream->substreams)) { 1825 substream = list_entry(stream->substreams.next, struct snd_rawmidi_substream, list); 1826 list_del(&substream->list); 1827 kfree(substream); 1828 } 1829 } 1830 1831 static int snd_rawmidi_free(struct snd_rawmidi *rmidi) 1832 { 1833 if (!rmidi) 1834 return 0; 1835 1836 snd_info_free_entry(rmidi->proc_entry); 1837 rmidi->proc_entry = NULL; 1838 mutex_lock(®ister_mutex); 1839 if (rmidi->ops && rmidi->ops->dev_unregister) 1840 rmidi->ops->dev_unregister(rmidi); 1841 mutex_unlock(®ister_mutex); 1842 1843 snd_rawmidi_free_substreams(&rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT]); 1844 snd_rawmidi_free_substreams(&rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT]); 1845 if (rmidi->private_free) 1846 rmidi->private_free(rmidi); 1847 put_device(&rmidi->dev); 1848 return 0; 1849 } 1850 1851 static int snd_rawmidi_dev_free(struct snd_device *device) 1852 { 1853 struct snd_rawmidi *rmidi = device->device_data; 1854 1855 return snd_rawmidi_free(rmidi); 1856 } 1857 1858 #if IS_ENABLED(CONFIG_SND_SEQUENCER) 1859 static void snd_rawmidi_dev_seq_free(struct snd_seq_device *device) 1860 { 1861 struct snd_rawmidi *rmidi = device->private_data; 1862 1863 rmidi->seq_dev = NULL; 1864 } 1865 #endif 1866 1867 static int snd_rawmidi_dev_register(struct snd_device *device) 1868 { 1869 int err; 1870 struct snd_info_entry *entry; 1871 char name[16]; 1872 struct snd_rawmidi *rmidi = device->device_data; 1873 1874 if (rmidi->device >= SNDRV_RAWMIDI_DEVICES) 1875 return -ENOMEM; 1876 err = 0; 1877 mutex_lock(®ister_mutex); 1878 if (snd_rawmidi_search(rmidi->card, rmidi->device)) 1879 err = -EBUSY; 1880 else 1881 list_add_tail(&rmidi->list, &snd_rawmidi_devices); 1882 mutex_unlock(®ister_mutex); 1883 if (err < 0) 1884 return err; 1885 1886 err = snd_register_device(SNDRV_DEVICE_TYPE_RAWMIDI, 1887 rmidi->card, rmidi->device, 1888 &snd_rawmidi_f_ops, rmidi, &rmidi->dev); 1889 if (err < 0) { 1890 rmidi_err(rmidi, "unable to register\n"); 1891 goto error; 1892 } 1893 if (rmidi->ops && rmidi->ops->dev_register) { 1894 err = rmidi->ops->dev_register(rmidi); 1895 if (err < 0) 1896 goto error_unregister; 1897 } 1898 #ifdef CONFIG_SND_OSSEMUL 1899 rmidi->ossreg = 0; 1900 if ((int)rmidi->device == midi_map[rmidi->card->number]) { 1901 if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, 1902 rmidi->card, 0, &snd_rawmidi_f_ops, 1903 rmidi) < 0) { 1904 rmidi_err(rmidi, 1905 "unable to register OSS rawmidi device %i:%i\n", 1906 rmidi->card->number, 0); 1907 } else { 1908 rmidi->ossreg++; 1909 #ifdef SNDRV_OSS_INFO_DEV_MIDI 1910 snd_oss_info_register(SNDRV_OSS_INFO_DEV_MIDI, rmidi->card->number, rmidi->name); 1911 #endif 1912 } 1913 } 1914 if ((int)rmidi->device == amidi_map[rmidi->card->number]) { 1915 if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, 1916 rmidi->card, 1, &snd_rawmidi_f_ops, 1917 rmidi) < 0) { 1918 rmidi_err(rmidi, 1919 "unable to register OSS rawmidi device %i:%i\n", 1920 rmidi->card->number, 1); 1921 } else { 1922 rmidi->ossreg++; 1923 } 1924 } 1925 #endif /* CONFIG_SND_OSSEMUL */ 1926 sprintf(name, "midi%d", rmidi->device); 1927 entry = snd_info_create_card_entry(rmidi->card, name, rmidi->card->proc_root); 1928 if (entry) { 1929 entry->private_data = rmidi; 1930 entry->c.text.read = snd_rawmidi_proc_info_read; 1931 if (snd_info_register(entry) < 0) { 1932 snd_info_free_entry(entry); 1933 entry = NULL; 1934 } 1935 } 1936 rmidi->proc_entry = entry; 1937 #if IS_ENABLED(CONFIG_SND_SEQUENCER) 1938 if (!rmidi->ops || !rmidi->ops->dev_register) { /* own registration mechanism */ 1939 if (snd_seq_device_new(rmidi->card, rmidi->device, SNDRV_SEQ_DEV_ID_MIDISYNTH, 0, &rmidi->seq_dev) >= 0) { 1940 rmidi->seq_dev->private_data = rmidi; 1941 rmidi->seq_dev->private_free = snd_rawmidi_dev_seq_free; 1942 sprintf(rmidi->seq_dev->name, "MIDI %d-%d", rmidi->card->number, rmidi->device); 1943 snd_device_register(rmidi->card, rmidi->seq_dev); 1944 } 1945 } 1946 #endif 1947 return 0; 1948 1949 error_unregister: 1950 snd_unregister_device(&rmidi->dev); 1951 error: 1952 mutex_lock(®ister_mutex); 1953 list_del(&rmidi->list); 1954 mutex_unlock(®ister_mutex); 1955 return err; 1956 } 1957 1958 static int snd_rawmidi_dev_disconnect(struct snd_device *device) 1959 { 1960 struct snd_rawmidi *rmidi = device->device_data; 1961 int dir; 1962 1963 mutex_lock(®ister_mutex); 1964 mutex_lock(&rmidi->open_mutex); 1965 wake_up(&rmidi->open_wait); 1966 list_del_init(&rmidi->list); 1967 for (dir = 0; dir < 2; dir++) { 1968 struct snd_rawmidi_substream *s; 1969 1970 list_for_each_entry(s, &rmidi->streams[dir].substreams, list) { 1971 if (s->runtime) 1972 wake_up(&s->runtime->sleep); 1973 } 1974 } 1975 1976 #ifdef CONFIG_SND_OSSEMUL 1977 if (rmidi->ossreg) { 1978 if ((int)rmidi->device == midi_map[rmidi->card->number]) { 1979 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, rmidi->card, 0); 1980 #ifdef SNDRV_OSS_INFO_DEV_MIDI 1981 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_MIDI, rmidi->card->number); 1982 #endif 1983 } 1984 if ((int)rmidi->device == amidi_map[rmidi->card->number]) 1985 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, rmidi->card, 1); 1986 rmidi->ossreg = 0; 1987 } 1988 #endif /* CONFIG_SND_OSSEMUL */ 1989 snd_unregister_device(&rmidi->dev); 1990 mutex_unlock(&rmidi->open_mutex); 1991 mutex_unlock(®ister_mutex); 1992 return 0; 1993 } 1994 1995 /** 1996 * snd_rawmidi_set_ops - set the rawmidi operators 1997 * @rmidi: the rawmidi instance 1998 * @stream: the stream direction, SNDRV_RAWMIDI_STREAM_XXX 1999 * @ops: the operator table 2000 * 2001 * Sets the rawmidi operators for the given stream direction. 2002 */ 2003 void snd_rawmidi_set_ops(struct snd_rawmidi *rmidi, int stream, 2004 const struct snd_rawmidi_ops *ops) 2005 { 2006 struct snd_rawmidi_substream *substream; 2007 2008 list_for_each_entry(substream, &rmidi->streams[stream].substreams, list) 2009 substream->ops = ops; 2010 } 2011 EXPORT_SYMBOL(snd_rawmidi_set_ops); 2012 2013 /* 2014 * ENTRY functions 2015 */ 2016 2017 static int __init alsa_rawmidi_init(void) 2018 { 2019 2020 snd_ctl_register_ioctl(snd_rawmidi_control_ioctl); 2021 snd_ctl_register_ioctl_compat(snd_rawmidi_control_ioctl); 2022 #ifdef CONFIG_SND_OSSEMUL 2023 { int i; 2024 /* check device map table */ 2025 for (i = 0; i < SNDRV_CARDS; i++) { 2026 if (midi_map[i] < 0 || midi_map[i] >= SNDRV_RAWMIDI_DEVICES) { 2027 pr_err("ALSA: rawmidi: invalid midi_map[%d] = %d\n", 2028 i, midi_map[i]); 2029 midi_map[i] = 0; 2030 } 2031 if (amidi_map[i] < 0 || amidi_map[i] >= SNDRV_RAWMIDI_DEVICES) { 2032 pr_err("ALSA: rawmidi: invalid amidi_map[%d] = %d\n", 2033 i, amidi_map[i]); 2034 amidi_map[i] = 1; 2035 } 2036 } 2037 } 2038 #endif /* CONFIG_SND_OSSEMUL */ 2039 return 0; 2040 } 2041 2042 static void __exit alsa_rawmidi_exit(void) 2043 { 2044 snd_ctl_unregister_ioctl(snd_rawmidi_control_ioctl); 2045 snd_ctl_unregister_ioctl_compat(snd_rawmidi_control_ioctl); 2046 } 2047 2048 module_init(alsa_rawmidi_init) 2049 module_exit(alsa_rawmidi_exit) 2050