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 25MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>"); 26MODULE_DESCRIPTION("Midlevel RawMidi code for ALSA."); 27MODULE_LICENSE("GPL"); 28 29#ifdef CONFIG_SND_OSSEMUL 30static int midi_map[SNDRV_CARDS]; 31static int amidi_map[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = 1}; 32module_param_array(midi_map, int, NULL, 0444); 33MODULE_PARM_DESC(midi_map, "Raw MIDI device number assigned to 1st OSS device."); 34module_param_array(amidi_map, int, NULL, 0444); 35MODULE_PARM_DESC(amidi_map, "Raw MIDI device number assigned to 2nd OSS device."); 36#endif /* CONFIG_SND_OSSEMUL */ 37 38static int snd_rawmidi_free(struct snd_rawmidi *rmidi); 39static int snd_rawmidi_dev_free(struct snd_device *device); 40static int snd_rawmidi_dev_register(struct snd_device *device); 41static int snd_rawmidi_dev_disconnect(struct snd_device *device); 42 43static LIST_HEAD(snd_rawmidi_devices); 44static 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 53struct 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 64struct 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 76static 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 86static 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 98static inline bool __snd_rawmidi_ready(struct snd_rawmidi_runtime *runtime) 99{ 100 return runtime->avail >= runtime->avail_min; 101} 102 103static 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 115static 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 124static 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 */ 134static inline void snd_rawmidi_buffer_ref(struct snd_rawmidi_runtime *runtime) 135{ 136 runtime->buffer_ref++; 137} 138 139static inline void snd_rawmidi_buffer_unref(struct snd_rawmidi_runtime *runtime) 140{ 141 runtime->buffer_ref--; 142} 143 144static 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 172static 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 182static 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 189static 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 198static 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 206static 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 216int 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} 222EXPORT_SYMBOL(snd_rawmidi_drop_output); 223 224int 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} 254EXPORT_SYMBOL(snd_rawmidi_drain_output); 255 256int 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} 262EXPORT_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 */ 267static 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 */ 299static 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 325static void close_substream(struct snd_rawmidi *rmidi, 326 struct snd_rawmidi_substream *substream, 327 int cleanup); 328 329static 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 */ 372int 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} 398EXPORT_SYMBOL(snd_rawmidi_kernel_open); 399 400static 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 init_waitqueue_entry(&wait, current); 451 add_wait_queue(&rmidi->open_wait, &wait); 452 while (1) { 453 subdevice = snd_ctl_get_preferred_subdevice(card, SND_CTL_SUBDEV_RAWMIDI); 454 err = rawmidi_open_priv(rmidi, subdevice, fflags, rawmidi_file); 455 if (err >= 0) 456 break; 457 if (err == -EAGAIN) { 458 if (file->f_flags & O_NONBLOCK) { 459 err = -EBUSY; 460 break; 461 } 462 } else 463 break; 464 set_current_state(TASK_INTERRUPTIBLE); 465 mutex_unlock(&rmidi->open_mutex); 466 schedule(); 467 mutex_lock(&rmidi->open_mutex); 468 if (rmidi->card->shutdown) { 469 err = -ENODEV; 470 break; 471 } 472 if (signal_pending(current)) { 473 err = -ERESTARTSYS; 474 break; 475 } 476 } 477 remove_wait_queue(&rmidi->open_wait, &wait); 478 if (err < 0) { 479 kfree(rawmidi_file); 480 goto __error; 481 } 482#ifdef CONFIG_SND_OSSEMUL 483 if (rawmidi_file->input && rawmidi_file->input->runtime) 484 rawmidi_file->input->runtime->oss = (maj == SOUND_MAJOR); 485 if (rawmidi_file->output && rawmidi_file->output->runtime) 486 rawmidi_file->output->runtime->oss = (maj == SOUND_MAJOR); 487#endif 488 file->private_data = rawmidi_file; 489 mutex_unlock(&rmidi->open_mutex); 490 snd_card_unref(rmidi->card); 491 return 0; 492 493 __error: 494 snd_card_file_remove(card, file); 495 __error_card: 496 mutex_unlock(&rmidi->open_mutex); 497 module_put(rmidi->card->module); 498 snd_card_unref(rmidi->card); 499 return err; 500} 501 502static void close_substream(struct snd_rawmidi *rmidi, 503 struct snd_rawmidi_substream *substream, 504 int cleanup) 505{ 506 if (--substream->use_count) 507 return; 508 509 if (cleanup) { 510 if (substream->stream == SNDRV_RAWMIDI_STREAM_INPUT) 511 snd_rawmidi_input_trigger(substream, 0); 512 else { 513 if (substream->active_sensing) { 514 unsigned char buf = 0xfe; 515 /* sending single active sensing message 516 * to shut the device up 517 */ 518 snd_rawmidi_kernel_write(substream, &buf, 1); 519 } 520 if (snd_rawmidi_drain_output(substream) == -ERESTARTSYS) 521 snd_rawmidi_output_trigger(substream, 0); 522 } 523 } 524 substream->ops->close(substream); 525 if (substream->runtime->private_free) 526 substream->runtime->private_free(substream); 527 snd_rawmidi_runtime_free(substream); 528 substream->opened = 0; 529 substream->append = 0; 530 put_pid(substream->pid); 531 substream->pid = NULL; 532 rmidi->streams[substream->stream].substream_opened--; 533} 534 535static void rawmidi_release_priv(struct snd_rawmidi_file *rfile) 536{ 537 struct snd_rawmidi *rmidi; 538 539 rmidi = rfile->rmidi; 540 mutex_lock(&rmidi->open_mutex); 541 if (rfile->input) { 542 close_substream(rmidi, rfile->input, 1); 543 rfile->input = NULL; 544 } 545 if (rfile->output) { 546 close_substream(rmidi, rfile->output, 1); 547 rfile->output = NULL; 548 } 549 rfile->rmidi = NULL; 550 mutex_unlock(&rmidi->open_mutex); 551 wake_up(&rmidi->open_wait); 552} 553 554/* called from sound/core/seq/seq_midi.c */ 555int snd_rawmidi_kernel_release(struct snd_rawmidi_file *rfile) 556{ 557 struct snd_rawmidi *rmidi; 558 559 if (snd_BUG_ON(!rfile)) 560 return -ENXIO; 561 562 rmidi = rfile->rmidi; 563 rawmidi_release_priv(rfile); 564 module_put(rmidi->card->module); 565 return 0; 566} 567EXPORT_SYMBOL(snd_rawmidi_kernel_release); 568 569static int snd_rawmidi_release(struct inode *inode, struct file *file) 570{ 571 struct snd_rawmidi_file *rfile; 572 struct snd_rawmidi *rmidi; 573 struct module *module; 574 575 rfile = file->private_data; 576 rmidi = rfile->rmidi; 577 rawmidi_release_priv(rfile); 578 kfree(rfile); 579 module = rmidi->card->module; 580 snd_card_file_remove(rmidi->card, file); 581 module_put(module); 582 return 0; 583} 584 585static int snd_rawmidi_info(struct snd_rawmidi_substream *substream, 586 struct snd_rawmidi_info *info) 587{ 588 struct snd_rawmidi *rmidi; 589 590 if (substream == NULL) 591 return -ENODEV; 592 rmidi = substream->rmidi; 593 memset(info, 0, sizeof(*info)); 594 info->card = rmidi->card->number; 595 info->device = rmidi->device; 596 info->subdevice = substream->number; 597 info->stream = substream->stream; 598 info->flags = rmidi->info_flags; 599 strcpy(info->id, rmidi->id); 600 strcpy(info->name, rmidi->name); 601 strcpy(info->subname, substream->name); 602 info->subdevices_count = substream->pstr->substream_count; 603 info->subdevices_avail = (substream->pstr->substream_count - 604 substream->pstr->substream_opened); 605 return 0; 606} 607 608static int snd_rawmidi_info_user(struct snd_rawmidi_substream *substream, 609 struct snd_rawmidi_info __user *_info) 610{ 611 struct snd_rawmidi_info info; 612 int err; 613 614 err = snd_rawmidi_info(substream, &info); 615 if (err < 0) 616 return err; 617 if (copy_to_user(_info, &info, sizeof(struct snd_rawmidi_info))) 618 return -EFAULT; 619 return 0; 620} 621 622static int __snd_rawmidi_info_select(struct snd_card *card, 623 struct snd_rawmidi_info *info) 624{ 625 struct snd_rawmidi *rmidi; 626 struct snd_rawmidi_str *pstr; 627 struct snd_rawmidi_substream *substream; 628 629 rmidi = snd_rawmidi_search(card, info->device); 630 if (!rmidi) 631 return -ENXIO; 632 if (info->stream < 0 || info->stream > 1) 633 return -EINVAL; 634 info->stream = array_index_nospec(info->stream, 2); 635 pstr = &rmidi->streams[info->stream]; 636 if (pstr->substream_count == 0) 637 return -ENOENT; 638 if (info->subdevice >= pstr->substream_count) 639 return -ENXIO; 640 list_for_each_entry(substream, &pstr->substreams, list) { 641 if ((unsigned int)substream->number == info->subdevice) 642 return snd_rawmidi_info(substream, info); 643 } 644 return -ENXIO; 645} 646 647int snd_rawmidi_info_select(struct snd_card *card, struct snd_rawmidi_info *info) 648{ 649 int ret; 650 651 mutex_lock(®ister_mutex); 652 ret = __snd_rawmidi_info_select(card, info); 653 mutex_unlock(®ister_mutex); 654 return ret; 655} 656EXPORT_SYMBOL(snd_rawmidi_info_select); 657 658static int snd_rawmidi_info_select_user(struct snd_card *card, 659 struct snd_rawmidi_info __user *_info) 660{ 661 int err; 662 struct snd_rawmidi_info info; 663 664 if (get_user(info.device, &_info->device)) 665 return -EFAULT; 666 if (get_user(info.stream, &_info->stream)) 667 return -EFAULT; 668 if (get_user(info.subdevice, &_info->subdevice)) 669 return -EFAULT; 670 err = snd_rawmidi_info_select(card, &info); 671 if (err < 0) 672 return err; 673 if (copy_to_user(_info, &info, sizeof(struct snd_rawmidi_info))) 674 return -EFAULT; 675 return 0; 676} 677 678static int resize_runtime_buffer(struct snd_rawmidi_runtime *runtime, 679 struct snd_rawmidi_params *params, 680 bool is_input) 681{ 682 char *newbuf, *oldbuf; 683 684 if (params->buffer_size < 32 || params->buffer_size > 1024L * 1024L) 685 return -EINVAL; 686 if (params->avail_min < 1 || params->avail_min > params->buffer_size) 687 return -EINVAL; 688 if (params->buffer_size != runtime->buffer_size) { 689 newbuf = kvzalloc(params->buffer_size, GFP_KERNEL); 690 if (!newbuf) 691 return -ENOMEM; 692 spin_lock_irq(&runtime->lock); 693 if (runtime->buffer_ref) { 694 spin_unlock_irq(&runtime->lock); 695 kvfree(newbuf); 696 return -EBUSY; 697 } 698 oldbuf = runtime->buffer; 699 runtime->buffer = newbuf; 700 runtime->buffer_size = params->buffer_size; 701 __reset_runtime_ptrs(runtime, is_input); 702 spin_unlock_irq(&runtime->lock); 703 kvfree(oldbuf); 704 } 705 runtime->avail_min = params->avail_min; 706 return 0; 707} 708 709int snd_rawmidi_output_params(struct snd_rawmidi_substream *substream, 710 struct snd_rawmidi_params *params) 711{ 712 if (substream->append && substream->use_count > 1) 713 return -EBUSY; 714 snd_rawmidi_drain_output(substream); 715 substream->active_sensing = !params->no_active_sensing; 716 return resize_runtime_buffer(substream->runtime, params, false); 717} 718EXPORT_SYMBOL(snd_rawmidi_output_params); 719 720int snd_rawmidi_input_params(struct snd_rawmidi_substream *substream, 721 struct snd_rawmidi_params *params) 722{ 723 snd_rawmidi_drain_input(substream); 724 return resize_runtime_buffer(substream->runtime, params, true); 725} 726EXPORT_SYMBOL(snd_rawmidi_input_params); 727 728static int snd_rawmidi_output_status(struct snd_rawmidi_substream *substream, 729 struct snd_rawmidi_status64 *status) 730{ 731 struct snd_rawmidi_runtime *runtime = substream->runtime; 732 733 memset(status, 0, sizeof(*status)); 734 status->stream = SNDRV_RAWMIDI_STREAM_OUTPUT; 735 spin_lock_irq(&runtime->lock); 736 status->avail = runtime->avail; 737 spin_unlock_irq(&runtime->lock); 738 return 0; 739} 740 741static int snd_rawmidi_input_status(struct snd_rawmidi_substream *substream, 742 struct snd_rawmidi_status64 *status) 743{ 744 struct snd_rawmidi_runtime *runtime = substream->runtime; 745 746 memset(status, 0, sizeof(*status)); 747 status->stream = SNDRV_RAWMIDI_STREAM_INPUT; 748 spin_lock_irq(&runtime->lock); 749 status->avail = runtime->avail; 750 status->xruns = runtime->xruns; 751 runtime->xruns = 0; 752 spin_unlock_irq(&runtime->lock); 753 return 0; 754} 755 756static int snd_rawmidi_ioctl_status32(struct snd_rawmidi_file *rfile, 757 struct snd_rawmidi_status32 __user *argp) 758{ 759 int err = 0; 760 struct snd_rawmidi_status32 __user *status = argp; 761 struct snd_rawmidi_status32 status32; 762 struct snd_rawmidi_status64 status64; 763 764 if (copy_from_user(&status32, argp, 765 sizeof(struct snd_rawmidi_status32))) 766 return -EFAULT; 767 768 switch (status32.stream) { 769 case SNDRV_RAWMIDI_STREAM_OUTPUT: 770 if (rfile->output == NULL) 771 return -EINVAL; 772 err = snd_rawmidi_output_status(rfile->output, &status64); 773 break; 774 case SNDRV_RAWMIDI_STREAM_INPUT: 775 if (rfile->input == NULL) 776 return -EINVAL; 777 err = snd_rawmidi_input_status(rfile->input, &status64); 778 break; 779 default: 780 return -EINVAL; 781 } 782 if (err < 0) 783 return err; 784 785 status32 = (struct snd_rawmidi_status32) { 786 .stream = status64.stream, 787 .tstamp_sec = status64.tstamp_sec, 788 .tstamp_nsec = status64.tstamp_nsec, 789 .avail = status64.avail, 790 .xruns = status64.xruns, 791 }; 792 793 if (copy_to_user(status, &status32, sizeof(*status))) 794 return -EFAULT; 795 796 return 0; 797} 798 799static int snd_rawmidi_ioctl_status64(struct snd_rawmidi_file *rfile, 800 struct snd_rawmidi_status64 __user *argp) 801{ 802 int err = 0; 803 struct snd_rawmidi_status64 status; 804 805 if (copy_from_user(&status, argp, sizeof(struct snd_rawmidi_status64))) 806 return -EFAULT; 807 808 switch (status.stream) { 809 case SNDRV_RAWMIDI_STREAM_OUTPUT: 810 if (rfile->output == NULL) 811 return -EINVAL; 812 err = snd_rawmidi_output_status(rfile->output, &status); 813 break; 814 case SNDRV_RAWMIDI_STREAM_INPUT: 815 if (rfile->input == NULL) 816 return -EINVAL; 817 err = snd_rawmidi_input_status(rfile->input, &status); 818 break; 819 default: 820 return -EINVAL; 821 } 822 if (err < 0) 823 return err; 824 if (copy_to_user(argp, &status, 825 sizeof(struct snd_rawmidi_status64))) 826 return -EFAULT; 827 return 0; 828} 829 830static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 831{ 832 struct snd_rawmidi_file *rfile; 833 void __user *argp = (void __user *)arg; 834 835 rfile = file->private_data; 836 if (((cmd >> 8) & 0xff) != 'W') 837 return -ENOTTY; 838 switch (cmd) { 839 case SNDRV_RAWMIDI_IOCTL_PVERSION: 840 return put_user(SNDRV_RAWMIDI_VERSION, (int __user *)argp) ? -EFAULT : 0; 841 case SNDRV_RAWMIDI_IOCTL_INFO: 842 { 843 int stream; 844 struct snd_rawmidi_info __user *info = argp; 845 846 if (get_user(stream, &info->stream)) 847 return -EFAULT; 848 switch (stream) { 849 case SNDRV_RAWMIDI_STREAM_INPUT: 850 return snd_rawmidi_info_user(rfile->input, info); 851 case SNDRV_RAWMIDI_STREAM_OUTPUT: 852 return snd_rawmidi_info_user(rfile->output, info); 853 default: 854 return -EINVAL; 855 } 856 } 857 case SNDRV_RAWMIDI_IOCTL_PARAMS: 858 { 859 struct snd_rawmidi_params params; 860 861 if (copy_from_user(¶ms, argp, sizeof(struct snd_rawmidi_params))) 862 return -EFAULT; 863 switch (params.stream) { 864 case SNDRV_RAWMIDI_STREAM_OUTPUT: 865 if (rfile->output == NULL) 866 return -EINVAL; 867 return snd_rawmidi_output_params(rfile->output, ¶ms); 868 case SNDRV_RAWMIDI_STREAM_INPUT: 869 if (rfile->input == NULL) 870 return -EINVAL; 871 return snd_rawmidi_input_params(rfile->input, ¶ms); 872 default: 873 return -EINVAL; 874 } 875 } 876 case SNDRV_RAWMIDI_IOCTL_STATUS32: 877 return snd_rawmidi_ioctl_status32(rfile, argp); 878 case SNDRV_RAWMIDI_IOCTL_STATUS64: 879 return snd_rawmidi_ioctl_status64(rfile, argp); 880 case SNDRV_RAWMIDI_IOCTL_DROP: 881 { 882 int val; 883 884 if (get_user(val, (int __user *) argp)) 885 return -EFAULT; 886 switch (val) { 887 case SNDRV_RAWMIDI_STREAM_OUTPUT: 888 if (rfile->output == NULL) 889 return -EINVAL; 890 return snd_rawmidi_drop_output(rfile->output); 891 default: 892 return -EINVAL; 893 } 894 } 895 case SNDRV_RAWMIDI_IOCTL_DRAIN: 896 { 897 int val; 898 899 if (get_user(val, (int __user *) argp)) 900 return -EFAULT; 901 switch (val) { 902 case SNDRV_RAWMIDI_STREAM_OUTPUT: 903 if (rfile->output == NULL) 904 return -EINVAL; 905 return snd_rawmidi_drain_output(rfile->output); 906 case SNDRV_RAWMIDI_STREAM_INPUT: 907 if (rfile->input == NULL) 908 return -EINVAL; 909 return snd_rawmidi_drain_input(rfile->input); 910 default: 911 return -EINVAL; 912 } 913 } 914 default: 915 rmidi_dbg(rfile->rmidi, 916 "rawmidi: unknown command = 0x%x\n", cmd); 917 } 918 return -ENOTTY; 919} 920 921static int snd_rawmidi_control_ioctl(struct snd_card *card, 922 struct snd_ctl_file *control, 923 unsigned int cmd, 924 unsigned long arg) 925{ 926 void __user *argp = (void __user *)arg; 927 928 switch (cmd) { 929 case SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE: 930 { 931 int device; 932 933 if (get_user(device, (int __user *)argp)) 934 return -EFAULT; 935 if (device >= SNDRV_RAWMIDI_DEVICES) /* next device is -1 */ 936 device = SNDRV_RAWMIDI_DEVICES - 1; 937 mutex_lock(®ister_mutex); 938 device = device < 0 ? 0 : device + 1; 939 while (device < SNDRV_RAWMIDI_DEVICES) { 940 if (snd_rawmidi_search(card, device)) 941 break; 942 device++; 943 } 944 if (device == SNDRV_RAWMIDI_DEVICES) 945 device = -1; 946 mutex_unlock(®ister_mutex); 947 if (put_user(device, (int __user *)argp)) 948 return -EFAULT; 949 return 0; 950 } 951 case SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE: 952 { 953 int val; 954 955 if (get_user(val, (int __user *)argp)) 956 return -EFAULT; 957 control->preferred_subdevice[SND_CTL_SUBDEV_RAWMIDI] = val; 958 return 0; 959 } 960 case SNDRV_CTL_IOCTL_RAWMIDI_INFO: 961 return snd_rawmidi_info_select_user(card, argp); 962 } 963 return -ENOIOCTLCMD; 964} 965 966/** 967 * snd_rawmidi_receive - receive the input data from the device 968 * @substream: the rawmidi substream 969 * @buffer: the buffer pointer 970 * @count: the data size to read 971 * 972 * Reads the data from the internal buffer. 973 * 974 * Return: The size of read data, or a negative error code on failure. 975 */ 976int snd_rawmidi_receive(struct snd_rawmidi_substream *substream, 977 const unsigned char *buffer, int count) 978{ 979 unsigned long flags; 980 int result = 0, count1; 981 struct snd_rawmidi_runtime *runtime = substream->runtime; 982 983 if (!substream->opened) 984 return -EBADFD; 985 if (runtime->buffer == NULL) { 986 rmidi_dbg(substream->rmidi, 987 "snd_rawmidi_receive: input is not active!!!\n"); 988 return -EINVAL; 989 } 990 spin_lock_irqsave(&runtime->lock, flags); 991 if (count == 1) { /* special case, faster code */ 992 substream->bytes++; 993 if (runtime->avail < runtime->buffer_size) { 994 runtime->buffer[runtime->hw_ptr++] = buffer[0]; 995 runtime->hw_ptr %= runtime->buffer_size; 996 runtime->avail++; 997 result++; 998 } else { 999 runtime->xruns++; 1000 } 1001 } else { 1002 substream->bytes += count; 1003 count1 = runtime->buffer_size - runtime->hw_ptr; 1004 if (count1 > count) 1005 count1 = count; 1006 if (count1 > (int)(runtime->buffer_size - runtime->avail)) 1007 count1 = runtime->buffer_size - runtime->avail; 1008 memcpy(runtime->buffer + runtime->hw_ptr, buffer, count1); 1009 runtime->hw_ptr += count1; 1010 runtime->hw_ptr %= runtime->buffer_size; 1011 runtime->avail += count1; 1012 count -= count1; 1013 result += count1; 1014 if (count > 0) { 1015 buffer += count1; 1016 count1 = count; 1017 if (count1 > (int)(runtime->buffer_size - runtime->avail)) { 1018 count1 = runtime->buffer_size - runtime->avail; 1019 runtime->xruns += count - count1; 1020 } 1021 if (count1 > 0) { 1022 memcpy(runtime->buffer, buffer, count1); 1023 runtime->hw_ptr = count1; 1024 runtime->avail += count1; 1025 result += count1; 1026 } 1027 } 1028 } 1029 if (result > 0) { 1030 if (runtime->event) 1031 schedule_work(&runtime->event_work); 1032 else if (__snd_rawmidi_ready(runtime)) 1033 wake_up(&runtime->sleep); 1034 } 1035 spin_unlock_irqrestore(&runtime->lock, flags); 1036 return result; 1037} 1038EXPORT_SYMBOL(snd_rawmidi_receive); 1039 1040static long snd_rawmidi_kernel_read1(struct snd_rawmidi_substream *substream, 1041 unsigned char __user *userbuf, 1042 unsigned char *kernelbuf, long count) 1043{ 1044 unsigned long flags; 1045 long result = 0, count1; 1046 struct snd_rawmidi_runtime *runtime = substream->runtime; 1047 unsigned long appl_ptr; 1048 int err = 0; 1049 1050 spin_lock_irqsave(&runtime->lock, flags); 1051 snd_rawmidi_buffer_ref(runtime); 1052 while (count > 0 && runtime->avail) { 1053 count1 = runtime->buffer_size - runtime->appl_ptr; 1054 if (count1 > count) 1055 count1 = count; 1056 if (count1 > (int)runtime->avail) 1057 count1 = runtime->avail; 1058 1059 /* update runtime->appl_ptr before unlocking for userbuf */ 1060 appl_ptr = runtime->appl_ptr; 1061 runtime->appl_ptr += count1; 1062 runtime->appl_ptr %= runtime->buffer_size; 1063 runtime->avail -= count1; 1064 1065 if (kernelbuf) 1066 memcpy(kernelbuf + result, runtime->buffer + appl_ptr, count1); 1067 if (userbuf) { 1068 spin_unlock_irqrestore(&runtime->lock, flags); 1069 if (copy_to_user(userbuf + result, 1070 runtime->buffer + appl_ptr, count1)) 1071 err = -EFAULT; 1072 spin_lock_irqsave(&runtime->lock, flags); 1073 if (err) 1074 goto out; 1075 } 1076 result += count1; 1077 count -= count1; 1078 } 1079 out: 1080 snd_rawmidi_buffer_unref(runtime); 1081 spin_unlock_irqrestore(&runtime->lock, flags); 1082 return result > 0 ? result : err; 1083} 1084 1085long snd_rawmidi_kernel_read(struct snd_rawmidi_substream *substream, 1086 unsigned char *buf, long count) 1087{ 1088 snd_rawmidi_input_trigger(substream, 1); 1089 return snd_rawmidi_kernel_read1(substream, NULL/*userbuf*/, buf, count); 1090} 1091EXPORT_SYMBOL(snd_rawmidi_kernel_read); 1092 1093static ssize_t snd_rawmidi_read(struct file *file, char __user *buf, size_t count, 1094 loff_t *offset) 1095{ 1096 long result; 1097 int count1; 1098 struct snd_rawmidi_file *rfile; 1099 struct snd_rawmidi_substream *substream; 1100 struct snd_rawmidi_runtime *runtime; 1101 1102 rfile = file->private_data; 1103 substream = rfile->input; 1104 if (substream == NULL) 1105 return -EIO; 1106 runtime = substream->runtime; 1107 snd_rawmidi_input_trigger(substream, 1); 1108 result = 0; 1109 while (count > 0) { 1110 spin_lock_irq(&runtime->lock); 1111 while (!__snd_rawmidi_ready(runtime)) { 1112 wait_queue_entry_t wait; 1113 1114 if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) { 1115 spin_unlock_irq(&runtime->lock); 1116 return result > 0 ? result : -EAGAIN; 1117 } 1118 init_waitqueue_entry(&wait, current); 1119 add_wait_queue(&runtime->sleep, &wait); 1120 set_current_state(TASK_INTERRUPTIBLE); 1121 spin_unlock_irq(&runtime->lock); 1122 schedule(); 1123 remove_wait_queue(&runtime->sleep, &wait); 1124 if (rfile->rmidi->card->shutdown) 1125 return -ENODEV; 1126 if (signal_pending(current)) 1127 return result > 0 ? result : -ERESTARTSYS; 1128 spin_lock_irq(&runtime->lock); 1129 if (!runtime->avail) { 1130 spin_unlock_irq(&runtime->lock); 1131 return result > 0 ? result : -EIO; 1132 } 1133 } 1134 spin_unlock_irq(&runtime->lock); 1135 count1 = snd_rawmidi_kernel_read1(substream, 1136 (unsigned char __user *)buf, 1137 NULL/*kernelbuf*/, 1138 count); 1139 if (count1 < 0) 1140 return result > 0 ? result : count1; 1141 result += count1; 1142 buf += count1; 1143 count -= count1; 1144 } 1145 return result; 1146} 1147 1148/** 1149 * snd_rawmidi_transmit_empty - check whether the output buffer is empty 1150 * @substream: the rawmidi substream 1151 * 1152 * Return: 1 if the internal output buffer is empty, 0 if not. 1153 */ 1154int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream *substream) 1155{ 1156 struct snd_rawmidi_runtime *runtime = substream->runtime; 1157 int result; 1158 unsigned long flags; 1159 1160 if (runtime->buffer == NULL) { 1161 rmidi_dbg(substream->rmidi, 1162 "snd_rawmidi_transmit_empty: output is not active!!!\n"); 1163 return 1; 1164 } 1165 spin_lock_irqsave(&runtime->lock, flags); 1166 result = runtime->avail >= runtime->buffer_size; 1167 spin_unlock_irqrestore(&runtime->lock, flags); 1168 return result; 1169} 1170EXPORT_SYMBOL(snd_rawmidi_transmit_empty); 1171 1172/** 1173 * __snd_rawmidi_transmit_peek - copy data from the internal buffer 1174 * @substream: the rawmidi substream 1175 * @buffer: the buffer pointer 1176 * @count: data size to transfer 1177 * 1178 * This is a variant of snd_rawmidi_transmit_peek() without spinlock. 1179 */ 1180int __snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream, 1181 unsigned char *buffer, int count) 1182{ 1183 int result, count1; 1184 struct snd_rawmidi_runtime *runtime = substream->runtime; 1185 1186 if (runtime->buffer == NULL) { 1187 rmidi_dbg(substream->rmidi, 1188 "snd_rawmidi_transmit_peek: output is not active!!!\n"); 1189 return -EINVAL; 1190 } 1191 result = 0; 1192 if (runtime->avail >= runtime->buffer_size) { 1193 /* warning: lowlevel layer MUST trigger down the hardware */ 1194 goto __skip; 1195 } 1196 if (count == 1) { /* special case, faster code */ 1197 *buffer = runtime->buffer[runtime->hw_ptr]; 1198 result++; 1199 } else { 1200 count1 = runtime->buffer_size - runtime->hw_ptr; 1201 if (count1 > count) 1202 count1 = count; 1203 if (count1 > (int)(runtime->buffer_size - runtime->avail)) 1204 count1 = runtime->buffer_size - runtime->avail; 1205 memcpy(buffer, runtime->buffer + runtime->hw_ptr, count1); 1206 count -= count1; 1207 result += count1; 1208 if (count > 0) { 1209 if (count > (int)(runtime->buffer_size - runtime->avail - count1)) 1210 count = runtime->buffer_size - runtime->avail - count1; 1211 memcpy(buffer + count1, runtime->buffer, count); 1212 result += count; 1213 } 1214 } 1215 __skip: 1216 return result; 1217} 1218EXPORT_SYMBOL(__snd_rawmidi_transmit_peek); 1219 1220/** 1221 * snd_rawmidi_transmit_peek - copy data from the internal buffer 1222 * @substream: the rawmidi substream 1223 * @buffer: the buffer pointer 1224 * @count: data size to transfer 1225 * 1226 * Copies data from the internal output buffer to the given buffer. 1227 * 1228 * Call this in the interrupt handler when the midi output is ready, 1229 * and call snd_rawmidi_transmit_ack() after the transmission is 1230 * finished. 1231 * 1232 * Return: The size of copied data, or a negative error code on failure. 1233 */ 1234int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream, 1235 unsigned char *buffer, int count) 1236{ 1237 struct snd_rawmidi_runtime *runtime = substream->runtime; 1238 int result; 1239 unsigned long flags; 1240 1241 spin_lock_irqsave(&runtime->lock, flags); 1242 result = __snd_rawmidi_transmit_peek(substream, buffer, count); 1243 spin_unlock_irqrestore(&runtime->lock, flags); 1244 return result; 1245} 1246EXPORT_SYMBOL(snd_rawmidi_transmit_peek); 1247 1248/** 1249 * __snd_rawmidi_transmit_ack - acknowledge the transmission 1250 * @substream: the rawmidi substream 1251 * @count: the transferred count 1252 * 1253 * This is a variant of __snd_rawmidi_transmit_ack() without spinlock. 1254 */ 1255int __snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count) 1256{ 1257 struct snd_rawmidi_runtime *runtime = substream->runtime; 1258 1259 if (runtime->buffer == NULL) { 1260 rmidi_dbg(substream->rmidi, 1261 "snd_rawmidi_transmit_ack: output is not active!!!\n"); 1262 return -EINVAL; 1263 } 1264 snd_BUG_ON(runtime->avail + count > runtime->buffer_size); 1265 runtime->hw_ptr += count; 1266 runtime->hw_ptr %= runtime->buffer_size; 1267 runtime->avail += count; 1268 substream->bytes += count; 1269 if (count > 0) { 1270 if (runtime->drain || __snd_rawmidi_ready(runtime)) 1271 wake_up(&runtime->sleep); 1272 } 1273 return count; 1274} 1275EXPORT_SYMBOL(__snd_rawmidi_transmit_ack); 1276 1277/** 1278 * snd_rawmidi_transmit_ack - acknowledge the transmission 1279 * @substream: the rawmidi substream 1280 * @count: the transferred count 1281 * 1282 * Advances the hardware pointer for the internal output buffer with 1283 * the given size and updates the condition. 1284 * Call after the transmission is finished. 1285 * 1286 * Return: The advanced size if successful, or a negative error code on failure. 1287 */ 1288int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count) 1289{ 1290 struct snd_rawmidi_runtime *runtime = substream->runtime; 1291 int result; 1292 unsigned long flags; 1293 1294 spin_lock_irqsave(&runtime->lock, flags); 1295 result = __snd_rawmidi_transmit_ack(substream, count); 1296 spin_unlock_irqrestore(&runtime->lock, flags); 1297 return result; 1298} 1299EXPORT_SYMBOL(snd_rawmidi_transmit_ack); 1300 1301/** 1302 * snd_rawmidi_transmit - copy from the buffer to the device 1303 * @substream: the rawmidi substream 1304 * @buffer: the buffer pointer 1305 * @count: the data size to transfer 1306 * 1307 * Copies data from the buffer to the device and advances the pointer. 1308 * 1309 * Return: The copied size if successful, or a negative error code on failure. 1310 */ 1311int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream, 1312 unsigned char *buffer, int count) 1313{ 1314 struct snd_rawmidi_runtime *runtime = substream->runtime; 1315 int result; 1316 unsigned long flags; 1317 1318 spin_lock_irqsave(&runtime->lock, flags); 1319 if (!substream->opened) 1320 result = -EBADFD; 1321 else { 1322 count = __snd_rawmidi_transmit_peek(substream, buffer, count); 1323 if (count <= 0) 1324 result = count; 1325 else 1326 result = __snd_rawmidi_transmit_ack(substream, count); 1327 } 1328 spin_unlock_irqrestore(&runtime->lock, flags); 1329 return result; 1330} 1331EXPORT_SYMBOL(snd_rawmidi_transmit); 1332 1333/** 1334 * snd_rawmidi_proceed - Discard the all pending bytes and proceed 1335 * @substream: rawmidi substream 1336 * 1337 * Return: the number of discarded bytes 1338 */ 1339int snd_rawmidi_proceed(struct snd_rawmidi_substream *substream) 1340{ 1341 struct snd_rawmidi_runtime *runtime = substream->runtime; 1342 unsigned long flags; 1343 int count = 0; 1344 1345 spin_lock_irqsave(&runtime->lock, flags); 1346 if (runtime->avail < runtime->buffer_size) { 1347 count = runtime->buffer_size - runtime->avail; 1348 __snd_rawmidi_transmit_ack(substream, count); 1349 } 1350 spin_unlock_irqrestore(&runtime->lock, flags); 1351 return count; 1352} 1353EXPORT_SYMBOL(snd_rawmidi_proceed); 1354 1355static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream, 1356 const unsigned char __user *userbuf, 1357 const unsigned char *kernelbuf, 1358 long count) 1359{ 1360 unsigned long flags; 1361 long count1, result; 1362 struct snd_rawmidi_runtime *runtime = substream->runtime; 1363 unsigned long appl_ptr; 1364 1365 if (!kernelbuf && !userbuf) 1366 return -EINVAL; 1367 if (snd_BUG_ON(!runtime->buffer)) 1368 return -EINVAL; 1369 1370 result = 0; 1371 spin_lock_irqsave(&runtime->lock, flags); 1372 if (substream->append) { 1373 if ((long)runtime->avail < count) { 1374 spin_unlock_irqrestore(&runtime->lock, flags); 1375 return -EAGAIN; 1376 } 1377 } 1378 snd_rawmidi_buffer_ref(runtime); 1379 while (count > 0 && runtime->avail > 0) { 1380 count1 = runtime->buffer_size - runtime->appl_ptr; 1381 if (count1 > count) 1382 count1 = count; 1383 if (count1 > (long)runtime->avail) 1384 count1 = runtime->avail; 1385 1386 /* update runtime->appl_ptr before unlocking for userbuf */ 1387 appl_ptr = runtime->appl_ptr; 1388 runtime->appl_ptr += count1; 1389 runtime->appl_ptr %= runtime->buffer_size; 1390 runtime->avail -= count1; 1391 1392 if (kernelbuf) 1393 memcpy(runtime->buffer + appl_ptr, 1394 kernelbuf + result, count1); 1395 else if (userbuf) { 1396 spin_unlock_irqrestore(&runtime->lock, flags); 1397 if (copy_from_user(runtime->buffer + appl_ptr, 1398 userbuf + result, count1)) { 1399 spin_lock_irqsave(&runtime->lock, flags); 1400 result = result > 0 ? result : -EFAULT; 1401 goto __end; 1402 } 1403 spin_lock_irqsave(&runtime->lock, flags); 1404 } 1405 result += count1; 1406 count -= count1; 1407 } 1408 __end: 1409 count1 = runtime->avail < runtime->buffer_size; 1410 snd_rawmidi_buffer_unref(runtime); 1411 spin_unlock_irqrestore(&runtime->lock, flags); 1412 if (count1) 1413 snd_rawmidi_output_trigger(substream, 1); 1414 return result; 1415} 1416 1417long snd_rawmidi_kernel_write(struct snd_rawmidi_substream *substream, 1418 const unsigned char *buf, long count) 1419{ 1420 return snd_rawmidi_kernel_write1(substream, NULL, buf, count); 1421} 1422EXPORT_SYMBOL(snd_rawmidi_kernel_write); 1423 1424static ssize_t snd_rawmidi_write(struct file *file, const char __user *buf, 1425 size_t count, loff_t *offset) 1426{ 1427 long result, timeout; 1428 int count1; 1429 struct snd_rawmidi_file *rfile; 1430 struct snd_rawmidi_runtime *runtime; 1431 struct snd_rawmidi_substream *substream; 1432 1433 rfile = file->private_data; 1434 substream = rfile->output; 1435 runtime = substream->runtime; 1436 /* we cannot put an atomic message to our buffer */ 1437 if (substream->append && count > runtime->buffer_size) 1438 return -EIO; 1439 result = 0; 1440 while (count > 0) { 1441 spin_lock_irq(&runtime->lock); 1442 while (!snd_rawmidi_ready_append(substream, count)) { 1443 wait_queue_entry_t wait; 1444 1445 if (file->f_flags & O_NONBLOCK) { 1446 spin_unlock_irq(&runtime->lock); 1447 return result > 0 ? result : -EAGAIN; 1448 } 1449 init_waitqueue_entry(&wait, current); 1450 add_wait_queue(&runtime->sleep, &wait); 1451 set_current_state(TASK_INTERRUPTIBLE); 1452 spin_unlock_irq(&runtime->lock); 1453 timeout = schedule_timeout(30 * HZ); 1454 remove_wait_queue(&runtime->sleep, &wait); 1455 if (rfile->rmidi->card->shutdown) 1456 return -ENODEV; 1457 if (signal_pending(current)) 1458 return result > 0 ? result : -ERESTARTSYS; 1459 spin_lock_irq(&runtime->lock); 1460 if (!runtime->avail && !timeout) { 1461 spin_unlock_irq(&runtime->lock); 1462 return result > 0 ? result : -EIO; 1463 } 1464 } 1465 spin_unlock_irq(&runtime->lock); 1466 count1 = snd_rawmidi_kernel_write1(substream, buf, NULL, count); 1467 if (count1 < 0) 1468 return result > 0 ? result : count1; 1469 result += count1; 1470 buf += count1; 1471 if ((size_t)count1 < count && (file->f_flags & O_NONBLOCK)) 1472 break; 1473 count -= count1; 1474 } 1475 if (file->f_flags & O_DSYNC) { 1476 spin_lock_irq(&runtime->lock); 1477 while (runtime->avail != runtime->buffer_size) { 1478 wait_queue_entry_t wait; 1479 unsigned int last_avail = runtime->avail; 1480 1481 init_waitqueue_entry(&wait, current); 1482 add_wait_queue(&runtime->sleep, &wait); 1483 set_current_state(TASK_INTERRUPTIBLE); 1484 spin_unlock_irq(&runtime->lock); 1485 timeout = schedule_timeout(30 * HZ); 1486 remove_wait_queue(&runtime->sleep, &wait); 1487 if (signal_pending(current)) 1488 return result > 0 ? result : -ERESTARTSYS; 1489 if (runtime->avail == last_avail && !timeout) 1490 return result > 0 ? result : -EIO; 1491 spin_lock_irq(&runtime->lock); 1492 } 1493 spin_unlock_irq(&runtime->lock); 1494 } 1495 return result; 1496} 1497 1498static __poll_t snd_rawmidi_poll(struct file *file, poll_table *wait) 1499{ 1500 struct snd_rawmidi_file *rfile; 1501 struct snd_rawmidi_runtime *runtime; 1502 __poll_t mask; 1503 1504 rfile = file->private_data; 1505 if (rfile->input != NULL) { 1506 runtime = rfile->input->runtime; 1507 snd_rawmidi_input_trigger(rfile->input, 1); 1508 poll_wait(file, &runtime->sleep, wait); 1509 } 1510 if (rfile->output != NULL) { 1511 runtime = rfile->output->runtime; 1512 poll_wait(file, &runtime->sleep, wait); 1513 } 1514 mask = 0; 1515 if (rfile->input != NULL) { 1516 if (snd_rawmidi_ready(rfile->input)) 1517 mask |= EPOLLIN | EPOLLRDNORM; 1518 } 1519 if (rfile->output != NULL) { 1520 if (snd_rawmidi_ready(rfile->output)) 1521 mask |= EPOLLOUT | EPOLLWRNORM; 1522 } 1523 return mask; 1524} 1525 1526/* 1527 */ 1528#ifdef CONFIG_COMPAT 1529#include "rawmidi_compat.c" 1530#else 1531#define snd_rawmidi_ioctl_compat NULL 1532#endif 1533 1534/* 1535 */ 1536 1537static void snd_rawmidi_proc_info_read(struct snd_info_entry *entry, 1538 struct snd_info_buffer *buffer) 1539{ 1540 struct snd_rawmidi *rmidi; 1541 struct snd_rawmidi_substream *substream; 1542 struct snd_rawmidi_runtime *runtime; 1543 unsigned long buffer_size, avail, xruns; 1544 1545 rmidi = entry->private_data; 1546 snd_iprintf(buffer, "%s\n\n", rmidi->name); 1547 mutex_lock(&rmidi->open_mutex); 1548 if (rmidi->info_flags & SNDRV_RAWMIDI_INFO_OUTPUT) { 1549 list_for_each_entry(substream, 1550 &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams, 1551 list) { 1552 snd_iprintf(buffer, 1553 "Output %d\n" 1554 " Tx bytes : %lu\n", 1555 substream->number, 1556 (unsigned long) substream->bytes); 1557 if (substream->opened) { 1558 snd_iprintf(buffer, 1559 " Owner PID : %d\n", 1560 pid_vnr(substream->pid)); 1561 runtime = substream->runtime; 1562 spin_lock_irq(&runtime->lock); 1563 buffer_size = runtime->buffer_size; 1564 avail = runtime->avail; 1565 spin_unlock_irq(&runtime->lock); 1566 snd_iprintf(buffer, 1567 " Mode : %s\n" 1568 " Buffer size : %lu\n" 1569 " Avail : %lu\n", 1570 runtime->oss ? "OSS compatible" : "native", 1571 buffer_size, avail); 1572 } 1573 } 1574 } 1575 if (rmidi->info_flags & SNDRV_RAWMIDI_INFO_INPUT) { 1576 list_for_each_entry(substream, 1577 &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams, 1578 list) { 1579 snd_iprintf(buffer, 1580 "Input %d\n" 1581 " Rx bytes : %lu\n", 1582 substream->number, 1583 (unsigned long) substream->bytes); 1584 if (substream->opened) { 1585 snd_iprintf(buffer, 1586 " Owner PID : %d\n", 1587 pid_vnr(substream->pid)); 1588 runtime = substream->runtime; 1589 spin_lock_irq(&runtime->lock); 1590 buffer_size = runtime->buffer_size; 1591 avail = runtime->avail; 1592 xruns = runtime->xruns; 1593 spin_unlock_irq(&runtime->lock); 1594 snd_iprintf(buffer, 1595 " Buffer size : %lu\n" 1596 " Avail : %lu\n" 1597 " Overruns : %lu\n", 1598 buffer_size, avail, xruns); 1599 } 1600 } 1601 } 1602 mutex_unlock(&rmidi->open_mutex); 1603} 1604 1605/* 1606 * Register functions 1607 */ 1608 1609static const struct file_operations snd_rawmidi_f_ops = { 1610 .owner = THIS_MODULE, 1611 .read = snd_rawmidi_read, 1612 .write = snd_rawmidi_write, 1613 .open = snd_rawmidi_open, 1614 .release = snd_rawmidi_release, 1615 .llseek = no_llseek, 1616 .poll = snd_rawmidi_poll, 1617 .unlocked_ioctl = snd_rawmidi_ioctl, 1618 .compat_ioctl = snd_rawmidi_ioctl_compat, 1619}; 1620 1621static int snd_rawmidi_alloc_substreams(struct snd_rawmidi *rmidi, 1622 struct snd_rawmidi_str *stream, 1623 int direction, 1624 int count) 1625{ 1626 struct snd_rawmidi_substream *substream; 1627 int idx; 1628 1629 for (idx = 0; idx < count; idx++) { 1630 substream = kzalloc(sizeof(*substream), GFP_KERNEL); 1631 if (!substream) 1632 return -ENOMEM; 1633 substream->stream = direction; 1634 substream->number = idx; 1635 substream->rmidi = rmidi; 1636 substream->pstr = stream; 1637 list_add_tail(&substream->list, &stream->substreams); 1638 stream->substream_count++; 1639 } 1640 return 0; 1641} 1642 1643static void release_rawmidi_device(struct device *dev) 1644{ 1645 kfree(container_of(dev, struct snd_rawmidi, dev)); 1646} 1647 1648/** 1649 * snd_rawmidi_new - create a rawmidi instance 1650 * @card: the card instance 1651 * @id: the id string 1652 * @device: the device index 1653 * @output_count: the number of output streams 1654 * @input_count: the number of input streams 1655 * @rrawmidi: the pointer to store the new rawmidi instance 1656 * 1657 * Creates a new rawmidi instance. 1658 * Use snd_rawmidi_set_ops() to set the operators to the new instance. 1659 * 1660 * Return: Zero if successful, or a negative error code on failure. 1661 */ 1662int snd_rawmidi_new(struct snd_card *card, char *id, int device, 1663 int output_count, int input_count, 1664 struct snd_rawmidi **rrawmidi) 1665{ 1666 struct snd_rawmidi *rmidi; 1667 int err; 1668 static const struct snd_device_ops ops = { 1669 .dev_free = snd_rawmidi_dev_free, 1670 .dev_register = snd_rawmidi_dev_register, 1671 .dev_disconnect = snd_rawmidi_dev_disconnect, 1672 }; 1673 1674 if (snd_BUG_ON(!card)) 1675 return -ENXIO; 1676 if (rrawmidi) 1677 *rrawmidi = NULL; 1678 rmidi = kzalloc(sizeof(*rmidi), GFP_KERNEL); 1679 if (!rmidi) 1680 return -ENOMEM; 1681 rmidi->card = card; 1682 rmidi->device = device; 1683 mutex_init(&rmidi->open_mutex); 1684 init_waitqueue_head(&rmidi->open_wait); 1685 INIT_LIST_HEAD(&rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams); 1686 INIT_LIST_HEAD(&rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams); 1687 1688 if (id != NULL) 1689 strlcpy(rmidi->id, id, sizeof(rmidi->id)); 1690 1691 snd_device_initialize(&rmidi->dev, card); 1692 rmidi->dev.release = release_rawmidi_device; 1693 dev_set_name(&rmidi->dev, "midiC%iD%i", card->number, device); 1694 1695 err = snd_rawmidi_alloc_substreams(rmidi, 1696 &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT], 1697 SNDRV_RAWMIDI_STREAM_INPUT, 1698 input_count); 1699 if (err < 0) 1700 goto error; 1701 err = snd_rawmidi_alloc_substreams(rmidi, 1702 &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT], 1703 SNDRV_RAWMIDI_STREAM_OUTPUT, 1704 output_count); 1705 if (err < 0) 1706 goto error; 1707 err = snd_device_new(card, SNDRV_DEV_RAWMIDI, rmidi, &ops); 1708 if (err < 0) 1709 goto error; 1710 1711 if (rrawmidi) 1712 *rrawmidi = rmidi; 1713 return 0; 1714 1715 error: 1716 snd_rawmidi_free(rmidi); 1717 return err; 1718} 1719EXPORT_SYMBOL(snd_rawmidi_new); 1720 1721static void snd_rawmidi_free_substreams(struct snd_rawmidi_str *stream) 1722{ 1723 struct snd_rawmidi_substream *substream; 1724 1725 while (!list_empty(&stream->substreams)) { 1726 substream = list_entry(stream->substreams.next, struct snd_rawmidi_substream, list); 1727 list_del(&substream->list); 1728 kfree(substream); 1729 } 1730} 1731 1732static int snd_rawmidi_free(struct snd_rawmidi *rmidi) 1733{ 1734 if (!rmidi) 1735 return 0; 1736 1737 snd_info_free_entry(rmidi->proc_entry); 1738 rmidi->proc_entry = NULL; 1739 if (rmidi->ops && rmidi->ops->dev_unregister) 1740 rmidi->ops->dev_unregister(rmidi); 1741 1742 snd_rawmidi_free_substreams(&rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT]); 1743 snd_rawmidi_free_substreams(&rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT]); 1744 if (rmidi->private_free) 1745 rmidi->private_free(rmidi); 1746 put_device(&rmidi->dev); 1747 return 0; 1748} 1749 1750static int snd_rawmidi_dev_free(struct snd_device *device) 1751{ 1752 struct snd_rawmidi *rmidi = device->device_data; 1753 1754 return snd_rawmidi_free(rmidi); 1755} 1756 1757#if IS_ENABLED(CONFIG_SND_SEQUENCER) 1758static void snd_rawmidi_dev_seq_free(struct snd_seq_device *device) 1759{ 1760 struct snd_rawmidi *rmidi = device->private_data; 1761 1762 rmidi->seq_dev = NULL; 1763} 1764#endif 1765 1766static int snd_rawmidi_dev_register(struct snd_device *device) 1767{ 1768 int err; 1769 struct snd_info_entry *entry; 1770 char name[16]; 1771 struct snd_rawmidi *rmidi = device->device_data; 1772 1773 if (rmidi->device >= SNDRV_RAWMIDI_DEVICES) 1774 return -ENOMEM; 1775 err = 0; 1776 mutex_lock(®ister_mutex); 1777 if (snd_rawmidi_search(rmidi->card, rmidi->device)) 1778 err = -EBUSY; 1779 else 1780 list_add_tail(&rmidi->list, &snd_rawmidi_devices); 1781 mutex_unlock(®ister_mutex); 1782 if (err < 0) 1783 return err; 1784 1785 err = snd_register_device(SNDRV_DEVICE_TYPE_RAWMIDI, 1786 rmidi->card, rmidi->device, 1787 &snd_rawmidi_f_ops, rmidi, &rmidi->dev); 1788 if (err < 0) { 1789 rmidi_err(rmidi, "unable to register\n"); 1790 goto error; 1791 } 1792 if (rmidi->ops && rmidi->ops->dev_register) { 1793 err = rmidi->ops->dev_register(rmidi); 1794 if (err < 0) 1795 goto error_unregister; 1796 } 1797#ifdef CONFIG_SND_OSSEMUL 1798 rmidi->ossreg = 0; 1799 if ((int)rmidi->device == midi_map[rmidi->card->number]) { 1800 if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, 1801 rmidi->card, 0, &snd_rawmidi_f_ops, 1802 rmidi) < 0) { 1803 rmidi_err(rmidi, 1804 "unable to register OSS rawmidi device %i:%i\n", 1805 rmidi->card->number, 0); 1806 } else { 1807 rmidi->ossreg++; 1808#ifdef SNDRV_OSS_INFO_DEV_MIDI 1809 snd_oss_info_register(SNDRV_OSS_INFO_DEV_MIDI, rmidi->card->number, rmidi->name); 1810#endif 1811 } 1812 } 1813 if ((int)rmidi->device == amidi_map[rmidi->card->number]) { 1814 if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, 1815 rmidi->card, 1, &snd_rawmidi_f_ops, 1816 rmidi) < 0) { 1817 rmidi_err(rmidi, 1818 "unable to register OSS rawmidi device %i:%i\n", 1819 rmidi->card->number, 1); 1820 } else { 1821 rmidi->ossreg++; 1822 } 1823 } 1824#endif /* CONFIG_SND_OSSEMUL */ 1825 sprintf(name, "midi%d", rmidi->device); 1826 entry = snd_info_create_card_entry(rmidi->card, name, rmidi->card->proc_root); 1827 if (entry) { 1828 entry->private_data = rmidi; 1829 entry->c.text.read = snd_rawmidi_proc_info_read; 1830 if (snd_info_register(entry) < 0) { 1831 snd_info_free_entry(entry); 1832 entry = NULL; 1833 } 1834 } 1835 rmidi->proc_entry = entry; 1836#if IS_ENABLED(CONFIG_SND_SEQUENCER) 1837 if (!rmidi->ops || !rmidi->ops->dev_register) { /* own registration mechanism */ 1838 if (snd_seq_device_new(rmidi->card, rmidi->device, SNDRV_SEQ_DEV_ID_MIDISYNTH, 0, &rmidi->seq_dev) >= 0) { 1839 rmidi->seq_dev->private_data = rmidi; 1840 rmidi->seq_dev->private_free = snd_rawmidi_dev_seq_free; 1841 sprintf(rmidi->seq_dev->name, "MIDI %d-%d", rmidi->card->number, rmidi->device); 1842 snd_device_register(rmidi->card, rmidi->seq_dev); 1843 } 1844 } 1845#endif 1846 return 0; 1847 1848 error_unregister: 1849 snd_unregister_device(&rmidi->dev); 1850 error: 1851 mutex_lock(®ister_mutex); 1852 list_del(&rmidi->list); 1853 mutex_unlock(®ister_mutex); 1854 return err; 1855} 1856 1857static int snd_rawmidi_dev_disconnect(struct snd_device *device) 1858{ 1859 struct snd_rawmidi *rmidi = device->device_data; 1860 int dir; 1861 1862 mutex_lock(®ister_mutex); 1863 mutex_lock(&rmidi->open_mutex); 1864 wake_up(&rmidi->open_wait); 1865 list_del_init(&rmidi->list); 1866 for (dir = 0; dir < 2; dir++) { 1867 struct snd_rawmidi_substream *s; 1868 1869 list_for_each_entry(s, &rmidi->streams[dir].substreams, list) { 1870 if (s->runtime) 1871 wake_up(&s->runtime->sleep); 1872 } 1873 } 1874 1875#ifdef CONFIG_SND_OSSEMUL 1876 if (rmidi->ossreg) { 1877 if ((int)rmidi->device == midi_map[rmidi->card->number]) { 1878 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, rmidi->card, 0); 1879#ifdef SNDRV_OSS_INFO_DEV_MIDI 1880 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_MIDI, rmidi->card->number); 1881#endif 1882 } 1883 if ((int)rmidi->device == amidi_map[rmidi->card->number]) 1884 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, rmidi->card, 1); 1885 rmidi->ossreg = 0; 1886 } 1887#endif /* CONFIG_SND_OSSEMUL */ 1888 snd_unregister_device(&rmidi->dev); 1889 mutex_unlock(&rmidi->open_mutex); 1890 mutex_unlock(®ister_mutex); 1891 return 0; 1892} 1893 1894/** 1895 * snd_rawmidi_set_ops - set the rawmidi operators 1896 * @rmidi: the rawmidi instance 1897 * @stream: the stream direction, SNDRV_RAWMIDI_STREAM_XXX 1898 * @ops: the operator table 1899 * 1900 * Sets the rawmidi operators for the given stream direction. 1901 */ 1902void snd_rawmidi_set_ops(struct snd_rawmidi *rmidi, int stream, 1903 const struct snd_rawmidi_ops *ops) 1904{ 1905 struct snd_rawmidi_substream *substream; 1906 1907 list_for_each_entry(substream, &rmidi->streams[stream].substreams, list) 1908 substream->ops = ops; 1909} 1910EXPORT_SYMBOL(snd_rawmidi_set_ops); 1911 1912/* 1913 * ENTRY functions 1914 */ 1915 1916static int __init alsa_rawmidi_init(void) 1917{ 1918 1919 snd_ctl_register_ioctl(snd_rawmidi_control_ioctl); 1920 snd_ctl_register_ioctl_compat(snd_rawmidi_control_ioctl); 1921#ifdef CONFIG_SND_OSSEMUL 1922 { int i; 1923 /* check device map table */ 1924 for (i = 0; i < SNDRV_CARDS; i++) { 1925 if (midi_map[i] < 0 || midi_map[i] >= SNDRV_RAWMIDI_DEVICES) { 1926 pr_err("ALSA: rawmidi: invalid midi_map[%d] = %d\n", 1927 i, midi_map[i]); 1928 midi_map[i] = 0; 1929 } 1930 if (amidi_map[i] < 0 || amidi_map[i] >= SNDRV_RAWMIDI_DEVICES) { 1931 pr_err("ALSA: rawmidi: invalid amidi_map[%d] = %d\n", 1932 i, amidi_map[i]); 1933 amidi_map[i] = 1; 1934 } 1935 } 1936 } 1937#endif /* CONFIG_SND_OSSEMUL */ 1938 return 0; 1939} 1940 1941static void __exit alsa_rawmidi_exit(void) 1942{ 1943 snd_ctl_unregister_ioctl(snd_rawmidi_control_ioctl); 1944 snd_ctl_unregister_ioctl_compat(snd_rawmidi_control_ioctl); 1945} 1946 1947module_init(alsa_rawmidi_init) 1948module_exit(alsa_rawmidi_exit) 1949