1/* 2 * sound/oss/mpu401.c 3 * 4 * The low level driver for Roland MPU-401 compatible Midi cards. 5 */ 6/* 7 * Copyright (C) by Hannu Savolainen 1993-1997 8 * 9 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL) 10 * Version 2 (June 1991). See the "COPYING" file distributed with this software 11 * for more info. 12 * 13 * 14 * Thomas Sailer ioctl code reworked (vmalloc/vfree removed) 15 * Alan Cox modularisation, use normal request_irq, use dev_id 16 * Bartlomiej Zolnierkiewicz removed some __init to allow using many drivers 17 * Chris Rankin Update the module-usage counter for the coprocessor 18 * Zwane Mwaikambo Changed attach/unload resource freeing 19 */ 20 21#include <linux/module.h> 22#include <linux/slab.h> 23#include <linux/init.h> 24#include <linux/interrupt.h> 25#include <linux/spinlock.h> 26#define USE_SEQ_MACROS 27#define USE_SIMPLE_MACROS 28 29#include "sound_config.h" 30 31#include "coproc.h" 32#include "mpu401.h" 33 34static int timer_mode = TMR_INTERNAL, timer_caps = TMR_INTERNAL; 35 36struct mpu_config 37{ 38 int base; /* 39 * I/O base 40 */ 41 int irq; 42 int opened; /* 43 * Open mode 44 */ 45 int devno; 46 int synthno; 47 int uart_mode; 48 int initialized; 49 int mode; 50#define MODE_MIDI 1 51#define MODE_SYNTH 2 52 unsigned char version, revision; 53 unsigned int capabilities; 54#define MPU_CAP_INTLG 0x10000000 55#define MPU_CAP_SYNC 0x00000010 56#define MPU_CAP_FSK 0x00000020 57#define MPU_CAP_CLS 0x00000040 58#define MPU_CAP_SMPTE 0x00000080 59#define MPU_CAP_2PORT 0x00000001 60 int timer_flag; 61 62#define MBUF_MAX 10 63#define BUFTEST(dc) if (dc->m_ptr >= MBUF_MAX || dc->m_ptr < 0) \ 64 {printk( "MPU: Invalid buffer pointer %d/%d, s=%d\n", dc->m_ptr, dc->m_left, dc->m_state);dc->m_ptr--;} 65 int m_busy; 66 unsigned char m_buf[MBUF_MAX]; 67 int m_ptr; 68 int m_state; 69 int m_left; 70 unsigned char last_status; 71 void (*inputintr) (int dev, unsigned char data); 72 int shared_irq; 73 int *osp; 74 spinlock_t lock; 75 }; 76 77#define DATAPORT(base) (base) 78#define COMDPORT(base) (base+1) 79#define STATPORT(base) (base+1) 80 81 82static void mpu401_close(int dev); 83 84static inline int mpu401_status(struct mpu_config *devc) 85{ 86 return inb(STATPORT(devc->base)); 87} 88 89#define input_avail(devc) (!(mpu401_status(devc)&INPUT_AVAIL)) 90#define output_ready(devc) (!(mpu401_status(devc)&OUTPUT_READY)) 91 92static inline void write_command(struct mpu_config *devc, unsigned char cmd) 93{ 94 outb(cmd, COMDPORT(devc->base)); 95} 96 97static inline int read_data(struct mpu_config *devc) 98{ 99 return inb(DATAPORT(devc->base)); 100} 101 102static inline void write_data(struct mpu_config *devc, unsigned char byte) 103{ 104 outb(byte, DATAPORT(devc->base)); 105} 106 107#define OUTPUT_READY 0x40 108#define INPUT_AVAIL 0x80 109#define MPU_ACK 0xFE 110#define MPU_RESET 0xFF 111#define UART_MODE_ON 0x3F 112 113static struct mpu_config dev_conf[MAX_MIDI_DEV]; 114 115static int n_mpu_devs; 116 117static int reset_mpu401(struct mpu_config *devc); 118static void set_uart_mode(int dev, struct mpu_config *devc, int arg); 119 120static int mpu_timer_init(int midi_dev); 121static void mpu_timer_interrupt(void); 122static void timer_ext_event(struct mpu_config *devc, int event, int parm); 123 124static struct synth_info mpu_synth_info_proto = { 125 "MPU-401 MIDI interface", 126 0, 127 SYNTH_TYPE_MIDI, 128 MIDI_TYPE_MPU401, 129 0, 128, 130 0, 128, 131 SYNTH_CAP_INPUT 132}; 133 134static struct synth_info mpu_synth_info[MAX_MIDI_DEV]; 135 136/* 137 * States for the input scanner 138 */ 139 140#define ST_INIT 0 /* Ready for timing byte or msg */ 141#define ST_TIMED 1 /* Leading timing byte rcvd */ 142#define ST_DATABYTE 2 /* Waiting for (nr_left) data bytes */ 143 144#define ST_SYSMSG 100 /* System message (sysx etc). */ 145#define ST_SYSEX 101 /* System exclusive msg */ 146#define ST_MTC 102 /* Midi Time Code (MTC) qframe msg */ 147#define ST_SONGSEL 103 /* Song select */ 148#define ST_SONGPOS 104 /* Song position pointer */ 149 150static unsigned char len_tab[] = /* # of data bytes following a status 151 */ 152{ 153 2, /* 8x */ 154 2, /* 9x */ 155 2, /* Ax */ 156 2, /* Bx */ 157 1, /* Cx */ 158 1, /* Dx */ 159 2, /* Ex */ 160 0 /* Fx */ 161}; 162 163#define STORE(cmd) \ 164{ \ 165 int len; \ 166 unsigned char obuf[8]; \ 167 cmd; \ 168 seq_input_event(obuf, len); \ 169} 170 171#define _seqbuf obuf 172#define _seqbufptr 0 173#define _SEQ_ADVBUF(x) len=x 174 175static int mpu_input_scanner(struct mpu_config *devc, unsigned char midic) 176{ 177 178 switch (devc->m_state) 179 { 180 case ST_INIT: 181 switch (midic) 182 { 183 case 0xf8: 184 /* Timer overflow */ 185 break; 186 187 case 0xfc: 188 printk("<all end>"); 189 break; 190 191 case 0xfd: 192 if (devc->timer_flag) 193 mpu_timer_interrupt(); 194 break; 195 196 case 0xfe: 197 return MPU_ACK; 198 199 case 0xf0: 200 case 0xf1: 201 case 0xf2: 202 case 0xf3: 203 case 0xf4: 204 case 0xf5: 205 case 0xf6: 206 case 0xf7: 207 printk("<Trk data rq #%d>", midic & 0x0f); 208 break; 209 210 case 0xf9: 211 printk("<conductor rq>"); 212 break; 213 214 case 0xff: 215 devc->m_state = ST_SYSMSG; 216 break; 217 218 default: 219 if (midic <= 0xef) 220 { 221 /* printk( "mpu time: %d ", midic); */ 222 devc->m_state = ST_TIMED; 223 } 224 else 225 printk("<MPU: Unknown event %02x> ", midic); 226 } 227 break; 228 229 case ST_TIMED: 230 { 231 int msg = ((int) (midic & 0xf0) >> 4); 232 233 devc->m_state = ST_DATABYTE; 234 235 if (msg < 8) /* Data byte */ 236 { 237 /* printk( "midi msg (running status) "); */ 238 msg = ((int) (devc->last_status & 0xf0) >> 4); 239 msg -= 8; 240 devc->m_left = len_tab[msg] - 1; 241 242 devc->m_ptr = 2; 243 devc->m_buf[0] = devc->last_status; 244 devc->m_buf[1] = midic; 245 246 if (devc->m_left <= 0) 247 { 248 devc->m_state = ST_INIT; 249 do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr); 250 devc->m_ptr = 0; 251 } 252 } 253 else if (msg == 0xf) /* MPU MARK */ 254 { 255 devc->m_state = ST_INIT; 256 257 switch (midic) 258 { 259 case 0xf8: 260 /* printk( "NOP "); */ 261 break; 262 263 case 0xf9: 264 /* printk( "meas end "); */ 265 break; 266 267 case 0xfc: 268 /* printk( "data end "); */ 269 break; 270 271 default: 272 printk("Unknown MPU mark %02x\n", midic); 273 } 274 } 275 else 276 { 277 devc->last_status = midic; 278 /* printk( "midi msg "); */ 279 msg -= 8; 280 devc->m_left = len_tab[msg]; 281 282 devc->m_ptr = 1; 283 devc->m_buf[0] = midic; 284 285 if (devc->m_left <= 0) 286 { 287 devc->m_state = ST_INIT; 288 do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr); 289 devc->m_ptr = 0; 290 } 291 } 292 } 293 break; 294 295 case ST_SYSMSG: 296 switch (midic) 297 { 298 case 0xf0: 299 printk("<SYX>"); 300 devc->m_state = ST_SYSEX; 301 break; 302 303 case 0xf1: 304 devc->m_state = ST_MTC; 305 break; 306 307 case 0xf2: 308 devc->m_state = ST_SONGPOS; 309 devc->m_ptr = 0; 310 break; 311 312 case 0xf3: 313 devc->m_state = ST_SONGSEL; 314 break; 315 316 case 0xf6: 317 /* printk( "tune_request\n"); */ 318 devc->m_state = ST_INIT; 319 320 /* 321 * Real time messages 322 */ 323 case 0xf8: 324 /* midi clock */ 325 devc->m_state = ST_INIT; 326 timer_ext_event(devc, TMR_CLOCK, 0); 327 break; 328 329 case 0xfA: 330 devc->m_state = ST_INIT; 331 timer_ext_event(devc, TMR_START, 0); 332 break; 333 334 case 0xFB: 335 devc->m_state = ST_INIT; 336 timer_ext_event(devc, TMR_CONTINUE, 0); 337 break; 338 339 case 0xFC: 340 devc->m_state = ST_INIT; 341 timer_ext_event(devc, TMR_STOP, 0); 342 break; 343 344 case 0xFE: 345 /* active sensing */ 346 devc->m_state = ST_INIT; 347 break; 348 349 case 0xff: 350 /* printk( "midi hard reset"); */ 351 devc->m_state = ST_INIT; 352 break; 353 354 default: 355 printk("unknown MIDI sysmsg %0x\n", midic); 356 devc->m_state = ST_INIT; 357 } 358 break; 359 360 case ST_MTC: 361 devc->m_state = ST_INIT; 362 printk("MTC frame %x02\n", midic); 363 break; 364 365 case ST_SYSEX: 366 if (midic == 0xf7) 367 { 368 printk("<EOX>"); 369 devc->m_state = ST_INIT; 370 } 371 else 372 printk("%02x ", midic); 373 break; 374 375 case ST_SONGPOS: 376 BUFTEST(devc); 377 devc->m_buf[devc->m_ptr++] = midic; 378 if (devc->m_ptr == 2) 379 { 380 devc->m_state = ST_INIT; 381 devc->m_ptr = 0; 382 timer_ext_event(devc, TMR_SPP, 383 ((devc->m_buf[1] & 0x7f) << 7) | 384 (devc->m_buf[0] & 0x7f)); 385 } 386 break; 387 388 case ST_DATABYTE: 389 BUFTEST(devc); 390 devc->m_buf[devc->m_ptr++] = midic; 391 if ((--devc->m_left) <= 0) 392 { 393 devc->m_state = ST_INIT; 394 do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr); 395 devc->m_ptr = 0; 396 } 397 break; 398 399 default: 400 printk("Bad state %d ", devc->m_state); 401 devc->m_state = ST_INIT; 402 } 403 return 1; 404} 405 406static void mpu401_input_loop(struct mpu_config *devc) 407{ 408 unsigned long flags; 409 int busy; 410 int n; 411 412 spin_lock_irqsave(&devc->lock,flags); 413 busy = devc->m_busy; 414 devc->m_busy = 1; 415 spin_unlock_irqrestore(&devc->lock,flags); 416 417 if (busy) /* Already inside the scanner */ 418 return; 419 420 n = 50; 421 422 while (input_avail(devc) && n-- > 0) 423 { 424 unsigned char c = read_data(devc); 425 426 if (devc->mode == MODE_SYNTH) 427 { 428 mpu_input_scanner(devc, c); 429 } 430 else if (devc->opened & OPEN_READ && devc->inputintr != NULL) 431 devc->inputintr(devc->devno, c); 432 } 433 devc->m_busy = 0; 434} 435 436static irqreturn_t mpuintr(int irq, void *dev_id) 437{ 438 struct mpu_config *devc; 439 int dev = (int)(unsigned long) dev_id; 440 int handled = 0; 441 442 devc = &dev_conf[dev]; 443 444 if (input_avail(devc)) 445 { 446 handled = 1; 447 if (devc->base != 0 && (devc->opened & OPEN_READ || devc->mode == MODE_SYNTH)) 448 mpu401_input_loop(devc); 449 else 450 { 451 /* Dummy read (just to acknowledge the interrupt) */ 452 read_data(devc); 453 } 454 } 455 return IRQ_RETVAL(handled); 456} 457 458static int mpu401_open(int dev, int mode, 459 void (*input) (int dev, unsigned char data), 460 void (*output) (int dev) 461) 462{ 463 int err; 464 struct mpu_config *devc; 465 struct coproc_operations *coprocessor; 466 467 if (dev < 0 || dev >= num_midis || midi_devs[dev] == NULL) 468 return -ENXIO; 469 470 devc = &dev_conf[dev]; 471 472 if (devc->opened) 473 return -EBUSY; 474 /* 475 * Verify that the device is really running. 476 * Some devices (such as Ensoniq SoundScape don't 477 * work before the on board processor (OBP) is initialized 478 * by downloading its microcode. 479 */ 480 481 if (!devc->initialized) 482 { 483 if (mpu401_status(devc) == 0xff) /* Bus float */ 484 { 485 printk(KERN_ERR "mpu401: Device not initialized properly\n"); 486 return -EIO; 487 } 488 reset_mpu401(devc); 489 } 490 491 if ( (coprocessor = midi_devs[dev]->coproc) != NULL ) 492 { 493 if (!try_module_get(coprocessor->owner)) { 494 mpu401_close(dev); 495 return -ENODEV; 496 } 497 498 if ((err = coprocessor->open(coprocessor->devc, COPR_MIDI)) < 0) 499 { 500 printk(KERN_WARNING "MPU-401: Can't access coprocessor device\n"); 501 mpu401_close(dev); 502 return err; 503 } 504 } 505 506 set_uart_mode(dev, devc, 1); 507 devc->mode = MODE_MIDI; 508 devc->synthno = 0; 509 510 mpu401_input_loop(devc); 511 512 devc->inputintr = input; 513 devc->opened = mode; 514 515 return 0; 516} 517 518static void mpu401_close(int dev) 519{ 520 struct mpu_config *devc; 521 struct coproc_operations *coprocessor; 522 523 devc = &dev_conf[dev]; 524 if (devc->uart_mode) 525 reset_mpu401(devc); /* 526 * This disables the UART mode 527 */ 528 devc->mode = 0; 529 devc->inputintr = NULL; 530 531 coprocessor = midi_devs[dev]->coproc; 532 if (coprocessor) { 533 coprocessor->close(coprocessor->devc, COPR_MIDI); 534 module_put(coprocessor->owner); 535 } 536 devc->opened = 0; 537} 538 539static int mpu401_out(int dev, unsigned char midi_byte) 540{ 541 int timeout; 542 unsigned long flags; 543 544 struct mpu_config *devc; 545 546 devc = &dev_conf[dev]; 547 548 /* 549 * Sometimes it takes about 30000 loops before the output becomes ready 550 * (After reset). Normally it takes just about 10 loops. 551 */ 552 553 for (timeout = 30000; timeout > 0 && !output_ready(devc); timeout--); 554 555 spin_lock_irqsave(&devc->lock,flags); 556 if (!output_ready(devc)) 557 { 558 printk(KERN_WARNING "mpu401: Send data timeout\n"); 559 spin_unlock_irqrestore(&devc->lock,flags); 560 return 0; 561 } 562 write_data(devc, midi_byte); 563 spin_unlock_irqrestore(&devc->lock,flags); 564 return 1; 565} 566 567static int mpu401_command(int dev, mpu_command_rec * cmd) 568{ 569 int i, timeout, ok; 570 int ret = 0; 571 unsigned long flags; 572 struct mpu_config *devc; 573 574 devc = &dev_conf[dev]; 575 576 if (devc->uart_mode) /* 577 * Not possible in UART mode 578 */ 579 { 580 printk(KERN_WARNING "mpu401: commands not possible in the UART mode\n"); 581 return -EINVAL; 582 } 583 /* 584 * Test for input since pending input seems to block the output. 585 */ 586 if (input_avail(devc)) 587 mpu401_input_loop(devc); 588 589 /* 590 * Sometimes it takes about 50000 loops before the output becomes ready 591 * (After reset). Normally it takes just about 10 loops. 592 */ 593 594 timeout = 50000; 595retry: 596 if (timeout-- <= 0) 597 { 598 printk(KERN_WARNING "mpu401: Command (0x%x) timeout\n", (int) cmd->cmd); 599 return -EIO; 600 } 601 spin_lock_irqsave(&devc->lock,flags); 602 603 if (!output_ready(devc)) 604 { 605 spin_unlock_irqrestore(&devc->lock,flags); 606 goto retry; 607 } 608 write_command(devc, cmd->cmd); 609 610 ok = 0; 611 for (timeout = 50000; timeout > 0 && !ok; timeout--) 612 { 613 if (input_avail(devc)) 614 { 615 if (devc->opened && devc->mode == MODE_SYNTH) 616 { 617 if (mpu_input_scanner(devc, read_data(devc)) == MPU_ACK) 618 ok = 1; 619 } 620 else 621 { 622 /* Device is not currently open. Use simpler method */ 623 if (read_data(devc) == MPU_ACK) 624 ok = 1; 625 } 626 } 627 } 628 if (!ok) 629 { 630 spin_unlock_irqrestore(&devc->lock,flags); 631 return -EIO; 632 } 633 if (cmd->nr_args) 634 { 635 for (i = 0; i < cmd->nr_args; i++) 636 { 637 for (timeout = 3000; timeout > 0 && !output_ready(devc); timeout--); 638 639 if (!mpu401_out(dev, cmd->data[i])) 640 { 641 spin_unlock_irqrestore(&devc->lock,flags); 642 printk(KERN_WARNING "mpu401: Command (0x%x), parm send failed.\n", (int) cmd->cmd); 643 return -EIO; 644 } 645 } 646 } 647 ret = 0; 648 cmd->data[0] = 0; 649 650 if (cmd->nr_returns) 651 { 652 for (i = 0; i < cmd->nr_returns; i++) 653 { 654 ok = 0; 655 for (timeout = 5000; timeout > 0 && !ok; timeout--) 656 if (input_avail(devc)) 657 { 658 cmd->data[i] = read_data(devc); 659 ok = 1; 660 } 661 if (!ok) 662 { 663 spin_unlock_irqrestore(&devc->lock,flags); 664 return -EIO; 665 } 666 } 667 } 668 spin_unlock_irqrestore(&devc->lock,flags); 669 return ret; 670} 671 672static int mpu_cmd(int dev, int cmd, int data) 673{ 674 int ret; 675 676 static mpu_command_rec rec; 677 678 rec.cmd = cmd & 0xff; 679 rec.nr_args = ((cmd & 0xf0) == 0xE0); 680 rec.nr_returns = ((cmd & 0xf0) == 0xA0); 681 rec.data[0] = data & 0xff; 682 683 if ((ret = mpu401_command(dev, &rec)) < 0) 684 return ret; 685 return (unsigned char) rec.data[0]; 686} 687 688static int mpu401_prefix_cmd(int dev, unsigned char status) 689{ 690 struct mpu_config *devc = &dev_conf[dev]; 691 692 if (devc->uart_mode) 693 return 1; 694 695 if (status < 0xf0) 696 { 697 if (mpu_cmd(dev, 0xD0, 0) < 0) 698 return 0; 699 return 1; 700 } 701 switch (status) 702 { 703 case 0xF0: 704 if (mpu_cmd(dev, 0xDF, 0) < 0) 705 return 0; 706 return 1; 707 708 default: 709 return 0; 710 } 711} 712 713static int mpu401_start_read(int dev) 714{ 715 return 0; 716} 717 718static int mpu401_end_read(int dev) 719{ 720 return 0; 721} 722 723static int mpu401_ioctl(int dev, unsigned cmd, void __user *arg) 724{ 725 struct mpu_config *devc; 726 mpu_command_rec rec; 727 int val, ret; 728 729 devc = &dev_conf[dev]; 730 switch (cmd) 731 { 732 case SNDCTL_MIDI_MPUMODE: 733 if (!(devc->capabilities & MPU_CAP_INTLG)) { /* No intelligent mode */ 734 printk(KERN_WARNING "mpu401: Intelligent mode not supported by the HW\n"); 735 return -EINVAL; 736 } 737 if (get_user(val, (int __user *)arg)) 738 return -EFAULT; 739 set_uart_mode(dev, devc, !val); 740 return 0; 741 742 case SNDCTL_MIDI_MPUCMD: 743 if (copy_from_user(&rec, arg, sizeof(rec))) 744 return -EFAULT; 745 if ((ret = mpu401_command(dev, &rec)) < 0) 746 return ret; 747 if (copy_to_user(arg, &rec, sizeof(rec))) 748 return -EFAULT; 749 return 0; 750 751 default: 752 return -EINVAL; 753 } 754} 755 756static void mpu401_kick(int dev) 757{ 758} 759 760static int mpu401_buffer_status(int dev) 761{ 762 return 0; /* 763 * No data in buffers 764 */ 765} 766 767static int mpu_synth_ioctl(int dev, unsigned int cmd, void __user *arg) 768{ 769 int midi_dev; 770 struct mpu_config *devc; 771 772 midi_dev = synth_devs[dev]->midi_dev; 773 774 if (midi_dev < 0 || midi_dev >= num_midis || midi_devs[midi_dev] == NULL) 775 return -ENXIO; 776 777 devc = &dev_conf[midi_dev]; 778 779 switch (cmd) 780 { 781 782 case SNDCTL_SYNTH_INFO: 783 if (copy_to_user(arg, &mpu_synth_info[midi_dev], 784 sizeof(struct synth_info))) 785 return -EFAULT; 786 return 0; 787 788 case SNDCTL_SYNTH_MEMAVL: 789 return 0x7fffffff; 790 791 default: 792 return -EINVAL; 793 } 794} 795 796static int mpu_synth_open(int dev, int mode) 797{ 798 int midi_dev, err; 799 struct mpu_config *devc; 800 struct coproc_operations *coprocessor; 801 802 midi_dev = synth_devs[dev]->midi_dev; 803 804 if (midi_dev < 0 || midi_dev > num_midis || midi_devs[midi_dev] == NULL) 805 return -ENXIO; 806 807 devc = &dev_conf[midi_dev]; 808 809 /* 810 * Verify that the device is really running. 811 * Some devices (such as Ensoniq SoundScape don't 812 * work before the on board processor (OBP) is initialized 813 * by downloading its microcode. 814 */ 815 816 if (!devc->initialized) 817 { 818 if (mpu401_status(devc) == 0xff) /* Bus float */ 819 { 820 printk(KERN_ERR "mpu401: Device not initialized properly\n"); 821 return -EIO; 822 } 823 reset_mpu401(devc); 824 } 825 if (devc->opened) 826 return -EBUSY; 827 devc->mode = MODE_SYNTH; 828 devc->synthno = dev; 829 830 devc->inputintr = NULL; 831 832 coprocessor = midi_devs[midi_dev]->coproc; 833 if (coprocessor) { 834 if (!try_module_get(coprocessor->owner)) 835 return -ENODEV; 836 837 if ((err = coprocessor->open(coprocessor->devc, COPR_MIDI)) < 0) 838 { 839 printk(KERN_WARNING "mpu401: Can't access coprocessor device\n"); 840 return err; 841 } 842 } 843 devc->opened = mode; 844 reset_mpu401(devc); 845 846 if (mode & OPEN_READ) 847 { 848 mpu_cmd(midi_dev, 0x8B, 0); /* Enable data in stop mode */ 849 mpu_cmd(midi_dev, 0x34, 0); /* Return timing bytes in stop mode */ 850 mpu_cmd(midi_dev, 0x87, 0); /* Enable pitch & controller */ 851 } 852 return 0; 853} 854 855static void mpu_synth_close(int dev) 856{ 857 int midi_dev; 858 struct mpu_config *devc; 859 struct coproc_operations *coprocessor; 860 861 midi_dev = synth_devs[dev]->midi_dev; 862 863 devc = &dev_conf[midi_dev]; 864 mpu_cmd(midi_dev, 0x15, 0); /* Stop recording, playback and MIDI */ 865 mpu_cmd(midi_dev, 0x8a, 0); /* Disable data in stopped mode */ 866 867 devc->inputintr = NULL; 868 869 coprocessor = midi_devs[midi_dev]->coproc; 870 if (coprocessor) { 871 coprocessor->close(coprocessor->devc, COPR_MIDI); 872 module_put(coprocessor->owner); 873 } 874 devc->opened = 0; 875 devc->mode = 0; 876} 877 878#define MIDI_SYNTH_NAME "MPU-401 UART Midi" 879#define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT 880#include "midi_synth.h" 881 882static struct synth_operations mpu401_synth_proto = 883{ 884 .owner = THIS_MODULE, 885 .id = "MPU401", 886 .info = NULL, 887 .midi_dev = 0, 888 .synth_type = SYNTH_TYPE_MIDI, 889 .synth_subtype = 0, 890 .open = mpu_synth_open, 891 .close = mpu_synth_close, 892 .ioctl = mpu_synth_ioctl, 893 .kill_note = midi_synth_kill_note, 894 .start_note = midi_synth_start_note, 895 .set_instr = midi_synth_set_instr, 896 .reset = midi_synth_reset, 897 .hw_control = midi_synth_hw_control, 898 .load_patch = midi_synth_load_patch, 899 .aftertouch = midi_synth_aftertouch, 900 .controller = midi_synth_controller, 901 .panning = midi_synth_panning, 902 .bender = midi_synth_bender, 903 .setup_voice = midi_synth_setup_voice, 904 .send_sysex = midi_synth_send_sysex 905}; 906 907static struct synth_operations *mpu401_synth_operations[MAX_MIDI_DEV]; 908 909static struct midi_operations mpu401_midi_proto = 910{ 911 .owner = THIS_MODULE, 912 .info = {"MPU-401 Midi", 0, MIDI_CAP_MPU401, SNDCARD_MPU401}, 913 .in_info = {0}, 914 .open = mpu401_open, 915 .close = mpu401_close, 916 .ioctl = mpu401_ioctl, 917 .outputc = mpu401_out, 918 .start_read = mpu401_start_read, 919 .end_read = mpu401_end_read, 920 .kick = mpu401_kick, 921 .buffer_status = mpu401_buffer_status, 922 .prefix_cmd = mpu401_prefix_cmd 923}; 924 925static struct midi_operations mpu401_midi_operations[MAX_MIDI_DEV]; 926 927static void mpu401_chk_version(int n, struct mpu_config *devc) 928{ 929 int tmp; 930 931 devc->version = devc->revision = 0; 932 933 tmp = mpu_cmd(n, 0xAC, 0); 934 if (tmp < 0) 935 return; 936 if ((tmp & 0xf0) > 0x20) /* Why it's larger than 2.x ??? */ 937 return; 938 devc->version = tmp; 939 940 if ((tmp = mpu_cmd(n, 0xAD, 0)) < 0) { 941 devc->version = 0; 942 return; 943 } 944 devc->revision = tmp; 945} 946 947int attach_mpu401(struct address_info *hw_config, struct module *owner) 948{ 949 unsigned long flags; 950 char revision_char; 951 952 int m, ret; 953 struct mpu_config *devc; 954 955 hw_config->slots[1] = -1; 956 m = sound_alloc_mididev(); 957 if (m == -1) 958 { 959 printk(KERN_WARNING "MPU-401: Too many midi devices detected\n"); 960 ret = -ENOMEM; 961 goto out_err; 962 } 963 devc = &dev_conf[m]; 964 devc->base = hw_config->io_base; 965 devc->osp = hw_config->osp; 966 devc->irq = hw_config->irq; 967 devc->opened = 0; 968 devc->uart_mode = 0; 969 devc->initialized = 0; 970 devc->version = 0; 971 devc->revision = 0; 972 devc->capabilities = 0; 973 devc->timer_flag = 0; 974 devc->m_busy = 0; 975 devc->m_state = ST_INIT; 976 devc->shared_irq = hw_config->always_detect; 977 devc->irq = hw_config->irq; 978 spin_lock_init(&devc->lock); 979 980 if (devc->irq < 0) 981 { 982 devc->irq *= -1; 983 devc->shared_irq = 1; 984 } 985 986 if (!hw_config->always_detect) 987 { 988 /* Verify the hardware again */ 989 if (!reset_mpu401(devc)) 990 { 991 printk(KERN_WARNING "mpu401: Device didn't respond\n"); 992 ret = -ENODEV; 993 goto out_mididev; 994 } 995 if (!devc->shared_irq) 996 { 997 if (request_irq(devc->irq, mpuintr, 0, "mpu401", 998 hw_config) < 0) 999 { 1000 printk(KERN_WARNING "mpu401: Failed to allocate IRQ%d\n", devc->irq); 1001 ret = -ENOMEM; 1002 goto out_mididev; 1003 } 1004 } 1005 spin_lock_irqsave(&devc->lock,flags); 1006 mpu401_chk_version(m, devc); 1007 if (devc->version == 0) 1008 mpu401_chk_version(m, devc); 1009 spin_unlock_irqrestore(&devc->lock, flags); 1010 } 1011 1012 if (devc->version != 0) 1013 if (mpu_cmd(m, 0xC5, 0) >= 0) /* Set timebase OK */ 1014 if (mpu_cmd(m, 0xE0, 120) >= 0) /* Set tempo OK */ 1015 devc->capabilities |= MPU_CAP_INTLG; /* Supports intelligent mode */ 1016 1017 1018 mpu401_synth_operations[m] = kmalloc(sizeof(struct synth_operations), GFP_KERNEL); 1019 1020 if (mpu401_synth_operations[m] == NULL) 1021 { 1022 printk(KERN_ERR "mpu401: Can't allocate memory\n"); 1023 ret = -ENOMEM; 1024 goto out_irq; 1025 } 1026 if (!(devc->capabilities & MPU_CAP_INTLG)) /* No intelligent mode */ 1027 { 1028 memcpy((char *) mpu401_synth_operations[m], 1029 (char *) &std_midi_synth, 1030 sizeof(struct synth_operations)); 1031 } 1032 else 1033 { 1034 memcpy((char *) mpu401_synth_operations[m], 1035 (char *) &mpu401_synth_proto, 1036 sizeof(struct synth_operations)); 1037 } 1038 if (owner) 1039 mpu401_synth_operations[m]->owner = owner; 1040 1041 memcpy((char *) &mpu401_midi_operations[m], 1042 (char *) &mpu401_midi_proto, 1043 sizeof(struct midi_operations)); 1044 1045 mpu401_midi_operations[m].converter = mpu401_synth_operations[m]; 1046 1047 memcpy((char *) &mpu_synth_info[m], 1048 (char *) &mpu_synth_info_proto, 1049 sizeof(struct synth_info)); 1050 1051 n_mpu_devs++; 1052 1053 if (devc->version == 0x20 && devc->revision >= 0x07) /* MusicQuest interface */ 1054 { 1055 int ports = (devc->revision & 0x08) ? 32 : 16; 1056 1057 devc->capabilities |= MPU_CAP_SYNC | MPU_CAP_SMPTE | 1058 MPU_CAP_CLS | MPU_CAP_2PORT; 1059 1060 revision_char = (devc->revision == 0x7f) ? 'M' : ' '; 1061 sprintf(mpu_synth_info[m].name, "MQX-%d%c MIDI Interface #%d", 1062 ports, 1063 revision_char, 1064 n_mpu_devs); 1065 } 1066 else 1067 { 1068 revision_char = devc->revision ? devc->revision + '@' : ' '; 1069 if ((int) devc->revision > ('Z' - '@')) 1070 revision_char = '+'; 1071 1072 devc->capabilities |= MPU_CAP_SYNC | MPU_CAP_FSK; 1073 1074 if (hw_config->name) 1075 sprintf(mpu_synth_info[m].name, "%s (MPU401)", hw_config->name); 1076 else 1077 sprintf(mpu_synth_info[m].name, 1078 "MPU-401 %d.%d%c MIDI #%d", 1079 (int) (devc->version & 0xf0) >> 4, 1080 devc->version & 0x0f, 1081 revision_char, 1082 n_mpu_devs); 1083 } 1084 1085 strcpy(mpu401_midi_operations[m].info.name, 1086 mpu_synth_info[m].name); 1087 1088 conf_printf(mpu_synth_info[m].name, hw_config); 1089 1090 mpu401_synth_operations[m]->midi_dev = devc->devno = m; 1091 mpu401_synth_operations[devc->devno]->info = &mpu_synth_info[devc->devno]; 1092 1093 if (devc->capabilities & MPU_CAP_INTLG) /* Intelligent mode */ 1094 hw_config->slots[2] = mpu_timer_init(m); 1095 1096 midi_devs[m] = &mpu401_midi_operations[devc->devno]; 1097 1098 if (owner) 1099 midi_devs[m]->owner = owner; 1100 1101 hw_config->slots[1] = m; 1102 sequencer_init(); 1103 1104 return 0; 1105 1106out_irq: 1107 free_irq(devc->irq, hw_config); 1108out_mididev: 1109 sound_unload_mididev(m); 1110out_err: 1111 release_region(hw_config->io_base, 2); 1112 return ret; 1113} 1114 1115static int reset_mpu401(struct mpu_config *devc) 1116{ 1117 unsigned long flags; 1118 int ok, timeout, n; 1119 int timeout_limit; 1120 1121 /* 1122 * Send the RESET command. Try again if no success at the first time. 1123 * (If the device is in the UART mode, it will not ack the reset cmd). 1124 */ 1125 1126 ok = 0; 1127 1128 timeout_limit = devc->initialized ? 30000 : 100000; 1129 devc->initialized = 1; 1130 1131 for (n = 0; n < 2 && !ok; n++) 1132 { 1133 for (timeout = timeout_limit; timeout > 0 && !ok; timeout--) 1134 ok = output_ready(devc); 1135 1136 write_command(devc, MPU_RESET); /* 1137 * Send MPU-401 RESET Command 1138 */ 1139 1140 /* 1141 * Wait at least 25 msec. This method is not accurate so let's make the 1142 * loop bit longer. Cannot sleep since this is called during boot. 1143 */ 1144 1145 for (timeout = timeout_limit * 2; timeout > 0 && !ok; timeout--) 1146 { 1147 spin_lock_irqsave(&devc->lock,flags); 1148 if (input_avail(devc)) 1149 if (read_data(devc) == MPU_ACK) 1150 ok = 1; 1151 spin_unlock_irqrestore(&devc->lock,flags); 1152 } 1153 1154 } 1155 1156 devc->m_state = ST_INIT; 1157 devc->m_ptr = 0; 1158 devc->m_left = 0; 1159 devc->last_status = 0; 1160 devc->uart_mode = 0; 1161 1162 return ok; 1163} 1164 1165static void set_uart_mode(int dev, struct mpu_config *devc, int arg) 1166{ 1167 if (!arg && (devc->capabilities & MPU_CAP_INTLG)) 1168 return; 1169 if ((devc->uart_mode == 0) == (arg == 0)) 1170 return; /* Already set */ 1171 reset_mpu401(devc); /* This exits the uart mode */ 1172 1173 if (arg) 1174 { 1175 if (mpu_cmd(dev, UART_MODE_ON, 0) < 0) 1176 { 1177 printk(KERN_ERR "mpu401: Can't enter UART mode\n"); 1178 devc->uart_mode = 0; 1179 return; 1180 } 1181 } 1182 devc->uart_mode = arg; 1183 1184} 1185 1186int probe_mpu401(struct address_info *hw_config, struct resource *ports) 1187{ 1188 int ok = 0; 1189 struct mpu_config tmp_devc; 1190 1191 tmp_devc.base = hw_config->io_base; 1192 tmp_devc.irq = hw_config->irq; 1193 tmp_devc.initialized = 0; 1194 tmp_devc.opened = 0; 1195 tmp_devc.osp = hw_config->osp; 1196 1197 if (hw_config->always_detect) 1198 return 1; 1199 1200 if (inb(hw_config->io_base + 1) == 0xff) 1201 { 1202 DDB(printk("MPU401: Port %x looks dead.\n", hw_config->io_base)); 1203 return 0; /* Just bus float? */ 1204 } 1205 ok = reset_mpu401(&tmp_devc); 1206 1207 if (!ok) 1208 { 1209 DDB(printk("MPU401: Reset failed on port %x\n", hw_config->io_base)); 1210 } 1211 return ok; 1212} 1213 1214void unload_mpu401(struct address_info *hw_config) 1215{ 1216 void *p; 1217 int n=hw_config->slots[1]; 1218 1219 if (n != -1) { 1220 release_region(hw_config->io_base, 2); 1221 if (hw_config->always_detect == 0 && hw_config->irq > 0) 1222 free_irq(hw_config->irq, hw_config); 1223 p=mpu401_synth_operations[n]; 1224 sound_unload_mididev(n); 1225 sound_unload_timerdev(hw_config->slots[2]); 1226 kfree(p); 1227 } 1228} 1229 1230/***************************************************** 1231 * Timer stuff 1232 ****************************************************/ 1233 1234static volatile int timer_initialized = 0, timer_open = 0, tmr_running = 0; 1235static volatile int curr_tempo, curr_timebase, hw_timebase; 1236static int max_timebase = 8; /* 8*24=192 ppqn */ 1237static volatile unsigned long next_event_time; 1238static volatile unsigned long curr_ticks, curr_clocks; 1239static unsigned long prev_event_time; 1240static int metronome_mode; 1241 1242static unsigned long clocks2ticks(unsigned long clocks) 1243{ 1244 /* 1245 * The MPU-401 supports just a limited set of possible timebase values. 1246 * Since the applications require more choices, the driver has to 1247 * program the HW to do its best and to convert between the HW and 1248 * actual timebases. 1249 */ 1250 return ((clocks * curr_timebase) + (hw_timebase / 2)) / hw_timebase; 1251} 1252 1253static void set_timebase(int midi_dev, int val) 1254{ 1255 int hw_val; 1256 1257 if (val < 48) 1258 val = 48; 1259 if (val > 1000) 1260 val = 1000; 1261 1262 hw_val = val; 1263 hw_val = (hw_val + 12) / 24; 1264 if (hw_val > max_timebase) 1265 hw_val = max_timebase; 1266 1267 if (mpu_cmd(midi_dev, 0xC0 | (hw_val & 0x0f), 0) < 0) 1268 { 1269 printk(KERN_WARNING "mpu401: Can't set HW timebase to %d\n", hw_val * 24); 1270 return; 1271 } 1272 hw_timebase = hw_val * 24; 1273 curr_timebase = val; 1274 1275} 1276 1277static void tmr_reset(struct mpu_config *devc) 1278{ 1279 unsigned long flags; 1280 1281 spin_lock_irqsave(&devc->lock,flags); 1282 next_event_time = (unsigned long) -1; 1283 prev_event_time = 0; 1284 curr_ticks = curr_clocks = 0; 1285 spin_unlock_irqrestore(&devc->lock,flags); 1286} 1287 1288static void set_timer_mode(int midi_dev) 1289{ 1290 if (timer_mode & TMR_MODE_CLS) 1291 mpu_cmd(midi_dev, 0x3c, 0); /* Use CLS sync */ 1292 else if (timer_mode & TMR_MODE_SMPTE) 1293 mpu_cmd(midi_dev, 0x3d, 0); /* Use SMPTE sync */ 1294 1295 if (timer_mode & TMR_INTERNAL) 1296 { 1297 mpu_cmd(midi_dev, 0x80, 0); /* Use MIDI sync */ 1298 } 1299 else 1300 { 1301 if (timer_mode & (TMR_MODE_MIDI | TMR_MODE_CLS)) 1302 { 1303 mpu_cmd(midi_dev, 0x82, 0); /* Use MIDI sync */ 1304 mpu_cmd(midi_dev, 0x91, 0); /* Enable ext MIDI ctrl */ 1305 } 1306 else if (timer_mode & TMR_MODE_FSK) 1307 mpu_cmd(midi_dev, 0x81, 0); /* Use FSK sync */ 1308 } 1309} 1310 1311static void stop_metronome(int midi_dev) 1312{ 1313 mpu_cmd(midi_dev, 0x84, 0); /* Disable metronome */ 1314} 1315 1316static void setup_metronome(int midi_dev) 1317{ 1318 int numerator, denominator; 1319 int clks_per_click, num_32nds_per_beat; 1320 int beats_per_measure; 1321 1322 numerator = ((unsigned) metronome_mode >> 24) & 0xff; 1323 denominator = ((unsigned) metronome_mode >> 16) & 0xff; 1324 clks_per_click = ((unsigned) metronome_mode >> 8) & 0xff; 1325 num_32nds_per_beat = (unsigned) metronome_mode & 0xff; 1326 beats_per_measure = (numerator * 4) >> denominator; 1327 1328 if (!metronome_mode) 1329 mpu_cmd(midi_dev, 0x84, 0); /* Disable metronome */ 1330 else 1331 { 1332 mpu_cmd(midi_dev, 0xE4, clks_per_click); 1333 mpu_cmd(midi_dev, 0xE6, beats_per_measure); 1334 mpu_cmd(midi_dev, 0x83, 0); /* Enable metronome without accents */ 1335 } 1336} 1337 1338static int mpu_start_timer(int midi_dev) 1339{ 1340 struct mpu_config *devc= &dev_conf[midi_dev]; 1341 1342 tmr_reset(devc); 1343 set_timer_mode(midi_dev); 1344 1345 if (tmr_running) 1346 return TIMER_NOT_ARMED; /* Already running */ 1347 1348 if (timer_mode & TMR_INTERNAL) 1349 { 1350 mpu_cmd(midi_dev, 0x02, 0); /* Send MIDI start */ 1351 tmr_running = 1; 1352 return TIMER_NOT_ARMED; 1353 } 1354 else 1355 { 1356 mpu_cmd(midi_dev, 0x35, 0); /* Enable mode messages to PC */ 1357 mpu_cmd(midi_dev, 0x38, 0); /* Enable sys common messages to PC */ 1358 mpu_cmd(midi_dev, 0x39, 0); /* Enable real time messages to PC */ 1359 mpu_cmd(midi_dev, 0x97, 0); /* Enable system exclusive messages to PC */ 1360 } 1361 return TIMER_ARMED; 1362} 1363 1364static int mpu_timer_open(int dev, int mode) 1365{ 1366 int midi_dev = sound_timer_devs[dev]->devlink; 1367 struct mpu_config *devc= &dev_conf[midi_dev]; 1368 1369 if (timer_open) 1370 return -EBUSY; 1371 1372 tmr_reset(devc); 1373 curr_tempo = 50; 1374 mpu_cmd(midi_dev, 0xE0, 50); 1375 curr_timebase = hw_timebase = 120; 1376 set_timebase(midi_dev, 120); 1377 timer_open = 1; 1378 metronome_mode = 0; 1379 set_timer_mode(midi_dev); 1380 1381 mpu_cmd(midi_dev, 0xe7, 0x04); /* Send all clocks to host */ 1382 mpu_cmd(midi_dev, 0x95, 0); /* Enable clock to host */ 1383 1384 return 0; 1385} 1386 1387static void mpu_timer_close(int dev) 1388{ 1389 int midi_dev = sound_timer_devs[dev]->devlink; 1390 1391 timer_open = tmr_running = 0; 1392 mpu_cmd(midi_dev, 0x15, 0); /* Stop all */ 1393 mpu_cmd(midi_dev, 0x94, 0); /* Disable clock to host */ 1394 mpu_cmd(midi_dev, 0x8c, 0); /* Disable measure end messages to host */ 1395 stop_metronome(midi_dev); 1396} 1397 1398static int mpu_timer_event(int dev, unsigned char *event) 1399{ 1400 unsigned char command = event[1]; 1401 unsigned long parm = *(unsigned int *) &event[4]; 1402 int midi_dev = sound_timer_devs[dev]->devlink; 1403 1404 switch (command) 1405 { 1406 case TMR_WAIT_REL: 1407 parm += prev_event_time; 1408 case TMR_WAIT_ABS: 1409 if (parm > 0) 1410 { 1411 long time; 1412 1413 if (parm <= curr_ticks) /* It's the time */ 1414 return TIMER_NOT_ARMED; 1415 time = parm; 1416 next_event_time = prev_event_time = time; 1417 1418 return TIMER_ARMED; 1419 } 1420 break; 1421 1422 case TMR_START: 1423 if (tmr_running) 1424 break; 1425 return mpu_start_timer(midi_dev); 1426 1427 case TMR_STOP: 1428 mpu_cmd(midi_dev, 0x01, 0); /* Send MIDI stop */ 1429 stop_metronome(midi_dev); 1430 tmr_running = 0; 1431 break; 1432 1433 case TMR_CONTINUE: 1434 if (tmr_running) 1435 break; 1436 mpu_cmd(midi_dev, 0x03, 0); /* Send MIDI continue */ 1437 setup_metronome(midi_dev); 1438 tmr_running = 1; 1439 break; 1440 1441 case TMR_TEMPO: 1442 if (parm) 1443 { 1444 if (parm < 8) 1445 parm = 8; 1446 if (parm > 250) 1447 parm = 250; 1448 if (mpu_cmd(midi_dev, 0xE0, parm) < 0) 1449 printk(KERN_WARNING "mpu401: Can't set tempo to %d\n", (int) parm); 1450 curr_tempo = parm; 1451 } 1452 break; 1453 1454 case TMR_ECHO: 1455 seq_copy_to_input(event, 8); 1456 break; 1457 1458 case TMR_TIMESIG: 1459 if (metronome_mode) /* Metronome enabled */ 1460 { 1461 metronome_mode = parm; 1462 setup_metronome(midi_dev); 1463 } 1464 break; 1465 1466 default:; 1467 } 1468 return TIMER_NOT_ARMED; 1469} 1470 1471static unsigned long mpu_timer_get_time(int dev) 1472{ 1473 if (!timer_open) 1474 return 0; 1475 1476 return curr_ticks; 1477} 1478 1479static int mpu_timer_ioctl(int dev, unsigned int command, void __user *arg) 1480{ 1481 int midi_dev = sound_timer_devs[dev]->devlink; 1482 int __user *p = (int __user *)arg; 1483 1484 switch (command) 1485 { 1486 case SNDCTL_TMR_SOURCE: 1487 { 1488 int parm; 1489 1490 if (get_user(parm, p)) 1491 return -EFAULT; 1492 parm &= timer_caps; 1493 1494 if (parm != 0) 1495 { 1496 timer_mode = parm; 1497 1498 if (timer_mode & TMR_MODE_CLS) 1499 mpu_cmd(midi_dev, 0x3c, 0); /* Use CLS sync */ 1500 else if (timer_mode & TMR_MODE_SMPTE) 1501 mpu_cmd(midi_dev, 0x3d, 0); /* Use SMPTE sync */ 1502 } 1503 if (put_user(timer_mode, p)) 1504 return -EFAULT; 1505 return timer_mode; 1506 } 1507 break; 1508 1509 case SNDCTL_TMR_START: 1510 mpu_start_timer(midi_dev); 1511 return 0; 1512 1513 case SNDCTL_TMR_STOP: 1514 tmr_running = 0; 1515 mpu_cmd(midi_dev, 0x01, 0); /* Send MIDI stop */ 1516 stop_metronome(midi_dev); 1517 return 0; 1518 1519 case SNDCTL_TMR_CONTINUE: 1520 if (tmr_running) 1521 return 0; 1522 tmr_running = 1; 1523 mpu_cmd(midi_dev, 0x03, 0); /* Send MIDI continue */ 1524 return 0; 1525 1526 case SNDCTL_TMR_TIMEBASE: 1527 { 1528 int val; 1529 if (get_user(val, p)) 1530 return -EFAULT; 1531 if (val) 1532 set_timebase(midi_dev, val); 1533 if (put_user(curr_timebase, p)) 1534 return -EFAULT; 1535 return curr_timebase; 1536 } 1537 break; 1538 1539 case SNDCTL_TMR_TEMPO: 1540 { 1541 int val; 1542 int ret; 1543 1544 if (get_user(val, p)) 1545 return -EFAULT; 1546 1547 if (val) 1548 { 1549 if (val < 8) 1550 val = 8; 1551 if (val > 250) 1552 val = 250; 1553 if ((ret = mpu_cmd(midi_dev, 0xE0, val)) < 0) 1554 { 1555 printk(KERN_WARNING "mpu401: Can't set tempo to %d\n", (int) val); 1556 return ret; 1557 } 1558 curr_tempo = val; 1559 } 1560 if (put_user(curr_tempo, p)) 1561 return -EFAULT; 1562 return curr_tempo; 1563 } 1564 break; 1565 1566 case SNDCTL_SEQ_CTRLRATE: 1567 { 1568 int val; 1569 if (get_user(val, p)) 1570 return -EFAULT; 1571 1572 if (val != 0) /* Can't change */ 1573 return -EINVAL; 1574 val = ((curr_tempo * curr_timebase) + 30)/60; 1575 if (put_user(val, p)) 1576 return -EFAULT; 1577 return val; 1578 } 1579 break; 1580 1581 case SNDCTL_SEQ_GETTIME: 1582 if (put_user(curr_ticks, p)) 1583 return -EFAULT; 1584 return curr_ticks; 1585 1586 case SNDCTL_TMR_METRONOME: 1587 if (get_user(metronome_mode, p)) 1588 return -EFAULT; 1589 setup_metronome(midi_dev); 1590 return 0; 1591 1592 default:; 1593 } 1594 return -EINVAL; 1595} 1596 1597static void mpu_timer_arm(int dev, long time) 1598{ 1599 if (time < 0) 1600 time = curr_ticks + 1; 1601 else if (time <= curr_ticks) /* It's the time */ 1602 return; 1603 next_event_time = prev_event_time = time; 1604 return; 1605} 1606 1607static struct sound_timer_operations mpu_timer = 1608{ 1609 .owner = THIS_MODULE, 1610 .info = {"MPU-401 Timer", 0}, 1611 .priority = 10, /* Priority */ 1612 .devlink = 0, /* Local device link */ 1613 .open = mpu_timer_open, 1614 .close = mpu_timer_close, 1615 .event = mpu_timer_event, 1616 .get_time = mpu_timer_get_time, 1617 .ioctl = mpu_timer_ioctl, 1618 .arm_timer = mpu_timer_arm 1619}; 1620 1621static void mpu_timer_interrupt(void) 1622{ 1623 if (!timer_open) 1624 return; 1625 1626 if (!tmr_running) 1627 return; 1628 1629 curr_clocks++; 1630 curr_ticks = clocks2ticks(curr_clocks); 1631 1632 if (curr_ticks >= next_event_time) 1633 { 1634 next_event_time = (unsigned long) -1; 1635 sequencer_timer(0); 1636 } 1637} 1638 1639static void timer_ext_event(struct mpu_config *devc, int event, int parm) 1640{ 1641 int midi_dev = devc->devno; 1642 1643 if (!devc->timer_flag) 1644 return; 1645 1646 switch (event) 1647 { 1648 case TMR_CLOCK: 1649 printk("<MIDI clk>"); 1650 break; 1651 1652 case TMR_START: 1653 printk("Ext MIDI start\n"); 1654 if (!tmr_running) 1655 { 1656 if (timer_mode & TMR_EXTERNAL) 1657 { 1658 tmr_running = 1; 1659 setup_metronome(midi_dev); 1660 next_event_time = 0; 1661 STORE(SEQ_START_TIMER()); 1662 } 1663 } 1664 break; 1665 1666 case TMR_STOP: 1667 printk("Ext MIDI stop\n"); 1668 if (timer_mode & TMR_EXTERNAL) 1669 { 1670 tmr_running = 0; 1671 stop_metronome(midi_dev); 1672 STORE(SEQ_STOP_TIMER()); 1673 } 1674 break; 1675 1676 case TMR_CONTINUE: 1677 printk("Ext MIDI continue\n"); 1678 if (timer_mode & TMR_EXTERNAL) 1679 { 1680 tmr_running = 1; 1681 setup_metronome(midi_dev); 1682 STORE(SEQ_CONTINUE_TIMER()); 1683 } 1684 break; 1685 1686 case TMR_SPP: 1687 printk("Songpos: %d\n", parm); 1688 if (timer_mode & TMR_EXTERNAL) 1689 { 1690 STORE(SEQ_SONGPOS(parm)); 1691 } 1692 break; 1693 } 1694} 1695 1696static int mpu_timer_init(int midi_dev) 1697{ 1698 struct mpu_config *devc; 1699 int n; 1700 1701 devc = &dev_conf[midi_dev]; 1702 1703 if (timer_initialized) 1704 return -1; /* There is already a similar timer */ 1705 1706 timer_initialized = 1; 1707 1708 mpu_timer.devlink = midi_dev; 1709 dev_conf[midi_dev].timer_flag = 1; 1710 1711 n = sound_alloc_timerdev(); 1712 if (n == -1) 1713 n = 0; 1714 sound_timer_devs[n] = &mpu_timer; 1715 1716 if (devc->version < 0x20) /* Original MPU-401 */ 1717 timer_caps = TMR_INTERNAL | TMR_EXTERNAL | TMR_MODE_FSK | TMR_MODE_MIDI; 1718 else 1719 { 1720 /* 1721 * The version number 2.0 is used (at least) by the 1722 * MusicQuest cards and the Roland Super-MPU. 1723 * 1724 * MusicQuest has given a special meaning to the bits of the 1725 * revision number. The Super-MPU returns 0. 1726 */ 1727 1728 if (devc->revision) 1729 timer_caps |= TMR_EXTERNAL | TMR_MODE_MIDI; 1730 1731 if (devc->revision & 0x02) 1732 timer_caps |= TMR_MODE_CLS; 1733 1734 1735 if (devc->revision & 0x40) 1736 max_timebase = 10; /* Has the 216 and 240 ppqn modes */ 1737 } 1738 1739 timer_mode = (TMR_INTERNAL | TMR_MODE_MIDI) & timer_caps; 1740 return n; 1741 1742} 1743 1744EXPORT_SYMBOL(probe_mpu401); 1745EXPORT_SYMBOL(attach_mpu401); 1746EXPORT_SYMBOL(unload_mpu401); 1747 1748static struct address_info cfg; 1749 1750static int io = -1; 1751static int irq = -1; 1752 1753module_param(irq, int, 0); 1754module_param(io, int, 0); 1755 1756static int __init init_mpu401(void) 1757{ 1758 int ret; 1759 /* Can be loaded either for module use or to provide functions 1760 to others */ 1761 if (io != -1 && irq != -1) { 1762 struct resource *ports; 1763 cfg.irq = irq; 1764 cfg.io_base = io; 1765 ports = request_region(io, 2, "mpu401"); 1766 if (!ports) 1767 return -EBUSY; 1768 if (probe_mpu401(&cfg, ports) == 0) { 1769 release_region(io, 2); 1770 return -ENODEV; 1771 } 1772 if ((ret = attach_mpu401(&cfg, THIS_MODULE))) 1773 return ret; 1774 } 1775 1776 return 0; 1777} 1778 1779static void __exit cleanup_mpu401(void) 1780{ 1781 if (io != -1 && irq != -1) { 1782 /* Check for use by, for example, sscape driver */ 1783 unload_mpu401(&cfg); 1784 } 1785} 1786 1787module_init(init_mpu401); 1788module_exit(cleanup_mpu401); 1789 1790#ifndef MODULE 1791static int __init setup_mpu401(char *str) 1792{ 1793 /* io, irq */ 1794 int ints[3]; 1795 1796 str = get_options(str, ARRAY_SIZE(ints), ints); 1797 1798 io = ints[1]; 1799 irq = ints[2]; 1800 1801 return 1; 1802} 1803 1804__setup("mpu401=", setup_mpu401); 1805#endif 1806MODULE_LICENSE("GPL"); 1807