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