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 void snd_mpu401_uart_cmd(struct snd_mpu401 * mpu, unsigned char cmd, int ack) 187 { 188 unsigned long flags; 189 int timeout, ok; 190 191 spin_lock_irqsave(&mpu->input_lock, flags); 192 if (mpu->hardware != MPU401_HW_TRID4DWAVE) { 193 mpu->write(mpu, 0x00, MPU401D(mpu)); 194 /*snd_mpu401_uart_clear_rx(mpu);*/ 195 } 196 /* ok. standard MPU-401 initialization */ 197 if (mpu->hardware != MPU401_HW_SB) { 198 for (timeout = 1000; timeout > 0 && !snd_mpu401_output_ready(mpu); timeout--) 199 udelay(10); 200 #ifdef CONFIG_SND_DEBUG 201 if (!timeout) 202 snd_printk("cmd: tx timeout (status = 0x%x)\n", mpu->read(mpu, MPU401C(mpu))); 203 #endif 204 } 205 mpu->write(mpu, cmd, MPU401C(mpu)); 206 if (ack) { 207 ok = 0; 208 timeout = 10000; 209 while (!ok && timeout-- > 0) { 210 if (snd_mpu401_input_avail(mpu)) { 211 if (mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK) 212 ok = 1; 213 } 214 } 215 if (!ok && mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK) 216 ok = 1; 217 } else { 218 ok = 1; 219 } 220 spin_unlock_irqrestore(&mpu->input_lock, flags); 221 if (! ok) 222 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))); 223 // snd_printk("cmd: 0x%x at 0x%lx (status = 0x%x, data = 0x%x)\n", cmd, mpu->port, mpu->read(mpu, MPU401C(mpu)), mpu->read(mpu, MPU401D(mpu))); 224 } 225 226 /* 227 * input/output open/close - protected by open_mutex in rawmidi.c 228 */ 229 static int snd_mpu401_uart_input_open(struct snd_rawmidi_substream *substream) 230 { 231 struct snd_mpu401 *mpu; 232 int err; 233 234 mpu = substream->rmidi->private_data; 235 if (mpu->open_input && (err = mpu->open_input(mpu)) < 0) 236 return err; 237 if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode)) { 238 snd_mpu401_uart_cmd(mpu, MPU401_RESET, 1); 239 snd_mpu401_uart_cmd(mpu, MPU401_ENTER_UART, 1); 240 } 241 mpu->substream_input = substream; 242 set_bit(MPU401_MODE_BIT_INPUT, &mpu->mode); 243 return 0; 244 } 245 246 static int snd_mpu401_uart_output_open(struct snd_rawmidi_substream *substream) 247 { 248 struct snd_mpu401 *mpu; 249 int err; 250 251 mpu = substream->rmidi->private_data; 252 if (mpu->open_output && (err = mpu->open_output(mpu)) < 0) 253 return err; 254 if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) { 255 snd_mpu401_uart_cmd(mpu, MPU401_RESET, 1); 256 snd_mpu401_uart_cmd(mpu, MPU401_ENTER_UART, 1); 257 } 258 mpu->substream_output = substream; 259 set_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode); 260 return 0; 261 } 262 263 static int snd_mpu401_uart_input_close(struct snd_rawmidi_substream *substream) 264 { 265 struct snd_mpu401 *mpu; 266 267 mpu = substream->rmidi->private_data; 268 clear_bit(MPU401_MODE_BIT_INPUT, &mpu->mode); 269 mpu->substream_input = NULL; 270 if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode)) 271 snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0); 272 if (mpu->close_input) 273 mpu->close_input(mpu); 274 return 0; 275 } 276 277 static int snd_mpu401_uart_output_close(struct snd_rawmidi_substream *substream) 278 { 279 struct snd_mpu401 *mpu; 280 281 mpu = substream->rmidi->private_data; 282 clear_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode); 283 mpu->substream_output = NULL; 284 if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) 285 snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0); 286 if (mpu->close_output) 287 mpu->close_output(mpu); 288 return 0; 289 } 290 291 /* 292 * trigger input callback 293 */ 294 static void snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substream, int up) 295 { 296 unsigned long flags; 297 struct snd_mpu401 *mpu; 298 int max = 64; 299 300 mpu = substream->rmidi->private_data; 301 if (up) { 302 if (! test_and_set_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode)) { 303 /* first time - flush FIFO */ 304 while (max-- > 0) 305 mpu->read(mpu, MPU401D(mpu)); 306 if (mpu->irq < 0) 307 snd_mpu401_uart_add_timer(mpu, 1); 308 } 309 310 /* read data in advance */ 311 spin_lock_irqsave(&mpu->input_lock, flags); 312 snd_mpu401_uart_input_read(mpu); 313 spin_unlock_irqrestore(&mpu->input_lock, flags); 314 } else { 315 if (mpu->irq < 0) 316 snd_mpu401_uart_remove_timer(mpu, 1); 317 clear_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode); 318 } 319 } 320 321 /* 322 * transfer input pending data 323 * call with input_lock spinlock held 324 */ 325 static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu) 326 { 327 int max = 128; 328 unsigned char byte; 329 330 while (max-- > 0) { 331 if (snd_mpu401_input_avail(mpu)) { 332 byte = mpu->read(mpu, MPU401D(mpu)); 333 if (test_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode)) 334 snd_rawmidi_receive(mpu->substream_input, &byte, 1); 335 } else { 336 break; /* input not available */ 337 } 338 } 339 } 340 341 /* 342 * Tx FIFO sizes: 343 * CS4237B - 16 bytes 344 * AudioDrive ES1688 - 12 bytes 345 * S3 SonicVibes - 8 bytes 346 * SoundBlaster AWE 64 - 2 bytes (ugly hardware) 347 */ 348 349 /* 350 * write output pending bytes 351 * call with output_lock spinlock held 352 */ 353 static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu) 354 { 355 unsigned char byte; 356 int max = 256, timeout; 357 358 do { 359 if (snd_rawmidi_transmit_peek(mpu->substream_output, &byte, 1) == 1) { 360 for (timeout = 100; timeout > 0; timeout--) { 361 if (snd_mpu401_output_ready(mpu)) { 362 mpu->write(mpu, byte, MPU401D(mpu)); 363 snd_rawmidi_transmit_ack(mpu->substream_output, 1); 364 break; 365 } 366 } 367 if (timeout == 0) 368 break; /* Tx FIFO full - try again later */ 369 } else { 370 snd_mpu401_uart_remove_timer (mpu, 0); 371 break; /* no other data - leave the tx loop */ 372 } 373 } while (--max > 0); 374 } 375 376 /* 377 * output trigger callback 378 */ 379 static void snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substream, int up) 380 { 381 unsigned long flags; 382 struct snd_mpu401 *mpu; 383 384 mpu = substream->rmidi->private_data; 385 if (up) { 386 set_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode); 387 388 /* try to add the timer at each output trigger, 389 * since the output timer might have been removed in 390 * snd_mpu401_uart_output_write(). 391 */ 392 snd_mpu401_uart_add_timer(mpu, 0); 393 394 /* output pending data */ 395 spin_lock_irqsave(&mpu->output_lock, flags); 396 snd_mpu401_uart_output_write(mpu); 397 spin_unlock_irqrestore(&mpu->output_lock, flags); 398 } else { 399 snd_mpu401_uart_remove_timer(mpu, 0); 400 clear_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode); 401 } 402 } 403 404 /* 405 406 */ 407 408 static struct snd_rawmidi_ops snd_mpu401_uart_output = 409 { 410 .open = snd_mpu401_uart_output_open, 411 .close = snd_mpu401_uart_output_close, 412 .trigger = snd_mpu401_uart_output_trigger, 413 }; 414 415 static struct snd_rawmidi_ops snd_mpu401_uart_input = 416 { 417 .open = snd_mpu401_uart_input_open, 418 .close = snd_mpu401_uart_input_close, 419 .trigger = snd_mpu401_uart_input_trigger, 420 }; 421 422 static void snd_mpu401_uart_free(struct snd_rawmidi *rmidi) 423 { 424 struct snd_mpu401 *mpu = rmidi->private_data; 425 if (mpu->irq_flags && mpu->irq >= 0) 426 free_irq(mpu->irq, (void *) mpu); 427 release_and_free_resource(mpu->res); 428 kfree(mpu); 429 } 430 431 /** 432 * snd_mpu401_uart_new - create an MPU401-UART instance 433 * @card: the card instance 434 * @device: the device index, zero-based 435 * @hardware: the hardware type, MPU401_HW_XXXX 436 * @port: the base address of MPU401 port 437 * @integrated: non-zero if the port was already reserved by the chip 438 * @irq: the irq number, -1 if no interrupt for mpu 439 * @irq_flags: the irq request flags (SA_XXX), 0 if irq was already reserved. 440 * @rrawmidi: the pointer to store the new rawmidi instance 441 * 442 * Creates a new MPU-401 instance. 443 * 444 * Note that the rawmidi instance is returned on the rrawmidi argument, 445 * not the mpu401 instance itself. To access to the mpu401 instance, 446 * cast from rawmidi->private_data (with struct snd_mpu401 magic-cast). 447 * 448 * Returns zero if successful, or a negative error code. 449 */ 450 int snd_mpu401_uart_new(struct snd_card *card, int device, 451 unsigned short hardware, 452 unsigned long port, int integrated, 453 int irq, int irq_flags, 454 struct snd_rawmidi ** rrawmidi) 455 { 456 struct snd_mpu401 *mpu; 457 struct snd_rawmidi *rmidi; 458 int err; 459 460 if (rrawmidi) 461 *rrawmidi = NULL; 462 if ((err = snd_rawmidi_new(card, "MPU-401U", device, 1, 1, &rmidi)) < 0) 463 return err; 464 mpu = kzalloc(sizeof(*mpu), GFP_KERNEL); 465 if (mpu == NULL) { 466 snd_printk(KERN_ERR "mpu401_uart: cannot allocate\n"); 467 snd_device_free(card, rmidi); 468 return -ENOMEM; 469 } 470 rmidi->private_data = mpu; 471 rmidi->private_free = snd_mpu401_uart_free; 472 spin_lock_init(&mpu->input_lock); 473 spin_lock_init(&mpu->output_lock); 474 spin_lock_init(&mpu->timer_lock); 475 mpu->hardware = hardware; 476 if (!integrated) { 477 int res_size = hardware == MPU401_HW_PC98II ? 4 : 2; 478 if ((mpu->res = request_region(port, res_size, "MPU401 UART")) == NULL) { 479 snd_printk(KERN_ERR "mpu401_uart: unable to grab port 0x%lx size %d\n", port, res_size); 480 snd_device_free(card, rmidi); 481 return -EBUSY; 482 } 483 } 484 switch (hardware) { 485 case MPU401_HW_AUREAL: 486 mpu->write = mpu401_write_mmio; 487 mpu->read = mpu401_read_mmio; 488 break; 489 default: 490 mpu->write = mpu401_write_port; 491 mpu->read = mpu401_read_port; 492 break; 493 } 494 mpu->port = port; 495 if (hardware == MPU401_HW_PC98II) 496 mpu->cport = port + 2; 497 else 498 mpu->cport = port + 1; 499 if (irq >= 0 && irq_flags) { 500 if (request_irq(irq, snd_mpu401_uart_interrupt, irq_flags, "MPU401 UART", (void *) mpu)) { 501 snd_printk(KERN_ERR "mpu401_uart: unable to grab IRQ %d\n", irq); 502 snd_device_free(card, rmidi); 503 return -EBUSY; 504 } 505 } 506 mpu->irq = irq; 507 mpu->irq_flags = irq_flags; 508 if (card->shortname[0]) 509 snprintf(rmidi->name, sizeof(rmidi->name), "%s MIDI", card->shortname); 510 else 511 sprintf(rmidi->name, "MPU-401 MIDI %d-%d", card->number, device); 512 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_mpu401_uart_output); 513 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_mpu401_uart_input); 514 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | 515 SNDRV_RAWMIDI_INFO_INPUT | 516 SNDRV_RAWMIDI_INFO_DUPLEX; 517 mpu->rmidi = rmidi; 518 if (rrawmidi) 519 *rrawmidi = rmidi; 520 return 0; 521 } 522 523 EXPORT_SYMBOL(snd_mpu401_uart_interrupt); 524 EXPORT_SYMBOL(snd_mpu401_uart_new); 525 526 /* 527 * INIT part 528 */ 529 530 static int __init alsa_mpu401_uart_init(void) 531 { 532 return 0; 533 } 534 535 static void __exit alsa_mpu401_uart_exit(void) 536 { 537 } 538 539 module_init(alsa_mpu401_uart_init) 540 module_exit(alsa_mpu401_uart_exit) 541