1 /* 2 * Copyright (c) by Jaroslav Kysela <perex@perex.cz> 3 * Routines for control of MPU-401 in UART mode 4 * 5 * MPU-401 supports UART mode which is not capable generate transmit 6 * interrupts thus output is done via polling. Also, if irq < 0, then 7 * input is done also via polling. Do not expect good performance. 8 * 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 23 * 24 * 13-03-2003: 25 * Added support for different kind of hardware I/O. Build in choices 26 * are port and mmio. For other kind of I/O, set mpu->read and 27 * mpu->write to your own I/O functions. 28 * 29 */ 30 31 #include <asm/io.h> 32 #include <linux/delay.h> 33 #include <linux/init.h> 34 #include <linux/slab.h> 35 #include <linux/ioport.h> 36 #include <linux/interrupt.h> 37 #include <linux/errno.h> 38 #include <sound/core.h> 39 #include <sound/mpu401.h> 40 41 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>"); 42 MODULE_DESCRIPTION("Routines for control of MPU-401 in UART mode"); 43 MODULE_LICENSE("GPL"); 44 45 static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu); 46 static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu); 47 48 /* 49 50 */ 51 52 #define snd_mpu401_input_avail(mpu) (!(mpu->read(mpu, MPU401C(mpu)) & 0x80)) 53 #define snd_mpu401_output_ready(mpu) (!(mpu->read(mpu, MPU401C(mpu)) & 0x40)) 54 55 #define MPU401_RESET 0xff 56 #define MPU401_ENTER_UART 0x3f 57 #define MPU401_ACK 0xfe 58 59 /* Build in lowlevel io */ 60 static void mpu401_write_port(struct snd_mpu401 *mpu, unsigned char data, 61 unsigned long addr) 62 { 63 outb(data, addr); 64 } 65 66 static unsigned char mpu401_read_port(struct snd_mpu401 *mpu, 67 unsigned long addr) 68 { 69 return inb(addr); 70 } 71 72 static void mpu401_write_mmio(struct snd_mpu401 *mpu, unsigned char data, 73 unsigned long addr) 74 { 75 writeb(data, (void __iomem *)addr); 76 } 77 78 static unsigned char mpu401_read_mmio(struct snd_mpu401 *mpu, 79 unsigned long addr) 80 { 81 return readb((void __iomem *)addr); 82 } 83 /* */ 84 85 static void snd_mpu401_uart_clear_rx(struct snd_mpu401 *mpu) 86 { 87 int timeout = 100000; 88 for (; timeout > 0 && snd_mpu401_input_avail(mpu); timeout--) 89 mpu->read(mpu, MPU401D(mpu)); 90 #ifdef CONFIG_SND_DEBUG 91 if (timeout <= 0) 92 snd_printk(KERN_ERR "cmd: clear rx timeout (status = 0x%x)\n", 93 mpu->read(mpu, MPU401C(mpu))); 94 #endif 95 } 96 97 static void uart_interrupt_tx(struct snd_mpu401 *mpu) 98 { 99 unsigned long flags; 100 101 if (test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode) && 102 test_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode)) { 103 spin_lock_irqsave(&mpu->output_lock, flags); 104 snd_mpu401_uart_output_write(mpu); 105 spin_unlock_irqrestore(&mpu->output_lock, flags); 106 } 107 } 108 109 static void _snd_mpu401_uart_interrupt(struct snd_mpu401 *mpu) 110 { 111 unsigned long flags; 112 113 if (mpu->info_flags & MPU401_INFO_INPUT) { 114 spin_lock_irqsave(&mpu->input_lock, flags); 115 if (test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) 116 snd_mpu401_uart_input_read(mpu); 117 else 118 snd_mpu401_uart_clear_rx(mpu); 119 spin_unlock_irqrestore(&mpu->input_lock, flags); 120 } 121 if (! (mpu->info_flags & MPU401_INFO_TX_IRQ)) 122 /* ok. for better Tx performance try do some output 123 when input is done */ 124 uart_interrupt_tx(mpu); 125 } 126 127 /** 128 * snd_mpu401_uart_interrupt - generic MPU401-UART interrupt handler 129 * @irq: the irq number 130 * @dev_id: mpu401 instance 131 * 132 * Processes the interrupt for MPU401-UART i/o. 133 */ 134 irqreturn_t snd_mpu401_uart_interrupt(int irq, void *dev_id) 135 { 136 struct snd_mpu401 *mpu = dev_id; 137 138 if (mpu == NULL) 139 return IRQ_NONE; 140 _snd_mpu401_uart_interrupt(mpu); 141 return IRQ_HANDLED; 142 } 143 144 EXPORT_SYMBOL(snd_mpu401_uart_interrupt); 145 146 /** 147 * snd_mpu401_uart_interrupt_tx - generic MPU401-UART transmit irq handler 148 * @irq: the irq number 149 * @dev_id: mpu401 instance 150 * 151 * Processes the interrupt for MPU401-UART output. 152 */ 153 irqreturn_t snd_mpu401_uart_interrupt_tx(int irq, void *dev_id) 154 { 155 struct snd_mpu401 *mpu = dev_id; 156 157 if (mpu == NULL) 158 return IRQ_NONE; 159 uart_interrupt_tx(mpu); 160 return IRQ_HANDLED; 161 } 162 163 EXPORT_SYMBOL(snd_mpu401_uart_interrupt_tx); 164 165 /* 166 * timer callback 167 * reprogram the timer and call the interrupt job 168 */ 169 static void snd_mpu401_uart_timer(unsigned long data) 170 { 171 struct snd_mpu401 *mpu = (struct snd_mpu401 *)data; 172 unsigned long flags; 173 174 spin_lock_irqsave(&mpu->timer_lock, flags); 175 /*mpu->mode |= MPU401_MODE_TIMER;*/ 176 mpu->timer.expires = 1 + jiffies; 177 add_timer(&mpu->timer); 178 spin_unlock_irqrestore(&mpu->timer_lock, flags); 179 if (mpu->rmidi) 180 _snd_mpu401_uart_interrupt(mpu); 181 } 182 183 /* 184 * initialize the timer callback if not programmed yet 185 */ 186 static void snd_mpu401_uart_add_timer (struct snd_mpu401 *mpu, int input) 187 { 188 unsigned long flags; 189 190 spin_lock_irqsave (&mpu->timer_lock, flags); 191 if (mpu->timer_invoked == 0) { 192 init_timer(&mpu->timer); 193 mpu->timer.data = (unsigned long)mpu; 194 mpu->timer.function = snd_mpu401_uart_timer; 195 mpu->timer.expires = 1 + jiffies; 196 add_timer(&mpu->timer); 197 } 198 mpu->timer_invoked |= input ? MPU401_MODE_INPUT_TIMER : 199 MPU401_MODE_OUTPUT_TIMER; 200 spin_unlock_irqrestore (&mpu->timer_lock, flags); 201 } 202 203 /* 204 * remove the timer callback if still active 205 */ 206 static void snd_mpu401_uart_remove_timer (struct snd_mpu401 *mpu, int input) 207 { 208 unsigned long flags; 209 210 spin_lock_irqsave (&mpu->timer_lock, flags); 211 if (mpu->timer_invoked) { 212 mpu->timer_invoked &= input ? ~MPU401_MODE_INPUT_TIMER : 213 ~MPU401_MODE_OUTPUT_TIMER; 214 if (! mpu->timer_invoked) 215 del_timer(&mpu->timer); 216 } 217 spin_unlock_irqrestore (&mpu->timer_lock, flags); 218 } 219 220 /* 221 * send a UART command 222 * return zero if successful, non-zero for some errors 223 */ 224 225 static int snd_mpu401_uart_cmd(struct snd_mpu401 * mpu, unsigned char cmd, 226 int ack) 227 { 228 unsigned long flags; 229 int timeout, ok; 230 231 spin_lock_irqsave(&mpu->input_lock, flags); 232 if (mpu->hardware != MPU401_HW_TRID4DWAVE) { 233 mpu->write(mpu, 0x00, MPU401D(mpu)); 234 /*snd_mpu401_uart_clear_rx(mpu);*/ 235 } 236 /* ok. standard MPU-401 initialization */ 237 if (mpu->hardware != MPU401_HW_SB) { 238 for (timeout = 1000; timeout > 0 && 239 !snd_mpu401_output_ready(mpu); timeout--) 240 udelay(10); 241 #ifdef CONFIG_SND_DEBUG 242 if (!timeout) 243 snd_printk(KERN_ERR "cmd: tx timeout (status = 0x%x)\n", 244 mpu->read(mpu, MPU401C(mpu))); 245 #endif 246 } 247 mpu->write(mpu, cmd, MPU401C(mpu)); 248 if (ack) { 249 ok = 0; 250 timeout = 10000; 251 while (!ok && timeout-- > 0) { 252 if (snd_mpu401_input_avail(mpu)) { 253 if (mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK) 254 ok = 1; 255 } 256 } 257 if (!ok && mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK) 258 ok = 1; 259 } else 260 ok = 1; 261 spin_unlock_irqrestore(&mpu->input_lock, flags); 262 if (!ok) { 263 snd_printk(KERN_ERR "cmd: 0x%x failed at 0x%lx " 264 "(status = 0x%x, data = 0x%x)\n", cmd, mpu->port, 265 mpu->read(mpu, MPU401C(mpu)), 266 mpu->read(mpu, MPU401D(mpu))); 267 return 1; 268 } 269 return 0; 270 } 271 272 static int snd_mpu401_do_reset(struct snd_mpu401 *mpu) 273 { 274 if (snd_mpu401_uart_cmd(mpu, MPU401_RESET, 1)) 275 return -EIO; 276 if (snd_mpu401_uart_cmd(mpu, MPU401_ENTER_UART, 0)) 277 return -EIO; 278 return 0; 279 } 280 281 /* 282 * input/output open/close - protected by open_mutex in rawmidi.c 283 */ 284 static int snd_mpu401_uart_input_open(struct snd_rawmidi_substream *substream) 285 { 286 struct snd_mpu401 *mpu; 287 int err; 288 289 mpu = substream->rmidi->private_data; 290 if (mpu->open_input && (err = mpu->open_input(mpu)) < 0) 291 return err; 292 if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode)) { 293 if (snd_mpu401_do_reset(mpu) < 0) 294 goto error_out; 295 } 296 mpu->substream_input = substream; 297 set_bit(MPU401_MODE_BIT_INPUT, &mpu->mode); 298 return 0; 299 300 error_out: 301 if (mpu->open_input && mpu->close_input) 302 mpu->close_input(mpu); 303 return -EIO; 304 } 305 306 static int snd_mpu401_uart_output_open(struct snd_rawmidi_substream *substream) 307 { 308 struct snd_mpu401 *mpu; 309 int err; 310 311 mpu = substream->rmidi->private_data; 312 if (mpu->open_output && (err = mpu->open_output(mpu)) < 0) 313 return err; 314 if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) { 315 if (snd_mpu401_do_reset(mpu) < 0) 316 goto error_out; 317 } 318 mpu->substream_output = substream; 319 set_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode); 320 return 0; 321 322 error_out: 323 if (mpu->open_output && mpu->close_output) 324 mpu->close_output(mpu); 325 return -EIO; 326 } 327 328 static int snd_mpu401_uart_input_close(struct snd_rawmidi_substream *substream) 329 { 330 struct snd_mpu401 *mpu; 331 int err = 0; 332 333 mpu = substream->rmidi->private_data; 334 clear_bit(MPU401_MODE_BIT_INPUT, &mpu->mode); 335 mpu->substream_input = NULL; 336 if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode)) 337 err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0); 338 if (mpu->close_input) 339 mpu->close_input(mpu); 340 if (err) 341 return -EIO; 342 return 0; 343 } 344 345 static int snd_mpu401_uart_output_close(struct snd_rawmidi_substream *substream) 346 { 347 struct snd_mpu401 *mpu; 348 int err = 0; 349 350 mpu = substream->rmidi->private_data; 351 clear_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode); 352 mpu->substream_output = NULL; 353 if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) 354 err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0); 355 if (mpu->close_output) 356 mpu->close_output(mpu); 357 if (err) 358 return -EIO; 359 return 0; 360 } 361 362 /* 363 * trigger input callback 364 */ 365 static void 366 snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substream, int up) 367 { 368 unsigned long flags; 369 struct snd_mpu401 *mpu; 370 int max = 64; 371 372 mpu = substream->rmidi->private_data; 373 if (up) { 374 if (! test_and_set_bit(MPU401_MODE_BIT_INPUT_TRIGGER, 375 &mpu->mode)) { 376 /* first time - flush FIFO */ 377 while (max-- > 0) 378 mpu->read(mpu, MPU401D(mpu)); 379 if (mpu->irq < 0) 380 snd_mpu401_uart_add_timer(mpu, 1); 381 } 382 383 /* read data in advance */ 384 spin_lock_irqsave(&mpu->input_lock, flags); 385 snd_mpu401_uart_input_read(mpu); 386 spin_unlock_irqrestore(&mpu->input_lock, flags); 387 } else { 388 if (mpu->irq < 0) 389 snd_mpu401_uart_remove_timer(mpu, 1); 390 clear_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode); 391 } 392 393 } 394 395 /* 396 * transfer input pending data 397 * call with input_lock spinlock held 398 */ 399 static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu) 400 { 401 int max = 128; 402 unsigned char byte; 403 404 while (max-- > 0) { 405 if (! snd_mpu401_input_avail(mpu)) 406 break; /* input not available */ 407 byte = mpu->read(mpu, MPU401D(mpu)); 408 if (test_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode)) 409 snd_rawmidi_receive(mpu->substream_input, &byte, 1); 410 } 411 } 412 413 /* 414 * Tx FIFO sizes: 415 * CS4237B - 16 bytes 416 * AudioDrive ES1688 - 12 bytes 417 * S3 SonicVibes - 8 bytes 418 * SoundBlaster AWE 64 - 2 bytes (ugly hardware) 419 */ 420 421 /* 422 * write output pending bytes 423 * call with output_lock spinlock held 424 */ 425 static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu) 426 { 427 unsigned char byte; 428 int max = 256; 429 430 do { 431 if (snd_rawmidi_transmit_peek(mpu->substream_output, 432 &byte, 1) == 1) { 433 /* 434 * Try twice because there is hardware that insists on 435 * setting the output busy bit after each write. 436 */ 437 if (!snd_mpu401_output_ready(mpu) && 438 !snd_mpu401_output_ready(mpu)) 439 break; /* Tx FIFO full - try again later */ 440 mpu->write(mpu, byte, MPU401D(mpu)); 441 snd_rawmidi_transmit_ack(mpu->substream_output, 1); 442 } else { 443 snd_mpu401_uart_remove_timer (mpu, 0); 444 break; /* no other data - leave the tx loop */ 445 } 446 } while (--max > 0); 447 } 448 449 /* 450 * output trigger callback 451 */ 452 static void 453 snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substream, int up) 454 { 455 unsigned long flags; 456 struct snd_mpu401 *mpu; 457 458 mpu = substream->rmidi->private_data; 459 if (up) { 460 set_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode); 461 462 /* try to add the timer at each output trigger, 463 * since the output timer might have been removed in 464 * snd_mpu401_uart_output_write(). 465 */ 466 if (! (mpu->info_flags & MPU401_INFO_TX_IRQ)) 467 snd_mpu401_uart_add_timer(mpu, 0); 468 469 /* output pending data */ 470 spin_lock_irqsave(&mpu->output_lock, flags); 471 snd_mpu401_uart_output_write(mpu); 472 spin_unlock_irqrestore(&mpu->output_lock, flags); 473 } else { 474 if (! (mpu->info_flags & MPU401_INFO_TX_IRQ)) 475 snd_mpu401_uart_remove_timer(mpu, 0); 476 clear_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode); 477 } 478 } 479 480 /* 481 482 */ 483 484 static struct snd_rawmidi_ops snd_mpu401_uart_output = 485 { 486 .open = snd_mpu401_uart_output_open, 487 .close = snd_mpu401_uart_output_close, 488 .trigger = snd_mpu401_uart_output_trigger, 489 }; 490 491 static struct snd_rawmidi_ops snd_mpu401_uart_input = 492 { 493 .open = snd_mpu401_uart_input_open, 494 .close = snd_mpu401_uart_input_close, 495 .trigger = snd_mpu401_uart_input_trigger, 496 }; 497 498 static void snd_mpu401_uart_free(struct snd_rawmidi *rmidi) 499 { 500 struct snd_mpu401 *mpu = rmidi->private_data; 501 if (mpu->irq_flags && mpu->irq >= 0) 502 free_irq(mpu->irq, (void *) mpu); 503 release_and_free_resource(mpu->res); 504 kfree(mpu); 505 } 506 507 /** 508 * snd_mpu401_uart_new - create an MPU401-UART instance 509 * @card: the card instance 510 * @device: the device index, zero-based 511 * @hardware: the hardware type, MPU401_HW_XXXX 512 * @port: the base address of MPU401 port 513 * @info_flags: bitflags MPU401_INFO_XXX 514 * @irq: the irq number, -1 if no interrupt for mpu 515 * @irq_flags: the irq request flags (SA_XXX), 0 if irq was already reserved. 516 * @rrawmidi: the pointer to store the new rawmidi instance 517 * 518 * Creates a new MPU-401 instance. 519 * 520 * Note that the rawmidi instance is returned on the rrawmidi argument, 521 * not the mpu401 instance itself. To access to the mpu401 instance, 522 * cast from rawmidi->private_data (with struct snd_mpu401 magic-cast). 523 * 524 * Returns zero if successful, or a negative error code. 525 */ 526 int snd_mpu401_uart_new(struct snd_card *card, int device, 527 unsigned short hardware, 528 unsigned long port, 529 unsigned int info_flags, 530 int irq, int irq_flags, 531 struct snd_rawmidi ** rrawmidi) 532 { 533 struct snd_mpu401 *mpu; 534 struct snd_rawmidi *rmidi; 535 int in_enable, out_enable; 536 int err; 537 538 if (rrawmidi) 539 *rrawmidi = NULL; 540 if (! (info_flags & (MPU401_INFO_INPUT | MPU401_INFO_OUTPUT))) 541 info_flags |= MPU401_INFO_INPUT | MPU401_INFO_OUTPUT; 542 in_enable = (info_flags & MPU401_INFO_INPUT) ? 1 : 0; 543 out_enable = (info_flags & MPU401_INFO_OUTPUT) ? 1 : 0; 544 if ((err = snd_rawmidi_new(card, "MPU-401U", device, 545 out_enable, in_enable, &rmidi)) < 0) 546 return err; 547 mpu = kzalloc(sizeof(*mpu), GFP_KERNEL); 548 if (mpu == NULL) { 549 snd_printk(KERN_ERR "mpu401_uart: cannot allocate\n"); 550 snd_device_free(card, rmidi); 551 return -ENOMEM; 552 } 553 rmidi->private_data = mpu; 554 rmidi->private_free = snd_mpu401_uart_free; 555 spin_lock_init(&mpu->input_lock); 556 spin_lock_init(&mpu->output_lock); 557 spin_lock_init(&mpu->timer_lock); 558 mpu->hardware = hardware; 559 if (! (info_flags & MPU401_INFO_INTEGRATED)) { 560 int res_size = hardware == MPU401_HW_PC98II ? 4 : 2; 561 mpu->res = request_region(port, res_size, "MPU401 UART"); 562 if (mpu->res == NULL) { 563 snd_printk(KERN_ERR "mpu401_uart: " 564 "unable to grab port 0x%lx size %d\n", 565 port, res_size); 566 snd_device_free(card, rmidi); 567 return -EBUSY; 568 } 569 } 570 if (info_flags & MPU401_INFO_MMIO) { 571 mpu->write = mpu401_write_mmio; 572 mpu->read = mpu401_read_mmio; 573 } else { 574 mpu->write = mpu401_write_port; 575 mpu->read = mpu401_read_port; 576 } 577 mpu->port = port; 578 if (hardware == MPU401_HW_PC98II) 579 mpu->cport = port + 2; 580 else 581 mpu->cport = port + 1; 582 if (irq >= 0 && irq_flags) { 583 if (request_irq(irq, snd_mpu401_uart_interrupt, irq_flags, 584 "MPU401 UART", (void *) mpu)) { 585 snd_printk(KERN_ERR "mpu401_uart: " 586 "unable to grab IRQ %d\n", irq); 587 snd_device_free(card, rmidi); 588 return -EBUSY; 589 } 590 } 591 mpu->info_flags = info_flags; 592 mpu->irq = irq; 593 mpu->irq_flags = irq_flags; 594 if (card->shortname[0]) 595 snprintf(rmidi->name, sizeof(rmidi->name), "%s MIDI", 596 card->shortname); 597 else 598 sprintf(rmidi->name, "MPU-401 MIDI %d-%d",card->number, device); 599 if (out_enable) { 600 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, 601 &snd_mpu401_uart_output); 602 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT; 603 } 604 if (in_enable) { 605 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, 606 &snd_mpu401_uart_input); 607 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT; 608 if (out_enable) 609 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX; 610 } 611 mpu->rmidi = rmidi; 612 if (rrawmidi) 613 *rrawmidi = rmidi; 614 return 0; 615 } 616 617 EXPORT_SYMBOL(snd_mpu401_uart_new); 618 619 /* 620 * INIT part 621 */ 622 623 static int __init alsa_mpu401_uart_init(void) 624 { 625 return 0; 626 } 627 628 static void __exit alsa_mpu401_uart_exit(void) 629 { 630 } 631 632 module_init(alsa_mpu401_uart_init) 633 module_exit(alsa_mpu401_uart_exit) 634