1 /* 2 * Abstract layer for MIDI v1.0 stream 3 * Copyright (c) by Jaroslav Kysela <perex@perex.cz> 4 * 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 * 20 */ 21 22 #include <sound/core.h> 23 #include <linux/major.h> 24 #include <linux/init.h> 25 #include <linux/sched.h> 26 #include <linux/slab.h> 27 #include <linux/time.h> 28 #include <linux/wait.h> 29 #include <linux/mutex.h> 30 #include <linux/moduleparam.h> 31 #include <linux/delay.h> 32 #include <sound/rawmidi.h> 33 #include <sound/info.h> 34 #include <sound/control.h> 35 #include <sound/minors.h> 36 #include <sound/initval.h> 37 38 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>"); 39 MODULE_DESCRIPTION("Midlevel RawMidi code for ALSA."); 40 MODULE_LICENSE("GPL"); 41 42 #ifdef CONFIG_SND_OSSEMUL 43 static int midi_map[SNDRV_CARDS]; 44 static int amidi_map[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = 1}; 45 module_param_array(midi_map, int, NULL, 0444); 46 MODULE_PARM_DESC(midi_map, "Raw MIDI device number assigned to 1st OSS device."); 47 module_param_array(amidi_map, int, NULL, 0444); 48 MODULE_PARM_DESC(amidi_map, "Raw MIDI device number assigned to 2nd OSS device."); 49 #endif /* CONFIG_SND_OSSEMUL */ 50 51 static int snd_rawmidi_free(struct snd_rawmidi *rawmidi); 52 static int snd_rawmidi_dev_free(struct snd_device *device); 53 static int snd_rawmidi_dev_register(struct snd_device *device); 54 static int snd_rawmidi_dev_disconnect(struct snd_device *device); 55 56 static LIST_HEAD(snd_rawmidi_devices); 57 static DEFINE_MUTEX(register_mutex); 58 59 static struct snd_rawmidi *snd_rawmidi_search(struct snd_card *card, int device) 60 { 61 struct snd_rawmidi *rawmidi; 62 63 list_for_each_entry(rawmidi, &snd_rawmidi_devices, list) 64 if (rawmidi->card == card && rawmidi->device == device) 65 return rawmidi; 66 return NULL; 67 } 68 69 static inline unsigned short snd_rawmidi_file_flags(struct file *file) 70 { 71 switch (file->f_mode & (FMODE_READ | FMODE_WRITE)) { 72 case FMODE_WRITE: 73 return SNDRV_RAWMIDI_LFLG_OUTPUT; 74 case FMODE_READ: 75 return SNDRV_RAWMIDI_LFLG_INPUT; 76 default: 77 return SNDRV_RAWMIDI_LFLG_OPEN; 78 } 79 } 80 81 static inline int snd_rawmidi_ready(struct snd_rawmidi_substream *substream) 82 { 83 struct snd_rawmidi_runtime *runtime = substream->runtime; 84 return runtime->avail >= runtime->avail_min; 85 } 86 87 static inline int snd_rawmidi_ready_append(struct snd_rawmidi_substream *substream, 88 size_t count) 89 { 90 struct snd_rawmidi_runtime *runtime = substream->runtime; 91 return runtime->avail >= runtime->avail_min && 92 (!substream->append || runtime->avail >= count); 93 } 94 95 static void snd_rawmidi_input_event_tasklet(unsigned long data) 96 { 97 struct snd_rawmidi_substream *substream = (struct snd_rawmidi_substream *)data; 98 substream->runtime->event(substream); 99 } 100 101 static void snd_rawmidi_output_trigger_tasklet(unsigned long data) 102 { 103 struct snd_rawmidi_substream *substream = (struct snd_rawmidi_substream *)data; 104 substream->ops->trigger(substream, 1); 105 } 106 107 static int snd_rawmidi_runtime_create(struct snd_rawmidi_substream *substream) 108 { 109 struct snd_rawmidi_runtime *runtime; 110 111 if ((runtime = kzalloc(sizeof(*runtime), GFP_KERNEL)) == NULL) 112 return -ENOMEM; 113 spin_lock_init(&runtime->lock); 114 init_waitqueue_head(&runtime->sleep); 115 if (substream->stream == SNDRV_RAWMIDI_STREAM_INPUT) 116 tasklet_init(&runtime->tasklet, 117 snd_rawmidi_input_event_tasklet, 118 (unsigned long)substream); 119 else 120 tasklet_init(&runtime->tasklet, 121 snd_rawmidi_output_trigger_tasklet, 122 (unsigned long)substream); 123 runtime->event = NULL; 124 runtime->buffer_size = PAGE_SIZE; 125 runtime->avail_min = 1; 126 if (substream->stream == SNDRV_RAWMIDI_STREAM_INPUT) 127 runtime->avail = 0; 128 else 129 runtime->avail = runtime->buffer_size; 130 if ((runtime->buffer = kmalloc(runtime->buffer_size, GFP_KERNEL)) == NULL) { 131 kfree(runtime); 132 return -ENOMEM; 133 } 134 runtime->appl_ptr = runtime->hw_ptr = 0; 135 substream->runtime = runtime; 136 return 0; 137 } 138 139 static int snd_rawmidi_runtime_free(struct snd_rawmidi_substream *substream) 140 { 141 struct snd_rawmidi_runtime *runtime = substream->runtime; 142 143 kfree(runtime->buffer); 144 kfree(runtime); 145 substream->runtime = NULL; 146 return 0; 147 } 148 149 static inline void snd_rawmidi_output_trigger(struct snd_rawmidi_substream *substream,int up) 150 { 151 if (up) { 152 tasklet_hi_schedule(&substream->runtime->tasklet); 153 } else { 154 tasklet_kill(&substream->runtime->tasklet); 155 substream->ops->trigger(substream, 0); 156 } 157 } 158 159 static void snd_rawmidi_input_trigger(struct snd_rawmidi_substream *substream, int up) 160 { 161 substream->ops->trigger(substream, up); 162 if (!up && substream->runtime->event) 163 tasklet_kill(&substream->runtime->tasklet); 164 } 165 166 int snd_rawmidi_drop_output(struct snd_rawmidi_substream *substream) 167 { 168 unsigned long flags; 169 struct snd_rawmidi_runtime *runtime = substream->runtime; 170 171 snd_rawmidi_output_trigger(substream, 0); 172 runtime->drain = 0; 173 spin_lock_irqsave(&runtime->lock, flags); 174 runtime->appl_ptr = runtime->hw_ptr = 0; 175 runtime->avail = runtime->buffer_size; 176 spin_unlock_irqrestore(&runtime->lock, flags); 177 return 0; 178 } 179 180 int snd_rawmidi_drain_output(struct snd_rawmidi_substream *substream) 181 { 182 int err; 183 long timeout; 184 struct snd_rawmidi_runtime *runtime = substream->runtime; 185 186 err = 0; 187 runtime->drain = 1; 188 timeout = wait_event_interruptible_timeout(runtime->sleep, 189 (runtime->avail >= runtime->buffer_size), 190 10*HZ); 191 if (signal_pending(current)) 192 err = -ERESTARTSYS; 193 if (runtime->avail < runtime->buffer_size && !timeout) { 194 snd_printk(KERN_WARNING "rawmidi drain error (avail = %li, buffer_size = %li)\n", (long)runtime->avail, (long)runtime->buffer_size); 195 err = -EIO; 196 } 197 runtime->drain = 0; 198 if (err != -ERESTARTSYS) { 199 /* we need wait a while to make sure that Tx FIFOs are empty */ 200 if (substream->ops->drain) 201 substream->ops->drain(substream); 202 else 203 msleep(50); 204 snd_rawmidi_drop_output(substream); 205 } 206 return err; 207 } 208 209 int snd_rawmidi_drain_input(struct snd_rawmidi_substream *substream) 210 { 211 unsigned long flags; 212 struct snd_rawmidi_runtime *runtime = substream->runtime; 213 214 snd_rawmidi_input_trigger(substream, 0); 215 runtime->drain = 0; 216 spin_lock_irqsave(&runtime->lock, flags); 217 runtime->appl_ptr = runtime->hw_ptr = 0; 218 runtime->avail = 0; 219 spin_unlock_irqrestore(&runtime->lock, flags); 220 return 0; 221 } 222 223 int snd_rawmidi_kernel_open(struct snd_card *card, int device, int subdevice, 224 int mode, struct snd_rawmidi_file * rfile) 225 { 226 struct snd_rawmidi *rmidi; 227 struct list_head *list1, *list2; 228 struct snd_rawmidi_substream *sinput = NULL, *soutput = NULL; 229 struct snd_rawmidi_runtime *input = NULL, *output = NULL; 230 int err; 231 232 if (rfile) 233 rfile->input = rfile->output = NULL; 234 mutex_lock(®ister_mutex); 235 rmidi = snd_rawmidi_search(card, device); 236 mutex_unlock(®ister_mutex); 237 if (rmidi == NULL) { 238 err = -ENODEV; 239 goto __error1; 240 } 241 if (!try_module_get(rmidi->card->module)) { 242 err = -EFAULT; 243 goto __error1; 244 } 245 if (!(mode & SNDRV_RAWMIDI_LFLG_NOOPENLOCK)) 246 mutex_lock(&rmidi->open_mutex); 247 if (mode & SNDRV_RAWMIDI_LFLG_INPUT) { 248 if (!(rmidi->info_flags & SNDRV_RAWMIDI_INFO_INPUT)) { 249 err = -ENXIO; 250 goto __error; 251 } 252 if (subdevice >= 0 && (unsigned int)subdevice >= rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substream_count) { 253 err = -ENODEV; 254 goto __error; 255 } 256 if (rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substream_opened >= 257 rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substream_count) { 258 err = -EAGAIN; 259 goto __error; 260 } 261 } 262 if (mode & SNDRV_RAWMIDI_LFLG_OUTPUT) { 263 if (!(rmidi->info_flags & SNDRV_RAWMIDI_INFO_OUTPUT)) { 264 err = -ENXIO; 265 goto __error; 266 } 267 if (subdevice >= 0 && (unsigned int)subdevice >= rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substream_count) { 268 err = -ENODEV; 269 goto __error; 270 } 271 if (rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substream_opened >= 272 rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substream_count) { 273 err = -EAGAIN; 274 goto __error; 275 } 276 } 277 list1 = rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams.next; 278 while (1) { 279 if (list1 == &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams) { 280 sinput = NULL; 281 if (mode & SNDRV_RAWMIDI_LFLG_INPUT) { 282 err = -EAGAIN; 283 goto __error; 284 } 285 break; 286 } 287 sinput = list_entry(list1, struct snd_rawmidi_substream, list); 288 if ((mode & SNDRV_RAWMIDI_LFLG_INPUT) && sinput->opened) 289 goto __nexti; 290 if (subdevice < 0 || (subdevice >= 0 && subdevice == sinput->number)) 291 break; 292 __nexti: 293 list1 = list1->next; 294 } 295 list2 = rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams.next; 296 while (1) { 297 if (list2 == &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams) { 298 soutput = NULL; 299 if (mode & SNDRV_RAWMIDI_LFLG_OUTPUT) { 300 err = -EAGAIN; 301 goto __error; 302 } 303 break; 304 } 305 soutput = list_entry(list2, struct snd_rawmidi_substream, list); 306 if (mode & SNDRV_RAWMIDI_LFLG_OUTPUT) { 307 if (mode & SNDRV_RAWMIDI_LFLG_APPEND) { 308 if (soutput->opened && !soutput->append) 309 goto __nexto; 310 } else { 311 if (soutput->opened) 312 goto __nexto; 313 } 314 } 315 if (subdevice < 0 || (subdevice >= 0 && subdevice == soutput->number)) 316 break; 317 __nexto: 318 list2 = list2->next; 319 } 320 if (mode & SNDRV_RAWMIDI_LFLG_INPUT) { 321 if ((err = snd_rawmidi_runtime_create(sinput)) < 0) 322 goto __error; 323 input = sinput->runtime; 324 if ((err = sinput->ops->open(sinput)) < 0) 325 goto __error; 326 sinput->opened = 1; 327 rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substream_opened++; 328 } else { 329 sinput = NULL; 330 } 331 if (mode & SNDRV_RAWMIDI_LFLG_OUTPUT) { 332 if (soutput->opened) 333 goto __skip_output; 334 if ((err = snd_rawmidi_runtime_create(soutput)) < 0) { 335 if (mode & SNDRV_RAWMIDI_LFLG_INPUT) 336 sinput->ops->close(sinput); 337 goto __error; 338 } 339 output = soutput->runtime; 340 if ((err = soutput->ops->open(soutput)) < 0) { 341 if (mode & SNDRV_RAWMIDI_LFLG_INPUT) 342 sinput->ops->close(sinput); 343 goto __error; 344 } 345 __skip_output: 346 soutput->opened = 1; 347 if (mode & SNDRV_RAWMIDI_LFLG_APPEND) 348 soutput->append = 1; 349 if (soutput->use_count++ == 0) 350 soutput->active_sensing = 1; 351 rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substream_opened++; 352 } else { 353 soutput = NULL; 354 } 355 if (!(mode & SNDRV_RAWMIDI_LFLG_NOOPENLOCK)) 356 mutex_unlock(&rmidi->open_mutex); 357 if (rfile) { 358 rfile->rmidi = rmidi; 359 rfile->input = sinput; 360 rfile->output = soutput; 361 } 362 return 0; 363 364 __error: 365 if (input != NULL) 366 snd_rawmidi_runtime_free(sinput); 367 if (output != NULL) 368 snd_rawmidi_runtime_free(soutput); 369 module_put(rmidi->card->module); 370 if (!(mode & SNDRV_RAWMIDI_LFLG_NOOPENLOCK)) 371 mutex_unlock(&rmidi->open_mutex); 372 __error1: 373 return err; 374 } 375 376 static int snd_rawmidi_open(struct inode *inode, struct file *file) 377 { 378 int maj = imajor(inode); 379 struct snd_card *card; 380 int subdevice; 381 unsigned short fflags; 382 int err; 383 struct snd_rawmidi *rmidi; 384 struct snd_rawmidi_file *rawmidi_file; 385 wait_queue_t wait; 386 struct snd_ctl_file *kctl; 387 388 if (maj == snd_major) { 389 rmidi = snd_lookup_minor_data(iminor(inode), 390 SNDRV_DEVICE_TYPE_RAWMIDI); 391 #ifdef CONFIG_SND_OSSEMUL 392 } else if (maj == SOUND_MAJOR) { 393 rmidi = snd_lookup_oss_minor_data(iminor(inode), 394 SNDRV_OSS_DEVICE_TYPE_MIDI); 395 #endif 396 } else 397 return -ENXIO; 398 399 if (rmidi == NULL) 400 return -ENODEV; 401 if ((file->f_flags & O_APPEND) && !(file->f_flags & O_NONBLOCK)) 402 return -EINVAL; /* invalid combination */ 403 card = rmidi->card; 404 err = snd_card_file_add(card, file); 405 if (err < 0) 406 return -ENODEV; 407 fflags = snd_rawmidi_file_flags(file); 408 if ((file->f_flags & O_APPEND) || maj == SOUND_MAJOR) /* OSS emul? */ 409 fflags |= SNDRV_RAWMIDI_LFLG_APPEND; 410 fflags |= SNDRV_RAWMIDI_LFLG_NOOPENLOCK; 411 rawmidi_file = kmalloc(sizeof(*rawmidi_file), GFP_KERNEL); 412 if (rawmidi_file == NULL) { 413 snd_card_file_remove(card, file); 414 return -ENOMEM; 415 } 416 init_waitqueue_entry(&wait, current); 417 add_wait_queue(&rmidi->open_wait, &wait); 418 mutex_lock(&rmidi->open_mutex); 419 while (1) { 420 subdevice = -1; 421 read_lock(&card->ctl_files_rwlock); 422 list_for_each_entry(kctl, &card->ctl_files, list) { 423 if (kctl->pid == current->pid) { 424 subdevice = kctl->prefer_rawmidi_subdevice; 425 if (subdevice != -1) 426 break; 427 } 428 } 429 read_unlock(&card->ctl_files_rwlock); 430 err = snd_rawmidi_kernel_open(rmidi->card, rmidi->device, 431 subdevice, fflags, rawmidi_file); 432 if (err >= 0) 433 break; 434 if (err == -EAGAIN) { 435 if (file->f_flags & O_NONBLOCK) { 436 err = -EBUSY; 437 break; 438 } 439 } else 440 break; 441 set_current_state(TASK_INTERRUPTIBLE); 442 mutex_unlock(&rmidi->open_mutex); 443 schedule(); 444 mutex_lock(&rmidi->open_mutex); 445 if (signal_pending(current)) { 446 err = -ERESTARTSYS; 447 break; 448 } 449 } 450 #ifdef CONFIG_SND_OSSEMUL 451 if (rawmidi_file->input && rawmidi_file->input->runtime) 452 rawmidi_file->input->runtime->oss = (maj == SOUND_MAJOR); 453 if (rawmidi_file->output && rawmidi_file->output->runtime) 454 rawmidi_file->output->runtime->oss = (maj == SOUND_MAJOR); 455 #endif 456 remove_wait_queue(&rmidi->open_wait, &wait); 457 if (err >= 0) { 458 file->private_data = rawmidi_file; 459 } else { 460 snd_card_file_remove(card, file); 461 kfree(rawmidi_file); 462 } 463 mutex_unlock(&rmidi->open_mutex); 464 return err; 465 } 466 467 int snd_rawmidi_kernel_release(struct snd_rawmidi_file * rfile) 468 { 469 struct snd_rawmidi *rmidi; 470 struct snd_rawmidi_substream *substream; 471 struct snd_rawmidi_runtime *runtime; 472 473 if (snd_BUG_ON(!rfile)) 474 return -ENXIO; 475 rmidi = rfile->rmidi; 476 mutex_lock(&rmidi->open_mutex); 477 if (rfile->input != NULL) { 478 substream = rfile->input; 479 rfile->input = NULL; 480 runtime = substream->runtime; 481 snd_rawmidi_input_trigger(substream, 0); 482 substream->ops->close(substream); 483 if (runtime->private_free != NULL) 484 runtime->private_free(substream); 485 snd_rawmidi_runtime_free(substream); 486 substream->opened = 0; 487 rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substream_opened--; 488 } 489 if (rfile->output != NULL) { 490 substream = rfile->output; 491 rfile->output = NULL; 492 if (--substream->use_count == 0) { 493 runtime = substream->runtime; 494 if (substream->active_sensing) { 495 unsigned char buf = 0xfe; 496 /* sending single active sensing message to shut the device up */ 497 snd_rawmidi_kernel_write(substream, &buf, 1); 498 } 499 if (snd_rawmidi_drain_output(substream) == -ERESTARTSYS) 500 snd_rawmidi_output_trigger(substream, 0); 501 substream->ops->close(substream); 502 if (runtime->private_free != NULL) 503 runtime->private_free(substream); 504 snd_rawmidi_runtime_free(substream); 505 substream->opened = 0; 506 substream->append = 0; 507 } 508 rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substream_opened--; 509 } 510 mutex_unlock(&rmidi->open_mutex); 511 module_put(rmidi->card->module); 512 return 0; 513 } 514 515 static int snd_rawmidi_release(struct inode *inode, struct file *file) 516 { 517 struct snd_rawmidi_file *rfile; 518 struct snd_rawmidi *rmidi; 519 int err; 520 521 rfile = file->private_data; 522 err = snd_rawmidi_kernel_release(rfile); 523 rmidi = rfile->rmidi; 524 wake_up(&rmidi->open_wait); 525 kfree(rfile); 526 snd_card_file_remove(rmidi->card, file); 527 return err; 528 } 529 530 static int snd_rawmidi_info(struct snd_rawmidi_substream *substream, 531 struct snd_rawmidi_info *info) 532 { 533 struct snd_rawmidi *rmidi; 534 535 if (substream == NULL) 536 return -ENODEV; 537 rmidi = substream->rmidi; 538 memset(info, 0, sizeof(*info)); 539 info->card = rmidi->card->number; 540 info->device = rmidi->device; 541 info->subdevice = substream->number; 542 info->stream = substream->stream; 543 info->flags = rmidi->info_flags; 544 strcpy(info->id, rmidi->id); 545 strcpy(info->name, rmidi->name); 546 strcpy(info->subname, substream->name); 547 info->subdevices_count = substream->pstr->substream_count; 548 info->subdevices_avail = (substream->pstr->substream_count - 549 substream->pstr->substream_opened); 550 return 0; 551 } 552 553 static int snd_rawmidi_info_user(struct snd_rawmidi_substream *substream, 554 struct snd_rawmidi_info __user * _info) 555 { 556 struct snd_rawmidi_info info; 557 int err; 558 if ((err = snd_rawmidi_info(substream, &info)) < 0) 559 return err; 560 if (copy_to_user(_info, &info, sizeof(struct snd_rawmidi_info))) 561 return -EFAULT; 562 return 0; 563 } 564 565 int snd_rawmidi_info_select(struct snd_card *card, struct snd_rawmidi_info *info) 566 { 567 struct snd_rawmidi *rmidi; 568 struct snd_rawmidi_str *pstr; 569 struct snd_rawmidi_substream *substream; 570 571 mutex_lock(®ister_mutex); 572 rmidi = snd_rawmidi_search(card, info->device); 573 mutex_unlock(®ister_mutex); 574 if (!rmidi) 575 return -ENXIO; 576 if (info->stream < 0 || info->stream > 1) 577 return -EINVAL; 578 pstr = &rmidi->streams[info->stream]; 579 if (pstr->substream_count == 0) 580 return -ENOENT; 581 if (info->subdevice >= pstr->substream_count) 582 return -ENXIO; 583 list_for_each_entry(substream, &pstr->substreams, list) { 584 if ((unsigned int)substream->number == info->subdevice) 585 return snd_rawmidi_info(substream, info); 586 } 587 return -ENXIO; 588 } 589 590 static int snd_rawmidi_info_select_user(struct snd_card *card, 591 struct snd_rawmidi_info __user *_info) 592 { 593 int err; 594 struct snd_rawmidi_info info; 595 if (get_user(info.device, &_info->device)) 596 return -EFAULT; 597 if (get_user(info.stream, &_info->stream)) 598 return -EFAULT; 599 if (get_user(info.subdevice, &_info->subdevice)) 600 return -EFAULT; 601 if ((err = snd_rawmidi_info_select(card, &info)) < 0) 602 return err; 603 if (copy_to_user(_info, &info, sizeof(struct snd_rawmidi_info))) 604 return -EFAULT; 605 return 0; 606 } 607 608 int snd_rawmidi_output_params(struct snd_rawmidi_substream *substream, 609 struct snd_rawmidi_params * params) 610 { 611 char *newbuf; 612 struct snd_rawmidi_runtime *runtime = substream->runtime; 613 614 if (substream->append && substream->use_count > 1) 615 return -EBUSY; 616 snd_rawmidi_drain_output(substream); 617 if (params->buffer_size < 32 || params->buffer_size > 1024L * 1024L) { 618 return -EINVAL; 619 } 620 if (params->avail_min < 1 || params->avail_min > params->buffer_size) { 621 return -EINVAL; 622 } 623 if (params->buffer_size != runtime->buffer_size) { 624 newbuf = kmalloc(params->buffer_size, GFP_KERNEL); 625 if (!newbuf) 626 return -ENOMEM; 627 kfree(runtime->buffer); 628 runtime->buffer = newbuf; 629 runtime->buffer_size = params->buffer_size; 630 runtime->avail = runtime->buffer_size; 631 } 632 runtime->avail_min = params->avail_min; 633 substream->active_sensing = !params->no_active_sensing; 634 return 0; 635 } 636 637 int snd_rawmidi_input_params(struct snd_rawmidi_substream *substream, 638 struct snd_rawmidi_params * params) 639 { 640 char *newbuf; 641 struct snd_rawmidi_runtime *runtime = substream->runtime; 642 643 snd_rawmidi_drain_input(substream); 644 if (params->buffer_size < 32 || params->buffer_size > 1024L * 1024L) { 645 return -EINVAL; 646 } 647 if (params->avail_min < 1 || params->avail_min > params->buffer_size) { 648 return -EINVAL; 649 } 650 if (params->buffer_size != runtime->buffer_size) { 651 newbuf = kmalloc(params->buffer_size, GFP_KERNEL); 652 if (!newbuf) 653 return -ENOMEM; 654 kfree(runtime->buffer); 655 runtime->buffer = newbuf; 656 runtime->buffer_size = params->buffer_size; 657 } 658 runtime->avail_min = params->avail_min; 659 return 0; 660 } 661 662 static int snd_rawmidi_output_status(struct snd_rawmidi_substream *substream, 663 struct snd_rawmidi_status * status) 664 { 665 struct snd_rawmidi_runtime *runtime = substream->runtime; 666 667 memset(status, 0, sizeof(*status)); 668 status->stream = SNDRV_RAWMIDI_STREAM_OUTPUT; 669 spin_lock_irq(&runtime->lock); 670 status->avail = runtime->avail; 671 spin_unlock_irq(&runtime->lock); 672 return 0; 673 } 674 675 static int snd_rawmidi_input_status(struct snd_rawmidi_substream *substream, 676 struct snd_rawmidi_status * status) 677 { 678 struct snd_rawmidi_runtime *runtime = substream->runtime; 679 680 memset(status, 0, sizeof(*status)); 681 status->stream = SNDRV_RAWMIDI_STREAM_INPUT; 682 spin_lock_irq(&runtime->lock); 683 status->avail = runtime->avail; 684 status->xruns = runtime->xruns; 685 runtime->xruns = 0; 686 spin_unlock_irq(&runtime->lock); 687 return 0; 688 } 689 690 static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 691 { 692 struct snd_rawmidi_file *rfile; 693 void __user *argp = (void __user *)arg; 694 695 rfile = file->private_data; 696 if (((cmd >> 8) & 0xff) != 'W') 697 return -ENOTTY; 698 switch (cmd) { 699 case SNDRV_RAWMIDI_IOCTL_PVERSION: 700 return put_user(SNDRV_RAWMIDI_VERSION, (int __user *)argp) ? -EFAULT : 0; 701 case SNDRV_RAWMIDI_IOCTL_INFO: 702 { 703 int stream; 704 struct snd_rawmidi_info __user *info = argp; 705 if (get_user(stream, &info->stream)) 706 return -EFAULT; 707 switch (stream) { 708 case SNDRV_RAWMIDI_STREAM_INPUT: 709 return snd_rawmidi_info_user(rfile->input, info); 710 case SNDRV_RAWMIDI_STREAM_OUTPUT: 711 return snd_rawmidi_info_user(rfile->output, info); 712 default: 713 return -EINVAL; 714 } 715 } 716 case SNDRV_RAWMIDI_IOCTL_PARAMS: 717 { 718 struct snd_rawmidi_params params; 719 if (copy_from_user(¶ms, argp, sizeof(struct snd_rawmidi_params))) 720 return -EFAULT; 721 switch (params.stream) { 722 case SNDRV_RAWMIDI_STREAM_OUTPUT: 723 if (rfile->output == NULL) 724 return -EINVAL; 725 return snd_rawmidi_output_params(rfile->output, ¶ms); 726 case SNDRV_RAWMIDI_STREAM_INPUT: 727 if (rfile->input == NULL) 728 return -EINVAL; 729 return snd_rawmidi_input_params(rfile->input, ¶ms); 730 default: 731 return -EINVAL; 732 } 733 } 734 case SNDRV_RAWMIDI_IOCTL_STATUS: 735 { 736 int err = 0; 737 struct snd_rawmidi_status status; 738 if (copy_from_user(&status, argp, sizeof(struct snd_rawmidi_status))) 739 return -EFAULT; 740 switch (status.stream) { 741 case SNDRV_RAWMIDI_STREAM_OUTPUT: 742 if (rfile->output == NULL) 743 return -EINVAL; 744 err = snd_rawmidi_output_status(rfile->output, &status); 745 break; 746 case SNDRV_RAWMIDI_STREAM_INPUT: 747 if (rfile->input == NULL) 748 return -EINVAL; 749 err = snd_rawmidi_input_status(rfile->input, &status); 750 break; 751 default: 752 return -EINVAL; 753 } 754 if (err < 0) 755 return err; 756 if (copy_to_user(argp, &status, sizeof(struct snd_rawmidi_status))) 757 return -EFAULT; 758 return 0; 759 } 760 case SNDRV_RAWMIDI_IOCTL_DROP: 761 { 762 int val; 763 if (get_user(val, (int __user *) argp)) 764 return -EFAULT; 765 switch (val) { 766 case SNDRV_RAWMIDI_STREAM_OUTPUT: 767 if (rfile->output == NULL) 768 return -EINVAL; 769 return snd_rawmidi_drop_output(rfile->output); 770 default: 771 return -EINVAL; 772 } 773 } 774 case SNDRV_RAWMIDI_IOCTL_DRAIN: 775 { 776 int val; 777 if (get_user(val, (int __user *) argp)) 778 return -EFAULT; 779 switch (val) { 780 case SNDRV_RAWMIDI_STREAM_OUTPUT: 781 if (rfile->output == NULL) 782 return -EINVAL; 783 return snd_rawmidi_drain_output(rfile->output); 784 case SNDRV_RAWMIDI_STREAM_INPUT: 785 if (rfile->input == NULL) 786 return -EINVAL; 787 return snd_rawmidi_drain_input(rfile->input); 788 default: 789 return -EINVAL; 790 } 791 } 792 #ifdef CONFIG_SND_DEBUG 793 default: 794 snd_printk(KERN_WARNING "rawmidi: unknown command = 0x%x\n", cmd); 795 #endif 796 } 797 return -ENOTTY; 798 } 799 800 static int snd_rawmidi_control_ioctl(struct snd_card *card, 801 struct snd_ctl_file *control, 802 unsigned int cmd, 803 unsigned long arg) 804 { 805 void __user *argp = (void __user *)arg; 806 807 switch (cmd) { 808 case SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE: 809 { 810 int device; 811 812 if (get_user(device, (int __user *)argp)) 813 return -EFAULT; 814 mutex_lock(®ister_mutex); 815 device = device < 0 ? 0 : device + 1; 816 while (device < SNDRV_RAWMIDI_DEVICES) { 817 if (snd_rawmidi_search(card, device)) 818 break; 819 device++; 820 } 821 if (device == SNDRV_RAWMIDI_DEVICES) 822 device = -1; 823 mutex_unlock(®ister_mutex); 824 if (put_user(device, (int __user *)argp)) 825 return -EFAULT; 826 return 0; 827 } 828 case SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE: 829 { 830 int val; 831 832 if (get_user(val, (int __user *)argp)) 833 return -EFAULT; 834 control->prefer_rawmidi_subdevice = val; 835 return 0; 836 } 837 case SNDRV_CTL_IOCTL_RAWMIDI_INFO: 838 return snd_rawmidi_info_select_user(card, argp); 839 } 840 return -ENOIOCTLCMD; 841 } 842 843 /** 844 * snd_rawmidi_receive - receive the input data from the device 845 * @substream: the rawmidi substream 846 * @buffer: the buffer pointer 847 * @count: the data size to read 848 * 849 * Reads the data from the internal buffer. 850 * 851 * Returns the size of read data, or a negative error code on failure. 852 */ 853 int snd_rawmidi_receive(struct snd_rawmidi_substream *substream, 854 const unsigned char *buffer, int count) 855 { 856 unsigned long flags; 857 int result = 0, count1; 858 struct snd_rawmidi_runtime *runtime = substream->runtime; 859 860 if (runtime->buffer == NULL) { 861 snd_printd("snd_rawmidi_receive: input is not active!!!\n"); 862 return -EINVAL; 863 } 864 spin_lock_irqsave(&runtime->lock, flags); 865 if (count == 1) { /* special case, faster code */ 866 substream->bytes++; 867 if (runtime->avail < runtime->buffer_size) { 868 runtime->buffer[runtime->hw_ptr++] = buffer[0]; 869 runtime->hw_ptr %= runtime->buffer_size; 870 runtime->avail++; 871 result++; 872 } else { 873 runtime->xruns++; 874 } 875 } else { 876 substream->bytes += count; 877 count1 = runtime->buffer_size - runtime->hw_ptr; 878 if (count1 > count) 879 count1 = count; 880 if (count1 > (int)(runtime->buffer_size - runtime->avail)) 881 count1 = runtime->buffer_size - runtime->avail; 882 memcpy(runtime->buffer + runtime->hw_ptr, buffer, count1); 883 runtime->hw_ptr += count1; 884 runtime->hw_ptr %= runtime->buffer_size; 885 runtime->avail += count1; 886 count -= count1; 887 result += count1; 888 if (count > 0) { 889 buffer += count1; 890 count1 = count; 891 if (count1 > (int)(runtime->buffer_size - runtime->avail)) { 892 count1 = runtime->buffer_size - runtime->avail; 893 runtime->xruns += count - count1; 894 } 895 if (count1 > 0) { 896 memcpy(runtime->buffer, buffer, count1); 897 runtime->hw_ptr = count1; 898 runtime->avail += count1; 899 result += count1; 900 } 901 } 902 } 903 if (result > 0) { 904 if (runtime->event) 905 tasklet_hi_schedule(&runtime->tasklet); 906 else if (snd_rawmidi_ready(substream)) 907 wake_up(&runtime->sleep); 908 } 909 spin_unlock_irqrestore(&runtime->lock, flags); 910 return result; 911 } 912 913 static long snd_rawmidi_kernel_read1(struct snd_rawmidi_substream *substream, 914 unsigned char __user *userbuf, 915 unsigned char *kernelbuf, long count) 916 { 917 unsigned long flags; 918 long result = 0, count1; 919 struct snd_rawmidi_runtime *runtime = substream->runtime; 920 921 while (count > 0 && runtime->avail) { 922 count1 = runtime->buffer_size - runtime->appl_ptr; 923 if (count1 > count) 924 count1 = count; 925 spin_lock_irqsave(&runtime->lock, flags); 926 if (count1 > (int)runtime->avail) 927 count1 = runtime->avail; 928 if (kernelbuf) 929 memcpy(kernelbuf + result, runtime->buffer + runtime->appl_ptr, count1); 930 if (userbuf) { 931 spin_unlock_irqrestore(&runtime->lock, flags); 932 if (copy_to_user(userbuf + result, 933 runtime->buffer + runtime->appl_ptr, count1)) { 934 return result > 0 ? result : -EFAULT; 935 } 936 spin_lock_irqsave(&runtime->lock, flags); 937 } 938 runtime->appl_ptr += count1; 939 runtime->appl_ptr %= runtime->buffer_size; 940 runtime->avail -= count1; 941 spin_unlock_irqrestore(&runtime->lock, flags); 942 result += count1; 943 count -= count1; 944 } 945 return result; 946 } 947 948 long snd_rawmidi_kernel_read(struct snd_rawmidi_substream *substream, 949 unsigned char *buf, long count) 950 { 951 snd_rawmidi_input_trigger(substream, 1); 952 return snd_rawmidi_kernel_read1(substream, NULL/*userbuf*/, buf, count); 953 } 954 955 static ssize_t snd_rawmidi_read(struct file *file, char __user *buf, size_t count, 956 loff_t *offset) 957 { 958 long result; 959 int count1; 960 struct snd_rawmidi_file *rfile; 961 struct snd_rawmidi_substream *substream; 962 struct snd_rawmidi_runtime *runtime; 963 964 rfile = file->private_data; 965 substream = rfile->input; 966 if (substream == NULL) 967 return -EIO; 968 runtime = substream->runtime; 969 snd_rawmidi_input_trigger(substream, 1); 970 result = 0; 971 while (count > 0) { 972 spin_lock_irq(&runtime->lock); 973 while (!snd_rawmidi_ready(substream)) { 974 wait_queue_t wait; 975 if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) { 976 spin_unlock_irq(&runtime->lock); 977 return result > 0 ? result : -EAGAIN; 978 } 979 init_waitqueue_entry(&wait, current); 980 add_wait_queue(&runtime->sleep, &wait); 981 set_current_state(TASK_INTERRUPTIBLE); 982 spin_unlock_irq(&runtime->lock); 983 schedule(); 984 remove_wait_queue(&runtime->sleep, &wait); 985 if (signal_pending(current)) 986 return result > 0 ? result : -ERESTARTSYS; 987 if (!runtime->avail) 988 return result > 0 ? result : -EIO; 989 spin_lock_irq(&runtime->lock); 990 } 991 spin_unlock_irq(&runtime->lock); 992 count1 = snd_rawmidi_kernel_read1(substream, 993 (unsigned char __user *)buf, 994 NULL/*kernelbuf*/, 995 count); 996 if (count1 < 0) 997 return result > 0 ? result : count1; 998 result += count1; 999 buf += count1; 1000 count -= count1; 1001 } 1002 return result; 1003 } 1004 1005 /** 1006 * snd_rawmidi_transmit_empty - check whether the output buffer is empty 1007 * @substream: the rawmidi substream 1008 * 1009 * Returns 1 if the internal output buffer is empty, 0 if not. 1010 */ 1011 int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream *substream) 1012 { 1013 struct snd_rawmidi_runtime *runtime = substream->runtime; 1014 int result; 1015 unsigned long flags; 1016 1017 if (runtime->buffer == NULL) { 1018 snd_printd("snd_rawmidi_transmit_empty: output is not active!!!\n"); 1019 return 1; 1020 } 1021 spin_lock_irqsave(&runtime->lock, flags); 1022 result = runtime->avail >= runtime->buffer_size; 1023 spin_unlock_irqrestore(&runtime->lock, flags); 1024 return result; 1025 } 1026 1027 /** 1028 * snd_rawmidi_transmit_peek - copy data from the internal buffer 1029 * @substream: the rawmidi substream 1030 * @buffer: the buffer pointer 1031 * @count: data size to transfer 1032 * 1033 * Copies data from the internal output buffer to the given buffer. 1034 * 1035 * Call this in the interrupt handler when the midi output is ready, 1036 * and call snd_rawmidi_transmit_ack() after the transmission is 1037 * finished. 1038 * 1039 * Returns the size of copied data, or a negative error code on failure. 1040 */ 1041 int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream, 1042 unsigned char *buffer, int count) 1043 { 1044 unsigned long flags; 1045 int result, count1; 1046 struct snd_rawmidi_runtime *runtime = substream->runtime; 1047 1048 if (runtime->buffer == NULL) { 1049 snd_printd("snd_rawmidi_transmit_peek: output is not active!!!\n"); 1050 return -EINVAL; 1051 } 1052 result = 0; 1053 spin_lock_irqsave(&runtime->lock, flags); 1054 if (runtime->avail >= runtime->buffer_size) { 1055 /* warning: lowlevel layer MUST trigger down the hardware */ 1056 goto __skip; 1057 } 1058 if (count == 1) { /* special case, faster code */ 1059 *buffer = runtime->buffer[runtime->hw_ptr]; 1060 result++; 1061 } else { 1062 count1 = runtime->buffer_size - runtime->hw_ptr; 1063 if (count1 > count) 1064 count1 = count; 1065 if (count1 > (int)(runtime->buffer_size - runtime->avail)) 1066 count1 = runtime->buffer_size - runtime->avail; 1067 memcpy(buffer, runtime->buffer + runtime->hw_ptr, count1); 1068 count -= count1; 1069 result += count1; 1070 if (count > 0) { 1071 if (count > (int)(runtime->buffer_size - runtime->avail - count1)) 1072 count = runtime->buffer_size - runtime->avail - count1; 1073 memcpy(buffer + count1, runtime->buffer, count); 1074 result += count; 1075 } 1076 } 1077 __skip: 1078 spin_unlock_irqrestore(&runtime->lock, flags); 1079 return result; 1080 } 1081 1082 /** 1083 * snd_rawmidi_transmit_ack - acknowledge the transmission 1084 * @substream: the rawmidi substream 1085 * @count: the tranferred count 1086 * 1087 * Advances the hardware pointer for the internal output buffer with 1088 * the given size and updates the condition. 1089 * Call after the transmission is finished. 1090 * 1091 * Returns the advanced size if successful, or a negative error code on failure. 1092 */ 1093 int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count) 1094 { 1095 unsigned long flags; 1096 struct snd_rawmidi_runtime *runtime = substream->runtime; 1097 1098 if (runtime->buffer == NULL) { 1099 snd_printd("snd_rawmidi_transmit_ack: output is not active!!!\n"); 1100 return -EINVAL; 1101 } 1102 spin_lock_irqsave(&runtime->lock, flags); 1103 snd_BUG_ON(runtime->avail + count > runtime->buffer_size); 1104 runtime->hw_ptr += count; 1105 runtime->hw_ptr %= runtime->buffer_size; 1106 runtime->avail += count; 1107 substream->bytes += count; 1108 if (count > 0) { 1109 if (runtime->drain || snd_rawmidi_ready(substream)) 1110 wake_up(&runtime->sleep); 1111 } 1112 spin_unlock_irqrestore(&runtime->lock, flags); 1113 return count; 1114 } 1115 1116 /** 1117 * snd_rawmidi_transmit - copy from the buffer to the device 1118 * @substream: the rawmidi substream 1119 * @buffer: the buffer pointer 1120 * @count: the data size to transfer 1121 * 1122 * Copies data from the buffer to the device and advances the pointer. 1123 * 1124 * Returns the copied size if successful, or a negative error code on failure. 1125 */ 1126 int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream, 1127 unsigned char *buffer, int count) 1128 { 1129 count = snd_rawmidi_transmit_peek(substream, buffer, count); 1130 if (count < 0) 1131 return count; 1132 return snd_rawmidi_transmit_ack(substream, count); 1133 } 1134 1135 static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream, 1136 const unsigned char __user *userbuf, 1137 const unsigned char *kernelbuf, 1138 long count) 1139 { 1140 unsigned long flags; 1141 long count1, result; 1142 struct snd_rawmidi_runtime *runtime = substream->runtime; 1143 1144 if (snd_BUG_ON(!kernelbuf && !userbuf)) 1145 return -EINVAL; 1146 if (snd_BUG_ON(!runtime->buffer)) 1147 return -EINVAL; 1148 1149 result = 0; 1150 spin_lock_irqsave(&runtime->lock, flags); 1151 if (substream->append) { 1152 if ((long)runtime->avail < count) { 1153 spin_unlock_irqrestore(&runtime->lock, flags); 1154 return -EAGAIN; 1155 } 1156 } 1157 while (count > 0 && runtime->avail > 0) { 1158 count1 = runtime->buffer_size - runtime->appl_ptr; 1159 if (count1 > count) 1160 count1 = count; 1161 if (count1 > (long)runtime->avail) 1162 count1 = runtime->avail; 1163 if (kernelbuf) 1164 memcpy(runtime->buffer + runtime->appl_ptr, 1165 kernelbuf + result, count1); 1166 else if (userbuf) { 1167 spin_unlock_irqrestore(&runtime->lock, flags); 1168 if (copy_from_user(runtime->buffer + runtime->appl_ptr, 1169 userbuf + result, count1)) { 1170 spin_lock_irqsave(&runtime->lock, flags); 1171 result = result > 0 ? result : -EFAULT; 1172 goto __end; 1173 } 1174 spin_lock_irqsave(&runtime->lock, flags); 1175 } 1176 runtime->appl_ptr += count1; 1177 runtime->appl_ptr %= runtime->buffer_size; 1178 runtime->avail -= count1; 1179 result += count1; 1180 count -= count1; 1181 } 1182 __end: 1183 count1 = runtime->avail < runtime->buffer_size; 1184 spin_unlock_irqrestore(&runtime->lock, flags); 1185 if (count1) 1186 snd_rawmidi_output_trigger(substream, 1); 1187 return result; 1188 } 1189 1190 long snd_rawmidi_kernel_write(struct snd_rawmidi_substream *substream, 1191 const unsigned char *buf, long count) 1192 { 1193 return snd_rawmidi_kernel_write1(substream, NULL, buf, count); 1194 } 1195 1196 static ssize_t snd_rawmidi_write(struct file *file, const char __user *buf, 1197 size_t count, loff_t *offset) 1198 { 1199 long result, timeout; 1200 int count1; 1201 struct snd_rawmidi_file *rfile; 1202 struct snd_rawmidi_runtime *runtime; 1203 struct snd_rawmidi_substream *substream; 1204 1205 rfile = file->private_data; 1206 substream = rfile->output; 1207 runtime = substream->runtime; 1208 /* we cannot put an atomic message to our buffer */ 1209 if (substream->append && count > runtime->buffer_size) 1210 return -EIO; 1211 result = 0; 1212 while (count > 0) { 1213 spin_lock_irq(&runtime->lock); 1214 while (!snd_rawmidi_ready_append(substream, count)) { 1215 wait_queue_t wait; 1216 if (file->f_flags & O_NONBLOCK) { 1217 spin_unlock_irq(&runtime->lock); 1218 return result > 0 ? result : -EAGAIN; 1219 } 1220 init_waitqueue_entry(&wait, current); 1221 add_wait_queue(&runtime->sleep, &wait); 1222 set_current_state(TASK_INTERRUPTIBLE); 1223 spin_unlock_irq(&runtime->lock); 1224 timeout = schedule_timeout(30 * HZ); 1225 remove_wait_queue(&runtime->sleep, &wait); 1226 if (signal_pending(current)) 1227 return result > 0 ? result : -ERESTARTSYS; 1228 if (!runtime->avail && !timeout) 1229 return result > 0 ? result : -EIO; 1230 spin_lock_irq(&runtime->lock); 1231 } 1232 spin_unlock_irq(&runtime->lock); 1233 count1 = snd_rawmidi_kernel_write1(substream, buf, NULL, count); 1234 if (count1 < 0) 1235 return result > 0 ? result : count1; 1236 result += count1; 1237 buf += count1; 1238 if ((size_t)count1 < count && (file->f_flags & O_NONBLOCK)) 1239 break; 1240 count -= count1; 1241 } 1242 if (file->f_flags & O_SYNC) { 1243 spin_lock_irq(&runtime->lock); 1244 while (runtime->avail != runtime->buffer_size) { 1245 wait_queue_t wait; 1246 unsigned int last_avail = runtime->avail; 1247 init_waitqueue_entry(&wait, current); 1248 add_wait_queue(&runtime->sleep, &wait); 1249 set_current_state(TASK_INTERRUPTIBLE); 1250 spin_unlock_irq(&runtime->lock); 1251 timeout = schedule_timeout(30 * HZ); 1252 remove_wait_queue(&runtime->sleep, &wait); 1253 if (signal_pending(current)) 1254 return result > 0 ? result : -ERESTARTSYS; 1255 if (runtime->avail == last_avail && !timeout) 1256 return result > 0 ? result : -EIO; 1257 spin_lock_irq(&runtime->lock); 1258 } 1259 spin_unlock_irq(&runtime->lock); 1260 } 1261 return result; 1262 } 1263 1264 static unsigned int snd_rawmidi_poll(struct file *file, poll_table * wait) 1265 { 1266 struct snd_rawmidi_file *rfile; 1267 struct snd_rawmidi_runtime *runtime; 1268 unsigned int mask; 1269 1270 rfile = file->private_data; 1271 if (rfile->input != NULL) { 1272 runtime = rfile->input->runtime; 1273 snd_rawmidi_input_trigger(rfile->input, 1); 1274 poll_wait(file, &runtime->sleep, wait); 1275 } 1276 if (rfile->output != NULL) { 1277 runtime = rfile->output->runtime; 1278 poll_wait(file, &runtime->sleep, wait); 1279 } 1280 mask = 0; 1281 if (rfile->input != NULL) { 1282 if (snd_rawmidi_ready(rfile->input)) 1283 mask |= POLLIN | POLLRDNORM; 1284 } 1285 if (rfile->output != NULL) { 1286 if (snd_rawmidi_ready(rfile->output)) 1287 mask |= POLLOUT | POLLWRNORM; 1288 } 1289 return mask; 1290 } 1291 1292 /* 1293 */ 1294 #ifdef CONFIG_COMPAT 1295 #include "rawmidi_compat.c" 1296 #else 1297 #define snd_rawmidi_ioctl_compat NULL 1298 #endif 1299 1300 /* 1301 1302 */ 1303 1304 static void snd_rawmidi_proc_info_read(struct snd_info_entry *entry, 1305 struct snd_info_buffer *buffer) 1306 { 1307 struct snd_rawmidi *rmidi; 1308 struct snd_rawmidi_substream *substream; 1309 struct snd_rawmidi_runtime *runtime; 1310 1311 rmidi = entry->private_data; 1312 snd_iprintf(buffer, "%s\n\n", rmidi->name); 1313 mutex_lock(&rmidi->open_mutex); 1314 if (rmidi->info_flags & SNDRV_RAWMIDI_INFO_OUTPUT) { 1315 list_for_each_entry(substream, 1316 &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams, 1317 list) { 1318 snd_iprintf(buffer, 1319 "Output %d\n" 1320 " Tx bytes : %lu\n", 1321 substream->number, 1322 (unsigned long) substream->bytes); 1323 if (substream->opened) { 1324 runtime = substream->runtime; 1325 snd_iprintf(buffer, 1326 " Mode : %s\n" 1327 " Buffer size : %lu\n" 1328 " Avail : %lu\n", 1329 runtime->oss ? "OSS compatible" : "native", 1330 (unsigned long) runtime->buffer_size, 1331 (unsigned long) runtime->avail); 1332 } 1333 } 1334 } 1335 if (rmidi->info_flags & SNDRV_RAWMIDI_INFO_INPUT) { 1336 list_for_each_entry(substream, 1337 &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams, 1338 list) { 1339 snd_iprintf(buffer, 1340 "Input %d\n" 1341 " Rx bytes : %lu\n", 1342 substream->number, 1343 (unsigned long) substream->bytes); 1344 if (substream->opened) { 1345 runtime = substream->runtime; 1346 snd_iprintf(buffer, 1347 " Buffer size : %lu\n" 1348 " Avail : %lu\n" 1349 " Overruns : %lu\n", 1350 (unsigned long) runtime->buffer_size, 1351 (unsigned long) runtime->avail, 1352 (unsigned long) runtime->xruns); 1353 } 1354 } 1355 } 1356 mutex_unlock(&rmidi->open_mutex); 1357 } 1358 1359 /* 1360 * Register functions 1361 */ 1362 1363 static const struct file_operations snd_rawmidi_f_ops = 1364 { 1365 .owner = THIS_MODULE, 1366 .read = snd_rawmidi_read, 1367 .write = snd_rawmidi_write, 1368 .open = snd_rawmidi_open, 1369 .release = snd_rawmidi_release, 1370 .poll = snd_rawmidi_poll, 1371 .unlocked_ioctl = snd_rawmidi_ioctl, 1372 .compat_ioctl = snd_rawmidi_ioctl_compat, 1373 }; 1374 1375 static int snd_rawmidi_alloc_substreams(struct snd_rawmidi *rmidi, 1376 struct snd_rawmidi_str *stream, 1377 int direction, 1378 int count) 1379 { 1380 struct snd_rawmidi_substream *substream; 1381 int idx; 1382 1383 for (idx = 0; idx < count; idx++) { 1384 substream = kzalloc(sizeof(*substream), GFP_KERNEL); 1385 if (substream == NULL) { 1386 snd_printk(KERN_ERR "rawmidi: cannot allocate substream\n"); 1387 return -ENOMEM; 1388 } 1389 substream->stream = direction; 1390 substream->number = idx; 1391 substream->rmidi = rmidi; 1392 substream->pstr = stream; 1393 list_add_tail(&substream->list, &stream->substreams); 1394 stream->substream_count++; 1395 } 1396 return 0; 1397 } 1398 1399 /** 1400 * snd_rawmidi_new - create a rawmidi instance 1401 * @card: the card instance 1402 * @id: the id string 1403 * @device: the device index 1404 * @output_count: the number of output streams 1405 * @input_count: the number of input streams 1406 * @rrawmidi: the pointer to store the new rawmidi instance 1407 * 1408 * Creates a new rawmidi instance. 1409 * Use snd_rawmidi_set_ops() to set the operators to the new instance. 1410 * 1411 * Returns zero if successful, or a negative error code on failure. 1412 */ 1413 int snd_rawmidi_new(struct snd_card *card, char *id, int device, 1414 int output_count, int input_count, 1415 struct snd_rawmidi ** rrawmidi) 1416 { 1417 struct snd_rawmidi *rmidi; 1418 int err; 1419 static struct snd_device_ops ops = { 1420 .dev_free = snd_rawmidi_dev_free, 1421 .dev_register = snd_rawmidi_dev_register, 1422 .dev_disconnect = snd_rawmidi_dev_disconnect, 1423 }; 1424 1425 if (snd_BUG_ON(!card)) 1426 return -ENXIO; 1427 if (rrawmidi) 1428 *rrawmidi = NULL; 1429 rmidi = kzalloc(sizeof(*rmidi), GFP_KERNEL); 1430 if (rmidi == NULL) { 1431 snd_printk(KERN_ERR "rawmidi: cannot allocate\n"); 1432 return -ENOMEM; 1433 } 1434 rmidi->card = card; 1435 rmidi->device = device; 1436 mutex_init(&rmidi->open_mutex); 1437 init_waitqueue_head(&rmidi->open_wait); 1438 INIT_LIST_HEAD(&rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams); 1439 INIT_LIST_HEAD(&rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams); 1440 1441 if (id != NULL) 1442 strlcpy(rmidi->id, id, sizeof(rmidi->id)); 1443 if ((err = snd_rawmidi_alloc_substreams(rmidi, 1444 &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT], 1445 SNDRV_RAWMIDI_STREAM_INPUT, 1446 input_count)) < 0) { 1447 snd_rawmidi_free(rmidi); 1448 return err; 1449 } 1450 if ((err = snd_rawmidi_alloc_substreams(rmidi, 1451 &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT], 1452 SNDRV_RAWMIDI_STREAM_OUTPUT, 1453 output_count)) < 0) { 1454 snd_rawmidi_free(rmidi); 1455 return err; 1456 } 1457 if ((err = snd_device_new(card, SNDRV_DEV_RAWMIDI, rmidi, &ops)) < 0) { 1458 snd_rawmidi_free(rmidi); 1459 return err; 1460 } 1461 if (rrawmidi) 1462 *rrawmidi = rmidi; 1463 return 0; 1464 } 1465 1466 static void snd_rawmidi_free_substreams(struct snd_rawmidi_str *stream) 1467 { 1468 struct snd_rawmidi_substream *substream; 1469 1470 while (!list_empty(&stream->substreams)) { 1471 substream = list_entry(stream->substreams.next, struct snd_rawmidi_substream, list); 1472 list_del(&substream->list); 1473 kfree(substream); 1474 } 1475 } 1476 1477 static int snd_rawmidi_free(struct snd_rawmidi *rmidi) 1478 { 1479 if (!rmidi) 1480 return 0; 1481 1482 snd_info_free_entry(rmidi->proc_entry); 1483 rmidi->proc_entry = NULL; 1484 mutex_lock(®ister_mutex); 1485 if (rmidi->ops && rmidi->ops->dev_unregister) 1486 rmidi->ops->dev_unregister(rmidi); 1487 mutex_unlock(®ister_mutex); 1488 1489 snd_rawmidi_free_substreams(&rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT]); 1490 snd_rawmidi_free_substreams(&rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT]); 1491 if (rmidi->private_free) 1492 rmidi->private_free(rmidi); 1493 kfree(rmidi); 1494 return 0; 1495 } 1496 1497 static int snd_rawmidi_dev_free(struct snd_device *device) 1498 { 1499 struct snd_rawmidi *rmidi = device->device_data; 1500 return snd_rawmidi_free(rmidi); 1501 } 1502 1503 #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE)) 1504 static void snd_rawmidi_dev_seq_free(struct snd_seq_device *device) 1505 { 1506 struct snd_rawmidi *rmidi = device->private_data; 1507 rmidi->seq_dev = NULL; 1508 } 1509 #endif 1510 1511 static int snd_rawmidi_dev_register(struct snd_device *device) 1512 { 1513 int err; 1514 struct snd_info_entry *entry; 1515 char name[16]; 1516 struct snd_rawmidi *rmidi = device->device_data; 1517 1518 if (rmidi->device >= SNDRV_RAWMIDI_DEVICES) 1519 return -ENOMEM; 1520 mutex_lock(®ister_mutex); 1521 if (snd_rawmidi_search(rmidi->card, rmidi->device)) { 1522 mutex_unlock(®ister_mutex); 1523 return -EBUSY; 1524 } 1525 list_add_tail(&rmidi->list, &snd_rawmidi_devices); 1526 sprintf(name, "midiC%iD%i", rmidi->card->number, rmidi->device); 1527 if ((err = snd_register_device(SNDRV_DEVICE_TYPE_RAWMIDI, 1528 rmidi->card, rmidi->device, 1529 &snd_rawmidi_f_ops, rmidi, name)) < 0) { 1530 snd_printk(KERN_ERR "unable to register rawmidi device %i:%i\n", rmidi->card->number, rmidi->device); 1531 list_del(&rmidi->list); 1532 mutex_unlock(®ister_mutex); 1533 return err; 1534 } 1535 if (rmidi->ops && rmidi->ops->dev_register && 1536 (err = rmidi->ops->dev_register(rmidi)) < 0) { 1537 snd_unregister_device(SNDRV_DEVICE_TYPE_RAWMIDI, rmidi->card, rmidi->device); 1538 list_del(&rmidi->list); 1539 mutex_unlock(®ister_mutex); 1540 return err; 1541 } 1542 #ifdef CONFIG_SND_OSSEMUL 1543 rmidi->ossreg = 0; 1544 if ((int)rmidi->device == midi_map[rmidi->card->number]) { 1545 if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, 1546 rmidi->card, 0, &snd_rawmidi_f_ops, 1547 rmidi, name) < 0) { 1548 snd_printk(KERN_ERR "unable to register OSS rawmidi device %i:%i\n", rmidi->card->number, 0); 1549 } else { 1550 rmidi->ossreg++; 1551 #ifdef SNDRV_OSS_INFO_DEV_MIDI 1552 snd_oss_info_register(SNDRV_OSS_INFO_DEV_MIDI, rmidi->card->number, rmidi->name); 1553 #endif 1554 } 1555 } 1556 if ((int)rmidi->device == amidi_map[rmidi->card->number]) { 1557 if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, 1558 rmidi->card, 1, &snd_rawmidi_f_ops, 1559 rmidi, name) < 0) { 1560 snd_printk(KERN_ERR "unable to register OSS rawmidi device %i:%i\n", rmidi->card->number, 1); 1561 } else { 1562 rmidi->ossreg++; 1563 } 1564 } 1565 #endif /* CONFIG_SND_OSSEMUL */ 1566 mutex_unlock(®ister_mutex); 1567 sprintf(name, "midi%d", rmidi->device); 1568 entry = snd_info_create_card_entry(rmidi->card, name, rmidi->card->proc_root); 1569 if (entry) { 1570 entry->private_data = rmidi; 1571 entry->c.text.read = snd_rawmidi_proc_info_read; 1572 if (snd_info_register(entry) < 0) { 1573 snd_info_free_entry(entry); 1574 entry = NULL; 1575 } 1576 } 1577 rmidi->proc_entry = entry; 1578 #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE)) 1579 if (!rmidi->ops || !rmidi->ops->dev_register) { /* own registration mechanism */ 1580 if (snd_seq_device_new(rmidi->card, rmidi->device, SNDRV_SEQ_DEV_ID_MIDISYNTH, 0, &rmidi->seq_dev) >= 0) { 1581 rmidi->seq_dev->private_data = rmidi; 1582 rmidi->seq_dev->private_free = snd_rawmidi_dev_seq_free; 1583 sprintf(rmidi->seq_dev->name, "MIDI %d-%d", rmidi->card->number, rmidi->device); 1584 snd_device_register(rmidi->card, rmidi->seq_dev); 1585 } 1586 } 1587 #endif 1588 return 0; 1589 } 1590 1591 static int snd_rawmidi_dev_disconnect(struct snd_device *device) 1592 { 1593 struct snd_rawmidi *rmidi = device->device_data; 1594 1595 mutex_lock(®ister_mutex); 1596 list_del_init(&rmidi->list); 1597 #ifdef CONFIG_SND_OSSEMUL 1598 if (rmidi->ossreg) { 1599 if ((int)rmidi->device == midi_map[rmidi->card->number]) { 1600 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, rmidi->card, 0); 1601 #ifdef SNDRV_OSS_INFO_DEV_MIDI 1602 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_MIDI, rmidi->card->number); 1603 #endif 1604 } 1605 if ((int)rmidi->device == amidi_map[rmidi->card->number]) 1606 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, rmidi->card, 1); 1607 rmidi->ossreg = 0; 1608 } 1609 #endif /* CONFIG_SND_OSSEMUL */ 1610 snd_unregister_device(SNDRV_DEVICE_TYPE_RAWMIDI, rmidi->card, rmidi->device); 1611 mutex_unlock(®ister_mutex); 1612 return 0; 1613 } 1614 1615 /** 1616 * snd_rawmidi_set_ops - set the rawmidi operators 1617 * @rmidi: the rawmidi instance 1618 * @stream: the stream direction, SNDRV_RAWMIDI_STREAM_XXX 1619 * @ops: the operator table 1620 * 1621 * Sets the rawmidi operators for the given stream direction. 1622 */ 1623 void snd_rawmidi_set_ops(struct snd_rawmidi *rmidi, int stream, 1624 struct snd_rawmidi_ops *ops) 1625 { 1626 struct snd_rawmidi_substream *substream; 1627 1628 list_for_each_entry(substream, &rmidi->streams[stream].substreams, list) 1629 substream->ops = ops; 1630 } 1631 1632 /* 1633 * ENTRY functions 1634 */ 1635 1636 static int __init alsa_rawmidi_init(void) 1637 { 1638 1639 snd_ctl_register_ioctl(snd_rawmidi_control_ioctl); 1640 snd_ctl_register_ioctl_compat(snd_rawmidi_control_ioctl); 1641 #ifdef CONFIG_SND_OSSEMUL 1642 { int i; 1643 /* check device map table */ 1644 for (i = 0; i < SNDRV_CARDS; i++) { 1645 if (midi_map[i] < 0 || midi_map[i] >= SNDRV_RAWMIDI_DEVICES) { 1646 snd_printk(KERN_ERR "invalid midi_map[%d] = %d\n", i, midi_map[i]); 1647 midi_map[i] = 0; 1648 } 1649 if (amidi_map[i] < 0 || amidi_map[i] >= SNDRV_RAWMIDI_DEVICES) { 1650 snd_printk(KERN_ERR "invalid amidi_map[%d] = %d\n", i, amidi_map[i]); 1651 amidi_map[i] = 1; 1652 } 1653 } 1654 } 1655 #endif /* CONFIG_SND_OSSEMUL */ 1656 return 0; 1657 } 1658 1659 static void __exit alsa_rawmidi_exit(void) 1660 { 1661 snd_ctl_unregister_ioctl(snd_rawmidi_control_ioctl); 1662 snd_ctl_unregister_ioctl_compat(snd_rawmidi_control_ioctl); 1663 } 1664 1665 module_init(alsa_rawmidi_init) 1666 module_exit(alsa_rawmidi_exit) 1667 1668 EXPORT_SYMBOL(snd_rawmidi_output_params); 1669 EXPORT_SYMBOL(snd_rawmidi_input_params); 1670 EXPORT_SYMBOL(snd_rawmidi_drop_output); 1671 EXPORT_SYMBOL(snd_rawmidi_drain_output); 1672 EXPORT_SYMBOL(snd_rawmidi_drain_input); 1673 EXPORT_SYMBOL(snd_rawmidi_receive); 1674 EXPORT_SYMBOL(snd_rawmidi_transmit_empty); 1675 EXPORT_SYMBOL(snd_rawmidi_transmit_peek); 1676 EXPORT_SYMBOL(snd_rawmidi_transmit_ack); 1677 EXPORT_SYMBOL(snd_rawmidi_transmit); 1678 EXPORT_SYMBOL(snd_rawmidi_new); 1679 EXPORT_SYMBOL(snd_rawmidi_set_ops); 1680 EXPORT_SYMBOL(snd_rawmidi_info_select); 1681 EXPORT_SYMBOL(snd_rawmidi_kernel_open); 1682 EXPORT_SYMBOL(snd_rawmidi_kernel_release); 1683 EXPORT_SYMBOL(snd_rawmidi_kernel_read); 1684 EXPORT_SYMBOL(snd_rawmidi_kernel_write); 1685