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