sound/core/rawmidi.c

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