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