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 (snd_mpu401_uart_cmd(mpu, MPU401_ENTER_UART, 0)) 274 return -EIO; 275 return 0; 276 } 277 278 /* 279 * input/output open/close - protected by open_mutex in rawmidi.c 280 */ 281 static int snd_mpu401_uart_input_open(struct snd_rawmidi_substream *substream) 282 { 283 struct snd_mpu401 *mpu; 284 int err; 285 286 mpu = substream->rmidi->private_data; 287 if (mpu->open_input && (err = mpu->open_input(mpu)) < 0) 288 return err; 289 if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode)) { 290 if (snd_mpu401_do_reset(mpu) < 0) 291 goto error_out; 292 } 293 mpu->substream_input = substream; 294 set_bit(MPU401_MODE_BIT_INPUT, &mpu->mode); 295 return 0; 296 297 error_out: 298 if (mpu->open_input && mpu->close_input) 299 mpu->close_input(mpu); 300 return -EIO; 301 } 302 303 static int snd_mpu401_uart_output_open(struct snd_rawmidi_substream *substream) 304 { 305 struct snd_mpu401 *mpu; 306 int err; 307 308 mpu = substream->rmidi->private_data; 309 if (mpu->open_output && (err = mpu->open_output(mpu)) < 0) 310 return err; 311 if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) { 312 if (snd_mpu401_do_reset(mpu) < 0) 313 goto error_out; 314 } 315 mpu->substream_output = substream; 316 set_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode); 317 return 0; 318 319 error_out: 320 if (mpu->open_output && mpu->close_output) 321 mpu->close_output(mpu); 322 return -EIO; 323 } 324 325 static int snd_mpu401_uart_input_close(struct snd_rawmidi_substream *substream) 326 { 327 struct snd_mpu401 *mpu; 328 int err = 0; 329 330 mpu = substream->rmidi->private_data; 331 clear_bit(MPU401_MODE_BIT_INPUT, &mpu->mode); 332 mpu->substream_input = NULL; 333 if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode)) 334 err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0); 335 if (mpu->close_input) 336 mpu->close_input(mpu); 337 if (err) 338 return -EIO; 339 return 0; 340 } 341 342 static int snd_mpu401_uart_output_close(struct snd_rawmidi_substream *substream) 343 { 344 struct snd_mpu401 *mpu; 345 int err = 0; 346 347 mpu = substream->rmidi->private_data; 348 clear_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode); 349 mpu->substream_output = NULL; 350 if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) 351 err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0); 352 if (mpu->close_output) 353 mpu->close_output(mpu); 354 if (err) 355 return -EIO; 356 return 0; 357 } 358 359 /* 360 * trigger input callback 361 */ 362 static void 363 snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substream, int up) 364 { 365 unsigned long flags; 366 struct snd_mpu401 *mpu; 367 int max = 64; 368 369 mpu = substream->rmidi->private_data; 370 if (up) { 371 if (! test_and_set_bit(MPU401_MODE_BIT_INPUT_TRIGGER, 372 &mpu->mode)) { 373 /* first time - flush FIFO */ 374 while (max-- > 0) 375 mpu->read(mpu, MPU401D(mpu)); 376 if (mpu->irq < 0) 377 snd_mpu401_uart_add_timer(mpu, 1); 378 } 379 380 /* read data in advance */ 381 spin_lock_irqsave(&mpu->input_lock, flags); 382 snd_mpu401_uart_input_read(mpu); 383 spin_unlock_irqrestore(&mpu->input_lock, flags); 384 } else { 385 if (mpu->irq < 0) 386 snd_mpu401_uart_remove_timer(mpu, 1); 387 clear_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode); 388 } 389 390 } 391 392 /* 393 * transfer input pending data 394 * call with input_lock spinlock held 395 */ 396 static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu) 397 { 398 int max = 128; 399 unsigned char byte; 400 401 while (max-- > 0) { 402 if (! snd_mpu401_input_avail(mpu)) 403 break; /* input not available */ 404 byte = mpu->read(mpu, MPU401D(mpu)); 405 if (test_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode)) 406 snd_rawmidi_receive(mpu->substream_input, &byte, 1); 407 } 408 } 409 410 /* 411 * Tx FIFO sizes: 412 * CS4237B - 16 bytes 413 * AudioDrive ES1688 - 12 bytes 414 * S3 SonicVibes - 8 bytes 415 * SoundBlaster AWE 64 - 2 bytes (ugly hardware) 416 */ 417 418 /* 419 * write output pending bytes 420 * call with output_lock spinlock held 421 */ 422 static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu) 423 { 424 unsigned char byte; 425 int max = 256, timeout; 426 427 do { 428 if (snd_rawmidi_transmit_peek(mpu->substream_output, 429 &byte, 1) == 1) { 430 for (timeout = 100; timeout > 0; timeout--) { 431 if (snd_mpu401_output_ready(mpu)) 432 break; 433 } 434 if (timeout == 0) 435 break; /* Tx FIFO full - try again later */ 436 mpu->write(mpu, byte, MPU401D(mpu)); 437 snd_rawmidi_transmit_ack(mpu->substream_output, 1); 438 } else { 439 snd_mpu401_uart_remove_timer (mpu, 0); 440 break; /* no other data - leave the tx loop */ 441 } 442 } while (--max > 0); 443 } 444 445 /* 446 * output trigger callback 447 */ 448 static void 449 snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substream, int up) 450 { 451 unsigned long flags; 452 struct snd_mpu401 *mpu; 453 454 mpu = substream->rmidi->private_data; 455 if (up) { 456 set_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode); 457 458 /* try to add the timer at each output trigger, 459 * since the output timer might have been removed in 460 * snd_mpu401_uart_output_write(). 461 */ 462 if (! (mpu->info_flags & MPU401_INFO_TX_IRQ)) 463 snd_mpu401_uart_add_timer(mpu, 0); 464 465 /* output pending data */ 466 spin_lock_irqsave(&mpu->output_lock, flags); 467 snd_mpu401_uart_output_write(mpu); 468 spin_unlock_irqrestore(&mpu->output_lock, flags); 469 } else { 470 if (! (mpu->info_flags & MPU401_INFO_TX_IRQ)) 471 snd_mpu401_uart_remove_timer(mpu, 0); 472 clear_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode); 473 } 474 } 475 476 /* 477 478 */ 479 480 static struct snd_rawmidi_ops snd_mpu401_uart_output = 481 { 482 .open = snd_mpu401_uart_output_open, 483 .close = snd_mpu401_uart_output_close, 484 .trigger = snd_mpu401_uart_output_trigger, 485 }; 486 487 static struct snd_rawmidi_ops snd_mpu401_uart_input = 488 { 489 .open = snd_mpu401_uart_input_open, 490 .close = snd_mpu401_uart_input_close, 491 .trigger = snd_mpu401_uart_input_trigger, 492 }; 493 494 static void snd_mpu401_uart_free(struct snd_rawmidi *rmidi) 495 { 496 struct snd_mpu401 *mpu = rmidi->private_data; 497 if (mpu->irq_flags && mpu->irq >= 0) 498 free_irq(mpu->irq, (void *) mpu); 499 release_and_free_resource(mpu->res); 500 kfree(mpu); 501 } 502 503 /** 504 * snd_mpu401_uart_new - create an MPU401-UART instance 505 * @card: the card instance 506 * @device: the device index, zero-based 507 * @hardware: the hardware type, MPU401_HW_XXXX 508 * @port: the base address of MPU401 port 509 * @info_flags: bitflags MPU401_INFO_XXX 510 * @irq: the irq number, -1 if no interrupt for mpu 511 * @irq_flags: the irq request flags (SA_XXX), 0 if irq was already reserved. 512 * @rrawmidi: the pointer to store the new rawmidi instance 513 * 514 * Creates a new MPU-401 instance. 515 * 516 * Note that the rawmidi instance is returned on the rrawmidi argument, 517 * not the mpu401 instance itself. To access to the mpu401 instance, 518 * cast from rawmidi->private_data (with struct snd_mpu401 magic-cast). 519 * 520 * Returns zero if successful, or a negative error code. 521 */ 522 int snd_mpu401_uart_new(struct snd_card *card, int device, 523 unsigned short hardware, 524 unsigned long port, 525 unsigned int info_flags, 526 int irq, int irq_flags, 527 struct snd_rawmidi ** rrawmidi) 528 { 529 struct snd_mpu401 *mpu; 530 struct snd_rawmidi *rmidi; 531 int in_enable, out_enable; 532 int err; 533 534 if (rrawmidi) 535 *rrawmidi = NULL; 536 if (! (info_flags & (MPU401_INFO_INPUT | MPU401_INFO_OUTPUT))) 537 info_flags |= MPU401_INFO_INPUT | MPU401_INFO_OUTPUT; 538 in_enable = (info_flags & MPU401_INFO_INPUT) ? 1 : 0; 539 out_enable = (info_flags & MPU401_INFO_OUTPUT) ? 1 : 0; 540 if ((err = snd_rawmidi_new(card, "MPU-401U", device, 541 out_enable, in_enable, &rmidi)) < 0) 542 return err; 543 mpu = kzalloc(sizeof(*mpu), GFP_KERNEL); 544 if (mpu == NULL) { 545 snd_printk(KERN_ERR "mpu401_uart: cannot allocate\n"); 546 snd_device_free(card, rmidi); 547 return -ENOMEM; 548 } 549 rmidi->private_data = mpu; 550 rmidi->private_free = snd_mpu401_uart_free; 551 spin_lock_init(&mpu->input_lock); 552 spin_lock_init(&mpu->output_lock); 553 spin_lock_init(&mpu->timer_lock); 554 mpu->hardware = hardware; 555 if (! (info_flags & MPU401_INFO_INTEGRATED)) { 556 int res_size = hardware == MPU401_HW_PC98II ? 4 : 2; 557 mpu->res = request_region(port, res_size, "MPU401 UART"); 558 if (mpu->res == NULL) { 559 snd_printk(KERN_ERR "mpu401_uart: " 560 "unable to grab port 0x%lx size %d\n", 561 port, res_size); 562 snd_device_free(card, rmidi); 563 return -EBUSY; 564 } 565 } 566 if (info_flags & MPU401_INFO_MMIO) { 567 mpu->write = mpu401_write_mmio; 568 mpu->read = mpu401_read_mmio; 569 } else { 570 mpu->write = mpu401_write_port; 571 mpu->read = mpu401_read_port; 572 } 573 mpu->port = port; 574 if (hardware == MPU401_HW_PC98II) 575 mpu->cport = port + 2; 576 else 577 mpu->cport = port + 1; 578 if (irq >= 0 && irq_flags) { 579 if (request_irq(irq, snd_mpu401_uart_interrupt, irq_flags, 580 "MPU401 UART", (void *) mpu)) { 581 snd_printk(KERN_ERR "mpu401_uart: " 582 "unable to grab IRQ %d\n", irq); 583 snd_device_free(card, rmidi); 584 return -EBUSY; 585 } 586 } 587 mpu->info_flags = info_flags; 588 mpu->irq = irq; 589 mpu->irq_flags = irq_flags; 590 if (card->shortname[0]) 591 snprintf(rmidi->name, sizeof(rmidi->name), "%s MIDI", 592 card->shortname); 593 else 594 sprintf(rmidi->name, "MPU-401 MIDI %d-%d",card->number, device); 595 if (out_enable) { 596 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, 597 &snd_mpu401_uart_output); 598 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT; 599 } 600 if (in_enable) { 601 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, 602 &snd_mpu401_uart_input); 603 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT; 604 if (out_enable) 605 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX; 606 } 607 mpu->rmidi = rmidi; 608 if (rrawmidi) 609 *rrawmidi = rmidi; 610 return 0; 611 } 612 613 EXPORT_SYMBOL(snd_mpu401_uart_new); 614 615 /* 616 * INIT part 617 */ 618 619 static int __init alsa_mpu401_uart_init(void) 620 { 621 return 0; 622 } 623 624 static void __exit alsa_mpu401_uart_exit(void) 625 { 626 } 627 628 module_init(alsa_mpu401_uart_init) 629 module_exit(alsa_mpu401_uart_exit) 630